circlecloud
/
tmux
mirror of https://github.com/tmux/tmux.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'obsd-master'

pull/593/head
Thomas Adam 2016-10-16 22:01:14 +01:00
parent d401340c51 d15d54c2c8
commit 1a6e696b08
75 changed files with 1120 additions and 1052 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
cfg.c
View File

@ -34,7 +34,7 @@ static u_int cfg_ncauses;
struct client *cfg_client;
static enum cmd_retval
cfg_done(__unused struct cmd_q *cmdq, __unused void *data)
cfg_done(__unused struct cmdq_item *item, __unused void *data)
{
if (cfg_finished)
return (CMD_RETURN_NORMAL);
@ -78,15 +78,15 @@ start_cfg(void)
}
int
load_cfg(const char *path, struct client *c, struct cmd_q *cmdq, int quiet)
load_cfg(const char *path, struct client *c, struct cmdq_item *item, int quiet)
{
FILE *f;
char delim[3] = { '\\', '\\', '\0' };
u_int found;
size_t line = 0;
char *buf, *cause1, *p;
struct cmd_list *cmdlist;
struct cmd_q *new_cmdq;
FILE *f;
char delim[3] = { '\\', '\\', '\0' };
u_int found;
size_t line = 0;
char *buf, *cause1, *p;
struct cmd_list *cmdlist;
struct cmdq_item *new_item;
log_debug("loading %s", path);
if ((f = fopen(path, "rb")) == NULL) {
@ -122,11 +122,11 @@ load_cfg(const char *path, struct client *c, struct cmd_q *cmdq, int quiet)
if (cmdlist == NULL)
continue;
new_cmdq = cmdq_get_command(cmdlist, NULL, NULL, 0);
if (cmdq != NULL)
cmdq_insert_after(cmdq, new_cmdq);
new_item = cmdq_get_command(cmdlist, NULL, NULL, 0);
if (item != NULL)
cmdq_insert_after(item, new_item);
else
cmdq_append(c, new_cmdq);
cmdq_append(c, new_item);
cmd_list_free(cmdlist);
found++;
@ -152,12 +152,12 @@ cfg_add_cause(const char *fmt, ...)
}
void
cfg_print_causes(struct cmd_q *cmdq)
cfg_print_causes(struct cmdq_item *item)
{
u_int i;
for (i = 0; i < cfg_ncauses; i++) {
cmdq_print(cmdq, "%s", cfg_causes[i]);
cmdq_print(item, "%s", cfg_causes[i]);
free(cfg_causes[i]);
}

27
cmd-attach-session.c
View File

@ -30,7 +30,8 @@
* Attach existing session to the current terminal.
*/
static enum cmd_retval cmd_attach_session_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_attach_session_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_attach_session_entry = {
.name = "attach-session",
@ -46,26 +47,26 @@ const struct cmd_entry cmd_attach_session_entry = {
};
enum cmd_retval
cmd_attach_session(struct cmd_q *cmdq, int dflag, int rflag, const char *cflag,
int Eflag)
cmd_attach_session(struct cmdq_item *item, int dflag, int rflag,
const char *cflag, int Eflag)
{
struct session *s = cmdq->state.tflag.s;
struct client *c = cmdq->client, *c_loop;
struct winlink *wl = cmdq->state.tflag.wl;
struct window_pane *wp = cmdq->state.tflag.wp;
struct session *s = item->state.tflag.s;
struct client *c = item->client, *c_loop;
struct winlink *wl = item->state.tflag.wl;
struct window_pane *wp = item->state.tflag.wp;
const char *update;
char *cause, *cwd;
struct format_tree *ft;
if (RB_EMPTY(&sessions)) {
cmdq_error(cmdq, "no sessions");
cmdq_error(item, "no sessions");
return (CMD_RETURN_ERROR);
}
if (c == NULL)
return (CMD_RETURN_NORMAL);
if (server_client_check_nested(c)) {
cmdq_error(cmdq, "sessions should be nested with care, "
cmdq_error(item, "sessions should be nested with care, "
"unset $TMUX to force");
return (CMD_RETURN_ERROR);
}
@ -77,7 +78,7 @@ cmd_attach_session(struct cmd_q *cmdq, int dflag, int rflag, const char *cflag,
}
if (cflag != NULL) {
ft = format_create(cmdq, 0);
ft = format_create(item, 0);
format_defaults(ft, c, s, wl, wp);
cwd = format_expand(ft, cflag);
format_free(ft);
@ -111,7 +112,7 @@ cmd_attach_session(struct cmd_q *cmdq, int dflag, int rflag, const char *cflag,
s->curw->flags &= ~WINLINK_ALERTFLAGS;
} else {
if (server_client_open(c, &cause) != 0) {
cmdq_error(cmdq, "open terminal failed: %s", cause);
cmdq_error(item, "open terminal failed: %s", cause);
free(cause);
return (CMD_RETURN_ERROR);
}
@ -155,10 +156,10 @@ cmd_attach_session(struct cmd_q *cmdq, int dflag, int rflag, const char *cflag,
}
static enum cmd_retval
cmd_attach_session_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_attach_session_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
return (cmd_attach_session(cmdq, args_has(args, 'd'),
return (cmd_attach_session(item, args_has(args, 'd'),
args_has(args, 'r'), args_get(args, 'c'), args_has(args, 'E')));
}

26
cmd-bind-key.c
View File

@ -27,10 +27,10 @@
* Bind a key to a command, this recurses through cmd_*.
*/
static enum cmd_retval cmd_bind_key_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_bind_key_exec(struct cmd *, struct cmdq_item *);
static enum cmd_retval cmd_bind_key_mode_table(struct cmd *, struct cmd_q *,
key_code);
static enum cmd_retval cmd_bind_key_mode_table(struct cmd *,
struct cmdq_item *, key_code);
const struct cmd_entry cmd_bind_key_entry = {
.name = "bind-key",
@ -45,7 +45,7 @@ const struct cmd_entry cmd_bind_key_entry = {
};
static enum cmd_retval
cmd_bind_key_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_bind_key_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
char *cause;
@ -55,24 +55,24 @@ cmd_bind_key_exec(struct cmd *self, struct cmd_q *cmdq)
if (args_has(args, 't')) {
if (args->argc != 2 && args->argc != 3) {
cmdq_error(cmdq, "not enough arguments");
cmdq_error(item, "not enough arguments");
return (CMD_RETURN_ERROR);
}
} else {
if (args->argc < 2) {
cmdq_error(cmdq, "not enough arguments");
cmdq_error(item, "not enough arguments");
return (CMD_RETURN_ERROR);
}
}
key = key_string_lookup_string(args->argv[0]);
if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
cmdq_error(cmdq, "unknown key: %s", args->argv[0]);
cmdq_error(item, "unknown key: %s", args->argv[0]);
return (CMD_RETURN_ERROR);
}
if (args_has(args, 't'))
return (cmd_bind_key_mode_table(self, cmdq, key));
return (cmd_bind_key_mode_table(self, item, key));
if (args_has(args, 'T'))
tablename = args_get(args, 'T');
@ -84,7 +84,7 @@ cmd_bind_key_exec(struct cmd *self, struct cmd_q *cmdq)
cmdlist = cmd_list_parse(args->argc - 1, args->argv + 1, NULL, 0,
&cause);
if (cmdlist == NULL) {
cmdq_error(cmdq, "%s", cause);
cmdq_error(item, "%s", cause);
free(cause);
return (CMD_RETURN_ERROR);
}
@ -94,7 +94,7 @@ cmd_bind_key_exec(struct cmd *self, struct cmd_q *cmdq)
}
static enum cmd_retval
cmd_bind_key_mode_table(struct cmd *self, struct cmd_q *cmdq, key_code key)
cmd_bind_key_mode_table(struct cmd *self, struct cmdq_item *item, key_code key)
{
struct args *args = self->args;
const char *tablename;
@ -104,18 +104,18 @@ cmd_bind_key_mode_table(struct cmd *self, struct cmd_q *cmdq, key_code key)
tablename = args_get(args, 't');
if ((mtab = mode_key_findtable(tablename)) == NULL) {
cmdq_error(cmdq, "unknown key table: %s", tablename);
cmdq_error(item, "unknown key table: %s", tablename);
return (CMD_RETURN_ERROR);
}
cmd = mode_key_fromstring(mtab->cmdstr, args->argv[1]);
if (cmd == MODEKEY_NONE) {
cmdq_error(cmdq, "unknown command: %s", args->argv[1]);
cmdq_error(item, "unknown command: %s", args->argv[1]);
return (CMD_RETURN_ERROR);
}
if (args->argc != 2) {
cmdq_error(cmdq, "no argument allowed");
cmdq_error(item, "no argument allowed");
return (CMD_RETURN_ERROR);
}

24
cmd-break-pane.c
View File

@ -28,7 +28,7 @@
#define BREAK_PANE_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"
static enum cmd_retval cmd_break_pane_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_break_pane_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_break_pane_entry = {
.name = "break-pane",
@ -45,28 +45,28 @@ const struct cmd_entry cmd_break_pane_entry = {
};
static enum cmd_retval
cmd_break_pane_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_break_pane_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct winlink *wl = cmdq->state.sflag.wl;
struct session *src_s = cmdq->state.sflag.s;
struct session *dst_s = cmdq->state.tflag.s;
struct window_pane *wp = cmdq->state.sflag.wp;
struct winlink *wl = item->state.sflag.wl;
struct session *src_s = item->state.sflag.s;
struct session *dst_s = item->state.tflag.s;
struct window_pane *wp = item->state.sflag.wp;
struct window *w = wl->window;
char *name;
char *cause;
int idx = cmdq->state.tflag.idx;
int idx = item->state.tflag.idx;
struct format_tree *ft;
const char *template;
char *cp;
if (idx != -1 && winlink_find_by_index(&dst_s->windows, idx) != NULL) {
cmdq_error(cmdq, "index %d already in use", idx);
cmdq_error(item, "index %d already in use", idx);
return (CMD_RETURN_ERROR);
}
if (window_count_panes(w) == 1) {
cmdq_error(cmdq, "can't break with only one pane");
cmdq_error(item, "can't break with only one pane");
return (CMD_RETURN_ERROR);
}
server_unzoom_window(w);
@ -101,11 +101,11 @@ cmd_break_pane_exec(struct cmd *self, struct cmd_q *cmdq)
if ((template = args_get(args, 'F')) == NULL)
template = BREAK_PANE_TEMPLATE;
ft = format_create(cmdq, 0);
format_defaults(ft, cmdq->state.c, dst_s, wl, wp);
ft = format_create(item, 0);
format_defaults(ft, item->state.c, dst_s, wl, wp);
cp = format_expand(ft, template);
cmdq_print(cmdq, "%s", cp);
cmdq_print(item, "%s", cp);
free(cp);
format_free(ft);

30
cmd-capture-pane.c
View File

@ -27,14 +27,13 @@
* Write the entire contents of a pane to a buffer or stdout.
*/
static enum cmd_retval cmd_capture_pane_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_capture_pane_exec(struct cmd *, struct cmdq_item *);
static char *cmd_capture_pane_append(char *, size_t *, char *,
size_t);
static char *cmd_capture_pane_pending(struct args *,
struct window_pane *, size_t *);
static char *cmd_capture_pane_history(struct args *, struct cmd_q *,
struct window_pane *, size_t *);
static char *cmd_capture_pane_append(char *, size_t *, char *, size_t);
static char *cmd_capture_pane_pending(struct args *, struct window_pane *,
size_t *);
static char *cmd_capture_pane_history(struct args *, struct cmdq_item *,
struct window_pane *, size_t *);
const struct cmd_entry cmd_capture_pane_entry = {
.name = "capture-pane",
@ -92,7 +91,8 @@ cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
}
static char *
cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
struct window_pane *wp, size_t *len)
{
struct grid *gd;
@ -109,7 +109,7 @@ cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
gd = wp->saved_grid;
if (gd == NULL) {
if (!args_has(args, 'q')) {
cmdq_error(cmdq, "no alternate screen");
cmdq_error(item, "no alternate screen");
return (NULL);
}
return (xstrdup(""));
@ -177,11 +177,11 @@ cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
}
static enum cmd_retval
cmd_capture_pane_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_capture_pane_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c;
struct window_pane *wp = cmdq->state.tflag.wp;
struct window_pane *wp = item->state.tflag.wp;
char *buf, *cause;
const char *bufname;
size_t len;
@ -190,15 +190,15 @@ cmd_capture_pane_exec(struct cmd *self, struct cmd_q *cmdq)
if (args_has(args, 'P'))
buf = cmd_capture_pane_pending(args, wp, &len);
else
buf = cmd_capture_pane_history(args, cmdq, wp, &len);
buf = cmd_capture_pane_history(args, item, wp, &len);
if (buf == NULL)
return (CMD_RETURN_ERROR);
if (args_has(args, 'p')) {
c = cmdq->client;
c = item->client;
if (c == NULL ||
(c->session != NULL && !(c->flags & CLIENT_CONTROL))) {
cmdq_error(cmdq, "can't write to stdout");
cmdq_error(item, "can't write to stdout");
free(buf);
return (CMD_RETURN_ERROR);
}
@ -213,7 +213,7 @@ cmd_capture_pane_exec(struct cmd *self, struct cmd_q *cmdq)
bufname = args_get(args, 'b');
if (paste_set(buf, len, bufname, &cause) != 0) {
cmdq_error(cmdq, "%s", cause);
cmdq_error(item, "%s", cause);
free(cause);
free(buf);
return (CMD_RETURN_ERROR);

11
cmd-choose-buffer.c
View File

@ -30,7 +30,8 @@
#define CHOOSE_BUFFER_TEMPLATE \
"#{buffer_name}: #{buffer_size} bytes: #{buffer_sample}"
static enum cmd_retval cmd_choose_buffer_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_choose_buffer_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_choose_buffer_entry = {
.name = "choose-buffer",
@ -46,11 +47,11 @@ const struct cmd_entry cmd_choose_buffer_entry = {
};
static enum cmd_retval
cmd_choose_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_choose_buffer_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c = cmdq->state.c;
struct winlink *wl = cmdq->state.tflag.wl;
struct client *c = item->state.c;
struct winlink *wl = item->state.tflag.wl;
struct window_choose_data *cdata;
struct paste_buffer *pb;
char *action, *action_data;
@ -58,7 +59,7 @@ cmd_choose_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
u_int idx;
if (c == NULL) {
cmdq_error(cmdq, "no client available");
cmdq_error(item, "no client available");
return (CMD_RETURN_ERROR);
}

13
cmd-choose-client.c
View File

@ -33,7 +33,8 @@
"#{?client_utf8, (utf8),}#{?client_readonly, (ro),} " \
"(last used #{t:client_activity})"
static enum cmd_retval cmd_choose_client_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_choose_client_exec(struct cmd *,
struct cmdq_item *);
static void cmd_choose_client_callback(struct window_choose_data *);
@ -55,19 +56,19 @@ struct cmd_choose_client_data {
};
static enum cmd_retval
cmd_choose_client_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_choose_client_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c = cmdq->state.c;
struct client *c = item->state.c;
struct client *c1;
struct window_choose_data *cdata;
struct winlink *wl = cmdq->state.tflag.wl;
struct winlink *wl = item->state.tflag.wl;
const char *template;
char *action;
u_int idx, cur;
if (c == NULL) {
cmdq_error(cmdq, "no client available");
cmdq_error(item, "no client available");
return (CMD_RETURN_ERROR);
}
@ -86,7 +87,7 @@ cmd_choose_client_exec(struct cmd *self, struct cmd_q *cmdq)
TAILQ_FOREACH(c1, &clients, entry) {
if (c1->session == NULL || c1->tty.path == NULL)
continue;
if (c1 == cmdq->client)
if (c1 == item->client)
cur = idx;
cdata = window_choose_data_create(TREE_OTHER, c, c->session);

12
cmd-choose-tree.c
View File

@ -41,7 +41,7 @@
"#{window_index}: #{window_name}#{window_flags} " \
"\"#{pane_title}\""
static enum cmd_retval cmd_choose_tree_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_choose_tree_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_choose_tree_entry = {
.name = "choose-tree",
@ -84,12 +84,12 @@ const struct cmd_entry cmd_choose_window_entry = {
};
static enum cmd_retval
cmd_choose_tree_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_choose_tree_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c = cmdq->state.c;
struct winlink *wl = cmdq->state.tflag.wl, *wm;
struct session *s = cmdq->state.tflag.s, *s2;
struct client *c = item->state.c;
struct winlink *wl = item->state.tflag.wl, *wm;
struct session *s = item->state.tflag.s, *s2;
struct window_choose_data *wcd = NULL;
const char *ses_template, *win_template;
char *final_win_action, *cur_win_template;
@ -103,7 +103,7 @@ cmd_choose_tree_exec(struct cmd *self, struct cmd_q *cmdq)
ses_action = win_action = NULL;
if (c == NULL) {
cmdq_error(cmdq, "no client available");
cmdq_error(item, "no client available");
return (CMD_RETURN_ERROR);
}

9
cmd-clear-history.c
View File

@ -24,7 +24,8 @@
* Clear pane history.
*/
static enum cmd_retval cmd_clear_history_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_clear_history_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_clear_history_entry = {
.name = "clear-history",
@ -40,12 +41,12 @@ const struct cmd_entry cmd_clear_history_entry = {
};
static enum cmd_retval
cmd_clear_history_exec(__unused struct cmd *self, struct cmd_q *cmdq)
cmd_clear_history_exec(__unused struct cmd *self, struct cmdq_item *item)
{
struct window_pane *wp = cmdq->state.tflag.wp;
struct window_pane *wp = item->state.tflag.wp;
struct grid *gd;
gd = cmdq->state.tflag.wp->base.grid;
gd = item->state.tflag.wp->base.grid;
if (wp->mode == &window_copy_mode)
window_pane_reset_mode(wp);

23
cmd-command-prompt.c
View File

@ -29,7 +29,8 @@
* Prompt for command in client.
*/
static enum cmd_retval cmd_command_prompt_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_command_prompt_exec(struct cmd *,
struct cmdq_item *);
static int cmd_command_prompt_callback(void *, const char *);
static void cmd_command_prompt_free(void *);
@ -59,12 +60,12 @@ struct cmd_command_prompt_cdata {
};
static enum cmd_retval
cmd_command_prompt_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_command_prompt_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
const char *inputs, *prompts;
struct cmd_command_prompt_cdata *cdata;
struct client *c = cmdq->state.c;
struct client *c = item->state.c;
char *prompt, *ptr, *input = NULL;
size_t n;
int flags;
@ -122,11 +123,11 @@ cmd_command_prompt_exec(struct cmd *self, struct cmd_q *cmdq)
}
static enum cmd_retval
cmd_command_prompt_error(struct cmd_q *cmdq, void *data)
cmd_command_prompt_error(struct cmdq_item *item, void *data)
{
char *error = data;
cmdq_error(cmdq, "%s", error);
cmdq_error(item, "%s", error);
free(error);
return (CMD_RETURN_NORMAL);
@ -138,7 +139,7 @@ cmd_command_prompt_callback(void *data, const char *s)
struct cmd_command_prompt_cdata *cdata = data;
struct client *c = cdata->c;
struct cmd_list *cmdlist;
struct cmd_q *new_cmdq;
struct cmdq_item *new_item;
char *cause, *new_template, *prompt, *ptr;
char *input = NULL;
@ -165,17 +166,17 @@ cmd_command_prompt_callback(void *data, const char *s)
if (cmd_string_parse(new_template, &cmdlist, NULL, 0, &cause) != 0) {
if (cause != NULL) {
new_cmdq = cmdq_get_callback(cmd_command_prompt_error,
new_item = cmdq_get_callback(cmd_command_prompt_error,
cause);
} else
new_cmdq = NULL;
new_item = NULL;
} else {
new_cmdq = cmdq_get_command(cmdlist, NULL, NULL, 0);
new_item = cmdq_get_command(cmdlist, NULL, NULL, 0);
cmd_list_free(cmdlist);
}
if (new_cmdq != NULL)
cmdq_append(c, new_cmdq);
if (new_item != NULL)
cmdq_append(c, new_item);
if (c->prompt_callbackfn != (void *)&cmd_command_prompt_callback)
return (1);

27
cmd-confirm-before.c
View File

@ -28,10 +28,11 @@
* Asks for confirmation before executing a command.
*/
static enum cmd_retval cmd_confirm_before_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_confirm_before_exec(struct cmd *,
struct cmdq_item *);
static int cmd_confirm_before_callback(void *, const char *);
static void cmd_confirm_before_free(void *);
static int cmd_confirm_before_callback(void *, const char *);
static void cmd_confirm_before_free(void *);
const struct cmd_entry cmd_confirm_before_entry = {
.name = "confirm-before",
@ -52,11 +53,11 @@ struct cmd_confirm_before_data {
};
static enum cmd_retval
cmd_confirm_before_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_confirm_before_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct cmd_confirm_before_data *cdata;
struct client *c = cmdq->state.c;
struct client *c = item->state.c;
char *cmd, *copy, *new_prompt, *ptr;
const char *prompt;
@ -84,11 +85,11 @@ cmd_confirm_before_exec(struct cmd *self, struct cmd_q *cmdq)
}
static enum cmd_retval
cmd_confirm_before_error(struct cmd_q *cmdq, void *data)
cmd_confirm_before_error(struct cmdq_item *item, void *data)
{
char *error = data;
cmdq_error(cmdq, "%s", error);
cmdq_error(item, "%s", error);
free(error);
return (CMD_RETURN_NORMAL);
@ -100,7 +101,7 @@ cmd_confirm_before_callback(void *data, const char *s)
struct cmd_confirm_before_data *cdata = data;
struct client *c = cdata->client;
struct cmd_list *cmdlist;
struct cmd_q *new_cmdq;
struct cmdq_item *new_item;
char *cause;
if (c->flags & CLIENT_DEAD)
@ -113,17 +114,17 @@ cmd_confirm_before_callback(void *data, const char *s)
if (cmd_string_parse(cdata->cmd, &cmdlist, NULL, 0, &cause) != 0) {
if (cause != NULL) {
new_cmdq = cmdq_get_callback(cmd_confirm_before_error,
new_item = cmdq_get_callback(cmd_confirm_before_error,
cause);
} else
new_cmdq = NULL;
new_item = NULL;
} else {
new_cmdq = cmdq_get_command(cmdlist, NULL, NULL, 0);
new_item = cmdq_get_command(cmdlist, NULL, NULL, 0);
cmd_list_free(cmdlist);
}
if (new_cmdq != NULL)
cmdq_append(c, new_cmdq);
if (new_item != NULL)
cmdq_append(c, new_item);
return (0);
}

12
cmd-copy-mode.c
View File

@ -24,7 +24,7 @@
* Enter copy or clock mode.
*/
static enum cmd_retval cmd_copy_mode_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_copy_mode_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_copy_mode_entry = {
.name = "copy-mode",
@ -53,15 +53,15 @@ const struct cmd_entry cmd_clock_mode_entry = {
};
static enum cmd_retval
cmd_copy_mode_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_copy_mode_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c = cmdq->client;
struct client *c = item->client;
struct session *s;
struct window_pane *wp = cmdq->state.tflag.wp;
struct window_pane *wp = item->state.tflag.wp;
if (args_has(args, 'M')) {
if ((wp = cmd_mouse_pane(&cmdq->mouse, &s, NULL)) == NULL)
if ((wp = cmd_mouse_pane(&item->mouse, &s, NULL)) == NULL)
return (CMD_RETURN_NORMAL);
if (c == NULL || c->session != s)
return (CMD_RETURN_NORMAL);
@ -80,7 +80,7 @@ cmd_copy_mode_exec(struct cmd *self, struct cmd_q *cmdq)
if (args_has(args, 'M')) {
if (wp->mode != NULL && wp->mode != &window_copy_mode)
return (CMD_RETURN_NORMAL);
window_copy_start_drag(c, &cmdq->mouse);
window_copy_start_drag(c, &item->mouse);
}
if (wp->mode == &window_copy_mode && args_has(self->args, 'u'))
window_copy_pageup(wp, 0);

9
cmd-detach-client.c
View File

@ -26,7 +26,8 @@
* Detach a client.
*/
static enum cmd_retval cmd_detach_client_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_detach_client_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_detach_client_entry = {
.name = "detach-client",
@ -56,10 +57,10 @@ const struct cmd_entry cmd_suspend_client_entry = {
};
static enum cmd_retval
cmd_detach_client_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_detach_client_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c = cmdq->state.c, *cloop;
struct client *c = item->state.c, *cloop;
struct session *s;
enum msgtype msgtype;
@ -76,7 +77,7 @@ cmd_detach_client_exec(struct cmd *self, struct cmd_q *cmdq)
msgtype = MSG_DETACH;
if (args_has(args, 's')) {
s = cmdq->state.sflag.s;
s = item->state.sflag.s;
TAILQ_FOREACH(cloop, &clients, entry) {
if (cloop->session == s)
server_client_detach(cloop, msgtype);

19
cmd-display-message.c
View File

@ -32,7 +32,8 @@
"#{window_name}, current pane #{pane_index} " \
"- (%H:%M %d-%b-%y)"
static enum cmd_retval cmd_display_message_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_display_message_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_display_message_entry = {
.name = "display-message",
@ -50,19 +51,19 @@ const struct cmd_entry cmd_display_message_entry = {
};
static enum cmd_retval
cmd_display_message_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c = cmdq->state.c;
struct session *s = cmdq->state.tflag.s;
struct winlink *wl = cmdq->state.tflag.wl;
struct window_pane *wp = cmdq->state.tflag.wp;
struct client *c = item->state.c;
struct session *s = item->state.tflag.s;
struct winlink *wl = item->state.tflag.wl;
struct window_pane *wp = item->state.tflag.wp;
const char *template;
char *msg;
struct format_tree *ft;
if (args_has(args, 'F') && args->argc != 0) {
cmdq_error(cmdq, "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);
}
@ -72,12 +73,12 @@ cmd_display_message_exec(struct cmd *self, struct cmd_q *cmdq)
if (template == NULL)
template = DISPLAY_MESSAGE_TEMPLATE;
ft = format_create(cmdq, 0);
ft = format_create(item, 0);
format_defaults(ft, c, s, wl, wp);
msg = format_expand_time(ft, template, time(NULL));
if (args_has(self->args, 'p'))
cmdq_print(cmdq, "%s", msg);
cmdq_print(item, "%s", msg);
else if (c != NULL)
status_message_set(c, "%s", msg);
free(msg);

31
cmd-display-panes.c
View File

@ -27,10 +27,11 @@
* Display panes on a client.
*/
static enum cmd_retval cmd_display_panes_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_display_panes_exec(struct cmd *,
struct cmdq_item *);
static void cmd_display_panes_callback(struct client *,
struct window_pane *);
static void cmd_display_panes_callback(struct client *,
struct window_pane *);
const struct cmd_entry cmd_display_panes_entry = {
.name = "display-panes",
@ -46,10 +47,10 @@ const struct cmd_entry cmd_display_panes_entry = {
};
static enum cmd_retval
cmd_display_panes_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_display_panes_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c = cmdq->state.c;
struct client *c = item->state.c;
if (c->identify_callback != NULL)
return (CMD_RETURN_NORMAL);
@ -66,11 +67,11 @@ cmd_display_panes_exec(struct cmd *self, struct cmd_q *cmdq)
}
static enum cmd_retval
cmd_display_panes_error(struct cmd_q *cmdq, void *data)
cmd_display_panes_error(struct cmdq_item *item, void *data)
{
char *error = data;
cmdq_error(cmdq, "%s", error);
cmdq_error(item, "%s", error);
free(error);
return (CMD_RETURN_NORMAL);
@ -79,9 +80,9 @@ cmd_display_panes_error(struct cmd_q *cmdq, void *data)
static void
cmd_display_panes_callback(struct client *c, struct window_pane *wp)
{
struct cmd_list *cmdlist;
struct cmd_q *new_cmdq;
char *template, *cmd, *expanded, *cause;
struct cmd_list *cmdlist;
struct cmdq_item *new_item;
char *template, *cmd, *expanded, *cause;
template = c->identify_callback_data;
if (wp == NULL)
@ -91,17 +92,17 @@ cmd_display_panes_callback(struct client *c, struct window_pane *wp)
if (cmd_string_parse(cmd, &cmdlist, NULL, 0, &cause) != 0) {
if (cause != NULL) {
new_cmdq = cmdq_get_callback(cmd_display_panes_error,
new_item = cmdq_get_callback(cmd_display_panes_error,
cause);
} else
new_cmdq = NULL;
new_item = NULL;
} else {
new_cmdq = cmdq_get_command(cmdlist, NULL, NULL, 0);
new_item = cmdq_get_command(cmdlist, NULL, NULL, 0);
cmd_list_free(cmdlist);
}
if (new_cmdq != NULL)
cmdq_append(c, new_cmdq);
if (new_item != NULL)
cmdq_append(c, new_item);
free(cmd);
free(expanded);

16
cmd-find-window.c
View File

@ -33,9 +33,9 @@
"[#{window_width}x#{window_height}] " \
"(#{window_panes} panes) #{window_find_matches}"
static enum cmd_retval cmd_find_window_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_find_window_exec(struct cmd *, struct cmdq_item *);
static void cmd_find_window_callback(struct window_choose_data *);
static void cmd_find_window_callback(struct window_choose_data *);
/* Flags for determining matching behavior. */
#define CMD_FIND_WINDOW_BY_TITLE 0x1
@ -139,13 +139,13 @@ cmd_find_window_match(struct cmd_find_window_list *find_list,
}
static enum cmd_retval
cmd_find_window_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_find_window_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c = cmdq->state.c;
struct client *c = item->state.c;
struct window_choose_data *cdata;
struct session *s = cmdq->state.tflag.s;
struct winlink *wl = cmdq->state.tflag.wl, *wm;
struct session *s = item->state.tflag.s;
struct winlink *wl = item->state.tflag.wl, *wm;
struct cmd_find_window_list find_list;
struct cmd_find_window_data *find_data;
struct cmd_find_window_data *find_data1;
@ -154,7 +154,7 @@ cmd_find_window_exec(struct cmd *self, struct cmd_q *cmdq)
u_int i, match_flags;
if (c == NULL) {
cmdq_error(cmdq, "no client available");
cmdq_error(item, "no client available");
return (CMD_RETURN_ERROR);
}
@ -172,7 +172,7 @@ cmd_find_window_exec(struct cmd *self, struct cmd_q *cmdq)
free(searchstr);
if (TAILQ_EMPTY(&find_list)) {
cmdq_error(cmdq, "no windows matching: %s", str);
cmdq_error(item, "no windows matching: %s", str);
return (CMD_RETURN_ERROR);
}

82
cmd-find.c
View File

@ -37,7 +37,7 @@ static int cmd_find_best_winlink_with_window(struct cmd_find_state *);
static int cmd_find_current_session_with_client(struct cmd_find_state *);
static int cmd_find_current_session(struct cmd_find_state *);
static struct client *cmd_find_current_client(struct cmd_q *);
static struct client *cmd_find_current_client(struct cmdq_item *);
static const char *cmd_find_map_table(const char *[][2], const char *);
@ -191,8 +191,8 @@ cmd_find_best_session_with_window(struct cmd_find_state *fs)
u_int ssize;
struct session *s;
if (fs->cmdq != NULL && fs->cmdq->client != NULL) {
fs->s = cmd_find_try_TMUX(fs->cmdq->client, fs->w);
if (fs->item != NULL && fs->item->client != NULL) {
fs->s = cmd_find_try_TMUX(fs->item->client, fs->w);
if (fs->s != NULL)
return (cmd_find_best_winlink_with_window(fs));
}
@ -255,9 +255,9 @@ cmd_find_current_session_with_client(struct cmd_find_state *fs)
* sessions to those containing that pane (we still use the current
* window in the best session).
*/
if (fs->cmdq != NULL && fs->cmdq->client->tty.path != NULL) {
if (fs->item != NULL && fs->item->client->tty.path != NULL) {
RB_FOREACH(wp, window_pane_tree, &all_window_panes) {
if (strcmp(wp->tty, fs->cmdq->client->tty.path) == 0)
if (strcmp(wp->tty, fs->item->client->tty.path) == 0)
break;
}
} else
@ -291,8 +291,8 @@ cmd_find_current_session_with_client(struct cmd_find_state *fs)
unknown_pane:
fs->s = NULL;
if (fs->cmdq != NULL)
fs->s = cmd_find_try_TMUX(fs->cmdq->client, NULL);
if (fs->item != NULL)
fs->s = cmd_find_try_TMUX(fs->item->client, NULL);
if (fs->s == NULL)
fs->s = cmd_find_best_session(NULL, 0, fs->flags);
if (fs->s == NULL)
@ -313,12 +313,12 @@ static int
cmd_find_current_session(struct cmd_find_state *fs)
{
/* If we know the current client, use it. */
if (fs->cmdq != NULL && fs->cmdq->client != NULL) {
log_debug("%s: have client %p%s", __func__, fs->cmdq->client,
fs->cmdq->client->session == NULL ? "" : " (with session)");
if (fs->cmdq->client->session == NULL)
if (fs->item != NULL && fs->item->client != NULL) {
log_debug("%s: have client %p%s", __func__, fs->item->client,
fs->item->client->session == NULL ? "" : " (with session)");
if (fs->item->client->session == NULL)
return (cmd_find_current_session_with_client(fs));
fs->s = fs->cmdq->client->session;
fs->s = fs->item->client->session;
fs->wl = fs->s->curw;
fs->idx = fs->wl->idx;
fs->w = fs->wl->window;
@ -340,7 +340,7 @@ cmd_find_current_session(struct cmd_find_state *fs)
/* Work out the best current client. */
static struct client *
cmd_find_current_client(struct cmd_q *cmdq)
cmd_find_current_client(struct cmdq_item *item)
{
struct cmd_find_state current;
struct session *s;
@ -348,14 +348,14 @@ cmd_find_current_client(struct cmd_q *cmdq)
u_int csize;
/* If the queue client has a session, use it. */
if (cmdq->client != NULL && cmdq->client->session != NULL) {
log_debug("%s: using cmdq %p client %p", __func__, cmdq,
cmdq->client);
return (cmdq->client);
if (item->client != NULL && item->client->session != NULL) {
log_debug("%s: using item %p client %p", __func__, item,
item->client);
return (item->client);
}
/* Otherwise find the current session. */
cmd_find_clear_state(&current, cmdq, 0);
cmd_find_clear_state(&current, item, 0);
if (cmd_find_current_session(&current) != 0)
return (NULL);
@ -792,11 +792,12 @@ cmd_find_get_pane_with_window(struct cmd_find_state *fs, const char *pane)
/* Clear state. */
void
cmd_find_clear_state(struct cmd_find_state *fs, struct cmd_q *cmdq, int flags)
cmd_find_clear_state(struct cmd_find_state *fs, struct cmdq_item *item,
int flags)
{
memset(fs, 0, sizeof *fs);
fs->cmdq = cmdq;
fs->item = item;
fs->flags = flags;
fs->idx = -1;
@ -951,12 +952,12 @@ cmd_find_from_pane(struct cmd_find_state *fs, struct window_pane *wp)
/* Find current state. */
int
cmd_find_current(struct cmd_find_state *fs, struct cmd_q *cmdq, int flags)
cmd_find_current(struct cmd_find_state *fs, struct cmdq_item *item, int flags)
{
cmd_find_clear_state(fs, cmdq, flags);
cmd_find_clear_state(fs, item, flags);
if (cmd_find_current_session(fs) != 0) {
if (~flags & CMD_FIND_QUIET)
cmdq_error(cmdq, "no current session");
cmdq_error(item, "no current session");
return (-1);
}
return (0);
@ -968,7 +969,8 @@ cmd_find_current(struct cmd_find_state *fs, struct cmd_q *cmdq, int flags)
*/
int
cmd_find_target(struct cmd_find_state *fs, struct cmd_find_state *current,
struct cmd_q *cmdq, const char *target, enum cmd_find_type type, int flags)
struct cmdq_item *item, const char *target, enum cmd_find_type type,
int flags)
{
struct mouse_event *m;
char *colon, *period, *copy = NULL;
@ -979,17 +981,17 @@ cmd_find_target(struct cmd_find_state *fs, struct cmd_find_state *current,
log_debug("%s: target none, type %d", __func__, type);
else
log_debug("%s: target %s, type %d", __func__, target, type);
log_debug("%s: cmdq %p, flags %#x", __func__, cmdq, flags);
log_debug("%s: item %p, flags %#x", __func__, item, flags);
/* Clear new state. */
cmd_find_clear_state(fs, cmdq, flags);
cmd_find_clear_state(fs, item, flags);
/* Find current state. */
if (server_check_marked() && (flags & CMD_FIND_DEFAULT_MARKED)) {
fs->current = &marked_pane;
log_debug(" current is marked pane");
} else if (cmd_find_valid_state(&cmdq->current)) {
fs->current = &cmdq->current;
} else if (cmd_find_valid_state(&item->current)) {
fs->current = &item->current;
log_debug(" current is from queue");
} else {
fs->current = current;
@ -1005,7 +1007,7 @@ cmd_find_target(struct cmd_find_state *fs, struct cmd_find_state *current,
/* Mouse target is a plain = or {mouse}. */
if (strcmp(target, "=") == 0 || strcmp(target, "{mouse}") == 0) {
m = &cmdq->mouse;
m = &item->mouse;
switch (type) {
case CMD_FIND_PANE:
fs->wp = cmd_mouse_pane(m, &fs->s, &fs->wl);
@ -1023,7 +1025,7 @@ cmd_find_target(struct cmd_find_state *fs, struct cmd_find_state *current,
}
if (fs->wp == NULL) {
if (~flags & CMD_FIND_QUIET)
cmdq_error(cmdq, "no mouse target");
cmdq_error(item, "no mouse target");
goto error;
}
goto found;
@ -1033,7 +1035,7 @@ cmd_find_target(struct cmd_find_state *fs, struct cmd_find_state *current,
if (strcmp(target, "~") == 0 || strcmp(target, "{marked}") == 0) {
if (!server_check_marked()) {
if (~flags & CMD_FIND_QUIET)
cmdq_error(cmdq, "no marked target");
cmdq_error(item, "no marked target");
goto error;
}
cmd_find_copy_state(fs, &marked_pane);
@ -1119,7 +1121,7 @@ cmd_find_target(struct cmd_find_state *fs, struct cmd_find_state *current,
/* No pane is allowed if want an index. */
if (pane != NULL && (flags & CMD_FIND_WINDOW_INDEX)) {
if (~flags & CMD_FIND_QUIET)
cmdq_error(cmdq, "can't specify pane here");
cmdq_error(item, "can't specify pane here");
goto error;
}
@ -1218,23 +1220,23 @@ found:
no_session:
if (~flags & CMD_FIND_QUIET)
cmdq_error(cmdq, "can't find session %s", session);
cmdq_error(item, "can't find session %s", session);
goto error;
no_window:
if (~flags & CMD_FIND_QUIET)
cmdq_error(cmdq, "can't find window %s", window);
cmdq_error(item, "can't find window %s", window);
goto error;
no_pane:
if (~flags & CMD_FIND_QUIET)
cmdq_error(cmdq, "can't find pane %s", pane);
cmdq_error(item, "can't find pane %s", pane);
goto error;
}
/* Find the target client or report an error and return NULL. */
struct client *
cmd_find_client(struct cmd_q *cmdq, const char *target, int quiet)
cmd_find_client(struct cmdq_item *item, const char *target, int quiet)
{
struct client *c;
char *copy;
@ -1242,10 +1244,10 @@ cmd_find_client(struct cmd_q *cmdq, const char *target, int quiet)
const char *path;
/* A NULL argument means the current client. */
if (cmdq != NULL && target == NULL) {
c = cmd_find_current_client(cmdq);
if (item != NULL && target == NULL) {
c = cmd_find_current_client(item);
if (c == NULL && !quiet)
cmdq_error(cmdq, "no current client");
cmdq_error(item, "no current client");
log_debug("%s: no target, return %p", __func__, c);
return (c);
}
@ -1275,7 +1277,7 @@ cmd_find_client(struct cmd_q *cmdq, const char *target, int quiet)
/* If no client found, report an error. */
if (c == NULL && !quiet)
cmdq_error(cmdq, "can't find client %s", copy);
cmdq_error(item, "can't find client %s", copy);
free(copy);
log_debug("%s: target %s, return %p", __func__, target, c);

66
cmd-if-shell.c
View File

@ -29,11 +29,11 @@
* Executes a tmux command if a shell command returns true or false.
*/
static enum cmd_retval cmd_if_shell_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_if_shell_exec(struct cmd *, struct cmdq_item *);
static enum cmd_retval cmd_if_shell_error(struct cmd_q *, void *);
static void cmd_if_shell_callback(struct job *);
static void cmd_if_shell_free(void *);
static enum cmd_retval cmd_if_shell_error(struct cmdq_item *, void *);
static void cmd_if_shell_callback(struct job *);
static void cmd_if_shell_free(void *);
const struct cmd_entry cmd_if_shell_entry = {
.name = "if-shell",
@ -57,33 +57,33 @@ struct cmd_if_shell_data {
char *cmd_else;
struct client *client;
struct cmd_q *cmdq;
struct cmdq_item *item;
struct mouse_event mouse;
};
static enum cmd_retval
cmd_if_shell_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct cmd_if_shell_data *cdata;
char *shellcmd, *cmd, *cause;
struct cmd_list *cmdlist;
struct cmd_q *new_cmdq;
struct session *s = cmdq->state.tflag.s;
struct winlink *wl = cmdq->state.tflag.wl;
struct window_pane *wp = cmdq->state.tflag.wp;
struct cmdq_item *new_item;
struct session *s = item->state.tflag.s;
struct winlink *wl = item->state.tflag.wl;
struct window_pane *wp = item->state.tflag.wp;
struct format_tree *ft;
const char *cwd;
if (cmdq->client != NULL && cmdq->client->session == NULL)
cwd = cmdq->client->cwd;
if (item->client != NULL && item->client->session == NULL)
cwd = item->client->cwd;
else if (s != NULL)
cwd = s->cwd;
else
cwd = NULL;
ft = format_create(cmdq, 0);
format_defaults(ft, cmdq->state.c, s, wl, wp);
ft = format_create(item, 0);
format_defaults(ft, item->state.c, s, wl, wp);
shellcmd = format_expand(ft, args->argv[0]);
format_free(ft);
@ -98,13 +98,13 @@ cmd_if_shell_exec(struct cmd *self, struct cmd_q *cmdq)
return (CMD_RETURN_NORMAL);
if (cmd_string_parse(cmd, &cmdlist, NULL, 0, &cause) != 0) {
if (cause != NULL) {
cmdq_error(cmdq, "%s", cause);
cmdq_error(item, "%s", cause);
free(cause);
}
return (CMD_RETURN_ERROR);
}
new_cmdq = cmdq_get_command(cmdlist, NULL, &cmdq->mouse, 0);
cmdq_insert_after(cmdq, new_cmdq);
new_item = cmdq_get_command(cmdlist, NULL, &item->mouse, 0);
cmdq_insert_after(item, new_item);
cmd_list_free(cmdlist);
return (CMD_RETURN_NORMAL);
}
@ -121,14 +121,14 @@ cmd_if_shell_exec(struct cmd *self, struct cmd_q *cmdq)
else
cdata->cmd_else = NULL;
cdata->client = cmdq->client;
cdata->client = item->client;
cdata->client->references++;
if (!args_has(args, 'b'))
cdata->cmdq = cmdq;
cdata->item = item;
else
cdata->cmdq = NULL;
memcpy(&cdata->mouse, &cmdq->mouse, sizeof cdata->mouse);
cdata->item = NULL;
memcpy(&cdata->mouse, &item->mouse, sizeof cdata->mouse);
job_run(shellcmd, s, cwd, cmd_if_shell_callback, cmd_if_shell_free,
cdata);
@ -140,11 +140,11 @@ cmd_if_shell_exec(struct cmd *self, struct cmd_q *cmdq)
}
static enum cmd_retval
cmd_if_shell_error(struct cmd_q *cmdq, void *data)
cmd_if_shell_error(struct cmdq_item *item, void *data)
{
char *error = data;
cmdq_error(cmdq, "%s", error);
cmdq_error(item, "%s", error);
free(error);
return (CMD_RETURN_NORMAL);
@ -156,7 +156,7 @@ cmd_if_shell_callback(struct job *job)
struct cmd_if_shell_data *cdata = job->data;
struct client *c = cdata->client;
struct cmd_list *cmdlist;
struct cmd_q *new_cmdq;
struct cmdq_item *new_item;
char *cause, *cmd, *file = cdata->file;
u_int line = cdata->line;
@ -169,24 +169,24 @@ cmd_if_shell_callback(struct job *job)
if (cmd_string_parse(cmd, &cmdlist, file, line, &cause) != 0) {
if (cause != NULL)
new_cmdq = cmdq_get_callback(cmd_if_shell_error, cause);
new_item = cmdq_get_callback(cmd_if_shell_error, cause);
else
new_cmdq = NULL;
new_item = NULL;
} else {
new_cmdq = cmdq_get_command(cmdlist, NULL, &cdata->mouse, 0);
new_item = cmdq_get_command(cmdlist, NULL, &cdata->mouse, 0);
cmd_list_free(cmdlist);
}
if (new_cmdq != NULL) {
if (cdata->cmdq == NULL)
cmdq_append(c, new_cmdq);
if (new_item != NULL) {
if (cdata->item == NULL)
cmdq_append(c, new_item);
else
cmdq_insert_after(cdata->cmdq, new_cmdq);
cmdq_insert_after(cdata->item, new_item);
}
out:
if (cdata->cmdq != NULL)
cdata->cmdq->flags &= ~CMD_Q_WAITING;
if (cdata->item != NULL)
cdata->item->flags &= ~CMDQ_WAITING;
}
static void

24
cmd-join-pane.c
View File

@ -28,7 +28,7 @@
* Join or move a pane into another (like split/swap/kill).
*/
static enum cmd_retval cmd_join_pane_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_join_pane_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_join_pane_entry = {
.name = "join-pane",
@ -59,7 +59,7 @@ const struct cmd_entry cmd_move_pane_entry = {
};
static enum cmd_retval
cmd_join_pane_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_join_pane_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct session *dst_s;
@ -77,24 +77,24 @@ cmd_join_pane_exec(struct cmd *self, struct cmd_q *cmdq)
else
not_same_window = 0;
dst_s = cmdq->state.tflag.s;
dst_wl = cmdq->state.tflag.wl;
dst_wp = cmdq->state.tflag.wp;
dst_s = item->state.tflag.s;
dst_wl = item->state.tflag.wl;
dst_wp = item->state.tflag.wp;
dst_w = dst_wl->window;
dst_idx = dst_wl->idx;
server_unzoom_window(dst_w);
src_wl = cmdq->state.sflag.wl;
src_wp = cmdq->state.sflag.wp;
src_wl = item->state.sflag.wl;
src_wp = item->state.sflag.wp;
src_w = src_wl->window;
server_unzoom_window(src_w);
if (not_same_window && src_w == dst_w) {
cmdq_error(cmdq, "can't join a pane to its own window");
cmdq_error(item, "can't join a pane to its own window");
return (CMD_RETURN_ERROR);
}
if (!not_same_window && src_wp == dst_wp) {
cmdq_error(cmdq, "source and target panes must be different");
cmdq_error(item, "source and target panes must be different");
return (CMD_RETURN_ERROR);
}
@ -106,14 +106,14 @@ cmd_join_pane_exec(struct cmd *self, struct cmd_q *cmdq)
if (args_has(args, 'l')) {
size = args_strtonum(args, 'l', 0, INT_MAX, &cause);
if (cause != NULL) {
cmdq_error(cmdq, "size %s", cause);
cmdq_error(item, "size %s", cause);
free(cause);
return (CMD_RETURN_ERROR);
}
} else if (args_has(args, 'p')) {
percentage = args_strtonum(args, 'p', 0, 100, &cause);
if (cause != NULL) {
cmdq_error(cmdq, "percentage %s", cause);
cmdq_error(item, "percentage %s", cause);
free(cause);
return (CMD_RETURN_ERROR);
}
@ -124,7 +124,7 @@ cmd_join_pane_exec(struct cmd *self, struct cmd_q *cmdq)
}
lc = layout_split_pane(dst_wp, type, size, args_has(args, 'b'), 0);
if (lc == NULL) {
cmdq_error(cmdq, "create pane failed: pane too small");
cmdq_error(item, "create pane failed: pane too small");
return (CMD_RETURN_ERROR);
}

8
cmd-kill-pane.c
View File

@ -26,7 +26,7 @@
* Kill pane.
*/
static enum cmd_retval cmd_kill_pane_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_kill_pane_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_kill_pane_entry = {
.name = "kill-pane",
@ -42,10 +42,10 @@ const struct cmd_entry cmd_kill_pane_entry = {
};
static enum cmd_retval
cmd_kill_pane_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_kill_pane_exec(struct cmd *self, struct cmdq_item *item)
{
struct winlink *wl = cmdq->state.tflag.wl;
struct window_pane *loopwp, *tmpwp, *wp = cmdq->state.tflag.wp;
struct winlink *wl = item->state.tflag.wl;
struct window_pane *loopwp, *tmpwp, *wp = item->state.tflag.wp;
server_unzoom_window(wl->window);

4
cmd-kill-server.c
View File

@ -27,7 +27,7 @@
* Kill the server and do nothing else.
*/
static enum cmd_retval cmd_kill_server_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_kill_server_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_kill_server_entry = {
.name = "kill-server",
@ -52,7 +52,7 @@ const struct cmd_entry cmd_start_server_entry = {
};
static enum cmd_retval
cmd_kill_server_exec(struct cmd *self, __unused struct cmd_q *cmdq)
cmd_kill_server_exec(struct cmd *self, __unused struct cmdq_item *item)
{
if (self->entry == &cmd_kill_server_entry)
kill(getpid(), SIGTERM);

6
cmd-kill-session.c
View File

@ -27,7 +27,7 @@
* Note this deliberately has no alias to make it hard to hit by accident.
*/
static enum cmd_retval cmd_kill_session_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_kill_session_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_kill_session_entry = {
.name = "kill-session",
@ -43,13 +43,13 @@ const struct cmd_entry cmd_kill_session_entry = {
};
static enum cmd_retval
cmd_kill_session_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_kill_session_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct session *s, *sloop, *stmp;
struct winlink *wl;
s = cmdq->state.tflag.s;
s = item->state.tflag.s;
if (args_has(args, 'C')) {
RB_FOREACH(wl, winlinks, &s->windows) {

10
cmd-kill-window.c
View File

@ -24,7 +24,7 @@
* Destroy window.
*/
static enum cmd_retval cmd_kill_window_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_kill_window_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_kill_window_entry = {
.name = "kill-window",
@ -53,16 +53,16 @@ const struct cmd_entry cmd_unlink_window_entry = {
};
static enum cmd_retval
cmd_kill_window_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_kill_window_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct winlink *wl = cmdq->state.tflag.wl, *wl2, *wl3;
struct winlink *wl = item->state.tflag.wl, *wl2, *wl3;
struct window *w = wl->window;
struct session *s = cmdq->state.tflag.s;
struct session *s = item->state.tflag.s;
if (self->entry == &cmd_unlink_window_entry) {
if (!args_has(self->args, 'k') && !session_is_linked(s, w)) {
cmdq_error(cmdq, "window only linked to one session");
cmdq_error(item, "window only linked to one session");
return (CMD_RETURN_ERROR);
}
server_unlink_window(s, wl);

8
cmd-list-buffers.c
View File

@ -30,7 +30,7 @@
#define LIST_BUFFERS_TEMPLATE \
"#{buffer_name}: #{buffer_size} bytes: \"#{buffer_sample}\""
static enum cmd_retval cmd_list_buffers_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_list_buffers_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_list_buffers_entry = {
.name = "list-buffers",
@ -44,7 +44,7 @@ const struct cmd_entry cmd_list_buffers_entry = {
};
static enum cmd_retval
cmd_list_buffers_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_list_buffers_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct paste_buffer *pb;
@ -57,11 +57,11 @@ cmd_list_buffers_exec(struct cmd *self, struct cmd_q *cmdq)
pb = NULL;
while ((pb = paste_walk(pb)) != NULL) {
ft = format_create(cmdq, 0);
ft = format_create(item, 0);
format_defaults_paste_buffer(ft, pb);
line = format_expand(ft, template);
cmdq_print(cmdq, "%s", line);
cmdq_print(item, "%s", line);
free(line);
format_free(ft);

10
cmd-list-clients.c
View File

@ -33,7 +33,7 @@
"[#{client_width}x#{client_height} #{client_termname}]" \
"#{?client_utf8, (utf8),} #{?client_readonly, (ro),}"
static enum cmd_retval cmd_list_clients_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_list_clients_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_list_clients_entry = {
.name = "list-clients",
@ -49,7 +49,7 @@ const struct cmd_entry cmd_list_clients_entry = {
};
static enum cmd_retval
cmd_list_clients_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_list_clients_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c;
@ -60,7 +60,7 @@ cmd_list_clients_exec(struct cmd *self, struct cmd_q *cmdq)
char *line;
if (args_has(args, 't'))
s = cmdq->state.tflag.s;
s = item->state.tflag.s;
else
s = NULL;
@ -72,12 +72,12 @@ cmd_list_clients_exec(struct cmd *self, struct cmd_q *cmdq)
if (c->session == NULL || (s != NULL && s != c->session))
continue;
ft = format_create(cmdq, 0);
ft = format_create(item, 0);
format_add(ft, "line", "%u", idx);
format_defaults(ft, c, NULL, NULL, NULL);
line = format_expand(ft, template);
cmdq_print(cmdq, "%s", line);
cmdq_print(item, "%s", line);
free(line);
format_free(ft);

49
cmd-list-keys.c
View File

@ -27,10 +27,11 @@
* List key bindings.
*/
static enum cmd_retval cmd_list_keys_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_list_keys_exec(struct cmd *, struct cmdq_item *);
static enum cmd_retval cmd_list_keys_table(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_list_keys_commands(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_list_keys_table(struct cmd *, struct cmdq_item *);
static enum cmd_retval cmd_list_keys_commands(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_list_keys_entry = {
.name = "list-keys",
@ -55,7 +56,7 @@ const struct cmd_entry cmd_list_commands_entry = {
};
static enum cmd_retval
cmd_list_keys_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct key_table *table;
@ -65,14 +66,14 @@ cmd_list_keys_exec(struct cmd *self, struct cmd_q *cmdq)
int repeat, width, tablewidth, keywidth;
if (self->entry == &cmd_list_commands_entry)
return (cmd_list_keys_commands(self, cmdq));
return (cmd_list_keys_commands(self, item));
if (args_has(args, 't'))
return (cmd_list_keys_table(self, cmdq));
return (cmd_list_keys_table(self, item));
tablename = args_get(args, 'T');
if (tablename != NULL && key_bindings_get_table(tablename, 0) == NULL) {
cmdq_error(cmdq, "table %s doesn't exist", tablename);
cmdq_error(item, "table %s doesn't exist", tablename);
return (CMD_RETURN_ERROR);
}
@ -124,7 +125,7 @@ cmd_list_keys_exec(struct cmd *self, struct cmd_q *cmdq)
strlcat(tmp, cp, sizeof tmp);
free(cp);
cmdq_print(cmdq, "bind-key %s", tmp);
cmdq_print(item, "bind-key %s", tmp);
}
}
@ -132,7 +133,7 @@ cmd_list_keys_exec(struct cmd *self, struct cmd_q *cmdq)
}
static enum cmd_retval
cmd_list_keys_table(struct cmd *self, struct cmd_q *cmdq)
cmd_list_keys_table(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
const char *tablename, *cmdstr;
@ -142,7 +143,7 @@ cmd_list_keys_table(struct cmd *self, struct cmd_q *cmdq)
tablename = args_get(args, 't');
if ((mtab = mode_key_findtable(tablename)) == NULL) {
cmdq_error(cmdq, "unknown key table: %s", tablename);
cmdq_error(item, "unknown key table: %s", tablename);
return (CMD_RETURN_ERROR);
}
@ -156,7 +157,7 @@ cmd_list_keys_table(struct cmd *self, struct cmd_q *cmdq)
RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
cmdstr = mode_key_tostring(mtab->cmdstr, mbind->cmd);
if (cmdstr != NULL) {
cmdq_print(cmdq, "bind-key -t %s %*s %s",
cmdq_print(item, "bind-key -t %s %*s %s",
mtab->name, (int)keywidth,
key_string_lookup_key(mbind->key), cmdstr);
}
@ -166,13 +167,13 @@ cmd_list_keys_table(struct cmd *self, struct cmd_q *cmdq)
}
static enum cmd_retval
cmd_list_keys_commands(struct cmd *self, struct cmd_q *cmdq)
cmd_list_keys_commands(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
const struct cmd_entry **entryp;
const struct cmd_entry *entry;
struct format_tree *ft;
const char *template;
const char *template, *s;
char *line;
if ((template = args_get(args, 'F')) == NULL) {
@ -181,25 +182,27 @@ cmd_list_keys_commands(struct cmd *self, struct cmd_q *cmdq)
"#{command_list_usage}";
}
ft = format_create(cmdq, 0);
ft = format_create(item, 0);
format_defaults(ft, NULL, NULL, NULL, NULL);
for (entryp = cmd_table; *entryp != NULL; entryp++) {
entry = *entryp;
format_add(ft, "command_list_name", "%s", entry->name);
if (entry->alias != NULL) {
format_add(ft, "command_list_alias", "%s",
entry->alias);
}
if (entry->alias != NULL) {
format_add(ft, "command_list_usage", "%s",
entry->usage);
}
if (entry->alias != NULL)
s = entry->alias;
else
s = "";
format_add(ft, "command_list_alias", "%s", s);
if (entry->usage != NULL)
s = entry->usage;
else
s = "";
format_add(ft, "command_list_usage", "%s", s);
line = format_expand(ft, template);
if (*line != '\0')
cmdq_print(cmdq, "%s", line);
cmdq_print(item, "%s", line);
free(line);
}

36
cmd-list-panes.c
View File

@ -26,13 +26,13 @@
* List panes on given window.
*/
static enum cmd_retval cmd_list_panes_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_list_panes_exec(struct cmd *, struct cmdq_item *);
static void cmd_list_panes_server(struct cmd *, struct cmd_q *);
static void cmd_list_panes_server(struct cmd *, struct cmdq_item *);
static void cmd_list_panes_session(struct cmd *, struct session *,
struct cmd_q *, int);
struct cmdq_item *, int);
static void cmd_list_panes_window(struct cmd *, struct session *,
struct winlink *, struct cmd_q *, int);
struct winlink *, struct cmdq_item *, int);
const struct cmd_entry cmd_list_panes_entry = {
.name = "list-panes",
@ -48,44 +48,44 @@ const struct cmd_entry cmd_list_panes_entry = {
};
static enum cmd_retval
cmd_list_panes_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_list_panes_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct session *s = cmdq->state.tflag.s;
struct winlink *wl = cmdq->state.tflag.wl;
struct session *s = item->state.tflag.s;
struct winlink *wl = item->state.tflag.wl;
if (args_has(args, 'a'))
cmd_list_panes_server(self, cmdq);
cmd_list_panes_server(self, item);
else if (args_has(args, 's'))
cmd_list_panes_session(self, s, cmdq, 1);
cmd_list_panes_session(self, s, item, 1);
else
cmd_list_panes_window(self, s, wl, cmdq, 0);
cmd_list_panes_window(self, s, wl, item, 0);
return (CMD_RETURN_NORMAL);
}
static void
cmd_list_panes_server(struct cmd *self, struct cmd_q *cmdq)
cmd_list_panes_server(struct cmd *self, struct cmdq_item *item)
{
struct session *s;
RB_FOREACH(s, sessions, &sessions)
cmd_list_panes_session(self, s, cmdq, 2);
cmd_list_panes_session(self, s, item, 2);
}
static void
cmd_list_panes_session(struct cmd *self, struct session *s, struct cmd_q *cmdq,
int type)
cmd_list_panes_session(struct cmd *self, struct session *s,
struct cmdq_item *item, int type)
{
struct winlink *wl;
RB_FOREACH(wl, winlinks, &s->windows)
cmd_list_panes_window(self, s, wl, cmdq, type);
cmd_list_panes_window(self, s, wl, item, type);
}
static void
cmd_list_panes_window(struct cmd *self, struct session *s, struct winlink *wl,
struct cmd_q *cmdq, int type)
struct cmdq_item *item, int type)
{
struct args *args = self->args;
struct window_pane *wp;
@ -123,12 +123,12 @@ cmd_list_panes_window(struct cmd *self, struct session *s, struct winlink *wl,
n = 0;
TAILQ_FOREACH(wp, &wl->window->panes, entry) {
ft = format_create(cmdq, 0);
ft = format_create(item, 0);
format_add(ft, "line", "%u", n);
format_defaults(ft, NULL, s, wl, wp);
line = format_expand(ft, template);
cmdq_print(cmdq, "%s", line);
cmdq_print(item, "%s", line);
free(line);
format_free(ft);

9
cmd-list-sessions.c
View File

@ -36,7 +36,8 @@
"#{session_group}#{?session_grouped,),}" \
"#{?session_attached, (attached),}"
static enum cmd_retval cmd_list_sessions_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_list_sessions_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_list_sessions_entry = {
.name = "list-sessions",
@ -50,7 +51,7 @@ const struct cmd_entry cmd_list_sessions_entry = {
};
static enum cmd_retval
cmd_list_sessions_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_list_sessions_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct session *s;
@ -64,12 +65,12 @@ cmd_list_sessions_exec(struct cmd *self, struct cmd_q *cmdq)
n = 0;
RB_FOREACH(s, sessions, &sessions) {
ft = format_create(cmdq, 0);
ft = format_create(item, 0);
format_add(ft, "line", "%u", n);
format_defaults(ft, NULL, s, NULL, NULL);
line = format_expand(ft, template);
cmdq_print(cmdq, "%s", line);
cmdq_print(item, "%s", line);
free(line);
format_free(ft);

22
cmd-list-windows.c
View File

@ -39,11 +39,11 @@
"(#{window_panes} panes) " \
"[#{window_width}x#{window_height}] "
static enum cmd_retval cmd_list_windows_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_list_windows_exec(struct cmd *, struct cmdq_item *);
static void cmd_list_windows_server(struct cmd *, struct cmd_q *);
static void cmd_list_windows_server(struct cmd *, struct cmdq_item *);
static void cmd_list_windows_session(struct cmd *, struct session *,
struct cmd_q *, int);
struct cmdq_item *, int);
const struct cmd_entry cmd_list_windows_entry = {
.name = "list-windows",
@ -59,30 +59,30 @@ const struct cmd_entry cmd_list_windows_entry = {
};
static enum cmd_retval
cmd_list_windows_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_list_windows_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
if (args_has(args, 'a'))
cmd_list_windows_server(self, cmdq);
cmd_list_windows_server(self, item);
else
cmd_list_windows_session(self, cmdq->state.tflag.s, cmdq, 0);
cmd_list_windows_session(self, item->state.tflag.s, item, 0);
return (CMD_RETURN_NORMAL);
}
static void
cmd_list_windows_server(struct cmd *self, struct cmd_q *cmdq)
cmd_list_windows_server(struct cmd *self, struct cmdq_item *item)
{
struct session *s;
RB_FOREACH(s, sessions, &sessions)
cmd_list_windows_session(self, s, cmdq, 1);
cmd_list_windows_session(self, s, item, 1);
}
static void
cmd_list_windows_session(struct cmd *self, struct session *s,
struct cmd_q *cmdq, int type)
struct cmdq_item *item, int type)
{
struct args *args = self->args;
struct winlink *wl;
@ -105,12 +105,12 @@ cmd_list_windows_session(struct cmd *self, struct session *s,
n = 0;
RB_FOREACH(wl, winlinks, &s->windows) {
ft = format_create(cmdq, 0);
ft = format_create(item, 0);
format_add(ft, "line", "%u", n);
format_defaults(ft, NULL, s, wl, NULL);
line = format_expand(ft, template);
cmdq_print(cmdq, "%s", line);
cmdq_print(item, "%s", line);
free(line);
format_free(ft);

28
cmd-load-buffer.c
View File

@ -31,9 +31,9 @@
* Loads a paste buffer from a file.
*/
static enum cmd_retval cmd_load_buffer_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_load_buffer_exec(struct cmd *, struct cmdq_item *);
static void cmd_load_buffer_callback(struct client *, int, void *);
static void cmd_load_buffer_callback(struct client *, int, void *);
const struct cmd_entry cmd_load_buffer_entry = {
.name = "load-buffer",
@ -47,16 +47,16 @@ const struct cmd_entry cmd_load_buffer_entry = {
};
struct cmd_load_buffer_data {
struct cmd_q *cmdq;
char *bufname;
struct cmdq_item *item;
char *bufname;
};
static enum cmd_retval
cmd_load_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_load_buffer_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct cmd_load_buffer_data *cdata;
struct client *c = cmdq->client;
struct client *c = item->client;
struct session *s;
FILE *f;
const char *path, *bufname, *cwd;
@ -72,13 +72,13 @@ cmd_load_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
path = args->argv[0];
if (strcmp(path, "-") == 0) {
cdata = xcalloc(1, sizeof *cdata);
cdata->cmdq = cmdq;
cdata->item = item;
cdata->bufname = xstrdup(bufname);
error = server_set_stdin_callback(c, cmd_load_buffer_callback,
cdata, &cause);
if (error != 0) {
cmdq_error(cmdq, "%s: %s", path, cause);
cmdq_error(item, "%s: %s", path, cause);
free(cause);
return (CMD_RETURN_ERROR);
}
@ -98,13 +98,13 @@ cmd_load_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
xasprintf(&file, "%s/%s", cwd, path);
if (realpath(file, resolved) == NULL &&
strlcpy(resolved, file, sizeof resolved) >= sizeof resolved) {
cmdq_error(cmdq, "%s: %s", file, strerror(ENAMETOOLONG));
cmdq_error(item, "%s: %s", file, strerror(ENAMETOOLONG));
return (CMD_RETURN_ERROR);
}
f = fopen(resolved, "rb");
free(file);
if (f == NULL) {
cmdq_error(cmdq, "%s: %s", resolved, strerror(errno));
cmdq_error(item, "%s: %s", resolved, strerror(errno));
return (CMD_RETURN_ERROR);
}
@ -113,14 +113,14 @@ cmd_load_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
while ((ch = getc(f)) != EOF) {
/* Do not let the server die due to memory exhaustion. */
if ((new_pdata = realloc(pdata, psize + 2)) == NULL) {
cmdq_error(cmdq, "realloc error: %s", strerror(errno));
cmdq_error(item, "realloc error: %s", strerror(errno));
goto error;
}
pdata = new_pdata;
pdata[psize++] = ch;
}
if (ferror(f)) {
cmdq_error(cmdq, "%s: read error", resolved);
cmdq_error(item, "%s: read error", resolved);
goto error;
}
if (pdata != NULL)
@ -129,7 +129,7 @@ cmd_load_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
fclose(f);
if (paste_set(pdata, psize, bufname, &cause) != 0) {
cmdq_error(cmdq, "%s", cause);
cmdq_error(item, "%s", cause);
free(pdata);
free(cause);
return (CMD_RETURN_ERROR);
@ -180,7 +180,7 @@ cmd_load_buffer_callback(struct client *c, int closed, void *data)
free(cause);
}
out:
cdata->cmdq->flags &= ~CMD_Q_WAITING;
cdata->item->flags &= ~CMDQ_WAITING;
free(cdata->bufname);
free(cdata);

8
cmd-lock-server.c
View File

@ -24,7 +24,7 @@
* Lock commands.
*/
static enum cmd_retval cmd_lock_server_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_lock_server_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_lock_server_entry = {
.name = "lock-server",
@ -64,14 +64,14 @@ const struct cmd_entry cmd_lock_client_entry = {
};
static enum cmd_retval
cmd_lock_server_exec(struct cmd *self, __unused struct cmd_q *cmdq)
cmd_lock_server_exec(struct cmd *self, __unused struct cmdq_item *item)
{
if (self->entry == &cmd_lock_server_entry)
server_lock();
else if (self->entry == &cmd_lock_session_entry)
server_lock_session(cmdq->state.tflag.s);
server_lock_session(item->state.tflag.s);
else
server_lock_client(cmdq->state.c);
server_lock_client(item->state.c);
recalculate_sizes();

14
cmd-move-window.c
View File

@ -26,7 +26,7 @@
* Move a window.
*/
static enum cmd_retval cmd_move_window_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_move_window_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_move_window_entry = {
.name = "move-window",
@ -57,14 +57,14 @@ const struct cmd_entry cmd_link_window_entry = {
};
static enum cmd_retval
cmd_move_window_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_move_window_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct session *src = cmdq->state.sflag.s;
struct session *dst = cmdq->state.tflag.s;
struct winlink *wl = cmdq->state.sflag.wl;
struct session *src = item->state.sflag.s;
struct session *dst = item->state.tflag.s;
struct winlink *wl = item->state.sflag.wl;
char *cause;
int idx = cmdq->state.tflag.idx, kflag, dflag, sflag;
int idx = item->state.tflag.idx, kflag, dflag, sflag;
if (args_has(args, 'r')) {
session_renumber_windows(dst);
@ -84,7 +84,7 @@ cmd_move_window_exec(struct cmd *self, struct cmd_q *cmdq)
if (server_link_window(src, wl, dst, idx, kflag, !dflag,
&cause) != 0) {
cmdq_error(cmdq, "can't link window: %s", cause);
cmdq_error(item, "can't link window: %s", cause);
free(cause);
return (CMD_RETURN_ERROR);
}

42
cmd-new-session.c
View File

@ -33,7 +33,7 @@
#define NEW_SESSION_TEMPLATE "#{session_name}:"
static enum cmd_retval cmd_new_session_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_new_session_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_new_session_entry = {
.name = "new-session",
@ -64,12 +64,12 @@ const struct cmd_entry cmd_has_session_entry = {
};
static enum cmd_retval
cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c = cmdq->client;
struct client *c = item->client;
struct session *s, *as;
struct session *groupwith = cmdq->state.tflag.s;
struct session *groupwith = item->state.tflag.s;
struct window *w;
struct environ *env;
struct termios tio, *tiop;
@ -91,37 +91,37 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
}
if (args_has(args, 't') && (args->argc != 0 || args_has(args, 'n'))) {
cmdq_error(cmdq, "command or window name given with target");
cmdq_error(item, "command or window name given with target");
return (CMD_RETURN_ERROR);
}
newname = args_get(args, 's');
if (newname != NULL) {
if (!session_check_name(newname)) {
cmdq_error(cmdq, "bad session name: %s", newname);
cmdq_error(item, "bad session name: %s", newname);
return (CMD_RETURN_ERROR);
}
if ((as = session_find(newname)) != NULL) {
if (args_has(args, 'A')) {
/*
* This cmdq is now destined for
* This item is now destined for
* attach-session. Because attach-session
* will have already been prepared, copy this
* session into its tflag so it can be used.
*/
cmd_find_from_session(&cmdq->state.tflag, as);
return (cmd_attach_session(cmdq,
cmd_find_from_session(&item->state.tflag, as);
return (cmd_attach_session(item,
args_has(args, 'D'), 0, NULL,
args_has(args, 'E')));
}
cmdq_error(cmdq, "duplicate session: %s", newname);
cmdq_error(item, "duplicate session: %s", newname);
return (CMD_RETURN_ERROR);
}
}
if ((target = args_get(args, 't')) != NULL) {
if (groupwith == NULL) {
cmdq_error(cmdq, "no such session: %s", target);
cmdq_error(item, "no such session: %s", target);
goto error;
}
} else
@ -139,7 +139,7 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
/* Get the new session working directory. */
if (args_has(args, 'c')) {
ft = format_create(cmdq, 0);
ft = format_create(item, 0);
format_defaults(ft, c, NULL, NULL, NULL);
to_free = cwd = format_expand(ft, args_get(args, 'c'));
format_free(ft);
@ -158,8 +158,8 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
* over.
*/
if (!detached && !already_attached && c->tty.fd != -1) {
if (server_client_check_nested(cmdq->client)) {
cmdq_error(cmdq, "sessions should be nested with care, "
if (server_client_check_nested(item->client)) {
cmdq_error(item, "sessions should be nested with care, "
"unset $TMUX to force");
return (CMD_RETURN_ERROR);
}
@ -172,7 +172,7 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
/* Open the terminal if necessary. */
if (!detached && !already_attached) {
if (server_client_open(c, &cause) != 0) {
cmdq_error(cmdq, "open terminal failed: %s", cause);
cmdq_error(item, "open terminal failed: %s", cause);
free(cause);
goto error;
}
@ -189,14 +189,14 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
if (detached && args_has(args, 'x')) {
sx = strtonum(args_get(args, 'x'), 1, USHRT_MAX, &errstr);
if (errstr != NULL) {
cmdq_error(cmdq, "width %s", errstr);
cmdq_error(item, "width %s", errstr);
goto error;
}
}
if (detached && args_has(args, 'y')) {
sy = strtonum(args_get(args, 'y'), 1, USHRT_MAX, &errstr);
if (errstr != NULL) {
cmdq_error(cmdq, "height %s", errstr);
cmdq_error(item, "height %s", errstr);
goto error;
}
}
@ -246,7 +246,7 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
sy, &cause);
environ_free(env);
if (s == NULL) {
cmdq_error(cmdq, "create session failed: %s", cause);
cmdq_error(item, "create session failed: %s", cause);
free(cause);
goto error;
}
@ -301,11 +301,11 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
if ((template = args_get(args, 'F')) == NULL)
template = NEW_SESSION_TEMPLATE;
ft = format_create(cmdq, 0);
ft = format_create(item, 0);
format_defaults(ft, c, s, NULL, NULL);
cp = format_expand(ft, template);
cmdq_print(cmdq, "%s", cp);
cmdq_print(item, "%s", cp);
free(cp);
format_free(ft);
@ -318,7 +318,7 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
free((void *)to_free);
cmd_find_from_session(&fs, s);
hooks_insert(s->hooks, cmdq, &fs, "after-new-session");
hooks_insert(s->hooks, item, &fs, "after-new-session");
return (CMD_RETURN_NORMAL);

32
cmd-new-window.c
View File

@ -32,7 +32,7 @@
#define NEW_WINDOW_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"
static enum cmd_retval cmd_new_window_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_new_window_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_new_window_entry = {
.name = "new-window",
@ -49,13 +49,13 @@ const struct cmd_entry cmd_new_window_entry = {
};
static enum cmd_retval
cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct session *s = cmdq->state.tflag.s;
struct winlink *wl = cmdq->state.tflag.wl;
struct client *c = cmdq->state.c;
int idx = cmdq->state.tflag.idx;
struct session *s = item->state.tflag.s;
struct winlink *wl = item->state.tflag.wl;
struct client *c = item->state.c;
int idx = item->state.tflag.idx;
const char *cmd, *path, *template, *cwd, *to_free;
char **argv, *cause, *cp;
int argc, detached;
@ -65,7 +65,7 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
if (args_has(args, 'a')) {
if ((idx = winlink_shuffle_up(s, wl)) == -1) {
cmdq_error(cmdq, "no free window indexes");
cmdq_error(item, "no free window indexes");
return (CMD_RETURN_ERROR);
}
}
@ -86,8 +86,8 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
}
path = NULL;
if (cmdq->client != NULL && cmdq->client->session == NULL)
envent = environ_find(cmdq->client->environ, "PATH");
if (item->client != NULL && item->client->session == NULL)
envent = environ_find(item->client->environ, "PATH");
else
envent = environ_find(s->environ, "PATH");
if (envent != NULL)
@ -95,12 +95,12 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
to_free = NULL;
if (args_has(args, 'c')) {
ft = format_create(cmdq, 0);
ft = format_create(item, 0);
format_defaults(ft, c, s, NULL, NULL);
cwd = to_free = format_expand(ft, args_get(args, 'c'));
format_free(ft);
} else if (cmdq->client != NULL && cmdq->client->session == NULL)
cwd = cmdq->client->cwd;
} else if (item->client != NULL && item->client->session == NULL)
cwd = item->client->cwd;
else
cwd = s->cwd;
@ -129,7 +129,7 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
wl = session_new(s, args_get(args, 'n'), argc, argv, path, cwd, idx,
&cause);
if (wl == NULL) {
cmdq_error(cmdq, "create window failed: %s", cause);
cmdq_error(item, "create window failed: %s", cause);
free(cause);
goto error;
}
@ -143,11 +143,11 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
if ((template = args_get(args, 'F')) == NULL)
template = NEW_WINDOW_TEMPLATE;
ft = format_create(cmdq, 0);
ft = format_create(item, 0);
format_defaults(ft, c, s, wl, NULL);
cp = format_expand(ft, template);
cmdq_print(cmdq, "%s", cp);
cmdq_print(item, "%s", cp);
free(cp);
format_free(ft);
@ -157,7 +157,7 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
free((void *)to_free);
cmd_find_from_winlink(&fs, s, wl);
hooks_insert(s->hooks, cmdq, &fs, "after-new-window");
hooks_insert(s->hooks, item, &fs, "after-new-window");
return (CMD_RETURN_NORMAL);

8
cmd-paste-buffer.c
View File

@ -27,7 +27,7 @@
* Paste paste buffer if present.
*/
static enum cmd_retval cmd_paste_buffer_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_paste_buffer_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_paste_buffer_entry = {
.name = "paste-buffer",
@ -44,10 +44,10 @@ const struct cmd_entry cmd_paste_buffer_entry = {
};
static enum cmd_retval
cmd_paste_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_paste_buffer_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct window_pane *wp = cmdq->state.tflag.wp;
struct window_pane *wp = item->state.tflag.wp;
struct paste_buffer *pb;
const char *sepstr, *bufname, *bufdata, *bufend, *line;
size_t seplen, bufsize;
@ -62,7 +62,7 @@ cmd_paste_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
else {
pb = paste_get_name(bufname);
if (pb == NULL) {
cmdq_error(cmdq, "no buffer %s", bufname);
cmdq_error(item, "no buffer %s", bufname);
return (CMD_RETURN_ERROR);
}
}

18
cmd-pipe-pane.c
View File

@ -32,7 +32,7 @@
* Open pipe to redirect pane output. If already open, close first.
*/
static enum cmd_retval cmd_pipe_pane_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_pipe_pane_exec(struct cmd *, struct cmdq_item *);
static void cmd_pipe_pane_error_callback(struct bufferevent *, short, void *);
@ -50,13 +50,13 @@ const struct cmd_entry cmd_pipe_pane_entry = {
};
static enum cmd_retval
cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c = cmdq->state.c;
struct window_pane *wp = cmdq->state.tflag.wp;
struct session *s = cmdq->state.tflag.s;
struct winlink *wl = cmdq->state.tflag.wl;
struct client *c = item->state.c;
struct window_pane *wp = item->state.tflag.wp;
struct session *s = item->state.tflag.s;
struct winlink *wl = item->state.tflag.wl;
char *cmd;
int old_fd, pipe_fd[2], null_fd;
struct format_tree *ft;
@ -84,12 +84,12 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
/* Open the new pipe. */
if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pipe_fd) != 0) {
cmdq_error(cmdq, "socketpair error: %s", strerror(errno));
cmdq_error(item, "socketpair error: %s", strerror(errno));
return (CMD_RETURN_ERROR);
}
/* Expand the command. */
ft = format_create(cmdq, 0);
ft = format_create(item, 0);
format_defaults(ft, c, s, wl, wp);
cmd = format_expand_time(ft, args->argv[0], time(NULL));
format_free(ft);
@ -97,7 +97,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
/* Fork the child. */
switch (fork()) {
case -1:
cmdq_error(cmdq, "fork error: %s", strerror(errno));
cmdq_error(item, "fork error: %s", strerror(errno));
free(cmd);
return (CMD_RETURN_ERROR);

233
cmd-queue.c
View File

@ -26,7 +26,7 @@
#include "tmux.h"
/* Global command queue. */
static struct cmd_q_list global_queue = TAILQ_HEAD_INITIALIZER(global_queue);
static struct cmdq_list global_queue = TAILQ_HEAD_INITIALIZER(global_queue);
/* Get command queue name. */
static const char *
@ -41,7 +41,7 @@ cmdq_name(struct client *c)
}
/* Get command queue from client. */
static struct cmd_q_list *
static struct cmdq_list *
cmdq_get(struct client *c)
{
if (c == NULL)
@ -51,67 +51,68 @@ cmdq_get(struct client *c)
/* Append an item. */
void
cmdq_append(struct client *c, struct cmd_q *cmdq)
cmdq_append(struct client *c, struct cmdq_item *item)
{
struct cmd_q_list *queue = cmdq_get(c);
struct cmd_q *next;
struct cmdq_list *queue = cmdq_get(c);
struct cmdq_item *next;
do {
next = cmdq->next;
cmdq->next = NULL;
next = item->next;
item->next = NULL;
if (c != NULL)
c->references++;
cmdq->client = c;
item->client = c;
cmdq->queue = queue;
TAILQ_INSERT_TAIL(queue, cmdq, entry);
item->queue = queue;
TAILQ_INSERT_TAIL(queue, item, entry);
cmdq = next;
} while (cmdq != NULL);
item = next;
} while (item != NULL);
}
/* Insert an item. */
void
cmdq_insert_after(struct cmd_q *after, struct cmd_q *cmdq)
cmdq_insert_after(struct cmdq_item *after, struct cmdq_item *item)
{
struct client *c = after->client;
struct cmd_q_list *queue = after->queue;
struct cmd_q *next;
struct cmdq_list *queue = after->queue;
struct cmdq_item *next;
do {
next = cmdq->next;
cmdq->next = NULL;
next = item->next;
item->next = NULL;
if (c != NULL)
c->references++;
cmdq->client = c;
item->client = c;
cmdq->queue = queue;
item->queue = queue;
if (after->next != NULL)
TAILQ_INSERT_AFTER(queue, after->next, cmdq, entry);
TAILQ_INSERT_AFTER(queue, after->next, item, entry);
else
TAILQ_INSERT_AFTER(queue, after, cmdq, entry);
after->next = cmdq;
TAILQ_INSERT_AFTER(queue, after, item, entry);
after->next = item;
cmdq = next;
} while (cmdq != NULL);
item = next;
} while (item != NULL);
}
/* Remove an item. */
static void
cmdq_remove(struct cmd_q *cmdq)
cmdq_remove(struct cmdq_item *item)
{
free((void *)cmdq->hook);
if (item->formats != NULL)
format_free(item->formats);
if (cmdq->client != NULL)
server_client_unref(cmdq->client);
if (item->client != NULL)
server_client_unref(item->client);
if (cmdq->type == CMD_Q_COMMAND)
cmd_list_free(cmdq->cmdlist);
if (item->type == CMDQ_COMMAND)
cmd_list_free(item->cmdlist);
TAILQ_REMOVE(cmdq->queue, cmdq, entry);
free(cmdq);
TAILQ_REMOVE(item->queue, item, entry);
free(item);
}
/* Set command group. */
@ -125,129 +126,151 @@ cmdq_next_group(void)
/* Remove all subsequent items that match this item's group. */
static void
cmdq_remove_group(struct cmd_q *cmdq)
cmdq_remove_group(struct cmdq_item *item)
{
struct cmd_q *this, *next;
struct cmdq_item *this, *next;
this = TAILQ_NEXT(cmdq, entry);
this = TAILQ_NEXT(item, entry);
while (this != NULL) {
next = TAILQ_NEXT(this, entry);
if (this->group == cmdq->group)
if (this->group == item->group)
cmdq_remove(this);
this = next;
}
}
/* Get a command for the command queue. */
struct cmd_q *
struct cmdq_item *
cmdq_get_command(struct cmd_list *cmdlist, struct cmd_find_state *current,
struct mouse_event *m, int flags)
{
struct cmd_q *cmdq, *first = NULL, *last = NULL;
struct cmd *cmd;
u_int group = cmdq_next_group();
struct cmdq_item *item, *first = NULL, *last = NULL;
struct cmd *cmd;
u_int group = cmdq_next_group();
TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
cmdq = xcalloc(1, sizeof *cmdq);
cmdq->type = CMD_Q_COMMAND;
cmdq->group = group;
cmdq->flags = flags;
item = xcalloc(1, sizeof *item);
item->type = CMDQ_COMMAND;
item->group = group;
item->flags = flags;
cmdq->cmdlist = cmdlist;
cmdq->cmd = cmd;
item->cmdlist = cmdlist;
item->cmd = cmd;
if (current != NULL)
cmd_find_copy_state(&cmdq->current, current);
cmd_find_copy_state(&item->current, current);
if (m != NULL)
memcpy(&cmdq->mouse, m, sizeof cmdq->mouse);
memcpy(&item->mouse, m, sizeof item->mouse);
cmdlist->references++;
if (first == NULL)
first = cmdq;
first = item;
if (last != NULL)
last->next = cmdq;
last = cmdq;
last->next = item;
last = item;
}
return (first);
}
/* Fire command on command queue. */
static enum cmd_retval
cmdq_fire_command(struct cmd_q *cmdq)
cmdq_fire_command(struct cmdq_item *item)
{
struct client *c = cmdq->client;
struct cmd *cmd = cmdq->cmd;
struct client *c = item->client;
struct cmd *cmd = item->cmd;
enum cmd_retval retval;
const char *name;
struct cmd_find_state *fsp, fs;
int flags;
flags = !!(cmd->flags & CMD_CONTROL);
cmdq_guard(cmdq, "begin", flags);
cmdq_guard(item, "begin", flags);
if (cmd_prepare_state(cmd, cmdq) != 0) {
if (cmd_prepare_state(cmd, item) != 0) {
retval = CMD_RETURN_ERROR;
goto out;
}
if (cmdq->client == NULL)
cmdq->client = cmd_find_client(cmdq, NULL, CMD_FIND_QUIET);
if (item->client == NULL)
item->client = cmd_find_client(item, NULL, CMD_FIND_QUIET);
retval = cmd->entry->exec(cmd, cmdq);
retval = cmd->entry->exec(cmd, item);
if (retval == CMD_RETURN_ERROR)
goto out;
if (cmd->entry->flags & CMD_AFTERHOOK) {
name = cmd->entry->name;
if (cmd_find_valid_state(&cmdq->state.tflag))
fsp = &cmdq->state.tflag;
if (cmd_find_valid_state(&item->state.tflag))
fsp = &item->state.tflag;
else {
if (cmd_find_current(&fs, cmdq, CMD_FIND_QUIET) != 0)
if (cmd_find_current(&fs, item, CMD_FIND_QUIET) != 0)
goto out;
fsp = &fs;
}
hooks_insert(fsp->s->hooks, cmdq, fsp, "after-%s", name);
hooks_insert(fsp->s->hooks, item, fsp, "after-%s", name);
}
out:
cmdq->client = c;
item->client = c;
if (retval == CMD_RETURN_ERROR)
cmdq_guard(cmdq, "error", flags);
cmdq_guard(item, "error", flags);
else
cmdq_guard(cmdq, "end", flags);
cmdq_guard(item, "end", flags);
return (retval);
}
/* Get a callback for the command queue. */
struct cmd_q *
cmdq_get_callback(cmd_q_cb cb, void *data)
struct cmdq_item *
cmdq_get_callback(cmdq_cb cb, void *data)
{
struct cmd_q *cmdq;
struct cmdq_item *item;
cmdq = xcalloc(1, sizeof *cmdq);
cmdq->type = CMD_Q_CALLBACK;
cmdq->group = 0;
cmdq->flags = 0;
item = xcalloc(1, sizeof *item);
item->type = CMDQ_CALLBACK;
item->group = 0;
item->flags = 0;
cmdq->cb = cb;
cmdq->data = data;
item->cb = cb;
item->data = data;
return (cmdq);
return (item);
}
/* Fire callback on callback queue. */
static enum cmd_retval
cmdq_fire_callback(struct cmd_q *cmdq)
cmdq_fire_callback(struct cmdq_item *item)
{
return (cmdq->cb(cmdq, cmdq->data));
return (item->cb(item, item->data));
}
/* Add a format to command queue. */
void
cmdq_format(struct cmdq_item *item, const char *key, const char *fmt, ...)
{
va_list ap;
struct cmdq_item *loop;
char *value;
va_start(ap, fmt);
xvasprintf(&value, fmt, ap);
va_end(ap);
for (loop = item; loop != NULL; loop = item->next) {
if (loop->formats == NULL)
loop->formats = format_create(NULL, 0);
format_add(loop->formats, key, "%s", value);
}
free(value);
}
/* Process next item on command queue. */
u_int
cmdq_next(struct client *c)
{
struct cmd_q_list *queue = cmdq_get(c);
struct cmdq_list *queue = cmdq_get(c);
const char *name = cmdq_name(c);
struct cmd_q *cmdq;
struct cmdq_item *item;
enum cmd_retval retval;
u_int items = 0;
static u_int number;
@ -256,63 +279,63 @@ cmdq_next(struct client *c)
log_debug("%s %s: empty", __func__, name);
return (0);
}
if (TAILQ_FIRST(queue)->flags & CMD_Q_WAITING) {
if (TAILQ_FIRST(queue)->flags & CMDQ_WAITING) {
log_debug("%s %s: waiting", __func__, name);
return (0);
}
log_debug("%s %s: enter", __func__, name);
for (;;) {
cmdq = TAILQ_FIRST(queue);
if (cmdq == NULL)
item = TAILQ_FIRST(queue);
if (item == NULL)
break;
log_debug("%s %s: type %d, flags %x", __func__, name,
cmdq->type, cmdq->flags);
item->type, item->flags);
/*
* Any item with the waiting flag set waits until an external
* event clears the flag (for example, a job - look at
* run-shell).
*/
if (cmdq->flags & CMD_Q_WAITING)
if (item->flags & CMDQ_WAITING)
goto waiting;
/*
* Items are only fired once, once the fired flag is set, a
* waiting flag can only be cleared by an external event.
*/
if (~cmdq->flags & CMD_Q_FIRED) {
cmdq->time = time(NULL);
cmdq->number = ++number;
if (~item->flags & CMDQ_FIRED) {
item->time = time(NULL);
item->number = ++number;
switch (cmdq->type)
switch (item->type)
{
case CMD_Q_COMMAND:
retval = cmdq_fire_command(cmdq);
case CMDQ_COMMAND:
retval = cmdq_fire_command(item);
/*
* If a command returns an error, remove any
* subsequent commands in the same group.
*/
if (retval == CMD_RETURN_ERROR)
cmdq_remove_group(cmdq);
cmdq_remove_group(item);
break;
case CMD_Q_CALLBACK:
retval = cmdq_fire_callback(cmdq);
case CMDQ_CALLBACK:
retval = cmdq_fire_callback(item);
break;
default:
retval = CMD_RETURN_ERROR;
break;
}
cmdq->flags |= CMD_Q_FIRED;
item->flags |= CMDQ_FIRED;
if (retval == CMD_RETURN_WAIT) {
cmdq->flags |= CMD_Q_WAITING;
item->flags |= CMDQ_WAITING;
goto waiting;
}
items++;
}
cmdq_remove(cmdq);
cmdq_remove(item);
}
log_debug("%s %s: exit (empty)", __func__, name);
@ -325,23 +348,23 @@ waiting:
/* Print a guard line. */
void
cmdq_guard(struct cmd_q *cmdq, const char *guard, int flags)
cmdq_guard(struct cmdq_item *item, const char *guard, int flags)
{
struct client *c = cmdq->client;
struct client *c = item->client;
if (c == NULL || !(c->flags & CLIENT_CONTROL))
return;
evbuffer_add_printf(c->stdout_data, "%%%s %ld %u %d\n", guard,
(long)cmdq->time, cmdq->number, flags);
(long)item->time, item->number, flags);
server_client_push_stdout(c);
}
/* Show message from command. */
void
cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
cmdq_print(struct cmdq_item *item, const char *fmt, ...)
{
struct client *c = cmdq->client;
struct client *c = item->client;
struct window *w;
va_list ap;
char *tmp, *msg;
@ -376,10 +399,10 @@ cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
/* Show error from command. */
void
cmdq_error(struct cmd_q *cmdq, const char *fmt, ...)
cmdq_error(struct cmdq_item *item, const char *fmt, ...)
{
struct client *c = cmdq->client;
struct cmd *cmd = cmdq->cmd;
struct client *c = item->client;
struct cmd *cmd = item->cmd;
va_list ap;
char *msg;
size_t msglen;

14
cmd-refresh-client.c
View File

@ -24,7 +24,7 @@
* Refresh client.
*/
static enum cmd_retval cmd_refresh_client_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_refresh_client_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_refresh_client_entry = {
.name = "refresh-client",
@ -40,29 +40,29 @@ const struct cmd_entry cmd_refresh_client_entry = {
};
static enum cmd_retval
cmd_refresh_client_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_refresh_client_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c = cmdq->state.c;
struct client *c = item->state.c;
const char *size;
u_int w, h;
if (args_has(args, 'C')) {
if ((size = args_get(args, 'C')) == NULL) {
cmdq_error(cmdq, "missing size");
cmdq_error(item, "missing size");
return (CMD_RETURN_ERROR);
}
if (sscanf(size, "%u,%u", &w, &h) != 2) {
cmdq_error(cmdq, "bad size argument");
cmdq_error(item, "bad size argument");
return (CMD_RETURN_ERROR);
}
if (w < PANE_MINIMUM || w > 5000 ||
h < PANE_MINIMUM || h > 5000) {
cmdq_error(cmdq, "size too small or too big");
cmdq_error(item, "size too small or too big");
return (CMD_RETURN_ERROR);
}
if (!(c->flags & CLIENT_CONTROL)) {
cmdq_error(cmdq, "not a control client");
cmdq_error(item, "not a control client");
return (CMD_RETURN_ERROR);
}
if (tty_set_size(&c->tty, w, h))

11
cmd-rename-session.c
View File

@ -26,7 +26,8 @@
* Change session name.
*/
static enum cmd_retval cmd_rename_session_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_rename_session_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_rename_session_entry = {
.name = "rename-session",
@ -42,19 +43,19 @@ const struct cmd_entry cmd_rename_session_entry = {
};
static enum cmd_retval
cmd_rename_session_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_rename_session_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct session *s = cmdq->state.tflag.s;
struct session *s = item->state.tflag.s;
const char *newname;
newname = args->argv[0];
if (!session_check_name(newname)) {
cmdq_error(cmdq, "bad session name: %s", newname);
cmdq_error(item, "bad session name: %s", newname);
return (CMD_RETURN_ERROR);
}
if (session_find(newname) != NULL) {
cmdq_error(cmdq, "duplicate session: %s", newname);
cmdq_error(item, "duplicate session: %s", newname);
return (CMD_RETURN_ERROR);
}

7
cmd-rename-window.c
View File

@ -26,7 +26,8 @@
* Rename a window.
*/
static enum cmd_retval cmd_rename_window_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_rename_window_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_rename_window_entry = {
.name = "rename-window",
@ -42,10 +43,10 @@ const struct cmd_entry cmd_rename_window_entry = {
};
static enum cmd_retval
cmd_rename_window_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_rename_window_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct winlink *wl = cmdq->state.tflag.wl;
struct winlink *wl = item->state.tflag.wl;
window_set_name(wl->window, args->argv[0]);
options_set_number(wl->window->options, "automatic-rename", 0);

22
cmd-resize-pane.c
View File

@ -26,7 +26,7 @@
* Increase or decrease pane size.
*/
static enum cmd_retval cmd_resize_pane_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_resize_pane_exec(struct cmd *, struct cmdq_item *);
static void cmd_resize_pane_mouse_update(struct client *,
struct mouse_event *);
@ -46,26 +46,26 @@ const struct cmd_entry cmd_resize_pane_entry = {
};
static enum cmd_retval
cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_resize_pane_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct window_pane *wp = cmdq->state.tflag.wp;
struct winlink *wl = cmdq->state.tflag.wl;
struct window_pane *wp = item->state.tflag.wp;
struct winlink *wl = item->state.tflag.wl;
struct window *w = wl->window;
struct client *c = cmdq->client;
struct session *s = cmdq->state.tflag.s;
struct client *c = item->client;
struct session *s = item->state.tflag.s;
const char *errstr;
char *cause;
u_int adjust;
int x, y;
if (args_has(args, 'M')) {
if (cmd_mouse_window(&cmdq->mouse, &s) == NULL)
if (cmd_mouse_window(&item->mouse, &s) == NULL)
return (CMD_RETURN_NORMAL);
if (c == NULL || c->session != s)
return (CMD_RETURN_NORMAL);
c->tty.mouse_drag_update = cmd_resize_pane_mouse_update;
cmd_resize_pane_mouse_update(c, &cmdq->mouse);
cmd_resize_pane_mouse_update(c, &item->mouse);
return (CMD_RETURN_NORMAL);
}
@ -85,7 +85,7 @@ cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
else {
adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr);
if (errstr != NULL) {
cmdq_error(cmdq, "adjustment %s", errstr);
cmdq_error(item, "adjustment %s", errstr);
return (CMD_RETURN_ERROR);
}
}
@ -94,7 +94,7 @@ cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
x = args_strtonum(self->args, 'x', PANE_MINIMUM, INT_MAX,
&cause);
if (cause != NULL) {
cmdq_error(cmdq, "width %s", cause);
cmdq_error(item, "width %s", cause);
free(cause);
return (CMD_RETURN_ERROR);
}
@ -104,7 +104,7 @@ cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
y = args_strtonum(self->args, 'y', PANE_MINIMUM, INT_MAX,
&cause);
if (cause != NULL) {
cmdq_error(cmdq, "height %s", cause);
cmdq_error(item, "height %s", cause);
free(cause);
return (CMD_RETURN_ERROR);
}

18
cmd-respawn-pane.c
View File

@ -28,7 +28,7 @@
* Respawn a pane (restart the command). Kill existing if -k given.
*/
static enum cmd_retval cmd_respawn_pane_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_respawn_pane_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_respawn_pane_entry = {
.name = "respawn-pane",
@ -44,13 +44,13 @@ const struct cmd_entry cmd_respawn_pane_entry = {
};
static enum cmd_retval
cmd_respawn_pane_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_respawn_pane_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct winlink *wl = cmdq->state.tflag.wl;
struct winlink *wl = item->state.tflag.wl;
struct window *w = wl->window;
struct window_pane *wp = cmdq->state.tflag.wp;
struct session *s = cmdq->state.tflag.s;
struct window_pane *wp = item->state.tflag.wp;
struct session *s = item->state.tflag.s;
struct environ *env;
const char *path;
char *cause;
@ -60,7 +60,7 @@ cmd_respawn_pane_exec(struct cmd *self, struct cmd_q *cmdq)
if (!args_has(self->args, 'k') && wp->fd != -1) {
if (window_pane_index(wp, &idx) != 0)
fatalx("index not found");
cmdq_error(cmdq, "pane still active: %s:%d.%u",
cmdq_error(item, "pane still active: %s:%d.%u",
s->name, wl->idx, idx);
return (CMD_RETURN_ERROR);
}
@ -75,8 +75,8 @@ cmd_respawn_pane_exec(struct cmd *self, struct cmd_q *cmdq)
input_init(wp);
path = NULL;
if (cmdq->client != NULL && cmdq->client->session == NULL)
envent = environ_find(cmdq->client->environ, "PATH");
if (item->client != NULL && item->client->session == NULL)
envent = environ_find(item->client->environ, "PATH");
else
envent = environ_find(s->environ, "PATH");
if (envent != NULL)
@ -84,7 +84,7 @@ cmd_respawn_pane_exec(struct cmd *self, struct cmd_q *cmdq)
if (window_pane_spawn(wp, args->argc, args->argv, path, NULL, NULL, env,
s->tio, &cause) != 0) {
cmdq_error(cmdq, "respawn pane failed: %s", cause);
cmdq_error(item, "respawn pane failed: %s", cause);
free(cause);
environ_free(env);
return (CMD_RETURN_ERROR);

17
cmd-respawn-window.c
View File

@ -27,7 +27,8 @@
* Respawn a window (restart the command). Kill existing if -k given.
*/
static enum cmd_retval cmd_respawn_window_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_respawn_window_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_respawn_window_entry = {
.name = "respawn-window",
@ -43,11 +44,11 @@ const struct cmd_entry cmd_respawn_window_entry = {
};
static enum cmd_retval
cmd_respawn_window_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_respawn_window_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct session *s = cmdq->state.tflag.s;
struct winlink *wl = cmdq->state.tflag.wl;
struct session *s = item->state.tflag.s;
struct winlink *wl = item->state.tflag.wl;
struct window *w = wl->window;
struct window_pane *wp;
struct environ *env;
@ -59,7 +60,7 @@ cmd_respawn_window_exec(struct cmd *self, struct cmd_q *cmdq)
TAILQ_FOREACH(wp, &w->panes, entry) {
if (wp->fd == -1)
continue;
cmdq_error(cmdq, "window still active: %s:%d", s->name,
cmdq_error(item, "window still active: %s:%d", s->name,
wl->idx);
return (CMD_RETURN_ERROR);
}
@ -78,8 +79,8 @@ cmd_respawn_window_exec(struct cmd *self, struct cmd_q *cmdq)
window_pane_resize(wp, w->sx, w->sy);
path = NULL;
if (cmdq->client != NULL && cmdq->client->session == NULL)
envent = environ_find(cmdq->client->environ, "PATH");
if (item->client != NULL && item->client->session == NULL)
envent = environ_find(item->client->environ, "PATH");
else
envent = environ_find(s->environ, "PATH");
if (envent != NULL)
@ -87,7 +88,7 @@ cmd_respawn_window_exec(struct cmd *self, struct cmd_q *cmdq)
if (window_pane_spawn(wp, args->argc, args->argv, path, NULL, NULL, env,
s->tio, &cause) != 0) {
cmdq_error(cmdq, "respawn window failed: %s", cause);
cmdq_error(item, "respawn window failed: %s", cause);
free(cause);
environ_free(env);
server_destroy_pane(wp, 0);

7
cmd-rotate-window.c
View File

@ -24,7 +24,8 @@
* Rotate the panes in a window.
*/
static enum cmd_retval cmd_rotate_window_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_rotate_window_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_rotate_window_entry = {
.name = "rotate-window",
@ -40,9 +41,9 @@ const struct cmd_entry cmd_rotate_window_entry = {
};
static enum cmd_retval
cmd_rotate_window_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_rotate_window_exec(struct cmd *self, struct cmdq_item *item)
{
struct winlink *wl = cmdq->state.tflag.wl;
struct winlink *wl = item->state.tflag.wl;
struct window *w = wl->window;
struct window_pane *wp, *wp2;
struct layout_cell *lc;

32
cmd-run-shell.c
View File

@ -29,7 +29,7 @@
* Runs a command without a window.
*/
static enum cmd_retval cmd_run_shell_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_run_shell_exec(struct cmd *, struct cmdq_item *);
static void cmd_run_shell_callback(struct job *);
static void cmd_run_shell_free(void *);
@ -49,9 +49,9 @@ const struct cmd_entry cmd_run_shell_entry = {
};
struct cmd_run_shell_data {
char *cmd;
struct cmd_q *cmdq;
int wp_id;
char *cmd;
struct cmdq_item *item;
int wp_id;
};
static void
@ -63,7 +63,7 @@ cmd_run_shell_print(struct job *job, const char *msg)
if (cdata->wp_id != -1)
wp = window_pane_find_by_id(cdata->wp_id);
if (wp == NULL) {
cmdq_print(cdata->cmdq, "%s", msg);
cmdq_print(cdata->item, "%s", msg);
return;
}
@ -74,26 +74,26 @@ cmd_run_shell_print(struct job *job, const char *msg)
}
static enum cmd_retval
cmd_run_shell_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct cmd_run_shell_data *cdata;
char *shellcmd;
struct session *s = cmdq->state.tflag.s;
struct winlink *wl = cmdq->state.tflag.wl;
struct window_pane *wp = cmdq->state.tflag.wp;
struct session *s = item->state.tflag.s;
struct winlink *wl = item->state.tflag.wl;
struct window_pane *wp = item->state.tflag.wp;
struct format_tree *ft;
const char *cwd;
if (cmdq->client != NULL && cmdq->client->session == NULL)
cwd = cmdq->client->cwd;
if (item->client != NULL && item->client->session == NULL)
cwd = item->client->cwd;
else if (s != NULL)
cwd = s->cwd;
else
cwd = NULL;
ft = format_create(cmdq, 0);
format_defaults(ft, cmdq->state.c, s, wl, wp);
ft = format_create(item, 0);
format_defaults(ft, item->state.c, s, wl, wp);
shellcmd = format_expand(ft, args->argv[0]);
format_free(ft);
@ -111,7 +111,7 @@ cmd_run_shell_exec(struct cmd *self, struct cmd_q *cmdq)
cdata->wp_id = -1;
if (!args_has(args, 'b'))
cdata->cmdq = cmdq;
cdata->item = item;
job_run(shellcmd, s, cwd, cmd_run_shell_callback, cmd_run_shell_free,
cdata);
@ -163,8 +163,8 @@ cmd_run_shell_callback(struct job *job)
cmd_run_shell_print(job, msg);
free(msg);
if (cdata->cmdq != NULL)
cdata->cmdq->flags &= ~CMD_Q_WAITING;
if (cdata->item != NULL)
cdata->item->flags &= ~CMDQ_WAITING;
}
static void

22
cmd-save-buffer.c
View File

@ -31,7 +31,7 @@
* Saves a paste buffer to a file.
*/
static enum cmd_retval cmd_save_buffer_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_save_buffer_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_save_buffer_entry = {
.name = "save-buffer",
@ -56,10 +56,10 @@ const struct cmd_entry cmd_show_buffer_entry = {
};
static enum cmd_retval
cmd_save_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_save_buffer_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c = cmdq->client;
struct client *c = item->client;
struct session *s;
struct paste_buffer *pb;
const char *path, *bufname, *bufdata, *start, *end, *cwd;
@ -70,14 +70,14 @@ cmd_save_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
if (!args_has(args, 'b')) {
if ((pb = paste_get_top(NULL)) == NULL) {
cmdq_error(cmdq, "no buffers");
cmdq_error(item, "no buffers");
return (CMD_RETURN_ERROR);
}
} else {
bufname = args_get(args, 'b');
pb = paste_get_name(bufname);
if (pb == NULL) {
cmdq_error(cmdq, "no buffer %s", bufname);
cmdq_error(item, "no buffer %s", bufname);
return (CMD_RETURN_ERROR);
}
}
@ -89,7 +89,7 @@ cmd_save_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
path = args->argv[0];
if (strcmp(path, "-") == 0) {
if (c == NULL) {
cmdq_error(cmdq, "can't write to stdout");
cmdq_error(item, "can't write to stdout");
return (CMD_RETURN_ERROR);
}
if (c->session == NULL || (c->flags & CLIENT_CONTROL))
@ -114,18 +114,18 @@ cmd_save_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
xasprintf(&file, "%s/%s", cwd, path);
if (realpath(file, resolved) == NULL &&
strlcpy(resolved, file, sizeof resolved) >= sizeof resolved) {
cmdq_error(cmdq, "%s: %s", file, strerror(ENAMETOOLONG));
cmdq_error(item, "%s: %s", file, strerror(ENAMETOOLONG));
return (CMD_RETURN_ERROR);
}
f = fopen(resolved, flags);
free(file);
if (f == NULL) {
cmdq_error(cmdq, "%s: %s", resolved, strerror(errno));
cmdq_error(item, "%s: %s", resolved, strerror(errno));
return (CMD_RETURN_ERROR);
}
if (fwrite(bufdata, 1, bufsize, f) != bufsize) {
cmdq_error(cmdq, "%s: write error", resolved);
cmdq_error(item, "%s: write error", resolved);
fclose(f);
return (CMD_RETURN_ERROR);
}
@ -140,7 +140,7 @@ do_stdout:
do_print:
if (bufsize > (INT_MAX / 4) - 1) {
cmdq_error(cmdq, "buffer too big");
cmdq_error(item, "buffer too big");
return (CMD_RETURN_ERROR);
}
msg = NULL;
@ -158,7 +158,7 @@ do_print:
msg = xrealloc(msg, msglen);
strvisx(msg, start, size, VIS_OCTAL|VIS_TAB);
cmdq_print(cmdq, "%s", msg);
cmdq_print(item, "%s", msg);
used += size + (end != NULL);
}

9
cmd-select-layout.c
View File

@ -26,7 +26,8 @@
* Switch window to selected layout.
*/
static enum cmd_retval cmd_select_layout_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_select_layout_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_select_layout_entry = {
.name = "select-layout",
@ -68,10 +69,10 @@ const struct cmd_entry cmd_previous_layout_entry = {
};
static enum cmd_retval
cmd_select_layout_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_select_layout_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct winlink *wl = cmdq->state.tflag.wl;
struct winlink *wl = item->state.tflag.wl;
struct window *w;
const char *layoutname;
char *oldlayout;
@ -118,7 +119,7 @@ cmd_select_layout_exec(struct cmd *self, struct cmd_q *cmdq)
if (layoutname != NULL) {
if (layout_parse(w, layoutname) == -1) {
cmdq_error(cmdq, "can't set layout: %s", layoutname);
cmdq_error(item, "can't set layout: %s", layoutname);
goto error;
}
goto changed;

18
cmd-select-pane.c
View File

@ -24,7 +24,7 @@
* Select pane.
*/
static enum cmd_retval cmd_select_pane_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_select_pane_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_select_pane_entry = {
.name = "select-pane",
@ -53,19 +53,19 @@ const struct cmd_entry cmd_last_pane_entry = {
};
static enum cmd_retval
cmd_select_pane_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_select_pane_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct winlink *wl = cmdq->state.tflag.wl;
struct winlink *wl = item->state.tflag.wl;
struct window *w = wl->window;
struct session *s = cmdq->state.tflag.s;
struct window_pane *wp = cmdq->state.tflag.wp, *lastwp, *markedwp;
struct session *s = item->state.tflag.s;
struct window_pane *wp = item->state.tflag.wp, *lastwp, *markedwp;
const char *style;
if (self->entry == &cmd_last_pane_entry || args_has(args, 'l')) {
if (wl->window->last == NULL) {
cmdq_error(cmdq, "no last pane");
cmdq_error(item, "no last pane");
return (CMD_RETURN_ERROR);
}
@ -112,13 +112,13 @@ cmd_select_pane_exec(struct cmd *self, struct cmd_q *cmdq)
style = args_get(args, 'P');
if (style_parse(&grid_default_cell, &wp->colgc,
style) == -1) {
cmdq_error(cmdq, "bad style: %s", style);
cmdq_error(item, "bad style: %s", style);
return (CMD_RETURN_ERROR);
}
wp->flags |= PANE_REDRAW;
}
if (args_has(self->args, 'g'))
cmdq_print(cmdq, "%s", style_tostring(&wp->colgc));
cmdq_print(item, "%s", style_tostring(&wp->colgc));
return (CMD_RETURN_NORMAL);
}
@ -151,7 +151,7 @@ cmd_select_pane_exec(struct cmd *self, struct cmd_q *cmdq)
return (CMD_RETURN_NORMAL);
server_unzoom_window(wp->window);
if (!window_pane_visible(wp)) {
cmdq_error(cmdq, "pane not visible");
cmdq_error(item, "pane not visible");
return (CMD_RETURN_ERROR);
}
window_redraw_active_switch(w, wp);

17
cmd-select-window.c
View File

@ -26,7 +26,8 @@
* Select window by index.
*/
static enum cmd_retval cmd_select_window_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_select_window_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_select_window_entry = {
.name = "select-window",
@ -81,10 +82,10 @@ const struct cmd_entry cmd_last_window_entry = {
};
static enum cmd_retval
cmd_select_window_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_select_window_exec(struct cmd *self, struct cmdq_item *item)
{
struct winlink *wl = cmdq->state.tflag.wl;
struct session *s = cmdq->state.tflag.s;
struct winlink *wl = item->state.tflag.wl;
struct session *s = item->state.tflag.s;
int next, previous, last, activity;
next = self->entry == &cmd_next_window_entry;
@ -101,17 +102,17 @@ cmd_select_window_exec(struct cmd *self, struct cmd_q *cmdq)
activity = args_has(self->args, 'a');
if (next) {
if (session_next(s, activity) != 0) {
cmdq_error(cmdq, "no next window");
cmdq_error(item, "no next window");
return (CMD_RETURN_ERROR);
}
} else if (previous) {
if (session_previous(s, activity) != 0) {
cmdq_error(cmdq, "no previous window");
cmdq_error(item, "no previous window");
return (CMD_RETURN_ERROR);
}
} else {
if (session_last(s) != 0) {
cmdq_error(cmdq, "no last window");
cmdq_error(item, "no last window");
return (CMD_RETURN_ERROR);
}
}
@ -124,7 +125,7 @@ cmd_select_window_exec(struct cmd *self, struct cmd_q *cmdq)
*/
if (args_has(self->args, 'T') && wl == s->curw) {
if (session_last(s) != 0) {
cmdq_error(cmdq, "no last window");
cmdq_error(item, "no last window");
return (-1);
}
server_redraw_session(s);

20
cmd-send-keys.c
View File

@ -27,7 +27,7 @@
* Send keys to client.
*/
static enum cmd_retval cmd_send_keys_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_send_keys_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_send_keys_entry = {
.name = "send-keys",
@ -56,13 +56,13 @@ const struct cmd_entry cmd_send_prefix_entry = {
};
static enum cmd_retval
cmd_send_keys_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c = cmdq->state.c;
struct window_pane *wp = cmdq->state.tflag.wp;
struct session *s = cmdq->state.tflag.s;
struct mouse_event *m = &cmdq->mouse;
struct client *c = item->state.c;
struct window_pane *wp = item->state.tflag.wp;
struct session *s = item->state.tflag.s;
struct mouse_event *m = &item->mouse;
const u_char *keystr;
int i, literal;
key_code key;
@ -71,12 +71,12 @@ cmd_send_keys_exec(struct cmd *self, struct cmd_q *cmdq)
if (args_has(args, 'N')) {
if (wp->mode == NULL || wp->mode->command == NULL) {
cmdq_error(cmdq, "not in a mode");
cmdq_error(item, "not in a mode");
return (CMD_RETURN_ERROR);
}
np = args_strtonum(args, 'N', 1, UINT_MAX, &cause);
if (cause != NULL) {
cmdq_error(cmdq, "prefix %s", cause);
cmdq_error(item, "prefix %s", cause);
free(cause);
return (CMD_RETURN_ERROR);
}
@ -85,7 +85,7 @@ cmd_send_keys_exec(struct cmd *self, struct cmd_q *cmdq)
if (args_has(args, 'X')) {
if (wp->mode == NULL || wp->mode->command == NULL) {
cmdq_error(cmdq, "not in a mode");
cmdq_error(item, "not in a mode");
return (CMD_RETURN_ERROR);
}
if (!m->valid)
@ -101,7 +101,7 @@ cmd_send_keys_exec(struct cmd *self, struct cmd_q *cmdq)
if (args_has(args, 'M')) {
wp = cmd_mouse_pane(m, &s, NULL);
if (wp == NULL) {
cmdq_error(cmdq, "no mouse target");
cmdq_error(item, "no mouse target");
return (CMD_RETURN_ERROR);
}
window_pane_key(wp, NULL, s, m->key, m);

14
cmd-set-buffer.c
View File

@ -27,7 +27,7 @@
* Add, set, append to or delete a paste buffer.
*/
static enum cmd_retval cmd_set_buffer_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_set_buffer_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_set_buffer_entry = {
.name = "set-buffer",
@ -52,7 +52,7 @@ const struct cmd_entry cmd_delete_buffer_entry = {
};
static enum cmd_retval
cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_set_buffer_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct paste_buffer *pb;
@ -70,7 +70,7 @@ cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
if (pb == NULL)
pb = paste_get_top(&bufname);
if (pb == NULL) {
cmdq_error(cmdq, "no buffer");
cmdq_error(item, "no buffer");
return (CMD_RETURN_ERROR);
}
paste_free(pb);
@ -81,11 +81,11 @@ cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
if (pb == NULL)
pb = paste_get_top(&bufname);
if (pb == NULL) {
cmdq_error(cmdq, "no buffer");
cmdq_error(item, "no buffer");
return (CMD_RETURN_ERROR);
}
if (paste_rename(bufname, args_get(args, 'n'), &cause) != 0) {
cmdq_error(cmdq, "%s", cause);
cmdq_error(item, "%s", cause);
free(cause);
return (CMD_RETURN_ERROR);
}
@ -93,7 +93,7 @@ cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
}
if (args->argc != 1) {
cmdq_error(cmdq, "no data specified");
cmdq_error(item, "no data specified");
return (CMD_RETURN_ERROR);
}
if ((newsize = strlen(args->argv[0])) == 0)
@ -113,7 +113,7 @@ cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
bufsize += newsize;
if (paste_set(bufdata, bufsize, bufname, &cause) != 0) {
cmdq_error(cmdq, "%s", cause);
cmdq_error(item, "%s", cause);
free(bufdata);
free(cause);
return (CMD_RETURN_ERROR);

23
cmd-set-environment.c
View File

@ -27,7 +27,8 @@
* Set an environment variable.
*/
static enum cmd_retval cmd_set_environment_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_set_environment_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_set_environment_entry = {
.name = "set-environment",
@ -43,7 +44,7 @@ const struct cmd_entry cmd_set_environment_entry = {
};
static enum cmd_retval
cmd_set_environment_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_set_environment_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct environ *env;
@ -51,11 +52,11 @@ cmd_set_environment_exec(struct cmd *self, struct cmd_q *cmdq)
name = args->argv[0];
if (*name == '\0') {
cmdq_error(cmdq, "empty variable name");
cmdq_error(item, "empty variable name");
return (CMD_RETURN_ERROR);
}
if (strchr(name, '=') != NULL) {
cmdq_error(cmdq, "variable name contains =");
cmdq_error(item, "variable name contains =");
return (CMD_RETURN_ERROR);
}
@ -67,32 +68,32 @@ cmd_set_environment_exec(struct cmd *self, struct cmd_q *cmdq)
if (args_has(self->args, 'g'))
env = global_environ;
else {
if (cmdq->state.tflag.s == NULL) {
if (item->state.tflag.s == NULL) {
target = args_get(args, 't');
if (target != NULL)
cmdq_error(cmdq, "no such session: %s", target);
cmdq_error(item, "no such session: %s", target);
else
cmdq_error(cmdq, "no current session");
cmdq_error(item, "no current session");
return (CMD_RETURN_ERROR);
}
env = cmdq->state.tflag.s->environ;
env = item->state.tflag.s->environ;
}
if (args_has(self->args, 'u')) {
if (value != NULL) {
cmdq_error(cmdq, "can't specify a value with -u");
cmdq_error(item, "can't specify a value with -u");
return (CMD_RETURN_ERROR);
}
environ_unset(env, name);
} else if (args_has(self->args, 'r')) {
if (value != NULL) {
cmdq_error(cmdq, "can't specify a value with -r");
cmdq_error(item, "can't specify a value with -r");
return (CMD_RETURN_ERROR);
}
environ_clear(env, name);
} else {
if (value == NULL) {
cmdq_error(cmdq, "no value specified");
cmdq_error(item, "no value specified");
return (CMD_RETURN_ERROR);
}
environ_set(env, name, "%s", value);

22
cmd-set-hook.c
View File

@ -27,7 +27,7 @@
* Set or show global or session hooks.
*/
static enum cmd_retval cmd_set_hook_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_set_hook_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_set_hook_entry = {
.name = "set-hook",
@ -56,7 +56,7 @@ const struct cmd_entry cmd_show_hooks_entry = {
};
static enum cmd_retval
cmd_set_hook_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_set_hook_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct cmd_list *cmdlist;
@ -68,22 +68,22 @@ cmd_set_hook_exec(struct cmd *self, struct cmd_q *cmdq)
if (args_has(args, 'g'))
hooks = global_hooks;
else {
if (cmdq->state.tflag.s == NULL) {
if (item->state.tflag.s == NULL) {
target = args_get(args, 't');
if (target != NULL)
cmdq_error(cmdq, "no such session: %s", target);
cmdq_error(item, "no such session: %s", target);
else
cmdq_error(cmdq, "no current session");
cmdq_error(item, "no current session");
return (CMD_RETURN_ERROR);
}
hooks = cmdq->state.tflag.s->hooks;
hooks = item->state.tflag.s->hooks;
}
if (self->entry == &cmd_show_hooks_entry) {
hook = hooks_first(hooks);
while (hook != NULL) {
tmp = cmd_list_print(hook->cmdlist);
cmdq_print(cmdq, "%s -> %s", hook->name, tmp);
cmdq_print(item, "%s -> %s", hook->name, tmp);
free(tmp);
hook = hooks_next(hook);
@ -93,7 +93,7 @@ cmd_set_hook_exec(struct cmd *self, struct cmd_q *cmdq)
name = args->argv[0];
if (*name == '\0') {
cmdq_error(cmdq, "invalid hook name");
cmdq_error(item, "invalid hook name");
return (CMD_RETURN_ERROR);
}
if (args->argc < 2)
@ -103,7 +103,7 @@ cmd_set_hook_exec(struct cmd *self, struct cmd_q *cmdq)
if (args_has(args, 'u')) {
if (cmd != NULL) {
cmdq_error(cmdq, "command passed to unset hook: %s",
cmdq_error(item, "command passed to unset hook: %s",
name);
return (CMD_RETURN_ERROR);
}
@ -112,12 +112,12 @@ cmd_set_hook_exec(struct cmd *self, struct cmd_q *cmdq)
}
if (cmd == NULL) {
cmdq_error(cmdq, "no command to set hook: %s", name);
cmdq_error(item, "no command to set hook: %s", name);
return (CMD_RETURN_ERROR);
}
if (cmd_string_parse(cmd, &cmdlist, NULL, 0, &cause) != 0) {
if (cause != NULL) {
cmdq_error(cmdq, "%s", cause);
cmdq_error(item, "%s", cause);
free(cause);
}
return (CMD_RETURN_ERROR);

166
cmd-set-option.c
View File

@ -27,42 +27,42 @@
* Set an option.
*/
static enum cmd_retval cmd_set_option_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_set_option_exec(struct cmd *, struct cmdq_item *);
static enum cmd_retval cmd_set_option_user(struct cmd *, struct cmd_q *,
const char *, const char *);
static enum cmd_retval cmd_set_option_user(struct cmd *, struct cmdq_item *,
const char *, const char *);
static int cmd_set_option_unset(struct cmd *, struct cmd_q *,
static int cmd_set_option_unset(struct cmd *, struct cmdq_item *,
const struct options_table_entry *, struct options *,
const char *);
static int cmd_set_option_set(struct cmd *, struct cmd_q *,
static int cmd_set_option_set(struct cmd *, struct cmdq_item *,
const struct options_table_entry *, struct options *,
const char *);
static struct options_entry *cmd_set_option_string(struct cmd *, struct cmd_q *,
const struct options_table_entry *, struct options *,
const char *);
static struct options_entry *cmd_set_option_number(struct cmd *, struct cmd_q *,
const struct options_table_entry *, struct options *,
const char *);
static struct options_entry *cmd_set_option_key(struct cmd *, struct cmd_q *,
const struct options_table_entry *, struct options *,
const char *);
static struct options_entry *cmd_set_option_colour(struct cmd *, struct cmd_q *,
const struct options_table_entry *, struct options *,
const char *);
static struct options_entry *cmd_set_option_attributes(struct cmd *,
struct cmd_q *, const struct options_table_entry *,
static struct options_entry *cmd_set_option_string(struct cmd *,
struct cmdq_item *, const struct options_table_entry *,
struct options *, const char *);
static struct options_entry *cmd_set_option_number(struct cmd *,
struct cmdq_item *, const struct options_table_entry *,
struct options *, const char *);
static struct options_entry *cmd_set_option_key(struct cmd *,
struct cmdq_item *, const struct options_table_entry *,
struct options *, const char *);
static struct options_entry *cmd_set_option_colour(struct cmd *,
struct cmdq_item *, const struct options_table_entry *,
struct options *, const char *);
static struct options_entry *cmd_set_option_attributes(struct cmd *,
struct cmdq_item *, const struct options_table_entry *,
struct options *, const char *);
static struct options_entry *cmd_set_option_flag(struct cmd *,
struct cmdq_item *, const struct options_table_entry *,
struct options *, const char *);
static struct options_entry *cmd_set_option_choice(struct cmd *,
struct cmdq_item *, const struct options_table_entry *,
struct options *, const char *);
static struct options_entry *cmd_set_option_style(struct cmd *,
struct cmdq_item *, const struct options_table_entry *,
struct options *, const char *);
static struct options_entry *cmd_set_option_flag(struct cmd *, struct cmd_q *,
const struct options_table_entry *, struct options *,
const char *);
static struct options_entry *cmd_set_option_choice(struct cmd *, struct cmd_q *,
const struct options_table_entry *, struct options *,
const char *);
static struct options_entry *cmd_set_option_style(struct cmd *, struct cmd_q *,
const struct options_table_entry *, struct options *,
const char *);
const struct cmd_entry cmd_set_option_entry = {
.name = "set-option",
@ -91,11 +91,11 @@ const struct cmd_entry cmd_set_window_option_entry = {
};
static enum cmd_retval
cmd_set_option_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct session *s = cmdq->state.tflag.s;
struct winlink *wl = cmdq->state.tflag.wl;
struct session *s = item->state.tflag.s;
struct winlink *wl = item->state.tflag.wl;
struct window *w;
struct client *c;
const struct options_table_entry *oe;
@ -105,7 +105,7 @@ cmd_set_option_exec(struct cmd *self, struct cmd_q *cmdq)
/* Get the option name and value. */
optstr = args->argv[0];
if (*optstr == '\0') {
cmdq_error(cmdq, "invalid option");
cmdq_error(item, "invalid option");
return (CMD_RETURN_ERROR);
}
if (args->argc < 2)
@ -115,20 +115,20 @@ cmd_set_option_exec(struct cmd *self, struct cmd_q *cmdq)
/* Is this a user option? */
if (*optstr == '@')
return (cmd_set_option_user(self, cmdq, optstr, valstr));
return (cmd_set_option_user(self, item, optstr, valstr));
/* Find the option entry, try each table. */
oe = NULL;
if (options_table_find(optstr, &oe) != 0) {
if (!args_has(args, 'q')) {
cmdq_error(cmdq, "ambiguous option: %s", optstr);
cmdq_error(item, "ambiguous option: %s", optstr);
return (CMD_RETURN_ERROR);
}
return (CMD_RETURN_NORMAL);
}
if (oe == NULL) {
if (!args_has(args, 'q')) {
cmdq_error(cmdq, "unknown option: %s", optstr);
cmdq_error(item, "unknown option: %s", optstr);
return (CMD_RETURN_ERROR);
}
return (CMD_RETURN_NORMAL);
@ -143,10 +143,10 @@ cmd_set_option_exec(struct cmd *self, struct cmd_q *cmdq)
else if (wl == NULL) {
target = args_get(args, 't');
if (target != NULL) {
cmdq_error(cmdq, "no such window: %s",
cmdq_error(item, "no such window: %s",
target);
} else
cmdq_error(cmdq, "no current window");
cmdq_error(item, "no current window");
return (CMD_RETURN_ERROR);
} else
oo = wl->window->options;
@ -156,31 +156,31 @@ cmd_set_option_exec(struct cmd *self, struct cmd_q *cmdq)
else if (s == NULL) {
target = args_get(args, 't');
if (target != NULL) {
cmdq_error(cmdq, "no such session: %s",
cmdq_error(item, "no such session: %s",
target);
} else
cmdq_error(cmdq, "no current session");
cmdq_error(item, "no current session");
return (CMD_RETURN_ERROR);
} else
oo = s->options;
} else {
cmdq_error(cmdq, "unknown table");
cmdq_error(item, "unknown table");
return (CMD_RETURN_ERROR);
}
/* Unset or set the option. */
if (args_has(args, 'u')) {
if (cmd_set_option_unset(self, cmdq, oe, oo, valstr) != 0)
if (cmd_set_option_unset(self, item, oe, oo, valstr) != 0)
return (CMD_RETURN_ERROR);
} else {
if (args_has(args, 'o') && options_find1(oo, optstr) != NULL) {
if (!args_has(args, 'q')) {
cmdq_error(cmdq, "already set: %s", optstr);
cmdq_error(item, "already set: %s", optstr);
return (CMD_RETURN_ERROR);
}
return (CMD_RETURN_NORMAL);
}
if (cmd_set_option_set(self, cmdq, oe, oo, valstr) != 0)
if (cmd_set_option_set(self, item, oe, oo, valstr) != 0)
return (CMD_RETURN_ERROR);
}
@ -224,12 +224,12 @@ cmd_set_option_exec(struct cmd *self, struct cmd_q *cmdq)
/* Set user option. */
static enum cmd_retval
cmd_set_option_user(struct cmd *self, struct cmd_q *cmdq, const char *optstr,
const char *valstr)
cmd_set_option_user(struct cmd *self, struct cmdq_item *item,
const char *optstr, const char *valstr)
{
struct args *args = self->args;
struct session *s = cmdq->state.tflag.s;
struct winlink *wl = cmdq->state.tflag.wl;
struct session *s = item->state.tflag.s;
struct winlink *wl = item->state.tflag.wl;
struct options *oo;
struct options_entry *o;
const char *target;
@ -243,10 +243,10 @@ cmd_set_option_user(struct cmd *self, struct cmd_q *cmdq, const char *optstr,
else if (wl == NULL) {
target = args_get(args, 't');
if (target != NULL) {
cmdq_error(cmdq, "no such window: %s",
cmdq_error(item, "no such window: %s",
target);
} else
cmdq_error(cmdq, "no current window");
cmdq_error(item, "no current window");
return (CMD_RETURN_ERROR);
} else
oo = wl->window->options;
@ -256,10 +256,10 @@ cmd_set_option_user(struct cmd *self, struct cmd_q *cmdq, const char *optstr,
else if (s == NULL) {
target = args_get(args, 't');
if (target != NULL) {
cmdq_error(cmdq, "no such session: %s",
cmdq_error(item, "no such session: %s",
target);
} else
cmdq_error(cmdq, "no current session");
cmdq_error(item, "no current session");
return (CMD_RETURN_ERROR);
} else
oo = s->options;
@ -268,13 +268,13 @@ cmd_set_option_user(struct cmd *self, struct cmd_q *cmdq, const char *optstr,
if (args_has(args, 'u')) {
if (options_find1(oo, optstr) == NULL) {
if (!args_has(args, 'q')) {
cmdq_error(cmdq, "unknown option: %s", optstr);
cmdq_error(item, "unknown option: %s", optstr);
return (CMD_RETURN_ERROR);
}
return (CMD_RETURN_NORMAL);
}
if (valstr != NULL) {
cmdq_error(cmdq, "value passed to unset option: %s",
cmdq_error(item, "value passed to unset option: %s",
optstr);
return (CMD_RETURN_ERROR);
}
@ -283,13 +283,13 @@ cmd_set_option_user(struct cmd *self, struct cmd_q *cmdq, const char *optstr,
o = options_find1(oo, optstr);
if (args_has(args, 'o') && o != NULL) {
if (!args_has(args, 'q')) {
cmdq_error(cmdq, "already set: %s", optstr);
cmdq_error(item, "already set: %s", optstr);
return (CMD_RETURN_ERROR);
}
return (CMD_RETURN_NORMAL);
}
if (valstr == NULL) {
cmdq_error(cmdq, "empty value");
cmdq_error(item, "empty value");
return (CMD_RETURN_ERROR);
}
if (o != NULL && args_has(args, 'a'))
@ -302,14 +302,14 @@ cmd_set_option_user(struct cmd *self, struct cmd_q *cmdq, const char *optstr,
/* Unset an option. */
static int
cmd_set_option_unset(struct cmd *self, struct cmd_q *cmdq,
cmd_set_option_unset(struct cmd *self, struct cmdq_item *item,
const struct options_table_entry *oe, struct options *oo,
const char *value)
{
struct args *args = self->args;
if (value != NULL) {
cmdq_error(cmdq, "value passed to unset option: %s", oe->name);
cmdq_error(item, "value passed to unset option: %s", oe->name);
return (-1);
}
@ -332,7 +332,7 @@ cmd_set_option_unset(struct cmd *self, struct cmd_q *cmdq,
/* Set an option. */
static int
cmd_set_option_set(struct cmd *self, struct cmd_q *cmdq,
cmd_set_option_set(struct cmd *self, struct cmdq_item *item,
const struct options_table_entry *oe, struct options *oo,
const char *value)
{
@ -344,7 +344,7 @@ cmd_set_option_set(struct cmd *self, struct cmd_q *cmdq,
break;
default:
if (value == NULL) {
cmdq_error(cmdq, "empty value");
cmdq_error(item, "empty value");
return (-1);
}
}
@ -352,32 +352,32 @@ cmd_set_option_set(struct cmd *self, struct cmd_q *cmdq,
o = NULL;
switch (oe->type) {
case OPTIONS_TABLE_STRING:
o = cmd_set_option_string(self, cmdq, oe, oo, value);
o = cmd_set_option_string(self, item, oe, oo, value);
break;
case OPTIONS_TABLE_NUMBER:
o = cmd_set_option_number(self, cmdq, oe, oo, value);
o = cmd_set_option_number(self, item, oe, oo, value);
break;
case OPTIONS_TABLE_KEY:
o = cmd_set_option_key(self, cmdq, oe, oo, value);
o = cmd_set_option_key(self, item, oe, oo, value);
break;
case OPTIONS_TABLE_COLOUR:
o = cmd_set_option_colour(self, cmdq, oe, oo, value);
o = cmd_set_option_colour(self, item, oe, oo, value);
if (o != NULL)
style_update_new(oo, o->name, oe->style);
break;
case OPTIONS_TABLE_ATTRIBUTES:
o = cmd_set_option_attributes(self, cmdq, oe, oo, value);
o = cmd_set_option_attributes(self, item, oe, oo, value);
if (o != NULL)
style_update_new(oo, o->name, oe->style);
break;
case OPTIONS_TABLE_FLAG:
o = cmd_set_option_flag(self, cmdq, oe, oo, value);
o = cmd_set_option_flag(self, item, oe, oo, value);
break;
case OPTIONS_TABLE_CHOICE:
o = cmd_set_option_choice(self, cmdq, oe, oo, value);
o = cmd_set_option_choice(self, item, oe, oo, value);
break;
case OPTIONS_TABLE_STYLE:
o = cmd_set_option_style(self, cmdq, oe, oo, value);
o = cmd_set_option_style(self, item, oe, oo, value);
break;
}
if (o == NULL)
@ -387,7 +387,7 @@ cmd_set_option_set(struct cmd *self, struct cmd_q *cmdq,
/* Set a string option. */
static struct options_entry *
cmd_set_option_string(struct cmd *self, __unused struct cmd_q *cmdq,
cmd_set_option_string(struct cmd *self, __unused struct cmdq_item *item,
const struct options_table_entry *oe, struct options *oo,
const char *value)
{
@ -409,7 +409,7 @@ cmd_set_option_string(struct cmd *self, __unused struct cmd_q *cmdq,
/* Set a number option. */
static struct options_entry *
cmd_set_option_number(__unused struct cmd *self, struct cmd_q *cmdq,
cmd_set_option_number(__unused struct cmd *self, struct cmdq_item *item,
const struct options_table_entry *oe, struct options *oo,
const char *value)
{
@ -418,7 +418,7 @@ cmd_set_option_number(__unused struct cmd *self, struct cmd_q *cmdq,
ll = strtonum(value, oe->minimum, oe->maximum, &errstr);
if (errstr != NULL) {
cmdq_error(cmdq, "value is %s: %s", errstr, value);
cmdq_error(item, "value is %s: %s", errstr, value);
return (NULL);
}
@ -427,7 +427,7 @@ cmd_set_option_number(__unused struct cmd *self, struct cmd_q *cmdq,
/* Set a key option. */
static struct options_entry *
cmd_set_option_key(__unused struct cmd *self, struct cmd_q *cmdq,
cmd_set_option_key(__unused struct cmd *self, struct cmdq_item *item,
const struct options_table_entry *oe, struct options *oo,
const char *value)
{
@ -435,7 +435,7 @@ cmd_set_option_key(__unused struct cmd *self, struct cmd_q *cmdq,
key = key_string_lookup_string(value);
if (key == KEYC_UNKNOWN) {
cmdq_error(cmdq, "bad key: %s", value);
cmdq_error(item, "bad key: %s", value);
return (NULL);
}
@ -444,14 +444,14 @@ cmd_set_option_key(__unused struct cmd *self, struct cmd_q *cmdq,
/* Set a colour option. */
static struct options_entry *
cmd_set_option_colour(__unused struct cmd *self, struct cmd_q *cmdq,
cmd_set_option_colour(__unused struct cmd *self, struct cmdq_item *item,
const struct options_table_entry *oe, struct options *oo,
const char *value)
{
int colour;
if ((colour = colour_fromstring(value)) == -1) {
cmdq_error(cmdq, "bad colour: %s", value);
cmdq_error(item, "bad colour: %s", value);
return (NULL);
}
@ -460,14 +460,14 @@ cmd_set_option_colour(__unused struct cmd *self, struct cmd_q *cmdq,
/* Set an attributes option. */
static struct options_entry *
cmd_set_option_attributes(__unused struct cmd *self, struct cmd_q *cmdq,
cmd_set_option_attributes(__unused struct cmd *self, struct cmdq_item *item,
const struct options_table_entry *oe, struct options *oo,
const char *value)
{
int attr;
if ((attr = attributes_fromstring(value)) == -1) {
cmdq_error(cmdq, "bad attributes: %s", value);
cmdq_error(item, "bad attributes: %s", value);
return (NULL);
}
@ -476,7 +476,7 @@ cmd_set_option_attributes(__unused struct cmd *self, struct cmd_q *cmdq,
/* Set a flag option. */
static struct options_entry *
cmd_set_option_flag(__unused struct cmd *self, struct cmd_q *cmdq,
cmd_set_option_flag(__unused struct cmd *self, struct cmdq_item *item,
const struct options_table_entry *oe, struct options *oo,
const char *value)
{
@ -494,7 +494,7 @@ cmd_set_option_flag(__unused struct cmd *self, struct cmd_q *cmdq,
strcasecmp(value, "no") == 0)
flag = 0;
else {
cmdq_error(cmdq, "bad value: %s", value);
cmdq_error(item, "bad value: %s", value);
return (NULL);
}
}
@ -504,7 +504,7 @@ cmd_set_option_flag(__unused struct cmd *self, struct cmd_q *cmdq,
/* Set a choice option. */
static struct options_entry *
cmd_set_option_choice(__unused struct cmd *self, struct cmd_q *cmdq,
cmd_set_option_choice(__unused struct cmd *self, struct cmdq_item *item,
const struct options_table_entry *oe, struct options *oo,
const char *value)
{
@ -523,13 +523,13 @@ cmd_set_option_choice(__unused struct cmd *self, struct cmd_q *cmdq,
continue;
if (choice != -1) {
cmdq_error(cmdq, "ambiguous value: %s", value);
cmdq_error(item, "ambiguous value: %s", value);
return (NULL);
}
choice = n - 1;
}
if (choice == -1) {
cmdq_error(cmdq, "unknown value: %s", value);
cmdq_error(item, "unknown value: %s", value);
return (NULL);
}
}
@ -539,7 +539,7 @@ cmd_set_option_choice(__unused struct cmd *self, struct cmd_q *cmdq,
/* Set a style option. */
static struct options_entry *
cmd_set_option_style(struct cmd *self, struct cmd_q *cmdq,
cmd_set_option_style(struct cmd *self, struct cmdq_item *item,
const struct options_table_entry *oe, struct options *oo,
const char *value)
{
@ -549,7 +549,7 @@ cmd_set_option_style(struct cmd *self, struct cmd_q *cmdq,
append = args_has(args, 'a');
if ((o = options_set_style(oo, oe->name, value, append)) == NULL) {
cmdq_error(cmdq, "bad style: %s", value);
cmdq_error(item, "bad style: %s", value);
return (NULL);
}

35
cmd-show-environment.c
View File

@ -27,10 +27,11 @@
* Show environment.
*/
static enum cmd_retval cmd_show_environment_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_show_environment_exec(struct cmd *,
struct cmdq_item *);
static char *cmd_show_environment_escape(struct environ_entry *);
static void cmd_show_environment_print(struct cmd *, struct cmd_q *,
static void cmd_show_environment_print(struct cmd *, struct cmdq_item *,
struct environ_entry *);
const struct cmd_entry cmd_show_environment_entry = {
@ -65,30 +66,30 @@ cmd_show_environment_escape(struct environ_entry *envent)
}
static void
cmd_show_environment_print(struct cmd *self, struct cmd_q *cmdq,
cmd_show_environment_print(struct cmd *self, struct cmdq_item *item,
struct environ_entry *envent)
{
char *escaped;
if (!args_has(self->args, 's')) {
if (envent->value != NULL)
cmdq_print(cmdq, "%s=%s", envent->name, envent->value);
cmdq_print(item, "%s=%s", envent->name, envent->value);
else
cmdq_print(cmdq, "-%s", envent->name);
cmdq_print(item, "-%s", envent->name);
return;
}
if (envent->value != NULL) {
escaped = cmd_show_environment_escape(envent);
cmdq_print(cmdq, "%s=\"%s\"; export %s;", envent->name, escaped,
cmdq_print(item, "%s=\"%s\"; export %s;", envent->name, escaped,
envent->name);
free(escaped);
} else
cmdq_print(cmdq, "unset %s;", envent->name);
cmdq_print(item, "unset %s;", envent->name);
}
static enum cmd_retval
cmd_show_environment_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_show_environment_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct environ *env;
@ -96,8 +97,8 @@ cmd_show_environment_exec(struct cmd *self, struct cmd_q *cmdq)
const char *target;
if ((target = args_get(args, 't')) != NULL) {
if (cmdq->state.tflag.s == NULL) {
cmdq_error(cmdq, "no such session: %s", target);
if (item->state.tflag.s == NULL) {
cmdq_error(item, "no such session: %s", target);
return (CMD_RETURN_ERROR);
}
}
@ -105,30 +106,30 @@ cmd_show_environment_exec(struct cmd *self, struct cmd_q *cmdq)
if (args_has(self->args, 'g'))
env = global_environ;
else {
if (cmdq->state.tflag.s == NULL) {
if (item->state.tflag.s == NULL) {
target = args_get(args, 't');
if (target != NULL)
cmdq_error(cmdq, "no such session: %s", target);
cmdq_error(item, "no such session: %s", target);
else
cmdq_error(cmdq, "no current session");
cmdq_error(item, "no current session");
return (CMD_RETURN_ERROR);
}
env = cmdq->state.tflag.s->environ;
env = item->state.tflag.s->environ;
}
if (args->argc != 0) {
envent = environ_find(env, args->argv[0]);
if (envent == NULL) {
cmdq_error(cmdq, "unknown variable: %s", args->argv[0]);
cmdq_error(item, "unknown variable: %s", args->argv[0]);
return (CMD_RETURN_ERROR);
}
cmd_show_environment_print(self, cmdq, envent);
cmd_show_environment_print(self, item, envent);
return (CMD_RETURN_NORMAL);
}
envent = environ_first(env);
while (envent != NULL) {
cmd_show_environment_print(self, cmdq, envent);
cmd_show_environment_print(self, item, envent);
envent = environ_next(envent);
}
return (CMD_RETURN_NORMAL);

31
cmd-show-messages.c
View File

@ -28,7 +28,8 @@
* Show client message log.
*/
static enum cmd_retval cmd_show_messages_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_show_messages_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_show_messages_entry = {
.name = "show-messages",
@ -54,11 +55,11 @@ const struct cmd_entry cmd_server_info_entry = {
.exec = cmd_show_messages_exec
};
static int cmd_show_messages_terminals(struct cmd_q *, int);
static int cmd_show_messages_jobs(struct cmd_q *, int);
static int cmd_show_messages_terminals(struct cmdq_item *, int);
static int cmd_show_messages_jobs(struct cmdq_item *, int);
static int
cmd_show_messages_terminals(struct cmd_q *cmdq, int blank)
cmd_show_messages_terminals(struct cmdq_item *item, int blank)
{
struct tty_term *term;
u_int i, n;
@ -66,20 +67,20 @@ cmd_show_messages_terminals(struct cmd_q *cmdq, int blank)
n = 0;
LIST_FOREACH(term, &tty_terms, entry) {
if (blank) {
cmdq_print(cmdq, "%s", "");
cmdq_print(item, "%s", "");
blank = 0;
}
cmdq_print(cmdq, "Terminal %u: %s [references=%u, flags=0x%x]:",
cmdq_print(item, "Terminal %u: %s [references=%u, flags=0x%x]:",
n, term->name, term->references, term->flags);
n++;
for (i = 0; i < tty_term_ncodes(); i++)
cmdq_print(cmdq, "%s", tty_term_describe(term, i));
cmdq_print(item, "%s", tty_term_describe(term, i));
}
return (n != 0);
}
static int
cmd_show_messages_jobs(struct cmd_q *cmdq, int blank)
cmd_show_messages_jobs(struct cmdq_item *item, int blank)
{
struct job *job;
u_int n;
@ -87,10 +88,10 @@ cmd_show_messages_jobs(struct cmd_q *cmdq, int blank)
n = 0;
LIST_FOREACH(job, &all_jobs, lentry) {
if (blank) {
cmdq_print(cmdq, "%s", "");
cmdq_print(item, "%s", "");
blank = 0;
}
cmdq_print(cmdq, "Job %u: %s [fd=%d, pid=%d, status=%d]",
cmdq_print(item, "Job %u: %s [fd=%d, pid=%d, status=%d]",
n, job->cmd, job->fd, job->pid, job->status);
n++;
}
@ -98,21 +99,21 @@ cmd_show_messages_jobs(struct cmd_q *cmdq, int blank)
}
static enum cmd_retval
cmd_show_messages_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_show_messages_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c = cmdq->state.c;
struct client *c = item->state.c;
struct message_entry *msg;
char *tim;
int done, blank;
done = blank = 0;
if (args_has(args, 'T') || self->entry == &cmd_server_info_entry) {
blank = cmd_show_messages_terminals(cmdq, blank);
blank = cmd_show_messages_terminals(item, blank);
done = 1;
}
if (args_has(args, 'J') || self->entry == &cmd_server_info_entry) {
cmd_show_messages_jobs(cmdq, blank);
cmd_show_messages_jobs(item, blank);
done = 1;
}
if (done)
@ -122,7 +123,7 @@ cmd_show_messages_exec(struct cmd *self, struct cmd_q *cmdq)
tim = ctime(&msg->msg_time);
*strchr(tim, '\n') = '\0';
cmdq_print(cmdq, "%s %s", tim, msg->msg);
cmdq_print(item, "%s %s", tim, msg->msg);
}
return (CMD_RETURN_NORMAL);

52
cmd-show-options.c
View File

@ -27,11 +27,11 @@
* Show options.
*/
static enum cmd_retval cmd_show_options_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_show_options_exec(struct cmd *, struct cmdq_item *);
static enum cmd_retval cmd_show_options_one(struct cmd *, struct cmd_q *,
static enum cmd_retval cmd_show_options_one(struct cmd *, struct cmdq_item *,
struct options *, int);
static enum cmd_retval cmd_show_options_all(struct cmd *, struct cmd_q *,
static enum cmd_retval cmd_show_options_all(struct cmd *, struct cmdq_item *,
struct options *, enum options_table_scope);
const struct cmd_entry cmd_show_options_entry = {
@ -61,11 +61,11 @@ const struct cmd_entry cmd_show_window_options_entry = {
};
static enum cmd_retval
cmd_show_options_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_show_options_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct session *s = cmdq->state.tflag.s;
struct winlink *wl = cmdq->state.tflag.wl;
struct session *s = item->state.tflag.s;
struct winlink *wl = item->state.tflag.wl;
struct options *oo;
enum options_table_scope scope;
int quiet;
@ -82,9 +82,9 @@ cmd_show_options_exec(struct cmd *self, struct cmd_q *cmdq)
else if (wl == NULL) {
target = args_get(args, 't');
if (target != NULL) {
cmdq_error(cmdq, "no such window: %s", target);
cmdq_error(item, "no such window: %s", target);
} else
cmdq_error(cmdq, "no current window");
cmdq_error(item, "no current window");
return (CMD_RETURN_ERROR);
} else
oo = wl->window->options;
@ -95,9 +95,9 @@ cmd_show_options_exec(struct cmd *self, struct cmd_q *cmdq)
else if (s == NULL) {
target = args_get(args, 't');
if (target != NULL) {
cmdq_error(cmdq, "no such session: %s", target);
cmdq_error(item, "no such session: %s", target);
} else
cmdq_error(cmdq, "no current session");
cmdq_error(item, "no current session");
return (CMD_RETURN_ERROR);
} else
oo = s->options;
@ -105,13 +105,13 @@ cmd_show_options_exec(struct cmd *self, struct cmd_q *cmdq)
quiet = args_has(self->args, 'q');
if (args->argc == 0)
return (cmd_show_options_all(self, cmdq, oo, scope));
return (cmd_show_options_all(self, item, oo, scope));
else
return (cmd_show_options_one(self, cmdq, oo, quiet));
return (cmd_show_options_one(self, item, oo, quiet));
}
static enum cmd_retval
cmd_show_options_one(struct cmd *self, struct cmd_q *cmdq,
cmd_show_options_one(struct cmd *self, struct cmdq_item *item,
struct options *oo, int quiet)
{
struct args *args = self->args;
@ -125,25 +125,25 @@ retry:
if ((o = options_find1(oo, name)) == NULL) {
if (quiet)
return (CMD_RETURN_NORMAL);
cmdq_error(cmdq, "unknown option: %s", name);
cmdq_error(item, "unknown option: %s", name);
return (CMD_RETURN_ERROR);
}
if (args_has(self->args, 'v'))
cmdq_print(cmdq, "%s", o->str);
cmdq_print(item, "%s", o->str);
else
cmdq_print(cmdq, "%s \"%s\"", o->name, o->str);
cmdq_print(item, "%s \"%s\"", o->name, o->str);
return (CMD_RETURN_NORMAL);
}
oe = NULL;
if (options_table_find(name, &oe) != 0) {
cmdq_error(cmdq, "ambiguous option: %s", name);
cmdq_error(item, "ambiguous option: %s", name);
return (CMD_RETURN_ERROR);
}
if (oe == NULL) {
if (quiet)
return (CMD_RETURN_NORMAL);
cmdq_error(cmdq, "unknown option: %s", name);
cmdq_error(item, "unknown option: %s", name);
return (CMD_RETURN_ERROR);
}
if (oe->style != NULL) {
@ -154,15 +154,15 @@ retry:
return (CMD_RETURN_NORMAL);
optval = options_table_print_entry(oe, o, args_has(self->args, 'v'));
if (args_has(self->args, 'v'))
cmdq_print(cmdq, "%s", optval);
cmdq_print(item, "%s", optval);
else
cmdq_print(cmdq, "%s %s", oe->name, optval);
cmdq_print(item, "%s %s", oe->name, optval);
return (CMD_RETURN_NORMAL);
}
static enum cmd_retval
cmd_show_options_all(struct cmd *self, struct cmd_q *cmdq, struct options *oo,
enum options_table_scope scope)
cmd_show_options_all(struct cmd *self, struct cmdq_item *item,
struct options *oo, enum options_table_scope scope)
{
const struct options_table_entry *oe;
struct options_entry *o;
@ -173,9 +173,9 @@ cmd_show_options_all(struct cmd *self, struct cmd_q *cmdq, struct options *oo,
while (o != NULL) {
if (*o->name == '@') {
if (args_has(self->args, 'v'))
cmdq_print(cmdq, "%s", o->str);
cmdq_print(item, "%s", o->str);
else
cmdq_print(cmdq, "%s \"%s\"", o->name, o->str);
cmdq_print(item, "%s \"%s\"", o->name, o->str);
}
o = options_next(o);
}
@ -188,9 +188,9 @@ cmd_show_options_all(struct cmd *self, struct cmd_q *cmdq, struct options *oo,
continue;
optval = options_table_print_entry(oe, o, vflag);
if (vflag)
cmdq_print(cmdq, "%s", optval);
cmdq_print(item, "%s", optval);
else
cmdq_print(cmdq, "%s %s", oe->name, optval);
cmdq_print(item, "%s %s", oe->name, optval);
}
return (CMD_RETURN_NORMAL);

28
cmd-source-file.c
View File

@ -26,9 +26,9 @@
* Sources a configuration file.
*/
static enum cmd_retval cmd_source_file_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_source_file_exec(struct cmd *, struct cmdq_item *);
static enum cmd_retval cmd_source_file_done(struct cmd_q *, void *);
static enum cmd_retval cmd_source_file_done(struct cmdq_item *, void *);
const struct cmd_entry cmd_source_file_entry = {
.name = "source-file",
@ -42,34 +42,34 @@ const struct cmd_entry cmd_source_file_entry = {
};
static enum cmd_retval
cmd_source_file_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct client *c = cmdq->client;
int quiet;
struct cmd_q *new_cmdq;
struct args *args = self->args;
struct client *c = item->client;
int quiet;
struct cmdq_item *new_item;
quiet = args_has(args, 'q');
switch (load_cfg(args->argv[0], c, cmdq, quiet)) {
switch (load_cfg(args->argv[0], c, item, quiet)) {
case -1:
if (cfg_finished)
cfg_print_causes(cmdq);
cfg_print_causes(item);
return (CMD_RETURN_ERROR);
case 0:
if (cfg_finished)
cfg_print_causes(cmdq);
cfg_print_causes(item);
return (CMD_RETURN_NORMAL);
}
if (cfg_finished) {
new_cmdq = cmdq_get_callback(cmd_source_file_done, NULL);
cmdq_insert_after(cmdq, new_cmdq);
new_item = cmdq_get_callback(cmd_source_file_done, NULL);
cmdq_insert_after(item, new_item);
}
return (CMD_RETURN_NORMAL);
}
static enum cmd_retval
cmd_source_file_done(struct cmd_q *cmdq, __unused void *data)
cmd_source_file_done(struct cmdq_item *item, __unused void *data)
{
cfg_print_causes(cmdq);
cfg_print_causes(item);
return (CMD_RETURN_NORMAL);
}

33
cmd-split-window.c
View File

@ -32,7 +32,8 @@
#define SPLIT_WINDOW_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"
static enum cmd_retval cmd_split_window_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_split_window_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_split_window_entry = {
.name = "split-window",
@ -49,13 +50,13 @@ const struct cmd_entry cmd_split_window_entry = {
};
static enum cmd_retval
cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct session *s = cmdq->state.tflag.s;
struct winlink *wl = cmdq->state.tflag.wl;
struct session *s = item->state.tflag.s;
struct winlink *wl = item->state.tflag.wl;
struct window *w = wl->window;
struct window_pane *wp = cmdq->state.tflag.wp, *new_wp = NULL;
struct window_pane *wp = item->state.tflag.wp, *new_wp = NULL;
struct environ *env;
const char *cmd, *path, *shell, *template, *cwd, *to_free;
char **argv, *cause, *new_cause, *cp;
@ -90,12 +91,12 @@ cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
to_free = NULL;
if (args_has(args, 'c')) {
ft = format_create(cmdq, 0);
format_defaults(ft, cmdq->state.c, s, NULL, NULL);
ft = format_create(item, 0);
format_defaults(ft, item->state.c, s, NULL, NULL);
to_free = cwd = format_expand(ft, args_get(args, 'c'));
format_free(ft);
} else if (cmdq->client != NULL && cmdq->client->session == NULL)
cwd = cmdq->client->cwd;
} else if (item->client != NULL && item->client->session == NULL)
cwd = item->client->cwd;
else
cwd = s->cwd;
@ -141,8 +142,8 @@ cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
layout_assign_pane(lc, new_wp);
path = NULL;
if (cmdq->client != NULL && cmdq->client->session == NULL)
envent = environ_find(cmdq->client->environ, "PATH");
if (item->client != NULL && item->client->session == NULL)
envent = environ_find(item->client->environ, "PATH");
else
envent = environ_find(s->environ, "PATH");
if (envent != NULL)
@ -167,11 +168,11 @@ cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
if ((template = args_get(args, 'F')) == NULL)
template = SPLIT_WINDOW_TEMPLATE;
ft = format_create(cmdq, 0);
format_defaults(ft, cmdq->state.c, s, wl, new_wp);
ft = format_create(item, 0);
format_defaults(ft, item->state.c, s, wl, new_wp);
cp = format_expand(ft, template);
cmdq_print(cmdq, "%s", cp);
cmdq_print(item, "%s", cp);
free(cp);
format_free(ft);
@ -187,7 +188,7 @@ cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
fs.w = w;
fs.wp = new_wp;
cmd_find_log_state(__func__, &fs);
hooks_insert(s->hooks, cmdq, &fs, "after-split-window");
hooks_insert(s->hooks, item, &fs, "after-split-window");
return (CMD_RETURN_NORMAL);
@ -197,7 +198,7 @@ error:
layout_close_pane(new_wp);
window_remove_pane(w, new_wp);
}
cmdq_error(cmdq, "create pane failed: %s", cause);
cmdq_error(item, "create pane failed: %s", cause);
free(cause);
if (to_free != NULL)

12
cmd-swap-pane.c
View File

@ -26,7 +26,7 @@
* Swap two panes.
*/
static enum cmd_retval cmd_swap_pane_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_swap_pane_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_swap_pane_entry = {
.name = "swap-pane",
@ -43,17 +43,17 @@ const struct cmd_entry cmd_swap_pane_entry = {
};
static enum cmd_retval
cmd_swap_pane_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_swap_pane_exec(struct cmd *self, struct cmdq_item *item)
{
struct window *src_w, *dst_w;
struct window_pane *tmp_wp, *src_wp, *dst_wp;
struct layout_cell *src_lc, *dst_lc;
u_int sx, sy, xoff, yoff;
dst_w = cmdq->state.tflag.wl->window;
dst_wp = cmdq->state.tflag.wp;
src_w = cmdq->state.sflag.wl->window;
src_wp = cmdq->state.sflag.wp;
dst_w = item->state.tflag.wl->window;
dst_wp = item->state.tflag.wp;
src_w = item->state.sflag.wl->window;
src_wp = item->state.sflag.wp;
server_unzoom_window(dst_w);
if (args_has(self->args, 'D')) {

14
cmd-swap-window.c
View File

@ -26,7 +26,7 @@
* Swap one window with another.
*/
static enum cmd_retval cmd_swap_window_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_swap_window_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_swap_window_entry = {
.name = "swap-window",
@ -43,24 +43,24 @@ const struct cmd_entry cmd_swap_window_entry = {
};
static enum cmd_retval
cmd_swap_window_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_swap_window_exec(struct cmd *self, struct cmdq_item *item)
{
struct session *src, *dst;
struct session_group *sg_src, *sg_dst;
struct winlink *wl_src, *wl_dst;
struct window *w;
wl_src = cmdq->state.sflag.wl;
src = cmdq->state.sflag.s;
wl_src = item->state.sflag.wl;
src = item->state.sflag.s;
sg_src = session_group_find(src);
wl_dst = cmdq->state.tflag.wl;
dst = cmdq->state.tflag.s;
wl_dst = item->state.tflag.wl;
dst = item->state.tflag.s;
sg_dst = session_group_find(dst);
if (src != dst && sg_src != NULL && sg_dst != NULL &&
sg_src == sg_dst) {
cmdq_error(cmdq, "can't move window, sessions are grouped");
cmdq_error(item, "can't move window, sessions are grouped");
return (CMD_RETURN_ERROR);
}

19
cmd-switch-client.c
View File

@ -27,7 +27,8 @@
* Switch client to a different session.
*/
static enum cmd_retval cmd_switch_client_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_switch_client_exec(struct cmd *,
struct cmdq_item *);
const struct cmd_entry cmd_switch_client_entry = {
.name = "switch-client",
@ -45,12 +46,12 @@ const struct cmd_entry cmd_switch_client_entry = {
};
static enum cmd_retval
cmd_switch_client_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
struct cmd_state *state = &cmdq->state;
struct cmd_state *state = &item->state;
struct client *c = state->c;
struct session *s = cmdq->state.tflag.s;
struct session *s = item->state.tflag.s;
struct window_pane *wp;
const char *tablename, *update;
struct key_table *table;
@ -62,7 +63,7 @@ cmd_switch_client_exec(struct cmd *self, struct cmd_q *cmdq)
if (tablename != NULL) {
table = key_bindings_get_table(tablename, 0);
if (table == NULL) {
cmdq_error(cmdq, "table %s doesn't exist", tablename);
cmdq_error(item, "table %s doesn't exist", tablename);
return (CMD_RETURN_ERROR);
}
table->references++;
@ -73,12 +74,12 @@ cmd_switch_client_exec(struct cmd *self, struct cmd_q *cmdq)
if (args_has(args, 'n')) {
if ((s = session_next_session(c->session)) == NULL) {
cmdq_error(cmdq, "can't find next session");
cmdq_error(item, "can't find next session");
return (CMD_RETURN_ERROR);
}
} else if (args_has(args, 'p')) {
if ((s = session_previous_session(c->session)) == NULL) {
cmdq_error(cmdq, "can't find previous session");
cmdq_error(item, "can't find previous session");
return (CMD_RETURN_ERROR);
}
} else if (args_has(args, 'l')) {
@ -87,11 +88,11 @@ cmd_switch_client_exec(struct cmd *self, struct cmd_q *cmdq)
else
s = NULL;
if (s == NULL) {
cmdq_error(cmdq, "can't find last session");
cmdq_error(item, "can't find last session");
return (CMD_RETURN_ERROR);
}
} else {
if (cmdq->client == NULL)
if (item->client == NULL)
return (CMD_RETURN_NORMAL);
if (state->tflag.wl != NULL) {
wp = state->tflag.wp;

26
cmd-unbind-key.c
View File

@ -26,9 +26,10 @@
* Unbind key from command.
*/
static enum cmd_retval cmd_unbind_key_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_unbind_key_mode_table(struct cmd *, struct cmd_q *,
key_code);
static enum cmd_retval cmd_unbind_key_exec(struct cmd *, struct cmdq_item *);
static enum cmd_retval cmd_unbind_key_mode_table(struct cmd *,
struct cmdq_item *, key_code);
const struct cmd_entry cmd_unbind_key_entry = {
.name = "unbind-key",
@ -42,7 +43,7 @@ const struct cmd_entry cmd_unbind_key_entry = {
};
static enum cmd_retval
cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_unbind_key_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
key_code key;
@ -50,24 +51,24 @@ cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
if (!args_has(args, 'a')) {
if (args->argc != 1) {
cmdq_error(cmdq, "missing key");
cmdq_error(item, "missing key");
return (CMD_RETURN_ERROR);
}
key = key_string_lookup_string(args->argv[0]);
if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
cmdq_error(cmdq, "unknown key: %s", args->argv[0]);
cmdq_error(item, "unknown key: %s", args->argv[0]);
return (CMD_RETURN_ERROR);
}
} else {
if (args->argc != 0) {
cmdq_error(cmdq, "key given with -a");
cmdq_error(item, "key given with -a");
return (CMD_RETURN_ERROR);
}
key = KEYC_UNKNOWN;
}
if (args_has(args, 't'))
return (cmd_unbind_key_mode_table(self, cmdq, key));
return (cmd_unbind_key_mode_table(self, item, key));
if (key == KEYC_UNKNOWN) {
tablename = args_get(args, 'T');
@ -77,7 +78,7 @@ cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
return (CMD_RETURN_NORMAL);
}
if (key_bindings_get_table(tablename, 0) == NULL) {
cmdq_error(cmdq, "table %s doesn't exist", tablename);
cmdq_error(item, "table %s doesn't exist", tablename);
return (CMD_RETURN_ERROR);
}
key_bindings_remove_table(tablename);
@ -87,7 +88,7 @@ cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
if (args_has(args, 'T')) {
tablename = args_get(args, 'T');
if (key_bindings_get_table(tablename, 0) == NULL) {
cmdq_error(cmdq, "table %s doesn't exist", tablename);
cmdq_error(item, "table %s doesn't exist", tablename);
return (CMD_RETURN_ERROR);
}
} else if (args_has(args, 'n'))
@ -99,7 +100,8 @@ cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
}
static enum cmd_retval
cmd_unbind_key_mode_table(struct cmd *self, struct cmd_q *cmdq, key_code key)
cmd_unbind_key_mode_table(struct cmd *self, struct cmdq_item *item,
key_code key)
{
struct args *args = self->args;
const char *tablename;
@ -108,7 +110,7 @@ cmd_unbind_key_mode_table(struct cmd *self, struct cmd_q *cmdq, key_code key)
tablename = args_get(args, 't');
if ((mtab = mode_key_findtable(tablename)) == NULL) {
cmdq_error(cmdq, "unknown key table: %s", tablename);
cmdq_error(item, "unknown key table: %s", tablename);
return (CMD_RETURN_ERROR);
}

56
cmd-wait-for.c
View File

@ -28,7 +28,7 @@
* Block or wake a client on a named wait channel.
*/
static enum cmd_retval cmd_wait_for_exec(struct cmd *, struct cmd_q *);
static enum cmd_retval cmd_wait_for_exec(struct cmd *, struct cmdq_item *);
const struct cmd_entry cmd_wait_for_entry = {
.name = "wait-for",
@ -42,7 +42,7 @@ const struct cmd_entry cmd_wait_for_entry = {
};
struct wait_item {
struct cmd_q *cmdq;
struct cmdq_item *item;
TAILQ_ENTRY(wait_item) entry;
};
@ -68,17 +68,17 @@ wait_channel_cmp(struct wait_channel *wc1, struct wait_channel *wc2)
return (strcmp(wc1->name, wc2->name));
}
static enum cmd_retval cmd_wait_for_signal(struct cmd_q *, const char *,
static enum cmd_retval cmd_wait_for_signal(struct cmdq_item *, const char *,
struct wait_channel *);
static enum cmd_retval cmd_wait_for_wait(struct cmd_q *, const char *,
static enum cmd_retval cmd_wait_for_wait(struct cmdq_item *, const char *,
struct wait_channel *);
static enum cmd_retval cmd_wait_for_lock(struct cmd_q *, const char *,
static enum cmd_retval cmd_wait_for_lock(struct cmdq_item *, const char *,
struct wait_channel *);
static enum cmd_retval cmd_wait_for_unlock(struct cmd_q *, const char *,
static enum cmd_retval cmd_wait_for_unlock(struct cmdq_item *, const char *,
struct wait_channel *);
static struct wait_channel *cmd_wait_for_add(const char *);
static void cmd_wait_for_remove(struct wait_channel *wc);
static void cmd_wait_for_remove(struct wait_channel *);
static struct wait_channel *
cmd_wait_for_add(const char *name)
@ -118,7 +118,7 @@ cmd_wait_for_remove(struct wait_channel *wc)
}
static enum cmd_retval
cmd_wait_for_exec(struct cmd *self, struct cmd_q *cmdq)
cmd_wait_for_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args;
const char *name = args->argv[0];
@ -128,16 +128,16 @@ cmd_wait_for_exec(struct cmd *self, struct cmd_q *cmdq)
wc = RB_FIND(wait_channels, &wait_channels, &wc0);
if (args_has(args, 'S'))
return (cmd_wait_for_signal(cmdq, name, wc));
return (cmd_wait_for_signal(item, name, wc));
if (args_has(args, 'L'))
return (cmd_wait_for_lock(cmdq, name, wc));
return (cmd_wait_for_lock(item, name, wc));
if (args_has(args, 'U'))
return (cmd_wait_for_unlock(cmdq, name, wc));
return (cmd_wait_for_wait(cmdq, name, wc));
return (cmd_wait_for_unlock(item, name, wc));
return (cmd_wait_for_wait(item, name, wc));
}
static enum cmd_retval
cmd_wait_for_signal(__unused struct cmd_q *cmdq, const char *name,
cmd_wait_for_signal(__unused struct cmdq_item *item, const char *name,
struct wait_channel *wc)
{
struct wait_item *wi, *wi1;
@ -153,7 +153,7 @@ cmd_wait_for_signal(__unused struct cmd_q *cmdq, const char *name,
log_debug("signal wait channel %s, with waiters", wc->name);
TAILQ_FOREACH_SAFE(wi, &wc->waiters, entry, wi1) {
wi->cmdq->flags &= ~CMD_Q_WAITING;
wi->item->flags &= ~CMDQ_WAITING;
TAILQ_REMOVE(&wc->waiters, wi, entry);
free(wi);
@ -164,13 +164,14 @@ cmd_wait_for_signal(__unused struct cmd_q *cmdq, const char *name,
}
static enum cmd_retval
cmd_wait_for_wait(struct cmd_q *cmdq, const char *name, struct wait_channel *wc)
cmd_wait_for_wait(struct cmdq_item *item, const char *name,
struct wait_channel *wc)
{
struct client *c = cmdq->client;
struct client *c = item->client;
struct wait_item *wi;
if (c == NULL || c->session != NULL) {
cmdq_error(cmdq, "not able to wait");
cmdq_error(item, "not able to wait");
return (CMD_RETURN_ERROR);
}
@ -185,19 +186,20 @@ cmd_wait_for_wait(struct cmd_q *cmdq, const char *name, struct wait_channel *wc)
log_debug("wait channel %s not woken (%p)", wc->name, c);
wi = xcalloc(1, sizeof *wi);
wi->cmdq = cmdq;
wi->item = item;
TAILQ_INSERT_TAIL(&wc->waiters, wi, entry);
return (CMD_RETURN_WAIT);
}
static enum cmd_retval
cmd_wait_for_lock(struct cmd_q *cmdq, const char *name, struct wait_channel *wc)
cmd_wait_for_lock(struct cmdq_item *item, const char *name,
struct wait_channel *wc)
{
struct wait_item *wi;
if (cmdq->client == NULL || cmdq->client->session != NULL) {
cmdq_error(cmdq, "not able to lock");
if (item->client == NULL || item->client->session != NULL) {
cmdq_error(item, "not able to lock");
return (CMD_RETURN_ERROR);
}
@ -206,7 +208,7 @@ cmd_wait_for_lock(struct cmd_q *cmdq, const char *name, struct wait_channel *wc)
if (wc->locked) {
wi = xcalloc(1, sizeof *wi);
wi->cmdq = cmdq;
wi->item = item;
TAILQ_INSERT_TAIL(&wc->lockers, wi, entry);
return (CMD_RETURN_WAIT);
}
@ -216,18 +218,18 @@ cmd_wait_for_lock(struct cmd_q *cmdq, const char *name, struct wait_channel *wc)
}
static enum cmd_retval
cmd_wait_for_unlock(struct cmd_q *cmdq, const char *name,
cmd_wait_for_unlock(struct cmdq_item *item, const char *name,
struct wait_channel *wc)
{
struct wait_item *wi;
if (wc == NULL || !wc->locked) {
cmdq_error(cmdq, "channel %s not locked", name);
cmdq_error(item, "channel %s not locked", name);
return (CMD_RETURN_ERROR);
}
if ((wi = TAILQ_FIRST(&wc->lockers)) != NULL) {
wi->cmdq->flags &= ~CMD_Q_WAITING;
wi->item->flags &= ~CMDQ_WAITING;
TAILQ_REMOVE(&wc->lockers, wi, entry);
free(wi);
} else {
@ -246,13 +248,13 @@ cmd_wait_for_flush(void)
RB_FOREACH_SAFE(wc, wait_channels, &wait_channels, wc1) {
TAILQ_FOREACH_SAFE(wi, &wc->waiters, entry, wi1) {
wi->cmdq->flags &= ~CMD_Q_WAITING;
wi->item->flags &= ~CMDQ_WAITING;
TAILQ_REMOVE(&wc->waiters, wi, entry);
free(wi);
}
wc->woken = 1;
TAILQ_FOREACH_SAFE(wi, &wc->lockers, entry, wi1) {
wi->cmdq->flags &= ~CMD_Q_WAITING;
wi->item->flags &= ~CMDQ_WAITING;
TAILQ_REMOVE(&wc->lockers, wi, entry);
free(wi);
}

30
cmd.c
View File

@ -389,7 +389,7 @@ usage:
static int
cmd_prepare_state_flag(char c, const char *target, enum cmd_entry_flag flag,
struct cmd_q *cmdq)
struct cmdq_item *item)
{
int targetflags, error;
struct cmd_find_state *fs = NULL;
@ -401,9 +401,9 @@ cmd_prepare_state_flag(char c, const char *target, enum cmd_entry_flag flag,
return (0);
if (c == 't')
fs = &cmdq->state.tflag;
fs = &item->state.tflag;
else if (c == 's')
fs = &cmdq->state.sflag;
fs = &item->state.sflag;
if (flag == CMD_SESSION_WITHPANE) {
if (target != NULL && target[strcspn(target, ":.")] != '\0')
@ -449,7 +449,7 @@ cmd_prepare_state_flag(char c, const char *target, enum cmd_entry_flag flag,
}
log_debug("%s: flag %c %d %#x", __func__, c, flag, targetflags);
error = cmd_find_current(&current, cmdq, targetflags);
error = cmd_find_current(&current, item, targetflags);
if (error != 0 && ~targetflags & CMD_FIND_QUIET)
return (-1);
if (!cmd_find_empty_state(&current) && !cmd_find_valid_state(&current))
@ -464,13 +464,13 @@ cmd_prepare_state_flag(char c, const char *target, enum cmd_entry_flag flag,
case CMD_SESSION_CANFAIL:
case CMD_SESSION_PREFERUNATTACHED:
case CMD_SESSION_WITHPANE:
error = cmd_find_target(fs, &current, cmdq, target,
error = cmd_find_target(fs, &current, item, target,
CMD_FIND_SESSION, targetflags);
if (error != 0 && ~targetflags & CMD_FIND_QUIET)
return (-1);
break;
case CMD_MOVEW_R:
error = cmd_find_target(fs, &current, cmdq, target,
error = cmd_find_target(fs, &current, item, target,
CMD_FIND_SESSION, CMD_FIND_QUIET);
if (error == 0)
break;
@ -479,7 +479,7 @@ cmd_prepare_state_flag(char c, const char *target, enum cmd_entry_flag flag,
case CMD_WINDOW_CANFAIL:
case CMD_WINDOW_MARKED:
case CMD_WINDOW_INDEX:
error = cmd_find_target(fs, &current, cmdq, target,
error = cmd_find_target(fs, &current, item, target,
CMD_FIND_WINDOW, targetflags);
if (error != 0 && ~targetflags & CMD_FIND_QUIET)
return (-1);
@ -487,7 +487,7 @@ cmd_prepare_state_flag(char c, const char *target, enum cmd_entry_flag flag,
case CMD_PANE:
case CMD_PANE_CANFAIL:
case CMD_PANE_MARKED:
error = cmd_find_target(fs, &current, cmdq, target,
error = cmd_find_target(fs, &current, item, target,
CMD_FIND_PANE, targetflags);
if (error != 0 && ~targetflags & CMD_FIND_QUIET)
return (-1);
@ -499,17 +499,17 @@ cmd_prepare_state_flag(char c, const char *target, enum cmd_entry_flag flag,
}
int
cmd_prepare_state(struct cmd *cmd, struct cmd_q *cmdq)
cmd_prepare_state(struct cmd *cmd, struct cmdq_item *item)
{
const struct cmd_entry *entry = cmd->entry;
struct cmd_state *state = &cmdq->state;
struct cmd_state *state = &item->state;
char *tmp;
enum cmd_entry_flag flag;
const char *s;
int error;
tmp = cmd_print(cmd);
log_debug("preparing state for %s (client %p)", tmp, cmdq->client);
log_debug("preparing state for %s (client %p)", tmp, item->client);
free(tmp);
state->c = NULL;
@ -527,12 +527,12 @@ cmd_prepare_state(struct cmd *cmd, struct cmd_q *cmdq)
s = args_get(cmd->args, 'c');
switch (flag) {
case CMD_CLIENT:
state->c = cmd_find_client(cmdq, s, 0);
state->c = cmd_find_client(item, s, 0);
if (state->c == NULL)
return (-1);
break;
default:
state->c = cmd_find_client(cmdq, s, 1);
state->c = cmd_find_client(item, s, 1);
break;
}
log_debug("using client %p", state->c);
@ -540,14 +540,14 @@ cmd_prepare_state(struct cmd *cmd, struct cmd_q *cmdq)
s = args_get(cmd->args, 't');
log_debug("preparing -t state: target %s", s == NULL ? "none" : s);
error = cmd_prepare_state_flag('t', s, entry->tflag, cmdq);
error = cmd_prepare_state_flag('t', s, entry->tflag, item);
if (error != 0)
return (error);
s = args_get(cmd->args, 's');
log_debug("preparing -s state: target %s", s == NULL ? "none" : s);
error = cmd_prepare_state_flag('s', s, entry->sflag, cmdq);
error = cmd_prepare_state_flag('s', s, entry->sflag, item);
if (error != 0)
return (error);

24
control.c
View File

@ -51,14 +51,14 @@ control_write_buffer(struct client *c, struct evbuffer *buffer)
/* Control error callback. */
static enum cmd_retval
control_error(struct cmd_q *cmdq, void *data)
control_error(struct cmdq_item *item, void *data)
{
struct client *c = cmdq->client;
struct client *c = item->client;
char *error = data;
cmdq_guard(cmdq, "begin", 1);
cmdq_guard(item, "begin", 1);
control_write(c, "parse error: %s", error);
cmdq_guard(cmdq, "error", 1);
cmdq_guard(item, "error", 1);
free(error);
return (CMD_RETURN_NORMAL);
@ -68,10 +68,10 @@ control_error(struct cmd_q *cmdq, void *data)
void
control_callback(struct client *c, int closed, __unused void *data)
{
char *line, *cause;
struct cmd_list *cmdlist;
struct cmd *cmd;
struct cmd_q *cmdq;
char *line, *cause;
struct cmd_list *cmdlist;
struct cmd *cmd;
struct cmdq_item *item;
if (closed)
c->flags |= CLIENT_EXIT;
@ -86,13 +86,13 @@ control_callback(struct client *c, int closed, __unused void *data)
}
if (cmd_string_parse(line, &cmdlist, NULL, 0, &cause) != 0) {
cmdq = cmdq_get_callback(control_error, cause);
cmdq_append(c, cmdq);
item = cmdq_get_callback(control_error, cause);
cmdq_append(c, item);
} else {
TAILQ_FOREACH(cmd, &cmdlist->list, qentry)
cmd->flags |= CMD_CONTROL;
cmdq = cmdq_get_command(cmdlist, NULL, NULL, 0);
cmdq_append(c, cmdq);
item = cmdq_get_command(cmdlist, NULL, NULL, 0);
cmdq_append(c, item);
cmd_list_free(cmdlist);
}

23
format.c
View File

@ -487,9 +487,22 @@ format_cb_pane_tabs(struct format_tree *ft, struct format_entry *fe)
evbuffer_free(buffer);
}
/* Merge a format tree. */
static void
format_merge(struct format_tree *ft, struct format_tree *from)
{
struct format_entry *fe;
RB_FOREACH(fe, format_entry_tree, &from->tree) {
if (fe->value != NULL)
format_add(ft, fe->key, "%s", fe->value);
}
}
/* Create a new tree. */
struct format_tree *
format_create(struct cmd_q *cmdq, int flags)
format_create(struct cmdq_item *item, int flags)
{
struct format_tree *ft;
@ -508,10 +521,10 @@ format_create(struct cmd_q *cmdq, int flags)
format_add(ft, "socket_path", "%s", socket_path);
format_add_tv(ft, "start_time", &start_time);
if (cmdq != NULL && cmdq->cmd != NULL)
format_add(ft, "command", "%s", cmdq->cmd->entry->name);
if (cmdq != NULL && cmdq->hook != NULL)
format_add(ft, "hook", "%s", cmdq->hook);
if (item != NULL && item->cmd != NULL)
format_add(ft, "command", "%s", item->cmd->entry->name);
if (item != NULL && item->formats != NULL)
format_merge(ft, item->formats);
return (ft);
}

48
hooks.c
View File

@ -143,10 +143,10 @@ void
hooks_run(struct hooks *hooks, struct client *c, struct cmd_find_state *fs,
const char *fmt, ...)
{
struct hook *hook;
va_list ap;
char *name;
struct cmd_q *new_cmdq, *loop;
struct hook *hook;
va_list ap;
char *name;
struct cmdq_item *new_item;
va_start(ap, fmt);
xvasprintf(&name, fmt, ap);
@ -159,25 +159,23 @@ hooks_run(struct hooks *hooks, struct client *c, struct cmd_find_state *fs,
}
log_debug("running hook %s", name);
new_cmdq = cmdq_get_command(hook->cmdlist, fs, NULL, CMD_Q_NOHOOKS);
new_item = cmdq_get_command(hook->cmdlist, fs, NULL, CMDQ_NOHOOKS);
cmdq_format(new_item, "hook", "%s", name);
cmdq_append(c, new_item);
for (loop = new_cmdq; loop != NULL; loop = loop->next)
loop->hook = xstrdup(name);
free(name);
cmdq_append(c, new_cmdq);
}
void
hooks_insert(struct hooks *hooks, struct cmd_q *cmdq, struct cmd_find_state *fs,
const char *fmt, ...)
hooks_insert(struct hooks *hooks, struct cmdq_item *item,
struct cmd_find_state *fs, const char *fmt, ...)
{
struct hook *hook;
va_list ap;
char *name;
struct cmd_q *new_cmdq, *loop;
struct hook *hook;
va_list ap;
char *name;
struct cmdq_item *new_item;
if (cmdq->flags & CMD_Q_NOHOOKS)
if (item->flags & CMDQ_NOHOOKS)
return;
va_start(ap, fmt);
@ -189,16 +187,14 @@ hooks_insert(struct hooks *hooks, struct cmd_q *cmdq, struct cmd_find_state *fs,
free(name);
return;
}
log_debug("running hook %s (parent %p)", name, cmdq);
log_debug("running hook %s (parent %p)", name, item);
new_cmdq = cmdq_get_command(hook->cmdlist, fs, NULL, CMD_Q_NOHOOKS);
for (loop = new_cmdq; loop != NULL; loop = loop->next)
loop->hook = xstrdup(name);
free(name);
if (cmdq != NULL)
cmdq_insert_after(cmdq, new_cmdq);
new_item = cmdq_get_command(hook->cmdlist, fs, NULL, CMDQ_NOHOOKS);
cmdq_format(new_item, "hook", "%s", name);
if (item != NULL)
cmdq_insert_after(item, new_item);
else
cmdq_append(NULL, new_cmdq);
cmdq_append(NULL, new_item);
free(name);
}

4
key-bindings.c
View File

@ -389,9 +389,9 @@ key_bindings_init(void)
}
static enum cmd_retval
key_bindings_read_only(struct cmd_q *cmdq, __unused void *data)
key_bindings_read_only(struct cmdq_item *item, __unused void *data)
{
cmdq_error(cmdq, "client is read-only");
cmdq_error(item, "client is read-only");
return (CMD_RETURN_ERROR);
}

146
notify.c
View File

@ -40,8 +40,8 @@ static const char *notify_hooks[] = {
"window-renamed",
NULL, /* "attached-session-changed", */
"session-renamed",
NULL, /* "session-created", */
NULL, /* "session-closed" */
"session-created",
"session-closed"
};
struct notify_entry {
@ -50,34 +50,31 @@ struct notify_entry {
struct client *client;
struct session *session;
struct window *window;
TAILQ_ENTRY(notify_entry) entry;
};
TAILQ_HEAD(notify_queue, notify_entry);
static struct notify_queue notify_queue = TAILQ_HEAD_INITIALIZER(notify_queue);
static void notify_add(enum notify_type, struct client *, struct session *,
struct window *);
static void
notify_hook(struct notify_entry *ne)
notify_hook(struct cmdq_item *item, struct notify_entry *ne)
{
const char *name;
struct cmd_find_state fs;
struct hook *hook;
struct cmd_q *new_cmdq, *loop;
struct cmdq_item *new_item;
struct session *s = ne->session;
struct window *w = ne->window;
name = notify_hooks[ne->type];
if (name == NULL)
return;
cmd_find_clear_state(&fs, NULL, 0);
if (ne->session != NULL && ne->window != NULL)
cmd_find_from_session_window(&fs, ne->session, ne->window);
else if (ne->window != NULL)
cmd_find_from_window(&fs, ne->window);
else if (ne->session != NULL)
cmd_find_from_session(&fs, ne->session);
if (s != NULL && w != NULL)
cmd_find_from_session_window(&fs, s, w);
else if (w != NULL)
cmd_find_from_window(&fs, w);
else if (s != NULL && session_alive(s))
cmd_find_from_session(&fs, s);
else
cmd_find_current(&fs, item, CMD_FIND_QUIET);
if (cmd_find_empty_state(&fs) || !cmd_find_valid_state(&fs))
return;
@ -86,12 +83,63 @@ notify_hook(struct notify_entry *ne)
return;
log_debug("notify hook %s", name);
new_cmdq = cmdq_get_command(hook->cmdlist, &fs, NULL, CMD_Q_NOHOOKS);
new_item = cmdq_get_command(hook->cmdlist, &fs, NULL, CMDQ_NOHOOKS);
cmdq_format(new_item, "hook", "%s", name);
for (loop = new_cmdq; loop != NULL; loop = loop->next)
loop->hook = xstrdup(name);
if (s != NULL) {
cmdq_format(new_item, "hook_session", "$%u", s->id);
cmdq_format(new_item, "hook_session_name", "%s", s->name);
}
if (w != NULL) {
cmdq_format(new_item, "hook_window", "@%u", w->id);
cmdq_format(new_item, "hook_window_name", "%s", w->name);
}
cmdq_append(NULL, new_cmdq);
cmdq_insert_after(item, new_item);
}
static enum cmd_retval
notify_callback(struct cmdq_item *item, void *data)
{
struct notify_entry *ne = data;
switch (ne->type) {
case NOTIFY_WINDOW_LAYOUT_CHANGED:
control_notify_window_layout_changed(ne->window);
break;
case NOTIFY_WINDOW_UNLINKED:
control_notify_window_unlinked(ne->session, ne->window);
break;
case NOTIFY_WINDOW_LINKED:
control_notify_window_linked(ne->session, ne->window);
break;
case NOTIFY_WINDOW_RENAMED:
control_notify_window_renamed(ne->window);
break;
case NOTIFY_ATTACHED_SESSION_CHANGED:
control_notify_attached_session_changed(ne->client);
break;
case NOTIFY_SESSION_RENAMED:
control_notify_session_renamed(ne->session);
break;
case NOTIFY_SESSION_CREATED:
control_notify_session_created(ne->session);
break;
case NOTIFY_SESSION_CLOSED:
control_notify_session_closed(ne->session);
break;
}
notify_hook(item, ne);
if (ne->client != NULL)
server_client_unref(ne->client);
if (ne->session != NULL)
session_unref(ne->session);
if (ne->window != NULL)
window_remove_ref(ne->window);
free(ne);
return (CMD_RETURN_NORMAL);
}
static void
@ -99,13 +147,13 @@ notify_add(enum notify_type type, struct client *c, struct session *s,
struct window *w)
{
struct notify_entry *ne;
struct cmdq_item *new_item;
ne = xcalloc(1, sizeof *ne);
ne->type = type;
ne->client = c;
ne->session = s;
ne->window = w;
TAILQ_INSERT_TAIL(&notify_queue, ne, entry);
if (c != NULL)
c->references++;
@ -113,51 +161,9 @@ notify_add(enum notify_type type, struct client *c, struct session *s,
s->references++;
if (w != NULL)
w->references++;
}
void
notify_drain(void)
{
struct notify_entry *ne, *ne1;
TAILQ_FOREACH_SAFE(ne, &notify_queue, entry, ne1) {
switch (ne->type) {
case NOTIFY_WINDOW_LAYOUT_CHANGED:
control_notify_window_layout_changed(ne->window);
break;
case NOTIFY_WINDOW_UNLINKED:
control_notify_window_unlinked(ne->session, ne->window);
break;
case NOTIFY_WINDOW_LINKED:
control_notify_window_linked(ne->session, ne->window);
break;
case NOTIFY_WINDOW_RENAMED:
control_notify_window_renamed(ne->window);
break;
case NOTIFY_ATTACHED_SESSION_CHANGED:
control_notify_attached_session_changed(ne->client);
break;
case NOTIFY_SESSION_RENAMED:
control_notify_session_renamed(ne->session);
break;
case NOTIFY_SESSION_CREATED:
control_notify_session_created(ne->session);
break;
case NOTIFY_SESSION_CLOSED:
control_notify_session_closed(ne->session);
break;
}
TAILQ_REMOVE(&notify_queue, ne, entry);
notify_hook(ne);
if (ne->client != NULL)
server_client_unref(ne->client);
if (ne->session != NULL)
session_unref(ne->session);
if (ne->window != NULL)
window_remove_ref(ne->window);
free(ne);
}
new_item = cmdq_get_callback(notify_callback, ne);
cmdq_append(NULL, new_item);
}
void
@ -175,54 +181,46 @@ void
notify_window_layout_changed(struct window *w)
{
notify_add(NOTIFY_WINDOW_LAYOUT_CHANGED, NULL, NULL, w);
notify_drain();
}
void
notify_window_unlinked(struct session *s, struct window *w)
{
notify_add(NOTIFY_WINDOW_UNLINKED, NULL, s, w);
notify_drain();
}
void
notify_window_linked(struct session *s, struct window *w)
{
notify_add(NOTIFY_WINDOW_LINKED, NULL, s, w);
notify_drain();
}
void
notify_window_renamed(struct window *w)
{
notify_add(NOTIFY_WINDOW_RENAMED, NULL, NULL, w);
notify_drain();
}
void
notify_attached_session_changed(struct client *c)
{
notify_add(NOTIFY_ATTACHED_SESSION_CHANGED, c, NULL, NULL);
notify_drain();
}
void
notify_session_renamed(struct session *s)
{
notify_add(NOTIFY_SESSION_RENAMED, NULL, s, NULL);
notify_drain();
}
void
notify_session_created(struct session *s)
{
notify_add(NOTIFY_SESSION_CREATED, NULL, s, NULL);
notify_drain();
}
void
notify_session_closed(struct session *s)
{
notify_add(NOTIFY_SESSION_CLOSED, NULL, s, NULL);
notify_drain();
}

8
server-client.c
View File

@ -1262,9 +1262,9 @@ server_client_dispatch(struct imsg *imsg, void *arg)
/* Callback when command is done. */
static enum cmd_retval
server_client_command_done(struct cmd_q *cmdq, __unused void *data)
server_client_command_done(struct cmdq_item *item, __unused void *data)
{
struct client *c = cmdq->client;
struct client *c = item->client;
if (~c->flags & CLIENT_ATTACHED)
c->flags |= CLIENT_EXIT;
@ -1273,11 +1273,11 @@ server_client_command_done(struct cmd_q *cmdq, __unused void *data)
/* Show an error message. */
static enum cmd_retval
server_client_command_error(struct cmd_q *cmdq, void *data)
server_client_command_error(struct cmdq_item *item, void *data)
{
char *error = data;
cmdq_error(cmdq, "%s", error);
cmdq_error(item, "%s", error);
free(error);
return (CMD_RETURN_NORMAL);

2
server.c
View File

@ -194,8 +194,6 @@ server_loop(void)
struct client *c;
u_int items;
notify_drain();
do {
items = cmdq_next(NULL);
TAILQ_FOREACH(c, &clients, entry)

8
tmux.1
View File

@ -3248,6 +3248,10 @@ Run when the program running in a pane exits, but
is on so the pane has not closed.
.It pane-exited
Run when the program running in a pane exits.
.It session-created
Run when a new session created.
.It session-closed
Run when a session closed.
.It session-renamed
Run when a session is renamed.
.It window-renamed
@ -3471,6 +3475,10 @@ The following variables are available, where appropriate:
.It Li "history_limit" Ta "" Ta "Maximum window history lines"
.It Li "history_size" Ta "" Ta "Size of history in bytes"
.It Li "hook" Ta "" Ta "Name of running hook, if any"
.It Li "hook_session" Ta "" Ta "ID of session where hook was run, if any"
.It Li "hook_session_name" Ta "" Ta "Name of session where hook was run, if any"
.It Li "hook_window" Ta "" Ta "ID of window where hook was run, if any"
.It Li "hook_window_name" Ta "" Ta "Name of window where hook was run, if any"
.It Li "host" Ta "#H" Ta "Hostname of local host"
.It Li "host_short" Ta "#h" Ta "Hostname of local host (no domain name)"
.It Li "insert_flag" Ta "" Ta "Pane insert flag"

88
tmux.h
View File

@ -42,8 +42,8 @@ extern char **environ;
struct args;
struct client;
struct cmd_q;
struct cmd_q_list;
struct cmdq_item;
struct cmdq_list;
struct environ;
struct input_ctx;
struct mode_key_cmdstr;
@ -1179,7 +1179,7 @@ enum cmd_find_type {
CMD_FIND_SESSION,
};
struct cmd_find_state {
struct cmd_q *cmdq;
struct cmdq_item *item;
int flags;
struct cmd_find_state *current;
@ -1233,35 +1233,36 @@ enum cmd_retval {
};
/* Command queue item type. */
enum cmd_q_type {
CMD_Q_COMMAND,
CMD_Q_CALLBACK,
enum cmdq_type {
CMDQ_COMMAND,
CMDQ_CALLBACK,
};
/* Command queue item. */
typedef enum cmd_retval (*cmd_q_cb) (struct cmd_q *, void *);
struct cmd_q {
struct cmd_q_list *queue;
struct cmd_q *next;
typedef enum cmd_retval (*cmdq_cb) (struct cmdq_item *, void *);
struct cmdq_item {
struct cmdq_list *queue;
struct cmdq_item *next;
struct client *client;
enum cmd_q_type type;
enum cmdq_type type;
u_int group;
u_int number;
time_t time;
const char *hook;
struct format_tree *formats;
int flags;
#define CMD_Q_FIRED 0x1
#define CMD_Q_WAITING 0x2
#define CMD_Q_NOHOOKS 0x4
#define CMDQ_FIRED 0x1
#define CMDQ_WAITING 0x2
#define CMDQ_NOHOOKS 0x4
struct cmd_list *cmdlist;
struct cmd *cmd;
cmd_q_cb cb;
cmdq_cb cb;
void *data;
struct cmd_find_state current;
@ -1269,9 +1270,9 @@ struct cmd_q {
struct mouse_event mouse;
TAILQ_ENTRY(cmd_q) entry;
TAILQ_ENTRY(cmdq_item) entry;
};
TAILQ_HEAD(cmd_q_list, cmd_q);
TAILQ_HEAD(cmdq_list, cmdq_item);
/* Command -c, -t or -s flags. */
enum cmd_entry_flag {
@ -1318,13 +1319,13 @@ struct cmd_entry {
#define CMD_AFTERHOOK 0x4
int flags;
enum cmd_retval (*exec)(struct cmd *, struct cmd_q *);
enum cmd_retval (*exec)(struct cmd *, struct cmdq_item *);
};
/* Client connection. */
struct client {
struct tmuxpeer *peer;
struct cmd_q_list queue;
struct cmdq_list queue;
pid_t pid;
int fd;
@ -1512,12 +1513,12 @@ void proc_kill_peer(struct tmuxpeer *);
/* cfg.c */
extern int cfg_finished;
extern struct client *cfg_client;
void start_cfg(void);
int load_cfg(const char *, struct client *, struct cmd_q *, int);
void set_cfg_file(const char *);
void start_cfg(void);
int load_cfg(const char *, struct client *, struct cmdq_item *, int);
void set_cfg_file(const char *);
void printflike(1, 2) cfg_add_cause(const char *, ...);
void cfg_print_causes(struct cmd_q *);
void cfg_show_causes(struct session *);
void cfg_print_causes(struct cmdq_item *);
void cfg_show_causes(struct session *);
/* paste.c */
struct paste_buffer;
@ -1538,7 +1539,7 @@ char *paste_make_sample(struct paste_buffer *);
#define FORMAT_STATUS 0x1
#define FORMAT_FORCE 0x2
struct format_tree;
struct format_tree *format_create(struct cmd_q *, int);
struct format_tree *format_create(struct cmdq_item *, int);
void format_free(struct format_tree *);
void printflike(3, 4) format_add(struct format_tree *, const char *,
const char *, ...);
@ -1565,7 +1566,7 @@ void hooks_remove(struct hooks *, const char *);
struct hook *hooks_find(struct hooks *, const char *);
void printflike(4, 5) hooks_run(struct hooks *, struct client *,
struct cmd_find_state *, const char *, ...);
void printflike(4, 5) hooks_insert(struct hooks *, struct cmd_q *,
void printflike(4, 5) hooks_insert(struct hooks *, struct cmdq_item *,
struct cmd_find_state *, const char *, ...);
/* mode-key.c */
@ -1583,7 +1584,6 @@ void mode_key_init(struct mode_key_data *, struct mode_key_tree *);
enum mode_key_cmd mode_key_lookup(struct mode_key_data *, key_code);
/* notify.c */
void notify_drain(void);
void notify_input(struct window_pane *, struct evbuffer *);
void notify_window_layout_changed(struct window *);
void notify_window_unlinked(struct session *, struct window *);
@ -1731,14 +1731,14 @@ long long args_strtonum(struct args *, u_char, long long, long long,
char **);
/* cmd-find.c */
int cmd_find_current(struct cmd_find_state *, struct cmd_q *,
int cmd_find_current(struct cmd_find_state *, struct cmdq_item *,
int);
int cmd_find_target(struct cmd_find_state *,
struct cmd_find_state *, struct cmd_q *, const char *,
struct cmd_find_state *, struct cmdq_item *, const char *,
enum cmd_find_type, int);
struct client *cmd_find_client(struct cmd_q *, const char *, int);
void cmd_find_clear_state(struct cmd_find_state *, struct cmd_q *,
int);
struct client *cmd_find_client(struct cmdq_item *, const char *, int);
void cmd_find_clear_state(struct cmd_find_state *,
struct cmdq_item *, int);
int cmd_find_empty_state(struct cmd_find_state *);
int cmd_find_valid_state(struct cmd_find_state *);
void cmd_find_copy_state(struct cmd_find_state *,
@ -1761,7 +1761,7 @@ char **cmd_copy_argv(int, char **);
void cmd_free_argv(int, char **);
char *cmd_stringify_argv(int, char **);
struct cmd *cmd_parse(int, char **, const char *, u_int, char **);
int cmd_prepare_state(struct cmd *, struct cmd_q *);
int cmd_prepare_state(struct cmd *, struct cmdq_item *);
char *cmd_print(struct cmd *);
int cmd_mouse_at(struct window_pane *, struct mouse_event *,
u_int *, u_int *, int);
@ -1772,8 +1772,8 @@ char *cmd_template_replace(const char *, const char *, int);
extern const struct cmd_entry *cmd_table[];
/* cmd-attach-session.c */
enum cmd_retval cmd_attach_session(struct cmd_q *, int, int, const char *,
int);
enum cmd_retval cmd_attach_session(struct cmdq_item *, int, int, const char *,
int);
/* cmd-list.c */
struct cmd_list *cmd_list_parse(int, char **, const char *, u_int, char **);
@ -1781,15 +1781,17 @@ void cmd_list_free(struct cmd_list *);
char *cmd_list_print(struct cmd_list *);
/* cmd-queue.c */
struct cmd_q *cmdq_get_command(struct cmd_list *, struct cmd_find_state *,
struct cmdq_item *cmdq_get_command(struct cmd_list *, struct cmd_find_state *,
struct mouse_event *, int);
struct cmd_q *cmdq_get_callback(cmd_q_cb, void *);
void cmdq_insert_after(struct cmd_q *, struct cmd_q *);
void cmdq_append(struct client *, struct cmd_q *);
struct cmdq_item *cmdq_get_callback(cmdq_cb, void *);
void cmdq_insert_after(struct cmdq_item *, struct cmdq_item *);
void cmdq_append(struct client *, struct cmdq_item *);
void printflike(3, 4) cmdq_format(struct cmdq_item *, const char *,
const char *, ...);
u_int cmdq_next(struct client *);
void cmdq_guard(struct cmd_q *, const char *, int);
void printflike(2, 3) cmdq_print(struct cmd_q *, const char *, ...);
void printflike(2, 3) cmdq_error(struct cmd_q *, const char *, ...);
void cmdq_guard(struct cmdq_item *, const char *, int);
void printflike(2, 3) cmdq_print(struct cmdq_item *, const char *, ...);
void printflike(2, 3) cmdq_error(struct cmdq_item *, const char *, ...);
/* cmd-string.c */
int cmd_string_parse(const char *, struct cmd_list **, const char *,

10
window-choose.c
View File

@ -244,9 +244,9 @@ window_choose_data_free(struct window_choose_data *wcd)
void
window_choose_data_run(struct window_choose_data *cdata)
{
struct cmd_list *cmdlist;
char *cause;
struct cmd_q *cmdq;
struct cmd_list *cmdlist;
char *cause;
struct cmdq_item *item;
/*
* The command template will have already been replaced. But if it's
@ -264,8 +264,8 @@ window_choose_data_run(struct window_choose_data *cdata)
return;
}
cmdq = cmdq_get_command(cmdlist, NULL, NULL, 0);
cmdq_append(cdata->start_client, cmdq);
item = cmdq_get_command(cmdlist, NULL, NULL, 0);
cmdq_append(cdata->start_client, item);
cmd_list_free(cmdlist);
}