Merge branch 'obsd-master'

or used to be configured. GitHub issue 4498.

.github/CONTRIBUTING.md

@@ -0,0 +1,84 @@
+## 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).
+
+- 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, macOS, 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). Please attach logs to the issue directly rather
+  than using a download site or pastebin. Put in a zip file if necessary.
+
+- 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.
+
+## What does it mean if an issue is closed?
+
+All it means is that work on the issue is not planned for the near future. See
+the issue's comments to find out if contributions would be welcome.

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: nicm
+liberapay: tmux

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/use-this-issue-template.md

@@ -0,0 +1,31 @@
+---
+name: Use this issue template
+about: Please read https://github.com/tmux/tmux/blob/master/.github/CONTRIBUTING.md
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+### 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,95 @@
+# 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, macOS 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/).
+
+To build tmux, a C compiler (for example gcc or clang), make, pkg-config and a
+suitable yacc (yacc or bison) are needed.
+
+## Installation
+
+### Binary packages
+
+Some platforms provide binary packages for tmux, although these are sometimes
+out of date. Examples are listed on
+[this page](https://github.com/tmux/tmux/wiki/Installing).
+
+### 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.
+
+For more detailed instructions on building and installing tmux, see
+[this page](https://github.com/tmux/tmux/wiki/Installing).
+
+### 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/scop/bash-completion/blob/main/completions/tmux
+
+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

.github/travis/before-install.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+
+if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+	sudo apt-get update -qq
+	sudo apt-get -y install bison \
+				autotools-dev \
+				libncurses5-dev \
+				libevent-dev \
+				pkg-config \
+				libutempter-dev \
+				build-essential
+
+	if [ "$BUILD" = "musl" -o "$BUILD" = "musl-static" ]; then
+		sudo apt-get -y install musl-dev \
+					musl-tools
+	fi
+fi
+
+if [ "$TRAVIS_OS_NAME" = "freebsd" ]; then
+	sudo pkg install -y \
+		automake \
+		libevent \
+		pkgconf
+fi

.github/travis/build-all.sh

@@ -0,0 +1,38 @@
+#!/bin/sh
+
+BUILD=$PWD/build
+
+LIBEVENT=https://github.com/libevent/libevent/releases/download/release-2.1.11-stable/libevent-2.1.11-stab\
+le.tar.gz
+NCURSES=https://ftp.gnu.org/gnu/ncurses/ncurses-6.2.tar.gz
+
+wget -4q $LIBEVENT || exit 1
+tar -zxf libevent-*.tar.gz || exit 1
+(cd libevent-*/ &&
+	 ./configure --prefix=$BUILD \
+		     --enable-shared \
+		     --disable-libevent-regress \
+		     --disable-samples &&
+	 make && make install) || exit 1
+
+wget -4q $NCURSES || exit 1
+tar -zxf ncurses-*.tar.gz || exit 1
+(cd ncurses-*/ &&
+	CPPFLAGS=-P ./configure --prefix=$BUILD \
+				--with-shared \
+				--with-termlib \
+				--without-ada \
+				--without-cxx \
+				--without-manpages \
+				--without-progs \
+				--without-tests \
+				--without-tack \
+				--disable-database \
+				--enable-termcap \
+				--enable-pc-files \
+				--with-pkg-config-libdir=$BUILD/lib/pkgconfig &&
+	 make && make install) || exit 1
+
+sh autogen.sh || exit 1
+PKG_CONFIG_PATH=$BUILD/lib/pkgconfig ./configure --prefix=$BUILD "$@"
+make && make install || (cat config.log; exit 1)

.github/travis/build.sh

@@ -0,0 +1,25 @@
+#!/bin/sh
+
+sh autogen.sh || exit 1
+case "$BUILD" in
+	static)
+		./configure --enable-static || exit 1
+		exec make
+		;;
+	all)
+		sh $(dirname $0)/build-all.sh
+		exec make
+		;;
+	musl)
+		CC=musl-gcc sh $(dirname $0)/build-all.sh
+		exec make
+		;;
+	musl-static)
+		CC=musl-gcc sh $(dirname $0)/build-all.sh --enable-static
+		exec make
+		;;
+	*)
+		./configure || exit 1
+		exec make
+		;;
+esac

.github/workflows/lock.yml

@@ -0,0 +1,34 @@
+name: 'Lock Threads'
+
+on:
+  schedule:
+    - cron: '0 0 * * *'
+  workflow_dispatch:
+
+permissions:
+  issues: write
+  pull-requests: write
+  discussions: write
+
+concurrency:
+  group: lock-threads
+
+jobs:
+  action:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dessant/lock-threads@v5
+        with:
+          github-token: ${{ github.token }}
+          issue-inactive-days: '30'
+          issue-comment: >
+            This issue has been automatically locked since there
+            has not been any recent activity after it was closed.
+          pr-inactive-days: '60'
+          pr-comment: >
+            This pull request has been automatically locked since there
+            has not been any recent activity after it was closed.
+          discussion-inactive-days: '60'
+          discussion-comment: >
+            This discussion has been automatically locked since there
+            has not been any recent activity after it was closed.

.gitignore

@@ -1,19 +1,24 @@
-*.o
-*~
-*.diff
-*.patch
 *.core
-core
-tags
+*.dSYM
+*.diff
+*.o
+*.patch
+*.swp
+*~
 .deps/
-compat/.dirstamp
-aclocal.m4
-autom4te.cache/
-config.log
-config.status
-etc/
-tmux
+.dirstamp
 Makefile
 Makefile.in
+aclocal.m4
+autom4te.cache/
+cmd-parse.c
+compat/.dirstamp
+config.log
+config.status
 configure
+core
+etc/
+fuzz/*-fuzzer
+tags
+tmux
 tmux.1.*

.mailmap

@@ -22,6 +22,7 @@ Pierre-Yves Ritschard	<pyr@openbsd.org> pyr <pyr>
 Ray Lai			<ray@openbsd.org> ray <ray>
 Ryan McBride		<mcbride@openbsd.org> mcbride <mcbride>
 Sebastian Benoit	<benno@openbsd.org> benno <benno>
+Sebastien Marie		<semarie@openbsd.org> semarie <semarie>
 Stefan Sperling		<stsp@openbsd.org> stsp <stsp>
 Stuart Henderson	<sthen@openbsd.org> sthen <sthen>
 Ted Unangst		<tedu@openbsd.org> tedu <tedu>

.travis.yml

@@ -1,10 +1,88 @@
 language: c
-matrix:
-    include:
-        - compiler: gcc
-        - compiler: clang
-          env: CFLAGS="-g -O2"
+
+os:
+  - linux
+  - freebsd
+  - osx
+
+compiler:
+  - gcc
+  - clang
+
+arch:
+  - amd64
+  - arm64
+
+env:
+  - BUILD=
+  - BUILD=static
+  - BUILD=all
+  - BUILD=musl
+  - BUILD=musl-static
+
+jobs:
+  exclude:
+    # Static builds are broken on OS X (by Apple)
+    - os: osx
+      compiler: gcc
+      env: BUILD=static
+    - os: osx
+      compiler: clang
+      env: BUILD=static
+    # No musl on FreeBSD
+    - os: freebsd
+      compiler: gcc
+      env: BUILD=musl
+    - os: freebsd
+      compiler: clang
+      env: BUILD=musl
+    - os: freebsd
+      compiler: gcc
+      env: BUILD=musl-static
+    - os: freebsd
+      compiler: clang
+      env: BUILD=musl-static
+    # No musl on OS X
+    - os: osx
+      compiler: gcc
+      env: BUILD=musl
+    - os: osx
+      compiler: clang
+      env: BUILD=musl
+    - os: osx
+      compiler: gcc
+      env: BUILD=musl-static
+    - os: osx
+      compiler: clang
+      env: BUILD=musl-static
+    # arm64 doesn't link ncurses
+    - os: linux
+      compiler: gcc
+      arch: arm64
+      env: BUILD=all
+    - os: linux
+      compiler: clang
+      arch: arm64
+      env: BUILD=all
+    - os: linux
+      compiler: gcc
+      arch: arm64
+      env: BUILD=musl
+    - os: linux
+      compiler: clang
+      arch: arm64
+      env: BUILD=musl
+    - os: linux
+      compiler: gcc
+      arch: arm64
+      env: BUILD=musl-static
+    - os: linux
+      compiler: clang
+      arch: arm64
+      env: BUILD=musl-static
+
 before_install:
-    - sudo apt-get update -qq
-    - sudo apt-get -y install debhelper autotools-dev dh-autoreconf file libncurses5-dev libevent-dev pkg-config libutempter-dev build-essential
-script: (CFLAGS= ./autogen.sh) && ./configure --enable-debug && make
+  - sh .github/travis/before-install.sh
+
+script:
+  - sh .github/travis/build.sh

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
-license. Files under examples/ remain copyright their authors unless otherwise
-stated in the file but permission has been received to distribute them with
-tmux. All other files have a license and copyright notice at their start,
-typically:
+The README, CHANGES, FAQ and TODO files are licensed under the ISC license. 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

@@ -1,62 +1,74 @@
-# Makefile.am
-
 # 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] \
-	array.h compat.h tmux.h osdep-*.c xmalloc.h mdoc2man.awk tmux.1
-dist-hook:
-	make clean
-	grep "^#found_debug=" configure
+	CHANGES README README.ja COPYING example_tmux.conf \
+	osdep-*.c mdoc2man.awk tmux.1
+dist_EXTRA_tmux_SOURCES = compat/*.[ch]
 
 # Preprocessor flags.
-CPPFLAGS += @XOPEN_DEFINES@ -DTMUX_CONF="\"$(sysconfdir)/tmux.conf\""
+AM_CPPFLAGS += @XOPEN_DEFINES@ \
+	-DTMUX_VERSION='"@VERSION@"' \
+	-DTMUX_CONF='"$(sysconfdir)/tmux.conf:~/.tmux.conf:$$XDG_CONFIG_HOME/tmux/tmux.conf:~/.config/tmux/tmux.conf"' \
+	-DTMUX_LOCK_CMD='"@DEFAULT_LOCK_CMD@"' \
+	-DTMUX_TERM='"@DEFAULT_TERM@"'
 
-# glibc as usual does things ass-backwards and hides useful things by default,
-# so everyone has to add this.
-if IS_GLIBC
-CFLAGS += -D_GNU_SOURCE
-endif
+# Additional object files.
+LDADD = $(LIBOBJS)
 
 # Set flags for gcc.
 if IS_GCC
-CFLAGS += -std=gnu99 -O2
+AM_CFLAGS += -std=gnu99 -O2
 if IS_DEBUG
-CFLAGS += -g
-CFLAGS += -Wno-long-long -Wall -W -Wnested-externs -Wformat=2
-CFLAGS += -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations
-CFLAGS += -Wwrite-strings -Wshadow -Wpointer-arith -Wsign-compare
-CFLAGS += -Wundef -Wbad-function-cast -Winline -Wcast-align
-CFLAGS += -Wdeclaration-after-statement -Wno-pointer-sign -Wno-attributes
-CPPFLAGS += -DDEBUG
+AM_CFLAGS += -g
+AM_CFLAGS += -Wno-long-long -Wall -W -Wformat=2
+AM_CFLAGS += -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations
+AM_CFLAGS += -Wwrite-strings -Wshadow -Wpointer-arith -Wsign-compare
+AM_CFLAGS += -Wundef -Wbad-function-cast -Winline -Wcast-align
+AM_CFLAGS += -Wdeclaration-after-statement -Wno-pointer-sign -Wno-attributes
+AM_CFLAGS += -Wno-unused-result -Wno-format-y2k
+if IS_DARWIN
+AM_CFLAGS += -Wno-deprecated-declarations -Wno-cast-align -Wno-macro-redefined
 endif
-if IS_COVERAGE
-CFLAGS += -g -O0 --coverage
-LDFLAGS += --coverage
+AM_CPPFLAGS += -DDEBUG
 endif
-CPPFLAGS += -iquote.
+AM_CPPFLAGS += -iquote.
 endif
 
 # Set flags for Solaris.
 if IS_SUNOS
 if IS_GCC
-CPPFLAGS += -D_XPG6 -D__EXTENSIONS__ -D_POSIX_PTHREAD_SEMANTICS
+AM_CPPFLAGS += -D_XPG6
 else
-CPPFLAGS += -D_XPG4_2 -D__EXTENSIONS__ -D_POSIX_PTHREAD_SEMANTICS
+AM_CPPFLAGS += -D_XPG4_2
 endif
 endif
 
 # Set flags for Sun CC.
 if IS_SUNCC
-CFLAGS += -erroff=E_EMPTY_DECLARATION
+AM_CFLAGS += -erroff=E_EMPTY_DECLARATION
 endif
 
 # Set _LINUX_SOURCE_COMPAT for AIX for malloc(0).
 if IS_AIX
-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
+
+# Set flags for Haiku.
+if IS_HAIKU
+AM_CPPFLAGS += -D_BSD_SOURCE
+endif
+
+# Set flags for Cygwin.
+if IS_CYGWIN
+AM_CPPFLAGS += -DTMUX_SOCK_PERM=0
 endif
 
 # List of sources.
@@ -70,18 +82,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 \
@@ -94,12 +104,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 \
@@ -107,6 +117,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 \
@@ -116,16 +127,16 @@ dist_tmux_SOURCES = \
 	cmd-select-pane.c \
 	cmd-select-window.c \
 	cmd-send-keys.c \
+	cmd-server-access.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-show-prompt-history.c \
 	cmd-source-file.c \
 	cmd-split-window.c \
-	cmd-string.c \
 	cmd-swap-pane.c \
 	cmd-swap-window.c \
 	cmd-switch-client.c \
@@ -133,13 +144,17 @@ dist_tmux_SOURCES = \
 	cmd-wait-for.c \
 	cmd.c \
 	colour.c \
-	control.c \
+	compat.h \
 	control-notify.c \
+	control.c \
 	environ.c \
+	file.c \
 	format.c \
+	format-draw.c \
+	grid-reader.c \
 	grid-view.c \
 	grid.c \
-	hooks.c \
+	hyperlinks.c \
 	input-keys.c \
 	input.c \
 	job.c \
@@ -149,95 +164,73 @@ 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 \
+	popup.c \
 	proc.c \
+	regsub.c \
 	resize.c \
 	screen-redraw.c \
 	screen-write.c \
 	screen.c \
+	server-acl.c \
 	server-client.c \
 	server-fn.c \
 	server.c \
 	session.c \
-	signal.c \
+	spawn.c \
 	status.c \
 	style.c \
 	tmux.c \
+	tmux.h \
+	tmux-protocol.h \
 	tty-acs.c \
+	tty-features.c \
 	tty-keys.c \
 	tty-term.c \
 	tty.c \
+	utf8-combined.c \
 	utf8.c \
-	window-choose.c \
+	window-buffer.c \
+	window-client.c \
 	window-clock.c \
 	window-copy.c \
+	window-customize.c \
+	window-tree.c \
 	window.c \
 	xmalloc.c \
-	xterm-keys.c
+	xmalloc.h
 nodist_tmux_SOURCES = osdep-@PLATFORM@.c
 
-# Pile in all the compat/ stuff that is needed.
-if NO_FORKPTY
+# Add compat file for forkpty.
+if NEED_FORKPTY
 nodist_tmux_SOURCES += compat/forkpty-@PLATFORM@.c
 endif
-if NO_IMSG
-nodist_tmux_SOURCES += compat/imsg.c compat/imsg-buffer.c
+
+# Add compat file for systemd.
+if HAVE_SYSTEMD
+nodist_tmux_SOURCES += compat/systemd.c
 endif
-if NO_CLOSEFROM
-nodist_tmux_SOURCES += compat/closefrom.c
+
+# Add compat file for utf8proc.
+if HAVE_UTF8PROC
+nodist_tmux_SOURCES += compat/utf8proc.c
 endif
-if NO_DAEMON
-nodist_tmux_SOURCES += compat/daemon.c
+
+# Enable sixel support.
+if ENABLE_SIXEL
+dist_tmux_SOURCES += image.c image-sixel.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
+
+if NEED_FUZZING
+check_PROGRAMS = fuzz/input-fuzzer
+fuzz_input_fuzzer_LDFLAGS = $(FUZZING_LIBS)
+fuzz_input_fuzzer_LDADD = $(LDADD) $(tmux_OBJECTS)
 endif
 
 # Install tmux.1 in the right format.
@@ -247,7 +240,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,87 @@
 Welcome to tmux!
 
-tmux is a "terminal multiplexer", it enables a number of terminals (or windows)
-to be accessed and controlled from a single terminal. tmux is intended to be a
-simple, modern, BSD-licensed alternative to programs such as GNU screen.
+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.
+This release runs on OpenBSD, FreeBSD, NetBSD, Linux, macOS 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/
+
+To build tmux, a C compiler (for example gcc or clang), make, pkg-config and a
+suitable yacc (yacc or bison) are needed.
+
+* 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
-installed. Run configure with --disable-utempter to disable this.
+tmux can use the utempter library to update utmp(5), if it is installed - run
+configure with --enable-utempter to enable this.
 
-To get and build the latest from version control:
+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
+	$ sudo make install
 
-For more information see http://git-scm.com. Patches should be sent by email to
-the mailing list at tmux-users@googlegroups.com.
-
-For documentation on using tmux, see the tmux.1 manpage. It can be viewed from
-the source tree with:
-
-	$ nroff -mdoc tmux.1|less
-
-Some common questions are answered in the FAQ file and a more extensive (but
-slightly out of date) guide is available in the OpenBSD FAQ at
-http://www.openbsd.org/faq/faq7.html#tmux. A rough todo list is in the TODO
-file and 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/przepompownia/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
+* Contributing
 
 Bug reports, feature suggestions and especially code contributions are most
 welcome. Please send by email to:
 
 	tmux-users@googlegroups.com
 
-This file and the CHANGES, FAQ, SYNCING and TODO files are licensed under the
-ISC license. All other files have a license and copyright notice at their start.
+Or open a GitHub issue or pull request.
 
--- 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.
+
+Other documentation is available in the wiki:
+
+	https://github.com/tmux/tmux/wiki
+
+Also see the tmux FAQ at:
+
+	https://github.com/tmux/tmux/wiki/FAQ
+
+A bash(1) completion file is at:
+
+	https://github.com/scop/bash-completion/blob/main/completions/tmux
+
+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、macOS、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/scop/bash-completion/blob/main/completions/tmux
+
+「-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

@@ -1,17 +1,17 @@
 Preamble
 ========
 
-Tmux portable relies on  repositories "tmux" and "tmux-openbsd".
+Tmux portable relies on  repositories "tmux" and "tmux-obsd".
 Here's a description of them:
 
 * "tmux" is the portable version, the one which contains code for other
   operating systems, and autotools, etc., which isn't found or needed in the
   OpenBSD base system.
 
-* "tmux-openbsd" is the version of tmux in OpenBSD base system which provides
+* "tmux-obsd" is the version of tmux in OpenBSD base system which provides
   the basis of the portable tmux version.
 
-Note:  The "tmux-openbsd" repository is actually handled by "git cvsimport"
+Note:  The "tmux-obsd" repository is actually handled by "git cvsimport"
 running at 15 minute intervals, so a commit made to OpenBSD's tmux CVS
 repository will take at least that long to appear in this git repository.
 (It might take longer, depending on the CVS mirror used to import the
@@ -34,11 +34,11 @@ this information has ever been set before.
 Cloning repositories
 ====================
 
-This involves having both tmux and tmux-openbsd cloned, as in:
+This involves having both tmux and tmux-obsd cloned, as in:
 
 % cd /some/where/useful
 % git clone https://github.com/tmux/tmux.git
-% git clone https://github.com/ThomasAdam/tmux-openbsd.git
+% git clone https://github.com/ThomasAdam/tmux-obsd.git
 
 Note that you do not need additional checkouts to manage the sync -- an
 existing clone of either repositories will suffice.  So if you already have
@@ -47,30 +47,30 @@ these checkouts existing, skip that.
 Adding in git-remotes
 =====================
 
-Because the portable "tmux" git repository and the "tmux-openbsd"
+Because the portable "tmux" git repository and the "tmux-obsd"
 repository do not inherently share any history between each other, the
 history has been faked between them.  This "faking of history" is something
 which has to be told to git for the purposes of comparing the "tmux" and
-"tmux-openbsd" repositories for syncing.  To do this, we must reference the
-clone of the "tmux-openbsd" repository from the "tmux" repository, as
+"tmux-obsd" repositories for syncing.  To do this, we must reference the
+clone of the "tmux-obsd" repository from the "tmux" repository, as
 shown by the following command:
 
 % cd /path/to/tmux
-% git remote add obsd-tmux file:///path/to/tmux-openbsd
+% git remote add obsd-tmux file:///path/to/tmux-obsd
 
 So that now, the remote "obsd-tmux" can be used to reference branches and
-commits from the "tmux-openbsd" repository, but from the context of the
+commits from the "tmux-obsd" repository, but from the context of the
 portable "tmux" repository, which makes sense because it's the "tmux"
 repository which will have the updates applied to them.
 
 Fetching updates
 ================
 
-To ensure the latest commits from "tmux-openbsd" can be found from within
-"tmux", we have to ensure the "master" branch from "tmux-openbsd" is
+To ensure the latest commits from "tmux-obsd" can be found from within
+"tmux", we have to ensure the "master" branch from "tmux-obsd" is
 up-to-date first, and then reference that update in "tmux", as in:
 
-% cd /path/to/tmux-openbsd
+% cd /path/to/tmux-obsd
 % git checkout master
 % git pull
 
@@ -82,17 +82,17 @@ Then back in "tmux":
 Creating the necessary branches
 ===============================
 
-Now that "tmux" can see commits and branches from "tmux-openbsd" by way
+Now that "tmux" can see commits and branches from "tmux-obsd" by way
 of the remote name "obsd-tmux", we can now create the master branch from
-"tmux-openbsd" in the "tmux" repository:
+"tmux-obsd" in the "tmux" repository:
 
 % git checkout -b obsd-master obsd-tmux/master
 
 Adding in the fake history points
-================================= 
+=================================
 
 To tie both the "master" branch from "tmux" and the "obsd-master"
-branch from "tmux-openbsd" together, the fake history points added to the
+branch from "tmux-obsd" together, the fake history points added to the
 "tmux" repository need to be added.  To do this, we must add an
 additional refspec line, as in:
 
@@ -115,7 +115,7 @@ From there, merge the result in, fixing up any conflicts which might arise.
 
 % git merge obsd-master
 
-Then ensure things look correct by BULDING the result of that sync:
+Then ensure things look correct by BUILDING the result of that sync:
 
 % make clean && ./autogen.sh && ./configure && make
 
@@ -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
-   don't have debugging enabled, otherwise make(1) aborts when
-   preparing the distribution.
-
-2. Update and commit README and CHANGES.  The former should be checked for
+1. Update and commit README and CHANGES.  The former should be checked for
    anything outdated and updated with a list of things that might break
    upgrades and the latter should mention all the major changes since
    the last version.
 
+2. Make sure configure.ac has the new version number.
+
 3. Tag with:
 
    % git tag -a 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
-   the Makefile.  Commit it, and run 'make' to replace %%VERSION%%.  Push
-   the result out.
+6. Clone the tmux.github.io repository, and change the RELEASE version in the
+   Makefile.  Commit it, and run 'make' to replace %%RELEASE%%.  Push the
+   result out.
 
-8. Bump version in tmu/tmux.git configure.ac and uncomment "found_debug=yes" to
-   create a debug build by default.
+7. Change version back to master in configure.ac.

TODO

@@ -1,139 +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
-
-- 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)
-
-- hooks!
-
-- 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 seach for "foobar"
-          then it should be found even if it is now "foo\nbar" (if the WRAP flag
-          is set on the line)
-	* {} to go to next/previous blank line in copy mode
-
-- 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
-	* optimize pane redraws, 20120318184853.GK10965@yelena.nicm.ath.cx
-
-- miscellaneous
-	* way to keep a job running just read its last line of output for #()
-	* link panes into multiple windows
-	* 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

@@ -18,89 +18,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 *);
-int	alerts_enabled(struct window *, int);
-void	alerts_callback(int, short, void *);
-void	alerts_reset(struct window *);
+static void	alerts_timer(int, short, void *);
+static int	alerts_enabled(struct window *, int);
+static void	alerts_callback(int, short, void *);
+static void	alerts_reset(struct window *);
 
-void	alerts_run_hook(struct session *, struct winlink *, int);
-int	alerts_check_all(struct session *, struct winlink *);
-int	alerts_check_bell(struct session *, struct winlink *);
-int	alerts_check_activity(struct session *, struct winlink *);
-int	alerts_check_silence(struct session *, struct winlink *);
-void	alerts_ring_bell(struct session *);
+static int	alerts_action_applies(struct winlink *, const char *);
+static int	alerts_check_all(struct window *);
+static int	alerts_check_bell(struct window *);
+static int	alerts_check_activity(struct window *);
+static int	alerts_check_silence(struct window *);
+static void	alerts_set_message(struct winlink *, const char *,
+		    const char *);
 
-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 session	*s;
-	struct winlink	*wl;
-	int		 flags, alerts;
+	struct window	*w, *w1;
+	int		 alerts;
 
-	RB_FOREACH(w, windows, &windows) {
-		RB_FOREACH(s, sessions, &sessions) {
-			RB_FOREACH(wl, winlinks, &s->windows) {
-				if (wl->window != w)
-					continue;
-				flags = w->flags;
+	TAILQ_FOREACH_SAFE(w, &alerts_list, alerts_entry, w1) {
+		alerts = alerts_check_all(w);
+		log_debug("@%u alerts check, alerts %#x", w->id, alerts);
 
-				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, "
-				    "flags %#x", s->name, wl->idx, w->id,
-				    alerts, flags);
-			}
-		}
+		w->flags &= ~WINDOW_ALERTFLAGS;
+		window_remove_ref(w, __func__);
 	}
 	alerts_fired = 0;
 }
 
-void
-alerts_run_hook(struct session *s, struct winlink *wl, int flags)
+static int
+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)
-		hooks_run(s->hooks, NULL, &fs, "alert-bell");
-	if (flags & WINDOW_SILENCE)
-		hooks_run(s->hooks, NULL, &fs, "alert-silence");
-	if (flags & WINDOW_ACTIVITY)
-		hooks_run(s->hooks, NULL, &fs, "alert-activity");
+	action = options_get_number(wl->session->options, name);
+	if (action == ALERT_ANY)
+		return (1);
+	if (action == ALERT_CURRENT)
+		return (wl == wl->session->curw);
+	if (action == ALERT_OTHER)
+		return (wl != wl->session->curw);
+	return (0);
 }
 
-int
-alerts_check_all(struct session *s, struct winlink *wl)
+static int
+alerts_check_all(struct window *w)
 {
 	int	alerts;
 
-	alerts  = alerts_check_bell(s, wl);
-	alerts |= alerts_check_activity(s, wl);
-	alerts |= alerts_check_silence(s, wl);
-	if (alerts != 0) {
-		alerts_run_hook(s, wl, alerts);
-		server_status_session(s);
-	}
-
+	alerts	= alerts_check_bell(w);
+	alerts |= alerts_check_activity(w);
+	alerts |= alerts_check_silence(w);
 	return (alerts);
 }
 
@@ -110,14 +105,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)
-		return (1);
+	if (flags & WINDOW_BELL) {
+		if (options_get_number(w->options, "monitor-bell"))
+			return (1);
+	}
 	if (flags & WINDOW_ACTIVITY) {
 		if (options_get_number(w->options, "monitor-activity"))
 			return (1);
@@ -138,11 +135,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,17 +157,21 @@ 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 (!alerts_fired) {
+	if ((w->flags & flags) != flags) {
 		w->flags |= flags;
 		log_debug("@%u alerts flags added %#x", w->id, flags);
+	}
 
-		if (alerts_enabled(w, flags)) {
+	if (alerts_enabled(w, flags)) {
+		if (!w->alerts_queued) {
+			w->alerts_queued = 1;
+			TAILQ_INSERT_TAIL(&alerts_list, w, alerts_entry);
+			window_add_ref(w, __func__);
+		}
+
+		if (!alerts_fired) {
 			log_debug("alerts check queued (by @%u)", w->id);
 			event_once(-1, EV_TIMEOUT, alerts_callback, NULL, NULL);
 			alerts_fired = 1;
@@ -175,120 +179,147 @@ alerts_queue(struct window *w, int flags)
 	}
 }
 
-int
-alerts_check_bell(struct session *s, struct winlink *wl)
+static int
+alerts_check_bell(struct window *w)
 {
-	struct client	*c;
-	struct window	*w = wl->window;
-	int		 action, visual;
+	struct winlink	*wl;
+	struct session	*s;
 
-	if (!(w->flags & WINDOW_BELL))
+	if (~w->flags & WINDOW_BELL)
 		return (0);
-	if (s->curw != wl) {
-		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)
+	if (!options_get_number(w->options, "monitor-bell"))
 		return (0);
 
-	visual = options_get_number(s->options, "visual-bell");
-	TAILQ_FOREACH(c, &clients, entry) {
-		if (c->session != s || c->flags & CLIENT_CONTROL)
-			continue;
-		if (!visual) {
-			if ((action == BELL_CURRENT &&
-			    c->session->curw->window == w) ||
-			    (action == BELL_OTHER &&
-			    c->session->curw->window != w) ||
-			    action == BELL_ANY)
-				tty_putcode(&c->tty, TTYC_BEL);
-			continue;
+	TAILQ_FOREACH(wl, &w->winlinks, wentry)
+		wl->session->flags &= ~SESSION_ALERTED;
+
+	TAILQ_FOREACH(wl, &w->winlinks, wentry) {
+		/*
+		 * Bells are allowed even if there is an existing bell (so do
+		 * not check WINLINK_BELL).
+		 */
+		s = wl->session;
+		if (s->curw != wl || s->attached == 0) {
+			wl->flags |= WINLINK_BELL;
+			server_status_session(s);
 		}
-		if (action == BELL_CURRENT && c->session->curw->window == w)
-			status_message_set(c, "Bell in current window");
-		else if (action == BELL_ANY || (action == BELL_OTHER &&
-		    c->session->curw->window != w))
-			status_message_set(c, "Bell in window %d", wl->idx);
+		if (!alerts_action_applies(wl, "bell-action"))
+			continue;
+		notify_winlink("alert-bell", wl);
+
+		if (s->flags & SESSION_ALERTED)
+			continue;
+		s->flags |= SESSION_ALERTED;
+
+		alerts_set_message(wl, "Bell", "visual-bell");
 	}
 
 	return (WINDOW_BELL);
 }
 
-int
-alerts_check_activity(struct session *s, struct winlink *wl)
+static int
+alerts_check_activity(struct window *w)
 {
-	struct client	*c;
-	struct window	*w = wl->window;
+	struct winlink	*wl;
+	struct session	*s;
 
-	if (s->curw->window == w)
-		w->flags &= ~WINDOW_ACTIVITY;
-
-	if (!(w->flags & WINDOW_ACTIVITY) || wl->flags & WINLINK_ACTIVITY)
+	if (~w->flags & WINDOW_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"))
-		alerts_ring_bell(s);
-	wl->flags |= WINLINK_ACTIVITY;
+	TAILQ_FOREACH(wl, &w->winlinks, wentry)
+		wl->session->flags &= ~SESSION_ALERTED;
 
-	if (options_get_number(s->options, "visual-activity")) {
-		TAILQ_FOREACH(c, &clients, entry) {
-			if (c->session != s)
-				continue;
-			status_message_set(c, "Activity in window %d", wl->idx);
+	TAILQ_FOREACH(wl, &w->winlinks, wentry) {
+		if (wl->flags & WINLINK_ACTIVITY)
+			continue;
+		s = wl->session;
+		if (s->curw != wl || s->attached == 0) {
+			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
-alerts_check_silence(struct session *s, struct winlink *wl)
+static int
+alerts_check_silence(struct window *w)
 {
-	struct client	*c;
-	struct window	*w = wl->window;
+	struct winlink	*wl;
+	struct session	*s;
 
-	if (s->curw->window == w)
-		w->flags &= ~WINDOW_SILENCE;
-
-	if (!(w->flags & WINDOW_SILENCE) || wl->flags & WINLINK_SILENCE)
+	if (~w->flags & WINDOW_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"))
-		alerts_ring_bell(s);
-	wl->flags |= WINLINK_SILENCE;
+	TAILQ_FOREACH(wl, &w->winlinks, wentry)
+		wl->session->flags &= ~SESSION_ALERTED;
 
-	if (options_get_number(s->options, "visual-silence")) {
-		TAILQ_FOREACH(c, &clients, entry) {
-			if (c->session != s)
-				continue;
-			status_message_set(c, "Silence in window %d", wl->idx);
+	TAILQ_FOREACH(wl, &w->winlinks, wentry) {
+		if (wl->flags & WINLINK_SILENCE)
+			continue;
+		s = wl->session;
+		if (s->curw != wl || s->attached == 0) {
+			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
-alerts_ring_bell(struct session *s)
+static void
+alerts_set_message(struct winlink *wl, const char *type, const char *option)
 {
 	struct client	*c;
+	int		 visual;
 
+	/*
+	 * We have found an alert (bell, activity or silence), so we need to
+	 * pass it on to the user. For each client attached to this session,
+	 * decide whether a bell, message or both is needed.
+	 *
+	 * If visual-{bell,activity,silence} is on, then a message is
+	 * substituted for a bell; if it is off, a bell is sent as normal; both
+	 * mean both a bell and message is sent.
+	 */
+
+	visual = options_get_number(wl->session->options, option);
 	TAILQ_FOREACH(c, &clients, entry) {
-		if (c->session == 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, -1, 1, 0, 0,
+			    "%s in current window", type);
+		} else {
+			status_message_set(c, -1, 1, 0, 0,
+			    "%s in window %d", type, wl->idx);
+		}
 	}
 }

array.h

@@ -1,120 +0,0 @@
-/* $OpenBSD$ */
-
-/*
- * Copyright (c) 2006 Nicholas Marriott <nicholas.marriott@gmail.com>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
- * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef ARRAY_H
-#define ARRAY_H
-
-#define ARRAY_INITIALIZER { NULL, 0, 0 }
-
-#define ARRAY_DECL(n, c)						\
-	struct n {							\
-		c	*list;						\
-		u_int	 num;						\
-		size_t	 space;						\
-	}
-
-#define ARRAY_ITEM(a, i) ((a)->list[i])
-#define ARRAY_ITEMSIZE(a) (sizeof *(a)->list)
-#define ARRAY_INITIALSPACE(a) (10 * ARRAY_ITEMSIZE(a))
-
-#define ARRAY_ENSURE(a, n) do {						\
-	if (UINT_MAX - (n) < (a)->num)					\
-		fatalx("number too big");				\
-	if (SIZE_MAX / ((a)->num + (n)) < ARRAY_ITEMSIZE(a))		\
-		fatalx("size too big");					\
-	if ((a)->space == 0) {						\
-	       	(a)->space = ARRAY_INITIALSPACE(a);			\
-		(a)->list = xrealloc((a)->list, (a)->space);		\
-	}								\
-	while ((a)->space <= ((a)->num + (n)) * ARRAY_ITEMSIZE(a)) {	\
-		(a)->list = xreallocarray((a)->list, 2, (a)->space);	\
-		(a)->space *= 2;					\
-	}								\
-} while (0)
-
-#define ARRAY_EMPTY(a) (((void *) (a)) == NULL || (a)->num == 0)
-#define ARRAY_LENGTH(a) ((a)->num)
-#define ARRAY_DATA(a) ((a)->list)
-
-#define ARRAY_FIRST(a) ARRAY_ITEM(a, 0)
-#define ARRAY_LAST(a) ARRAY_ITEM(a, (a)->num - 1)
-
-#define ARRAY_INIT(a) do {						\
-	(a)->num = 0;							\
-	(a)->list = NULL;		 				\
-	(a)->space = 0;							\
-} while (0)
-#define ARRAY_CLEAR(a) do {						\
-	(a)->num = 0;							\
-} while (0)
-
-#define ARRAY_SET(a, i, s) do {						\
-	(a)->list[i] = s;						\
-} while (0)
-
-#define ARRAY_ADD(a, s) do {						\
-	ARRAY_ENSURE(a, 1);						\
-	(a)->list[(a)->num] = s;					\
-	(a)->num++;							\
-} while (0)
-#define ARRAY_INSERT(a, i, s) do {					\
-	ARRAY_ENSURE(a, 1);						\
-	if ((i) < (a)->num) {						\
-		memmove((a)->list + (i) + 1, (a)->list + (i), 		\
-		    ARRAY_ITEMSIZE(a) * ((a)->num - (i)));		\
-	}								\
-	(a)->list[i] = s;						\
-	(a)->num++;							\
-} while (0)
-#define ARRAY_REMOVE(a, i) do {						\
-	if ((i) < (a)->num - 1) {					\
-		memmove((a)->list + (i), (a)->list + (i) + 1, 		\
-		    ARRAY_ITEMSIZE(a) * ((a)->num - (i) - 1));		\
-	}								\
-	(a)->num--;							\
-	if ((a)->num == 0)						\
-		ARRAY_FREE(a);						\
-} while (0)
-
-#define ARRAY_EXPAND(a, n) do {						\
-	ARRAY_ENSURE(a, n);						\
-	(a)->num += n;							\
-} while (0)
-#define ARRAY_TRUNC(a, n) do {						\
-	if ((a)->num > n)						\
-		(a)->num -= n;				       		\
-	else								\
-		ARRAY_FREE(a);						\
-} while (0)
-
-#define ARRAY_CONCAT(a, b) do {						\
-	ARRAY_ENSURE(a, (b)->num);					\
-	memcpy((a)->list + (a)->num, (b)->list, (b)->num * ARRAY_ITEMSIZE(a)); \
-	(a)->num += (b)->num;						\
-} while (0)
-
-#define ARRAY_FREE(a) do {						\
-	free((a)->list);						\
-	ARRAY_INIT(a);							\
-} while (0)
-#define ARRAY_FREEALL(a) do {						\
-	ARRAY_FREE(a);							\
-	free(a);							\
-} while (0)
-
-#endif

attributes.c

@@ -23,22 +23,29 @@
 #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",
-		attr & GRID_ATTR_BRIGHT ? "bright," : "",
-		attr & GRID_ATTR_DIM ? "dim," : "",
-		attr & GRID_ATTR_UNDERSCORE ? "underscore," : "",
-		attr & GRID_ATTR_BLINK ? "blink," : "",
-		attr & GRID_ATTR_REVERSE ? "reverse," : "",
-		attr & GRID_ATTR_HIDDEN ? "hidden," : "",
-		attr & GRID_ATTR_ITALICS ? "italics," : "");
+	len = xsnprintf(buf, sizeof buf, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
+	    (attr & GRID_ATTR_CHARSET) ? "acs," : "",
+	    (attr & GRID_ATTR_BRIGHT) ? "bright," : "",
+	    (attr & GRID_ATTR_DIM) ? "dim," : "",
+	    (attr & GRID_ATTR_UNDERSCORE) ? "underscore," : "",
+	    (attr & GRID_ATTR_BLINK)? "blink," : "",
+	    (attr & GRID_ATTR_REVERSE) ? "reverse," : "",
+	    (attr & GRID_ATTR_HIDDEN) ? "hidden," : "",
+	    (attr & GRID_ATTR_ITALICS) ? "italics," : "",
+	    (attr & GRID_ATTR_STRIKETHROUGH) ? "strikethrough," : "",
+	    (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 +56,29 @@ 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[] = {
+		{ "acs", GRID_ATTR_CHARSET },
+		{ "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 +91,15 @@ attributes_fromstring(const char *str)
 	attr = 0;
 	do {
 		end = strcspn(str, delimiters);
-		if ((end == 6 && strncasecmp(str, "bright", end) == 0) ||
-		    (end == 4 && strncasecmp(str, "bold", end) == 0))
-			attr |= GRID_ATTR_BRIGHT;
-		else if (end == 3 && strncasecmp(str, "dim", end) == 0)
-			attr |= GRID_ATTR_DIM;
-		else if (end == 10 && strncasecmp(str, "underscore", end) == 0)
-			attr |= GRID_ATTR_UNDERSCORE;
-		else if (end == 5 && strncasecmp(str, "blink", end) == 0)
-			attr |= GRID_ATTR_BLINK;
-		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
+		for (i = 0; i < nitems(table); i++) {
+			if (end != strlen(table[i].name))
+				continue;
+			if (strncasecmp(str, table[i].name, end) == 0) {
+				attr |= table[i].attr;
+				break;
+			}
+		}
+		if (i == nitems(table))
 			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 "$AUTOCONF_VERSION" ] && export AUTOCONF_VERSION=2.65
+	[ -z "$AUTOMAKE_VERSION" ] && export AUTOMAKE_VERSION=1.15
+	[ -z "$AUTOCONF_VERSION" ] && export AUTOCONF_VERSION=2.69
 fi
 
 die()

cfg.c

@@ -23,140 +23,184 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
 
 #include "tmux.h"
 
-char		 *cfg_file;
-struct cmd_q	 *cfg_cmd_q;
-int		  cfg_finished;
-int		  cfg_references;
-char		**cfg_causes;
-u_int		  cfg_ncauses;
-struct client	 *cfg_client;
+struct client		 *cfg_client;
+int			  cfg_finished;
+static char		**cfg_causes;
+static u_int		  cfg_ncauses;
+static struct cmdq_item	 *cfg_item;
 
-void	cfg_default_done(struct cmd_q *);
+int                       cfg_quiet = 1;
+char                    **cfg_files;
+u_int                     cfg_nfiles;
 
-void
-set_cfg_file(const char *path)
+static enum cmd_retval
+cfg_client_done(__unused struct cmdq_item *item, __unused void *data)
 {
-	free(cfg_file);
-	cfg_file = xstrdup(path);
+	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;
+
+	cfg_show_causes(NULL);
+
+	if (cfg_item != NULL)
+		cmdq_continue(cfg_item);
+
+	status_prompt_load_history();
+
+	return (CMD_RETURN_NORMAL);
 }
 
 void
 start_cfg(void)
 {
-	char		*cause = NULL;
-	const char	*home;
+	struct client	 *c;
+	u_int		  i;
+	int		  flags = 0;
 
-	cfg_cmd_q = cmdq_new(NULL);
-	cfg_cmd_q->emptyfn = cfg_default_done;
-
-	cfg_finished = 0;
-	cfg_references = 1;
-
-	cfg_client = TAILQ_FIRST(&clients);
-	if (cfg_client != NULL)
-		cfg_client->references++;
-
-	if (access(TMUX_CONF, R_OK) == 0) {
-		if (load_cfg(TMUX_CONF, cfg_cmd_q, &cause) == -1)
-			cfg_add_cause("%s: %s", TMUX_CONF, cause);
-	} else if (errno != ENOENT)
-		cfg_add_cause("%s: %s", TMUX_CONF, strerror(errno));
-
-	if (cfg_file == NULL && (home = find_home()) != NULL) {
-		xasprintf(&cfg_file, "%s/.tmux.conf", home);
-		if (access(cfg_file, R_OK) != 0 && errno == ENOENT) {
-			free(cfg_file);
-			cfg_file = NULL;
-		}
+	/*
+	 * 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);
 	}
-	if (cfg_file != NULL && load_cfg(cfg_file, cfg_cmd_q, &cause) == -1)
-		cfg_add_cause("%s: %s", cfg_file, cause);
-	free(cause);
 
-	cmdq_continue(cfg_cmd_q);
+	if (cfg_quiet)
+		flags = CMD_PARSE_QUIET;
+	for (i = 0; i < cfg_nfiles; i++)
+		load_cfg(cfg_files[i], c, NULL, NULL, flags, NULL);
+
+	cmdq_append(NULL, cmdq_get_callback(cfg_done, NULL));
 }
 
 int
-load_cfg(const char *path, struct cmd_q *cmdq, char **cause)
+load_cfg(const char *path, struct client *c, struct cmdq_item *item,
+    struct cmd_find_state *current, int flags, struct cmdq_item **new_item)
 {
-	FILE		*f;
-	char		 delim[3] = { '\\', '\\', '\0' };
-	u_int		 found;
-	size_t		 line = 0;
-	char		*buf, *cause1, *p;
-	struct cmd_list	*cmdlist;
+	FILE			*f;
+	struct cmd_parse_input	 pi;
+	struct cmd_parse_result	*pr;
+	struct cmdq_item	*new_item0;
+	struct cmdq_state	*state;
+
+	if (new_item != NULL)
+		*new_item = NULL;
 
 	log_debug("loading %s", path);
 	if ((f = fopen(path, "rb")) == NULL) {
-		xasprintf(cause, "%s: %s", path, strerror(errno));
+		if (errno == ENOENT && (flags & CMD_PARSE_QUIET))
+			return (0);
+		cfg_add_cause("%s: %s", path, strerror(errno));
 		return (-1);
 	}
 
-	found = 0;
-	while ((buf = fparseln(f, NULL, &line, delim, 0)) != NULL) {
-		log_debug("%s: %s", path, buf);
+	memset(&pi, 0, sizeof pi);
+	pi.flags = flags;
+	pi.file = path;
+	pi.line = 1;
+	pi.item = item;
+	pi.c = c;
 
-		/* Skip empty lines. */
-		p = buf;
-		while (isspace((u_char) *p))
-			p++;
-		if (*p == '\0') {
-			free(buf);
-			continue;
-		}
-
-		/* Parse and run the command. */
-		if (cmd_string_parse(p, &cmdlist, path, line, &cause1) != 0) {
-			free(buf);
-			if (cause1 == NULL)
-				continue;
-			cfg_add_cause("%s:%zu: %s", path, line, cause1);
-			free(cause1);
-			continue;
-		}
-		free(buf);
-
-		if (cmdlist == NULL)
-			continue;
-		cmdq_append(cmdq, cmdlist, NULL);
-		cmd_list_free(cmdlist);
-		found++;
-	}
+	pr = cmd_parse_from_file(f, &pi);
 	fclose(f);
+	if (pr->status == CMD_PARSE_ERROR) {
+		cfg_add_cause("%s", pr->error);
+		free(pr->error);
+		return (-1);
+	}
+	if (flags & CMD_PARSE_PARSEONLY) {
+		cmd_list_free(pr->cmdlist);
+		return (0);
+	}
 
-	return (found);
+	if (item != NULL)
+		state = cmdq_copy_state(cmdq_get_state(item), current);
+	else
+		state = cmdq_new_state(NULL, NULL, 0);
+	cmdq_add_format(state, "current_file", "%s", pi.file);
+
+	new_item0 = cmdq_get_command(pr->cmdlist, state);
+	if (item != NULL)
+		new_item0 = cmdq_insert_after(item, new_item0);
+	else
+		new_item0 = cmdq_append(NULL, new_item0);
+	cmd_list_free(pr->cmdlist);
+	cmdq_free_state(state);
+
+	if (new_item != NULL)
+		*new_item = new_item0;
+	return (0);
 }
 
-void
-cfg_default_done(__unused struct cmd_q *cmdq)
+int
+load_cfg_from_buffer(const void *buf, size_t len, const char *path,
+    struct client *c, struct cmdq_item *item, struct cmd_find_state *current,
+    int flags, struct cmdq_item **new_item)
 {
-	if (--cfg_references != 0)
-		return;
-	cfg_finished = 1;
+	struct cmd_parse_input	 pi;
+	struct cmd_parse_result	*pr;
+	struct cmdq_item	*new_item0;
+	struct cmdq_state	*state;
 
-	if (!RB_EMPTY(&sessions))
-		cfg_show_causes(RB_MIN(sessions, &sessions));
+	if (new_item != NULL)
+		*new_item = NULL;
 
-	cmdq_free(cfg_cmd_q);
-	cfg_cmd_q = NULL;
+	log_debug("loading %s", path);
 
-	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;
+	memset(&pi, 0, sizeof pi);
+	pi.flags = flags;
+	pi.file = path;
+	pi.line = 1;
+	pi.item = item;
+	pi.c = c;
+
+	pr = cmd_parse_from_buffer(buf, len, &pi);
+	if (pr->status == CMD_PARSE_ERROR) {
+		cfg_add_cause("%s", pr->error);
+		free(pr->error);
+		return (-1);
 	}
+	if (flags & CMD_PARSE_PARSEONLY) {
+		cmd_list_free(pr->cmdlist);
+		return (0);
+	}
+
+	if (item != NULL)
+		state = cmdq_copy_state(cmdq_get_state(item), current);
+	else
+		state = cmdq_new_state(NULL, NULL, 0);
+	cmdq_add_format(state, "current_file", "%s", pi.file);
+
+	new_item0 = cmdq_get_command(pr->cmdlist, state);
+	if (item != NULL)
+		new_item0 = cmdq_insert_after(item, new_item0);
+	else
+		new_item0 = cmdq_append(NULL, new_item0);
+	cmd_list_free(pr->cmdlist);
+	cmdq_free_state(state);
+
+	if (new_item != NULL)
+		*new_item = new_item0;
+	return (0);
 }
 
 void
@@ -175,12 +219,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]);
 	}
 
@@ -192,20 +236,41 @@ cfg_print_causes(struct cmd_q *cmdq)
 void
 cfg_show_causes(struct session *s)
 {
-	struct window_pane	*wp;
-	u_int			 i;
+	struct client			*c = TAILQ_FIRST(&clients);
+	struct window_pane		*wp;
+	struct window_mode_entry	*wme;
+	u_int				 i;
 
-	if (s == NULL || cfg_ncauses == 0)
+	if (cfg_ncauses == 0)
+		return;
+
+	if (c != NULL && (c->flags & CLIENT_CONTROL)) {
+		for (i = 0; i < cfg_ncauses; i++) {
+			control_write(c, "%%config-error %s", cfg_causes[i]);
+			free(cfg_causes[i]);
+		}
+		goto out;
+	}
+
+	if (s == NULL) {
+		if (c != NULL && c->session != NULL)
+			s = c->session;
+		else
+			s = RB_MIN(sessions, &sessions);
+	}
+	if (s == NULL || s->attached == 0) /* wait for an attached session */
 		return;
 	wp = s->curw->window->active;
 
-	window_pane_set_mode(wp, &window_copy_mode);
-	window_copy_init_for_output(wp);
+	wme = TAILQ_FIRST(&wp->modes);
+	if (wme == NULL || wme->mode != &window_view_mode)
+		window_pane_set_mode(wp, NULL, &window_view_mode, NULL, NULL);
 	for (i = 0; i < cfg_ncauses; i++) {
-		window_copy_add(wp, "%s", cfg_causes[i]);
+		window_copy_add(wp, 0, "%s", cfg_causes[i]);
 		free(cfg_causes[i]);
 	}
 
+out:
 	free(cfg_causes);
 	cfg_causes = NULL;
 	cfg_ncauses = 0;

client.c

@@ -17,14 +17,13 @@
  */
 
 #include <sys/types.h>
-#include <sys/file.h>
 #include <sys/socket.h>
-#include <sys/stat.h>
+#include <sys/uio.h>
 #include <sys/un.h>
 #include <sys/wait.h>
+#include <sys/file.h>
 
 #include <errno.h>
-#include <event.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
@@ -33,11 +32,11 @@
 
 #include "tmux.h"
 
-struct tmuxproc	*client_proc;
-struct tmuxpeer	*client_peer;
-int		 client_flags;
-struct event	 client_stdin;
-enum {
+static struct tmuxproc	*client_proc;
+static struct tmuxpeer	*client_peer;
+static uint64_t		 client_flags;
+static int		 client_suspended;
+static enum {
 	CLIENT_EXIT_NONE,
 	CLIENT_EXIT_DETACHED,
 	CLIENT_EXIT_DETACHED_HUP,
@@ -46,30 +45,36 @@ enum {
 	CLIENT_EXIT_LOST_SERVER,
 	CLIENT_EXIT_EXITED,
 	CLIENT_EXIT_SERVER_EXITED,
+	CLIENT_EXIT_MESSAGE_PROVIDED
 } client_exitreason = CLIENT_EXIT_NONE;
-int		 client_exitval;
-enum msgtype	 client_exittype;
-const char	*client_exitsession;
-int		 client_attached;
+static int		 client_exitflag;
+static int		 client_exitval;
+static enum msgtype	 client_exittype;
+static const char	*client_exitsession;
+static char		*client_exitmessage;
+static const char	*client_execshell;
+static const char	*client_execcmd;
+static int		 client_attached;
+static struct client_files client_files = RB_INITIALIZER(&client_files);
 
-__dead void	client_exec(const char *,const char *);
-int		client_get_lock(char *);
-int		client_connect(struct event_base *, const char *, int);
-void		client_send_identify(const char *, const char *);
-void		client_stdin_callback(int, short, void *);
-void		client_write(int, const char *, size_t);
-void		client_signal(int);
-void		client_dispatch(struct imsg *, void *);
-void		client_dispatch_attached(struct imsg *);
-void		client_dispatch_wait(struct imsg *, const char *);
-const char     *client_exit_message(void);
+static __dead void	 client_exec(const char *,const char *);
+static int		 client_get_lock(char *);
+static int		 client_connect(struct event_base *, const char *,
+			     uint64_t);
+static void		 client_send_identify(const char *, const char *,
+			     char **, u_int, const char *, int);
+static void		 client_signal(int);
+static void		 client_dispatch(struct imsg *, void *);
+static void		 client_dispatch_attached(struct imsg *);
+static void		 client_dispatch_wait(struct imsg *);
+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,8 +101,8 @@ client_get_lock(char *lockfile)
 }
 
 /* Connect client to server. */
-int
-client_connect(struct event_base *base, const char *path, int start_server)
+static int
+client_connect(struct event_base *base, const char *path, uint64_t flags)
 {
 	struct sockaddr_un	sa;
 	size_t			size;
@@ -122,7 +127,9 @@ retry:
 		log_debug("connect failed: %s", strerror(errno));
 		if (errno != ECONNREFUSED && errno != ENOENT)
 			goto failed;
-		if (!start_server)
+		if (flags & CLIENT_NOSTARTSERVER)
+			goto failed;
+		if (~flags & CLIENT_STARTSERVER)
 			goto failed;
 		close(fd);
 
@@ -154,7 +161,7 @@ retry:
 			close(lockfd);
 			return (-1);
 		}
-		fd = server_start(base, lockfd, lockfile);
+		fd = server_start(client_proc, flags, base, lockfd, lockfile);
 	}
 
 	if (locked && lockfd >= 0) {
@@ -201,71 +208,86 @@ 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:
 		return ("server exited");
+	case CLIENT_EXIT_MESSAGE_PROVIDED:
+		return (client_exitmessage);
 	}
 	return ("unknown reason");
 }
 
+/* Exit if all streams flushed. */
+static void
+client_exit(void)
+{
+	if (!file_write_left(&client_files))
+		proc_exit(client_proc);
+}
+
 /* Client main loop. */
 int
-client_main(struct event_base *base, int argc, char **argv, int flags,
-    const char *shellcmd)
+client_main(struct event_base *base, int argc, char **argv, uint64_t flags,
+    int feat)
 {
-	struct cmd		*cmd;
-	struct cmd_list		*cmdlist;
-	struct msg_command_data	*data;
-	int			 cmdflags, fd, i;
-	const char		*ttynam, *cwd;
+	struct cmd_parse_result	*pr;
+	struct msg_command	*data;
+	int			 fd, i;
+	const char		*ttynam, *termname, *cwd;
 	pid_t			 ppid;
 	enum msgtype		 msg;
-	char			*cause, path[PATH_MAX];
 	struct termios		 tio, saved_tio;
-	size_t			 size;
-
-	/* Ignore SIGCHLD now or daemon() in the server will leave a zombie. */
-	signal(SIGCHLD, SIG_IGN);
-
-	/* Save the flags. */
-	client_flags = flags;
+	size_t			 size, linesize = 0;
+	ssize_t			 linelen;
+	char			*line = NULL, **caps = NULL, *cause;
+	u_int			 ncaps = 0;
+	struct args_value	*values;
 
 	/* Set up the initial command. */
-	cmdflags = 0;
-	if (shellcmd != NULL) {
+	if (shell_command != NULL) {
 		msg = MSG_SHELL;
-		cmdflags = CMD_STARTSERVER;
+		flags |= CLIENT_STARTSERVER;
 	} else if (argc == 0) {
 		msg = MSG_COMMAND;
-		cmdflags = CMD_STARTSERVER;
+		flags |= CLIENT_STARTSERVER;
 	} else {
 		msg = MSG_COMMAND;
 
 		/*
-		 * It sucks parsing the command string twice (in client and
-		 * later in server) but it is necessary to get the start server
-		 * flag.
+		 * It's annoying parsing the command string twice (in client
+		 * and later in server) but it is necessary to get the start
+		 * server flag.
 		 */
-		cmdlist = cmd_list_parse(argc, argv, NULL, 0, &cause);
-		if (cmdlist == NULL) {
-			fprintf(stderr, "%s\n", cause);
-			return (1);
-		}
-		cmdflags &= ~CMD_STARTSERVER;
-		TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
-			if (cmd->entry->flags & CMD_STARTSERVER)
-				cmdflags |= CMD_STARTSERVER;
-		}
-		cmd_list_free(cmdlist);
+		values = args_from_vector(argc, argv);
+		pr = cmd_parse_from_arguments(values, argc, NULL);
+		if (pr->status == CMD_PARSE_SUCCESS) {
+			if (cmd_list_any_have(pr->cmdlist, CMD_STARTSERVER))
+				flags |= CLIENT_STARTSERVER;
+			cmd_list_free(pr->cmdlist);
+		} else
+			free(pr->error);
+		args_free_values(values, argc);
+		free(values);
 	}
 
 	/* 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);
+
+	/* Save the flags. */
+	client_flags = flags;
+	log_debug("flags are %#llx", (unsigned long long)client_flags);
 
 	/* Initialize the client socket and start the server. */
-	fd = client_connect(base, socket_path, cmdflags & CMD_STARTSERVER);
+#ifdef HAVE_SYSTEMD
+	if (systemd_activated()) {
+		/* socket-based activation, do not even try to be a client. */
+		fd = server_start(client_proc, flags, base, 0, NULL);
+	} else
+#endif
+	fd = client_connect(base, socket_path, client_flags);
 	if (fd == -1) {
 		if (errno == ECONNREFUSED) {
 			fprintf(stderr, "no server running on %s\n",
@@ -276,18 +298,16 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 		}
 		return (1);
 	}
-	client_peer = proc_add_peer(client_proc, fd, client_dispatch,
-	    (void *)shellcmd);
+	client_peer = proc_add_peer(client_proc, fd, client_dispatch, NULL);
 
 	/* Save these before pledge(). */
-	if ((cwd = getcwd(path, sizeof path)) == NULL) {
-		if ((cwd = find_home()) == NULL)
-			cwd = "/";
-	}
+	if ((cwd = find_cwd()) == NULL && (cwd = find_home()) == NULL)
+		cwd = "/";
 	if ((ttynam = ttyname(STDIN_FILENO)) == NULL)
 		ttynam = "";
+	if ((termname = getenv("TERM")) == NULL)
+		termname = "";
 
-#ifdef __OpenBSD__
 	/*
 	 * Drop privileges for client. "proc exec" is needed for -c and for
 	 * locking (which uses system(3)).
@@ -297,23 +317,36 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 	 *
 	 * "sendfd" is dropped later in client_dispatch_wait().
 	 */
-	if (pledge("stdio unix sendfd proc exec tty", NULL) != 0)
+	if (pledge(
+	    "stdio rpath wpath cpath unix sendfd proc exec tty",
+	    NULL) != 0)
 		fatal("pledge failed");
-#endif
+
+	/* Load terminfo entry if any. */
+	if (isatty(STDIN_FILENO) &&
+	    *termname != '\0' &&
+	    tty_term_read_list(termname, STDIN_FILENO, &caps, &ncaps,
+	    &cause) != 0) {
+		fprintf(stderr, "%s\n", cause);
+		free(cause);
+		return (1);
+	}
 
 	/* 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);
 	environ_free(global_environ);
 
-	/* Create stdin handler. */
-	setblocking(STDIN_FILENO, 0);
-	event_set(&client_stdin, STDIN_FILENO, EV_READ|EV_PERSIST,
-	    client_stdin_callback, NULL);
+	/* Set up control mode. */
 	if (client_flags & CLIENT_CONTROLCONTROL) {
-		if (tcgetattr(STDIN_FILENO, &saved_tio) != 0)
-			fatal("tcgetattr failed");
+		if (tcgetattr(STDIN_FILENO, &saved_tio) != 0) {
+			fprintf(stderr, "tcgetattr failed: %s\n",
+			    strerror(errno));
+			return (1);
+		}
 		cfmakeraw(&tio);
 		tio.c_iflag = ICRNL|IXANY;
 		tio.c_oflag = OPOST|ONLCR;
@@ -329,7 +362,9 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 	}
 
 	/* Send identify messages. */
-	client_send_identify(ttynam, cwd);
+	client_send_identify(ttynam, termname, caps, ncaps, cwd, feat);
+	tty_term_free_list(caps, ncaps);
+	proc_flush_peer(client_peer);
 
 	/* Send first command. */
 	if (msg == MSG_COMMAND) {
@@ -337,6 +372,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 +400,18 @@ 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);
+	}
+
+	/* Restore streams to blocking. */
+	setblocking(STDIN_FILENO, 1);
+	setblocking(STDOUT_FILENO, 1);
+	setblocking(STDERR_FILENO, 1);
+
 	/* Print the exit message, if any, and exit. */
 	if (client_attached) {
 		if (client_exitreason != CLIENT_EXIT_NONE)
@@ -369,42 +420,66 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 		ppid = getppid();
 		if (client_exittype == MSG_DETACHKILL && ppid > 1)
 			kill(ppid, SIGHUP);
-	} else if (client_flags & CLIENT_CONTROLCONTROL) {
+	} else if (client_flags & CLIENT_CONTROL) {
 		if (client_exitreason != CLIENT_EXIT_NONE)
 			printf("%%exit %s\n", client_exit_message());
 		else
 			printf("%%exit\n");
-		printf("\033\\");
-		tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
+		fflush(stdout);
+		if (client_flags & CLIENT_CONTROL_WAITEXIT) {
+			setvbuf(stdin, NULL, _IOLBF, 0);
+			for (;;) {
+				linelen = getline(&line, &linesize, stdin);
+				if (linelen <= 1)
+					break;
+			}
+			free(line);
+		}
+		if (client_flags & CLIENT_CONTROLCONTROL) {
+			printf("\033\\");
+			fflush(stdout);
+			tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
+		}
 	} else if (client_exitreason != CLIENT_EXIT_NONE)
 		fprintf(stderr, "%s\n", client_exit_message());
-	setblocking(STDIN_FILENO, 1);
 	return (client_exitval);
 }
 
 /* Send identify messages to server. */
-void
-client_send_identify(const char *ttynam, const char *cwd)
+static void
+client_send_identify(const char *ttynam, const char *termname, char **caps,
+    u_int ncaps, const char *cwd, int feat)
 {
-	const char	 *s;
-	char		**ss;
-	size_t		  sslen;
-	int		  fd, flags = client_flags;
-	pid_t		  pid;
+	char	**ss;
+	size_t	  sslen;
+	int	  fd;
+	uint64_t  flags = client_flags;
+	pid_t	  pid;
+	u_int	  i;
 
-	proc_send(client_peer, MSG_IDENTIFY_FLAGS, -1, &flags, sizeof flags);
+	proc_send(client_peer, MSG_IDENTIFY_LONGFLAGS, -1, &flags, sizeof flags);
+	proc_send(client_peer, MSG_IDENTIFY_LONGFLAGS, -1, &client_flags,
+	    sizeof client_flags);
 
-	if ((s = getenv("TERM")) == NULL)
-		s = "";
-	proc_send(client_peer, MSG_IDENTIFY_TERM, -1, s, strlen(s) + 1);
+	proc_send(client_peer, MSG_IDENTIFY_TERM, -1, termname,
+	    strlen(termname) + 1);
+	proc_send(client_peer, MSG_IDENTIFY_FEATURES, -1, &feat, sizeof feat);
 
 	proc_send(client_peer, MSG_IDENTIFY_TTYNAME, -1, ttynam,
 	    strlen(ttynam) + 1);
 	proc_send(client_peer, MSG_IDENTIFY_CWD, -1, cwd, strlen(cwd) + 1);
 
+	for (i = 0; i < ncaps; i++) {
+		proc_send(client_peer, MSG_IDENTIFY_TERMINFO, -1,
+		    caps[i], strlen(caps[i]) + 1);
+	}
+
 	if ((fd = dup(STDIN_FILENO)) == -1)
 		fatal("dup failed");
 	proc_send(client_peer, MSG_IDENTIFY_STDIN, fd, NULL, 0);
+	if ((fd = dup(STDOUT_FILENO)) == -1)
+		fatal("dup failed");
+	proc_send(client_peer, MSG_IDENTIFY_STDOUT, fd, NULL, 0);
 
 	pid = getpid();
 	proc_send(client_peer, MSG_IDENTIFY_CLIENTPID, -1, &pid, sizeof pid);
@@ -419,60 +494,18 @@ client_send_identify(const char *ttynam, const char *cwd)
 	proc_send(client_peer, MSG_IDENTIFY_DONE, -1, NULL, 0);
 }
 
-/* Callback for client stdin read events. */
-void
-client_stdin_callback(__unused int fd, __unused short events,
-    __unused void *arg)
-{
-	struct msg_stdin_data	data;
-
-	data.size = read(STDIN_FILENO, data.data, sizeof data.data);
-	if (data.size < 0 && (errno == EINTR || errno == EAGAIN))
-		return;
-
-	proc_send(client_peer, MSG_STDIN, -1, &data, sizeof data);
-	if (data.size <= 0)
-		event_del(&client_stdin);
-}
-
-/* Force write to file descriptor. */
-void
-client_write(int fd, const char *data, size_t size)
-{
-	ssize_t	used;
-
-	while (size != 0) {
-		used = write(fd, data, size);
-		if (used == -1) {
-			if (errno == EINTR || errno == EAGAIN)
-				continue;
-			break;
-		}
-		data += used;
-		size -= used;
-	}
-}
-
 /* Run command in shell; used for -c. */
-__dead void
+static __dead void
 client_exec(const char *shell, const char *shellcmd)
 {
-	const char	*name, *ptr;
-	char		*argv0;
+	char	*argv0;
 
 	log_debug("shell %s, command %s", shell, shellcmd);
-
-	ptr = strrchr(shell, '/');
-	if (ptr != NULL && *(ptr + 1) != '\0')
-		name = ptr + 1;
-	else
-		name = shell;
-	if (client_flags & CLIENT_LOGIN)
-		xasprintf(&argv0, "-%s", name);
-	else
-		xasprintf(&argv0, "%s", name);
+	argv0 = shell_argv0(shell, !!(client_flags & CLIENT_LOGIN));
 	setenv("SHELL", shell, 1);
 
+	proc_clear_signals(client_proc, 1);
+
 	setblocking(STDIN_FILENO, 1);
 	setblocking(STDOUT_FILENO, 1);
 	setblocking(STDERR_FILENO, 1);
@@ -483,16 +516,28 @@ 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;
 	int		 status;
+	pid_t		 pid;
 
-	if (sig == SIGCHLD)
-		waitpid(WAIT_ANY, &status, WNOHANG);
-	else if (!client_attached) {
-		if (sig == SIGTERM)
+	log_debug("%s: %s", __func__, strsignal(sig));
+	if (sig == SIGCHLD) {
+		for (;;) {
+			pid = waitpid(WAIT_ANY, &status, WNOHANG);
+			if (pid == 0)
+				break;
+			if (pid == -1) {
+				if (errno == ECHILD)
+					break;
+				log_debug("waitpid failed: %s",
+				    strerror(errno));
+			}
+		}
+	} else if (!client_attached) {
+		if (sig == SIGTERM || sig == SIGHUP)
 			proc_exit(client_proc);
 	} else {
 		switch (sig) {
@@ -502,7 +547,8 @@ client_signal(int sig)
 			proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 			break;
 		case SIGTERM:
-			client_exitreason = CLIENT_EXIT_TERMINATED;
+			if (!client_suspended)
+				client_exitreason = CLIENT_EXIT_TERMINATED;
 			client_exitval = 1;
 			proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 			break;
@@ -517,18 +563,31 @@ client_signal(int sig)
 			if (sigaction(SIGTSTP, &sigact, NULL) != 0)
 				fatal("sigaction failed");
 			proc_send(client_peer, MSG_WAKEUP, -1, NULL, 0);
+			client_suspended = 0;
 			break;
 		}
 	}
 }
 
+/* Callback for file write error or close. */
+static void
+client_file_check_cb(__unused struct client *c, __unused const char *path,
+    __unused int error, __unused int closed, __unused struct evbuffer *buffer,
+    __unused void *data)
+{
+	if (client_exitflag)
+		client_exit();
+}
+
 /* Callback for client read events. */
-void
-client_dispatch(struct imsg *imsg, void *arg)
+static void
+client_dispatch(struct imsg *imsg, __unused void *arg)
 {
 	if (imsg == NULL) {
-		client_exitreason = CLIENT_EXIT_LOST_SERVER;
-		client_exitval = 1;
+		if (!client_exitflag) {
+			client_exitreason = CLIENT_EXIT_LOST_SERVER;
+			client_exitval = 1;
+		}
 		proc_exit(client_proc);
 		return;
 	}
@@ -536,20 +595,42 @@ client_dispatch(struct imsg *imsg, void *arg)
 	if (client_attached)
 		client_dispatch_attached(imsg);
 	else
-		client_dispatch_wait(imsg, arg);
+		client_dispatch_wait(imsg);
+}
+
+/* Process an exit message. */
+static void
+client_dispatch_exit_message(char *data, size_t datalen)
+{
+	int	retval;
+
+	if (datalen < sizeof retval && datalen != 0)
+		fatalx("bad MSG_EXIT size");
+
+	if (datalen >= sizeof retval) {
+		memcpy(&retval, data, sizeof retval);
+		client_exitval = retval;
+	}
+
+	if (datalen > sizeof retval) {
+		datalen -= sizeof retval;
+		data += sizeof retval;
+
+		client_exitmessage = xmalloc(datalen);
+		memcpy(client_exitmessage, data, datalen);
+		client_exitmessage[datalen - 1] = '\0';
+
+		client_exitreason = CLIENT_EXIT_MESSAGE_PROVIDED;
+	}
 }
 
 /* Dispatch imsgs when in wait state (before MSG_READY). */
-void
-client_dispatch_wait(struct imsg *imsg, const char *shellcmd)
+static void
+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;
+	char		*data;
+	ssize_t		 datalen;
+	static int	 pledge_applied;
 
 	/*
 	 * "sendfd" is no longer required once all of the identify messages
@@ -558,11 +639,12 @@ client_dispatch_wait(struct imsg *imsg, const char *shellcmd)
 	 * get the first message from the server.
 	 */
 	if (!pledge_applied) {
-		if (pledge("stdio unix proc exec tty", NULL) != 0)
+		if (pledge(
+		    "stdio rpath wpath cpath unix proc exec tty",
+		    NULL) != 0)
 			fatal("pledge failed");
 		pledge_applied = 1;
-	};
-#endif
+	}
 
 	data = imsg->data;
 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
@@ -570,44 +652,17 @@ client_dispatch_wait(struct imsg *imsg, const char *shellcmd)
 	switch (imsg->hdr.type) {
 	case MSG_EXIT:
 	case MSG_SHUTDOWN:
-		if (datalen != sizeof retval && datalen != 0)
-			fatalx("bad MSG_EXIT size");
-		if (datalen == sizeof retval) {
-			memcpy(&retval, data, sizeof retval);
-			client_exitval = retval;
-		}
-		proc_exit(client_proc);
+		client_dispatch_exit_message(data, datalen);
+		client_exitflag = 1;
+		client_exit();
 		break;
 	case MSG_READY:
 		if (datalen != 0)
 			fatalx("bad MSG_READY size");
 
-		event_del(&client_stdin);
 		client_attached = 1;
 		proc_send(client_peer, MSG_RESIZE, -1, NULL, 0);
 		break;
-	case MSG_STDIN:
-		if (datalen != 0)
-			fatalx("bad MSG_STDIN size");
-
-		event_add(&client_stdin, NULL);
-		break;
-	case MSG_STDOUT:
-		if (datalen != sizeof stdoutdata)
-			fatalx("bad MSG_STDOUT size");
-		memcpy(&stdoutdata, data, sizeof stdoutdata);
-
-		client_write(STDOUT_FILENO, stdoutdata.data,
-		    stdoutdata.size);
-		break;
-	case MSG_STDERR:
-		if (datalen != sizeof stderrdata)
-			fatalx("bad MSG_STDERR size");
-		memcpy(&stderrdata, data, sizeof stderrdata);
-
-		client_write(STDERR_FILENO, stderrdata.data,
-		    stderrdata.size);
-		break;
 	case MSG_VERSION:
 		if (datalen != 0)
 			fatalx("bad MSG_VERSION size");
@@ -618,12 +673,19 @@ client_dispatch_wait(struct imsg *imsg, const char *shellcmd)
 		client_exitval = 1;
 		proc_exit(client_proc);
 		break;
+	case MSG_FLAGS:
+		if (datalen != sizeof client_flags)
+			fatalx("bad MSG_FLAGS string");
+
+		memcpy(&client_flags, data, sizeof client_flags);
+		log_debug("new flags are %#llx",
+		    (unsigned long long)client_flags);
+		break;
 	case MSG_SHELL:
 		if (datalen == 0 || data[datalen - 1] != '\0')
 			fatalx("bad MSG_SHELL string");
 
-		clear_signals(0);
-		client_exec(data, shellcmd);
+		client_exec(data, shell_command);
 		/* NOTREACHED */
 	case MSG_DETACH:
 	case MSG_DETACHKILL:
@@ -632,11 +694,36 @@ client_dispatch_wait(struct imsg *imsg, const char *shellcmd)
 	case MSG_EXITED:
 		proc_exit(client_proc);
 		break;
+	case MSG_READ_OPEN:
+		file_read_open(&client_files, client_peer, imsg, 1,
+		    !(client_flags & CLIENT_CONTROL), client_file_check_cb,
+		    NULL);
+		break;
+	case MSG_READ_CANCEL:
+		file_read_cancel(&client_files, imsg);
+		break;
+	case MSG_WRITE_OPEN:
+		file_write_open(&client_files, client_peer, imsg, 1,
+		    !(client_flags & CLIENT_CONTROL), client_file_check_cb,
+		    NULL);
+		break;
+	case MSG_WRITE:
+		file_write_data(&client_files, imsg);
+		break;
+	case MSG_WRITE_CLOSE:
+		file_write_close(&client_files, imsg);
+		break;
+	case MSG_OLDSTDERR:
+	case MSG_OLDSTDIN:
+	case MSG_OLDSTDOUT:
+		fprintf(stderr, "server version is too old for client\n");
+		proc_exit(client_proc);
+		break;
 	}
 }
 
 /* Dispatch imsgs in attached state (after MSG_READY). */
-void
+static void
 client_dispatch_attached(struct imsg *imsg)
 {
 	struct sigaction	 sigact;
@@ -647,6 +734,14 @@ client_dispatch_attached(struct imsg *imsg)
 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
 
 	switch (imsg->hdr.type) {
+	case MSG_FLAGS:
+		if (datalen != sizeof client_flags)
+			fatalx("bad MSG_FLAGS string");
+
+		memcpy(&client_flags, data, sizeof client_flags);
+		log_debug("new flags are %#llx",
+		    (unsigned long long)client_flags);
+		break;
 	case MSG_DETACH:
 	case MSG_DETACHKILL:
 		if (datalen == 0 || data[datalen - 1] != '\0')
@@ -660,12 +755,21 @@ client_dispatch_attached(struct imsg *imsg)
 			client_exitreason = CLIENT_EXIT_DETACHED;
 		proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 		break;
-	case MSG_EXIT:
-		if (datalen != 0 && datalen != sizeof (int))
-			fatalx("bad MSG_EXIT size");
+	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:
+		client_dispatch_exit_message(data, datalen);
+		if (client_exitreason == CLIENT_EXIT_NONE)
+			client_exitreason = CLIENT_EXIT_EXITED;
 		proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
-		client_exitreason = CLIENT_EXIT_EXITED;
 		break;
 	case MSG_EXITED:
 		if (datalen != 0)
@@ -691,6 +795,7 @@ client_dispatch_attached(struct imsg *imsg)
 		sigact.sa_handler = SIG_DFL;
 		if (sigaction(SIGTSTP, &sigact, NULL) != 0)
 			fatal("sigaction failed");
+		client_suspended = 1;
 		kill(getpid(), SIGTSTP);
 		break;
 	case MSG_LOCK:

cmd-attach-session.c

@@ -30,135 +30,146 @@
  * 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 },
-	.usage = "[-dEr] [-c working-directory] " CMD_TARGET_SESSION_USAGE,
+	.args = { "c:dEf:rt:x", 0, 0, NULL },
+	.usage = "[-dErx] [-c working-directory] [-f flags] "
+	         CMD_TARGET_SESSION_USAGE,
 
-	.tflag = CMD_SESSION_WITHPANE,
+	/* -t is special */
 
-	.flags = CMD_STARTSERVER,
+	.flags = CMD_STARTSERVER|CMD_READONLY,
 	.exec = cmd_attach_session_exec
 };
 
 enum cmd_retval
-cmd_attach_session(struct cmd_q *cmdq, int dflag, int rflag, const char *cflag,
-    int Eflag)
+cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
+    int xflag, int rflag, const char *cflag, int Eflag, const char *fflag)
 {
-	struct session		*s = cmdq->state.tflag.s;
-	struct client		*c = cmdq->client, *c_loop;
-	struct winlink		*wl = cmdq->state.tflag.wl;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
-	const char		*update;
-	char			*cause, *cwd;
-	struct format_tree	*ft;
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	 target;
+	enum cmd_find_type	 type;
+	int			 flags;
+	struct client		*c = cmdq_get_client(item), *c_loop;
+	struct session		*s;
+	struct winlink		*wl;
+	struct window_pane	*wp;
+	char			*cwd, *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(&target, item, tflag, type, flags) != 0)
+		return (CMD_RETURN_ERROR);
+	s = target.s;
+	wl = target.wl;
+	wp = 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);
-
+		cwd = format_single(item, cflag, c, s, wl, wp);
 		free((void *)s->cwd);
 		s->cwd = cwd;
 	}
+	if (fflag)
+		server_client_set_flags(c, fflag);
+	if (rflag)
+		c->flags |= (CLIENT_READONLY|CLIENT_IGNORESIZE);
 
+	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)
+			environ_update(s->options, c->environ, s->environ);
 
-		if (!Eflag) {
-			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);
-		status_timer_start(c);
-		notify_attached_session_changed(c);
-		session_update_activity(s, NULL);
-		gettimeofday(&s->last_attached_time, NULL);
-		server_redraw_client(c);
-		s->curw->flags &= ~WINLINK_ALERTFLAGS;
+		server_client_set_session(c, s);
+		if (~cmdq_get_flags(item) & CMDQ_STATE_REPEAT)
+			server_client_set_key_table(c, NULL);
 	} 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)
+			environ_update(s->options, c->environ, s->environ);
 
-		if (!Eflag) {
-			update = options_get_string(s->options,
-			    "update-environment");
-			environ_update(update, c->environ, s->environ);
-		}
-
-		c->session = s;
+		server_client_set_session(c, s);
 		server_client_set_key_table(c, NULL);
-		status_timer_start(c);
-		notify_attached_session_changed(c);
-		session_update_activity(s, NULL);
-		gettimeofday(&s->last_attached_time, NULL);
-		server_redraw_client(c);
-		s->curw->flags &= ~WINLINK_ALERTFLAGS;
 
 		if (~c->flags & CLIENT_CONTROL)
 			proc_send(c->peer, MSG_READY, -1, NULL, 0);
-		hooks_run(c->session->hooks, c, NULL, "client-attached");
-		cmdq->client_exit = 0;
+		notify_client("client-attached", c);
+		c->flags |= CLIENT_ATTACHED;
 	}
-	recalculate_sizes();
-	alerts_check_session(s);
-	server_update_socket();
+
+	if (cfg_finished)
+		cfg_show_causes(s);
 
 	return (CMD_RETURN_NORMAL);
 }
 
-enum cmd_retval
-cmd_attach_session_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_attach_session_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args	*args = cmd_get_args(self);
 
-	return (cmd_attach_session(cmdq, args_has(args, 'd'),
-	    args_has(args, 'r'), args_get(args, 'c'), args_has(args, 'E')));
+	return (cmd_attach_session(item, args_get(args, 't'),
+	    args_has(args, 'd'), args_has(args, 'x'), args_has(args, 'r'),
+	    args_get(args, 'c'), args_has(args, 'E'), args_get(args, 'f')));
 }

cmd-bind-key.c

@@ -24,136 +24,84 @@
 #include "tmux.h"
 
 /*
- * Bind a key to a command, this recurses through cmd_*.
+ * Bind a key to a command.
  */
 
-enum cmd_retval	 cmd_bind_key_exec(struct cmd *, struct cmd_q *);
-
-enum cmd_retval	 cmd_bind_key_mode_table(struct cmd *, struct cmd_q *,
-		     key_code);
+static enum args_parse_type	cmd_bind_key_args_parse(struct args *, u_int,
+				    char **);
+static enum cmd_retval		cmd_bind_key_exec(struct cmd *,
+				    struct cmdq_item *);
 
 const struct cmd_entry cmd_bind_key_entry = {
 	.name = "bind-key",
 	.alias = "bind",
 
-	.args = { "cnrt:T:", 1, -1 },
-	.usage = "[-cnr] [-t mode-table] [-T key-table] key command "
-		 "[arguments]",
+	.args = { "nrN:T:", 1, -1, cmd_bind_key_args_parse },
+	.usage = "[-nr] [-T key-table] [-N note] key "
+	         "[command [argument ...]]",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_bind_key_exec
 };
 
-enum cmd_retval
-cmd_bind_key_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum args_parse_type
+cmd_bind_key_args_parse(__unused struct args *args, __unused u_int idx,
+    __unused char **cause)
 {
-	struct args	*args = self->args;
-	char		*cause;
-	struct cmd_list	*cmdlist;
-	key_code	 key;
-	const char	*tablename;
+	return (ARGS_PARSE_COMMANDS_OR_STRING);
+}
 
-	if (args_has(args, 't')) {
-		if (args->argc != 2 && args->argc != 3) {
-			cmdq_error(cmdq, "not enough arguments");
-			return (CMD_RETURN_ERROR);
-		}
-	} else {
-		if (args->argc < 2) {
-			cmdq_error(cmdq, "not enough arguments");
-			return (CMD_RETURN_ERROR);
-		}
-	}
+static enum cmd_retval
+cmd_bind_key_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		 *args = cmd_get_args(self);
+	key_code		  key;
+	const char		 *tablename, *note = args_get(args, 'N');
+	struct cmd_parse_result	 *pr;
+	int			  repeat;
+	struct args_value	 *value;
+	u_int			  count = args_count(args);
 
-	key = key_string_lookup_string(args->argv[0]);
+	key = key_string_lookup_string(args_string(args, 0));
 	if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
-		cmdq_error(cmdq, "unknown key: %s", args->argv[0]);
+		cmdq_error(item, "unknown key: %s", args_string(args, 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'))
 		tablename = "root";
 	else
 		tablename = "prefix";
+	repeat = args_has(args, 'r');
 
-	cmdlist = cmd_list_parse(args->argc - 1, args->argv + 1, NULL, 0,
-	    &cause);
-	if (cmdlist == NULL) {
-		cmdq_error(cmdq, "%s", cause);
-		free(cause);
-		return (CMD_RETURN_ERROR);
+	if (count == 1) {
+		key_bindings_add(tablename, key, note, repeat, NULL);
+		return (CMD_RETURN_NORMAL);
 	}
 
-	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;
-	const struct mode_key_table	*mtab;
-	struct mode_key_binding		*mbind, mtmp;
-	enum mode_key_cmd		 cmd;
-	const char			*arg;
-
-	tablename = args_get(args, 't');
-	if ((mtab = mode_key_findtable(tablename)) == NULL) {
-		cmdq_error(cmdq, "unknown key table: %s", tablename);
-		return (CMD_RETURN_ERROR);
-	}
-
-	cmd = mode_key_fromstring(mtab->cmdstr, args->argv[1]);
-	if (cmd == MODEKEY_NONE) {
-		cmdq_error(cmdq, "unknown command: %s", args->argv[1]);
-		return (CMD_RETURN_ERROR);
-	}
-
-	switch (cmd) {
-	case MODEKEYCOPY_APPENDSELECTION:
-	case MODEKEYCOPY_COPYSELECTION:
-	case MODEKEYCOPY_STARTNAMEDBUFFER:
-		if (args->argc == 2)
-			arg = NULL;
-		else {
-			arg = args->argv[2];
-			if (strcmp(arg, "-x") != 0) {
-				cmdq_error(cmdq, "unknown argument");
-				return (CMD_RETURN_ERROR);
-			}
-		}
-		break;
-	case MODEKEYCOPY_COPYPIPE:
-		if (args->argc != 3) {
-			cmdq_error(cmdq, "no argument given");
-			return (CMD_RETURN_ERROR);
-		}
-		arg = args->argv[2];
-		break;
-	default:
-		if (args->argc != 2) {
-			cmdq_error(cmdq, "no argument allowed");
-			return (CMD_RETURN_ERROR);
-		}
-		arg = NULL;
-		break;
-	}
-
-	mtmp.key = key;
-	mtmp.mode = !!args_has(args, 'c');
-	if ((mbind = RB_FIND(mode_key_tree, mtab->tree, &mtmp)) == NULL) {
-		mbind = xmalloc(sizeof *mbind);
-		mbind->key = mtmp.key;
-		mbind->mode = mtmp.mode;
-		RB_INSERT(mode_key_tree, mtab->tree, mbind);
-	}
-	mbind->cmd = cmd;
-	mbind->arg = arg != NULL ? xstrdup(arg) : NULL;
+	value = args_value(args, 1);
+	if (count == 2 && value->type == ARGS_COMMANDS) {
+		key_bindings_add(tablename, key, note, repeat, value->cmdlist);
+		value->cmdlist->references++;
+		return (CMD_RETURN_NORMAL);
+	}
+
+	if (count == 2)
+		pr = cmd_parse_from_string(args_string(args, 1), NULL);
+	else {
+		pr = cmd_parse_from_arguments(args_values(args) + 1, count - 1,
+		    NULL);
+	}
+	switch (pr->status) {
+	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, note, repeat, pr->cmdlist);
 	return (CMD_RETURN_NORMAL);
 }

cmd-break-pane.c

@@ -28,67 +28,102 @@
 
 #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 },
-	.usage = "[-dP] [-F format] [-s src-pane] [-t dst-window]",
+	.args = { "abdPF:n:s:t:", 0, 0, NULL },
+	.usage = "[-abdP] [-F format] [-n window-name] [-s src-pane] "
+		 "[-t dst-window]",
 
-	.sflag = CMD_PANE,
-	.tflag = CMD_WINDOW_INDEX,
+	.source = { 's', CMD_FIND_PANE, 0 },
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_WINDOW_INDEX },
 
 	.flags = 0,
 	.exec = cmd_break_pane_exec
 };
 
-enum cmd_retval
-cmd_break_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_break_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	struct winlink		*wl = cmdq->state.sflag.wl;
-	struct session		*src_s = cmdq->state.sflag.s;
-	struct session		*dst_s = cmdq->state.tflag.s;
-	struct window_pane	*wp = cmdq->state.sflag.wp;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct cmd_find_state	*source = cmdq_get_source(item);
+	struct client		*tc = cmdq_get_target_client(item);
+	struct winlink		*wl = source->wl;
+	struct session		*src_s = source->s;
+	struct session		*dst_s = target->s;
+	struct window_pane	*wp = source->wp;
 	struct window		*w = wl->window;
-	char			*name;
-	char			*cause;
-	int			 idx = cmdq->state.tflag.idx;
-	struct format_tree	*ft;
+	char			*name, *cause, *cp;
+	int			 idx = target->idx, before;
 	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);
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (window_count_panes(w) == 1) {
-		cmdq_error(cmdq, "can't break with only one pane");
-		return (CMD_RETURN_ERROR);
+	before = args_has(args, 'b');
+	if (args_has(args, 'a') || before) {
+		if (target->wl != NULL)
+			idx = winlink_shuffle_up(dst_s, target->wl, before);
+		else
+			idx = winlink_shuffle_up(dst_s, dst_s->curw, before);
+		if (idx == -1)
+			return (CMD_RETURN_ERROR);
 	}
 	server_unzoom_window(w);
 
+	if (window_count_panes(w) == 1) {
+		if (server_link_window(src_s, wl, dst_s, idx, 0,
+		    !args_has(args, 'd'), &cause) != 0) {
+			cmdq_error(item, "%s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+		if (args_has(args, 'n')) {
+			window_set_name(w, args_get(args, 'n'));
+			options_set_number(w->options, "automatic-rename", 0);
+		}
+		server_unlink_window(src_s, wl);
+		return (CMD_RETURN_NORMAL);
+	}
+	if (idx != -1 && winlink_find_by_index(&dst_s->windows, idx) != NULL) {
+		cmdq_error(item, "index in use: %d", idx);
+		return (CMD_RETURN_ERROR);
+	}
+
 	TAILQ_REMOVE(&w->panes, wp, entry);
+	server_client_remove_pane(wp);
 	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, w->xpixel, w->ypixel);
+	options_set_parent(wp->options, w->options);
+	wp->flags |= (PANE_STYLECHANGED|PANE_THEMECHANGED);
 	TAILQ_INSERT_HEAD(&w->panes, wp, entry);
 	w->active = wp;
-	name = default_window_name(w);
-	window_set_name(w, name);
-	free(name);
+	w->latest = tc;
+
+	if (!args_has(args, 'n')) {
+		name = default_window_name(w);
+		window_set_name(w, name);
+		free(name);
+	} else {
+		window_set_name(w, args_get(args, 'n'));
+		options_set_number(w->options, "automatic-rename", 0);
+	}
+
 	layout_init(w, wp);
 	wp->flags |= PANE_CHANGED;
+	colour_palette_from_option(&wp->palette, wp->options);
 
 	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(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 +135,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;
-
-		ft = format_create(cmdq, 0);
-		format_defaults(ft, cmdq->state.c, dst_s, wl, wp);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
+		cp = format_single(item, template, tc, dst_s, wl, wp);
+		cmdq_print(item, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}
 	return (CMD_RETURN_NORMAL);
 }

cmd-capture-pane.c

@@ -27,29 +27,42 @@
  * Write the entire contents of a pane to a buffer or stdout.
  */
 
-enum cmd_retval	 cmd_capture_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_capture_pane_exec(struct cmd *, struct cmdq_item *);
 
-char		*cmd_capture_pane_append(char *, size_t *, char *, size_t);
-char		*cmd_capture_pane_pending(struct args *, struct window_pane *,
+static char	*cmd_capture_pane_append(char *, size_t *, char *, size_t);
+static char	*cmd_capture_pane_pending(struct args *, struct window_pane *,
 		     size_t *);
-char		*cmd_capture_pane_history(struct args *, struct cmd_q *,
+static char	*cmd_capture_pane_history(struct args *, struct cmdq_item *,
 		     struct window_pane *, size_t *);
 
 const struct cmd_entry cmd_capture_pane_entry = {
 	.name = "capture-pane",
 	.alias = "capturep",
 
-	.args = { "ab:CeE:JpPqS:t:", 0, 0 },
-	.usage = "[-aCeJpPq] " CMD_BUFFER_USAGE " [-E end-line] "
-		 "[-S start-line]" CMD_TARGET_PANE_USAGE,
+	.args = { "ab:CeE:JMNpPqS:Tt:", 0, 0, NULL },
+	.usage = "[-aCeJMNpPqT] " CMD_BUFFER_USAGE " [-E end-line] "
+		 "[-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 = { "Ht:", 0, 0, NULL },
+	.usage = "[-H] " 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)
 {
@@ -67,7 +80,7 @@ cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
 	size_t		 linelen;
 	u_int		 i;
 
-	pending = input_pending(wp);
+	pending = input_pending(wp->ictx);
 	if (pending == NULL)
 		return (xstrdup(""));
 
@@ -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,37 +103,52 @@ cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
 	return (buf);
 }
 
-char *
-cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
+static char *
+cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
     struct window_pane *wp, size_t *len)
 {
-	struct grid		*gd;
-	const struct grid_line	*gl;
-	struct grid_cell	*gc = NULL;
-	int			 n, with_codes, escape_c0, join_lines;
-	u_int			 i, sx, top, bottom, tmp;
-	char			*cause, *buf, *line;
-	const char		*Sflag, *Eflag;
-	size_t			 linelen;
+	struct grid			*gd;
+	const struct grid_line		*gl;
+	struct screen			*s;
+	struct grid_cell		*gc = NULL;
+	struct window_mode_entry	*wme;
+	int				 n, join_lines, flags = 0;
+	u_int				 i, sx, top, bottom, tmp;
+	char				*cause, *buf, *line;
+	const char			*Sflag, *Eflag;
+	size_t				 linelen;
 
 	sx = screen_size_x(&wp->base);
 	if (args_has(args, 'a')) {
-		gd = wp->saved_grid;
+		gd = wp->base.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(""));
 		}
-	} else
+		s = &wp->base;
+	} else if (args_has(args, 'M')) {
+		wme = TAILQ_FIRST(&wp->modes);
+		if (wme != NULL && wme->mode->get_screen != NULL) {
+			s = wme->mode->get_screen (wme);
+			gd = s->grid;
+		} else {
+			s = &wp->base;
+			gd = wp->base.grid;
+		}
+	} else {
+		s = &wp->base;
 		gd = wp->base.grid;
+	}
 
 	Sflag = args_get(args, 'S');
 	if (Sflag != NULL && strcmp(Sflag, "-") == 0)
 		top = 0;
 	else {
-		n = args_strtonum(args, 'S', INT_MIN, SHRT_MAX, &cause);
+		n = args_strtonum_and_expand(args, 'S', INT_MIN, SHRT_MAX,
+			item, &cause);
 		if (cause != NULL) {
 			top = gd->hsize;
 			free(cause);
@@ -136,7 +164,8 @@ cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
 	if (Eflag != NULL && strcmp(Eflag, "-") == 0)
 		bottom = gd->hsize + gd->sy - 1;
 	else {
-		n = args_strtonum(args, 'E', INT_MIN, SHRT_MAX, &cause);
+		n = args_strtonum_and_expand(args, 'E', INT_MIN, SHRT_MAX,
+			item, &cause);
 		if (cause != NULL) {
 			bottom = gd->hsize + gd->sy - 1;
 			free(cause);
@@ -154,14 +183,19 @@ cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
 		top = tmp;
 	}
 
-	with_codes = args_has(args, 'e');
-	escape_c0 = args_has(args, 'C');
 	join_lines = args_has(args, 'J');
+	if (args_has(args, 'e'))
+		flags |= GRID_STRING_WITH_SEQUENCES;
+	if (args_has(args, 'C'))
+		flags |= GRID_STRING_ESCAPE_SEQUENCES;
+	if (!join_lines && !args_has(args, 'T'))
+		flags |= GRID_STRING_EMPTY_CELLS;
+	if (!join_lines && !args_has(args, 'N'))
+		flags |= GRID_STRING_TRIM_SPACES;
 
 	buf = NULL;
 	for (i = top; i <= bottom; i++) {
-		line = grid_string_cells(gd, 0, i, sx, &gc, with_codes,
-		    escape_c0, !join_lines);
+		line = grid_string_cells(gd, 0, i, sx, &gc, flags, s);
 		linelen = strlen(line);
 
 		buf = cmd_capture_pane_append(buf, len, line, linelen);
@@ -175,44 +209,54 @@ cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
 	return (buf);
 }
 
-enum cmd_retval
-cmd_capture_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_capture_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	struct client		*c;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
+	struct args		*args = cmd_get_args(self);
+	struct client		*c = cmdq_get_client(item);
+	struct window_pane	*wp = cmdq_get_target(item)->wp;
 	char			*buf, *cause;
 	const char		*bufname;
 	size_t			 len;
 
+	if (cmd_get_entry(self) == &cmd_clear_history_entry) {
+		window_pane_reset_mode_all(wp);
+		grid_clear_history(wp->base.grid);
+		if (args_has(args, 'H'))
+			screen_reset_hyperlinks(wp->screen);
+		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;
-		if (c == NULL ||
-		    (c->session != NULL && !(c->flags & CLIENT_CONTROL))) {
-			cmdq_error(cmdq, "can't write to stdout");
+		if (len > 0 && buf[len - 1] == '\n')
+			len--;
+		if (c->flags & CLIENT_CONTROL)
+			control_write(c, "%.*s", (int)len, buf);
+		else {
+			if (!file_can_print(c)) {
+				cmdq_error(item, "can't write to client");
+				free(buf);
+				return (CMD_RETURN_ERROR);
+			}
+			file_print_buffer(c, buf, len);
+			file_print(c, "\n");
 			free(buf);
-			return (CMD_RETURN_ERROR);
 		}
-		evbuffer_add(c->stdout_data, buf, len);
-		free(buf);
-		if (args_has(args, 'P') && len > 0)
-		    evbuffer_add(c->stdout_data, "\n", 1);
-		server_client_push_stdout(c);
 	} else {
 		bufname = NULL;
 		if (args_has(args, 'b'))
 			bufname = args_get(args, 'b');
 
 		if (paste_set(buf, len, bufname, &cause) != 0) {
-			cmdq_error(cmdq, "%s", cause);
+			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,100 @@
 
 #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				\
-	"#{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 *);
+static enum args_parse_type	cmd_choose_tree_args_parse(struct args *args,
+				    u_int idx, char **cause);
+static enum cmd_retval		cmd_choose_tree_exec(struct cmd *,
+    				    struct cmdq_item *);
 
 const struct cmd_entry cmd_choose_tree_entry = {
 	.name = "choose-tree",
 	.alias = NULL,
 
-	.args = { "S:W:swub:c:t:", 0, 1 },
-	.usage = "[-suw] [-b session-template] [-c window template] "
-		 "[-S format] [-W format] " CMD_TARGET_WINDOW_USAGE,
+	.args = { "F:f:GK:NO:rst:wyZ", 0, 1, cmd_choose_tree_args_parse },
+	.usage = "[-GNrswZ] [-F format] [-f filter] [-K key-format] "
+		 "[-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_session_entry = {
-	.name = "choose-session",
+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]",
+	.args = { "F:f:K:NO:rt:yZ", 0, 1, cmd_choose_tree_args_parse },
+	.usage = "[-NrZ] [-F format] [-f filter] [-K key-format] "
+		 "[-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 = {
-	.name = "choose-window",
+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]",
+	.args = { "F:f:K:NO:rt:yZ", 0, 1, cmd_choose_tree_args_parse },
+	.usage = "[-NrZ] [-F format] [-f filter] [-K key-format] "
+		 "[-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
-cmd_choose_tree_exec(struct cmd *self, struct cmd_q *cmdq)
+const struct cmd_entry cmd_customize_mode_entry = {
+	.name = "customize-mode",
+	.alias = NULL,
+
+	.args = { "F:f:Nt:yZ", 0, 0, NULL },
+	.usage = "[-NZ] [-F format] [-f filter] " CMD_TARGET_PANE_USAGE,
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = 0,
+	.exec = cmd_choose_tree_exec
+};
+
+static enum args_parse_type
+cmd_choose_tree_args_parse(__unused struct args *args, __unused u_int idx,
+    __unused char **cause)
 {
-	struct args			*args = self->args;
-	struct client			*c = cmdq->state.c;
-	struct winlink			*wl = cmdq->state.tflag.wl, *wm;
-	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;
+	return (ARGS_PARSE_COMMANDS_OR_STRING);
+}
 
-	ses_template = win_template = NULL;
-	ses_action = win_action = NULL;
+static enum cmd_retval
+cmd_choose_tree_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args			*args = cmd_get_args(self);
+	struct cmd_find_state		*target = cmdq_get_target(item);
+	struct window_pane		*wp = target->wp;
+	const struct window_mode	*mode;
 
-	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);
-
-	/* Sort out which command this is. */
-	wflag = sflag = 0;
-	if (self->entry == &cmd_choose_session_entry) {
-		sflag = 1;
-		if ((ses_template = args_get(args, 'F')) == NULL)
-			ses_template = CHOOSE_TREE_SESSION_TEMPLATE;
-
-		if (args->argc != 0)
-			ses_action = args->argv[0];
-		else
-			ses_action = CMD_CHOOSE_TREE_SESSION_ACTION;
-	} else if (self->entry == &cmd_choose_window_entry) {
-		wflag = 1;
-		if ((win_template = args_get(args, 'F')) == NULL)
-			win_template = CHOOSE_TREE_WINDOW_TEMPLATE;
-
-		if (args->argc != 0)
-			win_action = args->argv[0];
-		else
-			win_action = CMD_CHOOSE_TREE_WINDOW_ACTION;
-	} else {
-		wflag = args_has(args, 'w');
-		sflag = args_has(args, 's');
-
-		if ((ses_action = args_get(args, 'b')) == NULL)
-			ses_action = CMD_CHOOSE_TREE_SESSION_ACTION;
-
-		if ((win_action = args_get(args, 'c')) == NULL)
-			win_action = CMD_CHOOSE_TREE_WINDOW_ACTION;
-
-		if ((ses_template = args_get(args, 'S')) == NULL)
-			ses_template = CHOOSE_TREE_SESSION_TEMPLATE;
-
-		if ((win_template = args_get(args, 'W')) == NULL)
-			win_template = CHOOSE_TREE_WINDOW_TEMPLATE;
-	}
-
-	/*
-	 * If not asking for windows and sessions, assume no "-ws" given and
-	 * hence display the entire tree outright.
-	 */
-	if (!wflag && !sflag)
-		wflag = sflag = 1;
-
-	/*
-	 * If we're drawing in tree mode, including sessions, then pad the
-	 * window template, otherwise just render the windows as a flat list
-	 * without any padding.
-	 */
-	if (wflag && sflag) {
-		xasprintf(&final_win_template_middle,
-		    " \001tq\001> %s", win_template);
-		xasprintf(&final_win_template_last,
-		    " \001mq\001> %s", win_template);
-	} else if (wflag) {
-		final_win_template_middle = xstrdup(win_template);
-		final_win_template_last = xstrdup(win_template);
-	} else
-		final_win_template_middle = final_win_template_last = NULL;
-
-	idx_ses = cur_win = -1;
-	RB_FOREACH(s2, sessions, &sessions) {
-		idx_ses++;
-
-		/*
-		 * If we're just choosing windows, jump straight there. Note
-		 * that this implies the current session, so only choose
-		 * windows when the session matches this one.
-		 */
-		if (wflag && !sflag) {
-			if (s != s2)
-				continue;
-			goto windows_only;
-		}
-
-		wcd = window_choose_add_session(wl->window->active,
-		    c, s2, ses_template, ses_action, idx_ses);
-
-		/* If we're just choosing sessions, skip choosing windows. */
-		if (sflag && !wflag) {
-			if (s == s2)
-				cur_win = idx_ses;
-			continue;
-		}
-windows_only:
-		win_ses = win_max = -1;
-		RB_FOREACH(wm, winlinks, &s2->windows)
-			win_max++;
-		RB_FOREACH(wm, winlinks, &s2->windows) {
-			win_ses++;
-			if (sflag && wflag)
-				idx_ses++;
-
-			if (wm == s2->curw && s == s2) {
-				if (wflag && !sflag) {
-					/*
-					 * Then we're only counting windows.
-					 * So remember which is the current
-					 * window in the list.
-					 */
-					cur_win = win_ses;
-				} else
-					cur_win = idx_ses;
-			}
-
-			xasprintf(&final_win_action, "%s %s %s",
-			    wcd != NULL ? wcd->command : "",
-			    wcd != NULL ? ";" : "", win_action);
-
-			if (win_ses != win_max)
-				cur_win_template = final_win_template_middle;
-			else
-				cur_win_template = final_win_template_last;
-
-			window_choose_add_window(wl->window->active,
-			    c, s2, wm, cur_win_template,
-			    final_win_action,
-			    (wflag && !sflag) ? win_ses : idx_ses);
-
-			free(final_win_action);
-		}
-
-		/*
-		 * If we're just drawing windows, don't consider moving on to
-		 * other sessions as we only list windows in this session.
-		 */
-		if (wflag && !sflag)
-			break;
-	}
-	free(final_win_template_middle);
-	free(final_win_template_last);
-
-	window_choose_ready(wl->window->active, cur_win, NULL);
-
-	if (args_has(args, 'u')) {
-		window_choose_expand_all(wl->window->active);
-		window_choose_set_current(wl->window->active, cur_win);
-	}
+	if (cmd_get_entry(self) == &cmd_choose_buffer_entry) {
+		if (paste_is_empty())
+			return (CMD_RETURN_NORMAL);
+		mode = &window_buffer_mode;
+	} else if (cmd_get_entry(self) == &cmd_choose_client_entry) {
+		if (server_client_how_many() == 0)
+			return (CMD_RETURN_NORMAL);
+		mode = &window_client_mode;
+	} else if (cmd_get_entry(self) == &cmd_customize_mode_entry)
+		mode = &window_customize_mode;
+	else
+		mode = &window_tree_mode;
 
+	window_pane_set_mode(wp, NULL, mode, target, args);
 	return (CMD_RETURN_NORMAL);
 }

cmd-command-prompt.c

@@ -29,146 +29,214 @@
  * Prompt for command in client.
  */
 
-enum cmd_retval	cmd_command_prompt_exec(struct cmd *, struct cmd_q *);
+static enum args_parse_type	cmd_command_prompt_args_parse(struct args *,
+				    u_int, char **);
+static enum cmd_retval		cmd_command_prompt_exec(struct cmd *,
+				    struct cmdq_item *);
 
-int	cmd_command_prompt_callback(void *, const char *);
-void	cmd_command_prompt_free(void *);
+static int	cmd_command_prompt_callback(struct client *, void *,
+		    const char *, int);
+static void	cmd_command_prompt_free(void *);
 
 const struct cmd_entry cmd_command_prompt_entry = {
 	.name = "command-prompt",
 	.alias = NULL,
 
-	.args = { "I:p:t:", 0, 1 },
-	.usage = "[-I inputs] [-p prompts] " CMD_TARGET_CLIENT_USAGE " "
-		 "[template]",
+	.args = { "1bFkiI:Np:t:T:", 0, 1, cmd_command_prompt_args_parse },
+	.usage = "[-1bFkiN] [-I inputs] [-p prompts] " CMD_TARGET_CLIENT_USAGE
+		 " [-T prompt-type] [template]",
 
-	.tflag = CMD_CLIENT,
-
-	.flags = 0,
+	.flags = CMD_CLIENT_TFLAG,
 	.exec = cmd_command_prompt_exec
 };
 
-struct cmd_command_prompt_cdata {
-	struct client	*c;
-	char		*inputs;
-	char		*next_input;
-	char		*next_prompt;
-	char		*prompts;
-	char		*template;
-	int		 idx;
+struct cmd_command_prompt_prompt {
+	char	*input;
+	char	*prompt;
 };
 
-enum cmd_retval
-cmd_command_prompt_exec(struct cmd *self, struct cmd_q *cmdq)
+struct cmd_command_prompt_cdata {
+	struct cmdq_item		 *item;
+	struct args_command_state	 *state;
+
+	int				  flags;
+	enum prompt_type		  prompt_type;
+
+	struct cmd_command_prompt_prompt *prompts;
+	u_int				  count;
+	u_int				  current;
+
+	int				  argc;
+	char				**argv;
+};
+
+static enum args_parse_type
+cmd_command_prompt_args_parse(__unused struct args *args, __unused u_int idx,
+    __unused char **cause)
 {
-	struct args			*args = self->args;
-	const char			*inputs, *prompts;
-	struct cmd_command_prompt_cdata	*cdata;
-	struct client			*c = cmdq->state.c;
-	char				*prompt, *ptr, *input = NULL;
-	size_t				 n;
-
-	if (c->prompt_string != NULL)
-		return (CMD_RETURN_NORMAL);
-
-	cdata = xmalloc(sizeof *cdata);
-	cdata->c = c;
-	cdata->idx = 1;
-	cdata->inputs = NULL;
-	cdata->next_input = NULL;
-	cdata->next_prompt = NULL;
-	cdata->prompts = NULL;
-	cdata->template = NULL;
-
-	if (args->argc != 0)
-		cdata->template = xstrdup(args->argv[0]);
-	else
-		cdata->template = xstrdup("%1");
-
-	if ((prompts = args_get(args, 'p')) != NULL)
-		cdata->prompts = xstrdup(prompts);
-	else if (args->argc != 0) {
-		n = strcspn(cdata->template, " ,");
-		xasprintf(&cdata->prompts, "(%.*s) ", (int) n, cdata->template);
-	} else
-		cdata->prompts = xstrdup(":");
-
-	/* Get first prompt. */
-	cdata->next_prompt = cdata->prompts;
-	ptr = strsep(&cdata->next_prompt, ",");
-	if (prompts == NULL)
-		prompt = xstrdup(ptr);
-	else
-		xasprintf(&prompt, "%s ", ptr);
-
-	/* Get initial prompt input. */
-	if ((inputs = args_get(args, 'I')) != NULL) {
-		cdata->inputs = xstrdup(inputs);
-		cdata->next_input = cdata->inputs;
-		input = strsep(&cdata->next_input, ",");
-	}
-
-	status_prompt_set(c, prompt, input, cmd_command_prompt_callback,
-	    cmd_command_prompt_free, cdata, 0);
-	free(prompt);
-
-	return (CMD_RETURN_NORMAL);
+	return (ARGS_PARSE_COMMANDS_OR_STRING);
 }
 
-int
-cmd_command_prompt_callback(void *data, const char *s)
+static enum cmd_retval
+cmd_command_prompt_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct cmd_command_prompt_cdata	*cdata = data;
-	struct client			*c = cdata->c;
-	struct cmd_list			*cmdlist;
-	char				*cause, *new_template, *prompt, *ptr;
-	char				*input = NULL;
+	struct args			*args = cmd_get_args(self);
+	struct client			*tc = cmdq_get_target_client(item);
+	struct cmd_find_state		*target = cmdq_get_target(item);
+	const char			*type, *s, *input;
+	struct cmd_command_prompt_cdata	*cdata;
+	char				*tmp, *prompts, *prompt, *next_prompt;
+	char				*inputs = NULL, *next_input;
+	u_int				 count = args_count(args);
+	int				 wait = !args_has(args, 'b'), space = 1;
+
+	if (tc->prompt_string != NULL)
+		return (CMD_RETURN_NORMAL);
+	if (args_has(args, 'i'))
+		wait = 0;
+
+	cdata = xcalloc(1, sizeof *cdata);
+	if (wait)
+		cdata->item = item;
+	cdata->state = args_make_commands_prepare(self, item, 0, "%1", wait,
+	    args_has(args, 'F'));
+
+	if ((s = args_get(args, 'p')) == NULL) {
+		if (count != 0) {
+			tmp = args_make_commands_get_command(cdata->state);
+			xasprintf(&prompts, "(%s)", tmp);
+			free(tmp);
+		} else {
+			prompts = xstrdup(":");
+			space = 0;
+		}
+		next_prompt = prompts;
+	} else
+		next_prompt = prompts = xstrdup(s);
+	if ((s = args_get(args, 'I')) != NULL)
+		next_input = inputs = xstrdup(s);
+	else
+		next_input = NULL;
+	while ((prompt = strsep(&next_prompt, ",")) != NULL) {
+		cdata->prompts = xreallocarray(cdata->prompts, cdata->count + 1,
+		    sizeof *cdata->prompts);
+		if (!space)
+			tmp = xstrdup(prompt);
+		else
+			xasprintf(&tmp, "%s ", prompt);
+		cdata->prompts[cdata->count].prompt = tmp;
+
+		if (next_input != NULL) {
+			input = strsep(&next_input, ",");
+			if (input == NULL)
+				input = "";
+		} else
+			input = "";
+		cdata->prompts[cdata->count].input = xstrdup(input);
+
+		cdata->count++;
+	}
+	free(inputs);
+	free(prompts);
+
+	if ((type = args_get(args, 'T')) != NULL) {
+		cdata->prompt_type = status_prompt_type(type);
+		if (cdata->prompt_type == PROMPT_TYPE_INVALID) {
+			cmdq_error(item, "unknown type: %s", type);
+			cmd_command_prompt_free(cdata);
+			return (CMD_RETURN_ERROR);
+		}
+	} else
+		cdata->prompt_type = PROMPT_TYPE_COMMAND;
+
+	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;
+	else if (args_has(args, 'k'))
+		cdata->flags |= PROMPT_KEY;
+	status_prompt_set(tc, target, cdata->prompts[0].prompt,
+	    cdata->prompts[0].input, cmd_command_prompt_callback,
+	    cmd_command_prompt_free, cdata, cdata->flags, cdata->prompt_type);
+
+	if (!wait)
+		return (CMD_RETURN_NORMAL);
+	return (CMD_RETURN_WAIT);
+}
+
+static int
+cmd_command_prompt_callback(struct client *c, void *data, const char *s,
+    int done)
+{
+	struct cmd_command_prompt_cdata		 *cdata = data;
+	char					 *error;
+	struct cmdq_item			 *item = cdata->item, *new_item;
+	struct cmd_list				 *cmdlist;
+	struct cmd_command_prompt_prompt	 *prompt;
+	int					  argc = 0;
+	char					**argv = NULL;
 
 	if (s == NULL)
-		return (0);
+		goto out;
 
-	new_template = cmd_template_replace(cdata->template, s, cdata->idx);
-	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) {
-		xasprintf(&prompt, "%s ", ptr);
-		input = strsep(&cdata->next_input, ",");
-		status_prompt_update(c, prompt, input);
-
-		free(prompt);
-		cdata->idx++;
-		return (1);
-	}
-
-	if (cmd_string_parse(new_template, &cmdlist, NULL, 0, &cause) != 0) {
-		if (cause != NULL) {
-			*cause = toupper((u_char) *cause);
-			status_message_set(c, "%s", cause);
-			free(cause);
+	if (done) {
+		if (cdata->flags & PROMPT_INCREMENTAL)
+			goto out;
+		cmd_append_argv(&cdata->argc, &cdata->argv, s);
+		if (++cdata->current != cdata->count) {
+			prompt = &cdata->prompts[cdata->current];
+			status_prompt_update(c, prompt->prompt, prompt->input);
+			return (1);
 		}
-		return (0);
 	}
 
-	cmdq_run(c->cmdq, cmdlist, NULL);
-	cmd_list_free(cmdlist);
+	argc = cdata->argc;
+	argv = cmd_copy_argv(cdata->argc, cdata->argv);
+	if (!done)
+		cmd_append_argv(&argc, &argv, s);
 
-	if (c->prompt_callbackfn != (void *) &cmd_command_prompt_callback)
+	if (done) {
+		cmd_free_argv(cdata->argc, cdata->argv);
+		cdata->argc = argc;
+		cdata->argv = cmd_copy_argv(argc, argv);
+	}
+
+	cmdlist = args_make_commands(cdata->state, argc, argv, &error);
+	if (cmdlist == NULL) {
+		cmdq_append(c, cmdq_get_error(error));
+		free(error);
+	} else if (item == NULL) {
+		new_item = cmdq_get_command(cmdlist, NULL);
+		cmdq_append(c, new_item);
+	} else {
+		new_item = cmdq_get_command(cmdlist, cmdq_get_state(item));
+		cmdq_insert_after(item, new_item);
+	}
+	cmd_free_argv(argc, argv);
+
+	if (c->prompt_inputcb != cmd_command_prompt_callback)
 		return (1);
+
+out:
+	if (item != NULL)
+		cmdq_continue(item);
 	return (0);
 }
 
-void
+static void
 cmd_command_prompt_free(void *data)
 {
 	struct cmd_command_prompt_cdata	*cdata = data;
+	u_int				 i;
 
-	free(cdata->inputs);
+	for (i = 0; i < cdata->count; i++) {
+		free(cdata->prompts[i].prompt);
+		free(cdata->prompts[i].input);
+	}
 	free(cdata->prompts);
-	free(cdata->template);
+	cmd_free_argv(cdata->argc, cdata->argv);
+	args_make_commands_free(cdata->state);
 	free(cdata);
 }

cmd-confirm-before.c

@@ -28,99 +28,136 @@
  * Asks for confirmation before executing a command.
  */
 
-enum cmd_retval	 cmd_confirm_before_exec(struct cmd *, struct cmd_q *);
+static enum args_parse_type	cmd_confirm_before_args_parse(struct args *,
+				    u_int, char **);
+static enum cmd_retval		cmd_confirm_before_exec(struct cmd *,
+				    struct cmdq_item *);
 
-int		 cmd_confirm_before_callback(void *, const char *);
-void		 cmd_confirm_before_free(void *);
+static int	cmd_confirm_before_callback(struct client *, void *,
+		    const char *, int);
+static void	cmd_confirm_before_free(void *);
 
 const struct cmd_entry cmd_confirm_before_entry = {
 	.name = "confirm-before",
 	.alias = "confirm",
 
-	.args = { "p:t:", 1, 1 },
-	.usage = "[-p prompt] " CMD_TARGET_CLIENT_USAGE " command",
+	.args = { "bc:p:t:y", 1, 1, cmd_confirm_before_args_parse },
+	.usage = "[-by] [-c confirm-key] [-p prompt] " CMD_TARGET_CLIENT_USAGE
+		 " command",
 
-	.tflag = CMD_CLIENT,
-
-	.flags = 0,
+	.flags = CMD_CLIENT_TFLAG,
 	.exec = cmd_confirm_before_exec
 };
 
 struct cmd_confirm_before_data {
-	char		*cmd;
-	struct client	*client;
+	struct cmdq_item	*item;
+	struct cmd_list		*cmdlist;
+	u_char			 confirm_key;
+	int			 default_yes;
 };
 
-enum cmd_retval
-cmd_confirm_before_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum args_parse_type
+cmd_confirm_before_args_parse(__unused struct args *args, __unused u_int idx,
+    __unused char **cause)
 {
-	struct args			*args = self->args;
+	return (ARGS_PARSE_COMMANDS_OR_STRING);
+}
+
+static enum cmd_retval
+cmd_confirm_before_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args			*args = cmd_get_args(self);
 	struct cmd_confirm_before_data	*cdata;
-	struct client			*c = cmdq->state.c;
-	char				*cmd, *copy, *new_prompt, *ptr;
-	const char			*prompt;
+	struct client			*tc = cmdq_get_target_client(item);
+	struct cmd_find_state		*target = cmdq_get_target(item);
+	char				*new_prompt;
+	const char			*confirm_key, *prompt, *cmd;
+	int				 wait = !args_has(args, 'b');
+
+	cdata = xcalloc(1, sizeof *cdata);
+	cdata->cmdlist = args_make_commands_now(self, item, 0, 1);
+	if (cdata->cmdlist == NULL) {
+		free(cdata);
+		return (CMD_RETURN_ERROR);
+	}
+
+	if (wait)
+		cdata->item = item;
+
+	cdata->default_yes = args_has(args, 'y');
+	if ((confirm_key = args_get(args, 'c')) != NULL) {
+		if (confirm_key[1] == '\0' &&
+		    confirm_key[0] > 31 &&
+		    confirm_key[0] < 127)
+			cdata->confirm_key = confirm_key[0];
+		else {
+			cmdq_error(item, "invalid confirm key");
+			free(cdata);
+			return (CMD_RETURN_ERROR);
+		}
+	}
+	else
+		cdata->confirm_key = 'y';
 
 	if ((prompt = args_get(args, 'p')) != NULL)
 		xasprintf(&new_prompt, "%s ", prompt);
 	else {
-		ptr = copy = xstrdup(args->argv[0]);
-		cmd = strsep(&ptr, " \t");
-		xasprintf(&new_prompt, "Confirm '%s'? (y/n) ", cmd);
-		free(copy);
+		cmd = cmd_get_entry(cmd_list_first(cdata->cmdlist))->name;
+		xasprintf(&new_prompt, "Confirm '%s'? (%c/n) ", cmd,
+		    cdata->confirm_key);
 	}
 
-	cdata = xmalloc(sizeof *cdata);
-	cdata->cmd = xstrdup(args->argv[0]);
-
-	cdata->client = c;
-	cdata->client->references++;
-
-	status_prompt_set(c, new_prompt, NULL,
+	status_prompt_set(tc, target, new_prompt, NULL,
 	    cmd_confirm_before_callback, cmd_confirm_before_free, cdata,
-	    PROMPT_SINGLE);
-
+	    PROMPT_SINGLE, PROMPT_TYPE_COMMAND);
 	free(new_prompt);
-	return (CMD_RETURN_NORMAL);
+
+	if (!wait)
+		return (CMD_RETURN_NORMAL);
+	return (CMD_RETURN_WAIT);
 }
 
-int
-cmd_confirm_before_callback(void *data, const char *s)
+static int
+cmd_confirm_before_callback(struct client *c, void *data, const char *s,
+    __unused int done)
 {
 	struct cmd_confirm_before_data	*cdata = data;
-	struct client			*c = cdata->client;
-	struct cmd_list			*cmdlist;
-	char				*cause;
+	struct cmdq_item		*item = cdata->item, *new_item;
+	int				 retcode = 1;
 
 	if (c->flags & CLIENT_DEAD)
-		return (0);
+		goto out;
 
-	if (s == NULL || *s == '\0')
-		return (0);
-	if (tolower((u_char) s[0]) != 'y' || s[1] != '\0')
-		return (0);
+	if (s == NULL)
+		goto out;
+	if (s[0] != cdata->confirm_key && (s[0] != '\r' || !cdata->default_yes))
+		goto out;
+	retcode = 0;
 
-	if (cmd_string_parse(cdata->cmd, &cmdlist, NULL, 0, &cause) != 0) {
-		if (cause != NULL) {
-			cmdq_error(c->cmdq, "%s", cause);
-			free(cause);
-		}
-		return (0);
+	if (item == NULL) {
+		new_item = cmdq_get_command(cdata->cmdlist, NULL);
+		cmdq_append(c, new_item);
+	} else {
+		new_item = cmdq_get_command(cdata->cmdlist,
+		    cmdq_get_state(item));
+		cmdq_insert_after(item, new_item);
 	}
 
-	cmdq_run(c->cmdq, cmdlist, NULL);
-	cmd_list_free(cmdlist);
-
+out:
+	if (item != NULL) {
+		if (cmdq_get_client(item) != NULL &&
+		    cmdq_get_client(item)->session == NULL)
+			cmdq_get_client(item)->retval = retcode;
+		cmdq_continue(item);
+	}
 	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);
+	cmd_list_free(cdata->cmdlist);
 	free(cdata);
 }

cmd-copy-mode.c

@@ -24,18 +24,19 @@
  * 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",
 	.alias = NULL,
 
-	.args = { "Met:u", 0, 0 },
-	.usage = "[-Mu] " CMD_TARGET_PANE_USAGE,
+	.args = { "deHMqSs:t:u", 0, 0, NULL },
+	.usage = "[-deHMqSu] [-s src-pane] " CMD_TARGET_PANE_USAGE,
 
-	.tflag = CMD_PANE,
+	.source =  { 's', CMD_FIND_PANE, 0 },
+	.target = { 't', CMD_FIND_PANE, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_copy_mode_exec
 };
 
@@ -43,47 +44,60 @@ const struct cmd_entry cmd_clock_mode_entry = {
 	.name = "clock-mode",
 	.alias = NULL,
 
-	.args = { "t:", 0, 0 },
+	.args = { "t:", 0, 0, NULL },
 	.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
-cmd_copy_mode_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_copy_mode_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	struct client		*c = cmdq->client;
+	struct args		*args = cmd_get_args(self);
+	struct key_event	*event = cmdq_get_event(item);
+	struct cmd_find_state	*source = cmdq_get_source(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct client		*c = cmdq_get_client(item);
 	struct session		*s;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
+	struct window_pane	*wp = target->wp, *swp;
+
+	if (args_has(args, 'q')) {
+		window_pane_reset_mode_all(wp);
+		return (CMD_RETURN_NORMAL);
+	}
 
 	if (args_has(args, 'M')) {
-		if ((wp = cmd_mouse_pane(&cmdq->item->mouse, &s, NULL)) == NULL)
+		if ((wp = cmd_mouse_pane(&event->m, &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);
+	if (cmd_get_entry(self) == &cmd_clock_mode_entry) {
+		window_pane_set_mode(wp, NULL, &window_clock_mode, NULL, NULL);
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (wp->mode != &window_copy_mode) {
-		if (window_pane_set_mode(wp, &window_copy_mode) != 0)
-			return (CMD_RETURN_NORMAL);
-		window_copy_init_from_pane(wp, args_has(self->args, 'e'));
+	if (args_has(args, 's'))
+		swp = source->wp;
+	else
+		swp = wp;
+	if (!window_pane_set_mode(wp, swp, &window_copy_mode, NULL, args)) {
+		if (args_has(args, 'M'))
+			window_copy_start_drag(c, &event->m);
 	}
-	if (args_has(args, 'M')) {
-		if (wp->mode != NULL && wp->mode != &window_copy_mode)
-			return (CMD_RETURN_NORMAL);
-		window_copy_start_drag(c, &cmdq->item->mouse);
+	if (args_has(args, 'u'))
+		window_copy_pageup(wp, 0);
+	if (args_has(args, 'd'))
+		window_copy_pagedown(wp, 0, args_has(args, 'e'));
+	if (args_has(args, 'S')) {
+		window_copy_scroll(wp, c->tty.mouse_slider_mpos, event->m.y,
+		    args_has(args, 'e'));
+		return (CMD_RETURN_NORMAL);
 	}
-	if (wp->mode == &window_copy_mode && args_has(self->args, 'u'))
-		window_copy_pageup(wp);
 
 	return (CMD_RETURN_NORMAL);
 }

cmd-detach-client.c

@@ -26,19 +26,20 @@
  * 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 },
-	.usage = "[-P] [-a] [-s target-session] " CMD_TARGET_CLIENT_USAGE,
+	.args = { "aE:s:t:P", 0, 0, NULL },
+	.usage = "[-aP] [-E shell-command] "
+	         "[-s target-session] " CMD_TARGET_CLIENT_USAGE,
 
-	.sflag = CMD_SESSION,
-	.tflag = CMD_CLIENT,
+	.source = { 's', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
 
-	.flags = CMD_READONLY,
+	.flags = CMD_READONLY|CMD_CLIENT_TFLAG,
 	.exec = cmd_detach_client_exec
 };
 
@@ -46,27 +47,25 @@ const struct cmd_entry cmd_suspend_client_entry = {
 	.name = "suspend-client",
 	.alias = "suspendc",
 
-	.args = { "t:", 0, 0 },
+	.args = { "t:", 0, 0, NULL },
 	.usage = CMD_TARGET_CLIENT_USAGE,
 
-	.tflag = CMD_CLIENT,
-
-	.flags = 0,
+	.flags = CMD_CLIENT_TFLAG,
 	.exec = cmd_detach_client_exec
 };
 
-enum cmd_retval
-cmd_detach_client_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_detach_client_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	struct client	*c = cmdq->state.c, *cloop;
-	struct session	*s;
-	enum msgtype	 msgtype;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*source = cmdq_get_source(item);
+	struct client		*tc = cmdq_get_target_client(item), *loop;
+	struct session		*s;
+	enum msgtype		 msgtype;
+	const char		*cmd = args_get(args, 'E');
 
-	if (self->entry == &cmd_suspend_client_entry) {
-		tty_stop_tty(&c->tty);
-		c->flags |= CLIENT_SUSPENDED;
-		proc_send(c->peer, MSG_SUSPEND, -1, NULL, 0);
+	if (cmd_get_entry(self) == &cmd_suspend_client_entry) {
+		server_client_suspend(tc);
 		return (CMD_RETURN_NORMAL);
 	}
 
@@ -76,22 +75,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;
-		TAILQ_FOREACH(cloop, &clients, entry) {
-			if (cloop->session == s)
-				server_client_detach(cloop, msgtype);
+		s = source->s;
+		if (s == NULL)
+			return (CMD_RETURN_NORMAL);
+		TAILQ_FOREACH(loop, &clients, entry) {
+			if (loop->session == s) {
+				if (cmd != NULL)
+					server_client_exec(loop, cmd);
+				else
+					server_client_detach(loop, msgtype);
+			}
 		}
 		return (CMD_RETURN_STOP);
 	}
 
 	if (args_has(args, 'a')) {
-		TAILQ_FOREACH(cloop, &clients, entry) {
-			if (cloop->session != NULL && cloop != c)
-				server_client_detach(cloop, msgtype);
+		TAILQ_FOREACH(loop, &clients, entry) {
+			if (loop->session != NULL && loop != tc) {
+				if (cmd != NULL)
+					server_client_exec(loop, cmd);
+				else
+					server_client_detach(loop, msgtype);
+			}
 		}
 		return (CMD_RETURN_NORMAL);
 	}
 
-	server_client_detach(c, msgtype);
+	if (cmd != NULL)
+		server_client_exec(tc, cmd);
+	else
+		server_client_detach(tc, msgtype);
 	return (CMD_RETURN_STOP);
 }

cmd-display-menu.c

@@ -0,0 +1,502 @@
+/* $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 args_parse_type	cmd_display_menu_args_parse(struct args *,
+				    u_int, char **);
+static enum cmd_retval		cmd_display_menu_exec(struct cmd *,
+				    struct cmdq_item *);
+static enum cmd_retval		cmd_display_popup_exec(struct cmd *,
+				    struct cmdq_item *);
+
+const struct cmd_entry cmd_display_menu_entry = {
+	.name = "display-menu",
+	.alias = "menu",
+
+	.args = { "b:c:C:H:s:S:MOt:T:x:y:", 1, -1, cmd_display_menu_args_parse },
+	.usage = "[-MO] [-b border-lines] [-c target-client] "
+		 "[-C starting-choice] [-H selected-style] [-s style] "
+		 "[-S border-style] " CMD_TARGET_PANE_USAGE " [-T title] "
+		 "[-x position] [-y position] name [key] [command] ...",
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_CFLAG,
+	.exec = cmd_display_menu_exec
+};
+
+const struct cmd_entry cmd_display_popup_entry = {
+	.name = "display-popup",
+	.alias = "popup",
+
+	.args = { "Bb:Cc:d:e:Eh:s:S:t:T:w:x:y:", 0, -1, NULL },
+	.usage = "[-BCE] [-b border-lines] [-c target-client] "
+		 "[-d start-directory] [-e environment] [-h height] "
+		 "[-s style] [-S border-style] " CMD_TARGET_PANE_USAGE
+		 " [-T title] [-w width] [-x position] [-y position] "
+		 "[shell-command [argument ...]]",
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_CFLAG,
+	.exec = cmd_display_popup_exec
+};
+
+static enum args_parse_type
+cmd_display_menu_args_parse(struct args *args, u_int idx, __unused char **cause)
+{
+	u_int			 i = 0;
+	enum args_parse_type	 type = ARGS_PARSE_STRING;
+
+	for (;;) {
+		type = ARGS_PARSE_STRING;
+		if (i == idx)
+			break;
+		if (*args_string(args, i++) == '\0')
+			continue;
+
+		type = ARGS_PARSE_STRING;
+		if (i++ == idx)
+			break;
+
+		type = ARGS_PARSE_COMMANDS_OR_STRING;
+		if (i++ == idx)
+			break;
+	}
+	return (type);
+}
+
+static int
+cmd_display_menu_get_position(struct client *tc, struct cmdq_item *item,
+    struct args *args, u_int *px, u_int *py, u_int w, u_int h)
+{
+	struct tty		*tty = &tc->tty;
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct key_event	*event = cmdq_get_event(item);
+	struct session		*s = tc->session;
+	struct winlink		*wl = target->wl;
+	struct window_pane	*wp = target->wp;
+	struct style_ranges	*ranges = NULL;
+	struct style_range	*sr = NULL;
+	const char		*xp, *yp;
+	char			*p;
+	int			 top;
+	u_int			 line, ox, oy, sx, sy, lines, position;
+	long			 n;
+	struct format_tree	*ft;
+
+	/*
+	 * Work out the position from the -x and -y arguments. This is the
+	 * bottom-left position.
+	 */
+
+	/* If the popup is too big, stop now. */
+	if (w > tty->sx || h > tty->sy)
+		return (0);
+
+	/* Create format with mouse position if any. */
+	ft = format_create_from_target(item);
+	if (event->m.valid) {
+		format_add(ft, "popup_mouse_x", "%u", event->m.x);
+		format_add(ft, "popup_mouse_y", "%u", event->m.y);
+	}
+
+	/*
+	 * If there are any status lines, add this window position and the
+	 * status line position.
+	 */
+	top = status_at_line(tc);
+	if (top != -1) {
+		lines = status_line_size(tc);
+		if (top == 0)
+			top = lines;
+		else
+			top = 0;
+		position = options_get_number(s->options, "status-position");
+
+		for (line = 0; line < lines; line++) {
+			ranges = &tc->status.entries[line].ranges;
+			TAILQ_FOREACH(sr, ranges, entry) {
+				if (sr->type != STYLE_RANGE_WINDOW)
+					continue;
+				if (sr->argument == (u_int)wl->idx)
+					break;
+			}
+			if (sr != NULL)
+				break;
+		}
+
+		if (sr != NULL) {
+			format_add(ft, "popup_window_status_line_x", "%u",
+			    sr->start);
+			if (position == 0) {
+				format_add(ft, "popup_window_status_line_y",
+				    "%u", line + 1 + h);
+			} else {
+				format_add(ft, "popup_window_status_line_y",
+				    "%u", tty->sy - lines + line);
+			}
+		}
+
+		if (position == 0)
+			format_add(ft, "popup_status_line_y", "%u", lines + h);
+		else {
+			format_add(ft, "popup_status_line_y", "%u",
+			    tty->sy - lines);
+		}
+	} else
+		top = 0;
+
+	/* Popup width and height. */
+	format_add(ft, "popup_width", "%u", w);
+	format_add(ft, "popup_height", "%u", h);
+
+	/* Position so popup is in the centre. */
+	n = (long)(tty->sx - 1) / 2 - w / 2;
+	if (n < 0)
+		format_add(ft, "popup_centre_x", "%u", 0);
+	else
+		format_add(ft, "popup_centre_x", "%ld", n);
+	n = (tty->sy - 1) / 2 + h / 2;
+	if (n >= tty->sy)
+		format_add(ft, "popup_centre_y", "%u", tty->sy - h);
+	else
+		format_add(ft, "popup_centre_y", "%ld", n);
+
+	/* Position of popup relative to mouse. */
+	if (event->m.valid) {
+		n = (long)event->m.x - w / 2;
+		if (n < 0)
+			format_add(ft, "popup_mouse_centre_x", "%u", 0);
+		else
+			format_add(ft, "popup_mouse_centre_x", "%ld", n);
+		n = event->m.y - h / 2;
+		if (n + h >= tty->sy) {
+			format_add(ft, "popup_mouse_centre_y", "%u",
+			    tty->sy - h);
+		} else
+			format_add(ft, "popup_mouse_centre_y", "%ld", n);
+		n = (long)event->m.y + h;
+		if (n >= tty->sy)
+			format_add(ft, "popup_mouse_top", "%u", tty->sy - 1);
+		else
+			format_add(ft, "popup_mouse_top", "%ld", n);
+		n = event->m.y - h;
+		if (n < 0)
+			format_add(ft, "popup_mouse_bottom", "%u", 0);
+		else
+			format_add(ft, "popup_mouse_bottom", "%ld", n);
+	}
+
+	/* Position in pane. */
+	tty_window_offset(&tc->tty, &ox, &oy, &sx, &sy);
+	n = top + wp->yoff - oy + h;
+	if (n >= tty->sy)
+		format_add(ft, "popup_pane_top", "%u", tty->sy - h);
+	else
+		format_add(ft, "popup_pane_top", "%ld", n);
+	format_add(ft, "popup_pane_bottom", "%u", top + wp->yoff + wp->sy - oy);
+	format_add(ft, "popup_pane_left", "%u", wp->xoff - ox);
+	n = (long)wp->xoff + wp->sx - ox - w;
+	if (n < 0)
+		format_add(ft, "popup_pane_right", "%u", 0);
+	else
+		format_add(ft, "popup_pane_right", "%ld", n);
+
+	/* Expand horizontal position. */
+	xp = args_get(args, 'x');
+	if (xp == NULL || strcmp(xp, "C") == 0)
+		xp = "#{popup_centre_x}";
+	else if (strcmp(xp, "R") == 0)
+		xp = "#{popup_pane_right}";
+	else if (strcmp(xp, "P") == 0)
+		xp = "#{popup_pane_left}";
+	else if (strcmp(xp, "M") == 0)
+		xp = "#{popup_mouse_centre_x}";
+	else if (strcmp(xp, "W") == 0)
+		xp = "#{popup_window_status_line_x}";
+	p = format_expand(ft, xp);
+	n = strtol(p, NULL, 10);
+	if (n + w >= tty->sx)
+		n = tty->sx - w;
+	else if (n < 0)
+		n = 0;
+	*px = n;
+	log_debug("%s: -x: %s = %s = %u (-w %u)", __func__, xp, p, *px, w);
+	free(p);
+
+	/* Expand vertical position  */
+	yp = args_get(args, 'y');
+	if (yp == NULL || strcmp(yp, "C") == 0)
+		yp = "#{popup_centre_y}";
+	else if (strcmp(yp, "P") == 0)
+		yp = "#{popup_pane_bottom}";
+	else if (strcmp(yp, "M") == 0)
+		yp = "#{popup_mouse_top}";
+	else if (strcmp(yp, "S") == 0)
+		yp = "#{popup_status_line_y}";
+	else if (strcmp(yp, "W") == 0)
+		yp = "#{popup_window_status_line_y}";
+	p = format_expand(ft, yp);
+	n = strtol(p, NULL, 10);
+	if (n < h)
+		n = 0;
+	else
+		n -= h;
+	if (n + h >= tty->sy)
+		n = tty->sy - h;
+	else if (n < 0)
+		n = 0;
+	*py = n;
+	log_debug("%s: -y: %s = %s = %u (-h %u)", __func__, yp, p, *py, h);
+	free(p);
+
+	format_free(ft);
+	return (1);
+}
+
+static enum cmd_retval
+cmd_display_menu_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct key_event	*event = cmdq_get_event(item);
+	struct client		*tc = cmdq_get_target_client(item);
+	struct menu		*menu = NULL;
+	struct menu_item	 menu_item;
+	const char		*key, *name, *value;
+	const char		*style = args_get(args, 's');
+	const char		*border_style = args_get(args, 'S');
+	const char		*selected_style = args_get(args, 'H');
+	enum box_lines		 lines = BOX_LINES_DEFAULT;
+	char			*title, *cause;
+	int			 flags = 0, starting_choice = 0;
+	u_int			 px, py, i, count = args_count(args);
+	struct options		*o = target->s->curw->window->options;
+	struct options_entry	*oe;
+
+
+	if (tc->overlay_draw != NULL)
+		return (CMD_RETURN_NORMAL);
+
+	if (args_has(args, 'C')) {
+		if (strcmp(args_get(args, 'C'), "-") == 0)
+			starting_choice = -1;
+		else {
+			starting_choice = args_strtonum(args, 'C', 0, UINT_MAX,
+			    &cause);
+			if (cause != NULL) {
+				cmdq_error(item, "starting choice %s", cause);
+				free(cause);
+				return (CMD_RETURN_ERROR);
+			}
+		}
+	}
+
+	if (args_has(args, 'T'))
+		title = format_single_from_target(item, args_get(args, 'T'));
+	else
+		title = xstrdup("");
+	menu = menu_create(title);
+	free(title);
+
+	for (i = 0; i != count; /* nothing */) {
+		name = args_string(args, i++);
+		if (*name == '\0') {
+			menu_add_item(menu, NULL, item, tc, target);
+			continue;
+		}
+
+		if (count - i < 2) {
+			cmdq_error(item, "not enough arguments");
+			menu_free(menu);
+			return (CMD_RETURN_ERROR);
+		}
+		key = args_string(args, i++);
+
+		menu_item.name = name;
+		menu_item.key = key_string_lookup_string(key);
+		menu_item.command = args_string(args, i++);
+
+		menu_add_item(menu, &menu_item, item, tc, target);
+	}
+	if (menu == NULL) {
+		cmdq_error(item, "invalid menu arguments");
+		return (CMD_RETURN_ERROR);
+	}
+	if (menu->count == 0) {
+		menu_free(menu);
+		return (CMD_RETURN_NORMAL);
+	}
+	if (!cmd_display_menu_get_position(tc, item, args, &px, &py,
+	    menu->width + 4, menu->count + 2)) {
+		menu_free(menu);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	value = args_get(args, 'b');
+	if (value != NULL) {
+		oe = options_get(o, "menu-border-lines");
+		lines = options_find_choice(options_table_entry(oe), value,
+		    &cause);
+		if (lines == -1) {
+			cmdq_error(item, "menu-border-lines %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+	}
+
+	if (args_has(args, 'O'))
+		flags |= MENU_STAYOPEN;
+	if (!event->m.valid && !args_has(args, 'M'))
+		flags |= MENU_NOMOUSE;
+	if (menu_display(menu, flags, starting_choice, item, px, py, tc, lines,
+	    style, selected_style, border_style, target, NULL, NULL) != 0)
+		return (CMD_RETURN_NORMAL);
+	return (CMD_RETURN_WAIT);
+}
+
+static enum cmd_retval
+cmd_display_popup_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct session		*s = target->s;
+	struct client		*tc = cmdq_get_target_client(item);
+	struct tty		*tty = &tc->tty;
+	const char		*value, *shell, *shellcmd = NULL;
+	const char		*style = args_get(args, 's');
+	const char		*border_style = args_get(args, 'S');
+	char			*cwd, *cause = NULL, **argv = NULL, *title;
+	int			 flags = 0, argc = 0;
+	enum box_lines		 lines = BOX_LINES_DEFAULT;
+	u_int			 px, py, w, h, count = args_count(args);
+	struct args_value	*av;
+	struct environ		*env = NULL;
+	struct options		*o = s->curw->window->options;
+	struct options_entry	*oe;
+
+	if (args_has(args, 'C')) {
+		server_client_clear_overlay(tc);
+		return (CMD_RETURN_NORMAL);
+	}
+	if (tc->overlay_draw != NULL)
+		return (CMD_RETURN_NORMAL);
+
+	h = tty->sy / 2;
+	if (args_has(args, 'h')) {
+		h = args_percentage(args, 'h', 1, tty->sy, tty->sy, &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "height %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+	}
+
+	w = tty->sx / 2;
+	if (args_has(args, 'w')) {
+		w = args_percentage(args, 'w', 1, tty->sx, tty->sx, &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "width %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+	}
+
+	if (w > tty->sx)
+		w = tty->sx;
+	if (h > tty->sy)
+		h = tty->sy;
+	if (!cmd_display_menu_get_position(tc, item, args, &px, &py, w, h))
+		return (CMD_RETURN_NORMAL);
+
+	value = args_get(args, 'b');
+	if (args_has(args, 'B'))
+		lines = BOX_LINES_NONE;
+	else if (value != NULL) {
+		oe = options_get(o, "popup-border-lines");
+		lines = options_find_choice(options_table_entry(oe), value,
+		    &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "popup-border-lines %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+	}
+
+	value = args_get(args, 'd');
+	if (value != NULL)
+		cwd = format_single_from_target(item, value);
+	else
+		cwd = xstrdup(server_client_get_cwd(tc, s));
+	if (count == 0)
+		shellcmd = options_get_string(s->options, "default-command");
+	else if (count == 1)
+		shellcmd = args_string(args, 0);
+	if (count <= 1 && (shellcmd == NULL || *shellcmd == '\0')) {
+		shellcmd = NULL;
+		shell = options_get_string(s->options, "default-shell");
+		if (!checkshell(shell))
+			shell = _PATH_BSHELL;
+		cmd_append_argv(&argc, &argv, shell);
+	} else
+		args_to_vector(args, &argc, &argv);
+
+	if (args_has(args, 'e') >= 1) {
+		env = environ_create();
+		av = args_first_value(args, 'e');
+		while (av != NULL) {
+			environ_put(env, av->string, 0);
+			av = args_next_value(av);
+		}
+	}
+
+	if (args_has(args, 'T'))
+		title = format_single_from_target(item, args_get(args, 'T'));
+	else
+		title = xstrdup("");
+	if (args_has(args, 'E') > 1)
+		flags |= POPUP_CLOSEEXITZERO;
+	else if (args_has(args, 'E'))
+		flags |= POPUP_CLOSEEXIT;
+	if (popup_display(flags, lines, item, px, py, w, h, env, shellcmd, argc,
+	    argv, cwd, title, tc, s, style, border_style, NULL, NULL) != 0) {
+		cmd_free_argv(argc, argv);
+		if (env != NULL)
+			environ_free(env);
+		free(cwd);
+		free(title);
+		return (CMD_RETURN_NORMAL);
+	}
+	if (env != NULL)
+		environ_free(env);
+	free(cwd);
+	free(title);
+	cmd_free_argv(argc, argv);
+	return (CMD_RETURN_WAIT);
+}

cmd-display-message.c

@@ -32,55 +32,128 @@
 	"#{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 },
-	.usage = "[-p] [-c target-client] [-F format] "
+	.args = { "aCc:d:lINpt:F:v", 0, 1, NULL },
+	.usage = "[-aCIlNpv] [-c target-client] [-d delay] [-F format] "
 		 CMD_TARGET_PANE_USAGE " [message]",
 
-	.cflag = CMD_CLIENT_CANFAIL,
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_CFLAG|CMD_CLIENT_CANFAIL,
 	.exec = cmd_display_message_exec
 };
 
-enum cmd_retval
-cmd_display_message_exec(struct cmd *self, struct cmd_q *cmdq)
+static void
+cmd_display_message_each(const char *key, const char *value, void *arg)
 {
-	struct args		*args = self->args;
-	struct client		*c = cmdq->state.c;
-	struct session		*s = cmdq->state.tflag.s;
-	struct winlink		*wl = cmdq->state.tflag.wl;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
-	const char		*template;
-	char			*msg;
-	struct format_tree	*ft;
+	struct cmdq_item	*item = arg;
 
-	if (args_has(args, 'F') && args->argc != 0) {
-		cmdq_error(cmdq, "only one of -F or argument must be given");
+	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 = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct client		*tc = cmdq_get_target_client(item), *c;
+	struct session		*s = target->s;
+	struct winlink		*wl = target->wl;
+	struct window_pane	*wp = target->wp;
+	const char		*template;
+	char			*msg, *cause;
+	int			 delay = -1, flags, Nflag = args_has(args, 'N');
+	int			 Cflag = args_has(args, 'C');
+	struct format_tree	*ft;
+	u_int			 count = args_count(args);
+	struct evbuffer		*evb;
+
+	if (args_has(args, 'I')) {
+		if (wp == NULL)
+			return (CMD_RETURN_NORMAL);
+		switch (window_pane_start_input(wp, item, &cause)) {
+		case -1:
+			cmdq_error(item, "%s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		case 1:
+			return (CMD_RETURN_NORMAL);
+		case 0:
+			return (CMD_RETURN_WAIT);
+		}
+	}
+
+	if (args_has(args, 'F') && count != 0) {
+		cmdq_error(item, "only one of -F or argument must be given");
 		return (CMD_RETURN_ERROR);
 	}
 
-	template = args_get(args, 'F');
-	if (args->argc != 0)
-		template = args->argv[0];
+	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);
+		}
+	}
+
+	if (count != 0)
+		template = args_string(args, 0);
+	else
+		template = args_get(args, 'F');
 	if (template == NULL)
 		template = DISPLAY_MESSAGE_TEMPLATE;
 
-	ft = format_create(cmdq, 0);
+	/*
+	 * -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.
+	 */
+	if (tc != NULL && tc->session == s)
+		c = tc;
+	else if (s != NULL)
+		c = cmd_find_best_client(s);
+	else
+		c = NULL;
+	if (args_has(args, 'v'))
+		flags = FORMAT_VERBOSE;
+	else
+		flags = 0;
+	ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, flags);
 	format_defaults(ft, c, s, wl, wp);
 
-	msg = format_expand_time(ft, template, time(NULL));
-	if (args_has(self->args, 'p'))
-		cmdq_print(cmdq, "%s", msg);
+	if (args_has(args, 'a')) {
+		format_each(ft, cmd_display_message_each, item);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	if (args_has(args, 'l'))
+		msg = xstrdup(template);
 	else
-		status_message_set(c, "%s", msg);
+		msg = format_expand_time(ft, template);
+
+	if (cmdq_get_client(item) == NULL)
+		cmdq_error(item, "%s", msg);
+	else if (args_has(args, 'p'))
+		cmdq_print(item, "%s", msg);
+	else if (tc != NULL && (tc->flags & CLIENT_CONTROL)) {
+		evb = evbuffer_new();
+		if (evb == NULL)
+			fatalx("out of memory");
+		evbuffer_add_printf(evb, "%%message %s", msg);
+		server_client_print(tc, 0, evb);
+		evbuffer_free(evb);
+	} else if (tc != NULL)
+		status_message_set(tc, delay, 0, Nflag, Cflag, "%s", msg);
 	free(msg);
+
 	format_free(ft);
 
 	return (CMD_RETURN_NORMAL);

cmd-display-panes.c

@@ -18,31 +18,295 @@
 
 #include <sys/types.h>
 
+#include <stdlib.h>
+#include <string.h>
+
 #include "tmux.h"
 
 /*
  * Display panes on a client.
  */
 
-enum cmd_retval	 cmd_display_panes_exec(struct cmd *, struct cmd_q *);
+static enum args_parse_type	cmd_display_panes_args_parse(struct args *,
+				    u_int, char **);
+static enum cmd_retval		cmd_display_panes_exec(struct cmd *,
+				    struct cmdq_item *);
 
 const struct cmd_entry cmd_display_panes_entry = {
 	.name = "display-panes",
 	.alias = "displayp",
 
-	.args = { "t:", 0, 0 },
-	.usage = CMD_TARGET_CLIENT_USAGE,
+	.args = { "bd:Nt:", 0, 1, cmd_display_panes_args_parse },
+	.usage = "[-bN] [-d duration] " CMD_TARGET_CLIENT_USAGE " [template]",
 
-	.tflag = CMD_CLIENT,
-
-	.flags = 0,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG,
 	.exec = cmd_display_panes_exec
 };
 
-enum cmd_retval
-cmd_display_panes_exec(__unused struct cmd *self, struct cmd_q *cmdq)
-{
-	server_set_identify(cmdq->state.c);
+struct cmd_display_panes_data {
+	struct cmdq_item		*item;
+	struct args_command_state	*state;
+};
 
-	return (CMD_RETURN_NORMAL);
+static enum args_parse_type
+cmd_display_panes_args_parse(__unused struct args *args, __unused u_int idx,
+    __unused char **cause)
+{
+	return (ARGS_PARSE_COMMANDS_OR_STRING);
+}
+
+static void
+cmd_display_panes_draw_pane(struct screen_redraw_ctx *ctx,
+    struct window_pane *wp)
+{
+	struct client		*c = ctx->c;
+	struct tty		*tty = &c->tty;
+	struct session		*s = c->session;
+	struct options		*oo = s->options;
+	struct window		*w = wp->window;
+	struct grid_cell	 fgc, bgc;
+	u_int			 pane, idx, px, py, i, j, xoff, yoff, sx, sy;
+	int			 colour, active_colour;
+	char			 buf[16], lbuf[16], rbuf[16], *ptr;
+	size_t			 len, llen, rlen;
+
+	if (wp->xoff + wp->sx <= ctx->ox ||
+	    wp->xoff >= ctx->ox + ctx->sx ||
+	    wp->yoff + wp->sy <= ctx->oy ||
+	    wp->yoff >= ctx->oy + ctx->sy)
+		return;
+
+	if (wp->xoff >= ctx->ox && wp->xoff + wp->sx <= ctx->ox + ctx->sx) {
+		/* All visible. */
+		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, &pane) != 0)
+		fatalx("index not found");
+	len = xsnprintf(buf, sizeof buf, "%u", pane);
+
+	if (sx < len)
+		return;
+	colour = options_get_number(oo, "display-panes-colour");
+	active_colour = options_get_number(oo, "display-panes-active-colour");
+
+	memcpy(&fgc, &grid_default_cell, sizeof fgc);
+	memcpy(&bgc, &grid_default_cell, sizeof bgc);
+	if (w->active == wp) {
+		fgc.fg = active_colour;
+		bgc.bg = active_colour;
+	} else {
+		fgc.fg = colour;
+		bgc.bg = colour;
+	}
+
+	rlen = xsnprintf(rbuf, sizeof rbuf, "%ux%u", wp->sx, wp->sy);
+	if (pane > 9 && pane < 35)
+		llen = xsnprintf(lbuf, sizeof lbuf, "%c", 'a' + (pane - 10));
+	else
+		llen = 0;
+
+	if (sx < len * 6 || sy < 5) {
+		tty_attributes(tty, &fgc, &grid_default_cell, NULL, NULL);
+		if (sx >= len + llen + 1) {
+			len += llen + 1;
+			tty_cursor(tty, xoff + px - len / 2, yoff + py);
+			tty_putn(tty, buf, len,	 len);
+			tty_putn(tty, " ", 1, 1);
+			tty_putn(tty, lbuf, llen, llen);
+		} else {
+			tty_cursor(tty, xoff + px - len / 2, yoff + py);
+			tty_putn(tty, buf, len, len);
+		}
+		goto out;
+	}
+
+	px -= len * 3;
+	py -= 2;
+
+	tty_attributes(tty, &bgc, &grid_default_cell, NULL, NULL);
+	for (ptr = buf; *ptr != '\0'; ptr++) {
+		if (*ptr < '0' || *ptr > '9')
+			continue;
+		idx = *ptr - '0';
+
+		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;
+	}
+
+	if (sy <= 6)
+		goto out;
+	tty_attributes(tty, &fgc, &grid_default_cell, NULL, NULL);
+	if (rlen != 0 && sx >= rlen) {
+		tty_cursor(tty, xoff + sx - rlen, yoff);
+		tty_putn(tty, rbuf, rlen, rlen);
+	}
+	if (llen != 0) {
+		tty_cursor(tty, xoff + sx / 2 + len * 3 - llen - 1,
+		    yoff + py + 5);
+		tty_putn(tty, lbuf, llen, llen);
+	}
+
+out:
+	tty_cursor(tty, 0, 0);
+}
+
+static void
+cmd_display_panes_draw(struct client *c, __unused void *data,
+    struct screen_redraw_ctx *ctx)
+{
+	struct window		*w = c->session->curw->window;
+	struct window_pane	*wp;
+
+	log_debug("%s: %s @%u", __func__, c->name, w->id);
+
+	TAILQ_FOREACH(wp, &w->panes, entry) {
+		if (window_pane_visible(wp))
+			cmd_display_panes_draw_pane(ctx, wp);
+	}
+}
+
+static void
+cmd_display_panes_free(__unused struct client *c, void *data)
+{
+	struct cmd_display_panes_data	*cdata = data;
+
+	if (cdata->item != NULL)
+		cmdq_continue(cdata->item);
+	args_make_commands_free(cdata->state);
+	free(cdata);
+}
+
+static int
+cmd_display_panes_key(struct client *c, void *data, struct key_event *event)
+{
+	struct cmd_display_panes_data	*cdata = data;
+	char				*expanded, *error;
+	struct cmdq_item		*item = cdata->item, *new_item;
+	struct cmd_list			*cmdlist;
+	struct window			*w = c->session->curw->window;
+	struct window_pane		*wp;
+	u_int				 index;
+	key_code			 key;
+
+	if (event->key >= '0' && event->key <= '9')
+		index = event->key - '0';
+	else if ((event->key & KEYC_MASK_MODIFIERS) == 0) {
+		key = (event->key & KEYC_MASK_KEY);
+		if (key >= 'a' && key <= 'z')
+			index = 10 + (key - 'a');
+		else
+			return (-1);
+	} else
+		return (-1);
+
+	wp = window_pane_at_index(w, index);
+	if (wp == NULL)
+		return (1);
+	window_unzoom(w, 1);
+
+	xasprintf(&expanded, "%%%u", wp->id);
+
+	cmdlist = args_make_commands(cdata->state, 1, &expanded, &error);
+	if (cmdlist == NULL) {
+		cmdq_append(c, cmdq_get_error(error));
+		free(error);
+	} else if (item == NULL) {
+		new_item = cmdq_get_command(cmdlist, NULL);
+		cmdq_append(c, new_item);
+	} else {
+		new_item = cmdq_get_command(cmdlist, cmdq_get_state(item));
+		cmdq_insert_after(item, new_item);
+	}
+
+	free(expanded);
+	return (1);
+}
+
+static enum cmd_retval
+cmd_display_panes_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args			*args = cmd_get_args(self);
+	struct client			*tc = cmdq_get_target_client(item);
+	struct session			*s = tc->session;
+	u_int				 delay;
+	char				*cause;
+	struct cmd_display_panes_data	*cdata;
+	int				 wait = !args_has(args, 'b');
+
+	if (tc->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 = xcalloc(1, sizeof *cdata);
+	if (wait)
+		cdata->item = item;
+	cdata->state = args_make_commands_prepare(self, item, 0,
+	    "select-pane -t \"%%%\"", wait, 0);
+
+	if (args_has(args, 'N')) {
+		server_client_set_overlay(tc, delay, NULL, NULL,
+		    cmd_display_panes_draw, NULL, cmd_display_panes_free, NULL,
+		    cdata);
+	} else {
+		server_client_set_overlay(tc, delay, NULL, NULL,
+		    cmd_display_panes_draw, cmd_display_panes_key,
+		    cmd_display_panes_free, NULL, cdata);
+	}
+
+	if (!wait)
+		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,91 @@
  * Find window containing text.
  */
 
-#define FIND_WINDOW_TEMPLATE					\
-	"#{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)
+static enum cmd_retval	cmd_find_window_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_find_window_entry = {
 	.name = "find-window",
 	.alias = "findw",
 
-	.args = { "F:CNt:T", 1, 4 },
-	.usage = "[-CNT] [-F format] " CMD_TARGET_WINDOW_USAGE " match-string",
+	.args = { "CiNrt:TZ", 1, 1, NULL },
+	.usage = "[-CiNrTZ] " 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 {
-	struct winlink	*wl;
-	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)
+static enum cmd_retval
+cmd_find_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	u_int	match_flags = 0;
+	struct args		*args = cmd_get_args(self), *new_args;
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct window_pane	*wp = target->wp;
+	const char		*s = args_string(args, 0), *suffix = "";
+	const char		*star = "*";
+	struct args_value	*filter;
+	int			 C, N, T;
 
-	/* Turn on flags based on the options. */
-	if (args_has(args, 'T'))
-		match_flags |= CMD_FIND_WINDOW_BY_TITLE;
-	if (args_has(args, 'C'))
-		match_flags |= CMD_FIND_WINDOW_BY_CONTENT;
-	if (args_has(args, 'N'))
-		match_flags |= CMD_FIND_WINDOW_BY_NAME;
+	C = args_has(args, 'C');
+	N = args_has(args, 'N');
+	T = args_has(args, 'T');
 
-	/* If none of the flags were set, default to matching anything. */
-	if (match_flags == 0)
-		match_flags = CMD_FIND_WINDOW_ALL;
+	if (args_has(args, 'r'))
+		star = "";
+	if (args_has(args, 'r') && args_has(args, 'i'))
+		suffix = "/ri";
+	else if (args_has(args, 'r'))
+		suffix = "/r";
+	else if (args_has(args, 'i'))
+		suffix = "/i";
 
-	return (match_flags);
-}
+	if (!C && !N && !T)
+		C = N = T = 1;
 
-void
-cmd_find_window_match(struct cmd_find_window_list *find_list,
-    int match_flags, struct winlink *wl, const char *str,
-    const char *searchstr)
-{
-	struct cmd_find_window_data	*find_data;
-	struct window_pane		*wp;
-	u_int				 i, line;
-	char				*sres;
+	filter = xcalloc(1, sizeof *filter);
+	filter->type = ARGS_STRING;
 
-	find_data = xcalloc(1, sizeof *find_data);
-
-	i = 0;
-	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
-		i++;
-
-		if ((match_flags & CMD_FIND_WINDOW_BY_NAME) &&
-		    fnmatch(searchstr, wl->window->name, 0) == 0) {
-			find_data->list_ctx = xstrdup("");
-			break;
-		}
-
-		if ((match_flags & CMD_FIND_WINDOW_BY_TITLE) &&
-		    fnmatch(searchstr, wp->base.title, 0) == 0) {
-			xasprintf(&find_data->list_ctx,
-			    "pane %u title: \"%s\"", i - 1, wp->base.title);
-			break;
-		}
-
-		if (match_flags & CMD_FIND_WINDOW_BY_CONTENT &&
-		    (sres = window_pane_search(wp, str, &line)) != NULL) {
-			xasprintf(&find_data->list_ctx,
-			    "pane %u line %u: \"%s\"", i - 1, line + 1, sres);
-			free(sres);
-			break;
-		}
+	if (C && N && T) {
+		xasprintf(&filter->string,
+		    "#{||:"
+		    "#{C%s:%s},#{||:#{m%s:%s%s%s,#{window_name}},"
+		    "#{m%s:%s%s%s,#{pane_title}}}}",
+		    suffix, s, suffix, star, s, star, suffix, star, s, star);
+	} else if (C && N) {
+		xasprintf(&filter->string,
+		    "#{||:#{C%s:%s},#{m%s:%s%s%s,#{window_name}}}",
+		    suffix, s, suffix, star, s, star);
+	} else if (C && T) {
+		xasprintf(&filter->string,
+		    "#{||:#{C%s:%s},#{m%s:%s%s%s,#{pane_title}}}",
+		    suffix, s, suffix, star, s, star);
+	} else if (N && T) {
+		xasprintf(&filter->string,
+		    "#{||:#{m%s:%s%s%s,#{window_name}},"
+		    "#{m%s:%s%s%s,#{pane_title}}}",
+		    suffix, star, s, star, suffix, star, s, star);
+	} else if (C) {
+		xasprintf(&filter->string,
+		    "#{C%s:%s}",
+		    suffix, s);
+	} else if (N) {
+		xasprintf(&filter->string,
+		    "#{m%s:%s%s%s,#{window_name}}",
+		    suffix, star, s, star);
+	} else {
+		xasprintf(&filter->string,
+		    "#{m%s:%s%s%s,#{pane_title}}",
+		    suffix, star, s, star);
 	}
 
-	if (find_data->list_ctx != NULL) {
-		find_data->wl = wl;
-		find_data->pane_id = i - 1;
-		TAILQ_INSERT_TAIL(find_list, find_data, entry);
-	} else
-		free(find_data);
-}
+	new_args = args_create();
+	if (args_has(args, 'Z'))
+		args_set(new_args, 'Z', NULL, 0);
+	args_set(new_args, 'f', filter, 0);
 
-enum cmd_retval
-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;
+	window_pane_set_mode(wp, NULL, &window_tree_mode, target, new_args);
+	args_free(new_args);
 
-	if (c == NULL) {
-		cmdq_error(cmdq, "no client available");
-		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

@@ -20,6 +20,7 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 
+#include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -29,176 +30,161 @@
  * 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 args_parse_type	cmd_if_shell_args_parse(struct args *, u_int,
+				    char **);
+static enum cmd_retval		cmd_if_shell_exec(struct cmd *,
+				    struct cmdq_item *);
 
-void	cmd_if_shell_callback(struct job *);
-void	cmd_if_shell_done(struct cmd_q *);
-void	cmd_if_shell_free(void *);
+static void	cmd_if_shell_callback(struct job *);
+static void	cmd_if_shell_free(void *);
 
 const struct cmd_entry cmd_if_shell_entry = {
 	.name = "if-shell",
 	.alias = "if",
 
-	.args = { "bFt:", 2, 3 },
+	.args = { "bFt:", 2, 3, cmd_if_shell_args_parse },
 	.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 {
-	char			*cmd_if;
-	char			*cmd_else;
+	struct args_command_state	*cmd_if;
+	struct args_command_state	*cmd_else;
 
-	struct cmd_q		*cmdq;
-	struct mouse_event	 mouse;
-
-	int			 bflag;
-	int			 references;
+	struct client			*client;
+	struct cmdq_item		*item;
 };
 
-enum cmd_retval
-cmd_if_shell_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum args_parse_type
+cmd_if_shell_args_parse(__unused struct args *args, u_int idx,
+    __unused char **cause)
 {
-	struct args			*args = self->args;
+	if (idx == 1 || idx == 2)
+		return (ARGS_PARSE_COMMANDS_OR_STRING);
+	return (ARGS_PARSE_STRING);
+}
+
+static enum cmd_retval
+cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args			*args = cmd_get_args(self);
+	struct cmd_find_state		*target = cmdq_get_target(item);
 	struct cmd_if_shell_data	*cdata;
-	char				*shellcmd, *cmd, *cause;
+	struct cmdq_item		*new_item;
+	char				*shellcmd;
+	struct client			*tc = cmdq_get_target_client(item);
+	struct session			*s = target->s;
 	struct cmd_list			*cmdlist;
-	struct session			*s = cmdq->state.tflag.s;
-	struct winlink			*wl = cmdq->state.tflag.wl;
-	struct window_pane		*wp = cmdq->state.tflag.wp;
-	struct format_tree		*ft;
-	const char			*cwd;
-
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
-		cwd = cmdq->client->cwd;
-	else if (s != NULL)
-		cwd = s->cwd;
-	else
-		cwd = NULL;
-
-	ft = format_create(cmdq, 0);
-	format_defaults(ft, NULL, s, wl, wp);
-	shellcmd = format_expand(ft, args->argv[0]);
-	format_free(ft);
+	u_int				 count = args_count(args);
+	int				 wait = !args_has(args, 'b');
 
+	shellcmd = format_single_from_target(item, args_string(args, 0));
 	if (args_has(args, 'F')) {
-		cmd = NULL;
 		if (*shellcmd != '0' && *shellcmd != '\0')
-			cmd = args->argv[1];
-		else if (args->argc == 3)
-			cmd = args->argv[2];
-		free(shellcmd);
-		if (cmd == NULL)
+			cmdlist = args_make_commands_now(self, item, 1, 0);
+		else if (count == 3)
+			cmdlist = args_make_commands_now(self, item, 2, 0);
+		else {
+			free(shellcmd);
 			return (CMD_RETURN_NORMAL);
-		if (cmd_string_parse(cmd, &cmdlist, NULL, 0, &cause) != 0) {
-			if (cause != NULL) {
-				cmdq_error(cmdq, "%s", cause);
-				free(cause);
-			}
-			return (CMD_RETURN_ERROR);
 		}
-		cmdq_run(cmdq, cmdlist, &cmdq->item->mouse);
-		cmd_list_free(cmdlist);
+		free(shellcmd);
+		if (cmdlist == NULL)
+			return (CMD_RETURN_ERROR);
+		new_item = cmdq_get_command(cmdlist, cmdq_get_state(item));
+		cmdq_insert_after(item, new_item);
 		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;
+	cdata->cmd_if = args_make_commands_prepare(self, item, 1, NULL, wait,
+	    0);
+	if (count == 3) {
+		cdata->cmd_else = args_make_commands_prepare(self, item, 2,
+		    NULL, wait, 0);
+	}
 
-	cdata->bflag = args_has(args, 'b');
+	if (wait) {
+		cdata->client = cmdq_get_client(item);
+		cdata->item = item;
+	} else
+		cdata->client = tc;
+	if (cdata->client != NULL)
+		cdata->client->references++;
 
-	cdata->cmdq = cmdq;
-	memcpy(&cdata->mouse, &cmdq->item->mouse, sizeof cdata->mouse);
-	cmdq->references++;
-
-	cdata->references = 1;
-	job_run(shellcmd, s, cwd, cmd_if_shell_callback, cmd_if_shell_free,
-	    cdata);
+	if (job_run(shellcmd, 0, NULL, NULL, s,
+	    server_client_get_cwd(cmdq_get_client(item), s), NULL,
+	    cmd_if_shell_callback, cmd_if_shell_free, cdata, 0, -1,
+	    -1) == NULL) {
+		cmdq_error(item, "failed to run command: %s", shellcmd);
+		free(shellcmd);
+		free(cdata);
+		return (CMD_RETURN_ERROR);
+	}
 	free(shellcmd);
 
-	if (cdata->bflag)
+	if (!wait)
 		return (CMD_RETURN_NORMAL);
 	return (CMD_RETURN_WAIT);
 }
 
-void
+static void
 cmd_if_shell_callback(struct job *job)
 {
-	struct cmd_if_shell_data	*cdata = job->data;
-	struct cmd_q			*cmdq = cdata->cmdq, *cmdq1;
+	struct cmd_if_shell_data	*cdata = job_get_data(job);
+	struct client			*c = cdata->client;
+	struct cmdq_item		*item = cdata->item, *new_item;
+	struct args_command_state	*state;
 	struct cmd_list			*cmdlist;
-	char				*cause, *cmd;
+	char				*error;
+	int				 status;
 
-	if (cmdq->flags & CMD_Q_DEAD)
-		return;
-
-	if (!WIFEXITED(job->status) || WEXITSTATUS(job->status) != 0)
-		cmd = cdata->cmd_else;
+	status = job_get_status(job);
+	if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
+		state = cdata->cmd_else;
 	else
-		cmd = cdata->cmd_if;
-	if (cmd == NULL)
-		return;
+		state = cdata->cmd_if;
+	if (state == NULL)
+		goto out;
 
-	if (cmd_string_parse(cmd, &cmdlist, NULL, 0, &cause) != 0) {
-		if (cause != NULL) {
-			cmdq_error(cmdq, "%s", cause);
-			free(cause);
-		}
-		return;
+	cmdlist = args_make_commands(state, 0, NULL, &error);
+	if (cmdlist == NULL) {
+		if (cdata->item == NULL) {
+			*error = toupper((u_char)*error);
+			status_message_set(c, -1, 1, 0, 0, "%s", error);
+		} else
+			cmdq_error(cdata->item, "%s", error);
+		free(error);
+	} else if (item == NULL) {
+		new_item = cmdq_get_command(cmdlist, NULL);
+		cmdq_append(c, new_item);
+	} else {
+		new_item = cmdq_get_command(cmdlist, cmdq_get_state(item));
+		cmdq_insert_after(item, new_item);
 	}
 
-	cmdq1 = cmdq_new(cmdq->client);
-	cmdq1->emptyfn = cmd_if_shell_done;
-	cmdq1->data = cdata;
-
-	cdata->references++;
-	cmdq_run(cmdq1, cmdlist, &cdata->mouse);
-	cmd_list_free(cmdlist);
+out:
+	if (cdata->item != NULL)
+		cmdq_continue(cdata->item);
 }
 
-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
+static void
 cmd_if_shell_free(void *data)
 {
 	struct cmd_if_shell_data	*cdata = data;
-	struct cmd_q			*cmdq = cdata->cmdq;
 
-	if (--cdata->references != 0)
-		return;
+	if (cdata->client != NULL)
+		server_client_unref(cdata->client);
 
-	if (!cmdq_free(cmdq) && !cdata->bflag)
-		cmdq_continue(cmdq);
+	if (cdata->cmd_else != NULL)
+		args_make_commands_free(cdata->cmd_else);
+	args_make_commands_free(cdata->cmd_if);
 
-	free(cdata->cmd_else);
-	free(cdata->cmd_if);
 	free(cdata);
 }

cmd-join-pane.c

@@ -20,6 +20,7 @@
 #include <sys/types.h>
 
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
 
 #include "tmux.h"
@@ -28,19 +29,17 @@
  * Join or move a pane into another (like split/swap/kill).
  */
 
-enum cmd_retval	 cmd_join_pane_exec(struct cmd *, struct cmd_q *);
-
-enum cmd_retval	 join_pane(struct cmd *, struct cmd_q *, int);
+static enum cmd_retval	cmd_join_pane_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_join_pane_entry = {
 	.name = "join-pane",
 	.alias = "joinp",
 
-	.args = { "bdhvp:l:s:t:", 0, 0 },
-	.usage = "[-bdhv] [-p percentage|-l size] " CMD_SRCDST_PANE_USAGE,
+	.args = { "bdfhvp:l:s:t:", 0, 0, NULL },
+	.usage = "[-bdfhv] [-l size] " CMD_SRCDST_PANE_USAGE,
 
-	.sflag = CMD_PANE_MARKED,
-	.tflag = CMD_PANE,
+	.source = { 's', CMD_FIND_PANE, CMD_FIND_DEFAULT_MARKED },
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_join_pane_exec
@@ -50,53 +49,48 @@ const struct cmd_entry cmd_move_pane_entry = {
 	.name = "move-pane",
 	.alias = "movep",
 
-	.args = { "bdhvp:l:s:t:", 0, 0 },
-	.usage = "[-bdhv] [-p percentage|-l size] " CMD_SRCDST_PANE_USAGE,
+	.args = { "bdfhvp:l:s:t:", 0, 0, NULL },
+	.usage = "[-bdfhv] [-l size] " CMD_SRCDST_PANE_USAGE,
 
-	.sflag = CMD_PANE,
-	.tflag = CMD_PANE,
+	.source = { 's', CMD_FIND_PANE, CMD_FIND_DEFAULT_MARKED },
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_join_pane_exec
 };
 
-enum cmd_retval
-cmd_join_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+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 args		*args = cmd_get_args(self);
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct cmd_find_state	*source = cmdq_get_source(item);
 	struct session		*dst_s;
 	struct winlink		*src_wl, *dst_wl;
 	struct window		*src_w, *dst_w;
 	struct window_pane	*src_wp, *dst_wp;
-	char			*cause;
-	int			 size, percentage, dst_idx;
+	char			*cause = NULL;
+	int			 size, dst_idx;
+	int			 flags;
 	enum layout_type	 type;
 	struct layout_cell	*lc;
+	u_int			 curval = 0;
 
-	dst_s = cmdq->state.tflag.s;
-	dst_wl = cmdq->state.tflag.wl;
-	dst_wp = cmdq->state.tflag.wp;
+	dst_s = target->s;
+	dst_wl = target->wl;
+	dst_wp = target->wp;
 	dst_w = dst_wl->window;
 	dst_idx = dst_wl->idx;
 	server_unzoom_window(dst_w);
 
-	src_wl = cmdq->state.sflag.wl;
-	src_wp = cmdq->state.sflag.wp;
+	src_wl = source->wl;
+	src_wp = 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");
-		return (CMD_RETURN_ERROR);
-	}
-	if (!not_same_window && src_wp == dst_wp) {
-		cmdq_error(cmdq, "source and target panes must be different");
+	if (src_wp == dst_wp) {
+		cmdq_error(item, "source and target panes must be different");
 		return (CMD_RETURN_ERROR);
 	}
 
@@ -104,45 +98,64 @@ join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
 	if (args_has(args, 'h'))
 		type = LAYOUT_LEFTRIGHT;
 
+	/* If the 'p' flag is dropped then this bit can be moved into 'l'. */
+	if (args_has(args, 'l') || args_has(args, 'p')) {
+		if (args_has(args, 'f')) {
+			if (type == LAYOUT_TOPBOTTOM)
+				curval = dst_w->sy;
+			else
+				curval = dst_w->sx;
+		} else {
+			if (type == LAYOUT_TOPBOTTOM)
+				curval = dst_wp->sy;
+			else
+				curval = dst_wp->sx;
+		}
+	}
+
 	size = -1;
 	if (args_has(args, 'l')) {
-		size = args_strtonum(args, 'l', 0, INT_MAX, &cause);
-		if (cause != NULL) {
-			cmdq_error(cmdq, "size %s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
+		size = args_percentage_and_expand(args, 'l', 0, INT_MAX, curval,
+			   item, &cause);
 	} else if (args_has(args, 'p')) {
-		percentage = args_strtonum(args, 'p', 0, 100, &cause);
-		if (cause != NULL) {
-			cmdq_error(cmdq, "percentage %s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-		if (type == LAYOUT_TOPBOTTOM)
-			size = (dst_wp->sy * percentage) / 100;
-		else
-			size = (dst_wp->sx * percentage) / 100;
+		size = args_strtonum_and_expand(args, 'l', 0, 100, item,
+			   &cause);
+		if (cause == NULL)
+			size = curval * size / 100;
 	}
-	lc = layout_split_pane(dst_wp, type, size, args_has(args, 'b'));
+	if (cause != NULL) {
+		cmdq_error(item, "size %s", cause);
+		free(cause);
+		return (CMD_RETURN_ERROR);
+	}
+
+	flags = 0;
+	if (args_has(args, 'b'))
+		flags |= SPAWN_BEFORE;
+	if (args_has(args, 'f'))
+		flags |= SPAWN_FULLSIZE;
+
+	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);
 	}
 
 	layout_close_pane(src_wp);
 
+	server_client_remove_pane(src_wp);
 	window_lost_pane(src_w, src_wp);
 	TAILQ_REMOVE(&src_w->panes, src_wp, entry);
 
-	if (window_count_panes(src_w) == 0)
-		server_kill_window(src_w);
-	else
-		notify_window_layout_changed(src_w);
-
 	src_wp->window = dst_w;
-	TAILQ_INSERT_AFTER(&dst_w->panes, dst_wp, src_wp, entry);
-	layout_assign_pane(lc, src_wp);
+	options_set_parent(src_wp->options, dst_w->options);
+	src_wp->flags |= (PANE_STYLECHANGED|PANE_THEMECHANGED);
+	if (flags & SPAWN_BEFORE)
+		TAILQ_INSERT_BEFORE(dst_wp, src_wp, entry);
+	else
+		TAILQ_INSERT_AFTER(&dst_w->panes, dst_wp, src_wp, entry);
+	layout_assign_pane(lc, src_wp, 0);
+	colour_palette_from_option(&src_wp->palette, src_wp->options);
 
 	recalculate_sizes();
 
@@ -150,12 +163,18 @@ 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);
 
-	notify_window_layout_changed(dst_w);
+	if (window_count_panes(src_w) == 0)
+		server_kill_window(src_w, 1);
+	else
+		notify_window("window-layout-changed", src_w);
+	notify_window("window-layout-changed", dst_w);
+
 	return (CMD_RETURN_NORMAL);
 }

cmd-kill-pane.c

@@ -26,48 +26,42 @@
  * 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",
 	.alias = "killp",
 
-	.args = { "at:", 0, 0 },
+	.args = { "at:", 0, 0, NULL },
 	.usage = "[-a] " CMD_TARGET_PANE_USAGE,
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_kill_pane_exec
 };
 
-enum cmd_retval
-cmd_kill_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_kill_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct winlink		*wl = cmdq->state.tflag.wl;
-	struct window_pane	*loopwp, *tmpwp, *wp = cmdq->state.tflag.wp;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct winlink		*wl = target->wl;
+	struct window_pane	*loopwp, *tmpwp, *wp = 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')) {
+	if (args_has(args, 'a')) {
+		server_unzoom_window(wl->window);
 		TAILQ_FOREACH_SAFE(loopwp, &wl->window->panes, entry, tmpwp) {
 			if (loopwp == wp)
 				continue;
+			server_client_remove_pane(loopwp);
 			layout_close_pane(loopwp);
 			window_remove_pane(wl->window, loopwp);
 		}
-	} else {
-		layout_close_pane(wp);
-		window_remove_pane(wl->window, wp);
+		server_redraw_window(wl->window);
+		return (CMD_RETURN_NORMAL);
 	}
-	server_redraw_window(wl->window);
 
+	server_kill_pane(wp);
 	return (CMD_RETURN_NORMAL);
 }

cmd-kill-server.c

@@ -27,13 +27,13 @@
  * 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",
 	.alias = NULL,
 
-	.args = { "", 0, 0 },
+	.args = { "", 0, 0, NULL },
 	.usage = "",
 
 	.flags = 0,
@@ -44,17 +44,17 @@ const struct cmd_entry cmd_start_server_entry = {
 	.name = "start-server",
 	.alias = "start",
 
-	.args = { "", 0, 0 },
+	.args = { "", 0, 0, NULL },
 	.usage = "",
 
 	.flags = CMD_STARTSERVER,
 	.exec = cmd_kill_server_exec
 };
 
-enum cmd_retval
-cmd_kill_server_exec(struct cmd *self, __unused struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_kill_server_exec(struct cmd *self, __unused struct cmdq_item *item)
 {
-	if (self->entry == &cmd_kill_server_entry)
+	if (cmd_get_entry(self) == &cmd_kill_server_entry)
 		kill(getpid(), SIGTERM);
 
 	return (CMD_RETURN_NORMAL);

cmd-kill-session.c

@@ -27,29 +27,28 @@
  * 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",
 	.alias = NULL,
 
-	.args = { "aCt:", 0, 0 },
+	.args = { "aCt:", 0, 0, NULL },
 	.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
-cmd_kill_session_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_kill_session_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	struct session	*s, *sloop, *stmp;
-	struct winlink	*wl;
-
-	s = cmdq->state.tflag.s;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct session		*s = target->s, *sloop, *stmp;
+	struct winlink		*wl;
 
 	if (args_has(args, 'C')) {
 		RB_FOREACH(wl, winlinks, &s->windows) {
@@ -61,12 +60,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,16 +24,16 @@
  * 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",
 	.alias = "killw",
 
-	.args = { "at:", 0, 0 },
+	.args = { "at:", 0, 0, NULL },
 	.usage = "[-a] " CMD_TARGET_WINDOW_USAGE,
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
 	.flags = 0,
 	.exec = cmd_kill_window_exec
@@ -43,39 +43,68 @@ const struct cmd_entry cmd_unlink_window_entry = {
 	.name = "unlink-window",
 	.alias = "unlinkw",
 
-	.args = { "kt:", 0, 0 },
+	.args = { "kt:", 0, 0, NULL },
 	.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
-cmd_kill_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+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 args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct winlink		*wl = target->wl, *loop;
 	struct window		*w = wl->window;
-	struct session		*s = cmdq->state.tflag.s;
+	struct session		*s = target->s;
+	u_int			 found;
 
-	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");
+	if (cmd_get_entry(self) == &cmd_unlink_window_entry) {
+		if (!args_has(args, 'k') && !session_is_linked(s, w)) {
+			cmdq_error(item, "window only linked to one session");
 			return (CMD_RETURN_ERROR);
 		}
 		server_unlink_window(s, wl);
-	} else {
-		if (args_has(args, 'a')) {
-			RB_FOREACH_SAFE(wl2, winlinks, &s->windows, wl3) {
-				if (wl != wl2)
-					server_kill_window(wl2->window);
-			}
-		} else
-			server_kill_window(wl->window);
+		recalculate_sizes();
+		return (CMD_RETURN_NORMAL);
 	}
 
-	recalculate_sizes();
+	if (args_has(args, 'a')) {
+		if (RB_PREV(winlinks, &s->windows, wl) == NULL &&
+		    RB_NEXT(winlinks, &s->windows, wl) == NULL)
+			return (CMD_RETURN_NORMAL);
+
+		/* Kill all windows except the current one. */
+		do {
+			found = 0;
+			RB_FOREACH(loop, winlinks, &s->windows) {
+				if (loop->window != wl->window) {
+					server_kill_window(loop->window, 0);
+					found++;
+					break;
+				}
+			}
+		} while (found != 0);
+
+		/*
+		 * If the current window appears in the session more than once,
+		 * kill it as well.
+		 */
+		found = 0;
+		RB_FOREACH(loop, winlinks, &s->windows) {
+			if (loop->window == wl->window)
+				found++;
+		}
+		if (found > 1)
+			server_kill_window(wl->window, 0);
+
+		server_renumber_all();
+		return (CMD_RETURN_NORMAL);
+	}
+
+	server_kill_window(wl->window, 1);
 	return (CMD_RETURN_NORMAL);
 }

cmd-list-buffers.c

@@ -30,39 +30,49 @@
 #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",
 	.alias = "lsb",
 
-	.args = { "F:", 0, 0 },
-	.usage = "[-F format]",
+	.args = { "F:f:", 0, 0, NULL },
+	.usage = "[-F format] [-f filter]",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_list_buffers_exec
 };
 
-enum cmd_retval
-cmd_list_buffers_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_buffers_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
 	struct paste_buffer	*pb;
 	struct format_tree	*ft;
-	char			*line;
-	const char		*template;
+	const char		*template, *filter;
+	char			*line, *expanded;
+	int			 flag;
 
 	if ((template = args_get(args, 'F')) == NULL)
 		template = LIST_BUFFERS_TEMPLATE;
+	filter = args_get(args, 'f');
 
 	pb = NULL;
 	while ((pb = paste_walk(pb)) != NULL) {
-		ft = format_create(cmdq, 0);
+		ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
 		format_defaults_paste_buffer(ft, pb);
 
-		line = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", line);
-		free(line);
+		if (filter != NULL) {
+			expanded = format_expand(ft, filter);
+			flag = format_true(expanded);
+			free(expanded);
+		} else
+			flag = 1;
+		if (flag) {
+			line = format_expand(ft, template);
+			cmdq_print(item, "%s", line);
+			free(line);
+		}
 
 		format_free(ft);
 	}

cmd-list-clients.c

@@ -28,57 +28,70 @@
  * List all clients.
  */
 
-#define LIST_CLIENTS_TEMPLATE					\
-	"#{client_tty}: #{session_name} "			\
-	"[#{client_width}x#{client_height} #{client_termname}]"	\
-	"#{?client_utf8, (utf8),} #{?client_readonly, (ro),}"
+#define LIST_CLIENTS_TEMPLATE						\
+	"#{client_name}: #{session_name} "				\
+	"[#{client_width}x#{client_height} #{client_termname}] "	\
+	"#{?#{!=:#{client_uid},#{uid}},"				\
+	"[user #{?client_user,#{client_user},#{client_uid},}] ,}"	\
+	"#{?client_flags,(,}#{client_flags}#{?client_flags,),}"
 
-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",
 	.alias = "lsc",
 
-	.args = { "F:t:", 0, 0 },
-	.usage = "[-F format] " CMD_TARGET_SESSION_USAGE,
+	.args = { "F:f:t:", 0, 0, NULL },
+	.usage = "[-F format] [-f filter] " 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
-cmd_list_clients_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_clients_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args 		*args = self->args;
+	struct args 		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
 	struct client		*c;
 	struct session		*s;
 	struct format_tree	*ft;
-	const char		*template;
+	const char		*template, *filter;
 	u_int			 idx;
-	char			*line;
+	char			*line, *expanded;
+	int			 flag;
 
 	if (args_has(args, 't'))
-		s = cmdq->state.tflag.s;
+		s = target->s;
 	else
 		s = NULL;
 
 	if ((template = args_get(args, 'F')) == NULL)
 		template = LIST_CLIENTS_TEMPLATE;
+	filter = args_get(args, 'f');
 
 	idx = 0;
 	TAILQ_FOREACH(c, &clients, entry) {
 		if (c->session == NULL || (s != NULL && s != c->session))
 			continue;
 
-		ft = format_create(cmdq, 0);
+		ft = format_create(cmdq_get_client(item), 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);
-		free(line);
+		if (filter != NULL) {
+			expanded = format_expand(ft, filter);
+			flag = format_true(expanded);
+			free(expanded);
+		} else
+			flag = 1;
+		if (flag) {
+			line = format_expand(ft, template);
+			cmdq_print(item, "%s", line);
+			free(line);
+		}
 
 		format_free(ft);
 

cmd-list-keys.c

@@ -27,19 +27,19 @@
  * List key bindings.
  */
 
-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 *);
 
-enum cmd_retval	 cmd_list_keys_table(struct cmd *, struct cmd_q *);
-enum cmd_retval	 cmd_list_keys_commands(struct cmd_q *);
+static enum cmd_retval	cmd_list_keys_commands(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_list_keys_entry = {
 	.name = "list-keys",
 	.alias = "lsk",
 
-	.args = { "t:T:", 0, 0 },
-	.usage = "[-t mode-table] [-T key-table]",
+	.args = { "1aNP:T:", 0, 1, NULL },
+	.usage = "[-1aN] [-P prefix-string] [-T key-table] [key]",
 
-	.flags = CMD_STARTSERVER,
+	.flags = CMD_STARTSERVER|CMD_AFTERHOOK,
 	.exec = cmd_list_keys_exec
 };
 
@@ -47,44 +47,186 @@ const struct cmd_entry cmd_list_commands_entry = {
 	.name = "list-commands",
 	.alias = "lscm",
 
-	.args = { "", 0, 0 },
-	.usage = "",
+	.args = { "F:", 0, 1, NULL },
+	.usage = "[-F format] [command]",
 
-	.flags = CMD_STARTSERVER,
+	.flags = CMD_STARTSERVER|CMD_AFTERHOOK,
 	.exec = cmd_list_keys_exec
 };
 
-enum cmd_retval
-cmd_list_keys_exec(struct cmd *self, struct cmd_q *cmdq)
+static u_int
+cmd_list_keys_get_width(const char *tablename, key_code only)
 {
-	struct args		*args = self->args;
 	struct key_table	*table;
 	struct key_binding	*bd;
-	const char		*key, *tablename, *r;
-	char			*cp, tmp[BUFSIZ];
-	int			 repeat, width, tablewidth, keywidth;
+	u_int			 width, keywidth = 0;
 
-	if (self->entry == &cmd_list_commands_entry)
-		return (cmd_list_keys_commands(cmdq));
+	table = key_bindings_get_table(tablename, 0);
+	if (table == NULL)
+		return (0);
+	bd = key_bindings_first(table);
+	while (bd != NULL) {
+		if ((only != KEYC_UNKNOWN && bd->key != only) ||
+		    KEYC_IS_MOUSE(bd->key) ||
+		    bd->note == NULL ||
+		    *bd->note == '\0') {
+			bd = key_bindings_next(table, bd);
+			continue;
+		}
+		width = utf8_cstrwidth(key_string_lookup_key(bd->key, 0));
+		if (width > keywidth)
+			keywidth = width;
 
-	if (args_has(args, 't'))
-		return (cmd_list_keys_table(self, cmdq));
+		bd = key_bindings_next(table, bd);
+	}
+	return (keywidth);
+}
+
+static int
+cmd_list_keys_print_notes(struct cmdq_item *item, struct args *args,
+    const char *tablename, u_int keywidth, key_code only, const char *prefix)
+{
+	struct client		*tc = cmdq_get_target_client(item);
+	struct key_table	*table;
+	struct key_binding	*bd;
+	const char		*key;
+	char			*tmp, *note;
+	int			 found = 0;
+
+	table = key_bindings_get_table(tablename, 0);
+	if (table == NULL)
+		return (0);
+	bd = key_bindings_first(table);
+	while (bd != NULL) {
+		if ((only != KEYC_UNKNOWN && bd->key != only) ||
+		    KEYC_IS_MOUSE(bd->key) ||
+		    ((bd->note == NULL || *bd->note == '\0') &&
+		    !args_has(args, 'a'))) {
+			bd = key_bindings_next(table, bd);
+			continue;
+		}
+		found = 1;
+		key = key_string_lookup_key(bd->key, 0);
+
+		if (bd->note == NULL || *bd->note == '\0')
+			note = cmd_list_print(bd->cmdlist, 1);
+		else
+			note = xstrdup(bd->note);
+		tmp = utf8_padcstr(key, keywidth + 1);
+		if (args_has(args, '1') && tc != NULL) {
+			status_message_set(tc, -1, 1, 0, 0, "%s%s%s", prefix,
+			    tmp, note);
+		} else
+			cmdq_print(item, "%s%s%s", prefix, tmp, note);
+		free(tmp);
+		free(note);
+
+		if (args_has(args, '1'))
+			break;
+		bd = key_bindings_next(table, bd);
+	}
+	return (found);
+}
+
+static char *
+cmd_list_keys_get_prefix(struct args *args, key_code *prefix)
+{
+	char	*s;
+
+	*prefix = options_get_number(global_s_options, "prefix");
+	if (!args_has(args, 'P')) {
+		if (*prefix != KEYC_NONE)
+			xasprintf(&s, "%s ", key_string_lookup_key(*prefix, 0));
+		else
+			s = xstrdup("");
+	} else
+		s = xstrdup(args_get(args, 'P'));
+	return (s);
+}
+
+static enum cmd_retval
+cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		*args = cmd_get_args(self);
+	struct client		*tc = cmdq_get_target_client(item);
+	struct key_table	*table;
+	struct key_binding	*bd;
+	const char		*tablename, *r, *keystr;
+	char			*key, *cp, *tmp, *start, *empty;
+	key_code		 prefix, only = KEYC_UNKNOWN;
+	int			 repeat, width, tablewidth, keywidth, found = 0;
+	size_t			 tmpsize, tmpused, cplen;
+
+	if (cmd_get_entry(self) == &cmd_list_commands_entry)
+		return (cmd_list_keys_commands(self, item));
+
+	if ((keystr = args_string(args, 0)) != NULL) {
+		only = key_string_lookup_string(keystr);
+		if (only == KEYC_UNKNOWN) {
+			cmdq_error(item, "invalid key: %s", keystr);
+			return (CMD_RETURN_ERROR);
+		}
+		only &= (KEYC_MASK_KEY|KEYC_MASK_MODIFIERS);
+	}
 
 	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);
 	}
 
+	if (args_has(args, 'N')) {
+		if (tablename == NULL) {
+			start = cmd_list_keys_get_prefix(args, &prefix);
+			keywidth = cmd_list_keys_get_width("root", only);
+			if (prefix != KEYC_NONE) {
+				width = cmd_list_keys_get_width("prefix", only);
+				if (width == 0)
+					prefix = KEYC_NONE;
+				else if (width > keywidth)
+					keywidth = width;
+			}
+			empty = utf8_padcstr("", utf8_cstrwidth(start));
+
+			found = cmd_list_keys_print_notes(item, args, "root",
+			    keywidth, only, empty);
+			if (prefix != KEYC_NONE) {
+				if (cmd_list_keys_print_notes(item, args,
+				    "prefix", keywidth, only, start))
+					found = 1;
+			}
+			free(empty);
+		} else {
+			if (args_has(args, 'P'))
+				start = xstrdup(args_get(args, 'P'));
+			else
+				start = xstrdup("");
+			keywidth = cmd_list_keys_get_width(tablename, only);
+			found = cmd_list_keys_print_notes(item, args, tablename,
+			    keywidth, only, start);
+
+		}
+		free(start);
+		goto out;
+	}
+
 	repeat = 0;
 	tablewidth = keywidth = 0;
-	RB_FOREACH(table, key_tables, &key_tables) {
-		if (tablename != NULL && strcmp(table->name, tablename) != 0)
+	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) {
+			if (only != KEYC_UNKNOWN && bd->key != only) {
+				bd = key_bindings_next(table, bd);
+				continue;
+			}
+			key = args_escape(key_string_lookup_key(bd->key, 0));
 
-			if (bd->can_repeat)
+			if (bd->flags & KEY_BINDING_REPEAT)
 				repeat = 1;
 
 			width = utf8_cstrwidth(table->name);
@@ -93,108 +235,152 @@ 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) {
-		if (tablename != NULL && strcmp(table->name, tablename) != 0)
+	tmpsize = 256;
+	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) {
+			if (only != KEYC_UNKNOWN && bd->key != only) {
+				bd = key_bindings_next(table, bd);
+				continue;
+			}
+			found = 1;
+			key = args_escape(key_string_lookup_key(bd->key, 0));
 
 			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);
-			strlcat(tmp, " ", sizeof tmp);
+			cplen = strlen(cp) + 1;
+			while (tmpused + cplen + 1 >= tmpsize) {
+				tmpsize *= 2;
+				tmp = xrealloc(tmp, tmpsize);
+			}
+			strlcat(tmp, cp, tmpsize);
+			tmpused = strlcat(tmp, " ", tmpsize);
 			free(cp);
 
 			cp = utf8_padcstr(key, keywidth);
-			strlcat(tmp, cp, sizeof tmp);
-			strlcat(tmp, " ", sizeof tmp);
+			cplen = strlen(cp) + 1;
+			while (tmpused + cplen + 1 >= tmpsize) {
+				tmpsize *= 2;
+				tmp = xrealloc(tmp, tmpsize);
+			}
+			strlcat(tmp, cp, tmpsize);
+			tmpused = strlcat(tmp, " ", tmpsize);
 			free(cp);
 
-			cp = cmd_list_print(bd->cmdlist);
-			strlcat(tmp, cp, sizeof tmp);
+			cp = cmd_list_print(bd->cmdlist, 1);
+			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);
+			if (args_has(args, '1') && tc != NULL) {
+				status_message_set(tc, -1, 1, 0, 0,
+				    "bind-key %s", tmp);
+			} else
+				cmdq_print(item, "bind-key %s", tmp);
+			free(key);
+
+			if (args_has(args, '1'))
+				break;
+			bd = key_bindings_next(table, bd);
 		}
+		table = key_bindings_next_table(table);
 	}
 
-	return (CMD_RETURN_NORMAL);
-}
+	free(tmp);
 
-enum cmd_retval
-cmd_list_keys_table(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args			*args = self->args;
-	const char			*tablename;
-	const struct mode_key_table	*mtab;
-	struct mode_key_binding		*mbind;
-	const char			*key, *cmdstr, *mode;
-	int			 	 width, keywidth, any_mode;
-
-	tablename = args_get(args, 't');
-	if ((mtab = mode_key_findtable(tablename)) == NULL) {
-		cmdq_error(cmdq, "unknown key table: %s", tablename);
+out:
+	if (only != KEYC_UNKNOWN && !found) {
+		cmdq_error(item, "unknown key: %s", args_string(args, 0));
 		return (CMD_RETURN_ERROR);
 	}
-
-	width = 0;
-	any_mode = 0;
-	RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
-		key = key_string_lookup_key(mbind->key);
-
-		if (mbind->mode != 0)
-			any_mode = 1;
-
-		keywidth = strlen(key);
-		if (keywidth > width)
-			width = keywidth;
-	}
-
-	RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
-		key = key_string_lookup_key(mbind->key);
-
-		mode = "";
-		if (mbind->mode != 0)
-			mode = "c";
-		cmdstr = mode_key_tostring(mtab->cmdstr, mbind->cmd);
-		if (cmdstr != NULL) {
-			cmdq_print(cmdq, "bind-key -%st %s%s %*s %s%s%s%s",
-			    mode, any_mode && *mode == '\0' ? " " : "",
-			    mtab->name, (int) width, key, cmdstr,
-			    mbind->arg != NULL ? " \"" : "",
-			    mbind->arg != NULL ? mbind->arg : "",
-			    mbind->arg != NULL ? "\"": "");
-		}
-	}
-
 	return (CMD_RETURN_NORMAL);
 }
 
-enum cmd_retval
-cmd_list_keys_commands(struct cmd_q *cmdq)
+static void
+cmd_list_single_command(const struct cmd_entry *entry, struct format_tree *ft,
+    const char *template, struct cmdq_item *item)
 {
+	const char	*s;
+	char		*line;
+
+	format_add(ft, "command_list_name", "%s", entry->name);
+	if (entry->alias != NULL)
+		s = entry->alias;
+	else
+		s = "";
+	format_add(ft, "command_list_alias", "%s", s);
+	if (entry->usage != NULL)
+		s = entry->usage;
+	else
+		s = "";
+	format_add(ft, "command_list_usage", "%s", s);
+
+	line = format_expand(ft, template);
+	if (*line != '\0')
+		cmdq_print(item, "%s", line);
+	free(line);
+}
+
+static enum cmd_retval
+cmd_list_keys_commands(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		 *args = cmd_get_args(self);
 	const struct cmd_entry	**entryp;
 	const struct cmd_entry	 *entry;
+	struct format_tree	 *ft;
+	const char		 *template,  *command;
+	char			 *cause;
 
-	for (entryp = cmd_table; *entryp != NULL; entryp++) {
-		entry = *entryp;
-		if (entry->alias == NULL) {
-			cmdq_print(cmdq, "%s %s", entry->name, entry->usage);
-			continue;
-		}
-		cmdq_print(cmdq, "%s (%s) %s", entry->name, entry->alias,
-		    entry->usage);
+	if ((template = args_get(args, 'F')) == NULL) {
+		template = "#{command_list_name}"
+		    "#{?command_list_alias, (#{command_list_alias}),} "
+		    "#{command_list_usage}";
 	}
 
+	ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
+	format_defaults(ft, NULL, NULL, NULL, NULL);
+
+	command = args_string(args, 0);
+	if (command == NULL) {
+		for (entryp = cmd_table; *entryp != NULL; entryp++)
+			cmd_list_single_command(*entryp, ft, template, item);
+	} else {
+		entry = cmd_find(command, &cause);
+		if (entry != NULL)
+			cmd_list_single_command(entry, ft, template, item);
+		else {
+			cmdq_error(item, "%s", cause);
+			free(cause);
+			format_free(ft);
+			return (CMD_RETURN_ERROR);
+		}
+	}
+
+	format_free(ft);
 	return (CMD_RETURN_NORMAL);
 }

cmd-list-panes.c

@@ -26,73 +26,75 @@
  * List panes on given window.
  */
 
-enum cmd_retval	 cmd_list_panes_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_list_panes_exec(struct cmd *, struct cmdq_item *);
 
-void	cmd_list_panes_server(struct cmd *, struct cmd_q *);
-void	cmd_list_panes_session(struct cmd *, struct session *, struct cmd_q *,
-	    int);
-void	cmd_list_panes_window(struct cmd *, struct session *, struct winlink *,
-	    struct cmd_q *, int);
+static void	cmd_list_panes_server(struct cmd *, struct cmdq_item *);
+static void	cmd_list_panes_session(struct cmd *, struct session *,
+		    struct cmdq_item *, int);
+static void	cmd_list_panes_window(struct cmd *, struct session *,
+		    struct winlink *, struct cmdq_item *, int);
 
 const struct cmd_entry cmd_list_panes_entry = {
 	.name = "list-panes",
 	.alias = "lsp",
 
-	.args = { "asF:t:", 0, 0 },
-	.usage = "[-as] [-F format] " CMD_TARGET_WINDOW_USAGE,
+	.args = { "asF:f:t:", 0, 0, NULL },
+	.usage = "[-as] [-F format] [-f filter] " 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
-cmd_list_panes_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_panes_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	struct session	*s = cmdq->state.tflag.s;
-	struct winlink	*wl = cmdq->state.tflag.wl;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct session		*s = target->s;
+	struct winlink		*wl = 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
-cmd_list_panes_server(struct cmd *self, struct cmd_q *cmdq)
+static void
+cmd_list_panes_server(struct cmd *self, struct cmdq_item *item)
 {
 	struct session	*s;
 
 	RB_FOREACH(s, sessions, &sessions)
-		cmd_list_panes_session(self, s, cmdq, 2);
+		cmd_list_panes_session(self, s, item, 2);
 }
 
-void
-cmd_list_panes_session(struct cmd *self, struct session *s, struct cmd_q *cmdq,
-    int type)
+static void
+cmd_list_panes_session(struct cmd *self, struct session *s,
+    struct cmdq_item *item, int type)
 {
 	struct winlink	*wl;
 
 	RB_FOREACH(wl, winlinks, &s->windows)
-		cmd_list_panes_window(self, s, wl, cmdq, type);
+		cmd_list_panes_window(self, s, wl, item, type);
 }
 
-void
+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 args		*args = cmd_get_args(self);
 	struct window_pane	*wp;
 	u_int			 n;
 	struct format_tree	*ft;
-	const char		*template;
-	char			*line;
+	const char		*template, *filter;
+	char			*line, *expanded;
+	int			 flag;
 
 	template = args_get(args, 'F');
 	if (template == NULL) {
@@ -120,16 +122,25 @@ cmd_list_panes_window(struct cmd *self, struct session *s, struct winlink *wl,
 			break;
 		}
 	}
+	filter = args_get(args, 'f');
 
 	n = 0;
 	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
-		ft = format_create(cmdq, 0);
+		ft = format_create(cmdq_get_client(item), 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);
-		free(line);
+		if (filter != NULL) {
+			expanded = format_expand(ft, filter);
+			flag = format_true(expanded);
+			free(expanded);
+		} else
+			flag = 1;
+		if (flag) {
+			line = format_expand(ft, template);
+			cmdq_print(item, "%s", line);
+			free(line);
+		}
 
 		format_free(ft);
 		n++;

cmd-list-sessions.c

@@ -30,47 +30,57 @@
 
 #define LIST_SESSIONS_TEMPLATE				\
 	"#{session_name}: #{session_windows} windows "	\
-	"(created #{t:session_created}) "		\
-	"[#{session_width}x#{session_height}]"		\
+	"(created #{t:session_created})"		\
 	"#{?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",
 	.alias = "ls",
 
-	.args = { "F:", 0, 0 },
-	.usage = "[-F format]",
+	.args = { "F:f:", 0, 0, NULL },
+	.usage = "[-F format] [-f filter]",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_list_sessions_exec
 };
 
-enum cmd_retval
-cmd_list_sessions_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_sessions_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
 	struct session		*s;
 	u_int		 	 n;
 	struct format_tree	*ft;
-	const char		*template;
-	char			*line;
+	const char		*template, *filter;
+	char			*line, *expanded;
+	int			 flag;
 
 	if ((template = args_get(args, 'F')) == NULL)
 		template = LIST_SESSIONS_TEMPLATE;
+	filter = args_get(args, 'f');
 
 	n = 0;
 	RB_FOREACH(s, sessions, &sessions) {
-		ft = format_create(cmdq, 0);
+		ft = format_create(cmdq_get_client(item), 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);
-		free(line);
+		if (filter != NULL) {
+			expanded = format_expand(ft, filter);
+			flag = format_true(expanded);
+			free(expanded);
+		} else
+			flag = 1;
+		if (flag) {
+			line = format_expand(ft, template);
+			cmdq_print(item, "%s", line);
+			free(line);
+		}
 
 		format_free(ft);
 		n++;

cmd-list-windows.c

@@ -28,68 +28,70 @@
  */
 
 #define LIST_WINDOWS_TEMPLATE					\
-	"#{window_index}: #{window_name}#{window_flags} "	\
+	"#{window_index}: #{window_name}#{window_raw_flags} "	\
 	"(#{window_panes} panes) "				\
 	"[#{window_width}x#{window_height}] "			\
 	"[layout #{window_layout}] #{window_id}"		\
 	"#{?window_active, (active),}";
 #define LIST_WINDOWS_WITH_SESSION_TEMPLATE			\
 	"#{session_name}:"					\
-	"#{window_index}: #{window_name}#{window_flags} "	\
+	"#{window_index}: #{window_name}#{window_raw_flags} "	\
 	"(#{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 *);
-void	cmd_list_windows_session(struct cmd *, struct session *,
-	    struct cmd_q *, int);
+static void	cmd_list_windows_server(struct cmd *, struct cmdq_item *);
+static void	cmd_list_windows_session(struct cmd *, struct session *,
+		    struct cmdq_item *, int);
 
 const struct cmd_entry cmd_list_windows_entry = {
 	.name = "list-windows",
 	.alias = "lsw",
 
-	.args = { "F:at:", 0, 0 },
-	.usage = "[-a] [-F format] " CMD_TARGET_SESSION_USAGE,
+	.args = { "F:f:at:", 0, 0, NULL },
+	.usage = "[-a] [-F format] [-f filter] " 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
-cmd_list_windows_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_windows_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
 
 	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, target->s, item, 0);
 
 	return (CMD_RETURN_NORMAL);
 }
 
-void
-cmd_list_windows_server(struct cmd *self, struct cmd_q *cmdq)
+static void
+cmd_list_windows_server(struct cmd *self, struct cmdq_item *item)
 {
 	struct session	*s;
 
 	RB_FOREACH(s, sessions, &sessions)
-		cmd_list_windows_session(self, s, cmdq, 1);
+		cmd_list_windows_session(self, s, item, 1);
 }
 
-void
+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 args		*args = cmd_get_args(self);
 	struct winlink		*wl;
-	u_int			n;
+	u_int			 n;
 	struct format_tree	*ft;
-	const char		*template;
-	char			*line;
+	const char		*template, *filter;
+	char			*line, *expanded;
+	int			 flag;
 
 	template = args_get(args, 'F');
 	if (template == NULL) {
@@ -102,16 +104,25 @@ cmd_list_windows_session(struct cmd *self, struct session *s,
 			break;
 		}
 	}
+	filter = args_get(args, 'f');
 
 	n = 0;
 	RB_FOREACH(wl, winlinks, &s->windows) {
-		ft = format_create(cmdq, 0);
+		ft = format_create(cmdq_get_client(item), 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);
-		free(line);
+		if (filter != NULL) {
+			expanded = format_expand(ft, filter);
+			flag = format_true(expanded);
+			free(expanded);
+		} else
+			flag = 1;
+		if (flag) {
+			line = format_expand(ft, template);
+			cmdq_print(item, "%s", line);
+			free(line);
+		}
 
 		format_free(ft);
 		n++;

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,143 +31,83 @@
  * Loads a paste buffer from a file.
  */
 
-enum cmd_retval	 cmd_load_buffer_exec(struct cmd *, struct cmd_q *);
-void		 cmd_load_buffer_callback(struct client *, int, void *);
+static enum cmd_retval	cmd_load_buffer_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_load_buffer_entry = {
 	.name = "load-buffer",
 	.alias = "loadb",
 
-	.args = { "b:", 1, 1 },
-	.usage = CMD_BUFFER_USAGE " path",
+	.args = { "b:t:w", 1, 1, NULL },
+	.usage = CMD_BUFFER_USAGE " " CMD_TARGET_CLIENT_USAGE " path",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG|CMD_CLIENT_CANFAIL,
 	.exec = cmd_load_buffer_exec
 };
 
-enum cmd_retval
-cmd_load_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+struct cmd_load_buffer_data {
+	struct client		*client;
+	struct cmdq_item	*item;
+	char			*name;
+};
+
+static void
+cmd_load_buffer_done(__unused struct client *c, const char *path, int error,
+    int closed, struct evbuffer *buffer, void *data)
 {
-	struct args	*args = self->args;
-	struct client	*c = cmdq->client;
-	struct session  *s;
-	FILE		*f;
-	const char	*path, *bufname, *cwd;
-	char		*pdata, *new_pdata, *cause, *file, resolved[PATH_MAX];
-	size_t		 psize;
-	int		 ch, error;
-
-	bufname = NULL;
-	if (args_has(args, 'b'))
-		bufname = args_get(args, 'b');
-
-	path = args->argv[0];
-	if (strcmp(path, "-") == 0) {
-		error = server_set_stdin_callback(c, cmd_load_buffer_callback,
-		    (void *)bufname, &cause);
-		if (error != 0) {
-			cmdq_error(cmdq, "%s: %s", path, cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-		return (CMD_RETURN_WAIT);
-	}
-
-	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 = ".";
-
-	if (*path == '/')
-		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));
-		return (CMD_RETURN_ERROR);
-	}
-
-	pdata = NULL;
-	psize = 0;
-	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));
-			goto error;
-		}
-		pdata = new_pdata;
-		pdata[psize++] = ch;
-	}
-	if (ferror(f)) {
-		cmdq_error(cmdq, "%s: read error", resolved);
-		goto error;
-	}
-	if (pdata != NULL)
-		pdata[psize] = '\0';
-
-	fclose(f);
-
-	if (paste_set(pdata, psize, bufname, &cause) != 0) {
-		cmdq_error(cmdq, "%s", cause);
-		free(pdata);
-		free(cause);
-		return (CMD_RETURN_ERROR);
-	}
-
-	return (CMD_RETURN_NORMAL);
-
-error:
-	free(pdata);
-	if (f != NULL)
-		fclose(f);
-	return (CMD_RETURN_ERROR);
-}
-
-void
-cmd_load_buffer_callback(struct client *c, int closed, void *data)
-{
-	const char	*bufname = data;
-	char		*pdata, *cause, *saved;
-	size_t		 psize;
+	struct cmd_load_buffer_data	*cdata = data;
+	struct client			*tc = cdata->client;
+	struct cmdq_item		*item = cdata->item;
+	void				*bdata = EVBUFFER_DATA(buffer);
+	size_t				 bsize = EVBUFFER_LENGTH(buffer);
+	void				*copy;
+	char				*cause;
 
 	if (!closed)
 		return;
-	c->stdin_callback = NULL;
 
-	server_client_unref(c);
-	if (c->flags & CLIENT_DEAD)
-		return;
+	if (error != 0)
+		cmdq_error(item, "%s: %s", path, strerror(error));
+	else if (bsize != 0) {
+		copy = xmalloc(bsize);
+		memcpy(copy, bdata, bsize);
+		if (paste_set(copy, bsize, cdata->name, &cause) != 0) {
+			cmdq_error(item, "%s", cause);
+			free(cause);
+			free(copy);
+		} else if (tc != NULL &&
+		    tc->session != NULL &&
+		    (~tc->flags & CLIENT_DEAD))
+			tty_set_selection(&tc->tty, "", copy, bsize);
+		if (tc != NULL)
+			server_client_unref(tc);
+	}
+	cmdq_continue(item);
 
-	psize = EVBUFFER_LENGTH(c->stdin_data);
-	if (psize == 0 || (pdata = malloc(psize + 1)) == NULL)
-		goto out;
+	free(cdata->name);
+	free(cdata);
+}
 
-	memcpy(pdata, EVBUFFER_DATA(c->stdin_data), psize);
-	pdata[psize] = '\0';
-	evbuffer_drain(c->stdin_data, psize);
+static enum cmd_retval
+cmd_load_buffer_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args			*args = cmd_get_args(self);
+	struct client			*tc = cmdq_get_target_client(item);
+	struct cmd_load_buffer_data	*cdata;
+	const char			*bufname = args_get(args, 'b');
+	char				*path;
 
-	if (paste_set(pdata, psize, bufname, &cause) != 0) {
-		/* No context so can't use server_client_msg_error. */
-		if (~c->flags & CLIENT_UTF8) {
-			saved = cause;
-			cause = utf8_sanitize(saved);
-			free(saved);
-		}
-		evbuffer_add_printf(c->stderr_data, "%s", cause);
-		server_client_push_stderr(c);
-		free(pdata);
-		free(cause);
+	cdata = xcalloc(1, sizeof *cdata);
+	cdata->item = item;
+	if (bufname != NULL)
+		cdata->name = xstrdup(bufname);
+	if (args_has(args, 'w') && tc != NULL) {
+		cdata->client = tc;
+		cdata->client->references++;
 	}
 
-out:
-	cmdq_continue(c->cmdq);
+	path = format_single_from_target(item, args_string(args, 0));
+	file_read(cmdq_get_client(item), path, cmd_load_buffer_done, cdata);
+	free(path);
+
+	return (CMD_RETURN_WAIT);
 }

cmd-lock-server.c

@@ -24,16 +24,16 @@
  * 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",
 	.alias = "lock",
 
-	.args = { "", 0, 0 },
+	.args = { "", 0, 0, NULL },
 	.usage = "",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_lock_server_exec
 };
 
@@ -41,12 +41,12 @@ const struct cmd_entry cmd_lock_session_entry = {
 	.name = "lock-session",
 	.alias = "locks",
 
-	.args = { "t:", 0, 0 },
+	.args = { "t:", 0, 0, NULL },
 	.usage = CMD_TARGET_SESSION_USAGE,
 
-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_lock_server_exec
 };
 
@@ -54,25 +54,25 @@ const struct cmd_entry cmd_lock_client_entry = {
 	.name = "lock-client",
 	.alias = "lockc",
 
-	.args = { "t:", 0, 0 },
+	.args = { "t:", 0, 0, NULL },
 	.usage = CMD_TARGET_CLIENT_USAGE,
 
-	.tflag = CMD_CLIENT,
-
-	.flags = 0,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG,
 	.exec = cmd_lock_server_exec
 };
 
-enum cmd_retval
-cmd_lock_server_exec(struct cmd *self, __unused struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_lock_server_exec(struct cmd *self, struct cmdq_item *item)
 {
-	if (self->entry == &cmd_lock_server_entry)
-		server_lock();
-	else if (self->entry == &cmd_lock_session_entry)
-		server_lock_session(cmdq->state.tflag.s);
-	else
-		server_lock_client(cmdq->state.c);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct client		*tc = cmdq_get_target_client(item);
 
+	if (cmd_get_entry(self) == &cmd_lock_server_entry)
+		server_lock();
+	else if (cmd_get_entry(self) == &cmd_lock_session_entry)
+		server_lock_session(target->s);
+	else
+		server_lock_client(tc);
 	recalculate_sizes();
 
 	return (CMD_RETURN_NORMAL);

cmd-move-window.c

@@ -26,17 +26,17 @@
  * 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",
 	.alias = "movew",
 
-	.args = { "adkrs:t:", 0, 0 },
-	.usage = "[-dkr] " CMD_SRCDST_WINDOW_USAGE,
+	.args = { "abdkrs:t:", 0, 0, NULL },
+	.usage = "[-abdkr] " CMD_SRCDST_WINDOW_USAGE,
 
-	.sflag = CMD_WINDOW,
-	.tflag = CMD_MOVEW_R,
+	.source = { 's', CMD_FIND_WINDOW, 0 },
+	/* -t is special */
 
 	.flags = 0,
 	.exec = cmd_move_window_exec
@@ -46,52 +46,66 @@ const struct cmd_entry cmd_link_window_entry = {
 	.name = "link-window",
 	.alias = "linkw",
 
-	.args = { "adks:t:", 0, 0 },
-	.usage = "[-dk] " CMD_SRCDST_WINDOW_USAGE,
+	.args = { "abdks:t:", 0, 0, NULL },
+	.usage = "[-abdk] " CMD_SRCDST_WINDOW_USAGE,
 
-	.sflag = CMD_WINDOW,
-	.tflag = CMD_WINDOW_INDEX,
+	.source = { 's', CMD_FIND_WINDOW, 0 },
+	/* -t is special */
 
 	.flags = 0,
 	.exec = cmd_move_window_exec
 };
 
-enum cmd_retval
-cmd_move_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_move_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	struct session	*src = cmdq->state.sflag.s;
-	struct session	*dst = cmdq->state.tflag.s;
-	struct winlink	*wl = cmdq->state.sflag.wl;
-	char		*cause;
-	int		 idx = cmdq->state.tflag.idx, kflag, dflag, sflag;
-
-	kflag = args_has(self->args, 'k');
-	dflag = args_has(self->args, 'd');
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*source = cmdq_get_source(item);
+	struct cmd_find_state	 target;
+	const char		*tflag = args_get(args, 't');
+	struct session		*src = source->s;
+	struct session		*dst;
+	struct winlink		*wl = source->wl;
+	char			*cause;
+	int			 idx, kflag, dflag, sflag, before;
 
 	if (args_has(args, 'r')) {
-		session_renumber_windows(dst);
+		if (cmd_find_target(&target, item, tflag, CMD_FIND_SESSION,
+		    CMD_FIND_QUIET) != 0)
+			return (CMD_RETURN_ERROR);
+
+		session_renumber_windows(target.s);
 		recalculate_sizes();
+		server_status_session(target.s);
 
 		return (CMD_RETURN_NORMAL);
 	}
+	if (cmd_find_target(&target, item, tflag, CMD_FIND_WINDOW,
+	    CMD_FIND_WINDOW_INDEX) != 0)
+		return (CMD_RETURN_ERROR);
+	dst = target.s;
+	idx = target.idx;
 
-	kflag = args_has(self->args, 'k');
-	dflag = args_has(self->args, 'd');
-	sflag = args_has(self->args, 's');
+	kflag = args_has(args, 'k');
+	dflag = args_has(args, 'd');
+	sflag = args_has(args, 's');
 
-	if (args_has(self->args, 'a')) {
-		if ((idx = winlink_shuffle_up(dst, dst->curw)) == -1)
+	before = args_has(args, 'b');
+	if (args_has(args, 'a') || before) {
+		if (target.wl != NULL)
+			idx = winlink_shuffle_up(dst, target.wl, before);
+		else
+			idx = winlink_shuffle_up(dst, dst->curw, before);
+		if (idx == -1)
 			return (CMD_RETURN_ERROR);
 	}
 
-	if (server_link_window(src, wl, dst, idx, kflag, !dflag,
-	    &cause) != 0) {
-		cmdq_error(cmdq, "can't link window: %s", cause);
+	if (server_link_window(src, wl, dst, idx, kflag, !dflag, &cause) != 0) {
+		cmdq_error(item, "%s", cause);
 		free(cause);
 		return (CMD_RETURN_ERROR);
 	}
-	if (self->entry == &cmd_move_window_entry)
+	if (cmd_get_entry(self) == &cmd_move_window_entry)
 		server_unlink_window(src, wl);
 
 	/*

cmd-new-session.c

@@ -33,18 +33,19 @@
 
 #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 },
-	.usage = "[-AdDEP] [-c start-directory] [-F format] [-n window-name] "
-		 "[-s session-name] " CMD_TARGET_SESSION_USAGE " [-x width] "
-		 "[-y height] [command]",
+	.args = { "Ac:dDe:EF:f:n:Ps:t:x:Xy:", 0, -1, NULL },
+	.usage = "[-AdDEPX] [-c start-directory] [-e environment] [-F format] "
+		 "[-f flags] [-n window-name] [-s session-name] "
+		 CMD_TARGET_SESSION_USAGE " [-x width] [-y height] "
+		 "[shell-command [argument ...]]",
 
-	.tflag = CMD_SESSION_CANFAIL,
+	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },
 
 	.flags = CMD_STARTSERVER,
 	.exec = cmd_new_session_exec
@@ -54,82 +55,107 @@ const struct cmd_entry cmd_has_session_entry = {
 	.name = "has-session",
 	.alias = "has",
 
-	.args = { "t:", 0, 0 },
+	.args = { "t:", 0, 0, NULL },
 	.usage = CMD_TARGET_SESSION_USAGE,
 
-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },
 
 	.flags = 0,
 	.exec = cmd_new_session_exec
 };
 
-enum cmd_retval
-cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	struct client		*c = cmdq->client;
-	struct session		*s, *as;
-	struct session		*groupwith = cmdq->state.tflag.s;
-	struct window		*w;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct client		*c = cmdq_get_client(item);
+	struct session		*s, *as, *groupwith = NULL;
 	struct environ		*env;
+	struct options		*oo;
 	struct termios		 tio, *tiop;
-	const char		*newname, *target, *update, *errstr, *template;
-	const char		*path, *cwd, *to_free = NULL;
-	char		       **argv, *cmd, *cause, *cp;
-	int			 detached, already_attached, idx, argc;
-	u_int			 sx, sy;
-	struct format_tree	*ft;
-	struct environ_entry	*envent;
+	struct session_group	*sg = NULL;
+	const char		*errstr, *template, *group, *tmp;
+	char			*cause, *cwd = NULL, *cp, *newname = NULL;
+	char			*name, *prefix = NULL;
+	int			 detached, already_attached, is_control = 0;
+	u_int			 sx, sy, dsx, dsy, count = args_count(args);
+	struct spawn_context	 sc = { 0 };
+	enum cmd_retval		 retval;
+	struct cmd_find_state    fs;
+	struct args_value	*av;
 
-	if (self->entry == &cmd_has_session_entry) {
+	if (cmd_get_entry(self) == &cmd_has_session_entry) {
 		/*
-		 * cmd_prepare() will fail if the session cannot be found,
-		 * hence always return success here.
+		 * cmd_find_target() will fail if the session cannot be found,
+		 * so always return success here.
 		 */
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (args_has(args, 't') && (args->argc != 0 || args_has(args, 'n'))) {
-		cmdq_error(cmdq, "command or window name given with target");
+	if (args_has(args, 't') && (count != 0 || args_has(args, 'n'))) {
+		cmdq_error(item, "command or window name given with target");
 		return (CMD_RETURN_ERROR);
 	}
 
-	newname = args_get(args, 's');
-	if (newname != NULL) {
-		if (!session_check_name(newname)) {
-			cmdq_error(cmdq, "bad session name: %s", newname);
+	tmp = args_get(args, 's');
+	if (tmp != NULL) {
+		name = format_single(item, tmp, c, NULL, NULL, NULL);
+		newname = session_check_name(name);
+		if (newname == NULL) {
+			cmdq_error(item, "invalid session: %s", name);
+			free(name);
 			return (CMD_RETURN_ERROR);
 		}
-		if ((as = session_find(newname)) != NULL) {
-			if (args_has(args, 'A')) {
-				/*
-				 * This cmdq is now destined for
-				 * attach-session.  Because attach-session
-				 * will have already been prepared, copy this
-				 * session into its tflag so it can be used.
-				 */
-				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);
-			return (CMD_RETURN_ERROR);
+		free(name);
+	}
+	if (args_has(args, 'A')) {
+		if (newname != NULL)
+			as = session_find(newname);
+		else
+			as = target->s;
+		if (as != NULL) {
+			retval = cmd_attach_session(item, as->name,
+			    args_has(args, 'D'), args_has(args, 'X'), 0, NULL,
+			    args_has(args, 'E'), args_get(args, 'f'));
+			free(newname);
+			return (retval);
 		}
 	}
+	if (newname != NULL && session_find(newname) != NULL) {
+		cmdq_error(item, "duplicate session: %s", newname);
+		goto fail;
+	}
 
-	if ((target = args_get(args, 't')) != NULL) {
-		if (groupwith == NULL) {
-			cmdq_error(cmdq, "no such session: %s", target);
-			goto error;
+	/* Is this going to be part of a session group? */
+	group = args_get(args, 't');
+	if (group != NULL) {
+		groupwith = target->s;
+		if (groupwith == NULL)
+			sg = session_group_find(group);
+		else
+			sg = session_group_contains(groupwith);
+		if (sg != NULL)
+			prefix = xstrdup(sg->name);
+		else if (groupwith != NULL)
+			prefix = xstrdup(groupwith->name);
+		else {
+			prefix = session_check_name(group);
+			if (prefix == NULL) {
+				cmdq_error(item, "invalid session group: %s",
+				    group);
+				goto fail;
+			}
 		}
-	} else
-		groupwith = 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 +163,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')) {
-		ft = format_create(cmdq, 0);
-		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;
+	if ((tmp = args_get(args, 'c')) != NULL)
+		cwd = format_single(item, tmp, c, NULL, NULL, NULL);
 	else
-		cwd = ".";
+		cwd = xstrdup(server_client_get_cwd(c, NULL));
 
 	/*
 	 * If this is a new client, check for nesting and save the termios
@@ -156,13 +177,16 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 	 * the terminal as that calls tcsetattr() to prepare for tmux taking
 	 * over.
 	 */
-	if (!detached && !already_attached && c->tty.fd != -1) {
-		if (server_client_check_nested(cmdq->client)) {
-			cmdq_error(cmdq, "sessions should be nested with care, "
+	if (!detached &&
+	    !already_attached &&
+	    c->fd != -1 &&
+	    (~c->flags & CLIENT_CONTROL)) {
+		if (server_client_check_nested(cmdq_get_client(item))) {
+			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)
+		if (tcgetattr(c->fd, &tio) != 0)
 			fatal("tcgetattr failed");
 		tiop = &tio;
 	} else
@@ -171,154 +195,176 @@ 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;
+			}
+		}
+	} else
+		dsx = 80;
+	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;
+			}
+		}
+	} else
+		dsy = 24;
+
 	/* 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;
-		sy = 24;
-	}
-	if (detached && args_has(args, 'x')) {
-		sx = strtonum(args_get(args, 'x'), 1, USHRT_MAX, &errstr);
-		if (errstr != NULL) {
-			cmdq_error(cmdq, "width %s", errstr);
-			goto error;
+		tmp = options_get_string(global_s_options, "default-size");
+		if (sscanf(tmp, "%ux%u", &sx, &sy) != 2) {
+			sx = dsx;
+			sy = dsy;
+		} else {
+			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");
-	s = session_create(newname, argc, argv, path, cwd, env, tiop, idx, sx,
-	    sy, &cause);
-	environ_free(env);
-	if (s == NULL) {
-		cmdq_error(cmdq, "create session failed: %s", cause);
-		free(cause);
-		goto error;
+	oo = options_create(global_s_options);
+	if (args_has(args, 'x') || args_has(args, 'y')) {
+		if (!args_has(args, 'x'))
+			dsx = sx;
+		if (!args_has(args, 'y'))
+			dsy = sy;
+		options_set_string(oo, "default-size", 0, "%ux%u", dsx, dsy);
 	}
+	env = environ_create();
+	if (c != NULL && !args_has(args, 'E'))
+		environ_update(global_s_options, c->environ, env);
+	av = args_first_value(args, 'e');
+	while (av != NULL) {
+		environ_put(env, av->string, 0);
+		av = args_next_value(av);
+	}
+	s = session_create(prefix, newname, cwd, env, oo, tiop);
 
-	/* Set the initial window name if one given. */
-	if (argc >= 0 && args_has(args, 'n')) {
-		w = s->curw->window;
-		window_set_name(w, args_get(args, 'n'));
-		options_set_number(w->options, "automatic-rename", 0);
+	/* Spawn the initial window. */
+	sc.item = item;
+	sc.s = s;
+	if (!detached)
+		sc.tc = c;
+
+	sc.name = args_get(args, 'n');
+	args_to_vector(args, &sc.argc, &sc.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) {
-		session_group_add(groupwith, s);
+	if (group != NULL) {
+		if (sg == NULL) {
+			if (groupwith != NULL) {
+				sg = session_group_new(groupwith->name);
+				session_group_add(sg, groupwith);
+			} else
+				sg = session_group_new(group);
+		}
+		session_group_add(sg, s);
 		session_group_synchronize_to(s);
 		session_select(s, RB_MIN(winlinks, &s->windows)->idx);
 	}
+	notify_session("session-created", s);
 
 	/*
 	 * Set the client to the new session. If a command client exists, it is
 	 * taking this session and needs to get MSG_READY and stay around.
 	 */
 	if (!detached) {
+		if (args_has(args, 'f'))
+			server_client_set_flags(c, args_get(args, 'f'));
 		if (!already_attached) {
 			if (~c->flags & CLIENT_CONTROL)
 				proc_send(c->peer, MSG_READY, -1, NULL, 0);
 		} else if (c->session != NULL)
 			c->last_session = c->session;
-		c->session = s;
-		server_client_set_key_table(c, NULL);
-		status_timer_start(c);
-		notify_attached_session_changed(c);
-		session_update_activity(s, NULL);
-		gettimeofday(&s->last_attached_time, NULL);
-		server_redraw_client(c);
+		server_client_set_session(c, s);
+		if (~cmdq_get_flags(item) & CMDQ_STATE_REPEAT)
+			server_client_set_key_table(c, NULL);
 	}
-	recalculate_sizes();
-	server_update_socket();
-
-	/*
-	 * If there are still configuration file errors to display, put the new
-	 * session's current window into more mode and display them now.
-	 */
-	if (cfg_finished)
-		cfg_show_causes(s);
 
 	/* Print if requested. */
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = NEW_SESSION_TEMPLATE;
-
-		ft = format_create(cmdq, 0);
-		format_defaults(ft, c, s, NULL, NULL);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
+		cp = format_single(item, template, c, s, s->curw, NULL);
+		cmdq_print(item, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}
 
 	if (!detached)
-		cmdq->client_exit = 0;
+		c->flags |= CLIENT_ATTACHED;
+	if (!args_has(args, 'd'))
+		cmd_find_from_session(current, s, 0);
 
-	if (to_free != NULL)
-		free((void *)to_free);
+	cmd_find_from_session(&fs, s, 0);
+	cmdq_insert_hook(s, item, &fs, "after-new-session");
+
+	if (cfg_finished)
+		cfg_show_causes(s);
+
+	if (sc.argv != NULL)
+		cmd_free_argv(sc.argc, sc.argv);
+	free(cwd);
+	free(newname);
+	free(prefix);
 	return (CMD_RETURN_NORMAL);
 
-error:
-	if (to_free != NULL)
-		free((void *)to_free);
+fail:
+	if (sc.argv != NULL)
+		cmd_free_argv(sc.argc, sc.argv);
+	free(cwd);
+	free(newname);
+	free(prefix);
 	return (CMD_RETURN_ERROR);
 }

cmd-new-window.c

@@ -32,108 +32,111 @@
 
 #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 },
-	.usage = "[-adkP] [-c start-directory] [-F format] [-n window-name] "
-		 CMD_TARGET_WINDOW_USAGE " [command]",
+	.args = { "abc:de:F:kn:PSt:", 0, -1, NULL },
+	.usage = "[-abdkPS] [-c start-directory] [-e environment] [-F format] "
+		 "[-n window-name] " CMD_TARGET_WINDOW_USAGE
+		 " [shell-command [argument ...]]",
 
-	.tflag = CMD_WINDOW_INDEX,
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_WINDOW_INDEX },
 
 	.flags = 0,
 	.exec = cmd_new_window_exec
 };
 
-enum cmd_retval
-cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	struct session		*s = cmdq->state.tflag.s;
-	struct winlink		*wl = cmdq->state.tflag.wl;
-	struct client		*c = cmdq->state.c;
-	int			 idx = cmdq->state.tflag.idx;
-	const char		*cmd, *path, *template, *cwd, *to_free;
-	char		       **argv, *cause, *cp;
-	int			 argc, detached;
-	struct format_tree	*ft;
-	struct environ_entry	*envent;
+	struct args		*args = cmd_get_args(self);
+	struct client		*c = cmdq_get_client(item);
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct spawn_context	 sc = { 0 };
+	struct client		*tc = cmdq_get_target_client(item);
+	struct session		*s = target->s;
+	struct winlink		*wl = target->wl, *new_wl = NULL;
+	int			 idx = target->idx, before;
+	char			*cause = NULL, *cp, *expanded;
+	const char		*template, *name;
+	struct cmd_find_state	 fs;
+	struct args_value	*av;
 
-	if (args_has(args, 'a')) {
-		if ((idx = winlink_shuffle_up(s, wl)) == -1) {
-			cmdq_error(cmdq, "no free window indexes");
+	/*
+	 * If -S and -n are given and -t is not and a single window with this
+	 * name already exists, select it.
+	 */
+	name = args_get(args, 'n');
+	if (args_has(args, 'S') && name != NULL && target->idx == -1) {
+		expanded = format_single(item, name, c, s, NULL, NULL);
+		RB_FOREACH(wl, winlinks, &s->windows) {
+			if (strcmp(wl->window->name, expanded) != 0)
+				continue;
+			if (new_wl == NULL) {
+				new_wl = wl;
+				continue;
+			}
+			cmdq_error(item, "multiple windows named %s", name);
+			free(expanded);
 			return (CMD_RETURN_ERROR);
 		}
-	}
-	detached = args_has(args, 'd');
-
-	if (args->argc == 0) {
-		cmd = options_get_string(s->options, "default-command");
-		if (cmd != NULL && *cmd != '\0') {
-			argc = 1;
-			argv = (char **)&cmd;
-		} else {
-			argc = 0;
-			argv = NULL;
-		}
-	} else {
-		argc = args->argc;
-		argv = args->argv;
-	}
-
-	path = NULL;
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
-		envent = environ_find(cmdq->client->environ, "PATH");
-	else
-		envent = environ_find(s->environ, "PATH");
-	if (envent != NULL)
-		path = envent->value;
-
-	to_free = NULL;
-	if (args_has(args, 'c')) {
-		ft = format_create(cmdq, 0);
-		format_defaults(ft, c, s, NULL, NULL);
-		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;
-	if (idx != -1)
-		wl = winlink_find_by_index(&s->windows, idx);
-	if (wl != NULL && args_has(args, 'k')) {
-		/*
-		 * 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;
+		free(expanded);
+		if (new_wl != NULL) {
+			if (args_has(args, 'd'))
+				return (CMD_RETURN_NORMAL);
+			if (session_set_current(s, new_wl) == 0)
+				server_redraw_session(s);
+			if (c != NULL && c->session != NULL)
+				s->curw->window->latest = c;
+			recalculate_sizes();
+			return (CMD_RETURN_NORMAL);
 		}
 	}
 
-	if (idx == -1)
-		idx = -1 - options_get_number(s->options, "base-index");
-	wl = session_new(s, args_get(args, 'n'), argc, argv, path, cwd, idx,
-		&cause);
-	if (wl == NULL) {
-		cmdq_error(cmdq, "create window failed: %s", cause);
+	before = args_has(args, 'b');
+	if (args_has(args, 'a') || before) {
+		idx = winlink_shuffle_up(s, wl, before);
+		if (idx == -1)
+			idx = target->idx;
+	}
+
+	sc.item = item;
+	sc.s = s;
+	sc.tc = tc;
+
+	sc.name = args_get(args, 'n');
+	args_to_vector(args, &sc.argc, &sc.argv);
+	sc.environ = environ_create();
+
+	av = args_first_value(args, 'e');
+	while (av != NULL) {
+		environ_put(sc.environ, av->string, 0);
+		av = args_next_value(av);
+	}
+
+	sc.idx = idx;
+	sc.cwd = args_get(args, 'c');
+
+	sc.flags = 0;
+	if (args_has(args, 'd'))
+		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;
+		if (sc.argv != NULL)
+			cmd_free_argv(sc.argc, sc.argv);
+		environ_free(sc.environ);
+		return (CMD_RETURN_ERROR);
 	}
-	if (!detached) {
-		session_select(s, wl->idx);
+	if (!args_has(args, 'd') || new_wl == s->curw) {
+		cmd_find_from_winlink(current, new_wl, 0);
 		server_redraw_session_group(s);
 	} else
 		server_status_session_group(s);
@@ -141,23 +144,17 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = NEW_WINDOW_TEMPLATE;
-
-		ft = format_create(cmdq, 0);
-		format_defaults(ft, c, s, wl, NULL);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
+		cp = format_single(item, template, tc, s, new_wl,
+			new_wl->window->active);
+		cmdq_print(item, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}
 
-	if (to_free != NULL)
-		free((void *)to_free);
-	return (CMD_RETURN_NORMAL);
+	cmd_find_from_winlink(&fs, new_wl, 0);
+	cmdq_insert_hook(s, item, &fs, "after-new-window");
 
-error:
-	if (to_free != NULL)
-		free((void *)to_free);
-	return (CMD_RETURN_ERROR);
+	if (sc.argv != NULL)
+		cmd_free_argv(sc.argc, sc.argv);
+	environ_free(sc.environ);
+	return (CMD_RETURN_NORMAL);
 }

cmd-paste-buffer.c

@@ -27,35 +27,38 @@
  * Paste paste buffer if present.
  */
 
-enum cmd_retval	 cmd_paste_buffer_exec(struct cmd *, struct cmd_q *);
-
-void	cmd_paste_buffer_filter(struct window_pane *,
-	    const char *, size_t, const char *, int);
+static enum cmd_retval	cmd_paste_buffer_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_paste_buffer_entry = {
 	.name = "paste-buffer",
 	.alias = "pasteb",
 
-	.args = { "db:prs:t:", 0, 0 },
+	.args = { "db:prs:t:", 0, 0, NULL },
 	.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
-cmd_paste_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_paste_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct window_pane	*wp = target->wp;
 	struct paste_buffer	*pb;
 	const char		*sepstr, *bufname, *bufdata, *bufend, *line;
 	size_t			 seplen, bufsize;
 	int			 bracket = args_has(args, 'p');
 
+	if (window_pane_exited(wp)) {
+		cmdq_error(item, "target pane has exited");
+		return (CMD_RETURN_ERROR);
+	}
+
 	bufname = NULL;
 	if (args_has(args, 'b'))
 		bufname = args_get(args, 'b');
@@ -65,7 +68,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,45 @@
  * 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 },
-	.usage = "[-o] " CMD_TARGET_PANE_USAGE " [command]",
+	.args = { "IOot:", 0, 1, NULL },
+	.usage = "[-IOo] " CMD_TARGET_PANE_USAGE " [shell-command]",
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_pipe_pane_exec
 };
 
-enum cmd_retval
-cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	struct client		*c = cmdq->state.c;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
-	struct session		*s = cmdq->state.tflag.s;
-	struct winlink		*wl = cmdq->state.tflag.wl;
-	char			*cmd;
-	int			 old_fd, pipe_fd[2], null_fd;
-	struct format_tree	*ft;
+	struct args			*args = cmd_get_args(self);
+	struct cmd_find_state		*target = cmdq_get_target(item);
+	struct client			*tc = cmdq_get_target_client(item);
+	struct window_pane		*wp = target->wp;
+	struct session			*s = target->s;
+	struct winlink			*wl = target->wl;
+	struct window_pane_offset	*wpo = &wp->pipe_offset;
+	char				*cmd;
+	int				 old_fd, pipe_fd[2], null_fd, in, out;
+	struct format_tree		*ft;
+	sigset_t			 set, oldset;
+
+	/* Do nothing if pane is dead. */
+	if (window_pane_exited(wp)) {
+		cmdq_error(item, "target pane has exited");
+		return (CMD_RETURN_ERROR);
+	}
 
 	/* Destroy the old pipe. */
 	old_fd = wp->pipe_fd;
@@ -67,10 +79,15 @@ 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. */
-	if (args->argc == 0 || *args->argv[0] == '\0')
+	if (args_count(args) == 0 || *args_string(args, 0) == '\0')
 		return (CMD_RETURN_NORMAL);
 
 	/*
@@ -79,75 +96,135 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	 *
 	 *	bind ^p pipep -o 'cat >>~/output'
 	 */
-	if (args_has(self->args, 'o') && old_fd != -1)
+	if (args_has(args, 'o') && old_fd != -1)
 		return (CMD_RETURN_NORMAL);
 
+	/* What do we want to do? Neither -I or -O is -O. */
+	if (args_has(args, 'I')) {
+		in = 1;
+		out = args_has(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);
-	format_defaults(ft, c, s, wl, wp);
-	cmd = format_expand_time(ft, args->argv[0], time(NULL));
+	ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
+	format_defaults(ft, tc, s, wl, wp);
+	cmd = format_expand_time(ft, args_string(args, 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)
-			_exit(1);
+		null_fd = open(_PATH_DEVNULL, O_WRONLY);
+		if (out) {
+			if (dup2(pipe_fd[1], STDIN_FILENO) == -1)
+				_exit(1);
+		} else {
+			if (dup2(null_fd, STDIN_FILENO) == -1)
+				_exit(1);
+		}
+		if (in) {
+			if (dup2(pipe_fd[1], STDOUT_FILENO) == -1)
+				_exit(1);
+			if (pipe_fd[1] != STDOUT_FILENO)
+				close(pipe_fd[1]);
+		} else {
+			if (dup2(null_fd, STDOUT_FILENO) == -1)
+				_exit(1);
+		}
 		if (dup2(null_fd, STDERR_FILENO) == -1)
 			_exit(1);
-		if (null_fd != STDOUT_FILENO && null_fd != STDERR_FILENO)
-			close(null_fd);
-
 		closefrom(STDERR_FILENO + 1);
 
 		execl(_PATH_BSHELL, "sh", "-c", cmd, (char *) NULL);
 		_exit(1);
 	default:
 		/* Parent process. */
+		sigprocmask(SIG_SETMASK, &oldset, NULL);
 		close(pipe_fd[1]);
 
 		wp->pipe_fd = pipe_fd[0];
-		wp->pipe_off = EVBUFFER_LENGTH(wp->event->input);
-
-		wp->pipe_event = bufferevent_new(wp->pipe_fd,
-		    NULL, NULL, cmd_pipe_pane_error_callback, wp);
-		bufferevent_enable(wp->pipe_event, EV_WRITE);
+		memcpy(wpo, &wp->offset, sizeof *wpo);
 
 		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-refresh-client.c

@@ -18,62 +18,318 @@
 
 #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 },
-	.usage = "[-S] [-C size] " CMD_TARGET_CLIENT_USAGE,
+	.args = { "A:B:cC:Df:r:F:l::LRSt:U", 0, 1, NULL },
+	.usage = "[-cDlLRSU] [-A pane:state] [-B name:what:format] "
+		 "[-C XxY] [-f flags] [-r pane:report] " CMD_TARGET_CLIENT_USAGE
+		 " [adjustment]",
 
-	.tflag = CMD_CLIENT,
-
-	.flags = 0,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG,
 	.exec = cmd_refresh_client_exec
 };
 
-enum cmd_retval
-cmd_refresh_client_exec(struct cmd *self, struct cmd_q *cmdq)
+static void
+cmd_refresh_client_update_subscription(struct client *tc, const char *value)
 {
-	struct args	*args = self->args;
-	struct client	*c = cmdq->state.c;
-	const char	*size;
-	u_int		 w, h;
+	char			*copy, *split, *name, *what;
+	enum control_sub_type	 subtype;
+	int			 subid = -1;
 
-	if (args_has(args, 'C')) {
-		if ((size = args_get(args, 'C')) == NULL) {
-			cmdq_error(cmdq, "missing size");
+	copy = name = xstrdup(value);
+	if ((split = strchr(copy, ':')) == NULL) {
+		control_remove_sub(tc, copy);
+		goto out;
+	}
+	*split++ = '\0';
+
+	what = split;
+	if ((split = strchr(what, ':')) == NULL)
+		goto out;
+	*split++ = '\0';
+
+	if (strcmp(what, "%*") == 0)
+		subtype = CONTROL_SUB_ALL_PANES;
+	else if (sscanf(what, "%%%d", &subid) == 1 && subid >= 0)
+		subtype = CONTROL_SUB_PANE;
+	else if (strcmp(what, "@*") == 0)
+		subtype = CONTROL_SUB_ALL_WINDOWS;
+	else if (sscanf(what, "@%d", &subid) == 1 && subid >= 0)
+		subtype = CONTROL_SUB_WINDOW;
+	else
+		subtype = CONTROL_SUB_SESSION;
+	control_add_sub(tc, name, subtype, subid, split);
+
+out:
+	free(copy);
+}
+
+static enum cmd_retval
+cmd_refresh_client_control_client_size(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		*args = cmd_get_args(self);
+	struct client		*tc = cmdq_get_target_client(item);
+	const char		*size = args_get(args, 'C');
+	u_int			 w, x, y;
+	struct client_window	*cw;
+
+	if (sscanf(size, "@%u:%ux%u", &w, &x, &y) == 3) {
+		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);
 		}
-		if (sscanf(size, "%u,%u", &w, &h) != 2) {
-			cmdq_error(cmdq, "bad size argument");
-			return (CMD_RETURN_ERROR);
+		log_debug("%s: client %s window @%u: size %ux%u", __func__,
+		    tc->name, w, x, y);
+		cw = server_client_add_client_window(tc, w);
+		cw->sx = x;
+		cw->sy = y;
+		tc->flags |= CLIENT_WINDOWSIZECHANGED;
+		recalculate_sizes_now(1);
+		return (CMD_RETURN_NORMAL);
+	}
+	if (sscanf(size, "@%u:", &w) == 1) {
+		cw = server_client_get_client_window(tc, w);
+		if (cw != NULL) {
+			log_debug("%s: client %s window @%u: no size", __func__,
+			    tc->name, w);
+			cw->sx = 0;
+			cw->sy = 0;
+			recalculate_sizes_now(1);
 		}
-		if (w < PANE_MINIMUM || w > 5000 ||
-		    h < PANE_MINIMUM || h > 5000) {
-			cmdq_error(cmdq, "size too small or too big");
-			return (CMD_RETURN_ERROR);
-		}
-		if (!(c->flags & CLIENT_CONTROL)) {
-			cmdq_error(cmdq, "not a control client");
-			return (CMD_RETURN_ERROR);
-		}
-		if (tty_set_size(&c->tty, w, h))
-			recalculate_sizes();
-	} else if (args_has(args, 'S')) {
-		c->flags |= CLIENT_STATUSFORCE;
-		server_status_client(c);
-	} else {
-		c->flags |= CLIENT_STATUSFORCE;
-		server_redraw_client(c);
+		return (CMD_RETURN_NORMAL);
 	}
 
+	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(&tc->tty, x, y, 0, 0);
+	tc->flags |= CLIENT_SIZECHANGED;
+	recalculate_sizes_now(1);
 	return (CMD_RETURN_NORMAL);
 }
+
+static void
+cmd_refresh_client_update_offset(struct client *tc, const char *value)
+{
+	struct window_pane	*wp;
+	char			*copy, *split;
+	u_int			 pane;
+
+	if (*value != '%')
+		return;
+	copy = xstrdup(value);
+	if ((split = strchr(copy, ':')) == NULL)
+		goto out;
+	*split++ = '\0';
+
+	if (sscanf(copy, "%%%u", &pane) != 1)
+		goto out;
+	wp = window_pane_find_by_id(pane);
+	if (wp == NULL)
+		goto out;
+
+	if (strcmp(split, "on") == 0)
+		control_set_pane_on(tc, wp);
+	else if (strcmp(split, "off") == 0)
+		control_set_pane_off(tc, wp);
+	else if (strcmp(split, "continue") == 0)
+		control_continue_pane(tc, wp);
+	else if (strcmp(split, "pause") == 0)
+		control_pause_pane(tc, wp);
+
+out:
+	free(copy);
+}
+
+static enum cmd_retval
+cmd_refresh_client_clipboard(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		*args = cmd_get_args(self);
+	struct client		*tc = cmdq_get_target_client(item);
+	const char		*p;
+	u_int			 i;
+	struct cmd_find_state	 fs;
+
+	p = args_get(args, 'l');
+	if (p == NULL) {
+		if (tc->flags & CLIENT_CLIPBOARDBUFFER)
+			return (CMD_RETURN_NORMAL);
+		tc->flags |= CLIENT_CLIPBOARDBUFFER;
+	} else {
+		if (cmd_find_target(&fs, item, p, CMD_FIND_PANE, 0) != 0)
+			return (CMD_RETURN_ERROR);
+		for (i = 0; i < tc->clipboard_npanes; i++) {
+			if (tc->clipboard_panes[i] == fs.wp->id)
+				break;
+		}
+		if (i != tc->clipboard_npanes)
+			return (CMD_RETURN_NORMAL);
+		tc->clipboard_panes = xreallocarray(tc->clipboard_panes,
+		    tc->clipboard_npanes + 1, sizeof *tc->clipboard_panes);
+		tc->clipboard_panes[tc->clipboard_npanes++] = fs.wp->id;
+	}
+	tty_clipboard_query(&tc->tty);
+	return (CMD_RETURN_NORMAL);
+}
+
+static void
+cmd_refresh_report(struct tty *tty, const char *value)
+{
+	struct window_pane	*wp;
+	u_int			 pane;
+	size_t			 size = 0;
+	char			*copy, *split;
+
+	if (*value != '%')
+		return;
+	copy = xstrdup(value);
+	if ((split = strchr(copy, ':')) == NULL)
+		goto out;
+	*split++ = '\0';
+
+	if (sscanf(copy, "%%%u", &pane) != 1)
+		goto out;
+	wp = window_pane_find_by_id(pane);
+	if (wp == NULL)
+		goto out;
+
+	tty_keys_colours(tty, split, strlen(split), &size, &wp->control_fg,
+	    &wp->control_bg);
+
+out:
+	free(copy);
+}
+
+static enum cmd_retval
+cmd_refresh_client_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		*args = cmd_get_args(self);
+	struct client		*tc = cmdq_get_target_client(item);
+	struct tty		*tty = &tc->tty;
+	struct window		*w;
+	const char		*errstr;
+	u_int			 adjust;
+	struct args_value	*av;
+
+	if (args_has(args, 'c') ||
+	    args_has(args, 'L') ||
+	    args_has(args, 'R') ||
+	    args_has(args, 'U') ||
+	    args_has(args, 'D'))
+	{
+		if (args_count(args) == 0)
+			adjust = 1;
+		else {
+			adjust = strtonum(args_string(args, 0), 1, INT_MAX,
+			    &errstr);
+			if (errstr != NULL) {
+				cmdq_error(item, "adjustment %s", errstr);
+				return (CMD_RETURN_ERROR);
+			}
+		}
+
+		if (args_has(args, 'c'))
+			tc->pan_window = NULL;
+		else {
+			w = tc->session->curw->window;
+			if (tc->pan_window != w) {
+				tc->pan_window = w;
+				tc->pan_ox = tty->oox;
+				tc->pan_oy = tty->ooy;
+			}
+			if (args_has(args, 'L')) {
+				if (tc->pan_ox > adjust)
+					tc->pan_ox -= adjust;
+				else
+					tc->pan_ox = 0;
+			} else if (args_has(args, 'R')) {
+				tc->pan_ox += adjust;
+				if (tc->pan_ox > w->sx - tty->osx)
+					tc->pan_ox = w->sx - tty->osx;
+			} else if (args_has(args, 'U')) {
+				if (tc->pan_oy > adjust)
+					tc->pan_oy -= adjust;
+				else
+					tc->pan_oy = 0;
+			} else if (args_has(args, 'D')) {
+				tc->pan_oy += adjust;
+				if (tc->pan_oy > w->sy - tty->osy)
+					tc->pan_oy = w->sy - tty->osy;
+			}
+		}
+		tty_update_client_offset(tc);
+		server_redraw_client(tc);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	if (args_has(args, 'l'))
+		return (cmd_refresh_client_clipboard(self, item));
+
+	if (args_has(args, 'F')) /* -F is an alias for -f */
+		server_client_set_flags(tc, args_get(args, 'F'));
+	if (args_has(args, 'f'))
+		server_client_set_flags(tc, args_get(args, 'f'));
+	if (args_has(args, 'r'))
+		cmd_refresh_report(tty, args_get(args, 'r'));
+
+	if (args_has(args, 'A')) {
+		if (~tc->flags & CLIENT_CONTROL)
+			goto not_control_client;
+		av = args_first_value(args, 'A');
+		while (av != NULL) {
+			cmd_refresh_client_update_offset(tc, av->string);
+			av = args_next_value(av);
+		}
+		return (CMD_RETURN_NORMAL);
+	}
+	if (args_has(args, 'B')) {
+		if (~tc->flags & CLIENT_CONTROL)
+			goto not_control_client;
+		av = args_first_value(args, 'B');
+		while (av != NULL) {
+			cmd_refresh_client_update_subscription(tc, av->string);
+			av = args_next_value(av);
+		}
+		return (CMD_RETURN_NORMAL);
+	}
+	if (args_has(args, 'C')) {
+		if (~tc->flags & CLIENT_CONTROL)
+			goto not_control_client;
+		return (cmd_refresh_client_control_client_size(self, item));
+	}
+
+	if (args_has(args, 'S')) {
+		tc->flags |= CLIENT_STATUSFORCE;
+		server_status_client(tc);
+	} else {
+		tc->flags |= CLIENT_STATUSFORCE;
+		server_redraw_client(tc);
+	}
+	return (CMD_RETURN_NORMAL);
+
+not_control_client:
+	cmdq_error(item, "not a control client");
+	return (CMD_RETURN_ERROR);
+}

cmd-rename-session.c

@@ -19,6 +19,7 @@
 #include <sys/types.h>
 
 #include <stdlib.h>
+#include <string.h>
 
 #include "tmux.h"
 
@@ -26,45 +27,55 @@
  * 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",
 	.alias = "rename",
 
-	.args = { "t:", 1, 1 },
+	.args = { "t:", 1, 1, NULL },
 	.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
-cmd_rename_session_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_rename_session_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	struct session	*s = cmdq->state.tflag.s;
-	const char	*newname;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct session		*s = target->s;
+	char			*newname, *tmp;
 
-	newname = args->argv[0];
-	if (!session_check_name(newname)) {
-		cmdq_error(cmdq, "bad session name: %s", newname);
+	tmp = format_single_from_target(item, args_string(args, 0));
+	newname = session_check_name(tmp);
+	if (newname == NULL) {
+		cmdq_error(item, "invalid session: %s", tmp);
+		free(tmp);
 		return (CMD_RETURN_ERROR);
 	}
+	free(tmp);
+	if (strcmp(newname, s->name) == 0) {
+		free(newname);
+		return (CMD_RETURN_NORMAL);
+	}
 	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,31 +26,37 @@
  * Rename a window.
  */
 
-enum cmd_retval	 cmd_rename_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_rename_window_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_rename_window_entry = {
 	.name = "rename-window",
 	.alias = "renamew",
 
-	.args = { "t:", 1, 1 },
+	.args = { "t:", 1, 1, NULL },
 	.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
-cmd_rename_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_rename_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	struct winlink	*wl = cmdq->state.tflag.wl;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct winlink		*wl = target->wl;
+	char			*newname;
 
-	window_set_name(wl->window, args->argv[0]);
+	newname = format_single_from_target(item, args_string(args, 0));
+	window_set_name(wl->window, newname);
 	options_set_number(wl->window->options, "automatic-rename", 0);
 
+	server_redraw_window_borders(wl->window);
 	server_status_window(wl->window);
+	free(newname);
 
 	return (CMD_RETURN_NORMAL);
 }

cmd-resize-pane.c

@@ -19,6 +19,7 @@
 #include <sys/types.h>
 
 #include <stdlib.h>
+#include <string.h>
 
 #include "tmux.h"
 
@@ -26,146 +27,189 @@
  * 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",
 	.alias = "resizep",
 
-	.args = { "DLMRt:Ux:y:Z", 0, 1 },
-	.usage = "[-DLMRUZ] [-x width] [-y height] " CMD_TARGET_PANE_USAGE " "
+	.args = { "DLMRTt:Ux:y:Z", 0, 1, NULL },
+	.usage = "[-DLMRTUZ] [-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
-cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_resize_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct key_event	*event = cmdq_get_event(item);
+	struct window_pane	*wp = target->wp;
+	struct winlink		*wl = target->wl;
 	struct window		*w = wl->window;
-	struct client		*c = cmdq->client;
-	struct session		*s = cmdq->state.tflag.s;
+	struct client		*c = cmdq_get_client(item);
+	struct session		*s = target->s;
 	const char	       	*errstr;
 	char			*cause;
 	u_int			 adjust;
-	int			 x, y;
+	int			 x, y, status;
+	struct grid		*gd = wp->base.grid;
+
+	if (args_has(args, 'T')) {
+		if (!TAILQ_EMPTY(&wp->modes))
+			return (CMD_RETURN_NORMAL);
+		adjust = screen_size_y(&wp->base) - 1 - wp->base.cy;
+		if (adjust > gd->hsize)
+			adjust = gd->hsize;
+		grid_remove_history(gd, adjust);
+		wp->base.cy += adjust;
+		wp->flags |= PANE_REDRAW;
+		return (CMD_RETURN_NORMAL);
+	}
 
 	if (args_has(args, 'M')) {
-		if (cmd_mouse_window(&cmdq->item->mouse, &s) == NULL)
+		if (!event->m.valid || cmd_mouse_window(&event->m, &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, &event->m);
 		return (CMD_RETURN_NORMAL);
 	}
 
 	if (args_has(args, 'Z')) {
 		if (w->flags & WINDOW_ZOOMED)
-			window_unzoom(w);
+			window_unzoom(w, 1);
 		else
 			window_zoom(wp);
 		server_redraw_window(w);
-		server_status_window(w);
 		return (CMD_RETURN_NORMAL);
 	}
 	server_unzoom_window(w);
 
-	if (args->argc == 0)
+	if (args_count(args) == 0)
 		adjust = 1;
 	else {
-		adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr);
+		adjust = strtonum(args_string(args, 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')) {
-		x = args_strtonum(self->args, 'x', PANE_MINIMUM, INT_MAX,
-		    &cause);
+	if (args_has(args, 'x')) {
+		x = args_percentage(args, 'x', 0, INT_MAX, w->sx, &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')) {
-		y = args_strtonum(self->args, 'y', PANE_MINIMUM, INT_MAX,
-		    &cause);
+	if (args_has(args, 'y')) {
+		y = args_percentage(args, 'y', 0, INT_MAX, w->sy, &cause);
 		if (cause != NULL) {
-			cmdq_error(cmdq, "height %s", cause);
+			cmdq_error(item, "height %s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
+		status = options_get_number(w->options, "pane-border-status");
+		switch (status) {
+		case PANE_STATUS_TOP:
+			if (y != INT_MAX && wp->yoff == 1)
+				y++;
+			break;
+		case PANE_STATUS_BOTTOM:
+			if (y != INT_MAX && wp->yoff + wp->sy == w->sy - 1)
+				y++;
+			break;
+		}
 		layout_resize_pane_to(wp, LAYOUT_TOPBOTTOM, y);
 	}
 
-	if (args_has(self->args, 'L'))
-		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, -adjust);
-	else if (args_has(self->args, 'R'))
-		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, adjust);
-	else if (args_has(self->args, 'U'))
-		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, -adjust);
-	else if (args_has(self->args, 'D'))
-		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, adjust);
+	if (args_has(args, 'L'))
+		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, -adjust, 1);
+	else if (args_has(args, 'R'))
+		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, adjust, 1);
+	else if (args_has(args, 'U'))
+		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, -adjust, 1);
+	else if (args_has(args, 'D'))
+		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;
-	int			 found;
-	u_int			 y, ly;
+	struct window		*w;
+	u_int			 y, ly, x, lx;
+	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;
-	if (m->statusat == 0 && y > 0)
-		y--;
+	y = m->y + m->oy; x = m->x + m->ox;
+	if (m->statusat == 0 && y >= m->statuslines)
+		y -= m->statuslines;
 	else if (m->statusat > 0 && y >= (u_int)m->statusat)
 		y = m->statusat - 1;
-	ly = m->ly;
-	if (m->statusat == 0 && ly > 0)
-		ly--;
+	ly = m->ly + m->oy; lx = m->lx + m->ox;
+	if (m->statusat == 0 && ly >= m->statuslines)
+		ly -= m->statuslines;
 	else if (m->statusat > 0 && ly >= (u_int)m->statusat)
 		ly = m->statusat - 1;
 
-	found = 0;
-	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
-		if (!window_pane_visible(wp))
+	for (i = 0; i < nitems(cells); i++) {
+		lc = layout_search_by_border(w->layout_root, lx + offsets[i][0],
+		    ly + offsets[i][1]);
+		if (lc == NULL)
 			continue;
 
-		if (wp->xoff + wp->sx == m->lx &&
-		    wp->yoff <= 1 + ly && wp->yoff + wp->sy >= ly) {
-			layout_resize_pane(wp, LAYOUT_LEFTRIGHT, m->x - m->lx);
-			found = 1;
+		for (j = 0; j < ncells; j++) {
+			if (cells[j] == lc) {
+				lc = NULL;
+				break;
+			}
 		}
-		if (wp->yoff + wp->sy == ly &&
-		    wp->xoff <= 1 + m->lx && wp->xoff + wp->sx >= m->lx) {
-			layout_resize_pane(wp, LAYOUT_TOPBOTTOM, y - ly);
-			found = 1;
+		if (lc == NULL)
+			continue;
+
+		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)
-		server_redraw_window(wl->window);
-	else
-		c->tty.mouse_drag_update = NULL;
+	if (resizes != 0)
+		server_redraw_window(w);
 }

cmd-resize-window.c

@@ -0,0 +1,115 @@
+/* $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, NULL },
+	.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 = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct winlink		*wl = target->wl;
+	struct window		*w = wl->window;
+	struct session		*s = target->s;
+	const char	       	*errstr;
+	char			*cause;
+	u_int			 adjust, sx, sy, xpixel = 0, ypixel = 0;
+
+	if (args_count(args) == 0)
+		adjust = 1;
+	else {
+		adjust = strtonum(args_string(args, 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(NULL, s, w, &sx, &sy, &xpixel, &ypixel,
+		    WINDOW_SIZE_LARGEST);
+	} else if (args_has(args, 'a')) {
+		default_window_size(NULL, s, w, &sx, &sy, &xpixel, &ypixel,
+		    WINDOW_SIZE_SMALLEST);
+	}
+
+	options_set_number(w->options, "window-size", WINDOW_SIZE_MANUAL);
+	w->manual_sx = sx;
+	w->manual_sy = sy;
+	recalculate_size(w, 1);
+
+	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,71 @@
  * 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 },
-	.usage = "[-k] " CMD_TARGET_PANE_USAGE " [command]",
+	.args = { "c:e:kt:", 0, -1, NULL },
+	.usage = "[-k] [-c start-directory] [-e environment] "
+		 CMD_TARGET_PANE_USAGE " [shell-command [argument ...]]",
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_respawn_pane_exec
 };
 
-enum cmd_retval
-cmd_respawn_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_respawn_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	struct winlink		*wl = cmdq->state.tflag.wl;
-	struct window		*w = wl->window;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
-	struct session		*s = cmdq->state.tflag.s;
-	struct environ		*env;
-	const char		*path;
-	char			*cause;
-	u_int			 idx;
-	struct environ_entry	*envent;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct spawn_context	 sc = { 0 };
+	struct session		*s = target->s;
+	struct winlink		*wl = target->wl;
+	struct window_pane	*wp = target->wp;
+	char			*cause = NULL;
+	struct args_value	*av;
 
-	if (!args_has(self->args, 'k') && wp->fd != -1) {
-		if (window_pane_index(wp, &idx) != 0)
-			fatalx("index not found");
-		cmdq_error(cmdq, "pane still active: %s:%d.%u",
-		    s->name, wl->idx, idx);
-		return (CMD_RETURN_ERROR);
+	sc.item = item;
+	sc.s = s;
+	sc.wl = wl;
+
+	sc.wp0 = wp;
+
+	args_to_vector(args, &sc.argc, &sc.argv);
+	sc.environ = environ_create();
+
+	av = args_first_value(args, 'e');
+	while (av != NULL) {
+		environ_put(sc.environ, av->string, 0);
+		av = args_next_value(av);
 	}
 
-	env = environ_create();
-	environ_copy(global_environ, env);
-	environ_copy(s->environ, env);
-	server_fill_environ(s, env);
+	sc.idx = -1;
+	sc.cwd = args_get(args, 'c');
 
-	window_pane_reset_mode(wp);
-	screen_reinit(&wp->base);
-	input_init(wp);
+	sc.flags = SPAWN_RESPAWN;
+	if (args_has(args, 'k'))
+		sc.flags |= SPAWN_KILL;
 
-	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(wp, args->argc, args->argv, path, NULL, NULL, env,
-	    s->tio, &cause) != 0) {
-		cmdq_error(cmdq, "respawn pane failed: %s", cause);
+	if (spawn_pane(&sc, &cause) == NULL) {
+		cmdq_error(item, "respawn pane failed: %s", cause);
 		free(cause);
-		environ_free(env);
+		if (sc.argv != NULL)
+			cmd_free_argv(sc.argc, sc.argv);
+		environ_free(sc.environ);
 		return (CMD_RETURN_ERROR);
 	}
-	wp->flags |= PANE_REDRAW;
-	server_status_window(w);
 
-	environ_free(env);
+	wp->flags |= PANE_REDRAW;
+	server_redraw_window_borders(wp->window);
+	server_status_window(wp->window);
+
+	if (sc.argv != NULL)
+		cmd_free_argv(sc.argc, sc.argv);
+	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,69 @@
  * 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 },
-	.usage = "[-k] " CMD_TARGET_WINDOW_USAGE " [command]",
+	.args = { "c:e:kt:", 0, -1, NULL },
+	.usage = "[-k] [-c start-directory] [-e environment] "
+		 CMD_TARGET_WINDOW_USAGE " [shell-command [argument ...]]",
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
 	.flags = 0,
 	.exec = cmd_respawn_window_exec
 };
 
-enum cmd_retval
-cmd_respawn_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_respawn_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	struct session		*s = cmdq->state.tflag.s;
-	struct winlink		*wl = cmdq->state.tflag.wl;
-	struct window		*w = wl->window;
-	struct window_pane	*wp;
-	struct environ		*env;
-	const char		*path;
-	char		 	*cause;
-	struct environ_entry	*envent;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct spawn_context	 sc = { 0 };
+	struct client		*tc = cmdq_get_target_client(item);
+	struct session		*s = target->s;
+	struct winlink		*wl = target->wl;
+	char			*cause = NULL;
+	struct args_value	*av;
 
-	if (!args_has(self->args, 'k')) {
-		TAILQ_FOREACH(wp, &w->panes, entry) {
-			if (wp->fd == -1)
-				continue;
-			cmdq_error(cmdq, "window still active: %s:%d", s->name,
-			    wl->idx);
-			return (CMD_RETURN_ERROR);
-		}
+	sc.item = item;
+	sc.s = s;
+	sc.wl = wl;
+	sc.tc = tc;
+
+	args_to_vector(args, &sc.argc, &sc.argv);
+	sc.environ = environ_create();
+
+	av = args_first_value(args, 'e');
+	while (av != NULL) {
+		environ_put(sc.environ, av->string, 0);
+		av = args_next_value(av);
 	}
 
-	env = environ_create();
-	environ_copy(global_environ, env);
-	environ_copy(s->environ, env);
-	server_fill_environ(s, env);
+	sc.idx = -1;
+	sc.cwd = args_get(args, 'c');
 
-	wp = TAILQ_FIRST(&w->panes);
-	TAILQ_REMOVE(&w->panes, wp, entry);
-	layout_free(w);
-	window_destroy_panes(w);
-	TAILQ_INSERT_HEAD(&w->panes, wp, entry);
-	window_pane_resize(wp, w->sx, w->sy);
+	sc.flags = SPAWN_RESPAWN;
+	if (args_has(args, 'k'))
+		sc.flags |= SPAWN_KILL;
 
-	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(wp, args->argc, args->argv, path, NULL, NULL, env,
-	    s->tio, &cause) != 0) {
-		cmdq_error(cmdq, "respawn window failed: %s", cause);
+	if (spawn_window(&sc, &cause) == NULL) {
+		cmdq_error(item, "respawn window failed: %s", cause);
 		free(cause);
-		environ_free(env);
-		server_destroy_pane(wp, 0);
+		if (sc.argv != NULL)
+			cmd_free_argv(sc.argc, sc.argv);
+		environ_free(sc.environ);
 		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(w);
+	server_redraw_window(wl->window);
 
-	environ_free(env);
+	if (sc.argv != NULL)
+		cmd_free_argv(sc.argc, sc.argv);
+	environ_free(sc.environ);
 	return (CMD_RETURN_NORMAL);
 }

cmd-rotate-window.c

@@ -24,31 +24,37 @@
  * 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",
 	.alias = "rotatew",
 
-	.args = { "Dt:U", 0, 0 },
-	.usage = "[-DU] " CMD_TARGET_WINDOW_USAGE,
+	.args = { "Dt:UZ", 0, 0, NULL },
+	.usage = "[-DUZ] " CMD_TARGET_WINDOW_USAGE,
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
 	.flags = 0,
 	.exec = cmd_rotate_window_exec
 };
 
-enum cmd_retval
-cmd_rotate_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_rotate_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct winlink		*wl = target->wl;
 	struct window		*w = wl->window;
 	struct window_pane	*wp, *wp2;
 	struct layout_cell	*lc;
 	u_int			 sx, sy, xoff, yoff;
 
-	if (args_has(self->args, 'D')) {
+	window_push_zoom(w, 0, args_has(args, 'Z'));
+
+	if (args_has(args, 'D')) {
 		wp = TAILQ_LAST(&w->panes, window_panes);
 		TAILQ_REMOVE(&w->panes, wp, entry);
 		TAILQ_INSERT_HEAD(&w->panes, wp, entry);
@@ -73,8 +79,6 @@ 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);
-		server_redraw_window(w);
 	} else {
 		wp = TAILQ_FIRST(&w->panes);
 		TAILQ_REMOVE(&w->panes, wp, entry);
@@ -100,9 +104,12 @@ 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);
-		server_redraw_window(w);
 	}
 
+	window_set_active_pane(w, wp, 1);
+	cmd_find_from_winlink_pane(current, wl, wp, 0);
+	window_pop_zoom(w);
+	server_redraw_window(w);
+
 	return (CMD_RETURN_NORMAL);
 }

cmd-run-shell.c

@@ -20,6 +20,7 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 
+#include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -29,147 +30,264 @@
  * Runs a command without a window.
  */
 
-enum cmd_retval	 cmd_run_shell_exec(struct cmd *, struct cmd_q *);
+static enum args_parse_type	cmd_run_shell_args_parse(struct args *, u_int,
+				    char **);
+static enum cmd_retval		cmd_run_shell_exec(struct cmd *,
+				    struct cmdq_item *);
 
-void	cmd_run_shell_callback(struct job *);
-void	cmd_run_shell_free(void *);
-void	cmd_run_shell_print(struct job *, const char *);
+static void	cmd_run_shell_timer(int, short, void *);
+static void	cmd_run_shell_callback(struct job *);
+static void	cmd_run_shell_free(void *);
+static void	cmd_run_shell_print(struct job *, const char *);
 
 const struct cmd_entry cmd_run_shell_entry = {
 	.name = "run-shell",
 	.alias = "run",
 
-	.args = { "bt:", 1, 1 },
-	.usage = "[-b] " CMD_TARGET_PANE_USAGE " shell-command",
+	.args = { "bd:Ct:Es:c:", 0, 1, cmd_run_shell_args_parse },
+	.usage = "[-bCE] [-c start-directory] [-d delay] " 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;
-	struct cmd_q	*cmdq;
-	int		 bflag;
-	int		 wp_id;
+	struct client			*client;
+	char				*cmd;
+	struct args_command_state	*state;
+	char				*cwd;
+	struct cmdq_item		*item;
+	struct session			*s;
+	int				 wp_id;
+	struct event			 timer;
+	int				 flags;
 };
 
-void
+static enum args_parse_type
+cmd_run_shell_args_parse(struct args *args, __unused u_int idx,
+    __unused char **cause)
+{
+	if (args_has(args, 'C'))
+		return (ARGS_PARSE_COMMANDS_OR_STRING);
+	return (ARGS_PARSE_STRING);
+}
+
+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);
-		return;
+		if (cdata->item != NULL) {
+			cmdq_print(cdata->item, "%s", msg);
+			return;
+		}
+		if (cdata->item != NULL && cdata->client != NULL)
+			wp = server_client_get_pane(cdata->client);
+		if (wp == NULL && cmd_find_from_nothing(&fs, 0) == 0)
+			wp = fs.wp;
+		if (wp == NULL)
+			return;
 	}
 
-	if (window_pane_set_mode(wp, &window_copy_mode) == 0)
-		window_copy_init_for_output(wp);
-	if (wp->mode == &window_copy_mode)
-		window_copy_add(wp, "%s", msg);
+	wme = TAILQ_FIRST(&wp->modes);
+	if (wme == NULL || wme->mode != &window_view_mode)
+		window_pane_set_mode(wp, NULL, &window_view_mode, NULL, NULL);
+	window_copy_add(wp, 1, "%s", msg);
 }
 
-enum cmd_retval
-cmd_run_shell_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = self->args;
+	struct args			*args = cmd_get_args(self);
+	struct cmd_find_state		*target = cmdq_get_target(item);
 	struct cmd_run_shell_data	*cdata;
-	char				*shellcmd;
-	struct session			*s = cmdq->state.tflag.s;
-	struct winlink			*wl = cmdq->state.tflag.wl;
-	struct window_pane		*wp = cmdq->state.tflag.wp;
-	struct format_tree		*ft;
-	const char			*cwd;
+	struct client			*c = cmdq_get_client(item);
+	struct client			*tc = cmdq_get_target_client(item);
+	struct session			*s = target->s;
+	struct window_pane		*wp = target->wp;
+	const char			*delay, *cmd;
+	double				 d;
+	struct timeval			 tv;
+	char				*end;
+	int				 wait = !args_has(args, 'b');
 
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
-		cwd = cmdq->client->cwd;
-	else if (s != NULL)
-		cwd = s->cwd;
+	if ((delay = args_get(args, 'd')) != NULL) {
+		d = strtod(delay, &end);
+		if (*end != '\0') {
+			cmdq_error(item, "invalid delay time: %s", delay);
+			return (CMD_RETURN_ERROR);
+		}
+	} else if (args_count(args) == 0)
+		return (CMD_RETURN_NORMAL);
+
+	cdata = xcalloc(1, sizeof *cdata);
+	if (!args_has(args, 'C')) {
+		cmd = args_string(args, 0);
+		if (cmd != NULL)
+			cdata->cmd = format_single_from_target(item, cmd);
+	} else {
+		cdata->state = args_make_commands_prepare(self, item, 0, NULL,
+		    wait, 1);
+	}
+
+	if (args_has(args, 't') && wp != NULL)
+		cdata->wp_id = wp->id;
 	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);
+		cdata->wp_id = -1;
 
-	cdata = xmalloc(sizeof *cdata);
-	cdata->cmd = shellcmd;
-	cdata->bflag = args_has(args, 'b');
-	cdata->wp_id = wp != NULL ? (int) wp->id : -1;
+	if (wait) {
+		cdata->client = c;
+		cdata->item = item;
+	} else {
+		cdata->client = tc;
+		cdata->flags |= JOB_NOWAIT;
+	}
+	if (cdata->client != NULL)
+		cdata->client->references++;
+	if (args_has(args, 'c'))
+		cdata->cwd = xstrdup(args_get(args, 'c'));
+	else
+		cdata->cwd = xstrdup(server_client_get_cwd(c, s));
 
-	cdata->cmdq = cmdq;
-	cmdq->references++;
+	if (args_has(args, 'E'))
+		cdata->flags |= JOB_SHOWSTDERR;
 
-	job_run(shellcmd, s, cwd, cmd_run_shell_callback, cmd_run_shell_free,
-	    cdata);
+	cdata->s = s;
+	if (s != NULL)
+		session_add_ref(s, __func__);
 
-	if (cdata->bflag)
+	evtimer_set(&cdata->timer, cmd_run_shell_timer, cdata);
+	if (delay != NULL) {
+		timerclear(&tv);
+		tv.tv_sec = (time_t)d;
+		tv.tv_usec = (d - (double)tv.tv_sec) * 1000000U;
+		evtimer_add(&cdata->timer, &tv);
+	} else
+		event_active(&cdata->timer, EV_TIMEOUT, 1);
+
+	if (!wait)
 		return (CMD_RETURN_NORMAL);
 	return (CMD_RETURN_WAIT);
 }
 
-void
+static void
+cmd_run_shell_timer(__unused int fd, __unused short events, void* arg)
+{
+	struct cmd_run_shell_data	*cdata = arg;
+	struct client			*c = cdata->client;
+	const char			*cmd = cdata->cmd;
+	struct cmdq_item		*item = cdata->item, *new_item;
+	struct cmd_list			*cmdlist;
+	char				*error;
+
+	if (cdata->state == NULL) {
+		if (cmd == NULL) {
+			if (cdata->item != NULL)
+				cmdq_continue(cdata->item);
+			cmd_run_shell_free(cdata);
+			return;
+		}
+		if (job_run(cmd, 0, NULL, NULL, cdata->s, cdata->cwd, NULL,
+		    cmd_run_shell_callback, cmd_run_shell_free, cdata,
+		    cdata->flags, -1, -1) == NULL)
+			cmd_run_shell_free(cdata);
+		return;
+	}
+
+	cmdlist = args_make_commands(cdata->state, 0, NULL, &error);
+	if (cmdlist == NULL) {
+		if (cdata->item == NULL) {
+			*error = toupper((u_char)*error);
+			status_message_set(c, -1, 1, 0, 0, "%s", error);
+		} else
+			cmdq_error(cdata->item, "%s", error);
+		free(error);
+	} else if (item == NULL) {
+		new_item = cmdq_get_command(cmdlist, NULL);
+		cmdq_append(c, new_item);
+	} else {
+		new_item = cmdq_get_command(cmdlist, cmdq_get_state(item));
+		cmdq_insert_after(item, new_item);
+	}
+
+	if (cdata->item != NULL)
+		cmdq_continue(cdata->item);
+	cmd_run_shell_free(cdata);
+}
+
+static void
 cmd_run_shell_callback(struct job *job)
 {
-	struct cmd_run_shell_data	*cdata = job->data;
-	struct cmd_q			*cmdq = cdata->cmdq;
-	char				*cmd, *msg, *line;
+	struct cmd_run_shell_data	*cdata = job_get_data(job);
+	struct bufferevent		*event = job_get_event(job);
+	struct cmdq_item		*item = cdata->item;
+	char				*cmd = cdata->cmd, *msg = NULL, *line;
 	size_t				 size;
-	int				 retcode;
-	u_int				 lines;
+	int				 retcode, status;
 
-	if (cmdq->flags & CMD_Q_DEAD)
-		return;
-	cmd = cdata->cmd;
-
-	lines = 0;
 	do {
-		if ((line = evbuffer_readline(job->event->input)) != NULL) {
+		line = evbuffer_readln(event->input, NULL, EVBUFFER_EOL_LF);
+		if (line != 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;
-	if (WIFEXITED(job->status)) {
-		if ((retcode = WEXITSTATUS(job->status)) != 0)
+	status = job_get_status(job);
+	if (WIFEXITED(status)) {
+		if ((retcode = WEXITSTATUS(status)) != 0)
 			xasprintf(&msg, "'%s' returned %d", cmd, retcode);
-	} else if (WIFSIGNALED(job->status)) {
-		retcode = WTERMSIG(job->status);
+	} else if (WIFSIGNALED(status)) {
+		retcode = WTERMSIG(status);
 		xasprintf(&msg, "'%s' terminated by signal %d", cmd, retcode);
-	}
+		retcode += 128;
+	} else
+		retcode = 0;
 	if (msg != NULL)
 		cmd_run_shell_print(job, msg);
 	free(msg);
+
+	if (item != NULL) {
+		if (cmdq_get_client(item) != NULL &&
+		    cmdq_get_client(item)->session == NULL)
+			cmdq_get_client(item)->retval = retcode;
+		cmdq_continue(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);
 
+	evtimer_del(&cdata->timer);
+	if (cdata->s != NULL)
+		session_remove_ref(cdata->s, __func__);
+	if (cdata->client != NULL)
+		server_client_unref(cdata->client);
+	if (cdata->state != NULL)
+		args_make_commands_free(cdata->state);
+	free(cdata->cwd);
 	free(cdata->cmd);
 	free(cdata);
 }

cmd-save-buffer.c

@@ -31,16 +31,16 @@
  * 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",
 	.alias = "saveb",
 
-	.args = { "ab:", 1, 1 },
+	.args = { "ab:", 1, 1, NULL },
 	.usage = "[-a] " CMD_BUFFER_USAGE " path",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_save_buffer_exec
 };
 
@@ -48,121 +48,73 @@ const struct cmd_entry cmd_show_buffer_entry = {
 	.name = "show-buffer",
 	.alias = "showb",
 
-	.args = { "b:", 0, 0 },
+	.args = { "b:", 0, 0, NULL },
 	.usage = CMD_BUFFER_USAGE,
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_save_buffer_exec
 };
 
-enum cmd_retval
-cmd_save_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+static void
+cmd_save_buffer_done(__unused struct client *c, const char *path, int error,
+    __unused int closed, __unused struct evbuffer *buffer, void *data)
 {
-	struct args		*args = self->args;
-	struct client		*c = cmdq->client;
-	struct session          *s;
-	struct paste_buffer	*pb;
-	const char		*path, *bufname, *bufdata, *start, *end, *cwd;
-	const char		*flags;
-	char			*msg, *file, resolved[PATH_MAX];
-	size_t			 size, used, msglen, bufsize;
-	FILE			*f;
+	struct cmdq_item	*item = data;
 
-	if (!args_has(args, 'b')) {
+	if (!closed)
+		return;
+
+	if (error != 0)
+		cmdq_error(item, "%s: %s", path, strerror(error));
+	cmdq_continue(item);
+}
+
+static enum cmd_retval
+cmd_save_buffer_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		*args = cmd_get_args(self);
+	struct client		*c = cmdq_get_client(item);
+	struct paste_buffer	*pb;
+	int			 flags;
+	const char		*bufname = args_get(args, 'b'), *bufdata;
+	size_t			 bufsize;
+	char			*path;
+	struct evbuffer		*evb;
+
+	if (bufname == NULL) {
 		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 = "-";
-	else
-		path = args->argv[0];
-	if (strcmp(path, "-") == 0) {
-		if (c == NULL) {
-			cmdq_error(cmdq, "can't write to stdout");
-			return (CMD_RETURN_ERROR);
+	if (cmd_get_entry(self) == &cmd_show_buffer_entry) {
+		if (c->session != NULL || (c->flags & CLIENT_CONTROL)) {
+			evb = evbuffer_new();
+			if (evb == NULL)
+				fatalx("out of memory");
+			evbuffer_add(evb, bufdata, bufsize);
+			cmdq_print_data(item, evb);
+			evbuffer_free(evb);
+			return (CMD_RETURN_NORMAL);
 		}
-		if (c->session == NULL || (c->flags & CLIENT_CONTROL))
-			goto do_stdout;
-		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;
+		path = xstrdup("-");
+	} else
+		path = format_single_from_target(item, args_string(args, 0));
+	if (args_has(args, 'a'))
+		flags = O_APPEND;
 	else
-		cwd = ".";
+		flags = O_TRUNC;
+	file_write(cmdq_get_client(item), path, flags, bufdata, bufsize,
+	    cmd_save_buffer_done, item);
+	free(path);
 
-	flags = "wb";
-	if (args_has(self->args, 'a'))
-		flags = "ab";
-
-	if (*path == '/')
-		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, flags);
-	free(file);
-	if (f == NULL) {
-		cmdq_error(cmdq, "%s: %s", resolved, strerror(errno));
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (fwrite(bufdata, 1, bufsize, f) != bufsize) {
-		cmdq_error(cmdq, "%s: write error", resolved);
-		fclose(f);
-		return (CMD_RETURN_ERROR);
-	}
-	fclose(f);
-
-	return (CMD_RETURN_NORMAL);
-
-do_stdout:
-	evbuffer_add(c->stdout_data, bufdata, bufsize);
-	server_client_push_stdout(c);
-	return (CMD_RETURN_NORMAL);
-
-do_print:
-	if (bufsize > (INT_MAX / 4) - 1) {
-		cmdq_error(cmdq, "buffer too big");
-		return (CMD_RETURN_ERROR);
-	}
-	msg = NULL;
-
-	used = 0;
-	while (used != bufsize) {
-		start = bufdata + used;
-		end = memchr(start, '\n', bufsize - used);
-		if (end != NULL)
-			size = end - start;
-		else
-			size = bufsize - used;
-
-		msglen = size * 4 + 1;
-		msg = xrealloc(msg, msglen);
-
-		strvisx(msg, start, size, VIS_OCTAL|VIS_TAB);
-		cmdq_print(cmdq, "%s", msg);
-
-		used += size + (end != NULL);
-	}
-
-	free(msg);
-	return (CMD_RETURN_NORMAL);
+	return (CMD_RETURN_WAIT);
 }

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 },
-	.usage = "[-nop] " CMD_TARGET_WINDOW_USAGE " [layout-name]",
+	.args = { "Enopt:", 0, 1, NULL },
+	.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
 };
 
@@ -45,12 +46,12 @@ const struct cmd_entry cmd_next_layout_entry = {
 	.name = "next-layout",
 	.alias = "nextl",
 
-	.args = { "t:", 0, 0 },
+	.args = { "t:", 0, 0, NULL },
 	.usage = CMD_TARGET_WINDOW_USAGE,
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_select_layout_exec
 };
 
@@ -58,32 +59,33 @@ const struct cmd_entry cmd_previous_layout_entry = {
 	.name = "previous-layout",
 	.alias = "prevl",
 
-	.args = { "t:", 0, 0 },
+	.args = { "t:", 0, 0, NULL },
 	.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
-cmd_select_layout_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_select_layout_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	struct winlink	*wl = cmdq->state.tflag.wl;
-	struct window	*w;
-	const char	*layoutname;
-	char		*oldlayout;
-	int		 next, previous, layout;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct winlink		*wl = target->wl;
+	struct window		*w = wl->window;
+	struct window_pane	*wp = target->wp;
+	const char		*layoutname;
+	char			*oldlayout, *cause;
+	int			 next, previous, layout;
 
-	w = wl->window;
 	server_unzoom_window(w);
 
-	next = self->entry == &cmd_next_layout_entry;
+	next = (cmd_get_entry(self) == &cmd_next_layout_entry);
 	if (args_has(args, 'n'))
 		next = 1;
-	previous = self->entry == &cmd_previous_layout_entry;
+	previous = (cmd_get_entry(self) == &cmd_previous_layout_entry);
 	if (args_has(args, 'p'))
 		previous = 1;
 
@@ -98,27 +100,33 @@ 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_count(args) != 0)
+		layoutname = args_string(args, 0);
+	else if (args_has(args, 'o'))
+		layoutname = oldlayout;
+	else
+		layoutname = NULL;
+
 	if (!args_has(args, 'o')) {
-		if (args->argc == 0)
+		if (layoutname == NULL)
 			layout = w->lastlayout;
 		else
-			layout = layout_set_lookup(args->argv[0]);
+			layout = layout_set_lookup(layoutname);
 		if (layout != -1) {
 			layout_set_select(w, layout);
 			goto changed;
 		}
 	}
 
-	if (args->argc != 0)
-		layoutname = args->argv[0];
-	else if (args_has(args, 'o'))
-		layoutname = oldlayout;
-	else
-		layoutname = NULL;
-
 	if (layoutname != NULL) {
-		if (layout_parse(w, layoutname) == -1) {
-			cmdq_error(cmdq, "can't set layout: %s", layoutname);
+		if (layout_parse(w, layoutname, &cause) == -1) {
+			cmdq_error(item, "%s: %s", cause, layoutname);
+			free(cause);
 			goto error;
 		}
 		goto changed;
@@ -129,7 +137,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 },
-	.usage = "[-DdegLlMmRU] [-P style] " CMD_TARGET_PANE_USAGE,
+	.args = { "DdegLlMmP:RT:t:UZ", 0, 0, NULL }, /* -P and -g deprecated */
+	.usage = "[-DdeLlMmRUZ] [-T title] " CMD_TARGET_PANE_USAGE,
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_select_pane_exec
@@ -43,52 +46,101 @@ const struct cmd_entry cmd_last_pane_entry = {
 	.name = "last-pane",
 	.alias = "lastp",
 
-	.args = { "det:", 0, 0 },
-	.usage = "[-de] " CMD_TARGET_WINDOW_USAGE,
+	.args = { "det:Z", 0, 0, NULL },
+	.usage = "[-deZ] " CMD_TARGET_WINDOW_USAGE,
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
 	.flags = 0,
 	.exec = cmd_select_pane_exec
 };
 
-enum cmd_retval
-cmd_select_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static void
+cmd_select_pane_redraw(struct window *w)
 {
-	struct args		*args = self->args;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	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 = cmd_get_args(self);
+	const struct cmd_entry	*entry = cmd_get_entry(self);
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct client		*c = cmdq_get_client(item);
+	struct winlink		*wl = target->wl;
 	struct window		*w = wl->window;
-	struct session		*s = cmdq->state.tflag.s;
-	struct window_pane	*wp = cmdq->state.tflag.wp, *lastwp, *markedwp;
+	struct session		*s = target->s;
+	struct window_pane	*wp = target->wp, *activewp, *lastwp, *markedwp;
+	struct options		*oo = wp->options;
+	char			*title;
 	const char		*style;
+	struct options_entry	*o;
 
-	if (self->entry == &cmd_last_pane_entry || args_has(args, 'l')) {
-
-		if (wl->window->last == NULL) {
-			cmdq_error(cmdq, "no last pane");
+	if (entry == &cmd_last_pane_entry || args_has(args, 'l')) {
+		/*
+		 * Check for no last pane found in case the other pane was
+		 * spawned without being visited (for example split-window -d).
+		 */
+		lastwp = TAILQ_FIRST(&w->last_panes);
+		if (lastwp == NULL && window_count_panes(w) == 2) {
+			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;
-		else if (args_has(self->args, 'd'))
-			w->last->flags |= PANE_INPUTOFF;
-		else {
-			server_unzoom_window(w);
-			window_redraw_active_switch(w, w->last);
-			if (window_set_active_pane(w, w->last)) {
-				server_status_window(w);
-				server_redraw_window_borders(w);
+		if (args_has(args, 'e')) {
+			lastwp->flags &= ~PANE_INPUTOFF;
+			server_redraw_window_borders(lastwp->window);
+			server_status_window(lastwp->window);
+		} else if (args_has(args, 'd')) {
+			lastwp->flags |= PANE_INPUTOFF;
+			server_redraw_window_borders(lastwp->window);
+			server_status_window(lastwp->window);
+		} else {
+			if (window_push_zoom(w, 0, args_has(args, 'Z')))
+				server_redraw_window(w);
+			window_redraw_active_switch(w, lastwp);
+			if (window_set_active_pane(w, lastwp, 1)) {
+				cmd_find_from_winlink(current, wl, 0);
+				cmd_select_pane_redraw(w);
 			}
+			if (window_pop_zoom(w))
+				server_redraw_window(w);
 		}
-
 		return (CMD_RETURN_NORMAL);
 	}
 
 	if (args_has(args, 'm') || args_has(args, 'M')) {
 		if (args_has(args, 'm') && !window_pane_visible(wp))
 			return (CMD_RETURN_NORMAL);
-		lastwp = marked_pane.wp;
+		if (server_check_marked())
+			lastwp = marked_pane.wp;
+		else
+			lastwp = NULL;
 
 		if (args_has(args, 'M') || server_is_marked(s, wl, wp))
 			server_clear_marked();
@@ -97,68 +149,96 @@ cmd_select_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 		markedwp = marked_pane.wp;
 
 		if (lastwp != NULL) {
+			lastwp->flags |= (PANE_REDRAW|PANE_STYLECHANGED|
+			    PANE_THEMECHANGED);
 			server_redraw_window_borders(lastwp->window);
 			server_status_window(lastwp->window);
 		}
 		if (markedwp != NULL) {
+			markedwp->flags |= (PANE_REDRAW|PANE_STYLECHANGED|
+			    PANE_THEMECHANGED);
 			server_redraw_window_borders(markedwp->window);
 			server_status_window(markedwp->window);
 		}
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (args_has(self->args, 'P') || args_has(self->args, 'g')) {
-		if (args_has(args, 'P')) {
-			style = args_get(args, 'P');
-			if (style_parse(&grid_default_cell, &wp->colgc,
-			    style) == -1) {
-				cmdq_error(cmdq, "bad style: %s", style);
-				return (CMD_RETURN_ERROR);
-			}
-			wp->flags |= PANE_REDRAW;
+	style = args_get(args, 'P');
+	if (style != NULL) {
+		o = options_set_string(oo, "window-style", 0, "%s", style);
+		if (o == NULL) {
+			cmdq_error(item, "bad style: %s", style);
+			return (CMD_RETURN_ERROR);
 		}
-		if (args_has(self->args, 'g'))
-			cmdq_print(cmdq, "%s", style_tostring(&wp->colgc));
+		options_set_string(oo, "window-active-style", 0, "%s", style);
+		wp->flags |= (PANE_REDRAW|PANE_STYLECHANGED|PANE_THEMECHANGED);
+	}
+	if (args_has(args, 'g')) {
+		cmdq_print(item, "%s", options_get_string(oo, "window-style"));
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (args_has(self->args, 'L')) {
-		server_unzoom_window(wp->window);
+	if (args_has(args, 'L')) {
+		window_push_zoom(w, 0, 1);
 		wp = window_pane_find_left(wp);
-	} else if (args_has(self->args, 'R')) {
-		server_unzoom_window(wp->window);
+		window_pop_zoom(w);
+	} else if (args_has(args, 'R')) {
+		window_push_zoom(w, 0, 1);
 		wp = window_pane_find_right(wp);
-	} else if (args_has(self->args, 'U')) {
-		server_unzoom_window(wp->window);
+		window_pop_zoom(w);
+	} else if (args_has(args, 'U')) {
+		window_push_zoom(w, 0, 1);
 		wp = window_pane_find_up(wp);
-	} else if (args_has(self->args, 'D')) {
-		server_unzoom_window(wp->window);
+		window_pop_zoom(w);
+	} else if (args_has(args, 'D')) {
+		window_push_zoom(w, 0, 1);
 		wp = window_pane_find_down(wp);
+		window_pop_zoom(w);
 	}
 	if (wp == NULL)
 		return (CMD_RETURN_NORMAL);
 
-	if (args_has(self->args, 'e')) {
+	if (args_has(args, 'e')) {
 		wp->flags &= ~PANE_INPUTOFF;
+		server_redraw_window_borders(wp->window);
+		server_status_window(wp->window);
 		return (CMD_RETURN_NORMAL);
 	}
-	if (args_has(self->args, 'd')) {
+	if (args_has(args, 'd')) {
 		wp->flags |= PANE_INPUTOFF;
+		server_redraw_window_borders(wp->window);
+		server_status_window(wp->window);
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (wp == w->active)
+	if (args_has(args, 'T')) {
+		title = format_single_from_target(item, args_get(args, 'T'));
+		if (screen_set_title(&wp->base, title)) {
+			notify_pane("pane-title-changed", wp);
+			server_redraw_window_borders(wp->window);
+			server_status_window(wp->window);
+		}
+		free(title);
 		return (CMD_RETURN_NORMAL);
-	server_unzoom_window(wp->window);
-	if (!window_pane_visible(wp)) {
-		cmdq_error(cmdq, "pane not visible");
-		return (CMD_RETURN_ERROR);
 	}
+
+	if (c != NULL && c->session != NULL && (c->flags & CLIENT_ACTIVEPANE))
+		activewp = server_client_get_pane(c);
+	else
+		activewp = w->active;
+	if (wp == activewp)
+		return (CMD_RETURN_NORMAL);
+	if (window_push_zoom(w, 0, args_has(args, 'Z')))
+		server_redraw_window(w);
 	window_redraw_active_switch(w, wp);
-	if (window_set_active_pane(w, wp)) {
-		server_status_window(w);
-		server_redraw_window_borders(w);
-	}
+	if (c != NULL && c->session != NULL && (c->flags & CLIENT_ACTIVEPANE))
+		server_client_set_pane(c, wp);
+	else if (window_set_active_pane(w, wp, 1))
+		cmd_find_from_winlink_pane(current, wl, wp, 0);
+	cmdq_insert_hook(s, item, current, "after-select-pane");
+	cmd_select_pane_redraw(w);
+	if (window_pop_zoom(w))
+		server_redraw_window(w);
 
 	return (CMD_RETURN_NORMAL);
 }

cmd-select-window.c

@@ -26,16 +26,17 @@
  * 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",
 	.alias = "selectw",
 
-	.args = { "lnpTt:", 0, 0 },
+	.args = { "lnpTt:", 0, 0, NULL },
 	.usage = "[-lnpT] " CMD_TARGET_WINDOW_USAGE,
 
-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
 	.flags = 0,
 	.exec = cmd_select_window_exec
@@ -45,10 +46,10 @@ const struct cmd_entry cmd_next_window_entry = {
 	.name = "next-window",
 	.alias = "next",
 
-	.args = { "at:", 0, 0 },
+	.args = { "at:", 0, 0, NULL },
 	.usage = "[-a] " CMD_TARGET_SESSION_USAGE,
 
-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },
 
 	.flags = 0,
 	.exec = cmd_select_window_exec
@@ -58,10 +59,10 @@ const struct cmd_entry cmd_previous_window_entry = {
 	.name = "previous-window",
 	.alias = "prev",
 
-	.args = { "at:", 0, 0 },
+	.args = { "at:", 0, 0, NULL },
 	.usage = "[-a] " CMD_TARGET_SESSION_USAGE,
 
-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },
 
 	.flags = 0,
 	.exec = cmd_select_window_exec
@@ -71,66 +72,78 @@ const struct cmd_entry cmd_last_window_entry = {
 	.name = "last-window",
 	.alias = "last",
 
-	.args = { "t:", 0, 0 },
+	.args = { "t:", 0, 0, NULL },
 	.usage = CMD_TARGET_SESSION_USAGE,
 
-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },
 
 	.flags = 0,
 	.exec = cmd_select_window_exec
 };
 
-enum cmd_retval
-cmd_select_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_select_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct winlink	*wl = cmdq->state.tflag.wl;
-	struct session	*s = cmdq->state.tflag.s;
-	int		 next, previous, last, activity;
+	struct args		*args = cmd_get_args(self);
+	struct client		*c = cmdq_get_client(item);
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct winlink		*wl = target->wl;
+	struct session		*s = target->s;
+	int			 next, previous, last, activity;
 
-	next = self->entry == &cmd_next_window_entry;
-	if (args_has(self->args, 'n'))
+	next = (cmd_get_entry(self) == &cmd_next_window_entry);
+	if (args_has(args, 'n'))
 		next = 1;
-	previous = self->entry == &cmd_previous_window_entry;
-	if (args_has(self->args, 'p'))
+	previous = (cmd_get_entry(self) == &cmd_previous_window_entry);
+	if (args_has(args, 'p'))
 		previous = 1;
-	last = self->entry == &cmd_last_window_entry;
-	if (args_has(self->args, 'l'))
+	last = (cmd_get_entry(self) == &cmd_last_window_entry);
+	if (args_has(args, 'l'))
 		last = 1;
 
 	if (next || previous || last) {
-		activity = args_has(self->args, 'a');
+		activity = args_has(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
 		 * current, switch to previous window.
 		 */
-		if (args_has(self->args, 'T') && wl == s->curw) {
+		if (args_has(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");
 	}
+	if (c != NULL && c->session != NULL)
+		s->curw->window->latest = c;
 	recalculate_sizes();
 
 	return (CMD_RETURN_NORMAL);

cmd-send-keys.c

@@ -27,18 +27,19 @@
  * 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 },
-	.usage = "[-lRM] " CMD_TARGET_PANE_USAGE " key ...",
+	.args = { "c:FHKlMN:Rt:X", 0, -1, NULL },
+	.usage = "[-FHKlMRX] [-c target-client] [-N repeat-count] "
+	         CMD_TARGET_PANE_USAGE " [key ...]",
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_CFLAG|CMD_CLIENT_CANFAIL,
 	.exec = cmd_send_keys_exec
 };
 
@@ -46,60 +47,191 @@ const struct cmd_entry cmd_send_prefix_entry = {
 	.name = "send-prefix",
 	.alias = NULL,
 
-	.args = { "2t:", 0, 0 },
+	.args = { "2t:", 0, 0, NULL },
 	.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
-cmd_send_keys_exec(struct cmd *self, struct cmd_q *cmdq)
+static struct cmdq_item *
+cmd_send_keys_inject_key(struct cmdq_item *item, struct cmdq_item *after,
+    struct args *args, key_code key)
 {
-	struct args		*args = self->args;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
-	struct session		*s = cmdq->state.tflag.s;
-	struct mouse_event	*m = &cmdq->item->mouse;
-	const u_char		*keystr;
-	int			 i, literal;
+	struct cmd_find_state		*target = cmdq_get_target(item);
+	struct client			*tc = cmdq_get_target_client(item);
+	struct session			*s = target->s;
+	struct winlink			*wl = target->wl;
+	struct window_pane		*wp = target->wp;
+	struct window_mode_entry	*wme;
+	struct key_table		*table = NULL;
+	struct key_binding		*bd;
+	struct key_event		*event;
+
+	if (args_has(args, 'K')) {
+		if (tc == NULL)
+			return (item);
+		event = xcalloc(1, sizeof *event);
+		event->key = key|KEYC_SENT;
+		memset(&event->m, 0, sizeof event->m);
+		if (server_client_handle_key(tc, event) == 0) {
+			free(event->buf);
+			free(event);
+		}
+		return (item);
+	}
+
+	wme = TAILQ_FIRST(&wp->modes);
+	if (wme == NULL || wme->mode->key_table == NULL) {
+		if (window_pane_key(wp, tc, s, wl, key, NULL) != 0)
+			return (NULL);
+		return (item);
+	}
+	table = key_bindings_get_table(wme->mode->key_table(wme), 1);
+
+	bd = key_bindings_get(table, key & ~KEYC_MASK_FLAGS);
+	if (bd != NULL) {
+		table->references++;
+		after = key_bindings_dispatch(bd, after, tc, NULL, target);
+		key_bindings_unref_table(table);
+	}
+	return (after);
+}
+
+static struct cmdq_item *
+cmd_send_keys_inject_string(struct cmdq_item *item, struct cmdq_item *after,
+    struct args *args, int i)
+{
+	const char		*s = args_string(args, i);
+	struct utf8_data	*ud, *loop;
+	utf8_char		 uc;
 	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(item, after, args,
+		    KEYC_LITERAL|n));
+	}
+
+	literal = args_has(args, 'l');
+	if (!literal) {
+		key = key_string_lookup_string(s);
+		if (key != KEYC_NONE && key != KEYC_UNKNOWN) {
+			after = cmd_send_keys_inject_key(item, after, args,
+			    key);
+			if (after != NULL)
+				return (after);
+		}
+		literal = 1;
+	}
+	if (literal) {
+		ud = utf8_fromcstr(s);
+		for (loop = ud; loop->size != 0; loop++) {
+			if (loop->size == 1 && loop->data[0] <= 0x7f)
+				key = loop->data[0];
+			else {
+				if (utf8_from_data(loop, &uc) != UTF8_DONE)
+					continue;
+				key = uc;
+			}
+			after = cmd_send_keys_inject_key(item, after, args,
+			    key);
+		}
+		free(ud);
+	}
+	return (after);
+}
+
+static enum cmd_retval
+cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args			*args = cmd_get_args(self);
+	struct cmd_find_state		*target = cmdq_get_target(item);
+	struct client			*tc = cmdq_get_target_client(item);
+	struct session			*s = target->s;
+	struct winlink			*wl = target->wl;
+	struct window_pane		*wp = target->wp;
+	struct key_event		*event = cmdq_get_event(item);
+	struct mouse_event		*m = &event->m;
+	struct window_mode_entry	*wme = TAILQ_FIRST(&wp->modes);
+	struct cmdq_item		*after = item;
+	key_code			 key;
+	u_int				 i, np = 1;
+	u_int				 count = args_count(args);
+	char				*cause = NULL;
+
+	if (args_has(args, 'N')) {
+		np = args_strtonum_and_expand(args, 'N', 1, UINT_MAX, item,
+			 &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "repeat count %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+		if (wme != NULL && (args_has(args, 'X') || count == 0)) {
+			if (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, tc, 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, tc, s, wl, m->key, m);
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (self->entry == &cmd_send_prefix_entry) {
+	if (cmd_get_entry(self) == &cmd_send_prefix_entry) {
 		if (args_has(args, '2'))
 			key = options_get_number(s->options, "prefix2");
 		else
 			key = options_get_number(s->options, "prefix");
-		window_pane_key(wp, NULL, s, key, NULL);
+		cmd_send_keys_inject_key(item, item, args, key);
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (args_has(args, 'R'))
-		input_reset(wp, 1);
+	if (args_has(args, 'R')) {
+		colour_palette_clear(&wp->palette);
+		input_reset(wp->ictx, 1);
+		wp->flags |= (PANE_STYLECHANGED|PANE_THEMECHANGED|PANE_REDRAW);
+	}
 
-	for (i = 0; i < args->argc; i++) {
-		literal = args_has(args, 'l');
-		if (!literal) {
-			key = key_string_lookup_string(args->argv[i]);
-			if (key != KEYC_NONE && key != KEYC_UNKNOWN)
-				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);
+	if (count == 0) {
+		if (args_has(args, 'N') || args_has(args, 'R'))
+			return (CMD_RETURN_NORMAL);
+		for (; np != 0; np--)
+			cmd_send_keys_inject_key(item, NULL, args, event->key);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	for (; np != 0; np--) {
+		for (i = 0; i < count; i++) {
+			after = cmd_send_keys_inject_string(item, after, args,
+			    i);
 		}
 	}
 

cmd-server-access.c

@@ -0,0 +1,147 @@
+/* $OpenBSD$ */
+
+/*
+ * Copyright (c) 2021 Dallas Lyons <dallasdlyons@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/stat.h>
+#include <sys/types.h>
+
+#include <pwd.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "tmux.h"
+
+/*
+ * Controls access to session.
+ */
+
+static enum cmd_retval cmd_server_access_exec(struct cmd *, struct cmdq_item *);
+
+const struct cmd_entry cmd_server_access_entry = {
+	.name = "server-access",
+	.alias = NULL,
+
+	.args = { "adlrw", 0, 1, NULL },
+	.usage = "[-adlrw] " CMD_TARGET_PANE_USAGE " [user]",
+
+	.flags = CMD_CLIENT_CANFAIL,
+	.exec = cmd_server_access_exec
+};
+
+static enum cmd_retval
+cmd_server_access_deny(struct cmdq_item *item, struct passwd *pw)
+{
+	struct client		*loop;
+	struct server_acl_user	*user;
+	uid_t			 uid;
+
+	if ((user = server_acl_user_find(pw->pw_uid)) == NULL) {
+		cmdq_error(item, "user %s not found", pw->pw_name);
+		return (CMD_RETURN_ERROR);
+	}
+	TAILQ_FOREACH(loop, &clients, entry) {
+		uid = proc_get_peer_uid(loop->peer);
+		if (uid == server_acl_get_uid(user)) {
+			loop->exit_message = xstrdup("access not allowed");
+			loop->flags |= CLIENT_EXIT;
+		}
+	}
+	server_acl_user_deny(pw->pw_uid);
+
+	return (CMD_RETURN_NORMAL);
+}
+
+static enum cmd_retval
+cmd_server_access_exec(struct cmd *self, struct cmdq_item *item)
+{
+
+	struct args	*args = cmd_get_args(self);
+	struct client	*c = cmdq_get_target_client(item);
+	char		*name;
+	struct passwd	*pw = NULL;
+
+	if (args_has(args, 'l')) {
+		server_acl_display(item);
+		return (CMD_RETURN_NORMAL);
+	}
+	if (args_count(args) == 0) {
+		cmdq_error(item, "missing user argument");
+		return (CMD_RETURN_ERROR);
+	}
+
+	name = format_single(item, args_string(args, 0), c, NULL, NULL, NULL);
+	if (*name != '\0')
+		pw = getpwnam(name);
+	if (pw == NULL) {
+		cmdq_error(item, "unknown user: %s", name);
+		return (CMD_RETURN_ERROR);
+	}
+	free(name);
+
+	if (pw->pw_uid == 0 || pw->pw_uid == getuid()) {
+		cmdq_error(item, "%s owns the server, can't change access",
+		    pw->pw_name);
+		return (CMD_RETURN_ERROR);
+	}
+
+	if (args_has(args, 'a') && args_has(args, 'd')) {
+		cmdq_error(item, "-a and -d cannot be used together");
+		return (CMD_RETURN_ERROR);
+	}
+	if (args_has(args, 'w') && args_has(args, 'r')) {
+		cmdq_error(item, "-r and -w cannot be used together");
+		return (CMD_RETURN_ERROR);
+	}
+
+	if (args_has(args, 'd'))
+		return (cmd_server_access_deny(item, pw));
+	if (args_has(args, 'a')) {
+		if (server_acl_user_find(pw->pw_uid) != NULL) {
+			cmdq_error(item, "user %s is already added",
+			    pw->pw_name);
+			return (CMD_RETURN_ERROR);
+		}
+		server_acl_user_allow(pw->pw_uid);
+		/* Do not return - allow -r or -w with -a. */
+	} else if (args_has(args, 'r') || args_has(args, 'w')) {
+		/* -r or -w implies -a if user does not exist. */
+		if (server_acl_user_find(pw->pw_uid) == NULL)
+			server_acl_user_allow(pw->pw_uid);
+	}
+
+	if (args_has(args, 'w')) {
+		if (server_acl_user_find(pw->pw_uid) == NULL) {
+			cmdq_error(item, "user %s not found", pw->pw_name);
+			return (CMD_RETURN_ERROR);
+		}
+		server_acl_user_allow_write(pw->pw_uid);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	if (args_has(args, 'r')) {
+		if (server_acl_user_find(pw->pw_uid) == NULL) {
+			cmdq_error(item, "user %s not found", pw->pw_name);
+			return (CMD_RETURN_ERROR);
+		}
+		server_acl_user_deny_write(pw->pw_uid);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	return (CMD_RETURN_NORMAL);
+}

cmd-set-buffer.c

@@ -27,16 +27,17 @@
  * 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",
 	.alias = "setb",
 
-	.args = { "ab:n:", 0, 1 },
-	.usage = "[-a] " CMD_BUFFER_USAGE " [-n new-buffer-name] data",
+	.args = { "ab:t:n:w", 0, 1, NULL },
+	.usage = "[-aw] " CMD_BUFFER_USAGE " [-n new-buffer-name] "
+	         CMD_TARGET_CLIENT_USAGE " [data]",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG|CMD_CLIENT_CANFAIL,
 	.exec = cmd_set_buffer_exec
 };
 
@@ -44,17 +45,18 @@ const struct cmd_entry cmd_delete_buffer_entry = {
 	.name = "delete-buffer",
 	.alias = "deleteb",
 
-	.args = { "b:", 0, 0 },
+	.args = { "b:", 0, 0, NULL },
 	.usage = CMD_BUFFER_USAGE,
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_buffer_exec
 };
 
-enum cmd_retval
-cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_set_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
+	struct client		*tc = cmdq_get_target_client(item);
 	struct paste_buffer	*pb;
 	char			*bufdata, *cause;
 	const char		*bufname, *olddata;
@@ -66,11 +68,16 @@ cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 	else
 		pb = paste_get_name(bufname);
 
-	if (self->entry == &cmd_delete_buffer_entry) {
-		if (pb == NULL)
-			pb = paste_get_top(&bufname);
+	if (cmd_get_entry(self) == &cmd_delete_buffer_entry) {
 		if (pb == NULL) {
-			cmdq_error(cmdq, "no buffer");
+			if (bufname != NULL) {
+				cmdq_error(item, "unknown buffer: %s", bufname);
+				return (CMD_RETURN_ERROR);
+			}
+			pb = paste_get_top(&bufname);
+		}
+		if (pb == NULL) {
+			cmdq_error(item, "no buffer");
 			return (CMD_RETURN_ERROR);
 		}
 		paste_free(pb);
@@ -78,25 +85,30 @@ cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 	}
 
 	if (args_has(args, 'n')) {
-		if (pb == NULL)
-			pb = paste_get_top(&bufname);
 		if (pb == NULL) {
-			cmdq_error(cmdq, "no buffer");
+			if (bufname != NULL) {
+				cmdq_error(item, "unknown buffer: %s", bufname);
+				return (CMD_RETURN_ERROR);
+			}
+			pb = paste_get_top(&bufname);
+		}
+		if (pb == NULL) {
+			cmdq_error(item, "no buffer");
 			return (CMD_RETURN_ERROR);
 		}
 		if (paste_rename(bufname, args_get(args, 'n'), &cause) != 0) {
-			cmdq_error(cmdq, "%s", cause);
+			cmdq_error(item, "%s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
 		return (CMD_RETURN_NORMAL);
 	}
 
-	if (args->argc != 1) {
-		cmdq_error(cmdq, "no data specified");
+	if (args_count(args) != 1) {
+		cmdq_error(item, "no data specified");
 		return (CMD_RETURN_ERROR);
 	}
-	if ((newsize = strlen(args->argv[0])) == 0)
+	if ((newsize = strlen(args_string(args, 0))) == 0)
 		return (CMD_RETURN_NORMAL);
 
 	bufsize = 0;
@@ -109,15 +121,17 @@ cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 	}
 
 	bufdata = xrealloc(bufdata, bufsize + newsize);
-	memcpy(bufdata + bufsize, args->argv[0], newsize);
+	memcpy(bufdata + bufsize, args_string(args, 0), newsize);
 	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);
 	}
+	if (args_has(args, 'w') && tc != NULL)
+ 		tty_set_selection(&tc->tty, "", bufdata, bufsize);
 
 	return (CMD_RETURN_NORMAL);
 }

cmd-set-environment.c

@@ -27,76 +27,93 @@
  * 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",
 	.alias = "setenv",
 
-	.args = { "grt:u", 1, 2 },
-	.usage = "[-gru] " CMD_TARGET_SESSION_USAGE " name [value]",
+	.args = { "Fhgrt:u", 1, 2, NULL },
+	.usage = "[-Fhgru] " CMD_TARGET_SESSION_USAGE " variable [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
-cmd_set_environment_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_set_environment_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	struct environ	*env;
-	const char	*name, *value, *target;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct environ		*env;
+	const char		*name = args_string(args, 0), *value;
+	const char		*tflag;
+	char			*expanded = NULL;
+	enum cmd_retval		 retval = CMD_RETURN_NORMAL;
 
-	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);
 	}
 
-	if (args->argc < 2)
+	if (args_count(args) < 2)
 		value = NULL;
 	else
-		value = args->argv[1];
-
-	if (args_has(self->args, 'g'))
+		value = args_string(args, 1);
+	if (value != NULL && args_has(args, 'F')) {
+		expanded = format_single_from_target(item, value);
+		value = expanded;
+	}
+	if (args_has(args, 'g'))
 		env = global_environ;
 	else {
-		if (cmdq->state.tflag.s == NULL) {
-			target = args_get(args, 't');
-			if (target != NULL)
-				cmdq_error(cmdq, "no such session: %s", target);
+		if (target->s == NULL) {
+			tflag = args_get(args, 't');
+			if (tflag != NULL)
+				cmdq_error(item, "no such session: %s", tflag);
 			else
-				cmdq_error(cmdq, "no current session");
-			return (CMD_RETURN_ERROR);
+				cmdq_error(item, "no current session");
+			retval = CMD_RETURN_ERROR;
+			goto out;
 		}
-		env = cmdq->state.tflag.s->environ;
+		env = target->s->environ;
 	}
 
-	if (args_has(self->args, 'u')) {
+	if (args_has(args, 'u')) {
 		if (value != NULL) {
-			cmdq_error(cmdq, "can't specify a value with -u");
-			return (CMD_RETURN_ERROR);
+			cmdq_error(item, "can't specify a value with -u");
+			retval = CMD_RETURN_ERROR;
+			goto out;
 		}
 		environ_unset(env, name);
-	} else if (args_has(self->args, 'r')) {
+	} else if (args_has(args, 'r')) {
 		if (value != NULL) {
-			cmdq_error(cmdq, "can't specify a value with -r");
-			return (CMD_RETURN_ERROR);
+			cmdq_error(item, "can't specify a value with -r");
+			retval = CMD_RETURN_ERROR;
+			goto out;
 		}
 		environ_clear(env, name);
 	} else {
 		if (value == NULL) {
-			cmdq_error(cmdq, "no value specified");
-			return (CMD_RETURN_ERROR);
+			cmdq_error(item, "no value specified");
+			retval = CMD_RETURN_ERROR;
+			goto out;
 		}
-		environ_set(env, name, "%s", value);
+
+		if (args_has(args, 'h'))
+			environ_set(env, name, ENVIRON_HIDDEN, "%s", value);
+		else
+			environ_set(env, name, 0, "%s", value);
 	}
 
-	return (CMD_RETURN_NORMAL);
+out:
+	free(expanded);
+	return (retval);
 }

cmd-set-hook.c

@@ -1,120 +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,
-
-	.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;
-
-	if (args_has(args, 'g'))
-		hooks = global_hooks;
-	else
-		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

@@ -27,53 +27,21 @@
  * Set an option.
  */
 
-enum cmd_retval	cmd_set_option_exec(struct cmd *, struct cmd_q *);
-
-enum cmd_retval	cmd_set_option_user(struct cmd *, struct cmd_q *,
-	    const char *, const char *);
-
-int	cmd_set_option_unset(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-int	cmd_set_option_set(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-
-struct options_entry *cmd_set_option_string(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_number(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_key(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_colour(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_attributes(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_flag(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_choice(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_style(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
+static enum args_parse_type	cmd_set_option_args_parse(struct args *,
+				    u_int, char **);
+static enum cmd_retval		cmd_set_option_exec(struct cmd *,
+				    struct cmdq_item *);
 
 const struct cmd_entry cmd_set_option_entry = {
 	.name = "set-option",
 	.alias = "set",
 
-	.args = { "agoqst:uw", 1, 2 },
-	.usage = "[-agosquw] [-t target-window] option [value]",
+	.args = { "aFgopqst:uUw", 1, 2, cmd_set_option_args_parse },
+	.usage = "[-aFgopqsuUw] " 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,445 +49,191 @@ const struct cmd_entry cmd_set_window_option_entry = {
 	.name = "set-window-option",
 	.alias = "setw",
 
-	.args = { "agoqt:u", 1, 2 },
-	.usage = "[-agoqu] " CMD_TARGET_WINDOW_USAGE " option [value]",
+	.args = { "aFgoqt:u", 1, 2, cmd_set_option_args_parse },
+	.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
-cmd_set_option_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	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;
+const struct cmd_entry cmd_set_hook_entry = {
+	.name = "set-hook",
+	.alias = NULL,
 
-	/* Get the option name and value. */
-	optstr = args->argv[0];
-	if (*optstr == '\0') {
-		cmdq_error(cmdq, "invalid option");
-		return (CMD_RETURN_ERROR);
+	.args = { "agpRt:uw", 1, 2, cmd_set_option_args_parse },
+	.usage = "[-agpRuw] " CMD_TARGET_PANE_USAGE " hook [command]",
+
+	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_set_option_exec
+};
+
+static enum args_parse_type
+cmd_set_option_args_parse(__unused struct args *args, u_int idx,
+    __unused char **cause)
+{
+	if (idx == 1)
+		return (ARGS_PARSE_COMMANDS_OR_STRING);
+	return (ARGS_PARSE_STRING);
+}
+
+static enum cmd_retval
+cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args			*args = cmd_get_args(self);
+	int				 append = args_has(args, 'a');
+	struct cmd_find_state		*target = cmdq_get_target(item);
+	struct window_pane		*loop;
+	struct options			*oo;
+	struct options_entry		*parent, *o, *po;
+	char				*name, *argument, *expanded = NULL;
+	char				*cause;
+	const char			*value;
+	int				 window, idx, already, error, ambiguous;
+	int				 scope;
+
+	window = (cmd_get_entry(self) == &cmd_set_window_option_entry);
+
+	/* Expand argument. */
+	argument = format_single_from_target(item, args_string(args, 0));
+
+	/* If set-hook -R, fire the hook straight away. */
+	if (cmd_get_entry(self) == &cmd_set_hook_entry && args_has(args, 'R')) {
+		notify_hook(item, argument);
+		free(argument);
+		return (CMD_RETURN_NORMAL);
 	}
-	if (args->argc < 2)
-		valstr = NULL;
+
+	/* Parse option name and index. */
+	name = options_match(argument, &idx, &ambiguous);
+	if (name == NULL) {
+		if (args_has(args, 'q'))
+			goto out;
+		if (ambiguous)
+			cmdq_error(item, "ambiguous option: %s", argument);
+		else
+			cmdq_error(item, "invalid option: %s", argument);
+		goto fail;
+	}
+	if (args_count(args) < 2)
+		value = NULL;
 	else
-		valstr = args->argv[1];
-
-	/* Is this a user option? */
-	if (*optstr == '@')
-		return (cmd_set_option_user(self, cmdq, optstr, valstr));
-
-	/* Find the option entry, try each table. */
-	oe = NULL;
-	if (options_table_find(optstr, &oe) != 0) {
-		if (!args_has(args, 'q')) {
-			cmdq_error(cmdq, "ambiguous option: %s", optstr);
-			return (CMD_RETURN_ERROR);
-		}
-		return (CMD_RETURN_NORMAL);
-	}
-	if (oe == NULL) {
-		if (!args_has(args, 'q')) {
-			cmdq_error(cmdq, "unknown option: %s", optstr);
-			return (CMD_RETURN_ERROR);
-		}
-		return (CMD_RETURN_NORMAL);
+		value = args_string(args, 1);
+	if (value != NULL && args_has(args, 'F')) {
+		expanded = format_single_from_target(item, value);
+		value = expanded;
 	}
 
-	/* Work out the tree from the scope of 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);
+	/* Get the scope and table for the option .*/
+	scope = options_scope_from_name(args, window, name, target, &oo,
+	    &cause);
+	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);
+
+	/* Check that array options and indexes match up. */
+	if (idx != -1 && (*name == '@' || !options_is_array(parent))) {
+		cmdq_error(item, "not an array: %s", argument);
+		goto fail;
 	}
 
-	/* Unset or set the option. */
-	if (args_has(args, 'u')) {
-		if (cmd_set_option_unset(self, cmdq, oe, oo, valstr) != 0)
-			return (CMD_RETURN_ERROR);
-	} else {
-		if (args_has(args, 'o') && options_find1(oo, optstr) != NULL) {
-			if (!args_has(args, 'q')) {
-				cmdq_error(cmdq, "already set: %s", optstr);
-				return (CMD_RETURN_ERROR);
-			}
-			return (CMD_RETURN_NORMAL);
-		}
-		if (cmd_set_option_set(self, cmdq, oe, oo, valstr) != 0)
-			return (CMD_RETURN_ERROR);
-	}
-
-	/* Start or stop timers if necessary. */
-	if (strcmp(oe->name, "automatic-rename") == 0) {
-		RB_FOREACH(w, windows, &windows) {
-			if (options_get_number(w->options, "automatic-rename"))
-				w->active->flags |= PANE_CHANGED;
-		}
-	}
-	if (strcmp(oe->name, "key-table") == 0) {
-		TAILQ_FOREACH(c, &clients, entry)
-			server_client_set_key_table(c, NULL);
-	}
-	if (strcmp(oe->name, "status") == 0 ||
-	    strcmp(oe->name, "status-interval") == 0)
-		status_timer_start_all();
-	if (strcmp(oe->name, "monitor-silence") == 0)
-		alerts_reset_all();
-
-	/* Update sizes and redraw. May not need it but meh. */
-	recalculate_sizes();
-	TAILQ_FOREACH(c, &clients, entry) {
-		if (c->session != NULL)
-			server_redraw_client(c);
-	}
-
-	return (CMD_RETURN_NORMAL);
-}
-
-/* Set user option. */
-enum cmd_retval
-cmd_set_option_user(struct cmd *self, struct cmd_q *cmdq, const char *optstr,
-    const char *valstr)
-{
-	struct args	*args = self->args;
-	struct session	*s = cmdq->state.tflag.s;
-	struct winlink	*wl = cmdq->state.tflag.wl;
-	struct options	*oo;
-
-	if (args_has(args, 's'))
-		oo = global_options;
-	else if (args_has(self->args, 'w') ||
-	    self->entry == &cmd_set_window_option_entry) {
-		if (args_has(self->args, 'g'))
-			oo = global_w_options;
-		else
-			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 {
-		if (valstr == NULL) {
-			cmdq_error(cmdq, "empty value");
-			return (CMD_RETURN_ERROR);
-		}
-		if (args_has(args, 'o') && options_find1(oo, optstr) != NULL) {
-			if (!args_has(args, 'q')) {
-				cmdq_error(cmdq, "already set: %s", optstr);
-				return (CMD_RETURN_ERROR);
-			}
-			return (CMD_RETURN_NORMAL);
-		}
-		options_set_string(oo, optstr, "%s", valstr);
-	}
-	return (CMD_RETURN_NORMAL);
-}
-
-/* Unset an option. */
-int
-cmd_set_option_unset(struct cmd *self, struct cmd_q *cmdq,
-    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);
-		break;
-	case OPTIONS_TABLE_NUMBER:
-		o = cmd_set_option_number(self, cmdq, oe, oo, value);
-		break;
-	case OPTIONS_TABLE_KEY:
-		o = cmd_set_option_key(self, cmdq, oe, oo, value);
-		break;
-	case OPTIONS_TABLE_COLOUR:
-		o = cmd_set_option_colour(self, cmdq, oe, oo, value);
-		if (o != NULL)
-			style_update_new(oo, o->name, oe->style);
-		break;
-	case OPTIONS_TABLE_ATTRIBUTES:
-		o = cmd_set_option_attributes(self, cmdq, oe, oo, value);
-		if (o != NULL)
-			style_update_new(oo, o->name, oe->style);
-		break;
-	case OPTIONS_TABLE_FLAG:
-		o = cmd_set_option_flag(self, cmdq, oe, oo, value);
-		break;
-	case OPTIONS_TABLE_CHOICE:
-		o = cmd_set_option_choice(self, cmdq, oe, oo, value);
-		break;
-	case OPTIONS_TABLE_STYLE:
-		o = cmd_set_option_style(self, cmdq, oe, oo, value);
-		break;
-	}
-	if (o == NULL)
-		return (-1);
-	return (0);
-}
-
-/* Set a string option. */
-struct options_entry *
-cmd_set_option_string(struct cmd *self, __unused struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	struct args		*args = self->args;
-	struct options_entry	*o;
-	char			*oldval, *newval;
-
-	if (args_has(args, 'a')) {
-		oldval = options_get_string(oo, oe->name);
-		xasprintf(&newval, "%s%s", oldval, value);
-	} else
-		newval = xstrdup(value);
-
-	o = options_set_string(oo, oe->name, "%s", newval);
-
-	free(newval);
-	return (o);
-}
-
-/* Set a number option. */
-struct options_entry *
-cmd_set_option_number(__unused struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	long long	 ll;
-	const char     	*errstr;
-
-	ll = strtonum(value, oe->minimum, oe->maximum, &errstr);
-	if (errstr != NULL) {
-		cmdq_error(cmdq, "value is %s: %s", errstr, value);
-		return (NULL);
-	}
-
-	return (options_set_number(oo, oe->name, ll));
-}
-
-/* Set a key option. */
-struct options_entry *
-cmd_set_option_key(__unused struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	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)
-{
-	int	flag;
-
-	if (value == NULL || *value == '\0')
-		flag = !options_get_number(oo, oe->name);
-	else {
-		if ((value[0] == '1' && value[1] == '\0') ||
-		    strcasecmp(value, "on") == 0 ||
-		    strcasecmp(value, "yes") == 0)
-			flag = 1;
-		else if ((value[0] == '0' && value[1] == '\0') ||
-		    strcasecmp(value, "off") == 0 ||
-		    strcasecmp(value, "no") == 0)
-			flag = 0;
+	/* 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 {
-			cmdq_error(cmdq, "bad value: %s", value);
-			return (NULL);
+			if (o == NULL)
+				already = 0;
+			else
+				already = (options_array_get(o, idx) != NULL);
+		}
+		if (already) {
+			if (args_has(args, 'q'))
+				goto out;
+			cmdq_error(item, "already set: %s", argument);
+			goto fail;
 		}
 	}
 
-	return (options_set_number(oo, oe->name, flag));
-}
-
-/* Set a choice option. */
-struct options_entry *
-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;
-	int		  n, choice = -1;
-
-	if (value == NULL) {
-		choice = options_get_number(oo, oe->name);
-		if (choice < 2)
-			choice = !choice;
-	} else {
-		n = 0;
-		for (choicep = oe->choices; *choicep != NULL; choicep++) {
-			n++;
-			if (strncmp(*choicep, value, strlen(value)) != 0)
+	/* Change the option. */
+	if (args_has(args, 'U') && scope == OPTIONS_TABLE_WINDOW) {
+		TAILQ_FOREACH(loop, &target->w->panes, entry) {
+			po = options_get_only(loop->options, name);
+			if (po == NULL)
 				continue;
-
-			if (choice != -1) {
-				cmdq_error(cmdq, "ambiguous value: %s", value);
-				return (NULL);
+			if (options_remove_or_default(po, idx, &cause) != 0) {
+				cmdq_error(item, "%s", cause);
+				free(cause);
+				goto fail;
 			}
-			choice = n - 1;
 		}
-		if (choice == -1) {
-			cmdq_error(cmdq, "unknown value: %s", value);
-			return (NULL);
+	}
+	if (args_has(args, 'u') || args_has(args, 'U')) {
+		if (o == NULL)
+			goto out;
+		if (options_remove_or_default(o, idx, &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_is_array(parent)) {
+		error = options_from_string(oo, options_table_entry(parent),
+		    options_table_entry(parent)->name, value,
+		    args_has(args, 'a'), &cause);
+		if (error != 0) {
+			cmdq_error(item, "%s", cause);
+			free(cause);
+			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;
 		}
 	}
 
-	return (options_set_number(oo, oe->name, choice));
-}
-
-/* Set a style option. */
-struct options_entry *
-cmd_set_option_style(struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	struct args		*args = self->args;
-	struct options_entry	*o;
-	int			 append;
-
-	append = args_has(args, 'a');
-	if ((o = options_set_style(oo, oe->name, value, append)) == NULL) {
-		cmdq_error(cmdq, "bad style: %s", value);
-		return (NULL);
-	}
-
-	style_update_old(oo, oe->name, &o->style);
-	return (o);
+	options_push_changes(name);
+
+out:
+	free(argument);
+	free(expanded);
+	free(name);
+	return (CMD_RETURN_NORMAL);
+
+fail:
+	free(argument);
+	free(expanded);
+	free(name);
+	return (CMD_RETURN_ERROR);
 }

cmd-show-environment.c

@@ -27,26 +27,27 @@
  * 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 *);
-void	 cmd_show_environment_print(struct cmd *, struct cmd_q *,
-	     struct environ_entry *);
+static char	*cmd_show_environment_escape(struct environ_entry *);
+static void	 cmd_show_environment_print(struct cmd *, struct cmdq_item *,
+		     struct environ_entry *);
 
 const struct cmd_entry cmd_show_environment_entry = {
 	.name = "show-environment",
 	.alias = "showenv",
 
-	.args = { "gst:", 0, 1 },
-	.usage = "[-gs] " CMD_TARGET_SESSION_USAGE " [name]",
+	.args = { "hgst:", 0, 1, NULL },
+	.usage = "[-hgs] " CMD_TARGET_SESSION_USAGE " [variable]",
 
-	.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,71 +65,78 @@ cmd_show_environment_escape(struct environ_entry *envent)
 	return (ret);
 }
 
-void
-cmd_show_environment_print(struct cmd *self, struct cmd_q *cmdq,
+static void
+cmd_show_environment_print(struct cmd *self, struct cmdq_item *item,
     struct environ_entry *envent)
 {
-	char	*escaped;
+	struct args	*args = cmd_get_args(self);
+	char		*escaped;
 
-	if (!args_has(self->args, 's')) {
+	if (!args_has(args, 'h') && (envent->flags & ENVIRON_HIDDEN))
+		return;
+	if (args_has(args, 'h') && (~envent->flags & ENVIRON_HIDDEN))
+		return;
+
+	if (!args_has(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
-cmd_show_environment_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_show_environment_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*target = cmdq_get_target(item);
 	struct environ		*env;
 	struct environ_entry	*envent;
-	const char		*target;
+	const char		*tflag, *name = args_string(args, 0);
 
-	if ((target = args_get(args, 't')) != NULL) {
-		if (cmdq->state.tflag.s == NULL) {
-			cmdq_error(cmdq, "no such session: %s", target);
+	if ((tflag = args_get(args, 't')) != NULL) {
+		if (target->s == NULL) {
+			cmdq_error(item, "no such session: %s", tflag);
 			return (CMD_RETURN_ERROR);
 		}
 	}
 
-	if (args_has(self->args, 'g'))
+	if (args_has(args, 'g'))
 		env = global_environ;
 	else {
-		if (cmdq->state.tflag.s == NULL) {
-			target = args_get(args, 't');
-			if (target != NULL)
-				cmdq_error(cmdq, "no such session: %s", target);
+		if (target->s == NULL) {
+			tflag = args_get(args, 't');
+			if (tflag != NULL)
+				cmdq_error(item, "no such session: %s", tflag);
 			else
-				cmdq_error(cmdq, "no current session");
+				cmdq_error(item, "no current session");
 			return (CMD_RETURN_ERROR);
 		}
-		env = cmdq->state.tflag.s->environ;
+		env = target->s->environ;
 	}
 
-	if (args->argc != 0) {
-		envent = environ_find(env, args->argv[0]);
+	if (name != NULL) {
+		envent = environ_find(env, name);
 		if (envent == NULL) {
-			cmdq_error(cmdq, "unknown variable: %s", args->argv[0]);
+			cmdq_error(item, "unknown variable: %s", name);
 			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

@@ -18,112 +18,90 @@
 
 #include <sys/types.h>
 
+#include <stdlib.h>
 #include <string.h>
-#include <time.h>
 #include <unistd.h>
 
 #include "tmux.h"
 
 /*
- * Show client message log.
+ * Show message log.
  */
 
-enum cmd_retval	 cmd_show_messages_exec(struct cmd *, struct cmd_q *);
+#define SHOW_MESSAGES_TEMPLATE \
+	"#{t/p:message_time}: #{message_text}"
+
+static enum cmd_retval	cmd_show_messages_exec(struct cmd *,
+			    struct cmdq_item *);
 
 const struct cmd_entry cmd_show_messages_entry = {
 	.name = "show-messages",
 	.alias = "showmsgs",
 
-	.args = { "JTt:", 0, 0 },
+	.args = { "JTt:", 0, 0, NULL },
 	.usage = "[-JT] " CMD_TARGET_CLIENT_USAGE,
 
-	.tflag = CMD_CLIENT,
-
-	.flags = 0,
+	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG,
 	.exec = cmd_show_messages_exec
 };
 
-const struct cmd_entry cmd_server_info_entry = {
-	.name = "server-info",
-	.alias = "info",
-
-	.args = { "", 0, 0 },
-	.usage = "",
-
-	.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)
+static int
+cmd_show_messages_terminals(struct cmd *self, struct cmdq_item *item, int blank)
 {
+	struct args	*args = cmd_get_args(self);
+	struct client	*tc = cmdq_get_target_client(item);
 	struct tty_term	*term;
 	u_int		 i, n;
 
 	n = 0;
 	LIST_FOREACH(term, &tty_terms, entry) {
+		if (args_has(args, 't') && term != tc->tty.term)
+			continue;
 		if (blank) {
-			cmdq_print(cmdq, "%s", "");
+			cmdq_print(item, "%s", "");
 			blank = 0;
 		}
-		cmdq_print(cmdq, "Terminal %u: %s [references=%u, flags=0x%x]:",
-		    n, term->name, term->references, term->flags);
+		cmdq_print(item, "Terminal %u: %s for %s, flags=0x%x:", n,
+		    term->name, term->tty->client->name, 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
-cmd_show_messages_jobs(struct cmd_q *cmdq, int blank)
+static enum cmd_retval
+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 args		*args = cmd_get_args(self);
 	struct message_entry	*msg;
-	char			*tim;
+	char			*s;
 	int			 done, blank;
+	struct format_tree	*ft;
 
 	done = blank = 0;
-	if (args_has(args, 'T') || self->entry == &cmd_server_info_entry) {
-		blank = cmd_show_messages_terminals(cmdq, blank);
+	if (args_has(args, 'T')) {
+		blank = cmd_show_messages_terminals(self, item, blank);
 		done = 1;
 	}
-	if (args_has(args, 'J') || self->entry == &cmd_server_info_entry) {
-		cmd_show_messages_jobs(cmdq, blank);
+	if (args_has(args, 'J')) {
+		job_print_summary(item, blank);
 		done = 1;
 	}
 	if (done)
 		return (CMD_RETURN_NORMAL);
 
-	TAILQ_FOREACH(msg, &c->message_log, entry) {
-		tim = ctime(&msg->msg_time);
-		*strchr(tim, '\n') = '\0';
+	ft = format_create_from_target(item);
+	TAILQ_FOREACH_REVERSE(msg, &message_log, message_list, entry) {
+		format_add(ft, "message_text", "%s", msg->msg);
+		format_add(ft, "message_number", "%u", msg->msg_num);
+		format_add_tv(ft, "message_time", &msg->msg_time);
 
-		cmdq_print(cmdq, "%s %s", tim, msg->msg);
+		s = format_expand(ft, SHOW_MESSAGES_TEMPLATE);
+		cmdq_print(item, "%s", s);
+		free(s);
 	}
+	format_free(ft);
 
 	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 *,
-		    struct options *, int);
-enum cmd_retval cmd_show_options_all(struct cmd *, struct cmd_q *,
-	    	    struct options *, enum options_table_scope);
+static void		cmd_show_options_print(struct cmd *, struct cmdq_item *,
+			    struct options_entry *, int, int);
+static enum cmd_retval	cmd_show_options_all(struct cmd *, struct cmdq_item *,
+			    int, struct options *);
 
 const struct cmd_entry cmd_show_options_entry = {
 	.name = "show-options",
 	.alias = "show",
 
-	.args = { "gqst:vw", 0, 1 },
-	.usage = "[-gqsvw] [-t target-session|target-window] [option]",
+	.args = { "AgHpqst:vw", 0, 1, NULL },
+	.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
 };
 
@@ -51,147 +51,210 @@ const struct cmd_entry cmd_show_window_options_entry = {
 	.name = "show-window-options",
 	.alias = "showw",
 
-	.args = { "gvt:", 0, 1 },
+	.args = { "gvt:", 0, 1, NULL },
 	.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
-cmd_show_options_exec(struct cmd *self, struct cmd_q *cmdq)
+const struct cmd_entry cmd_show_hooks_entry = {
+	.name = "show-hooks",
+	.alias = NULL,
+
+	.args = { "gpt:w", 0, 1, NULL },
+	.usage = "[-gpw] " CMD_TARGET_PANE_USAGE " [hook]",
+
+	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
+
+	.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 winlink			*wl = cmdq->state.tflag.wl;
+	struct args			*args = cmd_get_args(self);
+	struct cmd_find_state		*target = cmdq_get_target(item);
 	struct options			*oo;
-	enum options_table_scope	 scope;
-	int				 quiet;
-	const char			*target;
+	char				*argument, *name = NULL, *cause;
+	int				 window, idx, ambiguous, parent, scope;
+	struct options_entry		*o;
 
-	if (args_has(self->args, 's')) {
-		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;
-	}
+	window = (cmd_get_entry(self) == &cmd_show_window_options_entry);
 
-	quiet = args_has(self->args, 'q');
-	if (args->argc == 0)
-		return (cmd_show_options_all(self, cmdq, oo, scope));
-	else
-		return (cmd_show_options_one(self, cmdq, oo, quiet));
-}
-
-enum cmd_retval
-cmd_show_options_one(struct cmd *self, struct cmd_q *cmdq,
-    struct options *oo, int quiet)
-{
-	struct args				*args = self->args;
-	const char				*name = args->argv[0];
-	const struct options_table_entry	*oe;
-	struct options_entry			*o;
-	const char				*optval;
-
-retry:
-	if (*name == '@') {
-		if ((o = options_find1(oo, name)) == NULL) {
-			if (quiet)
+	if (args_count(args) == 0) {
+		scope = options_scope_from_flags(args, window, target, &oo,
+		    &cause);
+		if (scope == OPTIONS_TABLE_NONE) {
+			if (args_has(args, 'q'))
 				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'))
-			cmdq_print(cmdq, "%s", o->str);
+		return (cmd_show_options_all(self, item, scope, oo));
+	}
+	argument = format_single_from_target(item, args_string(args, 0));
+
+	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_print(cmdq, "%s \"%s\"", o->name, o->str);
-		return (CMD_RETURN_NORMAL);
+			cmdq_error(item, "invalid option: %s", argument);
+		goto fail;
+	}
+	scope = options_scope_from_name(args, window, name, target, &oo,
+	    &cause);
+	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);
+	if (args_has(args, 'A') && o == NULL) {
+		o = options_get(oo, name);
+		parent = 1;
+	} else
+		parent = 0;
+	if (o != NULL)
+		cmd_show_options_print(self, item, o, idx, parent);
+	else if (*name == '@') {
+		if (args_has(args, 'q'))
+			goto out;
+		cmdq_error(item, "invalid option: %s", argument);
+		goto fail;
 	}
 
-	oe = NULL;
-	if (options_table_find(name, &oe) != 0) {
-		cmdq_error(cmdq, "ambiguous option: %s", name);
-		return (CMD_RETURN_ERROR);
-	}
-	if (oe == NULL) {
-		if (quiet)
-			return (CMD_RETURN_NORMAL);
-		cmdq_error(cmdq, "unknown option: %s", name);
-		return (CMD_RETURN_ERROR);
-	}
-	if (oe->style != NULL) {
-		name = oe->style;
-		goto retry;
-	}
-	if ((o = options_find1(oo, oe->name)) == NULL)
-		return (CMD_RETURN_NORMAL);
-	optval = options_table_print_entry(oe, o, args_has(self->args, 'v'));
-	if (args_has(self->args, 'v'))
-		cmdq_print(cmdq, "%s", optval);
-	else
-		cmdq_print(cmdq, "%s %s", oe->name, optval);
+out:
+	free(name);
+	free(argument);
 	return (CMD_RETURN_NORMAL);
+
+fail:
+	free(name);
+	free(argument);
+	return (CMD_RETURN_ERROR);
 }
 
-enum cmd_retval
-cmd_show_options_all(struct cmd *self, struct cmd_q *cmdq, struct options *oo,
-    enum options_table_scope scope)
+static void
+cmd_show_options_print(struct cmd *self, struct cmdq_item *item,
+    struct options_entry *o, int idx, int parent)
 {
+	struct args			*args = cmd_get_args(self);
+	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_is_array(o)) {
+			a = options_array_first(o);
+			if (a == NULL) {
+				if (!args_has(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_to_string(o, idx, 0);
+	if (args_has(args, 'v'))
+		cmdq_print(item, "%s", value);
+	else if (options_is_string(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)
+{
+	struct args				*args = cmd_get_args(self);
 	const struct options_table_entry	*oe;
 	struct options_entry			*o;
-	const char				*optval;
-	int					 vflag;
+	struct options_array_item		*a;
+	const char				*name;
+	u_int					 idx;
+	int					 parent;
 
-	o = options_first(oo);
-	while (o != NULL) {
-		if (*o->name == '@') {
-			if (args_has(self->args, 'v'))
-				cmdq_print(cmdq, "%s", o->str);
-			else
-				cmdq_print(cmdq, "%s \"%s\"", o->name, o->str);
+	if (cmd_get_entry(self) != &cmd_show_hooks_entry) {
+		o = options_first(oo);
+		while (o != NULL) {
+			if (options_table_entry(o) == NULL)
+				cmd_show_options_print(self, item, o, -1, 0);
+			o = options_next(o);
 		}
-		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 ((cmd_get_entry(self) != &cmd_show_hooks_entry &&
+		    !args_has(args, 'H') &&
+		    (oe->flags & OPTIONS_TABLE_IS_HOOK)) ||
+		    (cmd_get_entry(self) == &cmd_show_hooks_entry &&
+		    (~oe->flags & OPTIONS_TABLE_IS_HOOK)))
+			continue;
+
+		o = options_get_only(oo, oe->name);
+		if (o == NULL) {
+			if (!args_has(args, 'A'))
+				continue;
+			o = options_get(oo, oe->name);
+			if (o == NULL)
+				continue;
+			parent = 1;
+		} else
+			parent = 0;
+
+		if (!options_is_array(o))
+			cmd_show_options_print(self, item, o, -1, parent);
+		else if ((a = options_array_first(o)) == NULL) {
+			if (!args_has(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-show-prompt-history.c

@@ -0,0 +1,108 @@
+/* $OpenBSD$ */
+
+/*
+ * Copyright (c) 2021 Anindya Mukherjee <anindya49@hotmail.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 "tmux.h"
+
+#include <stdlib.h>
+
+/*
+ * Show or clear prompt history.
+ */
+
+static enum cmd_retval	cmd_show_prompt_history_exec(struct cmd *,
+			    struct cmdq_item *);
+
+const struct cmd_entry cmd_show_prompt_history_entry = {
+	.name = "show-prompt-history",
+	.alias = "showphist",
+
+	.args = { "T:", 0, 0, NULL },
+	.usage = "[-T prompt-type]",
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_show_prompt_history_exec
+};
+
+const struct cmd_entry cmd_clear_prompt_history_entry = {
+	.name = "clear-prompt-history",
+	.alias = "clearphist",
+
+	.args = { "T:", 0, 0, NULL },
+	.usage = "[-T prompt-type]",
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_show_prompt_history_exec
+};
+
+static enum cmd_retval
+cmd_show_prompt_history_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		*args = cmd_get_args(self);
+	const char		*typestr = args_get(args, 'T');
+	enum prompt_type	 type;
+	u_int			 tidx, hidx;
+
+	if (cmd_get_entry(self) == &cmd_clear_prompt_history_entry) {
+		if (typestr == NULL) {
+			for (tidx = 0; tidx < PROMPT_NTYPES; tidx++) {
+				free(status_prompt_hlist[tidx]);
+				status_prompt_hlist[tidx] = NULL;
+				status_prompt_hsize[tidx] = 0;
+			}
+		} else {
+			type = status_prompt_type(typestr);
+			if (type == PROMPT_TYPE_INVALID) {
+				cmdq_error(item, "invalid type: %s", typestr);
+				return (CMD_RETURN_ERROR);
+			}
+			free(status_prompt_hlist[type]);
+			status_prompt_hlist[type] = NULL;
+			status_prompt_hsize[type] = 0;
+		}
+
+		return (CMD_RETURN_NORMAL);
+	}
+
+	if (typestr == NULL) {
+		for (tidx = 0; tidx < PROMPT_NTYPES; tidx++) {
+			cmdq_print(item, "History for %s:\n",
+			    status_prompt_type_string(tidx));
+			for (hidx = 0; hidx < status_prompt_hsize[tidx];
+			    hidx++) {
+				cmdq_print(item, "%d: %s", hidx + 1,
+				    status_prompt_hlist[tidx][hidx]);
+			}
+			cmdq_print(item, "%s", "");
+		}
+	} else {
+		type = status_prompt_type(typestr);
+		if (type == PROMPT_TYPE_INVALID) {
+			cmdq_error(item, "invalid type: %s", typestr);
+			return (CMD_RETURN_ERROR);
+		}
+		cmdq_print(item, "History for %s:\n",
+		    status_prompt_type_string(type));
+		for (hidx = 0; hidx < status_prompt_hsize[type]; hidx++) {
+			cmdq_print(item, "%d: %s", hidx + 1,
+			    status_prompt_hlist[type][hidx]);
+		}
+		cmdq_print(item, "%s", "");
+	}
+
+	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,73 +29,218 @@
  * Sources a configuration file.
  */
 
-enum cmd_retval	cmd_source_file_exec(struct cmd *, struct cmd_q *);
+#define CMD_SOURCE_FILE_DEPTH_LIMIT 50
+static u_int cmd_source_file_depth;
 
-void		cmd_source_file_done(struct cmd_q *);
+static enum cmd_retval	cmd_source_file_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_source_file_entry = {
 	.name = "source-file",
 	.alias = "source",
 
-	.args = { "", 1, 1 },
-	.usage = "path",
+	.args = { "t:Fnqv", 1, -1, NULL },
+	.usage = "[-Fnqv] " CMD_TARGET_PANE_USAGE " path ...",
+
+	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
 
 	.flags = 0,
 	.exec = cmd_source_file_exec
 };
 
-enum cmd_retval
-cmd_source_file_exec(struct cmd *self, struct cmd_q *cmdq)
+struct cmd_source_file_data {
+	struct cmdq_item	 *item;
+	int			  flags;
+
+	struct cmdq_item	 *after;
+	enum cmd_retval		  retval;
+
+	u_int			  current;
+	char			**files;
+	u_int			  nfiles;
+};
+
+static enum cmd_retval
+cmd_source_file_complete_cb(struct cmdq_item *item, __unused void *data)
 {
-	struct args	*args = self->args;
-	struct cmd_q	*cmdq1;
-	char		*cause;
+	struct client	*c = cmdq_get_client(item);
 
-	cmdq1 = cmdq_new(cmdq->client);
-	cmdq1->emptyfn = cmd_source_file_done;
-	cmdq1->data = cmdq;
-
-	switch (load_cfg(args->argv[0], cmdq1, &cause)) {
-	case -1:
-		if (cfg_references == 0) {
-			cmdq_free(cmdq1);
-			cmdq_error(cmdq, "%s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-		cfg_add_cause("%s", cause);
-		free(cause);
-		/* FALLTHROUGH */
-	case 0:
-		if (cfg_references == 0)
-			cfg_print_causes(cmdq);
-		cmdq_free(cmdq1);
-		return (CMD_RETURN_NORMAL);
+	if (c == NULL) {
+		cmd_source_file_depth--;
+		log_debug("%s: depth now %u", __func__, cmd_source_file_depth);
+	} else {
+		c->source_file_depth--;
+		log_debug("%s: depth now %u", __func__, c->source_file_depth);
 	}
 
-	cmdq->references++;
-	cfg_references++;
-
-	cmdq_continue(cmdq1);
-	return (CMD_RETURN_WAIT);
+	cfg_print_causes(item);
+	return (CMD_RETURN_NORMAL);
 }
 
-void
-cmd_source_file_done(struct cmd_q *cmdq1)
+static void
+cmd_source_file_complete(struct client *c, struct cmd_source_file_data *cdata)
 {
-	struct cmd_q	*cmdq = cmdq1->data;
+	struct cmdq_item	*new_item;
+	u_int			 i;
 
-	if (cmdq1->client_exit >= 0)
-		cmdq->client_exit = cmdq1->client_exit;
+	if (cfg_finished) {
+		if (cdata->retval == CMD_RETURN_ERROR &&
+		    c != NULL &&
+		    c->session == NULL)
+			c->retval = 1;
+		new_item = cmdq_get_callback(cmd_source_file_complete_cb, NULL);
+		cmdq_insert_after(cdata->after, new_item);
+	}
 
-	cmdq_free(cmdq1);
+	for (i = 0; i < cdata->nfiles; i++)
+		free(cdata->files[i]);
+	free(cdata->files);
+	free(cdata);
+}
 
-	cfg_references--;
+static void
+cmd_source_file_done(struct client *c, const char *path, int error,
+    int closed, struct evbuffer *buffer, void *data)
+{
+	struct cmd_source_file_data	*cdata = data;
+	struct cmdq_item		*item = cdata->item;
+	void				*bdata = EVBUFFER_DATA(buffer);
+	size_t				 bsize = EVBUFFER_LENGTH(buffer);
+	u_int				 n;
+	struct cmdq_item		*new_item;
+	struct cmd_find_state		*target = cmdq_get_target(item);
 
-	if (cmdq_free(cmdq))
+	if (!closed)
 		return;
 
-	if (cfg_references == 0)
-		cfg_print_causes(cmdq);
-	cmdq_continue(cmdq);
+	if (error != 0)
+		cmdq_error(item, "%s: %s", path, strerror(error));
+	else if (bsize != 0) {
+		if (load_cfg_from_buffer(bdata, bsize, path, c, cdata->after,
+		    target, cdata->flags, &new_item) < 0)
+			cdata->retval = CMD_RETURN_ERROR;
+		else if (new_item != NULL)
+			cdata->after = new_item;
+	}
+
+	n = ++cdata->current;
+	if (n < cdata->nfiles)
+		file_read(c, cdata->files[n], cmd_source_file_done, cdata);
+	else {
+		cmd_source_file_complete(c, cdata);
+		cmdq_continue(item);
+	}
+}
+
+static void
+cmd_source_file_add(struct cmd_source_file_data *cdata, const char *path)
+{
+	char	resolved[PATH_MAX];
+
+	if (realpath(path, resolved) == NULL) {
+		log_debug("%s: realpath(\"%s\") failed: %s", __func__,
+			path, strerror(errno));
+	} else
+		path = resolved;
+
+	log_debug("%s: %s", __func__, path);
+
+	cdata->files = xreallocarray(cdata->files, cdata->nfiles + 1,
+	    sizeof *cdata->files);
+	cdata->files[cdata->nfiles++] = xstrdup(path);
+}
+
+static enum cmd_retval
+cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args			*args = cmd_get_args(self);
+	struct cmd_source_file_data	*cdata;
+	struct client			*c = cmdq_get_client(item);
+	enum cmd_retval			 retval = CMD_RETURN_NORMAL;
+	char				*pattern, *cwd, *expanded = NULL;
+	const char			*path, *error;
+	glob_t				 g;
+	int				 result;
+	u_int				 i, j;
+
+	if (c == NULL) {
+		if (cmd_source_file_depth >= CMD_SOURCE_FILE_DEPTH_LIMIT) {
+			cmdq_error(item, "too many nested files");
+			return (CMD_RETURN_ERROR);
+		}
+		cmd_source_file_depth++;
+		log_debug("%s: depth now %u", __func__, cmd_source_file_depth);
+	} else {
+		if (c->source_file_depth >= CMD_SOURCE_FILE_DEPTH_LIMIT) {
+			cmdq_error(item, "too many nested files");
+			return (CMD_RETURN_ERROR);
+		}
+		c->source_file_depth++;
+		log_debug("%s: depth now %u", __func__, c->source_file_depth);
+	}
+
+	cdata = xcalloc(1, sizeof *cdata);
+	cdata->item = item;
+
+	if (args_has(args, 'q'))
+		cdata->flags |= CMD_PARSE_QUIET;
+	if (args_has(args, 'n'))
+		cdata->flags |= CMD_PARSE_PARSEONLY;
+	if (args_has(args, 'v'))
+		cdata->flags |= CMD_PARSE_VERBOSE;
+
+	utf8_stravis(&cwd, server_client_get_cwd(c, NULL), VIS_GLOB);
+
+	for (i = 0; i < args_count(args); i++) {
+		path = args_string(args, i);
+		if (args_has(args, 'F')) {
+			free(expanded);
+			expanded = format_single_from_target(item, path);
+			path = expanded;
+		}
+		if (strcmp(path, "-") == 0) {
+			cmd_source_file_add(cdata, "-");
+			continue;
+		}
+
+		if (*path == '/')
+			pattern = xstrdup(path);
+		else
+			xasprintf(&pattern, "%s/%s", cwd, path);
+		log_debug("%s: %s", __func__, pattern);
+
+		if ((result = glob(pattern, 0, NULL, &g)) != 0) {
+			if (result != GLOB_NOMATCH ||
+			    (~cdata->flags & CMD_PARSE_QUIET)) {
+				if (result == GLOB_NOMATCH)
+					error = strerror(ENOENT);
+				else if (result == GLOB_NOSPACE)
+					error = strerror(ENOMEM);
+				else
+					error = strerror(EINVAL);
+				cmdq_error(item, "%s: %s", path, error);
+				retval = CMD_RETURN_ERROR;
+			}
+			globfree(&g);
+			free(pattern);
+			continue;
+		}
+		free(pattern);
+
+		for (j = 0; j < g.gl_pathc; j++)
+			cmd_source_file_add(cdata, g.gl_pathv[j]);
+		globfree(&g);
+	}
+	free(expanded);
+
+	cdata->after = item;
+	cdata->retval = retval;
+
+	if (cdata->nfiles != 0) {
+		file_read(c, cdata->files[0], cmd_source_file_done, cdata);
+		retval = CMD_RETURN_WAIT;
+	} else
+		cmd_source_file_complete(c, cdata);
+
+	free(cwd);
+	return (retval);
 }

cmd-split-window.c

@@ -32,164 +32,168 @@
 
 #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:dF:l:hp:Pt:v", 0, -1 },
-	.usage = "[-bdhvP] [-c start-directory] [-F format] "
-		 "[-p percentage|-l size] " CMD_TARGET_PANE_USAGE " [command]",
+	.args = { "bc:de:fF:hIl:p:Pt:vZ", 0, -1, NULL },
+	.usage = "[-bdefhIPvZ] [-c start-directory] [-e environment] "
+		 "[-F format] [-l size] " CMD_TARGET_PANE_USAGE
+		 " [shell-command [argument ...]]",
 
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_split_window_exec
 };
 
-enum cmd_retval
-cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	struct session		*s = cmdq->state.tflag.s;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct spawn_context	 sc = { 0 };
+	struct client		*tc = cmdq_get_target_client(item);
+	struct session		*s = target->s;
+	struct winlink		*wl = target->wl;
 	struct window		*w = wl->window;
-	struct window_pane	*wp = cmdq->state.tflag.wp, *new_wp = NULL;
-	struct environ		*env;
-	const char		*cmd, *path, *shell, *template, *cwd, *to_free;
-	char		       **argv, *cause, *new_cause, *cp;
-	u_int			 hlimit;
-	int			 argc, size, percentage;
+	struct window_pane	*wp = target->wp, *new_wp;
 	enum layout_type	 type;
 	struct layout_cell	*lc;
-	struct format_tree	*ft;
-	struct environ_entry	*envent;
-
-	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;
+	struct cmd_find_state	 fs;
+	int			 size, flags, input;
+	const char		*template;
+	char			*cause = NULL, *cp;
+	struct args_value	*av;
+	u_int			 count = args_count(args), curval = 0;
 
 	type = LAYOUT_TOPBOTTOM;
 	if (args_has(args, 'h'))
 		type = LAYOUT_LEFTRIGHT;
 
+	/* If the 'p' flag is dropped then this bit can be moved into 'l'. */
+	if (args_has(args, 'l') || args_has(args, 'p')) {
+		if (args_has(args, 'f')) {
+			if (type == LAYOUT_TOPBOTTOM)
+				curval = w->sy;
+			else
+				curval = w->sx;
+		} else {
+			if (type == LAYOUT_TOPBOTTOM)
+				curval = wp->sy;
+			else
+				curval = wp->sx;
+		}
+	}
+
 	size = -1;
 	if (args_has(args, 'l')) {
-		size = args_strtonum(args, 'l', 0, INT_MAX, &cause);
-		if (cause != NULL) {
-			xasprintf(&new_cause, "size %s", cause);
-			free(cause);
-			cause = new_cause;
-			goto error;
-		}
+		size = args_percentage_and_expand(args, 'l', 0, INT_MAX, curval,
+		    item, &cause);
 	} else if (args_has(args, 'p')) {
-		percentage = args_strtonum(args, 'p', 0, INT_MAX, &cause);
-		if (cause != NULL) {
-			xasprintf(&new_cause, "percentage %s", cause);
-			free(cause);
-			cause = new_cause;
-			goto error;
-		}
-		if (type == LAYOUT_TOPBOTTOM)
-			size = (wp->sy * percentage) / 100;
-		else
-			size = (wp->sx * percentage) / 100;
+		size = args_strtonum_and_expand(args, 'p', 0, 100, item,
+		    &cause);
+		if (cause == NULL)
+			size = curval * size / 100;
+	}
+	if (cause != NULL) {
+		cmdq_error(item, "size %s", cause);
+		free(cause);
+		return (CMD_RETURN_ERROR);
 	}
-	hlimit = options_get_number(s->options, "history-limit");
 
-	shell = options_get_string(s->options, "default-shell");
-	if (*shell == '\0' || areshell(shell))
-		shell = _PATH_BSHELL;
+	window_push_zoom(wp->window, 1, args_has(args, 'Z'));
+	input = (args_has(args, 'I') && count == 0);
 
-	lc = layout_split_pane(wp, type, size, args_has(args, 'b'));
+	flags = 0;
+	if (args_has(args, 'b'))
+		flags |= SPAWN_BEFORE;
+	if (args_has(args, 'f'))
+		flags |= SPAWN_FULLSIZE;
+	if (input || (count == 1 && *args_string(args, 0) == '\0'))
+		flags |= SPAWN_EMPTY;
+
+	lc = layout_split_pane(wp, type, size, flags);
 	if (lc == NULL) {
-		cause = xstrdup("pane too small");
-		goto error;
+		cmdq_error(item, "no space for new pane");
+		return (CMD_RETURN_ERROR);
 	}
-	new_wp = window_add_pane(w, 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;
+	sc.item = item;
+	sc.s = s;
+	sc.wl = wl;
 
-	if (window_pane_spawn(new_wp, argc, argv, path, shell, cwd, env,
-	    s->tio, &cause) != 0)
-		goto error;
+	sc.wp0 = wp;
+	sc.lc = lc;
 
-	server_redraw_window(w);
+	args_to_vector(args, &sc.argc, &sc.argv);
+	sc.environ = environ_create();
 
-	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);
+	av = args_first_value(args, 'e');
+	while (av != NULL) {
+		environ_put(sc.environ, av->string, 0);
+		av = args_next_value(av);
+	}
 
-	environ_free(env);
+	sc.idx = -1;
+	sc.cwd = args_get(args, 'c');
+
+	sc.flags = flags;
+	if (args_has(args, 'd'))
+		sc.flags |= SPAWN_DETACHED;
+	if (args_has(args, 'Z'))
+		sc.flags |= SPAWN_ZOOM;
+
+	if ((new_wp = spawn_pane(&sc, &cause)) == NULL) {
+		cmdq_error(item, "create pane failed: %s", cause);
+		free(cause);
+		if (sc.argv != NULL)
+			cmd_free_argv(sc.argc, sc.argv);
+		environ_free(sc.environ);
+		return (CMD_RETURN_ERROR);
+	}
+	if (input) {
+		switch (window_pane_start_input(new_wp, item, &cause)) {
+		case -1:
+			server_client_remove_pane(new_wp);
+			layout_close_pane(new_wp);
+			window_remove_pane(wp->window, new_wp);
+			cmdq_error(item, "%s", cause);
+			free(cause);
+			if (sc.argv != NULL)
+				cmd_free_argv(sc.argc, sc.argv);
+			environ_free(sc.environ);
+			return (CMD_RETURN_ERROR);
+		case 1:
+			input = 0;
+			break;
+		}
+	}
+	if (!args_has(args, 'd'))
+		cmd_find_from_winlink_pane(current, wl, new_wp, 0);
+	window_pop_zoom(wp->window);
+	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;
-
-		ft = format_create(cmdq, 0);
-		format_defaults(ft, cmdq->state.c, s, wl, new_wp);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
+		cp = format_single(item, template, tc, s, wl, new_wp);
+		cmdq_print(item, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}
-	notify_window_layout_changed(w);
 
-	if (to_free != NULL)
-		free((void *)to_free);
+	cmd_find_from_winlink_pane(&fs, wl, new_wp, 0);
+	cmdq_insert_hook(s, item, &fs, "after-split-window");
+
+	if (sc.argv != NULL)
+		cmd_free_argv(sc.argc, sc.argv);
+	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,51 +26,61 @@
  * 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",
 	.alias = "swapp",
 
-	.args = { "dDs:t:U", 0, 0 },
-	.usage = "[-dDU] " CMD_SRCDST_PANE_USAGE,
+	.args = { "dDs:t:UZ", 0, 0, NULL },
+	.usage = "[-dDUZ] " CMD_SRCDST_PANE_USAGE,
 
-	.sflag = CMD_PANE_MARKED,
-	.tflag = CMD_PANE,
+	.source = { 's', CMD_FIND_PANE, CMD_FIND_DEFAULT_MARKED },
+	.target = { 't', CMD_FIND_PANE, 0 },
 
 	.flags = 0,
 	.exec = cmd_swap_pane_exec
 };
 
-enum cmd_retval
-cmd_swap_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_swap_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*source = cmdq_get_source(item);
+	struct cmd_find_state	*target = cmdq_get_target(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_wp = cmdq->state.tflag.wp;
-	src_w = cmdq->state.sflag.wl->window;
-	src_wp = cmdq->state.sflag.wp;
-	server_unzoom_window(dst_w);
+	dst_w = target->wl->window;
+	dst_wp = target->wp;
+	src_w = source->wl->window;
+	src_wp = source->wp;
 
-	if (args_has(self->args, 'D')) {
+	if (window_push_zoom(dst_w, 0, args_has(args, 'Z')))
+		server_redraw_window(dst_w);
+
+	if (args_has(args, 'D')) {
 		src_w = dst_w;
 		src_wp = TAILQ_NEXT(dst_wp, entry);
 		if (src_wp == NULL)
 			src_wp = TAILQ_FIRST(&dst_w->panes);
-	} else if (args_has(self->args, 'U')) {
+	} else if (args_has(args, 'U')) {
 		src_w = dst_w;
 		src_wp = TAILQ_PREV(dst_wp, window_panes, entry);
 		if (src_wp == NULL)
 			src_wp = TAILQ_LAST(&dst_w->panes, window_panes);
 	}
-	server_unzoom_window(src_w);
+
+	if (src_w != dst_w && window_push_zoom(src_w, 0, args_has(args, 'Z')))
+		server_redraw_window(src_w);
 
 	if (src_wp == dst_wp)
-		return (CMD_RETURN_NORMAL);
+		goto out;
+
+	server_client_remove_pane(src_wp);
+	server_client_remove_pane(dst_wp);
 
 	tmp_wp = TAILQ_PREV(dst_wp, window_panes, entry);
 	TAILQ_REMOVE(&dst_w->panes, dst_wp, entry);
@@ -90,7 +100,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|PANE_THEMECHANGED);
 	dst_wp->window = src_w;
+	options_set_parent(dst_wp->options, src_w->options);
+	dst_wp->flags |= (PANE_STYLECHANGED|PANE_THEMECHANGED);
 
 	sx = src_wp->sx; sy = src_wp->sy;
 	xoff = src_wp->xoff; yoff = src_wp->yoff;
@@ -99,30 +113,39 @@ cmd_swap_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	dst_wp->xoff = xoff; dst_wp->yoff = yoff;
 	window_pane_resize(dst_wp, sx, sy);
 
-	if (!args_has(self->args, 'd')) {
+	if (!args_has(args, 'd')) {
 		if (src_w != dst_w) {
-			window_set_active_pane(src_w, dst_wp);
-			window_set_active_pane(dst_w, src_wp);
+			window_set_active_pane(src_w, dst_wp, 1);
+			window_set_active_pane(dst_w, src_wp, 1);
 		} else {
 			tmp_wp = dst_wp;
-			if (!window_pane_visible(tmp_wp))
-				tmp_wp = src_wp;
-			window_set_active_pane(src_w, tmp_wp);
+			window_set_active_pane(src_w, tmp_wp, 1);
 		}
 	} 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)
-			src_w->last = NULL;
-		if (dst_w->last == dst_wp)
-			dst_w->last = NULL;
+		window_pane_stack_remove(&src_w->last_panes, src_wp);
+		window_pane_stack_remove(&dst_w->last_panes, dst_wp);
+		colour_palette_from_option(&src_wp->palette, src_wp->options);
+		colour_palette_from_option(&dst_wp->palette, dst_wp->options);
+		layout_fix_panes(src_w, NULL);
+		server_redraw_window(src_w);
 	}
-	server_redraw_window(src_w);
+	layout_fix_panes(dst_w, NULL);
 	server_redraw_window(dst_w);
 
+	notify_window("window-layout-changed", src_w);
+	if (src_w != dst_w)
+		notify_window("window-layout-changed", dst_w);
+
+out:
+	if (window_pop_zoom(src_w))
+		server_redraw_window(src_w);
+	if (src_w != dst_w && window_pop_zoom(dst_w))
+		server_redraw_window(dst_w);
 	return (CMD_RETURN_NORMAL);
 }

cmd-swap-window.c

@@ -26,52 +26,58 @@
  * 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",
 	.alias = "swapw",
 
-	.args = { "ds:t:", 0, 0 },
+	.args = { "ds:t:", 0, 0, NULL },
 	.usage = "[-d] " CMD_SRCDST_WINDOW_USAGE,
 
-	.sflag = CMD_WINDOW_MARKED,
-	.tflag = CMD_WINDOW,
+	.source = { 's', CMD_FIND_WINDOW, CMD_FIND_DEFAULT_MARKED },
+	.target = { 't', CMD_FIND_WINDOW, 0 },
 
 	.flags = 0,
 	.exec = cmd_swap_window_exec
 };
 
-enum cmd_retval
-cmd_swap_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_swap_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct session		*src, *dst;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*source = cmdq_get_source(item);
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct session		*src = source->s, *dst = target->s;
 	struct session_group	*sg_src, *sg_dst;
-	struct winlink		*wl_src, *wl_dst;
-	struct window		*w;
+	struct winlink		*wl_src = source->wl, *wl_dst = target->wl;
+	struct window		*w_src, *w_dst;
 
-	wl_src = cmdq->state.sflag.wl;
-	src = cmdq->state.sflag.s;
-	sg_src = session_group_find(src);
+	sg_src = session_group_contains(src);
+	sg_dst = session_group_contains(dst);
 
-	wl_dst = cmdq->state.tflag.wl;
-	dst = cmdq->state.tflag.s;
-	sg_dst = session_group_find(dst);
-
-	if (src != dst && sg_src != NULL && sg_dst != NULL &&
+	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;
-	wl_dst->window = wl_src->window;
-	wl_src->window = w;
+	w_dst = wl_dst->window;
+	TAILQ_REMOVE(&w_dst->winlinks, wl_dst, wentry);
+	w_src = wl_src->window;
+	TAILQ_REMOVE(&w_src->winlinks, wl_src, wentry);
 
-	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(args, 'd')) {
 		session_select(dst, wl_dst->idx);
 		if (src != dst)
 			session_select(src, wl_src->idx);

cmd-switch-client.c

@@ -27,98 +27,116 @@
  * 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",
 	.alias = "switchc",
 
-	.args = { "lc:Enpt:rT:", 0, 0 },
-	.usage = "[-Elnpr] [-c target-client] [-t target-session] "
+	.args = { "lc:EFnpt:rT:Z", 0, 0, NULL },
+	.usage = "[-ElnprZ] [-c target-client] [-t target-session] "
 		 "[-T key-table]",
 
-	.cflag = CMD_CLIENT,
-	.tflag = CMD_SESSION_WITHPANE,
+	/* -t is special */
 
-	.flags = CMD_READONLY,
+	.flags = CMD_READONLY|CMD_CLIENT_CFLAG,
 	.exec = cmd_switch_client_exec
 };
 
-enum cmd_retval
-cmd_switch_client_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = self->args;
-	struct cmd_state	*state = &cmdq->state;
-	struct client		*c = state->c;
-	struct session		*s = cmdq->state.tflag.s;
+	struct args		*args = cmd_get_args(self);
+	struct cmd_find_state	*current = cmdq_get_current(item);
+	struct cmd_find_state	 target;
+	const char		*tflag = args_get(args, 't');
+	enum cmd_find_type	 type;
+	int			 flags;
+	struct client		*tc = cmdq_get_target_client(item);
+	struct session		*s;
+	struct winlink		*wl;
+	struct window		*w;
 	struct window_pane	*wp;
-	const char		*tablename, *update;
+	const char		*tablename;
 	struct key_table	*table;
 
-	if (args_has(args, 'r'))
-		c->flags ^= CLIENT_READONLY;
+	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(&target, item, tflag, type, flags) != 0)
+		return (CMD_RETURN_ERROR);
+	s = target.s;
+	wl = target.wl;
+	wp = target.wp;
+
+	if (args_has(args, 'r')) {
+		if (tc->flags & CLIENT_READONLY)
+			tc->flags &= ~(CLIENT_READONLY|CLIENT_IGNORESIZE);
+		else
+			tc->flags |= (CLIENT_READONLY|CLIENT_IGNORESIZE);
+	}
 
 	tablename = args_get(args, 'T');
 	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++;
-		key_bindings_unref_table(c->keytable);
-		c->keytable = table;
+		key_bindings_unref_table(tc->keytable);
+		tc->keytable = table;
 		return (CMD_RETURN_NORMAL);
 	}
 
 	if (args_has(args, 'n')) {
-		if ((s = session_next_session(c->session)) == NULL) {
-			cmdq_error(cmdq, "can't find next session");
+		if ((s = session_next_session(tc->session)) == NULL) {
+			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");
+		if ((s = session_previous_session(tc->session)) == NULL) {
+			cmdq_error(item, "can't find previous session");
 			return (CMD_RETURN_ERROR);
 		}
 	} else if (args_has(args, 'l')) {
-		if (c->last_session != NULL && session_alive(c->last_session))
-			s = c->last_session;
+		if (tc->last_session != NULL && session_alive(tc->last_session))
+			s = tc->last_session;
 		else
 			s = NULL;
 		if (s == NULL) {
-			cmdq_error(cmdq, "can't find last session");
+			cmdq_error(item, "can't find last session");
 			return (CMD_RETURN_ERROR);
 		}
 	} else {
-		if (cmdq->client == NULL)
+		if (cmdq_get_client(item) == NULL)
 			return (CMD_RETURN_NORMAL);
-		if (state->tflag.wl != NULL) {
-			wp = state->tflag.wp;
-			if (wp != NULL)
-				window_set_active_pane(wp->window, wp);
-			session_set_current(s, state->tflag.wl);
+		if (wl != NULL && wp != NULL && wp != wl->window->active) {
+			w = wl->window;
+			if (window_push_zoom(w, 0, args_has(args, 'Z')))
+				server_redraw_window(w);
+			window_redraw_active_switch(w, wp);
+			window_set_active_pane(w, wp, 1);
+			if (window_pop_zoom(w))
+				server_redraw_window(w);
+		}
+		if (wl != NULL) {
+			session_set_current(s, wl);
+			cmd_find_from_session(current, s, 0);
 		}
 	}
 
-	if (c != NULL && !args_has(args, 'E')) {
-		update = options_get_string(s->options, "update-environment");
-		environ_update(update, c->environ, s->environ);
-	}
+	if (!args_has(args, 'E'))
+		environ_update(s->options, tc->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);
-	status_timer_start(c);
-	session_update_activity(s, NULL);
-	gettimeofday(&s->last_attached_time, NULL);
-
-	recalculate_sizes();
-	server_check_unattached();
-	server_redraw_client(c);
-	s->curw->flags &= ~WINLINK_ALERTFLAGS;
-	alerts_check_session(s);
+	server_client_set_session(tc, s);
+	if (~cmdq_get_flags(item) & CMDQ_STATE_REPEAT)
+		server_client_set_key_table(tc, NULL);
 
 	return (CMD_RETURN_NORMAL);
 }

cmd-unbind-key.c

@@ -26,68 +26,73 @@
  * Unbind key from command.
  */
 
-enum cmd_retval	cmd_unbind_key_exec(struct cmd *, struct cmd_q *);
-enum cmd_retval	cmd_unbind_key_mode_table(struct cmd *, struct cmd_q *,
-		    key_code);
+static enum cmd_retval	cmd_unbind_key_exec(struct cmd *, struct cmdq_item *);
 
 const struct cmd_entry cmd_unbind_key_entry = {
 	.name = "unbind-key",
 	.alias = "unbind",
 
-	.args = { "acnt:T:", 0, 1 },
-	.usage = "[-acn] [-t mode-table] [-T key-table] key",
+	.args = { "anqT:", 0, 1, NULL },
+	.usage = "[-anq] [-T key-table] key",
 
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_unbind_key_exec
 };
 
-enum cmd_retval
-cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_unbind_key_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
+	struct args	*args = cmd_get_args(self);
 	key_code	 key;
-	const char	*tablename;
+	const char	*tablename, *keystr = args_string(args, 0);
+	int		 quiet = args_has(args, 'q');
 
-	if (!args_has(args, 'a')) {
-		if (args->argc != 1) {
-			cmdq_error(cmdq, "missing key");
+	if (args_has(args, 'a')) {
+		if (keystr != NULL) {
+			if (!quiet)
+				cmdq_error(item, "key given with -a");
 			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]);
-			return (CMD_RETURN_ERROR);
-		}
-	} else {
-		if (args->argc != 0) {
-			cmdq_error(cmdq, "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) {
-			key_bindings_remove_table("root");
-			key_bindings_remove_table("prefix");
-			return (CMD_RETURN_NORMAL);
+			if (args_has(args, 'n'))
+				tablename = "root";
+			else
+				tablename = "prefix";
 		}
 		if (key_bindings_get_table(tablename, 0) == NULL) {
-			cmdq_error(cmdq, "table %s doesn't exist", tablename);
+			if (!quiet) {
+				cmdq_error(item, "table %s doesn't exist" ,
+				    tablename);
+			}
 			return (CMD_RETURN_ERROR);
 		}
+
 		key_bindings_remove_table(tablename);
 		return (CMD_RETURN_NORMAL);
 	}
 
+	if (keystr == NULL) {
+		if (!quiet)
+			cmdq_error(item, "missing key");
+		return (CMD_RETURN_ERROR);
+	}
+
+	key = key_string_lookup_string(keystr);
+	if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
+		if (!quiet)
+			cmdq_error(item, "unknown key: %s", keystr);
+		return (CMD_RETURN_ERROR);
+	}
+
 	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);
+			if (!quiet) {
+				cmdq_error(item, "table %s doesn't exist" ,
+				    tablename);
+			}
 			return (CMD_RETURN_ERROR);
 		}
 	} else if (args_has(args, 'n'))
@@ -97,35 +102,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,55 +28,59 @@
  * 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",
 	.alias = "wait",
 
-	.args = { "LSU", 1, 1 },
+	.args = { "LSU", 1, 1, NULL },
 	.usage = "[-L|-S|-U] channel",
 
 	.flags = 0,
 	.exec = cmd_wait_for_exec
 };
 
+struct wait_item {
+	struct cmdq_item	*item;
+	TAILQ_ENTRY(wait_item)	 entry;
+};
+
 struct wait_channel {
 	const char	       *name;
 	int			locked;
 	int			woken;
 
-	TAILQ_HEAD(, cmd_q)	waiters;
-	TAILQ_HEAD(, cmd_q)	lockers;
+	TAILQ_HEAD(, wait_item)	waiters;
+	TAILQ_HEAD(, wait_item)	lockers;
 
 	RB_ENTRY(wait_channel)	entry;
 };
 RB_HEAD(wait_channels, wait_channel);
-struct wait_channels wait_channels = RB_INITIALIZER(wait_channels);
+static struct wait_channels wait_channels = RB_INITIALIZER(wait_channels);
 
-int	wait_channel_cmp(struct wait_channel *, struct wait_channel *);
-RB_PROTOTYPE(wait_channels, wait_channel, entry, wait_channel_cmp);
-RB_GENERATE(wait_channels, wait_channel, entry, wait_channel_cmp);
+static int wait_channel_cmp(struct wait_channel *, struct wait_channel *);
+RB_GENERATE_STATIC(wait_channels, wait_channel, entry, wait_channel_cmp);
 
-int
+static int
 wait_channel_cmp(struct wait_channel *wc1, struct wait_channel *wc2)
 {
 	return (strcmp(wc1->name, wc2->name));
 }
 
-enum cmd_retval	cmd_wait_for_signal(struct cmd_q *, const char *,
-		    struct wait_channel *);
-enum cmd_retval	cmd_wait_for_wait(struct cmd_q *, const char *,
-		    struct wait_channel *);
-enum cmd_retval	cmd_wait_for_lock(struct cmd_q *, const char *,
-		    struct wait_channel *);
-enum cmd_retval	cmd_wait_for_unlock(struct cmd_q *, const char *,
-		    struct wait_channel *);
+static enum cmd_retval	cmd_wait_for_signal(struct cmdq_item *, const char *,
+			    struct wait_channel *);
+static enum cmd_retval	cmd_wait_for_wait(struct cmdq_item *, const char *,
+			    struct wait_channel *);
+static enum cmd_retval	cmd_wait_for_lock(struct cmdq_item *, const char *,
+			    struct wait_channel *);
+static enum cmd_retval	cmd_wait_for_unlock(struct cmdq_item *, const char *,
+			    struct wait_channel *);
 
-struct wait_channel	*cmd_wait_for_add(const char *);
-void			 cmd_wait_for_remove(struct wait_channel *wc);
+static struct wait_channel	*cmd_wait_for_add(const char *);
+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,30 +117,30 @@ cmd_wait_for_remove(struct wait_channel *wc)
 	free(wc);
 }
 
-enum cmd_retval
-cmd_wait_for_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_wait_for_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args     	*args = self->args;
-	const char		*name = args->argv[0];
-	struct wait_channel	*wc, wc0;
+	struct args     	*args = cmd_get_args(self);
+	const char		*name = args_string(args, 0);
+	struct wait_channel	*wc, find;
 
-	wc0.name = name;
-	wc = RB_FIND(wait_channels, &wait_channels, &wc0);
+	find.name = name;
+	wc = RB_FIND(wait_channels, &wait_channels, &find);
 
 	if (args_has(args, 'S'))
-		return (cmd_wait_for_signal(cmdq, name, wc));
+		return (cmd_wait_for_signal(item, name, wc));
 	if (args_has(args, 'L'))
-		return (cmd_wait_for_lock(cmdq, name, wc));
+		return (cmd_wait_for_lock(item, name, wc));
 	if (args_has(args, 'U'))
-		return (cmd_wait_for_unlock(cmdq, name, wc));
-	return (cmd_wait_for_wait(cmdq, name, wc));
+		return (cmd_wait_for_unlock(item, name, wc));
+	return (cmd_wait_for_wait(item, name, wc));
 }
 
-enum cmd_retval
-cmd_wait_for_signal(__unused struct cmd_q *cmdq, const char *name,
+static enum cmd_retval
+cmd_wait_for_signal(__unused struct cmdq_item *item, const char *name,
     struct wait_channel *wc)
 {
-	struct cmd_q	*wq, *wq1;
+	struct wait_item	*wi, *wi1;
 
 	if (wc == NULL)
 		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_REMOVE(&wc->waiters, wq, waitentry);
-		if (!cmdq_free(wq))
-			cmdq_continue(wq);
+	TAILQ_FOREACH_SAFE(wi, &wc->waiters, entry, wi1) {
+		cmdq_continue(wi->item);
+
+		TAILQ_REMOVE(&wc->waiters, wi, entry);
+		free(wi);
 	}
 
 	cmd_wait_for_remove(wc);
 	return (CMD_RETURN_NORMAL);
 }
 
-enum cmd_retval
-cmd_wait_for_wait(struct cmd_q *cmdq, const char *name,
+static enum cmd_retval
+cmd_wait_for_wait(struct cmdq_item *item, const char *name,
     struct wait_channel *wc)
 {
-	struct client	*c = cmdq->client;
+	struct client		*c = cmdq_get_client(item);
+	struct wait_item	*wi;
 
-	if (c == NULL || c->session != NULL) {
-		cmdq_error(cmdq, "not able to wait");
+	if (c == NULL) {
+		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);
-	cmdq->references++;
+	wi = xcalloc(1, sizeof *wi);
+	wi->item = item;
+	TAILQ_INSERT_TAIL(&wc->waiters, wi, entry);
 
 	return (CMD_RETURN_WAIT);
 }
 
-enum cmd_retval
-cmd_wait_for_lock(struct cmd_q *cmdq, const char *name,
+static enum cmd_retval
+cmd_wait_for_lock(struct cmdq_item *item, const char *name,
     struct wait_channel *wc)
 {
-	if (cmdq->client == NULL || cmdq->client->session != NULL) {
-		cmdq_error(cmdq, "not able to lock");
+	struct wait_item	*wi;
+
+	if (cmdq_get_client(item) == 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);
-		cmdq->references++;
+		wi = xcalloc(1, sizeof *wi);
+		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
-cmd_wait_for_unlock(struct cmd_q *cmdq, const char *name,
+static enum cmd_retval
+cmd_wait_for_unlock(struct cmdq_item *item, const char *name,
     struct wait_channel *wc)
 {
-	struct cmd_q	*wq;
+	struct wait_item	*wi;
 
 	if (wc == NULL || !wc->locked) {
-		cmdq_error(cmdq, "channel %s not locked", name);
+		cmdq_error(item, "channel %s not locked", name);
 		return (CMD_RETURN_ERROR);
 	}
 
-	if ((wq = TAILQ_FIRST(&wc->lockers)) != NULL) {
-		TAILQ_REMOVE(&wc->lockers, wq, waitentry);
-		if (!cmdq_free(wq))
-			cmdq_continue(wq);
+	if ((wi = TAILQ_FIRST(&wc->lockers)) != NULL) {
+		cmdq_continue(wi->item);
+		TAILQ_REMOVE(&wc->lockers, wi, entry);
+		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_REMOVE(&wc->waiters, wq, waitentry);
-			if (!cmdq_free(wq))
-				cmdq_continue(wq);
+		TAILQ_FOREACH_SAFE(wi, &wc->waiters, entry, wi1) {
+			cmdq_continue(wi->item);
+			TAILQ_REMOVE(&wc->waiters, wi, entry);
+			free(wi);
 		}
 		wc->woken = 1;
-		TAILQ_FOREACH_SAFE(wq, &wc->lockers, waitentry, wq1) {
-			TAILQ_REMOVE(&wc->lockers, wq, waitentry);
-			if (!cmdq_free(wq))
-				cmdq_continue(wq);
+		TAILQ_FOREACH_SAFE(wi, &wc->lockers, entry, wi1) {
+			cmdq_continue(wi->item);
+			TAILQ_REMOVE(&wc->lockers, wi, entry);
+			free(wi);
 		}
 		wc->locked = 0;
 		cmd_wait_for_remove(wc);

cmd.c

@@ -33,19 +33,20 @@ 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_clear_prompt_history_entry;
 extern const struct cmd_entry cmd_clock_mode_entry;
 extern const struct cmd_entry cmd_command_prompt_entry;
 extern const struct cmd_entry cmd_confirm_before_entry;
 extern const struct cmd_entry cmd_copy_mode_entry;
+extern const struct cmd_entry cmd_customize_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_popup_entry;
 extern const struct cmd_entry cmd_display_panes_entry;
-extern const struct cmd_entry cmd_down_pane_entry;
 extern const struct cmd_entry cmd_find_window_entry;
 extern const struct cmd_entry cmd_has_session_entry;
 extern const struct cmd_entry cmd_if_shell_entry;
@@ -82,6 +83,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 +94,7 @@ 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_server_access_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;
@@ -103,6 +105,7 @@ extern const struct cmd_entry cmd_show_environment_entry;
 extern const struct cmd_entry cmd_show_hooks_entry;
 extern const struct cmd_entry cmd_show_messages_entry;
 extern const struct cmd_entry cmd_show_options_entry;
+extern const struct cmd_entry cmd_show_prompt_history_entry;
 extern const struct cmd_entry cmd_show_window_options_entry;
 extern const struct cmd_entry cmd_source_file_entry;
 extern const struct cmd_entry cmd_split_window_entry;
@@ -113,7 +116,6 @@ extern const struct cmd_entry cmd_swap_window_entry;
 extern const struct cmd_entry cmd_switch_client_entry;
 extern const struct cmd_entry cmd_unbind_key_entry;
 extern const struct cmd_entry cmd_unlink_window_entry;
-extern const struct cmd_entry cmd_up_pane_entry;
 extern const struct cmd_entry cmd_wait_for_entry;
 
 const struct cmd_entry *cmd_table[] = {
@@ -123,17 +125,19 @@ 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_clear_prompt_history_entry,
 	&cmd_clock_mode_entry,
 	&cmd_command_prompt_entry,
 	&cmd_confirm_before_entry,
 	&cmd_copy_mode_entry,
+	&cmd_customize_mode_entry,
 	&cmd_delete_buffer_entry,
 	&cmd_detach_client_entry,
+	&cmd_display_menu_entry,
 	&cmd_display_message_entry,
+	&cmd_display_popup_entry,
 	&cmd_display_panes_entry,
 	&cmd_find_window_entry,
 	&cmd_has_session_entry,
@@ -171,6 +175,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 +186,7 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_select_window_entry,
 	&cmd_send_keys_entry,
 	&cmd_send_prefix_entry,
-	&cmd_server_info_entry,
+	&cmd_server_access_entry,
 	&cmd_set_buffer_entry,
 	&cmd_set_environment_entry,
 	&cmd_set_hook_entry,
@@ -192,6 +197,7 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_show_hooks_entry,
 	&cmd_show_messages_entry,
 	&cmd_show_options_entry,
+	&cmd_show_prompt_history_entry,
 	&cmd_show_window_options_entry,
 	&cmd_source_file_entry,
 	&cmd_split_window_entry,
@@ -206,6 +212,65 @@ const struct cmd_entry *cmd_table[] = {
 	NULL
 };
 
+/* Instance of a command. */
+struct cmd {
+	const struct cmd_entry	 *entry;
+	struct args		 *args;
+	u_int			  group;
+
+	char			 *file;
+	u_int			  line;
+
+	TAILQ_ENTRY(cmd)	  qentry;
+};
+TAILQ_HEAD(cmds, cmd);
+
+/* Next group number for new command list. */
+static u_int cmd_list_next_group = 1;
+
+/* Log an argument vector. */
+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);
+}
+
+/* Prepend to an argument vector. */
+void
+cmd_prepend_argv(int *argc, char ***argv, const 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)++;
+}
+
+/* Append to an argument vector. */
+void
+cmd_append_argv(int *argc, char ***argv, const char *arg)
+{
+	*argv = xreallocarray(*argv, (*argc) + 1, sizeof **argv);
+	(*argv)[(*argc)++] = xstrdup(arg);
+}
+
+/* Pack an argument vector up into a buffer. */
 int
 cmd_pack_argv(int argc, char **argv, char *buf, size_t len)
 {
@@ -214,6 +279,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++) {
@@ -227,6 +293,7 @@ cmd_pack_argv(int argc, char **argv, char *buf, size_t len)
 	return (0);
 }
 
+/* Unpack an argument vector from a packed buffer. */
 int
 cmd_unpack_argv(char *buf, size_t len, int argc, char ***argv)
 {
@@ -246,13 +313,16 @@ 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);
 }
 
+/* Copy an argument vector, ensuring it is terminated by NULL. */
 char **
 cmd_copy_argv(int argc, char **argv)
 {
@@ -269,6 +339,7 @@ cmd_copy_argv(int argc, char **argv)
 	return (new_argv);
 }
 
+/* Free an argument vector. */
 void
 cmd_free_argv(int argc, char **argv)
 {
@@ -281,80 +352,175 @@ cmd_free_argv(int argc, char **argv)
 	free(argv);
 }
 
+/* Convert argument vector to a string. */
 char *
 cmd_stringify_argv(int argc, char **argv)
 {
-	char	*buf;
+	char	*buf = NULL, *s;
+	size_t	 len = 0;
 	int	 i;
-	size_t	 len;
 
 	if (argc == 0)
 		return (xstrdup(""));
 
-	len = 0;
-	buf = NULL;
-
 	for (i = 0; i < argc; i++) {
-		len += strlen(argv[i]) + 1;
+		s = args_escape(argv[i]);
+		log_debug("%s: %u %s = %s", __func__, i, argv[i], s);
+
+		len += strlen(s) + 1;
 		buf = xrealloc(buf, len);
 
 		if (i == 0)
 			*buf = '\0';
 		else
 			strlcat(buf, " ", len);
-		strlcat(buf, argv[i], len);
+		strlcat(buf, s, len);
+
+		free(s);
 	}
 	return (buf);
 }
 
-struct cmd *
-cmd_parse(int argc, char **argv, const char *file, u_int line, char **cause)
+/* Get entry for command. */
+const struct cmd_entry *
+cmd_get_entry(struct cmd *cmd)
 {
-	const struct cmd_entry **entryp, *entry;
-	struct cmd		*cmd;
-	struct args		*args;
-	char			 s[BUFSIZ];
-	int			 ambiguous = 0;
+	return (cmd->entry);
+}
 
-	*cause = NULL;
-	if (argc == 0) {
-		xasprintf(cause, "no command");
+/* Get arguments for command. */
+struct args *
+cmd_get_args(struct cmd *cmd)
+{
+	return (cmd->args);
+}
+
+/* Get group for command. */
+u_int
+cmd_get_group(struct cmd *cmd)
+{
+	return (cmd->group);
+}
+
+/* Get file and line for command. */
+void
+cmd_get_source(struct cmd *cmd, const char **file, u_int *line)
+{
+	if (file != NULL)
+		*file = cmd->file;
+	if (line != NULL)
+		*line = cmd->line;
+}
+
+/* Look for an alias for a command. */
+char *
+cmd_get_alias(const char *name)
+{
+	struct options_entry		*o;
+	struct options_array_item	*a;
+	union options_value		*ov;
+	size_t				 wanted, n;
+	const char			*equals;
+
+	o = options_get_only(global_options, "command-alias");
+	if (o == NULL)
 		return (NULL);
-	}
+	wanted = strlen(name);
 
-	entry = NULL;
-	for (entryp = cmd_table; *entryp != NULL; entryp++) {
-		if ((*entryp)->alias != NULL &&
-		    strcmp((*entryp)->alias, argv[0]) == 0) {
+	a = options_array_first(o);
+	while (a != NULL) {
+		ov = options_array_item_value(a);
+
+		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);
+}
+
+/* Look up a command entry by name. */
+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, argv[0]) == 0)
+		if (strcmp(entry->name, name) == 0)
 			break;
 	}
 	if (ambiguous)
 		goto ambiguous;
-	if (entry == NULL) {
-		xasprintf(cause, "unknown command: %s", argv[0]);
+	if (found == NULL) {
+		xasprintf(cause, "unknown command: %s", name);
 		return (NULL);
 	}
+	return (found);
 
-	args = args_parse(entry->args.template, argc, argv);
-	if (args == NULL)
-		goto usage;
-	if (entry->args.lower != -1 && args->argc < entry->args.lower)
-		goto usage;
-	if (entry->args.upper != -1 && args->argc > entry->args.upper)
-		goto usage;
+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);
+}
+
+/* Parse a single command from an argument vector. */
+struct cmd *
+cmd_parse(struct args_value *values, u_int count, const char *file, u_int line,
+    char **cause)
+{
+	const struct cmd_entry	*entry;
+	struct cmd		*cmd;
+	struct args		*args;
+	char			*error = NULL;
+
+	if (count == 0 || values[0].type != ARGS_STRING) {
+		xasprintf(cause, "no command");
+		return (NULL);
+	}
+	entry = cmd_find(values[0].string, cause);
+	if (entry == NULL)
+		return (NULL);
+
+	args = args_parse(&entry->args, values, count, &error);
+	if (args == NULL && error == NULL) {
+		xasprintf(cause, "usage: %s %s", entry->name, entry->usage);
+		return (NULL);
+	}
+	if (args == NULL) {
+		xasprintf(cause, "command %s: %s", entry->name, error);
+		free(error);
+		return (NULL);
+	}
 
 	cmd = xcalloc(1, sizeof *cmd);
 	cmd->entry = entry;
@@ -365,201 +531,36 @@ cmd_parse(int argc, char **argv, const char *file, u_int line, char **cause)
 	cmd->line = line;
 
 	return (cmd);
-
-ambiguous:
-	*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)
-		args_free(args);
-	xasprintf(cause, "usage: %s %s", entry->name, entry->usage);
-	return (NULL);
 }
 
-static int
-cmd_prepare_state_flag(char c, const char *target, enum cmd_entry_flag flag,
-    struct cmd_q *cmdq, struct cmd_q *parent)
+/* Free a command. */
+void
+cmd_free(struct cmd *cmd)
 {
-	int			 targetflags, error;
-	struct cmd_find_state	*fs = NULL;
-	struct cmd_find_state	*current = NULL;
-	struct cmd_find_state	 tmp;
+	free(cmd->file);
 
-	if (flag == CMD_NONE ||
-	    flag == CMD_CLIENT ||
-	    flag == CMD_CLIENT_CANFAIL)
-		return (0);
-
-	if (c == 't')
-		fs = &cmdq->state.tflag;
-	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);
+	args_free(cmd->args);
+	free(cmd);
 }
 
-int
-cmd_prepare_state(struct cmd *cmd, struct cmd_q *cmdq, struct cmd_q *parent)
+/* Copy a command. */
+struct cmd *
+cmd_copy(struct cmd *cmd, int argc, char **argv)
 {
-	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;
+	struct cmd	*new_cmd;
 
-	tmp = cmd_print(cmd);
-	log_debug("preparing state for %s (client %p)", tmp, cmdq->client);
-	free(tmp);
+	new_cmd = xcalloc(1, sizeof *new_cmd);
+	new_cmd->entry = cmd->entry;
+	new_cmd->args = args_copy(cmd->args, argc, argv);
 
-	state->c = NULL;
-	cmd_find_clear_state(&state->tflag, NULL, 0);
-	cmd_find_clear_state(&state->sflag, NULL, 0);
+	if (cmd->file != NULL)
+		new_cmd->file = xstrdup(cmd->file);
+	new_cmd->line = cmd->line;
 
-	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);
+	return (new_cmd);
 }
 
+/* Get a command as a string. */
 char *
 cmd_print(struct cmd *cmd)
 {
@@ -575,6 +576,175 @@ cmd_print(struct cmd *cmd)
 	return (out);
 }
 
+/* Create a new command list. */
+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++;
+	cmdlist->list = xcalloc(1, sizeof *cmdlist->list);
+	TAILQ_INIT(cmdlist->list);
+	return (cmdlist);
+}
+
+/* Append a command to a command list. */
+void
+cmd_list_append(struct cmd_list *cmdlist, struct cmd *cmd)
+{
+	cmd->group = cmdlist->group;
+	TAILQ_INSERT_TAIL(cmdlist->list, cmd, qentry);
+}
+
+/* Append all commands from one list to another.  */
+void
+cmd_list_append_all(struct cmd_list *cmdlist, struct cmd_list *from)
+{
+	struct cmd	*cmd;
+
+	TAILQ_FOREACH(cmd, from->list, qentry)
+		cmd->group = cmdlist->group;
+	TAILQ_CONCAT(cmdlist->list, from->list, qentry);
+}
+
+/* Move all commands from one command list to another. */
+void
+cmd_list_move(struct cmd_list *cmdlist, struct cmd_list *from)
+{
+	TAILQ_CONCAT(cmdlist->list, from->list, qentry);
+	cmdlist->group = cmd_list_next_group++;
+}
+
+/* Free a command list. */
+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->list);
+	free(cmdlist);
+}
+
+/* Copy a command list, expanding %s in arguments. */
+struct cmd_list *
+cmd_list_copy(const struct cmd_list *cmdlist, int argc, char **argv)
+{
+	struct cmd	*cmd;
+	struct cmd_list	*new_cmdlist;
+	struct cmd	*new_cmd;
+	u_int		 group = cmdlist->group;
+	char		*s;
+
+	s = cmd_list_print(cmdlist, 0);
+	log_debug("%s: %s", __func__, s);
+	free(s);
+
+	new_cmdlist = cmd_list_new();
+	TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
+		if (cmd->group != group) {
+			new_cmdlist->group = cmd_list_next_group++;
+			group = cmd->group;
+		}
+		new_cmd = cmd_copy(cmd, argc, argv);
+		cmd_list_append(new_cmdlist, new_cmd);
+	}
+
+	s = cmd_list_print(new_cmdlist, 0);
+	log_debug("%s: %s", __func__, s);
+	free(s);
+
+	return (new_cmdlist);
+}
+
+/* Get a command list as a string. */
+char *
+cmd_list_print(const struct cmd_list *cmdlist, int escaped)
+{
+	struct cmd	*cmd, *next;
+	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) + 6;
+		buf = xrealloc(buf, len);
+
+		strlcat(buf, this, len);
+
+		next = TAILQ_NEXT(cmd, qentry);
+		if (next != NULL) {
+			if (cmd->group != next->group) {
+				if (escaped)
+					strlcat(buf, " \\;\\; ", len);
+				else
+					strlcat(buf, " ;; ", len);
+			} else {
+				if (escaped)
+					strlcat(buf, " \\; ", len);
+				else
+					strlcat(buf, " ; ", len);
+			}
+		}
+
+		free(this);
+	}
+
+	return (buf);
+}
+
+/* Get first command in list. */
+struct cmd *
+cmd_list_first(struct cmd_list *cmdlist)
+{
+	return (TAILQ_FIRST(cmdlist->list));
+}
+
+/* Get next command in list. */
+struct cmd *
+cmd_list_next(struct cmd *cmd)
+{
+	return (TAILQ_NEXT(cmd, qentry));
+}
+
+/* Do all of the commands in this command list have this flag? */
+int
+cmd_list_all_have(struct cmd_list *cmdlist, int flag)
+{
+	struct cmd	*cmd;
+
+	TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
+		if (~cmd->entry->flags & flag)
+			return (0);
+	}
+	return (1);
+}
+
+/* Do any of the commands in this command list have this flag? */
+int
+cmd_list_any_have(struct cmd_list *cmdlist, int flag)
+{
+	struct cmd	*cmd;
+
+	TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
+		if (cmd->entry->flags & flag)
+			return (1);
+	}
+	return (0);
+}
+
 /* Adjust current mouse position for a pane. */
 int
 cmd_mouse_at(struct window_pane *wp, struct mouse_event *m, u_int *xp,
@@ -583,25 +753,26 @@ cmd_mouse_at(struct window_pane *wp, struct mouse_event *m, u_int *xp,
 	u_int	x, y;
 
 	if (last) {
-		x = m->lx;
-		y = m->ly;
+		x = m->lx + m->ox;
+		y = m->ly + m->oy;
 	} else {
-		x = m->x;
-		y = m->y;
+		x = m->x + m->ox;
+		y = m->y + m->oy;
 	}
+	log_debug("%s: x=%u, y=%u%s", __func__, x, y, last ? " (last)" : "");
 
-	if (m->statusat == 0 && y > 0)
-		y--;
-	else if (m->statusat > 0 && y >= (u_int)m->statusat)
-		y = m->statusat - 1;
+	if (m->statusat == 0 && y >= m->statuslines)
+		y -= m->statuslines;
 
 	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;
-	*yp = y - wp->yoff;
+	if (xp != NULL)
+		*xp = x - wp->xoff;
+	if (yp != NULL)
+		*yp = y - wp->yoff;
 	return (0);
 }
 
@@ -611,17 +782,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)
-		return (NULL);
-
+	if (m->w == -1)
+		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. */
@@ -634,10 +810,14 @@ cmd_mouse_pane(struct mouse_event *m, struct session **sp,
 
 	if ((wl = cmd_mouse_window(m, sp)) == NULL)
 		return (NULL);
-	if ((wp = window_pane_find_by_id(m->wp)) == NULL)
-		return (NULL);
-	if (!window_has_pane(wl->window, wp))
-		return (NULL);
+	if (m->wp == -1)
+		wp = wl->window->active;
+	else {
+		if ((wp = window_pane_find_by_id(m->wp)) == NULL)
+			return (NULL);
+		if (!window_has_pane(wl->window, wp))
+			return (NULL);
+	}
 
 	if (wlp != NULL)
 		*wlp = wl;
@@ -649,8 +829,8 @@ char *
 cmd_template_replace(const char *template, const char *s, int idx)
 {
 	char		 ch, *buf;
-	const char	*ptr;
-	int		 replaced;
+	const char	*ptr, *cp, quote[] = "\"\\$;~";
+	int		 replaced, quoted;
 	size_t		 len;
 
 	if (strchr(template, '%') == NULL)
@@ -672,9 +852,17 @@ cmd_template_replace(const char *template, const char *s, int idx)
 			}
 			ptr++;
 
-			len += strlen(s);
-			buf = xrealloc(buf, len + 1);
-			strlcat(buf, s, len + 1);
+			quoted = (*ptr == '%');
+			if (quoted)
+				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);

compat.h

@@ -17,10 +17,53 @@
 #ifndef COMPAT_H
 #define COMPAT_H
 
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/uio.h>
+
+#include <fnmatch.h>
+#include <limits.h>
+#include <stdio.h>
+#include <termios.h>
+#include <wchar.h>
+
+#ifdef HAVE_EVENT2_EVENT_H
+#include <event2/event.h>
+#include <event2/event_compat.h>
+#include <event2/event_struct.h>
+#include <event2/buffer.h>
+#include <event2/buffer_compat.h>
+#include <event2/bufferevent.h>
+#include <event2/bufferevent_struct.h>
+#include <event2/bufferevent_compat.h>
+#else
+#include <event.h>
+#ifndef EVBUFFER_EOL_LF
+/*
+ * This doesn't really work because evbuffer_readline is broken, but gets us to
+ * build with very old (older than 1.4.14) libevent.
+ */
+#define EVBUFFER_EOL_LF
+#define evbuffer_readln(a, b, c) evbuffer_readline(a)
+#endif
+#endif
+
+#ifdef HAVE_MALLOC_TRIM
+#include <malloc.h>
+#endif
+
+#ifdef HAVE_UTF8PROC
+#include <utf8proc.h>
+#endif
+
 #ifndef __GNUC__
 #define __attribute__(a)
 #endif
 
+#ifdef BROKEN___DEAD
+#undef __dead
+#endif
+
 #ifndef __unused
 #define __unused __attribute__ ((__unused__))
 #endif
@@ -30,26 +73,77 @@
 #ifndef __packed
 #define __packed __attribute__ ((__packed__))
 #endif
+#ifndef __weak
+#define __weak __attribute__ ((__weak__))
+#endif
 
 #ifndef ECHOPRT
 #define ECHOPRT 0
 #endif
 
-#ifndef HAVE_BSD_TYPES
-typedef uint8_t u_int8_t;
-typedef uint16_t u_int16_t;
-typedef uint32_t u_int32_t;
-typedef uint64_t u_int64_t;
+#ifndef ACCESSPERMS
+#define ACCESSPERMS (S_IRWXU|S_IRWXG|S_IRWXO)
 #endif
 
-#ifndef HAVE_PATHS_H
-#define	_PATH_BSHELL	"/bin/sh"
-#define	_PATH_TMP	"/tmp/"
+#if !defined(FIONREAD) && defined(__sun)
+#include <sys/filio.h>
+#endif
+
+#ifdef HAVE_ERR_H
+#include <err.h>
+#else
+void	err(int, const char *, ...);
+void	errx(int, const char *, ...);
+void	warn(const char *, ...);
+void	warnx(const char *, ...);
+#endif
+
+#ifdef HAVE_PATHS_H
+#include <paths.h>
+#endif
+
+#ifndef _PATH_BSHELL
+#define _PATH_BSHELL	"/bin/sh"
+#endif
+
+#ifndef _PATH_TMP
+#define _PATH_TMP	"/tmp/"
+#endif
+
+#ifndef _PATH_DEVNULL
 #define _PATH_DEVNULL	"/dev/null"
+#endif
+
+#ifndef _PATH_TTY
 #define _PATH_TTY	"/dev/tty"
+#endif
+
+#ifndef _PATH_DEV
 #define _PATH_DEV	"/dev/"
 #endif
 
+#ifndef _PATH_DEFPATH
+#define _PATH_DEFPATH	"/usr/bin:/bin"
+#endif
+
+#ifndef _PATH_VI
+#define _PATH_VI	"/usr/bin/vi"
+#endif
+
+#ifndef __OpenBSD__
+#define pledge(s, p) (0)
+#endif
+
+#ifndef IMAXBEL
+#define IMAXBEL 0
+#endif
+
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#else
+#include <inttypes.h>
+#endif
+
 #ifdef HAVE_QUEUE_H
 #include <sys/queue.h>
 #else
@@ -68,21 +162,17 @@ typedef uint64_t u_int64_t;
 #include "compat/bitstring.h"
 #endif
 
-#ifdef HAVE_PATHS_H
-#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>
@@ -96,12 +186,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) \
@@ -130,6 +214,14 @@ typedef uint64_t u_int64_t;
 #define O_DIRECTORY 0
 #endif
 
+#ifndef FNM_CASEFOLD
+#ifdef FNM_IGNORECASE
+#define FNM_CASEFOLD FNM_IGNORECASE
+#else
+#define FNM_CASEFOLD 0
+#endif
+#endif
+
 #ifndef INFTIM
 #define INFTIM -1
 #endif
@@ -181,6 +273,13 @@ typedef uint64_t u_int64_t;
 #define HOST_NAME_MAX 255
 #endif
 
+#ifndef CLOCK_REALTIME
+#define CLOCK_REALTIME 0
+#endif
+#ifndef CLOCK_MONOTONIC
+#define CLOCK_MONOTONIC CLOCK_REALTIME
+#endif
+
 #ifndef HAVE_FLOCK
 #define LOCK_SH 0
 #define LOCK_EX 0
@@ -188,9 +287,24 @@ 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_GETDTABLESIZE
+/* getdtablesize.c */
+int		 getdtablesize(void);
+#endif
+
 #ifndef HAVE_CLOSEFROM
 /* closefrom.c */
-void	closefrom(int);
+void		 closefrom(int);
 #endif
 
 #ifndef HAVE_STRCASESTR
@@ -218,20 +332,75 @@ 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_HTONLL
+/* htonll.c */
+#undef htonll
+uint64_t	 htonll(uint64_t);
+#endif
+
+#ifndef HAVE_NTOHLL
+/* ntohll.c */
+#undef ntohll
+uint64_t	 ntohll(uint64_t);
+#endif
+
+#ifndef HAVE_GETPEEREID
+/* getpeereid.c */
+int		getpeereid(int, uid_t *, gid_t *);
+#endif
+
 #ifndef HAVE_DAEMON
 /* daemon.c */
 int	 	 daemon(int, int);
 #endif
 
+#ifndef HAVE_GETPROGNAME
+/* getprogname.c */
+const char	*getprogname(void);
+#endif
+
+#ifndef HAVE_SETPROCTITLE
+/* setproctitle.c */
+void		 setproctitle(const char *, ...);
+#endif
+
+#ifndef HAVE_CLOCK_GETTIME
+/* clock_gettime.c */
+int		 clock_gettime(int, struct timespec *);
+#endif
+
 #ifndef HAVE_B64_NTOP
-/* b64_ntop.c */
-#undef b64_ntop /* for Cygwin */
+/* base64.c */
+#undef b64_ntop
+#undef b64_pton
 int		 b64_ntop(const char *, size_t, char *, size_t);
+int		 b64_pton(const char *, u_char *, size_t);
+#endif
+
+#ifndef HAVE_FDFORKPTY
+/* fdforkpty.c */
+int		 getptmfd(void);
+pid_t		 fdforkpty(int, int *, char *, struct termios *,
+		     struct winsize *);
 #endif
 
 #ifndef HAVE_FORKPTY
 /* forkpty.c */
-#include <sys/ioctl.h>
 pid_t		 forkpty(int *, char *, struct termios *, struct winsize *);
 #endif
 
@@ -246,8 +415,9 @@ 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);
+#ifndef HAVE_GETLINE
+/* getline.c */
+ssize_t		 getline(char **, size_t *, FILE *);
 #endif
 
 #ifndef HAVE_SETENV
@@ -261,26 +431,46 @@ int		 unsetenv(const char *);
 void		 cfmakeraw(struct termios *);
 #endif
 
-#ifndef HAVE_OPENAT
-/* openat.c */
-#define AT_FDCWD -100
-int		 openat(int, const char *, int, ...);
+#ifndef HAVE_FREEZERO
+/* freezero.c */
+void		 freezero(void *, size_t);
 #endif
 
 #ifndef HAVE_REALLOCARRAY
 /* reallocarray.c */
-void		*reallocarray(void *, size_t, size_t size);
+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_SYSTEMD
+/* systemd.c */
+int		 systemd_activated(void);
+int		 systemd_create_socket(int, char **);
+int		 systemd_move_to_new_cgroup(char **);
+#endif
+
+#ifdef HAVE_UTF8PROC
+/* utf8proc.c */
+int		 utf8proc_wcwidth(wchar_t);
+int		 utf8proc_mbtowc(wchar_t *, const char *, size_t);
+int		 utf8proc_wctomb(char *, wchar_t);
+#endif
+
+#ifdef NEED_FUZZING
+/* tmux.c */
+#define main __weak main
 #endif
 
-#ifdef HAVE_GETOPT
-#include <getopt.h>
-#else
 /* getopt.c */
-extern int	BSDopterr;
-extern int	BSDoptind;
-extern int	BSDoptopt;
-extern int	BSDoptreset;
-extern char    *BSDoptarg;
+extern int	 BSDopterr;
+extern int	 BSDoptind;
+extern int	 BSDoptopt;
+extern int	 BSDoptreset;
+extern char	*BSDoptarg;
 int	BSDgetopt(int, char *const *, const char *);
 #define getopt(ac, av, o)  BSDgetopt(ac, av, o)
 #define opterr             BSDopterr
@@ -288,6 +478,5 @@ int	BSDgetopt(int, char *const *, const char *);
 #define optopt             BSDoptopt
 #define optreset           BSDoptreset
 #define optarg             BSDoptarg
-#endif
 
 #endif /* COMPAT_H */

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, ...)