circlecloud/tmux
1
0
Fork 0
mirror of https://github.com/tmux/tmux.git synced 2024-11-17 18:08:51 +00:00
Code Issues Projects Releases Wiki Activity
5df9b3650a
tmux/cmd-queue.c

866 lines
19 KiB
C
Raw Normal View History

Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
/* $OpenBSD$ */
/*
I no longer use my SourceForge address so replace it.
2016-01-19 15:59:12 +00:00
* Copyright (c) 2013 Nicholas Marriott <nicholas.marriott@gmail.com>
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
* IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <sys/types.h>
#include <ctype.h>
#include <stdlib.h>
Rewrite of tmux mouse support which was a mess. Instead of having options for "mouse-this" and "mouse-that", mouse events may be bound as keys and there is one option "mouse" that turns on mouse support entirely (set -g mouse on). See the new MOUSE SUPPORT section of the man page for description of the key names and new flags (-t= to specify the pane or window under mouse as a target, and send-keys -M to pass through a mouse event). The default builtin bindings for the mouse are: bind -n MouseDown1Pane select-pane -t=; send-keys -M bind -n MouseDown1Status select-window -t= bind -n MouseDrag1Pane copy-mode -M bind -n MouseDrag1Border resize-pane -M To get the effect of turning mode-mouse off, do: unbind -n MouseDrag1Pane unbind -temacs-copy MouseDrag1Pane The old mouse options are now gone, set-option -q may be used to suppress warnings if mixing configuration files.
2015-04-19 21:34:21 +00:00
#include <string.h>
Fix compiler warnings, missing #include. From Thomas Adam.
2013-03-26 10:54:48 +00:00
#include <time.h>
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
#include "tmux.h"
Move the NOHOOKS flag into the shared flags.
2020-04-13 13:32:09 +00:00
/* Command queue flags. */
#define CMDQ_FIRED 0x1
#define CMDQ_WAITING 0x2
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
/* Command queue item type. */
enum cmdq_type {
CMDQ_COMMAND,
CMDQ_CALLBACK,
};
/* Command queue item. */
struct cmdq_item {
char *name;
struct cmdq_list *queue;
struct cmdq_item *next;
struct client *client;
Make client -c and -t handling common in cmd-queue.c and try to be clearer about whether the client is the target client (must have a session) or not.
2020-04-13 20:51:57 +00:00
struct client *target_client;
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
enum cmdq_type type;
u_int group;
u_int number;
time_t time;
int flags;
Rename cmdq_shared to cmdq_state which will better reflect what it is (going to be) used for.
2020-04-13 14:04:25 +00:00
struct cmdq_state *state;
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
struct cmd_find_state source;
struct cmd_find_state target;
struct cmd_list *cmdlist;
struct cmd *cmd;
cmdq_cb cb;
void *data;
TAILQ_ENTRY(cmdq_item) entry;
};
Provide an accessor for the running queue item and use it to not let hooks recurse.
2020-04-14 06:00:52 +00:00
TAILQ_HEAD(cmdq_item_list, cmdq_item);
Break cmdq_continue inner loop into a helper function.
2015-06-17 17:02:15 +00:00
Move cmdq_state into cmd-queue.c.
2020-04-13 14:46:04 +00:00
/*
* Command queue state. This is the context for commands on the command queue.
* It holds information about how the commands were fired (the key and flags),
* any additional formats for the commands, and the current default target.
* Multiple commands can share the same state and a command may update the
* default target.
*/
struct cmdq_state {
int references;
int flags;
struct format_tree *formats;
struct key_event event;
struct cmd_find_state current;
};
Provide an accessor for the running queue item and use it to not let hooks recurse.
2020-04-14 06:00:52 +00:00
/* Command queue. */
struct cmdq_list {
struct cmdq_item *item;
struct cmdq_item_list list;
};
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
/* Get command queue name. */
static const char *
cmdq_name(struct client *c)
{
Use client name when logging command queue.
2019-05-25 10:44:09 +00:00
static char s[256];
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
if (c == NULL)
return ("<global>");
Client name can actually be NULL, so use address in that case.
2019-05-25 10:46:55 +00:00
if (c->name != NULL)
xsnprintf(s, sizeof s, "<%s>", c->name);
else
xsnprintf(s, sizeof s, "<%p>", c);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
return (s);
}
/* Get command queue from client. */
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
static struct cmdq_list *
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
cmdq_get(struct client *c)
{
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
static struct cmdq_list *global_queue;
if (c == NULL) {
if (global_queue == NULL)
global_queue = cmdq_new();
return (global_queue);
}
return (c->queue);
}
/* Create a queue. */
struct cmdq_list *
cmdq_new(void)
{
struct cmdq_list *queue;
queue = xcalloc (1, sizeof *queue);
Provide an accessor for the running queue item and use it to not let hooks recurse.
2020-04-14 06:00:52 +00:00
TAILQ_INIT (&queue->list);
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
return (queue);
}
/* Free a queue. */
void
cmdq_free(struct cmdq_list *queue)
{
Provide an accessor for the running queue item and use it to not let hooks recurse.
2020-04-14 06:00:52 +00:00
if (!TAILQ_EMPTY(&queue->list))
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
fatalx("queue not empty");
free(queue);
}
/* Get item name. */
const char *
cmdq_get_name(struct cmdq_item *item)
{
return (item->name);
}
/* Get item client. */
struct client *
cmdq_get_client(struct cmdq_item *item)
{
return (item->client);
}
Make client -c and -t handling common in cmd-queue.c and try to be clearer about whether the client is the target client (must have a session) or not.
2020-04-13 20:51:57 +00:00
/* Get item target client. */
struct client *
cmdq_get_target_client(struct cmdq_item *item)
{
return (item->target_client);
}
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
/* Get item state. */
struct cmdq_state *
cmdq_get_state(struct cmdq_item *item)
{
return (item->state);
}
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
/* Get item target. */
struct cmd_find_state *
cmdq_get_target(struct cmdq_item *item)
{
return (&item->target);
}
/* Get item source. */
struct cmd_find_state *
cmdq_get_source(struct cmdq_item *item)
{
return (&item->source);
}
Move cmdq_state into cmd-queue.c.
2020-04-13 14:46:04 +00:00
/* Get state event. */
struct key_event *
cmdq_get_event(struct cmdq_item *item)
{
return (&item->state->event);
}
/* Get state current target. */
struct cmd_find_state *
cmdq_get_current(struct cmdq_item *item)
{
return (&item->state->current);
}
/* Get state flags. */
int
cmdq_get_flags(struct cmdq_item *item)
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
{
Move cmdq_state into cmd-queue.c.
2020-04-13 14:46:04 +00:00
return (item->state->flags);
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
}
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
/* Create a new state. */
struct cmdq_state *
cmdq_new_state(struct cmd_find_state *current, struct key_event *event,
int flags)
{
struct cmdq_state *state;
state = xcalloc(1, sizeof *state);
state->references = 1;
state->flags = flags;
if (event != NULL)
memcpy(&state->event, event, sizeof state->event);
else
state->event.key = KEYC_NONE;
if (current != NULL && cmd_find_valid_state(current))
cmd_find_copy_state(&state->current, current);
else
cmd_find_clear_state(&state->current, 0);
return (state);
}
/* Add a reference to a state. */
struct cmdq_state *
cmdq_link_state(struct cmdq_state *state)
{
state->references++;
return (state);
}
/* Make a copy of a state. */
struct cmdq_state *
cmdq_copy_state(struct cmdq_state *state)
{
return (cmdq_new_state(&state->current, &state->event, state->flags));
}
/* Free a state. */
void
cmdq_free_state(struct cmdq_state *state)
{
Fix a couple of memory leaks, one when creating a new pane and one when adding formats onto the queue item.
2020-04-23 05:48:42 +00:00
if (--state->references != 0)
return;
if (state->formats != NULL)
format_free(state->formats);
free(state);
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
}
/* Add a format to command queue. */
void
cmdq_add_format(struct cmdq_state *state, const char *key, const char *fmt, ...)
{
va_list ap;
char *value;
va_start(ap, fmt);
xvasprintf(&value, fmt, ap);
va_end(ap);
if (state->formats == NULL)
state->formats = format_create(NULL, NULL, FORMAT_NONE, 0);
format_add(state->formats, key, "%s", value);
free(value);
}
Also move cmdq_item and cmdq_list into cmd-queue.c (this is to make its use more clearly defined and preparation for some future work).
2020-04-13 10:59:58 +00:00
/* Merge formats from item. */
void
cmdq_merge_formats(struct cmdq_item *item, struct format_tree *ft)
{
const struct cmd_entry *entry;
if (item->cmd != NULL) {
entry = cmd_get_entry (item->cmd);
format_add(ft, "command", "%s", entry->name);
}
Rename cmdq_shared to cmdq_state which will better reflect what it is (going to be) used for.
2020-04-13 14:04:25 +00:00
if (item->state->formats != NULL)
format_merge(ft, item->state->formats);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
}
/* Append an item. */
When adding a list with multiple commands to the queue, the next item to insert after needs to be the last one added, not the first. Reported by Jason Kim in GitHub issue 2023.
2019-12-19 09:22:33 +00:00
struct cmdq_item *
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
cmdq_append(struct client *c, struct cmdq_item *item)
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
{
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
struct cmdq_list *queue = cmdq_get(c);
struct cmdq_item *next;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
do {
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
next = item->next;
item->next = NULL;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
if (c != NULL)
c->references++;
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
item->client = c;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
item->queue = queue;
Provide an accessor for the running queue item and use it to not let hooks recurse.
2020-04-14 06:00:52 +00:00
TAILQ_INSERT_TAIL(&queue->list, item, entry);
Correct ordering when adding after an existing item.
2019-05-03 15:43:01 +00:00
log_debug("%s %s: %s", __func__, cmdq_name(c), item->name);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
item = next;
} while (item != NULL);
Provide an accessor for the running queue item and use it to not let hooks recurse.
2020-04-14 06:00:52 +00:00
return (TAILQ_LAST(&queue->list, cmdq_item_list));
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
}
/* Insert an item. */
When adding a list with multiple commands to the queue, the next item to insert after needs to be the last one added, not the first. Reported by Jason Kim in GitHub issue 2023.
2019-12-19 09:22:33 +00:00
struct cmdq_item *
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
cmdq_insert_after(struct cmdq_item *after, struct cmdq_item *item)
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
{
struct client *c = after->client;
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
struct cmdq_list *queue = after->queue;
struct cmdq_item *next;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
do {
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
next = item->next;
Correct ordering when adding after an existing item.
2019-05-03 15:43:01 +00:00
item->next = after->next;
after->next = item;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
if (c != NULL)
c->references++;
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
item->client = c;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
item->queue = queue;
Provide an accessor for the running queue item and use it to not let hooks recurse.
2020-04-14 06:00:52 +00:00
TAILQ_INSERT_AFTER(&queue->list, after, item, entry);
Correct ordering when adding after an existing item.
2019-05-03 15:43:01 +00:00
log_debug("%s %s: %s after %s", __func__, cmdq_name(c),
item->name, after->name);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
Insert after the right element on queue.
2019-05-03 18:59:58 +00:00
after = item;
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
item = next;
} while (item != NULL);
When adding a list with multiple commands to the queue, the next item to insert after needs to be the last one added, not the first. Reported by Jason Kim in GitHub issue 2023.
2019-12-19 09:22:33 +00:00
return (after);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
}
Merge hooks into options and make each one an array option. This allows multiple commands to be easily bound to one hook. set-hook and show-hooks remain but they are now variants of set-option and show-options. show-options now has a -H flag to show hooks (by default they are not shown).
2019-04-26 11:38:51 +00:00
/* Insert a hook. */
void
cmdq_insert_hook(struct session *s, struct cmdq_item *item,
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
struct cmd_find_state *current, const char *fmt, ...)
Merge hooks into options and make each one an array option. This allows multiple commands to be easily bound to one hook. set-hook and show-hooks remain but they are now variants of set-option and show-options. show-options now has a -H flag to show hooks (by default they are not shown).
2019-04-26 11:38:51 +00:00
{
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
struct cmdq_state *state = item->state;
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
struct cmd *cmd = item->cmd;
struct args *args = cmd_get_args(cmd);
struct args_entry *entryp;
struct args_value *valuep;
Merge hooks into options and make each one an array option. This allows multiple commands to be easily bound to one hook. set-hook and show-hooks remain but they are now variants of set-option and show-options. show-options now has a -H flag to show hooks (by default they are not shown).
2019-04-26 11:38:51 +00:00
struct options *oo;
va_list ap;
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
char *name, tmp[32], flag, *arguments;
int i;
const char *value;
Merge hooks into options and make each one an array option. This allows multiple commands to be easily bound to one hook. set-hook and show-hooks remain but they are now variants of set-option and show-options. show-options now has a -H flag to show hooks (by default they are not shown).
2019-04-26 11:38:51 +00:00
struct cmdq_item *new_item;
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
struct cmdq_state *new_state;
Merge hooks into options and make each one an array option. This allows multiple commands to be easily bound to one hook. set-hook and show-hooks remain but they are now variants of set-option and show-options. show-options now has a -H flag to show hooks (by default they are not shown).
2019-04-26 11:38:51 +00:00
struct options_entry *o;
struct options_array_item *a;
struct cmd_list *cmdlist;
Rename cmdq_shared to cmdq_state which will better reflect what it is (going to be) used for.
2020-04-13 14:04:25 +00:00
if (item->state->flags & CMDQ_STATE_NOHOOKS)
Merge hooks into options and make each one an array option. This allows multiple commands to be easily bound to one hook. set-hook and show-hooks remain but they are now variants of set-option and show-options. show-options now has a -H flag to show hooks (by default they are not shown).
2019-04-26 11:38:51 +00:00
return;
if (s == NULL)
oo = global_s_options;
else
oo = s->options;
va_start(ap, fmt);
xvasprintf(&name, fmt, ap);
va_end(ap);
o = options_get(oo, name);
if (o == NULL) {
free(name);
return;
}
log_debug("running hook %s (parent %p)", name, item);
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
/*
* The hooks get a new state because they should not update the current
* target or formats for any subsequent commands.
*/
new_state = cmdq_new_state(current, &state->event, CMDQ_STATE_NOHOOKS);
cmdq_add_format(new_state, "hook", "%s", name);
Add formats for after hook command arguments.
2020-05-16 15:40:04 +00:00
arguments = args_print(args);
cmdq_add_format(new_state, "hook_arguments", "%s", arguments);
free(arguments);
for (i = 0; i < args->argc; i++) {
xsnprintf(tmp, sizeof tmp, "hook_argument_%d", i);
cmdq_add_format(new_state, tmp, "%s", args->argv[i]);
}
flag = args_first(args, &entryp);
while (flag != 0) {
value = args_get(args, flag);
if (value == NULL) {
xsnprintf(tmp, sizeof tmp, "hook_flag_%c", flag);
cmdq_add_format(new_state, tmp, "1");
} else {
xsnprintf(tmp, sizeof tmp, "hook_flag_%c", flag);
cmdq_add_format(new_state, tmp, "%s", value);
}
i = 0;
value = args_first_value(args, flag, &valuep);
while (value != NULL) {
xsnprintf(tmp, sizeof tmp, "hook_flag_%c_%d", flag, i);
cmdq_add_format(new_state, tmp, "%s", value);
i++;
value = args_next_value(&valuep);
}
flag = args_next(&entryp);
}
Merge hooks into options and make each one an array option. This allows multiple commands to be easily bound to one hook. set-hook and show-hooks remain but they are now variants of set-option and show-options. show-options now has a -H flag to show hooks (by default they are not shown).
2019-04-26 11:38:51 +00:00
a = options_array_first(o);
while (a != NULL) {
cmdlist = options_array_item_value(a)->cmdlist;
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
if (cmdlist != NULL) {
new_item = cmdq_get_command(cmdlist, new_state);
if (item != NULL)
item = cmdq_insert_after(item, new_item);
else
item = cmdq_append(NULL, new_item);
Merge hooks into options and make each one an array option. This allows multiple commands to be easily bound to one hook. set-hook and show-hooks remain but they are now variants of set-option and show-options. show-options now has a -H flag to show hooks (by default they are not shown).
2019-04-26 11:38:51 +00:00
}
a = options_array_next(a);
}
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
cmdq_free_state(new_state);
Merge hooks into options and make each one an array option. This allows multiple commands to be easily bound to one hook. set-hook and show-hooks remain but they are now variants of set-option and show-options. show-options now has a -H flag to show hooks (by default they are not shown).
2019-04-26 11:38:51 +00:00
free(name);
}
Add a cmdq_continue function rather than twiddling the flag directly.
2019-06-18 11:08:42 +00:00
/* Continue processing command queue. */
void
cmdq_continue(struct cmdq_item *item)
{
item->flags &= ~CMDQ_WAITING;
}
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
/* Remove an item. */
static void
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
cmdq_remove(struct cmdq_item *item)
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
{
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
if (item->client != NULL)
server_client_unref(item->client);
Break new window and pane creation common code from various commands and window.c into a separate file spawn.c.
2019-04-17 14:37:48 +00:00
if (item->cmdlist != NULL)
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
cmd_list_free(item->cmdlist);
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
cmdq_free_state(item->state);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
Provide an accessor for the running queue item and use it to not let hooks recurse.
2020-04-14 06:00:52 +00:00
TAILQ_REMOVE(&item->queue->list, item, entry);
Give each item on queue a name for better logging.
2016-10-18 08:46:43 +00:00
Correct ordering when adding after an existing item.
2019-05-03 15:43:01 +00:00
free(item->name);
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
free(item);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
}
/* Remove all subsequent items that match this item's group. */
static void
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
cmdq_remove_group(struct cmdq_item *item)
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
{
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
struct cmdq_item *this, *next;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
Don't remove group items for group 0 (no group).
2019-05-23 13:08:43 +00:00
if (item->group == 0)
return;
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
this = TAILQ_NEXT(item, entry);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
while (this != NULL) {
next = TAILQ_NEXT(this, entry);
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
if (this->group == item->group)
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
cmdq_remove(this);
this = next;
}
}
/* Get a command for the command queue. */
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
struct cmdq_item *
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
cmdq_get_command(struct cmd_list *cmdlist, struct cmdq_state *state)
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
{
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
struct cmdq_item *item, *first = NULL, *last = NULL;
struct cmd *cmd;
Make struct cmd local to cmd.c and move it out of tmux.h.
2020-04-13 08:26:27 +00:00
const struct cmd_entry *entry;
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
int created = 0;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
if (state == NULL) {
state = cmdq_new_state(NULL, NULL, 0);
created = 1;
}
cmd = cmd_list_first(cmdlist);
Make struct cmd local to cmd.c and move it out of tmux.h.
2020-04-13 08:26:27 +00:00
while (cmd != NULL) {
entry = cmd_get_entry(cmd);
The line number needs to be updated only after the \n is processed by the parser, so store a flag and update it next time around. Also each new line needs its own shared data.
2019-05-29 19:34:42 +00:00
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
item = xcalloc(1, sizeof *item);
Make struct cmd local to cmd.c and move it out of tmux.h.
2020-04-13 08:26:27 +00:00
xasprintf(&item->name, "[%s/%p]", entry->name, item);
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
item->type = CMDQ_COMMAND;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
item->group = cmd_get_group(cmd);
item->state = cmdq_link_state(state);
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
item->cmdlist = cmdlist;
item->cmd = cmd;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
cmdlist->references++;
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
log_debug("%s: %s group %u", __func__, item->name, item->group);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
if (first == NULL)
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
first = item;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
if (last != NULL)
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
last->next = item;
last = item;
Make struct cmd local to cmd.c and move it out of tmux.h.
2020-04-13 08:26:27 +00:00
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
cmd = cmd_list_next(cmd);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
}
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
if (created)
cmdq_free_state(state);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
return (first);
}
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
Get rid of the extra layer of flags and cmd_prepare() and just store the CMD_FIND_* flags in the cmd_entry and call it for the command. Commands with special requirements call it themselves and update the target for hooks to use.
2017-04-22 10:22:39 +00:00
/* Fill in flag for a command. */
static enum cmd_retval
cmdq_find_flag(struct cmdq_item *item, struct cmd_find_state *fs,
const struct cmd_entry_flag *flag)
{
const char *value;
if (flag->flag == 0) {
Expand target from client and use it to expand the prompt.
2020-05-16 16:16:07 +00:00
cmd_find_from_client(fs, item->target_client, 0);
Get rid of the extra layer of flags and cmd_prepare() and just store the CMD_FIND_* flags in the cmd_entry and call it for the command. Commands with special requirements call it themselves and update the target for hooks to use.
2017-04-22 10:22:39 +00:00
return (CMD_RETURN_NORMAL);
}
Make struct cmd local to cmd.c and move it out of tmux.h.
2020-04-13 08:26:27 +00:00
value = args_get(cmd_get_args(item->cmd), flag->flag);
Get rid of the extra layer of flags and cmd_prepare() and just store the CMD_FIND_* flags in the cmd_entry and call it for the command. Commands with special requirements call it themselves and update the target for hooks to use.
2017-04-22 10:22:39 +00:00
if (cmd_find_target(fs, item, value, flag->type, flag->flags) != 0) {
cmd_find_clear_state(fs, 0);
return (CMD_RETURN_ERROR);
}
return (CMD_RETURN_NORMAL);
}
Change message log to be per server rather than per client and include every command that is run.
2020-05-16 15:47:22 +00:00
/* Add message with command. */
static void
cmdq_add_message(struct cmdq_item *item)
{
struct client *c = item->client;
struct cmdq_state *state = item->state;
const char *name, *key;
char *tmp;
tmp = cmd_print(item->cmd);
if (c != NULL) {
name = c->name;
if (c->session != NULL && state->event.key != KEYC_NONE) {
Separate key flags and modifiers, log key flags, make the "xterm" flag more explicit and fix M- keys with a leading escape.
2020-05-16 16:35:13 +00:00
key = key_string_lookup_key(state->event.key, 0);
Change message log to be per server rather than per client and include every command that is run.
2020-05-16 15:47:22 +00:00
server_add_message("%s key %s: %s", name, key, tmp);
} else
server_add_message("%s command: %s", name, tmp);
} else
server_add_message("command: %s", tmp);
free(tmp);
}
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
/* Fire command on command queue. */
static enum cmd_retval
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
cmdq_fire_command(struct cmdq_item *item)
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
{
Make client -c and -t handling common in cmd-queue.c and try to be clearer about whether the client is the target client (must have a session) or not.
2020-04-13 20:51:57 +00:00
const char *name = cmdq_name(item->client);
Rename cmdq_shared to cmdq_state which will better reflect what it is (going to be) used for.
2020-04-13 14:04:25 +00:00
struct cmdq_state *state = item->state;
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
struct cmd *cmd = item->cmd;
Make client -c and -t handling common in cmd-queue.c and try to be clearer about whether the client is the target client (must have a session) or not.
2020-04-13 20:51:57 +00:00
struct args *args = cmd_get_args(cmd);
Make struct cmd local to cmd.c and move it out of tmux.h.
2020-04-13 08:26:27 +00:00
const struct cmd_entry *entry = cmd_get_entry(cmd);
Make client -c and -t handling common in cmd-queue.c and try to be clearer about whether the client is the target client (must have a session) or not.
2020-04-13 20:51:57 +00:00
struct client *tc, *saved = item->client;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
enum cmd_retval retval;
struct cmd_find_state *fsp, fs;
Make client -c and -t handling common in cmd-queue.c and try to be clearer about whether the client is the target client (must have a session) or not.
2020-04-13 20:51:57 +00:00
int flags, quiet = 0;
The line number needs to be updated only after the \n is processed by the parser, so store a flag and update it next time around. Also each new line needs its own shared data.
2019-05-29 19:34:42 +00:00
char *tmp;
Change message log to be per server rather than per client and include every command that is run.
2020-05-16 15:47:22 +00:00
if (cfg_finished)
cmdq_add_message(item);
The line number needs to be updated only after the \n is processed by the parser, so store a flag and update it next time around. Also each new line needs its own shared data.
2019-05-29 19:34:42 +00:00
if (log_get_level() > 1) {
tmp = cmd_print(cmd);
log_debug("%s %s: (%u) %s", __func__, name, item->group, tmp);
free(tmp);
}
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
Rename cmdq_shared to cmdq_state which will better reflect what it is (going to be) used for.
2020-04-13 14:04:25 +00:00
flags = !!(state->flags & CMDQ_STATE_CONTROL);
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
cmdq_guard(item, "begin", flags);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
Log error properly when no current state, and some other minor tweaks.
2017-04-21 22:23:24 +00:00
if (item->client == NULL)
item->client = cmd_find_client(item, NULL, 1);
Make client -c and -t handling common in cmd-queue.c and try to be clearer about whether the client is the target client (must have a session) or not.
2020-04-13 20:51:57 +00:00
if (entry->flags & CMD_CLIENT_CANFAIL)
quiet = 1;
if (entry->flags & CMD_CLIENT_CFLAG) {
tc = cmd_find_client(item, args_get(args, 'c'), quiet);
if (tc == NULL && !quiet) {
retval = CMD_RETURN_ERROR;
goto out;
}
} else if (entry->flags & CMD_CLIENT_TFLAG) {
tc = cmd_find_client(item, args_get(args, 't'), quiet);
if (tc == NULL && !quiet) {
retval = CMD_RETURN_ERROR;
goto out;
}
} else
tc = cmd_find_client(item, NULL, 1);
item->target_client = tc;
Get rid of the extra layer of flags and cmd_prepare() and just store the CMD_FIND_* flags in the cmd_entry and call it for the command. Commands with special requirements call it themselves and update the target for hooks to use.
2017-04-22 10:22:39 +00:00
retval = cmdq_find_flag(item, &item->source, &entry->source);
if (retval == CMD_RETURN_ERROR)
goto out;
retval = cmdq_find_flag(item, &item->target, &entry->target);
if (retval == CMD_RETURN_ERROR)
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
goto out;
Clear shared state if not filling it in.
2017-04-21 20:34:05 +00:00
Get rid of the extra layer of flags and cmd_prepare() and just store the CMD_FIND_* flags in the cmd_entry and call it for the command. Commands with special requirements call it themselves and update the target for hooks to use.
2017-04-22 10:22:39 +00:00
retval = entry->exec(cmd, item);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
if (retval == CMD_RETURN_ERROR)
goto out;
Get rid of the extra layer of flags and cmd_prepare() and just store the CMD_FIND_* flags in the cmd_entry and call it for the command. Commands with special requirements call it themselves and update the target for hooks to use.
2017-04-22 10:22:39 +00:00
if (entry->flags & CMD_AFTERHOOK) {
if (cmd_find_valid_state(&item->target))
fsp = &item->target;
Rename cmdq_shared to cmdq_state which will better reflect what it is (going to be) used for.
2020-04-13 14:04:25 +00:00
else if (cmd_find_valid_state(&item->state->current))
fsp = &item->state->current;
Pass flags into cmd_find_from_* to fix prefer-unattached, reported by Thomas Sattler.
2017-08-30 10:33:57 +00:00
else if (cmd_find_from_client(&fs, item->client, 0) == 0)
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
fsp = &fs;
Make the cmd_find_* functions more obvious when looking for a client, rather than having it inside other functions. Should be no change to the way targets are resolved just yet.
2017-04-21 20:26:34 +00:00
else
goto out;
Merge hooks into options and make each one an array option. This allows multiple commands to be easily bound to one hook. set-hook and show-hooks remain but they are now variants of set-option and show-options. show-options now has a -H flag to show hooks (by default they are not shown).
2019-04-26 11:38:51 +00:00
cmdq_insert_hook(fsp->s, item, fsp, "after-%s", entry->name);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
}
out:
Make client -c and -t handling common in cmd-queue.c and try to be clearer about whether the client is the target client (must have a session) or not.
2020-04-13 20:51:57 +00:00
item->client = saved;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
if (retval == CMD_RETURN_ERROR)
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
cmdq_guard(item, "error", flags);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
else
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
cmdq_guard(item, "end", flags);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
return (retval);
}
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
/* Get a callback for the command queue. */
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
struct cmdq_item *
Give each item on queue a name for better logging.
2016-10-18 08:46:43 +00:00
cmdq_get_callback1(const char *name, cmdq_cb cb, void *data)
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
{
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
struct cmdq_item *item;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
item = xcalloc(1, sizeof *item);
Correct ordering when adding after an existing item.
2019-05-03 15:43:01 +00:00
xasprintf(&item->name, "[%s/%p]", name, item);
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
item->type = CMDQ_CALLBACK;
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
item->group = 0;
When adding a list of commands to the queue, instead of automatically creating a new state for each group of commands, require the caller to create one and use it for all the commands in the list. This means the current target works even with list with multiple groups (which can happen if they are defined with newlines).
2020-04-13 15:55:51 +00:00
item->state = cmdq_new_state(NULL, NULL, 0);
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
item->cb = cb;
item->data = data;
Add infrastructure to work out the best target given a pane or window alone and use it to add pane_died and pane_exited hooks.
2015-12-16 21:50:37 +00:00
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
return (item);
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
}
Replace the various identical error callbacks with a single one in cmd-queue.c.
2019-05-20 11:46:06 +00:00
/* Generic error callback. */
static enum cmd_retval
cmdq_error_callback(struct cmdq_item *item, void *data)
{
char *error = data;
cmdq_error(item, "%s", error);
free(error);
return (CMD_RETURN_NORMAL);
}
/* Get an error callback for the command queue. */
struct cmdq_item *
cmdq_get_error(const char *error)
{
return (cmdq_get_callback(cmdq_error_callback, xstrdup(error)));
}
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
/* Fire callback on callback queue. */
static enum cmd_retval
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
cmdq_fire_callback(struct cmdq_item *item)
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
{
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
return (item->cb(item, item->data));
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
}
/* Process next item on command queue. */
u_int
cmdq_next(struct client *c)
{
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
struct cmdq_list *queue = cmdq_get(c);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
const char *name = cmdq_name(c);
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
struct cmdq_item *item;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
enum cmd_retval retval;
u_int items = 0;
static u_int number;
source-file and some other commands can recurse back into cmdq_continue, which could potentially free the currently running command, so we need to take a reference to it in cmdq_continue_one. Fixes problem reported by Theo Buehler.
2016-10-14 18:41:53 +00:00
Provide an accessor for the running queue item and use it to not let hooks recurse.
2020-04-14 06:00:52 +00:00
if (TAILQ_EMPTY(&queue->list)) {
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
log_debug("%s %s: empty", __func__, name);
return (0);
}
Provide an accessor for the running queue item and use it to not let hooks recurse.
2020-04-14 06:00:52 +00:00
if (TAILQ_FIRST(&queue->list)->flags & CMDQ_WAITING) {
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
log_debug("%s %s: waiting", __func__, name);
Rename cmd_q dead flag to a general flags bitmask (will be more flags later).
2015-09-16 22:24:54 +00:00
return (0);
}
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
log_debug("%s %s: enter", __func__, name);
for (;;) {
Provide an accessor for the running queue item and use it to not let hooks recurse.
2020-04-14 06:00:52 +00:00
item = queue->item = TAILQ_FIRST(&queue->list);
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
if (item == NULL)
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
break;
Give each item on queue a name for better logging.
2016-10-18 08:46:43 +00:00
log_debug("%s %s: %s (%d), flags %x", __func__, name,
item->name, item->type, item->flags);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
/*
* Any item with the waiting flag set waits until an external
* event clears the flag (for example, a job - look at
* run-shell).
*/
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
if (item->flags & CMDQ_WAITING)
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
goto waiting;
/*
* Items are only fired once, once the fired flag is set, a
* waiting flag can only be cleared by an external event.
*/
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
if (~item->flags & CMDQ_FIRED) {
item->time = time(NULL);
item->number = ++number;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
Style nits and an unused struct.
2017-04-21 18:18:17 +00:00
switch (item->type) {
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
case CMDQ_COMMAND:
retval = cmdq_fire_command(item);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
/*
* If a command returns an error, remove any
* subsequent commands in the same group.
*/
if (retval == CMD_RETURN_ERROR)
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
cmdq_remove_group(item);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
break;
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
case CMDQ_CALLBACK:
retval = cmdq_fire_callback(item);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
break;
default:
retval = CMD_RETURN_ERROR;
break;
}
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
item->flags |= CMDQ_FIRED;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
if (retval == CMD_RETURN_WAIT) {
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
item->flags |= CMDQ_WAITING;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
goto waiting;
}
items++;
}
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
cmdq_remove(item);
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
}
Provide an accessor for the running queue item and use it to not let hooks recurse.
2020-04-14 06:00:52 +00:00
queue->item = NULL;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
log_debug("%s %s: exit (empty)", __func__, name);
return (items);
waiting:
log_debug("%s %s: exit (wait)", __func__, name);
return (items);
}
Provide an accessor for the running queue item and use it to not let hooks recurse.
2020-04-14 06:00:52 +00:00
/* Get running item if any. */
struct cmdq_item *
cmdq_running(struct client *c)
{
struct cmdq_list *queue = cmdq_get(c);
return (queue->item);
}
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
/* Print a guard line. */
void
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
cmdq_guard(struct cmdq_item *item, const char *guard, int flags)
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
{
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
struct client *c = item->client;
Rewrite the code for reading and writing files. Now, if the client is not attached, the server process asks it to open the file, similar to how works for stdin, stdout, stderr. This makes special files like /dev/fd/X work (used by some shells). stdin, stdout and stderr and control mode are now just special cases of the same mechanism. This will also make it easier to use for other commands that read files such as source-file.
2019-12-12 11:39:56 +00:00
long t = item->time;
u_int number = item->number;
Rewrite command queue handling. Each client still has a command queue, but there is also now a global command queue. Instead of command queues being dispatched on demand from wherever the command happens to be added, they are now all dispatched from the top level server loop. Command queues may now also include callbacks as well as commands, and items may be inserted after the current command as well as at the end. This all makes command queues significantly more predictable and easier to use, and avoids the complex multiple nested command queues used by source-file, if-shell and friends. A mass rename of struct cmdq to a better name (cmdq_item probably) is coming.
2016-10-16 17:55:14 +00:00
Rewrite the code for reading and writing files. Now, if the client is not attached, the server process asks it to open the file, similar to how works for stdin, stdout, stderr. This makes special files like /dev/fd/X work (used by some shells). stdin, stdout and stderr and control mode are now just special cases of the same mechanism. This will also make it easier to use for other commands that read files such as source-file.
2019-12-12 11:39:56 +00:00
if (c != NULL && (c->flags & CLIENT_CONTROL))
Instead of sending all data to control mode clients as fast as possible, add a limit of how much data will be sent to the client and try to use it for panes with some degree of fairness. GitHub issue 2217, with George Nachman.
2020-06-01 09:43:00 +00:00
control_write(c, "%%%s %ld %u %d", guard, t, number, flags);
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
}
/* Show message from command. */
Better format for printf format attributes.
2014-10-20 23:57:13 +00:00
void
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
cmdq_print(struct cmdq_item *item, const char *fmt, ...)
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
{
Allow multiple modes to be open in a pane. A stack of open modes is kept and the previous restored when the top is exited. If a mode that is already on the stack is entered, the existing instance is moved to the top as the active mode rather than being opened new.
2019-03-12 11:16:49 +00:00
struct client *c = item->client;
struct window_pane *wp;
struct window_mode_entry *wme;
va_list ap;
char *tmp, *msg;
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
va_start(ap, fmt);
Rewrite the code for reading and writing files. Now, if the client is not attached, the server process asks it to open the file, similar to how works for stdin, stdout, stderr. This makes special files like /dev/fd/X work (used by some shells). stdin, stdout and stderr and control mode are now just special cases of the same mechanism. This will also make it easier to use for other commands that read files such as source-file.
2019-12-12 11:39:56 +00:00
xvasprintf(&msg, fmt, ap);
va_end(ap);
log_debug("%s: %s", __func__, msg);
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
if (c == NULL)
/* nothing */;
else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
If we know the terminal outside tmux is not UTF-8, replace UTF-8 in error messages and whatnot with underscores the same as we do when we draw UTF-8 characters as part of the screen.
2015-11-12 11:10:50 +00:00
if (~c->flags & CLIENT_UTF8) {
Rewrite the code for reading and writing files. Now, if the client is not attached, the server process asks it to open the file, similar to how works for stdin, stdout, stderr. This makes special files like /dev/fd/X work (used by some shells). stdin, stdout and stderr and control mode are now just special cases of the same mechanism. This will also make it easier to use for other commands that read files such as source-file.
2019-12-12 11:39:56 +00:00
tmp = msg;
If we know the terminal outside tmux is not UTF-8, replace UTF-8 in error messages and whatnot with underscores the same as we do when we draw UTF-8 characters as part of the screen.
2015-11-12 11:10:50 +00:00
msg = utf8_sanitize(tmp);
free(tmp);
Rewrite the code for reading and writing files. Now, if the client is not attached, the server process asks it to open the file, similar to how works for stdin, stdout, stderr. This makes special files like /dev/fd/X work (used by some shells). stdin, stdout and stderr and control mode are now just special cases of the same mechanism. This will also make it easier to use for other commands that read files such as source-file.
2019-12-12 11:39:56 +00:00
}
Instead of sending all data to control mode clients as fast as possible, add a limit of how much data will be sent to the client and try to use it for panes with some degree of fairness. GitHub issue 2217, with George Nachman.
2020-06-01 09:43:00 +00:00
if (c->flags & CLIENT_CONTROL)
control_write(c, "%s", msg);
else
file_print(c, "%s\n", msg);
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
} else {
Add a client flag 'active-pane' which stores the active pane in the client and allows it to be changed independently from the real active pane stored in the window. This is can be used with session groups which allow an independent current window (although it would be nice to have a flag for this too and remove session groups). The client active pane is only really useful interactively, many things (hooks, window-style, zooming) still use the window active pane.
2020-05-16 16:20:59 +00:00
wp = server_client_get_pane(c);
Allow multiple modes to be open in a pane. A stack of open modes is kept and the previous restored when the top is exited. If a mode that is already on the stack is entered, the existing instance is moved to the top as the active mode rather than being opened new.
2019-03-12 11:16:49 +00:00
wme = TAILQ_FIRST(&wp->modes);
Now that copy mode copies the pane content rather than keeping a reference to it, it isn't necessary that the pane in copy mode is the same as the one copying from. Add a -s flag to copy-mode to specify a different pane for the source content. This means it is possible to view two places in a pane's history at the same time in different panes, or copy from a pane's history into an editor or shell in the same pane. From Anindya Mukherjee.
2020-04-10 07:44:26 +00:00
if (wme == NULL || wme->mode != &window_view_mode) {
window_pane_set_mode(wp, NULL, &window_view_mode, NULL,
NULL);
}
Use the message that has already been built rather than the va_list.
2019-12-17 11:43:23 +00:00
window_copy_add(wp, "%s", msg);
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
}
Rewrite the code for reading and writing files. Now, if the client is not attached, the server process asks it to open the file, similar to how works for stdin, stdout, stderr. This makes special files like /dev/fd/X work (used by some shells). stdin, stdout and stderr and control mode are now just special cases of the same mechanism. This will also make it easier to use for other commands that read files such as source-file.
2019-12-12 11:39:56 +00:00
free(msg);
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
}
/* Show error from command. */
Better format for printf format attributes.
2014-10-20 23:57:13 +00:00
void
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
cmdq_error(struct cmdq_item *item, const char *fmt, ...)
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
{
Mass rename struct cmd_q to struct cmdq_item and related.
2016-10-16 19:04:05 +00:00
struct client *c = item->client;
struct cmd *cmd = item->cmd;
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
va_list ap;
Make struct cmd local to cmd.c and move it out of tmux.h.
2020-04-13 08:26:27 +00:00
char *msg, *tmp;
const char *file;
u_int line;
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
va_start(ap, fmt);
Rewrite the code for reading and writing files. Now, if the client is not attached, the server process asks it to open the file, similar to how works for stdin, stdout, stderr. This makes special files like /dev/fd/X work (used by some shells). stdin, stdout and stderr and control mode are now just special cases of the same mechanism. This will also make it easier to use for other commands that read files such as source-file.
2019-12-12 11:39:56 +00:00
xvasprintf(&msg, fmt, ap);
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
va_end(ap);
Tweak some logging.
2017-06-16 15:12:38 +00:00
log_debug("%s: %s", __func__, msg);
Make struct cmd local to cmd.c and move it out of tmux.h.
2020-04-13 08:26:27 +00:00
if (c == NULL) {
cmd_get_source(cmd, &file, &line);
cfg_add_cause("%s:%u: %s", file, line, msg);
} else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
Change message log to be per server rather than per client and include every command that is run.
2020-05-16 15:47:22 +00:00
server_add_message("%s message: %s", c->name, msg);
If we know the terminal outside tmux is not UTF-8, replace UTF-8 in error messages and whatnot with underscores the same as we do when we draw UTF-8 characters as part of the screen.
2015-11-12 11:10:50 +00:00
if (~c->flags & CLIENT_UTF8) {
tmp = msg;
msg = utf8_sanitize(tmp);
free(tmp);
}
Send errors to stdout in control mode so they don't get reordered with other output, reported by George Nachman in GitHub issue 2048.
2020-01-05 12:51:43 +00:00
if (c->flags & CLIENT_CONTROL)
Instead of sending all data to control mode clients as fast as possible, add a limit of how much data will be sent to the client and try to use it for panes with some degree of fairness. GitHub issue 2217, with George Nachman.
2020-06-01 09:43:00 +00:00
control_write(c, "%s", msg);
Send errors to stdout in control mode so they don't get reordered with other output, reported by George Nachman in GitHub issue 2048.
2020-01-05 12:51:43 +00:00
else
file_error(c, "%s\n", msg);
retcode -> retval for exit message.
2013-10-10 12:12:54 +00:00
c->retval = 1;
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
} else {
*msg = toupper((u_char) *msg);
Add a -d option to display-message to set delay, from theonekeyg at gmail dot com in GitHub issue 2322.
2020-07-27 08:03:10 +00:00
status_message_set(c, -1, 1, "%s", msg);
Add a command queue to standardize and simplify commands that call other commands and allow a command to block execution of subsequent commands. This allows run-shell and if-shell to be synchronous which has been much requested. Each client has a default command queue and commands are consumed one at a time from it. A command may suspend execution from the queue by returning CMD_RETURN_WAIT and then resume it by calling cmd_continue() - for example run-shell does this from the callback that is fired after the job is freed. When the command queue becomes empty, command clients are automatically exited (unless attaching). A callback is also fired - this is used for nested commands in, for example, if-shell which can block execution of the client's cmdq until a new cmdq becomes empty. Also merge all the old error/info/print functions together and lose the old curclient/cmdclient distinction - a cmdq is bound to one client (or none if in the configuration file), this is a command client if c->session is NULL otherwise an attached client.
2013-03-24 09:54:10 +00:00
}
free(msg);
}
Reference in New Issue Copy Permalink