Tag 1.6 release.

Remove unused backoff code that doesn't do any good.

CHANGES

@@ -1,3 +1,225 @@
+CHANGES FROM 1.5 TO 1.6, 23 January 2012
+
+* Extend the mode-mouse option to add a third choice which means the mouse
+  does not enter copy mode.
+* Add a -r flag to switch-client to toggle the client read-only flag.
+* Add pane-base-index option.
+* Support \ for line continuation in the configuration file.
+* Framework for more powerful formatting of command output and use it for
+  list-{panes,windows,sessions}. This allows more descriptive replacements
+  (such as #{session_name}) and conditionals.
+* Mark dead panes with some text saying they are dead.
+* Reject $SHELL if it is not a full path.
+* Add -S option to refresh-client to redraw status line.
+* Add an else clause for if-shell.
+* Try to resolve relative paths for loadb and saveb (first, using client
+  working directory, if any, then default-path or session working directory).
+* Support for \e[3J to clear the history and send the corresponding
+  terminfo code (E3) before locking.
+* When in copy mode, make repeat count indicate buffer to replace, if used.
+* Add screen*:XT to terminal-overrides for tmux-in-tmux.
+* Status-line message attributes added.
+* Move word-separators to be a session rather than window option.
+* Change the way the working directory for new processes is discovered. If
+  default-path isn't empty, it is used. Otherwise, if a new window is created
+  from the command-line, the working directory of the client is used. If not,
+  platform specific code is used to retrieve the current working directory
+  of the process in the active pane. If that fails, the directory where the
+  session was created is used, instead.
+* Do not change the current pane if both mouse-select-{pane,window} are
+  enabled.
+* Add \033[s and \033[u to save and restore cursor position.
+* Allow $HOME to be used as default-path.
+* Add CNL and CPL escape sequences.
+* Calculate last position correctly for UTF-8 wide characters.
+* Add an option allow-rename to disable the window rename escape sequence.
+* Attributes for each type of status-line alert (ie bell, content and
+  activity) added. Therefore, remove the superfluous options
+  window-status-alert-{attr,bg,fg}.
+* Add a -R flag to send-keys to reset the terminal.
+* Add strings to allow the aixterm bright colours to be used when
+  configuring colours.
+* Drop the ability to have a list of keys in the prefix in favour of two
+  separate options, prefix and prefix2.
+* Flag -2 added to send-prefix to send the secondary prefix key.
+* Show pane size in top right of display panes mode.
+* Some memory leaks plugged.
+* More command-prompt editing improvements.
+* Various manpage improvements.
+* More Vi mode improvements.
+
+CHANGES FROM 1.4 TO 1.5, 09 July 2011
+
+* Support xterm mouse modes 1002 and 1003.
+* Change from a per-session stack of buffers to one global stack. This renders
+  copy-buffer useless and makes buffer-limit now a server option.
+* Fix most-recently-used choice by avoiding reset the activity timer for
+  unattached sessions every second.
+* Add a -P option to new-window and split-window to print the new window or
+  pane index in target form (useful to pass it into other commands).
+* Handle a # at the end of a replacement string (such as status-left)
+  correctly.
+* Support for UTF-8 mouse input (\033[1005h) which was added in xterm 262.
+  If the new mouse-utf8 option is on, UTF-8 mouse input is enabled for all
+  UTF-8 terminals. The option defaults to on if LANG etc are set in the same
+  manner as the utf8 option.
+* Support for HP-UX.
+* Accept colours of the hex form #ffffff and translate to the nearest from the
+  xterm(1) 256-colour set.
+* Clear the non-blocking IO flag (O_NONBLOCK) on the stdio file descriptors
+  before closing them (fixes things like "tmux ls && cat").
+* Use TMPDIR if set.
+* Fix next and previous session functions to actually work.
+* Support -x and -y for new-session to specify the initial size of the window
+  if created detached with -d.
+* Make bind-key accept characters with the top-bit-set and print them as octal.
+* Set $TMUX without the session when background jobs are run.
+* Simplify the way jobs work and drop the persist type, so all jobs are
+  fire-and-forget.
+* Accept tcgetattr/tcsetattr(3) failure, fixes problems with fatal() if the
+  terminal disappears while locked.
+* Add a -P option to detach to HUP the client's parent process (usually causing
+  it to exit as well).
+* Support passing through escape sequences to the underlying terminal by using
+  DCS with a "tmux;" prefix.
+* Prevent tiled producing a corrupt layout when only one column is needed.
+* Give each pane created in a tmux server a unique id (starting from 0), put it
+  in the TMUX_PANE environment variable and accept it as a target.
+* Allow a start and end line to be specified for capture-pane which may be
+  negative to capture part of the history.
+* Add -a and -s options to lsp to list all panes in the server or session
+  respectively. Likewise add -s to lsw.
+* Change -t on display-message to be target-pane for the #[A-Z] replacements
+  and add -c as target-client.
+* The attach-session command now prefers the most recently used unattached
+  session.
+* Add -s option to detach-client to detach all clients attached to a session.
+* Add -t to list-clients.
+* Change window with mouse wheel over status line if mouse-select-window is on.
+* When mode-mouse is on, automatically enter copy mode when the mouse is
+  dragged or the mouse wheel is used. Also exit copy mode when the mouse wheel
+  is scrolled off the bottom.
+* Provide #h character pair for short hostname (no domain).
+* Don't use strnvis(3) for the title as it breaks UTF-8.
+* Use the tsl and fsl terminfo(5) capabilities to update terminal title and
+  automatically fill them in on terminals with the XT capability (which means
+  their title setting is xterm-compatible).
+* Add a new option, mouse-resize-pane. When on, panes may be resized by
+  dragging their borders.
+* Fix crash by resetting last pane on {break,swap}-pane across windows.
+* Add three new copy-mode commands - select-line, copy-line, copy-end-of-line.
+* Support setting the xterm clipboard when copying from copy mode using the
+  xterm escape sequence for the purpose (if xterm is configured to allow it).
+* Support xterm(1) cursor colour change sequences through terminfo(5) Cc
+  (set) and Cr (reset) extensions.
+* Support DECSCUSR sequence to set the cursor style with two new terminfo(5)
+  extensions, Cs and Csr.
+* Make the command-prompt custom prompts recognize the status-left option
+  character pairs.
+* Add a respawn-pane command.
+* Add a couple of extra xterm-style keys that gnome terminal provides.
+* Allow the initial context on prompts to be set with the new -I option to
+  command-prompt. Include the current window and session name in the prompt
+  when renaming and add a new key binding ($) for rename session.
+* Option bell-on-alert added to trigger the terminal bell when there is an
+  alert.
+* Change the list-keys format so that it shows the keys using actual tmux
+  commands which should be able to be directly copied into the config file.
+* Show full targets for lsp/lsw -a.
+* Make confirm-before prompt customizable with -p option like command-prompt
+  and add the character pairs #W and #P to the default kill-{pane,window}
+  prompts.
+* Avoid sending data to suspended/locked clients.
+* Small memory leaks in error paths plugged.
+* Vi mode improvements.
+
+CHANGES FROM 1.3 TO 1.4, 27 December 2010
+
+* Window bell reporting fixed.
+* Show which pane is active in the list-panes output.
+* Backoff reworked.
+* Prevent the server from dying when switching into copy mode when already
+  in a different mode.
+* Reset running jobs when the status line is enabled or disabled.
+* Simplify xterm modifier detection.
+* Avoid crashing in copy mode if the screen size is too small for the
+  indicator.
+* Flags -n and -p added to switch-client.
+* Use UTF-8 line drawing characters on UTF-8 terminals, thus fixing some
+  terminals (eg putty) which disable the vt100 ACS mode switching sequences
+  in UTF-8 mode. On terminals without ACS, use ASCII equivalents.
+* New server option exit-unattached added.
+* New session option destroy-unattached added.
+* Fall back on normal session choice method if $TMUX exists but is invalid
+  rather than rejecting.
+* Mark repeating keys with "(repeat)" in the key list.
+* When removing a pane, don't change the active pane unless the active pane
+  is actually the one being removed.
+* New command last-pane added.
+* AIX fixes.
+* Flag -a added to unbind-key.
+* Add XAUTHORITY to update-environment.
+* More info regarding window and pane flags is now shown in list-*.
+* If VISUAL or EDITOR contains "vi" configure mode-keys and status-key to vi.
+* New window option monitor-silence and session option visual-silence added.
+* In the built-in layouts distribute the panes more evenly.
+* Set the default value of main-pane-width to 80 instead of 81.
+* Command-line flag -V added.
+* Instead of keeping a per-client prompt history make it global.
+* Fix rectangle copy to behave like emacs (the cursor is not part of the
+  selection on the right edge but on the left it is).
+* Flag -l added to switch-client.
+* Retrieve environment variables from the global environment rather than
+  getenv(3), thus allowing them to be updated during the configuration file.
+* New window options other-pane-{height,width} added.
+* More minor bugs fixed and manpage improvements.
+
+CHANGES FROM 1.2 TO 1.3, 18 July 2010
+
+* New input parser.
+* Flags to move through panes -UDLR added to select-pane.
+* Commands up-pane, and down-pane removed, since equivalent behaviour is now
+  available through the target flag (-t:+ and -t:-).
+* Jump-forward/backward in copy move (based on vi's F, and f commands).
+* Make paste-buffer accept a pane as a target.
+* Flag -a added to new-window to insert a window after an existing one, moving
+  windows up if necessary.
+* Merge more mode into copy mode.
+* Run job commands explicitly in the global environment (which can be modified
+  with setenv -g), rather than with the environment tmux started with.
+* Use the machine's hostname as the default title, instead of an empty string.
+* Prevent double free if the window option remain-on-exit is set. 
+* Key string conversions rewritten.
+* Mark zombie windows as dead in the choose-window list.
+* Tiled layout added.
+* Signal handling reworked.
+* Reset SIGCHLD after fork to fix problems with some shells.
+* Select-prompt command removed. Therefore, bound ' to command-prompt -p index
+  "select-window -t:%%" by default.
+* Catch SIGHUP and terminate if running as a client, thus avoiding clients from
+  being left hanging around when, for instance, a SSH session is disconnected.
+* Solaris 9 fixes (such as adding compat {get,set}env(3) code).
+* Accept none instead of default for attributes.
+* Window options window-status-alert-{alert,bg,fg} added.
+* Flag -s added to the paste-buffer command to specify a custom separator.
+* Allow dragging to make a selection in copy mode if the mode-mouse option is
+  set.
+* Support the mouse scroll wheel.
+* Make pipe-pane accept special character sequences (eg #I).
+* Fix problems with window sizing when starting tmux from .xinitrc.
+* Give tmux sockets (but not the containing folder) group permissions.
+* Extend the target flags (ie -t) to accept an offset (for example -t:+2), and
+  make it wrap windows, and panes.
+* New command choose-buffer added.
+* New server option detach-on-destroy to set what happens to a client when the
+  session it is attached to is destroyed. If on (default), the client is
+  detached. Otherwise, the client is switched to the most recently active of
+  the remaining sessions.
+* The commands load-buffer, and save-buffer now accept a dash (-) as the file
+  to read from stdin, or write to stdout.
+* Custom layouts added.
+* Additional code reduction, bug fixes, and manpage enhancements.
+
 CHANGES FROM 1.1 TO 1.2, 10 March 2010
 
 * Switch to libevent.
@@ -1467,7 +1689,7 @@ The list of older changes is below.
   (including mutt, emacs). No status bar yet and no key remapping or other
   customisation.
 
-$Id: CHANGES,v 1.302 2010-03-10 15:18:11 tcunha Exp $
+$Id$
 
  LocalWords:  showw utf UTF fulvio ciriaco joshe OSC APC gettime abc DEF OA clr
  LocalWords:  rivo nurges lscm Erdely eol smysession mysession ek dstname RB ms

FAQ

@@ -12,29 +12,98 @@ tmux frequently asked questions
 * and derivatives.                                                           *
 ******************************************************************************
 
-* How is tmux different from GNU screen? What else does it offer?
+* How is tmux different from GNU screen?
 
-tmux offers several advantages over screen:
+tmux and GNU screen have many similarities. Some of the main differences I am
+aware of are (bearing in mind I haven't used screen for a few years now):
 
-- a clearly-defined client-server model: windows are independent entities which
+- tmux uses a client-server model. Each server has single Unix domain socket in
-  may be attached simultaneously to multiple sessions and viewed from multiple
+  /tmp and within one server there are multiple sessions which may be attached
-  clients (terminals), as well as moved freely between sessions within the same
+  to multiple clients (terminals).
-  tmux server;
-- a consistent, well-documented command interface, with the same syntax
-  whether used interactively, as a key binding, or from the shell;
-- easily scriptable from the shell;
-- multiple paste buffers;
-- choice of vi or emacs key layouts;
-- an option to limit the window size;
-- a more usable status line syntax, with the ability to display the first line
-  of output of a specific command;
-- a cleaner, modern, easily extended, BSD-licensed codebase.
 
-There are still a few features screen includes that tmux omits:
+  This has advantages, notably: windows may be linked simultaneously to
+  multiple sessions; windows may be moved freely between sessions; and a client
+  may be switched between sessions easily (C-b D). There is one major
+  disadvantage: if the server crashes, game over, all sessions die. In
+  practice, however, tmux is quite stable and gets more so as people report any
+  bugs they hit :-).
 
-- builtin serial and telnet support; this is bloat and is unlikely to be added
+  This model is different from screen, where typically each new screen instance
-  to tmux;
+  is independent. tmux supports the same behaviour by using multiple servers
-- wider platform support, for example IRIX and HP-UX, and for odd terminals.
+  with the -L option but it is not typically recommended.
+
+- Different command interfaces. One of the goals of tmux is that the shell
+  should be easily usable as a scripting language - almost all tmux commands
+  can be used from the shell and behave identically whether used from the
+  shell, from a key binding or from the command prompt. Personally I also find
+  tmux's command interface much more consistent and clearer, but this is
+  subjective.
+
+- tmux calls window names (what you see in the status line) "names", screen
+  calls them "titles".
+
+- tmux has a multiple paste buffers. Not a major one but comes in handy quite a
+  lot.
+
+- tmux supports automatically renaming windows to the running application
+  without gross hacks using escape sequences. Its even on by default.
+
+- tmux has a choice of vi or emacs key layouts. Again, not major, but I use
+  emacs so if tmux did support only one key set it would be emacs and then all
+  the vi users would get humpy. Key bindings may be completely reconfigured in
+  any case.
+
+- tmux has an option to limit the window size.
+
+- tmux has search in windows (C-b f).
+
+- The window split (pane) model is different. tmux has two objects, windows and
+  panes; screen has just windows. This difference has several implications:
+
+  * In screen you can have a window appear in several layouts, in tmux a pane
+  can only be in one window (fixing this is a big todo item but quite
+  invasive).
+
+  * tmux layouts are immutable and do not get changed unless you modify them.
+
+  * In tmux, all panes are closed when you kill a window.
+
+  * tmux panes do not have individual names, titles and so on.
+
+  I think tmux's model is much easier to manage and navigate within a window,
+  but breaking panes off from and joining them to windows is more clumsy.
+
+  tmux also has support for preset pane layouts.
+
+- tmux's status line syntax is more readable and easier to use. I think it'd be
+  hard for anyone to argue with this. tmux doesn't support running a command
+  constantly and always using the last line of its output, commands must be run
+  again each time.
+
+- tmux has modern, easily extended code. Again hard to argue screen is better
+  if you have looked at the code.
+
+- tmux depends on libevent. I don't see this as a disadvantage: libevent is
+  small and portable, and on modern systems with current package management
+  systems dependencies are not an issue. libevent brings advantages in code
+  simplicity and performance.
+
+- screen allows the window to be bigger than the terminal and can pan around
+  it. tmux limits the size to the largest attached client. This is a big todo
+  item for tmux but it is not trivial.
+
+- screen has builtin serial and telnet support; this is bloat and is unlikely
+  to be added to tmux.
+
+- screen has support for updating utmp. Nobody has really come up with a clean,
+  portable way to do this without making tmux setuid or setgid yet.
+
+- Environment handling is different.
+
+- tmux tends to be more demanding on the terminal so tends to show up terminal
+  and application bugs which screen does not.
+
+- screen has wider platform support, for example IRIX, and for odd terminals.
 
 * I found a bug! What do I do?
 
@@ -167,6 +236,8 @@ the ctrl (bit 5 set, for example ^[[5~ to ^[[5^) modifier in non-xterm(1) mode;
 it may be possible to configure vim to accept these, an example of how to do so
 would be welcome.
 
+vim users may also want to set the "ttyfast" option inside tmux.
+
 * Why doesn't elinks set the window title inside tmux?
 
 There isn't a way to detect if a terminal supports setting the window title, so
@@ -239,4 +310,104 @@ set -g terminal-overrides "xterm*:kLFT5=\eOD:kRIT5=\eOC:kUP5=\eOA:kDN5=\eOB:smkx
 
 Note that this will only work in tmux 1.2 and above.
 
-$Id: FAQ,v 1.36 2010-02-04 21:01:59 nicm Exp $
+* How can I blank the tmux window?
+
+GNU screen has a feature whereby it will blank the screen after a period of
+inactivity. To do the same thing in tmux, use the lock-command setting, for
+example (with GNU bash):
+
+set -g lock-command 'tput civis && read -s -n1'
+
+This will remove the cursor and tell the shell to quit once a key has been
+pressed. For zsh, use "read -s -k1".
+
+In addition, it's possible to have both blanking and locking (for instance via
+lock(1) or vlock(1)) by using the following:
+
+bind x set lock-command '/usr/bin/vlock' \; lock-client \; set lock-command 'tput civis && read -s -n1'
+
+* How can I open a new window in the same directory as the current window?
+
+One option is to just run "TMUX= tmux" in the window. However, this only works if no
+command is running, so that you can input the command.
+
+A workaround is to let tmux know about the current path through an environment
+variable. To do so, use the following command:
+
+    [ -n "$TMUX" ] && tmux setenv TMUXPWD_$(tmux display -p "#I") $PWD
+
+Which sets TMUXPWD_i (where i is the number of the current window) to the path
+of the current directory. This command can be added to PS1, for example:
+
+    PS1='$([ -n "$TMUX" ] && tmux setenv TMUXPWD_$(tmux display -p "#I") $PWD)\h$ '
+
+When a new window is created, the shell should be asked to change
+directory. You can define a new binding (for example, if using GNU bash):
+
+    bind-key C-c run-shell 'tmux neww "cd $(tmux display -p "\$TMUXPWD_#I"); exec bash"'
+
+This solution will work even if a command is currently running in the terminal,
+but it will not work from a window that has just been swapped with another
+because TMUXPWD_i will not be updated after a swap. However, once a new prompt
+is displayed, TMUXPWD_i is updated properly.
+
+* tmux doesn't start with "daemon failed"
+
+tmux shows something similar to this when started:
+
+    fatal: server_start: daemon failed: No such file or directory
+    fatal: main_dispatch: imsg_read failed
+
+A possible reason is that /dev/null is not a character device or is otherwise
+inaccessible.
+
+Check with:
+
+    file /dev/null
+    ls -l /dev/null
+
+If it is not a character device or has incorrect permissions, it can typically
+be recreated with:
+
+    cd /dev && rm null && ./MAKEDEV null
+
+* vim displays reverse video instead of italics, while less displays italics
+  (or just regular text) instead of reverse. What's wrong?
+
+Screen's terminfo description lacks italics mode and has standout mode in its
+place, but using the same escape sequence that urxvt uses for italics. This
+means applications (like vim) looking for italics will not find it and might
+turn to reverse in its place, while applications (like less) asking for
+standout will end up with italics instead of reverse. To make applications
+aware that tmux supports italics and to use a proper escape sequence for
+standout, you'll need to create a new terminfo file with modified sgr, smso,
+rmso, sitm and ritm entries:
+
+	$ mkdir $HOME/.terminfo/
+	$ screen_terminfo="screen"
+	$ infocmp "$screen_terminfo" | sed \
+	  -e 's/^screen[^|]*|[^,]*,/screen-it|screen with italics support,/' \
+	  -e 's/%?%p1%t;3%/%?%p1%t;7%/' \
+	  -e 's/smso=[^,]*,/smso=\\E[7m,/' \
+	  -e 's/rmso=[^,]*,/rmso=\\E[27m,/' \
+	  -e '$s/$/ sitm=\\E[3m, ritm=\\E[23m,/' > /tmp/screen.terminfo
+	$ tic /tmp/screen.terminfo
+
+And tell tmux to use it in ~/.tmux.conf:
+	
+	set -g default-terminal "screen-it"
+
+If your terminal supports 256 colors, use:
+
+	$ screen_terminfo="screen-256color"
+
+instead of "screen". See the FAQ entry about 256 colors support for more info.
+Also note that tmux will still display reverse video on terminals that do not
+support italics.
+
+If your urxvt cannot display italics at all, make sure you have an italics
+capable font enabled, for example, add to ~/.Xdefaults:
+
+	urxvt.italicFont: xft:Bitstream Vera Sans Mono:italic:autohint=true
+ 
+$Id$

GNUmakefile

@@ -1,86 +0,0 @@
-# $Id: GNUmakefile,v 1.122 2010-03-10 15:15:33 tcunha Exp $
-#
-# Copyright (c) 2009 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.
-#
-
-.PHONY: clean
-
-VERSION= 1.2
-
-#FDEBUG= 1
-
-CC?= cc
-CFLAGS+= -DBUILD="\"$(VERSION)\""
-LDFLAGS+= -L/usr/local/lib
-LIBS+=
-
-# Sun CC 
-ifneq ($(shell ($(CC) -V 2>&1|awk '/Sun C/' || true)), )
-	CFLAGS+=-erroff=E_EMPTY_DECLARATION
-	FDEBUG=
-endif
-
-ifdef FDEBUG
-CFLAGS+= -g -ggdb -DDEBUG
-CFLAGS+= -Wno-long-long -Wall -W -Wnested-externs -Wformat=2
-CFLAGS+= -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations
-CFLAGS+= -Wwrite-strings -Wshadow -Wpointer-arith -Wsign-compare
-CFLAGS+= -Wundef -Wbad-function-cast -Winline -Wcast-align
-endif
-
-# This sort of sucks but gets rid of the stupid warning and should work on
-# most platforms...
-ifeq ($(shell (LC_ALL=C $(CC) -v 2>&1|awk '/gcc version 4|clang/') || true), )
-CPPFLAGS:= -I. -I- $(CPPFLAGS)
-else
-CPPFLAGS:= -iquote. $(CPPFLAGS)
-ifdef FDEBUG
-CFLAGS+= -Wno-pointer-sign
-endif
-endif
-
-PREFIX?= /usr/local
-INSTALLDIR= install -d
-INSTALLBIN= install -g bin -o root -m 555
-INSTALLMAN= install -g bin -o root -m 444
-
-SRCS= $(shell echo *.c|sed 's|osdep-[a-z0-9]*.c||g')
-include config.mk
-OBJS= $(patsubst %.c,%.o,$(SRCS))
-
-all:		tmux
-
-tmux:		$(OBJS)
-		$(CC) $(LDFLAGS) -o tmux $+ $(LIBS)
-
-depend: 	$(SRCS)
-		$(CC) $(CPPFLAGS) $(CFLAGS) -MM $(SRCS) > .depend
-
-clean:
-		rm -f tmux *.o *~ *.core *.log compat/*.o compat/*~
-
-clean-depend:
-		rm -f .depend
-
-clean-all:	clean clean-depend
-		rm -f config.h config.mk
-
-install:	all
-		$(INSTALLDIR) $(DESTDIR)$(PREFIX)/bin
-		$(INSTALLBIN) tmux $(DESTDIR)$(PREFIX)/bin/tmux
-		$(INSTALLDIR) $(DESTDIR)$(PREFIX)/man/man1
-		$(INSTALLMAN) tmux.1 $(DESTDIR)$(PREFIX)/man/man1/tmux.1
-
--include .depend

Makefile

@@ -1,83 +0,0 @@
-# $Id: Makefile,v 1.155 2010-03-10 15:15:33 tcunha Exp $
-#
-# Copyright (c) 2009 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.
-#
-
-.SUFFIXES: .c .o
-.PHONY: clean
-
-VERSION= 1.2
-
-#FDEBUG= 1
-
-CC?= cc
-CFLAGS+= -DBUILD="\"$(VERSION)\""
-LDFLAGS+= -L/usr/local/lib
-LIBS+=
-
-.ifdef FDEBUG
-CFLAGS+= -g -ggdb -DDEBUG
-CFLAGS+= -Wno-long-long -Wall -W -Wnested-externs -Wformat=2
-CFLAGS+= -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations
-CFLAGS+= -Wwrite-strings -Wshadow -Wpointer-arith -Wsign-compare
-CFLAGS+= -Wundef -Wbad-function-cast -Winline -Wcast-align
-.endif
-
-# This sort of sucks but gets rid of the stupid warning and should work on
-# most platforms...
-CCV!= (LC_ALL=C ${CC} -v 2>&1|awk '/gcc version 4|clang/') || true
-.if empty(CCV)
-CPPFLAGS:= -I. -I- -I/usr/local/include ${CPPFLAGS}
-.else
-CPPFLAGS:= -iquote. -I/usr/local/include ${CPPFLAGS}
-.ifdef FDEBUG
-CFLAGS+= -Wno-pointer-sign
-.endif
-.endif
-
-PREFIX?= /usr/local
-INSTALLDIR= install -d
-INSTALLBIN= install -g bin -o root -m 555
-INSTALLMAN= install -g bin -o root -m 444
-
-SRCS!= echo *.c|sed 's|osdep-[a-z0-9]*.c||g'
-.include "config.mk"
-OBJS= ${SRCS:S/.c/.o/}
-
-.c.o:
-		${CC} ${CPPFLAGS} ${CFLAGS} -c ${.IMPSRC} -o ${.TARGET}
-
-all:		tmux
-
-tmux:		${OBJS}
-		${CC} ${LDFLAGS} -o tmux ${OBJS} ${LIBS}
-
-depend:
-		mkdep ${CPPFLAGS} ${CFLAGS} ${SRCS:M*.c}
-
-clean:
-		rm -f tmux *.o *~ *.core *.log compat/*.o compat/*~
-
-clean-depend:
-		rm -f .depend
-
-clean-all:	clean clean-depend
-		rm -f config.h config.mk
-
-install:	all
-		${INSTALLDIR} ${DESTDIR}${PREFIX}/bin
-		${INSTALLBIN} tmux ${DESTDIR}${PREFIX}/bin/
-		${INSTALLDIR} ${DESTDIR}${PREFIX}/man/man1
-		${INSTALLMAN} tmux.1 ${DESTDIR}${PREFIX}/man/man1/

Makefile.am

@@ -0,0 +1,242 @@
+# $Id$
+
+# Obvious program stuff.
+bin_PROGRAMS = tmux
+dist_man1_MANS = tmux.1
+
+# Distribution tarball options.
+EXTRA_DIST = \
+	CHANGES FAQ NOTES TODO examples compat \
+	array.h compat.h tmux.h osdep-*.c
+dist-hook:
+	grep "^#found_debug=" configure
+	find $(distdir) -name .svn -type d|xargs rm -Rf
+
+# Preprocessor flags.
+CPPFLAGS += @XOPEN_DEFINES@
+
+# glibc as usual does things ass-backwards and hides useful things by default,
+# so everyone has to add this.
+if IS_GLIBC
+CFLAGS += -D_GNU_SOURCE
+endif
+
+# Set flags for gcc. gcc4 whines abouts silly stuff so it needs slightly
+# different flags.
+if IS_GCC
+CFLAGS += -std=c99
+if IS_DEBUG
+CFLAGS += -g -ggdb -O0
+CFLAGS += -Wno-long-long -Wall -W -Wnested-externs -Wformat=2
+CFLAGS += -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations
+CFLAGS += -Wwrite-strings -Wshadow -Wpointer-arith -Wsign-compare
+CFLAGS += -Wundef -Wbad-function-cast -Winline -Wcast-align
+CPPFLAGS += -DDEBUG
+endif
+if IS_GCC4
+CPPFLAGS += -iquote. -I/usr/local/include
+if IS_DEBUG
+CFLAGS += -Wno-pointer-sign
+endif
+else
+CPPFLAGS += -I. -I- -I/usr/local/include
+endif
+endif
+
+# Set flags for Solaris.
+if IS_SUNOS
+CPPFLAGS += -D_XPG4_2 -D__EXTENSIONS__ -D_POSIX_PTHREAD_SEMANTICS
+endif
+
+# Set flags for Sun CC.
+if IS_SUNCC
+CFLAGS += -erroff=E_EMPTY_DECLARATION
+endif
+
+# List of sources.
+dist_tmux_SOURCES = \
+	arguments.c \
+	attributes.c \
+	cfg.c \
+	client.c \
+	clock.c \
+	cmd-attach-session.c \
+	cmd-bind-key.c \
+	cmd-break-pane.c \
+	cmd-capture-pane.c \
+	cmd-choose-buffer.c \
+	cmd-choose-client.c \
+	cmd-choose-session.c \
+	cmd-choose-window.c \
+	cmd-clear-history.c \
+	cmd-clock-mode.c \
+	cmd-command-prompt.c \
+	cmd-confirm-before.c \
+	cmd-copy-mode.c \
+	cmd-delete-buffer.c \
+	cmd-detach-client.c \
+	cmd-display-message.c \
+	cmd-display-panes.c \
+	cmd-find-window.c \
+	cmd-has-session.c \
+	cmd-if-shell.c \
+	cmd-join-pane.c \
+	cmd-kill-pane.c \
+	cmd-kill-server.c \
+	cmd-kill-session.c \
+	cmd-kill-window.c \
+	cmd-link-window.c \
+	cmd-list-buffers.c \
+	cmd-list-clients.c \
+	cmd-list-commands.c \
+	cmd-list-keys.c \
+	cmd-list-panes.c \
+	cmd-list-sessions.c \
+	cmd-list-windows.c \
+	cmd-list.c \
+	cmd-load-buffer.c \
+	cmd-lock-server.c \
+	cmd-move-window.c \
+	cmd-new-session.c \
+	cmd-new-window.c \
+	cmd-paste-buffer.c \
+	cmd-pipe-pane.c \
+	cmd-refresh-client.c \
+	cmd-rename-session.c \
+	cmd-rename-window.c \
+	cmd-resize-pane.c \
+	cmd-respawn-pane.c \
+	cmd-respawn-window.c \
+	cmd-rotate-window.c \
+	cmd-run-shell.c \
+	cmd-save-buffer.c \
+	cmd-select-layout.c \
+	cmd-select-pane.c \
+	cmd-select-window.c \
+	cmd-send-keys.c \
+	cmd-send-prefix.c \
+	cmd-server-info.c \
+	cmd-set-buffer.c \
+	cmd-set-environment.c \
+	cmd-set-option.c \
+	cmd-show-buffer.c \
+	cmd-show-environment.c \
+	cmd-show-messages.c \
+	cmd-show-options.c \
+	cmd-source-file.c \
+	cmd-split-window.c \
+	cmd-start-server.c \
+	cmd-string.c \
+	cmd-suspend-client.c \
+	cmd-swap-pane.c \
+	cmd-swap-window.c \
+	cmd-switch-client.c \
+	cmd-unbind-key.c \
+	cmd-unlink-window.c \
+	cmd.c \
+	colour.c \
+	environ.c \
+	format.c \
+	grid-utf8.c \
+	grid-view.c \
+	grid.c \
+	input-keys.c \
+	input.c \
+	job.c \
+	key-bindings.c \
+	key-string.c \
+	layout-custom.c \
+	layout-set.c \
+	layout.c \
+	log.c \
+	mode-key.c \
+	names.c \
+	options-table.c \
+	options.c \
+	paste.c \
+	resize.c \
+	screen-redraw.c \
+	screen-write.c \
+	screen.c \
+	server-client.c \
+	server-fn.c \
+	server-window.c \
+	server.c \
+	session.c \
+	signal.c \
+	status.c \
+	tmux.c \
+	tty-acs.c \
+	tty-keys.c \
+	tty-term.c \
+	tty.c \
+	utf8.c \
+	window-choose.c \
+	window-clock.c \
+	window-copy.c \
+	window.c \
+	xmalloc.c \
+	xterm-keys.c
+nodist_tmux_SOURCES = osdep-@PLATFORM@.c
+
+# Pile in all the compat/ stuff that is needed.
+if NO_FORKPTY
+nodist_tmux_SOURCES += compat/forkpty-@PLATFORM@.c
+endif
+if NO_IMSG
+nodist_tmux_SOURCES += compat/imsg.c compat/imsg-buffer.c
+endif
+if NO_CLOSEFROM
+nodist_tmux_SOURCES += compat/closefrom.c
+endif
+if NO_DAEMON
+nodist_tmux_SOURCES += compat/daemon.c
+endif
+if NO_SETENV
+nodist_tmux_SOURCES += compat/setenv.c
+endif
+if NO_STRLCAT
+nodist_tmux_SOURCES += compat/strlcat.c
+endif
+if NO_STRLCPY
+nodist_tmux_SOURCES += compat/strlcpy.c
+endif
+if NO_ASPRINTF
+nodist_tmux_SOURCES += compat/asprintf.c
+endif
+if NO_FGETLN
+nodist_tmux_SOURCES += compat/fgetln.c
+endif
+if NO_GETOPT
+nodist_tmux_SOURCES += compat/getopt.c
+endif
+if NO_STRCASESTR
+nodist_tmux_SOURCES += compat/strcasestr.c
+endif
+if NO_STRSEP
+nodist_tmux_SOURCES += compat/strsep.c
+endif
+if NO_VIS
+nodist_tmux_SOURCES += compat/vis.c compat/unvis.c
+endif
+if NO_STRTONUM
+nodist_tmux_SOURCES += compat/strtonum.c
+endif
+if NO_B64_NTOP
+nodist_tmux_SOURCES += compat/b64_ntop.c
+endif
+
+# Update SF web site.
+upload-index.html: update-index.html
+	scp www/index.html www/main.css www/images/*.png \
+		${USER},tmux@web.sf.net:/home/groups/t/tm/tmux/htdocs
+	rm -f www/index.html www/images/small-*
+
+update-index.html:
+	(cd www/images && \
+		rm -f small-* && \
+		for i in *.png; do \
+			convert "$$i" -resize 200x150 "small-$$i"; \
+		done \
+	)
+	sed "s/%%VERSION%%/${VERSION}/g" www/index.html.in >www/index.html

NOTES

@@ -9,11 +9,27 @@ run on Solaris and AIX (although they haven't been tested in a while). It is
 usable, although there remain a number of missing features and some remaining
 bugs are expected.
 
-Since the 1.2 release that tmux depends on libevent. Download the stable
+If upgrading from 1.5, PLEASE NOTE:
-version from:
+- The word-separators window option is now a session option.
+- The options used to change the window attributes when an alert occurs were
+  removed. Each kind of alert has its own individual set of options.
+- The ability to have a list of prefix keys was dropped in favour of two
+  separate options, prefix and prefix2.
+
+Since the 1.2 release that tmux depends on libevent. Download it from:
 
 	http://www.monkey.org/~provos/libevent/
 
+To build tmux from a release tarball, do:
+
+	$ ./configure && make
+	$ sudo make install
+
+To build from a version control checkout, the configure script must be
+generated by running:
+
+	$ sh autogen.sh
+
 tmux consists of a server part and multiple clients. The server is created when
 required and runs continuously unless killed by the user. Clients access the
 server through a socket in /tmp. Multiple sessions may be created on a single
@@ -25,34 +41,11 @@ windows into several simultaneously displayed panes; and to bind and unbind
 command keys (invoked preceded by a prefix key, by default ctrl-b). Please see
 the tmux(1) man page for further information.
 
-The following is a summary of major features implemented in this version:
-
-- Basic multiplexing, window switching, attaching and detaching.
-- Window listing and renaming.
-- Key binding.
-- Handling of client terminal resize.
-- Terminal emulation sufficient to handle most curses applications.
-- A optional status line (enabled by default).
-- Window history and copy and paste.
-- Support for VT100 line drawing characters.
-- A large command set.
-- Vertical window splitting and layout.
-- Automatic server locking on inactivity by running an external command.
-- A configuration file.
-- UTF-8 support.
-
 A more extensive, but rough, todo list is included in the TODO file.
 
 tmux also depends on several features of the client terminal (TERM), if these
 are missing it may refuse to run, or not behave correctly.
 
-tmux supports UTF-8. To use it, the utf8 option must be set on each window;
-this may be turned on for all windows by setting it as a global option, see
-tmux(1) and the FAQ file. As of 0.9, tmux attempts to autodetect a
-UTF-8 capable terminal by checking the LC_ALL, LC_CTYPE and LANG environment
-variables. list-clients may be used to check if this is detected correctly; if
-not, the -u command-line flag may be specified.
-
 A Vim syntax file is available in the examples directory. To install it:
 
 - Drop the file in the syntax directory in your runtimepath (such as
@@ -86,4 +79,4 @@ start. Please contact me with any queries.
 
 -- Nicholas Marriott <nicm@users.sf.net>
 
-$Id: NOTES,v 1.53 2010-03-10 15:18:11 tcunha Exp $
+$Id$

TODO

@@ -1,33 +1,17 @@
-- window creation/idle time
-- better errors when creating new windows/sessions (how?)
 - implicitly add exec to the commands for new windows (switch to disable it)?
-- it would be nice to have multichar commands eg C-b K K
+- bring back detach-session to detach all clients on a session?
-- commands:
- 	extend list-clients to list clients attached to a session (-a for all?)
-	bring back detach-session to detach all clients on a session?
 - allow fnmatch for -c, so that you can, eg, detach all clients
 - garbage collect window history (100 lines at a time?) if it hasn't been used
-  in $x time (need window creation/use times)
+  in $x time
-- lift SHRT_MAX limits for history?
 - flags to centre screen in window
-- better terminal emulation
 - activity/bell should be per-window not per-link? what if it is cur win in
   session not being watched?
-- next prev word etc in command prompt
-- many more info() displays for various things
-- input.c is too complicated. simplify?
 - use a better termcap internally instead of screen, perhaps xterm
-- fix rxvt cursor fg issue (text under cursor can have non-white fg)
 - should be able to move to a hidden pane and it would be moved into view. pane
   number in status line/top-right would be cool for this
 - support other mouse modes (highlight etc) and use it in copy mode
 - set-remain-on-exit is a bit of a hack, some way to do it generically?
-- set-option should be set-session-option and should be overall global options
-      also quiet, utf8 and maybe other flags?
-  -g is a bit unexpected in conf file
 - clear window title on exit
-- the output code (tty.c) could do with optimisation depending on term
-  capabilities
 - would be nice to be able to use "--" to mark start of command w/ neww etc
   to avoid quoting
 - make command sequences more usable: don't require space after ;, handle
@@ -38,11 +22,7 @@
   "new-session" if-shell "[ -e $HOME/.tmux-session.conf ]" source-file
   $HOME/.tmux-session.conf
 - get it passing all the vttest tests that don't require resizing the terminal
-- esc seq to set window name and title should be documented, and name variant
-  should clear automatic-rename
 - way to set socket path from config file
-- XXX once env stuff is in, default-path and VISUAL/EDITOR should be picked up
-  when session is started
 - what about utmp etc? can tmux update it like screen? setgid?
 - warts on current naming:
   	- display-time but message-fg/bg/attr
@@ -50,48 +30,24 @@
 	- server-info
 	- up-pane/down-pane/swap-pane -U/swap-pane -D vs next-*/previous-*
 	- split-window -> split-pane??
-- tidy up and prioritise todo list ;-)
-- neww and attach can create a session if none exists?
-       would work fine with config file since
 - a way for force-width/height to apply to only one pane (how?)
 - command to list what is actually running in each window with command line,
   pid (need some adaption of the osdep code)
 - support for bce
-- it would be nice if the start/end line keys in copy mode were aware of
-  wrapped lines
 - some way to force a screen to use the entire terminal even if it is forced
   to be smaller by other clients. pan smaller terminal? (like screen F)
-		-- idea of a "view" onto a window, need base x/y offsets
+	-- idea of a "view" onto a window, need base x/y offsets for redraw
-		   for redraw
 - handle resize better in copy mode
 - way to copy stuff that is off screen due to resize
 - commands should be able to succeed or fail and have || or && for command
   lists
-- support the mouse wheel to scroll through history
 - some way to KEEP a command running continually and just use its LAST line of
   output
-- bind commands to mouse buttons
 - UTF-8 to a non-UTF-8 terminal should not be able to balls up
   the terminal - www/ruby-addressable; make regress
-- copy mode needs a tidy/cleanup
-- ability to save history (to buffer?)
-- multiple keys could be done with tables, ie have prefixes go and instead
-	bind -n ^A prefix-table "default"
-  where prefix-table sets command lookup table and sets prefix flag, then next
-  key is looked up in that table
-- UTF-8 should be a pointer into a combined string buffer
-- check irssi (term_charset) works with UTF-8
 - support esc-esc to quit in modes
 - fix ctrl+F1-F4 output. to what?
-- look into xterm clearing its selection when scrolling etc
+- better utf8 support: window names, prompt input, message display
-- better utf8 support:
-  	 window names
-	 prompt input
-	 message display
-	 copy and paste cursor and wide characters
-	 ...?
-- option so that when session is destroyed, attach client to another session
-  rather than exiting
 - session history for client and last-session command
 - option to change status line colour when current window is in a mode?
 - option to move copy mode indicator into status line
@@ -99,37 +55,90 @@
 - selection behaviour closer to vi in vi mode
 - live update: server started with -U connects to server, requests sessions and
   windows, receives fds
-- convert status line history to be server global (anything else?)
-- something for -t "last window in session" so a session can be used as a stack
 - command to show a tree of sessions-windows-panes (active marked with *)
 - sort out inheriting config from shell on new sessions/windows:
         should pick up default-path/termios/etc from client if possible,
 	else leave empty/default
-- define custom layouts
 - link panes into multiple windows
-- -h option to capture-pane to capture the history as well
 - bells should be passed between sessions with visual-bell etc
 - use screen-256color when started on 256 colour terminal??
 - if-shell/run-shell should block further command execution in the same command
   sequence until its shell exits, to allow them to be used from the config file
 - better session sharing: create-socket command to create socket somewhere (-r
   flag for readonly)
-- allow buffer to be specified when copying in copy mode
+- multiline status line (no?)
-- multiline status line
 - flag for absolute pane size to resize-pane
 - sanity check input to socket
-- stdin fd should be passed up to parent so load-buffer and others could use it
-  for nonattaching clients
-- environment should be set up for jobs
-- select-buffer command
-- fix jobs so they block in config file rather than executing at an arbitrary
-  future point -- need state stored in client so other clients can proceed
-- rectangle copy:
-	when selecting leftward, cursor should be inside block per emacs
-	key to rotate corner at which cursor is
-- double C-a should walk back over wrapped lines like C-e
 - support title stack, both internally and externally
 	http://docs.freebsd.org/cgi/getmsg.cgi?fetch=1149299+0+archive/2010/freebsd-questions/20100207.freebsd-questions
-- copy buffers should be global, limit can be server option, nuke copy-buffer
-  command
 - command to show status line information briefly when it is off
+- some way to pad # stuff with spaces, #!2T maybe
+- a binding to "scroll down and exit at bottom" copy mode
+- some way to pass keystrokes in copy mode through to underlying window
+- last window update time and # replacement for it for display-message
+- find-window across sessions - other ways to make session handling easier?
+- ' and " should be parsed the same (eg "\e" vs '\e') in config and command
+  prompt?
+- command to toggle selection not to move it in copy-mode
+- why are alerts per-winlink? try per window?
+- audit of escape sequence support vs xterm
+- support binding keys to mouse (mouse-select-pane -> mouse-keys or something,
+  mouse click == select-pane -t %%, mouse scroll up == copy-mode)
+- something for -t "last window in session" so a session can be used as a stack
+- synchronous commands - client sends cmd and blocks, neww/splitw saves client
+  ptr then when program inside died, sends MSG_SOMETHING with wait status to
+  client
+- documentation improvements - rlpowell's tutorial - build instructions
+- bind commands to key sequences? -- make it so ALL keys go through a table,
+  first an implicit table in which C-b is the only default binding to a
+  command that says "next key from $othertable" and so on. means -n can
+  go away as well
+- monitor, bell etc should monitor /all/ panes in the window not just one
+- a history of commands that can be reversed (reverse member of each command,
+  and a buffer) info() when changing to same window
+- way to add dest for break-pane; maybe some easier way to unbreak-pane
+- case insensitive searching
+- option to move status line to top
+- configurable borders and empty space filler for when panes < window?
+- mouse-select-pane will screw up with !MODE_MOUSE_STANDARD (it sets the
+  flag on w/o checking the others before calling tty_update_mode)
+- multiple keys could be done with tables, ie have prefixes go and instead
+	bind -n ^A prefix-table "default"
+  where prefix-table sets command lookup table and sets prefix flag, then next
+  key is looked up in that table
+- pass shell commands as argv rather than strings, allow them to be specified
+  in commands without quotes
+- a command to choose from a generic list, so you can do eg
+  choose-list -l Abc,Moo,Blah "run-shell 'sh /my/choose/script %%'"
+- numeric prefix in copy mode should be paste buffer for C-w
+- named buffers and allow gaps in the stack
+- get rid of separate UTF-8 cell stuff: add 1 byte to cell and store BMP as
+  uint16_t+3 bits of flags. anything <=0xffff is Unicode, higher are used to
+  build tree of combined characters/non-BMP (LRU dropped when full)
+- entry in FAQ about what to do when someone does mkdir /tmp/tmux-1000
+- show size under pane number in display-panes mode
+- monitor-activity is broken in several ways with multiple clients
+- monitor-activity should be more powerful (eg set a region)
+- maybe a way to put pane names instead of window names in status line
+- support for borderless panes
+- run-shell/if-shell should support status_replace stuff
+- wait-pane command or another way to make it synchronous/wait for command to
+  finish
+- last-pane across sessions
+- attach should take a pane and select it as well as attaching
+- should default-path be a window option?
+- option to put status line at top (why?)
+- panes should have names like windows
+- command-prompt doesn't work if made read-only. why?
+- option to quote format eg #{session_name:quoted}
+- formats need to be used for much much more stuff!
+- formats need conditions for >0 (for #P)
+- flags to find-window to select what is searched (title, name, content, history)
+- fetch full command line on !Linux, and add option to strip prefixes
+  such as "sh " "/bin/sh " etc etc
+- synchronize-windows option
+- possibly support rxvt-unicode extended mouse input (1015)
+- append to buffer in copy mode
+* We need a tmux terminfo entry to document the extensions we are using in
+  upstream terminfo. Must NOT change (only add or remove) anything from
+  TERM=screen so we can fallback!

arguments.c

@@ -0,0 +1,222 @@
+/* $Id$ */
+
+/*
+ * Copyright (c) 2010 Nicholas Marriott <nicm@users.sourceforge.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "tmux.h"
+
+/* Create an arguments set with no flags. */
+struct args *
+args_create(int argc, ...)
+{
+	struct args	*args;
+	va_list		 ap;
+	int		 i;
+
+	args = xcalloc(1, sizeof *args);
+	if ((args->flags = bit_alloc(SCHAR_MAX)) == NULL)
+		fatal("bit_alloc failed");
+
+	args->argc = argc;
+	if (argc == 0)
+		args->argv = NULL;
+	else
+		args->argv = xcalloc(argc, sizeof *args->argv);
+
+	va_start(ap, argc);
+	for (i = 0; i < argc; i++)
+		args->argv[i] = xstrdup(va_arg(ap, char *));
+	va_end(ap);
+
+	return (args);
+}
+
+/* Parse an argv and argc into a new argument set. */
+struct args *
+args_parse(const char *template, int argc, char **argv)
+{
+	struct args	*args;
+	char		*ptr;
+	int		 opt;
+
+	args = xcalloc(1, sizeof *args);
+	if ((args->flags = bit_alloc(SCHAR_MAX)) == NULL)
+		fatal("bit_alloc failed");
+
+	optreset = 1;
+	optind = 1;
+
+	while ((opt = getopt(argc, argv, template)) != -1) {
+		if (opt < 0 || opt >= SCHAR_MAX)
+			continue;
+		if (opt == '?' || (ptr = strchr(template, opt)) == NULL) {
+			xfree(args->flags);
+			xfree(args);
+			return (NULL);
+		}
+
+		bit_set(args->flags, opt);
+		if (ptr[1] == ':') {
+			if (args->values[opt] != NULL)
+				xfree(args->values[opt]);
+			args->values[opt] = xstrdup(optarg);
+		}
+	}
+	argc -= optind;
+	argv += optind;
+
+	args->argc = argc;
+	args->argv = cmd_copy_argv(argc, argv);
+
+	return (args);
+}
+
+/* Free an arguments set. */
+void
+args_free(struct args *args)
+{
+	u_int	i;
+
+	cmd_free_argv(args->argc, args->argv);
+
+	for (i = 0; i < SCHAR_MAX; i++) {
+		if (args->values[i] != NULL)
+			xfree(args->values[i]);
+	}
+
+	xfree(args->flags);
+	xfree(args);
+}
+
+/* Print a set of arguments. */
+size_t
+args_print(struct args *args, char *buf, size_t len)
+{
+	size_t		 off;
+	int		 i;
+	const char	*quotes;
+
+	/* There must be at least one byte at the start. */
+	if (len == 0)
+		return (0);
+	off = 0;
+
+	/* Process the flags first. */
+	buf[off++] = '-';
+	for (i = 0; i < SCHAR_MAX; i++) {
+		if (!bit_test(args->flags, i) || args->values[i] != NULL)
+			continue;
+
+		if (off == len - 1) {
+			buf[off] = '\0';
+			return (len);
+		}
+		buf[off++] = i;
+		buf[off] = '\0';
+	}
+	if (off == 1)
+		buf[--off] = '\0';
+
+	/* Then the flags with arguments. */
+	for (i = 0; i < SCHAR_MAX; i++) {
+		if (!bit_test(args->flags, i) || args->values[i] == NULL)
+			continue;
+
+		if (off >= len) {
+			/* snprintf will have zero terminated. */
+			return (len);
+		}
+
+		if (strchr(args->values[i], ' ') != NULL)
+			quotes = "\"";
+		else
+			quotes = "";
+		off += xsnprintf(buf + off, len - off, "%s-%c %s%s%s",
+		    off != 0 ? " " : "", i, quotes, args->values[i], quotes);
+	}
+
+	/* And finally the argument vector. */
+	for (i = 0; i < args->argc; i++) {
+		if (off >= len) {
+			/* snprintf will have zero terminated. */
+			return (len);
+		}
+
+		if (strchr(args->argv[i], ' ') != NULL)
+			quotes = "\"";
+		else
+			quotes = "";
+		off += xsnprintf(buf + off, len - off, "%s%s%s%s",
+		    off != 0 ? " " : "", quotes, args->argv[i], quotes);
+	}
+
+	return (off);
+}
+
+/* Return if an argument is present. */
+int
+args_has(struct args *args, u_char ch)
+{
+	return (bit_test(args->flags, ch));
+}
+
+/* Set argument value. */
+void
+args_set(struct args *args, u_char ch, const char *value)
+{
+	if (args->values[ch] != NULL)
+		xfree(args->values[ch]);
+	if (value != NULL)
+		args->values[ch] = xstrdup(value);
+	else
+		args->values[ch] = NULL;
+	bit_set(args->flags, ch);
+}
+
+/* Get argument value. Will be NULL if it isn't present. */
+const char *
+args_get(struct args *args, u_char ch)
+{
+	return (args->values[ch]);
+}
+
+/* Convert an argument value to a number. */
+long long
+args_strtonum(struct args *args,
+    u_char ch, long long minval, long long maxval, char **cause)
+{
+	const char	*errstr;
+	long long 	 ll;
+
+	if (!args_has(args, ch)) {
+		*cause = xstrdup("missing");
+		return (0);
+	}
+
+	ll = strtonum(args->values[ch], minval, maxval, &errstr);
+	if (errstr != NULL) {
+		*cause = xstrdup(errstr);
+		return (0);
+	}
+
+	*cause = NULL;
+	return (ll);
+}

array.h

@@ -1,4 +1,4 @@
-/* $Id: array.h,v 1.10 2010-02-08 18:29:32 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2006 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -47,7 +47,7 @@
 	}								\
 } while (0)
 
-#define ARRAY_EMPTY(a) ((a) == NULL || (a)->num == 0)
+#define ARRAY_EMPTY(a) (((void *) (a)) == NULL || (a)->num == 0)
 #define ARRAY_LENGTH(a) ((a)->num)
 #define ARRAY_DATA(a) ((a)->list)
 

attributes.c

@@ -1,4 +1,4 @@
-/* $Id: attributes.c,v 1.3 2009-11-28 14:46:23 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Joshua Elsasser <josh@elsasser.org>
@@ -28,7 +28,7 @@ attributes_tostring(u_char attr)
 	static char	buf[128];
 
 	if (attr == 0)
-		return ("default");
+		return ("none");
 
 	buf[0] = '\0';
 	if (attr & GRID_ATTR_BRIGHT)
@@ -63,7 +63,7 @@ attributes_fromstring(const char *str)
 	if (strchr(delimiters, str[strlen(str) - 1]) != NULL)
 		return (-1);
 
-	if (strcasecmp(str, "default") == 0)
+	if (strcasecmp(str, "default") == 0 || strcasecmp(str, "none") == 0)
 		return (0);
 
 	attr = 0;

autogen.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+# $Id$
+
+[ -z "$AUTOMAKE_VERSION" ] && export AUTOMAKE_VERSION=1.10
+[ -z "$AUTOCONF_VERSION" ] && export AUTOCONF_VERSION=2.65
+
+die()
+{
+    echo "$@" >&2
+    exit 1
+}
+
+mkdir -p etc
+aclocal || die "aclocal failed"
+automake --add-missing --force-missing --copy --foreign || die "automake failed"
+autoreconf || die "autoreconf failed"

cfg.c

@@ -1,4 +1,4 @@
-/* $Id: cfg.c,v 1.26 2010-02-08 18:29:32 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -69,7 +69,7 @@ cfg_add_cause(struct causelist *causes, const char *fmt, ...)
 
 /*
  * Load configuration file. Returns -1 for an error with a list of messages in
- * causes. Note that causes and ncauses must be initialised by the caller!
+ * causes. Note that causes must be initialised by the caller!
  */
 int
 load_cfg(const char *path, struct cmd_ctx *ctxin, struct causelist *causes)
@@ -80,6 +80,7 @@ load_cfg(const char *path, struct cmd_ctx *ctxin, struct causelist *causes)
 	size_t		 len;
 	struct cmd_list	*cmdlist;
 	struct cmd_ctx	 ctx;
+	int		 retval;
 
 	if ((f = fopen(path, "rb")) == NULL) {
 		cfg_add_cause(causes, "%s: %s", path, strerror(errno));
@@ -88,24 +89,40 @@ load_cfg(const char *path, struct cmd_ctx *ctxin, struct causelist *causes)
 	n = 0;
 
 	line = NULL;
+	retval = 0;
 	while ((buf = fgetln(f, &len))) {
 		if (buf[len - 1] == '\n')
-			buf[len - 1] = '\0';
+			len--;
+
+		if (line != NULL)
+			line = xrealloc(line, 1, strlen(line) + len + 1);
 		else {
-			line = xrealloc(line, 1, len + 1);
+			line = xmalloc(len + 1);
-			memcpy(line, buf, len);
+			*line = '\0';
-			line[len] = '\0';
-			buf = line;
 		}
+
+		/* Append buffer to line. strncat will terminate. */
+		strncat(line, buf, len);
 		n++;
 
+		/* Continuation: get next line? */
+		len = strlen(line);
+		if (len > 0 && line[len - 1] == '\\') {
+			line[len - 1] = '\0';
+			continue;
+		}
+		buf = line;
+		line = NULL;
+
 		if (cmd_string_parse(buf, &cmdlist, &cause) != 0) {
+			xfree(buf);
 			if (cause == NULL)
 				continue;
 			cfg_add_cause(causes, "%s: %u: %s", path, n, cause);
 			xfree(cause);
 			continue;
-		}
+		} else
+			xfree(buf);
 		if (cmdlist == NULL)
 			continue;
 		cfg_cause = NULL;
@@ -125,19 +142,21 @@ load_cfg(const char *path, struct cmd_ctx *ctxin, struct causelist *causes)
 		ctx.info = cfg_print;
 
 		cfg_cause = NULL;
-		cmd_list_exec(cmdlist, &ctx);
+		if (cmd_list_exec(cmdlist, &ctx) == 1)
+			retval = 1;
 		cmd_list_free(cmdlist);
 		if (cfg_cause != NULL) {
-			cfg_add_cause(causes, "%s: %d: %s", path, n, cfg_cause);
+			cfg_add_cause(
+			    causes, "%s: %d: %s", path, n, cfg_cause);
 			xfree(cfg_cause);
-			continue;
 		}
 	}
-	if (line != NULL)
+	if (line != NULL) {
+		cfg_add_cause(causes,
+		    "%s: %d: line continuation at end of file", path, n);
 		xfree(line);
+	}
 	fclose(f);
 
-	if (ARRAY_LENGTH(causes) != 0)
+	return (retval);
-		return (-1);
-	return (0);
 }

client.c

@@ -1,4 +1,4 @@
-/* $Id: client.c,v 1.90 2009-12-04 22:14:47 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -17,7 +17,6 @@
  */
 
 #include <sys/types.h>
-#include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/un.h>
@@ -29,7 +28,6 @@
 #include <pwd.h>
 #include <stdlib.h>
 #include <string.h>
-#include <syslog.h>
 #include <unistd.h>
 
 #include "tmux.h"
@@ -38,93 +36,185 @@ struct imsgbuf	client_ibuf;
 struct event	client_event;
 const char     *client_exitmsg;
 int		client_exitval;
+enum msgtype	client_exittype;
+int		client_attached;
 
+int		client_connect(char *, int);
 void		client_send_identify(int);
 void		client_send_environ(void);
 void		client_write_server(enum msgtype, void *, size_t);
 void		client_update_event(void);
 void		client_signal(int, short, void *);
 void		client_callback(int, short, void *);
-int		client_dispatch(void);
+int		client_dispatch_attached(void);
+int		client_dispatch_wait(void *);
 
-struct imsgbuf *
+/* Connect client to server. */
-client_init(char *path, int cmdflags, int flags)
+int
+client_connect(char *path, int start_server)
 {
 	struct sockaddr_un	sa;
 	size_t			size;
-	int			fd, mode;
+	int			fd;
-#ifdef HAVE_SETPROCTITLE
-	char		        rpathbuf[MAXPATHLEN];
-#endif
-
-#ifdef HAVE_SETPROCTITLE
-	if (realpath(path, rpathbuf) == NULL)
-		strlcpy(rpathbuf, path, sizeof rpathbuf);
-	setproctitle("client (%s)", rpathbuf);
-#endif
 
 	memset(&sa, 0, sizeof sa);
 	sa.sun_family = AF_UNIX;
 	size = strlcpy(sa.sun_path, path, sizeof sa.sun_path);
 	if (size >= sizeof sa.sun_path) {
 		errno = ENAMETOOLONG;
-		goto not_found;
+		return (-1);
 	}
 
 	if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
 		fatal("socket failed");
 
 	if (connect(fd, (struct sockaddr *) &sa, SUN_LEN(&sa)) == -1) {
-		if (!(cmdflags & CMD_STARTSERVER))
+		if (!start_server)
-			goto not_found;
+			goto failed;
 		switch (errno) {
 		case ECONNREFUSED:
 			if (unlink(path) != 0)
-				goto not_found;
+				goto failed;
 			/* FALLTHROUGH */
 		case ENOENT:
-			if ((fd = server_start(path)) == -1)
+			if ((fd = server_start()) == -1)
-				goto start_failed;
+				goto failed;
-			goto server_started;
+			break;
+		default:
+			goto failed;
 		}
-		goto not_found;
 	}
 
-server_started:
+	setblocking(fd, 0);
-	if ((mode = fcntl(fd, F_GETFL)) == -1)
+	return (fd);
-		fatal("fcntl failed");
-	if (fcntl(fd, F_SETFL, mode|O_NONBLOCK) == -1)
-		fatal("fcntl failed");
-	if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
-		fatal("fcntl failed");
-	imsg_init(&client_ibuf, fd);
 
-	if (cmdflags & CMD_SENDENVIRON)
+failed:
-		client_send_environ();
+	close(fd);
-	if (isatty(STDIN_FILENO))
+	return (-1);
-		client_send_identify(flags);
-
-	return (&client_ibuf);
-
-start_failed:
-	log_warnx("server failed to start");
-	return (NULL);
-
-not_found:
-	log_warn("server not found");
-	return (NULL);
 }
 
+/* Client main loop. */
+int
+client_main(int argc, char **argv, int flags)
+{
+	struct cmd		*cmd;
+	struct cmd_list		*cmdlist;
+	struct msg_command_data	 cmddata;
+	int			 cmdflags, fd;
+	pid_t			 ppid;
+	enum msgtype		 msg;
+	char			*cause;
+
+	/* Set up the initial command. */
+	cmdflags = 0;
+	if (shell_cmd != NULL) {
+		msg = MSG_SHELL;
+		cmdflags = CMD_STARTSERVER;
+	} else if (argc == 0) {
+		msg = MSG_COMMAND;
+		cmdflags = CMD_STARTSERVER|CMD_SENDENVIRON|CMD_CANTNEST;
+	} else {
+		msg = MSG_COMMAND;
+
+		/*
+		 * It sucks parsing the command string twice (in client and
+		 * later in server) but it is necessary to get the start server
+		 * flag.
+		 */
+		if ((cmdlist = cmd_list_parse(argc, argv, &cause)) == NULL) {
+			log_warnx("%s", cause);
+			return (1);
+		}
+		cmdflags &= ~CMD_STARTSERVER;
+		TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
+			if (cmd->entry->flags & CMD_STARTSERVER)
+				cmdflags |= CMD_STARTSERVER;
+			if (cmd->entry->flags & CMD_SENDENVIRON)
+				cmdflags |= CMD_SENDENVIRON;
+			if (cmd->entry->flags & CMD_CANTNEST)
+				cmdflags |= CMD_CANTNEST;
+		}
+		cmd_list_free(cmdlist);
+	}
+
+	/*
+	 * Check if this could be a nested session, if the command can't nest:
+	 * if the socket path matches $TMUX, this is probably the same server.
+	 */
+	if (shell_cmd == NULL && environ_path != NULL &&
+	    cmdflags & CMD_CANTNEST && strcmp(socket_path, environ_path) == 0) {
+		log_warnx("sessions should be nested with care. "
+		    "unset $TMUX to force.");
+		return (1);
+	}
+
+	/* Initialise the client socket and start the server. */
+	fd = client_connect(socket_path, cmdflags & CMD_STARTSERVER);
+	if (fd == -1) {
+		log_warn("failed to connect to server");
+		return (1);
+	}
+
+	/* Set process title, log and signals now this is the client. */
+#ifdef HAVE_SETPROCTITLE
+	setproctitle("client (%s)", socket_path);
+#endif
+	logfile("client");
+
+	/* Create imsg. */
+	imsg_init(&client_ibuf, fd);
+	event_set(&client_event, fd, EV_READ, client_callback, shell_cmd);
+
+	/* Establish signal handlers. */
+	set_signals(client_signal);
+
+	/* Send initial environment. */
+	if (cmdflags & CMD_SENDENVIRON)
+		client_send_environ();
+	client_send_identify(flags);
+
+	/* Send first command. */
+	if (msg == MSG_COMMAND) {
+		/* Fill in command line arguments. */
+		cmddata.pid = environ_pid;
+		cmddata.idx = environ_idx;
+
+		/* Prepare command for server. */
+		cmddata.argc = argc;
+		if (cmd_pack_argv(
+		    argc, argv, cmddata.argv, sizeof cmddata.argv) != 0) {
+			log_warnx("command too long");
+			return (1);
+		}
+
+		client_write_server(msg, &cmddata, sizeof cmddata);
+	} else if (msg == MSG_SHELL)
+		client_write_server(msg, NULL, 0);
+
+	/* Set the event and dispatch. */
+	client_update_event();
+	event_dispatch();
+
+	/* Print the exit message, if any, and exit. */
+	if (client_attached) {
+		if (client_exitmsg != NULL && !login_shell)
+			printf("[%s]\n", client_exitmsg);
+
+		ppid = getppid();
+		if (client_exittype == MSG_DETACHKILL && ppid > 1)
+			kill(ppid, SIGHUP);
+	}
+	return (client_exitval);
+}
+
+/* Send identify message to server with the file descriptors. */
 void
 client_send_identify(int flags)
 {
 	struct msg_identify_data	data;
-	struct winsize			ws;
 	char			       *term;
 	int				fd;
 
-	if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) == -1)
-		fatal("ioctl(TIOCGWINSZ)");
 	data.flags = flags;
 
 	if (getcwd(data.cwd, sizeof data.cwd) == NULL)
@@ -139,8 +229,19 @@ client_send_identify(int flags)
 		fatal("dup failed");
 	imsg_compose(&client_ibuf,
 	    MSG_IDENTIFY, PROTOCOL_VERSION, -1, fd, &data, sizeof data);
+
+	if ((fd = dup(STDOUT_FILENO)) == -1)
+		fatal("dup failed");
+	imsg_compose(&client_ibuf,
+	    MSG_STDOUT, PROTOCOL_VERSION, -1, fd, NULL, 0);
+
+	if ((fd = dup(STDERR_FILENO)) == -1)
+		fatal("dup failed");
+	imsg_compose(&client_ibuf,
+	    MSG_STDERR, PROTOCOL_VERSION, -1, fd, NULL, 0);
 }
 
+/* Forward entire environment to server. */
 void
 client_send_environ(void)
 {
@@ -154,12 +255,14 @@ client_send_environ(void)
 	}
 }
 
+/* Write a message to the server without a file descriptor. */
 void
 client_write_server(enum msgtype type, void *buf, size_t len)
 {
 	imsg_compose(&client_ibuf, type, PROTOCOL_VERSION, -1, -1, buf, len);
 }
 
+/* Update client event based on whether it needs to read or read and write. */
 void
 client_update_event(void)
 {
@@ -169,102 +272,74 @@ client_update_event(void)
 	events = EV_READ;
 	if (client_ibuf.w.queued > 0)
 		events |= EV_WRITE;
-	event_set(&client_event, client_ibuf.fd, events, client_callback, NULL);
+	event_set(
+	    &client_event, client_ibuf.fd, events, client_callback, shell_cmd);
 	event_add(&client_event, NULL);
 }
 
-__dead void
+/* Callback to handle signals in the client. */
-client_main(void)
-{
-	struct event		ev_sigcont, ev_sigterm, ev_sigwinch;
-	struct sigaction	sigact;
-
-	logfile("client");
-
-	/* Note: event_init() has already been called. */
-
-	/* Set up signals. */
-	memset(&sigact, 0, sizeof sigact);
-	sigemptyset(&sigact.sa_mask);
-	sigact.sa_flags = SA_RESTART;
-	sigact.sa_handler = SIG_IGN;
-	if (sigaction(SIGINT, &sigact, NULL) != 0)
-		fatal("sigaction failed");
-	if (sigaction(SIGPIPE, &sigact, NULL) != 0)
-		fatal("sigaction failed");
-	if (sigaction(SIGUSR1, &sigact, NULL) != 0)
-		fatal("sigaction failed");
-	if (sigaction(SIGUSR2, &sigact, NULL) != 0)
-		fatal("sigaction failed");
-	if (sigaction(SIGTSTP, &sigact, NULL) != 0)
-		fatal("sigaction failed");
-
-	signal_set(&ev_sigcont, SIGCONT, client_signal, NULL);
-	signal_add(&ev_sigcont, NULL);
-	signal_set(&ev_sigterm, SIGTERM, client_signal, NULL);
-	signal_add(&ev_sigterm, NULL);
-	signal_set(&ev_sigwinch, SIGWINCH, client_signal, NULL);
-	signal_add(&ev_sigwinch, NULL);
-
-	/*
-	 * imsg_read in the first client poll loop (before the terminal has
-	 * been initialised) may have read messages into the buffer after the
-	 * MSG_READY switched to here. Process anything outstanding now to
-	 * avoid hanging waiting for messages that have already arrived.
-	 */
-	if (client_dispatch() != 0)
-		goto out;
-
-	/* Set the event and dispatch. */
-	client_update_event();
-	event_dispatch();
-
-out:
-	/* Print the exit message, if any, and exit. */
-	if (client_exitmsg != NULL && !login_shell)
-		printf("[%s]\n", client_exitmsg);
-	exit(client_exitval);
-}
-
 /* ARGSUSED */
 void
 client_signal(int sig, unused short events, unused void *data)
 {
-	struct sigaction	sigact;
+	struct sigaction sigact;
+	int		 status;
 
-	switch (sig) {
+	if (!client_attached) {
-	case SIGTERM:
+		switch (sig) {
-		client_exitmsg = "terminated";
+		case SIGCHLD:
-		client_exitval = 1;
+			waitpid(WAIT_ANY, &status, WNOHANG);
-		client_write_server(MSG_EXITING, NULL, 0);
+			break;
-		break;
+		case SIGTERM:
-	case SIGWINCH:
+			event_loopexit(NULL);
-		client_write_server(MSG_RESIZE, NULL, 0);
+			break;
-		break;
+		}
-	case SIGCONT:
+	} else {
-		memset(&sigact, 0, sizeof sigact);
+		switch (sig) {
-		sigemptyset(&sigact.sa_mask);
+		case SIGHUP:
-		sigact.sa_flags = SA_RESTART;
+			client_exitmsg = "lost tty";
-		sigact.sa_handler = SIG_IGN;
+			client_exitval = 1;
-		if (sigaction(SIGTSTP, &sigact, NULL) != 0)
+			client_write_server(MSG_EXITING, NULL, 0);
-			fatal("sigaction failed");
+			break;
-		client_write_server(MSG_WAKEUP, NULL, 0);
+		case SIGTERM:
-		break;
+			client_exitmsg = "terminated";
+			client_exitval = 1;
+			client_write_server(MSG_EXITING, NULL, 0);
+			break;
+		case SIGWINCH:
+			client_write_server(MSG_RESIZE, NULL, 0);
+			break;
+		case SIGCONT:
+			memset(&sigact, 0, sizeof sigact);
+			sigemptyset(&sigact.sa_mask);
+			sigact.sa_flags = SA_RESTART;
+			sigact.sa_handler = SIG_IGN;
+			if (sigaction(SIGTSTP, &sigact, NULL) != 0)
+				fatal("sigaction failed");
+			client_write_server(MSG_WAKEUP, NULL, 0);
+			break;
+		}
 	}
 
 	client_update_event();
 }
 
+/* Callback for client imsg read events. */
 /* ARGSUSED */
 void
-client_callback(unused int fd, short events, unused void *data)
+client_callback(unused int fd, short events, void *data)
 {
 	ssize_t	n;
+	int	retval;
 
 	if (events & EV_READ) {
 		if ((n = imsg_read(&client_ibuf)) == -1 || n == 0)
 			goto lost_server;
-		if (client_dispatch() != 0) {
+		if (client_attached)
+			retval = client_dispatch_attached();
+		else
+			retval = client_dispatch_wait(data);
+		if (retval != 0) {
 			event_loopexit(NULL);
 			return;
 		}
@@ -284,8 +359,76 @@ lost_server:
 	event_loopexit(NULL);
 }
 
+/* Dispatch imsgs when in wait state (before MSG_READY). */
 int
-client_dispatch(void)
+client_dispatch_wait(void *data)
+{
+	struct imsg		imsg;
+	ssize_t			n, datalen;
+	struct msg_shell_data	shelldata;
+	struct msg_exit_data	exitdata;
+	const char             *shellcmd = data;
+
+	if ((n = imsg_read(&client_ibuf)) == -1 || n == 0)
+		fatalx("imsg_read failed");
+
+	for (;;) {
+		if ((n = imsg_get(&client_ibuf, &imsg)) == -1)
+			fatalx("imsg_get failed");
+		if (n == 0)
+			return (0);
+		datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
+
+		switch (imsg.hdr.type) {
+		case MSG_EXIT:
+		case MSG_SHUTDOWN:
+			if (datalen != sizeof exitdata) {
+				if (datalen != 0)
+					fatalx("bad MSG_EXIT size");
+			} else {
+				memcpy(&exitdata, imsg.data, sizeof exitdata);
+				client_exitval = exitdata.retcode;
+			}
+			imsg_free(&imsg);
+			return (-1);
+		case MSG_READY:
+			if (datalen != 0)
+				fatalx("bad MSG_READY size");
+
+			client_attached = 1;
+			break;
+		case MSG_VERSION:
+			if (datalen != 0)
+				fatalx("bad MSG_VERSION size");
+
+			log_warnx("protocol version mismatch (client %u, "
+			    "server %u)", PROTOCOL_VERSION, imsg.hdr.peerid);
+			client_exitval = 1;
+
+			imsg_free(&imsg);
+			return (-1);
+		case MSG_SHELL:
+			if (datalen != sizeof shelldata)
+				fatalx("bad MSG_SHELL size");
+			memcpy(&shelldata, imsg.data, sizeof shelldata);
+			shelldata.shell[(sizeof shelldata.shell) - 1] = '\0';
+
+			clear_signals(0);
+
+			shell_exec(shelldata.shell, shellcmd);
+			/* NOTREACHED */
+		default:
+			fatalx("unexpected message");
+		}
+
+		imsg_free(&imsg);
+	}
+}
+
+/* Dispatch imsgs in attached state (after MSG_READY). */
+/* ARGSUSED */
+int
+client_dispatch_attached(void)
 {
 	struct imsg		imsg;
 	struct msg_lock_data	lockdata;
@@ -301,15 +444,21 @@ client_dispatch(void)
 
 		log_debug("client got %d", imsg.hdr.type);
 		switch (imsg.hdr.type) {
+		case MSG_DETACHKILL:
 		case MSG_DETACH:
 			if (datalen != 0)
 				fatalx("bad MSG_DETACH size");
 
+			client_exittype = imsg.hdr.type;
+			if (imsg.hdr.type == MSG_DETACHKILL)
+				client_exitmsg = "detached and SIGHUP";
+			else
+				client_exitmsg = "detached";
 			client_write_server(MSG_EXITING, NULL, 0);
-			client_exitmsg = "detached";
 			break;
 		case MSG_EXIT:
-			if (datalen != 0)
+			if (datalen != 0 &&
+			    datalen != sizeof (struct msg_exit_data))
 				fatalx("bad MSG_EXIT size");
 
 			client_write_server(MSG_EXITING, NULL, 0);

clock.c

@@ -1,4 +1,4 @@
-/* $Id: clock.c,v 1.9 2009-12-04 22:14:47 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>

cmd-attach-session.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-attach-session.c,v 1.36 2010-02-08 18:27:34 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -28,37 +28,37 @@ int	cmd_attach_session_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_attach_session_entry = {
 	"attach-session", "attach",
+	"drt:", 0, 0,
 	"[-dr] " CMD_TARGET_SESSION_USAGE,
-	CMD_CANTNEST|CMD_STARTSERVER|CMD_SENDENVIRON, "dr",
+	CMD_CANTNEST|CMD_STARTSERVER|CMD_SENDENVIRON,
-	cmd_target_init,
+	NULL,
-	cmd_target_parse,
+	NULL,
-	cmd_attach_session_exec,
+	cmd_attach_session_exec
-	cmd_target_free,
-	cmd_target_print
 };
 
 int
 cmd_attach_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data	*data = self->data;
+	struct args	*args = self->args;
-	struct session		*s;
+	struct session	*s;
-	struct client		*c;
+	struct client	*c;
-	const char		*update;
+	const char	*update;
-	char			*overrides, *cause;
+	char		*overrides, *cause;
-	u_int			 i;
+	u_int		 i;
 
-	if (ARRAY_LENGTH(&sessions) == 0) {
+	if (RB_EMPTY(&sessions)) {
 		ctx->error(ctx, "no sessions");
 		return (-1);
 	}
-	if ((s = cmd_find_session(ctx, data->target)) == NULL)
+
+	if ((s = cmd_find_session(ctx, args_get(args, 't'), 1)) == NULL)
 		return (-1);
 
 	if (ctx->cmdclient == NULL && ctx->curclient == NULL)
 		return (0);
 
 	if (ctx->cmdclient == NULL) {
-		if (cmd_check_flag(data->chflags, 'd')) {
+		if (args_has(self->args, 'd')) {
 			/*
 			 * Can't use server_write_session in case attaching to
 			 * the same session as currently attached to.
@@ -74,7 +74,9 @@ cmd_attach_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 		}
 
 		ctx->curclient->session = s;
+		session_update_activity(s);
 		server_redraw_client(ctx->curclient);
+		s->curw->flags &= ~WINLINK_ALERTFLAGS;
 	} else {
 		if (!(ctx->cmdclient->flags & CLIENT_TERMINAL)) {
 			ctx->error(ctx, "not a terminal");
@@ -89,19 +91,21 @@ cmd_attach_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 			return (-1);
 		}
 
-		if (cmd_check_flag(data->chflags, 'r'))
+		if (args_has(self->args, 'r'))
 			ctx->cmdclient->flags |= CLIENT_READONLY;
 
-		if (cmd_check_flag(data->chflags, 'd'))
+		if (args_has(self->args, 'd'))
 			server_write_session(s, MSG_DETACH, NULL, 0);
 
 		ctx->cmdclient->session = s;
+		session_update_activity(s);
 		server_write_client(ctx->cmdclient, MSG_READY, NULL, 0);
 
 		update = options_get_string(&s->options, "update-environment");
 		environ_update(update, &ctx->cmdclient->environ, &s->environ);
 
 		server_redraw_client(ctx->cmdclient);
+		s->curw->flags &= ~WINLINK_ALERTFLAGS;
 	}
 	recalculate_sizes();
 	server_update_socket();

cmd-bind-key.c

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

cmd-break-pane.c

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

cmd-capture-pane.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-capture-pane.c,v 1.3 2010-01-22 17:29:19 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Jonathan Alvarado <radobobo@users.sourceforge.net>
@@ -18,6 +18,7 @@
 
 #include <sys/types.h>
 
+#include <stdlib.h>
 #include <string.h>
 
 #include "tmux.h"
@@ -30,35 +31,64 @@ int	cmd_capture_pane_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_capture_pane_entry = {
 	"capture-pane", "capturep",
-	CMD_BUFFER_PANE_USAGE,
+	"b:E:S:t:", 0, 0,
-	0, "",
+	"[-b buffer-index] [-E end-line] [-S start-line] [-t target-pane]",
-	cmd_buffer_init,
+	0,
-	cmd_buffer_parse,
+	NULL,
-	cmd_capture_pane_exec,
+	NULL,
-	cmd_buffer_free,
+	cmd_capture_pane_exec
-	cmd_buffer_print
 };
 
 int
 cmd_capture_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_buffer_data	*data = self->data;
+	struct args		*args = self->args;
 	struct window_pane	*wp;
-	char 			*buf, *line;
+	char 			*buf, *line, *cause;
 	struct screen		*s;
-	struct session		*sess;
+	struct grid		*gd;
-	u_int			 i, limit;
+	int			 buffer, n;
+	u_int			 i, limit, top, bottom, tmp;
 	size_t         		 len, linelen;
 
-	if (cmd_find_pane(ctx, data->target, &sess, &wp) == NULL)
+	if (cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp) == NULL)
 		return (-1);
 	s = &wp->base;
+	gd = s->grid;
 
 	buf = NULL;
 	len = 0;
 
-	for (i = 0; i < screen_size_y(s); i++) {
+	n = args_strtonum(args, 'S', INT_MIN, SHRT_MAX, &cause);
-	       line = grid_view_string_cells(s->grid, 0, i, screen_size_x(s));
+	if (cause != NULL) {
+		top = gd->hsize;
+		xfree(cause);
+	} else if (n < 0 && (u_int) -n > gd->hsize)
+		top = 0;
+	else
+		top = gd->hsize + n;
+	if (top > gd->hsize + gd->sy - 1)
+		top = gd->hsize + gd->sy - 1;
+
+	n = args_strtonum(args, 'E', INT_MIN, SHRT_MAX, &cause);
+	if (cause != NULL) {
+		bottom = gd->hsize + gd->sy - 1;
+		xfree(cause);
+	} else if (n < 0 && (u_int) -n > gd->hsize)
+		bottom = 0;
+	else
+		bottom = gd->hsize + n;
+	if (bottom > gd->hsize + gd->sy - 1)
+		bottom = gd->hsize + gd->sy - 1;
+
+	if (bottom < top) {
+		tmp = bottom;
+		bottom = top;
+		top = tmp;
+	}
+
+	for (i = top; i <= bottom; i++) {
+	       line = grid_string_cells(s->grid, 0, i, screen_size_x(s));
 	       linelen = strlen(line);
 
 	       buf = xrealloc(buf, 1, len + linelen + 1);
@@ -69,15 +99,26 @@ cmd_capture_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 	       xfree(line);
 	}
 
-	limit = options_get_number(&sess->options, "buffer-limit");
+	limit = options_get_number(&global_options, "buffer-limit");
-	if (data->buffer == -1) {
+
-		paste_add(&sess->buffers, buf, len, limit);
+	if (!args_has(args, 'b')) {
+		paste_add(&global_buffers, buf, len, limit);
 		return (0);
 	}
-	if (paste_replace(&sess->buffers, data->buffer, buf, len) != 0) {
+
-		ctx->error(ctx, "no buffer %d", data->buffer);
+	buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
+	if (cause != NULL) {
+		ctx->error(ctx, "buffer %s", cause);
+		xfree(buf);
+		xfree(cause);
+		return (-1);
+	}
+
+	if (paste_replace(&global_buffers, buffer, buf, len) != 0) {
+		ctx->error(ctx, "no buffer %d", buffer);
 		xfree(buf);
 		return (-1);
 	}
+
 	return (0);
 }

cmd-choose-buffer.c

@@ -0,0 +1,143 @@
+/* $Id$ */
+
+/*
+ * Copyright (c) 2010 Nicholas Marriott <nicm@users.sourceforge.net>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+
+#include <ctype.h>
+
+#include "tmux.h"
+
+/*
+ * Enter choice mode to choose a buffer.
+ */
+
+int	cmd_choose_buffer_exec(struct cmd *, struct cmd_ctx *);
+
+void	cmd_choose_buffer_callback(void *, int);
+void	cmd_choose_buffer_free(void *);
+
+const struct cmd_entry cmd_choose_buffer_entry = {
+	"choose-buffer", NULL,
+	"t:", 0, 1,
+	CMD_TARGET_WINDOW_USAGE " [template]",
+	0,
+	NULL,
+	NULL,
+	cmd_choose_buffer_exec
+};
+
+struct cmd_choose_buffer_data {
+	struct client   *client;
+	char            *template;
+};
+
+int
+cmd_choose_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
+{
+	struct args			*args = self->args;
+	struct cmd_choose_buffer_data	*cdata;
+	struct winlink			*wl;
+	struct paste_buffer		*pb;
+	u_int				 idx;
+	char				*tmp;
+
+	if (ctx->curclient == NULL) {
+		ctx->error(ctx, "must be run interactively");
+		return (-1);
+	}
+
+	if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
+		return (-1);
+
+	if (paste_get_top(&global_buffers) == NULL)
+		return (0);
+
+	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
+		return (0);
+
+	idx = 0;
+	while ((pb = paste_walk_stack(&global_buffers, &idx)) != NULL) {
+		tmp = paste_print(pb, 50);
+		window_choose_add(wl->window->active, idx - 1,
+		    "%u: %zu bytes: \"%s\"", idx - 1, pb->size, tmp);
+		xfree(tmp);
+	}
+
+	cdata = xmalloc(sizeof *cdata);
+	if (args->argc != 0)
+		cdata->template = xstrdup(args->argv[0]);
+	else
+		cdata->template = xstrdup("paste-buffer -b '%%'");
+	cdata->client = ctx->curclient;
+	cdata->client->references++;
+
+	window_choose_ready(wl->window->active,
+	    0, cmd_choose_buffer_callback, cmd_choose_buffer_free, cdata);
+
+	return (0);
+}
+
+void
+cmd_choose_buffer_callback(void *data, int idx)
+{
+	struct cmd_choose_buffer_data	*cdata = data;
+	struct cmd_list			*cmdlist;
+	struct cmd_ctx			 ctx;
+	char				*template, *cause, tmp[16];
+
+	if (idx == -1)
+		return;
+	if (cdata->client->flags & CLIENT_DEAD)
+		return;
+
+	xsnprintf(tmp, sizeof tmp, "%u", idx);
+	template = cmd_template_replace(cdata->template, tmp, 1);
+
+	if (cmd_string_parse(template, &cmdlist, &cause) != 0) {
+		if (cause != NULL) {
+			*cause = toupper((u_char) *cause);
+			status_message_set(cdata->client, "%s", cause);
+			xfree(cause);
+		}
+		xfree(template);
+		return;
+	}
+	xfree(template);
+
+	ctx.msgdata = NULL;
+	ctx.curclient = cdata->client;
+
+	ctx.error = key_bindings_error;
+	ctx.print = key_bindings_print;
+	ctx.info = key_bindings_info;
+
+	ctx.cmdclient = NULL;
+
+	cmd_list_exec(cmdlist, &ctx);
+	cmd_list_free(cmdlist);
+}
+
+void
+cmd_choose_buffer_free(void *data)
+{
+	struct cmd_choose_buffer_data	*cdata = data;
+
+	cdata->client->references--;
+	xfree(cdata->template);
+	xfree(cdata);
+}

cmd-choose-client.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-choose-client.c,v 1.4 2009-11-14 17:56:39 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -33,13 +33,12 @@ void	cmd_choose_client_free(void *);
 
 const struct cmd_entry cmd_choose_client_entry = {
 	"choose-client", NULL,
+	"t:", 0, 1,
 	CMD_TARGET_WINDOW_USAGE " [template]",
-	CMD_ARG01, "",
+	0,
-	cmd_target_init,
+	NULL,
-	cmd_target_parse,
+	NULL,
-	cmd_choose_client_exec,
+	cmd_choose_client_exec
-	cmd_target_free,
-	cmd_target_print
 };
 
 struct cmd_choose_client_data {
@@ -50,7 +49,7 @@ struct cmd_choose_client_data {
 int
 cmd_choose_client_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data		*data = self->data;
+	struct args			*args = self->args;
 	struct cmd_choose_client_data	*cdata;
 	struct winlink			*wl;
 	struct client			*c;
@@ -61,7 +60,7 @@ cmd_choose_client_exec(struct cmd *self, struct cmd_ctx *ctx)
 		return (-1);
 	}
 
-	if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
+	if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
 		return (-1);
 
 	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
@@ -77,14 +76,16 @@ cmd_choose_client_exec(struct cmd *self, struct cmd_ctx *ctx)
 		idx++;
 
 		window_choose_add(wl->window->active, i,
-		    "%s: %s [%ux%u %s]%s", c->tty.path,
+		    "%s: %s [%ux%u %s]%s%s", c->tty.path,
 		    c->session->name, c->tty.sx, c->tty.sy,
-		    c->tty.termname, c->tty.flags & TTY_UTF8 ? " (utf8)" : "");
+		    c->tty.termname,
+		    c->tty.flags & TTY_UTF8 ? " (utf8)" : "",
+		    c->flags & CLIENT_READONLY ? " (ro)" : "");
 	}
 
 	cdata = xmalloc(sizeof *cdata);
-	if (data->arg != NULL)
+	if (args->argc != 0)
-		cdata->template = xstrdup(data->arg);
+		cdata->template = xstrdup(args->argv[0]);
 	else
 		cdata->template = xstrdup("detach-client -t '%%'");
 	cdata->client = ctx->curclient;

cmd-choose-session.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-choose-session.c,v 1.15 2009-11-14 17:56:39 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -33,13 +33,12 @@ void	cmd_choose_session_free(void *);
 
 const struct cmd_entry cmd_choose_session_entry = {
 	"choose-session", NULL,
+	"t:", 0, 1,
 	CMD_TARGET_WINDOW_USAGE " [template]",
-	CMD_ARG01, "",
+	0,
-	cmd_target_init,
+	NULL,
-	cmd_target_parse,
+	NULL,
-	cmd_choose_session_exec,
+	cmd_choose_session_exec
-	cmd_target_free,
-	cmd_target_print
 };
 
 struct cmd_choose_session_data {
@@ -50,12 +49,12 @@ struct cmd_choose_session_data {
 int
 cmd_choose_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data		*data = self->data;
+	struct args			*args = self->args;
 	struct cmd_choose_session_data	*cdata;
 	struct winlink			*wl;
 	struct session			*s;
 	struct session_group		*sg;
-	u_int			 	 i, idx, cur;
+	u_int			 	 idx, sgidx, cur;
 	char				 tmp[64];
 
 	if (ctx->curclient == NULL) {
@@ -63,17 +62,14 @@ cmd_choose_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 		return (-1);
 	}
 
-	if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
+	if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
 		return (-1);
 
 	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
 		return (0);
 
 	cur = idx = 0;
-	for (i = 0; i < ARRAY_LENGTH(&sessions); i++) {
+	RB_FOREACH(s, sessions, &sessions) {
-		s = ARRAY_ITEM(&sessions, i);
-		if (s == NULL)
-			continue;
 		if (s == ctx->curclient->session)
 			cur = idx;
 		idx++;
@@ -82,19 +78,19 @@ cmd_choose_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 		if (sg == NULL)
 			*tmp = '\0';
 		else {
-			idx = session_group_index(sg);
+			sgidx = session_group_index(sg);
-			xsnprintf(tmp, sizeof tmp, " (group %u)", idx);
+			xsnprintf(tmp, sizeof tmp, " (group %u)", sgidx);
 		}
 
-		window_choose_add(wl->window->active, i,
+		window_choose_add(wl->window->active, s->idx,
 		    "%s: %u windows [%ux%u]%s%s", s->name,
 		    winlink_count(&s->windows), s->sx, s->sy,
 		    tmp, s->flags & SESSION_UNATTACHED ? "" : " (attached)");
 	}
 
 	cdata = xmalloc(sizeof *cdata);
-	if (data->arg != NULL)
+	if (args->argc != 0)
-		cdata->template = xstrdup(data->arg);
+		cdata->template = xstrdup(args->argv[0]);
 	else
 		cdata->template = xstrdup("switch-client -t '%%'");
 	cdata->client = ctx->curclient;
@@ -120,9 +116,7 @@ cmd_choose_session_callback(void *data, int idx)
 	if (cdata->client->flags & CLIENT_DEAD)
 		return;
 
-	if ((u_int) idx > ARRAY_LENGTH(&sessions) - 1)
+	s = session_find_by_index(idx);
-		return;
-	s = ARRAY_ITEM(&sessions, idx);
 	if (s == NULL)
 		return;
 	template = cmd_template_replace(cdata->template, s->name, 1);

cmd-choose-window.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-choose-window.c,v 1.20 2009-12-04 22:14:47 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -33,13 +33,12 @@ void	cmd_choose_window_free(void *);
 
 const struct cmd_entry cmd_choose_window_entry = {
 	"choose-window", NULL,
+	"t:", 0, 1,
 	CMD_TARGET_WINDOW_USAGE " [template]",
-	CMD_ARG01, "",
+	0,
-	cmd_target_init,
+	NULL,
-	cmd_target_parse,
+	NULL,
-	cmd_choose_window_exec,
+	cmd_choose_window_exec
-	cmd_target_free,
-	cmd_target_print
 };
 
 struct cmd_choose_window_data {
@@ -51,13 +50,13 @@ struct cmd_choose_window_data {
 int
 cmd_choose_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data		*data = self->data;
+	struct args			*args = self->args;
 	struct cmd_choose_window_data	*cdata;
 	struct session			*s;
 	struct winlink			*wl, *wm;
 	struct window			*w;
 	u_int			 	 idx, cur;
-	char				 flag, *title;
+	char				*flags, *title;
 	const char			*left, *right;
 
 	if (ctx->curclient == NULL) {
@@ -66,7 +65,7 @@ cmd_choose_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 	}
 	s = ctx->curclient->session;
 
-	if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
+	if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
 		return (-1);
 
 	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
@@ -80,18 +79,7 @@ cmd_choose_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 			cur = idx;
 		idx++;
 
-		flag = ' ';
+		flags = window_printable_flags(s, wm);
-		if (session_alert_has(s, wm, WINDOW_ACTIVITY))
-			flag = '#';
-		else if (session_alert_has(s, wm, WINDOW_BELL))
-			flag = '!';
-		else if (session_alert_has(s, wm, WINDOW_CONTENT))
-			flag = '+';
-		else if (wm == s->curw)
-			flag = '*';
-		else if (wm == TAILQ_FIRST(&s->lastw))
-			flag = '-';
-
 		title = w->active->screen->title;
 		if (wm == wl)
 			title = w->active->base.title;
@@ -101,14 +89,17 @@ cmd_choose_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 			left = right = "";
 
 		window_choose_add(wl->window->active,
-		    wm->idx, "%3d: %s%c [%ux%u] (%u panes)%s%s%s",
+		    wm->idx, "%3d: %s%s [%ux%u] (%u panes%s)%s%s%s",
-		    wm->idx, w->name, flag, w->sx, w->sy, window_count_panes(w),
+		    wm->idx, w->name, flags, w->sx, w->sy, window_count_panes(w),
+		    w->active->fd == -1 ? ", dead" : "",
 		    left, title, right);
+
+		xfree(flags);
 	}
 
 	cdata = xmalloc(sizeof *cdata);
-	if (data->arg != NULL)
+	if (args->argc != 0)
-		cdata->template = xstrdup(data->arg);
+		cdata->template = xstrdup(args->argv[0]);
 	else
 		cdata->template = xstrdup("select-window -t '%%'");
 	cdata->session = s;
@@ -126,20 +117,19 @@ void
 cmd_choose_window_callback(void *data, int idx)
 {
 	struct cmd_choose_window_data	*cdata = data;
+	struct session			*s = cdata->session;
 	struct cmd_list			*cmdlist;
 	struct cmd_ctx			 ctx;
 	char				*target, *template, *cause;
 
 	if (idx == -1)
 		return;
+	if (!session_alive(s))
+		return;
 	if (cdata->client->flags & CLIENT_DEAD)
 		return;
-	if (cdata->session->flags & SESSION_DEAD)
-		return;
-	if (cdata->client->session != cdata->session)
-		return;
 
-	xasprintf(&target, "%s:%d", cdata->session->name, idx);
+	xasprintf(&target, "%s:%d", s->name, idx);
 	template = cmd_template_replace(cdata->template, target, 1);
 	xfree(target);
 

cmd-clear-history.c

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

cmd-clock-mode.c

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

cmd-command-prompt.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-command-prompt.c,v 1.27 2009-11-14 17:56:39 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -20,6 +20,7 @@
 
 #include <ctype.h>
 #include <string.h>
+#include <time.h>
 
 #include "tmux.h"
 
@@ -27,34 +28,27 @@
  * Prompt for command in client.
  */
 
-void	 cmd_command_prompt_init(struct cmd *, int);
+void	cmd_command_prompt_key_binding(struct cmd *, int);
-int	 cmd_command_prompt_parse(struct cmd *, int, char **, char **);
+int	cmd_command_prompt_check(struct args *);
-int	 cmd_command_prompt_exec(struct cmd *, struct cmd_ctx *);
+int	cmd_command_prompt_exec(struct cmd *, struct cmd_ctx *);
-void	 cmd_command_prompt_free(struct cmd *);
-size_t	 cmd_command_prompt_print(struct cmd *, char *, size_t);
 
-int	 cmd_command_prompt_callback(void *, const char *);
+int	cmd_command_prompt_callback(void *, const char *);
-void	 cmd_command_prompt_cfree(void *);
+void	cmd_command_prompt_free(void *);
 
 const struct cmd_entry cmd_command_prompt_entry = {
 	"command-prompt", NULL,
-	CMD_TARGET_CLIENT_USAGE " [-p prompts] [template]",
+	"I:p:t:", 0, 1,
-	0, "",
+	"[-I inputs] [-p prompts] " CMD_TARGET_CLIENT_USAGE " [template]",
-	cmd_command_prompt_init,
+	0,
-	cmd_command_prompt_parse,
+	cmd_command_prompt_key_binding,
-	cmd_command_prompt_exec,
+	NULL,
-	cmd_command_prompt_free,
+	cmd_command_prompt_exec
-	cmd_command_prompt_print
-};
-
-struct cmd_command_prompt_data {
-	char	*prompts;
-	char	*target;
-	char	*template;
 };
 
 struct cmd_command_prompt_cdata {
 	struct client	*c;
+	char		*inputs;
+	char		*next_input;
 	char		*next_prompt;
 	char		*prompts;
 	char		*template;
@@ -62,78 +56,44 @@ struct cmd_command_prompt_cdata {
 };
 
 void
-cmd_command_prompt_init(struct cmd *self, int key)
+cmd_command_prompt_key_binding(struct cmd *self, int key)
 {
-	struct cmd_command_prompt_data	*data;
-
-	self->data = data = xmalloc(sizeof *data);
-	data->prompts = NULL;
-	data->target = NULL;
-	data->template = NULL;
-
 	switch (key) {
+	case '$':
+		self->args = args_create(1, "rename-session '%%'");
+		args_set(self->args, 'I', "#S");
+		break;
 	case ',':
-		data->template = xstrdup("rename-window '%%'");
+		self->args = args_create(1, "rename-window '%%'");
+		args_set(self->args, 'I', "#W");
 		break;
 	case '.':
-		data->template = xstrdup("move-window -t '%%'");
+		self->args = args_create(1, "move-window -t '%%'");
 		break;
 	case 'f':
-		data->template = xstrdup("find-window '%%'");
+		self->args = args_create(1, "find-window '%%'");
+		break;
+	case '\'':
+		self->args = args_create(1, "select-window -t ':%%'");
+		args_set(self->args, 'p', "index");
+		break;
+	default:
+		self->args = args_create(0);
 		break;
 	}
 }
 
-int
-cmd_command_prompt_parse(struct cmd *self, int argc, char **argv, char **cause)
-{
-	struct cmd_command_prompt_data	*data;
-	int				 opt;
-
-	self->entry->init(self, KEYC_NONE);
-	data = self->data;
-
-	while ((opt = getopt(argc, argv, "p:t:")) != -1) {
-		switch (opt) {
-		case 'p':
-			if (data->prompts == NULL)
-				data->prompts = xstrdup(optarg);
-			break;
-		case 't':
-			if (data->target == NULL)
-				data->target = xstrdup(optarg);
-			break;
-		default:
-			goto usage;
-		}
-	}
-	argc -= optind;
-	argv += optind;
-	if (argc != 0 && argc != 1)
-		goto usage;
-
-	if (argc == 1)
-		data->template = xstrdup(argv[0]);
-
-	return (0);
-
-usage:
-	xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
-
-	self->entry->free(self);
-	return (-1);
-}
-
 int
 cmd_command_prompt_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_command_prompt_data	*data = self->data;
+	struct args			*args = self->args;
+	const char			*inputs, *prompts;
 	struct cmd_command_prompt_cdata	*cdata;
 	struct client			*c;
-	char				*prompt, *ptr;
+	char				*prompt, *ptr, *input = NULL;
 	size_t				 n;
 
-	if ((c = cmd_find_client(ctx, data->target)) == NULL)
+	if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
 		return (-1);
 
 	if (c->prompt_string != NULL)
@@ -142,67 +102,47 @@ cmd_command_prompt_exec(struct cmd *self, struct cmd_ctx *ctx)
 	cdata = xmalloc(sizeof *cdata);
 	cdata->c = c;
 	cdata->idx = 1;
+	cdata->inputs = NULL;
+	cdata->next_input = NULL;
 	cdata->next_prompt = NULL;
 	cdata->prompts = NULL;
 	cdata->template = NULL;
 
-	if (data->template != NULL)
+	if (args->argc != 0)
-		cdata->template = xstrdup(data->template);
+		cdata->template = xstrdup(args->argv[0]);
 	else
 		cdata->template = xstrdup("%1");
-	if (data->prompts != NULL)
+
-		cdata->prompts = xstrdup(data->prompts);
+	if ((prompts = args_get(args, 'p')) != NULL)
-	else if (data->template != NULL) {
+		cdata->prompts = xstrdup(prompts);
-		n = strcspn(data->template, " ,");
+	else if (args->argc != 0) {
-		xasprintf(&cdata->prompts, "(%.*s) ", (int) n, data->template);
+		n = strcspn(cdata->template, " ,");
+		xasprintf(&cdata->prompts, "(%.*s) ", (int) n, cdata->template);
 	} else
 		cdata->prompts = xstrdup(":");
 
+	/* Get first prompt. */
 	cdata->next_prompt = cdata->prompts;
 	ptr = strsep(&cdata->next_prompt, ",");
-	if (data->prompts == NULL)
+	if (prompts == NULL)
 		prompt = xstrdup(ptr);
 	else
 		xasprintf(&prompt, "%s ", ptr);
-	status_prompt_set(c, prompt, cmd_command_prompt_callback,
+
-	    cmd_command_prompt_cfree, cdata, 0);
+	/* Get initial prompt input. */
+	if ((inputs = args_get(args, 'I')) != NULL) {
+		cdata->inputs = xstrdup(inputs);
+		cdata->next_input = cdata->inputs;
+		input = strsep(&cdata->next_input, ",");
+	}
+
+	status_prompt_set(c, prompt, input, cmd_command_prompt_callback,
+	    cmd_command_prompt_free, cdata, 0);
 	xfree(prompt);
 
 	return (0);
 }
 
-void
-cmd_command_prompt_free(struct cmd *self)
-{
-	struct cmd_command_prompt_data	*data = self->data;
-
-	if (data->prompts != NULL)
-		xfree(data->prompts);
-	if (data->target != NULL)
-		xfree(data->target);
-	if (data->template != NULL)
-		xfree(data->template);
-	xfree(data);
-}
-
-size_t
-cmd_command_prompt_print(struct cmd *self, char *buf, size_t len)
-{
-	struct cmd_command_prompt_data	*data = self->data;
-	size_t				 off = 0;
-
-	off += xsnprintf(buf, len, "%s", self->entry->name);
-	if (data == NULL)
-		return (off);
-	if (off < len && data->prompts != NULL)
-		off += cmd_prarg(buf + off, len - off, " -p ", data->prompts);
-	if (off < len && data->target != NULL)
-		off += cmd_prarg(buf + off, len - off, " -t ", data->target);
-	if (off < len && data->template != NULL)
-		off += cmd_prarg(buf + off, len - off, " ", data->template);
-	return (off);
-}
-
 int
 cmd_command_prompt_callback(void *data, const char *s)
 {
@@ -210,24 +150,31 @@ cmd_command_prompt_callback(void *data, const char *s)
 	struct client			*c = cdata->c;
 	struct cmd_list			*cmdlist;
 	struct cmd_ctx			 ctx;
-	char				*cause, *newtempl, *prompt, *ptr;
+	char				*cause, *new_template, *prompt, *ptr;
+	char				*input = NULL;
 
 	if (s == NULL)
 		return (0);
 
-	newtempl = cmd_template_replace(cdata->template, s, cdata->idx);
+	new_template = cmd_template_replace(cdata->template, s, cdata->idx);
 	xfree(cdata->template);
-	cdata->template = newtempl;
+	cdata->template = new_template;
 
+	/*
+	 * Check if there are more prompts; if so, get its respective input
+	 * and update the prompt data.
+	 */
 	if ((ptr = strsep(&cdata->next_prompt, ",")) != NULL) {
 		xasprintf(&prompt, "%s ", ptr);
-		status_prompt_update(c, prompt);
+		input = strsep(&cdata->next_input, ",");
+		status_prompt_update(c, prompt, input);
+
 		xfree(prompt);
 		cdata->idx++;
 		return (1);
 	}
 
-	if (cmd_string_parse(newtempl, &cmdlist, &cause) != 0) {
+	if (cmd_string_parse(new_template, &cmdlist, &cause) != 0) {
 		if (cause != NULL) {
 			*cause = toupper((u_char) *cause);
 			status_message_set(c, "%s", cause);
@@ -254,10 +201,12 @@ cmd_command_prompt_callback(void *data, const char *s)
 }
 
 void
-cmd_command_prompt_cfree(void *data)
+cmd_command_prompt_free(void *data)
 {
 	struct cmd_command_prompt_cdata	*cdata = data;
 
+	if (cdata->inputs != NULL)
+		xfree(cdata->inputs);
 	if (cdata->prompts != NULL)
 		xfree(cdata->prompts);
 	if (cdata->template != NULL)

cmd-confirm-before.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-confirm-before.c,v 1.12 2009-11-14 17:56:39 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -25,21 +25,20 @@
  * Asks for confirmation before executing a command.
  */
 
+void	cmd_confirm_before_key_binding(struct cmd *, int);
 int	cmd_confirm_before_exec(struct cmd *, struct cmd_ctx *);
-void	cmd_confirm_before_init(struct cmd *, int);
 
 int	cmd_confirm_before_callback(void *, const char *);
 void	cmd_confirm_before_free(void *);
 
 const struct cmd_entry cmd_confirm_before_entry = {
 	"confirm-before", "confirm",
-	CMD_TARGET_CLIENT_USAGE " command",
+	"p:t:", 1, 1,
-	CMD_ARG1, "",
+	"[-p prompt] " CMD_TARGET_CLIENT_USAGE " command",
-	cmd_confirm_before_init,
+	0,
-	cmd_target_parse,
+	cmd_confirm_before_key_binding,
-	cmd_confirm_before_exec,
+	NULL,
-	cmd_target_free,
+	cmd_confirm_before_exec
-	cmd_target_print
 };
 
 struct cmd_confirm_before_data {
@@ -48,19 +47,19 @@ struct cmd_confirm_before_data {
 };
 
 void
-cmd_confirm_before_init(struct cmd *self, int key)
+cmd_confirm_before_key_binding(struct cmd *self, int key)
 {
-	struct cmd_target_data	*data;
-
-	cmd_target_init(self, key);
-	data = self->data;
-
 	switch (key) {
 	case '&':
-		data->arg = xstrdup("kill-window");
+		self->args = args_create(1, "kill-window");
+		args_set(self->args, 'p', "kill-window #W? (y/n)");
 		break;
 	case 'x':
-		data->arg = xstrdup("kill-pane");
+		self->args = args_create(1, "kill-pane");
+		args_set(self->args, 'p', "kill-pane #P? (y/n)");
+		break;
+	default:
+		self->args = args_create(0);
 		break;
 	}
 }
@@ -68,33 +67,37 @@ cmd_confirm_before_init(struct cmd *self, int key)
 int
 cmd_confirm_before_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data		*data = self->data;
+	struct args			*args = self->args;
 	struct cmd_confirm_before_data	*cdata;
 	struct client			*c;
-	char				*buf, *cmd, *ptr;
+	char				*cmd, *copy, *new_prompt, *ptr;
+	const char			*prompt;
 
 	if (ctx->curclient == NULL) {
 		ctx->error(ctx, "must be run interactively");
 		return (-1);
 	}
 
-	if ((c = cmd_find_client(ctx, data->target)) == NULL)
+	if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
 		return (-1);
 
-	ptr = xstrdup(data->arg);
+	if ((prompt = args_get(args, 'p')) != NULL)
-	if ((cmd = strtok(ptr, " \t")) == NULL)
+		xasprintf(&new_prompt, "%s ", prompt);
-		cmd = ptr;
+	else {
-	xasprintf(&buf, "Confirm '%s'? (y/n) ", cmd);
+		ptr = copy = xstrdup(args->argv[0]);
-	xfree(ptr);
+		cmd = strsep(&ptr, " \t");
+		xasprintf(&new_prompt, "Confirm '%s'? (y/n) ", cmd);
+		xfree(copy);
+	}
 
 	cdata = xmalloc(sizeof *cdata);
-	cdata->cmd = xstrdup(data->arg);
+	cdata->cmd = xstrdup(args->argv[0]);
 	cdata->c = c;
-	status_prompt_set(cdata->c, buf,
+	status_prompt_set(cdata->c, new_prompt, NULL,
 	    cmd_confirm_before_callback, cmd_confirm_before_free, cdata,
 	    PROMPT_SINGLE);
 
-	xfree(buf);
+	xfree(new_prompt);
 	return (1);
 }
 

cmd-copy-buffer.c

@@ -1,205 +0,0 @@
-/* $Id: cmd-copy-buffer.c,v 1.7 2009-11-28 14:50:36 tcunha Exp $ */
-
-/*
- * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
- * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include <sys/types.h>
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "tmux.h"
-
-/*
- * Copies a session paste buffer to another session.
- */
-
-int	cmd_copy_buffer_parse(struct cmd *, int, char **, char **);
-int	cmd_copy_buffer_exec(struct cmd *, struct cmd_ctx *);
-void	cmd_copy_buffer_free(struct cmd *);
-void	cmd_copy_buffer_init(struct cmd *, int);
-size_t	cmd_copy_buffer_print(struct cmd *, char *, size_t);
-
-struct cmd_copy_buffer_data {
-	char	*dst_session;
-	char	*src_session;
-	int	 dst_idx;
-	int	 src_idx;
-};
-
-const struct cmd_entry cmd_copy_buffer_entry = {
-	"copy-buffer", "copyb",
-	"[-a src-index] [-b dst-index] [-s src-session] [-t dst-session]",
-	0, "",
-	cmd_copy_buffer_init,
-	cmd_copy_buffer_parse,
-	cmd_copy_buffer_exec,
-	cmd_copy_buffer_free,
-	cmd_copy_buffer_print
-};
-
-/* ARGSUSED */
-void
-cmd_copy_buffer_init(struct cmd *self, unused int arg)
-{
-	struct cmd_copy_buffer_data	*data;
-
-	self->data = data = xmalloc(sizeof *data);
-	data->dst_session = NULL;
-	data->src_session = NULL;
-	data->dst_idx = -1;
-	data->src_idx = -1;
-}
-
-int
-cmd_copy_buffer_parse(struct cmd *self, int argc, char **argv, char **cause)
-{
-	struct cmd_copy_buffer_data	*data;
-	const char			*errstr;
-	int				 n, opt;
-
-	self->entry->init(self, KEYC_NONE);
-	data = self->data;
-
-	while ((opt = getopt(argc, argv, "a:b:s:t:")) != -1) {
-		switch (opt) {
-		case 'a':
-			if (data->src_idx == -1) {
-				n = strtonum(optarg, 0, INT_MAX, &errstr);
-				if (errstr != NULL) {
-					xasprintf(cause, "buffer %s", errstr);
-					goto error;
-				}
-				data->src_idx = n;
-			}
-			break;
-		case 'b':
-			if (data->dst_idx == -1) {
-				n = strtonum(optarg, 0, INT_MAX, &errstr);
-				if (errstr != NULL) {
-					xasprintf(cause, "buffer %s", errstr);
-					goto error;
-				}
-				data->dst_idx = n;
-			}
-			break;
-		case 's':
-			if (data->src_session == NULL)
-				data->src_session = xstrdup(optarg);
-			break;
-		case 't':
-			if (data->dst_session == NULL)
-				data->dst_session = xstrdup(optarg);
-			break;
-		default:
-			goto usage;
-		}
-	}
-	argc -= optind;
-	argv += optind;
-
-	return (0);
-
-usage:
-	xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
-
-error:
-	self->entry->free(self);
-	return (-1);
-}
-
-int
-cmd_copy_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
-{
-	struct cmd_copy_buffer_data	*data = self->data;
-	struct paste_buffer		*pb;
-	struct paste_stack		*dst_ps, *src_ps;
-	u_char				*pdata;
-	struct session			*dst_session, *src_session;
-	u_int				 limit;
-
-	if ((dst_session = cmd_find_session(ctx, data->dst_session)) == NULL ||
-	    (src_session = cmd_find_session(ctx, data->src_session)) == NULL)
-	    	return (-1);
-	dst_ps = &dst_session->buffers;
-	src_ps = &src_session->buffers;
-
-	if (data->src_idx == -1) {
-		if ((pb = paste_get_top(src_ps)) == NULL) {
-			ctx->error(ctx, "no buffers");
-			return (-1);
-		}
-	} else {
-		if ((pb = paste_get_index(src_ps, data->src_idx)) == NULL) {
-		    	ctx->error(ctx, "no buffer %d", data->src_idx);
-		    	return (-1);
-		}
-	}
-	limit = options_get_number(&dst_session->options, "buffer-limit");
-
-	pdata = xmalloc(pb->size);
-	memcpy(pdata, pb->data, pb->size);
-
-	if (data->dst_idx == -1)
-		paste_add(dst_ps, pdata, pb->size, limit);
-	else if (paste_replace(dst_ps, data->dst_idx, pdata, pb->size) != 0) {
-		ctx->error(ctx, "no buffer %d", data->dst_idx);
-		xfree(pdata);
-		return (-1);
-	}
-
-	return (0);
-}
-
-void
-cmd_copy_buffer_free(struct cmd *self)
-{
-	struct cmd_copy_buffer_data	*data = self->data;
-
-	if (data->dst_session != NULL)
-		xfree(data->dst_session);
-	if (data->src_session != NULL)
-		xfree(data->src_session);
-	xfree(data);
-}
-
-size_t
-cmd_copy_buffer_print(struct cmd *self, char *buf, size_t len)
-{
-	struct cmd_copy_buffer_data	*data = self->data;
-	size_t				off = 0;
-
-	off += xsnprintf(buf, len, "%s", self->entry->name);
-	if (data == NULL)
-		return (off);
-	if (off < len && data->src_idx != -1) {
-		off += xsnprintf(buf + off, len - off, " -a %d",
-				 data->src_idx);
-	}
-	if (off < len && data->dst_idx != -1) {
-		off += xsnprintf(buf + off, len - off, " -b %d",
-				 data->dst_idx);
-	}
-	if (off < len && data->src_session != NULL) {
-		off += cmd_prarg(buf + off, len - off, " -s ",
-				 data->src_session);
-	}
-	if (off < len && data->dst_session != NULL) {
-		off += cmd_prarg(buf + off, len - off, " -t ",
-				 data->dst_session);
-	}
-	return (off);
-}

cmd-copy-mode.c

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

cmd-delete-buffer.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-delete-buffer.c,v 1.8 2009-11-14 17:56:39 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -30,28 +30,35 @@ int	cmd_delete_buffer_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_delete_buffer_entry = {
 	"delete-buffer", "deleteb",
-	CMD_BUFFER_SESSION_USAGE,
+	"b:", 0, 0,
-	0, "",
+	CMD_BUFFER_USAGE,
-	cmd_buffer_init,
+	0,
-	cmd_buffer_parse,
+	NULL,
-	cmd_delete_buffer_exec,
+	NULL,
-	cmd_buffer_free,
+	cmd_delete_buffer_exec
-	cmd_buffer_print
 };
 
 int
 cmd_delete_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_buffer_data	*data = self->data;
+	struct args	*args = self->args;
-	struct session		*s;
+	char		*cause;
+	int		 buffer;
 
-	if ((s = cmd_find_session(ctx, data->target)) == NULL)
+	if (!args_has(args, 'b')) {
+		paste_free_top(&global_buffers);
+		return (0);
+	}
+
+	buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
+	if (cause != NULL) {
+		ctx->error(ctx, "buffer %s", cause);
+		xfree(cause);
 		return (-1);
+	}
 
-	if (data->buffer == -1)
+	if (paste_free_index(&global_buffers, buffer) != 0) {
-		paste_free_top(&s->buffers);
+		ctx->error(ctx, "no buffer %d", buffer);
-	else if (paste_free_index(&s->buffers, data->buffer) != 0) {
-		ctx->error(ctx, "no buffer %d", data->buffer);
 		return (-1);
 	}
 

cmd-detach-client.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-detach-client.c,v 1.11 2010-02-08 18:27:34 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -28,25 +28,45 @@ int	cmd_detach_client_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_detach_client_entry = {
 	"detach-client", "detach",
-	CMD_TARGET_CLIENT_USAGE,
+	"s:t:P", 0, 0,
-	CMD_READONLY, "",
+	"[-P] [-s target-session] " CMD_TARGET_CLIENT_USAGE,
-	cmd_target_init,
+	CMD_READONLY,
-	cmd_target_parse,
+	NULL,
-	cmd_detach_client_exec,
+	NULL,
-	cmd_target_free,
+	cmd_detach_client_exec
-	cmd_target_print
 };
 
 int
 cmd_detach_client_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data	*data = self->data;
+	struct args	*args = self->args;
-	struct client		*c;
+	struct client	*c;
+	struct session 	*s;
+	enum msgtype     msgtype;
+	u_int 		 i;
 
-	if ((c = cmd_find_client(ctx, data->target)) == NULL)
+	if (args_has(args, 'P'))
-		return (-1);
+		msgtype = MSG_DETACHKILL;
+	else
+		msgtype = MSG_DETACH;
 
-	server_write_client(c, MSG_DETACH, NULL, 0);
+	if (args_has(args, 's')) {
+		s = cmd_find_session(ctx, args_get(args, 's'), 0);
+		if (s == NULL)
+			return (-1);
+
+		for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
+			c = ARRAY_ITEM(&clients, i);
+			if (c != NULL && c->session == s)
+				server_write_client(c, msgtype, NULL, 0);
+		}
+	} else {
+		c = cmd_find_client(ctx, args_get(args, 't'));
+		if (c == NULL)
+			return (-1);
+
+		server_write_client(c, msgtype, NULL, 0);
+	}
 
 	return (0);
 }

cmd-display-message.c

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

cmd-display-panes.c

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

cmd-down-pane.c

@@ -1,60 +0,0 @@
-/* $Id: cmd-down-pane.c,v 1.14 2010-01-05 23:52:37 tcunha Exp $ */
-
-/*
- * Copyright (c) 2009 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 "tmux.h"
-
-/*
- * Move down a pane.
- */
-
-int	cmd_down_pane_exec(struct cmd *, struct cmd_ctx *);
-
-const struct cmd_entry cmd_down_pane_entry = {
-	"down-pane", "downp",
-	CMD_TARGET_WINDOW_USAGE,
-	0, "",
-	cmd_target_init,
-	cmd_target_parse,
-	cmd_down_pane_exec,
-	cmd_target_free,
-	cmd_target_print
-};
-
-int
-cmd_down_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
-{
-	struct cmd_target_data	*data = self->data;
-	struct winlink		*wl;
-	struct window		*w;
-
-	if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
-		return (-1);
-	w = wl->window;
-
-	do {
-		w->active = TAILQ_NEXT(w->active, entry);
-		if (w->active == NULL)
-			w->active = TAILQ_FIRST(&w->panes);
-	} while (!window_pane_visible(w->active));
-	server_status_window(wl->window);
-	server_redraw_window_borders(wl->window);
-
-	return (0);
-}

cmd-find-window.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-find-window.c,v 1.14 2009-11-14 17:56:39 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -30,26 +30,26 @@
 int	cmd_find_window_exec(struct cmd *, struct cmd_ctx *);
 
 void	cmd_find_window_callback(void *, int);
+void	cmd_find_window_free(void *);
 
 const struct cmd_entry cmd_find_window_entry = {
 	"find-window", "findw",
+	"t:", 1, 1,
 	CMD_TARGET_WINDOW_USAGE " match-string",
-	CMD_ARG1, "",
+	0,
-	cmd_target_init,
+	NULL,
-	cmd_target_parse,
+	NULL,
-	cmd_find_window_exec,
+	cmd_find_window_exec
-	cmd_target_free,
-	cmd_target_print
 };
 
 struct cmd_find_window_data {
-	u_int	session;
+	struct session	*session;
 };
 
 int
 cmd_find_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data		*data = self->data;
+	struct args			*args = self->args;
 	struct cmd_find_window_data	*cdata;
 	struct session			*s;
 	struct winlink			*wl, *wm;
@@ -57,7 +57,7 @@ cmd_find_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 	struct window_pane		*wp;
 	ARRAY_DECL(, u_int)	 	 list_idx;
 	ARRAY_DECL(, char *)	 	 list_ctx;
-	char				*sres, *sctx, *searchstr;
+	char				*str, *sres, *sctx, *searchstr;
 	u_int				 i, line;
 
 	if (ctx->curclient == NULL) {
@@ -66,13 +66,15 @@ cmd_find_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 	}
 	s = ctx->curclient->session;
 
-	if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
+	if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
 		return (-1);
 
+	str = args->argv[0];
+
 	ARRAY_INIT(&list_idx);
 	ARRAY_INIT(&list_ctx);
 
-	xasprintf(&searchstr, "*%s*", data->arg);
+	xasprintf(&searchstr, "*%s*", str);
 	RB_FOREACH(wm, winlinks, &s->windows) {
 		i = 0;
 		TAILQ_FOREACH(wp, &wm->window->panes, entry) {
@@ -81,7 +83,7 @@ cmd_find_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 			if (fnmatch(searchstr, wm->window->name, 0) == 0)
 				sctx = xstrdup("");
 			else {
-				sres = window_pane_search(wp, data->arg, &line);
+				sres = window_pane_search(wp, str, &line);
 				if (sres == NULL &&
 				    fnmatch(searchstr, wp->base.title, 0) != 0)
 					continue;
@@ -105,7 +107,7 @@ cmd_find_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 	xfree(searchstr);
 
 	if (ARRAY_LENGTH(&list_idx) == 0) {
-		ctx->error(ctx, "no windows matching: %s", data->arg);
+		ctx->error(ctx, "no windows matching: %s", str);
 		ARRAY_FREE(&list_idx);
 		ARRAY_FREE(&list_ctx);
 		return (-1);
@@ -134,11 +136,11 @@ cmd_find_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 	}
 
 	cdata = xmalloc(sizeof *cdata);
-	if (session_index(s, &cdata->session) != 0)
+	cdata->session = s;
-		fatalx("session not found");
+	cdata->session->references++;
 
-	window_choose_ready(
+	window_choose_ready(wl->window->active,
-	    wl->window->active, 0, cmd_find_window_callback, xfree, cdata);
+	    0, cmd_find_window_callback, cmd_find_window_free, cdata);
 
 out:
 	ARRAY_FREE(&list_idx);
@@ -151,12 +153,24 @@ void
 cmd_find_window_callback(void *data, int idx)
 {
 	struct cmd_find_window_data	*cdata = data;
-	struct session			*s;
+	struct session			*s = cdata->session;
 
-	if (idx != -1 && cdata->session <= ARRAY_LENGTH(&sessions) - 1) {
+	if (idx == -1)
-		s = ARRAY_ITEM(&sessions, cdata->session);
+		return;
-		if (s != NULL && session_select(s, idx) == 0)
+	if (!session_alive(s))
-			server_redraw_session(s);
+		return;
+
+	if (session_select(s, idx) == 0) {
+		server_redraw_session(s);
 		recalculate_sizes();
 	}
 }
+
+void
+cmd_find_window_free(void *data)
+{
+	struct cmd_find_window_data	*cdata = data;
+
+	cdata->session->references--;
+	xfree(cdata);
+}

cmd-generic.c

@@ -1,423 +0,0 @@
-/* $Id: cmd-generic.c,v 1.38 2009-12-04 22:14:47 tcunha Exp $ */
-
-/*
- * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
- * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include <sys/types.h>
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "tmux.h"
-
-int	cmd_getopt(int, char **, const char *, const char *);
-int	cmd_parse_flags(int, const char *, uint64_t *);
-size_t	cmd_print_flags(char *, size_t, size_t, uint64_t);
-int	cmd_fill_argument(int, char **, char **, int, char **);
-
-size_t
-cmd_prarg(char *buf, size_t len, const char *prefix, char *arg)
-{
-	if (strchr(arg, ' ') != NULL)
-		return (xsnprintf(buf, len, "%s\"%s\"", prefix, arg));
-	return (xsnprintf(buf, len, "%s%s", prefix, arg));
-}
-
-/* Append two flag strings together and call getopt. */
-int
-cmd_getopt(int argc, char **argv, const char *flagstr, const char *chflagstr)
-{
-	char	tmp[BUFSIZ];
-
-	if (strlcpy(tmp, flagstr, sizeof tmp) >= sizeof tmp)
-		fatalx("strlcpy overflow");
-	if (strlcat(tmp, chflagstr, sizeof tmp) >= sizeof tmp)
-		fatalx("strlcat overflow");
-	return (getopt(argc, argv, tmp));
-}
-
-/* Return if flag character is set. */
-int
-cmd_check_flag(uint64_t chflags, int flag)
-{
-	if (flag >= 'A' && flag <= 'Z')
-		flag = 26 + flag - 'A';
-	else if (flag >= 'a' && flag <= 'z')
-		flag = flag - 'a';
-	else
-		return (0);
-	return ((chflags & (1ULL << flag)) != 0);
-}
-
-/* Set flag character. */
-void
-cmd_set_flag(uint64_t *chflags, int flag)
-{
-	if (flag >= 'A' && flag <= 'Z')
-		flag = 26 + flag - 'A';
-	else if (flag >= 'a' && flag <= 'z')
-		flag = flag - 'a';
-	else
-		return;
-	(*chflags) |= (1ULL << flag);
-}
-
-/* If this option is expected, set it in chflags, otherwise return -1. */
-int
-cmd_parse_flags(int opt, const char *chflagstr, uint64_t *chflags)
-{
-	if (strchr(chflagstr, opt) == NULL)
-		return (-1);
-	cmd_set_flag(chflags, opt);
-	return (0);
-}
-
-/* Print the flags present in chflags. */
-size_t
-cmd_print_flags(char *buf, size_t len, size_t off, uint64_t chflags)
-{
-	u_char	ch;
-	size_t	boff = off;
-
-	if (chflags == 0)
-		return (0);
-	off += xsnprintf(buf + off, len - off, " -");
-
-	for (ch = 0; ch < 26; ch++) {
-		if (cmd_check_flag(chflags, 'a' + ch))
-			off += xsnprintf(buf + off, len - off, "%c", 'a' + ch);
-		if (cmd_check_flag(chflags, 'A' + ch))
-			off += xsnprintf(buf + off, len - off, "%c", 'A' + ch);
-	}
-	return (off - boff);
-}
-
-int
-cmd_fill_argument(int flags, char **arg, char **arg2, int argc, char **argv)
-{
-	*arg = NULL;
-	*arg2 = NULL;
-
-	if (flags & CMD_ARG1) {
-		if (argc != 1)
-			return (-1);
-		*arg = xstrdup(argv[0]);
-		return (0);
-	}
-
-	if (flags & CMD_ARG01) {
-		if (argc != 0 && argc != 1)
-			return (-1);
-		if (argc == 1)
-			*arg = xstrdup(argv[0]);
-		return (0);
-	}
-
-	if (flags & CMD_ARG2) {
-		if (argc != 2)
-			return (-1);
-		*arg = xstrdup(argv[0]);
-		*arg2 = xstrdup(argv[1]);
-		return (0);
-	}
-
-	if (flags & CMD_ARG12) {
-		if (argc != 1 && argc != 2)
-			return (-1);
-		*arg = xstrdup(argv[0]);
-		if (argc == 2)
-			*arg2 = xstrdup(argv[1]);
-		return (0);
-	}
-
-	if (argc != 0)
-		return (-1);
-	return (0);
-}
-
-/* ARGSUSED */
-void
-cmd_target_init(struct cmd *self, unused int key)
-{
-	struct cmd_target_data	*data;
-
-	self->data = data = xmalloc(sizeof *data);
-	data->chflags = 0;
-	data->target = NULL;
-	data->arg = NULL;
-	data->arg2 = NULL;
-}
-
-int
-cmd_target_parse(struct cmd *self, int argc, char **argv, char **cause)
-{
-	struct cmd_target_data	*data;
-	const struct cmd_entry	*entry = self->entry;
-	int			 opt;
-
-	/* Don't use the entry version since it may be dependent on key. */
-	cmd_target_init(self, 0);
-	data = self->data;
-
-	while ((opt = cmd_getopt(argc, argv, "t:", entry->chflags)) != -1) {
-		if (cmd_parse_flags(opt, entry->chflags, &data->chflags) == 0)
-			continue;
-		switch (opt) {
-		case 't':
-			if (data->target == NULL)
-				data->target = xstrdup(optarg);
-			break;
-		default:
-			goto usage;
-		}
-	}
-	argc -= optind;
-	argv += optind;
-
-	if (cmd_fill_argument(
-	    self->entry->flags, &data->arg, &data->arg2, argc, argv) != 0)
-		goto usage;
-	return (0);
-
-usage:
-	xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
-
-	self->entry->free(self);
-	return (-1);
-}
-
-void
-cmd_target_free(struct cmd *self)
-{
-	struct cmd_target_data	*data = self->data;
-
-	if (data->target != NULL)
-		xfree(data->target);
-	if (data->arg != NULL)
-		xfree(data->arg);
-	if (data->arg2 != NULL)
-		xfree(data->arg2);
-	xfree(data);
-}
-
-size_t
-cmd_target_print(struct cmd *self, char *buf, size_t len)
-{
-	struct cmd_target_data	*data = self->data;
-	size_t			 off = 0;
-
-	off += xsnprintf(buf, len, "%s", self->entry->name);
-	if (data == NULL)
-		return (off);
-	off += cmd_print_flags(buf, len, off, data->chflags);
-	if (off < len && data->target != NULL)
-		off += cmd_prarg(buf + off, len - off, " -t ", data->target);
-	if (off < len && data->arg != NULL)
-		off += cmd_prarg(buf + off, len - off, " ", data->arg);
-	if (off < len && data->arg2 != NULL)
-		off += cmd_prarg(buf + off, len - off, " ", data->arg2);
-	return (off);
-}
-
-/* ARGSUSED */
-void
-cmd_srcdst_init(struct cmd *self, unused int key)
-{
-	struct cmd_srcdst_data	*data;
-
-	self->data = data = xmalloc(sizeof *data);
-	data->chflags = 0;
-	data->src = NULL;
-	data->dst = NULL;
-	data->arg = NULL;
-	data->arg2 = NULL;
-}
-
-int
-cmd_srcdst_parse(struct cmd *self, int argc, char **argv, char **cause)
-{
-	struct cmd_srcdst_data	*data;
-	const struct cmd_entry	*entry = self->entry;
-	int			 opt;
-
-	cmd_srcdst_init(self, 0);
-	data = self->data;
-
-	while ((opt = cmd_getopt(argc, argv, "s:t:", entry->chflags)) != -1) {
-		if (cmd_parse_flags(opt, entry->chflags, &data->chflags) == 0)
-			continue;
-		switch (opt) {
-		case 's':
-			if (data->src == NULL)
-				data->src = xstrdup(optarg);
-			break;
-		case 't':
-			if (data->dst == NULL)
-				data->dst = xstrdup(optarg);
-			break;
-		default:
-			goto usage;
-		}
-	}
-	argc -= optind;
-	argv += optind;
-
-	if (cmd_fill_argument(
-	    self->entry->flags, &data->arg, &data->arg2, argc, argv) != 0)
-		goto usage;
-	return (0);
-
-usage:
-	xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
-
-	self->entry->free(self);
-	return (-1);
-}
-
-void
-cmd_srcdst_free(struct cmd *self)
-{
-	struct cmd_srcdst_data	*data = self->data;
-
-	if (data->src != NULL)
-		xfree(data->src);
-	if (data->dst != NULL)
-		xfree(data->dst);
-	if (data->arg != NULL)
-		xfree(data->arg);
-	if (data->arg2 != NULL)
-		xfree(data->arg2);
-	xfree(data);
-}
-
-size_t
-cmd_srcdst_print(struct cmd *self, char *buf, size_t len)
-{
-	struct cmd_srcdst_data	*data = self->data;
-	size_t			 off = 0;
-
-	off += xsnprintf(buf, len, "%s", self->entry->name);
-	if (data == NULL)
-		return (off);
-	off += cmd_print_flags(buf, len, off, data->chflags);
-	if (off < len && data->src != NULL)
-		off += xsnprintf(buf + off, len - off, " -s %s", data->src);
-	if (off < len && data->dst != NULL)
-		off += xsnprintf(buf + off, len - off, " -t %s", data->dst);
-	if (off < len && data->arg != NULL)
-		off += cmd_prarg(buf + off, len - off, " ", data->arg);
-	if (off < len && data->arg2 != NULL)
-		off += cmd_prarg(buf + off, len - off, " ", data->arg2);
-	return (off);
-}
-
-/* ARGSUSED */
-void
-cmd_buffer_init(struct cmd *self, unused int key)
-{
-	struct cmd_buffer_data	*data;
-
-	self->data = data = xmalloc(sizeof *data);
-	data->chflags = 0;
-	data->target = NULL;
-	data->buffer = -1;
-	data->arg = NULL;
-	data->arg2 = NULL;
-}
-
-int
-cmd_buffer_parse(struct cmd *self, int argc, char **argv, char **cause)
-{
-	struct cmd_buffer_data	*data;
-	const struct cmd_entry	*entry = self->entry;
-	int			 opt, n;
-	const char		*errstr;
-
-	cmd_buffer_init(self, 0);
-	data = self->data;
-
-	while ((opt = cmd_getopt(argc, argv, "b:t:", entry->chflags)) != -1) {
-		if (cmd_parse_flags(opt, entry->chflags, &data->chflags) == 0)
-			continue;
-		switch (opt) {
-		case 'b':
-			if (data->buffer == -1) {
-				n = strtonum(optarg, 0, INT_MAX, &errstr);
-				if (errstr != NULL) {
-					xasprintf(cause, "buffer %s", errstr);
-					goto error;
-				}
-				data->buffer = n;
-			}
-			break;
-		case 't':
-			if (data->target == NULL)
-				data->target = xstrdup(optarg);
-			break;
-		default:
-			goto usage;
-		}
-	}
-	argc -= optind;
-	argv += optind;
-
-	if (cmd_fill_argument(
-	    self->entry->flags, &data->arg, &data->arg2, argc, argv) != 0)
-		goto usage;
-	return (0);
-
-usage:
-	xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
-
-error:
-	self->entry->free(self);
-	return (-1);
-}
-
-void
-cmd_buffer_free(struct cmd *self)
-{
-	struct cmd_buffer_data	*data = self->data;
-
-	if (data->target != NULL)
-		xfree(data->target);
-	if (data->arg != NULL)
-		xfree(data->arg);
-	if (data->arg2 != NULL)
-		xfree(data->arg2);
-	xfree(data);
-}
-
-size_t
-cmd_buffer_print(struct cmd *self, char *buf, size_t len)
-{
-	struct cmd_buffer_data	*data = self->data;
-	size_t			 off = 0;
-
-	off += xsnprintf(buf, len, "%s", self->entry->name);
-	if (data == NULL)
-		return (off);
-	off += cmd_print_flags(buf, len, off, data->chflags);
-	if (off < len && data->buffer != -1)
-		off += xsnprintf(buf + off, len - off, " -b %d", data->buffer);
-	if (off < len && data->target != NULL)
-		off += cmd_prarg(buf + off, len - off, " -t ", data->target);
-	if (off < len && data->arg != NULL)
-		off += cmd_prarg(buf + off, len - off, " ", data->arg);
-	if (off < len && data->arg2 != NULL)
-		off += cmd_prarg(buf + off, len - off, " ", data->arg2);
-	return (off);
-}

cmd-has-session.c

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

cmd-if-shell.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-if-shell.c,v 1.8 2009-11-14 17:56:39 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -25,7 +25,7 @@
 #include "tmux.h"
 
 /*
- * Executes a tmux command if a shell command returns true.
+ * Executes a tmux command if a shell command returns true or false.
  */
 
 int	cmd_if_shell_exec(struct cmd *, struct cmd_ctx *);
@@ -35,29 +35,33 @@ void	cmd_if_shell_free(void *);
 
 const struct cmd_entry cmd_if_shell_entry = {
 	"if-shell", "if",
-	"shell-command command",
+	"", 2, 3,
-	CMD_ARG2, "",
+	"shell-command command [command]",
-	cmd_target_init,
+	0,
-	cmd_target_parse,
+	NULL,
-	cmd_if_shell_exec,
+	NULL,
-	cmd_target_free,
+	cmd_if_shell_exec
-	cmd_target_print
 };
 
 struct cmd_if_shell_data {
-	char		*cmd;
+	char		*cmd_if;
+	char		*cmd_else;
 	struct cmd_ctx	 ctx;
 };
 
 int
 cmd_if_shell_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data		*data = self->data;
+	struct args			*args = self->args;
 	struct cmd_if_shell_data	*cdata;
-	struct job			*job;
+	const char			*shellcmd = args->argv[0];
 
 	cdata = xmalloc(sizeof *cdata);
-	cdata->cmd = xstrdup(data->arg2);
+	cdata->cmd_if = xstrdup(args->argv[1]);
+	if (args->argc == 3)
+		cdata->cmd_else = xstrdup(args->argv[2]);
+	else
+		cdata->cmd_else = NULL;
 	memcpy(&cdata->ctx, ctx, sizeof cdata->ctx);
 
 	if (ctx->cmdclient != NULL)
@@ -65,9 +69,7 @@ cmd_if_shell_exec(struct cmd *self, struct cmd_ctx *ctx)
 	if (ctx->curclient != NULL)
 		ctx->curclient->references++;
 
-	job = job_add(NULL, 0, NULL,
+	job_run(shellcmd, cmd_if_shell_callback, cmd_if_shell_free, cdata);
-	    data->arg, cmd_if_shell_callback, cmd_if_shell_free, cdata);
-	job_run(job);
 
 	return (1);	/* don't let client exit */
 }
@@ -78,12 +80,15 @@ cmd_if_shell_callback(struct job *job)
 	struct cmd_if_shell_data	*cdata = job->data;
 	struct cmd_ctx			*ctx = &cdata->ctx;
 	struct cmd_list			*cmdlist;
-	char				*cause;
+	char				*cause, *cmd;
 
-	if (!WIFEXITED(job->status) || WEXITSTATUS(job->status) != 0)
+	if (!WIFEXITED(job->status) || WEXITSTATUS(job->status) != 0) {
-		return;
+		cmd = cdata->cmd_else;
-
+		if (cmd == NULL)
-	if (cmd_string_parse(cdata->cmd, &cmdlist, &cause) != 0) {
+			return;
+	} else
+		cmd = cdata->cmd_if;
+	if (cmd_string_parse(cmd, &cmdlist, &cause) != 0) {
 		if (cause != NULL) {
 			ctx->error(ctx, "%s", cause);
 			xfree(cause);
@@ -91,11 +96,7 @@ cmd_if_shell_callback(struct job *job)
 		return;
 	}
 
-	if (cmd_list_exec(cmdlist, ctx) < 0) {
+	cmd_list_exec(cmdlist, ctx);
-		cmd_list_free(cmdlist);
-		return;
-	}
-
 	cmd_list_free(cmdlist);
 }
 
@@ -104,14 +105,18 @@ cmd_if_shell_free(void *data)
 {
 	struct cmd_if_shell_data	*cdata = data;
 	struct cmd_ctx			*ctx = &cdata->ctx;
+	struct msg_exit_data		 exitdata;
 
 	if (ctx->cmdclient != NULL) {
 		ctx->cmdclient->references--;
-		server_write_client(ctx->cmdclient, MSG_EXIT, NULL, 0);
+		exitdata.retcode = ctx->cmdclient->retcode;
+		ctx->cmdclient->flags |= CLIENT_EXIT;
 	}
 	if (ctx->curclient != NULL)
 		ctx->curclient->references--;
 
-	xfree(cdata->cmd);
+	if (cdata->cmd_else != NULL)
+		xfree(cdata->cmd_else);
+	xfree(cdata->cmd_if);
 	xfree(cdata);
 }

cmd-join-pane.c

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

cmd-kill-pane.c

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

cmd-kill-server.c

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

cmd-kill-session.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-kill-session.c,v 1.17 2009-12-04 22:14:47 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -31,35 +31,24 @@ int	cmd_kill_session_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_kill_session_entry = {
 	"kill-session", NULL,
+	"t:", 0, 0,
 	CMD_TARGET_SESSION_USAGE,
-	0, "",
+	0,
-	cmd_target_init,
+	NULL,
-	cmd_target_parse,
+	NULL,
-	cmd_kill_session_exec,
+	cmd_kill_session_exec
-	cmd_target_free,
-	cmd_target_print
 };
 
 int
 cmd_kill_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data	*data = self->data;
+	struct args	*args = self->args;
-	struct session		*s;
+	struct session	*s;
-	struct client		*c;
-	u_int			 i;
 
-	if ((s = cmd_find_session(ctx, data->target)) == NULL)
+	if ((s = cmd_find_session(ctx, args_get(args, 't'), 0)) == NULL)
 		return (-1);
 
-	for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
+	server_destroy_session(s);
-		c = ARRAY_ITEM(&clients, i);
-		if (c != NULL && c->session == s) {
-			c->session = NULL;
-			server_write_client(c, MSG_EXIT, NULL, 0);
-		}
-	}
-	recalculate_sizes();
-
 	session_destroy(s);
 
 	return (0);

cmd-kill-window.c

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

cmd-last-window.c

@@ -1,58 +0,0 @@
-/* $Id: cmd-last-window.c,v 1.19 2009-11-14 17:56:39 tcunha Exp $ */
-
-/*
- * Copyright (c) 2007 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 "tmux.h"
-
-/*
- * Move to last window.
- */
-
-int	cmd_last_window_exec(struct cmd *, struct cmd_ctx *);
-
-const struct cmd_entry cmd_last_window_entry = {
-	"last-window", "last",
-	CMD_TARGET_SESSION_USAGE,
-	0, "",
-	cmd_target_init,
-	cmd_target_parse,
-	cmd_last_window_exec,
-	cmd_target_free,
-	cmd_target_print
-};
-
-int
-cmd_last_window_exec(struct cmd *self, struct cmd_ctx *ctx)
-{
-	struct cmd_target_data	*data = self->data;
-	struct session		*s;
-
-	if ((s = cmd_find_session(ctx, data->target)) == NULL)
-		return (-1);
-
-	if (session_last(s) == 0)
-		server_redraw_session(s);
-	else {
-		ctx->error(ctx, "no last window");
-		return (-1);
-	}
-	recalculate_sizes();
-
-	return (0);
-}

cmd-link-window.c

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

cmd-list-buffers.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-list-buffers.c,v 1.15 2009-12-04 22:14:47 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -30,48 +30,28 @@ int	cmd_list_buffers_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_list_buffers_entry = {
 	"list-buffers", "lsb",
-	CMD_TARGET_SESSION_USAGE,
+	"", 0, 0,
-	0, "",
+	"",
-	cmd_target_init,
+	0,
-	cmd_target_parse,
+	NULL,
-	cmd_list_buffers_exec,
+	NULL,
-	cmd_target_free,
+	cmd_list_buffers_exec
-	cmd_target_print
 };
 
+/* ARGSUSED */
 int
-cmd_list_buffers_exec(struct cmd *self, struct cmd_ctx *ctx)
+cmd_list_buffers_exec(unused struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data	*data = self->data;
-	struct session		*s;
 	struct paste_buffer	*pb;
 	u_int			 idx;
-	char			 tmp[51 * 4 + 1];
+	char			*tmp;
-	size_t			 size, len;
-
-	if ((s = cmd_find_session(ctx, data->target)) == NULL)
-		return (-1);
 
 	idx = 0;
-	while ((pb = paste_walk_stack(&s->buffers, &idx)) != NULL) {
+	while ((pb = paste_walk_stack(&global_buffers, &idx)) != NULL) {
-		size = pb->size;
+		tmp = paste_print(pb, 50);
-
+		ctx->print(ctx,
-		/* Translate the first 50 characters. */
+		    "%u: %zu bytes: \"%s\"", idx - 1, pb->size, tmp);
-		len = size;
+		xfree(tmp);
-		if (len > 50)
-			len = 50;
-		strvisx(tmp, pb->data, len, VIS_OCTAL|VIS_TAB|VIS_NL);
-
-		/*
-		 * If the first 50 characters were encoded as a longer string,
-		 * or there is definitely more data, add "...".
-		 */
-		if (size > 50 || strlen(tmp) > 50) {
-			tmp[50 - 3] = '\0';
-			strlcat(tmp, "...", sizeof tmp);
-		}
-
-		ctx->print(ctx, "%u: %zu bytes: \"%s\"", idx - 1, size, tmp);
 	}
 
 	return (0);

cmd-list-clients.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-list-clients.c,v 1.20 2009-11-28 14:50:36 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -31,35 +31,59 @@ int	cmd_list_clients_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_list_clients_entry = {
 	"list-clients", "lsc",
-	"",
+	"F:t:", 0, 0,
-	0, "",
+	"[-F format] " CMD_TARGET_SESSION_USAGE,
+	CMD_READONLY,
 	NULL,
 	NULL,
-	cmd_list_clients_exec,
+	cmd_list_clients_exec
-	NULL,
-	NULL
 };
 
 /* ARGSUSED */
 int
-cmd_list_clients_exec(unused struct cmd *self, struct cmd_ctx *ctx)
+cmd_list_clients_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct client	*c;
+	struct args 		*args = self->args;
-	u_int		 i;
+	struct client		*c;
-	const char	*s_utf8;
+	struct session		*s;
+	struct format_tree	*ft;
+	const char		*template;
+	u_int			 i;
+	char			*line;
+
+	if (args_has(args, 't')) {
+		s = cmd_find_session(ctx, args_get(args, 't'), 0);
+		if (s == NULL)
+			return (-1);
+	} else
+		s = NULL;
+
+	template = args_get(args, 'F');
+	if (template == NULL) {
+		template = "#{client_tty}: #{session_name} "
+		    "[#{client_width}x#{client_height} #{client_termname}]"
+		    "#{?client_utf8, (utf8),}"
+		    "#{?client_readonly, (ro),}";
+	}
 
 	for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
 		c = ARRAY_ITEM(&clients, i);
 		if (c == NULL || c->session == NULL)
 			continue;
 
-		if (c->tty.flags & TTY_UTF8)
+		if (s != NULL && s != c->session)
-			s_utf8 = " (utf8)";
+			continue;
-		else
+
-			s_utf8 = "";
+		ft = format_create();
-		ctx->print(ctx, "%s: %s [%ux%u %s]%s", c->tty.path,
+		format_add(ft, "line", "%u", i);
-		    c->session->name, c->tty.sx, c->tty.sy,
+		format_session(ft, c->session);
-		    c->tty.termname, s_utf8);
+		format_client(ft, c);
+
+		line = format_expand(ft, template);
+		ctx->print(ctx, "%s", line);
+		xfree(line);
+
+		format_free(ft);
 	}
 
 	return (0);

cmd-list-commands.c

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

cmd-list-keys.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-list-keys.c,v 1.24 2009-12-04 22:14:47 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -32,56 +32,67 @@ int	cmd_list_keys_table(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_list_keys_entry = {
 	"list-keys", "lsk",
+	"t:", 0, 0,
 	"[-t key-table]",
-	0, "",
+	0,
-	cmd_target_init,
+	NULL,
-	cmd_target_parse,
+	NULL,
-	cmd_list_keys_exec,
+	cmd_list_keys_exec
-	cmd_target_free,
-	cmd_target_print
 };
 
 int
 cmd_list_keys_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data	*data = self->data;
+	struct args		*args = self->args;
 	struct key_binding	*bd;
 	const char		*key;
-	char			 tmp[BUFSIZ];
+	char			 tmp[BUFSIZ], flags[8];
 	size_t			 used;
 	int			 width, keywidth;
 
-	if (data->target != NULL)
+	if (args_has(args, 't'))
 		return (cmd_list_keys_table(self, ctx));
 
 	width = 0;
-	SPLAY_FOREACH(bd, key_bindings, &key_bindings) {
+
+	RB_FOREACH(bd, key_bindings, &key_bindings) {
 		key = key_string_lookup_key(bd->key & ~KEYC_PREFIX);
 		if (key == NULL)
 			continue;
 
-		keywidth = strlen(key) + 1;
+		keywidth = strlen(key);
-		if (!(bd->key & KEYC_PREFIX))
+		if (!(bd->key & KEYC_PREFIX)) {
-			keywidth += 2;
+			if (bd->can_repeat)
+				keywidth += 4;
+			else
+				keywidth += 3;
+		} else if (bd->can_repeat)
+			keywidth += 3;
 		if (keywidth > width)
 			width = keywidth;
 	}
 
-	SPLAY_FOREACH(bd, key_bindings, &key_bindings) {
+	RB_FOREACH(bd, key_bindings, &key_bindings) {
 		key = key_string_lookup_key(bd->key & ~KEYC_PREFIX);
 		if (key == NULL)
 			continue;
-		used = xsnprintf(tmp, sizeof tmp, "%*s: ", width, key);
+
+		*flags = '\0';
+		if (!(bd->key & KEYC_PREFIX)) {
+			if (bd->can_repeat)
+				xsnprintf(flags, sizeof flags, "-rn ");
+			else
+				xsnprintf(flags, sizeof flags, "-n ");
+		} else if (bd->can_repeat)
+			xsnprintf(flags, sizeof flags, "-r ");
+
+		used = xsnprintf(tmp, sizeof tmp, "%s%*s ",
+		    flags, (int) (width - strlen(flags)), key);
 		if (used >= sizeof tmp)
 			continue;
 
-		if (!(bd->key & KEYC_PREFIX)) {
-			used = strlcat(tmp, "(no prefix) ", sizeof tmp);
-			if (used >= sizeof tmp)
-				continue;
-		}
 		cmd_list_print(bd->cmdlist, tmp + used, (sizeof tmp) - used);
-		ctx->print(ctx, "%s", tmp);
+		ctx->print(ctx, "bind-key %s", tmp);
 	}
 
 	return (0);
@@ -90,39 +101,48 @@ cmd_list_keys_exec(struct cmd *self, struct cmd_ctx *ctx)
 int
 cmd_list_keys_table(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data		*data = self->data;
+	struct args			*args = self->args;
+	const char			*tablename;
 	const struct mode_key_table	*mtab;
 	struct mode_key_binding		*mbind;
 	const char			*key, *cmdstr, *mode;
-	int			 	 width, keywidth;
+	int			 	 width, keywidth, any_mode;
 
-	if ((mtab = mode_key_findtable(data->target)) == NULL) {
+	tablename = args_get(args, 't');
-		ctx->error(ctx, "unknown key table: %s", data->target);
+	if ((mtab = mode_key_findtable(tablename)) == NULL) {
+		ctx->error(ctx, "unknown key table: %s", tablename);
 		return (-1);
 	}
 
 	width = 0;
-	SPLAY_FOREACH(mbind, mode_key_tree, mtab->tree) {
+	any_mode = 0;
+	RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
 		key = key_string_lookup_key(mbind->key);
 		if (key == NULL)
 			continue;
 
-		keywidth = strlen(key) + 1;
+		if (mbind->mode != 0)
+			any_mode = 1;
+
+		keywidth = strlen(key);
 		if (keywidth > width)
 			width = keywidth;
 	}
 
-	SPLAY_FOREACH(mbind, mode_key_tree, mtab->tree) {
+	RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
 		key = key_string_lookup_key(mbind->key);
 		if (key == NULL)
 			continue;
 
 		mode = "";
 		if (mbind->mode != 0)
-			mode = "(command mode) ";
+			mode = "c";
 		cmdstr = mode_key_tostring(mtab->cmdstr, mbind->cmd);
-		if (cmdstr != NULL)
+		if (cmdstr != NULL) {
-			ctx->print(ctx, "%*s: %s%s", width, key, mode, cmdstr);
+			ctx->print(ctx, "bind-key -%st %s%s %*s %s",
+			    mode, any_mode && *mode == '\0' ? " " : "",
+			    mtab->name, (int) width, key, cmdstr);
+		}
 	}
 
 	return (0);

cmd-list-panes.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-list-panes.c,v 1.4 2009-12-04 22:14:47 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -28,47 +28,116 @@
 
 int	cmd_list_panes_exec(struct cmd *, struct cmd_ctx *);
 
+void	cmd_list_panes_server(struct cmd *, struct cmd_ctx *);
+void	cmd_list_panes_session(
+	    struct cmd *, struct session *, struct cmd_ctx *, int);
+void	cmd_list_panes_window(struct cmd *,
+	    struct session *, struct winlink *, struct cmd_ctx *, int);
+
 const struct cmd_entry cmd_list_panes_entry = {
 	"list-panes", "lsp",
-	CMD_TARGET_WINDOW_USAGE,
+	"asF:t:", 0, 0,
-	0, "",
+	"[-as] [-F format] [-t target]",
-	cmd_target_init,
+	0,
-	cmd_target_parse,
+	NULL,
-	cmd_list_panes_exec,
+	NULL,
-	cmd_target_free,
+	cmd_list_panes_exec
-	cmd_target_print
 };
 
 int
 cmd_list_panes_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data	*data = self->data;
+	struct args	*args = self->args;
-	struct winlink		*wl;
+	struct session	*s;
-	struct window_pane	*wp;
+	struct winlink	*wl;
-	struct grid		*gd;
-	struct grid_line	*gl;
-	u_int			 i, n;
-	unsigned long long	 size;
 
-	if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
+	if (args_has(args, 'a'))
-		return (-1);
+		cmd_list_panes_server(self, ctx);
-
+	else if (args_has(args, 's')) {
-	n = 0;
+		s = cmd_find_session(ctx, args_get(args, 't'), 0);
-	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
+		if (s == NULL)
-		gd = wp->base.grid;
+			return (-1);
-
+		cmd_list_panes_session(self, s, ctx, 1);
-		size = 0;
+	} else {
-		for (i = 0; i < gd->hsize; i++) {
+		wl = cmd_find_window(ctx, args_get(args, 't'), &s);
-			gl = &gd->linedata[i];
+		if (wl == NULL)
-			size += gl->cellsize * sizeof *gl->celldata;
+			return (-1);
-			size += gl->utf8size * sizeof *gl->utf8data;
+		cmd_list_panes_window(self, s, wl, ctx, 0);
-		}
-		size += gd->hsize * sizeof *gd->linedata;
-
-		ctx->print(ctx, "%u: [%ux%u] [history %u/%u, %llu bytes]",
-		    n, wp->sx, wp->sy, gd->hsize, gd->hlimit, size);
-		n++;
 	}
 
 	return (0);
 }
+
+void
+cmd_list_panes_server(struct cmd *self, struct cmd_ctx *ctx)
+{
+	struct session	*s;
+
+	RB_FOREACH(s, sessions, &sessions)
+		cmd_list_panes_session(self, s, ctx, 2);
+}
+
+void
+cmd_list_panes_session(
+    struct cmd *self, struct session *s, struct cmd_ctx *ctx, int type)
+{
+	struct winlink	*wl;
+
+	RB_FOREACH(wl, winlinks, &s->windows)
+		cmd_list_panes_window(self, s, wl, ctx, type);
+}
+
+void
+cmd_list_panes_window(struct cmd *self,
+    struct session *s, struct winlink *wl, struct cmd_ctx *ctx, int type)
+{
+	struct args		*args = self->args;
+	struct window_pane	*wp;
+	u_int			 n;
+	struct format_tree	*ft;
+	const char		*template;
+	char			*line;
+
+	template = args_get(args, 'F');
+	if (template == NULL) {
+		switch (type) {
+		case 0:
+			template = "#{pane_index}: "
+			    "[#{pane_width}x#{pane_height}] [history "
+			    "#{history_size}/#{history_limit}, "
+			    "#{history_bytes} bytes] #{pane_id}"
+			    "#{?pane_active, (active),}#{?pane_dead, (dead),}";
+			break;
+		case 1:
+			template = "#{window_index}.#{pane_index}: "
+			    "[#{pane_width}x#{pane_height}] [history "
+			    "#{history_size}/#{history_limit}, "
+			    "#{history_bytes} bytes] #{pane_id}"
+			    "#{?pane_active, (active),}#{?pane_dead, (dead),}";
+			break;
+		case 2:
+			template = "#{session_name}:#{window_index}.#{pane_index}: "
+			    "[#{pane_width}x#{pane_height}] [history "
+			    "#{history_size}/#{history_limit}, "
+			    "#{history_bytes} bytes] #{pane_id}"
+			    "#{?pane_active, (active),}#{?pane_dead, (dead),}";
+			break;
+		}
+	}
+
+	n = 0;
+	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
+		ft = format_create();
+		format_add(ft, "line", "%u", n);
+		format_session(ft, s);
+		format_winlink(ft, s, wl);
+		format_window_pane(ft, wp);
+
+		line = format_expand(ft, template);
+		ctx->print(ctx, "%s", line);
+		xfree(line);
+
+		format_free(ft);
+		n++;
+	}
+}

cmd-list-sessions.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-list-sessions.c,v 1.25 2009-11-28 14:50:36 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -30,45 +30,46 @@
 int	cmd_list_sessions_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_list_sessions_entry = {
-	"list-sessions", "ls", "",
+	"list-sessions", "ls",
-	0, "",
+	"F:", 0, 0,
+	"[-F format]",
+	0,
 	NULL,
 	NULL,
-	cmd_list_sessions_exec,
+	cmd_list_sessions_exec
-	NULL,
-	NULL
 };
 
-/* ARGSUSED */
 int
-cmd_list_sessions_exec(unused struct cmd *self, struct cmd_ctx *ctx)
+cmd_list_sessions_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
+	struct args		*args = self->args;
 	struct session		*s;
-	struct session_group	*sg;
+	u_int		 	 n;
-	char			*tim, tmp[64];
+	struct format_tree	*ft;
-	u_int			 i, idx;
+	const char		*template;
-	time_t			 t;
+	char			*line;
 
-	for (i = 0; i < ARRAY_LENGTH(&sessions); i++) {
+	template = args_get(args, 'F');
-		s = ARRAY_ITEM(&sessions, i);
+	if (template == NULL) {
-		if (s == NULL)
+		template = "#{session_name}: #{session_windows} windows "
-			continue;
+		    "(created #{session_created_string}) [#{session_width}x"
+		    "#{session_height}]#{?session_grouped, (group ,}"
+		    "#{session_group}#{?session_grouped,),}"
+		    "#{?session_attached, (attached),}";
+	}
 
-		sg = session_group_find(s);
+	n = 0;
-		if (sg == NULL)
+	RB_FOREACH(s, sessions, &sessions) {
-			*tmp = '\0';
+		ft = format_create();
-		else {
+		format_add(ft, "line", "%u", n);
-			idx = session_group_index(sg);
+		format_session(ft, s);
-			xsnprintf(tmp, sizeof tmp, " (group %u)", idx);
-		}
 
-		t = s->creation_time.tv_sec;
+		line = format_expand(ft, template);
-		tim = ctime(&t);
+		ctx->print(ctx, "%s", line);
-		*strchr(tim, '\n') = '\0';
+		xfree(line);
 
-		ctx->print(ctx, "%s: %u windows (created %s) [%ux%u]%s%s",
+		format_free(ft);
-		    s->name, winlink_count(&s->windows), tim, s->sx, s->sy,
+		n++;
-		    tmp, s->flags & SESSION_UNATTACHED ? "" : " (attached)");
 	}
 
 	return (0);

cmd-list-windows.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-list-windows.c,v 1.42 2009-11-14 17:56:39 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -28,31 +28,90 @@
 
 int	cmd_list_windows_exec(struct cmd *, struct cmd_ctx *);
 
+void	cmd_list_windows_server(struct cmd *, struct cmd_ctx *);
+void	cmd_list_windows_session(
+	    struct cmd *, struct session *, struct cmd_ctx *, int);
+
 const struct cmd_entry cmd_list_windows_entry = {
 	"list-windows", "lsw",
-	CMD_TARGET_SESSION_USAGE,
+	"aF:t:", 0, 0,
-	0, "",
+	"[-a] [-F format] " CMD_TARGET_SESSION_USAGE,
-	cmd_target_init,
+	0,
-	cmd_target_parse,
+	NULL,
-	cmd_list_windows_exec,
+	NULL,
-	cmd_target_free,
+	cmd_list_windows_exec
-	cmd_target_print
 };
 
 int
 cmd_list_windows_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data	*data = self->data;
+	struct args	*args = self->args;
-	struct session		*s;
+	struct session	*s;
-	struct winlink		*wl;
 
-	if ((s = cmd_find_session(ctx, data->target)) == NULL)
+	if (args_has(args, 'a'))
-		return (-1);
+		cmd_list_windows_server(self, ctx);
-
+	else {
-	RB_FOREACH(wl, winlinks, &s->windows) {
+		s = cmd_find_session(ctx, args_get(args, 't'), 0);
-		ctx->print(ctx, "%d: %s [%ux%u]",
+		if (s == NULL)
-		    wl->idx, wl->window->name, wl->window->sx, wl->window->sy);
+			return (-1);
+		cmd_list_windows_session(self, s, ctx, 0);
 	}
 
 	return (0);
 }
+
+void
+cmd_list_windows_server(struct cmd *self, struct cmd_ctx *ctx)
+{
+	struct session	*s;
+
+	RB_FOREACH(s, sessions, &sessions)
+		cmd_list_windows_session(self, s, ctx, 1);
+}
+
+void
+cmd_list_windows_session(
+    struct cmd *self, struct session *s, struct cmd_ctx *ctx, int type)
+{
+	struct args		*args = self->args;
+	struct winlink		*wl;
+	u_int			n;
+	struct format_tree	*ft;
+	const char		*template;
+	char			*line;
+
+	template = args_get(args, 'F');
+	if (template == NULL) {
+		switch (type) {
+		case 0:
+			template = "#{window_index}: "
+			    "#{window_name} "
+			    "[#{window_width}x#{window_height}] "
+			    "[layout #{window_layout}]"
+			    "#{?window_active, (active),}";
+			break;
+		case 1:
+			template = "#{session_name}:#{window_index}: "
+			    "#{window_name} "
+			    "[#{window_width}x#{window_height}] "
+			    "[layout #{window_layout}]"
+			    "#{?window_active, (active),}";
+			break;
+		}
+	}
+
+	n = 0;
+	RB_FOREACH(wl, winlinks, &s->windows) {
+		ft = format_create();
+		format_add(ft, "line", "%u", n);
+		format_session(ft, s);
+		format_winlink(ft, s, wl);
+
+		line = format_expand(ft, template);
+		ctx->print(ctx, "%s", line);
+		xfree(line);
+
+		format_free(ft);
+		n++;
+	}
+}

cmd-list.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-list.c,v 1.7 2010-02-02 23:51:04 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -29,47 +29,52 @@ cmd_list_parse(int argc, char **argv, char **cause)
 	struct cmd	*cmd;
 	int		 i, lastsplit;
 	size_t		 arglen, new_argc;
-	char	       **new_argv;
+	char	       **copy_argv, **new_argv;
+
+	copy_argv = cmd_copy_argv(argc, argv);
 
 	cmdlist = xmalloc(sizeof *cmdlist);
-	TAILQ_INIT(cmdlist);
+	cmdlist->references = 1;
+	TAILQ_INIT(&cmdlist->list);
 
 	lastsplit = 0;
 	for (i = 0; i < argc; i++) {
-		arglen = strlen(argv[i]);
+		arglen = strlen(copy_argv[i]);
-		if (arglen == 0 || argv[i][arglen - 1] != ';')
+		if (arglen == 0 || copy_argv[i][arglen - 1] != ';')
 			continue;
-		argv[i][arglen - 1] = '\0';
+		copy_argv[i][arglen - 1] = '\0';
 
-		if (arglen > 1 && argv[i][arglen - 2] == '\\') {
+		if (arglen > 1 && copy_argv[i][arglen - 2] == '\\') {
-			argv[i][arglen - 2] = ';';
+			copy_argv[i][arglen - 2] = ';';
 			continue;
 		}
 
 		new_argc = i - lastsplit;
-		new_argv = argv + lastsplit;
+		new_argv = copy_argv + lastsplit;
 		if (arglen != 1)
 			new_argc++;
 
 		cmd = cmd_parse(new_argc, new_argv, cause);
 		if (cmd == NULL)
 			goto bad;
-		TAILQ_INSERT_TAIL(cmdlist, cmd, qentry);
+		TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
 
 		lastsplit = i + 1;
 	}
 
 	if (lastsplit != argc) {
-		cmd = cmd_parse(argc - lastsplit, argv + lastsplit, cause);
+		cmd = cmd_parse(argc - lastsplit, copy_argv + lastsplit, cause);
 		if (cmd == NULL)
 			goto bad;
-		TAILQ_INSERT_TAIL(cmdlist, cmd, qentry);
+		TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
 	}
 
+	cmd_free_argv(argc, copy_argv);
 	return (cmdlist);
 
 bad:
 	cmd_list_free(cmdlist);
+	cmd_free_argv(argc, copy_argv);
 	return (NULL);
 }
 
@@ -80,7 +85,7 @@ cmd_list_exec(struct cmd_list *cmdlist, struct cmd_ctx *ctx)
 	int		 n, retval;
 
 	retval = 0;
-	TAILQ_FOREACH(cmd, cmdlist, qentry) {
+	TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
 		if ((n = cmd_exec(cmd, ctx)) == -1)
 			return (-1);
 
@@ -99,6 +104,10 @@ cmd_list_exec(struct cmd_list *cmdlist, struct cmd_ctx *ctx)
 			if (ctx->curclient == NULL) {
 				ctx->curclient = ctx->cmdclient;
 				ctx->cmdclient = NULL;
+
+				ctx->error = key_bindings_error;
+				ctx->print = key_bindings_print;
+				ctx->info = key_bindings_info;
 			}
 		}
 	}
@@ -110,9 +119,12 @@ cmd_list_free(struct cmd_list *cmdlist)
 {
 	struct cmd	*cmd;
 
-	while (!TAILQ_EMPTY(cmdlist)) {
+	if (--cmdlist->references != 0)
-		cmd = TAILQ_FIRST(cmdlist);
+		return;
-		TAILQ_REMOVE(cmdlist, cmd, qentry);
+
+	while (!TAILQ_EMPTY(&cmdlist->list)) {
+		cmd = TAILQ_FIRST(&cmdlist->list);
+		TAILQ_REMOVE(&cmdlist->list, cmd, qentry);
 		cmd_free(cmd);
 	}
 	xfree(cmdlist);
@@ -125,7 +137,7 @@ cmd_list_print(struct cmd_list *cmdlist, char *buf, size_t len)
 	size_t		 off;
 
 	off = 0;
-	TAILQ_FOREACH(cmd, cmdlist, qentry) {
+	TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
 		if (off >= len)
 			break;
 		off += cmd_print(cmd, buf + off, len - off);

cmd-load-buffer.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-load-buffer.c,v 1.15 2010-02-26 13:30:07 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -16,46 +16,99 @@
  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
+#include <sys/types.h>
+
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 #include "tmux.h"
 
 /*
- * Loads a session paste buffer from a file.
+ * Loads a paste buffer from a file.
  */
 
 int	cmd_load_buffer_exec(struct cmd *, struct cmd_ctx *);
+void	cmd_load_buffer_callback(struct client *, void *);
 
 const struct cmd_entry cmd_load_buffer_entry = {
 	"load-buffer", "loadb",
-	CMD_BUFFER_SESSION_USAGE " path",
+	"b:", 1, 1,
-	CMD_ARG1, "",
+	CMD_BUFFER_USAGE " path",
-	cmd_buffer_init,
+	0,
-	cmd_buffer_parse,
+	NULL,
-	cmd_load_buffer_exec,
+	NULL,
-	cmd_buffer_free,
+	cmd_load_buffer_exec
-	cmd_buffer_print
 };
 
 int
 cmd_load_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_buffer_data	*data = self->data;
+	struct args	*args = self->args;
-	struct session		*s;
+	struct client	*c = ctx->cmdclient;
-	FILE			*f;
+	struct session  *s;
-	char		      	*pdata, *new_pdata;
+	FILE		*f;
-	size_t			 psize;
+	const char	*path, *newpath, *wd;
-	u_int			 limit;
+	char		*pdata, *new_pdata, *cause;
-	int			 ch;
+	size_t		 psize;
+	u_int		 limit;
+	int		 ch, buffer;
+	int		*buffer_ptr;
 
-	if ((s = cmd_find_session(ctx, data->target)) == NULL)
+	if (!args_has(args, 'b'))
-		return (-1);
+		buffer = -1;
+	else {
+		buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
+		if (cause != NULL) {
+			ctx->error(ctx, "buffer %s", cause);
+			xfree(cause);
+			return (-1);
+		}
+	}
 
-	if ((f = fopen(data->arg, "rb")) == NULL) {
+	path = args->argv[0];
-		ctx->error(ctx, "%s: %s", data->arg, strerror(errno));
+	if (strcmp(path, "-") == 0) {
+		if (c == NULL) {
+			ctx->error(ctx, "%s: can't read from stdin", path);
+			return (-1);
+		}
+		if (c->flags & CLIENT_TERMINAL) {
+			ctx->error(ctx, "%s: stdin is a tty", path);
+			return (-1);
+		}
+		if (c->stdin_fd == -1) {
+			ctx->error(ctx, "%s: can't read from stdin", path);
+			return (-1);
+		}
+
+		buffer_ptr = xmalloc(sizeof *buffer_ptr);
+		*buffer_ptr = buffer;
+
+		c->stdin_data = buffer_ptr;
+		c->stdin_callback = cmd_load_buffer_callback;
+
+		c->references++;
+		bufferevent_enable(c->stdin_event, EV_READ);
+		return (1);
+	}
+
+	if (c != NULL)
+		wd = c->cwd;
+	else if ((s = cmd_current_session(ctx, 0)) != NULL) {
+		wd = options_get_string(&s->options, "default-path");
+		if (*wd == '\0')
+			wd = s->cwd;
+	} else
+		wd = NULL;
+	if (wd != NULL && *wd != '\0') {
+		newpath = get_full_path(wd, path);
+		if (newpath != NULL)
+			path = newpath;
+	}
+	if ((f = fopen(path, "rb")) == NULL) {
+		ctx->error(ctx, "%s: %s", path, strerror(errno));
 		return (-1);
 	}
 
@@ -71,7 +124,7 @@ cmd_load_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
 		pdata[psize++] = ch;
 	}
 	if (ferror(f)) {
-		ctx->error(ctx, "%s: read error", data->arg);
+		ctx->error(ctx, "%s: read error", path);
 		goto error;
 	}
 	if (pdata != NULL)
@@ -79,14 +132,15 @@ cmd_load_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
 
 	fclose(f);
 
-	limit = options_get_number(&s->options, "buffer-limit");
+	limit = options_get_number(&global_options, "buffer-limit");
-	if (data->buffer == -1) {
+	if (buffer == -1) {
-		paste_add(&s->buffers, pdata, psize, limit);
+		paste_add(&global_buffers, pdata, psize, limit);
 		return (0);
 	}
-	if (paste_replace(&s->buffers, data->buffer, pdata, psize) != 0) {
+	if (paste_replace(&global_buffers, buffer, pdata, psize) != 0) {
-		ctx->error(ctx, "no buffer %d", data->buffer);
+		ctx->error(ctx, "no buffer %d", buffer);
-		goto error;
+		xfree(pdata);
+		return (-1);
 	}
 
 	return (0);
@@ -94,6 +148,42 @@ cmd_load_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
 error:
 	if (pdata != NULL)
 		xfree(pdata);
-	fclose(f);
+	if (f != NULL)
+		fclose(f);
 	return (-1);
 }
+
+void
+cmd_load_buffer_callback(struct client *c, void *data)
+{
+	int	*buffer = data;
+	char	*pdata;
+	size_t	 psize;
+	u_int	 limit;
+
+	/*
+	 * Event callback has already checked client is not dead and reduced
+	 * its reference count. But tell it to exit.
+	 */
+	c->flags |= CLIENT_EXIT;
+
+	psize = EVBUFFER_LENGTH(c->stdin_event->input);
+	if (psize == 0 || (pdata = malloc(psize + 1)) == NULL) {
+		xfree(data);
+		return;
+	}
+	bufferevent_read(c->stdin_event, pdata, psize);
+	pdata[psize] = '\0';
+
+	limit = options_get_number(&global_options, "buffer-limit");
+	if (*buffer == -1)
+		paste_add(&global_buffers, pdata, psize, limit);
+	else if (paste_replace(&global_buffers, *buffer, pdata, psize) != 0) {
+		/* No context so can't use server_client_msg_error. */
+		evbuffer_add_printf(
+		    c->stderr_event->output, "no buffer %d\n", *buffer);
+		bufferevent_enable(c->stderr_event, EV_WRITE);
+	}
+
+	xfree(data);
+}

cmd-lock-server.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-lock-server.c,v 1.9 2009-11-28 14:50:36 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -25,27 +25,60 @@
 #include "tmux.h"
 
 /*
- * Lock server.
+ * Lock commands.
  */
 
 int	cmd_lock_server_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_lock_server_entry = {
 	"lock-server", "lock",
+	"", 0, 0,
 	"",
-	0, "",
+	0,
 	NULL,
 	NULL,
-	cmd_lock_server_exec,
+	cmd_lock_server_exec
+};
+
+const struct cmd_entry cmd_lock_session_entry = {
+	"lock-session", "locks",
+	"t:", 0, 0,
+	CMD_TARGET_SESSION_USAGE,
+	0,
 	NULL,
 	NULL,
+	cmd_lock_server_exec
+};
+
+const struct cmd_entry cmd_lock_client_entry = {
+	"lock-client", "lockc",
+	"t:", 0, 0,
+	CMD_TARGET_CLIENT_USAGE,
+	0,
+	NULL,
+	NULL,
+	cmd_lock_server_exec
 };
 
 /* ARGSUSED */
 int
-cmd_lock_server_exec(unused struct cmd *self, unused struct cmd_ctx *ctx)
+cmd_lock_server_exec(struct cmd *self, unused struct cmd_ctx *ctx)
 {
-	server_lock();
+	struct args	*args = self->args;
+	struct client	*c;
+	struct session	*s;
+
+	if (self->entry == &cmd_lock_server_entry)
+		server_lock();
+	else if (self->entry == &cmd_lock_session_entry) {
+		if ((s = cmd_find_session(ctx, args_get(args, 't'), 0)) == NULL)
+			return (-1);
+		server_lock_session(s);
+	} else {
+		if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
+			return (-1);
+		server_lock_client(c);
+	}
 	recalculate_sizes();
 
 	return (0);

cmd-move-window.c

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

cmd-new-session.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-new-session.c,v 1.76 2010-02-26 13:28:15 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,8 +18,11 @@
 
 #include <sys/types.h>
 
+#include <pwd.h>
+#include <stdlib.h>
 #include <string.h>
 #include <termios.h>
+#include <unistd.h>
 
 #include "tmux.h"
 
@@ -27,118 +30,62 @@
  * Create a new session and attach to the current terminal unless -d is given.
  */
 
-int	cmd_new_session_parse(struct cmd *, int, char **, char **);
+int	cmd_new_session_check(struct args *);
 int	cmd_new_session_exec(struct cmd *, struct cmd_ctx *);
-void	cmd_new_session_free(struct cmd *);
-void	cmd_new_session_init(struct cmd *, int);
-size_t	cmd_new_session_print(struct cmd *, char *, size_t);
-
-struct cmd_new_session_data {
-	char	*target;
-	char	*newname;
-	char	*winname;
-	char	*cmd;
-	int	 flag_detached;
-};
 
 const struct cmd_entry cmd_new_session_entry = {
 	"new-session", "new",
-	"[-d] [-n window-name] [-s session-name] [-t target-session] [command]",
+	"dn:s:t:x:y:", 0, 1,
-	CMD_STARTSERVER|CMD_CANTNEST|CMD_SENDENVIRON, "",
+	"[-d] [-n window-name] [-s session-name] [-t target-session] "
-	cmd_new_session_init,
+	"[-x width] [-y height] [command]",
-	cmd_new_session_parse,
+	CMD_STARTSERVER|CMD_CANTNEST|CMD_SENDENVIRON,
-	cmd_new_session_exec,
+	NULL,
-	cmd_new_session_free,
+	cmd_new_session_check,
-	cmd_new_session_print
+	cmd_new_session_exec
 };
 
-/* ARGSUSED */
-void
-cmd_new_session_init(struct cmd *self, unused int arg)
-{
-	struct cmd_new_session_data	 *data;
-
-	self->data = data = xmalloc(sizeof *data);
-	data->flag_detached = 0;
-	data->target = NULL;
-	data->newname = NULL;
-	data->winname = NULL;
-	data->cmd = NULL;
-}
-
 int
-cmd_new_session_parse(struct cmd *self, int argc, char **argv, char **cause)
+cmd_new_session_check(struct args *args)
 {
-	struct cmd_new_session_data	*data;
+	if (args_has(args, 't') && (args->argc != 0 || args_has(args, 'n')))
-	int				 opt;
+		return (-1);
-
-	self->entry->init(self, KEYC_NONE);
-	data = self->data;
-
-	while ((opt = getopt(argc, argv, "ds:t:n:")) != -1) {
-		switch (opt) {
-		case 'd':
-			data->flag_detached = 1;
-			break;
-		case 's':
-			if (data->newname == NULL)
-				data->newname = xstrdup(optarg);
-			break;
-		case 't':
-			if (data->target == NULL)
-				data->target = xstrdup(optarg);
-			break;
-		case 'n':
-			if (data->winname == NULL)
-				data->winname = xstrdup(optarg);
-			break;
-		default:
-			goto usage;
-		}
-	}
-	argc -= optind;
-	argv += optind;
-	if (argc != 0 && argc != 1)
-		goto usage;
-
-	if (data->target != NULL && (argc == 1 || data->winname != NULL))
-		goto usage;
-
-	if (argc == 1)
-		data->cmd = xstrdup(argv[0]);
-
 	return (0);
-
-usage:
-	xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
-
-	self->entry->free(self);
-	return (-1);
 }
 
 int
 cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_new_session_data	*data = self->data;
+	struct args		*args = self->args;
-	struct session			*s, *groupwith;
+	struct session		*s, *old_s, *groupwith;
-	struct window			*w;
+	struct window		*w;
-	struct window_pane		*wp;
+	struct window_pane	*wp;
-	struct environ			 env;
+	struct environ		 env;
-	struct termios			 tio, *tiop;
+	struct termios		 tio, *tiop;
-	const char			*update;
+	struct passwd		*pw;
-	char				*overrides, *cmd, *cwd, *cause;
+	const char		*newname, *target, *update, *cwd, *errstr;
-	int				 detached, idx;
+	char			*overrides, *cmd, *cause;
-	u_int				 sx, sy, i;
+	int			 detached, idx;
+	u_int			 sx, sy, i;
 
-	if (data->newname != NULL && session_find(data->newname) != NULL) {
+	newname = args_get(args, 's');
-		ctx->error(ctx, "duplicate session: %s", data->newname);
+	if (newname != NULL) {
-		return (-1);
+		if (!session_check_name(newname)) {
+			ctx->error(ctx, "bad session name: %s", newname);
+			return (-1);
+		}
+		if (session_find(newname) != NULL) {
+			ctx->error(ctx, "duplicate session: %s", newname);
+			return (-1);
+		}
 	}
 
-	groupwith = NULL;
+	target = args_get(args, 't');
-	if (data->target != NULL &&
+	if (target != NULL) {
-	    (groupwith = cmd_find_session(ctx, data->target)) == NULL)
+		groupwith = cmd_find_session(ctx, target, 0);
-		return (-1);
+		if (groupwith == NULL)
+			return (-1);
+	} else
+		groupwith = NULL;
 
 	/*
 	 * There are three cases:
@@ -159,7 +106,7 @@ cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 	 */
 
 	/* Set -d if no client. */
-	detached = data->flag_detached;
+	detached = args_has(args, 'd');
 	if (ctx->cmdclient == NULL && ctx->curclient == NULL)
 		detached = 1;
 
@@ -198,19 +145,42 @@ cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 	/* Get the new session working directory. */
 	if (ctx->cmdclient != NULL && ctx->cmdclient->cwd != NULL)
 		cwd = ctx->cmdclient->cwd;
-	else
+	else {
-		cwd = options_get_string(&global_s_options, "default-path");
+		pw = getpwuid(getuid());
+		if (pw->pw_dir != NULL && *pw->pw_dir != '\0')
+			cwd = pw->pw_dir;
+		else
+			cwd = "/";
+	}
 
 	/* Find new session size. */
-	if (detached) {
+	if (ctx->cmdclient != NULL) {
-		sx = 80;
-		sy = 24;
-	} else if (ctx->cmdclient != NULL) {
 		sx = ctx->cmdclient->tty.sx;
 		sy = ctx->cmdclient->tty.sy;
-	} else {
+	} else if (ctx->curclient != NULL) {
 		sx = ctx->curclient->tty.sx;
 		sy = ctx->curclient->tty.sy;
+	} else {
+		sx = 80;
+		sy = 24;
+	}
+	if (detached) {
+		if (args_has(args, 'x')) {
+			sx = strtonum(
+			    args_get(args, 'x'), 1, USHRT_MAX, &errstr);
+			if (errstr != NULL) {
+				ctx->error(ctx, "width %s", errstr);
+				return (-1);
+			}
+		}
+		if (args_has(args, 'y')) {
+			sy = strtonum(
+			    args_get(args, 'y'), 1, USHRT_MAX, &errstr);
+			if (errstr != NULL) {
+				ctx->error(ctx, "height %s", errstr);
+				return (-1);
+			}
+		}
 	}
 	if (sy > 0 && options_get_number(&global_s_options, "status"))
 		sy--;
@@ -220,10 +190,10 @@ cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 		sy = 1;
 
 	/* Figure out the command for the new window. */
-	if (data->target != NULL)
+	if (target != NULL)
 		cmd = NULL;
-	else if (data->cmd != NULL)
+	else if (args->argc != 0)
-		cmd = data->cmd;
+		cmd = args->argv[0];
 	else
 		cmd = options_get_string(&global_s_options, "default-command");
 
@@ -235,8 +205,7 @@ cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 
 	/* Create the new session. */
 	idx = -1 - options_get_number(&global_s_options, "base-index");
-	s = session_create(
+	s = session_create(newname, cmd, cwd, &env, tiop, idx, sx, sy, &cause);
-	    data->newname, cmd, cwd, &env, tiop, idx, sx, sy, &cause);
 	if (s == NULL) {
 		ctx->error(ctx, "create session failed: %s", cause);
 		xfree(cause);
@@ -245,11 +214,11 @@ cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 	environ_free(&env);
 
 	/* Set the initial window name if one given. */
-	if (cmd != NULL && data->winname != NULL) {
+	if (cmd != NULL && args_has(args, 'n')) {
 		w = s->curw->window;
 
 		xfree(w->name);
-		w->name = xstrdup(data->winname);
+		w->name = xstrdup(args_get(args, 'n'));
 
 		options_set_number(&w->options, "automatic-rename", 0);
 	}
@@ -271,10 +240,19 @@ cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 	if (!detached) {
 		if (ctx->cmdclient != NULL) {
 			server_write_client(ctx->cmdclient, MSG_READY, NULL, 0);
+
+			old_s = ctx->cmdclient->session;
+			if (old_s != NULL)
+				ctx->cmdclient->last_session = old_s;
 			ctx->cmdclient->session = s;
+			session_update_activity(s);
 			server_redraw_client(ctx->cmdclient);
 		} else {
+			old_s = ctx->curclient->session;
+			if (old_s != NULL)
+				ctx->curclient->last_session = old_s;
 			ctx->curclient->session = s;
+			session_update_activity(s);
 			server_redraw_client(ctx->curclient);
 		}
 	}
@@ -287,10 +265,11 @@ cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 	 */
 	if (cfg_finished && !ARRAY_EMPTY(&cfg_causes)) {
 		wp = s->curw->window->active;
-		window_pane_set_mode(wp, &window_more_mode);
+		window_pane_set_mode(wp, &window_copy_mode);
+		window_copy_init_for_output(wp);
 		for (i = 0; i < ARRAY_LENGTH(&cfg_causes); i++) {
 			cause = ARRAY_ITEM(&cfg_causes, i);
-			window_more_add(wp, "%s", cause);
+			window_copy_add(wp, "%s", cause);
 			xfree(cause);
 		}
 		ARRAY_FREE(&cfg_causes);
@@ -298,39 +277,3 @@ cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 
 	return (!detached);	/* 1 means don't tell command client to exit */
 }
-
-void
-cmd_new_session_free(struct cmd *self)
-{
-	struct cmd_new_session_data	*data = self->data;
-
-	if (data->newname != NULL)
-		xfree(data->newname);
-	if (data->winname != NULL)
-		xfree(data->winname);
-	if (data->cmd != NULL)
-		xfree(data->cmd);
-	xfree(data);
-}
-
-size_t
-cmd_new_session_print(struct cmd *self, char *buf, size_t len)
-{
-	struct cmd_new_session_data	*data = self->data;
-	size_t				 off = 0;
-
-	off += xsnprintf(buf, len, "%s", self->entry->name);
-	if (data == NULL)
-		return (off);
-	if (off < len && data->flag_detached)
-		off += xsnprintf(buf + off, len - off, " -d");
-	if (off < len && data->winname != NULL)
-		off += cmd_prarg(buf + off, len - off, " -n ", data->winname);
-	if (off < len && data->newname != NULL)
-		off += cmd_prarg(buf + off, len - off, " -s ", data->newname);
-	if (off < len && data->target != NULL)
-		off += cmd_prarg(buf + off, len - off, " -t ", data->target);
-	if (off < len && data->cmd != NULL)
-		off += cmd_prarg(buf + off, len - off, " ", data->cmd);
-	return (off);
-}

cmd-new-window.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-new-window.c,v 1.43 2010-01-22 17:28:34 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -26,180 +26,96 @@
  * Create a new window.
  */
 
-int	cmd_new_window_parse(struct cmd *, int, char **, char **);
 int	cmd_new_window_exec(struct cmd *, struct cmd_ctx *);
-void	cmd_new_window_free(struct cmd *);
-void	cmd_new_window_init(struct cmd *, int);
-size_t	cmd_new_window_print(struct cmd *, char *, size_t);
-
-struct cmd_new_window_data {
-	char	*target;
-	char	*name;
-	char	*cmd;
-	int	 flag_detached;
-	int	 flag_kill;
-};
 
 const struct cmd_entry cmd_new_window_entry = {
 	"new-window", "neww",
-	"[-dk] [-n window-name] [-t target-window] [command]",
+	"adkn:Pt:", 0, 1,
-	0, "",
+	"[-adk] [-n window-name] [-t target-window] [command]",
-	cmd_new_window_init,
+	0,
-	cmd_new_window_parse,
+	NULL,
-	cmd_new_window_exec,
+	NULL,
-	cmd_new_window_free,
+	cmd_new_window_exec
-	cmd_new_window_print
 };
 
-/* ARGSUSED */
-void
-cmd_new_window_init(struct cmd *self, unused int arg)
-{
-	struct cmd_new_window_data	 *data;
-
-	self->data = data = xmalloc(sizeof *data);
-	data->target = NULL;
-	data->name = NULL;
-	data->cmd = NULL;
-	data->flag_detached = 0;
-	data->flag_kill = 0;
-}
-
-int
-cmd_new_window_parse(struct cmd *self, int argc, char **argv, char **cause)
-{
-	struct cmd_new_window_data	*data;
-	int				 opt;
-
-	self->entry->init(self, KEYC_NONE);
-	data = self->data;
-
-	while ((opt = getopt(argc, argv, "dkt:n:")) != -1) {
-		switch (opt) {
-		case 'd':
-			data->flag_detached = 1;
-			break;
-		case 'k':
-			data->flag_kill = 1;
-			break;
-		case 't':
-			if (data->target == NULL)
-				data->target = xstrdup(optarg);
-			break;
-		case 'n':
-			if (data->name == NULL)
-				data->name = xstrdup(optarg);
-			break;
-		default:
-			goto usage;
-		}
-	}
-	argc -= optind;
-	argv += optind;
-	if (argc != 0 && argc != 1)
-		goto usage;
-
-	if (argc == 1)
-		data->cmd = xstrdup(argv[0]);
-
-	return (0);
-
-usage:
-	xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
-
-	self->entry->free(self);
-	return (-1);
-}
-
 int
 cmd_new_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_new_window_data	*data = self->data;
+	struct args	*args = self->args;
-	struct session			*s;
+	struct session	*s;
-	struct winlink			*wl;
+	struct winlink	*wl;
-	char				*cmd, *cwd, *cause;
+	const char     	*cmd, *cwd;
-	int				 idx;
+	char		*cause;
+	int		 idx, last, detached;
 
-	if (data == NULL)
+	if (args_has(args, 'a')) {
-		return (0);
+		wl = cmd_find_window(ctx, args_get(args, 't'), &s);
+		if (wl == NULL)
+			return (-1);
+		idx = wl->idx + 1;
 
-	if ((idx = cmd_find_index(ctx, data->target, &s)) == -2)
+		/* Find the next free index. */
-		return (-1);
+		for (last = idx; last < INT_MAX; last++) {
+			if (winlink_find_by_index(&s->windows, last) == NULL)
+				break;
+		}
+		if (last == INT_MAX) {
+			ctx->error(ctx, "no free window indexes");
+			return (-1);
+		}
+
+		/* Move everything from last - 1 to idx up a bit. */
+		for (; last > idx; last--) {
+			wl = winlink_find_by_index(&s->windows, last - 1);
+			server_link_window(s, wl, s, last, 0, 0, NULL);
+			server_unlink_window(s, wl);
+		}
+	} else {
+		if ((idx = cmd_find_index(ctx, args_get(args, 't'), &s)) == -2)
+			return (-1);
+	}
+	detached = args_has(args, 'd');
 
 	wl = NULL;
 	if (idx != -1)
 		wl = winlink_find_by_index(&s->windows, idx);
-	if (wl != NULL && data->flag_kill) {
+	if (wl != NULL && args_has(args, 'k')) {
 		/*
 		 * Can't use session_detach as it will destroy session if this
 		 * makes it empty.
 		 */
-		session_alert_cancel(s, wl);
+		wl->flags &= ~WINLINK_ALERTFLAGS;
 		winlink_stack_remove(&s->lastw, wl);
 		winlink_remove(&s->windows, wl);
 
 		/* Force select/redraw if current. */
 		if (wl == s->curw) {
-			data->flag_detached = 0;
+			detached = 0;
 			s->curw = NULL;
 		}
 	}
 
-	cmd = data->cmd;
+	if (args->argc == 0)
-	if (cmd == NULL)
 		cmd = options_get_string(&s->options, "default-command");
-	if (ctx->cmdclient == NULL || ctx->cmdclient->cwd == NULL)
-		cwd = options_get_string(&s->options, "default-path");
 	else
-		cwd = ctx->cmdclient->cwd;
+		cmd = args->argv[0];
+	cwd = cmd_get_default_path(ctx);
 
 	if (idx == -1)
 		idx = -1 - options_get_number(&s->options, "base-index");
-	wl = session_new(s, data->name, cmd, cwd, idx, &cause);
+	wl = session_new(s, args_get(args, 'n'), cmd, cwd, idx, &cause);
 	if (wl == NULL) {
 		ctx->error(ctx, "create window failed: %s", cause);
 		xfree(cause);
 		return (-1);
 	}
-	if (!data->flag_detached) {
+	if (!detached) {
 		session_select(s, wl->idx);
 		server_redraw_session_group(s);
 	} else
 		server_status_session_group(s);
 
+	if (args_has(args, 'P'))
+		ctx->print(ctx, "%s:%u", s->name, wl->idx);
 	return (0);
 }
-
-void
-cmd_new_window_free(struct cmd *self)
-{
-	struct cmd_new_window_data	*data = self->data;
-
-	if (data->target != NULL)
-		xfree(data->target);
-	if (data->name != NULL)
-		xfree(data->name);
-	if (data->cmd != NULL)
-		xfree(data->cmd);
-	xfree(data);
-}
-
-size_t
-cmd_new_window_print(struct cmd *self, char *buf, size_t len)
-{
-	struct cmd_new_window_data	*data = self->data;
-	size_t				 off = 0;
-
-	off += xsnprintf(buf, len, "%s", self->entry->name);
-	if (data == NULL)
-		return (off);
-	if (off < len && data->flag_detached)
-		off += xsnprintf(buf + off, len - off, " -d");
-	if (off < len && data->target != NULL)
-		off += cmd_prarg(buf + off, len - off, " -t ", data->target);
-	if (off < len && data->name != NULL)
-		off += cmd_prarg(buf + off, len - off, " -n ", data->name);
-	if (off < len && data->cmd != NULL)
-		off += cmd_prarg(buf + off, len - off, " ", data->cmd);
-	return (off);
-}

cmd-next-layout.c

@@ -1,54 +0,0 @@
-/* $Id: cmd-next-layout.c,v 1.6 2009-11-14 17:56:39 tcunha Exp $ */
-
-/*
- * Copyright (c) 2009 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 "tmux.h"
-
-/*
- * Switch window to next layout.
- */
-
-int	cmd_next_layout_exec(struct cmd *, struct cmd_ctx *);
-
-const struct cmd_entry cmd_next_layout_entry = {
-	"next-layout", "nextl",
-	CMD_TARGET_WINDOW_USAGE,
-	0, "",
-	cmd_target_init,
-	cmd_target_parse,
-	cmd_next_layout_exec,
-	cmd_target_free,
-	cmd_target_print
-};
-
-int
-cmd_next_layout_exec(struct cmd *self, struct cmd_ctx *ctx)
-{
-	struct cmd_target_data	*data = self->data;
-	struct winlink		*wl;
-	u_int			 layout;
-
-	if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
-		return (-1);
-
-	layout = layout_set_next(wl->window);
-	ctx->info(ctx, "arranging in: %s", layout_set_name(layout));
-
-	return (0);
-}

cmd-next-window.c

@@ -1,76 +0,0 @@
-/* $Id: cmd-next-window.c,v 1.21 2009-11-14 17:56:39 tcunha Exp $ */
-
-/*
- * Copyright (c) 2007 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 "tmux.h"
-
-/*
- * Move to next window.
- */
-
-void	cmd_next_window_init(struct cmd *, int);
-int	cmd_next_window_exec(struct cmd *, struct cmd_ctx *);
-
-const struct cmd_entry cmd_next_window_entry = {
-	"next-window", "next",
-	"[-a] " CMD_TARGET_SESSION_USAGE,
-	0, "a",
-	cmd_next_window_init,
-	cmd_target_parse,
-	cmd_next_window_exec,
-	cmd_target_free,
-	cmd_target_print
-};
-
-void
-cmd_next_window_init(struct cmd *self, int key)
-{
-	struct cmd_target_data	*data;
-
-	cmd_target_init(self, key);
-	data = self->data;
-
-	if (key == ('n' | KEYC_ESCAPE))
-		cmd_set_flag(&data->chflags, 'a');
-}
-
-int
-cmd_next_window_exec(struct cmd *self, struct cmd_ctx *ctx)
-{
-	struct cmd_target_data	*data = self->data;
-	struct session		*s;
-	int			 activity;
-
-	if ((s = cmd_find_session(ctx, data->target)) == NULL)
-		return (-1);
-
-	activity = 0;
-	if (cmd_check_flag(data->chflags, 'a'))
-		activity = 1;
-
-	if (session_next(s, activity) == 0)
-		server_redraw_session(s);
-	else {
-		ctx->error(ctx, "no next window");
-		return (-1);
-	}
-	recalculate_sizes();
-
-	return (0);
-}

cmd-paste-buffer.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-paste-buffer.c,v 1.24 2009-12-04 22:14:47 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,6 +18,7 @@
 
 #include <sys/types.h>
 
+#include <stdlib.h>
 #include <string.h>
 
 #include "tmux.h"
@@ -27,71 +28,91 @@
  */
 
 int	cmd_paste_buffer_exec(struct cmd *, struct cmd_ctx *);
-void	cmd_paste_buffer_lf2cr(struct window_pane *, const char *, size_t);
+
+void	cmd_paste_buffer_filter(
+	    struct window_pane *, const char *, size_t, const char *);
 
 const struct cmd_entry cmd_paste_buffer_entry = {
 	"paste-buffer", "pasteb",
-	"[-dr] " CMD_BUFFER_WINDOW_USAGE,
+	"db:rs:t:", 0, 0,
-	0, "dr",
+	"[-dr] [-s separator] [-b buffer-index] [-t target-pane]",
-	cmd_buffer_init,
+	0,
-	cmd_buffer_parse,
+	NULL,
-	cmd_paste_buffer_exec,
+	NULL,
-	cmd_buffer_free,
+	cmd_paste_buffer_exec
-	cmd_buffer_print
 };
 
 int
 cmd_paste_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_buffer_data	*data = self->data;
+	struct args		*args = self->args;
-	struct winlink		*wl;
 	struct window_pane	*wp;
 	struct session		*s;
 	struct paste_buffer	*pb;
+	const char		*sepstr;
+	char			*cause;
+	int			 buffer;
 
-	if ((wl = cmd_find_window(ctx, data->target, &s)) == NULL)
+	if (cmd_find_pane(ctx, args_get(args, 't'), &s, &wp) == NULL)
 		return (-1);
-	wp = wl->window->active;
 
-	if (data->buffer == -1)
+	if (!args_has(args, 'b'))
-		pb = paste_get_top(&s->buffers);
+		buffer = -1;
 	else {
-		if ((pb = paste_get_index(&s->buffers, data->buffer)) == NULL) {
+		buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
-			ctx->error(ctx, "no buffer %d", data->buffer);
+		if (cause != NULL) {
+			ctx->error(ctx, "buffer %s", cause);
+			xfree(cause);
+			return (-1);
+		}
+	}
+
+	if (buffer == -1)
+		pb = paste_get_top(&global_buffers);
+	else {
+		pb = paste_get_index(&global_buffers, buffer);
+		if (pb == NULL) {
+			ctx->error(ctx, "no buffer %d", buffer);
 			return (-1);
 		}
 	}
 
 	if (pb != NULL) {
-		/* -r means raw data without LF->CR conversion. */
+		sepstr = args_get(args, 's');
-		if (cmd_check_flag(data->chflags, 'r'))
+		if (sepstr == NULL) {
-			bufferevent_write(wp->event, pb->data, pb->size);
+			if (args_has(args, 'r'))
-		else
+				sepstr = "\n";
-			cmd_paste_buffer_lf2cr(wp, pb->data, pb->size);
+			else
+				sepstr = "\r";
+		}
+		cmd_paste_buffer_filter(wp, pb->data, pb->size, sepstr);
 	}
 
 	/* Delete the buffer if -d. */
-	if (cmd_check_flag(data->chflags, 'd')) {
+	if (args_has(args, 'd')) {
-		if (data->buffer == -1)
+		if (buffer == -1)
-			paste_free_top(&s->buffers);
+			paste_free_top(&global_buffers);
 		else
-			paste_free_index(&s->buffers, data->buffer);
+			paste_free_index(&global_buffers, buffer);
 	}
 
 	return (0);
 }
 
-/* Add bytes to a buffer but change every '\n' to '\r'. */
+/* Add bytes to a buffer and filter '\n' according to separator. */
 void
-cmd_paste_buffer_lf2cr(struct window_pane *wp, const char *data, size_t size)
+cmd_paste_buffer_filter(
+    struct window_pane *wp, const char *data, size_t size, const char *sep)
 {
 	const char	*end = data + size;
 	const char	*lf;
+	size_t		 seplen;
 
+	seplen = strlen(sep);
 	while ((lf = memchr(data, '\n', end - data)) != NULL) {
 		if (lf != data)
 			bufferevent_write(wp->event, data, lf - data);
-		bufferevent_write(wp->event, "\r", 1);
+		bufferevent_write(wp->event, sep, seplen);
 		data = lf + 1;
 	}
 

cmd-pipe-pane.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-pipe-pane.c,v 1.10 2009-12-04 22:14:47 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -22,6 +22,7 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <string.h>
+#include <time.h>
 #include <unistd.h>
 
 #include "tmux.h"
@@ -36,24 +37,26 @@ void	cmd_pipe_pane_error_callback(struct bufferevent *, short, void *);
 
 const struct cmd_entry cmd_pipe_pane_entry = {
 	"pipe-pane", "pipep",
-	CMD_TARGET_PANE_USAGE "[-o] [command]",
+	"ot:", 0, 1,
-	CMD_ARG01, "o",
+	"[-o] " CMD_TARGET_PANE_USAGE " [command]",
-	cmd_target_init,
+	0,
-	cmd_target_parse,
+	NULL,
-	cmd_pipe_pane_exec,
+	NULL,
-	cmd_target_free,
+	cmd_pipe_pane_exec
-	cmd_target_print
 };
 
 int
 cmd_pipe_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data	*data = self->data;
+	struct args		*args = self->args;
+	struct client		*c;
 	struct window_pane	*wp;
-	int			 old_fd, pipe_fd[2], null_fd, mode;
+	char			*command;
+	int			 old_fd, pipe_fd[2], null_fd;
 
-	if (cmd_find_pane(ctx, data->target, NULL, &wp) == NULL)
+	if (cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp) == NULL)
 		return (-1);
+	c = cmd_find_client(ctx, NULL);
 
 	/* Destroy the old pipe. */
 	old_fd = wp->pipe_fd;
@@ -64,7 +67,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 	}
 
 	/* If no pipe command, that is enough. */
-	if (data->arg == NULL || *data->arg == '\0')
+	if (args->argc == 0 || *args->argv[0] == '\0')
 		return (0);
 
 	/*
@@ -73,7 +76,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 	 *
 	 *	bind ^p pipep -o 'cat >>~/output'
 	 */
-	if (cmd_check_flag(data->chflags, 'o') && old_fd != -1)
+	if (args_has(self->args, 'o') && old_fd != -1)
 		return (0);
 
 	/* Open the new pipe. */
@@ -90,7 +93,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 	case 0:
 		/* Child process. */
 		close(pipe_fd[0]);
-		server_signal_clear();
+		clear_signals(1);
 
 		if (dup2(pipe_fd[1], STDIN_FILENO) == -1)
 			_exit(1);
@@ -105,7 +108,11 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 		if (null_fd != STDOUT_FILENO && null_fd != STDERR_FILENO)
 			close(null_fd);
 
-		execl(_PATH_BSHELL, "sh", "-c", data->arg, (char *) NULL);
+		closefrom(STDERR_FILENO + 1);
+
+		command = status_replace(
+		    c, NULL, NULL, NULL, args->argv[0], time(NULL), 0);
+		execl(_PATH_BSHELL, "sh", "-c", command, (char *) NULL);
 		_exit(1);
 	default:
 		/* Parent process. */
@@ -118,12 +125,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 		    NULL, NULL, cmd_pipe_pane_error_callback, wp);
 		bufferevent_enable(wp->pipe_event, EV_WRITE);
 
-		if ((mode = fcntl(wp->pipe_fd, F_GETFL)) == -1)
+		setblocking(wp->pipe_fd, 0);
-			fatal("fcntl failed");
-		if (fcntl(wp->pipe_fd, F_SETFL, mode|O_NONBLOCK) == -1)
-			fatal("fcntl failed");
-		if (fcntl(wp->pipe_fd, F_SETFD, FD_CLOEXEC) == -1)
-			fatal("fcntl failed");
 		return (0);
 	}
 }

cmd-previous-layout.c

@@ -1,54 +0,0 @@
-/* $Id: cmd-previous-layout.c,v 1.6 2009-12-04 22:14:47 tcunha Exp $ */
-
-/*
- * Copyright (c) 2009 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 "tmux.h"
-
-/*
- * Switch window to previous layout.
- */
-
-int	cmd_previous_layout_exec(struct cmd *, struct cmd_ctx *);
-
-const struct cmd_entry cmd_previous_layout_entry = {
-	"previous-layout", "prevl",
-	CMD_TARGET_WINDOW_USAGE,
-	0, "",
-	cmd_target_init,
-	cmd_target_parse,
-	cmd_previous_layout_exec,
-	cmd_target_free,
-	cmd_target_print
-};
-
-int
-cmd_previous_layout_exec(struct cmd *self, struct cmd_ctx *ctx)
-{
-	struct cmd_target_data	*data = self->data;
-	struct winlink		*wl;
-	u_int			 layout;
-
-	if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
-		return (-1);
-
-	layout = layout_set_previous(wl->window);
-	ctx->info(ctx, "arranging in: %s", layout_set_name(layout));
-
-	return (0);
-}

cmd-previous-window.c

@@ -1,76 +0,0 @@
-/* $Id: cmd-previous-window.c,v 1.21 2009-11-14 17:56:39 tcunha Exp $ */
-
-/*
- * Copyright (c) 2007 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 "tmux.h"
-
-/*
- * Move to previous window.
- */
-
-void	cmd_previous_window_init(struct cmd *, int);
-int	cmd_previous_window_exec(struct cmd *, struct cmd_ctx *);
-
-const struct cmd_entry cmd_previous_window_entry = {
-	"previous-window", "prev",
-	"[-a] " CMD_TARGET_SESSION_USAGE,
-	0, "a",
-	cmd_previous_window_init,
-	cmd_target_parse,
-	cmd_previous_window_exec,
-	cmd_target_free,
-	cmd_target_print
-};
-
-void
-cmd_previous_window_init(struct cmd *self, int key)
-{
-	struct cmd_target_data	*data;
-
-	cmd_target_init(self, key);
-	data = self->data;
-
-	if (key == ('p' | KEYC_ESCAPE))
-		cmd_set_flag(&data->chflags, 'a');
-}
-
-int
-cmd_previous_window_exec(struct cmd *self, struct cmd_ctx *ctx)
-{
-	struct cmd_target_data	*data = self->data;
-	struct session		*s;
-	int			 activity;
-
-	if ((s = cmd_find_session(ctx, data->target)) == NULL)
-		return (-1);
-
-	activity = 0;
-	if (cmd_check_flag(data->chflags, 'a'))
-		activity = 1;
-
-	if (session_previous(s, activity) == 0)
-		server_redraw_session(s);
-	else {
-		ctx->error(ctx, "no previous window");
-		return (-1);
-	}
-	recalculate_sizes();
-
-	return (0);
-}

cmd-refresh-client.c

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

cmd-rename-session.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-rename-session.c,v 1.19 2009-11-14 17:56:39 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -30,26 +30,38 @@ int	cmd_rename_session_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_rename_session_entry = {
 	"rename-session", "rename",
+	"t:", 1, 1,
 	CMD_TARGET_SESSION_USAGE " new-name",
-	CMD_ARG1, "",
+	0,
-	cmd_target_init,
+	NULL,
-	cmd_target_parse,
+	NULL,
-	cmd_rename_session_exec,
+	cmd_rename_session_exec
-	cmd_target_free,
-	cmd_target_print
 };
 
 int
 cmd_rename_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data	*data = self->data;
+	struct args	*args = self->args;
-	struct session		*s;
+	struct session	*s;
+	const char	*newname;
 
-	if ((s = cmd_find_session(ctx, data->target)) == NULL)
+	newname = args->argv[0];
+	if (!session_check_name(newname)) {
+		ctx->error(ctx, "bad session name: %s", newname);
+		return (-1);
+	}
+	if (session_find(newname) != NULL) {
+		ctx->error(ctx, "duplicate session: %s", newname);
+		return (-1);
+	}
+
+	if ((s = cmd_find_session(ctx, args_get(args, 't'), 0)) == NULL)
 		return (-1);
 
+	RB_REMOVE(sessions, &sessions, s);
 	xfree(s->name);
-	s->name = xstrdup(data->arg);
+	s->name = xstrdup(newname);
+	RB_INSERT(sessions, &sessions, s);
 
 	server_status_session(s);
 

cmd-rename-window.c

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

cmd-resize-pane.c

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

cmd-respawn-pane.c

@@ -0,0 +1,91 @@
+/* $Id$ */
+
+/*
+ * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2011 Marcel P. Partap <mpartap@gmx.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 <unistd.h>
+
+#include "tmux.h"
+
+/*
+ * Respawn a pane (restart the command). Kill existing if -k given.
+ */
+
+int	cmd_respawn_pane_exec(struct cmd *, struct cmd_ctx *);
+
+const struct cmd_entry cmd_respawn_pane_entry = {
+	"respawn-pane", "respawnp",
+	"kt:", 0, 1,
+	"[-k] " CMD_TARGET_PANE_USAGE " [command]",
+	0,
+	NULL,
+	NULL,
+	cmd_respawn_pane_exec
+};
+
+int
+cmd_respawn_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
+{
+	struct args		*args = self->args;
+	struct winlink		*wl;
+	struct window		*w;
+	struct window_pane	*wp;
+	struct session		*s;
+	struct environ		 env;
+	const char		*cmd;
+	char			*cause;
+	u_int			 idx;
+
+	if ((wl = cmd_find_pane(ctx, args_get(args, 't'), &s, &wp)) == NULL)
+		return (-1);
+	w = wl->window;
+
+	if (!args_has(self->args, 'k') && wp->fd != -1) {
+		if (window_pane_index(wp, &idx) != 0)
+			fatalx("index not found");
+		ctx->error(ctx, "pane still active: %s:%u.%u",
+		    s->name, wl->idx, idx);
+		return (-1);
+	}
+
+	environ_init(&env);
+	environ_copy(&global_environ, &env);
+	environ_copy(&s->environ, &env);
+	server_fill_environ(s, &env);
+
+	window_pane_reset_mode(wp);
+	screen_reinit(&wp->base);
+	input_init(wp);
+
+	if (args->argc != 0)
+		cmd = args->argv[0];
+	else
+		cmd = NULL;
+	if (window_pane_spawn(wp, cmd, NULL, NULL, &env, s->tio, &cause) != 0) {
+		ctx->error(ctx, "respawn pane failed: %s", cause);
+		xfree(cause);
+		environ_free(&env);
+		return (-1);
+	}
+	wp->flags |= PANE_REDRAW;
+	server_status_window(w);
+
+	environ_free(&env);
+	return (0);
+}

cmd-respawn-window.c

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

cmd-rotate-window.c

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

cmd-run-shell.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-run-shell.c,v 1.6 2009-11-14 17:56:39 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -35,13 +35,12 @@ void	cmd_run_shell_free(void *);
 
 const struct cmd_entry cmd_run_shell_entry = {
 	"run-shell", "run",
+	"", 1, 1,
 	"command",
-	CMD_ARG1, "",
+	0,
-	cmd_target_init,
+	NULL,
-	cmd_target_parse,
+	NULL,
-	cmd_run_shell_exec,
+	cmd_run_shell_exec
-	cmd_target_free,
-	cmd_target_print
 };
 
 struct cmd_run_shell_data {
@@ -52,12 +51,12 @@ struct cmd_run_shell_data {
 int
 cmd_run_shell_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data		*data = self->data;
+	struct args			*args = self->args;
 	struct cmd_run_shell_data	*cdata;
-	struct job			*job;
+	const char			*shellcmd = args->argv[0];
 
 	cdata = xmalloc(sizeof *cdata);
-	cdata->cmd = xstrdup(data->arg);
+	cdata->cmd = xstrdup(args->argv[0]);
 	memcpy(&cdata->ctx, ctx, sizeof cdata->ctx);
 
 	if (ctx->cmdclient != NULL)
@@ -65,9 +64,7 @@ cmd_run_shell_exec(struct cmd *self, struct cmd_ctx *ctx)
 	if (ctx->curclient != NULL)
 		ctx->curclient->references++;
 
-	job = job_add(NULL, 0, NULL,
+	job_run(shellcmd, cmd_run_shell_callback, cmd_run_shell_free, cdata);
-	    data->arg, cmd_run_shell_callback, cmd_run_shell_free, cdata);
-	job_run(job);
 
 	return (1);	/* don't let client exit */
 }
@@ -82,6 +79,11 @@ cmd_run_shell_callback(struct job *job)
 	int				 retcode;
 	u_int				 lines;
 
+	if (ctx->cmdclient != NULL && ctx->cmdclient->flags & CLIENT_DEAD)
+		return;
+	if (ctx->curclient != NULL && ctx->curclient->flags & CLIENT_DEAD)
+		return;
+
 	lines = 0;
 	do {
 		if ((line = evbuffer_readline(job->event->input)) != NULL) {
@@ -129,7 +131,7 @@ cmd_run_shell_free(void *data)
 
 	if (ctx->cmdclient != NULL) {
 		ctx->cmdclient->references--;
-		server_write_client(ctx->cmdclient, MSG_EXIT, NULL, 0);
+		ctx->cmdclient->flags |= CLIENT_EXIT;
 	}
 	if (ctx->curclient != NULL)
 		ctx->curclient->references--;

cmd-save-buffer.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-save-buffer.c,v 1.10 2009-11-14 17:56:39 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -25,64 +25,93 @@
 #include "tmux.h"
 
 /*
- * Saves a session paste buffer to a file.
+ * Saves a paste buffer to a file.
  */
 
 int	cmd_save_buffer_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_save_buffer_entry = {
 	"save-buffer", "saveb",
-	"[-a] " CMD_BUFFER_SESSION_USAGE " path",
+	"ab:", 1, 1,
-	CMD_ARG1, "a",
+	"[-a] " CMD_BUFFER_USAGE,
-	cmd_buffer_init,
+	0,
-	cmd_buffer_parse,
+	NULL,
-	cmd_save_buffer_exec,
+	NULL,
-	cmd_buffer_free,
+	cmd_save_buffer_exec
-	cmd_buffer_print
 };
 
 int
 cmd_save_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_buffer_data	*data = self->data;
+	struct args		*args = self->args;
-	struct session		*s;
+	struct client		*c = ctx->cmdclient;
+	struct session          *s;
 	struct paste_buffer	*pb;
-	mode_t			mask;
+	const char		*path, *newpath, *wd;
+	char			*cause;
+	int			 buffer;
+	mode_t			 mask;
 	FILE			*f;
 
-	if ((s = cmd_find_session(ctx, data->target)) == NULL)
+	if (!args_has(args, 'b')) {
-		return (-1);
+		if ((pb = paste_get_top(&global_buffers)) == NULL) {
-
-	if (data->buffer == -1) {
-		if ((pb = paste_get_top(&s->buffers)) == NULL) {
 			ctx->error(ctx, "no buffers");
 			return (-1);
 		}
 	} else {
-		if ((pb = paste_get_index(&s->buffers, data->buffer)) == NULL) {
+		buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
-			ctx->error(ctx, "no buffer %d", data->buffer);
+		if (cause != NULL) {
+			ctx->error(ctx, "buffer %s", cause);
+			xfree(cause);
+			return (-1);
+		}
+
+		pb = paste_get_index(&global_buffers, buffer);
+		if (pb == NULL) {
+			ctx->error(ctx, "no buffer %d", buffer);
 			return (-1);
 		}
 	}
 
-	mask = umask(S_IRWXG | S_IRWXO);
+	path = args->argv[0];
-	if (cmd_check_flag(data->chflags, 'a'))
+	if (strcmp(path, "-") == 0) {
-		f = fopen(data->arg, "ab");
+		if (c == NULL) {
-	else
+			ctx->error(ctx, "%s: can't write to stdout", path);
-		f = fopen(data->arg, "wb");
+			return (-1);
-	umask(mask);
+		}
-	if (f == NULL) {
+		bufferevent_write(c->stdout_event, pb->data, pb->size);
-		ctx->error(ctx, "%s: %s", data->arg, strerror(errno));
+	} else {
-		return (-1);
+		if (c != NULL)
-	}
+			wd = c->cwd;
+		else if ((s = cmd_current_session(ctx, 0)) != NULL) {
+			wd = options_get_string(&s->options, "default-path");
+			if (*wd == '\0')
+				wd = s->cwd;
+		} else
+			wd = NULL;
+		if (wd != NULL && *wd != '\0') {
+			newpath = get_full_path(wd, path);
+			if (newpath != NULL)
+				path = newpath;
+		}
 
-	if (fwrite(pb->data, 1, pb->size, f) != pb->size) {
+		mask = umask(S_IRWXG | S_IRWXO);
-	    	ctx->error(ctx, "%s: fwrite error", data->arg);
+		if (args_has(self->args, 'a'))
-	    	fclose(f);
+			f = fopen(path, "ab");
-	    	return (-1);
+		else
+			f = fopen(path, "wb");
+		umask(mask);
+		if (f == NULL) {
+			ctx->error(ctx, "%s: %s", path, strerror(errno));
+			return (-1);
+		}
+		if (fwrite(pb->data, 1, pb->size, f) != pb->size) {
+			ctx->error(ctx, "%s: fwrite error", path);
+			fclose(f);
+			return (-1);
+		}
+		fclose(f);
 	}
 
-	fclose(f);
-
 	return (0);
 }

cmd-select-layout.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-select-layout.c,v 1.10 2009-12-04 22:14:47 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -24,40 +24,60 @@
  * Switch window to selected layout.
  */
 
-void	cmd_select_layout_init(struct cmd *, int);
+void	cmd_select_layout_key_binding(struct cmd *, int);
 int	cmd_select_layout_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_select_layout_entry = {
 	"select-layout", "selectl",
-	CMD_TARGET_WINDOW_USAGE " [layout-name]",
+	"npt:", 0, 1,
-	CMD_ARG01, "",
+	"[-np] " CMD_TARGET_WINDOW_USAGE " [layout-name]",
-	cmd_select_layout_init,
+	0,
-	cmd_target_parse,
+	cmd_select_layout_key_binding,
-	cmd_select_layout_exec,
+	NULL,
-	cmd_target_free,
+	cmd_select_layout_exec
-	cmd_target_print
+};
+
+const struct cmd_entry cmd_next_layout_entry = {
+	"next-layout", "nextl",
+	"t:", 0, 0,
+	CMD_TARGET_WINDOW_USAGE,
+	0,
+	NULL,
+	NULL,
+	cmd_select_layout_exec
+};
+
+const struct cmd_entry cmd_previous_layout_entry = {
+	"previous-layout", "prevl",
+	"t:", 0, 0,
+	CMD_TARGET_WINDOW_USAGE,
+	0,
+	NULL,
+	NULL,
+	cmd_select_layout_exec
 };
 
 void
-cmd_select_layout_init(struct cmd *self, int key)
+cmd_select_layout_key_binding(struct cmd *self, int key)
 {
-	struct cmd_target_data	*data;
-
-	cmd_target_init(self, key);
-	data = self->data;
-
 	switch (key) {
-	case ('1' | KEYC_ESCAPE):
+	case '1' | KEYC_ESCAPE:
-		data->arg = xstrdup("even-horizontal");
+		self->args = args_create(1, "even-horizontal");
 		break;
-	case ('2' | KEYC_ESCAPE):
+	case '2' | KEYC_ESCAPE:
-		data->arg = xstrdup("even-vertical");
+		self->args = args_create(1, "even-vertical");
 		break;
-	case ('3' | KEYC_ESCAPE):
+	case '3' | KEYC_ESCAPE:
-		data->arg = xstrdup("main-horizontal");
+		self->args = args_create(1, "main-horizontal");
 		break;
-	case ('4' | KEYC_ESCAPE):
+	case '4' | KEYC_ESCAPE:
-		data->arg = xstrdup("main-vertical");
+		self->args = args_create(1, "main-vertical");
+		break;
+	case '5' | KEYC_ESCAPE:
+		self->args = args_create(1, "tiled");
+		break;
+	default:
+		self->args = args_create(0);
 		break;
 	}
 }
@@ -65,24 +85,49 @@ cmd_select_layout_init(struct cmd *self, int key)
 int
 cmd_select_layout_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data	*data = self->data;
+	struct args	*args = self->args;
-	struct winlink		*wl;
+	struct winlink	*wl;
-	int			 layout;
+	const char	*layoutname;
+	int		 next, previous, layout;
 
-	if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
+	if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
 		return (-1);
 
-	if (data->arg == NULL) {
+	next = self->entry == &cmd_next_layout_entry;
-		layout = wl->window->lastlayout;
+	if (args_has(self->args, 'n'))
-		if (layout == -1)
+		next = 1;
-			return (0);
+	previous = self->entry == &cmd_previous_layout_entry;
-	} else if ((layout = layout_set_lookup(data->arg)) == -1) {
+	if (args_has(self->args, 'p'))
-		ctx->error(ctx, "unknown layout or ambiguous: %s", data->arg);
+		previous = 1;
-		return (-1);
+
+	if (next || previous) {
+		if (next)
+			layout = layout_set_next(wl->window);
+		else
+			layout = layout_set_previous(wl->window);
+		ctx->info(ctx, "arranging in: %s", layout_set_name(layout));
+		return (0);
 	}
 
-	layout = layout_set_select(wl->window, layout);
+	if (args->argc == 0)
-	ctx->info(ctx, "arranging in: %s", layout_set_name(layout));
+		layout = wl->window->lastlayout;
+	else
+		layout = layout_set_lookup(args->argv[0]);
+	if (layout != -1) {
+		layout = layout_set_select(wl->window, layout);
+		ctx->info(ctx, "arranging in: %s", layout_set_name(layout));
+		return (0);
+	}
+
+	if (args->argc != 0) {
+		layoutname = args->argv[0];
+		if (layout_parse(wl->window, layoutname) == -1) {
+			ctx->error(ctx, "can't set layout: %s", layoutname);
+			return (-1);
+		}
+		ctx->info(ctx, "arranging in: %s", layoutname);
+		return (0);
+	}
 
 	return (0);
 }

cmd-select-pane.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-select-pane.c,v 1.12 2010-01-05 23:52:37 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -24,33 +24,90 @@
  * Select pane.
  */
 
+void	cmd_select_pane_key_binding(struct cmd *, int);
 int	cmd_select_pane_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_select_pane_entry = {
 	"select-pane", "selectp",
-	CMD_TARGET_PANE_USAGE,
+	"lDLRt:U", 0, 0,
-	0, "",
+	"[-lDLRU] " CMD_TARGET_PANE_USAGE,
-	cmd_target_init,
+	0,
-	cmd_target_parse,
+	cmd_select_pane_key_binding,
-	cmd_select_pane_exec,
+	NULL,
-	cmd_target_free,
+	cmd_select_pane_exec
-	cmd_target_print
 };
 
+const struct cmd_entry cmd_last_pane_entry = {
+	"last-pane", "lastp",
+	"t:", 0, 0,
+	CMD_TARGET_WINDOW_USAGE,
+	0,
+	NULL,
+	NULL,
+	cmd_select_pane_exec
+};
+
+void
+cmd_select_pane_key_binding(struct cmd *self, int key)
+{
+	self->args = args_create(0);
+	if (key == KEYC_UP)
+		args_set(self->args, 'U', NULL);
+	if (key == KEYC_DOWN)
+		args_set(self->args, 'D', NULL);
+	if (key == KEYC_LEFT)
+		args_set(self->args, 'L', NULL);
+	if (key == KEYC_RIGHT)
+		args_set(self->args, 'R', NULL);
+	if (key == 'o')
+		args_set(self->args, 't', ":.+");
+}
+
 int
 cmd_select_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data	*data = self->data;
+	struct args		*args = self->args;
 	struct winlink		*wl;
 	struct window_pane	*wp;
 
-	if ((wl = cmd_find_pane(ctx, data->target, NULL, &wp)) == NULL)
+	if (self->entry == &cmd_last_pane_entry || args_has(args, 'l')) {
+		wl = cmd_find_window(ctx, args_get(args, 't'), NULL);
+		if (wl == NULL)
+			return (-1);
+
+		if (wl->window->last == NULL) {
+			ctx->error(ctx, "no last pane");
+			return (-1);
+		}
+
+		window_set_active_pane(wl->window, wl->window->last);
+		server_status_window(wl->window);
+		server_redraw_window_borders(wl->window);
+
+		return (0);
+	}
+
+	if ((wl = cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp)) == NULL)
 		return (-1);
 
 	if (!window_pane_visible(wp)) {
-		ctx->error(ctx, "pane not visible: %s", data->target);
+		ctx->error(ctx, "pane not visible");
 		return (-1);
 	}
+
+	if (args_has(self->args, 'L'))
+		wp = window_pane_find_left(wp);
+	else if (args_has(self->args, 'R'))
+		wp = window_pane_find_right(wp);
+	else if (args_has(self->args, 'U'))
+		wp = window_pane_find_up(wp);
+	else if (args_has(self->args, 'D'))
+		wp = window_pane_find_down(wp);
+	if (wp == NULL) {
+		ctx->error(ctx, "pane not found");
+		return (-1);
+	}
+
 	window_set_active_pane(wl->window, wp);
 	server_status_window(wl->window);
 	server_redraw_window_borders(wl->window);

cmd-select-prompt.c

@@ -1,91 +0,0 @@
-/* $Id: cmd-select-prompt.c,v 1.13 2009-11-14 17:56:39 tcunha Exp $ */
-
-/*
- * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
- * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include <sys/types.h>
-
-#include <stdlib.h>
-
-#include "tmux.h"
-
-/*
- * Prompt for window index and select it.
- */
-
-int	cmd_select_prompt_exec(struct cmd *, struct cmd_ctx *);
-
-int	cmd_select_prompt_callback(void *, const char *);
-
-const struct cmd_entry cmd_select_prompt_entry = {
-	"select-prompt", NULL,
-	CMD_TARGET_CLIENT_USAGE,
-	0, "",
-	cmd_target_init,
-	cmd_target_parse,
-	cmd_select_prompt_exec,
-	cmd_target_free,
-	cmd_target_print
-};
-
-int
-cmd_select_prompt_exec(struct cmd *self, struct cmd_ctx *ctx)
-{
-	struct cmd_target_data	*data = self->data;
-	struct client		*c;
-
-	if ((c = cmd_find_client(ctx, data->target)) == NULL)
-		return (-1);
-
-	if (c->prompt_string != NULL)
-		return (0);
-
-	status_prompt_set(c, "index ", cmd_select_prompt_callback, NULL, c, 0);
-
-	return (0);
-}
-
-int
-cmd_select_prompt_callback(void *data, const char *s)
-{
-	struct client	*c = data;
-	const char	*errstr;
-	char		 msg[128];
-	u_int		 idx;
-
-	if (s == NULL || *s == '\0')
-		return (0);
-
-	idx = strtonum(s, 0, UINT_MAX, &errstr);
-	if (errstr != NULL) {
-		xsnprintf(msg, sizeof msg, "Index %s: %s", errstr, s);
-		status_message_set(c, "%s", msg);
-		return (0);
-	}
-
-	if (winlink_find_by_index(&c->session->windows, idx) == NULL) {
-		xsnprintf(msg, sizeof msg,
-		    "Window not found: %s:%d", c->session->name, idx);
-		status_message_set(c, "%s", msg);
-		return (0);
-	}
-
-	if (session_select(c->session, idx) == 0)
-		server_redraw_session(c->session);
-	recalculate_sizes();
-
-	return (0);
-}

cmd-select-window.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-select-window.c,v 1.24 2009-11-14 17:56:39 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -26,43 +26,113 @@
  * Select window by index.
  */
 
-void	cmd_select_window_init(struct cmd *, int);
+void	cmd_select_window_key_binding(struct cmd *, int);
 int	cmd_select_window_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_select_window_entry = {
 	"select-window", "selectw",
-	CMD_TARGET_WINDOW_USAGE,
+	"lnpt:", 0, 0,
-	0, "",
+	"[-lnp] " CMD_TARGET_WINDOW_USAGE,
-	cmd_select_window_init,
+	0,
-	cmd_target_parse,
+	cmd_select_window_key_binding,
-	cmd_select_window_exec,
+	NULL,
-	cmd_target_free,
+	cmd_select_window_exec
-	cmd_target_print
+};
+
+const struct cmd_entry cmd_next_window_entry = {
+	"next-window", "next",
+	"at:", 0, 0,
+	"[-a] " CMD_TARGET_SESSION_USAGE,
+	0,
+	cmd_select_window_key_binding,
+	NULL,
+	cmd_select_window_exec
+};
+
+const struct cmd_entry cmd_previous_window_entry = {
+	"previous-window", "prev",
+	"at:", 0, 0,
+	"[-a] " CMD_TARGET_SESSION_USAGE,
+	0,
+	cmd_select_window_key_binding,
+	NULL,
+	cmd_select_window_exec
+};
+
+const struct cmd_entry cmd_last_window_entry = {
+	"last-window", "last",
+	"t:", 0, 0,
+	CMD_TARGET_SESSION_USAGE,
+	0,
+	NULL,
+	NULL,
+	cmd_select_window_exec
 };
 
 void
-cmd_select_window_init(struct cmd *self, int key)
+cmd_select_window_key_binding(struct cmd *self, int key)
 {
-	struct cmd_target_data	*data;
+	char	tmp[16];
 
-	cmd_target_init(self, key);
+	self->args = args_create(0);
-	data = self->data;
+	if (key >= '0' && key <= '9') {
-
+		xsnprintf(tmp, sizeof tmp, ":%d", key - '0');
-	xasprintf(&data->target, ":%d", key - '0');
+		args_set(self->args, 't', tmp);
+	}
+	if (key == ('n' | KEYC_ESCAPE) || key == ('p' | KEYC_ESCAPE))
+		args_set(self->args, 'a', NULL);
 }
 
 int
 cmd_select_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data	*data = self->data;
+	struct args	*args = self->args;
-	struct winlink		*wl;
+	struct winlink	*wl;
-	struct session		*s;
+	struct session	*s;
+	int		 next, previous, last, activity;
 
-	if ((wl = cmd_find_window(ctx, data->target, &s)) == NULL)
+	next = self->entry == &cmd_next_window_entry;
-		return (-1);
+	if (args_has(self->args, 'n'))
+		next = 1;
+	previous = self->entry == &cmd_previous_window_entry;
+	if (args_has(self->args, 'p'))
+		previous = 1;
+	last = self->entry == &cmd_last_window_entry;
+	if (args_has(self->args, 'l'))
+		last = 1;
+
+	if (next || previous || last) {
+		s = cmd_find_session(ctx, args_get(args, 't'), 0);
+		if (s == NULL)
+			return (-1);
+
+		activity = args_has(self->args, 'a');
+		if (next) {
+			if (session_next(s, activity) != 0) {
+				ctx->error(ctx, "no next window");
+				return (-1);
+			}
+		} else if (previous) {
+			if (session_previous(s, activity) != 0) {
+				ctx->error(ctx, "no previous window");
+				return (-1);
+			}
+		} else {
+			if (session_last(s) != 0) {
+				ctx->error(ctx, "no last window");
+				return (-1);
+			}
+		}
 
-	if (session_select(s, wl->idx) == 0)
 		server_redraw_session(s);
+	} else {
+		wl = cmd_find_window(ctx, args_get(args, 't'), &s);
+		if (wl == NULL)
+			return (-1);
+
+		if (session_select(s, wl->idx) == 0)
+			server_redraw_session(s);
+	}
 	recalculate_sizes();
 
 	return (0);

cmd-send-keys.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-send-keys.c,v 1.24 2009-12-04 22:14:47 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -19,6 +19,7 @@
 #include <sys/types.h>
 
 #include <stdlib.h>
+#include <string.h>
 
 #include "tmux.h"
 
@@ -26,127 +27,57 @@
  * Send keys to client.
  */
 
-int	cmd_send_keys_parse(struct cmd *, int, char **, char **);
 int	cmd_send_keys_exec(struct cmd *, struct cmd_ctx *);
-void	cmd_send_keys_free(struct cmd *);
-size_t	cmd_send_keys_print(struct cmd *, char *, size_t);
-
-struct cmd_send_keys_data {
-	char	*target;
-	u_int	 nkeys;
-	int	*keys;
-};
 
 const struct cmd_entry cmd_send_keys_entry = {
 	"send-keys", "send",
-	"[-t target-pane] key ...",
+	"Rt:", 0, -1,
-	0, "",
+	"[-R] [-t target-pane] key ...",
+	0,
 	NULL,
-	cmd_send_keys_parse,
+	NULL,
-	cmd_send_keys_exec,
+	cmd_send_keys_exec
-	cmd_send_keys_free,
-	cmd_send_keys_print
 };
 
-int
-cmd_send_keys_parse(struct cmd *self, int argc, char **argv, char **cause)
-{
-	struct cmd_send_keys_data	*data;
-	int				 opt, key;
-	char				*s;
-
-	self->data = data = xmalloc(sizeof *data);
-	data->target = NULL;
-	data->nkeys = 0;
-	data->keys = NULL;
-
-	while ((opt = getopt(argc, argv, "t:")) != -1) {
-		switch (opt) {
-		case 't':
-			if (data->target == NULL)
-				data->target = xstrdup(optarg);
-			break;
-		default:
-			goto usage;
-		}
-	}
-	argc -= optind;
-	argv += optind;
-	if (argc == 0)
-		goto usage;
-
-	while (argc-- != 0) {
-		if ((key = key_string_lookup_string(*argv)) != KEYC_NONE) {
-			data->keys = xrealloc(
-			    data->keys, data->nkeys + 1, sizeof *data->keys);
-			data->keys[data->nkeys++] = key;
-		} else {
-			for (s = *argv; *s != '\0'; s++) {
-				data->keys = xrealloc(data->keys,
-				    data->nkeys + 1, sizeof *data->keys);
-				data->keys[data->nkeys++] = *s;
-			}
-		}
-
-		argv++;
-	}
-
-	return (0);
-
-usage:
-	xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
-
-	self->entry->free(self);
-	return (-1);
-}
-
 int
 cmd_send_keys_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_send_keys_data	*data = self->data;
+	struct args		*args = self->args;
-	struct window_pane		*wp;
+	struct window_pane	*wp;
-	u_int				 i;
+	struct session		*s;
+	struct input_ctx	*ictx;
+	const char		*str;
+	int			 i, key;
 
-	if (data == NULL)
+	if (cmd_find_pane(ctx, args_get(args, 't'), &s, &wp) == NULL)
 		return (-1);
 
-	if (cmd_find_pane(ctx, data->target, NULL, &wp) == NULL)
+	if (args_has(args, 'R')) {
-		return (-1);
+		ictx = &wp->ictx;
 
-	for (i = 0; i < data->nkeys; i++)
+		memcpy(&ictx->cell, &grid_default_cell, sizeof ictx->cell);
-		window_pane_key(wp, ctx->curclient, data->keys[i]);
+		memcpy(&ictx->old_cell, &ictx->cell, sizeof ictx->old_cell);
+		ictx->old_cx = 0;
+		ictx->old_cy = 0;
+
+		if (wp->mode == NULL)
+			screen_write_start(&ictx->ctx, wp, &wp->base);
+		else
+			screen_write_start(&ictx->ctx, NULL, &wp->base);
+		screen_write_reset(&ictx->ctx);
+		screen_write_stop(&ictx->ctx);
+	}
+
+	for (i = 0; i < args->argc; i++) {
+		str = args->argv[i];
+
+		if ((key = key_string_lookup_string(str)) != KEYC_NONE) {
+			    window_pane_key(wp, s, key);
+		} else {
+			for (; *str != '\0'; str++)
+			    window_pane_key(wp, s, *str);
+		}
+	}
 
 	return (0);
 }
-
-void
-cmd_send_keys_free(struct cmd *self)
-{
-	struct cmd_send_keys_data	*data = self->data;
-
-	if (data->target != NULL)
-		xfree(data->target);
-	xfree(data);
-}
-
-size_t
-cmd_send_keys_print(struct cmd *self, char *buf, size_t len)
-{
-	struct cmd_send_keys_data	*data = self->data;
-	size_t				 off = 0;
-	u_int				 i;
-
-	off += xsnprintf(buf, len, "%s", self->entry->name);
-	if (data == NULL)
-		return (off);
-	if (off < len && data->target != NULL)
-		off += cmd_prarg(buf + off, len - off, " -t ", data->target);
-
-	for (i = 0; i < data->nkeys; i++) {
-		if (off >= len)
-			break;
-		off += xsnprintf(buf + off,
-		    len - off, " %s", key_string_lookup_key(data->keys[i]));
-	}
-	return (off);
-}

cmd-send-prefix.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-send-prefix.c,v 1.28 2009-11-14 17:56:39 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -28,28 +28,30 @@ int	cmd_send_prefix_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_send_prefix_entry = {
 	"send-prefix", NULL,
-	CMD_TARGET_PANE_USAGE,
+	"2t:", 0, 0,
-	0, "",
+	"[-2] " CMD_TARGET_PANE_USAGE,
-	cmd_target_init,
+	0,
-	cmd_target_parse,
+	NULL,
-	cmd_send_prefix_exec,
+	NULL,
-	cmd_target_free,
+	cmd_send_prefix_exec
-	cmd_target_print
 };
 
 int
 cmd_send_prefix_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data	*data = self->data;
+	struct args		*args = self->args;
 	struct session		*s;
 	struct window_pane	*wp;
-	struct keylist		*keylist;
+	int			 key;
 
-	if (cmd_find_pane(ctx, data->target, &s, &wp) == NULL)
+	if (cmd_find_pane(ctx, args_get(args, 't'), &s, &wp) == NULL)
 		return (-1);
 
-	keylist = options_get_data(&s->options, "prefix");
+	if (args_has(args, '2'))
-	window_pane_key(wp, ctx->curclient, ARRAY_FIRST(keylist));
+		key = options_get_number(&s->options, "prefix2");
+	else
+		key = options_get_number(&s->options, "prefix");
+	window_pane_key(wp, s, key);
 
 	return (0);
 }

cmd-server-info.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-server-info.c,v 1.37 2009-12-10 16:59:02 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -34,45 +34,44 @@ int	cmd_server_info_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_server_info_entry = {
 	"server-info", "info",
+	"", 0, 0,
 	"",
-	0, "",
+	0,
 	NULL,
 	NULL,
-	cmd_server_info_exec,
+	cmd_server_info_exec
-	NULL,
-	NULL
 };
 
 /* ARGSUSED */
 int
 cmd_server_info_exec(unused struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct tty_term			*term;
+	struct tty_term				*term;
-	struct client			*c;
+	struct client				*c;
-	struct session			*s;
+	struct session				*s;
-	struct winlink			*wl;
+	struct winlink				*wl;
-	struct window			*w;
+	struct window				*w;
-	struct window_pane		*wp;
+	struct window_pane			*wp;
-	struct tty_code			*code;
+	struct tty_code				*code;
-	struct tty_term_code_entry	*ent;
+	const struct tty_term_code_entry	*ent;
-	struct utsname			 un;
+	struct utsname				 un;
-	struct job			*job;
+	struct job				*job;
-	struct grid			*gd;
+	struct grid				*gd;
-	struct grid_line		*gl;
+	struct grid_line			*gl;
-	u_int		 		 i, j, k;
+	u_int		 			 i, j, k;
-	char				 out[80];
+	char					 out[80];
-	char				*tim;
+	char					*tim;
-	time_t		 		 t;
+	time_t		 			 t;
-	u_int				 lines, ulines;
+	u_int					 lines, ulines;
-	size_t				 size, usize;
+	size_t					 size, usize;
 
 	tim = ctime(&start_time);
 	*strchr(tim, '\n') = '\0';
 	ctx->print(ctx,
-	    "tmux " BUILD ", pid %ld, started %s", (long) getpid(), tim);
+	    "tmux " VERSION ", pid %ld, started %s", (long) getpid(), tim);
 	ctx->print(
 	    ctx, "socket path %s, debug level %d", socket_path, debug_level);
-	if (uname(&un) == 0) {
+	if (uname(&un) >= 0) {
 		ctx->print(ctx, "system is %s %s %s %s",
 		    un.sysname, un.release, un.version, un.machine);
 	}
@@ -81,8 +80,6 @@ cmd_server_info_exec(unused struct cmd *self, struct cmd_ctx *ctx)
 	else
 		ctx->print(ctx, "configuration file not specified");
 	ctx->print(ctx, "protocol version is %d", PROTOCOL_VERSION);
-	ctx->print(ctx, "%u clients, %u sessions",
-	    ARRAY_LENGTH(&clients), ARRAY_LENGTH(&sessions));
 	ctx->print(ctx, "%s", "");
 
 	ctx->print(ctx, "Clients:");
@@ -91,29 +88,25 @@ cmd_server_info_exec(unused struct cmd *self, struct cmd_ctx *ctx)
 		if (c == NULL || c->session == NULL)
 			continue;
 
-		ctx->print(ctx, "%2d: %s (%d, %d): %s [%ux%u %s] "
+		ctx->print(ctx,"%2d: %s (%d, %d): %s [%ux%u %s bs=%hho] "
 		    "[flags=0x%x/0x%x, references=%u]", i, c->tty.path,
 		    c->ibuf.fd, c->tty.fd, c->session->name,
-		    c->tty.sx, c->tty.sy, c->tty.termname, c->flags,
+		    c->tty.sx, c->tty.sy, c->tty.termname,
+		    c->tty.tio.c_cc[VERASE], c->flags,
 		    c->tty.flags, c->references);
 	}
 	ctx->print(ctx, "%s", "");
 
 	ctx->print(ctx, "Sessions: [%zu/%zu]",
 	    sizeof (struct grid_cell), sizeof (struct grid_utf8));
-	for (i = 0; i < ARRAY_LENGTH(&sessions); i++) {
+	RB_FOREACH(s, sessions, &sessions) {
-		s = ARRAY_ITEM(&sessions, i);
-		if (s == NULL)
-			continue;
-
 		t = s->creation_time.tv_sec;
 		tim = ctime(&t);
 		*strchr(tim, '\n') = '\0';
 
 		ctx->print(ctx, "%2u: %s: %u windows (created %s) [%ux%u] "
-		    "[flags=0x%x, references=%u]", i, s->name,
+		    "[flags=0x%x]", s->idx, s->name,
-		    winlink_count(&s->windows), tim, s->sx, s->sy, s->flags,
+		    winlink_count(&s->windows), tim, s->sx, s->sy, s->flags);
-		    s->references);
 		RB_FOREACH(wl, winlinks, &s->windows) {
 			w = wl->window;
 			ctx->print(ctx, "%4u: %s [%ux%u] [flags=0x%x, "
@@ -149,7 +142,7 @@ cmd_server_info_exec(unused struct cmd *self, struct cmd_ctx *ctx)
 	ctx->print(ctx, "%s", "");
 
 	ctx->print(ctx, "Terminals:");
-	SLIST_FOREACH(term, &tty_terms, entry) {
+	LIST_FOREACH(term, &tty_terms, entry) {
 		ctx->print(ctx, "%s [references=%u, flags=0x%x]:",
 		    term->name, term->references, term->flags);
 		for (i = 0; i < NTTYCODE; i++) {
@@ -181,9 +174,9 @@ cmd_server_info_exec(unused struct cmd *self, struct cmd_ctx *ctx)
 	ctx->print(ctx, "%s", "");
 
 	ctx->print(ctx, "Jobs:");
-	SLIST_FOREACH(job, &all_jobs, lentry) {
+	LIST_FOREACH(job, &all_jobs, lentry) {
-		ctx->print(ctx, "%s [fd=%d, pid=%d, status=%d, flags=0x%x]",
+		ctx->print(ctx, "%s [fd=%d, pid=%d, status=%d]",
-		    job->cmd, job->fd, job->pid, job->status, job->flags);
+		    job->cmd, job->fd, job->pid, job->status);
 	}
 
 	return (0);

cmd-set-buffer.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-set-buffer.c,v 1.12 2009-11-28 14:54:12 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -23,46 +23,53 @@
 #include "tmux.h"
 
 /*
- * Add or set a session paste buffer.
+ * Add or set a paste buffer.
  */
 
 int	cmd_set_buffer_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_set_buffer_entry = {
 	"set-buffer", "setb",
-	CMD_BUFFER_SESSION_USAGE " data",
+	"b:", 1, 1,
-	CMD_ARG1, "",
+	CMD_BUFFER_USAGE " data",
-	cmd_buffer_init,
+	0,
-	cmd_buffer_parse,
+	NULL,
-	cmd_set_buffer_exec,
+	NULL,
-	cmd_buffer_free,
+	cmd_set_buffer_exec
-	cmd_buffer_print
 };
 
 int
 cmd_set_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_buffer_data	*data = self->data;
+	struct args	*args = self->args;
-	struct session		*s;
+	u_int		 limit;
-	u_int			 limit;
+	char		*pdata, *cause;
-	char			*pdata;
+	size_t		 psize;
-	size_t			 psize;
+	int		 buffer;
 
-	if ((s = cmd_find_session(ctx, data->target)) == NULL)
+	limit = options_get_number(&global_options, "buffer-limit");
-		return (-1);
-	limit = options_get_number(&s->options, "buffer-limit");
 
-	pdata = xstrdup(data->arg);
+	pdata = xstrdup(args->argv[0]);
 	psize = strlen(pdata);
 
-	if (data->buffer == -1) {
+	if (!args_has(args, 'b')) {
-		paste_add(&s->buffers, pdata, psize, limit);
+		paste_add(&global_buffers, pdata, psize, limit);
 		return (0);
 	}
-	if (paste_replace(&s->buffers, data->buffer, pdata, psize) != 0) {
+
-		ctx->error(ctx, "no buffer %d", data->buffer);
+	buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
+	if (cause != NULL) {
+		ctx->error(ctx, "buffer %s", cause);
+		xfree(cause);
 		xfree(pdata);
 		return (-1);
 	}
+
+	if (paste_replace(&global_buffers, buffer, pdata, psize) != 0) {
+		ctx->error(ctx, "no buffer %d", buffer);
+		xfree(pdata);
+		return (-1);
+	}
+
 	return (0);
 }

cmd-set-environment.c

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

cmd-set-option.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-set-option.c,v 1.96 2010-02-26 13:31:39 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -29,252 +29,161 @@
 
 int	cmd_set_option_exec(struct cmd *, struct cmd_ctx *);
 
-const char *cmd_set_option_print(
+int	cmd_set_option_find(const char *, const struct options_table_entry **,
-	    const struct set_option_entry *, struct options_entry *);
+	    const struct options_table_entry **);
-void	cmd_set_option_string(struct cmd_ctx *,
+
-	    struct options *, const struct set_option_entry *, char *, int);
+int	cmd_set_option_unset(struct cmd *, struct cmd_ctx *,
-void	cmd_set_option_number(struct cmd_ctx *,
+	    const struct options_table_entry *, struct options *,
-	    struct options *, const struct set_option_entry *, char *);
+	    const char *);
-void	cmd_set_option_keys(struct cmd_ctx *,
+int	cmd_set_option_set(struct cmd *, struct cmd_ctx *,
-	    struct options *, const struct set_option_entry *, char *);
+	    const struct options_table_entry *, struct options *,
-void	cmd_set_option_colour(struct cmd_ctx *,
+	    const char *);
-	    struct options *, const struct set_option_entry *, char *);
+
-void	cmd_set_option_attributes(struct cmd_ctx *,
+struct options_entry *cmd_set_option_string(struct cmd *, struct cmd_ctx *,
-	    struct options *, const struct set_option_entry *, char *);
+	    const struct options_table_entry *, struct options *,
-void	cmd_set_option_flag(struct cmd_ctx *,
+	    const char *);
-	    struct options *, const struct set_option_entry *, char *);
+struct options_entry *cmd_set_option_number(struct cmd *, struct cmd_ctx *,
-void	cmd_set_option_choice(struct cmd_ctx *,
+	    const struct options_table_entry *, struct options *,
-	    struct options *, const struct set_option_entry *, char *);
+	    const char *);
+struct options_entry *cmd_set_option_key(struct cmd *, struct cmd_ctx *,
+	    const struct options_table_entry *, struct options *,
+	    const char *);
+struct options_entry *cmd_set_option_colour(struct cmd *, struct cmd_ctx *,
+	    const struct options_table_entry *, struct options *,
+	    const char *);
+struct options_entry *cmd_set_option_attributes(struct cmd *, struct cmd_ctx *,
+	    const struct options_table_entry *, struct options *,
+	    const char *);
+struct options_entry *cmd_set_option_flag(struct cmd *, struct cmd_ctx *,
+	    const struct options_table_entry *, struct options *,
+	    const char *);
+struct options_entry *cmd_set_option_choice(struct cmd *, struct cmd_ctx *,
+	    const struct options_table_entry *, struct options *,
+	    const char *);
 
 const struct cmd_entry cmd_set_option_entry = {
 	"set-option", "set",
+	"agst:uw", 1, 2,
 	"[-agsuw] [-t target-session|target-window] option [value]",
-	CMD_ARG12, "agsuw",
+	0,
 	NULL,
-	cmd_target_parse,
+	NULL,
-	cmd_set_option_exec,
+	cmd_set_option_exec
-	cmd_target_free,
-	cmd_target_print
 };
 
-const char *set_option_mode_keys_list[] = {
+const struct cmd_entry cmd_set_window_option_entry = {
-	"emacs", "vi", NULL
+	"set-window-option", "setw",
-};
+	"agt:u", 1, 2,
-const char *set_option_clock_mode_style_list[] = {
+	"[-agu] " CMD_TARGET_WINDOW_USAGE " option [value]",
-	"12", "24", NULL
+	0,
-};
+	NULL,
-const char *set_option_status_keys_list[] = {
+	NULL,
-	"emacs", "vi", NULL
+	cmd_set_option_exec
-};
-const char *set_option_status_justify_list[] = {
-	"left", "centre", "right", NULL
-};
-const char *set_option_bell_action_list[] = {
-	"none", "any", "current", NULL
 };
 
-const struct set_option_entry set_option_table[] = {
+/* Look for an option in all three tables. */
-	{ "escape-time", SET_OPTION_NUMBER, 0, INT_MAX, NULL },
+int
-	{ "quiet", SET_OPTION_FLAG, 0, 0, NULL },
+cmd_set_option_find(
-	{ NULL, 0, 0, 0, NULL }
+    const char *optstr, const struct options_table_entry **table,
-};
+    const struct options_table_entry **oe)
+{
+	static const struct options_table_entry	*tables[] = {
+		server_options_table,
+		window_options_table,
+		session_options_table
+	};
+	const struct options_table_entry	*oe_loop;
+	u_int					 i;
 
-const struct set_option_entry set_session_option_table[] = {
+	for (i = 0; i < nitems(tables); i++) {
-	{ "base-index", SET_OPTION_NUMBER, 0, INT_MAX, NULL },
+		for (oe_loop = tables[i]; oe_loop->name != NULL; oe_loop++) {
-	{ "bell-action", SET_OPTION_CHOICE, 0, 0, set_option_bell_action_list },
+			if (strncmp(oe_loop->name, optstr, strlen(optstr)) != 0)
-	{ "buffer-limit", SET_OPTION_NUMBER, 1, INT_MAX, NULL },
+				continue;
-	{ "default-command", SET_OPTION_STRING, 0, 0, NULL },
-	{ "default-path", SET_OPTION_STRING, 0, 0, NULL },
-	{ "default-shell", SET_OPTION_STRING, 0, 0, NULL },
-	{ "default-terminal", SET_OPTION_STRING, 0, 0, NULL },
-	{ "display-panes-colour", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "display-panes-active-colour", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "display-panes-time", SET_OPTION_NUMBER, 1, INT_MAX, NULL },
-	{ "display-time", SET_OPTION_NUMBER, 1, INT_MAX, NULL },
-	{ "history-limit", SET_OPTION_NUMBER, 0, INT_MAX, NULL },
-	{ "lock-after-time", SET_OPTION_NUMBER, 0, INT_MAX, NULL },
-	{ "lock-command", SET_OPTION_STRING, 0, 0, NULL },
-	{ "lock-server", SET_OPTION_FLAG, 0, 0, NULL },
-	{ "message-attr", SET_OPTION_ATTRIBUTES, 0, 0, NULL },
-	{ "message-bg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "message-fg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "message-limit", SET_OPTION_NUMBER, 0, INT_MAX, NULL },
-	{ "mouse-select-pane", SET_OPTION_FLAG, 0, 0, NULL },
-	{ "pane-active-border-bg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "pane-active-border-fg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "pane-border-bg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "pane-border-fg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "prefix", SET_OPTION_KEYS, 0, 0, NULL },
-	{ "repeat-time", SET_OPTION_NUMBER, 0, SHRT_MAX, NULL },
-	{ "set-remain-on-exit", SET_OPTION_FLAG, 0, 0, NULL },
-	{ "set-titles", SET_OPTION_FLAG, 0, 0, NULL },
-	{ "set-titles-string", SET_OPTION_STRING, 0, 0, NULL },
-	{ "status", SET_OPTION_FLAG, 0, 0, NULL },
-	{ "status-attr", SET_OPTION_ATTRIBUTES, 0, 0, NULL },
-	{ "status-bg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "status-fg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "status-interval", SET_OPTION_NUMBER, 0, INT_MAX, NULL },
-	{ "status-justify",
-	  SET_OPTION_CHOICE, 0, 0, set_option_status_justify_list },
-	{ "status-keys", SET_OPTION_CHOICE, 0, 0, set_option_status_keys_list },
-	{ "status-left", SET_OPTION_STRING, 0, 0, NULL },
-	{ "status-left-attr", SET_OPTION_ATTRIBUTES, 0, 0, NULL },
-	{ "status-left-bg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "status-left-fg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "status-left-length", SET_OPTION_NUMBER, 0, SHRT_MAX, NULL },
-	{ "status-right", SET_OPTION_STRING, 0, 0, NULL },
-	{ "status-right-attr", SET_OPTION_ATTRIBUTES, 0, 0, NULL },
-	{ "status-right-bg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "status-right-fg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "status-right-length", SET_OPTION_NUMBER, 0, SHRT_MAX, NULL },
-	{ "status-utf8", SET_OPTION_FLAG, 0, 0, NULL },
-	{ "terminal-overrides", SET_OPTION_STRING, 0, 0, NULL },
-	{ "update-environment", SET_OPTION_STRING, 0, 0, NULL },
-	{ "visual-activity", SET_OPTION_FLAG, 0, 0, NULL },
-	{ "visual-bell", SET_OPTION_FLAG, 0, 0, NULL },
-	{ "visual-content", SET_OPTION_FLAG, 0, 0, NULL },
-	{ NULL, 0, 0, 0, NULL }
-};
 
-const struct set_option_entry set_window_option_table[] = {
+			/* If already found, ambiguous. */
-	{ "aggressive-resize", SET_OPTION_FLAG, 0, 0, NULL },
+			if (*oe != NULL)
-	{ "alternate-screen", SET_OPTION_FLAG, 0, 0, NULL },
+				return (-1);
-	{ "automatic-rename", SET_OPTION_FLAG, 0, 0, NULL },
+			*oe = oe_loop;
-	{ "clock-mode-colour", SET_OPTION_COLOUR, 0, 0, NULL },
+			*table = tables[i];
-	{ "clock-mode-style",
+
-	  SET_OPTION_CHOICE, 0, 0, set_option_clock_mode_style_list },
+			/* Bail now if an exact match. */
-	{ "force-height", SET_OPTION_NUMBER, 0, INT_MAX, NULL },
+			if (strcmp((*oe)->name, optstr) == 0)
-	{ "force-width", SET_OPTION_NUMBER, 0, INT_MAX, NULL },
+				break;
-	{ "main-pane-height", SET_OPTION_NUMBER, 1, INT_MAX, NULL },
+		}
-	{ "main-pane-width", SET_OPTION_NUMBER, 1, INT_MAX, NULL },
+	}
-	{ "mode-attr", SET_OPTION_ATTRIBUTES, 0, 0, NULL },
+	return (0);
-	{ "mode-bg", SET_OPTION_COLOUR, 0, 0, NULL },
+}
-	{ "mode-fg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "mode-keys", SET_OPTION_CHOICE, 0, 0, set_option_mode_keys_list },
-	{ "mode-mouse", SET_OPTION_FLAG, 0, 0, NULL },
-	{ "monitor-activity", SET_OPTION_FLAG, 0, 0, NULL },
-	{ "monitor-content", SET_OPTION_STRING, 0, 0, NULL },
-	{ "remain-on-exit", SET_OPTION_FLAG, 0, 0, NULL },
-	{ "synchronize-panes", SET_OPTION_FLAG, 0, 0, NULL },
-	{ "utf8", SET_OPTION_FLAG, 0, 0, NULL },
-	{ "window-status-attr", SET_OPTION_ATTRIBUTES, 0, 0, NULL },
-	{ "window-status-bg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "window-status-current-attr", SET_OPTION_ATTRIBUTES, 0, 0, NULL },
-	{ "window-status-current-bg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "window-status-current-fg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "window-status-current-format", SET_OPTION_STRING, 0, 0, NULL },
-	{ "window-status-fg", SET_OPTION_COLOUR, 0, 0, NULL },
-	{ "window-status-format", SET_OPTION_STRING, 0, 0, NULL },
-	{ "word-separators", SET_OPTION_STRING, 0, 0, NULL },
-	{ "xterm-keys", SET_OPTION_FLAG, 0, 0, NULL },
-	{ NULL, 0, 0, 0, NULL }
-};
 
 int
 cmd_set_option_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data		*data = self->data;
+	struct args				*args = self->args;
-	const struct set_option_entry	*table;
+	const struct options_table_entry	*table, *oe;
-	struct session			*s;
+	struct session				*s;
-	struct winlink			*wl;
+	struct winlink				*wl;
-	struct client			*c;
+	struct client				*c;
-	struct options			*oo;
+	struct options				*oo;
-	const struct set_option_entry   *entry, *opt;
+	const char				*optstr, *valstr;
-	struct jobs			*jobs;
+	u_int					 i;
-	struct job			*job, *nextjob;
-	u_int				 i;
-	int				 try_again;
 
-	if (cmd_check_flag(data->chflags, 's')) {
+	/* Get the option name and value. */
+	optstr = args->argv[0];
+	if (*optstr == '\0') {
+		ctx->error(ctx, "invalid option");
+		return (-1);
+	}
+	if (args->argc < 2)
+		valstr = NULL;
+	else
+		valstr = args->argv[1];
+
+	/* Find the option entry, try each table. */
+	table = oe = NULL;
+	if (cmd_set_option_find(optstr, &table, &oe) != 0) {
+		ctx->error(ctx, "ambiguous option: %s", optstr);
+		return (-1);
+	}
+	if (oe == NULL) {
+		ctx->error(ctx, "unknown option: %s", optstr);
+		return (-1);
+	}
+
+	/* Work out the tree from the table. */
+	if (table == server_options_table)
 		oo = &global_options;
-		table = set_option_table;
+	else if (table == window_options_table) {
-	} else if (cmd_check_flag(data->chflags, 'w')) {
+		if (args_has(self->args, 'g'))
-		table = set_window_option_table;
-		if (cmd_check_flag(data->chflags, 'g'))
 			oo = &global_w_options;
 		else {
-			wl = cmd_find_window(ctx, data->target, NULL);
+			wl = cmd_find_window(ctx, args_get(args, 't'), NULL);
 			if (wl == NULL)
 				return (-1);
 			oo = &wl->window->options;
 		}
-	} else {
+	} else if (table == session_options_table) {
-		table = set_session_option_table;
+		if (args_has(self->args, 'g'))
-		if (cmd_check_flag(data->chflags, 'g'))
 			oo = &global_s_options;
 		else {
-			s = cmd_find_session(ctx, data->target);
+			s = cmd_find_session(ctx, args_get(args, 't'), 0);
 			if (s == NULL)
 				return (-1);
 			oo = &s->options;
 		}
-	}
-
-	if (*data->arg == '\0') {
-		ctx->error(ctx, "invalid option");
-		return (-1);
-	}
-
-	entry = NULL;
-	for (opt = table; opt->name != NULL; opt++) {
-		if (strncmp(opt->name, data->arg, strlen(data->arg)) != 0)
-			continue;
-		if (entry != NULL) {
-			ctx->error(ctx, "ambiguous option: %s", data->arg);
-			return (-1);
-		}
-		entry = opt;
-
-		/* Bail now if an exact match. */
-		if (strcmp(entry->name, data->arg) == 0)
-			break;
-	}
-	if (entry == NULL) {
-		ctx->error(ctx, "unknown option: %s", data->arg);
-		return (-1);
-	}
-
-	if (cmd_check_flag(data->chflags, 'u')) {
-		if (cmd_check_flag(data->chflags, 'g')) {
-			ctx->error(ctx,
-			    "can't unset global option: %s", entry->name);
-			return (-1);
-		}
-		if (data->arg2 != NULL) {
-			ctx->error(ctx,
-			    "value passed to unset option: %s", entry->name);
-			return (-1);
-		}
-
-		options_remove(oo, entry->name);
-		ctx->info(ctx, "unset option: %s", entry->name);
 	} else {
-		switch (entry->type) {
+		ctx->error(ctx, "unknown table");
-		case SET_OPTION_STRING:
+		return (-1);
-			cmd_set_option_string(ctx, oo, entry,
-			    data->arg2, cmd_check_flag(data->chflags, 'a'));
-			break;
-		case SET_OPTION_NUMBER:
-			cmd_set_option_number(ctx, oo, entry, data->arg2);
-			break;
-		case SET_OPTION_KEYS:
-			cmd_set_option_keys(ctx, oo, entry, data->arg2);
-			break;
-		case SET_OPTION_COLOUR:
-			cmd_set_option_colour(ctx, oo, entry, data->arg2);
-			break;
-		case SET_OPTION_ATTRIBUTES:
-			cmd_set_option_attributes(ctx, oo, entry, data->arg2);
-			break;
-		case SET_OPTION_FLAG:
-			cmd_set_option_flag(ctx, oo, entry, data->arg2);
-			break;
-		case SET_OPTION_CHOICE:
-			cmd_set_option_choice(ctx, oo, entry, data->arg2);
-			break;
-		}
 	}
 
+	/* Unset or set the option. */
+	if (args_has(args, 'u')) {
+		if (cmd_set_option_unset(self, ctx, oe, oo, valstr) != 0)
+			return (-1);
+	} else {
+		if (cmd_set_option_set(self, ctx, oe, oo, valstr) != 0)
+			return (-1);
+	}
+
+	/* Update sizes and redraw. May not need it but meh. */
 	recalculate_sizes();
 	for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
 		c = ARRAY_ITEM(&clients, i);
@@ -282,226 +191,167 @@ cmd_set_option_exec(struct cmd *self, struct cmd_ctx *ctx)
 			server_redraw_client(c);
 	}
 
-	/*
-	 * Special-case: kill all persistent jobs if status-left, status-right
-	 * or set-titles-string have changed. Persistent jobs are only used by
-	 * the status line at the moment so this works XXX.
-	 */
-	if (strcmp(entry->name, "status-left") == 0 ||
-	    strcmp(entry->name, "status-right") == 0 ||
-	    strcmp(entry->name, "set-titles-string") == 0 ||
-	    strcmp(entry->name, "window-status-format") == 0) {
-		for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
-			c = ARRAY_ITEM(&clients, i);
-			if (c == NULL || c->session == NULL)
-				continue;
-
-			jobs = &c->status_jobs;
-			do {
-				try_again = 0;
-				job = RB_ROOT(jobs);
-				while (job != NULL) {
-					nextjob = RB_NEXT(jobs, jobs, job);
-					if (job->flags & JOB_PERSIST) {
-						job_remove(jobs, job);
-						try_again = 1;
-						break;
-					}
-					job = nextjob;
-				}
-			} while (try_again);
-			server_redraw_client(c);
-		}
-	}
-
 	return (0);
 }
 
-const char *
+/* Unset an option. */
-cmd_set_option_print(
+int
-    const struct set_option_entry *entry, struct options_entry *o)
+cmd_set_option_unset(struct cmd *self, struct cmd_ctx *ctx,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
 {
-	static char	out[BUFSIZ];
+	struct args	*args = self->args;
-	const char     *s;
-	struct keylist *keylist;
-	u_int		i;
 
-	*out = '\0';
+	if (args_has(args, 'g')) {
-	switch (entry->type) {
+		ctx->error(ctx, "can't unset global option: %s", oe->name);
-		case SET_OPTION_STRING:
+		return (-1);
-			xsnprintf(out, sizeof out, "\"%s\"", o->str);
-			break;
-		case SET_OPTION_NUMBER:
-			xsnprintf(out, sizeof out, "%lld", o->num);
-			break;
-		case SET_OPTION_KEYS:
-			keylist = o->data;
-			for (i = 0; i < ARRAY_LENGTH(keylist); i++) {
-				strlcat(out, key_string_lookup_key(
-				    ARRAY_ITEM(keylist, i)), sizeof out);
-				if (i != ARRAY_LENGTH(keylist) - 1)
-					strlcat(out, ",", sizeof out);
-			}
-			break;
-		case SET_OPTION_COLOUR:
-			s = colour_tostring(o->num);
-			xsnprintf(out, sizeof out, "%s", s);
-			break;
-		case SET_OPTION_ATTRIBUTES:
-			s = attributes_tostring(o->num);
-			xsnprintf(out, sizeof out, "%s", s);
-			break;
-		case SET_OPTION_FLAG:
-			if (o->num)
-				strlcpy(out, "on", sizeof out);
-			else
-				strlcpy(out, "off", sizeof out);
-			break;
-		case SET_OPTION_CHOICE:
-			s = entry->choices[o->num];
-			xsnprintf(out, sizeof out, "%s", s);
-			break;
 	}
-	return (out);
+	if (value != NULL) {
+		ctx->error(ctx, "value passed to unset option: %s", oe->name);
+		return (-1);
+	}
+
+	options_remove(oo, oe->name);
+	ctx->info(ctx, "unset option: %s", oe->name);
+	return (0);
 }
 
-void
+/* Set an option. */
-cmd_set_option_string(struct cmd_ctx *ctx, struct options *oo,
+int
-    const struct set_option_entry *entry, char *value, int append)
+cmd_set_option_set(struct cmd *self, struct cmd_ctx *ctx,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
 {
 	struct options_entry	*o;
-	char			*oldvalue, *newvalue;
+	const char		*s;
 
-	if (value == NULL) {
+	if (oe->type != OPTIONS_TABLE_FLAG && value == NULL) {
 		ctx->error(ctx, "empty value");
-		return;
+		return (-1);
 	}
 
-	if (append) {
+	o = NULL;
-		oldvalue = options_get_string(oo, entry->name);
+	switch (oe->type) {
-		xasprintf(&newvalue, "%s%s", oldvalue, value);
+	case OPTIONS_TABLE_STRING:
+		o = cmd_set_option_string(self, ctx, oe, oo, value);
+		break;
+	case OPTIONS_TABLE_NUMBER:
+		o = cmd_set_option_number(self, ctx, oe, oo, value);
+		break;
+	case OPTIONS_TABLE_KEY:
+		o = cmd_set_option_key(self, ctx, oe, oo, value);
+		break;
+	case OPTIONS_TABLE_COLOUR:
+		o = cmd_set_option_colour(self, ctx, oe, oo, value);
+		break;
+	case OPTIONS_TABLE_ATTRIBUTES:
+		o = cmd_set_option_attributes(self, ctx, oe, oo, value);
+		break;
+	case OPTIONS_TABLE_FLAG:
+		o = cmd_set_option_flag(self, ctx, oe, oo, value);
+		break;
+	case OPTIONS_TABLE_CHOICE:
+		o = cmd_set_option_choice(self, ctx, oe, oo, value);
+		break;
+	}
+	if (o == NULL)
+		return (-1);
+
+	s = options_table_print_entry(oe, o);
+	ctx->info(ctx, "set option: %s -> %s", oe->name, s);
+	return (0);
+}
+
+/* Set a string option. */
+struct options_entry *
+cmd_set_option_string(struct cmd *self, unused struct cmd_ctx *ctx,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
+{
+	struct args	*args = self->args;
+	struct options_entry	*o;
+	char			*oldval, *newval;
+
+	if (args_has(args, 'a')) {
+		oldval = options_get_string(oo, oe->name);
+		xasprintf(&newval, "%s%s", oldval, value);
 	} else
-		newvalue = value;
+		newval = xstrdup(value);
 
-	o = options_set_string(oo, entry->name, "%s", newvalue);
+	o = options_set_string(oo, oe->name, "%s", newval);
-	ctx->info(ctx,
-	    "set option: %s -> %s", o->name, cmd_set_option_print(entry, o));
 
-	if (newvalue != value)
+	xfree(newval);
-		xfree(newvalue);
+	return (o);
 }
 
-void
+/* Set a number option. */
-cmd_set_option_number(struct cmd_ctx *ctx, struct options *oo,
+struct options_entry *
-    const struct set_option_entry *entry, char *value)
+cmd_set_option_number(unused struct cmd *self, struct cmd_ctx *ctx,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
 {
-	struct options_entry	*o;
+	long long	 ll;
-	long long		 number;
+	const char     	*errstr;
-	const char     		*errstr;
 
-	if (value == NULL) {
+	ll = strtonum(value, oe->minimum, oe->maximum, &errstr);
-		ctx->error(ctx, "empty value");
-		return;
-	}
-
-	number = strtonum(value, entry->minimum, entry->maximum, &errstr);
 	if (errstr != NULL) {
 		ctx->error(ctx, "value is %s: %s", errstr, value);
-		return;
+		return (NULL);
 	}
 
-	o = options_set_number(oo, entry->name, number);
+	return (options_set_number(oo, oe->name, ll));
-	ctx->info(ctx,
-	    "set option: %s -> %s", o->name, cmd_set_option_print(entry, o));
 }
 
-void
+/* Set a key option. */
-cmd_set_option_keys(struct cmd_ctx *ctx, struct options *oo,
+struct options_entry *
-    const struct set_option_entry *entry, char *value)
+cmd_set_option_key(unused struct cmd *self, struct cmd_ctx *ctx,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
 {
-	struct options_entry	*o;
+	int	key;
-	struct keylist		*keylist;
-	char			*copyvalue, *ptr, *str;
-	int		 	 key;
 
-	if (value == NULL) {
+	if ((key = key_string_lookup_string(value)) == KEYC_NONE) {
-		ctx->error(ctx, "empty value");
+		ctx->error(ctx, "bad key: %s", value);
-		return;
+		return (NULL);
 	}
 
-	keylist = xmalloc(sizeof *keylist);
+	return (options_set_number(oo, oe->name, key));
-	ARRAY_INIT(keylist);
-
-	ptr = copyvalue = xstrdup(value);
-	while ((str = strsep(&ptr, ",")) != NULL) {
-		if ((key = key_string_lookup_string(str)) == KEYC_NONE) {
-			xfree(keylist);
-			ctx->error(ctx, "unknown key: %s", str);
-			xfree(copyvalue);
-			return;
-		}
-		ARRAY_ADD(keylist, key);
-	}
-	xfree(copyvalue);
-
-	o = options_set_data(oo, entry->name, keylist, xfree);
-	ctx->info(ctx,
-	    "set option: %s -> %s", o->name, cmd_set_option_print(entry, o));
 }
 
-void
+/* Set a colour option. */
-cmd_set_option_colour(struct cmd_ctx *ctx, struct options *oo,
+struct options_entry *
-    const struct set_option_entry *entry, char *value)
+cmd_set_option_colour(unused struct cmd *self, struct cmd_ctx *ctx,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
 {
-	struct options_entry	*o;
+	int	colour;
-	int			 colour;
-
-	if (value == NULL) {
-		ctx->error(ctx, "empty value");
-		return;
-	}
 
 	if ((colour = colour_fromstring(value)) == -1) {
 		ctx->error(ctx, "bad colour: %s", value);
-		return;
+		return (NULL);
 	}
 
-	o = options_set_number(oo, entry->name, colour);
+	return (options_set_number(oo, oe->name, colour));
-	ctx->info(ctx,
-	    "set option: %s -> %s", o->name, cmd_set_option_print(entry, o));
 }
 
-void
+/* Set an attributes option. */
-cmd_set_option_attributes(struct cmd_ctx *ctx, struct options *oo,
+struct options_entry *
-    const struct set_option_entry *entry, char *value)
+cmd_set_option_attributes(unused struct cmd *self, struct cmd_ctx *ctx,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
 {
-	struct options_entry	*o;
+	int	attr;
-	int			 attr;
-
-	if (value == NULL) {
-		ctx->error(ctx, "empty value");
-		return;
-	}
 
 	if ((attr = attributes_fromstring(value)) == -1) {
 		ctx->error(ctx, "bad attributes: %s", value);
-		return;
+		return (NULL);
 	}
 
-	o = options_set_number(oo, entry->name, attr);
+	return (options_set_number(oo, oe->name, attr));
-	ctx->info(ctx,
-	    "set option: %s -> %s", o->name, cmd_set_option_print(entry, o));
 }
 
-void
+/* Set a flag option. */
-cmd_set_option_flag(struct cmd_ctx *ctx, struct options *oo,
+struct options_entry *
-    const struct set_option_entry *entry, char *value)
+cmd_set_option_flag(unused struct cmd *self, struct cmd_ctx *ctx,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
 {
-	struct options_entry	*o;
+	int	flag;
-	int			 flag;
 
 	if (value == NULL || *value == '\0')
-		flag = !options_get_number(oo, entry->name);
+		flag = !options_get_number(oo, oe->name);
 	else {
 		if ((value[0] == '1' && value[1] == '\0') ||
 		    strcasecmp(value, "on") == 0 ||
@@ -513,46 +363,37 @@ cmd_set_option_flag(struct cmd_ctx *ctx, struct options *oo,
 			flag = 0;
 		else {
 			ctx->error(ctx, "bad value: %s", value);
-			return;
+			return (NULL);
 		}
 	}
 
-	o = options_set_number(oo, entry->name, flag);
+	return (options_set_number(oo, oe->name, flag));
-	ctx->info(ctx,
-	    "set option: %s -> %s", o->name, cmd_set_option_print(entry, o));
 }
 
-void
+/* Set a choice option. */
-cmd_set_option_choice(struct cmd_ctx *ctx, struct options *oo,
+struct options_entry *
-    const struct set_option_entry *entry, char *value)
+cmd_set_option_choice(unused struct cmd *self, struct cmd_ctx *ctx,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
 {
-	struct options_entry	*o;
+	const char	**choicep;
-	const char     	       **choicep;
+	int		  n, choice = -1;
-	int		 	 n, choice = -1;
-
-	if (value == NULL) {
-		ctx->error(ctx, "empty value");
-		return;
-	}
 
 	n = 0;
-	for (choicep = entry->choices; *choicep != NULL; choicep++) {
+	for (choicep = oe->choices; *choicep != NULL; choicep++) {
 		n++;
 		if (strncmp(*choicep, value, strlen(value)) != 0)
 			continue;
 
 		if (choice != -1) {
-			ctx->error(ctx, "ambiguous option value: %s", value);
+			ctx->error(ctx, "ambiguous value: %s", value);
-			return;
+			return (NULL);
 		}
 		choice = n - 1;
 	}
 	if (choice == -1) {
-		ctx->error(ctx, "unknown option value: %s", value);
+		ctx->error(ctx, "unknown value: %s", value);
-		return;
+		return (NULL);
 	}
 
-	o = options_set_number(oo, entry->name, choice);
+	return (options_set_number(oo, oe->name, choice));
-	ctx->info(ctx,
-	    "set option: %s -> %s", o->name, cmd_set_option_print(entry, o));
 }

cmd-set-window-option.c

@@ -1,47 +0,0 @@
-/* $Id: cmd-set-window-option.c,v 1.43 2009-12-04 22:11:23 tcunha Exp $ */
-
-/*
- * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
- * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include <sys/types.h>
-
-#include "tmux.h"
-
-/*
- * Set a window option. This is just an alias for set-option -w.
- */
-
-int	cmd_set_window_option_exec(struct cmd *, struct cmd_ctx *);
-
-const struct cmd_entry cmd_set_window_option_entry = {
-	"set-window-option", "setw",
-	"[-agu] " CMD_TARGET_WINDOW_USAGE " option [value]",
-	CMD_ARG12, "agu",
-	NULL,
-	cmd_target_parse,
-	cmd_set_window_option_exec,
-	cmd_target_free,
-	cmd_target_print
-};
-
-int
-cmd_set_window_option_exec(struct cmd *self, struct cmd_ctx *ctx)
-{
-	struct cmd_target_data		*data = self->data;
-
-	cmd_set_flag(&data->chflags, 'w');
-	return (cmd_set_option_entry.exec(self, ctx));
-}

cmd-show-buffer.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-show-buffer.c,v 1.12 2009-12-04 22:14:47 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -21,46 +21,54 @@
 #include "tmux.h"
 
 /*
- * Show a session paste buffer.
+ * Show a paste buffer.
  */
 
 int	cmd_show_buffer_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_show_buffer_entry = {
 	"show-buffer", "showb",
-	CMD_BUFFER_SESSION_USAGE,
+	"b:", 0, 0,
-	0, "",
+	CMD_BUFFER_USAGE,
-	cmd_buffer_init,
+	0,
-	cmd_buffer_parse,
+	NULL,
-	cmd_show_buffer_exec,
+	NULL,
-	cmd_buffer_free,
+	cmd_show_buffer_exec
-	cmd_buffer_print
 };
 
 int
 cmd_show_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_buffer_data	*data = self->data;
+	struct args		*args = self->args;
 	struct session		*s;
 	struct paste_buffer	*pb;
-	char			*in, *buf, *ptr;
+	int			 buffer;
+	char			*in, *buf, *ptr, *cause;
 	size_t			 size, len;
 	u_int			 width;
 
-	if ((s = cmd_find_session(ctx, data->target)) == NULL)
+	if ((s = cmd_find_session(ctx, NULL, 0)) == NULL)
 		return (-1);
 
-	if (data->buffer == -1) {
+	if (!args_has(args, 'b')) {
-		if ((pb = paste_get_top(&s->buffers)) == NULL) {
+		if ((pb = paste_get_top(&global_buffers)) == NULL) {
 			ctx->error(ctx, "no buffers");
 			return (-1);
 		}
-	} else if ((pb = paste_get_index(&s->buffers, data->buffer)) == NULL) {
+	} else {
-		ctx->error(ctx, "no buffer %d", data->buffer);
+		buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
-		return (-1);
+		if (cause != NULL) {
+			ctx->error(ctx, "buffer %s", cause);
+			xfree(cause);
+			return (-1);
+		}
+
+		pb = paste_get_index(&global_buffers, buffer);
+		if (pb == NULL) {
+			ctx->error(ctx, "no buffer %d", buffer);
+			return (-1);
+		}
 	}
-	if (pb == NULL)
-		return (0);
 
 	size = pb->size;
 	if (size > SIZE_MAX / 4 - 1)

cmd-show-environment.c

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

cmd-show-messages.c

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

cmd-show-options.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-show-options.c,v 1.21 2009-12-10 16:59:02 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -31,57 +31,66 @@ int	cmd_show_options_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_show_options_entry = {
 	"show-options", "show",
+	"gst:w", 0, 0,
 	"[-gsw] [-t target-session|target-window]",
-	0, "gsw",
+	0,
-	cmd_target_init,
+	NULL,
-	cmd_target_parse,
+	NULL,
-	cmd_show_options_exec,
+	cmd_show_options_exec
-	cmd_target_free,
+};
-	cmd_target_print
+
+const struct cmd_entry cmd_show_window_options_entry = {
+	"show-window-options", "showw",
+	"gt:", 0, 0,
+	"[-g] " CMD_TARGET_WINDOW_USAGE,
+	0,
+	NULL,
+	NULL,
+	cmd_show_options_exec
 };
 
 int
 cmd_show_options_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data		*data = self->data;
+	struct args				*args = self->args;
-	const struct set_option_entry	*table;
+	const struct options_table_entry	*table, *oe;
-	struct session			*s;
+	struct session				*s;
-	struct winlink			*wl;
+	struct winlink				*wl;
-	struct options			*oo;
+	struct options				*oo;
-	struct options_entry		*o;
+	struct options_entry			*o;
-	const struct set_option_entry   *entry;
+	const char				*optval;
-	const char			*optval;
 
-	if (cmd_check_flag(data->chflags, 's')) {
+	if (args_has(self->args, 's')) {
 		oo = &global_options;
-		table = set_option_table;
+		table = server_options_table;
-	} else if (cmd_check_flag(data->chflags, 'w')) {
+	} else if (args_has(self->args, 'w') ||
-		table = set_window_option_table;
+	    self->entry == &cmd_show_window_options_entry) {
-		if (cmd_check_flag(data->chflags, 'g'))
+		table = window_options_table;
+		if (args_has(self->args, 'g'))
 			oo = &global_w_options;
 		else {
-			wl = cmd_find_window(ctx, data->target, NULL);
+			wl = cmd_find_window(ctx, args_get(args, 't'), NULL);
 			if (wl == NULL)
 				return (-1);
 			oo = &wl->window->options;
 		}
 	} else {
-		table = set_session_option_table;
+		table = session_options_table;
-		if (cmd_check_flag(data->chflags, 'g'))
+		if (args_has(self->args, 'g'))
 			oo = &global_s_options;
 		else {
-			s = cmd_find_session(ctx, data->target);
+			s = cmd_find_session(ctx, args_get(args, 't'), 0);
 			if (s == NULL)
 				return (-1);
 			oo = &s->options;
 		}
 	}
 
-	for (entry = table; entry->name != NULL; entry++) {
+	for (oe = table; oe->name != NULL; oe++) {
-		if ((o = options_find1(oo, entry->name)) == NULL)
+		if ((o = options_find1(oo, oe->name)) == NULL)
 			continue;
-		optval = cmd_set_option_print(entry, o);
+		optval = options_table_print_entry(oe, o);
-		ctx->print(ctx, "%s %s", entry->name, optval);
+		ctx->print(ctx, "%s %s", oe->name, optval);
 	}
 
 	return (0);

cmd-source-file.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-source-file.c,v 1.13 2010-02-08 18:29:32 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Tiago Cunha <me@tiagocunha.org>
@@ -24,108 +24,51 @@
  * Sources a configuration file.
  */
 
-int	cmd_source_file_parse(struct cmd *, int, char **, char **);
 int	cmd_source_file_exec(struct cmd *, struct cmd_ctx *);
-void	cmd_source_file_free(struct cmd *);
-void	cmd_source_file_init(struct cmd *, int);
-size_t	cmd_source_file_print(struct cmd *, char *, size_t);
-
-struct cmd_source_file_data {
-	char *path;
-};
 
 const struct cmd_entry cmd_source_file_entry = {
 	"source-file", "source",
+	"", 1, 1,
 	"path",
-	0, "",
+	0,
-	cmd_source_file_init,
+	NULL,
-	cmd_source_file_parse,
+	NULL,
-	cmd_source_file_exec,
+	cmd_source_file_exec
-	cmd_source_file_free,
-	cmd_source_file_print
 };
 
-/* ARGSUSED */
-void
-cmd_source_file_init(struct cmd *self, unused int arg)
-{
-	struct cmd_source_file_data	*data;
-
-	self->data = data = xmalloc(sizeof *data);
-	data->path = NULL;
-}
-
-int
-cmd_source_file_parse(struct cmd *self, int argc, char **argv, char **cause)
-{
-	struct cmd_source_file_data	*data;
-	int				 opt;
-
-	self->entry->init(self, KEYC_NONE);
-	data = self->data;
-
-	while ((opt = getopt(argc, argv, "")) != -1) {
-		switch (opt) {
-		default:
-			goto usage;
-		}
-	}
-	argc -= optind;
-	argv += optind;
-	if (argc != 1)
-		goto usage;
-
-	data->path = xstrdup(argv[0]);
-	return (0);
-
-usage:
-	xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
-
-	self->entry->free(self);
-	return (-1);
-}
-
 int
 cmd_source_file_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_source_file_data	*data = self->data;
+	struct args		*args = self->args;
-	struct causelist		 causes;
+	struct causelist	 causes;
-	char				*cause;
+	char			*cause;
-	u_int				 i;
+	struct window_pane	*wp;
+	int			 retval;
+	u_int			 i;
 
 	ARRAY_INIT(&causes);
-	if (load_cfg(data->path, ctx, &causes) != 0) {
+
+	retval = load_cfg(args->argv[0], ctx, &causes);
+	if (ARRAY_EMPTY(&causes))
+		return (retval);
+
+	if (retval == 1 && !RB_EMPTY(&sessions) && ctx->cmdclient != NULL) {
+		wp = RB_MIN(sessions, &sessions)->curw->window->active;
+		window_pane_set_mode(wp, &window_copy_mode);
+		window_copy_init_for_output(wp);
+		for (i = 0; i < ARRAY_LENGTH(&causes); i++) {
+			cause = ARRAY_ITEM(&causes, i);
+			window_copy_add(wp, "%s", cause);
+			xfree(cause);
+		}
+	} else {
 		for (i = 0; i < ARRAY_LENGTH(&causes); i++) {
 			cause = ARRAY_ITEM(&causes, i);
 			ctx->print(ctx, "%s", cause);
 			xfree(cause);
 		}
-		ARRAY_FREE(&causes);
 	}
+	ARRAY_FREE(&causes);
 
-	return (0);
+	return (retval);
-}
-
-void
-cmd_source_file_free(struct cmd *self)
-{
-	struct cmd_source_file_data	*data = self->data;
-
-	if (data->path != NULL)
-		xfree(data->path);
-	xfree(data);
-}
-
-size_t
-cmd_source_file_print(struct cmd *self, char *buf, size_t len)
-{
-	struct cmd_source_file_data	*data = self->data;
-	size_t				off = 0;
-
-	off += xsnprintf(buf, len, "%s", self->entry->name);
-	if (data == NULL)
-		return (off);
-	if (off < len && data->path != NULL)
-		off += cmd_prarg(buf + off, len - off, " ", data->path);
-	return (off);
 }

cmd-split-window.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-split-window.c,v 1.34 2010-01-08 16:31:35 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -27,137 +27,44 @@
  * Split a window (add a new pane).
  */
 
-int	cmd_split_window_parse(struct cmd *, int, char **, char **);
+void	cmd_split_window_key_binding(struct cmd *, int);
 int	cmd_split_window_exec(struct cmd *, struct cmd_ctx *);
-void	cmd_split_window_free(struct cmd *);
-void	cmd_split_window_init(struct cmd *, int);
-size_t	cmd_split_window_print(struct cmd *, char *, size_t);
-
-struct cmd_split_window_data {
-	char	*target;
-	char	*cmd;
-	int	 flag_detached;
-	int	 flag_horizontal;
-	int	 percentage;
-	int	 size;
-};
 
 const struct cmd_entry cmd_split_window_entry = {
 	"split-window", "splitw",
-	"[-dhv] [-p percentage|-l size] [-t target-pane] [command]",
+	"dl:hp:Pt:v", 0, 1,
-	0, "",
+	"[-dhvP] [-p percentage|-l size] [-t target-pane] [command]",
-	cmd_split_window_init,
+	0,
-	cmd_split_window_parse,
+	cmd_split_window_key_binding,
-	cmd_split_window_exec,
+	NULL,
-	cmd_split_window_free,
+	cmd_split_window_exec
-	cmd_split_window_print
 };
 
 void
-cmd_split_window_init(struct cmd *self, int key)
+cmd_split_window_key_binding(struct cmd *self, int key)
 {
-	struct cmd_split_window_data	 *data;
+	self->args = args_create(0);
-
+	if (key == '%')
-	self->data = data = xmalloc(sizeof *data);
+		args_set(self->args, 'h', NULL);
-	data->target = NULL;
-	data->cmd = NULL;
-	data->flag_detached = 0;
-	data->flag_horizontal = 0;
-	data->percentage = -1;
-	data->size = -1;
-
-	switch (key) {
-	case '%':
-		data->flag_horizontal = 1;
-		break;
-	case '"':
-		data->flag_horizontal = 0;
-		break;
-	}
-}
-
-int
-cmd_split_window_parse(struct cmd *self, int argc, char **argv, char **cause)
-{
-	struct cmd_split_window_data	*data;
-	int				 opt;
-	const char			*errstr;
-
-	self->entry->init(self, KEYC_NONE);
-	data = self->data;
-
-	while ((opt = getopt(argc, argv, "dhl:p:t:v")) != -1) {
-		switch (opt) {
-		case 'd':
-			data->flag_detached = 1;
-			break;
-		case 'h':
-			data->flag_horizontal = 1;
-			break;
-		case 't':
-			if (data->target == NULL)
-				data->target = xstrdup(optarg);
-			break;
-		case 'l':
-			if (data->percentage != -1 || data->size != -1)
-				break;
-			data->size = strtonum(optarg, 1, INT_MAX, &errstr);
-			if (errstr != NULL) {
-				xasprintf(cause, "size %s", errstr);
-				goto error;
-			}
-			break;
-		case 'p':
-			if (data->size != -1 || data->percentage != -1)
-				break;
-			data->percentage = strtonum(optarg, 1, 100, &errstr);
-			if (errstr != NULL) {
-				xasprintf(cause, "percentage %s", errstr);
-				goto error;
-			}
-			break;
-		case 'v':
-			data->flag_horizontal = 0;
-			break;
-		default:
-			goto usage;
-		}
-	}
-	argc -= optind;
-	argv += optind;
-	if (argc != 0 && argc != 1)
-		goto usage;
-
-	if (argc == 1)
-		data->cmd = xstrdup(argv[0]);
-
-	return (0);
-
-usage:
-	xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
-
-error:
-	self->entry->free(self);
-	return (-1);
 }
 
 int
 cmd_split_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_split_window_data	*data = self->data;
+	struct args		*args = self->args;
-	struct session			*s;
+	struct session		*s;
-	struct winlink			*wl;
+	struct winlink		*wl;
-	struct window			*w;
+	struct window		*w;
-	struct window_pane		*wp, *new_wp = NULL;
+	struct window_pane	*wp, *new_wp = NULL;
-	struct environ			 env;
+	struct environ		 env;
-	char		 		*cmd, *cwd, *cause;
+	const char	       	*cmd, *cwd, *shell;
-	const char			*shell;
+	char			*cause, *new_cause;
-	u_int				 hlimit;
+	u_int			 hlimit, paneidx;
-	int				 size;
+	int			 size, percentage;
-	enum layout_type		 type;
+	enum layout_type	 type;
-	struct layout_cell		*lc;
+	struct layout_cell	*lc;
 
-	if ((wl = cmd_find_pane(ctx, data->target, &s, &wp)) == NULL)
+	if ((wl = cmd_find_pane(ctx, args_get(args, 't'), &s, &wp)) == NULL)
 		return (-1);
 	w = wl->window;
 
@@ -166,26 +73,37 @@ cmd_split_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 	environ_copy(&s->environ, &env);
 	server_fill_environ(s, &env);
 
-	cmd = data->cmd;
+	if (args->argc == 0)
-	if (cmd == NULL)
 		cmd = options_get_string(&s->options, "default-command");
-	if (ctx->cmdclient == NULL || ctx->cmdclient->cwd == NULL)
-		cwd = options_get_string(&s->options, "default-path");
 	else
-		cwd = ctx->cmdclient->cwd;
+		cmd = args->argv[0];
+	cwd = cmd_get_default_path(ctx);
 
 	type = LAYOUT_TOPBOTTOM;
-	if (data->flag_horizontal)
+	if (args_has(args, 'h'))
 		type = LAYOUT_LEFTRIGHT;
 
 	size = -1;
-	if (data->size != -1)
+	if (args_has(args, 'l')) {
-		size = data->size;
+		size = args_strtonum(args, 'l', 0, INT_MAX, &cause);
-	else if (data->percentage != -1) {
+		if (cause != NULL) {
+			xasprintf(&new_cause, "size %s", cause);
+			xfree(cause);
+			cause = new_cause;
+			goto error;
+		}
+	} else if (args_has(args, 'p')) {
+		percentage = args_strtonum(args, 'p', 0, INT_MAX, &cause);
+		if (cause != NULL) {
+			xasprintf(&new_cause, "percentage %s", cause);
+			xfree(cause);
+			cause = new_cause;
+			goto error;
+		}
 		if (type == LAYOUT_TOPBOTTOM)
-			size = (wp->sy * data->percentage) / 100;
+			size = (wp->sy * percentage) / 100;
 		else
-			size = (wp->sx * data->percentage) / 100;
+			size = (wp->sx * percentage) / 100;
 	}
 	hlimit = options_get_number(&s->options, "history-limit");
 
@@ -205,7 +123,7 @@ cmd_split_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 
 	server_redraw_window(w);
 
-	if (!data->flag_detached) {
+	if (!args_has(args, 'd')) {
 		window_set_active_pane(w, new_wp);
 		session_select(s, wl->idx);
 		server_redraw_session(s);
@@ -213,6 +131,12 @@ cmd_split_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 		server_status_session(s);
 
 	environ_free(&env);
+
+	if (args_has(args, 'P')) {
+		if (window_pane_index(new_wp, &paneidx) != 0)
+			fatalx("index not found");
+		ctx->print(ctx, "%s:%u.%u", s->name, wl->idx, paneidx);
+	}
 	return (0);
 
 error:
@@ -223,41 +147,3 @@ error:
 	xfree(cause);
 	return (-1);
 }
-
-void
-cmd_split_window_free(struct cmd *self)
-{
-	struct cmd_split_window_data	*data = self->data;
-
-	if (data->target != NULL)
-		xfree(data->target);
-	if (data->cmd != NULL)
-		xfree(data->cmd);
-	xfree(data);
-}
-
-size_t
-cmd_split_window_print(struct cmd *self, char *buf, size_t len)
-{
-	struct cmd_split_window_data	*data = self->data;
-	size_t				 off = 0;
-
-	off += xsnprintf(buf, len, "%s", self->entry->name);
-	if (data == NULL)
-		return (off);
-	if (off < len && data->flag_detached)
-		off += xsnprintf(buf + off, len - off, " -d");
-	if (off < len && data->flag_horizontal)
-		off += xsnprintf(buf + off, len - off, " -h");
-	if (off < len && data->size > 0)
-		off += xsnprintf(buf + off, len - off, " -l %d", data->size);
-	if (off < len && data->percentage > 0) {
-		off += xsnprintf(
-		    buf + off, len - off, " -p %d", data->percentage);
-	}
-	if (off < len && data->target != NULL)
-		off += cmd_prarg(buf + off, len - off, " -t ", data->target);
-	if (off < len && data->cmd != NULL)
-		off += cmd_prarg(buf + off, len - off, " ", data->cmd);
-	return (off);
-}

cmd-start-server.c

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

cmd-string.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-string.c,v 1.31 2010-02-26 13:27:38 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -247,9 +247,10 @@ error:
 char *
 cmd_string_variable(const char *s, size_t *p)
 {
-	int	ch, fch;
+	int			ch, fch;
-	char   *buf, *t;
+	char		       *buf, *t;
-	size_t	len;
+	size_t			len;
+	struct environ_entry   *envent;
 
 #define cmd_string_first(ch) ((ch) == '_' || \
 	((ch) >= 'a' && (ch) <= 'z') || ((ch) >= 'A' && (ch) <= 'Z'))
@@ -301,12 +302,11 @@ cmd_string_variable(const char *s, size_t *p)
 	buf = xrealloc(buf, 1, len + 1);
 	buf[len] = '\0';
 
-	if ((t = getenv(buf)) == NULL) {
+	envent = environ_find(&global_environ, buf);
-		xfree(buf);
-		return (xstrdup(""));
-	}
 	xfree(buf);
-	return (xstrdup(t));
+	if (envent == NULL)
+		return (xstrdup(""));
+	return (xstrdup(envent->value));
 
 error:
 	if (buf != NULL)
@@ -317,15 +317,17 @@ error:
 char *
 cmd_string_expand_tilde(const char *s, size_t *p)
 {
-	struct passwd	*pw;
+	struct passwd		*pw;
-	char		*home, *path, *username;
+	struct environ_entry	*envent;
+	char			*home, *path, *username;
 
 	home = NULL;
 	if (cmd_string_getc(s, p) == '/') {
-		if ((home = getenv("HOME")) == NULL || *home == '\0') {
+		envent = environ_find(&global_environ, "HOME");
-			if ((pw = getpwuid(getuid())) != NULL)
+		if (envent != NULL && *envent->value != '\0')
-				home = pw->pw_dir;
+			home = envent->value;
-		}
+		else if ((pw = getpwuid(getuid())) != NULL)
+			home = pw->pw_dir;
 	} else {
 		cmd_string_ungetc(p);
 		if ((username = cmd_string_string(s, p, '/', 0)) == NULL)

cmd-suspend-client.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-suspend-client.c,v 1.5 2009-11-14 17:56:39 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -29,29 +29,23 @@
 
 int	cmd_suspend_client_exec(struct cmd *, struct cmd_ctx *);
 
-struct cmd_suspend_client_data {
-	char	*name;
-	char	*target;
-};
-
 const struct cmd_entry cmd_suspend_client_entry = {
 	"suspend-client", "suspendc",
-	"[-c target-client]",
+	"t:", 0, 0,
-	0, "",
+	CMD_TARGET_CLIENT_USAGE,
-	cmd_target_init,
+	0,
-	cmd_target_parse,
+	NULL,
-	cmd_suspend_client_exec,
+	NULL,
-	cmd_target_free,
+	cmd_suspend_client_exec
-	cmd_target_print
 };
 
 int
 cmd_suspend_client_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_target_data	*data = self->data;
+	struct args	*args = self->args;
-	struct client		*c;
+	struct client	*c;
 
-	if ((c = cmd_find_client(ctx, data->target)) == NULL)
+	if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
 		return (-1);
 
 	tty_stop_tty(&c->tty);

cmd-swap-pane.c

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

cmd-swap-window.c

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

cmd-switch-client.c

@@ -1,4 +1,4 @@
-/* $Id: cmd-switch-client.c,v 1.19 2010-01-25 17:12:44 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -27,112 +27,88 @@
  * Switch client to a different session.
  */
 
-int	cmd_switch_client_parse(struct cmd *, int, char **, char **);
+void	cmd_switch_client_key_binding(struct cmd *, int);
 int	cmd_switch_client_exec(struct cmd *, struct cmd_ctx *);
-void	cmd_switch_client_free(struct cmd *);
-size_t	cmd_switch_client_print(struct cmd *, char *, size_t);
-
-struct cmd_switch_client_data {
-	char	*name;
-	char	*target;
-};
 
 const struct cmd_entry cmd_switch_client_entry = {
 	"switch-client", "switchc",
-	"[-c target-client] [-t target-session]",
+	"lc:npt:r", 0, 0,
-	0, "",
+	"[-lnpr] [-c target-client] [-t target-session]",
+	CMD_READONLY,
+	cmd_switch_client_key_binding,
 	NULL,
-	cmd_switch_client_parse,
+	cmd_switch_client_exec
-	cmd_switch_client_exec,
-	cmd_switch_client_free,
-	cmd_switch_client_print
 };
 
-int
+void
-cmd_switch_client_parse(struct cmd *self, int argc, char **argv, char **cause)
+cmd_switch_client_key_binding(struct cmd *self, int key)
 {
-	struct cmd_switch_client_data	*data;
+	self->args = args_create(0);
-	int				 opt;
+	switch (key) {
-
+	case '(':
-	self->data = data = xmalloc(sizeof *data);
+		args_set(self->args, 'p', NULL);
-	data->name = NULL;
+		break;
-	data->target = NULL;
+	case ')':
-
+		args_set(self->args, 'n', NULL);
-	while ((opt = getopt(argc, argv, "c:t:")) != -1) {
+		break;
-		switch (opt) {
+	case 'L':
-		case 'c':
+		args_set(self->args, 'l', NULL);
-			if (data->name == NULL)
+		break;
-				data->name = xstrdup(optarg);
-			break;
-		case 't':
-			if (data->target == NULL)
-				data->target = xstrdup(optarg);
-			break;
-		default:
-			goto usage;
-		}
 	}
-	argc -= optind;
-	argv += optind;
-	if (argc != 0)
-		goto usage;
-
-	return (0);
-
-usage:
-	xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);
-
-	self->entry->free(self);
-	return (-1);
 }
 
 int
 cmd_switch_client_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct cmd_switch_client_data	*data = self->data;
+	struct args	*args = self->args;
-	struct client			*c;
+	struct client	*c;
-	struct session			*s;
+	struct session	*s;
 
-	if (data == NULL)
+	if ((c = cmd_find_client(ctx, args_get(args, 'c'))) == NULL)
-		return (0);
-
-	if ((c = cmd_find_client(ctx, data->name)) == NULL)
-		return (-1);
-	if ((s = cmd_find_session(ctx, data->target)) == NULL)
 		return (-1);
 
+	if (args_has(args, 'r')) {
+		if (c->flags & CLIENT_READONLY) {
+			c->flags &= ~CLIENT_READONLY;
+			ctx->info(ctx, "made client writable");
+		} else {
+			c->flags |= CLIENT_READONLY;
+			ctx->info(ctx, "made client read-only");
+		}
+	}
+
+	s = NULL;
+	if (args_has(args, 'n')) {
+		if ((s = session_next_session(c->session)) == NULL) {
+			ctx->error(ctx, "can't find next session");
+			return (-1);
+		}
+	} else if (args_has(args, 'p')) {
+		if ((s = session_previous_session(c->session)) == NULL) {
+			ctx->error(ctx, "can't find previous session");
+			return (-1);
+		}
+	} else if (args_has(args, 'l')) {
+		if (c->last_session != NULL && session_alive(c->last_session))
+			s = c->last_session;
+		if (s == NULL) {
+			ctx->error(ctx, "can't find last session");
+			return (-1);
+		}
+	} else
+		s = cmd_find_session(ctx, args_get(args, 't'), 0);
+	if (s == NULL)
+		return (-1);
+
+	if (c->session != NULL)
+		c->last_session = c->session;
 	c->session = s;
+	session_update_activity(s);
 
 	recalculate_sizes();
+	server_check_unattached();
 	server_redraw_client(c);
+	s->curw->flags &= ~WINLINK_ALERTFLAGS;
 
 	return (0);
 }
-
-void
-cmd_switch_client_free(struct cmd *self)
-{
-	struct cmd_switch_client_data	*data = self->data;
-
-	if (data->name != NULL)
-		xfree(data->name);
-	if (data->target != NULL)
-		xfree(data->target);
-	xfree(data);
-}
-
-size_t
-cmd_switch_client_print(struct cmd *self, char *buf, size_t len)
-{
-	struct cmd_switch_client_data	*data = self->data;
-	size_t				 off = 0;
-
-	off += xsnprintf(buf, len, "%s", self->entry->name);
-	if (data == NULL)
-		return (off);
-	if (off < len && data->name != NULL)
-		off += cmd_prarg(buf + off, len - off, " -c ", data->name);
-	if (off < len && data->target != NULL)
-		off += cmd_prarg(buf + off, len - off, " -t ", data->target);
-	return (off);
-}

cmd-unbind-key.c

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

cmd-unlink-window.c

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

cmd-up-pane.c

@@ -1,60 +0,0 @@
-/* $Id: cmd-up-pane.c,v 1.14 2010-01-05 23:52:37 tcunha Exp $ */
-
-/*
- * Copyright (c) 2009 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 "tmux.h"
-
-/*
- * Move up a pane.
- */
-
-int	cmd_up_pane_exec(struct cmd *, struct cmd_ctx *);
-
-const struct cmd_entry cmd_up_pane_entry = {
-	"up-pane", "upp",
-	CMD_TARGET_WINDOW_USAGE,
-	0, "",
-	cmd_target_init,
-	cmd_target_parse,
-	cmd_up_pane_exec,
-	cmd_target_free,
-	cmd_target_print
-};
-
-int
-cmd_up_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
-{
-	struct cmd_target_data	*data = self->data;
-	struct winlink		*wl;
-	struct window		*w;
-
-	if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)
-		return (-1);
-	w = wl->window;
-
-	do {
-		w->active = TAILQ_PREV(w->active, window_panes, entry);
-		if (w->active == NULL)
-			w->active = TAILQ_LAST(&w->panes, window_panes);
-	} while (!window_pane_visible(w->active));
-	server_status_window(wl->window);
-	server_redraw_window_borders(wl->window);
-
-	return (0);
-}

cmd.c

@@ -1,4 +1,4 @@
-/* $Id: cmd.c,v 1.137 2010-01-22 17:28:34 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -31,6 +31,7 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_bind_key_entry,
 	&cmd_break_pane_entry,
 	&cmd_capture_pane_entry,
+	&cmd_choose_buffer_entry,
 	&cmd_choose_client_entry,
 	&cmd_choose_session_entry,
 	&cmd_choose_window_entry,
@@ -38,13 +39,11 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_clock_mode_entry,
 	&cmd_command_prompt_entry,
 	&cmd_confirm_before_entry,
-	&cmd_copy_buffer_entry,
 	&cmd_copy_mode_entry,
 	&cmd_delete_buffer_entry,
 	&cmd_detach_client_entry,
 	&cmd_display_message_entry,
 	&cmd_display_panes_entry,
-	&cmd_down_pane_entry,
 	&cmd_find_window_entry,
 	&cmd_has_session_entry,
 	&cmd_if_shell_entry,
@@ -53,6 +52,7 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_kill_server_entry,
 	&cmd_kill_session_entry,
 	&cmd_kill_window_entry,
+	&cmd_last_pane_entry,
 	&cmd_last_window_entry,
 	&cmd_link_window_entry,
 	&cmd_list_buffers_entry,
@@ -79,13 +79,13 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_rename_session_entry,
 	&cmd_rename_window_entry,
 	&cmd_resize_pane_entry,
+	&cmd_respawn_pane_entry,
 	&cmd_respawn_window_entry,
 	&cmd_rotate_window_entry,
 	&cmd_run_shell_entry,
 	&cmd_save_buffer_entry,
 	&cmd_select_layout_entry,
 	&cmd_select_pane_entry,
-	&cmd_select_prompt_entry,
 	&cmd_select_window_entry,
 	&cmd_send_keys_entry,
 	&cmd_send_prefix_entry,
@@ -108,16 +108,22 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_switch_client_entry,
 	&cmd_unbind_key_entry,
 	&cmd_unlink_window_entry,
-	&cmd_up_pane_entry,
 	NULL
 };
 
-struct session	*cmd_choose_session(struct sessions *);
+struct session	*cmd_choose_session_list(struct sessionslist *);
+struct session	*cmd_choose_session(int);
 struct client	*cmd_choose_client(struct clients *);
 struct client	*cmd_lookup_client(const char *);
 struct session	*cmd_lookup_session(const char *, int *);
 struct winlink	*cmd_lookup_window(struct session *, const char *, int *);
 int		 cmd_lookup_index(struct session *, const char *, int *);
+struct window_pane *cmd_lookup_paneid(const char *);
+struct session	*cmd_pane_session(struct cmd_ctx *,
+		    struct window_pane *, struct winlink **);
+struct winlink	*cmd_find_window_offset(const char *, struct session *, int *);
+int		 cmd_find_index_offset(const char *, struct session *, int *);
+struct window_pane *cmd_find_pane_offset(const char *, struct winlink *);
 
 int
 cmd_pack_argv(int argc, char **argv, char *buf, size_t len)
@@ -163,6 +169,22 @@ cmd_unpack_argv(char *buf, size_t len, int argc, char ***argv)
 	return (0);
 }
 
+char **
+cmd_copy_argv(int argc, char *const *argv)
+{
+	char	**new_argv;
+	int	  i;
+
+	if (argc == 0)
+		return (NULL);
+	new_argv = xcalloc(argc, sizeof *new_argv);
+	for (i = 0; i < argc; i++) {
+		if (argv[i] != NULL)
+			new_argv[i] = xstrdup(argv[i]);
+	}
+	return (new_argv);
+}
+
 void
 cmd_free_argv(int argc, char **argv)
 {
@@ -182,8 +204,9 @@ cmd_parse(int argc, char **argv, char **cause)
 {
 	const struct cmd_entry **entryp, *entry;
 	struct cmd		*cmd;
+	struct args		*args;
 	char			 s[BUFSIZ];
-	int			 opt, ambiguous = 0;
+	int			 ambiguous = 0;
 
 	*cause = NULL;
 	if (argc == 0) {
@@ -217,30 +240,19 @@ cmd_parse(int argc, char **argv, char **cause)
 		return (NULL);
 	}
 
-	optreset = 1;
+	args = args_parse(entry->args_template, argc, argv);
-	optind = 1;
+	if (args == NULL)
-	if (entry->parse == NULL) {
+		goto usage;
-		while ((opt = getopt(argc, argv, "")) != -1) {
+	if (entry->args_lower != -1 && args->argc < entry->args_lower)
-			switch (opt) {
+		goto usage;
-			default:
+	if (entry->args_upper != -1 && args->argc > entry->args_upper)
-				goto usage;
+		goto usage;
-			}
+	if (entry->check != NULL && entry->check(args) != 0)
-		}
+		goto usage;
-		argc -= optind;
-		argv += optind;
-		if (argc != 0)
-			goto usage;
-	}
 
 	cmd = xmalloc(sizeof *cmd);
 	cmd->entry = entry;
-	cmd->data = NULL;
+	cmd->args = args;
-	if (entry->parse != NULL) {
-		if (entry->parse(cmd, argc, argv, cause) != 0) {
-			xfree(cmd);
-			return (NULL);
-		}
-	}
 	return (cmd);
 
 ambiguous:
@@ -258,6 +270,8 @@ ambiguous:
 	return (NULL);
 
 usage:
+	if (args != NULL)
+		args_free(args);
 	xasprintf(cause, "usage: %s %s", entry->name, entry->usage);
 	return (NULL);
 }
@@ -271,17 +285,27 @@ cmd_exec(struct cmd *cmd, struct cmd_ctx *ctx)
 void
 cmd_free(struct cmd *cmd)
 {
-	if (cmd->data != NULL && cmd->entry->free != NULL)
+	if (cmd->args != NULL)
-		cmd->entry->free(cmd);
+		args_free(cmd->args);
 	xfree(cmd);
 }
 
 size_t
 cmd_print(struct cmd *cmd, char *buf, size_t len)
 {
-	if (cmd->entry->print == NULL)
+	size_t	off, used;
-		return (xsnprintf(buf, len, "%s", cmd->entry->name));
+
-	return (cmd->entry->print(cmd, buf, len));
+	off = xsnprintf(buf, len, "%s ", cmd->entry->name);
+	if (off < len) {
+		used = args_print(cmd->args, buf + off, len - off);
+		if (used == 0)
+			buf[off - 1] = '\0';
+		else {
+			off += used;
+			buf[off] = '\0';
+		}
+	}
+	return (off);
 }
 
 /*
@@ -292,15 +316,14 @@ cmd_print(struct cmd *cmd, char *buf, size_t len)
  * session from all sessions.
  */
 struct session *
-cmd_current_session(struct cmd_ctx *ctx)
+cmd_current_session(struct cmd_ctx *ctx, int prefer_unattached)
 {
 	struct msg_command_data	*data = ctx->msgdata;
 	struct client		*c = ctx->cmdclient;
 	struct session		*s;
-	struct sessions		 ss;
+	struct sessionslist	 ss;
 	struct winlink		*wl;
 	struct window_pane	*wp;
-	u_int			 i;
 	int			 found;
 
 	if (ctx->curclient != NULL && ctx->curclient->session != NULL)
@@ -313,9 +336,7 @@ cmd_current_session(struct cmd_ctx *ctx)
 	 */
 	if (c != NULL && c->tty.path != NULL) {
 		ARRAY_INIT(&ss);
-		for (i = 0; i < ARRAY_LENGTH(&sessions); i++) {
+		RB_FOREACH(s, sessions, &sessions) {
-			if ((s = ARRAY_ITEM(&sessions, i)) == NULL)
-				continue;
 			found = 0;
 			RB_FOREACH(wl, winlinks, &s->windows) {
 				TAILQ_FOREACH(wp, &wl->window->panes, entry) {
@@ -331,29 +352,49 @@ cmd_current_session(struct cmd_ctx *ctx)
 				ARRAY_ADD(&ss, s);
 		}
 
-		s = cmd_choose_session(&ss);
+		s = cmd_choose_session_list(&ss);
 		ARRAY_FREE(&ss);
 		if (s != NULL)
 			return (s);
 	}
 
 	/* Use the session from the TMUX environment variable. */
-	if (data != NULL && data->pid != -1) {
+	if (data != NULL && data->pid == getpid() && data->idx != -1) {
-		if (data->pid != getpid())
+		s = session_find_by_index(data->idx);
-			return (NULL);
+		if (s != NULL)
-		if (data->idx > ARRAY_LENGTH(&sessions))
+			return (s);
-			return (NULL);
-		if ((s = ARRAY_ITEM(&sessions, data->idx)) == NULL)
-			return (NULL);
-		return (s);
 	}
 
-	return (cmd_choose_session(&sessions));
+	return (cmd_choose_session(prefer_unattached));
+}
+
+/*
+ * Find the most recently used session, preferring unattached if the flag is
+ * set.
+ */
+struct session *
+cmd_choose_session(int prefer_unattached)
+{
+	struct session	*s, *sbest;
+	struct timeval	*tv = NULL;
+
+	sbest = NULL;
+	RB_FOREACH(s, sessions, &sessions) {
+		if (tv == NULL || timercmp(&s->activity_time, tv, >) ||
+		    (prefer_unattached &&
+		    !(sbest->flags & SESSION_UNATTACHED) &&
+		    (s->flags & SESSION_UNATTACHED))) {
+			sbest = s;
+			tv = &s->activity_time;
+		}
+	}
+
+	return (sbest);
 }
 
 /* Find the most recently used session from a list. */
 struct session *
-cmd_choose_session(struct sessions *ss)
+cmd_choose_session_list(struct sessionslist *ss)
 {
 	struct session	*s, *sbest;
 	struct timeval	*tv = NULL;
@@ -393,7 +434,7 @@ cmd_current_client(struct cmd_ctx *ctx)
 	 * No current client set. Find the current session and return the
 	 * newest of its clients.
 	 */
-	s = cmd_current_session(ctx);
+	s = cmd_current_session(ctx, 0);
 	if (s != NULL && !(s->flags & SESSION_UNATTACHED)) {
 		ARRAY_INIT(&cc);
 		for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
@@ -501,7 +542,6 @@ struct session *
 cmd_lookup_session(const char *name, int *ambiguous)
 {
 	struct session	*s, *sfound;
-	u_int		 i;
 
 	*ambiguous = 0;
 
@@ -510,21 +550,15 @@ cmd_lookup_session(const char *name, int *ambiguous)
 	 * be unique so an exact match can't be ambigious and can just be
 	 * returned.
 	 */
-	for (i = 0; i < ARRAY_LENGTH(&sessions); i++) {
+	if ((s = session_find(name)) != NULL)
-		if ((s = ARRAY_ITEM(&sessions, i)) == NULL)
+		return (s);
-			continue;
-		if (strcmp(name, s->name) == 0)
-			return (s);
-	}
 
 	/*
 	 * Otherwise look for partial matches, returning early if it is found to
 	 * be ambiguous.
 	 */
 	sfound = NULL;
-	for (i = 0; i < ARRAY_LENGTH(&sessions); i++) {
+	RB_FOREACH(s, sessions, &sessions) {
-		if ((s = ARRAY_ITEM(&sessions, i)) == NULL)
-			continue;
 		if (strncmp(name, s->name, strlen(name)) == 0 ||
 		    fnmatch(name, s->name, 0) == 0) {
 			if (sfound != NULL) {
@@ -540,7 +574,7 @@ cmd_lookup_session(const char *name, int *ambiguous)
 /*
  * Lookup a window or return -1 if not found or ambigious. First try as an
  * index and if invalid, use fnmatch or leading prefix. Return NULL but fill in
- * idx if the window index is a valid number but there is now window with that
+ * idx if the window index is a valid number but there is no window with that
  * index.
  */
 struct winlink *
@@ -614,26 +648,89 @@ cmd_lookup_index(struct session *s, const char *name, int *ambiguous)
 	return (-1);
 }
 
+/*
+ * Lookup pane id. An initial % means a pane id. sp must already point to the
+ * current session.
+ */
+struct window_pane *
+cmd_lookup_paneid(const char *arg)
+{
+	const char	*errstr;
+	u_int		 paneid;
+
+	if (*arg != '%')
+		return (NULL);
+
+	paneid = strtonum(arg + 1, 0, UINT_MAX, &errstr);
+	if (errstr != NULL)
+		return (NULL);
+	return (window_pane_find_by_id(paneid));
+}
+
+/* Find session and winlink for pane. */
+struct session *
+cmd_pane_session(struct cmd_ctx *ctx, struct window_pane *wp,
+    struct winlink **wlp)
+{
+	struct session		*s;
+	struct sessionslist	 ss;
+	struct winlink		*wl;
+
+	/* If this pane is in the current session, return that winlink. */
+	s = cmd_current_session(ctx, 0);
+	if (s != NULL) {
+		wl = winlink_find_by_window(&s->windows, wp->window);
+		if (wl != NULL) {
+			if (wlp != NULL)
+				*wlp = wl;
+			return (s);
+		}
+	}
+
+	/* Otherwise choose from all sessions with this pane. */
+	ARRAY_INIT(&ss);
+	RB_FOREACH(s, sessions, &sessions) {
+		if (winlink_find_by_window(&s->windows, wp->window) != NULL)
+			ARRAY_ADD(&ss, s);
+	}
+	s = cmd_choose_session_list(&ss);
+	ARRAY_FREE(&ss);
+	if (wlp != NULL)
+		*wlp = winlink_find_by_window(&s->windows, wp->window);
+	return (s);
+}
+
 /* Find the target session or report an error and return NULL. */
 struct session *
-cmd_find_session(struct cmd_ctx *ctx, const char *arg)
+cmd_find_session(struct cmd_ctx *ctx, const char *arg, int prefer_unattached)
 {
-	struct session	*s;
+	struct session		*s;
-	struct client	*c;
+	struct window_pane	*wp;
-	char		*tmparg;
+	struct client		*c;
-	size_t		 arglen;
+	char			*tmparg;
-	int		 ambiguous;
+	size_t			 arglen;
+	int			 ambiguous;
 
 	/* A NULL argument means the current session. */
 	if (arg == NULL)
-		return (cmd_current_session(ctx));
+		return (cmd_current_session(ctx, prefer_unattached));
-	tmparg = xstrdup(arg);
+
+	/* Lookup as pane id. */
+	if ((wp = cmd_lookup_paneid(arg)) != NULL)
+		return (cmd_pane_session(ctx, wp, NULL));
 
 	/* Trim a single trailing colon if any. */
+	tmparg = xstrdup(arg);
 	arglen = strlen(tmparg);
 	if (arglen != 0 && tmparg[arglen - 1] == ':')
 		tmparg[arglen - 1] = '\0';
 
+	/* An empty session name is the current session. */
+	if (*tmparg == '\0') {
+		xfree(tmparg);
+		return (cmd_current_session(ctx, prefer_unattached));
+	}
+
 	/* Find the session, if any. */
 	s = cmd_lookup_session(tmparg, &ambiguous);
 
@@ -657,17 +754,18 @@ cmd_find_session(struct cmd_ctx *ctx, const char *arg)
 struct winlink *
 cmd_find_window(struct cmd_ctx *ctx, const char *arg, struct session **sp)
 {
-	struct session	*s;
+	struct session		*s;
-	struct winlink	*wl;
+	struct winlink		*wl;
-	const char	*winptr;
+	struct window_pane	*wp;
-	char		*sessptr = NULL;
+	const char		*winptr;
-	int		 ambiguous = 0;
+	char			*sessptr = NULL;
+	int			 ambiguous = 0;
 
 	/*
 	 * Find the current session. There must always be a current session, if
 	 * it can't be found, report an error.
 	 */
-	if ((s = cmd_current_session(ctx)) == NULL) {
+	if ((s = cmd_current_session(ctx, 0)) == NULL) {
 		ctx->error(ctx, "can't establish current session");
 		return (NULL);
 	}
@@ -679,6 +777,14 @@ cmd_find_window(struct cmd_ctx *ctx, const char *arg, struct session **sp)
 		return (s->curw);
 	}
 
+	/* Lookup as pane id. */
+	if ((wp = cmd_lookup_paneid(arg)) != NULL) {
+		s = cmd_pane_session(ctx, wp, &wl);
+		if (sp != NULL)
+			*sp = s;
+		return (wl);
+	}
+
 	/* Time to look at the argument. If it is empty, that is an error. */
 	if (*arg == '\0')
 		goto not_found;
@@ -707,10 +813,8 @@ cmd_find_window(struct cmd_ctx *ctx, const char *arg, struct session **sp)
 		wl = s->curw;
 	else if (winptr[0] == '!' && winptr[1] == '\0')
 		wl = TAILQ_FIRST(&s->lastw);
-	else if (winptr[0] == '+' && winptr[1] == '\0')
+	else if (winptr[0] == '+' || winptr[0] == '-')
-		wl = winlink_next(s->curw);
+		wl = cmd_find_window_offset(winptr, s, &ambiguous);
-	else if (winptr[0] == '-' && winptr[1] == '\0')
-		wl = winlink_previous(s->curw);
 	else
 		wl = cmd_lookup_window(s, winptr, &ambiguous);
 	if (wl == NULL)
@@ -728,25 +832,28 @@ no_colon:
 	if (arg[0] == '!' && arg[1] == '\0') {
 		if ((wl = TAILQ_FIRST(&s->lastw)) == NULL)
 			goto not_found;
-	} else if (arg[0] == '+' && arg[1] == '\0') {
+	} else if (arg[0] == '+' || arg[0] == '-') {
-		if ((wl = winlink_next(s->curw)) == NULL)
+		if ((wl = cmd_find_window_offset(arg, s, &ambiguous)) == NULL)
-			goto not_found;
+			goto lookup_session;
-	} else if (arg[0] == '-' && arg[1] == '\0') {
+	} else if ((wl = cmd_lookup_window(s, arg, &ambiguous)) == NULL)
-		if ((wl = winlink_previous(s->curw)) == NULL)
+		goto lookup_session;
-			goto not_found;
-	} else if ((wl = cmd_lookup_window(s, arg, &ambiguous)) == NULL) {
-		if (ambiguous)
-			goto not_found;
-		if ((s = cmd_lookup_session(arg, &ambiguous)) == NULL)
-			goto no_session;
-		wl = s->curw;
-	}
 
 	if (sp != NULL)
 		*sp = s;
 
 	return (wl);
 
+lookup_session:
+	if (ambiguous)
+		goto not_found;
+	if (*arg != '\0' && (s = cmd_lookup_session(arg, &ambiguous)) == NULL)
+		goto no_session;
+
+	if (sp != NULL)
+		*sp = s;
+
+	return (s->curw);
+
 no_session:
 	if (ambiguous)
 		ctx->error(ctx, "multiple sessions: %s", arg);
@@ -766,6 +873,26 @@ not_found:
 	return (NULL);
 }
 
+struct winlink *
+cmd_find_window_offset(const char *winptr, struct session *s, int *ambiguous)
+{
+	struct winlink	*wl;
+	int		 offset = 1;
+
+	if (winptr[1] != '\0')
+		offset = strtonum(winptr + 1, 1, INT_MAX, NULL);
+	if (offset == 0)
+		wl = cmd_lookup_window(s, winptr, ambiguous);
+	else {
+		if (winptr[0] == '+')
+			wl = winlink_next_by_number(s->curw, s, offset);
+		else
+			wl = winlink_previous_by_number(s->curw, s, offset);
+	}
+
+	return (wl);
+}
+
 /*
  * Find the target session and window index, whether or not it exists in the
  * session. Return -2 on error or -1 if no window index is specified. This is
@@ -785,7 +912,7 @@ cmd_find_index(struct cmd_ctx *ctx, const char *arg, struct session **sp)
 	 * Find the current session. There must always be a current session, if
 	 * it can't be found, report an error.
 	 */
-	if ((s = cmd_current_session(ctx)) == NULL) {
+	if ((s = cmd_current_session(ctx, 0)) == NULL) {
 		ctx->error(ctx, "can't establish current session");
 		return (-2);
 	}
@@ -827,20 +954,11 @@ cmd_find_index(struct cmd_ctx *ctx, const char *arg, struct session **sp)
 		if ((wl = TAILQ_FIRST(&s->lastw)) == NULL)
 			goto not_found;
 		idx = wl->idx;
-	} else if (winptr[0] == '+' && winptr[1] == '\0') {
+	} else if (winptr[0] == '+' || winptr[0] == '-') {
-		if (s->curw->idx == INT_MAX)
+		if ((idx = cmd_find_index_offset(winptr, s, &ambiguous)) < 0)
-			goto not_found;
+			goto invalid_index;
-		idx = s->curw->idx + 1;
+	} else if ((idx = cmd_lookup_index(s, winptr, &ambiguous)) == -1)
-	} else if (winptr[0] == '-' && winptr[1] == '\0') {
+		goto invalid_index;
-		if (s->curw->idx == 0)
-			goto not_found;
-		idx = s->curw->idx - 1;
-	} else if ((idx = cmd_lookup_index(s, winptr, &ambiguous)) == -1) {
-		if (ambiguous)
-			goto not_found;
-		ctx->error(ctx, "invalid index: %s", arg);
-		idx = -2;
-	}
 
 	if (sessptr != NULL)
 		xfree(sessptr);
@@ -855,27 +973,28 @@ no_colon:
 		if ((wl = TAILQ_FIRST(&s->lastw)) == NULL)
 			goto not_found;
 		idx = wl->idx;
-	} else if (arg[0] == '+' && arg[1] == '\0') {
+	} else if (arg[0] == '+' || arg[0] == '-') {
-		if (s->curw->idx == INT_MAX)
+		if ((idx = cmd_find_index_offset(arg, s, &ambiguous)) < 0)
-			goto not_found;
+			goto lookup_session;
-		idx = s->curw->idx + 1;
+	} else if ((idx = cmd_lookup_index(s, arg, &ambiguous)) == -1)
-	} else if (arg[0] == '-' && arg[1] == '\0') {
+		goto lookup_session;
-		if (s->curw->idx == 0)
-			goto not_found;
-		idx = s->curw->idx - 1;
-	} else if ((idx = cmd_lookup_index(s, arg, &ambiguous)) == -1) {
-		if (ambiguous)
-			goto not_found;
-		if ((s = cmd_lookup_session(arg, &ambiguous)) == NULL)
-			goto no_session;
-		idx = -1;
-	}
 
 	if (sp != NULL)
 		*sp = s;
 
 	return (idx);
 
+lookup_session:
+	if (ambiguous)
+		goto not_found;
+	if (*arg != '\0' && (s = cmd_lookup_session(arg, &ambiguous)) == NULL)
+		goto no_session;
+
+	if (sp != NULL)
+		*sp = s;
+
+	return (-1);
+
 no_session:
 	if (ambiguous)
 		ctx->error(ctx, "multiple sessions: %s", arg);
@@ -885,6 +1004,15 @@ no_session:
 		xfree(sessptr);
 	return (-2);
 
+invalid_index:
+	if (ambiguous)
+		goto not_found;
+	ctx->error(ctx, "invalid index: %s", arg);
+
+	if (sessptr != NULL)
+		xfree(sessptr);
+	return (-2);
+
 not_found:
 	if (ambiguous)
 		ctx->error(ctx, "multiple windows: %s", arg);
@@ -895,6 +1023,32 @@ not_found:
 	return (-2);
 }
 
+int
+cmd_find_index_offset(const char *winptr, struct session *s, int *ambiguous)
+{
+	int	idx, offset = 1;
+
+	if (winptr[1] != '\0')
+		offset = strtonum(winptr + 1, 1, INT_MAX, NULL);
+	if (offset == 0)
+		idx = cmd_lookup_index(s, winptr, ambiguous);
+	else {
+		if (winptr[0] == '+') {
+			if (s->curw->idx == INT_MAX)
+				idx = cmd_lookup_index(s, winptr, ambiguous);
+			else
+				idx = s->curw->idx + offset;
+		} else {
+			if (s->curw->idx == 0)
+				idx = cmd_lookup_index(s, winptr, ambiguous);
+			else
+				idx = s->curw->idx - offset;
+		}
+	}
+
+	return (idx);
+}
+
 /*
  * Find the target session, window and pane number or report an error and
  * return NULL. The pane number is separated from the session:window by a .,
@@ -904,15 +1058,14 @@ struct winlink *
 cmd_find_pane(struct cmd_ctx *ctx,
     const char *arg, struct session **sp, struct window_pane **wpp)
 {
-	struct session		*s;
+	struct session	*s;
-	struct winlink		*wl;
+	struct winlink	*wl;
-	struct layout_cell	*lc;
+	const char	*period, *errstr;
-	const char		*period, *errstr;
+	char		*winptr, *paneptr;
-	char			*winptr, *paneptr;
+	u_int		 idx;
-	u_int			 idx;
 
 	/* Get the current session. */
-	if ((s = cmd_current_session(ctx)) == NULL) {
+	if ((s = cmd_current_session(ctx, 0)) == NULL) {
 		ctx->error(ctx, "can't establish current session");
 		return (NULL);
 	}
@@ -925,6 +1078,14 @@ cmd_find_pane(struct cmd_ctx *ctx,
 		return (s->curw);
 	}
 
+	/* Lookup as pane id. */
+	if ((*wpp = cmd_lookup_paneid(arg)) != NULL) {
+		s = cmd_pane_session(ctx, *wpp, &wl);
+		if (sp != NULL)
+			*sp = s;
+		return (wl);
+	}
+
 	/* Look for a separating period. */
 	if ((period = strrchr(arg, '.')) == NULL)
 		goto no_period;
@@ -941,6 +1102,8 @@ cmd_find_pane(struct cmd_ctx *ctx,
 	paneptr = winptr + (period - arg) + 1;
 	if (*paneptr == '\0')
 		*wpp = wl->window->active;
+	else if (paneptr[0] == '+' || paneptr[0] == '-')
+		*wpp = cmd_find_pane_offset(paneptr, wl);
 	else {
 		idx = strtonum(paneptr, 0, INT_MAX, &errstr);
 		if (errstr != NULL)
@@ -955,14 +1118,13 @@ cmd_find_pane(struct cmd_ctx *ctx,
 
 lookup_string:
 	/* Try pane string description. */
-	if ((lc = layout_find_string(s->curw->window, paneptr)) == NULL) {
+	if ((*wpp = window_find_string(wl->window, paneptr)) == NULL) {
 		ctx->error(ctx, "can't find pane: %s", paneptr);
 		goto error;
 	}
-	*wpp = lc->wp;
 
 	xfree(winptr);
-	return (s->curw);
+	return (wl);
 
 no_period:
 	/* Try as a pane number alone. */
@@ -978,10 +1140,8 @@ no_period:
 
 lookup_window:
 	/* Try pane string description. */
-	if ((lc = layout_find_string(s->curw->window, arg)) != NULL) {
+	if ((*wpp = window_find_string(s->curw->window, arg)) != NULL)
-		*wpp = lc->wp;
 		return (s->curw);
-	}
 
 	/* Try as a window and use the active pane. */
 	if ((wl = cmd_find_window(ctx, arg, sp)) != NULL)
@@ -993,6 +1153,25 @@ error:
 	return (NULL);
 }
 
+struct window_pane *
+cmd_find_pane_offset(const char *paneptr, struct winlink *wl)
+{
+	struct window		*w = wl->window;
+	struct window_pane	*wp = w->active;
+	u_int			 offset = 1;
+
+	if (paneptr[1] != '\0')
+		offset = strtonum(paneptr + 1, 1, INT_MAX, NULL);
+	if (offset > 0) {
+		if (paneptr[0] == '+')
+			wp = window_pane_next_by_number(w, wp, offset);
+		else
+			wp = window_pane_previous_by_number(w, wp, offset);
+	}
+
+	return (wp);
+}
+
 /* Replace the first %% or %idx in template by s. */
 char *
 cmd_template_replace(char *template, const char *s, int idx)
@@ -1033,3 +1212,35 @@ cmd_template_replace(char *template, const char *s, int idx)
 
 	return (buf);
 }
+
+/* Return the default path for a new pane. */
+const char *
+cmd_get_default_path(struct cmd_ctx *ctx)
+{
+	const char		*cwd;
+	struct session		*s;
+	struct window_pane	*wp;
+	struct environ_entry	*envent;
+
+	if ((s = cmd_current_session(ctx, 0)) == NULL)
+		return (NULL);
+
+	cwd = options_get_string(&s->options, "default-path");
+	if ((cwd[0] == '~' && cwd[1] == '\0') || !strcmp(cwd, "$HOME")) {
+		envent = environ_find(&global_environ, "HOME");
+		if (envent != NULL && *envent->value != '\0')
+			return envent->value;
+		cwd = "";
+	}
+	if (*cwd == '\0') {
+		if (ctx->cmdclient != NULL && ctx->cmdclient->cwd != NULL)
+			return (ctx->cmdclient->cwd);
+		if (ctx->curclient != NULL) {
+			wp = s->curw->window->active;
+			if ((cwd = osdep_get_cwd(wp->pid)) != NULL)
+				return (cwd);
+		}
+		return (s->cwd);
+	}
+	return (cwd);
+}

colour.c

@@ -1,4 +1,4 @@
-/* $Id: colour.c,v 1.7 2009-09-11 14:13:52 tcunha Exp $ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,6 +18,7 @@
 
 #include <sys/types.h>
 
+#include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -28,6 +29,100 @@
  * of the 256 colour palette.
  */
 
+/* An RGB colour. */
+struct colour_rgb {
+	u_char	r;
+	u_char	g;
+	u_char	b;
+};
+
+/* 256 colour RGB table, generated on first use. */
+struct colour_rgb *colour_rgb_256;
+
+void	colour_rgb_generate256(void);
+u_int	colour_rgb_distance(struct colour_rgb *, struct colour_rgb *);
+int	colour_rgb_find(struct colour_rgb *);
+
+/* Generate 256 colour RGB table. */
+void
+colour_rgb_generate256(void)
+{
+	struct colour_rgb	*rgb;
+	u_int			 i, r, g, b;
+
+	/*
+	 * Allocate the table. The first 16 colours are often changed by users
+	 * and terminals so don't include them.
+	 */
+	colour_rgb_256 = xcalloc(240, sizeof *colour_rgb_256);
+
+	/* Add the colours first. */
+	r = g = b = 0;
+	for (i = 240; i > 24; i--) {
+		rgb = &colour_rgb_256[240 - i];
+
+		if (r != 0)
+			rgb->r = (r * 40) + 55;
+		if (g != 0)
+			rgb->g = (g * 40) + 55;
+		if (b != 0)
+			rgb->b = (b * 40) + 55;
+
+		b++;
+		if (b > 5) {
+			b = 0;
+			g++;
+		}
+		if (g > 5) {
+			g = 0;
+			r++;
+		}
+	}
+
+	/* Then add the greys. */
+	for (i = 24; i > 0; i--) {
+		rgb = &colour_rgb_256[240 - i];
+
+		rgb->r = 8 + (24 - i) * 10;
+		rgb->g = 8 + (24 - i) * 10;
+		rgb->b = 8 + (24 - i) * 10;
+	}
+}
+
+/* Get colour RGB distance. */
+u_int
+colour_rgb_distance(struct colour_rgb *rgb1, struct colour_rgb *rgb2)
+{
+	int	r, g, b;
+
+	r = rgb1->r - rgb2->r;
+	g = rgb1->g - rgb2->g;
+	b = rgb1->b - rgb2->b;
+	return (r * r + g * g + b * b);
+}
+
+/* Work out the nearest colour from the 256 colour set. */
+int
+colour_rgb_find(struct colour_rgb *rgb)
+{
+	u_int	distance, lowest, colour, i;
+
+	if (colour_rgb_256 == NULL)
+		colour_rgb_generate256();
+
+	colour = 16;
+	lowest = UINT_MAX;
+	for (i = 0; i < 240; i++) {
+		distance = colour_rgb_distance(&colour_rgb_256[i], rgb);
+		if (distance < lowest) {
+			lowest = distance;
+			colour = 16 + i;
+		}
+	}
+	return (colour);
+}
+
+/* Set grid cell foreground colour. */
 void
 colour_set_fg(struct grid_cell *gc, int c)
 {
@@ -36,6 +131,7 @@ colour_set_fg(struct grid_cell *gc, int c)
 	gc->fg = c;
 }
 
+/* Set grid cell background colour. */
 void
 colour_set_bg(struct grid_cell *gc, int c)
 {
@@ -44,6 +140,7 @@ colour_set_bg(struct grid_cell *gc, int c)
 	gc->bg = c;
 }
 
+/* Convert colour to a string. */
 const char *
 colour_tostring(int c)
 {
@@ -73,15 +170,45 @@ colour_tostring(int c)
 		return ("white");
 	case 8:
 		return ("default");
+	case 90:
+		return ("brightblack");
+	case 91:
+		return ("brightred");
+	case 92:
+		return ("brightgreen");
+	case 93:
+		return ("brightyellow");
+	case 94:
+		return ("brightblue");
+	case 95:
+		return ("brightmagenta");
+	case 96:
+		return ("brightcyan");
+	case 97:
+		return ("brightwhite");
 	}
 	return (NULL);
 }
 
+/* Convert colour from string. */
 int
 colour_fromstring(const char *s)
 {
-	const char	*errstr;
+	const char		*errstr;
-	int		 n;
+	const char		*cp;
+	struct colour_rgb	 rgb;
+	int			 n;
+
+	if (*s == '#' && strlen(s) == 7) {
+		for (cp = s + 1; isxdigit((u_char) *cp); cp++)
+			;
+		if (*cp != '\0')
+			return (-1);
+		n = sscanf(s + 1, "%2hhx%2hhx%2hhx", &rgb.r, &rgb.g, &rgb.b);
+		if (n != 3)
+			return (-1);
+		return (colour_rgb_find(&rgb) | 0x100);
+	}
 
 	if (strncasecmp(s, "colour", (sizeof "colour") - 1) == 0) {
 		n = strtonum(s + (sizeof "colour") - 1, 0, 255, &errstr);
@@ -108,9 +235,34 @@ colour_fromstring(const char *s)
 		return (7);
 	if (strcasecmp(s, "default") == 0 || (s[0] == '8' && s[1] == '\0'))
 		return (8);
+	if (strcasecmp(s, "brightblack") == 0 ||
+	    (s[0] == '9' && s[1] == '0' && s[1] == '\0'))
+		return (90);
+	if (strcasecmp(s, "brightred") == 0 ||
+	    (s[0] == '9' && s[1] == '1' && s[1] == '\0'))
+		return (91);
+	if (strcasecmp(s, "brightgreen") == 0 ||
+	    (s[0] == '9' && s[1] == '2' && s[1] == '\0'))
+		return (92);
+	if (strcasecmp(s, "brightyellow") == 0 ||
+	    (s[0] == '9' && s[1] == '3' && s[1] == '\0'))
+		return (93);
+	if (strcasecmp(s, "brightblue") == 0 ||
+	    (s[0] == '9' && s[1] == '4' && s[1] == '\0'))
+		return (94);
+	if (strcasecmp(s, "brightmagenta") == 0 ||
+	    (s[0] == '9' && s[1] == '5' && s[1] == '\0'))
+		return (95);
+	if (strcasecmp(s, "brightcyan") == 0 ||
+	    (s[0] == '9' && s[1] == '6' && s[1] == '\0'))
+		return (96);
+	if (strcasecmp(s, "brightwhite") == 0 ||
+	    (s[0] == '9' && s[1] == '7' && s[1] == '\0'))
+		return (97);
 	return (-1);
 }
 
+/* Convert 256 colour palette to 16. */
 u_char
 colour_256to16(u_char c)
 {
@@ -136,6 +288,7 @@ colour_256to16(u_char c)
 	return (table[c]);
 }
 
+/* Convert 256 colour palette to 88. */
 u_char
 colour_256to88(u_char c)
 {