Do not crash on empty window, reported by Jamie Macdonald in GitHub

issue 1299. Patch from Thomas Adam.

.gitignore

@@ -17,3 +17,4 @@ Makefile
 Makefile.in
 configure
 tmux.1.*
+*.dSYM

.mailmap

@@ -1,24 +1,37 @@
-Bob Beck 		<beck@openbsd.org> beck <beck>
-Igor Sobrado 		<sobrado@openbsd.org> sobrado <sobrado>
-Jacek Masiulaniec 	<jacekm@openbsd.org> jacekm <jacekm>
-Jason McIntyre 		<jmc@openbsd.org> jcm <jcm>
+Bob Beck		<beck@openbsd.org> beck <beck>
+Claudio Jeker		<claudio@openbsd.org> claudio <claudio>
+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>
 Joel Sing		<jsing@openbsd.org> jsing <jsing>
-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 	<nicm@openbsd.org> nicm <nicm>
-Nicholas Marriott 	<nicm@openbsd.org> no_author <no_author@example.org>
-<nicm@openbsd.org>	<nicholas.marriott@gmail.com>
-Okan Demirmen 		<okan@openbsd.org> okan <okan>
+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>
+Michael McConville	<mmcc@openbsd.org> mmcc <mmcc>
+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>
+Pierre-Yves Ritschard	<pyr@openbsd.org> pyr <pyr>
+Ray Lai			<ray@openbsd.org> ray <ray>
 Ryan McBride		<mcbride@openbsd.org> mcbride <mcbride>
-Stefan Sperling 	<stsp@openbsd.org> stsp <stsp>
-Stuart Henderson 	<sthen@openbsd.org> sthen <sthen>
-Ted Unangst 		<tedu@openbsd.org> tedu <tedu>
-Theo Deraadt 		<deraadt@openbsd.org> deraadt <deraadt>
+Sebastian Benoit	<benno@openbsd.org> benno <benno>
+Sebastien Marie		<semarie@openbsd.org> semarie <semarie>
+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> Theo Deraadt <deraadt@openbsd.org>
+Theo de Raadt		<deraadt@openbsd.org> deraadt <deraadt>
 Thomas Adam		<thomas@xteddy.org> Thomas <thomas@xteddy.org>
-William Yodlowsky 	<william@openbsd.org> william <william>
+Thomas Adam		<thomas@xteddy.org> Thomas Adam <thomas.adam@smoothwall.net>
+Thomas Adam		<thomas@xteddy.org> n6tadam <n6tadam@xteddy.org>
+Tim van der Molen	<tim@openbsd.org> tim <tim>
+Tobias Stoeckmann	<tobias@openbsd.org> tobias <tobias>
+Todd C Miller		<millert@openbsd.org> millert <millert>
+William Yodlowsky	<william@openbsd.org> william <william>

.travis.yml

@@ -0,0 +1,10 @@
+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,4 +1,549 @@
-CHANGES FROM 1.8 to 1.9, 20 February 2014
+CHANGES FROM 2.6 TO 2.7
+
+* Remove EVENT_* variables from environment on platforms where tmux uses them
+  so they do not pass on to panes.
+
+* Fixed for hooks at server exit.
+
+* Remove SGR 10 (was equivalent to SGR 0 but no other terminal seems to do
+  this).
+
+* Expand formats in window and session names.
+
+* Add -Z flag to choose-tree, choose-client, choose-buffer to automatically
+  zoom the pane when the mode is entered and unzoom when it exits, assuming the
+  pane is not already zoomed. This is now part of the default key bindings.
+
+* Add C-g to exit modes with emacs keys.
+
+* Add exit-empty option to exit server if no sessions (defaults to on).
+
+* Show if a filter is present in choose modes.
+
+* Add pipe-pane -I to to connect stdin of the child process.
+
+* Performance improvements for reflow.
+
+* Use RGB terminfo(5) capability to detect RGB colour terminals (the existing
+  Tc extension remains unchanged).
+
+* Support for ISO colon-separated SGR sequences.
+
+* Add select-layout -E to spread panes out evenly (bound to E key).
+
+* Support wide characters properly when reflowing.
+
+* Pass PWD to new panes as a hint to shells, as well as calling chdir().
+
+* Performance improvements for the various choose modes.
+
+* Only show first member of session groups in tree mode (-G flag to choose-tree
+  to show all).
+
+* Support %else in config files to match %if; from Brad Town in GitHub issue
+  1071.
+
+* Fix "kind" terminfo(5) capability to be S-Down not S-Up.
+
+* Add a box around the preview label in tree mode.
+
+* Show exit status and time in the remain-on-exit pane text; from Timo
+  Boettcher in GitHub issue 1103.
+
+* Correctly use pane-base-index in tree mode.
+
+* Change the allow-rename option default to off.
+
+* Support for xterm(1) title stack escape sequences (GitHub issue 1075 from
+  Brad Town).
+
+* Correctly remove padding cells to fix a UTF-8 display problem (GitHub issue
+  1090).
+
+CHANGES FROM 2.5 TO 2.6, 05 October 2017
+
+* Add select-pane -T to set pane title.
+
+* Fix memory leak when lines with BCE are removed from history.
+
+* Fix (again) the "prefer unattached" behaviour of attach-session.
+
+* Reorder how keys are checked to allow keys to be specified that have a
+  leading escape. GitHub issue 1048.
+
+* Support REP escape sequence (\033[b).
+
+* Run alert hooks based on options rather than always, and allow further bells
+  even if there is an existing bell.
+
+* Add -d flag to display-panes to override display-panes-time.
+
+* Add selection_present format when in copy mode (allows key bindings that do
+  something different if there is a selection).
+
+* Add pane_at_left, pane_at_right, pane_at_top and pane_at_bottom formats.
+
+* Make bell, activity and silence alerting more consistent by: removing the
+  bell-on-alert option; adding activity-action and silence-action options with
+  the same possible values as the existing bell-action; adding a "both" value
+  for the visual-bell, visual-activity and visual-silence options to trigger
+  both a bell and a message.
+
+* Add a pane_pipe format to show if pipe-pane is active.
+
+* Block signals between forking and resetting signal handlers so that the
+  libevent signal handler doesn't get called in the child and incorrectly write
+  into the signal pipe that it still shares with the parent. GitHub issue 1001.
+
+* Allow punctuation in pane_current_command.
+
+* Add -c for respawn-pane and respawn-window.
+
+* Wait for any remaining data to flush when a pane is closed while pipe-pane is
+  in use.
+
+* Fix working out current client with no target. GitHub issue 995.
+
+* Try to fallback to C.UTF-8 as well as en_US.UTF-8 when looking for a UTF-8
+  locale.
+
+* Add user-keys option for user-defined key escape sequences (mapped to User0
+  to User999 keys).
+
+* Add pane-set-clipboard hook.
+
+* FAQ file has moved out of repository to online.
+
+* Fix problem with high CPU usage when a client dies unexpectedly. GitHub issue
+  941.
+
+* Do a dance on OS X 10.10 and above to return tmux to the user namespace,
+  allowing access to the clipboard.
+
+* Do not allow escape sequences which expect a specific terminator (APC, DSC,
+  OSC) to wait for forever - use a small timeout. This reduces the chance of
+  the pane locking up completely when sent garbage (cat /dev/random or
+  similar).
+
+* Support SIGUSR2 to toggle logging on a running server, also generate the
+  "out" log file with -vv not -vvvv.
+
+* Make set-clipboard a three state option: on (tmux both sends to outside
+  terminal and accepts from applications inside); external (tmux sends outside
+  but does not accept inside); and off.
+
+* Fix OSC 4 palette setting for bright foreground colours. GitHub issue 954.
+
+* Use setrgbf and setrgbb terminfo(5) capabilities to set RGB colours, if they
+  are available. (Tc is still supported as well.)
+
+* Fix redrawing panes when they are resized several times but end up with the
+  size unchanged (for example, splitw/resizep -Z/breakp).
+
+* Major rewrite of choose mode. Now includes preview, sorting, searching and
+  tagging; commands that can be executed directly from the mode (for example,
+  to delete one or more buffers); and filtering in tree mode.
+
+* choose-window and choose-session are now aliases of choose-tree (in the
+  command-alias option).
+
+* Support OSC 10 and OSC 11 to set foreground and background colours.
+
+* Check the U8 capability to determine whether to use UTF-8 line drawing
+  characters for ACS.
+
+* Some missing notifications for layout changes.
+
+* Control mode clients now do not affect session sizes until they issue
+  refresh-client -C. new-session -x and -y works with control clients even if
+  the session is not detached.
+
+* All new sessions that are unattached (whether with -d or started with no
+  terminal) are now created with size 80 x 24. Whether the status line is on or
+  off does not affect the size of new sessions until they are attached.
+
+* Expand formats in option names and add -F flag to expand them in option values.
+
+* Remember the search string for a pane even if copy mode is exited and entered
+  again.
+
+* Some further BCE fixes (scroll up, reverse index).
+
+* Improvements to how terminals are cleared (entirely or partially).
+
+CHANGES FROM 2.4 TO 2.5, 09 May 2017
+
+* Reset updated flag when restarting #() command so that new output is properly
+  recognised. GitHub issue 922.
+
+* Fix ECH with a background colour.
+
+* Do not rely on the terminal not moving the cursor after DL or EL.
+
+* Fix send-keys and send-prefix in copy-mode (so C-b C-b works). GitHub issue
+  905.
+
+* Set the current pane for rotate-window so it works in command sequences.
+
+* Add pane_mode format.
+
+* Differentiate M-Up from Escape+Up when possible (that is, in terminals with
+  xterm(1) style function keys). GitHub issue 907.
+
+* Add session_stack and window_stack_index formats.
+
+* Some new control mode notifications and corresponding hooks:
+  pane-mode-changed, window-pane-changed, client-session-changed,
+  session-window-changed.
+
+* Format pane_search_string for last search term while in copy mode (useful
+  with command-prompt -I).
+
+* Fix a problem with high CPU usage and multiple clients with #(). GitHub issue
+  889.
+
+* Fix UTF-8 combining characters in column 0.
+
+* Fix reference counting so that panes are properly destroyed and their
+  processes killed.
+
+* Clamp SU (CSI S) parameter to work around a bug in Konsole.
+
+* Tweak line wrapping in full width panes to play more nicely with terminal
+  copy and paste.
+
+* Fix when we emit SGR 0 in capture-pane -e.
+
+* Do not change TERM until after config file parsing has finished, so that
+  commands run inside the config file can use it to make decisions (typically
+  about default-terminal).
+
+* Make the initial client wait until config file parsing has finished to avoid
+  racing with commands.
+
+* Fix core when if-shell fails.
+
+* Only use ED to clear screen if the pane is at the bottom.
+
+* Fix multibyte UTF-8 output.
+
+* Code improvements around target (-t) resolution.
+
+* Change how the default target (for commands without -t) is managed across
+  command sequences: now it is set up at the start and commands are required
+  to update it if needed. Fixes binding command sequences to mouse keys.
+
+* Make if-shell from the config file work correctly.
+
+* Change to always check the root key table if no binding is found in the
+  current table (prefix table or copy-mode table or whatever). This means that
+  root key bindings will take effect even in copy mode, if not overridden by a
+  copy mode key binding.
+
+* Fix so that the history file works again.
+
+* Run config file without a client rather than using the first client, restores
+  previous behaviour.
+
+* If a #() command doesn't exit, continue to read from it and use its last full
+  line of output.
+
+* Handle slow terminals and fast output better: when the amount of data
+  outstanding gets too large, discard output until it is drained and we are
+  able to do a full redraw. Prevents tmux sitting on a huge buffer that the
+  terminal will take forever to consume.
+
+* Do not redraw a client unless we realistically think it can accept the data -
+  defer redraws until the client has nothing else waiting to write.
+ 
+CHANGES FROM 2.3 TO 2.4, 20 April 2017
+
+Incompatible Changes
+====================
+
+* Key tables have undergone major changes. Mode key tables are no longer
+  separate from the main key tables. All mode key tables have been removed,
+  together with the -t flag to bind-key and unbind-key.
+
+  The emacs-edit, vi-edit, emacs-choose and vi-choose tables have been replaced
+  by fixed key bindings in the command prompt and choose modes. The mode-keys
+  and status-keys options remain.
+
+  The emacs-copy and vi-copy tables have been replaced by the copy-mode and
+  copy-mode-vi tables. Commands are sent using the -X and -N flags to
+  send-keys. So the following:
+
+    bind -temacs-copy C-Up scroll-up
+    bind -temacs-copy -R5 WheelUpPane scroll-up
+
+  Becomes:
+
+    bind -Tcopy-mode C-Up send -X scroll-up
+    bind -Tcopy-mode WheelUpPane send -N5 -X scroll-up
+
+  These changes allows the full command parser (including command sequences) and
+  command set to be used - for example, the normal command prompt with editing
+  and history is now used for searching, jumping, and so on instead of a custom
+  one. The default C-r binding is now:
+
+    bind -Tcopy-mode C-r command-prompt -i -p'search up' "send -X search-backward-incremental '%%'"
+
+  There are also some new commmands available with send -X, such as
+  copy-pipe-and-cancel.
+* set-remain-on-exit has gone -- can be achieved with hooks instead.
+* Hooks: before hooks have been removed and only a selection of commands now
+  have after hooks (they are no longer automatic). Additional hooks have been
+  added.
+* The xterm-keys option now defaults to on.
+
+Normal Changes
+==============
+
+* Support for mouse double and triple clicks.
+* BCE (Background Colour Erase) is now supported.
+* All occurrences of a search string in copy mode are now highlighted;
+  additionally, the number of search results is displayed. The highlighting
+  updates interactively with the default emacs key bindings (incremental
+  search).
+* source-file now understands glob patterns.
+* Formats now have simple comparisons:
+
+    #{==:a,b}
+    #{!=:a,b}
+
+* There are the following new formats:
+
+  - #{version} -- the tmux server version;
+  - #{client_termtype} -- the terminal type of the client;
+  - #{client_name} -- the name of a client;
+  - #{client_written} -- the number of bytes written to the client.
+
+* The configuration file now accepts %if/%endif conditional blocks which are
+  processed when it is parsed; the argument is a format string (useful with the
+  new format comparison options).
+* detach-client now has -E to execute a command replacing the client instead of
+  exiting.
+* Add support for custom command aliases, this is an array option which
+  contains items of the form "alias=command". This is consulted when an
+  unknown command is parsed.
+* break-pane now has -n to specify the new window name.
+* OSC 52 support has been added for programs inside tmux to set a tmux buffer.
+* The mouse "all event" mode (1003) is now supported.
+* Palette setting is now possible (OSC 4 and 104).
+* Strikethrough support (a recent terminfo is required).
+* Grouped sessions can now be named (new -t).
+* terminal-overrides and update-environment are now array options (the previous
+  set -ag syntax should work without change).
+* There have been substantial performance improvements.
+
+CHANGES FROM 2.2 TO 2.3, 29 September 2016
+
+Incompatible Changes
+====================
+
+None.
+
+Normal Changes
+==============
+
+* New option 'pane-border-status' to add text in the pane borders.
+* Support for hooks on commands: 'after' and 'before' hooks.
+* 'source-file' understands '-q' to suppress errors for nonexistent files.
+* Lots of UTF8 improvements, especially on MacOS.
+* 'window-status-separator' understands #[] expansions.
+* 'split-window' understands '-f' for performing a full-width split.
+* Allow report count to be specified when using 'bind-key -R'.
+* 'set -a' for appending to user options (@foo) is now supported.
+* 'display-panes' can now accept a command to run, rather than always
+  selecting the pane.
+
+CHANGES FROM 2.1 TO 2.2, 10 April 2016
+
+Incompatible Changes
+====================
+
+* The format strings which referenced time have been removed.  Instead:
+
+  #{t:window_activity}
+
+can be used.
+
+* Support for TMPDIR has been removed.  Use TMUX_TMPDIR instead.
+* UTF8 detection now happens automatically if the client supports it, hence
+  the:
+
+  mouse-utf8
+  utf8
+
+  options has been removed.
+* The:
+
+  mouse_utf8_flag
+
+  format string has been removed.
+* The -I option to show-messages has been removed.  See:
+
+  #{t:start_time}
+
+  format option instead.
+
+Normal Changes
+==============
+
+* Panes are unzoomed with selectp -LRUD
+* New formats added:
+
+  #{scroll_position}
+  #{socket_path}
+  #{=10:...} -- limit to N characters (from the start)
+  #{=-10:...} -- limit to N characters (from the end)
+  #{t:...} -- used to format time-based formats
+  #{b:...} -- used to ascertain basename from string
+  #{d:...} -- used to ascertain dirname from string
+  #{s:...} -- used to perform substitutions on a string
+
+* Job output is run via the format system, so formats work again
+* If display-time is set to 0, then the indicators wait for a key to be
+  pressed.
+* list-keys and list-commands can be run without starting the tmux server.
+* kill-session learns -C to clear all alerts in all windows of the session.
+* Support for hooks (internal for now), but hooks for the following have been
+  implemented:
+
+  alert-bell
+  alert-silence
+  alert-activity
+  client-attached
+  client-detached
+  client-resized
+  pane-died
+  pane-exited
+
+* RGB (24bit) colour support.  The 'Tc' flag must be set in the external TERM
+  entry (using terminal-overrides or a custom terminfo entry).
+
+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, 06 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
@@ -30,8 +575,8 @@ 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)
+* A #{pane_synchronized} format specifier has been added to be a conditional
+  format if a pane is in a synchronised mode (c.f. synchronize-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
@@ -53,7 +598,7 @@ Normal Changes
 * tmux now supports 256 colours running under fbterm.
 * Many bug fixes!
 
-CHANGES FROM 1.7 to 1.8, 26 March 2013
+CHANGES FROM 1.7 TO 1.8, 26 March 2013
 
 Incompatible Changes
 ====================
@@ -104,7 +649,7 @@ Normal Changes
 * Lots and lots of bug fixes, fixing memory-leaks, etc.
 * Various manpage improvements.
 
-CHANGES FROM 1.6 to 1.7, 13 October 2012
+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.
@@ -495,7 +1040,7 @@ CHANGES FROM 1.0 TO 1.1, 05 November 2009
 * xterm-keys rewrite.
 * Additional code reduction, and bug fixes.
 
-CHANGES FROM 0.9 TO 1.0, 20 Sept 2009
+CHANGES FROM 0.9 TO 1.0, 20 September 2009
 
 * Option to alter the format of the window title set by tmux.
 * Backoff for a while after multiple incorrect password attempts.
@@ -831,7 +1376,7 @@ The list of older changes is below.
 * -u flag to scroll-mode and copy-mode to start scrolled one page
   up. scroll-mode -u is bound to prefix,page-up (ppage) by default.
 * Allow status, mode and message attributes to be changed by three new options:
-  status-attr, mode-attr, message-attr. A comma-separataed list is accepted
+  status-attr, mode-attr, message-attr. A comma-separated list is accepted
   containing: bright, dim, underscore, blink, reverse, hidden, italics, for
   example:
 
@@ -1854,10 +2399,3 @@ 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

CONTRIBUTING

@@ -0,0 +1,33 @@
+When reporting issues:
+
+YOU MUST INCLUDE THE TMUX VERSION
+
+DO NOT OPEN AN ISSUE THAT DOES NOT MENTION THE TMUX VERSION
+
+Please also include:
+
+- your platform (Linux, OS X, or whatever);
+- a brief description of the problem with steps to reproduce;
+- a minimal tmux config, if you can't reproduce without a config;
+- your terminal, and $TERM inside and outside of tmux;
+- logs from tmux (see below);
+- at most one or two screenshots, if helpful.
+
+This should include at least the output of:
+
+    $ uname -sp && tmux -V && echo $TERM
+
+Please do not report bugs (crashes, incorrect behaviour) without reproducing on
+a tmux built from Git master.
+
+Note that TERM inside tmux must be a variant of screen or tmux (for example:
+screen or screen-256color, tmux or tmux-256color). Please ensure this is the
+case before opening an issue.
+
+To run tmux without a config and get logs, run:
+
+    tmux -Ltest kill-server
+    tmux -vv -Ltest -f/dev/null new
+
+Then reproduce the problem, exit tmux, and attach the tmux-server-*.log file
+from the current directory to the issue.

FAQ

@@ -1,439 +0,0 @@
-tmux frequently asked questions
-
-******************************************************************************
-* PLEASE NOTE: most display problems are due to incorrect TERM! Before       *
-* reporting problems make SURE that TERM settings are correct inside and     *
-* outside tmux.                                                              *
-*                                                                            *
-* Inside tmux TERM must be "screen" or similar (such as "screen-256color").  *
-* Don't bother reporting problems where it isn't!                            *
-*                                                                            *
-* Outside, it must match your terminal: particularly, use "rxvt" for rxvt    *
-* and derivatives.                                                           *
-******************************************************************************
-
-* How is tmux different from GNU screen?
-
-tmux and GNU screen have many similarities. Some of the main differences I am
-aware of are (bearing in mind I haven't used screen for a few years now):
-
-- tmux uses a client-server model. Each server has single Unix domain socket in
-  /tmp and within one server there are multiple sessions which may be attached
-  to multiple clients (terminals).
-
-  This has advantages, notably: windows may be linked simultaneously to
-  multiple sessions; windows may be moved freely between sessions; and a client
-  may be switched between sessions easily (C-b D). There is one major
-  disadvantage: if the server crashes, game over, all sessions die. In
-  practice, however, tmux is quite stable and gets more so as people report any
-  bugs they hit :-).
-
-  This model is different from screen, where typically each new screen instance
-  is independent. tmux supports the same behaviour by using multiple servers
-  with the -L option but it is not typically recommended.
-
-- Different command interfaces. One of the goals of tmux is that the shell
-  should be easily usable as a scripting language - almost all tmux commands
-  can be used from the shell and behave identically whether used from the
-  shell, from a key binding or from the command prompt. Personally I also find
-  tmux's command interface much more consistent and clearer, but this is
-  subjective.
-
-- tmux calls window names (what you see in the status line) "names", screen
-  calls them "titles".
-
-- tmux has a multiple paste buffers. Not a major one but comes in handy quite a
-  lot.
-
-- tmux supports automatically renaming windows to the running application
-  without gross hacks using escape sequences. Its even on by default.
-
-- tmux has a choice of vi or emacs key layouts. Again, not major, but I use
-  emacs so if tmux did support only one key set it would be emacs and then all
-  the vi users would get humpy. Key bindings may be completely reconfigured in
-  any case.
-
-- tmux has an option to limit the window size.
-
-- tmux has search in windows (C-b f).
-
-- The window split (pane) model is different. tmux has two objects, windows and
-  panes; screen has just windows. This difference has several implications:
-
-  * In screen you can have a window appear in several layouts, in tmux a pane
-  can only be in one window (fixing this is a big todo item but quite
-  invasive).
-
-  * tmux layouts are immutable and do not get changed unless you modify them.
-
-  * In tmux, all panes are closed when you kill a window.
-
-  * tmux panes do not have individual names, titles and so on.
-
-  I think tmux's model is much easier to manage and navigate within a window,
-  but breaking panes off from and joining them to windows is more clumsy.
-
-  tmux also has support for preset pane layouts.
-
-- tmux's status line syntax is more readable and easier to use. I think it'd be
-  hard for anyone to argue with this. tmux doesn't support running a command
-  constantly and always using the last line of its output, commands must be run
-  again each time.
-
-- tmux has modern, easily extended code. Again hard to argue screen is better
-  if you have looked at the code.
-
-- tmux depends on libevent. I don't see this as a disadvantage: libevent is
-  small and portable, and on modern systems with current package management
-  systems dependencies are not an issue. libevent brings advantages in code
-  simplicity and performance.
-
-- screen allows the window to be bigger than the terminal and can pan around
-  it. tmux limits the size to the largest attached client. This is a big todo
-  item for tmux but it is not trivial.
-
-- screen has builtin serial and telnet support; this is bloat and is unlikely
-  to be added to tmux.
-
-- screen has support for updating utmp. Nobody has really come up with a clean,
-  portable way to do this without making tmux setuid or setgid yet.
-
-- Environment handling is different.
-
-- tmux tends to be more demanding on the terminal so tends to show up terminal
-  and application bugs which screen does not.
-
-- screen has wider platform support, for example IRIX, and for odd terminals.
-
-* I found a bug! What do I do?
-
-Please send bug reports by email to nicm@users.sourceforge.net or
-tmux-users@lists.sourceforge.net. Please include as much of the following
-information as possible:
-
-- the version of tmux you are running;
-- the operating system you are using and its version;
-- the terminal emulator you are using and the TERM setting when tmux was
-  started;
-- a description of the problem;
-- if the problem is repeatable, the steps to repeat the problem;
-- for screen corruption issues, a screenshot and the output of "infocmp $TERM"
-  from outside tmux are often very useful.
-
-* Why doesn't tmux do $x?
-
-Please send feature requests by email to nicm@users.sourceforge.net.
-
-* Why do you use the screen terminal description inside tmux? It sucks.
-
-It is already widely available. It is planned to change to something else such
-as xterm-xfree86 at some point, if possible.
-
-* I don't see any colour in my terminal! Help!
-
-On some platforms, common terminal descriptions such as xterm do not include
-colour. screen ignores this, tmux does not. If the terminal emulator in use
-supports colour, use a value for TERM which correctly lists this, such as
-xterm-color.
-
-* tmux freezes my terminal when I attach to a session. I even have to kill -9
-  the shell it was started from to recover!
-
-Some consoles really really don't like attempts to set the window title. Tell
-tmux not to do this by turning off the "set-titles" option (you can do this
-in .tmux.conf):
-
-     set -g set-titles off
-
-If this doesn't fix it, send a bug report.
-
-* Why is C-b the prefix key? How do I change it?
-
-The default key is C-b because the prototype of tmux was originally developed
-inside screen and C-b was chosen not to clash with the screen meta key. It
-also has the advantage of not interfering with the use of C-a for start-of-line
-in emacs and the shell (although it does interfere with previous-character).
-
-Changing is simple: change the "prefix-key" option, and - if required - move
-the binding of the "send-prefix" command from C-b (C-b C-b sends C-b by
-default) to the new key. For example:
-
-	set -g prefix C-a
-	unbind C-b
-	bind C-a send-prefix
-
-* How do I use UTF-8?
-
-When running tmux in a UTF-8 capable terminal, UTF-8 must be turned on in tmux;
-as of release 0.9, tmux attempts to autodetect a UTF-8-capable terminal by
-checking the LC_ALL, LC_CTYPE and LANG environment variables. list-clients may
-be used to check if this is detected correctly; if not, the -u command-line
-flag may be specified when creating or attaching a client to a tmux session:
-
-	$ tmux -u new
-
-Since the 1.0 release, tmux will turn on UTF-8 related options automatically
-(ie status-utf8, and utf8) if the above conditions are met.
-
-* How do I use a 256 colour terminal?
-
-Provided the underlying terminal supports 256 colours, it is usually sufficient
-to add the following to ~/.tmux.conf:
-
-	set -g default-terminal "screen-256color"
-
-Note that some platforms do not support "screen-256color" ("infocmp
-screen-256color" will return an error) - in this case see the next entry in
-this FAQ.
-
-tmux attempts to detect a 256 colour terminal both by looking at the colors
-terminfo entry and by looking for the string "256col" in the TERM environment
-variable.
-
-If both these methods fail, the -2 flag may be passed to tmux when attaching
-to a session to indicate the terminal supports 256 colours.
-
-* vim or $otherprogram doesn't display 256 colours. What's up?
-
-Some programs attempt to detect the number of colours a terminal is capable of
-by checking the colors terminfo or Co termcap entry. However, this is not
-reliable, and in any case is missing from the "screen" terminal description
-used inside tmux.
-
-There are two options (aside from using "screen-256color") to allow programs to
-recognise they are running on a 256-colour terminal inside tmux:
-
-- Manually force the application to use 256 colours always or if TERM is set to
-  screen. For vim, you can do this by overriding the t_Co option, see
-  http://vim.wikia.com/wiki/256_colors_in_vim.
-- Creating a custom terminfo file that includes colors#256 in ~/.terminfo and
-  using it instead. These may be compiled with tic(1).
-
-* How do I make Ctrl-PgUp and Ctrl-PgDn work in vim?
-
-tmux supports passing through ctrl (and where supported by the client terminal,
-alt and shift) modifiers to function keys using xterm(1)-style key sequences.
-This may be enabled per window, or globally with the tmux command:
-
-	setw -g xterm-keys on
-
-Because the TERM variable inside tmux must be set to "screen", vim will not
-automatically detect these keys are available; however, the appropriate key
-sequences can be overridden in .vimrc using the following:
-
-	if &term == "screen"
-	set t_kN=^[[6;*~
-	set t_kP=^[[5;*~
-	endif
-
-And similarly for any other keys for which modifiers are desired.
-
-Please note that the "xterm-keys" setting may affect other programs, in the
-same way as running them in a standard xterm; for example most shells do not
-expect to receive xterm(1)-style key sequences so this setting may prevent keys
-such as ctrl-left and ctrl-right working correctly. tmux also passes through
-the ctrl (bit 5 set, for example ^[[5~ to ^[[5^) modifier in non-xterm(1) mode;
-it may be possible to configure vim to accept these, an example of how to do so
-would be welcome.
-
-vim users may also want to set the "ttyfast" option inside tmux.
-
-* Why doesn't elinks set the window title inside tmux?
-
-There isn't a way to detect if a terminal supports setting the window title, so
-elinks attempts to guess by looking at the environment. Rather than looking for
-TERM=screen, it uses the STY variable to detect if it is running in screen;
-tmux does not use this so the check fails. A workaround is to set STY before
-running elinks.
-
-The following shell function does this, and also clears the window title on
-exit (elinks, for some strange reason, sets it to the value of TERM):
-
-	elinks() {
-        	STY= `which elinks` $*
-	        echo -ne \\033]0\;\\007;
-	}
-
-* What is the proper way to escape characters with #(command)?
-
-When using the #(command) construction to include the output from a command in
-the status line, the command will be parsed twice. First, when it's read by the
-configuration file or the command-prompt parser, and second when the status
-line is being drawn and the command is passed to the shell. For example, to
-echo the string "(test)" to the status line, either single or double quotes
-could be used:
-
-	set -g status-right "#(echo \\\\(test\\\\))"
-	set -g status-right '#(echo \\\(test\\\))'
-
-In both cases, the status-right option will be set to the string "#(echo
-\\(test\\))" and the command executed will be "echo \(test\)".
-
-* tmux uses too much CPU. What do I do?
-
-Automatic window renaming may use a lot of CPU, particularly on slow computers:
-if this is a problem, turn it off with "setw -g automatic-rename off". If this
-doesn't fix it, please report the problem.
-
-* I use PuTTY and my tmux window pane separators are all qqqqqqqqq's! 
-
-PuTTY is using a character set translation that doesn't support ACS line
-drawing. With a Unicode font, try setting PuTTY to use a different translation
-on the Window -> Translation configuration page. For example, change UTF-8 to
-ISO-8859-1 or CP437. It may also be necessary to adjust the way PuTTY treats
-line drawing characters in the lower part of the same configuration page.
-
-* What is the best way to display the load average? Why no #L?
-
-It isn't possible to get the load average portably in code and it is preferable
-not to add portability goop. The following works on at least Linux, *BSD and OS
-X:
-
-uptime|awk '{split(substr($0, index($0, "load")), a, ":"); print a[2]}'
-
-* How do I attach the same session to multiple clients but with a different
-  current window, like screen -x?
-
-One or more of the windows can be linked into multiple sessions manually with
-link-window, or a grouped session with all the windows can be created with
-new-session -t.
-
-* Ctrl and arrow keys doesn't work in putty! What do I do?
-
-putty inverts the sense of the cursor key mode on ctrl, which is a bit hard for
-tmux to detect properly. To get ctrl keys right, change the terminfo settings
-so kUP5 (Ctrl-Up etc) are the adjusted versions, and disable smkx/rmkx so tmux
-doesn't change the mode. For example with this line in .tmux.conf (assuming you
-have TERM set to xterm):
-
-set -g terminal-overrides "xterm*:kLFT5=\eOD:kRIT5=\eOC:kUP5=\eOA:kDN5=\eOB:smkx@:rmkx@"
-
-Note that this will only work in tmux 1.2 and above.
-
-* How can I blank the tmux window?
-
-GNU screen has a feature whereby it will blank the screen after a period of
-inactivity. To do the same thing in tmux, use the lock-command setting, for
-example (with GNU bash):
-
-set -g lock-command 'tput civis && read -s -n1'
-
-This will remove the cursor and tell the shell to quit once a key has been
-pressed. For zsh, use "read -s -k1".
-
-In addition, it's possible to have both blanking and locking (for instance via
-lock(1) or vlock(1)) by using the following:
-
-bind x set lock-command '/usr/bin/vlock' \; lock-client \; set lock-command 'tput civis && read -s -n1'
-
-* vim displays reverse video instead of italics, while less displays italics
-  (or just regular text) instead of reverse. What's wrong?
-
-Screen's terminfo description lacks italics mode and has standout mode in its
-place, but using the same escape sequence that urxvt uses for italics. This
-means applications (like vim) looking for italics will not find it and might
-turn to reverse in its place, while applications (like less) asking for
-standout will end up with italics instead of reverse. To make applications
-aware that tmux supports italics and to use a proper escape sequence for
-standout, you'll need to create a new terminfo file with modified sgr, smso,
-rmso, sitm and ritm entries:
-
-	$ mkdir $HOME/.terminfo/
-	$ screen_terminfo="screen"
-	$ infocmp "$screen_terminfo" | sed \
-	  -e 's/^screen[^|]*|[^,]*,/screen-it|screen with italics support,/' \
-	  -e 's/%?%p1%t;3%/%?%p1%t;7%/' \
-	  -e 's/smso=[^,]*,/smso=\\E[7m,/' \
-	  -e 's/rmso=[^,]*,/rmso=\\E[27m,/' \
-	  -e '$s/$/ sitm=\\E[3m, ritm=\\E[23m,/' > /tmp/screen.terminfo
-	$ tic /tmp/screen.terminfo
-
-And tell tmux to use it in ~/.tmux.conf:
-	
-	set -g default-terminal "screen-it"
-
-If your terminal supports 256 colors, use:
-
-	$ screen_terminfo="screen-256color"
-
-instead of "screen". See the FAQ entry about 256 colors support for more info.
-Also note that tmux will still display reverse video on terminals that do not
-support italics.
-
-If your urxvt cannot display italics at all, make sure you have an italics
-capable font enabled, for example, add to ~/.Xdefaults:
-
-	urxvt.italicFont: xft:Bitstream Vera Sans Mono:italic:autohint=true
-
-* 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 -g 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?
-
-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
-
-$Id$

ISSUE_TEMPLATE

@@ -0,0 +1 @@
+Please read https://raw.githubusercontent.com/tmux/tmux/master/CONTRIBUTING

Makefile.am

@@ -1,4 +1,4 @@
-# $Id$
+# Makefile.am
 
 # Obvious program stuff.
 bin_PROGRAMS = tmux
@@ -6,96 +6,83 @@ CLEANFILES = tmux.1.mdoc tmux.1.man
 
 # Distribution tarball options.
 EXTRA_DIST = \
-	CHANGES FAQ README TODO COPYING examples compat \
-	array.h compat.h tmux.h osdep-*.c mdoc2man.awk tmux.1
-dist-hook:
-	grep "^#found_debug=" configure
-	find $(distdir) -name .svn -type d|xargs rm -Rf
+	CHANGES README COPYING example_tmux.conf compat/*.[ch] \
+	osdep-*.c mdoc2man.awk tmux.1
 
 # Preprocessor flags.
-CPPFLAGS += @XOPEN_DEFINES@ -DTMUX_CONF="\"$(sysconfdir)/tmux.conf\""
+AM_CPPFLAGS += @XOPEN_DEFINES@ -DTMUX_CONF="\"$(sysconfdir)/tmux.conf\""
 
-# glibc as usual does things ass-backwards and hides useful things by default,
-# so everyone has to add this.
-if IS_GLIBC
-CFLAGS += -D_GNU_SOURCE
-endif
+# Additional object files.
+LDADD = $(LIBOBJS)
 
-# Set flags for gcc. gcc4 whines abouts silly stuff so it needs slightly
-# different flags.
+# Set flags for gcc.
 if IS_GCC
-CFLAGS += -std=gnu99
+AM_CFLAGS += -std=gnu99 -O2
 if IS_DEBUG
-CFLAGS += -O0 -g
-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
-CPPFLAGS += -DDEBUG
-else
-CFLAGS += -O2
-endif
-if IS_GCC4
-CPPFLAGS += -iquote. -I/usr/local/include
-if IS_DEBUG
-CFLAGS += -Wno-pointer-sign
-endif
-else
-CPPFLAGS += -I. -I- -I/usr/local/include
+AM_CFLAGS += -g
+AM_CFLAGS += -Wno-long-long -Wall -W -Wformat=2
+AM_CFLAGS += -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations
+AM_CFLAGS += -Wwrite-strings -Wshadow -Wpointer-arith -Wsign-compare
+AM_CFLAGS += -Wundef -Wbad-function-cast -Winline -Wcast-align
+AM_CFLAGS += -Wdeclaration-after-statement -Wno-pointer-sign -Wno-attributes
+AM_CFLAGS += -Wno-unused-result
+AM_CPPFLAGS += -DDEBUG
 endif
+AM_CPPFLAGS += -iquote.
 endif
 
 # Set flags for Solaris.
 if IS_SUNOS
 if IS_GCC
-CPPFLAGS += -D_XPG6 -D__EXTENSIONS__ -D_POSIX_PTHREAD_SEMANTICS
+AM_CPPFLAGS += -D_XPG6
 else
-CPPFLAGS += -D_XPG4_2 -D__EXTENSIONS__ -D_POSIX_PTHREAD_SEMANTICS
+AM_CPPFLAGS += -D_XPG4_2
 endif
 endif
 
 # Set flags for Sun CC.
 if IS_SUNCC
-CFLAGS += -erroff=E_EMPTY_DECLARATION
+AM_CFLAGS += -erroff=E_EMPTY_DECLARATION
+endif
+
+# Set _LINUX_SOURCE_COMPAT for AIX for malloc(0).
+if IS_AIX
+AM_CPPFLAGS += -D_LINUX_SOURCE_COMPAT=1
+endif
+
+# Set flags for NetBSD.
+if IS_NETBSD
+AM_CPPFLAGS += -D_OPENBSD_SOURCE
 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-list.c \
 	cmd-choose-tree.c \
-	cmd-clear-history.c \
-	cmd-clock-mode.c \
 	cmd-command-prompt.c \
 	cmd-confirm-before.c \
 	cmd-copy-mode.c \
-	cmd-delete-buffer.c \
 	cmd-detach-client.c \
 	cmd-display-message.c \
 	cmd-display-panes.c \
 	cmd-find-window.c \
-	cmd-has-session.c \
+	cmd-find.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 \
@@ -124,6 +111,7 @@ dist_tmux_SOURCES = \
 	cmd-send-keys.c \
 	cmd-set-buffer.c \
 	cmd-set-environment.c \
+	cmd-set-hook.c \
 	cmd-set-option.c \
 	cmd-show-environment.c \
 	cmd-show-messages.c \
@@ -131,22 +119,21 @@ dist_tmux_SOURCES = \
 	cmd-source-file.c \
 	cmd-split-window.c \
 	cmd-string.c \
-	cmd-suspend-client.c \
 	cmd-swap-pane.c \
 	cmd-swap-window.c \
 	cmd-switch-client.c \
 	cmd-unbind-key.c \
-	cmd-unlink-window.c \
 	cmd-wait-for.c \
 	cmd.c \
 	colour.c \
-	control.c \
+	compat.h \
 	control-notify.c \
+	control.c \
 	environ.c \
 	format.c \
-	grid-cell.c \
 	grid-view.c \
 	grid.c \
+	hooks.c \
 	input-keys.c \
 	input.c \
 	job.c \
@@ -156,89 +143,49 @@ dist_tmux_SOURCES = \
 	layout-set.c \
 	layout.c \
 	log.c \
-	mode-key.c \
+	mode-tree.c \
 	names.c \
 	notify.c \
 	options-table.c \
 	options.c \
 	paste.c \
+	proc.c \
 	resize.c \
 	screen-redraw.c \
 	screen-write.c \
 	screen.c \
 	server-client.c \
 	server-fn.c \
-	server-window.c \
 	server.c \
 	session.c \
-	signal.c \
 	status.c \
 	style.c \
 	tmux.c \
+	tmux.h \
 	tty-acs.c \
 	tty-keys.c \
 	tty-term.c \
 	tty.c \
 	utf8.c \
-	window-choose.c \
+	window-buffer.c \
+	window-client.c \
 	window-clock.c \
 	window-copy.c \
+	window-tree.c \
 	window.c \
 	xmalloc.c \
+	xmalloc.h \
 	xterm-keys.c
 nodist_tmux_SOURCES = osdep-@PLATFORM@.c
 
-# Pile in all the compat/ stuff that is needed.
-if NO_FORKPTY
+# Add compat file for forkpty.
+if NEED_FORKPTY
 nodist_tmux_SOURCES += compat/forkpty-@PLATFORM@.c
 endif
-if NO_IMSG
-nodist_tmux_SOURCES += compat/imsg.c compat/imsg-buffer.c
-endif
-if NO_CLOSEFROM
-nodist_tmux_SOURCES += compat/closefrom.c
-endif
-if NO_DAEMON
-nodist_tmux_SOURCES += compat/daemon.c
-endif
-if NO_SETENV
-nodist_tmux_SOURCES += compat/setenv.c
-endif
-if NO_STRLCAT
-nodist_tmux_SOURCES += compat/strlcat.c
-endif
-if NO_STRLCPY
-nodist_tmux_SOURCES += compat/strlcpy.c
-endif
-if NO_ASPRINTF
-nodist_tmux_SOURCES += compat/asprintf.c
-endif
-if NO_FGETLN
-nodist_tmux_SOURCES += compat/fgetln.c
-endif
-if NO_GETOPT
-nodist_tmux_SOURCES += compat/getopt.c
-endif
-if NO_STRCASESTR
-nodist_tmux_SOURCES += compat/strcasestr.c
-endif
-if NO_STRSEP
-nodist_tmux_SOURCES += compat/strsep.c
-endif
-if NO_VIS
-nodist_tmux_SOURCES += compat/vis.c compat/unvis.c
-endif
-if NO_STRTONUM
-nodist_tmux_SOURCES += compat/strtonum.c
-endif
-if NO_B64_NTOP
-nodist_tmux_SOURCES += compat/b64_ntop.c
-endif
-if NO_CFMAKERAW
-nodist_tmux_SOURCES += compat/cfmakeraw.c
-endif
-if NO_OPENAT
-nodist_tmux_SOURCES += compat/openat.c
+
+# Add compat file for utf8proc.
+if HAVE_UTF8PROC
+nodist_tmux_SOURCES += compat/utf8proc.c
 endif
 
 # Install tmux.1 in the right format.
@@ -248,23 +195,8 @@ install-exec-hook:
 			>$(srcdir)/tmux.1.mdoc; \
 	else \
 		sed -e "s|@SYSCONFDIR@|$(sysconfdir)|g" $(srcdir)/tmux.1| \
-			$(AWK) -fmdoc2man.awk >$(srcdir)/tmux.1.man; \
+			$(AWK) -f$(srcdir)/mdoc2man.awk >$(srcdir)/tmux.1.man; \
 	fi
-	$(MKDIR_P) $(DESTDIR)$(mandir)/man1
+	$(mkdir_p) $(DESTDIR)$(mandir)/man1
 	$(INSTALL_DATA) $(srcdir)/tmux.1.@MANFORMAT@ \
 		$(DESTDIR)$(mandir)/man1/tmux.1
-
-# Update SF web site.
-upload-index.html: update-index.html
-	scp www/index.html www/main.css www/images/*.png \
-		${USER},tmux@web.sf.net:/home/groups/t/tm/tmux/htdocs
-	rm -f www/index.html www/images/small-*
-
-update-index.html:
-	(cd www/images && \
-		rm -f small-* && \
-		for i in *.png; do \
-			convert "$$i" -resize 200x150 "small-$$i"; \
-		done \
-	)
-	sed "s/%%VERSION%%/${VERSION}/g" www/index.html.in >www/index.html

README

@@ -4,57 +4,68 @@ 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).
+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/
+	http://libevent.org
 
-To build tmux from a release tarball, do:
+It also depends on ncurses, available from:
+
+	http://invisible-island.net/ncurses/
+
+To build and install tmux from a release tarball, use:
 
 	$ ./configure && make
 	$ sudo make install
 
+tmux can use the utempter library to update utmp(5), if it is installed - run
+configure with --enable-utempter to enable this.
+
 To get and build the latest from version control:
 
-	$ git clone git://git.code.sf.net/p/tmux/tmux-code tmux
+	$ git clone https://github.com/tmux/tmux.git
 	$ cd tmux
 	$ sh autogen.sh
 	$ ./configure && make
 
-For more information see https://sourceforge.net/scm/?type=git&group_id=200378
-and http://git-scm.com. Patches should be sent by email to the mailing list at
-tmux-users@lists.sourceforge.net.
+(Note that this requires at least a working C compiler, make, autoconf,
+automake, pkg-config as well as libevent and ncurses libraries and headers.)
+
+For more information see http://git-scm.com. Patches should be sent by email to
+the mailing list at tmux-users@googlegroups.com or submitted through GitHub at
+https://github.com/tmux/tmux/issues.
 
 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.
+A small example configuration in example_tmux.conf.
+
+And a bash(1) completion file at:
+
+	https://github.com/imomaliev/tmux-bash-completion
 
 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:
+tmux mailing lists are available. For general discussion and bug reports:
 
-	https://sourceforge.net/mail/?group_id=200378
+	https://groups.google.com/forum/#!forum/tmux-users
+
+And for Git commit emails:
+
+	https://groups.google.com/forum/#!forum/tmux-git
+
+Subscribe by sending an email to <tmux-users+subscribe@googlegroups.com>.
 
 Bug reports, feature suggestions and especially code contributions are most
 welcome. Please send by email to:
 
-	tmux-users@lists.sourceforge.net
+	tmux-users@googlegroups.com
 
-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.
+This file and the CHANGES, FAQ, SYNCING and TODO files are licensed under the
+ISC license. All other files have a license and copyright notice at their start.
 
--- Nicholas Marriott <nicm@users.sf.net>
-
-$Id$
+-- Nicholas Marriott <nicholas.marriott@gmail.com>

SYNCING

@@ -1,10 +1,10 @@
 Preamble
 ========
 
-Tmux on SourceForge has two git repositories [1] "tmux-code" and "tmux-openbsd".
+Tmux portable relies on  repositories "tmux" and "tmux-openbsd".
 Here's a description of them:
 
-* "tmux-code" is the portable version, the one which contains code for other
+* "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.
 
@@ -17,9 +17,6 @@ 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).
 
-It is assumed that the person doing the sync has read/write access to the
-tmux-code repository on SourceForge already.
-
 If you've never used git before, git tracks meta-data about the committer
 and the author, as part of a commit, hence:
 
@@ -37,11 +34,11 @@ this information has ever been set before.
 Cloning repositories
 ====================
 
-This involves having both tmux-code and tmux-openbsd cloned, as in:
+This involves having both tmux and tmux-openbsd cloned, as in:
 
 % cd /some/where/useful
-% git clone ssh://${USER}@git.code.sf.net/p/tmux/tmux
-% git clone ssh://${USER}@git.code.sf.net/p/tmux/tmux-openbsd
+% 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
@@ -50,56 +47,56 @@ these checkouts existing, skip that.
 Adding in git-remotes
 =====================
 
-Because the portable "tmux-code" git repository and the "tmux-openbsd"
+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-code" repository, as
+clone of the "tmux-openbsd" repository from the "tmux" repository, as
 shown by the following command:
 
-% cd /path/to/tmux-code
+% 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-code" repository, which makes sense because it's the "tmux"
+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-code", we have to ensure the "master" branch from "tmux-openbsd" is
-up-to-date first, and then reference that update in "tmux-code", as in:
+"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-code":
+Then back in "tmux":
 
-% cd /path/to/tmux-code
-% git fetch obsd-tmux-code
+% cd /path/to/tmux
+% git fetch obsd-tmux
 
 Creating the necessary branches
 ===============================
 
-Now that "tmux-code" can see commits and branches from "tmux-openbsd" by way
+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-code" repository:
+"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-code" and the "obsd-master"
+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-code" repository need to be added.  To do this, we must add an
+"tmux" repository need to be added.  To do this, we must add an
 additional refspec line, as in:
 
-% cd /path/to/tmux-code
+% cd /path/to/tmux
 % git config --add remote.origin.fetch '+refs/replace/*:refs/replace/*'
 % git fetch origin
 
@@ -110,7 +107,7 @@ Make sure the "master" branch is checked out:
 
 % git checkout master
 
-The following will show commits on OpenBSD not yet synched with "tmux-code":
+The following will show commits on OpenBSD not yet synched with "tmux":
 
 % git log master..obsd-master
 
@@ -118,7 +115,7 @@ 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:
+Then ensure things look correct by BUILDING the result of that sync:
 
 % make clean && ./autogen.sh && ./configure && make
 
@@ -131,44 +128,46 @@ 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
+1. 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.
 
+2. Make sure configure.ac has the new version number.
+
 3. Tag with:
 
-   % git tag -a 1.X
+   % git tag -a 2.X
 
-   Where "1.X" is the next version.
+   Where "2.X" is the next version.
 
    Push the tag out with:
 
-   % git push 1.X
+   % git push --tags
 
-4. Build the tarball with make dist.  Now that it's using autoconf there
-   shouldn't be any weird files (such as the original and rejection files
-   from patch(1)) but it doesn't hurt taking a quick look at it.
+4. Build the tarball with 'make dist'.
 
-5. Split the release changes into a new file.  This should be named
-   tmux-$VERSION-readme to make sourceforge show it automagically in specific
-   parts of the project page.
+5. Check the tarball.  If it's good, go here to select the tag just pushed:
 
-6. Upload the tarball and the above file. Make the tarball the default
-   download by selecting all operating systems under the file details.
+   https://github.com/tmux/tmux/tags
 
-7. Run make update-index.html upload-index.html to replace %%VERSION%%.
+   Click the "Add release notes", upload the tarball and add a link in the
+   description field to the CHANGES file.
 
-8. Bump version in configure.ac and uncomment "found_debug=yes" to create
-   a debug build by default.
+6. Clone the tmux.github.io repository, and change the RELEASE version in the
+   Makefile.  Commit it, and run 'make' to replace %%RELEASE%%.  Push the
+   result out.
 
-9. Update freshmeat.
-
-[1] https://sourceforge.net/p/tmux/_list/git
+7. Change version back to master in configure.ac.

TODO

@@ -1,40 +1,28 @@
 - command bits and pieces:
-	* use "--" to mark start of command w/ neww etc to avoid quoting
-	* why doesn't command-prompt work if made read-only?
 	* allow multiple targets: fnmatch for -t/-c, for example detach all
 	  clients with -t*
-	* add -c for new-session like new-window
-	* attach should take a pane and select it as well as attaching
 	* ' and " should be parsed the same (eg "\e" vs '\e') in config
 	  and command prompt
 	* last-pane across sessions
-	* exact match operator for targets (or break the substring match
-	  and require eg x* instead of just x)
+	* resize-pane -p to match split-window -p
+	* flag to wait-for to have a timeout and/or to stop waiting when the
+	  client gets a signal
 
 - make command sequences more usable
 	* don't require space after ;
 	* options for error handling: && and ||?
 
 - options bits and pieces:
-	* set-remain-on-exit is a complete hack
 	* way to set socket path from config file
 
 - format improvements:
-	* option to quote format (#{session_name:quoted})
-	* formats need conditions for >0 (for #P)
-	* some way to pad # stuff with spaces, #!2T maybe
-	* status stuff is redundant with formats
-	* last window update time and format for it
+	* option to quote format (#{q:session_name})
+	* some way to pad # stuff with spaces
 	* formats to show if a window is linked into multiple sessions, into
 	  multiple attached sessions, and is the active window in multiple
 	  attached sessions?
-
-- choose mode improvements:
-	* choose-pane command (augment choose-tree to do this?)
-	* 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)
+	* comparison operators like < and > (for #{version}?)
+	* %else statement in config file
 
 - improve monitor-*:
 	* straighten out rules for multiple clients
@@ -44,38 +32,29 @@
 
 - improve mouse support:
 	* bind commands to mouse in different areas? 
-	* more fine-grained options
 	* commands executed when clicking on a pattern (URL)
-	* send arrow key sequences for mouse scroll wheel in alternate screen
-	* 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)
-
-- hooks!
 
 - warts on current naming:
 	* display-time but message-fg/bg/attr
 	* list-* vs show-*
-	* split-window -> split-pane??
-
-- better UTF-8 support:
-	* #22T can split in the middle of UTF-8 characters!
-	* window names and titles
-	* message display
-	* prompt input
-	* multibyte key input
-	* buffer_sample and the choose-* could show UTF-8 properly
 
 - copy/paste improvements:
-	* incremental searching
-	* append to buffer
 	* paste w/o trailing whitespace
-	* named buffers and allow gaps in the stack
 	* command to toggle selection not to move it in copy-mode
+	* regex searching
+	* searching in copy mode should unwrap lines, so if you search for "foobar"
+	  then it should be found even if it is now "foo\nbar" (if the WRAP flag
+	  is set on the line)
+	* capture-pane option to preserve spaces but not join lines
+	* improve word and line selection in copy mode (for example when
+	  dragging it should select by word. compare how xterm works. GitHub
+	  issue 682)
+	* key to search for word under cursor (GitHub issue 1240)
 
 - layout stuff
 	* way to tag a layout as a number/name
 	* maybe keep last layout + size around and if size reverts just put it
-          back
+	  back
 	* revamp layouts: they are too complicated, should be more closely
 	  integrated, should support hints, layout sets should just be a
 	  special case of custom layouts, and we should support panes that are
@@ -83,20 +62,21 @@
 	  panelink to replace layout_cell
 	* way to set hints/limits about pane size for resizing
 	* panning over window (window larger than visible)
-
-- terminfo bits
-	* use a better termcap internally instead of screen, perhaps xterm
-	* use screen-256color when started on 256 colour terminal?
-	* need a tmux terminfo entry to document the extensions we are using in
-	  upstream terminfo
-	* support title stack, both internally and externally (restore on
-	  detach) http://docs.freebsd.org/cgi/getmsg.cgi?fetch=1149299+0+archive/2010/freebsd-questions/20100207.freebsd-questions
+	* a mode where one application can cross two panes (ie x|y, width =
+	  COLUMNS/2 but height = ROWS * 2)
+	* separate active panes for different clients
+	* way to choose where the freed space goes when a pane is killed:
+	  option to kill-pane? GitHub issue 918
 
 - code cleanup
 	* instead of separate window and session options, just one master
 	  options list with each option having a type (window or session), then
 	  options on window, on session, and global. for window options we look
-	  window->session->global, and for session we look session->global
+	  window->session->global, and for session we look session->global.
+	  problem: what about windows in multiple sessions? there are contexts
+	  where we do not know which session, or where multiple choices makes
+	  no sense... could at least have one global list for all types of
+	  global options and keep separate window,session lists
 	* the way pane, window, session destroy is handled is too complicated
 	  and the distinction between session.c, window.c and server-fn.c
 	  functions is not clear. could we just have kill_pane(),
@@ -109,25 +89,45 @@
 	  know about the client, notably:
 		- is this the config file? (cmdq->c == NULL)
 		- is this a command client? (cmdq->c != NULL &&
-                  cmdq->c->session == NULL)
+		  cmdq->c->session == NULL)
 		- is this a control client?
 		- can i do stdin or stdout to this client?
 	  or even guarantee that cmdq->c != NULL and provide a better way to
 	  tell when in the config file - then we use cmdq->c if we need a
 	  client w/o a session else cmd_current_client
-	* optimize pane redraws, 20120318184853.GK10965@yelena.nicm.ath.cx
 
 - miscellaneous
-	* way to keep a job running just read its last line of output for #()
-	 link panes into multiple windows
+	* link panes into multiple windows
 	* live update: server started with -U connects to server, requests
 	  sessions and windows, receives file descriptors
 	* there are inconsistencies in what we get from old shell and what
-	  comes from config for new sessions and windows
-	* multiline status line?
-	* bind commands to key sequences -- make it so ALL keys go through a
-	  table, first an implicit table in which C-b is the only default
-	  binding to a command that says "next key from $othertable" and so
-	  on. means -n can go away as well
-
+	  comes from config for new sessions and windows. likewise, panes and
+	  jobs and run-shell and lock command all start with slightly different
+	  environments
+	* multiline status line? separate command prompt and status line?
+	* automatic pane logging
+	* marks in history, automatically add (move?) one when pane is changed
+	* this doesn't work, need pane reference count probably:
+	  bind -n DoubleClick3Status confirm-before -p "kill-window #I? (y/n)" kill-window
+	* respawn -c flag same as neww etc
+	* marker lines in history (GitHub issue 1042)
+	* tree mode stuff: make command prompt (:) common code so all modes get it,
+	  predefined filters, tag-all key, ...
+	* drag panes and windows around to move/swap them in choose mode
 
+- hooks
+	* more hooks for various things
+	* finish after hooks for special commands. these do not have a hook at
+	  the moment:
+		 attach-session detach-client kill-server respawn-window
+		 swap-window break-pane find-window kill-session rotate-window
+		 switch-client choose-tree if-shell kill-window run-shell
+		 wait-for command-prompt join-pane move-window source-file
+		 confirm-before kill-pane respawn-pane swap-pane
+	  at the moment AFTERHOOK uses current only if target is not valid,
+	  but target is ALWAYS valid - it should use current if no -t flag?
+	  then select-* could use AFTERHOOK
+	* multiple hooks with the same name?
+	* finish hooks for notifys
+	* for session_closed, if no sessions at all, perhaps fake up a
+	  temporary one

alerts.c

@@ -0,0 +1,323 @@
+/* $OpenBSD$ */
+
+/*
+ * Copyright (c) 2015 Nicholas Marriott <nicholas.marriott@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 <event.h>
+#include <stdlib.h>
+
+#include "tmux.h"
+
+static int	alerts_fired;
+
+static void	alerts_timer(int, short, void *);
+static int	alerts_enabled(struct window *, int);
+static void	alerts_callback(int, short, void *);
+static void	alerts_reset(struct window *);
+
+static int	alerts_action_applies(struct winlink *, const char *);
+static int	alerts_check_all(struct window *);
+static int	alerts_check_bell(struct window *);
+static int	alerts_check_activity(struct window *);
+static int	alerts_check_silence(struct window *);
+static void	alerts_set_message(struct winlink *, const char *,
+		    const char *);
+
+static TAILQ_HEAD(, window) alerts_list = TAILQ_HEAD_INITIALIZER(alerts_list);
+
+static void
+alerts_timer(__unused int fd, __unused short events, void *arg)
+{
+	struct window	*w = arg;
+
+	log_debug("@%u alerts timer expired", w->id);
+	alerts_queue(w, WINDOW_SILENCE);
+}
+
+static void
+alerts_callback(__unused int fd, __unused short events, __unused void *arg)
+{
+	struct window	*w, *w1;
+	int		 alerts;
+
+	TAILQ_FOREACH_SAFE(w, &alerts_list, alerts_entry, w1) {
+		alerts = alerts_check_all(w);
+		log_debug("@%u alerts check, alerts %#x", w->id, alerts);
+
+		w->alerts_queued = 0;
+		TAILQ_REMOVE(&alerts_list, w, alerts_entry);
+
+		w->flags &= ~WINDOW_ALERTFLAGS;
+		window_remove_ref(w, __func__);
+	}
+	alerts_fired = 0;
+}
+
+static int
+alerts_action_applies(struct winlink *wl, const char *name)
+{
+	int	action;
+
+	/*
+	 * {bell,activity,silence}-action determines when to alert: none means
+	 * nothing happens, current means only do something for the current
+	 * window and other means only for windows other than the current.
+	 */
+
+	action = options_get_number(wl->session->options, name);
+	if (action == ALERT_ANY)
+		return (1);
+	if (action == ALERT_CURRENT)
+		return (wl == wl->session->curw);
+	if (action == ALERT_OTHER)
+		return (wl != wl->session->curw);
+	return (0);
+}
+
+static int
+alerts_check_all(struct window *w)
+{
+	int	alerts;
+
+	alerts	= alerts_check_bell(w);
+	alerts |= alerts_check_activity(w);
+	alerts |= alerts_check_silence(w);
+	return (alerts);
+}
+
+void
+alerts_check_session(struct session *s)
+{
+	struct winlink	*wl;
+
+	RB_FOREACH(wl, winlinks, &s->windows)
+		alerts_check_all(wl->window);
+}
+
+static int
+alerts_enabled(struct window *w, int flags)
+{
+	if (flags & WINDOW_BELL) {
+		if (options_get_number(w->options, "monitor-bell"))
+			return (1);
+	}
+	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);
+	}
+	return (0);
+}
+
+void
+alerts_reset_all(void)
+{
+	struct window	*w;
+
+	RB_FOREACH(w, windows, &windows)
+		alerts_reset(w);
+}
+
+static void
+alerts_reset(struct window *w)
+{
+	struct timeval	tv;
+
+	if (!event_initialized(&w->alerts_timer))
+		evtimer_set(&w->alerts_timer, alerts_timer, w);
+
+	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)
+{
+	alerts_reset(w);
+
+	if ((w->flags & flags) != flags) {
+		w->flags |= flags;
+		log_debug("@%u alerts flags added %#x", w->id, flags);
+	}
+
+	if (alerts_enabled(w, flags)) {
+		if (!w->alerts_queued) {
+			w->alerts_queued = 1;
+			TAILQ_INSERT_TAIL(&alerts_list, w, alerts_entry);
+			window_add_ref(w, __func__);
+		}
+
+		if (!alerts_fired) {
+			log_debug("alerts check queued (by @%u)", w->id);
+			event_once(-1, EV_TIMEOUT, alerts_callback, NULL, NULL);
+			alerts_fired = 1;
+		}
+	}
+}
+
+static int
+alerts_check_bell(struct window *w)
+{
+	struct winlink	*wl;
+	struct session	*s;
+
+	if (~w->flags & WINDOW_BELL)
+		return (0);
+	if (!options_get_number(w->options, "monitor-bell"))
+		return (0);
+
+	TAILQ_FOREACH(wl, &w->winlinks, wentry)
+		wl->session->flags &= ~SESSION_ALERTED;
+
+	TAILQ_FOREACH(wl, &w->winlinks, wentry) {
+		/*
+		 * Bells are allowed even if there is an existing bell (so do
+		 * not check WINLINK_BELL).
+		 */
+		s = wl->session;
+		if (s->curw != wl) {
+			wl->flags |= WINLINK_BELL;
+			server_status_session(s);
+		}
+		if (!alerts_action_applies(wl, "bell-action"))
+			continue;
+		notify_winlink("alert-bell", wl);
+
+		if (s->flags & SESSION_ALERTED)
+			continue;
+		s->flags |= SESSION_ALERTED;
+
+		alerts_set_message(wl, "Bell", "visual-bell");
+	}
+
+	return (WINDOW_BELL);
+}
+
+static int
+alerts_check_activity(struct window *w)
+{
+	struct winlink	*wl;
+	struct session	*s;
+
+	if (~w->flags & WINDOW_ACTIVITY)
+		return (0);
+	if (!options_get_number(w->options, "monitor-activity"))
+		return (0);
+
+	TAILQ_FOREACH(wl, &w->winlinks, wentry)
+		wl->session->flags &= ~SESSION_ALERTED;
+
+	TAILQ_FOREACH(wl, &w->winlinks, wentry) {
+		if (wl->flags & WINLINK_ACTIVITY)
+			continue;
+		s = wl->session;
+		if (s->curw != wl) {
+			wl->flags |= WINLINK_ACTIVITY;
+			server_status_session(s);
+		}
+		if (!alerts_action_applies(wl, "activity-action"))
+			continue;
+		notify_winlink("alert-activity", wl);
+
+		if (s->flags & SESSION_ALERTED)
+			continue;
+		s->flags |= SESSION_ALERTED;
+
+		alerts_set_message(wl, "Activity", "visual-activity");
+	}
+
+	return (WINDOW_ACTIVITY);
+}
+
+static int
+alerts_check_silence(struct window *w)
+{
+	struct winlink	*wl;
+	struct session	*s;
+
+	if (~w->flags & WINDOW_SILENCE)
+		return (0);
+	if (options_get_number(w->options, "monitor-silence") == 0)
+		return (0);
+
+	TAILQ_FOREACH(wl, &w->winlinks, wentry)
+		wl->session->flags &= ~SESSION_ALERTED;
+
+	TAILQ_FOREACH(wl, &w->winlinks, wentry) {
+		if (wl->flags & WINLINK_SILENCE)
+			continue;
+		s = wl->session;
+		if (s->curw != wl) {
+			wl->flags |= WINLINK_SILENCE;
+			server_status_session(s);
+		}
+		if (!alerts_action_applies(wl, "silence-action"))
+			continue;
+		notify_winlink("alert-silence", wl);
+
+		if (s->flags & SESSION_ALERTED)
+			continue;
+		s->flags |= SESSION_ALERTED;
+
+		alerts_set_message(wl, "Silence", "visual-silence");
+	}
+
+	return (WINDOW_SILENCE);
+}
+
+static void
+alerts_set_message(struct winlink *wl, const char *type, const char *option)
+{
+	struct client	*c;
+	int		 visual;
+
+	/*
+	 * We have found an alert (bell, activity or silence), so we need to
+	 * pass it on to the user. For each client attached to this session,
+	 * decide whether a bell, message or both is needed.
+	 *
+	 * If visual-{bell,activity,silence} is on, then a message is
+	 * substituted for a bell; if it is off, a bell is sent as normal; both
+	 * mean both a bell and message is sent.
+	 */
+
+	visual = options_get_number(wl->session->options, option);
+	TAILQ_FOREACH(c, &clients, entry) {
+		if (c->session != wl->session || c->flags & CLIENT_CONTROL)
+			continue;
+
+		if (visual == VISUAL_OFF || visual == VISUAL_BOTH)
+			tty_putcode(&c->tty, TTYC_BEL);
+		if (visual == VISUAL_OFF)
+			continue;
+		if (c->session->curw == wl)
+			status_message_set(c, "%s in current window", type);
+		else
+			status_message_set(c, "%s in window %d", type, wl->idx);
+	}
+}

arguments.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2010 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2010 Nicholas Marriott <nicholas.marriott@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
@@ -28,43 +28,26 @@
  * Manipulate command arguments.
  */
 
-struct args_entry	*args_find(struct args *, u_char);
+struct args_entry {
+	u_char			 flag;
+	char			*value;
+	RB_ENTRY(args_entry)	 entry;
+};
 
-RB_GENERATE(args_tree, args_entry, entry, args_cmp);
+static struct args_entry	*args_find(struct args *, u_char);
+
+static int	args_cmp(struct args_entry *, struct args_entry *);
+RB_GENERATE_STATIC(args_tree, args_entry, entry, args_cmp);
 
 /* Arguments tree comparison function. */
-int
+static 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, ...)
-{
-	struct args	*args;
-	va_list		 ap;
-	int		 i;
-
-	args = xcalloc(1, sizeof *args);
-
-	args->argc = argc;
-	if (argc == 0)
-		args->argv = NULL;
-	else
-		args->argv = xcalloc(argc, sizeof *args->argv);
-
-	va_start(ap, argc);
-	for (i = 0; i < argc; i++)
-		args->argv[i] = xstrdup(va_arg(ap, char *));
-	va_end(ap);
-
-	return (args);
-}
-
 /* Find a flag in the arguments tree. */
-struct args_entry *
+static struct args_entry *
 args_find(struct args *args, u_char ch)
 {
 	struct args_entry	entry;
@@ -121,78 +104,93 @@ args_free(struct args *args)
 	free(args);
 }
 
-/* Print a set of arguments. */
-size_t
-args_print(struct args *args, char *buf, size_t len)
+/* Add to string. */
+static void printflike(3, 4)
+args_print_add(char **buf, size_t *len, const char *fmt, ...)
 {
-	size_t		 	 off;
-	int			 i;
-	const char		*quotes;
-	struct args_entry	*entry;
+	va_list  ap;
+	char	*s;
+	size_t	 slen;
 
-	/* There must be at least one byte at the start. */
-	if (len == 0)
-		return (0);
-	off = 0;
+	va_start(ap, fmt);
+	slen = xvasprintf(&s, fmt, ap);
+	va_end(ap);
+
+	*len += slen;
+	*buf = xrealloc(*buf, *len);
+
+	strlcat(*buf, s, *len);
+	free(s);
+}
+
+/* Print a set of arguments. */
+char *
+args_print(struct args *args)
+{
+	size_t		 	 len;
+	char			*buf, *escaped;
+	int			 i, flags;
+	struct args_entry	*entry;
+	static const char	 quoted[] = " #\"';$";
+
+	len = 1;
+	buf = xcalloc(1, len);
 
 	/* Process the flags first. */
-	buf[off++] = '-';
 	RB_FOREACH(entry, args_tree, &args->tree) {
 		if (entry->value != NULL)
 			continue;
 
-		if (off == len - 1) {
-			buf[off] = '\0';
-			return (len);
-		}
-		buf[off++] = entry->flag;
-		buf[off] = '\0';
+		if (*buf == '\0')
+			args_print_add(&buf, &len, "-");
+		args_print_add(&buf, &len, "%c", entry->flag);
 	}
-	if (off == 1)
-		buf[--off] = '\0';
 
 	/* Then the flags with arguments. */
 	RB_FOREACH(entry, args_tree, &args->tree) {
 		if (entry->value == NULL)
 			continue;
 
-		if (off >= len) {
-			/* snprintf will have zero terminated. */
-			return (len);
-		}
-
-		if (strchr(entry->value, ' ') != NULL)
-			quotes = "\"";
+		if (*buf != '\0')
+			args_print_add(&buf, &len, " -%c ", entry->flag);
 		else
-			quotes = "";
-		off += xsnprintf(buf + off, len - off, "%s-%c %s%s%s",
-		    off != 0 ? " " : "", entry->flag, quotes, entry->value,
-		    quotes);
+			args_print_add(&buf, &len, "-%c ", entry->flag);
+
+		flags = VIS_OCTAL|VIS_TAB|VIS_NL;
+		if (entry->value[strcspn(entry->value, quoted)] != '\0')
+			flags |= VIS_DQ;
+		utf8_stravis(&escaped, entry->value, flags);
+		if (flags & VIS_DQ)
+			args_print_add(&buf, &len, "\"%s\"", escaped);
+		else
+			args_print_add(&buf, &len, "%s", escaped);
+		free(escaped);
 	}
 
 	/* And finally the argument vector. */
 	for (i = 0; i < args->argc; i++) {
-		if (off >= len) {
-			/* snprintf will have zero terminated. */
-			return (len);
-		}
+		if (*buf != '\0')
+			args_print_add(&buf, &len, " ");
 
-		if (strchr(args->argv[i], ' ') != NULL)
-			quotes = "\"";
+		flags = VIS_OCTAL|VIS_TAB|VIS_NL;
+		if (args->argv[i][strcspn(args->argv[i], quoted)] != '\0')
+			flags |= VIS_DQ;
+		utf8_stravis(&escaped, args->argv[i], flags);
+		if (flags & VIS_DQ)
+			args_print_add(&buf, &len, "\"%s\"", escaped);
 		else
-			quotes = "";
-		off += xsnprintf(buf + off, len - off, "%s%s%s%s",
-		    off != 0 ? " " : "", quotes, args->argv[i], quotes);
+			args_print_add(&buf, &len, "%s", escaped);
+		free(escaped);
 	}
 
-	return (off);
+	return (buf);
 }
 
 /* Return if an argument is present. */
 int
 args_has(struct args *args, u_char ch)
 {
-	return (args_find(args, ch) == NULL ? 0 : 1);
+	return (args_find(args, ch) != NULL);
 }
 
 /* Set argument value in the arguments tree. */

array.h

@@ -1,120 +0,0 @@
-/* $Id$ */
-
-/*
- * Copyright (c) 2006 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.
- */
-
-#ifndef ARRAY_H
-#define ARRAY_H
-
-#define ARRAY_INITIALIZER { NULL, 0, 0 }
-
-#define ARRAY_DECL(n, c)						\
-	struct n {							\
-		c	*list;						\
-		u_int	 num;						\
-		size_t	 space;						\
-	}
-
-#define ARRAY_ITEM(a, i) ((a)->list[i])
-#define ARRAY_ITEMSIZE(a) (sizeof *(a)->list)
-#define ARRAY_INITIALSPACE(a) (10 * ARRAY_ITEMSIZE(a))
-
-#define ARRAY_ENSURE(a, n) do {						\
-	if (UINT_MAX - (n) < (a)->num)					\
-		fatalx("number too big");				\
-	if (SIZE_MAX / ((a)->num + (n)) < ARRAY_ITEMSIZE(a))		\
-		fatalx("size too big");					\
-	if ((a)->space == 0) {						\
-	       	(a)->space = ARRAY_INITIALSPACE(a);			\
-		(a)->list = xrealloc((a)->list, 1, (a)->space);		\
-	}								\
-	while ((a)->space <= ((a)->num + (n)) * ARRAY_ITEMSIZE(a)) {	\
-		(a)->list = xrealloc((a)->list, 2, (a)->space);		\
-		(a)->space *= 2;					\
-	}								\
-} while (0)
-
-#define ARRAY_EMPTY(a) (((void *) (a)) == NULL || (a)->num == 0)
-#define ARRAY_LENGTH(a) ((a)->num)
-#define ARRAY_DATA(a) ((a)->list)
-
-#define ARRAY_FIRST(a) ARRAY_ITEM(a, 0)
-#define ARRAY_LAST(a) ARRAY_ITEM(a, (a)->num - 1)
-
-#define ARRAY_INIT(a) do {						\
-	(a)->num = 0;							\
-	(a)->list = NULL;		 				\
-	(a)->space = 0;							\
-} while (0)
-#define ARRAY_CLEAR(a) do {						\
-	(a)->num = 0;							\
-} while (0)
-
-#define ARRAY_SET(a, i, s) do {						\
-	(a)->list[i] = s;						\
-} while (0)
-
-#define ARRAY_ADD(a, s) do {						\
-	ARRAY_ENSURE(a, 1);						\
-	(a)->list[(a)->num] = s;					\
-	(a)->num++;							\
-} while (0)
-#define ARRAY_INSERT(a, i, s) do {					\
-	ARRAY_ENSURE(a, 1);						\
-	if ((i) < (a)->num) {						\
-		memmove((a)->list + (i) + 1, (a)->list + (i), 		\
-		    ARRAY_ITEMSIZE(a) * ((a)->num - (i)));		\
-	}								\
-	(a)->list[i] = s;						\
-	(a)->num++;							\
-} while (0)
-#define ARRAY_REMOVE(a, i) do {						\
-	if ((i) < (a)->num - 1) {					\
-		memmove((a)->list + (i), (a)->list + (i) + 1, 		\
-		    ARRAY_ITEMSIZE(a) * ((a)->num - (i) - 1));		\
-	}								\
-	(a)->num--;							\
-	if ((a)->num == 0)						\
-		ARRAY_FREE(a);						\
-} while (0)
-
-#define ARRAY_EXPAND(a, n) do {						\
-	ARRAY_ENSURE(a, n);						\
-	(a)->num += n;							\
-} while (0)
-#define ARRAY_TRUNC(a, n) do {						\
-	if ((a)->num > n)						\
-		(a)->num -= n;				       		\
-	else								\
-		ARRAY_FREE(a);						\
-} while (0)
-
-#define ARRAY_CONCAT(a, b) do {						\
-	ARRAY_ENSURE(a, (b)->num);					\
-	memcpy((a)->list + (a)->num, (b)->list, (b)->num * ARRAY_ITEMSIZE(a)); \
-	(a)->num += (b)->num;						\
-} while (0)
-
-#define ARRAY_FREE(a) do {						\
-	free((a)->list);						\
-	ARRAY_INIT(a);							\
-} while (0)
-#define ARRAY_FREEALL(a) do {						\
-	ARRAY_FREE(a);							\
-	free(a);							\
-} while (0)
-
-#endif

attributes.c

@@ -1,4 +1,4 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
  * Copyright (c) 2009 Joshua Elsasser <josh@elsasser.org>
@@ -23,7 +23,7 @@
 #include "tmux.h"
 
 const char *
-attributes_tostring(u_char attr)
+attributes_tostring(int attr)
 {
 	static char	buf[128];
 	size_t		len;
@@ -31,14 +31,15 @@ attributes_tostring(u_char attr)
 	if (attr == 0)
 		return ("none");
 
-	len = xsnprintf(buf, sizeof buf, "%s%s%s%s%s%s%s",
-		attr & GRID_ATTR_BRIGHT ? "bright," : "",
-		attr & GRID_ATTR_DIM ? "dim," : "",
-		attr & GRID_ATTR_UNDERSCORE ? "underscore," : "",
-		attr & GRID_ATTR_BLINK ? "blink," : "",
-		attr & GRID_ATTR_REVERSE ? "reverse," : "",
-		attr & GRID_ATTR_HIDDEN ? "hidden," : "",
-		attr & GRID_ATTR_ITALICS ? "italics," : "");
+	len = xsnprintf(buf, sizeof buf, "%s%s%s%s%s%s%s%s",
+	    (attr & GRID_ATTR_BRIGHT) ? "bright," : "",
+	    (attr & GRID_ATTR_DIM) ? "dim," : "",
+	    (attr & GRID_ATTR_UNDERSCORE) ? "underscore," : "",
+	    (attr & GRID_ATTR_BLINK)? "blink," : "",
+	    (attr & GRID_ATTR_REVERSE) ? "reverse," : "",
+	    (attr & GRID_ATTR_HIDDEN) ? "hidden," : "",
+	    (attr & GRID_ATTR_ITALICS) ? "italics," : "",
+	    (attr & GRID_ATTR_STRIKETHROUGH) ? "strikethrough," : "");
 	if (len > 0)
 		buf[len - 1] = '\0';
 
@@ -49,7 +50,7 @@ int
 attributes_fromstring(const char *str)
 {
 	const char	delimiters[] = " ,|";
-	u_char		attr;
+	int		attr;
 	size_t		end;
 
 	if (*str == '\0' || strcspn(str, delimiters) == 0)
@@ -78,6 +79,8 @@ attributes_fromstring(const char *str)
 			attr |= GRID_ATTR_HIDDEN;
 		else if (end == 7 && strncasecmp(str, "italics", end) == 0)
 			attr |= GRID_ATTR_ITALICS;
+		else if (end == 13 && strncasecmp(str, "strikethrough", end) == 0)
+			attr |= GRID_ATTR_STRIKETHROUGH;
 		else
 			return (-1);
 		str += end + strspn(str + end, delimiters);

autogen.sh

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

cfg.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@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
@@ -17,7 +17,6 @@
  */
 
 #include <sys/types.h>
-#include <sys/stat.h>
 
 #include <ctype.h>
 #include <errno.h>
@@ -27,140 +26,334 @@
 
 #include "tmux.h"
 
-struct cmd_q		*cfg_cmd_q;
-int			 cfg_finished;
-int			 cfg_references;
-struct causelist	 cfg_causes;
-struct client		*cfg_client;
+/* Condition for %if, %elif, %else and %endif. */
+struct cfg_cond {
+	size_t			line;		/* line number of %if */
+	int			met;		/* condition was met */
+	int			skip;		/* skip later %elif/%else */
+	int			saw_else;	/* saw a %else */
 
-int
-load_cfg(const char *path, struct cmd_q *cmdq, char **cause)
+	TAILQ_ENTRY(cfg_cond)	entry;
+};
+TAILQ_HEAD(cfg_conds, cfg_cond);
+
+static char		 *cfg_file;
+int			  cfg_finished;
+static char		**cfg_causes;
+static u_int		  cfg_ncauses;
+static struct cmdq_item	 *cfg_item;
+
+static enum cmd_retval
+cfg_client_done(__unused struct cmdq_item *item, __unused void *data)
 {
-	FILE		*f;
-	u_int		 n, found;
-	char		*buf, *copy, *line, *cause1, *msg;
-	size_t		 len, oldlen;
-	struct cmd_list	*cmdlist;
-
-	log_debug("loading %s", path);
-	if ((f = fopen(path, "rb")) == NULL) {
-		xasprintf(cause, "%s: %s", path, strerror(errno));
-		return (-1);
-	}
-
-	n = found = 0;
-	line = NULL;
-	while ((buf = fgetln(f, &len))) {
-		/* Trim \n. */
-		if (buf[len - 1] == '\n')
-			len--;
-		log_debug("%s: %.*s", path, (int)len, buf);
-
-		/* Current line is the continuation of the previous one. */
-		if (line != NULL) {
-			oldlen = strlen(line);
-			line = xrealloc(line, 1, oldlen + len + 1);
-		} else {
-			oldlen = 0;
-			line = xmalloc(len + 1);
-		}
-
-		/* Append current line to the previous. */
-		memcpy(line + oldlen, buf, len);
-		line[oldlen + len] = '\0';
-		n++;
-
-		/* Continuation: get next line? */
-		len = strlen(line);
-		if (len > 0 && line[len - 1] == '\\') {
-			line[len - 1] = '\0';
-
-			/* Ignore escaped backslash at EOL. */
-			if (len > 1 && line[len - 2] != '\\')
-				continue;
-		}
-		copy = line;
-		line = NULL;
-
-		/* Skip empty lines. */
-		buf = copy;
-		while (isspace((u_char)*buf))
-			buf++;
-		if (*buf == '\0') {
-			free(copy);
-			continue;
-		}
-
-		/* Parse and run the command. */
-		if (cmd_string_parse(buf, &cmdlist, path, n, &cause1) != 0) {
-			free(copy);
-			if (cause1 == NULL)
-				continue;
-			xasprintf(&msg, "%s:%u: %s", path, n, cause1);
-			ARRAY_ADD(&cfg_causes, msg);
-			free(cause1);
-			continue;
-		}
-		free(copy);
-
-		if (cmdlist == NULL)
-			continue;
-		cmdq_append(cmdq, cmdlist);
-		cmd_list_free(cmdlist);
-		found++;
-	}
-	if (line != NULL)
-		free(line);
-	fclose(f);
-
-	return (found);
+	if (!cfg_finished)
+		return (CMD_RETURN_WAIT);
+	return (CMD_RETURN_NORMAL);
 }
 
-void
-cfg_default_done(unused struct cmd_q *cmdq)
+static enum cmd_retval
+cfg_done(__unused struct cmdq_item *item, __unused void *data)
 {
-	if (--cfg_references != 0)
-		return;
+	if (cfg_finished)
+		return (CMD_RETURN_NORMAL);
 	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_item != NULL)
+		cfg_item->flags &= ~CMDQ_WAITING;
 
-	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);
-		cfg_client->references--;
-		cfg_client = NULL;
+	status_prompt_load_history();
+
+	return (CMD_RETURN_NORMAL);
+}
+
+void
+set_cfg_file(const char *path)
+{
+	free(cfg_file);
+	cfg_file = xstrdup(path);
+}
+
+void
+start_cfg(void)
+{
+	const char	*home;
+	int		 quiet = 0;
+	struct client	*c;
+
+	/*
+	 * Configuration files are loaded without a client, so NULL is passed
+	 * into load_cfg() and commands run in the global queue with
+	 * item->client NULL.
+	 *
+	 * However, we must block the initial client (but just the initial
+	 * client) so that its command runs after the configuration is loaded.
+	 * Because start_cfg() is called so early, we can be sure the client's
+	 * command queue is currently empty and our callback will be at the
+	 * front - we need to get in before MSG_COMMAND.
+	 */
+	c = TAILQ_FIRST(&clients);
+	if (c != NULL) {
+		cfg_item = cmdq_get_callback(cfg_client_done, NULL);
+		cmdq_append(c, cfg_item);
 	}
+
+	load_cfg(TMUX_CONF, NULL, NULL, 1);
+
+	if (cfg_file == NULL && (home = find_home()) != NULL) {
+		xasprintf(&cfg_file, "%s/.tmux.conf", home);
+		quiet = 1;
+	}
+	if (cfg_file != NULL)
+		load_cfg(cfg_file, NULL, NULL, quiet);
+
+	cmdq_append(NULL, cmdq_get_callback(cfg_done, NULL));
+}
+
+static int
+cfg_check_condition(const char *path, size_t line, const char *p, int *skip)
+{
+	struct format_tree	*ft;
+	char			*s;
+	int			 result;
+
+	while (isspace((u_char)*p))
+		p++;
+	if (p[0] == '\0') {
+		cfg_add_cause("%s:%zu: invalid condition", path, line);
+		*skip = 1;
+		return (0);
+	}
+
+	ft = format_create(NULL, NULL, FORMAT_NONE, FORMAT_NOJOBS);
+	s = format_expand(ft, p);
+	result = format_true(s);
+	free(s);
+	format_free(ft);
+
+	*skip = result;
+	return (result);
+}
+
+static void
+cfg_handle_if(const char *path, size_t line, struct cfg_conds *conds,
+    const char *p)
+{
+	struct cfg_cond	*cond;
+	struct cfg_cond	*parent = TAILQ_FIRST(conds);
+
+	/*
+	 * Add a new condition. If a previous condition exists and isn't
+	 * currently met, this new one also can't be met.
+	 */
+	cond = xcalloc(1, sizeof *cond);
+	cond->line = line;
+	if (parent == NULL || parent->met)
+		cond->met = cfg_check_condition(path, line, p, &cond->skip);
+	else
+		cond->skip = 1;
+	cond->saw_else = 0;
+	TAILQ_INSERT_HEAD(conds, cond, entry);
+}
+
+static void
+cfg_handle_elif(const char *path, size_t line, struct cfg_conds *conds,
+    const char *p)
+{
+	struct cfg_cond	*cond = TAILQ_FIRST(conds);
+
+	/*
+	 * If a previous condition exists and wasn't met, check this
+	 * one instead and change the state.
+	 */
+	if (cond == NULL || cond->saw_else)
+		cfg_add_cause("%s:%zu: unexpected %%elif", path, line);
+	else if (!cond->skip)
+		cond->met = cfg_check_condition(path, line, p, &cond->skip);
+	else
+		cond->met = 0;
+}
+
+static void
+cfg_handle_else(const char *path, size_t line, struct cfg_conds *conds)
+{
+	struct cfg_cond	*cond = TAILQ_FIRST(conds);
+
+	/*
+	 * If a previous condition exists and wasn't met and wasn't already
+	 * %else, use this one instead.
+	 */
+	if (cond == NULL || cond->saw_else) {
+		cfg_add_cause("%s:%zu: unexpected %%else", path, line);
+		return;
+	}
+	cond->saw_else = 1;
+	cond->met = !cond->skip;
+	cond->skip = 1;
+}
+
+static void
+cfg_handle_endif(const char *path, size_t line, struct cfg_conds *conds)
+{
+	struct cfg_cond	*cond = TAILQ_FIRST(conds);
+
+	/*
+	 * Remove previous condition if one exists.
+	 */
+	if (cond == NULL) {
+		cfg_add_cause("%s:%zu: unexpected %%endif", path, line);
+		return;
+	}
+	TAILQ_REMOVE(conds, cond, entry);
+	free(cond);
+}
+
+static void
+cfg_handle_directive(const char *p, const char *path, size_t line,
+    struct cfg_conds *conds)
+{
+	int	n = 0;
+
+	while (p[n] != '\0' && !isspace((u_char)p[n]))
+		n++;
+	if (strncmp(p, "%if", n) == 0)
+		cfg_handle_if(path, line, conds, p + n);
+	else if (strncmp(p, "%elif", n) == 0)
+		cfg_handle_elif(path, line, conds, p + n);
+	else if (strcmp(p, "%else") == 0)
+		cfg_handle_else(path, line, conds);
+	else if (strcmp(p, "%endif") == 0)
+		cfg_handle_endif(path, line, conds);
+	else
+		cfg_add_cause("%s:%zu: invalid directive: %s", path, line, p);
+}
+
+int
+load_cfg(const char *path, struct client *c, struct cmdq_item *item, int quiet)
+{
+	FILE			*f;
+	const char		 delim[3] = { '\\', '\\', '\0' };
+	u_int			 found = 0;
+	size_t			 line = 0;
+	char			*buf, *cause1, *p, *q;
+	struct cmd_list		*cmdlist;
+	struct cmdq_item	*new_item;
+	struct cfg_cond		*cond, *cond1;
+	struct cfg_conds	 conds;
+
+	TAILQ_INIT(&conds);
+
+	log_debug("loading %s", path);
+	if ((f = fopen(path, "rb")) == NULL) {
+		if (errno == ENOENT && quiet)
+			return (0);
+		cfg_add_cause("%s: %s", path, strerror(errno));
+		return (-1);
+	}
+
+	while ((buf = fparseln(f, NULL, &line, delim, 0)) != NULL) {
+		log_debug("%s: %s", path, buf);
+
+		p = buf;
+		while (isspace((u_char)*p))
+			p++;
+		if (*p == '\0') {
+			free(buf);
+			continue;
+		}
+		q = p + strlen(p) - 1;
+		while (q != p && isspace((u_char)*q))
+			*q-- = '\0';
+
+		if (*p == '%') {
+			cfg_handle_directive(p, path, line, &conds);
+			continue;
+		}
+		cond = TAILQ_FIRST(&conds);
+		if (cond != NULL && !cond->met)
+			continue;
+
+		cmdlist = cmd_string_parse(p, path, line, &cause1);
+		if (cmdlist == NULL) {
+			free(buf);
+			if (cause1 == NULL)
+				continue;
+			cfg_add_cause("%s:%zu: %s", path, line, cause1);
+			free(cause1);
+			continue;
+		}
+		free(buf);
+
+		new_item = cmdq_get_command(cmdlist, NULL, NULL, 0);
+		if (item != NULL)
+			cmdq_insert_after(item, new_item);
+		else
+			cmdq_append(c, new_item);
+		cmd_list_free(cmdlist);
+
+		found++;
+	}
+	fclose(f);
+
+	TAILQ_FOREACH_REVERSE_SAFE(cond, &conds, cfg_conds, entry, cond1) {
+		cfg_add_cause("%s:%zu: unterminated %%if", path, cond->line);
+		TAILQ_REMOVE(&conds, cond, entry);
+		free(cond);
+	}
+
+	return (found);
+}
+
+void
+cfg_add_cause(const char *fmt, ...)
+{
+	va_list	 ap;
+	char	*msg;
+
+	va_start(ap, fmt);
+	xvasprintf(&msg, fmt, ap);
+	va_end(ap);
+
+	cfg_ncauses++;
+	cfg_causes = xreallocarray(cfg_causes, cfg_ncauses, sizeof *cfg_causes);
+	cfg_causes[cfg_ncauses - 1] = msg;
+}
+
+void
+cfg_print_causes(struct cmdq_item *item)
+{
+	u_int	 i;
+
+	for (i = 0; i < cfg_ncauses; i++) {
+		cmdq_print(item, "%s", cfg_causes[i]);
+		free(cfg_causes[i]);
+	}
+
+	free(cfg_causes);
+	cfg_causes = NULL;
+	cfg_ncauses = 0;
 }
 
 void
 cfg_show_causes(struct session *s)
 {
 	struct window_pane	*wp;
-	char			*cause;
 	u_int			 i;
 
-	if (s == NULL || ARRAY_EMPTY(&cfg_causes))
+	if (s == NULL || cfg_ncauses == 0)
 		return;
 	wp = s->curw->window->active;
 
-	window_pane_set_mode(wp, &window_copy_mode);
+	window_pane_set_mode(wp, &window_copy_mode, NULL, NULL);
 	window_copy_init_for_output(wp);
-	for (i = 0; i < ARRAY_LENGTH(&cfg_causes); i++) {
-		cause = ARRAY_ITEM(&cfg_causes, i);
-		window_copy_add(wp, "%s", cause);
-		free(cause);
+	for (i = 0; i < cfg_ncauses; i++) {
+		window_copy_add(wp, "%s", cfg_causes[i]);
+		free(cfg_causes[i]);
 	}
-	ARRAY_FREE(&cfg_causes);
+
+	free(cfg_causes);
+	cfg_causes = NULL;
+	cfg_ncauses = 0;
 }

clock.c

@@ -1,166 +0,0 @@
-/* $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;
-	struct tm		*tm;
-	u_int			 i, j, x, y, idx;
-
-	t = time(NULL);
-	tm = localtime(&t);
-	if (style == 0) {
-		strftime(tim, sizeof tim, "%l:%M ", localtime(&t));
-		if (tm->tm_hour >= 12)
-			strlcat(tim, "PM", sizeof tim);
-		else
-			strlcat(tim, "AM", sizeof tim);
-	} else
-		strftime(tim, sizeof tim, "%H:%M", tm);
-
-
-	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,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -30,166 +30,142 @@
  * Attach existing session to the current terminal.
  */
 
-enum cmd_retval	cmd_attach_session_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_attach_session_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_attach_session_entry = {
-	"attach-session", "attach",
-	"c:drt:", 0, 0,
-	"[-dr] [-c working-directory] " CMD_TARGET_SESSION_USAGE,
-	CMD_CANTNEST|CMD_STARTSERVER,
-	NULL,
-	cmd_attach_session_exec
+	.name = "attach-session",
+	.alias = "attach",
+
+	.args = { "c:dErt:", 0, 0 },
+	.usage = "[-dEr] [-c working-directory] " CMD_TARGET_SESSION_USAGE,
+
+	/* -t is special */
+
+	.flags = CMD_STARTSERVER,
+	.exec = cmd_attach_session_exec
 };
 
 enum cmd_retval
-cmd_attach_session(struct cmd_q *cmdq, const char *tflag, int dflag, int rflag,
-    const char *cflag)
+cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
+    int rflag, const char *cflag, int Eflag)
 {
+	struct cmd_find_state	*current = &item->shared->current;
+	enum cmd_find_type	 type;
+	int			 flags;
+	struct client		*c = item->client, *c_loop;
 	struct session		*s;
-	struct client		*c;
-	struct winlink		*wl = NULL;
-	struct window		*w = NULL;
-	struct window_pane	*wp = NULL;
-	const char		*update;
+	struct winlink		*wl;
+	struct window_pane	*wp;
 	char			*cause;
-	u_int			 i;
-	int			 fd;
-	struct format_tree	*ft;
-	char			*cp;
 
 	if (RB_EMPTY(&sessions)) {
-		cmdq_error(cmdq, "no sessions");
+		cmdq_error(item, "no sessions");
 		return (CMD_RETURN_ERROR);
 	}
 
-	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 = cmd_lookup_windowid(tflag);
-		if (w == NULL && (wp = cmd_lookup_paneid(tflag)) != NULL)
-			w = wp->window;
-		if (w != NULL)
-			wl = winlink_find_by_window(&s->windows, w);
+	if (c == NULL)
+		return (CMD_RETURN_NORMAL);
+	if (server_client_check_nested(c)) {
+		cmdq_error(item, "sessions should be nested with care, "
+		    "unset $TMUX to force");
+		return (CMD_RETURN_ERROR);
 	}
 
-	if (cmdq->client == NULL)
-		return (CMD_RETURN_NORMAL);
+	if (tflag != NULL && tflag[strcspn(tflag, ":.")] != '\0') {
+		type = CMD_FIND_PANE;
+		flags = 0;
+	} else {
+		type = CMD_FIND_SESSION;
+		flags = CMD_FIND_PREFER_UNATTACHED;
+	}
+	if (cmd_find_target(&item->target, item, tflag, type, flags) != 0)
+		return (CMD_RETURN_ERROR);
+	s = item->target.s;
+	wl = item->target.wl;
+	wp = item->target.wp;
 
 	if (wl != NULL) {
 		if (wp != NULL)
 			window_set_active_pane(wp->window, wp);
 		session_set_current(s, wl);
+		if (wp != NULL)
+			cmd_find_from_winlink_pane(current, wl, wp, 0);
+		else
+			cmd_find_from_winlink(current, wl, 0);
 	}
 
-	if (cmdq->client->session != NULL) {
+	if (cflag != NULL) {
+		free((void *)s->cwd);
+		s->cwd = format_single(item, cflag, c, s, wl, wp);
+	}
+
+	if (c->session != NULL) {
 		if (dflag) {
-			/*
-			 * Can't use server_write_session in case attaching to
-			 * the same session as currently attached to.
-			 */
-			for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
-				c = ARRAY_ITEM(&clients, i);
-				if (c == NULL || c->session != s)
+			TAILQ_FOREACH(c_loop, &clients, entry) {
+				if (c_loop->session != s || c == c_loop)
 					continue;
-				if (c == cmdq->client)
-					continue;
-				server_write_client(c, MSG_DETACH,
-				    c->session->name,
-				    strlen(c->session->name) + 1);
+				server_client_detach(c_loop, MSG_DETACH);
 			}
 		}
+		if (!Eflag)
+			environ_update(s->options, c->environ, s->environ);
 
-		if (cflag != NULL) {
-			ft = format_create();
-			if ((c = cmd_find_client(cmdq, NULL, 1)) != NULL)
-				format_client(ft, c);
-			format_session(ft, s);
-			format_winlink(ft, s, s->curw);
-			format_window_pane(ft, s->curw->window->active);
-			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;
-		}
-
-		cmdq->client->session = s;
-		notify_attached_session_changed(cmdq->client);
-		session_update_activity(s);
-		server_redraw_client(cmdq->client);
+		c->session = s;
+		if (~item->shared->flags & CMDQ_SHARED_REPEAT)
+			server_client_set_key_table(c, NULL);
+		status_timer_start(c);
+		notify_client("client-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(cmdq->client, s, &cause) != 0) {
-			cmdq_error(cmdq, "open terminal failed: %s", cause);
+		if (server_client_open(c, &cause) != 0) {
+			cmdq_error(item, "open terminal failed: %s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
-
-		if (cflag != NULL) {
-			ft = format_create();
-			if ((c = cmd_find_client(cmdq, NULL, 1)) != NULL)
-				format_client(ft, c);
-			format_session(ft, s);
-			format_winlink(ft, s, s->curw);
-			format_window_pane(ft, s->curw->window->active);
-			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 (rflag)
-			cmdq->client->flags |= CLIENT_READONLY;
+			c->flags |= CLIENT_READONLY;
 
 		if (dflag) {
-			server_write_session(s, MSG_DETACH, s->name,
-			    strlen(s->name) + 1);
+			TAILQ_FOREACH(c_loop, &clients, entry) {
+				if (c_loop->session != s || c == c_loop)
+					continue;
+				server_client_detach(c_loop, MSG_DETACH);
+			}
 		}
+		if (!Eflag)
+			environ_update(s->options, c->environ, s->environ);
 
-		update = options_get_string(&s->options, "update-environment");
-		environ_update(update, &cmdq->client->environ, &s->environ);
-
-		cmdq->client->session = s;
-		notify_attached_session_changed(cmdq->client);
-		session_update_activity(s);
-		server_redraw_client(cmdq->client);
+		c->session = s;
+		server_client_set_key_table(c, NULL);
+		status_timer_start(c);
+		notify_client("client-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(cmdq->client);
-		cmdq->client_exit = 0;
+		if (~c->flags & CLIENT_CONTROL)
+			proc_send(c->peer, MSG_READY, -1, NULL, 0);
+		notify_client("client-attached", c);
+		c->flags |= CLIENT_ATTACHED;
 	}
 	recalculate_sizes();
+	alerts_check_session(s);
 	server_update_socket();
 
 	return (CMD_RETURN_NORMAL);
 }
 
-enum cmd_retval
-cmd_attach_session_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_attach_session_exec(struct cmd *self, struct cmdq_item *item)
 {
 	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')));
+	return (cmd_attach_session(item, 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,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -24,110 +24,53 @@
 #include "tmux.h"
 
 /*
- * Bind a key to a command, this recurses through cmd_*.
+ * Bind a key to a command.
  */
 
-enum cmd_retval	 cmd_bind_key_exec(struct cmd *, struct cmd_q *);
-
-enum cmd_retval	 cmd_bind_key_table(struct cmd *, struct cmd_q *, int);
+static enum cmd_retval	cmd_bind_key_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_bind_key_entry = {
-	"bind-key", "bind",
-	"cnrt:", 1, -1,
-	"[-cnr] [-t key-table] key command [arguments]",
-	0,
-	NULL,
-	cmd_bind_key_exec
+	.name = "bind-key",
+	.alias = "bind",
+
+	.args = { "cnrT:", 2, -1 },
+	.usage = "[-cnr] [-T key-table] key "
+	         "command [arguments]",
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_bind_key_exec
 };
 
-enum cmd_retval
-cmd_bind_key_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_bind_key_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
 	char		*cause;
 	struct cmd_list	*cmdlist;
-	int		 key;
-
-	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_code	 key;
+	const char	*tablename;
 
 	key = key_string_lookup_string(args->argv[0]);
-	if (key == KEYC_NONE) {
-		cmdq_error(cmdq, "unknown key: %s", args->argv[0]);
+	if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
+		cmdq_error(item, "unknown key: %s", args->argv[0]);
 		return (CMD_RETURN_ERROR);
 	}
 
-	if (args_has(args, 't'))
-		return (cmd_bind_key_table(self, cmdq, key));
+	if (args_has(args, 'T'))
+		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);
+		cmdq_error(item, "%s", cause);
 		free(cause);
 		return (CMD_RETURN_ERROR);
 	}
 
-	if (!args_has(args, 'n'))
-	    key |= KEYC_PREFIX;
-	key_bindings_add(key, args_has(args, 'r'), cmdlist);
-	return (CMD_RETURN_NORMAL);
-}
-
-enum cmd_retval
-cmd_bind_key_table(struct cmd *self, struct cmd_q *cmdq, 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);
-		return (CMD_RETURN_ERROR);
-	}
-
-	cmd = mode_key_fromstring(mtab->cmdstr, args->argv[1]);
-	if (cmd == MODEKEY_NONE) {
-		cmdq_error(cmdq, "unknown command: %s", args->argv[1]);
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (cmd != MODEKEYCOPY_COPYPIPE) {
-		if (args->argc != 2) {
-			cmdq_error(cmdq, "no argument allowed");
-			return (CMD_RETURN_ERROR);
-		}
-		arg = NULL;
-	} else {
-		if (args->argc != 3) {
-			cmdq_error(cmdq, "no argument given");
-			return (CMD_RETURN_ERROR);
-		}
-		arg = args->argv[2];
-	}
-
-	mtmp.key = key;
-	mtmp.mode = !!args_has(args, 'c');
-	if ((mbind = RB_FIND(mode_key_tree, mtab->tree, &mtmp)) == NULL) {
-		mbind = xmalloc(sizeof *mbind);
-		mbind->key = mtmp.key;
-		mbind->mode = mtmp.mode;
-		RB_INSERT(mode_key_tree, mtab->tree, mbind);
-	}
-	mbind->cmd = cmd;
-	mbind->arg = arg != NULL ? xstrdup(arg) : NULL;
+	key_bindings_add(tablename, key, args_has(args, 'r'), cmdlist);
 	return (CMD_RETURN_NORMAL);
 }

cmd-break-pane.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -26,89 +26,93 @@
  * Break pane off into a window.
  */
 
-enum cmd_retval	 cmd_break_pane_exec(struct cmd *, struct cmd_q *);
+#define BREAK_PANE_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"
+
+static enum cmd_retval	cmd_break_pane_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_break_pane_entry = {
-	"break-pane", "breakp",
-	"dPF:t:", 0, 0,
-	"[-dP] [-F format] " CMD_TARGET_PANE_USAGE,
-	0,
-	NULL,
-	cmd_break_pane_exec
+	.name = "break-pane",
+	.alias = "breakp",
+
+	.args = { "dPF:n:s:t:", 0, 0 },
+	.usage = "[-dP] [-F format] [-n window-name] [-s src-pane] "
+		 "[-t dst-window]",
+
+	.source = { 's', CMD_FIND_PANE, 0 },
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_WINDOW_INDEX },
+
+	.flags = 0,
+	.exec = cmd_break_pane_exec
 };
 
-enum cmd_retval
-cmd_break_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_break_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct winlink		*wl;
-	struct session		*s;
-	struct window_pane	*wp;
-	struct window		*w;
-	char			*name;
-	char			*cause;
-	int			 base_idx;
-	struct client		*c;
-	struct format_tree	*ft;
+	struct cmd_find_state	*current = &item->shared->current;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct winlink		*wl = item->source.wl;
+	struct session		*src_s = item->source.s;
+	struct session		*dst_s = item->target.s;
+	struct window_pane	*wp = item->source.wp;
+	struct window		*w = wl->window;
+	char			*name, *cause;
+	int			 idx = item->target.idx;
 	const char		*template;
 	char			*cp;
 
-	if ((wl = cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp)) == NULL)
-		return (CMD_RETURN_ERROR);
-
-	if (window_count_panes(wl->window) == 1) {
-		cmdq_error(cmdq, "can't break with only one pane");
+	if (idx != -1 && winlink_find_by_index(&dst_s->windows, idx) != NULL) {
+		cmdq_error(item, "index %d already in use", idx);
 		return (CMD_RETURN_ERROR);
 	}
 
-	w = wl->window;
+	if (window_count_panes(w) == 1) {
+		cmdq_error(item, "can't break with only one pane");
+		return (CMD_RETURN_ERROR);
+	}
 	server_unzoom_window(w);
 
 	TAILQ_REMOVE(&w->panes, wp, entry);
-	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;
+	window_lost_pane(w, wp);
 	layout_close_pane(wp);
 
-	w = wp->window = window_create1(s->sx, s->sy);
+	w = wp->window = window_create(dst_s->sx, dst_s->sy);
 	TAILQ_INSERT_HEAD(&w->panes, wp, entry);
 	w->active = wp;
-	name = default_window_name(w);
-	window_set_name(w, name);
-	free(name);
+
+	if (!args_has(args, 'n')) {
+		name = default_window_name(w);
+		window_set_name(w, name);
+		free(name);
+	} else {
+		window_set_name(w, args_get(args, 'n'));
+		options_set_number(w->options, "automatic-rename", 0);
+	}
+
 	layout_init(w, wp);
+	wp->flags |= PANE_CHANGED;
 
-	base_idx = options_get_number(&s->options, "base-index");
-	wl = session_attach(s, w, -1 - base_idx, &cause); /* can't fail */
-	if (!args_has(self->args, 'd'))
-		session_select(s, wl->idx);
+	if (idx == -1)
+		idx = -1 - options_get_number(dst_s->options, "base-index");
+	wl = session_attach(dst_s, w, idx, &cause); /* can't fail */
+	if (!args_has(self->args, 'd')) {
+		session_select(dst_s, wl->idx);
+		cmd_find_from_session(current, dst_s, 0);
+	}
 
-	server_redraw_session(s);
-	server_status_session_group(s);
+	server_redraw_session(src_s);
+	if (src_s != dst_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')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = BREAK_PANE_TEMPLATE;
-
-		ft = format_create();
-		if ((c = cmd_find_client(cmdq, NULL, 1)) != NULL)
-			format_client(ft, c);
-		format_session(ft, s);
-		format_winlink(ft, s, wl);
-		format_window_pane(ft, wp);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
+		cp = format_single(item, template, c, dst_s, wl, wp);
+		cmdq_print(item, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}
 	return (CMD_RETURN_NORMAL);
 }

cmd-capture-pane.c

@@ -1,4 +1,4 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
  * Copyright (c) 2009 Jonathan Alvarado <radobobo@users.sourceforge.net>
@@ -27,55 +27,74 @@
  * Write the entire contents of a pane to a buffer or stdout.
  */
 
-enum cmd_retval	 cmd_capture_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_capture_pane_exec(struct cmd *, struct cmdq_item *);
 
-char		*cmd_capture_pane_append(char *, size_t *, char *, size_t);
-char		*cmd_capture_pane_pending(struct args *, struct window_pane *,
+static char	*cmd_capture_pane_append(char *, size_t *, char *, size_t);
+static char	*cmd_capture_pane_pending(struct args *, struct window_pane *,
 		     size_t *);
-char		*cmd_capture_pane_history(struct args *, struct cmd_q *,
+static char	*cmd_capture_pane_history(struct args *, struct cmdq_item *,
 		     struct window_pane *, size_t *);
 
 const struct cmd_entry cmd_capture_pane_entry = {
-	"capture-pane", "capturep",
-	"ab:CeE:JpPqS:t:", 0, 0,
-	"[-aCeJpPq] [-b buffer-index] [-E end-line] [-S start-line]"
-	CMD_TARGET_PANE_USAGE,
-	0,
-	NULL,
-	cmd_capture_pane_exec
+	.name = "capture-pane",
+	.alias = "capturep",
+
+	.args = { "ab:CeE:JpPqS:t:", 0, 0 },
+	.usage = "[-aCeJpPq] " CMD_BUFFER_USAGE " [-E end-line] "
+		 "[-S start-line]" CMD_TARGET_PANE_USAGE,
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_capture_pane_exec
 };
 
-char *
+const struct cmd_entry cmd_clear_history_entry = {
+	.name = "clear-history",
+	.alias = "clearhist",
+
+	.args = { "t:", 0, 0 },
+	.usage = CMD_TARGET_PANE_USAGE,
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_capture_pane_exec
+};
+
+static char *
 cmd_capture_pane_append(char *buf, size_t *len, char *line, size_t linelen)
 {
-	buf = xrealloc(buf, 1, *len + linelen + 1);
+	buf = xrealloc(buf, *len + linelen + 1);
 	memcpy(buf + *len, line, linelen);
 	*len += linelen;
 	return (buf);
 }
 
-char *
+static char *
 cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
     size_t *len)
 {
-	char	*buf, *line, tmp[5];
-	size_t	 linelen;
-	u_int	 i;
+	struct evbuffer	*pending;
+	char		*buf, *line, tmp[5];
+	size_t		 linelen;
+	u_int		 i;
 
-	if (wp->ictx.since_ground == NULL)
+	pending = input_pending(wp);
+	if (pending == NULL)
 		return (xstrdup(""));
 
-	line = EVBUFFER_DATA(wp->ictx.since_ground);
-	linelen = EVBUFFER_LENGTH(wp->ictx.since_ground);
+	line = EVBUFFER_DATA(pending);
+	linelen = EVBUFFER_LENGTH(pending);
 
 	buf = xstrdup("");
 	if (args_has(args, 'C')) {
 		for (i = 0; i < linelen; i++) {
-			if (line[i] >= ' ') {
+			if (line[i] >= ' ' && line[i] != '\\') {
 				tmp[0] = line[i];
 				tmp[1] = '\0';
 			} else
-				xsnprintf(tmp, sizeof tmp, "\\%03o", line[i]);
+				xsnprintf(tmp, sizeof tmp, "\\%03hho", line[i]);
 			buf = cmd_capture_pane_append(buf, len, tmp,
 			    strlen(tmp));
 		}
@@ -84,8 +103,8 @@ cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
 	return (buf);
 }
 
-char *
-cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
+static char *
+cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
     struct window_pane *wp, size_t *len)
 {
 	struct grid		*gd;
@@ -94,6 +113,7 @@ cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
 	int			 n, with_codes, escape_c0, join_lines;
 	u_int			 i, sx, top, bottom, tmp;
 	char			*cause, *buf, *line;
+	const char		*Sflag, *Eflag;
 	size_t			 linelen;
 
 	sx = screen_size_x(&wp->base);
@@ -101,7 +121,7 @@ cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
 		gd = wp->saved_grid;
 		if (gd == NULL) {
 			if (!args_has(args, 'q')) {
-				cmdq_error(cmdq, "no alternate screen");
+				cmdq_error(item, "no alternate screen");
 				return (NULL);
 			}
 			return (xstrdup(""));
@@ -109,27 +129,37 @@ cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
 	} else
 		gd = wp->base.grid;
 
-	n = args_strtonum(args, 'S', INT_MIN, SHRT_MAX, &cause);
-	if (cause != NULL) {
-		top = gd->hsize;
-		free(cause);
-	} else if (n < 0 && (u_int) -n > gd->hsize)
+	Sflag = args_get(args, 'S');
+	if (Sflag != NULL && strcmp(Sflag, "-") == 0)
 		top = 0;
-	else
-		top = gd->hsize + n;
-	if (top > gd->hsize + gd->sy - 1)
-		top = gd->hsize + gd->sy - 1;
+	else {
+		n = args_strtonum(args, 'S', INT_MIN, SHRT_MAX, &cause);
+		if (cause != NULL) {
+			top = gd->hsize;
+			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;
+	}
 
-	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)
+	Eflag = args_get(args, 'E');
+	if (Eflag != NULL && strcmp(Eflag, "-") == 0)
 		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;
@@ -158,56 +188,52 @@ cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
 	return (buf);
 }
 
-enum cmd_retval
-cmd_capture_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_capture_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct client		*c;
-	struct window_pane	*wp;
+	struct window_pane	*wp = item->target.wp;
 	char			*buf, *cause;
-	int			 buffer;
-	u_int			 limit;
+	const char		*bufname;
 	size_t			 len;
 
-	if (cmd_find_pane(cmdq, args_get(args, 't'), NULL, &wp) == NULL)
-		return (CMD_RETURN_ERROR);
+	if (self->entry == &cmd_clear_history_entry) {
+		if (wp->mode == &window_copy_mode)
+			window_pane_reset_mode(wp);
+		grid_clear_history(wp->base.grid);
+		return (CMD_RETURN_NORMAL);
+	}
 
 	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);
+		buf = cmd_capture_pane_history(args, item, wp, &len);
 	if (buf == NULL)
 		return (CMD_RETURN_ERROR);
 
 	if (args_has(args, 'p')) {
-		c = cmdq->client;
+		c = item->client;
 		if (c == NULL ||
 		    (c->session != NULL && !(c->flags & CLIENT_CONTROL))) {
-			cmdq_error(cmdq, "can't write to stdout");
+			cmdq_error(item, "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);
+		server_client_push_stdout(c);
 	} else {
-		limit = options_get_number(&global_options, "buffer-limit");
-		if (!args_has(args, 'b')) {
-			paste_add(&global_buffers, buf, len, limit);
-			return (CMD_RETURN_NORMAL);
-		}
+		bufname = NULL;
+		if (args_has(args, 'b'))
+			bufname = args_get(args, 'b');
 
-		buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
-		if (cause != NULL) {
-			cmdq_error(cmdq, "buffer %s", cause);
-			free(buf);
+		if (paste_set(buf, len, bufname, &cause) != 0) {
+			cmdq_error(item, "%s", cause);
 			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-
-		if (paste_replace(&global_buffers, buffer, buf, len) != 0) {
-			cmdq_error(cmdq, "no buffer %d", buffer);
 			free(buf);
 			return (CMD_RETURN_ERROR);
 		}

cmd-choose-buffer.c

@@ -1,95 +0,0 @@
-/* $Id$ */
-
-/*
- * Copyright (c) 2010 Nicholas Marriott <nicm@users.sourceforge.net>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
- * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include <sys/types.h>
-
-#include <ctype.h>
-#include <stdlib.h>
-
-#include "tmux.h"
-
-/*
- * Enter choice mode to choose a buffer.
- */
-
-enum cmd_retval	 cmd_choose_buffer_exec(struct cmd *, struct cmd_q *);
-
-const struct cmd_entry cmd_choose_buffer_entry = {
-	"choose-buffer", NULL,
-	"F:t:", 0, 1,
-	CMD_TARGET_WINDOW_USAGE " [-F format] [template]",
-	0,
-	NULL,
-	cmd_choose_buffer_exec
-};
-
-enum cmd_retval
-cmd_choose_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args			*args = self->args;
-	struct client			*c;
-	struct window_choose_data	*cdata;
-	struct winlink			*wl;
-	struct paste_buffer		*pb;
-	char				*action, *action_data;
-	const char			*template;
-	u_int				 idx;
-
-	if ((c = cmd_current_client(cmdq)) == NULL) {
-		cmdq_error(cmdq, "no client available");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if ((template = args_get(args, 'F')) == NULL)
-		template = CHOOSE_BUFFER_TEMPLATE;
-
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), NULL)) == NULL)
-		return (CMD_RETURN_ERROR);
-
-	if (paste_get_top(&global_buffers) == NULL)
-		return (CMD_RETURN_NORMAL);
-
-	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
-		return (CMD_RETURN_NORMAL);
-
-	if (args->argc != 0)
-		action = xstrdup(args->argv[0]);
-	else
-		action = xstrdup("paste-buffer -b '%%'");
-
-	idx = 0;
-	while ((pb = paste_walk_stack(&global_buffers, &idx)) != NULL) {
-		cdata = window_choose_data_create(TREE_OTHER, c, c->session);
-		cdata->idx = idx - 1;
-
-		cdata->ft_template = xstrdup(template);
-		format_add(cdata->ft, "line", "%u", idx - 1);
-		format_paste_buffer(cdata->ft, pb);
-
-		xasprintf(&action_data, "%u", idx - 1);
-		cdata->command = cmd_template_replace(action, action_data, 1);
-		free(action_data);
-
-		window_choose_add(wl->window->active, cdata);
-	}
-	free(action);
-
-	window_choose_ready(wl->window->active, 0, NULL);
-
-	return (CMD_RETURN_NORMAL);
-}

cmd-choose-client.c

@@ -1,124 +0,0 @@
-/* $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 <stdlib.h>
-
-#include "tmux.h"
-
-/*
- * Enter choice mode to choose a client.
- */
-
-enum cmd_retval	 cmd_choose_client_exec(struct cmd *, struct cmd_q *);
-
-void	cmd_choose_client_callback(struct window_choose_data *);
-
-const struct cmd_entry cmd_choose_client_entry = {
-	"choose-client", NULL,
-	"F:t:", 0, 1,
-	CMD_TARGET_WINDOW_USAGE " [-F format] [template]",
-	0,
-	NULL,
-	cmd_choose_client_exec
-};
-
-struct cmd_choose_client_data {
-	struct client	*client;
-};
-
-enum cmd_retval
-cmd_choose_client_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args			*args = self->args;
-	struct client			*c;
-	struct client			*c1;
-	struct window_choose_data	*cdata;
-	struct winlink			*wl;
-	const char			*template;
-	char				*action;
-	u_int			 	 i, idx, cur;
-
-	if ((c = cmd_current_client(cmdq)) == NULL) {
-		cmdq_error(cmdq, "no client available");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), NULL)) == NULL)
-		return (CMD_RETURN_ERROR);
-
-	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
-		return (CMD_RETURN_NORMAL);
-
-	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;
-	for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
-		c1 = ARRAY_ITEM(&clients, i);
-		if (c1 == NULL || c1->session == NULL || c1->tty.path == NULL)
-			continue;
-		if (c1 == cmdq->client)
-			cur = idx;
-		idx++;
-
-		cdata = window_choose_data_create(TREE_OTHER, c, c->session);
-		cdata->idx = i;
-
-		cdata->ft_template = xstrdup(template);
-		format_add(cdata->ft, "line", "%u", i);
-		format_session(cdata->ft, c1->session);
-		format_client(cdata->ft, c1);
-
-		cdata->command = cmd_template_replace(action, c1->tty.path, 1);
-
-		window_choose_add(wl->window->active, cdata);
-	}
-	free(action);
-
-	window_choose_ready(wl->window->active, cur,
-	    cmd_choose_client_callback);
-
-	return (CMD_RETURN_NORMAL);
-}
-
-void
-cmd_choose_client_callback(struct window_choose_data *cdata)
-{
-	struct client  	*c;
-
-	if (cdata == NULL)
-		return;
-	if (cdata->start_client->flags & CLIENT_DEAD)
-		return;
-
-	if (cdata->idx > ARRAY_LENGTH(&clients) - 1)
-		return;
-	c = ARRAY_ITEM(&clients, cdata->idx);
-	if (c == NULL || c->session == NULL)
-		return;
-
-	window_choose_data_run(cdata);
-}

cmd-choose-list.c

@@ -1,97 +0,0 @@
-/* $Id$ */
-
-/*
- * 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_LIST_DEFAULT_TEMPLATE "run-shell '%%'"
-
-/*
- * Enter choose mode to choose a custom list.
- */
-
-enum cmd_retval cmd_choose_list_exec(struct cmd *, struct cmd_q *);
-
-const struct cmd_entry cmd_choose_list_entry = {
-	"choose-list", NULL,
-	"l:t:", 0, 1,
-	"[-l items] " CMD_TARGET_WINDOW_USAGE "[template]",
-	0,
-	NULL,
-	cmd_choose_list_exec
-};
-
-enum cmd_retval
-cmd_choose_list_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args			*args = self->args;
-	struct client			*c;
-	struct winlink			*wl;
-	const char			*list1;
-	char				*template, *item, *copy, *list;
-	u_int				 idx;
-
-	if ((c = cmd_current_client(cmdq)) == NULL) {
-		cmdq_error(cmdq, "no client available");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if ((list1 = args_get(args, 'l')) == NULL)
-		return (CMD_RETURN_ERROR);
-
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), NULL)) == NULL)
-		return (CMD_RETURN_ERROR);
-
-	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
-		return (CMD_RETURN_NORMAL);
-
-	if (args->argc != 0)
-		template = xstrdup(args->argv[0]);
-	else
-		template = xstrdup(CMD_CHOOSE_LIST_DEFAULT_TEMPLATE);
-
-	copy = list = xstrdup(list1);
-	idx = 0;
-	while ((item = strsep(&list, ",")) != NULL)
-	{
-		if (*item == '\0') /* no empty entries */
-			continue;
-		window_choose_add_item(wl->window->active, c, wl, item,
-		    template, idx);
-		idx++;
-	}
-	free(copy);
-
-	if (idx == 0) {
-		free(template);
-		window_pane_reset_mode(wl->window->active);
-		return (CMD_RETURN_ERROR);
-	}
-
-	window_choose_ready(wl->window->active, 0, NULL);
-
-	free(template);
-
-	return (CMD_RETURN_NORMAL);
-}

cmd-choose-tree.c

@@ -1,4 +1,4 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
  * Copyright (c) 2012 Thomas Adam <thomas@xteddy.org>
@@ -18,218 +18,74 @@
 
 #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.
+ * Enter a mode.
  */
 
-enum cmd_retval	cmd_choose_tree_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_choose_tree_exec(struct cmd *, struct cmdq_item *);
 
 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,
-	NULL,
-	cmd_choose_tree_exec
+	.name = "choose-tree",
+	.alias = NULL,
+
+	.args = { "F:Gf:NO:st:wZ", 0, 1 },
+	.usage = "[-GNsw] [-F format] [-f filter] [-O sort-order] "
+	         CMD_TARGET_PANE_USAGE,
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = 0,
+	.exec = 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,
-	NULL,
-	cmd_choose_tree_exec
+const struct cmd_entry cmd_choose_client_entry = {
+	.name = "choose-client",
+	.alias = NULL,
+
+	.args = { "F:f:NO:t:Z", 0, 1 },
+	.usage = "[-N] [-F format] [-f filter] [-O sort-order] "
+	         CMD_TARGET_PANE_USAGE,
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = 0,
+	.exec = 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,
-	NULL,
-	cmd_choose_tree_exec
+const struct cmd_entry cmd_choose_buffer_entry = {
+	.name = "choose-buffer",
+	.alias = NULL,
+
+	.args = { "F:f:NO:t:Z", 0, 1 },
+	.usage = "[-N] [-F format] [-f filter] [-O sort-order] "
+	         CMD_TARGET_PANE_USAGE,
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = 0,
+	.exec = cmd_choose_tree_exec
 };
 
-enum cmd_retval
-cmd_choose_tree_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_choose_tree_exec(struct cmd *self, struct cmdq_item *item)
 {
 	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;
+	struct window_pane		*wp = item->target.wp;
+	const struct window_mode	*mode;
 
-	ses_template = win_template = NULL;
-	ses_action = win_action = NULL;
-
-	if ((c = cmd_current_client(cmdq)) == 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);
+	if (self->entry == &cmd_choose_buffer_entry) {
+		if (paste_get_top(NULL) == NULL)
+			return (CMD_RETURN_NORMAL);
+		mode = &window_buffer_mode;
+	} else if (self->entry == &cmd_choose_client_entry) {
+		if (server_client_how_many() == 0)
+			return (CMD_RETURN_NORMAL);
+		mode = &window_client_mode;
 	} 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);
-	}
+		mode = &window_tree_mode;
 
+	window_pane_set_mode(wp, mode, &item->target, args);
 	return (CMD_RETURN_NORMAL);
 }

cmd-command-prompt.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@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
@@ -29,61 +29,40 @@
  * Prompt for command in client.
  */
 
-void	cmd_command_prompt_key_binding(struct cmd *, int);
-enum cmd_retval	cmd_command_prompt_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_command_prompt_exec(struct cmd *,
+			    struct cmdq_item *);
 
-int	cmd_command_prompt_callback(void *, const char *);
-void	cmd_command_prompt_free(void *);
+static int	cmd_command_prompt_callback(struct client *, void *,
+		    const char *, int);
+static void	cmd_command_prompt_free(void *);
 
 const struct cmd_entry cmd_command_prompt_entry = {
-	"command-prompt", NULL,
-	"I:p:t:", 0, 1,
-	"[-I inputs] [-p prompts] " CMD_TARGET_CLIENT_USAGE " [template]",
-	0,
-	cmd_command_prompt_key_binding,
-	cmd_command_prompt_exec
+	.name = "command-prompt",
+	.alias = NULL,
+
+	.args = { "1iI:Np:t:", 0, 1 },
+	.usage = "[-1Ni] [-I inputs] [-p prompts] " CMD_TARGET_CLIENT_USAGE " "
+		 "[template]",
+
+	.flags = 0,
+	.exec = cmd_command_prompt_exec
 };
 
 struct cmd_command_prompt_cdata {
-	struct client	*c;
-	char		*inputs;
-	char		*next_input;
-	char		*next_prompt;
-	char		*prompts;
-	char		*template;
-	int		 idx;
+	int	 flags;
+
+	char	*inputs;
+	char	*next_input;
+
+	char	*prompts;
+	char	*next_prompt;
+
+	char	*template;
+	int	 idx;
 };
 
-void
-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;
-	}
-}
-
-enum cmd_retval
-cmd_command_prompt_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_command_prompt_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
 	const char			*inputs, *prompts;
@@ -92,20 +71,22 @@ 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(item, args_get(args, 't'), 0)) == NULL)
 		return (CMD_RETURN_ERROR);
 
 	if (c->prompt_string != NULL)
 		return (CMD_RETURN_NORMAL);
 
-	cdata = xmalloc(sizeof *cdata);
-	cdata->c = c;
-	cdata->idx = 1;
+	cdata = xcalloc(1, sizeof *cdata);
+
 	cdata->inputs = NULL;
 	cdata->next_input = NULL;
-	cdata->next_prompt = NULL;
+
 	cdata->prompts = NULL;
+	cdata->next_prompt = NULL;
+
 	cdata->template = NULL;
+	cdata->idx = 1;
 
 	if (args->argc != 0)
 		cdata->template = xstrdup(args->argv[0]);
@@ -135,34 +116,56 @@ cmd_command_prompt_exec(struct cmd *self, struct cmd_q *cmdq)
 		input = strsep(&cdata->next_input, ",");
 	}
 
+	if (args_has(args, '1'))
+		cdata->flags |= PROMPT_SINGLE;
+	else if (args_has(args, 'N'))
+		cdata->flags |= PROMPT_NUMERIC;
+	else if (args_has(args, 'i'))
+		cdata->flags |= PROMPT_INCREMENTAL;
 	status_prompt_set(c, prompt, input, cmd_command_prompt_callback,
-	    cmd_command_prompt_free, cdata, 0);
+	    cmd_command_prompt_free, cdata, cdata->flags);
 	free(prompt);
 
 	return (CMD_RETURN_NORMAL);
 }
 
-int
-cmd_command_prompt_callback(void *data, const char *s)
+static enum cmd_retval
+cmd_command_prompt_error(struct cmdq_item *item, void *data)
+{
+	char	*error = data;
+
+	cmdq_error(item, "%s", error);
+	free(error);
+
+	return (CMD_RETURN_NORMAL);
+}
+
+static int
+cmd_command_prompt_callback(struct client *c, void *data, const char *s,
+    int done)
 {
 	struct cmd_command_prompt_cdata	*cdata = data;
-	struct client			*c = cdata->c;
 	struct cmd_list			*cmdlist;
+	struct cmdq_item		*new_item;
 	char				*cause, *new_template, *prompt, *ptr;
 	char				*input = NULL;
 
 	if (s == NULL)
 		return (0);
+	if (done && (cdata->flags & PROMPT_INCREMENTAL))
+		return (0);
 
 	new_template = cmd_template_replace(cdata->template, s, cdata->idx);
-	free(cdata->template);
-	cdata->template = new_template;
+	if (done) {
+		free(cdata->template);
+		cdata->template = new_template;
+	}
 
 	/*
 	 * Check if there are more prompts; if so, get its respective input
 	 * and update the prompt data.
 	 */
-	if ((ptr = strsep(&cdata->next_prompt, ",")) != NULL) {
+	if (done && (ptr = strsep(&cdata->next_prompt, ",")) != NULL) {
 		xasprintf(&prompt, "%s ", ptr);
 		input = strsep(&cdata->next_input, ",");
 		status_prompt_update(c, prompt, input);
@@ -172,24 +175,29 @@ cmd_command_prompt_callback(void *data, const char *s)
 		return (1);
 	}
 
-	if (cmd_string_parse(new_template, &cmdlist, NULL, 0, &cause) != 0) {
+	cmdlist = cmd_string_parse(new_template, NULL, 0, &cause);
+	if (cmdlist == NULL) {
 		if (cause != NULL) {
-			*cause = toupper((u_char) *cause);
-			status_message_set(c, "%s", cause);
-			free(cause);
-		}
-		return (0);
+			new_item = cmdq_get_callback(cmd_command_prompt_error,
+			    cause);
+		} else
+			new_item = NULL;
+	} else {
+		new_item = cmdq_get_command(cmdlist, NULL, NULL, 0);
+		cmd_list_free(cmdlist);
 	}
 
-	cmdq_run(c->cmdq, cmdlist);
-	cmd_list_free(cmdlist);
+	if (new_item != NULL)
+		cmdq_append(c, new_item);
 
-	if (c->prompt_callbackfn != (void *) &cmd_command_prompt_callback)
+	if (!done)
+		free(new_template);
+	if (c->prompt_inputcb != cmd_command_prompt_callback)
 		return (1);
 	return (0);
 }
 
-void
+static void
 cmd_command_prompt_free(void *data)
 {
 	struct cmd_command_prompt_cdata	*cdata = data;

cmd-confirm-before.c

@@ -1,4 +1,4 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -16,6 +16,8 @@
  * 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>
@@ -26,46 +28,30 @@
  * Asks for confirmation before executing a command.
  */
 
-void		 cmd_confirm_before_key_binding(struct cmd *, int);
-enum cmd_retval	 cmd_confirm_before_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_confirm_before_exec(struct cmd *,
+			    struct cmdq_item *);
 
-int		 cmd_confirm_before_callback(void *, const char *);
-void		 cmd_confirm_before_free(void *);
+static int	cmd_confirm_before_callback(struct client *, void *,
+		    const char *, int);
+static 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,
-	cmd_confirm_before_exec
+	.name = "confirm-before",
+	.alias = "confirm",
+
+	.args = { "p:t:", 1, 1 },
+	.usage = "[-p prompt] " CMD_TARGET_CLIENT_USAGE " command",
+
+	.flags = 0,
+	.exec = cmd_confirm_before_exec
 };
 
 struct cmd_confirm_before_data {
-	char		*cmd;
-	struct client	*client;
+	char	*cmd;
 };
 
-void
-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;
-	}
-}
-
-enum cmd_retval
-cmd_confirm_before_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_confirm_before_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
 	struct cmd_confirm_before_data	*cdata;
@@ -73,7 +59,7 @@ 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 ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
 		return (CMD_RETURN_ERROR);
 
 	if ((prompt = args_get(args, 'p')) != NULL)
@@ -88,9 +74,6 @@ cmd_confirm_before_exec(struct cmd *self, struct cmd_q *cmdq)
 	cdata = xmalloc(sizeof *cdata);
 	cdata->cmd = xstrdup(args->argv[0]);
 
-	cdata->client = c;
-	cdata->client->references++;
-
 	status_prompt_set(c, new_prompt, NULL,
 	    cmd_confirm_before_callback, cmd_confirm_before_free, cdata,
 	    PROMPT_SINGLE);
@@ -99,12 +82,24 @@ cmd_confirm_before_exec(struct cmd *self, struct cmd_q *cmdq)
 	return (CMD_RETURN_NORMAL);
 }
 
-int
-cmd_confirm_before_callback(void *data, const char *s)
+static enum cmd_retval
+cmd_confirm_before_error(struct cmdq_item *item, void *data)
+{
+	char	*error = data;
+
+	cmdq_error(item, "%s", error);
+	free(error);
+
+	return (CMD_RETURN_NORMAL);
+}
+
+static int
+cmd_confirm_before_callback(struct client *c, void *data, const char *s,
+    __unused int done)
 {
 	struct cmd_confirm_before_data	*cdata = data;
-	struct client			*c = cdata->client;
 	struct cmd_list			*cmdlist;
+	struct cmdq_item		*new_item;
 	char				*cause;
 
 	if (c->flags & CLIENT_DEAD)
@@ -115,27 +110,28 @@ cmd_confirm_before_callback(void *data, const char *s)
 	if (tolower((u_char) s[0]) != 'y' || s[1] != '\0')
 		return (0);
 
-	if (cmd_string_parse(cdata->cmd, &cmdlist, NULL, 0, &cause) != 0) {
+	cmdlist = cmd_string_parse(cdata->cmd, NULL, 0, &cause);
+	if (cmdlist == NULL) {
 		if (cause != NULL) {
-			cmdq_error(c->cmdq, "%s", cause);
-			free(cause);
-		}
-		return (0);
+			new_item = cmdq_get_callback(cmd_confirm_before_error,
+			    cause);
+		} else
+			new_item = NULL;
+	} else {
+		new_item = cmdq_get_command(cmdlist, NULL, NULL, 0);
+		cmd_list_free(cmdlist);
 	}
 
-	cmdq_run(c->cmdq, cmdlist);
-	cmd_list_free(cmdlist);
+	if (new_item != NULL)
+		cmdq_append(c, new_item);
 
 	return (0);
 }
 
-void
+static void
 cmd_confirm_before_free(void *data)
 {
 	struct cmd_confirm_before_data	*cdata = data;
-	struct client			*c = cdata->client;
-
-	c->references--;
 
 	free(cdata->cmd);
 	free(cdata);

cmd-copy-mode.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -21,45 +21,72 @@
 #include "tmux.h"
 
 /*
- * Enter copy mode.
+ * Enter copy or clock mode.
  */
 
-void		 cmd_copy_mode_key_binding(struct cmd *, int);
-enum cmd_retval	 cmd_copy_mode_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_copy_mode_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_copy_mode_entry = {
-	"copy-mode", NULL,
-	"t:u", 0, 0,
-	"[-u] " CMD_TARGET_PANE_USAGE,
-	0,
-	cmd_copy_mode_key_binding,
-	cmd_copy_mode_exec
+	.name = "copy-mode",
+	.alias = NULL,
+
+	.args = { "Met:u", 0, 0 },
+	.usage = "[-Mu] " CMD_TARGET_PANE_USAGE,
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_copy_mode_exec
 };
 
-void
-cmd_copy_mode_key_binding(struct cmd *self, int key)
-{
-	self->args = args_create(0);
-	if (key == KEYC_PPAGE)
-		args_set(self->args, 'u', NULL);
-}
+const struct cmd_entry cmd_clock_mode_entry = {
+	.name = "clock-mode",
+	.alias = NULL,
 
-enum cmd_retval
-cmd_copy_mode_exec(struct cmd *self, struct cmd_q *cmdq)
+	.args = { "t:", 0, 0 },
+	.usage = CMD_TARGET_PANE_USAGE,
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_copy_mode_exec
+};
+
+static enum cmd_retval
+cmd_copy_mode_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct window_pane	*wp;
+	struct cmdq_shared	*shared = item->shared;
+	struct client		*c = item->client;
+	struct session		*s;
+	struct window_pane	*wp = item->target.wp;
+	int			 flag;
 
-	if (cmd_find_pane(cmdq, args_get(args, 't'), NULL, &wp) == NULL)
-		return (CMD_RETURN_ERROR);
+	if (args_has(args, 'M')) {
+		if ((wp = cmd_mouse_pane(&shared->mouse, &s, NULL)) == NULL)
+			return (CMD_RETURN_NORMAL);
+		if (c == NULL || c->session != s)
+			return (CMD_RETURN_NORMAL);
+	}
+
+	if (self->entry == &cmd_clock_mode_entry) {
+		window_pane_set_mode(wp, &window_clock_mode, NULL, NULL);
+		return (CMD_RETURN_NORMAL);
+	}
 
 	if (wp->mode != &window_copy_mode) {
-		if (window_pane_set_mode(wp, &window_copy_mode) != 0)
+		flag = window_pane_set_mode(wp, &window_copy_mode, NULL, NULL);
+		if (flag != 0)
 			return (CMD_RETURN_NORMAL);
-		window_copy_init_from_pane(wp);
+		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, &shared->mouse);
 	}
 	if (wp->mode == &window_copy_mode && args_has(self->args, 'u'))
-		window_copy_pageup(wp);
+		window_copy_pageup(wp, 0);
 
 	return (CMD_RETURN_NORMAL);
 }

cmd-delete-buffer.c

@@ -1,65 +0,0 @@
-/* $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.
- */
-
-enum cmd_retval	 cmd_delete_buffer_exec(struct cmd *, struct cmd_q *);
-
-const struct cmd_entry cmd_delete_buffer_entry = {
-	"delete-buffer", "deleteb",
-	"b:", 0, 0,
-	CMD_BUFFER_USAGE,
-	0,
-	NULL,
-	cmd_delete_buffer_exec
-};
-
-enum cmd_retval
-cmd_delete_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args	*args = self->args;
-	char		*cause;
-	int		 buffer;
-
-	if (!args_has(args, 'b')) {
-		paste_free_top(&global_buffers);
-		return (CMD_RETURN_NORMAL);
-	}
-
-	buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
-	if (cause != NULL) {
-		cmdq_error(cmdq, "buffer %s", cause);
-		free(cause);
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (paste_free_index(&global_buffers, buffer) != 0) {
-		cmdq_error(cmdq, "no buffer %d", buffer);
-		return (CMD_RETURN_ERROR);
-	}
-
-	return (CMD_RETURN_NORMAL);
-}

cmd-detach-client.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -26,25 +26,50 @@
  * Detach a client.
  */
 
-enum cmd_retval	 cmd_detach_client_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_detach_client_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_detach_client_entry = {
-	"detach-client", "detach",
-	"as:t:P", 0, 0,
-	"[-P] [-a] [-s target-session] " CMD_TARGET_CLIENT_USAGE,
-	CMD_READONLY,
-	NULL,
-	cmd_detach_client_exec
+	.name = "detach-client",
+	.alias = "detach",
+
+	.args = { "aE:s:t:P", 0, 0 },
+	.usage = "[-aP] [-E shell-command] "
+	         "[-s target-session] " CMD_TARGET_CLIENT_USAGE,
+
+	.source = { 's', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
+
+	.flags = CMD_READONLY,
+	.exec = cmd_detach_client_exec
 };
 
-enum cmd_retval
-cmd_detach_client_exec(struct cmd *self, struct cmd_q *cmdq)
+const struct cmd_entry cmd_suspend_client_entry = {
+	.name = "suspend-client",
+	.alias = "suspendc",
+
+	.args = { "t:", 0, 0 },
+	.usage = CMD_TARGET_CLIENT_USAGE,
+
+	.flags = 0,
+	.exec = cmd_detach_client_exec
+};
+
+static enum cmd_retval
+cmd_detach_client_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct client	*c, *c2;
+	struct client	*c, *cloop;
 	struct session	*s;
 	enum msgtype	 msgtype;
-	u_int 		 i;
+	const char	*cmd = args_get(args, 'E');
+
+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+
+	if (self->entry == &cmd_suspend_client_entry) {
+		server_client_suspend(c);
+		return (CMD_RETURN_NORMAL);
+	}
 
 	if (args_has(args, 'P'))
 		msgtype = MSG_DETACHKILL;
@@ -52,37 +77,35 @@ 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 = item->source.s;
 		if (s == NULL)
-			return (CMD_RETURN_ERROR);
-
-		for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
-			c = ARRAY_ITEM(&clients, i);
-			if (c == NULL || c->session != s)
-				continue;
-			server_write_client(c, msgtype, c->session->name,
-			    strlen(c->session->name) + 1);
-		}
-	} else {
-		c = cmd_find_client(cmdq, args_get(args, 't'), 0);
-		if (c == NULL)
-			return (CMD_RETURN_ERROR);
-
-		if (args_has(args, 'a')) {
-			for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
-				c2 = ARRAY_ITEM(&clients, i);
-				if (c2 == NULL || c2->session == NULL ||
-				    c2 == c)
-					continue;
-				server_write_client(c2, msgtype,
-				    c2->session->name,
-				    strlen(c2->session->name) + 1);
+			return (CMD_RETURN_NORMAL);
+		TAILQ_FOREACH(cloop, &clients, entry) {
+			if (cloop->session == s) {
+				if (cmd != NULL)
+					server_client_exec(cloop, cmd);
+				else
+					server_client_detach(cloop, msgtype);
 			}
-		} else {
-			server_write_client(c, msgtype, c->session->name,
-			    strlen(c->session->name) + 1);
 		}
+		return (CMD_RETURN_STOP);
 	}
 
+	if (args_has(args, 'a')) {
+		TAILQ_FOREACH(cloop, &clients, entry) {
+			if (cloop->session != NULL && cloop != c) {
+				if (cmd != NULL)
+					server_client_exec(cloop, cmd);
+				else
+					server_client_detach(cloop, msgtype);
+			}
+		}
+		return (CMD_RETURN_NORMAL);
+	}
+
+	if (cmd != NULL)
+		server_client_exec(c, cmd);
+	else
+		server_client_detach(c, msgtype);
 	return (CMD_RETURN_STOP);
 }

cmd-display-message.c

@@ -1,4 +1,4 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -27,59 +27,45 @@
  * Displays a message in the status line.
  */
 
-enum cmd_retval	 cmd_display_message_exec(struct cmd *, struct cmd_q *);
+#define DISPLAY_MESSAGE_TEMPLATE			\
+	"[#{session_name}] #{window_index}:"		\
+	"#{window_name}, current pane #{pane_index} "	\
+	"- (%H:%M %d-%b-%y)"
+
+static enum cmd_retval	cmd_display_message_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_display_message_entry = {
-	"display-message", "display",
-	"c:pt:F:", 0, 1,
-	"[-p] [-c target-client] [-F format] " CMD_TARGET_PANE_USAGE
-	" [message]",
-	0,
-	NULL,
-	cmd_display_message_exec
+	.name = "display-message",
+	.alias = "display",
+
+	.args = { "c:pt:F:", 0, 1 },
+	.usage = "[-p] [-c target-client] [-F format] "
+		 CMD_TARGET_PANE_USAGE " [message]",
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_display_message_exec
 };
 
-enum cmd_retval
-cmd_display_message_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct client		*c;
-	struct session		*s;
-	struct winlink		*wl;
-	struct window_pane	*wp;
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	struct window_pane	*wp = item->target.wp;
 	const char		*template;
 	char			*msg;
 	struct format_tree	*ft;
-	char			 out[BUFSIZ];
-	time_t			 t;
-	size_t			 len;
-
-	if (args_has(args, 't')) {
-		wl = cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp);
-		if (wl == NULL)
-			return (CMD_RETURN_ERROR);
-	} else {
-		wl = cmd_find_pane(cmdq, NULL, &s, &wp);
-		if (wl == NULL)
-			return (CMD_RETURN_ERROR);
-	}
 
 	if (args_has(args, 'F') && args->argc != 0) {
-		cmdq_error(cmdq, "only one of -F or argument must be given");
+		cmdq_error(item, "only one of -F or argument must be given");
 		return (CMD_RETURN_ERROR);
 	}
-
-	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_current_client(cmdq);
-		if (c == NULL && !args_has(self->args, 'p')) {
-			cmdq_error(cmdq, "no client available");
-			return (CMD_RETURN_ERROR);
-		}
-	}
+	c = cmd_find_client(item, args_get(args, 'c'), 1);
 
 	template = args_get(args, 'F');
 	if (args->argc != 0)
@@ -87,23 +73,16 @@ cmd_display_message_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (template == NULL)
 		template = DISPLAY_MESSAGE_TEMPLATE;
 
-	ft = format_create();
-	if (c != NULL)
-		format_client(ft, c);
-	format_session(ft, s);
-	format_winlink(ft, s, wl);
-	format_window_pane(ft, wp);
+	ft = format_create(item->client, item, FORMAT_NONE, 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);
+	msg = format_expand_time(ft, template, time(NULL));
 	if (args_has(self->args, 'p'))
-		cmdq_print(cmdq, "%s", msg);
-	else
+		cmdq_print(item, "%s", msg);
+	else if (c != NULL)
 		status_message_set(c, "%s", msg);
 	free(msg);
+
 	format_free(ft);
 
 	return (CMD_RETURN_NORMAL);

cmd-display-panes.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -18,33 +18,112 @@
 
 #include <sys/types.h>
 
+#include <ctype.h>
+#include <stdlib.h>
+
 #include "tmux.h"
 
 /*
  * Display panes on a client.
  */
 
-enum cmd_retval	 cmd_display_panes_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_display_panes_exec(struct cmd *,
+			    struct cmdq_item *);
+
+static void		cmd_display_panes_callback(struct client *,
+			    struct window_pane *);
 
 const struct cmd_entry cmd_display_panes_entry = {
-	"display-panes", "displayp",
-	"t:", 0, 0,
-	CMD_TARGET_CLIENT_USAGE,
-	0,
-	NULL,
-	cmd_display_panes_exec
+	.name = "display-panes",
+	.alias = "displayp",
+
+	.args = { "d:t:", 0, 1 },
+	.usage = "[-d duration] " CMD_TARGET_CLIENT_USAGE,
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_display_panes_exec
 };
 
-enum cmd_retval
-cmd_display_panes_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_display_panes_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
 	struct client	*c;
+	struct session	*s;
+	u_int		 delay;
+	char		*cause;
 
-	if ((c = cmd_find_client(cmdq, args_get(args, 't'), 0)) == NULL)
+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
 		return (CMD_RETURN_ERROR);
 
-	server_set_identify(c);
+	if (c->identify_callback != NULL)
+		return (CMD_RETURN_NORMAL);
+
+	c->identify_callback = cmd_display_panes_callback;
+	if (args->argc != 0)
+		c->identify_callback_data = xstrdup(args->argv[0]);
+	else
+		c->identify_callback_data = xstrdup("select-pane -t '%%'");
+	s = c->session;
+
+	if (args_has(args, 'd')) {
+		delay = args_strtonum(args, 'd', 0, UINT_MAX, &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "delay %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+	} else
+		delay = options_get_number(s->options, "display-panes-time");
+	server_client_set_identify(c, delay);
 
 	return (CMD_RETURN_NORMAL);
 }
+
+static enum cmd_retval
+cmd_display_panes_error(struct cmdq_item *item, void *data)
+{
+	char	*error = data;
+
+	cmdq_error(item, "%s", error);
+	free(error);
+
+	return (CMD_RETURN_NORMAL);
+}
+
+static void
+cmd_display_panes_callback(struct client *c, struct window_pane *wp)
+{
+	struct cmd_list		*cmdlist;
+	struct cmdq_item	*new_item;
+	char			*template, *cmd, *expanded, *cause;
+
+	template = c->identify_callback_data;
+	if (wp == NULL)
+		goto out;
+	xasprintf(&expanded, "%%%u", wp->id);
+	cmd = cmd_template_replace(template, expanded, 1);
+
+	cmdlist = cmd_string_parse(cmd, NULL, 0, &cause);
+	if (cmdlist == NULL) {
+		if (cause != NULL) {
+			new_item = cmdq_get_callback(cmd_display_panes_error,
+			    cause);
+		} else
+			new_item = NULL;
+	} else {
+		new_item = cmdq_get_command(cmdlist, NULL, NULL, 0);
+		cmd_list_free(cmdlist);
+	}
+
+	if (new_item != NULL)
+		cmdq_append(c, new_item);
+
+	free(cmd);
+	free(expanded);
+
+out:
+	free(c->identify_callback_data);
+	c->identify_callback_data = NULL;
+	c->identify_callback = NULL;
+}

cmd-find-window.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -18,9 +18,7 @@
 
 #include <sys/types.h>
 
-#include <fnmatch.h>
 #include <stdlib.h>
-#include <string.h>
 
 #include "tmux.h"
 
@@ -28,200 +26,69 @@
  * Find window containing text.
  */
 
-enum cmd_retval	 cmd_find_window_exec(struct cmd *, struct cmd_q *);
-
-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)
+static enum cmd_retval	cmd_find_window_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_find_window_entry = {
-	"find-window", "findw",
-	"F:CNt:T", 1, 4,
-	"[-CNT] [-F format] " CMD_TARGET_WINDOW_USAGE " match-string",
-	0,
-	NULL,
-	cmd_find_window_exec
+	.name = "find-window",
+	.alias = "findw",
+
+	.args = { "CNt:T", 1, 1 },
+	.usage = "[-CNT] " CMD_TARGET_PANE_USAGE " match-string",
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = 0,
+	.exec = cmd_find_window_exec
 };
 
-struct cmd_find_window_data {
-	struct winlink	*wl;
-	char		*list_ctx;
-	u_int		 pane_id;
-};
-ARRAY_DECL(cmd_find_window_data_list, struct cmd_find_window_data);
-
-u_int	cmd_find_window_match_flags(struct args *);
-void	cmd_find_window_match(struct cmd_find_window_data_list *, int,
-	    struct winlink *, const char *, const char *);
-
-u_int
-cmd_find_window_match_flags(struct args *args)
+static enum cmd_retval
+cmd_find_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	u_int	match_flags = 0;
+	struct args		*args = self->args, *new_args;
+	struct window_pane	*wp = item->target.wp;
+	const char		*s = args->argv[0];
+	char			*filter, *argv = { NULL };
+	int			 C, N, T;
 
-	/* 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;
+	C = args_has(args, 'C');
+	N = args_has(args, 'N');
+	T = args_has(args, 'T');
 
-	/* If none of the flags were set, default to matching anything. */
-	if (match_flags == 0)
-		match_flags = CMD_FIND_WINDOW_ALL;
+	if (!C && !N && !T)
+		C = N = T = 1;
 
-	return (match_flags);
-}
+	if (C && N && T) {
+		xasprintf(&filter,
+		    "#{||:"
+		    "#{C:%s},#{||:#{m:*%s*,#{window_name}},"
+		    "#{m:*%s*,#{pane_title}}}}",
+		    s, s, s);
+	} else if (C && N) {
+		xasprintf(&filter,
+		    "#{||:#{C:%s},#{m:*%s*,#{window_name}}}",
+		    s, s);
+	} else if (C && T) {
+		xasprintf(&filter,
+		    "#{||:#{C:%s},#{m:*%s*,#{pane_title}}}",
+		    s, s);
+	} else if (N && T) {
+		xasprintf(&filter,
+		    "#{||:#{m:*%s*,#{window_name}},#{m:*%s*,#{pane_title}}}",
+		    s, s);
+	} else if (C)
+		xasprintf(&filter, "#{C:%s}", s);
+	else if (N)
+		xasprintf(&filter, "#{m:*%s*,#{window_name}}", s);
+	else
+		xasprintf(&filter, "#{m:*%s*,#{pane_title}}", s);
 
-void
-cmd_find_window_match(struct cmd_find_window_data_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;
+	new_args = args_parse("", 1, &argv);
+	args_set(new_args, 'f', filter);
 
-	memset(&find_data, 0, sizeof find_data);
+	window_pane_set_mode(wp, &window_tree_mode, &item->target, new_args);
 
-	i = 0;
-	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
-		i++;
+	args_free(new_args);
+	free(filter);
 
-		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;
-		ARRAY_ADD(find_list, 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 window_choose_data	*cdata;
-	struct session			*s;
-	struct winlink			*wl, *wm;
-	struct cmd_find_window_data_list find_list;
-	char				*str, *searchstr;
-	const char			*template;
-	u_int				 i, match_flags;
-
-	if ((c = cmd_current_client(cmdq)) == NULL) {
-		cmdq_error(cmdq, "no client available");
-		return (CMD_RETURN_ERROR);
-	}
-	s = c->session;
-
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), NULL)) == NULL)
-		return (CMD_RETURN_ERROR);
-
-	if ((template = args_get(args, 'F')) == NULL)
-		template = FIND_WINDOW_TEMPLATE;
-
-	match_flags = cmd_find_window_match_flags(args);
-	str = args->argv[0];
-
-	ARRAY_INIT(&find_list);
-
-	xasprintf(&searchstr, "*%s*", str);
-	RB_FOREACH(wm, winlinks, &s->windows)
-	    cmd_find_window_match (&find_list, match_flags, wm, str, searchstr);
-	free(searchstr);
-
-	if (ARRAY_LENGTH(&find_list) == 0) {
-		cmdq_error(cmdq, "no windows matching: %s", str);
-		ARRAY_FREE(&find_list);
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (ARRAY_LENGTH(&find_list) == 1) {
-		if (session_select(s, ARRAY_FIRST(&find_list).wl->idx) == 0)
-			server_redraw_session(s);
-		recalculate_sizes();
-		goto out;
-	}
-
-	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
-		goto out;
-
-	for (i = 0; i < ARRAY_LENGTH(&find_list); i++) {
-		wm = ARRAY_ITEM(&find_list, i).wl;
-
-		cdata = window_choose_data_create(TREE_OTHER, c, c->session);
-		cdata->idx = wm->idx;
-		cdata->wl = wm;
-
-		cdata->ft_template = xstrdup(template);
-		cdata->pane_id = ARRAY_ITEM(&find_list, i).pane_id;
-
-		format_add(cdata->ft, "line", "%u", i);
-		format_add(cdata->ft, "window_find_matches", "%s",
-		    ARRAY_ITEM(&find_list, i).list_ctx);
-		format_session(cdata->ft, s);
-		format_winlink(cdata->ft, s, wm);
-		format_window_pane(cdata->ft, wm->window->active);
-
-		window_choose_add(wl->window->active, cdata);
-	}
-
-	window_choose_ready(wl->window->active, 0, cmd_find_window_callback);
-
-out:
-	ARRAY_FREE(&find_list);
 	return (CMD_RETURN_NORMAL);
 }
-
-void
-cmd_find_window_callback(struct window_choose_data *cdata)
-{
-	struct session		*s;
-	struct window_pane	*wp;
-
-	if (cdata == NULL)
-		return;
-
-	s = cdata->start_session;
-	if (!session_alive(s))
-		return;
-
-	wp = window_pane_at_index(cdata->wl->window, cdata->pane_id);
-	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();
-	}
-}

cmd-if-shell.c

@@ -1,4 +1,4 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -29,150 +29,165 @@
  * Executes a tmux command if a shell command returns true or false.
  */
 
-enum cmd_retval	 cmd_if_shell_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_if_shell_exec(struct cmd *, struct cmdq_item *);
 
-void	cmd_if_shell_callback(struct job *);
-void	cmd_if_shell_done(struct cmd_q *);
-void	cmd_if_shell_free(void *);
+static void		cmd_if_shell_callback(struct job *);
+static void		cmd_if_shell_free(void *);
 
 const struct cmd_entry cmd_if_shell_entry = {
-	"if-shell", "if",
-	"bt:", 2, 3,
-	"[-b] " CMD_TARGET_PANE_USAGE " shell-command command [command]",
-	0,
-	NULL,
-	cmd_if_shell_exec
+	.name = "if-shell",
+	.alias = "if",
+
+	.args = { "bFt:", 2, 3 },
+	.usage = "[-bF] " CMD_TARGET_PANE_USAGE " shell-command command "
+		 "[command]",
+
+	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
+
+	.flags = 0,
+	.exec = cmd_if_shell_exec
 };
 
 struct cmd_if_shell_data {
-	char		*cmd_if;
-	char		*cmd_else;
-	struct cmd_q	*cmdq;
-	int		 bflag;
-	int		 started;
+	char			*file;
+	u_int			 line;
+
+	char			*cmd_if;
+	char			*cmd_else;
+
+	struct client		*client;
+	struct cmdq_item	*item;
+	struct mouse_event	 mouse;
 };
 
-enum cmd_retval
-cmd_if_shell_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
+	struct cmdq_shared		*shared = item->shared;
 	struct cmd_if_shell_data	*cdata;
-	char				*shellcmd;
-	struct client			*c;
-	struct session			*s = NULL;
-	struct winlink			*wl = NULL;
-	struct window_pane		*wp = NULL;
-	struct format_tree		*ft;
+	char				*shellcmd, *cmd, *cause;
+	struct cmd_list			*cmdlist;
+	struct cmdq_item		*new_item;
+	struct client			*c = cmd_find_client(item, NULL, 1);
+	struct session			*s = item->target.s;
+	struct winlink			*wl = item->target.wl;
+	struct window_pane		*wp = item->target.wp;
+	const char			*cwd;
 
-	if (args_has(args, 't'))
-		wl = cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp);
-	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 (item->client != NULL && item->client->session == NULL)
+		cwd = item->client->cwd;
+	else if (s != NULL)
+		cwd = s->cwd;
+	else
+		cwd = NULL;
+
+	shellcmd = format_single(item, args->argv[0], c, s, wl, wp);
+	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];
+		free(shellcmd);
+		if (cmd == NULL)
+			return (CMD_RETURN_NORMAL);
+		cmdlist = cmd_string_parse(cmd, NULL, 0, &cause);
+		if (cmdlist == NULL) {
+			if (cause != NULL) {
+				cmdq_error(item, "%s", cause);
+				free(cause);
+			}
+			return (CMD_RETURN_ERROR);
 		}
+		new_item = cmdq_get_command(cmdlist, NULL, &shared->mouse, 0);
+		cmdq_insert_after(item, new_item);
+		cmd_list_free(cmdlist);
+		return (CMD_RETURN_NORMAL);
 	}
 
-	ft = format_create();
-	if (s != NULL)
-		format_session(ft, s);
-	if (s != NULL && wl != NULL)
-		format_winlink(ft, s, wl);
-	if (wp != NULL)
-		format_window_pane(ft, wp);
-	shellcmd = format_expand(ft, args->argv[0]);
-	format_free(ft);
+	cdata = xcalloc(1, sizeof *cdata);
+	if (self->file != NULL) {
+		cdata->file = xstrdup(self->file);
+		cdata->line = self->line;
+	}
 
-	cdata = xmalloc(sizeof *cdata);
 	cdata->cmd_if = xstrdup(args->argv[1]);
 	if (args->argc == 3)
 		cdata->cmd_else = xstrdup(args->argv[2]);
 	else
 		cdata->cmd_else = NULL;
-	cdata->bflag = args_has(args, 'b');
 
-	cdata->started = 0;
-	cdata->cmdq = cmdq;
-	cmdq->references++;
+	cdata->client = item->client;
+	if (cdata->client != NULL)
+		cdata->client->references++;
 
-	job_run(shellcmd, s, cmd_if_shell_callback, cmd_if_shell_free, cdata);
+	if (!args_has(args, 'b'))
+		cdata->item = item;
+	else
+		cdata->item = NULL;
+	memcpy(&cdata->mouse, &shared->mouse, sizeof cdata->mouse);
+
+	job_run(shellcmd, s, cwd, NULL, cmd_if_shell_callback,
+	    cmd_if_shell_free, cdata, 0);
 	free(shellcmd);
 
-	if (cdata->bflag)
+	if (args_has(args, 'b'))
 		return (CMD_RETURN_NORMAL);
 	return (CMD_RETURN_WAIT);
 }
 
-void
+static void
 cmd_if_shell_callback(struct job *job)
 {
 	struct cmd_if_shell_data	*cdata = job->data;
-	struct cmd_q			*cmdq = cdata->cmdq, *cmdq1;
+	struct client			*c = cdata->client;
 	struct cmd_list			*cmdlist;
-	char				*cause, *cmd;
-
-	if (cmdq->dead)
-		return;
+	struct cmdq_item		*new_item;
+	char				*cause, *cmd, *file = cdata->file;
+	u_int				 line = cdata->line;
 
 	if (!WIFEXITED(job->status) || WEXITSTATUS(job->status) != 0)
 		cmd = cdata->cmd_else;
 	else
 		cmd = cdata->cmd_if;
 	if (cmd == NULL)
-		return;
+		goto out;
 
-	if (cmd_string_parse(cmd, &cmdlist, NULL, 0, &cause) != 0) {
-		if (cause != NULL) {
-			cmdq_error(cmdq, "%s", cause);
-			free(cause);
-		}
-		return;
+	cmdlist = cmd_string_parse(cmd, file, line, &cause);
+	if (cmdlist == NULL) {
+		if (cause != NULL && cdata->item != NULL)
+			cmdq_error(cdata->item, "%s", cause);
+		free(cause);
+		new_item = NULL;
+	} else {
+		new_item = cmdq_get_command(cmdlist, NULL, &cdata->mouse, 0);
+		cmd_list_free(cmdlist);
 	}
 
-	cdata->started = 1;
+	if (new_item != NULL) {
+		if (cdata->item == NULL)
+			cmdq_append(c, new_item);
+		else
+			cmdq_insert_after(cdata->item, new_item);
+	}
 
-	cmdq1 = cmdq_new(cmdq->client);
-	cmdq1->emptyfn = cmd_if_shell_done;
-	cmdq1->data = cdata;
-
-	cmdq_run(cmdq1, cmdlist);
-	cmd_list_free(cmdlist);
+out:
+	if (cdata->item != NULL)
+		cdata->item->flags &= ~CMDQ_WAITING;
 }
 
-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;
-
-	if (!cmdq_free(cmdq) && !cdata->bflag)
-		cmdq_continue(cmdq);
-
-	cmdq_free(cmdq1);
-
-	free(cdata->cmd_else);
-	free(cdata->cmd_if);
-	free(cdata);
-}
-
-void
+static void
 cmd_if_shell_free(void *data)
 {
 	struct cmd_if_shell_data	*cdata = data;
-	struct cmd_q			*cmdq = cdata->cmdq;
 
-	if (cdata->started)
-		return;
-
-	if (!cmdq_free(cmdq) && !cdata->bflag)
-		cmdq_continue(cmdq);
+	if (cdata->client != NULL)
+		server_client_unref(cdata->client);
 
 	free(cdata->cmd_else);
 	free(cdata->cmd_if);
+
+	free(cdata->file);
 	free(cdata);
 }

cmd-join-pane.c

@@ -1,8 +1,8 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
  * Copyright (c) 2011 George Nachman <tmux@georgester.com>
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -28,53 +28,41 @@
  * Join or move a pane into another (like split/swap/kill).
  */
 
-void		 cmd_join_pane_key_binding(struct cmd *, int);
-enum cmd_retval	 cmd_join_pane_exec(struct cmd *, struct cmd_q *);
-
-enum cmd_retval	 join_pane(struct cmd *, struct cmd_q *, int);
+static enum cmd_retval	cmd_join_pane_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_join_pane_entry = {
-	"join-pane", "joinp",
-	"bdhvp:l:s:t:", 0, 0,
-	"[-bdhv] [-p percentage|-l size] [-s src-pane] [-t dst-pane]",
-	0,
-	cmd_join_pane_key_binding,
-	cmd_join_pane_exec
+	.name = "join-pane",
+	.alias = "joinp",
+
+	.args = { "bdhvp:l:s:t:", 0, 0 },
+	.usage = "[-bdhv] [-p percentage|-l size] " CMD_SRCDST_PANE_USAGE,
+
+	.source = { 's', CMD_FIND_PANE, CMD_FIND_DEFAULT_MARKED },
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = 0,
+	.exec = cmd_join_pane_exec
 };
 
 const struct cmd_entry cmd_move_pane_entry = {
-	"move-pane", "movep",
-	"bdhvp:l:s:t:", 0, 0,
-	"[-bdhv] [-p percentage|-l size] [-s src-pane] [-t dst-pane]",
-	0,
-	NULL,
-	cmd_join_pane_exec
+	.name = "move-pane",
+	.alias = "movep",
+
+	.args = { "bdhvp:l:s:t:", 0, 0 },
+	.usage = "[-bdhv] [-p percentage|-l size] " CMD_SRCDST_PANE_USAGE,
+
+	.source = { 's', CMD_FIND_PANE, 0 },
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = 0,
+	.exec = cmd_join_pane_exec
 };
 
-void
-cmd_join_pane_key_binding(struct cmd *self, int key)
-{
-	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
-cmd_join_pane_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	return (join_pane(self, cmdq, self->entry == &cmd_join_pane_entry));
-}
-
-enum cmd_retval
-join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
+static enum cmd_retval
+cmd_join_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
+	struct cmd_find_state	*current = &item->shared->current;
 	struct session		*dst_s;
 	struct winlink		*src_wl, *dst_wl;
 	struct window		*src_w, *dst_w;
@@ -83,26 +71,31 @@ join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
 	int			 size, percentage, dst_idx;
 	enum layout_type	 type;
 	struct layout_cell	*lc;
+	int			 not_same_window;
 
-	dst_wl = cmd_find_pane(cmdq, args_get(args, 't'), &dst_s, &dst_wp);
-	if (dst_wl == NULL)
-		return (CMD_RETURN_ERROR);
+	if (self->entry == &cmd_join_pane_entry)
+		not_same_window = 1;
+	else
+		not_same_window = 0;
+
+	dst_s = item->target.s;
+	dst_wl = item->target.wl;
+	dst_wp = item->target.wp;
 	dst_w = dst_wl->window;
 	dst_idx = dst_wl->idx;
 	server_unzoom_window(dst_w);
 
-	src_wl = cmd_find_pane(cmdq, args_get(args, 's'), NULL, &src_wp);
-	if (src_wl == NULL)
-		return (CMD_RETURN_ERROR);
+	src_wl = item->source.wl;
+	src_wp = item->source.wp;
 	src_w = src_wl->window;
 	server_unzoom_window(src_w);
 
 	if (not_same_window && src_w == dst_w) {
-		cmdq_error(cmdq, "can't join a pane to its own window");
+		cmdq_error(item, "can't join a pane to its own window");
 		return (CMD_RETURN_ERROR);
 	}
 	if (!not_same_window && src_wp == dst_wp) {
-		cmdq_error(cmdq, "source and target panes must be different");
+		cmdq_error(item, "source and target panes must be different");
 		return (CMD_RETURN_ERROR);
 	}
 
@@ -114,14 +107,14 @@ 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);
+			cmdq_error(item, "size %s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
 	} else if (args_has(args, 'p')) {
 		percentage = args_strtonum(args, 'p', 0, 100, &cause);
 		if (cause != NULL) {
-			cmdq_error(cmdq, "percentage %s", cause);
+			cmdq_error(item, "percentage %s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
@@ -130,26 +123,17 @@ join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
 		else
 			size = (dst_wp->sx * percentage) / 100;
 	}
-	lc = layout_split_pane(dst_wp, type, size, args_has(args, 'b'));
+	lc = layout_split_pane(dst_wp, type, size, args_has(args, 'b'), 0);
 	if (lc == NULL) {
-		cmdq_error(cmdq, "create pane failed: pane too small");
+		cmdq_error(item, "create pane failed: pane too small");
 		return (CMD_RETURN_ERROR);
 	}
 
 	layout_close_pane(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);
-	}
+	window_lost_pane(src_w, src_wp);
 	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);
 	layout_assign_pane(lc, src_wp);
@@ -162,10 +146,16 @@ join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
 	if (!args_has(args, 'd')) {
 		window_set_active_pane(dst_w, src_wp);
 		session_select(dst_s, dst_idx);
+		cmd_find_from_session(current, dst_s, 0);
 		server_redraw_session(dst_s);
 	} else
 		server_status_session(dst_s);
 
-	notify_window_layout_changed(dst_w);
+	if (window_count_panes(src_w) == 0)
+		server_kill_window(src_w);
+	else
+		notify_window("window-layout-changed", src_w);
+	notify_window("window-layout-changed", dst_w);
+
 	return (CMD_RETURN_NORMAL);
 }

cmd-kill-pane.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -26,35 +26,29 @@
  * Kill pane.
  */
 
-enum cmd_retval	 cmd_kill_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_kill_pane_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_kill_pane_entry = {
-	"kill-pane", "killp",
-	"at:", 0, 0,
-	"[-a] " CMD_TARGET_PANE_USAGE,
-	0,
-	NULL,
-	cmd_kill_pane_exec
+	.name = "kill-pane",
+	.alias = "killp",
+
+	.args = { "at:", 0, 0 },
+	.usage = "[-a] " CMD_TARGET_PANE_USAGE,
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = 0,
+	.exec = cmd_kill_pane_exec
 };
 
-enum cmd_retval
-cmd_kill_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_kill_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	struct winlink		*wl;
-	struct window_pane	*loopwp, *tmpwp, *wp;
+	struct winlink		*wl = item->target.wl;
+	struct window_pane	*loopwp, *tmpwp, *wp = item->target.wp;
 
-	if ((wl = cmd_find_pane(cmdq, args_get(args, 't'), NULL, &wp)) == NULL)
-		return (CMD_RETURN_ERROR);
 	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);
-	}
-
 	if (args_has(self->args, 'a')) {
 		TAILQ_FOREACH_SAFE(loopwp, &wl->window->panes, entry, tmpwp) {
 			if (loopwp == wp)
@@ -62,11 +56,17 @@ cmd_kill_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 			layout_close_pane(loopwp);
 			window_remove_pane(wl->window, loopwp);
 		}
+		server_redraw_window(wl->window);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	if (window_count_panes(wl->window) == 1) {
+		server_kill_window(wl->window);
+		recalculate_sizes();
 	} else {
 		layout_close_pane(wp);
 		window_remove_pane(wl->window, wp);
+		server_redraw_window(wl->window);
 	}
-	server_redraw_window(wl->window);
-
 	return (CMD_RETURN_NORMAL);
 }

cmd-kill-server.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -27,28 +27,32 @@
  * Kill the server and do nothing else.
  */
 
-enum cmd_retval	 cmd_kill_server_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_kill_server_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_kill_server_entry = {
-	"kill-server", NULL,
-	"", 0, 0,
-	"",
-	0,
-	NULL,
-	cmd_kill_server_exec
+	.name = "kill-server",
+	.alias = NULL,
+
+	.args = { "", 0, 0 },
+	.usage = "",
+
+	.flags = 0,
+	.exec = cmd_kill_server_exec
 };
 
 const struct cmd_entry cmd_start_server_entry = {
-	"start-server", "start",
-	"", 0, 0,
-	"",
-	CMD_STARTSERVER,
-	NULL,
-	cmd_kill_server_exec
+	.name = "start-server",
+	.alias = "start",
+
+	.args = { "", 0, 0 },
+	.usage = "",
+
+	.flags = CMD_STARTSERVER,
+	.exec = cmd_kill_server_exec
 };
 
-enum cmd_retval
-cmd_kill_server_exec(struct cmd *self, unused struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_kill_server_exec(struct cmd *self, __unused struct cmdq_item *item)
 {
 	if (self->entry == &cmd_kill_server_entry)
 		kill(getpid(), SIGTERM);

cmd-kill-session.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -27,36 +27,46 @@
  * 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 *);
+static enum cmd_retval	cmd_kill_session_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_kill_session_entry = {
-	"kill-session", NULL,
-	"at:", 0, 0,
-	"[-a] " CMD_TARGET_SESSION_USAGE,
-	0,
-	NULL,
-	cmd_kill_session_exec
+	.name = "kill-session",
+	.alias = NULL,
+
+	.args = { "aCt:", 0, 0 },
+	.usage = "[-aC] " CMD_TARGET_SESSION_USAGE,
+
+	.target = { 't', CMD_FIND_SESSION, 0 },
+
+	.flags = 0,
+	.exec = cmd_kill_session_exec
 };
 
-enum cmd_retval
-cmd_kill_session_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_kill_session_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct session	*s, *s2, *s3;
+	struct session	*s, *sloop, *stmp;
+	struct winlink	*wl;
 
-	if ((s = cmd_find_session(cmdq, args_get(args, 't'), 0)) == NULL)
-		return (CMD_RETURN_ERROR);
+	s = item->target.s;
 
-	if (args_has(args, 'a')) {
-		RB_FOREACH_SAFE(s2, sessions, &sessions, s3) {
-			if (s != s2) {
-				server_destroy_session(s2);
-				session_destroy(s2);
+	if (args_has(args, 'C')) {
+		RB_FOREACH(wl, winlinks, &s->windows) {
+			wl->window->flags &= ~WINDOW_ALERTFLAGS;
+			wl->flags &= ~WINLINK_ALERTFLAGS;
+		}
+		server_redraw_session(s);
+	} else if (args_has(args, 'a')) {
+		RB_FOREACH_SAFE(sloop, sessions, &sessions, stmp) {
+			if (sloop != s) {
+				server_destroy_session(sloop);
+				session_destroy(sloop, __func__);
 			}
 		}
 	} else {
 		server_destroy_session(s);
-		session_destroy(s);
+		session_destroy(s, __func__);
 	}
 	return (CMD_RETURN_NORMAL);
 }

cmd-kill-window.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -24,34 +24,57 @@
  * Destroy window.
  */
 
-enum cmd_retval	 cmd_kill_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_kill_window_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_kill_window_entry = {
-	"kill-window", "killw",
-	"at:", 0, 0,
-	"[-a] " CMD_TARGET_WINDOW_USAGE,
-	0,
-	NULL,
-	cmd_kill_window_exec
+	.name = "kill-window",
+	.alias = "killw",
+
+	.args = { "at:", 0, 0 },
+	.usage = "[-a] " CMD_TARGET_WINDOW_USAGE,
+
+	.target = { 't', CMD_FIND_WINDOW, 0 },
+
+	.flags = 0,
+	.exec = cmd_kill_window_exec
 };
 
-enum cmd_retval
-cmd_kill_window_exec(struct cmd *self, struct cmd_q *cmdq)
+const struct cmd_entry cmd_unlink_window_entry = {
+	.name = "unlink-window",
+	.alias = "unlinkw",
+
+	.args = { "kt:", 0, 0 },
+	.usage = "[-k] " CMD_TARGET_WINDOW_USAGE,
+
+	.target = { 't', CMD_FIND_WINDOW, 0 },
+
+	.flags = 0,
+	.exec = cmd_kill_window_exec
+};
+
+static enum cmd_retval
+cmd_kill_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	struct winlink	*wl, *wl2, *wl3;
-	struct session	*s;
+	struct args		*args = self->args;
+	struct winlink		*wl = item->target.wl, *wl2, *wl3;
+	struct window		*w = wl->window;
+	struct session		*s = item->target.s;
 
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), &s)) == NULL)
-		return (CMD_RETURN_ERROR);
-
-	if (args_has(args, 'a')) {
-		RB_FOREACH_SAFE(wl2, winlinks, &s->windows, wl3) {
-			if (wl != wl2)
-				server_kill_window(wl2->window);
+	if (self->entry == &cmd_unlink_window_entry) {
+		if (!args_has(self->args, 'k') && !session_is_linked(s, w)) {
+			cmdq_error(item, "window only linked to one session");
+			return (CMD_RETURN_ERROR);
 		}
-	} else
-		server_kill_window(wl->window);
+		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);
+	}
 
 	recalculate_sizes();
 	return (CMD_RETURN_NORMAL);

cmd-link-window.c

@@ -1,64 +0,0 @@
-/* $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.
- */
-
-enum cmd_retval	 cmd_link_window_exec(struct cmd *, struct cmd_q *);
-
-const struct cmd_entry cmd_link_window_entry = {
-	"link-window", "linkw",
-	"dks:t:", 0, 0,
-	"[-dk] " CMD_SRCDST_WINDOW_USAGE,
-	0,
-	NULL,
-	cmd_link_window_exec
-};
-
-enum cmd_retval
-cmd_link_window_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args	*args = self->args;
-	struct session	*src, *dst;
-	struct winlink	*wl;
-	char		*cause;
-	int		 idx, kflag, dflag;
-
-	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');
-	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);
-	}
-	recalculate_sizes();
-
-	return (CMD_RETURN_NORMAL);
-}

cmd-list-buffers.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -27,38 +27,41 @@
  * List paste buffers.
  */
 
-enum cmd_retval	 cmd_list_buffers_exec(struct cmd *, struct cmd_q *);
+#define LIST_BUFFERS_TEMPLATE						\
+	"#{buffer_name}: #{buffer_size} bytes: \"#{buffer_sample}\""
+
+static enum cmd_retval	cmd_list_buffers_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_list_buffers_entry = {
-	"list-buffers", "lsb",
-	"F:", 0, 0,
-	"[-F format]",
-	0,
-	NULL,
-	cmd_list_buffers_exec
+	.name = "list-buffers",
+	.alias = "lsb",
+
+	.args = { "F:", 0, 0 },
+	.usage = "[-F format]",
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_list_buffers_exec
 };
 
-enum cmd_retval
-cmd_list_buffers_exec(unused struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_buffers_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct paste_buffer	*pb;
 	struct format_tree	*ft;
-	u_int			 idx;
 	char			*line;
 	const char		*template;
 
 	if ((template = args_get(args, 'F')) == NULL)
 		template = LIST_BUFFERS_TEMPLATE;
 
-	idx = 0;
-	while ((pb = paste_walk_stack(&global_buffers, &idx)) != NULL) {
-		ft = format_create();
-		format_add(ft, "line", "%u", idx - 1);
-		format_paste_buffer(ft, pb);
+	pb = NULL;
+	while ((pb = paste_walk(pb)) != NULL) {
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
+		format_defaults_paste_buffer(ft, pb);
 
 		line = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", line);
+		cmdq_print(item, "%s", line);
 		free(line);
 
 		format_free(ft);

cmd-list-clients.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -28,56 +28,61 @@
  * List all clients.
  */
 
-enum cmd_retval	cmd_list_clients_exec(struct cmd *, struct cmd_q *);
+#define LIST_CLIENTS_TEMPLATE					\
+	"#{client_name}: #{session_name} "			\
+	"[#{client_width}x#{client_height} #{client_termname}]"	\
+	"#{?client_utf8, (utf8),} #{?client_readonly, (ro),}"
+
+static enum cmd_retval	cmd_list_clients_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_list_clients_entry = {
-	"list-clients", "lsc",
-	"F:t:", 0, 0,
-	"[-F format] " CMD_TARGET_SESSION_USAGE,
-	CMD_READONLY,
-	NULL,
-	cmd_list_clients_exec
+	.name = "list-clients",
+	.alias = "lsc",
+
+	.args = { "F:t:", 0, 0 },
+	.usage = "[-F format] " CMD_TARGET_SESSION_USAGE,
+
+	.target = { 't', CMD_FIND_SESSION, 0 },
+
+	.flags = CMD_READONLY|CMD_AFTERHOOK,
+	.exec = cmd_list_clients_exec
 };
 
-enum cmd_retval
-cmd_list_clients_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_clients_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args 		*args = self->args;
 	struct client		*c;
 	struct session		*s;
 	struct format_tree	*ft;
 	const char		*template;
-	u_int			 i;
+	u_int			 idx;
 	char			*line;
 
-	if (args_has(args, 't')) {
-		s = cmd_find_session(cmdq, args_get(args, 't'), 0);
-		if (s == NULL)
-			return (CMD_RETURN_ERROR);
-	} else
+	if (args_has(args, 't'))
+		s = item->target.s;
+	else
 		s = NULL;
 
 	if ((template = args_get(args, 'F')) == NULL)
 		template = LIST_CLIENTS_TEMPLATE;
 
-	for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
-		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;
 
-		if (s != NULL && s != c->session)
-			continue;
-
-		ft = format_create();
-		format_add(ft, "line", "%u", i);
-		format_session(ft, c->session);
-		format_client(ft, c);
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
+		format_add(ft, "line", "%u", idx);
+		format_defaults(ft, c, NULL, NULL, NULL);
 
 		line = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", line);
+		cmdq_print(item, "%s", line);
 		free(line);
 
 		format_free(ft);
+
+		idx++;
 	}
 
 	return (CMD_RETURN_NORMAL);

cmd-list-commands.c

@@ -1,54 +0,0 @@
-/* $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.
- */
-
-enum cmd_retval	 cmd_list_commands_exec(struct cmd *, struct cmd_q *);
-
-const struct cmd_entry cmd_list_commands_entry = {
-	"list-commands", "lscm",
-	"", 0, 0,
-	"",
-	0,
-	NULL,
-	cmd_list_commands_exec
-};
-
-enum cmd_retval
-cmd_list_commands_exec(unused struct cmd *self, struct cmd_q *cmdq)
-{
-	const struct cmd_entry 	      **entryp;
-
-	for (entryp = cmd_table; *entryp != NULL; entryp++) {
-		if ((*entryp)->alias != NULL) {
-			cmdq_print(cmdq, "%s (%s) %s", (*entryp)->name,
-			    (*entryp)->alias, (*entryp)->usage);
-		} else {
-			cmdq_print(cmdq, "%s %s", (*entryp)->name,
-			    (*entryp)->usage);
-		}
-	}
-
-	return (CMD_RETURN_NORMAL);
-}

cmd-list-keys.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -18,6 +18,7 @@
 
 #include <sys/types.h>
 
+#include <stdlib.h>
 #include <string.h>
 
 #include "tmux.h"
@@ -26,125 +27,147 @@
  * List key bindings.
  */
 
-enum cmd_retval	 cmd_list_keys_exec(struct cmd *, struct cmd_q *);
-enum cmd_retval	 cmd_list_keys_table(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_list_keys_exec(struct cmd *, struct cmdq_item *);
+
+static enum cmd_retval	cmd_list_keys_commands(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_list_keys_entry = {
-	"list-keys", "lsk",
-	"t:", 0, 0,
-	"[-t key-table]",
-	0,
-	NULL,
-	cmd_list_keys_exec
+	.name = "list-keys",
+	.alias = "lsk",
+
+	.args = { "T:", 0, 0 },
+	.usage = "[-T key-table]",
+
+	.flags = CMD_STARTSERVER|CMD_AFTERHOOK,
+	.exec = cmd_list_keys_exec
 };
 
-enum cmd_retval
-cmd_list_keys_exec(struct cmd *self, struct cmd_q *cmdq)
+const struct cmd_entry cmd_list_commands_entry = {
+	.name = "list-commands",
+	.alias = "lscm",
+
+	.args = { "F:", 0, 0 },
+	.usage = "[-F format]",
+
+	.flags = CMD_STARTSERVER|CMD_AFTERHOOK,
+	.exec = cmd_list_keys_exec
+};
+
+static enum cmd_retval
+cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
+	struct key_table	*table;
 	struct key_binding	*bd;
-	const char		*key;
-	char			 tmp[BUFSIZ], flags[8];
-	size_t			 used;
-	int			 width, keywidth;
+	const char		*key, *tablename, *r;
+	char			*cp, tmp[BUFSIZ];
+	int			 repeat, width, tablewidth, keywidth;
 
-	if (args_has(args, 't'))
-		return (cmd_list_keys_table(self, cmdq));
+	if (self->entry == &cmd_list_commands_entry)
+		return (cmd_list_keys_commands(self, item));
 
-	width = 0;
-
-	RB_FOREACH(bd, key_bindings, &key_bindings) {
-		key = key_string_lookup_key(bd->key & ~KEYC_PREFIX);
-		if (key == NULL)
-			continue;
-
-		keywidth = strlen(key);
-		if (!(bd->key & KEYC_PREFIX)) {
-			if (bd->can_repeat)
-				keywidth += 4;
-			else
-				keywidth += 3;
-		} else if (bd->can_repeat)
-			keywidth += 3;
-		if (keywidth > width)
-			width = keywidth;
-	}
-
-	RB_FOREACH(bd, key_bindings, &key_bindings) {
-		key = key_string_lookup_key(bd->key & ~KEYC_PREFIX);
-		if (key == NULL)
-			continue;
-
-		*flags = '\0';
-		if (!(bd->key & KEYC_PREFIX)) {
-			if (bd->can_repeat)
-				xsnprintf(flags, sizeof flags, "-rn ");
-			else
-				xsnprintf(flags, sizeof flags, "-n ");
-		} else if (bd->can_repeat)
-			xsnprintf(flags, sizeof flags, "-r ");
-
-		used = xsnprintf(tmp, sizeof tmp, "%s%*s ",
-		    flags, (int) (width - strlen(flags)), key);
-		if (used >= sizeof tmp)
-			continue;
-
-		cmd_list_print(bd->cmdlist, tmp + used, (sizeof tmp) - used);
-		cmdq_print(cmdq, "bind-key %s", tmp);
-	}
-
-	return (CMD_RETURN_NORMAL);
-}
-
-enum cmd_retval
-cmd_list_keys_table(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args			*args = self->args;
-	const char			*tablename;
-	const struct mode_key_table	*mtab;
-	struct mode_key_binding		*mbind;
-	const char			*key, *cmdstr, *mode;
-	int			 	 width, keywidth, any_mode;
-
-	tablename = args_get(args, 't');
-	if ((mtab = mode_key_findtable(tablename)) == NULL) {
-		cmdq_error(cmdq, "unknown key table: %s", tablename);
+	tablename = args_get(args, 'T');
+	if (tablename != NULL && key_bindings_get_table(tablename, 0) == NULL) {
+		cmdq_error(item, "table %s doesn't exist", tablename);
 		return (CMD_RETURN_ERROR);
 	}
 
-	width = 0;
-	any_mode = 0;
-	RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
-		key = key_string_lookup_key(mbind->key);
-		if (key == NULL)
+	repeat = 0;
+	tablewidth = keywidth = 0;
+	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 (mbind->mode != 0)
-			any_mode = 1;
+			if (bd->flags & KEY_BINDING_REPEAT)
+				repeat = 1;
 
-		keywidth = strlen(key);
-		if (keywidth > width)
-			width = keywidth;
+			width = utf8_cstrwidth(table->name);
+			if (width > tablewidth)
+				tablewidth = width;
+			width = utf8_cstrwidth(key);
+			if (width > keywidth)
+				keywidth = width;
+		}
 	}
 
-	RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
-		key = key_string_lookup_key(mbind->key);
-		if (key == NULL)
+	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);
 
-		mode = "";
-		if (mbind->mode != 0)
-			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",
-			    mode, any_mode && *mode == '\0' ? " " : "",
-			    mtab->name, (int) width, key, cmdstr,
-			    mbind->arg != NULL ? " \"" : "",
-			    mbind->arg != NULL ? mbind->arg : "",
-			    mbind->arg != NULL ? "\"": "");
+			if (!repeat)
+				r = "";
+			else if (bd->flags & KEY_BINDING_REPEAT)
+				r = "-r ";
+			else
+				r = "   ";
+			xsnprintf(tmp, sizeof tmp, "%s-T ", r);
+
+			cp = utf8_padcstr(table->name, tablewidth);
+			strlcat(tmp, cp, sizeof tmp);
+			strlcat(tmp, " ", sizeof tmp);
+			free(cp);
+
+			cp = utf8_padcstr(key, keywidth);
+			strlcat(tmp, cp, sizeof tmp);
+			strlcat(tmp, " ", sizeof tmp);
+			free(cp);
+
+			cp = cmd_list_print(bd->cmdlist);
+			strlcat(tmp, cp, sizeof tmp);
+			free(cp);
+
+			cmdq_print(item, "bind-key %s", tmp);
 		}
 	}
 
 	return (CMD_RETURN_NORMAL);
 }
+
+static enum cmd_retval
+cmd_list_keys_commands(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		*args = self->args;
+	const struct cmd_entry	**entryp;
+	const struct cmd_entry	 *entry;
+	struct format_tree	 *ft;
+	const char		 *template, *s;
+	char			 *line;
+
+	if ((template = args_get(args, 'F')) == NULL) {
+		template = "#{command_list_name}"
+		    "#{?command_list_alias, (#{command_list_alias}),} "
+		    "#{command_list_usage}";
+	}
+
+	ft = format_create(item->client, item, FORMAT_NONE, 0);
+	format_defaults(ft, NULL, NULL, NULL, NULL);
+
+	for (entryp = cmd_table; *entryp != NULL; entryp++) {
+		entry = *entryp;
+
+		format_add(ft, "command_list_name", "%s", entry->name);
+		if (entry->alias != NULL)
+			s = entry->alias;
+		else
+			s = "";
+		format_add(ft, "command_list_alias", "%s", s);
+		if (entry->usage != NULL)
+			s = entry->usage;
+		else
+			s = "";
+		format_add(ft, "command_list_usage", "%s", s);
+
+		line = format_expand(ft, template);
+		if (*line != '\0')
+			cmdq_print(item, "%s", line);
+		free(line);
+	}
+
+	format_free(ft);
+	return (CMD_RETURN_NORMAL);
+}

cmd-list-panes.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -19,7 +19,6 @@
 #include <sys/types.h>
 
 #include <stdlib.h>
-#include <unistd.h>
 
 #include "tmux.h"
 
@@ -27,69 +26,66 @@
  * List panes on given window.
  */
 
-enum cmd_retval	 cmd_list_panes_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_list_panes_exec(struct cmd *, struct cmdq_item *);
 
-void	cmd_list_panes_server(struct cmd *, struct cmd_q *);
-void	cmd_list_panes_session(
-	    struct cmd *, struct session *, struct cmd_q *, int);
-void	cmd_list_panes_window(struct cmd *,
-	    struct session *, struct winlink *, struct cmd_q *, int);
+static void	cmd_list_panes_server(struct cmd *, struct cmdq_item *);
+static void	cmd_list_panes_session(struct cmd *, struct session *,
+		    struct cmdq_item *, int);
+static void	cmd_list_panes_window(struct cmd *, struct session *,
+		    struct winlink *, struct cmdq_item *, int);
 
 const struct cmd_entry cmd_list_panes_entry = {
-	"list-panes", "lsp",
-	"asF:t:", 0, 0,
-	"[-as] [-F format] " CMD_TARGET_WINDOW_USAGE,
-	0,
-	NULL,
-	cmd_list_panes_exec
+	.name = "list-panes",
+	.alias = "lsp",
+
+	.args = { "asF:t:", 0, 0 },
+	.usage = "[-as] [-F format] " CMD_TARGET_WINDOW_USAGE,
+
+	.target = { 't', CMD_FIND_WINDOW, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_list_panes_exec
 };
 
-enum cmd_retval
-cmd_list_panes_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_panes_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct session	*s;
-	struct winlink	*wl;
+	struct session	*s = item->target.s;
+	struct winlink	*wl = item->target.wl;
 
 	if (args_has(args, 'a'))
-		cmd_list_panes_server(self, cmdq);
-	else if (args_has(args, 's')) {
-		s = cmd_find_session(cmdq, args_get(args, 't'), 0);
-		if (s == NULL)
-			return (CMD_RETURN_ERROR);
-		cmd_list_panes_session(self, s, cmdq, 1);
-	} else {
-		wl = cmd_find_window(cmdq, args_get(args, 't'), &s);
-		if (wl == NULL)
-			return (CMD_RETURN_ERROR);
-		cmd_list_panes_window(self, s, wl, cmdq, 0);
-	}
+		cmd_list_panes_server(self, item);
+	else if (args_has(args, 's'))
+		cmd_list_panes_session(self, s, item, 1);
+	else
+		cmd_list_panes_window(self, s, wl, item, 0);
 
 	return (CMD_RETURN_NORMAL);
 }
 
-void
-cmd_list_panes_server(struct cmd *self, struct cmd_q *cmdq)
+static void
+cmd_list_panes_server(struct cmd *self, struct cmdq_item *item)
 {
 	struct session	*s;
 
 	RB_FOREACH(s, sessions, &sessions)
-		cmd_list_panes_session(self, s, cmdq, 2);
+		cmd_list_panes_session(self, s, item, 2);
 }
 
-void
-cmd_list_panes_session(
-    struct cmd *self, struct session *s, struct cmd_q *cmdq, int type)
+static void
+cmd_list_panes_session(struct cmd *self, struct session *s,
+    struct cmdq_item *item, int type)
 {
 	struct winlink	*wl;
 
 	RB_FOREACH(wl, winlinks, &s->windows)
-		cmd_list_panes_window(self, s, wl, cmdq, type);
+		cmd_list_panes_window(self, s, wl, item, type);
 }
 
-void
-cmd_list_panes_window(struct cmd *self,
-    struct session *s, struct winlink *wl, struct cmd_q *cmdq, int type)
+static void
+cmd_list_panes_window(struct cmd *self, struct session *s, struct winlink *wl,
+    struct cmdq_item *item, int type)
 {
 	struct args		*args = self->args;
 	struct window_pane	*wp;
@@ -116,9 +112,9 @@ cmd_list_panes_window(struct cmd *self,
 			    "#{?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}, "
+			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;
@@ -127,14 +123,12 @@ cmd_list_panes_window(struct cmd *self,
 
 	n = 0;
 	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
-		ft = format_create();
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", n);
-		format_session(ft, s);
-		format_winlink(ft, s, wl);
-		format_window_pane(ft, wp);
+		format_defaults(ft, NULL, s, wl, wp);
 
 		line = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", line);
+		cmdq_print(item, "%s", line);
 		free(line);
 
 		format_free(ft);

cmd-list-sessions.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -28,19 +28,30 @@
  * List all sessions.
  */
 
-enum cmd_retval	 cmd_list_sessions_exec(struct cmd *, struct cmd_q *);
+#define LIST_SESSIONS_TEMPLATE				\
+	"#{session_name}: #{session_windows} windows "	\
+	"(created #{t:session_created}) "		\
+	"[#{session_width}x#{session_height}]"		\
+	"#{?session_grouped, (group ,}"			\
+	"#{session_group}#{?session_grouped,),}"	\
+	"#{?session_attached, (attached),}"
+
+static enum cmd_retval	cmd_list_sessions_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_list_sessions_entry = {
-	"list-sessions", "ls",
-	"F:", 0, 0,
-	"[-F format]",
-	0,
-	NULL,
-	cmd_list_sessions_exec
+	.name = "list-sessions",
+	.alias = "ls",
+
+	.args = { "F:", 0, 0 },
+	.usage = "[-F format]",
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_list_sessions_exec
 };
 
-enum cmd_retval
-cmd_list_sessions_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_sessions_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct session		*s;
@@ -54,12 +65,12 @@ cmd_list_sessions_exec(struct cmd *self, struct cmd_q *cmdq)
 
 	n = 0;
 	RB_FOREACH(s, sessions, &sessions) {
-		ft = format_create();
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", n);
-		format_session(ft, s);
+		format_defaults(ft, NULL, s, NULL, NULL);
 
 		line = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", line);
+		cmdq_print(item, "%s", line);
 		free(line);
 
 		format_free(ft);

cmd-list-windows.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -27,55 +27,66 @@
  * List windows on given session.
  */
 
-enum cmd_retval	 cmd_list_windows_exec(struct cmd *, struct cmd_q *);
+#define LIST_WINDOWS_TEMPLATE					\
+	"#{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}] "
 
-void	cmd_list_windows_server(struct cmd *, struct cmd_q *);
-void	cmd_list_windows_session(
-	    struct cmd *, struct session *, struct cmd_q *, int);
+static enum cmd_retval	cmd_list_windows_exec(struct cmd *, struct cmdq_item *);
+
+static void	cmd_list_windows_server(struct cmd *, struct cmdq_item *);
+static void	cmd_list_windows_session(struct cmd *, struct session *,
+		    struct cmdq_item *, int);
 
 const struct cmd_entry cmd_list_windows_entry = {
-	"list-windows", "lsw",
-	"F:at:", 0, 0,
-	"[-a] [-F format] " CMD_TARGET_SESSION_USAGE,
-	0,
-	NULL,
-	cmd_list_windows_exec
+	.name = "list-windows",
+	.alias = "lsw",
+
+	.args = { "F:at:", 0, 0 },
+	.usage = "[-a] [-F format] " CMD_TARGET_SESSION_USAGE,
+
+	.target = { 't', CMD_FIND_SESSION, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_list_windows_exec
 };
 
-enum cmd_retval
-cmd_list_windows_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_windows_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct session	*s;
 
 	if (args_has(args, 'a'))
-		cmd_list_windows_server(self, cmdq);
-	else {
-		s = cmd_find_session(cmdq, args_get(args, 't'), 0);
-		if (s == NULL)
-			return (CMD_RETURN_ERROR);
-		cmd_list_windows_session(self, s, cmdq, 0);
-	}
+		cmd_list_windows_server(self, item);
+	else
+		cmd_list_windows_session(self, item->target.s, item, 0);
 
 	return (CMD_RETURN_NORMAL);
 }
 
-void
-cmd_list_windows_server(struct cmd *self, struct cmd_q *cmdq)
+static void
+cmd_list_windows_server(struct cmd *self, struct cmdq_item *item)
 {
 	struct session	*s;
 
 	RB_FOREACH(s, sessions, &sessions)
-		cmd_list_windows_session(self, s, cmdq, 1);
+		cmd_list_windows_session(self, s, item, 1);
 }
 
-void
-cmd_list_windows_session(
-    struct cmd *self, struct session *s, struct cmd_q *cmdq, int type)
+static void
+cmd_list_windows_session(struct cmd *self, struct session *s,
+    struct cmdq_item *item, int type)
 {
 	struct args		*args = self->args;
 	struct winlink		*wl;
-	u_int			n;
+	u_int			 n;
 	struct format_tree	*ft;
 	const char		*template;
 	char			*line;
@@ -94,14 +105,12 @@ cmd_list_windows_session(
 
 	n = 0;
 	RB_FOREACH(wl, winlinks, &s->windows) {
-		ft = format_create();
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", n);
-		format_session(ft, s);
-		format_winlink(ft, s, wl);
-		format_window_pane(ft, wl->window->active);
+		format_defaults(ft, NULL, s, wl, NULL);
 
 		line = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", line);
+		cmdq_print(item, "%s", line);
 		free(line);
 
 		format_free(ft);

cmd-list.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -24,7 +24,7 @@
 #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, const char *file, u_int line,
     char **cause)
 {
 	struct cmd_list	*cmdlist;
@@ -99,21 +99,28 @@ cmd_list_free(struct cmd_list *cmdlist)
 	free(cmdlist);
 }
 
-size_t
-cmd_list_print(struct cmd_list *cmdlist, char *buf, size_t len)
+char *
+cmd_list_print(struct cmd_list *cmdlist)
 {
 	struct cmd	*cmd;
-	size_t		 off;
+	char		*buf, *this;
+	size_t		 len;
+
+	len = 1;
+	buf = xcalloc(1, len);
 
-	off = 0;
 	TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
-		if (off >= len)
-			break;
-		off += cmd_print(cmd, buf + off, len - off);
-		if (off >= len)
-			break;
+		this = cmd_print(cmd);
+
+		len += strlen(this) + 3;
+		buf = xrealloc(buf, len);
+
+		strlcat(buf, this, len);
 		if (TAILQ_NEXT(cmd, qentry) != NULL)
-			off += xsnprintf(buf + off, len - off, " ; ");
+			strlcat(buf, " ; ", len);
+
+		free(this);
 	}
-	return (off);
+
+	return (buf);
 }

cmd-load-buffer.c

@@ -1,4 +1,4 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -31,70 +31,66 @@
  * Loads a paste buffer from a file.
  */
 
-enum cmd_retval	 cmd_load_buffer_exec(struct cmd *, struct cmd_q *);
-void		 cmd_load_buffer_callback(struct client *, int, void *);
+static enum cmd_retval	cmd_load_buffer_exec(struct cmd *, struct cmdq_item *);
+
+static void		cmd_load_buffer_callback(struct client *, int, void *);
 
 const struct cmd_entry cmd_load_buffer_entry = {
-	"load-buffer", "loadb",
-	"b:", 1, 1,
-	CMD_BUFFER_USAGE " path",
-	0,
-	NULL,
-	cmd_load_buffer_exec
+	.name = "load-buffer",
+	.alias = "loadb",
+
+	.args = { "b:", 1, 1 },
+	.usage = CMD_BUFFER_USAGE " path",
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_load_buffer_exec
 };
 
-enum cmd_retval
-cmd_load_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args	*args = self->args;
-	struct client	*c = cmdq->client;
-	struct session  *s;
-	FILE		*f;
-	const char	*path;
-	char		*pdata, *new_pdata, *cause;
-	size_t		 psize;
-	u_int		 limit;
-	int		 ch, error, buffer, *buffer_ptr, cwd, fd;
+struct cmd_load_buffer_data {
+	struct cmdq_item	*item;
+	char			*bufname;
+};
 
-	if (!args_has(args, 'b'))
-		buffer = -1;
-	else {
-		buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
-		if (cause != NULL) {
-			cmdq_error(cmdq, "buffer %s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-	}
+static enum cmd_retval
+cmd_load_buffer_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args			*args = self->args;
+	struct cmd_load_buffer_data	*cdata;
+	struct client			*c = item->client;
+	FILE				*f;
+	const char			*path, *bufname;
+	char				*pdata = NULL, *new_pdata, *cause;
+	char				*file;
+	size_t				 psize;
+	int				 ch, error;
+
+	bufname = NULL;
+	if (args_has(args, 'b'))
+		bufname = args_get(args, 'b');
 
 	path = args->argv[0];
 	if (strcmp(path, "-") == 0) {
-		buffer_ptr = xmalloc(sizeof *buffer_ptr);
-		*buffer_ptr = buffer;
+		cdata = xcalloc(1, sizeof *cdata);
+		cdata->item = item;
+
+		if (bufname != NULL)
+			cdata->bufname = xstrdup(bufname);
 
 		error = server_set_stdin_callback(c, cmd_load_buffer_callback,
-		    buffer_ptr, &cause);
+		    cdata, &cause);
 		if (error != 0) {
-			cmdq_error(cmdq, "%s: %s", path, cause);
+			cmdq_error(item, "%s: %s", path, cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
 		return (CMD_RETURN_WAIT);
 	}
 
-	if (c != NULL && c->session == NULL)
-		cwd = c->cwd;
-	else if ((s = cmd_current_session(cmdq, 0)) != NULL)
-		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);
+	file = server_client_get_path(c, path);
+	f = fopen(file, "rb");
+	if (f == NULL) {
+		cmdq_error(item, "%s: %s", file, strerror(errno));
+		goto error;
 	}
 
 	pdata = NULL;
@@ -102,29 +98,26 @@ 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));
+			cmdq_error(item, "realloc error: %s", strerror(errno));
 			goto error;
 		}
 		pdata = new_pdata;
 		pdata[psize++] = ch;
 	}
 	if (ferror(f)) {
-		cmdq_error(cmdq, "%s: read error", path);
+		cmdq_error(item, "%s: read error", file);
 		goto error;
 	}
 	if (pdata != NULL)
 		pdata[psize] = '\0';
 
 	fclose(f);
+	free(file);
 
-	limit = options_get_number(&global_options, "buffer-limit");
-	if (buffer == -1) {
-		paste_add(&global_buffers, pdata, psize, limit);
-		return (CMD_RETURN_NORMAL);
-	}
-	if (paste_replace(&global_buffers, buffer, pdata, psize) != 0) {
-		cmdq_error(cmdq, "no buffer %d", buffer);
+	if (paste_set(pdata, psize, bufname, &cause) != 0) {
+		cmdq_error(item, "%s", cause);
 		free(pdata);
+		free(cause);
 		return (CMD_RETURN_ERROR);
 	}
 
@@ -134,46 +127,48 @@ error:
 	free(pdata);
 	if (f != NULL)
 		fclose(f);
+	free(file);
 	return (CMD_RETURN_ERROR);
 }
 
-void
+static void
 cmd_load_buffer_callback(struct client *c, int closed, void *data)
 {
-	int	*buffer = data;
-	char	*pdata;
-	size_t	 psize;
-	u_int	 limit;
+	struct cmd_load_buffer_data	*cdata = data;
+	char				*pdata, *cause, *saved;
+	size_t				 psize;
 
 	if (!closed)
 		return;
 	c->stdin_callback = NULL;
 
-	c->references--;
+	server_client_unref(c);
 	if (c->flags & CLIENT_DEAD)
-		return;
+		goto out;
 
 	psize = EVBUFFER_LENGTH(c->stdin_data);
-	if (psize == 0 || (pdata = malloc(psize + 1)) == NULL) {
-		free(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);
 
-	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) {
+	if (paste_set(pdata, psize, cdata->bufname, &cause) != 0) {
 		/* No context so can't use server_client_msg_error. */
-		evbuffer_add_printf(c->stderr_data, "no buffer %d\n", *buffer);
-		server_push_stderr(c);
+		if (~c->flags & CLIENT_UTF8) {
+			saved = cause;
+			cause = utf8_sanitize(saved);
+			free(saved);
+		}
+		evbuffer_add_printf(c->stderr_data, "%s", cause);
+		server_client_push_stderr(c);
 		free(pdata);
+		free(cause);
 	}
-
-	free(data);
-
 out:
-	cmdq_continue(c->cmdq);
+	cdata->item->flags &= ~CMDQ_WAITING;
+
+	free(cdata->bufname);
+	free(cdata);
 }

cmd-lock-server.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@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
@@ -18,62 +18,61 @@
 
 #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 *);
+static enum cmd_retval	cmd_lock_server_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_lock_server_entry = {
-	"lock-server", "lock",
-	"", 0, 0,
-	"",
-	0,
-	NULL,
-	cmd_lock_server_exec
+	.name = "lock-server",
+	.alias = "lock",
+
+	.args = { "", 0, 0 },
+	.usage = "",
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_lock_server_exec
 };
 
 const struct cmd_entry cmd_lock_session_entry = {
-	"lock-session", "locks",
-	"t:", 0, 0,
-	CMD_TARGET_SESSION_USAGE,
-	0,
-	NULL,
-	cmd_lock_server_exec
+	.name = "lock-session",
+	.alias = "locks",
+
+	.args = { "t:", 0, 0 },
+	.usage = CMD_TARGET_SESSION_USAGE,
+
+	.target = { 't', CMD_FIND_SESSION, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_lock_server_exec
 };
 
 const struct cmd_entry cmd_lock_client_entry = {
-	"lock-client", "lockc",
-	"t:", 0, 0,
-	CMD_TARGET_CLIENT_USAGE,
-	0,
-	NULL,
-	cmd_lock_server_exec
+	.name = "lock-client",
+	.alias = "lockc",
+
+	.args = { "t:", 0, 0 },
+	.usage = CMD_TARGET_CLIENT_USAGE,
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_lock_server_exec
 };
 
-enum cmd_retval
-cmd_lock_server_exec(struct cmd *self, unused struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_lock_server_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
 	struct client	*c;
-	struct session	*s;
 
 	if (self->entry == &cmd_lock_server_entry)
 		server_lock();
-	else if (self->entry == &cmd_lock_session_entry) {
-		s = cmd_find_session(cmdq, args_get(args, 't'), 0);
-		if (s == NULL)
-			return (CMD_RETURN_ERROR);
-		server_lock_session(s);
-	} else {
-		c = cmd_find_client(cmdq, args_get(args, 't'), 0);
-		if (c == NULL)
+	else if (self->entry == &cmd_lock_session_entry)
+		server_lock_session(item->target.s);
+	else {
+		if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
 			return (CMD_RETURN_ERROR);
 		server_lock_client(c);
 	}

cmd-move-window.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@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
@@ -26,49 +26,92 @@
  * Move a window.
  */
 
-enum cmd_retval	 cmd_move_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_move_window_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_move_window_entry = {
-	"move-window", "movew",
-	"dkrs:t:", 0, 0,
-	"[-dkr] " CMD_SRCDST_WINDOW_USAGE,
-	0,
-	NULL,
-	cmd_move_window_exec
+	.name = "move-window",
+	.alias = "movew",
+
+	.args = { "adkrs:t:", 0, 0 },
+	.usage = "[-dkr] " CMD_SRCDST_WINDOW_USAGE,
+
+	.source = { 's', CMD_FIND_WINDOW, 0 },
+	/* -t is special */
+
+	.flags = 0,
+	.exec = cmd_move_window_exec
 };
 
-enum cmd_retval
-cmd_move_window_exec(struct cmd *self, struct cmd_q *cmdq)
+const struct cmd_entry cmd_link_window_entry = {
+	.name = "link-window",
+	.alias = "linkw",
+
+	.args = { "adks:t:", 0, 0 },
+	.usage = "[-dk] " CMD_SRCDST_WINDOW_USAGE,
+
+	.source = { 's', CMD_FIND_WINDOW, 0 },
+	/* -t is special */
+
+	.flags = 0,
+	.exec = cmd_move_window_exec
+};
+
+static enum cmd_retval
+cmd_move_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct session	*src, *dst, *s;
+	const char	*tflag = args_get(args, 't');
+	struct session	*src;
+	struct session	*dst;
 	struct winlink	*wl;
 	char		*cause;
-	int		 idx, kflag, dflag;
+	int		 idx, kflag, dflag, sflag;
 
 	if (args_has(args, 'r')) {
-		if ((s = cmd_find_session(cmdq, args_get(args, 't'), 0)) == NULL)
+		if (cmd_find_target(&item->target, item, tflag,
+		    CMD_FIND_SESSION, CMD_FIND_QUIET) != 0)
 			return (CMD_RETURN_ERROR);
 
-		session_renumber_windows(s);
+		session_renumber_windows(item->target.s);
 		recalculate_sizes();
+		server_status_session(item->target.s);
 
 		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)
+	if (cmd_find_target(&item->target, item, tflag, CMD_FIND_WINDOW,
+	    CMD_FIND_WINDOW_INDEX) != 0)
 		return (CMD_RETURN_ERROR);
+	src = item->source.s;
+	dst = item->target.s;
+	wl = item->source.wl;
+	idx = item->target.idx;
 
 	kflag = args_has(self->args, 'k');
 	dflag = args_has(self->args, 'd');
-	if (server_link_window(src, wl, dst, idx, kflag, !dflag, &cause) != 0) {
-		cmdq_error(cmdq, "can't move window: %s", cause);
+	sflag = args_has(self->args, 's');
+
+	if (args_has(self->args, 'a')) {
+		if ((idx = winlink_shuffle_up(dst, dst->curw)) == -1)
+			return (CMD_RETURN_ERROR);
+	}
+
+	if (server_link_window(src, wl, dst, idx, kflag, !dflag,
+	    &cause) != 0) {
+		cmdq_error(item, "can't link window: %s", cause);
 		free(cause);
 		return (CMD_RETURN_ERROR);
 	}
-	server_unlink_window(src, wl);
+	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);

cmd-new-session.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -20,7 +20,6 @@
 
 #include <errno.h>
 #include <fcntl.h>
-#include <pwd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <termios.h>
@@ -32,67 +31,122 @@
  * Create a new session and attach to the current terminal unless -d is given.
  */
 
-enum cmd_retval	 cmd_new_session_exec(struct cmd *, struct cmd_q *);
+#define NEW_SESSION_TEMPLATE "#{session_name}:"
+
+static enum cmd_retval	cmd_new_session_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_new_session_entry = {
-	"new-session", "new",
-	"Ac:dDF:n:Ps:t:x:y:", 0, 1,
-	"[-AdDP] [-c start-directory] [-F format] [-n window-name] "
-	"[-s session-name] " CMD_TARGET_SESSION_USAGE " [-x width] [-y height] "
-	"[command]",
-	CMD_STARTSERVER|CMD_CANTNEST,
-	NULL,
-	cmd_new_session_exec
+	.name = "new-session",
+	.alias = "new",
+
+	.args = { "Ac:dDEF:n:Ps:t:x:y:", 0, -1 },
+	.usage = "[-AdDEP] [-c start-directory] [-F format] [-n window-name] "
+		 "[-s session-name] " CMD_TARGET_SESSION_USAGE " [-x width] "
+		 "[-y height] [command]",
+
+	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
+
+	.flags = CMD_STARTSERVER,
+	.exec = cmd_new_session_exec
 };
 
-enum cmd_retval
-cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
+const struct cmd_entry cmd_has_session_entry = {
+	.name = "has-session",
+	.alias = "has",
+
+	.args = { "t:", 0, 0 },
+	.usage = CMD_TARGET_SESSION_USAGE,
+
+	.target = { 't', CMD_FIND_SESSION, 0 },
+
+	.flags = 0,
+	.exec = cmd_new_session_exec
+};
+
+static enum cmd_retval
+cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->client, *c0;
-	struct session		*s, *groupwith;
+	struct client		*c = item->client;
+	struct session		*s, *as, *groupwith;
 	struct window		*w;
-	struct environ		 env;
+	struct environ		*env;
 	struct termios		 tio, *tiop;
-	const char		*newname, *target, *update, *errstr, *template;
-	char			*cmd, *cause, *cp;
-	int			 detached, already_attached, idx, cwd, fd = -1;
+	struct session_group	*sg;
+	const char		*errstr, *template, *group, *prefix;
+	const char		*path, *cmd, *tmp;
+	char		       **argv, *cause, *cp, *newname, *cwd = NULL;
+	int			 detached, already_attached, idx, argc;
+	int			 is_control = 0;
 	u_int			 sx, sy;
-	struct format_tree	*ft;
+	struct environ_entry	*envent;
+	struct cmd_find_state	 fs;
+	enum cmd_retval		 retval;
+
+	if (self->entry == &cmd_has_session_entry) {
+		/*
+		 * cmd_find_target() will fail if the session cannot be found,
+		 * so always return success here.
+		 */
+		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");
+		cmdq_error(item, "command or window name given with target");
 		return (CMD_RETURN_ERROR);
 	}
 
-	newname = args_get(args, 's');
-	if (newname != NULL) {
+	newname = NULL;
+	if (args_has(args, 's')) {
+		newname = format_single(item, args_get(args, 's'), c, NULL,
+		    NULL, NULL);
 		if (!session_check_name(newname)) {
-			cmdq_error(cmdq, "bad session name: %s", newname);
-			return (CMD_RETURN_ERROR);
+			cmdq_error(item, "bad session name: %s", newname);
+			goto error;
 		}
-		if (session_find(newname) != NULL) {
+		if ((as = session_find(newname)) != NULL) {
 			if (args_has(args, 'A')) {
-				return (cmd_attach_session(cmdq, newname,
-				    args_has(args, 'D'), 0, NULL));
+				retval = cmd_attach_session(item,
+				    newname, args_has(args, 'D'),
+				    0, NULL, args_has(args, 'E'));
+				free(newname);
+				return (retval);
 			}
-			cmdq_error(cmdq, "duplicate session: %s", newname);
-			return (CMD_RETURN_ERROR);
+			cmdq_error(item, "duplicate session: %s", newname);
+			goto error;
 		}
 	}
 
-	target = args_get(args, 't');
-	if (target != NULL) {
-		groupwith = cmd_find_session(cmdq, target, 0);
-		if (groupwith == NULL)
-			return (CMD_RETURN_ERROR);
-	} else
+	/* Is this going to be part of a session group? */
+	group = args_get(args, 't');
+	if (group != NULL) {
+		groupwith = item->target.s;
+		if (groupwith == NULL) {
+			if (!session_check_name(group)) {
+				cmdq_error(item, "bad group name: %s", group);
+				goto error;
+			}
+			sg = session_group_find(group);
+		} else
+			sg = session_group_contains(groupwith);
+		if (sg != NULL)
+			prefix = sg->name;
+		else if (groupwith != NULL)
+			prefix = groupwith->name;
+		else
+			prefix = group;
+	} else {
 		groupwith = NULL;
+		sg = NULL;
+		prefix = NULL;
+	}
 
 	/* Set -d if no client. */
 	detached = args_has(args, 'd');
 	if (c == NULL)
 		detached = 1;
+	else if (c->flags & CLIENT_CONTROL)
+		is_control = 1;
 
 	/* Is this client already attached? */
 	already_attached = 0;
@@ -100,43 +154,28 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 		already_attached = 1;
 
 	/* Get the new session working directory. */
-	if (args_has(args, 'c')) {
-		ft = format_create();
-		if ((c0 = cmd_find_client(cmdq, NULL, 1)) != NULL)
-			format_client(ft, c0);
-		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_current_client(cmdq)) != NULL)
-		cwd = c0->session->cwd;
-	else {
-		fd = open(".", O_RDONLY);
-		cwd = fd;
-	}
+	if ((tmp = args_get(args, 'c')) != NULL)
+		cwd = format_single(item, tmp, c, NULL, NULL, NULL);
+	else if (c != NULL && c->session == NULL && c->cwd != NULL)
+		cwd = xstrdup(c->cwd);
+	else
+		cwd = xstrdup(".");
 
 	/*
-	 * Save the termios settings, part of which is used for new windows in
-	 * this session.
+	 * If this is a new client, check for nesting and save the termios
+	 * settings (part of which is used for new windows in this session).
 	 *
-	 * This is read again with tcgetattr() rather than using tty.tio as if
-	 * detached, tty_open won't be called. Because of this, it must be done
-	 * before opening the terminal as that calls tcsetattr() to prepare for
-	 * tmux taking over.
+	 * tcgetattr() is used rather than using tty.tio since if the client is
+	 * detached, tty_open won't be called. It must be done before opening
+	 * the terminal as that calls tcsetattr() to prepare for tmux taking
+	 * over.
 	 */
 	if (!detached && !already_attached && c->tty.fd != -1) {
+		if (server_client_check_nested(item->client)) {
+			cmdq_error(item, "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;
@@ -145,95 +184,129 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 
 	/* Open the terminal if necessary. */
 	if (!detached && !already_attached) {
-		if (server_client_open(c, NULL, &cause) != 0) {
-			cmdq_error(cmdq, "open terminal failed: %s", cause);
+		if (server_client_open(c, &cause) != 0) {
+			cmdq_error(item, "open terminal failed: %s", cause);
 			free(cause);
 			goto error;
 		}
 	}
 
 	/* Find new session size. */
-	if (c != NULL) {
+	if (!detached) {
 		sx = c->tty.sx;
 		sy = c->tty.sy;
+		if (!is_control &&
+		    sy > 0 &&
+		    options_get_number(global_s_options, "status"))
+			sy--;
 	} else {
 		sx = 80;
 		sy = 24;
 	}
-	if (detached && args_has(args, 'x')) {
+	if ((is_control || detached) && args_has(args, 'x')) {
 		sx = strtonum(args_get(args, 'x'), 1, USHRT_MAX, &errstr);
 		if (errstr != NULL) {
-			cmdq_error(cmdq, "width %s", errstr);
+			cmdq_error(item, "width %s", errstr);
 			goto error;
 		}
 	}
-	if (detached && args_has(args, 'y')) {
+	if ((is_control || detached) && args_has(args, 'y')) {
 		sy = strtonum(args_get(args, 'y'), 1, USHRT_MAX, &errstr);
 		if (errstr != NULL) {
-			cmdq_error(cmdq, "height %s", errstr);
+			cmdq_error(item, "height %s", errstr);
 			goto error;
 		}
 	}
-	if (sy > 0 && options_get_number(&global_s_options, "status"))
-		sy--;
 	if (sx == 0)
 		sx = 1;
 	if (sy == 0)
 		sy = 1;
 
 	/* Figure out the command for the new window. */
-	if (target != NULL)
-		cmd = NULL;
-	else if (args->argc != 0)
-		cmd = args->argv[0];
+	argc = -1;
+	argv = NULL;
+	if (!args_has(args, 't') && args->argc != 0) {
+		argc = args->argc;
+		argv = args->argv;
+	} else if (sg == NULL && groupwith == NULL) {
+		cmd = options_get_string(global_s_options, "default-command");
+		if (cmd != NULL && *cmd != '\0') {
+			argc = 1;
+			argv = (char **)&cmd;
+		} else {
+			argc = 0;
+			argv = NULL;
+		}
+	}
+
+	path = NULL;
+	if (c != NULL && c->session == NULL)
+		envent = environ_find(c->environ, "PATH");
 	else
-		cmd = options_get_string(&global_s_options, "default-command");
+		envent = environ_find(global_environ, "PATH");
+	if (envent != NULL)
+		path = envent->value;
 
 	/* Construct the environment. */
-	environ_init(&env);
-	update = options_get_string(&global_s_options, "update-environment");
-	if (c != NULL)
-		environ_update(update, &c->environ, &env);
+	env = environ_create();
+	if (c != NULL && !args_has(args, 'E'))
+		environ_update(global_s_options, c->environ, env);
 
 	/* Create the new session. */
-	idx = -1 - options_get_number(&global_s_options, "base-index");
-	s = session_create(newname, cmd, cwd, &env, tiop, idx, sx, sy, &cause);
+	idx = -1 - options_get_number(global_s_options, "base-index");
+	s = session_create(prefix, newname, argc, argv, path, cwd, env, tiop,
+	    idx, sx, sy, &cause);
+	environ_free(env);
 	if (s == NULL) {
-		cmdq_error(cmdq, "create session failed: %s", cause);
+		cmdq_error(item, "create session failed: %s", cause);
 		free(cause);
 		goto error;
 	}
-	environ_free(&env);
 
 	/* Set the initial window name if one given. */
-	if (cmd != NULL && args_has(args, 'n')) {
+	if (argc >= 0 && (tmp = args_get(args, 'n')) != NULL) {
+		cp = format_single(item, tmp, c, s, NULL, NULL);
 		w = s->curw->window;
-		window_set_name(w, args_get(args, 'n'));
-		options_set_number(&w->options, "automatic-rename", 0);
+		window_set_name(w, cp);
+		options_set_number(w->options, "automatic-rename", 0);
+		free(cp);
 	}
 
 	/*
 	 * If a target session is given, this is to be part of a session group,
 	 * so add it to the group and synchronize.
 	 */
-	if (groupwith != NULL) {
-		session_group_add(groupwith, s);
+	if (group != NULL) {
+		if (sg == NULL) {
+			if (groupwith != NULL) {
+				sg = session_group_new(groupwith->name);
+				session_group_add(sg, groupwith);
+			} else
+				sg = session_group_new(group);
+		}
+		session_group_add(sg, s);
 		session_group_synchronize_to(s);
-		session_select(s, RB_ROOT(&s->windows)->idx);
+		session_select(s, RB_MIN(winlinks, &s->windows)->idx);
 	}
+	notify_session("session-created", s);
 
 	/*
 	 * Set the client to the new session. If a command client exists, it is
 	 * taking this session and needs to get MSG_READY and stay around.
 	 */
 	if (!detached) {
-		if (!already_attached)
-			server_write_ready(c);
-		else if (c->session != NULL)
+		if (!already_attached) {
+			if (~c->flags & CLIENT_CONTROL)
+				proc_send(c->peer, MSG_READY, -1, NULL, 0);
+		} else if (c->session != NULL)
 			c->last_session = c->session;
 		c->session = s;
-		notify_attached_session_changed(c);
-		session_update_activity(s);
+		if (~item->shared->flags & CMDQ_SHARED_REPEAT)
+			server_client_set_key_table(c, NULL);
+		status_timer_start(c);
+		notify_client("client-session-changed", c);
+		session_update_activity(s, NULL);
+		gettimeofday(&s->last_attached_time, NULL);
 		server_redraw_client(c);
 	}
 	recalculate_sizes();
@@ -250,28 +323,25 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = NEW_SESSION_TEMPLATE;
-
-		ft = format_create();
-		if ((c0 = cmd_find_client(cmdq, NULL, 1)) != NULL)
-			format_client(ft, c0);
-		format_session(ft, s);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
+		cp = format_single(item, template, c, s, NULL, NULL);
+		cmdq_print(item, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}
 
-	if (!detached)
-		cmdq->client_exit = 0;
+	if (!detached) {
+		c->flags |= CLIENT_ATTACHED;
+		cmd_find_from_session(&item->shared->current, s, 0);
+	}
 
-	if (fd != -1)
-		close(fd);
+	cmd_find_from_session(&fs, s, 0);
+	hooks_insert(s->hooks, item, &fs, "after-new-session");
+
+	free(cwd);
+	free(newname);
 	return (CMD_RETURN_NORMAL);
 
 error:
-	if (fd != -1)
-		close(fd);
+	free(cwd);
+	free(newname);
 	return (CMD_RETURN_ERROR);
 }

cmd-new-window.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -30,88 +30,80 @@
  * Create a new window.
  */
 
-enum cmd_retval	cmd_new_window_exec(struct cmd *, struct cmd_q *);
+#define NEW_WINDOW_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"
+
+static enum cmd_retval	cmd_new_window_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_new_window_entry = {
-	"new-window", "neww",
-	"ac:dF:kn:Pt:", 0, 1,
-	"[-adkP] [-c start-directory] [-F format] [-n window-name] "
-	CMD_TARGET_WINDOW_USAGE " [command]",
-	0,
-	NULL,
-	cmd_new_window_exec
+	.name = "new-window",
+	.alias = "neww",
+
+	.args = { "ac:dF:kn:Pt:", 0, -1 },
+	.usage = "[-adkP] [-c start-directory] [-F format] [-n window-name] "
+		 CMD_TARGET_WINDOW_USAGE " [command]",
+
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_WINDOW_INDEX },
+
+	.flags = 0,
+	.exec = cmd_new_window_exec
 };
 
-enum cmd_retval
-cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct session		*s;
-	struct winlink		*wl;
-	struct client		*c;
-	const char		*cmd, *template;
-	char			*cause, *cp;
-	int			 idx, last, detached, cwd, fd = -1;
-	struct format_tree	*ft;
+	struct cmd_find_state	*current = &item->shared->current;
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	int			 idx = item->target.idx;
+	const char		*cmd, *path, *template, *tmp;
+	char		       **argv, *cause, *cp, *cwd, *name;
+	int			 argc, detached;
+	struct environ_entry	*envent;
+	struct cmd_find_state	 fs;
 
 	if (args_has(args, 'a')) {
-		wl = cmd_find_window(cmdq, args_get(args, 't'), &s);
-		if (wl == NULL)
-			return (CMD_RETURN_ERROR);
-		idx = wl->idx + 1;
-
-		/* 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) {
-			cmdq_error(cmdq, "no free window indexes");
+		if ((idx = winlink_shuffle_up(s, wl)) == -1) {
+			cmdq_error(item, "no free window indexes");
 			return (CMD_RETURN_ERROR);
 		}
-
-		/* Move everything from last - 1 to idx up a bit. */
-		for (; last > idx; last--) {
-			wl = winlink_find_by_index(&s->windows, last - 1);
-			server_link_window(s, wl, s, last, 0, 0, NULL);
-			server_unlink_window(s, wl);
-		}
-	} else {
-		if ((idx = cmd_find_index(cmdq, args_get(args, 't'), &s)) == -2)
-			return (CMD_RETURN_ERROR);
 	}
 	detached = args_has(args, 'd');
 
-	if (args->argc == 0)
-		cmd = options_get_string(&s->options, "default-command");
-	else
-		cmd = args->argv[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();
-		if ((c = cmd_find_client(cmdq, NULL, 1)) != NULL)
-			format_client(ft, c);
-		format_session(ft, s);
-		format_winlink(ft, s, s->curw);
-		format_window_pane(ft, s->curw->window->active);
-		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;
+	path = NULL;
+	if (item->client != NULL && item->client->session == NULL)
+		envent = environ_find(item->client->environ, "PATH");
 	else
-		cwd = s->cwd;
+		envent = environ_find(s->environ, "PATH");
+	if (envent != NULL)
+		path = envent->value;
+
+	if ((tmp = args_get(args, 'c')) != NULL)
+		cwd = format_single(item, tmp, c, s, NULL, NULL);
+	else if (item->client != NULL && item->client->session == NULL)
+		cwd = xstrdup(item->client->cwd);
+	else
+		cwd = xstrdup(s->cwd);
+
+	if ((tmp = args_get(args, 'n')) != NULL)
+		name = format_single(item, tmp, c, s, NULL, NULL);
+	else
+		name = NULL;
 
 	wl = NULL;
 	if (idx != -1)
@@ -121,7 +113,7 @@ 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);
+		notify_session_window("window-unlinked", s, wl->window);
 		wl->flags &= ~WINLINK_ALERTFLAGS;
 		winlink_stack_remove(&s->lastw, wl);
 		winlink_remove(&s->windows, wl);
@@ -134,15 +126,17 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	}
 
 	if (idx == -1)
-		idx = -1 - options_get_number(&s->options, "base-index");
-	wl = session_new(s, args_get(args, 'n'), cmd, cwd, idx, &cause);
+		idx = -1 - options_get_number(s->options, "base-index");
+	wl = session_new(s, name, argc, argv, path, cwd, idx,
+		&cause);
 	if (wl == NULL) {
-		cmdq_error(cmdq, "create window failed: %s", cause);
+		cmdq_error(item, "create window failed: %s", cause);
 		free(cause);
 		goto error;
 	}
 	if (!detached) {
 		session_select(s, wl->idx);
+		cmd_find_from_winlink(current, wl, 0);
 		server_redraw_session_group(s);
 	} else
 		server_status_session_group(s);
@@ -150,27 +144,20 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = NEW_WINDOW_TEMPLATE;
-
-		ft = format_create();
-		if ((c = cmd_find_client(cmdq, NULL, 1)) != NULL)
-			format_client(ft, c);
-		format_session(ft, s);
-		format_winlink(ft, s, wl);
-		format_window_pane(ft, wl->window->active);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
+		cp = format_single(item, template, c, s, wl, NULL);
+		cmdq_print(item, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}
 
-	if (fd != -1)
-		close(fd);
+	cmd_find_from_winlink(&fs, wl, 0);
+	hooks_insert(s->hooks, item, &fs, "after-new-window");
+
+	free(name);
+	free(cwd);
 	return (CMD_RETURN_NORMAL);
 
 error:
-	if (fd != -1)
-		close(fd);
+	free(name);
+	free(cwd);
 	return (CMD_RETURN_ERROR);
 }

cmd-paste-buffer.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -27,57 +27,47 @@
  * Paste paste buffer if present.
  */
 
-enum cmd_retval	 cmd_paste_buffer_exec(struct cmd *, struct cmd_q *);
-
-void	cmd_paste_buffer_filter(struct window_pane *,
-	    const char *, size_t, const char *, int);
+static enum cmd_retval	cmd_paste_buffer_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_paste_buffer_entry = {
-	"paste-buffer", "pasteb",
-	"db:prs:t:", 0, 0,
-	"[-dpr] [-s separator] [-b buffer-index] " CMD_TARGET_PANE_USAGE,
-	0,
-	NULL,
-	cmd_paste_buffer_exec
+	.name = "paste-buffer",
+	.alias = "pasteb",
+
+	.args = { "db:prs:t:", 0, 0 },
+	.usage = "[-dpr] [-s separator] " CMD_BUFFER_USAGE " "
+		 CMD_TARGET_PANE_USAGE,
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_paste_buffer_exec
 };
 
-enum cmd_retval
-cmd_paste_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_paste_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct window_pane	*wp;
-	struct session		*s;
+	struct window_pane	*wp = item->target.wp;
 	struct paste_buffer	*pb;
-	const char		*sepstr;
-	char			*cause;
-	int			 buffer;
-	int			 pflag;
+	const char		*sepstr, *bufname, *bufdata, *bufend, *line;
+	size_t			 seplen, bufsize;
+	int			 bracket = args_has(args, 'p');
 
-	if (cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp) == NULL)
-		return (CMD_RETURN_ERROR);
+	bufname = NULL;
+	if (args_has(args, 'b'))
+		bufname = args_get(args, 'b');
 
-	if (!args_has(args, 'b'))
-		buffer = -1;
+	if (bufname == NULL)
+		pb = paste_get_top(NULL);
 	else {
-		buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
-		if (cause != NULL) {
-			cmdq_error(cmdq, "buffer %s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-	}
-
-	if (buffer == -1)
-		pb = paste_get_top(&global_buffers);
-	else {
-		pb = paste_get_index(&global_buffers, buffer);
+		pb = paste_get_name(bufname);
 		if (pb == NULL) {
-			cmdq_error(cmdq, "no buffer %d", buffer);
+			cmdq_error(item, "no buffer %s", bufname);
 			return (CMD_RETURN_ERROR);
 		}
 	}
 
-	if (pb != NULL) {
+	if (pb != NULL && ~wp->flags & PANE_INPUTOFF) {
 		sepstr = args_get(args, 's');
 		if (sepstr == NULL) {
 			if (args_has(args, 'r'))
@@ -85,17 +75,33 @@ cmd_paste_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 			else
 				sepstr = "\r";
 		}
-		pflag = (wp->screen->mode & MODE_BRACKETPASTE);
-		paste_send_pane(pb, wp, sepstr, args_has(args, 'p') && pflag);
+		seplen = strlen(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);
 	}
 
-	/* Delete the buffer if -d. */
-	if (args_has(args, 'd')) {
-		if (buffer == -1)
-			paste_free_top(&global_buffers);
-		else
-			paste_free_index(&global_buffers, buffer);
-	}
+	if (pb != NULL && args_has(args, 'd'))
+		paste_free(pb);
 
 	return (CMD_RETURN_NORMAL);
 }

cmd-pipe-pane.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -21,6 +21,8 @@
 
 #include <errno.h>
 #include <fcntl.h>
+#include <signal.h>
+#include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
@@ -31,31 +33,37 @@
  * Open pipe to redirect pane output. If already open, close first.
  */
 
-enum cmd_retval	 cmd_pipe_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_pipe_pane_exec(struct cmd *, struct cmdq_item *);
 
-void	cmd_pipe_pane_error_callback(struct bufferevent *, short, void *);
+static void cmd_pipe_pane_read_callback(struct bufferevent *, void *);
+static void cmd_pipe_pane_write_callback(struct bufferevent *, void *);
+static 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]",
-	0,
-	NULL,
-	cmd_pipe_pane_exec
+	.name = "pipe-pane",
+	.alias = "pipep",
+
+	.args = { "IOot:", 0, 1 },
+	.usage = "[-IOo] " CMD_TARGET_PANE_USAGE " [command]",
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_pipe_pane_exec
 };
 
-enum cmd_retval
-cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c;
-	struct window_pane	*wp;
-	char			*command;
-	int			 old_fd, pipe_fd[2], null_fd;
-
-	if (cmd_find_pane(cmdq, args_get(args, 't'), NULL, &wp) == NULL)
-		return (CMD_RETURN_ERROR);
-	c = cmd_find_client(cmdq, NULL, 1);
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct window_pane	*wp = item->target.wp;
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	char			*cmd;
+	int			 old_fd, pipe_fd[2], null_fd, in, out;
+	struct format_tree	*ft;
+	sigset_t		 set, oldset;
 
 	/* Destroy the old pipe. */
 	old_fd = wp->pipe_fd;
@@ -63,6 +71,11 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 		bufferevent_free(wp->pipe_event);
 		close(wp->pipe_fd);
 		wp->pipe_fd = -1;
+
+		if (window_pane_destroy_ready(wp)) {
+			server_destroy_pane(wp, 1);
+			return (CMD_RETURN_NORMAL);
+		}
 	}
 
 	/* If no pipe command, that is enough. */
@@ -78,64 +91,130 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(self->args, 'o') && old_fd != -1)
 		return (CMD_RETURN_NORMAL);
 
+	/* What do we want to do? Neither -I or -O is -O. */
+	if (args_has(self->args, 'I')) {
+		in = 1;
+		out = args_has(self->args, 'O');
+	} else {
+		in = 0;
+		out = 1;
+	}
+
 	/* Open the new pipe. */
 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pipe_fd) != 0) {
-		cmdq_error(cmdq, "socketpair error: %s", strerror(errno));
+		cmdq_error(item, "socketpair error: %s", strerror(errno));
 		return (CMD_RETURN_ERROR);
 	}
 
+	/* Expand the command. */
+	ft = format_create(item->client, item, FORMAT_NONE, 0);
+	format_defaults(ft, c, s, wl, wp);
+	cmd = format_expand_time(ft, args->argv[0], time(NULL));
+	format_free(ft);
+
 	/* Fork the child. */
+	sigfillset(&set);
+	sigprocmask(SIG_BLOCK, &set, &oldset);
 	switch (fork()) {
 	case -1:
-		cmdq_error(cmdq, "fork error: %s", strerror(errno));
+		sigprocmask(SIG_SETMASK, &oldset, NULL);
+		cmdq_error(item, "fork error: %s", strerror(errno));
+
+		free(cmd);
 		return (CMD_RETURN_ERROR);
 	case 0:
 		/* Child process. */
+		proc_clear_signals(server_proc, 1);
+		sigprocmask(SIG_SETMASK, &oldset, NULL);
 		close(pipe_fd[0]);
-		clear_signals(1);
-
-		if (dup2(pipe_fd[1], STDIN_FILENO) == -1)
-			_exit(1);
-		if (pipe_fd[1] != STDIN_FILENO)
-			close(pipe_fd[1]);
 
 		null_fd = open(_PATH_DEVNULL, O_WRONLY, 0);
-		if (dup2(null_fd, STDOUT_FILENO) == -1)
-			_exit(1);
+		if (out) {
+			if (dup2(pipe_fd[1], STDIN_FILENO) == -1)
+				_exit(1);
+		} else {
+			if (dup2(null_fd, STDIN_FILENO) == -1)
+				_exit(1);
+		}
+		if (in) {
+			if (dup2(pipe_fd[1], STDOUT_FILENO) == -1)
+				_exit(1);
+			if (pipe_fd[1] != STDOUT_FILENO)
+				close(pipe_fd[1]);
+		} else {
+			if (dup2(null_fd, STDOUT_FILENO) == -1)
+				_exit(1);
+		}
 		if (dup2(null_fd, STDERR_FILENO) == -1)
 			_exit(1);
-		if (null_fd != STDOUT_FILENO && null_fd != STDERR_FILENO)
-			close(null_fd);
-
 		closefrom(STDERR_FILENO + 1);
 
-		command = status_replace(
-		    c, NULL, NULL, NULL, args->argv[0], time(NULL), 0);
-		execl(_PATH_BSHELL, "sh", "-c", command, (char *) NULL);
+		execl(_PATH_BSHELL, "sh", "-c", cmd, (char *) NULL);
 		_exit(1);
 	default:
 		/* Parent process. */
+		sigprocmask(SIG_SETMASK, &oldset, NULL);
 		close(pipe_fd[1]);
 
 		wp->pipe_fd = pipe_fd[0];
 		wp->pipe_off = EVBUFFER_LENGTH(wp->event->input);
 
-		wp->pipe_event = bufferevent_new(wp->pipe_fd,
-		    NULL, NULL, cmd_pipe_pane_error_callback, wp);
-		bufferevent_enable(wp->pipe_event, EV_WRITE);
-
 		setblocking(wp->pipe_fd, 0);
+		wp->pipe_event = bufferevent_new(wp->pipe_fd,
+		    cmd_pipe_pane_read_callback,
+		    cmd_pipe_pane_write_callback,
+		    cmd_pipe_pane_error_callback,
+		    wp);
+		if (out)
+			bufferevent_enable(wp->pipe_event, EV_WRITE);
+		if (in)
+			bufferevent_enable(wp->pipe_event, EV_READ);
+
+		free(cmd);
 		return (CMD_RETURN_NORMAL);
 	}
 }
 
-void
-cmd_pipe_pane_error_callback(
-    unused struct bufferevent *bufev, unused short what, void *data)
+static void
+cmd_pipe_pane_read_callback(__unused struct bufferevent *bufev, void *data)
 {
 	struct window_pane	*wp = data;
+	struct evbuffer		*evb = wp->pipe_event->input;
+	size_t			 available;
+
+	available = EVBUFFER_LENGTH(evb);
+	log_debug("%%%u pipe read %zu", wp->id, available);
+
+	bufferevent_write(wp->event, EVBUFFER_DATA(evb), available);
+	evbuffer_drain(evb, available);
+
+	if (window_pane_destroy_ready(wp))
+		server_destroy_pane(wp, 1);
+}
+
+static void
+cmd_pipe_pane_write_callback(__unused struct bufferevent *bufev, void *data)
+{
+	struct window_pane	*wp = data;
+
+	log_debug("%%%u pipe empty", wp->id);
+
+	if (window_pane_destroy_ready(wp))
+		server_destroy_pane(wp, 1);
+}
+
+static void
+cmd_pipe_pane_error_callback(__unused struct bufferevent *bufev,
+    __unused short what, void *data)
+{
+	struct window_pane	*wp = data;
+
+	log_debug("%%%u pipe error", wp->id);
 
 	bufferevent_free(wp->pipe_event);
 	close(wp->pipe_fd);
 	wp->pipe_fd = -1;
+
+	if (window_pane_destroy_ready(wp))
+		server_destroy_pane(wp, 1);
 }

cmd-queue.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2013 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2013 Nicholas Marriott <nicholas.marriott@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
@@ -20,64 +20,416 @@
 
 #include <ctype.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 
 #include "tmux.h"
 
-/* Create new command queue. */
-struct cmd_q *
-cmdq_new(struct client *c)
+/* Global command queue. */
+static struct cmdq_list global_queue = TAILQ_HEAD_INITIALIZER(global_queue);
+
+/* Get command queue name. */
+static const char *
+cmdq_name(struct client *c)
 {
-	struct cmd_q	*cmdq;
+	static char	s[32];
 
-	cmdq = xcalloc(1, sizeof *cmdq);
-	cmdq->references = 1;
-	cmdq->dead = 0;
-
-	cmdq->client = c;
-	cmdq->client_exit = -1;
-
-	TAILQ_INIT(&cmdq->queue);
-	cmdq->item = NULL;
-	cmdq->cmd = NULL;
-
-	return (cmdq);
+	if (c == NULL)
+		return ("<global>");
+	xsnprintf(s, sizeof s, "<%p>", c);
+	return (s);
 }
 
-/* Free command queue */
-int
-cmdq_free(struct cmd_q *cmdq)
+/* Get command queue from client. */
+static struct cmdq_list *
+cmdq_get(struct client *c)
 {
-	if (--cmdq->references != 0)
-		return (cmdq->dead);
+	if (c == NULL)
+		return (&global_queue);
+	return (&c->queue);
+}
 
-	cmdq_flush(cmdq);
-	free(cmdq);
-	return (1);
+/* Append an item. */
+void
+cmdq_append(struct client *c, struct cmdq_item *item)
+{
+	struct cmdq_list	*queue = cmdq_get(c);
+	struct cmdq_item	*next;
+
+	do {
+		next = item->next;
+		item->next = NULL;
+
+		if (c != NULL)
+			c->references++;
+		item->client = c;
+
+		item->queue = queue;
+		TAILQ_INSERT_TAIL(queue, item, entry);
+
+		item = next;
+	} while (item != NULL);
+}
+
+/* Insert an item. */
+void
+cmdq_insert_after(struct cmdq_item *after, struct cmdq_item *item)
+{
+	struct client		*c = after->client;
+	struct cmdq_list	*queue = after->queue;
+	struct cmdq_item	*next;
+
+	do {
+		next = item->next;
+		item->next = NULL;
+
+		if (c != NULL)
+			c->references++;
+		item->client = c;
+
+		item->queue = queue;
+		if (after->next != NULL)
+			TAILQ_INSERT_AFTER(queue, after->next, item, entry);
+		else
+			TAILQ_INSERT_AFTER(queue, after, item, entry);
+		after->next = item;
+
+		item = next;
+	} while (item != NULL);
+}
+
+/* Remove an item. */
+static void
+cmdq_remove(struct cmdq_item *item)
+{
+	if (item->shared != NULL && --item->shared->references == 0) {
+		if (item->shared->formats != NULL)
+			format_free(item->shared->formats);
+		free(item->shared);
+	}
+
+	if (item->client != NULL)
+		server_client_unref(item->client);
+
+	if (item->type == CMDQ_COMMAND)
+		cmd_list_free(item->cmdlist);
+
+	TAILQ_REMOVE(item->queue, item, entry);
+
+	free((void *)item->name);
+	free(item);
+}
+
+/* Set command group. */
+static u_int
+cmdq_next_group(void)
+{
+	static u_int	group;
+
+	return (++group);
+}
+
+/* Remove all subsequent items that match this item's group. */
+static void
+cmdq_remove_group(struct cmdq_item *item)
+{
+	struct cmdq_item	*this, *next;
+
+	this = TAILQ_NEXT(item, entry);
+	while (this != NULL) {
+		next = TAILQ_NEXT(this, entry);
+		if (this->group == item->group)
+			cmdq_remove(this);
+		this = next;
+	}
+}
+
+/* Get a command for the command queue. */
+struct cmdq_item *
+cmdq_get_command(struct cmd_list *cmdlist, struct cmd_find_state *current,
+    struct mouse_event *m, int flags)
+{
+	struct cmdq_item	*item, *first = NULL, *last = NULL;
+	struct cmd		*cmd;
+	u_int			 group = cmdq_next_group();
+	char			*tmp;
+	struct cmdq_shared	*shared;
+
+	shared = xcalloc(1, sizeof *shared);
+	if (current != NULL)
+		cmd_find_copy_state(&shared->current, current);
+	else
+		cmd_find_clear_state(&shared->current, 0);
+	if (m != NULL)
+		memcpy(&shared->mouse, m, sizeof shared->mouse);
+
+	TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
+		xasprintf(&tmp, "command[%s]", cmd->entry->name);
+
+		item = xcalloc(1, sizeof *item);
+		item->name = tmp;
+		item->type = CMDQ_COMMAND;
+
+		item->group = group;
+		item->flags = flags;
+
+		item->shared = shared;
+		item->cmdlist = cmdlist;
+		item->cmd = cmd;
+
+		shared->references++;
+		cmdlist->references++;
+
+		if (first == NULL)
+			first = item;
+		if (last != NULL)
+			last->next = item;
+		last = item;
+	}
+	return (first);
+}
+
+/* Fill in flag for a command. */
+static enum cmd_retval
+cmdq_find_flag(struct cmdq_item *item, struct cmd_find_state *fs,
+    const struct cmd_entry_flag *flag)
+{
+	const char	*value;
+
+	if (flag->flag == 0) {
+		cmd_find_clear_state(fs, 0);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	value = args_get(item->cmd->args, flag->flag);
+	if (cmd_find_target(fs, item, value, flag->type, flag->flags) != 0) {
+		cmd_find_clear_state(fs, 0);
+		return (CMD_RETURN_ERROR);
+	}
+	return (CMD_RETURN_NORMAL);
+}
+
+/* Fire command on command queue. */
+static enum cmd_retval
+cmdq_fire_command(struct cmdq_item *item)
+{
+	struct client		*c = item->client;
+	struct cmd		*cmd = item->cmd;
+	const struct cmd_entry	*entry = cmd->entry;
+	enum cmd_retval		 retval;
+	struct cmd_find_state	*fsp, fs;
+	int			 flags;
+
+	flags = !!(cmd->flags & CMD_CONTROL);
+	cmdq_guard(item, "begin", flags);
+
+	if (item->client == NULL)
+		item->client = cmd_find_client(item, NULL, 1);
+	retval = cmdq_find_flag(item, &item->source, &entry->source);
+	if (retval == CMD_RETURN_ERROR)
+		goto out;
+	retval = cmdq_find_flag(item, &item->target, &entry->target);
+	if (retval == CMD_RETURN_ERROR)
+		goto out;
+
+	retval = entry->exec(cmd, item);
+	if (retval == CMD_RETURN_ERROR)
+		goto out;
+
+	if (entry->flags & CMD_AFTERHOOK) {
+		if (cmd_find_valid_state(&item->target))
+			fsp = &item->target;
+		else if (cmd_find_valid_state(&item->shared->current))
+			fsp = &item->shared->current;
+		else if (cmd_find_from_client(&fs, item->client, 0) == 0)
+			fsp = &fs;
+		else
+			goto out;
+		hooks_insert(fsp->s->hooks, item, fsp, "after-%s", entry->name);
+	}
+
+out:
+	item->client = c;
+	if (retval == CMD_RETURN_ERROR)
+		cmdq_guard(item, "error", flags);
+	else
+		cmdq_guard(item, "end", flags);
+	return (retval);
+}
+
+/* Get a callback for the command queue. */
+struct cmdq_item *
+cmdq_get_callback1(const char *name, cmdq_cb cb, void *data)
+{
+	struct cmdq_item	*item;
+	char			*tmp;
+
+	xasprintf(&tmp, "callback[%s]", name);
+
+	item = xcalloc(1, sizeof *item);
+	item->name = tmp;
+	item->type = CMDQ_CALLBACK;
+
+	item->group = 0;
+	item->flags = 0;
+
+	item->cb = cb;
+	item->data = data;
+
+	return (item);
+}
+
+/* Fire callback on callback queue. */
+static enum cmd_retval
+cmdq_fire_callback(struct cmdq_item *item)
+{
+	return (item->cb(item, item->data));
+}
+
+/* Add a format to command queue. */
+void
+cmdq_format(struct cmdq_item *item, const char *key, const char *fmt, ...)
+{
+	struct cmdq_shared	*shared = item->shared;
+	va_list			 ap;
+	char			*value;
+
+	va_start(ap, fmt);
+	xvasprintf(&value, fmt, ap);
+	va_end(ap);
+
+	if (shared->formats == NULL)
+		shared->formats = format_create(NULL, NULL, FORMAT_NONE, 0);
+	format_add(shared->formats, key, "%s", value);
+
+	free(value);
+}
+
+/* Process next item on command queue. */
+u_int
+cmdq_next(struct client *c)
+{
+	struct cmdq_list	*queue = cmdq_get(c);
+	const char		*name = cmdq_name(c);
+	struct cmdq_item	*item;
+	enum cmd_retval		 retval;
+	u_int			 items = 0;
+	static u_int		 number;
+
+	if (TAILQ_EMPTY(queue)) {
+		log_debug("%s %s: empty", __func__, name);
+		return (0);
+	}
+	if (TAILQ_FIRST(queue)->flags & CMDQ_WAITING) {
+		log_debug("%s %s: waiting", __func__, name);
+		return (0);
+	}
+
+	log_debug("%s %s: enter", __func__, name);
+	for (;;) {
+		item = TAILQ_FIRST(queue);
+		if (item == NULL)
+			break;
+		log_debug("%s %s: %s (%d), flags %x", __func__, name,
+		    item->name, item->type, item->flags);
+
+		/*
+		 * Any item with the waiting flag set waits until an external
+		 * event clears the flag (for example, a job - look at
+		 * run-shell).
+		 */
+		if (item->flags & CMDQ_WAITING)
+			goto waiting;
+
+		/*
+		 * Items are only fired once, once the fired flag is set, a
+		 * waiting flag can only be cleared by an external event.
+		 */
+		if (~item->flags & CMDQ_FIRED) {
+			item->time = time(NULL);
+			item->number = ++number;
+
+			switch (item->type) {
+			case CMDQ_COMMAND:
+				retval = cmdq_fire_command(item);
+
+				/*
+				 * If a command returns an error, remove any
+				 * subsequent commands in the same group.
+				 */
+				if (retval == CMD_RETURN_ERROR)
+					cmdq_remove_group(item);
+				break;
+			case CMDQ_CALLBACK:
+				retval = cmdq_fire_callback(item);
+				break;
+			default:
+				retval = CMD_RETURN_ERROR;
+				break;
+			}
+			item->flags |= CMDQ_FIRED;
+
+			if (retval == CMD_RETURN_WAIT) {
+				item->flags |= CMDQ_WAITING;
+				goto waiting;
+			}
+			items++;
+		}
+		cmdq_remove(item);
+	}
+
+	log_debug("%s %s: exit (empty)", __func__, name);
+	return (items);
+
+waiting:
+	log_debug("%s %s: exit (wait)", __func__, name);
+	return (items);
+}
+
+/* Print a guard line. */
+void
+cmdq_guard(struct cmdq_item *item, const char *guard, int flags)
+{
+	struct client	*c = item->client;
+
+	if (c == NULL || !(c->flags & CLIENT_CONTROL))
+		return;
+
+	evbuffer_add_printf(c->stdout_data, "%%%s %ld %u %d\n", guard,
+	    (long)item->time, item->number, flags);
+	server_client_push_stdout(c);
 }
 
 /* Show message from command. */
-void printflike2
-cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
+void
+cmdq_print(struct cmdq_item *item, const char *fmt, ...)
 {
-	struct client	*c = cmdq->client;
+	struct client	*c = item->client;
 	struct window	*w;
 	va_list		 ap;
+	char		*tmp, *msg;
 
 	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);
-
+		if (~c->flags & CLIENT_UTF8) {
+			xvasprintf(&tmp, fmt, ap);
+			msg = utf8_sanitize(tmp);
+			free(tmp);
+			evbuffer_add(c->stdout_data, msg, strlen(msg));
+			free(msg);
+		} else
+			evbuffer_add_vprintf(c->stdout_data, fmt, ap);
 		evbuffer_add(c->stdout_data, "\n", 1);
-		server_push_stdout(c);
+		server_client_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_pane_set_mode(w->active, &window_copy_mode, NULL,
+			    NULL);
 			window_copy_init_for_output(w->active);
 		}
 		window_copy_vadd(w->active, fmt, ap);
@@ -86,59 +438,35 @@ cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
 	va_end(ap);
 }
 
-/* Show info from command. */
-void printflike2
-cmdq_info(struct cmd_q *cmdq, const char *fmt, ...)
+/* Show error from command. */
+void
+cmdq_error(struct cmdq_item *item, const char *fmt, ...)
 {
-	struct client	*c = cmdq->client;
+	struct client	*c = item->client;
+	struct cmd	*cmd = item->cmd;
 	va_list		 ap;
 	char		*msg;
-
-	if (options_get_number(&global_options, "quiet"))
-		return;
-
-	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 {
-		xvasprintf(&msg, fmt, ap);
-		*msg = toupper((u_char) *msg);
-		status_message_set(c, "%s", msg);
-		free(msg);
-	}
-
-	va_end(ap);
-
-}
-
-/* Show error from command. */
-void printflike2
-cmdq_error(struct cmd_q *cmdq, const char *fmt, ...)
-{
-	struct client	*c = cmdq->client;
-	struct cmd	*cmd = cmdq->cmd;
-	va_list		 ap;
-	char		*msg, *cause;
 	size_t		 msglen;
+	char		*tmp;
 
 	va_start(ap, fmt);
 	msglen = xvasprintf(&msg, fmt, ap);
 	va_end(ap);
 
-	if (c == NULL) {
-		xasprintf(&cause, "%s:%u: %s", cmd->file, cmd->line, msg);
-		ARRAY_ADD(&cfg_causes, cause);
-	} else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
+	log_debug("%s: %s", __func__, msg);
+
+	if (c == NULL)
+		cfg_add_cause("%s:%u: %s", cmd->file, cmd->line, msg);
+	else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
+		if (~c->flags & CLIENT_UTF8) {
+			tmp = msg;
+			msg = utf8_sanitize(tmp);
+			free(tmp);
+			msglen = strlen(msg);
+		}
 		evbuffer_add(c->stderr_data, msg, msglen);
 		evbuffer_add(c->stderr_data, "\n", 1);
-
-		server_push_stderr(c);
+		server_client_push_stderr(c);
 		c->retval = 1;
 	} else {
 		*msg = toupper((u_char) *msg);
@@ -147,135 +475,3 @@ cmdq_error(struct cmd_q *cmdq, const char *fmt, ...)
 
 	free(msg);
 }
-
-/* Print a guard line. */
-int
-cmdq_guard(struct cmd_q *cmdq, const char *guard, int flags)
-{
-	struct client	*c = cmdq->client;
-
-	if (c == NULL)
-		return 0;
-	if (!(c->flags & CLIENT_CONTROL))
-		return 0;
-
-	evbuffer_add_printf(c->stdout_data, "%%%s %ld %u %d\n", guard,
-	    (long) cmdq->time, cmdq->number, flags);
-	server_push_stdout(c);
-	return 1;
-}
-
-/* Add command list to queue and begin processing if needed. */
-void
-cmdq_run(struct cmd_q *cmdq, struct cmd_list *cmdlist)
-{
-	cmdq_append(cmdq, cmdlist);
-
-	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 cmd_q_item	*item;
-
-	item = xcalloc(1, sizeof *item);
-	item->cmdlist = cmdlist;
-	TAILQ_INSERT_TAIL(&cmdq->queue, item, qentry);
-	cmdlist->references++;
-}
-
-/* Continue processing command queue. Returns 1 if finishes empty. */
-int
-cmdq_continue(struct cmd_q *cmdq)
-{
-	struct cmd_q_item	*next;
-	enum cmd_retval		 retval;
-	int			 empty, guard, flags;
-	char			 s[1024];
-
-	notify_disable();
-
-	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 {
-		next = TAILQ_NEXT(cmdq->item, qentry);
-
-		while (cmdq->cmd != NULL) {
-			cmd_print(cmdq->cmd, s, sizeof s);
-			log_debug("cmdq %p: %s (client %d)", cmdq, s,
-			    cmdq->client != NULL ? cmdq->client->ibuf.fd : -1);
-
-			cmdq->time = time(NULL);
-			cmdq->number++;
-
-			flags = !!(cmdq->cmd->flags & CMD_CONTROL);
-			guard = cmdq_guard(cmdq, "begin", flags);
-
-			retval = cmdq->cmd->entry->exec(cmdq->cmd, cmdq);
-
-			if (guard) {
-				if (retval == CMD_RETURN_ERROR)
-					cmdq_guard(cmdq, "error", flags);
-				else
-					cmdq_guard(cmdq, "end", flags);
-			}
-
-			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);
-		}
-
-		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); /* may free cmdq */
-	empty = 1;
-
-out:
-	notify_enable();
-	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,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -24,53 +24,59 @@
  * Refresh client.
  */
 
-enum cmd_retval	 cmd_refresh_client_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_refresh_client_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_refresh_client_entry = {
-	"refresh-client", "refresh",
-	"C:St:", 0, 0,
-	"[-S] [-C size] " CMD_TARGET_CLIENT_USAGE,
-	0,
-	NULL,
-	cmd_refresh_client_exec
+	.name = "refresh-client",
+	.alias = "refresh",
+
+	.args = { "C:St:", 0, 0 },
+	.usage = "[-S] [-C size] " CMD_TARGET_CLIENT_USAGE,
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_refresh_client_exec
 };
 
-enum cmd_retval
-cmd_refresh_client_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_refresh_client_exec(struct cmd *self, struct cmdq_item *item)
 {
 	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(item, args_get(args, 't'), 0)) == NULL)
 		return (CMD_RETURN_ERROR);
 
 	if (args_has(args, 'C')) {
 		if ((size = args_get(args, 'C')) == NULL) {
-			cmdq_error(cmdq, "missing size");
+			cmdq_error(item, "missing size");
 			return (CMD_RETURN_ERROR);
 		}
 		if (sscanf(size, "%u,%u", &w, &h) != 2) {
-			cmdq_error(cmdq, "bad size argument");
+			cmdq_error(item, "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");
+			cmdq_error(item, "size too small or too big");
 			return (CMD_RETURN_ERROR);
 		}
 		if (!(c->flags & CLIENT_CONTROL)) {
-			cmdq_error(cmdq, "not a control client");
+			cmdq_error(item, "not a control client");
 			return (CMD_RETURN_ERROR);
 		}
-		if (tty_set_size(&c->tty, w, h))
-			recalculate_sizes();
+		tty_set_size(&c->tty, w, h);
+		c->flags |= CLIENT_SIZECHANGED;
+		recalculate_sizes();
 	} else if (args_has(args, 'S')) {
-		status_update_jobs(c);
+		c->flags |= CLIENT_STATUSFORCE;
 		server_status_client(c);
-	} else
+	} else {
+		c->flags |= CLIENT_STATUSFORCE;
 		server_redraw_client(c);
+	}
 
 	return (CMD_RETURN_NORMAL);
 }

cmd-rename-session.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -19,6 +19,7 @@
 #include <sys/types.h>
 
 #include <stdlib.h>
+#include <string.h>
 
 #include "tmux.h"
 
@@ -26,44 +27,54 @@
  * Change session name.
  */
 
-enum cmd_retval	 cmd_rename_session_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_rename_session_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_rename_session_entry = {
-	"rename-session", "rename",
-	"t:", 1, 1,
-	CMD_TARGET_SESSION_USAGE " new-name",
-	0,
-	NULL,
-	cmd_rename_session_exec
+	.name = "rename-session",
+	.alias = "rename",
+
+	.args = { "t:", 1, 1 },
+	.usage = CMD_TARGET_SESSION_USAGE " new-name",
+
+	.target = { 't', CMD_FIND_SESSION, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_rename_session_exec
 };
 
-enum cmd_retval
-cmd_rename_session_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_rename_session_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	struct session	*s;
-	const char	*newname;
+	struct args		*args = self->args;
+	struct client		*c = cmd_find_client(item, NULL, 0);
+	struct session		*s = item->target.s;
+	char			*newname;
+
+	newname = format_single(item, args->argv[0], c, s, NULL, NULL);
+	if (strcmp(newname, s->name) == 0) {
+		free(newname);
+		return (CMD_RETURN_NORMAL);
+	}
 
-	newname = args->argv[0];
 	if (!session_check_name(newname)) {
-		cmdq_error(cmdq, "bad session name: %s", newname);
+		cmdq_error(item, "bad session name: %s", newname);
+		free(newname);
 		return (CMD_RETURN_ERROR);
 	}
 	if (session_find(newname) != NULL) {
-		cmdq_error(cmdq, "duplicate session: %s", newname);
+		cmdq_error(item, "duplicate session: %s", newname);
+		free(newname);
 		return (CMD_RETURN_ERROR);
 	}
 
-	if ((s = cmd_find_session(cmdq, args_get(args, 't'), 0)) == NULL)
-		return (CMD_RETURN_ERROR);
-
 	RB_REMOVE(sessions, &sessions, s);
 	free(s->name);
-	s->name = xstrdup(newname);
+	s->name = newname;
 	RB_INSERT(sessions, &sessions, s);
 
 	server_status_session(s);
-	notify_session_renamed(s);
+	notify_session("session-renamed", s);
 
 	return (CMD_RETURN_NORMAL);
 }

cmd-rename-window.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -26,31 +26,37 @@
  * Rename a window.
  */
 
-enum cmd_retval	 cmd_rename_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_rename_window_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_rename_window_entry = {
-	"rename-window", "renamew",
-	"t:", 1, 1,
-	CMD_TARGET_WINDOW_USAGE " new-name",
-	0,
-	NULL,
-	cmd_rename_window_exec
+	.name = "rename-window",
+	.alias = "renamew",
+
+	.args = { "t:", 1, 1 },
+	.usage = CMD_TARGET_WINDOW_USAGE " new-name",
+
+	.target = { 't', CMD_FIND_WINDOW, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_rename_window_exec
 };
 
-enum cmd_retval
-cmd_rename_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_rename_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct session	*s;
-	struct winlink	*wl;
+	struct client	*c = cmd_find_client(item, NULL, 1);
+	struct session	*s = item->target.s;
+	struct winlink	*wl = item->target.wl;
+	char		*newname;
 
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), &s)) == NULL)
-		return (CMD_RETURN_ERROR);
-
-	window_set_name(wl->window, args->argv[0]);
-	options_set_number(&wl->window->options, "automatic-rename", 0);
+	newname = format_single(item, args->argv[0], c, s, wl, NULL);
+	window_set_name(wl->window, newname);
+	options_set_number(wl->window->options, "automatic-rename", 0);
 
 	server_status_window(wl->window);
+	free(newname);
 
 	return (CMD_RETURN_NORMAL);
 }

cmd-resize-pane.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -26,79 +26,49 @@
  * Increase or decrease pane size.
  */
 
-void		 cmd_resize_pane_key_binding(struct cmd *, int);
-enum cmd_retval	 cmd_resize_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_resize_pane_exec(struct cmd *, struct cmdq_item *);
+
+static void	cmd_resize_pane_mouse_update(struct client *,
+		    struct mouse_event *);
 
 const struct cmd_entry cmd_resize_pane_entry = {
-	"resize-pane", "resizep",
-	"DLRt:Ux:y:Z", 0, 1,
-	"[-DLRUZ] [-x width] [-y height] " CMD_TARGET_PANE_USAGE " [adjustment]",
-	0,
-	cmd_resize_pane_key_binding,
-	cmd_resize_pane_exec
+	.name = "resize-pane",
+	.alias = "resizep",
+
+	.args = { "DLMRt:Ux:y:Z", 0, 1 },
+	.usage = "[-DLMRUZ] [-x width] [-y height] " CMD_TARGET_PANE_USAGE " "
+		 "[adjustment]",
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_resize_pane_exec
 };
 
-void
-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;
-	case 'z':
-		self->args = args_create(0);
-		args_set(self->args, 'Z', NULL);
-		break;
-	default:
-		self->args = args_create(0);
-		break;
-	}
-}
-
-enum cmd_retval
-cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_resize_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct winlink		*wl;
-	struct window		*w;
+	struct cmdq_shared	*shared = item->shared;
+	struct window_pane	*wp = item->target.wp;
+	struct winlink		*wl = item->target.wl;
+	struct window		*w = wl->window;
+	struct client		*c = item->client;
+	struct session		*s = item->target.s;
 	const char	       	*errstr;
 	char			*cause;
-	struct window_pane	*wp;
 	u_int			 adjust;
 	int			 x, y;
 
-	if ((wl = cmd_find_pane(cmdq, args_get(args, 't'), NULL, &wp)) == NULL)
-		return (CMD_RETURN_ERROR);
-	w = wl->window;
+	if (args_has(args, 'M')) {
+		if (cmd_mouse_window(&shared->mouse, &s) == NULL)
+			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, &shared->mouse);
+		return (CMD_RETURN_NORMAL);
+	}
 
 	if (args_has(args, 'Z')) {
 		if (w->flags & WINDOW_ZOOMED)
@@ -116,7 +86,7 @@ cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	else {
 		adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr);
 		if (errstr != NULL) {
-			cmdq_error(cmdq, "adjustment %s", errstr);
+			cmdq_error(item, "adjustment %s", errstr);
 			return (CMD_RETURN_ERROR);
 		}
 	}
@@ -125,7 +95,7 @@ cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 		x = args_strtonum(self->args, 'x', PANE_MINIMUM, INT_MAX,
 		    &cause);
 		if (cause != NULL) {
-			cmdq_error(cmdq, "width %s", cause);
+			cmdq_error(item, "width %s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
@@ -135,7 +105,7 @@ cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 		y = args_strtonum(self->args, 'y', PANE_MINIMUM, INT_MAX,
 		    &cause);
 		if (cause != NULL) {
-			cmdq_error(cmdq, "height %s", cause);
+			cmdq_error(item, "height %s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
@@ -143,14 +113,73 @@ cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	}
 
 	if (args_has(self->args, 'L'))
-		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, -adjust);
+		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, -adjust, 1);
 	else if (args_has(self->args, 'R'))
-		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, adjust);
+		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, adjust, 1);
 	else if (args_has(self->args, 'U'))
-		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, -adjust);
+		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, -adjust, 1);
 	else if (args_has(self->args, 'D'))
-		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, adjust);
+		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, adjust, 1);
 	server_redraw_window(wl->window);
 
 	return (CMD_RETURN_NORMAL);
 }
+
+static void
+cmd_resize_pane_mouse_update(struct client *c, struct mouse_event *m)
+{
+	struct winlink		*wl;
+	struct window_pane	*loop, *wp_x, *wp_y;
+	u_int			 y, ly, x, lx, sx, sy, ex, ey;
+
+	wl = cmd_mouse_window(m, NULL);
+	if (wl == NULL) {
+		c->tty.mouse_drag_update = NULL;
+		return;
+	}
+
+	y = m->y; x = m->x;
+	if (m->statusat == 0 && y > 0)
+		y--;
+	else if (m->statusat > 0 && y >= (u_int)m->statusat)
+		y = m->statusat - 1;
+	ly = m->ly; lx = m->lx;
+	if (m->statusat == 0 && ly > 0)
+		ly--;
+	else if (m->statusat > 0 && ly >= (u_int)m->statusat)
+		ly = m->statusat - 1;
+
+	wp_x = wp_y = NULL;
+	TAILQ_FOREACH(loop, &wl->window->panes, entry) {
+		if (!window_pane_visible(loop))
+			continue;
+
+		sx = loop->xoff;
+		if (sx != 0)
+			sx--;
+		ex = loop->xoff + loop->sx;
+
+		sy = loop->yoff;
+		if (sy != 0)
+			sy--;
+		ey = loop->yoff + loop->sy;
+
+		if ((lx == sx || lx == ex) &&
+		    (ly >= sy && ly <= ey) &&
+		    (wp_x == NULL || loop->sy > wp_x->sy))
+			wp_x = loop;
+		if ((ly == sy || ly == ey) &&
+		    (lx >= sx && lx <= ex) &&
+		    (wp_y == NULL || loop->sx > wp_y->sx))
+			wp_y = loop;
+	}
+	if (wp_x == NULL && wp_y == NULL) {
+		c->tty.mouse_drag_update = NULL;
+		return;
+	}
+	if (wp_x != NULL)
+		layout_resize_pane(wp_x, LAYOUT_LEFTRIGHT, x - lx, 0);
+	if (wp_y != NULL)
+		layout_resize_pane(wp_y, LAYOUT_TOPBOTTOM, y - ly, 0);
+	server_redraw_window(wl->window);
+}

cmd-respawn-pane.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@gmail.com>
  * Copyright (c) 2011 Marcel P. Partap <mpartap@gmx.net>
  *
  * Permission to use, copy, modify, and distribute this software for any
@@ -28,64 +28,73 @@
  * Respawn a pane (restart the command). Kill existing if -k given.
  */
 
-enum cmd_retval	 cmd_respawn_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_respawn_pane_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_respawn_pane_entry = {
-	"respawn-pane", "respawnp",
-	"kt:", 0, 1,
-	"[-k] " CMD_TARGET_PANE_USAGE " [command]",
-	0,
-	NULL,
-	cmd_respawn_pane_exec
+	.name = "respawn-pane",
+	.alias = "respawnp",
+
+	.args = { "c:kt:", 0, -1 },
+	.usage = "[-c start-directory] [-k] " CMD_TARGET_PANE_USAGE
+	         " [command]",
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = 0,
+	.exec = cmd_respawn_pane_exec
 };
 
-enum cmd_retval
-cmd_respawn_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_respawn_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct winlink		*wl;
-	struct window		*w;
-	struct window_pane	*wp;
-	struct session		*s;
-	struct environ		 env;
-	const char		*cmd;
-	char			*cause;
+	struct winlink		*wl = item->target.wl;
+	struct window		*w = wl->window;
+	struct window_pane	*wp = item->target.wp;
+	struct client           *c = cmd_find_client(item, NULL, 1);
+	struct session		*s = item->target.s;
+	struct environ		*env;
+	const char		*path = NULL, *cp;
+	char			*cause, *cwd = NULL;
 	u_int			 idx;
-
-	if ((wl = cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp)) == NULL)
-		return (CMD_RETURN_ERROR);
-	w = wl->window;
+	struct environ_entry	*envent;
 
 	if (!args_has(self->args, 'k') && wp->fd != -1) {
 		if (window_pane_index(wp, &idx) != 0)
 			fatalx("index not found");
-		cmdq_error(cmdq, "pane still active: %s:%u.%u",
+		cmdq_error(item, "pane still active: %s:%d.%u",
 		    s->name, wl->idx, idx);
 		return (CMD_RETURN_ERROR);
 	}
 
-	environ_init(&env);
-	environ_copy(&global_environ, &env);
-	environ_copy(&s->environ, &env);
-	server_fill_environ(s, &env);
-
 	window_pane_reset_mode(wp);
 	screen_reinit(&wp->base);
 	input_init(wp);
 
-	if (args->argc != 0)
-		cmd = args->argv[0];
+	if (item->client != NULL && item->client->session == NULL)
+		envent = environ_find(item->client->environ, "PATH");
 	else
-		cmd = NULL;
-	if (window_pane_spawn(wp, cmd, NULL, -1, &env, s->tio, &cause) != 0) {
-		cmdq_error(cmdq, "respawn pane failed: %s", cause);
+		envent = environ_find(s->environ, "PATH");
+	if (envent != NULL)
+		path = envent->value;
+
+	if ((cp = args_get(args, 'c')) != NULL)
+		cwd = format_single(item, cp, c, s, NULL, NULL);
+
+	env = environ_for_session(s, 0);
+	if (window_pane_spawn(wp, args->argc, args->argv, path, NULL, cwd, env,
+	    s->tio, &cause) != 0) {
+		cmdq_error(item, "respawn pane failed: %s", cause);
 		free(cause);
-		environ_free(&env);
+		environ_free(env);
+		free(cwd);
 		return (CMD_RETURN_ERROR);
 	}
+	environ_free(env);
+	free(cwd);
+
 	wp->flags |= PANE_REDRAW;
 	server_status_window(w);
 
-	environ_free(&env);
 	return (CMD_RETURN_NORMAL);
 }

cmd-respawn-window.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@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
@@ -27,65 +27,77 @@
  * Respawn a window (restart the command). Kill existing if -k given.
  */
 
-enum cmd_retval	 cmd_respawn_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_respawn_window_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_respawn_window_entry = {
-	"respawn-window", "respawnw",
-	"kt:", 0, 1,
-	"[-k] " CMD_TARGET_WINDOW_USAGE " [command]",
-	0,
-	NULL,
-	cmd_respawn_window_exec
+	.name = "respawn-window",
+	.alias = "respawnw",
+
+	.args = { "c:kt:", 0, -1 },
+	.usage = "[-c start-directory] [-k] " CMD_TARGET_WINDOW_USAGE
+	         " [command]",
+
+	.target = { 't', CMD_FIND_WINDOW, 0 },
+
+	.flags = 0,
+	.exec = cmd_respawn_window_exec
 };
 
-enum cmd_retval
-cmd_respawn_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_respawn_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct winlink		*wl;
-	struct window		*w;
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	struct window		*w = wl->window;
 	struct window_pane	*wp;
-	struct session		*s;
-	struct environ		 env;
-	const char		*cmd;
-	char		 	*cause;
-
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), &s)) == NULL)
-		return (CMD_RETURN_ERROR);
-	w = wl->window;
+	struct client           *c = cmd_find_client(item, NULL, 1);
+	struct environ		*env;
+	const char		*path = NULL, *cp;
+	char		 	*cause, *cwd = NULL;
+	struct environ_entry	*envent;
 
 	if (!args_has(self->args, 'k')) {
 		TAILQ_FOREACH(wp, &w->panes, entry) {
 			if (wp->fd == -1)
 				continue;
-			cmdq_error(cmdq,
-			    "window still active: %s:%d", s->name, wl->idx);
+			cmdq_error(item, "window still active: %s:%d", s->name,
+			    wl->idx);
 			return (CMD_RETURN_ERROR);
 		}
 	}
 
-	environ_init(&env);
-	environ_copy(&global_environ, &env);
-	environ_copy(&s->environ, &env);
-	server_fill_environ(s, &env);
-
 	wp = TAILQ_FIRST(&w->panes);
 	TAILQ_REMOVE(&w->panes, wp, entry);
 	layout_free(w);
 	window_destroy_panes(w);
 	TAILQ_INSERT_HEAD(&w->panes, wp, entry);
 	window_pane_resize(wp, w->sx, w->sy);
-	if (args->argc != 0)
-		cmd = args->argv[0];
+
+	if (item->client != NULL && item->client->session == NULL)
+		envent = environ_find(item->client->environ, "PATH");
 	else
-		cmd = NULL;
-	if (window_pane_spawn(wp, cmd, NULL, -1, &env, s->tio, &cause) != 0) {
-		cmdq_error(cmdq, "respawn window failed: %s", cause);
+		envent = environ_find(s->environ, "PATH");
+	if (envent != NULL)
+		path = envent->value;
+
+	if ((cp = args_get(args, 'c')) != NULL)
+		cwd = format_single(item, cp, c, s, NULL, NULL);
+
+	env = environ_for_session(s, 0);
+	if (window_pane_spawn(wp, args->argc, args->argv, path, NULL, cwd, env,
+	    s->tio, &cause) != 0) {
+		cmdq_error(item, "respawn window failed: %s", cause);
 		free(cause);
-		environ_free(&env);
-		server_destroy_pane(wp);
+		environ_free(env);
+		free(cwd);
+		server_destroy_pane(wp, 0);
 		return (CMD_RETURN_ERROR);
 	}
+	environ_free(env);
+	free(cwd);
+
 	layout_init(w, wp);
 	window_pane_reset_mode(wp);
 	screen_reinit(&wp->base);
@@ -95,6 +107,5 @@ cmd_respawn_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	recalculate_sizes();
 	server_redraw_window(w);
 
-	environ_free(&env);
 	return (CMD_RETURN_NORMAL);
 }

cmd-rotate-window.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -24,39 +24,33 @@
  * Rotate the panes in a window.
  */
 
-void		 cmd_rotate_window_key_binding(struct cmd *, int);
-enum cmd_retval	 cmd_rotate_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_rotate_window_exec(struct cmd *,
+			    struct cmdq_item *);
 
 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,
-	cmd_rotate_window_exec
+	.name = "rotate-window",
+	.alias = "rotatew",
+
+	.args = { "Dt:U", 0, 0 },
+	.usage = "[-DU] " CMD_TARGET_WINDOW_USAGE,
+
+	.target = { 't', CMD_FIND_WINDOW, 0 },
+
+	.flags = 0,
+	.exec = cmd_rotate_window_exec
 };
 
-void
-cmd_rotate_window_key_binding(struct cmd *self, int key)
+static enum cmd_retval
+cmd_rotate_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	self->args = args_create(0);
-	if (key == ('o' | KEYC_ESCAPE))
-		args_set(self->args, 'D', NULL);
-}
-
-enum cmd_retval
-cmd_rotate_window_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args		*args = self->args;
-	struct winlink		*wl;
-	struct window		*w;
+	struct cmd_find_state	*current = &item->shared->current;
+	struct winlink		*wl = item->target.wl;
+	struct window		*w = wl->window;
 	struct window_pane	*wp, *wp2;
 	struct layout_cell	*lc;
 	u_int			 sx, sy, xoff, yoff;
 
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), NULL)) == NULL)
-		return (CMD_RETURN_ERROR);
-	w = wl->window;
+	server_unzoom_window(w);
 
 	if (args_has(self->args, 'D')) {
 		wp = TAILQ_LAST(&w->panes, window_panes);
@@ -84,6 +78,7 @@ cmd_rotate_window_exec(struct cmd *self, struct cmd_q *cmdq)
 		if ((wp = TAILQ_PREV(w->active, window_panes, entry)) == NULL)
 			wp = TAILQ_LAST(&w->panes, window_panes);
 		window_set_active_pane(w, wp);
+		cmd_find_from_winlink_pane(current, wl, wp, 0);
 		server_redraw_window(w);
 	} else {
 		wp = TAILQ_FIRST(&w->panes);
@@ -111,6 +106,7 @@ cmd_rotate_window_exec(struct cmd *self, struct cmd_q *cmdq)
 		if ((wp = TAILQ_NEXT(w->active, entry)) == NULL)
 			wp = TAILQ_FIRST(&w->panes);
 		window_set_active_pane(w, wp);
+		cmd_find_from_winlink_pane(current, wl, wp, 0);
 		server_redraw_window(w);
 	}
 

cmd-run-shell.c

@@ -1,4 +1,4 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -29,115 +29,107 @@
  * Runs a command without a window.
  */
 
-enum cmd_retval	 cmd_run_shell_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_run_shell_exec(struct cmd *, struct cmdq_item *);
 
-void	cmd_run_shell_callback(struct job *);
-void	cmd_run_shell_free(void *);
-void	cmd_run_shell_print(struct job *, const char *);
+static void	cmd_run_shell_callback(struct job *);
+static void	cmd_run_shell_free(void *);
+static void	cmd_run_shell_print(struct job *, const char *);
 
 const struct cmd_entry cmd_run_shell_entry = {
-	"run-shell", "run",
-	"bt:", 1, 1,
-	"[-b] " CMD_TARGET_PANE_USAGE " shell-command",
-	0,
-	NULL,
-	cmd_run_shell_exec
+	.name = "run-shell",
+	.alias = "run",
+
+	.args = { "bt:", 1, 1 },
+	.usage = "[-b] " CMD_TARGET_PANE_USAGE " shell-command",
+
+	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
+
+	.flags = 0,
+	.exec = cmd_run_shell_exec
 };
 
 struct cmd_run_shell_data {
-	char		*cmd;
-	struct cmd_q	*cmdq;
-	int		 bflag;
-	int		 wp_id;
+	char			*cmd;
+	struct cmdq_item	*item;
+	int			 wp_id;
 };
 
-void
+static void
 cmd_run_shell_print(struct job *job, const char *msg)
 {
 	struct cmd_run_shell_data	*cdata = job->data;
 	struct window_pane		*wp = NULL;
+	struct cmd_find_state		 fs;
 
 	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 (cdata->item != NULL) {
+			cmdq_print(cdata->item, "%s", msg);
+			return;
+		}
+		if (cmd_find_from_nothing(&fs, 0) != 0)
+			return;
+		wp = fs.wp;
+		if (wp == NULL)
+			return;
 	}
 
-	if (window_pane_set_mode(wp, &window_copy_mode) == 0)
+	if (window_pane_set_mode(wp, &window_copy_mode, NULL, NULL) == 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)
+static enum cmd_retval
+cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
 	struct cmd_run_shell_data	*cdata;
-	char				*shellcmd;
-	struct client			*c;
-	struct session			*s = NULL;
-	struct winlink			*wl = NULL;
-	struct window_pane		*wp = NULL;
-	struct format_tree		*ft;
+	struct client			*c = cmd_find_client(item, NULL, 1);
+	struct session			*s = item->target.s;
+	struct winlink			*wl = item->target.wl;
+	struct window_pane		*wp = item->target.wp;
+	const char			*cwd;
 
-	if (args_has(args, 't'))
-		wl = cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp);
-	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 (item->client != NULL && item->client->session == NULL)
+		cwd = item->client->cwd;
+	else if (s != NULL)
+		cwd = s->cwd;
+	else
+		cwd = NULL;
 
-	ft = format_create();
-	if (s != NULL)
-		format_session(ft, s);
-	if (s != NULL && wl != NULL)
-		format_winlink(ft, s, wl);
-	if (wp != NULL)
-		format_window_pane(ft, wp);
-	shellcmd = format_expand(ft, args->argv[0]);
-	format_free(ft);
+	cdata = xcalloc(1, sizeof *cdata);
+	cdata->cmd = format_single(item, args->argv[0], c, s, wl, wp);
 
-	cdata = xmalloc(sizeof *cdata);
-	cdata->cmd = shellcmd;
-	cdata->bflag = args_has(args, 'b');
-	cdata->wp_id = wp != NULL ? (int) wp->id : -1;
+	if (args_has(args, 't') && wp != NULL)
+		cdata->wp_id = wp->id;
+	else
+		cdata->wp_id = -1;
 
-	cdata->cmdq = cmdq;
-	cmdq->references++;
+	if (!args_has(args, 'b'))
+		cdata->item = item;
 
-	job_run(shellcmd, s, cmd_run_shell_callback, cmd_run_shell_free, cdata);
+	job_run(cdata->cmd, s, cwd, NULL, cmd_run_shell_callback,
+	    cmd_run_shell_free, cdata, 0);
 
-	if (cdata->bflag)
+	if (args_has(args, 'b'))
 		return (CMD_RETURN_NORMAL);
 	return (CMD_RETURN_WAIT);
 }
 
-void
+static void
 cmd_run_shell_callback(struct job *job)
 {
 	struct cmd_run_shell_data	*cdata = job->data;
-	struct cmd_q			*cmdq = cdata->cmdq;
-	char				*cmd, *msg, *line;
+	char				*cmd = cdata->cmd, *msg, *line;
 	size_t				 size;
 	int				 retcode;
-	u_int				 lines;
 
-	if (cmdq->dead)
-		return;
-	cmd = cdata->cmd;
-
-	lines = 0;
 	do {
 		if ((line = evbuffer_readline(job->event->input)) != NULL) {
 			cmd_run_shell_print(job, line);
 			free(line);
-			lines++;
 		}
 	} while (line != NULL);
 
@@ -148,7 +140,6 @@ cmd_run_shell_callback(struct job *job)
 		line[size] = '\0';
 
 		cmd_run_shell_print(job, line);
-		lines++;
 
 		free(line);
 	}
@@ -161,23 +152,18 @@ cmd_run_shell_callback(struct job *job)
 		retcode = WTERMSIG(job->status);
 		xasprintf(&msg, "'%s' terminated by signal %d", cmd, retcode);
 	}
-	if (msg != NULL) {
-		if (lines == 0)
-			cmdq_info(cmdq, "%s", msg);
-		else
-			cmd_run_shell_print(job, msg);
-		free(msg);
-	}
+	if (msg != NULL)
+		cmd_run_shell_print(job, msg);
+	free(msg);
+
+	if (cdata->item != NULL)
+		cdata->item->flags &= ~CMDQ_WAITING;
 }
 
-void
+static void
 cmd_run_shell_free(void *data)
 {
 	struct cmd_run_shell_data	*cdata = data;
-	struct cmd_q			*cmdq = cdata->cmdq;
-
-	if (!cmdq_free(cmdq) && !cdata->bflag)
-		cmdq_continue(cmdq);
 
 	free(cdata->cmd);
 	free(cdata);

cmd-save-buffer.c

@@ -1,4 +1,4 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -31,58 +31,56 @@
  * Saves a paste buffer to a file.
  */
 
-enum cmd_retval	 cmd_save_buffer_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_save_buffer_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_save_buffer_entry = {
-	"save-buffer", "saveb",
-	"ab:", 1, 1,
-	"[-a] " CMD_BUFFER_USAGE " path",
-	0,
-	NULL,
-	cmd_save_buffer_exec
+	.name = "save-buffer",
+	.alias = "saveb",
+
+	.args = { "ab:", 1, 1 },
+	.usage = "[-a] " CMD_BUFFER_USAGE " path",
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_save_buffer_exec
 };
 
 const struct cmd_entry cmd_show_buffer_entry = {
-	"show-buffer", "showb",
-	"b:", 0, 0,
-	CMD_BUFFER_USAGE,
-	0,
-	NULL,
-	cmd_save_buffer_exec
+	.name = "show-buffer",
+	.alias = "showb",
+
+	.args = { "b:", 0, 0 },
+	.usage = CMD_BUFFER_USAGE,
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_save_buffer_exec
 };
 
-enum cmd_retval
-cmd_save_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_save_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->client;
-	struct session          *s;
+	struct client		*c = item->client;
 	struct paste_buffer	*pb;
-	const char		*path;
-	char			*cause, *start, *end, *msg;
-	size_t			 size, used, msglen;
-	int			 cwd, fd, buffer;
+	const char		*path, *bufname, *bufdata, *start, *end;
+	const char		*flags;
+	char			*msg, *file;
+	size_t			 size, used, msglen, bufsize;
 	FILE			*f;
 
 	if (!args_has(args, 'b')) {
-		if ((pb = paste_get_top(&global_buffers)) == NULL) {
-			cmdq_error(cmdq, "no buffers");
+		if ((pb = paste_get_top(NULL)) == NULL) {
+			cmdq_error(item, "no buffers");
 			return (CMD_RETURN_ERROR);
 		}
 	} else {
-		buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
-		if (cause != NULL) {
-			cmdq_error(cmdq, "buffer %s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-
-		pb = paste_get_index(&global_buffers, buffer);
+		bufname = args_get(args, 'b');
+		pb = paste_get_name(bufname);
 		if (pb == NULL) {
-			cmdq_error(cmdq, "no buffer %d", buffer);
+			cmdq_error(item, "no buffer %s", bufname);
 			return (CMD_RETURN_ERROR);
 		}
 	}
+	bufdata = paste_buffer_data(pb, &bufsize);
 
 	if (self->entry == &cmd_show_buffer_entry)
 		path = "-";
@@ -90,7 +88,7 @@ cmd_save_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 		path = args->argv[0];
 	if (strcmp(path, "-") == 0) {
 		if (c == NULL) {
-			cmdq_error(cmdq, "can't write to stdout");
+			cmdq_error(item, "can't write to stdout");
 			return (CMD_RETURN_ERROR);
 		}
 		if (c->session == NULL || (c->flags & CLIENT_CONTROL))
@@ -98,65 +96,56 @@ cmd_save_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 		goto do_print;
 	}
 
-	if (c != NULL && c->session == NULL)
-		cwd = c->cwd;
-	else if ((s = cmd_current_session(cmdq, 0)) != NULL)
-		cwd = s->cwd;
-	else
-		cwd = AT_FDCWD;
+	flags = "wb";
+	if (args_has(self->args, 'a'))
+		flags = "ab";
 
-	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, 0600);
-		if (fd != -1)
-			f = fdopen(fd, "wb");
-	}
+	file = server_client_get_path(c, path);
+	f = fopen(file, flags);
 	if (f == NULL) {
-		if (fd != -1)
-			close(fd);
-		cmdq_error(cmdq, "%s: %s", path, strerror(errno));
+		cmdq_error(item, "%s: %s", file, strerror(errno));
+		free(file);
 		return (CMD_RETURN_ERROR);
 	}
-	if (fwrite(pb->data, 1, pb->size, f) != pb->size) {
-		cmdq_error(cmdq, "%s: fwrite error", path);
+
+	if (fwrite(bufdata, 1, bufsize, f) != bufsize) {
+		cmdq_error(item, "%s: write error", file);
 		fclose(f);
+		free(file);
 		return (CMD_RETURN_ERROR);
 	}
+
 	fclose(f);
+	free(file);
 
 	return (CMD_RETURN_NORMAL);
 
 do_stdout:
-	evbuffer_add(c->stdout_data, pb->data, pb->size);
-	server_push_stdout(c);
+	evbuffer_add(c->stdout_data, bufdata, bufsize);
+	server_client_push_stdout(c);
 	return (CMD_RETURN_NORMAL);
 
 do_print:
-	if (pb->size > (INT_MAX / 4) - 1) {
-		cmdq_error(cmdq, "buffer too big");
+	if (bufsize > (INT_MAX / 4) - 1) {
+		cmdq_error(item, "buffer too big");
 		return (CMD_RETURN_ERROR);
 	}
 	msg = NULL;
-	msglen = 0;
 
 	used = 0;
-	while (used != pb->size) {
-		start = pb->data + used;
-		end = memchr(start, '\n', pb->size - used);
+	while (used != bufsize) {
+		start = bufdata + used;
+		end = memchr(start, '\n', bufsize - used);
 		if (end != NULL)
 			size = end - start;
 		else
-			size = pb->size - used;
+			size = bufsize - used;
 
 		msglen = size * 4 + 1;
-		msg = xrealloc(msg, 1, msglen);
+		msg = xrealloc(msg, msglen);
 
 		strvisx(msg, start, size, VIS_OCTAL|VIS_TAB);
-		cmdq_print(cmdq, "%s", msg);
+		cmdq_print(item, "%s", msg);
 
 		used += size + (end != NULL);
 	}

cmd-select-layout.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -18,115 +18,128 @@
 
 #include <sys/types.h>
 
+#include <stdlib.h>
+
 #include "tmux.h"
 
 /*
  * Switch window to selected layout.
  */
 
-void		 cmd_select_layout_key_binding(struct cmd *, int);
-enum cmd_retval	 cmd_select_layout_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_select_layout_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_select_layout_entry = {
-	"select-layout", "selectl",
-	"npt:", 0, 1,
-	"[-np] " CMD_TARGET_WINDOW_USAGE " [layout-name]",
-	0,
-	cmd_select_layout_key_binding,
-	cmd_select_layout_exec
+	.name = "select-layout",
+	.alias = "selectl",
+
+	.args = { "Enopt:", 0, 1 },
+	.usage = "[-Enop] " CMD_TARGET_PANE_USAGE " [layout-name]",
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_select_layout_exec
 };
 
 const struct cmd_entry cmd_next_layout_entry = {
-	"next-layout", "nextl",
-	"t:", 0, 0,
-	CMD_TARGET_WINDOW_USAGE,
-	0,
-	NULL,
-	cmd_select_layout_exec
+	.name = "next-layout",
+	.alias = "nextl",
+
+	.args = { "t:", 0, 0 },
+	.usage = CMD_TARGET_WINDOW_USAGE,
+
+	.target = { 't', CMD_FIND_WINDOW, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_select_layout_exec
 };
 
 const struct cmd_entry cmd_previous_layout_entry = {
-	"previous-layout", "prevl",
-	"t:", 0, 0,
-	CMD_TARGET_WINDOW_USAGE,
-	0,
-	NULL,
-	cmd_select_layout_exec
+	.name = "previous-layout",
+	.alias = "prevl",
+
+	.args = { "t:", 0, 0 },
+	.usage = CMD_TARGET_WINDOW_USAGE,
+
+	.target = { 't', CMD_FIND_WINDOW, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_select_layout_exec
 };
 
-void
-cmd_select_layout_key_binding(struct cmd *self, int key)
+static enum cmd_retval
+cmd_select_layout_exec(struct cmd *self, struct cmdq_item *item)
 {
-	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;
-	}
-}
+	struct args		*args = self->args;
+	struct winlink		*wl = item->target.wl;
+	struct window		*w = wl->window;
+	struct window_pane	*wp = item->target.wp;
+	const char		*layoutname;
+	char			*oldlayout;
+	int			 next, previous, layout;
 
-enum cmd_retval
-cmd_select_layout_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args	*args = self->args;
-	struct winlink	*wl;
-	const char	*layoutname;
-	int		 next, previous, layout;
-
-	if ((wl = cmd_find_window(cmdq, args_get(args, 't'), NULL)) == NULL)
-		return (CMD_RETURN_ERROR);
-	server_unzoom_window(wl->window);
+	server_unzoom_window(w);
 
 	next = self->entry == &cmd_next_layout_entry;
-	if (args_has(self->args, 'n'))
+	if (args_has(args, 'n'))
 		next = 1;
 	previous = self->entry == &cmd_previous_layout_entry;
-	if (args_has(self->args, 'p'))
+	if (args_has(args, 'p'))
 		previous = 1;
 
+	oldlayout = w->old_layout;
+	w->old_layout = layout_dump(w->layout_root);
+
 	if (next || previous) {
 		if (next)
-			layout = layout_set_next(wl->window);
+			layout_set_next(w);
 		else
-			layout = layout_set_previous(wl->window);
-		server_redraw_window(wl->window);
-		cmdq_info(cmdq, "arranging in: %s", layout_set_name(layout));
-		return (CMD_RETURN_NORMAL);
+			layout_set_previous(w);
+		goto changed;
 	}
 
-	if (args->argc == 0)
-		layout = wl->window->lastlayout;
-	else
-		layout = layout_set_lookup(args->argv[0]);
-	if (layout != -1) {
-		layout = layout_set_select(wl->window, layout);
-		server_redraw_window(wl->window);
-		cmdq_info(cmdq, "arranging in: %s", layout_set_name(layout));
-		return (CMD_RETURN_NORMAL);
+	if (args_has(args, 'E')) {
+		layout_spread_out(wp);
+		goto changed;
 	}
 
-	if (args->argc != 0) {
-		layoutname = args->argv[0];
-		if (layout_parse(wl->window, layoutname) == -1) {
-			cmdq_error(cmdq, "can't set layout: %s", layoutname);
-			return (CMD_RETURN_ERROR);
+	if (!args_has(args, 'o')) {
+		if (args->argc == 0)
+			layout = w->lastlayout;
+		else
+			layout = layout_set_lookup(args->argv[0]);
+		if (layout != -1) {
+			layout_set_select(w, layout);
+			goto changed;
 		}
-		server_redraw_window(wl->window);
-		cmdq_info(cmdq, "arranging in: %s", layoutname);
 	}
+
+	if (args->argc != 0)
+		layoutname = args->argv[0];
+	else if (args_has(args, 'o'))
+		layoutname = oldlayout;
+	else
+		layoutname = NULL;
+
+	if (layoutname != NULL) {
+		if (layout_parse(w, layoutname) == -1) {
+			cmdq_error(item, "can't set layout: %s", layoutname);
+			goto error;
+		}
+		goto changed;
+	}
+
+	free(oldlayout);
 	return (CMD_RETURN_NORMAL);
+
+changed:
+	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,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -18,99 +18,161 @@
 
 #include <sys/types.h>
 
+#include <stdlib.h>
+
 #include "tmux.h"
 
 /*
  * Select pane.
  */
 
-void		 cmd_select_pane_key_binding(struct cmd *, int);
-enum cmd_retval	 cmd_select_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_select_pane_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_select_pane_entry = {
-	"select-pane", "selectp",
-	"lDLRt:U", 0, 0,
-	"[-lDLRU] " CMD_TARGET_PANE_USAGE,
-	0,
-	cmd_select_pane_key_binding,
-	cmd_select_pane_exec
+	.name = "select-pane",
+	.alias = "selectp",
+
+	.args = { "DdegLlMmP:RT:t:U", 0, 0 },
+	.usage = "[-DdegLlMmRU] [-P style] [-T title] " CMD_TARGET_PANE_USAGE,
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = 0,
+	.exec = cmd_select_pane_exec
 };
 
 const struct cmd_entry cmd_last_pane_entry = {
-	"last-pane", "lastp",
-	"t:", 0, 0,
-	CMD_TARGET_WINDOW_USAGE,
-	0,
-	NULL,
-	cmd_select_pane_exec
+	.name = "last-pane",
+	.alias = "lastp",
+
+	.args = { "det:", 0, 0 },
+	.usage = "[-de] " CMD_TARGET_WINDOW_USAGE,
+
+	.target = { 't', CMD_FIND_WINDOW, 0 },
+
+	.flags = 0,
+	.exec = cmd_select_pane_exec
 };
 
-void
-cmd_select_pane_key_binding(struct cmd *self, int key)
-{
-	self->args = args_create(0);
-	if (key == KEYC_UP)
-		args_set(self->args, 'U', NULL);
-	if (key == KEYC_DOWN)
-		args_set(self->args, 'D', NULL);
-	if (key == KEYC_LEFT)
-		args_set(self->args, 'L', NULL);
-	if (key == KEYC_RIGHT)
-		args_set(self->args, 'R', NULL);
-	if (key == 'o')
-		args_set(self->args, 't', ":.+");
-}
-
-enum cmd_retval
-cmd_select_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_select_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct winlink		*wl;
-	struct window_pane	*wp;
+	struct cmd_find_state	*current = &item->shared->current;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct winlink		*wl = item->target.wl;
+	struct window		*w = wl->window;
+	struct session		*s = item->target.s;
+	struct window_pane	*wp = item->target.wp, *lastwp, *markedwp;
+	char			*pane_title;
+	const char		*style;
 
 	if (self->entry == &cmd_last_pane_entry || args_has(args, 'l')) {
-		wl = cmd_find_window(cmdq, args_get(args, 't'), NULL);
-		if (wl == NULL)
-			return (CMD_RETURN_ERROR);
-
-		if (wl->window->last == NULL) {
-			cmdq_error(cmdq, "no last pane");
+		lastwp = w->last;
+		if (lastwp == NULL) {
+			cmdq_error(item, "no last pane");
 			return (CMD_RETURN_ERROR);
 		}
-
-		server_unzoom_window(wl->window);
-		window_set_active_pane(wl->window, wl->window->last);
-		server_status_window(wl->window);
-		server_redraw_window_borders(wl->window);
-
+		if (args_has(self->args, 'e'))
+			lastwp->flags &= ~PANE_INPUTOFF;
+		else if (args_has(self->args, 'd'))
+			lastwp->flags |= PANE_INPUTOFF;
+		else {
+			server_unzoom_window(w);
+			window_redraw_active_switch(w, lastwp);
+			if (window_set_active_pane(w, lastwp)) {
+				cmd_find_from_winlink(current, wl, 0);
+				server_status_window(w);
+				server_redraw_window_borders(w);
+			}
+		}
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if ((wl = cmd_find_pane(cmdq, args_get(args, 't'), NULL, &wp)) == NULL)
-		return (CMD_RETURN_ERROR);
+	if (args_has(args, 'm') || args_has(args, 'M')) {
+		if (args_has(args, 'm') && !window_pane_visible(wp))
+			return (CMD_RETURN_NORMAL);
+		lastwp = marked_pane.wp;
 
+		if (args_has(args, 'M') || server_is_marked(s, wl, wp))
+			server_clear_marked();
+		else
+			server_set_marked(s, wl, wp);
+		markedwp = marked_pane.wp;
+
+		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(item, "bad style: %s", style);
+				return (CMD_RETURN_ERROR);
+			}
+			wp->flags |= PANE_REDRAW;
+		}
+		if (args_has(self->args, 'g'))
+			cmdq_print(item, "%s", style_tostring(&wp->colgc));
+		return (CMD_RETURN_NORMAL);
+	}
+
+	if (args_has(self->args, 'L')) {
+		server_unzoom_window(wp->window);
+		wp = window_pane_find_left(wp);
+	} else if (args_has(self->args, 'R')) {
+		server_unzoom_window(wp->window);
+		wp = window_pane_find_right(wp);
+	} else if (args_has(self->args, 'U')) {
+		server_unzoom_window(wp->window);
+		wp = window_pane_find_up(wp);
+	} else if (args_has(self->args, 'D')) {
+		server_unzoom_window(wp->window);
+		wp = window_pane_find_down(wp);
+	}
+	if (wp == NULL)
+		return (CMD_RETURN_NORMAL);
+
+	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 (args_has(self->args, 'T')) {
+		pane_title = format_single(item, args_get(self->args, 'T'),
+		    c, s, wl, wp);
+		screen_set_title(&wp->base, pane_title);
+		server_status_window(wp->window);
+		free(pane_title);
+	}
+
+	if (wp == w->active)
+		return (CMD_RETURN_NORMAL);
 	server_unzoom_window(wp->window);
 	if (!window_pane_visible(wp)) {
-		cmdq_error(cmdq, "pane not visible");
+		cmdq_error(item, "pane not visible");
 		return (CMD_RETURN_ERROR);
 	}
-
-	if (args_has(self->args, 'L'))
-		wp = window_pane_find_left(wp);
-	else if (args_has(self->args, 'R'))
-		wp = window_pane_find_right(wp);
-	else if (args_has(self->args, 'U'))
-		wp = window_pane_find_up(wp);
-	else if (args_has(self->args, 'D'))
-		wp = window_pane_find_down(wp);
-	if (wp == NULL) {
-		cmdq_error(cmdq, "pane not found");
-		return (CMD_RETURN_ERROR);
+	window_redraw_active_switch(w, wp);
+	if (window_set_active_pane(w, wp)) {
+		cmd_find_from_winlink_pane(current, wl, wp, 0);
+		hooks_insert(s->hooks, item, current, "after-select-pane");
+		server_status_window(w);
+		server_redraw_window_borders(w);
 	}
 
-	window_set_active_pane(wl->window, wp);
-	server_status_window(wl->window);
-	server_redraw_window_borders(wl->window);
-
 	return (CMD_RETURN_NORMAL);
 }

cmd-select-window.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -26,66 +26,68 @@
  * Select window by index.
  */
 
-void		 cmd_select_window_key_binding(struct cmd *, int);
-enum cmd_retval	 cmd_select_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_select_window_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_select_window_entry = {
-	"select-window", "selectw",
-	"lnpTt:", 0, 0,
-	"[-lnpT] " CMD_TARGET_WINDOW_USAGE,
-	0,
-	cmd_select_window_key_binding,
-	cmd_select_window_exec
+	.name = "select-window",
+	.alias = "selectw",
+
+	.args = { "lnpTt:", 0, 0 },
+	.usage = "[-lnpT] " CMD_TARGET_WINDOW_USAGE,
+
+	.target = { 't', CMD_FIND_WINDOW, 0 },
+
+	.flags = 0,
+	.exec = cmd_select_window_exec
 };
 
 const struct cmd_entry cmd_next_window_entry = {
-	"next-window", "next",
-	"at:", 0, 0,
-	"[-a] " CMD_TARGET_SESSION_USAGE,
-	0,
-	cmd_select_window_key_binding,
-	cmd_select_window_exec
+	.name = "next-window",
+	.alias = "next",
+
+	.args = { "at:", 0, 0 },
+	.usage = "[-a] " CMD_TARGET_SESSION_USAGE,
+
+	.target = { 't', CMD_FIND_SESSION, 0 },
+
+	.flags = 0,
+	.exec = cmd_select_window_exec
 };
 
 const struct cmd_entry cmd_previous_window_entry = {
-	"previous-window", "prev",
-	"at:", 0, 0,
-	"[-a] " CMD_TARGET_SESSION_USAGE,
-	0,
-	cmd_select_window_key_binding,
-	cmd_select_window_exec
+	.name = "previous-window",
+	.alias = "prev",
+
+	.args = { "at:", 0, 0 },
+	.usage = "[-a] " CMD_TARGET_SESSION_USAGE,
+
+	.target = { 't', CMD_FIND_SESSION, 0 },
+
+	.flags = 0,
+	.exec = cmd_select_window_exec
 };
 
 const struct cmd_entry cmd_last_window_entry = {
-	"last-window", "last",
-	"t:", 0, 0,
-	CMD_TARGET_SESSION_USAGE,
-	0,
-	NULL,
-	cmd_select_window_exec
+	.name = "last-window",
+	.alias = "last",
+
+	.args = { "t:", 0, 0 },
+	.usage = CMD_TARGET_SESSION_USAGE,
+
+	.target = { 't', CMD_FIND_SESSION, 0 },
+
+	.flags = 0,
+	.exec = cmd_select_window_exec
 };
 
-void
-cmd_select_window_key_binding(struct cmd *self, int key)
+static enum cmd_retval
+cmd_select_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	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);
-}
-
-enum cmd_retval
-cmd_select_window_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args	*args = self->args;
-	struct winlink	*wl;
-	struct session	*s;
-	int		 next, previous, last, activity;
+	struct cmd_find_state	*current = &item->shared->current;
+	struct winlink		*wl = item->target.wl;
+	struct session		*s = item->target.s;
+	int			 next, previous, last, activity;
 
 	next = self->entry == &cmd_next_window_entry;
 	if (args_has(self->args, 'n'))
@@ -98,46 +100,44 @@ 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);
-		if (s == NULL)
-			return (CMD_RETURN_ERROR);
-
 		activity = args_has(self->args, 'a');
 		if (next) {
 			if (session_next(s, activity) != 0) {
-				cmdq_error(cmdq, "no next window");
+				cmdq_error(item, "no next window");
 				return (CMD_RETURN_ERROR);
 			}
 		} else if (previous) {
 			if (session_previous(s, activity) != 0) {
-				cmdq_error(cmdq, "no previous window");
+				cmdq_error(item, "no previous window");
 				return (CMD_RETURN_ERROR);
 			}
 		} else {
 			if (session_last(s) != 0) {
-				cmdq_error(cmdq, "no last window");
+				cmdq_error(item, "no last window");
 				return (CMD_RETURN_ERROR);
 			}
 		}
-
+		cmd_find_from_session(current, s, 0);
 		server_redraw_session(s);
+		hooks_insert(s->hooks, item, current, "after-select-window");
 	} else {
-		wl = cmd_find_window(cmdq, args_get(args, 't'), &s);
-		if (wl == NULL)
-			return (CMD_RETURN_ERROR);
-
 		/*
 		 * 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");
+				cmdq_error(item, "no last window");
 				return (-1);
 			}
+			if (current->s == s)
+				cmd_find_from_session(current, s, 0);
 			server_redraw_session(s);
-		} else if (session_select(s, wl->idx) == 0)
+		} else if (session_select(s, wl->idx) == 0) {
+			cmd_find_from_session(current, s, 0);
 			server_redraw_session(s);
+		}
+		hooks_insert(s->hooks, item, current, "after-select-window");
 	}
 	recalculate_sizes();
 

cmd-send-keys.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@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
@@ -27,74 +27,142 @@
  * Send keys to client.
  */
 
-enum cmd_retval	 cmd_send_keys_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_send_keys_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_send_keys_entry = {
-	"send-keys", "send",
-	"lRt:", 0, -1,
-	"[-lR] " CMD_TARGET_PANE_USAGE " key ...",
-	0,
-	NULL,
-	cmd_send_keys_exec
+	.name = "send-keys",
+	.alias = "send",
+
+	.args = { "lXRMN:t:", 0, -1 },
+	.usage = "[-lXRM] [-N repeat-count] " CMD_TARGET_PANE_USAGE " key ...",
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_send_keys_exec
 };
 
 const struct cmd_entry cmd_send_prefix_entry = {
-	"send-prefix", NULL,
-	"2t:", 0, 0,
-	"[-2] " CMD_TARGET_PANE_USAGE,
-	0,
-	NULL,
-	cmd_send_keys_exec
+	.name = "send-prefix",
+	.alias = NULL,
+
+	.args = { "2t:", 0, 0 },
+	.usage = "[-2] " CMD_TARGET_PANE_USAGE,
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_send_keys_exec
 };
 
-enum cmd_retval
-cmd_send_keys_exec(struct cmd *self, struct cmd_q *cmdq)
+static void
+cmd_send_keys_inject(struct client *c, struct cmdq_item *item, key_code key)
+{
+	struct window_pane	*wp = item->target.wp;
+	struct session		*s = item->target.s;
+	struct key_table	*table;
+	struct key_binding	*bd, bd_find;
+
+	if (wp->mode == NULL || wp->mode->key_table == NULL) {
+		if (options_get_number(wp->window->options, "xterm-keys"))
+			key |= KEYC_XTERM;
+		window_pane_key(wp, NULL, s, key, NULL);
+		return;
+	}
+	table = key_bindings_get_table(wp->mode->key_table(wp), 1);
+
+	bd_find.key = (key & ~KEYC_XTERM);
+	bd = RB_FIND(key_bindings, &table->key_bindings, &bd_find);
+	if (bd != NULL) {
+		table->references++;
+		key_bindings_dispatch(bd, item, c, NULL, &item->target);
+		key_bindings_unref_table(table);
+	}
+}
+
+static enum cmd_retval
+cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct window_pane	*wp;
-	struct session		*s;
-	struct input_ctx	*ictx;
-	const u_char		*str;
-	int			 i, key;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct window_pane	*wp = item->target.wp;
+	struct session		*s = item->target.s;
+	struct mouse_event	*m = &item->shared->mouse;
+	struct utf8_data	*ud, *uc;
+	wchar_t			 wc;
+	int			 i, literal;
+	key_code		 key;
+	u_int			 np = 1;
+	char			*cause = NULL;
 
-	if (cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp) == NULL)
-		return (CMD_RETURN_ERROR);
+	if (args_has(args, 'N')) {
+		np = args_strtonum(args, 'N', 1, UINT_MAX, &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "repeat count %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+		if (args_has(args, 'X') || args->argc == 0)
+			wp->modeprefix = np;
+	}
+
+	if (args_has(args, 'X')) {
+		if (wp->mode == NULL || wp->mode->command == NULL) {
+			cmdq_error(item, "not in a mode");
+			return (CMD_RETURN_ERROR);
+		}
+		if (!m->valid)
+			wp->mode->command(wp, c, s, args, NULL);
+		else
+			wp->mode->command(wp, c, s, args, m);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	if (args_has(args, 'M')) {
+		wp = cmd_mouse_pane(m, &s, NULL);
+		if (wp == NULL) {
+			cmdq_error(item, "no mouse target");
+			return (CMD_RETURN_ERROR);
+		}
+		window_pane_key(wp, NULL, s, m->key, m);
+		return (CMD_RETURN_NORMAL);
+	}
 
 	if (self->entry == &cmd_send_prefix_entry) {
 		if (args_has(args, '2'))
-			key = options_get_number(&s->options, "prefix2");
+			key = options_get_number(s->options, "prefix2");
 		else
-			key = options_get_number(&s->options, "prefix");
-		window_pane_key(wp, s, key);
+			key = options_get_number(s->options, "prefix");
+		cmd_send_keys_inject(c, item, key);
 		return (CMD_RETURN_NORMAL);
 	}
 
 	if (args_has(args, 'R')) {
-		ictx = &wp->ictx;
-
-		memcpy(&ictx->cell, &grid_default_cell, sizeof ictx->cell);
-		memcpy(&ictx->old_cell, &ictx->cell, sizeof ictx->old_cell);
-		ictx->old_cx = 0;
-		ictx->old_cy = 0;
-
-		if (wp->mode == NULL)
-			screen_write_start(&ictx->ctx, wp, &wp->base);
-		else
-			screen_write_start(&ictx->ctx, NULL, &wp->base);
-		screen_write_reset(&ictx->ctx);
-		screen_write_stop(&ictx->ctx);
+		window_pane_reset_palette(wp);
+		input_reset(wp, 1);
 	}
 
-	for (i = 0; i < args->argc; i++) {
-		str = args->argv[i];
-
-		if (!args_has(args, 'l') &&
-		    (key = key_string_lookup_string(str)) != KEYC_NONE) {
-			    window_pane_key(wp, s, key);
-		} else {
-			for (; *str != '\0'; str++)
-			    window_pane_key(wp, s, *str);
+	for (; np != 0; np--) {
+		for (i = 0; i < args->argc; i++) {
+			literal = args_has(args, 'l');
+			if (!literal) {
+				key = key_string_lookup_string(args->argv[i]);
+				if (key != KEYC_NONE && key != KEYC_UNKNOWN)
+					cmd_send_keys_inject(c, item, key);
+				else
+					literal = 1;
+			}
+			if (literal) {
+				ud = utf8_fromcstr(args->argv[i]);
+				for (uc = ud; uc->size != 0; uc++) {
+					if (utf8_combine(uc, &wc) != UTF8_DONE)
+						continue;
+					cmd_send_keys_inject(c, item, wc);
+				}
+				free(ud);
+			}
 		}
+
 	}
 
 	return (CMD_RETURN_NORMAL);

cmd-set-buffer.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -24,50 +24,98 @@
 #include "tmux.h"
 
 /*
- * Add or set a paste buffer.
+ * Add, set, append to or delete a paste buffer.
  */
 
-enum cmd_retval	 cmd_set_buffer_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_set_buffer_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_set_buffer_entry = {
-	"set-buffer", "setb",
-	"b:", 1, 1,
-	CMD_BUFFER_USAGE " data",
-	0,
-	NULL,
-	cmd_set_buffer_exec
+	.name = "set-buffer",
+	.alias = "setb",
+
+	.args = { "ab:n:", 0, 1 },
+	.usage = "[-a] " CMD_BUFFER_USAGE " [-n new-buffer-name] data",
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_set_buffer_exec
 };
 
-enum cmd_retval
-cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+const struct cmd_entry cmd_delete_buffer_entry = {
+	.name = "delete-buffer",
+	.alias = "deleteb",
+
+	.args = { "b:", 0, 0 },
+	.usage = CMD_BUFFER_USAGE,
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_set_buffer_exec
+};
+
+static enum cmd_retval
+cmd_set_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	u_int		 limit;
-	char		*pdata, *cause;
-	size_t		 psize;
-	int		 buffer;
+	struct args		*args = self->args;
+	struct paste_buffer	*pb;
+	char			*bufdata, *cause;
+	const char		*bufname, *olddata;
+	size_t			 bufsize, newsize;
 
-	limit = options_get_number(&global_options, "buffer-limit");
+	bufname = args_get(args, 'b');
+	if (bufname == NULL)
+		pb = NULL;
+	else
+		pb = paste_get_name(bufname);
 
-	pdata = xstrdup(args->argv[0]);
-	psize = strlen(pdata);
-
-	if (!args_has(args, 'b')) {
-		paste_add(&global_buffers, pdata, psize, limit);
+	if (self->entry == &cmd_delete_buffer_entry) {
+		if (pb == NULL)
+			pb = paste_get_top(&bufname);
+		if (pb == NULL) {
+			cmdq_error(item, "no buffer");
+			return (CMD_RETURN_ERROR);
+		}
+		paste_free(pb);
 		return (CMD_RETURN_NORMAL);
 	}
 
-	buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
-	if (cause != NULL) {
-		cmdq_error(cmdq, "buffer %s", cause);
-		free(cause);
-		free(pdata);
-		return (CMD_RETURN_ERROR);
+	if (args_has(args, 'n')) {
+		if (pb == NULL)
+			pb = paste_get_top(&bufname);
+		if (pb == NULL) {
+			cmdq_error(item, "no buffer");
+			return (CMD_RETURN_ERROR);
+		}
+		if (paste_rename(bufname, args_get(args, 'n'), &cause) != 0) {
+			cmdq_error(item, "%s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+		return (CMD_RETURN_NORMAL);
 	}
 
-	if (paste_replace(&global_buffers, buffer, pdata, psize) != 0) {
-		cmdq_error(cmdq, "no buffer %d", buffer);
-		free(pdata);
+	if (args->argc != 1) {
+		cmdq_error(item, "no data specified");
+		return (CMD_RETURN_ERROR);
+	}
+	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);
+	memcpy(bufdata + bufsize, args->argv[0], newsize);
+	bufsize += newsize;
+
+	if (paste_set(bufdata, bufsize, bufname, &cause) != 0) {
+		cmdq_error(item, "%s", cause);
+		free(bufdata);
+		free(cause);
 		return (CMD_RETURN_ERROR);
 	}
 

cmd-set-environment.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -27,32 +27,36 @@
  * Set an environment variable.
  */
 
-enum cmd_retval	 cmd_set_environment_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_set_environment_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_set_environment_entry = {
-	"set-environment", "setenv",
-	"grt:u", 1, 2,
-	"[-gru] " CMD_TARGET_SESSION_USAGE " name [value]",
-	0,
-	NULL,
-	cmd_set_environment_exec
+	.name = "set-environment",
+	.alias = "setenv",
+
+	.args = { "grt:u", 1, 2 },
+	.usage = "[-gru] " CMD_TARGET_SESSION_USAGE " name [value]",
+
+	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_set_environment_exec
 };
 
-enum cmd_retval
-cmd_set_environment_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_set_environment_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct session	*s;
 	struct environ	*env;
-	const char	*name, *value;
+	const char	*name, *value, *target;
 
 	name = args->argv[0];
 	if (*name == '\0') {
-		cmdq_error(cmdq, "empty variable name");
+		cmdq_error(item, "empty variable name");
 		return (CMD_RETURN_ERROR);
 	}
 	if (strchr(name, '=') != NULL) {
-		cmdq_error(cmdq, "variable name contains =");
+		cmdq_error(item, "variable name contains =");
 		return (CMD_RETURN_ERROR);
 	}
 
@@ -62,31 +66,37 @@ cmd_set_environment_exec(struct cmd *self, struct cmd_q *cmdq)
 		value = args->argv[1];
 
 	if (args_has(self->args, 'g'))
-		env = &global_environ;
+		env = global_environ;
 	else {
-		if ((s = cmd_find_session(cmdq, args_get(args, 't'), 0)) == NULL)
+		if (item->target.s == NULL) {
+			target = args_get(args, 't');
+			if (target != NULL)
+				cmdq_error(item, "no such session: %s", target);
+			else
+				cmdq_error(item, "no current session");
 			return (CMD_RETURN_ERROR);
-		env = &s->environ;
+		}
+		env = item->target.s->environ;
 	}
 
 	if (args_has(self->args, 'u')) {
 		if (value != NULL) {
-			cmdq_error(cmdq, "can't specify a value with -u");
+			cmdq_error(item, "can't specify a value with -u");
 			return (CMD_RETURN_ERROR);
 		}
 		environ_unset(env, name);
 	} else if (args_has(self->args, 'r')) {
 		if (value != NULL) {
-			cmdq_error(cmdq, "can't specify a value with -r");
+			cmdq_error(item, "can't specify a value with -r");
 			return (CMD_RETURN_ERROR);
 		}
-		environ_set(env, name, NULL);
+		environ_clear(env, name);
 	} else {
 		if (value == NULL) {
-			cmdq_error(cmdq, "no value specified");
+			cmdq_error(item, "no value specified");
 			return (CMD_RETURN_ERROR);
 		}
-		environ_set(env, name, value);
+		environ_set(env, name, "%s", value);
 	}
 
 	return (CMD_RETURN_NORMAL);

cmd-set-hook.c

@@ -0,0 +1,130 @@
+/* $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 <stdlib.h>
+#include <string.h>
+
+#include "tmux.h"
+
+/*
+ * Set or show global or session hooks.
+ */
+
+static enum cmd_retval cmd_set_hook_exec(struct cmd *, struct cmdq_item *);
+
+const struct cmd_entry cmd_set_hook_entry = {
+	.name = "set-hook",
+	.alias = NULL,
+
+	.args = { "gt:u", 1, 2 },
+	.usage = "[-gu] " CMD_TARGET_SESSION_USAGE " hook-name [command]",
+
+	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_set_hook_exec
+};
+
+const struct cmd_entry cmd_show_hooks_entry = {
+	.name = "show-hooks",
+	.alias = NULL,
+
+	.args = { "gt:", 0, 1 },
+	.usage = "[-g] " CMD_TARGET_SESSION_USAGE,
+
+	.target = { 't', CMD_FIND_SESSION, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_set_hook_exec
+};
+
+static enum cmd_retval
+cmd_set_hook_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args	*args = self->args;
+	struct cmd_list	*cmdlist;
+	struct hooks	*hooks;
+	struct hook	*hook;
+	char		*cause, *tmp;
+	const char	*name, *cmd, *target;
+
+	if (args_has(args, 'g'))
+		hooks = global_hooks;
+	else {
+		if (item->target.s == NULL) {
+			target = args_get(args, 't');
+			if (target != NULL)
+				cmdq_error(item, "no such session: %s", target);
+			else
+				cmdq_error(item, "no current session");
+			return (CMD_RETURN_ERROR);
+		}
+		hooks = item->target.s->hooks;
+	}
+
+	if (self->entry == &cmd_show_hooks_entry) {
+		hook = hooks_first(hooks);
+		while (hook != NULL) {
+			tmp = cmd_list_print(hook->cmdlist);
+			cmdq_print(item, "%s -> %s", hook->name, tmp);
+			free(tmp);
+
+			hook = hooks_next(hook);
+		}
+		return (CMD_RETURN_NORMAL);
+	}
+
+	name = args->argv[0];
+	if (*name == '\0') {
+		cmdq_error(item, "invalid hook name");
+		return (CMD_RETURN_ERROR);
+	}
+	if (args->argc < 2)
+		cmd = NULL;
+	else
+		cmd = args->argv[1];
+
+	if (args_has(args, 'u')) {
+		if (cmd != NULL) {
+			cmdq_error(item, "command passed to unset hook: %s",
+			    name);
+			return (CMD_RETURN_ERROR);
+		}
+		hooks_remove(hooks, name);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	if (cmd == NULL) {
+		cmdq_error(item, "no command to set hook: %s", name);
+		return (CMD_RETURN_ERROR);
+	}
+	cmdlist = cmd_string_parse(cmd, NULL, 0, &cause);
+	if (cmdlist == NULL) {
+		if (cause != NULL) {
+			cmdq_error(item, "%s", cause);
+			free(cause);
+		}
+		return (CMD_RETURN_ERROR);
+	}
+	hooks_add(hooks, name, cmdlist);
+	cmd_list_free(cmdlist);
+
+	return (CMD_RETURN_NORMAL);
+}

cmd-set-option.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -27,468 +27,390 @@
  * Set an option.
  */
 
-enum cmd_retval	cmd_set_option_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_set_option_exec(struct cmd *, struct cmdq_item *);
 
-enum cmd_retval	cmd_set_option_user(struct cmd *, struct cmd_q *,
-	    const char *, const char *);
-
-int	cmd_set_option_unset(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-int	cmd_set_option_set(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-
-struct options_entry *cmd_set_option_string(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_number(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_key(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_colour(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_attributes(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_flag(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_choice(struct cmd *, struct cmd_q *,
-	    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 *);
+static int	cmd_set_option_set(struct cmd *, struct cmdq_item *,
+		    struct options *, struct options_entry *, const char *);
+static int	cmd_set_option_flag(struct cmdq_item *,
+		    const struct options_table_entry *, struct options *,
+		    const char *);
+static int	cmd_set_option_choice(struct cmdq_item *,
+		    const struct options_table_entry *, struct options *,
+		    const char *);
 
 const struct cmd_entry cmd_set_option_entry = {
-	"set-option", "set",
-	"agoqst:uw", 1, 2,
-	"[-agosquw] [-t target-session|target-window] option [value]",
-	0,
-	NULL,
-	cmd_set_option_exec
+	.name = "set-option",
+	.alias = "set",
+
+	.args = { "aFgoqst:uw", 1, 2 },
+	.usage = "[-aFgosquw] [-t target-window] option [value]",
+
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_CANFAIL },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_set_option_exec
 };
 
 const struct cmd_entry cmd_set_window_option_entry = {
-	"set-window-option", "setw",
-	"agoqt:u", 1, 2,
-	"[-agoqu] " CMD_TARGET_WINDOW_USAGE " option [value]",
-	0,
-	NULL,
-	cmd_set_option_exec
+	.name = "set-window-option",
+	.alias = "setw",
+
+	.args = { "aFgoqt:u", 1, 2 },
+	.usage = "[-aFgoqu] " CMD_TARGET_WINDOW_USAGE " option [value]",
+
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_CANFAIL },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_set_option_exec
 };
 
-enum cmd_retval
-cmd_set_option_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args				*args = self->args;
-	const struct options_table_entry	*table, *oe;
-	struct session				*s;
-	struct winlink				*wl;
-	struct client				*c;
-	struct options				*oo;
-	struct window				*w;
-	const char				*optstr, *valstr;
-	u_int					 i;
+	struct args			*args = self->args;
+	int				 append = args_has(args, 'a');
+	struct cmd_find_state		*fs = &item->target;
+	struct client			*c, *loop;
+	struct session			*s = fs->s;
+	struct winlink			*wl = fs->wl;
+	struct window			*w;
+	enum options_table_scope	 scope;
+	struct options			*oo;
+	struct options_entry		*parent, *o;
+	char				*name, *argument, *value = NULL, *cause;
+	const char			*target;
+	int				 window, idx, already, error, ambiguous;
 
-	/* Get the option name and value. */
-	optstr = args->argv[0];
-	if (*optstr == '\0') {
-		cmdq_error(cmdq, "invalid option");
-		return (CMD_RETURN_ERROR);
+	/* Expand argument. */
+	c = cmd_find_client(item, NULL, 1);
+	argument = format_single(item, args->argv[0], c, s, wl, NULL);
+
+	/* Parse option name and index. */
+	name = options_match(argument, &idx, &ambiguous);
+	if (name == NULL) {
+		if (args_has(args, 'q'))
+			goto out;
+		if (ambiguous)
+			cmdq_error(item, "ambiguous option: %s", argument);
+		else
+			cmdq_error(item, "invalid option: %s", argument);
+		goto fail;
 	}
 	if (args->argc < 2)
-		valstr = NULL;
+		value = NULL;
+	else if (args_has(args, 'F'))
+		value = format_single(item, args->argv[1], c, s, wl, NULL);
 	else
-		valstr = args->argv[1];
+		value = xstrdup(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) {
-		cmdq_error(cmdq, "ambiguous option: %s", optstr);
-		return (CMD_RETURN_ERROR);
-	}
-	if (oe == NULL) {
-		cmdq_error(cmdq, "unknown option: %s", optstr);
-		return (CMD_RETURN_ERROR);
-	}
-
-	/* Work out the tree from the table. */
-	if (table == server_options_table)
-		oo = &global_options;
-	else if (table == window_options_table) {
-		if (args_has(self->args, 'g'))
-			oo = &global_w_options;
-		else {
-			wl = cmd_find_window(cmdq, args_get(args, 't'), NULL);
-			if (wl == NULL) {
-				cmdq_error(cmdq,
-				    "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);
-			if (s == NULL) {
-				cmdq_error(cmdq,
-				    "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;
-		}
+	/*
+	 * Figure out the scope: for user options it comes from the arguments,
+	 * otherwise from the option name.
+	 */
+	if (*name == '@') {
+		window = (self->entry == &cmd_set_window_option_entry);
+		scope = options_scope_from_flags(args, window, fs, &oo, &cause);
 	} else {
-		cmdq_error(cmdq, "unknown table");
-		return (CMD_RETURN_ERROR);
+		if (options_get_only(global_options, name) != NULL)
+			scope = OPTIONS_TABLE_SERVER;
+		else if (options_get_only(global_s_options, name) != NULL)
+			scope = OPTIONS_TABLE_SESSION;
+		else if (options_get_only(global_w_options, name) != NULL)
+			scope = OPTIONS_TABLE_WINDOW;
+		else {
+			scope = OPTIONS_TABLE_NONE;
+			xasprintf(&cause, "unknown option: %s", argument);
+		}
+	}
+	if (scope == OPTIONS_TABLE_NONE) {
+		if (args_has(args, 'q'))
+			goto out;
+		cmdq_error(item, "%s", cause);
+		free(cause);
+		goto fail;
 	}
 
-	/* Unset or set the option. */
+	/* Which table should this option go into? */
+	if (scope == OPTIONS_TABLE_SERVER)
+		oo = global_options;
+	else if (scope == OPTIONS_TABLE_SESSION) {
+		if (args_has(self->args, 'g'))
+			oo = global_s_options;
+		else if (s == NULL) {
+			target = args_get(args, 't');
+			if (target != NULL)
+				cmdq_error(item, "no such session: %s", target);
+			else
+				cmdq_error(item, "no current session");
+			goto fail;
+		} else
+			oo = s->options;
+	} else if (scope == OPTIONS_TABLE_WINDOW) {
+		if (args_has(self->args, 'g'))
+			oo = global_w_options;
+		else if (wl == NULL) {
+			target = args_get(args, 't');
+			if (target != NULL)
+				cmdq_error(item, "no such window: %s", target);
+			else
+				cmdq_error(item, "no current window");
+			goto fail;
+		} else
+			oo = wl->window->options;
+	}
+	o = options_get_only(oo, name);
+	parent = options_get(oo, name);
+
+	/* Check that array options and indexes match up. */
+	if (idx != -1) {
+		if (*name == '@' || options_array_size(parent, NULL) == -1) {
+			cmdq_error(item, "not an array: %s", argument);
+			goto fail;
+		}
+	}
+
+	/* With -o, check this option is not already set. */
+	if (!args_has(args, 'u') && args_has(args, 'o')) {
+		if (idx == -1)
+			already = (o != NULL);
+		else {
+			if (o == NULL)
+				already = 0;
+			else
+				already = (options_array_get(o, idx) != NULL);
+		}
+		if (already) {
+			if (args_has(args, 'q'))
+				goto out;
+			cmdq_error(item, "already set: %s", argument);
+			goto fail;
+		}
+	}
+
+	/* Change the option. */
 	if (args_has(args, 'u')) {
-		if (cmd_set_option_unset(self, cmdq, oe, oo, valstr) != 0)
-			return (CMD_RETURN_ERROR);
-	} else {
-		if (args_has(args, 'o') && options_find1(oo, optstr) != NULL) {
-			if (!args_has(args, 'q'))
-				cmdq_print(cmdq, "already set: %s", optstr);
-			return (CMD_RETURN_NORMAL);
+		if (o == NULL)
+			goto out;
+		if (idx == -1) {
+			if (*name == '@')
+				options_remove(o);
+			else if (oo == global_options ||
+			    oo == global_s_options ||
+			    oo == global_w_options)
+				options_default(oo, options_table_entry(o));
+			else
+				options_remove(o);
+		} else
+			options_array_set(o, idx, NULL, 0);
+	} else if (*name == '@') {
+		if (value == NULL) {
+			cmdq_error(item, "empty value");
+			goto fail;
+		}
+		options_set_string(oo, name, append, "%s", value);
+	} else if (idx == -1 && options_array_size(parent, NULL) == -1) {
+		error = cmd_set_option_set(self, item, oo, parent, value);
+		if (error != 0)
+			goto fail;
+	} else {
+		if (value == NULL) {
+			cmdq_error(item, "empty value");
+			goto fail;
+		}
+		if (o == NULL)
+			o = options_empty(oo, options_table_entry(parent));
+		if (idx == -1) {
+			if (!append)
+				options_array_clear(o);
+			options_array_assign(o, value);
+		} else if (options_array_set(o, idx, value, append) != 0) {
+			cmdq_error(item, "invalid index: %s", argument);
+			goto fail;
 		}
-		if (cmd_set_option_set(self, cmdq, oe, oo, valstr) != 0)
-			return (CMD_RETURN_ERROR);
 	}
 
-	/* Start or stop timers when automatic-rename changed. */
-	if (strcmp(oe->name, "automatic-rename") == 0) {
-		for (i = 0; i < ARRAY_LENGTH(&windows); i++) {
-			if ((w = ARRAY_ITEM(&windows, i)) == NULL)
+	/* Update timers and so on for various options. */
+	if (strcmp(name, "automatic-rename") == 0) {
+		RB_FOREACH(w, windows, &windows) {
+			if (w->active == NULL)
 				continue;
-			if (options_get_number(&w->options, "automatic-rename"))
-				queue_window_name(w);
-			else if (event_initialized(&w->name_timer))
-				evtimer_del(&w->name_timer);
+			if (options_get_number(w->options, "automatic-rename"))
+				w->active->flags |= PANE_CHANGED;
 		}
 	}
+	if (strcmp(name, "key-table") == 0) {
+		TAILQ_FOREACH(loop, &clients, entry)
+			server_client_set_key_table(loop, NULL);
+	}
+	if (strcmp(name, "user-keys") == 0) {
+		TAILQ_FOREACH(loop, &clients, entry) {
+			if (loop->tty.flags & TTY_OPENED)
+				tty_keys_build(&loop->tty);
+		}
+	}
+	if (strcmp(name, "status") == 0 ||
+	    strcmp(name, "status-interval") == 0)
+		status_timer_start_all();
+	if (strcmp(name, "monitor-silence") == 0)
+		alerts_reset_all();
+	if (strcmp(name, "window-style") == 0 ||
+	    strcmp(name, "window-active-style") == 0) {
+		RB_FOREACH(w, windows, &windows)
+			w->flags |= WINDOW_STYLECHANGED;
+	}
+	if (strcmp(name, "pane-border-status") == 0) {
+		RB_FOREACH(w, windows, &windows)
+			layout_fix_panes(w, w->sx, w->sy);
+	}
+	RB_FOREACH(s, sessions, &sessions)
+		status_update_saved(s);
 
-	/* Update sizes and redraw. May not need it but meh. */
+	/*
+	 * Update sizes and redraw. May not always be necessary but do it
+	 * anyway.
+	 */
 	recalculate_sizes();
-	for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
-		c = ARRAY_ITEM(&clients, i);
-		if (c != NULL && c->session != NULL)
-			server_redraw_client(c);
+	TAILQ_FOREACH(loop, &clients, entry) {
+		if (loop->session != NULL)
+			server_redraw_client(loop);
 	}
 
+out:
+	free(argument);
+	free(value);
+	free(name);
 	return (CMD_RETURN_NORMAL);
+
+fail:
+	free(argument);
+	free(value);
+	free(name);
+	return (CMD_RETURN_ERROR);
 }
 
-/* Set user option. */
-enum cmd_retval
-cmd_set_option_user(struct cmd *self, struct cmd_q *cmdq, const char* optstr,
-    const char *valstr)
+static int
+cmd_set_option_set(struct cmd *self, struct cmdq_item *item, struct options *oo,
+    struct options_entry *parent, const char *value)
 {
-	struct args	*args = self->args;
-	struct session	*s;
-	struct winlink	*wl;
-	struct options	*oo;
+	const struct options_table_entry	*oe;
+	struct args				*args = self->args;
+	int					 append = args_has(args, 'a');
+	struct options_entry			*o;
+	long long				 number;
+	const char				*errstr;
+	key_code				 key;
 
-	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) {
-			cmdq_error(cmdq, "unknown option: %s", optstr);
-			return (CMD_RETURN_ERROR);
-		}
-		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_print(cmdq, "already set: %s", optstr);
-			return (CMD_RETURN_NORMAL);
-		}
-		options_set_string(oo, optstr, "%s", valstr);
-		if (!args_has(args, 'q')) {
-			cmdq_info(cmdq, "set option: %s -> %s", optstr,
-			    valstr);
-		}
-	}
-	return (CMD_RETURN_NORMAL);
-}
-
-
-/* Unset an option. */
-int
-cmd_set_option_unset(struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo, const char *value)
-{
-	struct args	*args = self->args;
-
-	if (args_has(args, 'g')) {
-		cmdq_error(cmdq, "can't unset global option: %s", oe->name);
-		return (-1);
-	}
-	if (value != NULL) {
-		cmdq_error(cmdq, "value passed to unset option: %s", oe->name);
+	oe = options_table_entry(parent);
+	if (value == NULL &&
+	    oe->type != OPTIONS_TABLE_FLAG &&
+	    oe->type != OPTIONS_TABLE_CHOICE) {
+		cmdq_error(item, "empty value");
 		return (-1);
 	}
 
-	options_remove(oo, oe->name);
-	if (!args_has(args, 'q'))
-		cmdq_info(cmdq, "unset option: %s", oe->name);
-	return (0);
-}
-
-/* Set an option. */
-int
-cmd_set_option_set(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;
-	const char		*s;
-
-	if (oe->type != OPTIONS_TABLE_FLAG && 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);
-		break;
+		options_set_string(oo, oe->name, append, "%s", value);
+		return (0);
 	case OPTIONS_TABLE_NUMBER:
-		o = cmd_set_option_number(self, cmdq, oe, oo, value);
-		break;
+		number = strtonum(value, oe->minimum, oe->maximum, &errstr);
+		if (errstr != NULL) {
+			cmdq_error(item, "value is %s: %s", errstr, value);
+			return (-1);
+		}
+		options_set_number(oo, oe->name, number);
+		return (0);
 	case OPTIONS_TABLE_KEY:
-		o = cmd_set_option_key(self, cmdq, oe, oo, value);
-		break;
+		key = key_string_lookup_string(value);
+		if (key == KEYC_UNKNOWN) {
+			cmdq_error(item, "bad key: %s", value);
+			return (-1);
+		}
+		options_set_number(oo, oe->name, key);
+		return (0);
 	case OPTIONS_TABLE_COLOUR:
-		o = cmd_set_option_colour(self, cmdq, oe, oo, value);
-		if (o != NULL)
-			style_update_new(oo, o->name, oe->style);
-		break;
+		if ((number = colour_fromstring(value)) == -1) {
+			cmdq_error(item, "bad colour: %s", value);
+			return (-1);
+		}
+		o = options_set_number(oo, oe->name, number);
+		options_style_update_new(oo, o);
+		return (0);
 	case OPTIONS_TABLE_ATTRIBUTES:
-		o = cmd_set_option_attributes(self, cmdq, oe, oo, value);
-		if (o != NULL)
-			style_update_new(oo, o->name, oe->style);
-		break;
+		if ((number = attributes_fromstring(value)) == -1) {
+			cmdq_error(item, "bad attributes: %s", value);
+			return (-1);
+		}
+		o = options_set_number(oo, oe->name, number);
+		options_style_update_new(oo, o);
+		return (0);
 	case OPTIONS_TABLE_FLAG:
-		o = cmd_set_option_flag(self, cmdq, oe, oo, value);
-		break;
+		return (cmd_set_option_flag(item, oe, oo, value));
 	case OPTIONS_TABLE_CHOICE:
-		o = cmd_set_option_choice(self, cmdq, oe, oo, value);
-		break;
+		return (cmd_set_option_choice(item, oe, oo, value));
 	case OPTIONS_TABLE_STYLE:
-		o = cmd_set_option_style(self, cmdq, oe, oo, value);
+		o = options_set_style(oo, oe->name, append, value);
+		if (o == NULL) {
+			cmdq_error(item, "bad style: %s", value);
+			return (-1);
+		}
+		options_style_update_old(oo, o);
+		return (0);
+	case OPTIONS_TABLE_ARRAY:
 		break;
 	}
-	if (o == NULL)
-		return (-1);
-
-	s = options_table_print_entry(oe, o, 0);
-	if (!args_has(args, 'q'))
-		cmdq_info(cmdq, "set option: %s -> %s", oe->name, s);
-	return (0);
+	return (-1);
 }
 
-/* Set a string option. */
-struct options_entry *
-cmd_set_option_string(struct cmd *self, unused 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;
-	char			*oldval, *newval;
-
-	if (args_has(args, 'a')) {
-		oldval = options_get_string(oo, oe->name);
-		xasprintf(&newval, "%s%s", oldval, value);
-	} else
-		newval = xstrdup(value);
-
-	o = options_set_string(oo, oe->name, "%s", newval);
-
-	free(newval);
-	return (o);
-}
-
-/* Set a number option. */
-struct options_entry *
-cmd_set_option_number(unused struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo, 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);
-		return (NULL);
-	}
-
-	return (options_set_number(oo, oe->name, ll));
-}
-
-/* Set a key option. */
-struct options_entry *
-cmd_set_option_key(unused struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo, const char *value)
-{
-	int	key;
-
-	if ((key = key_string_lookup_string(value)) == KEYC_NONE) {
-		cmdq_error(cmdq, "bad key: %s", value);
-		return (NULL);
-	}
-
-	return (options_set_number(oo, oe->name, key));
-}
-
-/* Set a colour option. */
-struct options_entry *
-cmd_set_option_colour(unused struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo, const char *value)
-{
-	int	colour;
-
-	if ((colour = colour_fromstring(value)) == -1) {
-		cmdq_error(cmdq, "bad colour: %s", value);
-		return (NULL);
-	}
-
-	return (options_set_number(oo, oe->name, colour));
-}
-
-/* Set an attributes option. */
-struct options_entry *
-cmd_set_option_attributes(unused struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo, const char *value)
-{
-	int	attr;
-
-	if ((attr = attributes_fromstring(value)) == -1) {
-		cmdq_error(cmdq, "bad attributes: %s", value);
-		return (NULL);
-	}
-
-	return (options_set_number(oo, oe->name, attr));
-}
-
-/* Set a flag option. */
-struct options_entry *
-cmd_set_option_flag(unused struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo, const char *value)
+static int
+cmd_set_option_flag(struct cmdq_item *item,
+    const struct options_table_entry *oe, struct options *oo,
+    const char *value)
 {
 	int	flag;
 
 	if (value == NULL || *value == '\0')
 		flag = !options_get_number(oo, oe->name);
+	else if (strcmp(value, "1") == 0 ||
+	    strcasecmp(value, "on") == 0 ||
+	    strcasecmp(value, "yes") == 0)
+		flag = 1;
+	else if (strcmp(value, "0") == 0 ||
+	    strcasecmp(value, "off") == 0 ||
+	    strcasecmp(value, "no") == 0)
+		flag = 0;
 	else {
-		if ((value[0] == '1' && value[1] == '\0') ||
-		    strcasecmp(value, "on") == 0 ||
-		    strcasecmp(value, "yes") == 0)
-			flag = 1;
-		else if ((value[0] == '0' && value[1] == '\0') ||
-		    strcasecmp(value, "off") == 0 ||
-		    strcasecmp(value, "no") == 0)
-			flag = 0;
-		else {
-			cmdq_error(cmdq, "bad value: %s", value);
-			return (NULL);
-		}
+		cmdq_error(item, "bad value: %s", value);
+		return (-1);
 	}
-
-	return (options_set_number(oo, oe->name, flag));
+	options_set_number(oo, oe->name, flag);
+	return (0);
 }
 
-/* Set a choice option. */
-struct options_entry *
-cmd_set_option_choice(unused struct cmd *self, struct cmd_q *cmdq,
+static int
+cmd_set_option_choice(struct cmdq_item *item,
     const struct options_table_entry *oe, struct options *oo,
     const char *value)
 {
-	const char	**choicep;
+	const char	**cp;
 	int		  n, choice = -1;
 
-	n = 0;
-	for (choicep = oe->choices; *choicep != NULL; choicep++) {
-		n++;
-		if (strncmp(*choicep, value, strlen(value)) != 0)
-			continue;
-
-		if (choice != -1) {
-			cmdq_error(cmdq, "ambiguous value: %s", value);
-			return (NULL);
+	if (value == NULL) {
+		choice = options_get_number(oo, oe->name);
+		if (choice < 2)
+			choice = !choice;
+	} else {
+		n = 0;
+		for (cp = oe->choices; *cp != NULL; cp++) {
+			if (strcmp(*cp, value) == 0)
+				choice = n;
+			n++;
+		}
+		if (choice == -1) {
+			cmdq_error(item, "unknown value: %s", value);
+			return (-1);
 		}
-		choice = n - 1;
 	}
-	if (choice == -1) {
-		cmdq_error(cmdq, "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);
+	options_set_number(oo, oe->name, choice);
+	return (0);
 }

cmd-show-environment.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -27,52 +27,110 @@
  * Show environment.
  */
 
-enum cmd_retval	 cmd_show_environment_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_show_environment_exec(struct cmd *,
+			    struct cmdq_item *);
+
+static char	*cmd_show_environment_escape(struct environ_entry *);
+static void	 cmd_show_environment_print(struct cmd *, struct cmdq_item *,
+		     struct environ_entry *);
 
 const struct cmd_entry cmd_show_environment_entry = {
-	"show-environment", "showenv",
-	"gt:", 0, 1,
-	"[-g] " CMD_TARGET_SESSION_USAGE " [name]",
-	0,
-	NULL,
-	cmd_show_environment_exec
+	.name = "show-environment",
+	.alias = "showenv",
+
+	.args = { "gst:", 0, 1 },
+	.usage = "[-gs] " CMD_TARGET_SESSION_USAGE " [name]",
+
+	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_show_environment_exec
 };
 
-enum cmd_retval
-cmd_show_environment_exec(struct cmd *self, struct cmd_q *cmdq)
+static char *
+cmd_show_environment_escape(struct environ_entry *envent)
+{
+	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);
+}
+
+static void
+cmd_show_environment_print(struct cmd *self, struct cmdq_item *item,
+    struct environ_entry *envent)
+{
+	char	*escaped;
+
+	if (!args_has(self->args, 's')) {
+		if (envent->value != NULL)
+			cmdq_print(item, "%s=%s", envent->name, envent->value);
+		else
+			cmdq_print(item, "-%s", envent->name);
+		return;
+	}
+
+	if (envent->value != NULL) {
+		escaped = cmd_show_environment_escape(envent);
+		cmdq_print(item, "%s=\"%s\"; export %s;", envent->name, escaped,
+		    envent->name);
+		free(escaped);
+	} else
+		cmdq_print(item, "unset %s;", envent->name);
+}
+
+static enum cmd_retval
+cmd_show_environment_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct session		*s;
 	struct environ		*env;
 	struct environ_entry	*envent;
+	const char		*target;
+
+	if ((target = args_get(args, 't')) != NULL) {
+		if (item->target.s == NULL) {
+			cmdq_error(item, "no such session: %s", target);
+			return (CMD_RETURN_ERROR);
+		}
+	}
 
 	if (args_has(self->args, 'g'))
-		env = &global_environ;
+		env = global_environ;
 	else {
-		if ((s = cmd_find_session(cmdq, args_get(args, 't'), 0)) == NULL)
+		if (item->target.s == NULL) {
+			target = args_get(args, 't');
+			if (target != NULL)
+				cmdq_error(item, "no such session: %s", target);
+			else
+				cmdq_error(item, "no current session");
 			return (CMD_RETURN_ERROR);
-		env = &s->environ;
+		}
+		env = item->target.s->environ;
 	}
 
 	if (args->argc != 0) {
 		envent = environ_find(env, args->argv[0]);
 		if (envent == NULL) {
-			cmdq_error(cmdq, "unknown variable: %s", args->argv[0]);
+			cmdq_error(item, "unknown variable: %s", args->argv[0]);
 			return (CMD_RETURN_ERROR);
 		}
-		if (envent->value != NULL)
-			cmdq_print(cmdq, "%s=%s", envent->name, envent->value);
-		else
-			cmdq_print(cmdq, "-%s", envent->name);
+		cmd_show_environment_print(self, item, envent);
 		return (CMD_RETURN_NORMAL);
 	}
 
-	RB_FOREACH(envent, environ, env) {
-		if (envent->value != NULL)
-			cmdq_print(cmdq, "%s=%s", envent->name, envent->value);
-		else
-			cmdq_print(cmdq, "-%s", envent->name);
+	envent = environ_first(env);
+	while (envent != NULL) {
+		cmd_show_environment_print(self, item, envent);
+		envent = environ_next(envent);
 	}
-
 	return (CMD_RETURN_NORMAL);
 }

cmd-show-messages.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -28,142 +28,92 @@
  * Show client message log.
  */
 
-enum cmd_retval	 cmd_show_messages_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_show_messages_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_show_messages_entry = {
-	"show-messages", "showmsgs",
-	"IJTt:", 0, 0,
-	"[-IJT] " CMD_TARGET_CLIENT_USAGE,
-	0,
-	NULL,
-	cmd_show_messages_exec
+	.name = "show-messages",
+	.alias = "showmsgs",
+
+	.args = { "JTt:", 0, 0 },
+	.usage = "[-JT] " CMD_TARGET_CLIENT_USAGE,
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_show_messages_exec
 };
 
-const struct cmd_entry cmd_server_info_entry = {
-	"server-info", "info",
-	"", 0, 0,
-	"",
-	0,
-	NULL,
-	cmd_show_messages_exec
-};
+static int	cmd_show_messages_terminals(struct cmdq_item *, int);
+static int	cmd_show_messages_jobs(struct cmdq_item *, int);
 
-void	cmd_show_messages_server(struct cmd_q *);
-void	cmd_show_messages_terminals(struct cmd_q *);
-void	cmd_show_messages_jobs(struct cmd_q *);
-
-void
-cmd_show_messages_server(struct cmd_q *cmdq)
+static int
+cmd_show_messages_terminals(struct cmdq_item *item, int blank)
 {
-	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);
-}
-
-void
-cmd_show_messages_terminals(struct cmd_q *cmdq)
-{
-	struct tty_term				*term;
-	const struct tty_term_code_entry	*ent;
-	struct tty_code				*code;
-	u_int					 i, n;
-	char					 out[80];
+	struct tty_term	*term;
+	u_int		 i, n;
 
 	n = 0;
 	LIST_FOREACH(term, &tty_terms, entry) {
-		cmdq_print(cmdq,
-		    "Terminal %u: %s [references=%u, flags=0x%x]:",
+		if (blank) {
+			cmdq_print(item, "%s", "");
+			blank = 0;
+		}
+		cmdq_print(item, "Terminal %u: %s [references=%u, flags=0x%x]:",
 		    n, term->name, term->references, term->flags);
 		n++;
-		for (i = 0; i < NTTYCODE; i++) {
-			ent = &tty_term_codes[i];
-			code = &term->codes[ent->code];
-			switch (code->type) {
-			case TTYCODE_NONE:
-				cmdq_print(cmdq, "%4u: %s: [missing]",
-				    ent->code, ent->name);
-				break;
-			case TTYCODE_STRING:
-				strnvis(out, code->value.string, sizeof out,
-				    VIS_OCTAL|VIS_TAB|VIS_NL);
-				cmdq_print(cmdq, "%4u: %s: (string) %s",
-				    ent->code, ent->name, out);
-				break;
-			case TTYCODE_NUMBER:
-				cmdq_print(cmdq, "%4u: %s: (number) %d",
-				    ent->code, ent->name, code->value.number);
-				break;
-			case TTYCODE_FLAG:
-				cmdq_print(cmdq, "%4u: %s: (flag) %s",
-				    ent->code, ent->name,
-				    code->value.flag ? "true" : "false");
-				break;
-			}
-		}
+		for (i = 0; i < tty_term_ncodes(); i++)
+			cmdq_print(item, "%s", tty_term_describe(term, i));
 	}
+	return (n != 0);
 }
 
-void
-cmd_show_messages_jobs(struct cmd_q *cmdq)
+static int
+cmd_show_messages_jobs(struct cmdq_item *item, int blank)
 {
 	struct job	*job;
 	u_int		 n;
 
 	n = 0;
-	LIST_FOREACH(job, &all_jobs, lentry) {
-		cmdq_print(cmdq,
-		    "Job %u: %s [fd=%d, pid=%d, status=%d]",
-		    n, job->cmd, job->fd, job->pid, job->status);
+	LIST_FOREACH(job, &all_jobs, entry) {
+		if (blank) {
+			cmdq_print(item, "%s", "");
+			blank = 0;
+		}
+		cmdq_print(item, "Job %u: %s [fd=%d, pid=%ld, status=%d]",
+		    n, job->cmd, job->fd, (long)job->pid, job->status);
 		n++;
 	}
+	return (n != 0);
 }
 
-enum cmd_retval
-cmd_show_messages_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_show_messages_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct client		*c;
 	struct message_entry	*msg;
 	char			*tim;
-	u_int			 i;
-	int			 done;
+	int			 done, blank;
 
-	done = 0;
-	if (args_has(args, 'I') || self->entry == &cmd_server_info_entry) {
-		cmd_show_messages_server(cmdq);
+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+
+	done = blank = 0;
+	if (args_has(args, 'T')) {
+		blank = cmd_show_messages_terminals(item, blank);
 		done = 1;
 	}
-	if (args_has(args, 'T') || self->entry == &cmd_server_info_entry) {
-		if (done)
-			cmdq_print(cmdq, "%s", "");
-		cmd_show_messages_terminals(cmdq);
-		done = 1;
-	}
-	if (args_has(args, 'J') || self->entry == &cmd_server_info_entry) {
-		if (done)
-			cmdq_print(cmdq, "%s", "");
-		cmd_show_messages_jobs(cmdq);
+	if (args_has(args, 'J')) {
+		cmd_show_messages_jobs(item, blank);
 		done = 1;
 	}
 	if (done)
 		return (CMD_RETURN_NORMAL);
 
-	if ((c = cmd_find_client(cmdq, args_get(args, 't'), 0)) == NULL)
-		return (CMD_RETURN_ERROR);
-
-	for (i = 0; i < ARRAY_LENGTH(&c->message_log); i++) {
-		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);
+		cmdq_print(item, "%s %s", tim, msg->msg);
 	}
 
 	return (CMD_RETURN_NORMAL);

cmd-show-options.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -27,145 +27,164 @@
  * Show options.
  */
 
-enum cmd_retval	 cmd_show_options_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_show_options_exec(struct cmd *, struct cmdq_item *);
 
-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 *);
+static enum cmd_retval	cmd_show_options_one(struct cmd *, struct cmdq_item *,
+			    struct options *);
+static enum cmd_retval	cmd_show_options_all(struct cmd *, struct cmdq_item *,
+		    	    struct options *);
 
 const struct cmd_entry cmd_show_options_entry = {
-	"show-options", "show",
-	"gqst:vw", 0, 1,
-	"[-gqsvw] [-t target-session|target-window] [option]",
-	0,
-	NULL,
-	cmd_show_options_exec
+	.name = "show-options",
+	.alias = "show",
+
+	.args = { "gqst:vw", 0, 1 },
+	.usage = "[-gqsvw] [-t target-session|target-window] [option]",
+
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_CANFAIL },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_show_options_exec
 };
 
 const struct cmd_entry cmd_show_window_options_entry = {
-	"show-window-options", "showw",
-	"gvt:", 0, 1,
-	"[-gv] " CMD_TARGET_WINDOW_USAGE " [option]",
-	0,
-	NULL,
-	cmd_show_options_exec
+	.name = "show-window-options",
+	.alias = "showw",
+
+	.args = { "gvt:", 0, 1 },
+	.usage = "[-gv] " CMD_TARGET_WINDOW_USAGE " [option]",
+
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_CANFAIL },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_show_options_exec
 };
 
-enum cmd_retval
-cmd_show_options_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_show_options_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args				*args = self->args;
-	struct session				*s;
-	struct winlink				*wl;
-	const struct options_table_entry	*table;
-	struct options				*oo;
-	int					 quiet;
+	struct args			*args = self->args;
+	struct cmd_find_state		*fs = &item->target;
+	struct options			*oo;
+	enum options_table_scope	 scope;
+	char				*cause;
+	int				 window;
 
-	if (args_has(self->args, 's')) {
-		oo = &global_options;
-		table = server_options_table;
-	} else if (args_has(self->args, 'w') ||
-	    self->entry == &cmd_show_window_options_entry) {
-		table = window_options_table;
-		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 {
-		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);
-			if (s == NULL)
-				return (CMD_RETURN_ERROR);
-			oo = &s->options;
-		}
+	window = (self->entry == &cmd_show_window_options_entry);
+	scope = options_scope_from_flags(args, window, fs, &oo, &cause);
+	if (scope == OPTIONS_TABLE_NONE) {
+		cmdq_error(item, "%s", cause);
+		free(cause);
+		return (CMD_RETURN_ERROR);
 	}
 
-	quiet = args_has(self->args, 'q');
 	if (args->argc == 0)
-		return (cmd_show_options_all(self, cmdq, table, oo));
+		return (cmd_show_options_all(self, item, oo));
 	else
-		return (cmd_show_options_one(self, cmdq, oo, quiet));
+		return (cmd_show_options_one(self, item, oo));
 }
 
-enum cmd_retval
-cmd_show_options_one(struct cmd *self, struct cmd_q *cmdq,
-    struct options *oo, int quiet)
+static void
+cmd_show_options_print(struct cmd *self, struct cmdq_item *item,
+    struct options_entry *o, int idx)
 {
-	struct args				*args = self->args;
-	const struct options_table_entry	*table, *oe;
-	struct options_entry			*o;
-	const char				*optval;
+	const char	*name;
+	const char	*value;
+	char		*tmp, *escaped;
+	u_int		 size, i;
 
-	if (*args->argv[0] == '@') {
-		if ((o = options_find1(oo, args->argv[0])) == NULL) {
-			if (quiet)
-				return (CMD_RETURN_NORMAL);
-			cmdq_error(cmdq, "unknown option: %s", args->argv[0]);
+	if (idx != -1) {
+		xasprintf(&tmp, "%s[%d]", options_name(o), idx);
+		name = tmp;
+	} else {
+		if (options_array_size(o, &size) != -1) {
+			for (i = 0; i < size; i++) {
+				if (options_array_get(o, i) == NULL)
+					continue;
+				cmd_show_options_print(self, item, o, i);
+			}
+			return;
+		}
+		tmp = NULL;
+		name = options_name(o);
+	}
+
+	value = options_tostring(o, idx, 0);
+	if (args_has(self->args, 'v'))
+		cmdq_print(item, "%s", value);
+	else if (options_isstring(o)) {
+		utf8_stravis(&escaped, value, VIS_OCTAL|VIS_TAB|VIS_NL|VIS_DQ);
+		cmdq_print(item, "%s \"%s\"", name, escaped);
+		free(escaped);
+	} else
+		cmdq_print(item, "%s %s", name, value);
+
+	free(tmp);
+}
+
+static enum cmd_retval
+cmd_show_options_one(struct cmd *self, struct cmdq_item *item,
+    struct options *oo)
+{
+	struct args		*args = self->args;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	struct options_entry	*o;
+	int			 idx, ambiguous;
+	char			*name;
+
+	name = format_single(item, args->argv[0], c, s, wl, NULL);
+	o = options_match_get(oo, name, &idx, 1, &ambiguous);
+	if (o == NULL) {
+		if (args_has(args, 'q')) {
+			free(name);
+			return (CMD_RETURN_NORMAL);
+		}
+		if (ambiguous) {
+			cmdq_error(item, "ambiguous option: %s", name);
+			free(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(args->argv[0], &table, &oe) != 0) {
-		cmdq_error(cmdq, "ambiguous option: %s", args->argv[0]);
-		return (CMD_RETURN_ERROR);
-	}
-	if (oe == NULL) {
-		if (quiet)
-		    return (CMD_RETURN_NORMAL);
-		cmdq_error(cmdq, "unknown option: %s", args->argv[0]);
-		return (CMD_RETURN_ERROR);
-	}
-	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);
+		if (*name != '@' &&
+		    options_match_get(oo, name, &idx, 0, &ambiguous) != NULL) {
+			free(name);
+			return (CMD_RETURN_NORMAL);
 		}
+		cmdq_error(item, "unknown option: %s", name);
+		free(name);
+		return (CMD_RETURN_ERROR);
+	}
+	cmd_show_options_print(self, item, o, idx);
+	free(name);
+	return (CMD_RETURN_NORMAL);
+}
+
+static enum cmd_retval
+cmd_show_options_all(struct cmd *self, struct cmdq_item *item,
+    struct options *oo)
+{
+	struct options_entry			 *o;
+	const struct options_table_entry	*oe;
+	u_int					 size, idx;
+
+	o = options_first(oo);
+	while (o != NULL) {
+		oe = options_table_entry(o);
+		if (oe != NULL && oe->style != NULL) {
+			o = options_next(o);
+			continue;
+		}
+		if (options_array_size(o, &size) == -1)
+			cmd_show_options_print(self, item, o, -1);
+		else {
+			for (idx = 0; idx < size; idx++) {
+				if (options_array_get(o, idx) == NULL)
+					continue;
+				cmd_show_options_print(self, item, o, idx);
+			}
+		}
+		o = options_next(o);
 	}
-
-	for (oe = table; oe->name != NULL; oe++) {
-		if ((o = options_find1(oo, oe->name)) == NULL)
-			continue;
-		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);
 }

cmd-source-file.c

@@ -1,4 +1,4 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
  * Copyright (c) 2008 Tiago Cunha <me@tiagocunha.org>
@@ -18,7 +18,10 @@
 
 #include <sys/types.h>
 
+#include <errno.h>
+#include <glob.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "tmux.h"
 
@@ -26,86 +29,70 @@
  * Sources a configuration file.
  */
 
-enum cmd_retval	cmd_source_file_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_source_file_exec(struct cmd *, struct cmdq_item *);
 
-void		cmd_source_file_show(struct cmd_q *);
-void		cmd_source_file_done(struct cmd_q *);
+static enum cmd_retval	cmd_source_file_done(struct cmdq_item *, void *);
 
 const struct cmd_entry cmd_source_file_entry = {
-	"source-file", "source",
-	"", 1, 1,
-	"path",
-	0,
-	NULL,
-	cmd_source_file_exec
+	.name = "source-file",
+	.alias = "source",
+
+	.args = { "q", 1, 1 },
+	.usage = "[-q] path",
+
+	.flags = 0,
+	.exec = cmd_source_file_exec
 };
 
-enum cmd_retval
-cmd_source_file_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	struct cmd_q	*cmdq1;
-	char		*cause;
+	struct args		*args = self->args;
+	int			 quiet = args_has(args, 'q');
+	struct client		*c = item->client;
+	struct cmdq_item	*new_item;
+	enum cmd_retval		 retval;
+	char			*pattern, *tmp;
+	const char		*path = args->argv[0];
+	glob_t			 g;
+	u_int			 i;
 
-	cmdq1 = cmdq_new(NULL);
-	cmdq1->client = cmdq->client;
-	cmdq1->emptyfn = cmd_source_file_done;
-	cmdq1->data = cmdq;
+	if (*path == '/')
+		pattern = xstrdup(path);
+	else {
+		utf8_stravis(&tmp, server_client_get_cwd(c), VIS_GLOB);
+		xasprintf(&pattern, "%s/%s", tmp, path);
+		free(tmp);
+	}
+	log_debug("%s: %s", __func__, pattern);
 
-	switch (load_cfg(args->argv[0], cmdq1, &cause)) {
-	case -1:
-		if (cfg_references == 0) {
-			cmdq_free(cmdq1);
-			cmdq_error(cmdq, "%s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
+	retval = CMD_RETURN_NORMAL;
+	if (glob(pattern, 0, NULL, &g) != 0) {
+		if (!quiet || errno != ENOENT) {
+			cmdq_error(item, "%s: %s", path, strerror(errno));
+			retval = CMD_RETURN_ERROR;
 		}
-		ARRAY_ADD(&cfg_causes, cause);
-		/* FALLTHROUGH */
-	case 0:
-		if (cfg_references == 0)
-			cmd_source_file_show(cmdq);
-		cmdq_free(cmdq1);
-		return (CMD_RETURN_NORMAL);
+		free(pattern);
+		return (retval);
+	}
+	free(pattern);
+
+	for (i = 0; i < (u_int)g.gl_pathc; i++) {
+		if (load_cfg(g.gl_pathv[i], c, item, quiet) < 0)
+			retval = CMD_RETURN_ERROR;
+	}
+	if (cfg_finished) {
+		new_item = cmdq_get_callback(cmd_source_file_done, NULL);
+		cmdq_insert_after(item, new_item);
 	}
 
-	cmdq->references++;
-	cfg_references++;
-
-	cmdq_continue(cmdq1);
-	return (CMD_RETURN_WAIT);
+	globfree(&g);
+	return (retval);
 }
 
-void
-cmd_source_file_show(struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_source_file_done(struct cmdq_item *item, __unused void *data)
 {
-	u_int	 i;
-	char	*cause;
-
-	for (i = 0; i < ARRAY_LENGTH(&cfg_causes); i++) {
-		cause = ARRAY_ITEM(&cfg_causes, i);
-		cmdq_print(cmdq, "%s", cause);
-		free(cause);
-	}
-	ARRAY_FREE(&cfg_causes);
-}
-
-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)
-		cmd_source_file_show(cmdq);
-	cmdq_continue(cmdq);
+	cfg_print_causes(item);
+	return (CMD_RETURN_NORMAL);
 }

cmd-split-window.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -30,89 +30,72 @@
  * Split a window (add a new pane).
  */
 
-void		 cmd_split_window_key_binding(struct cmd *, int);
-enum cmd_retval	 cmd_split_window_exec(struct cmd *, struct cmd_q *);
+#define SPLIT_WINDOW_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"
+
+static enum cmd_retval	cmd_split_window_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_split_window_entry = {
-	"split-window", "splitw",
-	"c:dF:l:hp:Pt:v", 0, 1,
-	"[-dhvP] [-c start-directory] [-F format] [-p percentage|-l size] "
-	CMD_TARGET_PANE_USAGE " [command]",
-	0,
-	cmd_split_window_key_binding,
-	cmd_split_window_exec
+	.name = "split-window",
+	.alias = "splitw",
+
+	.args = { "bc:dfF:l:hp:Pt:v", 0, -1 },
+	.usage = "[-bdfhvP] [-c start-directory] [-F format] "
+		 "[-p percentage|-l size] " CMD_TARGET_PANE_USAGE " [command]",
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = 0,
+	.exec = cmd_split_window_exec
 };
 
-void
-cmd_split_window_key_binding(struct cmd *self, int key)
-{
-	self->args = args_create(0);
-	if (key == '%')
-		args_set(self->args, 'h', NULL);
-}
-
-enum cmd_retval
-cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 {
+	struct cmd_find_state	*current = &item->shared->current;
 	struct args		*args = self->args;
-	struct session		*s;
-	struct winlink		*wl;
-	struct window		*w;
-	struct window_pane	*wp, *new_wp = NULL;
-	struct environ		 env;
-	const char		*cmd, *shell, *template;
-	char			*cause, *new_cause, *cp;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	struct window		*w = wl->window;
+	struct window_pane	*wp = item->target.wp, *new_wp = NULL;
+	struct environ		*env;
+	const char		*cmd, *path, *shell, *template, *tmp;
+	char		       **argv, *cause, *new_cause, *cp, *cwd;
 	u_int			 hlimit;
-	int			 size, percentage, cwd, fd = -1;
+	int			 argc, size, percentage, before;
 	enum layout_type	 type;
 	struct layout_cell	*lc;
-	struct client		*c;
-	struct format_tree	*ft;
+	struct environ_entry	*envent;
+	struct cmd_find_state    fs;
 
-	if ((wl = cmd_find_pane(cmdq, args_get(args, 't'), &s, &wp)) == NULL)
-		return (CMD_RETURN_ERROR);
-	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) {
+		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->argc == 0)
-		cmd = options_get_string(&s->options, "default-command");
+	if ((tmp = args_get(args, 'c')) != NULL)
+		cwd = format_single(item, tmp, c, s, NULL, NULL);
+	else if (item->client != NULL && item->client->session == NULL)
+		cwd = xstrdup(item->client->cwd);
 	else
-		cmd = args->argv[0];
-
-	if (args_has(args, 'c')) {
-		ft = format_create();
-		if ((c = cmd_find_client(cmdq, NULL, 1)) != NULL)
-			format_client(ft, c);
-		format_session(ft, s);
-		format_winlink(ft, s, s->curw);
-		format_window_pane(ft, s->curw->window->active);
-		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;
+		cwd = xstrdup(s->cwd);
 
 	type = LAYOUT_TOPBOTTOM;
 	if (args_has(args, 'h'))
 		type = LAYOUT_LEFTRIGHT;
+	before = args_has(args, 'b');
 
 	size = -1;
 	if (args_has(args, 'l')) {
@@ -136,63 +119,70 @@ cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
 		else
 			size = (wp->sx * percentage) / 100;
 	}
-	hlimit = options_get_number(&s->options, "history-limit");
+	hlimit = options_get_number(s->options, "history-limit");
 
-	shell = options_get_string(&s->options, "default-shell");
+	shell = options_get_string(s->options, "default-shell");
 	if (*shell == '\0' || areshell(shell))
 		shell = _PATH_BSHELL;
 
-	if ((lc = layout_split_pane(wp, type, size, 0)) == NULL) {
+	lc = layout_split_pane(wp, type, size, before, args_has(args, 'f'));
+	if (lc == NULL) {
 		cause = xstrdup("pane too small");
 		goto error;
 	}
-	new_wp = window_add_pane(w, hlimit);
-	if (window_pane_spawn(
-	    new_wp, cmd, shell, cwd, &env, s->tio, &cause) != 0)
-		goto error;
-	layout_assign_pane(lc, new_wp);
+	new_wp = window_add_pane(w, wp, before, args_has(args, 'f'), hlimit);
+	layout_make_leaf(lc, new_wp);
 
+	path = NULL;
+	if (item->client != NULL && item->client->session == NULL)
+		envent = environ_find(item->client->environ, "PATH");
+	else
+		envent = environ_find(s->environ, "PATH");
+	if (envent != NULL)
+		path = envent->value;
+
+	env = environ_for_session(s, 0);
+	if (window_pane_spawn(new_wp, argc, argv, path, shell, cwd, env,
+	    s->tio, &cause) != 0) {
+		environ_free(env);
+		goto error;
+	}
+	environ_free(env);
+
+	layout_fix_panes(w, w->sx, w->sy);
 	server_redraw_window(w);
 
 	if (!args_has(args, 'd')) {
 		window_set_active_pane(w, new_wp);
 		session_select(s, wl->idx);
+		cmd_find_from_session(current, s, 0);
 		server_redraw_session(s);
 	} else
 		server_status_session(s);
 
-	environ_free(&env);
-
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = SPLIT_WINDOW_TEMPLATE;
-
-		ft = format_create();
-		if ((c = cmd_find_client(cmdq, NULL, 1)) != NULL)
-			format_client(ft, c);
-		format_session(ft, s);
-		format_winlink(ft, s, wl);
-		format_window_pane(ft, new_wp);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
+		cp = format_single(item, template, c, s, wl, new_wp);
+		cmdq_print(item, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}
-	notify_window_layout_changed(w);
+	notify_window("window-layout-changed", w);
 
-	if (fd != -1)
-		close(fd);
+	cmd_find_from_winlink_pane(&fs, wl, new_wp, 0);
+	hooks_insert(s->hooks, item, &fs, "after-split-window");
+
+	free(cwd);
 	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);
-	cmdq_error(cmdq, "create pane failed: %s", cause);
+	}
+	cmdq_error(item, "create pane failed: %s", cause);
 	free(cause);
-	if (fd != -1)
-		close(fd);
+
+	free(cwd);
 	return (CMD_RETURN_ERROR);
 }

cmd-string.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@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
@@ -31,14 +31,14 @@
  * Parse a command from a string.
  */
 
-int	 cmd_string_getc(const char *, 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_variable(const char *, size_t *);
-char	*cmd_string_expand_tilde(const char *, size_t *);
+static int	 cmd_string_getc(const char *, size_t *);
+static void	 cmd_string_ungetc(size_t *);
+static void	 cmd_string_copy(char **, char *, size_t *);
+static char	*cmd_string_string(const char *, size_t *, char, int);
+static char	*cmd_string_variable(const char *, size_t *);
+static char	*cmd_string_expand_tilde(const char *, size_t *);
 
-int
+static int
 cmd_string_getc(const char *s, size_t *p)
 {
 	const u_char	*ucs = s;
@@ -48,38 +48,21 @@ cmd_string_getc(const char *s, size_t *p)
 	return (ucs[(*p)++]);
 }
 
-void
+static void
 cmd_string_ungetc(size_t *p)
 {
 	(*p)--;
 }
 
-/*
- * Parse command string. Returns -1 on error. If returning -1, cause is error
- * string, or NULL for empty command.
- */
 int
-cmd_string_parse(const char *s, struct cmd_list **cmdlist, const char *file,
-    u_int line, char **cause)
+cmd_string_split(const char *s, int *rargc, char ***rargv)
 {
-	size_t		p;
-	int		ch, i, argc, rval;
-	char	      **argv, *buf, *t;
+	size_t		p = 0;
+	int		ch, argc = 0, append = 0;
+	char	      **argv = NULL, *buf = NULL, *t;
 	const char     *whitespace, *equals;
-	size_t		len;
+	size_t		len = 0;
 
-	argv = NULL;
-	argc = 0;
-
-	buf = NULL;
-	len = 0;
-
-	*cause = NULL;
-
-	*cmdlist = NULL;
-	rval = -1;
-
-	p = 0;
 	for (;;) {
 		ch = cmd_string_getc(s, &p);
 		switch (ch) {
@@ -107,10 +90,11 @@ cmd_string_parse(const char *s, struct cmd_list **cmdlist, const char *file,
 		case ' ':
 		case '\t':
 			if (buf != NULL) {
-				buf = xrealloc(buf, 1, len + 1);
+				buf = xrealloc(buf, len + 1);
 				buf[len] = '\0';
 
-				argv = xrealloc(argv, argc + 1, sizeof *argv);
+				argv = xreallocarray(argv, argc + 1,
+				    sizeof *argv);
 				argv[argc++] = buf;
 
 				buf = NULL;
@@ -125,68 +109,86 @@ cmd_string_parse(const char *s, struct cmd_list **cmdlist, const char *file,
 				whitespace = argv[0] + strcspn(argv[0], " \t");
 				if (equals == NULL || equals > whitespace)
 					break;
-				environ_put(&global_environ, argv[0]);
+				environ_put(global_environ, argv[0]);
 				argc--;
 				memmove(argv, argv + 1, argc * (sizeof *argv));
 			}
-			if (argc == 0)
-				goto out;
-
-			*cmdlist = cmd_list_parse(argc, argv, file, line, cause);
-			if (*cmdlist == NULL)
-				goto out;
-
-			rval = 0;
-			goto out;
+			goto done;
 		case '~':
-			if (buf == NULL) {
-				t = cmd_string_expand_tilde(s, &p);
-				if (t == NULL)
-					goto error;
-				cmd_string_copy(&buf, t, &len);
+			if (buf != NULL) {
+				append = 1;
 				break;
 			}
-			/* FALLTHROUGH */
-		default:
-			if (len >= SIZE_MAX - 2)
+			t = cmd_string_expand_tilde(s, &p);
+			if (t == NULL)
 				goto error;
-
-			buf = xrealloc(buf, 1, len + 1);
-			buf[len++] = ch;
+			cmd_string_copy(&buf, t, &len);
+			break;
+		default:
+			append = 1;
 			break;
 		}
+		if (append) {
+			if (len >= SIZE_MAX - 2)
+				goto error;
+			buf = xrealloc(buf, len + 1);
+			buf[len++] = ch;
+		}
+		append = 0;
 	}
 
+done:
+	*rargc = argc;
+	*rargv = argv;
+
+	free(buf);
+	return (0);
+
 error:
-	xasprintf(cause, "invalid or unknown command: %s", s);
-
-out:
+	if (argv != NULL)
+		cmd_free_argv(argc, argv);
 	free(buf);
-
-	if (argv != NULL) {
-		for (i = 0; i < argc; i++)
-			free(argv[i]);
-		free(argv);
-	}
-
-	return (rval);
+	return (-1);
 }
 
-void
+struct cmd_list *
+cmd_string_parse(const char *s, const char *file, u_int line, char **cause)
+{
+	struct cmd_list	 *cmdlist = NULL;
+	int		  argc;
+	char		**argv;
+
+	*cause = NULL;
+	if (cmd_string_split(s, &argc, &argv) != 0) {
+		xasprintf(cause, "invalid or unknown command: %s", s);
+		return (NULL);
+	}
+	if (argc != 0) {
+		cmdlist = cmd_list_parse(argc, argv, file, line, cause);
+		if (cmdlist == NULL) {
+			cmd_free_argv(argc, argv);
+			return (NULL);
+		}
+	}
+	cmd_free_argv(argc, argv);
+	return (cmdlist);
+}
+
+static void
 cmd_string_copy(char **dst, char *src, size_t *len)
 {
 	size_t srclen;
 
 	srclen = strlen(src);
 
-	*dst = xrealloc(*dst, 1, *len + srclen + 1);
+	*dst = xrealloc(*dst, *len + srclen + 1);
 	strlcpy(*dst + *len, src, srclen + 1);
 
 	*len += srclen;
 	free(src);
 }
 
-char *
+static char *
 cmd_string_string(const char *s, size_t *p, char endch, int esc)
 {
 	int	ch;
@@ -231,11 +233,11 @@ cmd_string_string(const char *s, size_t *p, char endch, int esc)
 
 		if (len >= SIZE_MAX - 2)
 			goto error;
-		buf = xrealloc(buf, 1, len + 1);
+		buf = xrealloc(buf, len + 1);
 		buf[len++] = ch;
 	}
 
-	buf = xrealloc(buf, 1, len + 1);
+	buf = xrealloc(buf, len + 1);
 	buf[len] = '\0';
 	return (buf);
 
@@ -244,7 +246,7 @@ error:
 	return (NULL);
 }
 
-char *
+static char *
 cmd_string_variable(const char *s, size_t *p)
 {
 	int			ch, fch;
@@ -278,7 +280,7 @@ cmd_string_variable(const char *s, size_t *p)
 			return (t);
 		}
 
-		buf = xrealloc(buf, 1, len + 1);
+		buf = xrealloc(buf, len + 1);
 		buf[len++] = ch;
 
 		for (;;) {
@@ -288,7 +290,7 @@ cmd_string_variable(const char *s, size_t *p)
 			else {
 				if (len >= SIZE_MAX - 3)
 					goto error;
-				buf = xrealloc(buf, 1, len + 1);
+				buf = xrealloc(buf, len + 1);
 				buf[len++] = ch;
 			}
 		}
@@ -299,10 +301,10 @@ cmd_string_variable(const char *s, size_t *p)
 	if (ch != EOF && fch != '{')
 		cmd_string_ungetc(p); /* ch */
 
-	buf = xrealloc(buf, 1, len + 1);
+	buf = xrealloc(buf, len + 1);
 	buf[len] = '\0';
 
-	envent = environ_find(&global_environ, buf);
+	envent = environ_find(global_environ, buf);
 	free(buf);
 	if (envent == NULL)
 		return (xstrdup(""));
@@ -313,7 +315,7 @@ error:
 	return (NULL);
 }
 
-char *
+static char *
 cmd_string_expand_tilde(const char *s, size_t *p)
 {
 	struct passwd		*pw;
@@ -325,7 +327,7 @@ cmd_string_expand_tilde(const char *s, size_t *p)
 
 	last = cmd_string_getc(s, p);
 	if (last == EOF || last == '/' || last == ' '|| last == '\t') {
-		envent = environ_find(&global_environ, "HOME");
+		envent = environ_find(global_environ, "HOME");
 		if (envent != NULL && *envent->value != '\0')
 			home = envent->value;
 		else if ((pw = getpwuid(getuid())) != NULL)
@@ -336,7 +338,10 @@ cmd_string_expand_tilde(const char *s, size_t *p)
 		cp = user = xmalloc(strlen(s));
 		for (;;) {
 			last = cmd_string_getc(s, p);
-			if (last == EOF || last == '/' || last == ' '|| last == '\t')
+			if (last == EOF ||
+			    last == '/' ||
+			    last == ' '||
+			    last == '\t')
 				break;
 			*cp++ = last;
 		}

cmd-suspend-client.c

@@ -1,55 +0,0 @@
-/* $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 <stdlib.h>
-#include <string.h>
-
-#include "tmux.h"
-
-/*
- * Suspend client with SIGTSTP.
- */
-
-enum cmd_retval	 cmd_suspend_client_exec(struct cmd *, struct cmd_q *);
-
-const struct cmd_entry cmd_suspend_client_entry = {
-	"suspend-client", "suspendc",
-	"t:", 0, 0,
-	CMD_TARGET_CLIENT_USAGE,
-	0,
-	NULL,
-	cmd_suspend_client_exec
-};
-
-enum cmd_retval
-cmd_suspend_client_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args	*args = self->args;
-	struct client	*c;
-
-	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);
-}

cmd-swap-pane.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@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
@@ -26,65 +26,46 @@
  * Swap two panes.
  */
 
-void		 cmd_swap_pane_key_binding(struct cmd *, int);
-enum cmd_retval	 cmd_swap_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_swap_pane_exec(struct cmd *, struct cmdq_item *);
 
 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,
-	cmd_swap_pane_exec
+	.name = "swap-pane",
+	.alias = "swapp",
+
+	.args = { "dDs:t:U", 0, 0 },
+	.usage = "[-dDU] " CMD_SRCDST_PANE_USAGE,
+
+	.source = { 's', CMD_FIND_PANE, CMD_FIND_DEFAULT_MARKED },
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = 0,
+	.exec = cmd_swap_pane_exec
 };
 
-void
-cmd_swap_pane_key_binding(struct cmd *self, int key)
+static enum cmd_retval
+cmd_swap_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	self->args = args_create(0);
-	if (key == '{')
-		args_set(self->args, 'U', NULL);
-	else if (key == '}')
-		args_set(self->args, 'D', NULL);
-}
-
-enum cmd_retval
-cmd_swap_pane_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args		*args = self->args;
-	struct winlink		*src_wl, *dst_wl;
 	struct window		*src_w, *dst_w;
 	struct window_pane	*tmp_wp, *src_wp, *dst_wp;
 	struct layout_cell	*src_lc, *dst_lc;
 	u_int			 sx, sy, xoff, yoff;
 
-	dst_wl = cmd_find_pane(cmdq, args_get(args, 't'), NULL, &dst_wp);
-	if (dst_wl == NULL)
-		return (CMD_RETURN_ERROR);
-	dst_w = dst_wl->window;
+	dst_w = item->target.wl->window;
+	dst_wp = item->target.wp;
+	src_w = item->source.wl->window;
+	src_wp = item->source.wp;
 	server_unzoom_window(dst_w);
 
-	if (!args_has(args, 's')) {
+	if (args_has(self->args, 'D')) {
 		src_w = dst_w;
-		if (args_has(self->args, 'D')) {
-			src_wp = TAILQ_NEXT(dst_wp, entry);
-			if (src_wp == NULL)
-				src_wp = TAILQ_FIRST(&dst_w->panes);
-		} else if (args_has(self->args, 'U')) {
-			src_wp = TAILQ_PREV(dst_wp, window_panes, entry);
-			if (src_wp == NULL)
-				src_wp = TAILQ_LAST(&dst_w->panes, window_panes);
-		} else {
-			src_wl = cmd_find_pane(cmdq, NULL, NULL, &src_wp);
-			if (src_wl == NULL)
-				return (CMD_RETURN_ERROR);
-			src_w = src_wl->window;
-		}
-	} else {
-		src_wl = cmd_find_pane(cmdq, args_get(args, 's'), NULL, &src_wp);
-		if (src_wl == NULL)
-			return (CMD_RETURN_ERROR);
-		src_w = src_wl->window;
+		src_wp = TAILQ_NEXT(dst_wp, entry);
+		if (src_wp == NULL)
+			src_wp = TAILQ_FIRST(&dst_w->panes);
+	} else if (args_has(self->args, 'U')) {
+		src_w = dst_w;
+		src_wp = TAILQ_PREV(dst_wp, window_panes, entry);
+		if (src_wp == NULL)
+			src_wp = TAILQ_LAST(&dst_w->panes, window_panes);
 	}
 	server_unzoom_window(src_w);
 

cmd-swap-window.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -26,48 +26,56 @@
  * Swap one window with another.
  */
 
-enum cmd_retval	cmd_swap_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_swap_window_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_swap_window_entry = {
-	"swap-window", "swapw",
-	"ds:t:", 0, 0,
-	"[-d] " CMD_SRCDST_WINDOW_USAGE,
-	0,
-	NULL,
-	cmd_swap_window_exec
+	.name = "swap-window",
+	.alias = "swapw",
+
+	.args = { "ds:t:", 0, 0 },
+	.usage = "[-d] " CMD_SRCDST_WINDOW_USAGE,
+
+	.source = { 's', CMD_FIND_WINDOW, CMD_FIND_DEFAULT_MARKED },
+	.target = { 't', CMD_FIND_WINDOW, 0 },
+
+	.flags = 0,
+	.exec = cmd_swap_window_exec
 };
 
-enum cmd_retval
-cmd_swap_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_swap_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	const char		*target_src, *target_dst;
 	struct session		*src, *dst;
 	struct session_group	*sg_src, *sg_dst;
 	struct winlink		*wl_src, *wl_dst;
-	struct window		*w;
+	struct window		*w_src, *w_dst;
 
-	target_src = args_get(args, 's');
-	if ((wl_src = cmd_find_window(cmdq, target_src, &src)) == NULL)
-		return (CMD_RETURN_ERROR);
-	target_dst = args_get(args, 't');
-	if ((wl_dst = cmd_find_window(cmdq, target_dst, &dst)) == NULL)
-		return (CMD_RETURN_ERROR);
+	wl_src = item->source.wl;
+	src = item->source.s;
+	sg_src = session_group_contains(src);
 
-	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");
+	wl_dst = item->target.wl;
+	dst = item->target.s;
+	sg_dst = session_group_contains(dst);
+
+	if (src != dst && sg_src != NULL && sg_dst != NULL &&
+	    sg_src == sg_dst) {
+		cmdq_error(item, "can't move window, sessions are grouped");
 		return (CMD_RETURN_ERROR);
 	}
 
 	if (wl_dst->window == wl_src->window)
 		return (CMD_RETURN_NORMAL);
 
-	w = wl_dst->window;
-	wl_dst->window = wl_src->window;
-	wl_src->window = w;
+	w_dst = wl_dst->window;
+	TAILQ_REMOVE(&w_dst->winlinks, wl_dst, wentry);
+	w_src = wl_src->window;
+	TAILQ_REMOVE(&w_src->winlinks, wl_src, wentry);
+
+	wl_dst->window = w_src;
+	TAILQ_INSERT_TAIL(&w_src->winlinks, wl_dst, wentry);
+	wl_src->window = w_dst;
+	TAILQ_INSERT_TAIL(&w_dst->winlinks, wl_src, wentry);
 
 	if (!args_has(self->args, 'd')) {
 		session_select(dst, wl_dst->idx);

cmd-switch-client.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -27,114 +27,117 @@
  * Switch client to a different session.
  */
 
-void		 cmd_switch_client_key_binding(struct cmd *, int);
-enum cmd_retval	 cmd_switch_client_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_switch_client_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_switch_client_entry = {
-	"switch-client", "switchc",
-	"lc:npt:r", 0, 0,
-	"[-lnpr] [-c target-client] [-t target-session]",
-	CMD_READONLY,
-	cmd_switch_client_key_binding,
-	cmd_switch_client_exec
+	.name = "switch-client",
+	.alias = "switchc",
+
+	.args = { "lc:Enpt:rT:", 0, 0 },
+	.usage = "[-Elnpr] [-c target-client] [-t target-session] "
+		 "[-T key-table]",
+
+	/* -t is special */
+
+	.flags = CMD_READONLY,
+	.exec = cmd_switch_client_exec
 };
 
-void
-cmd_switch_client_key_binding(struct cmd *self, int key)
-{
-	self->args = args_create(0);
-	switch (key) {
-	case '(':
-		args_set(self->args, 'p', NULL);
-		break;
-	case ')':
-		args_set(self->args, 'n', NULL);
-		break;
-	case 'L':
-		args_set(self->args, 'l', NULL);
-		break;
-	}
-}
-
-enum cmd_retval
-cmd_switch_client_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
+	const char		*tflag = args_get(args, 't');
+	enum cmd_find_type	 type;
+	int			 flags;
 	struct client		*c;
-	struct session		*s = NULL;
-	struct winlink		*wl = NULL;
-	struct window 		*w = NULL;
-	struct window_pane	*wp = NULL;
-	const char		*tflag;
+	struct session		*s;
+	struct winlink		*wl;
+	struct window_pane	*wp;
+	const char		*tablename;
+	struct key_table	*table;
 
-	if ((c = cmd_find_client(cmdq, args_get(args, 'c'), 0)) == NULL)
+	if ((c = cmd_find_client(item, args_get(args, 'c'), 0)) == NULL)
 		return (CMD_RETURN_ERROR);
 
-	if (args_has(args, 'r')) {
-		if (c->flags & CLIENT_READONLY) {
-			c->flags &= ~CLIENT_READONLY;
-			cmdq_info(cmdq, "made client writable");
-		} else {
-			c->flags |= CLIENT_READONLY;
-			cmdq_info(cmdq, "made client read-only");
+	if (tflag != NULL && tflag[strcspn(tflag, ":.")] != '\0') {
+		type = CMD_FIND_PANE;
+		flags = 0;
+	} else {
+		type = CMD_FIND_SESSION;
+		flags = CMD_FIND_PREFER_UNATTACHED;
+	}
+	if (cmd_find_target(&item->target, item, tflag, type, flags) != 0)
+		return (CMD_RETURN_ERROR);
+	s = item->target.s;
+	wl = item->target.wl;
+	wp = item->target.wp;
+
+	if (args_has(args, 'r'))
+		c->flags ^= CLIENT_READONLY;
+
+	tablename = args_get(args, 'T');
+	if (tablename != NULL) {
+		table = key_bindings_get_table(tablename, 0);
+		if (table == NULL) {
+			cmdq_error(item, "table %s doesn't exist", tablename);
+			return (CMD_RETURN_ERROR);
 		}
+		table->references++;
+		key_bindings_unref_table(c->keytable);
+		c->keytable = table;
+		return (CMD_RETURN_NORMAL);
 	}
 
-	tflag = args_get(args, 't');
 	if (args_has(args, 'n')) {
 		if ((s = session_next_session(c->session)) == NULL) {
-			cmdq_error(cmdq, "can't find next session");
+			cmdq_error(item, "can't find next session");
 			return (CMD_RETURN_ERROR);
 		}
 	} else if (args_has(args, 'p')) {
 		if ((s = session_previous_session(c->session)) == NULL) {
-			cmdq_error(cmdq, "can't find previous session");
+			cmdq_error(item, "can't find previous session");
 			return (CMD_RETURN_ERROR);
 		}
 	} else if (args_has(args, 'l')) {
 		if (c->last_session != NULL && session_alive(c->last_session))
 			s = c->last_session;
+		else
+			s = NULL;
 		if (s == NULL) {
-			cmdq_error(cmdq, "can't find last session");
+			cmdq_error(item, "can't find last session");
 			return (CMD_RETURN_ERROR);
 		}
 	} 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 = cmd_lookup_windowid(tflag);
-			if (w == NULL &&
-			    (wp = cmd_lookup_paneid(tflag)) != NULL)
-				w = wp->window;
-			if (w != NULL)
-				wl = winlink_find_by_window(&s->windows, w);
-		}
-
-		if (cmdq->client == NULL)
+		if (item->client == NULL)
 			return (CMD_RETURN_NORMAL);
-
 		if (wl != NULL) {
 			if (wp != NULL)
 				window_set_active_pane(wp->window, wp);
 			session_set_current(s, wl);
+			cmd_find_from_session(&item->shared->current, s, 0);
 		}
 	}
 
-	if (c->session != NULL)
+	if (!args_has(args, 'E'))
+		environ_update(s->options, c->environ, s->environ);
+
+	if (c->session != NULL && c->session != s)
 		c->last_session = c->session;
 	c->session = s;
-	session_update_activity(s);
+	if (~item->shared->flags & CMDQ_SHARED_REPEAT)
+		server_client_set_key_table(c, NULL);
+	status_timer_start(c);
+	notify_client("client-session-changed", c);
+	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;
+	alerts_check_session(s);
 
 	return (CMD_RETURN_NORMAL);
 }

cmd-unbind-key.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -26,88 +26,69 @@
  * Unbind key from command.
  */
 
-enum cmd_retval	 cmd_unbind_key_exec(struct cmd *, struct cmd_q *);
-enum cmd_retval	 cmd_unbind_key_table(struct cmd *, struct cmd_q *, int);
+static enum cmd_retval	cmd_unbind_key_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_unbind_key_entry = {
-	"unbind-key", "unbind",
-	"acnt:", 0, 1,
-	"[-acn] [-t key-table] key",
-	0,
-	NULL,
-	cmd_unbind_key_exec
+	.name = "unbind-key",
+	.alias = "unbind",
+
+	.args = { "anT:", 0, 1 },
+	.usage = "[-an] [-T key-table] key",
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_unbind_key_exec
 };
 
-enum cmd_retval
-cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_unbind_key_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	struct key_binding	*bd;
-	int			 key;
+	struct args	*args = self->args;
+	key_code	 key;
+	const char	*tablename;
 
 	if (!args_has(args, 'a')) {
 		if (args->argc != 1) {
-			cmdq_error(cmdq, "missing key");
+			cmdq_error(item, "missing key");
 			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]);
+		if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
+			cmdq_error(item, "unknown key: %s", args->argv[0]);
 			return (CMD_RETURN_ERROR);
 		}
 	} else {
 		if (args->argc != 0) {
-			cmdq_error(cmdq, "key given with -a");
+			cmdq_error(item, "key given with -a");
 			return (CMD_RETURN_ERROR);
 		}
-		key = KEYC_NONE;
+		key = KEYC_UNKNOWN;
 	}
 
-	if (args_has(args, 't'))
-		return (cmd_unbind_key_table(self, cmdq, key));
-
-	if (key == KEYC_NONE) {
-		while (!RB_EMPTY(&key_bindings)) {
-			bd = RB_ROOT(&key_bindings);
-			key_bindings_remove(bd->key);
+	if (key == KEYC_UNKNOWN) {
+		tablename = args_get(args, 'T');
+		if (tablename == NULL) {
+			key_bindings_remove_table("root");
+			key_bindings_remove_table("prefix");
+			return (CMD_RETURN_NORMAL);
 		}
+		if (key_bindings_get_table(tablename, 0) == NULL) {
+			cmdq_error(item, "table %s doesn't exist", tablename);
+			return (CMD_RETURN_ERROR);
+		}
+		key_bindings_remove_table(tablename);
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (!args_has(args, 'n'))
-		key |= KEYC_PREFIX;
-	key_bindings_remove(key);
-	return (CMD_RETURN_NORMAL);
-}
-
-enum cmd_retval
-cmd_unbind_key_table(struct cmd *self, struct cmd_q *cmdq, int key)
-{
-	struct args			*args = self->args;
-	const char			*tablename;
-	const struct mode_key_table	*mtab;
-	struct mode_key_binding		*mbind, mtmp;
-
-	tablename = args_get(args, 't');
-	if ((mtab = mode_key_findtable(tablename)) == NULL) {
-		cmdq_error(cmdq, "unknown key table: %s", tablename);
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (key == KEYC_NONE) {
-		while (!RB_EMPTY(mtab->tree)) {
-			mbind = RB_ROOT(mtab->tree);
-			RB_REMOVE(mode_key_tree, mtab->tree, mbind);
-			free(mbind);
+	if (args_has(args, 'T')) {
+		tablename = args_get(args, 'T');
+		if (key_bindings_get_table(tablename, 0) == NULL) {
+			cmdq_error(item, "table %s doesn't exist", tablename);
+			return (CMD_RETURN_ERROR);
 		}
-		return (CMD_RETURN_NORMAL);
-	}
-
-	mtmp.key = key;
-	mtmp.mode = !!args_has(args, 'c');
-	if ((mbind = RB_FIND(mode_key_tree, mtab->tree, &mtmp)) != NULL) {
-		RB_REMOVE(mode_key_tree, mtab->tree, mbind);
-		free(mbind);
-	}
+	} else if (args_has(args, 'n'))
+		tablename = "root";
+	else
+		tablename = "prefix";
+	key_bindings_remove(tablename, key);
 	return (CMD_RETURN_NORMAL);
 }

cmd-unlink-window.c

@@ -1,69 +0,0 @@
-/* $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).
- */
-
-enum cmd_retval	 cmd_unlink_window_exec(struct cmd *, struct cmd_q *);
-
-const struct cmd_entry cmd_unlink_window_entry = {
-	"unlink-window", "unlinkw",
-	"kt:", 0, 0,
-	"[-k] " CMD_TARGET_WINDOW_USAGE,
-	0,
-	NULL,
-	cmd_unlink_window_exec
-};
-
-enum cmd_retval
-cmd_unlink_window_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	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(cmdq, args_get(args, 't'), &s)) == NULL)
-		return (CMD_RETURN_ERROR);
-	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) {
-		cmdq_error(cmdq, "window is only linked to one session");
-		return (CMD_RETURN_ERROR);
-	}
-
-	server_unlink_window(s, wl);
-	recalculate_sizes();
-
-	return (CMD_RETURN_NORMAL);
-}

cmd-wait-for.c

@@ -1,7 +1,7 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2013 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2013 Nicholas Marriott <nicholas.marriott@gmail.com>
  * Copyright (c) 2013 Thiago de Arruda <tpadilha84@gmail.com>
  *
  * Permission to use, copy, modify, and distribute this software for any
@@ -28,50 +28,97 @@
  * Block or wake a client on a named wait channel.
  */
 
-enum cmd_retval cmd_wait_for_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval cmd_wait_for_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_wait_for_entry = {
-	"wait-for", "wait",
-	"LSU", 1, 1,
-	"[-L|-S|-U] channel",
-	0,
-	NULL,
-	cmd_wait_for_exec
+	.name = "wait-for",
+	.alias = "wait",
+
+	.args = { "LSU", 1, 1 },
+	.usage = "[-L|-S|-U] channel",
+
+	.flags = 0,
+	.exec = cmd_wait_for_exec
+};
+
+struct wait_item {
+	struct cmdq_item	*item;
+	TAILQ_ENTRY(wait_item)	 entry;
 };
 
 struct wait_channel {
 	const char	       *name;
 	int			locked;
+	int			woken;
 
-	TAILQ_HEAD(, cmd_q)	waiters;
-	TAILQ_HEAD(, cmd_q)	lockers;
+	TAILQ_HEAD(, wait_item)	waiters;
+	TAILQ_HEAD(, wait_item)	lockers;
 
 	RB_ENTRY(wait_channel)	entry;
 };
 RB_HEAD(wait_channels, wait_channel);
-struct wait_channels wait_channels = RB_INITIALIZER(wait_channels);
+static 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);
+static int wait_channel_cmp(struct wait_channel *, struct wait_channel *);
+RB_GENERATE_STATIC(wait_channels, wait_channel, entry, wait_channel_cmp);
 
-int
+static 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 *);
+static enum cmd_retval	cmd_wait_for_signal(struct cmdq_item *, const char *,
+			    struct wait_channel *);
+static enum cmd_retval	cmd_wait_for_wait(struct cmdq_item *, const char *,
+			    struct wait_channel *);
+static enum cmd_retval	cmd_wait_for_lock(struct cmdq_item *, const char *,
+			    struct wait_channel *);
+static enum cmd_retval	cmd_wait_for_unlock(struct cmdq_item *, const char *,
+			    struct wait_channel *);
 
-enum cmd_retval
-cmd_wait_for_exec(struct cmd *self, struct cmd_q *cmdq)
+static struct wait_channel	*cmd_wait_for_add(const char *);
+static void			 cmd_wait_for_remove(struct wait_channel *);
+
+static 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);
+}
+
+static 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);
+}
+
+static enum cmd_retval
+cmd_wait_for_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args     	*args = self->args;
 	const char		*name = args->argv[0];
@@ -81,85 +128,88 @@ cmd_wait_for_exec(struct cmd *self, struct cmd_q *cmdq)
 	wc = RB_FIND(wait_channels, &wait_channels, &wc0);
 
 	if (args_has(args, 'S'))
-		return (cmd_wait_for_signal(cmdq, name, wc));
+		return (cmd_wait_for_signal(item, name, wc));
 	if (args_has(args, 'L'))
-		return (cmd_wait_for_lock(cmdq, name, wc));
+		return (cmd_wait_for_lock(item, name, wc));
 	if (args_has(args, 'U'))
-		return (cmd_wait_for_unlock(cmdq, name, wc));
-	return (cmd_wait_for_wait(cmdq, name, wc));
+		return (cmd_wait_for_unlock(item, name, wc));
+	return (cmd_wait_for_wait(item, name, wc));
 }
 
-enum cmd_retval
-cmd_wait_for_signal(struct cmd_q *cmdq, const char *name,
+static enum cmd_retval
+cmd_wait_for_signal(__unused struct cmdq_item *item, const char *name,
     struct wait_channel *wc)
 {
-	struct cmd_q	*wq, *wq1;
+	struct wait_item	*wi, *wi1;
 
-	if (wc == NULL || TAILQ_EMPTY(&wc->waiters)) {
-		cmdq_error(cmdq, "no waiting clients on %s", name);
-		return (CMD_RETURN_ERROR);
-	}
-
-	TAILQ_FOREACH_SAFE(wq, &wc->waiters, waitentry, wq1) {
-		TAILQ_REMOVE(&wc->waiters, wq, waitentry);
-		if (!cmdq_free(wq))
-			cmdq_continue(wq);
-	}
-
-	if (!wc->locked) {
-		RB_REMOVE(wait_channels, &wait_channels, wc);
-		free((void*) wc->name);
-		free(wc);
+	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(wi, &wc->waiters, entry, wi1) {
+		wi->item->flags &= ~CMDQ_WAITING;
+
+		TAILQ_REMOVE(&wc->waiters, wi, entry);
+		free(wi);
 	}
 
+	cmd_wait_for_remove(wc);
 	return (CMD_RETURN_NORMAL);
 }
 
-enum cmd_retval
-cmd_wait_for_wait(struct cmd_q *cmdq, const char *name,
+static enum cmd_retval
+cmd_wait_for_wait(struct cmdq_item *item, const char *name,
     struct wait_channel *wc)
 {
-	if (cmdq->client == NULL || cmdq->client->session != NULL) {
-		cmdq_error(cmdq, "not able to wait");
+	struct client		*c = item->client;
+	struct wait_item	*wi;
+
+	if (c == NULL || c->session != NULL) {
+		cmdq_error(item, "not able to wait");
 		return (CMD_RETURN_ERROR);
 	}
 
-	if (wc == NULL) {
-		wc = xmalloc(sizeof *wc);
-		wc->name = xstrdup(name);
-		wc->locked = 0;
-		TAILQ_INIT(&wc->waiters);
-		TAILQ_INIT(&wc->lockers);
-		RB_INSERT(wait_channels, &wait_channels, wc);
-	}
+	if (wc == NULL)
+		wc = cmd_wait_for_add(name);
 
-	TAILQ_INSERT_TAIL(&wc->waiters, cmdq, waitentry);
-	cmdq->references++;
+	if (wc->woken) {
+		log_debug("wait channel %s already woken (%p)", wc->name, c);
+		cmd_wait_for_remove(wc);
+		return (CMD_RETURN_NORMAL);
+	}
+	log_debug("wait channel %s not woken (%p)", wc->name, c);
+
+	wi = xcalloc(1, sizeof *wi);
+	wi->item = item;
+	TAILQ_INSERT_TAIL(&wc->waiters, wi, entry);
 
 	return (CMD_RETURN_WAIT);
 }
 
-enum cmd_retval
-cmd_wait_for_lock(struct cmd_q *cmdq, const char *name,
+static enum cmd_retval
+cmd_wait_for_lock(struct cmdq_item *item, const char *name,
     struct wait_channel *wc)
 {
-	if (cmdq->client == NULL || cmdq->client->session != NULL) {
-		cmdq_error(cmdq, "not able to lock");
+	struct wait_item	*wi;
+
+	if (item->client == NULL || item->client->session != NULL) {
+		cmdq_error(item, "not able to lock");
 		return (CMD_RETURN_ERROR);
 	}
 
-	if (wc == NULL) {
-		wc = xmalloc(sizeof *wc);
-		wc->name = xstrdup(name);
-		wc->locked = 0;
-		TAILQ_INIT(&wc->waiters);
-		TAILQ_INIT(&wc->lockers);
-		RB_INSERT(wait_channels, &wait_channels, wc);
-	}
+	if (wc == NULL)
+		wc = cmd_wait_for_add(name);
 
 	if (wc->locked) {
-		TAILQ_INSERT_TAIL(&wc->lockers, cmdq, waitentry);
-		cmdq->references++;
+		wi = xcalloc(1, sizeof *wi);
+		wi->item = item;
+		TAILQ_INSERT_TAIL(&wc->lockers, wi, entry);
 		return (CMD_RETURN_WAIT);
 	}
 	wc->locked = 1;
@@ -167,30 +217,48 @@ cmd_wait_for_lock(struct cmd_q *cmdq, const char *name,
 	return (CMD_RETURN_NORMAL);
 }
 
-enum cmd_retval
-cmd_wait_for_unlock(struct cmd_q *cmdq, const char *name,
+static enum cmd_retval
+cmd_wait_for_unlock(struct cmdq_item *item, const char *name,
     struct wait_channel *wc)
 {
-	struct cmd_q	*wq;
+	struct wait_item	*wi;
 
 	if (wc == NULL || !wc->locked) {
-		cmdq_error(cmdq, "channel %s not locked", name);
+		cmdq_error(item, "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);
+	if ((wi = TAILQ_FIRST(&wc->lockers)) != NULL) {
+		wi->item->flags &= ~CMDQ_WAITING;
+		TAILQ_REMOVE(&wc->lockers, wi, entry);
+		free(wi);
 	} else {
 		wc->locked = 0;
-		if (TAILQ_EMPTY(&wc->waiters)) {
-			RB_REMOVE(wait_channels, &wait_channels, wc);
-			free((void*) wc->name);
-			free(wc);
-		}
+		cmd_wait_for_remove(wc);
 	}
 
 	return (CMD_RETURN_NORMAL);
 }
 
+void
+cmd_wait_for_flush(void)
+{
+	struct wait_channel	*wc, *wc1;
+	struct wait_item	*wi, *wi1;
+
+	RB_FOREACH_SAFE(wc, wait_channels, &wait_channels, wc1) {
+		TAILQ_FOREACH_SAFE(wi, &wc->waiters, entry, wi1) {
+			wi->item->flags &= ~CMDQ_WAITING;
+			TAILQ_REMOVE(&wc->waiters, wi, entry);
+			free(wi);
+		}
+		wc->woken = 1;
+		TAILQ_FOREACH_SAFE(wi, &wc->lockers, entry, wi1) {
+			wi->item->flags &= ~CMDQ_WAITING;
+			TAILQ_REMOVE(&wc->lockers, wi, entry);
+			free(wi);
+		}
+		wc->locked = 0;
+		cmd_wait_for_remove(wc);
+	}
+}

colour.c

@@ -1,7 +1,8 @@
-/* $Id$ */
+/* $OpenBSD$ */
 
 /*
- * Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@gmail.com>
+ * Copyright (c) 2016 Avi Halachmi <avihpit@yahoo.com>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -24,120 +25,83 @@
 
 #include "tmux.h"
 
+static int
+colour_dist_sq(int R, int G, int B, int r, int g, int b)
+{
+	return ((R - r) * (R - r) + (G - g) * (G - g) + (B - b) * (B - b));
+}
+
+static int
+colour_to_6cube(int v)
+{
+	if (v < 48)
+		return (0);
+	if (v < 114)
+		return (1);
+	return ((v - 35) / 40);
+}
+
 /*
- * Colour to string conversion functions. Bit 8 of the colour means it is one
- * of the 256 colour palette.
+ * Convert an RGB triplet to the xterm(1) 256 colour palette.
+ *
+ * xterm provides a 6x6x6 colour cube (16 - 231) and 24 greys (232 - 255). We
+ * map our RGB colour to the closest in the cube, also work out the closest
+ * grey, and use the nearest of the two.
+ *
+ * Note that the xterm has much lower resolution for darker colours (they are
+ * not evenly spread out), so our 6 levels are not evenly spread: 0x0, 0x5f
+ * (95), 0x87 (135), 0xaf (175), 0xd7 (215) and 0xff (255). Greys are more
+ * evenly spread (8, 18, 28 ... 238).
  */
-
-/* An RGB colour. */
-struct colour_rgb {
-	u_char	r;
-	u_char	g;
-	u_char	b;
-};
-
-/* 256 colour RGB table, generated on first use. */
-struct colour_rgb *colour_rgb_256;
-
-void	colour_rgb_generate256(void);
-u_int	colour_rgb_distance(struct colour_rgb *, struct colour_rgb *);
-int	colour_rgb_find(struct colour_rgb *);
-
-/* Generate 256 colour RGB table. */
-void
-colour_rgb_generate256(void)
-{
-	struct colour_rgb	*rgb;
-	u_int			 i, r, g, b;
-
-	/*
-	 * Allocate the table. The first 16 colours are often changed by users
-	 * and terminals so don't include them.
-	 */
-	colour_rgb_256 = xcalloc(240, sizeof *colour_rgb_256);
-
-	/* Add the colours first. */
-	r = g = b = 0;
-	for (i = 240; i > 24; i--) {
-		rgb = &colour_rgb_256[240 - i];
-
-		if (r != 0)
-			rgb->r = (r * 40) + 55;
-		if (g != 0)
-			rgb->g = (g * 40) + 55;
-		if (b != 0)
-			rgb->b = (b * 40) + 55;
-
-		b++;
-		if (b > 5) {
-			b = 0;
-			g++;
-		}
-		if (g > 5) {
-			g = 0;
-			r++;
-		}
-	}
-
-	/* Then add the greys. */
-	for (i = 24; i > 0; i--) {
-		rgb = &colour_rgb_256[240 - i];
-
-		rgb->r = 8 + (24 - i) * 10;
-		rgb->g = 8 + (24 - i) * 10;
-		rgb->b = 8 + (24 - i) * 10;
-	}
-}
-
-/* Get colour RGB distance. */
-u_int
-colour_rgb_distance(struct colour_rgb *rgb1, struct colour_rgb *rgb2)
-{
-	int	r, g, b;
-
-	r = rgb1->r - rgb2->r;
-	g = rgb1->g - rgb2->g;
-	b = rgb1->b - rgb2->b;
-	return (r * r + g * g + b * b);
-}
-
-/* Work out the nearest colour from the 256 colour set. */
 int
-colour_rgb_find(struct colour_rgb *rgb)
+colour_find_rgb(u_char r, u_char g, u_char b)
 {
-	u_int	distance, lowest, colour, i;
+	static const int	q2c[6] = { 0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff };
+	int			qr, qg, qb, cr, cg, cb, d, idx;
+	int			grey_avg, grey_idx, grey;
 
-	if (colour_rgb_256 == NULL)
-		colour_rgb_generate256();
+	/* Map RGB to 6x6x6 cube. */
+	qr = colour_to_6cube(r); cr = q2c[qr];
+	qg = colour_to_6cube(g); cg = q2c[qg];
+	qb = colour_to_6cube(b); cb = q2c[qb];
 
-	colour = 16;
-	lowest = UINT_MAX;
-	for (i = 0; i < 240; i++) {
-		distance = colour_rgb_distance(&colour_rgb_256[i], rgb);
-		if (distance < lowest) {
-			lowest = distance;
-			colour = 16 + i;
-		}
-	}
-	return (colour);
+	/* If we have hit the colour exactly, return early. */
+	if (cr == r && cg == g && cb == b)
+		return ((16 + (36 * qr) + (6 * qg) + qb) | COLOUR_FLAG_256);
+
+	/* Work out the closest grey (average of RGB). */
+	grey_avg = (r + g + b) / 3;
+	if (grey_avg > 238)
+		grey_idx = 23;
+	else
+		grey_idx = (grey_avg - 3) / 10;
+	grey = 8 + (10 * grey_idx);
+
+	/* Is grey or 6x6x6 colour closest? */
+	d = colour_dist_sq(cr, cg, cb, r, g, b);
+	if (colour_dist_sq(grey, grey, grey, r, g, b) < d)
+		idx = 232 + grey_idx;
+	else
+		idx = 16 + (36 * qr) + (6 * qg) + qb;
+	return (idx | COLOUR_FLAG_256);
 }
 
-/* Set grid cell foreground colour. */
-void
-colour_set_fg(struct grid_cell *gc, int c)
+/* Join RGB into a colour. */
+int
+colour_join_rgb(u_char r, u_char g, u_char b)
 {
-	if (c & 0x100)
-		gc->flags |= GRID_FLAG_FG256;
-	gc->fg = c;
+	return ((((int)((r) & 0xff)) << 16) |
+	    (((int)((g) & 0xff)) << 8) |
+	    (((int)((b) & 0xff))) | COLOUR_FLAG_RGB);
 }
 
-/* Set grid cell background colour. */
+/* Split colour into RGB. */
 void
-colour_set_bg(struct grid_cell *gc, int c)
+colour_split_rgb(int c, u_char *r, u_char *g, u_char *b)
 {
-	if (c & 0x100)
-		gc->flags |= GRID_FLAG_BG256;
-	gc->bg = c;
+	*r = (c >> 16) & 0xff;
+	*g = (c >> 8) & 0xff;
+	*b = c & 0xff;
 }
 
 /* Convert colour to a string. */
@@ -145,9 +109,16 @@ const char *
 colour_tostring(int c)
 {
 	static char	s[32];
+	u_char		r, g, b;
 
-	if (c & 0x100) {
-		xsnprintf(s, sizeof s, "colour%u", c & ~0x100);
+	if (c & COLOUR_FLAG_RGB) {
+		colour_split_rgb(c, &r, &g, &b);
+		xsnprintf(s, sizeof s, "#%02x%02x%02x", r, g, b);
+		return (s);
+	}
+
+	if (c & COLOUR_FLAG_256) {
+		xsnprintf(s, sizeof s, "colour%u", c & 0xff);
 		return (s);
 	}
 
@@ -194,70 +165,62 @@ colour_tostring(int c)
 int
 colour_fromstring(const char *s)
 {
-	const char		*errstr;
-	const char		*cp;
-	struct colour_rgb	 rgb;
-	int			 n;
+	const char	*errstr;
+	const char	*cp;
+	int		 n;
+	u_char		 r, g, b;
 
 	if (*s == '#' && strlen(s) == 7) {
 		for (cp = s + 1; isxdigit((u_char) *cp); cp++)
 			;
 		if (*cp != '\0')
 			return (-1);
-		n = sscanf(s + 1, "%2hhx%2hhx%2hhx", &rgb.r, &rgb.g, &rgb.b);
+		n = sscanf(s + 1, "%2hhx%2hhx%2hhx", &r, &g, &b);
 		if (n != 3)
 			return (-1);
-		return (colour_rgb_find(&rgb) | 0x100);
+		return (colour_join_rgb(r, g, b));
 	}
 
 	if (strncasecmp(s, "colour", (sizeof "colour") - 1) == 0) {
 		n = strtonum(s + (sizeof "colour") - 1, 0, 255, &errstr);
 		if (errstr != NULL)
 			return (-1);
-		return (n | 0x100);
+		return (n | COLOUR_FLAG_256);
 	}
 
-	if (strcasecmp(s, "black") == 0 || (s[0] == '0' && s[1] == '\0'))
+	if (strcasecmp(s, "black") == 0 || strcmp(s, "0") == 0)
 		return (0);
-	if (strcasecmp(s, "red") == 0 || (s[0] == '1' && s[1] == '\0'))
+	if (strcasecmp(s, "red") == 0 || strcmp(s, "1") == 0)
 		return (1);
-	if (strcasecmp(s, "green") == 0 || (s[0] == '2' && s[1] == '\0'))
+	if (strcasecmp(s, "green") == 0 || strcmp(s, "2") == 0)
 		return (2);
-	if (strcasecmp(s, "yellow") == 0 || (s[0] == '3' && s[1] == '\0'))
+	if (strcasecmp(s, "yellow") == 0 || strcmp(s, "3") == 0)
 		return (3);
-	if (strcasecmp(s, "blue") == 0 || (s[0] == '4' && s[1] == '\0'))
+	if (strcasecmp(s, "blue") == 0 || strcmp(s, "4") == 0)
 		return (4);
-	if (strcasecmp(s, "magenta") == 0 || (s[0] == '5' && s[1] == '\0'))
+	if (strcasecmp(s, "magenta") == 0 || strcmp(s, "5") == 0)
 		return (5);
-	if (strcasecmp(s, "cyan") == 0 || (s[0] == '6' && s[1] == '\0'))
+	if (strcasecmp(s, "cyan") == 0 || strcmp(s, "6") == 0)
 		return (6);
-	if (strcasecmp(s, "white") == 0 || (s[0] == '7' && s[1] == '\0'))
+	if (strcasecmp(s, "white") == 0 || strcmp(s, "7") == 0)
 		return (7);
-	if (strcasecmp(s, "default") == 0 || (s[0] == '8' && s[1] == '\0'))
+	if (strcasecmp(s, "default") == 0 || strcmp(s, "8") == 0)
 		return (8);
-	if (strcasecmp(s, "brightblack") == 0 ||
-	    (s[0] == '9' && s[1] == '0' && s[1] == '\0'))
+	if (strcasecmp(s, "brightblack") == 0 || strcmp(s, "90") == 0)
 		return (90);
-	if (strcasecmp(s, "brightred") == 0 ||
-	    (s[0] == '9' && s[1] == '1' && s[1] == '\0'))
+	if (strcasecmp(s, "brightred") == 0 || strcmp(s, "91") == 0)
 		return (91);
-	if (strcasecmp(s, "brightgreen") == 0 ||
-	    (s[0] == '9' && s[1] == '2' && s[1] == '\0'))
+	if (strcasecmp(s, "brightgreen") == 0 || strcmp(s, "92") == 0)
 		return (92);
-	if (strcasecmp(s, "brightyellow") == 0 ||
-	    (s[0] == '9' && s[1] == '3' && s[1] == '\0'))
+	if (strcasecmp(s, "brightyellow") == 0 || strcmp(s, "93") == 0)
 		return (93);
-	if (strcasecmp(s, "brightblue") == 0 ||
-	    (s[0] == '9' && s[1] == '4' && s[1] == '\0'))
+	if (strcasecmp(s, "brightblue") == 0 || strcmp(s, "94") == 0)
 		return (94);
-	if (strcasecmp(s, "brightmagenta") == 0 ||
-	    (s[0] == '9' && s[1] == '5' && s[1] == '\0'))
+	if (strcasecmp(s, "brightmagenta") == 0 || strcmp(s, "95") == 0)
 		return (95);
-	if (strcasecmp(s, "brightcyan") == 0 ||
-	    (s[0] == '9' && s[1] == '6' && s[1] == '\0'))
+	if (strcasecmp(s, "brightcyan") == 0 || strcmp(s, "96") == 0)
 		return (96);
-	if (strcasecmp(s, "brightwhite") == 0 ||
-	    (s[0] == '9' && s[1] == '7' && s[1] == '\0'))
+	if (strcasecmp(s, "brightwhite") == 0 || strcmp(s, "97") == 0)
 		return (97);
 	return (-1);
 }

compat.h

@@ -1,7 +1,5 @@
-/* $Id$ */
-
 /*
- * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@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
@@ -19,10 +17,22 @@
 #ifndef COMPAT_H
 #define COMPAT_H
 
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/uio.h>
+
+#include <limits.h>
+#include <stdio.h>
+#include <termios.h>
+#include <wchar.h>
+
 #ifndef __GNUC__
 #define __attribute__(a)
 #endif
 
+#ifndef __unused
+#define __unused __attribute__ ((__unused__))
+#endif
 #ifndef __dead
 #define __dead __attribute__ ((__noreturn__))
 #endif
@@ -34,11 +44,21 @@
 #define ECHOPRT 0
 #endif
 
-#ifndef HAVE_BSD_TYPES
-typedef uint8_t u_int8_t;
-typedef uint16_t u_int16_t;
-typedef uint32_t u_int32_t;
-typedef uint64_t u_int64_t;
+#ifndef ACCESSPERMS
+#define ACCESSPERMS (S_IRWXU|S_IRWXG|S_IRWXO)
+#endif
+
+#if !defined(FIONREAD) && defined(__sun)
+#include <sys/filio.h>
+#endif
+
+#ifdef HAVE_ERR_H
+#include <err.h>
+#else
+void	err(int, const char *, ...);
+void	errx(int, const char *, ...);
+void	warn(const char *, ...);
+void	warnx(const char *, ...);
 #endif
 
 #ifndef HAVE_PATHS_H
@@ -49,6 +69,16 @@ typedef uint64_t u_int64_t;
 #define _PATH_DEV	"/dev/"
 #endif
 
+#ifndef __OpenBSD__
+#define pledge(s, p) (0)
+#endif
+
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#else
+#include <inttypes.h>
+#endif
+
 #ifdef HAVE_QUEUE_H
 #include <sys/queue.h>
 #else
@@ -71,17 +101,17 @@ typedef uint64_t u_int64_t;
 #include <paths.h>
 #endif
 
-#ifdef HAVE_FORKPTY
 #ifdef HAVE_LIBUTIL_H
 #include <libutil.h>
 #endif
+
 #ifdef HAVE_PTY_H
 #include <pty.h>
 #endif
+
 #ifdef HAVE_UTIL_H
 #include <util.h>
 #endif
-#endif
 
 #ifdef HAVE_VIS
 #include <vis.h>
@@ -95,12 +125,6 @@ typedef uint64_t u_int64_t;
 #include "compat/imsg.h"
 #endif
 
-#ifdef HAVE_STDINT_H
-#include <stdint.h>
-#else
-#include <inttypes.h>
-#endif
-
 #ifdef BROKEN_CMSG_FIRSTHDR
 #undef CMSG_FIRSTHDR
 #define CMSG_FIRSTHDR(mhdr) \
@@ -176,14 +200,30 @@ typedef uint64_t u_int64_t;
 #define TTY_NAME_MAX 32
 #endif
 
-#ifndef HAVE_BZERO
-#undef bzero
-#define bzero(buf, len) memset(buf, 0, len);
+#ifndef HOST_NAME_MAX
+#define HOST_NAME_MAX 255
+#endif
+
+#ifndef HAVE_FLOCK
+#define LOCK_SH 0
+#define LOCK_EX 0
+#define LOCK_NB 0
+#define flock(fd, op) (0)
+#endif
+
+#ifndef HAVE_EXPLICIT_BZERO
+/* explicit_bzero.c */
+void		 explicit_bzero(void *, size_t);
+#endif
+
+#ifndef HAVE_GETDTABLECOUNT
+/* getdtablecount.c */
+int		 getdtablecount(void);
 #endif
 
 #ifndef HAVE_CLOSEFROM
 /* closefrom.c */
-void	closefrom(int);
+void		 closefrom(int);
 #endif
 
 #ifndef HAVE_STRCASESTR
@@ -211,20 +251,53 @@ size_t	 	 strlcpy(char *, const char *, size_t);
 size_t	 	 strlcat(char *, const char *, size_t);
 #endif
 
+#ifndef HAVE_STRNLEN
+/* strnlen.c */
+size_t		 strnlen(const char *, size_t);
+#endif
+
+#ifndef HAVE_STRNDUP
+/* strndup.c */
+char		*strndup(const char *, size_t);
+#endif
+
+#ifndef HAVE_MEMMEM
+/* memmem.c */
+void		*memmem(const void *, size_t, const void *, size_t);
+#endif
+
 #ifndef HAVE_DAEMON
 /* daemon.c */
 int	 	 daemon(int, int);
 #endif
 
+#ifndef HAVE_GETPROGNAME
+/* getprogname.c */
+const char	*getprogname(void);
+#endif
+
+#ifndef HAVE_SETPROCTITLE
+/* setproctitle.c */
+void		 setproctitle(const char *, ...);
+#endif
+
 #ifndef HAVE_B64_NTOP
-/* b64_ntop.c */
-#undef b64_ntop /* for Cygwin */
+/* base64.c */
+#undef b64_ntop
+#undef b64_pton
 int		 b64_ntop(const char *, size_t, char *, size_t);
+int		 b64_pton(const char *, u_char *, size_t);
+#endif
+
+#ifndef HAVE_FDFORKPTY
+/* fdforkpty.c */
+int		 getptmfd(void);
+pid_t		 fdforkpty(int, int *, char *, struct termios *,
+		     struct winsize *);
 #endif
 
 #ifndef HAVE_FORKPTY
 /* forkpty.c */
-#include <sys/ioctl.h>
 pid_t		 forkpty(int *, char *, struct termios *, struct winsize *);
 #endif
 
@@ -239,6 +312,10 @@ 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);
@@ -247,18 +324,32 @@ int		 unsetenv(const char *);
 
 #ifndef HAVE_CFMAKERAW
 /* cfmakeraw.c */
-void		cfmakeraw(struct termios *);
+void		 cfmakeraw(struct termios *);
 #endif
 
-#ifndef HAVE_OPENAT
-/* openat.c */
-#define AT_FDCWD -100
-int		openat(int, const char *, int, ...);
+#ifndef HAVE_FREEZERO
+/* freezero.c */
+void		 freezero(void *, size_t);
 #endif
 
-#ifdef HAVE_GETOPT
-#include <getopt.h>
-#else
+#ifndef HAVE_REALLOCARRAY
+/* reallocarray.c */
+void		*reallocarray(void *, size_t, size_t);
+#endif
+
+#ifndef HAVE_RECALLOCARRAY
+/* recallocarray.c */
+void		*recallocarray(void *, size_t, size_t, size_t);
+#endif
+
+#ifdef HAVE_UTF8PROC
+/* utf8proc.c */
+int		 utf8proc_wcwidth(wchar_t);
+int		 utf8proc_mbtowc(wchar_t *, const char *, size_t);
+int		 utf8proc_wctomb(char *, wchar_t);
+#endif
+
+#ifndef HAVE_GETOPT
 /* getopt.c */
 extern int	BSDopterr;
 extern int	BSDoptind;

compat/asprintf.c

@@ -1,7 +1,5 @@
-/* $Id$ */
-
 /*
- * Copyright (c) 2006 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2006 Nicholas Marriott <nicholas.marriott@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
@@ -16,16 +14,13 @@
  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
+#include <sys/types.h>
+
 #include <stdarg.h>
 #include <stdio.h>
-#ifdef HAVE_STDINT_H
-#include <stdint.h>
-#else
-#include <inttypes.h>
-#endif
 #include <string.h>
 
-#include "tmux.h"
+#include "compat.h"
 
 int
 asprintf(char **ret, const char *fmt, ...)
@@ -56,10 +51,12 @@ vasprintf(char **ret, const char *fmt, va_list ap)
 		free(*ret);
 		goto error;
 	}
+	va_end(ap2);
 
 	return (n);
 
 error:
+	va_end(ap2);
 	*ret = NULL;
 	return (-1);
 }

compat/base64.c

@@ -1,5 +1,7 @@
+/*	$OpenBSD: base64.c,v 1.8 2015/01/16 16:48:51 deraadt Exp $	*/
+
 /*
- * Copyright (c) 1996, 1998 by Internet Software Consortium.
+ * Copyright (c) 1996 by Internet Software Consortium.
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -41,19 +43,18 @@
  */
 
 #include <sys/types.h>
-#include <sys/param.h>
 #include <sys/socket.h>
-
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#include <arpa/nameser.h>
 
 #include <ctype.h>
+#include <resolv.h>
 #include <stdio.h>
+
 #include <stdlib.h>
 #include <string.h>
 
-#define Assert(Cond) if (!(Cond)) abort()
-
 static const char Base64[] =
 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 static const char Pad64 = '=';
@@ -122,11 +123,16 @@ static const char Pad64 = '=';
    */
 
 int
-b64_ntop(uint8_t const *src, size_t srclength, char *target, size_t targsize) {
+b64_ntop(src, srclength, target, targsize)
+	u_char const *src;
+	size_t srclength;
+	char *target;
+	size_t targsize;
+{
 	size_t datalength = 0;
-	uint8_t input[3];
-	uint8_t output[4];
-	size_t i;
+	u_char input[3];
+	u_char output[4];
+	int i;
 
 	while (2 < srclength) {
 		input[0] = *src++;
@@ -138,10 +144,6 @@ b64_ntop(uint8_t const *src, size_t srclength, char *target, size_t targsize) {
 		output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
 		output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
 		output[3] = input[2] & 0x3f;
-		Assert(output[0] < 64);
-		Assert(output[1] < 64);
-		Assert(output[2] < 64);
-		Assert(output[3] < 64);
 
 		if (datalength + 4 > targsize)
 			return (-1);
@@ -161,9 +163,6 @@ b64_ntop(uint8_t const *src, size_t srclength, char *target, size_t targsize) {
 		output[0] = input[0] >> 2;
 		output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
 		output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
-		Assert(output[0] < 64);
-		Assert(output[1] < 64);
-		Assert(output[2] < 64);
 
 		if (datalength + 4 > targsize)
 			return (-1);
@@ -180,3 +179,137 @@ b64_ntop(uint8_t const *src, size_t srclength, char *target, size_t targsize) {
 	target[datalength] = '\0';	/* Returned value doesn't count \0. */
 	return (datalength);
 }
+
+/* skips all whitespace anywhere.
+   converts characters, four at a time, starting at (or after)
+   src from base - 64 numbers into three 8 bit bytes in the target area.
+   it returns the number of data bytes stored at the target, or -1 on error.
+ */
+
+int
+b64_pton(src, target, targsize)
+	char const *src;
+	u_char *target;
+	size_t targsize;
+{
+	int tarindex, state, ch;
+	u_char nextbyte;
+	char *pos;
+
+	state = 0;
+	tarindex = 0;
+
+	while ((ch = (unsigned char)*src++) != '\0') {
+		if (isspace(ch))	/* Skip whitespace anywhere. */
+			continue;
+
+		if (ch == Pad64)
+			break;
+
+		pos = strchr(Base64, ch);
+		if (pos == 0) 		/* A non-base64 character. */
+			return (-1);
+
+		switch (state) {
+		case 0:
+			if (target) {
+				if (tarindex >= targsize)
+					return (-1);
+				target[tarindex] = (pos - Base64) << 2;
+			}
+			state = 1;
+			break;
+		case 1:
+			if (target) {
+				if (tarindex >= targsize)
+					return (-1);
+				target[tarindex]   |=  (pos - Base64) >> 4;
+				nextbyte = ((pos - Base64) & 0x0f) << 4;
+				if (tarindex + 1 < targsize)
+					target[tarindex+1] = nextbyte;
+				else if (nextbyte)
+					return (-1);
+			}
+			tarindex++;
+			state = 2;
+			break;
+		case 2:
+			if (target) {
+				if (tarindex >= targsize)
+					return (-1);
+				target[tarindex]   |=  (pos - Base64) >> 2;
+				nextbyte = ((pos - Base64) & 0x03) << 6;
+				if (tarindex + 1 < targsize)
+					target[tarindex+1] = nextbyte;
+				else if (nextbyte)
+					return (-1);
+			}
+			tarindex++;
+			state = 3;
+			break;
+		case 3:
+			if (target) {
+				if (tarindex >= targsize)
+					return (-1);
+				target[tarindex] |= (pos - Base64);
+			}
+			tarindex++;
+			state = 0;
+			break;
+		}
+	}
+
+	/*
+	 * We are done decoding Base-64 chars.  Let's see if we ended
+	 * on a byte boundary, and/or with erroneous trailing characters.
+	 */
+
+	if (ch == Pad64) {			/* We got a pad char. */
+		ch = (unsigned char)*src++;	/* Skip it, get next. */
+		switch (state) {
+		case 0:		/* Invalid = in first position */
+		case 1:		/* Invalid = in second position */
+			return (-1);
+
+		case 2:		/* Valid, means one byte of info */
+			/* Skip any number of spaces. */
+			for (; ch != '\0'; ch = (unsigned char)*src++)
+				if (!isspace(ch))
+					break;
+			/* Make sure there is another trailing = sign. */
+			if (ch != Pad64)
+				return (-1);
+			ch = (unsigned char)*src++;		/* Skip the = */
+			/* Fall through to "single trailing =" case. */
+			/* FALLTHROUGH */
+
+		case 3:		/* Valid, means two bytes of info */
+			/*
+			 * We know this char is an =.  Is there anything but
+			 * whitespace after it?
+			 */
+			for (; ch != '\0'; ch = (unsigned char)*src++)
+				if (!isspace(ch))
+					return (-1);
+
+			/*
+			 * Now make sure for cases 2 and 3 that the "extra"
+			 * bits that slopped past the last full byte were
+			 * zeros.  If we don't check them, they become a
+			 * subliminal channel.
+			 */
+			if (target && tarindex < targsize &&
+			    target[tarindex] != 0)
+				return (-1);
+		}
+	} else {
+		/*
+		 * We ended by seeing the end of the string.  Make sure we
+		 * have no partial bytes lying around.
+		 */
+		if (state != 0)
+			return (-1);
+	}
+
+	return (tarindex);
+}

compat/bitstring.h

@@ -1,4 +1,3 @@
-/* $Id$ */
 /*	$OpenBSD: bitstring.h,v 1.5 2003/06/02 19:34:12 millert Exp $	*/
 /*	$NetBSD: bitstring.h,v 1.5 1997/05/14 15:49:55 pk Exp $	*/
 

compat/cfmakeraw.c

@@ -1,8 +1,6 @@
-/* $Id$ */
-
 /*
  * Copyright (c) 2013 Dagobert Michelsen
- * Copyright (c) 2013 Nicholas Marriott <nicm@users.sourceforge.net>
+ * Copyright (c) 2013 Nicholas Marriott <nicholas.marriott@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
@@ -17,9 +15,12 @@
  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include <string.h>
+#include <sys/types.h>
 
-#include "tmux.h"
+#include <string.h>
+#include <termios.h>
+
+#include "compat.h"
 
 void
 cfmakeraw(struct termios *tio)

compat/closefrom.c

@@ -1,5 +1,3 @@
-/* $Id$ */
-
 /*
  * Copyright (c) 2004-2005 Todd C. Miller <Todd.Miller@courtesan.com>
  *
@@ -16,8 +14,6 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include "tmux.h"
-
 #ifndef HAVE_CLOSEFROM
 
 #include <sys/types.h>
@@ -49,6 +45,8 @@
 # endif
 #endif
 
+#include "compat.h"
+
 #ifndef OPEN_MAX
 # define OPEN_MAX	256
 #endif

compat/daemon-darwin.c

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2017 Nicholas Marriott <nicholas.marriott@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.
+ */
+
+/*
+ * Copyright (c) 2011-2013, Chris Johnsen <chris_johnsen@pobox.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *     1. Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *     2. Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <sys/types.h>
+
+#include <mach/mach.h>
+
+#include <Availability.h>
+#include <unistd.h>
+
+void daemon_darwin(void);
+
+#ifdef __MAC_10_10
+
+extern kern_return_t	bootstrap_look_up_per_user(mach_port_t, const char *,
+			    uid_t, mach_port_t *);
+extern kern_return_t	bootstrap_get_root(mach_port_t, mach_port_t *);
+
+void
+daemon_darwin(void)
+{
+	mach_port_t	root = MACH_PORT_NULL;
+	mach_port_t	s = MACH_PORT_NULL;
+	uid_t		uid;
+
+	uid = getuid();
+	if (bootstrap_get_root(bootstrap_port, &root) == KERN_SUCCESS &&
+	    bootstrap_look_up_per_user(root, NULL, uid, &s) == KERN_SUCCESS &&
+	    task_set_bootstrap_port(mach_task_self(), s) == KERN_SUCCESS &&
+	    mach_port_deallocate(mach_task_self(), bootstrap_port) == KERN_SUCCESS)
+		bootstrap_port = s;
+}
+
+#else
+
+void
+daemon_darwin(void)
+{
+}
+
+#endif

compat/daemon.c

@@ -1,4 +1,3 @@
-/* $Id$ */
 /*	$OpenBSD: daemon.c,v 1.6 2005/08/08 08:05:33 espie Exp $ */
 /*-
  * Copyright (c) 1990, 1993
@@ -29,11 +28,17 @@
  * SUCH DAMAGE.
  */
 
+#include <sys/types.h>
+
 #include <fcntl.h>
 #include <unistd.h>
 #include <stdlib.h>
 
-#include "tmux.h"
+#include "compat.h"
+
+#ifdef __APPLE__
+extern void daemon_darwin(void);
+#endif
 
 int
 daemon(int nochdir, int noclose)
@@ -62,5 +67,9 @@ daemon(int nochdir, int noclose)
 		if (fd > 2)
 			(void)close (fd);
 	}
+
+#ifdef __APPLE__
+	daemon_darwin();
+#endif
 	return (0);
 }

compat/err.c

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2017 Nicholas Marriott <nicholas.marriott@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 <errno.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "compat.h"
+
+void
+err(int eval, const char *fmt, ...)
+{
+	va_list	 ap;
+	int	 saved_errno = errno;
+
+	fprintf(stderr, "%s: ", getprogname());
+
+	va_start(ap, fmt);
+	if (fmt != NULL) {
+		vfprintf(stderr, fmt, ap);
+		fprintf(stderr, ": ");
+	}
+	va_end(ap);
+
+	fprintf(stderr, "%s\n", strerror(saved_errno));
+	exit(eval);
+}
+
+void
+errx(int eval, const char *fmt, ...)
+{
+	va_list	 ap;
+
+	fprintf(stderr, "%s: ", getprogname());
+
+	va_start(ap, fmt);
+	if (fmt != NULL)
+		vfprintf(stderr, fmt, ap);
+	va_end(ap);
+
+	putc('\n', stderr);
+	exit(eval);
+}
+
+void
+warn(const char *fmt, ...)
+{
+	va_list	 ap;
+	int	 saved_errno = errno;
+
+	fprintf(stderr, "%s: ", getprogname());
+
+	va_start(ap, fmt);
+	if (fmt != NULL) {
+		vfprintf(stderr, fmt, ap);
+		fprintf(stderr, ": ");
+	}
+	va_end(ap);
+
+	fprintf(stderr, "%s\n", strerror(saved_errno));
+}
+
+void
+warnx(const char *fmt, ...)
+{
+	va_list	 ap;
+
+	fprintf(stderr, "%s: ", getprogname());
+
+	va_start(ap, fmt);
+	if (fmt != NULL)
+		vfprintf(stderr, fmt, ap);
+	va_end(ap);
+
+	putc('\n', stderr);
+}