Tag 1.5 release.

.gitignore

@@ -1,19 +0,0 @@
-*.o
-*~
-*.diff
-*.patch
-*.core
-core
-tags
-.deps/
-compat/.dirstamp
-aclocal.m4
-autom4te.cache/
-config.log
-config.status
-etc/
-tmux
-Makefile
-Makefile.in
-configure
-tmux.1.*

.mailmap

@@ -1,34 +0,0 @@
-Bob Beck		<beck@openbsd.org> beck <beck>
-Igor Sobrado		<sobrado@openbsd.org> sobrado <sobrado>
-Ingo Schwarze		<schwarze@openbsd.org> schwarze <schwarze>
-Jacek Masiulaniec	<jacekm@openbsd.org> jacekm <jacekm>
-Jason McIntyre		<jmc@openbsd.org> jmc <jmc>
-Jason McIntyre		<jmc@openbsd.org> jcm <jcm>
-Joel Sing		<jsing@openbsd.org> jsing <jsing>
-Jonathan Gray		<jsg@openbsd.org> jsg <jsg>
-Kenneth R Westerback	<krw@openbsd.org> krw <krw>
-Marc Espie		<espie@openbsd.org> espie <espie>
-Matthew Dempsky		<matthew@openbsd.org> matthew <matthew>
-Matthias Kilian		<kili@openbsd.org> kili <kili>
-Matthieu Herrb		<matthieu@openbsd.org> matthieu <matthieu>
-Miod Vallat		<miod@openbsd.org> miod <miod>
-Nicholas Marriott	<nicholas.marriott@gmail.com> Nicholas Marriott <nicm@openbsd.org>
-Nicholas Marriott	<nicholas.marriott@gmail.com> nicm <nicm>
-Nicholas Marriott	<nicholas.marriott@gmail.com> no_author <no_author@example.org>
-Okan Demirmen		<okan@openbsd.org> okan <okan>
-Philip Guenther		<guenther@openbsd.org> guenther <guenther>
-Pierre-Yves Ritschard	<pyr@openbsd.org> pyr <pyr>
-Ray Lai			<ray@openbsd.org> ray <ray>
-Ryan McBride		<mcbride@openbsd.org> mcbride <mcbride>
-Sebastian Benoit	<benno@openbsd.org> benno <benno>
-Stefan Sperling		<stsp@openbsd.org> stsp <stsp>
-Stuart Henderson	<sthen@openbsd.org> sthen <sthen>
-Ted Unangst		<tedu@openbsd.org> tedu <tedu>
-Theo de Raadt		<deraadt@openbsd.org> deraadt <deraadt>
-Theo de Raadt		<deraadt@openbsd.org> Theo Deraadt <deraadt@openbsd.org>
-Thomas Adam		<thomas@xteddy.org> Thomas <thomas@xteddy.org>
-Thomas Adam		<thomas@xteddy.org> n6tadam <n6tadam@xteddy.org>
-Thomas Adam		<thomas@xteddy.org> Thomas Adam <thomas.adam@smoothwall.net>
-Tobias Stoeckmann	<tobias@openbsd.org> tobias <tobias>
-Todd C Miller		<millert@openbsd.org> millert <millert>
-William Yodlowsky	<william@openbsd.org> william <william>

.travis.yml

@@ -1,10 +0,0 @@
-language: c
-matrix:
-    include:
-        - compiler: gcc
-        - compiler: clang
-          env: CFLAGS="-g -O2"
-before_install:
-    - sudo apt-get update -qq
-    - sudo apt-get -y install debhelper autotools-dev dh-autoreconf file libncurses5-dev libevent-dev pkg-config libutempter-dev build-essential
-script: (CFLAGS= ./autogen.sh) && ./configure --enable-debug && make

CHANGES

@@ -1,340 +1,3 @@
-CHANGES FROM 2.0 to 2.1 18 October 2015
-
-Incompatible Changes
-====================
-
-* Mouse-mode has been rewritten.  There's now no longer options for:
-	- mouse-resize-pane
-	- mouse-select-pane
-	- mouse-select-window
-	- mode-mouse
-
-  Instead there is just one option:  'mouse' which turns on mouse support
-  entirely.
-* 'default-terminal' is now a session option.  Furthermore, if this is set
-  to 'screen-*' then emulate what screen does.  If italics are wanted, this
-  can be set to 'tmux' but this is still new and not necessarily supported
-  on all platforms with older ncurses installs.
-* The c0-* options for rate-limiting have been removed.  Instead, a backoff
-  approach is used.
-
-Normal Changes
-==============
-
-* New formats:
-	- session_activity
-	- window_linked
-	- window_activity_format
-	- session_alerts
-	- session_last_attached
-	- client_pid
-	- pid
-* 'copy-selection', 'append-selection', 'start-named-buffer' now understand
-  an '-x' flag to prevent it exiting copying mode.
-* 'select-pane' now understands '-P' to set window/pane background colours.
-* 'renumber-windows' now understands windows which are unlinked.
-* 'bind' now understands multiple key tables.  Allows for key-chaining.
-* 'select-layout' understands '-o' to undo the last layout change.
-* The environment is updated when switching sessions as well as attaching.
-* 'select-pane' now understands '-M' for marking a pane.  This marked pane
-  can then be used with commands which understand src-pane specifiers
-  automatically.
-* If a session/window target is prefixed with '=' then only an exact match
-  is considered.
-* 'move-window' understands '-a'.
-* 'update-environment' understands '-E' when attach-session is used on an
-  already attached client.
-* 'show-environment' understands '-s' to output Bourne-compatible commands.
-* New option: 'history-file' to save/restore command prompt history.
-* Copy mode is exited if the history is cleared whilst in copy-mode.
-* 'copy-mode' learned '-e' to exit copy-mode when scrolling to end.
-
-CHANGES FROM 1.9a to 2.0 6 March 2015
-
-Incompatible Changes
-====================
-
-* The choose-list command has been removed.
-* 'terminal-overrides' is now a server option, not a session option.
-* 'message-limit' is now a server option, not a session option.
-* 'monitor-content' option has been removed.
-* 'pane_start_path' option has been removed.
-* The "info" mechanism which used to (for some commands) provide feedback
-  has been removed, and like other commands, they now produce nothing on
-  success.
-
-Normal Changes
-==============
-
-* tmux can now write an entry to utmp if the library 'utempter' is present
-  at compile time.
-* set-buffer learned append mode (-a), and a corresponding
-  'append-selection' command has been added to copy-mode.
-* choose-mode now has the following commands which can be bound:
-	- start-of-list
-	- end-of-list
-	- top-line
-	- bottom-line
-
-* choose-buffer now understands UTF-8.
-* Pane navigation has changed:
-	- The old way of always using the top or left if the choice is ambiguous.
-	- The new way of remembering the last used pane is annoying if the
-	  layout is balanced and the leftmost is obvious to the user (because
-	  clearly if we go right from the top-left in a tiled set of four we want
-	  to end up in top-right, even if we were last using the bottom-right).
-
-      So instead, use a combination of both: if there is only one possible
-      pane alongside the current pane, move to it, otherwise choose the most
-      recently used of the choice.
-* 'set-buffer' can now be told to give names to buffers.
-* The 'new-session', 'new-window', 'split-window', and 'respawn-pane' commands
-  now understand multiple arguments and handle quoting problems correctly.
-* 'capture-pane' understands '-S-' to mean the start of the pane, and '-E-' to
-  mean the end of the pane.
-* Support for function keys beyond F12 has changed.  The following explains:
-	- F13-F24 are S-F1 to S-F12
-	- F25-F36 are C-F1 to C-F12
-	- F37-F48 are C-S-F1 to C-S-F12
-	- F49-F60 are M-F1 to M-F12
-	- F61-F63 are M-S-F1 to M-S-F3
-
- Therefore, F13 becomes a binding of S-F1, etc.
-* Support using pane id as part of session or window specifier (so % means
-  session-of-%1 or window-of-%1) and window id as part of session
-  (so @1 means session-of-@1).
-* 'copy-pipe' command now understands formats via -F
-* 'if-shell'  command now understands formats via -F
-* 'split-window' and 'join-window' understand -b to create the pane to the left
-  or above the target pane.
-
-CHANGES FROM 1.9 to 1.9a 22 February 2014
-
-NOTE:  This is a bug-fix release to address some important bugs which just
-missed the 1.9 deadline, but were found afterwards.
-
-Normal Changes
-==============
-
-* Fix crash due to uninitialized lastwp member of layout_cell
-* Fix -fg/-bg/-style with 256 colour terminals.  
-
-CHANGES FROM 1.8 to 1.9, 20 February 2014
-
-NOTE:  This release has bumped the tmux protocol version.  It is therefore
-advised that the prior tmux server is restarted when this version of tmux is
-installed, to avoid protocol mismatch errors for newer clients trying to
-talk to an older running tmux server.
-
-Incompatible Changes
-====================
-
-* 88 colour support has been removed.
-* 'default-path' has been removed.  The new-window command accepts '-c' to
-  cater for this.  The previous value of "." can be replaced with: 'neww -c
-  $PWD', the previous value of '' which meant current path of the pane can
-  be specified as:  'neww -c "#{pane_current_path}"'
-
-Deprecated Changes
-==================
-
-* The single format specifiers:  #A -> #Z (where defined) have been
-  deprecated and replaced with longer-named equivalents, as listed in the
-  FORMATS section of the tmux manpage.
-* The various foo-{fg,bg,attr} commands have been deprecated and replaced
-  with equivalent foo-style option instead.  Currently this is still
-  backwards-compatible, but will be removed over time.
-
-Normal Changes
-==============
-
-* A new environment variable TMUX_TMPDIR is now honoured, allowing the
-  socket directory to be set outside of TMPDIR (/tmp/ if not set).
-* If -s not given to swap-pane the current pane is assumed.
-* A #{pane_syncronized} format specifier has been added to be a conditional
-  format if a pane is in a syncronised mode (c.f. syncronize-panes)
-* Tmux now runs under Cygwin natively.
-* Formats can now be nested within each other and expanded accordingly.
-* Added 'automatic-rename-format' option to allow the automatic rename
-  mechanism to use something other than the default of
-  #{pane_current_command}.
-* new-session learnt '-c' to specify the starting directory for that session
-  and all subsequent windows therein.
-* The session name is now shown in the message printed to the terminal when
-  a session is detached.
-* Lots more format specifiers have been added.
-* Server race conditions have been fixed; in particular commands are not run
-  until after the configuration file is read completely.
-* Case insensitive searching in tmux's copy-mode is now possible.
-* attach-session and switch-client learnt the '-t' option to accept a window
-  and/or a pane to use.
-* Copy-mode is only exited if no selection is in progress.
-* Paste key in copy-mode is now possible to enter text from the clipboard.
-* status-interval set to '0' now works as intended.
-* tmux now supports 256 colours running under fbterm.
-* Many bug fixes!
-
-CHANGES FROM 1.7 to 1.8, 26 March 2013
-
-Incompatible Changes
-====================
-
-* layout redo/undo has been removed.
-
-Normal Changes
-==============
-
-* Add halfpage up/down bindings to copy mode.
-* Session choosing fixed to work with unattached sessions.
-* New window options window-status-last-{attr,bg,fg} to denote the last
-  window which was active.
-* Scrolling in copy-mode now scrolls the region without moving the mouse
-  cursor.
-* run-shell learnt '-t' to specify the pane to use when displaying output.
-* Support for middle-click pasting.
-* choose-tree learns '-u' to start uncollapsed.
-* select-window learnt '-T' to toggle to the last window if it's already
-  current.
-* New session option 'assume-paste-time' for pasting text versus key-binding
-  actions.
-* choose-* commands now work outside of an attached client.
-* Aliases are now shown for list-commands command.
-* Status learns about formats.
-* Free-form options can be set with set-option if prepended with an '@'
-  sign.
-* capture-pane learnt '-p' to send to stdout, and '-e' for capturing escape
-  sequences, and '-a' to capture the alternate screen, and '-P' to dump
-  pending output.
-* Many new formats added (client_session, client_last_session, etc.)
-* Control mode, which is a way for a client to send tmux commands.
-  Currently more useful to users of iterm2.
-* resize-pane learnt '-x' and '-y' for absolute pane sizing.
-* Config file loading now reports errors from all files which are loaded via
-  the 'source-file' command.
-* 'copy-pipe' mode command to copy selection and pipe the selection to a
-  command.
-* Panes can now emit focus notifications for certain applications
-  which use those.
-* run-shell and if-shell now accept formats.
-* resize-pane learnt '-Z' for zooming a pane temporarily.
-* new-session learnt '-A' to make it behave like attach-session.
-* set-option learnt '-o' to prevent setting an option which is already set.
-* capture-pane and show-options learns '-q' to silence errors.
-* New command 'wait-for' which blocks a client until woken up again.
-* Resizing panes will now reflow the text inside them.
-* Lots and lots of bug fixes, fixing memory-leaks, etc.
-* Various manpage improvements.
-
-CHANGES FROM 1.6 to 1.7, 13 October 2012
-
-* tmux configuration files now support line-continuation with a "\" at the
-  end of a line.
-* New option status-position to move the status line to the top or bottom of
-  the screen.
-* Enforce history-limit option when clearing the screen.
-* Give each window a unique id, like panes but prefixed with @.
-* Add pane id to each pane in layout description (while still accepting
-  the old form).
-* Provide defined ways to set the various default-path possibilities: ~
-  for home directory, . for server start directory, - for session start
-  directory and empty for the pane's working directory (the default). All
-  can also be used as part of a relative path (eg -/foo). Also provide -c
-  flags to neww and splitw to override default-path setting.
-* Add -l flag to send-keys to send input literally (without translating
-  key names).
-* Allow a single option to be specified to show-options to show just that
-  option.
-* New command "move-pane" (like join-pane but allows the same window).
-* join-pane and move-pane commands learn "-b" option to place the pane to
-  the left or above.
-* Support for bracketed-paste mode.
-* Allow send-keys command to accept hex values.
-* Add locking around "start-server" to avoid race-conditions.
-* break-pane learns -P/-F arguments for display formatting.
-* set-option learns "-q" to make it quiet, and not print out anything.
-* copy mode learns "wrap-search" option.
-* Add a simple form of output rate limiting by counting the number of
-  certain C0 sequences (linefeeds, backspaces, carriage returns) and if it
-  exceeds a threshold (current default 250/millisecond), start to redraw
-  the pane every 100 milliseconds instead of making each change as it
-  comes. Two configuration options - c0-change-trigger and
-  c0-change-interval.
-* find-window learns new flags:  "-C", "-N", "-T" to match against either or
-  all of a window's content, name, or title.  Defaults to all three options
-  if none specified.
-* find-window automatically selects the appropriate pane for the found
-  matches.
-* show-environment can now accept one option to show that environment value.
-* Exit mouse mode when end-of-screen reached when scrolling with the mouse
-  wheel.
-* select-layout learns -u and -U for layout history stacks.
-* kill-window, detach-client, kill-session all  learn "-a" option for
-  killing all but the current thing specified.
-* move-window learns "-r" option to renumber window sequentially in a
-  session.
-* New session option "renumber-windows" to automatically renumber windows in
-  a session when a window is closed.  (see "move-window -r").
-* Only enter copy-mode on scroll up.
-* choose-* and list-* commands all use "-F" for format specifiers.
-* When spawning external commands, the value from the "default-shell" option
-  is now used, rather than assuming /bin/sh.
-* New choose-tree command to render window/sessions as a tree for selection.
-* display-message learns new format options.
-* For linked-windows across sessions, all flags for that window are now
-  cleared across sessions.
-* Lots and lots of bug fixes, fixing memory-leaks, etc.
-* Various manpage improvements.
-
-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.
@@ -1975,3 +1638,10 @@ The list of older changes is below.
   emacs) that don't require scrolling regions (ESC[r) mostly work fine
   (including mutt, emacs). No status bar yet and no key remapping or other
   customisation.
+
+$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
+ LocalWords:  dstidx srcname srcidx winlink lsw nabc sabc Exp Tiago Cunha dch
+ LocalWords:  setw Chisnall renamew merdely eg Maier newname selectw neww Gass

COPYING

@@ -1,21 +0,0 @@
-THIS IS FOR INFORMATION ONLY, CODE IS UNDER THE LICENCE AT THE TOP OF ITS FILE.
-
-The README, CHANGES, FAQ and TODO files are licensed under the ISC
-license. Files under examples/ remain copyright their authors unless otherwise
-stated in the file but permission has been received to distribute them with
-tmux. All other files have a license and copyright notice at their start,
-typically:
-
-Copyright (c) <author>
-
-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.

FAQ

@@ -95,6 +95,9 @@ aware of are (bearing in mind I haven't used screen for a few years now):
 - 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
@@ -104,12 +107,8 @@ aware of are (bearing in mind I haven't used screen for a few years now):
 
 * I found a bug! What do I do?
 
-Check the latest version of tmux from Git to see if the problem is still
+Please send bug reports by email to nicm@users.sourceforge.net or
-reproducible.  Sometimes the length of time between releases means a lot of
+tmux-users@lists.sourceforge.net. Please include as much of the following
-fixes can be sitting in Git and the problem might already be fixed.
-
-Please send bug reports by email to nicholas.marriott@gmail.com or
-tmux-users@googlegroups.com. Please include as much of the following
 information as possible:
 
 - the version of tmux you are running;
@@ -123,7 +122,7 @@ information as possible:
 
 * Why doesn't tmux do $x?
 
-Please send feature requests by email to tmux-users@googlegroups.com.
+Please send feature requests by email to nicm@users.sourceforge.net.
 
 * Why do you use the screen terminal description inside tmux? It sucks.
 
@@ -239,31 +238,6 @@ would be welcome.
 
 vim users may also want to set the "ttyfast" option inside tmux.
 
-* How do I make ctrl and shift arrow keys work in emacs?
-
-The terminal-init-screen function in term/screen.el is called for new frames,
-but it doesn't configure any function keys.
-
-If the tmux xterm-keys option is on, it is enough to define the same keys as
-xterm. Add the following to init.el or .emacs to do this:
-
-(defadvice terminal-init-screen
-  ;; The advice is named `tmux', and is run before `terminal-init-screen' runs.
-  (before tmux activate)
-  ;; Docstring.  This describes the advice and is made available inside emacs;
-  ;; for example when doing C-h f terminal-init-screen RET
-  "Apply xterm keymap, allowing use of keys passed through tmux."
-  ;; This is the elisp code that is run before `terminal-init-screen'.
-  (if (getenv "TMUX")
-    (let ((map (copy-keymap xterm-function-map)))
-    (set-keymap-parent map (keymap-parent input-decode-map))
-    (set-keymap-parent input-decode-map map))))
-
-And ensure .tmux.conf contains "set -g xterm-keys on".
-
-Alternatively, the screen.el file can be copied to the load path and
-customized.
-
 * 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
@@ -352,103 +326,88 @@ 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'
 
-* I don't see italics! Or less and vim show italics and reverse the wrong way round!
+* How can I open a new window in the same directory as the current window?
 
-GNU screen does not support italics and the "screen" terminfo description uses
+One option is to just run "TMUX= tmux" in the window. However, this only works if no
-the italics escape sequence incorrectly.
+command is running, so that you can input the command.
 
-As of tmux 2.1, if default-terminal is set to "screen" or matches "screen-*",
+A workaround is to let tmux know about the current path through an environment
-tmux will behave like screen and italics will be disabled.
+variable. To do so, use the following command:
 
-To enable italics, create a new terminfo entry called "tmux" (some platforms
+    [ -n "$TMUX" ] && tmux setenv TMUXPWD_$(tmux display -p "#I") $PWD
-may already have this, you can check with "infocmp tmux"):
 
-	$ cat <<EOF|tic -x -
+Which sets TMUXPWD_i (where i is the number of the current window) to the path
-	tmux|tmux terminal multiplexer,
+of the current directory. This command can be added to PS1, for example:
-		ritm=\E[23m, rmso=\E[27m, sitm=\E[3m, smso=\E[7m, Ms@,
-		use=xterm+tmux, use=screen,
 
-	tmux-256color|tmux with 256 colors,
+    PS1='$([ -n "$TMUX" ] && tmux setenv TMUXPWD_$(tmux display -p "#I") $PWD)\h$ '
-		use=xterm+256setaf, use=tmux,
+
-	EOF
+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 "tmux"
+	set -g default-terminal "screen-it"
 
-If using urxvt, make sure you have an italics capable font enabled. for
+If your terminal supports 256 colors, use:
-example, add to ~/.Xdefaults:
+
+	$ 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
-
-* How can I make tmux use my terminal's scrollback buffer?
-
-Normally, tmux enables the terminal's "alternate screen". Most terminals (such
-as xterm) do not save scrollback for the alternate screen. You might prefer
-tmux to use the normal screen, so it uses your terminal's scrollback
-buffer. This way, you can access the scrollback buffer as usual, for example
-using the mouse wheel - although there is no guarantee output inside tmux will
-always (or ever) be added to the scrollback.
-
-You can make tmux use the normal screen by telling it that your terminal does
-not have an alternate screen. Put the following in ~/.tmux.conf:
-
-        set -ga terminal-overrides ',xterm*:smcup@:rmcup@'
-
-Adjust if your $TERM does not start with xterm.
-
-tmux will still emulate the alternate screen for applications run under tmux,
-so you don't really lose anything with this setting. The only disadvantage is
-that when you exit tmux, it will not restore whatever was there before you
-started.
-
-* How do I see the default configuration?
-
-Show the default session options by starting a new tmux server with no
-configuration file:
-
-        $ tmux -Lfoo -f/dev/null start\; show -g
-
-Or the default window options:
-
-        $ tmux -Lfoo -f/dev/null start\; show -gw
-
-* How do I copy a selection from tmux to the system's clipboard?
-
-When running in xterm(1), tmux can automatically send copied text to the
-clipboard. This is controlled by the set-clipboard option and also needs this
-X resource to be set:
-
-	XTerm*disallowedWindowOps: 20,21,SetXprop
-
-For rxvt-unicode (urxvt), there is an unofficial Perl extension here:
-
-        http://anti.teamidiot.de/static/nei/*/Code/urxvt/
-
-Otherwise a key binding for copy mode using xclip (or xsel) works:
-
-	bind -temacs-copy C-y copy-pipe "xclip -i >/dev/null"
-
-Or for inside and outside copy mode with the prefix key:
-
-        bind C-y run -b "tmux save-buffer - | xclip -i"
-
-On OS X, reattach-to-usernamespace lets pbcopy/pbpaste work:
-
-        https://github.com/ChrisJohnsen/tmux-MacOSX-pasteboard
  
-* Why do I see dots around a session when I attach to it?
+$Id$
-
-tmux limits the size of the window to the smallest attached session. If
-it didn't do this then it would be impossible to see the entire window.
-The dots mark the size of the window tmux can display.
-
-To avoid this, detach all other clients when attaching:
-
-	$ tmux attach -d
-
-Or from inside tmux by detaching individual clients with C-b D or all
-using:
-
-	C-b : attach -d

Makefile.am

@@ -1,19 +1,19 @@
-# Makefile.am
+# $Id$
 
 # Obvious program stuff.
 bin_PROGRAMS = tmux
-CLEANFILES = tmux.1.mdoc tmux.1.man
+dist_man1_MANS = tmux.1
 
 # Distribution tarball options.
 EXTRA_DIST = \
-	CHANGES FAQ README TODO COPYING examples compat/*.[ch] \
+	CHANGES FAQ NOTES TODO examples compat \
-	array.h compat.h tmux.h osdep-*.c mdoc2man.awk tmux.1
+	array.h compat.h tmux.h osdep-*.c
 dist-hook:
-	make clean
 	grep "^#found_debug=" configure
+	find $(distdir) -name .svn -type d|xargs rm -Rf
 
 # Preprocessor flags.
-CPPFLAGS += @XOPEN_DEFINES@ -DTMUX_CONF="\"$(sysconfdir)/tmux.conf\""
+CPPFLAGS += @XOPEN_DEFINES@
 
 # glibc as usual does things ass-backwards and hides useful things by default,
 # so everyone has to add this.
@@ -21,75 +21,79 @@ if IS_GLIBC
 CFLAGS += -D_GNU_SOURCE
 endif
 
-# Set flags for gcc.
+# Set flags for gcc. gcc4 whines abouts silly stuff so it needs slightly
+# different flags.
 if IS_GCC
-CFLAGS += -std=gnu99 -O2
+CFLAGS += -std=c99
 if IS_DEBUG
-CFLAGS += -g
+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
-CFLAGS += -Wdeclaration-after-statement -Wno-pointer-sign
 CPPFLAGS += -DDEBUG
 endif
-if IS_COVERAGE
+if IS_GCC4
-CFLAGS += -g -O0 --coverage
+CPPFLAGS += -iquote. -I/usr/local/include
-LDFLAGS += --coverage
+if IS_DEBUG
+CFLAGS += -Wno-pointer-sign
 endif
-CPPFLAGS += -iquote.
+else
+CPPFLAGS += -I. -I- -I/usr/local/include
+endif
+endif
+
+# Set flags for static.
+if IS_STATIC
+LDFLAGS += -static
 endif
 
 # Set flags for Solaris.
 if IS_SUNOS
-if IS_GCC
-CPPFLAGS += -D_XPG6 -D__EXTENSIONS__ -D_POSIX_PTHREAD_SEMANTICS
-else
 CPPFLAGS += -D_XPG4_2 -D__EXTENSIONS__ -D_POSIX_PTHREAD_SEMANTICS
 endif
-endif
 
 # Set flags for Sun CC.
 if IS_SUNCC
 CFLAGS += -erroff=E_EMPTY_DECLARATION
 endif
 
-# Set _LINUX_SOURCE_COMPAT for AIX for mallocing 0 bytes
-if IS_AIX
-DEFS += -D_LINUX_SOURCE_COMPAT=1
-endif
-
 # List of sources.
 dist_tmux_SOURCES = \
-	alerts.c \
 	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-tree.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.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 \
@@ -102,7 +106,6 @@ dist_tmux_SOURCES = \
 	cmd-new-window.c \
 	cmd-paste-buffer.c \
 	cmd-pipe-pane.c \
-	cmd-queue.c \
 	cmd-refresh-client.c \
 	cmd-rename-session.c \
 	cmd-rename-window.c \
@@ -116,27 +119,29 @@ dist_tmux_SOURCES = \
 	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-wait-for.c \
+	cmd-unlink-window.c \
 	cmd.c \
 	colour.c \
-	control.c \
-	control-notify.c \
 	environ.c \
-	format.c \
+	grid-utf8.c \
-	grid-cell.c \
 	grid-view.c \
 	grid.c \
 	input-keys.c \
@@ -150,7 +155,6 @@ dist_tmux_SOURCES = \
 	log.c \
 	mode-key.c \
 	names.c \
-	notify.c \
 	options-table.c \
 	options.c \
 	paste.c \
@@ -160,11 +164,11 @@ dist_tmux_SOURCES = \
 	screen.c \
 	server-client.c \
 	server-fn.c \
+	server-window.c \
 	server.c \
 	session.c \
 	signal.c \
 	status.c \
-	style.c \
 	tmux.c \
 	tty-acs.c \
 	tty-keys.c \
@@ -207,9 +211,6 @@ endif
 if NO_FGETLN
 nodist_tmux_SOURCES += compat/fgetln.c
 endif
-if NO_FPARSELN
-nodist_tmux_SOURCES += compat/fparseln.c
-endif
 if NO_GETOPT
 nodist_tmux_SOURCES += compat/getopt.c
 endif
@@ -225,25 +226,18 @@ endif
 if NO_STRTONUM
 nodist_tmux_SOURCES += compat/strtonum.c
 endif
-if NO_B64_NTOP
-nodist_tmux_SOURCES += compat/b64_ntop.c
-endif
-if NO_CFMAKERAW
-nodist_tmux_SOURCES += compat/cfmakeraw.c
-endif
-if NO_OPENAT
-nodist_tmux_SOURCES += compat/openat.c
-endif
 
-# Install tmux.1 in the right format.
+# Update SF web site.
-install-exec-hook:
+upload-index.html: update-index.html
-	if test x@MANFORMAT@ = xmdoc; then \
+	scp www/index.html www/main.css www/images/*.png \
-		sed -e "s|@SYSCONFDIR@|$(sysconfdir)|g" $(srcdir)/tmux.1 \
+		${USER},tmux@web.sf.net:/home/groups/t/tm/tmux/htdocs
-			>$(srcdir)/tmux.1.mdoc; \
+	rm -f www/index.html www/images/small-*
-	else \
+
-		sed -e "s|@SYSCONFDIR@|$(sysconfdir)|g" $(srcdir)/tmux.1| \
+update-index.html:
-			$(AWK) -f$(srcdir)/mdoc2man.awk >$(srcdir)/tmux.1.man; \
+	(cd www/images && \
-	fi
+		rm -f small-* && \
-	$(mkdir_p) $(DESTDIR)$(mandir)/man1
+		for i in *.png; do \
-	$(INSTALL_DATA) $(srcdir)/tmux.1.@MANFORMAT@ \
+			convert "$$i" -resize 200x150 "small-$$i"; \
-		$(DESTDIR)$(mandir)/man1/tmux.1
+		done \
+	)
+	sed "s/%%VERSION%%/${VERSION}/g" www/index.html.in >www/index.html

NOTES

@@ -0,0 +1,65 @@
+Welcome to tmux!
+
+tmux is a "terminal multiplexer", it enables a number of terminals (or windows)
+to be accessed and controlled from a single terminal. tmux is intended to be a
+simple, modern, BSD-licensed alternative to programs such as GNU screen.
+
+This release runs on OpenBSD, FreeBSD, NetBSD, Linux and OS X and may still
+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 it from:
+
+	http://www.monkey.org/~provos/libevent/
+
+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
+server and attached to a number of clients. Each session may then have a number
+of windows and windows may be linked to a number of sessions. Commands are
+available to create, rename and destroy windows and sessions; to attach and
+detach sessions from client terminals; to set configuration options; to split
+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.
+
+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.
+
+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
+  ~/.vim/syntax/tmux.vim).
+- Make the filetype recognisable by adding the following to filetype.vim
+  in your runtimepath (~/.vim/filetype.vim):
+
+	augroup filetypedetect
+		au BufNewFile,BufRead .tmux.conf*,tmux.conf* setf tmux
+	augroup END
+
+- Switch on syntax highlighting by adding "syntax enable" to your vimrc file.
+
+For debugging, running tmux with -v or -vv will generate server and client log
+files in the current directory.
+
+tmux mailing lists are available; visit:
+
+	https://sourceforge.net/mail/?group_id=200378
+
+Bug reports, feature suggestions and especially code contributions are most
+welcome. Please send by email to:
+
+	nicm@users.sf.net
+
+This file and the CHANGES, FAQ and TODO files are licensed under the ISC
+license. Files under examples/ remain copyright their authors unless otherwise
+stated in the file but permission has been received to distribute them with
+tmux. All other files have a license and copyright notice at their
+start. Please contact me with any queries.
+
+-- Nicholas Marriott <nicm@users.sf.net>
+
+$Id$

README

@@ -1,61 +0,0 @@
-Welcome to tmux!
-
-tmux is a "terminal multiplexer", it enables a number of terminals (or windows)
-to be accessed and controlled from a single terminal. tmux is intended to be a
-simple, modern, BSD-licensed alternative to programs such as GNU screen.
-
-This release runs on OpenBSD, FreeBSD, NetBSD, Linux, OS X and Solaris.
-
-tmux depends on libevent 2.x. Download it from:
-
-	http://www.monkey.org/~provos/libevent/
-
-To build tmux from a release tarball, do:
-
-	$ ./configure && make
-	$ sudo make install
-
-To get and build the latest from version control:
-
-	$ git clone https://github.com/tmux/tmux.git
-	$ cd tmux
-	$ sh autogen.sh
-	$ ./configure && make
-
-For more information see http://git-scm.com. Patches should be sent by email to
-the mailing list at tmux-users@googlegroups.com.
-
-For documentation on using tmux, see the tmux.1 manpage. It can be viewed from
-the source tree with:
-
-	$ nroff -mdoc tmux.1|less
-
-Some common questions are answered in the FAQ file and a more extensive (but
-slightly out of date) guide is available in the OpenBSD FAQ at
-http://www.openbsd.org/faq/faq7.html#tmux. A rough todo list is in the TODO
-file and some example configurations and a Vim syntax file are in the examples
-directory.
-
-For debugging, running tmux with -v or -vv will generate server and client log
-files in the current directory.
-
-tmux mailing lists are available. For general discussion and bug reports:
-
-	https://groups.google.com/forum/#!forum/tmux-users
-
-And for Git commit emails:
-
-	https://groups.google.com/forum/#!forum/tmux-git
-
-Bug reports, feature suggestions and especially code contributions are most
-welcome. Please send by email to:
-
-	tmux-users@googlegroups.com
-
-This file and the CHANGES, FAQ, SYNCING and TODO files are licensed under
-the ISC license. Files under examples/ remain copyright their authors unless
-otherwise stated in the file but permission has been received to distribute
-them with tmux. All other files have a license and copyright notice at their
-start.
-
--- Nicholas Marriott <nicholas.marriott@gmail.com>

SYNCING

@@ -1,176 +0,0 @@
-Preamble
-========
-
-Tmux portable relies on  repositories "tmux" and "tmux-openbsd".
-Here's a description of them:
-
-* "tmux" is the portable version, the one which contains code for other
-  operating systems, and autotools, etc., which isn't found or needed in the
-  OpenBSD base system.
-
-* "tmux-openbsd" is the version of tmux in OpenBSD base system which provides
-  the basis of the portable tmux version.
-
-Note:  The "tmux-openbsd" repository is actually handled by "git cvsimport"
-running at 15 minute intervals, so a commit made to OpenBSD's tmux CVS
-repository will take at least that long to appear in this git repository.
-(It might take longer, depending on the CVS mirror used to import the
-OpenBSD code).
-
-If you've never used git before, git tracks meta-data about the committer
-and the author, as part of a commit, hence:
-
-% git config [--global] user.name "Your name"
-% git config [--global] user.email "you@yourdomain.com"
-
-Note that, if you already have this in the global ~/.gitconfig option, then
-this will be used.  Setting this per-repository would involve not using the
-"--global" flag above.   If you wish to use the same credentials always,
-pass the "--global" option, as shown.
-
-This is a one-off operation once the repository has been cloned, assuming
-this information has ever been set before.
-
-Cloning repositories
-====================
-
-This involves having both tmux and tmux-openbsd cloned, as in:
-
-% cd /some/where/useful
-% git clone https://github.com/tmux/tmux.git
-% git clone https://github.com/ThomasAdam/tmux-openbsd.git
-
-Note that you do not need additional checkouts to manage the sync -- an
-existing clone of either repositories will suffice.  So if you already have
-these checkouts existing, skip that.
-
-Adding in git-remotes
-=====================
-
-Because the portable "tmux" git repository and the "tmux-openbsd"
-repository do not inherently share any history between each other, the
-history has been faked between them.  This "faking of history" is something
-which has to be told to git for the purposes of comparing the "tmux" and
-"tmux-openbsd" repositories for syncing.  To do this, we must reference the
-clone of the "tmux-openbsd" repository from the "tmux" repository, as
-shown by the following command:
-
-% cd /path/to/tmux
-% git remote add obsd-tmux file:///path/to/tmux-openbsd
-
-So that now, the remote "obsd-tmux" can be used to reference branches and
-commits from the "tmux-openbsd" repository, but from the context of the
-portable "tmux" repository, which makes sense because it's the "tmux"
-repository which will have the updates applied to them.
-
-Fetching updates
-================
-
-To ensure the latest commits from "tmux-openbsd" can be found from within
-"tmux", we have to ensure the "master" branch from "tmux-openbsd" is
-up-to-date first, and then reference that update in "tmux", as in:
-
-% cd /path/to/tmux-openbsd
-% git checkout master
-% git pull
-
-Then back in "tmux":
-
-% cd /path/to/tmux
-% git fetch obsd-tmux
-
-Creating the necessary branches
-===============================
-
-Now that "tmux" can see commits and branches from "tmux-openbsd" by way
-of the remote name "obsd-tmux", we can now create the master branch from
-"tmux-openbsd" in the "tmux" repository:
-
-% git checkout -b obsd-master obsd-tmux/master
-
-Adding in the fake history points
-================================= 
-
-To tie both the "master" branch from "tmux" and the "obsd-master"
-branch from "tmux-openbsd" together, the fake history points added to the
-"tmux" repository need to be added.  To do this, we must add an
-additional refspec line, as in:
-
-% cd /path/to/tmux
-% git config --add remote.origin.fetch '+refs/replace/*:refs/replace/*'
-% git fetch origin
-
-Performing the Sync
-===================
-
-Make sure the "master" branch is checked out:
-
-% git checkout master
-
-The following will show commits on OpenBSD not yet synched with "tmux":
-
-% git log master..obsd-master
-
-From there, merge the result in, fixing up any conflicts which might arise.
-
-% git merge obsd-master
-
-Then ensure things look correct by BULDING the result of that sync:
-
-% make clean && ./autogen.sh && ./configure && make
-
-Compare the git merge result with what's on origin/master -- that is, check
-which commits you're about to push:
-
-% git log origin/master..master
-
-And if happy:
-
-% git push origin master
-
-Keeping an eye on libutil in OpenBSD
-====================================
-
-A lot of the compat/ code in tmux comes from libutil, especially imsg.
-Sometimes the API can change, etc., which might cause interesting problems
-trying to run the portable version of tmux.  It's worth checking
-periodically for any changes to libutil in OpenBSD and syncing those files
-to compat/ as and when appropriate.
-
-Release tmux for next version
-=============================
-
-1. Comment the "found_debug=yes" line in configure.ac, since releases
-   don't have debugging enabled, otherwise make(1) aborts when
-   preparing the distribution.
-
-2. Update and commit README and CHANGES.  The former should be checked for
-   anything outdated and updated with a list of things that might break
-   upgrades and the latter should mention all the major changes since
-   the last version.
-
-3. Tag with:
-
-   % git tag -a 2.X
-
-   Where "2.X" is the next version.
-
-   Push the tag out with:
-
-   % git push 2.X
-
-4. Build the tarball with 'make dist'.
-
-5. Check the tarball.  If it's good, go here to select the tag just pushed:
-
-   https://github.com/tmux/tmux/tags
-
-   Click the "Add release notes", upload the tarball and add a link in the
-   description field to the CHANGES file.
-
-7. Clone the tmux.github.io repository, and change the RELEASE version in
-   the Makefile.  Commit it, and run 'make' to replace %%VERSION%%.  Push
-   the result out.
-
-8. Bump version in tmu/tmux.git configure.ac and uncomment "found_debug=yes" to
-   create a debug build by default.

TODO

@@ -1,126 +1,140 @@
-- command bits and pieces:
+- implicitly add exec to the commands for new windows (switch to disable it)?
-	* allow multiple targets: fnmatch for -t/-c, for example detach all
+- bring back detach-session to detach all clients on a session?
-	  clients with -t*
+- allow fnmatch for -c, so that you can, eg, detach all clients
-	* add -c for new-session like new-window
+- garbage collect window history (100 lines at a time?) if it hasn't been used
-	* ' and " should be parsed the same (eg "\e" vs '\e') in config
+  in $x time
-	  and command prompt
+- flags to centre screen in window
-	* last-pane across sessions
+- activity/bell should be per-window not per-link? what if it is cur win in
-
+  session not being watched?
-- make command sequences more usable
+- next prev word etc in command prompt
-	* don't require space after ;
+- use a better termcap internally instead of screen, perhaps xterm
-	* options for error handling: && and ||?
+- 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
-- options bits and pieces:
+- support other mouse modes (highlight etc) and use it in copy mode
-	* set-remain-on-exit is a complete hack
+- set-remain-on-exit is a bit of a hack, some way to do it generically?
-	* way to set socket path from config file
+- clear window title on exit
-
+- would be nice to be able to use "--" to mark start of command w/ neww etc
-- format improvements:
+  to avoid quoting
-	* option to quote format (#{session_name:quoted})
+- make command sequences more usable: don't require space after ;, handle
-	* formats need conditions for >0 (for #P)
+  errors better
-	* some way to pad # stuff with spaces
+- attach should have a flag to create session if it doesn't exist
-	* last window update time and format for it
+- choice and more mode would be better per client than per window?
-	* formats to show if a window is linked into multiple sessions, into
+- hooks to which commands may be attached, for example: tmux add-hook
-	  multiple attached sessions, and is the active window in multiple
+  "new-session" if-shell "[ -e $HOME/.tmux-session.conf ]" source-file
-	  attached sessions?
+  $HOME/.tmux-session.conf
-
+- get it passing all the vttest tests that don't require resizing the terminal
-- choose mode improvements:
+- way to set socket path from config file
-	* choose-pane command (augment choose-tree to do this?)
+- what about utmp etc? can tmux update it like screen? setgid?
-	* choose-mode and copy-mode are very similar, make choose-mode a subset?
-	* flag to choose-* for sort order
-	* choose mode would be better per client than per window?
-	* two choices (first one then second, for swap-pane and join-pane)
-	* choose modes should ditch the key bindings and just have fixed keys, and
-          be more customized to their purpose (d to delete a buffer for choose-buffer,
-          a preview of buffer contents, etc)
-
-- improve monitor-*:
-	* straighten out rules for multiple clients
-	* think about what happens across sessions
-	* monitor changes within a region
-	* perhaps monitor /all/ panes in the window not just one
-
-- improve mouse support:
-	* bind commands to mouse in different areas? 
-	* commands executed when clicking on a pattern (URL)
-
-- hooks!
-
 - warts on current naming:
-	* display-time but message-fg/bg/attr
+  	- display-time but message-fg/bg/attr
-	* list-* vs show-*
+	- list-* vs show-*
-	* split-window -> split-pane?
+	- server-info
-
+	- up-pane/down-pane/swap-pane -U/swap-pane -D vs next-*/previous-*
-- better UTF-8 support:
+	- split-window -> split-pane??
-	* window names and titles
+- a way for force-width/height to apply to only one pane (how?)
-	* message display
+- command to list what is actually running in each window with command line,
-	* prompt input
+  pid (need some adaption of the osdep code)
-	* multibyte key input
+- support for bce
-	* searching in copy mode
+- 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)
-- copy/paste improvements:
+	-- idea of a "view" onto a window, need base x/y offsets for redraw
-	* incremental searching
+- handle resize better in copy mode
-	* paste w/o trailing whitespace
+- way to copy stuff that is off screen due to resize
-	* command to toggle selection not to move it in copy-mode
+- commands should be able to succeed or fail and have || or && for command
-	* regex searching
+  lists
-	* copy-pipe should have -x as well
+- some way to KEEP a command running continually and just use its LAST line of
-
+  output
-- layout stuff
+- UTF-8 to a non-UTF-8 terminal should not be able to balls up
-	* way to tag a layout as a number/name
+  the terminal - www/ruby-addressable; make regress
-	* maybe keep last layout + size around and if size reverts just put it
+- support esc-esc to quit in modes
-	  back
+- fix ctrl+F1-F4 output. to what?
-	* revamp layouts: they are too complicated, should be more closely
+- better utf8 support: window names, prompt input, message display
-	  integrated, should support hints, layout sets should just be a
+- session history for client and last-session command
-	  special case of custom layouts, and we should support panes that are
+- option to change status line colour when current window is in a mode?
-	  not attached to a cell at all. this could be the time to introduce
+- option to move copy mode indicator into status line
-	  panelink to replace layout_cell
+- list-buffer/show-buffer should display UTF-8
-	* way to set hints/limits about pane size for resizing
+- selection behaviour closer to vi in vi mode
-	* panning over window (window larger than visible)
+- live update: server started with -U connects to server, requests sessions and
-	* a mode where one application can cross two panes (ie x|y, width =
+  windows, receives fds
-	  COLUMNS/2 but height = ROWS * 2)
+- command to show a tree of sessions-windows-panes (active marked with *)
-	* general key to space cells out evenly (horiz or vert) within their
+- sort out inheriting config from shell on new sessions/windows:
-	  parent cell (could replace even-vert/even-horiz layouts)
+        should pick up default-path/termios/etc from client if possible,
-	* separate active panes for different clients
+	else leave empty/default
-
+- link panes into multiple windows
-- terminfo bits
+- bells should be passed between sessions with visual-bell etc
-	* use a better termcap internally instead of screen, perhaps xterm
+- use screen-256color when started on 256 colour terminal??
-	* 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
-- code cleanup
+- better session sharing: create-socket command to create socket somewhere (-r
-	* instead of separate window and session options, just one master
+  flag for readonly)
-	  options list with each option having a type (window or session), then
+- allow buffer to be specified when copying in copy mode
-	  options on window, on session, and global. for window options we look
+- multiline status line (no?)
-	  window->session->global, and for session we look session->global
+- flag for absolute pane size to resize-pane
-	* the way pane, window, session destroy is handled is too complicated
+- sanity check input to socket
-	  and the distinction between session.c, window.c and server-fn.c
+- support title stack, both internally and externally
-	  functions is not clear. could we just have kill_pane(),
+	http://docs.freebsd.org/cgi/getmsg.cgi?fetch=1149299+0+archive/2010/freebsd-questions/20100207.freebsd-questions
-	  kill_window(), unlink_window(), kill_session() that fix up all data
+- command to show status line information briefly when it is off
-	  structures (flagging sessions as dead) and return a value to say
+- some way to pad # stuff with spaces, #!2T maybe
-	  whether clients need to be checked for dead sessions? sort of like
+- a binding to "scroll down and exit at bottom" copy mode
-	  session_detach now but more so. or some other scheme to make it
+- some way to pass keystrokes in copy mode through to underlying window
-	  simpler and clearer? also would be nice to remove/rename server-fn.c
+- last window update time and # replacement for it for display-message
-	* more readable way to work out the various things commands need to
+- find-window across sessions - other ways to make session handling easier?
-	  know about the client, notably:
+- ' and " should be parsed the same (eg "\e" vs '\e') in config and command
-		- is this the config file? (cmdq->c == NULL)
+  prompt?
-		- is this a command client? (cmdq->c != NULL &&
+- command to toggle selection not to move it in copy-mode
-		  cmdq->c->session == NULL)
+- why are alerts per-winlink? try per window?
-		- is this a control client?
+- audit of escape sequence support vs xterm
-		- can i do stdin or stdout to this client?
+- support binding keys to mouse (mouse-select-pane -> mouse-keys or something,
-	  or even guarantee that cmdq->c != NULL and provide a better way to
+  mouse click == select-pane -t %%, mouse scroll up == copy-mode)
-	  tell when in the config file - then we use cmdq->c if we need a
+- something for -t "last window in session" so a session can be used as a stack
-	  client w/o a session else cmd_current_client
+- synchronous commands - client sends cmd and blocks, neww/splitw saves client
-	* optimize pane redraws, 20120318184853.GK10965@yelena.nicm.ath.cx
+  ptr then when program inside died, sends MSG_SOMETHING with wait status to
-
+  client
-- miscellaneous
+- documentation improvements - rlpowell's tutorial - build instructions
-	* way to keep a job running just read its last line of output for #()
+- bind commands to key sequences? -- make it so ALL keys go through a table,
-	* link panes into multiple windows
+  first an implicit table in which C-b is the only default binding to a
-	* live update: server started with -U connects to server, requests
+  command that says "next key from $othertable" and so on. means -n can
-	  sessions and windows, receives file descriptors
+  go away as well
-	* there are inconsistencies in what we get from old shell and what
+- monitor, bell etc should monitor /all/ panes in the window not just one
-	  comes from config for new sessions and windows. likewise, panes and
+- a history of commands that can be reversed (reverse member of each command,
-	  jobs and run-shell and lock command all start with slightly different
+  and a buffer) info() when changing to same window
-	  environments
+- way to add dest for break-pane; maybe some easier way to unbreak-pane
-	* multiline status line?
+- case insensitive searching
-	* customizable command aliases
+- pane-index option like base-index
-	* automatic pane logging
+- option to move status line to top
-	* BCE? We are halfway there (output side is done for pane backgrounds),
+- configurable borders and empty space filler for when panes < window?
-	  just need to change how screen/grid handles erase
+- 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 %%'"
+- else part for if-shell
+- add general internal format for lists (key=value) and a way to output them in
+  different representations, use for list-windows, etc etc. see message id
+  20110221205346.GA1580@yelena.nicm.ath.cx
+- numeric prefix in copy mode should be paste buffer for C-w
+- named buffers and allow gaps in the stack
+- npage/ppage/dc/ic should have aliases for more typical names
+- 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
+- way to get command window was started with (part of format stuff?)
+- last-pane across sessions
+- attach should take a pane and select it as well as attaching
+* 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!

alerts.c

@@ -1,263 +0,0 @@
-/* $OpenBSD$ */
-
-/*
- * Copyright (c) 2015 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 <event.h>
-
-#include "tmux.h"
-
-int	alerts_fired;
-
-void	alerts_timer(int, short, void *);
-int	alerts_enabled(struct window *, int);
-void	alerts_callback(int, short, void *);
-void	alerts_reset(struct window *);
-
-int	alerts_check_bell(struct session *, struct winlink *);
-int	alerts_check_activity(struct session *, struct winlink *);
-int	alerts_check_silence(struct session *, struct winlink *);
-void	alerts_ring_bell(struct session *);
-
-void
-alerts_timer(unused int fd, unused short events, void *arg)
-{
-	struct window	*w = arg;
-
-	log_debug("@%u alerts timer expired", w->id);
-	alerts_reset(w);
-	alerts_queue(w, WINDOW_SILENCE);
-}
-
-void
-alerts_callback(unused int fd, unused short events, unused void *arg)
-{
-	struct window	*w;
-	struct session	*s;
-	struct winlink	*wl;
-	int		 flags, alerts;
-
-	RB_FOREACH(w, windows, &windows) {
-		RB_FOREACH(s, sessions, &sessions) {
-			RB_FOREACH(wl, winlinks, &s->windows) {
-				if (wl->window != w)
-					continue;
-				flags = w->flags;
-
-				alerts  = alerts_check_bell(s, wl);
-				alerts |= alerts_check_activity(s, wl);
-				alerts |= alerts_check_silence(s, wl);
-				if (alerts != 0)
-					server_status_session(s);
-
-				log_debug("%s:%d @%u alerts check, alerts %#x, "
-				    "flags %#x", s->name, wl->idx, w->id,
-				    alerts, flags);
-			}
-		}
-	}
-	alerts_fired = 0;
-}
-
-int
-alerts_enabled(struct window *w, int flags)
-{
-	struct session	*s;
-
-	if (flags & WINDOW_ACTIVITY) {
-		if (options_get_number(&w->options, "monitor-activity"))
-			return (1);
-	}
-	if (flags & WINDOW_SILENCE) {
-		if (options_get_number(&w->options, "monitor-silence") != 0)
-			return (1);
-	}
-	if (~flags & WINDOW_BELL)
-		return (0);
-	RB_FOREACH(s, sessions, &sessions) {
-		if (!session_has(s, w))
-			continue;
-		if (options_get_number(&s->options, "bell-action") != BELL_NONE)
-			return (1);
-	}
-	return (0);
-}
-
-void
-alerts_reset_all(void)
-{
-	struct window	*w;
-
-	RB_FOREACH(w, windows, &windows)
-		alerts_reset(w);
-}
-
-void
-alerts_reset(struct window *w)
-{
-	struct timeval	tv;
-
-	w->flags &= ~WINDOW_SILENCE;
-	event_del(&w->alerts_timer);
-
-	timerclear(&tv);
-	tv.tv_sec = options_get_number(&w->options, "monitor-silence");
-
-	log_debug("@%u alerts timer reset %u", w->id, (u_int)tv.tv_sec);
-	if (tv.tv_sec != 0)
-		event_add(&w->alerts_timer, &tv);
-}
-
-void
-alerts_queue(struct window *w, int flags)
-{
-	if (w->flags & WINDOW_ACTIVITY)
-		alerts_reset(w);
-
-	if (!event_initialized(&w->alerts_timer))
-		evtimer_set(&w->alerts_timer, alerts_timer, w);
-
-	if (w->flags & flags)
-		return;
-	w->flags |= flags;
-	log_debug("@%u alerts flags added %#x", w->id, flags);
-
-	if (!alerts_fired && alerts_enabled(w, flags)) {
-		log_debug("alerts check queued (by @%u)", w->id);
-		event_once(-1, EV_TIMEOUT, alerts_callback, NULL, NULL);
-		alerts_fired = 1;
-	}
-}
-
-int
-alerts_check_bell(struct session *s, struct winlink *wl)
-{
-	struct client	*c;
-	struct window	*w = wl->window;
-	int		 action, visual;
-
-	if (!(w->flags & WINDOW_BELL) || wl->flags & WINLINK_BELL)
-		return (0);
-	if (s->curw != wl || s->flags & SESSION_UNATTACHED)
-		wl->flags |= WINLINK_BELL;
-	if (s->flags & SESSION_UNATTACHED)
-		return (0);
-	if (s->curw->window == w)
-		w->flags &= ~WINDOW_BELL;
-
-	action = options_get_number(&s->options, "bell-action");
-	if (action == BELL_NONE)
-		return (0);
-
-	visual = options_get_number(&s->options, "visual-bell");
-	TAILQ_FOREACH(c, &clients, entry) {
-		if (c->session != s || c->flags & CLIENT_CONTROL)
-			continue;
-		if (!visual) {
-			if ((action == BELL_CURRENT &&
-			    c->session->curw->window == w) ||
-			    (action == BELL_OTHER &&
-			    c->session->curw->window != w) ||
-			    action == BELL_ANY)
-				tty_putcode(&c->tty, TTYC_BEL);
-			continue;
-		}
-		if (action == BELL_CURRENT && c->session->curw->window == w)
-			status_message_set(c, "Bell in current window");
-		else if (action == BELL_ANY || (action == BELL_OTHER &&
-		    c->session->curw->window != w))
-			status_message_set(c, "Bell in window %d", wl->idx);
-	}
-
-	return (WINDOW_BELL);
-}
-
-int
-alerts_check_activity(struct session *s, struct winlink *wl)
-{
-	struct client	*c;
-	struct window	*w = wl->window;
-
-	if (s->curw->window == w)
-		w->flags &= ~WINDOW_ACTIVITY;
-
-	if (!(w->flags & WINDOW_ACTIVITY) || wl->flags & WINLINK_ACTIVITY)
-		return (0);
-	if (s->curw == wl && !(s->flags & SESSION_UNATTACHED))
-		return (0);
-
-	if (!options_get_number(&w->options, "monitor-activity"))
-		return (0);
-
-	if (options_get_number(&s->options, "bell-on-alert"))
-		alerts_ring_bell(s);
-	wl->flags |= WINLINK_ACTIVITY;
-
-	if (options_get_number(&s->options, "visual-activity")) {
-		TAILQ_FOREACH(c, &clients, entry) {
-			if (c->session != s)
-				continue;
-			status_message_set(c, "Activity in window %d", wl->idx);
-		}
-	}
-
-	return (WINDOW_ACTIVITY);
-}
-
-int
-alerts_check_silence(struct session *s, struct winlink *wl)
-{
-	struct client	*c;
-	struct window	*w = wl->window;
-
-	if (s->curw->window == w)
-		w->flags &= ~WINDOW_SILENCE;
-
-	if (!(w->flags & WINDOW_SILENCE) || wl->flags & WINLINK_SILENCE)
-		return (0);
-	if (s->curw == wl && !(s->flags & SESSION_UNATTACHED))
-		return (0);
-
-	if (options_get_number(&w->options, "monitor-silence") == 0)
-		return (0);
-
-	if (options_get_number(&s->options, "bell-on-alert"))
-		alerts_ring_bell(s);
-	wl->flags |= WINLINK_SILENCE;
-
-	if (options_get_number(&s->options, "visual-silence")) {
-		TAILQ_FOREACH(c, &clients, entry) {
-			if (c->session != s)
-				continue;
-			status_message_set(c, "Silence in window %d", wl->idx);
-		}
-	}
-
-	return (WINDOW_SILENCE);
-}
-
-void
-alerts_ring_bell(struct session *s)
-{
-	struct client	*c;
-
-	TAILQ_FOREACH(c, &clients, entry) {
-		if (c->session == s && !(c->flags & CLIENT_CONTROL))
-			tty_putcode(&c->tty, TTYC_BEL);
-	}
-}

arguments.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2010 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -20,31 +20,9 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
 
 #include "tmux.h"
 
-/*
- * Manipulate command arguments.
- */
-
-struct args_entry {
-	u_char			 flag;
-	char			*value;
-	RB_ENTRY(args_entry)	 entry;
-};
-
-struct args_entry	*args_find(struct args *, u_char);
-
-RB_GENERATE(args_tree, args_entry, entry, args_cmp);
-
-/* Arguments tree comparison function. */
-int
-args_cmp(struct args_entry *a1, struct args_entry *a2)
-{
-	return (a1->flag - a2->flag);
-}
-
 /* Create an arguments set with no flags. */
 struct args *
 args_create(int argc, ...)
@@ -54,6 +32,8 @@ args_create(int argc, ...)
 	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)
@@ -69,36 +49,36 @@ args_create(int argc, ...)
 	return (args);
 }
 
-/* Find a flag in the arguments tree. */
-struct args_entry *
-args_find(struct args *args, u_char ch)
-{
-	struct args_entry	entry;
-
-	entry.flag = ch;
-	return (RB_FIND(args_tree, &args->tree, &entry));
-}
-
 /* 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)
+		if (opt < 0 || opt >= SCHAR_MAX)
 			continue;
-		if (opt == '?' || strchr(template, opt) == NULL) {
+		if (opt == '?' || (ptr = strchr(template, opt)) == NULL) {
-			args_free(args);
+			xfree(args->flags);
+			xfree(args);
 			return (NULL);
 		}
-		args_set(args, opt, optarg);
+
+		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;
@@ -113,28 +93,26 @@ args_parse(const char *template, int argc, char **argv)
 void
 args_free(struct args *args)
 {
-	struct args_entry	*entry;
+	u_int	i;
-	struct args_entry	*entry1;
 
 	cmd_free_argv(args->argc, args->argv);
 
-	RB_FOREACH_SAFE(entry, args_tree, &args->tree, entry1) {
+	for (i = 0; i < SCHAR_MAX; i++) {
-		RB_REMOVE(args_tree, &args->tree, entry);
+		if (args->values[i] != NULL)
-		free(entry->value);
+			xfree(args->values[i]);
-		free(entry);
 	}
 
-	free(args);
+	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, used;
+	size_t		 off;
-	int			 i;
+	int		 i;
-	const char		*quotes;
+	const char	*quotes;
-	struct args_entry	*entry;
 
 	/* There must be at least one byte at the start. */
 	if (len == 0)
@@ -143,23 +121,23 @@ args_print(struct args *args, char *buf, size_t len)
 
 	/* Process the flags first. */
 	buf[off++] = '-';
-	RB_FOREACH(entry, args_tree, &args->tree) {
+	for (i = 0; i < SCHAR_MAX; i++) {
-		if (entry->value != NULL)
+		if (!bit_test(args->flags, i) || args->values[i] != NULL)
 			continue;
 
 		if (off == len - 1) {
 			buf[off] = '\0';
 			return (len);
 		}
-		buf[off++] = entry->flag;
+		buf[off++] = i;
 		buf[off] = '\0';
 	}
 	if (off == 1)
 		buf[--off] = '\0';
 
 	/* Then the flags with arguments. */
-	RB_FOREACH(entry, args_tree, &args->tree) {
+	for (i = 0; i < SCHAR_MAX; i++) {
-		if (entry->value == NULL)
+		if (!bit_test(args->flags, i) || args->values[i] == NULL)
 			continue;
 
 		if (off >= len) {
@@ -167,16 +145,12 @@ args_print(struct args *args, char *buf, size_t len)
 			return (len);
 		}
 
-		if (strchr(entry->value, ' ') != NULL)
+		if (strchr(args->values[i], ' ') != NULL)
 			quotes = "\"";
 		else
 			quotes = "";
-		used = xsnprintf(buf + off, len - off, "%s-%c %s%s%s",
+		off += xsnprintf(buf + off, len - off, "%s-%c %s%s%s",
-		    off != 0 ? " " : "", entry->flag, quotes, entry->value,
+		    off != 0 ? " " : "", i, quotes, args->values[i], quotes);
-		    quotes);
-		if (used > len - off)
-			used = len - off;
-		off += used;
 	}
 
 	/* And finally the argument vector. */
@@ -190,11 +164,8 @@ args_print(struct args *args, char *buf, size_t len)
 			quotes = "\"";
 		else
 			quotes = "";
-		used = xsnprintf(buf + off, len - off, "%s%s%s%s",
+		off += xsnprintf(buf + off, len - off, "%s%s%s%s",
 		    off != 0 ? " " : "", quotes, args->argv[i], quotes);
-		if (used > len - off)
-			used = len - off;
-		off += used;
 	}
 
 	return (off);
@@ -204,55 +175,43 @@ args_print(struct args *args, char *buf, size_t len)
 int
 args_has(struct args *args, u_char ch)
 {
-	return (args_find(args, ch) == NULL ? 0 : 1);
+	return (bit_test(args->flags, ch));
 }
 
-/* Set argument value in the arguments tree. */
+/* Set argument value. */
 void
 args_set(struct args *args, u_char ch, const char *value)
 {
-	struct args_entry	*entry;
+	if (args->values[ch] != NULL)
-
+		xfree(args->values[ch]);
-	/* Replace existing argument. */
-	if ((entry = args_find(args, ch)) != NULL) {
-		free(entry->value);
-		entry->value = NULL;
-	} else {
-		entry = xcalloc(1, sizeof *entry);
-		entry->flag = ch;
-		RB_INSERT(args_tree, &args->tree, entry);
-	}
-
 	if (value != NULL)
-		entry->value = xstrdup(value);
+		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)
 {
-	struct args_entry	*entry;
+	return (args->values[ch]);
-
-	if ((entry = args_find(args, ch)) == NULL)
-		return (NULL);
-	return (entry->value);
 }
 
 /* Convert an argument value to a number. */
 long long
-args_strtonum(struct args *args, u_char ch, long long minval, long long maxval,
+args_strtonum(struct args *args,
-    char **cause)
+    u_char ch, long long minval, long long maxval, char **cause)
 {
-	const char		*errstr;
+	const char	*errstr;
-	long long 	 	 ll;
+	long long 	 ll;
-	struct args_entry	*entry;
 
-	if ((entry = args_find(args, ch)) == NULL) {
+	if (!args_has(args, ch)) {
 		*cause = xstrdup("missing");
 		return (0);
 	}
 
-	ll = strtonum(entry->value, minval, maxval, &errstr);
+	ll = strtonum(args->values[ch], minval, maxval, &errstr);
 	if (errstr != NULL) {
 		*cause = xstrdup(errstr);
 		return (0);

array.h

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2006 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -39,10 +39,10 @@
 		fatalx("size too big");					\
 	if ((a)->space == 0) {						\
 	       	(a)->space = ARRAY_INITIALSPACE(a);			\
-		(a)->list = xrealloc((a)->list, (a)->space);		\
+		(a)->list = xrealloc((a)->list, 1, (a)->space);		\
 	}								\
 	while ((a)->space <= ((a)->num + (n)) * ARRAY_ITEMSIZE(a)) {	\
-		(a)->list = xreallocarray((a)->list, 2, (a)->space);	\
+		(a)->list = xrealloc((a)->list, 2, (a)->space);		\
 		(a)->space *= 2;					\
 	}								\
 } while (0)
@@ -109,12 +109,13 @@
 } while (0)
 
 #define ARRAY_FREE(a) do {						\
-	free((a)->list);						\
+	if ((a)->list != NULL)						\
+		xfree((a)->list);					\
 	ARRAY_INIT(a);							\
 } while (0)
 #define ARRAY_FREEALL(a) do {						\
 	ARRAY_FREE(a);							\
-	free(a);							\
+	xfree(a);							\
 } while (0)
 
 #endif

attributes.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Joshua Elsasser <josh@elsasser.org>
@@ -26,21 +26,27 @@ const char *
 attributes_tostring(u_char attr)
 {
 	static char	buf[128];
-	size_t		len;
 
 	if (attr == 0)
 		return ("none");
 
-	len = xsnprintf(buf, sizeof buf, "%s%s%s%s%s%s%s",
+	buf[0] = '\0';
-		attr & GRID_ATTR_BRIGHT ? "bright," : "",
+	if (attr & GRID_ATTR_BRIGHT)
-		attr & GRID_ATTR_DIM ? "dim," : "",
+		strlcat(buf, "bright,", sizeof (buf));
-		attr & GRID_ATTR_UNDERSCORE ? "underscore," : "",
+	if (attr & GRID_ATTR_DIM)
-		attr & GRID_ATTR_BLINK ? "blink," : "",
+		strlcat(buf, "dim,", sizeof (buf));
-		attr & GRID_ATTR_REVERSE ? "reverse," : "",
+	if (attr & GRID_ATTR_UNDERSCORE)
-		attr & GRID_ATTR_HIDDEN ? "hidden," : "",
+		strlcat(buf, "underscore,", sizeof (buf));
-		attr & GRID_ATTR_ITALICS ? "italics," : "");
+	if (attr & GRID_ATTR_BLINK)
-	if (len > 0)
+		strlcat(buf, "blink,", sizeof (buf));
-		buf[len - 1] = '\0';
+	if (attr & GRID_ATTR_REVERSE)
+		strlcat(buf, "reverse,", sizeof (buf));
+	if (attr & GRID_ATTR_HIDDEN)
+		strlcat(buf, "hidden,", sizeof (buf));
+	if (attr & GRID_ATTR_ITALICS)
+		strlcat(buf, "italics,", sizeof (buf));
+	if (*buf != '\0')
+		*(strrchr(buf, ',')) = '\0';
 
 	return (buf);
 }

autogen.sh

@@ -1,9 +1,8 @@
 #!/bin/sh
+# $Id$
 
-if [ "x$(uname)" = "xOpenBSD" ]; then
+[ -z "$AUTOMAKE_VERSION" ] && export AUTOMAKE_VERSION=1.10
-	[ -z "$AUTOMAKE_VERSION" ] && export AUTOMAKE_VERSION=1.10
+[ -z "$AUTOCONF_VERSION" ] && export AUTOCONF_VERSION=2.65
-	[ -z "$AUTOCONF_VERSION" ] && export AUTOCONF_VERSION=2.65
-fi
 
 die()
 {

cfg.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -17,196 +17,127 @@
  */
 
 #include <sys/types.h>
+#include <sys/stat.h>
 
-#include <ctype.h>
 #include <errno.h>
 #include <stdio.h>
-#include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
 
 #include "tmux.h"
 
-char		 *cfg_file;
+/*
-struct cmd_q	 *cfg_cmd_q;
+ * Config file parser. Pretty quick and simple, each line is parsed into a
-int		  cfg_finished;
+ * argv array and executed as a command.
-int		  cfg_references;
+ */
-char		**cfg_causes;
-u_int		  cfg_ncauses;
-struct client	 *cfg_client;
 
-void	cfg_default_done(struct cmd_q *);
+void printflike2 cfg_print(struct cmd_ctx *, const char *, ...);
+void printflike2 cfg_error(struct cmd_ctx *, const char *, ...);
 
-void
+char	 	       *cfg_cause;
-set_cfg_file(const char *path)
+int     	 	cfg_finished;
+struct causelist	cfg_causes = ARRAY_INITIALIZER;
+
+/* ARGSUSED */
+void printflike2
+cfg_print(unused struct cmd_ctx *ctx, unused const char *fmt, ...)
 {
-	free(cfg_file);
-	cfg_file = xstrdup(path);
 }
 
-void
+/* ARGSUSED */
-start_cfg(void)
+void printflike2
+cfg_error(unused struct cmd_ctx *ctx, const char *fmt, ...)
 {
-	char		*cause = NULL;
+	va_list	ap;
-	const char	*home;
-
-	cfg_cmd_q = cmdq_new(NULL);
-	cfg_cmd_q->emptyfn = cfg_default_done;
-
-	cfg_finished = 0;
-	cfg_references = 1;
-
-	cfg_client = TAILQ_FIRST(&clients);
-	if (cfg_client != NULL)
-		cfg_client->references++;
-
-	if (access(TMUX_CONF, R_OK) == 0) {
-		if (load_cfg(TMUX_CONF, cfg_cmd_q, &cause) == -1)
-			cfg_add_cause("%s: %s", TMUX_CONF, cause);
-	} else if (errno != ENOENT)
-		cfg_add_cause("%s: %s", TMUX_CONF, strerror(errno));
-
-	if (cfg_file == NULL && (home = find_home()) != NULL) {
-		xasprintf(&cfg_file, "%s/.tmux.conf", home);
-		if (access(cfg_file, R_OK) != 0 && errno == ENOENT) {
-			free(cfg_file);
-			cfg_file = NULL;
-		}
-	}
-	if (cfg_file != NULL && load_cfg(cfg_file, cfg_cmd_q, &cause) == -1)
-		cfg_add_cause("%s: %s", cfg_file, cause);
-	free(cause);
-
-	cmdq_continue(cfg_cmd_q);
-}
-
-int
-load_cfg(const char *path, struct cmd_q *cmdq, char **cause)
-{
-	FILE		*f;
-	char		 delim[3] = { '\\', '\\', '\0' };
-	u_int		 found;
-	size_t		 line = 0;
-	char		*buf, *cause1, *p;
-	struct cmd_list	*cmdlist;
-
-	log_debug("loading %s", path);
-	if ((f = fopen(path, "rb")) == NULL) {
-		xasprintf(cause, "%s: %s", path, strerror(errno));
-		return (-1);
-	}
-
-	found = 0;
-	while ((buf = fparseln(f, NULL, &line, delim, 0)) != NULL) {
-		log_debug("%s: %s", path, buf);
-
-		/* Skip empty lines. */
-		p = buf;
-		while (isspace((u_char) *p))
-			p++;
-		if (*p == '\0') {
-			free(buf);
-			continue;
-		}
-
-		/* Parse and run the command. */
-		if (cmd_string_parse(p, &cmdlist, path, line, &cause1) != 0) {
-			free(buf);
-			if (cause1 == NULL)
-				continue;
-			cfg_add_cause("%s:%zu: %s", path, line, cause1);
-			free(cause1);
-			continue;
-		}
-		free(buf);
-
-		if (cmdlist == NULL)
-			continue;
-		cmdq_append(cmdq, cmdlist, NULL);
-		cmd_list_free(cmdlist);
-		found++;
-	}
-	fclose(f);
-
-	return (found);
-}
-
-void
-cfg_default_done(unused struct cmd_q *cmdq)
-{
-	if (--cfg_references != 0)
-		return;
-	cfg_finished = 1;
-
-	if (!RB_EMPTY(&sessions))
-		cfg_show_causes(RB_MIN(sessions, &sessions));
-
-	cmdq_free(cfg_cmd_q);
-	cfg_cmd_q = NULL;
-
-	if (cfg_client != NULL) {
-		/*
-		 * The client command queue starts with client_exit set to 1 so
-		 * only continue if not empty (that is, we have been delayed
-		 * during configuration parsing for long enough that the
-		 * MSG_COMMAND has arrived), else the client will exit before
-		 * the MSG_COMMAND which might tell it not to.
-		 */
-		if (!TAILQ_EMPTY(&cfg_client->cmdq->queue))
-			cmdq_continue(cfg_client->cmdq);
-		server_client_unref(cfg_client);
-		cfg_client = NULL;
-	}
-}
-
-void
-cfg_add_cause(const char *fmt, ...)
-{
-	va_list	 ap;
-	char	*msg;
 
 	va_start(ap, fmt);
-	xvasprintf(&msg, fmt, ap);
+	xvasprintf(&cfg_cause, fmt, ap);
+	va_end(ap);
+}
+
+void printflike2
+cfg_add_cause(struct causelist *causes, const char *fmt, ...)
+{
+	char	*cause;
+	va_list	 ap;
+
+	va_start(ap, fmt);
+	xvasprintf(&cause, fmt, ap);
 	va_end(ap);
 
-	cfg_ncauses++;
+	ARRAY_ADD(causes, cause);
-	cfg_causes = xreallocarray(cfg_causes, cfg_ncauses, sizeof *cfg_causes);
-	cfg_causes[cfg_ncauses - 1] = msg;
 }
 
-void
+/*
-cfg_print_causes(struct cmd_q *cmdq)
+ * Load configuration file. Returns -1 for an error with a list of messages in
+ * causes. Note that causes must be initialised by the caller!
+ */
+int
+load_cfg(const char *path, struct cmd_ctx *ctxin, struct causelist *causes)
 {
-	u_int	 i;
+	FILE		*f;
+	u_int		 n;
+	char		*buf, *line, *cause;
+	size_t		 len;
+	struct cmd_list	*cmdlist;
+	struct cmd_ctx	 ctx;
+	int		 retval;
 
-	for (i = 0; i < cfg_ncauses; i++) {
+	if ((f = fopen(path, "rb")) == NULL) {
-		cmdq_print(cmdq, "%s", cfg_causes[i]);
+		cfg_add_cause(causes, "%s: %s", path, strerror(errno));
-		free(cfg_causes[i]);
+		return (-1);
 	}
+	n = 0;
 
-	free(cfg_causes);
+	line = NULL;
-	cfg_causes = NULL;
+	retval = 0;
-	cfg_ncauses = 0;
+	while ((buf = fgetln(f, &len))) {
-}
+		if (buf[len - 1] == '\n')
+			buf[len - 1] = '\0';
+		else {
+			line = xrealloc(line, 1, len + 1);
+			memcpy(line, buf, len);
+			line[len] = '\0';
+			buf = line;
+		}
+		n++;
 
-void
+		if (cmd_string_parse(buf, &cmdlist, &cause) != 0) {
-cfg_show_causes(struct session *s)
+			if (cause == NULL)
-{
+				continue;
-	struct window_pane	*wp;
+			cfg_add_cause(causes, "%s: %u: %s", path, n, cause);
-	u_int			 i;
+			xfree(cause);
+			continue;
+		}
+		if (cmdlist == NULL)
+			continue;
+		cfg_cause = NULL;
 
-	if (s == NULL || cfg_ncauses == 0)
+		if (ctxin == NULL) {
-		return;
+			ctx.msgdata = NULL;
-	wp = s->curw->window->active;
+			ctx.curclient = NULL;
+			ctx.cmdclient = NULL;
+		} else {
+			ctx.msgdata = ctxin->msgdata;
+			ctx.curclient = ctxin->curclient;
+			ctx.cmdclient = ctxin->cmdclient;
+		}
 
-	window_pane_set_mode(wp, &window_copy_mode);
+		ctx.error = cfg_error;
-	window_copy_init_for_output(wp);
+		ctx.print = cfg_print;
-	for (i = 0; i < cfg_ncauses; i++) {
+		ctx.info = cfg_print;
-		window_copy_add(wp, "%s", cfg_causes[i]);
+
-		free(cfg_causes[i]);
+		cfg_cause = NULL;
+		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);
+			xfree(cfg_cause);
+		}
 	}
+	if (line != NULL)
+		xfree(line);
+	fclose(f);
 
-	free(cfg_causes);
+	return (retval);
-	cfg_causes = NULL;
-	cfg_ncauses = 0;
 }

client.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -17,7 +17,6 @@
  */
 
 #include <sys/types.h>
-#include <sys/file.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/un.h>
@@ -26,84 +25,37 @@
 #include <errno.h>
 #include <event.h>
 #include <fcntl.h>
-#include <signal.h>
+#include <pwd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "tmux.h"
 
-int		client_flags;
 struct imsgbuf	client_ibuf;
 struct event	client_event;
-struct event	client_stdin;
+const char     *client_exitmsg;
-enum {
-	CLIENT_EXIT_NONE,
-	CLIENT_EXIT_DETACHED,
-	CLIENT_EXIT_DETACHED_HUP,
-	CLIENT_EXIT_LOST_TTY,
-	CLIENT_EXIT_TERMINATED,
-	CLIENT_EXIT_LOST_SERVER,
-	CLIENT_EXIT_EXITED,
-	CLIENT_EXIT_SERVER_EXITED,
-} client_exitreason = CLIENT_EXIT_NONE;
 int		client_exitval;
 enum msgtype	client_exittype;
-const char     *client_exitsession;
 int		client_attached;
 
-__dead void	client_exec(const char *);
+int		client_connect(char *, int);
-int		client_get_lock(char *);
+void		client_send_identify(int);
-int		client_connect(struct event_base *, char *, int);
+void		client_send_environ(void);
-void		client_send_identify(const char *, int);
+void		client_write_server(enum msgtype, void *, size_t);
-int		client_write_one(enum msgtype, int, const void *, size_t);
-int		client_write_server(enum msgtype, const void *, size_t);
 void		client_update_event(void);
 void		client_signal(int, short, void *);
-void		client_stdin_callback(int, short, void *);
-void		client_write(int, const char *, size_t);
 void		client_callback(int, short, void *);
 int		client_dispatch_attached(void);
-int		client_dispatch_wait(void);
+int		client_dispatch_wait(void *);
-const char     *client_exit_message(void);
-
-/*
- * Get server create lock. If already held then server start is happening in
- * another client, so block until the lock is released and return -1 to
- * retry. Ignore other errors - just continue and start the server without the
- * lock.
- */
-int
-client_get_lock(char *lockfile)
-{
-	int lockfd;
-
-	if ((lockfd = open(lockfile, O_WRONLY|O_CREAT, 0600)) == -1)
-		fatal("open failed");
-	log_debug("lock file is %s", lockfile);
-
-	if (flock(lockfd, LOCK_EX|LOCK_NB) == -1) {
-		log_debug("flock failed: %s", strerror(errno));
-		if (errno != EAGAIN)
-			return (lockfd);
-		while (flock(lockfd, LOCK_EX) == -1 && errno == EINTR)
-			/* nothing */;
-		close(lockfd);
-		return (-1);
-	}
-	log_debug("flock succeeded");
-
-	return (lockfd);
-}
 
 /* Connect client to server. */
 int
-client_connect(struct event_base *base, char *path, int start_server)
+client_connect(char *path, int start_server)
 {
 	struct sockaddr_un	sa;
 	size_t			size;
-	int			fd, lockfd = -1, locked = 0;
+	int			fd;
-	char		       *lockfile = NULL;
 
 	memset(&sa, 0, sizeof sa);
 	sa.sun_family = AF_UNIX;
@@ -112,118 +64,46 @@ client_connect(struct event_base *base, char *path, int start_server)
 		errno = ENAMETOOLONG;
 		return (-1);
 	}
-	log_debug("socket is %s", path);
 
-retry:
 	if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
 		fatal("socket failed");
 
-	log_debug("trying connect");
+	if (connect(fd, (struct sockaddr *) &sa, SUN_LEN(&sa)) == -1) {
-	if (connect(fd, (struct sockaddr *) &sa, sizeof(sa)) == -1) {
-		log_debug("connect failed: %s", strerror(errno));
-		if (errno != ECONNREFUSED && errno != ENOENT)
-			goto failed;
 		if (!start_server)
 			goto failed;
-		close(fd);
+		switch (errno) {
-
+		case ECONNREFUSED:
-		if (!locked) {
+			if (unlink(path) != 0)
-			xasprintf(&lockfile, "%s.lock", path);
+				goto failed;
-			if ((lockfd = client_get_lock(lockfile)) == -1) {
+			/* FALLTHROUGH */
-				log_debug("didn't get lock");
+		case ENOENT:
-				free(lockfile);
+			if ((fd = server_start()) == -1)
-				goto retry;
+				goto failed;
-			}
+			break;
-			log_debug("got lock");
+		default:
-
+			goto failed;
-			/*
-			 * Always retry at least once, even if we got the lock,
-			 * because another client could have taken the lock,
-			 * started the server and released the lock between our
-			 * connect() and flock().
-			 */
-			locked = 1;
-			goto retry;
 		}
-
-		if (unlink(path) != 0 && errno != ENOENT) {
-			free(lockfile);
-			close(lockfd);
-			return (-1);
-		}
-		fd = server_start(base, lockfd, lockfile);
 	}
 
-	if (locked) {
-		free(lockfile);
-		close(lockfd);
-	}
 	setblocking(fd, 0);
 	return (fd);
 
 failed:
-	if (locked) {
-		free(lockfile);
-		close(lockfd);
-	}
 	close(fd);
 	return (-1);
 }
 
-/* Get exit string from reason number. */
-const char *
-client_exit_message(void)
-{
-	static char msg[256];
-
-	switch (client_exitreason) {
-	case CLIENT_EXIT_NONE:
-		break;
-	case CLIENT_EXIT_DETACHED:
-		if (client_exitsession != NULL) {
-			xsnprintf(msg, sizeof msg, "detached "
-			    "(from session %s)", client_exitsession);
-			return (msg);
-		}
-		return ("detached");
-	case CLIENT_EXIT_DETACHED_HUP:
-		if (client_exitsession != NULL) {
-			xsnprintf(msg, sizeof msg, "detached and SIGHUP "
-			    "(from session %s)", client_exitsession);
-			return (msg);
-		}
-		return ("detached and SIGHUP");
-	case CLIENT_EXIT_LOST_TTY:
-		return ("lost tty");
-	case CLIENT_EXIT_TERMINATED:
-		return ("terminated");
-	case CLIENT_EXIT_LOST_SERVER:
-		return ("lost server");
-	case CLIENT_EXIT_EXITED:
-		return ("exited");
-	case CLIENT_EXIT_SERVER_EXITED:
-		return ("server exited");
-	}
-	return ("unknown reason");
-}
-
 /* Client main loop. */
 int
-client_main(struct event_base *base, int argc, char **argv, int flags)
+client_main(int argc, char **argv, int flags)
 {
 	struct cmd		*cmd;
 	struct cmd_list		*cmdlist;
-	struct msg_command_data	*data;
+	struct msg_command_data	 cmddata;
-	int			 cmdflags, fd, i, cwd;
+	int			 cmdflags, fd;
-	const char*              ttynam;
 	pid_t			 ppid;
 	enum msgtype		 msg;
 	char			*cause;
-	struct termios		 tio, saved_tio;
-	size_t			 size;
-
-	/* Save the flags. */
-	client_flags = flags;
 
 	/* Set up the initial command. */
 	cmdflags = 0;
@@ -232,7 +112,7 @@ client_main(struct event_base *base, int argc, char **argv, int flags)
 		cmdflags = CMD_STARTSERVER;
 	} else if (argc == 0) {
 		msg = MSG_COMMAND;
-		cmdflags = CMD_STARTSERVER;
+		cmdflags = CMD_STARTSERVER|CMD_SENDENVIRON|CMD_CANTNEST;
 	} else {
 		msg = MSG_COMMAND;
 
@@ -241,60 +121,39 @@ client_main(struct event_base *base, int argc, char **argv, int flags)
 		 * later in server) but it is necessary to get the start server
 		 * flag.
 		 */
-		cmdlist = cmd_list_parse(argc, argv, NULL, 0, &cause);
+		if ((cmdlist = cmd_list_parse(argc, argv, &cause)) == NULL) {
-		if (cmdlist == NULL) {
+			log_warnx("%s", cause);
-			fprintf(stderr, "%s\n", 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);
 	}
 
-	/* Establish signal handlers. */
+	/*
-	set_signals(client_signal);
+	 * 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.
-	/* Initialize the client socket and start the server. */
+	 */
-	fd = client_connect(base, socket_path, cmdflags & CMD_STARTSERVER);
+	if (shell_cmd == NULL && environ_path != NULL &&
-	if (fd == -1) {
+	    cmdflags & CMD_CANTNEST && strcmp(socket_path, environ_path) == 0) {
-		if (errno == ECONNREFUSED) {
+		log_warnx("sessions should be nested with care. "
-			fprintf(stderr, "no server running on %s\n",
+		    "unset $TMUX to force.");
-			    socket_path);
-		} else {
-			fprintf(stderr, "error connecting to %s (%s)\n",
-			    socket_path, strerror(errno));
-		}
 		return (1);
 	}
 
-	/* Save these before pledge(). */
+	/* Initialise the client socket and start the server. */
-	if ((cwd = open(".", O_RDONLY)) == -1)
+	fd = client_connect(socket_path, cmdflags & CMD_STARTSERVER);
-		cwd = open("/", O_RDONLY);
+	if (fd == -1) {
-	if ((ttynam = ttyname(STDIN_FILENO)) == NULL)
+		log_warn("failed to connect to server");
-		ttynam = "";
+		return (1);
-
+	}
-#ifdef __OpenBSD__
-	/*
-	 * Drop privileges for client. "proc exec" is needed for -c and for
-	 * locking (which uses system(3)).
-	 *
-	 * "tty" is needed to restore termios(4) and also for some reason -CC
-	 * does not work properly without it (input is not recognised).
-	 *
-	 * "sendfd" is dropped later in client_dispatch_wait().
-	 */
-	if (pledge("stdio unix sendfd proc exec tty", NULL) != 0)
-		fatal("pledge failed");
-#endif
-
-	/* Free stuff that is not used in the client. */
-	options_free(&global_options);
-	options_free(&global_s_options);
-	options_free(&global_w_options);
-	environ_free(&global_environ);
 
 	/* Set process title, log and signals now this is the client. */
 #ifdef HAVE_SETPROCTITLE
@@ -304,59 +163,31 @@ client_main(struct event_base *base, int argc, char **argv, int flags)
 
 	/* Create imsg. */
 	imsg_init(&client_ibuf, fd);
-	event_set(&client_event, fd, EV_READ, client_callback, NULL);
+	event_set(&client_event, fd, EV_READ, client_callback, shell_cmd);
 
-	/* Create stdin handler. */
+	/* Establish signal handlers. */
-	setblocking(STDIN_FILENO, 0);
+	set_signals(client_signal);
-	event_set(&client_stdin, STDIN_FILENO, EV_READ|EV_PERSIST,
-	    client_stdin_callback, NULL);
-	if (client_flags & CLIENT_CONTROLCONTROL) {
-		if (tcgetattr(STDIN_FILENO, &saved_tio) != 0) {
-			fprintf(stderr, "tcgetattr failed: %s\n",
-			    strerror(errno));
-			return (1);
-		}
-		cfmakeraw(&tio);
-		tio.c_iflag = ICRNL|IXANY;
-		tio.c_oflag = OPOST|ONLCR;
-#ifdef NOKERNINFO
-		tio.c_lflag = NOKERNINFO;
-#endif
-		tio.c_cflag = CREAD|CS8|HUPCL;
-		tio.c_cc[VMIN] = 1;
-		tio.c_cc[VTIME] = 0;
-		cfsetispeed(&tio, cfgetispeed(&saved_tio));
-		cfsetospeed(&tio, cfgetospeed(&saved_tio));
-		tcsetattr(STDIN_FILENO, TCSANOW, &tio);
-	}
 
-	/* Send identify messages. */
+	/* Send initial environment. */
-	client_send_identify(ttynam, cwd); /* closes cwd */
+	if (cmdflags & CMD_SENDENVIRON)
+		client_send_environ();
+	client_send_identify(flags);
 
 	/* Send first command. */
 	if (msg == MSG_COMMAND) {
-		/* How big is the command? */
+		/* Fill in command line arguments. */
-		size = 0;
+		cmddata.pid = environ_pid;
-		for (i = 0; i < argc; i++)
+		cmddata.idx = environ_idx;
-			size += strlen(argv[i]) + 1;
-		data = xmalloc((sizeof *data) + size);
 
 		/* Prepare command for server. */
-		data->argc = argc;
+		cmddata.argc = argc;
-		if (cmd_pack_argv(argc, argv, (char *)(data + 1), size) != 0) {
+		if (cmd_pack_argv(
-			fprintf(stderr, "command too long\n");
+		    argc, argv, cmddata.argv, sizeof cmddata.argv) != 0) {
-			free(data);
+			log_warnx("command too long");
 			return (1);
 		}
-		size += sizeof *data;
 
-		/* Send the command. */
+		client_write_server(msg, &cmddata, sizeof cmddata);
-		if (client_write_server(msg, data, size) != 0) {
-			fprintf(stderr, "failed to send command\n");
-			free(data);
-			return (1);
-		}
-		free(data);
 	} else if (msg == MSG_SHELL)
 		client_write_server(msg, NULL, 0);
 
@@ -366,82 +197,69 @@ client_main(struct event_base *base, int argc, char **argv, int flags)
 
 	/* Print the exit message, if any, and exit. */
 	if (client_attached) {
-		if (client_exitreason != CLIENT_EXIT_NONE)
+		if (client_exitmsg != NULL && !login_shell)
-			printf("[%s]\n", client_exit_message());
+			printf("[%s]\n", client_exitmsg);
 
 		ppid = getppid();
 		if (client_exittype == MSG_DETACHKILL && ppid > 1)
 			kill(ppid, SIGHUP);
-	} else if (client_flags & CLIENT_CONTROLCONTROL) {
-		if (client_exitreason != CLIENT_EXIT_NONE)
-			printf("%%exit %s\n", client_exit_message());
-		else
-			printf("%%exit\n");
-		printf("\033\\");
-		tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
 	}
-	setblocking(STDIN_FILENO, 1);
 	return (client_exitval);
 }
 
-/* Send identify messages to server. */
+/* Send identify message to server with the file descriptors. */
 void
-client_send_identify(const char *ttynam, int cwd)
+client_send_identify(int flags)
 {
-	const char	 *s;
+	struct msg_identify_data	data;
-	char		**ss;
+	char			       *term;
-	size_t		  sslen;
+	int				fd;
-	int		  fd, flags = client_flags;
-	pid_t		  pid;
 
-	client_write_one(MSG_IDENTIFY_FLAGS, -1, &flags, sizeof flags);
+	data.flags = flags;
 
-	if ((s = getenv("TERM")) == NULL)
+	if (getcwd(data.cwd, sizeof data.cwd) == NULL)
-		s = "";
+		*data.cwd = '\0';
-	client_write_one(MSG_IDENTIFY_TERM, -1, s, strlen(s) + 1);
 
-	client_write_one(MSG_IDENTIFY_TTYNAME, -1, ttynam, strlen(ttynam) + 1);
+	term = getenv("TERM");
-	client_write_one(MSG_IDENTIFY_CWD, cwd, NULL, 0);
+	if (term == NULL ||
+	    strlcpy(data.term, term, sizeof data.term) >= sizeof data.term)
+		*data.term = '\0';
 
 	if ((fd = dup(STDIN_FILENO)) == -1)
 		fatal("dup failed");
-	client_write_one(MSG_IDENTIFY_STDIN, fd, NULL, 0);
+	imsg_compose(&client_ibuf,
+	    MSG_IDENTIFY, PROTOCOL_VERSION, -1, fd, &data, sizeof data);
 
-	pid = getpid();
+	if ((fd = dup(STDOUT_FILENO)) == -1)
-	client_write_one(MSG_IDENTIFY_CLIENTPID, -1, &pid, sizeof pid);
+		fatal("dup failed");
+	imsg_compose(&client_ibuf,
+	    MSG_STDOUT, PROTOCOL_VERSION, -1, fd, NULL, 0);
 
-	for (ss = environ; *ss != NULL; ss++) {
+	if ((fd = dup(STDERR_FILENO)) == -1)
-		sslen = strlen(*ss) + 1;
+		fatal("dup failed");
-		if (sslen <= MAX_IMSGSIZE - IMSG_HEADER_SIZE)
+	imsg_compose(&client_ibuf,
-			client_write_one(MSG_IDENTIFY_ENVIRON, -1, *ss, sslen);
+	    MSG_STDERR, PROTOCOL_VERSION, -1, fd, NULL, 0);
-	}
-
-	client_write_one(MSG_IDENTIFY_DONE, -1, NULL, 0);
 }
 
-/* Helper to send one message. */
+/* Forward entire environment to server. */
-int
+void
-client_write_one(enum msgtype type, int fd, const void *buf, size_t len)
+client_send_environ(void)
 {
-	int	retval;
+	struct msg_environ_data	data;
+	char		      **var;
 
-	retval = imsg_compose(&client_ibuf, type, PROTOCOL_VERSION, -1, fd,
+	for (var = environ; *var != NULL; var++) {
-	    (void *)buf, len);
+		if (strlcpy(data.var, *var, sizeof data.var) >= sizeof data.var)
-	if (retval != 1)
+			continue;
-		return (-1);
+		client_write_server(MSG_ENVIRON, &data, sizeof data);
-	return (0);
+	}
 }
 
 /* Write a message to the server without a file descriptor. */
-int
+void
-client_write_server(enum msgtype type, const void *buf, size_t len)
+client_write_server(enum msgtype type, void *buf, size_t len)
 {
-	int	retval;
+	imsg_compose(&client_ibuf, type, PROTOCOL_VERSION, -1, -1, buf, len);
-
-	retval = client_write_one(type, -1, buf, len);
-	if (retval == 0)
-		client_update_event();
-	return (retval);
 }
 
 /* Update client event based on whether it needs to read or read and write. */
@@ -454,31 +272,37 @@ 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);
 }
 
 /* Callback to handle signals in the client. */
+/* ARGSUSED */
 void
-client_signal(int sig, unused short events, unused void *arg)
+client_signal(int sig, unused short events, unused void *data)
 {
 	struct sigaction sigact;
 	int		 status;
 
-	if (sig == SIGCHLD)
+	if (!client_attached) {
-		waitpid(WAIT_ANY, &status, WNOHANG);
+		switch (sig) {
-	else if (!client_attached) {
+		case SIGCHLD:
-		if (sig == SIGTERM)
+			waitpid(WAIT_ANY, &status, WNOHANG);
+			break;
+		case SIGTERM:
 			event_loopexit(NULL);
+			break;
+		}
 	} else {
 		switch (sig) {
 		case SIGHUP:
-			client_exitreason = CLIENT_EXIT_LOST_TTY;
+			client_exitmsg = "lost tty";
 			client_exitval = 1;
 			client_write_server(MSG_EXITING, NULL, 0);
 			break;
 		case SIGTERM:
-			client_exitreason = CLIENT_EXIT_TERMINATED;
+			client_exitmsg = "terminated";
 			client_exitval = 1;
 			client_write_server(MSG_EXITING, NULL, 0);
 			break;
@@ -501,8 +325,9 @@ client_signal(int sig, unused short events, unused void *arg)
 }
 
 /* Callback for client imsg read events. */
+/* ARGSUSED */
 void
-client_callback(unused int fd, short events, unused void *arg)
+client_callback(unused int fd, short events, void *data)
 {
 	ssize_t	n;
 	int	retval;
@@ -513,7 +338,7 @@ client_callback(unused int fd, short events, unused void *arg)
 		if (client_attached)
 			retval = client_dispatch_attached();
 		else
-			retval = client_dispatch_wait();
+			retval = client_dispatch_wait(data);
 		if (retval != 0) {
 			event_loopexit(NULL);
 			return;
@@ -521,7 +346,7 @@ client_callback(unused int fd, short events, unused void *arg)
 	}
 
 	if (events & EV_WRITE) {
-		if (msgbuf_write(&client_ibuf.w) <= 0 && errno != EAGAIN)
+		if (msgbuf_write(&client_ibuf.w) < 0)
 			goto lost_server;
 	}
 
@@ -529,118 +354,40 @@ client_callback(unused int fd, short events, unused void *arg)
 	return;
 
 lost_server:
-	client_exitreason = CLIENT_EXIT_LOST_SERVER;
+	client_exitmsg = "lost server";
 	client_exitval = 1;
 	event_loopexit(NULL);
 }
 
-/* Callback for client stdin read events. */
-void
-client_stdin_callback(unused int fd, unused short events, unused void *arg)
-{
-	struct msg_stdin_data	data;
-
-	data.size = read(STDIN_FILENO, data.data, sizeof data.data);
-	if (data.size < 0 && (errno == EINTR || errno == EAGAIN))
-		return;
-
-	client_write_server(MSG_STDIN, &data, sizeof data);
-	if (data.size <= 0)
-		event_del(&client_stdin);
-	client_update_event();
-}
-
-/* Force write to file descriptor. */
-void
-client_write(int fd, const char *data, size_t size)
-{
-	ssize_t	used;
-
-	while (size != 0) {
-		used = write(fd, data, size);
-		if (used == -1) {
-			if (errno == EINTR || errno == EAGAIN)
-				continue;
-			break;
-		}
-		data += used;
-		size -= used;
-	}
-}
-
-/* Run command in shell; used for -c. */
-__dead void
-client_exec(const char *shell)
-{
-	const char	*name, *ptr;
-	char		*argv0;
-
-	log_debug("shell %s, command %s", shell, shell_cmd);
-
-	ptr = strrchr(shell, '/');
-	if (ptr != NULL && *(ptr + 1) != '\0')
-		name = ptr + 1;
-	else
-		name = shell;
-	if (client_flags & CLIENT_LOGIN)
-		xasprintf(&argv0, "-%s", name);
-	else
-		xasprintf(&argv0, "%s", name);
-	setenv("SHELL", shell, 1);
-
-	setblocking(STDIN_FILENO, 1);
-	setblocking(STDOUT_FILENO, 1);
-	setblocking(STDERR_FILENO, 1);
-	closefrom(STDERR_FILENO + 1);
-
-	execl(shell, argv0, "-c", shell_cmd, (char *) NULL);
-	fatal("execl failed");
-}
-
 /* Dispatch imsgs when in wait state (before MSG_READY). */
 int
-client_dispatch_wait(void)
+client_dispatch_wait(void *data)
 {
-	struct imsg		 imsg;
+	struct imsg		imsg;
-	char			*data;
+	ssize_t			n, datalen;
-	ssize_t			 n, datalen;
+	struct msg_shell_data	shelldata;
-	struct msg_stdout_data	 stdoutdata;
+	struct msg_exit_data	exitdata;
-	struct msg_stderr_data	 stderrdata;
+	const char             *shellcmd = data;
-	int			 retval;
-#ifdef __OpenBSD__
-	static int		 pledge_applied;
 
-	/*
+	if ((n = imsg_read(&client_ibuf)) == -1 || n == 0)
-	 * "sendfd" is no longer required once all of the identify messages
+		fatalx("imsg_read failed");
-	 * have been sent. We know the server won't send us anything until that
-	 * point (because we don't ask it to), so we can drop "sendfd" once we
-	 * get the first message from the server.
-	 */
-	if (!pledge_applied) {
-		if (pledge("stdio unix proc exec tty", NULL) != 0)
-			fatal("pledge failed");
-		pledge_applied = 1;
-	};
-#endif
 
 	for (;;) {
 		if ((n = imsg_get(&client_ibuf, &imsg)) == -1)
 			fatalx("imsg_get failed");
 		if (n == 0)
 			return (0);
-
-		data = imsg.data;
 		datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
 
-		log_debug("got %u from server", imsg.hdr.type);
 		switch (imsg.hdr.type) {
 		case MSG_EXIT:
 		case MSG_SHUTDOWN:
-			if (datalen != sizeof retval && datalen != 0)
+			if (datalen != sizeof exitdata) {
-				fatalx("bad MSG_EXIT size");
+				if (datalen != 0)
-			if (datalen == sizeof retval) {
+					fatalx("bad MSG_EXIT size");
-				memcpy(&retval, data, sizeof retval);
+			} else {
-				client_exitval = retval;
+				memcpy(&exitdata, imsg.data, sizeof exitdata);
+				client_exitval = exitdata.retcode;
 			}
 			imsg_free(&imsg);
 			return (-1);
@@ -648,57 +395,30 @@ client_dispatch_wait(void)
 			if (datalen != 0)
 				fatalx("bad MSG_READY size");
 
-			event_del(&client_stdin);
 			client_attached = 1;
-			client_write_server(MSG_RESIZE, NULL, 0);
-			break;
-		case MSG_STDIN:
-			if (datalen != 0)
-				fatalx("bad MSG_STDIN size");
-
-			event_add(&client_stdin, NULL);
-			break;
-		case MSG_STDOUT:
-			if (datalen != sizeof stdoutdata)
-				fatalx("bad MSG_STDOUT size");
-			memcpy(&stdoutdata, data, sizeof stdoutdata);
-
-			client_write(STDOUT_FILENO, stdoutdata.data,
-			    stdoutdata.size);
-			break;
-		case MSG_STDERR:
-			if (datalen != sizeof stderrdata)
-				fatalx("bad MSG_STDERR size");
-			memcpy(&stderrdata, data, sizeof stderrdata);
-
-			client_write(STDERR_FILENO, stderrdata.data,
-			    stderrdata.size);
 			break;
 		case MSG_VERSION:
 			if (datalen != 0)
 				fatalx("bad MSG_VERSION size");
 
-			fprintf(stderr, "protocol version mismatch "
+			log_warnx("protocol version mismatch (client %u, "
-			    "(client %d, server %u)\n", PROTOCOL_VERSION,
+			    "server %u)", PROTOCOL_VERSION, imsg.hdr.peerid);
-			    imsg.hdr.peerid);
 			client_exitval = 1;
 
 			imsg_free(&imsg);
 			return (-1);
 		case MSG_SHELL:
-			if (datalen == 0 || data[datalen - 1] != '\0')
+			if (datalen != sizeof shelldata)
-				fatalx("bad MSG_SHELL string");
+				fatalx("bad MSG_SHELL size");
+			memcpy(&shelldata, imsg.data, sizeof shelldata);
+			shelldata.shell[(sizeof shelldata.shell) - 1] = '\0';
 
 			clear_signals(0);
-			client_exec(data);
+
+			shell_exec(shelldata.shell, shellcmd);
 			/* NOTREACHED */
-		case MSG_DETACH:
+		default:
-		case MSG_DETACHKILL:
+			fatalx("unexpected message");
-			client_write_server(MSG_EXITING, NULL, 0);
-			break;
-		case MSG_EXITED:
-			imsg_free(&imsg);
-			return (-1);
 		}
 
 		imsg_free(&imsg);
@@ -706,44 +426,43 @@ client_dispatch_wait(void)
 }
 
 /* Dispatch imsgs in attached state (after MSG_READY). */
+/* ARGSUSED */
 int
 client_dispatch_attached(void)
 {
-	struct imsg		 imsg;
+	struct imsg		imsg;
-	struct sigaction	 sigact;
+	struct msg_lock_data	lockdata;
-	char			*data;
+	struct sigaction	sigact;
-	ssize_t			 n, datalen;
+	ssize_t			n, datalen;
 
 	for (;;) {
 		if ((n = imsg_get(&client_ibuf, &imsg)) == -1)
 			fatalx("imsg_get failed");
 		if (n == 0)
 			return (0);
-
-		data = imsg.data;
 		datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
 
-		log_debug("got %u from server", imsg.hdr.type);
+		log_debug("client got %d", imsg.hdr.type);
 		switch (imsg.hdr.type) {
-		case MSG_DETACH:
 		case MSG_DETACHKILL:
-			if (datalen == 0 || data[datalen - 1] != '\0')
+		case MSG_DETACH:
-				fatalx("bad MSG_DETACH string");
+			if (datalen != 0)
+				fatalx("bad MSG_DETACH size");
 
-			client_exitsession = xstrdup(data);
 			client_exittype = imsg.hdr.type;
 			if (imsg.hdr.type == MSG_DETACHKILL)
-				client_exitreason = CLIENT_EXIT_DETACHED_HUP;
+				client_exitmsg = "detached and SIGHUP";
 			else
-				client_exitreason = CLIENT_EXIT_DETACHED;
+				client_exitmsg = "detached";
 			client_write_server(MSG_EXITING, NULL, 0);
 			break;
 		case MSG_EXIT:
-			if (datalen != 0 && datalen != sizeof (int))
+			if (datalen != 0 &&
+			    datalen != sizeof (struct msg_exit_data))
 				fatalx("bad MSG_EXIT size");
 
 			client_write_server(MSG_EXITING, NULL, 0);
-			client_exitreason = CLIENT_EXIT_EXITED;
+			client_exitmsg = "exited";
 			break;
 		case MSG_EXITED:
 			if (datalen != 0)
@@ -756,7 +475,7 @@ client_dispatch_attached(void)
 				fatalx("bad MSG_SHUTDOWN size");
 
 			client_write_server(MSG_EXITING, NULL, 0);
-			client_exitreason = CLIENT_EXIT_SERVER_EXITED;
+			client_exitmsg = "server exited";
 			client_exitval = 1;
 			break;
 		case MSG_SUSPEND:
@@ -772,12 +491,16 @@ client_dispatch_attached(void)
 			kill(getpid(), SIGTSTP);
 			break;
 		case MSG_LOCK:
-			if (datalen == 0 || data[datalen - 1] != '\0')
+			if (datalen != sizeof lockdata)
-				fatalx("bad MSG_LOCK string");
+				fatalx("bad MSG_LOCK size");
+			memcpy(&lockdata, imsg.data, sizeof lockdata);
 
-			system(data);
+			lockdata.cmd[(sizeof lockdata.cmd) - 1] = '\0';
+			system(lockdata.cmd);
 			client_write_server(MSG_UNLOCK, NULL, 0);
 			break;
+		default:
+			fatalx("unexpected message");
 		}
 
 		imsg_free(&imsg);

clock.c

@@ -0,0 +1,159 @@
+/* $Id$ */
+
+/*
+ * 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 <string.h>
+#include <time.h>
+
+#include "tmux.h"
+
+const char clock_table[14][5][5] = {
+	{ { 1,1,1,1,1 }, /* 0 */
+	  { 1,0,0,0,1 },
+	  { 1,0,0,0,1 },
+	  { 1,0,0,0,1 },
+	  { 1,1,1,1,1 } },
+	{ { 0,0,0,0,1 }, /* 1 */
+	  { 0,0,0,0,1 },
+	  { 0,0,0,0,1 },
+	  { 0,0,0,0,1 },
+	  { 0,0,0,0,1 } },
+	{ { 1,1,1,1,1 }, /* 2 */
+	  { 0,0,0,0,1 },
+	  { 1,1,1,1,1 },
+	  { 1,0,0,0,0 },
+	  { 1,1,1,1,1 } },
+	{ { 1,1,1,1,1 }, /* 3 */
+	  { 0,0,0,0,1 },
+	  { 1,1,1,1,1 },
+	  { 0,0,0,0,1 },
+	  { 1,1,1,1,1 } },
+	{ { 1,0,0,0,1 }, /* 4 */
+	  { 1,0,0,0,1 },
+	  { 1,1,1,1,1 },
+	  { 0,0,0,0,1 },
+	  { 0,0,0,0,1 } },
+	{ { 1,1,1,1,1 }, /* 5 */
+	  { 1,0,0,0,0 },
+	  { 1,1,1,1,1 },
+	  { 0,0,0,0,1 },
+	  { 1,1,1,1,1 } },
+	{ { 1,1,1,1,1 }, /* 6 */
+	  { 1,0,0,0,0 },
+	  { 1,1,1,1,1 },
+	  { 1,0,0,0,1 },
+	  { 1,1,1,1,1 } },
+	{ { 1,1,1,1,1 }, /* 7 */
+	  { 0,0,0,0,1 },
+	  { 0,0,0,0,1 },
+	  { 0,0,0,0,1 },
+	  { 0,0,0,0,1 } },
+	{ { 1,1,1,1,1 }, /* 8 */
+	  { 1,0,0,0,1 },
+	  { 1,1,1,1,1 },
+	  { 1,0,0,0,1 },
+	  { 1,1,1,1,1 } },
+	{ { 1,1,1,1,1 }, /* 9 */
+	  { 1,0,0,0,1 },
+	  { 1,1,1,1,1 },
+	  { 0,0,0,0,1 },
+	  { 1,1,1,1,1 } },
+	{ { 0,0,0,0,0 }, /* : */
+	  { 0,0,1,0,0 },
+	  { 0,0,0,0,0 },
+	  { 0,0,1,0,0 },
+	  { 0,0,0,0,0 } },
+	{ { 1,1,1,1,1 }, /* A */
+	  { 1,0,0,0,1 },
+	  { 1,1,1,1,1 },
+	  { 1,0,0,0,1 },
+	  { 1,0,0,0,1 } },
+	{ { 1,1,1,1,1 }, /* P */
+	  { 1,0,0,0,1 },
+	  { 1,1,1,1,1 },
+	  { 1,0,0,0,0 },
+	  { 1,0,0,0,0 } },
+	{ { 1,0,0,0,1 }, /* M */
+	  { 1,1,0,1,1 },
+	  { 1,0,1,0,1 },
+	  { 1,0,0,0,1 },
+	  { 1,0,0,0,1 } },
+};
+
+void
+clock_draw(struct screen_write_ctx *ctx, int colour, int style)
+{
+	struct screen		*s = ctx->s;
+	struct grid_cell	 gc;
+	char			 tim[64], *ptr;
+	time_t			 t;
+	u_int			 i, j, x, y, idx;
+
+	t = time(NULL);
+	if (style == 0)
+		strftime(tim, sizeof tim, "%l:%M %p", localtime(&t));
+	else
+		strftime(tim, sizeof tim, "%H:%M", localtime(&t));
+
+	screen_write_clearscreen(ctx);
+
+	if (screen_size_x(s) < 6 * strlen(tim) || screen_size_y(s) < 6) {
+		if (screen_size_x(s) >= strlen(tim) && screen_size_y(s) != 0) {
+			x = (screen_size_x(s) / 2) - (strlen(tim) / 2);
+			y = screen_size_y(s) / 2;
+			screen_write_cursormove(ctx, x, y);
+
+			memcpy(&gc, &grid_default_cell, sizeof gc);
+			colour_set_fg(&gc, colour);
+			screen_write_puts(ctx, &gc, "%s", tim);
+		}
+		return;
+	}
+
+	x = (screen_size_x(s) / 2) - 3 * strlen(tim);
+	y = (screen_size_y(s) / 2) - 3;
+
+	memcpy(&gc, &grid_default_cell, sizeof gc);
+	colour_set_bg(&gc, colour);
+	for (ptr = tim; *ptr != '\0'; ptr++) {
+		if (*ptr >= '0' && *ptr <= '9')
+			idx = *ptr - '0';
+		else if (*ptr == ':')
+			idx = 10;
+		else if (*ptr == 'A')
+			idx = 11;
+		else if (*ptr == 'P')
+			idx = 12;
+		else if (*ptr == 'M')
+			idx = 13;
+		else {
+			x += 6;
+			continue;
+		}
+
+		for (j = 0; j < 5; j++) {
+			for (i = 0; i < 5; i++) {
+				screen_write_cursormove(ctx, x + i, y + j);
+				if (clock_table[idx][j][i])
+					screen_write_putc(ctx, &gc, ' ');
+			}
+		}
+		x += 6;
+	}
+}

cmd-attach-session.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,171 +18,95 @@
 
 #include <sys/types.h>
 
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
 #include "tmux.h"
 
 /*
  * Attach existing session to the current terminal.
  */
 
-enum cmd_retval	cmd_attach_session_exec(struct cmd *, struct cmd_q *);
+int	cmd_attach_session_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_attach_session_entry = {
 	"attach-session", "attach",
-	"c:dErt:", 0, 0,
+	"drt:", 0, 0,
-	"[-dEr] [-c working-directory] " CMD_TARGET_SESSION_USAGE,
+	"[-dr] " CMD_TARGET_SESSION_USAGE,
-	CMD_STARTSERVER,
+	CMD_CANTNEST|CMD_STARTSERVER|CMD_SENDENVIRON,
+	NULL,
+	NULL,
 	cmd_attach_session_exec
 };
 
-enum cmd_retval
+int
-cmd_attach_session(struct cmd_q *cmdq, const char *tflag, int dflag, int rflag,
+cmd_attach_session_exec(struct cmd *self, struct cmd_ctx *ctx)
-    const char *cflag, int Eflag)
 {
-	struct session		*s;
+	struct args	*args = self->args;
-	struct client		*c = cmdq->client, *c_loop;
+	struct session	*s;
-	struct winlink		*wl = NULL;
+	struct client	*c;
-	struct window		*w = NULL;
+	const char	*update;
-	struct window_pane	*wp = NULL;
+	char		*overrides, *cause;
-	const char		*update;
+	u_int		 i;
-	char			*cause;
-	int			 fd;
-	struct format_tree	*ft;
-	char			*cp;
 
 	if (RB_EMPTY(&sessions)) {
-		cmdq_error(cmdq, "no sessions");
+		ctx->error(ctx, "no sessions");
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 
-	if (tflag == NULL) {
+	if ((s = cmd_find_session(ctx, args_get(args, 't'), 1)) == NULL)
-		if ((s = cmd_find_session(cmdq, tflag, 1)) == NULL)
+		return (-1);
-			return (CMD_RETURN_ERROR);
-	} else if (tflag[strcspn(tflag, ":.")] != '\0') {
-		if ((wl = cmd_find_pane(cmdq, tflag, &s, &wp)) == NULL)
-			return (CMD_RETURN_ERROR);
-	} else {
-		if ((s = cmd_find_session(cmdq, tflag, 1)) == NULL)
-			return (CMD_RETURN_ERROR);
-		w = window_find_by_id_str(tflag);
-		if (w == NULL) {
-			wp = window_pane_find_by_id_str(tflag);
-			if (wp != NULL)
-				w = wp->window;
-		}
-		if (w != NULL)
-			wl = winlink_find_by_window(&s->windows, w);
-	}
 
-	if (c == NULL)
+	if (ctx->cmdclient == NULL && ctx->curclient == NULL)
-		return (CMD_RETURN_NORMAL);
+		return (0);
-	if (server_client_check_nested(c)) {
-		cmdq_error(cmdq, "sessions should be nested with care, "
-		    "unset $TMUX to force");
-		return (CMD_RETURN_ERROR);
-	}
 
-	if (wl != NULL) {
+	if (ctx->cmdclient == NULL) {
-		if (wp != NULL)
+		if (args_has(self->args, 'd')) {
-			window_set_active_pane(wp->window, wp);
-		session_set_current(s, wl);
-	}
-
-	if (cflag != NULL) {
-		ft = format_create();
-		format_defaults(ft, cmd_find_client(cmdq, NULL, 1), s,
-		    NULL, NULL);
-		cp = format_expand(ft, cflag);
-		format_free(ft);
-
-		fd = open(cp, O_RDONLY|O_DIRECTORY);
-		free(cp);
-		if (fd == -1) {
-			cmdq_error(cmdq, "bad working directory: %s",
-			    strerror(errno));
-			return (CMD_RETURN_ERROR);
-		}
-		close(s->cwd);
-		s->cwd = fd;
-	}
-
-	if (c->session != NULL) {
-		if (dflag) {
 			/*
 			 * Can't use server_write_session in case attaching to
 			 * the same session as currently attached to.
 			 */
-			TAILQ_FOREACH(c_loop, &clients, entry) {
+			for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
-				if (c_loop->session != s || c == c_loop)
+				c = ARRAY_ITEM(&clients, i);
+				if (c == NULL || c->session != s)
 					continue;
-				server_write_client(c, MSG_DETACH,
+				if (c == ctx->curclient)
-				    c_loop->session->name,
+					continue;
-				    strlen(c_loop->session->name) + 1);
+				server_write_client(c, MSG_DETACH, NULL, 0);
 			}
 		}
 
-		if (!Eflag) {
+		ctx->curclient->session = s;
-			update = options_get_string(&s->options,
+		session_update_activity(s);
-			    "update-environment");
+		server_redraw_client(ctx->curclient);
-			environ_update(update, &c->environ, &s->environ);
-		}
-
-		c->session = s;
-		status_timer_start(c);
-		notify_attached_session_changed(c);
-		session_update_activity(s, NULL);
-		gettimeofday(&s->last_attached_time, NULL);
-		server_redraw_client(c);
-		s->curw->flags &= ~WINLINK_ALERTFLAGS;
 	} else {
-		if (server_client_open(c, &cause) != 0) {
+		if (!(ctx->cmdclient->flags & CLIENT_TERMINAL)) {
-			cmdq_error(cmdq, "open terminal failed: %s", cause);
+			ctx->error(ctx, "not a terminal");
-			free(cause);
+			return (-1);
-			return (CMD_RETURN_ERROR);
 		}
 
-		if (rflag)
+		overrides =
-			c->flags |= CLIENT_READONLY;
+		    options_get_string(&s->options, "terminal-overrides");
-
+		if (tty_open(&ctx->cmdclient->tty, overrides, &cause) != 0) {
-		if (dflag) {
+			ctx->error(ctx, "terminal open failed: %s", cause);
-			server_write_session(s, MSG_DETACH, s->name,
+			xfree(cause);
-			    strlen(s->name) + 1);
+			return (-1);
 		}
 
-		if (!Eflag) {
+		if (args_has(self->args, 'r'))
-			update = options_get_string(&s->options,
+			ctx->cmdclient->flags |= CLIENT_READONLY;
-			    "update-environment");
-			environ_update(update, &c->environ, &s->environ);
-		}
 
-		c->session = s;
+		if (args_has(self->args, 'd'))
-		status_timer_start(c);
+			server_write_session(s, MSG_DETACH, NULL, 0);
-		notify_attached_session_changed(c);
-		session_update_activity(s, NULL);
-		gettimeofday(&s->last_attached_time, NULL);
-		server_redraw_client(c);
-		s->curw->flags &= ~WINLINK_ALERTFLAGS;
 
-		server_write_ready(c);
+		ctx->cmdclient->session = s;
-		cmdq->client_exit = 0;
+		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);
 	}
 	recalculate_sizes();
 	server_update_socket();
 
-	return (CMD_RETURN_NORMAL);
+	return (1);	/* 1 means don't tell command client to exit */
-}
-
-enum cmd_retval
-cmd_attach_session_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args	*args = self->args;
-
-	return (cmd_attach_session(cmdq, args_get(args, 't'),
-	    args_has(args, 'd'), args_has(args, 'r'), args_get(args, 'c'),
-	    args_has(args, 'E')));
 }

cmd-bind-key.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,7 +18,6 @@
 
 #include <sys/types.h>
 
-#include <stdlib.h>
 #include <string.h>
 
 #include "tmux.h"
@@ -27,128 +26,95 @@
  * Bind a key to a command, this recurses through cmd_*.
  */
 
-enum cmd_retval	 cmd_bind_key_exec(struct cmd *, struct cmd_q *);
+int	cmd_bind_key_check(struct args *);
+int	cmd_bind_key_exec(struct cmd *, struct cmd_ctx *);
 
-enum cmd_retval	 cmd_bind_key_mode_table(struct cmd *, struct cmd_q *, int);
+int	cmd_bind_key_table(struct cmd *, struct cmd_ctx *, int);
 
 const struct cmd_entry cmd_bind_key_entry = {
 	"bind-key", "bind",
-	"cnrt:T:", 1, -1,
+	"cnrt:", 1, -1,
-	"[-cnr] [-t mode-table] [-T key-table] key command [arguments]",
+	"[-cnr] [-t key-table] key command [arguments]",
 	0,
+	NULL,
+	cmd_bind_key_check,
 	cmd_bind_key_exec
 };
 
-enum cmd_retval
+int
-cmd_bind_key_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_bind_key_check(struct args *args)
+{
+	if (args_has(args, 't')) {
+		if (args->argc != 2)
+			return (-1);
+	} else {
+		if (args->argc < 2)
+			return (-1);
+	}
+	return (0);
+}
+
+int
+cmd_bind_key_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args	*args = self->args;
 	char		*cause;
 	struct cmd_list	*cmdlist;
 	int		 key;
-	const char	*tablename;
-
-	if (args_has(args, 't')) {
-		if (args->argc != 2 && args->argc != 3) {
-			cmdq_error(cmdq, "not enough arguments");
-			return (CMD_RETURN_ERROR);
-		}
-	} else {
-		if (args->argc < 2) {
-			cmdq_error(cmdq, "not enough arguments");
-			return (CMD_RETURN_ERROR);
-		}
-	}
 
 	key = key_string_lookup_string(args->argv[0]);
 	if (key == KEYC_NONE) {
-		cmdq_error(cmdq, "unknown key: %s", args->argv[0]);
+		ctx->error(ctx, "unknown key: %s", args->argv[0]);
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 
 	if (args_has(args, 't'))
-		return (cmd_bind_key_mode_table(self, cmdq, key));
+		return (cmd_bind_key_table(self, ctx, key));
 
-	if (args_has(args, 'T'))
+	cmdlist = cmd_list_parse(args->argc - 1, args->argv + 1, &cause);
-		tablename = args_get(args, 'T');
-	else if (args_has(args, 'n'))
-		tablename = "root";
-	else
-		tablename = "prefix";
-
-	cmdlist = cmd_list_parse(args->argc - 1, args->argv + 1, NULL, 0,
-	    &cause);
 	if (cmdlist == NULL) {
-		cmdq_error(cmdq, "%s", cause);
+		ctx->error(ctx, "%s", cause);
-		free(cause);
+		xfree(cause);
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 
-	key_bindings_add(tablename, key, args_has(args, 'r'), cmdlist);
+	if (!args_has(args, 'n'))
-	return (CMD_RETURN_NORMAL);
+	    key |= KEYC_PREFIX;
+	key_bindings_add(key, args_has(args, 'r'), cmdlist);
+	return (0);
 }
 
-enum cmd_retval
+int
-cmd_bind_key_mode_table(struct cmd *self, struct cmd_q *cmdq, int key)
+cmd_bind_key_table(struct cmd *self, struct cmd_ctx *ctx, int key)
 {
 	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;
-	const char			*arg;
 
 	tablename = args_get(args, 't');
 	if ((mtab = mode_key_findtable(tablename)) == NULL) {
-		cmdq_error(cmdq, "unknown key table: %s", tablename);
+		ctx->error(ctx, "unknown key table: %s", tablename);
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 
 	cmd = mode_key_fromstring(mtab->cmdstr, args->argv[1]);
 	if (cmd == MODEKEY_NONE) {
-		cmdq_error(cmdq, "unknown command: %s", args->argv[1]);
+		ctx->error(ctx, "unknown command: %s", args->argv[1]);
-		return (CMD_RETURN_ERROR);
+		return (-1);
-	}
-
-	switch (cmd) {
-	case MODEKEYCOPY_APPENDSELECTION:
-	case MODEKEYCOPY_COPYSELECTION:
-	case MODEKEYCOPY_STARTNAMEDBUFFER:
-		if (args->argc == 2)
-			arg = NULL;
-		else {
-			arg = args->argv[2];
-			if (strcmp(arg, "-x") != 0) {
-				cmdq_error(cmdq, "unknown argument");
-				return (CMD_RETURN_ERROR);
-			}
-		}
-		break;
-	case MODEKEYCOPY_COPYPIPE:
-		if (args->argc != 3) {
-			cmdq_error(cmdq, "no argument given");
-			return (CMD_RETURN_ERROR);
-		}
-		arg = args->argv[2];
-		break;
-	default:
-		if (args->argc != 2) {
-			cmdq_error(cmdq, "no argument allowed");
-			return (CMD_RETURN_ERROR);
-		}
-		arg = NULL;
-		break;
 	}
 
 	mtmp.key = key;
 	mtmp.mode = !!args_has(args, 'c');
-	if ((mbind = RB_FIND(mode_key_tree, mtab->tree, &mtmp)) == NULL) {
+	if ((mbind = SPLAY_FIND(mode_key_tree, mtab->tree, &mtmp)) != NULL) {
-		mbind = xmalloc(sizeof *mbind);
+		mbind->cmd = cmd;
-		mbind->key = mtmp.key;
+		return (0);
-		mbind->mode = mtmp.mode;
-		RB_INSERT(mode_key_tree, mtab->tree, mbind);
 	}
+	mbind = xmalloc(sizeof *mbind);
+	mbind->key = mtmp.key;
+	mbind->mode = mtmp.mode;
 	mbind->cmd = cmd;
-	mbind->arg = arg != NULL ? xstrdup(arg) : NULL;
+	SPLAY_INSERT(mode_key_tree, mtab->tree, mbind);
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-break-pane.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -26,89 +26,64 @@
  * Break pane off into a window.
  */
 
-#define BREAK_PANE_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"
+int	cmd_break_pane_exec(struct cmd *, struct cmd_ctx *);
-
-enum cmd_retval	 cmd_break_pane_exec(struct cmd *, struct cmd_q *);
 
 const struct cmd_entry cmd_break_pane_entry = {
 	"break-pane", "breakp",
-	"dPF:s:t:", 0, 0,
+	"dt:", 0, 0,
-	"[-dP] [-F format] " CMD_SRCDST_PANE_USAGE,
+	"[-d] " CMD_TARGET_PANE_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_break_pane_exec
 };
 
-enum cmd_retval
+int
-cmd_break_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_break_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
 	struct winlink		*wl;
-	struct session		*src_s;
+	struct session		*s;
-	struct session		*dst_s;
 	struct window_pane	*wp;
 	struct window		*w;
-	char			*name;
 	char			*cause;
-	int			 idx;
+	int			 base_idx;
-	struct format_tree	*ft;
-	const char		*template;
-	char			*cp;
 
-	wl = cmd_find_pane(cmdq, args_get(args, 's'), &src_s, &wp);
+	if ((wl = cmd_find_pane(ctx, args_get(args, 't'), &s, &wp)) == NULL)
-	if (wl == NULL)
+		return (-1);
-		return (CMD_RETURN_ERROR);
+
-	if ((idx = cmd_find_index(cmdq, args_get(args, 't'), &dst_s)) == -2)
+	if (window_count_panes(wl->window) == 1) {
-		return (CMD_RETURN_ERROR);
+		ctx->error(ctx, "can't break with only one pane");
-	if (idx != -1 && winlink_find_by_index(&dst_s->windows, idx) != NULL) {
+		return (-1);
-		cmdq_error(cmdq, "index %d already in use", idx);
-		return (CMD_RETURN_ERROR);
 	}
+
 	w = wl->window;
-
-	if (window_count_panes(w) == 1) {
-		cmdq_error(cmdq, "can't break with only one pane");
-		return (CMD_RETURN_ERROR);
-	}
-	server_unzoom_window(w);
-
 	TAILQ_REMOVE(&w->panes, wp, entry);
-	window_lost_pane(w, wp);
+	if (wp == w->active) {
+		w->active = w->last;
+		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(dst_s->sx, dst_s->sy);
+	w = wp->window = window_create1(s->sx, s->sy);
 	TAILQ_INSERT_HEAD(&w->panes, wp, entry);
 	w->active = wp;
-	name = default_window_name(w);
+	w->name = default_window_name(w);
-	window_set_name(w, name);
+	layout_init(w);
-	free(name);
-	layout_init(w, wp);
 
-	if (idx == -1)
+	base_idx = options_get_number(&s->options, "base-index");
-		idx = -1 - options_get_number(&dst_s->options, "base-index");
+	wl = session_attach(s, w, -1 - base_idx, &cause); /* can't fail */
-	wl = session_attach(dst_s, w, idx, &cause); /* can't fail */
 	if (!args_has(self->args, 'd'))
-		session_select(dst_s, wl->idx);
+		session_select(s, wl->idx);
 
-	server_redraw_session(src_s);
+	server_redraw_session(s);
-	if (src_s != dst_s)
+	server_status_session_group(s);
-		server_redraw_session(dst_s);
-	server_status_session_group(src_s);
-	if (src_s != dst_s)
-		server_status_session_group(dst_s);
 
-	if (args_has(args, 'P')) {
+	return (0);
-		if ((template = args_get(args, 'F')) == NULL)
-			template = BREAK_PANE_TEMPLATE;
-
-		ft = format_create();
-		format_defaults(ft, cmd_find_client(cmdq, NULL, 1), dst_s, wl,
-		    wp);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
-		free(cp);
-
-		format_free(ft);
-	}
-	return (CMD_RETURN_NORMAL);
 }

cmd-capture-pane.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Jonathan Alvarado <radobobo@users.sourceforge.net>
@@ -24,124 +24,62 @@
 #include "tmux.h"
 
 /*
- * Write the entire contents of a pane to a buffer or stdout.
+ * Write the entire contents of a pane to a buffer.
  */
 
-enum cmd_retval	 cmd_capture_pane_exec(struct cmd *, struct cmd_q *);
+int	cmd_capture_pane_exec(struct cmd *, struct cmd_ctx *);
-
-char		*cmd_capture_pane_append(char *, size_t *, char *, size_t);
-char		*cmd_capture_pane_pending(struct args *, struct window_pane *,
-		     size_t *);
-char		*cmd_capture_pane_history(struct args *, struct cmd_q *,
-		     struct window_pane *, size_t *);
 
 const struct cmd_entry cmd_capture_pane_entry = {
 	"capture-pane", "capturep",
-	"ab:CeE:JpPqS:t:", 0, 0,
+	"b:E:S:t:", 0, 0,
-	"[-aCeJpPq] " CMD_BUFFER_USAGE " [-E end-line] [-S start-line]"
+	"[-b buffer-index] [-E end-line] [-S start-line] [-t target-pane]",
-	CMD_TARGET_PANE_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_capture_pane_exec
 };
 
-char *
+int
-cmd_capture_pane_append(char *buf, size_t *len, char *line, size_t linelen)
+cmd_capture_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
-{
-	buf = xrealloc(buf, *len + linelen + 1);
-	memcpy(buf + *len, line, linelen);
-	*len += linelen;
-	return (buf);
-}
-
-char *
-cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
-    size_t *len)
-{
-	struct evbuffer	*pending;
-	char		*buf, *line, tmp[5];
-	size_t		 linelen;
-	u_int		 i;
-
-	pending = input_pending(wp);
-	if (pending == NULL)
-		return (xstrdup(""));
-
-	line = EVBUFFER_DATA(pending);
-	linelen = EVBUFFER_LENGTH(pending);
-
-	buf = xstrdup("");
-	if (args_has(args, 'C')) {
-		for (i = 0; i < linelen; i++) {
-			if (line[i] >= ' ') {
-				tmp[0] = line[i];
-				tmp[1] = '\0';
-			} else
-				xsnprintf(tmp, sizeof tmp, "\\%03hho", line[i]);
-			buf = cmd_capture_pane_append(buf, len, tmp,
-			    strlen(tmp));
-		}
-	} else
-		buf = cmd_capture_pane_append(buf, len, line, linelen);
-	return (buf);
-}
-
-char *
-cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
-    struct window_pane *wp, size_t *len)
 {
+	struct args		*args = self->args;
+	struct window_pane	*wp;
+	char 			*buf, *line, *cause;
+	struct screen		*s;
 	struct grid		*gd;
-	const struct grid_line	*gl;
+	int			 buffer, n;
-	struct grid_cell	*gc = NULL;
+	u_int			 i, limit, top, bottom, tmp;
-	int			 n, with_codes, escape_c0, join_lines;
+	size_t         		 len, linelen;
-	u_int			 i, sx, top, bottom, tmp;
-	char			*cause, *buf, *line;
-	const char		*Sflag, *Eflag;
-	size_t			 linelen;
 
-	sx = screen_size_x(&wp->base);
+	if (cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp) == NULL)
-	if (args_has(args, 'a')) {
+		return (-1);
-		gd = wp->saved_grid;
+	s = &wp->base;
-		if (gd == NULL) {
+	gd = s->grid;
-			if (!args_has(args, 'q')) {
-				cmdq_error(cmdq, "no alternate screen");
-				return (NULL);
-			}
-			return (xstrdup(""));
-		}
-	} else
-		gd = wp->base.grid;
 
-	Sflag = args_get(args, 'S');
+	buf = NULL;
-	if (Sflag != NULL && strcmp(Sflag, "-") == 0)
+	len = 0;
+
+	n = args_strtonum(args, 'S', SHRT_MIN, SHRT_MAX, &cause);
+	if (cause != NULL) {
+		top = gd->hsize;
+		xfree(cause);
+	} else if (n < 0 && (u_int) -n > gd->hsize)
 		top = 0;
-	else {
+	else
-		n = args_strtonum(args, 'S', INT_MIN, SHRT_MAX, &cause);
+		top = gd->hsize + n;
-		if (cause != NULL) {
+	if (top > gd->hsize + gd->sy - 1)
-			top = gd->hsize;
+		top = gd->hsize + gd->sy - 1;
-			free(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;
-	}
 
-	Eflag = args_get(args, 'E');
+	n = args_strtonum(args, 'E', SHRT_MIN, SHRT_MAX, &cause);
-	if (Eflag != NULL && strcmp(Eflag, "-") == 0)
+	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;
-	else {
-		n = args_strtonum(args, 'E', INT_MIN, SHRT_MAX, &cause);
-		if (cause != NULL) {
-			bottom = gd->hsize + gd->sy - 1;
-			free(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;
@@ -149,73 +87,37 @@ cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
 		top = tmp;
 	}
 
-	with_codes = args_has(args, 'e');
-	escape_c0 = args_has(args, 'C');
-	join_lines = args_has(args, 'J');
-
-	buf = NULL;
 	for (i = top; i <= bottom; i++) {
-		line = grid_string_cells(gd, 0, i, sx, &gc, with_codes,
+	       line = grid_string_cells(s->grid, 0, i, screen_size_x(s));
-		    escape_c0, !join_lines);
+	       linelen = strlen(line);
-		linelen = strlen(line);
 
-		buf = cmd_capture_pane_append(buf, len, line, linelen);
+	       buf = xrealloc(buf, 1, len + linelen + 1);
+	       memcpy(buf + len, line, linelen);
+	       len += linelen;
+	       buf[len++] = '\n';
 
-		gl = grid_peek_line(gd, i);
+	       xfree(line);
-		if (!join_lines || !(gl->flags & GRID_LINE_WRAPPED))
-			buf[(*len)++] = '\n';
-
-		free(line);
-	}
-	return (buf);
-}
-
-enum cmd_retval
-cmd_capture_pane_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args		*args = self->args;
-	struct client		*c;
-	struct window_pane	*wp;
-	char			*buf, *cause;
-	const char		*bufname;
-	size_t			 len;
-
-	if (cmd_find_pane(cmdq, args_get(args, 't'), NULL, &wp) == NULL)
-		return (CMD_RETURN_ERROR);
-
-	len = 0;
-	if (args_has(args, 'P'))
-		buf = cmd_capture_pane_pending(args, wp, &len);
-	else
-		buf = cmd_capture_pane_history(args, cmdq, wp, &len);
-	if (buf == NULL)
-		return (CMD_RETURN_ERROR);
-
-	if (args_has(args, 'p')) {
-		c = cmdq->client;
-		if (c == NULL ||
-		    (c->session != NULL && !(c->flags & CLIENT_CONTROL))) {
-			cmdq_error(cmdq, "can't write to stdout");
-			free(buf);
-			return (CMD_RETURN_ERROR);
-		}
-		evbuffer_add(c->stdout_data, buf, len);
-		free(buf);
-		if (args_has(args, 'P') && len > 0)
-		    evbuffer_add(c->stdout_data, "\n", 1);
-		server_push_stdout(c);
-	} else {
-		bufname = NULL;
-		if (args_has(args, 'b'))
-			bufname = args_get(args, 'b');
-
-		if (paste_set(buf, len, bufname, &cause) != 0) {
-			cmdq_error(cmdq, "%s", cause);
-			free(cause);
-			free(buf);
-			return (CMD_RETURN_ERROR);
-		}
 	}
 
-	return (CMD_RETURN_NORMAL);
+	limit = options_get_number(&global_options, "buffer-limit");
+
+	if (!args_has(args, 'b')) {
+		paste_add(&global_buffers, buf, len, limit);
+		return (0);
+	}
+
+	buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
+	if (cause != NULL) {
+		ctx->error(ctx, "buffer %s", cause);
+		xfree(cause);
+		return (-1);
+	}
+
+	if (paste_replace(&global_buffers, buffer, buf, len) != 0) {
+		ctx->error(ctx, "no buffer %d", buffer);
+		xfree(buf);
+		return (-1);
+	}
+
+	return (0);
 }

cmd-choose-buffer.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2010 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -19,7 +19,6 @@
 #include <sys/types.h>
 
 #include <ctype.h>
-#include <stdlib.h>
 
 #include "tmux.h"
 
@@ -27,74 +26,118 @@
  * Enter choice mode to choose a buffer.
  */
 
-#define CHOOSE_BUFFER_TEMPLATE						\
+int	cmd_choose_buffer_exec(struct cmd *, struct cmd_ctx *);
-	"#{buffer_name}: #{buffer_size} bytes: #{buffer_sample}"
 
-enum cmd_retval	 cmd_choose_buffer_exec(struct cmd *, struct cmd_q *);
+void	cmd_choose_buffer_callback(void *, int);
+void	cmd_choose_buffer_free(void *);
 
 const struct cmd_entry cmd_choose_buffer_entry = {
 	"choose-buffer", NULL,
-	"F:t:", 0, 1,
+	"t:", 0, 1,
-	CMD_TARGET_WINDOW_USAGE " [-F format] [template]",
+	CMD_TARGET_WINDOW_USAGE " [template]",
 	0,
+	NULL,
+	NULL,
 	cmd_choose_buffer_exec
 };
 
-enum cmd_retval
+struct cmd_choose_buffer_data {
-cmd_choose_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+	struct client   *client;
+	char            *template;
+};
+
+int
+cmd_choose_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args			*args = self->args;
-	struct client			*c;
+	struct cmd_choose_buffer_data	*cdata;
-	struct window_choose_data	*cdata;
 	struct winlink			*wl;
 	struct paste_buffer		*pb;
-	char				*action, *action_data;
-	const char			*template;
 	u_int				 idx;
-	int				 utf8flag;
+	char				*tmp;
 
-	if ((c = cmd_find_client(cmdq, NULL, 1)) == NULL) {
+	if (ctx->curclient == NULL) {
-		cmdq_error(cmdq, "no client available");
+		ctx->error(ctx, "must be run interactively");
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 
-	if ((template = args_get(args, 'F')) == NULL)
+	if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
-		template = CHOOSE_BUFFER_TEMPLATE;
+		return (-1);
 
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), NULL)) == NULL)
+	if (paste_get_top(&global_buffers) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (0);
-	utf8flag = options_get_number(&wl->window->options, "utf8");
-
-	if (paste_get_top(NULL) == NULL)
-		return (CMD_RETURN_NORMAL);
 
 	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
-		return (CMD_RETURN_NORMAL);
+		return (0);
-
-	if (args->argc != 0)
-		action = xstrdup(args->argv[0]);
-	else
-		action = xstrdup("paste-buffer -b '%%'");
 
 	idx = 0;
-	pb = NULL;
+	while ((pb = paste_walk_stack(&global_buffers, &idx)) != NULL) {
-	while ((pb = paste_walk(pb)) != NULL) {
+		tmp = paste_print(pb, 50);
-		cdata = window_choose_data_create(TREE_OTHER, c, c->session);
+		window_choose_add(wl->window->active, idx - 1,
-		cdata->idx = idx;
+		    "%u: %zu bytes: \"%s\"", idx - 1, pb->size, tmp);
-
+		xfree(tmp);
-		cdata->ft_template = xstrdup(template);
-		format_defaults_paste_buffer(cdata->ft, pb, utf8flag);
-
-		xasprintf(&action_data, "%s", paste_buffer_name(pb));
-		cdata->command = cmd_template_replace(action, action_data, 1);
-		free(action_data);
-
-		window_choose_add(wl->window->active, cdata);
-		idx++;
 	}
-	free(action);
 
-	window_choose_ready(wl->window->active, 0, NULL);
+	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++;
 
-	return (CMD_RETURN_NORMAL);
+	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 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -19,7 +19,6 @@
 #include <sys/types.h>
 
 #include <ctype.h>
-#include <stdlib.h>
 
 #include "tmux.h"
 
@@ -27,106 +26,126 @@
  * Enter choice mode to choose a client.
  */
 
-#define CHOOSE_CLIENT_TEMPLATE					\
+int	cmd_choose_client_exec(struct cmd *, struct cmd_ctx *);
-	"#{client_tty}: #{session_name} "			\
-	"[#{client_width}x#{client_height} #{client_termname}]"	\
-	"#{?client_utf8, (utf8),}#{?client_readonly, (ro),} "	\
-	"(last used #{client_activity_string})"
 
-enum cmd_retval	 cmd_choose_client_exec(struct cmd *, struct cmd_q *);
+void	cmd_choose_client_callback(void *, int);
-
+void	cmd_choose_client_free(void *);
-void	cmd_choose_client_callback(struct window_choose_data *);
 
 const struct cmd_entry cmd_choose_client_entry = {
 	"choose-client", NULL,
-	"F:t:", 0, 1,
+	"t:", 0, 1,
-	CMD_TARGET_WINDOW_USAGE " [-F format] [template]",
+	CMD_TARGET_WINDOW_USAGE " [template]",
 	0,
+	NULL,
+	NULL,
 	cmd_choose_client_exec
 };
 
 struct cmd_choose_client_data {
 	struct client	*client;
+	char   		*template;
 };
 
-enum cmd_retval
+int
-cmd_choose_client_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_choose_client_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args			*args = self->args;
-	struct client			*c;
+	struct cmd_choose_client_data	*cdata;
-	struct client			*c1;
-	struct window_choose_data	*cdata;
 	struct winlink			*wl;
-	const char			*template;
+	struct client			*c;
-	char				*action;
+	u_int			 	 i, idx, cur;
-	u_int			 	 idx, cur;
 
-	if ((c = cmd_find_client(cmdq, NULL, 1)) == NULL) {
+	if (ctx->curclient == NULL) {
-		cmdq_error(cmdq, "no client available");
+		ctx->error(ctx, "must be run interactively");
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), NULL)) == NULL)
+	if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 
 	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
-		return (CMD_RETURN_NORMAL);
+		return (0);
-
-	if ((template = args_get(args, 'F')) == NULL)
-		template = CHOOSE_CLIENT_TEMPLATE;
-
-	if (args->argc != 0)
-		action = xstrdup(args->argv[0]);
-	else
-		action = xstrdup("detach-client -t '%%'");
 
 	cur = idx = 0;
-	TAILQ_FOREACH(c1, &clients, entry) {
+	for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
-		if (c1->session == NULL || c1->tty.path == NULL)
+		c = ARRAY_ITEM(&clients, i);
+		if (c == NULL || c->session == NULL)
 			continue;
-		if (c1 == cmdq->client)
+		if (c == ctx->curclient)
 			cur = idx;
-
-		cdata = window_choose_data_create(TREE_OTHER, c, c->session);
-		cdata->idx = idx;
-
-		cdata->ft_template = xstrdup(template);
-		format_add(cdata->ft, "line", "%u", idx);
-		format_defaults(cdata->ft, c1, NULL, NULL, NULL);
-
-		cdata->command = cmd_template_replace(action, c1->tty.path, 1);
-
-		window_choose_add(wl->window->active, cdata);
-
 		idx++;
+
+		window_choose_add(wl->window->active, i,
+		    "%s: %s [%ux%u %s]%s", c->tty.path,
+		    c->session->name, c->tty.sx, c->tty.sy,
+		    c->tty.termname, c->tty.flags & TTY_UTF8 ? " (utf8)" : "");
 	}
-	free(action);
 
-	window_choose_ready(wl->window->active, cur,
+	cdata = xmalloc(sizeof *cdata);
-	    cmd_choose_client_callback);
+	if (args->argc != 0)
+		cdata->template = xstrdup(args->argv[0]);
+	else
+		cdata->template = xstrdup("detach-client -t '%%'");
+	cdata->client = ctx->curclient;
+	cdata->client->references++;
 
-	return (CMD_RETURN_NORMAL);
+	window_choose_ready(wl->window->active,
+	    cur, cmd_choose_client_callback, cmd_choose_client_free, cdata);
+
+	return (0);
 }
 
 void
-cmd_choose_client_callback(struct window_choose_data *cdata)
+cmd_choose_client_callback(void *data, int idx)
 {
-	struct client  	*c;
+	struct cmd_choose_client_data	*cdata = data;
-	u_int		 idx;
+	struct client  			*c;
+	struct cmd_list			*cmdlist;
+	struct cmd_ctx			 ctx;
+	char				*template, *cause;
 
-	if (cdata == NULL)
+	if (idx == -1)
 		return;
-	if (cdata->start_client->flags & CLIENT_DEAD)
+	if (cdata->client->flags & CLIENT_DEAD)
 		return;
 
-	idx = 0;
+	if ((u_int) idx > ARRAY_LENGTH(&clients) - 1)
-	TAILQ_FOREACH(c, &clients, entry) {
+		return;
-		if (idx == cdata->idx)
+	c = ARRAY_ITEM(&clients, idx);
-			break;
-		idx++;
-	}
 	if (c == NULL || c->session == NULL)
 		return;
+	template = cmd_template_replace(cdata->template, c->tty.path, 1);
 
-	window_choose_data_run(cdata);
+	if (cmd_string_parse(template, &cmdlist, &cause) != 0) {
+		if (cause != NULL) {
+			*cause = toupper((u_char) *cause);
+			status_message_set(c, "%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_client_free(void *data)
+{
+	struct cmd_choose_client_data	*cdata = data;
+
+	cdata->client->references--;
+	xfree(cdata->template);
+	xfree(cdata);
 }

cmd-choose-session.c

@@ -0,0 +1,156 @@
+/* $Id$ */
+
+/*
+ * 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 <ctype.h>
+
+#include "tmux.h"
+
+/*
+ * Enter choice mode to choose a session.
+ */
+
+int	cmd_choose_session_exec(struct cmd *, struct cmd_ctx *);
+
+void	cmd_choose_session_callback(void *, int);
+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]",
+	0,
+	NULL,
+	NULL,
+	cmd_choose_session_exec
+};
+
+struct cmd_choose_session_data {
+	struct client	*client;
+	char   		*template;
+};
+
+int
+cmd_choose_session_exec(struct cmd *self, struct cmd_ctx *ctx)
+{
+	struct args			*args = self->args;
+	struct cmd_choose_session_data	*cdata;
+	struct winlink			*wl;
+	struct session			*s;
+	struct session_group		*sg;
+	u_int			 	 idx, sgidx, cur;
+	char				 tmp[64];
+
+	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 (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
+		return (0);
+
+	cur = idx = 0;
+	RB_FOREACH(s, sessions, &sessions) {
+		if (s == ctx->curclient->session)
+			cur = idx;
+		idx++;
+
+		sg = session_group_find(s);
+		if (sg == NULL)
+			*tmp = '\0';
+		else {
+			sgidx = session_group_index(sg);
+			xsnprintf(tmp, sizeof tmp, " (group %u)", sgidx);
+		}
+
+		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 (args->argc != 0)
+		cdata->template = xstrdup(args->argv[0]);
+	else
+		cdata->template = xstrdup("switch-client -t '%%'");
+	cdata->client = ctx->curclient;
+	cdata->client->references++;
+
+	window_choose_ready(wl->window->active,
+	    cur, cmd_choose_session_callback, cmd_choose_session_free, cdata);
+
+	return (0);
+}
+
+void
+cmd_choose_session_callback(void *data, int idx)
+{
+	struct cmd_choose_session_data	*cdata = data;
+	struct session			*s;
+	struct cmd_list			*cmdlist;
+	struct cmd_ctx			 ctx;
+	char				*template, *cause;
+
+	if (idx == -1)
+		return;
+	if (cdata->client->flags & CLIENT_DEAD)
+		return;
+
+	s = session_find_by_index(idx);
+	if (s == NULL)
+		return;
+	template = cmd_template_replace(cdata->template, s->name, 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_session_free(void *data)
+{
+	struct cmd_choose_session_data	*cdata = data;
+
+	cdata->client->references--;
+	xfree(cdata->template);
+	xfree(cdata);
+}

cmd-choose-tree.c

@@ -1,241 +0,0 @@
-/* $OpenBSD$ */
-
-/*
- * Copyright (c) 2012 Thomas Adam <thomas@xteddy.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 <ctype.h>
-#include <stdlib.h>
-
-#include <string.h>
-
-#include "tmux.h"
-
-#define CMD_CHOOSE_TREE_WINDOW_ACTION "select-window -t '%%'"
-#define CMD_CHOOSE_TREE_SESSION_ACTION "switch-client -t '%%'"
-
-/*
- * Enter choice mode to choose a session and/or window.
- */
-
-#define CHOOSE_TREE_SESSION_TEMPLATE				\
-	"#{session_name}: #{session_windows} windows"		\
-	"#{?session_grouped, (group ,}"				\
-	"#{session_group}#{?session_grouped,),}"		\
-	"#{?session_attached, (attached),}"
-#define CHOOSE_TREE_WINDOW_TEMPLATE				\
-	"#{window_index}: #{window_name}#{window_flags} "	\
-	"\"#{pane_title}\""
-
-enum cmd_retval	cmd_choose_tree_exec(struct cmd *, struct cmd_q *);
-
-const struct cmd_entry cmd_choose_tree_entry = {
-	"choose-tree", NULL,
-	"S:W:swub:c:t:", 0, 1,
-	"[-suw] [-b session-template] [-c window template] [-S format] " \
-	"[-W format] " CMD_TARGET_WINDOW_USAGE,
-	0,
-	cmd_choose_tree_exec
-};
-
-const struct cmd_entry cmd_choose_session_entry = {
-	"choose-session", NULL,
-	"F:t:", 0, 1,
-	CMD_TARGET_WINDOW_USAGE " [-F format] [template]",
-	0,
-	cmd_choose_tree_exec
-};
-
-const struct cmd_entry cmd_choose_window_entry = {
-	"choose-window", NULL,
-	"F:t:", 0, 1,
-	CMD_TARGET_WINDOW_USAGE "[-F format] [template]",
-	0,
-	cmd_choose_tree_exec
-};
-
-enum cmd_retval
-cmd_choose_tree_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args			*args = self->args;
-	struct winlink			*wl, *wm;
-	struct session			*s, *s2;
-	struct client			*c;
-	struct window_choose_data	*wcd = NULL;
-	const char			*ses_template, *win_template;
-	char				*final_win_action, *cur_win_template;
-	char				*final_win_template_middle;
-	char				*final_win_template_last;
-	const char			*ses_action, *win_action;
-	u_int				 cur_win, idx_ses, win_ses, win_max;
-	u_int				 wflag, sflag;
-
-	ses_template = win_template = NULL;
-	ses_action = win_action = NULL;
-
-	if ((c = cmd_find_client(cmdq, NULL, 1)) == NULL) {
-		cmdq_error(cmdq, "no client available");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), &s)) == NULL)
-		return (CMD_RETURN_ERROR);
-
-	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
-		return (CMD_RETURN_NORMAL);
-
-	/* Sort out which command this is. */
-	wflag = sflag = 0;
-	if (self->entry == &cmd_choose_session_entry) {
-		sflag = 1;
-		if ((ses_template = args_get(args, 'F')) == NULL)
-			ses_template = CHOOSE_TREE_SESSION_TEMPLATE;
-
-		if (args->argc != 0)
-			ses_action = args->argv[0];
-		else
-			ses_action = CMD_CHOOSE_TREE_SESSION_ACTION;
-	} else if (self->entry == &cmd_choose_window_entry) {
-		wflag = 1;
-		if ((win_template = args_get(args, 'F')) == NULL)
-			win_template = CHOOSE_TREE_WINDOW_TEMPLATE;
-
-		if (args->argc != 0)
-			win_action = args->argv[0];
-		else
-			win_action = CMD_CHOOSE_TREE_WINDOW_ACTION;
-	} else {
-		wflag = args_has(args, 'w');
-		sflag = args_has(args, 's');
-
-		if ((ses_action = args_get(args, 'b')) == NULL)
-			ses_action = CMD_CHOOSE_TREE_SESSION_ACTION;
-
-		if ((win_action = args_get(args, 'c')) == NULL)
-			win_action = CMD_CHOOSE_TREE_WINDOW_ACTION;
-
-		if ((ses_template = args_get(args, 'S')) == NULL)
-			ses_template = CHOOSE_TREE_SESSION_TEMPLATE;
-
-		if ((win_template = args_get(args, 'W')) == NULL)
-			win_template = CHOOSE_TREE_WINDOW_TEMPLATE;
-	}
-
-	/*
-	 * If not asking for windows and sessions, assume no "-ws" given and
-	 * hence display the entire tree outright.
-	 */
-	if (!wflag && !sflag)
-		wflag = sflag = 1;
-
-	/*
-	 * If we're drawing in tree mode, including sessions, then pad the
-	 * window template, otherwise just render the windows as a flat list
-	 * without any padding.
-	 */
-	if (wflag && sflag) {
-		xasprintf(&final_win_template_middle,
-		    " \001tq\001> %s", win_template);
-		xasprintf(&final_win_template_last,
-		    " \001mq\001> %s", win_template);
-	} else if (wflag) {
-		final_win_template_middle = xstrdup(win_template);
-		final_win_template_last = xstrdup(win_template);
-	} else
-		final_win_template_middle = final_win_template_last = NULL;
-
-	idx_ses = cur_win = -1;
-	RB_FOREACH(s2, sessions, &sessions) {
-		idx_ses++;
-
-		/*
-		 * If we're just choosing windows, jump straight there. Note
-		 * that this implies the current session, so only choose
-		 * windows when the session matches this one.
-		 */
-		if (wflag && !sflag) {
-			if (s != s2)
-				continue;
-			goto windows_only;
-		}
-
-		wcd = window_choose_add_session(wl->window->active,
-		    c, s2, ses_template, ses_action, idx_ses);
-
-		/* If we're just choosing sessions, skip choosing windows. */
-		if (sflag && !wflag) {
-			if (s == s2)
-				cur_win = idx_ses;
-			continue;
-		}
-windows_only:
-		win_ses = win_max = -1;
-		RB_FOREACH(wm, winlinks, &s2->windows)
-			win_max++;
-		RB_FOREACH(wm, winlinks, &s2->windows) {
-			win_ses++;
-			if (sflag && wflag)
-				idx_ses++;
-
-			if (wm == s2->curw && s == s2) {
-				if (wflag && !sflag) {
-					/*
-					 * Then we're only counting windows.
-					 * So remember which is the current
-					 * window in the list.
-					 */
-					cur_win = win_ses;
-				} else
-					cur_win = idx_ses;
-			}
-
-			xasprintf(&final_win_action, "%s %s %s",
-			    wcd != NULL ? wcd->command : "",
-			    wcd != NULL ? ";" : "", win_action);
-
-			if (win_ses != win_max)
-				cur_win_template = final_win_template_middle;
-			else
-				cur_win_template = final_win_template_last;
-
-			window_choose_add_window(wl->window->active,
-			    c, s2, wm, cur_win_template,
-			    final_win_action,
-			    (wflag && !sflag) ? win_ses : idx_ses);
-
-			free(final_win_action);
-		}
-
-		/*
-		 * If we're just drawing windows, don't consider moving on to
-		 * other sessions as we only list windows in this session.
-		 */
-		if (wflag && !sflag)
-			break;
-	}
-	free(final_win_template_middle);
-	free(final_win_template_last);
-
-	window_choose_ready(wl->window->active, cur_win, NULL);
-
-	if (args_has(args, 'u')) {
-		window_choose_expand_all(wl->window->active);
-		window_choose_set_current(wl->window->active, cur_win);
-	}
-
-	return (CMD_RETURN_NORMAL);
-}

cmd-choose-window.c

@@ -0,0 +1,169 @@
+/* $Id$ */
+
+/*
+ * 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 <ctype.h>
+
+#include "tmux.h"
+
+/*
+ * Enter choice mode to choose a window.
+ */
+
+int	cmd_choose_window_exec(struct cmd *, struct cmd_ctx *);
+
+void	cmd_choose_window_callback(void *, int);
+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]",
+	0,
+	NULL,
+	NULL,
+	cmd_choose_window_exec
+};
+
+struct cmd_choose_window_data {
+	struct client	*client;
+	struct session	*session;
+	char   		*template;
+};
+
+int
+cmd_choose_window_exec(struct cmd *self, struct cmd_ctx *ctx)
+{
+	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				*flags, *title;
+	const char			*left, *right;
+
+	if (ctx->curclient == NULL) {
+		ctx->error(ctx, "must be run interactively");
+		return (-1);
+	}
+	s = ctx->curclient->session;
+
+	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;
+	RB_FOREACH(wm, winlinks, &s->windows) {
+		w = wm->window;
+
+		if (wm == s->curw)
+			cur = idx;
+		idx++;
+
+		flags = window_printable_flags(s, wm);
+		title = w->active->screen->title;
+		if (wm == wl)
+			title = w->active->base.title;
+		left = " \"";
+		right = "\"";
+		if (*title == '\0')
+			left = right = "";
+
+		window_choose_add(wl->window->active,
+		    wm->idx, "%3d: %s%s [%ux%u] (%u panes%s)%s%s%s",
+		    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 (args->argc != 0)
+		cdata->template = xstrdup(args->argv[0]);
+	else
+		cdata->template = xstrdup("select-window -t '%%'");
+	cdata->session = s;
+	cdata->session->references++;
+	cdata->client = ctx->curclient;
+	cdata->client->references++;
+
+	window_choose_ready(wl->window->active,
+	    cur, cmd_choose_window_callback, cmd_choose_window_free, cdata);
+
+	return (0);
+}
+
+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;
+
+	xasprintf(&target, "%s:%d", s->name, idx);
+	template = cmd_template_replace(cdata->template, target, 1);
+	xfree(target);
+
+	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_window_free(void *data)
+{
+	struct cmd_choose_window_data	*cdata = data;
+
+	cdata->session->references--;
+	cdata->client->references--;
+	xfree(cdata->template);
+	xfree(cdata);
+}

cmd-clear-history.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -24,30 +24,31 @@
  * Clear pane history.
  */
 
-enum cmd_retval	 cmd_clear_history_exec(struct cmd *, struct cmd_q *);
+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,
+	NULL,
+	NULL,
 	cmd_clear_history_exec
 };
 
-enum cmd_retval
+int
-cmd_clear_history_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_clear_history_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
 	struct window_pane	*wp;
 	struct grid		*gd;
 
-	if (cmd_find_pane(cmdq, args_get(args, 't'), NULL, &wp) == NULL)
+	if (cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	gd = wp->base.grid;
 
-	if (wp->mode == &window_copy_mode)
+	grid_move_lines(gd, 0, gd->hsize, gd->sy);
-		window_pane_reset_mode(wp);
+	gd->hsize = 0;
-	grid_clear_history(gd);
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-clock-mode.c

@@ -0,0 +1,51 @@
+/* $Id$ */
+
+/*
+ * 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"
+
+/*
+ * Enter clock mode.
+ */
+
+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,
+	NULL,
+	NULL,
+	cmd_clock_mode_exec
+};
+
+int
+cmd_clock_mode_exec(struct cmd *self, struct cmd_ctx *ctx)
+{
+	struct args		*args = self->args;
+	struct window_pane	*wp;
+
+	if (cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp) == NULL)
+		return (-1);
+
+	window_pane_set_mode(wp, &window_clock_mode);
+
+	return (0);
+}

cmd-command-prompt.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -19,7 +19,6 @@
 #include <sys/types.h>
 
 #include <ctype.h>
-#include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
@@ -29,7 +28,9 @@
  * Prompt for command in client.
  */
 
-enum cmd_retval	cmd_command_prompt_exec(struct cmd *, struct cmd_q *);
+void	cmd_command_prompt_key_binding(struct cmd *, int);
+int	cmd_command_prompt_check(struct args *);
+int	cmd_command_prompt_exec(struct cmd *, struct cmd_ctx *);
 
 int	cmd_command_prompt_callback(void *, const char *);
 void	cmd_command_prompt_free(void *);
@@ -39,6 +40,8 @@ const struct cmd_entry cmd_command_prompt_entry = {
 	"I:p:t:", 0, 1,
 	"[-I inputs] [-p prompts] " CMD_TARGET_CLIENT_USAGE " [template]",
 	0,
+	cmd_command_prompt_key_binding,
+	NULL,
 	cmd_command_prompt_exec
 };
 
@@ -52,8 +55,36 @@ struct cmd_command_prompt_cdata {
 	int		 idx;
 };
 
-enum cmd_retval
+void
-cmd_command_prompt_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_command_prompt_key_binding(struct cmd *self, int key)
+{
+	switch (key) {
+	case '$':
+		self->args = args_create(1, "rename-session '%%'");
+		args_set(self->args, 'I', "#S");
+		break;
+	case ',':
+		self->args = args_create(1, "rename-window '%%'");
+		args_set(self->args, 'I', "#W");
+		break;
+	case '.':
+		self->args = args_create(1, "move-window -t '%%'");
+		break;
+	case 'f':
+		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_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args			*args = self->args;
 	const char			*inputs, *prompts;
@@ -62,11 +93,11 @@ cmd_command_prompt_exec(struct cmd *self, struct cmd_q *cmdq)
 	char				*prompt, *ptr, *input = NULL;
 	size_t				 n;
 
-	if ((c = cmd_find_client(cmdq, args_get(args, 't'), 0)) == NULL)
+	if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 
 	if (c->prompt_string != NULL)
-		return (CMD_RETURN_NORMAL);
+		return (0);
 
 	cdata = xmalloc(sizeof *cdata);
 	cdata->c = c;
@@ -107,9 +138,9 @@ cmd_command_prompt_exec(struct cmd *self, struct cmd_q *cmdq)
 
 	status_prompt_set(c, prompt, input, cmd_command_prompt_callback,
 	    cmd_command_prompt_free, cdata, 0);
-	free(prompt);
+	xfree(prompt);
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }
 
 int
@@ -118,6 +149,7 @@ cmd_command_prompt_callback(void *data, const char *s)
 	struct cmd_command_prompt_cdata	*cdata = data;
 	struct client			*c = cdata->c;
 	struct cmd_list			*cmdlist;
+	struct cmd_ctx			 ctx;
 	char				*cause, *new_template, *prompt, *ptr;
 	char				*input = NULL;
 
@@ -125,7 +157,7 @@ cmd_command_prompt_callback(void *data, const char *s)
 		return (0);
 
 	new_template = cmd_template_replace(cdata->template, s, cdata->idx);
-	free(cdata->template);
+	xfree(cdata->template);
 	cdata->template = new_template;
 
 	/*
@@ -137,21 +169,30 @@ cmd_command_prompt_callback(void *data, const char *s)
 		input = strsep(&cdata->next_input, ",");
 		status_prompt_update(c, prompt, input);
 
-		free(prompt);
+		xfree(prompt);
 		cdata->idx++;
 		return (1);
 	}
 
-	if (cmd_string_parse(new_template, &cmdlist, NULL, 0, &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);
-			free(cause);
+			xfree(cause);
 		}
 		return (0);
 	}
 
-	cmdq_run(c->cmdq, cmdlist, NULL);
+	ctx.msgdata = NULL;
+	ctx.curclient = c;
+
+	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);
 
 	if (c->prompt_callbackfn != (void *) &cmd_command_prompt_callback)
@@ -164,8 +205,11 @@ cmd_command_prompt_free(void *data)
 {
 	struct cmd_command_prompt_cdata	*cdata = data;
 
-	free(cdata->inputs);
+	if (cdata->inputs != NULL)
-	free(cdata->prompts);
+		xfree(cdata->inputs);
-	free(cdata->template);
+	if (cdata->prompts != NULL)
-	free(cdata);
+		xfree(cdata->prompts);
+	if (cdata->template != NULL)
+		xfree(cdata->template);
+	xfree(cdata);
 }

cmd-confirm-before.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -16,10 +16,7 @@
  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include <sys/types.h>
-
 #include <ctype.h>
-#include <stdlib.h>
 #include <string.h>
 
 #include "tmux.h"
@@ -28,26 +25,47 @@
  * Asks for confirmation before executing a command.
  */
 
-enum cmd_retval	 cmd_confirm_before_exec(struct cmd *, struct cmd_q *);
+void	cmd_confirm_before_key_binding(struct cmd *, int);
+int	cmd_confirm_before_exec(struct cmd *, struct cmd_ctx *);
 
-int		 cmd_confirm_before_callback(void *, const char *);
+int	cmd_confirm_before_callback(void *, const char *);
-void		 cmd_confirm_before_free(void *);
+void	cmd_confirm_before_free(void *);
 
 const struct cmd_entry cmd_confirm_before_entry = {
 	"confirm-before", "confirm",
 	"p:t:", 1, 1,
 	"[-p prompt] " CMD_TARGET_CLIENT_USAGE " command",
 	0,
+	cmd_confirm_before_key_binding,
+	NULL,
 	cmd_confirm_before_exec
 };
 
 struct cmd_confirm_before_data {
+	struct client	*c;
 	char		*cmd;
-	struct client	*client;
 };
 
-enum cmd_retval
+void
-cmd_confirm_before_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_confirm_before_key_binding(struct cmd *self, int key)
+{
+	switch (key) {
+	case '&':
+		self->args = args_create(1, "kill-window");
+		args_set(self->args, 'p', "kill-window #W? (y/n)");
+		break;
+	case 'x':
+		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;
+	}
+}
+
+int
+cmd_confirm_before_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args			*args = self->args;
 	struct cmd_confirm_before_data	*cdata;
@@ -55,8 +73,13 @@ cmd_confirm_before_exec(struct cmd *self, struct cmd_q *cmdq)
 	char				*cmd, *copy, *new_prompt, *ptr;
 	const char			*prompt;
 
-	if ((c = cmd_find_client(cmdq, args_get(args, 't'), 0)) == NULL)
+	if (ctx->curclient == NULL) {
-		return (CMD_RETURN_ERROR);
+		ctx->error(ctx, "must be run interactively");
+		return (-1);
+	}
+
+	if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
+		return (-1);
 
 	if ((prompt = args_get(args, 'p')) != NULL)
 		xasprintf(&new_prompt, "%s ", prompt);
@@ -64,48 +87,53 @@ cmd_confirm_before_exec(struct cmd *self, struct cmd_q *cmdq)
 		ptr = copy = xstrdup(args->argv[0]);
 		cmd = strsep(&ptr, " \t");
 		xasprintf(&new_prompt, "Confirm '%s'? (y/n) ", cmd);
-		free(copy);
+		xfree(copy);
 	}
 
 	cdata = xmalloc(sizeof *cdata);
 	cdata->cmd = xstrdup(args->argv[0]);
-
+	cdata->c = c;
-	cdata->client = c;
+	status_prompt_set(cdata->c, new_prompt, NULL,
-	cdata->client->references++;
-
-	status_prompt_set(c, new_prompt, NULL,
 	    cmd_confirm_before_callback, cmd_confirm_before_free, cdata,
 	    PROMPT_SINGLE);
 
-	free(new_prompt);
+	xfree(new_prompt);
-	return (CMD_RETURN_NORMAL);
+	return (1);
 }
 
 int
 cmd_confirm_before_callback(void *data, const char *s)
 {
 	struct cmd_confirm_before_data	*cdata = data;
-	struct client			*c = cdata->client;
+	struct client			*c = cdata->c;
 	struct cmd_list			*cmdlist;
+	struct cmd_ctx	 	 	 ctx;
 	char				*cause;
 
-	if (c->flags & CLIENT_DEAD)
-		return (0);
-
 	if (s == NULL || *s == '\0')
 		return (0);
 	if (tolower((u_char) s[0]) != 'y' || s[1] != '\0')
 		return (0);
 
-	if (cmd_string_parse(cdata->cmd, &cmdlist, NULL, 0, &cause) != 0) {
+	if (cmd_string_parse(cdata->cmd, &cmdlist, &cause) != 0) {
 		if (cause != NULL) {
-			cmdq_error(c->cmdq, "%s", cause);
+			*cause = toupper((u_char) *cause);
-			free(cause);
+			status_message_set(c, "%s", cause);
+			xfree(cause);
 		}
 		return (0);
 	}
 
-	cmdq_run(c->cmdq, cmdlist, NULL);
+	ctx.msgdata = NULL;
+	ctx.curclient = c;
+
+	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);
 
 	return (0);
@@ -115,10 +143,8 @@ void
 cmd_confirm_before_free(void *data)
 {
 	struct cmd_confirm_before_data	*cdata = data;
-	struct client			*c = cdata->client;
 
-	server_client_unref(c);
+	if (cdata->cmd != NULL)
-
+		xfree(cdata->cmd);
-	free(cdata->cmd);
+	xfree(cdata);
-	free(cdata);
 }

cmd-copy-mode.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -21,60 +21,44 @@
 #include "tmux.h"
 
 /*
- * Enter copy or clock mode.
+ * Enter copy mode.
  */
 
-enum cmd_retval	 cmd_copy_mode_exec(struct cmd *, struct cmd_q *);
+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,
-	"Met:u", 0, 0,
+	"t:u", 0, 0,
-	"[-Meu] " CMD_TARGET_PANE_USAGE,
+	"[-u] " CMD_TARGET_PANE_USAGE,
 	0,
+	cmd_copy_mode_key_binding,
+	NULL,
 	cmd_copy_mode_exec
 };
 
-const struct cmd_entry cmd_clock_mode_entry = {
+void
-	"clock-mode", NULL,
+cmd_copy_mode_key_binding(struct cmd *self, int key)
-	"t:", 0, 0,
+{
-	CMD_TARGET_PANE_USAGE,
+	self->args = args_create(0);
-	0,
+	if (key == KEYC_PPAGE)
-	cmd_copy_mode_exec
+		args_set(self->args, 'u', NULL);
-};
+}
 
-enum cmd_retval
+int
-cmd_copy_mode_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_copy_mode_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->client;
-	struct session		*s;
 	struct window_pane	*wp;
 
-	if (args_has(args, 'M')) {
+	if (cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp) == NULL)
-		if ((wp = cmd_mouse_pane(&cmdq->item->mouse, &s, NULL)) == NULL)
+		return (-1);
-			return (CMD_RETURN_NORMAL);
-		if (c == NULL || c->session != s)
-			return (CMD_RETURN_NORMAL);
-	} else if (cmd_find_pane(cmdq, args_get(args, 't'), NULL, &wp) == NULL)
-		return (CMD_RETURN_ERROR);
 
-	if (self->entry == &cmd_clock_mode_entry) {
+	if (window_pane_set_mode(wp, &window_copy_mode) != 0)
-		window_pane_set_mode(wp, &window_clock_mode);
+		return (0);
-		return (CMD_RETURN_NORMAL);
+	window_copy_init_from_pane(wp);
-	}
-
-	if (wp->mode != &window_copy_mode) {
-		if (window_pane_set_mode(wp, &window_copy_mode) != 0)
-			return (CMD_RETURN_NORMAL);
-		window_copy_init_from_pane(wp, args_has(self->args, 'e'));
-	}
-	if (args_has(args, 'M')) {
-		if (wp->mode != NULL && wp->mode != &window_copy_mode)
-			return (CMD_RETURN_NORMAL);
-		window_copy_start_drag(c, &cmdq->item->mouse);
-	}
 	if (wp->mode == &window_copy_mode && args_has(self->args, 'u'))
 		window_copy_pageup(wp);
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-delete-buffer.c

@@ -0,0 +1,66 @@
+/* $Id$ */
+
+/*
+ * 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 <stdlib.h>
+
+#include "tmux.h"
+
+/*
+ * Delete a paste buffer.
+ */
+
+int	cmd_delete_buffer_exec(struct cmd *, struct cmd_ctx *);
+
+const struct cmd_entry cmd_delete_buffer_entry = {
+	"delete-buffer", "deleteb",
+	"b:", 0, 0,
+	CMD_BUFFER_USAGE,
+	0,
+	NULL,
+	NULL,
+	cmd_delete_buffer_exec
+};
+
+int
+cmd_delete_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
+{
+	struct args	*args = self->args;
+	char		*cause;
+	int		 buffer;
+
+	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 (paste_free_index(&global_buffers, buffer) != 0) {
+		ctx->error(ctx, "no buffer %d", buffer);
+		return (-1);
+	}
+
+	return (0);
+}

cmd-detach-client.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,48 +18,32 @@
 
 #include <sys/types.h>
 
-#include <string.h>
-
 #include "tmux.h"
 
 /*
  * Detach a client.
  */
 
-enum cmd_retval	 cmd_detach_client_exec(struct cmd *, struct cmd_q *);
+int	cmd_detach_client_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_detach_client_entry = {
 	"detach-client", "detach",
-	"as:t:P", 0, 0,
+	"s:t:P", 0, 0,
-	"[-P] [-a] [-s target-session] " CMD_TARGET_CLIENT_USAGE,
+	"[-P] [-s target-session] " CMD_TARGET_CLIENT_USAGE,
 	CMD_READONLY,
+	NULL,
+	NULL,
 	cmd_detach_client_exec
 };
 
-const struct cmd_entry cmd_suspend_client_entry = {
+int
-	"suspend-client", "suspendc",
+cmd_detach_client_exec(struct cmd *self, struct cmd_ctx *ctx)
-	"t:", 0, 0,
-	CMD_TARGET_CLIENT_USAGE,
-	0,
-	cmd_detach_client_exec
-};
-
-enum cmd_retval
-cmd_detach_client_exec(struct cmd *self, struct cmd_q *cmdq)
 {
 	struct args	*args = self->args;
-	struct client	*c, *cloop;
+	struct client	*c;
-	struct session	*s;
+	struct session 	*s;
-	enum msgtype	 msgtype;
+	enum msgtype     msgtype;
-
+	u_int 		 i;
-	if (self->entry == &cmd_suspend_client_entry) {
-		if ((c = cmd_find_client(cmdq, args_get(args, 't'), 0)) == NULL)
-			return (CMD_RETURN_ERROR);
-		tty_stop_tty(&c->tty);
-		c->flags |= CLIENT_SUSPENDED;
-		server_write_client(c, MSG_SUSPEND, NULL, 0);
-		return (CMD_RETURN_NORMAL);
-	}
 
 	if (args_has(args, 'P'))
 		msgtype = MSG_DETACHKILL;
@@ -67,36 +51,22 @@ cmd_detach_client_exec(struct cmd *self, struct cmd_q *cmdq)
 		msgtype = MSG_DETACH;
 
 	if (args_has(args, 's')) {
-		s = cmd_find_session(cmdq, args_get(args, 's'), 0);
+		s = cmd_find_session(ctx, args_get(args, 's'), 0);
 		if (s == NULL)
-			return (CMD_RETURN_ERROR);
+			return (-1);
 
-		TAILQ_FOREACH(cloop, &clients, entry) {
+		for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
-			if (cloop->session != s)
+			c = ARRAY_ITEM(&clients, i);
-				continue;
+			if (c != NULL && c->session == s)
-			server_write_client(cloop, msgtype,
+				server_write_client(c, msgtype, NULL, 0);
-			    cloop->session->name,
-			    strlen(cloop->session->name) + 1);
 		}
-		return (CMD_RETURN_STOP);
+	} else {
+		c = cmd_find_client(ctx, args_get(args, 't'));
+		if (c == NULL)
+			return (-1);
+
+		server_write_client(c, msgtype, NULL, 0);
 	}
 
-	c = cmd_find_client(cmdq, args_get(args, 't'), 0);
+	return (0);
-	if (c == NULL)
-		return (CMD_RETURN_ERROR);
-
-	if (args_has(args, 'a')) {
-		TAILQ_FOREACH(cloop, &clients, entry) {
-			if (cloop->session == NULL || cloop == c)
-				continue;
-			server_write_client(cloop, msgtype,
-			    cloop->session->name,
-			    strlen(cloop->session->name) + 1);
-		}
-		return (CMD_RETURN_NORMAL);
-	}
-
-	server_write_client(c, msgtype, c->session->name,
-	    strlen(c->session->name) + 1);
-	return (CMD_RETURN_STOP);
 }

cmd-display-message.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -18,7 +18,6 @@
 
 #include <sys/types.h>
 
-#include <stdlib.h>
 #include <time.h>
 
 #include "tmux.h"
@@ -27,24 +26,20 @@
  * Displays a message in the status line.
  */
 
-#define DISPLAY_MESSAGE_TEMPLATE			\
+int	cmd_display_message_exec(struct cmd *, struct cmd_ctx *);
-	"[#{session_name}] #{window_index}:"		\
-	"#{window_name}, current pane #{pane_index} "	\
-	"- (%H:%M %d-%b-%y)"
-
-enum cmd_retval	 cmd_display_message_exec(struct cmd *, struct cmd_q *);
 
 const struct cmd_entry cmd_display_message_entry = {
 	"display-message", "display",
-	"c:pt:F:", 0, 1,
+	"c:pt:", 0, 1,
-	"[-p] [-c target-client] [-F format] " CMD_TARGET_PANE_USAGE
+	"[-p] [-c target-client] [-t target-pane] [message]",
-	" [message]",
 	0,
+	NULL,
+	NULL,
 	cmd_display_message_exec
 };
 
-enum cmd_retval
+int
-cmd_display_message_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_display_message_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
 	struct client		*c;
@@ -53,58 +48,31 @@ cmd_display_message_exec(struct cmd *self, struct cmd_q *cmdq)
 	struct window_pane	*wp;
 	const char		*template;
 	char			*msg;
-	struct format_tree	*ft;
-	char			 out[BUFSIZ];
-	time_t			 t;
-	size_t			 len;
 
-	if (args_has(args, 't')) {
+	if ((c = cmd_find_client(ctx, args_get(args, 'c'))) == NULL)
-		wl = cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp);
+		return (-1);
+
+	if (args_has(args, 't') != 0) {
+		wl = cmd_find_pane(ctx, args_get(args, 't'), &s, &wp);
 		if (wl == NULL)
-			return (CMD_RETURN_ERROR);
+			return (-1);
 	} else {
-		wl = cmd_find_pane(cmdq, NULL, &s, &wp);
+		s = NULL;
-		if (wl == NULL)
+		wl = NULL;
-			return (CMD_RETURN_ERROR);
+		wp = NULL;
 	}
 
-	if (args_has(args, 'F') && args->argc != 0) {
+	if (args->argc == 0)
-		cmdq_error(cmdq, "only one of -F or argument must be given");
+		template = "[#S] #I:#W, current pane #P - (%H:%M %d-%b-%y)";
-		return (CMD_RETURN_ERROR);
+	else
-	}
-
-	if (args_has(args, 'c')) {
-		c = cmd_find_client(cmdq, args_get(args, 'c'), 0);
-		if (c == NULL)
-			return (CMD_RETURN_ERROR);
-	} else {
-		c = cmd_find_client(cmdq, NULL, 1);
-		if (c == NULL && !args_has(self->args, 'p')) {
-			cmdq_error(cmdq, "no client available");
-			return (CMD_RETURN_ERROR);
-		}
-	}
-
-	template = args_get(args, 'F');
-	if (args->argc != 0)
 		template = args->argv[0];
-	if (template == NULL)
-		template = DISPLAY_MESSAGE_TEMPLATE;
 
-	ft = format_create();
+	msg = status_replace(c, s, wl, wp, template, time(NULL), 0);
-	format_defaults(ft, c, s, wl, wp);
-
-	t = time(NULL);
-	len = strftime(out, sizeof out, template, localtime(&t));
-	out[len] = '\0';
-
-	msg = format_expand(ft, out);
 	if (args_has(self->args, 'p'))
-		cmdq_print(cmdq, "%s", msg);
+		ctx->print(ctx, "%s", msg);
 	else
 		status_message_set(c, "%s", msg);
-	free(msg);
+	xfree(msg);
-	format_free(ft);
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-display-panes.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -24,26 +24,28 @@
  * Display panes on a client.
  */
 
-enum cmd_retval	 cmd_display_panes_exec(struct cmd *, struct cmd_q *);
+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,
+	NULL,
+	NULL,
 	cmd_display_panes_exec
 };
 
-enum cmd_retval
+int
-cmd_display_panes_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_display_panes_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args	*args = self->args;
 	struct client	*c;
 
-	if ((c = cmd_find_client(cmdq, args_get(args, 't'), 0)) == NULL)
+	if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 
 	server_set_identify(c);
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-find-window.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -19,7 +19,6 @@
 #include <sys/types.h>
 
 #include <fnmatch.h>
-#include <stdlib.h>
 #include <string.h>
 
 #include "tmux.h"
@@ -28,155 +27,94 @@
  * Find window containing text.
  */
 
-#define FIND_WINDOW_TEMPLATE					\
+int	cmd_find_window_exec(struct cmd *, struct cmd_ctx *);
-	"#{window_index}: #{window_name} "			\
-	"[#{window_width}x#{window_height}] "			\
-	"(#{window_panes} panes) #{window_find_matches}"
 
-enum cmd_retval	 cmd_find_window_exec(struct cmd *, struct cmd_q *);
+void	cmd_find_window_callback(void *, int);
-
+void	cmd_find_window_free(void *);
-void	cmd_find_window_callback(struct window_choose_data *);
-
-/* Flags for determining matching behavior. */
-#define CMD_FIND_WINDOW_BY_TITLE   0x1
-#define CMD_FIND_WINDOW_BY_CONTENT 0x2
-#define CMD_FIND_WINDOW_BY_NAME    0x4
-
-#define CMD_FIND_WINDOW_ALL		\
-	(CMD_FIND_WINDOW_BY_TITLE |	\
-	 CMD_FIND_WINDOW_BY_CONTENT |	\
-	 CMD_FIND_WINDOW_BY_NAME)
 
 const struct cmd_entry cmd_find_window_entry = {
 	"find-window", "findw",
-	"F:CNt:T", 1, 4,
+	"t:", 1, 1,
-	"[-CNT] [-F format] " CMD_TARGET_WINDOW_USAGE " match-string",
+	CMD_TARGET_WINDOW_USAGE " match-string",
 	0,
+	NULL,
+	NULL,
 	cmd_find_window_exec
 };
 
 struct cmd_find_window_data {
-	struct winlink	*wl;
+	struct session	*session;
-	char		*list_ctx;
-	u_int		 pane_id;
-	TAILQ_ENTRY(cmd_find_window_data) entry;
 };
-TAILQ_HEAD(cmd_find_window_list, cmd_find_window_data);
 
-u_int	cmd_find_window_match_flags(struct args *);
+int
-void	cmd_find_window_match(struct cmd_find_window_list *, int,
+cmd_find_window_exec(struct cmd *self, struct cmd_ctx *ctx)
-	    struct winlink *, const char *, const char *);
-
-u_int
-cmd_find_window_match_flags(struct args *args)
-{
-	u_int	match_flags = 0;
-
-	/* Turn on flags based on the options. */
-	if (args_has(args, 'T'))
-		match_flags |= CMD_FIND_WINDOW_BY_TITLE;
-	if (args_has(args, 'C'))
-		match_flags |= CMD_FIND_WINDOW_BY_CONTENT;
-	if (args_has(args, 'N'))
-		match_flags |= CMD_FIND_WINDOW_BY_NAME;
-
-	/* If none of the flags were set, default to matching anything. */
-	if (match_flags == 0)
-		match_flags = CMD_FIND_WINDOW_ALL;
-
-	return (match_flags);
-}
-
-void
-cmd_find_window_match(struct cmd_find_window_list *find_list,
-    int match_flags, struct winlink *wl, const char *str,
-    const char *searchstr)
-{
-	struct cmd_find_window_data	*find_data;
-	struct window_pane		*wp;
-	u_int				 i, line;
-	char				*sres;
-
-	find_data = xcalloc(1, sizeof *find_data);
-
-	i = 0;
-	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
-		i++;
-
-		if ((match_flags & CMD_FIND_WINDOW_BY_NAME) &&
-		    fnmatch(searchstr, wl->window->name, 0) == 0) {
-			find_data->list_ctx = xstrdup("");
-			break;
-		}
-
-		if ((match_flags & CMD_FIND_WINDOW_BY_TITLE) &&
-		    fnmatch(searchstr, wp->base.title, 0) == 0) {
-			xasprintf(&find_data->list_ctx,
-			    "pane %u title: \"%s\"", i - 1, wp->base.title);
-			break;
-		}
-
-		if (match_flags & CMD_FIND_WINDOW_BY_CONTENT &&
-		    (sres = window_pane_search(wp, str, &line)) != NULL) {
-			xasprintf(&find_data->list_ctx,
-			    "pane %u line %u: \"%s\"", i - 1, line + 1, sres);
-			free(sres);
-			break;
-		}
-	}
-
-	if (find_data->list_ctx != NULL) {
-		find_data->wl = wl;
-		find_data->pane_id = i - 1;
-		TAILQ_INSERT_TAIL(find_list, find_data, entry);
-	} else
-		free(find_data);
-}
-
-enum cmd_retval
-cmd_find_window_exec(struct cmd *self, struct cmd_q *cmdq)
 {
 	struct args			*args = self->args;
-	struct client			*c;
+	struct cmd_find_window_data	*cdata;
-	struct window_choose_data	*cdata;
 	struct session			*s;
 	struct winlink			*wl, *wm;
-	struct cmd_find_window_list	 find_list;
+	struct window			*w;
-	struct cmd_find_window_data	*find_data;
+	struct window_pane		*wp;
-	struct cmd_find_window_data	*find_data1;
+	ARRAY_DECL(, u_int)	 	 list_idx;
-	char				*str, *searchstr;
+	ARRAY_DECL(, char *)	 	 list_ctx;
-	const char			*template;
+	char				*str, *sres, *sctx, *searchstr;
-	u_int				 i, match_flags;
+	u_int				 i, line;
 
-	if ((c = cmd_find_client(cmdq, NULL, 1)) == NULL) {
+	if (ctx->curclient == NULL) {
-		cmdq_error(cmdq, "no client available");
+		ctx->error(ctx, "must be run interactively");
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
-	s = c->session;
+	s = ctx->curclient->session;
 
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), NULL)) == NULL)
+	if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 
-	if ((template = args_get(args, 'F')) == NULL)
-		template = FIND_WINDOW_TEMPLATE;
-
-	match_flags = cmd_find_window_match_flags(args);
 	str = args->argv[0];
 
-	TAILQ_INIT(&find_list);
+	ARRAY_INIT(&list_idx);
+	ARRAY_INIT(&list_ctx);
 
 	xasprintf(&searchstr, "*%s*", str);
-	RB_FOREACH(wm, winlinks, &s->windows)
+	RB_FOREACH(wm, winlinks, &s->windows) {
-	    cmd_find_window_match(&find_list, match_flags, wm, str, searchstr);
+		i = 0;
-	free(searchstr);
+		TAILQ_FOREACH(wp, &wm->window->panes, entry) {
+			i++;
 
-	if (TAILQ_EMPTY(&find_list)) {
+			if (fnmatch(searchstr, wm->window->name, 0) == 0)
-		cmdq_error(cmdq, "no windows matching: %s", str);
+				sctx = xstrdup("");
-		return (CMD_RETURN_ERROR);
+			else {
+				sres = window_pane_search(wp, str, &line);
+				if (sres == NULL &&
+				    fnmatch(searchstr, wp->base.title, 0) != 0)
+					continue;
+
+				if (sres == NULL) {
+					xasprintf(&sctx,
+					    "pane %u title: \"%s\"", i - 1,
+					    wp->base.title);
+				} else {
+					xasprintf(&sctx,
+					    "pane %u line %u: \"%s\"", i - 1,
+					    line + 1, sres);
+					xfree(sres);
+				}
+			}
+
+			ARRAY_ADD(&list_idx, wm->idx);
+			ARRAY_ADD(&list_ctx, sctx);
+		}
+	}
+	xfree(searchstr);
+
+	if (ARRAY_LENGTH(&list_idx) == 0) {
+		ctx->error(ctx, "no windows matching: %s", str);
+		ARRAY_FREE(&list_idx);
+		ARRAY_FREE(&list_ctx);
+		return (-1);
 	}
 
-	if (TAILQ_NEXT(TAILQ_FIRST(&find_list), entry) == NULL) {
+	if (ARRAY_LENGTH(&list_idx) == 1) {
-		if (session_select(s, TAILQ_FIRST(&find_list)->wl->idx) == 0)
+		if (session_select(s, ARRAY_FIRST(&list_idx)) == 0)
 			server_redraw_session(s);
 		recalculate_sizes();
 		goto out;
@@ -185,55 +123,54 @@ cmd_find_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
 		goto out;
 
-	i = 0;
+	for (i = 0; i < ARRAY_LENGTH(&list_idx); i++) {
-	TAILQ_FOREACH(find_data, &find_list, entry) {
+		wm = winlink_find_by_index(
-		cdata = window_choose_data_create(TREE_OTHER, c, c->session);
+		    &s->windows, ARRAY_ITEM(&list_idx, i));
-		cdata->idx = find_data->wl->idx;
+		w = wm->window;
-		cdata->wl = find_data->wl;
 
-		cdata->ft_template = xstrdup(template);
+		sctx = ARRAY_ITEM(&list_ctx, i);
-		cdata->pane_id = find_data->pane_id;
+		window_choose_add(wl->window->active,
-
+		    wm->idx, "%3d: %s [%ux%u] (%u panes) %s", wm->idx, w->name,
-		format_add(cdata->ft, "line", "%u", i);
+		    w->sx, w->sy, window_count_panes(w), sctx);
-		format_add(cdata->ft, "window_find_matches", "%s",
+		xfree(sctx);
-		    find_data->list_ctx);
-		format_defaults(cdata->ft, NULL, s, find_data->wl, NULL);
-
-		window_choose_add(wl->window->active, cdata);
-
-		i++;
 	}
 
-	window_choose_ready(wl->window->active, 0, cmd_find_window_callback);
+	cdata = xmalloc(sizeof *cdata);
+	cdata->session = s;
+	cdata->session->references++;
+
+	window_choose_ready(wl->window->active,
+	    0, cmd_find_window_callback, cmd_find_window_free, cdata);
 
 out:
-	TAILQ_FOREACH_SAFE(find_data, &find_list, entry, find_data1) {
+	ARRAY_FREE(&list_idx);
-		free(find_data->list_ctx);
+	ARRAY_FREE(&list_ctx);
-		TAILQ_REMOVE(&find_list, find_data, entry);
+
-		free(find_data);
+	return (0);
-	}
-	return (CMD_RETURN_NORMAL);
 }
 
 void
-cmd_find_window_callback(struct window_choose_data *cdata)
+cmd_find_window_callback(void *data, int idx)
 {
-	struct session		*s;
+	struct cmd_find_window_data	*cdata = data;
-	struct window_pane	*wp;
+	struct session			*s = cdata->session;
 
-	if (cdata == NULL)
+	if (idx == -1)
 		return;
-
-	s = cdata->start_session;
 	if (!session_alive(s))
 		return;
 
-	wp = window_pane_at_index(cdata->wl->window, cdata->pane_id);
+	if (session_select(s, idx) == 0) {
-	if (wp != NULL && window_pane_visible(wp))
-		window_set_active_pane(cdata->wl->window, wp);
-
-	if (session_select(s, cdata->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-has-session.c

@@ -0,0 +1,48 @@
+/* $Id$ */
+
+/*
+ * 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"
+
+/*
+ * Cause client to report an error and exit with 1 if session doesn't exist.
+ */
+
+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,
+	NULL,
+	NULL,
+	cmd_has_session_exec
+};
+
+int
+cmd_has_session_exec(struct cmd *self, struct cmd_ctx *ctx)
+{
+	struct args	*args = self->args;
+
+	if (cmd_find_session(ctx, args_get(args, 't'), 0) == NULL)
+		return (-1);
+
+	return (0);
+}

cmd-if-shell.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -20,190 +20,93 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 
-#include <stdlib.h>
 #include <string.h>
 
 #include "tmux.h"
 
 /*
- * Executes a tmux command if a shell command returns true or false.
+ * Executes a tmux command if a shell command returns true.
  */
 
-enum cmd_retval	 cmd_if_shell_exec(struct cmd *, struct cmd_q *);
+int	cmd_if_shell_exec(struct cmd *, struct cmd_ctx *);
 
 void	cmd_if_shell_callback(struct job *);
-void	cmd_if_shell_done(struct cmd_q *);
 void	cmd_if_shell_free(void *);
 
 const struct cmd_entry cmd_if_shell_entry = {
 	"if-shell", "if",
-	"bFt:", 2, 3,
+	"", 2, 2,
-	"[-bF] " CMD_TARGET_PANE_USAGE " shell-command command [command]",
+	"shell-command command",
 	0,
+	NULL,
+	NULL,
 	cmd_if_shell_exec
 };
 
 struct cmd_if_shell_data {
-	char			*cmd_if;
+	char		*cmd;
-	char			*cmd_else;
+	struct cmd_ctx	 ctx;
-
-	struct cmd_q		*cmdq;
-	struct mouse_event	 mouse;
-
-	int			 bflag;
-	int			 references;
 };
 
-enum cmd_retval
+int
-cmd_if_shell_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_if_shell_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args			*args = self->args;
 	struct cmd_if_shell_data	*cdata;
-	char				*shellcmd, *cmd, *cause;
+	const char			*shellcmd = args->argv[0];
-	struct cmd_list			*cmdlist;
-	struct client			*c;
-	struct session			*s = NULL;
-	struct winlink			*wl = NULL;
-	struct window_pane		*wp = NULL;
-	struct format_tree		*ft;
-	int				 cwd;
-
-	if (args_has(args, 't')) {
-		wl = cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp);
-		cwd = wp->cwd;
-	} else {
-		c = cmd_find_client(cmdq, NULL, 1);
-		if (c != NULL && c->session != NULL) {
-			s = c->session;
-			wl = s->curw;
-			wp = wl->window->active;
-		}
-		if (cmdq->client != NULL && cmdq->client->session == NULL)
-			cwd = cmdq->client->cwd;
-		else if (s != NULL)
-			cwd = s->cwd;
-		else
-			cwd = -1;
-	}
-
-	ft = format_create();
-	format_defaults(ft, NULL, s, wl, wp);
-	shellcmd = format_expand(ft, args->argv[0]);
-	format_free(ft);
-
-	if (args_has(args, 'F')) {
-		cmd = NULL;
-		if (*shellcmd != '0' && *shellcmd != '\0')
-			cmd = args->argv[1];
-		else if (args->argc == 3)
-			cmd = args->argv[2];
-		if (cmd == NULL)
-			return (CMD_RETURN_NORMAL);
-		if (cmd_string_parse(cmd, &cmdlist, NULL, 0, &cause) != 0) {
-			if (cause != NULL) {
-				cmdq_error(cmdq, "%s", cause);
-				free(cause);
-			}
-			return (CMD_RETURN_ERROR);
-		}
-		cmdq_run(cmdq, cmdlist, &cmdq->item->mouse);
-		cmd_list_free(cmdlist);
-		return (CMD_RETURN_NORMAL);
-	}
 
 	cdata = xmalloc(sizeof *cdata);
+	cdata->cmd = xstrdup(args->argv[1]);
+	memcpy(&cdata->ctx, ctx, sizeof cdata->ctx);
 
-	cdata->cmd_if = xstrdup(args->argv[1]);
+	if (ctx->cmdclient != NULL)
-	if (args->argc == 3)
+		ctx->cmdclient->references++;
-		cdata->cmd_else = xstrdup(args->argv[2]);
+	if (ctx->curclient != NULL)
-	else
+		ctx->curclient->references++;
-		cdata->cmd_else = NULL;
 
-	cdata->bflag = args_has(args, 'b');
+	job_run(shellcmd, cmd_if_shell_callback, cmd_if_shell_free, cdata);
 
-	cdata->cmdq = cmdq;
+	return (1);	/* don't let client exit */
-	memcpy(&cdata->mouse, &cmdq->item->mouse, sizeof cdata->mouse);
-	cmdq->references++;
-
-	cdata->references = 1;
-	job_run(shellcmd, s, cwd, cmd_if_shell_callback, cmd_if_shell_free,
-	    cdata);
-	free(shellcmd);
-
-	if (cdata->bflag)
-		return (CMD_RETURN_NORMAL);
-	return (CMD_RETURN_WAIT);
 }
 
 void
 cmd_if_shell_callback(struct job *job)
 {
 	struct cmd_if_shell_data	*cdata = job->data;
-	struct cmd_q			*cmdq = cdata->cmdq, *cmdq1;
+	struct cmd_ctx			*ctx = &cdata->ctx;
 	struct cmd_list			*cmdlist;
-	char				*cause, *cmd;
+	char				*cause;
-
-	if (cmdq->flags & CMD_Q_DEAD)
-		return;
 
 	if (!WIFEXITED(job->status) || WEXITSTATUS(job->status) != 0)
-		cmd = cdata->cmd_else;
-	else
-		cmd = cdata->cmd_if;
-	if (cmd == NULL)
 		return;
 
-	if (cmd_string_parse(cmd, &cmdlist, NULL, 0, &cause) != 0) {
+	if (cmd_string_parse(cdata->cmd, &cmdlist, &cause) != 0) {
 		if (cause != NULL) {
-			cmdq_error(cmdq, "%s", cause);
+			ctx->error(ctx, "%s", cause);
-			free(cause);
+			xfree(cause);
 		}
 		return;
 	}
 
-	cmdq1 = cmdq_new(cmdq->client);
+	cmd_list_exec(cmdlist, ctx);
-	cmdq1->emptyfn = cmd_if_shell_done;
-	cmdq1->data = cdata;
-
-	cdata->references++;
-	cmdq_run(cmdq1, cmdlist, &cdata->mouse);
 	cmd_list_free(cmdlist);
 }
 
-void
-cmd_if_shell_done(struct cmd_q *cmdq1)
-{
-	struct cmd_if_shell_data	*cdata = cmdq1->data;
-	struct cmd_q			*cmdq = cdata->cmdq;
-
-	if (cmdq1->client_exit >= 0)
-		cmdq->client_exit = cmdq1->client_exit;
-	cmdq_free(cmdq1);
-
-	if (--cdata->references != 0)
-		return;
-
-	if (!cmdq_free(cmdq) && !cdata->bflag)
-		cmdq_continue(cmdq);
-
-	free(cdata->cmd_else);
-	free(cdata->cmd_if);
-	free(cdata);
-}
-
 void
 cmd_if_shell_free(void *data)
 {
 	struct cmd_if_shell_data	*cdata = data;
-	struct cmd_q			*cmdq = cdata->cmdq;
+	struct cmd_ctx			*ctx = &cdata->ctx;
+	struct msg_exit_data		 exitdata;
 
-	if (--cdata->references != 0)
+	if (ctx->cmdclient != NULL) {
-		return;
+		ctx->cmdclient->references--;
+		exitdata.retcode = ctx->cmdclient->retcode;
+		ctx->cmdclient->flags |= CLIENT_EXIT;
+	}
+	if (ctx->curclient != NULL)
+		ctx->curclient->references--;
 
-	if (!cmdq_free(cmdq) && !cdata->bflag)
+	xfree(cdata->cmd);
-		cmdq_continue(cmdq);
+	xfree(cdata);
-
-	free(cdata->cmd_else);
-	free(cdata->cmd_if);
-	free(cdata);
 }

cmd-join-pane.c

@@ -1,7 +1,6 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
- * Copyright (c) 2011 George Nachman <tmux@georgester.com>
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
  *
  * Permission to use, copy, modify, and distribute this software for any
@@ -25,37 +24,38 @@
 #include "tmux.h"
 
 /*
- * Join or move a pane into another (like split/swap/kill).
+ * Join a pane into another (like split/swap/kill).
  */
 
-enum cmd_retval	 cmd_join_pane_exec(struct cmd *, struct cmd_q *);
+void	cmd_join_pane_key_binding(struct cmd *, int);
-
+int	cmd_join_pane_exec(struct cmd *, struct cmd_ctx *);
-enum cmd_retval	 join_pane(struct cmd *, struct cmd_q *, int);
 
 const struct cmd_entry cmd_join_pane_entry = {
 	"join-pane", "joinp",
-	"bdhvp:l:s:t:", 0, 0,
+	"dhvp:l:s:t:", 0, 0,
-	"[-bdhv] [-p percentage|-l size] " CMD_SRCDST_PANE_USAGE,
+	"[-dhv] [-p percentage|-l size] [-s src-pane] [-t dst-pane]",
 	0,
+	cmd_join_pane_key_binding,
+	NULL,
 	cmd_join_pane_exec
 };
 
-const struct cmd_entry cmd_move_pane_entry = {
+void
-	"move-pane", "movep",
+cmd_join_pane_key_binding(struct cmd *self, int key)
-	"bdhvp:l:s:t:", 0, 0,
-	"[-bdhv] [-p percentage|-l size] " CMD_SRCDST_PANE_USAGE,
-	0,
-	cmd_join_pane_exec
-};
-
-enum cmd_retval
-cmd_join_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 {
-	return (join_pane(self, cmdq, self->entry == &cmd_join_pane_entry));
+	switch (key) {
+	case '%':
+		self->args = args_create(0);
+		args_set(self->args, 'h', NULL);
+		break;
+	default:
+		self->args = args_create(0);
+		break;
+	}
 }
 
-enum cmd_retval
+int
-join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
+cmd_join_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
 	struct session		*dst_s;
@@ -67,26 +67,20 @@ join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
 	enum layout_type	 type;
 	struct layout_cell	*lc;
 
-	dst_wl = cmd_find_pane(cmdq, args_get(args, 't'), &dst_s, &dst_wp);
+	dst_wl = cmd_find_pane(ctx, args_get(args, 't'), &dst_s, &dst_wp);
 	if (dst_wl == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	dst_w = dst_wl->window;
 	dst_idx = dst_wl->idx;
-	server_unzoom_window(dst_w);
 
-	src_wl = cmd_find_pane_marked(cmdq, args_get(args, 's'), NULL, &src_wp);
+	src_wl = cmd_find_pane(ctx, args_get(args, 's'), NULL, &src_wp);
 	if (src_wl == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	src_w = src_wl->window;
-	server_unzoom_window(src_w);
 
-	if (not_same_window && src_w == dst_w) {
+	if (src_w == dst_w) {
-		cmdq_error(cmdq, "can't join a pane to its own window");
+		ctx->error(ctx, "can't join a pane to its own window");
-		return (CMD_RETURN_ERROR);
+		return (-1);
-	}
-	if (!not_same_window && src_wp == dst_wp) {
-		cmdq_error(cmdq, "source and target panes must be different");
-		return (CMD_RETURN_ERROR);
 	}
 
 	type = LAYOUT_TOPBOTTOM;
@@ -97,37 +91,39 @@ join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
 	if (args_has(args, 'l')) {
 		size = args_strtonum(args, 'l', 0, INT_MAX, &cause);
 		if (cause != NULL) {
-			cmdq_error(cmdq, "size %s", cause);
+			ctx->error(ctx, "size %s", cause);
-			free(cause);
+			xfree(cause);
-			return (CMD_RETURN_ERROR);
+			return (-1);
 		}
 	} else if (args_has(args, 'p')) {
 		percentage = args_strtonum(args, 'p', 0, 100, &cause);
 		if (cause != NULL) {
-			cmdq_error(cmdq, "percentage %s", cause);
+			ctx->error(ctx, "percentage %s", cause);
-			free(cause);
+			xfree(cause);
-			return (CMD_RETURN_ERROR);
+			return (-1);
 		}
 		if (type == LAYOUT_TOPBOTTOM)
 			size = (dst_wp->sy * percentage) / 100;
 		else
 			size = (dst_wp->sx * percentage) / 100;
 	}
-	lc = layout_split_pane(dst_wp, type, size, args_has(args, 'b'));
+
-	if (lc == NULL) {
+	if ((lc = layout_split_pane(dst_wp, type, size)) == NULL) {
-		cmdq_error(cmdq, "create pane failed: pane too small");
+		ctx->error(ctx, "create pane failed: pane too small");
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 
 	layout_close_pane(src_wp);
 
-	window_lost_pane(src_w, src_wp);
+	if (src_w->active == src_wp) {
+		src_w->active = TAILQ_PREV(src_wp, window_panes, entry);
+		if (src_w->active == NULL)
+			src_w->active = TAILQ_NEXT(src_wp, entry);
+	}
 	TAILQ_REMOVE(&src_w->panes, src_wp, entry);
 
 	if (window_count_panes(src_w) == 0)
 		server_kill_window(src_w);
-	else
-		notify_window_layout_changed(src_w);
 
 	src_wp->window = dst_w;
 	TAILQ_INSERT_AFTER(&dst_w->panes, dst_wp, src_wp, entry);
@@ -145,6 +141,5 @@ join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
 	} else
 		server_status_session(dst_s);
 
-	notify_window_layout_changed(dst_w);
+	return (0);
-	return (CMD_RETURN_NORMAL);
 }

cmd-kill-pane.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -26,40 +26,44 @@
  * Kill pane.
  */
 
-enum cmd_retval	 cmd_kill_pane_exec(struct cmd *, struct cmd_q *);
+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,
+	NULL,
+	NULL,
 	cmd_kill_pane_exec
 };
 
-enum cmd_retval
+int
-cmd_kill_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_kill_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
 	struct winlink		*wl;
-	struct window_pane	*loopwp, *tmpwp, *wp;
+	struct window_pane	*loopwp, *nextwp, *wp;
 
-	if ((wl = cmd_find_pane(cmdq, args_get(args, 't'), NULL, &wp)) == NULL)
+	if ((wl = cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
-	server_unzoom_window(wl->window);
 
 	if (window_count_panes(wl->window) == 1) {
 		/* Only one pane, kill the window. */
 		server_kill_window(wl->window);
 		recalculate_sizes();
-		return (CMD_RETURN_NORMAL);
+		return (0);
 	}
 
 	if (args_has(self->args, 'a')) {
-		TAILQ_FOREACH_SAFE(loopwp, &wl->window->panes, entry, tmpwp) {
+		loopwp = TAILQ_FIRST(&wl->window->panes);
-			if (loopwp == wp)
+		while (loopwp != NULL) {
-				continue;
+			nextwp = TAILQ_NEXT(loopwp, entry);
-			layout_close_pane(loopwp);
+			if (loopwp != wp) {
-			window_remove_pane(wl->window, loopwp);
+				layout_close_pane(loopwp);
+				window_remove_pane(wl->window, loopwp);
+			}
+			loopwp = nextwp;
 		}
 	} else {
 		layout_close_pane(wp);
@@ -67,5 +71,5 @@ cmd_kill_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	}
 	server_redraw_window(wl->window);
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-kill-server.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -27,29 +27,23 @@
  * Kill the server and do nothing else.
  */
 
-enum cmd_retval	 cmd_kill_server_exec(struct cmd *, struct cmd_q *);
+int	cmd_kill_server_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_kill_server_entry = {
 	"kill-server", NULL,
 	"", 0, 0,
 	"",
 	0,
+	NULL,
+	NULL,
 	cmd_kill_server_exec
 };
 
-const struct cmd_entry cmd_start_server_entry = {
+/* ARGSUSED */
-	"start-server", "start",
+int
-	"", 0, 0,
+cmd_kill_server_exec(unused struct cmd *self, unused struct cmd_ctx *ctx)
-	"",
-	CMD_STARTSERVER,
-	cmd_kill_server_exec
-};
-
-enum cmd_retval
-cmd_kill_server_exec(struct cmd *self, unused struct cmd_q *cmdq)
 {
-	if (self->entry == &cmd_kill_server_entry)
+	kill(getpid(), SIGTERM);
-		kill(getpid(), SIGTERM);
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-kill-session.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -27,35 +27,29 @@
  * Note this deliberately has no alias to make it hard to hit by accident.
  */
 
-enum cmd_retval	 cmd_kill_session_exec(struct cmd *, struct cmd_q *);
+int	cmd_kill_session_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_kill_session_entry = {
 	"kill-session", NULL,
-	"at:", 0, 0,
+	"t:", 0, 0,
-	"[-a] " CMD_TARGET_SESSION_USAGE,
+	CMD_TARGET_SESSION_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_kill_session_exec
 };
 
-enum cmd_retval
+int
-cmd_kill_session_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_kill_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args	*args = self->args;
-	struct session	*s, *sloop, *stmp;
+	struct session	*s;
 
-	if ((s = cmd_find_session(cmdq, args_get(args, 't'), 0)) == NULL)
+	if ((s = cmd_find_session(ctx, args_get(args, 't'), 0)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 
-	if (args_has(args, 'a')) {
+	server_destroy_session(s);
-		RB_FOREACH_SAFE(sloop, sessions, &sessions, stmp) {
+	session_destroy(s);
-			if (sloop != s) {
+
-				server_destroy_session(sloop);
+	return (0);
-				session_destroy(sloop);
-			}
-		}
-	} else {
-		server_destroy_session(s);
-		session_destroy(s);
-	}
-	return (CMD_RETURN_NORMAL);
 }

cmd-kill-window.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -24,52 +24,29 @@
  * Destroy window.
  */
 
-enum cmd_retval	 cmd_kill_window_exec(struct cmd *, struct cmd_q *);
+int	cmd_kill_window_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_kill_window_entry = {
 	"kill-window", "killw",
-	"at:", 0, 0,
+	"t:", 0, 0,
-	"[-a] " CMD_TARGET_WINDOW_USAGE,
+	CMD_TARGET_WINDOW_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_kill_window_exec
 };
 
-const struct cmd_entry cmd_unlink_window_entry = {
+int
-	"unlink-window", "unlinkw",
+cmd_kill_window_exec(struct cmd *self, struct cmd_ctx *ctx)
-	"kt:", 0, 0,
-	"[-k] " CMD_TARGET_WINDOW_USAGE,
-	0,
-	cmd_kill_window_exec
-};
-
-enum cmd_retval
-cmd_kill_window_exec(struct cmd *self, struct cmd_q *cmdq)
 {
 	struct args	*args = self->args;
-	struct winlink	*wl, *wl2, *wl3;
+	struct winlink	*wl;
-	struct window	*w;
-	struct session	*s;
 
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), &s)) == NULL)
+	if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
-	w = wl->window;
-
-	if (self->entry == &cmd_unlink_window_entry) {
-		if (!args_has(self->args, 'k') && !session_is_linked(s, w)) {
-			cmdq_error(cmdq, "window only linked to one session");
-			return (CMD_RETURN_ERROR);
-		}
-		server_unlink_window(s, wl);
-	} else {
-		if (args_has(args, 'a')) {
-			RB_FOREACH_SAFE(wl2, winlinks, &s->windows, wl3) {
-				if (wl != wl2)
-					server_kill_window(wl2->window);
-			}
-		} else
-			server_kill_window(wl->window);
-	}
 
+	server_kill_window(wl->window);
 	recalculate_sizes();
-	return (CMD_RETURN_NORMAL);
+
+	return (0);
 }

cmd-link-window.c

@@ -0,0 +1,65 @@
+/* $Id$ */
+
+/*
+ * 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 <stdlib.h>
+
+#include "tmux.h"
+
+/*
+ * Link a window into another session.
+ */
+
+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,
+	NULL,
+	NULL,
+	cmd_link_window_exec
+};
+
+int
+cmd_link_window_exec(struct cmd *self, struct cmd_ctx *ctx)
+{
+	struct args	*args = self->args;
+	struct session	*src, *dst;
+	struct winlink	*wl;
+	char		*cause;
+	int		 idx, kflag, dflag;
+
+	if ((wl = cmd_find_window(ctx, args_get(args, 's'), &src)) == NULL)
+		return (-1);
+	if ((idx = cmd_find_index(ctx, args_get(args, 't'), &dst)) == -2)
+		return (-1);
+
+	kflag = args_has(self->args, 'k');
+	dflag = args_has(self->args, 'd');
+	if (server_link_window(src, wl, dst, idx, kflag, !dflag, &cause) != 0) {
+		ctx->error(ctx, "can't link window: %s", cause);
+		xfree(cause);
+		return (-1);
+	}
+	recalculate_sizes();
+
+	return (0);
+}

cmd-list-buffers.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,7 +18,6 @@
 
 #include <sys/types.h>
 
-#include <stdlib.h>
 #include <string.h>
 
 #include "tmux.h"
@@ -27,42 +26,33 @@
  * List paste buffers.
  */
 
-#define LIST_BUFFERS_TEMPLATE						\
+int	cmd_list_buffers_exec(struct cmd *, struct cmd_ctx *);
-	"#{buffer_name}: #{buffer_size} bytes: \"#{buffer_sample}\""
-
-enum cmd_retval	 cmd_list_buffers_exec(struct cmd *, struct cmd_q *);
 
 const struct cmd_entry cmd_list_buffers_entry = {
 	"list-buffers", "lsb",
-	"F:", 0, 0,
+	"", 0, 0,
-	"[-F format]",
+	"",
 	0,
+	NULL,
+	NULL,
 	cmd_list_buffers_exec
 };
 
-enum cmd_retval
+/* ARGSUSED */
-cmd_list_buffers_exec(unused struct cmd *self, struct cmd_q *cmdq)
+int
+cmd_list_buffers_exec(unused struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct args		*args = self->args;
 	struct paste_buffer	*pb;
-	struct format_tree	*ft;
+	u_int			 idx;
-	char			*line;
+	char			*tmp;
-	const char		*template;
 
-	if ((template = args_get(args, 'F')) == NULL)
+	idx = 0;
-		template = LIST_BUFFERS_TEMPLATE;
+	while ((pb = paste_walk_stack(&global_buffers, &idx)) != NULL) {
-
+		tmp = paste_print(pb, 50);
-	pb = NULL;
+		ctx->print(ctx,
-	while ((pb = paste_walk(pb)) != NULL) {
+		    "%u: %zu bytes: \"%s\"", idx - 1, pb->size, tmp);
-		ft = format_create();
+		xfree(tmp);
-		format_defaults_paste_buffer(ft, pb, 0);
-
-		line = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", line);
-		free(line);
-
-		format_free(ft);
 	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-list-clients.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,7 +18,6 @@
 
 #include <sys/types.h>
 
-#include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
@@ -28,59 +27,51 @@
  * List all clients.
  */
 
-#define LIST_CLIENTS_TEMPLATE					\
+int	cmd_list_clients_exec(struct cmd *, struct cmd_ctx *);
-	"#{client_tty}: #{session_name} "			\
-	"[#{client_width}x#{client_height} #{client_termname}]"	\
-	"#{?client_utf8, (utf8),} #{?client_readonly, (ro),}"
-
-enum cmd_retval	cmd_list_clients_exec(struct cmd *, struct cmd_q *);
 
 const struct cmd_entry cmd_list_clients_entry = {
 	"list-clients", "lsc",
-	"F:t:", 0, 0,
+	"t:", 0, 0,
-	"[-F format] " CMD_TARGET_SESSION_USAGE,
+	CMD_TARGET_SESSION_USAGE,
-	CMD_READONLY,
+	0,
+	NULL,
+	NULL,
 	cmd_list_clients_exec
 };
 
-enum cmd_retval
+/* ARGSUSED */
-cmd_list_clients_exec(struct cmd *self, struct cmd_q *cmdq)
+int
+cmd_list_clients_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct args 		*args = self->args;
+	struct args 	*args = self->args;
-	struct client		*c;
+	struct client	*c;
-	struct session		*s;
+	struct session  *s;
-	struct format_tree	*ft;
+	u_int		 i;
-	const char		*template;
+	const char	*s_utf8;
-	u_int			 idx;
-	char			*line;
 
 	if (args_has(args, 't')) {
-		s = cmd_find_session(cmdq, args_get(args, 't'), 0);
+		s = cmd_find_session(ctx, args_get(args, 't'), 0);
 		if (s == NULL)
-			return (CMD_RETURN_ERROR);
+			return (-1);
 	} else
 		s = NULL;
 
-	if ((template = args_get(args, 'F')) == NULL)
+	for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
-		template = LIST_CLIENTS_TEMPLATE;
+		c = ARRAY_ITEM(&clients, i);
-
+		if (c == NULL || c->session == NULL)
-	idx = 0;
-	TAILQ_FOREACH(c, &clients, entry) {
-		if (c->session == NULL || (s != NULL && s != c->session))
 			continue;
 
-		ft = format_create();
+		if (c->tty.flags & TTY_UTF8)
-		format_add(ft, "line", "%u", idx);
+			s_utf8 = " (utf8)";
-		format_defaults(ft, c, NULL, NULL, NULL);
+		else
+			s_utf8 = "";
 
-		line = format_expand(ft, template);
+		if (s != NULL && s != c->session)
-		cmdq_print(cmdq, "%s", line);
+			continue;
-		free(line);
+		ctx->print(ctx, "%s: %s [%ux%u %s]%s", c->tty.path,
-
+		    c->session->name, c->tty.sx, c->tty.sy,
-		format_free(ft);
+		    c->tty.termname, s_utf8);
-
-		idx++;
 	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-list-commands.c

@@ -0,0 +1,49 @@
+/* $Id$ */
+
+/*
+ * 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"
+
+/*
+ * List all commands with usages.
+ */
+
+int	cmd_list_commands_exec(struct cmd *, struct cmd_ctx *);
+
+const struct cmd_entry cmd_list_commands_entry = {
+	"list-commands", "lscm",
+	"", 0, 0,
+	"",
+	0,
+	NULL,
+	NULL,
+	cmd_list_commands_exec
+};
+
+/* ARGSUSED */
+int
+cmd_list_commands_exec(unused struct cmd *self, struct cmd_ctx *ctx)
+{
+	const struct cmd_entry 	      **entryp;
+
+	for (entryp = cmd_table; *entryp != NULL; entryp++)
+		ctx->print(ctx, "%s %s", (*entryp)->name, (*entryp)->usage);
+
+	return (0);
+}

cmd-list-keys.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -26,102 +26,80 @@
  * List key bindings.
  */
 
-enum cmd_retval	 cmd_list_keys_exec(struct cmd *, struct cmd_q *);
+int	cmd_list_keys_exec(struct cmd *, struct cmd_ctx *);
 
-enum cmd_retval	 cmd_list_keys_table(struct cmd *, struct cmd_q *);
+int	cmd_list_keys_table(struct cmd *, struct cmd_ctx *);
-enum cmd_retval	 cmd_list_keys_commands(struct cmd *, struct cmd_q *);
 
 const struct cmd_entry cmd_list_keys_entry = {
 	"list-keys", "lsk",
-	"t:T:", 0, 0,
+	"t:", 0, 0,
-	"[-t mode-table] [-T key-table]",
+	"[-t key-table]",
 	0,
+	NULL,
+	NULL,
 	cmd_list_keys_exec
 };
 
-const struct cmd_entry cmd_list_commands_entry = {
+int
-	"list-commands", "lscm",
+cmd_list_keys_exec(struct cmd *self, struct cmd_ctx *ctx)
-	"", 0, 0,
-	"",
-	0,
-	cmd_list_keys_exec
-};
-
-enum cmd_retval
-cmd_list_keys_exec(struct cmd *self, struct cmd_q *cmdq)
 {
 	struct args		*args = self->args;
-	struct key_table	*table;
 	struct key_binding	*bd;
-	const char		*key, *tablename, *r;
+	const char		*key;
-	char			 tmp[BUFSIZ];
+	char			 tmp[BUFSIZ], flags[8];
 	size_t			 used;
-	int			 repeat, width, tablewidth, keywidth;
+	int			 width, keywidth;
-
-	if (self->entry == &cmd_list_commands_entry)
-		return (cmd_list_keys_commands(self, cmdq));
 
 	if (args_has(args, 't'))
-		return (cmd_list_keys_table(self, cmdq));
+		return (cmd_list_keys_table(self, ctx));
 
-	tablename = args_get(args, 'T');
+	width = 0;
-	if (tablename != NULL && key_bindings_get_table(tablename, 0) == NULL) {
+	*flags = '\0';
-		cmdq_error(cmdq, "table %s doesn't exist", tablename);
-		return (CMD_RETURN_ERROR);
-	}
 
-	repeat = 0;
+	SPLAY_FOREACH(bd, key_bindings, &key_bindings) {
-	tablewidth = keywidth = 0;
+		key = key_string_lookup_key(bd->key & ~KEYC_PREFIX);
-	RB_FOREACH(table, key_tables, &key_tables) {
+		if (key == NULL)
-		if (tablename != NULL && strcmp(table->name, tablename) != 0)
 			continue;
-		RB_FOREACH(bd, key_bindings, &table->key_bindings) {
-			key = key_string_lookup_key(bd->key);
-			if (key == NULL)
-				continue;
 
+		keywidth = strlen(key);
+		if (!(bd->key & KEYC_PREFIX)) {
 			if (bd->can_repeat)
-				repeat = 1;
+				keywidth += 4;
-
-			width = strlen(table->name);
-			if (width > tablewidth)
-				tablewidth =width;
-			width = strlen(key);
-			if (width > keywidth)
-				keywidth = width;
-		}
-	}
-
-	RB_FOREACH(table, key_tables, &key_tables) {
-		if (tablename != NULL && strcmp(table->name, tablename) != 0)
-			continue;
-		RB_FOREACH(bd, key_bindings, &table->key_bindings) {
-			key = key_string_lookup_key(bd->key);
-			if (key == NULL)
-				continue;
-
-			if (!repeat)
-				r = "";
-			else if (bd->can_repeat)
-				r = "-r ";
 			else
-				r = "   ";
+				keywidth += 3;
-			used = xsnprintf(tmp, sizeof tmp, "%s-T %-*s %-*s ", r,
+		} else if (bd->can_repeat)
-			    (int)tablewidth, table->name, (int)keywidth, key);
+			keywidth += 3;
-			if (used < sizeof tmp) {
+		if (keywidth > width)
-				cmd_list_print(bd->cmdlist, tmp + used,
+			width = keywidth;
-				    (sizeof tmp) - used);
-			}
-
-			cmdq_print(cmdq, "bind-key %s", tmp);
-		}
 	}
 
-	return (CMD_RETURN_NORMAL);
+	SPLAY_FOREACH(bd, key_bindings, &key_bindings) {
+		key = key_string_lookup_key(bd->key & ~KEYC_PREFIX);
+		if (key == NULL)
+			continue;
+
+		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;
+
+		cmd_list_print(bd->cmdlist, tmp + used, (sizeof tmp) - used);
+		ctx->print(ctx, "bind-key %s", tmp);
+	}
+
+	return (0);
 }
 
-enum cmd_retval
+int
-cmd_list_keys_table(struct cmd *self, struct cmd_q *cmdq)
+cmd_list_keys_table(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args			*args = self->args;
 	const char			*tablename;
@@ -132,13 +110,13 @@ cmd_list_keys_table(struct cmd *self, struct cmd_q *cmdq)
 
 	tablename = args_get(args, 't');
 	if ((mtab = mode_key_findtable(tablename)) == NULL) {
-		cmdq_error(cmdq, "unknown key table: %s", tablename);
+		ctx->error(ctx, "unknown key table: %s", tablename);
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 
 	width = 0;
 	any_mode = 0;
-	RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
+	SPLAY_FOREACH(mbind, mode_key_tree, mtab->tree) {
 		key = key_string_lookup_key(mbind->key);
 		if (key == NULL)
 			continue;
@@ -151,7 +129,7 @@ cmd_list_keys_table(struct cmd *self, struct cmd_q *cmdq)
 			width = keywidth;
 	}
 
-	RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
+	SPLAY_FOREACH(mbind, mode_key_tree, mtab->tree) {
 		key = key_string_lookup_key(mbind->key);
 		if (key == NULL)
 			continue;
@@ -161,33 +139,11 @@ cmd_list_keys_table(struct cmd *self, struct cmd_q *cmdq)
 			mode = "c";
 		cmdstr = mode_key_tostring(mtab->cmdstr, mbind->cmd);
 		if (cmdstr != NULL) {
-			cmdq_print(cmdq, "bind-key -%st %s%s %*s %s%s%s%s",
+			ctx->print(ctx, "bind-key -%st %s%s %*s %s",
 			    mode, any_mode && *mode == '\0' ? " " : "",
-			    mtab->name, (int) width, key, cmdstr,
+			    mtab->name, (int) width, key, cmdstr);
-			    mbind->arg != NULL ? " \"" : "",
-			    mbind->arg != NULL ? mbind->arg : "",
-			    mbind->arg != NULL ? "\"": "");
 		}
 	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
-}
-
-enum cmd_retval
-cmd_list_keys_commands(unused struct cmd *self, struct cmd_q *cmdq)
-{
-	const struct cmd_entry	**entryp;
-	const struct cmd_entry	 *entry;
-
-	for (entryp = cmd_table; *entryp != NULL; entryp++) {
-		entry = *entryp;
-		if (entry->alias == NULL) {
-			cmdq_print(cmdq, "%s %s", entry->name, entry->usage);
-			continue;
-		}
-		cmdq_print(cmdq, "%s (%s) %s", entry->name, entry->alias,
-		    entry->usage);
-	}
-
-	return (CMD_RETURN_NORMAL);
 }

cmd-list-panes.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,7 +18,7 @@
 
 #include <sys/types.h>
 
-#include <stdlib.h>
+#include <unistd.h>
 
 #include "tmux.h"
 
@@ -26,114 +26,112 @@
  * List panes on given window.
  */
 
-enum cmd_retval	 cmd_list_panes_exec(struct cmd *, struct cmd_q *);
+int	cmd_list_panes_exec(struct cmd *, struct cmd_ctx *);
 
-void	cmd_list_panes_server(struct cmd *, struct cmd_q *);
+void	cmd_list_panes_server(struct cmd_ctx *);
-void	cmd_list_panes_session(struct cmd *, struct session *, struct cmd_q *,
+void	cmd_list_panes_session(struct session *, struct cmd_ctx *, int);
-	    int);
+void	cmd_list_panes_window(
-void	cmd_list_panes_window(struct cmd *, struct session *, struct winlink *,
+	    struct session *, struct winlink *, struct cmd_ctx *, int);
-	    struct cmd_q *, int);
 
 const struct cmd_entry cmd_list_panes_entry = {
 	"list-panes", "lsp",
-	"asF:t:", 0, 0,
+	"ast:", 0, 0,
-	"[-as] [-F format] " CMD_TARGET_WINDOW_USAGE,
+	"[-as] [-t target]",
 	0,
+	NULL,
+	NULL,
 	cmd_list_panes_exec
 };
 
-enum cmd_retval
+int
-cmd_list_panes_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_list_panes_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args	*args = self->args;
 	struct session	*s;
 	struct winlink	*wl;
 
 	if (args_has(args, 'a'))
-		cmd_list_panes_server(self, cmdq);
+		cmd_list_panes_server(ctx);
 	else if (args_has(args, 's')) {
-		s = cmd_find_session(cmdq, args_get(args, 't'), 0);
+		s = cmd_find_session(ctx, args_get(args, 't'), 0);
 		if (s == NULL)
-			return (CMD_RETURN_ERROR);
+			return (-1);
-		cmd_list_panes_session(self, s, cmdq, 1);
+		cmd_list_panes_session(s, ctx, 1);
 	} else {
-		wl = cmd_find_window(cmdq, args_get(args, 't'), &s);
+		wl = cmd_find_window(ctx, args_get(args, 't'), &s);
 		if (wl == NULL)
-			return (CMD_RETURN_ERROR);
+			return (-1);
-		cmd_list_panes_window(self, s, wl, cmdq, 0);
+		cmd_list_panes_window(s, wl, ctx, 0);
 	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }
 
 void
-cmd_list_panes_server(struct cmd *self, struct cmd_q *cmdq)
+cmd_list_panes_server(struct cmd_ctx *ctx)
 {
 	struct session	*s;
 
 	RB_FOREACH(s, sessions, &sessions)
-		cmd_list_panes_session(self, s, cmdq, 2);
+		cmd_list_panes_session(s, ctx, 2);
 }
 
 void
-cmd_list_panes_session(struct cmd *self, struct session *s, struct cmd_q *cmdq,
+cmd_list_panes_session(struct session *s, struct cmd_ctx *ctx, int type)
-    int type)
 {
 	struct winlink	*wl;
 
 	RB_FOREACH(wl, winlinks, &s->windows)
-		cmd_list_panes_window(self, s, wl, cmdq, type);
+		cmd_list_panes_window(s, wl, ctx, type);
 }
 
 void
-cmd_list_panes_window(struct cmd *self, struct session *s, struct winlink *wl,
+cmd_list_panes_window(
-    struct cmd_q *cmdq, int type)
+    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 grid		*gd;
-	struct format_tree	*ft;
+	struct grid_line	*gl;
-	const char		*template;
+	u_int			 i, n;
-	char			*line;
+	unsigned long long	 size;
-
-	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();
+		gd = wp->base.grid;
-		format_add(ft, "line", "%u", n);
-		format_defaults(ft, NULL, s, wl, wp);
 
-		line = format_expand(ft, template);
+		size = 0;
-		cmdq_print(cmdq, "%s", line);
+		for (i = 0; i < gd->hsize; i++) {
-		free(line);
+			gl = &gd->linedata[i];
+			size += gl->cellsize * sizeof *gl->celldata;
+			size += gl->utf8size * sizeof *gl->utf8data;
+		}
+		size += gd->hsize * sizeof *gd->linedata;
 
-		format_free(ft);
+		switch (type) {
+		case 0:
+			ctx->print(ctx,
+			    "%u: [%ux%u] [history %u/%u, %llu bytes] %%%u%s%s",
+			    n, wp->sx, wp->sy, gd->hsize, gd->hlimit, size,
+			    wp->id, wp == wp->window->active ? " (active)" : "",
+			    wp->fd == -1 ? " (dead)" : "");
+			break;
+		case 1:
+			ctx->print(ctx,
+			    "%d.%u: [%ux%u] [history %u/%u, %llu bytes] "
+			    "%%%u%s%s", wl->idx,
+			    n, wp->sx, wp->sy, gd->hsize, gd->hlimit, size,
+			    wp->id, wp == wp->window->active ? " (active)" : "",
+			    wp->fd == -1 ? " (dead)" : "");
+			break;
+		case 2:
+			ctx->print(ctx,
+			    "%s:%d.%u: [%ux%u] [history %u/%u, %llu bytes] "
+			    "%%%u%s%s", s->name, wl->idx,
+			    n, wp->sx, wp->sy, gd->hsize, gd->hlimit, size,
+			    wp->id, wp == wp->window->active ? " (active)" : "",
+			    wp->fd == -1 ? " (dead)" : "");
+			break;
+		}
 		n++;
 	}
 }

cmd-list-sessions.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,7 +18,6 @@
 
 #include <sys/types.h>
 
-#include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
@@ -28,50 +27,45 @@
  * List all sessions.
  */
 
-#define LIST_SESSIONS_TEMPLATE				\
+int	cmd_list_sessions_exec(struct cmd *, struct cmd_ctx *);
-	"#{session_name}: #{session_windows} windows "	\
-	"(created #{session_created_string}) "		\
-	"[#{session_width}x#{session_height}]"		\
-	"#{?session_grouped, (group ,}"			\
-	"#{session_group}#{?session_grouped,),}"	\
-	"#{?session_attached, (attached),}"
-
-enum cmd_retval	 cmd_list_sessions_exec(struct cmd *, struct cmd_q *);
 
 const struct cmd_entry cmd_list_sessions_entry = {
 	"list-sessions", "ls",
-	"F:", 0, 0,
+	"", 0, 0,
-	"[-F format]",
+	"",
 	0,
+	NULL,
+	NULL,
 	cmd_list_sessions_exec
 };
 
-enum cmd_retval
+/* ARGSUSED */
-cmd_list_sessions_exec(struct cmd *self, struct cmd_q *cmdq)
+int
+cmd_list_sessions_exec(unused struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct args		*args = self->args;
 	struct session		*s;
-	u_int		 	 n;
+	struct session_group	*sg;
-	struct format_tree	*ft;
+	char			*tim, tmp[64];
-	const char		*template;
+	u_int			 idx;
-	char			*line;
+	time_t			 t;
 
-	if ((template = args_get(args, 'F')) == NULL)
-		template = LIST_SESSIONS_TEMPLATE;
-
-	n = 0;
 	RB_FOREACH(s, sessions, &sessions) {
-		ft = format_create();
+		sg = session_group_find(s);
-		format_add(ft, "line", "%u", n);
+		if (sg == NULL)
-		format_defaults(ft, NULL, s, NULL, NULL);
+			*tmp = '\0';
+		else {
+			idx = session_group_index(sg);
+			xsnprintf(tmp, sizeof tmp, " (group %u)", idx);
+		}
 
-		line = format_expand(ft, template);
+		t = s->creation_time.tv_sec;
-		cmdq_print(cmdq, "%s", line);
+		tim = ctime(&t);
-		free(line);
+		*strchr(tim, '\n') = '\0';
 
-		format_free(ft);
+		ctx->print(ctx, "%s: %u windows (created %s) [%ux%u]%s%s",
-		n++;
+		    s->name, winlink_count(&s->windows), tim, s->sx, s->sy,
+		    tmp, s->flags & SESSION_UNATTACHED ? "" : " (attached)");
 	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-list-windows.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,7 +18,6 @@
 
 #include <sys/types.h>
 
-#include <stdlib.h>
 #include <unistd.h>
 
 #include "tmux.h"
@@ -27,93 +26,67 @@
  * List windows on given session.
  */
 
-#define LIST_WINDOWS_TEMPLATE					\
+int	cmd_list_windows_exec(struct cmd *, struct cmd_ctx *);
-	"#{window_index}: #{window_name}#{window_flags} "	\
-	"(#{window_panes} panes) "				\
-	"[#{window_width}x#{window_height}] "			\
-	"[layout #{window_layout}] #{window_id}"		\
-	"#{?window_active, (active),}";
-#define LIST_WINDOWS_WITH_SESSION_TEMPLATE			\
-	"#{session_name}:"					\
-	"#{window_index}: #{window_name}#{window_flags} "	\
-	"(#{window_panes} panes) "				\
-	"[#{window_width}x#{window_height}] "
 
-enum cmd_retval	 cmd_list_windows_exec(struct cmd *, struct cmd_q *);
+void	cmd_list_windows_server(struct cmd_ctx *);
-
+void	cmd_list_windows_session(struct session *, struct cmd_ctx *, int);
-void	cmd_list_windows_server(struct cmd *, struct cmd_q *);
-void	cmd_list_windows_session(struct cmd *, struct session *,
-	    struct cmd_q *, int);
 
 const struct cmd_entry cmd_list_windows_entry = {
 	"list-windows", "lsw",
-	"F:at:", 0, 0,
+	"at:", 0, 0,
-	"[-a] [-F format] " CMD_TARGET_SESSION_USAGE,
+	"[-a] " CMD_TARGET_SESSION_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_list_windows_exec
 };
 
-enum cmd_retval
+int
-cmd_list_windows_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_list_windows_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args	*args = self->args;
 	struct session	*s;
 
 	if (args_has(args, 'a'))
-		cmd_list_windows_server(self, cmdq);
+		cmd_list_windows_server(ctx);
 	else {
-		s = cmd_find_session(cmdq, args_get(args, 't'), 0);
+		s = cmd_find_session(ctx, args_get(args, 't'), 0);
 		if (s == NULL)
-			return (CMD_RETURN_ERROR);
+			return (-1);
-		cmd_list_windows_session(self, s, cmdq, 0);
+		cmd_list_windows_session(s, ctx, 0);
 	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }
 
 void
-cmd_list_windows_server(struct cmd *self, struct cmd_q *cmdq)
+cmd_list_windows_server(struct cmd_ctx *ctx)
 {
 	struct session	*s;
 
 	RB_FOREACH(s, sessions, &sessions)
-		cmd_list_windows_session(self, s, cmdq, 1);
+		cmd_list_windows_session(s, ctx, 1);
 }
 
 void
-cmd_list_windows_session(
+cmd_list_windows_session(struct session *s, struct cmd_ctx *ctx, int type)
-    struct cmd *self, struct session *s, struct cmd_q *cmdq, int type)
 {
-	struct args		*args = self->args;
+	struct winlink	*wl;
-	struct winlink		*wl;
+	char		*layout;
-	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 = LIST_WINDOWS_TEMPLATE;
-			break;
-		case 1:
-			template = LIST_WINDOWS_WITH_SESSION_TEMPLATE;
-			break;
-		}
-	}
-
-	n = 0;
 	RB_FOREACH(wl, winlinks, &s->windows) {
-		ft = format_create();
+		layout = layout_dump(wl->window);
-		format_add(ft, "line", "%u", n);
+		if (type) {
-		format_defaults(ft, NULL, s, wl, NULL);
+			ctx->print(ctx, "%s:%d: %s [%ux%u] [layout %s]%s",
-
+			    s->name, wl->idx, wl->window->name, wl->window->sx,
-		line = format_expand(ft, template);
+			    wl->window->sy, layout,
-		cmdq_print(cmdq, "%s", line);
+			    wl == s->curw ? " (active)" : "");
-		free(line);
+		} else {
-
+			ctx->print(ctx, "%d: %s [%ux%u] [layout %s]%s",
-		format_free(ft);
+			    wl->idx, wl->window->name, wl->window->sx,
-		n++;
+			    wl->window->sy, layout,
+			    wl == s->curw ? " (active)" : "");
+		}
+		xfree(layout);
 	}
 }

cmd-list.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,14 +18,12 @@
 
 #include <sys/types.h>
 
-#include <stdlib.h>
 #include <string.h>
 
 #include "tmux.h"
 
 struct cmd_list *
-cmd_list_parse(int argc, char **argv, const char *file, u_int line,
+cmd_list_parse(int argc, char **argv, char **cause)
-    char **cause)
 {
 	struct cmd_list	*cmdlist;
 	struct cmd	*cmd;
@@ -35,7 +33,7 @@ cmd_list_parse(int argc, char **argv, const char *file, u_int line,
 
 	copy_argv = cmd_copy_argv(argc, argv);
 
-	cmdlist = xcalloc(1, sizeof *cmdlist);
+	cmdlist = xmalloc(sizeof *cmdlist);
 	cmdlist->references = 1;
 	TAILQ_INIT(&cmdlist->list);
 
@@ -56,7 +54,7 @@ cmd_list_parse(int argc, char **argv, const char *file, u_int line,
 		if (arglen != 1)
 			new_argc++;
 
-		cmd = cmd_parse(new_argc, new_argv, file, line, cause);
+		cmd = cmd_parse(new_argc, new_argv, cause);
 		if (cmd == NULL)
 			goto bad;
 		TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
@@ -65,8 +63,7 @@ cmd_list_parse(int argc, char **argv, const char *file, u_int line,
 	}
 
 	if (lastsplit != argc) {
-		cmd = cmd_parse(argc - lastsplit, copy_argv + lastsplit,
+		cmd = cmd_parse(argc - lastsplit, copy_argv + lastsplit, cause);
-		    file, line, cause);
 		if (cmd == NULL)
 			goto bad;
 		TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
@@ -81,29 +78,63 @@ bad:
 	return (NULL);
 }
 
+int
+cmd_list_exec(struct cmd_list *cmdlist, struct cmd_ctx *ctx)
+{
+	struct cmd	*cmd;
+	int		 n, retval;
+
+	retval = 0;
+	TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
+		if ((n = cmd_exec(cmd, ctx)) == -1)
+			return (-1);
+
+		/*
+		 * A 1 return value means the command client is being attached
+		 * (sent MSG_READY).
+		 */
+		if (n == 1) {
+			retval = 1;
+
+			/*
+			 * The command client has been attached, so mangle the
+			 * context to treat any following commands as if they
+			 * were called from inside.
+			 */
+			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;
+			}
+		}
+	}
+	return (retval);
+}
+
 void
 cmd_list_free(struct cmd_list *cmdlist)
 {
-	struct cmd	*cmd, *cmd1;
+	struct cmd	*cmd;
 
 	if (--cmdlist->references != 0)
 		return;
 
-	TAILQ_FOREACH_SAFE(cmd, &cmdlist->list, qentry, cmd1) {
+	while (!TAILQ_EMPTY(&cmdlist->list)) {
+		cmd = TAILQ_FIRST(&cmdlist->list);
 		TAILQ_REMOVE(&cmdlist->list, cmd, qentry);
-		args_free(cmd->args);
+		cmd_free(cmd);
-		free(cmd->file);
-		free(cmd);
 	}
-
+	xfree(cmdlist);
-	free(cmdlist);
 }
 
 size_t
 cmd_list_print(struct cmd_list *cmdlist, char *buf, size_t len)
 {
 	struct cmd	*cmd;
-	size_t		 off, used;
+	size_t		 off;
 
 	off = 0;
 	TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
@@ -112,12 +143,8 @@ cmd_list_print(struct cmd_list *cmdlist, char *buf, size_t len)
 		off += cmd_print(cmd, buf + off, len - off);
 		if (off >= len)
 			break;
-		if (TAILQ_NEXT(cmd, qentry) != NULL) {
+		if (TAILQ_NEXT(cmd, qentry) != NULL)
-			used = xsnprintf(buf + off, len - off, " ; ");
+			off += xsnprintf(buf + off, len - off, " ; ");
-			if (used > len - off)
-				used = len - off;
-			off += used;
-		}
 	}
 	return (off);
 }

cmd-load-buffer.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -19,7 +19,6 @@
 #include <sys/types.h>
 
 #include <errno.h>
-#include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -28,61 +27,75 @@
 #include "tmux.h"
 
 /*
- * Loads a paste buffer from a file.
+ * Loads a session paste buffer from a file.
  */
 
-enum cmd_retval	 cmd_load_buffer_exec(struct cmd *, struct cmd_q *);
+int	cmd_load_buffer_exec(struct cmd *, struct cmd_ctx *);
-void		 cmd_load_buffer_callback(struct client *, int, void *);
+void	cmd_load_buffer_callback(struct client *, void *);
 
 const struct cmd_entry cmd_load_buffer_entry = {
 	"load-buffer", "loadb",
 	"b:", 1, 1,
 	CMD_BUFFER_USAGE " path",
 	0,
+	NULL,
+	NULL,
 	cmd_load_buffer_exec
 };
 
-enum cmd_retval
+int
-cmd_load_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_load_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args	*args = self->args;
-	struct client	*c = cmdq->client;
+	struct client	*c = ctx->cmdclient;
-	struct session  *s;
 	FILE		*f;
-	const char	*path, *bufname;
+	const char	*path;
 	char		*pdata, *new_pdata, *cause;
 	size_t		 psize;
-	int		 ch, error, cwd, fd;
+	u_int		 limit;
+	int		 ch, buffer;
+	int		*buffer_ptr;
 
-	bufname = NULL;
+	if (!args_has(args, 'b'))
-	if (args_has(args, 'b'))
+		buffer = -1;
-		bufname = args_get(args, 'b');
+	else {
+		buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
+		if (cause != NULL) {
+			ctx->error(ctx, "buffer %s", cause);
+			xfree(cause);
+			return (-1);
+		}
+	}
 
 	path = args->argv[0];
 	if (strcmp(path, "-") == 0) {
-		error = server_set_stdin_callback(c, cmd_load_buffer_callback,
+		if (c == NULL) {
-		    (void *)bufname, &cause);
+			ctx->error(ctx, "%s: can't read from stdin", path);
-		if (error != 0) {
+			return (-1);
-			cmdq_error(cmdq, "%s: %s", path, cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
 		}
-		return (CMD_RETURN_WAIT);
+		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 && c->session == NULL)
+	if ((f = fopen(path, "rb")) == NULL) {
-		cwd = c->cwd;
+		ctx->error(ctx, "%s: %s", path, strerror(errno));
-	else if ((s = cmd_find_current(cmdq)) != NULL)
+		return (-1);
-		cwd = s->cwd;
-	else
-		cwd = AT_FDCWD;
-
-	if ((fd = openat(cwd, path, O_RDONLY)) == -1 ||
-	    (f = fdopen(fd, "rb")) == NULL) {
-		if (fd != -1)
-			close(fd);
-		cmdq_error(cmdq, "%s: %s", path, strerror(errno));
-		return (CMD_RETURN_ERROR);
 	}
 
 	pdata = NULL;
@@ -90,14 +103,14 @@ cmd_load_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 	while ((ch = getc(f)) != EOF) {
 		/* Do not let the server die due to memory exhaustion. */
 		if ((new_pdata = realloc(pdata, psize + 2)) == NULL) {
-			cmdq_error(cmdq, "realloc error: %s", strerror(errno));
+			ctx->error(ctx, "realloc error: %s", strerror(errno));
 			goto error;
 		}
 		pdata = new_pdata;
 		pdata[psize++] = ch;
 	}
 	if (ferror(f)) {
-		cmdq_error(cmdq, "%s: read error", path);
+		ctx->error(ctx, "%s: read error", path);
 		goto error;
 	}
 	if (pdata != NULL)
@@ -105,53 +118,57 @@ cmd_load_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 
 	fclose(f);
 
-	if (paste_set(pdata, psize, bufname, &cause) != 0) {
+	limit = options_get_number(&global_options, "buffer-limit");
-		cmdq_error(cmdq, "%s", cause);
+	if (buffer == -1) {
-		free(pdata);
+		paste_add(&global_buffers, pdata, psize, limit);
-		free(cause);
+		return (0);
-		return (CMD_RETURN_ERROR);
+	}
+	if (paste_replace(&global_buffers, buffer, pdata, psize) != 0) {
+		ctx->error(ctx, "no buffer %d", buffer);
+		return (-1);
 	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 
 error:
-	free(pdata);
+	if (pdata != NULL)
+		xfree(pdata);
 	if (f != NULL)
 		fclose(f);
-	return (CMD_RETURN_ERROR);
+	return (-1);
 }
 
 void
-cmd_load_buffer_callback(struct client *c, int closed, void *data)
+cmd_load_buffer_callback(struct client *c, void *data)
 {
-	const char	*bufname = data;
+	int	*buffer = data;
-	char		*pdata, *cause;
+	char	*pdata;
-	size_t		 psize;
+	size_t	 psize;
+	u_int	 limit;
 
-	if (!closed)
+	/*
+	 * 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;
-	c->stdin_callback = NULL;
+	}
-
+	bufferevent_read(c->stdin_event, pdata, psize);
-	server_client_unref(c);
-	if (c->flags & CLIENT_DEAD)
-		return;
-
-	psize = EVBUFFER_LENGTH(c->stdin_data);
-	if (psize == 0 || (pdata = malloc(psize + 1)) == NULL)
-		goto out;
-
-	memcpy(pdata, EVBUFFER_DATA(c->stdin_data), psize);
 	pdata[psize] = '\0';
-	evbuffer_drain(c->stdin_data, psize);
 
-	if (paste_set(pdata, psize, bufname, &cause) != 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_data, "%s", cause);
+		evbuffer_add_printf(
-		server_push_stderr(c);
+		    c->stderr_event->output, "no buffer %d\n", *buffer);
-		free(pdata);
+		bufferevent_enable(c->stderr_event, EV_WRITE);
-		free(cause);
 	}
 
-out:
+	xfree(data);
-	cmdq_continue(c->cmdq);
 }

cmd-lock-server.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,19 +18,25 @@
 
 #include <sys/types.h>
 
+#include <pwd.h>
+#include <string.h>
+#include <unistd.h>
+
 #include "tmux.h"
 
 /*
  * Lock commands.
  */
 
-enum cmd_retval	 cmd_lock_server_exec(struct cmd *, struct cmd_q *);
+int	cmd_lock_server_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_lock_server_entry = {
 	"lock-server", "lock",
 	"", 0, 0,
 	"",
 	0,
+	NULL,
+	NULL,
 	cmd_lock_server_exec
 };
 
@@ -39,6 +45,8 @@ const struct cmd_entry cmd_lock_session_entry = {
 	"t:", 0, 0,
 	CMD_TARGET_SESSION_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_lock_server_exec
 };
 
@@ -47,11 +55,14 @@ const struct cmd_entry cmd_lock_client_entry = {
 	"t:", 0, 0,
 	CMD_TARGET_CLIENT_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_lock_server_exec
 };
 
-enum cmd_retval
+/* ARGSUSED */
-cmd_lock_server_exec(struct cmd *self, unused struct cmd_q *cmdq)
+int
+cmd_lock_server_exec(struct cmd *self, unused struct cmd_ctx *ctx)
 {
 	struct args	*args = self->args;
 	struct client	*c;
@@ -60,17 +71,15 @@ cmd_lock_server_exec(struct cmd *self, unused struct cmd_q *cmdq)
 	if (self->entry == &cmd_lock_server_entry)
 		server_lock();
 	else if (self->entry == &cmd_lock_session_entry) {
-		s = cmd_find_session(cmdq, args_get(args, 't'), 0);
+		if ((s = cmd_find_session(ctx, args_get(args, 't'), 0)) == NULL)
-		if (s == NULL)
+			return (-1);
-			return (CMD_RETURN_ERROR);
 		server_lock_session(s);
 	} else {
-		c = cmd_find_client(cmdq, args_get(args, 't'), 0);
+		if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
-		if (c == NULL)
+			return (-1);
-			return (CMD_RETURN_ERROR);
 		server_lock_client(c);
 	}
 	recalculate_sizes();
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-move-window.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -26,79 +26,41 @@
  * Move a window.
  */
 
-enum cmd_retval	 cmd_move_window_exec(struct cmd *, struct cmd_q *);
+int	cmd_move_window_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_move_window_entry = {
 	"move-window", "movew",
-	"adkrs:t:", 0, 0,
+	"dks:t:", 0, 0,
-	"[-dkr] " CMD_SRCDST_WINDOW_USAGE,
-	0,
-	cmd_move_window_exec
-};
-
-const struct cmd_entry cmd_link_window_entry = {
-	"link-window", "linkw",
-	"adks:t:", 0, 0,
 	"[-dk] " CMD_SRCDST_WINDOW_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_move_window_exec
 };
 
-enum cmd_retval
+int
-cmd_move_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_move_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args	*args = self->args;
-	struct session	*src, *dst, *s;
+	struct session	*src, *dst;
 	struct winlink	*wl;
 	char		*cause;
-	int		 idx, kflag, dflag, sflag;
+	int		 idx, kflag, dflag;
 
-	if (args_has(args, 'r')) {
+	if ((wl = cmd_find_window(ctx, args_get(args, 's'), &src)) == NULL)
-		s = cmd_find_session(cmdq, args_get(args, 't'), 0);
+		return (-1);
-		if (s == NULL)
+	if ((idx = cmd_find_index(ctx, args_get(args, 't'), &dst)) == -2)
-			return (CMD_RETURN_ERROR);
+		return (-1);
-
-		session_renumber_windows(s);
-		recalculate_sizes();
-
-		return (CMD_RETURN_NORMAL);
-	}
-
-	if ((wl = cmd_find_window(cmdq, args_get(args, 's'), &src)) == NULL)
-		return (CMD_RETURN_ERROR);
-	if ((idx = cmd_find_index(cmdq, args_get(args, 't'), &dst)) == -2)
-		return (CMD_RETURN_ERROR);
 
 	kflag = args_has(self->args, 'k');
 	dflag = args_has(self->args, 'd');
-	sflag = args_has(self->args, 's');
+	if (server_link_window(src, wl, dst, idx, kflag, !dflag, &cause) != 0) {
-
+		ctx->error(ctx, "can't move window: %s", cause);
-	if (args_has(self->args, 'a')) {
+		xfree(cause);
-		s = cmd_find_session(cmdq, args_get(args, 't'), 0);
+		return (-1);
-		if (s == NULL)
-			return (CMD_RETURN_ERROR);
-		if ((idx = winlink_shuffle_up(s, s->curw)) == -1)
-			return (CMD_RETURN_ERROR);
 	}
-
+	server_unlink_window(src, wl);
-	if (server_link_window(src, wl, dst, idx, kflag, !dflag,
-	    &cause) != 0) {
-		cmdq_error(cmdq, "can't link window: %s", cause);
-		free(cause);
-		return (CMD_RETURN_ERROR);
-	}
-	if (self->entry == &cmd_move_window_entry)
-		server_unlink_window(src, wl);
-
-	/*
-	 * Renumber the winlinks in the src session only, the destination
-	 * session already has the correct winlink id to us, either
-	 * automatically or specified by -s.
-	 */
-	if (!sflag && options_get_number(&src->options, "renumber-windows"))
-		session_renumber_windows(src);
-
 	recalculate_sizes();
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-new-session.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,8 +18,7 @@
 
 #include <sys/types.h>
 
-#include <errno.h>
+#include <pwd.h>
-#include <fcntl.h>
 #include <stdlib.h>
 #include <string.h>
 #include <termios.h>
@@ -31,171 +30,155 @@
  * Create a new session and attach to the current terminal unless -d is given.
  */
 
-#define NEW_SESSION_TEMPLATE "#{session_name}:"
+int	cmd_new_session_check(struct args *);
-
+int	cmd_new_session_exec(struct cmd *, struct cmd_ctx *);
-enum cmd_retval	 cmd_new_session_exec(struct cmd *, struct cmd_q *);
 
 const struct cmd_entry cmd_new_session_entry = {
 	"new-session", "new",
-	"Ac:dDEF:n:Ps:t:x:y:", 0, -1,
+	"dn:s:t:x:y:", 0, 1,
-	"[-AdDEP] [-c start-directory] [-F format] [-n window-name] "
+	"[-d] [-n window-name] [-s session-name] [-t target-session] "
-	"[-s session-name] " CMD_TARGET_SESSION_USAGE " [-x width] "
+	"[-x width] [-y height] [command]",
-	"[-y height] [command]",
+	CMD_STARTSERVER|CMD_CANTNEST|CMD_SENDENVIRON,
-	CMD_STARTSERVER,
+	NULL,
+	cmd_new_session_check,
 	cmd_new_session_exec
 };
 
-const struct cmd_entry cmd_has_session_entry = {
+int
-	"has-session", "has",
+cmd_new_session_check(struct args *args)
-	"t:", 0, 0,
+{
-	CMD_TARGET_SESSION_USAGE,
+	if (args_has(args, 't') && (args->argc != 0 || args_has(args, 'n')))
-	0,
+		return (-1);
-	cmd_new_session_exec
+	return (0);
-};
+}
 
-enum cmd_retval
+int
-cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->client, *c0;
+	struct session		*s, *old_s, *groupwith;
-	struct session		*s, *groupwith;
 	struct window		*w;
+	struct window_pane	*wp;
 	struct environ		 env;
 	struct termios		 tio, *tiop;
-	const char		*newname, *target, *update, *errstr, *template;
+	struct passwd		*pw;
-	const char		*path;
+	const char		*newname, *target, *update, *cwd, *errstr;
-	char		       **argv, *cmd, *cause, *cp;
+	char			*overrides, *cmd, *cause;
-	int			 detached, already_attached, idx, cwd, fd = -1;
+	int			 detached, idx;
-	int			 argc;
+	u_int			 sx, sy, i;
-	u_int			 sx, sy;
-	struct format_tree	*ft;
-	struct environ_entry	*envent;
-
-	if (self->entry == &cmd_has_session_entry) {
-		if (cmd_find_session(cmdq, args_get(args, 't'), 0) == NULL)
-			return (CMD_RETURN_ERROR);
-		return (CMD_RETURN_NORMAL);
-	}
-
-	if (args_has(args, 't') && (args->argc != 0 || args_has(args, 'n'))) {
-		cmdq_error(cmdq, "command or window name given with target");
-		return (CMD_RETURN_ERROR);
-	}
 
 	newname = args_get(args, 's');
 	if (newname != NULL) {
 		if (!session_check_name(newname)) {
-			cmdq_error(cmdq, "bad session name: %s", newname);
+			ctx->error(ctx, "bad session name: %s", newname);
-			return (CMD_RETURN_ERROR);
+			return (-1);
 		}
 		if (session_find(newname) != NULL) {
-			if (args_has(args, 'A')) {
+			ctx->error(ctx, "duplicate session: %s", newname);
-				return (cmd_attach_session(cmdq, newname,
+			return (-1);
-				    args_has(args, 'D'), 0, NULL,
-				    args_has(args, 'E')));
-			}
-			cmdq_error(cmdq, "duplicate session: %s", newname);
-			return (CMD_RETURN_ERROR);
 		}
 	}
 
 	target = args_get(args, 't');
 	if (target != NULL) {
-		groupwith = cmd_find_session(cmdq, target, 0);
+		groupwith = cmd_find_session(ctx, target, 0);
 		if (groupwith == NULL)
-			return (CMD_RETURN_ERROR);
+			return (-1);
 	} else
 		groupwith = NULL;
 
+	/*
+	 * There are three cases:
+	 *
+	 * 1. If cmdclient is non-NULL, new-session has been called from the
+	 *    command-line - cmdclient is to become a new attached, interactive
+	 *    client. Unless -d is given, the terminal must be opened and then
+	 *    the client sent MSG_READY.
+	 *
+	 * 2. If cmdclient is NULL, new-session has been called from an
+	 *    existing client (such as a key binding).
+	 *
+	 * 3. Both are NULL, the command was in the configuration file. Treat
+	 *    this as if -d was given even if it was not.
+	 *
+	 * In all cases, a new additional session needs to be created and
+	 * (unless -d) set as the current session for the client.
+	 */
+
 	/* Set -d if no client. */
 	detached = args_has(args, 'd');
-	if (c == NULL)
+	if (ctx->cmdclient == NULL && ctx->curclient == NULL)
 		detached = 1;
 
-	/* Is this client already attached? */
-	already_attached = 0;
-	if (c != NULL && c->session != NULL)
-		already_attached = 1;
-
-	/* Get the new session working directory. */
-	if (args_has(args, 'c')) {
-		ft = format_create();
-		format_defaults(ft, cmd_find_client(cmdq, NULL, 1), NULL, NULL,
-		    NULL);
-		cp = format_expand(ft, args_get(args, 'c'));
-		format_free(ft);
-
-		if (cp != NULL && *cp != '\0') {
-			fd = open(cp, O_RDONLY|O_DIRECTORY);
-			free(cp);
-			if (fd == -1) {
-				cmdq_error(cmdq, "bad working directory: %s",
-				    strerror(errno));
-				return (CMD_RETURN_ERROR);
-			}
-		} else if (cp != NULL)
-			free(cp);
-		cwd = fd;
-	} else if (c != NULL && c->session == NULL)
-		cwd = c->cwd;
-	else if ((c0 = cmd_find_client(cmdq, NULL, 1)) != NULL)
-		cwd = c0->session->cwd;
-	else {
-		fd = open(".", O_RDONLY);
-		cwd = fd;
-	}
-
 	/*
-	 * If this is a new client, check for nesting and save the termios
+	 * Save the termios settings, part of which is used for new windows in
-	 * settings (part of which is used for new windows in this session).
+	 * this session.
 	 *
-	 * tcgetattr() is used rather than using tty.tio since if the client is
+	 * This is read again with tcgetattr() rather than using tty.tio as if
-	 * detached, tty_open won't be called. It must be done before opening
+	 * detached, tty_open won't be called. Because of this, it must be done
-	 * the terminal as that calls tcsetattr() to prepare for tmux taking
+	 * before opening the terminal as that calls tcsetattr() to prepare for
-	 * over.
+	 * tmux taking over.
 	 */
-	if (!detached && !already_attached && c->tty.fd != -1) {
+	if (ctx->cmdclient != NULL && ctx->cmdclient->tty.fd != -1) {
-		if (server_client_check_nested(cmdq->client)) {
+		if (tcgetattr(ctx->cmdclient->tty.fd, &tio) != 0)
-			cmdq_error(cmdq, "sessions should be nested with care, "
-			    "unset $TMUX to force");
-			return (CMD_RETURN_ERROR);
-		}
-		if (tcgetattr(c->tty.fd, &tio) != 0)
 			fatal("tcgetattr failed");
 		tiop = &tio;
 	} else
 		tiop = NULL;
 
 	/* Open the terminal if necessary. */
-	if (!detached && !already_attached) {
+	if (!detached && ctx->cmdclient != NULL) {
-		if (server_client_open(c, &cause) != 0) {
+		if (!(ctx->cmdclient->flags & CLIENT_TERMINAL)) {
-			cmdq_error(cmdq, "open terminal failed: %s", cause);
+			ctx->error(ctx, "not a terminal");
-			free(cause);
+			return (-1);
-			goto error;
+		}
+
+		overrides =
+		    options_get_string(&global_s_options, "terminal-overrides");
+		if (tty_open(&ctx->cmdclient->tty, overrides, &cause) != 0) {
+			ctx->error(ctx, "open terminal failed: %s", cause);
+			xfree(cause);
+			return (-1);
 		}
 	}
 
+	/* Get the new session working directory. */
+	if (ctx->cmdclient != NULL && ctx->cmdclient->cwd != NULL)
+		cwd = ctx->cmdclient->cwd;
+	else {
+		pw = getpwuid(getuid());
+		if (pw->pw_dir != NULL && *pw->pw_dir != '\0')
+			cwd = pw->pw_dir;
+		else
+			cwd = "/";
+	}
+
 	/* Find new session size. */
-	if (c != NULL) {
+	if (detached) {
-		sx = c->tty.sx;
-		sy = c->tty.sy;
-	} else {
 		sx = 80;
 		sy = 24;
-	}
+		if (args_has(args, 'x')) {
-	if (detached && args_has(args, 'x')) {
+			sx = strtonum(
-		sx = strtonum(args_get(args, 'x'), 1, USHRT_MAX, &errstr);
+			    args_get(args, 'x'), 1, USHRT_MAX, &errstr);
-		if (errstr != NULL) {
+			if (errstr != NULL) {
-			cmdq_error(cmdq, "width %s", errstr);
+				ctx->error(ctx, "width %s", errstr);
-			goto error;
+				return (-1);
+			}
 		}
-	}
+		if (args_has(args, 'y')) {
-	if (detached && args_has(args, 'y')) {
+			sy = strtonum(
-		sy = strtonum(args_get(args, 'y'), 1, USHRT_MAX, &errstr);
+			    args_get(args, 'y'), 1, USHRT_MAX, &errstr);
-		if (errstr != NULL) {
+			if (errstr != NULL) {
-			cmdq_error(cmdq, "height %s", errstr);
+				ctx->error(ctx, "height %s", errstr);
-			goto error;
+				return (-1);
+			}
 		}
+	} else if (ctx->cmdclient != NULL) {
+		sx = ctx->cmdclient->tty.sx;
+		sy = ctx->cmdclient->tty.sy;
+	} else {
+		sx = ctx->curclient->tty.sx;
+		sy = ctx->curclient->tty.sy;
 	}
 	if (sy > 0 && options_get_number(&global_s_options, "status"))
 		sy--;
@@ -205,53 +188,36 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 		sy = 1;
 
 	/* Figure out the command for the new window. */
-	argc = -1;
+	if (target != NULL)
-	argv = NULL;
+		cmd = NULL;
-	if (target == NULL && args->argc != 0) {
+	else if (args->argc != 0)
-		argc = args->argc;
+		cmd = args->argv[0];
-		argv = args->argv;
-	} else if (target == NULL) {
-		cmd = options_get_string(&global_s_options, "default-command");
-		if (cmd != NULL && *cmd != '\0') {
-			argc = 1;
-			argv = &cmd;
-		} else {
-			argc = 0;
-			argv = NULL;
-		}
-	}
-
-	path = NULL;
-	if (c != NULL && c->session == NULL)
-		envent = environ_find(&c->environ, "PATH");
 	else
-		envent = environ_find(&global_environ, "PATH");
+		cmd = options_get_string(&global_s_options, "default-command");
-	if (envent != NULL)
-		path = envent->value;
 
 	/* Construct the environment. */
 	environ_init(&env);
-	if (c != NULL && !args_has(args, 'E')) {
+	update = options_get_string(&global_s_options, "update-environment");
-		update = options_get_string(&global_s_options,
+	if (ctx->cmdclient != NULL)
-		    "update-environment");
+		environ_update(update, &ctx->cmdclient->environ, &env);
-		environ_update(update, &c->environ, &env);
-	}
 
 	/* Create the new session. */
 	idx = -1 - options_get_number(&global_s_options, "base-index");
-	s = session_create(newname, argc, argv, path, cwd, &env, tiop, idx, sx,
+	s = session_create(newname, cmd, cwd, &env, tiop, idx, sx, sy, &cause);
-	    sy, &cause);
 	if (s == NULL) {
-		cmdq_error(cmdq, "create session failed: %s", cause);
+		ctx->error(ctx, "create session failed: %s", cause);
-		free(cause);
+		xfree(cause);
-		goto error;
+		return (-1);
 	}
 	environ_free(&env);
 
 	/* Set the initial window name if one given. */
-	if (argc >= 0 && args_has(args, 'n')) {
+	if (cmd != NULL && args_has(args, 'n')) {
 		w = s->curw->window;
-		window_set_name(w, args_get(args, 'n'));
+
+		xfree(w->name);
+		w->name = xstrdup(args_get(args, 'n'));
+
 		options_set_number(&w->options, "automatic-rename", 0);
 	}
 
@@ -262,7 +228,7 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (groupwith != NULL) {
 		session_group_add(groupwith, s);
 		session_group_synchronize_to(s);
-		session_select(s, RB_MIN(winlinks, &s->windows)->idx);
+		session_select(s, RB_ROOT(&s->windows)->idx);
 	}
 
 	/*
@@ -270,16 +236,23 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 	 * taking this session and needs to get MSG_READY and stay around.
 	 */
 	if (!detached) {
-		if (!already_attached)
+		if (ctx->cmdclient != NULL) {
-			server_write_ready(c);
+			server_write_client(ctx->cmdclient, MSG_READY, NULL, 0);
-		else if (c->session != NULL)
+
-			c->last_session = c->session;
+			old_s = ctx->cmdclient->session;
-		c->session = s;
+			if (old_s != NULL)
-		status_timer_start(c);
+				ctx->cmdclient->last_session = old_s;
-		notify_attached_session_changed(c);
+			ctx->cmdclient->session = s;
-		session_update_activity(s, NULL);
+			session_update_activity(s);
-		gettimeofday(&s->last_attached_time, NULL);
+			server_redraw_client(ctx->cmdclient);
-		server_redraw_client(c);
+		} 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);
+		}
 	}
 	recalculate_sizes();
 	server_update_socket();
@@ -288,34 +261,17 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 	 * If there are still configuration file errors to display, put the new
 	 * session's current window into more mode and display them now.
 	 */
-	if (cfg_finished)
+	if (cfg_finished && !ARRAY_EMPTY(&cfg_causes)) {
-		cfg_show_causes(s);
+		wp = s->curw->window->active;
-
+		window_pane_set_mode(wp, &window_copy_mode);
-	/* Print if requested. */
+		window_copy_init_for_output(wp);
-	if (args_has(args, 'P')) {
+		for (i = 0; i < ARRAY_LENGTH(&cfg_causes); i++) {
-		if ((template = args_get(args, 'F')) == NULL)
+			cause = ARRAY_ITEM(&cfg_causes, i);
-			template = NEW_SESSION_TEMPLATE;
+			window_copy_add(wp, "%s", cause);
-
+			xfree(cause);
-		ft = format_create();
+		}
-		format_defaults(ft, cmd_find_client(cmdq, NULL, 1), s, NULL,
+		ARRAY_FREE(&cfg_causes);
-		    NULL);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
-		free(cp);
-
-		format_free(ft);
 	}
 
-	if (!detached)
+	return (!detached);	/* 1 means don't tell command client to exit */
-		cmdq->client_exit = 0;
-
-	if (fd != -1)
-		close(fd);
-	return (CMD_RETURN_NORMAL);
-
-error:
-	if (fd != -1)
-		close(fd);
-	return (CMD_RETURN_ERROR);
 }

cmd-new-window.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,11 +18,7 @@
 
 #include <sys/types.h>
 
-#include <errno.h>
-#include <fcntl.h>
 #include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
 
 #include "tmux.h"
 
@@ -30,91 +26,55 @@
  * Create a new window.
  */
 
-#define NEW_WINDOW_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"
+int	cmd_new_window_exec(struct cmd *, struct cmd_ctx *);
-
-enum cmd_retval	cmd_new_window_exec(struct cmd *, struct cmd_q *);
 
 const struct cmd_entry cmd_new_window_entry = {
 	"new-window", "neww",
-	"ac:dF:kn:Pt:", 0, -1,
+	"adkn:Pt:", 0, 1,
-	"[-adkP] [-c start-directory] [-F format] [-n window-name] "
+	"[-adk] [-n window-name] [-t target-window] [command]",
-	CMD_TARGET_WINDOW_USAGE " [command]",
 	0,
+	NULL,
+	NULL,
 	cmd_new_window_exec
 };
 
-enum cmd_retval
+int
-cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_new_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct args		*args = self->args;
+	struct args	*args = self->args;
-	struct session		*s;
+	struct session	*s;
-	struct winlink		*wl;
+	struct winlink	*wl;
-	const char		*cmd, *path, *template;
+	char		*cmd, *cwd, *cause;
-	char		       **argv, *cause, *cp;
+	int		 idx, last, detached;
-	int			 argc, idx, detached, cwd, fd = -1;
-	struct format_tree	*ft;
-	struct environ_entry	*envent;
 
 	if (args_has(args, 'a')) {
-		wl = cmd_find_window(cmdq, args_get(args, 't'), &s);
+		wl = cmd_find_window(ctx, args_get(args, 't'), &s);
 		if (wl == NULL)
-			return (CMD_RETURN_ERROR);
+			return (-1);
-		if ((idx = winlink_shuffle_up(s, wl)) == -1) {
+		idx = wl->idx + 1;
-			cmdq_error(cmdq, "no free window indexes");
+
-			return (CMD_RETURN_ERROR);
+		/* Find the next free index. */
+		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 {
-		idx = cmd_find_index(cmdq, args_get(args, 't'), &s);
+		if ((idx = cmd_find_index(ctx, args_get(args, 't'), &s)) == -2)
-		if (idx == -2)
+			return (-1);
-			return (CMD_RETURN_ERROR);
 	}
 	detached = args_has(args, 'd');
 
-	if (args->argc == 0) {
-		cmd = options_get_string(&s->options, "default-command");
-		if (cmd != NULL && *cmd != '\0') {
-			argc = 1;
-			argv = (char **)&cmd;
-		} else {
-			argc = 0;
-			argv = NULL;
-		}
-	} else {
-		argc = args->argc;
-		argv = args->argv;
-	}
-
-	path = NULL;
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
-		envent = environ_find(&cmdq->client->environ, "PATH");
-	else
-		envent = environ_find(&s->environ, "PATH");
-	if (envent != NULL)
-		path = envent->value;
-
-	if (args_has(args, 'c')) {
-		ft = format_create();
-		format_defaults(ft, cmd_find_client(cmdq, NULL, 1), s, NULL,
-		    NULL);
-		cp = format_expand(ft, args_get(args, 'c'));
-		format_free(ft);
-
-		if (cp != NULL && *cp != '\0') {
-			fd = open(cp, O_RDONLY|O_DIRECTORY);
-			free(cp);
-			if (fd == -1) {
-				cmdq_error(cmdq, "bad working directory: %s",
-				    strerror(errno));
-				return (CMD_RETURN_ERROR);
-			}
-		} else if (cp != NULL)
-			free(cp);
-		cwd = fd;
-	} else if (cmdq->client != NULL && cmdq->client->session == NULL)
-		cwd = cmdq->client->cwd;
-	else
-		cwd = s->cwd;
-
 	wl = NULL;
 	if (idx != -1)
 		wl = winlink_find_by_index(&s->windows, idx);
@@ -123,7 +83,6 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
 		 * Can't use session_detach as it will destroy session if this
 		 * makes it empty.
 		 */
-		notify_window_unlinked(s, wl->window);
 		wl->flags &= ~WINLINK_ALERTFLAGS;
 		winlink_stack_remove(&s->lastw, wl);
 		winlink_remove(&s->windows, wl);
@@ -135,14 +94,25 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
 		}
 	}
 
+	if (args->argc == 0)
+		cmd = options_get_string(&s->options, "default-command");
+	else
+		cmd = args->argv[0];
+	cwd = options_get_string(&s->options, "default-path");
+	if (*cwd == '\0') {
+		if (ctx->cmdclient != NULL && ctx->cmdclient->cwd != NULL)
+			cwd = ctx->cmdclient->cwd;
+		else
+			cwd = s->cwd;
+	}
+
 	if (idx == -1)
 		idx = -1 - options_get_number(&s->options, "base-index");
-	wl = session_new(s, args_get(args, 'n'), argc, argv, path, cwd, idx,
+	wl = session_new(s, args_get(args, 'n'), cmd, cwd, idx, &cause);
-		&cause);
 	if (wl == NULL) {
-		cmdq_error(cmdq, "create window failed: %s", cause);
+		ctx->error(ctx, "create window failed: %s", cause);
-		free(cause);
+		xfree(cause);
-		goto error;
+		return (-1);
 	}
 	if (!detached) {
 		session_select(s, wl->idx);
@@ -150,27 +120,7 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	} else
 		server_status_session_group(s);
 
-	if (args_has(args, 'P')) {
+	if (args_has(args, 'P'))
-		if ((template = args_get(args, 'F')) == NULL)
+		ctx->print(ctx, "%s:%u", s->name, wl->idx);
-			template = NEW_WINDOW_TEMPLATE;
+	return (0);
-
-		ft = format_create();
-		format_defaults(ft, cmd_find_client(cmdq, NULL, 1), s, wl,
-		    NULL);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
-		free(cp);
-
-		format_free(ft);
-	}
-
-	if (fd != -1)
-		close(fd);
-	return (CMD_RETURN_NORMAL);
-
-error:
-	if (fd != -1)
-		close(fd);
-	return (CMD_RETURN_ERROR);
 }

cmd-paste-buffer.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -27,48 +27,57 @@
  * Paste paste buffer if present.
  */
 
-enum cmd_retval	 cmd_paste_buffer_exec(struct cmd *, struct cmd_q *);
+int	cmd_paste_buffer_exec(struct cmd *, struct cmd_ctx *);
 
-void	cmd_paste_buffer_filter(struct window_pane *,
+void	cmd_paste_buffer_filter(
-	    const char *, size_t, const char *, int);
+	    struct window_pane *, const char *, size_t, const char *);
 
 const struct cmd_entry cmd_paste_buffer_entry = {
 	"paste-buffer", "pasteb",
-	"db:prs:t:", 0, 0,
+	"db:rs:t:", 0, 0,
-	"[-dpr] [-s separator] " CMD_BUFFER_USAGE " " CMD_TARGET_PANE_USAGE,
+	"[-dr] [-s separator] [-b buffer-index] [-t target-pane]",
 	0,
+	NULL,
+	NULL,
 	cmd_paste_buffer_exec
 };
 
-enum cmd_retval
+int
-cmd_paste_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_paste_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
 	struct window_pane	*wp;
 	struct session		*s;
 	struct paste_buffer	*pb;
-	const char		*sepstr, *bufname, *bufdata, *bufend, *line;
+	const char		*sepstr;
-	size_t			 seplen, bufsize;
+	char			*cause;
-	int			 bracket = args_has(args, 'p');
+	int			 buffer;
 
-	if (cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp) == NULL)
+	if (cmd_find_pane(ctx, args_get(args, 't'), &s, &wp) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 
-	bufname = NULL;
+	if (!args_has(args, 'b'))
-	if (args_has(args, 'b'))
+		buffer = -1;
-		bufname = args_get(args, 'b');
-
-	if (bufname == NULL)
-		pb = paste_get_top(NULL);
 	else {
-		pb = paste_get_name(bufname);
+		buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
-		if (pb == NULL) {
+		if (cause != NULL) {
-			cmdq_error(cmdq, "no buffer %s", bufname);
+			ctx->error(ctx, "buffer %s", cause);
-			return (CMD_RETURN_ERROR);
+			xfree(cause);
+			return (-1);
 		}
 	}
 
-	if (pb != NULL && ~wp->flags & PANE_INPUTOFF) {
+	if (buffer == -1)
+		pb = paste_get_top(&global_buffers);
+	else {
+		pb = paste_get_index(&global_buffers, buffer);
+		if (pb == NULL) {
+			ctx->error(ctx, "no buffer %d", buffer);
+			return (-1);
+		}
+	}
+
+	if (pb != NULL) {
 		sepstr = args_get(args, 's');
 		if (sepstr == NULL) {
 			if (args_has(args, 'r'))
@@ -76,33 +85,37 @@ cmd_paste_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 			else
 				sepstr = "\r";
 		}
-		seplen = strlen(sepstr);
+		cmd_paste_buffer_filter(wp, pb->data, pb->size, sepstr);
-
-		if (bracket && (wp->screen->mode & MODE_BRACKETPASTE))
-			bufferevent_write(wp->event, "\033[200~", 6);
-
-		bufdata = paste_buffer_data(pb, &bufsize);
-		bufend = bufdata + bufsize;
-
-		for (;;) {
-			line = memchr(bufdata, '\n', bufend - bufdata);
-			if (line == NULL)
-				break;
-
-			bufferevent_write(wp->event, bufdata, line - bufdata);
-			bufferevent_write(wp->event, sepstr, seplen);
-
-			bufdata = line + 1;
-		}
-		if (bufdata != bufend)
-			bufferevent_write(wp->event, bufdata, bufend - bufdata);
-
-		if (bracket && (wp->screen->mode & MODE_BRACKETPASTE))
-			bufferevent_write(wp->event, "\033[201~", 6);
 	}
 
-	if (pb != NULL && args_has(args, 'd'))
+	/* Delete the buffer if -d. */
-		paste_free(pb);
+	if (args_has(args, 'd')) {
+		if (buffer == -1)
+			paste_free_top(&global_buffers);
+		else
+			paste_free_index(&global_buffers, buffer);
+	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
+}
+
+/* Add bytes to a buffer and filter '\n' according to separator. */
+void
+cmd_paste_buffer_filter(
+    struct window_pane *wp, const char *data, size_t size, 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, sep, seplen);
+		data = lf + 1;
+	}
+
+	if (end != data)
+		bufferevent_write(wp->event, data, end - data);
 }

cmd-pipe-pane.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -21,7 +21,6 @@
 
 #include <errno.h>
 #include <fcntl.h>
-#include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
@@ -32,33 +31,34 @@
  * Open pipe to redirect pane output. If already open, close first.
  */
 
-enum cmd_retval	 cmd_pipe_pane_exec(struct cmd *, struct cmd_q *);
+int	cmd_pipe_pane_exec(struct cmd *, struct cmd_ctx *);
 
 void	cmd_pipe_pane_error_callback(struct bufferevent *, short, void *);
 
 const struct cmd_entry cmd_pipe_pane_entry = {
 	"pipe-pane", "pipep",
 	"ot:", 0, 1,
-	"[-o] " CMD_TARGET_PANE_USAGE " [command]",
+	CMD_TARGET_PANE_USAGE "[-o] [command]",
 	0,
+	NULL,
+	NULL,
 	cmd_pipe_pane_exec
 };
 
-enum cmd_retval
+int
-cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_pipe_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
 	struct client		*c;
-	struct session		*s;
-	struct winlink		*wl;
 	struct window_pane	*wp;
-	char			*cmd;
+	char			*command;
 	int			 old_fd, pipe_fd[2], null_fd;
-	struct format_tree	*ft;
 
-	if ((wl = cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp)) == NULL)
+	if ((c = cmd_find_client(ctx, NULL)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
-	c = cmd_find_client(cmdq, NULL, 1);
+
+	if (cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp) == NULL)
+		return (-1);
 
 	/* Destroy the old pipe. */
 	old_fd = wp->pipe_fd;
@@ -70,7 +70,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 
 	/* If no pipe command, that is enough. */
 	if (args->argc == 0 || *args->argv[0] == '\0')
-		return (CMD_RETURN_NORMAL);
+		return (0);
 
 	/*
 	 * With -o, only open the new pipe if there was no previous one. This
@@ -79,27 +79,19 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	 *	bind ^p pipep -o 'cat >>~/output'
 	 */
 	if (args_has(self->args, 'o') && old_fd != -1)
-		return (CMD_RETURN_NORMAL);
+		return (0);
 
 	/* Open the new pipe. */
 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pipe_fd) != 0) {
-		cmdq_error(cmdq, "socketpair error: %s", strerror(errno));
+		ctx->error(ctx, "socketpair error: %s", strerror(errno));
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 
-	/* Expand the command. */
-	ft = format_create();
-	format_defaults(ft, c, s, wl, wp);
-	cmd = format_expand_time(ft, args->argv[0], time(NULL));
-	format_free(ft);
-
 	/* Fork the child. */
 	switch (fork()) {
 	case -1:
-		cmdq_error(cmdq, "fork error: %s", strerror(errno));
+		ctx->error(ctx, "fork error: %s", strerror(errno));
-
+		return (-1);
-		free(cmd);
-		return (CMD_RETURN_ERROR);
 	case 0:
 		/* Child process. */
 		close(pipe_fd[0]);
@@ -120,7 +112,9 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 
 		closefrom(STDERR_FILENO + 1);
 
-		execl(_PATH_BSHELL, "sh", "-c", cmd, (char *) NULL);
+		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. */
@@ -134,12 +128,11 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 		bufferevent_enable(wp->pipe_event, EV_WRITE);
 
 		setblocking(wp->pipe_fd, 0);
-
+		return (0);
-		free(cmd);
-		return (CMD_RETURN_NORMAL);
 	}
 }
 
+/* ARGSUSED */
 void
 cmd_pipe_pane_error_callback(
     unused struct bufferevent *bufev, unused short what, void *data)

cmd-queue.c

@@ -1,269 +0,0 @@
-/* $OpenBSD$ */
-
-/*
- * Copyright (c) 2013 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 <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#include "tmux.h"
-
-enum cmd_retval	cmdq_continue_one(struct cmd_q *);
-
-/* Create new command queue. */
-struct cmd_q *
-cmdq_new(struct client *c)
-{
-	struct cmd_q	*cmdq;
-
-	cmdq = xcalloc(1, sizeof *cmdq);
-	cmdq->references = 1;
-	cmdq->flags = 0;
-
-	cmdq->client = c;
-	cmdq->client_exit = -1;
-
-	TAILQ_INIT(&cmdq->queue);
-	cmdq->item = NULL;
-	cmdq->cmd = NULL;
-
-	return (cmdq);
-}
-
-/* Free command queue */
-int
-cmdq_free(struct cmd_q *cmdq)
-{
-	if (--cmdq->references != 0) {
-		if (cmdq->flags & CMD_Q_DEAD)
-			return (1);
-		return (0);
-	}
-
-	cmdq_flush(cmdq);
-	free(cmdq);
-	return (1);
-}
-
-/* Show message from command. */
-void
-cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
-{
-	struct client	*c = cmdq->client;
-	struct window	*w;
-	va_list		 ap;
-
-	va_start(ap, fmt);
-
-	if (c == NULL)
-		/* nothing */;
-	else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
-		evbuffer_add_vprintf(c->stdout_data, fmt, ap);
-
-		evbuffer_add(c->stdout_data, "\n", 1);
-		server_push_stdout(c);
-	} else {
-		w = c->session->curw->window;
-		if (w->active->mode != &window_copy_mode) {
-			window_pane_reset_mode(w->active);
-			window_pane_set_mode(w->active, &window_copy_mode);
-			window_copy_init_for_output(w->active);
-		}
-		window_copy_vadd(w->active, fmt, ap);
-	}
-
-	va_end(ap);
-}
-
-/* Show error from command. */
-void
-cmdq_error(struct cmd_q *cmdq, const char *fmt, ...)
-{
-	struct client	*c = cmdq->client;
-	struct cmd	*cmd = cmdq->cmd;
-	va_list		 ap;
-	char		*msg;
-	size_t		 msglen;
-
-	va_start(ap, fmt);
-	msglen = xvasprintf(&msg, fmt, ap);
-	va_end(ap);
-
-	if (c == NULL)
-		cfg_add_cause("%s:%u: %s", cmd->file, cmd->line, msg);
-	else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
-		evbuffer_add(c->stderr_data, msg, msglen);
-		evbuffer_add(c->stderr_data, "\n", 1);
-
-		server_push_stderr(c);
-		c->retval = 1;
-	} else {
-		*msg = toupper((u_char) *msg);
-		status_message_set(c, "%s", msg);
-	}
-
-	free(msg);
-}
-
-/* Print a guard line. */
-void
-cmdq_guard(struct cmd_q *cmdq, const char *guard, int flags)
-{
-	struct client	*c = cmdq->client;
-
-	if (c == NULL || !(c->flags & CLIENT_CONTROL))
-		return;
-
-	evbuffer_add_printf(c->stdout_data, "%%%s %ld %u %d\n", guard,
-	    (long) cmdq->time, cmdq->number, flags);
-	server_push_stdout(c);
-}
-
-/* Add command list to queue and begin processing if needed. */
-void
-cmdq_run(struct cmd_q *cmdq, struct cmd_list *cmdlist, struct mouse_event *m)
-{
-	cmdq_append(cmdq, cmdlist, m);
-
-	if (cmdq->item == NULL) {
-		cmdq->cmd = NULL;
-		cmdq_continue(cmdq);
-	}
-}
-
-/* Add command list to queue. */
-void
-cmdq_append(struct cmd_q *cmdq, struct cmd_list *cmdlist, struct mouse_event *m)
-{
-	struct cmd_q_item	*item;
-
-	item = xcalloc(1, sizeof *item);
-	item->cmdlist = cmdlist;
-	TAILQ_INSERT_TAIL(&cmdq->queue, item, qentry);
-	cmdlist->references++;
-
-	if (m != NULL)
-		memcpy(&item->mouse, m, sizeof item->mouse);
-	else
-		item->mouse.valid = 0;
-}
-
-/* Process one command. */
-enum cmd_retval
-cmdq_continue_one(struct cmd_q *cmdq)
-{
-	struct cmd	*cmd = cmdq->cmd;
-	enum cmd_retval	 retval;
-	char		 tmp[1024];
-	int		 flags = !!(cmd->flags & CMD_CONTROL);
-
-	cmd_print(cmd, tmp, sizeof tmp);
-	log_debug("cmdq %p: %s", cmdq, tmp);
-
-	cmdq->time = time(NULL);
-	cmdq->number++;
-
-	cmdq_guard(cmdq, "begin", flags);
-
-	retval = cmd->entry->exec(cmd, cmdq);
-
-	if (retval == CMD_RETURN_ERROR)
-		cmdq_guard(cmdq, "error", flags);
-	else
-		cmdq_guard(cmdq, "end", flags);
-	return (retval);
-}
-
-/* Continue processing command queue. Returns 1 if finishes empty. */
-int
-cmdq_continue(struct cmd_q *cmdq)
-{
-	struct client           *c = cmdq->client;
-	struct cmd_q_item	*next;
-	enum cmd_retval		 retval;
-	int			 empty;
-
-	cmdq->references++;
-	notify_disable();
-
-	log_debug("continuing cmdq %p: flags=%#x, client=%d", cmdq, cmdq->flags,
-	    c != NULL ? c->ibuf.fd : -1);
-
-	empty = TAILQ_EMPTY(&cmdq->queue);
-	if (empty)
-		goto empty;
-
-	if (cmdq->item == NULL) {
-		cmdq->item = TAILQ_FIRST(&cmdq->queue);
-		cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
-	} else
-		cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
-
-	do {
-		while (cmdq->cmd != NULL) {
-			retval = cmdq_continue_one(cmdq);
-			if (retval == CMD_RETURN_ERROR)
-				break;
-			if (retval == CMD_RETURN_WAIT)
-				goto out;
-			if (retval == CMD_RETURN_STOP) {
-				cmdq_flush(cmdq);
-				goto empty;
-			}
-			cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
-		}
-		next = TAILQ_NEXT(cmdq->item, qentry);
-
-		TAILQ_REMOVE(&cmdq->queue, cmdq->item, qentry);
-		cmd_list_free(cmdq->item->cmdlist);
-		free(cmdq->item);
-
-		cmdq->item = next;
-		if (cmdq->item != NULL)
-			cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
-	} while (cmdq->item != NULL);
-
-empty:
-	if (cmdq->client_exit > 0)
-		cmdq->client->flags |= CLIENT_EXIT;
-	if (cmdq->emptyfn != NULL)
-		cmdq->emptyfn(cmdq);
-	empty = 1;
-
-out:
-	notify_enable();
-	cmdq_free(cmdq);
-
-	return (empty);
-}
-
-/* Flush command queue. */
-void
-cmdq_flush(struct cmd_q *cmdq)
-{
-	struct cmd_q_item	*item, *item1;
-
-	TAILQ_FOREACH_SAFE(item, &cmdq->queue, qentry, item1) {
-		TAILQ_REMOVE(&cmdq->queue, item, qentry);
-		cmd_list_free(item->cmdlist);
-		free(item);
-	}
-	cmdq->item = NULL;
-}

cmd-refresh-client.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -24,54 +24,28 @@
  * Refresh client.
  */
 
-enum cmd_retval	 cmd_refresh_client_exec(struct cmd *, struct cmd_q *);
+int	cmd_refresh_client_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_refresh_client_entry = {
 	"refresh-client", "refresh",
-	"C:St:", 0, 0,
+	"t:", 0, 0,
-	"[-S] [-C size] " CMD_TARGET_CLIENT_USAGE,
+	CMD_TARGET_CLIENT_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_refresh_client_exec
 };
 
-enum cmd_retval
+int
-cmd_refresh_client_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_refresh_client_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args	*args = self->args;
 	struct client	*c;
-	const char	*size;
-	u_int		 w, h;
 
-	if ((c = cmd_find_client(cmdq, args_get(args, 't'), 0)) == NULL)
+	if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 
-	if (args_has(args, 'C')) {
+	server_redraw_client(c);
-		if ((size = args_get(args, 'C')) == NULL) {
-			cmdq_error(cmdq, "missing size");
-			return (CMD_RETURN_ERROR);
-		}
-		if (sscanf(size, "%u,%u", &w, &h) != 2) {
-			cmdq_error(cmdq, "bad size argument");
-			return (CMD_RETURN_ERROR);
-		}
-		if (w < PANE_MINIMUM || w > 5000 ||
-		    h < PANE_MINIMUM || h > 5000) {
-			cmdq_error(cmdq, "size too small or too big");
-			return (CMD_RETURN_ERROR);
-		}
-		if (!(c->flags & CLIENT_CONTROL)) {
-			cmdq_error(cmdq, "not a control client");
-			return (CMD_RETURN_ERROR);
-		}
-		if (tty_set_size(&c->tty, w, h))
-			recalculate_sizes();
-	} else if (args_has(args, 'S')) {
-		c->flags |= CLIENT_STATUSFORCE;
-		server_status_client(c);
-	} else {
-		c->flags |= CLIENT_STATUSFORCE;
-		server_redraw_client(c);
-	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-rename-session.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -26,18 +26,20 @@
  * Change session name.
  */
 
-enum cmd_retval	 cmd_rename_session_exec(struct cmd *, struct cmd_q *);
+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",
 	0,
+	NULL,
+	NULL,
 	cmd_rename_session_exec
 };
 
-enum cmd_retval
+int
-cmd_rename_session_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_rename_session_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args	*args = self->args;
 	struct session	*s;
@@ -45,24 +47,23 @@ cmd_rename_session_exec(struct cmd *self, struct cmd_q *cmdq)
 
 	newname = args->argv[0];
 	if (!session_check_name(newname)) {
-		cmdq_error(cmdq, "bad session name: %s", newname);
+		ctx->error(ctx, "bad session name: %s", newname);
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 	if (session_find(newname) != NULL) {
-		cmdq_error(cmdq, "duplicate session: %s", newname);
+		ctx->error(ctx, "duplicate session: %s", newname);
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 
-	if ((s = cmd_find_session(cmdq, args_get(args, 't'), 0)) == NULL)
+	if ((s = cmd_find_session(ctx, args_get(args, 't'), 0)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 
 	RB_REMOVE(sessions, &sessions, s);
-	free(s->name);
+	xfree(s->name);
 	s->name = xstrdup(newname);
 	RB_INSERT(sessions, &sessions, s);
 
 	server_status_session(s);
-	notify_session_renamed(s);
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-rename-window.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -26,30 +26,33 @@
  * Rename a window.
  */
 
-enum cmd_retval	 cmd_rename_window_exec(struct cmd *, struct cmd_q *);
+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",
 	0,
+	NULL,
+	NULL,
 	cmd_rename_window_exec
 };
 
-enum cmd_retval
+int
-cmd_rename_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_rename_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args	*args = self->args;
 	struct session	*s;
 	struct winlink	*wl;
 
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), &s)) == NULL)
+	if ((wl = cmd_find_window(ctx, args_get(args, 't'), &s)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 
-	window_set_name(wl->window, args->argv[0]);
+	xfree(wl->window->name);
+	wl->window->name = xstrdup(args->argv[0]);
 	options_set_number(&wl->window->options, "automatic-rename", 0);
 
 	server_status_window(wl->window);
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-resize-pane.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -26,89 +26,83 @@
  * Increase or decrease pane size.
  */
 
-enum cmd_retval	 cmd_resize_pane_exec(struct cmd *, struct cmd_q *);
+void	cmd_resize_pane_key_binding(struct cmd *, int);
-
+int	cmd_resize_pane_exec(struct cmd *, struct cmd_ctx *);
-void	cmd_resize_pane_mouse_update(struct client *, struct mouse_event *);
 
 const struct cmd_entry cmd_resize_pane_entry = {
 	"resize-pane", "resizep",
-	"DLMRt:Ux:y:Z", 0, 1,
+	"DLRt:U", 0, 1,
-	"[-DLMRUZ] [-x width] [-y height] " CMD_TARGET_PANE_USAGE
+	"[-DLRU] " CMD_TARGET_PANE_USAGE " [adjustment]",
-	" [adjustment]",
 	0,
+	cmd_resize_pane_key_binding,
+	NULL,
 	cmd_resize_pane_exec
 };
 
-enum cmd_retval
+void
-cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_resize_pane_key_binding(struct cmd *self, int key)
+{
+	switch (key) {
+	case KEYC_UP | KEYC_CTRL:
+		self->args = args_create(0);
+		args_set(self->args, 'U', NULL);
+		break;
+	case KEYC_DOWN | KEYC_CTRL:
+		self->args = args_create(0);
+		args_set(self->args, 'D', NULL);
+		break;
+	case KEYC_LEFT | KEYC_CTRL:
+		self->args = args_create(0);
+		args_set(self->args, 'L', NULL);
+		break;
+	case KEYC_RIGHT | KEYC_CTRL:
+		self->args = args_create(0);
+		args_set(self->args, 'R', NULL);
+		break;
+	case KEYC_UP | KEYC_ESCAPE:
+		self->args = args_create(1, "5");
+		args_set(self->args, 'U', NULL);
+		break;
+	case KEYC_DOWN | KEYC_ESCAPE:
+		self->args = args_create(1, "5");
+		args_set(self->args, 'D', NULL);
+		break;
+	case KEYC_LEFT | KEYC_ESCAPE:
+		self->args = args_create(1, "5");
+		args_set(self->args, 'L', NULL);
+		break;
+	case KEYC_RIGHT | KEYC_ESCAPE:
+		self->args = args_create(1, "5");
+		args_set(self->args, 'R', NULL);
+		break;
+	default:
+		self->args = args_create(0);
+		break;
+	}
+}
+
+int
+cmd_resize_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->client;
-	struct session		*s;
 	struct winlink		*wl;
-	struct window		*w;
 	const char	       	*errstr;
-	char			*cause;
 	struct window_pane	*wp;
 	u_int			 adjust;
-	int			 x, y;
 
-	if (args_has(args, 'M')) {
+	if ((wl = cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp)) == NULL)
-		if (cmd_mouse_window(&cmdq->item->mouse, &s) == NULL)
+		return (-1);
-			return (CMD_RETURN_NORMAL);
-		if (c == NULL || c->session != s)
-			return (CMD_RETURN_NORMAL);
-		c->tty.mouse_drag_update = cmd_resize_pane_mouse_update;
-		cmd_resize_pane_mouse_update(c, &cmdq->item->mouse);
-		return (CMD_RETURN_NORMAL);
-	}
-
-	if ((wl = cmd_find_pane(cmdq, args_get(args, 't'), NULL, &wp)) == NULL)
-		return (CMD_RETURN_ERROR);
-	w = wl->window;
-
-	if (args_has(args, 'Z')) {
-		if (w->flags & WINDOW_ZOOMED)
-			window_unzoom(w);
-		else
-			window_zoom(wp);
-		server_redraw_window(w);
-		server_status_window(w);
-		return (CMD_RETURN_NORMAL);
-	}
-	server_unzoom_window(w);
 
 	if (args->argc == 0)
 		adjust = 1;
 	else {
 		adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr);
 		if (errstr != NULL) {
-			cmdq_error(cmdq, "adjustment %s", errstr);
+			ctx->error(ctx, "adjustment %s", errstr);
-			return (CMD_RETURN_ERROR);
+			return (-1);
 		}
 	}
 
-	if (args_has(self->args, 'x')) {
-		x = args_strtonum(self->args, 'x', PANE_MINIMUM, INT_MAX,
-		    &cause);
-		if (cause != NULL) {
-			cmdq_error(cmdq, "width %s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-		layout_resize_pane_to(wp, LAYOUT_LEFTRIGHT, x);
-	}
-	if (args_has(self->args, 'y')) {
-		y = args_strtonum(self->args, 'y', PANE_MINIMUM, INT_MAX,
-		    &cause);
-		if (cause != NULL) {
-			cmdq_error(cmdq, "height %s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-		layout_resize_pane_to(wp, LAYOUT_TOPBOTTOM, y);
-	}
-
 	if (args_has(self->args, 'L'))
 		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, -adjust);
 	else if (args_has(self->args, 'R'))
@@ -119,52 +113,5 @@ cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, adjust);
 	server_redraw_window(wl->window);
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
-}
-
-void
-cmd_resize_pane_mouse_update(struct client *c, struct mouse_event *m)
-{
-	struct winlink		*wl;
-	struct window_pane	*wp;
-	int			 found;
-	u_int			 y, ly;
-
-	wl = cmd_mouse_window(m, NULL);
-	if (wl == NULL) {
-		c->tty.mouse_drag_update = NULL;
-		return;
-	}
-
-	y = m->y;
-	if (m->statusat == 0 && y > 0)
-		y--;
-	else if (m->statusat > 0 && y >= (u_int)m->statusat)
-		y = m->statusat - 1;
-	ly = m->ly;
-	if (m->statusat == 0 && ly > 0)
-		ly--;
-	else if (m->statusat > 0 && ly >= (u_int)m->statusat)
-		ly = m->statusat - 1;
-
-	found = 0;
-	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
-		if (!window_pane_visible(wp))
-			continue;
-
-		if (wp->xoff + wp->sx == m->lx &&
-		    wp->yoff <= 1 + ly && wp->yoff + wp->sy >= ly) {
-			layout_resize_pane(wp, LAYOUT_LEFTRIGHT, m->x - m->lx);
-			found = 1;
-		}
-		if (wp->yoff + wp->sy == ly &&
-		    wp->xoff <= 1 + m->lx && wp->xoff + wp->sx >= m->lx) {
-			layout_resize_pane(wp, LAYOUT_TOPBOTTOM, y - ly);
-			found = 1;
-		}
-	}
-	if (found)
-		server_redraw_window(wl->window);
-	else
-		c->tty.mouse_drag_update = NULL;
 }

cmd-respawn-pane.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -19,7 +19,6 @@
 
 #include <sys/types.h>
 
-#include <stdlib.h>
 #include <unistd.h>
 
 #include "tmux.h"
@@ -28,18 +27,20 @@
  * Respawn a pane (restart the command). Kill existing if -k given.
  */
 
-enum cmd_retval	 cmd_respawn_pane_exec(struct cmd *, struct cmd_q *);
+int	cmd_respawn_pane_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_respawn_pane_entry = {
 	"respawn-pane", "respawnp",
-	"kt:", 0, -1,
+	"kt:", 0, 1,
 	"[-k] " CMD_TARGET_PANE_USAGE " [command]",
 	0,
+	NULL,
+	NULL,
 	cmd_respawn_pane_exec
 };
 
-enum cmd_retval
+int
-cmd_respawn_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_respawn_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
 	struct winlink		*wl;
@@ -47,21 +48,17 @@ cmd_respawn_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	struct window_pane	*wp;
 	struct session		*s;
 	struct environ		 env;
-	const char		*path;
+	const char		*cmd;
-	char			*cause;
+	char		 	*cause;
-	u_int			 idx;
-	struct environ_entry	*envent;
 
-	if ((wl = cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp)) == NULL)
+	if ((wl = cmd_find_pane(ctx, args_get(args, 't'), &s, &wp)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	w = wl->window;
 
 	if (!args_has(self->args, 'k') && wp->fd != -1) {
-		if (window_pane_index(wp, &idx) != 0)
+		ctx->error(ctx, "pane still active: %s:%u.%u",
-			fatalx("index not found");
+		    s->name, wl->idx, window_pane_index(w, wp));
-		cmdq_error(cmdq, "pane still active: %s:%d.%u",
+		return (-1);
-		    s->name, wl->idx, idx);
-		return (CMD_RETURN_ERROR);
 	}
 
 	environ_init(&env);
@@ -73,24 +70,19 @@ cmd_respawn_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	screen_reinit(&wp->base);
 	input_init(wp);
 
-	path = NULL;
+	if (args->argc != 0)
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
+		cmd = args->argv[0];
-		envent = environ_find(&cmdq->client->environ, "PATH");
 	else
-		envent = environ_find(&s->environ, "PATH");
+		cmd = NULL;
-	if (envent != NULL)
+	if (window_pane_spawn(wp, cmd, NULL, NULL, &env, s->tio, &cause) != 0) {
-		path = envent->value;
+		ctx->error(ctx, "respawn pane failed: %s", cause);
-
+		xfree(cause);
-	if (window_pane_spawn(wp, args->argc, args->argv, path, NULL, -1, &env,
-	    s->tio, &cause) != 0) {
-		cmdq_error(cmdq, "respawn pane failed: %s", cause);
-		free(cause);
 		environ_free(&env);
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 	wp->flags |= PANE_REDRAW;
 	server_status_window(w);
 
 	environ_free(&env);
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-respawn-window.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,7 +18,6 @@
 
 #include <sys/types.h>
 
-#include <stdlib.h>
 #include <unistd.h>
 
 #include "tmux.h"
@@ -27,18 +26,20 @@
  * Respawn a window (restart the command). Kill existing if -k given.
  */
 
-enum cmd_retval	 cmd_respawn_window_exec(struct cmd *, struct cmd_q *);
+int	cmd_respawn_window_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_respawn_window_entry = {
 	"respawn-window", "respawnw",
-	"kt:", 0, -1,
+	"kt:", 0, 1,
 	"[-k] " CMD_TARGET_WINDOW_USAGE " [command]",
 	0,
+	NULL,
+	NULL,
 	cmd_respawn_window_exec
 };
 
-enum cmd_retval
+int
-cmd_respawn_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_respawn_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
 	struct winlink		*wl;
@@ -46,21 +47,20 @@ cmd_respawn_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	struct window_pane	*wp;
 	struct session		*s;
 	struct environ		 env;
-	const char		*path;
+	const char		*cmd;
 	char		 	*cause;
-	struct environ_entry	*envent;
 
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), &s)) == NULL)
+	if ((wl = cmd_find_window(ctx, args_get(args, 't'), &s)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	w = wl->window;
 
 	if (!args_has(self->args, 'k')) {
 		TAILQ_FOREACH(wp, &w->panes, entry) {
 			if (wp->fd == -1)
 				continue;
-			cmdq_error(cmdq,
+			ctx->error(ctx,
 			    "window still active: %s:%d", s->name, wl->idx);
-			return (CMD_RETURN_ERROR);
+			return (-1);
 		}
 	}
 
@@ -75,24 +75,18 @@ cmd_respawn_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	window_destroy_panes(w);
 	TAILQ_INSERT_HEAD(&w->panes, wp, entry);
 	window_pane_resize(wp, w->sx, w->sy);
-
+	if (args->argc != 0)
-	path = NULL;
+		cmd = args->argv[0];
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
-		envent = environ_find(&cmdq->client->environ, "PATH");
 	else
-		envent = environ_find(&s->environ, "PATH");
+		cmd = NULL;
-	if (envent != NULL)
+	if (window_pane_spawn(wp, cmd, NULL, NULL, &env, s->tio, &cause) != 0) {
-		path = envent->value;
+		ctx->error(ctx, "respawn window failed: %s", cause);
-
+		xfree(cause);
-	if (window_pane_spawn(wp, args->argc, args->argv, path, NULL, -1, &env,
-	    s->tio, &cause) != 0) {
-		cmdq_error(cmdq, "respawn window failed: %s", cause);
-		free(cause);
 		environ_free(&env);
 		server_destroy_pane(wp);
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
-	layout_init(w, wp);
+	layout_init(w);
 	window_pane_reset_mode(wp);
 	screen_reinit(&wp->base);
 	input_init(wp);
@@ -102,5 +96,5 @@ cmd_respawn_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	server_redraw_window(w);
 
 	environ_free(&env);
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-rotate-window.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -24,18 +24,29 @@
  * Rotate the panes in a window.
  */
 
-enum cmd_retval	 cmd_rotate_window_exec(struct cmd *, struct cmd_q *);
+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,
+	cmd_rotate_window_key_binding,
+	NULL,
 	cmd_rotate_window_exec
 };
 
-enum cmd_retval
+void
-cmd_rotate_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_rotate_window_key_binding(struct cmd *self, int key)
+{
+	self->args = args_create(0);
+	if (key == ('o' | KEYC_ESCAPE))
+		args_set(self->args, 'D', NULL);
+}
+
+int
+cmd_rotate_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
 	struct winlink		*wl;
@@ -44,8 +55,8 @@ cmd_rotate_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	struct layout_cell	*lc;
 	u_int			 sx, sy, xoff, yoff;
 
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), NULL)) == NULL)
+	if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	w = wl->window;
 
 	if (args_has(self->args, 'D')) {
@@ -104,5 +115,5 @@ cmd_rotate_window_exec(struct cmd *self, struct cmd_q *cmdq)
 		server_redraw_window(w);
 	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-run-shell.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -20,7 +20,6 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 
-#include <stdlib.h>
 #include <string.h>
 
 #include "tmux.h"
@@ -29,117 +28,66 @@
  * Runs a command without a window.
  */
 
-enum cmd_retval	 cmd_run_shell_exec(struct cmd *, struct cmd_q *);
+int	cmd_run_shell_exec(struct cmd *, struct cmd_ctx *);
 
 void	cmd_run_shell_callback(struct job *);
 void	cmd_run_shell_free(void *);
-void	cmd_run_shell_print(struct job *, const char *);
 
 const struct cmd_entry cmd_run_shell_entry = {
 	"run-shell", "run",
-	"bt:", 1, 1,
+	"", 1, 1,
-	"[-b] " CMD_TARGET_PANE_USAGE " shell-command",
+	"command",
 	0,
+	NULL,
+	NULL,
 	cmd_run_shell_exec
 };
 
 struct cmd_run_shell_data {
 	char		*cmd;
-	struct cmd_q	*cmdq;
+	struct cmd_ctx	 ctx;
-	int		 bflag;
-	int		 wp_id;
 };
 
-void
+int
-cmd_run_shell_print(struct job *job, const char *msg)
+cmd_run_shell_exec(struct cmd *self, struct cmd_ctx *ctx)
-{
-	struct cmd_run_shell_data	*cdata = job->data;
-	struct window_pane		*wp = NULL;
-
-	if (cdata->wp_id != -1)
-		wp = window_pane_find_by_id(cdata->wp_id);
-	if (wp == NULL) {
-		cmdq_print(cdata->cmdq, "%s", msg);
-		return;
-	}
-
-	if (window_pane_set_mode(wp, &window_copy_mode) == 0)
-		window_copy_init_for_output(wp);
-	if (wp->mode == &window_copy_mode)
-		window_copy_add(wp, "%s", msg);
-}
-
-enum cmd_retval
-cmd_run_shell_exec(struct cmd *self, struct cmd_q *cmdq)
 {
 	struct args			*args = self->args;
 	struct cmd_run_shell_data	*cdata;
-	char				*shellcmd;
+	const char			*shellcmd = args->argv[0];
-	struct client			*c;
-	struct session			*s = NULL;
-	struct winlink			*wl = NULL;
-	struct window_pane		*wp = NULL;
-	struct format_tree		*ft;
-	int				 cwd;
-
-	if (args_has(args, 't')) {
-		wl = cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp);
-		cwd = wp->cwd;
-	} else {
-		c = cmd_find_client(cmdq, NULL, 1);
-		if (c != NULL && c->session != NULL) {
-			s = c->session;
-			wl = s->curw;
-			wp = wl->window->active;
-		}
-		if (cmdq->client != NULL && cmdq->client->session == NULL)
-			cwd = cmdq->client->cwd;
-		else if (s != NULL)
-			cwd = s->cwd;
-		else
-			cwd = -1;
-	}
-
-	ft = format_create();
-	format_defaults(ft, NULL, s, wl, wp);
-	shellcmd = format_expand(ft, args->argv[0]);
-	format_free(ft);
 
 	cdata = xmalloc(sizeof *cdata);
-	cdata->cmd = shellcmd;
+	cdata->cmd = xstrdup(args->argv[0]);
-	cdata->bflag = args_has(args, 'b');
+	memcpy(&cdata->ctx, ctx, sizeof cdata->ctx);
-	cdata->wp_id = wp != NULL ? (int) wp->id : -1;
 
-	cdata->cmdq = cmdq;
+	if (ctx->cmdclient != NULL)
-	cmdq->references++;
+		ctx->cmdclient->references++;
+	if (ctx->curclient != NULL)
+		ctx->curclient->references++;
 
-	job_run(shellcmd, s, cwd, cmd_run_shell_callback, cmd_run_shell_free,
+	job_run(shellcmd, cmd_run_shell_callback, cmd_run_shell_free, cdata);
-	    cdata);
 
-	if (cdata->bflag)
+	return (1);	/* don't let client exit */
-		return (CMD_RETURN_NORMAL);
-	return (CMD_RETURN_WAIT);
 }
 
 void
 cmd_run_shell_callback(struct job *job)
 {
 	struct cmd_run_shell_data	*cdata = job->data;
-	struct cmd_q			*cmdq = cdata->cmdq;
+	struct cmd_ctx			*ctx = &cdata->ctx;
 	char				*cmd, *msg, *line;
 	size_t				 size;
 	int				 retcode;
 	u_int				 lines;
 
-	if (cmdq->flags & CMD_Q_DEAD)
+	if (ctx->cmdclient != NULL && ctx->cmdclient->flags & CLIENT_DEAD)
+		return;
+	if (ctx->curclient != NULL && ctx->curclient->flags & CLIENT_DEAD)
 		return;
-	cmd = cdata->cmd;
 
 	lines = 0;
 	do {
 		if ((line = evbuffer_readline(job->event->input)) != NULL) {
-			cmd_run_shell_print(job, line);
+			ctx->print(ctx, "%s", line);
-			free(line);
 			lines++;
 		}
 	} while (line != NULL);
@@ -150,12 +98,14 @@ cmd_run_shell_callback(struct job *job)
 		memcpy(line, EVBUFFER_DATA(job->event->input), size);
 		line[size] = '\0';
 
-		cmd_run_shell_print(job, line);
+		ctx->print(ctx, "%s", line);
 		lines++;
 
-		free(line);
+		xfree(line);
 	}
 
+	cmd = cdata->cmd;
+
 	msg = NULL;
 	if (WIFEXITED(job->status)) {
 		if ((retcode = WEXITSTATUS(job->status)) != 0)
@@ -164,20 +114,28 @@ cmd_run_shell_callback(struct job *job)
 		retcode = WTERMSIG(job->status);
 		xasprintf(&msg, "'%s' terminated by signal %d", cmd, retcode);
 	}
-	if (msg != NULL)
+	if (msg != NULL) {
-		cmd_run_shell_print(job, msg);
+		if (lines != 0)
-	free(msg);
+			ctx->print(ctx, "%s", msg);
+		else
+			ctx->info(ctx, "%s", msg);
+		xfree(msg);
+	}
 }
 
 void
 cmd_run_shell_free(void *data)
 {
 	struct cmd_run_shell_data	*cdata = data;
-	struct cmd_q			*cmdq = cdata->cmdq;
+	struct cmd_ctx			*ctx = &cdata->ctx;
 
-	if (!cmdq_free(cmdq) && !cdata->bflag)
+	if (ctx->cmdclient != NULL) {
-		cmdq_continue(cmdq);
+		ctx->cmdclient->references--;
+		ctx->cmdclient->flags |= CLIENT_EXIT;
+	}
+	if (ctx->curclient != NULL)
+		ctx->curclient->references--;
 
-	free(cdata->cmd);
+	xfree(cdata->cmd);
-	free(cdata);
+	xfree(cdata);
 }

cmd-save-buffer.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -20,139 +20,83 @@
 #include <sys/stat.h>
 
 #include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
 
 #include "tmux.h"
 
 /*
- * Saves a paste buffer to a file.
+ * Saves a session paste buffer to a file.
  */
 
-enum cmd_retval	 cmd_save_buffer_exec(struct cmd *, struct cmd_q *);
+int	cmd_save_buffer_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_save_buffer_entry = {
 	"save-buffer", "saveb",
 	"ab:", 1, 1,
-	"[-a] " CMD_BUFFER_USAGE " path",
+	"[-a] " CMD_BUFFER_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_save_buffer_exec
 };
 
-const struct cmd_entry cmd_show_buffer_entry = {
+int
-	"show-buffer", "showb",
+cmd_save_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
-	"b:", 0, 0,
-	CMD_BUFFER_USAGE,
-	0,
-	cmd_save_buffer_exec
-};
-
-enum cmd_retval
-cmd_save_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->client;
+	struct client		*c = ctx->cmdclient;
-	struct session          *s;
 	struct paste_buffer	*pb;
-	const char		*path, *bufname, *bufdata, *start, *end;
+	const char		*path;
-	char			*msg;
+	char			*cause;
-	size_t			 size, used, msglen, bufsize;
+	int			 buffer;
-	int			 cwd, fd;
+	mode_t			 mask;
 	FILE			*f;
 
 	if (!args_has(args, 'b')) {
-		if ((pb = paste_get_top(NULL)) == NULL) {
+		if ((pb = paste_get_top(&global_buffers)) == NULL) {
-			cmdq_error(cmdq, "no buffers");
+			ctx->error(ctx, "no buffers");
-			return (CMD_RETURN_ERROR);
+			return (-1);
 		}
 	} else {
-		bufname = args_get(args, 'b');
+		buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
-		pb = paste_get_name(bufname);
+		if (cause != NULL) {
+			ctx->error(ctx, "buffer %s", cause);
+			xfree(cause);
+			return (-1);
+		}
+
+		pb = paste_get_index(&global_buffers, buffer);
 		if (pb == NULL) {
-			cmdq_error(cmdq, "no buffer %s", bufname);
+			ctx->error(ctx, "no buffer %d", buffer);
-			return (CMD_RETURN_ERROR);
+			return (-1);
 		}
 	}
-	bufdata = paste_buffer_data(pb, &bufsize);
 
-	if (self->entry == &cmd_show_buffer_entry)
+	path = args->argv[0];
-		path = "-";
-	else
-		path = args->argv[0];
 	if (strcmp(path, "-") == 0) {
 		if (c == NULL) {
-			cmdq_error(cmdq, "can't write to stdout");
+			ctx->error(ctx, "%s: can't write to stdout", path);
-			return (CMD_RETURN_ERROR);
+			return (-1);
 		}
-		if (c->session == NULL || (c->flags & CLIENT_CONTROL))
+		bufferevent_write(c->stdout_event, pb->data, pb->size);
-			goto do_stdout;
-		goto do_print;
-	}
-
-	if (c != NULL && c->session == NULL)
-		cwd = c->cwd;
-	else if ((s = cmd_find_current(cmdq)) != NULL)
-		cwd = s->cwd;
-	else
-		cwd = AT_FDCWD;
-
-	f = NULL;
-	if (args_has(self->args, 'a')) {
-		fd = openat(cwd, path, O_CREAT|O_RDWR|O_APPEND, 0600);
-		if (fd != -1)
-			f = fdopen(fd, "ab");
 	} else {
-		fd = openat(cwd, path, O_CREAT|O_RDWR|O_TRUNC, 0600);
+		mask = umask(S_IRWXG | S_IRWXO);
-		if (fd != -1)
+		if (args_has(self->args, 'a'))
-			f = fdopen(fd, "wb");
+			f = fopen(path, "ab");
-	}
-	if (f == NULL) {
-		if (fd != -1)
-			close(fd);
-		cmdq_error(cmdq, "%s: %s", path, strerror(errno));
-		return (CMD_RETURN_ERROR);
-	}
-	if (fwrite(bufdata, 1, bufsize, f) != bufsize) {
-		cmdq_error(cmdq, "%s: fwrite error", path);
-		fclose(f);
-		return (CMD_RETURN_ERROR);
-	}
-	fclose(f);
-
-	return (CMD_RETURN_NORMAL);
-
-do_stdout:
-	evbuffer_add(c->stdout_data, bufdata, bufsize);
-	server_push_stdout(c);
-	return (CMD_RETURN_NORMAL);
-
-do_print:
-	if (bufsize > (INT_MAX / 4) - 1) {
-		cmdq_error(cmdq, "buffer too big");
-		return (CMD_RETURN_ERROR);
-	}
-	msg = NULL;
-
-	used = 0;
-	while (used != bufsize) {
-		start = bufdata + used;
-		end = memchr(start, '\n', bufsize - used);
-		if (end != NULL)
-			size = end - start;
 		else
-			size = bufsize - used;
+			f = fopen(path, "wb");
-
+		umask(mask);
-		msglen = size * 4 + 1;
+		if (f == NULL) {
-		msg = xrealloc(msg, msglen);
+			ctx->error(ctx, "%s: %s", path, strerror(errno));
-
+			return (-1);
-		strvisx(msg, start, size, VIS_OCTAL|VIS_TAB);
+		}
-		cmdq_print(cmdq, "%s", msg);
+		if (fwrite(pb->data, 1, pb->size, f) != pb->size) {
-
+			ctx->error(ctx, "%s: fwrite error", path);
-		used += size + (end != NULL);
+			fclose(f);
+			return (-1);
+		}
+		fclose(f);
 	}
 
-	free(msg);
+	return (0);
-	return (CMD_RETURN_NORMAL);
 }

cmd-select-layout.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,21 +18,22 @@
 
 #include <sys/types.h>
 
-#include <stdlib.h>
-
 #include "tmux.h"
 
 /*
  * Switch window to selected layout.
  */
 
-enum cmd_retval	 cmd_select_layout_exec(struct cmd *, struct cmd_q *);
+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",
-	"nopt:", 0, 1,
+	"npt:", 0, 1,
-	"[-nop] " CMD_TARGET_WINDOW_USAGE " [layout-name]",
+	"[-np] " CMD_TARGET_WINDOW_USAGE " [layout-name]",
 	0,
+	cmd_select_layout_key_binding,
+	NULL,
 	cmd_select_layout_exec
 };
 
@@ -41,6 +42,8 @@ const struct cmd_entry cmd_next_layout_entry = {
 	"t:", 0, 0,
 	CMD_TARGET_WINDOW_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_select_layout_exec
 };
 
@@ -49,79 +52,82 @@ const struct cmd_entry cmd_previous_layout_entry = {
 	"t:", 0, 0,
 	CMD_TARGET_WINDOW_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_select_layout_exec
 };
 
-enum cmd_retval
+void
-cmd_select_layout_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_select_layout_key_binding(struct cmd *self, int key)
+{
+	switch (key) {
+	case '1' | KEYC_ESCAPE:
+		self->args = args_create(1, "even-horizontal");
+		break;
+	case '2' | KEYC_ESCAPE:
+		self->args = args_create(1, "even-vertical");
+		break;
+	case '3' | KEYC_ESCAPE:
+		self->args = args_create(1, "main-horizontal");
+		break;
+	case '4' | KEYC_ESCAPE:
+		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;
+	}
+}
+
+int
+cmd_select_layout_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args	*args = self->args;
 	struct winlink	*wl;
-	struct window	*w;
 	const char	*layoutname;
-	char		*oldlayout;
 	int		 next, previous, layout;
 
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), NULL)) == NULL)
+	if ((wl = cmd_find_window(ctx, args_get(args, 't'), NULL)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
-	w = wl->window;
-
-	server_unzoom_window(w);
 
 	next = self->entry == &cmd_next_layout_entry;
-	if (args_has(args, 'n'))
+	if (args_has(self->args, 'n'))
 		next = 1;
 	previous = self->entry == &cmd_previous_layout_entry;
-	if (args_has(args, 'p'))
+	if (args_has(self->args, 'p'))
 		previous = 1;
 
-	oldlayout = w->old_layout;
-	w->old_layout = layout_dump(w->layout_root);
-
 	if (next || previous) {
 		if (next)
-			layout_set_next(w);
+			layout = layout_set_next(wl->window);
 		else
-			layout_set_previous(w);
+			layout = layout_set_previous(wl->window);
-		goto changed;
+		ctx->info(ctx, "arranging in: %s", layout_set_name(layout));
+		return (0);
 	}
 
-	if (!args_has(args, 'o')) {
+	if (args->argc == 0)
-		if (args->argc == 0)
+		layout = wl->window->lastlayout;
-			layout = w->lastlayout;
-		else
-			layout = layout_set_lookup(args->argv[0]);
-		if (layout != -1) {
-			layout_set_select(w, layout);
-			goto changed;
-		}
-	}
-
-	if (args->argc != 0)
-		layoutname = args->argv[0];
-	else if (args_has(args, 'o'))
-		layoutname = oldlayout;
 	else
-		layoutname = NULL;
+		layout = layout_set_lookup(args->argv[0]);
-
+	if (layout != -1) {
-	if (layoutname != NULL) {
+		layout = layout_set_select(wl->window, layout);
-		if (layout_parse(w, layoutname) == -1) {
+		ctx->info(ctx, "arranging in: %s", layout_set_name(layout));
-			cmdq_error(cmdq, "can't set layout: %s", layoutname);
+		return (0);
-			goto error;
-		}
-		goto changed;
 	}
 
-	free(oldlayout);
+	if (args->argc != 0) {
-	return (CMD_RETURN_NORMAL);
+		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);
+	}
 
-changed:
+	return (0);
-	free(oldlayout);
-	server_redraw_window(w);
-	return (CMD_RETURN_NORMAL);
-
-error:
-	free(w->old_layout);
-	w->old_layout = oldlayout;
-	return (CMD_RETURN_ERROR);
 }

cmd-select-pane.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -24,100 +24,75 @@
  * Select pane.
  */
 
-enum cmd_retval	 cmd_select_pane_exec(struct cmd *, struct cmd_q *);
+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",
-	"DdegLlMmP:Rt:U", 0, 0,
+	"lDLRt:U", 0, 0,
-	"[-DdegLlMmRU] [-P style] " CMD_TARGET_PANE_USAGE,
+	"[-lDLRU] " CMD_TARGET_PANE_USAGE,
 	0,
+	cmd_select_pane_key_binding,
+	NULL,
 	cmd_select_pane_exec
 };
 
 const struct cmd_entry cmd_last_pane_entry = {
 	"last-pane", "lastp",
-	"det:", 0, 0,
+	"t:", 0, 0,
-	"[-de] " CMD_TARGET_WINDOW_USAGE,
+	CMD_TARGET_WINDOW_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_select_pane_exec
 };
 
-enum cmd_retval
+void
-cmd_select_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+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 args		*args = self->args;
 	struct winlink		*wl;
-	struct window		*w;
+	struct window_pane	*wp;
-	struct session		*s;
-	struct window_pane	*wp, *lastwp, *markedwp;
-	const char		*style;
 
 	if (self->entry == &cmd_last_pane_entry || args_has(args, 'l')) {
-		wl = cmd_find_window(cmdq, args_get(args, 't'), NULL);
+		wl = cmd_find_window(ctx, args_get(args, 't'), NULL);
 		if (wl == NULL)
-			return (CMD_RETURN_ERROR);
+			return (-1);
-		w = wl->window;
 
-		if (w->last == NULL) {
+		if (wl->window->last == NULL) {
-			cmdq_error(cmdq, "no last pane");
+			ctx->error(ctx, "no last pane");
-			return (CMD_RETURN_ERROR);
+			return (-1);
 		}
 
-		if (args_has(self->args, 'e'))
+		window_set_active_pane(wl->window, wl->window->last);
-			w->last->flags &= ~PANE_INPUTOFF;
+		server_status_window(wl->window);
-		else if (args_has(self->args, 'd'))
+		server_redraw_window_borders(wl->window);
-			w->last->flags |= PANE_INPUTOFF;
-		else {
-			server_unzoom_window(w);
-			window_redraw_active_switch(w, w->last);
-			if (window_set_active_pane(w, w->last)) {
-				server_status_window(w);
-				server_redraw_window_borders(w);
-			}
-		}
 
-		return (CMD_RETURN_NORMAL);
+		return (0);
 	}
 
-	if ((wl = cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp)) == NULL)
+	if ((wl = cmd_find_pane(ctx, args_get(args, 't'), NULL, &wp)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
-	w = wl->window;
 
-	if (args_has(args, 'm') || args_has(args, 'M')) {
+	if (!window_pane_visible(wp)) {
-		if (args_has(args, 'm') && !window_pane_visible(wp))
+		ctx->error(ctx, "pane not visible");
-			return (CMD_RETURN_NORMAL);
+		return (-1);
-		lastwp = marked_window_pane;
-
-		if (args_has(args, 'M') || server_is_marked(s, wl, wp))
-			server_clear_marked();
-		else
-			server_set_marked(s, wl, wp);
-		markedwp = marked_window_pane;
-
-		if (lastwp != NULL) {
-			server_redraw_window_borders(lastwp->window);
-			server_status_window(lastwp->window);
-		}
-		if (markedwp != NULL) {
-			server_redraw_window_borders(markedwp->window);
-			server_status_window(markedwp->window);
-		}
-		return (CMD_RETURN_NORMAL);
-	}
-
-	if (args_has(self->args, 'P') || args_has(self->args, 'g')) {
-		if (args_has(args, 'P')) {
-			style = args_get(args, 'P');
-			if (style_parse(&grid_default_cell, &wp->colgc,
-			    style) == -1) {
-				cmdq_error(cmdq, "bad style: %s", style);
-				return (CMD_RETURN_ERROR);
-			}
-			wp->flags |= PANE_REDRAW;
-		}
-		if (args_has(self->args, 'g'))
-			cmdq_print(cmdq, "%s", style_tostring(&wp->colgc));
-		return (CMD_RETURN_NORMAL);
 	}
 
 	if (args_has(self->args, 'L'))
@@ -128,30 +103,14 @@ cmd_select_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 		wp = window_pane_find_up(wp);
 	else if (args_has(self->args, 'D'))
 		wp = window_pane_find_down(wp);
-	if (wp == NULL)
+	if (wp == NULL) {
-		return (CMD_RETURN_NORMAL);
+		ctx->error(ctx, "pane not found");
-
+		return (-1);
-	if (args_has(self->args, 'e')) {
-		wp->flags &= ~PANE_INPUTOFF;
-		return (CMD_RETURN_NORMAL);
-	}
-	if (args_has(self->args, 'd')) {
-		wp->flags |= PANE_INPUTOFF;
-		return (CMD_RETURN_NORMAL);
 	}
 
-	if (wp == w->active)
+	window_set_active_pane(wl->window, wp);
-		return (CMD_RETURN_NORMAL);
+	server_status_window(wl->window);
-	server_unzoom_window(wp->window);
+	server_redraw_window_borders(wl->window);
-	if (!window_pane_visible(wp)) {
-		cmdq_error(cmdq, "pane not visible");
-		return (CMD_RETURN_ERROR);
-	}
-	window_redraw_active_switch(w, wp);
-	if (window_set_active_pane(w, wp)) {
-		server_status_window(w);
-		server_redraw_window_borders(w);
-	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-select-window.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -26,13 +26,16 @@
  * Select window by index.
  */
 
-enum cmd_retval	 cmd_select_window_exec(struct cmd *, struct cmd_q *);
+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",
-	"lnpTt:", 0, 0,
+	"lnpt:", 0, 0,
-	"[-lnpT] " CMD_TARGET_WINDOW_USAGE,
+	"[-lnp] " CMD_TARGET_WINDOW_USAGE,
 	0,
+	cmd_select_window_key_binding,
+	NULL,
 	cmd_select_window_exec
 };
 
@@ -41,6 +44,8 @@ const struct cmd_entry cmd_next_window_entry = {
 	"at:", 0, 0,
 	"[-a] " CMD_TARGET_SESSION_USAGE,
 	0,
+	cmd_select_window_key_binding,
+	NULL,
 	cmd_select_window_exec
 };
 
@@ -49,6 +54,8 @@ const struct cmd_entry cmd_previous_window_entry = {
 	"at:", 0, 0,
 	"[-a] " CMD_TARGET_SESSION_USAGE,
 	0,
+	cmd_select_window_key_binding,
+	NULL,
 	cmd_select_window_exec
 };
 
@@ -57,11 +64,27 @@ const struct cmd_entry cmd_last_window_entry = {
 	"t:", 0, 0,
 	CMD_TARGET_SESSION_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_select_window_exec
 };
 
-enum cmd_retval
+void
-cmd_select_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_select_window_key_binding(struct cmd *self, int key)
+{
+	char	tmp[16];
+
+	self->args = args_create(0);
+	if (key >= '0' && key <= '9') {
+		xsnprintf(tmp, sizeof tmp, ":%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 args	*args = self->args;
 	struct winlink	*wl;
@@ -79,48 +102,38 @@ cmd_select_window_exec(struct cmd *self, struct cmd_q *cmdq)
 		last = 1;
 
 	if (next || previous || last) {
-		s = cmd_find_session(cmdq, args_get(args, 't'), 0);
+		s = cmd_find_session(ctx, args_get(args, 't'), 0);
 		if (s == NULL)
-			return (CMD_RETURN_ERROR);
+			return (-1);
 
 		activity = args_has(self->args, 'a');
 		if (next) {
 			if (session_next(s, activity) != 0) {
-				cmdq_error(cmdq, "no next window");
+				ctx->error(ctx, "no next window");
-				return (CMD_RETURN_ERROR);
+				return (-1);
 			}
 		} else if (previous) {
 			if (session_previous(s, activity) != 0) {
-				cmdq_error(cmdq, "no previous window");
+				ctx->error(ctx, "no previous window");
-				return (CMD_RETURN_ERROR);
+				return (-1);
 			}
 		} else {
 			if (session_last(s) != 0) {
-				cmdq_error(cmdq, "no last window");
+				ctx->error(ctx, "no last window");
-				return (CMD_RETURN_ERROR);
+				return (-1);
 			}
 		}
 
 		server_redraw_session(s);
 	} else {
-		wl = cmd_find_window(cmdq, args_get(args, 't'), &s);
+		wl = cmd_find_window(ctx, args_get(args, 't'), &s);
 		if (wl == NULL)
-			return (CMD_RETURN_ERROR);
+			return (-1);
 
-		/*
+		if (session_select(s, wl->idx) == 0)
-		 * If -T and select-window is invoked on same window as
-		 * current, switch to previous window.
-		 */
-		if (args_has(self->args, 'T') && wl == s->curw) {
-			if (session_last(s) != 0) {
-				cmdq_error(cmdq, "no last window");
-				return (-1);
-			}
-			server_redraw_session(s);
-		} else if (session_select(s, wl->idx) == 0)
 			server_redraw_session(s);
 	}
 	recalculate_sizes();
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-send-keys.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -19,7 +19,6 @@
 #include <sys/types.h>
 
 #include <stdlib.h>
-#include <string.h>
 
 #include "tmux.h"
 
@@ -27,70 +26,40 @@
  * Send keys to client.
  */
 
-enum cmd_retval	 cmd_send_keys_exec(struct cmd *, struct cmd_q *);
+int	cmd_send_keys_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_send_keys_entry = {
 	"send-keys", "send",
-	"lRMt:", 0, -1,
+	"t:", 0, -1,
-	"[-lRM] " CMD_TARGET_PANE_USAGE " key ...",
+	"[-t target-pane] key ...",
 	0,
+	NULL,
+	NULL,
 	cmd_send_keys_exec
 };
 
-const struct cmd_entry cmd_send_prefix_entry = {
+int
-	"send-prefix", NULL,
+cmd_send_keys_exec(struct cmd *self, struct cmd_ctx *ctx)
-	"2t:", 0, 0,
-	"[-2] " CMD_TARGET_PANE_USAGE,
-	0,
-	cmd_send_keys_exec
-};
-
-enum cmd_retval
-cmd_send_keys_exec(struct cmd *self, struct cmd_q *cmdq)
 {
 	struct args		*args = self->args;
-	struct mouse_event	*m = &cmdq->item->mouse;
 	struct window_pane	*wp;
 	struct session		*s;
-	const u_char		*str;
+	const char		*str;
 	int			 i, key;
 
-	if (args_has(args, 'M')) {
+	if (cmd_find_pane(ctx, args_get(args, 't'), &s, &wp) == NULL)
-		wp = cmd_mouse_pane(m, &s, NULL);
+		return (-1);
-		if (wp == NULL) {
-			cmdq_error(cmdq, "no mouse target");
-			return (CMD_RETURN_ERROR);
-		}
-		window_pane_key(wp, NULL, s, m->key, m);
-		return (CMD_RETURN_NORMAL);
-	}
-
-	if (cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp) == NULL)
-		return (CMD_RETURN_ERROR);
-
-	if (self->entry == &cmd_send_prefix_entry) {
-		if (args_has(args, '2'))
-			key = options_get_number(&s->options, "prefix2");
-		else
-			key = options_get_number(&s->options, "prefix");
-		window_pane_key(wp, NULL, s, key, NULL);
-		return (CMD_RETURN_NORMAL);
-	}
-
-	if (args_has(args, 'R'))
-		input_reset(wp);
 
 	for (i = 0; i < args->argc; i++) {
 		str = args->argv[i];
 
-		if (!args_has(args, 'l') &&
+		if ((key = key_string_lookup_string(str)) != KEYC_NONE) {
-		    (key = key_string_lookup_string(str)) != KEYC_NONE) {
+			    window_pane_key(wp, s, key);
-			window_pane_key(wp, NULL, s, key, NULL);
 		} else {
 			for (; *str != '\0'; str++)
-				window_pane_key(wp, NULL, s, *str, NULL);
+			    window_pane_key(wp, s, *str);
 		}
 	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-send-prefix.c

@@ -0,0 +1,54 @@
+/* $Id$ */
+
+/*
+ * 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"
+
+/*
+ * Send prefix key as a key.
+ */
+
+int	cmd_send_prefix_exec(struct cmd *, struct cmd_ctx *);
+
+const struct cmd_entry cmd_send_prefix_entry = {
+	"send-prefix", NULL,
+	"t:", 0, 0,
+	CMD_TARGET_PANE_USAGE,
+	0,
+	NULL,
+	NULL,
+	cmd_send_prefix_exec
+};
+
+int
+cmd_send_prefix_exec(struct cmd *self, struct cmd_ctx *ctx)
+{
+	struct args		*args = self->args;
+	struct session		*s;
+	struct window_pane	*wp;
+	struct keylist		*keylist;
+
+	if (cmd_find_pane(ctx, args_get(args, 't'), &s, &wp) == NULL)
+		return (-1);
+
+	keylist = options_get_data(&s->options, "prefix");
+	window_pane_key(wp, s, ARRAY_FIRST(keylist));
+
+	return (0);
+}

cmd-server-info.c

@@ -0,0 +1,183 @@
+/* $Id$ */
+
+/*
+ * 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 <sys/utsname.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "tmux.h"
+
+/*
+ * Show various information about server.
+ */
+
+int	cmd_server_info_exec(struct cmd *, struct cmd_ctx *);
+
+const struct cmd_entry cmd_server_info_entry = {
+	"server-info", "info",
+	"", 0, 0,
+	"",
+	0,
+	NULL,
+	NULL,
+	cmd_server_info_exec
+};
+
+/* ARGSUSED */
+int
+cmd_server_info_exec(unused struct cmd *self, struct cmd_ctx *ctx)
+{
+	struct tty_term				*term;
+	struct client				*c;
+	struct session				*s;
+	struct winlink				*wl;
+	struct window				*w;
+	struct window_pane			*wp;
+	struct tty_code				*code;
+	const struct tty_term_code_entry	*ent;
+	struct utsname				 un;
+	struct job				*job;
+	struct grid				*gd;
+	struct grid_line			*gl;
+	u_int		 			 i, j, k;
+	char					 out[80];
+	char					*tim;
+	time_t		 			 t;
+	u_int					 lines, ulines;
+	size_t					 size, usize;
+
+	tim = ctime(&start_time);
+	*strchr(tim, '\n') = '\0';
+	ctx->print(ctx,
+	    "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) {
+		ctx->print(ctx, "system is %s %s %s %s",
+		    un.sysname, un.release, un.version, un.machine);
+	}
+	if (cfg_file != NULL)
+		ctx->print(ctx, "configuration file is %s", cfg_file);
+	else
+		ctx->print(ctx, "configuration file not specified");
+	ctx->print(ctx, "protocol version is %d", PROTOCOL_VERSION);
+	ctx->print(ctx, "%s", "");
+
+	ctx->print(ctx, "Clients:");
+	for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
+		c = ARRAY_ITEM(&clients, i);
+		if (c == NULL || c->session == NULL)
+			continue;
+
+		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->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));
+	RB_FOREACH(s, sessions, &sessions) {
+		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]", s->idx, s->name,
+		    winlink_count(&s->windows), tim, s->sx, s->sy, s->flags);
+		RB_FOREACH(wl, winlinks, &s->windows) {
+			w = wl->window;
+			ctx->print(ctx, "%4u: %s [%ux%u] [flags=0x%x, "
+			    "references=%u, last layout=%d]", wl->idx, w->name,
+			    w->sx, w->sy, w->flags, w->references,
+			    w->lastlayout);
+			j = 0;
+			TAILQ_FOREACH(wp, &w->panes, entry) {
+				lines = ulines = size = usize = 0;
+				gd = wp->base.grid;
+				for (k = 0; k < gd->hsize + gd->sy; k++) {
+					gl = &gd->linedata[k];
+					if (gl->celldata != NULL) {
+						lines++;
+						size += gl->cellsize *
+						    sizeof *gl->celldata;
+					}
+					if (gl->utf8data != NULL) {
+						ulines++;
+						usize += gl->utf8size *
+						    sizeof *gl->utf8data;
+					}
+				}
+				ctx->print(ctx, "%6u: %s %lu %d %u/%u, %zu "
+				    "bytes; UTF-8 %u/%u, %zu bytes", j,
+				    wp->tty, (u_long) wp->pid, wp->fd, lines,
+				    gd->hsize + gd->sy, size, ulines,
+				    gd->hsize + gd->sy, usize);
+				j++;
+			}
+		}
+	}
+	ctx->print(ctx, "%s", "");
+
+	ctx->print(ctx, "Terminals:");
+	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++) {
+			ent = &tty_term_codes[i];
+			code = &term->codes[ent->code];
+			switch (code->type) {
+			case TTYCODE_NONE:
+				ctx->print(ctx, "%2u: %s: [missing]",
+				    ent->code, ent->name);
+				break;
+			case TTYCODE_STRING:
+				strnvis(out, code->value.string, sizeof out,
+				    VIS_OCTAL|VIS_TAB|VIS_NL);
+				ctx->print(ctx, "%2u: %s: (string) %s",
+				    ent->code, ent->name, out);
+				break;
+			case TTYCODE_NUMBER:
+				ctx->print(ctx, "%2u: %s: (number) %d",
+				    ent->code, ent->name, code->value.number);
+				break;
+			case TTYCODE_FLAG:
+				ctx->print(ctx, "%2u: %s: (flag) %s",
+				    ent->code, ent->name,
+				    code->value.flag ? "true" : "false");
+				break;
+			}
+		}
+	}
+	ctx->print(ctx, "%s", "");
+
+	ctx->print(ctx, "Jobs:");
+	LIST_FOREACH(job, &all_jobs, lentry) {
+		ctx->print(ctx, "%s [fd=%d, pid=%d, status=%d]",
+		    job->cmd, job->fd, job->pid, job->status);
+	}
+
+	return (0);
+}

cmd-set-buffer.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,100 +18,58 @@
 
 #include <sys/types.h>
 
-#include <stdlib.h>
 #include <string.h>
 
 #include "tmux.h"
 
 /*
- * Add, set, append to or delete a paste buffer.
+ * Add or set a session paste buffer.
  */
 
-enum cmd_retval	 cmd_set_buffer_exec(struct cmd *, struct cmd_q *);
+int	cmd_set_buffer_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_set_buffer_entry = {
 	"set-buffer", "setb",
-	"ab:n:", 0, 1,
+	"b:", 1, 1,
-	"[-a] " CMD_BUFFER_USAGE " [-n new-buffer-name] data",
+	CMD_BUFFER_USAGE " data",
 	0,
+	NULL,
+	NULL,
 	cmd_set_buffer_exec
 };
 
-const struct cmd_entry cmd_delete_buffer_entry = {
+int
-	"delete-buffer", "deleteb",
+cmd_set_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
-	"b:", 0, 0,
-	CMD_BUFFER_USAGE,
-	0,
-	cmd_set_buffer_exec
-};
-
-enum cmd_retval
-cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 {
-	struct args		*args = self->args;
+	struct args	*args = self->args;
-	struct paste_buffer	*pb;
+	u_int		 limit;
-	char			*bufdata, *cause;
+	char		*pdata, *cause;
-	const char		*bufname, *olddata;
+	size_t		 psize;
-	size_t			 bufsize, newsize;
+	int		 buffer;
 
-	bufname = args_get(args, 'b');
+	limit = options_get_number(&global_options, "buffer-limit");
-	if (bufname == NULL)
-		pb = NULL;
-	else
-		pb = paste_get_name(bufname);
 
-	if (self->entry == &cmd_delete_buffer_entry) {
+	pdata = xstrdup(args->argv[0]);
-		if (pb == NULL)
+	psize = strlen(pdata);
-			pb = paste_get_top(&bufname);
+
-		if (pb == NULL) {
+	if (!args_has(args, 'b')) {
-			cmdq_error(cmdq, "no buffer");
+		paste_add(&global_buffers, pdata, psize, limit);
-			return (CMD_RETURN_ERROR);
+		return (0);
-		}
-		paste_free(pb);
-		return (CMD_RETURN_NORMAL);
 	}
 
-	if (args_has(args, 'n')) {
+	buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
-		if (pb == NULL)
+	if (cause != NULL) {
-			pb = paste_get_top(&bufname);
+		ctx->error(ctx, "buffer %s", cause);
-		if (pb == NULL) {
+		xfree(cause);
-			cmdq_error(cmdq, "no buffer");
+		xfree(pdata);
-			return (CMD_RETURN_ERROR);
+		return (-1);
-		}
-		if (paste_rename(bufname, args_get(args, 'n'), &cause) != 0) {
-			cmdq_error(cmdq, "%s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-		return (CMD_RETURN_NORMAL);
 	}
 
-	if (args->argc != 1) {
+	if (paste_replace(&global_buffers, buffer, pdata, psize) != 0) {
-		cmdq_error(cmdq, "no data specified");
+		ctx->error(ctx, "no buffer %d", buffer);
-		return (CMD_RETURN_ERROR);
+		xfree(pdata);
-	}
+		return (-1);
-	if ((newsize = strlen(args->argv[0])) == 0)
-		return (CMD_RETURN_NORMAL);
-
-	bufsize = 0;
-	bufdata = NULL;
-
-	if (args_has(args, 'a') && pb != NULL) {
-		olddata = paste_buffer_data(pb, &bufsize);
-		bufdata = xmalloc(bufsize);
-		memcpy(bufdata, olddata, bufsize);
 	}
 
-	bufdata = xrealloc(bufdata, bufsize + newsize);
+	return (0);
-	memcpy(bufdata + bufsize, args->argv[0], newsize);
-	bufsize += newsize;
-
-	if (paste_set(bufdata, bufsize, bufname, &cause) != 0) {
-		cmdq_error(cmdq, "%s", cause);
-		free(bufdata);
-		free(cause);
-		return (CMD_RETURN_ERROR);
-	}
-
-	return (CMD_RETURN_NORMAL);
 }

cmd-set-environment.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -27,18 +27,20 @@
  * Set an environment variable.
  */
 
-enum cmd_retval	 cmd_set_environment_exec(struct cmd *, struct cmd_q *);
+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]",
 	0,
+	NULL,
+	NULL,
 	cmd_set_environment_exec
 };
 
-enum cmd_retval
+int
-cmd_set_environment_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_set_environment_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args	*args = self->args;
 	struct session	*s;
@@ -47,15 +49,15 @@ cmd_set_environment_exec(struct cmd *self, struct cmd_q *cmdq)
 
 	name = args->argv[0];
 	if (*name == '\0') {
-		cmdq_error(cmdq, "empty variable name");
+		ctx->error(ctx, "empty variable name");
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 	if (strchr(name, '=') != NULL) {
-		cmdq_error(cmdq, "variable name contains =");
+		ctx->error(ctx, "variable name contains =");
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 
-	if (args->argc < 2)
+	if (args->argc < 1)
 		value = NULL;
 	else
 		value = args->argv[1];
@@ -63,30 +65,30 @@ cmd_set_environment_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(self->args, 'g'))
 		env = &global_environ;
 	else {
-		if ((s = cmd_find_session(cmdq, args_get(args, 't'), 0)) == NULL)
+		if ((s = cmd_find_session(ctx, args_get(args, 't'), 0)) == NULL)
-			return (CMD_RETURN_ERROR);
+			return (-1);
 		env = &s->environ;
 	}
 
 	if (args_has(self->args, 'u')) {
 		if (value != NULL) {
-			cmdq_error(cmdq, "can't specify a value with -u");
+			ctx->error(ctx, "can't specify a value with -u");
-			return (CMD_RETURN_ERROR);
+			return (-1);
 		}
 		environ_unset(env, name);
 	} else if (args_has(self->args, 'r')) {
 		if (value != NULL) {
-			cmdq_error(cmdq, "can't specify a value with -r");
+			ctx->error(ctx, "can't specify a value with -r");
-			return (CMD_RETURN_ERROR);
+			return (-1);
 		}
 		environ_set(env, name, NULL);
 	} else {
 		if (value == NULL) {
-			cmdq_error(cmdq, "no value specified");
+			ctx->error(ctx, "no value specified");
-			return (CMD_RETURN_ERROR);
+			return (-1);
 		}
 		environ_set(env, name, value);
 	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-set-option.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -27,61 +27,95 @@
  * Set an option.
  */
 
-enum cmd_retval	cmd_set_option_exec(struct cmd *, struct cmd_q *);
+int	cmd_set_option_exec(struct cmd *, struct cmd_ctx *);
 
-enum cmd_retval	cmd_set_option_user(struct cmd *, struct cmd_q *,
+int	cmd_set_option_find(const char *, const struct options_table_entry **,
-	    const char *, const char *);
+	    const struct options_table_entry **);
 
-int	cmd_set_option_unset(struct cmd *, struct cmd_q *,
+int	cmd_set_option_unset(struct cmd *, struct cmd_ctx *,
 	    const struct options_table_entry *, struct options *,
 	    const char *);
-int	cmd_set_option_set(struct cmd *, struct cmd_q *,
+int	cmd_set_option_set(struct cmd *, struct cmd_ctx *,
 	    const struct options_table_entry *, struct options *,
 	    const char *);
 
-struct options_entry *cmd_set_option_string(struct cmd *, struct cmd_q *,
+struct options_entry *cmd_set_option_string(struct cmd *, struct cmd_ctx *,
 	    const struct options_table_entry *, struct options *,
 	    const char *);
-struct options_entry *cmd_set_option_number(struct cmd *, struct cmd_q *,
+struct options_entry *cmd_set_option_number(struct cmd *, struct cmd_ctx *,
 	    const struct options_table_entry *, struct options *,
 	    const char *);
-struct options_entry *cmd_set_option_key(struct cmd *, struct cmd_q *,
+struct options_entry *cmd_set_option_keys(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_q *,
+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_q *,
+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_q *,
+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_q *,
+struct options_entry *cmd_set_option_choice(struct cmd *, struct cmd_ctx *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_style(struct cmd *, struct cmd_q *,
 	    const struct options_table_entry *, struct options *,
 	    const char *);
 
 const struct cmd_entry cmd_set_option_entry = {
 	"set-option", "set",
-	"agoqst:uw", 1, 2,
+	"agst:uw", 1, 2,
-	"[-agosquw] [-t target-session|target-window] option [value]",
+	"[-agsuw] [-t target-session|target-window] option [value]",
 	0,
+	NULL,
+	NULL,
 	cmd_set_option_exec
 };
 
 const struct cmd_entry cmd_set_window_option_entry = {
 	"set-window-option", "setw",
-	"agoqt:u", 1, 2,
+	"agt:u", 1, 2,
-	"[-agoqu] " CMD_TARGET_WINDOW_USAGE " option [value]",
+	"[-agu] " CMD_TARGET_WINDOW_USAGE " option [value]",
 	0,
+	NULL,
+	NULL,
 	cmd_set_option_exec
 };
 
-enum cmd_retval
+/* Look for an option in all three tables. */
-cmd_set_option_exec(struct cmd *self, struct cmd_q *cmdq)
+int
+cmd_set_option_find(
+    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;
+
+	for (i = 0; i < nitems(tables); i++) {
+		for (oe_loop = tables[i]; oe_loop->name != NULL; oe_loop++) {
+			if (strncmp(oe_loop->name, optstr, strlen(optstr)) != 0)
+				continue;
+
+			/* If already found, ambiguous. */
+			if (*oe != NULL)
+				return (-1);
+			*oe = oe_loop;
+			*table = tables[i];
+
+			/* Bail now if an exact match. */
+			if (strcmp((*oe)->name, optstr) == 0)
+				break;
+		}
+	}
+	return (0);
+}
+
+int
+cmd_set_option_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args				*args = self->args;
 	const struct options_table_entry	*table, *oe;
@@ -89,39 +123,29 @@ cmd_set_option_exec(struct cmd *self, struct cmd_q *cmdq)
 	struct winlink				*wl;
 	struct client				*c;
 	struct options				*oo;
-	struct window				*w;
 	const char				*optstr, *valstr;
+	u_int					 i;
 
 	/* Get the option name and value. */
 	optstr = args->argv[0];
 	if (*optstr == '\0') {
-		cmdq_error(cmdq, "invalid option");
+		ctx->error(ctx, "invalid option");
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 	if (args->argc < 2)
 		valstr = NULL;
 	else
 		valstr = args->argv[1];
 
-	/* Is this a user option? */
-	if (*optstr == '@')
-		return (cmd_set_option_user(self, cmdq, optstr, valstr));
-
 	/* Find the option entry, try each table. */
 	table = oe = NULL;
-	if (options_table_find(optstr, &table, &oe) != 0) {
+	if (cmd_set_option_find(optstr, &table, &oe) != 0) {
-		if (!args_has(args, 'q')) {
+		ctx->error(ctx, "ambiguous option: %s", optstr);
-			cmdq_error(cmdq, "ambiguous option: %s", optstr);
+		return (-1);
-			return (CMD_RETURN_ERROR);
-		}
-		return (CMD_RETURN_NORMAL);
 	}
 	if (oe == NULL) {
-		if (!args_has(args, 'q')) {
+		ctx->error(ctx, "unknown option: %s", optstr);
-			cmdq_error(cmdq, "unknown option: %s", optstr);
+		return (-1);
-			return (CMD_RETURN_ERROR);
-		}
-		return (CMD_RETURN_NORMAL);
 	}
 
 	/* Work out the tree from the table. */
@@ -131,230 +155,117 @@ cmd_set_option_exec(struct cmd *self, struct cmd_q *cmdq)
 		if (args_has(self->args, 'g'))
 			oo = &global_w_options;
 		else {
-			wl = cmd_find_window(cmdq, args_get(args, 't'), NULL);
+			wl = cmd_find_window(ctx, args_get(args, 't'), NULL);
-			if (wl == NULL) {
+			if (wl == NULL)
-				cmdq_error(cmdq,
+				return (-1);
-				    "couldn't set '%s'%s", optstr,
-				    (!args_has(args, 't') && !args_has(args,
-				    'g')) ? " need target window or -g" : "");
-				return (CMD_RETURN_ERROR);
-			}
 			oo = &wl->window->options;
 		}
 	} else if (table == session_options_table) {
 		if (args_has(self->args, 'g'))
 			oo = &global_s_options;
 		else {
-			s = cmd_find_session(cmdq, args_get(args, 't'), 0);
+			s = cmd_find_session(ctx, args_get(args, 't'), 0);
-			if (s == NULL) {
+			if (s == NULL)
-				cmdq_error(cmdq,
+				return (-1);
-				    "couldn't set '%s'%s", optstr,
-				    (!args_has(args, 't') && !args_has(args,
-				    'g')) ? " need target session or -g" : "");
-				return (CMD_RETURN_ERROR);
-			}
 			oo = &s->options;
 		}
 	} else {
-		cmdq_error(cmdq, "unknown table");
+		ctx->error(ctx, "unknown table");
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 
 	/* Unset or set the option. */
 	if (args_has(args, 'u')) {
-		if (cmd_set_option_unset(self, cmdq, oe, oo, valstr) != 0)
+		if (cmd_set_option_unset(self, ctx, oe, oo, valstr) != 0)
-			return (CMD_RETURN_ERROR);
+			return (-1);
 	} else {
-		if (args_has(args, 'o') && options_find1(oo, optstr) != NULL) {
+		if (cmd_set_option_set(self, ctx, oe, oo, valstr) != 0)
-			if (!args_has(args, 'q')) {
+			return (-1);
-				cmdq_error(cmdq, "already set: %s", optstr);
-				return (CMD_RETURN_ERROR);
-			}
-			return (CMD_RETURN_NORMAL);
-		}
-		if (cmd_set_option_set(self, cmdq, oe, oo, valstr) != 0)
-			return (CMD_RETURN_ERROR);
 	}
 
-	/* Start or stop timers if necessary. */
-	if (strcmp(oe->name, "automatic-rename") == 0) {
-		RB_FOREACH(w, windows, &windows) {
-			if (options_get_number(&w->options, "automatic-rename"))
-				w->active->flags |= PANE_CHANGED;
-		}
-	}
-	if (strcmp(oe->name, "status") == 0 ||
-	    strcmp(oe->name, "status-interval") == 0)
-		status_timer_start_all();
-	if (strcmp(oe->name, "monitor-silence") == 0)
-		alerts_reset_all();
-
 	/* Update sizes and redraw. May not need it but meh. */
 	recalculate_sizes();
-	TAILQ_FOREACH(c, &clients, entry) {
+	for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
-		if (c->session != NULL)
+		c = ARRAY_ITEM(&clients, i);
+		if (c != NULL && c->session != NULL)
 			server_redraw_client(c);
 	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
-}
-
-/* Set user option. */
-enum cmd_retval
-cmd_set_option_user(struct cmd *self, struct cmd_q *cmdq, const char *optstr,
-    const char *valstr)
-{
-	struct args	*args = self->args;
-	struct session	*s;
-	struct winlink	*wl;
-	struct options	*oo;
-
-	if (args_has(args, 's'))
-		oo = &global_options;
-	else if (args_has(self->args, 'w') ||
-	    self->entry == &cmd_set_window_option_entry) {
-		if (args_has(self->args, 'g'))
-			oo = &global_w_options;
-		else {
-			wl = cmd_find_window(cmdq, args_get(args, 't'), NULL);
-			if (wl == NULL)
-				return (CMD_RETURN_ERROR);
-			oo = &wl->window->options;
-		}
-	} else {
-		if (args_has(self->args, 'g'))
-			oo = &global_s_options;
-		else {
-			s = cmd_find_session(cmdq, args_get(args, 't'), 0);
-			if (s == NULL)
-				return (CMD_RETURN_ERROR);
-			oo = &s->options;
-		}
-	}
-
-	if (args_has(args, 'u')) {
-		if (options_find1(oo, optstr) == NULL) {
-			if (!args_has(args, 'q')) {
-				cmdq_error(cmdq, "unknown option: %s", optstr);
-				return (CMD_RETURN_ERROR);
-			}
-			return (CMD_RETURN_NORMAL);
-		}
-		if (valstr != NULL) {
-			cmdq_error(cmdq, "value passed to unset option: %s",
-			    optstr);
-			return (CMD_RETURN_ERROR);
-		}
-		options_remove(oo, optstr);
-	} else {
-		if (valstr == NULL) {
-			cmdq_error(cmdq, "empty value");
-			return (CMD_RETURN_ERROR);
-		}
-		if (args_has(args, 'o') && options_find1(oo, optstr) != NULL) {
-			if (!args_has(args, 'q')) {
-				cmdq_error(cmdq, "already set: %s", optstr);
-				return (CMD_RETURN_ERROR);
-			}
-			return (CMD_RETURN_NORMAL);
-		}
-		options_set_string(oo, optstr, "%s", valstr);
-	}
-	return (CMD_RETURN_NORMAL);
 }
 
 /* Unset an option. */
 int
-cmd_set_option_unset(struct cmd *self, struct cmd_q *cmdq,
+cmd_set_option_unset(struct cmd *self, struct cmd_ctx *ctx,
-    const struct options_table_entry *oe, struct options *oo,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
-    const char *value)
 {
 	struct args	*args = self->args;
 
+	if (args_has(args, 'g')) {
+		ctx->error(ctx, "can't unset global option: %s", oe->name);
+		return (-1);
+	}
 	if (value != NULL) {
-		cmdq_error(cmdq, "value passed to unset option: %s", oe->name);
+		ctx->error(ctx, "value passed to unset option: %s", oe->name);
 		return (-1);
 	}
 
-	if (args_has(args, 'g') || oo == &global_options) {
+	options_remove(oo, oe->name);
-		switch (oe->type) {
+	ctx->info(ctx, "unset option: %s", oe->name);
-		case OPTIONS_TABLE_STRING:
-			options_set_string(oo, oe->name, "%s", oe->default_str);
-			break;
-		case OPTIONS_TABLE_STYLE:
-			options_set_style(oo, oe->name, oe->default_str, 0);
-			break;
-		default:
-			options_set_number(oo, oe->name, oe->default_num);
-			break;
-		}
-	} else
-		options_remove(oo, oe->name);
 	return (0);
 }
 
 /* Set an option. */
 int
-cmd_set_option_set(struct cmd *self, struct cmd_q *cmdq,
+cmd_set_option_set(struct cmd *self, struct cmd_ctx *ctx,
-    const struct options_table_entry *oe, struct options *oo,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
-    const char *value)
 {
 	struct options_entry	*o;
+	const char		*s;
 
-	switch (oe->type) {
+	if (oe->type != OPTIONS_TABLE_FLAG && value == NULL) {
-	case OPTIONS_TABLE_FLAG:
+		ctx->error(ctx, "empty value");
-	case OPTIONS_TABLE_CHOICE:
+		return (-1);
-		break;
-	default:
-		if (value == NULL) {
-			cmdq_error(cmdq, "empty value");
-			return (-1);
-		}
 	}
 
 	o = NULL;
 	switch (oe->type) {
 	case OPTIONS_TABLE_STRING:
-		o = cmd_set_option_string(self, cmdq, oe, oo, value);
+		o = cmd_set_option_string(self, ctx, oe, oo, value);
 		break;
 	case OPTIONS_TABLE_NUMBER:
-		o = cmd_set_option_number(self, cmdq, oe, oo, value);
+		o = cmd_set_option_number(self, ctx, oe, oo, value);
 		break;
-	case OPTIONS_TABLE_KEY:
+	case OPTIONS_TABLE_KEYS:
-		o = cmd_set_option_key(self, cmdq, oe, oo, value);
+		o = cmd_set_option_keys(self, ctx, oe, oo, value);
 		break;
 	case OPTIONS_TABLE_COLOUR:
-		o = cmd_set_option_colour(self, cmdq, oe, oo, value);
+		o = cmd_set_option_colour(self, ctx, oe, oo, value);
-		if (o != NULL)
-			style_update_new(oo, o->name, oe->style);
 		break;
 	case OPTIONS_TABLE_ATTRIBUTES:
-		o = cmd_set_option_attributes(self, cmdq, oe, oo, value);
+		o = cmd_set_option_attributes(self, ctx, oe, oo, value);
-		if (o != NULL)
-			style_update_new(oo, o->name, oe->style);
 		break;
 	case OPTIONS_TABLE_FLAG:
-		o = cmd_set_option_flag(self, cmdq, oe, oo, value);
+		o = cmd_set_option_flag(self, ctx, oe, oo, value);
 		break;
 	case OPTIONS_TABLE_CHOICE:
-		o = cmd_set_option_choice(self, cmdq, oe, oo, value);
+		o = cmd_set_option_choice(self, ctx, oe, oo, value);
-		break;
-	case OPTIONS_TABLE_STYLE:
-		o = cmd_set_option_style(self, cmdq, 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_q *cmdq,
+cmd_set_option_string(struct cmd *self, unused struct cmd_ctx *ctx,
-    const struct options_table_entry *oe, struct options *oo,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
-    const char *value)
 {
-	struct args		*args = self->args;
+	struct args	*args = self->args;
 	struct options_entry	*o;
 	char			*oldval, *newval;
 
@@ -366,54 +277,63 @@ cmd_set_option_string(struct cmd *self, unused struct cmd_q *cmdq,
 
 	o = options_set_string(oo, oe->name, "%s", newval);
 
-	free(newval);
+	xfree(newval);
 	return (o);
 }
 
 /* Set a number option. */
 struct options_entry *
-cmd_set_option_number(unused struct cmd *self, struct cmd_q *cmdq,
+cmd_set_option_number(unused struct cmd *self, struct cmd_ctx *ctx,
-    const struct options_table_entry *oe, struct options *oo,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
-    const char *value)
 {
 	long long	 ll;
 	const char     	*errstr;
 
 	ll = strtonum(value, oe->minimum, oe->maximum, &errstr);
 	if (errstr != NULL) {
-		cmdq_error(cmdq, "value is %s: %s", errstr, value);
+		ctx->error(ctx, "value is %s: %s", errstr, value);
 		return (NULL);
 	}
 
 	return (options_set_number(oo, oe->name, ll));
 }
 
-/* Set a key option. */
+/* Set a keys option. */
 struct options_entry *
-cmd_set_option_key(unused struct cmd *self, struct cmd_q *cmdq,
+cmd_set_option_keys(unused struct cmd *self, struct cmd_ctx *ctx,
-    const struct options_table_entry *oe, struct options *oo,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
-    const char *value)
 {
-	int	key;
+	struct keylist	*keylist;
+	char		*copy, *ptr, *s;
+	int		 key;
 
-	if ((key = key_string_lookup_string(value)) == KEYC_NONE) {
+	keylist = xmalloc(sizeof *keylist);
-		cmdq_error(cmdq, "bad key: %s", value);
+	ARRAY_INIT(keylist);
-		return (NULL);
+
+	ptr = copy = xstrdup(value);
+	while ((s = strsep(&ptr, ",")) != NULL) {
+		if ((key = key_string_lookup_string(s)) == KEYC_NONE) {
+			ctx->error(ctx, "unknown key: %s", s);
+			xfree(copy);
+			xfree(keylist);
+			return (NULL);
+		}
+		ARRAY_ADD(keylist, key);
 	}
+	xfree(copy);
 
-	return (options_set_number(oo, oe->name, key));
+	return (options_set_data(oo, oe->name, keylist, xfree));
 }
 
 /* Set a colour option. */
 struct options_entry *
-cmd_set_option_colour(unused struct cmd *self, struct cmd_q *cmdq,
+cmd_set_option_colour(unused struct cmd *self, struct cmd_ctx *ctx,
-    const struct options_table_entry *oe, struct options *oo,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
-    const char *value)
 {
 	int	colour;
 
 	if ((colour = colour_fromstring(value)) == -1) {
-		cmdq_error(cmdq, "bad colour: %s", value);
+		ctx->error(ctx, "bad colour: %s", value);
 		return (NULL);
 	}
 
@@ -422,14 +342,13 @@ cmd_set_option_colour(unused struct cmd *self, struct cmd_q *cmdq,
 
 /* Set an attributes option. */
 struct options_entry *
-cmd_set_option_attributes(unused struct cmd *self, struct cmd_q *cmdq,
+cmd_set_option_attributes(unused struct cmd *self, struct cmd_ctx *ctx,
-    const struct options_table_entry *oe, struct options *oo,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
-    const char *value)
 {
 	int	attr;
 
 	if ((attr = attributes_fromstring(value)) == -1) {
-		cmdq_error(cmdq, "bad attributes: %s", value);
+		ctx->error(ctx, "bad attributes: %s", value);
 		return (NULL);
 	}
 
@@ -438,9 +357,8 @@ cmd_set_option_attributes(unused struct cmd *self, struct cmd_q *cmdq,
 
 /* Set a flag option. */
 struct options_entry *
-cmd_set_option_flag(unused struct cmd *self, struct cmd_q *cmdq,
+cmd_set_option_flag(unused struct cmd *self, struct cmd_ctx *ctx,
-    const struct options_table_entry *oe, struct options *oo,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
-    const char *value)
 {
 	int	flag;
 
@@ -456,7 +374,7 @@ cmd_set_option_flag(unused struct cmd *self, struct cmd_q *cmdq,
 		    strcasecmp(value, "no") == 0)
 			flag = 0;
 		else {
-			cmdq_error(cmdq, "bad value: %s", value);
+			ctx->error(ctx, "bad value: %s", value);
 			return (NULL);
 		}
 	}
@@ -466,55 +384,28 @@ cmd_set_option_flag(unused struct cmd *self, struct cmd_q *cmdq,
 
 /* Set a choice option. */
 struct options_entry *
-cmd_set_option_choice(unused struct cmd *self, struct cmd_q *cmdq,
+cmd_set_option_choice(unused struct cmd *self, struct cmd_ctx *ctx,
-    const struct options_table_entry *oe, struct options *oo,
+    const struct options_table_entry *oe, struct options *oo, const char *value)
-    const char *value)
 {
 	const char	**choicep;
 	int		  n, choice = -1;
 
-	if (value == NULL) {
+	n = 0;
-		choice = options_get_number(oo, oe->name);
+	for (choicep = oe->choices; *choicep != NULL; choicep++) {
-		if (choice < 2)
+		n++;
-			choice = !choice;
+		if (strncmp(*choicep, value, strlen(value)) != 0)
-	} else {
+			continue;
-		n = 0;
-		for (choicep = oe->choices; *choicep != NULL; choicep++) {
-			n++;
-			if (strncmp(*choicep, value, strlen(value)) != 0)
-				continue;
 
-			if (choice != -1) {
+		if (choice != -1) {
-				cmdq_error(cmdq, "ambiguous value: %s", value);
+			ctx->error(ctx, "ambiguous value: %s", value);
-				return (NULL);
-			}
-			choice = n - 1;
-		}
-		if (choice == -1) {
-			cmdq_error(cmdq, "unknown value: %s", value);
 			return (NULL);
 		}
+		choice = n - 1;
+	}
+	if (choice == -1) {
+		ctx->error(ctx, "unknown value: %s", value);
+		return (NULL);
 	}
 
 	return (options_set_number(oo, oe->name, choice));
 }
-
-/* Set a style option. */
-struct options_entry *
-cmd_set_option_style(struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	struct args		*args = self->args;
-	struct options_entry	*o;
-	int			 append;
-
-	append = args_has(args, 'a');
-	if ((o = options_set_style(oo, oe->name, value, append)) == NULL) {
-		cmdq_error(cmdq, "bad style: %s", value);
-		return (NULL);
-	}
-
-	style_update_old(oo, oe->name, &o->style);
-	return (o);
-}

cmd-show-buffer.c

@@ -0,0 +1,109 @@
+/* $Id$ */
+
+/*
+ * 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"
+
+/*
+ * Show a session paste buffer.
+ */
+
+int	cmd_show_buffer_exec(struct cmd *, struct cmd_ctx *);
+
+const struct cmd_entry cmd_show_buffer_entry = {
+	"show-buffer", "showb",
+	"b:", 0, 0,
+	CMD_BUFFER_USAGE,
+	0,
+	NULL,
+	NULL,
+	cmd_show_buffer_exec
+};
+
+int
+cmd_show_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
+{
+	struct args		*args = self->args;
+	struct session		*s;
+	struct paste_buffer	*pb;
+	int			 buffer;
+	char			*in, *buf, *ptr, *cause;
+	size_t			 size, len;
+	u_int			 width;
+
+	if ((s = cmd_find_session(ctx, NULL, 0)) == NULL)
+		return (-1);
+
+	if (!args_has(args, 'b')) {
+		if ((pb = paste_get_top(&global_buffers)) == NULL) {
+			ctx->error(ctx, "no buffers");
+			return (-1);
+		}
+	} else {
+		buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
+		if (cause != NULL) {
+			ctx->error(ctx, "buffer %s", cause);
+			xfree(cause);
+			return (-1);
+		}
+
+		pb = paste_get_index(&global_buffers, buffer);
+		if (pb == NULL) {
+			ctx->error(ctx, "no buffer %d", buffer);
+			return (-1);
+		}
+	}
+
+	size = pb->size;
+	if (size > SIZE_MAX / 4 - 1)
+		size = SIZE_MAX / 4 - 1;
+	in = xmalloc(size * 4 + 1);
+	strvisx(in, pb->data, size, VIS_OCTAL|VIS_TAB);
+
+	width = s->sx;
+	if (ctx->cmdclient != NULL)
+		width = ctx->cmdclient->tty.sx;
+
+	buf = xmalloc(width + 1);
+	len = 0;
+
+	ptr = in;
+	do {
+		buf[len++] = *ptr++;
+
+		if (len == width || buf[len - 1] == '\n') {
+			if (buf[len - 1] == '\n')
+				len--;
+			buf[len] = '\0';
+
+			ctx->print(ctx, "%s", buf);
+			len = 0;
+		}
+	} while (*ptr != '\0');
+
+	if (len != 0) {
+		buf[len] = '\0';
+		ctx->print(ctx, "%s", buf);
+	}
+	xfree(buf);
+
+	xfree(in);
+
+	return (0);
+}

cmd-show-environment.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -27,63 +27,20 @@
  * Show environment.
  */
 
-enum cmd_retval	cmd_show_environment_exec(struct cmd *, struct cmd_q *);
+int	cmd_show_environment_exec(struct cmd *, struct cmd_ctx *);
-
-char	*cmd_show_environment_escape(struct environ_entry *);
-void	 cmd_show_environment_print(struct cmd *, struct cmd_q *,
-	     struct environ_entry *);
 
 const struct cmd_entry cmd_show_environment_entry = {
 	"show-environment", "showenv",
-	"gst:", 0, 1,
+	"gt:", 0, 0,
-	"[-gs] " CMD_TARGET_SESSION_USAGE " [name]",
+	"[-g] " CMD_TARGET_SESSION_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_show_environment_exec
 };
 
-char *
+int
-cmd_show_environment_escape(struct environ_entry *envent)
+cmd_show_environment_exec(struct cmd *self, struct cmd_ctx *ctx)
-{
-	const char	*value = envent->value;
-	char		 c, *out, *ret;
-
-	out = ret = xmalloc(strlen(value) * 2 + 1); /* at most twice the size */
-	while ((c = *value++) != '\0') {
-		/* POSIX interprets $ ` " and \ in double quotes. */
-		if (c == '$' || c == '`' || c == '"' || c == '\\')
-			*out++ = '\\';
-		*out++ = c;
-	}
-	*out = '\0';
-
-	return (ret);
-}
-
-void
-cmd_show_environment_print(struct cmd *self, struct cmd_q *cmdq,
-    struct environ_entry *envent)
-{
-	char	*escaped;
-
-	if (!args_has(self->args, 's')) {
-		if (envent->value != NULL)
-			cmdq_print(cmdq, "%s=%s", envent->name, envent->value);
-		else
-			cmdq_print(cmdq, "-%s", envent->name);
-		return;
-	}
-
-	if (envent->value != NULL) {
-		escaped = cmd_show_environment_escape(envent);
-		cmdq_print(cmdq, "%s=\"%s\"; export %s;", envent->name, escaped,
-		    envent->name);
-		free(escaped);
-	} else
-		cmdq_print(cmdq, "unset %s;", envent->name);
-}
-
-enum cmd_retval
-cmd_show_environment_exec(struct cmd *self, struct cmd_q *cmdq)
 {
 	struct args		*args = self->args;
 	struct session		*s;
@@ -93,23 +50,17 @@ cmd_show_environment_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(self->args, 'g'))
 		env = &global_environ;
 	else {
-		s = cmd_find_session(cmdq, args_get(args, 't'), 0);
+		if ((s = cmd_find_session(ctx, args_get(args, 't'), 0)) == NULL)
-		if (s == NULL)
+			return (-1);
-			return (CMD_RETURN_ERROR);
 		env = &s->environ;
 	}
 
-	if (args->argc != 0) {
+	RB_FOREACH(envent, environ, env) {
-		envent = environ_find(env, args->argv[0]);
+		if (envent->value != NULL)
-		if (envent == NULL) {
+			ctx->print(ctx, "%s=%s", envent->name, envent->value);
-			cmdq_error(cmdq, "unknown variable: %s", args->argv[0]);
+		else
-			return (CMD_RETURN_ERROR);
+			ctx->print(ctx, "-%s", envent->name);
-		}
-		cmd_show_environment_print(self, cmdq, envent);
-		return (CMD_RETURN_NORMAL);
 	}
 
-	RB_FOREACH(envent, environ, env)
+	return (0);
-		cmd_show_environment_print(self, cmdq, envent);
-	return (CMD_RETURN_NORMAL);
 }

cmd-show-messages.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -20,7 +20,6 @@
 
 #include <string.h>
 #include <time.h>
-#include <unistd.h>
 
 #include "tmux.h"
 
@@ -28,118 +27,38 @@
  * Show client message log.
  */
 
-enum cmd_retval	 cmd_show_messages_exec(struct cmd *, struct cmd_q *);
+int	cmd_show_messages_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_show_messages_entry = {
 	"show-messages", "showmsgs",
-	"IJTt:", 0, 0,
+	"t:", 0, 0,
-	"[-IJT] " CMD_TARGET_CLIENT_USAGE,
+	CMD_TARGET_CLIENT_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_show_messages_exec
 };
 
-const struct cmd_entry cmd_server_info_entry = {
-	"server-info", "info",
-	"", 0, 0,
-	"",
-	0,
-	cmd_show_messages_exec
-};
-
-int	cmd_show_messages_server(struct cmd_q *);
-int	cmd_show_messages_terminals(struct cmd_q *, int);
-int	cmd_show_messages_jobs(struct cmd_q *, int);
-
 int
-cmd_show_messages_server(struct cmd_q *cmdq)
+cmd_show_messages_exec(struct cmd *self, struct cmd_ctx *ctx)
-{
-	char	*tim;
-
-	tim = ctime(&start_time);
-	*strchr(tim, '\n') = '\0';
-
-	cmdq_print(cmdq, "started %s", tim);
-	cmdq_print(cmdq, "socket path %s", socket_path);
-	cmdq_print(cmdq, "debug level %d", debug_level);
-	cmdq_print(cmdq, "protocol version %d", PROTOCOL_VERSION);
-
-	return (1);
-}
-
-int
-cmd_show_messages_terminals(struct cmd_q *cmdq, int blank)
-{
-	struct tty_term	*term;
-	u_int		 i, n;
-
-	n = 0;
-	LIST_FOREACH(term, &tty_terms, entry) {
-		if (blank) {
-			cmdq_print(cmdq, "%s", "");
-			blank = 0;
-		}
-		cmdq_print(cmdq, "Terminal %u: %s [references=%u, flags=0x%x]:",
-		    n, term->name, term->references, term->flags);
-		n++;
-		for (i = 0; i < tty_term_ncodes(); i++)
-			cmdq_print(cmdq, "%s", tty_term_describe(term, i));
-	}
-	return (n != 0);
-}
-
-int
-cmd_show_messages_jobs(struct cmd_q *cmdq, int blank)
-{
-	struct job	*job;
-	u_int		 n;
-
-	n = 0;
-	LIST_FOREACH(job, &all_jobs, lentry) {
-		if (blank) {
-			cmdq_print(cmdq, "%s", "");
-			blank = 0;
-		}
-		cmdq_print(cmdq, "Job %u: %s [fd=%d, pid=%d, status=%d]",
-		    n, job->cmd, job->fd, job->pid, job->status);
-		n++;
-	}
-	return (n != 0);
-}
-
-enum cmd_retval
-cmd_show_messages_exec(struct cmd *self, struct cmd_q *cmdq)
 {
 	struct args		*args = self->args;
 	struct client		*c;
 	struct message_entry	*msg;
 	char			*tim;
-	int			 done, blank;
+	u_int			 i;
 
-	done = blank = 0;
+	if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
-	if (args_has(args, 'I') || self->entry == &cmd_server_info_entry) {
+		return (-1);
-		blank = cmd_show_messages_server(cmdq);
-		done = 1;
-	}
-	if (args_has(args, 'T') || self->entry == &cmd_server_info_entry) {
-		blank = cmd_show_messages_terminals(cmdq, blank);
-		done = 1;
-	}
-	if (args_has(args, 'J') || self->entry == &cmd_server_info_entry) {
-		cmd_show_messages_jobs(cmdq, blank);
-		done = 1;
-	}
-	if (done)
-		return (CMD_RETURN_NORMAL);
 
-	if ((c = cmd_find_client(cmdq, args_get(args, 't'), 0)) == NULL)
+	for (i = 0; i < ARRAY_LENGTH(&c->message_log); i++) {
-		return (CMD_RETURN_ERROR);
+		msg = &ARRAY_ITEM(&c->message_log, i);
 
-	TAILQ_FOREACH(msg, &c->message_log, entry) {
 		tim = ctime(&msg->msg_time);
 		*strchr(tim, '\n') = '\0';
 
-		cmdq_print(cmdq, "%s %s", tim, msg->msg);
+		ctx->print(ctx, "%s %s", tim, msg->msg);
 	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-show-options.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -27,38 +27,38 @@
  * Show options.
  */
 
-enum cmd_retval	 cmd_show_options_exec(struct cmd *, struct cmd_q *);
+int	cmd_show_options_exec(struct cmd *, struct cmd_ctx *);
-
-enum cmd_retval	cmd_show_options_one(struct cmd *, struct cmd_q *,
-		    struct options *, int);
-enum cmd_retval cmd_show_options_all(struct cmd *, struct cmd_q *,
-		    const struct options_table_entry *, struct options *);
 
 const struct cmd_entry cmd_show_options_entry = {
 	"show-options", "show",
-	"gqst:vw", 0, 1,
+	"gst:w", 0, 0,
-	"[-gqsvw] [-t target-session|target-window] [option]",
+	"[-gsw] [-t target-session|target-window]",
 	0,
+	NULL,
+	NULL,
 	cmd_show_options_exec
 };
 
 const struct cmd_entry cmd_show_window_options_entry = {
 	"show-window-options", "showw",
-	"gvt:", 0, 1,
+	"gt:", 0, 0,
-	"[-gv] " CMD_TARGET_WINDOW_USAGE " [option]",
+	"[-g] " CMD_TARGET_WINDOW_USAGE,
 	0,
+	NULL,
+	NULL,
 	cmd_show_options_exec
 };
 
-enum cmd_retval
+int
-cmd_show_options_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_show_options_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args				*args = self->args;
+	const struct options_table_entry	*table, *oe;
 	struct session				*s;
 	struct winlink				*wl;
-	const struct options_table_entry	*table;
 	struct options				*oo;
-	int					 quiet;
+	struct options_entry			*o;
+	const char				*optval;
 
 	if (args_has(self->args, 's')) {
 		oo = &global_options;
@@ -69,9 +69,9 @@ cmd_show_options_exec(struct cmd *self, struct cmd_q *cmdq)
 		if (args_has(self->args, 'g'))
 			oo = &global_w_options;
 		else {
-			wl = cmd_find_window(cmdq, args_get(args, 't'), NULL);
+			wl = cmd_find_window(ctx, args_get(args, 't'), NULL);
 			if (wl == NULL)
-				return (CMD_RETURN_ERROR);
+				return (-1);
 			oo = &wl->window->options;
 		}
 	} else {
@@ -79,99 +79,19 @@ cmd_show_options_exec(struct cmd *self, struct cmd_q *cmdq)
 		if (args_has(self->args, 'g'))
 			oo = &global_s_options;
 		else {
-			s = cmd_find_session(cmdq, args_get(args, 't'), 0);
+			s = cmd_find_session(ctx, args_get(args, 't'), 0);
 			if (s == NULL)
-				return (CMD_RETURN_ERROR);
+				return (-1);
 			oo = &s->options;
 		}
 	}
 
-	quiet = args_has(self->args, 'q');
-	if (args->argc == 0)
-		return (cmd_show_options_all(self, cmdq, table, oo));
-	else
-		return (cmd_show_options_one(self, cmdq, oo, quiet));
-}
-
-enum cmd_retval
-cmd_show_options_one(struct cmd *self, struct cmd_q *cmdq,
-    struct options *oo, int quiet)
-{
-	struct args				*args = self->args;
-	const char				*name = args->argv[0];
-	const struct options_table_entry	*table, *oe;
-	struct options_entry			*o;
-	const char				*optval;
-
-retry:
-	if (*name == '@') {
-		if ((o = options_find1(oo, name)) == NULL) {
-			if (quiet)
-				return (CMD_RETURN_NORMAL);
-			cmdq_error(cmdq, "unknown option: %s", name);
-			return (CMD_RETURN_ERROR);
-		}
-		if (args_has(self->args, 'v'))
-			cmdq_print(cmdq, "%s", o->str);
-		else
-			cmdq_print(cmdq, "%s \"%s\"", o->name, o->str);
-		return (CMD_RETURN_NORMAL);
-	}
-
-	table = oe = NULL;
-	if (options_table_find(name, &table, &oe) != 0) {
-		cmdq_error(cmdq, "ambiguous option: %s", name);
-		return (CMD_RETURN_ERROR);
-	}
-	if (oe == NULL) {
-		if (quiet)
-		    return (CMD_RETURN_NORMAL);
-		cmdq_error(cmdq, "unknown option: %s", name);
-		return (CMD_RETURN_ERROR);
-	}
-	if (oe->style != NULL) {
-		name = oe->style;
-		goto retry;
-	}
-	if ((o = options_find1(oo, oe->name)) == NULL)
-		return (CMD_RETURN_NORMAL);
-	optval = options_table_print_entry(oe, o, args_has(self->args, 'v'));
-	if (args_has(self->args, 'v'))
-		cmdq_print(cmdq, "%s", optval);
-	else
-		cmdq_print(cmdq, "%s %s", oe->name, optval);
-	return (CMD_RETURN_NORMAL);
-}
-
-enum cmd_retval
-cmd_show_options_all(struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *table, struct options *oo)
-{
-	const struct options_table_entry	*oe;
-	struct options_entry			*o;
-	const char				*optval;
-
-	RB_FOREACH(o, options_tree, &oo->tree) {
-		if (*o->name == '@') {
-			if (args_has(self->args, 'v'))
-				cmdq_print(cmdq, "%s", o->str);
-			else
-				cmdq_print(cmdq, "%s \"%s\"", o->name, o->str);
-		}
-	}
-
 	for (oe = table; oe->name != NULL; oe++) {
-		if (oe->style != NULL)
-			continue;
 		if ((o = options_find1(oo, oe->name)) == NULL)
 			continue;
-		optval = options_table_print_entry(oe, o,
+		optval = options_table_print_entry(oe, o);
-		    args_has(self->args, 'v'));
+		ctx->print(ctx, "%s %s", oe->name, optval);
-		if (args_has(self->args, 'v'))
-			cmdq_print(cmdq, "%s", optval);
-		else
-			cmdq_print(cmdq, "%s %s", oe->name, optval);
 	}
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-source-file.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Tiago Cunha <me@tiagocunha.org>
@@ -18,79 +18,57 @@
 
 #include <sys/types.h>
 
-#include <stdlib.h>
-
 #include "tmux.h"
 
 /*
  * Sources a configuration file.
  */
 
-enum cmd_retval	cmd_source_file_exec(struct cmd *, struct cmd_q *);
+int	cmd_source_file_exec(struct cmd *, struct cmd_ctx *);
-
-void		cmd_source_file_done(struct cmd_q *);
 
 const struct cmd_entry cmd_source_file_entry = {
 	"source-file", "source",
 	"", 1, 1,
 	"path",
 	0,
+	NULL,
+	NULL,
 	cmd_source_file_exec
 };
 
-enum cmd_retval
+int
-cmd_source_file_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_source_file_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
-	struct args	*args = self->args;
+	struct args		*args = self->args;
-	struct cmd_q	*cmdq1;
+	struct causelist	 causes;
-	char		*cause;
+	char			*cause;
+	struct window_pane	*wp;
+	int			 retval;
+	u_int			 i;
 
-	cmdq1 = cmdq_new(NULL);
+	ARRAY_INIT(&causes);
-	cmdq1->client = cmdq->client;
-	cmdq1->emptyfn = cmd_source_file_done;
-	cmdq1->data = cmdq;
 
-	switch (load_cfg(args->argv[0], cmdq1, &cause)) {
+	retval = load_cfg(args->argv[0], ctx, &causes);
-	case -1:
+	if (ARRAY_EMPTY(&causes))
-		if (cfg_references == 0) {
+		return (retval);
-			cmdq_free(cmdq1);
+
-			cmdq_error(cmdq, "%s", cause);
+	if (retval == 1 && !RB_EMPTY(&sessions) && ctx->cmdclient != NULL) {
-			free(cause);
+		wp = RB_MIN(sessions, &sessions)->curw->window->active;
-			return (CMD_RETURN_ERROR);
+		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);
 		}
-		cfg_add_cause("%s", cause);
-		free(cause);
-		/* FALLTHROUGH */
-	case 0:
-		if (cfg_references == 0)
-			cfg_print_causes(cmdq);
-		cmdq_free(cmdq1);
-		return (CMD_RETURN_NORMAL);
 	}
+	ARRAY_FREE(&causes);
 
-	cmdq->references++;
+	return (retval);
-	cfg_references++;
-
-	cmdq_continue(cmdq1);
-	return (CMD_RETURN_WAIT);
-}
-
-void
-cmd_source_file_done(struct cmd_q *cmdq1)
-{
-	struct cmd_q	*cmdq = cmdq1->data;
-
-	if (cmdq1->client_exit >= 0)
-		cmdq->client_exit = cmdq1->client_exit;
-
-	cmdq_free(cmdq1);
-
-	cfg_references--;
-
-	if (cmdq_free(cmdq))
-		return;
-
-	if (cfg_references == 0)
-		cfg_print_causes(cmdq);
-	cmdq_continue(cmdq);
 }

cmd-split-window.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,10 +18,7 @@
 
 #include <sys/types.h>
 
-#include <errno.h>
-#include <fcntl.h>
 #include <stdlib.h>
-#include <string.h>
 #include <unistd.h>
 
 #include "tmux.h"
@@ -30,21 +27,29 @@
  * Split a window (add a new pane).
  */
 
-#define SPLIT_WINDOW_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"
+void	cmd_split_window_key_binding(struct cmd *, int);
-
+int	cmd_split_window_exec(struct cmd *, struct cmd_ctx *);
-enum cmd_retval	 cmd_split_window_exec(struct cmd *, struct cmd_q *);
 
 const struct cmd_entry cmd_split_window_entry = {
 	"split-window", "splitw",
-	"bc:dF:l:hp:Pt:v", 0, -1,
+	"dl:hp:Pt:v", 0, 1,
-	"[-bdhvP] [-c start-directory] [-F format] [-p percentage|-l size] "
+	"[-dhvP] [-p percentage|-l size] [-t target-pane] [command]",
-	CMD_TARGET_PANE_USAGE " [command]",
 	0,
+	cmd_split_window_key_binding,
+	NULL,
 	cmd_split_window_exec
 };
 
-enum cmd_retval
+void
-cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_split_window_key_binding(struct cmd *self, int key)
+{
+	self->args = args_create(0);
+	if (key == '%')
+		args_set(self->args, 'h', NULL);
+}
+
+int
+cmd_split_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
 	struct session		*s;
@@ -52,61 +57,33 @@ cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	struct window		*w;
 	struct window_pane	*wp, *new_wp = NULL;
 	struct environ		 env;
-	const char		*cmd, *path, *shell, *template;
+	char		 	*cmd, *cwd, *cause;
-	char		       **argv, *cause, *new_cause, *cp;
+	const char		*shell;
-	u_int			 hlimit;
+	u_int			 hlimit, paneidx;
-	int			 argc, size, percentage, cwd, fd = -1;
+	int			 size, percentage;
 	enum layout_type	 type;
 	struct layout_cell	*lc;
-	struct format_tree	*ft;
-	struct environ_entry	*envent;
 
-	if ((wl = cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp)) == NULL)
+	if ((wl = cmd_find_pane(ctx, args_get(args, 't'), &s, &wp)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	w = wl->window;
-	server_unzoom_window(w);
 
 	environ_init(&env);
 	environ_copy(&global_environ, &env);
 	environ_copy(&s->environ, &env);
 	server_fill_environ(s, &env);
 
-	if (args->argc == 0) {
+	if (args->argc == 0)
 		cmd = options_get_string(&s->options, "default-command");
-		if (cmd != NULL && *cmd != '\0') {
-			argc = 1;
-			argv = (char **)&cmd;
-		} else {
-			argc = 0;
-			argv = NULL;
-		}
-	} else {
-		argc = args->argc;
-		argv = args->argv;
-	}
-
-	if (args_has(args, 'c')) {
-		ft = format_create();
-		format_defaults(ft, cmd_find_client(cmdq, NULL, 1), s, NULL,
-		    NULL);
-		cp = format_expand(ft, args_get(args, 'c'));
-		format_free(ft);
-
-		if (cp != NULL && *cp != '\0') {
-			fd = open(cp, O_RDONLY|O_DIRECTORY);
-			free(cp);
-			if (fd == -1) {
-				cmdq_error(cmdq, "bad working directory: %s",
-				    strerror(errno));
-				return (CMD_RETURN_ERROR);
-			}
-		} else if (cp != NULL)
-			free(cp);
-		cwd = fd;
-	} else if (cmdq->client != NULL && cmdq->client->session == NULL)
-		cwd = cmdq->client->cwd;
 	else
-		cwd = s->cwd;
+		cmd = args->argv[0];
+	cwd = options_get_string(&s->options, "default-path");
+	if (*cwd == '\0') {
+		if (ctx->cmdclient != NULL && ctx->cmdclient->cwd != NULL)
+			cwd = ctx->cmdclient->cwd;
+		else
+			cwd = s->cwd;
+	}
 
 	type = LAYOUT_TOPBOTTOM;
 	if (args_has(args, 'h'))
@@ -116,18 +93,16 @@ cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(args, 'l')) {
 		size = args_strtonum(args, 'l', 0, INT_MAX, &cause);
 		if (cause != NULL) {
-			xasprintf(&new_cause, "size %s", cause);
+			ctx->error(ctx, "size %s", cause);
-			free(cause);
+			xfree(cause);
-			cause = new_cause;
+			return (-1);
-			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);
+			ctx->error(ctx, "percentage %s", cause);
-			free(cause);
+			xfree(cause);
-			cause = new_cause;
+			return (-1);
-			goto error;
 		}
 		if (type == LAYOUT_TOPBOTTOM)
 			size = (wp->sy * percentage) / 100;
@@ -140,25 +115,15 @@ cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (*shell == '\0' || areshell(shell))
 		shell = _PATH_BSHELL;
 
-	lc = layout_split_pane(wp, type, size, args_has(args, 'b'));
+	if ((lc = layout_split_pane(wp, type, size)) == NULL) {
-	if (lc == NULL) {
 		cause = xstrdup("pane too small");
 		goto error;
 	}
 	new_wp = window_add_pane(w, hlimit);
-	layout_assign_pane(lc, new_wp);
+	if (window_pane_spawn(
-
+	    new_wp, cmd, shell, cwd, &env, s->tio, &cause) != 0)
-	path = NULL;
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
-		envent = environ_find(&cmdq->client->environ, "PATH");
-	else
-		envent = environ_find(&s->environ, "PATH");
-	if (envent != NULL)
-		path = envent->value;
-
-	if (window_pane_spawn(new_wp, argc, argv, path, shell, cwd, &env,
-	    s->tio, &cause) != 0)
 		goto error;
+	layout_assign_pane(lc, new_wp);
 
 	server_redraw_window(w);
 
@@ -172,34 +137,16 @@ cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	environ_free(&env);
 
 	if (args_has(args, 'P')) {
-		if ((template = args_get(args, 'F')) == NULL)
+		paneidx = window_pane_index(wl->window, new_wp);
-			template = SPLIT_WINDOW_TEMPLATE;
+		ctx->print(ctx, "%s:%u.%u", s->name, wl->idx, paneidx);
-
-		ft = format_create();
-		format_defaults(ft, cmd_find_client(cmdq, NULL, 1), s, wl,
-		    new_wp);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
-		free(cp);
-
-		format_free(ft);
 	}
-	notify_window_layout_changed(w);
+	return (0);
-
-	if (fd != -1)
-		close(fd);
-	return (CMD_RETURN_NORMAL);
 
 error:
 	environ_free(&env);
-	if (new_wp != NULL) {
+	if (new_wp != NULL)
-		layout_close_pane(new_wp);
 		window_remove_pane(w, new_wp);
-	}
+	ctx->error(ctx, "create pane failed: %s", cause);
-	cmdq_error(cmdq, "create pane failed: %s", cause);
+	xfree(cause);
-	free(cause);
+	return (-1);
-	if (fd != -1)
-		close(fd);
-	return (CMD_RETURN_ERROR);
 }

cmd-start-server.c

@@ -1,6 +1,7 @@
+/* $Id$ */
+
 /*
- * Copyright (c) 2013 Dagobert Michelsen
+ * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
- * Copyright (c) 2013 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
@@ -15,16 +16,29 @@
  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include <string.h>
+#include <sys/types.h>
 
 #include "tmux.h"
 
-void
+/*
-cfmakeraw(struct termios *tio)
+ * Start the server and do nothing else.
+ */
+
+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,
+	NULL,
+	NULL,
+	cmd_start_server_exec
+};
+
+/* ARGSUSED */
+int
+cmd_start_server_exec(unused struct cmd *self, unused struct cmd_ctx *ctx)
 {
-	tio->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
+	return (0);
-	tio->c_oflag &= ~OPOST;
-	tio->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
-	tio->c_cflag &= ~(CSIZE|PARENB);
-	tio->c_cflag |= CS8;
 }

cmd-string.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -31,12 +31,11 @@
  * Parse a command from a string.
  */
 
-int	 cmd_string_getc(const char *, size_t *);
+int	cmd_string_getc(const char *, size_t *);
-void	 cmd_string_ungetc(size_t *);
+void	cmd_string_ungetc(size_t *);
-void	 cmd_string_copy(char **, char *, size_t *);
+char   *cmd_string_string(const char *, size_t *, char, int);
-char	*cmd_string_string(const char *, size_t *, char, int);
+char   *cmd_string_variable(const char *, size_t *);
-char	*cmd_string_variable(const char *, size_t *);
+char   *cmd_string_expand_tilde(const char *, size_t *);
-char	*cmd_string_expand_tilde(const char *, size_t *);
 
 int
 cmd_string_getc(const char *s, size_t *p)
@@ -59,8 +58,7 @@ cmd_string_ungetc(size_t *p)
  * string, or NULL for empty command.
  */
 int
-cmd_string_parse(const char *s, struct cmd_list **cmdlist, const char *file,
+cmd_string_parse(const char *s, struct cmd_list **cmdlist, char **cause)
-    u_int line, char **cause)
 {
 	size_t		p;
 	int		ch, i, argc, rval;
@@ -86,17 +84,26 @@ cmd_string_parse(const char *s, struct cmd_list **cmdlist, const char *file,
 		case '\'':
 			if ((t = cmd_string_string(s, &p, '\'', 0)) == NULL)
 				goto error;
-			cmd_string_copy(&buf, t, &len);
+			buf = xrealloc(buf, 1, len + strlen(t) + 1);
+			strlcpy(buf + len, t, strlen(t) + 1);
+			len += strlen(t);
+			xfree(t);
 			break;
 		case '"':
 			if ((t = cmd_string_string(s, &p, '"', 1)) == NULL)
 				goto error;
-			cmd_string_copy(&buf, t, &len);
+			buf = xrealloc(buf, 1, len + strlen(t) + 1);
+			strlcpy(buf + len, t, strlen(t) + 1);
+			len += strlen(t);
+			xfree(t);
 			break;
 		case '$':
 			if ((t = cmd_string_variable(s, &p)) == NULL)
 				goto error;
-			cmd_string_copy(&buf, t, &len);
+			buf = xrealloc(buf, 1, len + strlen(t) + 1);
+			strlcpy(buf + len, t, strlen(t) + 1);
+			len += strlen(t);
+			xfree(t);
 			break;
 		case '#':
 			/* Comment: discard rest of line. */
@@ -107,11 +114,10 @@ cmd_string_parse(const char *s, struct cmd_list **cmdlist, const char *file,
 		case ' ':
 		case '\t':
 			if (buf != NULL) {
-				buf = xrealloc(buf, len + 1);
+				buf = xrealloc(buf, 1, len + 1);
 				buf[len] = '\0';
 
-				argv = xreallocarray(argv, argc + 1,
+				argv = xrealloc(argv, argc + 1, sizeof *argv);
-				    sizeof *argv);
 				argv[argc++] = buf;
 
 				buf = NULL;
@@ -133,7 +139,7 @@ cmd_string_parse(const char *s, struct cmd_list **cmdlist, const char *file,
 			if (argc == 0)
 				goto out;
 
-			*cmdlist = cmd_list_parse(argc, argv, file, line, cause);
+			*cmdlist = cmd_list_parse(argc, argv, cause);
 			if (*cmdlist == NULL)
 				goto out;
 
@@ -141,10 +147,12 @@ cmd_string_parse(const char *s, struct cmd_list **cmdlist, const char *file,
 			goto out;
 		case '~':
 			if (buf == NULL) {
-				t = cmd_string_expand_tilde(s, &p);
+				if ((t = cmd_string_expand_tilde(s, &p)) == NULL)
-				if (t == NULL)
 					goto error;
-				cmd_string_copy(&buf, t, &len);
+				buf = xrealloc(buf, 1, len + strlen(t) + 1);
+				strlcpy(buf + len, t, strlen(t) + 1);
+				len += strlen(t);
+				xfree(t);
 				break;
 			}
 			/* FALLTHROUGH */
@@ -152,7 +160,7 @@ cmd_string_parse(const char *s, struct cmd_list **cmdlist, const char *file,
 			if (len >= SIZE_MAX - 2)
 				goto error;
 
-			buf = xrealloc(buf, len + 1);
+			buf = xrealloc(buf, 1, len + 1);
 			buf[len++] = ch;
 			break;
 		}
@@ -162,31 +170,18 @@ error:
 	xasprintf(cause, "invalid or unknown command: %s", s);
 
 out:
-	free(buf);
+	if (buf != NULL)
+		xfree(buf);
 
 	if (argv != NULL) {
 		for (i = 0; i < argc; i++)
-			free(argv[i]);
+			xfree(argv[i]);
-		free(argv);
+		xfree(argv);
 	}
 
 	return (rval);
 }
 
-void
-cmd_string_copy(char **dst, char *src, size_t *len)
-{
-	size_t srclen;
-
-	srclen = strlen(src);
-
-	*dst = xrealloc(*dst, *len + srclen + 1);
-	strlcpy(*dst + *len, src, srclen + 1);
-
-	*len += srclen;
-	free(src);
-}
-
 char *
 cmd_string_string(const char *s, size_t *p, char endch, int esc)
 {
@@ -226,22 +221,26 @@ cmd_string_string(const char *s, size_t *p, char endch, int esc)
 				break;
 			if ((t = cmd_string_variable(s, p)) == NULL)
 				goto error;
-			cmd_string_copy(&buf, t, &len);
+			buf = xrealloc(buf, 1, len + strlen(t) + 1);
+			strlcpy(buf + len, t, strlen(t) + 1);
+			len += strlen(t);
+			xfree(t);
 			continue;
 		}
 
 		if (len >= SIZE_MAX - 2)
 			goto error;
-		buf = xrealloc(buf, len + 1);
+		buf = xrealloc(buf, 1, len + 1);
 		buf[len++] = ch;
 	}
 
-	buf = xrealloc(buf, len + 1);
+	buf = xrealloc(buf, 1, len + 1);
 	buf[len] = '\0';
 	return (buf);
 
 error:
-	free(buf);
+	if (buf != NULL)
+		xfree(buf);
 	return (NULL);
 }
 
@@ -279,7 +278,7 @@ cmd_string_variable(const char *s, size_t *p)
 			return (t);
 		}
 
-		buf = xrealloc(buf, len + 1);
+		buf = xrealloc(buf, 1, len + 1);
 		buf[len++] = ch;
 
 		for (;;) {
@@ -289,7 +288,7 @@ cmd_string_variable(const char *s, size_t *p)
 			else {
 				if (len >= SIZE_MAX - 3)
 					goto error;
-				buf = xrealloc(buf, len + 1);
+				buf = xrealloc(buf, 1, len + 1);
 				buf[len++] = ch;
 			}
 		}
@@ -300,17 +299,18 @@ cmd_string_variable(const char *s, size_t *p)
 	if (ch != EOF && fch != '{')
 		cmd_string_ungetc(p); /* ch */
 
-	buf = xrealloc(buf, len + 1);
+	buf = xrealloc(buf, 1, len + 1);
 	buf[len] = '\0';
 
 	envent = environ_find(&global_environ, buf);
-	free(buf);
+	xfree(buf);
 	if (envent == NULL)
 		return (xstrdup(""));
 	return (xstrdup(envent->value));
 
 error:
-	free(buf);
+	if (buf != NULL)
+		xfree(buf);
 	return (NULL);
 }
 
@@ -319,13 +319,10 @@ cmd_string_expand_tilde(const char *s, size_t *p)
 {
 	struct passwd		*pw;
 	struct environ_entry	*envent;
-	char			*home, *path, *user, *cp;
+	char			*home, *path, *username;
-	int			 last;
 
 	home = NULL;
-
+	if (cmd_string_getc(s, p) == '/') {
-	last = cmd_string_getc(s, p);
-	if (last == EOF || last == '/' || last == ' '|| last == '\t') {
 		envent = environ_find(&global_environ, "HOME");
 		if (envent != NULL && *envent->value != '\0')
 			home = envent->value;
@@ -333,27 +330,15 @@ cmd_string_expand_tilde(const char *s, size_t *p)
 			home = pw->pw_dir;
 	} else {
 		cmd_string_ungetc(p);
-
+		if ((username = cmd_string_string(s, p, '/', 0)) == NULL)
-		cp = user = xmalloc(strlen(s));
+			return (NULL);
-		for (;;) {
+		if ((pw = getpwnam(username)) != NULL)
-			last = cmd_string_getc(s, p);
-			if (last == EOF || last == '/' || last == ' '|| last == '\t')
-				break;
-			*cp++ = last;
-		}
-		*cp = '\0';
-
-		if ((pw = getpwnam(user)) != NULL)
 			home = pw->pw_dir;
-		free(user);
+		xfree(username);
 	}
-
 	if (home == NULL)
 		return (NULL);
 
-	if (last != EOF)
+	xasprintf(&path, "%s/", home);
-		xasprintf(&path, "%s%c", home, last);
-	else
-		xasprintf(&path, "%s", home);
 	return (path);
 }

cmd-suspend-client.c

@@ -1,7 +1,7 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
- * Copyright (c) 2012 Nicholas Marriott <nicm@users.sourceforge.net>
+ * 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
@@ -18,38 +18,39 @@
 
 #include <sys/types.h>
 
+#include <stdlib.h>
 #include <string.h>
 
 #include "tmux.h"
 
-/* Get cell width. */
+/*
-u_int
+ * Suspend client with SIGTSTP.
-grid_cell_width(const struct grid_cell *gc)
+ */
-{
-	return (gc->xstate >> 4);
-}
 
-/* Get cell data. */
+int	cmd_suspend_client_exec(struct cmd *, struct cmd_ctx *);
-void
-grid_cell_get(const struct grid_cell *gc, struct utf8_data *ud)
-{
-	ud->size = gc->xstate & 0xf;
-	ud->width = gc->xstate >> 4;
-	memcpy(ud->data, gc->xdata, ud->size);
-}
 
-/* Set cell data. */
+const struct cmd_entry cmd_suspend_client_entry = {
-void
+	"suspend-client", "suspendc",
-grid_cell_set(struct grid_cell *gc, const struct utf8_data *ud)
+	"t:", 0, 0,
-{
+	CMD_TARGET_CLIENT_USAGE,
-	memcpy(gc->xdata, ud->data, ud->size);
+	0,
-	gc->xstate = (ud->width << 4) | ud->size;
+	NULL,
-}
+	NULL,
+	cmd_suspend_client_exec
+};
 
-/* Set a single character as cell data. */
+int
-void
+cmd_suspend_client_exec(struct cmd *self, struct cmd_ctx *ctx)
-grid_cell_one(struct grid_cell *gc, u_char ch)
 {
-	*gc->xdata = ch;
+	struct args	*args = self->args;
-	gc->xstate = (1 << 4) | 1;
+	struct client	*c;
+
+	if ((c = cmd_find_client(ctx, args_get(args, 't'))) == NULL)
+		return (-1);
+
+	tty_stop_tty(&c->tty);
+	c->flags |= CLIENT_SUSPENDED;
+	server_write_client(c, MSG_SUSPEND, NULL, 0);
+
+	return (0);
 }

cmd-swap-pane.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -26,18 +26,31 @@
  * Swap two panes.
  */
 
-enum cmd_retval	 cmd_swap_pane_exec(struct cmd *, struct cmd_q *);
+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,
+	cmd_swap_pane_key_binding,
+	NULL,
 	cmd_swap_pane_exec
 };
 
-enum cmd_retval
+void
-cmd_swap_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_swap_pane_key_binding(struct cmd *self, int key)
+{
+	self->args = args_create(0);
+	if (key == '{')
+		args_set(self->args, 'U', NULL);
+	else if (key == '}')
+		args_set(self->args, 'D', NULL);
+}
+
+int
+cmd_swap_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
 	struct winlink		*src_wl, *dst_wl;
@@ -46,11 +59,10 @@ cmd_swap_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	struct layout_cell	*src_lc, *dst_lc;
 	u_int			 sx, sy, xoff, yoff;
 
-	dst_wl = cmd_find_pane(cmdq, args_get(args, 't'), NULL, &dst_wp);
+	dst_wl = cmd_find_pane(ctx, args_get(args, 't'), NULL, &dst_wp);
 	if (dst_wl == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	dst_w = dst_wl->window;
-	server_unzoom_window(dst_w);
 
 	if (!args_has(args, 's')) {
 		src_w = dst_w;
@@ -62,24 +74,17 @@ cmd_swap_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 			src_wp = TAILQ_PREV(dst_wp, window_panes, entry);
 			if (src_wp == NULL)
 				src_wp = TAILQ_LAST(&dst_w->panes, window_panes);
-		} else {
+		} else
-			src_wl = cmd_find_pane_marked(cmdq, NULL, NULL,
+			return (0);
-			    &src_wp);
-			if (src_wl == NULL)
-				return (CMD_RETURN_ERROR);
-			src_w = src_wl->window;
-		}
 	} else {
-		src_wl = cmd_find_pane_marked(cmdq, args_get(args, 's'), NULL,
+		src_wl = cmd_find_pane(ctx, args_get(args, 's'), NULL, &src_wp);
-		    &src_wp);
 		if (src_wl == NULL)
-			return (CMD_RETURN_ERROR);
+			return (-1);
 		src_w = src_wl->window;
 	}
-	server_unzoom_window(src_w);
 
 	if (src_wp == dst_wp)
-		return (CMD_RETURN_NORMAL);
+		return (0);
 
 	tmp_wp = TAILQ_PREV(dst_wp, window_panes, entry);
 	TAILQ_REMOVE(&dst_w->panes, dst_wp, entry);
@@ -133,5 +138,5 @@ cmd_swap_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	server_redraw_window(src_w);
 	server_redraw_window(dst_w);
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-swap-window.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -26,18 +26,20 @@
  * Swap one window with another.
  */
 
-enum cmd_retval	cmd_swap_window_exec(struct cmd *, struct cmd_q *);
+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,
+	NULL,
+	NULL,
 	cmd_swap_window_exec
 };
 
-enum cmd_retval
+int
-cmd_swap_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_swap_window_exec(struct cmd *self, struct cmd_ctx *ctx)
 {
 	struct args		*args = self->args;
 	const char		*target_src, *target_dst;
@@ -47,22 +49,22 @@ cmd_swap_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	struct window		*w;
 
 	target_src = args_get(args, 's');
-	if ((wl_src = cmd_find_window_marked(cmdq, target_src, &src)) == NULL)
+	if ((wl_src = cmd_find_window(ctx, target_src, &src)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	target_dst = args_get(args, 't');
-	if ((wl_dst = cmd_find_window(cmdq, target_dst, &dst)) == NULL)
+	if ((wl_dst = cmd_find_window(ctx, target_dst, &dst)) == NULL)
-		return (CMD_RETURN_ERROR);
+		return (-1);
 
 	sg_src = session_group_find(src);
 	sg_dst = session_group_find(dst);
 	if (src != dst &&
 	    sg_src != NULL && sg_dst != NULL && sg_src == sg_dst) {
-		cmdq_error(cmdq, "can't move window, sessions are grouped");
+		ctx->error(ctx, "can't move window, sessions are grouped");
-		return (CMD_RETURN_ERROR);
+		return (-1);
 	}
 
 	if (wl_dst->window == wl_src->window)
-		return (CMD_RETURN_NORMAL);
+		return (0);
 
 	w = wl_dst->window;
 	wl_dst->window = wl_src->window;
@@ -81,5 +83,5 @@ cmd_swap_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	}
 	recalculate_sizes();
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-switch-client.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -27,114 +27,77 @@
  * Switch client to a different session.
  */
 
-enum cmd_retval	 cmd_switch_client_exec(struct cmd *, struct cmd_q *);
+void	cmd_switch_client_key_binding(struct cmd *, int);
+int	cmd_switch_client_exec(struct cmd *, struct cmd_ctx *);
 
 const struct cmd_entry cmd_switch_client_entry = {
 	"switch-client", "switchc",
-	"lc:Enpt:rT:", 0, 0,
+	"lc:npt:", 0, 0,
-	"[-Elnpr] [-c target-client] [-t target-session] [-T key-table]",
+	"[-lnp] [-c target-client] [-t target-session]",
-	CMD_READONLY,
+	0,
+	cmd_switch_client_key_binding,
+	NULL,
 	cmd_switch_client_exec
 };
 
-enum cmd_retval
+void
-cmd_switch_client_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_switch_client_key_binding(struct cmd *self, int key)
 {
-	struct args		*args = self->args;
+	self->args = args_create(0);
-	struct client		*c;
+	switch (key) {
-	struct session		*s = NULL;
+	case '(':
-	struct winlink		*wl = NULL;
+		args_set(self->args, 'p', NULL);
-	struct window 		*w = NULL;
+		break;
-	struct window_pane	*wp = NULL;
+	case ')':
-	const char		*tflag, *tablename, *update;
+		args_set(self->args, 'n', NULL);
-	struct key_table	*table;
+		break;
-
+	case 'L':
-	if ((c = cmd_find_client(cmdq, args_get(args, 'c'), 0)) == NULL)
+		args_set(self->args, 'l', NULL);
-		return (CMD_RETURN_ERROR);
+		break;
-
-	if (args_has(args, 'r')) {
-		if (c->flags & CLIENT_READONLY)
-			c->flags &= ~CLIENT_READONLY;
-		else
-			c->flags |= CLIENT_READONLY;
 	}
+}
 
-	tablename = args_get(args, 'T');
+int
-	if (tablename != NULL) {
+cmd_switch_client_exec(struct cmd *self, struct cmd_ctx *ctx)
-		table = key_bindings_get_table(tablename, 0);
+{
-		if (table == NULL) {
+	struct args	*args = self->args;
-			cmdq_error(cmdq, "table %s doesn't exist", tablename);
+	struct client	*c;
-			return (CMD_RETURN_ERROR);
+	struct session	*s;
-		}
-		table->references++;
-		key_bindings_unref_table(c->keytable);
-		c->keytable = table;
-	}
 
-	tflag = args_get(args, 't');
+	if ((c = cmd_find_client(ctx, args_get(args, 'c'))) == NULL)
+		return (-1);
+
+	s = NULL;
 	if (args_has(args, 'n')) {
 		if ((s = session_next_session(c->session)) == NULL) {
-			cmdq_error(cmdq, "can't find next session");
+			ctx->error(ctx, "can't find next session");
-			return (CMD_RETURN_ERROR);
+			return (-1);
 		}
 	} else if (args_has(args, 'p')) {
 		if ((s = session_previous_session(c->session)) == NULL) {
-			cmdq_error(cmdq, "can't find previous session");
+			ctx->error(ctx, "can't find previous session");
-			return (CMD_RETURN_ERROR);
+			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) {
-			cmdq_error(cmdq, "can't find last session");
+			ctx->error(ctx, "can't find last session");
-			return (CMD_RETURN_ERROR);
+			return (-1);
-		}
-	} else {
-		if (tflag == NULL) {
-			if ((s = cmd_find_session(cmdq, tflag, 1)) == NULL)
-				return (CMD_RETURN_ERROR);
-		} else if (tflag[strcspn(tflag, ":.")] != '\0') {
-			if ((wl = cmd_find_pane(cmdq, tflag, &s, &wp)) == NULL)
-				return (CMD_RETURN_ERROR);
-		} else {
-			if ((s = cmd_find_session(cmdq, tflag, 1)) == NULL)
-				return (CMD_RETURN_ERROR);
-			w = window_find_by_id_str(tflag);
-			if (w == NULL) {
-				wp = window_pane_find_by_id_str(tflag);
-				if (wp != NULL)
-					w = wp->window;
-			}
-			if (w != NULL)
-				wl = winlink_find_by_window(&s->windows, w);
 		}
+	} else
+		s = cmd_find_session(ctx, args_get(args, 't'), 0);
+	if (s == NULL)
+		return (-1);
 
-		if (cmdq->client == NULL)
+	if (c->session != NULL)
-			return (CMD_RETURN_NORMAL);
-
-		if (wl != NULL) {
-			if (wp != NULL)
-				window_set_active_pane(wp->window, wp);
-			session_set_current(s, wl);
-		}
-	}
-
-	if (c != NULL && !args_has(args, 'E')) {
-		update = options_get_string(&s->options, "update-environment");
-		environ_update(update, &c->environ, &s->environ);
-	}
-
-	if (c->session != NULL && c->session != s)
 		c->last_session = c->session;
 	c->session = s;
-	status_timer_start(c);
+	session_update_activity(s);
-	session_update_activity(s, NULL);
-	gettimeofday(&s->last_attached_time, NULL);
 
 	recalculate_sizes();
 	server_check_unattached();
 	server_redraw_client(c);
-	s->curw->flags &= ~WINLINK_ALERTFLAGS;
 
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-unbind-key.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -18,84 +18,71 @@
 
 #include <sys/types.h>
 
-#include <stdlib.h>
-
 #include "tmux.h"
 
 /*
  * Unbind key from command.
  */
 
-enum cmd_retval	 cmd_unbind_key_exec(struct cmd *, struct cmd_q *);
+int	cmd_unbind_key_check(struct args *);
-enum cmd_retval	 cmd_unbind_key_mode_table(struct cmd *, struct cmd_q *, int);
+int	cmd_unbind_key_exec(struct cmd *, struct cmd_ctx *);
+
+int	cmd_unbind_key_table(struct cmd *, struct cmd_ctx *, int);
 
 const struct cmd_entry cmd_unbind_key_entry = {
 	"unbind-key", "unbind",
-	"acnt:T:", 0, 1,
+	"acnt:", 0, 1,
-	"[-acn] [-t mode-table] [-T key-table] key",
+	"[-acn] [-t key-table] key",
 	0,
+	NULL,
+	cmd_unbind_key_check,
 	cmd_unbind_key_exec
 };
 
-enum cmd_retval
+int
-cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_unbind_key_check(struct args *args)
 {
-	struct args	*args = self->args;
+	if (args_has(args, 'a') && (args->argc != 0 || args_has(args, 't')))
-	int		 key;
+	    return (-1);
-	const char	*tablename;
+	if (!args_has(args, 'a') && args->argc != 1)
+		return (-1);
+	return (0);
+}
 
-	if (!args_has(args, 'a')) {
+int
-		if (args->argc != 1) {
+cmd_unbind_key_exec(struct cmd *self, unused struct cmd_ctx *ctx)
-			cmdq_error(cmdq, "missing key");
+{
-			return (CMD_RETURN_ERROR);
+	struct args		*args = self->args;
+	struct key_binding	*bd;
+	int			 key;
+
+	if (args_has(args, 'a')) {
+		while (!SPLAY_EMPTY(&key_bindings)) {
+			bd = SPLAY_ROOT(&key_bindings);
+			SPLAY_REMOVE(key_bindings, &key_bindings, bd);
+			cmd_list_free(bd->cmdlist);
+			xfree(bd);
 		}
-		key = key_string_lookup_string(args->argv[0]);
+		return (0);
-		if (key == KEYC_NONE) {
+	}
-			cmdq_error(cmdq, "unknown key: %s", args->argv[0]);
+
-			return (CMD_RETURN_ERROR);
+	key = key_string_lookup_string(args->argv[0]);
-		}
+	if (key == KEYC_NONE) {
-	} else {
+		ctx->error(ctx, "unknown key: %s", args->argv[0]);
-		if (args->argc != 0) {
+		return (-1);
-			cmdq_error(cmdq, "key given with -a");
-			return (CMD_RETURN_ERROR);
-		}
-		key = KEYC_NONE;
 	}
 
 	if (args_has(args, 't'))
-		return (cmd_unbind_key_mode_table(self, cmdq, key));
+		return (cmd_unbind_key_table(self, ctx, key));
 
-	if (key == KEYC_NONE) {
+	if (!args_has(args, 'n'))
-		tablename = args_get(args, 'T');
+		key |= KEYC_PREFIX;
-		if (tablename == NULL) {
+	key_bindings_remove(key);
-			key_bindings_remove_table("root");
+	return (0);
-			key_bindings_remove_table("prefix");
-			return (CMD_RETURN_NORMAL);
-		}
-		if (key_bindings_get_table(tablename, 0) == NULL) {
-			cmdq_error(cmdq, "table %s doesn't exist", tablename);
-			return (CMD_RETURN_ERROR);
-		}
-		key_bindings_remove_table(tablename);
-		return (CMD_RETURN_NORMAL);
-	}
-
-	if (args_has(args, 'T')) {
-		tablename = args_get(args, 'T');
-		if (key_bindings_get_table(tablename, 0) == NULL) {
-			cmdq_error(cmdq, "table %s doesn't exist", tablename);
-			return (CMD_RETURN_ERROR);
-		}
-	} else if (args_has(args, 'n'))
-		tablename = "root";
-	else
-		tablename = "prefix";
-	key_bindings_remove(tablename, key);
-	return (CMD_RETURN_NORMAL);
 }
 
-enum cmd_retval
+int
-cmd_unbind_key_mode_table(struct cmd *self, struct cmd_q *cmdq, int key)
+cmd_unbind_key_table(struct cmd *self, struct cmd_ctx *ctx, int key)
 {
 	struct args			*args = self->args;
 	const char			*tablename;
@@ -104,24 +91,15 @@ cmd_unbind_key_mode_table(struct cmd *self, struct cmd_q *cmdq, int key)
 
 	tablename = args_get(args, 't');
 	if ((mtab = mode_key_findtable(tablename)) == NULL) {
-		cmdq_error(cmdq, "unknown key table: %s", tablename);
+		ctx->error(ctx, "unknown key table: %s", tablename);
-		return (CMD_RETURN_ERROR);
+		return (-1);
-	}
-
-	if (key == KEYC_NONE) {
-		while (!RB_EMPTY(mtab->tree)) {
-			mbind = RB_ROOT(mtab->tree);
-			RB_REMOVE(mode_key_tree, mtab->tree, mbind);
-			free(mbind);
-		}
-		return (CMD_RETURN_NORMAL);
 	}
 
 	mtmp.key = key;
 	mtmp.mode = !!args_has(args, 'c');
-	if ((mbind = RB_FIND(mode_key_tree, mtab->tree, &mtmp)) != NULL) {
+	if ((mbind = SPLAY_FIND(mode_key_tree, mtab->tree, &mtmp)) != NULL) {
-		RB_REMOVE(mode_key_tree, mtab->tree, mbind);
+		SPLAY_REMOVE(mode_key_tree, mtab->tree, mbind);
-		free(mbind);
+		xfree(mbind);
 	}
-	return (CMD_RETURN_NORMAL);
+	return (0);
 }

cmd-unlink-window.c

@@ -0,0 +1,70 @@
+/* $Id$ */
+
+/*
+ * 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"
+
+/*
+ * Unlink a window, unless it would be destroyed by doing so (only one link).
+ */
+
+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,
+	NULL,
+	NULL,
+	cmd_unlink_window_exec
+};
+
+int
+cmd_unlink_window_exec(struct cmd *self, struct cmd_ctx *ctx)
+{
+	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, args_get(args, 't'), &s)) == NULL)
+		return (-1);
+	w = wl->window;
+
+	sg = session_group_find(s);
+	if (sg != NULL) {
+		references = 0;
+		TAILQ_FOREACH(s2, &sg->sessions, gentry)
+			references++;
+	} else
+		references = 1;
+
+	if (!args_has(self->args, 'k') && w->references == references) {
+		ctx->error(ctx, "window is only linked to one session");
+		return (-1);
+	}
+
+	server_unlink_window(s, wl);
+	recalculate_sizes();
+
+	return (0);
+}

cmd-wait-for.c

@@ -1,252 +0,0 @@
-/* $OpenBSD$ */
-
-/*
- * Copyright (c) 2013 Nicholas Marriott <nicm@users.sourceforge.net>
- * Copyright (c) 2013 Thiago de Arruda <tpadilha84@gmail.com>
- *
- * 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"
-
-/*
- * Block or wake a client on a named wait channel.
- */
-
-enum cmd_retval cmd_wait_for_exec(struct cmd *, struct cmd_q *);
-
-const struct cmd_entry cmd_wait_for_entry = {
-	"wait-for", "wait",
-	"LSU", 1, 1,
-	"[-L|-S|-U] channel",
-	0,
-	cmd_wait_for_exec
-};
-
-struct wait_channel {
-	const char	       *name;
-	int			locked;
-	int			woken;
-
-	TAILQ_HEAD(, cmd_q)	waiters;
-	TAILQ_HEAD(, cmd_q)	lockers;
-
-	RB_ENTRY(wait_channel)	entry;
-};
-RB_HEAD(wait_channels, wait_channel);
-struct wait_channels wait_channels = RB_INITIALIZER(wait_channels);
-
-int	wait_channel_cmp(struct wait_channel *, struct wait_channel *);
-RB_PROTOTYPE(wait_channels, wait_channel, entry, wait_channel_cmp);
-RB_GENERATE(wait_channels, wait_channel, entry, wait_channel_cmp);
-
-int
-wait_channel_cmp(struct wait_channel *wc1, struct wait_channel *wc2)
-{
-	return (strcmp(wc1->name, wc2->name));
-}
-
-enum cmd_retval	cmd_wait_for_signal(struct cmd_q *, const char *,
-		    struct wait_channel *);
-enum cmd_retval	cmd_wait_for_wait(struct cmd_q *, const char *,
-		    struct wait_channel *);
-enum cmd_retval	cmd_wait_for_lock(struct cmd_q *, const char *,
-		    struct wait_channel *);
-enum cmd_retval	cmd_wait_for_unlock(struct cmd_q *, const char *,
-		    struct wait_channel *);
-
-struct wait_channel	*cmd_wait_for_add(const char *);
-void			 cmd_wait_for_remove(struct wait_channel *wc);
-
-struct wait_channel *
-cmd_wait_for_add(const char *name)
-{
-	struct wait_channel *wc;
-
-	wc = xmalloc(sizeof *wc);
-	wc->name = xstrdup(name);
-
-	wc->locked = 0;
-	wc->woken = 0;
-
-	TAILQ_INIT(&wc->waiters);
-	TAILQ_INIT(&wc->lockers);
-
-	RB_INSERT(wait_channels, &wait_channels, wc);
-
-	log_debug("add wait channel %s", wc->name);
-
-	return (wc);
-}
-
-void
-cmd_wait_for_remove(struct wait_channel *wc)
-{
-	if (wc->locked)
-		return;
-	if (!TAILQ_EMPTY(&wc->waiters) || !wc->woken)
-		return;
-
-	log_debug("remove wait channel %s", wc->name);
-
-	RB_REMOVE(wait_channels, &wait_channels, wc);
-
-	free((void *)wc->name);
-	free(wc);
-}
-
-enum cmd_retval
-cmd_wait_for_exec(struct cmd *self, unused struct cmd_q *cmdq)
-{
-	struct args     	*args = self->args;
-	const char		*name = args->argv[0];
-	struct wait_channel	*wc, wc0;
-
-	wc0.name = name;
-	wc = RB_FIND(wait_channels, &wait_channels, &wc0);
-
-	if (args_has(args, 'S'))
-		return (cmd_wait_for_signal(cmdq, name, wc));
-	if (args_has(args, 'L'))
-		return (cmd_wait_for_lock(cmdq, name, wc));
-	if (args_has(args, 'U'))
-		return (cmd_wait_for_unlock(cmdq, name, wc));
-	return (cmd_wait_for_wait(cmdq, name, wc));
-}
-
-enum cmd_retval
-cmd_wait_for_signal(unused struct cmd_q *cmdq, const char *name,
-    struct wait_channel *wc)
-{
-	struct cmd_q	*wq, *wq1;
-
-	if (wc == NULL)
-		wc = cmd_wait_for_add(name);
-
-	if (TAILQ_EMPTY(&wc->waiters) && !wc->woken) {
-		log_debug("signal wait channel %s, no waiters", wc->name);
-		wc->woken = 1;
-		return (CMD_RETURN_NORMAL);
-	}
-	log_debug("signal wait channel %s, with waiters", wc->name);
-
-	TAILQ_FOREACH_SAFE(wq, &wc->waiters, waitentry, wq1) {
-		TAILQ_REMOVE(&wc->waiters, wq, waitentry);
-		if (!cmdq_free(wq))
-			cmdq_continue(wq);
-	}
-
-	cmd_wait_for_remove(wc);
-	return (CMD_RETURN_NORMAL);
-}
-
-enum cmd_retval
-cmd_wait_for_wait(struct cmd_q *cmdq, const char *name,
-    struct wait_channel *wc)
-{
-	struct client	*c = cmdq->client;
-
-	if (c == NULL || c->session != NULL) {
-		cmdq_error(cmdq, "not able to wait");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (wc == NULL)
-		wc = cmd_wait_for_add(name);
-
-	if (wc->woken) {
-		log_debug("wait channel %s already woken (client %d)", wc->name,
-		    c->tty.fd);
-		cmd_wait_for_remove(wc);
-		return (CMD_RETURN_NORMAL);
-	}
-	log_debug("wait channel %s not woken (client %d)", wc->name, c->tty.fd);
-
-	TAILQ_INSERT_TAIL(&wc->waiters, cmdq, waitentry);
-	cmdq->references++;
-
-	return (CMD_RETURN_WAIT);
-}
-
-enum cmd_retval
-cmd_wait_for_lock(struct cmd_q *cmdq, const char *name,
-    struct wait_channel *wc)
-{
-	if (cmdq->client == NULL || cmdq->client->session != NULL) {
-		cmdq_error(cmdq, "not able to lock");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (wc == NULL)
-		wc = cmd_wait_for_add(name);
-
-	if (wc->locked) {
-		TAILQ_INSERT_TAIL(&wc->lockers, cmdq, waitentry);
-		cmdq->references++;
-		return (CMD_RETURN_WAIT);
-	}
-	wc->locked = 1;
-
-	return (CMD_RETURN_NORMAL);
-}
-
-enum cmd_retval
-cmd_wait_for_unlock(struct cmd_q *cmdq, const char *name,
-    struct wait_channel *wc)
-{
-	struct cmd_q	*wq;
-
-	if (wc == NULL || !wc->locked) {
-		cmdq_error(cmdq, "channel %s not locked", name);
-		return (CMD_RETURN_ERROR);
-	}
-
-	if ((wq = TAILQ_FIRST(&wc->lockers)) != NULL) {
-		TAILQ_REMOVE(&wc->lockers, wq, waitentry);
-		if (!cmdq_free(wq))
-			cmdq_continue(wq);
-	} else {
-		wc->locked = 0;
-		cmd_wait_for_remove(wc);
-	}
-
-	return (CMD_RETURN_NORMAL);
-}
-
-void
-cmd_wait_for_flush(void)
-{
-	struct wait_channel	*wc, *wc1;
-	struct cmd_q		*wq, *wq1;
-
-	RB_FOREACH_SAFE(wc, wait_channels, &wait_channels, wc1) {
-		TAILQ_FOREACH_SAFE(wq, &wc->waiters, waitentry, wq1) {
-			TAILQ_REMOVE(&wc->waiters, wq, waitentry);
-			if (!cmdq_free(wq))
-				cmdq_continue(wq);
-		}
-		wc->woken = 1;
-		TAILQ_FOREACH_SAFE(wq, &wc->lockers, waitentry, wq1) {
-			TAILQ_REMOVE(&wc->lockers, wq, waitentry);
-			if (!cmdq_free(wq))
-				cmdq_continue(wq);
-		}
-		wc->locked = 0;
-		cmd_wait_for_remove(wc);
-	}
-}

colour.c

@@ -1,4 +1,4 @@
-/* $OpenBSD$ */
+/* $Id$ */
 
 /*
  * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
@@ -19,6 +19,7 @@
 #include <sys/types.h>
 
 #include <ctype.h>
+#include <math.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -29,305 +30,92 @@
  * of the 256 colour palette.
  */
 
+/* An RGB colour. */
 struct colour_rgb {
-	u_char  i;
 	u_char	r;
 	u_char	g;
 	u_char	b;
 };
 
-const struct colour_rgb colour_from_256[] = {
+/* 256 colour RGB table, generated on first use. */
-	{   0, 0x00, 0x00, 0x00 }, {   1, 0x00, 0x00, 0x5f },
+struct colour_rgb *colour_rgb_256;
-	{   2, 0x00, 0x00, 0x87 }, {   3, 0x00, 0x00, 0xaf },
-	{   4, 0x00, 0x00, 0xd7 }, {   5, 0x00, 0x00, 0xff },
-	{   6, 0x00, 0x5f, 0x00 }, {   7, 0x00, 0x5f, 0x5f },
-	{   8, 0x00, 0x5f, 0x87 }, {   9, 0x00, 0x5f, 0xaf },
-	{  10, 0x00, 0x5f, 0xd7 }, {  11, 0x00, 0x5f, 0xff },
-	{  12, 0x00, 0x87, 0x00 }, {  13, 0x00, 0x87, 0x5f },
-	{  14, 0x00, 0x87, 0x87 }, {  15, 0x00, 0x87, 0xaf },
-	{  16, 0x00, 0x87, 0xd7 }, {  17, 0x00, 0x87, 0xff },
-	{  18, 0x00, 0xaf, 0x00 }, {  19, 0x00, 0xaf, 0x5f },
-	{  20, 0x00, 0xaf, 0x87 }, {  21, 0x00, 0xaf, 0xaf },
-	{  22, 0x00, 0xaf, 0xd7 }, {  23, 0x00, 0xaf, 0xff },
-	{  24, 0x00, 0xd7, 0x00 }, {  25, 0x00, 0xd7, 0x5f },
-	{  26, 0x00, 0xd7, 0x87 }, {  27, 0x00, 0xd7, 0xaf },
-	{  28, 0x00, 0xd7, 0xd7 }, {  29, 0x00, 0xd7, 0xff },
-	{  30, 0x00, 0xff, 0x00 }, {  31, 0x00, 0xff, 0x5f },
-	{  32, 0x00, 0xff, 0x87 }, {  33, 0x00, 0xff, 0xaf },
-	{  34, 0x00, 0xff, 0xd7 }, {  35, 0x00, 0xff, 0xff },
-	{  36, 0x5f, 0x00, 0x00 }, {  37, 0x5f, 0x00, 0x5f },
-	{  38, 0x5f, 0x00, 0x87 }, {  39, 0x5f, 0x00, 0xaf },
-	{  40, 0x5f, 0x00, 0xd7 }, {  41, 0x5f, 0x00, 0xff },
-	{  42, 0x5f, 0x5f, 0x00 }, {  43, 0x5f, 0x5f, 0x5f },
-	{  44, 0x5f, 0x5f, 0x87 }, {  45, 0x5f, 0x5f, 0xaf },
-	{  46, 0x5f, 0x5f, 0xd7 }, {  47, 0x5f, 0x5f, 0xff },
-	{  48, 0x5f, 0x87, 0x00 }, {  49, 0x5f, 0x87, 0x5f },
-	{  50, 0x5f, 0x87, 0x87 }, {  51, 0x5f, 0x87, 0xaf },
-	{  52, 0x5f, 0x87, 0xd7 }, {  53, 0x5f, 0x87, 0xff },
-	{  54, 0x5f, 0xaf, 0x00 }, {  55, 0x5f, 0xaf, 0x5f },
-	{  56, 0x5f, 0xaf, 0x87 }, {  57, 0x5f, 0xaf, 0xaf },
-	{  58, 0x5f, 0xaf, 0xd7 }, {  59, 0x5f, 0xaf, 0xff },
-	{  60, 0x5f, 0xd7, 0x00 }, {  61, 0x5f, 0xd7, 0x5f },
-	{  62, 0x5f, 0xd7, 0x87 }, {  63, 0x5f, 0xd7, 0xaf },
-	{  64, 0x5f, 0xd7, 0xd7 }, {  65, 0x5f, 0xd7, 0xff },
-	{  66, 0x5f, 0xff, 0x00 }, {  67, 0x5f, 0xff, 0x5f },
-	{  68, 0x5f, 0xff, 0x87 }, {  69, 0x5f, 0xff, 0xaf },
-	{  70, 0x5f, 0xff, 0xd7 }, {  71, 0x5f, 0xff, 0xff },
-	{  72, 0x87, 0x00, 0x00 }, {  73, 0x87, 0x00, 0x5f },
-	{  74, 0x87, 0x00, 0x87 }, {  75, 0x87, 0x00, 0xaf },
-	{  76, 0x87, 0x00, 0xd7 }, {  77, 0x87, 0x00, 0xff },
-	{  78, 0x87, 0x5f, 0x00 }, {  79, 0x87, 0x5f, 0x5f },
-	{  80, 0x87, 0x5f, 0x87 }, {  81, 0x87, 0x5f, 0xaf },
-	{  82, 0x87, 0x5f, 0xd7 }, {  83, 0x87, 0x5f, 0xff },
-	{  84, 0x87, 0x87, 0x00 }, {  85, 0x87, 0x87, 0x5f },
-	{  86, 0x87, 0x87, 0x87 }, {  87, 0x87, 0x87, 0xaf },
-	{  88, 0x87, 0x87, 0xd7 }, {  89, 0x87, 0x87, 0xff },
-	{  90, 0x87, 0xaf, 0x00 }, {  91, 0x87, 0xaf, 0x5f },
-	{  92, 0x87, 0xaf, 0x87 }, {  93, 0x87, 0xaf, 0xaf },
-	{  94, 0x87, 0xaf, 0xd7 }, {  95, 0x87, 0xaf, 0xff },
-	{  96, 0x87, 0xd7, 0x00 }, {  97, 0x87, 0xd7, 0x5f },
-	{  98, 0x87, 0xd7, 0x87 }, {  99, 0x87, 0xd7, 0xaf },
-	{ 100, 0x87, 0xd7, 0xd7 }, { 101, 0x87, 0xd7, 0xff },
-	{ 102, 0x87, 0xff, 0x00 }, { 103, 0x87, 0xff, 0x5f },
-	{ 104, 0x87, 0xff, 0x87 }, { 105, 0x87, 0xff, 0xaf },
-	{ 106, 0x87, 0xff, 0xd7 }, { 107, 0x87, 0xff, 0xff },
-	{ 108, 0xaf, 0x00, 0x00 }, { 109, 0xaf, 0x00, 0x5f },
-	{ 110, 0xaf, 0x00, 0x87 }, { 111, 0xaf, 0x00, 0xaf },
-	{ 112, 0xaf, 0x00, 0xd7 }, { 113, 0xaf, 0x00, 0xff },
-	{ 114, 0xaf, 0x5f, 0x00 }, { 115, 0xaf, 0x5f, 0x5f },
-	{ 116, 0xaf, 0x5f, 0x87 }, { 117, 0xaf, 0x5f, 0xaf },
-	{ 118, 0xaf, 0x5f, 0xd7 }, { 119, 0xaf, 0x5f, 0xff },
-	{ 120, 0xaf, 0x87, 0x00 }, { 121, 0xaf, 0x87, 0x5f },
-	{ 122, 0xaf, 0x87, 0x87 }, { 123, 0xaf, 0x87, 0xaf },
-	{ 124, 0xaf, 0x87, 0xd7 }, { 125, 0xaf, 0x87, 0xff },
-	{ 126, 0xaf, 0xaf, 0x00 }, { 127, 0xaf, 0xaf, 0x5f },
-	{ 128, 0xaf, 0xaf, 0x87 }, { 129, 0xaf, 0xaf, 0xaf },
-	{ 130, 0xaf, 0xaf, 0xd7 }, { 131, 0xaf, 0xaf, 0xff },
-	{ 132, 0xaf, 0xd7, 0x00 }, { 133, 0xaf, 0xd7, 0x5f },
-	{ 134, 0xaf, 0xd7, 0x87 }, { 135, 0xaf, 0xd7, 0xaf },
-	{ 136, 0xaf, 0xd7, 0xd7 }, { 137, 0xaf, 0xd7, 0xff },
-	{ 138, 0xaf, 0xff, 0x00 }, { 139, 0xaf, 0xff, 0x5f },
-	{ 140, 0xaf, 0xff, 0x87 }, { 141, 0xaf, 0xff, 0xaf },
-	{ 142, 0xaf, 0xff, 0xd7 }, { 143, 0xaf, 0xff, 0xff },
-	{ 144, 0xd7, 0x00, 0x00 }, { 145, 0xd7, 0x00, 0x5f },
-	{ 146, 0xd7, 0x00, 0x87 }, { 147, 0xd7, 0x00, 0xaf },
-	{ 148, 0xd7, 0x00, 0xd7 }, { 149, 0xd7, 0x00, 0xff },
-	{ 150, 0xd7, 0x5f, 0x00 }, { 151, 0xd7, 0x5f, 0x5f },
-	{ 152, 0xd7, 0x5f, 0x87 }, { 153, 0xd7, 0x5f, 0xaf },
-	{ 154, 0xd7, 0x5f, 0xd7 }, { 155, 0xd7, 0x5f, 0xff },
-	{ 156, 0xd7, 0x87, 0x00 }, { 157, 0xd7, 0x87, 0x5f },
-	{ 158, 0xd7, 0x87, 0x87 }, { 159, 0xd7, 0x87, 0xaf },
-	{ 160, 0xd7, 0x87, 0xd7 }, { 161, 0xd7, 0x87, 0xff },
-	{ 162, 0xd7, 0xaf, 0x00 }, { 163, 0xd7, 0xaf, 0x5f },
-	{ 164, 0xd7, 0xaf, 0x87 }, { 165, 0xd7, 0xaf, 0xaf },
-	{ 166, 0xd7, 0xaf, 0xd7 }, { 167, 0xd7, 0xaf, 0xff },
-	{ 168, 0xd7, 0xd7, 0x00 }, { 169, 0xd7, 0xd7, 0x5f },
-	{ 170, 0xd7, 0xd7, 0x87 }, { 171, 0xd7, 0xd7, 0xaf },
-	{ 172, 0xd7, 0xd7, 0xd7 }, { 173, 0xd7, 0xd7, 0xff },
-	{ 174, 0xd7, 0xff, 0x00 }, { 175, 0xd7, 0xff, 0x5f },
-	{ 176, 0xd7, 0xff, 0x87 }, { 177, 0xd7, 0xff, 0xaf },
-	{ 178, 0xd7, 0xff, 0xd7 }, { 179, 0xd7, 0xff, 0xff },
-	{ 180, 0xff, 0x00, 0x00 }, { 181, 0xff, 0x00, 0x5f },
-	{ 182, 0xff, 0x00, 0x87 }, { 183, 0xff, 0x00, 0xaf },
-	{ 184, 0xff, 0x00, 0xd7 }, { 185, 0xff, 0x00, 0xff },
-	{ 186, 0xff, 0x5f, 0x00 }, { 187, 0xff, 0x5f, 0x5f },
-	{ 188, 0xff, 0x5f, 0x87 }, { 189, 0xff, 0x5f, 0xaf },
-	{ 190, 0xff, 0x5f, 0xd7 }, { 191, 0xff, 0x5f, 0xff },
-	{ 192, 0xff, 0x87, 0x00 }, { 193, 0xff, 0x87, 0x5f },
-	{ 194, 0xff, 0x87, 0x87 }, { 195, 0xff, 0x87, 0xaf },
-	{ 196, 0xff, 0x87, 0xd7 }, { 197, 0xff, 0x87, 0xff },
-	{ 198, 0xff, 0xaf, 0x00 }, { 199, 0xff, 0xaf, 0x5f },
-	{ 200, 0xff, 0xaf, 0x87 }, { 201, 0xff, 0xaf, 0xaf },
-	{ 202, 0xff, 0xaf, 0xd7 }, { 203, 0xff, 0xaf, 0xff },
-	{ 204, 0xff, 0xd7, 0x00 }, { 205, 0xff, 0xd7, 0x5f },
-	{ 206, 0xff, 0xd7, 0x87 }, { 207, 0xff, 0xd7, 0xaf },
-	{ 208, 0xff, 0xd7, 0xd7 }, { 209, 0xff, 0xd7, 0xff },
-	{ 210, 0xff, 0xff, 0x00 }, { 211, 0xff, 0xff, 0x5f },
-	{ 212, 0xff, 0xff, 0x87 }, { 213, 0xff, 0xff, 0xaf },
-	{ 214, 0xff, 0xff, 0xd7 }, { 215, 0xff, 0xff, 0xff },
-	{ 216, 0x08, 0x08, 0x08 }, { 217, 0x12, 0x12, 0x12 },
-	{ 218, 0x1c, 0x1c, 0x1c }, { 219, 0x26, 0x26, 0x26 },
-	{ 220, 0x30, 0x30, 0x30 }, { 221, 0x3a, 0x3a, 0x3a },
-	{ 222, 0x44, 0x44, 0x44 }, { 223, 0x4e, 0x4e, 0x4e },
-	{ 224, 0x58, 0x58, 0x58 }, { 225, 0x62, 0x62, 0x62 },
-	{ 226, 0x6c, 0x6c, 0x6c }, { 227, 0x76, 0x76, 0x76 },
-	{ 228, 0x80, 0x80, 0x80 }, { 229, 0x8a, 0x8a, 0x8a },
-	{ 230, 0x94, 0x94, 0x94 }, { 231, 0x9e, 0x9e, 0x9e },
-	{ 232, 0xa8, 0xa8, 0xa8 }, { 233, 0xb2, 0xb2, 0xb2 },
-	{ 234, 0xbc, 0xbc, 0xbc }, { 235, 0xc6, 0xc6, 0xc6 },
-	{ 236, 0xd0, 0xd0, 0xd0 }, { 237, 0xda, 0xda, 0xda },
-	{ 238, 0xe4, 0xe4, 0xe4 }, { 239, 0xee, 0xee, 0xee },
-};
-const struct colour_rgb colour_to_256[] = {
-	{   0, 0x00, 0x00, 0x00 }, {   1, 0x00, 0x00, 0x5f },
-	{   2, 0x00, 0x00, 0x87 }, {   3, 0x00, 0x00, 0xaf },
-	{   4, 0x00, 0x00, 0xd7 }, {   5, 0x00, 0x00, 0xff },
-	{   6, 0x00, 0x5f, 0x00 }, {   7, 0x00, 0x5f, 0x5f },
-	{   8, 0x00, 0x5f, 0x87 }, {   9, 0x00, 0x5f, 0xaf },
-	{  10, 0x00, 0x5f, 0xd7 }, {  11, 0x00, 0x5f, 0xff },
-	{  12, 0x00, 0x87, 0x00 }, {  13, 0x00, 0x87, 0x5f },
-	{  14, 0x00, 0x87, 0x87 }, {  15, 0x00, 0x87, 0xaf },
-	{  16, 0x00, 0x87, 0xd7 }, {  17, 0x00, 0x87, 0xff },
-	{  18, 0x00, 0xaf, 0x00 }, {  19, 0x00, 0xaf, 0x5f },
-	{  20, 0x00, 0xaf, 0x87 }, {  21, 0x00, 0xaf, 0xaf },
-	{  22, 0x00, 0xaf, 0xd7 }, {  23, 0x00, 0xaf, 0xff },
-	{  24, 0x00, 0xd7, 0x00 }, {  25, 0x00, 0xd7, 0x5f },
-	{  26, 0x00, 0xd7, 0x87 }, {  27, 0x00, 0xd7, 0xaf },
-	{  28, 0x00, 0xd7, 0xd7 }, {  29, 0x00, 0xd7, 0xff },
-	{  30, 0x00, 0xff, 0x00 }, {  31, 0x00, 0xff, 0x5f },
-	{  32, 0x00, 0xff, 0x87 }, {  33, 0x00, 0xff, 0xaf },
-	{  34, 0x00, 0xff, 0xd7 }, {  35, 0x00, 0xff, 0xff },
-	{ 216, 0x08, 0x08, 0x08 }, { 217, 0x12, 0x12, 0x12 },
-	{ 218, 0x1c, 0x1c, 0x1c }, { 219, 0x26, 0x26, 0x26 },
-	{ 220, 0x30, 0x30, 0x30 }, { 221, 0x3a, 0x3a, 0x3a },
-	{ 222, 0x44, 0x44, 0x44 }, { 223, 0x4e, 0x4e, 0x4e },
-	{ 224, 0x58, 0x58, 0x58 }, {  36, 0x5f, 0x00, 0x00 },
-	{  37, 0x5f, 0x00, 0x5f }, {  38, 0x5f, 0x00, 0x87 },
-	{  39, 0x5f, 0x00, 0xaf }, {  40, 0x5f, 0x00, 0xd7 },
-	{  41, 0x5f, 0x00, 0xff }, {  42, 0x5f, 0x5f, 0x00 },
-	{  43, 0x5f, 0x5f, 0x5f }, {  44, 0x5f, 0x5f, 0x87 },
-	{  45, 0x5f, 0x5f, 0xaf }, {  46, 0x5f, 0x5f, 0xd7 },
-	{  47, 0x5f, 0x5f, 0xff }, {  48, 0x5f, 0x87, 0x00 },
-	{  49, 0x5f, 0x87, 0x5f }, {  50, 0x5f, 0x87, 0x87 },
-	{  51, 0x5f, 0x87, 0xaf }, {  52, 0x5f, 0x87, 0xd7 },
-	{  53, 0x5f, 0x87, 0xff }, {  54, 0x5f, 0xaf, 0x00 },
-	{  55, 0x5f, 0xaf, 0x5f }, {  56, 0x5f, 0xaf, 0x87 },
-	{  57, 0x5f, 0xaf, 0xaf }, {  58, 0x5f, 0xaf, 0xd7 },
-	{  59, 0x5f, 0xaf, 0xff }, {  60, 0x5f, 0xd7, 0x00 },
-	{  61, 0x5f, 0xd7, 0x5f }, {  62, 0x5f, 0xd7, 0x87 },
-	{  63, 0x5f, 0xd7, 0xaf }, {  64, 0x5f, 0xd7, 0xd7 },
-	{  65, 0x5f, 0xd7, 0xff }, {  66, 0x5f, 0xff, 0x00 },
-	{  67, 0x5f, 0xff, 0x5f }, {  68, 0x5f, 0xff, 0x87 },
-	{  69, 0x5f, 0xff, 0xaf }, {  70, 0x5f, 0xff, 0xd7 },
-	{  71, 0x5f, 0xff, 0xff }, { 225, 0x62, 0x62, 0x62 },
-	{ 226, 0x6c, 0x6c, 0x6c }, { 227, 0x76, 0x76, 0x76 },
-	{ 228, 0x80, 0x80, 0x80 }, {  72, 0x87, 0x00, 0x00 },
-	{  73, 0x87, 0x00, 0x5f }, {  74, 0x87, 0x00, 0x87 },
-	{  75, 0x87, 0x00, 0xaf }, {  76, 0x87, 0x00, 0xd7 },
-	{  77, 0x87, 0x00, 0xff }, {  78, 0x87, 0x5f, 0x00 },
-	{  79, 0x87, 0x5f, 0x5f }, {  80, 0x87, 0x5f, 0x87 },
-	{  81, 0x87, 0x5f, 0xaf }, {  82, 0x87, 0x5f, 0xd7 },
-	{  83, 0x87, 0x5f, 0xff }, {  84, 0x87, 0x87, 0x00 },
-	{  85, 0x87, 0x87, 0x5f }, {  86, 0x87, 0x87, 0x87 },
-	{  87, 0x87, 0x87, 0xaf }, {  88, 0x87, 0x87, 0xd7 },
-	{  89, 0x87, 0x87, 0xff }, {  90, 0x87, 0xaf, 0x00 },
-	{  91, 0x87, 0xaf, 0x5f }, {  92, 0x87, 0xaf, 0x87 },
-	{  93, 0x87, 0xaf, 0xaf }, {  94, 0x87, 0xaf, 0xd7 },
-	{  95, 0x87, 0xaf, 0xff }, {  96, 0x87, 0xd7, 0x00 },
-	{  97, 0x87, 0xd7, 0x5f }, {  98, 0x87, 0xd7, 0x87 },
-	{  99, 0x87, 0xd7, 0xaf }, { 100, 0x87, 0xd7, 0xd7 },
-	{ 101, 0x87, 0xd7, 0xff }, { 102, 0x87, 0xff, 0x00 },
-	{ 103, 0x87, 0xff, 0x5f }, { 104, 0x87, 0xff, 0x87 },
-	{ 105, 0x87, 0xff, 0xaf }, { 106, 0x87, 0xff, 0xd7 },
-	{ 107, 0x87, 0xff, 0xff }, { 229, 0x8a, 0x8a, 0x8a },
-	{ 230, 0x94, 0x94, 0x94 }, { 231, 0x9e, 0x9e, 0x9e },
-	{ 232, 0xa8, 0xa8, 0xa8 }, { 108, 0xaf, 0x00, 0x00 },
-	{ 109, 0xaf, 0x00, 0x5f }, { 110, 0xaf, 0x00, 0x87 },
-	{ 111, 0xaf, 0x00, 0xaf }, { 112, 0xaf, 0x00, 0xd7 },
-	{ 113, 0xaf, 0x00, 0xff }, { 114, 0xaf, 0x5f, 0x00 },
-	{ 115, 0xaf, 0x5f, 0x5f }, { 116, 0xaf, 0x5f, 0x87 },
-	{ 117, 0xaf, 0x5f, 0xaf }, { 118, 0xaf, 0x5f, 0xd7 },
-	{ 119, 0xaf, 0x5f, 0xff }, { 120, 0xaf, 0x87, 0x00 },
-	{ 121, 0xaf, 0x87, 0x5f }, { 122, 0xaf, 0x87, 0x87 },
-	{ 123, 0xaf, 0x87, 0xaf }, { 124, 0xaf, 0x87, 0xd7 },
-	{ 125, 0xaf, 0x87, 0xff }, { 126, 0xaf, 0xaf, 0x00 },
-	{ 127, 0xaf, 0xaf, 0x5f }, { 128, 0xaf, 0xaf, 0x87 },
-	{ 129, 0xaf, 0xaf, 0xaf }, { 130, 0xaf, 0xaf, 0xd7 },
-	{ 131, 0xaf, 0xaf, 0xff }, { 132, 0xaf, 0xd7, 0x00 },
-	{ 133, 0xaf, 0xd7, 0x5f }, { 134, 0xaf, 0xd7, 0x87 },
-	{ 135, 0xaf, 0xd7, 0xaf }, { 136, 0xaf, 0xd7, 0xd7 },
-	{ 137, 0xaf, 0xd7, 0xff }, { 138, 0xaf, 0xff, 0x00 },
-	{ 139, 0xaf, 0xff, 0x5f }, { 140, 0xaf, 0xff, 0x87 },
-	{ 141, 0xaf, 0xff, 0xaf }, { 142, 0xaf, 0xff, 0xd7 },
-	{ 143, 0xaf, 0xff, 0xff }, { 233, 0xb2, 0xb2, 0xb2 },
-	{ 234, 0xbc, 0xbc, 0xbc }, { 235, 0xc6, 0xc6, 0xc6 },
-	{ 236, 0xd0, 0xd0, 0xd0 }, { 144, 0xd7, 0x00, 0x00 },
-	{ 145, 0xd7, 0x00, 0x5f }, { 146, 0xd7, 0x00, 0x87 },
-	{ 147, 0xd7, 0x00, 0xaf }, { 148, 0xd7, 0x00, 0xd7 },
-	{ 149, 0xd7, 0x00, 0xff }, { 150, 0xd7, 0x5f, 0x00 },
-	{ 151, 0xd7, 0x5f, 0x5f }, { 152, 0xd7, 0x5f, 0x87 },
-	{ 153, 0xd7, 0x5f, 0xaf }, { 154, 0xd7, 0x5f, 0xd7 },
-	{ 155, 0xd7, 0x5f, 0xff }, { 156, 0xd7, 0x87, 0x00 },
-	{ 157, 0xd7, 0x87, 0x5f }, { 158, 0xd7, 0x87, 0x87 },
-	{ 159, 0xd7, 0x87, 0xaf }, { 160, 0xd7, 0x87, 0xd7 },
-	{ 161, 0xd7, 0x87, 0xff }, { 162, 0xd7, 0xaf, 0x00 },
-	{ 163, 0xd7, 0xaf, 0x5f }, { 164, 0xd7, 0xaf, 0x87 },
-	{ 165, 0xd7, 0xaf, 0xaf }, { 166, 0xd7, 0xaf, 0xd7 },
-	{ 167, 0xd7, 0xaf, 0xff }, { 168, 0xd7, 0xd7, 0x00 },
-	{ 169, 0xd7, 0xd7, 0x5f }, { 170, 0xd7, 0xd7, 0x87 },
-	{ 171, 0xd7, 0xd7, 0xaf }, { 172, 0xd7, 0xd7, 0xd7 },
-	{ 173, 0xd7, 0xd7, 0xff }, { 174, 0xd7, 0xff, 0x00 },
-	{ 175, 0xd7, 0xff, 0x5f }, { 176, 0xd7, 0xff, 0x87 },
-	{ 177, 0xd7, 0xff, 0xaf }, { 178, 0xd7, 0xff, 0xd7 },
-	{ 179, 0xd7, 0xff, 0xff }, { 237, 0xda, 0xda, 0xda },
-	{ 238, 0xe4, 0xe4, 0xe4 }, { 239, 0xee, 0xee, 0xee },
-	{ 180, 0xff, 0x00, 0x00 }, { 181, 0xff, 0x00, 0x5f },
-	{ 182, 0xff, 0x00, 0x87 }, { 183, 0xff, 0x00, 0xaf },
-	{ 184, 0xff, 0x00, 0xd7 }, { 185, 0xff, 0x00, 0xff },
-	{ 186, 0xff, 0x5f, 0x00 }, { 187, 0xff, 0x5f, 0x5f },
-	{ 188, 0xff, 0x5f, 0x87 }, { 189, 0xff, 0x5f, 0xaf },
-	{ 190, 0xff, 0x5f, 0xd7 }, { 191, 0xff, 0x5f, 0xff },
-	{ 192, 0xff, 0x87, 0x00 }, { 193, 0xff, 0x87, 0x5f },
-	{ 194, 0xff, 0x87, 0x87 }, { 195, 0xff, 0x87, 0xaf },
-	{ 196, 0xff, 0x87, 0xd7 }, { 197, 0xff, 0x87, 0xff },
-	{ 198, 0xff, 0xaf, 0x00 }, { 199, 0xff, 0xaf, 0x5f },
-	{ 200, 0xff, 0xaf, 0x87 }, { 201, 0xff, 0xaf, 0xaf },
-	{ 202, 0xff, 0xaf, 0xd7 }, { 203, 0xff, 0xaf, 0xff },
-	{ 204, 0xff, 0xd7, 0x00 }, { 205, 0xff, 0xd7, 0x5f },
-	{ 206, 0xff, 0xd7, 0x87 }, { 207, 0xff, 0xd7, 0xaf },
-	{ 208, 0xff, 0xd7, 0xd7 }, { 209, 0xff, 0xd7, 0xff },
-	{ 210, 0xff, 0xff, 0x00 }, { 211, 0xff, 0xff, 0x5f },
-	{ 212, 0xff, 0xff, 0x87 }, { 213, 0xff, 0xff, 0xaf },
-	{ 214, 0xff, 0xff, 0xd7 }, { 215, 0xff, 0xff, 0xff },
-};
 
-int	colour_cmp_rgb(const void *, const void *);
+void	colour_rgb_generate256(void);
+double	colour_rgb_distance(struct colour_rgb *, struct colour_rgb *);
+int	colour_rgb_find(struct colour_rgb *);
 
-/* Compare function for bsearch(). */
+/* Generate 256 colour RGB table. */
-int
+void
-colour_cmp_rgb(const void *lhs0, const void *rhs0)
+colour_rgb_generate256(void)
 {
-	const struct colour_rgb *lhs = lhs0, *rhs = rhs0;
+	struct colour_rgb	*rgb;
+	u_int			 i, r, g, b;
 
-	if (lhs->r < rhs->r)
+	/*
-		return (-1);
+	 * Allocate the table. The first 16 colours are often changed by users
-	if (lhs->r > rhs->r)
+	 * and terminals so don't include them.
-		return (1);
+	 */
+	colour_rgb_256 = xcalloc(240, sizeof *colour_rgb_256);
 
-	if (lhs->g < rhs->g)
+	/* Add the colours first. */
-		return (-1);
+	r = g = b = 0;
-	if (lhs->g > rhs->g)
+	for (i = 240; i > 24; i--) {
-		return (1);
+		rgb = &colour_rgb_256[240 - i];
 
-	if (lhs->b < rhs->b)
+		if (r != 0)
-		return (-1);
+			rgb->r = (r * 40) + 55;
-	if (lhs->b > rhs->b)
+		if (g != 0)
-		return (1);
+			rgb->g = (g * 40) + 55;
+		if (b != 0)
+			rgb->b = (b * 40) + 55;
 
-	return (0);
+		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. */
+double
+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 (sqrt(r * r + g * g + b * b));
 }
 
 /* Work out the nearest colour from the 256 colour set. */
 int
-colour_find_rgb(u_char r, u_char g, u_char b)
+colour_rgb_find(struct colour_rgb *rgb)
 {
-	struct colour_rgb	rgb = { .r = r, .g = g, .b = b }, *found;
+	double	distance, lowest;
-	u_int			distance, lowest, colour, i;
+	u_int	colour, i;
-	int			dr, dg, db;
 
-	found = bsearch(&rgb, colour_to_256, nitems(colour_to_256),
+	if (colour_rgb_256 == NULL)
-	    sizeof colour_to_256[0], colour_cmp_rgb);
+		colour_rgb_generate256();
-	if (found != NULL)
-		return (16 + found->i);
 
 	colour = 16;
-	lowest = UINT_MAX;
+	lowest = INFINITY;
 	for (i = 0; i < 240; i++) {
-		dr = (int)colour_from_256[i].r - r;
+		distance = colour_rgb_distance(&colour_rgb_256[i], rgb);
-		dg = (int)colour_from_256[i].g - g;
-		db = (int)colour_from_256[i].b - b;
-
-		distance = dr * dr + dg * dg + db * db;
 		if (distance < lowest) {
 			lowest = distance;
 			colour = 16 + i;
@@ -361,7 +149,7 @@ colour_tostring(int c)
 	static char	s[32];
 
 	if (c & 0x100) {
-		xsnprintf(s, sizeof s, "colour%d", c & ~0x100);
+		xsnprintf(s, sizeof s, "colour%u", c & ~0x100);
 		return (s);
 	}
 
@@ -384,22 +172,6 @@ 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);
 }
@@ -408,20 +180,20 @@ colour_tostring(int c)
 int
 colour_fromstring(const char *s)
 {
-	const char	*errstr;
+	const char		*errstr;
-	const char	*cp;
+	const char		*cp;
-	int		 n;
+	struct colour_rgb	 rgb;
-	u_char		 r, g, b;
+	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", &r, &g, &b);
+		n = sscanf(s + 1, "%2hhx%2hhx%2hhx", &rgb.r, &rgb.g, &rgb.b);
 		if (n != 3)
 			return (-1);
-		return (colour_find_rgb(r, g, b) | 0x100);
+		return (colour_rgb_find(&rgb) | 0x100);
 	}
 
 	if (strncasecmp(s, "colour", (sizeof "colour") - 1) == 0) {
@@ -431,40 +203,24 @@ colour_fromstring(const char *s)
 		return (n | 0x100);
 	}
 
-	if (strcasecmp(s, "black") == 0 || strcmp(s, "0") == 0)
+	if (strcasecmp(s, "black") == 0 || (s[0] == '0' && s[1] == '\0'))
 		return (0);
-	if (strcasecmp(s, "red") == 0 || strcmp(s, "1") == 0)
+	if (strcasecmp(s, "red") == 0 || (s[0] == '1' && s[1] == '\0'))
 		return (1);
-	if (strcasecmp(s, "green") == 0 || strcmp(s, "2") == 0)
+	if (strcasecmp(s, "green") == 0 || (s[0] == '2' && s[1] == '\0'))
 		return (2);
-	if (strcasecmp(s, "yellow") == 0 || strcmp(s, "3") == 0)
+	if (strcasecmp(s, "yellow") == 0 || (s[0] == '3' && s[1] == '\0'))
 		return (3);
-	if (strcasecmp(s, "blue") == 0 || strcmp(s, "4") == 0)
+	if (strcasecmp(s, "blue") == 0 || (s[0] == '4' && s[1] == '\0'))
 		return (4);
-	if (strcasecmp(s, "magenta") == 0 || strcmp(s, "5") == 0)
+	if (strcasecmp(s, "magenta") == 0 || (s[0] == '5' && s[1] == '\0'))
 		return (5);
-	if (strcasecmp(s, "cyan") == 0 || strcmp(s, "6") == 0)
+	if (strcasecmp(s, "cyan") == 0 || (s[0] == '6' && s[1] == '\0'))
 		return (6);
-	if (strcasecmp(s, "white") == 0 || strcmp(s, "7") == 0)
+	if (strcasecmp(s, "white") == 0 || (s[0] == '7' && s[1] == '\0'))
 		return (7);
-	if (strcasecmp(s, "default") == 0 || strcmp(s, "8") == 0)
+	if (strcasecmp(s, "default") == 0 || (s[0] == '8' && s[1] == '\0'))
 		return (8);
-	if (strcasecmp(s, "brightblack") == 0 || strcmp(s, "90") == 0)
-		return (90);
-	if (strcasecmp(s, "brightred") == 0 || strcmp(s, "91") == 0)
-		return (91);
-	if (strcasecmp(s, "brightgreen") == 0 || strcmp(s, "92") == 0)
-		return (92);
-	if (strcasecmp(s, "brightyellow") == 0 || strcmp(s, "93") == 0)
-		return (93);
-	if (strcasecmp(s, "brightblue") == 0 || strcmp(s, "94") == 0)
-		return (94);
-	if (strcasecmp(s, "brightmagenta") == 0 || strcmp(s, "95") == 0)
-		return (95);
-	if (strcasecmp(s, "brightcyan") == 0 || strcmp(s, "96") == 0)
-		return (96);
-	if (strcasecmp(s, "brightwhite") == 0 || strcmp(s, "97") == 0)
-		return (97);
 	return (-1);
 }
 
@@ -493,3 +249,29 @@ colour_256to16(u_char c)
 
 	return (table[c]);
 }
+
+/* Convert 256 colour palette to 88. */
+u_char
+colour_256to88(u_char c)
+{
+	static const u_char table[256] = {
+		 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
+		16, 17, 17, 18, 18, 19, 20, 21, 21, 22, 22, 23, 20, 21, 21, 22,
+		22, 23, 24, 25, 25, 26, 26, 27, 24, 25, 25, 26, 26, 27, 28, 29,
+		29, 30, 30, 31, 32, 33, 33, 34, 34, 35, 36, 37, 37, 38, 38, 39,
+		36, 37, 37, 38, 38, 39, 40, 41, 41, 42, 42, 43, 40, 41, 41, 42,
+		42, 43, 44, 45, 45, 46, 46, 47, 32, 33, 33, 34, 34, 35, 36, 37,
+		37, 38, 38, 39, 36, 37, 37, 38, 38, 39, 40, 41, 41, 42, 42, 43,
+		40, 41, 41, 42, 42, 43, 44, 45, 45, 46, 46, 47, 48, 49, 49, 50,
+		50, 51, 52, 53, 53, 54, 54, 55, 52, 53, 53, 54, 54, 55, 56, 57,
+		57, 58, 58, 59, 56, 57, 57, 58, 58, 59, 60, 61, 61, 62, 62, 63,
+		48, 49, 49, 50, 50, 51, 52, 53, 53, 54, 54, 55, 52, 53, 53, 54,
+		54, 55, 56, 57, 57, 58, 58, 59, 56, 57, 57, 58, 58, 59, 60, 61,
+		61, 62, 62, 63, 64, 65, 65, 66, 66, 67, 68, 69, 69, 70, 70, 71,
+		68, 69, 69, 70, 70, 71, 72, 73, 73, 74, 74, 75, 72, 73, 73, 74,
+		74, 75, 76, 77, 77, 78, 78, 79,  0,  0, 80, 80, 80, 81, 81, 81,
+		82, 82, 82, 83, 83, 83, 84, 84, 84, 85, 85, 85, 86, 86, 86, 87
+	};
+
+	return (table[c]);
+}

compat.h

@@ -1,3 +1,5 @@
+/* $Id$ */
+
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
  *
@@ -28,10 +30,6 @@
 #define __packed __attribute__ ((__packed__))
 #endif
 
-#ifndef ECHOPRT
-#define ECHOPRT 0
-#endif
-
 #ifndef HAVE_BSD_TYPES
 typedef uint8_t u_int8_t;
 typedef uint16_t u_int16_t;
@@ -123,10 +121,6 @@ typedef uint64_t u_int64_t;
 #define CMSG_LEN(len) (CMSG_ALIGN(sizeof(struct cmsghdr)) + (len))
 #endif
 
-#ifndef O_DIRECTORY
-#define O_DIRECTORY 0
-#endif
-
 #ifndef INFTIM
 #define INFTIM -1
 #endif
@@ -158,31 +152,13 @@ typedef uint64_t u_int64_t;
 	} while (0)
 #endif
 
-#ifndef timersub
-#define timersub(tvp, uvp, vvp)                                         \
-	do {                                                            \
-		(vvp)->tv_sec = (tvp)->tv_sec - (uvp)->tv_sec;          \
-		(vvp)->tv_usec = (tvp)->tv_usec - (uvp)->tv_usec;       \
-		if ((vvp)->tv_usec < 0) {                               \
-			(vvp)->tv_sec--;                                \
-			(vvp)->tv_usec += 1000000;                      \
-		}                                                       \
-	} while (0)
-#endif
-
 #ifndef TTY_NAME_MAX
 #define TTY_NAME_MAX 32
 #endif
 
-#ifndef HOST_NAME_MAX
+#ifndef HAVE_BZERO
-#define HOST_NAME_MAX 255
+#undef bzero
-#endif
+#define bzero(buf, len) memset(buf, 0, len);
-
-#ifndef HAVE_FLOCK
-#define LOCK_SH 0
-#define LOCK_EX 0
-#define LOCK_NB 0
-#define flock(fd, op) (0)
 #endif
 
 #ifndef HAVE_CLOSEFROM
@@ -220,12 +196,6 @@ size_t	 	 strlcat(char *, const char *, size_t);
 int	 	 daemon(int, int);
 #endif
 
-#ifndef HAVE_B64_NTOP
-/* b64_ntop.c */
-#undef b64_ntop /* for Cygwin */
-int		 b64_ntop(const char *, size_t, char *, size_t);
-#endif
-
 #ifndef HAVE_FORKPTY
 /* forkpty.c */
 #include <sys/ioctl.h>
@@ -243,27 +213,12 @@ int		 vasprintf(char **, const char *, va_list);
 char		*fgetln(FILE *, size_t *);
 #endif
 
-#ifndef HAVE_FPARSELN
-char		*fparseln(FILE *, size_t *, size_t *, const char *, int);
-#endif
-
 #ifndef HAVE_SETENV
 /* setenv.c */
 int		 setenv(const char *, const char *, int);
 int		 unsetenv(const char *);
 #endif
 
-#ifndef HAVE_CFMAKERAW
-/* cfmakeraw.c */
-void		cfmakeraw(struct termios *);
-#endif
-
-#ifndef HAVE_OPENAT
-/* openat.c */
-#define AT_FDCWD -100
-int		openat(int, const char *, int, ...);
-#endif
-
 #ifdef HAVE_GETOPT
 #include <getopt.h>
 #else

compat/asprintf.c

@@ -1,3 +1,5 @@
+/* $Id$ */
+
 /*
  * Copyright (c) 2006 Nicholas Marriott <nicm@users.sourceforge.net>
  *
@@ -42,24 +44,19 @@ int
 vasprintf(char **ret, const char *fmt, va_list ap)
 {
 	int	 n;
-	va_list  ap2;
-
-	va_copy(ap2, ap);
 
 	if ((n = vsnprintf(NULL, 0, fmt, ap)) < 0)
 		goto error;
 
 	*ret = xmalloc(n + 1);
-	if ((n = vsnprintf(*ret, n + 1, fmt, ap2)) < 0) {
+	if ((n = vsnprintf(*ret, n + 1, fmt, ap)) < 0) {
-		free(*ret);
+		xfree(*ret);
 		goto error;
 	}
-	va_end(ap2);
 
 	return (n);
 
 error:
-	va_end(ap2);
 	*ret = NULL;
 	return (-1);
 }