Add to CHANGES.

it. From Evan Green, GitHub issue 1982.

.github/CONTRIBUTING.md

@@ -0,0 +1,78 @@
+## What should I do before opening an issue?
+
+Before opening an issue, please ensure that:
+
+- Your problem is a specific problem or question or suggestion, not a general
+  complaint.
+
+- `$TERM` inside tmux is screen, screen-256color, tmux or tmux-256color. Check
+  by running `echo $TERM` inside tmux.
+
+- You can reproduce the problem with the latest tmux release, or a build from
+  Git master.
+
+- Your question or issue is not covered [in the
+  manual](https://man.openbsd.org/tmux.1) (run `man tmux`).
+
+- Your problem is not mentioned in the [CHANGES
+  file](https://raw.githubusercontent.com/tmux/tmux/master/CHANGES) file.
+
+- Nobody else has opened the same issue recently.
+
+## What should I include in an issue?
+
+Please include the output of:
+
+~~~bash
+uname -sp && tmux -V && echo $TERM
+~~~
+
+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.
+
+## How do I test without a .tmux.conf?
+
+Run a separate tmux server with `-f/dev/null` to skip loading `.tmux.conf`:
+
+~~~bash
+tmux -Ltest kill-server
+tmux -Ltest -f/dev/null new
+~~~
+
+## How do I get logs from tmux?
+
+Add `-vv` to tmux to create three log files in the current directory. If you can
+reproduce without a configuration file:
+
+~~~bash
+tmux -Ltest kill-server
+tmux -vv -Ltest -f/dev/null new
+~~~
+
+Or if you need your configuration:
+
+~~~base
+tmux kill-server
+tmux -vv new
+~~~
+
+The log files are:
+
+- `tmux-server*.log`: server log file.
+
+- `tmux-client*.log`: client log file.
+
+- `tmux-out*.log`: output log file.
+
+Please attach the log files to your issue.

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,22 @@
+### Issue description
+
+Please read https://github.com/tmux/tmux/blob/master/.github/CONTRIBUTING.md
+before opening an issue.
+
+If you have upgraded, make sure your issue is not covered in the CHANGES file
+for your version: https://raw.githubusercontent.com/tmux/tmux/master/CHANGES
+
+Describe the problem and the steps to reproduce. Add a minimal tmux config if
+necessary. Screenshots can be helpful, but no more than one or two.
+
+Do not report bugs (crashes, incorrect behaviour) without reproducing on a tmux
+built from the latest code in Git.
+
+### Required information
+
+Please provide the following information:
+
+* tmux version (`tmux -V`).
+* Platform (`uname -sp`).
+* $TERM inside and outside of tmux (`echo $TERM`).
+* Logs from tmux (`tmux kill-server; tmux -vv new`).

.github/README.md

@@ -0,0 +1,83 @@
+# Welcome to tmux!
+
+tmux is a terminal multiplexer: it enables a number of terminals to be created,
+accessed, and controlled from a single screen. tmux may be detached from a
+screen and continue running in the background, then later reattached.
+
+This release runs on OpenBSD, FreeBSD, NetBSD, Linux, OS X and Solaris.
+
+## Dependencies
+
+tmux depends on [libevent](https://libevent.org) 2.x, available from [this
+page](https://github.com/libevent/libevent/releases/latest).
+
+It also depends on [ncurses](https://www.gnu.org/software/ncurses/), available
+from [this page](https://invisible-mirror.net/archives/ncurses/).
+
+## Installation
+
+### From release tarball
+
+To build and install tmux from a release tarball, use:
+
+~~~bash
+./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.
+
+### From version control
+
+To get and build the latest from version control - note that this requires
+`autoconf`, `automake` and `pkg-config`:
+
+~~~bash
+git clone https://github.com/tmux/tmux.git
+cd tmux
+sh autogen.sh
+./configure && make
+~~~
+
+## Contributing
+
+Bug reports, feature suggestions and especially code contributions are most
+welcome. Please send by email to:
+
+tmux-users@googlegroups.com
+
+Or open a GitHub issue or pull request. **Please read [this
+document](CONTRIBUTING.md) before opening an issue.**
+
+There is [a list of suggestions for contributions](https://github.com/tmux/tmux/wiki/Contributing).
+Please feel free to ask on the mailing list if you're thinking of working on something or need
+further information.
+
+## Documentation
+
+For documentation on using tmux, see the tmux.1 manpage. View it from the
+source tree with:
+
+~~~bash
+nroff -mdoc tmux.1|less
+~~~
+
+A small example configuration is in `example_tmux.conf`.
+
+And a bash(1) completion file at:
+
+https://github.com/imomaliev/tmux-bash-completion
+
+For debugging, run tmux with `-v` or `-vv` to generate server and client log 
+files in the current directory.
+
+## Support
+
+The tmux mailing list for general discussion and bug reports is:
+
+https://groups.google.com/forum/#!forum/tmux-users
+
+Subscribe by sending an email to:
+
+tmux-users+subscribe@googlegroups.com

.gitignore

@@ -18,3 +18,4 @@ Makefile.in
 configure
 tmux.1.*
 *.dSYM
+cmd-parse.c

.travis.yml

@@ -1,10 +1,16 @@
 language: c
-matrix:
+
-    include:
+os:
-        - compiler: gcc
+    - linux
-        - compiler: clang
+    - osx
-          env: CFLAGS="-g -O2"
+
+compiler:
+    - gcc
+    - clang
+
 before_install:
-    - sudo apt-get update -qq
+    - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sudo apt-get update -qq; fi
-    - sudo apt-get -y install debhelper autotools-dev dh-autoreconf file libncurses5-dev libevent-dev pkg-config libutempter-dev build-essential
+    - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sudo apt-get -y install bison autotools-dev libncurses5-dev libevent-dev pkg-config libutempter-dev build-essential; fi
-script: (CFLAGS= ./autogen.sh) && ./configure --enable-debug && make
+
+script:
+    - ./autogen.sh && ./configure && make

CHANGES

@@ -1,4 +1,646 @@
-CHANGES FROM 2.2 to 2.3 29 September 2016
+CHANGES FROM 3.0 to 3.0a
+
+* Do not require REG_STARTEND.
+
+* Respawn panes or windows correctly if default-command is set.
+
+* Add missing option for after-kill-pane hook.
+
+* Fix for crash with a format variable that doesn't exist.
+
+* Do not truncate list-keys output on some platforms.
+
+* Do not crash when restoring a layout with only one pane.
+
+CHANGES FROM 2.9 to 3.0
+
+* Workaround invalid layout strings generated by older tmux versions and add
+  some additional sanity checks
+
+* xterm 348 now disables margins when resized, so send DECLRMM again after
+  resize.
+
+* Add support for the SD (scroll down) escape sequence.
+
+* Expand arguments to C and s format modifiers to match the m modifier.
+
+* Add support for underscore colours (Setulc capability must be added with
+  terminal-overrides as described in tmux(1)).
+
+* Add a "fill" style attribute for the fill colour of the drawing area (where
+  appropriate).
+
+* New -H flag to send-keys to send literal keys.
+
+* Format variables for pane mouse modes (mouse_utf8_flag and mouse_sgr_flag)
+  and for origin mode (origin_flag).
+
+* Add -F to refresh-client for flags for control mode clients, only one flag
+  (no-output) supported at the moment.
+
+* Add a few vi(1) keys for menus.
+
+* Add pane options, set with set-option -p and displayed with show-options -p.
+  Pane options inherit from window options (so every pane option is also
+  a window option). The pane style is now configured by setting window-style
+  and window-active-style in the pane options; select-pane -P and -g now change
+  the option but are no longer documented.
+
+* Do not document set-window-option and show-window-options. set-option -w and
+  show-options -w should be used instead.
+
+* Add a -A flag to show-options to show parent options as well (they are marked
+  with a *).
+
+* Resize panes lazily - do not resize unless they are in an attached, active
+  window.
+
+* Add regular expression support for the format search, match and substitute
+  modifiers and make them able to ignore case. find-window now accepts -r to
+  use regular expressions.
+
+* Do not use $TMUX to find the session because for windows in multiple sessions
+  it is wrong as often as it is right, and for windows in one session it is
+  pointless. Instead use TMUX_PANE if it is present.
+
+* Do not always resize the window back to its original size after applying a
+  layout, keep it at the layout size until it must be resized (for example when
+  attached and window-size is not manual).
+
+* Add new-session -X and attach-session -x to send SIGHUP to parent when
+  detaching (like detach-client -P).
+
+* Support for octal escapes in strings (such as \007) and improve list-keys
+  output so it parses correctly if copied into a configuration file.
+
+* INCOMPATIBLE: Add a new {} syntax to the configuration file. This is a string
+  similar to single quotes but also includes newlines and allows commands that
+  take other commands as string arguments to be expressed more clearly and
+  without additional escaping.
+
+  A literal { and } or a string containing { or } must now be escaped or
+  quoted, for example '{' and '}' instead of { or }, or 'X#{foo}' instead of
+  X#{foo}.
+
+* New <, >, <= and >= comparison operators for formats.
+
+* Improve escaping of special characters in list-keys output.
+
+* INCOMPATIBLE: tmux's configuration parsing has changed to use yacc(1). There
+  is one incompatible change: a \ on its own must be escaped or quoted as
+  either \\ or '\' (the latter works on older tmux versions).
+
+  Entirely the same parser is now used for parsing the configuration file
+  and for string commands. This means that constructs previously only
+  available in .tmux.conf, such as %if, can now be used in string commands
+  (for example, those given to if-shell - not commands invoked from the
+  shell, they are still parsed by the shell itself).
+
+* Add support for the overline attribute (SGR 53). The Smol capability is
+  needed in terminal-overrides.
+
+* Add the ability to create simple menus. Introduces new command
+  display-menu. Default menus are bound to MouseDown3 on the status line;
+  MouseDown3 or M-MouseDown3 on panes; MouseDown3 in tree, client and
+  buffer modes; and C-b C-m and C-b M-m.
+
+* Allow panes to be empty (no command). They can be created either by piping to
+  split-window -I, or by passing an empty command ('') to split-window. Output
+  can be sent to an existing empty window with display-message -I.
+
+* Add keys to jump between matching brackets (emacs C-M-f and C-M-b, vi %).
+
+* Add a -e flag to new-window, split-window, respawn-window, respawn-pane to
+  pass environment variables into the newly created process.
+
+* Hooks are now stored in the options tree as array options, allowing them to
+  have multiple separate commands. set-hook and show-hooks remain but
+  set-option and show-options can now also be used (show-options will only show
+  hooks if given the -H flag). Hooks with multiple commands are run in index
+  order.
+
+* Automatically scroll if dragging to create a selection with the mouse and the
+  cursor reaches the top or bottom line.
+
+* Add -no-clear variants of copy-selection and copy-pipe which do not clear the
+  selection after copying. Make copy-pipe clear the selection by default to be
+  consistent with copy-selection.
+
+* Add an argument to copy commands to set the prefix for the buffer name, this
+  (for example) allows buffers for different sessions to be named separately.
+
+* Update session activity on focus event.
+
+* Pass target from source-file into the config file parser so formats in %if
+  and %endif have access to more useful variables.
+
+* Add the ability to infer an option type (server, session, window) from its
+  name to show-options (it was already present in set-option).
+
+CHANGES FROM 2.9 to 2.9a
+
+* Fix bugs in select-pane and the main-horizontal and main-vertical layouts.
+
+CHANGES FROM 2.8 to 2.9
+
+* Attempt to preserve horizontal cursor position as well as vertical with
+  reflow.
+
+* Rewrite main-vertical and horizontal and change layouts to better handle the
+  case where all panes won't fit into the window size, reduce problems with
+  pane border status lines and fix other bugs mostly found by Thomas Sattler.
+
+* Add format variables for the default formats in the various modes
+  (tree_mode_format and so on) and add a -a flag to display-message to list
+  variables with values.
+
+* Add a -v flag to display-message to show verbose messages as the format is
+  parsed, this allows formats to be debugged
+
+* Add support for HPA (\033[`).
+
+* Add support for origin mode (\033[?6h).
+
+* No longer clear history on RIS.
+
+* Extend the #[] style syntax and use that together with previous format
+  changes to allow the status line to be entirely configured with a single
+  option.
+
+  Now that it is possible to configure their content, enable the existing code
+  that lets the status line be multiple lines in height. The status option can
+  now take a value of 2, 3, 4 or 5 (as well as the previous on or off) to
+  configure more than one line. The new status-format array option configures
+  the format of each line, the default just references the existing status-*
+  options, although some of the more obscure status options may be eliminated
+  in time.
+
+  Additions to the #[] syntax are: "align" to specify alignment (left, centre,
+  right), "list" for the window list and "range" to configure ranges of text
+  for the mouse bindings.
+
+  The "align" keyword can also be used to specify alignment of entries in tree
+  mode and the pane status lines.
+
+* Add E: and T: format modifiers to expand a format twice (useful to expand the
+  value of an option).
+
+* The individual -fg, -bg and -attr options have been removed; they
+  were superseded by -style options in tmux 1.9.
+
+* Allow more than one mode to be opened in a pane. Modes are kept on a stack
+  and retrieved if the same mode is entered again. Exiting the active mode goes
+  back to the previous one.
+
+* When showing command output in copy mode, call it view mode instead (affects
+  pane_mode format).
+
+* Add -b to display-panes like run-shell.
+
+* Handle UTF-8 in word-separators option.
+
+* New "terminal" colour allowing options to use the terminal default colour
+  rather than inheriting the default from a parent option.
+
+* Do not move the cursor in copy mode when the mouse wheel is used.
+
+* Use the same working directory rules for jobs as new windows rather than
+  always starting in the user's home.
+
+* Allow panes to be one line or column in size.
+
+* Go to last line when goto-line number is out of range in copy mode.
+
+* Yank previously cut text if any with C-y in the command prompt, only use the
+  buffer if no text has been cut.
+
+* Add q: format modifier to quote shell special characters.
+
+* Add StatusLeft and StatusRight mouse locations (keys such as
+  MouseDown1StatusLeft) for the status-left and status-right areas of the
+  status line.
+
+* Add -Z to find-window.
+
+* Support for windows larger than the client. This adds two new options,
+  window-size and default-size, and a new command, resize-window. The
+  force-width and force-height options and the session_width and session_height
+  formats have been removed.
+
+  The new window-size option tells tmux how to work out the size of windows:
+  largest means it picks the size of the largest session, smallest the smallest
+  session (similar to the old behaviour) and manual means that it does not
+  automatically resize windows. aggressive-resize modifies the choice of
+  session for largest and smallest as it did before.
+
+  If a window is in a session attached to a client that is too small, only part
+  of the window is shown. tmux attempts to keep the cursor visible, so the part
+  of the window displayed is changed as the cursor moves (with a small delay,
+  to try and avoid excess redrawing when applications redraw status lines or
+  similar that are not currently visible).
+
+  Drawing windows which are larger than the client is not as efficient as those
+  which fit, particularly when the cursor moves, so it is recommended to avoid
+  using this on slow machines or networks (set window-size to smallest or
+  manual).
+
+  The resize-window command can be used to resize a window manually. If it is
+  used, the window-size option is automatically set to manual for the window
+  (undo this with "setw -u window-size"). resize-window works in a similar way
+  to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a
+  sets the window to the size of the smallest client (what it would be if
+  window-size was smallest) and -A the largest.
+
+  For the same behaviour as force-width or force-height, use resize-window -x
+  or -y.
+
+  If the global window-size option is set to manual, the default-size option is
+  used for new windows. If -x or -y is used with new-session, that sets the
+  default-size option for the new session.
+
+  The maximum size of a window is 10000x10000. But expect applications to
+  complain and higher memory use if making a window that big. The minimum size
+  is the size required for the current layout including borders.
+
+  The refresh-client command can be used to pan around a window, -U -D -L -R
+  moves up, down, left or right and -c returns to automatic cursor
+  tracking. The position is reset when the current window is changed.
+
+CHANGES FROM 2.7 to 2.8
+
+* Make display-panes block the client until a pane is chosen or it
+  times out.
+
+* Clear history on RIS like most other terminals do.
+
+* Add an "Any" key to run a command if a key is pressed that is not
+  bound in the current key table.
+
+* Expand formats in load-buffer and save-buffer.
+
+* Add a rectangle_toggle format.
+
+* Add set-hook -R to run a hook immediately.
+
+* Add README.ja.
+
+* Add pane focus hooks.
+
+* Allow any punctuation as separator for s/x/y not only /.
+
+* Improve resizing with the mouse (fix resizing the wrong pane in some
+  layouts, and allow resizing multiple panes at the same time).
+
+* Allow , and } to be escaped in formats as #, and #}.
+
+* Add KRB5CCNAME to update-environment.
+
+* Change meaning of -c to display-message so the client is used if it
+  matches the session given to -t.
+
+* Fixes to : form of SGR.
+
+* Add x and X to choose-tree to kill sessions, windows or panes.
+
+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.
+
+* Fixes 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
 ====================
@@ -8,9 +650,9 @@ None.
 Normal Changes
 ==============
 
-* New option 'pane-border-status' to add text in the oane borders.
+* 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 supress errors for nonexistent files.
+* '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.
@@ -19,7 +661,7 @@ Normal Changes
 * '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
+CHANGES FROM 2.1 TO 2.2, 10 April 2016
 
 Incompatible Changes
 ====================
@@ -31,7 +673,7 @@ Incompatible Changes
 can be used.
 
 * Support for TMPDIR has been removed.  Use TMUX_TMPDIR instead.
-* UTF8 detection how happens automatically if the client supports it, hence
+* UTF8 detection now happens automatically if the client supports it, hence
   the:
 
   mouse-utf8
@@ -84,8 +726,7 @@ Normal Changes
 * 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
-CHANGES FROM 2.0 to 2.1 18 October 2015
 
 Incompatible Changes
 ====================
@@ -136,7 +777,7 @@ Normal Changes
 * Copy mode is exited if the history is cleared whilst in copy-mode.
 * 'copy-mode' learned '-e' to exit copy-mode when scrolling to end.
 
-CHANGES FROM 1.9a to 2.0 6 March 2015
+CHANGES FROM 1.9a TO 2.0, 06 March 2015
 
 Incompatible Changes
 ====================
@@ -195,9 +836,9 @@ Normal Changes
 * '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
+CHANGES FROM 1.9 TO 1.9a, 22 February 2014
 
-NOTE:  This is a bug-fix release to address some important bugs which just
+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
@@ -206,7 +847,7 @@ 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
+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
@@ -261,7 +902,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
 ====================
@@ -312,7 +953,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.
@@ -703,7 +1344,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.

COPYING

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

FAQ

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

Makefile.am

@@ -2,65 +2,57 @@
 
 # Obvious program stuff.
 bin_PROGRAMS = tmux
-CLEANFILES = tmux.1.mdoc tmux.1.man
+CLEANFILES = tmux.1.mdoc tmux.1.man cmd-parse.c
 
 # Distribution tarball options.
 EXTRA_DIST = \
-	CHANGES FAQ README TODO COPYING example_tmux.conf compat/*.[ch] \
+	CHANGES README README.ja COPYING example_tmux.conf compat/*.[ch] \
-	compat.h tmux.h osdep-*.c xmalloc.h mdoc2man.awk tmux.1
+	osdep-*.c mdoc2man.awk tmux.1
-dist-hook:
-	make clean
-	grep "^#found_debug=" configure
 
 # 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,
+# Additional object files.
-# so everyone has to add this.
+LDADD = $(LIBOBJS)
-if IS_GLIBC
-CFLAGS += -D_GNU_SOURCE
-endif
 
 # Set flags for gcc.
 if IS_GCC
-CFLAGS += -std=gnu99 -O2
+AM_CFLAGS += -std=gnu99 -O2
 if IS_DEBUG
-CFLAGS += -g
+AM_CFLAGS += -g
-CFLAGS += -Wno-long-long -Wall -W -Wformat=2
+AM_CFLAGS += -Wno-long-long -Wall -W -Wformat=2
-CFLAGS += -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations
+AM_CFLAGS += -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations
-CFLAGS += -Wwrite-strings -Wshadow -Wpointer-arith -Wsign-compare
+AM_CFLAGS += -Wwrite-strings -Wshadow -Wpointer-arith -Wsign-compare
-CFLAGS += -Wundef -Wbad-function-cast -Winline -Wcast-align
+AM_CFLAGS += -Wundef -Wbad-function-cast -Winline -Wcast-align
-CFLAGS += -Wdeclaration-after-statement -Wno-pointer-sign -Wno-attributes
+AM_CFLAGS += -Wdeclaration-after-statement -Wno-pointer-sign -Wno-attributes
-CPPFLAGS += -DDEBUG
+AM_CFLAGS += -Wno-unused-result
+AM_CPPFLAGS += -DDEBUG
 endif
-if IS_COVERAGE
+AM_CPPFLAGS += -iquote.
-CFLAGS += -g -O0 --coverage
-LDFLAGS += --coverage
-endif
-if IS_PROFILE
-CFLAGS += -g -O0 -pg
-LDFLAGS += -pg
-endif
-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
-DEFS += -D_LINUX_SOURCE_COMPAT=1
+AM_CPPFLAGS += -D_LINUX_SOURCE_COMPAT=1
+endif
+
+# Set flags for NetBSD.
+if IS_NETBSD
+AM_CPPFLAGS += -D_OPENBSD_SOURCE
 endif
 
 # List of sources.
@@ -74,18 +66,16 @@ dist_tmux_SOURCES = \
 	cmd-bind-key.c \
 	cmd-break-pane.c \
 	cmd-capture-pane.c \
-	cmd-choose-buffer.c \
-	cmd-choose-client.c \
 	cmd-choose-tree.c \
-	cmd-clear-history.c \
 	cmd-command-prompt.c \
 	cmd-confirm-before.c \
 	cmd-copy-mode.c \
 	cmd-detach-client.c \
+	cmd-display-menu.c \
 	cmd-display-message.c \
 	cmd-display-panes.c \
-	cmd-find.c \
 	cmd-find-window.c \
+	cmd-find.c \
 	cmd-if-shell.c \
 	cmd-join-pane.c \
 	cmd-kill-pane.c \
@@ -98,12 +88,12 @@ dist_tmux_SOURCES = \
 	cmd-list-panes.c \
 	cmd-list-sessions.c \
 	cmd-list-windows.c \
-	cmd-list.c \
 	cmd-load-buffer.c \
 	cmd-lock-server.c \
 	cmd-move-window.c \
 	cmd-new-session.c \
 	cmd-new-window.c \
+	cmd-parse.y \
 	cmd-paste-buffer.c \
 	cmd-pipe-pane.c \
 	cmd-queue.c \
@@ -111,6 +101,7 @@ dist_tmux_SOURCES = \
 	cmd-rename-session.c \
 	cmd-rename-window.c \
 	cmd-resize-pane.c \
+	cmd-resize-window.c \
 	cmd-respawn-pane.c \
 	cmd-respawn-window.c \
 	cmd-rotate-window.c \
@@ -122,14 +113,12 @@ 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 \
 	cmd-show-options.c \
 	cmd-source-file.c \
 	cmd-split-window.c \
-	cmd-string.c \
 	cmd-swap-pane.c \
 	cmd-swap-window.c \
 	cmd-switch-client.c \
@@ -137,13 +126,14 @@ dist_tmux_SOURCES = \
 	cmd-wait-for.c \
 	cmd.c \
 	colour.c \
-	control.c \
+	compat.h \
 	control-notify.c \
+	control.c \
 	environ.c \
 	format.c \
+	format-draw.c \
 	grid-view.c \
 	grid.c \
-	hooks.c \
 	input-keys.c \
 	input.c \
 	job.c \
@@ -153,13 +143,15 @@ dist_tmux_SOURCES = \
 	layout-set.c \
 	layout.c \
 	log.c \
-	mode-key.c \
+	menu.c \
+	mode-tree.c \
 	names.c \
 	notify.c \
 	options-table.c \
 	options.c \
 	paste.c \
 	proc.c \
+	regsub.c \
 	resize.c \
 	screen-redraw.c \
 	screen-write.c \
@@ -168,93 +160,37 @@ dist_tmux_SOURCES = \
 	server-fn.c \
 	server.c \
 	session.c \
-	signal.c \
+	spawn.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
 
+# Add compat file for forkpty.
+if NEED_FORKPTY
+nodist_tmux_SOURCES += compat/forkpty-@PLATFORM@.c
+endif
+
 # Add compat file for utf8proc.
 if HAVE_UTF8PROC
 nodist_tmux_SOURCES += compat/utf8proc.c
 endif
 
-# Add compat for missing or broken functions.
-if NO_FORKPTY
-nodist_tmux_SOURCES += compat/forkpty-@PLATFORM@.c
-endif
-if NO_IMSG
-nodist_tmux_SOURCES += compat/imsg.c compat/imsg-buffer.c
-endif
-if NO_CLOSEFROM
-nodist_tmux_SOURCES += compat/closefrom.c
-endif
-if NO_DAEMON
-nodist_tmux_SOURCES += compat/daemon.c
-endif
-if NO_GETPROGNAME
-nodist_tmux_SOURCES += compat/getprogname.c
-endif
-if NO_SETPROCTITLE
-nodist_tmux_SOURCES += compat/setproctitle.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_FPARSELN
-nodist_tmux_SOURCES += compat/fparseln.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
-endif
-if NO_REALLOCARRAY
-nodist_tmux_SOURCES += compat/reallocarray.c
-endif
-
 # Install tmux.1 in the right format.
 install-exec-hook:
 	if test x@MANFORMAT@ = xmdoc; then \
@@ -262,7 +198,7 @@ install-exec-hook:
 			>$(srcdir)/tmux.1.mdoc; \
 	else \
 		sed -e "s|@SYSCONFDIR@|$(sysconfdir)|g" $(srcdir)/tmux.1| \
-			$(AWK) -f$(srcdir)/mdoc2man.awk >$(srcdir)/tmux.1.man; \
+			$(AWK) -f $(srcdir)/mdoc2man.awk >$(srcdir)/tmux.1.man; \
 	fi
 	$(mkdir_p) $(DESTDIR)$(mandir)/man1
 	$(INSTALL_DATA) $(srcdir)/tmux.1.@MANFORMAT@ \

README

@@ -1,69 +1,75 @@
 Welcome to tmux!
 
-tmux is a "terminal multiplexer", it enables a number of terminals (or windows)
+tmux is a terminal multiplexer: it enables a number of terminals to be created,
-to be accessed and controlled from a single terminal. tmux is intended to be a
+accessed, and controlled from a single screen. tmux may be detached from a
-simple, modern, BSD-licensed alternative to programs such as GNU screen.
+screen and continue running in the background, then later reattached.
 
 This release runs on OpenBSD, FreeBSD, NetBSD, Linux, OS X and Solaris.
 
-tmux depends on libevent 2.x. Download it from:
+* Dependencies
 
-	http://libevent.org
+tmux depends on libevent 2.x, available from:
 
-To build tmux from a release tarball, do:
+	https://github.com/libevent/libevent/releases/latest
+
+It also depends on ncurses, available from:
+
+	https://invisible-mirror.net/archives/ncurses/
+
+* Installation
+
+To build and install tmux from a release tarball, use:
 
 	$ ./configure && make
 	$ sudo make install
 
-By default, tmux will use the utempter library to update utmp(5), if it is
+tmux can use the utempter library to update utmp(5), if it is installed - run
-installed. Run configure with --disable-utempter to disable this.
+configure with --enable-utempter to enable this.
 
-To get and build the latest from version control:
+To get and build the latest from version control - note that this requires
+autoconf, automake and pkg-config:
 
 	$ git clone https://github.com/tmux/tmux.git
 	$ cd tmux
 	$ sh autogen.sh
 	$ ./configure && make
 
-For more information see http://git-scm.com. Patches should be sent by email to
+* Contributing
-the mailing list at tmux-users@googlegroups.com.
-
-For documentation on using tmux, see the tmux.1 manpage. It can be viewed from
-the source tree with:
-
-	$ nroff -mdoc tmux.1|less
-
-Some common questions are answered in the FAQ file, a rough todo list is in the
-TODO file and an example configuration in example_tmux.conf.
-
-A vim(1) syntax file is available at:
-
-	https://github.com/keith/tmux.vim
-	https://raw.githubusercontent.com/keith/tmux.vim/master/syntax/tmux.vim
-
-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. For general discussion and bug reports:
-
-	https://groups.google.com/forum/#!forum/tmux-users
-
-And for Git commit emails:
-
-	https://groups.google.com/forum/#!forum/tmux-git
-
-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@googlegroups.com
 
-This file and the CHANGES, FAQ, SYNCING and TODO files are licensed under the
+Or open a GitHub issue or pull request.
-ISC license. All other files have a license and copyright notice at their start.
 
--- Nicholas Marriott <nicholas.marriott@gmail.com>
+* Documentation
+
+For documentation on using tmux, see the tmux.1 manpage. View it from the
+source tree with:
+
+	$ nroff -mdoc tmux.1|less
+
+A small example configuration is in example_tmux.conf.
+
+A bash(1) completion file is at:
+
+	https://github.com/imomaliev/tmux-bash-completion
+
+For debugging, run tmux with -v and -vv to generate server and client log files
+in the current directory.
+
+* Support
+
+The tmux mailing list for general discussion and bug reports is:
+
+	https://groups.google.com/forum/#!forum/tmux-users
+
+Subscribe by sending an email to:
+
+	tmux-users+subscribe@googlegroups.com
+
+* License
+
+This file and the CHANGES files are licensed under the ISC license. All other
+files have a license and copyright notice at their start.

README.ja

@@ -0,0 +1,62 @@
+tmuxへようこそ!
+
+tmuxはターミナルマルチプレクサーです。複数のターミナルを一つのスクリーン内に作成し、操作することができます。
+バックグラウンドで処理を実行中に一度スクリーンから離れて後から復帰することも可能です。
+
+OpenBSD、FreeBSD、NetBSD、Linux、OS X、Solarisで実行できます。
+
+tmuxはlibevent 2.x.に依存します。 下記からダウンロードしてください。
+
+	http://libevent.org
+
+また、ncursesも必要です。こちらからどうぞ。
+
+	http://invisible-island.net/ncurses/
+
+tarballでのtmuxのビルドとインストール方法。
+
+	$ ./configure && make
+	$ sudo make install
+
+tmuxはutmp(5)をアップデートするためにutempterを使うことができます。もしインストール済みであればオプション「--enable-utempter」をつけて実行してください。
+
+リポジトリから最新バージョンを手に入れるためには下記を実行。
+
+	$ git clone https://github.com/tmux/tmux.git
+	$ cd tmux
+	$ sh autogen.sh
+	$ ./configure && make
+
+(ビルドのためにはlibevent、ncurses libraries、headersに加えて、C compiler、make、autoconf、automake、pkg-configが必要です。)
+
+詳しい情報はhttp://git-scm.comをご覧ください。修正はメール<tmux-users@googlegroups.com>宛、もしくはhttps://github.com/tmux/tmux/issuesにて受け付けています。
+
+tmuxのドキュメントについてはtmux.1マニュアルをご覧ください。こちらのコマンドで参照可能です。
+
+	$ nroff -mdoc tmux.1|less
+
+サンプル設定は本リポジトリのexample_tmux.confに
+また、bash-completionファイルは下記にあります。
+
+	https://github.com/imomaliev/tmux-bash-completion
+
+「-v」や「-vv」を指定することでデバッグモードでの起動が可能です。カレントディレクトリにサーバーやクライアントのログファイルが生成されます。
+
+議論やバグレポート用のメーリングリストにはこちらから参加可能です。
+
+	https://groups.google.com/forum/#!forum/tmux-users
+
+gitコミットについての連絡先
+
+	https://groups.google.com/forum/#!forum/tmux-git
+
+購読は<tmux-users+subscribe@googlegroups.com>までメールをお願いします。
+
+バグレポートや機能追加(特にコードへの貢献)は大歓迎です。こちらにご連絡ください。
+
+	tmux-users@googlegroups.com
+
+本ファイル、CHANGES、 FAQ、SYNCINGそしてTODOはISC licenseで保護されています。
+その他のファイルのライセンスや著作権については、ファイルの上部に明記されています。
+
+-- Nicholas Marriott <nicholas.marriott@gmail.com>

SYNCING

@@ -140,15 +140,13 @@ to compat/ as and when appropriate.
 Release tmux for next version
 =============================
 
-1. Comment the "found_debug=yes" line in configure.ac, since releases
+1. Update and commit README and CHANGES.  The former should be checked for
-   don't have debugging enabled, otherwise make(1) aborts when
-   preparing the distribution.
-
-2. Update and commit README and CHANGES.  The former should be checked for
    anything outdated and updated with a list of things that might break
    upgrades and the latter should mention all the major changes since
    the last version.
 
+2. Make sure configure.ac has the new version number.
+
 3. Tag with:
 
    % git tag -a 2.X
@@ -157,7 +155,7 @@ Release tmux for next version
 
    Push the tag out with:
 
-   % git push 2.X
+   % git push --tags
 
 4. Build the tarball with 'make dist'.
 
@@ -168,9 +166,8 @@ Release tmux for next version
    Click the "Add release notes", upload the tarball and add a link in the
    description field to the CHANGES file.
 
-7. Clone the tmux.github.io repository, and change the RELEASE version in
+6. Clone the tmux.github.io repository, and change the RELEASE version in the
-   the Makefile.  Commit it, and run 'make' to replace %%VERSION%%.  Push
+   Makefile.  Commit it, and run 'make' to replace %%RELEASE%%.  Push the
-   the result out.
+   result out.
 
-8. Bump version in tmux/tmux.git configure.ac and uncomment "found_debug=yes" to
+7. Change version back to master in configure.ac.
-   create a debug build by default.

TODO

@@ -1,143 +0,0 @@
-- command bits and pieces:
-	* allow multiple targets: fnmatch for -t/-c, for example detach all
-	  clients with -t*
-	* add -c for new-session like new-window
-	* ' and " should be parsed the same (eg "\e" vs '\e') in config
-	  and command prompt
-	* last-pane across sessions
-	* list-keys should quote output so that bindings can just be used in
-          config file as-is
-	* resize-pane -p to match split-window -p
-
-- 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 (#{q:session_name})
-	* formats need conditions for >0 (for #P)
-	* 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)
-	* choose modes should ditch the key bindings and just have fixed keys, and
-          be more customized to their purpose (d to delete a buffer for choose-buffer,
-          a preview of buffer contents, etc)
-
-- improve monitor-*:
-	* straighten out rules for multiple clients
-	* think about what happens across sessions
-	* monitor changes within a region
-	* perhaps monitor /all/ panes in the window not just one
-
-- improve mouse support:
-	* bind commands to mouse in different areas? 
-	* commands executed when clicking on a pattern (URL)
-
-- warts on current naming:
-	* display-time but message-fg/bg/attr
-	* list-* vs show-*
-	* split-window -> split-pane?
-
-- better UTF-8 support:
-	* message display
-	* prompt input
-	* searching in copy mode
-
-- copy/paste improvements:
-	* incremental searching
-	* paste w/o trailing whitespace
-	* command to toggle selection not to move it in copy-mode
-	* regex searching
-	* copy-pipe should have -x as well
-	* copy mode key bindings should just be a standard key table, using
-          something like "copy-mode start-selection"; it could use
-          command-prompt for search, goto, etc:
-
-              bind -Temacs command-prompt -p'Search Up: ' 'copy-mode search-up %%'
-
-          it'd need a separate lookup, because modes are per-pane, perhaps a
-          table() cb to give the table name ("vi" or "emacs"). anything in the
-          table fires the command, anything not in the table is injected as a
-          key
-	* 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
-
-- 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
-	* 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
-	  not attached to a cell at all. this could be the time to introduce
-	  panelink to replace layout_cell
-	* way to set hints/limits about pane size for resizing
-	* panning over window (window larger than visible)
-	* a mode where one application can cross two panes (ie x|y, width =
-	  COLUMNS/2 but height = ROWS * 2)
-	* general key to space cells out evenly (horiz or vert) within their
-	  parent cell (could replace even-vert/even-horiz layouts)
-	* separate active panes for different clients
-
-- terminfo bits
-	* use a better termcap internally instead of screen, perhaps xterm
-	* use screen-256color when started on 256 colour terminal?
-
-- 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
-	* 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(),
-	  kill_window(), unlink_window(), kill_session() that fix up all data
-	  structures (flagging sessions as dead) and return a value to say
-	  whether clients need to be checked for dead sessions? sort of like
-	  session_detach now but more so. or some other scheme to make it
-	  simpler and clearer? also would be nice to remove/rename server-fn.c
-	* more readable way to work out the various things commands need to
-	  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)
-		- 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
-	* we do more work than we should if a single read() contains operations
-          that cancel each other out: for example, writing twice to the same
-          cell, or writing and then clearing a line; it would be nice to
-          optimize these. would it mean processing the entire read() data first
-          then applying changes? or an initial optimization step? or something
-          else?
-
-- miscellaneous
-	* way to keep a job running just read its last line of output for #()
-	* 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. 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?
-	* customizable command aliases
-	* automatic pane logging
-	* BCE? We are halfway there (output side is done for pane backgrounds),
-	  just need to change how screen/grid handles erase

alerts.c

@@ -19,88 +19,84 @@
 #include <sys/types.h>
 
 #include <event.h>
+#include <stdlib.h>
 
 #include "tmux.h"
 
-int	alerts_fired;
+static int	alerts_fired;
 
-void	alerts_timer(int, short, void *);
+static void	alerts_timer(int, short, void *);
-int	alerts_enabled(struct window *, int);
+static int	alerts_enabled(struct window *, int);
-void	alerts_callback(int, short, void *);
+static void	alerts_callback(int, short, void *);
-void	alerts_reset(struct window *);
+static void	alerts_reset(struct window *);
 
-void	alerts_run_hook(struct session *, struct winlink *, int);
+static int	alerts_action_applies(struct winlink *, const char *);
-int	alerts_check_all(struct session *, struct winlink *);
+static int	alerts_check_all(struct window *);
-int	alerts_check_bell(struct session *, struct winlink *);
+static int	alerts_check_bell(struct window *);
-int	alerts_check_activity(struct session *, struct winlink *);
+static int	alerts_check_activity(struct window *);
-int	alerts_check_silence(struct session *, struct winlink *);
+static int	alerts_check_silence(struct window *);
-void	alerts_ring_bell(struct session *);
+static void	alerts_set_message(struct winlink *, const char *,
+		    const char *);
 
-void
+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_reset(w);
 	alerts_queue(w, WINDOW_SILENCE);
 }
 
-void
+static void
 alerts_callback(__unused int fd, __unused short events, __unused void *arg)
 {
-	struct window	*w;
+	struct window	*w, *w1;
-	struct session	*s;
+	int		 alerts;
-	struct winlink	*wl;
-	int		 flags, alerts;
 
-	RB_FOREACH(w, windows, &windows) {
+	TAILQ_FOREACH_SAFE(w, &alerts_list, alerts_entry, w1) {
-		RB_FOREACH(s, sessions, &sessions) {
+		alerts = alerts_check_all(w);
-			RB_FOREACH(wl, winlinks, &s->windows) {
+		log_debug("@%u alerts check, alerts %#x", w->id, alerts);
-				if (wl->window != w)
-					continue;
-				flags = w->flags;
 
-				alerts = alerts_check_all(s, wl);
+		w->alerts_queued = 0;
+		TAILQ_REMOVE(&alerts_list, w, alerts_entry);
 
-				log_debug("%s:%d @%u alerts check, alerts %#x, "
+		w->flags &= ~WINDOW_ALERTFLAGS;
-				    "flags %#x", s->name, wl->idx, w->id,
+		window_remove_ref(w, __func__);
-				    alerts, flags);
-			}
-		}
 	}
 	alerts_fired = 0;
 }
 
-void
+static int
-alerts_run_hook(struct session *s, struct winlink *wl, int flags)
+alerts_action_applies(struct winlink *wl, const char *name)
 {
-	struct cmd_find_state	 fs;
+	int	action;
 
-	if (cmd_find_from_winlink(&fs, s, wl) != 0)
+	/*
-		return;
+	 * {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.
+	 */
 
-	if (flags & WINDOW_BELL)
+	action = options_get_number(wl->session->options, name);
-		hooks_run(s->hooks, NULL, &fs, "alert-bell");
+	if (action == ALERT_ANY)
-	if (flags & WINDOW_SILENCE)
+		return (1);
-		hooks_run(s->hooks, NULL, &fs, "alert-silence");
+	if (action == ALERT_CURRENT)
-	if (flags & WINDOW_ACTIVITY)
+		return (wl == wl->session->curw);
-		hooks_run(s->hooks, NULL, &fs, "alert-activity");
+	if (action == ALERT_OTHER)
+		return (wl != wl->session->curw);
+	return (0);
 }
 
-int
+static int
-alerts_check_all(struct session *s, struct winlink *wl)
+alerts_check_all(struct window *w)
 {
 	int	alerts;
 
-	alerts  = alerts_check_bell(s, wl);
+	alerts	= alerts_check_bell(w);
-	alerts |= alerts_check_activity(s, wl);
+	alerts |= alerts_check_activity(w);
-	alerts |= alerts_check_silence(s, wl);
+	alerts |= alerts_check_silence(w);
-	if (alerts != 0) {
-		alerts_run_hook(s, wl, alerts);
-		server_status_session(s);
-	}
-
 	return (alerts);
 }
 
@@ -110,14 +106,16 @@ alerts_check_session(struct session *s)
 	struct winlink	*wl;
 
 	RB_FOREACH(wl, winlinks, &s->windows)
-		alerts_check_all(s, wl);
+		alerts_check_all(wl->window);
 }
 
-int
+static int
 alerts_enabled(struct window *w, int flags)
 {
-	if (flags & WINDOW_BELL)
+	if (flags & WINDOW_BELL) {
-		return (1);
+		if (options_get_number(w->options, "monitor-bell"))
+			return (1);
+	}
 	if (flags & WINDOW_ACTIVITY) {
 		if (options_get_number(w->options, "monitor-activity"))
 			return (1);
@@ -138,11 +136,14 @@ alerts_reset_all(void)
 		alerts_reset(w);
 }
 
-void
+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);
 
@@ -157,138 +158,166 @@ alerts_reset(struct window *w)
 void
 alerts_queue(struct window *w, int flags)
 {
-	if (w->flags & WINDOW_ACTIVITY)
+	alerts_reset(w);
-		alerts_reset(w);
-
-	if (!event_initialized(&w->alerts_timer))
-		evtimer_set(&w->alerts_timer, alerts_timer, w);
 
 	if ((w->flags & flags) != flags) {
 		w->flags |= flags;
 		log_debug("@%u alerts flags added %#x", w->id, flags);
 	}
 
-	if (!alerts_fired && alerts_enabled(w, flags)) {
+	if (alerts_enabled(w, flags)) {
-		log_debug("alerts check queued (by @%u)", w->id);
+		if (!w->alerts_queued) {
-		event_once(-1, EV_TIMEOUT, alerts_callback, NULL, NULL);
+			w->alerts_queued = 1;
-		alerts_fired = 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;
+		}
 	}
 }
 
-int
+static int
-alerts_check_bell(struct session *s, struct winlink *wl)
+alerts_check_bell(struct window *w)
 {
-	struct client	*c;
+	struct winlink	*wl;
-	struct window	*w = wl->window;
+	struct session	*s;
-	int		 action, visual;
 
-	if (!(w->flags & WINDOW_BELL))
+	if (~w->flags & WINDOW_BELL)
 		return (0);
-	if (s->curw != wl) {
+	if (!options_get_number(w->options, "monitor-bell"))
-		wl->flags |= WINLINK_BELL;
-		w->flags &= ~WINDOW_BELL;
-	}
-	if (s->curw->window == w)
-		w->flags &= ~WINDOW_BELL;
-
-	action = options_get_number(s->options, "bell-action");
-	if (action == BELL_NONE)
 		return (0);
 
-	visual = options_get_number(s->options, "visual-bell");
+	TAILQ_FOREACH(wl, &w->winlinks, wentry)
-	TAILQ_FOREACH(c, &clients, entry) {
+		wl->session->flags &= ~SESSION_ALERTED;
-		if (c->session != s || c->flags & CLIENT_CONTROL)
+
-			continue;
+	TAILQ_FOREACH(wl, &w->winlinks, wentry) {
-		if (!visual) {
+		/*
-			if ((action == BELL_CURRENT &&
+		 * Bells are allowed even if there is an existing bell (so do
-			    c->session->curw->window == w) ||
+		 * not check WINLINK_BELL).
-			    (action == BELL_OTHER &&
+		 */
-			    c->session->curw->window != w) ||
+		s = wl->session;
-			    action == BELL_ANY)
+		if (s->curw != wl) {
-				tty_putcode(&c->tty, TTYC_BEL);
+			wl->flags |= WINLINK_BELL;
-			continue;
+			server_status_session(s);
 		}
-		if (action == BELL_CURRENT && c->session->curw->window == w)
+		if (!alerts_action_applies(wl, "bell-action"))
-			status_message_set(c, "Bell in current window");
+			continue;
-		else if (action == BELL_ANY || (action == BELL_OTHER &&
+		notify_winlink("alert-bell", wl);
-		    c->session->curw->window != w))
+
-			status_message_set(c, "Bell in window %d", wl->idx);
+		if (s->flags & SESSION_ALERTED)
+			continue;
+		s->flags |= SESSION_ALERTED;
+
+		alerts_set_message(wl, "Bell", "visual-bell");
 	}
 
 	return (WINDOW_BELL);
 }
 
-int
+static int
-alerts_check_activity(struct session *s, struct winlink *wl)
+alerts_check_activity(struct window *w)
 {
-	struct client	*c;
+	struct winlink	*wl;
-	struct window	*w = wl->window;
+	struct session	*s;
 
-	if (s->curw->window == w)
+	if (~w->flags & WINDOW_ACTIVITY)
-		w->flags &= ~WINDOW_ACTIVITY;
-
-	if (!(w->flags & WINDOW_ACTIVITY) || wl->flags & WINLINK_ACTIVITY)
 		return (0);
-	if (s->curw == wl)
-		return (0);
-
 	if (!options_get_number(w->options, "monitor-activity"))
 		return (0);
 
-	if (options_get_number(s->options, "bell-on-alert"))
+	TAILQ_FOREACH(wl, &w->winlinks, wentry)
-		alerts_ring_bell(s);
+		wl->session->flags &= ~SESSION_ALERTED;
-	wl->flags |= WINLINK_ACTIVITY;
 
-	if (options_get_number(s->options, "visual-activity")) {
+	TAILQ_FOREACH(wl, &w->winlinks, wentry) {
-		TAILQ_FOREACH(c, &clients, entry) {
+		if (wl->flags & WINLINK_ACTIVITY)
-			if (c->session != s)
+			continue;
-				continue;
+		s = wl->session;
-			status_message_set(c, "Activity in window %d", wl->idx);
+		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);
 }
 
-int
+static int
-alerts_check_silence(struct session *s, struct winlink *wl)
+alerts_check_silence(struct window *w)
 {
-	struct client	*c;
+	struct winlink	*wl;
-	struct window	*w = wl->window;
+	struct session	*s;
 
-	if (s->curw->window == w)
+	if (~w->flags & WINDOW_SILENCE)
-		w->flags &= ~WINDOW_SILENCE;
-
-	if (!(w->flags & WINDOW_SILENCE) || wl->flags & WINLINK_SILENCE)
 		return (0);
-	if (s->curw == wl)
-		return (0);
-
 	if (options_get_number(w->options, "monitor-silence") == 0)
 		return (0);
 
-	if (options_get_number(s->options, "bell-on-alert"))
+	TAILQ_FOREACH(wl, &w->winlinks, wentry)
-		alerts_ring_bell(s);
+		wl->session->flags &= ~SESSION_ALERTED;
-	wl->flags |= WINLINK_SILENCE;
 
-	if (options_get_number(s->options, "visual-silence")) {
+	TAILQ_FOREACH(wl, &w->winlinks, wentry) {
-		TAILQ_FOREACH(c, &clients, entry) {
+		if (wl->flags & WINLINK_SILENCE)
-			if (c->session != s)
+			continue;
-				continue;
+		s = wl->session;
-			status_message_set(c, "Silence in window %d", wl->idx);
+		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);
 }
 
-void
+static void
-alerts_ring_bell(struct session *s)
+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 == s && !(c->flags & CLIENT_CONTROL))
+		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

@@ -28,49 +28,33 @@
  * Manipulate command arguments.
  */
 
+struct args_value {
+	char			*value;
+	TAILQ_ENTRY(args_value)	 entry;
+};
+TAILQ_HEAD(args_values, args_value);
+
 struct args_entry {
 	u_char			 flag;
-	char			*value;
+	struct args_values	 values;
+	u_int			 count;
 	RB_ENTRY(args_entry)	 entry;
 };
 
-struct args_entry	*args_find(struct args *, u_char);
+static struct args_entry	*args_find(struct args *, u_char);
 
-RB_GENERATE(args_tree, args_entry, entry, args_cmp);
+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;
@@ -115,12 +99,18 @@ args_free(struct args *args)
 {
 	struct args_entry	*entry;
 	struct args_entry	*entry1;
+	struct args_value	*value;
+	struct args_value	*value1;
 
 	cmd_free_argv(args->argc, args->argv);
 
 	RB_FOREACH_SAFE(entry, args_tree, &args->tree, entry1) {
 		RB_REMOVE(args_tree, &args->tree, entry);
-		free(entry->value);
+		TAILQ_FOREACH_SAFE(value, &entry->values, entry, value1) {
+			TAILQ_REMOVE(&entry->values, value, entry);
+			free(value->value);
+			free(value);
+		}
 		free(entry);
 	}
 
@@ -146,6 +136,37 @@ args_print_add(char **buf, size_t *len, const char *fmt, ...)
 	free(s);
 }
 
+/* Add value to string. */
+static void
+args_print_add_value(char **buf, size_t *len, struct args_entry *entry,
+    struct args_value *value)
+{
+	char	*escaped;
+
+	if (**buf != '\0')
+		args_print_add(buf, len, " -%c ", entry->flag);
+	else
+		args_print_add(buf, len, "-%c ", entry->flag);
+
+	escaped = args_escape(value->value);
+	args_print_add(buf, len, "%s", escaped);
+	free(escaped);
+}
+
+/* Add argument to string. */
+static void
+args_print_add_argument(char **buf, size_t *len, const char *argument)
+{
+	char	*escaped;
+
+	if (**buf != '\0')
+		args_print_add(buf, len, " ");
+
+	escaped = args_escape(argument);
+	args_print_add(buf, len, "%s", escaped);
+	free(escaped);
+}
+
 /* Print a set of arguments. */
 char *
 args_print(struct args *args)
@@ -153,74 +174,108 @@ args_print(struct args *args)
 	size_t		 	 len;
 	char			*buf;
 	int			 i;
+	u_int			 j;
 	struct args_entry	*entry;
+	struct args_value	*value;
 
 	len = 1;
 	buf = xcalloc(1, len);
 
 	/* Process the flags first. */
 	RB_FOREACH(entry, args_tree, &args->tree) {
-		if (entry->value != NULL)
+		if (!TAILQ_EMPTY(&entry->values))
 			continue;
 
 		if (*buf == '\0')
 			args_print_add(&buf, &len, "-");
-		args_print_add(&buf, &len, "%c", entry->flag);
+		for (j = 0; j < entry->count; j++)
+			args_print_add(&buf, &len, "%c", entry->flag);
 	}
 
 	/* Then the flags with arguments. */
 	RB_FOREACH(entry, args_tree, &args->tree) {
-		if (entry->value == NULL)
+		TAILQ_FOREACH(value, &entry->values, entry)
-			continue;
+			args_print_add_value(&buf, &len, entry, value);
-
-		if (*buf != '\0')
-			args_print_add(&buf, &len, " -%c ", entry->flag);
-		else
-			args_print_add(&buf, &len, "-%c ", entry->flag);
-		if (strchr(entry->value, ' ') != NULL)
-			args_print_add(&buf, &len, "\"%s\"", entry->value);
-		else
-			args_print_add(&buf, &len, "%s", entry->value);
 	}
 
 	/* And finally the argument vector. */
-	for (i = 0; i < args->argc; i++) {
+	for (i = 0; i < args->argc; i++)
-		if (*buf != '\0')
+		args_print_add_argument(&buf, &len, args->argv[i]);
-			args_print_add(&buf, &len, " ");
-		if (strchr(args->argv[i], ' ') != NULL)
-			args_print_add(&buf, &len, "\"%s\"", args->argv[i]);
-		else
-			args_print_add(&buf, &len, "%s", args->argv[i]);
-	}
 
 	return (buf);
 }
 
+/* Escape an argument. */
+char *
+args_escape(const char *s)
+{
+	static const char	 quoted[] = " #\"';${}";
+	char			*escaped, *result;
+	int			 flags;
+
+	if (*s == '\0')
+		return (xstrdup(s));
+	if (s[0] != ' ' &&
+	    (strchr(quoted, s[0]) != NULL || s[0] == '~') &&
+	    s[1] == '\0') {
+		xasprintf(&escaped, "\\%c", s[0]);
+		return (escaped);
+	}
+
+	flags = VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL;
+	if (s[strcspn(s, quoted)] != '\0')
+		flags |= VIS_DQ;
+	utf8_stravis(&escaped, s, flags);
+
+	if (flags & VIS_DQ) {
+		if (*escaped == '~')
+			xasprintf(&result, "\"\\%s\"", escaped);
+		else
+			xasprintf(&result, "\"%s\"", escaped);
+	} else {
+		if (*escaped == '~')
+			xasprintf(&result, "\\%s", escaped);
+		else
+			result = xstrdup(escaped);
+	}
+	free(escaped);
+	return (result);
+}
+
 /* Return if an argument is present. */
 int
 args_has(struct args *args, u_char ch)
 {
-	return (args_find(args, ch) == NULL ? 0 : 1);
+	struct args_entry	*entry;
+
+	entry = args_find(args, ch);
+	if (entry == NULL)
+		return (0);
+	return (entry->count);
 }
 
 /* Set argument value in the arguments tree. */
 void
-args_set(struct args *args, u_char ch, const char *value)
+args_set(struct args *args, u_char ch, const char *s)
 {
 	struct args_entry	*entry;
+	struct args_value	*value;
 
-	/* Replace existing argument. */
+	entry = args_find(args, ch);
-	if ((entry = args_find(args, ch)) != NULL) {
+	if (entry == NULL) {
-		free(entry->value);
-		entry->value = NULL;
-	} else {
 		entry = xcalloc(1, sizeof *entry);
 		entry->flag = ch;
+		entry->count = 1;
+		TAILQ_INIT(&entry->values);
 		RB_INSERT(args_tree, &args->tree, entry);
-	}
+	} else
+		entry->count++;
 
-	if (value != NULL)
+	if (s != NULL) {
-		entry->value = xstrdup(value);
+		value = xcalloc(1, sizeof *value);
+		value->value = xstrdup(s);
+		TAILQ_INSERT_TAIL(&entry->values, value, entry);
+	}
 }
 
 /* Get argument value. Will be NULL if it isn't present. */
@@ -231,7 +286,34 @@ args_get(struct args *args, u_char ch)
 
 	if ((entry = args_find(args, ch)) == NULL)
 		return (NULL);
-	return (entry->value);
+	return (TAILQ_LAST(&entry->values, args_values)->value);
+}
+
+/* Get first value in argument. */
+const char *
+args_first_value(struct args *args, u_char ch, struct args_value **value)
+{
+	struct args_entry	*entry;
+
+	if ((entry = args_find(args, ch)) == NULL)
+		return (NULL);
+
+	*value = TAILQ_FIRST(&entry->values);
+	if (*value == NULL)
+		return (NULL);
+	return ((*value)->value);
+}
+
+/* Get next value in argument. */
+const char *
+args_next_value(struct args_value **value)
+{
+	if (*value == NULL)
+		return (NULL);
+	*value = TAILQ_NEXT(*value, entry);
+	if (*value == NULL)
+		return (NULL);
+	return ((*value)->value);
 }
 
 /* Convert an argument value to a number. */
@@ -242,13 +324,15 @@ args_strtonum(struct args *args, u_char ch, long long minval, long long maxval,
 	const char		*errstr;
 	long long 	 	 ll;
 	struct args_entry	*entry;
+	struct args_value	*value;
 
 	if ((entry = args_find(args, ch)) == NULL) {
 		*cause = xstrdup("missing");
 		return (0);
 	}
+	value = TAILQ_LAST(&entry->values, args_values);
 
-	ll = strtonum(entry->value, minval, maxval, &errstr);
+	ll = strtonum(value->value, minval, maxval, &errstr);
 	if (errstr != NULL) {
 		*cause = xstrdup(errstr);
 		return (0);

attributes.c

@@ -23,22 +23,28 @@
 #include "tmux.h"
 
 const char *
-attributes_tostring(u_char attr)
+attributes_tostring(int attr)
 {
-	static char	buf[128];
+	static char	buf[512];
 	size_t		len;
 
 	if (attr == 0)
 		return ("none");
 
-	len = xsnprintf(buf, sizeof buf, "%s%s%s%s%s%s%s",
+	len = xsnprintf(buf, sizeof buf, "%s%s%s%s%s%s%s%s%s%s%s%s%s",
-		attr & GRID_ATTR_BRIGHT ? "bright," : "",
+	    (attr & GRID_ATTR_BRIGHT) ? "bright," : "",
-		attr & GRID_ATTR_DIM ? "dim," : "",
+	    (attr & GRID_ATTR_DIM) ? "dim," : "",
-		attr & GRID_ATTR_UNDERSCORE ? "underscore," : "",
+	    (attr & GRID_ATTR_UNDERSCORE) ? "underscore," : "",
-		attr & GRID_ATTR_BLINK ? "blink," : "",
+	    (attr & GRID_ATTR_BLINK)? "blink," : "",
-		attr & GRID_ATTR_REVERSE ? "reverse," : "",
+	    (attr & GRID_ATTR_REVERSE) ? "reverse," : "",
-		attr & GRID_ATTR_HIDDEN ? "hidden," : "",
+	    (attr & GRID_ATTR_HIDDEN) ? "hidden," : "",
-		attr & GRID_ATTR_ITALICS ? "italics," : "");
+	    (attr & GRID_ATTR_ITALICS) ? "italics," : "",
+	    (attr & GRID_ATTR_STRIKETHROUGH) ? "strikethrough," : "",
+	    (attr & GRID_ATTR_UNDERSCORE_2) ? "double-underscore," : "",
+	    (attr & GRID_ATTR_UNDERSCORE_3) ? "curly-underscore," : "",
+	    (attr & GRID_ATTR_UNDERSCORE_4) ? "dotted-underscore," : "",
+	    (attr & GRID_ATTR_UNDERSCORE_5) ? "dashed-underscore," : "",
+	    (attr & GRID_ATTR_OVERLINE) ? "overline," : "");
 	if (len > 0)
 		buf[len - 1] = '\0';
 
@@ -49,8 +55,28 @@ int
 attributes_fromstring(const char *str)
 {
 	const char	delimiters[] = " ,|";
-	u_char		attr;
+	int		attr;
 	size_t		end;
+	u_int		i;
+	struct {
+		const char*	name;
+		int		attr;
+	} table[] = {
+		{ "bright", GRID_ATTR_BRIGHT },
+		{ "bold", GRID_ATTR_BRIGHT },
+		{ "dim", GRID_ATTR_DIM },
+		{ "underscore", GRID_ATTR_UNDERSCORE },
+		{ "blink", GRID_ATTR_BLINK },
+		{ "reverse", GRID_ATTR_REVERSE },
+		{ "hidden", GRID_ATTR_HIDDEN },
+		{ "italics", GRID_ATTR_ITALICS },
+		{ "strikethrough", GRID_ATTR_STRIKETHROUGH },
+		{ "double-underscore", GRID_ATTR_UNDERSCORE_2 },
+		{ "curly-underscore", GRID_ATTR_UNDERSCORE_3 },
+		{ "dotted-underscore", GRID_ATTR_UNDERSCORE_4 },
+		{ "dashed-underscore", GRID_ATTR_UNDERSCORE_5 },
+		{ "overline", GRID_ATTR_OVERLINE }
+	};
 
 	if (*str == '\0' || strcspn(str, delimiters) == 0)
 		return (-1);
@@ -63,22 +89,15 @@ attributes_fromstring(const char *str)
 	attr = 0;
 	do {
 		end = strcspn(str, delimiters);
-		if ((end == 6 && strncasecmp(str, "bright", end) == 0) ||
+		for (i = 0; i < nitems(table); i++) {
-		    (end == 4 && strncasecmp(str, "bold", end) == 0))
+			if (end != strlen(table[i].name))
-			attr |= GRID_ATTR_BRIGHT;
+				continue;
-		else if (end == 3 && strncasecmp(str, "dim", end) == 0)
+			if (strncasecmp(str, table[i].name, end) == 0) {
-			attr |= GRID_ATTR_DIM;
+				attr |= table[i].attr;
-		else if (end == 10 && strncasecmp(str, "underscore", end) == 0)
+				break;
-			attr |= GRID_ATTR_UNDERSCORE;
+			}
-		else if (end == 5 && strncasecmp(str, "blink", end) == 0)
+		}
-			attr |= GRID_ATTR_BLINK;
+		if (i == nitems(table))
-		else if (end == 7 && strncasecmp(str, "reverse", end) == 0)
-			attr |= GRID_ATTR_REVERSE;
-		else if (end == 6 && strncasecmp(str, "hidden", end) == 0)
-			attr |= GRID_ATTR_HIDDEN;
-		else if (end == 7 && strncasecmp(str, "italics", end) == 0)
-			attr |= GRID_ATTR_ITALICS;
-		else
 			return (-1);
 		str += end + strspn(str + end, delimiters);
 	} while (*str != '\0');

autogen.sh

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

cfg.c

@@ -23,19 +23,41 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
 
 #include "tmux.h"
 
-char		 *cfg_file;
+struct client		 *cfg_client;
-struct cmd_q	 *cfg_cmd_q;
+static char		 *cfg_file;
-int		  cfg_finished;
+int			  cfg_finished;
-int		  cfg_references;
+static char		**cfg_causes;
-char		**cfg_causes;
+static u_int		  cfg_ncauses;
-u_int		  cfg_ncauses;
+static struct cmdq_item	 *cfg_item;
-struct client	 *cfg_client;
 
-void	cfg_default_done(struct cmd_q *);
+static enum cmd_retval
+cfg_client_done(__unused struct cmdq_item *item, __unused void *data)
+{
+	if (!cfg_finished)
+		return (CMD_RETURN_WAIT);
+	return (CMD_RETURN_NORMAL);
+}
+
+static enum cmd_retval
+cfg_done(__unused struct cmdq_item *item, __unused void *data)
+{
+	if (cfg_finished)
+		return (CMD_RETURN_NORMAL);
+	cfg_finished = 1;
+
+	if (!RB_EMPTY(&sessions))
+		cfg_show_causes(RB_MIN(sessions, &sessions));
+
+	if (cfg_item != NULL)
+		cmdq_continue(cfg_item);
+
+	status_prompt_load_history();
+
+	return (CMD_RETURN_NORMAL);
+}
 
 void
 set_cfg_file(const char *path)
@@ -48,109 +70,89 @@ void
 start_cfg(void)
 {
 	const char	*home;
-	int		 quiet = 0;
+	int		 flags = 0;
+	struct client	*c;
 
-	cfg_cmd_q = cmdq_new(NULL);
+	/*
-	cfg_cmd_q->emptyfn = cfg_default_done;
+	 * Configuration files are loaded without a client, so commands are 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.
+	 */
+	cfg_client = c = TAILQ_FIRST(&clients);
+	if (c != NULL) {
+		cfg_item = cmdq_get_callback(cfg_client_done, NULL);
+		cmdq_append(c, cfg_item);
+	}
 
-	cfg_finished = 0;
+	if (cfg_file == NULL)
-	cfg_references = 1;
+		load_cfg(TMUX_CONF, c, NULL, CMD_PARSE_QUIET, NULL);
-
-	cfg_client = TAILQ_FIRST(&clients);
-	if (cfg_client != NULL)
-		cfg_client->references++;
-
-	load_cfg(TMUX_CONF, cfg_cmd_q, 1);
 
 	if (cfg_file == NULL && (home = find_home()) != NULL) {
 		xasprintf(&cfg_file, "%s/.tmux.conf", home);
-		quiet = 1;
+		flags = CMD_PARSE_QUIET;
 	}
 	if (cfg_file != NULL)
-		load_cfg(cfg_file, cfg_cmd_q, quiet);
+		load_cfg(cfg_file, c, NULL, flags, NULL);
 
-	cmdq_continue(cfg_cmd_q);
+	cmdq_append(NULL, cmdq_get_callback(cfg_done, NULL));
 }
 
 int
-load_cfg(const char *path, struct cmd_q *cmdq, int quiet)
+load_cfg(const char *path, struct client *c, struct cmdq_item *item, int flags,
+    struct cmdq_item **new_item)
 {
-	FILE		*f;
+	FILE			*f;
-	char		 delim[3] = { '\\', '\\', '\0' };
+	struct cmd_parse_input	 pi;
-	u_int		 found;
+	struct cmd_parse_result	*pr;
-	size_t		 line = 0;
+	struct cmdq_item	*new_item0;
-	char		*buf, *cause1, *p;
+
-	struct cmd_list	*cmdlist;
+	if (new_item != NULL)
+		*new_item = NULL;
 
 	log_debug("loading %s", path);
 	if ((f = fopen(path, "rb")) == NULL) {
-		if (errno == ENOENT && quiet)
+		if (errno == ENOENT && (flags & CMD_PARSE_QUIET))
 			return (0);
 		cfg_add_cause("%s: %s", path, strerror(errno));
 		return (-1);
 	}
 
-	found = 0;
+	memset(&pi, 0, sizeof pi);
-	while ((buf = fparseln(f, NULL, &line, delim, 0)) != NULL) {
+	pi.flags = flags;
-		log_debug("%s: %s", path, buf);
+	pi.file = path;
+	pi.line = 1;
+	pi.item = item;
+	pi.c = c;
 
-		/* Skip empty lines. */
+	pr = cmd_parse_from_file(f, &pi);
-		p = buf;
-		while (isspace((u_char) *p))
-			p++;
-		if (*p == '\0') {
-			free(buf);
-			continue;
-		}
-
-		/* Parse and run the command. */
-		if (cmd_string_parse(p, &cmdlist, path, line, &cause1) != 0) {
-			free(buf);
-			if (cause1 == NULL)
-				continue;
-			cfg_add_cause("%s:%zu: %s", path, line, cause1);
-			free(cause1);
-			continue;
-		}
-		free(buf);
-
-		if (cmdlist == NULL)
-			continue;
-		cmdq_append(cmdq, cmdlist, NULL);
-		cmd_list_free(cmdlist);
-		found++;
-	}
 	fclose(f);
-
+	if (pr->status == CMD_PARSE_EMPTY)
-	return (found);
+		return (0);
-}
+	if (pr->status == CMD_PARSE_ERROR) {
-
+		cfg_add_cause("%s", pr->error);
-void
+		free(pr->error);
-cfg_default_done(__unused struct cmd_q *cmdq)
+		return (-1);
-{
-	if (--cfg_references != 0)
-		return;
-	cfg_finished = 1;
-
-	if (!RB_EMPTY(&sessions))
-		cfg_show_causes(RB_MIN(sessions, &sessions));
-
-	cmdq_free(cfg_cmd_q);
-	cfg_cmd_q = NULL;
-
-	if (cfg_client != NULL) {
-		/*
-		 * The client command queue starts with client_exit set to 1 so
-		 * only continue if not empty (that is, we have been delayed
-		 * during configuration parsing for long enough that the
-		 * MSG_COMMAND has arrived), else the client will exit before
-		 * the MSG_COMMAND which might tell it not to.
-		 */
-		if (!TAILQ_EMPTY(&cfg_client->cmdq->queue))
-			cmdq_continue(cfg_client->cmdq);
-		server_client_unref(cfg_client);
-		cfg_client = NULL;
 	}
+	if (flags & CMD_PARSE_PARSEONLY) {
+		cmd_list_free(pr->cmdlist);
+		return (0);
+	}
+
+	new_item0 = cmdq_get_command(pr->cmdlist, NULL, NULL, 0);
+	if (item != NULL)
+		cmdq_insert_after(item, new_item0);
+	else
+		cmdq_append(NULL, new_item0);
+	cmd_list_free(pr->cmdlist);
+
+	if (new_item != NULL)
+		*new_item = new_item0;
+	return (0);
 }
 
 void
@@ -169,12 +171,12 @@ cfg_add_cause(const char *fmt, ...)
 }
 
 void
-cfg_print_causes(struct cmd_q *cmdq)
+cfg_print_causes(struct cmdq_item *item)
 {
 	u_int	 i;
 
 	for (i = 0; i < cfg_ncauses; i++) {
-		cmdq_print(cmdq, "%s", cfg_causes[i]);
+		cmdq_print(item, "%s", cfg_causes[i]);
 		free(cfg_causes[i]);
 	}
 
@@ -186,15 +188,17 @@ cfg_print_causes(struct cmd_q *cmdq)
 void
 cfg_show_causes(struct session *s)
 {
-	struct window_pane	*wp;
+	struct window_pane		*wp;
-	u_int			 i;
+	struct window_mode_entry	*wme;
+	u_int				 i;
 
 	if (s == NULL || cfg_ncauses == 0)
 		return;
 	wp = s->curw->window->active;
 
-	window_pane_set_mode(wp, &window_copy_mode);
+	wme = TAILQ_FIRST(&wp->modes);
-	window_copy_init_for_output(wp);
+	if (wme == NULL || wme->mode != &window_view_mode)
+		window_pane_set_mode(wp, &window_view_mode, NULL, NULL);
 	for (i = 0; i < cfg_ncauses; i++) {
 		window_copy_add(wp, "%s", cfg_causes[i]);
 		free(cfg_causes[i]);

client.c

@@ -17,11 +17,10 @@
  */
 
 #include <sys/types.h>
-#include <sys/file.h>
 #include <sys/socket.h>
-#include <sys/stat.h>
 #include <sys/un.h>
 #include <sys/wait.h>
+#include <sys/file.h>
 
 #include <errno.h>
 #include <event.h>
@@ -33,11 +32,11 @@
 
 #include "tmux.h"
 
-struct tmuxproc	*client_proc;
+static struct tmuxproc	*client_proc;
-struct tmuxpeer	*client_peer;
+static struct tmuxpeer	*client_peer;
-int		 client_flags;
+static int		 client_flags;
-struct event	 client_stdin;
+static struct event	 client_stdin;
-enum {
+static enum {
 	CLIENT_EXIT_NONE,
 	CLIENT_EXIT_DETACHED,
 	CLIENT_EXIT_DETACHED_HUP,
@@ -47,29 +46,31 @@ enum {
 	CLIENT_EXIT_EXITED,
 	CLIENT_EXIT_SERVER_EXITED,
 } client_exitreason = CLIENT_EXIT_NONE;
-int		 client_exitval;
+static int		 client_exitval;
-enum msgtype	 client_exittype;
+static enum msgtype	 client_exittype;
-const char	*client_exitsession;
+static const char	*client_exitsession;
-int		 client_attached;
+static const char	*client_execshell;
+static const char	*client_execcmd;
+static int		 client_attached;
 
-__dead void	client_exec(const char *,const char *);
+static __dead void	 client_exec(const char *,const char *);
-int		client_get_lock(char *);
+static int		 client_get_lock(char *);
-int		client_connect(struct event_base *, const char *, int);
+static int		 client_connect(struct event_base *, const char *, int);
-void		client_send_identify(const char *, const char *);
+static void		 client_send_identify(const char *, const char *);
-void		client_stdin_callback(int, short, void *);
+static void		 client_stdin_callback(int, short, void *);
-void		client_write(int, const char *, size_t);
+static void		 client_write(int, const char *, size_t);
-void		client_signal(int);
+static void		 client_signal(int);
-void		client_dispatch(struct imsg *, void *);
+static void		 client_dispatch(struct imsg *, void *);
-void		client_dispatch_attached(struct imsg *);
+static void		 client_dispatch_attached(struct imsg *);
-void		client_dispatch_wait(struct imsg *, const char *);
+static void		 client_dispatch_wait(struct imsg *);
-const char     *client_exit_message(void);
+static const char	*client_exit_message(void);
 
 /*
  * Get server create lock. If already held then server start is happening in
  * another client, so block until the lock is released and return -2 to
  * retry. Return -1 on failure to continue and start the server anyway.
  */
-int
+static int
 client_get_lock(char *lockfile)
 {
 	int lockfd;
@@ -96,7 +97,7 @@ client_get_lock(char *lockfile)
 }
 
 /* Connect client to server. */
-int
+static int
 client_connect(struct event_base *base, const char *path, int start_server)
 {
 	struct sockaddr_un	sa;
@@ -154,7 +155,7 @@ retry:
 			close(lockfd);
 			return (-1);
 		}
-		fd = server_start(base, lockfd, lockfile);
+		fd = server_start(client_proc, base, lockfd, lockfile);
 	}
 
 	if (locked && lockfd >= 0) {
@@ -201,7 +202,7 @@ client_exit_message(void)
 	case CLIENT_EXIT_TERMINATED:
 		return ("terminated");
 	case CLIENT_EXIT_LOST_SERVER:
-		return ("lost server");
+		return ("server exited unexpectedly");
 	case CLIENT_EXIT_EXITED:
 		return ("exited");
 	case CLIENT_EXIT_SERVER_EXITED:
@@ -212,17 +213,15 @@ client_exit_message(void)
 
 /* Client main loop. */
 int
-client_main(struct event_base *base, int argc, char **argv, int flags,
+client_main(struct event_base *base, int argc, char **argv, int flags)
-    const char *shellcmd)
 {
+	struct cmd_parse_result	*pr;
 	struct cmd		*cmd;
-	struct cmd_list		*cmdlist;
 	struct msg_command_data	*data;
 	int			 cmdflags, fd, i;
 	const char		*ttynam, *cwd;
 	pid_t			 ppid;
 	enum msgtype		 msg;
-	char			*cause, path[PATH_MAX];
 	struct termios		 tio, saved_tio;
 	size_t			 size;
 
@@ -234,7 +233,7 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 
 	/* Set up the initial command. */
 	cmdflags = 0;
-	if (shellcmd != NULL) {
+	if (shell_command != NULL) {
 		msg = MSG_SHELL;
 		cmdflags = CMD_STARTSERVER;
 	} else if (argc == 0) {
@@ -248,21 +247,20 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 		 * later in server) but it is necessary to get the start server
 		 * flag.
 		 */
-		cmdlist = cmd_list_parse(argc, argv, NULL, 0, &cause);
+		pr = cmd_parse_from_arguments(argc, argv, NULL);
-		if (cmdlist == NULL) {
+		if (pr->status == CMD_PARSE_SUCCESS) {
-			fprintf(stderr, "%s\n", cause);
+			TAILQ_FOREACH(cmd, &pr->cmdlist->list, qentry) {
-			return (1);
+				if (cmd->entry->flags & CMD_STARTSERVER)
-		}
+					cmdflags |= CMD_STARTSERVER;
-		cmdflags &= ~CMD_STARTSERVER;
+			}
-		TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
+			cmd_list_free(pr->cmdlist);
-			if (cmd->entry->flags & CMD_STARTSERVER)
+		} else
-				cmdflags |= CMD_STARTSERVER;
+			free(pr->error);
-		}
-		cmd_list_free(cmdlist);
 	}
 
 	/* Create client process structure (starts logging). */
-	client_proc = proc_start("client", base, 0, client_signal);
+	client_proc = proc_start("client");
+	proc_set_signals(client_proc, client_signal);
 
 	/* Initialize the client socket and start the server. */
 	fd = client_connect(base, socket_path, cmdflags & CMD_STARTSERVER);
@@ -276,18 +274,14 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 		}
 		return (1);
 	}
-	client_peer = proc_add_peer(client_proc, fd, client_dispatch,
+	client_peer = proc_add_peer(client_proc, fd, client_dispatch, NULL);
-	    (void *)shellcmd);
 
 	/* Save these before pledge(). */
-	if ((cwd = getcwd(path, sizeof path)) == NULL) {
+	if ((cwd = find_cwd()) == NULL && (cwd = find_home()) == NULL)
-		if ((cwd = find_home()) == NULL)
+		cwd = "/";
-			cwd = "/";
-	}
 	if ((ttynam = ttyname(STDIN_FILENO)) == NULL)
 		ttynam = "";
 
-#ifdef __OpenBSD__
 	/*
 	 * Drop privileges for client. "proc exec" is needed for -c and for
 	 * locking (which uses system(3)).
@@ -299,9 +293,10 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 	 */
 	if (pledge("stdio unix sendfd proc exec tty", NULL) != 0)
 		fatal("pledge failed");
-#endif
 
 	/* Free stuff that is not used in the client. */
+	if (ptm_fd != -1)
+		close(ptm_fd);
 	options_free(global_options);
 	options_free(global_s_options);
 	options_free(global_w_options);
@@ -312,8 +307,11 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 	event_set(&client_stdin, STDIN_FILENO, EV_READ|EV_PERSIST,
 	    client_stdin_callback, NULL);
 	if (client_flags & CLIENT_CONTROLCONTROL) {
-		if (tcgetattr(STDIN_FILENO, &saved_tio) != 0)
+		if (tcgetattr(STDIN_FILENO, &saved_tio) != 0) {
-			fatal("tcgetattr failed");
+			fprintf(stderr, "tcgetattr failed: %s\n",
+			    strerror(errno));
+			return (1);
+		}
 		cfmakeraw(&tio);
 		tio.c_iflag = ICRNL|IXANY;
 		tio.c_oflag = OPOST|ONLCR;
@@ -337,6 +335,10 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 		size = 0;
 		for (i = 0; i < argc; i++)
 			size += strlen(argv[i]) + 1;
+		if (size > MAX_IMSGSIZE - (sizeof *data)) {
+			fprintf(stderr, "command too long\n");
+			return (1);
+		}
 		data = xmalloc((sizeof *data) + size);
 
 		/* Prepare command for server. */
@@ -361,6 +363,13 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 	/* Start main loop. */
 	proc_loop(client_proc, NULL);
 
+	/* Run command if user requested exec, instead of exiting. */
+	if (client_exittype == MSG_EXEC) {
+		if (client_flags & CLIENT_CONTROLCONTROL)
+			tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
+		client_exec(client_execshell, client_execcmd);
+	}
+
 	/* Print the exit message, if any, and exit. */
 	if (client_attached) {
 		if (client_exitreason != CLIENT_EXIT_NONE)
@@ -383,7 +392,7 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 }
 
 /* Send identify messages to server. */
-void
+static void
 client_send_identify(const char *ttynam, const char *cwd)
 {
 	const char	 *s;
@@ -420,14 +429,14 @@ client_send_identify(const char *ttynam, const char *cwd)
 }
 
 /* Callback for client stdin read events. */
-void
+static void
 client_stdin_callback(__unused int fd, __unused short events,
     __unused void *arg)
 {
 	struct msg_stdin_data	data;
 
 	data.size = read(STDIN_FILENO, data.data, sizeof data.data);
-	if (data.size < 0 && (errno == EINTR || errno == EAGAIN))
+	if (data.size == -1 && (errno == EINTR || errno == EAGAIN))
 		return;
 
 	proc_send(client_peer, MSG_STDIN, -1, &data, sizeof data);
@@ -436,11 +445,12 @@ client_stdin_callback(__unused int fd, __unused short events,
 }
 
 /* Force write to file descriptor. */
-void
+static void
 client_write(int fd, const char *data, size_t size)
 {
 	ssize_t	used;
 
+	log_debug("%s: %.*s", __func__, (int)size, data);
 	while (size != 0) {
 		used = write(fd, data, size);
 		if (used == -1) {
@@ -454,7 +464,7 @@ client_write(int fd, const char *data, size_t size)
 }
 
 /* Run command in shell; used for -c. */
-__dead void
+static __dead void
 client_exec(const char *shell, const char *shellcmd)
 {
 	const char	*name, *ptr;
@@ -473,6 +483,8 @@ client_exec(const char *shell, const char *shellcmd)
 		xasprintf(&argv0, "%s", name);
 	setenv("SHELL", shell, 1);
 
+	proc_clear_signals(client_proc, 1);
+
 	setblocking(STDIN_FILENO, 1);
 	setblocking(STDOUT_FILENO, 1);
 	setblocking(STDERR_FILENO, 1);
@@ -483,7 +495,7 @@ client_exec(const char *shell, const char *shellcmd)
 }
 
 /* Callback to handle signals in the client. */
-void
+static void
 client_signal(int sig)
 {
 	struct sigaction sigact;
@@ -523,8 +535,8 @@ client_signal(int sig)
 }
 
 /* Callback for client read events. */
-void
+static void
-client_dispatch(struct imsg *imsg, void *arg)
+client_dispatch(struct imsg *imsg, __unused void *arg)
 {
 	if (imsg == NULL) {
 		client_exitreason = CLIENT_EXIT_LOST_SERVER;
@@ -536,19 +548,18 @@ client_dispatch(struct imsg *imsg, void *arg)
 	if (client_attached)
 		client_dispatch_attached(imsg);
 	else
-		client_dispatch_wait(imsg, arg);
+		client_dispatch_wait(imsg);
 }
 
 /* Dispatch imsgs when in wait state (before MSG_READY). */
-void
+static void
-client_dispatch_wait(struct imsg *imsg, const char *shellcmd)
+client_dispatch_wait(struct imsg *imsg)
 {
 	char			*data;
 	ssize_t			 datalen;
 	struct msg_stdout_data	 stdoutdata;
 	struct msg_stderr_data	 stderrdata;
 	int			 retval;
-#ifdef __OpenBSD__
 	static int		 pledge_applied;
 
 	/*
@@ -562,7 +573,6 @@ client_dispatch_wait(struct imsg *imsg, const char *shellcmd)
 			fatal("pledge failed");
 		pledge_applied = 1;
 	};
-#endif
 
 	data = imsg->data;
 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
@@ -622,8 +632,7 @@ client_dispatch_wait(struct imsg *imsg, const char *shellcmd)
 		if (datalen == 0 || data[datalen - 1] != '\0')
 			fatalx("bad MSG_SHELL string");
 
-		clear_signals(0);
+		client_exec(data, shell_command);
-		client_exec(data, shellcmd);
 		/* NOTREACHED */
 	case MSG_DETACH:
 	case MSG_DETACHKILL:
@@ -636,7 +645,7 @@ client_dispatch_wait(struct imsg *imsg, const char *shellcmd)
 }
 
 /* Dispatch imsgs in attached state (after MSG_READY). */
-void
+static void
 client_dispatch_attached(struct imsg *imsg)
 {
 	struct sigaction	 sigact;
@@ -660,6 +669,16 @@ client_dispatch_attached(struct imsg *imsg)
 			client_exitreason = CLIENT_EXIT_DETACHED;
 		proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 		break;
+	case MSG_EXEC:
+		if (datalen == 0 || data[datalen - 1] != '\0' ||
+		    strlen(data) + 1 == (size_t)datalen)
+			fatalx("bad MSG_EXEC string");
+		client_execcmd = xstrdup(data);
+		client_execshell = xstrdup(data + strlen(data) + 1);
+
+		client_exittype = imsg->hdr.type;
+		proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
+		break;
 	case MSG_EXIT:
 		if (datalen != 0 && datalen != sizeof (int))
 			fatalx("bad MSG_EXIT size");

cmd-attach-session.c

@@ -30,113 +30,131 @@
  * 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 = {
 	.name = "attach-session",
 	.alias = "attach",
 
-	.args = { "c:dErt:", 0, 0 },
+	.args = { "c:dErt:x", 0, 0 },
-	.usage = "[-dEr] [-c working-directory] " CMD_TARGET_SESSION_USAGE,
+	.usage = "[-dErx] [-c working-directory] " CMD_TARGET_SESSION_USAGE,
 
-	.tflag = CMD_SESSION_WITHPANE,
+	/* -t is special */
 
 	.flags = CMD_STARTSERVER,
 	.exec = cmd_attach_session_exec
 };
 
 enum cmd_retval
-cmd_attach_session(struct cmd_q *cmdq, int dflag, int rflag, const char *cflag,
+cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
-    int Eflag)
+    int xflag, int rflag, const char *cflag, int Eflag)
 {
-	struct session		*s = cmdq->state.tflag.s;
+	struct cmd_find_state	*current = &item->shared->current;
-	struct client		*c = cmdq->client, *c_loop;
+	enum cmd_find_type	 type;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	int			 flags;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
+	struct client		*c = item->client, *c_loop;
-	const char		*update;
+	struct session		*s;
-	char			*cause, *cwd;
+	struct winlink		*wl;
-	struct format_tree	*ft;
+	struct window_pane	*wp;
+	char			*cause;
+	enum msgtype		 msgtype;
 
 	if (RB_EMPTY(&sessions)) {
-		cmdq_error(cmdq, "no sessions");
+		cmdq_error(item, "no sessions");
 		return (CMD_RETURN_ERROR);
 	}
 
 	if (c == NULL)
 		return (CMD_RETURN_NORMAL);
 	if (server_client_check_nested(c)) {
-		cmdq_error(cmdq, "sessions should be nested with care, "
+		cmdq_error(item, "sessions should be nested with care, "
 		    "unset $TMUX to force");
 		return (CMD_RETURN_ERROR);
 	}
 
+	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);
+			window_set_active_pane(wp->window, wp, 1);
 		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 (cflag != NULL) {
-		ft = format_create(cmdq, 0);
-		format_defaults(ft, c, s, wl, wp);
-		cwd = format_expand(ft, cflag);
-		format_free(ft);
-
 		free((void *)s->cwd);
-		s->cwd = cwd;
+		s->cwd = format_single(item, cflag, c, s, wl, wp);
 	}
 
+	c->last_session = c->session;
 	if (c->session != NULL) {
-		if (dflag) {
+		if (dflag || xflag) {
+			if (xflag)
+				msgtype = MSG_DETACHKILL;
+			else
+				msgtype = MSG_DETACH;
 			TAILQ_FOREACH(c_loop, &clients, entry) {
 				if (c_loop->session != s || c == c_loop)
 					continue;
-				server_client_detach(c_loop, MSG_DETACH);
+				server_client_detach(c_loop, msgtype);
 			}
 		}
-
+		if (!Eflag)
-		if (!Eflag) {
+			environ_update(s->options, c->environ, s->environ);
-			update = options_get_string(s->options,
-			    "update-environment");
-			environ_update(update, c->environ, s->environ);
-		}
 
 		c->session = s;
-		server_client_set_key_table(c, NULL);
+		if (~item->shared->flags & CMDQ_SHARED_REPEAT)
+			server_client_set_key_table(c, NULL);
+		tty_update_client_offset(c);
 		status_timer_start(c);
-		notify_attached_session_changed(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(c, &cause) != 0) {
-			cmdq_error(cmdq, "open terminal failed: %s", cause);
+			cmdq_error(item, "open terminal failed: %s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
-
 		if (rflag)
 			c->flags |= CLIENT_READONLY;
 
-		if (dflag) {
+		if (dflag || xflag) {
+			if (xflag)
+				msgtype = MSG_DETACHKILL;
+			else
+				msgtype = MSG_DETACH;
 			TAILQ_FOREACH(c_loop, &clients, entry) {
 				if (c_loop->session != s || c == c_loop)
 					continue;
-				server_client_detach(c_loop, MSG_DETACH);
+				server_client_detach(c_loop, msgtype);
 			}
 		}
-
+		if (!Eflag)
-		if (!Eflag) {
+			environ_update(s->options, c->environ, s->environ);
-			update = options_get_string(s->options,
-			    "update-environment");
-			environ_update(update, c->environ, s->environ);
-		}
 
 		c->session = s;
 		server_client_set_key_table(c, NULL);
+		tty_update_client_offset(c);
 		status_timer_start(c);
-		notify_attached_session_changed(c);
+		notify_client("client-session-changed", c);
 		session_update_activity(s, NULL);
 		gettimeofday(&s->last_attached_time, NULL);
 		server_redraw_client(c);
@@ -144,8 +162,8 @@ cmd_attach_session(struct cmd_q *cmdq, int dflag, int rflag, const char *cflag,
 
 		if (~c->flags & CLIENT_CONTROL)
 			proc_send(c->peer, MSG_READY, -1, NULL, 0);
-		hooks_run(c->session->hooks, c, NULL, "client-attached");
+		notify_client("client-attached", c);
-		cmdq->client_exit = 0;
+		c->flags |= CLIENT_ATTACHED;
 	}
 	recalculate_sizes();
 	alerts_check_session(s);
@@ -154,11 +172,12 @@ cmd_attach_session(struct cmd_q *cmdq, int dflag, int rflag, const char *cflag,
 	return (CMD_RETURN_NORMAL);
 }
 
-enum cmd_retval
+static enum cmd_retval
-cmd_attach_session_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_attach_session_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
 
-	return (cmd_attach_session(cmdq, args_has(args, 'd'),
+	return (cmd_attach_session(item, args_get(args, 't'),
-	    args_has(args, 'r'), args_get(args, 'c'), args_has(args, 'E')));
+	    args_has(args, 'd'), args_has(args, 'x'), args_has(args, 'r'),
+	    args_get(args, 'c'), args_has(args, 'E')));
 }

cmd-bind-key.c

@@ -24,56 +24,39 @@
 #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 *);
+static enum cmd_retval	cmd_bind_key_exec(struct cmd *, struct cmdq_item *);
-
-enum cmd_retval	 cmd_bind_key_mode_table(struct cmd *, struct cmd_q *,
-		     key_code);
 
 const struct cmd_entry cmd_bind_key_entry = {
 	.name = "bind-key",
 	.alias = "bind",
 
-	.args = { "cnrR:t:T:", 1, -1 },
+	.args = { "cnrT:", 2, -1 },
-	.usage = "[-cnr] [-t mode-table] [-R repeat-count] [-T key-table] key "
+	.usage = "[-cnr] [-T key-table] key "
 	         "command [arguments]",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_bind_key_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_bind_key_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_bind_key_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args		 *args = self->args;
-	char		*cause;
+	key_code		  key;
-	struct cmd_list	*cmdlist;
+	const char		 *tablename;
-	key_code	 key;
+	struct cmd_parse_result	 *pr;
-	const char	*tablename;
+	char			**argv = args->argv;
+	int			  argc = args->argc;
 
-	if (args_has(args, 't')) {
+	key = key_string_lookup_string(argv[0]);
-		if (args->argc != 2 && args->argc != 3) {
-			cmdq_error(cmdq, "not enough arguments");
-			return (CMD_RETURN_ERROR);
-		}
-	} else {
-		if (args->argc < 2) {
-			cmdq_error(cmdq, "not enough arguments");
-			return (CMD_RETURN_ERROR);
-		}
-	}
-
-	key = key_string_lookup_string(args->argv[0]);
 	if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
-		cmdq_error(cmdq, "unknown key: %s", args->argv[0]);
+		cmdq_error(item, "unknown key: %s", argv[0]);
 		return (CMD_RETURN_ERROR);
 	}
 
-	if (args_has(args, 't'))
-		return (cmd_bind_key_mode_table(self, cmdq, key));
-
 	if (args_has(args, 'T'))
 		tablename = args_get(args, 'T');
 	else if (args_has(args, 'n'))
@@ -81,91 +64,21 @@ cmd_bind_key_exec(struct cmd *self, struct cmd_q *cmdq)
 	else
 		tablename = "prefix";
 
-	cmdlist = cmd_list_parse(args->argc - 1, args->argv + 1, NULL, 0,
+	if (argc == 2)
-	    &cause);
+		pr = cmd_parse_from_string(argv[1], NULL);
-	if (cmdlist == NULL) {
+	else
-		cmdq_error(cmdq, "%s", cause);
+		pr = cmd_parse_from_arguments(argc - 1, argv + 1, NULL);
-		free(cause);
+	switch (pr->status) {
+	case CMD_PARSE_EMPTY:
+		cmdq_error(item, "empty command");
 		return (CMD_RETURN_ERROR);
+	case CMD_PARSE_ERROR:
+		cmdq_error(item, "%s", pr->error);
+		free(pr->error);
+		return (CMD_RETURN_ERROR);
+	case CMD_PARSE_SUCCESS:
+		break;
 	}
-
+	key_bindings_add(tablename, key, args_has(args, 'r'), pr->cmdlist);
-	key_bindings_add(tablename, key, args_has(args, 'r'), cmdlist);
-	return (CMD_RETURN_NORMAL);
-}
-
-enum cmd_retval
-cmd_bind_key_mode_table(struct cmd *self, struct cmd_q *cmdq, key_code key)
-{
-	struct args			*args = self->args;
-	const char			*tablename, *arg;
-	const struct mode_key_table	*mtab;
-	struct mode_key_binding		*mbind, mtmp;
-	enum mode_key_cmd		 cmd;
-	char				*cause;
-	u_int				 repeat;
-
-	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);
-	}
-
-	switch (cmd) {
-	case MODEKEYCOPY_APPENDSELECTION:
-	case MODEKEYCOPY_COPYSELECTION:
-	case MODEKEYCOPY_STARTNAMEDBUFFER:
-		if (args->argc == 2)
-			arg = NULL;
-		else {
-			arg = args->argv[2];
-			if (strcmp(arg, "-x") != 0) {
-				cmdq_error(cmdq, "unknown argument");
-				return (CMD_RETURN_ERROR);
-			}
-		}
-		break;
-	case MODEKEYCOPY_COPYPIPE:
-		if (args->argc != 3) {
-			cmdq_error(cmdq, "no argument given");
-			return (CMD_RETURN_ERROR);
-		}
-		arg = args->argv[2];
-		break;
-	default:
-		if (args->argc != 2) {
-			cmdq_error(cmdq, "no argument allowed");
-			return (CMD_RETURN_ERROR);
-		}
-		arg = NULL;
-		break;
-	}
-
-	repeat = 1;
-	if (args_has(args, 'R')) {
-		repeat = args_strtonum(args, 'R', 1, SHRT_MAX, &cause);
-		if (cause != NULL) {
-			cmdq_error(cmdq, "repeat count %s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-	}
-
-	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->repeat = repeat;
-	mbind->cmd = cmd;
-	mbind->arg = arg != NULL ? xstrdup(arg) : NULL;
 	return (CMD_RETURN_NORMAL);
 }

cmd-break-pane.c

@@ -28,45 +28,46 @@
 
 #define BREAK_PANE_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"
 
-enum cmd_retval	 cmd_break_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_break_pane_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_break_pane_entry = {
 	.name = "break-pane",
 	.alias = "breakp",
 
-	.args = { "dPF:s:t:", 0, 0 },
+	.args = { "dPF:n:s:t:", 0, 0 },
-	.usage = "[-dP] [-F format] [-s src-pane] [-t dst-window]",
+	.usage = "[-dP] [-F format] [-n window-name] [-s src-pane] "
+		 "[-t dst-window]",
 
-	.sflag = CMD_PANE,
+	.source = { 's', CMD_FIND_PANE, 0 },
-	.tflag = CMD_WINDOW_INDEX,
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_WINDOW_INDEX },
 
 	.flags = 0,
 	.exec = cmd_break_pane_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_break_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_break_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct winlink		*wl = cmdq->state.sflag.wl;
+	struct cmd_find_state	*current = &item->shared->current;
-	struct session		*src_s = cmdq->state.sflag.s;
+	struct client		*c = cmd_find_client(item, NULL, 1);
-	struct session		*dst_s = cmdq->state.tflag.s;
+	struct winlink		*wl = item->source.wl;
-	struct window_pane	*wp = cmdq->state.sflag.wp;
+	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;
+	char			*name, *cause;
-	char			*cause;
+	int			 idx = item->target.idx;
-	int			 idx = cmdq->state.tflag.idx;
-	struct format_tree	*ft;
 	const char		*template;
 	char			*cp;
 
 	if (idx != -1 && winlink_find_by_index(&dst_s->windows, idx) != NULL) {
-		cmdq_error(cmdq, "index %d already in use", idx);
+		cmdq_error(item, "index %d already in use", idx);
 		return (CMD_RETURN_ERROR);
 	}
 
 	if (window_count_panes(w) == 1) {
-		cmdq_error(cmdq, "can't break with only one pane");
+		cmdq_error(item, "can't break with only one pane");
 		return (CMD_RETURN_ERROR);
 	}
 	server_unzoom_window(w);
@@ -75,20 +76,31 @@ cmd_break_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	window_lost_pane(w, wp);
 	layout_close_pane(wp);
 
-	w = wp->window = window_create1(dst_s->sx, dst_s->sy);
+	w = wp->window = window_create(w->sx, w->sy);
+	options_set_parent(wp->options, w->options);
+	wp->flags |= PANE_STYLECHANGED;
 	TAILQ_INSERT_HEAD(&w->panes, wp, entry);
 	w->active = wp;
-	name = default_window_name(w);
+
-	window_set_name(w, name);
+	if (!args_has(args, 'n')) {
-	free(name);
+		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;
 
 	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'))
+	if (!args_has(self->args, 'd')) {
 		session_select(dst_s, wl->idx);
+		cmd_find_from_session(current, dst_s, 0);
+	}
 
 	server_redraw_session(src_s);
 	if (src_s != dst_s)
@@ -100,15 +112,9 @@ cmd_break_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = BREAK_PANE_TEMPLATE;
-
+		cp = format_single(item, template, c, dst_s, wl, wp);
-		ft = format_create(cmdq, 0);
+		cmdq_print(item, "%s", cp);
-		format_defaults(ft, cmdq->state.c, dst_s, wl, wp);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}
 	return (CMD_RETURN_NORMAL);
 }

cmd-capture-pane.c

@@ -27,12 +27,12 @@
  * 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);
+static 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_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 = {
@@ -41,15 +41,28 @@ const struct cmd_entry cmd_capture_pane_entry = {
 
 	.args = { "ab:CeE:JpPqS:t:", 0, 0 },
 	.usage = "[-aCeJpPq] " CMD_BUFFER_USAGE " [-E end-line] "
-		 "[-S start-line]" CMD_TARGET_PANE_USAGE,
+		 "[-S start-line] " CMD_TARGET_PANE_USAGE,
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
-	.flags = 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, *len + linelen + 1);
@@ -58,7 +71,7 @@ cmd_capture_pane_append(char *buf, size_t *len, char *line, size_t linelen)
 	return (buf);
 }
 
-char *
+static char *
 cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
     size_t *len)
 {
@@ -77,7 +90,7 @@ cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
 	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
@@ -90,8 +103,8 @@ cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
 	return (buf);
 }
 
-char *
+static char *
-cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
+cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
     struct window_pane *wp, size_t *len)
 {
 	struct grid		*gd;
@@ -108,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(""));
@@ -175,29 +188,35 @@ cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
 	return (buf);
 }
 
-enum cmd_retval
+static enum cmd_retval
-cmd_capture_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_capture_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct client		*c;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
+	struct window_pane	*wp = item->target.wp;
 	char			*buf, *cause;
 	const char		*bufname;
 	size_t			 len;
 
+	if (self->entry == &cmd_clear_history_entry) {
+		window_pane_reset_mode_all(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);
 		}
@@ -212,7 +231,7 @@ cmd_capture_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 			bufname = args_get(args, 'b');
 
 		if (paste_set(buf, len, bufname, &cause) != 0) {
-			cmdq_error(cmdq, "%s", cause);
+			cmdq_error(item, "%s", cause);
 			free(cause);
 			free(buf);
 			return (CMD_RETURN_ERROR);

cmd-choose-buffer.c

@@ -1,100 +0,0 @@
-/* $OpenBSD$ */
-
-/*
- * 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
- * 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.
- */
-
-#define CHOOSE_BUFFER_TEMPLATE						\
-	"#{buffer_name}: #{buffer_size} bytes: #{buffer_sample}"
-
-enum cmd_retval	 cmd_choose_buffer_exec(struct cmd *, struct cmd_q *);
-
-const struct cmd_entry cmd_choose_buffer_entry = {
-	.name = "choose-buffer",
-	.alias = NULL,
-
-	.args = { "F:t:", 0, 1 },
-	.usage = CMD_TARGET_WINDOW_USAGE " [-F format] [template]",
-
-	.tflag = CMD_WINDOW,
-
-	.flags = 0,
-	.exec = 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 = cmdq->state.c;
-	struct winlink			*wl = cmdq->state.tflag.wl;
-	struct window_choose_data	*cdata;
-	struct paste_buffer		*pb;
-	char				*action, *action_data;
-	const char			*template;
-	u_int				 idx;
-
-	if (c == NULL) {
-		cmdq_error(cmdq, "no client available");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if ((template = args_get(args, 'F')) == NULL)
-		template = CHOOSE_BUFFER_TEMPLATE;
-
-	if (paste_get_top(NULL) == NULL)
-		return (CMD_RETURN_NORMAL);
-
-	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
-		return (CMD_RETURN_NORMAL);
-
-	if (args->argc != 0)
-		action = xstrdup(args->argv[0]);
-	else
-		action = xstrdup("paste-buffer -b '%%'");
-
-	idx = 0;
-	pb = NULL;
-	while ((pb = paste_walk(pb)) != NULL) {
-		cdata = window_choose_data_create(TREE_OTHER, c, c->session);
-		cdata->idx = idx;
-
-		cdata->ft_template = xstrdup(template);
-		format_defaults_paste_buffer(cdata->ft, pb);
-
-		xasprintf(&action_data, "%s", paste_buffer_name(pb));
-		cdata->command = cmd_template_replace(action, action_data, 1);
-		free(action_data);
-
-		window_choose_add(wl->window->active, cdata);
-		idx++;
-	}
-	free(action);
-
-	window_choose_ready(wl->window->active, 0, NULL);
-
-	return (CMD_RETURN_NORMAL);
-}

cmd-choose-client.c

@@ -1,134 +0,0 @@
-/* $OpenBSD$ */
-
-/*
- * 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
- * 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.
- */
-
-#define CHOOSE_CLIENT_TEMPLATE					\
-	"#{client_tty}: #{session_name} "			\
-	"[#{client_width}x#{client_height} #{client_termname}]"	\
-	"#{?client_utf8, (utf8),}#{?client_readonly, (ro),} "	\
-	"(last used #{t:client_activity})"
-
-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 = {
-	.name = "choose-client",
-	.alias = NULL,
-
-	.args = { "F:t:", 0, 1 },
-	.usage = CMD_TARGET_WINDOW_USAGE " [-F format] [template]",
-
-	.tflag = CMD_WINDOW,
-
-	.flags = 0,
-	.exec = 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 = cmdq->state.c;
-	struct client			*c1;
-	struct window_choose_data	*cdata;
-	struct winlink			*wl = cmdq->state.tflag.wl;
-	const char			*template;
-	char				*action;
-	u_int			 	 idx, cur;
-
-	if (c == NULL) {
-		cmdq_error(cmdq, "no client available");
-		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;
-	TAILQ_FOREACH(c1, &clients, entry) {
-		if (c1->session == NULL || c1->tty.path == NULL)
-			continue;
-		if (c1 == cmdq->client)
-			cur = idx;
-
-		cdata = window_choose_data_create(TREE_OTHER, c, c->session);
-		cdata->idx = idx;
-
-		cdata->ft_template = xstrdup(template);
-		format_add(cdata->ft, "line", "%u", idx);
-		format_defaults(cdata->ft, c1, NULL, NULL, NULL);
-
-		cdata->command = cmd_template_replace(action, c1->tty.path, 1);
-
-		window_choose_add(wl->window->active, cdata);
-
-		idx++;
-	}
-	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;
-	u_int		 idx;
-
-	if (cdata == NULL)
-		return;
-	if (cdata->start_client->flags & CLIENT_DEAD)
-		return;
-
-	idx = 0;
-	TAILQ_FOREACH(c, &clients, entry) {
-		if (idx == cdata->idx)
-			break;
-		idx++;
-	}
-	if (c == NULL || c->session == NULL)
-		return;
-
-	window_choose_data_run(cdata);
-}

cmd-choose-tree.c

@@ -18,236 +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.
  */
 
-#define CHOOSE_TREE_SESSION_TEMPLATE				\
+static enum cmd_retval	cmd_choose_tree_exec(struct cmd *, struct cmdq_item *);
-	"#{session_name}: #{session_windows} windows"		\
-	"#{?session_grouped, (group ,}"				\
-	"#{session_group}#{?session_grouped,),}"		\
-	"#{?session_attached, (attached),}"
-#define CHOOSE_TREE_WINDOW_TEMPLATE				\
-	"#{window_index}: #{window_name}#{window_flags} "	\
-	"\"#{pane_title}\""
-
-enum cmd_retval	cmd_choose_tree_exec(struct cmd *, struct cmd_q *);
 
 const struct cmd_entry cmd_choose_tree_entry = {
 	.name = "choose-tree",
 	.alias = NULL,
 
-	.args = { "S:W:swub:c:t:", 0, 1 },
+	.args = { "F:Gf:NO:st:wZ", 0, 1 },
-	.usage = "[-suw] [-b session-template] [-c window template] "
+	.usage = "[-GNsw] [-F format] [-f filter] [-O sort-order] "
-		 "[-S format] [-W format] " CMD_TARGET_WINDOW_USAGE,
+	         CMD_TARGET_PANE_USAGE " [template]",
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_choose_tree_exec
 };
 
-const struct cmd_entry cmd_choose_session_entry = {
+const struct cmd_entry cmd_choose_client_entry = {
-	.name = "choose-session",
+	.name = "choose-client",
 	.alias = NULL,
 
-	.args = { "F:t:", 0, 1 },
+	.args = { "F:f:NO:t:Z", 0, 1 },
-	.usage = CMD_TARGET_WINDOW_USAGE " [-F format] [template]",
+	.usage = "[-N] [-F format] [-f filter] [-O sort-order] "
+	         CMD_TARGET_PANE_USAGE " [template]",
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_choose_tree_exec
 };
 
-const struct cmd_entry cmd_choose_window_entry = {
+const struct cmd_entry cmd_choose_buffer_entry = {
-	.name = "choose-window",
+	.name = "choose-buffer",
 	.alias = NULL,
 
-	.args = { "F:t:", 0, 1 },
+	.args = { "F:f:NO:t:Z", 0, 1 },
-	.usage = CMD_TARGET_WINDOW_USAGE "[-F format] [template]",
+	.usage = "[-N] [-F format] [-f filter] [-O sort-order] "
+	         CMD_TARGET_PANE_USAGE " [template]",
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_choose_tree_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_choose_tree_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_choose_tree_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
-	struct client			*c = cmdq->state.c;
+	struct window_pane		*wp = item->target.wp;
-	struct winlink			*wl = cmdq->state.tflag.wl, *wm;
+	const struct window_mode	*mode;
-	struct session			*s = cmdq->state.tflag.s, *s2;
-	struct window_choose_data	*wcd = NULL;
-	const char			*ses_template, *win_template;
-	char				*final_win_action, *cur_win_template;
-	char				*final_win_template_middle;
-	char				*final_win_template_last;
-	const char			*ses_action, *win_action;
-	u_int				 cur_win, idx_ses, win_ses, win_max;
-	u_int				 wflag, sflag;
 
-	ses_template = win_template = NULL;
+	if (self->entry == &cmd_choose_buffer_entry) {
-	ses_action = win_action = NULL;
+		if (paste_get_top(NULL) == NULL)
-
+			return (CMD_RETURN_NORMAL);
-	if (c == NULL) {
+		mode = &window_buffer_mode;
-		cmdq_error(cmdq, "no client available");
+	} else if (self->entry == &cmd_choose_client_entry) {
-		return (CMD_RETURN_ERROR);
+		if (server_client_how_many() == 0)
-	}
+			return (CMD_RETURN_NORMAL);
-
+		mode = &window_client_mode;
-	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
-		return (CMD_RETURN_NORMAL);
-
-	/* Sort out which command this is. */
-	wflag = sflag = 0;
-	if (self->entry == &cmd_choose_session_entry) {
-		sflag = 1;
-		if ((ses_template = args_get(args, 'F')) == NULL)
-			ses_template = CHOOSE_TREE_SESSION_TEMPLATE;
-
-		if (args->argc != 0)
-			ses_action = args->argv[0];
-		else
-			ses_action = CMD_CHOOSE_TREE_SESSION_ACTION;
-	} else if (self->entry == &cmd_choose_window_entry) {
-		wflag = 1;
-		if ((win_template = args_get(args, 'F')) == NULL)
-			win_template = CHOOSE_TREE_WINDOW_TEMPLATE;
-
-		if (args->argc != 0)
-			win_action = args->argv[0];
-		else
-			win_action = CMD_CHOOSE_TREE_WINDOW_ACTION;
-	} else {
-		wflag = args_has(args, 'w');
-		sflag = args_has(args, 's');
-
-		if ((ses_action = args_get(args, 'b')) == NULL)
-			ses_action = CMD_CHOOSE_TREE_SESSION_ACTION;
-
-		if ((win_action = args_get(args, 'c')) == NULL)
-			win_action = CMD_CHOOSE_TREE_WINDOW_ACTION;
-
-		if ((ses_template = args_get(args, 'S')) == NULL)
-			ses_template = CHOOSE_TREE_SESSION_TEMPLATE;
-
-		if ((win_template = args_get(args, 'W')) == NULL)
-			win_template = CHOOSE_TREE_WINDOW_TEMPLATE;
-	}
-
-	/*
-	 * If not asking for windows and sessions, assume no "-ws" given and
-	 * hence display the entire tree outright.
-	 */
-	if (!wflag && !sflag)
-		wflag = sflag = 1;
-
-	/*
-	 * If we're drawing in tree mode, including sessions, then pad the
-	 * window template, otherwise just render the windows as a flat list
-	 * without any padding.
-	 */
-	if (wflag && sflag) {
-		xasprintf(&final_win_template_middle,
-		    " \001tq\001> %s", win_template);
-		xasprintf(&final_win_template_last,
-		    " \001mq\001> %s", win_template);
-	} else if (wflag) {
-		final_win_template_middle = xstrdup(win_template);
-		final_win_template_last = xstrdup(win_template);
 	} else
-		final_win_template_middle = final_win_template_last = NULL;
+		mode = &window_tree_mode;
-
-	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);
-	}
 
+	window_pane_set_mode(wp, mode, &item->target, args);
 	return (CMD_RETURN_NORMAL);
 }

cmd-command-prompt.c

@@ -29,56 +29,64 @@
  * Prompt for command in client.
  */
 
-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 *);
+static int	cmd_command_prompt_callback(struct client *, void *,
-void	cmd_command_prompt_free(void *);
+		    const char *, int);
+static void	cmd_command_prompt_free(void *);
 
 const struct cmd_entry cmd_command_prompt_entry = {
 	.name = "command-prompt",
 	.alias = NULL,
 
-	.args = { "I:p:t:", 0, 1 },
+	.args = { "1iI:Np:t:", 0, 1 },
-	.usage = "[-I inputs] [-p prompts] " CMD_TARGET_CLIENT_USAGE " "
+	.usage = "[-1Ni] [-I inputs] [-p prompts] " CMD_TARGET_CLIENT_USAGE " "
 		 "[template]",
 
-	.tflag = CMD_CLIENT,
-
 	.flags = 0,
 	.exec = cmd_command_prompt_exec
 };
 
 struct cmd_command_prompt_cdata {
-	struct client	*c;
+	int	 flags;
-	char		*inputs;
+
-	char		*next_input;
+	char	*inputs;
-	char		*next_prompt;
+	char	*next_input;
-	char		*prompts;
+
-	char		*template;
+	char	*prompts;
-	int		 idx;
+	char	*next_prompt;
+
+	char	*template;
+	int	 idx;
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_command_prompt_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_command_prompt_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
 	const char			*inputs, *prompts;
 	struct cmd_command_prompt_cdata	*cdata;
-	struct client			*c = cmdq->state.c;
+	struct client			*c;
 	char				*prompt, *ptr, *input = NULL;
 	size_t				 n;
 
+	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 = xcalloc(1, sizeof *cdata);
-	cdata->c = c;
+
-	cdata->idx = 1;
 	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]);
@@ -108,34 +116,45 @@ 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
+static int
-cmd_command_prompt_callback(void *data, const char *s)
+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 cmdq_item		*new_item;
-	struct cmd_list			*cmdlist;
+	char				*new_template, *prompt, *ptr;
-	char				*cause, *new_template, *prompt, *ptr;
 	char				*input = NULL;
+	struct cmd_parse_result		*pr;
 
 	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);
+	if (done) {
-	cdata->template = new_template;
+		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);
@@ -145,24 +164,31 @@ cmd_command_prompt_callback(void *data, const char *s)
 		return (1);
 	}
 
-	if (cmd_string_parse(new_template, &cmdlist, NULL, 0, &cause) != 0) {
+	pr = cmd_parse_from_string(new_template, NULL);
-		if (cause != NULL) {
+	switch (pr->status) {
-			*cause = toupper((u_char) *cause);
+	case CMD_PARSE_EMPTY:
-			status_message_set(c, "%s", cause);
+		new_item = NULL;
-			free(cause);
+		break;
-		}
+	case CMD_PARSE_ERROR:
-		return (0);
+		new_item = cmdq_get_error(pr->error);
+		free(pr->error);
+		cmdq_append(c, new_item);
+		break;
+	case CMD_PARSE_SUCCESS:
+		new_item = cmdq_get_command(pr->cmdlist, NULL, NULL, 0);
+		cmd_list_free(pr->cmdlist);
+		cmdq_append(c, new_item);
+		break;
 	}
 
-	cmdq_run(c->cmdq, cmdlist, NULL);
+	if (!done)
-	cmd_list_free(cmdlist);
+		free(new_template);
-
+	if (c->prompt_inputcb != cmd_command_prompt_callback)
-	if (c->prompt_callbackfn != (void *) &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

@@ -28,10 +28,12 @@
  * Asks for confirmation before executing a command.
  */
 
-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 *);
+static int	cmd_confirm_before_callback(struct client *, void *,
-void		 cmd_confirm_before_free(void *);
+		    const char *, int);
+static void	cmd_confirm_before_free(void *);
 
 const struct cmd_entry cmd_confirm_before_entry = {
 	.name = "confirm-before",
@@ -40,26 +42,26 @@ const struct cmd_entry cmd_confirm_before_entry = {
 	.args = { "p:t:", 1, 1 },
 	.usage = "[-p prompt] " CMD_TARGET_CLIENT_USAGE " command",
 
-	.tflag = CMD_CLIENT,
-
 	.flags = 0,
 	.exec = cmd_confirm_before_exec
 };
 
 struct cmd_confirm_before_data {
-	char		*cmd;
+	char	*cmd;
-	struct client	*client;
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_confirm_before_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_confirm_before_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
 	struct cmd_confirm_before_data	*cdata;
-	struct client			*c = cmdq->state.c;
+	struct client			*c;
 	char				*cmd, *copy, *new_prompt, *ptr;
 	const char			*prompt;
 
+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+
 	if ((prompt = args_get(args, 'p')) != NULL)
 		xasprintf(&new_prompt, "%s ", prompt);
 	else {
@@ -72,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);
@@ -83,43 +82,46 @@ cmd_confirm_before_exec(struct cmd *self, struct cmd_q *cmdq)
 	return (CMD_RETURN_NORMAL);
 }
 
-int
+static int
-cmd_confirm_before_callback(void *data, const char *s)
+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 cmdq_item		*new_item;
-	struct cmd_list			*cmdlist;
+	struct cmd_parse_result		*pr;
-	char				*cause;
 
 	if (c->flags & CLIENT_DEAD)
 		return (0);
 
 	if (s == NULL || *s == '\0')
 		return (0);
-	if (tolower((u_char) s[0]) != 'y' || s[1] != '\0')
+	if (tolower((u_char)s[0]) != 'y' || s[1] != '\0')
 		return (0);
 
-	if (cmd_string_parse(cdata->cmd, &cmdlist, NULL, 0, &cause) != 0) {
+	pr = cmd_parse_from_string(cdata->cmd, NULL);
-		if (cause != NULL) {
+	switch (pr->status) {
-			cmdq_error(c->cmdq, "%s", cause);
+	case CMD_PARSE_EMPTY:
-			free(cause);
+		new_item = NULL;
-		}
+		break;
-		return (0);
+	case CMD_PARSE_ERROR:
+		new_item = cmdq_get_error(pr->error);
+		free(pr->error);
+		cmdq_append(c, new_item);
+		break;
+	case CMD_PARSE_SUCCESS:
+		new_item = cmdq_get_command(pr->cmdlist, NULL, NULL, 0);
+		cmd_list_free(pr->cmdlist);
+		cmdq_append(c, new_item);
+		break;
 	}
 
-	cmdq_run(c->cmdq, cmdlist, NULL);
-	cmd_list_free(cmdlist);
-
 	return (0);
 }
 
-void
+static void
 cmd_confirm_before_free(void *data)
 {
 	struct cmd_confirm_before_data	*cdata = data;
-	struct client			*c = cdata->client;
-
-	server_client_unref(c);
 
 	free(cdata->cmd);
 	free(cdata);

cmd-copy-mode.c

@@ -24,7 +24,7 @@
  * Enter copy or clock mode.
  */
 
-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 = {
 	.name = "copy-mode",
@@ -33,9 +33,9 @@ const struct cmd_entry cmd_copy_mode_entry = {
 	.args = { "Met:u", 0, 0 },
 	.usage = "[-Mu] " CMD_TARGET_PANE_USAGE,
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_copy_mode_exec
 };
 
@@ -46,43 +46,38 @@ const struct cmd_entry cmd_clock_mode_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_PANE_USAGE,
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_copy_mode_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_copy_mode_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_copy_mode_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->client;
+	struct cmdq_shared	*shared = item->shared;
+	struct client		*c = item->client;
 	struct session		*s;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
+	struct window_pane	*wp = item->target.wp;
 
 	if (args_has(args, 'M')) {
-		if ((wp = cmd_mouse_pane(&cmdq->item->mouse, &s, NULL)) == NULL)
+		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);
+		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, NULL, args)) {
-		if (window_pane_set_mode(wp, &window_copy_mode) != 0)
+		if (args_has(args, 'M'))
-			return (CMD_RETURN_NORMAL);
+			window_copy_start_drag(c, &shared->mouse);
-		window_copy_init_from_pane(wp, args_has(self->args, 'e'));
 	}
-	if (args_has(args, 'M')) {
+	if (args_has(self->args, 'u'))
-		if (wp->mode != NULL && wp->mode != &window_copy_mode)
-			return (CMD_RETURN_NORMAL);
-		window_copy_start_drag(c, &cmdq->item->mouse);
-	}
-	if (wp->mode == &window_copy_mode && args_has(self->args, 'u'))
 		window_copy_pageup(wp, 0);
 
 	return (CMD_RETURN_NORMAL);

cmd-detach-client.c

@@ -26,17 +26,18 @@
  * 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 = {
 	.name = "detach-client",
 	.alias = "detach",
 
-	.args = { "as:t:P", 0, 0 },
+	.args = { "aE:s:t:P", 0, 0 },
-	.usage = "[-P] [-a] [-s target-session] " CMD_TARGET_CLIENT_USAGE,
+	.usage = "[-aP] [-E shell-command] "
+	         "[-s target-session] " CMD_TARGET_CLIENT_USAGE,
 
-	.sflag = CMD_SESSION,
+	.source = { 's', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
-	.tflag = CMD_CLIENT,
 
 	.flags = CMD_READONLY,
 	.exec = cmd_detach_client_exec
@@ -49,24 +50,24 @@ const struct cmd_entry cmd_suspend_client_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_CLIENT_USAGE,
 
-	.tflag = CMD_CLIENT,
-
 	.flags = 0,
 	.exec = cmd_detach_client_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_detach_client_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_detach_client_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct client	*c = cmdq->state.c, *cloop;
+	struct client	*c, *cloop;
 	struct session	*s;
 	enum msgtype	 msgtype;
+	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) {
-		tty_stop_tty(&c->tty);
+		server_client_suspend(c);
-		c->flags |= CLIENT_SUSPENDED;
-		proc_send(c->peer, MSG_SUSPEND, -1, NULL, 0);
 		return (CMD_RETURN_NORMAL);
 	}
 
@@ -76,22 +77,35 @@ cmd_detach_client_exec(struct cmd *self, struct cmd_q *cmdq)
 		msgtype = MSG_DETACH;
 
 	if (args_has(args, 's')) {
-		s = cmdq->state.sflag.s;
+		s = item->source.s;
+		if (s == NULL)
+			return (CMD_RETURN_NORMAL);
 		TAILQ_FOREACH(cloop, &clients, entry) {
-			if (cloop->session == s)
+			if (cloop->session == s) {
-				server_client_detach(cloop, msgtype);
+				if (cmd != NULL)
+					server_client_exec(cloop, cmd);
+				else
+					server_client_detach(cloop, msgtype);
+			}
 		}
 		return (CMD_RETURN_STOP);
 	}
 
 	if (args_has(args, 'a')) {
 		TAILQ_FOREACH(cloop, &clients, entry) {
-			if (cloop->session != NULL && cloop != c)
+			if (cloop->session != NULL && cloop != c) {
-				server_client_detach(cloop, msgtype);
+				if (cmd != NULL)
+					server_client_exec(cloop, cmd);
+				else
+					server_client_detach(cloop, msgtype);
+			}
 		}
 		return (CMD_RETURN_NORMAL);
 	}
 
-	server_client_detach(c, msgtype);
+	if (cmd != NULL)
+		server_client_exec(c, cmd);
+	else
+		server_client_detach(c, msgtype);
 	return (CMD_RETURN_STOP);
 }

cmd-display-menu.c

@@ -0,0 +1,178 @@
+/* $OpenBSD$ */
+
+/*
+ * Copyright (c) 2019 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 <stdlib.h>
+#include <string.h>
+
+#include "tmux.h"
+
+/*
+ * Display a menu on a client.
+ */
+
+static enum cmd_retval	cmd_display_menu_exec(struct cmd *,
+			    struct cmdq_item *);
+
+const struct cmd_entry cmd_display_menu_entry = {
+	.name = "display-menu",
+	.alias = "menu",
+
+	.args = { "c:t:T:x:y:", 1, -1 },
+	.usage = "[-c target-client] " CMD_TARGET_PANE_USAGE " [-T title] "
+		 "[-x position] [-y position] name key command ...",
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_display_menu_exec
+};
+
+static enum cmd_retval
+cmd_display_menu_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		*args = self->args;
+	struct client		*c;
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	struct window_pane	*wp = item->target.wp;
+	struct cmd_find_state	*fs = &item->target;
+	struct menu		*menu = NULL;
+	struct style_range	*sr;
+	struct menu_item	 menu_item;
+	const char		*xp, *yp, *key;
+	char			*title, *name;
+	int			 at, flags, i;
+	u_int			 px, py, ox, oy, sx, sy;
+
+	if ((c = cmd_find_client(item, args_get(args, 'c'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+	if (c->overlay_draw != NULL)
+		return (CMD_RETURN_NORMAL);
+	at = status_at_line(c);
+
+	if (args_has(args, 'T'))
+		title = format_single(NULL, args_get(args, 'T'), c, s, wl, wp);
+	else
+		title = xstrdup("");
+
+	menu = menu_create(title);
+
+	for (i = 0; i != args->argc; /* nothing */) {
+		name = args->argv[i++];
+		if (*name == '\0') {
+			menu_add_item(menu, NULL, item, c, fs);
+			continue;
+		}
+
+		if (args->argc - i < 2) {
+			cmdq_error(item, "not enough arguments");
+			free(title);
+			menu_free(menu);
+			return (CMD_RETURN_ERROR);
+		}
+		key = args->argv[i++];
+
+		menu_item.name = name;
+		menu_item.key = key_string_lookup_string(key);
+		menu_item.command = args->argv[i++];
+
+		menu_add_item(menu, &menu_item, item, c, fs);
+	}
+	free(title);
+	if (menu == NULL) {
+		cmdq_error(item, "invalid menu arguments");
+		return (CMD_RETURN_ERROR);
+	}
+	if (menu->count == 0) {
+		menu_free(menu);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	xp = args_get(args, 'x');
+	if (xp == NULL)
+		px = 0;
+	else if (strcmp(xp, "R") == 0)
+		px = c->tty.sx - 1;
+	else if (strcmp(xp, "P") == 0) {
+		tty_window_offset(&c->tty, &ox, &oy, &sx, &sy);
+		if (wp->xoff >= ox)
+			px = wp->xoff - ox;
+		else
+			px = 0;
+	} else if (strcmp(xp, "M") == 0 && item->shared->mouse.valid) {
+		if (item->shared->mouse.x > (menu->width + 4) / 2)
+			px = item->shared->mouse.x - (menu->width + 4) / 2;
+		else
+			px = 0;
+	}
+	else if (strcmp(xp, "W") == 0) {
+		if (at == -1)
+			px = 0;
+		else {
+			TAILQ_FOREACH(sr, &c->status.entries[0].ranges, entry) {
+				if (sr->type != STYLE_RANGE_WINDOW)
+					continue;
+				if (sr->argument == (u_int)wl->idx)
+					break;
+			}
+			if (sr != NULL)
+				px = sr->start;
+			else
+				px = 0;
+		}
+	} else
+		px = strtoul(xp, NULL, 10);
+	if (px + menu->width + 4 >= c->tty.sx)
+		px = c->tty.sx - menu->width - 4;
+
+	yp = args_get(args, 'y');
+	if (yp == NULL)
+		py = 0;
+	else if (strcmp(yp, "P") == 0) {
+		tty_window_offset(&c->tty, &ox, &oy, &sx, &sy);
+		if (wp->yoff + wp->sy >= oy)
+			py = wp->yoff + wp->sy - oy;
+		else
+			py = 0;
+	} else if (strcmp(yp, "M") == 0 && item->shared->mouse.valid)
+		py = item->shared->mouse.y + menu->count + 2;
+	else if (strcmp(yp, "S") == 0) {
+		if (at == -1)
+			py = c->tty.sy;
+		else if (at == 0)
+			py = status_line_size(c) + menu->count + 2;
+		else
+			py = at;
+	} else
+		py = strtoul(yp, NULL, 10);
+	if (py < menu->count + 2)
+		py = 0;
+	else
+		py -= menu->count + 2;
+	if (py + menu->count + 2 >= c->tty.sy)
+		py = c->tty.sy - menu->count - 2;
+
+	flags = 0;
+	if (!item->shared->mouse.valid)
+		flags |= MENU_NOMOUSE;
+	if (menu_display(menu, flags, item, px, py, c, fs, NULL, NULL) != 0)
+		return (CMD_RETURN_NORMAL);
+	return (CMD_RETURN_WAIT);
+}

cmd-display-message.c

@@ -32,37 +32,55 @@
 	"#{window_name}, current pane #{pane_index} "	\
 	"- (%H:%M %d-%b-%y)"
 
-enum cmd_retval	 cmd_display_message_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_display_message_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_display_message_entry = {
 	.name = "display-message",
 	.alias = "display",
 
-	.args = { "c:pt:F:", 0, 1 },
+	.args = { "ac:Ipt:F:v", 0, 1 },
-	.usage = "[-p] [-c target-client] [-F format] "
+	.usage = "[-aIpv] [-c target-client] [-F format] "
 		 CMD_TARGET_PANE_USAGE " [message]",
 
-	.cflag = CMD_CLIENT_CANFAIL,
+	.target = { 't', CMD_FIND_PANE, 0 },
-	.tflag = CMD_PANE,
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_display_message_exec
 };
 
-enum cmd_retval
+static void
-cmd_display_message_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_display_message_each(const char *key, const char *value, void *arg)
+{
+	struct cmdq_item	*item = arg;
+
+	cmdq_print(item, "%s=%s", key, value);
+}
+
+static enum cmd_retval
+cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->state.c;
+	struct client		*c, *target_c;
-	struct session		*s = cmdq->state.tflag.s;
+	struct session		*s = item->target.s;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	struct winlink		*wl = item->target.wl;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
+	struct window_pane	*wp = item->target.wp;
 	const char		*template;
-	char			*msg;
+	char			*msg, *cause;
 	struct format_tree	*ft;
+	int			 flags;
+
+	if (args_has(args, 'I')) {
+		if (window_pane_start_input(wp, item, &cause) != 0) {
+			cmdq_error(item, "%s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+		return (CMD_RETURN_WAIT);
+	}
 
 	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);
 	}
 
@@ -72,12 +90,32 @@ cmd_display_message_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (template == NULL)
 		template = DISPLAY_MESSAGE_TEMPLATE;
 
-	ft = format_create(cmdq, 0);
+	/*
-	format_defaults(ft, c, s, wl, wp);
+	 * -c is intended to be the client where the message should be
+	 * displayed if -p is not given. But it makes sense to use it for the
+	 * formats too, assuming it matches the session. If it doesn't, use the
+	 * best client for the session.
+	 */
+	c = cmd_find_client(item, args_get(args, 'c'), 1);
+	if (c != NULL && c->session == s)
+		target_c = c;
+	else
+		target_c = cmd_find_best_client(s);
+	if (args_has(self->args, 'v'))
+		flags = FORMAT_VERBOSE;
+	else
+		flags = 0;
+	ft = format_create(item->client, item, FORMAT_NONE, flags);
+	format_defaults(ft, target_c, s, wl, wp);
 
-	msg = format_expand_time(ft, template, time(NULL));
+	if (args_has(args, 'a')) {
+		format_each(ft, cmd_display_message_each, item);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	msg = format_expand_time(ft, template);
 	if (args_has(self->args, 'p'))
-		cmdq_print(cmdq, "%s", msg);
+		cmdq_print(item, "%s", msg);
 	else if (c != NULL)
 		status_message_set(c, "%s", msg);
 	free(msg);

cmd-display-panes.c

@@ -18,8 +18,8 @@
 
 #include <sys/types.h>
 
-#include <ctype.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "tmux.h"
 
@@ -27,71 +27,256 @@
  * Display panes on a client.
  */
 
-static 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 = {
 	.name = "display-panes",
 	.alias = "displayp",
 
-	.args = { "t:", 0, 1 },
+	.args = { "bd:t:", 0, 1 },
-	.usage = CMD_TARGET_CLIENT_USAGE,
+	.usage = "[-b] [-d duration] " CMD_TARGET_CLIENT_USAGE " [template]",
 
-	.tflag = CMD_CLIENT,
+	.flags = CMD_AFTERHOOK,
-
-	.flags = 0,
 	.exec = cmd_display_panes_exec
 };
 
-static enum cmd_retval
+struct cmd_display_panes_data {
-cmd_display_panes_exec(struct cmd *self, struct cmd_q *cmdq)
+	struct cmdq_item	*item;
+	char			*command;
+};
+
+static void
+cmd_display_panes_draw_pane(struct screen_redraw_ctx *ctx,
+    struct window_pane *wp)
 {
-	struct args	*args = self->args;
+	struct client		*c = ctx->c;
-	struct client	*c = cmdq->state.c;
+	struct tty		*tty = &c->tty;
+	struct session		*s = c->session;
+	struct options		*oo = s->options;
+	struct window		*w = wp->window;
+	struct grid_cell	 gc;
+	u_int			 idx, px, py, i, j, xoff, yoff, sx, sy;
+	int			 colour, active_colour;
+	char			 buf[16], *ptr;
+	size_t			 len;
 
-	if (c->identify_callback != NULL)
+	if (wp->xoff + wp->sx <= ctx->ox ||
-		return (CMD_RETURN_NORMAL);
+	    wp->xoff >= ctx->ox + ctx->sx ||
+	    wp->yoff + wp->sy <= ctx->oy ||
+	    wp->yoff >= ctx->oy + ctx->sy)
+		return;
 
-	c->identify_callback = cmd_display_panes_callback;
+	if (wp->xoff >= ctx->ox && wp->xoff + wp->sx <= ctx->ox + ctx->sx) {
-	if (args->argc != 0)
+		/* All visible. */
-		c->identify_callback_data = xstrdup(args->argv[0]);
+		xoff = wp->xoff - ctx->ox;
+		sx = wp->sx;
+	} else if (wp->xoff < ctx->ox &&
+	    wp->xoff + wp->sx > ctx->ox + ctx->sx) {
+		/* Both left and right not visible. */
+		xoff = 0;
+		sx = ctx->sx;
+	} else if (wp->xoff < ctx->ox) {
+		/* Left not visible. */
+		xoff = 0;
+		sx = wp->sx - (ctx->ox - wp->xoff);
+	} else {
+		/* Right not visible. */
+		xoff = wp->xoff - ctx->ox;
+		sx = wp->sx - xoff;
+	}
+	if (wp->yoff >= ctx->oy && wp->yoff + wp->sy <= ctx->oy + ctx->sy) {
+		/* All visible. */
+		yoff = wp->yoff - ctx->oy;
+		sy = wp->sy;
+	} else if (wp->yoff < ctx->oy &&
+	    wp->yoff + wp->sy > ctx->oy + ctx->sy) {
+		/* Both top and bottom not visible. */
+		yoff = 0;
+		sy = ctx->sy;
+	} else if (wp->yoff < ctx->oy) {
+		/* Top not visible. */
+		yoff = 0;
+		sy = wp->sy - (ctx->oy - wp->yoff);
+	} else {
+		/* Bottom not visible. */
+		yoff = wp->yoff - ctx->oy;
+		sy = wp->sy - yoff;
+	}
+
+	if (ctx->statustop)
+		yoff += ctx->statuslines;
+	px = sx / 2;
+	py = sy / 2;
+
+	if (window_pane_index(wp, &idx) != 0)
+		fatalx("index not found");
+	len = xsnprintf(buf, sizeof buf, "%u", idx);
+
+	if (sx < len)
+		return;
+	colour = options_get_number(oo, "display-panes-colour");
+	active_colour = options_get_number(oo, "display-panes-active-colour");
+
+	if (sx < len * 6 || sy < 5) {
+		tty_cursor(tty, xoff + px - len / 2, yoff + py);
+		goto draw_text;
+	}
+
+	px -= len * 3;
+	py -= 2;
+
+	memcpy(&gc, &grid_default_cell, sizeof gc);
+	if (w->active == wp)
+		gc.bg = active_colour;
 	else
-		c->identify_callback_data = xstrdup("select-pane -t '%%'");
+		gc.bg = colour;
+	gc.flags |= GRID_FLAG_NOPALETTE;
 
-	server_set_identify(c);
+	tty_attributes(tty, &gc, wp);
+	for (ptr = buf; *ptr != '\0'; ptr++) {
+		if (*ptr < '0' || *ptr > '9')
+			continue;
+		idx = *ptr - '0';
 
-	return (CMD_RETURN_NORMAL);
+		for (j = 0; j < 5; j++) {
+			for (i = px; i < px + 5; i++) {
+				tty_cursor(tty, xoff + i, yoff + py + j);
+				if (window_clock_table[idx][j][i - px])
+					tty_putc(tty, ' ');
+			}
+		}
+		px += 6;
+	}
+
+	len = xsnprintf(buf, sizeof buf, "%ux%u", wp->sx, wp->sy);
+	if (sx < len || sy < 6)
+		return;
+	tty_cursor(tty, xoff + sx - len, yoff);
+
+draw_text:
+	memcpy(&gc, &grid_default_cell, sizeof gc);
+	if (w->active == wp)
+		gc.fg = active_colour;
+	else
+		gc.fg = colour;
+	gc.flags |= GRID_FLAG_NOPALETTE;
+
+	tty_attributes(tty, &gc, wp);
+	tty_puts(tty, buf);
+
+	tty_cursor(tty, 0, 0);
 }
 
 static void
-cmd_display_panes_callback(struct client *c, struct window_pane *wp)
+cmd_display_panes_draw(struct client *c, struct screen_redraw_ctx *ctx)
 {
-	struct cmd_list	*cmdlist;
+	struct window		*w = c->session->curw->window;
-	char		*template, *cmd, *expanded, *cause;
+	struct window_pane	*wp;
 
-	template = c->identify_callback_data;
+	log_debug("%s: %s @%u", __func__, c->name, w->id);
-	if (wp != NULL) {
-		xasprintf(&expanded, "%%%u", wp->id);
-		cmd = cmd_template_replace(template, expanded, 1);
 
-		if (cmd_string_parse(cmd, &cmdlist, NULL, 0, &cause) != 0) {
+	TAILQ_FOREACH(wp, &w->panes, entry) {
-			if (cause != NULL) {
+		if (window_pane_visible(wp))
-				*cause = toupper((u_char) *cause);
+			cmd_display_panes_draw_pane(ctx, wp);
-				status_message_set(c, "%s", cause);
+	}
-				free(cause);
+}
-			}
-		} else {
-			cmdq_run(c->cmdq, cmdlist, NULL);
-			cmd_list_free(cmdlist);
-		}
 
-		free(cmd);
+static void
-		free(expanded);
+cmd_display_panes_free(struct client *c)
+{
+	struct cmd_display_panes_data	*cdata = c->overlay_data;
+
+	if (cdata->item != NULL)
+		cmdq_continue(cdata->item);
+	free(cdata->command);
+	free(cdata);
+}
+
+static int
+cmd_display_panes_key(struct client *c, struct key_event *event)
+{
+	struct cmd_display_panes_data	*cdata = c->overlay_data;
+	struct cmdq_item		*new_item;
+	char				*cmd, *expanded;
+	struct window			*w = c->session->curw->window;
+	struct window_pane		*wp;
+	struct cmd_parse_result		*pr;
+
+	if (event->key < '0' || event->key > '9')
+		return (-1);
+
+	wp = window_pane_at_index(w, event->key - '0');
+	if (wp == NULL)
+		return (1);
+	window_unzoom(w);
+
+	xasprintf(&expanded, "%%%u", wp->id);
+	cmd = cmd_template_replace(cdata->command, expanded, 1);
+
+	pr = cmd_parse_from_string(cmd, NULL);
+	switch (pr->status) {
+	case CMD_PARSE_EMPTY:
+		new_item = NULL;
+		break;
+	case CMD_PARSE_ERROR:
+		new_item = cmdq_get_error(pr->error);
+		free(pr->error);
+		cmdq_append(c, new_item);
+		break;
+	case CMD_PARSE_SUCCESS:
+		new_item = cmdq_get_command(pr->cmdlist, NULL, NULL, 0);
+		cmd_list_free(pr->cmdlist);
+		cmdq_append(c, new_item);
+		break;
 	}
 
-	free(c->identify_callback_data);
+	free(cmd);
-	c->identify_callback_data = NULL;
+	free(expanded);
-	c->identify_callback = NULL;
+	return (1);
+}
+
+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;
+	struct cmd_display_panes_data	*cdata;
+
+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+	s = c->session;
+
+	if (c->overlay_draw != NULL)
+		return (CMD_RETURN_NORMAL);
+
+	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");
+
+	cdata = xmalloc(sizeof *cdata);
+	if (args->argc != 0)
+		cdata->command = xstrdup(args->argv[0]);
+	else
+		cdata->command = xstrdup("select-pane -t '%%'");
+	if (args_has(args, 'b'))
+		cdata->item = NULL;
+	else
+		cdata->item = item;
+
+	server_client_set_overlay(c, delay, cmd_display_panes_draw,
+	    cmd_display_panes_key, cmd_display_panes_free, cdata);
+
+	if (args_has(args, 'b'))
+		return (CMD_RETURN_NORMAL);
+	return (CMD_RETURN_WAIT);
 }

cmd-find-window.c

@@ -18,9 +18,7 @@
 
 #include <sys/types.h>
 
-#include <fnmatch.h>
 #include <stdlib.h>
-#include <string.h>
 
 #include "tmux.h"
 
@@ -28,213 +26,100 @@
  * Find window containing text.
  */
 
-#define FIND_WINDOW_TEMPLATE					\
+static enum cmd_retval	cmd_find_window_exec(struct cmd *, struct cmdq_item *);
-	"#{window_index}: #{window_name} "			\
-	"[#{window_width}x#{window_height}] "			\
-	"(#{window_panes} panes) #{window_find_matches}"
-
-enum cmd_retval	 cmd_find_window_exec(struct cmd *, struct cmd_q *);
-
-void	cmd_find_window_callback(struct window_choose_data *);
-
-/* Flags for determining matching behavior. */
-#define CMD_FIND_WINDOW_BY_TITLE   0x1
-#define CMD_FIND_WINDOW_BY_CONTENT 0x2
-#define CMD_FIND_WINDOW_BY_NAME    0x4
-
-#define CMD_FIND_WINDOW_ALL		\
-	(CMD_FIND_WINDOW_BY_TITLE |	\
-	 CMD_FIND_WINDOW_BY_CONTENT |	\
-	 CMD_FIND_WINDOW_BY_NAME)
 
 const struct cmd_entry cmd_find_window_entry = {
 	.name = "find-window",
 	.alias = "findw",
 
-	.args = { "F:CNt:T", 1, 4 },
+	.args = { "CNrt:TZ", 1, 1 },
-	.usage = "[-CNT] [-F format] " CMD_TARGET_WINDOW_USAGE " match-string",
+	.usage = "[-CNrTZ] " CMD_TARGET_PANE_USAGE " match-string",
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_find_window_exec
 };
 
-struct cmd_find_window_data {
+static enum cmd_retval
-	struct winlink	*wl;
+cmd_find_window_exec(struct cmd *self, struct cmdq_item *item)
-	char		*list_ctx;
-	u_int		 pane_id;
-	TAILQ_ENTRY(cmd_find_window_data) entry;
-};
-TAILQ_HEAD(cmd_find_window_list, cmd_find_window_data);
-
-u_int	cmd_find_window_match_flags(struct args *);
-void	cmd_find_window_match(struct cmd_find_window_list *, int,
-	    struct winlink *, const char *, const char *);
-
-u_int
-cmd_find_window_match_flags(struct args *args)
 {
-	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. */
+	C = args_has(args, 'C');
-	if (args_has(args, 'T'))
+	N = args_has(args, 'N');
-		match_flags |= CMD_FIND_WINDOW_BY_TITLE;
+	T = args_has(args, 'T');
-	if (args_has(args, 'C'))
-		match_flags |= CMD_FIND_WINDOW_BY_CONTENT;
-	if (args_has(args, 'N'))
-		match_flags |= CMD_FIND_WINDOW_BY_NAME;
 
-	/* If none of the flags were set, default to matching anything. */
+	if (!C && !N && !T)
-	if (match_flags == 0)
+		C = N = T = 1;
-		match_flags = CMD_FIND_WINDOW_ALL;
 
-	return (match_flags);
+	if (!args_has(args, 'r')) {
-}
+		if (C && N && T) {
-
+			xasprintf(&filter,
-void
+			    "#{||:"
-cmd_find_window_match(struct cmd_find_window_list *find_list,
+			    "#{C:%s},#{||:#{m:*%s*,#{window_name}},"
-    int match_flags, struct winlink *wl, const char *str,
+			    "#{m:*%s*,#{pane_title}}}}",
-    const char *searchstr)
+			    s, s, s);
-{
+		} else if (C && N) {
-	struct cmd_find_window_data	*find_data;
+			xasprintf(&filter,
-	struct window_pane		*wp;
+			    "#{||:#{C:%s},#{m:*%s*,#{window_name}}}",
-	u_int				 i, line;
+			    s, s);
-	char				*sres;
+		} else if (C && T) {
-
+			xasprintf(&filter,
-	find_data = xcalloc(1, sizeof *find_data);
+			    "#{||:#{C:%s},#{m:*%s*,#{pane_title}}}",
-
+			    s, s);
-	i = 0;
+		} else if (N && T) {
-	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
+			xasprintf(&filter,
-		i++;
+			    "#{||:#{m:*%s*,#{window_name}},"
-
+			    "#{m:*%s*,#{pane_title}}}",
-		if ((match_flags & CMD_FIND_WINDOW_BY_NAME) &&
+			    s, s);
-		    fnmatch(searchstr, wl->window->name, 0) == 0) {
+		} else if (C)
-			find_data->list_ctx = xstrdup("");
+			xasprintf(&filter, "#{C:%s}", s);
-			break;
+		else if (N)
-		}
+			xasprintf(&filter, "#{m:*%s*,#{window_name}}", s);
-
+		else
-		if ((match_flags & CMD_FIND_WINDOW_BY_TITLE) &&
+			xasprintf(&filter, "#{m:*%s*,#{pane_title}}", s);
-		    fnmatch(searchstr, wp->base.title, 0) == 0) {
+	} else {
-			xasprintf(&find_data->list_ctx,
+		if (C && N && T) {
-			    "pane %u title: \"%s\"", i - 1, wp->base.title);
+			xasprintf(&filter,
-			break;
+			    "#{||:"
-		}
+			    "#{C/r:%s},#{||:#{m/r:%s,#{window_name}},"
-
+			    "#{m/r:%s,#{pane_title}}}}",
-		if (match_flags & CMD_FIND_WINDOW_BY_CONTENT &&
+			    s, s, s);
-		    (sres = window_pane_search(wp, str, &line)) != NULL) {
+		} else if (C && N) {
-			xasprintf(&find_data->list_ctx,
+			xasprintf(&filter,
-			    "pane %u line %u: \"%s\"", i - 1, line + 1, sres);
+			    "#{||:#{C/r:%s},#{m/r:%s,#{window_name}}}",
-			free(sres);
+			    s, s);
-			break;
+		} else if (C && T) {
-		}
+			xasprintf(&filter,
+			    "#{||:#{C/r:%s},#{m/r:%s,#{pane_title}}}",
+			    s, s);
+		} else if (N && T) {
+			xasprintf(&filter,
+			    "#{||:#{m/r:%s,#{window_name}},"
+			    "#{m/r:%s,#{pane_title}}}",
+			    s, s);
+		} else if (C)
+			xasprintf(&filter, "#{C/r:%s}", s);
+		else if (N)
+			xasprintf(&filter, "#{m/r:%s,#{window_name}}", s);
+		else
+			xasprintf(&filter, "#{m/r:%s,#{pane_title}}", s);
 	}
 
-	if (find_data->list_ctx != NULL) {
+	new_args = args_parse("", 1, &argv);
-		find_data->wl = wl;
+	if (args_has(args, 'Z'))
-		find_data->pane_id = i - 1;
+		args_set(new_args, 'Z', NULL);
-		TAILQ_INSERT_TAIL(find_list, find_data, entry);
+	args_set(new_args, 'f', filter);
-	} else
-		free(find_data);
-}
 
-enum cmd_retval
+	window_pane_set_mode(wp, &window_tree_mode, &item->target, new_args);
-cmd_find_window_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args			*args = self->args;
-	struct client			*c = cmdq->state.c;
-	struct window_choose_data	*cdata;
-	struct session			*s = cmdq->state.tflag.s;
-	struct winlink			*wl = cmdq->state.tflag.wl, *wm;
-	struct cmd_find_window_list	 find_list;
-	struct cmd_find_window_data	*find_data;
-	struct cmd_find_window_data	*find_data1;
-	char				*str, *searchstr;
-	const char			*template;
-	u_int				 i, match_flags;
 
-	if (c == NULL) {
+	args_free(new_args);
-		cmdq_error(cmdq, "no client available");
+	free(filter);
-		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];
-
-	TAILQ_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 (TAILQ_EMPTY(&find_list)) {
-		cmdq_error(cmdq, "no windows matching: %s", str);
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (TAILQ_NEXT(TAILQ_FIRST(&find_list), entry) == NULL) {
-		if (session_select(s, TAILQ_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;
-
-	i = 0;
-	TAILQ_FOREACH(find_data, &find_list, entry) {
-		cdata = window_choose_data_create(TREE_OTHER, c, c->session);
-		cdata->idx = find_data->wl->idx;
-		cdata->wl = find_data->wl;
-
-		cdata->ft_template = xstrdup(template);
-		cdata->pane_id = find_data->pane_id;
-
-		format_add(cdata->ft, "line", "%u", i);
-		format_add(cdata->ft, "window_find_matches", "%s",
-		    find_data->list_ctx);
-		format_defaults(cdata->ft, NULL, s, find_data->wl, NULL);
-
-		window_choose_add(wl->window->active, cdata);
-
-		i++;
-	}
-
-	window_choose_ready(wl->window->active, 0, cmd_find_window_callback);
-
-out:
-	TAILQ_FOREACH_SAFE(find_data, &find_list, entry, find_data1) {
-		free(find_data->list_ctx);
-		TAILQ_REMOVE(&find_list, find_data, entry);
-		free(find_data);
-	}
 	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

@@ -29,11 +29,10 @@
  * 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 *);
+static void		cmd_if_shell_callback(struct job *);
-void	cmd_if_shell_done(struct cmd_q *);
+static void		cmd_if_shell_free(void *);
-void	cmd_if_shell_free(void *);
 
 const struct cmd_entry cmd_if_shell_entry = {
 	.name = "if-shell",
@@ -43,163 +42,180 @@ const struct cmd_entry cmd_if_shell_entry = {
 	.usage = "[-bF] " CMD_TARGET_PANE_USAGE " shell-command command "
 		 "[command]",
 
-	.tflag = CMD_PANE_CANFAIL,
+	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
 
 	.flags = 0,
 	.exec = cmd_if_shell_exec
 };
 
 struct cmd_if_shell_data {
+	struct cmd_parse_input	 input;
+
 	char			*cmd_if;
 	char			*cmd_else;
 
-	struct cmd_q		*cmdq;
+	struct client		*client;
+	struct cmdq_item	*item;
 	struct mouse_event	 mouse;
-
-	int			 bflag;
-	int			 references;
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_if_shell_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
+	struct mouse_event		*m = &item->shared->mouse;
 	struct cmd_if_shell_data	*cdata;
-	char				*shellcmd, *cmd, *cause;
+	char				*shellcmd, *cmd;
-	struct cmd_list			*cmdlist;
+	struct cmdq_item		*new_item;
-	struct session			*s = cmdq->state.tflag.s;
+	struct cmd_find_state		*fs = &item->target;
-	struct winlink			*wl = cmdq->state.tflag.wl;
+	struct client			*c = cmd_find_client(item, NULL, 1);
-	struct window_pane		*wp = cmdq->state.tflag.wp;
+	struct session			*s = fs->s;
-	struct format_tree		*ft;
+	struct winlink			*wl = fs->wl;
-	const char			*cwd;
+	struct window_pane		*wp = fs->wp;
-
+	struct cmd_parse_input		 pi;
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
+	struct cmd_parse_result		*pr;
-		cwd = cmdq->client->cwd;
-	else if (s != NULL)
-		cwd = s->cwd;
-	else
-		cwd = NULL;
-
-	ft = format_create(cmdq, 0);
-	format_defaults(ft, cmdq->state.c, s, wl, wp);
-	shellcmd = format_expand(ft, args->argv[0]);
-	format_free(ft);
 
+	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];
+		else
+			cmd = NULL;
 		free(shellcmd);
 		if (cmd == NULL)
 			return (CMD_RETURN_NORMAL);
-		if (cmd_string_parse(cmd, &cmdlist, NULL, 0, &cause) != 0) {
+
-			if (cause != NULL) {
+		memset(&pi, 0, sizeof pi);
-				cmdq_error(cmdq, "%s", cause);
+		if (self->file != NULL)
-				free(cause);
+			pi.file = self->file;
-			}
+		pi.line = self->line;
+		pi.item = item;
+		pi.c = c;
+		cmd_find_copy_state(&pi.fs, fs);
+
+		pr = cmd_parse_from_string(cmd, &pi);
+		switch (pr->status) {
+		case CMD_PARSE_EMPTY:
+			break;
+		case CMD_PARSE_ERROR:
+			cmdq_error(item, "%s", pr->error);
+			free(pr->error);
 			return (CMD_RETURN_ERROR);
+		case CMD_PARSE_SUCCESS:
+			new_item = cmdq_get_command(pr->cmdlist, fs, m, 0);
+			cmdq_insert_after(item, new_item);
+			cmd_list_free(pr->cmdlist);
+			break;
 		}
-		cmdq_run(cmdq, cmdlist, &cmdq->item->mouse);
-		cmd_list_free(cmdlist);
 		return (CMD_RETURN_NORMAL);
 	}
 
-	cdata = xmalloc(sizeof *cdata);
+	cdata = xcalloc(1, 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;
+	memcpy(&cdata->mouse, m, sizeof cdata->mouse);
 
-	cdata->bflag = args_has(args, 'b');
+	if (!args_has(args, 'b'))
+		cdata->client = item->client;
+	else
+		cdata->client = c;
+	if (cdata->client != NULL)
+		cdata->client->references++;
 
-	cdata->cmdq = cmdq;
+	if (!args_has(args, 'b'))
-	memcpy(&cdata->mouse, &cmdq->item->mouse, sizeof cdata->mouse);
+		cdata->item = item;
-	cmdq->references++;
+	else
+		cdata->item = NULL;
 
-	cdata->references = 1;
+	memset(&cdata->input, 0, sizeof cdata->input);
-	job_run(shellcmd, s, cwd, cmd_if_shell_callback, cmd_if_shell_free,
+	if (self->file != NULL)
-	    cdata);
+		cdata->input.file = xstrdup(self->file);
+	cdata->input.line = self->line;
+	cdata->input.item = cdata->item;
+	cdata->input.c = c;
+	if (cdata->input.c != NULL)
+		cdata->input.c->references++;
+	cmd_find_copy_state(&cdata->input.fs, fs);
+
+	if (job_run(shellcmd, s, server_client_get_cwd(item->client, s), NULL,
+	    cmd_if_shell_callback, cmd_if_shell_free, cdata, 0) == NULL) {
+		cmdq_error(item, "failed to run command: %s", shellcmd);
+		free(shellcmd);
+		free(cdata);
+		return (CMD_RETURN_ERROR);
+	}
 	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_if_shell_data	*cdata = job_get_data(job);
-	struct cmd_q			*cmdq = cdata->cmdq, *cmdq1;
+	struct client			*c = cdata->client;
-	struct cmd_list			*cmdlist;
+	struct mouse_event		*m = &cdata->mouse;
-	char				*cause, *cmd;
+	struct cmdq_item		*new_item = NULL;
+	char				*cmd;
+	int				 status;
+	struct cmd_parse_result		*pr;
 
-	if (cmdq->flags & CMD_Q_DEAD)
+	status = job_get_status(job);
-		return;
+	if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
-
-	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) {
+	pr = cmd_parse_from_string(cmd, &cdata->input);
-		if (cause != NULL) {
+	switch (pr->status) {
-			cmdq_error(cmdq, "%s", cause);
+	case CMD_PARSE_EMPTY:
-			free(cause);
+		break;
-		}
+	case CMD_PARSE_ERROR:
-		return;
+		if (cdata->item != NULL)
+		       cmdq_error(cdata->item, "%s", pr->error);
+		free(pr->error);
+		break;
+	case CMD_PARSE_SUCCESS:
+		new_item = cmdq_get_command(pr->cmdlist, NULL, m, 0);
+		cmd_list_free(pr->cmdlist);
+		break;
+	}
+	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);
+out:
-	cmdq1->flags |= cmdq->flags & CMD_Q_NOHOOKS;
+	if (cdata->item != NULL)
-	cmdq1->emptyfn = cmd_if_shell_done;
+		cmdq_continue(cdata->item);
-	cmdq1->data = cdata;
-
-	cdata->references++;
-	cmdq_run(cmdq1, cmdlist, &cdata->mouse);
-	cmd_list_free(cmdlist);
 }
 
-void
+static void
-cmd_if_shell_done(struct cmd_q *cmdq1)
-{
-	struct cmd_if_shell_data	*cdata = cmdq1->data;
-	struct cmd_q			*cmdq = cdata->cmdq;
-
-	if (cmdq1->client_exit >= 0)
-		cmdq->client_exit = cmdq1->client_exit;
-	cmdq_free(cmdq1);
-
-	if (--cdata->references != 0)
-		return;
-
-	if (!cmdq_free(cmdq) && !cdata->bflag)
-		cmdq_continue(cmdq);
-
-	free(cdata->cmd_else);
-	free(cdata->cmd_if);
-	free(cdata);
-}
-
-void
 cmd_if_shell_free(void *data)
 {
 	struct cmd_if_shell_data	*cdata = data;
-	struct cmd_q			*cmdq = cdata->cmdq;
 
-	if (--cdata->references != 0)
+	if (cdata->client != NULL)
-		return;
+		server_client_unref(cdata->client);
-
-	if (!cmdq_free(cmdq) && !cdata->bflag)
-		cmdq_continue(cmdq);
 
 	free(cdata->cmd_else);
 	free(cdata->cmd_if);
+
+	if (cdata->input.c != NULL)
+		server_client_unref(cdata->input.c);
+	free((void *)cdata->input.file);
+
 	free(cdata);
 }

cmd-join-pane.c

@@ -28,9 +28,7 @@
  * Join or move a pane into another (like split/swap/kill).
  */
 
-enum cmd_retval	 cmd_join_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_join_pane_exec(struct cmd *, struct cmdq_item *);
-
-enum cmd_retval	 join_pane(struct cmd *, struct cmd_q *, int);
 
 const struct cmd_entry cmd_join_pane_entry = {
 	.name = "join-pane",
@@ -39,8 +37,8 @@ const struct cmd_entry cmd_join_pane_entry = {
 	.args = { "bdhvp:l:s:t:", 0, 0 },
 	.usage = "[-bdhv] [-p percentage|-l size] " CMD_SRCDST_PANE_USAGE,
 
-	.sflag = CMD_PANE_MARKED,
+	.source = { 's', CMD_FIND_PANE, CMD_FIND_DEFAULT_MARKED },
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_join_pane_exec
@@ -53,23 +51,18 @@ const struct cmd_entry cmd_move_pane_entry = {
 	.args = { "bdhvp:l:s:t:", 0, 0 },
 	.usage = "[-bdhv] [-p percentage|-l size] " CMD_SRCDST_PANE_USAGE,
 
-	.sflag = CMD_PANE,
+	.source = { 's', CMD_FIND_PANE, 0 },
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_join_pane_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_join_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_join_pane_exec(struct cmd *self, struct cmdq_item *item)
-{
-	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)
 {
 	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;
@@ -78,25 +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, flags;
 
-	dst_s = cmdq->state.tflag.s;
+	if (self->entry == &cmd_join_pane_entry)
-	dst_wl = cmdq->state.tflag.wl;
+		not_same_window = 1;
-	dst_wp = cmdq->state.tflag.wp;
+	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 = cmdq->state.sflag.wl;
+	src_wl = item->source.wl;
-	src_wp = cmdq->state.sflag.wp;
+	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);
 	}
 
@@ -108,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);
 		}
@@ -124,9 +123,13 @@ 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'), 0);
+	if (args_has(args, 'b'))
+		flags = SPAWN_BEFORE;
+	else
+		flags = 0;
+	lc = layout_split_pane(dst_wp, type, size, flags);
 	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);
 	}
 
@@ -136,6 +139,8 @@ join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
 	TAILQ_REMOVE(&src_w->panes, src_wp, entry);
 
 	src_wp->window = dst_w;
+	options_set_parent(src_wp->options, dst_w->options);
+	src_wp->flags |= PANE_STYLECHANGED;
 	TAILQ_INSERT_AFTER(&dst_w->panes, dst_wp, src_wp, entry);
 	layout_assign_pane(lc, src_wp);
 
@@ -145,8 +150,9 @@ join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
 	server_redraw_window(dst_w);
 
 	if (!args_has(args, 'd')) {
-		window_set_active_pane(dst_w, src_wp);
+		window_set_active_pane(dst_w, src_wp, 1);
 		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);
@@ -154,8 +160,8 @@ join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
 	if (window_count_panes(src_w) == 0)
 		server_kill_window(src_w);
 	else
-		notify_window_layout_changed(src_w);
+		notify_window("window-layout-changed", src_w);
-	notify_window_layout_changed(dst_w);
+	notify_window("window-layout-changed", dst_w);
 
 	return (CMD_RETURN_NORMAL);
 }

cmd-kill-pane.c

@@ -26,7 +26,7 @@
  * 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 = {
 	.name = "kill-pane",
@@ -35,39 +35,30 @@ const struct cmd_entry cmd_kill_pane_entry = {
 	.args = { "at:", 0, 0 },
 	.usage = "[-a] " CMD_TARGET_PANE_USAGE,
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_kill_pane_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_kill_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_kill_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	struct winlink		*wl = item->target.wl;
-	struct window_pane	*loopwp, *tmpwp, *wp = cmdq->state.tflag.wp;
+	struct window_pane	*loopwp, *tmpwp, *wp = item->target.wp;
-
-	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')) {
+		server_unzoom_window(wl->window);
 		TAILQ_FOREACH_SAFE(loopwp, &wl->window->panes, entry, tmpwp) {
 			if (loopwp == wp)
 				continue;
 			layout_close_pane(loopwp);
 			window_remove_pane(wl->window, loopwp);
 		}
-	} else {
+		server_redraw_window(wl->window);
-		layout_close_pane(wp);
+		return (CMD_RETURN_NORMAL);
-		window_remove_pane(wl->window, wp);
 	}
-	server_redraw_window(wl->window);
 
+	server_kill_pane(wp);
 	return (CMD_RETURN_NORMAL);
 }

cmd-kill-server.c

@@ -27,7 +27,7 @@
  * 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 = {
 	.name = "kill-server",
@@ -51,8 +51,8 @@ const struct cmd_entry cmd_start_server_entry = {
 	.exec = cmd_kill_server_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_kill_server_exec(struct cmd *self, __unused struct cmd_q *cmdq)
+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

@@ -27,7 +27,7 @@
  * 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 = {
 	.name = "kill-session",
@@ -36,20 +36,20 @@ const struct cmd_entry cmd_kill_session_entry = {
 	.args = { "aCt:", 0, 0 },
 	.usage = "[-aC] " CMD_TARGET_SESSION_USAGE,
 
-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },
 
 	.flags = 0,
 	.exec = cmd_kill_session_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_kill_session_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_kill_session_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
 	struct session	*s, *sloop, *stmp;
 	struct winlink	*wl;
 
-	s = cmdq->state.tflag.s;
+	s = item->target.s;
 
 	if (args_has(args, 'C')) {
 		RB_FOREACH(wl, winlinks, &s->windows) {
@@ -61,12 +61,12 @@ cmd_kill_session_exec(struct cmd *self, struct cmd_q *cmdq)
 		RB_FOREACH_SAFE(sloop, sessions, &sessions, stmp) {
 			if (sloop != s) {
 				server_destroy_session(sloop);
-				session_destroy(sloop);
+				session_destroy(sloop, 1, __func__);
 			}
 		}
 	} else {
 		server_destroy_session(s);
-		session_destroy(s);
+		session_destroy(s, 1, __func__);
 	}
 	return (CMD_RETURN_NORMAL);
 }

cmd-kill-window.c

@@ -24,7 +24,7 @@
  * 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 = {
 	.name = "kill-window",
@@ -33,7 +33,7 @@ const struct cmd_entry cmd_kill_window_entry = {
 	.args = { "at:", 0, 0 },
 	.usage = "[-a] " CMD_TARGET_WINDOW_USAGE,
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
 	.flags = 0,
 	.exec = cmd_kill_window_exec
@@ -46,23 +46,23 @@ const struct cmd_entry cmd_unlink_window_entry = {
 	.args = { "kt:", 0, 0 },
 	.usage = "[-k] " CMD_TARGET_WINDOW_USAGE,
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
 	.flags = 0,
 	.exec = cmd_kill_window_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_kill_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_kill_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct winlink		*wl = cmdq->state.tflag.wl, *wl2, *wl3;
+	struct winlink		*wl = item->target.wl, *wl2, *wl3;
 	struct window		*w = wl->window;
-	struct session		*s = cmdq->state.tflag.s;
+	struct session		*s = item->target.s;
 
 	if (self->entry == &cmd_unlink_window_entry) {
 		if (!args_has(self->args, 'k') && !session_is_linked(s, w)) {
-			cmdq_error(cmdq, "window only linked to one session");
+			cmdq_error(item, "window only linked to one session");
 			return (CMD_RETURN_ERROR);
 		}
 		server_unlink_window(s, wl);

cmd-list-buffers.c

@@ -30,7 +30,7 @@
 #define LIST_BUFFERS_TEMPLATE						\
 	"#{buffer_name}: #{buffer_size} bytes: \"#{buffer_sample}\""
 
-enum cmd_retval	 cmd_list_buffers_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_list_buffers_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_list_buffers_entry = {
 	.name = "list-buffers",
@@ -39,12 +39,12 @@ const struct cmd_entry cmd_list_buffers_entry = {
 	.args = { "F:", 0, 0 },
 	.usage = "[-F format]",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_list_buffers_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_list_buffers_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_list_buffers_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct paste_buffer	*pb;
@@ -57,11 +57,11 @@ cmd_list_buffers_exec(struct cmd *self, struct cmd_q *cmdq)
 
 	pb = NULL;
 	while ((pb = paste_walk(pb)) != NULL) {
-		ft = format_create(cmdq, 0);
+		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

@@ -29,11 +29,11 @@
  */
 
 #define LIST_CLIENTS_TEMPLATE					\
-	"#{client_tty}: #{session_name} "			\
+	"#{client_name}: #{session_name} "			\
 	"[#{client_width}x#{client_height} #{client_termname}]"	\
 	"#{?client_utf8, (utf8),} #{?client_readonly, (ro),}"
 
-enum cmd_retval	cmd_list_clients_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_list_clients_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_list_clients_entry = {
 	.name = "list-clients",
@@ -42,14 +42,14 @@ const struct cmd_entry cmd_list_clients_entry = {
 	.args = { "F:t:", 0, 0 },
 	.usage = "[-F format] " CMD_TARGET_SESSION_USAGE,
 
-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },
 
-	.flags = CMD_READONLY,
+	.flags = CMD_READONLY|CMD_AFTERHOOK,
 	.exec = cmd_list_clients_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_list_clients_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_list_clients_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args 		*args = self->args;
 	struct client		*c;
@@ -60,7 +60,7 @@ cmd_list_clients_exec(struct cmd *self, struct cmd_q *cmdq)
 	char			*line;
 
 	if (args_has(args, 't'))
-		s = cmdq->state.tflag.s;
+		s = item->target.s;
 	else
 		s = NULL;
 
@@ -72,12 +72,12 @@ cmd_list_clients_exec(struct cmd *self, struct cmd_q *cmdq)
 		if (c->session == NULL || (s != NULL && s != c->session))
 			continue;
 
-		ft = format_create(cmdq, 0);
+		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);

cmd-list-keys.c

@@ -27,19 +27,19 @@
  * List key bindings.
  */
 
-static enum cmd_retval	 cmd_list_keys_exec(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_table(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_list_keys_commands(struct cmd *,
-static enum cmd_retval	 cmd_list_keys_commands(struct cmd *, struct cmd_q *);
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_list_keys_entry = {
 	.name = "list-keys",
 	.alias = "lsk",
 
-	.args = { "t:T:", 0, 0 },
+	.args = { "T:", 0, 0 },
-	.usage = "[-t mode-table] [-T key-table]",
+	.usage = "[-T key-table]",
 
-	.flags = CMD_STARTSERVER,
+	.flags = CMD_STARTSERVER|CMD_AFTERHOOK,
 	.exec = cmd_list_keys_exec
 };
 
@@ -50,41 +50,43 @@ const struct cmd_entry cmd_list_commands_entry = {
 	.args = { "F:", 0, 0 },
 	.usage = "[-F format]",
 
-	.flags = CMD_STARTSERVER,
+	.flags = CMD_STARTSERVER|CMD_AFTERHOOK,
 	.exec = cmd_list_keys_exec
 };
 
 static enum cmd_retval
-cmd_list_keys_exec(struct cmd *self, struct cmd_q *cmdq)
+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, *tablename, *r;
+	const char		*tablename, *r;
-	char			*cp, tmp[BUFSIZ];
+	char			*key, *cp, *tmp;
 	int			 repeat, width, tablewidth, keywidth;
+	size_t			 tmpsize, tmpused, cplen;
 
 	if (self->entry == &cmd_list_commands_entry)
-		return (cmd_list_keys_commands(self, cmdq));
+		return (cmd_list_keys_commands(self, item));
-
-	if (args_has(args, 't'))
-		return (cmd_list_keys_table(self, cmdq));
 
 	tablename = args_get(args, 'T');
 	if (tablename != NULL && key_bindings_get_table(tablename, 0) == NULL) {
-		cmdq_error(cmdq, "table %s doesn't exist", tablename);
+		cmdq_error(item, "table %s doesn't exist", tablename);
 		return (CMD_RETURN_ERROR);
 	}
 
 	repeat = 0;
 	tablewidth = keywidth = 0;
-	RB_FOREACH(table, key_tables, &key_tables) {
+	table = key_bindings_first_table ();
-		if (tablename != NULL && strcmp(table->name, tablename) != 0)
+	while (table != NULL) {
+		if (tablename != NULL && strcmp(table->name, tablename) != 0) {
+			table = key_bindings_next_table(table);
 			continue;
-		RB_FOREACH(bd, key_bindings, &table->key_bindings) {
+		}
-			key = key_string_lookup_key(bd->key);
+		bd = key_bindings_first(table);
+		while (bd != NULL) {
+			key = args_escape(key_string_lookup_key(bd->key));
 
-			if (bd->can_repeat)
+			if (bd->flags & KEY_BINDING_REPEAT)
 				repeat = 1;
 
 			width = utf8_cstrwidth(table->name);
@@ -93,114 +95,84 @@ cmd_list_keys_exec(struct cmd *self, struct cmd_q *cmdq)
 			width = utf8_cstrwidth(key);
 			if (width > keywidth)
 				keywidth = width;
+
+			free(key);
+			bd = key_bindings_next(table, bd);
 		}
+		table = key_bindings_next_table(table);
 	}
 
-	RB_FOREACH(table, key_tables, &key_tables) {
+	tmpsize = 256;
-		if (tablename != NULL && strcmp(table->name, tablename) != 0)
+	tmp = xmalloc(tmpsize);
+
+	table = key_bindings_first_table ();
+	while (table != NULL) {
+		if (tablename != NULL && strcmp(table->name, tablename) != 0) {
+			table = key_bindings_next_table(table);
 			continue;
-		RB_FOREACH(bd, key_bindings, &table->key_bindings) {
+		}
-			key = key_string_lookup_key(bd->key);
+		bd = key_bindings_first(table);
+		while (bd != NULL) {
+			key = args_escape(key_string_lookup_key(bd->key));
 
 			if (!repeat)
 				r = "";
-			else if (bd->can_repeat)
+			else if (bd->flags & KEY_BINDING_REPEAT)
 				r = "-r ";
 			else
 				r = "   ";
-			xsnprintf(tmp, sizeof tmp, "%s-T ", r);
+			tmpused = xsnprintf(tmp, tmpsize, "%s-T ", r);
 
 			cp = utf8_padcstr(table->name, tablewidth);
-			strlcat(tmp, cp, sizeof tmp);
+			cplen = strlen(cp) + 1;
-			strlcat(tmp, " ", sizeof tmp);
+			while (tmpused + cplen + 1 >= tmpsize) {
+				tmpsize *= 2;
+				tmp = xrealloc(tmp, tmpsize);
+			}
+			tmpused = strlcat(tmp, cp, tmpsize);
+			tmpused = strlcat(tmp, " ", tmpsize);
 			free(cp);
 
 			cp = utf8_padcstr(key, keywidth);
-			strlcat(tmp, cp, sizeof tmp);
+			cplen = strlen(cp) + 1;
-			strlcat(tmp, " ", sizeof tmp);
+			while (tmpused + cplen + 1 >= tmpsize) {
+				tmpsize *= 2;
+				tmp = xrealloc(tmp, tmpsize);
+			}
+			tmpused = strlcat(tmp, cp, tmpsize);
+			tmpused = strlcat(tmp, " ", tmpsize);
 			free(cp);
 
-			cp = cmd_list_print(bd->cmdlist);
+			cp = cmd_list_print(bd->cmdlist, 1);
-			strlcat(tmp, cp, sizeof tmp);
+			cplen = strlen(cp);
+			while (tmpused + cplen + 1 >= tmpsize) {
+				tmpsize *= 2;
+				tmp = xrealloc(tmp, tmpsize);
+			}
+			strlcat(tmp, cp, tmpsize);
 			free(cp);
 
-			cmdq_print(cmdq, "bind-key %s", tmp);
+			cmdq_print(item, "bind-key %s", tmp);
+
+			free(key);
+			bd = key_bindings_next(table, bd);
 		}
+		table = key_bindings_next_table(table);
 	}
 
+	free(tmp);
+
 	return (CMD_RETURN_NORMAL);
 }
 
 static enum cmd_retval
-cmd_list_keys_table(struct cmd *self, struct cmd_q *cmdq)
+cmd_list_keys_commands(struct cmd *self, struct cmdq_item *item)
-{
-	struct args			*args = self->args;
-	const char			*tablename, *key, *cmdstr, *mode;
-	const struct mode_key_table	*mtab;
-	struct mode_key_binding		*mbind;
-	char				 repeat[16];
-	int			 	 width, keywidth, repeatwidth, any_mode;
-
-	tablename = args_get(args, 't');
-	if ((mtab = mode_key_findtable(tablename)) == NULL) {
-		cmdq_error(cmdq, "unknown key table: %s", tablename);
-		return (CMD_RETURN_ERROR);
-	}
-
-	keywidth = repeatwidth = 0;
-	any_mode = 0;
-	RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
-		key = key_string_lookup_key(mbind->key);
-
-		if (mbind->mode != 0)
-			any_mode = 1;
-
-		width = strlen(key);
-		if (width > keywidth)
-			keywidth = width;
-
-		if (mbind->repeat != 1) {
-			snprintf(repeat, sizeof repeat, "%u", mbind->repeat);
-			width = strlen(repeat);
-			if (width > repeatwidth)
-				repeatwidth = width;
-		}
-	}
-
-	RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
-		key = key_string_lookup_key(mbind->key);
-
-		mode = "";
-		if (mbind->mode != 0)
-			mode = "c";
-		snprintf(repeat, sizeof repeat, "%u", mbind->repeat);
-		cmdstr = mode_key_tostring(mtab->cmdstr, mbind->cmd);
-		if (cmdstr != NULL) {
-			cmdq_print(cmdq,
-			    "bind-key -%st %s%s%s%*s %*s %s%s%s%s",
-			    mode, any_mode && *mode == '\0' ? " " : "",
-			    mtab->name,
-			    mbind->repeat != 1 ? " -R " :
-			    (repeatwidth == 0 ? "" : "    "),
-			    repeatwidth, mbind->repeat != 1 ? repeat : "",
-			    (int)keywidth, key, cmdstr,
-			    mbind->arg != NULL ? " \"" : "",
-			    mbind->arg != NULL ? mbind->arg : "",
-			    mbind->arg != NULL ? "\"": "");
-		}
-	}
-
-	return (CMD_RETURN_NORMAL);
-}
-
-static enum cmd_retval
-cmd_list_keys_commands(struct cmd *self, struct cmd_q *cmdq)
 {
 	struct args		*args = self->args;
 	const struct cmd_entry	**entryp;
 	const struct cmd_entry	 *entry;
 	struct format_tree	 *ft;
-	const char		 *template;
+	const char		 *template, *s;
 	char			 *line;
 
 	if ((template = args_get(args, 'F')) == NULL) {
@@ -209,25 +181,27 @@ cmd_list_keys_commands(struct cmd *self, struct cmd_q *cmdq)
 		    "#{command_list_usage}";
 	}
 
-	ft = format_create(cmdq, 0);
+	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) {
+		if (entry->alias != NULL)
-			format_add(ft, "command_list_alias", "%s",
+			s = entry->alias;
-			    entry->alias);
+		else
-		}
+			s = "";
-		if (entry->alias != NULL) {
+		format_add(ft, "command_list_alias", "%s", s);
-			format_add(ft, "command_list_usage", "%s",
+		if (entry->usage != NULL)
-			    entry->usage);
+			s = entry->usage;
-		}
+		else
+			s = "";
+		format_add(ft, "command_list_usage", "%s", s);
 
 		line = format_expand(ft, template);
 		if (*line != '\0')
-			cmdq_print(cmdq, "%s", line);
+			cmdq_print(item, "%s", line);
 		free(line);
 	}
 

cmd-list-panes.c

@@ -26,13 +26,13 @@
  * 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 *);
+static void	cmd_list_panes_server(struct cmd *, struct cmdq_item *);
-void	cmd_list_panes_session(struct cmd *, struct session *, struct cmd_q *,
+static void	cmd_list_panes_session(struct cmd *, struct session *,
-	    int);
+		    struct cmdq_item *, int);
-void	cmd_list_panes_window(struct cmd *, struct session *, struct winlink *,
+static void	cmd_list_panes_window(struct cmd *, struct session *,
-	    struct cmd_q *, int);
+		    struct winlink *, struct cmdq_item *, int);
 
 const struct cmd_entry cmd_list_panes_entry = {
 	.name = "list-panes",
@@ -41,51 +41,51 @@ const struct cmd_entry cmd_list_panes_entry = {
 	.args = { "asF:t:", 0, 0 },
 	.usage = "[-as] [-F format] " CMD_TARGET_WINDOW_USAGE,
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_list_panes_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_list_panes_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_list_panes_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct session	*s = cmdq->state.tflag.s;
+	struct session	*s = item->target.s;
-	struct winlink	*wl = cmdq->state.tflag.wl;
+	struct winlink	*wl = item->target.wl;
 
 	if (args_has(args, 'a'))
-		cmd_list_panes_server(self, cmdq);
+		cmd_list_panes_server(self, item);
 	else if (args_has(args, 's'))
-		cmd_list_panes_session(self, s, cmdq, 1);
+		cmd_list_panes_session(self, s, item, 1);
 	else
-		cmd_list_panes_window(self, s, wl, cmdq, 0);
+		cmd_list_panes_window(self, s, wl, item, 0);
 
 	return (CMD_RETURN_NORMAL);
 }
 
-void
+static void
-cmd_list_panes_server(struct cmd *self, struct cmd_q *cmdq)
+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
+static void
-cmd_list_panes_session(struct cmd *self, struct session *s, struct cmd_q *cmdq,
+cmd_list_panes_session(struct cmd *self, struct session *s,
-    int type)
+    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
+static void
 cmd_list_panes_window(struct cmd *self, struct session *s, struct winlink *wl,
-    struct cmd_q *cmdq, int type)
+    struct cmdq_item *item, int type)
 {
 	struct args		*args = self->args;
 	struct window_pane	*wp;
@@ -123,12 +123,12 @@ cmd_list_panes_window(struct cmd *self, struct session *s, struct winlink *wl,
 
 	n = 0;
 	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
-		ft = format_create(cmdq, 0);
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", n);
 		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

@@ -30,13 +30,13 @@
 
 #define LIST_SESSIONS_TEMPLATE				\
 	"#{session_name}: #{session_windows} windows "	\
-	"(created #{t:session_created}) "		\
+	"(created #{t:session_created})"		\
-	"[#{session_width}x#{session_height}]"		\
 	"#{?session_grouped, (group ,}"			\
 	"#{session_group}#{?session_grouped,),}"	\
 	"#{?session_attached, (attached),}"
 
-enum cmd_retval	 cmd_list_sessions_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_list_sessions_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_list_sessions_entry = {
 	.name = "list-sessions",
@@ -45,12 +45,12 @@ const struct cmd_entry cmd_list_sessions_entry = {
 	.args = { "F:", 0, 0 },
 	.usage = "[-F format]",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_list_sessions_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_list_sessions_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_list_sessions_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct session		*s;
@@ -64,12 +64,12 @@ cmd_list_sessions_exec(struct cmd *self, struct cmd_q *cmdq)
 
 	n = 0;
 	RB_FOREACH(s, sessions, &sessions) {
-		ft = format_create(cmdq, 0);
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", n);
 		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

@@ -39,11 +39,11 @@
 	"(#{window_panes} panes) "				\
 	"[#{window_width}x#{window_height}] "
 
-enum cmd_retval	 cmd_list_windows_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_list_windows_exec(struct cmd *, struct cmdq_item *);
 
-void	cmd_list_windows_server(struct cmd *, struct cmd_q *);
+static void	cmd_list_windows_server(struct cmd *, struct cmdq_item *);
-void	cmd_list_windows_session(struct cmd *, struct session *,
+static void	cmd_list_windows_session(struct cmd *, struct session *,
-	    struct cmd_q *, int);
+		    struct cmdq_item *, int);
 
 const struct cmd_entry cmd_list_windows_entry = {
 	.name = "list-windows",
@@ -52,41 +52,41 @@ const struct cmd_entry cmd_list_windows_entry = {
 	.args = { "F:at:", 0, 0 },
 	.usage = "[-a] [-F format] " CMD_TARGET_SESSION_USAGE,
 
-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_list_windows_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_list_windows_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_list_windows_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
 
 	if (args_has(args, 'a'))
-		cmd_list_windows_server(self, cmdq);
+		cmd_list_windows_server(self, item);
 	else
-		cmd_list_windows_session(self, cmdq->state.tflag.s, cmdq, 0);
+		cmd_list_windows_session(self, item->target.s, item, 0);
 
 	return (CMD_RETURN_NORMAL);
 }
 
-void
+static void
-cmd_list_windows_server(struct cmd *self, struct cmd_q *cmdq)
+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
+static void
 cmd_list_windows_session(struct cmd *self, struct session *s,
-    struct cmd_q *cmdq, int type)
+    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;
@@ -105,12 +105,12 @@ cmd_list_windows_session(struct cmd *self, struct session *s,
 
 	n = 0;
 	RB_FOREACH(wl, winlinks, &s->windows) {
-		ft = format_create(cmdq, 0);
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", n);
 		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,126 +0,0 @@
-/* $OpenBSD$ */
-
-/*
- * 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
- * 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"
-
-struct cmd_list *
-cmd_list_parse(int argc, char **argv, const char *file, u_int line,
-    char **cause)
-{
-	struct cmd_list	*cmdlist;
-	struct cmd	*cmd;
-	int		 i, lastsplit;
-	size_t		 arglen, new_argc;
-	char	       **copy_argv, **new_argv;
-
-	copy_argv = cmd_copy_argv(argc, argv);
-
-	cmdlist = xcalloc(1, sizeof *cmdlist);
-	cmdlist->references = 1;
-	TAILQ_INIT(&cmdlist->list);
-
-	lastsplit = 0;
-	for (i = 0; i < argc; i++) {
-		arglen = strlen(copy_argv[i]);
-		if (arglen == 0 || copy_argv[i][arglen - 1] != ';')
-			continue;
-		copy_argv[i][arglen - 1] = '\0';
-
-		if (arglen > 1 && copy_argv[i][arglen - 2] == '\\') {
-			copy_argv[i][arglen - 2] = ';';
-			continue;
-		}
-
-		new_argc = i - lastsplit;
-		new_argv = copy_argv + lastsplit;
-		if (arglen != 1)
-			new_argc++;
-
-		cmd = cmd_parse(new_argc, new_argv, file, line, cause);
-		if (cmd == NULL)
-			goto bad;
-		TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
-
-		lastsplit = i + 1;
-	}
-
-	if (lastsplit != argc) {
-		cmd = cmd_parse(argc - lastsplit, copy_argv + lastsplit,
-		    file, line, cause);
-		if (cmd == NULL)
-			goto bad;
-		TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
-	}
-
-	cmd_free_argv(argc, copy_argv);
-	return (cmdlist);
-
-bad:
-	cmd_list_free(cmdlist);
-	cmd_free_argv(argc, copy_argv);
-	return (NULL);
-}
-
-void
-cmd_list_free(struct cmd_list *cmdlist)
-{
-	struct cmd	*cmd, *cmd1;
-
-	if (--cmdlist->references != 0)
-		return;
-
-	TAILQ_FOREACH_SAFE(cmd, &cmdlist->list, qentry, cmd1) {
-		TAILQ_REMOVE(&cmdlist->list, cmd, qentry);
-		args_free(cmd->args);
-		free(cmd->file);
-		free(cmd);
-	}
-
-	free(cmdlist);
-}
-
-char *
-cmd_list_print(struct cmd_list *cmdlist)
-{
-	struct cmd	*cmd;
-	char		*buf, *this;
-	size_t		 len;
-
-	len = 1;
-	buf = xcalloc(1, len);
-
-	TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
-		this = cmd_print(cmd);
-
-		len += strlen(this) + 3;
-		buf = xrealloc(buf, len);
-
-		strlcat(buf, this, len);
-		if (TAILQ_NEXT(cmd, qentry) != NULL)
-			strlcat(buf, " ; ", len);
-
-		free(this);
-	}
-
-	return (buf);
-}

cmd-load-buffer.c

@@ -31,8 +31,9 @@
  * Loads a paste buffer from a file.
  */
 
-enum cmd_retval	 cmd_load_buffer_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_load_buffer_exec(struct cmd *, struct cmdq_item *);
-void		 cmd_load_buffer_callback(struct client *, int, void *);
+
+static void		cmd_load_buffer_callback(struct client *, int, void *);
 
 const struct cmd_entry cmd_load_buffer_entry = {
 	.name = "load-buffer",
@@ -41,59 +42,64 @@ const struct cmd_entry cmd_load_buffer_entry = {
 	.args = { "b:", 1, 1 },
 	.usage = CMD_BUFFER_USAGE " path",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_load_buffer_exec
 };
 
-enum cmd_retval
+struct cmd_load_buffer_data {
-cmd_load_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+	struct cmdq_item	*item;
+	char			*bufname;
+};
+
+static enum cmd_retval
+cmd_load_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args			*args = self->args;
-	struct client	*c = cmdq->client;
+	struct cmd_load_buffer_data	*cdata;
-	struct session  *s;
+	struct client			*c = cmd_find_client(item, NULL, 1);
-	FILE		*f;
+	struct session			*s = item->target.s;
-	const char	*path, *bufname, *cwd;
+	struct winlink			*wl = item->target.wl;
-	char		*pdata, *new_pdata, *cause, *file, resolved[PATH_MAX];
+	struct window_pane		*wp = item->target.wp;
-	size_t		 psize;
+	FILE				*f;
-	int		 ch, error;
+	const char			*bufname;
+	char				*pdata = NULL, *new_pdata, *cause;
+	char				*path, *file;
+	size_t				 psize;
+	int				 ch, error;
 
 	bufname = NULL;
 	if (args_has(args, 'b'))
 		bufname = args_get(args, 'b');
 
-	path = args->argv[0];
+	path = format_single(item, args->argv[0], c, s, wl, wp);
 	if (strcmp(path, "-") == 0) {
+		free(path);
+		c = item->client;
+
+		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,
-		    (void *)bufname, &cause);
+		    cdata, &cause);
 		if (error != 0) {
-			cmdq_error(cmdq, "%s: %s", path, cause);
+			cmdq_error(item, "-: %s", cause);
 			free(cause);
+			free(cdata);
 			return (CMD_RETURN_ERROR);
 		}
 		return (CMD_RETURN_WAIT);
 	}
 
-	if (c != NULL && c->session == NULL && c->cwd != NULL)
+	file = server_client_get_path(item->client, path);
-		cwd = c->cwd;
+	free(path);
-	else if ((s = c->session) != NULL && s->cwd != NULL)
-		cwd = s->cwd;
-	else
-		cwd = ".";
 
-	if (*path == '/')
+	f = fopen(file, "rb");
-		file = xstrdup(path);
-	else
-		xasprintf(&file, "%s/%s", cwd, path);
-	if (realpath(file, resolved) == NULL &&
-	    strlcpy(resolved, file, sizeof resolved) >= sizeof resolved) {
-		cmdq_error(cmdq, "%s: %s", file, strerror(ENAMETOOLONG));
-		return (CMD_RETURN_ERROR);
-	}
-	f = fopen(resolved, "rb");
-	free(file);
 	if (f == NULL) {
-		cmdq_error(cmdq, "%s: %s", resolved, strerror(errno));
+		cmdq_error(item, "%s: %s", file, strerror(errno));
-		return (CMD_RETURN_ERROR);
+		goto error;
 	}
 
 	pdata = NULL;
@@ -101,23 +107,24 @@ 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", resolved);
+		cmdq_error(item, "%s: read error", file);
 		goto error;
 	}
 	if (pdata != NULL)
 		pdata[psize] = '\0';
 
 	fclose(f);
+	free(file);
 
 	if (paste_set(pdata, psize, bufname, &cause) != 0) {
-		cmdq_error(cmdq, "%s", cause);
+		cmdq_error(item, "%s", cause);
 		free(pdata);
 		free(cause);
 		return (CMD_RETURN_ERROR);
@@ -129,15 +136,16 @@ 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)
 {
-	const char	*bufname = data;
+	struct cmd_load_buffer_data	*cdata = data;
-	char		*pdata, *cause, *saved;
+	char				*pdata, *cause, *saved;
-	size_t		 psize;
+	size_t				 psize;
 
 	if (!closed)
 		return;
@@ -145,7 +153,7 @@ cmd_load_buffer_callback(struct client *c, int closed, void *data)
 
 	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)
@@ -155,7 +163,7 @@ cmd_load_buffer_callback(struct client *c, int closed, void *data)
 	pdata[psize] = '\0';
 	evbuffer_drain(c->stdin_data, psize);
 
-	if (paste_set(pdata, psize, bufname, &cause) != 0) {
+	if (paste_set(pdata, psize, cdata->bufname, &cause) != 0) {
 		/* No context so can't use server_client_msg_error. */
 		if (~c->flags & CLIENT_UTF8) {
 			saved = cause;
@@ -167,7 +175,9 @@ cmd_load_buffer_callback(struct client *c, int closed, void *data)
 		free(pdata);
 		free(cause);
 	}
-
 out:
-	cmdq_continue(c->cmdq);
+	cmdq_continue(cdata->item);
+
+	free(cdata->bufname);
+	free(cdata);
 }

cmd-lock-server.c

@@ -24,7 +24,7 @@
  * 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 = {
 	.name = "lock-server",
@@ -33,7 +33,7 @@ const struct cmd_entry cmd_lock_server_entry = {
 	.args = { "", 0, 0 },
 	.usage = "",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_lock_server_exec
 };
 
@@ -44,9 +44,9 @@ const struct cmd_entry cmd_lock_session_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_SESSION_USAGE,
 
-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_lock_server_exec
 };
 
@@ -57,22 +57,25 @@ const struct cmd_entry cmd_lock_client_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_CLIENT_USAGE,
 
-	.tflag = CMD_CLIENT,
+	.flags = CMD_AFTERHOOK,
-
-	.flags = 0,
 	.exec = cmd_lock_server_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_lock_server_exec(struct cmd *self, __unused struct cmd_q *cmdq)
+cmd_lock_server_exec(struct cmd *self, struct cmdq_item *item)
 {
+	struct args	*args = self->args;
+	struct client	*c;
+
 	if (self->entry == &cmd_lock_server_entry)
 		server_lock();
 	else if (self->entry == &cmd_lock_session_entry)
-		server_lock_session(cmdq->state.tflag.s);
+		server_lock_session(item->target.s);
-	else
+	else {
-		server_lock_client(cmdq->state.c);
+		if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
-
+			return (CMD_RETURN_ERROR);
+		server_lock_client(c);
+	}
 	recalculate_sizes();
 
 	return (CMD_RETURN_NORMAL);

cmd-move-window.c

@@ -26,7 +26,7 @@
  * 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 = {
 	.name = "move-window",
@@ -35,8 +35,8 @@ const struct cmd_entry cmd_move_window_entry = {
 	.args = { "adkrs:t:", 0, 0 },
 	.usage = "[-dkr] " CMD_SRCDST_WINDOW_USAGE,
 
-	.sflag = CMD_WINDOW,
+	.source = { 's', CMD_FIND_WINDOW, 0 },
-	.tflag = CMD_MOVEW_R,
+	/* -t is special */
 
 	.flags = 0,
 	.exec = cmd_move_window_exec
@@ -49,32 +49,42 @@ const struct cmd_entry cmd_link_window_entry = {
 	.args = { "adks:t:", 0, 0 },
 	.usage = "[-dk] " CMD_SRCDST_WINDOW_USAGE,
 
-	.sflag = CMD_WINDOW,
+	.source = { 's', CMD_FIND_WINDOW, 0 },
-	.tflag = CMD_WINDOW_INDEX,
+	/* -t is special */
 
 	.flags = 0,
 	.exec = cmd_move_window_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_move_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_move_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct session	*src = cmdq->state.sflag.s;
+	const char	*tflag = args_get(args, 't');
-	struct session	*dst = cmdq->state.tflag.s;
+	struct session	*src;
-	struct winlink	*wl = cmdq->state.sflag.wl;
+	struct session	*dst;
+	struct winlink	*wl;
 	char		*cause;
-	int		 idx = cmdq->state.tflag.idx, kflag, dflag, sflag;
+	int		 idx, kflag, dflag, sflag;
-
-	kflag = args_has(self->args, 'k');
-	dflag = args_has(self->args, 'd');
 
 	if (args_has(args, 'r')) {
-		session_renumber_windows(dst);
+		if (cmd_find_target(&item->target, item, tflag,
+		    CMD_FIND_SESSION, CMD_FIND_QUIET) != 0)
+			return (CMD_RETURN_ERROR);
+
+		session_renumber_windows(item->target.s);
 		recalculate_sizes();
+		server_status_session(item->target.s);
 
 		return (CMD_RETURN_NORMAL);
 	}
+	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');
@@ -87,7 +97,7 @@ cmd_move_window_exec(struct cmd *self, struct cmd_q *cmdq)
 
 	if (server_link_window(src, wl, dst, idx, kflag, !dflag,
 	    &cause) != 0) {
-		cmdq_error(cmdq, "can't link window: %s", cause);
+		cmdq_error(item, "can't link window: %s", cause);
 		free(cause);
 		return (CMD_RETURN_ERROR);
 	}

cmd-new-session.c

@@ -33,18 +33,18 @@
 
 #define NEW_SESSION_TEMPLATE "#{session_name}:"
 
-enum cmd_retval	 cmd_new_session_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_new_session_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_new_session_entry = {
 	.name = "new-session",
 	.alias = "new",
 
-	.args = { "Ac:dDEF:n:Ps:t:x:y:", 0, -1 },
+	.args = { "Ac:dDEF:n:Ps:t:x:Xy:", 0, -1 },
-	.usage = "[-AdDEP] [-c start-directory] [-F format] [-n window-name] "
+	.usage = "[-AdDEPX] [-c start-directory] [-F format] [-n window-name] "
 		 "[-s session-name] " CMD_TARGET_SESSION_USAGE " [-x width] "
 		 "[-y height] [command]",
 
-	.tflag = CMD_SESSION_CANFAIL,
+	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
 
 	.flags = CMD_STARTSERVER,
 	.exec = cmd_new_session_exec
@@ -57,79 +57,94 @@ const struct cmd_entry cmd_has_session_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_SESSION_USAGE,
 
-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },
 
 	.flags = 0,
 	.exec = cmd_new_session_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->client;
+	struct client		*c = item->client;
-	struct session		*s, *as;
+	struct session		*s, *as, *groupwith;
-	struct session		*groupwith = cmdq->state.tflag.s;
-	struct window		*w;
 	struct environ		*env;
+	struct options		*oo;
 	struct termios		 tio, *tiop;
-	const char		*newname, *target, *update, *errstr, *template;
+	struct session_group	*sg;
-	const char		*path, *cwd, *to_free = NULL;
+	const char		*errstr, *template, *group, *prefix, *tmp;
-	char		       **argv, *cmd, *cause, *cp;
+	char			*cause, *cwd = NULL, *cp, *newname = NULL;
-	int			 detached, already_attached, idx, argc;
+	int			 detached, already_attached, is_control = 0;
-	u_int			 sx, sy;
+	u_int			 sx, sy, dsx, dsy;
-	struct format_tree	*ft;
+	struct spawn_context	 sc;
-	struct environ_entry	*envent;
+	enum cmd_retval		 retval;
+	struct cmd_find_state    fs;
 
 	if (self->entry == &cmd_has_session_entry) {
 		/*
-		 * cmd_prepare() will fail if the session cannot be found,
+		 * cmd_find_target() will fail if the session cannot be found,
-		 * hence always return success here.
+		 * 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 (args_has(args, 's')) {
-	if (newname != NULL) {
+		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);
+			cmdq_error(item, "bad session name: %s", newname);
-			return (CMD_RETURN_ERROR);
+			goto fail;
 		}
 		if ((as = session_find(newname)) != NULL) {
 			if (args_has(args, 'A')) {
-				/*
+				retval = cmd_attach_session(item,
-				 * This cmdq is now destined for
+				    newname, args_has(args, 'D'),
-				 * attach-session.  Because attach-session
+				    args_has(args, 'X'), 0, NULL,
-				 * will have already been prepared, copy this
+				    args_has(args, 'E'));
-				 * session into its tflag so it can be used.
+				free(newname);
-				 */
+				return (retval);
-				cmd_find_from_session(&cmdq->state.tflag, as);
-				return (cmd_attach_session(cmdq,
-				    args_has(args, 'D'), 0, NULL,
-				    args_has(args, 'E')));
 			}
-			cmdq_error(cmdq, "duplicate session: %s", newname);
+			cmdq_error(item, "duplicate session: %s", newname);
-			return (CMD_RETURN_ERROR);
+			goto fail;
 		}
 	}
 
-	if ((target = args_get(args, 't')) != NULL) {
+	/* 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) {
-			cmdq_error(cmdq, "no such session: %s", target);
+			if (!session_check_name(group)) {
-			goto error;
+				cmdq_error(item, "bad group name: %s", group);
-		}
+				goto fail;
-	} else
+			}
+			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;
@@ -137,15 +152,10 @@ 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')) {
+	if ((tmp = args_get(args, 'c')) != NULL)
-		ft = format_create(cmdq, 0);
+		cwd = format_single(item, tmp, c, NULL, NULL, NULL);
-		format_defaults(ft, c, NULL, NULL, NULL);
-		to_free = cwd = format_expand(ft, args_get(args, 'c'));
-		format_free(ft);
-	} else if (c != NULL && c->session == NULL && c->cwd != NULL)
-		cwd = c->cwd;
 	else
-		cwd = ".";
+		cwd = xstrdup(server_client_get_cwd(c, NULL));
 
 	/*
 	 * If this is a new client, check for nesting and save the termios
@@ -157,10 +167,10 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 	 * over.
 	 */
 	if (!detached && !already_attached && c->tty.fd != -1) {
-		if (server_client_check_nested(cmdq->client)) {
+		if (server_client_check_nested(item->client)) {
-			cmdq_error(cmdq, "sessions should be nested with care, "
+			cmdq_error(item, "sessions should be nested with care, "
 			    "unset $TMUX to force");
-			return (CMD_RETURN_ERROR);
+			goto fail;
 		}
 		if (tcgetattr(c->tty.fd, &tio) != 0)
 			fatal("tcgetattr failed");
@@ -171,101 +181,118 @@ 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, &cause) != 0) {
-			cmdq_error(cmdq, "open terminal failed: %s", cause);
+			cmdq_error(item, "open terminal failed: %s", cause);
 			free(cause);
-			goto error;
+			goto fail;
+		}
+	}
+
+	/* Get default session size. */
+	if (args_has(args, 'x')) {
+		tmp = args_get(args, 'x');
+		if (strcmp(tmp, "-") == 0) {
+			if (c != NULL)
+				dsx = c->tty.sx;
+			else
+				dsx = 80;
+		} else {
+			dsx = strtonum(tmp, 1, USHRT_MAX, &errstr);
+			if (errstr != NULL) {
+				cmdq_error(item, "width %s", errstr);
+				goto fail;
+			}
+		}
+	}
+	if (args_has(args, 'y')) {
+		tmp = args_get(args, 'y');
+		if (strcmp(tmp, "-") == 0) {
+			if (c != NULL)
+				dsy = c->tty.sy;
+			else
+				dsy = 24;
+		} else {
+			dsy = strtonum(tmp, 1, USHRT_MAX, &errstr);
+			if (errstr != NULL) {
+				cmdq_error(item, "height %s", errstr);
+				goto fail;
+			}
 		}
 	}
 
 	/* Find new session size. */
-	if (c != NULL) {
+	if (!detached && !is_control) {
 		sx = c->tty.sx;
 		sy = c->tty.sy;
+		if (sy > 0 && options_get_number(global_s_options, "status"))
+			sy--;
 	} else {
-		sx = 80;
+		tmp = options_get_string(global_s_options, "default-size");
-		sy = 24;
+		if (sscanf(tmp, "%ux%u", &sx, &sy) != 2) {
-	}
+			sx = 80;
-	if (detached && args_has(args, 'x')) {
+			sy = 24;
-		sx = strtonum(args_get(args, 'x'), 1, USHRT_MAX, &errstr);
-		if (errstr != NULL) {
-			cmdq_error(cmdq, "width %s", errstr);
-			goto error;
 		}
+		if (args_has(args, 'x'))
+			sx = dsx;
+		if (args_has(args, 'y'))
+			sy = dsy;
 	}
-	if (detached && args_has(args, 'y')) {
-		sy = strtonum(args_get(args, 'y'), 1, USHRT_MAX, &errstr);
-		if (errstr != NULL) {
-			cmdq_error(cmdq, "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. */
-	argc = -1;
-	argv = NULL;
-	if (!args_has(args, 't') && args->argc != 0) {
-		argc = args->argc;
-		argv = args->argv;
-	} else if (groupwith == NULL) {
-		cmd = options_get_string(global_s_options, "default-command");
-		if (cmd != NULL && *cmd != '\0') {
-			argc = 1;
-			argv = &cmd;
-		} else {
-			argc = 0;
-			argv = NULL;
-		}
-	}
-
-	path = NULL;
-	if (c != NULL && c->session == NULL)
-		envent = environ_find(c->environ, "PATH");
-	else
-		envent = environ_find(global_environ, "PATH");
-	if (envent != NULL)
-		path = envent->value;
-
-	/* Construct the environment. */
-	env = environ_create();
-	if (c != NULL && !args_has(args, 'E')) {
-		update = options_get_string(global_s_options,
-		    "update-environment");
-		environ_update(update, c->environ, env);
-	}
-
 	/* Create the new session. */
-	idx = -1 - options_get_number(global_s_options, "base-index");
+	oo = options_create(global_s_options);
-	s = session_create(newname, argc, argv, path, cwd, env, tiop, idx, sx,
+	if (args_has(args, 'x') || args_has(args, 'y')) {
-	    sy, &cause);
+		if (!args_has(args, 'x'))
-	environ_free(env);
+			dsx = sx;
-	if (s == NULL) {
+		if (!args_has(args, 'y'))
-		cmdq_error(cmdq, "create session failed: %s", cause);
+			dsy = sy;
-		free(cause);
+		options_set_string(oo, "default-size", 0, "%ux%u", dsx, dsy);
-		goto error;
 	}
+	env = environ_create();
+	if (c != NULL && !args_has(args, 'E'))
+		environ_update(global_s_options, c->environ, env);
+	s = session_create(prefix, newname, cwd, env, oo, tiop);
 
-	/* Set the initial window name if one given. */
+	/* Spawn the initial window. */
-	if (argc >= 0 && args_has(args, 'n')) {
+	memset(&sc, 0, sizeof sc);
-		w = s->curw->window;
+	sc.item = item;
-		window_set_name(w, args_get(args, 'n'));
+	sc.s = s;
-		options_set_number(w->options, "automatic-rename", 0);
+
+	sc.name = args_get(args, 'n');
+	sc.argc = args->argc;
+	sc.argv = args->argv;
+
+	sc.idx = -1;
+	sc.cwd = args_get(args, 'c');
+
+	sc.flags = 0;
+
+	if (spawn_window(&sc, &cause) == NULL) {
+		session_destroy(s, 0, __func__);
+		cmdq_error(item, "create window failed: %s", cause);
+		free(cause);
+		goto fail;
 	}
 
 	/*
 	 * 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) {
+	if (group != NULL) {
-		session_group_add(groupwith, s);
+		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_MIN(winlinks, &s->windows)->idx);
 	}
+	notify_session("session-created", s);
 
 	/*
 	 * Set the client to the new session. If a command client exists, it is
@@ -278,9 +305,11 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 		} else if (c->session != NULL)
 			c->last_session = c->session;
 		c->session = s;
-		server_client_set_key_table(c, NULL);
+		if (~item->shared->flags & CMDQ_SHARED_REPEAT)
+			server_client_set_key_table(c, NULL);
+		tty_update_client_offset(c);
 		status_timer_start(c);
-		notify_attached_session_changed(c);
+		notify_client("client-session-changed", c);
 		session_update_activity(s, NULL);
 		gettimeofday(&s->last_attached_time, NULL);
 		server_redraw_client(c);
@@ -299,26 +328,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;
-
+		cp = format_single(item, template, c, s, NULL, NULL);
-		ft = format_create(cmdq, 0);
+		cmdq_print(item, "%s", cp);
-		format_defaults(ft, c, s, NULL, NULL);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}
 
-	if (!detached)
+	if (!detached) {
-		cmdq->client_exit = 0;
+		c->flags |= CLIENT_ATTACHED;
+		cmd_find_from_session(&item->shared->current, s, 0);
+	}
 
-	if (to_free != NULL)
+	cmd_find_from_session(&fs, s, 0);
-		free((void *)to_free);
+	cmdq_insert_hook(s, item, &fs, "after-new-session");
+
+	free(cwd);
+	free(newname);
 	return (CMD_RETURN_NORMAL);
 
-error:
+fail:
-	if (to_free != NULL)
+	free(cwd);
-		free((void *)to_free);
+	free(newname);
 	return (CMD_RETURN_ERROR);
 }

cmd-new-window.c

@@ -32,108 +32,74 @@
 
 #define NEW_WINDOW_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"
 
-enum cmd_retval	cmd_new_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_new_window_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_new_window_entry = {
 	.name = "new-window",
 	.alias = "neww",
 
-	.args = { "ac:dF:kn:Pt:", 0, -1 },
+	.args = { "ac:de:F:kn:Pt:", 0, -1 },
-	.usage = "[-adkP] [-c start-directory] [-F format] [-n window-name] "
+	.usage = "[-adkP] [-c start-directory] [-e environment] [-F format] "
-		 CMD_TARGET_WINDOW_USAGE " [command]",
+		 "[-n window-name] " CMD_TARGET_WINDOW_USAGE " [command]",
 
-	.tflag = CMD_WINDOW_INDEX,
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_WINDOW_INDEX },
 
 	.flags = 0,
 	.exec = cmd_new_window_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct session		*s = cmdq->state.tflag.s;
+	struct cmd_find_state	*current = &item->shared->current;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	struct spawn_context	 sc;
-	struct client		*c = cmdq->state.c;
+	struct client		*c = cmd_find_client(item, NULL, 1);
-	int			 idx = cmdq->state.tflag.idx;
+	struct session		*s = item->target.s;
-	const char		*cmd, *path, *template, *cwd, *to_free;
+	struct winlink		*wl = item->target.wl;
-	char		       **argv, *cause, *cp;
+	int			 idx = item->target.idx;
-	int			 argc, detached;
+	struct winlink		*new_wl;
-	struct format_tree	*ft;
+	char			*cause = NULL, *cp;
-	struct environ_entry	*envent;
+	const char		*template, *add;
+	struct cmd_find_state	 fs;
+	struct args_value	*value;
 
-	if (args_has(args, 'a')) {
+	if (args_has(args, 'a') && (idx = winlink_shuffle_up(s, wl)) == -1) {
-		if ((idx = winlink_shuffle_up(s, wl)) == -1) {
+		cmdq_error(item, "couldn't get a window index");
-			cmdq_error(cmdq, "no free window indexes");
+		return (CMD_RETURN_ERROR);
-			return (CMD_RETURN_ERROR);
-		}
-	}
-	detached = args_has(args, 'd');
-
-	if (args->argc == 0) {
-		cmd = options_get_string(s->options, "default-command");
-		if (cmd != NULL && *cmd != '\0') {
-			argc = 1;
-			argv = (char **)&cmd;
-		} else {
-			argc = 0;
-			argv = NULL;
-		}
-	} else {
-		argc = args->argc;
-		argv = args->argv;
 	}
 
-	path = NULL;
+	memset(&sc, 0, sizeof sc);
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
+	sc.item = item;
-		envent = environ_find(cmdq->client->environ, "PATH");
+	sc.s = s;
-	else
-		envent = environ_find(s->environ, "PATH");
-	if (envent != NULL)
-		path = envent->value;
 
-	to_free = NULL;
+	sc.name = args_get(args, 'n');
-	if (args_has(args, 'c')) {
+	sc.argc = args->argc;
-		ft = format_create(cmdq, 0);
+	sc.argv = args->argv;
-		format_defaults(ft, c, s, NULL, NULL);
+	sc.environ = environ_create();
-		cwd = to_free = format_expand(ft, args_get(args, 'c'));
-		format_free(ft);
-	} else if (cmdq->client != NULL && cmdq->client->session == NULL)
-		cwd = cmdq->client->cwd;
-	else
-		cwd = s->cwd;
 
-	wl = NULL;
+	add = args_first_value(args, 'e', &value);
-	if (idx != -1)
+	while (add != NULL) {
-		wl = winlink_find_by_index(&s->windows, idx);
+		environ_put(sc.environ, add);
-	if (wl != NULL && args_has(args, 'k')) {
+		add = args_next_value(&value);
-		/*
-		 * Can't use session_detach as it will destroy session if this
-		 * makes it empty.
-		 */
-		notify_window_unlinked(s, wl->window);
-		wl->flags &= ~WINLINK_ALERTFLAGS;
-		winlink_stack_remove(&s->lastw, wl);
-		winlink_remove(&s->windows, wl);
-
-		/* Force select/redraw if current. */
-		if (wl == s->curw) {
-			detached = 0;
-			s->curw = NULL;
-		}
 	}
 
-	if (idx == -1)
+	sc.idx = idx;
-		idx = -1 - options_get_number(s->options, "base-index");
+	sc.cwd = args_get(args, 'c');
-	wl = session_new(s, args_get(args, 'n'), argc, argv, path, cwd, idx,
+
-		&cause);
+	sc.flags = 0;
-	if (wl == NULL) {
+	if (args_has(args, 'd'))
-		cmdq_error(cmdq, "create window failed: %s", cause);
+		sc.flags |= SPAWN_DETACHED;
+	if (args_has(args, 'k'))
+		sc.flags |= SPAWN_KILL;
+
+	if ((new_wl = spawn_window(&sc, &cause)) == NULL) {
+		cmdq_error(item, "create window failed: %s", cause);
 		free(cause);
-		goto error;
+		return (CMD_RETURN_ERROR);
 	}
-	if (!detached) {
+	if (!args_has(args, 'd') || new_wl == s->curw) {
-		session_select(s, wl->idx);
+		cmd_find_from_winlink(current, new_wl, 0);
 		server_redraw_session_group(s);
 	} else
 		server_status_session_group(s);
@@ -141,23 +107,14 @@ 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;
-
+		cp = format_single(item, template, c, s, new_wl, NULL);
-		ft = format_create(cmdq, 0);
+		cmdq_print(item, "%s", cp);
-		format_defaults(ft, c, s, wl, NULL);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}
 
-	if (to_free != NULL)
+	cmd_find_from_winlink(&fs, new_wl, 0);
-		free((void *)to_free);
+	cmdq_insert_hook(s, item, &fs, "after-new-window");
-	return (CMD_RETURN_NORMAL);
 
-error:
+	environ_free(sc.environ);
-	if (to_free != NULL)
+	return (CMD_RETURN_NORMAL);
-		free((void *)to_free);
-	return (CMD_RETURN_ERROR);
 }

cmd-paste-buffer.c

@@ -27,10 +27,7 @@
  * Paste paste buffer if present.
  */
 
-enum cmd_retval	 cmd_paste_buffer_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_paste_buffer_exec(struct cmd *, struct cmdq_item *);
-
-void	cmd_paste_buffer_filter(struct window_pane *,
-	    const char *, size_t, const char *, int);
 
 const struct cmd_entry cmd_paste_buffer_entry = {
 	.name = "paste-buffer",
@@ -40,17 +37,17 @@ const struct cmd_entry cmd_paste_buffer_entry = {
 	.usage = "[-dpr] [-s separator] " CMD_BUFFER_USAGE " "
 		 CMD_TARGET_PANE_USAGE,
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_paste_buffer_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_paste_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_paste_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
+	struct window_pane	*wp = item->target.wp;
 	struct paste_buffer	*pb;
 	const char		*sepstr, *bufname, *bufdata, *bufend, *line;
 	size_t			 seplen, bufsize;
@@ -65,7 +62,7 @@ cmd_paste_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 	else {
 		pb = paste_get_name(bufname);
 		if (pb == NULL) {
-			cmdq_error(cmdq, "no buffer %s", bufname);
+			cmdq_error(item, "no buffer %s", bufname);
 			return (CMD_RETURN_ERROR);
 		}
 	}

cmd-pipe-pane.c

@@ -21,6 +21,7 @@
 
 #include <errno.h>
 #include <fcntl.h>
+#include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
@@ -32,34 +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 = {
 	.name = "pipe-pane",
 	.alias = "pipep",
 
-	.args = { "ot:", 0, 1 },
+	.args = { "IOot:", 0, 1 },
-	.usage = "[-o] " CMD_TARGET_PANE_USAGE " [command]",
+	.usage = "[-IOo] " CMD_TARGET_PANE_USAGE " [command]",
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_pipe_pane_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->state.c;
+	struct client		*c = cmd_find_client(item, NULL, 1);
-	struct window_pane	*wp = cmdq->state.tflag.wp;
+	struct window_pane	*wp = item->target.wp;
-	struct session		*s = cmdq->state.tflag.s;
+	struct session		*s = item->target.s;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	struct winlink		*wl = item->target.wl;
 	char			*cmd;
-	int			 old_fd, pipe_fd[2], null_fd;
+	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;
@@ -67,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. */
@@ -82,72 +91,135 @@ 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(cmdq, 0);
+	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));
+	cmd = format_expand_time(ft, args->argv[0]);
 	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)
+		if (out) {
-			_exit(1);
+			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);
 
 		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);
+		if (wp->fd != -1)
-
+			wp->pipe_off = EVBUFFER_LENGTH(wp->event->input);
-		wp->pipe_event = bufferevent_new(wp->pipe_fd,
+		else
-		    NULL, NULL, cmd_pipe_pane_error_callback, wp);
+			wp->pipe_off = 0;
-		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 (wp->pipe_event == NULL)
+			fatalx("out of memory");
+		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
+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

@@ -25,54 +25,475 @@
 
 #include "tmux.h"
 
-static enum cmd_retval	cmdq_continue_one(struct cmd_q *);
+/* Global command queue. */
+static struct cmdq_list global_queue = TAILQ_HEAD_INITIALIZER(global_queue);
 
-/* Create new command queue. */
+/* Get command queue name. */
-struct cmd_q *
+static const char *
-cmdq_new(struct client *c)
+cmdq_name(struct client *c)
 {
-	struct cmd_q	*cmdq;
+	static char	s[256];
 
-	cmdq = xcalloc(1, sizeof *cmdq);
+	if (c == NULL)
-	cmdq->references = 1;
+		return ("<global>");
-	cmdq->flags = 0;
+	if (c->name != NULL)
-
+		xsnprintf(s, sizeof s, "<%s>", c->name);
-	cmdq->client = c;
+	else
-	cmdq->client_exit = -1;
+		xsnprintf(s, sizeof s, "<%p>", c);
-
+	return (s);
-	TAILQ_INIT(&cmdq->queue);
-	cmdq->item = NULL;
-	cmdq->cmd = NULL;
-
-	cmd_find_clear_state(&cmdq->current, NULL, 0);
-	cmdq->parent = NULL;
-
-	return (cmdq);
 }
 
-/* Free command queue */
+/* Get command queue from client. */
-int
+static struct cmdq_list *
-cmdq_free(struct cmd_q *cmdq)
+cmdq_get(struct client *c)
 {
-	if (--cmdq->references != 0) {
+	if (c == NULL)
-		if (cmdq->flags & CMD_Q_DEAD)
+		return (&global_queue);
-			return (1);
+	return (&c->queue);
+}
+
+/* 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);
+		log_debug("%s %s: %s", __func__, cmdq_name(c), item->name);
+
+		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 = after->next;
+		after->next = item;
+
+		if (c != NULL)
+			c->references++;
+		item->client = c;
+
+		item->queue = queue;
+		TAILQ_INSERT_AFTER(queue, after, item, entry);
+		log_debug("%s %s: %s after %s", __func__, cmdq_name(c),
+		    item->name, after->name);
+
+		after = item;
+		item = next;
+	} while (item != NULL);
+}
+
+
+/* Insert a hook. */
+void
+cmdq_insert_hook(struct session *s, struct cmdq_item *item,
+    struct cmd_find_state *fs, const char *fmt, ...)
+{
+	struct options			*oo;
+	va_list				 ap;
+	char				*name;
+	struct cmdq_item		*new_item;
+	struct options_entry		*o;
+	struct options_array_item	*a;
+	struct cmd_list			*cmdlist;
+
+	if (item->flags & CMDQ_NOHOOKS)
+		return;
+	if (s == NULL)
+		oo = global_s_options;
+	else
+		oo = s->options;
+
+	va_start(ap, fmt);
+	xvasprintf(&name, fmt, ap);
+	va_end(ap);
+
+	o = options_get(oo, name);
+	if (o == NULL) {
+		free(name);
+		return;
+	}
+	log_debug("running hook %s (parent %p)", name, item);
+
+	a = options_array_first(o);
+	while (a != NULL) {
+		cmdlist = options_array_item_value(a)->cmdlist;
+		if (cmdlist == NULL) {
+			a = options_array_next(a);
+			continue;
+		}
+
+		new_item = cmdq_get_command(cmdlist, fs, NULL, CMDQ_NOHOOKS);
+		cmdq_format(new_item, "hook", "%s", name);
+		if (item != NULL) {
+			cmdq_insert_after(item, new_item);
+			item = new_item;
+		} else
+			cmdq_append(NULL, new_item);
+
+		a = options_array_next(a);
+	}
+
+	free(name);
+}
+
+/* Continue processing command queue. */
+void
+cmdq_continue(struct cmdq_item *item)
+{
+	item->flags &= ~CMDQ_WAITING;
+}
+
+/* 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->cmdlist != NULL)
+		cmd_list_free(item->cmdlist);
+
+	TAILQ_REMOVE(item->queue, item, entry);
+
+	free(item->name);
+	free(item);
+}
+
+/* Remove all subsequent items that match this item's group. */
+static void
+cmdq_remove_group(struct cmdq_item *item)
+{
+	struct cmdq_item	*this, *next;
+
+	if (item->group == 0)
+		return;
+	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;
+	struct cmdq_shared	*shared = NULL;
+	u_int			 group = 0;
+
+	TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
+		if (cmd->group != group) {
+			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);
+			group = cmd->group;
+		}
+
+		item = xcalloc(1, sizeof *item);
+		xasprintf(&item->name, "[%s/%p]", cmd->entry->name, item);
+		item->type = CMDQ_COMMAND;
+
+		item->group = cmd->group;
+		item->flags = flags;
+
+		item->shared = shared;
+		item->cmdlist = cmdlist;
+		item->cmd = cmd;
+
+		log_debug("%s: %s group %u", __func__, item->name, item->group);
+
+		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;
+	const char		*name = cmdq_name(c);
+	struct cmdq_shared	*shared = item->shared;
+	struct cmd		*cmd = item->cmd;
+	const struct cmd_entry	*entry = cmd->entry;
+	enum cmd_retval		 retval;
+	struct cmd_find_state	*fsp, fs;
+	int			 flags;
+	char			*tmp;
+
+	if (log_get_level() > 1) {
+		tmp = cmd_print(cmd);
+		log_debug("%s %s: (%u) %s", __func__, name, item->group, tmp);
+		free(tmp);
+	}
+
+	flags = !!(shared->flags & CMDQ_SHARED_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;
+		cmdq_insert_hook(fsp->s, 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;
+
+	item = xcalloc(1, sizeof *item);
+	xasprintf(&item->name, "[%s/%p]", name, item);
+	item->type = CMDQ_CALLBACK;
+
+	item->group = 0;
+	item->flags = 0;
+
+	item->cb = cb;
+	item->data = data;
+
+	return (item);
+}
+
+/* Generic error callback. */
+static enum cmd_retval
+cmdq_error_callback(struct cmdq_item *item, void *data)
+{
+	char	*error = data;
+
+	cmdq_error(item, "%s", error);
+	free(error);
+
+	return (CMD_RETURN_NORMAL);
+}
+
+/* Get an error callback for the command queue. */
+struct cmdq_item *
+cmdq_get_error(const char *error)
+{
+	return (cmdq_get_callback(cmdq_error_callback, xstrdup(error)));
+}
+
+/* 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);
 	}
 
-	cmdq_flush(cmdq);
+	log_debug("%s %s: enter", __func__, name);
-	free(cmdq);
+	for (;;) {
-	return (1);
+		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
-cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
+cmdq_print(struct cmdq_item *item, const char *fmt, ...)
 {
-	struct client	*c = cmdq->client;
+	struct client			*c = item->client;
-	struct window	*w;
+	struct window_pane		*wp;
-	va_list		 ap;
+	struct window_mode_entry	*wme;
-	char		*tmp, *msg;
+	va_list				 ap;
+	char				*tmp, *msg;
 
 	va_start(ap, fmt);
 
@@ -90,13 +511,11 @@ cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
 		evbuffer_add(c->stdout_data, "\n", 1);
 		server_client_push_stdout(c);
 	} else {
-		w = c->session->curw->window;
+		wp = c->session->curw->window->active;
-		if (w->active->mode != &window_copy_mode) {
+		wme = TAILQ_FIRST(&wp->modes);
-			window_pane_reset_mode(w->active);
+		if (wme == NULL || wme->mode != &window_view_mode)
-			window_pane_set_mode(w->active, &window_copy_mode);
+			window_pane_set_mode(wp, &window_view_mode, NULL, NULL);
-			window_copy_init_for_output(w->active);
+		window_copy_vadd(wp, fmt, ap);
-		}
-		window_copy_vadd(w->active, fmt, ap);
 	}
 
 	va_end(ap);
@@ -104,10 +523,10 @@ cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
 
 /* Show error from command. */
 void
-cmdq_error(struct cmd_q *cmdq, const char *fmt, ...)
+cmdq_error(struct cmdq_item *item, const char *fmt, ...)
 {
-	struct client	*c = cmdq->client;
+	struct client	*c = item->client;
-	struct cmd	*cmd = cmdq->cmd;
+	struct cmd	*cmd = item->cmd;
 	va_list		 ap;
 	char		*msg;
 	size_t		 msglen;
@@ -117,6 +536,8 @@ cmdq_error(struct cmd_q *cmdq, const char *fmt, ...)
 	msglen = xvasprintf(&msg, fmt, ap);
 	va_end(ap);
 
+	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)) {
@@ -137,198 +558,3 @@ cmdq_error(struct cmd_q *cmdq, const char *fmt, ...)
 
 	free(msg);
 }
-
-/* Print a guard line. */
-void
-cmdq_guard(struct cmd_q *cmdq, const char *guard, int flags)
-{
-	struct client	*c = cmdq->client;
-
-	if (c == NULL || !(c->flags & CLIENT_CONTROL))
-		return;
-
-	evbuffer_add_printf(c->stdout_data, "%%%s %ld %u %d\n", guard,
-	    (long) cmdq->time, cmdq->number, flags);
-	server_client_push_stdout(c);
-}
-
-/* Add command list to queue and begin processing if needed. */
-void
-cmdq_run(struct cmd_q *cmdq, struct cmd_list *cmdlist, struct mouse_event *m)
-{
-	cmdq_append(cmdq, cmdlist, m);
-
-	if (cmdq->item == NULL) {
-		cmdq->cmd = NULL;
-		cmdq_continue(cmdq);
-	}
-}
-
-/* Add command list to queue. */
-void
-cmdq_append(struct cmd_q *cmdq, struct cmd_list *cmdlist, struct mouse_event *m)
-{
-	struct cmd_q_item	*item;
-
-	item = xcalloc(1, sizeof *item);
-	item->cmdlist = cmdlist;
-	TAILQ_INSERT_TAIL(&cmdq->queue, item, qentry);
-	cmdlist->references++;
-
-	if (m != NULL)
-		memcpy(&item->mouse, m, sizeof item->mouse);
-	else
-		item->mouse.valid = 0;
-}
-
-/* Process one command. */
-static enum cmd_retval
-cmdq_continue_one(struct cmd_q *cmdq)
-{
-	struct cmd	*cmd = cmdq->cmd;
-	const char	*name = cmd->entry->name;
-	struct session	*s;
-	struct hooks	*hooks;
-	enum cmd_retval	 retval;
-	char		*tmp;
-	int		 flags = !!(cmd->flags & CMD_CONTROL);
-
-	tmp = cmd_print(cmd);
-	log_debug("cmdq %p: %s", cmdq, tmp);
-	free(tmp);
-
-	cmdq->time = time(NULL);
-	cmdq->number++;
-
-	if (~cmdq->flags & CMD_Q_REENTRY)
-		cmdq_guard(cmdq, "begin", flags);
-
-	if (cmd_prepare_state(cmd, cmdq, cmdq->parent) != 0)
-		goto error;
-
-	if (~cmdq->flags & CMD_Q_NOHOOKS) {
-		s = NULL;
-		if (cmdq->state.tflag.s != NULL)
-			s = cmdq->state.tflag.s;
-		else if (cmdq->state.sflag.s != NULL)
-			s = cmdq->state.sflag.s;
-		else if (cmdq->state.c != NULL)
-			s = cmdq->state.c->session;
-		if (s != NULL)
-			hooks = s->hooks;
-		else
-			hooks = global_hooks;
-
-		if (~cmdq->flags & CMD_Q_REENTRY) {
-			cmdq->flags |= CMD_Q_REENTRY;
-			if (hooks_wait(hooks, cmdq, NULL,
-			    "before-%s", name) == 0)
-				return (CMD_RETURN_WAIT);
-			if (cmd_prepare_state(cmd, cmdq, cmdq->parent) != 0)
-				goto error;
-		}
-	} else
-		hooks = NULL;
-	cmdq->flags &= ~CMD_Q_REENTRY;
-
-	retval = cmd->entry->exec(cmd, cmdq);
-	if (retval == CMD_RETURN_ERROR)
-		goto error;
-
-	if (hooks != NULL && hooks_wait(hooks, cmdq, NULL,
-	    "after-%s", name) == 0)
-		retval = CMD_RETURN_WAIT;
-	cmdq_guard(cmdq, "end", flags);
-
-	return (retval);
-
-error:
-	cmdq_guard(cmdq, "error", flags);
-	cmdq->flags &= ~CMD_Q_REENTRY;
-	return (CMD_RETURN_ERROR);
-}
-
-/* Continue processing command queue. Returns 1 if finishes empty. */
-int
-cmdq_continue(struct cmd_q *cmdq)
-{
-	struct client		*c = cmdq->client;
-	struct cmd_q_item	*next;
-	enum cmd_retval		 retval;
-	int			 empty;
-
-	cmdq->references++;
-	notify_disable();
-
-	log_debug("continuing cmdq %p: flags %#x, client %p", cmdq, cmdq->flags,
-	    c);
-
-	empty = TAILQ_EMPTY(&cmdq->queue);
-	if (empty)
-		goto empty;
-
-	/*
-	 * If the command isn't in the middle of running hooks (due to
-	 * CMD_RETURN_WAIT), move onto the next command; otherwise, leave the
-	 * state of the queue as it is.
-	 */
-	if (~cmdq->flags & CMD_Q_REENTRY) {
-		if (cmdq->item == NULL) {
-			cmdq->item = TAILQ_FIRST(&cmdq->queue);
-			cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
-		} else
-			cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
-	}
-
-	do {
-		while (cmdq->cmd != NULL) {
-			retval = cmdq_continue_one(cmdq);
-			if (retval == CMD_RETURN_ERROR)
-				break;
-			if (retval == CMD_RETURN_WAIT)
-				goto out;
-			if (retval == CMD_RETURN_STOP) {
-				cmdq_flush(cmdq);
-				goto empty;
-			}
-			cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
-		}
-		next = TAILQ_NEXT(cmdq->item, qentry);
-
-		TAILQ_REMOVE(&cmdq->queue, cmdq->item, qentry);
-		cmd_list_free(cmdq->item->cmdlist);
-		free(cmdq->item);
-
-		cmdq->item = next;
-		if (cmdq->item != NULL)
-			cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
-	} while (cmdq->item != NULL);
-
-empty:
-	if (cmdq->client_exit > 0)
-		cmdq->client->flags |= CLIENT_EXIT;
-	if (cmdq->emptyfn != NULL)
-		cmdq->emptyfn(cmdq);
-	empty = 1;
-
-out:
-	notify_enable();
-	cmdq_free(cmdq);
-
-	return (empty);
-}
-
-/* Flush command queue. */
-void
-cmdq_flush(struct cmd_q *cmdq)
-{
-	struct cmd_q_item	*item, *item1;
-
-	TAILQ_FOREACH_SAFE(item, &cmdq->queue, qentry, item1) {
-		TAILQ_REMOVE(&cmdq->queue, item, qentry);
-		cmd_list_free(item->cmdlist);
-		free(item);
-	}
-	cmdq->item = NULL;
-}
-

cmd-refresh-client.c

@@ -18,62 +18,144 @@
 
 #include <sys/types.h>
 
+#include <stdlib.h>
+#include <string.h>
+
 #include "tmux.h"
 
 /*
  * 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 = {
 	.name = "refresh-client",
 	.alias = "refresh",
 
-	.args = { "C:St:", 0, 0 },
+	.args = { "cC:DF:lLRSt:U", 0, 1 },
-	.usage = "[-S] [-C size] " CMD_TARGET_CLIENT_USAGE,
+	.usage = "[-cDlLRSU] [-C XxY] [-F flags] " CMD_TARGET_CLIENT_USAGE
+		" [adjustment]",
 
-	.tflag = CMD_CLIENT,
+	.flags = CMD_AFTERHOOK,
-
-	.flags = 0,
 	.exec = cmd_refresh_client_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_refresh_client_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_refresh_client_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct client	*c = cmdq->state.c;
+	struct client	*c;
-	const char	*size;
+	struct tty	*tty;
-	u_int		 w, h;
+	struct window	*w;
+	const char	*size, *errstr;
+	char		*copy, *next, *s;
+	u_int		 x, y, adjust;
 
-	if (args_has(args, 'C')) {
+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
-		if ((size = args_get(args, 'C')) == NULL) {
+		return (CMD_RETURN_ERROR);
-			cmdq_error(cmdq, "missing size");
+	tty = &c->tty;
-			return (CMD_RETURN_ERROR);
+
+	if (args_has(args, 'c') ||
+	    args_has(args, 'L') ||
+	    args_has(args, 'R') ||
+	    args_has(args, 'U') ||
+	    args_has(args, 'D'))
+	{
+		if (args->argc == 0)
+			adjust = 1;
+		else {
+			adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr);
+			if (errstr != NULL) {
+				cmdq_error(item, "adjustment %s", errstr);
+				return (CMD_RETURN_ERROR);
+			}
 		}
-		if (sscanf(size, "%u,%u", &w, &h) != 2) {
+
-			cmdq_error(cmdq, "bad size argument");
+		if (args_has(args, 'c'))
-			return (CMD_RETURN_ERROR);
+		    c->pan_window = NULL;
+		else {
+			w = c->session->curw->window;
+			if (c->pan_window != w) {
+				c->pan_window = w;
+				c->pan_ox = tty->oox;
+				c->pan_oy = tty->ooy;
+			}
+			if (args_has(args, 'L')) {
+				if (c->pan_ox > adjust)
+					c->pan_ox -= adjust;
+				else
+					c->pan_ox = 0;
+			} else if (args_has(args, 'R')) {
+				c->pan_ox += adjust;
+				if (c->pan_ox > w->sx - tty->osx)
+					c->pan_ox = w->sx - tty->osx;
+			} else if (args_has(args, 'U')) {
+				if (c->pan_oy > adjust)
+					c->pan_oy -= adjust;
+				else
+					c->pan_oy = 0;
+			} else if (args_has(args, 'D')) {
+				c->pan_oy += adjust;
+				if (c->pan_oy > w->sy - tty->osy)
+					c->pan_oy = w->sy - tty->osy;
+			}
 		}
-		if (w < PANE_MINIMUM || w > 5000 ||
+		tty_update_client_offset(c);
-		    h < PANE_MINIMUM || h > 5000) {
+		server_redraw_client(c);
-			cmdq_error(cmdq, "size too small or too big");
+		return (CMD_RETURN_NORMAL);
-			return (CMD_RETURN_ERROR);
+	}
-		}
+
-		if (!(c->flags & CLIENT_CONTROL)) {
+	if (args_has(args, 'l')) {
-			cmdq_error(cmdq, "not a control client");
+		if (c->session != NULL)
-			return (CMD_RETURN_ERROR);
+			tty_putcode_ptr2(&c->tty, TTYC_MS, "", "?");
-		}
+		return (CMD_RETURN_NORMAL);
-		if (tty_set_size(&c->tty, w, h))
+	}
+
+	if (args_has(args, 'C') || args_has(args, 'F')) {
+		if (args_has(args, 'C')) {
+			if (!(c->flags & CLIENT_CONTROL)) {
+				cmdq_error(item, "not a control client");
+				return (CMD_RETURN_ERROR);
+			}
+			size = args_get(args, 'C');
+			if (sscanf(size, "%u,%u", &x, &y) != 2 &&
+			    sscanf(size, "%ux%u", &x, &y) != 2) {
+				cmdq_error(item, "bad size argument");
+				return (CMD_RETURN_ERROR);
+			}
+			if (x < WINDOW_MINIMUM || x > WINDOW_MAXIMUM ||
+			    y < WINDOW_MINIMUM || y > WINDOW_MAXIMUM) {
+				cmdq_error(item, "size too small or too big");
+				return (CMD_RETURN_ERROR);
+			}
+			tty_set_size(&c->tty, x, y);
+			c->flags |= CLIENT_SIZECHANGED;
 			recalculate_sizes();
-	} else if (args_has(args, 'S')) {
+		}
+		if (args_has(args, 'F')) {
+			if (!(c->flags & CLIENT_CONTROL)) {
+				cmdq_error(item, "not a control client");
+				return (CMD_RETURN_ERROR);
+			}
+			s = copy = xstrdup(args_get(args, 'F'));
+			while ((next = strsep(&s, ",")) != NULL) {
+				/* Unknown flags are ignored. */
+				if (strcmp(next, "no-output") == 0)
+					c->flags |= CLIENT_CONTROL_NOOUTPUT;
+			}
+			free(copy);
+		}
+		return (CMD_RETURN_NORMAL);
+	}
+
+	if (args_has(args, 'S')) {
 		c->flags |= CLIENT_STATUSFORCE;
 		server_status_client(c);
 	} else {
 		c->flags |= CLIENT_STATUSFORCE;
 		server_redraw_client(c);
 	}
-
 	return (CMD_RETURN_NORMAL);
 }

cmd-rename-session.c

@@ -19,6 +19,7 @@
 #include <sys/types.h>
 
 #include <stdlib.h>
+#include <string.h>
 
 #include "tmux.h"
 
@@ -26,7 +27,8 @@
  * 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 = {
 	.name = "rename-session",
@@ -35,36 +37,44 @@ const struct cmd_entry cmd_rename_session_entry = {
 	.args = { "t:", 1, 1 },
 	.usage = CMD_TARGET_SESSION_USAGE " new-name",
 
-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_rename_session_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_rename_session_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_rename_session_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args		*args = self->args;
-	struct session	*s = cmdq->state.tflag.s;
+	struct client		*c = cmd_find_client(item, NULL, 1);
-	const char	*newname;
+	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);
 	}
 
 	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

@@ -26,7 +26,8 @@
  * 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 = {
 	.name = "rename-window",
@@ -35,22 +36,27 @@ const struct cmd_entry cmd_rename_window_entry = {
 	.args = { "t:", 1, 1 },
 	.usage = CMD_TARGET_WINDOW_USAGE " new-name",
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_rename_window_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_rename_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_rename_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct winlink	*wl = cmdq->state.tflag.wl;
+	struct client	*c = cmd_find_client(item, NULL, 1);
+	struct session	*s = item->target.s;
+	struct winlink	*wl = item->target.wl;
+	char		*newname;
 
-	window_set_name(wl->window, args->argv[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

@@ -26,9 +26,10 @@
  * Increase or decrease pane size.
  */
 
-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 *);
 
-void	cmd_resize_pane_mouse_update(struct client *, struct mouse_event *);
+static void	cmd_resize_pane_mouse_update(struct client *,
+		    struct mouse_event *);
 
 const struct cmd_entry cmd_resize_pane_entry = {
 	.name = "resize-pane",
@@ -38,33 +39,34 @@ const struct cmd_entry cmd_resize_pane_entry = {
 	.usage = "[-DLMRUZ] [-x width] [-y height] " CMD_TARGET_PANE_USAGE " "
 		 "[adjustment]",
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_resize_pane_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_resize_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
+	struct cmdq_shared	*shared = item->shared;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	struct window_pane	*wp = item->target.wp;
+	struct winlink		*wl = item->target.wl;
 	struct window		*w = wl->window;
-	struct client		*c = cmdq->client;
+	struct client		*c = item->client;
-	struct session		*s = cmdq->state.tflag.s;
+	struct session		*s = item->target.s;
 	const char	       	*errstr;
 	char			*cause;
 	u_int			 adjust;
 	int			 x, y;
 
 	if (args_has(args, 'M')) {
-		if (cmd_mouse_window(&cmdq->item->mouse, &s) == NULL)
+		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, &cmdq->item->mouse);
+		cmd_resize_pane_mouse_update(c, &shared->mouse);
 		return (CMD_RETURN_NORMAL);
 	}
 
@@ -84,88 +86,105 @@ 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);
 		}
 	}
 
-	if (args_has(self->args, 'x')) {
+	if (args_has(args, 'x')) {
-		x = args_strtonum(self->args, 'x', PANE_MINIMUM, INT_MAX,
+		x = args_strtonum(args, 'x', PANE_MINIMUM, INT_MAX, &cause);
-		    &cause);
 		if (cause != NULL) {
-			cmdq_error(cmdq, "width %s", cause);
+			cmdq_error(item, "width %s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
 		layout_resize_pane_to(wp, LAYOUT_LEFTRIGHT, x);
 	}
-	if (args_has(self->args, 'y')) {
+	if (args_has(args, 'y')) {
-		y = args_strtonum(self->args, 'y', PANE_MINIMUM, INT_MAX,
+		y = args_strtonum(args, 'y', PANE_MINIMUM, INT_MAX, &cause);
-		    &cause);
 		if (cause != NULL) {
-			cmdq_error(cmdq, "height %s", cause);
+			cmdq_error(item, "height %s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
 		layout_resize_pane_to(wp, LAYOUT_TOPBOTTOM, y);
 	}
 
-	if (args_has(self->args, 'L'))
+	if (args_has(args, 'L'))
-		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, -adjust);
+		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, -adjust, 1);
-	else if (args_has(self->args, 'R'))
+	else if (args_has(args, 'R'))
-		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, adjust);
+		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, adjust, 1);
-	else if (args_has(self->args, 'U'))
+	else if (args_has(args, 'U'))
-		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, -adjust);
+		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, -adjust, 1);
-	else if (args_has(self->args, 'D'))
+	else if (args_has(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);
 }
 
-void
+static void
 cmd_resize_pane_mouse_update(struct client *c, struct mouse_event *m)
 {
 	struct winlink		*wl;
-	struct window_pane	*wp;
+	struct window		*w;
-	int			 found;
+	u_int			 y, ly, x, lx;
-	u_int			 y, ly;
+	static const int         offsets[][2] = {
+	    { 0, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 },
+	};
+	struct layout_cell	*cells[nitems(offsets)], *lc;
+	u_int			 ncells = 0, i, j, resizes = 0;
+	enum layout_type	 type;
 
 	wl = cmd_mouse_window(m, NULL);
 	if (wl == NULL) {
 		c->tty.mouse_drag_update = NULL;
 		return;
 	}
+	w = wl->window;
 
-	y = m->y;
+	y = m->y + m->oy; x = m->x + m->ox;
-	if (m->statusat == 0 && y > 0)
+	if (m->statusat == 0 && y >= m->statuslines)
-		y--;
+		y -= m->statuslines;
 	else if (m->statusat > 0 && y >= (u_int)m->statusat)
 		y = m->statusat - 1;
-	ly = m->ly;
+	ly = m->ly + m->oy; lx = m->lx + m->ox;
-	if (m->statusat == 0 && ly > 0)
+	if (m->statusat == 0 && ly >= m->statuslines)
-		ly--;
+		ly -= m->statuslines;
 	else if (m->statusat > 0 && ly >= (u_int)m->statusat)
 		ly = m->statusat - 1;
 
-	found = 0;
+	for (i = 0; i < nitems(cells); i++) {
-	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
+		lc = layout_search_by_border(w->layout_root, lx + offsets[i][0],
-		if (!window_pane_visible(wp))
+		    ly + offsets[i][1]);
+		if (lc == NULL)
 			continue;
 
-		if (wp->xoff + wp->sx == m->lx &&
+		for (j = 0; j < ncells; j++) {
-		    wp->yoff <= 1 + ly && wp->yoff + wp->sy >= ly) {
+			if (cells[j] == lc) {
-			layout_resize_pane(wp, LAYOUT_LEFTRIGHT, m->x - m->lx);
+				lc = NULL;
-			found = 1;
+				break;
+			}
 		}
-		if (wp->yoff + wp->sy == ly &&
+		if (lc == NULL)
-		    wp->xoff <= 1 + m->lx && wp->xoff + wp->sx >= m->lx) {
+			continue;
-			layout_resize_pane(wp, LAYOUT_TOPBOTTOM, y - ly);
+
-			found = 1;
+		cells[ncells] = lc;
+		ncells++;
+	}
+	if (ncells == 0)
+		return;
+
+	for (i = 0; i < ncells; i++) {
+		type = cells[i]->parent->type;
+		if (y != ly && type == LAYOUT_TOPBOTTOM) {
+			layout_resize_layout(w, cells[i], type, y - ly, 0);
+			resizes++;
+		} else if (x != lx && type == LAYOUT_LEFTRIGHT) {
+			layout_resize_layout(w, cells[i], type, x - lx, 0);
+			resizes++;
 		}
 	}
-	if (found)
+	if (resizes != 0)
-		server_redraw_window(wl->window);
+		server_redraw_window(w);
-	else
-		c->tty.mouse_drag_update = NULL;
 }

cmd-resize-window.c

@@ -0,0 +1,109 @@
+/* $OpenBSD$ */
+
+/*
+ * Copyright (c) 2018 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 <stdlib.h>
+
+#include "tmux.h"
+
+/*
+ * Increase or decrease window size.
+ */
+
+static enum cmd_retval	cmd_resize_window_exec(struct cmd *,
+			    struct cmdq_item *);
+
+const struct cmd_entry cmd_resize_window_entry = {
+	.name = "resize-window",
+	.alias = "resizew",
+
+	.args = { "aADLRt:Ux:y:", 0, 1 },
+	.usage = "[-aADLRU] [-x width] [-y height] " CMD_TARGET_WINDOW_USAGE " "
+		 "[adjustment]",
+
+	.target = { 't', CMD_FIND_WINDOW, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_resize_window_exec
+};
+
+static enum cmd_retval
+cmd_resize_window_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		*args = self->args;
+	struct winlink		*wl = item->target.wl;
+	struct window		*w = wl->window;
+	struct session		*s = item->target.s;
+	const char	       	*errstr;
+	char			*cause;
+	u_int			 adjust, sx, sy;
+
+	if (args->argc == 0)
+		adjust = 1;
+	else {
+		adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr);
+		if (errstr != NULL) {
+			cmdq_error(item, "adjustment %s", errstr);
+			return (CMD_RETURN_ERROR);
+		}
+	}
+
+	sx = w->sx;
+	sy = w->sy;
+
+	if (args_has(args, 'x')) {
+		sx = args_strtonum(args, 'x', WINDOW_MINIMUM, WINDOW_MAXIMUM,
+		    &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "width %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+	}
+	if (args_has(args, 'y')) {
+		sy = args_strtonum(args, 'y', WINDOW_MINIMUM, WINDOW_MAXIMUM,
+		    &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "height %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+	}
+
+	if (args_has(args, 'L')) {
+		if (sx >= adjust)
+			sx -= adjust;
+	} else if (args_has(args, 'R'))
+		sx += adjust;
+	else if (args_has(args, 'U')) {
+		if (sy >= adjust)
+			sy -= adjust;
+	} else if (args_has(args, 'D'))
+		sy += adjust;
+
+	if (args_has(args, 'A'))
+		default_window_size(s, w, &sx, &sy, WINDOW_SIZE_LARGEST);
+	else if (args_has(args, 'a'))
+		default_window_size(s, w, &sx, &sy, WINDOW_SIZE_SMALLEST);
+
+	options_set_number(w->options, "window-size", WINDOW_SIZE_MANUAL);
+	resize_window(w, sx, sy);
+
+	return (CMD_RETURN_NORMAL);
+}

cmd-respawn-pane.c

@@ -20,7 +20,7 @@
 #include <sys/types.h>
 
 #include <stdlib.h>
-#include <unistd.h>
+#include <string.h>
 
 #include "tmux.h"
 
@@ -28,70 +28,69 @@
  * 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 = {
 	.name = "respawn-pane",
 	.alias = "respawnp",
 
-	.args = { "kt:", 0, -1 },
+	.args = { "c:e:kt:", 0, -1 },
-	.usage = "[-k] " CMD_TARGET_PANE_USAGE " [command]",
+	.usage = "[-k] [-c start-directory] [-e environment] "
+		 CMD_TARGET_PANE_USAGE " [command]",
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_respawn_pane_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_respawn_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_respawn_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	struct spawn_context	 sc;
-	struct window		*w = wl->window;
+	struct session		*s = item->target.s;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
+	struct winlink		*wl = item->target.wl;
-	struct session		*s = cmdq->state.tflag.s;
+	struct window_pane	*wp = item->target.wp;
-	struct environ		*env;
+	char			*cause = NULL;
-	const char		*path;
+	const char		*add;
-	char			*cause;
+	struct args_value	*value;
-	u_int			 idx;
-	struct environ_entry	*envent;
 
-	if (!args_has(self->args, 'k') && wp->fd != -1) {
+	memset(&sc, 0, sizeof sc);
-		if (window_pane_index(wp, &idx) != 0)
+	sc.item = item;
-			fatalx("index not found");
+	sc.s = s;
-		cmdq_error(cmdq, "pane still active: %s:%d.%u",
+	sc.wl = wl;
-		    s->name, wl->idx, idx);
+
-		return (CMD_RETURN_ERROR);
+	sc.wp0 = wp;
+	sc.lc = NULL;
+
+	sc.name = NULL;
+	sc.argc = args->argc;
+	sc.argv = args->argv;
+	sc.environ = environ_create();
+
+	add = args_first_value(args, 'e', &value);
+	while (add != NULL) {
+		environ_put(sc.environ, add);
+		add = args_next_value(&value);
 	}
 
-	env = environ_create();
+	sc.idx = -1;
-	environ_copy(global_environ, env);
+	sc.cwd = args_get(args, 'c');
-	environ_copy(s->environ, env);
-	server_fill_environ(s, env);
 
-	window_pane_reset_mode(wp);
+	sc.flags = SPAWN_RESPAWN;
-	screen_reinit(&wp->base);
+	if (args_has(args, 'k'))
-	input_init(wp);
+		sc.flags |= SPAWN_KILL;
 
-	path = NULL;
+	if (spawn_pane(&sc, &cause) == NULL) {
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
+		cmdq_error(item, "respawn pane failed: %s", cause);
-		envent = environ_find(cmdq->client->environ, "PATH");
-	else
-		envent = environ_find(s->environ, "PATH");
-	if (envent != NULL)
-		path = envent->value;
-
-	if (window_pane_spawn(wp, args->argc, args->argv, path, NULL, NULL, env,
-	    s->tio, &cause) != 0) {
-		cmdq_error(cmdq, "respawn pane failed: %s", cause);
 		free(cause);
-		environ_free(env);
 		return (CMD_RETURN_ERROR);
 	}
-	wp->flags |= PANE_REDRAW;
-	server_status_window(w);
 
-	environ_free(env);
+	wp->flags |= PANE_REDRAW;
+	server_status_window(wp->window);
+
+	environ_free(sc.environ);
 	return (CMD_RETURN_NORMAL);
 }

cmd-respawn-window.c

@@ -19,7 +19,7 @@
 #include <sys/types.h>
 
 #include <stdlib.h>
-#include <unistd.h>
+#include <string.h>
 
 #include "tmux.h"
 
@@ -27,81 +27,65 @@
  * 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 = {
 	.name = "respawn-window",
 	.alias = "respawnw",
 
-	.args = { "kt:", 0, -1 },
+	.args = { "c:e:kt:", 0, -1 },
-	.usage = "[-k] " CMD_TARGET_WINDOW_USAGE " [command]",
+	.usage = "[-k] [-c start-directory] [-e environment] "
+		 CMD_TARGET_WINDOW_USAGE " [command]",
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
 	.flags = 0,
 	.exec = cmd_respawn_window_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_respawn_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_respawn_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct session		*s = cmdq->state.tflag.s;
+	struct spawn_context	 sc;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	struct session		*s = item->target.s;
-	struct window		*w = wl->window;
+	struct winlink		*wl = item->target.wl;
-	struct window_pane	*wp;
+	char			*cause = NULL;
-	struct environ		*env;
+	const char		*add;
-	const char		*path;
+	struct args_value	*value;
-	char		 	*cause;
-	struct environ_entry	*envent;
 
-	if (!args_has(self->args, 'k')) {
+	memset(&sc, 0, sizeof sc);
-		TAILQ_FOREACH(wp, &w->panes, entry) {
+	sc.item = item;
-			if (wp->fd == -1)
+	sc.s = s;
-				continue;
+	sc.wl = wl;
-			cmdq_error(cmdq, "window still active: %s:%d", s->name,
+
-			    wl->idx);
+	sc.name = NULL;
-			return (CMD_RETURN_ERROR);
+	sc.argc = args->argc;
-		}
+	sc.argv = args->argv;
+	sc.environ = environ_create();
+
+	add = args_first_value(args, 'e', &value);
+	while (add != NULL) {
+		environ_put(sc.environ, add);
+		add = args_next_value(&value);
 	}
 
-	env = environ_create();
+	sc.idx = -1;
-	environ_copy(global_environ, env);
+	sc.cwd = args_get(args, 'c');
-	environ_copy(s->environ, env);
-	server_fill_environ(s, env);
 
-	wp = TAILQ_FIRST(&w->panes);
+	sc.flags = SPAWN_RESPAWN;
-	TAILQ_REMOVE(&w->panes, wp, entry);
+	if (args_has(args, 'k'))
-	layout_free(w);
+		sc.flags |= SPAWN_KILL;
-	window_destroy_panes(w);
-	TAILQ_INSERT_HEAD(&w->panes, wp, entry);
-	window_pane_resize(wp, w->sx, w->sy);
 
-	path = NULL;
+	if (spawn_window(&sc, &cause) == NULL) {
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
+		cmdq_error(item, "respawn window failed: %s", cause);
-		envent = environ_find(cmdq->client->environ, "PATH");
-	else
-		envent = environ_find(s->environ, "PATH");
-	if (envent != NULL)
-		path = envent->value;
-
-	if (window_pane_spawn(wp, args->argc, args->argv, path, NULL, NULL, env,
-	    s->tio, &cause) != 0) {
-		cmdq_error(cmdq, "respawn window failed: %s", cause);
 		free(cause);
-		environ_free(env);
-		server_destroy_pane(wp, 0);
 		return (CMD_RETURN_ERROR);
 	}
-	layout_init(w, wp);
-	window_pane_reset_mode(wp);
-	screen_reinit(&wp->base);
-	input_init(wp);
-	window_set_active_pane(w, wp);
 
-	recalculate_sizes();
+	server_redraw_window(wl->window);
-	server_redraw_window(w);
 
-	environ_free(env);
+	environ_free(sc.environ);
 	return (CMD_RETURN_NORMAL);
 }

cmd-rotate-window.c

@@ -24,7 +24,8 @@
  * Rotate the panes in a window.
  */
 
-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 = {
 	.name = "rotate-window",
@@ -33,21 +34,24 @@ const struct cmd_entry cmd_rotate_window_entry = {
 	.args = { "Dt:U", 0, 0 },
 	.usage = "[-DU] " CMD_TARGET_WINDOW_USAGE,
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
 	.flags = 0,
 	.exec = cmd_rotate_window_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_rotate_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_rotate_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	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;
 
+	server_unzoom_window(w);
+
 	if (args_has(self->args, 'D')) {
 		wp = TAILQ_LAST(&w->panes, window_panes);
 		TAILQ_REMOVE(&w->panes, wp, entry);
@@ -73,7 +77,8 @@ 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);
+		window_set_active_pane(w, wp, 1);
+		cmd_find_from_winlink_pane(current, wl, wp, 0);
 		server_redraw_window(w);
 	} else {
 		wp = TAILQ_FIRST(&w->panes);
@@ -100,7 +105,8 @@ 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);
+		window_set_active_pane(w, wp, 1);
+		cmd_find_from_winlink_pane(current, wl, wp, 0);
 		server_redraw_window(w);
 	}
 

cmd-run-shell.c

@@ -29,11 +29,11 @@
  * 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 *);
+static void	cmd_run_shell_callback(struct job *);
-void	cmd_run_shell_free(void *);
+static void	cmd_run_shell_free(void *);
-void	cmd_run_shell_print(struct job *, const char *);
+static void	cmd_run_shell_print(struct job *, const char *);
 
 const struct cmd_entry cmd_run_shell_entry = {
 	.name = "run-shell",
@@ -42,133 +42,126 @@ const struct cmd_entry cmd_run_shell_entry = {
 	.args = { "bt:", 1, 1 },
 	.usage = "[-b] " CMD_TARGET_PANE_USAGE " shell-command",
 
-	.tflag = CMD_PANE_CANFAIL,
+	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
 
 	.flags = 0,
 	.exec = cmd_run_shell_exec
 };
 
 struct cmd_run_shell_data {
-	char		*cmd;
+	char			*cmd;
-	struct cmd_q	*cmdq;
+	struct cmdq_item	*item;
-	int		 bflag;
+	int			 wp_id;
-	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 cmd_run_shell_data	*cdata = job_get_data(job);
 	struct window_pane		*wp = NULL;
+	struct cmd_find_state		 fs;
+	struct window_mode_entry	*wme;
 
 	if (cdata->wp_id != -1)
 		wp = window_pane_find_by_id(cdata->wp_id);
 	if (wp == NULL) {
-		cmdq_print(cdata->cmdq, "%s", msg);
+		if (cdata->item != NULL) {
-		return;
+			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)
+	wme = TAILQ_FIRST(&wp->modes);
-		window_copy_init_for_output(wp);
+	if (wme == NULL || wme->mode != &window_view_mode)
-	if (wp->mode == &window_copy_mode)
+		window_pane_set_mode(wp, &window_view_mode, NULL, NULL);
-		window_copy_add(wp, "%s", msg);
+	window_copy_add(wp, "%s", msg);
 }
 
-enum cmd_retval
+static enum cmd_retval
-cmd_run_shell_exec(struct cmd *self, struct cmd_q *cmdq)
+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 = cmd_find_client(item, NULL, 1);
-	struct session			*s = cmdq->state.tflag.s;
+	struct session			*s = item->target.s;
-	struct winlink			*wl = cmdq->state.tflag.wl;
+	struct winlink			*wl = item->target.wl;
-	struct window_pane		*wp = cmdq->state.tflag.wp;
+	struct window_pane		*wp = item->target.wp;
-	struct format_tree		*ft;
-	const char			*cwd;
 
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
+	cdata = xcalloc(1, sizeof *cdata);
-		cwd = cmdq->client->cwd;
+	cdata->cmd = format_single(item, args->argv[0], c, s, wl, wp);
-	else if (s != NULL)
+
-		cwd = s->cwd;
+	if (args_has(args, 't') && wp != NULL)
+		cdata->wp_id = wp->id;
 	else
-		cwd = NULL;
+		cdata->wp_id = -1;
-	ft = format_create(cmdq, 0);
-	format_defaults(ft, cmdq->state.c, s, wl, wp);
-	shellcmd = format_expand(ft, args->argv[0]);
-	format_free(ft);
 
-	cdata = xmalloc(sizeof *cdata);
+	if (!args_has(args, 'b'))
-	cdata->cmd = shellcmd;
+		cdata->item = item;
-	cdata->bflag = args_has(args, 'b');
-	cdata->wp_id = wp != NULL ? (int) wp->id : -1;
 
-	cdata->cmdq = cmdq;
+	if (job_run(cdata->cmd, s, server_client_get_cwd(item->client, s), NULL,
-	cmdq->references++;
+	    cmd_run_shell_callback, cmd_run_shell_free, cdata, 0) == NULL) {
+		cmdq_error(item, "failed to run command: %s", cdata->cmd);
+		free(cdata);
+		return (CMD_RETURN_ERROR);
+	}
 
-	job_run(shellcmd, s, cwd, cmd_run_shell_callback, cmd_run_shell_free,
+	if (args_has(args, 'b'))
-	    cdata);
-
-	if (cdata->bflag)
 		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_run_shell_data	*cdata = job_get_data(job);
-	struct cmd_q			*cmdq = cdata->cmdq;
+	struct bufferevent		*event = job_get_event(job);
-	char				*cmd, *msg, *line;
+	char				*cmd = cdata->cmd, *msg = NULL, *line;
 	size_t				 size;
-	int				 retcode;
+	int				 retcode, status;
-	u_int				 lines;
 
-	if (cmdq->flags & CMD_Q_DEAD)
-		return;
-	cmd = cdata->cmd;
-
-	lines = 0;
 	do {
-		if ((line = evbuffer_readline(job->event->input)) != NULL) {
+		if ((line = evbuffer_readline(event->input)) != NULL) {
 			cmd_run_shell_print(job, line);
 			free(line);
-			lines++;
 		}
 	} while (line != NULL);
 
-	size = EVBUFFER_LENGTH(job->event->input);
+	size = EVBUFFER_LENGTH(event->input);
 	if (size != 0) {
 		line = xmalloc(size + 1);
-		memcpy(line, EVBUFFER_DATA(job->event->input), size);
+		memcpy(line, EVBUFFER_DATA(event->input), size);
 		line[size] = '\0';
 
 		cmd_run_shell_print(job, line);
-		lines++;
 
 		free(line);
 	}
 
-	msg = NULL;
+	status = job_get_status(job);
-	if (WIFEXITED(job->status)) {
+	if (WIFEXITED(status)) {
-		if ((retcode = WEXITSTATUS(job->status)) != 0)
+		if ((retcode = WEXITSTATUS(status)) != 0)
 			xasprintf(&msg, "'%s' returned %d", cmd, retcode);
-	} else if (WIFSIGNALED(job->status)) {
+	} else if (WIFSIGNALED(status)) {
-		retcode = WTERMSIG(job->status);
+		retcode = WTERMSIG(status);
 		xasprintf(&msg, "'%s' terminated by signal %d", cmd, retcode);
 	}
 	if (msg != NULL)
 		cmd_run_shell_print(job, msg);
 	free(msg);
+
+	if (cdata->item != NULL)
+		cmdq_continue(cdata->item);
 }
 
-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

@@ -31,7 +31,7 @@
  * 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 = {
 	.name = "save-buffer",
@@ -40,7 +40,7 @@ const struct cmd_entry cmd_save_buffer_entry = {
 	.args = { "ab:", 1, 1 },
 	.usage = "[-a] " CMD_BUFFER_USAGE " path",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_save_buffer_exec
 };
 
@@ -51,45 +51,48 @@ const struct cmd_entry cmd_show_buffer_entry = {
 	.args = { "b:", 0, 0 },
 	.usage = CMD_BUFFER_USAGE,
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_save_buffer_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_save_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_save_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->client;
+	struct client		*c = cmd_find_client(item, NULL, 1);
-	struct session          *s;
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	struct window_pane	*wp = item->target.wp;
 	struct paste_buffer	*pb;
-	const char		*path, *bufname, *bufdata, *start, *end, *cwd;
+	const char		*bufname, *bufdata, *start, *end, *flags;
-	const char		*flags;
+	char			*msg, *path, *file;
-	char			*msg, *file, resolved[PATH_MAX];
 	size_t			 size, used, msglen, bufsize;
 	FILE			*f;
 
 	if (!args_has(args, 'b')) {
 		if ((pb = paste_get_top(NULL)) == NULL) {
-			cmdq_error(cmdq, "no buffers");
+			cmdq_error(item, "no buffers");
 			return (CMD_RETURN_ERROR);
 		}
 	} else {
 		bufname = args_get(args, 'b');
 		pb = paste_get_name(bufname);
 		if (pb == NULL) {
-			cmdq_error(cmdq, "no buffer %s", bufname);
+			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 = "-";
+		path = xstrdup("-");
 	else
-		path = args->argv[0];
+		path = format_single(item, args->argv[0], c, s, wl, wp);
 	if (strcmp(path, "-") == 0) {
+		free(path);
+		c = item->client;
 		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))
@@ -97,39 +100,29 @@ cmd_save_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 		goto do_print;
 	}
 
-	if (c != NULL && c->session == NULL && c->cwd != NULL)
-		cwd = c->cwd;
-	else if ((s = c->session) != NULL && s->cwd != NULL)
-		cwd = s->cwd;
-	else
-		cwd = ".";
-
 	flags = "wb";
 	if (args_has(self->args, 'a'))
 		flags = "ab";
 
-	if (*path == '/')
+	file = server_client_get_path(item->client, path);
-		file = xstrdup(path);
+	free(path);
-	else
+
-		xasprintf(&file, "%s/%s", cwd, path);
+	f = fopen(file, flags);
-	if (realpath(file, resolved) == NULL &&
-	    strlcpy(resolved, file, sizeof resolved) >= sizeof resolved) {
-		cmdq_error(cmdq, "%s: %s", file, strerror(ENAMETOOLONG));
-		return (CMD_RETURN_ERROR);
-	}
-	f = fopen(resolved, flags);
-	free(file);
 	if (f == NULL) {
-		cmdq_error(cmdq, "%s: %s", resolved, strerror(errno));
+		cmdq_error(item, "%s: %s", file, strerror(errno));
+		free(file);
 		return (CMD_RETURN_ERROR);
 	}
 
 	if (fwrite(bufdata, 1, bufsize, f) != bufsize) {
-		cmdq_error(cmdq, "%s: write error", resolved);
+		cmdq_error(item, "%s: write error", file);
 		fclose(f);
+		free(file);
 		return (CMD_RETURN_ERROR);
 	}
+
 	fclose(f);
+	free(file);
 
 	return (CMD_RETURN_NORMAL);
 
@@ -140,7 +133,7 @@ do_stdout:
 
 do_print:
 	if (bufsize > (INT_MAX / 4) - 1) {
-		cmdq_error(cmdq, "buffer too big");
+		cmdq_error(item, "buffer too big");
 		return (CMD_RETURN_ERROR);
 	}
 	msg = NULL;
@@ -158,7 +151,7 @@ do_print:
 		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

@@ -26,18 +26,19 @@
  * Switch window to selected layout.
  */
 
-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 = {
 	.name = "select-layout",
 	.alias = "selectl",
 
-	.args = { "nopt:", 0, 1 },
+	.args = { "Enopt:", 0, 1 },
-	.usage = "[-nop] " CMD_TARGET_WINDOW_USAGE " [layout-name]",
+	.usage = "[-Enop] " CMD_TARGET_PANE_USAGE " [layout-name]",
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_select_layout_exec
 };
 
@@ -48,9 +49,9 @@ const struct cmd_entry cmd_next_layout_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_WINDOW_USAGE,
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_select_layout_exec
 };
 
@@ -61,23 +62,23 @@ const struct cmd_entry cmd_previous_layout_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_WINDOW_USAGE,
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_select_layout_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_select_layout_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_select_layout_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args		*args = self->args;
-	struct winlink	*wl = cmdq->state.tflag.wl;
+	struct winlink		*wl = item->target.wl;
-	struct window	*w;
+	struct window		*w = wl->window;
-	const char	*layoutname;
+	struct window_pane	*wp = item->target.wp;
-	char		*oldlayout;
+	const char		*layoutname;
-	int		 next, previous, layout;
+	char			*oldlayout;
+	int			 next, previous, layout;
 
-	w = wl->window;
 	server_unzoom_window(w);
 
 	next = self->entry == &cmd_next_layout_entry;
@@ -98,6 +99,11 @@ cmd_select_layout_exec(struct cmd *self, struct cmd_q *cmdq)
 		goto changed;
 	}
 
+	if (args_has(args, 'E')) {
+		layout_spread_out(wp);
+		goto changed;
+	}
+
 	if (!args_has(args, 'o')) {
 		if (args->argc == 0)
 			layout = w->lastlayout;
@@ -118,7 +124,7 @@ cmd_select_layout_exec(struct cmd *self, struct cmd_q *cmdq)
 
 	if (layoutname != NULL) {
 		if (layout_parse(w, layoutname) == -1) {
-			cmdq_error(cmdq, "can't set layout: %s", layoutname);
+			cmdq_error(item, "can't set layout: %s", layoutname);
 			goto error;
 		}
 		goto changed;
@@ -129,7 +135,9 @@ cmd_select_layout_exec(struct cmd *self, struct cmd_q *cmdq)
 
 changed:
 	free(oldlayout);
+	recalculate_sizes();
 	server_redraw_window(w);
+	notify_window("window-layout-changed", w);
 	return (CMD_RETURN_NORMAL);
 
 error:

cmd-select-pane.c

@@ -18,22 +18,25 @@
 
 #include <sys/types.h>
 
+#include <stdlib.h>
+#include <string.h>
+
 #include "tmux.h"
 
 /*
  * Select pane.
  */
 
-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 = {
 	.name = "select-pane",
 	.alias = "selectp",
 
-	.args = { "DdegLlMmP:Rt:U", 0, 0 },
+	.args = { "DdegLlMmP:RT:t:U", 0, 0 }, /* -P and -g deprecated */
-	.usage = "[-DdegLlMmRU] [-P style] " CMD_TARGET_PANE_USAGE,
+	.usage = "[-DdeLlMmRU] [-T title] " CMD_TARGET_PANE_USAGE,
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_select_pane_exec
@@ -46,42 +49,75 @@ const struct cmd_entry cmd_last_pane_entry = {
 	.args = { "det:", 0, 0 },
 	.usage = "[-de] " CMD_TARGET_WINDOW_USAGE,
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
 	.flags = 0,
 	.exec = cmd_select_pane_exec
 };
 
-enum cmd_retval
+static void
-cmd_select_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_select_pane_redraw(struct window *w)
+{
+	struct client	*c;
+
+	/*
+	 * Redraw entire window if it is bigger than the client (the
+	 * offset may change), otherwise just draw borders.
+	 */
+
+	TAILQ_FOREACH(c, &clients, entry) {
+		if (c->session == NULL || (c->flags & CLIENT_CONTROL))
+			continue;
+		if (c->session->curw->window == w && tty_window_bigger(&c->tty))
+			server_redraw_client(c);
+		else {
+			if (c->session->curw->window == w)
+				c->flags |= CLIENT_REDRAWBORDERS;
+			if (session_has(c->session, w))
+				c->flags |= CLIENT_REDRAWSTATUS;
+		}
+
+	}
+}
+
+static enum cmd_retval
+cmd_select_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	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 = cmdq->state.tflag.s;
+	struct session		*s = item->target.s;
-	struct window_pane	*wp = cmdq->state.tflag.wp, *lastwp, *markedwp;
+	struct window_pane	*wp = item->target.wp, *lastwp, *markedwp;
+	char			*pane_title;
 	const char		*style;
+	struct style		*sy;
+	struct options_entry	*o;
 
 	if (self->entry == &cmd_last_pane_entry || args_has(args, 'l')) {
-
+		lastwp = w->last;
-		if (wl->window->last == NULL) {
+		if (lastwp == NULL && window_count_panes(w) == 2) {
-			cmdq_error(cmdq, "no last pane");
+			lastwp = TAILQ_PREV(w->active, window_panes, entry);
+			if (lastwp == NULL)
+				lastwp = TAILQ_NEXT(w->active, entry);
+		}
+		if (lastwp == NULL) {
+			cmdq_error(item, "no last pane");
 			return (CMD_RETURN_ERROR);
 		}
-
 		if (args_has(self->args, 'e'))
-			w->last->flags &= ~PANE_INPUTOFF;
+			lastwp->flags &= ~PANE_INPUTOFF;
 		else if (args_has(self->args, 'd'))
-			w->last->flags |= PANE_INPUTOFF;
+			lastwp->flags |= PANE_INPUTOFF;
 		else {
 			server_unzoom_window(w);
-			window_redraw_active_switch(w, w->last);
+			window_redraw_active_switch(w, lastwp);
-			if (window_set_active_pane(w, w->last)) {
+			if (window_set_active_pane(w, lastwp, 1)) {
-				server_status_window(w);
+				cmd_find_from_winlink(current, wl, 0);
-				server_redraw_window_borders(w);
+				cmd_select_pane_redraw(w);
 			}
 		}
-
 		return (CMD_RETURN_NORMAL);
 	}
 
@@ -108,17 +144,21 @@ cmd_select_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	}
 
 	if (args_has(self->args, 'P') || args_has(self->args, 'g')) {
-		if (args_has(args, 'P')) {
+		if ((style = args_get(args, 'P')) != NULL) {
-			style = args_get(args, 'P');
+			o = options_set_style(wp->options, "window-style", 0,
-			if (style_parse(&grid_default_cell, &wp->colgc,
+			    style);
-			    style) == -1) {
+			if (o == NULL) {
-				cmdq_error(cmdq, "bad style: %s", style);
+				cmdq_error(item, "bad style: %s", style);
 				return (CMD_RETURN_ERROR);
 			}
-			wp->flags |= PANE_REDRAW;
+			options_set_style(wp->options, "window-active-style", 0,
+			    style);
+			wp->flags |= (PANE_REDRAW|PANE_STYLECHANGED);
+		}
+		if (args_has(self->args, 'g')) {
+			sy = options_get_style(wp->options, "window-style");
+			cmdq_print(item, "%s", style_tostring(sy));
 		}
-		if (args_has(self->args, 'g'))
-			cmdq_print(cmdq, "%s", style_tostring(&wp->colgc));
 		return (CMD_RETURN_NORMAL);
 	}
 
@@ -147,17 +187,23 @@ cmd_select_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 		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);
+		return (CMD_RETURN_NORMAL);
+	}
+
 	if (wp == w->active)
 		return (CMD_RETURN_NORMAL);
 	server_unzoom_window(wp->window);
-	if (!window_pane_visible(wp)) {
-		cmdq_error(cmdq, "pane not visible");
-		return (CMD_RETURN_ERROR);
-	}
 	window_redraw_active_switch(w, wp);
-	if (window_set_active_pane(w, wp)) {
+	if (window_set_active_pane(w, wp, 1)) {
-		server_status_window(w);
+		cmd_find_from_winlink_pane(current, wl, wp, 0);
-		server_redraw_window_borders(w);
+		cmdq_insert_hook(s, item, current, "after-select-pane");
+		cmd_select_pane_redraw(w);
 	}
 
 	return (CMD_RETURN_NORMAL);

cmd-select-window.c

@@ -26,7 +26,8 @@
  * Select window by index.
  */
 
-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 = {
 	.name = "select-window",
@@ -35,7 +36,7 @@ const struct cmd_entry cmd_select_window_entry = {
 	.args = { "lnpTt:", 0, 0 },
 	.usage = "[-lnpT] " CMD_TARGET_WINDOW_USAGE,
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
 	.flags = 0,
 	.exec = cmd_select_window_exec
@@ -48,7 +49,7 @@ const struct cmd_entry cmd_next_window_entry = {
 	.args = { "at:", 0, 0 },
 	.usage = "[-a] " CMD_TARGET_SESSION_USAGE,
 
-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },
 
 	.flags = 0,
 	.exec = cmd_select_window_exec
@@ -61,7 +62,7 @@ const struct cmd_entry cmd_previous_window_entry = {
 	.args = { "at:", 0, 0 },
 	.usage = "[-a] " CMD_TARGET_SESSION_USAGE,
 
-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },
 
 	.flags = 0,
 	.exec = cmd_select_window_exec
@@ -74,18 +75,19 @@ const struct cmd_entry cmd_last_window_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_SESSION_USAGE,
 
-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },
 
 	.flags = 0,
 	.exec = cmd_select_window_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_select_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_select_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct winlink	*wl = cmdq->state.tflag.wl;
+	struct cmd_find_state	*current = &item->shared->current;
-	struct session	*s = cmdq->state.tflag.s;
+	struct winlink		*wl = item->target.wl;
-	int		 next, previous, last, activity;
+	struct session		*s = item->target.s;
+	int			 next, previous, last, activity;
 
 	next = self->entry == &cmd_next_window_entry;
 	if (args_has(self->args, 'n'))
@@ -101,22 +103,23 @@ cmd_select_window_exec(struct cmd *self, struct cmd_q *cmdq)
 		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);
+		cmdq_insert_hook(s, item, current, "after-select-window");
 	} else {
 		/*
 		 * If -T and select-window is invoked on same window as
@@ -124,12 +127,17 @@ cmd_select_window_exec(struct cmd *self, struct cmd_q *cmdq)
 		 */
 		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);
+		}
+		cmdq_insert_hook(s, item, current, "after-select-window");
 	}
 	recalculate_sizes();
 

cmd-send-keys.c

@@ -27,18 +27,18 @@
  * 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 = {
 	.name = "send-keys",
 	.alias = "send",
 
-	.args = { "lRMt:", 0, -1 },
+	.args = { "HlXRMN:t:", 0, -1 },
-	.usage = "[-lRM] " CMD_TARGET_PANE_USAGE " key ...",
+	.usage = "[-HlXRM] [-N repeat-count] " CMD_TARGET_PANE_USAGE " key ...",
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_send_keys_exec
 };
 
@@ -49,30 +49,126 @@ const struct cmd_entry cmd_send_prefix_entry = {
 	.args = { "2t:", 0, 0 },
 	.usage = "[-2] " CMD_TARGET_PANE_USAGE,
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_send_keys_exec
 };
 
-enum cmd_retval
+static struct cmdq_item *
-cmd_send_keys_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_send_keys_inject_key(struct client *c, struct cmd_find_state *fs,
+    struct cmdq_item *item, key_code key)
 {
-	struct args		*args = self->args;
+	struct window_mode_entry	*wme;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
+	struct key_table		*table;
-	struct session		*s = cmdq->state.tflag.s;
+	struct key_binding		*bd;
-	struct mouse_event	*m = &cmdq->item->mouse;
+
-	const u_char		*keystr;
+	wme = TAILQ_FIRST(&fs->wp->modes);
-	int			 i, literal;
+	if (wme == NULL || wme->mode->key_table == NULL) {
+		if (options_get_number(fs->wp->window->options, "xterm-keys"))
+			key |= KEYC_XTERM;
+		window_pane_key(fs->wp, item->client, fs->s, fs->wl, key, NULL);
+		return (item);
+	}
+	table = key_bindings_get_table(wme->mode->key_table(wme), 1);
+
+	bd = key_bindings_get(table, key & ~KEYC_XTERM);
+	if (bd != NULL) {
+		table->references++;
+		item = key_bindings_dispatch(bd, item, c, NULL, &item->target);
+		key_bindings_unref_table(table);
+	}
+	return (item);
+}
+
+static struct cmdq_item *
+cmd_send_keys_inject_string(struct client *c, struct cmd_find_state *fs,
+    struct cmdq_item *item, struct args *args, int i)
+{
+	const char		*s = args->argv[i];
+	struct utf8_data	*ud, *uc;
+	wchar_t			 wc;
 	key_code		 key;
+	char			*endptr;
+	long			 n;
+	int			 literal;
+
+	if (args_has(args, 'H')) {
+		n = strtol(s, &endptr, 16);
+		if (*s =='\0' || n < 0 || n > 0xff || *endptr != '\0')
+			return (item);
+		return (cmd_send_keys_inject_key(c, fs, item, KEYC_LITERAL|n));
+	}
+
+	literal = args_has(args, 'l');
+	if (!literal) {
+		key = key_string_lookup_string(s);
+		if (key != KEYC_NONE && key != KEYC_UNKNOWN)
+			return (cmd_send_keys_inject_key(c, fs, item, key));
+		literal = 1;
+	}
+	if (literal) {
+		ud = utf8_fromcstr(s);
+		for (uc = ud; uc->size != 0; uc++) {
+			if (utf8_combine(uc, &wc) != UTF8_DONE)
+				continue;
+			item = cmd_send_keys_inject_key(c, fs, item, wc);
+		}
+		free(ud);
+	}
+	return (item);
+}
+
+static enum cmd_retval
+cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args			*args = self->args;
+	struct client			*c = cmd_find_client(item, NULL, 1);
+	struct cmd_find_state		*fs = &item->target;
+	struct window_pane		*wp = item->target.wp;
+	struct session			*s = item->target.s;
+	struct winlink			*wl = item->target.wl;
+	struct mouse_event		*m = &item->shared->mouse;
+	struct window_mode_entry	*wme = TAILQ_FIRST(&wp->modes);
+	int				 i;
+	key_code			 key;
+	u_int				 np = 1;
+	char				*cause = NULL;
+
+	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 (wme != NULL && (args_has(args, 'X') || args->argc == 0)) {
+			if (wme == NULL || wme->mode->command == NULL) {
+				cmdq_error(item, "not in a mode");
+				return (CMD_RETURN_ERROR);
+			}
+			wme->prefix = np;
+		}
+	}
+
+	if (args_has(args, 'X')) {
+		if (wme == NULL || wme->mode->command == NULL) {
+			cmdq_error(item, "not in a mode");
+			return (CMD_RETURN_ERROR);
+		}
+		if (!m->valid)
+			m = NULL;
+		wme->mode->command(wme, c, s, wl, args, m);
+		return (CMD_RETURN_NORMAL);
+	}
 
 	if (args_has(args, 'M')) {
 		wp = cmd_mouse_pane(m, &s, NULL);
 		if (wp == NULL) {
-			cmdq_error(cmdq, "no mouse target");
+			cmdq_error(item, "no mouse target");
 			return (CMD_RETURN_ERROR);
 		}
-		window_pane_key(wp, NULL, s, m->key, m);
+		window_pane_key(wp, item->client, s, wl, m->key, m);
 		return (CMD_RETURN_NORMAL);
 	}
 
@@ -81,26 +177,18 @@ cmd_send_keys_exec(struct cmd *self, struct cmd_q *cmdq)
 			key = options_get_number(s->options, "prefix2");
 		else
 			key = options_get_number(s->options, "prefix");
-		window_pane_key(wp, NULL, s, key, NULL);
+		cmd_send_keys_inject_key(c, fs, item, key);
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (args_has(args, 'R'))
+	if (args_has(args, 'R')) {
+		window_pane_reset_palette(wp);
 		input_reset(wp, 1);
+	}
 
-	for (i = 0; i < args->argc; i++) {
+	for (; np != 0; np--) {
-		literal = args_has(args, 'l');
+		for (i = 0; i < args->argc; i++)
-		if (!literal) {
+			item = cmd_send_keys_inject_string(c, fs, item, args, i);
-			key = key_string_lookup_string(args->argv[i]);
-			if (key != KEYC_NONE && key != KEYC_UNKNOWN)
-				window_pane_key(wp, NULL, s, key, NULL);
-			else
-				literal = 1;
-		}
-		if (literal) {
-			for (keystr = args->argv[i]; *keystr != '\0'; keystr++)
-				window_pane_key(wp, NULL, s, *keystr, NULL);
-		}
 	}
 
 	return (CMD_RETURN_NORMAL);

cmd-set-buffer.c

@@ -27,7 +27,7 @@
  * 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 = {
 	.name = "set-buffer",
@@ -36,7 +36,7 @@ const struct cmd_entry cmd_set_buffer_entry = {
 	.args = { "ab:n:", 0, 1 },
 	.usage = "[-a] " CMD_BUFFER_USAGE " [-n new-buffer-name] data",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_buffer_exec
 };
 
@@ -47,12 +47,12 @@ const struct cmd_entry cmd_delete_buffer_entry = {
 	.args = { "b:", 0, 0 },
 	.usage = CMD_BUFFER_USAGE,
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_buffer_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_set_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct paste_buffer	*pb;
@@ -70,7 +70,7 @@ cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 		if (pb == NULL)
 			pb = paste_get_top(&bufname);
 		if (pb == NULL) {
-			cmdq_error(cmdq, "no buffer");
+			cmdq_error(item, "no buffer");
 			return (CMD_RETURN_ERROR);
 		}
 		paste_free(pb);
@@ -81,11 +81,11 @@ cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 		if (pb == NULL)
 			pb = paste_get_top(&bufname);
 		if (pb == NULL) {
-			cmdq_error(cmdq, "no buffer");
+			cmdq_error(item, "no buffer");
 			return (CMD_RETURN_ERROR);
 		}
 		if (paste_rename(bufname, args_get(args, 'n'), &cause) != 0) {
-			cmdq_error(cmdq, "%s", cause);
+			cmdq_error(item, "%s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
@@ -93,7 +93,7 @@ cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 	}
 
 	if (args->argc != 1) {
-		cmdq_error(cmdq, "no data specified");
+		cmdq_error(item, "no data specified");
 		return (CMD_RETURN_ERROR);
 	}
 	if ((newsize = strlen(args->argv[0])) == 0)
@@ -113,7 +113,7 @@ cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 	bufsize += newsize;
 
 	if (paste_set(bufdata, bufsize, bufname, &cause) != 0) {
-		cmdq_error(cmdq, "%s", cause);
+		cmdq_error(item, "%s", cause);
 		free(bufdata);
 		free(cause);
 		return (CMD_RETURN_ERROR);

cmd-set-environment.c

@@ -27,7 +27,8 @@
  * 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 = {
 	.name = "set-environment",
@@ -36,14 +37,14 @@ const struct cmd_entry cmd_set_environment_entry = {
 	.args = { "grt:u", 1, 2 },
 	.usage = "[-gru] " CMD_TARGET_SESSION_USAGE " name [value]",
 
-	.tflag = CMD_SESSION_CANFAIL,
+	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_environment_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_set_environment_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_set_environment_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
 	struct environ	*env;
@@ -51,11 +52,11 @@ cmd_set_environment_exec(struct cmd *self, struct cmd_q *cmdq)
 
 	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);
 	}
 
@@ -67,32 +68,32 @@ cmd_set_environment_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(self->args, 'g'))
 		env = global_environ;
 	else {
-		if (cmdq->state.tflag.s == NULL) {
+		if (item->target.s == NULL) {
 			target = args_get(args, 't');
 			if (target != NULL)
-				cmdq_error(cmdq, "no such session: %s", target);
+				cmdq_error(item, "no such session: %s", target);
 			else
-				cmdq_error(cmdq, "no current session");
+				cmdq_error(item, "no current session");
 			return (CMD_RETURN_ERROR);
 		}
-		env = cmdq->state.tflag.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_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, "%s", value);

cmd-set-hook.c

@@ -1,129 +0,0 @@
-/* $OpenBSD$ */
-
-/*
- * Copyright (c) 2012 Thomas Adam <thomas@xteddy.org>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
- * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include <sys/types.h>
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "tmux.h"
-
-/*
- * Set or show global or session hooks.
- */
-
-enum cmd_retval cmd_set_hook_exec(struct cmd *, struct cmd_q *);
-
-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]",
-
-	.tflag = CMD_SESSION_CANFAIL,
-
-	.flags = 0,
-	.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,
-
-	.tflag = CMD_SESSION,
-
-	.flags = 0,
-	.exec = cmd_set_hook_exec
-};
-
-enum cmd_retval
-cmd_set_hook_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	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 (cmdq->state.tflag.s == NULL) {
-			target = args_get(args, 't');
-			if (target != NULL)
-				cmdq_error(cmdq, "no such session: %s", target);
-			else
-				cmdq_error(cmdq, "no current session");
-			return (CMD_RETURN_ERROR);
-		}
-		hooks = cmdq->state.tflag.s->hooks;
-	}
-
-	if (self->entry == &cmd_show_hooks_entry) {
-		hook = hooks_first(hooks);
-		while (hook != NULL) {
-			tmp = cmd_list_print(hook->cmdlist);
-			cmdq_print(cmdq, "%s -> %s", hook->name, tmp);
-			free(tmp);
-
-			hook = hooks_next(hook);
-		}
-		return (CMD_RETURN_NORMAL);
-	}
-
-	name = args->argv[0];
-	if (*name == '\0') {
-		cmdq_error(cmdq, "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(cmdq, "command passed to unset hook: %s",
-			    name);
-			return (CMD_RETURN_ERROR);
-		}
-		hooks_remove(hooks, name);
-		return (CMD_RETURN_NORMAL);
-	}
-
-	if (cmd == NULL) {
-		cmdq_error(cmdq, "no command to set hook: %s", name);
-		return (CMD_RETURN_ERROR);
-	}
-	if (cmd_string_parse(cmd, &cmdlist, NULL, 0, &cause) != 0) {
-		if (cause != NULL) {
-			cmdq_error(cmdq, "%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

@@ -18,6 +18,7 @@
 
 #include <sys/types.h>
 
+#include <fnmatch.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -27,53 +28,27 @@
  * 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 *,
+static int	cmd_set_option_set(struct cmd *, struct cmdq_item *,
-	    const char *, const char *);
+		    struct options *, struct options_entry *, const char *);
-
+static int	cmd_set_option_flag(struct cmdq_item *,
-int	cmd_set_option_unset(struct cmd *, struct cmd_q *,
+		    const struct options_table_entry *, struct options *,
-	    const struct options_table_entry *, struct options *,
+		    const char *);
-	    const char *);
+static int	cmd_set_option_choice(struct cmdq_item *,
-int	cmd_set_option_set(struct cmd *, struct cmd_q *,
+		    const struct options_table_entry *, struct options *,
-	    const struct options_table_entry *, struct options *,
+		    const char *);
-	    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 *);
 
 const struct cmd_entry cmd_set_option_entry = {
 	.name = "set-option",
 	.alias = "set",
 
-	.args = { "agoqst:uw", 1, 2 },
+	.args = { "aFgopqst:uw", 1, 2 },
-	.usage = "[-agosquw] [-t target-window] option [value]",
+	.usage = "[-aFgopqsuw] " CMD_TARGET_PANE_USAGE " option [value]",
 
-	.tflag = CMD_WINDOW_CANFAIL,
+	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_option_exec
 };
 
@@ -81,385 +56,309 @@ const struct cmd_entry cmd_set_window_option_entry = {
 	.name = "set-window-option",
 	.alias = "setw",
 
-	.args = { "agoqt:u", 1, 2 },
+	.args = { "aFgoqt:u", 1, 2 },
-	.usage = "[-agoqu] " CMD_TARGET_WINDOW_USAGE " option [value]",
+	.usage = "[-aFgoqu] " CMD_TARGET_WINDOW_USAGE " option [value]",
 
-	.tflag = CMD_WINDOW_CANFAIL,
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_CANFAIL },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_option_exec
 };
 
-enum cmd_retval
+const struct cmd_entry cmd_set_hook_entry = {
-cmd_set_option_exec(struct cmd *self, struct cmd_q *cmdq)
+	.name = "set-hook",
-{
+	.alias = NULL,
-	struct args				*args = self->args;
-	struct session				*s = cmdq->state.tflag.s;
-	struct winlink				*wl = cmdq->state.tflag.wl;
-	struct window				*w;
-	struct client				*c;
-	const struct options_table_entry	*oe;
-	struct options				*oo;
-	const char				*optstr, *valstr, *target;
 
-	/* Get the option name and value. */
+	.args = { "agRt:u", 1, 2 },
-	optstr = args->argv[0];
+	.usage = "[-agRu] " CMD_TARGET_SESSION_USAGE " hook [command]",
-	if (*optstr == '\0') {
+
-		cmdq_error(cmdq, "invalid option");
+	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
-		return (CMD_RETURN_ERROR);
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_set_option_exec
+};
+
+static enum cmd_retval
+cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
+{
+	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;
+	struct window_pane		*wp;
+	struct options			*oo;
+	struct options_entry		*parent, *o;
+	char				*name, *argument, *value = NULL, *cause;
+	int				 window, idx, already, error, ambiguous;
+	int				 scope;
+	struct style			*sy;
+
+	window = (self->entry == &cmd_set_window_option_entry);
+
+	/* Expand argument. */
+	c = cmd_find_client(item, NULL, 1);
+	argument = format_single(item, args->argv[0], c, s, wl, NULL);
+
+	/* If set-hook -R, fire the hook straight away. */
+	if (self->entry == &cmd_set_hook_entry && args_has(args, 'R')) {
+		notify_hook(item, argument);
+		free(argument);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	/* 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? */
+	/* Get the scope and table for the option .*/
-	if (*optstr == '@')
+	scope = options_scope_from_name(args, window, name, fs, &oo, &cause);
-		return (cmd_set_option_user(self, cmdq, optstr, valstr));
+	if (scope == OPTIONS_TABLE_NONE) {
+		if (args_has(args, 'q'))
+			goto out;
+		cmdq_error(item, "%s", cause);
+		free(cause);
+		goto fail;
+	}
+	o = options_get_only(oo, name);
+	parent = options_get(oo, name);
 
-	/* Find the option entry, try each table. */
+	/* Check that array options and indexes match up. */
-	oe = NULL;
+	if (idx != -1 && (*name == '@' || !options_isarray(parent))) {
-	if (options_table_find(optstr, &oe) != 0) {
+		cmdq_error(item, "not an array: %s", argument);
-		if (!args_has(args, 'q')) {
+		goto fail;
-			cmdq_error(cmdq, "ambiguous option: %s", optstr);
+	}
-			return (CMD_RETURN_ERROR);
+
+	/* 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);
 		}
-		return (CMD_RETURN_NORMAL);
+		if (already) {
-	}
+			if (args_has(args, 'q'))
-	if (oe == NULL) {
+				goto out;
-		if (!args_has(args, 'q')) {
+			cmdq_error(item, "already set: %s", argument);
-			cmdq_error(cmdq, "unknown option: %s", optstr);
+			goto fail;
-			return (CMD_RETURN_ERROR);
 		}
-		return (CMD_RETURN_NORMAL);
 	}
 
-	/* Work out the tree from the scope of the option. */
+	/* Change the option. */
-	if (oe->scope == OPTIONS_TABLE_SERVER)
-		oo = global_options;
-	else if (oe->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(cmdq, "no such window: %s",
-				    target);
-			} else
-				cmdq_error(cmdq, "no current window");
-			return (CMD_RETURN_ERROR);
-		} else
-			oo = wl->window->options;
-	} else if (oe->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(cmdq, "no such session: %s",
-				    target);
-			} else
-				cmdq_error(cmdq, "no current session");
-			return (CMD_RETURN_ERROR);
-		} else
-			oo = s->options;
-	} else {
-		cmdq_error(cmdq, "unknown table");
-		return (CMD_RETURN_ERROR);
-	}
-
-	/* Unset or set the option. */
 	if (args_has(args, 'u')) {
-		if (cmd_set_option_unset(self, cmdq, oe, oo, valstr) != 0)
+		if (o == NULL)
-			return (CMD_RETURN_ERROR);
+			goto out;
-	} else {
+		if (idx == -1) {
-		if (args_has(args, 'o') && options_find1(oo, optstr) != NULL) {
+			if (*name == '@')
-			if (!args_has(args, 'q')) {
+				options_remove(o);
-				cmdq_error(cmdq, "already set: %s", optstr);
+			else if (oo == global_options ||
-				return (CMD_RETURN_ERROR);
+			    oo == global_s_options ||
-			}
+			    oo == global_w_options)
-			return (CMD_RETURN_NORMAL);
+				options_default(oo, options_table_entry(o));
+			else
+				options_remove(o);
+		} else if (options_array_set(o, idx, NULL, 0, &cause) != 0) {
+			cmdq_error(item, "%s", cause);
+			free(cause);
+			goto fail;
+		}
+	} 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_isarray(parent)) {
+		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);
+			if (options_array_assign(o, value, &cause) != 0) {
+				cmdq_error(item, "%s", cause);
+				free(cause);
+				goto fail;
+			}
+		} else if (options_array_set(o, idx, value, append,
+		    &cause) != 0) {
+			cmdq_error(item, "%s", cause);
+			free(cause);
+			goto fail;
 		}
-		if (cmd_set_option_set(self, cmdq, oe, oo, valstr) != 0)
-			return (CMD_RETURN_ERROR);
 	}
 
-	/* Start or stop timers if necessary. */
+	/* Update timers and so on for various options. */
-	if (strcmp(oe->name, "automatic-rename") == 0) {
+	if (strcmp(name, "automatic-rename") == 0) {
 		RB_FOREACH(w, windows, &windows) {
+			if (w->active == NULL)
+				continue;
 			if (options_get_number(w->options, "automatic-rename"))
 				w->active->flags |= PANE_CHANGED;
 		}
 	}
-	if (strcmp(oe->name, "key-table") == 0) {
+	if (strcmp(name, "key-table") == 0) {
-		TAILQ_FOREACH(c, &clients, entry)
+		TAILQ_FOREACH(loop, &clients, entry)
-			server_client_set_key_table(c, NULL);
+			server_client_set_key_table(loop, NULL);
 	}
-	if (strcmp(oe->name, "status") == 0 ||
+	if (strcmp(name, "user-keys") == 0) {
-	    strcmp(oe->name, "status-interval") == 0)
+		TAILQ_FOREACH(loop, &clients, entry) {
+			if (loop->tty.flags & TTY_OPENED)
+				tty_keys_build(&loop->tty);
+		}
+	}
+	if (strcmp(name, "status-fg") == 0 || strcmp(name, "status-bg") == 0) {
+		sy = options_get_style(oo, "status-style");
+		sy->gc.fg = options_get_number(oo, "status-fg");
+		sy->gc.bg = options_get_number(oo, "status-bg");
+	}
+	if (strcmp(name, "status-style") == 0) {
+		sy = options_get_style(oo, "status-style");
+		options_set_number(oo, "status-fg", sy->gc.fg);
+		options_set_number(oo, "status-bg", sy->gc.bg);
+	}
+	if (strcmp(name, "status") == 0 ||
+	    strcmp(name, "status-interval") == 0)
 		status_timer_start_all();
-	if (strcmp(oe->name, "monitor-silence") == 0)
+	if (strcmp(name, "monitor-silence") == 0)
 		alerts_reset_all();
-	if (strcmp(oe->name, "window-style") == 0 ||
+	if (strcmp(name, "window-style") == 0 ||
-	    strcmp(oe->name, "window-active-style") == 0) {
+	    strcmp(name, "window-active-style") == 0) {
-		RB_FOREACH(w, windows, &windows)
+		RB_FOREACH(wp, window_pane_tree, &all_window_panes)
-			w->flags |= WINDOW_STYLECHANGED;
+			wp->flags |= PANE_STYLECHANGED;
 	}
-
+	if (strcmp(name, "pane-border-status") == 0) {
-	/* When the pane-border-status option has been changed, resize panes. */
-	if (strcmp(oe->name, "pane-border-status") == 0) {
 		RB_FOREACH(w, windows, &windows)
-			layout_fix_panes(w, w->sx, w->sy);
+			layout_fix_panes(w);
 	}
+	RB_FOREACH(s, sessions, &sessions)
+		status_update_cache(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();
-	TAILQ_FOREACH(c, &clients, entry) {
+	TAILQ_FOREACH(loop, &clients, entry) {
-		if (c->session != NULL)
+		if (loop->session != NULL)
-			server_redraw_client(c);
+			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. */
+static int
-enum cmd_retval
+cmd_set_option_set(struct cmd *self, struct cmdq_item *item, struct options *oo,
-cmd_set_option_user(struct cmd *self, struct cmd_q *cmdq, const char *optstr,
+    struct options_entry *parent, const char *value)
-    const char *valstr)
 {
-	struct args		*args = self->args;
+	const struct options_table_entry	*oe;
-	struct session		*s = cmdq->state.tflag.s;
+	struct args				*args = self->args;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	int					 append = args_has(args, 'a');
-	struct options		*oo;
+	struct options_entry			*o;
-	struct options_entry	*o;
+	long long				 number;
+	const char				*errstr, *new;
+	char					*old;
+	key_code				 key;
 
-	if (args_has(args, 's'))
+	oe = options_table_entry(parent);
-		oo = global_options;
+	if (value == NULL &&
-	else if (args_has(self->args, 'w') ||
+	    oe->type != OPTIONS_TABLE_FLAG &&
-	    self->entry == &cmd_set_window_option_entry) {
+	    oe->type != OPTIONS_TABLE_CHOICE) {
-		if (args_has(self->args, 'g'))
+		cmdq_error(item, "empty value");
-			oo = global_w_options;
-		else
-			oo = wl->window->options;
-	} else {
-		if (args_has(self->args, 'g'))
-			oo = global_s_options;
-		else
-			oo = s->options;
-	}
-
-	if (args_has(args, 'u')) {
-		if (options_find1(oo, optstr) == NULL) {
-			if (!args_has(args, 'q')) {
-				cmdq_error(cmdq, "unknown option: %s", optstr);
-				return (CMD_RETURN_ERROR);
-			}
-			return (CMD_RETURN_NORMAL);
-		}
-		if (valstr != NULL) {
-			cmdq_error(cmdq, "value passed to unset option: %s",
-			    optstr);
-			return (CMD_RETURN_ERROR);
-		}
-		options_remove(oo, optstr);
-	} else {
-		o = options_find1(oo, optstr);
-		if (args_has(args, 'o') && o != NULL) {
-			if (!args_has(args, 'q')) {
-				cmdq_error(cmdq, "already set: %s", optstr);
-				return (CMD_RETURN_ERROR);
-			}
-			return (CMD_RETURN_NORMAL);
-		}
-		if (valstr == NULL) {
-			cmdq_error(cmdq, "empty value");
-			return (CMD_RETURN_ERROR);
-		}
-		if (o != NULL && args_has(args, 'a'))
-			options_set_string(oo, optstr, "%s%s", o->str, valstr);
-		else
-			options_set_string(oo, optstr, "%s", valstr);
-	}
-	return (CMD_RETURN_NORMAL);
-}
-
-/* Unset an option. */
-int
-cmd_set_option_unset(struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	struct args	*args = self->args;
-
-	if (value != NULL) {
-		cmdq_error(cmdq, "value passed to unset option: %s", oe->name);
 		return (-1);
 	}
 
-	if (args_has(args, 'g') || oo == global_options) {
-		switch (oe->type) {
-		case OPTIONS_TABLE_STRING:
-			options_set_string(oo, oe->name, "%s", oe->default_str);
-			break;
-		case OPTIONS_TABLE_STYLE:
-			options_set_style(oo, oe->name, oe->default_str, 0);
-			break;
-		default:
-			options_set_number(oo, oe->name, oe->default_num);
-			break;
-		}
-	} else
-		options_remove(oo, oe->name);
-	return (0);
-}
-
-/* Set an option. */
-int
-cmd_set_option_set(struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	struct options_entry	*o;
-
-	switch (oe->type) {
-	case OPTIONS_TABLE_FLAG:
-	case OPTIONS_TABLE_CHOICE:
-		break;
-	default:
-		if (value == NULL) {
-			cmdq_error(cmdq, "empty value");
-			return (-1);
-		}
-	}
-
-	o = NULL;
 	switch (oe->type) {
 	case OPTIONS_TABLE_STRING:
-		o = cmd_set_option_string(self, cmdq, oe, oo, value);
+		old = xstrdup(options_get_string(oo, oe->name));
-		break;
+		options_set_string(oo, oe->name, append, "%s", value);
+		new = options_get_string(oo, oe->name);
+		if (oe->pattern != NULL && fnmatch(oe->pattern, new, 0) != 0) {
+			options_set_string(oo, oe->name, 0, "%s", old);
+			free(old);
+			cmdq_error(item, "value is invalid: %s", value);
+			return (-1);
+		}
+		free(old);
+		return (0);
 	case OPTIONS_TABLE_NUMBER:
-		o = cmd_set_option_number(self, cmdq, oe, oo, value);
+		number = strtonum(value, oe->minimum, oe->maximum, &errstr);
-		break;
+		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);
+		key = key_string_lookup_string(value);
-		break;
+		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 ((number = colour_fromstring(value)) == -1) {
-		if (o != NULL)
+			cmdq_error(item, "bad colour: %s", value);
-			style_update_new(oo, o->name, oe->style);
+			return (-1);
-		break;
+		}
-	case OPTIONS_TABLE_ATTRIBUTES:
+		options_set_number(oo, oe->name, number);
-		o = cmd_set_option_attributes(self, cmdq, oe, oo, value);
+		return (0);
-		if (o != NULL)
-			style_update_new(oo, o->name, oe->style);
-		break;
 	case OPTIONS_TABLE_FLAG:
-		o = cmd_set_option_flag(self, cmdq, oe, oo, value);
+		return (cmd_set_option_flag(item, oe, oo, value));
-		break;
 	case OPTIONS_TABLE_CHOICE:
-		o = cmd_set_option_choice(self, cmdq, oe, oo, value);
+		return (cmd_set_option_choice(item, oe, oo, value));
-		break;
 	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);
+		}
+		return (0);
+	case OPTIONS_TABLE_COMMAND:
 		break;
 	}
-	if (o == NULL)
+	return (-1);
-		return (-1);
-	return (0);
 }
 
-/* Set a string option. */
+static int
-struct options_entry *
+cmd_set_option_flag(struct cmdq_item *item,
-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)
-{
-	key_code	key;
-
-	key = key_string_lookup_string(value);
-	if (key == KEYC_UNKNOWN) {
-		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)
 {
@@ -467,31 +366,28 @@ cmd_set_option_flag(__unused struct cmd *self, struct cmd_q *cmdq,
 
 	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') ||
+		cmdq_error(item, "bad value: %s", value);
-		    strcasecmp(value, "on") == 0 ||
+		return (-1);
-		    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);
-		}
 	}
-
+	options_set_number(oo, oe->name, flag);
-	return (options_set_number(oo, oe->name, flag));
+	return (0);
 }
 
-/* Set a choice option. */
+static int
-struct options_entry *
+cmd_set_option_choice(struct cmdq_item *item,
-cmd_set_option_choice(__unused struct cmd *self, struct cmd_q *cmdq,
     const struct options_table_entry *oe, struct options *oo,
     const char *value)
 {
-	const char	**choicep;
+	const char	**cp;
 	int		  n, choice = -1;
 
 	if (value == NULL) {
@@ -500,42 +396,16 @@ cmd_set_option_choice(__unused struct cmd *self, struct cmd_q *cmdq,
 			choice = !choice;
 	} else {
 		n = 0;
-		for (choicep = oe->choices; *choicep != NULL; choicep++) {
+		for (cp = oe->choices; *cp != NULL; cp++) {
+			if (strcmp(*cp, value) == 0)
+				choice = n;
 			n++;
-			if (strncmp(*choicep, value, strlen(value)) != 0)
-				continue;
-
-			if (choice != -1) {
-				cmdq_error(cmdq, "ambiguous value: %s", value);
-				return (NULL);
-			}
-			choice = n - 1;
 		}
 		if (choice == -1) {
-			cmdq_error(cmdq, "unknown value: %s", value);
+			cmdq_error(item, "unknown value: %s", value);
-			return (NULL);
+			return (-1);
 		}
 	}
-
+	options_set_number(oo, oe->name, choice);
-	return (options_set_number(oo, oe->name, choice));
+	return (0);
-}
-
-/* Set a style option. */
-struct options_entry *
-cmd_set_option_style(struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	struct args		*args = self->args;
-	struct options_entry	*o;
-	int			 append;
-
-	append = args_has(args, 'a');
-	if ((o = options_set_style(oo, oe->name, value, append)) == NULL) {
-		cmdq_error(cmdq, "bad style: %s", value);
-		return (NULL);
-	}
-
-	style_update_old(oo, oe->name, &o->style);
-	return (o);
 }

cmd-show-environment.c

@@ -27,11 +27,12 @@
  * 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 *);
 
-char	*cmd_show_environment_escape(struct environ_entry *);
+static char	*cmd_show_environment_escape(struct environ_entry *);
-void	 cmd_show_environment_print(struct cmd *, struct cmd_q *,
+static void	 cmd_show_environment_print(struct cmd *, struct cmdq_item *,
-	     struct environ_entry *);
+		     struct environ_entry *);
 
 const struct cmd_entry cmd_show_environment_entry = {
 	.name = "show-environment",
@@ -40,13 +41,13 @@ const struct cmd_entry cmd_show_environment_entry = {
 	.args = { "gst:", 0, 1 },
 	.usage = "[-gs] " CMD_TARGET_SESSION_USAGE " [name]",
 
-	.tflag = CMD_SESSION_CANFAIL,
+	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_show_environment_exec
 };
 
-char *
+static char *
 cmd_show_environment_escape(struct environ_entry *envent)
 {
 	const char	*value = envent->value;
@@ -64,31 +65,31 @@ cmd_show_environment_escape(struct environ_entry *envent)
 	return (ret);
 }
 
-void
+static void
-cmd_show_environment_print(struct cmd *self, struct cmd_q *cmdq,
+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(cmdq, "%s=%s", envent->name, envent->value);
+			cmdq_print(item, "%s=%s", envent->name, envent->value);
 		else
-			cmdq_print(cmdq, "-%s", envent->name);
+			cmdq_print(item, "-%s", envent->name);
 		return;
 	}
 
 	if (envent->value != NULL) {
 		escaped = cmd_show_environment_escape(envent);
-		cmdq_print(cmdq, "%s=\"%s\"; export %s;", envent->name, escaped,
+		cmdq_print(item, "%s=\"%s\"; export %s;", envent->name, escaped,
 		    envent->name);
 		free(escaped);
 	} else
-		cmdq_print(cmdq, "unset %s;", envent->name);
+		cmdq_print(item, "unset %s;", envent->name);
 }
 
-enum cmd_retval
+static enum cmd_retval
-cmd_show_environment_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_show_environment_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct environ		*env;
@@ -96,8 +97,8 @@ cmd_show_environment_exec(struct cmd *self, struct cmd_q *cmdq)
 	const char		*target;
 
 	if ((target = args_get(args, 't')) != NULL) {
-		if (cmdq->state.tflag.s == NULL) {
+		if (item->target.s == NULL) {
-			cmdq_error(cmdq, "no such session: %s", target);
+			cmdq_error(item, "no such session: %s", target);
 			return (CMD_RETURN_ERROR);
 		}
 	}
@@ -105,30 +106,30 @@ cmd_show_environment_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(self->args, 'g'))
 		env = global_environ;
 	else {
-		if (cmdq->state.tflag.s == NULL) {
+		if (item->target.s == NULL) {
 			target = args_get(args, 't');
 			if (target != NULL)
-				cmdq_error(cmdq, "no such session: %s", target);
+				cmdq_error(item, "no such session: %s", target);
 			else
-				cmdq_error(cmdq, "no current session");
+				cmdq_error(item, "no current session");
 			return (CMD_RETURN_ERROR);
 		}
-		env = cmdq->state.tflag.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);
 		}
-		cmd_show_environment_print(self, cmdq, envent);
+		cmd_show_environment_print(self, item, envent);
 		return (CMD_RETURN_NORMAL);
 	}
 
 	envent = environ_first(env);
 	while (envent != NULL) {
-		cmd_show_environment_print(self, cmdq, envent);
+		cmd_show_environment_print(self, item, envent);
 		envent = environ_next(envent);
 	}
 	return (CMD_RETURN_NORMAL);

cmd-show-messages.c

@@ -28,7 +28,8 @@
  * 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 = {
 	.name = "show-messages",
@@ -37,28 +38,14 @@ const struct cmd_entry cmd_show_messages_entry = {
 	.args = { "JTt:", 0, 0 },
 	.usage = "[-JT] " CMD_TARGET_CLIENT_USAGE,
 
-	.tflag = CMD_CLIENT,
+	.flags = CMD_AFTERHOOK,
-
-	.flags = 0,
 	.exec = cmd_show_messages_exec
 };
 
-const struct cmd_entry cmd_server_info_entry = {
+static int	cmd_show_messages_terminals(struct cmdq_item *, int);
-	.name = "server-info",
-	.alias = "info",
 
-	.args = { "", 0, 0 },
+static int
-	.usage = "",
+cmd_show_messages_terminals(struct cmdq_item *item, int blank)
-
-	.flags = 0,
-	.exec = cmd_show_messages_exec
-};
-
-int	cmd_show_messages_terminals(struct cmd_q *, int);
-int	cmd_show_messages_jobs(struct cmd_q *, int);
-
-int
-cmd_show_messages_terminals(struct cmd_q *cmdq, int blank)
 {
 	struct tty_term	*term;
 	u_int		 i, n;
@@ -66,53 +53,37 @@ cmd_show_messages_terminals(struct cmd_q *cmdq, int blank)
 	n = 0;
 	LIST_FOREACH(term, &tty_terms, entry) {
 		if (blank) {
-			cmdq_print(cmdq, "%s", "");
+			cmdq_print(item, "%s", "");
 			blank = 0;
 		}
-		cmdq_print(cmdq, "Terminal %u: %s [references=%u, flags=0x%x]:",
+		cmdq_print(item, "Terminal %u: %s [references=%u, flags=0x%x]:",
 		    n, term->name, term->references, term->flags);
 		n++;
 		for (i = 0; i < tty_term_ncodes(); i++)
-			cmdq_print(cmdq, "%s", tty_term_describe(term, i));
+			cmdq_print(item, "%s", tty_term_describe(term, i));
 	}
 	return (n != 0);
 }
 
-int
+static enum cmd_retval
-cmd_show_messages_jobs(struct cmd_q *cmdq, int blank)
+cmd_show_messages_exec(struct cmd *self, struct cmdq_item *item)
-{
-	struct job	*job;
-	u_int		 n;
-
-	n = 0;
-	LIST_FOREACH(job, &all_jobs, lentry) {
-		if (blank) {
-			cmdq_print(cmdq, "%s", "");
-			blank = 0;
-		}
-		cmdq_print(cmdq, "Job %u: %s [fd=%d, pid=%d, status=%d]",
-		    n, job->cmd, job->fd, job->pid, job->status);
-		n++;
-	}
-	return (n != 0);
-}
-
-enum cmd_retval
-cmd_show_messages_exec(struct cmd *self, struct cmd_q *cmdq)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->state.c;
+	struct client		*c;
 	struct message_entry	*msg;
 	char			*tim;
 	int			 done, blank;
 
+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+
 	done = blank = 0;
-	if (args_has(args, 'T') || self->entry == &cmd_server_info_entry) {
+	if (args_has(args, 'T')) {
-		blank = cmd_show_messages_terminals(cmdq, blank);
+		blank = cmd_show_messages_terminals(item, blank);
 		done = 1;
 	}
-	if (args_has(args, 'J') || self->entry == &cmd_server_info_entry) {
+	if (args_has(args, 'J')) {
-		cmd_show_messages_jobs(cmdq, blank);
+		job_print_summary(item, blank);
 		done = 1;
 	}
 	if (done)
@@ -122,7 +93,7 @@ cmd_show_messages_exec(struct cmd *self, struct cmd_q *cmdq)
 		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

@@ -27,23 +27,23 @@
  * 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 *,
+static void		cmd_show_options_print(struct cmd *, struct cmdq_item *,
-		    struct options *, int);
+			    struct options_entry *, int, int);
-enum cmd_retval cmd_show_options_all(struct cmd *, struct cmd_q *,
+static enum cmd_retval	cmd_show_options_all(struct cmd *, struct cmdq_item *,
-	    	    struct options *, enum options_table_scope);
+			    int, struct options *);
 
 const struct cmd_entry cmd_show_options_entry = {
 	.name = "show-options",
 	.alias = "show",
 
-	.args = { "gqst:vw", 0, 1 },
+	.args = { "AgHpqst:vw", 0, 1 },
-	.usage = "[-gqsvw] [-t target-session|target-window] [option]",
+	.usage = "[-AgHpqsvw] " CMD_TARGET_PANE_USAGE " [option]",
 
-	.tflag = CMD_WINDOW_CANFAIL,
+	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_show_options_exec
 };
 
@@ -54,144 +54,199 @@ const struct cmd_entry cmd_show_window_options_entry = {
 	.args = { "gvt:", 0, 1 },
 	.usage = "[-gv] " CMD_TARGET_WINDOW_USAGE " [option]",
 
-	.tflag = CMD_WINDOW_CANFAIL,
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_CANFAIL },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_show_options_exec
 };
 
-enum cmd_retval
+const struct cmd_entry cmd_show_hooks_entry = {
-cmd_show_options_exec(struct cmd *self, struct cmd_q *cmdq)
+	.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_show_options_exec
+};
+
+static enum cmd_retval
+cmd_show_options_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
-	struct session			*s = cmdq->state.tflag.s;
+	struct cmd_find_state		*fs = &item->target;
-	struct winlink			*wl = cmdq->state.tflag.wl;
+	struct client			*c = cmd_find_client(item, NULL, 1);
+	struct session			*s = item->target.s;
+	struct winlink			*wl = item->target.wl;
 	struct options			*oo;
-	enum options_table_scope	 scope;
+	char				*argument, *name = NULL, *cause;
-	int				 quiet;
+	int				 window, idx, ambiguous, parent, scope;
-	const char			*target;
+	struct options_entry		*o;
 
-	if (args_has(self->args, 's')) {
+	window = (self->entry == &cmd_show_window_options_entry);
-		oo = global_options;
-		scope = OPTIONS_TABLE_SERVER;
-	} else if (args_has(self->args, 'w') ||
-	    self->entry == &cmd_show_window_options_entry) {
-		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(cmdq, "no such window: %s", target);
-			} else
-				cmdq_error(cmdq, "no current window");
-			return (CMD_RETURN_ERROR);
-		} else
-			oo = wl->window->options;
-	} else {
-		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(cmdq, "no such session: %s", target);
-			} else
-				cmdq_error(cmdq, "no current session");
-			return (CMD_RETURN_ERROR);
-		} else
-			oo = s->options;
-	}
 
-	quiet = args_has(self->args, 'q');
+	if (args->argc == 0) {
-	if (args->argc == 0)
+		scope = options_scope_from_flags(args, window, fs, &oo, &cause);
-		return (cmd_show_options_all(self, cmdq, oo, scope));
+		if (scope == OPTIONS_TABLE_NONE) {
-	else
+			if (args_has(args, 'q'))
-		return (cmd_show_options_one(self, cmdq, oo, quiet));
-}
-
-enum cmd_retval
-cmd_show_options_one(struct cmd *self, struct cmd_q *cmdq,
-    struct options *oo, int quiet)
-{
-	struct args				*args = self->args;
-	const char				*name = args->argv[0];
-	const struct options_table_entry	*oe;
-	struct options_entry			*o;
-	const char				*optval;
-
-retry:
-	if (*name == '@') {
-		if ((o = options_find1(oo, name)) == NULL) {
-			if (quiet)
 				return (CMD_RETURN_NORMAL);
-			cmdq_error(cmdq, "unknown option: %s", name);
+			cmdq_error(item, "%s", cause);
+			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
-		if (args_has(self->args, 'v'))
+		return (cmd_show_options_all(self, item, scope, oo));
-			cmdq_print(cmdq, "%s", o->str);
-		else
-			cmdq_print(cmdq, "%s \"%s\"", o->name, o->str);
-		return (CMD_RETURN_NORMAL);
 	}
+	argument = format_single(item, args->argv[0], c, s, wl, NULL);
 
-	oe = NULL;
+	name = options_match(argument, &idx, &ambiguous);
-	if (options_table_find(name, &oe) != 0) {
+	if (name == NULL) {
-		cmdq_error(cmdq, "ambiguous option: %s", name);
+		if (args_has(args, 'q'))
-		return (CMD_RETURN_ERROR);
+			goto fail;
+		if (ambiguous)
+			cmdq_error(item, "ambiguous option: %s", argument);
+		else
+			cmdq_error(item, "invalid option: %s", argument);
+		goto fail;
 	}
-	if (oe == NULL) {
+	scope = options_scope_from_name(args, window, name, fs, &oo, &cause);
-		if (quiet)
+	if (scope == OPTIONS_TABLE_NONE) {
-			return (CMD_RETURN_NORMAL);
+		if (args_has(args, 'q'))
-		cmdq_error(cmdq, "unknown option: %s", name);
+			goto fail;
-		return (CMD_RETURN_ERROR);
+		cmdq_error(item, "%s", cause);
+		free(cause);
+		goto fail;
 	}
-	if (oe->style != NULL) {
+	o = options_get_only(oo, name);
-		name = oe->style;
+	if (args_has(args, 'A') && o == NULL) {
-		goto retry;
+		o = options_get(oo, name);
-	}
+		parent = 1;
-	if ((o = options_find1(oo, oe->name)) == NULL)
+	} else
-		return (CMD_RETURN_NORMAL);
+		parent = 0;
-	optval = options_table_print_entry(oe, o, args_has(self->args, 'v'));
+	if (o != NULL)
-	if (args_has(self->args, 'v'))
+		cmd_show_options_print(self, item, o, idx, parent);
-		cmdq_print(cmdq, "%s", optval);
+
-	else
+	free(name);
-		cmdq_print(cmdq, "%s %s", oe->name, optval);
+	free(argument);
 	return (CMD_RETURN_NORMAL);
+
+fail:
+	free(name);
+	free(argument);
+	return (CMD_RETURN_ERROR);
 }
 
-enum cmd_retval
+static void
-cmd_show_options_all(struct cmd *self, struct cmd_q *cmdq, struct options *oo,
+cmd_show_options_print(struct cmd *self, struct cmdq_item *item,
-    enum options_table_scope scope)
+    struct options_entry *o, int idx, int parent)
+{
+	struct options_array_item	*a;
+	const char			*name = options_name(o);
+	char				*value, *tmp = NULL, *escaped;
+
+	if (idx != -1) {
+		xasprintf(&tmp, "%s[%d]", name, idx);
+		name = tmp;
+	} else {
+		if (options_isarray(o)) {
+			a = options_array_first(o);
+			if (a == NULL) {
+				if (!args_has(self->args, 'v'))
+					cmdq_print(item, "%s", name);
+				return;
+			}
+			while (a != NULL) {
+				idx = options_array_item_index(a);
+				cmd_show_options_print(self, item, o, idx,
+				    parent);
+				a = options_array_next(a);
+			}
+			return;
+		}
+	}
+
+	value = options_tostring(o, idx, 0);
+	if (args_has(self->args, 'v'))
+		cmdq_print(item, "%s", value);
+	else if (options_isstring(o)) {
+		escaped = args_escape(value);
+		if (parent)
+			cmdq_print(item, "%s* %s", name, escaped);
+		else
+			cmdq_print(item, "%s %s", name, escaped);
+		free(escaped);
+	} else {
+		if (parent)
+			cmdq_print(item, "%s* %s", name, value);
+		else
+			cmdq_print(item, "%s %s", name, value);
+	}
+	free(value);
+
+	free(tmp);
+}
+
+static enum cmd_retval
+cmd_show_options_all(struct cmd *self, struct cmdq_item *item, int scope,
+    struct options *oo)
 {
 	const struct options_table_entry	*oe;
 	struct options_entry			*o;
-	const char				*optval;
+	struct options_array_item		*a;
-	int					 vflag;
+	const char				*name;
+	u_int					 idx;
+	int					 parent;
 
 	o = options_first(oo);
 	while (o != NULL) {
-		if (*o->name == '@') {
+		if (options_table_entry(o) == NULL)
-			if (args_has(self->args, 'v'))
+			cmd_show_options_print(self, item, o, -1, 0);
-				cmdq_print(cmdq, "%s", o->str);
-			else
-				cmdq_print(cmdq, "%s \"%s\"", o->name, o->str);
-		}
 		o = options_next(o);
 	}
-
-	vflag = args_has(self->args, 'v');
 	for (oe = options_table; oe->name != NULL; oe++) {
-		if (oe->style != NULL || oe->scope != scope)
+		if (~oe->scope & scope)
 			continue;
-		if ((o = options_find1(oo, oe->name)) == NULL)
-			continue;
-		optval = options_table_print_entry(oe, o, vflag);
-		if (vflag)
-			cmdq_print(cmdq, "%s", optval);
-		else
-			cmdq_print(cmdq, "%s %s", oe->name, optval);
-	}
 
+		if ((self->entry != &cmd_show_hooks_entry &&
+		    !args_has(self->args, 'H') &&
+		    oe != NULL &&
+		    (oe->flags & OPTIONS_TABLE_IS_HOOK)) ||
+		    (self->entry == &cmd_show_hooks_entry &&
+		    (oe == NULL ||
+		    (~oe->flags & OPTIONS_TABLE_IS_HOOK))))
+			continue;
+
+		o = options_get_only(oo, oe->name);
+		if (o == NULL) {
+			if (!args_has(self->args, 'A'))
+				continue;
+			o = options_get(oo, oe->name);
+			if (o == NULL)
+				continue;
+			parent = 1;
+		} else
+			parent = 0;
+
+		if (!options_isarray(o))
+			cmd_show_options_print(self, item, o, -1, parent);
+		else if ((a = options_array_first(o)) == NULL) {
+			if (!args_has(self->args, 'v')) {
+				name = options_name(o);
+				if (parent)
+					cmdq_print(item, "%s*", name);
+				else
+					cmdq_print(item, "%s", name);
+			}
+		} else {
+			while (a != NULL) {
+				idx = options_array_item_index(a);
+				cmd_show_options_print(self, item, o, idx,
+				    parent);
+				a = options_array_next(a);
+			}
+		}
+	}
 	return (CMD_RETURN_NORMAL);
 }

cmd-source-file.c

@@ -18,7 +18,10 @@
 
 #include <sys/types.h>
 
+#include <errno.h>
+#include <glob.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "tmux.h"
 
@@ -26,72 +29,87 @@
  * 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_done(struct cmd_q *);
+static enum cmd_retval	cmd_source_file_done(struct cmdq_item *, void *);
 
 const struct cmd_entry cmd_source_file_entry = {
 	.name = "source-file",
 	.alias = "source",
 
-	.args = { "q", 1, 1 },
+	.args = { "nqv", 1, -1 },
-	.usage = "[-q] path",
+	.usage = "[-nqv] path ...",
 
 	.flags = 0,
 	.exec = cmd_source_file_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_source_file_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args		*args = self->args;
-	struct cmd_q	*cmdq1;
+	int			 flags = 0;
-	int		 quiet;
+	struct client		*c = item->client;
+	struct cmdq_item	*new_item, *after;
+	enum cmd_retval		 retval;
+	char			*pattern, *cwd;
+	const char		*path, *error;
+	glob_t			 g;
+	int			 i;
+	u_int			 j;
 
-	cmdq1 = cmdq_new(cmdq->client);
+	if (args_has(args, 'q'))
-	cmdq1->flags |= cmdq->flags & CMD_Q_NOHOOKS;
+		flags |= CMD_PARSE_QUIET;
-	cmdq1->emptyfn = cmd_source_file_done;
+	if (args_has(args, 'n'))
-	cmdq1->data = cmdq;
+		flags |= CMD_PARSE_PARSEONLY;
+	if (args_has(args, 'v'))
+		flags |= CMD_PARSE_VERBOSE;
+	utf8_stravis(&cwd, server_client_get_cwd(c, NULL), VIS_GLOB);
 
-	quiet = args_has(args, 'q');
+	retval = CMD_RETURN_NORMAL;
-	switch (load_cfg(args->argv[0], cmdq1, quiet)) {
+	for (i = 0; i < args->argc; i++) {
-	case -1:
+		path = args->argv[i];
-		cmdq_free(cmdq1);
+		if (*path == '/')
-		if (cfg_references == 0) {
+			pattern = xstrdup(path);
-			cfg_print_causes(cmdq);
+		else
-			return (CMD_RETURN_ERROR);
+			xasprintf(&pattern, "%s/%s", cwd, path);
+		log_debug("%s: %s", __func__, pattern);
+
+		if (glob(pattern, 0, NULL, &g) != 0) {
+			error = strerror(errno);
+			if (errno != ENOENT || (~flags & CMD_PARSE_QUIET)) {
+				cmdq_error(item, "%s: %s", path, error);
+				retval = CMD_RETURN_ERROR;
+			}
+			free(pattern);
+			continue;
 		}
-		return (CMD_RETURN_NORMAL);
+		free(pattern);
-	case 0:
+
-		cmdq_free(cmdq1);
+		after = item;
-		if (cfg_references == 0)
+		for (j = 0; j < g.gl_pathc; j++) {
-			cfg_print_causes(cmdq);
+			path = g.gl_pathv[j];
-		return (CMD_RETURN_NORMAL);
+			if (load_cfg(path, c, after, flags, &new_item) < 0)
+				retval = CMD_RETURN_ERROR;
+			else if (new_item != NULL)
+				after = new_item;
+		}
+		globfree(&g);
+	}
+	if (cfg_finished) {
+		if (retval == CMD_RETURN_ERROR && c->session == NULL)
+			c->retval = 1;
+		new_item = cmdq_get_callback(cmd_source_file_done, NULL);
+		cmdq_insert_after(item, new_item);
 	}
 
-	cmdq->references++;
+	free(cwd);
-	cfg_references++;
+	return (retval);
-
-	cmdq_continue(cmdq1);
-	return (CMD_RETURN_WAIT);
 }
 
-void
+static enum cmd_retval
-cmd_source_file_done(struct cmd_q *cmdq1)
+cmd_source_file_done(struct cmdq_item *item, __unused void *data)
 {
-	struct cmd_q	*cmdq = cmdq1->data;
+	cfg_print_causes(item);
-
+	return (CMD_RETURN_NORMAL);
-	if (cmdq1->client_exit >= 0)
-		cmdq->client_exit = cmdq1->client_exit;
-
-	cmdq_free(cmdq1);
-
-	cfg_references--;
-
-	if (cmdq_free(cmdq))
-		return;
-
-	if (cfg_references == 0)
-		cfg_print_causes(cmdq);
-	cmdq_continue(cmdq);
 }

cmd-split-window.c

@@ -32,165 +32,141 @@
 
 #define SPLIT_WINDOW_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"
 
-enum cmd_retval	 cmd_split_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_split_window_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_split_window_entry = {
 	.name = "split-window",
 	.alias = "splitw",
 
-	.args = { "bc:dfF:l:hp:Pt:v", 0, -1 },
+	.args = { "bc:de:fF:hIl:p:Pt:v", 0, -1 },
-	.usage = "[-bdfhvP] [-c start-directory] [-F format] "
+	.usage = "[-bdefhIPv] [-c start-directory] [-e environment] "
-		 "[-p percentage|-l size] " CMD_TARGET_PANE_USAGE " [command]",
+		 "[-F format] [-p percentage|-l size] " CMD_TARGET_PANE_USAGE
+		 " [command]",
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_split_window_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct session		*s = cmdq->state.tflag.s;
+	struct cmd_find_state	*current = &item->shared->current;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	struct spawn_context	 sc;
-	struct window		*w = wl->window;
+	struct client		*c = cmd_find_client(item, NULL, 1);
-	struct window_pane	*wp = cmdq->state.tflag.wp, *new_wp = NULL;
+	struct session		*s = item->target.s;
-	struct environ		*env;
+	struct winlink		*wl = item->target.wl;
-	const char		*cmd, *path, *shell, *template, *cwd, *to_free;
+	struct window_pane	*wp = item->target.wp, *new_wp;
-	char		       **argv, *cause, *new_cause, *cp;
-	u_int			 hlimit;
-	int			 argc, size, percentage;
 	enum layout_type	 type;
 	struct layout_cell	*lc;
-	struct format_tree	*ft;
+	struct cmd_find_state	 fs;
-	struct environ_entry	*envent;
+	int			 size, percentage, flags, input;
+	const char		*template, *add;
+	char			*cause, *cp;
+	struct args_value	*value;
 
-	server_unzoom_window(w);
-
-	env = environ_create();
-	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;
-	}
-
-	to_free = NULL;
-	if (args_has(args, 'c')) {
-		ft = format_create(cmdq, 0);
-		format_defaults(ft, cmdq->state.c, s, NULL, NULL);
-		to_free = cwd = format_expand(ft, args_get(args, 'c'));
-		format_free(ft);
-	} else if (cmdq->client != NULL && cmdq->client->session == NULL)
-		cwd = cmdq->client->cwd;
-	else
-		cwd = s->cwd;
-
-	type = LAYOUT_TOPBOTTOM;
 	if (args_has(args, 'h'))
 		type = LAYOUT_LEFTRIGHT;
-
+	else
-	size = -1;
+		type = LAYOUT_TOPBOTTOM;
 	if (args_has(args, 'l')) {
 		size = args_strtonum(args, 'l', 0, INT_MAX, &cause);
 		if (cause != NULL) {
-			xasprintf(&new_cause, "size %s", cause);
+			cmdq_error(item, "create pane failed: -l %s", cause);
 			free(cause);
-			cause = new_cause;
+			return (CMD_RETURN_ERROR);
-			goto error;
 		}
 	} else if (args_has(args, 'p')) {
 		percentage = args_strtonum(args, 'p', 0, INT_MAX, &cause);
 		if (cause != NULL) {
-			xasprintf(&new_cause, "percentage %s", cause);
+			cmdq_error(item, "create pane failed: -p %s", cause);
 			free(cause);
-			cause = new_cause;
+			return (CMD_RETURN_ERROR);
-			goto error;
 		}
 		if (type == LAYOUT_TOPBOTTOM)
 			size = (wp->sy * percentage) / 100;
 		else
 			size = (wp->sx * percentage) / 100;
-	}
-	hlimit = options_get_number(s->options, "history-limit");
-
-	shell = options_get_string(s->options, "default-shell");
-	if (*shell == '\0' || areshell(shell))
-		shell = _PATH_BSHELL;
-
-	lc = layout_split_pane(wp, type, size, args_has(args, 'b'),
-	    args_has(args, 'f'));
-	if (lc == NULL) {
-		cause = xstrdup("pane too small");
-		goto error;
-	}
-	new_wp = window_add_pane(w, wp, hlimit);
-	layout_assign_pane(lc, new_wp);
-
-	path = NULL;
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
-		envent = environ_find(cmdq->client->environ, "PATH");
-	else
-		envent = environ_find(s->environ, "PATH");
-	if (envent != NULL)
-		path = envent->value;
-
-	if (window_pane_spawn(new_wp, argc, argv, path, shell, cwd, env,
-	    s->tio, &cause) != 0)
-		goto error;
-
-	server_redraw_window(w);
-
-	if (!args_has(args, 'd')) {
-		window_set_active_pane(w, new_wp);
-		session_select(s, wl->idx);
-		server_redraw_session(s);
 	} else
-		server_status_session(s);
+		size = -1;
 
-	environ_free(env);
+	server_unzoom_window(wp->window);
+	input = (args_has(args, 'I') && args->argc == 0);
+
+	flags = 0;
+	if (args_has(args, 'b'))
+		flags |= SPAWN_BEFORE;
+	if (args_has(args, 'f'))
+		flags |= SPAWN_FULLSIZE;
+	if (input || (args->argc == 1 && *args->argv[0] == '\0'))
+		flags |= SPAWN_EMPTY;
+
+	lc = layout_split_pane(wp, type, size, flags);
+	if (lc == NULL) {
+		cmdq_error(item, "no space for new pane");
+		return (CMD_RETURN_ERROR);
+	}
+
+	memset(&sc, 0, sizeof sc);
+	sc.item = item;
+	sc.s = s;
+	sc.wl = wl;
+
+	sc.wp0 = wp;
+	sc.lc = lc;
+
+	sc.name = NULL;
+	sc.argc = args->argc;
+	sc.argv = args->argv;
+	sc.environ = environ_create();
+
+	add = args_first_value(args, 'e', &value);
+	while (add != NULL) {
+		environ_put(sc.environ, add);
+		add = args_next_value(&value);
+	}
+
+	sc.idx = -1;
+	sc.cwd = args_get(args, 'c');
+
+	sc.flags = flags;
+	if (args_has(args, 'd'))
+		sc.flags |= SPAWN_DETACHED;
+
+	if ((new_wp = spawn_pane(&sc, &cause)) == NULL) {
+		layout_close_pane(new_wp);
+		cmdq_error(item, "create pane failed: %s", cause);
+		free(cause);
+		return (CMD_RETURN_ERROR);
+	}
+	if (input && window_pane_start_input(new_wp, item, &cause) != 0) {
+		layout_close_pane(new_wp);
+		window_remove_pane(wp->window, new_wp);
+		cmdq_error(item, "%s", cause);
+		free(cause);
+		return (CMD_RETURN_ERROR);
+	}
+	if (!args_has(args, 'd'))
+		cmd_find_from_winlink_pane(current, wl, new_wp, 0);
+	server_redraw_window(wp->window);
+	server_status_session(s);
 
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = SPLIT_WINDOW_TEMPLATE;
-
+		cp = format_single(item, template, c, s, wl, new_wp);
-		ft = format_create(cmdq, 0);
+		cmdq_print(item, "%s", cp);
-		format_defaults(ft, cmdq->state.c, s, wl, new_wp);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}
-	notify_window_layout_changed(w);
 
-	if (to_free != NULL)
+	cmd_find_from_winlink_pane(&fs, wl, new_wp, 0);
-		free((void *)to_free);
+	cmdq_insert_hook(s, item, &fs, "after-split-window");
+
+	environ_free(sc.environ);
+	if (input)
+		return (CMD_RETURN_WAIT);
 	return (CMD_RETURN_NORMAL);
-
-error:
-	environ_free(env);
-	if (new_wp != NULL) {
-		layout_close_pane(new_wp);
-		window_remove_pane(w, new_wp);
-	}
-	cmdq_error(cmdq, "create pane failed: %s", cause);
-	free(cause);
-
-	if (to_free != NULL)
-		free((void *)to_free);
-	return (CMD_RETURN_ERROR);
 }

cmd-string.c

@@ -1,359 +0,0 @@
-/* $OpenBSD$ */
-
-/*
- * 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
- * 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 <pwd.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "tmux.h"
-
-/*
- * 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 *);
-
-int
-cmd_string_getc(const char *s, size_t *p)
-{
-	const u_char	*ucs = s;
-
-	if (ucs[*p] == '\0')
-		return (EOF);
-	return (ucs[(*p)++]);
-}
-
-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)
-{
-	size_t		p;
-	int		ch, i, argc, rval;
-	char	      **argv, *buf, *t;
-	const char     *whitespace, *equals;
-	size_t		len;
-
-	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) {
-		case '\'':
-			if ((t = cmd_string_string(s, &p, '\'', 0)) == NULL)
-				goto error;
-			cmd_string_copy(&buf, t, &len);
-			break;
-		case '"':
-			if ((t = cmd_string_string(s, &p, '"', 1)) == NULL)
-				goto error;
-			cmd_string_copy(&buf, t, &len);
-			break;
-		case '$':
-			if ((t = cmd_string_variable(s, &p)) == NULL)
-				goto error;
-			cmd_string_copy(&buf, t, &len);
-			break;
-		case '#':
-			/* Comment: discard rest of line. */
-			while ((ch = cmd_string_getc(s, &p)) != EOF)
-				;
-			/* FALLTHROUGH */
-		case EOF:
-		case ' ':
-		case '\t':
-			if (buf != NULL) {
-				buf = xrealloc(buf, len + 1);
-				buf[len] = '\0';
-
-				argv = xreallocarray(argv, argc + 1,
-				    sizeof *argv);
-				argv[argc++] = buf;
-
-				buf = NULL;
-				len = 0;
-			}
-
-			if (ch != EOF)
-				break;
-
-			while (argc != 0) {
-				equals = strchr(argv[0], '=');
-				whitespace = argv[0] + strcspn(argv[0], " \t");
-				if (equals == NULL || equals > whitespace)
-					break;
-				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;
-		case '~':
-			if (buf == NULL) {
-				t = cmd_string_expand_tilde(s, &p);
-				if (t == NULL)
-					goto error;
-				cmd_string_copy(&buf, t, &len);
-				break;
-			}
-			/* FALLTHROUGH */
-		default:
-			if (len >= SIZE_MAX - 2)
-				goto error;
-
-			buf = xrealloc(buf, len + 1);
-			buf[len++] = ch;
-			break;
-		}
-	}
-
-error:
-	xasprintf(cause, "invalid or unknown command: %s", s);
-
-out:
-	free(buf);
-
-	if (argv != NULL) {
-		for (i = 0; i < argc; i++)
-			free(argv[i]);
-		free(argv);
-	}
-
-	return (rval);
-}
-
-void
-cmd_string_copy(char **dst, char *src, size_t *len)
-{
-	size_t srclen;
-
-	srclen = strlen(src);
-
-	*dst = xrealloc(*dst, *len + srclen + 1);
-	strlcpy(*dst + *len, src, srclen + 1);
-
-	*len += srclen;
-	free(src);
-}
-
-char *
-cmd_string_string(const char *s, size_t *p, char endch, int esc)
-{
-	int	ch;
-	char   *buf, *t;
-	size_t	len;
-
-	buf = NULL;
-	len = 0;
-
-	while ((ch = cmd_string_getc(s, p)) != endch) {
-		switch (ch) {
-		case EOF:
-			goto error;
-		case '\\':
-			if (!esc)
-				break;
-			switch (ch = cmd_string_getc(s, p)) {
-			case EOF:
-				goto error;
-			case 'e':
-				ch = '\033';
-				break;
-			case 'r':
-				ch = '\r';
-				break;
-			case 'n':
-				ch = '\n';
-				break;
-			case 't':
-				ch = '\t';
-				break;
-			}
-			break;
-		case '$':
-			if (!esc)
-				break;
-			if ((t = cmd_string_variable(s, p)) == NULL)
-				goto error;
-			cmd_string_copy(&buf, t, &len);
-			continue;
-		}
-
-		if (len >= SIZE_MAX - 2)
-			goto error;
-		buf = xrealloc(buf, len + 1);
-		buf[len++] = ch;
-	}
-
-	buf = xrealloc(buf, len + 1);
-	buf[len] = '\0';
-	return (buf);
-
-error:
-	free(buf);
-	return (NULL);
-}
-
-char *
-cmd_string_variable(const char *s, size_t *p)
-{
-	int			ch, fch;
-	char		       *buf, *t;
-	size_t			len;
-	struct environ_entry   *envent;
-
-#define cmd_string_first(ch) ((ch) == '_' || \
-	((ch) >= 'a' && (ch) <= 'z') || ((ch) >= 'A' && (ch) <= 'Z'))
-#define cmd_string_other(ch) ((ch) == '_' || \
-	((ch) >= 'a' && (ch) <= 'z') || ((ch) >= 'A' && (ch) <= 'Z') || \
-	((ch) >= '0' && (ch) <= '9'))
-
-	buf = NULL;
-	len = 0;
-
-	fch = EOF;
-	switch (ch = cmd_string_getc(s, p)) {
-	case EOF:
-		goto error;
-	case '{':
-		fch = '{';
-
-		ch = cmd_string_getc(s, p);
-		if (!cmd_string_first(ch))
-			goto error;
-		/* FALLTHROUGH */
-	default:
-		if (!cmd_string_first(ch)) {
-			xasprintf(&t, "$%c", ch);
-			return (t);
-		}
-
-		buf = xrealloc(buf, len + 1);
-		buf[len++] = ch;
-
-		for (;;) {
-			ch = cmd_string_getc(s, p);
-			if (ch == EOF || !cmd_string_other(ch))
-				break;
-			else {
-				if (len >= SIZE_MAX - 3)
-					goto error;
-				buf = xrealloc(buf, len + 1);
-				buf[len++] = ch;
-			}
-		}
-	}
-
-	if (fch == '{' && ch != '}')
-		goto error;
-	if (ch != EOF && fch != '{')
-		cmd_string_ungetc(p); /* ch */
-
-	buf = xrealloc(buf, len + 1);
-	buf[len] = '\0';
-
-	envent = environ_find(global_environ, buf);
-	free(buf);
-	if (envent == NULL)
-		return (xstrdup(""));
-	return (xstrdup(envent->value));
-
-error:
-	free(buf);
-	return (NULL);
-}
-
-char *
-cmd_string_expand_tilde(const char *s, size_t *p)
-{
-	struct passwd		*pw;
-	struct environ_entry	*envent;
-	char			*home, *path, *user, *cp;
-	int			 last;
-
-	home = NULL;
-
-	last = cmd_string_getc(s, p);
-	if (last == EOF || last == '/' || last == ' '|| last == '\t') {
-		envent = environ_find(global_environ, "HOME");
-		if (envent != NULL && *envent->value != '\0')
-			home = envent->value;
-		else if ((pw = getpwuid(getuid())) != NULL)
-			home = pw->pw_dir;
-	} else {
-		cmd_string_ungetc(p);
-
-		cp = user = xmalloc(strlen(s));
-		for (;;) {
-			last = cmd_string_getc(s, p);
-			if (last == EOF || last == '/' || last == ' '|| last == '\t')
-				break;
-			*cp++ = last;
-		}
-		*cp = '\0';
-
-		if ((pw = getpwnam(user)) != NULL)
-			home = pw->pw_dir;
-		free(user);
-	}
-
-	if (home == NULL)
-		return (NULL);
-
-	if (last != EOF)
-		xasprintf(&path, "%s%c", home, last);
-	else
-		xasprintf(&path, "%s", home);
-	return (path);
-}

cmd-swap-pane.c

@@ -26,7 +26,7 @@
  * Swap two panes.
  */
 
-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 = {
 	.name = "swap-pane",
@@ -35,25 +35,25 @@ const struct cmd_entry cmd_swap_pane_entry = {
 	.args = { "dDs:t:U", 0, 0 },
 	.usage = "[-dDU] " CMD_SRCDST_PANE_USAGE,
 
-	.sflag = CMD_PANE_MARKED,
+	.source = { 's', CMD_FIND_PANE, CMD_FIND_DEFAULT_MARKED },
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_swap_pane_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_swap_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_swap_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	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_w = cmdq->state.tflag.wl->window;
+	dst_w = item->target.wl->window;
-	dst_wp = cmdq->state.tflag.wp;
+	dst_wp = item->target.wp;
-	src_w = cmdq->state.sflag.wl->window;
+	src_w = item->source.wl->window;
-	src_wp = cmdq->state.sflag.wp;
+	src_wp = item->source.wp;
 	server_unzoom_window(dst_w);
 
 	if (args_has(self->args, 'D')) {
@@ -90,7 +90,11 @@ cmd_swap_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	src_wp->layout_cell = dst_lc;
 
 	src_wp->window = dst_w;
+	options_set_parent(src_wp->options, dst_w->options);
+	src_wp->flags |= PANE_STYLECHANGED;
 	dst_wp->window = src_w;
+	options_set_parent(dst_wp->options, src_w->options);
+	dst_wp->flags |= PANE_STYLECHANGED;
 
 	sx = src_wp->sx; sy = src_wp->sy;
 	xoff = src_wp->xoff; yoff = src_wp->yoff;
@@ -101,19 +105,17 @@ cmd_swap_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 
 	if (!args_has(self->args, 'd')) {
 		if (src_w != dst_w) {
-			window_set_active_pane(src_w, dst_wp);
+			window_set_active_pane(src_w, dst_wp, 1);
-			window_set_active_pane(dst_w, src_wp);
+			window_set_active_pane(dst_w, src_wp, 1);
 		} else {
 			tmp_wp = dst_wp;
-			if (!window_pane_visible(tmp_wp))
+			window_set_active_pane(src_w, tmp_wp, 1);
-				tmp_wp = src_wp;
-			window_set_active_pane(src_w, tmp_wp);
 		}
 	} else {
 		if (src_w->active == src_wp)
-			window_set_active_pane(src_w, dst_wp);
+			window_set_active_pane(src_w, dst_wp, 1);
 		if (dst_w->active == dst_wp)
-			window_set_active_pane(dst_w, src_wp);
+			window_set_active_pane(dst_w, src_wp, 1);
 	}
 	if (src_w != dst_w) {
 		if (src_w->last == src_wp)

cmd-swap-window.c

@@ -26,7 +26,7 @@
  * 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 = {
 	.name = "swap-window",
@@ -35,43 +35,49 @@ const struct cmd_entry cmd_swap_window_entry = {
 	.args = { "ds:t:", 0, 0 },
 	.usage = "[-d] " CMD_SRCDST_WINDOW_USAGE,
 
-	.sflag = CMD_WINDOW_MARKED,
+	.source = { 's', CMD_FIND_WINDOW, CMD_FIND_DEFAULT_MARKED },
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
 	.flags = 0,
 	.exec = cmd_swap_window_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_swap_window_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_swap_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	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;
 
-	wl_src = cmdq->state.sflag.wl;
+	wl_src = item->source.wl;
-	src = cmdq->state.sflag.s;
+	src = item->source.s;
-	sg_src = session_group_find(src);
+	sg_src = session_group_contains(src);
 
-	wl_dst = cmdq->state.tflag.wl;
+	wl_dst = item->target.wl;
-	dst = cmdq->state.tflag.s;
+	dst = item->target.s;
-	sg_dst = session_group_find(dst);
+	sg_dst = session_group_contains(dst);
 
 	if (src != dst && sg_src != NULL && sg_dst != NULL &&
 	    sg_src == sg_dst) {
-		cmdq_error(cmdq, "can't move window, sessions are grouped");
+		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;
+	w_dst = wl_dst->window;
-	wl_dst->window = wl_src->window;
+	TAILQ_REMOVE(&w_dst->winlinks, wl_dst, wentry);
-	wl_src->window = w;
+	w_src = wl_src->window;
+	TAILQ_REMOVE(&w_src->winlinks, wl_src, wentry);
 
-	if (!args_has(self->args, 'd')) {
+	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);
 		if (src != dst)
 			session_select(src, wl_src->idx);

cmd-switch-client.c

@@ -27,7 +27,8 @@
  * Switch client to a different session.
  */
 
-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 = {
 	.name = "switch-client",
@@ -37,24 +38,42 @@ const struct cmd_entry cmd_switch_client_entry = {
 	.usage = "[-Elnpr] [-c target-client] [-t target-session] "
 		 "[-T key-table]",
 
-	.cflag = CMD_CLIENT,
+	/* -t is special */
-	.tflag = CMD_SESSION_WITHPANE,
 
 	.flags = CMD_READONLY,
 	.exec = cmd_switch_client_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_switch_client_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct cmd_state	*state = &cmdq->state;
+	const char		*tflag = args_get(args, 't');
-	struct client		*c = state->c;
+	enum cmd_find_type	 type;
-	struct session		*s = cmdq->state.tflag.s;
+	int			 flags;
+	struct client		*c;
+	struct session		*s;
+	struct winlink		*wl;
 	struct window_pane	*wp;
-	const char		*tablename, *update;
+	const char		*tablename;
 	struct key_table	*table;
 
+	if ((c = cmd_find_client(item, args_get(args, 'c'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+
+	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;
 
@@ -62,7 +81,7 @@ cmd_switch_client_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (tablename != NULL) {
 		table = key_bindings_get_table(tablename, 0);
 		if (table == NULL) {
-			cmdq_error(cmdq, "table %s doesn't exist", tablename);
+			cmdq_error(item, "table %s doesn't exist", tablename);
 			return (CMD_RETURN_ERROR);
 		}
 		table->references++;
@@ -73,12 +92,12 @@ cmd_switch_client_exec(struct cmd *self, struct cmd_q *cmdq)
 
 	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')) {
@@ -87,30 +106,34 @@ cmd_switch_client_exec(struct cmd *self, struct cmd_q *cmdq)
 		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 (cmdq->client == NULL)
+		if (item->client == NULL)
 			return (CMD_RETURN_NORMAL);
-		if (state->tflag.wl != NULL) {
+		if (wl != NULL) {
-			wp = state->tflag.wp;
+			server_unzoom_window(wl->window);
-			if (wp != NULL)
+			if (wp != NULL) {
-				window_set_active_pane(wp->window, wp);
+				window_redraw_active_switch(wp->window, wp);
-			session_set_current(s, state->tflag.wl);
+				window_set_active_pane(wp->window, wp, 1);
+			}
+			session_set_current(s, wl);
+			cmd_find_from_session(&item->shared->current, s, 0);
 		}
 	}
 
-	if (c != NULL && !args_has(args, 'E')) {
+	if (!args_has(args, 'E'))
-		update = options_get_string(s->options, "update-environment");
+		environ_update(s->options, c->environ, s->environ);
-		environ_update(update, c->environ, s->environ);
-	}
 
 	if (c->session != NULL && c->session != s)
 		c->last_session = c->session;
 	c->session = s;
-	server_client_set_key_table(c, NULL);
+	if (~item->shared->flags & CMDQ_SHARED_REPEAT)
+		server_client_set_key_table(c, NULL);
+	tty_update_client_offset(c);
 	status_timer_start(c);
+	notify_client("client-session-changed", c);
 	session_update_activity(s, NULL);
 	gettimeofday(&s->last_attached_time, NULL);
 

cmd-unbind-key.c

@@ -26,23 +26,21 @@
  * Unbind key from command.
  */
 
-enum cmd_retval	cmd_unbind_key_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_unbind_key_exec(struct cmd *, struct cmdq_item *);
-enum cmd_retval	cmd_unbind_key_mode_table(struct cmd *, struct cmd_q *,
-		    key_code);
 
 const struct cmd_entry cmd_unbind_key_entry = {
 	.name = "unbind-key",
 	.alias = "unbind",
 
-	.args = { "acnt:T:", 0, 1 },
+	.args = { "anT:", 0, 1 },
-	.usage = "[-acn] [-t mode-table] [-T key-table] key",
+	.usage = "[-an] [-T key-table] key",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_unbind_key_exec
 };
 
-enum cmd_retval
+static enum cmd_retval
-cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_unbind_key_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
 	key_code	 key;
@@ -50,25 +48,22 @@ cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
 
 	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 || key == KEYC_UNKNOWN) {
-			cmdq_error(cmdq, "unknown key: %s", args->argv[0]);
+			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_UNKNOWN;
 	}
 
-	if (args_has(args, 't'))
-		return (cmd_unbind_key_mode_table(self, cmdq, key));
-
 	if (key == KEYC_UNKNOWN) {
 		tablename = args_get(args, 'T');
 		if (tablename == NULL) {
@@ -77,7 +72,7 @@ cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
 			return (CMD_RETURN_NORMAL);
 		}
 		if (key_bindings_get_table(tablename, 0) == NULL) {
-			cmdq_error(cmdq, "table %s doesn't exist", tablename);
+			cmdq_error(item, "table %s doesn't exist", tablename);
 			return (CMD_RETURN_ERROR);
 		}
 		key_bindings_remove_table(tablename);
@@ -87,7 +82,7 @@ cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(args, 'T')) {
 		tablename = args_get(args, 'T');
 		if (key_bindings_get_table(tablename, 0) == NULL) {
-			cmdq_error(cmdq, "table %s doesn't exist", tablename);
+			cmdq_error(item, "table %s doesn't exist", tablename);
 			return (CMD_RETURN_ERROR);
 		}
 	} else if (args_has(args, 'n'))
@@ -97,35 +92,3 @@ cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
 	key_bindings_remove(tablename, key);
 	return (CMD_RETURN_NORMAL);
 }
-
-enum cmd_retval
-cmd_unbind_key_mode_table(struct cmd *self, struct cmd_q *cmdq, key_code 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_UNKNOWN) {
-		while (!RB_EMPTY(mtab->tree)) {
-			mbind = RB_ROOT(mtab->tree);
-			RB_REMOVE(mode_key_tree, mtab->tree, mbind);
-			free(mbind);
-		}
-		return (CMD_RETURN_NORMAL);
-	}
-
-	mtmp.key = key;
-	mtmp.mode = !!args_has(args, 'c');
-	if ((mbind = RB_FIND(mode_key_tree, mtab->tree, &mtmp)) != NULL) {
-		RB_REMOVE(mode_key_tree, mtab->tree, mbind);
-		free(mbind);
-	}
-	return (CMD_RETURN_NORMAL);
-}

cmd-wait-for.c

@@ -28,7 +28,7 @@
  * 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 = {
 	.name = "wait-for",
@@ -41,42 +41,46 @@ const struct cmd_entry cmd_wait_for_entry = {
 	.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(, wait_item)	waiters;
-	TAILQ_HEAD(, cmd_q)	lockers;
+	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 *);
+static int wait_channel_cmp(struct wait_channel *, struct wait_channel *);
-RB_PROTOTYPE(wait_channels, wait_channel, entry, wait_channel_cmp);
+RB_GENERATE_STATIC(wait_channels, wait_channel, entry, wait_channel_cmp);
-RB_GENERATE(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 *,
+static enum cmd_retval	cmd_wait_for_signal(struct cmdq_item *, const char *,
-		    struct wait_channel *);
+			    struct wait_channel *);
-enum cmd_retval	cmd_wait_for_wait(struct cmd_q *, const char *,
+static enum cmd_retval	cmd_wait_for_wait(struct cmdq_item *, const char *,
-		    struct wait_channel *);
+			    struct wait_channel *);
-enum cmd_retval	cmd_wait_for_lock(struct cmd_q *, const char *,
+static enum cmd_retval	cmd_wait_for_lock(struct cmdq_item *, const char *,
-		    struct wait_channel *);
+			    struct wait_channel *);
-enum cmd_retval	cmd_wait_for_unlock(struct cmd_q *, const char *,
+static enum cmd_retval	cmd_wait_for_unlock(struct cmdq_item *, const char *,
-		    struct wait_channel *);
+			    struct wait_channel *);
 
-struct wait_channel	*cmd_wait_for_add(const char *);
+static struct wait_channel	*cmd_wait_for_add(const char *);
-void			 cmd_wait_for_remove(struct wait_channel *wc);
+static void			 cmd_wait_for_remove(struct wait_channel *);
 
-struct wait_channel *
+static struct wait_channel *
 cmd_wait_for_add(const char *name)
 {
 	struct wait_channel *wc;
@@ -97,7 +101,7 @@ cmd_wait_for_add(const char *name)
 	return (wc);
 }
 
-void
+static void
 cmd_wait_for_remove(struct wait_channel *wc)
 {
 	if (wc->locked)
@@ -113,8 +117,8 @@ cmd_wait_for_remove(struct wait_channel *wc)
 	free(wc);
 }
 
-enum cmd_retval
+static enum cmd_retval
-cmd_wait_for_exec(struct cmd *self, struct cmd_q *cmdq)
+cmd_wait_for_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args     	*args = self->args;
 	const char		*name = args->argv[0];
@@ -124,19 +128,19 @@ 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_unlock(item, name, wc));
-	return (cmd_wait_for_wait(cmdq, name, wc));
+	return (cmd_wait_for_wait(item, name, wc));
 }
 
-enum cmd_retval
+static enum cmd_retval
-cmd_wait_for_signal(__unused struct cmd_q *cmdq, const char *name,
+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)
 		wc = cmd_wait_for_add(name);
@@ -148,24 +152,26 @@ cmd_wait_for_signal(__unused struct cmd_q *cmdq, const char *name,
 	}
 	log_debug("signal wait channel %s, with waiters", wc->name);
 
-	TAILQ_FOREACH_SAFE(wq, &wc->waiters, waitentry, wq1) {
+	TAILQ_FOREACH_SAFE(wi, &wc->waiters, entry, wi1) {
-		TAILQ_REMOVE(&wc->waiters, wq, waitentry);
+		cmdq_continue(wi->item);
-		if (!cmdq_free(wq))
+
-			cmdq_continue(wq);
+		TAILQ_REMOVE(&wc->waiters, wi, entry);
+		free(wi);
 	}
 
 	cmd_wait_for_remove(wc);
 	return (CMD_RETURN_NORMAL);
 }
 
-enum cmd_retval
+static enum cmd_retval
-cmd_wait_for_wait(struct cmd_q *cmdq, const char *name,
+cmd_wait_for_wait(struct cmdq_item *item, const char *name,
     struct wait_channel *wc)
 {
-	struct client	*c = cmdq->client;
+	struct client		*c = item->client;
+	struct wait_item	*wi;
 
-	if (c == NULL || c->session != NULL) {
+	if (c == NULL) {
-		cmdq_error(cmdq, "not able to wait");
+		cmdq_error(item, "not able to wait");
 		return (CMD_RETURN_ERROR);
 	}
 
@@ -179,18 +185,21 @@ cmd_wait_for_wait(struct cmd_q *cmdq, const char *name,
 	}
 	log_debug("wait channel %s not woken (%p)", wc->name, c);
 
-	TAILQ_INSERT_TAIL(&wc->waiters, cmdq, waitentry);
+	wi = xcalloc(1, sizeof *wi);
-	cmdq->references++;
+	wi->item = item;
+	TAILQ_INSERT_TAIL(&wc->waiters, wi, entry);
 
 	return (CMD_RETURN_WAIT);
 }
 
-enum cmd_retval
+static enum cmd_retval
-cmd_wait_for_lock(struct cmd_q *cmdq, const char *name,
+cmd_wait_for_lock(struct cmdq_item *item, const char *name,
     struct wait_channel *wc)
 {
-	if (cmdq->client == NULL || cmdq->client->session != NULL) {
+	struct wait_item	*wi;
-		cmdq_error(cmdq, "not able to lock");
+
+	if (item->client == NULL) {
+		cmdq_error(item, "not able to lock");
 		return (CMD_RETURN_ERROR);
 	}
 
@@ -198,8 +207,9 @@ cmd_wait_for_lock(struct cmd_q *cmdq, const char *name,
 		wc = cmd_wait_for_add(name);
 
 	if (wc->locked) {
-		TAILQ_INSERT_TAIL(&wc->lockers, cmdq, waitentry);
+		wi = xcalloc(1, sizeof *wi);
-		cmdq->references++;
+		wi->item = item;
+		TAILQ_INSERT_TAIL(&wc->lockers, wi, entry);
 		return (CMD_RETURN_WAIT);
 	}
 	wc->locked = 1;
@@ -207,21 +217,21 @@ cmd_wait_for_lock(struct cmd_q *cmdq, const char *name,
 	return (CMD_RETURN_NORMAL);
 }
 
-enum cmd_retval
+static enum cmd_retval
-cmd_wait_for_unlock(struct cmd_q *cmdq, const char *name,
+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) {
+	if ((wi = TAILQ_FIRST(&wc->lockers)) != NULL) {
-		TAILQ_REMOVE(&wc->lockers, wq, waitentry);
+		cmdq_continue(wi->item);
-		if (!cmdq_free(wq))
+		TAILQ_REMOVE(&wc->lockers, wi, entry);
-			cmdq_continue(wq);
+		free(wi);
 	} else {
 		wc->locked = 0;
 		cmd_wait_for_remove(wc);
@@ -234,19 +244,19 @@ void
 cmd_wait_for_flush(void)
 {
 	struct wait_channel	*wc, *wc1;
-	struct cmd_q		*wq, *wq1;
+	struct wait_item	*wi, *wi1;
 
 	RB_FOREACH_SAFE(wc, wait_channels, &wait_channels, wc1) {
-		TAILQ_FOREACH_SAFE(wq, &wc->waiters, waitentry, wq1) {
+		TAILQ_FOREACH_SAFE(wi, &wc->waiters, entry, wi1) {
-			TAILQ_REMOVE(&wc->waiters, wq, waitentry);
+			cmdq_continue(wi->item);
-			if (!cmdq_free(wq))
+			TAILQ_REMOVE(&wc->waiters, wi, entry);
-				cmdq_continue(wq);
+			free(wi);
 		}
 		wc->woken = 1;
-		TAILQ_FOREACH_SAFE(wq, &wc->lockers, waitentry, wq1) {
+		TAILQ_FOREACH_SAFE(wi, &wc->lockers, entry, wi1) {
-			TAILQ_REMOVE(&wc->lockers, wq, waitentry);
+			cmdq_continue(wi->item);
-			if (!cmdq_free(wq))
+			TAILQ_REMOVE(&wc->lockers, wi, entry);
-				cmdq_continue(wq);
+			free(wi);
 		}
 		wc->locked = 0;
 		cmd_wait_for_remove(wc);

cmd.c

@@ -33,9 +33,7 @@ extern const struct cmd_entry cmd_break_pane_entry;
 extern const struct cmd_entry cmd_capture_pane_entry;
 extern const struct cmd_entry cmd_choose_buffer_entry;
 extern const struct cmd_entry cmd_choose_client_entry;
-extern const struct cmd_entry cmd_choose_session_entry;
 extern const struct cmd_entry cmd_choose_tree_entry;
-extern const struct cmd_entry cmd_choose_window_entry;
 extern const struct cmd_entry cmd_clear_history_entry;
 extern const struct cmd_entry cmd_clock_mode_entry;
 extern const struct cmd_entry cmd_command_prompt_entry;
@@ -43,6 +41,7 @@ extern const struct cmd_entry cmd_confirm_before_entry;
 extern const struct cmd_entry cmd_copy_mode_entry;
 extern const struct cmd_entry cmd_delete_buffer_entry;
 extern const struct cmd_entry cmd_detach_client_entry;
+extern const struct cmd_entry cmd_display_menu_entry;
 extern const struct cmd_entry cmd_display_message_entry;
 extern const struct cmd_entry cmd_display_panes_entry;
 extern const struct cmd_entry cmd_down_pane_entry;
@@ -82,6 +81,7 @@ extern const struct cmd_entry cmd_refresh_client_entry;
 extern const struct cmd_entry cmd_rename_session_entry;
 extern const struct cmd_entry cmd_rename_window_entry;
 extern const struct cmd_entry cmd_resize_pane_entry;
+extern const struct cmd_entry cmd_resize_window_entry;
 extern const struct cmd_entry cmd_respawn_pane_entry;
 extern const struct cmd_entry cmd_respawn_window_entry;
 extern const struct cmd_entry cmd_rotate_window_entry;
@@ -92,7 +92,6 @@ extern const struct cmd_entry cmd_select_pane_entry;
 extern const struct cmd_entry cmd_select_window_entry;
 extern const struct cmd_entry cmd_send_keys_entry;
 extern const struct cmd_entry cmd_send_prefix_entry;
-extern const struct cmd_entry cmd_server_info_entry;
 extern const struct cmd_entry cmd_set_buffer_entry;
 extern const struct cmd_entry cmd_set_environment_entry;
 extern const struct cmd_entry cmd_set_hook_entry;
@@ -123,9 +122,7 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_capture_pane_entry,
 	&cmd_choose_buffer_entry,
 	&cmd_choose_client_entry,
-	&cmd_choose_session_entry,
 	&cmd_choose_tree_entry,
-	&cmd_choose_window_entry,
 	&cmd_clear_history_entry,
 	&cmd_clock_mode_entry,
 	&cmd_command_prompt_entry,
@@ -133,6 +130,7 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_copy_mode_entry,
 	&cmd_delete_buffer_entry,
 	&cmd_detach_client_entry,
+	&cmd_display_menu_entry,
 	&cmd_display_message_entry,
 	&cmd_display_panes_entry,
 	&cmd_find_window_entry,
@@ -171,6 +169,7 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_rename_session_entry,
 	&cmd_rename_window_entry,
 	&cmd_resize_pane_entry,
+	&cmd_resize_window_entry,
 	&cmd_respawn_pane_entry,
 	&cmd_respawn_window_entry,
 	&cmd_rotate_window_entry,
@@ -181,7 +180,6 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_select_window_entry,
 	&cmd_send_keys_entry,
 	&cmd_send_prefix_entry,
-	&cmd_server_info_entry,
 	&cmd_set_buffer_entry,
 	&cmd_set_environment_entry,
 	&cmd_set_hook_entry,
@@ -206,6 +204,47 @@ const struct cmd_entry *cmd_table[] = {
 	NULL
 };
 
+static u_int cmd_list_next_group = 1;
+
+void printflike(3, 4)
+cmd_log_argv(int argc, char **argv, const char *fmt, ...)
+{
+	char	*prefix;
+	va_list	 ap;
+	int	 i;
+
+	va_start(ap, fmt);
+	xvasprintf(&prefix, fmt, ap);
+	va_end(ap);
+
+	for (i = 0; i < argc; i++)
+		log_debug("%s: argv[%d]=%s", prefix, i, argv[i]);
+	free(prefix);
+}
+
+void
+cmd_prepend_argv(int *argc, char ***argv, char *arg)
+{
+	char	**new_argv;
+	int	  i;
+
+	new_argv = xreallocarray(NULL, (*argc) + 1, sizeof *new_argv);
+	new_argv[0] = xstrdup(arg);
+	for (i = 0; i < *argc; i++)
+		new_argv[1 + i] = (*argv)[i];
+
+	free(*argv);
+	*argv = new_argv;
+	(*argc)++;
+}
+
+void
+cmd_append_argv(int *argc, char ***argv, char *arg)
+{
+	*argv = xreallocarray(*argv, (*argc) + 1, sizeof **argv);
+	(*argv)[(*argc)++] = xstrdup(arg);
+}
+
 int
 cmd_pack_argv(int argc, char **argv, char *buf, size_t len)
 {
@@ -214,6 +253,7 @@ cmd_pack_argv(int argc, char **argv, char *buf, size_t len)
 
 	if (argc == 0)
 		return (0);
+	cmd_log_argv(argc, argv, "%s", __func__);
 
 	*buf = '\0';
 	for (i = 0; i < argc; i++) {
@@ -246,9 +286,11 @@ cmd_unpack_argv(char *buf, size_t len, int argc, char ***argv)
 
 		arglen = strlen(buf) + 1;
 		(*argv)[i] = xstrdup(buf);
+
 		buf += arglen;
 		len -= arglen;
 	}
+	cmd_log_argv(argc, *argv, "%s", __func__);
 
 	return (0);
 }
@@ -307,46 +349,103 @@ cmd_stringify_argv(int argc, char **argv)
 	return (buf);
 }
 
-struct cmd *
+char *
-cmd_parse(int argc, char **argv, const char *file, u_int line, char **cause)
+cmd_get_alias(const char *name)
 {
-	const struct cmd_entry **entryp, *entry;
+	struct options_entry		*o;
-	struct cmd		*cmd;
+	struct options_array_item	*a;
-	struct args		*args;
+	union options_value		*ov;
-	char			 s[BUFSIZ];
+	size_t				 wanted, n;
-	int			 ambiguous = 0;
+	const char			*equals;
 
-	*cause = NULL;
+	o = options_get_only(global_options, "command-alias");
-	if (argc == 0) {
+	if (o == NULL)
-		xasprintf(cause, "no command");
 		return (NULL);
-	}
+	wanted = strlen(name);
 
-	entry = NULL;
+	a = options_array_first(o);
-	for (entryp = cmd_table; *entryp != NULL; entryp++) {
+	while (a != NULL) {
-		if ((*entryp)->alias != NULL &&
+		ov = options_array_item_value(a);
-		    strcmp((*entryp)->alias, argv[0]) == 0) {
+
+		equals = strchr(ov->string, '=');
+		if (equals != NULL) {
+			n = equals - ov->string;
+			if (n == wanted && strncmp(name, ov->string, n) == 0)
+				return (xstrdup(equals + 1));
+		}
+
+		a = options_array_next(a);
+	}
+	return (NULL);
+}
+
+static const struct cmd_entry *
+cmd_find(const char *name, char **cause)
+{
+	const struct cmd_entry	**loop, *entry, *found = NULL;
+	int			  ambiguous;
+	char			  s[8192];
+
+	ambiguous = 0;
+	for (loop = cmd_table; *loop != NULL; loop++) {
+		entry = *loop;
+		if (entry->alias != NULL && strcmp(entry->alias, name) == 0) {
 			ambiguous = 0;
-			entry = *entryp;
+			found = entry;
 			break;
 		}
 
-		if (strncmp((*entryp)->name, argv[0], strlen(argv[0])) != 0)
+		if (strncmp(entry->name, name, strlen(name)) != 0)
 			continue;
-		if (entry != NULL)
+		if (found != NULL)
 			ambiguous = 1;
-		entry = *entryp;
+		found = entry;
 
-		/* Bail now if an exact match. */
+		if (strcmp(entry->name, name) == 0)
-		if (strcmp(entry->name, argv[0]) == 0)
 			break;
 	}
 	if (ambiguous)
 		goto ambiguous;
-	if (entry == NULL) {
+	if (found == NULL) {
-		xasprintf(cause, "unknown command: %s", argv[0]);
+		xasprintf(cause, "unknown command: %s", name);
 		return (NULL);
 	}
+	return (found);
+
+ambiguous:
+	*s = '\0';
+	for (loop = cmd_table; *loop != NULL; loop++) {
+		entry = *loop;
+		if (strncmp(entry->name, name, strlen(name)) != 0)
+			continue;
+		if (strlcat(s, entry->name, sizeof s) >= sizeof s)
+			break;
+		if (strlcat(s, ", ", sizeof s) >= sizeof s)
+			break;
+	}
+	s[strlen(s) - 2] = '\0';
+	xasprintf(cause, "ambiguous command: %s, could be: %s", name, s);
+	return (NULL);
+}
+
+struct cmd *
+cmd_parse(int argc, char **argv, const char *file, u_int line, char **cause)
+{
+	const struct cmd_entry	*entry;
+	const char		*name;
+	struct cmd		*cmd;
+	struct args		*args;
+
+	if (argc == 0) {
+		xasprintf(cause, "no command");
+		return (NULL);
+	}
+	name = argv[0];
+
+	entry = cmd_find(name, cause);
+	if (entry == NULL)
+		return (NULL);
+	cmd_log_argv(argc, argv, "%s: %s", __func__, entry->name);
 
 	args = args_parse(entry->args.template, argc, argv);
 	if (args == NULL)
@@ -364,21 +463,11 @@ cmd_parse(int argc, char **argv, const char *file, u_int line, char **cause)
 		cmd->file = xstrdup(file);
 	cmd->line = line;
 
-	return (cmd);
+	cmd->alias = NULL;
+	cmd->argc = argc;
+	cmd->argv = cmd_copy_argv(argc, argv);
 
-ambiguous:
+	return (cmd);
-	*s = '\0';
-	for (entryp = cmd_table; *entryp != NULL; entryp++) {
-		if (strncmp((*entryp)->name, argv[0], strlen(argv[0])) != 0)
-			continue;
-		if (strlcat(s, (*entryp)->name, sizeof s) >= sizeof s)
-			break;
-		if (strlcat(s, ", ", sizeof s) >= sizeof s)
-			break;
-	}
-	s[strlen(s) - 2] = '\0';
-	xasprintf(cause, "ambiguous command: %s, could be: %s", argv[0], s);
-	return (NULL);
 
 usage:
 	if (args != NULL)
@@ -387,177 +476,16 @@ usage:
 	return (NULL);
 }
 
-static int
+void
-cmd_prepare_state_flag(char c, const char *target, enum cmd_entry_flag flag,
+cmd_free(struct cmd *cmd)
-    struct cmd_q *cmdq, struct cmd_q *parent)
 {
-	int			 targetflags, error;
+	free(cmd->alias);
-	struct cmd_find_state	*fs = NULL;
+	cmd_free_argv(cmd->argc, cmd->argv);
-	struct cmd_find_state	*current = NULL;
-	struct cmd_find_state	 tmp;
 
-	if (flag == CMD_NONE ||
+	free(cmd->file);
-	    flag == CMD_CLIENT ||
-	    flag == CMD_CLIENT_CANFAIL)
-		return (0);
 
-	if (c == 't')
+	args_free(cmd->args);
-		fs = &cmdq->state.tflag;
+	free(cmd);
-	else if (c == 's')
-		fs = &cmdq->state.sflag;
-
-	if (flag == CMD_SESSION_WITHPANE) {
-		if (target != NULL && target[strcspn(target, ":.")] != '\0')
-			flag = CMD_PANE;
-		else
-			flag = CMD_SESSION;
-	}
-
-	targetflags = 0;
-	switch (flag) {
-	case CMD_SESSION:
-	case CMD_SESSION_CANFAIL:
-	case CMD_SESSION_PREFERUNATTACHED:
-		if (flag == CMD_SESSION_CANFAIL)
-			targetflags |= CMD_FIND_QUIET;
-		if (flag == CMD_SESSION_PREFERUNATTACHED)
-			targetflags |= CMD_FIND_PREFER_UNATTACHED;
-		break;
-	case CMD_MOVEW_R:
-		flag = CMD_WINDOW_INDEX;
-		/* FALLTHROUGH */
-	case CMD_WINDOW:
-	case CMD_WINDOW_CANFAIL:
-	case CMD_WINDOW_MARKED:
-	case CMD_WINDOW_INDEX:
-		if (flag == CMD_WINDOW_CANFAIL)
-			targetflags |= CMD_FIND_QUIET;
-		if (flag == CMD_WINDOW_MARKED)
-			targetflags |= CMD_FIND_DEFAULT_MARKED;
-		if (flag == CMD_WINDOW_INDEX)
-			targetflags |= CMD_FIND_WINDOW_INDEX;
-		break;
-	case CMD_PANE:
-	case CMD_PANE_CANFAIL:
-	case CMD_PANE_MARKED:
-		if (flag == CMD_PANE_CANFAIL)
-			targetflags |= CMD_FIND_QUIET;
-		if (flag == CMD_PANE_MARKED)
-			targetflags |= CMD_FIND_DEFAULT_MARKED;
-		break;
-	default:
-		fatalx("unknown %cflag %d", c, flag);
-	}
-
-	log_debug("%s: flag %c %d %#x", __func__, c, flag, targetflags);
-	if (parent != NULL) {
-		if (c == 't')
-			current = &parent->state.tflag;
-		else if (c == 's')
-			current = &parent->state.sflag;
-	} else {
-		error = cmd_find_current(&tmp, cmdq, targetflags);
-		if (error != 0 && ~targetflags & CMD_FIND_QUIET)
-			return (-1);
-		current = &tmp;
-	}
-
-	switch (flag) {
-	case CMD_NONE:
-	case CMD_CLIENT:
-	case CMD_CLIENT_CANFAIL:
-		return (0);
-	case CMD_SESSION:
-	case CMD_SESSION_CANFAIL:
-	case CMD_SESSION_PREFERUNATTACHED:
-	case CMD_SESSION_WITHPANE:
-		error = cmd_find_target(fs, current, cmdq, target,
-		    CMD_FIND_SESSION, targetflags);
-		if (error != 0 && ~targetflags & CMD_FIND_QUIET)
-			return (-1);
-		break;
-	case CMD_MOVEW_R:
-		error = cmd_find_target(fs, current, cmdq, target,
-		    CMD_FIND_SESSION, CMD_FIND_QUIET);
-		if (error == 0)
-			break;
-		/* FALLTHROUGH */
-	case CMD_WINDOW:
-	case CMD_WINDOW_CANFAIL:
-	case CMD_WINDOW_MARKED:
-	case CMD_WINDOW_INDEX:
-		error = cmd_find_target(fs, current, cmdq, target,
-		    CMD_FIND_WINDOW, targetflags);
-		if (error != 0 && ~targetflags & CMD_FIND_QUIET)
-			return (-1);
-		break;
-	case CMD_PANE:
-	case CMD_PANE_CANFAIL:
-	case CMD_PANE_MARKED:
-		error = cmd_find_target(fs, current, cmdq, target,
-		    CMD_FIND_PANE, targetflags);
-		if (error != 0 && ~targetflags & CMD_FIND_QUIET)
-			return (-1);
-		break;
-	default:
-		fatalx("unknown %cflag %d", c, flag);
-	}
-	return (0);
-}
-
-int
-cmd_prepare_state(struct cmd *cmd, struct cmd_q *cmdq, struct cmd_q *parent)
-{
-	const struct cmd_entry		*entry = cmd->entry;
-	struct cmd_state		*state = &cmdq->state;
-	char				*tmp;
-	enum cmd_entry_flag		 flag;
-	const char			*s;
-	int				 error;
-
-	tmp = cmd_print(cmd);
-	log_debug("preparing state for %s (client %p)", tmp, cmdq->client);
-	free(tmp);
-
-	state->c = NULL;
-	cmd_find_clear_state(&state->tflag, NULL, 0);
-	cmd_find_clear_state(&state->sflag, NULL, 0);
-
-	flag = cmd->entry->cflag;
-	if (flag == CMD_NONE) {
-		flag = cmd->entry->tflag;
-		if (flag == CMD_CLIENT || flag == CMD_CLIENT_CANFAIL)
-			s = args_get(cmd->args, 't');
-		else
-			s = NULL;
-	} else
-		s = args_get(cmd->args, 'c');
-	switch (flag) {
-	case CMD_CLIENT:
-		state->c = cmd_find_client(cmdq, s, 0);
-		if (state->c == NULL)
-			return (-1);
-		break;
-	default:
-		state->c = cmd_find_client(cmdq, s, 1);
-		break;
-	}
-
-	s = args_get(cmd->args, 't');
-	log_debug("preparing -t state: target %s", s == NULL ? "none" : s);
-
-	error = cmd_prepare_state_flag('t', s, entry->tflag, cmdq, parent);
-	if (error != 0)
-		return (error);
-
-	s = args_get(cmd->args, 's');
-	log_debug("preparing -s state: target %s", s == NULL ? "none" : s);
-
-	error = cmd_prepare_state_flag('s', s, entry->sflag, cmdq, parent);
-	if (error != 0)
-		return (error);
-
-	return (0);
 }
 
 char *
@@ -575,6 +503,83 @@ cmd_print(struct cmd *cmd)
 	return (out);
 }
 
+struct cmd_list *
+cmd_list_new(void)
+{
+	struct cmd_list	*cmdlist;
+
+	cmdlist = xcalloc(1, sizeof *cmdlist);
+	cmdlist->references = 1;
+	cmdlist->group = cmd_list_next_group++;
+	TAILQ_INIT(&cmdlist->list);
+	return (cmdlist);
+}
+
+void
+cmd_list_append(struct cmd_list *cmdlist, struct cmd *cmd)
+{
+	cmd->group = cmdlist->group;
+	TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
+}
+
+void
+cmd_list_move(struct cmd_list *cmdlist, struct cmd_list *from)
+{
+	struct cmd	*cmd, *cmd1;
+
+	TAILQ_FOREACH_SAFE(cmd, &from->list, qentry, cmd1) {
+		TAILQ_REMOVE(&from->list, cmd, qentry);
+		TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
+	}
+	cmdlist->group = cmd_list_next_group++;
+}
+
+void
+cmd_list_free(struct cmd_list *cmdlist)
+{
+	struct cmd	*cmd, *cmd1;
+
+	if (--cmdlist->references != 0)
+		return;
+
+	TAILQ_FOREACH_SAFE(cmd, &cmdlist->list, qentry, cmd1) {
+		TAILQ_REMOVE(&cmdlist->list, cmd, qentry);
+		cmd_free(cmd);
+	}
+
+	free(cmdlist);
+}
+
+char *
+cmd_list_print(struct cmd_list *cmdlist, int escaped)
+{
+	struct cmd	*cmd;
+	char		*buf, *this;
+	size_t		 len;
+
+	len = 1;
+	buf = xcalloc(1, len);
+
+	TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
+		this = cmd_print(cmd);
+
+		len += strlen(this) + 4;
+		buf = xrealloc(buf, len);
+
+		strlcat(buf, this, len);
+		if (TAILQ_NEXT(cmd, qentry) != NULL) {
+			if (escaped)
+				strlcat(buf, " \\; ", len);
+			else
+				strlcat(buf, " ; ", len);
+		}
+
+		free(this);
+	}
+
+	return (buf);
+}
+
 /* Adjust current mouse position for a pane. */
 int
 cmd_mouse_at(struct window_pane *wp, struct mouse_event *m, u_int *xp,
@@ -583,25 +588,26 @@ cmd_mouse_at(struct window_pane *wp, struct mouse_event *m, u_int *xp,
 	u_int	x, y;
 
 	if (last) {
-		x = m->lx;
+		x = m->lx + m->ox;
-		y = m->ly;
+		y = m->ly + m->oy;
 	} else {
-		x = m->x;
+		x = m->x + m->ox;
-		y = m->y;
+		y = m->y + m->oy;
 	}
+	log_debug("%s: x=%u, y=%u%s", __func__, x, y, last ? " (last)" : "");
 
-	if (m->statusat == 0 && y > 0)
+	if (m->statusat == 0 && y >= m->statuslines)
-		y--;
+		y -= m->statuslines;
-	else if (m->statusat > 0 && y >= (u_int)m->statusat)
-		y = m->statusat - 1;
 
 	if (x < wp->xoff || x >= wp->xoff + wp->sx)
 		return (-1);
 	if (y < wp->yoff || y >= wp->yoff + wp->sy)
 		return (-1);
 
-	*xp = x - wp->xoff;
+	if (xp != NULL)
-	*yp = y - wp->yoff;
+		*xp = x - wp->xoff;
+	if (yp != NULL)
+		*yp = y - wp->yoff;
 	return (0);
 }
 
@@ -611,17 +617,22 @@ cmd_mouse_window(struct mouse_event *m, struct session **sp)
 {
 	struct session	*s;
 	struct window	*w;
+	struct winlink	*wl;
 
-	if (!m->valid || m->s == -1 || m->w == -1)
+	if (!m->valid)
 		return (NULL);
-	if ((s = session_find_by_id(m->s)) == NULL)
+	if (m->s == -1 || (s = session_find_by_id(m->s)) == NULL)
 		return (NULL);
-	if ((w = window_find_by_id(m->w)) == NULL)
+	if (m->w == -1)
-		return (NULL);
+		wl = s->curw;
-
+	else {
+		if ((w = window_find_by_id(m->w)) == NULL)
+			return (NULL);
+		wl = winlink_find_by_window(&s->windows, w);
+	}
 	if (sp != NULL)
 		*sp = s;
-	return (winlink_find_by_window(&s->windows, w));
+	return (wl);
 }
 
 /* Get current mouse pane if any. */
@@ -649,8 +660,8 @@ char *
 cmd_template_replace(const char *template, const char *s, int idx)
 {
 	char		 ch, *buf;
-	const char	*ptr;
+	const char	*ptr, *cp, quote[] = "\"\\$;";
-	int		 replaced;
+	int		 replaced, quoted;
 	size_t		 len;
 
 	if (strchr(template, '%') == NULL)
@@ -672,9 +683,17 @@ cmd_template_replace(const char *template, const char *s, int idx)
 			}
 			ptr++;
 
-			len += strlen(s);
+			quoted = (*ptr == '%');
-			buf = xrealloc(buf, len + 1);
+			if (quoted)
-			strlcat(buf, s, len + 1);
+				ptr++;
+
+			buf = xrealloc(buf, len + (strlen(s) * 3) + 1);
+			for (cp = s; *cp != '\0'; cp++) {
+				if (quoted && strchr(quote, *cp) != NULL)
+					buf[len++] = '\\';
+				buf[len++] = *cp;
+			}
+			buf[len] = '\0';
 			continue;
 		}
 		buf = xrealloc(buf, len + 2);

colour.c

@@ -48,7 +48,7 @@ colour_to_6cube(int v)
  * 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 colors (they are
+ * 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).
@@ -141,6 +141,8 @@ colour_tostring(int c)
 		return ("white");
 	case 8:
 		return ("default");
+	case 9:
+		return ("terminal");
 	case 90:
 		return ("brightblack");
 	case 91:
@@ -158,7 +160,7 @@ colour_tostring(int c)
 	case 97:
 		return ("brightwhite");
 	}
-	return (NULL);
+	return ("invalid");
 }
 
 /* Convert colour from string. */
@@ -188,6 +190,11 @@ colour_fromstring(const char *s)
 		return (n | COLOUR_FLAG_256);
 	}
 
+	if (strcasecmp(s, "default") == 0)
+		return (8);
+	if (strcasecmp(s, "terminal") == 0)
+		return (9);
+
 	if (strcasecmp(s, "black") == 0 || strcmp(s, "0") == 0)
 		return (0);
 	if (strcasecmp(s, "red") == 0 || strcmp(s, "1") == 0)
@@ -204,8 +211,6 @@ colour_fromstring(const char *s)
 		return (6);
 	if (strcasecmp(s, "white") == 0 || strcmp(s, "7") == 0)
 		return (7);
-	if (strcasecmp(s, "default") == 0 || strcmp(s, "8") == 0)
-		return (8);
 	if (strcasecmp(s, "brightblack") == 0 || strcmp(s, "90") == 0)
 		return (90);
 	if (strcasecmp(s, "brightred") == 0 || strcmp(s, "91") == 0)
@@ -225,11 +230,85 @@ colour_fromstring(const char *s)
 	return (-1);
 }
 
-/* Convert 256 colour palette to 16. */
+/* Convert 256 colour to RGB colour. */
-u_char
+int
-colour_256to16(u_char c)
+colour_256toRGB(int c)
 {
-	static const u_char table[256] = {
+	static const int table[256] = {
+		0x000000, 0x800000, 0x008000, 0x808000,
+		0x000080, 0x800080, 0x008080, 0xc0c0c0,
+		0x808080, 0xff0000, 0x00ff00, 0xffff00,
+		0x0000ff, 0xff00ff, 0x00ffff, 0xffffff,
+		0x000000, 0x00005f, 0x000087, 0x0000af,
+		0x0000d7, 0x0000ff, 0x005f00, 0x005f5f,
+		0x005f87, 0x005faf, 0x005fd7, 0x005fff,
+		0x008700, 0x00875f, 0x008787, 0x0087af,
+		0x0087d7, 0x0087ff, 0x00af00, 0x00af5f,
+		0x00af87, 0x00afaf, 0x00afd7, 0x00afff,
+		0x00d700, 0x00d75f, 0x00d787, 0x00d7af,
+		0x00d7d7, 0x00d7ff, 0x00ff00, 0x00ff5f,
+		0x00ff87, 0x00ffaf, 0x00ffd7, 0x00ffff,
+		0x5f0000, 0x5f005f, 0x5f0087, 0x5f00af,
+		0x5f00d7, 0x5f00ff, 0x5f5f00, 0x5f5f5f,
+		0x5f5f87, 0x5f5faf, 0x5f5fd7, 0x5f5fff,
+		0x5f8700, 0x5f875f, 0x5f8787, 0x5f87af,
+		0x5f87d7, 0x5f87ff, 0x5faf00, 0x5faf5f,
+		0x5faf87, 0x5fafaf, 0x5fafd7, 0x5fafff,
+		0x5fd700, 0x5fd75f, 0x5fd787, 0x5fd7af,
+		0x5fd7d7, 0x5fd7ff, 0x5fff00, 0x5fff5f,
+		0x5fff87, 0x5fffaf, 0x5fffd7, 0x5fffff,
+		0x870000, 0x87005f, 0x870087, 0x8700af,
+		0x8700d7, 0x8700ff, 0x875f00, 0x875f5f,
+		0x875f87, 0x875faf, 0x875fd7, 0x875fff,
+		0x878700, 0x87875f, 0x878787, 0x8787af,
+		0x8787d7, 0x8787ff, 0x87af00, 0x87af5f,
+		0x87af87, 0x87afaf, 0x87afd7, 0x87afff,
+		0x87d700, 0x87d75f, 0x87d787, 0x87d7af,
+		0x87d7d7, 0x87d7ff, 0x87ff00, 0x87ff5f,
+		0x87ff87, 0x87ffaf, 0x87ffd7, 0x87ffff,
+		0xaf0000, 0xaf005f, 0xaf0087, 0xaf00af,
+		0xaf00d7, 0xaf00ff, 0xaf5f00, 0xaf5f5f,
+		0xaf5f87, 0xaf5faf, 0xaf5fd7, 0xaf5fff,
+		0xaf8700, 0xaf875f, 0xaf8787, 0xaf87af,
+		0xaf87d7, 0xaf87ff, 0xafaf00, 0xafaf5f,
+		0xafaf87, 0xafafaf, 0xafafd7, 0xafafff,
+		0xafd700, 0xafd75f, 0xafd787, 0xafd7af,
+		0xafd7d7, 0xafd7ff, 0xafff00, 0xafff5f,
+		0xafff87, 0xafffaf, 0xafffd7, 0xafffff,
+		0xd70000, 0xd7005f, 0xd70087, 0xd700af,
+		0xd700d7, 0xd700ff, 0xd75f00, 0xd75f5f,
+		0xd75f87, 0xd75faf, 0xd75fd7, 0xd75fff,
+		0xd78700, 0xd7875f, 0xd78787, 0xd787af,
+		0xd787d7, 0xd787ff, 0xd7af00, 0xd7af5f,
+		0xd7af87, 0xd7afaf, 0xd7afd7, 0xd7afff,
+		0xd7d700, 0xd7d75f, 0xd7d787, 0xd7d7af,
+		0xd7d7d7, 0xd7d7ff, 0xd7ff00, 0xd7ff5f,
+		0xd7ff87, 0xd7ffaf, 0xd7ffd7, 0xd7ffff,
+		0xff0000, 0xff005f, 0xff0087, 0xff00af,
+		0xff00d7, 0xff00ff, 0xff5f00, 0xff5f5f,
+		0xff5f87, 0xff5faf, 0xff5fd7, 0xff5fff,
+		0xff8700, 0xff875f, 0xff8787, 0xff87af,
+		0xff87d7, 0xff87ff, 0xffaf00, 0xffaf5f,
+		0xffaf87, 0xffafaf, 0xffafd7, 0xffafff,
+		0xffd700, 0xffd75f, 0xffd787, 0xffd7af,
+		0xffd7d7, 0xffd7ff, 0xffff00, 0xffff5f,
+		0xffff87, 0xffffaf, 0xffffd7, 0xffffff,
+		0x080808, 0x121212, 0x1c1c1c, 0x262626,
+		0x303030, 0x3a3a3a, 0x444444, 0x4e4e4e,
+		0x585858, 0x626262, 0x6c6c6c, 0x767676,
+		0x808080, 0x8a8a8a, 0x949494, 0x9e9e9e,
+		0xa8a8a8, 0xb2b2b2, 0xbcbcbc, 0xc6c6c6,
+		0xd0d0d0, 0xdadada, 0xe4e4e4, 0xeeeeee
+	};
+
+	return (table[c & 0xff] | COLOUR_FLAG_RGB);
+}
+
+/* Convert 256 colour to 16 colour. */
+int
+colour_256to16(int c)
+{
+	static const char table[256] = {
 		 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 		 0,  4,  4,  4, 12, 12,  2,  6,  4,  4, 12, 12,  2,  2,  6,  4,
 		12, 12,  2,  2,  2,  6, 12, 12, 10, 10, 10, 10, 14, 12, 10, 10,
@@ -248,5 +327,5 @@ colour_256to16(u_char c)
 		 8,  8,  8,  8,  7,  7,  7,  7,  7,  7, 15, 15, 15, 15, 15, 15
 	};
 
-	return (table[c]);
+	return (table[c & 0xff]);
 }

compat.h

@@ -17,6 +17,15 @@
 #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
@@ -43,11 +52,13 @@
 #include <sys/filio.h>
 #endif
 
-#ifndef HAVE_BSD_TYPES
+#ifdef HAVE_ERR_H
-typedef uint8_t u_int8_t;
+#include <err.h>
-typedef uint16_t u_int16_t;
+#else
-typedef uint32_t u_int32_t;
+void	err(int, const char *, ...);
-typedef uint64_t u_int64_t;
+void	errx(int, const char *, ...);
+void	warn(const char *, ...);
+void	warnx(const char *, ...);
 #endif
 
 #ifndef HAVE_PATHS_H
@@ -56,6 +67,17 @@ typedef uint64_t u_int64_t;
 #define _PATH_DEVNULL	"/dev/null"
 #define _PATH_TTY	"/dev/tty"
 #define _PATH_DEV	"/dev/"
+#define _PATH_DEFPATH	"/usr/bin:/bin"
+#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
@@ -80,17 +102,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>
@@ -104,12 +126,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) \
@@ -196,6 +212,16 @@ typedef uint64_t u_int64_t;
 #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);
@@ -226,6 +252,21 @@ 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);
@@ -242,14 +283,22 @@ void		 setproctitle(const char *, ...);
 #endif
 
 #ifndef HAVE_B64_NTOP
-/* b64_ntop.c */
+/* base64.c */
-#undef b64_ntop /* for Cygwin */
+#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
 
@@ -264,10 +313,6 @@ 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);
@@ -279,10 +324,9 @@ int		 unsetenv(const char *);
 void		 cfmakeraw(struct termios *);
 #endif
 
-#ifndef HAVE_OPENAT
+#ifndef HAVE_FREEZERO
-/* openat.c */
+/* freezero.c */
-#define AT_FDCWD -100
+void		 freezero(void *, size_t);
-int		 openat(int, const char *, int, ...);
 #endif
 
 #ifndef HAVE_REALLOCARRAY
@@ -290,6 +334,11 @@ int		 openat(int, const char *, int, ...);
 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);
@@ -297,9 +346,7 @@ int		 utf8proc_mbtowc(wchar_t *, const char *, size_t);
 int		 utf8proc_wctomb(char *, wchar_t);
 #endif
 
-#ifdef HAVE_GETOPT
+#ifndef HAVE_GETOPT
-#include <getopt.h>
-#else
 /* getopt.c */
 extern int	BSDopterr;
 extern int	BSDoptind;

compat/asprintf.c

@@ -14,16 +14,15 @@
  * 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 <stdlib.h>
 
-#include "tmux.h"
+#include "compat.h"
+#include "xmalloc.h"
 
 int
 asprintf(char **ret, const char *fmt, ...)

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];
+	u_char input[3];
-	uint8_t output[4];
+	u_char output[4];
-	size_t i;
+	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/cfmakeraw.c

@@ -15,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

@@ -45,7 +45,7 @@
 # endif
 #endif
 
-#include "tmux.h"
+#include "compat.h"
 
 #ifndef OPEN_MAX
 # define OPEN_MAX	256

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

@@ -28,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)
@@ -61,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);
+}

compat/explicit_bzero.c

@@ -0,0 +1,15 @@
+/*	$OpenBSD: explicit_bzero.c,v 1.4 2015/08/31 02:53:57 guenther Exp $ */
+/*
+ * Public domain.
+ * Written by Matthew Dempsky.
+ */
+
+#include <string.h>
+
+#include "compat.h"
+
+void
+explicit_bzero(void *buf, size_t len)
+{
+	memset(buf, 0, len);
+}

compat/fdforkpty.c

@@ -0,0 +1,34 @@
+/*
+ * 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 <limits.h>
+
+#include "compat.h"
+
+int
+getptmfd(void)
+{
+	return (INT_MAX);
+}
+
+pid_t
+fdforkpty(__unused int ptmfd, int *master, char *name, struct termios *tio,
+    struct winsize *ws)
+{
+	return (forkpty(master, name, tio, ws));
+}

compat/fgetln.c

@@ -22,7 +22,7 @@
 #include <stdlib.h>
 #include <errno.h>
 
-#include "tmux.h"
+#include "compat.h"
 
 char *
 fgetln(FILE *fp, size_t *len)

compat/forkpty-aix.c

@@ -23,10 +23,14 @@
 #include <unistd.h>
 #include <errno.h>
 
-#include "tmux.h"
+#include "compat.h"
+
+void fatal(const char *, ...);
+void fatalx(const char *, ...);
 
 pid_t
-forkpty(int *master, unused char *name, struct termios *tio, struct winsize *ws)
+forkpty(int *master, __unused char *name, struct termios *tio,
+    struct winsize *ws)
 {
 	int	slave = -1, fd, pipe_fd[2];
 	char   *path, dummy;