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

Sync OpenBSD patchset 829: 

Clean up and simplify tmux command argument parsing.

Originally, tmux commands were parsed in the client process into a
struct with the command data which was then serialised and sent to the
server to be executed. The parsing was later moved into the server (an
argv was sent from the client), but the parse step and intermediate
struct was kept.

This change removes that struct and the separate parse step. Argument
parsing and printing is now common to all commands (in arguments.c) with
each command left with just an optional check function (to validate the
arguments at parse time), the exec function and a function to set up any
key bindings (renamed from the old init function).

This is overall more simple and consistent.

There should be no changes to any commands behaviour or syntax although
as this touches every command please watch for any unexpected changes.
pull/1/head
Tiago Cunha 2011-01-07 14:45:34 +00:00
parent 219442cff7
commit 1df427bc7b
85 changed files with 1690 additions and 3048 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

222
arguments.c Normal file
View File

@ -0,0 +1,222 @@
/* $Id: arguments.c,v 1.1 2011-01-07 14:45:33 tcunha Exp $ */
/*
* Copyright (c) 2010 Nicholas Marriott <nicm@users.sourceforge.net>
*
* 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 <bitstring.h>
#include <stdlib.h>
#include <string.h>
#include "tmux.h"
/* Create an arguments set with no flags. */
struct args *
args_create(int argc, ...)
{
struct args *args;
va_list ap;
int i;
args = xcalloc(1, sizeof *args);
if ((args->flags = bit_alloc(SCHAR_MAX)) == NULL)
fatal("bit_alloc failed");
args->argc = argc;
if (argc == 0)
args->argv = NULL;
else
args->argv = xcalloc(argc, sizeof **args->argv);
va_start(ap, argc);
for (i = 0; i < argc; i++)
args->argv[i] = xstrdup(va_arg(ap, char *));
va_end(ap);
return (args);
}
/* Parse an argv and argc into a new argument set. */
struct args *
args_parse(const char *template, int argc, char **argv)
{
struct args *args;
char *ptr;
int opt;
args = xcalloc(1, sizeof *args);
if ((args->flags = bit_alloc(SCHAR_MAX)) == NULL)
fatal("bit_alloc failed");
optreset = 1;
optind = 1;
while ((opt = getopt(argc, argv, template)) != -1) {
if (opt < 0 || opt >= SCHAR_MAX)
continue;
if (opt == '?' || (ptr = strchr(template, opt)) == NULL) {
xfree(args->flags);
xfree(args);
return (NULL);
}
bit_set(args->flags, opt);
if (ptr[1] == ':') {
if (args->values[opt] != NULL)
xfree(args->values[opt]);
args->values[opt] = xstrdup(optarg);
}
}
argc -= optind;
argv += optind;
args->argc = argc;
args->argv = cmd_copy_argv(argc, argv);
return (args);
}
/* Free an arguments set. */
void
args_free(struct args *args)
{
u_int i;
cmd_free_argv(args->argc, args->argv);
for (i = 0; i < SCHAR_MAX; i++) {
if (args->values[i] != NULL)
xfree(args->values[i]);
}
xfree(args->flags);
xfree(args);
}
/* Print a set of arguments. */
size_t
args_print(struct args *args, char *buf, size_t len)
{
size_t off;
int i;
const char *quotes;
/* There must be at least one byte at the start. */
if (len == 0)
return (0);
off = 0;
/* Process the flags first. */
buf[off++] = '-';
for (i = 0; i < SCHAR_MAX; i++) {
if (!bit_test(args->flags, i) || args->values[i] != NULL)
continue;
if (off == len - 1) {
buf[off] = '\0';
return (len);
}
buf[off++] = i;
buf[off] = '\0';
}
if (off == 1)
buf[--off] = '\0';
/* Then the flags with arguments. */
for (i = 0; i < SCHAR_MAX; i++) {
if (!bit_test(args->flags, i) || args->values[i] == NULL)
continue;
if (off >= len) {
/* snprintf will have zero terminated. */
return (len);
}
if (strchr(args->values[i], ' ') != NULL)
quotes = "\"";
else
quotes = "";
off += xsnprintf(buf + off, len - off, "%s-%c %s%s%s",
off != 0 ? " " : "", i, quotes, args->values[i], quotes);
}
/* And finally the argument vector. */
for (i = 0; i < args->argc; i++) {
if (off >= len) {
/* snprintf will have zero terminated. */
return (len);
}
if (strchr(args->argv[i], ' ') != NULL)
quotes = "\"";
else
quotes = "";
off += xsnprintf(buf + off, len - off, "%s%s%s%s",
off != 0 ? " " : "", quotes, args->argv[i], quotes);
}
return (off);
}
/* Return if an argument is present. */
int
args_has(struct args *args, u_char ch)
{
return (bit_test(args->flags, ch));
}
/* Set argument value. */
void
args_set(struct args *args, u_char ch, const char *value)
{
if (value != NULL) {
if (args->values[ch] != NULL)
xfree(args->values[ch]);
args->values[ch] = xstrdup(value);
}
bit_set(args->flags, ch);
}
/* Get argument value. Will be NULL if it isn't present. */
const char *
args_get(struct args *args, u_char ch)
{
return (args->values[ch]);
}
/* Convert an argument value to a number. */
long long
args_strtonum(struct args *args,
u_char ch, long long minval, long long maxval, char **cause)
{
const char *errstr;
long long ll;
if (!args_has(args, ch)) {
*cause = xstrdup("missing");
return (0);
}
ll = strtonum(args->values[ch], minval, maxval, &errstr);
if (errstr != NULL) {
*cause = xstrdup(errstr);
return (0);
}
*cause = NULL;
return (ll);
}

34
cmd-attach-session.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-attach-session.c,v 1.38 2011-01-03 23:27:54 tcunha Exp $ */
/* $Id: cmd-attach-session.c,v 1.39 2011-01-07 14:45:33 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,37 +28,37 @@ int cmd_attach_session_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_attach_session_entry = {
"attach-session", "attach",
"drt:", 0, 0,
"[-dr] " CMD_TARGET_SESSION_USAGE,
CMD_CANTNEST|CMD_STARTSERVER|CMD_SENDENVIRON, "dr",
cmd_target_init,
cmd_target_parse,
cmd_attach_session_exec,
cmd_target_free,
cmd_target_print
CMD_CANTNEST|CMD_STARTSERVER|CMD_SENDENVIRON,
NULL,
NULL,
cmd_attach_session_exec
};
int
cmd_attach_session_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct session *s;
struct client *c;
const char *update;
char *overrides, *cause;
u_int i;
struct args *args = self->args;
struct session *s;
struct client *c;
const char *update;
char *overrides, *cause;
u_int i;
if (RB_EMPTY(&sessions)) {
ctx->error(ctx, "no sessions");
return (-1);
}
if ((s = cmd_find_session(ctx, data->target)) == NULL)
if ((s = cmd_find_session(ctx, args_get(args, 't'))) == NULL)
return (-1);
if (ctx->cmdclient == NULL && ctx->curclient == NULL)
return (0);
if (ctx->cmdclient == NULL) {
if (cmd_check_flag(data->chflags, 'd')) {
if (args_has(self->args, 'd')) {
/*
* Can't use server_write_session in case attaching to
* the same session as currently attached to.
@ -90,10 +90,10 @@ cmd_attach_session_exec(struct cmd *self, struct cmd_ctx *ctx)
return (-1);
}
if (cmd_check_flag(data->chflags, 'r'))
if (args_has(self->args, 'r'))
ctx->cmdclient->flags |= CLIENT_READONLY;
if (cmd_check_flag(data->chflags, 'd'))
if (args_has(self->args, 'd'))
server_write_session(s, MSG_DETACH, NULL, 0);
ctx->cmdclient->session = s;

191
cmd-bind-key.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-bind-key.c,v 1.29 2010-07-02 02:43:01 tcunha Exp $ */
/* $Id: cmd-bind-key.c,v 1.30 2011-01-07 14:45:33 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -26,136 +26,87 @@
* Bind a key to a command, this recurses through cmd_*.
*/
int cmd_bind_key_parse(struct cmd *, int, char **, char **);
int cmd_bind_key_check(struct args *);
int cmd_bind_key_exec(struct cmd *, struct cmd_ctx *);
void cmd_bind_key_free(struct cmd *);
size_t cmd_bind_key_print(struct cmd *, char *, size_t);
int cmd_bind_key_table(struct cmd *, struct cmd_ctx *);
struct cmd_bind_key_data {
int key;
int can_repeat;
struct cmd_list *cmdlist;
int command_key;
char *tablename;
char *modecmd;
};
int cmd_bind_key_table(struct cmd *, struct cmd_ctx *, int);
const struct cmd_entry cmd_bind_key_entry = {
"bind-key", "bind",
"cnrt:", 1, -1,
"[-cnr] [-t key-table] key command [arguments]",
0, "",
0,
NULL,
cmd_bind_key_parse,
cmd_bind_key_exec,
cmd_bind_key_free,
cmd_bind_key_print
cmd_bind_key_check,
cmd_bind_key_exec
};
int
cmd_bind_key_parse(struct cmd *self, int argc, char **argv, char **cause)
cmd_bind_key_check(struct args *args)
{
struct cmd_bind_key_data *data;
int opt, no_prefix = 0;
self->data = data = xmalloc(sizeof *data);
data->can_repeat = 0;
data->cmdlist = NULL;
data->command_key = 0;
data->tablename = NULL;
data->modecmd = NULL;
while ((opt = getopt(argc, argv, "cnrt:")) != -1) {
switch (opt) {
case 'c':
data->command_key = 1;
break;
case 'n':
no_prefix = 1;
break;
case 'r':
data->can_repeat = 1;
break;
case 't':
if (data->tablename == NULL)
data->tablename = xstrdup(optarg);
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (argc < 1)
goto usage;
if ((data->key = key_string_lookup_string(argv[0])) == KEYC_NONE) {
xasprintf(cause, "unknown key: %s", argv[0]);
goto error;
}
if (!no_prefix)
data->key |= KEYC_PREFIX;
argc--;
argv++;
if (data->tablename != NULL) {
if (argc != 1)
goto usage;
data->modecmd = xstrdup(argv[0]);
if (args_has(args, 't')) {
if (args->argc != 1)
return (-1);
} else {
if ((data->cmdlist = cmd_list_parse(argc, argv, cause)) == NULL)
goto error;
if (args->argc < 2)
return (-1);
}
return (0);
}
int
cmd_bind_key_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct args *args = self->args;
char *cause;
struct cmd_list *cmdlist;
int key;
key = key_string_lookup_string(args->argv[0]);
if (key == KEYC_NONE) {
ctx->error(ctx, "unknown key: %s", args->argv[0]);
return (-1);
}
return (0);
if (args_has(args, 't'))
return (cmd_bind_key_table(self, ctx, key));
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
error:
self->entry->free(self);
return (-1);
}
int
cmd_bind_key_exec(struct cmd *self, unused struct cmd_ctx *ctx)
{
struct cmd_bind_key_data *data = self->data;
if (data == NULL)
return (0);
if (data->tablename != NULL)
return (cmd_bind_key_table(self, ctx));
key_bindings_add(data->key, data->can_repeat, data->cmdlist);
data->cmdlist->references++;
cmdlist = cmd_list_parse(args->argc - 1, args->argv + 1, &cause);
if (cmdlist == NULL) {
ctx->error(ctx, "%s", cause);
xfree(cause);
return (-1);
}
if (!args_has(args, 'n'))
key |= KEYC_PREFIX;
key_bindings_add(key, args_has(args, 'r'), cmdlist);
return (0);
}
int
cmd_bind_key_table(struct cmd *self, struct cmd_ctx *ctx)
cmd_bind_key_table(struct cmd *self, struct cmd_ctx *ctx, int key)
{
struct cmd_bind_key_data *data = self->data;
struct args *args = self->args;
const char *tablename;
const struct mode_key_table *mtab;
struct mode_key_binding *mbind, mtmp;
enum mode_key_cmd cmd;
if ((mtab = mode_key_findtable(data->tablename)) == NULL) {
ctx->error(ctx, "unknown key table: %s", data->tablename);
tablename = args_get(args, 't');
if ((mtab = mode_key_findtable(tablename)) == NULL) {
ctx->error(ctx, "unknown key table: %s", tablename);
return (-1);
}
cmd = mode_key_fromstring(mtab->cmdstr, data->modecmd);
cmd = mode_key_fromstring(mtab->cmdstr, args->argv[0]);
if (cmd == MODEKEY_NONE) {
ctx->error(ctx, "unknown command: %s", data->modecmd);
ctx->error(ctx, "unknown command: %s", args->argv[0]);
return (-1);
}
mtmp.key = data->key & ~KEYC_PREFIX;
mtmp.mode = data->command_key ? 1 : 0;
mtmp.key = key;
mtmp.mode = !!args_has(args, 'c');
if ((mbind = SPLAY_FIND(mode_key_tree, mtab->tree, &mtmp)) != NULL) {
mbind->cmd = cmd;
return (0);
@ -167,45 +118,3 @@ cmd_bind_key_table(struct cmd *self, struct cmd_ctx *ctx)
SPLAY_INSERT(mode_key_tree, mtab->tree, mbind);
return (0);
}
void
cmd_bind_key_free(struct cmd *self)
{
struct cmd_bind_key_data *data = self->data;
if (data->cmdlist != NULL)
cmd_list_free(data->cmdlist);
if (data->tablename != NULL)
xfree(data->tablename);
if (data->modecmd != NULL)
xfree(data->modecmd);
xfree(data);
}
size_t
cmd_bind_key_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_bind_key_data *data = self->data;
size_t off = 0;
const char *skey;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
if (off < len && data->command_key)
off += xsnprintf(buf + off, len - off, " -c");
if (off < len && !(data->key & KEYC_PREFIX))
off += xsnprintf(buf + off, len - off, " -n");
if (off < len && data->can_repeat)
off += xsnprintf(buf + off, len - off, " -r");
if (off < len && data->tablename != NULL)
off += cmd_prarg(buf + off, len - off, " -t ", data->tablename);
if (off < len) {
skey = key_string_lookup_key(data->key & ~KEYC_PREFIX);
off += xsnprintf(buf + off, len - off, " %s ", skey);
}
if (off < len)
off += cmd_list_print(data->cmdlist, buf + off, len - off);
return (off);
}

21
cmd-break-pane.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-break-pane.c,v 1.11 2009-12-04 22:14:47 tcunha Exp $ */
/* $Id: cmd-break-pane.c,v 1.12 2011-01-07 14:45:33 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,19 +30,18 @@ int cmd_break_pane_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_break_pane_entry = {
"break-pane", "breakp",
CMD_TARGET_PANE_USAGE " [-d]",
0, "d",
cmd_target_init,
cmd_target_parse,
cmd_break_pane_exec,
cmd_target_free,
cmd_target_print
"dt:", 0, 0,
"[-d] " CMD_TARGET_PANE_USAGE,
0,
NULL,
NULL,
cmd_break_pane_exec
};
int
cmd_break_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct winlink *wl;
struct session *s;
struct window_pane *wp;
@ -50,7 +49,7 @@ cmd_break_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
char *cause;
int base_idx;
if ((wl = cmd_find_pane(ctx, data->target, &s, &wp)) == NULL)
if ((wl = cmd_find_pane(ctx, args_get(args, 't'), &s, &wp)) == NULL)
return (-1);
if (window_count_panes(wl->window) == 1) {
@ -74,7 +73,7 @@ cmd_break_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
base_idx = options_get_number(&s->options, "base-index");
wl = session_attach(s, w, -1 - base_idx, &cause); /* can't fail */
if (!cmd_check_flag(data->chflags, 'd'))
if (!args_has(self->args, 'd'))
session_select(s, wl->idx);
server_redraw_session(s);

133
cmd-capture-pane.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-capture-pane.c,v 1.5 2010-12-31 01:59:47 tcunha Exp $ */
/* $Id: cmd-capture-pane.c,v 1.6 2011-01-07 14:45:33 tcunha Exp $ */
/*
* Copyright (c) 2009 Jonathan Alvarado <radobobo@users.sourceforge.net>
@ -27,93 +27,30 @@
* Write the entire contents of a pane to a buffer.
*/
int cmd_capture_pane_parse(struct cmd *, int, char **, char **);
int cmd_capture_pane_exec(struct cmd *, struct cmd_ctx *);
void cmd_capture_pane_free(struct cmd *);
void cmd_capture_pane_init(struct cmd *, int);
size_t cmd_capture_pane_print(struct cmd *, char *, size_t);
struct cmd_capture_pane_data {
char *target;
int buffer;
};
const struct cmd_entry cmd_capture_pane_entry = {
"capture-pane", "capturep",
"b:t:", 0, 0,
"[-b buffer-index] [-t target-pane]",
0, "",
cmd_capture_pane_init,
cmd_capture_pane_parse,
cmd_capture_pane_exec,
cmd_capture_pane_free,
cmd_capture_pane_print
0,
NULL,
NULL,
cmd_capture_pane_exec
};
/* ARGSUSED */
void
cmd_capture_pane_init(struct cmd *self, unused int arg)
{
struct cmd_capture_pane_data *data;
self->data = data = xmalloc(sizeof *data);
data->buffer = -1;
data->target = NULL;
}
int
cmd_capture_pane_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_capture_pane_data *data;
const char *errstr;
int n, opt;
self->entry->init(self, KEYC_NONE);
data = self->data;
while ((opt = getopt(argc, argv, "b:t:")) != -1) {
switch (opt) {
case 'b':
if (data->buffer == -1) {
n = strtonum(optarg, 0, INT_MAX, &errstr);
if (errstr != NULL) {
xasprintf(cause, "buffer %s", errstr);
goto error;
}
data->buffer = n;
}
break;
case 't':
if (data->target == NULL)
data->target = xstrdup(optarg);
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
error:
self->entry->free(self);
return (-1);
}
int
cmd_capture_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_capture_pane_data *data = self->data;
struct window_pane *wp;
char *buf, *line;
struct screen *s;
u_int i, limit;
size_t len, linelen;
struct args *args = self->args;
struct window_pane *wp;
char *buf, *line, *cause;
struct screen *s;
int buffer;
u_int i, limit;
size_t len, linelen;
if (cmd_find_pane(ctx, data->target, NULL, &wp) == NULL)
if (cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp) == NULL)
return (-1);
s = &wp->base;
@ -133,40 +70,24 @@ cmd_capture_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
}
limit = options_get_number(&global_options, "buffer-limit");
if (data->buffer == -1) {
if (!args_has(args, 'b')) {
paste_add(&global_buffers, buf, len, limit);
return (0);
}
if (paste_replace(&global_buffers, data->buffer, buf, len) != 0) {
ctx->error(ctx, "no buffer %d", data->buffer);
buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
if (cause != NULL) {
ctx->error(ctx, "buffer %s", cause);
xfree(cause);
return (-1);
}
if (paste_replace(&global_buffers, buffer, buf, len) != 0) {
ctx->error(ctx, "no buffer %d", buffer);
xfree(buf);
return (-1);
}
return (0);
}
void
cmd_capture_pane_free(struct cmd *self)
{
struct cmd_capture_pane_data *data = self->data;
if (data->target != NULL)
xfree(data->target);
xfree(data);
}
size_t
cmd_capture_pane_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_capture_pane_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
if (off < len && data->buffer != -1)
off += xsnprintf(buf + off, len - off, " -b %d", data->buffer);
if (off < len && data->target != NULL)
off += xsnprintf(buf + off, len - off, " -t %s", data->target);
return (off);
}

25
cmd-choose-buffer.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-choose-buffer.c,v 1.3 2011-01-03 23:26:14 tcunha Exp $ */
/* $Id: cmd-choose-buffer.c,v 1.4 2011-01-07 14:45:33 tcunha Exp $ */
/*
* Copyright (c) 2010 Nicholas Marriott <nicm@users.sourceforge.net>
@ -33,24 +33,23 @@ void cmd_choose_buffer_free(void *);
const struct cmd_entry cmd_choose_buffer_entry = {
"choose-buffer", NULL,
"t:", 0, 1,
CMD_TARGET_WINDOW_USAGE " [template]",
CMD_ARG01, "",
cmd_target_init,
cmd_target_parse,
cmd_choose_buffer_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_choose_buffer_exec
};
struct cmd_choose_buffer_data {
struct client *client;
char *template;
struct client *client;
char *template;
};
int
cmd_choose_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct cmd_choose_buffer_data *cdata;
struct winlink *wl;
struct paste_buffer *pb;
@ -62,7 +61,7 @@ cmd_choose_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
return (-1);
}
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
return (-1);
if (paste_get_top(&global_buffers) == NULL)
@ -80,8 +79,8 @@ cmd_choose_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
}
cdata = xmalloc(sizeof *cdata);
if (data->arg != NULL)
cdata->template = xstrdup(data->arg);
if (args->argc != 0)
cdata->template = xstrdup(args->argv[0]);
else
cdata->template = xstrdup("paste-buffer -b '%%'");
cdata->client = ctx->curclient;

21
cmd-choose-client.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-choose-client.c,v 1.4 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-choose-client.c,v 1.5 2011-01-07 14:45:33 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -33,13 +33,12 @@ void cmd_choose_client_free(void *);
const struct cmd_entry cmd_choose_client_entry = {
"choose-client", NULL,
"t:", 0, 1,
CMD_TARGET_WINDOW_USAGE " [template]",
CMD_ARG01, "",
cmd_target_init,
cmd_target_parse,
cmd_choose_client_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_choose_client_exec
};
struct cmd_choose_client_data {
@ -50,7 +49,7 @@ struct cmd_choose_client_data {
int
cmd_choose_client_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct cmd_choose_client_data *cdata;
struct winlink *wl;
struct client *c;
@ -61,7 +60,7 @@ cmd_choose_client_exec(struct cmd *self, struct cmd_ctx *ctx)
return (-1);
}
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
return (-1);
if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
@ -83,8 +82,8 @@ cmd_choose_client_exec(struct cmd *self, struct cmd_ctx *ctx)
}
cdata = xmalloc(sizeof *cdata);
if (data->arg != NULL)
cdata->template = xstrdup(data->arg);
if (args->argc != 0)
cdata->template = xstrdup(args->argv[0]);
else
cdata->template = xstrdup("detach-client -t '%%'");
cdata->client = ctx->curclient;

21
cmd-choose-session.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-choose-session.c,v 1.17 2010-12-22 15:36:44 tcunha Exp $ */
/* $Id: cmd-choose-session.c,v 1.18 2011-01-07 14:45:33 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -33,13 +33,12 @@ void cmd_choose_session_free(void *);
const struct cmd_entry cmd_choose_session_entry = {
"choose-session", NULL,
"t:", 0, 1,
CMD_TARGET_WINDOW_USAGE " [template]",
CMD_ARG01, "",
cmd_target_init,
cmd_target_parse,
cmd_choose_session_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_choose_session_exec
};
struct cmd_choose_session_data {
@ -50,7 +49,7 @@ struct cmd_choose_session_data {
int
cmd_choose_session_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct cmd_choose_session_data *cdata;
struct winlink *wl;
struct session *s;
@ -63,7 +62,7 @@ cmd_choose_session_exec(struct cmd *self, struct cmd_ctx *ctx)
return (-1);
}
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
return (-1);
if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
@ -90,8 +89,8 @@ cmd_choose_session_exec(struct cmd *self, struct cmd_ctx *ctx)
}
cdata = xmalloc(sizeof *cdata);
if (data->arg != NULL)
cdata->template = xstrdup(data->arg);
if (args->argc != 0)
cdata->template = xstrdup(args->argv[0]);
else
cdata->template = xstrdup("switch-client -t '%%'");
cdata->client = ctx->curclient;

21
cmd-choose-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-choose-window.c,v 1.24 2010-12-22 15:28:50 tcunha Exp $ */
/* $Id: cmd-choose-window.c,v 1.25 2011-01-07 14:45:33 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -33,13 +33,12 @@ void cmd_choose_window_free(void *);
const struct cmd_entry cmd_choose_window_entry = {
"choose-window", NULL,
"t:", 0, 1,
CMD_TARGET_WINDOW_USAGE " [template]",
CMD_ARG01, "",
cmd_target_init,
cmd_target_parse,
cmd_choose_window_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_choose_window_exec
};
struct cmd_choose_window_data {
@ -51,7 +50,7 @@ struct cmd_choose_window_data {
int
cmd_choose_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct cmd_choose_window_data *cdata;
struct session *s;
struct winlink *wl, *wm;
@ -66,7 +65,7 @@ cmd_choose_window_exec(struct cmd *self, struct cmd_ctx *ctx)
}
s = ctx->curclient->session;
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
return (-1);
if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
@ -110,8 +109,8 @@ cmd_choose_window_exec(struct cmd *self, struct cmd_ctx *ctx)
}
cdata = xmalloc(sizeof *cdata);
if (data->arg != NULL)
cdata->template = xstrdup(data->arg);
if (args->argc != 0)
cdata->template = xstrdup(args->argv[0]);
else
cdata->template = xstrdup("select-window -t '%%'");
cdata->session = s;

17
cmd-clear-history.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-clear-history.c,v 1.8 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-clear-history.c,v 1.9 2011-01-07 14:45:33 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,23 +28,22 @@ int cmd_clear_history_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_clear_history_entry = {
"clear-history", "clearhist",
"t:", 0, 0,
CMD_TARGET_PANE_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_clear_history_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_clear_history_exec
};
int
cmd_clear_history_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct window_pane *wp;
struct grid *gd;
if (cmd_find_pane(ctx, data->target, NULL, &wp) == NULL)
if (cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp) == NULL)
return (-1);
gd = wp->base.grid;

17
cmd-clock-mode.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-clock-mode.c,v 1.7 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-clock-mode.c,v 1.8 2011-01-07 14:45:33 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,22 +28,21 @@ int cmd_clock_mode_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_clock_mode_entry = {
"clock-mode", NULL,
"t:", 0, 0,
CMD_TARGET_PANE_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_clock_mode_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_clock_mode_exec
};
int
cmd_clock_mode_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct window_pane *wp;
if (cmd_find_pane(ctx, data->target, NULL, &wp) == NULL)
if (cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp) == NULL)
return (-1);
window_pane_set_mode(wp, &window_clock_mode);

152
cmd-command-prompt.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-command-prompt.c,v 1.28 2010-05-14 14:33:39 tcunha Exp $ */
/* $Id: cmd-command-prompt.c,v 1.29 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@ -27,30 +27,21 @@
* Prompt for command in client.
*/
void cmd_command_prompt_init(struct cmd *, int);
int cmd_command_prompt_parse(struct cmd *, int, char **, char **);
int cmd_command_prompt_exec(struct cmd *, struct cmd_ctx *);
void cmd_command_prompt_free(struct cmd *);
size_t cmd_command_prompt_print(struct cmd *, char *, size_t);
void cmd_command_prompt_key_binding(struct cmd *, int);
int cmd_command_prompt_check(struct args *);
int cmd_command_prompt_exec(struct cmd *, struct cmd_ctx *);
int cmd_command_prompt_callback(void *, const char *);
void cmd_command_prompt_cfree(void *);
int cmd_command_prompt_callback(void *, const char *);
void cmd_command_prompt_free(void *);
const struct cmd_entry cmd_command_prompt_entry = {
"command-prompt", NULL,
"p:t:", 0, 0,
CMD_TARGET_CLIENT_USAGE " [-p prompts] [template]",
0, "",
cmd_command_prompt_init,
cmd_command_prompt_parse,
cmd_command_prompt_exec,
cmd_command_prompt_free,
cmd_command_prompt_print
};
struct cmd_command_prompt_data {
char *prompts;
char *target;
char *template;
0,
cmd_command_prompt_key_binding,
NULL,
cmd_command_prompt_exec
};
struct cmd_command_prompt_cdata {
@ -62,82 +53,39 @@ struct cmd_command_prompt_cdata {
};
void
cmd_command_prompt_init(struct cmd *self, int key)
cmd_command_prompt_key_binding(struct cmd *self, int key)
{
struct cmd_command_prompt_data *data;
self->data = data = xmalloc(sizeof *data);
data->prompts = NULL;
data->target = NULL;
data->template = NULL;
switch (key) {
case ',':
data->template = xstrdup("rename-window '%%'");
self->args = args_create(1, "rename-window '%%'");
break;
case '.':
data->template = xstrdup("move-window -t '%%'");
self->args = args_create(1, "move-window -t '%%'");
break;
case 'f':
data->template = xstrdup("find-window '%%'");
self->args = args_create(1, "find-window '%%'");
break;
case '\'':
data->template = xstrdup("select-window -t ':%%'");
data->prompts = xstrdup("index");
self->args = args_create(1, "select-window -t ':%%'");
args_set(self->args, 'p', "index");
break;
default:
self->args = args_create(0);
break;
}
}
int
cmd_command_prompt_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_command_prompt_data *data;
int opt;
self->entry->init(self, KEYC_NONE);
data = self->data;
while ((opt = getopt(argc, argv, "p:t:")) != -1) {
switch (opt) {
case 'p':
if (data->prompts == NULL)
data->prompts = xstrdup(optarg);
break;
case 't':
if (data->target == NULL)
data->target = xstrdup(optarg);
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (argc != 0 && argc != 1)
goto usage;
if (argc == 1)
data->template = xstrdup(argv[0]);
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
self->entry->free(self);
return (-1);
}
int
cmd_command_prompt_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_command_prompt_data *data = self->data;
struct args *args = self->args;
const char *prompts;
struct cmd_command_prompt_cdata *cdata;
struct client *c;
char *prompt, *ptr;
size_t n;
if ((c = cmd_find_client(ctx, data->target)) == NULL)
if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
return (-1);
if (c->prompt_string != NULL)
@ -150,63 +98,33 @@ cmd_command_prompt_exec(struct cmd *self, struct cmd_ctx *ctx)
cdata->prompts = NULL;
cdata->template = NULL;
if (data->template != NULL)
cdata->template = xstrdup(data->template);
if (args->argc != 0)
cdata->template = xstrdup(args->argv[0]);
else
cdata->template = xstrdup("%1");
if (data->prompts != NULL)
cdata->prompts = xstrdup(data->prompts);
else if (data->template != NULL) {
n = strcspn(data->template, " ,");
xasprintf(&cdata->prompts, "(%.*s) ", (int) n, data->template);
prompts = args_get(args, 'p');
if (prompts != NULL)
cdata->prompts = xstrdup(prompts);
else if (args->argc != 0) {
n = strcspn(cdata->template, " ,");
xasprintf(&cdata->prompts, "(%.*s) ", (int) n, cdata->template);
} else
cdata->prompts = xstrdup(":");
cdata->next_prompt = cdata->prompts;
ptr = strsep(&cdata->next_prompt, ",");
if (data->prompts == NULL)
if (prompts == NULL)
prompt = xstrdup(ptr);
else
xasprintf(&prompt, "%s ", ptr);
status_prompt_set(c, prompt, cmd_command_prompt_callback,
cmd_command_prompt_cfree, cdata, 0);
cmd_command_prompt_free, cdata, 0);
xfree(prompt);
return (0);
}
void
cmd_command_prompt_free(struct cmd *self)
{
struct cmd_command_prompt_data *data = self->data;
if (data->prompts != NULL)
xfree(data->prompts);
if (data->target != NULL)
xfree(data->target);
if (data->template != NULL)
xfree(data->template);
xfree(data);
}
size_t
cmd_command_prompt_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_command_prompt_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
if (off < len && data->prompts != NULL)
off += cmd_prarg(buf + off, len - off, " -p ", data->prompts);
if (off < len && data->target != NULL)
off += cmd_prarg(buf + off, len - off, " -t ", data->target);
if (off < len && data->template != NULL)
off += cmd_prarg(buf + off, len - off, " ", data->template);
return (off);
}
int
cmd_command_prompt_callback(void *data, const char *s)
{
@ -258,7 +176,7 @@ cmd_command_prompt_callback(void *data, const char *s)
}
void
cmd_command_prompt_cfree(void *data)
cmd_command_prompt_free(void *data)
{
struct cmd_command_prompt_cdata *cdata = data;

37
cmd-confirm-before.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-confirm-before.c,v 1.12 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-confirm-before.c,v 1.13 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@ -25,21 +25,20 @@
* Asks for confirmation before executing a command.
*/
void cmd_confirm_before_key_binding(struct cmd *, int);
int cmd_confirm_before_exec(struct cmd *, struct cmd_ctx *);
void cmd_confirm_before_init(struct cmd *, int);
int cmd_confirm_before_callback(void *, const char *);
void cmd_confirm_before_free(void *);
const struct cmd_entry cmd_confirm_before_entry = {
"confirm-before", "confirm",
"t:", 1, 1,
CMD_TARGET_CLIENT_USAGE " command",
CMD_ARG1, "",
cmd_confirm_before_init,
cmd_target_parse,
cmd_confirm_before_exec,
cmd_target_free,
cmd_target_print
0,
cmd_confirm_before_key_binding,
NULL,
cmd_confirm_before_exec
};
struct cmd_confirm_before_data {
@ -48,19 +47,17 @@ struct cmd_confirm_before_data {
};
void
cmd_confirm_before_init(struct cmd *self, int key)
cmd_confirm_before_key_binding(struct cmd *self, int key)
{
struct cmd_target_data *data;
cmd_target_init(self, key);
data = self->data;
switch (key) {
case '&':
data->arg = xstrdup("kill-window");
self->args = args_create(1, "kill-window");
break;
case 'x':
data->arg = xstrdup("kill-pane");
self->args = args_create(1, "kill-pane");
break;
default:
self->args = args_create(0);
break;
}
}
@ -68,7 +65,7 @@ cmd_confirm_before_init(struct cmd *self, int key)
int
cmd_confirm_before_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct cmd_confirm_before_data *cdata;
struct client *c;
char *buf, *cmd, *ptr;
@ -78,17 +75,17 @@ cmd_confirm_before_exec(struct cmd *self, struct cmd_ctx *ctx)
return (-1);
}
if ((c = cmd_find_client(ctx, data->target)) == NULL)
if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
return (-1);
ptr = xstrdup(data->arg);
ptr = xstrdup(args->argv[0]);
if ((cmd = strtok(ptr, " \t")) == NULL)
cmd = ptr;
xasprintf(&buf, "Confirm '%s'? (y/n) ", cmd);
xfree(ptr);
cdata = xmalloc(sizeof *cdata);
cdata->cmd = xstrdup(data->arg);
cdata->cmd = xstrdup(args->argv[0]);
cdata->c = c;
status_prompt_set(cdata->c, buf,
cmd_confirm_before_callback, cmd_confirm_before_free, cdata,

36
cmd-copy-mode.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-copy-mode.c,v 1.28 2010-08-11 22:18:28 tcunha Exp $ */
/* $Id: cmd-copy-mode.c,v 1.29 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -24,48 +24,40 @@
* Enter copy mode.
*/
void cmd_copy_mode_init(struct cmd *, int);
void cmd_copy_mode_key_binding(struct cmd *, int);
int cmd_copy_mode_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_copy_mode_entry = {
"copy-mode", NULL,
"t:u", 0, 0,
"[-u] " CMD_TARGET_PANE_USAGE,
0, "u",
cmd_copy_mode_init,
cmd_target_parse,
cmd_copy_mode_exec,
cmd_target_free,
cmd_target_print
0,
cmd_copy_mode_key_binding,
NULL,
cmd_copy_mode_exec
};
void
cmd_copy_mode_init(struct cmd *self, int key)
cmd_copy_mode_key_binding(struct cmd *self, int key)
{
struct cmd_target_data *data;
cmd_target_init(self, key);
data = self->data;
switch (key) {
case KEYC_PPAGE:
cmd_set_flag(&data->chflags, 'u');
break;
}
self->args = args_create(0);
if (key == KEYC_PPAGE)
args_set(self->args, 'u', NULL);
}
int
cmd_copy_mode_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct window_pane *wp;
if (cmd_find_pane(ctx, data->target, NULL, &wp) == NULL)
if (cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp) == NULL)
return (-1);
if (window_pane_set_mode(wp, &window_copy_mode) != 0)
return (0);
window_copy_init_from_pane(wp);
if (wp->mode == &window_copy_mode && cmd_check_flag(data->chflags, 'u'))
if (wp->mode == &window_copy_mode && args_has(self->args, 'u'))
window_copy_pageup(wp);
return (0);

33
cmd-delete-buffer.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-delete-buffer.c,v 1.9 2010-12-30 22:39:49 tcunha Exp $ */
/* $Id: cmd-delete-buffer.c,v 1.10 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,24 +30,35 @@ int cmd_delete_buffer_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_delete_buffer_entry = {
"delete-buffer", "deleteb",
"b:", 0, 0,
CMD_BUFFER_USAGE,
0, "",
cmd_buffer_init,
cmd_buffer_parse,
cmd_delete_buffer_exec,
cmd_buffer_free,
cmd_buffer_print
0,
NULL,
NULL,
cmd_delete_buffer_exec
};
int
cmd_delete_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_buffer_data *data = self->data;
struct args *args = self->args;
char *cause;
int buffer;
if (data->buffer == -1)
if (!args_has(args, 'b')) {
paste_free_top(&global_buffers);
else if (paste_free_index(&global_buffers, data->buffer) != 0) {
ctx->error(ctx, "no buffer %d", data->buffer);
return (0);
}
buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
if (cause != NULL) {
ctx->error(ctx, "buffer %s", cause);
xfree(cause);
return (-1);
}
if (paste_free_index(&global_buffers, buffer) != 0) {
ctx->error(ctx, "no buffer %d", buffer);
return (-1);
}

19
cmd-detach-client.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-detach-client.c,v 1.11 2010-02-08 18:27:34 tcunha Exp $ */
/* $Id: cmd-detach-client.c,v 1.12 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,22 +28,21 @@ int cmd_detach_client_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_detach_client_entry = {
"detach-client", "detach",
"t:", 0, 0,
CMD_TARGET_CLIENT_USAGE,
CMD_READONLY, "",
cmd_target_init,
cmd_target_parse,
cmd_detach_client_exec,
cmd_target_free,
cmd_target_print
CMD_READONLY,
NULL,
NULL,
cmd_detach_client_exec
};
int
cmd_detach_client_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct client *c;
struct args *args = self->args;
struct client *c;
if ((c = cmd_find_client(ctx, data->target)) == NULL)
if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
return (-1);
server_write_client(c, MSG_DETACH, NULL, 0);

23
cmd-display-message.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-display-message.c,v 1.7 2009-11-28 14:39:53 tcunha Exp $ */
/* $Id: cmd-display-message.c,v 1.8 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@ -30,33 +30,32 @@ int cmd_display_message_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_display_message_entry = {
"display-message", "display",
"pt:", 0, 1,
"[-p] " CMD_TARGET_CLIENT_USAGE " [message]",
CMD_ARG01, "p",
cmd_target_init,
cmd_target_parse,
cmd_display_message_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_display_message_exec
};
int
cmd_display_message_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct client *c;
const char *template;
char *msg;
if ((c = cmd_find_client(ctx, data->target)) == NULL)
if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
return (-1);
if (data->arg == NULL)
if (args->argc == 0)
template = "[#S] #I:#W, current pane #P - (%H:%M %d-%b-%y)";
else
template = data->arg;
template = args->argv[0];
msg = status_replace(c, NULL, template, time(NULL), 0);
if (cmd_check_flag(data->chflags, 'p'))
if (args_has(self->args, 'p'))
ctx->print(ctx, "%s", msg);
else
status_message_set(c, "%s", msg);

19
cmd-display-panes.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-display-panes.c,v 1.2 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-display-panes.c,v 1.3 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,22 +28,21 @@ int cmd_display_panes_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_display_panes_entry = {
"display-panes", "displayp",
"t:", 0, 0,
CMD_TARGET_CLIENT_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_display_panes_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_display_panes_exec
};
int
cmd_display_panes_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct client *c;
struct args *args = self->args;
struct client *c;
if ((c = cmd_find_client(ctx, data->target)) == NULL)
if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
return (-1);
server_set_identify(c);

27
cmd-find-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-find-window.c,v 1.15 2010-12-22 15:28:50 tcunha Exp $ */
/* $Id: cmd-find-window.c,v 1.16 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -34,13 +34,12 @@ void cmd_find_window_free(void *);
const struct cmd_entry cmd_find_window_entry = {
"find-window", "findw",
"t:", 1, 1,
CMD_TARGET_WINDOW_USAGE " match-string",
CMD_ARG1, "",
cmd_target_init,
cmd_target_parse,
cmd_find_window_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_find_window_exec
};
struct cmd_find_window_data {
@ -50,7 +49,7 @@ struct cmd_find_window_data {
int
cmd_find_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct cmd_find_window_data *cdata;
struct session *s;
struct winlink *wl, *wm;
@ -58,7 +57,7 @@ cmd_find_window_exec(struct cmd *self, struct cmd_ctx *ctx)
struct window_pane *wp;
ARRAY_DECL(, u_int) list_idx;
ARRAY_DECL(, char *) list_ctx;
char *sres, *sctx, *searchstr;
char *str, *sres, *sctx, *searchstr;
u_int i, line;
if (ctx->curclient == NULL) {
@ -67,13 +66,15 @@ cmd_find_window_exec(struct cmd *self, struct cmd_ctx *ctx)
}
s = ctx->curclient->session;
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
return (-1);
str = args->argv[0];
ARRAY_INIT(&list_idx);
ARRAY_INIT(&list_ctx);
xasprintf(&searchstr, "*%s*", data->arg);
xasprintf(&searchstr, "*%s*", str);
RB_FOREACH(wm, winlinks, &s->windows) {
i = 0;
TAILQ_FOREACH(wp, &wm->window->panes, entry) {
@ -82,7 +83,7 @@ cmd_find_window_exec(struct cmd *self, struct cmd_ctx *ctx)
if (fnmatch(searchstr, wm->window->name, 0) == 0)
sctx = xstrdup("");
else {
sres = window_pane_search(wp, data->arg, &line);
sres = window_pane_search(wp, str, &line);
if (sres == NULL &&
fnmatch(searchstr, wp->base.title, 0) != 0)
continue;
@ -106,7 +107,7 @@ cmd_find_window_exec(struct cmd *self, struct cmd_ctx *ctx)
xfree(searchstr);
if (ARRAY_LENGTH(&list_idx) == 0) {
ctx->error(ctx, "no windows matching: %s", data->arg);
ctx->error(ctx, "no windows matching: %s", str);
ARRAY_FREE(&list_idx);
ARRAY_FREE(&list_ctx);
return (-1);

414
cmd-generic.c
View File

@ -1,414 +0,0 @@
/* $Id: cmd-generic.c,v 1.39 2010-12-30 22:39:49 tcunha Exp $ */
/*
* Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
*
* 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 <stdlib.h>
#include <string.h>
#include "tmux.h"
int cmd_getopt(int, char **, const char *, const char *);
int cmd_parse_flags(int, const char *, uint64_t *);
size_t cmd_print_flags(char *, size_t, size_t, uint64_t);
int cmd_fill_argument(int, char **, char **, int, char **);
size_t
cmd_prarg(char *buf, size_t len, const char *prefix, char *arg)
{
if (strchr(arg, ' ') != NULL)
return (xsnprintf(buf, len, "%s\"%s\"", prefix, arg));
return (xsnprintf(buf, len, "%s%s", prefix, arg));
}
/* Append two flag strings together and call getopt. */
int
cmd_getopt(int argc, char **argv, const char *flagstr, const char *chflagstr)
{
char tmp[BUFSIZ];
if (strlcpy(tmp, flagstr, sizeof tmp) >= sizeof tmp)
fatalx("strlcpy overflow");
if (strlcat(tmp, chflagstr, sizeof tmp) >= sizeof tmp)
fatalx("strlcat overflow");
return (getopt(argc, argv, tmp));
}
/* Return if flag character is set. */
int
cmd_check_flag(uint64_t chflags, int flag)
{
if (flag >= 'A' && flag <= 'Z')
flag = 26 + flag - 'A';
else if (flag >= 'a' && flag <= 'z')
flag = flag - 'a';
else
return (0);
return ((chflags & (1ULL << flag)) != 0);
}
/* Set flag character. */
void
cmd_set_flag(uint64_t *chflags, int flag)
{
if (flag >= 'A' && flag <= 'Z')
flag = 26 + flag - 'A';
else if (flag >= 'a' && flag <= 'z')
flag = flag - 'a';
else
return;
(*chflags) |= (1ULL << flag);
}
/* If this option is expected, set it in chflags, otherwise return -1. */
int
cmd_parse_flags(int opt, const char *chflagstr, uint64_t *chflags)
{
if (strchr(chflagstr, opt) == NULL)
return (-1);
cmd_set_flag(chflags, opt);
return (0);
}
/* Print the flags present 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 (chflags == 0)
return (0);
off += xsnprintf(buf + off, len - off, " -");
for (ch = 0; ch < 26; ch++) {
if (cmd_check_flag(chflags, 'a' + ch))
off += xsnprintf(buf + off, len - off, "%c", 'a' + ch);
if (cmd_check_flag(chflags, 'A' + ch))
off += xsnprintf(buf + off, len - off, "%c", 'A' + ch);
}
return (off - boff);
}
int
cmd_fill_argument(int flags, char **arg, char **arg2, int argc, char **argv)
{
*arg = NULL;
*arg2 = NULL;
if (flags & CMD_ARG1) {
if (argc != 1)
return (-1);
*arg = xstrdup(argv[0]);
return (0);
}
if (flags & CMD_ARG01) {
if (argc != 0 && argc != 1)
return (-1);
if (argc == 1)
*arg = xstrdup(argv[0]);
return (0);
}
if (flags & CMD_ARG2) {
if (argc != 2)
return (-1);
*arg = xstrdup(argv[0]);
*arg2 = xstrdup(argv[1]);
return (0);
}
if (flags & CMD_ARG12) {
if (argc != 1 && argc != 2)
return (-1);
*arg = xstrdup(argv[0]);
if (argc == 2)
*arg2 = xstrdup(argv[1]);
return (0);
}
if (argc != 0)
return (-1);
return (0);
}
/* ARGSUSED */
void
cmd_target_init(struct cmd *self, unused int key)
{
struct cmd_target_data *data;
self->data = data = xmalloc(sizeof *data);
data->chflags = 0;
data->target = NULL;
data->arg = NULL;
data->arg2 = NULL;
}
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 = cmd_getopt(argc, argv, "t:", entry->chflags)) != -1) {
if (cmd_parse_flags(opt, entry->chflags, &data->chflags) == 0)
continue;
switch (opt) {
case 't':
if (data->target == NULL)
data->target = xstrdup(optarg);
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (cmd_fill_argument(
self->entry->flags, &data->arg, &data->arg2, argc, argv) != 0)
goto usage;
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
self->entry->free(self);
return (-1);
}
void
cmd_target_free(struct cmd *self)
{
struct cmd_target_data *data = self->data;
if (data->target != NULL)
xfree(data->target);
if (data->arg != NULL)
xfree(data->arg);
if (data->arg2 != NULL)
xfree(data->arg2);
xfree(data);
}
size_t
cmd_target_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_target_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
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)
off += cmd_prarg(buf + off, len - off, " ", data->arg);
if (off < len && data->arg2 != NULL)
off += cmd_prarg(buf + off, len - off, " ", data->arg2);
return (off);
}
/* ARGSUSED */
void
cmd_srcdst_init(struct cmd *self, unused int key)
{
struct cmd_srcdst_data *data;
self->data = data = xmalloc(sizeof *data);
data->chflags = 0;
data->src = NULL;
data->dst = NULL;
data->arg = NULL;
data->arg2 = NULL;
}
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 = cmd_getopt(argc, argv, "s:t:", entry->chflags)) != -1) {
if (cmd_parse_flags(opt, entry->chflags, &data->chflags) == 0)
continue;
switch (opt) {
case 's':
if (data->src == NULL)
data->src = xstrdup(optarg);
break;
case 't':
if (data->dst == NULL)
data->dst = xstrdup(optarg);
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (cmd_fill_argument(
self->entry->flags, &data->arg, &data->arg2, argc, argv) != 0)
goto usage;
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
self->entry->free(self);
return (-1);
}
void
cmd_srcdst_free(struct cmd *self)
{
struct cmd_srcdst_data *data = self->data;
if (data->src != NULL)
xfree(data->src);
if (data->dst != NULL)
xfree(data->dst);
if (data->arg != NULL)
xfree(data->arg);
if (data->arg2 != NULL)
xfree(data->arg2);
xfree(data);
}
size_t
cmd_srcdst_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_srcdst_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
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)
off += xsnprintf(buf + off, len - off, " -t %s", data->dst);
if (off < len && data->arg != NULL)
off += cmd_prarg(buf + off, len - off, " ", data->arg);
if (off < len && data->arg2 != NULL)
off += cmd_prarg(buf + off, len - off, " ", data->arg2);
return (off);
}
/* ARGSUSED */
void
cmd_buffer_init(struct cmd *self, unused int key)
{
struct cmd_buffer_data *data;
self->data = data = xmalloc(sizeof *data);
data->chflags = 0;
data->buffer = -1;
data->arg = NULL;
data->arg2 = NULL;
}
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 = cmd_getopt(argc, argv, "b:", entry->chflags)) != -1) {
if (cmd_parse_flags(opt, entry->chflags, &data->chflags) == 0)
continue;
switch (opt) {
case 'b':
if (data->buffer == -1) {
n = strtonum(optarg, 0, INT_MAX, &errstr);
if (errstr != NULL) {
xasprintf(cause, "buffer %s", errstr);
goto error;
}
data->buffer = n;
}
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (cmd_fill_argument(
self->entry->flags, &data->arg, &data->arg2, argc, argv) != 0)
goto usage;
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
error:
self->entry->free(self);
return (-1);
}
void
cmd_buffer_free(struct cmd *self)
{
struct cmd_buffer_data *data = self->data;
if (data->arg != NULL)
xfree(data->arg);
if (data->arg2 != NULL)
xfree(data->arg2);
xfree(data);
}
size_t
cmd_buffer_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_buffer_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
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->arg != NULL)
off += cmd_prarg(buf + off, len - off, " ", data->arg);
if (off < len && data->arg2 != NULL)
off += cmd_prarg(buf + off, len - off, " ", data->arg2);
return (off);
}

17
cmd-has-session.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-has-session.c,v 1.15 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-has-session.c,v 1.16 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,21 +28,20 @@ int cmd_has_session_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_has_session_entry = {
"has-session", "has",
"t:", 0, 0,
CMD_TARGET_SESSION_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_has_session_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_has_session_exec
};
int
cmd_has_session_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
if (cmd_find_session(ctx, data->target) == NULL)
if (cmd_find_session(ctx, args_get(args, 't')) == NULL)
return (-1);
return (0);

19
cmd-if-shell.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-if-shell.c,v 1.10 2010-08-09 21:44:25 tcunha Exp $ */
/* $Id: cmd-if-shell.c,v 1.11 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@ -35,13 +35,12 @@ void cmd_if_shell_free(void *);
const struct cmd_entry cmd_if_shell_entry = {
"if-shell", "if",
"", 2, 2,
"shell-command command",
CMD_ARG2, "",
cmd_target_init,
cmd_target_parse,
cmd_if_shell_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_if_shell_exec
};
struct cmd_if_shell_data {
@ -52,12 +51,12 @@ struct cmd_if_shell_data {
int
cmd_if_shell_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct cmd_if_shell_data *cdata;
struct job *job;
cdata = xmalloc(sizeof *cdata);
cdata->cmd = xstrdup(data->arg2);
cdata->cmd = xstrdup(args->argv[1]);
memcpy(&cdata->ctx, ctx, sizeof cdata->ctx);
if (ctx->cmdclient != NULL)
@ -66,7 +65,7 @@ cmd_if_shell_exec(struct cmd *self, struct cmd_ctx *ctx)
ctx->curclient->references++;
job = job_add(NULL, 0, NULL,
data->arg, cmd_if_shell_callback, cmd_if_shell_free, cdata);
args->argv[0], cmd_if_shell_callback, cmd_if_shell_free, cdata);
job_run(job);
return (1); /* don't let client exit */

198
cmd-join-pane.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-join-pane.c,v 1.5 2010-08-11 22:17:32 tcunha Exp $ */
/* $Id: cmd-join-pane.c,v 1.6 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -27,139 +27,54 @@
* Join a pane into another (like split/swap/kill).
*/
int cmd_join_pane_parse(struct cmd *, int, char **, char **);
void cmd_join_pane_key_binding(struct cmd *, int);
int cmd_join_pane_exec(struct cmd *, struct cmd_ctx *);
void cmd_join_pane_free(struct cmd *);
void cmd_join_pane_init(struct cmd *, int);
size_t cmd_join_pane_print(struct cmd *, char *, size_t);
struct cmd_join_pane_data {
char *src;
char *dst;
int flag_detached;
int flag_horizontal;
int percentage;
int size;
};
const struct cmd_entry cmd_join_pane_entry = {
"join-pane", "joinp",
"dhvp:l:s:t:", 0, 0,
"[-dhv] [-p percentage|-l size] [-s src-pane] [-t dst-pane]",
0, "",
cmd_join_pane_init,
cmd_join_pane_parse,
cmd_join_pane_exec,
cmd_join_pane_free,
cmd_join_pane_print
0,
cmd_join_pane_key_binding,
NULL,
cmd_join_pane_exec
};
void
cmd_join_pane_init(struct cmd *self, int key)
cmd_join_pane_key_binding(struct cmd *self, int key)
{
struct cmd_join_pane_data *data;
self->data = data = xmalloc(sizeof *data);
data->src = NULL;
data->dst = NULL;
data->flag_detached = 0;
data->flag_horizontal = 0;
data->percentage = -1;
data->size = -1;
switch (key) {
case '%':
data->flag_horizontal = 1;
self->args = args_create(0);
args_set(self->args, 'h', NULL);
break;
case '"':
data->flag_horizontal = 0;
default:
self->args = args_create(0);
break;
}
}
int
cmd_join_pane_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_join_pane_data *data;
int opt;
const char *errstr;
self->entry->init(self, KEYC_NONE);
data = self->data;
while ((opt = getopt(argc, argv, "dhl:p:s:t:v")) != -1) {
switch (opt) {
case 'd':
data->flag_detached = 1;
break;
case 'h':
data->flag_horizontal = 1;
break;
case 's':
if (data->src == NULL)
data->src = xstrdup(optarg);
break;
case 't':
if (data->dst == NULL)
data->dst = xstrdup(optarg);
break;
case 'l':
if (data->percentage != -1 || data->size != -1)
break;
data->size = strtonum(optarg, 1, INT_MAX, &errstr);
if (errstr != NULL) {
xasprintf(cause, "size %s", errstr);
goto error;
}
break;
case 'p':
if (data->size != -1 || data->percentage != -1)
break;
data->percentage = strtonum(optarg, 1, 100, &errstr);
if (errstr != NULL) {
xasprintf(cause, "percentage %s", errstr);
goto error;
}
break;
case 'v':
data->flag_horizontal = 0;
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (argc != 0)
goto usage;
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
error:
self->entry->free(self);
return (-1);
}
int
cmd_join_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_join_pane_data *data = self->data;
struct session *dst_s;
struct winlink *src_wl, *dst_wl;
struct window *src_w, *dst_w;
struct window_pane *src_wp, *dst_wp;
int size, dst_idx;
enum layout_type type;
struct layout_cell *lc;
struct args *args = self->args;
struct session *dst_s;
struct winlink *src_wl, *dst_wl;
struct window *src_w, *dst_w;
struct window_pane *src_wp, *dst_wp;
char *cause;
int size, percentage, dst_idx;
enum layout_type type;
struct layout_cell *lc;
if ((dst_wl = cmd_find_pane(ctx, data->dst, &dst_s, &dst_wp)) == NULL)
dst_wl = cmd_find_pane(ctx, args_get(args, 't'), &dst_s, &dst_wp);
if (dst_wl == NULL)
return (-1);
dst_w = dst_wl->window;
dst_idx = dst_wl->idx;
if ((src_wl = cmd_find_pane(ctx, data->src, NULL, &src_wp)) == NULL)
src_wl = cmd_find_pane(ctx, args_get(args, 's'), NULL, &src_wp);
if (src_wl == NULL)
return (-1);
src_w = src_wl->window;
@ -169,17 +84,28 @@ cmd_join_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
}
type = LAYOUT_TOPBOTTOM;
if (data->flag_horizontal)
if (args_has(args, 'h'))
type = LAYOUT_LEFTRIGHT;
size = -1;
if (data->size != -1)
size = data->size;
else if (data->percentage != -1) {
if (args_has(args, 's')) {
size = args_strtonum(args, 's', 0, INT_MAX, &cause);
if (cause != NULL) {
ctx->error(ctx, "size %s", cause);
xfree(cause);
return (-1);
}
} else if (args_has(args, 'p')) {
percentage = args_strtonum(args, 'p', 0, INT_MAX, &cause);
if (cause != NULL) {
ctx->error(ctx, "percentage %s", cause);
xfree(cause);
return (-1);
}
if (type == LAYOUT_TOPBOTTOM)
size = (dst_wp->sy * data->percentage) / 100;
size = (dst_wp->sy * percentage) / 100;
else
size = (dst_wp->sx * data->percentage) / 100;
size = (dst_wp->sx * percentage) / 100;
}
if ((lc = layout_split_pane(dst_wp, type, size)) == NULL) {
@ -208,7 +134,7 @@ cmd_join_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
server_redraw_window(src_w);
server_redraw_window(dst_w);
if (!data->flag_detached) {
if (!args_has(args, 'd')) {
window_set_active_pane(dst_w, src_wp);
session_select(dst_s, dst_idx);
server_redraw_session(dst_s);
@ -217,41 +143,3 @@ cmd_join_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
return (0);
}
void
cmd_join_pane_free(struct cmd *self)
{
struct cmd_join_pane_data *data = self->data;
if (data->src != NULL)
xfree(data->src);
if (data->dst != NULL)
xfree(data->dst);
xfree(data);
}
size_t
cmd_join_pane_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_join_pane_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
if (off < len && data->flag_detached)
off += xsnprintf(buf + off, len - off, " -d");
if (off < len && data->flag_horizontal)
off += xsnprintf(buf + off, len - off, " -h");
if (off < len && data->size > 0)
off += xsnprintf(buf + off, len - off, " -l %d", data->size);
if (off < len && data->percentage > 0) {
off += xsnprintf(
buf + off, len - off, " -p %d", data->percentage);
}
if (off < len && data->src != NULL)
off += cmd_prarg(buf + off, len - off, " -s ", data->src);
if (off < len && data->dst != NULL)
off += cmd_prarg(buf + off, len - off, " -t ", data->dst);
return (off);
}

19
cmd-kill-pane.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-kill-pane.c,v 1.15 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-kill-pane.c,v 1.16 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,23 +30,22 @@ int cmd_kill_pane_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_kill_pane_entry = {
"kill-pane", "killp",
"at:", 0, 0,
"[-a] " CMD_TARGET_PANE_USAGE,
0, "a",
cmd_target_init,
cmd_target_parse,
cmd_kill_pane_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_kill_pane_exec
};
int
cmd_kill_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct winlink *wl;
struct window_pane *loopwp, *nextwp, *wp;
if ((wl = cmd_find_pane(ctx, data->target, NULL, &wp)) == NULL)
if ((wl = cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp)) == NULL)
return (-1);
if (window_count_panes(wl->window) == 1) {
@ -56,7 +55,7 @@ cmd_kill_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
return (0);
}
if (cmd_check_flag(data->chflags, 'a')) {
if (args_has(self->args, 'a')) {
loopwp = TAILQ_FIRST(&wl->window->panes);
while (loopwp != NULL) {
nextwp = TAILQ_NEXT(loopwp, entry);

9
cmd-kill-server.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-kill-server.c,v 1.11 2009-11-28 14:50:36 tcunha Exp $ */
/* $Id: cmd-kill-server.c,v 1.12 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -31,13 +31,12 @@ int cmd_kill_server_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_kill_server_entry = {
"kill-server", NULL,
"", 0, 0,
"",
0, "",
0,
NULL,
NULL,
cmd_kill_server_exec,
NULL,
NULL
cmd_kill_server_exec
};
/* ARGSUSED */

19
cmd-kill-session.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-kill-session.c,v 1.18 2010-07-02 02:43:50 tcunha Exp $ */
/* $Id: cmd-kill-session.c,v 1.19 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -31,22 +31,21 @@ int cmd_kill_session_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_kill_session_entry = {
"kill-session", NULL,
"t:", 0, 0,
CMD_TARGET_SESSION_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_kill_session_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_kill_session_exec
};
int
cmd_kill_session_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct session *s;
struct args *args = self->args;
struct session *s;
if ((s = cmd_find_session(ctx, data->target)) == NULL)
if ((s = cmd_find_session(ctx, args_get(args, 't'))) == NULL)
return (-1);
server_destroy_session(s);

19
cmd-kill-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-kill-window.c,v 1.21 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-kill-window.c,v 1.22 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,22 +28,21 @@ int cmd_kill_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_kill_window_entry = {
"kill-window", "killw",
"t:", 0, 0,
CMD_TARGET_WINDOW_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_kill_window_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_kill_window_exec
};
int
cmd_kill_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct winlink *wl;
struct args *args = self->args;
struct winlink *wl;
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
return (-1);
server_kill_window(wl->window);

21
cmd-last-pane.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-last-pane.c,v 1.1 2010-10-24 01:34:30 tcunha Exp $ */
/* $Id: cmd-last-pane.c,v 1.2 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2010 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,23 +28,22 @@ int cmd_last_pane_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_last_pane_entry = {
"last-pane", "lastp",
"t:", 0, 0,
CMD_TARGET_WINDOW_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_last_pane_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_last_pane_exec
};
int
cmd_last_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct winlink *wl;
struct window *w;
struct args *args = self->args;
struct winlink *wl;
struct window *w;
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
return (-1);
w = wl->window;

19
cmd-last-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-last-window.c,v 1.19 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-last-window.c,v 1.20 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,22 +28,21 @@ int cmd_last_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_last_window_entry = {
"last-window", "last",
"t:", 0, 0,
CMD_TARGET_SESSION_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_last_window_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_last_window_exec
};
int
cmd_last_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct session *s;
struct args *args = self->args;
struct session *s;
if ((s = cmd_find_session(ctx, data->target)) == NULL)
if ((s = cmd_find_session(ctx, args_get(args, 't'))) == NULL)
return (-1);
if (session_last(s) == 0)

31
cmd-link-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-link-window.c,v 1.36 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-link-window.c,v 1.37 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,31 +30,30 @@ int cmd_link_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_link_window_entry = {
"link-window", "linkw",
"dks:t:", 0, 0,
"[-dk] " CMD_SRCDST_WINDOW_USAGE,
0, "dk",
cmd_srcdst_init,
cmd_srcdst_parse,
cmd_link_window_exec,
cmd_srcdst_free,
cmd_srcdst_print
0,
NULL,
NULL,
cmd_link_window_exec
};
int
cmd_link_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_srcdst_data *data = self->data;
struct session *src, *dst;
struct winlink *wl;
char *cause;
int idx, kflag, dflag;
struct args *args = self->args;
struct session *src, *dst;
struct winlink *wl;
char *cause;
int idx, kflag, dflag;
if ((wl = cmd_find_window(ctx, data->src, &src)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 's'), &src)) == NULL)
return (-1);
if ((idx = cmd_find_index(ctx, data->dst, &dst)) == -2)
if ((idx = cmd_find_index(ctx, args_get(args, 't'), &dst)) == -2)
return (-1);
kflag = cmd_check_flag(data->chflags, 'k');
dflag = cmd_check_flag(data->chflags, 'd');
kflag = args_has(self->args, 'k');
dflag = args_has(self->args, 'd');
if (server_link_window(src, wl, dst, idx, kflag, !dflag, &cause) != 0) {
ctx->error(ctx, "can't link window: %s", cause);
xfree(cause);

9
cmd-list-buffers.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-list-buffers.c,v 1.17 2010-12-30 22:39:49 tcunha Exp $ */
/* $Id: cmd-list-buffers.c,v 1.18 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,13 +30,12 @@ int cmd_list_buffers_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_list_buffers_entry = {
"list-buffers", "lsb",
"", 0, 0,
"",
0, "",
0,
NULL,
NULL,
cmd_list_buffers_exec,
NULL,
NULL
cmd_list_buffers_exec
};
/* ARGSUSED */

9
cmd-list-clients.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-list-clients.c,v 1.20 2009-11-28 14:50:36 tcunha Exp $ */
/* $Id: cmd-list-clients.c,v 1.21 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -31,13 +31,12 @@ int cmd_list_clients_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_list_clients_entry = {
"list-clients", "lsc",
"", 0, 0,
"",
0, "",
0,
NULL,
NULL,
cmd_list_clients_exec,
NULL,
NULL
cmd_list_clients_exec
};
/* ARGSUSED */

9
cmd-list-commands.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-list-commands.c,v 1.7 2009-11-28 14:50:36 tcunha Exp $ */
/* $Id: cmd-list-commands.c,v 1.8 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,13 +28,12 @@ int cmd_list_commands_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_list_commands_entry = {
"list-commands", "lscm",
"", 0, 0,
"",
0, "",
0,
NULL,
NULL,
cmd_list_commands_exec,
NULL,
NULL
cmd_list_commands_exec
};
/* ARGSUSED */

25
cmd-list-keys.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-list-keys.c,v 1.25 2010-10-24 01:31:57 tcunha Exp $ */
/* $Id: cmd-list-keys.c,v 1.26 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -32,26 +32,25 @@ int cmd_list_keys_table(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_list_keys_entry = {
"list-keys", "lsk",
"t:", 0, 0,
"[-t key-table]",
0, "",
cmd_target_init,
cmd_target_parse,
cmd_list_keys_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_list_keys_exec
};
int
cmd_list_keys_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct key_binding *bd;
const char *key;
char tmp[BUFSIZ];
size_t used;
int width, keywidth;
if (data->target != NULL)
if (args_has(args, 't'))
return (cmd_list_keys_table(self, ctx));
width = 0;
@ -95,14 +94,16 @@ cmd_list_keys_exec(struct cmd *self, struct cmd_ctx *ctx)
int
cmd_list_keys_table(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
const char *tablename;
const struct mode_key_table *mtab;
struct mode_key_binding *mbind;
const char *key, *cmdstr, *mode;
int width, keywidth;
if ((mtab = mode_key_findtable(data->target)) == NULL) {
ctx->error(ctx, "unknown key table: %s", data->target);
tablename = args_get(args, 't');
if ((mtab = mode_key_findtable(tablename)) == NULL) {
ctx->error(ctx, "unknown key table: %s", tablename);
return (-1);
}

17
cmd-list-panes.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-list-panes.c,v 1.6 2010-12-06 21:56:32 nicm Exp $ */
/* $Id: cmd-list-panes.c,v 1.7 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,19 +30,18 @@ int cmd_list_panes_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_list_panes_entry = {
"list-panes", "lsp",
"t:", 0, 0,
CMD_TARGET_WINDOW_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_list_panes_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_list_panes_exec
};
int
cmd_list_panes_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct winlink *wl;
struct window_pane *wp;
struct grid *gd;
@ -50,7 +49,7 @@ cmd_list_panes_exec(struct cmd *self, struct cmd_ctx *ctx)
u_int i, n;
unsigned long long size;
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
return (-1);
n = 0;

12
cmd-list-sessions.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-list-sessions.c,v 1.26 2010-12-22 15:36:44 tcunha Exp $ */
/* $Id: cmd-list-sessions.c,v 1.27 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,13 +30,13 @@
int cmd_list_sessions_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_list_sessions_entry = {
"list-sessions", "ls", "",
0, "",
"list-sessions", "ls",
"", 0, 0,
"",
0,
NULL,
NULL,
cmd_list_sessions_exec,
NULL,
NULL
cmd_list_sessions_exec
};
/* ARGSUSED */

23
cmd-list-windows.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-list-windows.c,v 1.44 2010-12-06 21:56:32 nicm Exp $ */
/* $Id: cmd-list-windows.c,v 1.45 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,24 +30,23 @@ int cmd_list_windows_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_list_windows_entry = {
"list-windows", "lsw",
"t:", 0, 0,
CMD_TARGET_SESSION_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_list_windows_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_list_windows_exec
};
int
cmd_list_windows_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct session *s;
struct winlink *wl;
char *layout;
struct args *args = self->args;
struct session *s;
struct winlink *wl;
char *layout;
if ((s = cmd_find_session(ctx, data->target)) == NULL)
if ((s = cmd_find_session(ctx, args_get(args, 't'))) == NULL)
return (-1);
RB_FOREACH(wl, winlinks, &s->windows) {

78
cmd-load-buffer.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-load-buffer.c,v 1.19 2010-12-30 22:39:49 tcunha Exp $ */
/* $Id: cmd-load-buffer.c,v 1.20 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@ -35,41 +35,57 @@ void cmd_load_buffer_callback(struct client *, void *);
const struct cmd_entry cmd_load_buffer_entry = {
"load-buffer", "loadb",
"b:", 1, 1,
CMD_BUFFER_USAGE " path",
CMD_ARG1, "",
cmd_buffer_init,
cmd_buffer_parse,
cmd_load_buffer_exec,
cmd_buffer_free,
cmd_buffer_print
0,
NULL,
NULL,
cmd_load_buffer_exec
};
int
cmd_load_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_buffer_data *data = self->data;
struct client *c = ctx->cmdclient;
FILE *f;
char *pdata, *new_pdata;
size_t psize;
u_int limit;
int ch;
struct args *args = self->args;
struct client *c = ctx->cmdclient;
FILE *f;
const char *path;
char *pdata, *new_pdata, *cause;
size_t psize;
u_int limit;
int ch, buffer;
int *buffer_ptr;
if (strcmp(data->arg, "-") == 0) {
if (!args_has(args, 'b'))
buffer = -1;
else {
buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
if (cause != NULL) {
ctx->error(ctx, "buffer %s", cause);
xfree(cause);
return (-1);
}
}
path = args->argv[0];
if (strcmp(path, "-") == 0) {
if (c == NULL) {
ctx->error(ctx, "%s: can't read from stdin", data->arg);
ctx->error(ctx, "%s: can't read from stdin", path);
return (-1);
}
if (c->flags & CLIENT_TERMINAL) {
ctx->error(ctx, "%s: stdin is a tty", data->arg);
ctx->error(ctx, "%s: stdin is a tty", path);
return (-1);
}
if (c->stdin_fd == -1) {
ctx->error(ctx, "%s: can't read from stdin", data->arg);
ctx->error(ctx, "%s: can't read from stdin", path);
return (-1);
}
c->stdin_data = &data->buffer;
buffer_ptr = xmalloc(sizeof *buffer_ptr);
*buffer_ptr = buffer;
c->stdin_data = buffer_ptr;
c->stdin_callback = cmd_load_buffer_callback;
c->references++;
@ -77,8 +93,8 @@ cmd_load_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
return (1);
}
if ((f = fopen(data->arg, "rb")) == NULL) {
ctx->error(ctx, "%s: %s", data->arg, strerror(errno));
if ((f = fopen(path, "rb")) == NULL) {
ctx->error(ctx, "%s: %s", path, strerror(errno));
return (-1);
}
@ -94,7 +110,7 @@ cmd_load_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
pdata[psize++] = ch;
}
if (ferror(f)) {
ctx->error(ctx, "%s: read error", data->arg);
ctx->error(ctx, "%s: read error", path);
goto error;
}
if (pdata != NULL)
@ -103,12 +119,12 @@ cmd_load_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
fclose(f);
limit = options_get_number(&global_options, "buffer-limit");
if (data->buffer == -1) {
if (buffer == -1) {
paste_add(&global_buffers, pdata, psize, limit);
return (0);
}
if (paste_replace(&global_buffers, data->buffer, pdata, psize) != 0) {
ctx->error(ctx, "no buffer %d", data->buffer);
if (paste_replace(&global_buffers, buffer, pdata, psize) != 0) {
ctx->error(ctx, "no buffer %d", buffer);
return (-1);
}
@ -125,10 +141,10 @@ error:
void
cmd_load_buffer_callback(struct client *c, void *data)
{
int *buffer = data;
char *pdata;
size_t psize;
u_int limit;
int *buffer = data;
/*
* Event callback has already checked client is not dead and reduced
@ -137,12 +153,10 @@ cmd_load_buffer_callback(struct client *c, void *data)
c->flags |= CLIENT_EXIT;
psize = EVBUFFER_LENGTH(c->stdin_event->input);
if (psize == 0)
return;
pdata = malloc(psize + 1);
if (pdata == NULL)
if (psize == 0 || (pdata = malloc(psize + 1)) == NULL) {
free(data);
return;
}
bufferevent_read(c->stdin_event, pdata, psize);
pdata[psize] = '\0';
@ -155,4 +169,6 @@ cmd_load_buffer_callback(struct client *c, void *data)
c->stderr_event->output, "no buffer %d\n", *buffer);
bufferevent_enable(c->stderr_event, EV_WRITE);
}
free (data);
}

19
cmd-lock-client.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-lock-client.c,v 1.2 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-lock-client.c,v 1.3 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,22 +28,21 @@ int cmd_lock_client_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_lock_client_entry = {
"lock-client", "lockc",
"t:", 0, 0,
CMD_TARGET_CLIENT_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_lock_client_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_lock_client_exec
};
int
cmd_lock_client_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct client *c;
struct args *args = self->args;
struct client *c;
if ((c = cmd_find_client(ctx, data->target)) == NULL)
if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
return (-1);
server_lock_client(c);

9
cmd-lock-server.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-lock-server.c,v 1.9 2009-11-28 14:50:36 tcunha Exp $ */
/* $Id: cmd-lock-server.c,v 1.10 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@ -32,13 +32,12 @@ 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,
0,
NULL,
NULL,
cmd_lock_server_exec
};
/* ARGSUSED */

19
cmd-lock-session.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-lock-session.c,v 1.2 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-lock-session.c,v 1.3 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,22 +28,21 @@ int cmd_lock_session_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_lock_session_entry = {
"lock-session", "locks",
"t:", 0, 0,
CMD_TARGET_SESSION_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_lock_session_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_lock_session_exec
};
int
cmd_lock_session_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct session *s;
struct args *args = self->args;
struct session *s;
if ((s = cmd_find_session(ctx, data->target)) == NULL)
if ((s = cmd_find_session(ctx, args_get(args, 't'))) == NULL)
return (-1);
server_lock_session(s);

31
cmd-move-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-move-window.c,v 1.13 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-move-window.c,v 1.14 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,31 +30,30 @@ int cmd_move_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_move_window_entry = {
"move-window", "movew",
"dks:t:", 0, 0,
"[-dk] " CMD_SRCDST_WINDOW_USAGE,
0, "dk",
cmd_srcdst_init,
cmd_srcdst_parse,
cmd_move_window_exec,
cmd_srcdst_free,
cmd_srcdst_print
0,
NULL,
NULL,
cmd_move_window_exec
};
int
cmd_move_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_srcdst_data *data = self->data;
struct session *src, *dst;
struct winlink *wl;
char *cause;
int idx, kflag, dflag;
struct args *args = self->args;
struct session *src, *dst;
struct winlink *wl;
char *cause;
int idx, kflag, dflag;
if ((wl = cmd_find_window(ctx, data->src, &src)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 's'), &src)) == NULL)
return (-1);
if ((idx = cmd_find_index(ctx, data->dst, &dst)) == -2)
if ((idx = cmd_find_index(ctx, args_get(args, 't'), &dst)) == -2)
return (-1);
kflag = cmd_check_flag(data->chflags, 'k');
dflag = cmd_check_flag(data->chflags, 'd');
kflag = args_has(self->args, 'k');
dflag = args_has(self->args, 'd');
if (server_link_window(src, wl, dst, idx, kflag, !dflag, &cause) != 0) {
ctx->error(ctx, "can't move window: %s", cause);
xfree(cause);

177
cmd-new-session.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-new-session.c,v 1.81 2011-01-03 23:27:54 tcunha Exp $ */
/* $Id: cmd-new-session.c,v 1.82 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -29,119 +29,55 @@
* Create a new session and attach to the current terminal unless -d is given.
*/
int cmd_new_session_parse(struct cmd *, int, char **, char **);
int cmd_new_session_check(struct args *);
int cmd_new_session_exec(struct cmd *, struct cmd_ctx *);
void cmd_new_session_free(struct cmd *);
void cmd_new_session_init(struct cmd *, int);
size_t cmd_new_session_print(struct cmd *, char *, size_t);
struct cmd_new_session_data {
char *target;
char *newname;
char *winname;
char *cmd;
int flag_detached;
};
const struct cmd_entry cmd_new_session_entry = {
"new-session", "new",
"dn:s:t:", 0, 1,
"[-d] [-n window-name] [-s session-name] [-t target-session] [command]",
CMD_STARTSERVER|CMD_CANTNEST|CMD_SENDENVIRON, "",
cmd_new_session_init,
cmd_new_session_parse,
cmd_new_session_exec,
cmd_new_session_free,
cmd_new_session_print
CMD_STARTSERVER|CMD_CANTNEST|CMD_SENDENVIRON,
NULL,
cmd_new_session_check,
cmd_new_session_exec
};
/* ARGSUSED */
void
cmd_new_session_init(struct cmd *self, unused int arg)
{
struct cmd_new_session_data *data;
self->data = data = xmalloc(sizeof *data);
data->flag_detached = 0;
data->target = NULL;
data->newname = NULL;
data->winname = NULL;
data->cmd = NULL;
}
int
cmd_new_session_parse(struct cmd *self, int argc, char **argv, char **cause)
cmd_new_session_check(struct args *args)
{
struct cmd_new_session_data *data;
int opt;
self->entry->init(self, KEYC_NONE);
data = self->data;
while ((opt = getopt(argc, argv, "ds:t:n:")) != -1) {
switch (opt) {
case 'd':
data->flag_detached = 1;
break;
case 's':
if (data->newname == NULL)
data->newname = xstrdup(optarg);
break;
case 't':
if (data->target == NULL)
data->target = xstrdup(optarg);
break;
case 'n':
if (data->winname == NULL)
data->winname = xstrdup(optarg);
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (argc != 0 && argc != 1)
goto usage;
if (data->target != NULL && (argc == 1 || data->winname != NULL))
goto usage;
if (argc == 1)
data->cmd = xstrdup(argv[0]);
if (args_has(args, 't') && (args->argc != 0 || args_has(args, 'n')))
return (-1);
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
self->entry->free(self);
return (-1);
}
int
cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_new_session_data *data = self->data;
struct session *s, *old_s, *groupwith;
struct window *w;
struct window_pane *wp;
struct environ env;
struct termios tio, *tiop;
struct passwd *pw;
const char *update, *cwd;
char *overrides, *cmd, *cause;
int detached, idx;
u_int sx, sy, i;
struct args *args = self->args;
struct session *s, *old_s, *groupwith;
struct window *w;
struct window_pane *wp;
struct environ env;
struct termios tio, *tiop;
struct passwd *pw;
const char *newname, *target, *update, *cwd;
char *overrides, *cmd, *cause;
int detached, idx;
u_int sx, sy, i;
if (data->newname != NULL && session_find(data->newname) != NULL) {
ctx->error(ctx, "duplicate session: %s", data->newname);
newname = args_get(args, 's');
if (newname != NULL && session_find(newname) != NULL) {
ctx->error(ctx, "duplicate session: %s", newname);
return (-1);
}
groupwith = NULL;
if (data->target != NULL &&
(groupwith = cmd_find_session(ctx, data->target)) == NULL)
return (-1);
target = args_get(args, 't');
if (target != NULL) {
groupwith = cmd_find_session(ctx, target);
if (groupwith == NULL)
return (-1);
} else
groupwith = NULL;
/*
* There are three cases:
@ -162,7 +98,7 @@ cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
*/
/* Set -d if no client. */
detached = data->flag_detached;
detached = args_has(args, 'd');
if (ctx->cmdclient == NULL && ctx->curclient == NULL)
detached = 1;
@ -228,10 +164,10 @@ cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
sy = 1;
/* Figure out the command for the new window. */
if (data->target != NULL)
if (target != NULL)
cmd = NULL;
else if (data->cmd != NULL)
cmd = data->cmd;
else if (args->argc != 0)
cmd = args->argv[0];
else
cmd = options_get_string(&global_s_options, "default-command");
@ -243,8 +179,7 @@ cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
/* Create the new session. */
idx = -1 - options_get_number(&global_s_options, "base-index");
s = session_create(
data->newname, cmd, cwd, &env, tiop, idx, sx, sy, &cause);
s = session_create(newname, cmd, cwd, &env, tiop, idx, sx, sy, &cause);
if (s == NULL) {
ctx->error(ctx, "create session failed: %s", cause);
xfree(cause);
@ -253,11 +188,11 @@ cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
environ_free(&env);
/* Set the initial window name if one given. */
if (cmd != NULL && data->winname != NULL) {
if (cmd != NULL && args_has(args, 'n')) {
w = s->curw->window;
xfree(w->name);
w->name = xstrdup(data->winname);
w->name = xstrdup(args_get(args, 'n'));
options_set_number(&w->options, "automatic-rename", 0);
}
@ -316,39 +251,3 @@ cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
return (!detached); /* 1 means don't tell command client to exit */
}
void
cmd_new_session_free(struct cmd *self)
{
struct cmd_new_session_data *data = self->data;
if (data->newname != NULL)
xfree(data->newname);
if (data->winname != NULL)
xfree(data->winname);
if (data->cmd != NULL)
xfree(data->cmd);
xfree(data);
}
size_t
cmd_new_session_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_new_session_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
if (off < len && data->flag_detached)
off += xsnprintf(buf + off, len - off, " -d");
if (off < len && data->winname != NULL)
off += cmd_prarg(buf + off, len - off, " -n ", data->winname);
if (off < len && data->newname != NULL)
off += cmd_prarg(buf + off, len - off, " -s ", data->newname);
if (off < len && data->target != NULL)
off += cmd_prarg(buf + off, len - off, " -t ", data->target);
if (off < len && data->cmd != NULL)
off += cmd_prarg(buf + off, len - off, " ", data->cmd);
return (off);
}

169
cmd-new-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-new-window.c,v 1.48 2011-01-03 23:29:09 tcunha Exp $ */
/* $Id: cmd-new-window.c,v 1.49 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -26,115 +26,30 @@
* Create a new window.
*/
int cmd_new_window_parse(struct cmd *, int, char **, char **);
int cmd_new_window_exec(struct cmd *, struct cmd_ctx *);
void cmd_new_window_free(struct cmd *);
void cmd_new_window_init(struct cmd *, int);
size_t cmd_new_window_print(struct cmd *, char *, size_t);
struct cmd_new_window_data {
char *target;
char *name;
char *cmd;
int flag_insert_after;
int flag_detached;
int flag_kill;
int flag_print;
};
const struct cmd_entry cmd_new_window_entry = {
"new-window", "neww",
"[-adkP] [-n window-name] [-t target-window] [command]",
0, "",
cmd_new_window_init,
cmd_new_window_parse,
cmd_new_window_exec,
cmd_new_window_free,
cmd_new_window_print
"adkn:Pt:", 0, 1,
"[-adk] [-n window-name] [-t target-window] [command]",
0,
NULL,
NULL,
cmd_new_window_exec
};
/* ARGSUSED */
void
cmd_new_window_init(struct cmd *self, unused int arg)
{
struct cmd_new_window_data *data;
self->data = data = xmalloc(sizeof *data);
data->target = NULL;
data->name = NULL;
data->cmd = NULL;
data->flag_insert_after = 0;
data->flag_detached = 0;
data->flag_kill = 0;
data->flag_print = 0;
}
int
cmd_new_window_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_new_window_data *data;
int opt;
self->entry->init(self, KEYC_NONE);
data = self->data;
while ((opt = getopt(argc, argv, "adkt:n:P")) != -1) {
switch (opt) {
case 'a':
data->flag_insert_after = 1;
break;
case 'd':
data->flag_detached = 1;
break;
case 'k':
data->flag_kill = 1;
break;
case 't':
if (data->target == NULL)
data->target = xstrdup(optarg);
break;
case 'n':
if (data->name == NULL)
data->name = xstrdup(optarg);
break;
case 'P':
data->flag_print = 1;
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (argc != 0 && argc != 1)
goto usage;
if (argc == 1)
data->cmd = xstrdup(argv[0]);
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
self->entry->free(self);
return (-1);
}
int
cmd_new_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_new_window_data *data = self->data;
struct session *s;
struct winlink *wl;
char *cmd, *cwd, *cause;
int idx, last;
struct args *args = self->args;
struct session *s;
struct winlink *wl;
char *cmd, *cwd, *cause;
int idx, last, detached;
if (data == NULL)
return (0);
if (data->flag_insert_after) {
if ((wl = cmd_find_window(ctx, data->target, &s)) == NULL)
if (args_has(args, 'a')) {
wl = cmd_find_window(ctx, args_get(args, 't'), &s);
if (wl == NULL)
return (-1);
idx = wl->idx + 1;
@ -155,14 +70,15 @@ cmd_new_window_exec(struct cmd *self, struct cmd_ctx *ctx)
server_unlink_window(s, wl);
}
} else {
if ((idx = cmd_find_index(ctx, data->target, &s)) == -2)
if ((idx = cmd_find_index(ctx, args_get(args, 't'), &s)) == -2)
return (-1);
}
detached = args_has(args, 'd');
wl = NULL;
if (idx != -1)
wl = winlink_find_by_index(&s->windows, idx);
if (wl != NULL && data->flag_kill) {
if (wl != NULL && args_has(args, 'k')) {
/*
* Can't use session_detach as it will destroy session if this
* makes it empty.
@ -173,14 +89,15 @@ cmd_new_window_exec(struct cmd *self, struct cmd_ctx *ctx)
/* Force select/redraw if current. */
if (wl == s->curw) {
data->flag_detached = 0;
detached = 0;
s->curw = NULL;
}
}
cmd = data->cmd;
if (cmd == NULL)
if (args->argc == 0)
cmd = options_get_string(&s->options, "default-command");
else
cmd = args->argv[0];
cwd = options_get_string(&s->options, "default-path");
if (*cwd == '\0') {
if (ctx->cmdclient != NULL && ctx->cmdclient->cwd != NULL)
@ -191,55 +108,19 @@ cmd_new_window_exec(struct cmd *self, struct cmd_ctx *ctx)
if (idx == -1)
idx = -1 - options_get_number(&s->options, "base-index");
wl = session_new(s, data->name, cmd, cwd, idx, &cause);
wl = session_new(s, args_get(args, 'n'), cmd, cwd, idx, &cause);
if (wl == NULL) {
ctx->error(ctx, "create window failed: %s", cause);
xfree(cause);
return (-1);
}
if (!data->flag_detached) {
if (!detached) {
session_select(s, wl->idx);
server_redraw_session_group(s);
} else
server_status_session_group(s);
if (data->flag_print)
if (args_has(args, 'P'))
ctx->print(ctx, "%s:%u", s->name, wl->idx);
return (0);
}
void
cmd_new_window_free(struct cmd *self)
{
struct cmd_new_window_data *data = self->data;
if (data->target != NULL)
xfree(data->target);
if (data->name != NULL)
xfree(data->name);
if (data->cmd != NULL)
xfree(data->cmd);
xfree(data);
}
size_t
cmd_new_window_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_new_window_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
if (off < len && data->flag_detached)
off += xsnprintf(buf + off, len - off, " -d");
if (off < len && data->flag_print)
off += xsnprintf(buf + off, len - off, " -P");
if (off < len && data->target != NULL)
off += cmd_prarg(buf + off, len - off, " -t ", data->target);
if (off < len && data->name != NULL)
off += cmd_prarg(buf + off, len - off, " -n ", data->name);
if (off < len && data->cmd != NULL)
off += cmd_prarg(buf + off, len - off, " ", data->cmd);
return (off);
}

21
cmd-next-layout.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-next-layout.c,v 1.6 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-next-layout.c,v 1.7 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,23 +28,22 @@ int cmd_next_layout_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_next_layout_entry = {
"next-layout", "nextl",
"t:", 0, 0,
CMD_TARGET_WINDOW_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_next_layout_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_next_layout_exec
};
int
cmd_next_layout_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct winlink *wl;
u_int layout;
struct args *args = self->args;
struct winlink *wl;
u_int layout;
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
return (-1);
layout = layout_set_next(wl->window);

35
cmd-next-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-next-window.c,v 1.21 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-next-window.c,v 1.22 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -24,44 +24,39 @@
* Move to next window.
*/
void cmd_next_window_init(struct cmd *, int);
void cmd_next_window_key_binding(struct cmd *, int);
int cmd_next_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_next_window_entry = {
"next-window", "next",
"at:", 0, 0,
"[-a] " CMD_TARGET_SESSION_USAGE,
0, "a",
cmd_next_window_init,
cmd_target_parse,
cmd_next_window_exec,
cmd_target_free,
cmd_target_print
0,
cmd_next_window_key_binding,
NULL,
cmd_next_window_exec
};
void
cmd_next_window_init(struct cmd *self, int key)
cmd_next_window_key_binding(struct cmd *self, int key)
{
struct cmd_target_data *data;
cmd_target_init(self, key);
data = self->data;
self->args = args_create(0);
if (key == ('n' | KEYC_ESCAPE))
cmd_set_flag(&data->chflags, 'a');
args_set(self->args, 'a', NULL);
}
int
cmd_next_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct session *s;
int activity;
struct args *args = self->args;
struct session *s;
int activity;
if ((s = cmd_find_session(ctx, data->target)) == NULL)
if ((s = cmd_find_session(ctx, args_get(args, 't'))) == NULL)
return (-1);
activity = 0;
if (cmd_check_flag(data->chflags, 'a'))
if (args_has(self->args, 'a'))
activity = 1;
if (session_next(s, activity) == 0)

194
cmd-paste-buffer.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-paste-buffer.c,v 1.30 2010-12-30 22:39:49 tcunha Exp $ */
/* $Id: cmd-paste-buffer.c,v 1.31 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -27,132 +27,73 @@
* Paste paste buffer if present.
*/
struct cmd_paste_buffer_data {
char *target;
int buffer;
int flag_delete;
char *sepstr;
};
void cmd_paste_buffer_init(struct cmd *, int);
int cmd_paste_buffer_parse(struct cmd *, int, char **, char **);
int cmd_paste_buffer_exec(struct cmd *, struct cmd_ctx *);
void cmd_paste_buffer_filter(
struct window_pane *, const char *, size_t, char *);
void cmd_paste_buffer_free(struct cmd *);
size_t cmd_paste_buffer_print(struct cmd *, char *, size_t);
struct window_pane *, const char *, size_t, const char *);
const struct cmd_entry cmd_paste_buffer_entry = {
"paste-buffer", "pasteb",
"db:rs:t:", 0, 0,
"[-dr] [-s separator] [-b buffer-index] [-t target-pane]",
0, "",
cmd_paste_buffer_init,
cmd_paste_buffer_parse,
cmd_paste_buffer_exec,
cmd_paste_buffer_free,
cmd_paste_buffer_print
0,
NULL,
NULL,
cmd_paste_buffer_exec
};
/* ARGSUSED */
void
cmd_paste_buffer_init(struct cmd *self, unused int arg)
{
struct cmd_paste_buffer_data *data;
self->data = data = xmalloc(sizeof *data);
data->target = NULL;
data->buffer = -1;
data->flag_delete = 0;
data->sepstr = xstrdup("\r");
}
int
cmd_paste_buffer_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_paste_buffer_data *data;
int opt, n;
const char *errstr;
cmd_paste_buffer_init(self, 0);
data = self->data;
while ((opt = getopt(argc, argv, "b:ds:t:r")) != -1) {
switch (opt) {
case 'b':
if (data->buffer == -1) {
n = strtonum(optarg, 0, INT_MAX, &errstr);
if (errstr != NULL) {
xasprintf(cause, "buffer %s", errstr);
goto error;
}
data->buffer = n;
}
break;
case 'd':
data->flag_delete = 1;
break;
case 's':
if (data->sepstr != NULL)
xfree(data->sepstr);
data->sepstr = xstrdup(optarg);
break;
case 't':
if (data->target == NULL)
data->target = xstrdup(optarg);
break;
case 'r':
if (data->sepstr != NULL)
xfree(data->sepstr);
data->sepstr = xstrdup("\n");
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
error:
self->entry->free(self);
return (-1);
}
int
cmd_paste_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_paste_buffer_data *data = self->data;
struct window_pane *wp;
struct session *s;
struct paste_buffer *pb;
struct args *args = self->args;
struct window_pane *wp;
struct session *s;
struct paste_buffer *pb;
const char *sepstr;
char *cause;
int buffer;
if (cmd_find_pane(ctx, data->target, &s, &wp) == NULL)
if (cmd_find_pane(ctx, args_get(args, 't'), &s, &wp) == NULL)
return (-1);
if (data->buffer == -1)
pb = paste_get_top(&global_buffers);
if (!args_has(args, 'b'))
buffer = -1;
else {
pb = paste_get_index(&global_buffers, data->buffer);
if (pb == NULL) {
ctx->error(ctx, "no buffer %d", data->buffer);
buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
if (cause != NULL) {
ctx->error(ctx, "buffer %s", cause);
xfree(cause);
return (-1);
}
}
if (pb != NULL)
cmd_paste_buffer_filter(wp, pb->data, pb->size, data->sepstr);
if (buffer == -1)
pb = paste_get_top(&global_buffers);
else {
pb = paste_get_index(&global_buffers, buffer);
if (pb == NULL) {
ctx->error(ctx, "no buffer %d", buffer);
return (-1);
}
}
if (pb != NULL) {
sepstr = args_get(args, 's');
if (sepstr == NULL) {
if (args_has(args, 'r'))
sepstr = "\n";
else
sepstr = "\r";
}
cmd_paste_buffer_filter(wp, pb->data, pb->size, sepstr);
}
/* Delete the buffer if -d. */
if (data->flag_delete) {
if (data->buffer == -1)
if (args_has(args, 'd')) {
if (buffer == -1)
paste_free_top(&global_buffers);
else
paste_free_index(&global_buffers, data->buffer);
paste_free_index(&global_buffers, buffer);
}
return (0);
@ -161,7 +102,7 @@ cmd_paste_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
/* Add bytes to a buffer and filter '\n' according to separator. */
void
cmd_paste_buffer_filter(
struct window_pane *wp, const char *data, size_t size, char *sep)
struct window_pane *wp, const char *data, size_t size, const char *sep)
{
const char *end = data + size;
const char *lf;
@ -178,46 +119,3 @@ cmd_paste_buffer_filter(
if (end != data)
bufferevent_write(wp->event, data, end - data);
}
void
cmd_paste_buffer_free(struct cmd *self)
{
struct cmd_paste_buffer_data *data = self->data;
if (data->target != NULL)
xfree(data->target);
if (data->sepstr != NULL)
xfree(data->sepstr);
xfree(data);
}
size_t
cmd_paste_buffer_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_paste_buffer_data *data = self->data;
size_t off = 0;
char tmp[BUFSIZ];
int r_flag;
r_flag = 0;
if (data->sepstr != NULL)
r_flag = (data->sepstr[0] == '\n' && data->sepstr[1] == '\0');
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
if (off < len && data->flag_delete)
off += xsnprintf(buf + off, len - off, " -d");
if (off < len && r_flag)
off += xsnprintf(buf + off, len - off, " -r");
if (off < len && data->buffer != -1)
off += xsnprintf(buf + off, len - off, " -b %d", data->buffer);
if (off < len && data->sepstr != NULL && !r_flag) {
strnvis(
tmp, data->sepstr, sizeof tmp, VIS_OCTAL|VIS_TAB|VIS_NL);
off += cmd_prarg(buf + off, len - off, " -s ", tmp);
}
if (off < len && data->target != NULL)
off += cmd_prarg(buf + off, len - off, " -t ", data->target);
return (off);
}

23
cmd-pipe-pane.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-pipe-pane.c,v 1.15 2010-10-24 00:45:57 tcunha Exp $ */
/* $Id: cmd-pipe-pane.c,v 1.16 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -37,19 +37,18 @@ void cmd_pipe_pane_error_callback(struct bufferevent *, short, void *);
const struct cmd_entry cmd_pipe_pane_entry = {
"pipe-pane", "pipep",
"ot:", 0, 1,
CMD_TARGET_PANE_USAGE "[-o] [command]",
CMD_ARG01, "o",
cmd_target_init,
cmd_target_parse,
cmd_pipe_pane_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_pipe_pane_exec
};
int
cmd_pipe_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct client *c;
struct window_pane *wp;
char *command;
@ -58,7 +57,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
if ((c = cmd_find_client(ctx, NULL)) == NULL)
return (-1);
if (cmd_find_pane(ctx, data->target, NULL, &wp) == NULL)
if (cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp) == NULL)
return (-1);
/* Destroy the old pipe. */
@ -70,7 +69,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
}
/* If no pipe command, that is enough. */
if (data->arg == NULL || *data->arg == '\0')
if (args->argc == 0 || *args->argv[0] == '\0')
return (0);
/*
@ -79,7 +78,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
*
* bind ^p pipep -o 'cat >>~/output'
*/
if (cmd_check_flag(data->chflags, 'o') && old_fd != -1)
if (args_has(self->args, 'o') && old_fd != -1)
return (0);
/* Open the new pipe. */
@ -113,7 +112,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
closefrom(STDERR_FILENO + 1);
command = status_replace(c, NULL, data->arg, time(NULL), 0);
command = status_replace(c, NULL, args->argv[0], time(NULL), 0);
execl(_PATH_BSHELL, "sh", "-c", command, (char *) NULL);
_exit(1);
default:

21
cmd-previous-layout.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-previous-layout.c,v 1.6 2009-12-04 22:14:47 tcunha Exp $ */
/* $Id: cmd-previous-layout.c,v 1.7 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,23 +28,22 @@ int cmd_previous_layout_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_previous_layout_entry = {
"previous-layout", "prevl",
"t:", 0, 0,
CMD_TARGET_WINDOW_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_previous_layout_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_previous_layout_exec
};
int
cmd_previous_layout_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct winlink *wl;
u_int layout;
struct args *args = self->args;
struct winlink *wl;
u_int layout;
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
return (-1);
layout = layout_set_previous(wl->window);

35
cmd-previous-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-previous-window.c,v 1.21 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-previous-window.c,v 1.22 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -24,44 +24,39 @@
* Move to previous window.
*/
void cmd_previous_window_init(struct cmd *, int);
void cmd_previous_window_key_binding(struct cmd *, int);
int cmd_previous_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_previous_window_entry = {
"previous-window", "prev",
"at:", 0, 0,
"[-a] " CMD_TARGET_SESSION_USAGE,
0, "a",
cmd_previous_window_init,
cmd_target_parse,
cmd_previous_window_exec,
cmd_target_free,
cmd_target_print
0,
cmd_previous_window_key_binding,
NULL,
cmd_previous_window_exec
};
void
cmd_previous_window_init(struct cmd *self, int key)
cmd_previous_window_key_binding(struct cmd *self, int key)
{
struct cmd_target_data *data;
cmd_target_init(self, key);
data = self->data;
self->args = args_create(0);
if (key == ('p' | KEYC_ESCAPE))
cmd_set_flag(&data->chflags, 'a');
args_set(self->args, 'a', NULL);
}
int
cmd_previous_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct session *s;
int activity;
struct args *args = self->args;
struct session *s;
int activity;
if ((s = cmd_find_session(ctx, data->target)) == NULL)
if ((s = cmd_find_session(ctx, args_get(args, 't'))) == NULL)
return (-1);
activity = 0;
if (cmd_check_flag(data->chflags, 'a'))
if (args_has(self->args, 'a'))
activity = 1;
if (session_previous(s, activity) == 0)

19
cmd-refresh-client.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-refresh-client.c,v 1.11 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-refresh-client.c,v 1.12 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,22 +28,21 @@ int cmd_refresh_client_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_refresh_client_entry = {
"refresh-client", "refresh",
"t:", 0, 0,
CMD_TARGET_CLIENT_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_refresh_client_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_refresh_client_exec
};
int
cmd_refresh_client_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct client *c;
struct args *args = self->args;
struct client *c;
if ((c = cmd_find_client(ctx, data->target)) == NULL)
if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
return (-1);
server_redraw_client(c);

27
cmd-rename-session.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-rename-session.c,v 1.21 2010-12-22 15:36:44 tcunha Exp $ */
/* $Id: cmd-rename-session.c,v 1.22 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,32 +30,33 @@ int cmd_rename_session_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_rename_session_entry = {
"rename-session", "rename",
"t:", 1, 1,
CMD_TARGET_SESSION_USAGE " new-name",
CMD_ARG1, "",
cmd_target_init,
cmd_target_parse,
cmd_rename_session_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_rename_session_exec
};
int
cmd_rename_session_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct session *s;
struct args *args = self->args;
struct session *s;
const char *newname;
if (data->arg != NULL && session_find(data->arg) != NULL) {
ctx->error(ctx, "duplicate session: %s", data->arg);
newname = args->argv[0];
if (session_find(newname) != NULL) {
ctx->error(ctx, "duplicate session: %s", newname);
return (-1);
}
if ((s = cmd_find_session(ctx, data->target)) == NULL)
if ((s = cmd_find_session(ctx, args_get(args, 't'))) == NULL)
return (-1);
RB_REMOVE(sessions, &sessions, s);
xfree(s->name);
s->name = xstrdup(data->arg);
s->name = xstrdup(newname);
RB_INSERT(sessions, &sessions, s);
server_status_session(s);

23
cmd-rename-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-rename-window.c,v 1.31 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-rename-window.c,v 1.32 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,27 +30,26 @@ int cmd_rename_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_rename_window_entry = {
"rename-window", "renamew",
"t:", 1, 1,
CMD_TARGET_WINDOW_USAGE " new-name",
CMD_ARG1, "",
cmd_target_init,
cmd_target_parse,
cmd_rename_window_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_rename_window_exec
};
int
cmd_rename_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct session *s;
struct winlink *wl;
struct args *args = self->args;
struct session *s;
struct winlink *wl;
if ((wl = cmd_find_window(ctx, data->target, &s)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), &s)) == NULL)
return (-1);
xfree(wl->window->name);
wl->window->name = xstrdup(data->arg);
wl->window->name = xstrdup(args->argv[0]);
options_set_number(&wl->window->options, "automatic-rename", 0);
server_status_window(wl->window);

100
cmd-resize-pane.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-resize-pane.c,v 1.14 2009-12-04 22:14:47 tcunha Exp $ */
/* $Id: cmd-resize-pane.c,v 1.15 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -26,84 +26,90 @@
* Increase or decrease pane size.
*/
void cmd_resize_pane_init(struct cmd *, int);
void cmd_resize_pane_key_binding(struct cmd *, int);
int cmd_resize_pane_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_resize_pane_entry = {
"resize-pane", "resizep",
"DLRt:U", 0, 1,
"[-DLRU] " CMD_TARGET_PANE_USAGE " [adjustment]",
CMD_ARG01, "DLRU",
cmd_resize_pane_init,
cmd_target_parse,
cmd_resize_pane_exec,
cmd_target_free,
cmd_target_print
0,
cmd_resize_pane_key_binding,
NULL,
cmd_resize_pane_exec
};
void
cmd_resize_pane_init(struct cmd *self, int key)
cmd_resize_pane_key_binding(struct cmd *self, int key)
{
struct cmd_target_data *data;
cmd_target_init(self, key);
data = self->data;
if (key == (KEYC_UP | KEYC_CTRL))
cmd_set_flag(&data->chflags, 'U');
if (key == (KEYC_DOWN | KEYC_CTRL))
cmd_set_flag(&data->chflags, 'D');
if (key == (KEYC_LEFT | KEYC_CTRL))
cmd_set_flag(&data->chflags, 'L');
if (key == (KEYC_RIGHT | KEYC_CTRL))
cmd_set_flag(&data->chflags, 'R');
if (key == (KEYC_UP | KEYC_ESCAPE)) {
cmd_set_flag(&data->chflags, 'U');
data->arg = xstrdup("5");
}
if (key == (KEYC_DOWN | KEYC_ESCAPE)) {
cmd_set_flag(&data->chflags, 'D');
data->arg = xstrdup("5");
}
if (key == (KEYC_LEFT | KEYC_ESCAPE)) {
cmd_set_flag(&data->chflags, 'L');
data->arg = xstrdup("5");
}
if (key == (KEYC_RIGHT | KEYC_ESCAPE)) {
cmd_set_flag(&data->chflags, 'R');
data->arg = xstrdup("5");
switch (key) {
case KEYC_UP | KEYC_CTRL:
self->args = args_create(0);
args_set(self->args, 'U', NULL);
break;
case KEYC_DOWN | KEYC_CTRL:
self->args = args_create(0);
args_set(self->args, 'D', NULL);
break;
case KEYC_LEFT | KEYC_CTRL:
self->args = args_create(0);
args_set(self->args, 'L', NULL);
break;
case KEYC_RIGHT | KEYC_CTRL:
self->args = args_create(0);
args_set(self->args, 'R', NULL);
break;
case KEYC_UP | KEYC_ESCAPE:
self->args = args_create(1, "5");
args_set(self->args, 'U', NULL);
break;
case KEYC_DOWN | KEYC_ESCAPE:
self->args = args_create(1, "5");
args_set(self->args, 'D', NULL);
break;
case KEYC_LEFT | KEYC_ESCAPE:
self->args = args_create(1, "5");
args_set(self->args, 'L', NULL);
break;
case KEYC_RIGHT | KEYC_ESCAPE:
self->args = args_create(1, "5");
args_set(self->args, 'R', NULL);
break;
default:
self->args = args_create(0);
break;
}
}
int
cmd_resize_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct winlink *wl;
const char *errstr;
struct window_pane *wp;
u_int adjust;
if ((wl = cmd_find_pane(ctx, data->target, NULL, &wp)) == NULL)
if ((wl = cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp)) == NULL)
return (-1);
if (data->arg == NULL)
if (args->argc == 0)
adjust = 1;
else {
adjust = strtonum(data->arg, 1, INT_MAX, &errstr);
adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr);
if (errstr != NULL) {
ctx->error(ctx, "adjustment %s: %s", errstr, data->arg);
ctx->error(ctx, "adjustment %s", errstr);
return (-1);
}
}
if (cmd_check_flag(data->chflags, 'L'))
if (args_has(self->args, 'L'))
layout_resize_pane(wp, LAYOUT_LEFTRIGHT, -adjust);
else if (cmd_check_flag(data->chflags, 'R'))
else if (args_has(self->args, 'R'))
layout_resize_pane(wp, LAYOUT_LEFTRIGHT, adjust);
else if (cmd_check_flag(data->chflags, 'U'))
else if (args_has(self->args, 'U'))
layout_resize_pane(wp, LAYOUT_TOPBOTTOM, -adjust);
else if (cmd_check_flag(data->chflags, 'D'))
else if (args_has(self->args, 'D'))
layout_resize_pane(wp, LAYOUT_TOPBOTTOM, adjust);
server_redraw_window(wl->window);

27
cmd-respawn-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-respawn-window.c,v 1.25 2009-12-04 22:14:47 tcunha Exp $ */
/* $Id: cmd-respawn-window.c,v 1.26 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,31 +30,31 @@ int cmd_respawn_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_respawn_window_entry = {
"respawn-window", "respawnw",
"kt:", 0, 1,
"[-k] " CMD_TARGET_WINDOW_USAGE " [command]",
CMD_ARG01, "k",
cmd_target_init,
cmd_target_parse,
cmd_respawn_window_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_respawn_window_exec
};
int
cmd_respawn_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct winlink *wl;
struct window *w;
struct window_pane *wp;
struct session *s;
struct environ env;
const char *cmd;
char *cause;
if ((wl = cmd_find_window(ctx, data->target, &s)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), &s)) == NULL)
return (-1);
w = wl->window;
if (!cmd_check_flag(data->chflags, 'k')) {
if (!args_has(self->args, 'k')) {
TAILQ_FOREACH(wp, &w->panes, entry) {
if (wp->fd == -1)
continue;
@ -75,8 +75,11 @@ cmd_respawn_window_exec(struct cmd *self, struct cmd_ctx *ctx)
window_destroy_panes(w);
TAILQ_INSERT_HEAD(&w->panes, wp, entry);
window_pane_resize(wp, w->sx, w->sy);
if (window_pane_spawn(
wp, data->arg, NULL, NULL, &env, s->tio, &cause) != 0) {
if (args->argc != 0)
cmd = args->argv[0];
else
cmd = NULL;
if (window_pane_spawn(wp, cmd, NULL, NULL, &env, s->tio, &cause) != 0) {
ctx->error(ctx, "respawn window failed: %s", cause);
xfree(cause);
environ_free(&env);

31
cmd-rotate-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-rotate-window.c,v 1.10 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-rotate-window.c,v 1.11 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -24,47 +24,42 @@
* Rotate the panes in a window.
*/
void cmd_rotate_window_init(struct cmd *, int);
void cmd_rotate_window_key_binding(struct cmd *, int);
int cmd_rotate_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_rotate_window_entry = {
"rotate-window", "rotatew",
"Dt:U", 0, 0,
"[-DU] " CMD_TARGET_WINDOW_USAGE,
0, "DU",
cmd_rotate_window_init,
cmd_target_parse,
cmd_rotate_window_exec,
cmd_target_free,
cmd_target_print
0,
cmd_rotate_window_key_binding,
NULL,
cmd_rotate_window_exec
};
void
cmd_rotate_window_init(struct cmd *self, int key)
cmd_rotate_window_key_binding(struct cmd *self, int key)
{
struct cmd_target_data *data;
cmd_target_init(self, key);
data = self->data;
self->args = args_create(0);
if (key == ('o' | KEYC_ESCAPE))
cmd_set_flag(&data->chflags, 'D');
args_set(self->args, 'D', NULL);
}
int
cmd_rotate_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct winlink *wl;
struct window *w;
struct window_pane *wp, *wp2;
struct layout_cell *lc;
u_int sx, sy, xoff, yoff;
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
return (-1);
w = wl->window;
if (cmd_check_flag(data->chflags, 'D')) {
if (args_has(self->args, 'D')) {
wp = TAILQ_LAST(&w->panes, window_panes);
TAILQ_REMOVE(&w->panes, wp, entry);
TAILQ_INSERT_HEAD(&w->panes, wp, entry);

19
cmd-run-shell.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-run-shell.c,v 1.9 2010-08-09 21:44:25 tcunha Exp $ */
/* $Id: cmd-run-shell.c,v 1.10 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@ -35,13 +35,12 @@ void cmd_run_shell_free(void *);
const struct cmd_entry cmd_run_shell_entry = {
"run-shell", "run",
"", 1, 1,
"command",
CMD_ARG1, "",
cmd_target_init,
cmd_target_parse,
cmd_run_shell_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_run_shell_exec
};
struct cmd_run_shell_data {
@ -52,12 +51,12 @@ struct cmd_run_shell_data {
int
cmd_run_shell_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct cmd_run_shell_data *cdata;
struct job *job;
cdata = xmalloc(sizeof *cdata);
cdata->cmd = xstrdup(data->arg);
cdata->cmd = xstrdup(args->argv[0]);
memcpy(&cdata->ctx, ctx, sizeof cdata->ctx);
if (ctx->cmdclient != NULL)
@ -66,7 +65,7 @@ cmd_run_shell_exec(struct cmd *self, struct cmd_ctx *ctx)
ctx->curclient->references++;
job = job_add(NULL, 0, NULL,
data->arg, cmd_run_shell_callback, cmd_run_shell_free, cdata);
args->argv[0], cmd_run_shell_callback, cmd_run_shell_free, cdata);
job_run(job);
return (1); /* don't let client exit */

54
cmd-save-buffer.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-save-buffer.c,v 1.13 2010-12-30 22:39:49 tcunha Exp $ */
/* $Id: cmd-save-buffer.c,v 1.14 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@ -32,56 +32,66 @@ int cmd_save_buffer_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_save_buffer_entry = {
"save-buffer", "saveb",
"[-a] " CMD_BUFFER_USAGE " path",
CMD_ARG1, "a",
cmd_buffer_init,
cmd_buffer_parse,
cmd_save_buffer_exec,
cmd_buffer_free,
cmd_buffer_print
"ab:", 1, 1,
"[-a] " CMD_BUFFER_USAGE,
0,
NULL,
NULL,
cmd_save_buffer_exec
};
int
cmd_save_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_buffer_data *data = self->data;
struct args *args = self->args;
struct client *c = ctx->cmdclient;
struct paste_buffer *pb;
const char *path;
char *cause;
int buffer;
mode_t mask;
FILE *f;
if (data->buffer == -1) {
if (!args_has(args, 'b')) {
if ((pb = paste_get_top(&global_buffers)) == NULL) {
ctx->error(ctx, "no buffers");
return (-1);
}
} else {
pb = paste_get_index(&global_buffers, data->buffer);
buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
if (cause != NULL) {
ctx->error(ctx, "buffer %s", cause);
xfree(cause);
return (-1);
}
pb = paste_get_index(&global_buffers, buffer);
if (pb == NULL) {
ctx->error(ctx, "no buffer %d", data->buffer);
ctx->error(ctx, "no buffer %d", buffer);
return (-1);
}
}
if (strcmp(data->arg, "-") == 0) {
if (ctx->cmdclient == NULL) {
ctx->error(ctx, "%s: can't write to stdout", data->arg);
path = args->argv[0];
if (strcmp(path, "-") == 0) {
if (c == NULL) {
ctx->error(ctx, "%s: can't write to stdout", path);
return (-1);
}
bufferevent_write(
ctx->cmdclient->stdout_event, pb->data, pb->size);
bufferevent_write(c->stdout_event, pb->data, pb->size);
} else {
mask = umask(S_IRWXG | S_IRWXO);
if (cmd_check_flag(data->chflags, 'a'))
f = fopen(data->arg, "ab");
if (args_has(self->args, 'a'))
f = fopen(path, "ab");
else
f = fopen(data->arg, "wb");
f = fopen(path, "wb");
umask(mask);
if (f == NULL) {
ctx->error(ctx, "%s: %s", data->arg, strerror(errno));
ctx->error(ctx, "%s: %s", path, strerror(errno));
return (-1);
}
if (fwrite(pb->data, 1, pb->size, f) != pb->size) {
ctx->error(ctx, "%s: fwrite error", data->arg);
ctx->error(ctx, "%s: fwrite error", path);
fclose(f);
return (-1);
}

75
cmd-select-layout.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-select-layout.c,v 1.12 2010-07-02 02:54:52 tcunha Exp $ */
/* $Id: cmd-select-layout.c,v 1.13 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -24,43 +24,40 @@
* Switch window to selected layout.
*/
void cmd_select_layout_init(struct cmd *, int);
void cmd_select_layout_key_binding(struct cmd *, int);
int cmd_select_layout_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_select_layout_entry = {
"select-layout", "selectl",
"t:", 0, 1,
CMD_TARGET_WINDOW_USAGE " [layout-name]",
CMD_ARG01, "",
cmd_select_layout_init,
cmd_target_parse,
cmd_select_layout_exec,
cmd_target_free,
cmd_target_print
0,
cmd_select_layout_key_binding,
NULL,
cmd_select_layout_exec
};
void
cmd_select_layout_init(struct cmd *self, int key)
cmd_select_layout_key_binding(struct cmd *self, int key)
{
struct cmd_target_data *data;
cmd_target_init(self, key);
data = self->data;
switch (key) {
case ('1' | KEYC_ESCAPE):
data->arg = xstrdup("even-horizontal");
case '1' | KEYC_ESCAPE:
self->args = args_create(1, "even-horizontal");
break;
case ('2' | KEYC_ESCAPE):
data->arg = xstrdup("even-vertical");
case '2' | KEYC_ESCAPE:
self->args = args_create(1, "even-vertical");
break;
case ('3' | KEYC_ESCAPE):
data->arg = xstrdup("main-horizontal");
case '3' | KEYC_ESCAPE:
self->args = args_create(1, "main-horizontal");
break;
case ('4' | KEYC_ESCAPE):
data->arg = xstrdup("main-vertical");
case '4' | KEYC_ESCAPE:
self->args = args_create(1, "main-vertical");
break;
case ('5' | KEYC_ESCAPE):
data->arg = xstrdup("tiled");
case '5' | KEYC_ESCAPE:
self->args = args_create(1, "tiled");
break;
default:
self->args = args_create(0);
break;
}
}
@ -68,26 +65,32 @@ cmd_select_layout_init(struct cmd *self, int key)
int
cmd_select_layout_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct winlink *wl;
int layout;
struct args *args = self->args;
struct winlink *wl;
const char *layoutname;
int layout;
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
return (-1);
if (data->arg == NULL) {
if (args->argc == 0)
layout = wl->window->lastlayout;
if (layout == -1)
return (0);
} else if ((layout = layout_set_lookup(data->arg)) != -1) {
else
layout = layout_set_lookup(args->argv[0]);
if (layout != -1) {
layout = layout_set_select(wl->window, layout);
ctx->info(ctx, "arranging in: %s", layout_set_name(layout));
} else {
if (layout_parse(wl->window, data->arg) == -1) {
ctx->error(ctx, "can't set layout: %s", data->arg);
return (0);
}
if (args->argc != 0) {
layoutname = args->argv[0];
if (layout_parse(wl->window, layoutname) == -1) {
ctx->error(ctx, "can't set layout: %s", layoutname);
return (-1);
}
ctx->info(ctx, "arranging in: %s", data->arg);
ctx->info(ctx, "arranging in: %s", layoutname);
return (0);
}
return (0);

47
cmd-select-pane.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-select-pane.c,v 1.13 2010-03-15 22:03:38 nicm Exp $ */
/* $Id: cmd-select-pane.c,v 1.14 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -24,62 +24,57 @@
* Select pane.
*/
void cmd_select_pane_init(struct cmd *, int);
void cmd_select_pane_key_binding(struct cmd *, int);
int cmd_select_pane_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_select_pane_entry = {
"select-pane", "selectp",
"DLRt:U", 0, 0,
"[-DLRU] " CMD_TARGET_PANE_USAGE,
0, "DLRU",
cmd_select_pane_init,
cmd_target_parse,
cmd_select_pane_exec,
cmd_target_free,
cmd_target_print
0,
cmd_select_pane_key_binding,
NULL,
cmd_select_pane_exec
};
void
cmd_select_pane_init(struct cmd *self, int key)
cmd_select_pane_key_binding(struct cmd *self, int key)
{
struct cmd_target_data *data;
cmd_target_init(self, key);
data = self->data;
self->args = args_create(0);
if (key == KEYC_UP)
cmd_set_flag(&data->chflags, 'U');
args_set(self->args, 'U', NULL);
if (key == KEYC_DOWN)
cmd_set_flag(&data->chflags, 'D');
args_set(self->args, 'D', NULL);
if (key == KEYC_LEFT)
cmd_set_flag(&data->chflags, 'L');
args_set(self->args, 'L', NULL);
if (key == KEYC_RIGHT)
cmd_set_flag(&data->chflags, 'R');
args_set(self->args, 'R', NULL);
if (key == 'o')
data->target = xstrdup(":.+");
args_set(self->args, 't', ":.+");
}
int
cmd_select_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct winlink *wl;
struct window_pane *wp;
if ((wl = cmd_find_pane(ctx, data->target, NULL, &wp)) == NULL)
if ((wl = cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp)) == NULL)
return (-1);
if (!window_pane_visible(wp)) {
ctx->error(ctx, "pane not visible: %s", data->target);
ctx->error(ctx, "pane not visible");
return (-1);
}
if (cmd_check_flag(data->chflags, 'L'))
if (args_has(self->args, 'L'))
wp = window_pane_find_left(wp);
else if (cmd_check_flag(data->chflags, 'R'))
else if (args_has(self->args, 'R'))
wp = window_pane_find_right(wp);
else if (cmd_check_flag(data->chflags, 'U'))
else if (args_has(self->args, 'U'))
wp = window_pane_find_up(wp);
else if (cmd_check_flag(data->chflags, 'D'))
else if (args_has(self->args, 'D'))
wp = window_pane_find_down(wp);
if (wp == NULL) {
ctx->error(ctx, "pane not found");

33
cmd-select-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-select-window.c,v 1.24 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-select-window.c,v 1.25 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -26,39 +26,38 @@
* Select window by index.
*/
void cmd_select_window_init(struct cmd *, int);
void cmd_select_window_key_binding(struct cmd *, int);
int cmd_select_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_select_window_entry = {
"select-window", "selectw",
"t:", 0, 0,
CMD_TARGET_WINDOW_USAGE,
0, "",
cmd_select_window_init,
cmd_target_parse,
cmd_select_window_exec,
cmd_target_free,
cmd_target_print
0,
cmd_select_window_key_binding,
NULL,
cmd_select_window_exec
};
void
cmd_select_window_init(struct cmd *self, int key)
cmd_select_window_key_binding(struct cmd *self, int key)
{
struct cmd_target_data *data;
char tmp[16];
cmd_target_init(self, key);
data = self->data;
xsnprintf(tmp, sizeof tmp, ":%d", key - '0');
xasprintf(&data->target, ":%d", key - '0');
self->args = args_create(0);
args_set(self->args, 't', tmp);
}
int
cmd_select_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct winlink *wl;
struct session *s;
struct args *args = self->args;
struct winlink *wl;
struct session *s;
if ((wl = cmd_find_window(ctx, data->target, &s)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), &s)) == NULL)
return (-1);
if (session_select(s, wl->idx) == 0)

128
cmd-send-keys.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-send-keys.c,v 1.25 2010-05-22 21:56:04 micahcowan Exp $ */
/* $Id: cmd-send-keys.c,v 1.26 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@ -26,128 +26,40 @@
* Send keys to client.
*/
int cmd_send_keys_parse(struct cmd *, int, char **, char **);
int cmd_send_keys_exec(struct cmd *, struct cmd_ctx *);
void cmd_send_keys_free(struct cmd *);
size_t cmd_send_keys_print(struct cmd *, char *, size_t);
struct cmd_send_keys_data {
char *target;
u_int nkeys;
int *keys;
};
const struct cmd_entry cmd_send_keys_entry = {
"send-keys", "send",
"t:", 0, -1,
"[-t target-pane] key ...",
0, "",
0,
NULL,
cmd_send_keys_parse,
cmd_send_keys_exec,
cmd_send_keys_free,
cmd_send_keys_print
NULL,
cmd_send_keys_exec
};
int
cmd_send_keys_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_send_keys_data *data;
int opt, key;
char *s;
self->data = data = xmalloc(sizeof *data);
data->target = NULL;
data->nkeys = 0;
data->keys = NULL;
while ((opt = getopt(argc, argv, "t:")) != -1) {
switch (opt) {
case 't':
if (data->target == NULL)
data->target = xstrdup(optarg);
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (argc == 0)
goto usage;
while (argc-- != 0) {
if ((key = key_string_lookup_string(*argv)) != KEYC_NONE) {
data->keys = xrealloc(
data->keys, data->nkeys + 1, sizeof *data->keys);
data->keys[data->nkeys++] = key;
} else {
for (s = *argv; *s != '\0'; s++) {
data->keys = xrealloc(data->keys,
data->nkeys + 1, sizeof *data->keys);
data->keys[data->nkeys++] = *s;
}
}
argv++;
}
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
self->entry->free(self);
return (-1);
}
int
cmd_send_keys_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_send_keys_data *data = self->data;
struct window_pane *wp;
struct session *s;
u_int i;
struct args *args = self->args;
struct window_pane *wp;
struct session *s;
const char *str;
int i, key;
if (data == NULL)
if (cmd_find_pane(ctx, args_get(args, 't'), &s, &wp) == NULL)
return (-1);
if (cmd_find_pane(ctx, data->target, &s, &wp) == NULL)
return (-1);
for (i = 0; i < args->argc; i++) {
str = args->argv[i];
for (i = 0; i < data->nkeys; i++)
window_pane_key(wp, s, data->keys[i]);
if ((key = key_string_lookup_string(str)) != KEYC_NONE) {
window_pane_key(wp, s, key);
} else {
for (; *str != '\0'; str++)
window_pane_key(wp, s, *str);
}
}
return (0);
}
void
cmd_send_keys_free(struct cmd *self)
{
struct cmd_send_keys_data *data = self->data;
if (data->target != NULL)
xfree(data->target);
xfree(data);
}
size_t
cmd_send_keys_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_send_keys_data *data = self->data;
size_t off = 0;
u_int i;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
if (off < len && data->target != NULL)
off += cmd_prarg(buf + off, len - off, " -t ", data->target);
for (i = 0; i < data->nkeys; i++) {
if (off >= len)
break;
off += xsnprintf(buf + off,
len - off, " %s", key_string_lookup_key(data->keys[i]));
}
return (off);
}

17
cmd-send-prefix.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-send-prefix.c,v 1.29 2010-05-22 21:56:04 micahcowan Exp $ */
/* $Id: cmd-send-prefix.c,v 1.30 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,24 +28,23 @@ int cmd_send_prefix_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_send_prefix_entry = {
"send-prefix", NULL,
"t:", 0, 0,
CMD_TARGET_PANE_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_send_prefix_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_send_prefix_exec
};
int
cmd_send_prefix_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct session *s;
struct window_pane *wp;
struct keylist *keylist;
if (cmd_find_pane(ctx, data->target, &s, &wp) == NULL)
if (cmd_find_pane(ctx, args_get(args, 't'), &s, &wp) == NULL)
return (-1);
keylist = options_get_data(&s->options, "prefix");

9
cmd-server-info.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-server-info.c,v 1.40 2011-01-03 23:30:43 tcunha Exp $ */
/* $Id: cmd-server-info.c,v 1.41 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@ -34,13 +34,12 @@ int cmd_server_info_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_server_info_entry = {
"server-info", "info",
"", 0, 0,
"",
0, "",
0,
NULL,
NULL,
cmd_server_info_exec,
NULL,
NULL
cmd_server_info_exec
};
/* ARGSUSED */

39
cmd-set-buffer.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-set-buffer.c,v 1.13 2010-12-30 22:39:49 tcunha Exp $ */
/* $Id: cmd-set-buffer.c,v 1.14 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,36 +30,45 @@ int cmd_set_buffer_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_set_buffer_entry = {
"set-buffer", "setb",
"b:", 1, 1,
CMD_BUFFER_USAGE " data",
CMD_ARG1, "",
cmd_buffer_init,
cmd_buffer_parse,
cmd_set_buffer_exec,
cmd_buffer_free,
cmd_buffer_print
0,
NULL,
NULL,
cmd_set_buffer_exec
};
int
cmd_set_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_buffer_data *data = self->data;
u_int limit;
char *pdata;
size_t psize;
struct args *args = self->args;
u_int limit;
char *pdata, *cause;
size_t psize;
int buffer;
limit = options_get_number(&global_options, "buffer-limit");
pdata = xstrdup(data->arg);
pdata = xstrdup(args->argv[0]);
psize = strlen(pdata);
if (data->buffer == -1) {
if (!args_has(args, 'b')) {
paste_add(&global_buffers, pdata, psize, limit);
return (0);
}
if (paste_replace(&global_buffers, data->buffer, pdata, psize) != 0) {
ctx->error(ctx, "no buffer %d", data->buffer);
buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
if (cause != NULL) {
ctx->error(ctx, "buffer %s", cause);
xfree(cause);
return (-1);
}
if (paste_replace(&global_buffers, buffer, pdata, psize) != 0) {
ctx->error(ctx, "no buffer %d", buffer);
xfree(pdata);
return (-1);
}
return (0);
}

48
cmd-set-environment.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-set-environment.c,v 1.3 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-set-environment.c,v 1.4 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -31,57 +31,63 @@ int cmd_set_environment_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_set_environment_entry = {
"set-environment", "setenv",
"grt:u", 1, 2,
"[-gru] " CMD_TARGET_SESSION_USAGE " name [value]",
CMD_ARG12, "gru",
0,
NULL,
cmd_target_parse,
cmd_set_environment_exec,
cmd_target_free,
cmd_target_print
NULL,
cmd_set_environment_exec
};
int
cmd_set_environment_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct session *s;
struct environ *env;
struct args *args = self->args;
struct session *s;
struct environ *env;
const char *name, *value;
if (*data->arg == '\0') {
name = args->argv[0];
if (*name == '\0') {
ctx->error(ctx, "empty variable name");
return (-1);
}
if (strchr(data->arg, '=') != NULL) {
if (strchr(name, '=') != NULL) {
ctx->error(ctx, "variable name contains =");
return (-1);
}
if (cmd_check_flag(data->chflags, 'g'))
if (args->argc < 1)
value = NULL;
else
value = args->argv[1];
if (args_has(self->args, 'g'))
env = &global_environ;
else {
if ((s = cmd_find_session(ctx, data->target)) == NULL)
if ((s = cmd_find_session(ctx, args_get(args, 't'))) == NULL)
return (-1);
env = &s->environ;
}
if (cmd_check_flag(data->chflags, 'u')) {
if (data->arg2 != NULL) {
if (args_has(self->args, 'u')) {
if (value != NULL) {
ctx->error(ctx, "can't specify a value with -u");
return (-1);
}
environ_unset(env, data->arg);
} else if (cmd_check_flag(data->chflags, 'r')) {
if (data->arg2 != NULL) {
environ_unset(env, name);
} else if (args_has(self->args, 'r')) {
if (value != NULL) {
ctx->error(ctx, "can't specify a value with -r");
return (-1);
}
environ_set(env, data->arg, NULL);
environ_set(env, name, NULL);
} else {
if (data->arg2 == NULL) {
if (value == NULL) {
ctx->error(ctx, "no value specified");
return (-1);
}
environ_set(env, data->arg, data->arg2);
environ_set(env, name, value);
}
return (0);

207
cmd-set-option.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-set-option.c,v 1.104 2011-01-03 23:52:38 tcunha Exp $ */
/* $Id: cmd-set-option.c,v 1.105 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,40 +30,48 @@
int cmd_set_option_exec(struct cmd *, struct cmd_ctx *);
int cmd_set_option_unset(struct cmd *, struct cmd_ctx *,
const struct options_table_entry *, struct options *);
const struct options_table_entry *, struct options *,
const char *);
int cmd_set_option_set(struct cmd *, struct cmd_ctx *,
const struct options_table_entry *, struct options *);
const struct options_table_entry *, struct options *,
const char *);
struct options_entry *cmd_set_option_string(struct cmd *, struct cmd_ctx *,
const struct options_table_entry *, struct options *);
const struct options_table_entry *, struct options *,
const char *);
struct options_entry *cmd_set_option_number(struct cmd *, struct cmd_ctx *,
const struct options_table_entry *, struct options *);
const struct options_table_entry *, struct options *,
const char *);
struct options_entry *cmd_set_option_keys(struct cmd *, struct cmd_ctx *,
const struct options_table_entry *, struct options *);
const struct options_table_entry *, struct options *,
const char *);
struct options_entry *cmd_set_option_colour(struct cmd *, struct cmd_ctx *,
const struct options_table_entry *, struct options *);
const struct options_table_entry *, struct options *,
const char *);
struct options_entry *cmd_set_option_attributes(struct cmd *, struct cmd_ctx *,
const struct options_table_entry *, struct options *);
const struct options_table_entry *, struct options *,
const char *);
struct options_entry *cmd_set_option_flag(struct cmd *, struct cmd_ctx *,
const struct options_table_entry *, struct options *);
const struct options_table_entry *, struct options *,
const char *);
struct options_entry *cmd_set_option_choice(struct cmd *, struct cmd_ctx *,
const struct options_table_entry *, struct options *);
const struct options_table_entry *, struct options *,
const char *);
const struct cmd_entry cmd_set_option_entry = {
"set-option", "set",
"agst:uw", 1, 2,
"[-agsuw] [-t target-session|target-window] option [value]",
CMD_ARG12, "agsuw",
0,
NULL,
cmd_target_parse,
cmd_set_option_exec,
cmd_target_free,
cmd_target_print
NULL,
cmd_set_option_exec
};
int
cmd_set_option_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
const struct options_table_entry *table, *oe, *oe_loop;
struct session *s;
struct winlink *wl;
@ -71,61 +79,74 @@ cmd_set_option_exec(struct cmd *self, struct cmd_ctx *ctx)
struct options *oo;
struct jobs *jobs;
struct job *job, *nextjob;
const char *optstr, *valstr;
u_int i;
int try_again;
/* Work out the options tree and table to use. */
if (cmd_check_flag(data->chflags, 's')) {
if (args_has(self->args, 's')) {
oo = &global_options;
table = server_options_table;
} else if (cmd_check_flag(data->chflags, 'w')) {
} else if (args_has(self->args, 'w')) {
table = window_options_table;
if (cmd_check_flag(data->chflags, 'g'))
if (args_has(self->args, 'g'))
oo = &global_w_options;
else {
wl = cmd_find_window(ctx, data->target, NULL);
wl = cmd_find_window(ctx, args_get(args, 't'), NULL);
if (wl == NULL)
return (-1);
oo = &wl->window->options;
}
} else {
table = session_options_table;
if (cmd_check_flag(data->chflags, 'g'))
if (args_has(self->args, 'g'))
oo = &global_s_options;
else {
s = cmd_find_session(ctx, data->target);
s = cmd_find_session(ctx, args_get(args, 't'));
if (s == NULL)
return (-1);
oo = &s->options;
}
}
/* Get the option name and value. */
optstr = args->argv[0];
if (*optstr == '\0') {
ctx->error(ctx, "invalid option");
return (-1);
}
if (args->argc < 1)
valstr = NULL;
else
valstr = args->argv[1];
/* Find the option table entry. */
oe = NULL;
for (oe_loop = table; oe_loop->name != NULL; oe_loop++) {
if (strncmp(oe_loop->name, data->arg, strlen(data->arg)) != 0)
if (strncmp(oe_loop->name, optstr, strlen(optstr)) != 0)
continue;
if (oe != NULL) {
ctx->error(ctx, "ambiguous option: %s", data->arg);
ctx->error(ctx, "ambiguous option: %s", optstr);
return (-1);
}
oe = oe_loop;
/* Bail now if an exact match. */
if (strcmp(oe->name, data->arg) == 0)
if (strcmp(oe->name, optstr) == 0)
break;
}
if (oe == NULL) {
ctx->error(ctx, "unknown option: %s", data->arg);
ctx->error(ctx, "unknown option: %s", optstr);
return (-1);
}
/* Unset or set the option. */
if (cmd_check_flag(data->chflags, 'u')) {
if (cmd_set_option_unset(self, ctx, oe, oo) != 0)
if (args_has(args, 'u')) {
if (cmd_set_option_unset(self, ctx, oe, oo, valstr) != 0)
return (-1);
} else {
if (cmd_set_option_set(self, ctx, oe, oo) != 0)
if (cmd_set_option_set(self, ctx, oe, oo, valstr) != 0)
return (-1);
}
@ -176,15 +197,15 @@ cmd_set_option_exec(struct cmd *self, struct cmd_ctx *ctx)
/* Unset an option. */
int
cmd_set_option_unset(struct cmd *self, struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo)
const struct options_table_entry *oe, struct options *oo, const char *value)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
if (cmd_check_flag(data->chflags, 'g')) {
if (args_has(args, 'g')) {
ctx->error(ctx, "can't unset global option: %s", oe->name);
return (-1);
}
if (data->arg2 != NULL) {
if (value != NULL) {
ctx->error(ctx, "value passed to unset option: %s", oe->name);
return (-1);
}
@ -197,39 +218,38 @@ cmd_set_option_unset(struct cmd *self, struct cmd_ctx *ctx,
/* Set an option. */
int
cmd_set_option_set(struct cmd *self, struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo)
const struct options_table_entry *oe, struct options *oo, const char *value)
{
struct cmd_target_data *data = self->data;
struct options_entry *o;
const char *s;
if (oe->type != OPTIONS_TABLE_FLAG && data->arg2 == NULL) {
ctx->error(ctx, "empty data->arg2");
if (oe->type != OPTIONS_TABLE_FLAG && value == NULL) {
ctx->error(ctx, "empty value");
return (-1);
}
o = NULL;
switch (oe->type) {
case OPTIONS_TABLE_STRING:
o = cmd_set_option_string(self, ctx, oe, oo);
o = cmd_set_option_string(self, ctx, oe, oo, value);
break;
case OPTIONS_TABLE_NUMBER:
o = cmd_set_option_number(self, ctx, oe, oo);
o = cmd_set_option_number(self, ctx, oe, oo, value);
break;
case OPTIONS_TABLE_KEYS:
o = cmd_set_option_keys(self, ctx, oe, oo);
o = cmd_set_option_keys(self, ctx, oe, oo, value);
break;
case OPTIONS_TABLE_COLOUR:
o = cmd_set_option_colour(self, ctx, oe, oo);
o = cmd_set_option_colour(self, ctx, oe, oo, value);
break;
case OPTIONS_TABLE_ATTRIBUTES:
o = cmd_set_option_attributes(self, ctx, oe, oo);
o = cmd_set_option_attributes(self, ctx, oe, oo, value);
break;
case OPTIONS_TABLE_FLAG:
o = cmd_set_option_flag(self, ctx, oe, oo);
o = cmd_set_option_flag(self, ctx, oe, oo, value);
break;
case OPTIONS_TABLE_CHOICE:
o = cmd_set_option_choice(self, ctx, oe, oo);
o = cmd_set_option_choice(self, ctx, oe, oo, value);
break;
}
if (o == NULL)
@ -243,37 +263,35 @@ cmd_set_option_set(struct cmd *self, struct cmd_ctx *ctx,
/* Set a string option. */
struct options_entry *
cmd_set_option_string(struct cmd *self, unused struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo)
const struct options_table_entry *oe, struct options *oo, const char *value)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct options_entry *o;
char *oldval, *newval;
if (cmd_check_flag(data->chflags, 'a')) {
if (args_has(args, 'a')) {
oldval = options_get_string(oo, oe->name);
xasprintf(&newval, "%s%s", oldval, data->arg2);
xasprintf(&newval, "%s%s", oldval, value);
} else
newval = data->arg2;
newval = xstrdup(value);
o = options_set_string(oo, oe->name, "%s", newval);
if (newval != data->arg2)
xfree(newval);
xfree(newval);
return (o);
}
/* Set a number option. */
struct options_entry *
cmd_set_option_number(struct cmd *self, struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo)
cmd_set_option_number(unused struct cmd *self, struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo, const char *value)
{
struct cmd_target_data *data = self->data;
long long ll;
const char *errstr;
long long ll;
const char *errstr;
ll = strtonum(data->arg2, oe->minimum, oe->maximum, &errstr);
ll = strtonum(value, oe->minimum, oe->maximum, &errstr);
if (errstr != NULL) {
ctx->error(ctx, "value is %s: %s", errstr, data->arg2);
ctx->error(ctx, "value is %s: %s", errstr, value);
return (NULL);
}
@ -282,18 +300,17 @@ cmd_set_option_number(struct cmd *self, struct cmd_ctx *ctx,
/* Set a keys option. */
struct options_entry *
cmd_set_option_keys(struct cmd *self, struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo)
cmd_set_option_keys(unused struct cmd *self, struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo, const char *value)
{
struct cmd_target_data *data = self->data;
struct keylist *keylist;
char *copy, *ptr, *s;
int key;
struct keylist *keylist;
char *copy, *ptr, *s;
int key;
keylist = xmalloc(sizeof *keylist);
ARRAY_INIT(keylist);
ptr = copy = xstrdup(data->arg2);
ptr = copy = xstrdup(value);
while ((s = strsep(&ptr, ",")) != NULL) {
if ((key = key_string_lookup_string(s)) == KEYC_NONE) {
ctx->error(ctx, "unknown key: %s", s);
@ -310,14 +327,13 @@ cmd_set_option_keys(struct cmd *self, struct cmd_ctx *ctx,
/* Set a colour option. */
struct options_entry *
cmd_set_option_colour(struct cmd *self, struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo)
cmd_set_option_colour(unused struct cmd *self, struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo, const char *value)
{
struct cmd_target_data *data = self->data;
int colour;
int colour;
if ((colour = colour_fromstring(data->arg2)) == -1) {
ctx->error(ctx, "bad colour: %s", data->arg2);
if ((colour = colour_fromstring(value)) == -1) {
ctx->error(ctx, "bad colour: %s", value);
return (NULL);
}
@ -326,14 +342,13 @@ cmd_set_option_colour(struct cmd *self, struct cmd_ctx *ctx,
/* Set an attributes option. */
struct options_entry *
cmd_set_option_attributes(struct cmd *self, struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo)
cmd_set_option_attributes(unused struct cmd *self, struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo, const char *value)
{
struct cmd_target_data *data = self->data;
int attr;
int attr;
if ((attr = attributes_fromstring(data->arg2)) == -1) {
ctx->error(ctx, "bad attributes: %s", data->arg2);
if ((attr = attributes_fromstring(value)) == -1) {
ctx->error(ctx, "bad attributes: %s", value);
return (NULL);
}
@ -342,25 +357,24 @@ cmd_set_option_attributes(struct cmd *self, struct cmd_ctx *ctx,
/* Set a flag option. */
struct options_entry *
cmd_set_option_flag(struct cmd *self, struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo)
cmd_set_option_flag(unused struct cmd *self, struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo, const char *value)
{
struct cmd_target_data *data = self->data;
int flag;
int flag;
if (data->arg2 == NULL || *data->arg2 == '\0')
if (value == NULL || *value == '\0')
flag = !options_get_number(oo, oe->name);
else {
if ((data->arg2[0] == '1' && data->arg2[1] == '\0') ||
strcasecmp(data->arg2, "on") == 0 ||
strcasecmp(data->arg2, "yes") == 0)
if ((value[0] == '1' && value[1] == '\0') ||
strcasecmp(value, "on") == 0 ||
strcasecmp(value, "yes") == 0)
flag = 1;
else if ((data->arg2[0] == '0' && data->arg2[1] == '\0') ||
strcasecmp(data->arg2, "off") == 0 ||
strcasecmp(data->arg2, "no") == 0)
else if ((value[0] == '0' && value[1] == '\0') ||
strcasecmp(value, "off") == 0 ||
strcasecmp(value, "no") == 0)
flag = 0;
else {
ctx->error(ctx, "bad value: %s", data->arg2);
ctx->error(ctx, "bad value: %s", value);
return (NULL);
}
}
@ -370,27 +384,26 @@ cmd_set_option_flag(struct cmd *self, struct cmd_ctx *ctx,
/* Set a choice option. */
struct options_entry *
cmd_set_option_choice(struct cmd *self, struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo)
cmd_set_option_choice(unused struct cmd *self, struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo, const char *value)
{
struct cmd_target_data *data = self->data;
const char **choicep;
int n, choice = -1;
const char **choicep;
int n, choice = -1;
n = 0;
for (choicep = oe->choices; *choicep != NULL; choicep++) {
n++;
if (strncmp(*choicep, data->arg2, strlen(data->arg2)) != 0)
if (strncmp(*choicep, value, strlen(value)) != 0)
continue;
if (choice != -1) {
ctx->error(ctx, "ambiguous value: %s", data->arg2);
ctx->error(ctx, "ambiguous value: %s", value);
return (NULL);
}
choice = n - 1;
}
if (choice == -1) {
ctx->error(ctx, "unknown value: %s", data->arg2);
ctx->error(ctx, "unknown value: %s", value);
return (NULL);
}

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

@ -1,4 +1,4 @@
/* $Id: cmd-set-window-option.c,v 1.43 2009-12-04 22:11:23 tcunha Exp $ */
/* $Id: cmd-set-window-option.c,v 1.44 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,20 +28,19 @@ int cmd_set_window_option_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_set_window_option_entry = {
"set-window-option", "setw",
"agt:u", 1, 2,
"[-agu] " CMD_TARGET_WINDOW_USAGE " option [value]",
CMD_ARG12, "agu",
0,
NULL,
cmd_target_parse,
cmd_set_window_option_exec,
cmd_target_free,
cmd_target_print
NULL,
cmd_set_window_option_exec
};
int
cmd_set_window_option_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
cmd_set_flag(&data->chflags, 'w');
args_set(args, 'w', NULL);
return (cmd_set_option_entry.exec(self, ctx));
}

31
cmd-show-buffer.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-show-buffer.c,v 1.13 2010-12-30 22:39:49 tcunha Exp $ */
/* $Id: cmd-show-buffer.c,v 1.14 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,37 +28,44 @@ int cmd_show_buffer_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_show_buffer_entry = {
"show-buffer", "showb",
"b:", 0, 0,
CMD_BUFFER_USAGE,
0, "",
cmd_buffer_init,
cmd_buffer_parse,
cmd_show_buffer_exec,
cmd_buffer_free,
cmd_buffer_print
0,
NULL,
NULL,
cmd_show_buffer_exec
};
int
cmd_show_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_buffer_data *data = self->data;
struct args *args = self->args;
struct session *s;
struct paste_buffer *pb;
char *in, *buf, *ptr;
int buffer;
char *in, *buf, *ptr, *cause;
size_t size, len;
u_int width;
if ((s = cmd_find_session(ctx, NULL)) == NULL)
return (-1);
if (data->buffer == -1) {
if (!args_has(args, 'b')) {
if ((pb = paste_get_top(&global_buffers)) == NULL) {
ctx->error(ctx, "no buffers");
return (-1);
}
} else {
pb = paste_get_index(&global_buffers, data->buffer);
buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
if (cause != NULL) {
ctx->error(ctx, "buffer %s", cause);
xfree(cause);
return (-1);
}
pb = paste_get_index(&global_buffers, buffer);
if (pb == NULL) {
ctx->error(ctx, "no buffer %d", data->buffer);
ctx->error(ctx, "no buffer %d", buffer);
return (-1);
}
}

25
cmd-show-environment.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-show-environment.c,v 1.2 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-show-environment.c,v 1.3 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -31,27 +31,26 @@ int cmd_show_environment_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_show_environment_entry = {
"show-environment", "showenv",
"gt:", 0, 0,
"[-g] " CMD_TARGET_SESSION_USAGE,
0, "g",
cmd_target_init,
cmd_target_parse,
cmd_show_environment_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_show_environment_exec
};
int
cmd_show_environment_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct session *s;
struct environ *env;
struct environ_entry *envent;
struct args *args = self->args;
struct session *s;
struct environ *env;
struct environ_entry *envent;
if (cmd_check_flag(data->chflags, 'g'))
if (args_has(self->args, 'g'))
env = &global_environ;
else {
if ((s = cmd_find_session(ctx, data->target)) == NULL)
if ((s = cmd_find_session(ctx, args_get(args, 't'))) == NULL)
return (-1);
env = &s->environ;
}

25
cmd-show-messages.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-show-messages.c,v 1.2 2009-12-04 22:14:47 tcunha Exp $ */
/* $Id: cmd-show-messages.c,v 1.3 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -31,25 +31,24 @@ int cmd_show_messages_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_show_messages_entry = {
"show-messages", "showmsgs",
"t:", 0, 0,
CMD_TARGET_CLIENT_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_show_messages_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_show_messages_exec
};
int
cmd_show_messages_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct client *c;
struct message_entry *msg;
char *tim;
u_int i;
struct args *args = self->args;
struct client *c;
struct message_entry *msg;
char *tim;
u_int i;
if ((c = cmd_find_client(ctx, data->target)) == NULL)
if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
return (-1);
for (i = 0; i < ARRAY_LENGTH(&c->message_log); i++) {

27
cmd-show-options.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-show-options.c,v 1.22 2011-01-03 23:52:38 tcunha Exp $ */
/* $Id: cmd-show-options.c,v 1.23 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -31,19 +31,18 @@ int cmd_show_options_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_show_options_entry = {
"show-options", "show",
"gst:w", 0, 0,
"[-gsw] [-t target-session|target-window]",
0, "gsw",
cmd_target_init,
cmd_target_parse,
cmd_show_options_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_show_options_exec
};
int
cmd_show_options_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
const struct options_table_entry *table, *oe;
struct session *s;
struct winlink *wl;
@ -51,25 +50,25 @@ cmd_show_options_exec(struct cmd *self, struct cmd_ctx *ctx)
struct options_entry *o;
const char *optval;
if (cmd_check_flag(data->chflags, 's')) {
if (args_has(self->args, 's')) {
oo = &global_options;
table = server_options_table;
} else if (cmd_check_flag(data->chflags, 'w')) {
} else if (args_has(self->args, 'w')) {
table = window_options_table;
if (cmd_check_flag(data->chflags, 'g'))
if (args_has(self->args, 'g'))
oo = &global_w_options;
else {
wl = cmd_find_window(ctx, data->target, NULL);
wl = cmd_find_window(ctx, args_get(args, 't'), NULL);
if (wl == NULL)
return (-1);
oo = &wl->window->options;
}
} else {
table = session_options_table;
if (cmd_check_flag(data->chflags, 'g'))
if (args_has(self->args, 'g'))
oo = &global_s_options;
else {
s = cmd_find_session(ctx, data->target);
s = cmd_find_session(ctx, args_get(args, 't'));
if (s == NULL)
return (-1);
oo = &s->options;

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

@ -1,4 +1,4 @@
/* $Id: cmd-show-window-options.c,v 1.15 2009-12-04 22:11:23 tcunha Exp $ */
/* $Id: cmd-show-window-options.c,v 1.16 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@ -31,20 +31,19 @@ int cmd_show_window_options_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_show_window_options_entry = {
"show-window-options", "showw",
"gt:", 0, 0,
"[-g] " CMD_TARGET_WINDOW_USAGE,
0, "g",
cmd_target_init,
cmd_target_parse,
cmd_show_window_options_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_show_window_options_exec
};
int
cmd_show_window_options_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
cmd_set_flag(&data->chflags, 'w');
args_set(args, 'w', NULL);
return (cmd_show_options_entry.exec(self, ctx));
}

99
cmd-source-file.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-source-file.c,v 1.14 2010-12-30 22:26:07 tcunha Exp $ */
/* $Id: cmd-source-file.c,v 1.15 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2008 Tiago Cunha <me@tiagocunha.org>
@ -24,80 +24,31 @@
* Sources a configuration file.
*/
int cmd_source_file_parse(struct cmd *, int, char **, char **);
int cmd_source_file_exec(struct cmd *, struct cmd_ctx *);
void cmd_source_file_free(struct cmd *);
void cmd_source_file_init(struct cmd *, int);
size_t cmd_source_file_print(struct cmd *, char *, size_t);
struct cmd_source_file_data {
char *path;
};
const struct cmd_entry cmd_source_file_entry = {
"source-file", "source",
"", 1, 1,
"path",
0, "",
cmd_source_file_init,
cmd_source_file_parse,
cmd_source_file_exec,
cmd_source_file_free,
cmd_source_file_print
0,
NULL,
NULL,
cmd_source_file_exec
};
/* ARGSUSED */
void
cmd_source_file_init(struct cmd *self, unused int arg)
{
struct cmd_source_file_data *data;
self->data = data = xmalloc(sizeof *data);
data->path = NULL;
}
int
cmd_source_file_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_source_file_data *data;
int opt;
self->entry->init(self, KEYC_NONE);
data = self->data;
while ((opt = getopt(argc, argv, "")) != -1) {
switch (opt) {
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (argc != 1)
goto usage;
data->path = xstrdup(argv[0]);
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
self->entry->free(self);
return (-1);
}
int
cmd_source_file_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_source_file_data *data = self->data;
struct causelist causes;
char *cause;
struct window_pane *wp;
int retval;
u_int i;
struct args *args = self->args;
struct causelist causes;
char *cause;
struct window_pane *wp;
int retval;
u_int i;
ARRAY_INIT(&causes);
retval = load_cfg(data->path, ctx, &causes);
retval = load_cfg(args->argv[0], ctx, &causes);
if (ARRAY_EMPTY(&causes))
return (retval);
@ -121,27 +72,3 @@ cmd_source_file_exec(struct cmd *self, struct cmd_ctx *ctx)
return (retval);
}
void
cmd_source_file_free(struct cmd *self)
{
struct cmd_source_file_data *data = self->data;
if (data->path != NULL)
xfree(data->path);
xfree(data);
}
size_t
cmd_source_file_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_source_file_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
if (off < len && data->path != NULL)
off += cmd_prarg(buf + off, len - off, " ", data->path);
return (off);
}

218
cmd-split-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-split-window.c,v 1.36 2011-01-03 23:29:09 tcunha Exp $ */
/* $Id: cmd-split-window.c,v 1.37 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -27,142 +27,44 @@
* Split a window (add a new pane).
*/
int cmd_split_window_parse(struct cmd *, int, char **, char **);
void cmd_split_window_key_binding(struct cmd *, int);
int cmd_split_window_exec(struct cmd *, struct cmd_ctx *);
void cmd_split_window_free(struct cmd *);
void cmd_split_window_init(struct cmd *, int);
size_t cmd_split_window_print(struct cmd *, char *, size_t);
struct cmd_split_window_data {
char *target;
char *cmd;
int flag_detached;
int flag_horizontal;
int flag_print;
int percentage;
int size;
};
const struct cmd_entry cmd_split_window_entry = {
"split-window", "splitw",
"dl:hp:Pt:v", 0, 1,
"[-dhvP] [-p percentage|-l size] [-t target-pane] [command]",
0, "",
cmd_split_window_init,
cmd_split_window_parse,
cmd_split_window_exec,
cmd_split_window_free,
cmd_split_window_print
0,
cmd_split_window_key_binding,
NULL,
cmd_split_window_exec
};
void
cmd_split_window_init(struct cmd *self, int key)
cmd_split_window_key_binding(struct cmd *self, int key)
{
struct cmd_split_window_data *data;
self->data = data = xmalloc(sizeof *data);
data->target = NULL;
data->cmd = NULL;
data->flag_detached = 0;
data->flag_horizontal = 0;
data->flag_print = 0;
data->percentage = -1;
data->size = -1;
switch (key) {
case '%':
data->flag_horizontal = 1;
break;
case '"':
data->flag_horizontal = 0;
break;
}
}
int
cmd_split_window_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_split_window_data *data;
int opt;
const char *errstr;
self->entry->init(self, KEYC_NONE);
data = self->data;
while ((opt = getopt(argc, argv, "dhl:p:Pt:v")) != -1) {
switch (opt) {
case 'd':
data->flag_detached = 1;
break;
case 'h':
data->flag_horizontal = 1;
break;
case 't':
if (data->target == NULL)
data->target = xstrdup(optarg);
break;
case 'l':
if (data->percentage != -1 || data->size != -1)
break;
data->size = strtonum(optarg, 1, INT_MAX, &errstr);
if (errstr != NULL) {
xasprintf(cause, "size %s", errstr);
goto error;
}
break;
case 'p':
if (data->size != -1 || data->percentage != -1)
break;
data->percentage = strtonum(optarg, 1, 100, &errstr);
if (errstr != NULL) {
xasprintf(cause, "percentage %s", errstr);
goto error;
}
break;
case 'P':
data->flag_print = 1;
break;
case 'v':
data->flag_horizontal = 0;
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (argc != 0 && argc != 1)
goto usage;
if (argc == 1)
data->cmd = xstrdup(argv[0]);
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
error:
self->entry->free(self);
return (-1);
self->args = args_create(0);
if (key == '%')
args_set(self->args, 'h', NULL);
}
int
cmd_split_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_split_window_data *data = self->data;
struct session *s;
struct winlink *wl;
struct window *w;
struct window_pane *wp, *new_wp = NULL;
struct environ env;
char *cmd, *cwd, *cause;
const char *shell;
u_int hlimit, paneidx;
int size;
enum layout_type type;
struct layout_cell *lc;
struct args *args = self->args;
struct session *s;
struct winlink *wl;
struct window *w;
struct window_pane *wp, *new_wp = NULL;
struct environ env;
char *cmd, *cwd, *cause;
const char *shell;
u_int hlimit, paneidx;
int size, percentage;
enum layout_type type;
struct layout_cell *lc;
if ((wl = cmd_find_pane(ctx, data->target, &s, &wp)) == NULL)
if ((wl = cmd_find_pane(ctx, args_get(args, 't'), &s, &wp)) == NULL)
return (-1);
w = wl->window;
@ -171,9 +73,10 @@ cmd_split_window_exec(struct cmd *self, struct cmd_ctx *ctx)
environ_copy(&s->environ, &env);
server_fill_environ(s, &env);
cmd = data->cmd;
if (cmd == NULL)
if (args->argc == 0)
cmd = options_get_string(&s->options, "default-command");
else
cmd = args->argv[0];
cwd = options_get_string(&s->options, "default-path");
if (*cwd == '\0') {
if (ctx->cmdclient != NULL && ctx->cmdclient->cwd != NULL)
@ -183,17 +86,28 @@ cmd_split_window_exec(struct cmd *self, struct cmd_ctx *ctx)
}
type = LAYOUT_TOPBOTTOM;
if (data->flag_horizontal)
if (args_has(args, 'h'))
type = LAYOUT_LEFTRIGHT;
size = -1;
if (data->size != -1)
size = data->size;
else if (data->percentage != -1) {
if (args_has(args, 's')) {
size = args_strtonum(args, 's', 0, INT_MAX, &cause);
if (cause != NULL) {
ctx->error(ctx, "size %s", cause);
xfree(cause);
return (-1);
}
} else if (args_has(args, 'p')) {
percentage = args_strtonum(args, 'p', 0, INT_MAX, &cause);
if (cause != NULL) {
ctx->error(ctx, "percentage %s", cause);
xfree(cause);
return (-1);
}
if (type == LAYOUT_TOPBOTTOM)
size = (wp->sy * data->percentage) / 100;
size = (wp->sy * percentage) / 100;
else
size = (wp->sx * data->percentage) / 100;
size = (wp->sx * percentage) / 100;
}
hlimit = options_get_number(&s->options, "history-limit");
@ -213,7 +127,7 @@ cmd_split_window_exec(struct cmd *self, struct cmd_ctx *ctx)
server_redraw_window(w);
if (!data->flag_detached) {
if (!args_has(args, 'd')) {
window_set_active_pane(w, new_wp);
session_select(s, wl->idx);
server_redraw_session(s);
@ -222,7 +136,7 @@ cmd_split_window_exec(struct cmd *self, struct cmd_ctx *ctx)
environ_free(&env);
if (data->flag_print) {
if (args_has(args, 'P')) {
paneidx = window_pane_index(wl->window, new_wp);
ctx->print(ctx, "%s:%u.%u", s->name, wl->idx, paneidx);
}
@ -236,43 +150,3 @@ error:
xfree(cause);
return (-1);
}
void
cmd_split_window_free(struct cmd *self)
{
struct cmd_split_window_data *data = self->data;
if (data->target != NULL)
xfree(data->target);
if (data->cmd != NULL)
xfree(data->cmd);
xfree(data);
}
size_t
cmd_split_window_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_split_window_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
if (off < len && data->flag_detached)
off += xsnprintf(buf + off, len - off, " -d");
if (off < len && data->flag_horizontal)
off += xsnprintf(buf + off, len - off, " -h");
if (off < len && data->flag_print)
off += xsnprintf(buf + off, len - off, " -P");
if (off < len && data->size > 0)
off += xsnprintf(buf + off, len - off, " -l %d", data->size);
if (off < len && data->percentage > 0) {
off += xsnprintf(
buf + off, len - off, " -p %d", data->percentage);
}
if (off < len && data->target != NULL)
off += cmd_prarg(buf + off, len - off, " -t ", data->target);
if (off < len && data->cmd != NULL)
off += cmd_prarg(buf + off, len - off, " ", data->cmd);
return (off);
}

9
cmd-start-server.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-start-server.c,v 1.10 2009-11-28 14:50:36 tcunha Exp $ */
/* $Id: cmd-start-server.c,v 1.11 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,13 +28,12 @@ int cmd_start_server_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_start_server_entry = {
"start-server", "start",
"", 0, 0,
"",
CMD_STARTSERVER, "",
CMD_STARTSERVER,
NULL,
NULL,
cmd_start_server_exec,
NULL,
NULL
cmd_start_server_exec
};
/* ARGSUSED */

19
cmd-suspend-client.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-suspend-client.c,v 1.6 2011-01-03 23:33:12 tcunha Exp $ */
/* $Id: cmd-suspend-client.c,v 1.7 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -31,22 +31,21 @@ int cmd_suspend_client_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_suspend_client_entry = {
"suspend-client", "suspendc",
"t:", 0, 0,
CMD_TARGET_CLIENT_USAGE,
0, "",
cmd_target_init,
cmd_target_parse,
cmd_suspend_client_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_suspend_client_exec
};
int
cmd_suspend_client_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct client *c;
struct args *args = self->args;
struct client *c;
if ((c = cmd_find_client(ctx, data->target)) == NULL)
if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
return (-1);
tty_stop_tty(&c->tty);

46
cmd-swap-pane.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-swap-pane.c,v 1.15 2009-12-04 22:14:47 tcunha Exp $ */
/* $Id: cmd-swap-pane.c,v 1.16 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@ -26,66 +26,58 @@
* Swap two panes.
*/
void cmd_swap_pane_init(struct cmd *, int);
void cmd_swap_pane_key_binding(struct cmd *, int);
int cmd_swap_pane_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_swap_pane_entry = {
"swap-pane", "swapp",
"dDs:t:U", 0, 0,
"[-dDU] " CMD_SRCDST_PANE_USAGE,
0, "dDU",
cmd_swap_pane_init,
cmd_srcdst_parse,
cmd_swap_pane_exec,
cmd_srcdst_free,
cmd_srcdst_print
0,
cmd_swap_pane_key_binding,
NULL,
cmd_swap_pane_exec
};
void
cmd_swap_pane_init(struct cmd *self, int key)
cmd_swap_pane_key_binding(struct cmd *self, int key)
{
struct cmd_target_data *data;
cmd_srcdst_init(self, key);
data = self->data;
self->args = args_create(0);
if (key == '{')
cmd_set_flag(&data->chflags, 'U');
args_set(self->args, 'U', NULL);
else if (key == '}')
cmd_set_flag(&data->chflags, 'D');
args_set(self->args, 'D', NULL);
}
int
cmd_swap_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_srcdst_data *data = self->data;
struct args *args = self->args;
struct winlink *src_wl, *dst_wl;
struct window *src_w, *dst_w;
struct window_pane *tmp_wp, *src_wp, *dst_wp;
struct layout_cell *src_lc, *dst_lc;
u_int sx, sy, xoff, yoff;
if (data == NULL)
return (0);
if ((dst_wl = cmd_find_pane(ctx, data->dst, NULL, &dst_wp)) == NULL)
dst_wl = cmd_find_pane(ctx, args_get(args, 't'), NULL, &dst_wp);
if (dst_wl == NULL)
return (-1);
dst_w = dst_wl->window;
if (data->src == NULL) {
if (!args_has(args, 's')) {
src_w = dst_w;
if (cmd_check_flag(data->chflags, 'D')) {
if (args_has(self->args, 'D')) {
src_wp = TAILQ_NEXT(dst_wp, entry);
if (src_wp == NULL)
src_wp = TAILQ_FIRST(&dst_w->panes);
} else if (cmd_check_flag(data->chflags, 'U')) {
} else if (args_has(self->args, 'U')) {
src_wp = TAILQ_PREV(dst_wp, window_panes, entry);
if (src_wp == NULL)
src_wp = TAILQ_LAST(&dst_w->panes, window_panes);
} else
return (0);
} else {
src_wl = cmd_find_pane(ctx, data->src, NULL, &src_wp);
src_wl = cmd_find_pane(ctx, args_get(args, 's'), NULL, &src_wp);
if (src_wl == NULL)
return (-1);
src_w = src_wl->window;
@ -121,7 +113,7 @@ cmd_swap_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
dst_wp->xoff = xoff; dst_wp->yoff = yoff;
window_pane_resize(dst_wp, sx, sy);
if (!cmd_check_flag(data->chflags, 'd')) {
if (!args_has(self->args, 'd')) {
if (src_w != dst_w) {
window_set_active_pane(src_w, dst_wp);
window_set_active_pane(dst_w, src_wp);

24
cmd-swap-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-swap-window.c,v 1.19 2009-11-14 17:56:39 tcunha Exp $ */
/* $Id: cmd-swap-window.c,v 1.20 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,27 +30,29 @@ int cmd_swap_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_swap_window_entry = {
"swap-window", "swapw",
"ds:t:", 0, 0,
"[-d] " CMD_SRCDST_WINDOW_USAGE,
0, "d",
cmd_srcdst_init,
cmd_srcdst_parse,
cmd_swap_window_exec,
cmd_srcdst_free,
cmd_srcdst_print
0,
NULL,
NULL,
cmd_swap_window_exec
};
int
cmd_swap_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_srcdst_data *data = self->data;
struct args *args = self->args;
const char *target_src, *target_dst;
struct session *src, *dst;
struct session_group *sg_src, *sg_dst;
struct winlink *wl_src, *wl_dst;
struct window *w;
if ((wl_src = cmd_find_window(ctx, data->src, &src)) == NULL)
target_src = args_get(args, 's');
if ((wl_src = cmd_find_window(ctx, target_src, &src)) == NULL)
return (-1);
if ((wl_dst = cmd_find_window(ctx, data->dst, &dst)) == NULL)
target_dst = args_get(args, 't');
if ((wl_dst = cmd_find_window(ctx, target_dst, &dst)) == NULL)
return (-1);
sg_src = session_group_find(src);
@ -68,7 +70,7 @@ cmd_swap_window_exec(struct cmd *self, struct cmd_ctx *ctx)
wl_dst->window = wl_src->window;
wl_src->window = w;
if (!cmd_check_flag(data->chflags, 'd')) {
if (!args_has(self->args, 'd')) {
session_select(dst, wl_dst->idx);
if (src != dst)
session_select(src, wl_src->idx);

154
cmd-switch-client.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-switch-client.c,v 1.24 2011-01-03 23:27:54 tcunha Exp $ */
/* $Id: cmd-switch-client.c,v 1.25 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -27,138 +27,58 @@
* Switch client to a different session.
*/
void cmd_switch_client_init(struct cmd *, int);
int cmd_switch_client_parse(struct cmd *, int, char **, char **);
void cmd_switch_client_key_binding(struct cmd *, int);
int cmd_switch_client_exec(struct cmd *, struct cmd_ctx *);
void cmd_switch_client_free(struct cmd *);
size_t cmd_switch_client_print(struct cmd *, char *, size_t);
struct cmd_switch_client_data {
char *name;
char *target;
int flag_last;
int flag_next;
int flag_previous;
};
const struct cmd_entry cmd_switch_client_entry = {
"switch-client", "switchc",
"lc:npt:", 0, 0,
"[-lnp] [-c target-client] [-t target-session]",
0, "",
cmd_switch_client_init,
cmd_switch_client_parse,
cmd_switch_client_exec,
cmd_switch_client_free,
cmd_switch_client_print
0,
cmd_switch_client_key_binding,
NULL,
cmd_switch_client_exec
};
void
cmd_switch_client_init(struct cmd *self, int key)
cmd_switch_client_key_binding(struct cmd *self, int key)
{
struct cmd_switch_client_data *data;
self->data = data = xmalloc(sizeof *data);
data->name = NULL;
data->target = NULL;
data->flag_last = 0;
data->flag_next = 0;
data->flag_previous = 0;
self->args = args_create(0);
switch (key) {
case '(':
data->flag_previous = 1;
args_set(self->args, 'p', NULL);
break;
case ')':
data->flag_next = 1;
args_set(self->args, 'n', NULL);
break;
case 'L':
data->flag_last = 1;
args_set(self->args, 'l', NULL);
break;
}
}
int
cmd_switch_client_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_switch_client_data *data;
int opt;
self->entry->init(self, KEYC_NONE);
data = self->data;
while ((opt = getopt(argc, argv, "c:lnpt:")) != -1) {
switch (opt) {
case 'c':
if (data->name == NULL)
data->name = xstrdup(optarg);
break;
case 'l':
if (data->flag_next || data->flag_previous ||
data->target != NULL)
goto usage;
data->flag_last = 1;
break;
case 'n':
if (data->flag_previous || data->flag_last ||
data->target != NULL)
goto usage;
data->flag_next = 1;
break;
case 'p':
if (data->flag_next || data->flag_last ||
data->target != NULL)
goto usage;
data->flag_next = 1;
break;
case 't':
if (data->flag_next || data->flag_previous)
goto usage;
if (data->target == NULL)
data->target = xstrdup(optarg);
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (argc != 0)
goto usage;
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
self->entry->free(self);
return (-1);
}
int
cmd_switch_client_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_switch_client_data *data = self->data;
struct client *c;
struct session *s;
struct args *args = self->args;
struct client *c;
struct session *s;
if (data == NULL)
return (0);
if ((c = cmd_find_client(ctx, data->name)) == NULL)
if ((c = cmd_find_client(ctx, args_get(args, 'c'))) == NULL)
return (-1);
s = NULL;
if (data->flag_next) {
if (args_has(args, 'n')) {
if ((s = session_next_session(c->session)) == NULL) {
ctx->error(ctx, "can't find next session");
return (-1);
}
} else if (data->flag_previous) {
} else if (args_has(args, 'p')) {
if ((s = session_previous_session(c->session)) == NULL) {
ctx->error(ctx, "can't find previous session");
return (-1);
}
} else if (data->flag_last) {
} else if (args_has(args, 'l')) {
if (c->last_session != NULL && session_alive(c->last_session))
s = c->last_session;
if (s == NULL) {
@ -166,7 +86,7 @@ cmd_switch_client_exec(struct cmd *self, struct cmd_ctx *ctx)
return (-1);
}
} else
s = cmd_find_session(ctx, data->target);
s = cmd_find_session(ctx, args_get(args, 't'));
if (s == NULL)
return (-1);
@ -181,37 +101,3 @@ cmd_switch_client_exec(struct cmd *self, struct cmd_ctx *ctx)
return (0);
}
void
cmd_switch_client_free(struct cmd *self)
{
struct cmd_switch_client_data *data = self->data;
if (data->name != NULL)
xfree(data->name);
if (data->target != NULL)
xfree(data->target);
xfree(data);
}
size_t
cmd_switch_client_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_switch_client_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
if (off < len && data->flag_last)
off += xsnprintf(buf + off, len - off, "%s", " -l");
if (off < len && data->flag_next)
off += xsnprintf(buf + off, len - off, "%s", " -n");
if (off < len && data->flag_previous)
off += xsnprintf(buf + off, len - off, "%s", " -p");
if (off < len && data->name != NULL)
off += cmd_prarg(buf + off, len - off, " -c ", data->name);
if (off < len && data->target != NULL)
off += cmd_prarg(buf + off, len - off, " -t ", data->target);
return (off);
}

130
cmd-unbind-key.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-unbind-key.c,v 1.23 2010-12-06 21:51:02 nicm Exp $ */
/* $Id: cmd-unbind-key.c,v 1.24 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -24,140 +24,80 @@
* Unbind key from command.
*/
int cmd_unbind_key_parse(struct cmd *, int, char **, char **);
int cmd_unbind_key_check(struct args *);
int cmd_unbind_key_exec(struct cmd *, struct cmd_ctx *);
void cmd_unbind_key_free(struct cmd *);
int cmd_unbind_key_table(struct cmd *, struct cmd_ctx *);
struct cmd_unbind_key_data {
int key;
int flag_all;
int command_key;
char *tablename;
};
int cmd_unbind_key_table(struct cmd *, struct cmd_ctx *, int);
const struct cmd_entry cmd_unbind_key_entry = {
"unbind-key", "unbind",
"acnt:", 1, 1,
"[-acn] [-t key-table] key",
0, "",
0,
NULL,
cmd_unbind_key_parse,
cmd_unbind_key_exec,
cmd_unbind_key_free,
NULL
cmd_unbind_key_check,
cmd_unbind_key_exec
};
int
cmd_unbind_key_parse(struct cmd *self, int argc, char **argv, char **cause)
cmd_unbind_key_check(struct args *args)
{
struct cmd_unbind_key_data *data;
int opt, no_prefix = 0;
self->data = data = xmalloc(sizeof *data);
data->flag_all = 0;
data->command_key = 0;
data->tablename = NULL;
while ((opt = getopt(argc, argv, "acnt:")) != -1) {
switch (opt) {
case 'a':
data->flag_all = 1;
break;
case 'c':
data->command_key = 1;
break;
case 'n':
no_prefix = 1;
break;
case 't':
if (data->tablename == NULL)
data->tablename = xstrdup(optarg);
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (data->flag_all && (argc != 0 || data->tablename))
goto usage;
if (!data->flag_all && argc != 1)
goto usage;
if (!data->flag_all) {
data->key = key_string_lookup_string(argv[0]);
if (data->key == KEYC_NONE) {
xasprintf(cause, "unknown key: %s", argv[0]);
goto error;
}
if (!no_prefix)
data->key |= KEYC_PREFIX;
}
if (args_has(args, 'a') && (args->argc != 0 || args_has(args, 't')))
return (-1);
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
error:
xfree(data);
return (-1);
}
int
cmd_unbind_key_exec(struct cmd *self, unused struct cmd_ctx *ctx)
{
struct cmd_unbind_key_data *data = self->data;
struct key_binding *bd;
struct args *args = self->args;
struct key_binding *bd;
int key;
if (data == NULL)
return (0);
if (data->flag_all) {
if (args_has(args, 'a')) {
while (!SPLAY_EMPTY(&key_bindings)) {
bd = SPLAY_ROOT(&key_bindings);
SPLAY_REMOVE(key_bindings, &key_bindings, bd);
cmd_list_free(bd->cmdlist);
xfree(bd);
}
} else {
if (data->tablename != NULL)
return (cmd_unbind_key_table(self, ctx));
key_bindings_remove(data->key);
return (0);
}
key = key_string_lookup_string(args->argv[0]);
if (key == KEYC_NONE) {
ctx->error(ctx, "unknown key: %s", args->argv[0]);
return (-1);
}
if (args_has(args, 't'))
return (cmd_unbind_key_table(self, ctx, key));
if (!args_has(args, 'n'))
key |= KEYC_PREFIX;
key_bindings_remove(key);
return (0);
}
int
cmd_unbind_key_table(struct cmd *self, struct cmd_ctx *ctx)
cmd_unbind_key_table(struct cmd *self, struct cmd_ctx *ctx, int key)
{
struct cmd_unbind_key_data *data = self->data;
struct args *args = self->args;
const char *tablename;
const struct mode_key_table *mtab;
struct mode_key_binding *mbind, mtmp;
if ((mtab = mode_key_findtable(data->tablename)) == NULL) {
ctx->error(ctx, "unknown key table: %s", data->tablename);
tablename = args_get(args, 't');
if ((mtab = mode_key_findtable(tablename)) == NULL) {
ctx->error(ctx, "unknown key table: %s", tablename);
return (-1);
}
mtmp.key = data->key & ~KEYC_PREFIX;
mtmp.mode = data->command_key ? 1 : 0;
mtmp.key = key;
mtmp.mode = !!args_has(args, 'c');
if ((mbind = SPLAY_FIND(mode_key_tree, mtab->tree, &mtmp)) != NULL) {
SPLAY_REMOVE(mode_key_tree, mtab->tree, mbind);
xfree(mbind);
}
return (0);
}
void
cmd_unbind_key_free(struct cmd *self)
{
struct cmd_unbind_key_data *data = self->data;
if (data->tablename != NULL)
xfree(data->tablename);
xfree(data);
}

19
cmd-unlink-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-unlink-window.c,v 1.21 2009-12-04 22:14:47 tcunha Exp $ */
/* $Id: cmd-unlink-window.c,v 1.22 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,26 +28,25 @@ int cmd_unlink_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_unlink_window_entry = {
"unlink-window", "unlinkw",
"kt:", 0, 0,
"[-k] " CMD_TARGET_WINDOW_USAGE,
0, "k",
cmd_target_init,
cmd_target_parse,
cmd_unlink_window_exec,
cmd_target_free,
cmd_target_print
0,
NULL,
NULL,
cmd_unlink_window_exec
};
int
cmd_unlink_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct args *args = self->args;
struct winlink *wl;
struct window *w;
struct session *s, *s2;
struct session_group *sg;
u_int references;
if ((wl = cmd_find_window(ctx, data->target, &s)) == NULL)
if ((wl = cmd_find_window(ctx, args_get(args, 't'), &s)) == NULL)
return (-1);
w = wl->window;
@ -59,7 +58,7 @@ cmd_unlink_window_exec(struct cmd *self, struct cmd_ctx *ctx)
} else
references = 1;
if (!cmd_check_flag(data->chflags, 'k') && w->references == references) {
if (!args_has(self->args, 'k') && w->references == references) {
ctx->error(ctx, "window is only linked to one session");
return (-1);
}

60
cmd.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd.c,v 1.147 2010-12-30 22:39:49 tcunha Exp $ */
/* $Id: cmd.c,v 1.148 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -166,7 +166,7 @@ cmd_unpack_argv(char *buf, size_t len, int argc, char ***argv)
}
char **
cmd_copy_argv(int argc, char **argv)
cmd_copy_argv(int argc, char *const *argv)
{
char **new_argv;
int i;
@ -200,8 +200,9 @@ cmd_parse(int argc, char **argv, char **cause)
{
const struct cmd_entry **entryp, *entry;
struct cmd *cmd;
struct args *args;
char s[BUFSIZ];
int opt, ambiguous = 0;
int ambiguous = 0;
*cause = NULL;
if (argc == 0) {
@ -235,30 +236,19 @@ cmd_parse(int argc, char **argv, char **cause)
return (NULL);
}
optreset = 1;
optind = 1;
if (entry->parse == NULL) {
while ((opt = getopt(argc, argv, "")) != -1) {
switch (opt) {
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (argc != 0)
goto usage;
}
args = args_parse(entry->args_template, argc, argv);
if (args == NULL)
goto usage;
if (entry->args_lower != -1 && args->argc < entry->args_lower)
goto usage;
if (entry->args_upper != -1 && args->argc > entry->args_upper)
goto usage;
if (entry->check != NULL && entry->check(args) != 0)
goto usage;
cmd = xmalloc(sizeof *cmd);
cmd->entry = entry;
cmd->data = NULL;
if (entry->parse != NULL) {
if (entry->parse(cmd, argc, argv, cause) != 0) {
xfree(cmd);
return (NULL);
}
}
cmd->args = args;
return (cmd);
ambiguous:
@ -276,6 +266,8 @@ ambiguous:
return (NULL);
usage:
if (args != NULL)
args_free(args);
xasprintf(cause, "usage: %s %s", entry->name, entry->usage);
return (NULL);
}
@ -289,17 +281,27 @@ cmd_exec(struct cmd *cmd, struct cmd_ctx *ctx)
void
cmd_free(struct cmd *cmd)
{
if (cmd->data != NULL && cmd->entry->free != NULL)
cmd->entry->free(cmd);
if (cmd->args != NULL)
args_free(cmd->args);
xfree(cmd);
}
size_t
cmd_print(struct cmd *cmd, char *buf, size_t len)
{
if (cmd->entry->print == NULL)
return (xsnprintf(buf, len, "%s", cmd->entry->name));
return (cmd->entry->print(cmd, buf, len));
size_t off, used;
off = xsnprintf(buf, len, "%s ", cmd->entry->name);
if (off < len) {
used = args_print(cmd->args, buf + off, len - off);
if (used == 0)
buf[off - 1] = '\0';
else {
off += used;
buf[off] = '\0';
}
}
return (off);
}
/*

9
key-bindings.c
View File

@ -1,4 +1,4 @@
/* $Id: key-bindings.c,v 1.97 2010-12-11 18:42:20 nicm Exp $ */
/* $Id: key-bindings.c,v 1.98 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -187,9 +187,10 @@ key_bindings_init(void)
cmd = xmalloc(sizeof *cmd);
cmd->entry = table[i].entry;
cmd->data = NULL;
if (cmd->entry->init != NULL)
cmd->entry->init(cmd, table[i].key);
if (cmd->entry->key_binding != NULL)
cmd->entry->key_binding(cmd, table[i].key);
else
cmd->args = args_create(0);
TAILQ_INSERT_HEAD(&cmdlist->list, cmd, qentry);
key_bindings_add(

119
tmux.h
View File

@ -1,4 +1,4 @@
/* $Id: tmux.h,v 1.601 2011-01-07 14:34:45 tcunha Exp $ */
/* $Id: tmux.h,v 1.602 2011-01-07 14:45:34 tcunha Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -1164,6 +1164,15 @@ struct client {
};
ARRAY_DECL(clients, struct client *);
/* Parsed arguments. */
struct args {
bitstr_t *flags;
char *values[SCHAR_MAX]; /* XXX This is awfully big. */
int argc;
char **argv;
};
/* Key/command line command. */
struct cmd_ctx {
/*
@ -1194,67 +1203,35 @@ struct cmd_ctx {
};
struct cmd {
const struct cmd_entry *entry;
void *data;
const struct cmd_entry *entry;
struct args *args;
TAILQ_ENTRY(cmd) qentry;
TAILQ_ENTRY(cmd) qentry;
};
struct cmd_list {
int references;
TAILQ_HEAD(, cmd) list;
int references;
TAILQ_HEAD(, cmd) list;
};
struct cmd_entry {
const char *name;
const char *alias;
const char *args_template;
int args_lower;
int args_upper;
const char *usage;
#define CMD_STARTSERVER 0x1
#define CMD_CANTNEST 0x2
#define CMD_SENDENVIRON 0x4
#define CMD_ARG1 0x8
#define CMD_ARG01 0x10
#define CMD_ARG2 0x20
#define CMD_ARG12 0x40
#define CMD_READONLY 0x80
#define CMD_READONLY 0x8
int flags;
const char *chflags;
void (*init)(struct cmd *, int);
int (*parse)(struct cmd *, int, char **, char **);
void (*key_binding)(struct cmd *, int);
int (*check)(struct args *);
int (*exec)(struct cmd *, struct cmd_ctx *);
void (*free)(struct cmd *);
size_t (*print)(struct cmd *, char *, size_t);
};
/* Generic command data. */
struct cmd_target_data {
uint64_t chflags;
char *target;
char *arg;
char *arg2;
};
struct cmd_srcdst_data {
uint64_t chflags;
char *src;
char *dst;
char *arg;
char *arg2;
};
struct cmd_buffer_data {
uint64_t chflags;
int buffer;
char *arg;
char *arg2;
};
/* Key binding. */
@ -1297,6 +1274,17 @@ struct options_table_entry {
/* List of configuration causes. */
ARRAY_DECL(causelist, char *);
/* Common command usages. */
#define CMD_TARGET_PANE_USAGE "[-t target-pane]"
#define CMD_TARGET_WINDOW_USAGE "[-t target-window]"
#define CMD_TARGET_SESSION_USAGE "[-t target-session]"
#define CMD_TARGET_CLIENT_USAGE "[-t target-client]"
#define CMD_SRCDST_PANE_USAGE "[-s src-pane] [-t dst-pane]"
#define CMD_SRCDST_WINDOW_USAGE "[-s src-window] [-t dst-window]"
#define CMD_SRCDST_SESSION_USAGE "[-s src-session] [-t dst-session]"
#define CMD_SRCDST_CLIENT_USAGE "[-s src-client] [-t dst-client]"
#define CMD_BUFFER_USAGE "[-b buffer-index]"
/* tmux.c */
extern struct options global_options;
extern struct options global_s_options;
@ -1475,10 +1463,21 @@ char *paste_print(struct paste_buffer *, size_t);
extern const char clock_table[14][5][5];
void clock_draw(struct screen_write_ctx *, int, int);
/* arguments.c */
struct args *args_create(int, ...);
struct args *args_parse(const char *, int, char **);
void args_free(struct args *);
size_t args_print(struct args *, char *, size_t);
int args_has(struct args *, u_char);
void args_set(struct args *, u_char, const char *);
const char *args_get(struct args *, u_char);
long long args_strtonum(
struct args *, u_char, long long, long long, char **);
/* cmd.c */
int cmd_pack_argv(int, char **, char *, size_t);
int cmd_unpack_argv(char *, size_t, int, char ***);
char **cmd_copy_argv(int, char **);
char **cmd_copy_argv(int, char *const *);
void cmd_free_argv(int, char **);
struct cmd *cmd_parse(int, char **, char **);
int cmd_exec(struct cmd *, struct cmd_ctx *);
@ -1588,32 +1587,6 @@ size_t cmd_list_print(struct cmd_list *, char *, size_t);
/* cmd-string.c */
int cmd_string_parse(const char *, struct cmd_list **, char **);
/* cmd-generic.c */
size_t cmd_prarg(char *, size_t, const char *, char *);
int cmd_check_flag(uint64_t, int);
void cmd_set_flag(uint64_t *, int);
#define CMD_TARGET_PANE_USAGE "[-t target-pane]"
#define CMD_TARGET_WINDOW_USAGE "[-t target-window]"
#define CMD_TARGET_SESSION_USAGE "[-t target-session]"
#define CMD_TARGET_CLIENT_USAGE "[-t target-client]"
void cmd_target_init(struct cmd *, int);
int cmd_target_parse(struct cmd *, int, char **, char **);
void cmd_target_free(struct cmd *);
size_t cmd_target_print(struct cmd *, char *, size_t);
#define CMD_SRCDST_PANE_USAGE "[-s src-pane] [-t dst-pane]"
#define CMD_SRCDST_WINDOW_USAGE "[-s src-window] [-t dst-window]"
#define CMD_SRCDST_SESSION_USAGE "[-s src-session] [-t dst-session]"
#define CMD_SRCDST_CLIENT_USAGE "[-s src-client] [-t dst-client]"
void cmd_srcdst_init(struct cmd *, int);
int cmd_srcdst_parse(struct cmd *, int, char **, char **);
void cmd_srcdst_free(struct cmd *);
size_t cmd_srcdst_print(struct cmd *, char *, size_t);
#define CMD_BUFFER_USAGE "[-b buffer-index]"
void cmd_buffer_init(struct cmd *, int);
int cmd_buffer_parse(struct cmd *, int, char **, char **);
void cmd_buffer_free(struct cmd *);
size_t cmd_buffer_print(struct cmd *, char *, size_t);
/* client.c */
int client_main(int, char **, int);