circlecloud/tmux
1
0
Fork 0
mirror of https://github.com/tmux/tmux.git synced 2026-07-03 10:22:29 +00:00
Code Issues Projects Releases Wiki Activity

Simplify args stuff.

Browse Source
This commit is contained in:
Nicholas Marriott
2026-06-30 17:19:37 +01:00
parent 91ea9e4beb
commit a97912a4f8
7 changed files with 220 additions and 304 deletions
Download Patch File Download Diff File Expand all files Collapse all files

183
arguments.c
View File

@@ -51,15 +51,6 @@ struct args {
struct args_value *values; struct args_value *values;
}; };
/* Prepared command state. */
struct args_command_state {
struct cmd_parse_tree *tree;
char *cmd;
struct cmd_parse_input pi;
char *error;
int parse_input;
};
static struct args_entry *args_find(struct args *, u_char); static struct args_entry *args_find(struct args *, u_char);
static int args_cmp(struct args_entry *, struct args_entry *); static int args_cmp(struct args_entry *, struct args_entry *);
@@ -748,151 +739,53 @@ args_string(struct args *args, u_int idx)
return (args_value_as_string(&args->values[idx])); return (args_value_as_string(&args->values[idx]));
} }
/* Make a command now. */ /*
struct cmdq_item * * Convert one command argument into a parse tree. A string value is parsed;
args_command_now(struct cmd *self, struct cmdq_item *item, u_int idx, * existing commands are referenced.
int expand) */
struct cmd_parse_tree *
args_to_commands(struct cmd *self, struct cmdq_item *item, u_int idx,
const char *default_command, int expand, char **cause)
{ {
struct args_command_state *state; struct args *args = cmd_get_args(self);
struct cmdq_item *new_item; struct args_value *value;
struct cmdq_state *cs = cmdq_get_state(item); struct cmd_parse_input pi = { 0 };
char *error; const char *cmd = NULL, *file;
char *expanded;
struct cmd_parse_tree *tree;
state = args_command_prepare(self, item, idx, NULL, expand); *cause = NULL;
new_item = args_command_get(state, 0, NULL, cs, &error);
if (new_item == NULL) {
cmdq_error(item, "%s", error);
free(error);
}
args_command_free(state);
return (new_item);
}
/* Save bits to make a command later. */ if (idx >= args->count)
struct args_command_state *
args_command_prepare(struct cmd *self, struct cmdq_item *item, u_int idx,
const char *default_command, int expand)
{
struct args *args = cmd_get_args(self);
struct args_value *value;
struct args_command_state *state;
const char *cmd = NULL;
const char *file;
state = xcalloc(1, sizeof *state);
state->pi.flags = cmd_get_parse_flags(self);
cmd_get_source(self, &file, &state->pi.line);
if (file != NULL)
state->pi.file = xstrdup(file);
if (idx < args->count) {
value = &args->values[idx];
if (value->type == ARGS_COMMANDS) {
state->tree = cmd_parse_add_ref(value->cmd);
return (state);
}
if (value->type != ARGS_STRING)
fatalx("argument not string or commands");
cmd = value->string;
} else {
if (default_command == NULL)
fatalx("argument out of range");
cmd = default_command; cmd = default_command;
else {
value = &args->values[idx];
switch (value->type) {
case ARGS_COMMANDS:
return (cmd_parse_add_ref(value->cmd));
case ARGS_STRING:
cmd = value->string;
break;
case ARGS_NONE:
break;
}
} }
if (cmd == NULL)
fatalx("argument out of range");
if (expand) if (expand)
state->cmd = format_single_from_target(item, cmd); expanded = format_single_from_target(item, cmd);
else else
state->cmd = xstrdup(cmd); expanded = xstrdup(cmd);
log_debug("%s: %s", __func__, state->cmd); log_debug("%s: %s", __func__, expanded);
if (strcmp(state->cmd, "%1") == 0) cmd_get_source(self, &file, &pi.line);
state->parse_input = 1; if (file != NULL)
else { pi.file = file;
state->tree = cmd_parse_from_string(state->cmd, &state->pi, pi.flags = cmd_get_parse_flags(self);
&state->error); tree = cmd_parse_from_string(expanded, &pi, cause);
} free(expanded);
return (tree);
return (state);
}
/* Return argument as command queue item. */
struct cmdq_item *
args_command_get(struct args_command_state *state, int argc, char **argv,
struct cmdq_state *qstate, char **error)
{
struct cmd_invoke_input ci = { 0 };
struct cmd_parse_tree *tree;
struct cmdq_item *item;
int free_tree = 0;
if (state->error != NULL) {
*error = xstrdup(state->error);
return (NULL);
}
ci.file = state->pi.file;
ci.flags = state->pi.flags;
if (state->parse_input) {
if (argc == 0 || argv[0] == NULL) {
*error = xstrdup("missing command");
return (NULL);
}
tree = cmd_parse_from_string(argv[0], &state->pi, error);
if (tree == NULL)
return (NULL);
free_tree = 1;
} else {
if (state->tree == NULL)
fatalx("no command tree");
tree = state->tree;
ci.argc = argc;
ci.argv = argv;
}
item = cmd_invoke_get(tree, qstate, &ci);
if (free_tree)
cmd_parse_free(tree);
return (item);
}
/* Free commands state. */
void
args_command_free(struct args_command_state *state)
{
if (state->tree != NULL)
cmd_parse_free(state->tree);
free((void *)state->pi.file);
free(state->cmd);
free(state->error);
free(state);
}
/* Get prepared command. */
char *
args_command_get_command(struct args_command_state *state)
{
int n;
char *s, *tmp;
if (state->parse_input)
return (xstrdup(""));
if (state->cmd == NULL && state->tree != NULL) {
tmp = cmd_parse_print(state->tree);
n = strcspn(tmp, " ,");
xasprintf(&s, "%.*s", n, tmp);
free(tmp);
return (s);
}
if (state->cmd != NULL) {
n = strcspn(state->cmd, " ,");
xasprintf(&s, "%.*s", n, state->cmd);
return (s);
}
return (xstrdup(""));
} }
/* Get first value in argument. */ /* Get first value in argument. */

64
cmd-command-prompt.c
View File

@@ -57,7 +57,7 @@ struct cmd_command_prompt_prompt {
struct cmd_command_prompt_cdata { struct cmd_command_prompt_cdata {
struct cmdq_item *item; struct cmdq_item *item;
struct args_command_state *state; struct cmd_parse_tree *tree;
int flags; int flags;
enum prompt_type prompt_type; enum prompt_type prompt_type;
@@ -85,13 +85,13 @@ cmd_command_prompt_exec(struct cmd *self, struct cmdq_item *item)
struct args *args = cmd_get_args(self); struct args *args = cmd_get_args(self);
struct client *tc = cmdq_get_target_client(item); struct client *tc = cmdq_get_target_client(item);
struct cmd_find_state *target = cmdq_get_target(item); struct cmd_find_state *target = cmdq_get_target(item);
const char *type, *s, *input; const char *type, *s, *input, *cmd;
struct cmd_command_prompt_cdata *cdata; struct cmd_command_prompt_cdata *cdata;
char *tmp, *prompts, *prompt, *next_prompt; char *tmp, *prompts, *prompt, *next_prompt;
char *inputs = NULL, *next_input; char *inputs = NULL, *next_input, *cause = NULL;
struct window_pane *wp = target->wp; struct window_pane *wp = target->wp;
u_int count = args_count(args); u_int count = args_count(args);
int wait = !args_has(args, 'b'), space = 1; int wait = !args_has(args, 'b'), space = 1, n;
int pane = args_has(args, 'P'); int pane = args_has(args, 'P');
if (pane) { if (pane) {
@@ -107,14 +107,22 @@ cmd_command_prompt_exec(struct cmd *self, struct cmdq_item *item)
cdata->item = item; cdata->item = item;
if (pane) if (pane)
cdata->wp = wp; cdata->wp = wp;
cdata->state = args_command_prepare(self, item, 0, "%1", if (count != 0) {
args_has(args, 'F')); cdata->tree = args_to_commands(self, item, 0, NULL,
args_has(args, 'F'), &cause);
if (cdata->tree == NULL) {
cmdq_error(item, "%s", cause);
free(cause);
free(cdata);
return (CMD_RETURN_ERROR);
}
}
if ((s = args_get(args, 'p')) == NULL) { if ((s = args_get(args, 'p')) == NULL) {
if (count != 0) { if (count != 0) {
tmp = args_command_get_command(cdata->state); cmd = args_string(args, 0);
xasprintf(&prompts, "(%s)", tmp); n = strcspn(cmd, " ,");
free(tmp); xasprintf(&prompts, "(%.*s)", n, cmd);
} else { } else {
prompts = xstrdup(":"); prompts = xstrdup(":");
space = 0; space = 0;
@@ -203,6 +211,9 @@ cmd_command_prompt_callback(struct client *c, void *data, const char *s,
struct cmdq_item *item = cdata->item, *new_item; struct cmdq_item *item = cdata->item, *new_item;
struct cmdq_state *cs = NULL; struct cmdq_state *cs = NULL;
struct cmd_command_prompt_prompt *prompt; struct cmd_command_prompt_prompt *prompt;
struct cmd_invoke_input ci = { 0 };
struct cmd_parse_tree *tree;
struct cmd_parse_input pi = { 0 };
int argc = 0; int argc = 0;
char **argv = NULL; char **argv = NULL;
@@ -237,14 +248,33 @@ cmd_command_prompt_callback(struct client *c, void *data, const char *s,
if (item != NULL) if (item != NULL)
cs = cmdq_get_state(item); cs = cmdq_get_state(item);
new_item = args_command_get(cdata->state, argc, argv, cs, &error);
if (new_item == NULL) { if (cdata->tree != NULL) {
cmdq_append(c, cmdq_get_error(error)); /* Explicit body: prompt inputs become the template argv. */
free(error); ci.argc = argc;
} else if (item == NULL) { ci.argv = argv;
cmdq_append(c, new_item); new_item = cmd_invoke_get(cdata->tree, cs, &ci);
if (item == NULL)
cmdq_append(c, new_item);
else
cmdq_insert_after(item, new_item);
} else { } else {
cmdq_insert_after(item, new_item); /* No body: parse the submitted text as command language. */
tree = cmd_parse_from_string(s, &pi, &error);
if (tree == NULL) {
if (item == NULL)
cmdq_append(c, cmdq_get_error(error));
else
cmdq_error(item, "%s", error);
free(error);
} else {
new_item = cmd_invoke_get(tree, cs, NULL);
cmd_parse_free(tree);
if (item == NULL)
cmdq_append(c, new_item);
else
cmdq_insert_after(item, new_item);
}
} }
cmd_free_argv(argc, argv); cmd_free_argv(argc, argv);
@@ -281,6 +311,6 @@ cmd_command_prompt_free(void *data)
} }
free(cdata->prompts); free(cdata->prompts);
cmd_free_argv(cdata->argc, cdata->argv); cmd_free_argv(cdata->argc, cdata->argv);
args_command_free(cdata->state); cmd_parse_free(cdata->tree);
free(cdata); free(cdata);
} }

51
cmd-confirm-before.c
View File

@@ -50,10 +50,10 @@ const struct cmd_entry cmd_confirm_before_entry = {
}; };
struct cmd_confirm_before_data { struct cmd_confirm_before_data {
struct cmdq_item *item; struct cmdq_item *item;
struct args_command_state *state; struct cmd_parse_tree *tree;
u_char confirm_key; u_char confirm_key;
int default_yes; int default_yes;
}; };
static enum args_parse_type static enum args_parse_type
@@ -70,13 +70,18 @@ cmd_confirm_before_exec(struct cmd *self, struct cmdq_item *item)
struct cmd_confirm_before_data *cdata; struct cmd_confirm_before_data *cdata;
struct client *tc = cmdq_get_target_client(item); struct client *tc = cmdq_get_target_client(item);
struct cmd_find_state *target = cmdq_get_target(item); struct cmd_find_state *target = cmdq_get_target(item);
char *new_prompt; char *new_prompt, *cause = NULL;
const char *confirm_key, *prompt; const char *confirm_key, *prompt, *cmd;
char *cmd; int wait = !args_has(args, 'b'), n;
int wait = !args_has(args, 'b');
cdata = xcalloc(1, sizeof *cdata); cdata = xcalloc(1, sizeof *cdata);
cdata->state = args_command_prepare(self, item, 0, NULL, 1); cdata->tree = args_to_commands(self, item, 0, NULL, 1, &cause);
if (cdata->tree == NULL) {
cmdq_error(item, "%s", cause);
free(cause);
free(cdata);
return (CMD_RETURN_ERROR);
}
if (wait) if (wait)
cdata->item = item; cdata->item = item;
@@ -89,7 +94,7 @@ cmd_confirm_before_exec(struct cmd *self, struct cmdq_item *item)
cdata->confirm_key = confirm_key[0]; cdata->confirm_key = confirm_key[0];
else { else {
cmdq_error(item, "invalid confirm key"); cmdq_error(item, "invalid confirm key");
args_command_free(cdata->state); cmd_parse_free(cdata->tree);
free(cdata); free(cdata);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
@@ -100,10 +105,10 @@ cmd_confirm_before_exec(struct cmd *self, struct cmdq_item *item)
if ((prompt = args_get(args, 'p')) != NULL) if ((prompt = args_get(args, 'p')) != NULL)
xasprintf(&new_prompt, "%s ", prompt); xasprintf(&new_prompt, "%s ", prompt);
else { else {
cmd = args_command_get_command(cdata->state); cmd = args_string(args, 0);
xasprintf(&new_prompt, "Confirm '%s'? (%c/n) ", cmd, n = strcspn(cmd, " ,");
xasprintf(&new_prompt, "Confirm '%.*s'? (%c/n) ", n, cmd,
cdata->confirm_key); cdata->confirm_key);
free(cmd);
} }
status_prompt_set(tc, target, new_prompt, NULL, status_prompt_set(tc, target, new_prompt, NULL,
@@ -122,7 +127,6 @@ cmd_confirm_before_callback(struct client *c, void *data, const char *s,
{ {
struct cmd_confirm_before_data *cdata = data; struct cmd_confirm_before_data *cdata = data;
struct cmdq_item *item = cdata->item, *new_item; struct cmdq_item *item = cdata->item, *new_item;
char *error;
int retcode = 1; int retcode = 1;
if (c->flags & CLIENT_DEAD) if (c->flags & CLIENT_DEAD)
@@ -135,22 +139,11 @@ cmd_confirm_before_callback(struct client *c, void *data, const char *s,
retcode = 0; retcode = 0;
if (item == NULL) { if (item == NULL) {
new_item = args_command_get(cdata->state, 0, NULL, NULL, new_item = cmd_invoke_get(cdata->tree, NULL, NULL);
&error);
if (new_item == NULL) {
cmdq_append(c, cmdq_get_error(error));
free(error);
goto out;
}
cmdq_append(c, new_item); cmdq_append(c, new_item);
} else { } else {
new_item = args_command_get(cdata->state, 0, NULL, new_item = cmd_invoke_get(cdata->tree, cmdq_get_state(item),
cmdq_get_state(item), &error); NULL);
if (new_item == NULL) {
cmdq_error(item, "%s", error);
free(error);
goto out;
}
cmdq_insert_after(item, new_item); cmdq_insert_after(item, new_item);
} }
@@ -169,6 +162,6 @@ cmd_confirm_before_free(void *data)
{ {
struct cmd_confirm_before_data *cdata = data; struct cmd_confirm_before_data *cdata = data;
args_command_free(cdata->state); cmd_parse_free(cdata->tree);
free(cdata); free(cdata);
} }

47
cmd-display-panes.c
View File

@@ -44,8 +44,8 @@ const struct cmd_entry cmd_display_panes_entry = {
}; };
struct cmd_display_panes_data { struct cmd_display_panes_data {
struct cmdq_item *item; struct cmdq_item *item;
struct args_command_state *state; struct cmd_parse_tree *tree;
}; };
struct cmd_display_panes_ctx { struct cmd_display_panes_ctx {
@@ -297,7 +297,7 @@ cmd_display_panes_free(__unused struct client *c, void *data)
if (cdata->item != NULL) if (cdata->item != NULL)
cmdq_continue(cdata->item); cmdq_continue(cdata->item);
args_command_free(cdata->state); cmd_parse_free(cdata->tree);
free(cdata); free(cdata);
} }
@@ -305,9 +305,9 @@ static int
cmd_display_panes_key(struct client *c, void *data, struct key_event *event) cmd_display_panes_key(struct client *c, void *data, struct key_event *event)
{ {
struct cmd_display_panes_data *cdata = data; struct cmd_display_panes_data *cdata = data;
char *expanded, *error; char *expanded;
struct cmd_invoke_input ci = { 0 };
struct cmdq_item *item = cdata->item, *new_item; struct cmdq_item *item = cdata->item, *new_item;
struct cmdq_state *cs = NULL;
struct window *w = c->session->curw->window; struct window *w = c->session->curw->window;
struct window_pane *wp; struct window_pane *wp;
u_int index; u_int index;
@@ -330,20 +330,14 @@ cmd_display_panes_key(struct client *c, void *data, struct key_event *event)
window_unzoom(w, 1); window_unzoom(w, 1);
xasprintf(&expanded, "%%%u", wp->id); xasprintf(&expanded, "%%%u", wp->id);
ci.argc = 1;
ci.argv = &expanded;
if (item != NULL) new_item = cmd_invoke_get(cdata->tree, cmdq_get_state(item), &ci);
cs = cmdq_get_state(item); if (item == NULL)
new_item = args_command_get(cdata->state, 1, &expanded, cs, cmdq_append(c, new_item);
&error); else
if (new_item == NULL) { cmdq_insert_after(item, new_item);
cmdq_append(c, cmdq_get_error(error));
free(error);
} else {
if (item == NULL)
cmdq_append(c, new_item);
else
cmdq_insert_after(item, new_item);
}
free(expanded); free(expanded);
return (1); return (1);
@@ -363,21 +357,28 @@ cmd_display_panes_exec(struct cmd *self, struct cmdq_item *item)
if (tc->overlay_draw != NULL) if (tc->overlay_draw != NULL)
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
if (args_has(args, 'd')) { if (!args_has(args, 'd'))
delay = options_get_number(s->options, "display-panes-time");
else {
delay = args_strtonum(args, 'd', 0, UINT_MAX, &cause); delay = args_strtonum(args, 'd', 0, UINT_MAX, &cause);
if (cause != NULL) { if (cause != NULL) {
cmdq_error(item, "delay %s", cause); cmdq_error(item, "delay %s", cause);
free(cause); free(cause);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
} else }
delay = options_get_number(s->options, "display-panes-time");
cdata = xcalloc(1, sizeof *cdata); cdata = xcalloc(1, sizeof *cdata);
if (wait) if (wait)
cdata->item = item; cdata->item = item;
cdata->state = args_command_prepare(self, item, 0, cdata->tree = args_to_commands(self, item, 0, "select-pane -t \"%%%\"",
"select-pane -t \"%%%\"", 0); 0, &cause);
if (cdata->tree == NULL) {
cmdq_error(item, "%s", cause);
free(cause);
free(cdata);
return (CMD_RETURN_ERROR);
}
if (args_has(args, 'N')) { if (args_has(args, 'N')) {
server_client_set_overlay(tc, delay, NULL, NULL, server_client_set_overlay(tc, delay, NULL, NULL,

94
cmd-if-shell.c
View File

@@ -53,11 +53,11 @@ const struct cmd_entry cmd_if_shell_entry = {
}; };
struct cmd_if_shell_data { struct cmd_if_shell_data {
struct args_command_state *cmd_if; struct cmd_parse_tree *cmd_if;
struct args_command_state *cmd_else; struct cmd_parse_tree *cmd_else;
struct client *client; struct client *client;
struct cmdq_item *item; struct cmdq_item *item;
}; };
static enum args_parse_type static enum args_parse_type
@@ -76,42 +76,58 @@ cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
struct cmd_find_state *target = cmdq_get_target(item); struct cmd_find_state *target = cmdq_get_target(item);
struct cmd_if_shell_data *cdata; struct cmd_if_shell_data *cdata;
struct cmdq_item *new_item; struct cmdq_item *new_item;
char *shellcmd; struct cmd_parse_tree *tree;
char *shellcmd, *cause = NULL;
struct client *tc = cmdq_get_target_client(item); struct client *tc = cmdq_get_target_client(item);
struct session *s = target->s; struct session *s = target->s;
u_int count = args_count(args); u_int count = args_count(args), idx;
int wait = !args_has(args, 'b'); int wait = !args_has(args, 'b');
shellcmd = format_single_from_target(item, args_string(args, 0)); shellcmd = format_single_from_target(item, args_string(args, 0));
if (args_has(args, 'F')) { if (args_has(args, 'F')) {
if (*shellcmd != '0' && *shellcmd != '\0') if (*shellcmd != '0' && *shellcmd != '\0')
new_item = args_command_now(self, item, 1, 0); idx = 1;
else if (count == 3) else if (count == 3)
new_item = args_command_now(self, item, 2, 0); idx = 2;
else { else {
free(shellcmd); free(shellcmd);
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
} }
free(shellcmd); free(shellcmd);
if (new_item == NULL)
tree = args_to_commands(self, item, idx, NULL, 0, &cause);
if (tree == NULL) {
cmdq_error(item, "%s", cause);
free(cause);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
}
new_item = cmd_invoke_get(tree, cmdq_get_state(item), NULL);
cmd_parse_free(tree);
cmdq_insert_after(item, new_item); cmdq_insert_after(item, new_item);
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
} }
cdata = xcalloc(1, sizeof *cdata); cdata = xcalloc(1, sizeof *cdata);
cdata->cmd_if = args_to_commands(self, item, 1, NULL, 0, &cause);
cdata->cmd_if = args_command_prepare(self, item, 1, NULL, 0); if (cdata->cmd_if == NULL) {
cmdq_error(item, "%s", cause);
goto fail;
}
if (count == 3) { if (count == 3) {
cdata->cmd_else = args_command_prepare(self, item, 2, cdata->cmd_else = args_to_commands(self, item, 2, NULL, 0,
NULL, 0); &cause);
if (cdata->cmd_else == NULL) {
cmdq_error(item, "%s", cause);
goto fail;
}
} }
if (wait) { if (!wait)
cdata->client = tc;
else {
cdata->client = cmdq_get_client(item); cdata->client = cmdq_get_client(item);
cdata->item = item; cdata->item = item;
} else }
cdata->client = tc;
if (cdata->client != NULL) if (cdata->client != NULL)
cdata->client->references++; cdata->client->references++;
@@ -120,15 +136,19 @@ cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
cmd_if_shell_callback, cmd_if_shell_free, cdata, 0, -1, cmd_if_shell_callback, cmd_if_shell_free, cdata, 0, -1,
-1) == NULL) { -1) == NULL) {
cmdq_error(item, "failed to run command: %s", shellcmd); cmdq_error(item, "failed to run command: %s", shellcmd);
free(shellcmd); goto fail;
cmd_if_shell_free(cdata);
return (CMD_RETURN_ERROR);
} }
free(shellcmd); free(shellcmd);
if (!wait) if (!wait)
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
return (CMD_RETURN_WAIT); return (CMD_RETURN_WAIT);
fail:
free(cause);
free(shellcmd);
cmd_if_shell_free(cdata);
return (CMD_RETURN_ERROR);
} }
static void static void
@@ -137,35 +157,23 @@ cmd_if_shell_callback(struct job *job)
struct cmd_if_shell_data *cdata = job_get_data(job); struct cmd_if_shell_data *cdata = job_get_data(job);
struct client *c = cdata->client; struct client *c = cdata->client;
struct cmdq_item *item = cdata->item, *new_item; struct cmdq_item *item = cdata->item, *new_item;
struct cmdq_state *cs = NULL; struct cmd_parse_tree *tree;
struct args_command_state *state;
char *error;
int status; int status;
status = job_get_status(job); status = job_get_status(job);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
state = cdata->cmd_else; tree = cdata->cmd_else;
else else
state = cdata->cmd_if; tree = cdata->cmd_if;
if (state == NULL) if (tree == NULL)
goto out; goto out;
if (item != NULL) if (item == NULL) {
cs = cmdq_get_state(item); new_item = cmd_invoke_get(tree, NULL, NULL);
new_item = args_command_get(state, 0, NULL, cs, &error); cmdq_append(c, new_item);
if (new_item == NULL) {
if (cdata->item != NULL)
cmdq_error(cdata->item, "%s", error);
else {
*error = toupper((u_char)*error);
status_message_set(c, -1, 1, 0, 0, "%s", error);
}
free(error);
} else { } else {
if (item == NULL) new_item = cmd_invoke_get(tree, cmdq_get_state(item), NULL);
cmdq_append(c, new_item); cmdq_insert_after(item, new_item);
else
cmdq_insert_after(item, new_item);
} }
out: out:
@@ -182,8 +190,8 @@ cmd_if_shell_free(void *data)
server_client_unref(cdata->client); server_client_unref(cdata->client);
if (cdata->cmd_else != NULL) if (cdata->cmd_else != NULL)
args_command_free(cdata->cmd_else); cmd_parse_free(cdata->cmd_else);
args_command_free(cdata->cmd_if); if (cdata->cmd_if != NULL)
cmd_parse_free(cdata->cmd_if);
free(cdata); free(cdata);
} }

74
cmd-run-shell.c
View File

@@ -55,15 +55,15 @@ const struct cmd_entry cmd_run_shell_entry = {
}; };
struct cmd_run_shell_data { struct cmd_run_shell_data {
struct client *client; struct client *client;
char *cmd; char *cmd;
struct args_command_state *state; struct cmd_parse_tree *tree;
char *cwd; char *cwd;
struct cmdq_item *item; struct cmdq_item *item;
struct session *s; struct session *s;
int wp_id; int wp_id;
struct event timer; struct event timer;
int flags; int flags;
}; };
static enum args_parse_type static enum args_parse_type
@@ -118,7 +118,7 @@ cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
struct format_tree *ft; struct format_tree *ft;
double d; double d;
struct timeval tv; struct timeval tv;
char *end, key[16]; char *end, key[16], *cause = NULL;
u_int i; u_int i;
int wait = !args_has(args, 'b'); int wait = !args_has(args, 'b');
@@ -128,8 +128,10 @@ cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
cmdq_error(item, "invalid delay time: %s", delay); cmdq_error(item, "invalid delay time: %s", delay);
return (CMD_RETURN_ERROR); return (CMD_RETURN_ERROR);
} }
} else if (args_count(args) == 0) } else {
return (CMD_RETURN_NORMAL); if (args_count(args) == 0)
return (CMD_RETURN_NORMAL);
}
cdata = xcalloc(1, sizeof *cdata); cdata = xcalloc(1, sizeof *cdata);
if (!args_has(args, 'C')) { if (!args_has(args, 'C')) {
@@ -144,8 +146,13 @@ cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
format_free(ft); format_free(ft);
} }
} else { } else {
cdata->state = args_command_prepare(self, item, 0, NULL, cdata->tree = args_to_commands(self, item, 0, NULL, 1, &cause);
1); if (cdata->tree == NULL) {
cmdq_error(item, "%s", cause);
free(cause);
cmd_run_shell_free(cdata);
return (CMD_RETURN_ERROR);
}
} }
if (args_has(args, 't') && wp != NULL) if (args_has(args, 't') && wp != NULL)
@@ -162,6 +169,7 @@ cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
} }
if (cdata->client != NULL) if (cdata->client != NULL)
cdata->client->references++; cdata->client->references++;
if (args_has(args, 'c')) if (args_has(args, 'c'))
cdata->cwd = xstrdup(args_get(args, 'c')); cdata->cwd = xstrdup(args_get(args, 'c'));
else else
@@ -170,18 +178,20 @@ cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
if (args_has(args, 'E')) if (args_has(args, 'E'))
cdata->flags |= JOB_SHOWSTDERR; cdata->flags |= JOB_SHOWSTDERR;
cdata->s = s; if (s != NULL) {
if (s != NULL) cdata->s = s;
session_add_ref(s, __func__); session_add_ref(s, __func__);
}
evtimer_set(&cdata->timer, cmd_run_shell_timer, cdata); evtimer_set(&cdata->timer, cmd_run_shell_timer, cdata);
if (delay != NULL) { if (delay == NULL)
event_active(&cdata->timer, EV_TIMEOUT, 1);
else {
timerclear(&tv); timerclear(&tv);
tv.tv_sec = (time_t)d; tv.tv_sec = (time_t)d;
tv.tv_usec = (d - (double)tv.tv_sec) * 1000000U; tv.tv_usec = (d - (double)tv.tv_sec) * 1000000U;
evtimer_add(&cdata->timer, &tv); evtimer_add(&cdata->timer, &tv);
} else }
event_active(&cdata->timer, EV_TIMEOUT, 1);
if (!wait) if (!wait)
return (CMD_RETURN_NORMAL); return (CMD_RETURN_NORMAL);
@@ -196,9 +206,8 @@ cmd_run_shell_timer(__unused int fd, __unused short events, void* arg)
const char *cmd = cdata->cmd; const char *cmd = cdata->cmd;
struct cmdq_item *item = cdata->item, *new_item; struct cmdq_item *item = cdata->item, *new_item;
struct cmdq_state *cs = NULL; struct cmdq_state *cs = NULL;
char *error;
if (cdata->state == NULL) { if (cdata->tree == NULL) {
if (cmd == NULL) { if (cmd == NULL) {
if (cdata->item != NULL) if (cdata->item != NULL)
cmdq_continue(cdata->item); cmdq_continue(cdata->item);
@@ -223,21 +232,11 @@ cmd_run_shell_timer(__unused int fd, __unused short events, void* arg)
if (item != NULL) if (item != NULL)
cs = cmdq_get_state(item); cs = cmdq_get_state(item);
new_item = args_command_get(cdata->state, 0, NULL, cs, &error); new_item = cmd_invoke_get(cdata->tree, cs, NULL);
if (new_item == NULL) { if (item == NULL)
if (cdata->item != NULL) cmdq_append(c, new_item);
cmdq_error(cdata->item, "%s", error); else
else { cmdq_insert_after(item, new_item);
*error = toupper((u_char)*error);
status_message_set(c, -1, 1, 0, 0, "%s", error);
}
free(error);
} else {
if (item == NULL)
cmdq_append(c, new_item);
else
cmdq_insert_after(item, new_item);
}
if (cdata->item != NULL) if (cdata->item != NULL)
cmdq_continue(cdata->item); cmdq_continue(cdata->item);
@@ -305,8 +304,7 @@ cmd_run_shell_free(void *data)
session_remove_ref(cdata->s, __func__); session_remove_ref(cdata->s, __func__);
if (cdata->client != NULL) if (cdata->client != NULL)
server_client_unref(cdata->client); server_client_unref(cdata->client);
if (cdata->state != NULL) cmd_parse_free(cdata->tree);
args_command_free(cdata->state);
free(cdata->cwd); free(cdata->cwd);
free(cdata->cmd); free(cdata->cmd);
free(cdata); free(cdata);

11
tmux.h
View File

@@ -40,7 +40,6 @@
extern char **environ; extern char **environ;
struct args; struct args;
struct args_command_state;
struct client; struct client;
struct cmd; struct cmd;
struct cmd_find_state; struct cmd_find_state;
@@ -2898,14 +2897,8 @@ u_int args_count(struct args *);
struct args_value *args_values(struct args *); struct args_value *args_values(struct args *);
struct args_value *args_value(struct args *, u_int); struct args_value *args_value(struct args *, u_int);
const char *args_string(struct args *, u_int); const char *args_string(struct args *, u_int);
struct cmdq_item *args_command_now(struct cmd *, struct cmdq_item *, struct cmd_parse_tree *args_to_commands(struct cmd *, struct cmdq_item *,
u_int, int); u_int, const char *, int, char **);
struct args_command_state *args_command_prepare(struct cmd *,
struct cmdq_item *, u_int, const char *, int);
struct cmdq_item *args_command_get(struct args_command_state *, int, char **,
struct cmdq_state *, char **);
void args_command_free(struct args_command_state *);
char *args_command_get_command(struct args_command_state *);
struct args_value *args_first_value(struct args *, u_char); struct args_value *args_first_value(struct args *, u_char);
struct args_value *args_next_value(struct args_value *); struct args_value *args_next_value(struct args_value *);
long long args_strtonum(struct args *, u_char, long long, long long, long long args_strtonum(struct args *, u_char, long long, long long,