extern/tmate
1
0
Fork 0
mirror of https://github.com/tmate-io/tmate.git synced 2024-12-22 23:00:51 +01:00
Code Issues Packages Projects Releases Wiki Activity

Having fixed flags for single-character getopt options is a bit hard to

Browse Source 
maintain and is only going to get worse as more are used. So instead, add a new
uint64_t member to cmd_entry which is a bitmask of upper and lowercase options
accepted by the command.

This means new single character options can be used without the need to add it
explicitly to the list.
This commit is contained in:
Nicholas Marriott 2009-07-13 23:11:35 +00:00
parent 5d91555c7c
commit 5f108d9df6
73 changed files with 196 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cmd-attach-session.c
View File

@ -29,7 +29,7 @@ int cmd_attach_session_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_attach_session_entry = {
"attach-session", "attach",
"[-d] " CMD_TARGET_SESSION_USAGE,
CMD_DFLAG|CMD_CANTNEST|CMD_STARTSERVER,
CMD_CANTNEST|CMD_STARTSERVER, CMD_CHFLAG('d'),
cmd_target_init,
cmd_target_parse,
cmd_attach_session_exec,
@ -67,7 +67,7 @@ cmd_attach_session_exec(struct cmd *self, struct cmd_ctx *ctx)
return (-1);
}
if (data->flags & CMD_DFLAG)
if (data->chflags & CMD_CHFLAG('d'))
server_write_session(s, MSG_DETACH, NULL, 0);
ctx->cmdclient->session = s;

2
cmd-bind-key.c
View File

@ -40,7 +40,7 @@ struct cmd_bind_key_data {
const struct cmd_entry cmd_bind_key_entry = {
"bind-key", "bind",
"[-r] key command [arguments]",
0,
0, 0,
NULL,
cmd_bind_key_parse,
cmd_bind_key_exec,

4
cmd-break-pane.c
View File

@ -31,7 +31,7 @@ int cmd_break_pane_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_break_pane_entry = {
"break-pane", "breakp",
CMD_PANE_WINDOW_USAGE " [-d]",
CMD_DFLAG,
0, CMD_CHFLAG('d'),
cmd_pane_init,
cmd_pane_parse,
cmd_break_pane_exec,
@ -82,7 +82,7 @@ cmd_break_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
w->name = default_window_name(w);
wl = session_attach(s, w, -1, &cause); /* can't fail */
if (!(data->flags & CMD_DFLAG))
if (!(data->chflags & CMD_CHFLAG('d')))
session_select(s, wl->idx);
layout_refresh(w, 0);

2
cmd-choose-session.c
View File

@ -31,7 +31,7 @@ void cmd_choose_session_callback(void *, int);
const struct cmd_entry cmd_choose_session_entry = {
"choose-session", NULL,
CMD_TARGET_WINDOW_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_choose_session_exec,

2
cmd-choose-window.c
View File

@ -31,7 +31,7 @@ void cmd_choose_window_callback(void *, int);
const struct cmd_entry cmd_choose_window_entry = {
"choose-window", NULL,
CMD_TARGET_WINDOW_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_choose_window_exec,

2
cmd-clear-history.c
View File

@ -29,7 +29,7 @@ int cmd_clear_history_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_clear_history_entry = {
"clear-history", "clearhist",
CMD_PANE_WINDOW_USAGE,
0,
0, 0,
cmd_pane_init,
cmd_pane_parse,
cmd_clear_history_exec,

2
cmd-clock-mode.c
View File

@ -29,7 +29,7 @@ int cmd_clock_mode_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_clock_mode_entry = {
"clock-mode", NULL,
CMD_TARGET_WINDOW_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_clock_mode_exec,

2
cmd-command-prompt.c
View File

@ -35,7 +35,7 @@ int cmd_command_prompt_callback(void *, const char *);
const struct cmd_entry cmd_command_prompt_entry = {
"command-prompt", NULL,
CMD_TARGET_CLIENT_USAGE " [template]",
CMD_ARG01,
CMD_ARG01, 0,
cmd_command_prompt_init,
cmd_target_parse,
cmd_command_prompt_exec,

2
cmd-confirm-before.c
View File

@ -38,7 +38,7 @@ struct cmd_confirm_before_data {
const struct cmd_entry cmd_confirm_before_entry = {
"confirm-before", "confirm",
CMD_TARGET_CLIENT_USAGE " command",
CMD_ARG1,
CMD_ARG1, 0,
cmd_confirm_before_init,
cmd_target_parse,
cmd_confirm_before_exec,

2
cmd-copy-buffer.c
View File

@ -42,7 +42,7 @@ struct cmd_copy_buffer_data {
const struct cmd_entry cmd_copy_buffer_entry = {
"copy-buffer", "copyb",
"[-a src-index] [-b dst-index] [-s src-session] [-t dst-session]",
0,
0, 0,
cmd_copy_buffer_init,
cmd_copy_buffer_parse,
cmd_copy_buffer_exec,

4
cmd-copy-mode.c
View File

@ -29,7 +29,7 @@ int cmd_copy_mode_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_copy_mode_entry = {
"copy-mode", NULL,
"[-u] " CMD_TARGET_WINDOW_USAGE,
CMD_UFLAG,
0, CMD_CHFLAG('u'),
cmd_target_init,
cmd_target_parse,
cmd_copy_mode_exec,
@ -51,7 +51,7 @@ cmd_copy_mode_exec(struct cmd *self, struct cmd_ctx *ctx)
wp = wl->window->active;
window_pane_set_mode(wp, &window_copy_mode);
if (wp->mode == &window_copy_mode && data->flags & CMD_UFLAG)
if (wp->mode == &window_copy_mode && data->chflags & CMD_CHFLAG('u'))
window_copy_pageup(wp);
return (0);

2
cmd-delete-buffer.c
View File

@ -31,7 +31,7 @@ int cmd_delete_buffer_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_delete_buffer_entry = {
"delete-buffer", "deleteb",
CMD_BUFFER_SESSION_USAGE,
0,
0, 0,
cmd_buffer_init,
cmd_buffer_parse,
cmd_delete_buffer_exec,

2
cmd-detach-client.c
View File

@ -29,7 +29,7 @@ int cmd_detach_client_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_detach_client_entry = {
"detach-client", "detach",
CMD_TARGET_CLIENT_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_detach_client_exec,

2
cmd-down-pane.c
View File

@ -29,7 +29,7 @@ int cmd_down_pane_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_down_pane_entry = {
"down-pane", "downp",
CMD_TARGET_WINDOW_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_down_pane_exec,

2
cmd-find-window.c
View File

@ -34,7 +34,7 @@ void cmd_find_window_callback(void *, int);
const struct cmd_entry cmd_find_window_entry = {
"find-window", "findw",
CMD_TARGET_WINDOW_USAGE " match-string",
CMD_ARG1,
CMD_ARG1, 0,
cmd_target_init,
cmd_target_parse,
cmd_find_window_exec,

198
cmd-generic.c
View File

@ -23,12 +23,9 @@
#include "tmux.h"
#define CMD_FLAGS "adDgkruU"
#define CMD_FLAGMASK (CMD_AFLAG|CMD_DFLAG|CMD_BIGDFLAG|CMD_GFLAG|CMD_KFLAG| \
CMD_RFLAG|CMD_UFLAG|CMD_BIGUFLAG)
int cmd_do_flags(int, int, int *);
size_t cmd_print_flags(char *, size_t, size_t, int);
int cmd_getopt(int, char **, const char *, uint64_t);
int cmd_flags(int, uint64_t, uint64_t *);
size_t cmd_print_flags(char *, size_t, size_t, uint64_t);
int cmd_fill_argument(int, char **, int, char **);
size_t
@ -39,86 +36,70 @@ cmd_prarg(char *buf, size_t len, const char *prefix, char *arg)
return (xsnprintf(buf, len, "%s%s", prefix, arg));
}
/* Prepend flags from chflags onto flagstr and call getopt. */
int
cmd_do_flags(int opt, int iflags, int *oflags)
cmd_getopt(int argc, char **argv, const char *flagstr, uint64_t chflags)
{
switch (opt) {
case 'a':
if (iflags & CMD_AFLAG) {
(*oflags) |= CMD_AFLAG;
return (0);
}
return (-1);
case 'd':
if (iflags & CMD_DFLAG) {
(*oflags) |= CMD_DFLAG;
return (0);
}
return (-1);
case 'D':
if (iflags & CMD_BIGDFLAG) {
(*oflags) |= CMD_BIGDFLAG;
return (0);
}
return (-1);
case 'g':
if (iflags & CMD_GFLAG) {
(*oflags) |= CMD_GFLAG;
return (0);
}
return (-1);
case 'k':
if (iflags & CMD_KFLAG) {
(*oflags) |= CMD_KFLAG;
return (0);
}
return (-1);
case 'r':
if (iflags & CMD_RFLAG) {
(*oflags) |= CMD_RFLAG;
return (0);
}
return (-1);
case 'u':
if (iflags & CMD_UFLAG) {
(*oflags) |= CMD_UFLAG;
return (0);
}
return (-1);
case 'U':
if (iflags & CMD_BIGUFLAG) {
(*oflags) |= CMD_BIGUFLAG;
return (0);
}
return (-1);
u_char ch;
char buf[128];
size_t len, off;
*buf = '\0';
len = sizeof buf;
off = 0;
for (ch = 0; ch < 26; ch++) {
if (chflags & CMD_CHFLAG('a' + ch))
off += xsnprintf(buf + off, len - off, "%c", 'a' + ch);
if (chflags & CMD_CHFLAG('A' + ch))
off += xsnprintf(buf + off, len - off, "%c", 'A' + ch);
}
return (1);
strlcat(buf, flagstr, sizeof buf);
return (getopt(argc, argv, buf));
}
size_t
cmd_print_flags(char *buf, size_t len, size_t off, int flags)
/*
* If this option is expected (in ichflags), set it in ochflags, otherwise
* return -1.
*/
int
cmd_flags(int opt, uint64_t ichflags, uint64_t *ochflags)
{
u_char ch;
for (ch = 0; ch < 26; ch++) {
if (opt == 'a' + ch && ichflags & CMD_CHFLAG(opt)) {
(*ochflags) |= CMD_CHFLAG(opt);
return (0);
}
if (opt == 'A' + ch && ichflags & CMD_CHFLAG(opt)) {
(*ochflags) |= CMD_CHFLAG(opt);
return (0);
}
}
return (-1);
}
/* Print the flags supported in chflags. */
size_t
cmd_print_flags(char *buf, size_t len, size_t off, uint64_t chflags)
{
u_char ch;
size_t boff = off;
if ((flags & CMD_FLAGMASK) == 0)
if (chflags == 0)
return (0);
off += xsnprintf(buf + off, len - off, " -");
if (off < len && flags & CMD_AFLAG)
off += xsnprintf(buf + off, len - off, "a");
if (off < len && flags & CMD_BIGDFLAG)
off += xsnprintf(buf + off, len - off, "D");
if (off < len && flags & CMD_DFLAG)
off += xsnprintf(buf + off, len - off, "d");
if (off < len && flags & CMD_GFLAG)
off += xsnprintf(buf + off, len - off, "g");
if (off < len && flags & CMD_KFLAG)
off += xsnprintf(buf + off, len - off, "k");
if (off < len && flags & CMD_RFLAG)
off += xsnprintf(buf + off, len - off, "r");
if (off < len && flags & CMD_UFLAG)
off += xsnprintf(buf + off, len - off, "u");
if (off < len && flags & CMD_BIGUFLAG)
off += xsnprintf(buf + off, len - off, "U");
for (ch = 0; ch < 26; ch++) {
if (chflags & CMD_CHFLAG('a' + ch))
off += xsnprintf(buf + off, len - off, "%c", 'a' + ch);
if (chflags & CMD_CHFLAG('A' + ch))
off += xsnprintf(buf + off, len - off, "%c", 'A' + ch);
}
return (off - boff);
}
@ -153,7 +134,7 @@ cmd_target_init(struct cmd *self, unused int key)
struct cmd_target_data *data;
self->data = data = xmalloc(sizeof *data);
data->flags = 0;
data->chflags = 0;
data->target = NULL;
data->arg = NULL;
}
@ -162,19 +143,16 @@ int
cmd_target_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_target_data *data;
const struct cmd_entry *entry = self->entry;
int opt;
/* Don't use the entry version since it may be dependent on key. */
cmd_target_init(self, 0);
data = self->data;
while ((opt = getopt(argc, argv, CMD_FLAGS "t:")) != -1) {
switch (cmd_do_flags(opt, self->entry->flags, &data->flags)) {
case -1:
goto usage;
case 0:
while ((opt = cmd_getopt(argc, argv, "t:", entry->chflags)) != -1) {
if (cmd_flags(opt, entry->chflags, &data->chflags) == 0)
continue;
}
switch (opt) {
case 't':
if (data->target == NULL)
@ -240,7 +218,7 @@ cmd_target_print(struct cmd *self, char *buf, size_t len)
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
off += cmd_print_flags(buf, len, off, data->flags);
off += cmd_print_flags(buf, len, off, data->chflags);
if (off < len && data->target != NULL)
off += cmd_prarg(buf + off, len - off, " -t ", data->target);
if (off < len && data->arg != NULL)
@ -254,7 +232,7 @@ cmd_srcdst_init(struct cmd *self, unused int key)
struct cmd_srcdst_data *data;
self->data = data = xmalloc(sizeof *data);
data->flags = 0;
data->chflags = 0;
data->src = NULL;
data->dst = NULL;
data->arg = NULL;
@ -264,18 +242,15 @@ int
cmd_srcdst_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_srcdst_data *data;
const struct cmd_entry *entry = self->entry;
int opt;
cmd_srcdst_init(self, 0);
data = self->data;
while ((opt = getopt(argc, argv, CMD_FLAGS "s:t:")) != -1) {
switch (cmd_do_flags(opt, self->entry->flags, &data->flags)) {
case -1:
goto usage;
case 0:
while ((opt = cmd_getopt(argc, argv, "s:t:", entry->chflags)) != -1) {
if (cmd_flags(opt, entry->chflags, &data->chflags) == 0)
continue;
}
switch (opt) {
case 's':
if (data->src == NULL)
@ -349,7 +324,7 @@ cmd_srcdst_print(struct cmd *self, char *buf, size_t len)
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
off += cmd_print_flags(buf, len, off, data->flags);
off += cmd_print_flags(buf, len, off, data->chflags);
if (off < len && data->src != NULL)
off += xsnprintf(buf + off, len - off, " -s %s", data->src);
if (off < len && data->dst != NULL)
@ -365,7 +340,7 @@ cmd_buffer_init(struct cmd *self, unused int key)
struct cmd_buffer_data *data;
self->data = data = xmalloc(sizeof *data);
data->flags = 0;
data->chflags = 0;
data->target = NULL;
data->buffer = -1;
data->arg = NULL;
@ -375,19 +350,16 @@ int
cmd_buffer_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_buffer_data *data;
const struct cmd_entry *entry = self->entry;
int opt, n;
const char *errstr;
cmd_buffer_init(self, 0);
data = self->data;
while ((opt = getopt(argc, argv, CMD_FLAGS "b:t:")) != -1) {
switch (cmd_do_flags(opt, self->entry->flags, &data->flags)) {
case -1:
goto usage;
case 0:
while ((opt = cmd_getopt(argc, argv, "b:t:", entry->chflags)) != -1) {
if (cmd_flags(opt, entry->chflags, &data->chflags) == 0)
continue;
}
switch (opt) {
case 'b':
if (data->buffer == -1) {
@ -464,7 +436,7 @@ cmd_buffer_print(struct cmd *self, char *buf, size_t len)
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
off += cmd_print_flags(buf, len, off, data->flags);
off += cmd_print_flags(buf, len, off, data->chflags);
if (off < len && data->buffer != -1)
off += xsnprintf(buf + off, len - off, " -b %d", data->buffer);
if (off < len && data->target != NULL)
@ -480,7 +452,7 @@ cmd_option_init(struct cmd *self, unused int key)
struct cmd_option_data *data;
self->data = data = xmalloc(sizeof *data);
data->flags = 0;
data->chflags = 0;
data->target = NULL;
data->option = NULL;
data->value = NULL;
@ -490,19 +462,16 @@ int
cmd_option_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_option_data *data;
const struct cmd_entry *entry = self->entry;
int opt;
/* Don't use the entry version since it may be dependent on key. */
cmd_option_init(self, 0);
data = self->data;
while ((opt = getopt(argc, argv, CMD_FLAGS "t:")) != -1) {
switch (cmd_do_flags(opt, self->entry->flags, &data->flags)) {
case -1:
goto usage;
case 0:
while ((opt = cmd_getopt(argc, argv, "t:", entry->chflags)) != -1) {
if (cmd_flags(opt, entry->chflags, &data->chflags) == 0)
continue;
}
switch (opt) {
case 't':
if (data->target == NULL)
@ -577,7 +546,7 @@ cmd_option_print(struct cmd *self, char *buf, size_t len)
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
off += cmd_print_flags(buf, len, off, data->flags);
off += cmd_print_flags(buf, len, off, data->chflags);
if (off < len && data->target != NULL)
off += cmd_prarg(buf + off, len - off, " -t ", data->target);
if (off < len && data->option != NULL)
@ -593,7 +562,7 @@ cmd_pane_init(struct cmd *self, unused int key)
struct cmd_pane_data *data;
self->data = data = xmalloc(sizeof *data);
data->flags = 0;
data->chflags = 0;
data->target = NULL;
data->arg = NULL;
data->pane = -1;
@ -603,6 +572,7 @@ int
cmd_pane_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_pane_data *data;
const struct cmd_entry *entry = self->entry;
int opt, n;
const char *errstr;
@ -610,13 +580,9 @@ cmd_pane_parse(struct cmd *self, int argc, char **argv, char **cause)
cmd_pane_init(self, 0);
data = self->data;
while ((opt = getopt(argc, argv, CMD_FLAGS "p:t:")) != -1) {
switch (cmd_do_flags(opt, self->entry->flags, &data->flags)) {
case -1:
goto usage;
case 0:
while ((opt = cmd_getopt(argc, argv, "p:t:", entry->chflags)) != -1) {
if (cmd_flags(opt, entry->chflags, &data->chflags) == 0)
continue;
}
switch (opt) {
case 'p':
if (data->pane == -1) {
@ -693,7 +659,7 @@ cmd_pane_print(struct cmd *self, char *buf, size_t len)
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
off += cmd_print_flags(buf, len, off, data->flags);
off += cmd_print_flags(buf, len, off, data->chflags);
if (off < len && data->target != NULL)
off += cmd_prarg(buf + off, len - off, " -t ", data->target);
if (off < len && data->arg != NULL)

2
cmd-has-session.c
View File

@ -29,7 +29,7 @@ int cmd_has_session_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_has_session_entry = {
"has-session", "has",
CMD_TARGET_SESSION_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_has_session_exec,

2
cmd-if-shell.c
View File

@ -44,7 +44,7 @@ struct cmd_if_shell_data {
const struct cmd_entry cmd_if_shell_entry = {
"if-shell", "if",
"shell-command command",
0,
0, 0,
cmd_if_shell_init,
cmd_if_shell_parse,
cmd_if_shell_exec,

2
cmd-kill-pane.c
View File

@ -31,7 +31,7 @@ int cmd_kill_pane_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_kill_pane_entry = {
"kill-pane", "killp",
CMD_PANE_WINDOW_USAGE,
0,
0, 0,
cmd_pane_init,
cmd_pane_parse,
cmd_kill_pane_exec,

2
cmd-kill-server.c
View File

@ -32,7 +32,7 @@ int cmd_kill_server_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_kill_server_entry = {
"kill-server", NULL,
"",
0,
0, 0,
NULL,
NULL,
cmd_kill_server_exec,

2
cmd-kill-session.c
View File

@ -32,7 +32,7 @@ int cmd_kill_session_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_kill_session_entry = {
"kill-session", NULL,
CMD_TARGET_SESSION_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_kill_session_exec,

2
cmd-kill-window.c
View File

@ -29,7 +29,7 @@ int cmd_kill_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_kill_window_entry = {
"kill-window", "killw",
CMD_TARGET_WINDOW_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_kill_window_exec,

2
cmd-last-window.c
View File

@ -29,7 +29,7 @@ int cmd_last_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_last_window_entry = {
"last-window", "last",
CMD_TARGET_SESSION_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_last_window_exec,

8
cmd-link-window.c
View File

@ -31,7 +31,7 @@ int cmd_link_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_link_window_entry = {
"link-window", "linkw",
"[-dk] " CMD_SRCDST_WINDOW_USAGE,
CMD_DFLAG|CMD_KFLAG,
0, CMD_CHFLAG('d')|CMD_CHFLAG('k'),
cmd_srcdst_init,
cmd_srcdst_parse,
cmd_link_window_exec,
@ -62,7 +62,7 @@ cmd_link_window_exec(struct cmd *self, struct cmd_ctx *ctx)
if (wl_dst->window == wl_src->window)
return (0);
if (data->flags & CMD_KFLAG) {
if (data->chflags & CMD_CHFLAG('k')) {
/*
* Can't use session_detach as it will destroy session
* if this makes it empty.
@ -73,7 +73,7 @@ cmd_link_window_exec(struct cmd *self, struct cmd_ctx *ctx)
/* Force select/redraw if current. */
if (wl_dst == dst->curw) {
data->flags &= ~CMD_DFLAG;
data->chflags &= ~CMD_CHFLAG('d');
dst->curw = NULL;
}
}
@ -86,7 +86,7 @@ cmd_link_window_exec(struct cmd *self, struct cmd_ctx *ctx)
return (-1);
}
if (data->flags & CMD_DFLAG)
if (data->chflags & CMD_CHFLAG('d'))
server_status_session(dst);
else {
session_select(dst, wl_dst->idx);

2
cmd-list-buffers.c
View File

@ -31,7 +31,7 @@ int cmd_list_buffers_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_list_buffers_entry = {
"list-buffers", "lsb",
CMD_TARGET_SESSION_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_list_buffers_exec,

2
cmd-list-clients.c
View File

@ -32,7 +32,7 @@ int cmd_list_clients_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_list_clients_entry = {
"list-clients", "lsc",
"",
0,
0, 0,
NULL,
NULL,
cmd_list_clients_exec,

2
cmd-list-commands.c
View File

@ -29,7 +29,7 @@ int cmd_list_commands_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_list_commands_entry = {
"list-commands", "lscm",
"",
0,
0, 0,
NULL,
NULL,
cmd_list_commands_exec,

2
cmd-list-keys.c
View File

@ -29,7 +29,7 @@ int cmd_list_keys_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_list_keys_entry = {
"list-keys", "lsk",
"",
0,
0, 0,
NULL,
NULL,
cmd_list_keys_exec,

2
cmd-list-sessions.c
View File

@ -31,7 +31,7 @@ int cmd_list_sessions_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_list_sessions_entry = {
"list-sessions", "ls", "",
0,
0, 0,
NULL,
NULL,
cmd_list_sessions_exec,

2
cmd-list-windows.c
View File

@ -31,7 +31,7 @@ int cmd_list_windows_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_list_windows_entry = {
"list-windows", "lsw",
CMD_TARGET_SESSION_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_list_windows_exec,

2
cmd-load-buffer.c
View File

@ -35,7 +35,7 @@ int cmd_load_buffer_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_load_buffer_entry = {
"load-buffer", "loadb",
CMD_BUFFER_SESSION_USAGE " path",
CMD_ARG1,
CMD_ARG1, 0,
cmd_buffer_init,
cmd_buffer_parse,
cmd_load_buffer_exec,

2
cmd-lock-server.c
View File

@ -33,7 +33,7 @@ int cmd_lock_server_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_lock_server_entry = {
"lock-server", "lock",
"",
0,
0, 0,
NULL,
NULL,
cmd_lock_server_exec,

8
cmd-move-window.c
View File

@ -31,7 +31,7 @@ int cmd_move_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_move_window_entry = {
"move-window", "movew",
"[-dk] " CMD_SRCDST_WINDOW_USAGE,
CMD_DFLAG|CMD_KFLAG,
0, CMD_CHFLAG('d')|CMD_CHFLAG('k'),
cmd_srcdst_init,
cmd_srcdst_parse,
cmd_move_window_exec,
@ -64,7 +64,7 @@ cmd_move_window_exec(struct cmd *self, struct cmd_ctx *ctx)
if (wl_dst->window == wl_src->window)
return (0);
if (data->flags & CMD_KFLAG) {
if (data->chflags & CMD_CHFLAG('k')) {
/*
* Can't use session_detach as it will destroy session
* if this makes it empty.
@ -75,7 +75,7 @@ cmd_move_window_exec(struct cmd *self, struct cmd_ctx *ctx)
/* Force select/redraw if current. */
if (wl_dst == dst->curw) {
data->flags &= ~CMD_DFLAG;
data->chflags &= ~CMD_CHFLAG('d');
dst->curw = NULL;
}
}
@ -100,7 +100,7 @@ cmd_move_window_exec(struct cmd *self, struct cmd_ctx *ctx)
server_redraw_client(c);
}
if (data->flags & CMD_DFLAG)
if (data->chflags & CMD_CHFLAG('d'))
server_status_session(dst);
else {
session_select(dst, wl_dst->idx);

2
cmd-new-session.c
View File

@ -42,7 +42,7 @@ struct cmd_new_session_data {
const struct cmd_entry cmd_new_session_entry = {
"new-session", "new",
"[-d] [-n window-name] [-s session-name] [command]",
CMD_STARTSERVER|CMD_CANTNEST,
CMD_STARTSERVER|CMD_CANTNEST, 0,
cmd_new_session_init,
cmd_new_session_parse,
cmd_new_session_exec,

2
cmd-new-window.c
View File

@ -45,7 +45,7 @@ struct cmd_new_window_data {
const struct cmd_entry cmd_new_window_entry = {
"new-window", "neww",
"[-dk] [-n window-name] [-t target-window] [command]",
0,
0, 0,
cmd_new_window_init,
cmd_new_window_parse,
cmd_new_window_exec,

2
cmd-next-layout.c
View File

@ -29,7 +29,7 @@ int cmd_next_layout_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_next_layout_entry = {
"next-layout", "nextl",
CMD_TARGET_WINDOW_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_next_layout_exec,

6
cmd-next-window.c
View File

@ -30,7 +30,7 @@ int cmd_next_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_next_window_entry = {
"next-window", "next",
"[-a] " CMD_TARGET_SESSION_USAGE,
CMD_AFLAG,
0, CMD_CHFLAG('a'),
cmd_next_window_init,
cmd_target_parse,
cmd_next_window_exec,
@ -49,7 +49,7 @@ cmd_next_window_init(struct cmd *self, int key)
data = self->data;
if (key == KEYC_ADDESC('n'))
data->flags |= CMD_AFLAG;
data->chflags |= CMD_CHFLAG('a');
}
int
@ -63,7 +63,7 @@ cmd_next_window_exec(struct cmd *self, struct cmd_ctx *ctx)
return (-1);
activity = 0;
if (data->flags & CMD_AFLAG)
if (data->chflags & CMD_CHFLAG('a'))
activity = 1;
if (session_next(s, activity) == 0)

6
cmd-paste-buffer.c
View File

@ -32,7 +32,7 @@ void cmd_paste_buffer_lf2cr(struct buffer *, const char *, size_t);
const struct cmd_entry cmd_paste_buffer_entry = {
"paste-buffer", "pasteb",
"[-dr] " CMD_BUFFER_WINDOW_USAGE,
CMD_DFLAG|CMD_RFLAG,
0, CMD_CHFLAG('d')|CMD_CHFLAG('r'),
cmd_buffer_init,
cmd_buffer_parse,
cmd_paste_buffer_exec,
@ -66,7 +66,7 @@ cmd_paste_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
if (pb != NULL && *pb->data != '\0') {
/* -r means raw data without LF->CR conversion. */
if (data->flags & CMD_RFLAG) {
if (data->chflags & CMD_CHFLAG('r')) {
buffer_write(
w->active->out, pb->data, strlen(pb->data));
} else {
@ -76,7 +76,7 @@ cmd_paste_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
}
/* Delete the buffer if -d. */
if (data->flags & CMD_DFLAG) {
if (data->chflags & CMD_CHFLAG('d')) {
if (data->buffer == -1)
paste_free_top(&s->buffers);
else

2
cmd-previous-layout.c
View File

@ -29,7 +29,7 @@ int cmd_previous_layout_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_previous_layout_entry = {
"previous-layout", "prevl",
CMD_TARGET_WINDOW_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_previous_layout_exec,

6
cmd-previous-window.c
View File

@ -30,7 +30,7 @@ int cmd_previous_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_previous_window_entry = {
"previous-window", "prev",
"[-a] " CMD_TARGET_SESSION_USAGE,
CMD_AFLAG,
0, CMD_CHFLAG('a'),
cmd_previous_window_init,
cmd_target_parse,
cmd_previous_window_exec,
@ -49,7 +49,7 @@ cmd_previous_window_init(struct cmd *self, int key)
data = self->data;
if (key == KEYC_ADDESC('p'))
data->flags |= CMD_AFLAG;
data->chflags |= CMD_CHFLAG('a');
}
int
@ -63,7 +63,7 @@ cmd_previous_window_exec(struct cmd *self, struct cmd_ctx *ctx)
return (-1);
activity = 0;
if (data->flags & CMD_AFLAG)
if (data->chflags & CMD_CHFLAG('a'))
activity = 1;
if (session_previous(s, activity) == 0)

2
cmd-refresh-client.c
View File

@ -29,7 +29,7 @@ int cmd_refresh_client_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_refresh_client_entry = {
"refresh-client", "refresh",
CMD_TARGET_CLIENT_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_refresh_client_exec,

2
cmd-rename-session.c
View File

@ -31,7 +31,7 @@ int cmd_rename_session_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_rename_session_entry = {
"rename-session", "rename",
CMD_TARGET_SESSION_USAGE " new-name",
CMD_ARG1,
CMD_ARG1, 0,
cmd_target_init,
cmd_target_parse,
cmd_rename_session_exec,

2
cmd-rename-window.c
View File

@ -31,7 +31,7 @@ int cmd_rename_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_rename_window_entry = {
"rename-window", "renamew",
CMD_TARGET_WINDOW_USAGE " new-name",
CMD_ARG1,
CMD_ARG1, 0,
cmd_target_init,
cmd_target_parse,
cmd_rename_window_exec,

8
cmd-resize-pane.c
View File

@ -32,7 +32,7 @@ int cmd_resize_pane_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_resize_pane_entry = {
"resize-pane", "resizep",
CMD_PANE_WINDOW_USAGE "[-DU] [adjustment]",
CMD_ARG01|CMD_BIGUFLAG|CMD_BIGDFLAG,
CMD_ARG01, CMD_CHFLAG('D')|CMD_CHFLAG('U'),
cmd_resize_pane_init,
cmd_pane_parse,
cmd_resize_pane_exec,
@ -51,12 +51,12 @@ cmd_resize_pane_init(struct cmd *self, int key)
data = self->data;
if (key == KEYC_ADDCTL(KEYC_DOWN))
data->flags |= CMD_BIGDFLAG;
data->chflags |= CMD_CHFLAG('D');
if (key == KEYC_ADDESC(KEYC_UP))
data->arg = xstrdup("5");
if (key == KEYC_ADDESC(KEYC_DOWN)) {
data->flags |= CMD_BIGDFLAG;
data->chflags |= CMD_CHFLAG('D');
data->arg = xstrdup("5");
}
}
@ -92,7 +92,7 @@ cmd_resize_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
}
}
if (!(data->flags & CMD_BIGDFLAG))
if (!(data->chflags & CMD_CHFLAG('D')))
adjust = -adjust;
if (layout_resize(wp, adjust) != 0) {
ctx->error(ctx, "layout %s "

4
cmd-respawn-window.c
View File

@ -31,7 +31,7 @@ int cmd_respawn_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_respawn_window_entry = {
"respawn-window", "respawnw",
"[-k] " CMD_TARGET_WINDOW_USAGE " [command]",
CMD_ARG01|CMD_KFLAG,
CMD_ARG01, CMD_CHFLAG('k'),
cmd_target_init,
cmd_target_parse,
cmd_respawn_window_exec,
@ -56,7 +56,7 @@ cmd_respawn_window_exec(struct cmd *self, struct cmd_ctx *ctx)
return (-1);
w = wl->window;
if (!(data->flags & CMD_KFLAG)) {
if (!(data->chflags & CMD_CHFLAG('k'))) {
TAILQ_FOREACH(wp, &w->panes, entry) {
if (wp->fd == -1)
continue;

6
cmd-rotate-window.c
View File

@ -30,7 +30,7 @@ int cmd_rotate_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_rotate_window_entry = {
"rotate-window", "rotatew",
"[-DU] " CMD_TARGET_WINDOW_USAGE,
CMD_BIGUFLAG|CMD_BIGDFLAG,
0, CMD_CHFLAG('D')|CMD_CHFLAG('U'),
cmd_rotate_window_init,
cmd_target_parse,
cmd_rotate_window_exec,
@ -49,7 +49,7 @@ cmd_rotate_window_init(struct cmd *self, int key)
data = self->data;
if (key == KEYC_ADDESC('o'))
data->flags |= CMD_BIGDFLAG;
data->chflags |= CMD_CHFLAG('D');
}
int
@ -66,7 +66,7 @@ cmd_rotate_window_exec(struct cmd *self, struct cmd_ctx *ctx)
return (-1);
w = wl->window;
if (data->flags & CMD_BIGDFLAG) {
if (data->chflags & CMD_CHFLAG('D')) {
wp = TAILQ_LAST(&w->panes, window_panes);
TAILQ_REMOVE(&w->panes, wp, entry);
TAILQ_INSERT_HEAD(&w->panes, wp, entry);

4
cmd-save-buffer.c
View File

@ -33,7 +33,7 @@ int cmd_save_buffer_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_save_buffer_entry = {
"save-buffer", "saveb",
"[-a] " CMD_BUFFER_SESSION_USAGE " path",
CMD_AFLAG|CMD_ARG1,
CMD_ARG1, CMD_CHFLAG('a'),
cmd_buffer_init,
cmd_buffer_parse,
cmd_save_buffer_exec,
@ -68,7 +68,7 @@ cmd_save_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
}
mask = umask(S_IRWXG | S_IRWXO);
if (data->flags & CMD_AFLAG)
if (data->chflags & CMD_CHFLAG('a'))
f = fopen(data->arg, "ab");
else
f = fopen(data->arg, "wb");

6
cmd-scroll-mode.c
View File

@ -30,7 +30,7 @@ int cmd_scroll_mode_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_scroll_mode_entry = {
"scroll-mode", NULL,
"[-u] " CMD_TARGET_WINDOW_USAGE,
CMD_UFLAG,
0, CMD_CHFLAG('u'),
cmd_scroll_mode_init,
cmd_target_parse,
cmd_scroll_mode_exec,
@ -50,7 +50,7 @@ cmd_scroll_mode_init(struct cmd *self, int key)
switch (key) {
case KEYC_PPAGE:
data->flags |= CMD_UFLAG;
data->chflags |= CMD_CHFLAG('u');
break;
}
}
@ -67,7 +67,7 @@ cmd_scroll_mode_exec(struct cmd *self, struct cmd_ctx *ctx)
wp = wl->window->active;
window_pane_set_mode(wp, &window_scroll_mode);
if (wp->mode == &window_scroll_mode && data->flags & CMD_UFLAG)
if (wp->mode == &window_scroll_mode && data->chflags & CMD_CHFLAG('u'))
window_scroll_pageup(wp);
return (0);

2
cmd-select-layout.c
View File

@ -30,7 +30,7 @@ int cmd_select_layout_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_select_layout_entry = {
"select-layout", "selectl",
CMD_TARGET_WINDOW_USAGE " layout-name",
CMD_ARG1,
CMD_ARG1, 0,
cmd_select_layout_init,
cmd_target_parse,
cmd_select_layout_exec,

2
cmd-select-pane.c
View File

@ -29,7 +29,7 @@ int cmd_select_pane_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_select_pane_entry = {
"select-pane", "selectp",
CMD_PANE_WINDOW_USAGE,
0,
0, 0,
cmd_pane_init,
cmd_pane_parse,
cmd_select_pane_exec,

2
cmd-select-prompt.c
View File

@ -33,7 +33,7 @@ int cmd_select_prompt_callback(void *, const char *);
const struct cmd_entry cmd_select_prompt_entry = {
"select-prompt", NULL,
CMD_TARGET_CLIENT_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_select_prompt_exec,

2
cmd-select-window.c
View File

@ -32,7 +32,7 @@ int cmd_select_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_select_window_entry = {
"select-window", "selectw",
CMD_TARGET_WINDOW_USAGE,
0,
0, 0,
cmd_select_window_init,
cmd_target_parse,
cmd_select_window_exec,

2
cmd-send-keys.c
View File

@ -43,7 +43,7 @@ struct cmd_send_keys_data {
const struct cmd_entry cmd_send_keys_entry = {
"send-keys", "send",
"[-t target-window] key ...",
0,
0, 0,
NULL,
cmd_send_keys_parse,
cmd_send_keys_exec,

2
cmd-send-prefix.c
View File

@ -29,7 +29,7 @@ int cmd_send_prefix_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_send_prefix_entry = {
"send-prefix", NULL,
CMD_TARGET_WINDOW_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_send_prefix_exec,

2
cmd-server-info.c
View File

@ -36,7 +36,7 @@ int cmd_server_info_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_server_info_entry = {
"server-info", "info",
"",
0,
0, 0,
NULL,
NULL,
cmd_server_info_exec,

2
cmd-set-buffer.c
View File

@ -31,7 +31,7 @@ int cmd_set_buffer_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_set_buffer_entry = {
"set-buffer", "setb",
CMD_BUFFER_SESSION_USAGE " data",
CMD_ARG1,
CMD_ARG1, 0,
cmd_buffer_init,
cmd_buffer_parse,
cmd_set_buffer_exec,

8
cmd-set-option.c
View File

@ -32,7 +32,7 @@ int cmd_set_option_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_set_option_entry = {
"set-option", "set",
CMD_OPTION_SESSION_USAGE,
CMD_GFLAG|CMD_UFLAG,
0, CMD_CHFLAG('g')|CMD_CHFLAG('u'),
NULL,
cmd_option_parse,
cmd_set_option_exec,
@ -87,7 +87,7 @@ cmd_set_option_exec(struct cmd *self, struct cmd_ctx *ctx)
const struct set_option_entry *entry;
u_int i;
if (data->flags & CMD_GFLAG)
if (data->chflags & CMD_CHFLAG('g'))
oo = &global_s_options;
else {
if ((s = cmd_find_session(ctx, data->target)) == NULL)
@ -120,8 +120,8 @@ cmd_set_option_exec(struct cmd *self, struct cmd_ctx *ctx)
return (-1);
}
if (data->flags & CMD_UFLAG) {
if (data->flags & CMD_GFLAG) {
if (data->chflags & CMD_CHFLAG('u')) {
if (data->chflags & CMD_CHFLAG('g')) {
ctx->error(ctx,
"can't unset global option: %s", entry->name);
return (-1);

2
cmd-set-password.c
View File

@ -43,7 +43,7 @@ struct cmd_set_password_data {
const struct cmd_entry cmd_set_password_entry = {
"set-password", "pass",
"[-c] password",
0,
0, 0,
cmd_set_password_init,
cmd_set_password_parse,
cmd_set_password_exec,

8
cmd-set-window-option.c
View File

@ -32,7 +32,7 @@ int cmd_set_window_option_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_set_window_option_entry = {
"set-window-option", "setw",
CMD_OPTION_WINDOW_USAGE,
CMD_GFLAG|CMD_UFLAG,
0, CMD_CHFLAG('g')|CMD_CHFLAG('u'),
NULL,
cmd_option_parse,
cmd_set_window_option_exec,
@ -81,7 +81,7 @@ cmd_set_window_option_exec(struct cmd *self, struct cmd_ctx *ctx)
const struct set_option_entry *entry;
u_int i;
if (data->flags & CMD_GFLAG)
if (data->chflags & CMD_CHFLAG('g'))
oo = &global_w_options;
else {
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
@ -114,8 +114,8 @@ cmd_set_window_option_exec(struct cmd *self, struct cmd_ctx *ctx)
return (-1);
}
if (data->flags & CMD_UFLAG) {
if (data->flags & CMD_GFLAG) {
if (data->chflags & CMD_CHFLAG('u')) {
if (data->chflags & CMD_CHFLAG('g')) {
ctx->error(ctx,
"can't unset global option: %s", entry->name);
return (-1);

2
cmd-show-buffer.c
View File

@ -31,7 +31,7 @@ int cmd_show_buffer_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_show_buffer_entry = {
"show-buffer", "showb",
CMD_BUFFER_SESSION_USAGE,
0,
0, 0,
cmd_buffer_init,
cmd_buffer_parse,
cmd_show_buffer_exec,

4
cmd-show-options.c
View File

@ -32,7 +32,7 @@ int cmd_show_options_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_show_options_entry = {
"show-options", "show",
"[-g] " CMD_TARGET_SESSION_USAGE,
CMD_GFLAG,
0, CMD_CHFLAG('g'),
cmd_target_init,
cmd_target_parse,
cmd_show_options_exec,
@ -53,7 +53,7 @@ cmd_show_options_exec(struct cmd *self, struct cmd_ctx *ctx)
char *vs;
long long vn;
if (data->flags & CMD_GFLAG)
if (data->chflags & CMD_CHFLAG('g'))
oo = &global_s_options;
else {
if ((s = cmd_find_session(ctx, data->target)) == NULL)

4
cmd-show-window-options.c
View File

@ -32,7 +32,7 @@ int cmd_show_window_options_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_show_window_options_entry = {
"show-window-options", "showw",
"[-g] " CMD_TARGET_WINDOW_USAGE,
CMD_GFLAG,
0, CMD_CHFLAG('g'),
cmd_target_init,
cmd_target_parse,
cmd_show_window_options_exec,
@ -53,7 +53,7 @@ cmd_show_window_options_exec(struct cmd *self, struct cmd_ctx *ctx)
char *vs;
long long vn;
if (data->flags & CMD_GFLAG)
if (data->chflags & CMD_CHFLAG('g'))
oo = &global_w_options;
else {
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)

2
cmd-source-file.c
View File

@ -39,7 +39,7 @@ struct cmd_source_file_data {
const struct cmd_entry cmd_source_file_entry = {
"source-file", "source",
"path",
0,
0, 0,
cmd_source_file_init,
cmd_source_file_parse,
cmd_source_file_exec,

2
cmd-split-window.c
View File

@ -46,7 +46,7 @@ struct cmd_split_window_data {
const struct cmd_entry cmd_split_window_entry = {
"split-window", "splitw",
"[-d] [-p percentage|-l lines] [-t target-window] [command]",
0,
0, 0,
cmd_split_window_init,
cmd_split_window_parse,
cmd_split_window_exec,

2
cmd-start-server.c
View File

@ -29,7 +29,7 @@ int cmd_start_server_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_start_server_entry = {
"start-server", "start",
"",
CMD_STARTSERVER,
CMD_STARTSERVER, 0,
NULL,
NULL,
cmd_start_server_exec,

2
cmd-suspend-client.c
View File

@ -37,7 +37,7 @@ struct cmd_suspend_client_data {
const struct cmd_entry cmd_suspend_client_entry = {
"suspend-client", "suspendc",
"[-c target-client]",
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_suspend_client_exec,

2
cmd-swap-pane.c
View File

@ -46,7 +46,7 @@ struct cmd_swap_pane_data {
const struct cmd_entry cmd_swap_pane_entry = {
"swap-pane", "swapp",
"[-dDU] [-t target-window] [-p src-index] [-q dst-index]",
0,
0, 0,
cmd_swap_pane_init,
cmd_swap_pane_parse,
cmd_swap_pane_exec,

4
cmd-swap-window.c
View File

@ -31,7 +31,7 @@ int cmd_swap_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_swap_window_entry = {
"swap-window", "swapw",
"[-d] " CMD_SRCDST_WINDOW_USAGE,
CMD_DFLAG,
0, CMD_CHFLAG('d'),
cmd_srcdst_init,
cmd_srcdst_parse,
cmd_swap_window_exec,
@ -61,7 +61,7 @@ cmd_swap_window_exec(struct cmd *self, struct cmd_ctx *ctx)
wl_dst->window = wl_src->window;
wl_src->window = w;
if (!(data->flags & CMD_DFLAG)) {
if (!(data->chflags & CMD_CHFLAG('d'))) {
session_select(dst, wl_dst->idx);
if (src != dst)
session_select(src, wl_src->idx);

2
cmd-switch-client.c
View File

@ -42,7 +42,7 @@ struct cmd_switch_client_data {
const struct cmd_entry cmd_switch_client_entry = {
"switch-client", "switchc",
"[-c target-client] [-t target-session]",
0,
0, 0,
NULL,
cmd_switch_client_parse,
cmd_switch_client_exec,

2
cmd-unbind-key.c
View File

@ -37,7 +37,7 @@ struct cmd_unbind_key_data {
const struct cmd_entry cmd_unbind_key_entry = {
"unbind-key", "unbind",
"key",
0,
0, 0,
NULL,
cmd_unbind_key_parse,
cmd_unbind_key_exec,

2
cmd-unlink-window.c
View File

@ -29,7 +29,7 @@ int cmd_unlink_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_unlink_window_entry = {
"unlink-window", "unlinkw",
CMD_TARGET_WINDOW_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_unlink_window_exec,

2
cmd-up-pane.c
View File

@ -29,7 +29,7 @@ int cmd_up_pane_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_up_pane_entry = {
"up-pane", "upp",
CMD_TARGET_WINDOW_USAGE,
0,
0, 0,
cmd_target_init,
cmd_target_parse,
cmd_up_pane_exec,

24
tmux.h
View File

@ -861,17 +861,13 @@ struct cmd_entry {
#define CMD_CANTNEST 0x2
#define CMD_ARG1 0x4
#define CMD_ARG01 0x8
#define CMD_AFLAG 0x10
#define CMD_DFLAG 0x20
#define CMD_GFLAG 0x40
#define CMD_KFLAG 0x80
#define CMD_UFLAG 0x100
#define CMD_BIGDFLAG 0x200
#define CMD_BIGUFLAG 0x400
#define CMD_RFLAG 0x800
int flags;
#define CMD_CHFLAG(flag) \
((flag) >= 'a' && (flag) <= 'z' ? 1ULL << ((flag) - 'a') : \
(flag) >= 'A' && (flag) <= 'Z' ? 1ULL << (26 + (flag) - 'A') : 0)
uint64_t chflags;
void (*init)(struct cmd *, int);
int (*parse)(struct cmd *, int, char **, char **);
int (*exec)(struct cmd *, struct cmd_ctx *);
@ -883,34 +879,34 @@ struct cmd_entry {
/* Generic command data. */
struct cmd_target_data {
int flags;
uint64_t chflags;
char *target;
char *arg;
};
struct cmd_srcdst_data {
int flags;
uint64_t chflags;
char *src;
char *dst;
char *arg;
};
struct cmd_buffer_data {
int flags;
uint64_t chflags;
char *target;
int buffer;
char *arg;
};
struct cmd_option_data {
int flags;
uint64_t chflags;
char *target;
char *option;
char *value;
};
struct cmd_pane_data {
int flags;
uint64_t chflags;
char *target;
char *arg;
int pane;