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

Big reorganisation of command-line syntax.

pull/1/head
Nicholas Marriott 2008-06-05 21:25:00 +00:00
parent ee1a7fded7
commit 0b9b873a55
42 changed files with 963 additions and 1574 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
CHANGES
View File

@ -1,5 +1,26 @@
05 June 2008
* Completely reorganise command parsing. Much more common code in cmd-generic.c
and a new way of specifying windows, clients or sessions. Now, most commands
take a -t argument, which specifies a client, a session, or a window target.
Clients and sessions are given alone (sessions are fnmatch(3)d and
clients currently not), windows are give by (client|session):index. For
example, if a user is in session "1" window 0 on /dev/ttypi, these should all
be equivalent:
tmux renamew newname (current session and window)
tmux renamew -t: newname (current session and window)
tmux renamew -t:0 newname (current session, window 0)
tmux renamew -t0 newname (current session, window 0)
tmux renamew -t1:0 newname (session 1, window 0)
tmux renamew -t1: newname (session 1, current window)
tmux renamew -t/dev/ttypi newname (client /dev/ttypi's current
session and window)
tmux renamew -t/dev/ttypi: newname (client /dev/ttypi's current
session and window)
tmux renamew -t/dev/ttypi:0 newname (client /dev/ttypi's current
session, window 0)
* Infrastructure for printing arguments in list-keys output. Easy ones only for
now.
@ -408,4 +429,4 @@
(including mutt, emacs). No status bar yet and no key remapping or other
customisation.
$Id: CHANGES,v 1.110 2008-06-05 16:35:31 nicm Exp $
$Id: CHANGES,v 1.111 2008-06-05 21:24:59 nicm Exp $

4
GNUmakefile
View File

@ -1,4 +1,4 @@
# $Id: GNUmakefile,v 1.15 2008-06-05 05:04:47 nicm Exp $
# $Id: GNUmakefile,v 1.16 2008-06-05 21:25:00 nicm Exp $
.PHONY: clean
@ -14,7 +14,7 @@ META?= \002
SRCS= tmux.c server.c server-msg.c server-fn.c buffer.c buffer-poll.c status.c \
xmalloc.c xmalloc-debug.c input.c input-keys.c screen.c screen-display.c \
window.c session.c log.c client.c client-msg.c client-fn.c cfg.c \
key-string.c key-bindings.c resize.c cmd.c cmd-generic.c \
key-string.c key-bindings.c resize.c arg.c cmd.c cmd-generic.c \
cmd-detach-client.c cmd-list-sessions.c cmd-new-window.c cmd-bind-key.c \
cmd-unbind-key.c cmd-previous-window.c cmd-last-window.c cmd-list-keys.c \
cmd-set-option.c cmd-rename-window.c cmd-select-window.c \

4
Makefile
View File

@ -1,4 +1,4 @@
# $Id: Makefile,v 1.58 2008-06-04 17:54:26 nicm Exp $
# $Id: Makefile,v 1.59 2008-06-05 21:25:00 nicm Exp $
.SUFFIXES: .c .o .y .h
.PHONY: clean update-index.html upload-index.html
@ -18,7 +18,7 @@ META?= \002 # C-b
SRCS= tmux.c server.c server-msg.c server-fn.c buffer.c buffer-poll.c status.c \
xmalloc.c xmalloc-debug.c input.c input-keys.c screen.c screen-display.c \
window.c session.c log.c client.c client-msg.c client-fn.c cfg.c \
key-string.c key-bindings.c resize.c cmd.c cmd-generic.c \
key-string.c key-bindings.c resize.c arg.c cmd.c cmd-generic.c \
cmd-detach-client.c cmd-list-sessions.c cmd-new-window.c cmd-bind-key.c \
cmd-unbind-key.c cmd-previous-window.c cmd-last-window.c cmd-list-keys.c \
cmd-set-option.c cmd-rename-window.c cmd-select-window.c \

8
TODO
View File

@ -83,11 +83,3 @@
- each command should have a print op as well for list keys
- fix occasion start server problems
- test and fix wsvt25
- look again at stuff that doesn't use flags
swap-window
switch-client
audit for lookup window
link-window
look for dstidx
also lookup dstsess with find_session
---

192
arg.c Normal file
View File

@ -0,0 +1,192 @@
/* $Id: arg.c,v 1.1 2008-06-05 21:25:00 nicm 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 <fnmatch.h>
#include <stdlib.h>
#include <string.h>
#include "tmux.h"
struct client *arg_lookup_client(const char *);
struct session *arg_lookup_session(const char *);
struct client *
arg_lookup_client(const char *name)
{
struct client *c;
u_int i;
for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
c = ARRAY_ITEM(&clients, i);
if (c != NULL && strcmp(name, c->tty.path) == 0)
return (c);
}
return (NULL);
}
struct session *
arg_lookup_session(const char *name)
{
struct session *s, *newest = NULL;
struct timespec *ts;
u_int i;
ts = NULL;
for (i = 0; i < ARRAY_LENGTH(&sessions); i++) {
s = ARRAY_ITEM(&sessions, i);
if (s == NULL || fnmatch(name, s->name, 0) != 0)
continue;
if (ts == NULL || timespeccmp(&s->ts, ts, >)) {
newest = s;
ts = &s->ts;
}
}
return (newest);
}
struct client *
arg_parse_client(const char *arg)
{
struct client *c;
char *arg2;
size_t n;
if (arg != NULL && (arg[0] != ':' || arg[1] != '\0')) {
arg2 = xstrdup(arg);
/* Trim a trailing : if any from the argument. */
n = strlen(arg2);
if (arg2[n - 1] == ':')
arg2[n - 1] = '\0';
/* Try and lookup the client name. */
c = arg_lookup_client(arg2);
xfree(arg2);
return (c);
}
return (NULL);
}
struct session *
arg_parse_session(const char *arg)
{
struct session *s;
struct client *c;
char *arg2;
size_t n;
if (arg != NULL && (arg[0] != ':' || arg[1] != '\0')) {
arg2 = xstrdup(arg);
/* Trim a trailing : if any from the argument. */
n = strlen(arg2);
if (arg2[n - 1] == ':')
arg2[n - 1] = '\0';
/* See if the argument matches a session. */
if ((s = arg_lookup_session(arg2)) != NULL) {
xfree(arg2);
return (s);
}
/* If not try a client. */
if ((c = arg_lookup_client(arg2)) != NULL) {
xfree(arg2);
return (c->session);
}
}
return (NULL);
}
int
arg_parse_window(const char *arg, struct session **s, int *idx)
{
char *arg2, *ptr;
const char *errstr;
*idx = -1;
/* Handle no argument or a single :. */
if (arg == NULL || (arg[0] == ':' && arg[1] == '\0')) {
*s = arg_parse_session(NULL);
return (0);
}
/* Find the separator if any. */
arg2 = xstrdup(arg);
ptr = strrchr(arg2, ':');
/*
* If it is first, this means no session name, so use current session
* and try to convert the rest as index.
*/
if (ptr == arg2) {
*idx = strtonum(ptr + 1, 0, INT_MAX, &errstr);
if (errstr != NULL) {
xfree(arg2);
return (1);
}
xfree(arg2);
*s = arg_parse_session(NULL);
return (0);
}
/* If missing, try as an index, else lookup immediately. */
if (ptr == NULL) {
*idx = strtonum(arg2, 0, INT_MAX, &errstr);
if (errstr == NULL) {
/* This is good as an index; use current session. */
xfree(arg2);
*s = arg_parse_session(NULL);
return (0);
}
*idx = -1;
goto lookup;
}
/* If last, strip it and look up as a session. */
if (ptr[1] == '\0') {
*ptr = '\0';
goto lookup;
}
/* Present but not first and not last. Break and convert both. */
*ptr = '\0';
*idx = strtonum(ptr + 1, 0, INT_MAX, &errstr);
if (errstr != NULL) {
xfree(arg2);
return (1);
}
lookup:
/* Look up as session. */
*s = arg_parse_session(arg2);
xfree(arg2);
if (*s == NULL)
return (1);
return (0);
}

136
cmd-attach-session.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-attach-session.c,v 1.17 2008-06-05 17:12:10 nicm Exp $ */
/* $Id: cmd-attach-session.c,v 1.18 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -26,89 +26,32 @@
* Attach existing session to the current terminal.
*/
int cmd_attach_session_parse(struct cmd *, int, char **, char **);
void cmd_attach_session_exec(struct cmd *, struct cmd_ctx *);
void cmd_attach_session_send(struct cmd *, struct buffer *);
void cmd_attach_session_recv(struct cmd *, struct buffer *);
void cmd_attach_session_free(struct cmd *);
void cmd_attach_session_print(struct cmd *, char *, size_t);
struct cmd_attach_session_data {
char *cname;
char *sname;
int flag_detach;
};
const struct cmd_entry cmd_attach_session_entry = {
"attach-session", "attach",
"[-d] [-c client-tty|-s session-name]",
CMD_CANTNEST,
cmd_attach_session_parse,
"[-d] " CMD_TARGET_SESSION_USAGE,
CMD_DFLAG|CMD_CANTNEST,
cmd_target_init,
cmd_target_parse,
cmd_attach_session_exec,
cmd_attach_session_send,
cmd_attach_session_recv,
cmd_attach_session_free,
NULL,
cmd_attach_session_print
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
int
cmd_attach_session_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_attach_session_data *data;
int opt;
self->data = data = xmalloc(sizeof *data);
data->cname = NULL;
data->sname = NULL;
data->flag_detach = 0;
while ((opt = getopt(argc, argv, "c:ds:")) != EOF) {
switch (opt) {
case 'c':
if (data->sname != NULL)
goto usage;
if (data->cname == NULL)
data->cname = xstrdup(optarg);
break;
case 'd':
data->flag_detach = 1;
break;
case 's':
if (data->cname != NULL)
goto usage;
if (data->sname == NULL)
data->sname = 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);
}
void
cmd_attach_session_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_attach_session_data *data = self->data;
struct session *s;
char *cause;
struct cmd_target_data *data = self->data;
struct session *s;
char *cause;
if (ctx->flags & CMD_KEY)
return;
if ((s = cmd_find_session(ctx, data->cname, data->sname)) == NULL)
if ((s = cmd_find_session(ctx, data->target)) == NULL)
return;
if (!(ctx->cmdclient->flags & CLIENT_TERMINAL)) {
@ -122,7 +65,7 @@ cmd_attach_session_exec(struct cmd *self, struct cmd_ctx *ctx)
return;
}
if (data->flag_detach)
if (data->flags & CMD_DFLAG)
server_write_session(s, MSG_DETACH, NULL, 0);
ctx->cmdclient->session = s;
@ -131,52 +74,3 @@ cmd_attach_session_exec(struct cmd *self, struct cmd_ctx *ctx)
server_redraw_client(ctx->cmdclient);
}
void
cmd_attach_session_send(struct cmd *self, struct buffer *b)
{
struct cmd_attach_session_data *data = self->data;
buffer_write(b, data, sizeof *data);
cmd_send_string(b, data->cname);
cmd_send_string(b, data->sname);
}
void
cmd_attach_session_recv(struct cmd *self, struct buffer *b)
{
struct cmd_attach_session_data *data;
self->data = data = xmalloc(sizeof *data);
buffer_read(b, data, sizeof *data);
data->cname = cmd_recv_string(b);
data->sname = cmd_recv_string(b);
}
void
cmd_attach_session_free(struct cmd *self)
{
struct cmd_attach_session_data *data = self->data;
if (data->cname != NULL)
xfree(data->cname);
if (data->sname != NULL)
xfree(data->sname);
xfree(data);
}
void
cmd_attach_session_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_attach_session_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return;
if (off < len && data->flag_detach)
off += xsnprintf(buf + off, len - off, " -d");
if (off < len && data->cname != NULL)
off += xsnprintf(buf + off, len - off, " -c %s", data->cname);
if (off < len && data->sname != NULL)
off += xsnprintf(buf + off, len - off, " -s %s", data->sname);
}

6
cmd-bind-key.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-bind-key.c,v 1.13 2008-06-05 16:35:31 nicm Exp $ */
/* $Id: cmd-bind-key.c,v 1.14 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -41,13 +41,13 @@ const struct cmd_entry cmd_bind_key_entry = {
"bind-key", "bind",
"key command [arguments]",
0,
NULL,
cmd_bind_key_parse,
cmd_bind_key_exec,
cmd_bind_key_send,
cmd_bind_key_recv,
cmd_bind_key_free,
NULL,
NULL
NULL /* XXX */
};
int

19
cmd-copy-mode.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-copy-mode.c,v 1.9 2008-06-05 16:35:31 nicm Exp $ */
/* $Id: cmd-copy-mode.c,v 1.10 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,23 +28,24 @@ void cmd_copy_mode_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_copy_mode_entry = {
"copy-mode", NULL,
CMD_WINDOWONLY_USAGE,
CMD_TARGET_WINDOW_USAGE,
0,
cmd_windowonly_parse,
cmd_target_init,
cmd_target_parse,
cmd_copy_mode_exec,
cmd_windowonly_send,
cmd_windowonly_recv,
cmd_windowonly_free,
NULL,
cmd_target_send,
cmd_target_recv,
cmd_target_free,
NULL
};
void
cmd_copy_mode_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct winlink *wl;
struct cmd_target_data *data = self->data;
struct winlink *wl;
if ((wl = cmd_windowonly_get(self, ctx, NULL)) == NULL)
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
return;
window_set_mode(wl->window, &window_copy_mode);

21
cmd-detach-client.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-detach-client.c,v 1.5 2008-06-05 16:35:31 nicm Exp $ */
/* $Id: cmd-detach-client.c,v 1.6 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,23 +28,24 @@ void cmd_detach_client_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_detach_client_entry = {
"detach-client", "detach",
CMD_CLIENTONLY_USAGE,
CMD_TARGET_CLIENT_USAGE,
0,
cmd_clientonly_parse,
cmd_target_init,
cmd_target_parse,
cmd_detach_client_exec,
cmd_clientonly_send,
cmd_clientonly_recv,
cmd_clientonly_free,
NULL,
cmd_clientonly_print
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
void
cmd_detach_client_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct client *c;
struct cmd_target_data *data = self->data;
struct client *c;
if ((c = cmd_clientonly_get(self, ctx)) == NULL)
if ((c = cmd_find_client(ctx, data->target)) == NULL)
return;
server_write_client(c, MSG_DETACH, NULL, 0);

434
cmd-generic.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-generic.c,v 1.7 2008-06-05 17:12:10 nicm Exp $ */
/* $Id: cmd-generic.c,v 1.8 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@ -23,223 +23,43 @@
#include "tmux.h"
int
cmd_clientonly_parse(struct cmd *self, int argc, char **argv, char **cause)
void
cmd_target_init(struct cmd *self, unused int key)
{
struct cmd_clientonly_data *data;
int opt;
struct cmd_target_data *data;
self->data = data = xmalloc(sizeof *data);
data->cname = NULL;
while ((opt = getopt(argc, argv, "c:")) != EOF) {
switch (opt) {
case 'c':
if (data->cname == NULL)
data->cname = 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);
}
void
cmd_clientonly_send(struct cmd *self, struct buffer *b)
{
struct cmd_clientonly_data *data = self->data;
buffer_write(b, data, sizeof *data);
cmd_send_string(b, data->cname);
}
void
cmd_clientonly_recv(struct cmd *self, struct buffer *b)
{
struct cmd_clientonly_data *data;
self->data = data = xmalloc(sizeof *data);
buffer_read(b, data, sizeof *data);
data->cname = cmd_recv_string(b);
}
void
cmd_clientonly_free(struct cmd *self)
{
struct cmd_clientonly_data *data = self->data;
if (data->cname != NULL)
xfree(data->cname);
xfree(data);
}
struct client *
cmd_clientonly_get(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_clientonly_data *data = self->data;
if (data != NULL)
return (cmd_find_client(ctx, data->cname));
return (cmd_find_client(ctx, NULL));
}
void
cmd_clientonly_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_clientonly_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return;
if (off < len && data->cname != NULL)
off += xsnprintf(buf + off, len - off, " -c %s", data->cname);
data->flags = 0;
data->target = NULL;
data->arg = NULL;
}
int
cmd_sessiononly_parse(struct cmd *self, int argc, char **argv, char **cause)
cmd_target_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_sessiononly_data *data;
int opt;
struct cmd_target_data *data;
int opt;
self->entry->init(self, 0);
data = self->data;
self->data = data = xmalloc(sizeof *data);
data->cname = NULL;
data->sname = NULL;
while ((opt = getopt(argc, argv, "c:s:")) != EOF) {
while ((opt = getopt(argc, argv, "dkt:")) != EOF) {
switch (opt) {
case 'c':
if (data->sname != NULL)
goto usage;
if (data->cname == NULL)
data->cname = xstrdup(optarg);
break;
case 's':
if (data->cname != NULL)
goto usage;
if (data->sname == NULL)
data->sname = 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);
}
void
cmd_sessiononly_send(struct cmd *self, struct buffer *b)
{
struct cmd_sessiononly_data *data = self->data;
buffer_write(b, data, sizeof *data);
cmd_send_string(b, data->cname);
cmd_send_string(b, data->sname);
}
void
cmd_sessiononly_recv(struct cmd *self, struct buffer *b)
{
struct cmd_sessiononly_data *data;
self->data = data = xmalloc(sizeof *data);
buffer_read(b, data, sizeof *data);
data->cname = cmd_recv_string(b);
data->sname = cmd_recv_string(b);
}
void
cmd_sessiononly_free(struct cmd *self)
{
struct cmd_sessiononly_data *data = self->data;
if (data->cname != NULL)
xfree(data->cname);
if (data->sname != NULL)
xfree(data->sname);
xfree(data);
}
struct session *
cmd_sessiononly_get(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_sessiononly_data *data = self->data;
if (data != NULL)
return (cmd_find_session(ctx, data->cname, data->sname));
return (cmd_find_session(ctx, NULL, NULL));
}
void
cmd_sessiononly_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_sessiononly_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return;
if (off < len && data->cname != NULL)
off += xsnprintf(buf + off, len - off, " -c %s", data->cname);
if (off < len && data->sname != NULL)
off += xsnprintf(buf + off, len - off, " -s %s", data->sname);
}
int
cmd_windowonly_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_windowonly_data *data;
int opt;
const char *errstr;
self->data = data = xmalloc(sizeof *data);
data->cname = NULL;
data->sname = NULL;
data->idx = -1;
while ((opt = getopt(argc, argv, "c:i:s:")) != EOF) {
switch (opt) {
case 'c':
if (data->sname != NULL)
goto usage;
if (data->cname == NULL)
data->cname = xstrdup(optarg);
break;
case 'i':
data->idx = strtonum(optarg, 0, INT_MAX, &errstr);
if (errstr != NULL) {
xasprintf(cause, "index %s", errstr);
goto error;
case 'd':
if (self->entry->flags & CMD_DFLAG) {
data->flags |= CMD_DFLAG;
break;
}
break;
case 's':
if (data->cname != NULL)
goto usage;
if (data->sname == NULL)
data->sname = xstrdup(optarg);
goto usage;
case 'k':
if (self->entry->flags & CMD_KFLAG) {
data->flags |= CMD_KFLAG;
break;
}
goto usage;
case 't':
if (data->target == NULL)
data->target = xstrdup(optarg);
break;
default:
goto usage;
@ -247,79 +67,197 @@ cmd_windowonly_parse(struct cmd *self, int argc, char **argv, char **cause)
}
argc -= optind;
argv += optind;
if (argc != 0)
goto usage;
if (self->entry->flags & CMD_ONEARG) {
if (argc != 1)
goto usage;
data->arg = xstrdup(argv[0]);
} else {
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);
}
void
cmd_windowonly_send(struct cmd *self, struct buffer *b)
cmd_target_send(struct cmd *self, struct buffer *b)
{
struct cmd_windowonly_data *data = self->data;
struct cmd_target_data *data = self->data;
buffer_write(b, data, sizeof *data);
cmd_send_string(b, data->cname);
cmd_send_string(b, data->sname);
cmd_send_string(b, data->target);
cmd_send_string(b, data->arg);
}
void
cmd_windowonly_recv(struct cmd *self, struct buffer *b)
cmd_target_recv(struct cmd *self, struct buffer *b)
{
struct cmd_windowonly_data *data;
struct cmd_target_data *data;
self->data = data = xmalloc(sizeof *data);
buffer_read(b, data, sizeof *data);
data->cname = cmd_recv_string(b);
data->sname = cmd_recv_string(b);
data->target = cmd_recv_string(b);
data->arg = cmd_recv_string(b);
}
void
cmd_windowonly_free(struct cmd *self)
cmd_target_free(struct cmd *self)
{
struct cmd_windowonly_data *data = self->data;
struct cmd_target_data *data = self->data;
if (data->cname != NULL)
xfree(data->cname);
if (data->sname != NULL)
xfree(data->sname);
if (data->target != NULL)
xfree(data->target);
if (data->arg != NULL)
xfree(data->arg);
xfree(data);
}
struct winlink *
cmd_windowonly_get(struct cmd *self, struct cmd_ctx *ctx, struct session **sp)
{
struct cmd_windowonly_data *data = self->data;
struct winlink *wl;
if (data == NULL) {
wl = cmd_find_window(ctx, NULL, NULL, -1, sp);
return (wl);
}
return (cmd_find_window(ctx, data->cname, data->sname, data->idx, sp));
}
void
cmd_windowonly_print(struct cmd *self, char *buf, size_t len)
cmd_target_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_windowonly_data *data = self->data;
size_t off = 0;
struct cmd_target_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return;
if (off < len && data->cname != NULL)
off += xsnprintf(buf + off, len - off, " -c %s", data->cname);
if (off < len && data->sname != NULL)
off += xsnprintf(buf + off, len - off, " -s %s", data->sname);
if (off < len && data->idx != -1)
off += xsnprintf(buf + off, len - off, " -i %d", data->idx);
if (off < len && data->flags & CMD_DFLAG)
off += xsnprintf(buf + off, len - off, " -d");
if (off < len && data->flags & CMD_KFLAG)
off += xsnprintf(buf + off, len - off, " -k");
if (off < len && data->target != NULL)
off += xsnprintf(buf + off, len - off, " -t %s", data->target);
if (off < len && data->arg != NULL)
off += xsnprintf(buf + off, len - off, " %s", data->arg);
}
void
cmd_srcdst_init(struct cmd *self, unused int key)
{
struct cmd_srcdst_data *data;
self->data = data = xmalloc(sizeof *data);
data->flags = 0;
data->src = NULL;
data->dst = NULL;
data->arg = NULL;
}
int
cmd_srcdst_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_srcdst_data *data;
int opt;
self->entry->init(self, 0);
data = self->data;
while ((opt = getopt(argc, argv, "dks:t:")) != EOF) {
switch (opt) {
case 'd':
if (self->entry->flags & CMD_DFLAG) {
data->flags |= CMD_DFLAG;
break;
}
goto usage;
case 'k':
if (self->entry->flags & CMD_KFLAG) {
data->flags |= CMD_KFLAG;
break;
}
goto usage;
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 (self->entry->flags & CMD_ONEARG) {
if (argc != 1)
goto usage;
data->arg = xstrdup(argv[0]);
} else {
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);
}
void
cmd_srcdst_send(struct cmd *self, struct buffer *b)
{
struct cmd_srcdst_data *data = self->data;
buffer_write(b, data, sizeof *data);
cmd_send_string(b, data->src);
cmd_send_string(b, data->dst);
cmd_send_string(b, data->arg);
}
void
cmd_srcdst_recv(struct cmd *self, struct buffer *b)
{
struct cmd_srcdst_data *data;
self->data = data = xmalloc(sizeof *data);
buffer_read(b, data, sizeof *data);
data->src = cmd_recv_string(b);
data->dst = cmd_recv_string(b);
data->arg = cmd_recv_string(b);
}
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);
xfree(data);
}
void
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;
if (off < len && data->flags & CMD_DFLAG)
off += xsnprintf(buf + off, len - off, " -d");
if (off < len && data->flags & CMD_KFLAG)
off += xsnprintf(buf + off, len - off, " -k");
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 += xsnprintf(buf + off, len - off, " %s", data->arg);
}

21
cmd-has-session.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-has-session.c,v 1.8 2008-06-05 16:35:31 nicm Exp $ */
/* $Id: cmd-has-session.c,v 1.9 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,23 +28,24 @@ void cmd_has_session_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_has_session_entry = {
"has-session", "has",
CMD_SESSIONONLY_USAGE,
CMD_TARGET_SESSION_USAGE,
0,
cmd_sessiononly_parse,
cmd_target_init,
cmd_target_parse,
cmd_has_session_exec,
cmd_sessiononly_send,
cmd_sessiononly_recv,
cmd_sessiononly_free,
NULL,
cmd_sessiononly_print
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
void
cmd_has_session_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct session *s;
struct cmd_target_data *data = self->data;
struct session *s;
if ((s = cmd_sessiononly_get(self, ctx)) == NULL)
if ((s = cmd_find_session(ctx, data->target)) == NULL)
return;
if (ctx->cmdclient != NULL)

4
cmd-kill-server.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-kill-server.c,v 1.4 2008-06-05 16:35:31 nicm Exp $ */
/* $Id: cmd-kill-server.c,v 1.5 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -34,8 +34,8 @@ const struct cmd_entry cmd_kill_server_entry = {
"",
0,
NULL,
cmd_kill_server_exec,
NULL,
cmd_kill_server_exec,
NULL,
NULL,
NULL,

25
cmd-kill-session.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-kill-session.c,v 1.9 2008-06-05 16:35:31 nicm Exp $ */
/* $Id: cmd-kill-session.c,v 1.10 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -31,25 +31,26 @@ void cmd_kill_session_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_kill_session_entry = {
"kill-session", NULL,
CMD_SESSIONONLY_USAGE,
CMD_TARGET_SESSION_USAGE,
0,
cmd_sessiononly_parse,
cmd_target_init,
cmd_target_parse,
cmd_kill_session_exec,
cmd_sessiononly_send,
cmd_sessiononly_recv,
cmd_sessiononly_free,
NULL,
cmd_sessiononly_print
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
void
cmd_kill_session_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct session *s;
struct client *c;
u_int i;
struct cmd_target_data *data = self->data;
struct session *s;
struct client *c;
u_int i;
if ((s = cmd_sessiononly_get(self, ctx)) == NULL)
if ((s = cmd_find_session(ctx, data->target)) == NULL)
return;
for (i = 0; i < ARRAY_LENGTH(&clients); i++) {

29
cmd-kill-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-kill-window.c,v 1.12 2008-06-05 16:35:31 nicm Exp $ */
/* $Id: cmd-kill-window.c,v 1.13 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,27 +28,28 @@ void cmd_kill_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_kill_window_entry = {
"kill-window", "killw",
CMD_WINDOWONLY_USAGE,
CMD_TARGET_WINDOW_USAGE,
0,
cmd_windowonly_parse,
cmd_target_init,
cmd_target_parse,
cmd_kill_window_exec,
cmd_windowonly_send,
cmd_windowonly_recv,
cmd_windowonly_free,
NULL,
NULL
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
void
cmd_kill_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct winlink *wl;
struct session *s;
struct client *c;
u_int i;
int destroyed;
struct cmd_target_data *data = self->data;
struct winlink *wl;
struct session *s;
struct client *c;
u_int i;
int destroyed;
if ((wl = cmd_windowonly_get(self, ctx, &s)) == NULL)
if ((wl = cmd_find_window(ctx, data->target, &s)) == NULL)
return;
destroyed = session_detach(s, wl);

23
cmd-last-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-last-window.c,v 1.10 2008-06-05 16:35:31 nicm Exp $ */
/* $Id: cmd-last-window.c,v 1.11 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,23 +28,24 @@ void cmd_last_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_last_window_entry = {
"last-window", "last",
CMD_SESSIONONLY_USAGE,
CMD_TARGET_SESSION_USAGE,
0,
cmd_sessiononly_parse,
cmd_target_init,
cmd_target_parse,
cmd_last_window_exec,
cmd_sessiononly_send,
cmd_sessiononly_recv,
cmd_sessiononly_free,
NULL,
cmd_sessiononly_print
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
void
cmd_last_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct session *s;
if ((s = cmd_sessiononly_get(self, ctx)) == NULL)
struct cmd_target_data *data = self->data;
struct session *s;
if ((s = cmd_find_session(ctx, data->target)) == NULL)
return;
if (session_last(s) == 0)

262
cmd-link-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-link-window.c,v 1.18 2008-06-05 17:12:10 nicm Exp $ */
/* $Id: cmd-link-window.c,v 1.19 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -27,239 +27,83 @@
* Link a window into another session.
*/
int cmd_link_window_parse(struct cmd *, int, char **, char **);
void cmd_link_window_exec(struct cmd *, struct cmd_ctx *);
void cmd_link_window_send(struct cmd *, struct buffer *);
void cmd_link_window_recv(struct cmd *, struct buffer *);
void cmd_link_window_free(struct cmd *);
void cmd_link_window_print(struct cmd *, char *, size_t);
struct cmd_link_window_data {
char *cname;
char *sname;
int idx;
int flag_detached;
int flag_kill;
int srcidx;
char *srcname;
};
const struct cmd_entry cmd_link_window_entry = {
"link-window", "linkw",
"[-dk] [-c client-tty|-s session-name] [-i index] session-name index",
0,
cmd_link_window_parse,
"[-dk] " CMD_SRCDST_WINDOW_USAGE,
CMD_DFLAG|CMD_KFLAG,
cmd_srcdst_init,
cmd_srcdst_parse,
cmd_link_window_exec,
cmd_link_window_send,
cmd_link_window_recv,
cmd_link_window_free,
NULL,
cmd_link_window_print
cmd_srcdst_send,
cmd_srcdst_recv,
cmd_srcdst_free,
cmd_srcdst_print
};
int
cmd_link_window_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_link_window_data *data;
const char *errstr;
int opt;
self->data = data = xmalloc(sizeof *data);
data->cname = NULL;
data->sname = NULL;
data->flag_detached = 0;
data->flag_kill = 0;
data->idx = -1;
data->srcidx = -1;
data->srcname = NULL;
while ((opt = getopt(argc, argv, "c:di:ks:")) != EOF) {
switch (opt) {
case 'c':
if (data->sname != NULL)
goto usage;
if (data->cname == NULL)
data->cname = xstrdup(optarg);
break;
case 'd':
data->flag_detached = 1;
break;
case 'i':
data->idx = strtonum(optarg, 0, INT_MAX, &errstr);
if (errstr != NULL) {
xasprintf(cause, "index %s", errstr);
goto error;
}
break;
case 'k':
data->flag_kill = 1;
break;
case 's':
if (data->cname != NULL)
goto usage;
if (data->sname == NULL)
data->sname = xstrdup(optarg);
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (argc != 2)
goto usage;
data->srcname = xstrdup(argv[0]);
data->srcidx = strtonum(argv[1], 0, INT_MAX, &errstr);
if (errstr != NULL) {
xasprintf(cause, "index %s", errstr);
goto error;
}
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
error:
self->entry->free(self);
return (-1);
}
void
cmd_link_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_link_window_data *data = self->data;
struct session *s, *src;
struct winlink *wl, *wl2;
struct cmd_srcdst_data *data = self->data;
struct session *s;
struct winlink *wl_src, *wl_dst;
int idx;
if (data == NULL)
if ((wl_src = cmd_find_window(ctx, data->src, NULL)) == NULL)
return;
if ((s = cmd_find_session(ctx, data->cname, data->sname)) == NULL)
if (arg_parse_window(data->dst, &s, &idx) != 0) {
ctx->error(ctx, "bad window: %s", data->dst);
return;
if ((src = session_find(data->srcname)) == NULL) {
ctx->error(ctx, "session not found: %s", data->srcname);
}
if (s == NULL)
s = ctx->cursession;
if (s == NULL)
s = cmd_current_session(ctx);
if (s == NULL) {
ctx->error(ctx, "session not found: %s", data->dst);
return;
}
if (data->srcidx < 0)
data->srcidx = -1;
if (data->srcidx == -1)
wl = src->curw;
else {
wl = winlink_find_by_index(&src->windows, data->srcidx);
if (wl == NULL) {
ctx->error(ctx, "no window %d", data->srcidx);
return;
if (data->flags & CMD_KFLAG) {
wl_dst = winlink_find_by_index(&s->windows, idx);
if (wl_dst != NULL) {
/*
* Can't use session_detach as it will destroy session
* if this makes it empty.
*/
session_alert_cancel(s, wl_dst);
winlink_remove(&s->windows, wl_dst);
/* Force select/redraw if current. */
if (wl_dst == s->curw) {
data->flags &= ~CMD_DFLAG;
s->curw = NULL;
}
if (wl_dst == s->lastw)
s->lastw = NULL;
/*
* Can't error out after this or there could be an empty
* session!
*/
}
}
if (data->idx < 0)
data->idx = -1;
if (data->flag_kill && data->idx != -1) {
wl2 = winlink_find_by_index(&s->windows, data->idx);
if (wl2 == NULL) {
ctx->error(ctx, "no window %d", data->idx);
return;
}
/*
* Can't use session_detach as it will destroy session if this
* makes it empty.
*/
session_alert_cancel(s, wl2);
winlink_remove(&s->windows, wl2);
/* Force select/redraw if current. */
if (wl2 == s->curw) {
data->flag_detached = 0;
s->curw = NULL;
}
if (wl2 == s->lastw)
s->lastw = NULL;
/*
* Can't error out after this or there could be an empty
* session!
*/
}
wl = session_attach(s, wl->window, data->idx);
if (wl == NULL) {
ctx->error(ctx, "index in use: %d", data->idx);
wl_dst = session_attach(s, wl_src->window, idx);
if (wl_dst == NULL) {
ctx->error(ctx, "index in use: %d", idx);
return;
}
if (!data->flag_detached) {
session_select(s, wl->idx);
server_redraw_session(s);
} else
if (data->flags & CMD_DFLAG)
server_status_session(s);
else {
session_select(s, wl_dst->idx);
server_redraw_session(s);
}
if (ctx->cmdclient != NULL)
server_write_client(ctx->cmdclient, MSG_EXIT, NULL, 0);
}
void
cmd_link_window_send(struct cmd *self, struct buffer *b)
{
struct cmd_link_window_data *data = self->data;
buffer_write(b, data, sizeof *data);
cmd_send_string(b, data->cname);
cmd_send_string(b, data->sname);
cmd_send_string(b, data->srcname);
}
void
cmd_link_window_recv(struct cmd *self, struct buffer *b)
{
struct cmd_link_window_data *data;
self->data = data = xmalloc(sizeof *data);
buffer_read(b, data, sizeof *data);
data->cname = cmd_recv_string(b);
data->sname = cmd_recv_string(b);
data->srcname = cmd_recv_string(b);
}
void
cmd_link_window_free(struct cmd *self)
{
struct cmd_link_window_data *data = self->data;
if (data->cname != NULL)
xfree(data->cname);
if (data->sname != NULL)
xfree(data->sname);
if (data->srcname != NULL)
xfree(data->srcname);
xfree(data);
}
void
cmd_link_window_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_link_window_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return;
if (off < len && data->flag_detached)
off += xsnprintf(buf + off, len - off, " -d");
if (off < len && data->flag_kill)
off += xsnprintf(buf + off, len - off, " -k");
if (off < len && data->cname != NULL)
off += xsnprintf(buf + off, len - off, " -c %s", data->cname);
if (off < len && data->sname != NULL)
off += xsnprintf(buf + off, len - off, " -s %s", data->sname);
if (off < len && data->idx != -1)
off += xsnprintf(buf + off, len - off, " -i %d", data->idx);
if (off < len && data->srcname != NULL)
off += xsnprintf(buf + off, len - off, " %s", data->srcname);
if (off < len && data->srcidx != -1)
off += xsnprintf(buf + off, len - off, " %d", data->srcidx);
}

4
cmd-list-clients.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-list-clients.c,v 1.7 2008-06-05 16:35:31 nicm Exp $ */
/* $Id: cmd-list-clients.c,v 1.8 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -34,8 +34,8 @@ const struct cmd_entry cmd_list_clients_entry = {
"",
0,
NULL,
cmd_list_clients_exec,
NULL,
cmd_list_clients_exec,
NULL,
NULL,
NULL,

6
cmd-list-keys.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-list-keys.c,v 1.9 2008-06-05 16:35:31 nicm Exp $ */
/* $Id: cmd-list-keys.c,v 1.10 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -31,12 +31,12 @@ const struct cmd_entry cmd_list_keys_entry = {
"",
0,
NULL,
NULL,
cmd_list_keys_exec,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL
};
void

4
cmd-list-sessions.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-list-sessions.c,v 1.14 2008-06-05 16:35:31 nicm Exp $ */
/* $Id: cmd-list-sessions.c,v 1.15 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -33,8 +33,8 @@ const struct cmd_entry cmd_list_sessions_entry = {
"list-sessions", "ls", "",
0,
NULL,
cmd_list_sessions_exec,
NULL,
cmd_list_sessions_exec,
NULL,
NULL,
NULL,

19
cmd-list-windows.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-list-windows.c,v 1.19 2008-06-05 16:35:31 nicm Exp $ */
/* $Id: cmd-list-windows.c,v 1.20 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,27 +30,28 @@ void cmd_list_windows_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_list_windows_entry = {
"list-windows", "lsw",
CMD_SESSIONONLY_USAGE,
CMD_TARGET_SESSION_USAGE,
0,
cmd_sessiononly_parse,
cmd_target_init,
cmd_target_parse,
cmd_list_windows_exec,
cmd_sessiononly_send,
cmd_sessiononly_recv,
cmd_sessiononly_free,
NULL,
cmd_sessiononly_print
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
void
cmd_list_windows_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_target_data *data = self->data;
struct session *s;
struct winlink *wl;
struct window *w;
u_int i;
unsigned long long size;
if ((s = cmd_sessiononly_get(self, ctx)) == NULL)
if ((s = cmd_find_session(ctx, data->target)) == NULL)
return;
RB_FOREACH(wl, winlinks, &s->windows) {

46
cmd-new-session.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-new-session.c,v 1.26 2008-06-05 17:12:10 nicm Exp $ */
/* $Id: cmd-new-session.c,v 1.27 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -35,7 +35,7 @@ void cmd_new_session_init(struct cmd *, int);
void cmd_new_session_print(struct cmd *, char *, size_t);
struct cmd_new_session_data {
char *name;
char *newname;
char *winname;
char *cmd;
int flag_detached;
@ -43,14 +43,14 @@ struct cmd_new_session_data {
const struct cmd_entry cmd_new_session_entry = {
"new-session", "new",
"[-d] [-n window-name] [-s session-name] [command]",
"[-d] [-s session-name] [-n window-name] [command]",
CMD_STARTSERVER|CMD_CANTNEST,
cmd_new_session_init,
cmd_new_session_parse,
cmd_new_session_exec,
cmd_new_session_send,
cmd_new_session_recv,
cmd_new_session_free,
cmd_new_session_init,
cmd_new_session_print
};
@ -61,7 +61,7 @@ cmd_new_session_init(struct cmd *self, unused int arg)
self->data = data = xmalloc(sizeof *data);
data->flag_detached = 0;
data->name = NULL;
data->newname = NULL;
data->winname = NULL;
data->cmd = NULL;
}
@ -81,10 +81,12 @@ cmd_new_session_parse(struct cmd *self, int argc, char **argv, char **cause)
data->flag_detached = 1;
break;
case 's':
data->name = xstrdup(optarg);
if (data->newname == NULL)
data->newname = xstrdup(optarg);
break;
case 'n':
data->winname = xstrdup(optarg);
if (data->winname == NULL)
data->winname = xstrdup(optarg);
break;
default:
goto usage;
@ -130,8 +132,8 @@ cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
}
}
if (data->name != NULL && session_find(data->name) != NULL) {
ctx->error(ctx, "duplicate session: %s", data->name);
if (data->newname != NULL && session_find(data->newname) != NULL) {
ctx->error(ctx, "duplicate session: %s", data->newname);
return;
}
@ -158,7 +160,7 @@ cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
}
if ((s = session_create(data->name, cmd, sx, sy)) == NULL)
if ((s = session_create(data->newname, cmd, sx, sy)) == NULL)
fatalx("session_create failed");
if (data->winname != NULL) {
xfree(s->curw->window->name);
@ -181,7 +183,7 @@ cmd_new_session_send(struct cmd *self, struct buffer *b)
struct cmd_new_session_data *data = self->data;
buffer_write(b, data, sizeof *data);
cmd_send_string(b, data->name);
cmd_send_string(b, data->newname);
cmd_send_string(b, data->winname);
cmd_send_string(b, data->cmd);
}
@ -193,7 +195,7 @@ cmd_new_session_recv(struct cmd *self, struct buffer *b)
self->data = data = xmalloc(sizeof *data);
buffer_read(b, data, sizeof *data);
data->name = cmd_recv_string(b);
data->newname = cmd_recv_string(b);
data->winname = cmd_recv_string(b);
data->cmd = cmd_recv_string(b);
}
@ -203,8 +205,8 @@ cmd_new_session_free(struct cmd *self)
{
struct cmd_new_session_data *data = self->data;
if (data->name != NULL)
xfree(data->name);
if (data->newname != NULL)
xfree(data->newname);
if (data->winname != NULL)
xfree(data->winname);
if (data->cmd != NULL)
@ -213,6 +215,20 @@ cmd_new_session_free(struct cmd *self)
}
void
cmd_new_session_print(struct cmd *cmd, char *buf, size_t len)
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;
if (off < len && data->flag_detached)
off += xsnprintf(buf + off, len - off, " -d");
if (off < len && data->newname != NULL)
off += xsnprintf(buf + off, len - off, " -s %s", data->newname);
if (off < len && data->winname != NULL)
off += xsnprintf(buf + off, len - off, " -n %s", data->winname);
if (off < len && data->cmd != NULL)
off += xsnprintf(buf + off, len - off, " %s", data->cmd);
}

81
cmd-new-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-new-window.c,v 1.22 2008-06-05 17:12:10 nicm Exp $ */
/* $Id: cmd-new-window.c,v 1.23 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -36,9 +36,7 @@ void cmd_new_window_init(struct cmd *, int);
void cmd_new_window_print(struct cmd *, char *, size_t);
struct cmd_new_window_data {
char *cname;
char *sname;
int idx;
char *target;
char *name;
char *cmd;
int flag_detached;
@ -46,14 +44,14 @@ struct cmd_new_window_data {
const struct cmd_entry cmd_new_window_entry = {
"new-window", "neww",
"[-d] [-c client-tty|-s session-name] [-i index] [-n name] [command]",
"[-d] [-t target-window] [-n window-name] [command]",
0,
cmd_new_window_init,
cmd_new_window_parse,
cmd_new_window_exec,
cmd_new_window_send,
cmd_new_window_recv,
cmd_new_window_free,
cmd_new_window_init,
cmd_new_window_print
};
@ -63,52 +61,34 @@ cmd_new_window_init(struct cmd *self, unused int arg)
struct cmd_new_window_data *data;
self->data = data = xmalloc(sizeof *data);
data->cname = NULL;
data->sname = NULL;
data->idx = -1;
data->flag_detached = 0;
data->target = NULL;
data->name = NULL;
data->cmd = NULL;
data->flag_detached = 0;
}
int
cmd_new_window_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_new_window_data *data;
const char *errstr;
int opt;
self->entry->init(self, 0);
data = self->data;
while ((opt = getopt(argc, argv, "c:di:n:s:")) != EOF) {
while ((opt = getopt(argc, argv, "dt:n:")) != EOF) {
switch (opt) {
case 'c':
if (data->sname != NULL)
goto usage;
if (data->cname == NULL)
data->cname = xstrdup(optarg);
break;
case 'd':
data->flag_detached = 1;
break;
case 'i':
data->idx = strtonum(optarg, 0, INT_MAX, &errstr);
if (errstr != NULL) {
xasprintf(cause, "index %s", errstr);
goto error;
}
case 't':
if (data->target == NULL)
data->target = xstrdup(optarg);
break;
case 'n':
if (data->name == NULL)
data->name = xstrdup(optarg);
break;
case 's':
if (data->cname != NULL)
goto usage;
if (data->sname == NULL)
data->sname = xstrdup(optarg);
break;
default:
goto usage;
}
@ -126,7 +106,6 @@ cmd_new_window_parse(struct cmd *self, int argc, char **argv, char **cause)
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
error:
self->entry->free(self);
return (-1);
}
@ -138,17 +117,29 @@ cmd_new_window_exec(struct cmd *self, struct cmd_ctx *ctx)
struct session *s;
struct winlink *wl;
char *cmd;
int idx;
if ((s = cmd_find_session(ctx, data->cname, data->sname)) == NULL)
if (data == NULL)
return;
if (arg_parse_window(data->target, &s, &idx) != 0) {
ctx->error(ctx, "bad window: %s", data->target);
return;
}
if (s == NULL)
s = ctx->cursession;
if (s == NULL)
s = cmd_current_session(ctx);
if (s == NULL) {
ctx->error(ctx, "session not found: %s", data->target);
return;
}
cmd = data->cmd;
if (cmd == NULL)
cmd = options_get_string(&s->options, "default-command");
if (data->idx < 0)
data->idx = -1;
wl = session_new(s, data->name, cmd, data->idx);
wl = session_new(s, data->name, cmd, idx);
if (wl == NULL) {
ctx->error(ctx, "command failed: %s", cmd);
return;
@ -169,8 +160,7 @@ cmd_new_window_send(struct cmd *self, struct buffer *b)
struct cmd_new_window_data *data = self->data;
buffer_write(b, data, sizeof *data);
cmd_send_string(b, data->cname);
cmd_send_string(b, data->sname);
cmd_send_string(b, data->target);
cmd_send_string(b, data->name);
cmd_send_string(b, data->cmd);
}
@ -182,8 +172,7 @@ cmd_new_window_recv(struct cmd *self, struct buffer *b)
self->data = data = xmalloc(sizeof *data);
buffer_read(b, data, sizeof *data);
data->cname = cmd_recv_string(b);
data->sname = cmd_recv_string(b);
data->target = cmd_recv_string(b);
data->name = cmd_recv_string(b);
data->cmd = cmd_recv_string(b);
}
@ -193,10 +182,8 @@ cmd_new_window_free(struct cmd *self)
{
struct cmd_new_window_data *data = self->data;
if (data->cname != NULL)
xfree(data->cname);
if (data->sname != NULL)
xfree(data->sname);
if (data->target != NULL)
xfree(data->target);
if (data->name != NULL)
xfree(data->name);
if (data->cmd != NULL)
@ -215,12 +202,8 @@ cmd_new_window_print(struct cmd *self, char *buf, size_t len)
return;
if (off < len && data->flag_detached)
off += xsnprintf(buf + off, len - off, " -d");
if (off < len && data->cname != NULL)
off += xsnprintf(buf + off, len - off, " -c %s", data->cname);
if (off < len && data->sname != NULL)
off += xsnprintf(buf + off, len - off, " -s %s", data->sname);
if (off < len && data->idx != -1)
off += xsnprintf(buf + off, len - off, " -i %d", data->idx);
if (off < len && data->target != NULL)
off += xsnprintf(buf + off, len - off, " -t %s", data->target);
if (off < len && data->name != NULL)
off += xsnprintf(buf + off, len - off, " -n %s", data->name);
if (off < len && data->cmd != NULL)

21
cmd-next-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-next-window.c,v 1.10 2008-06-05 16:35:31 nicm Exp $ */
/* $Id: cmd-next-window.c,v 1.11 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,23 +28,24 @@ void cmd_next_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_next_window_entry = {
"next-window", "next",
CMD_SESSIONONLY_USAGE,
CMD_TARGET_SESSION_USAGE,
0,
cmd_sessiononly_parse,
cmd_target_init,
cmd_target_parse,
cmd_next_window_exec,
cmd_sessiononly_send,
cmd_sessiononly_recv,
cmd_sessiononly_free,
NULL,
cmd_sessiononly_print
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
void
cmd_next_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct session *s;
struct cmd_target_data *data = self->data;
struct session *s;
if ((s = cmd_sessiononly_get(self, ctx)) == NULL)
if ((s = cmd_find_session(ctx, data->target)) == NULL)
return;
if (session_next(s) == 0)

21
cmd-paste-buffer.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-paste-buffer.c,v 1.7 2008-06-05 16:35:32 nicm Exp $ */
/* $Id: cmd-paste-buffer.c,v 1.8 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -30,23 +30,24 @@ void cmd_paste_buffer_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_paste_buffer_entry = {
"paste-buffer", "paste",
CMD_WINDOWONLY_USAGE,
CMD_TARGET_WINDOW_USAGE,
0,
cmd_windowonly_parse,
cmd_target_init,
cmd_target_parse,
cmd_paste_buffer_exec,
cmd_windowonly_send,
cmd_windowonly_recv,
cmd_windowonly_free,
NULL,
NULL
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
void
cmd_paste_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct winlink *wl;
struct cmd_target_data *data = self->data;
struct winlink *wl;
if ((wl = cmd_windowonly_get(self, ctx, NULL)) == NULL)
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
return;
if (paste_buffer != NULL && *paste_buffer != '\0') {

21
cmd-previous-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-previous-window.c,v 1.10 2008-06-05 16:35:32 nicm Exp $ */
/* $Id: cmd-previous-window.c,v 1.11 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,23 +28,24 @@ void cmd_previous_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_previous_window_entry = {
"previous-window", "prev",
CMD_SESSIONONLY_USAGE,
CMD_TARGET_SESSION_USAGE,
0,
cmd_sessiononly_parse,
cmd_target_init,
cmd_target_parse,
cmd_previous_window_exec,
cmd_sessiononly_send,
cmd_sessiononly_recv,
cmd_sessiononly_free,
NULL,
cmd_sessiononly_print
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
void
cmd_previous_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct session *s;
struct cmd_target_data *data = self->data;
struct session *s;
if ((s = cmd_sessiononly_get(self, ctx)) == NULL)
if ((s = cmd_find_session(ctx, data->target)) == NULL)
return;
if (session_previous(s) == 0)

23
cmd-refresh-client.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-refresh-client.c,v 1.5 2008-06-05 16:35:32 nicm Exp $ */
/* $Id: cmd-refresh-client.c,v 1.6 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,25 +28,26 @@ void cmd_refresh_client_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_refresh_client_entry = {
"refresh-client", "refresh",
CMD_CLIENTONLY_USAGE,
CMD_TARGET_CLIENT_USAGE,
0,
cmd_clientonly_parse,
cmd_target_init,
cmd_target_parse,
cmd_refresh_client_exec,
cmd_clientonly_send,
cmd_clientonly_recv,
cmd_clientonly_free,
NULL,
cmd_clientonly_print
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
void
cmd_refresh_client_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct client *c;
struct cmd_target_data *data = self->data;
struct client *c;
if ((c = cmd_clientonly_get(self, ctx)) == NULL)
if ((c = cmd_find_client(ctx, data->target)) == NULL)
return;
server_redraw_client(c);
if (ctx->cmdclient != NULL)

127
cmd-rename-session.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-rename-session.c,v 1.10 2008-06-05 17:12:10 nicm Exp $ */
/* $Id: cmd-rename-session.c,v 1.11 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -27,134 +27,33 @@
* Change session name.
*/
int cmd_rename_session_parse(struct cmd *, int, char **, char **);
void cmd_rename_session_exec(struct cmd *, struct cmd_ctx *);
void cmd_rename_session_send(struct cmd *, struct buffer *);
void cmd_rename_session_recv(struct cmd *, struct buffer *);
void cmd_rename_session_free(struct cmd *);
void cmd_rename_session_print(struct cmd *, char *, size_t);
struct cmd_rename_session_data {
char *cname;
char *sname;
char *newname;
};
const struct cmd_entry cmd_rename_session_entry = {
"rename-session", "rename",
"[-c client-tty|-s session-name] new-name",
0,
cmd_rename_session_parse,
CMD_TARGET_SESSION_USAGE " new-name",
CMD_ONEARG,
cmd_target_init,
cmd_target_parse,
cmd_rename_session_exec,
cmd_rename_session_send,
cmd_rename_session_recv,
cmd_rename_session_free,
NULL,
cmd_rename_session_print
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
int
cmd_rename_session_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_rename_session_data *data;
int opt;
self->data = data = xmalloc(sizeof *data);
data->cname = NULL;
data->sname = NULL;
data->newname = NULL;
while ((opt = getopt(argc, argv, "c:s:")) != EOF) {
switch (opt) {
case 'c':
if (data->sname != NULL)
goto usage;
if (data->cname == NULL)
data->cname = xstrdup(optarg);
break;
case 's':
if (data->cname != NULL)
goto usage;
if (data->sname == NULL)
data->sname = xstrdup(optarg);
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (argc != 1)
goto usage;
data->newname = xstrdup(argv[0]);
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
self->entry->free(self);
return (-1);
}
void
cmd_rename_session_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_rename_session_data *data = self->data;
struct session *s;
struct cmd_target_data *data = self->data;
struct session *s;
if (data == NULL)
return;
if ((s = cmd_find_session(ctx, data->cname, data->sname)) == NULL)
if ((s = cmd_find_session(ctx, data->target)) == NULL)
return;
xfree(s->name);
s->name = xstrdup(data->newname);
s->name = xstrdup(data->arg);
if (ctx->cmdclient != NULL)
server_write_client(ctx->cmdclient, MSG_EXIT, NULL, 0);
}
void
cmd_rename_session_send(struct cmd *self, struct buffer *b)
{
struct cmd_rename_session_data *data = self->data;
buffer_write(b, data, sizeof *data);
cmd_send_string(b, data->cname);
cmd_send_string(b, data->sname);
cmd_send_string(b, data->newname);
}
void
cmd_rename_session_recv(struct cmd *self, struct buffer *b)
{
struct cmd_rename_session_data *data;
self->data = data = xmalloc(sizeof *data);
buffer_read(b, data, sizeof *data);
data->cname = cmd_recv_string(b);
data->sname = cmd_recv_string(b);
data->newname = cmd_recv_string(b);
}
void
cmd_rename_session_free(struct cmd *self)
{
struct cmd_rename_session_data *data = self->data;
if (data->cname != NULL)
xfree(data->cname);
if (data->sname != NULL)
xfree(data->sname);
if (data->newname != NULL)
xfree(data->newname);
xfree(data);
}
void
cmd_rename_session_print(struct cmd *cmd, char *buf, size_t len)
{
}

157
cmd-rename-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-rename-window.c,v 1.21 2008-06-05 17:12:10 nicm Exp $ */
/* $Id: cmd-rename-window.c,v 1.22 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -24,166 +24,39 @@
#include "tmux.h"
/*
* Rename window by index.
* Rename a window.
*/
int cmd_rename_window_parse(struct cmd *, int, char **, char **);
void cmd_rename_window_exec(struct cmd *, struct cmd_ctx *);
void cmd_rename_window_send(struct cmd *, struct buffer *);
void cmd_rename_window_recv(struct cmd *, struct buffer *);
void cmd_rename_window_free(struct cmd *);
void cmd_rename_window_print(struct cmd *, char *, size_t);
struct cmd_rename_window_data {
char *cname;
char *sname;
int idx;
char *newname;
};
const struct cmd_entry cmd_rename_window_entry = {
"rename-window", "renamew",
"[-c client-tty|-s session-name] [-i index] new-name",
0,
cmd_rename_window_parse,
CMD_TARGET_WINDOW_USAGE " new-name",
CMD_ONEARG,
cmd_target_init,
cmd_target_parse,
cmd_rename_window_exec,
cmd_rename_window_send,
cmd_rename_window_recv,
cmd_rename_window_free,
NULL,
cmd_rename_window_print
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
int
cmd_rename_window_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_rename_window_data *data;
const char *errstr;
int opt;
self->data = data = xmalloc(sizeof *data);
data->cname = NULL;
data->sname = NULL;
data->idx = -1;
data->newname = NULL;
while ((opt = getopt(argc, argv, "c:i:s:")) != EOF) {
switch (opt) {
case 'c':
if (data->sname != NULL)
goto usage;
if (data->cname == NULL)
data->cname = xstrdup(optarg);
break;
case 'i':
data->idx = strtonum(optarg, 0, INT_MAX, &errstr);
if (errstr != NULL) {
xasprintf(cause, "index %s", errstr);
goto error;
}
break;
case 's':
if (data->cname != NULL)
goto usage;
if (data->sname == NULL)
data->sname = xstrdup(optarg);
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (argc != 1)
goto usage;
data->newname = xstrdup(argv[0]);
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
error:
self->entry->free(self);
return (-1);
}
void
cmd_rename_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_rename_window_data *data = self->data;
struct session *s;
struct winlink *wl;
struct cmd_target_data *data = self->data;
struct session *s;
struct winlink *wl;
if (data == NULL)
return;
wl = cmd_find_window(ctx, data->cname, data->sname, data->idx, &s);
if (wl == NULL)
if ((wl = cmd_find_window(ctx, data->target, &s)) == NULL)
return;
xfree(wl->window->name);
wl->window->name = xstrdup(data->newname);
wl->window->name = xstrdup(data->arg);
server_status_session(s);
if (ctx->cmdclient != NULL)
server_write_client(ctx->cmdclient, MSG_EXIT, NULL, 0);
}
void
cmd_rename_window_send(struct cmd *self, struct buffer *b)
{
struct cmd_rename_window_data *data = self->data;
buffer_write(b, data, sizeof *data);
cmd_send_string(b, data->cname);
cmd_send_string(b, data->sname);
cmd_send_string(b, data->newname);
}
void
cmd_rename_window_recv(struct cmd *self, struct buffer *b)
{
struct cmd_rename_window_data *data;
self->data = data = xmalloc(sizeof *data);
buffer_read(b, data, sizeof *data);
data->cname = cmd_recv_string(b);
data->sname = cmd_recv_string(b);
data->newname = cmd_recv_string(b);
}
void
cmd_rename_window_free(struct cmd *self)
{
struct cmd_rename_window_data *data = self->data;
if (data->cname != NULL)
xfree(data->cname);
if (data->sname != NULL)
xfree(data->sname);
if (data->newname != NULL)
xfree(data->newname);
xfree(data);
}
void
cmd_rename_window_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_rename_window_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return;
if (off < len && data->cname != NULL)
off += xsnprintf(buf + off, len - off, " -c %s", data->cname);
if (off < len && data->sname != NULL)
off += xsnprintf(buf + off, len - off, " -s %s", data->sname);
if (off < len && data->idx != -1)
off += xsnprintf(buf + off, len - off, " -i %d", data->idx);
if (off < len && data->newname != NULL)
off += xsnprintf(buf + off, len - off, " %s", data->newname);
}

21
cmd-scroll-mode.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-scroll-mode.c,v 1.11 2008-06-05 16:35:32 nicm Exp $ */
/* $Id: cmd-scroll-mode.c,v 1.12 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,23 +28,24 @@ void cmd_scroll_mode_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_scroll_mode_entry = {
"scroll-mode", NULL,
CMD_WINDOWONLY_USAGE,
CMD_TARGET_WINDOW_USAGE,
0,
cmd_windowonly_parse,
cmd_target_init,
cmd_target_parse,
cmd_scroll_mode_exec,
cmd_windowonly_send,
cmd_windowonly_recv,
cmd_windowonly_free,
NULL,
NULL
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
void
cmd_scroll_mode_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct winlink *wl;
struct cmd_target_data *data = self->data;
struct winlink *wl;
if ((wl = cmd_windowonly_get(self, ctx, NULL)) == NULL)
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
return;
window_set_mode(wl->window, &window_scroll_mode);

35
cmd-select-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-select-window.c,v 1.17 2008-06-05 16:35:32 nicm Exp $ */
/* $Id: cmd-select-window.c,v 1.18 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -32,35 +32,36 @@ void cmd_select_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_select_window_entry = {
"select-window", "selectw",
CMD_WINDOWONLY_USAGE,
CMD_TARGET_WINDOW_USAGE,
0,
cmd_windowonly_parse,
cmd_select_window_exec,
cmd_windowonly_send,
cmd_windowonly_recv,
cmd_windowonly_free,
cmd_select_window_init,
cmd_windowonly_print
cmd_target_parse,
cmd_select_window_exec,
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
void
cmd_select_window_init(struct cmd *self, int arg)
cmd_select_window_init(struct cmd *self, int key)
{
struct cmd_windowonly_data *data;
struct cmd_target_data *data;
self->data = data = xmalloc(sizeof *data);
data->cname = NULL;
data->sname = NULL;
data->idx = arg - '0';
cmd_target_init(self, key);
data = self->data;
xasprintf(&data->target, ":%d", key - '0');
}
void
cmd_select_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct winlink *wl;
struct session *s;
struct cmd_target_data *data = self->data;
struct winlink *wl;
struct session *s;
if ((wl = cmd_windowonly_get(self, ctx, &s)) == NULL)
if ((wl = cmd_find_window(ctx, data->target, &s)) == NULL)
return;
if (session_select(s, wl->idx) == 0)

54
cmd-send-keys.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-send-keys.c,v 1.9 2008-06-05 17:12:10 nicm Exp $ */
/* $Id: cmd-send-keys.c,v 1.10 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@ -35,8 +35,7 @@ void cmd_send_keys_free(struct cmd *);
void cmd_send_keys_print(struct cmd *, char *, size_t);
struct cmd_send_keys_data {
char *cname;
char *sname;
char *target;
int idx;
u_int nkeys;
int *keys;
@ -46,12 +45,12 @@ const struct cmd_entry cmd_send_keys_entry = {
"send-keys", "send",
"[-c client-tty|-s session-name] [-i index] key ...",
0,
NULL,
cmd_send_keys_parse,
cmd_send_keys_exec,
cmd_send_keys_send,
cmd_send_keys_recv,
cmd_send_keys_free,
NULL,
cmd_send_keys_print
};
@ -60,36 +59,19 @@ cmd_send_keys_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_send_keys_data *data;
int opt, key;
const char *errstr;
char *s;
self->data = data = xmalloc(sizeof *data);
data->cname = NULL;
data->sname = NULL;
data->target = NULL;
data->idx = -1;
data->nkeys = 0;
data->keys = NULL;
while ((opt = getopt(argc, argv, "c:i:s:")) != EOF) {
while ((opt = getopt(argc, argv, "t:")) != EOF) {
switch (opt) {
case 'c':
if (data->sname != NULL)
goto usage;
if (data->cname == NULL)
data->cname = xstrdup(optarg);
break;
case 'i':
data->idx = strtonum(optarg, 0, INT_MAX, &errstr);
if (errstr != NULL) {
xasprintf(cause, "index %s", errstr);
goto error;
}
break;
case 's':
if (data->cname != NULL)
goto usage;
if (data->sname == NULL)
data->sname = xstrdup(optarg);
case 't':
if (data->target == NULL)
data->target = xstrdup(optarg);
break;
default:
goto usage;
@ -121,7 +103,6 @@ cmd_send_keys_parse(struct cmd *self, int argc, char **argv, char **cause)
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
error:
self->entry->free(self);
return (-1);
}
@ -136,8 +117,7 @@ cmd_send_keys_exec(struct cmd *self, struct cmd_ctx *ctx)
if (data == NULL)
return;
wl = cmd_find_window(ctx, data->cname, data->sname, data->idx, NULL);
if (wl == NULL)
if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
return;
for (i = 0; i < data->nkeys; i++)
@ -153,8 +133,7 @@ cmd_send_keys_send(struct cmd *self, struct buffer *b)
struct cmd_send_keys_data *data = self->data;
buffer_write(b, data, sizeof *data);
cmd_send_string(b, data->cname);
cmd_send_string(b, data->sname);
cmd_send_string(b, data->target);
buffer_write(b, data->keys, data->nkeys * sizeof *data->keys);
}
@ -165,8 +144,7 @@ cmd_send_keys_recv(struct cmd *self, struct buffer *b)
self->data = data = xmalloc(sizeof *data);
buffer_read(b, data, sizeof *data);
data->cname = cmd_recv_string(b);
data->sname = cmd_recv_string(b);
data->target = cmd_recv_string(b);
data->keys = xcalloc(data->nkeys, sizeof *data->keys);
buffer_read(b, data->keys, data->nkeys * sizeof *data->keys);
}
@ -176,10 +154,8 @@ cmd_send_keys_free(struct cmd *self)
{
struct cmd_send_keys_data *data = self->data;
if (data->cname != NULL)
xfree(data->cname);
if (data->sname != NULL)
xfree(data->sname);
if (data->target != NULL)
xfree(data->target);
xfree(data);
}
@ -193,9 +169,7 @@ cmd_send_keys_print(struct cmd *self, char *buf, size_t len)
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return;
off += xsnprintf(buf + off, len - off, " -c %s", data->cname);
if (off < len && data->sname != NULL)
off += xsnprintf(buf + off, len - off, " -s %s", data->sname);
off += xsnprintf(buf + off, len - off, " -t %s", data->target);
if (off < len && data->idx != -1)
off += xsnprintf(buf + off, len - off, " -i %d", data->idx);

23
cmd-send-prefix.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-send-prefix.c,v 1.13 2008-06-05 16:35:32 nicm Exp $ */
/* $Id: cmd-send-prefix.c,v 1.14 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,24 +28,25 @@ void cmd_send_prefix_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_send_prefix_entry = {
"send-prefix", NULL,
CMD_WINDOWONLY_USAGE,
CMD_TARGET_WINDOW_USAGE,
0,
cmd_windowonly_parse,
cmd_target_init,
cmd_target_parse,
cmd_send_prefix_exec,
cmd_windowonly_send,
cmd_windowonly_recv,
cmd_windowonly_free,
NULL,
NULL
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
void
cmd_send_prefix_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct session *s;
struct winlink *wl;
struct cmd_target_data *data = self->data;
struct session *s;
struct winlink *wl;
if ((wl = cmd_windowonly_get(self, ctx, &s)) == NULL)
if ((wl = cmd_find_window(ctx, data->target, &s)) == NULL)
return;
window_key(wl->window, options_get_number(&s->options, "prefix-key"));

43
cmd-set-option.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-set-option.c,v 1.24 2008-06-05 17:12:11 nicm Exp $ */
/* $Id: cmd-set-option.c,v 1.25 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -36,8 +36,7 @@ void cmd_set_option_free(struct cmd *);
void cmd_set_option_print(struct cmd *, char *, size_t);
struct cmd_set_option_data {
char *cname;
char *sname;
char *target;
int flag_global;
char *option;
char *value;
@ -45,14 +44,14 @@ struct cmd_set_option_data {
const struct cmd_entry cmd_set_option_entry = {
"set-option", "set",
"[-c client-tty|-s session-name] option value",
"[-t target-window] option value",
0,
NULL,
cmd_set_option_parse,
cmd_set_option_exec,
cmd_set_option_send,
cmd_set_option_recv,
cmd_set_option_free,
NULL,
cmd_set_option_print
};
@ -63,26 +62,16 @@ cmd_set_option_parse(struct cmd *self, int argc, char **argv, char **cause)
int opt;
self->data = data = xmalloc(sizeof *data);
data->cname = NULL;
data->sname = NULL;
data->target = NULL;
data->flag_global = 1;
data->option = NULL;
data->value = NULL;
while ((opt = getopt(argc, argv, "c:s:")) != EOF) {
while ((opt = getopt(argc, argv, "t:s:")) != EOF) {
switch (opt) {
case 'c':
if (data->sname != NULL)
goto usage;
if (data->cname == NULL)
data->cname = xstrdup(optarg);
data->flag_global = 0;
break;
case 's':
if (data->cname != NULL)
goto usage;
if (data->sname == NULL)
data->sname = xstrdup(optarg);
case 't':
if (data->target == NULL)
data->target = xstrdup(optarg);
data->flag_global = 0;
break;
default:
@ -123,7 +112,7 @@ cmd_set_option_exec(struct cmd *self, unused struct cmd_ctx *ctx)
return;
if (data->flag_global ||
((s = cmd_find_session(ctx, data->cname, data->sname))) == NULL)
((s = cmd_find_session(ctx, data->target))) == NULL)
oo = &global_options;
else
oo = &s->options;
@ -282,8 +271,7 @@ cmd_set_option_send(struct cmd *self, struct buffer *b)
struct cmd_set_option_data *data = self->data;
buffer_write(b, data, sizeof *data);
cmd_send_string(b, data->cname);
cmd_send_string(b, data->sname);
cmd_send_string(b, data->target);
cmd_send_string(b, data->option);
cmd_send_string(b, data->value);
}
@ -295,8 +283,7 @@ cmd_set_option_recv(struct cmd *self, struct buffer *b)
self->data = data = xmalloc(sizeof *data);
buffer_read(b, data, sizeof *data);
data->cname = cmd_recv_string(b);
data->sname = cmd_recv_string(b);
data->target = cmd_recv_string(b);
data->option = cmd_recv_string(b);
data->value = cmd_recv_string(b);
}
@ -306,10 +293,8 @@ cmd_set_option_free(struct cmd *self)
{
struct cmd_set_option_data *data = self->data;
if (data->cname != NULL)
xfree(data->cname);
if (data->sname != NULL)
xfree(data->sname);
if (data->target != NULL)
xfree(data->target);
if (data->option != NULL)
xfree(data->option);
if (data->value != NULL)

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

@ -1,4 +1,4 @@
/* $Id: cmd-set-window-option.c,v 1.4 2008-06-05 17:12:11 nicm Exp $ */
/* $Id: cmd-set-window-option.c,v 1.5 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -36,23 +36,21 @@ void cmd_set_window_option_free(struct cmd *);
void cmd_set_window_option_print(struct cmd *, char *, size_t);
struct cmd_set_window_option_data {
char *cname;
char *sname;
int idx;
char *target;
char *option;
char *value;
};
const struct cmd_entry cmd_set_window_option_entry = {
"set-window-option", "setw",
"[-c client-tty|-s session-name] [-i index] option value",
"[-t target-window] option value",
0,
NULL,
cmd_set_window_option_parse,
cmd_set_window_option_exec,
cmd_set_window_option_send,
cmd_set_window_option_recv,
cmd_set_window_option_free,
NULL,
cmd_set_window_option_print
};
@ -62,35 +60,17 @@ cmd_set_window_option_parse(
{
struct cmd_set_window_option_data *data;
int opt;
const char *errstr;
self->data = data = xmalloc(sizeof *data);
data->cname = NULL;
data->sname = NULL;
data->idx = -1;
data->target = NULL;
data->option = NULL;
data->value = NULL;
while ((opt = getopt(argc, argv, "c:i:s:")) != EOF) {
while ((opt = getopt(argc, argv, "t:")) != EOF) {
switch (opt) {
case 'c':
if (data->sname != NULL)
goto usage;
if (data->cname == NULL)
data->cname = xstrdup(optarg);
break;
case 'i':
data->idx = strtonum(optarg, 0, INT_MAX, &errstr);
if (errstr != NULL) {
xasprintf(cause, "index %s", errstr);
goto error;
}
break;
case 's':
if (data->cname != NULL)
goto usage;
if (data->sname == NULL)
data->sname = xstrdup(optarg);
case 't':
if (data->target == NULL)
data->target = xstrdup(optarg);
break;
default:
goto usage;
@ -110,13 +90,12 @@ cmd_set_window_option_parse(
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
error:
self->entry->free(self);
return (-1);
}
void
cmd_set_window_option_exec(struct cmd *self, unused struct cmd_ctx *ctx)
cmd_set_window_option_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_set_window_option_data *data = self->data;
struct winlink *wl;
@ -128,10 +107,7 @@ cmd_set_window_option_exec(struct cmd *self, unused struct cmd_ctx *ctx)
if (data == NULL)
return;
if (data == NULL)
return;
wl = cmd_find_window(ctx, data->cname, data->sname, data->idx, &s);
wl = cmd_find_window(ctx, data->target, &s);
if (wl == NULL)
return;
@ -189,8 +165,7 @@ cmd_set_window_option_send(struct cmd *self, struct buffer *b)
struct cmd_set_window_option_data *data = self->data;
buffer_write(b, data, sizeof *data);
cmd_send_string(b, data->cname);
cmd_send_string(b, data->sname);
cmd_send_string(b, data->target);
cmd_send_string(b, data->option);
cmd_send_string(b, data->value);
}
@ -202,8 +177,7 @@ cmd_set_window_option_recv(struct cmd *self, struct buffer *b)
self->data = data = xmalloc(sizeof *data);
buffer_read(b, data, sizeof *data);
data->cname = cmd_recv_string(b);
data->sname = cmd_recv_string(b);
data->target = cmd_recv_string(b);
data->option = cmd_recv_string(b);
data->value = cmd_recv_string(b);
}
@ -213,10 +187,8 @@ cmd_set_window_option_free(struct cmd *self)
{
struct cmd_set_window_option_data *data = self->data;
if (data->cname != NULL)
xfree(data->cname);
if (data->sname != NULL)
xfree(data->sname);
if (data->target != NULL)
xfree(data->target);
if (data->option != NULL)
xfree(data->option);
if (data->value != NULL)
@ -233,6 +205,8 @@ cmd_set_window_option_print(struct cmd *self, char *buf, size_t len)
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return;
if (off < len && data->target != NULL)
off += xsnprintf(buf + off, len - off, " -t %s", data->target);
if (off < len && data->option != NULL)
off += xsnprintf(buf + off, len - off, " %s", data->option);
if (off < len && data->value != NULL)

4
cmd-start-server.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-start-server.c,v 1.4 2008-06-05 16:35:32 nicm Exp $ */
/* $Id: cmd-start-server.c,v 1.5 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -31,8 +31,8 @@ const struct cmd_entry cmd_start_server_entry = {
"",
CMD_STARTSERVER,
NULL,
cmd_start_server_exec,
NULL,
cmd_start_server_exec,
NULL,
NULL,
NULL,

219
cmd-swap-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-swap-window.c,v 1.10 2008-06-05 17:12:11 nicm Exp $ */
/* $Id: cmd-swap-window.c,v 1.11 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -27,216 +27,47 @@
* Swap one window with another.
*/
int cmd_swap_window_parse(struct cmd *, int, char **, char **);
void cmd_swap_window_exec(struct cmd *, struct cmd_ctx *);
void cmd_swap_window_send(struct cmd *, struct buffer *);
void cmd_swap_window_recv(struct cmd *, struct buffer *);
void cmd_swap_window_free(struct cmd *);
void cmd_swap_window_print(struct cmd *, char *, size_t);
struct cmd_swap_window_data {
char *cname;
char *sname;
int idx;
int srcidx;
char *srcname;
int flag_detached;
};
const struct cmd_entry cmd_swap_window_entry = {
"swap-window", "swapw",
"[-d] [-c client-tty|-s session-name] [-i index] session-name index",
0,
cmd_swap_window_parse,
"[-d] " CMD_SRCDST_WINDOW_USAGE,
CMD_DFLAG,
cmd_srcdst_init,
cmd_srcdst_parse,
cmd_swap_window_exec,
cmd_swap_window_send,
cmd_swap_window_recv,
cmd_swap_window_free,
NULL,
cmd_swap_window_print
cmd_srcdst_send,
cmd_srcdst_recv,
cmd_srcdst_free,
cmd_srcdst_print
};
int
cmd_swap_window_parse(struct cmd *self, int argc, char **argv, char **cause)
{
struct cmd_swap_window_data *data;
const char *errstr;
int opt;
self->data = data = xmalloc(sizeof *data);
data->cname = NULL;
data->sname = NULL;
data->flag_detached = 0;
data->idx = -1;
data->srcidx = -1;
data->srcname = NULL;
while ((opt = getopt(argc, argv, "c:di:s:")) != EOF) {
switch (opt) {
case 'c':
if (data->sname != NULL)
goto usage;
if (data->cname == NULL)
data->cname = xstrdup(optarg);
break;
case 'd':
data->flag_detached = 1;
break;
case 'i':
data->idx = strtonum(optarg, 0, INT_MAX, &errstr);
if (errstr != NULL) {
xasprintf(cause, "index %s", errstr);
goto error;
}
break;
case 's':
if (data->cname != NULL)
goto usage;
if (data->sname == NULL)
data->sname = xstrdup(optarg);
break;
default:
goto usage;
}
}
argc -= optind;
argv += optind;
if (argc != 2)
goto usage;
data->srcname = xstrdup(argv[0]);
data->srcidx = strtonum(argv[1], 0, INT_MAX, &errstr);
if (errstr != NULL) {
xasprintf(cause, "index %s", errstr);
goto error;
}
return (0);
usage:
xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
error:
self->entry->free(self);
return (-1);
}
void
cmd_swap_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct cmd_swap_window_data *data = self->data;
struct session *s, *src;
struct winlink *srcwl, *dstwl;
struct window *w;
struct cmd_srcdst_data *data = self->data;
struct session *src, *dst;
struct winlink *wl_src, *wl_dst;
struct window *w;
if (data == NULL)
if ((wl_src = cmd_find_window(ctx, data->src, &src)) == NULL)
return;
if ((wl_dst = cmd_find_window(ctx, data->dst, &dst)) == NULL)
return;
if ((s = cmd_find_session(ctx, data->cname, data->sname)) == NULL)
return;
w = wl_dst->window;
wl_dst->window = wl_src->window;
wl_src->window = w;
if ((src = session_find(data->srcname)) == NULL) {
ctx->error(ctx, "session not found: %s", data->srcname);
return;
}
if (data->srcidx < 0)
data->srcidx = -1;
if (data->srcidx == -1)
srcwl = src->curw;
else {
srcwl = winlink_find_by_index(&src->windows, data->srcidx);
if (srcwl == NULL) {
ctx->error(ctx, "no window %d", data->srcidx);
return;
}
}
if (data->idx < 0)
data->idx = -1;
if (data->idx == -1)
dstwl = s->curw;
else {
dstwl = winlink_find_by_index(&s->windows, data->idx);
if (dstwl == NULL) {
ctx->error(ctx, "no window %d", data->idx);
return;
}
}
w = dstwl->window;
dstwl->window = srcwl->window;
srcwl->window = w;
if (!data->flag_detached) {
session_select(s, dstwl->idx);
if (src != s)
session_select(src, srcwl->idx);
if (!(data->flags & CMD_DFLAG)) {
session_select(dst, wl_dst->idx);
if (src != dst)
session_select(src, wl_src->idx);
}
server_redraw_session(src);
if (src != s)
server_redraw_session(s);
if (src != dst)
server_redraw_session(dst);
if (ctx->cmdclient != NULL)
server_write_client(ctx->cmdclient, MSG_EXIT, NULL, 0);
}
void
cmd_swap_window_send(struct cmd *self, struct buffer *b)
{
struct cmd_swap_window_data *data = self->data;
buffer_write(b, data, sizeof *data);
cmd_send_string(b, data->cname);
cmd_send_string(b, data->sname);
cmd_send_string(b, data->srcname);
}
void
cmd_swap_window_recv(struct cmd *self, struct buffer *b)
{
struct cmd_swap_window_data *data;
self->data = data = xmalloc(sizeof *data);
buffer_read(b, data, sizeof *data);
data->cname = cmd_recv_string(b);
data->sname = cmd_recv_string(b);
data->srcname = cmd_recv_string(b);
}
void
cmd_swap_window_free(struct cmd *self)
{
struct cmd_swap_window_data *data = self->data;
if (data->cname != NULL)
xfree(data->cname);
if (data->sname != NULL)
xfree(data->sname);
if (data->srcname != NULL)
xfree(data->srcname);
xfree(data);
}
void
cmd_swap_window_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_swap_window_data *data = self->data;
size_t off = 0;
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return;
if (off < len && data->flag_detached)
off += xsnprintf(buf + off, len - off, " -d");
if (off < len && data->cname != NULL)
off += xsnprintf(buf + off, len - off, " -c %s", data->cname);
if (off < len && data->sname != NULL)
off += xsnprintf(buf + off, len - off, " -s %s", data->sname);
if (off < len && data->idx != -1)
off += xsnprintf(buf + off, len - off, " -i %d", data->idx);
if (off < len && data->srcname != NULL)
off += xsnprintf(buf + off, len - off, " %s", data->srcname);
if (off < len && data->srcidx != -1)
off += xsnprintf(buf + off, len - off, " %d", data->srcidx);
}

43
cmd-switch-client.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-switch-client.c,v 1.8 2008-06-05 17:12:11 nicm Exp $ */
/* $Id: cmd-switch-client.c,v 1.9 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -36,20 +36,20 @@ void cmd_switch_client_free(struct cmd *);
void cmd_switch_client_print(struct cmd *, char *, size_t);
struct cmd_switch_client_data {
char *cname;
char *name;
char *target;
};
const struct cmd_entry cmd_switch_client_entry = {
"switch-client", "switchc",
"[-c client-tty] session-name",
"[-c client-tty] [-t target-session]",
0,
NULL,
cmd_switch_client_parse,
cmd_switch_client_exec,
cmd_switch_client_send,
cmd_switch_client_recv,
cmd_switch_client_free,
NULL,
cmd_switch_client_print
};
@ -60,13 +60,16 @@ cmd_switch_client_parse(struct cmd *self, int argc, char **argv, char **cause)
int opt;
self->data = data = xmalloc(sizeof *data);
data->cname = NULL;
data->name = NULL;
data->target = NULL;
while ((opt = getopt(argc, argv, "c:")) != EOF) {
while ((opt = getopt(argc, argv, "c:t:")) != EOF) {
switch (opt) {
case 'c':
data->cname = xstrdup(optarg);
data->name = xstrdup(optarg);
break;
case 't':
data->target = xstrdup(optarg);
break;
default:
goto usage;
@ -74,11 +77,9 @@ cmd_switch_client_parse(struct cmd *self, int argc, char **argv, char **cause)
}
argc -= optind;
argv += optind;
if (argc != 1)
if (argc != 0)
goto usage;
data->name = xstrdup(argv[0]);
return (0);
usage:
@ -98,13 +99,11 @@ cmd_switch_client_exec(struct cmd *self, struct cmd_ctx *ctx)
if (data == NULL)
return;
if ((c = cmd_find_client(ctx, data->cname)) == NULL)
if ((c = cmd_find_client(ctx, data->name)) == NULL)
return;
if ((s = session_find(data->name)) == NULL) {
ctx->error(ctx, "session not found: %s", data->name);
if ((s = cmd_find_session(ctx, data->target)) == NULL)
return;
}
c->session = s;
recalculate_sizes();
@ -120,8 +119,8 @@ cmd_switch_client_send(struct cmd *self, struct buffer *b)
struct cmd_switch_client_data *data = self->data;
buffer_write(b, data, sizeof *data);
cmd_send_string(b, data->cname);
cmd_send_string(b, data->name);
cmd_send_string(b, data->target);
}
void
@ -131,8 +130,8 @@ cmd_switch_client_recv(struct cmd *self, struct buffer *b)
self->data = data = xmalloc(sizeof *data);
buffer_read(b, data, sizeof *data);
data->cname = cmd_recv_string(b);
data->name = cmd_recv_string(b);
data->target = cmd_recv_string(b);
}
void
@ -140,10 +139,10 @@ cmd_switch_client_free(struct cmd *self)
{
struct cmd_switch_client_data *data = self->data;
if (data->cname != NULL)
xfree(data->cname);
if (data->name != NULL)
xfree(data->name);
if (data->target != NULL)
xfree(data->target);
xfree(data);
}
@ -156,8 +155,8 @@ cmd_switch_client_print(struct cmd *self, char *buf, size_t len)
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return;
if (off < len && data->cname != NULL)
off += xsnprintf(buf + off, len - off, " -c %s", data->cname);
if (off < len && data->name != NULL)
off += xsnprintf(buf + off, len - off, " %s", data->name);
off += xsnprintf(buf + off, len - off, " -c %s", data->name);
if (off < len && data->target != NULL)
off += xsnprintf(buf + off, len - off, " -t %s", data->target);
}

6
cmd-unbind-key.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-unbind-key.c,v 1.12 2008-06-05 16:35:32 nicm Exp $ */
/* $Id: cmd-unbind-key.c,v 1.13 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -33,19 +33,19 @@ void cmd_unbind_key_recv(struct cmd *, struct buffer *);
void cmd_unbind_key_free(struct cmd *);
struct cmd_unbind_key_data {
int key;
int key;
};
const struct cmd_entry cmd_unbind_key_entry = {
"unbind-key", "unbind",
"key",
0,
NULL,
cmd_unbind_key_parse,
cmd_unbind_key_exec,
cmd_unbind_key_send,
cmd_unbind_key_recv,
cmd_unbind_key_free,
NULL,
NULL
};

29
cmd-unlink-window.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd-unlink-window.c,v 1.10 2008-06-05 16:35:32 nicm Exp $ */
/* $Id: cmd-unlink-window.c,v 1.11 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -28,27 +28,28 @@ void cmd_unlink_window_exec(struct cmd *, struct cmd_ctx *);
const struct cmd_entry cmd_unlink_window_entry = {
"unlink-window", "unlinkw",
CMD_WINDOWONLY_USAGE,
CMD_TARGET_WINDOW_USAGE,
0,
cmd_windowonly_parse,
cmd_target_init,
cmd_target_parse,
cmd_unlink_window_exec,
cmd_windowonly_send,
cmd_windowonly_recv,
cmd_windowonly_free,
NULL,
NULL
cmd_target_send,
cmd_target_recv,
cmd_target_free,
cmd_target_print
};
void
cmd_unlink_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct winlink *wl;
struct session *s;
struct client *c;
u_int i;
int destroyed;
struct cmd_target_data *data = self->data;
struct winlink *wl;
struct session *s;
struct client *c;
u_int i;
int destroyed;
if ((wl = cmd_windowonly_get(self, ctx, &s)) == NULL)
if ((wl = cmd_find_window(ctx, data->target, &s)) == NULL)
return;
if (wl->window->references == 1) {

156
cmd.c
View File

@ -1,4 +1,4 @@
/* $Id: cmd.c,v 1.42 2008-06-05 16:35:32 nicm Exp $ */
/* $Id: cmd.c,v 1.43 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -19,8 +19,8 @@
#include <sys/types.h>
#include <sys/time.h>
#include <fnmatch.h>
#include <getopt.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
@ -63,9 +63,6 @@ const struct cmd_entry *cmd_table[] = {
NULL
};
struct client *cmd_lookup_client(const char *);
struct session *cmd_lookup_session(const char *);
struct cmd *
cmd_parse(int argc, char **argv, char **cause)
{
@ -236,94 +233,13 @@ cmd_recv_string(struct buffer *b)
return (s);
}
struct client *
cmd_lookup_client(const char *cname)
{
struct client *c;
u_int i;
for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
c = ARRAY_ITEM(&clients, i);
if (c != NULL && strcmp(cname, c->tty.path) == 0)
return (c);
}
return (NULL);
}
struct session *
cmd_lookup_session(const char *sname)
cmd_current_session(struct cmd_ctx *ctx)
{
struct session *s, *newest = NULL;
struct timespec *ts;
u_int i;
ts = NULL;
for (i = 0; i < ARRAY_LENGTH(&sessions); i++) {
s = ARRAY_ITEM(&sessions, i);
if (s == NULL || fnmatch(sname, s->name, 0) != 0)
continue;
if (ts == NULL || timespeccmp(&s->ts, ts, >)) {
newest = s;
ts = &s->ts;
}
}
return (newest);
}
/*
* Figure out the client. Try the given client name first, then the current
* client.
*/
struct client *
cmd_find_client(unused struct cmd_ctx *ctx, const char *cname)
{
struct client *c;
if (cname != NULL) {
if ((c = cmd_lookup_client(cname)) == NULL)
ctx->error(ctx, "client not found: %s", cname);
return (c);
}
if (ctx->curclient != NULL)
return (ctx->curclient);
ctx->error(ctx, "must specify a client");
return (NULL);
}
/*
* Attempt to establish session. This looks first at the given arguments,
* if any, then sees if there is a session in the context, then finally tries
* the session data passed up from the client $TMUX variable.
*/
struct session *
cmd_find_session(struct cmd_ctx *ctx, const char *cname, const char *sname)
{
struct session *s, *newest = NULL;
struct client *c;
struct msg_command_data *data = ctx->msgdata;
u_int i;
struct timespec *ts;
if (cname != NULL) {
if ((c = cmd_lookup_client(cname)) == NULL) {
ctx->error(ctx, "client not found: %s", cname);
return (NULL);
}
if (c->session == NULL)
ctx->error(ctx, "client has no session: %s", cname);
return (c->session);
}
if (sname != NULL) {
if ((s = cmd_lookup_session(sname)) == NULL)
ctx->error(ctx, "session not found: %s", sname);
return (s);
}
struct session *s, *newest = NULL;
u_int i;
if (ctx->cursession != NULL)
return (ctx->cursession);
@ -343,7 +259,7 @@ cmd_find_session(struct cmd_ctx *ctx, const char *cname, const char *sname)
}
return (s);
}
ts = NULL;
for (i = 0; i < ARRAY_LENGTH(&sessions); i++) {
s = ARRAY_ITEM(&sessions, i);
@ -352,26 +268,60 @@ cmd_find_session(struct cmd_ctx *ctx, const char *cname, const char *sname)
ts = &s->ts;
}
}
if (newest == NULL)
ctx->error(ctx, "no sessions found");
return (newest);
}
struct winlink *
cmd_find_window(struct cmd_ctx *ctx,
const char *cname, const char *sname, int idx, struct session **sp)
struct client *
cmd_find_client(struct cmd_ctx *ctx, const char *arg)
{
struct session *s;
struct winlink *wl;
struct client *c;
if ((c = arg_parse_client(arg)) == NULL)
c = ctx->curclient;
if (c == NULL)
ctx->error(ctx, "client not found: %s", arg);
return (c);
}
if ((s = cmd_find_session(ctx, cname, sname)) == NULL)
struct session *
cmd_find_session(struct cmd_ctx *ctx, const char *arg)
{
struct session *s;
if ((s = arg_parse_session(arg)) == NULL)
s = ctx->cursession;
if (s == NULL)
s = cmd_current_session(ctx);
if (s == NULL)
ctx->error(ctx, "session not found: %s", arg);
return (s);
}
struct winlink *
cmd_find_window(struct cmd_ctx *ctx, const char *arg, struct session **sp)
{
struct session *s;
struct winlink *wl;
int idx;
wl = NULL;
if (arg_parse_window(arg, &s, &idx) != 0) {
ctx->error(ctx, "bad window: %s", arg);
return (NULL);
}
if (s == NULL)
s = ctx->cursession;
if (s == NULL)
s = cmd_current_session(ctx);
if (s != NULL) {
if (idx == -1)
wl = s->curw;
else
wl = winlink_find_by_index(&s->windows, idx);
}
if (sp != NULL)
*sp = s;
if (idx == -1)
return (s->curw);
if ((wl = winlink_find_by_index(&s->windows, idx)) == NULL)
ctx->error(ctx, "no window %d", idx);
if (wl == NULL)
ctx->error(ctx, "window not found: %s:%d", s->name, idx);
return (wl);
}

19
tmux.1
View File

@ -1,4 +1,4 @@
.\" $Id: tmux.1,v 1.28 2008-06-05 15:55:59 nicm Exp $
.\" $Id: tmux.1,v 1.29 2008-06-05 21:25:00 nicm Exp $
.\"
.\" Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
.\"
@ -185,8 +185,9 @@ and
keys or
.Xr vi 1
style
.Ql j ,
.Ql k ,
.Ql j
and
.Ql k
keys may be used to scroll the output up and down.
The
.Ql q
@ -212,8 +213,14 @@ In addition,
.Ql ^A
and
.Ql ^E
move to the start and end of the line; the space key begins a selection; and the
enter key or
(or the
.Xr vi 1
style
.Ql 0
and
.Ql $
keys) move to the start and end of the line; the space key begins a selection;
and the enter key or
.Ql ^W
copies the selection to the paste buffer and exits copy mode.
.Pp
@ -387,7 +394,7 @@ The
.Ev TERM
environment variable must be set to
.Dq screen
for all program running
for all programs running
.Em inside
.Nm .
New windows will automatically have

84
tmux.h
View File

@ -1,4 +1,4 @@
/* $Id: tmux.h,v 1.132 2008-06-05 16:35:32 nicm Exp $ */
/* $Id: tmux.h,v 1.133 2008-06-05 21:25:00 nicm Exp $ */
/*
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@ -685,31 +685,32 @@ struct cmd_entry {
#define CMD_STARTSERVER 0x1
#define CMD_CANTNEST 0x2
#define CMD_KFLAG 0x4
#define CMD_DFLAG 0x8
#define CMD_ONEARG 0x10
int flags;
void (*init)(struct cmd *, int);
int (*parse)(struct cmd *, int, char **, char **);
void (*exec)(struct cmd *, struct cmd_ctx *);
void (*send)(struct cmd *, struct buffer *);
void (*recv)(struct cmd *, struct buffer *);
void (*free)(struct cmd *);
void (*init)(struct cmd *, int);
void (*print)(struct cmd *, char *, size_t);
};
/* Generic command data. */
struct cmd_clientonly_data {
char *cname;
struct cmd_target_data {
int flags;
char *target;
char *arg;
};
struct cmd_sessiononly_data {
char *cname;
char *sname;
};
struct cmd_windowonly_data {
char *cname;
char *sname;
int idx;
struct cmd_srcdst_data {
int flags;
char *src;
char *dst;
char *arg;
};
/* Key binding. */
@ -781,6 +782,11 @@ void tty_vwrite_window(void *, int, va_list);
void tty_write_session(void *, int, ...);
void tty_vwrite_session(void *, int, va_list);
/* arg.c */
struct client *arg_parse_client(const char *);
struct session *arg_parse_session(const char *);
int arg_parse_window(const char *, struct session **, int *);
/* cmd.c */
struct cmd *cmd_parse(int, char **, char **);
void cmd_exec(struct cmd *, struct cmd_ctx *);
@ -789,10 +795,11 @@ struct cmd *cmd_recv(struct buffer *);
void cmd_free(struct cmd *);
void cmd_send_string(struct buffer *, const char *);
char *cmd_recv_string(struct buffer *);
struct session *cmd_current_session(struct cmd_ctx *);
struct client *cmd_find_client(struct cmd_ctx *, const char *);
struct session *cmd_find_session(struct cmd_ctx *, const char *, const char *);
struct winlink *cmd_find_window(struct cmd_ctx *,
const char *, const char *, int, struct session **);
struct session *cmd_find_session(struct cmd_ctx *, const char *);
struct winlink *cmd_find_window(
struct cmd_ctx *, const char *, struct session **);
extern const struct cmd_entry cmd_attach_session_entry;
extern const struct cmd_entry cmd_bind_key_entry;
extern const struct cmd_entry cmd_copy_mode_entry;
@ -828,31 +835,26 @@ extern const struct cmd_entry cmd_unbind_key_entry;
extern const struct cmd_entry cmd_unlink_window_entry;
/* cmd-generic.c */
#define CMD_CLIENTONLY_USAGE "[-c client-tty]"
int cmd_clientonly_parse(struct cmd *, int, char **, char **);
void cmd_clientonly_exec(struct cmd *, struct cmd_ctx *);
void cmd_clientonly_send(struct cmd *, struct buffer *);
void cmd_clientonly_recv(struct cmd *, struct buffer *);
void cmd_clientonly_free(struct cmd *);
struct client *cmd_clientonly_get(struct cmd *, struct cmd_ctx *);
void cmd_clientonly_print(struct cmd *, char *, size_t);
#define CMD_SESSIONONLY_USAGE "[-c client-tty|-s session-name]"
int cmd_sessiononly_parse(struct cmd *, int, char **, char **);
void cmd_sessiononly_exec(struct cmd *, struct cmd_ctx *);
void cmd_sessiononly_send(struct cmd *, struct buffer *);
void cmd_sessiononly_recv(struct cmd *, struct buffer *);
void cmd_sessiononly_free(struct cmd *);
struct session *cmd_sessiononly_get(struct cmd *, struct cmd_ctx *);
void cmd_sessiononly_print(struct cmd *, char *, size_t);
#define CMD_WINDOWONLY_USAGE "[-c client-tty|-s session-name] [-i index]"
int cmd_windowonly_parse(struct cmd *, int, char **, char **);
void cmd_windowonly_exec(struct cmd *, struct cmd_ctx *);
void cmd_windowonly_send(struct cmd *, struct buffer *);
void cmd_windowonly_recv(struct cmd *, struct buffer *);
void cmd_windowonly_free(struct cmd *);
struct winlink *cmd_windowonly_get(
struct cmd *, struct cmd_ctx *, struct session **);
void cmd_windowonly_print(struct cmd *, char *, size_t);
#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_exec(struct cmd *, struct cmd_ctx *);
void cmd_target_send(struct cmd *, struct buffer *);
void cmd_target_recv(struct cmd *, struct buffer *);
void cmd_target_free(struct cmd *);
void cmd_target_print(struct cmd *, char *, size_t);
#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_exec(struct cmd *, struct cmd_ctx *);
void cmd_srcdst_send(struct cmd *, struct buffer *);
void cmd_srcdst_recv(struct cmd *, struct buffer *);
void cmd_srcdst_free(struct cmd *);
void cmd_srcdst_print(struct cmd *, char *, size_t);
/* client.c */
int client_init(const char *, struct client_ctx *, int);