0.17.3

This reverts commit 2f1edeff78.

.gitignore

@@ -1,7 +1,9 @@
 bin/fzf
+bin/fzf.exe
 target
 pkg
 Gemfile.lock
 .DS_Store
 doc/tags
 vendor
+gopath

.travis.yml

@@ -1,19 +1,18 @@
 language: ruby
+dist: trusty
+sudo: required
 matrix:
   include:
     - env: TAGS=
       rvm: 2.3.3
 #   - env: TAGS=tcell
-#     rvm: 2.2.0
+#     rvm: 2.3.3
 
 install:
-- sudo apt-get update
-- sudo apt-get install -y libncurses-dev lib32ncurses5-dev libgpm-dev
 - sudo add-apt-repository -y ppa:pi-rho/dev
 - sudo apt-add-repository -y ppa:fish-shell/release-2
 - sudo apt-get update
-- sudo apt-get install -y tmux=1.9a-1~ppa1~p
+- sudo apt-get install -y tmux zsh fish
-- sudo apt-get install -y zsh fish
 
 script: |
   make test install &&

CHANGELOG.md

@@ -1,13 +1,80 @@
 CHANGELOG
 =========
 
+0.17.3
+------
+- `$LINES` and `$COLUMNS` are exported to preview command so that the command
+  knows the exact size of the preview window.
+- Better error messages when the default command or `$FZF_DEFAULT_COMMAND`
+  fails.
+- Reverted #1061 to avoid having duplicate entries in the list when find
+  command detected a file system loop (#1120). The default command now
+  requires that find supports `-fstype` option.
+- fzf now distinguishes mouse left click and right click (#1130)
+    - Right click is now bound to `toggle` action by default
+    - `--bind` understands `left-click` and `right-click`
+- Added `replace-query` action (#1137)
+    - Replaces query string with the current selection
+- Added `accept-non-empty` action (#1162)
+    - Same as accept, except that it prevents fzf from exiting without any
+      selection
+
+0.17.1
+------
+
+- Fixed custom background color of preview window (#1046)
+- Fixed background color issues of Windows binary
+- Fixed Windows binary to execute command using cmd.exe with no parsing and
+  escaping (#1072)
+- Added support for `window` layout on Vim 8 using Vim 8 terminal (#1055)
+
+0.17.0-2
+--------
+
+A maintenance release for auxiliary scripts. fzf binaries are not updated.
+
+- Experimental support for the builtin terminal of Vim 8
+    - fzf can now run inside GVim
+- Updated Vim plugin to better handle `&shell` issue on fish
+- Fixed a bug of fzf-tmux where invalid output is generated
+- Fixed fzf-tmux to work even when `tput` does not work
+
+0.17.0
+------
+- Performance optimization
+- One can match literal spaces in extended-search mode with a space prepended
+  by a backslash.
+- `--expect` is now additive and can be specified multiple times.
+
+0.16.11
+-------
+- Performance optimization
+- Fixed missing preview update
+
+0.16.10
+-------
+- Fixed invalid handling of ANSI colors in preview window
+- Further improved `--ansi` performance
+
+0.16.9
+------
+- Memory and performance optimization
+    - Around 20% performance improvement for general use cases
+    - Up to 5x faster processing of `--ansi`
+    - Up to 50% reduction of memory usage
+- Bug fixes and usability improvements
+    - Fixed handling of bracketed paste mode
+    - [ERROR] on info line when the default command failed
+    - More efficient rendering of preview window
+    - `--no-clear` updated for repetitive relaunching scenarios
+
 0.16.8
 ------
 - New `change` event and `top` action for `--bind`
     - `fzf --bind change:top`
         - Move cursor to the top result whenever the query string is changed
-    - `fzf --bind ctrl-u:unix-word-rubout+top`
+    - `fzf --bind 'ctrl-w:unix-word-rubout+top,ctrl-u:unix-line-discard+top'`
-        - `top` combined with `unix-word-rubout`
+        - `top` combined with `unix-word-rubout` and `unix-line-discard`
 - Fixed inconsistent tiebreak scores when `--nth` is used
 - Proper display of tab characters in `--prompt`
 - Fixed not to `--cycle` on page-up/page-down to prevent overshoot

README-VIM.md

@@ -37,7 +37,7 @@ Note that the environment variables `FZF_DEFAULT_COMMAND` and
 - `g:fzf_action`
     - Customizable extra key bindings for opening selected files in different ways
 - `g:fzf_layout`
-    - Determines the size and position of fzf window (tmux pane or Neovim split)
+    - Determines the size and position of fzf window
 - `g:fzf_colors`
     - Customizes fzf colors to match the current color scheme
 - `g:fzf_history_dir`
@@ -55,11 +55,24 @@ let g:fzf_action = {
   \ 'ctrl-x': 'split',
   \ 'ctrl-v': 'vsplit' }
 
+" An action can be a reference to a function that processes selected lines
+function! s:build_quickfix_list(lines)
+  call setqflist(map(copy(a:lines), '{ "filename": v:val }'))
+  copen
+  cc
+endfunction
+
+let g:fzf_action = {
+  \ 'ctrl-q': function('s:build_quickfix_list'),
+  \ 'ctrl-t': 'tab split',
+  \ 'ctrl-x': 'split',
+  \ 'ctrl-v': 'vsplit' }
+
 " Default fzf layout
 " - down / up / left / right
 let g:fzf_layout = { 'down': '~40%' }
 
-" In Neovim, you can set up fzf window using a Vim command
+" You can set up fzf window using a Vim command (Neovim or latest Vim 8 required)
 let g:fzf_layout = { 'window': 'enew' }
 let g:fzf_layout = { 'window': '-tabnew' }
 let g:fzf_layout = { 'window': '10split enew' }
@@ -73,6 +86,7 @@ let g:fzf_colors =
   \ 'bg+':     ['bg', 'CursorLine', 'CursorColumn'],
   \ 'hl+':     ['fg', 'Statement'],
   \ 'info':    ['fg', 'PreProc'],
+  \ 'border':  ['fg', 'Ignore'],
   \ 'prompt':  ['fg', 'Conditional'],
   \ 'pointer': ['fg', 'Exception'],
   \ 'marker':  ['fg', 'Keyword'],
@@ -102,7 +116,7 @@ following options.
 | `options`                  | string/list   | Options to fzf                                                   |
 | `dir`                      | string        | Working directory                                                |
 | `up`/`down`/`left`/`right` | number/string | Use tmux pane with the given size (e.g. `20`, `50%`)             |
-| `window` (*Neovim only*)   | string        | Command to open fzf window (e.g. `vertical aboveleft 30new`)     |
+| `window` (Vim 8 / Neovim)  | string        | Command to open fzf window (e.g. `vertical aboveleft 30new`)     |
 | `launcher`                 | string        | External terminal emulator to start fzf with (GVim only)         |
 | `launcher`                 | funcref       | Function for generating `launcher` string (GVim only)            |
 
@@ -128,11 +142,38 @@ command! -bang MyStuff
   \ call fzf#run(fzf#wrap('my-stuff', {'dir': '~/my-stuff'}, <bang>0))
 ```
 
+fzf inside terminal buffer
+--------------------------
+
+The latest versions of Vim and Neovim include builtin terminal emulator
+(`:terminal`) and fzf will start in a terminal buffer in the following cases:
+
+- On Neovim
+- On GVim
+- On Terminal Vim with the non-default layout
+    - `call fzf#run({'left': '30%'})` or `let g:fzf_layout = {'left': '30%'}`
+
+### Hide statusline
+
+When fzf starts in a terminal buffer, you may want to hide the statusline of
+the containing buffer.
+
+```vim
+autocmd! FileType fzf
+autocmd  FileType fzf set laststatus=0 noshowmode noruler
+  \| autocmd BufLeave <buffer> set laststatus=2 showmode ruler
+```
+
 GVim
 ----
 
-In GVim, you need an external terminal emulator to start fzf with. `xterm`
+With the latest version of GVim, fzf will start inside the builtin terminal
-command is used by default, but you can customize it with `g:fzf_launcher`.
+emulator of Vim. Please note that this terminal feature of Vim is still young
+and unstable and you may run into some issues.
+
+If you have an older version of GVim, you need an external terminal emulator
+to start fzf with. `xterm` command is used by default, but you can customize
+it with `g:fzf_launcher`.
 
 ```vim
 " This is the default. %s is replaced with fzf command

README.md

@@ -3,15 +3,19 @@
 
 fzf is a general-purpose command-line fuzzy finder.
 
-![](https://raw.github.com/junegunn/i/master/fzf.gif)
+<img src="https://raw.githubusercontent.com/junegunn/i/master/fzf-preview.png" width=640>
+
+It's an interactive Unix filter for command-line that can be used with any
+list; files, command history, processes, hostnames, bookmarks, git commits,
+etc.
 
 Pros
 ----
 
-- No dependencies
+- Portable, no dependencies
 - Blazingly fast
 - The most comprehensive feature set
-- Flexible layout using tmux panes
+- Flexible layout
 - Batteries included
     - Vim/Neovim plugin, key bindings and fuzzy auto-completion
 
@@ -19,9 +23,10 @@ Table of Contents
 -----------------
 
    * [Installation](#installation)
+      * [Using Homebrew or Linuxbrew](#using-homebrew-or-linuxbrew)
       * [Using git](#using-git)
-      * [Using Homebrew](#using-homebrew)
       * [As Vim plugin](#as-vim-plugin)
+      * [Fedora](#fedora)
       * [Windows](#windows)
    * [Upgrading fzf](#upgrading-fzf)
    * [Building fzf](#building-fzf)
@@ -42,8 +47,12 @@ Table of Contents
       * [Settings](#settings)
       * [Supported commands](#supported-commands)
    * [Vim plugin](#vim-plugin)
+   * [Advanced topics](#advanced-topics)
+      * [Performance](#performance)
+      * [Executing external programs](#executing-external-programs)
+      * [Preview window](#preview-window)
    * [Tips](#tips)
-      * [Respecting .gitignore, <code>.hgignore</code>, and <code>svn:ignore</code>](#respecting-gitignore-hgignore-and-svnignore)
+      * [Respecting .gitignore](#respecting-gitignore)
       * [git ls-tree for fast traversal](#git-ls-tree-for-fast-traversal)
       * [Fish shell](#fish-shell)
    * [<a href="LICENSE">License</a>](#license)
@@ -65,9 +74,21 @@ stuff.
 
 [bin]: https://github.com/junegunn/fzf-bin/releases
 
+### Using Homebrew or Linuxbrew
+
+You can use [Homebrew](http://brew.sh/) or [Linuxbrew](http://linuxbrew.sh/)
+to install fzf.
+
+```sh
+brew install fzf
+
+# To install useful key bindings and fuzzy completion:
+$(brew --prefix)/opt/fzf/install
+```
+
 ### Using git
 
-Clone this repository and run
+Alternatively, you can "git clone" this repository to any directory and run
 [install](https://github.com/junegunn/fzf/blob/master/install) script.
 
 ```sh
@@ -75,36 +96,55 @@ git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
 ~/.fzf/install
 ```
 
-### Using Homebrew
-
-On OS X, you can use [Homebrew](http://brew.sh/) to install fzf.
-
-```sh
-brew install fzf
-
-# Install shell extensions
-/usr/local/opt/fzf/install
-```
-
 ### As Vim plugin
 
-You can manually add the directory to `&runtimepath` as follows,
+Once you have fzf installed, you can enable it inside Vim simply by adding the
+directory to `&runtimepath` as follows:
 
 ```vim
-" If installed using git
-set rtp+=~/.fzf
-
 " If installed using Homebrew
 set rtp+=/usr/local/opt/fzf
+
+" If installed using git
+set rtp+=~/.fzf
 ```
 
-But it's recommended that you use a plugin manager like
+If you use [vim-plug](https://github.com/junegunn/vim-plug), the same can be
-[vim-plug](https://github.com/junegunn/vim-plug).
+written as:
 
 ```vim
-Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
+" If installed using Homebrew
+Plug '/usr/local/opt/fzf'
+
+" If installed using git
+Plug '~/.fzf'
 ```
 
+But instead of separately installing fzf on your system (using Homebrew or
+"git clone") and enabling it on Vim (adding it to `&runtimepath`), you can use
+vim-plug to do both.
+
+```vim
+" PlugInstall and PlugUpdate will clone fzf in ~/.fzf and run install script
+Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
+  " Both options are optional. You don't have to install fzf in ~/.fzf
+  " and you don't have to run install script if you use fzf only in Vim.
+```
+
+### Fedora
+
+fzf is available in Fedora 26 and above, and can be installed using the usual
+method:
+
+```sh
+sudo dnf install fzf
+```
+
+Shell completion and plugins for vim or neovim are enabled by default. Shell
+key bindings are installed but not enabled by default. See Fedora's package
+documentation for more information.
+
+
 ### Windows
 
 Pre-built binaries for Windows can be downloaded [here][bin]. fzf is also
@@ -116,10 +156,12 @@ available as a [Chocolatey package][choco].
 choco install fzf
 ```
 
-However, other components of the project may not work on Windows. You might
+However, other components of the project may not work on Windows. Known issues
-want to consider installing fzf on [Windows Subsystem for Linux][wsl] where
+and limitations can be found on [the wiki page][windows-wiki]. You might want
+to consider installing fzf on [Windows Subsystem for Linux][wsl] where
 everything runs flawlessly.
 
+[windows-wiki]: https://github.com/junegunn/fzf/wiki/Windows
 [wsl]: https://blogs.msdn.microsoft.com/wsl/
 
 Upgrading fzf
@@ -220,7 +262,7 @@ or `py`.
 
 - `FZF_DEFAULT_COMMAND`
     - Default command to use when input is tty
-    - e.g. `export FZF_DEFAULT_COMMAND='ag -g ""'`
+    - e.g. `export FZF_DEFAULT_COMMAND='fd --type f'`
 - `FZF_DEFAULT_OPTS`
     - Default options
     - e.g. `export FZF_DEFAULT_OPTS="--reverse --inline-info"`
@@ -358,12 +400,17 @@ export FZF_COMPLETION_TRIGGER='~~'
 # Options to fzf command
 export FZF_COMPLETION_OPTS='+c -x'
 
-# Use ag instead of the default find command for listing candidates.
+# Use fd (https://github.com/sharkdp/fd) instead of the default find
-# - The first argument to the function is the base path to start traversal
+# command for listing path candidates.
-# - Note that ag only lists files not directories
+# - The first argument to the function ($1) is the base path to start traversal
 # - See the source code (completion.{bash,zsh}) for the details.
 _fzf_compgen_path() {
-  ag -g "" "$1"
+  fd --hidden --follow --exclude ".git" . "$1"
+}
+
+# Use fd to generate the list for directory completion
+_fzf_compgen_dir() {
+  fd --type d --hidden --follow --exclude ".git" . "$1"
 }
 ```
 
@@ -383,33 +430,117 @@ Vim plugin
 
 See [README-VIM.md](README-VIM.md).
 
+Advanced topics
+---------------
+
+### Performance
+
+fzf is fast, and is [getting even faster][perf]. Performance should not be
+a problem in most use cases. However, you might want to be aware of the
+options that affect the performance.
+
+- `--ansi` tells fzf to extract and parse ANSI color codes in the input and it
+  makes the initial scanning slower. So it's not recommended that you add it
+  to your `$FZF_DEFAULT_OPTS`.
+- `--nth` makes fzf slower as fzf has to tokenize each line.
+- `--with-nth` makes fzf slower as fzf has to tokenize and reassemble each
+  line.
+- If you absolutely need better performance, you can consider using
+  `--algo=v1` (the default being `v2`) to make fzf use faster greedy
+  algorithm. However, this algorithm is not guaranteed to find the optimal
+  ordering of the matches and is not recommended.
+
+[perf]: https://junegunn.kr/images/fzf-0.17.0.png
+
+### Executing external programs
+
+You can set up key bindings for starting external processes without leaving
+fzf (`execute`, `execute-silent`).
+
+```bash
+# Press F1 to open the file with less without leaving fzf
+# Press CTRL-Y to copy the line to clipboard and aborts fzf (requires pbcopy)
+fzf --bind 'f1:execute(less -f {}),ctrl-y:execute-silent(echo {} | pbcopy)+abort'
+```
+
+See *KEY BINDINGS* section of the man page for details.
+
+### Preview window
+
+When `--preview` option is set, fzf automatically starts external process with
+the current line as the argument and shows the result in the split window.
+
+```bash
+# {} is replaced to the single-quoted string of the focused line
+fzf --preview 'cat {}'
+```
+
+Since preview window is updated only after the process is complete, it's
+important that the command finishes quickly.
+
+```bash
+# Use head instead of cat so that the command doesn't take too long to finish
+fzf --preview 'head -100 {}'
+```
+
+Preview window supports ANSI colors, so you can use programs that
+syntax-highlights the content of a file.
+
+- Highlight: http://www.andre-simon.de/doku/highlight/en/highlight.php
+- CodeRay: http://coderay.rubychan.de/
+- Rouge: https://github.com/jneen/rouge
+
+```bash
+# Try highlight, coderay, rougify in turn, then fall back to cat
+fzf --preview '[[ $(file --mime {}) =~ binary ]] &&
+                 echo {} is a binary file ||
+                 (highlight -O ansi -l {} ||
+                  coderay {} ||
+                  rougify {} ||
+                  cat {}) 2> /dev/null | head -500'
+```
+
+You can customize the size and position of the preview window using
+`--preview-window` option. For example,
+
+```bash
+fzf --height 40% --reverse --preview 'file {}' --preview-window down:1
+```
+
+For more advanced examples, see [Key bindings for git with fzf][fzf-git].
+
+[fzf-git]: https://junegunn.kr/2016/07/fzf-git/
+
 Tips
 ----
 
-#### Respecting `.gitignore`, `.hgignore`, and `svn:ignore`
+#### Respecting `.gitignore`
 
-[ag](https://github.com/ggreer/the_silver_searcher) or
+You can use [fd](https://github.com/sharkdp/fd),
-[pt](https://github.com/monochromegane/the_platinum_searcher) will do the
+[ripgrep](https://github.com/BurntSushi/ripgrep), or [the silver
-filtering:
+searcher](https://github.com/ggreer/the_silver_searcher) instead of the
+default find command to traverse the file system while respecting
+`.gitignore`.
 
 ```sh
-# Feed the output of ag into fzf
+# Feed the output of fd into fzf
-ag -g "" | fzf
+fd --type f | fzf
 
-# Setting ag as the default source for fzf
+# Setting fd as the default source for fzf
-export FZF_DEFAULT_COMMAND='ag -g ""'
+export FZF_DEFAULT_COMMAND='fd --type f'
 
-# Now fzf (w/o pipe) will use ag instead of find
+# Now fzf (w/o pipe) will use fd instead of find
 fzf
 
 # To apply the command to CTRL-T as well
 export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"
 ```
 
-If you don't want to exclude hidden files, use the following command:
+If you want the command to follow symbolic links, and don't want it to exclude
+hidden files, use the following command:
 
 ```sh
-export FZF_DEFAULT_COMMAND='ag --hidden --ignore .git -g ""'
+export FZF_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git'
 ```
 
 #### `git ls-tree` for fast traversal
@@ -426,10 +557,10 @@ export FZF_DEFAULT_COMMAND='
 
 #### Fish shell
 
-It's [a known bug of fish](https://github.com/fish-shell/fish-shell/issues/1362)
+Fish shell before version 2.6.0 [doesn't allow](https://github.com/fish-shell/fish-shell/issues/1362)
-(will be fixed in 2.6.0) that it doesn't allow reading from STDIN in command
+reading from STDIN in command substitution, which means simple `vim (fzf)`
-substitution, which means simple `vim (fzf)` won't work as expected. The
+doesn't work as expected. The workaround for fish 2.5.0 and earlier is to use
-workaround is to use the `read` fish command:
+the `read` fish command:
 
 ```sh
 fzf | read -l result; and vim $result
@@ -457,7 +588,7 @@ make use of this feature. `$dir` defaults to `.` when the last token is not a
 valid directory. Example:
 
 ```sh
-set -l FZF_CTRL_T_COMMAND "command find -L \$dir -type f 2> /dev/null | sed '1d; s#^\./##'"
+set -g FZF_CTRL_T_COMMAND "command find -L \$dir -type f 2> /dev/null | sed '1d; s#^\./##'"
 ```
 
 [License](LICENSE)

bin/fzf-tmux

@@ -16,8 +16,8 @@ skip=""
 swap=""
 close=""
 term=""
-[[ -n "$LINES" ]] && lines=$LINES || lines=$(tput lines)
+[[ -n "$LINES" ]] && lines=$LINES || lines=$(tput lines) || lines=$(tmux display-message -p "#{pane_height}")
-[[ -n "$COLUMNS" ]] && columns=$COLUMNS || columns=$(tput cols)
+[[ -n "$COLUMNS" ]] && columns=$COLUMNS || columns=$(tput cols) || columns=$(tmux display-message -p "#{pane_width}")
 
 help() {
   >&2 echo 'usage: fzf-tmux [-u|-d [HEIGHT[%]]] [-l|-r [WIDTH[%]]] [--] [FZF OPTIONS]
@@ -146,6 +146,7 @@ cleanup() {
   fi
 
   if [ $# -gt 0 ]; then
+    trap - EXIT
     exit 130
   fi
 }
@@ -170,21 +171,21 @@ for arg in "${args[@]}"; do
 done
 
 pppid=$$
-trap_set="trap 'kill -SIGUSR1 -$pppid' EXIT SIGINT SIGTERM"
+echo -n "trap 'kill -SIGUSR1 -$pppid' EXIT SIGINT SIGTERM;" > $argsf
-trap_unset="trap - EXIT SIGINT SIGTERM"
+close="; trap - EXIT SIGINT SIGTERM $close"
 
 if [[ -n "$term" ]] || [[ -t 0 ]]; then
-  cat <<< "\"$fzf\" $opts > $fifo2; echo \$? > $fifo3 $close" > $argsf
+  cat <<< "\"$fzf\" $opts > $fifo2; echo \$? > $fifo3 $close" >> $argsf
   TMUX=$(echo $TMUX | cut -d , -f 1,2) tmux set-window-option synchronize-panes off \;\
     set-window-option remain-on-exit off \;\
-    split-window $opt "$trap_set;cd $(printf %q "$PWD");$envs bash $argsf;$trap_unset" $swap \
+    split-window $opt "$envs bash -c 'cd $(printf %q "$PWD"); exec -a fzf bash $argsf'" $swap \
     > /dev/null 2>&1
 else
   mkfifo $fifo1
-  cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" > $argsf
+  cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" >> $argsf
   TMUX=$(echo $TMUX | cut -d , -f 1,2) tmux set-window-option synchronize-panes off \;\
     set-window-option remain-on-exit off \;\
-    split-window $opt "$trap_set;$envs bash $argsf;$trap_unset" $swap \
+    split-window $opt "$envs bash -c 'exec -a fzf bash $argsf'" $swap \
     > /dev/null 2>&1
   cat <&0 > $fifo1 &
 fi

doc/fzf.txt

@@ -1,4 +1,4 @@
-fzf.txt	fzf	Last change: April 28 2017
+fzf.txt	fzf	Last change: November 19 2017
 FZF - TABLE OF CONTENTS                                            *fzf* *fzf-toc*
 ==============================================================================
 
@@ -8,6 +8,8 @@ FZF - TABLE OF CONTENTS                                            *fzf* *fzf-to
         Examples
     fzf#run
     fzf#wrap
+    fzf inside terminal buffer
+      Hide statusline
     GVim
     License
 
@@ -61,7 +63,7 @@ Note that the environment variables `FZF_DEFAULT_COMMAND` and
    - Customizable extra key bindings for opening selected files in different
      ways
  - `g:fzf_layout`
-   - Determines the size and position of fzf window (tmux pane or Neovim split)
+   - Determines the size and position of fzf window
  - `g:fzf_colors`
    - Customizes fzf colors to match the current color scheme
  - `g:fzf_history_dir`
@@ -80,11 +82,24 @@ Examples~
       \ 'ctrl-x': 'split',
       \ 'ctrl-v': 'vsplit' }
 
+    " An action can be a reference to a function that processes selected lines
+    function! s:build_quickfix_list(lines)
+      call setqflist(map(copy(a:lines), '{ "filename": v:val }'))
+      copen
+      cc
+    endfunction
+
+    let g:fzf_action = {
+      \ 'ctrl-q': function('s:build_quickfix_list'),
+      \ 'ctrl-t': 'tab split',
+      \ 'ctrl-x': 'split',
+      \ 'ctrl-v': 'vsplit' }
+
     " Default fzf layout
     " - down / up / left / right
     let g:fzf_layout = { 'down': '~40%' }
 
-    " In Neovim, you can set up fzf window using a Vim command
+    " You can set up fzf window using a Vim command (Neovim or latest Vim 8 required)
     let g:fzf_layout = { 'window': 'enew' }
     let g:fzf_layout = { 'window': '-tabnew' }
     let g:fzf_layout = { 'window': '10split enew' }
@@ -98,6 +113,7 @@ Examples~
       \ 'bg+':     ['bg', 'CursorLine', 'CursorColumn'],
       \ 'hl+':     ['fg', 'Statement'],
       \ 'info':    ['fg', 'PreProc'],
+      \ 'border':  ['fg', 'Ignore'],
       \ 'prompt':  ['fg', 'Conditional'],
       \ 'pointer': ['fg', 'Exception'],
       \ 'marker':  ['fg', 'Keyword'],
@@ -128,7 +144,7 @@ following options.
   `options`                   | string/list   | Options to fzf
   `dir`                       | string        | Working directory
   `up` / `down` / `left` / `right`  | number/string | Use tmux pane with the given size (e.g.  `20` ,  `50%` )
-  `window`  (Neovim only)     | string        | Command to open fzf window (e.g.  `vertical aboveleft 30new` )
+  `window`  (Vim 8 / Neovim)  | string        | Command to open fzf window (e.g.  `vertical aboveleft 30new` )
   `launcher`                  | string        | External terminal emulator to start fzf with (GVim only)
   `launcher`                  | funcref       | Function for generating  `launcher`  string (GVim only)
  ---------------------------+---------------+--------------------------------------------------------------
@@ -153,11 +169,39 @@ function that decorates the options dictionary so that it understands
       \ call fzf#run(fzf#wrap('my-stuff', {'dir': '~/my-stuff'}, <bang>0))
 <
 
+FZF INSIDE TERMINAL BUFFER                          *fzf-inside-terminal-buffer*
+==============================================================================
+
+The latest versions of Vim and Neovim include builtin terminal emulator
+(`:terminal`) and fzf will start in a terminal buffer in the following cases:
+
+ - On Neovim
+ - On GVim
+ - On Terminal Vim with the non-default layout
+   - `call fzf#run({'left': '30%'})` or `let g:fzf_layout = {'left': '30%'}`
+
+
+< Hide statusline >___________________________________________________________~
+                                                           *fzf-hide-statusline*
+
+When fzf starts in a terminal buffer, you may want to hide the statusline of
+the containing buffer.
+>
+    autocmd! FileType fzf
+    autocmd  FileType fzf set laststatus=0 noshowmode noruler
+      \| autocmd BufLeave <buffer> set laststatus=2 showmode ruler
+<
+
 GVIM                                                                  *fzf-gvim*
 ==============================================================================
 
-In GVim, you need an external terminal emulator to start fzf with. `xterm`
+With the latest version of GVim, fzf will start inside the builtin terminal
-command is used by default, but you can customize it with `g:fzf_launcher`.
+emulator of Vim. Please note that this terminal feature of Vim is still young
+and unstable and you may run into some issues.
+
+If you have an older version of GVim, you need an external terminal emulator
+to start fzf with. `xterm` command is used by default, but you can customize
+it with `g:fzf_launcher`.
 >
     " This is the default. %s is replaced with fzf command
     let g:fzf_launcher = 'xterm -e bash -ic %s'

glide.lock

@@ -1,24 +1,68 @@
-hash: d68dd0bd779ac4ffca1e0c49ca38d85f90d5d68fa8e2d5d7db70a8ce8c662ec1
+hash: 92a208bfbaecdf8d1ccaf99a465884c49f9cd91f44f1756d7bbf3290795c781b
-updated: 2017-06-01T15:48:41.653745249-07:00
+updated: 2017-12-03T13:37:23.420874333+09:00
 imports:
+- name: github.com/bjwbell/gensimd
+  version: 06eb18285485c0d572cc7f024050fc6cb652ed4c
+  subpackages:
+  - simd
+- name: github.com/codegangsta/cli
+  version: c6af8847eb2b7b297d07c3ede98903e95e680ef9
 - name: github.com/gdamore/encoding
   version: b23993cbb6353f0e6aa98d0ee318a34728f628b9
 - name: github.com/gdamore/tcell
-  version: 44772c121bb7838819d3ba4a7e84c0c2d617328e
+  version: 0a0db94084dfe181108c18508ebd312f12d331fb
   subpackages:
   - encoding
 - name: github.com/lucasb-eyer/go-colorful
   version: c900de9dbbc73129068f5af6a823068fc5f2308c
+- name: github.com/Masterminds/semver
+  version: 15d8430ab86497c5c0da827b748823945e1cf1e1
+- name: github.com/Masterminds/vcs
+  version: 6f1c6d150500e452704e9863f68c2559f58616bf
 - name: github.com/mattn/go-isatty
   version: 66b8e73f3f5cda9f96b69efd03dd3d7fc4a5cdb8
 - name: github.com/mattn/go-runewidth
   version: 14207d285c6c197daabb5c9793d63e7af9ab2d50
 - name: github.com/mattn/go-shellwords
   version: 02e3cf038dcea8290e44424da473dd12be796a8a
+- name: github.com/mengzhuo/intrinsic
+  version: 34b800838e0bcd9c5b6abd414e3ad03dc1a686b8
+  subpackages:
+  - sse2
+- name: github.com/mitchellh/go-homedir
+  version: b8bc1bf767474819792c23f32d8286a45736f1c6
 - name: golang.org/x/crypto
   version: e1a4589e7d3ea14a3352255d04b6f1a418845e5e
   subpackages:
+  - acme
+  - blowfish
+  - cast5
+  - chacha20poly1305/internal/chacha20
+  - curve25519
+  - ed25519
+  - ed25519/internal/edwards25519
+  - hkdf
+  - nacl/secretbox
+  - openpgp
+  - openpgp/armor
+  - openpgp/elgamal
+  - openpgp/errors
+  - openpgp/packet
+  - openpgp/s2k
+  - pbkdf2
+  - pkcs12/internal/rc2
+  - poly1305
+  - ripemd160
+  - salsa20/salsa
+  - ssh
+  - ssh/agent
   - ssh/terminal
+  - ssh/testdata
+- name: golang.org/x/net
+  version: a8b9294777976932365dabb6640cf1468d95c70f
+  subpackages:
+  - context
+  - context/ctxhttp
 - name: golang.org/x/sys
   version: b90f89a1e7a9c1f6b918820b3daa7f08488c8594
   subpackages:
@@ -26,13 +70,65 @@ imports:
 - name: golang.org/x/text
   version: 4ee4af566555f5fbe026368b75596286a312663a
   subpackages:
+  - cases
+  - collate
+  - collate/build
+  - currency
   - encoding
   - encoding/charmap
+  - encoding/ianaindex
   - encoding/internal
   - encoding/internal/identifier
   - encoding/japanese
   - encoding/korean
   - encoding/simplifiedchinese
   - encoding/traditionalchinese
+  - encoding/unicode
+  - encoding/unicode/utf32
+  - internal
+  - internal/colltab
+  - internal/format
+  - internal/gen
+  - internal/stringset
+  - internal/tag
+  - internal/testtext
+  - internal/triegen
+  - internal/ucd
+  - internal/utf8internal
+  - language
+  - language/display
+  - message
+  - runes
+  - secure/bidirule
   - transform
-testImports: []
+  - unicode/bidi
+  - unicode/cldr
+  - unicode/norm
+  - unicode/rangetable
+  - width
+- name: golang.org/x/tools
+  version: 04447353bc504b9a5c02eb227b9ecd252e64ea20
+  subpackages:
+  - go/ast/astutil
+  - go/buildutil
+  - go/loader
+- name: gopkg.in/yaml.v2
+  version: 287cf08546ab5e7e37d55a84f7ed3fd1db036de5
+testImports:
+- name: github.com/gopherjs/gopherjs
+  version: 444abdf920945de5d4a977b572bcc6c674d1e4eb
+  subpackages:
+  - js
+- name: github.com/jtolds/gls
+  version: 77f18212c9c7edc9bd6a33d383a7b545ce62f064
+- name: github.com/smartystreets/assertions
+  version: 0b37b35ec7434b77e77a4bb29b79677cced992ea
+  subpackages:
+  - internal/go-render/render
+  - internal/oglematchers
+- name: github.com/smartystreets/goconvey
+  version: e5b2b7c9111590d019a696c7800593f666e1a7f4
+  subpackages:
+  - convey
+  - convey/gotest
+  - convey/reporting

glide.yaml

@@ -7,7 +7,7 @@ import:
 - package: github.com/mattn/go-shellwords
   version: 02e3cf038dcea8290e44424da473dd12be796a8a
 - package: github.com/gdamore/tcell
-  version: 44772c121bb7838819d3ba4a7e84c0c2d617328e
+  version: 0a0db94084dfe181108c18508ebd312f12d331fb
   subpackages:
   - encoding
 - package: golang.org/x/crypto

install

@@ -2,12 +2,13 @@
 
 set -u
 
-version=0.16.8
+version=0.17.3
 auto_completion=
 key_bindings=
 update_config=2
 binary_arch=
 allow_legacy=
+shells="bash zsh fish"
 
 help() {
   cat << EOF
@@ -21,6 +22,10 @@ usage: $0 [OPTIONS]
     --[no-]completion    Enable/disable fuzzy completion (bash & zsh)
     --[no-]update-rc     Whether or not to update shell configuration files
 
+    --no-bash            Do not set up bash configuration
+    --no-zsh             Do not set up zsh configuration
+    --no-fish            Do not set up fish configuration
+
     --32                 Download 32-bit binary
     --64                 Download 64-bit binary
 EOF
@@ -47,6 +52,9 @@ for opt in "$@"; do
     --32)              binary_arch=386   ;;
     --64)              binary_arch=amd64 ;;
     --bin)             ;;
+    --no-bash)         shells=${shells/bash/} ;;
+    --no-zsh)          shells=${shells/zsh/} ;;
+    --no-fish)         shells=${shells/fish/} ;;
     *)
       echo "unknown option: $opt"
       help
@@ -59,14 +67,14 @@ cd "$(dirname "${BASH_SOURCE[0]}")"
 fzf_base="$(pwd)"
 
 ask() {
-  # If stdin is a tty, we are "interactive".
+  while true; do
-  # non-interactive shell: wait for a linefeed
+    read -p "$1 ([y]/n) " -r
-  #     interactive shell: continue after a single keypress
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
-  read_n=$([ -t 0 ] && echo "-n 1")
+      return 1
-
+    elif [[ $REPLY =~ ^[Nn]$ ]]; then
-  read -p "$1 ([y]/n) " $read_n -r
+      return 0
-  echo
+    fi
-  [[ $REPLY =~ ^[Nn]$ ]]
+  done
 }
 
 check_binary() {
@@ -160,17 +168,20 @@ binary_error=""
 case "$archi" in
   Darwin\ *64)   download fzf-$version-darwin_${binary_arch:-amd64}.tgz  ;;
   Darwin\ *86)   download fzf-$version-darwin_${binary_arch:-386}.tgz    ;;
-  Linux\ *64)    download fzf-$version-linux_${binary_arch:-amd64}.tgz   ;;
-  Linux\ *86)    download fzf-$version-linux_${binary_arch:-386}.tgz     ;;
   Linux\ armv5*) download fzf-$version-linux_${binary_arch:-arm5}.tgz    ;;
   Linux\ armv6*) download fzf-$version-linux_${binary_arch:-arm6}.tgz    ;;
   Linux\ armv7*) download fzf-$version-linux_${binary_arch:-arm7}.tgz    ;;
   Linux\ armv8*) download fzf-$version-linux_${binary_arch:-arm8}.tgz    ;;
+  Linux\ aarch64*) download fzf-$version-linux_${binary_arch:-arm8}.tgz  ;;
+  Linux\ *64)    download fzf-$version-linux_${binary_arch:-amd64}.tgz   ;;
+  Linux\ *86)    download fzf-$version-linux_${binary_arch:-386}.tgz     ;;
   FreeBSD\ *64)  download fzf-$version-freebsd_${binary_arch:-amd64}.tgz ;;
   FreeBSD\ *86)  download fzf-$version-freebsd_${binary_arch:-386}.tgz   ;;
   OpenBSD\ *64)  download fzf-$version-openbsd_${binary_arch:-amd64}.tgz ;;
   OpenBSD\ *86)  download fzf-$version-openbsd_${binary_arch:-386}.tgz   ;;
   CYGWIN*\ *64)  download fzf-$version-windows_${binary_arch:-amd64}.zip ;;
+  MINGW*\ *86)   download fzf-$version-windows_${binary_arch:-386}.zip   ;;
+  MINGW*\ *64)   download fzf-$version-windows_${binary_arch:-amd64}.zip ;;
   *)             binary_available=0 binary_error=1 ;;
 esac
 
@@ -202,6 +213,17 @@ fi
 
 [[ "$*" =~ "--bin" ]] && exit 0
 
+for s in $shells; do
+  if ! command -v "$s" > /dev/null; then
+    shells=${shells/$s/}
+  fi
+done
+
+if [[ ${#shells} -lt 3 ]]; then
+  echo "No shell configuration to be updated."
+  exit 0
+fi
+
 # Auto-completion
 if [ -z "$auto_completion" ]; then
   ask "Do you want to enable fuzzy auto-completion?"
@@ -215,9 +237,8 @@ if [ -z "$key_bindings" ]; then
 fi
 
 echo
-has_zsh=$(command -v zsh > /dev/null && echo 1 || echo 0)
-shells=$([ $has_zsh -eq 1 ] && echo "bash zsh" || echo "bash")
 for shell in $shells; do
+  [[ "$shell" = fish ]] && continue
   echo -n "Generate ~/.fzf.$shell ... "
   src=~/.fzf.${shell}
 
@@ -251,11 +272,10 @@ EOF
 done
 
 # fish
-has_fish=$(command -v fish > /dev/null && echo 1 || echo 0)
+if [[ "$shells" =~ fish ]]; then
-if [ $has_fish -eq 1 ]; then
   echo -n "Update fish_user_paths ... "
   fish << EOF
-  echo \$fish_user_paths | grep $fzf_base/bin > /dev/null
+  echo \$fish_user_paths | \grep $fzf_base/bin > /dev/null
   or set --universal fish_user_paths \$fish_user_paths $fzf_base/bin
 EOF
   [ $? -eq 0 ] && echo "OK" || echo "Failed"
@@ -286,20 +306,22 @@ append_line() {
   line="$2"
   file="$3"
   pat="${4:-}"
+  lno=""
 
   echo "Update $file:"
   echo "  - $line"
-  [ -f "$file" ] || touch "$file"
+  if [ -f "$file" ]; then
-  if [ $# -lt 4 ]; then
+    if [ $# -lt 4 ]; then
-    lno=$(\grep -nF "$line" "$file" | sed 's/:.*//' | tr '\n' ' ')
+      lno=$(\grep -nF "$line" "$file" | sed 's/:.*//' | tr '\n' ' ')
-  else
+    else
-    lno=$(\grep -nF "$pat" "$file" | sed 's/:.*//' | tr '\n' ' ')
+      lno=$(\grep -nF "$pat" "$file" | sed 's/:.*//' | tr '\n' ' ')
+    fi
   fi
   if [ -n "$lno" ]; then
     echo "    - Already exists: line #$lno"
   else
     if [ $update -eq 1 ]; then
-      echo >> "$file"
+      [ -f "$file" ] && echo >> "$file"
       echo "$line" >> "$file"
       echo "    + Added"
     else
@@ -328,11 +350,12 @@ if [ $update_config -eq 2 ]; then
 fi
 echo
 for shell in $shells; do
+  [[ "$shell" = fish ]] && continue
   [ $shell = zsh ] && dest=${ZDOTDIR:-~}/.zshrc || dest=~/.bashrc
   append_line $update_config "[ -f ~/.fzf.${shell} ] && source ~/.fzf.${shell}" "$dest" "~/.fzf.${shell}"
 done
 
-if [ $key_bindings -eq 1 ] && [ $has_fish -eq 1 ]; then
+if [ $key_bindings -eq 1 ] && [[ "$shells" =~ fish ]]; then
   bind_file=~/.config/fish/functions/fish_user_key_bindings.fish
   if [ ! -e "$bind_file" ]; then
     create_file "$bind_file" \
@@ -346,9 +369,9 @@ fi
 
 if [ $update_config -eq 1 ]; then
   echo 'Finished. Restart your shell or reload config file.'
-  echo '   source ~/.bashrc  # bash'
+  [[ "$shells" =~ bash ]] && echo '   source ~/.bashrc  # bash'
-  [ $has_zsh  -eq 1 ] && echo "   source ${ZDOTDIR:-~}/.zshrc   # zsh"
+  [[ "$shells" =~ zsh ]]  && echo "   source ${ZDOTDIR:-~}/.zshrc   # zsh"
-  [ $has_fish -eq 1 ] && [ $key_bindings -eq 1 ] && echo '   fzf_key_bindings  # fish'
+  [[ "$shells" =~ fish ]] && [ $key_bindings -eq 1 ] && echo '   fzf_key_bindings  # fish'
   echo
   echo 'Use uninstall script to remove fzf.'
   echo

man/man1/fzf-tmux.1

@@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf-tmux 1 "Jun 2017" "fzf 0.16.8" "fzf-tmux - open fzf in tmux split pane"
+.TH fzf-tmux 1 "Dec 2017" "fzf 0.17.3" "fzf-tmux - open fzf in tmux split pane"
 
 .SH NAME
 fzf-tmux - open fzf in tmux split pane

man/man1/fzf.1

@@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf 1 "Jun 2017" "fzf 0.16.8" "fzf - a command-line fuzzy finder"
+.TH fzf 1 "Dec 2017" "fzf 0.17.3" "fzf - a command-line fuzzy finder"
 
 .SH NAME
 fzf - a command-line fuzzy finder
@@ -111,6 +111,9 @@ Comma-separated list of sort criteria to apply when the scores are tied.
 .B "-m, --multi"
 Enable multi-select with tab/shift-tab
 .TP
+.B "+m, --no-multi"
+Disable multi-select
+.TP
 .B "--no-mouse"
 Disable mouse
 .TP
@@ -236,6 +239,7 @@ e.g. \fBfzf --color=bg+:24\fR
     \fBbg+     \fRBackground (current line)
     \fBhl+     \fRHighlighted substrings (current line)
     \fBinfo    \fRInfo
+    \fBborder  \fRBorder of the preview window and horizontal separators (\fB--border\fR)
     \fBprompt  \fRPrompt
     \fBpointer \fRPointer to the current line
     \fBmarker  \fRMulti-select marker
@@ -268,14 +272,17 @@ string, specify field index expressions between the braces (See \fBFIELD INDEX
 EXPRESSION\fR for the details).
 
 .RS
-e.g. \fBfzf --preview="head -$LINES {}"\fR
+e.g. \fBfzf --preview='head -$LINES {}'\fR
      \fBls -l | fzf --preview="echo user={3} when={-4..-2}; cat {-1}" --header-lines=1\fR
 
+fzf overrides \fB$LINES\fR and \fB$COLUMNS\fR so that they represent the exact
+size of the preview window.
+
 A placeholder expression starting with \fB+\fR flag will be replaced to the
 space-separated list of the selected lines (or the current line if no selection
 was made) individually quoted.
 
-e.g. \fBfzf --multi --preview="head -10 {+}"\fR
+e.g. \fBfzf --multi --preview='head -10 {+}'\fR
      \fBgit log --oneline | fzf --multi --preview 'git show {+1}'\fR
 
 Also, \fB{q}\fR is replaced to the current query string.
@@ -327,10 +334,12 @@ Comma-separated list of keys that can be used to complete fzf in addition to
 the default enter key. When this option is set, fzf will print the name of the
 key pressed as the first line of its output (or as the second line if
 \fB--print-query\fR is also used). The line will be empty if fzf is completed
-with the default enter key.
+with the default enter key. If \fB--expect\fR option is specified multiple
+times, fzf will expect the union of the keys. \fB--no-expect\fR will clear the
+list.
 
 .RS
-e.g. \fBfzf --expect=ctrl-v,ctrl-t,alt-s,f1,f2,~,@\fR
+e.g. \fBfzf --expect=ctrl-v,ctrl-t,alt-s --expect=f1,f2,~,@\fR
 .RE
 .TP
 .B "--read0"
@@ -356,6 +365,9 @@ e.g. \fBfzf --multi | fzf --sync\fR
 .B "--version"
 Display version information and exit
 
+.TP
+Note that most options have the opposite versions with \fB--no-\fR prefix.
+
 .SH ENVIRONMENT VARIABLES
 .TP
 .B FZF_DEFAULT_COMMAND
@@ -403,6 +415,9 @@ Unless specified otherwise, fzf will start in "extended-search mode". In this
 mode, you can specify multiple patterns delimited by spaces, such as: \fB'wild
 ^music .mp3$ sbtrkt !rmx\fR
 
+You can prepend a backslash to a space (\fB\\ \fR) to match a literal space
+character.
+
 .SS Exact-match (quoted)
 A term that is prefixed by a single-quote character (\fB'\fR) is interpreted as
 an "exact-match" (or "non-fuzzy") term. fzf will search for the exact
@@ -464,6 +479,8 @@ e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
     \fIpgdn\fR        (\fIpage-down\fR)
     \fIshift-left\fR
     \fIshift-right\fR
+    \fIleft-click\fR
+    \fIright-click\fR
     \fIdouble-click\fR
     or any single character
 
@@ -475,12 +492,13 @@ triggered whenever the query string is changed.
   \fBACTION:               DEFAULT BINDINGS (NOTES):
     \fBabort\fR                 \fIctrl-c  ctrl-g  ctrl-q  esc\fR
     \fBaccept\fR                \fIenter   double-click\fR
+    \fBaccept-non-empty\fR      (same as \fBaccept\fR except that it prevents fzf from exiting without selection)
     \fBbackward-char\fR         \fIctrl-b  left\fR
     \fBbackward-delete-char\fR  \fIctrl-h  bspace\fR
     \fBbackward-kill-word\fR    \fIalt-bs\fR
     \fBbackward-word\fR         \fIalt-b   shift-left\fR
     \fBbeginning-of-line\fR     \fIctrl-a  home\fR
-    \fBcancel\fR
+    \fBcancel\fR                (clears query string if not empty, aborts fzf otherwise)
     \fBclear-screen\fR          \fIctrl-l\fR
     \fBdelete-char\fR           \fIdel\fR
     \fBdelete-char/eof\fR       \fIctrl-d\fR
@@ -508,8 +526,9 @@ triggered whenever the query string is changed.
     \fBpreview-page-up\fR
     \fBprevious-history\fR      (\fIctrl-p\fR on \fB--history\fR)
     \fBprint-query\fR           (print query and exit)
+    \fBreplace-query\fR         (replace query string with the current selection)
     \fBselect-all\fR
-    \fBtoggle\fR
+    \fBtoggle\fR                (\fIright-click\fR)
     \fBtoggle-all\fR
     \fBtoggle+down\fR           \fIctrl-i  (tab)\fR
     \fBtoggle-in\fR             (\fB--reverse\fR ? \fBtoggle+up\fR : \fBtoggle+down\fR)

plugin/fzf.vim

@@ -35,6 +35,8 @@ else
   let s:base_dir = expand('<sfile>:h:h')
 endif
 if s:is_win
+  let s:term_marker = '&::FZF'
+
   function! s:fzf_call(fn, ...)
     let shellslash = &shellslash
     try
@@ -53,6 +55,8 @@ if s:is_win
           \ ['chcp %origchcp% > nul']
   endfunction
 else
+  let s:term_marker = ";#FZF"
+
   function! s:fzf_call(fn, ...)
     return call(a:fn, a:000)
   endfunction
@@ -66,8 +70,8 @@ function! s:shellesc_cmd(arg)
   let escaped = substitute(a:arg, '[&|<>()@^]', '^&', 'g')
   let escaped = substitute(escaped, '%', '%%', 'g')
   let escaped = substitute(escaped, '"', '\\^&', 'g')
-  let escaped = substitute(escaped, '\\\+\(\\^\)', '\\\\\1', 'g')
+  let escaped = substitute(escaped, '\(\\\+\)\(\\^\)', '\1\1\2', 'g')
-  return '^"'.substitute(escaped, '[^\\]\zs\\$', '\\\\', '').'^"'
+  return '^"'.substitute(escaped, '\(\\\+\)$', '\1\1', '').'^"'
 endfunction
 
 function! fzf#shellescape(arg, ...)
@@ -149,13 +153,8 @@ function! s:tmux_enabled()
 endfunction
 
 function! s:escape(path)
-  let escaped_chars = '$%#''"'
+  let path = fnameescape(a:path)
-
+  return s:is_win ? escape(path, '$') : path
-  if has('unix')
-    let escaped_chars .= ' \'
-  endif
-
-  return escape(a:path, escaped_chars)
 endfunction
 
 " Upgrade legacy options
@@ -206,7 +205,10 @@ function! s:common_sink(action, lines) abort
     return
   endif
   let key = remove(a:lines, 0)
-  let cmd = get(a:action, key, 'e')
+  let Cmd = get(a:action, key, 'e')
+  if type(Cmd) == type(function('call'))
+    return Cmd(a:lines)
+  endif
   if len(a:lines) > 1
     augroup fzf_swap
       autocmd SwapExists * let v:swapchoice='o'
@@ -222,7 +224,7 @@ function! s:common_sink(action, lines) abort
         execute 'e' s:escape(item)
         let empty = 0
       else
-        call s:open(cmd, item)
+        call s:open(Cmd, item)
       endif
       if !has('patch-8.0.0177') && !has('nvim-0.2') && exists('#BufEnter')
             \ && isdirectory(item)
@@ -330,25 +332,21 @@ function! fzf#wrap(...)
   return opts
 endfunction
 
-function! fzf#run(...) abort
+function! s:use_sh()
-try
+  let [shell, shellslash] = [&shell, &shellslash]
-  let oshell = &shell
-  let useshellslash = &shellslash
-
   if s:is_win
     set shell=cmd.exe
     set noshellslash
   else
     set shell=sh
   endif
+  return [shell, shellslash]
+endfunction
+
+function! fzf#run(...) abort
+try
+  let [shell, shellslash] = s:use_sh()
 
-  if has('nvim')
-    let running = filter(range(1, bufnr('$')), "bufname(v:val) =~# ';#FZF'")
-    if len(running)
-      call s:warn('FZF is already running (in buffer '.join(running, ', ').')!')
-      return []
-    endif
-  endif
   let dict   = exists('a:1') ? s:upgrade(a:1) : {}
   let temps  = { 'result': s:fzf_tempname() }
   let optstr = s:evaluate_opts(get(dict, 'options', ''))
@@ -361,18 +359,21 @@ try
   if has('nvim') && !has_key(dict, 'dir')
     let dict.dir = s:fzf_getcwd()
   endif
+  if has('win32unix') && has_key(dict, 'dir')
+    let dict.dir = fnamemodify(dict.dir, ':p')
+  endif
 
-  if !has_key(dict, 'source') && !empty($FZF_DEFAULT_COMMAND)
+  if !has_key(dict, 'source') && !empty($FZF_DEFAULT_COMMAND) && !s:is_win
-    let temps.source = s:fzf_tempname().(s:is_win ? '.bat' : '')
+    let temps.source = s:fzf_tempname()
     call writefile(s:wrap_cmds(split($FZF_DEFAULT_COMMAND, "\n")), temps.source)
-    let dict.source = (empty($SHELL) ? &shell : $SHELL) . (s:is_win ? ' /c ' : ' ') . fzf#shellescape(temps.source)
+    let dict.source = (empty($SHELL) ? &shell : $SHELL).' '.fzf#shellescape(temps.source)
   endif
 
   if has_key(dict, 'source')
     let source = dict.source
     let type = type(source)
     if type == 1
-      let prefix = source.'|'
+      let prefix = '( '.source.' )|'
     elseif type == 3
       let temps.input = s:fzf_tempname()
       call writefile(source, temps.input)
@@ -385,10 +386,13 @@ try
   endif
 
   let prefer_tmux = get(g:, 'fzf_prefer_tmux', 0)
-  let use_height = has_key(dict, 'down') &&
+  let use_height = has_key(dict, 'down') && !has('gui_running') &&
-        \ !(has('nvim') || s:is_win || has('win32unix') || s:present(dict, 'up', 'left', 'right')) &&
+        \ !(has('nvim') || s:is_win || has('win32unix') || s:present(dict, 'up', 'left', 'right', 'window')) &&
         \ executable('tput') && filereadable('/dev/tty')
-  let use_term = has('nvim') && !s:is_win
+  let has_vim8_term = has('terminal') && has('patch-8.0.995')
+  let has_nvim_term = has('nvim-0.2.1') || has('nvim') && !s:is_win
+  let use_term = has_nvim_term ||
+    \ has_vim8_term && !has('win32unix') && (has('gui_running') || s:is_win || !use_height && s:present(dict, 'down', 'up', 'left', 'right', 'window'))
   let use_tmux = (!use_height && !use_term || prefer_tmux) && !has('win32unix') && s:tmux_enabled() && s:splittable(dict)
   if prefer_tmux && use_tmux
     let use_height = 0
@@ -411,8 +415,7 @@ try
   call s:callback(dict, lines)
   return lines
 finally
-  let &shell = oshell
+  let [&shell, &shellslash] = [shell, shellslash]
-  let &shellslash = useshellslash
 endtry
 endfunction
 
@@ -468,11 +471,11 @@ augroup fzf_popd
 augroup END
 
 function! s:dopopd()
-  if !exists('w:fzf_prev_dir') || exists('*haslocaldir') && !haslocaldir()
+  if !exists('w:fzf_dir') || s:fzf_getcwd() != w:fzf_dir[1]
     return
   endif
-  execute 'lcd' s:escape(w:fzf_prev_dir)
+  execute 'lcd' s:escape(w:fzf_dir[0])
-  unlet w:fzf_prev_dir
+  unlet w:fzf_dir
 endfunction
 
 function! s:xterm_launcher()
@@ -526,12 +529,15 @@ function! s:execute(dict, command, use_height, temps) abort
     let command = batchfile
     let a:temps.batchfile = batchfile
     if has('nvim')
-      let s:dict = a:dict
-      let s:temps = a:temps
       let fzf = {}
+      let fzf.dict = a:dict
+      let fzf.temps = a:temps
       function! fzf.on_exit(job_id, exit_status, event) dict
-        let lines = s:collect(s:temps)
+        if s:present(self.dict, 'dir')
-        call s:callback(s:dict, lines)
+          execute 'lcd' s:escape(self.dict.dir)
+        endif
+        let lines = s:collect(self.temps)
+        call s:callback(self.dict, lines)
       endfunction
       let cmd = 'start /wait cmd /c '.command
       call jobstart(cmd, fzf)
@@ -628,6 +634,7 @@ function! s:execute_term(dict, command, temps) abort
   let winrest = winrestcmd()
   let pbuf = bufnr('')
   let [ppos, winopts] = s:split(a:dict)
+  call s:use_sh()
   let b:fzf = a:dict
   let fzf = { 'buf': bufnr(''), 'pbuf': pbuf, 'ppos': ppos, 'dict': a:dict, 'temps': a:temps,
             \ 'winopts': winopts, 'winrest': winrest, 'lines': &lines,
@@ -643,7 +650,7 @@ function! s:execute_term(dict, command, temps) abort
       endif
     endif
   endfunction
-  function! fzf.on_exit(id, code, _event)
+  function! fzf.on_exit(id, code, ...)
     if s:getpos() == self.ppos " {'window': 'enew'}
       for [opt, val] in items(self.winopts)
         execute 'let' opt '=' val
@@ -681,13 +688,28 @@ function! s:execute_term(dict, command, temps) abort
     if s:present(a:dict, 'dir')
       execute 'lcd' s:escape(a:dict.dir)
     endif
-    call termopen(a:command . ';#FZF', fzf)
+    if s:is_win
+      let fzf.temps.batchfile = s:fzf_tempname().'.bat'
+      call writefile(s:wrap_cmds(a:command), fzf.temps.batchfile)
+      let command = fzf.temps.batchfile
+    else
+      let command = a:command
+    endif
+    let command .= s:term_marker
+    if has('nvim')
+      call termopen(command, fzf)
+    else
+      let t = term_start([&shell, &shellcmdflag, command], {'curwin': fzf.buf, 'exit_cb': function(fzf.on_exit)})
+      if !has('patch-8.0.1261') && !has('nvim') && !s:is_win
+        call term_wait(t, 20)
+      endif
+    endif
   finally
     if s:present(a:dict, 'dir')
       lcd -
     endif
   endtry
-  setlocal nospell bufhidden=wipe nobuflisted
+  setlocal nospell bufhidden=wipe nobuflisted nonumber
   setf fzf
   startinsert
   return []
@@ -718,7 +740,7 @@ function! s:callback(dict, lines) abort
   let popd = has_key(a:dict, 'prev_dir') &&
         \ (!&autochdir || (empty(a:lines) || len(a:lines) == 1 && empty(a:lines[0])))
   if popd
-    let w:fzf_prev_dir = a:dict.prev_dir
+    let w:fzf_dir = [a:dict.prev_dir, a:dict.dir]
   endif
 
   try
@@ -742,7 +764,7 @@ function! s:callback(dict, lines) abort
 
   " We may have opened a new window or tab
   if popd
-    let w:fzf_prev_dir = a:dict.prev_dir
+    let w:fzf_dir = [a:dict.prev_dir, a:dict.dir]
     call s:dopopd()
   endif
 endfunction
@@ -753,9 +775,12 @@ let s:default_action = {
   \ 'ctrl-v': 'vsplit' }
 
 function! s:shortpath()
-  let short = pathshorten(fnamemodify(getcwd(), ':~:.'))
+  let short = fnamemodify(getcwd(), ':~:.')
+  if !has('win32unix')
+    let short = pathshorten(short)
+  endif
   let slash = (s:is_win && !&shellslash) ? '\' : '/'
-  return empty(short) ? '~'.slash : short . (short =~ slash.'$' ? '' : slash)
+  return empty(short) ? '~'.slash : short . (short =~ escape(slash, '\').'$' ? '' : slash)
 endfunction
 
 function! s:cmd(bang, ...) abort
@@ -765,13 +790,12 @@ function! s:cmd(bang, ...) abort
     let opts.dir = substitute(substitute(remove(args, -1), '\\\(["'']\)', '\1', 'g'), '[/\\]*$', '/', '')
     if s:is_win && !&shellslash
       let opts.dir = substitute(opts.dir, '/', '\\', 'g')
-    elseif has('win32unix')
-      let opts.dir = fnamemodify(opts.dir, ':p')
     endif
     let prompt = opts.dir
   else
     let prompt = s:shortpath()
   endif
+  let prompt = strwidth(prompt) < &columns - 20 ? prompt : '> '
   call extend(opts.options, ['--prompt', prompt])
   call extend(opts.options, args)
   call fzf#run(fzf#wrap('FZF', opts, a:bang))

shell/completion.bash

@@ -113,7 +113,7 @@ _fzf_opts_completion() {
 }
 
 _fzf_handle_dynamic_completion() {
-  local cmd orig_var orig ret orig_cmd
+  local cmd orig_var orig ret orig_cmd orig_complete
   cmd="$1"
   shift
   orig_cmd="$1"
@@ -122,10 +122,14 @@ _fzf_handle_dynamic_completion() {
   if [ -n "$orig" ] && type "$orig" > /dev/null 2>&1; then
     $orig "$@"
   elif [ -n "$_fzf_completion_loader" ]; then
+    orig_complete=$(complete -p "$cmd")
     _completion_loader "$@"
     ret=$?
-    eval "$(complete | command grep "\-F.* $orig_cmd$" | _fzf_orig_completion_filter)"
+    # _completion_loader may not have updated completion for the command
-    source "${BASH_SOURCE[0]}"
+    if [ "$(complete -p "$cmd")" != "$orig_complete" ]; then
+      eval "$(complete | command grep "\-F.* $orig_cmd$" | _fzf_orig_completion_filter)"
+      eval "$orig_complete"
+    fi
     return $ret
   fi
 }
@@ -215,7 +219,7 @@ _fzf_complete_kill() {
 
   local selected fzf
   fzf="$(__fzfcmd_complete)"
-  selected=$(ps -ef | sed 1d | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-50%} --min-height 15 --reverse $FZF_DEFAULT_OPTS --preview 'echo {}' --preview-window down:3:wrap $FZF_COMPLETION_OPTS" $fzf -m | awk '{print $2}' | tr '\n' ' ')
+  selected=$(command ps -ef | sed 1d | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-50%} --min-height 15 --reverse $FZF_DEFAULT_OPTS --preview 'echo {}' --preview-window down:3:wrap $FZF_COMPLETION_OPTS" $fzf -m | awk '{print $2}' | tr '\n' ' ')
   printf '\e[5n'
 
   if [ -n "$selected" ]; then
@@ -233,8 +237,8 @@ _fzf_complete_telnet() {
 
 _fzf_complete_ssh() {
   _fzf_complete '+m' "$@" < <(
-    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | command grep -i '^host' | command grep -v '*') \
+    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | command grep -i '^host' | command grep -v '*' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}') \
-        <(command grep -oE '^[a-z0-9.,:-]+' ~/.ssh/known_hosts | tr ',' '\n' | awk '{ print $1 " " $1 }') \
+        <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
         <(command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0') |
         awk '{if (length($2) > 0) {print $2}}' | sort -u
   )

shell/completion.zsh

@@ -116,8 +116,8 @@ _fzf_complete_telnet() {
 
 _fzf_complete_ssh() {
   _fzf_complete '+m' "$@" < <(
-    command cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | command grep -i '^host' | command grep -v '*') \
+    command cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | command grep -i '^host' | command grep -v '*' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}') \
-        <(command grep -oE '^[a-z0-9.,:-]+' ~/.ssh/known_hosts | tr ',' '\n' | awk '{ print $1 " " $1 }') \
+        <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
         <(command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0') |
         awk '{if (length($2) > 0) {print $2}}' | sort -u
   )
@@ -163,7 +163,7 @@ fzf-completion() {
   # Kill completion (do not require trigger sequence)
   if [ $cmd = kill -a ${LBUFFER[-1]} = ' ' ]; then
     fzf="$(__fzfcmd_complete)"
-    matches=$(ps -ef | sed 1d | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-50%} --min-height 15 --reverse $FZF_DEFAULT_OPTS --preview 'echo {}' --preview-window down:3:wrap $FZF_COMPLETION_OPTS" ${=fzf} -m | awk '{print $2}' | tr '\n' ' ')
+    matches=$(command ps -ef | sed 1d | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-50%} --min-height 15 --reverse $FZF_DEFAULT_OPTS --preview 'echo {}' --preview-window down:3:wrap $FZF_COMPLETION_OPTS" ${=fzf} -m | awk '{print $2}' | tr '\n' ' ')
     if [ -n "$matches" ]; then
       LBUFFER="$LBUFFER$matches"
     fi

shell/key-bindings.fish

@@ -4,14 +4,9 @@ function fzf_key_bindings
 
   # Store current token in $dir as root for the 'find' command
   function fzf-file-widget -d "List files and folders"
-    set -l dir (commandline -t)
+    set -l commandline (__fzf_parse_commandline)
-    # The commandline token might be escaped, we need to unescape it.
+    set -l dir $commandline[1]
-    set dir (eval "printf '%s' $dir")
+    set -l fzf_query $commandline[2]
-    if [ ! -d "$dir" ]
-      set dir .
-    end
-    # Some 'find' versions print undesired duplicated slashes if the path ends with slashes.
-    set dir (string replace --regex '(.)/+$' '$1' "$dir")
 
     # "-path \$dir'*/\\.*'" matches hidden files/folders inside $dir but not
     # $dir itself, even if hidden.
@@ -19,19 +14,17 @@ function fzf_key_bindings
     command find -L \$dir -mindepth 1 \\( -path \$dir'*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' \\) -prune \
     -o -type f -print \
     -o -type d -print \
-    -o -type l -print 2> /dev/null | cut -b3-"
+    -o -type l -print 2> /dev/null | sed 's@^\./@@'"
 
     set -q FZF_TMUX_HEIGHT; or set FZF_TMUX_HEIGHT 40%
     begin
       set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT --reverse $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS"
-      eval "$FZF_CTRL_T_COMMAND | "(__fzfcmd)" -m" | while read -l r; set result $result $r; end
+      eval "$FZF_CTRL_T_COMMAND | "(__fzfcmd)' -m --query "'$fzf_query'"' | while read -l r; set result $result $r; end
     end
     if [ -z "$result" ]
       commandline -f repaint
       return
-    end
+    else
-
-    if [ "$dir" != . ]
       # Remove last token from commandline.
       commandline -t ""
     end
@@ -46,22 +39,45 @@ function fzf_key_bindings
     set -q FZF_TMUX_HEIGHT; or set FZF_TMUX_HEIGHT 40%
     begin
       set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT $FZF_DEFAULT_OPTS --tiebreak=index --bind=ctrl-r:toggle-sort $FZF_CTRL_R_OPTS +m"
-      history | eval (__fzfcmd) -q '(commandline)' | read -l result
+
-      and commandline -- $result
+      set -l FISH_MAJOR (echo $FISH_VERSION | cut -f1 -d.)
+      set -l FISH_MINOR (echo $FISH_VERSION | cut -f2 -d.)
+
+      # history's -z flag is needed for multi-line support.
+      # history's -z flag was added in fish 2.4.0, so don't use it for versions
+      # before 2.4.0.
+      if [ "$FISH_MAJOR" -gt 2 -o \( "$FISH_MAJOR" -eq 2 -a "$FISH_MINOR" -ge 4 \) ];
+        history -z | eval (__fzfcmd) --read0 -q '(commandline)' | perl -pe 'chomp if eof' | read -lz result
+        and commandline -- $result
+      else
+        history | eval (__fzfcmd) -q '(commandline)' | read -l result
+        and commandline -- $result
+      end
     end
     commandline -f repaint
   end
 
   function fzf-cd-widget -d "Change directory"
+    set -l commandline (__fzf_parse_commandline)
+    set -l dir $commandline[1]
+    set -l fzf_query $commandline[2]
+
     set -q FZF_ALT_C_COMMAND; or set -l FZF_ALT_C_COMMAND "
-    command find -L . -mindepth 1 \\( -path '*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' \\) -prune \
+    command find -L \$dir -mindepth 1 \\( -path \$dir'*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' \\) -prune \
-    -o -type d -print 2> /dev/null | cut -b3-"
+    -o -type d -print 2> /dev/null | sed 's@^\./@@'"
     set -q FZF_TMUX_HEIGHT; or set FZF_TMUX_HEIGHT 40%
     begin
       set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT --reverse $FZF_DEFAULT_OPTS $FZF_ALT_C_OPTS"
-      eval "$FZF_ALT_C_COMMAND | "(__fzfcmd)" +m" | read -l result
+      eval "$FZF_ALT_C_COMMAND | "(__fzfcmd)' +m --query "'$fzf_query'"' | read -l result
-      [ "$result" ]; and cd $result
+
+      if [ -n "$result" ]
+        cd $result
+
+        # Remove last token from commandline.
+        commandline -t ""
+      end
     end
+
     commandline -f repaint
   end
 
@@ -84,4 +100,47 @@ function fzf_key_bindings
     bind -M insert \cr fzf-history-widget
     bind -M insert \ec fzf-cd-widget
   end
+
+  function __fzf_parse_commandline -d 'Parse the current command line token and return split of existing filepath and rest of token'
+    # eval is used to do shell expansion on paths
+    set -l commandline (eval "printf '%s' "(commandline -t))
+
+    if [ -z $commandline ]
+      # Default to current directory with no --query
+      set dir '.'
+      set fzf_query ''
+    else
+      set dir (__fzf_get_dir $commandline)
+
+      if [ "$dir" = "." -a (string sub -l 1 $commandline) != '.' ]
+        # if $dir is "." but commandline is not a relative path, this means no file path found
+        set fzf_query $commandline
+      else
+        # Also remove trailing slash after dir, to "split" input properly
+        set fzf_query (string replace -r "^$dir/?" '' "$commandline")
+      end
+    end
+
+    echo $dir
+    echo $fzf_query
+  end
+
+  function __fzf_get_dir -d 'Find the longest existing filepath from input string'
+    set dir $argv
+
+    # Strip all trailing slashes. Ignore if $dir is root dir (/)
+    if [ (string length $dir) -gt 1 ]
+      set dir (string replace -r '/*$' '' $dir)
+    end
+
+    # Iteratively check if dir exists and strip tail end of path
+    while [ ! -d "$dir" ]
+      # If path is absolute, this can keep going until ends up at /
+      # If path is relative, this can keep going until entire input is consumed, dirname returns "."
+      set dir (dirname "$dir")
+    end
+
+    echo $dir
+  end
+
 end

shell/key-bindings.zsh

@@ -36,6 +36,16 @@ fzf-file-widget() {
 zle     -N   fzf-file-widget
 bindkey '^T' fzf-file-widget
 
+# Ensure precmds are run after cd
+fzf-redraw-prompt() {
+  local precmd
+  for precmd in $precmd_functions; do
+    $precmd
+  done
+  zle reset-prompt
+}
+zle -N fzf-redraw-prompt
+
 # ALT-C - cd into the selected directory
 fzf-cd-widget() {
   local cmd="${FZF_ALT_C_COMMAND:-"command find -L . -mindepth 1 \\( -path '*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
@@ -48,7 +58,7 @@ fzf-cd-widget() {
   fi
   cd "$dir"
   local ret=$?
-  zle reset-prompt
+  zle fzf-redraw-prompt
   typeset -f zle-line-init >/dev/null && zle zle-line-init
   return $ret
 }
@@ -59,8 +69,8 @@ bindkey '\ec' fzf-cd-widget
 fzf-history-widget() {
   local selected num
   setopt localoptions noglobsubst noposixbuiltins pipefail 2> /dev/null
-  selected=( $(fc -l 1 |
+  selected=( $(fc -rl 1 |
-    FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} $FZF_DEFAULT_OPTS --tac -n2..,.. --tiebreak=index --bind=ctrl-r:toggle-sort $FZF_CTRL_R_OPTS --query=${(q)LBUFFER} +m" $(__fzfcmd)) )
+    FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} $FZF_DEFAULT_OPTS -n2..,.. --tiebreak=index --bind=ctrl-r:toggle-sort $FZF_CTRL_R_OPTS --query=${(qqq)LBUFFER} +m" $(__fzfcmd)) )
   local ret=$?
   if [ -n "$selected" ]; then
     num=$selected[1]

src/algo/algo.go

@@ -78,9 +78,11 @@ Scoring criteria
 */
 
 import (
+	"bytes"
 	"fmt"
 	"strings"
 	"unicode"
+	"unicode/utf8"
 
 	"github.com/junegunn/fzf/src/util"
 )
@@ -156,27 +158,17 @@ func posArray(withPos bool, len int) *[]int {
 	return nil
 }
 
-func alloc16(offset int, slab *util.Slab, size int, clear bool) (int, []int16) {
+func alloc16(offset int, slab *util.Slab, size int) (int, []int16) {
 	if slab != nil && cap(slab.I16) > offset+size {
 		slice := slab.I16[offset : offset+size]
-		if clear {
-			for idx := range slice {
-				slice[idx] = 0
-			}
-		}
 		return offset + size, slice
 	}
 	return offset, make([]int16, size)
 }
 
-func alloc32(offset int, slab *util.Slab, size int, clear bool) (int, []int32) {
+func alloc32(offset int, slab *util.Slab, size int) (int, []int32) {
 	if slab != nil && cap(slab.I32) > offset+size {
 		slice := slab.I32[offset : offset+size]
-		if clear {
-			for idx := range slice {
-				slice[idx] = 0
-			}
-		}
 		return offset + size, slice
 	}
 	return offset, make([]int32, size)
@@ -227,7 +219,7 @@ func bonusFor(prevClass charClass, class charClass) int16 {
 	return 0
 }
 
-func bonusAt(input util.Chars, idx int) int16 {
+func bonusAt(input *util.Chars, idx int) int16 {
 	if idx == 0 {
 		return bonusBoundary
 	}
@@ -249,21 +241,113 @@ func normalizeRune(r rune) rune {
 // Algo functions make two assumptions
 // 1. "pattern" is given in lowercase if "caseSensitive" is false
 // 2. "pattern" is already normalized if "normalize" is true
-type Algo func(caseSensitive bool, normalize bool, forward bool, input util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int)
+type Algo func(caseSensitive bool, normalize bool, forward bool, input *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int)
 
-func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+func trySkip(input *util.Chars, caseSensitive bool, b byte, from int) int {
+	byteArray := input.Bytes()[from:]
+	idx := bytes.IndexByte(byteArray, b)
+	if idx == 0 {
+		// Can't skip any further
+		return from
+	}
+	// We may need to search for the uppercase letter again. We don't have to
+	// consider normalization as we can be sure that this is an ASCII string.
+	if !caseSensitive && b >= 'a' && b <= 'z' {
+		if idx > 0 {
+			byteArray = byteArray[:idx]
+		}
+		uidx := bytes.IndexByte(byteArray, b-32)
+		if uidx >= 0 {
+			idx = uidx
+		}
+	}
+	if idx < 0 {
+		return -1
+	}
+	return from + idx
+}
+
+func isAscii(runes []rune) bool {
+	for _, r := range runes {
+		if r >= utf8.RuneSelf {
+			return false
+		}
+	}
+	return true
+}
+
+func asciiFuzzyIndex(input *util.Chars, pattern []rune, caseSensitive bool) int {
+	// Can't determine
+	if !input.IsBytes() {
+		return 0
+	}
+
+	// Not possible
+	if !isAscii(pattern) {
+		return -1
+	}
+
+	firstIdx, idx := 0, 0
+	for pidx := 0; pidx < len(pattern); pidx++ {
+		idx = trySkip(input, caseSensitive, byte(pattern[pidx]), idx)
+		if idx < 0 {
+			return -1
+		}
+		if pidx == 0 && idx > 0 {
+			// Step back to find the right bonus point
+			firstIdx = idx - 1
+		}
+		idx++
+	}
+	return firstIdx
+}
+
+func debugV2(T []rune, pattern []rune, F []int32, lastIdx int, H []int16, C []int16) {
+	width := lastIdx - int(F[0]) + 1
+
+	for i, f := range F {
+		I := i * width
+		if i == 0 {
+			fmt.Print("  ")
+			for j := int(f); j <= lastIdx; j++ {
+				fmt.Printf(" " + string(T[j]) + " ")
+			}
+			fmt.Println()
+		}
+		fmt.Print(string(pattern[i]) + " ")
+		for idx := int(F[0]); idx < int(f); idx++ {
+			fmt.Print(" 0 ")
+		}
+		for idx := int(f); idx <= lastIdx; idx++ {
+			fmt.Printf("%2d ", H[i*width+idx-int(F[0])])
+		}
+		fmt.Println()
+
+		fmt.Print("  ")
+		for idx, p := range C[I : I+width] {
+			if idx+int(F[0]) < int(F[i]) {
+				p = 0
+			}
+			if p > 0 {
+				fmt.Printf("%2d ", p)
+			} else {
+				fmt.Print("   ")
+			}
+		}
+		fmt.Println()
+	}
+}
+
+func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	// Assume that pattern is given in lowercase if case-insensitive.
 	// First check if there's a match and calculate bonus for each position.
 	// If the input string is too long, consider finding the matching chars in
 	// this phase as well (non-optimal alignment).
-	N := input.Length()
 	M := len(pattern)
-	switch M {
+	if M == 0 {
-	case 0:
 		return Result{0, 0, 0}, posArray(withPos, M)
-	case 1:
-		return ExactMatchNaive(caseSensitive, normalize, forward, input, pattern[0:1], withPos, slab)
 	}
+	N := input.Length()
 
 	// Since O(nm) algorithm can be prohibitively expensive for large input,
 	// we fall back to the greedy algorithm.
@@ -271,158 +355,175 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input util.C
 		return FuzzyMatchV1(caseSensitive, normalize, forward, input, pattern, withPos, slab)
 	}
 
+	// Phase 1. Optimized search for ASCII string
+	idx := asciiFuzzyIndex(input, pattern, caseSensitive)
+	if idx < 0 {
+		return Result{-1, -1, 0}, nil
+	}
+
 	// Reuse pre-allocated integer slice to avoid unnecessary sweeping of garbages
 	offset16 := 0
 	offset32 := 0
+	offset16, H0 := alloc16(offset16, slab, N)
+	offset16, C0 := alloc16(offset16, slab, N)
 	// Bonus point for each position
-	offset16, B := alloc16(offset16, slab, N, false)
+	offset16, B := alloc16(offset16, slab, N)
 	// The first occurrence of each character in the pattern
-	offset32, F := alloc32(offset32, slab, M, false)
+	offset32, F := alloc32(offset32, slab, M)
 	// Rune array
-	offset32, T := alloc32(offset32, slab, N, false)
+	offset32, T := alloc32(offset32, slab, N)
+	input.CopyRunes(T)
 
-	// Phase 1. Check if there's a match and calculate bonus for each point
+	// Phase 2. Calculate bonus for each point
-	pidx, lastIdx, prevClass := 0, 0, charNonWord
+	maxScore, maxScorePos := int16(0), 0
-	for idx := 0; idx < N; idx++ {
+	pidx, lastIdx := 0, 0
-		char := input.Get(idx)
+	pchar0, pchar, prevH0, prevClass, inGap := pattern[0], pattern[0], int16(0), charNonWord, false
+	Tsub := T[idx:]
+	H0sub, C0sub, Bsub := H0[idx:][:len(Tsub)], C0[idx:][:len(Tsub)], B[idx:][:len(Tsub)]
+	for off, char := range Tsub {
 		var class charClass
 		if char <= unicode.MaxASCII {
 			class = charClassOfAscii(char)
+			if !caseSensitive && class == charUpper {
+				char += 32
+			}
 		} else {
 			class = charClassOfNonAscii(char)
-		}
+			if !caseSensitive && class == charUpper {
-
-		if !caseSensitive && class == charUpper {
-			if char <= unicode.MaxASCII {
-				char += 32
-			} else {
 				char = unicode.To(unicode.LowerCase, char)
 			}
+			if normalize {
+				char = normalizeRune(char)
+			}
 		}
 
-		if normalize {
+		Tsub[off] = char
-			char = normalizeRune(char)
+		bonus := bonusFor(prevClass, class)
-		}
+		Bsub[off] = bonus
-
-		T[idx] = char
-		B[idx] = bonusFor(prevClass, class)
 		prevClass = class
 
-		if pidx < M {
+		if char == pchar {
-			if char == pattern[pidx] {
+			if pidx < M {
-				lastIdx = idx
+				F[pidx] = int32(idx + off)
-				F[pidx] = int32(idx)
 				pidx++
+				pchar = pattern[util.Min(pidx, M-1)]
 			}
-		} else {
+			lastIdx = idx + off
-			if char == pattern[M-1] {
-				lastIdx = idx
-			}
 		}
+
+		if char == pchar0 {
+			score := scoreMatch + bonus*bonusFirstCharMultiplier
+			H0sub[off] = score
+			C0sub[off] = 1
+			if M == 1 && (forward && score > maxScore || !forward && score >= maxScore) {
+				maxScore, maxScorePos = score, idx+off
+				if forward && bonus == bonusBoundary {
+					break
+				}
+			}
+			inGap = false
+		} else {
+			if inGap {
+				H0sub[off] = util.Max16(prevH0+scoreGapExtention, 0)
+			} else {
+				H0sub[off] = util.Max16(prevH0+scoreGapStart, 0)
+			}
+			C0sub[off] = 0
+			inGap = true
+		}
+		prevH0 = H0sub[off]
 	}
 	if pidx != M {
 		return Result{-1, -1, 0}, nil
 	}
+	if M == 1 {
+		result := Result{maxScorePos, maxScorePos + 1, int(maxScore)}
+		if !withPos {
+			return result, nil
+		}
+		pos := []int{maxScorePos}
+		return result, &pos
+	}
 
-	// Phase 2. Fill in score matrix (H)
+	// Phase 3. Fill in score matrix (H)
 	// Unlike the original algorithm, we do not allow omission.
-	width := lastIdx - int(F[0]) + 1
+	f0 := int(F[0])
-	offset16, H := alloc16(offset16, slab, width*M, false)
+	width := lastIdx - f0 + 1
+	offset16, H := alloc16(offset16, slab, width*M)
+	copy(H, H0[f0:lastIdx+1])
 
 	// Possible length of consecutive chunk at each position.
-	offset16, C := alloc16(offset16, slab, width*M, false)
+	offset16, C := alloc16(offset16, slab, width*M)
+	copy(C, C0[f0:lastIdx+1])
 
-	maxScore, maxScorePos := int16(0), 0
+	Fsub := F[1:]
-	for i := 0; i < M; i++ {
+	Psub := pattern[1:][:len(Fsub)]
-		I := i * width
+	for off, f := range Fsub {
+		f := int(f)
+		pchar := Psub[off]
+		pidx := off + 1
+		row := pidx * width
 		inGap := false
-		for j := int(F[i]); j <= lastIdx; j++ {
+		Tsub := T[f : lastIdx+1]
-			j0 := j - int(F[0])
+		Bsub := B[f:][:len(Tsub)]
+		Csub := C[row+f-f0:][:len(Tsub)]
+		Cdiag := C[row+f-f0-1-width:][:len(Tsub)]
+		Hsub := H[row+f-f0:][:len(Tsub)]
+		Hdiag := H[row+f-f0-1-width:][:len(Tsub)]
+		Hleft := H[row+f-f0-1:][:len(Tsub)]
+		Hleft[0] = 0
+		for off, char := range Tsub {
+			col := off + f
 			var s1, s2, consecutive int16
 
-			if j > int(F[i]) {
+			if inGap {
-				if inGap {
+				s2 = Hleft[off] + scoreGapExtention
-					s2 = H[I+j0-1] + scoreGapExtention
+			} else {
-				} else {
+				s2 = Hleft[off] + scoreGapStart
-					s2 = H[I+j0-1] + scoreGapStart
-				}
 			}
 
-			if pattern[i] == T[j] {
+			if pchar == char {
-				var diag int16
+				s1 = Hdiag[off] + scoreMatch
-				if i > 0 && j0 > 0 {
+				b := Bsub[off]
-					diag = H[I-width+j0-1]
+				consecutive = Cdiag[off] + 1
-				}
+				// Break consecutive chunk
-				s1 = diag + scoreMatch
+				if b == bonusBoundary {
-				b := B[j]
-				if i > 0 {
-					// j > 0 if i > 0
-					consecutive = C[I-width+j0-1] + 1
-					// Break consecutive chunk
-					if b == bonusBoundary {
-						consecutive = 1
-					} else if consecutive > 1 {
-						b = util.Max16(b, util.Max16(bonusConsecutive, B[j-int(consecutive)+1]))
-					}
-				} else {
 					consecutive = 1
-					b *= bonusFirstCharMultiplier
+				} else if consecutive > 1 {
+					b = util.Max16(b, util.Max16(bonusConsecutive, B[col-int(consecutive)+1]))
 				}
 				if s1+b < s2 {
-					s1 += B[j]
+					s1 += Bsub[off]
 					consecutive = 0
 				} else {
 					s1 += b
 				}
 			}
-			C[I+j0] = consecutive
+			Csub[off] = consecutive
 
 			inGap = s1 < s2
 			score := util.Max16(util.Max16(s1, s2), 0)
-			if i == M-1 && (forward && score > maxScore || !forward && score >= maxScore) {
+			if pidx == M-1 && (forward && score > maxScore || !forward && score >= maxScore) {
-				maxScore, maxScorePos = score, j
+				maxScore, maxScorePos = score, col
 			}
-			H[I+j0] = score
+			Hsub[off] = score
-		}
-
-		if DEBUG {
-			if i == 0 {
-				fmt.Print("  ")
-				for j := int(F[i]); j <= lastIdx; j++ {
-					fmt.Printf(" " + string(input.Get(j)) + " ")
-				}
-				fmt.Println()
-			}
-			fmt.Print(string(pattern[i]) + " ")
-			for idx := int(F[0]); idx < int(F[i]); idx++ {
-				fmt.Print(" 0 ")
-			}
-			for idx := int(F[i]); idx <= lastIdx; idx++ {
-				fmt.Printf("%2d ", H[i*width+idx-int(F[0])])
-			}
-			fmt.Println()
-
-			fmt.Print("  ")
-			for idx, p := range C[I : I+width] {
-				if idx+int(F[0]) < int(F[i]) {
-					p = 0
-				}
-				fmt.Printf("%2d ", p)
-			}
-			fmt.Println()
 		}
 	}
 
-	// Phase 3. (Optional) Backtrace to find character positions
+	if DEBUG {
+		debugV2(T, pattern, F, lastIdx, H, C)
+	}
+
+	// Phase 4. (Optional) Backtrace to find character positions
 	pos := posArray(withPos, M)
-	j := int(F[0])
+	j := f0
 	if withPos {
 		i := M - 1
 		j = maxScorePos
 		preferMatch := true
 		for {
 			I := i * width
-			j0 := j - int(F[0])
+			j0 := j - f0
 			s := H[I+j0]
 
 			var s1, s2 int16
@@ -451,7 +552,7 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input util.C
 }
 
 // Implement the same sorting criteria as V2
-func calculateScore(caseSensitive bool, normalize bool, text util.Chars, pattern []rune, sidx int, eidx int, withPos bool) (int, *[]int) {
+func calculateScore(caseSensitive bool, normalize bool, text *util.Chars, pattern []rune, sidx int, eidx int, withPos bool) (int, *[]int) {
 	pidx, score, inGap, consecutive, firstBonus := 0, 0, false, 0, int16(0)
 	pos := posArray(withPos, len(pattern))
 	prevClass := charNonWord
@@ -511,10 +612,13 @@ func calculateScore(caseSensitive bool, normalize bool, text util.Chars, pattern
 }
 
 // FuzzyMatchV1 performs fuzzy-match
-func FuzzyMatchV1(caseSensitive bool, normalize bool, forward bool, text util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+func FuzzyMatchV1(caseSensitive bool, normalize bool, forward bool, text *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	if len(pattern) == 0 {
 		return Result{0, 0, 0}, nil
 	}
+	if asciiFuzzyIndex(text, pattern, caseSensitive) < 0 {
+		return Result{-1, -1, 0}, nil
+	}
 
 	pidx := 0
 	sidx := -1
@@ -594,7 +698,7 @@ func FuzzyMatchV1(caseSensitive bool, normalize bool, forward bool, text util.Ch
 // bonus point, instead of stopping immediately after finding the first match.
 // The solution is much cheaper since there is only one possible alignment of
 // the pattern.
-func ExactMatchNaive(caseSensitive bool, normalize bool, forward bool, text util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+func ExactMatchNaive(caseSensitive bool, normalize bool, forward bool, text *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	if len(pattern) == 0 {
 		return Result{0, 0, 0}, nil
 	}
@@ -606,6 +710,10 @@ func ExactMatchNaive(caseSensitive bool, normalize bool, forward bool, text util
 		return Result{-1, -1, 0}, nil
 	}
 
+	if asciiFuzzyIndex(text, pattern, caseSensitive) < 0 {
+		return Result{-1, -1, 0}, nil
+	}
+
 	// For simplicity, only look at the bonus at the first character position
 	pidx := 0
 	bestPos, bonus, bestBonus := -1, int16(0), int16(-1)
@@ -660,7 +768,7 @@ func ExactMatchNaive(caseSensitive bool, normalize bool, forward bool, text util
 }
 
 // PrefixMatch performs prefix-match
-func PrefixMatch(caseSensitive bool, normalize bool, forward bool, text util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+func PrefixMatch(caseSensitive bool, normalize bool, forward bool, text *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	if len(pattern) == 0 {
 		return Result{0, 0, 0}, nil
 	}
@@ -687,7 +795,7 @@ func PrefixMatch(caseSensitive bool, normalize bool, forward bool, text util.Cha
 }
 
 // SuffixMatch performs suffix-match
-func SuffixMatch(caseSensitive bool, normalize bool, forward bool, text util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+func SuffixMatch(caseSensitive bool, normalize bool, forward bool, text *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	lenRunes := text.Length()
 	trimmedLen := lenRunes - text.TrailingWhitespaces()
 	if len(pattern) == 0 {
@@ -718,7 +826,7 @@ func SuffixMatch(caseSensitive bool, normalize bool, forward bool, text util.Cha
 }
 
 // EqualMatch performs equal-match
-func EqualMatch(caseSensitive bool, normalize bool, forward bool, text util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+func EqualMatch(caseSensitive bool, normalize bool, forward bool, text *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	lenPattern := len(pattern)
 	if text.Length() != lenPattern {
 		return Result{-1, -1, 0}, nil

src/algo/algo_test.go

@@ -17,7 +17,8 @@ func assertMatch2(t *testing.T, fun Algo, caseSensitive, normalize, forward bool
 	if !caseSensitive {
 		pattern = strings.ToLower(pattern)
 	}
-	res, pos := fun(caseSensitive, normalize, forward, util.RunesToChars([]rune(input)), []rune(pattern), true, nil)
+	chars := util.ToChars([]byte(input))
+	res, pos := fun(caseSensitive, normalize, forward, &chars, []rune(pattern), true, nil)
 	var start, end int
 	if pos == nil || len(*pos) == 0 {
 		start = res.Start

src/ansi.go

@@ -44,7 +44,21 @@ func init() {
 	*/
 	// The following regular expression will include not all but most of the
 	// frequently used ANSI sequences
-	ansiRegex = regexp.MustCompile("\x1b[\\[()][0-9;]*[a-zA-Z@]|\x1b.|[\x0e\x0f]|.\x08")
+	ansiRegex = regexp.MustCompile("(?:\x1b[\\[()][0-9;]*[a-zA-Z@]|\x1b.|[\x0e\x0f]|.\x08)")
+}
+
+func findAnsiStart(str string) int {
+	idx := 0
+	for ; idx < len(str); idx++ {
+		b := str[idx]
+		if b == 0x1b || b == 0x0e || b == 0x0f {
+			return idx
+		}
+		if b == 0x08 && idx > 0 {
+			return idx - 1
+		}
+	}
+	return idx
 }
 
 func extractColor(str string, state *ansiState, proc func(string, *ansiState) bool) (string, *[]ansiOffset, *ansiState) {
@@ -55,50 +69,76 @@ func extractColor(str string, state *ansiState, proc func(string, *ansiState) bo
 		offsets = append(offsets, ansiOffset{[2]int32{0, 0}, *state})
 	}
 
-	idx := 0
+	prevIdx := 0
-	for _, offset := range ansiRegex.FindAllStringIndex(str, -1) {
+	runeCount := 0
-		prev := str[idx:offset[0]]
+	for idx := 0; idx < len(str); {
-		output.WriteString(prev)
+		idx += findAnsiStart(str[idx:])
+		if idx == len(str) {
+			break
+		}
+
+		// Make sure that we found an ANSI code
+		offset := ansiRegex.FindStringIndex(str[idx:])
+		if len(offset) < 2 {
+			idx++
+			continue
+		}
+		offset[0] += idx
+		offset[1] += idx
+		idx = offset[1]
+
+		// Check if we should continue
+		prev := str[prevIdx:offset[0]]
 		if proc != nil && !proc(prev, state) {
 			return "", nil, nil
 		}
-		newState := interpretCode(str[offset[0]:offset[1]], state)
 
+		prevIdx = offset[1]
+		runeCount += utf8.RuneCountInString(prev)
+		output.WriteString(prev)
+
+		newState := interpretCode(str[offset[0]:offset[1]], state)
 		if !newState.equals(state) {
 			if state != nil {
 				// Update last offset
-				(&offsets[len(offsets)-1]).offset[1] = int32(utf8.RuneCount(output.Bytes()))
+				(&offsets[len(offsets)-1]).offset[1] = int32(runeCount)
 			}
 
 			if newState.colored() {
 				// Append new offset
 				state = newState
-				newLen := int32(utf8.RuneCount(output.Bytes()))
+				offsets = append(offsets, ansiOffset{[2]int32{int32(runeCount), int32(runeCount)}, *state})
-				offsets = append(offsets, ansiOffset{[2]int32{newLen, newLen}, *state})
 			} else {
 				// Discard state
 				state = nil
 			}
 		}
-
-		idx = offset[1]
 	}
 
-	rest := str[idx:]
+	var rest string
-	if len(rest) > 0 {
+	var trimmed string
+
+	if prevIdx == 0 {
+		// No ANSI code found
+		rest = str
+		trimmed = str
+	} else {
+		rest = str[prevIdx:]
 		output.WriteString(rest)
-		if state != nil {
+		trimmed = output.String()
-			// Update last offset
+	}
-			(&offsets[len(offsets)-1]).offset[1] = int32(utf8.RuneCount(output.Bytes()))
+	if len(rest) > 0 && state != nil {
-		}
+		// Update last offset
+		runeCount += utf8.RuneCountInString(rest)
+		(&offsets[len(offsets)-1]).offset[1] = int32(runeCount)
 	}
 	if proc != nil {
 		proc(rest, state)
 	}
 	if len(offsets) == 0 {
-		return output.String(), nil, state
+		return trimmed, nil, state
 	}
-	return output.String(), &offsets, state
+	return trimmed, &offsets, state
 }
 
 func interpretCode(ansiCode string, prevState *ansiState) *ansiState {

src/cache.go

@@ -3,7 +3,7 @@ package fzf
 import "sync"
 
 // queryCache associates strings to lists of items
-type queryCache map[string][]*Result
+type queryCache map[string][]Result
 
 // ChunkCache associates Chunk and query string to lists of items
 type ChunkCache struct {
@@ -17,7 +17,7 @@ func NewChunkCache() ChunkCache {
 }
 
 // Add adds the list to the cache
-func (cc *ChunkCache) Add(chunk *Chunk, key string, list []*Result) {
+func (cc *ChunkCache) Add(chunk *Chunk, key string, list []Result) {
 	if len(key) == 0 || !chunk.IsFull() || len(list) > queryCacheMax {
 		return
 	}
@@ -33,10 +33,10 @@ func (cc *ChunkCache) Add(chunk *Chunk, key string, list []*Result) {
 	(*qc)[key] = list
 }
 
-// Find is called to lookup ChunkCache
+// Lookup is called to lookup ChunkCache
-func (cc *ChunkCache) Find(chunk *Chunk, key string) ([]*Result, bool) {
+func (cc *ChunkCache) Lookup(chunk *Chunk, key string) []Result {
 	if len(key) == 0 || !chunk.IsFull() {
-		return nil, false
+		return nil
 	}
 
 	cc.mutex.Lock()
@@ -46,8 +46,36 @@ func (cc *ChunkCache) Find(chunk *Chunk, key string) ([]*Result, bool) {
 	if ok {
 		list, ok := (*qc)[key]
 		if ok {
-			return list, true
+			return list
 		}
 	}
-	return nil, false
+	return nil
+}
+
+func (cc *ChunkCache) Search(chunk *Chunk, key string) []Result {
+	if len(key) == 0 || !chunk.IsFull() {
+		return nil
+	}
+
+	cc.mutex.Lock()
+	defer cc.mutex.Unlock()
+
+	qc, ok := cc.cache[chunk]
+	if !ok {
+		return nil
+	}
+
+	for idx := 1; idx < len(key); idx++ {
+		// [---------| ] | [ |---------]
+		// [--------|  ] | [  |--------]
+		// [-------|   ] | [   |-------]
+		prefix := key[:len(key)-idx]
+		suffix := key[idx:]
+		for _, substr := range [2]string{prefix, suffix} {
+			if cached, found := (*qc)[substr]; found {
+				return cached
+			}
+		}
+	}
+	return nil
 }

src/cache_test.go

@@ -4,37 +4,36 @@ import "testing"
 
 func TestChunkCache(t *testing.T) {
 	cache := NewChunkCache()
-	chunk2 := make(Chunk, chunkSize)
 	chunk1p := &Chunk{}
-	chunk2p := &chunk2
+	chunk2p := &Chunk{count: chunkSize}
-	items1 := []*Result{&Result{}}
+	items1 := []Result{Result{}}
-	items2 := []*Result{&Result{}, &Result{}}
+	items2 := []Result{Result{}, Result{}}
 	cache.Add(chunk1p, "foo", items1)
 	cache.Add(chunk2p, "foo", items1)
 	cache.Add(chunk2p, "bar", items2)
 
 	{ // chunk1 is not full
-		cached, found := cache.Find(chunk1p, "foo")
+		cached := cache.Lookup(chunk1p, "foo")
-		if found {
+		if cached != nil {
-			t.Error("Cached disabled for non-empty chunks", found, cached)
+			t.Error("Cached disabled for non-empty chunks", cached)
 		}
 	}
 	{
-		cached, found := cache.Find(chunk2p, "foo")
+		cached := cache.Lookup(chunk2p, "foo")
-		if !found || len(cached) != 1 {
+		if cached == nil || len(cached) != 1 {
-			t.Error("Expected 1 item cached", found, cached)
+			t.Error("Expected 1 item cached", cached)
 		}
 	}
 	{
-		cached, found := cache.Find(chunk2p, "bar")
+		cached := cache.Lookup(chunk2p, "bar")
-		if !found || len(cached) != 2 {
+		if cached == nil || len(cached) != 2 {
-			t.Error("Expected 2 items cached", found, cached)
+			t.Error("Expected 2 items cached", cached)
 		}
 	}
 	{
-		cached, found := cache.Find(chunk1p, "foobar")
+		cached := cache.Lookup(chunk1p, "foobar")
-		if found {
+		if cached != nil {
-			t.Error("Expected 0 item cached", found, cached)
+			t.Error("Expected 0 item cached", cached)
 		}
 	}
 }

src/chunklist.go

@@ -2,17 +2,18 @@ package fzf
 
 import "sync"
 
-// Chunk is a list of Item pointers whose size has the upper limit of chunkSize
+// Chunk is a list of Items whose size has the upper limit of chunkSize
-type Chunk []*Item // >>> []Item
+type Chunk struct {
+	items [chunkSize]Item
+	count int
+}
 
-// ItemBuilder is a closure type that builds Item object from a pointer to a
+// ItemBuilder is a closure type that builds Item object from byte array
-// string and an integer
+type ItemBuilder func(*Item, []byte) bool
-type ItemBuilder func([]byte, int) *Item
 
 // ChunkList is a list of Chunks
 type ChunkList struct {
 	chunks []*Chunk
-	count  int
 	mutex  sync.Mutex
 	trans  ItemBuilder
 }
@@ -21,15 +22,13 @@ type ChunkList struct {
 func NewChunkList(trans ItemBuilder) *ChunkList {
 	return &ChunkList{
 		chunks: []*Chunk{},
-		count:  0,
 		mutex:  sync.Mutex{},
 		trans:  trans}
 }
 
-func (c *Chunk) push(trans ItemBuilder, data []byte, index int) bool {
+func (c *Chunk) push(trans ItemBuilder, data []byte) bool {
-	item := trans(data, index)
+	if trans(&c.items[c.count], data) {
-	if item != nil {
+		c.count++
-		*c = append(*c, item)
 		return true
 	}
 	return false
@@ -37,7 +36,7 @@ func (c *Chunk) push(trans ItemBuilder, data []byte, index int) bool {
 
 // IsFull returns true if the Chunk is full
 func (c *Chunk) IsFull() bool {
-	return len(*c) == chunkSize
+	return c.count == chunkSize
 }
 
 func (cl *ChunkList) lastChunk() *Chunk {
@@ -49,45 +48,35 @@ func CountItems(cs []*Chunk) int {
 	if len(cs) == 0 {
 		return 0
 	}
-	return chunkSize*(len(cs)-1) + len(*(cs[len(cs)-1]))
+	return chunkSize*(len(cs)-1) + cs[len(cs)-1].count
 }
 
 // Push adds the item to the list
 func (cl *ChunkList) Push(data []byte) bool {
 	cl.mutex.Lock()
-	defer cl.mutex.Unlock()
 
 	if len(cl.chunks) == 0 || cl.lastChunk().IsFull() {
-		newChunk := Chunk(make([]*Item, 0, chunkSize))
+		cl.chunks = append(cl.chunks, &Chunk{})
-		cl.chunks = append(cl.chunks, &newChunk)
 	}
 
-	if cl.lastChunk().push(cl.trans, data, cl.count) {
+	ret := cl.lastChunk().push(cl.trans, data)
-		cl.count++
+	cl.mutex.Unlock()
-		return true
+	return ret
-	}
-	return false
 }
 
 // Snapshot returns immutable snapshot of the ChunkList
 func (cl *ChunkList) Snapshot() ([]*Chunk, int) {
 	cl.mutex.Lock()
-	defer cl.mutex.Unlock()
 
 	ret := make([]*Chunk, len(cl.chunks))
 	copy(ret, cl.chunks)
 
 	// Duplicate the last chunk
 	if cnt := len(ret); cnt > 0 {
-		ret[cnt-1] = ret[cnt-1].dupe()
+		newChunk := *ret[cnt-1]
+		ret[cnt-1] = &newChunk
 	}
-	return ret, cl.count
-}
 
-func (c *Chunk) dupe() *Chunk {
+	cl.mutex.Unlock()
-	newChunk := make(Chunk, len(*c))
+	return ret, CountItems(ret)
-	for idx, ptr := range *c {
-		newChunk[idx] = ptr
-	}
-	return &newChunk
 }

src/chunklist_test.go

@@ -11,8 +11,9 @@ func TestChunkList(t *testing.T) {
 	// FIXME global
 	sortCriteria = []criterion{byScore, byLength}
 
-	cl := NewChunkList(func(s []byte, i int) *Item {
+	cl := NewChunkList(func(item *Item, s []byte) bool {
-		return &Item{text: util.ToChars(s), index: int32(i * 2)}
+		item.text = util.ToChars(s)
+		return true
 	})
 
 	// Snapshot
@@ -38,11 +39,11 @@ func TestChunkList(t *testing.T) {
 
 	// Check the content of the ChunkList
 	chunk1 := snapshot[0]
-	if len(*chunk1) != 2 {
+	if chunk1.count != 2 {
 		t.Error("Snapshot should contain only two items")
 	}
-	if (*chunk1)[0].text.ToString() != "hello" || (*chunk1)[0].index != 0 ||
+	if chunk1.items[0].text.ToString() != "hello" ||
-		(*chunk1)[1].text.ToString() != "world" || (*chunk1)[1].index != 2 {
+		chunk1.items[1].text.ToString() != "world" {
 		t.Error("Invalid data")
 	}
 	if chunk1.IsFull() {
@@ -65,14 +66,14 @@ func TestChunkList(t *testing.T) {
 		!snapshot[1].IsFull() || snapshot[2].IsFull() || count != chunkSize*2+2 {
 		t.Error("Expected two full chunks and one more chunk")
 	}
-	if len(*snapshot[2]) != 2 {
+	if snapshot[2].count != 2 {
 		t.Error("Unexpected number of items")
 	}
 
 	cl.Push([]byte("hello"))
 	cl.Push([]byte("world"))
 
-	lastChunkCount := len(*snapshot[len(snapshot)-1])
+	lastChunkCount := snapshot[len(snapshot)-1].count
 	if lastChunkCount != 2 {
 		t.Error("Unexpected number of items:", lastChunkCount)
 	}

src/constants.go

@@ -9,14 +9,17 @@ import (
 
 const (
 	// Current version
-	version = "0.16.8"
+	version = "0.17.3"
 
 	// Core
 	coordinatorDelayMax  time.Duration = 100 * time.Millisecond
 	coordinatorDelayStep time.Duration = 10 * time.Millisecond
 
 	// Reader
-	readerBufferSize = 64 * 1024
+	readerBufferSize       = 64 * 1024
+	readerPollIntervalMin  = 10 * time.Millisecond
+	readerPollIntervalStep = 5 * time.Millisecond
+	readerPollIntervalMax  = 50 * time.Millisecond
 
 	// Terminal
 	initialDelay    = 20 * time.Millisecond
@@ -52,7 +55,7 @@ var defaultCommand string
 
 func init() {
 	if !util.IsWindows() {
-		defaultCommand = `command find -L . -mindepth 1 \( -path '*/\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \) -prune -o -type f -print -o -type l -print 2> /dev/null | cut -b3-`
+		defaultCommand = `set -o pipefail; command find -L . -mindepth 1 \( -path '*/\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \) -prune -o -type f -print -o -type l -print 2> /dev/null | cut -b3-`
 	} else if os.Getenv("TERM") == "cygwin" {
 		defaultCommand = `sh -c "command find -L . -mindepth 1 -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null | cut -b3-"`
 	} else {
@@ -68,7 +71,7 @@ const (
 	EvtSearchProgress
 	EvtSearchFin
 	EvtHeader
-	EvtClose
+	EvtReady
 )
 
 const (

src/core.go

@@ -63,76 +63,64 @@ func Run(opts *Options, revision string) {
 	ansiProcessor := func(data []byte) (util.Chars, *[]ansiOffset) {
 		return util.ToChars(data), nil
 	}
-	ansiProcessorRunes := func(data []rune) (util.Chars, *[]ansiOffset) {
-		return util.RunesToChars(data), nil
-	}
 	if opts.Ansi {
 		if opts.Theme != nil {
 			var state *ansiState
 			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
 				trimmed, offsets, newState := extractColor(string(data), state, nil)
 				state = newState
-				return util.RunesToChars([]rune(trimmed)), offsets
+				return util.ToChars([]byte(trimmed)), offsets
 			}
 		} else {
 			// When color is disabled but ansi option is given,
 			// we simply strip out ANSI codes from the input
 			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
 				trimmed, _, _ := extractColor(string(data), nil, nil)
-				return util.RunesToChars([]rune(trimmed)), nil
+				return util.ToChars([]byte(trimmed)), nil
 			}
 		}
-		ansiProcessorRunes = func(data []rune) (util.Chars, *[]ansiOffset) {
-			return ansiProcessor([]byte(string(data)))
-		}
 	}
 
 	// Chunk list
 	var chunkList *ChunkList
+	var itemIndex int32
 	header := make([]string, 0, opts.HeaderLines)
 	if len(opts.WithNth) == 0 {
-		chunkList = NewChunkList(func(data []byte, index int) *Item {
+		chunkList = NewChunkList(func(item *Item, data []byte) bool {
 			if len(header) < opts.HeaderLines {
 				header = append(header, string(data))
 				eventBox.Set(EvtHeader, header)
-				return nil
+				return false
 			}
-			chars, colors := ansiProcessor(data)
+			item.text, item.colors = ansiProcessor(data)
-			return &Item{
+			item.text.Index = itemIndex
-				index:      int32(index),
+			itemIndex++
-				trimLength: -1,
+			return true
-				text:       chars,
-				colors:     colors}
 		})
 	} else {
-		chunkList = NewChunkList(func(data []byte, index int) *Item {
+		chunkList = NewChunkList(func(item *Item, data []byte) bool {
-			tokens := Tokenize(util.ToChars(data), opts.Delimiter)
+			tokens := Tokenize(string(data), opts.Delimiter)
 			trans := Transform(tokens, opts.WithNth)
+			transformed := joinTokens(trans)
 			if len(header) < opts.HeaderLines {
-				header = append(header, string(joinTokens(trans)))
+				header = append(header, transformed)
 				eventBox.Set(EvtHeader, header)
-				return nil
+				return false
 			}
-			textRunes := joinTokens(trans)
+			item.text, item.colors = ansiProcessor([]byte(transformed))
-			item := Item{
+			item.text.Index = itemIndex
-				index:      int32(index),
+			item.origText = &data
-				trimLength: -1,
+			itemIndex++
-				origText:   &data,
+			return true
-				colors:     nil}
-
-			trimmed, colors := ansiProcessorRunes(textRunes)
-			item.text = trimmed
-			item.colors = colors
-			return &item
 		})
 	}
 
 	// Reader
 	streamingFilter := opts.Filter != nil && !sort && !opts.Tac && !opts.Sync
 	if !streamingFilter {
-		reader := Reader{func(data []byte) bool {
+		reader := NewReader(func(data []byte) bool {
 			return chunkList.Push(data)
-		}, eventBox, opts.ReadZero}
+		}, eventBox, opts.ReadZero)
 		go reader.ReadSource()
 	}
 
@@ -165,17 +153,17 @@ func Run(opts *Options, revision string) {
 		found := false
 		if streamingFilter {
 			slab := util.MakeSlab(slab16Size, slab32Size)
-			reader := Reader{
+			reader := NewReader(
 				func(runes []byte) bool {
-					item := chunkList.trans(runes, 0)
+					item := Item{}
-					if item != nil {
+					if chunkList.trans(&item, runes) {
-						if result, _, _ := pattern.MatchItem(item, false, slab); result != nil {
+						if result, _, _ := pattern.MatchItem(&item, false, slab); result != nil {
 							opts.Printer(item.text.ToString())
 							found = true
 						}
 					}
 					return false
-				}, eventBox, opts.ReadZero}
+				}, eventBox, opts.ReadZero)
 			reader.ReadSource()
 		} else {
 			eventBox.Unwatch(EvtReadNew)
@@ -221,14 +209,19 @@ func Run(opts *Options, revision string) {
 		delay := true
 		ticks++
 		eventBox.Wait(func(events *util.Events) {
-			defer events.Clear()
+			if _, fin := (*events)[EvtReadFin]; fin {
+				delete(*events, EvtReadNew)
+			}
 			for evt, value := range *events {
 				switch evt {
 
 				case EvtReadNew, EvtReadFin:
 					reading = reading && evt == EvtReadNew
 					snapshot, count := chunkList.Snapshot()
-					terminal.UpdateCount(count, !reading)
+					terminal.UpdateCount(count, !reading, value.(bool))
+					if opts.Sync {
+						terminal.UpdateList(PassMerger(&snapshot, opts.Tac))
+					}
 					matcher.Reset(snapshot, terminal.Input(), false, !reading, sort)
 
 				case EvtSearchNew:
@@ -281,6 +274,7 @@ func Run(opts *Options, revision string) {
 					}
 				}
 			}
+			events.Clear()
 		})
 		if delay && reading {
 			dur := util.DurWithin(

src/item.go

@@ -4,27 +4,23 @@ import (
 	"github.com/junegunn/fzf/src/util"
 )
 
-// Item represents each input line
+// Item represents each input line. 56 bytes.
 type Item struct {
-	index       int32
+	text        util.Chars    // 32 = 24 + 1 + 1 + 2 + 4
-	trimLength  int32
+	transformed *[]Token      // 8
-	text        util.Chars
+	origText    *[]byte       // 8
-	origText    *[]byte
+	colors      *[]ansiOffset // 8
-	colors      *[]ansiOffset
-	transformed []Token
 }
 
 // Index returns ordinal index of the Item
 func (item *Item) Index() int32 {
-	return item.index
+	return item.text.Index
 }
 
-func (item *Item) TrimLength() int32 {
+var minItem = Item{text: util.Chars{Index: -1}}
-	if item.trimLength >= 0 {
+
-		return item.trimLength
+func (item *Item) TrimLength() uint16 {
-	}
+	return item.text.TrimLength()
-	item.trimLength = int32(item.text.TrimLength())
-	return item.trimLength
 }
 
 // Colors returns ansiOffsets of the Item

src/matcher.go

@@ -131,7 +131,7 @@ func (m *Matcher) sliceChunks(chunks []*Chunk) [][]*Chunk {
 
 type partialResult struct {
 	index   int
-	matches []*Result
+	matches []Result
 }
 
 func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
@@ -162,7 +162,7 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 		go func(idx int, slab *util.Slab, chunks []*Chunk) {
 			defer func() { waitGroup.Done() }()
 			count := 0
-			allMatches := make([][]*Result, len(chunks))
+			allMatches := make([][]Result, len(chunks))
 			for idx, chunk := range chunks {
 				matches := request.pattern.Match(chunk, slab)
 				allMatches[idx] = matches
@@ -172,7 +172,7 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 				}
 				countChan <- len(matches)
 			}
-			sliceMatches := make([]*Result, 0, count)
+			sliceMatches := make([]Result, 0, count)
 			for _, matches := range allMatches {
 				sliceMatches = append(sliceMatches, matches...)
 			}
@@ -212,7 +212,7 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 		}
 	}
 
-	partialResults := make([][]*Result, numSlices)
+	partialResults := make([][]Result, numSlices)
 	for _ = range slices {
 		partialResult := <-resultChan
 		partialResults[partialResult.index] = partialResult.matches

src/merger.go

@@ -3,14 +3,14 @@ package fzf
 import "fmt"
 
 // EmptyMerger is a Merger with no data
-var EmptyMerger = NewMerger(nil, [][]*Result{}, false, false)
+var EmptyMerger = NewMerger(nil, [][]Result{}, false, false)
 
 // Merger holds a set of locally sorted lists of items and provides the view of
 // a single, globally-sorted list
 type Merger struct {
 	pattern *Pattern
-	lists   [][]*Result
+	lists   [][]Result
-	merged  []*Result
+	merged  []Result
 	chunks  *[]*Chunk
 	cursors []int
 	sorted  bool
@@ -29,17 +29,17 @@ func PassMerger(chunks *[]*Chunk, tac bool) *Merger {
 		count:   0}
 
 	for _, chunk := range *mg.chunks {
-		mg.count += len(*chunk)
+		mg.count += chunk.count
 	}
 	return &mg
 }
 
 // NewMerger returns a new Merger
-func NewMerger(pattern *Pattern, lists [][]*Result, sorted bool, tac bool) *Merger {
+func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool) *Merger {
 	mg := Merger{
 		pattern: pattern,
 		lists:   lists,
-		merged:  []*Result{},
+		merged:  []Result{},
 		chunks:  nil,
 		cursors: make([]int, len(lists)),
 		sorted:  sorted,
@@ -59,13 +59,13 @@ func (mg *Merger) Length() int {
 }
 
 // Get returns the pointer to the Result object indexed by the given integer
-func (mg *Merger) Get(idx int) *Result {
+func (mg *Merger) Get(idx int) Result {
 	if mg.chunks != nil {
 		if mg.tac {
 			idx = mg.count - idx - 1
 		}
 		chunk := (*mg.chunks)[idx/chunkSize]
-		return &Result{item: (*chunk)[idx%chunkSize]}
+		return Result{item: &chunk.items[idx%chunkSize]}
 	}
 
 	if mg.sorted {
@@ -89,7 +89,7 @@ func (mg *Merger) cacheable() bool {
 	return mg.count < mergerCacheMax
 }
 
-func (mg *Merger) mergedGet(idx int) *Result {
+func (mg *Merger) mergedGet(idx int) Result {
 	for i := len(mg.merged); i <= idx; i++ {
 		minRank := minRank()
 		minIdx := -1
@@ -100,7 +100,7 @@ func (mg *Merger) mergedGet(idx int) *Result {
 				continue
 			}
 			if cursor >= 0 {
-				rank := list[cursor].rank
+				rank := list[cursor]
 				if minIdx < 0 || compareRanks(rank, minRank, mg.tac) {
 					minRank = rank
 					minIdx = listIdx

src/merger_test.go

@@ -15,11 +15,11 @@ func assert(t *testing.T, cond bool, msg ...string) {
 	}
 }
 
-func randResult() *Result {
+func randResult() Result {
 	str := fmt.Sprintf("%d", rand.Uint32())
-	return &Result{
+	chars := util.ToChars([]byte(str))
-		item: &Item{text: util.RunesToChars([]rune(str))},
+	chars.Index = rand.Int31()
-		rank: rank{index: rand.Int31()}}
+	return Result{item: &Item{text: chars}}
 }
 
 func TestEmptyMerger(t *testing.T) {
@@ -29,14 +29,14 @@ func TestEmptyMerger(t *testing.T) {
 	assert(t, len(EmptyMerger.merged) == 0, "Invalid merged list")
 }
 
-func buildLists(partiallySorted bool) ([][]*Result, []*Result) {
+func buildLists(partiallySorted bool) ([][]Result, []Result) {
 	numLists := 4
-	lists := make([][]*Result, numLists)
+	lists := make([][]Result, numLists)
 	cnt := 0
 	for i := 0; i < numLists; i++ {
 		numResults := rand.Int() % 20
 		cnt += numResults
-		lists[i] = make([]*Result, numResults)
+		lists[i] = make([]Result, numResults)
 		for j := 0; j < numResults; j++ {
 			item := randResult()
 			lists[i][j] = item
@@ -45,7 +45,7 @@ func buildLists(partiallySorted bool) ([][]*Result, []*Result) {
 			sort.Sort(ByRelevance(lists[i]))
 		}
 	}
-	items := []*Result{}
+	items := []Result{}
 	for _, list := range lists {
 		items = append(items, list...)
 	}

src/options.go

@@ -430,6 +430,10 @@ func parseKeyChords(str string, message string) map[int]string {
 			chord = tui.SLeft
 		case "shift-right":
 			chord = tui.SRight
+		case "left-click":
+			chord = tui.LeftClick
+		case "right-click":
+			chord = tui.RightClick
 		case "double-click":
 			chord = tui.DoubleClick
 		case "f10":
@@ -658,8 +662,12 @@ func parseKeymap(keymap map[int][]action, str string) {
 				appendAction(actAbort)
 			case "accept":
 				appendAction(actAccept)
+			case "accept-non-empty":
+				appendAction(actAcceptNonEmpty)
 			case "print-query":
 				appendAction(actPrintQuery)
+			case "replace-query":
+				appendAction(actReplaceQuery)
 			case "backward-char":
 				appendAction(actBackwardChar)
 			case "backward-delete-char":
@@ -833,9 +841,6 @@ func parseSize(str string, maxPercent float64, label string) sizeSpec {
 }
 
 func parseHeight(str string) sizeSpec {
-	if util.IsWindows() {
-		errorExit("--height options is currently not supported on Windows")
-	}
 	size := parseSize(str, 100, "height")
 	return size
 }
@@ -962,7 +967,11 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "--algo":
 			opts.FuzzyAlgo = parseAlgo(nextString(allArgs, &i, "algorithm required (v1|v2)"))
 		case "--expect":
-			opts.Expect = parseKeyChords(nextString(allArgs, &i, "key names required"), "key names required")
+			for k, v := range parseKeyChords(nextString(allArgs, &i, "key names required"), "key names required") {
+				opts.Expect[k] = v
+			}
+		case "--no-expect":
+			opts.Expect = make(map[int]string)
 		case "--tiebreak":
 			opts.Criteria = parseTiebreak(nextString(allArgs, &i, "sort criterion required"))
 		case "--bind":
@@ -1138,7 +1147,9 @@ func parseOptions(opts *Options, allArgs []string) {
 			} else if match, value := optString(arg, "--toggle-sort="); match {
 				parseToggleSort(opts.Keymap, value)
 			} else if match, value := optString(arg, "--expect="); match {
-				opts.Expect = parseKeyChords(value, "key names required")
+				for k, v := range parseKeyChords(value, "key names required") {
+					opts.Expect[k] = v
+				}
 			} else if match, value := optString(arg, "--tiebreak="); match {
 				opts.Criteria = parseTiebreak(value)
 			} else if match, value := optString(arg, "--color="); match {
@@ -1197,6 +1208,9 @@ func parseOptions(opts *Options, allArgs []string) {
 }
 
 func postProcessOptions(opts *Options) {
+	if util.IsWindows() && opts.Height.size > 0 {
+		errorExit("--height option is currently not supported on Windows")
+	}
 	// Default actions for CTRL-N / CTRL-P when --history is set
 	if opts.History != nil {
 		if _, prs := opts.Keymap[tui.CtrlP]; !prs {

src/options_test.go

@@ -6,7 +6,6 @@ import (
 	"testing"
 
 	"github.com/junegunn/fzf/src/tui"
-	"github.com/junegunn/fzf/src/util"
 )
 
 func TestDelimiterRegex(t *testing.T) {
@@ -44,7 +43,7 @@ func TestDelimiterRegex(t *testing.T) {
 
 func TestDelimiterRegexString(t *testing.T) {
 	delim := delimiterRegexp("*")
-	tokens := Tokenize(util.RunesToChars([]rune("-*--*---**---")), delim)
+	tokens := Tokenize("-*--*---**---", delim)
 	if delim.regex != nil ||
 		tokens[0].text.ToString() != "-*" ||
 		tokens[1].text.ToString() != "--*" ||
@@ -57,7 +56,7 @@ func TestDelimiterRegexString(t *testing.T) {
 
 func TestDelimiterRegexRegex(t *testing.T) {
 	delim := delimiterRegexp("--\\*")
-	tokens := Tokenize(util.RunesToChars([]rune("-*--*---**---")), delim)
+	tokens := Tokenize("-*--*---**---", delim)
 	if delim.str != nil ||
 		tokens[0].text.ToString() != "-*--*" ||
 		tokens[1].text.ToString() != "---*" ||
@@ -415,3 +414,10 @@ func TestPreviewOpts(t *testing.T) {
 		t.Error(opts.Preview)
 	}
 }
+
+func TestAdditiveExpect(t *testing.T) {
+	opts := optsFor("--expect=a", "--expect", "b", "--expect=c")
+	if len(opts.Expect) != 3 {
+		t.Error(opts.Expect)
+	}
+}

src/pattern.go

@@ -10,12 +10,12 @@ import (
 
 // fuzzy
 // 'exact
-// ^exact-prefix
+// ^prefix-exact
-// exact-suffix$
+// suffix-exact$
-// !not-fuzzy
+// !inverse-exact
-// !'not-exact
+// !'inverse-fuzzy
-// !^not-exact-prefix
+// !^inverse-prefix-exact
-// !not-exact-suffix$
+// !inverse-suffix-exact$
 
 type termType int
 
@@ -32,7 +32,6 @@ type term struct {
 	inv           bool
 	text          []rune
 	caseSensitive bool
-	origText      []rune
 }
 
 type termSet []term
@@ -48,6 +47,7 @@ type Pattern struct {
 	text          []rune
 	termSets      []termSet
 	cacheable     bool
+	cacheKey      string
 	delimiter     Delimiter
 	nth           []Range
 	procFun       map[termType]algo.Algo
@@ -60,7 +60,7 @@ var (
 )
 
 func init() {
-	_splitRegex = regexp.MustCompile("\\s+")
+	_splitRegex = regexp.MustCompile(" +")
 	clearPatternCache()
 	clearChunkCache()
 }
@@ -81,7 +81,10 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 
 	var asString string
 	if extended {
-		asString = strings.Trim(string(runes), " ")
+		asString = strings.TrimLeft(string(runes), " ")
+		for strings.HasSuffix(asString, " ") && !strings.HasSuffix(asString, "\\ ") {
+			asString = asString[:len(asString)-1]
+		}
 	} else {
 		asString = string(runes)
 	}
@@ -101,7 +104,7 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 			for idx, term := range termSet {
 				// If the query contains inverse search terms or OR operators,
 				// we cannot cache the search scope
-				if !cacheable || idx > 0 || term.inv || !fuzzy && term.typ != termExact {
+				if !cacheable || idx > 0 || term.inv || fuzzy && term.typ != termFuzzy || !fuzzy && term.typ != termExact {
 					cacheable = false
 					break Loop
 				}
@@ -130,6 +133,7 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 		delimiter:     delimiter,
 		procFun:       make(map[termType]algo.Algo)}
 
+	ptr.cacheKey = ptr.buildCacheKey()
 	ptr.procFun[termFuzzy] = fuzzyAlgo
 	ptr.procFun[termEqual] = algo.EqualMatch
 	ptr.procFun[termExact] = algo.ExactMatchNaive
@@ -141,27 +145,30 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 }
 
 func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet {
+	str = strings.Replace(str, "\\ ", "\t", -1)
 	tokens := _splitRegex.Split(str, -1)
 	sets := []termSet{}
 	set := termSet{}
 	switchSet := false
+	afterBar := false
 	for _, token := range tokens {
-		typ, inv, text := termFuzzy, false, token
+		typ, inv, text := termFuzzy, false, strings.Replace(token, "\t", " ", -1)
 		lowerText := strings.ToLower(text)
 		caseSensitive := caseMode == CaseRespect ||
 			caseMode == CaseSmart && text != lowerText
 		if !caseSensitive {
 			text = lowerText
 		}
-		origText := []rune(text)
 		if !fuzzy {
 			typ = termExact
 		}
 
-		if text == "|" {
+		if len(set) > 0 && !afterBar && text == "|" {
 			switchSet = false
+			afterBar = true
 			continue
 		}
+		afterBar = false
 
 		if strings.HasPrefix(text, "!") {
 			inv = true
@@ -169,6 +176,11 @@ func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet
 			text = text[1:]
 		}
 
+		if text != "$" && strings.HasSuffix(text, "$") {
+			typ = termSuffix
+			text = text[:len(text)-1]
+		}
+
 		if strings.HasPrefix(text, "'") {
 			// Flip exactness
 			if fuzzy && !inv {
@@ -179,16 +191,12 @@ func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet
 				text = text[1:]
 			}
 		} else if strings.HasPrefix(text, "^") {
-			if strings.HasSuffix(text, "$") {
+			if typ == termSuffix {
 				typ = termEqual
-				text = text[1 : len(text)-1]
 			} else {
 				typ = termPrefix
-				text = text[1:]
 			}
-		} else if strings.HasSuffix(text, "$") {
+			text = text[1:]
-			typ = termSuffix
-			text = text[:len(text)-1]
 		}
 
 		if len(text) > 0 {
@@ -204,8 +212,7 @@ func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet
 				typ:           typ,
 				inv:           inv,
 				text:          textRunes,
-				caseSensitive: caseSensitive,
+				caseSensitive: caseSensitive})
-				origText:      origText})
 			switchSet = true
 		}
 	}
@@ -228,46 +235,36 @@ func (p *Pattern) AsString() string {
 	return string(p.text)
 }
 
-// CacheKey is used to build string to be used as the key of result cache
+func (p *Pattern) buildCacheKey() string {
-func (p *Pattern) CacheKey() string {
 	if !p.extended {
 		return p.AsString()
 	}
 	cacheableTerms := []string{}
 	for _, termSet := range p.termSets {
 		if len(termSet) == 1 && !termSet[0].inv && (p.fuzzy || termSet[0].typ == termExact) {
-			cacheableTerms = append(cacheableTerms, string(termSet[0].origText))
+			cacheableTerms = append(cacheableTerms, string(termSet[0].text))
 		}
 	}
-	return strings.Join(cacheableTerms, " ")
+	return strings.Join(cacheableTerms, "\t")
+}
+
+// CacheKey is used to build string to be used as the key of result cache
+func (p *Pattern) CacheKey() string {
+	return p.cacheKey
 }
 
 // Match returns the list of matches Items in the given Chunk
-func (p *Pattern) Match(chunk *Chunk, slab *util.Slab) []*Result {
+func (p *Pattern) Match(chunk *Chunk, slab *util.Slab) []Result {
 	// ChunkCache: Exact match
 	cacheKey := p.CacheKey()
 	if p.cacheable {
-		if cached, found := _cache.Find(chunk, cacheKey); found {
+		if cached := _cache.Lookup(chunk, cacheKey); cached != nil {
 			return cached
 		}
 	}
 
 	// Prefix/suffix cache
-	var space []*Result
+	space := _cache.Search(chunk, cacheKey)
-Loop:
-	for idx := 1; idx < len(cacheKey); idx++ {
-		// [---------| ] | [ |---------]
-		// [--------|  ] | [  |--------]
-		// [-------|   ] | [   |-------]
-		prefix := cacheKey[:len(cacheKey)-idx]
-		suffix := cacheKey[idx:]
-		for _, substr := range [2]*string{&prefix, &suffix} {
-			if cached, found := _cache.Find(chunk, *substr); found {
-				space = cached
-				break Loop
-			}
-		}
-	}
 
 	matches := p.matchChunk(chunk, space, slab)
 
@@ -277,19 +274,19 @@ Loop:
 	return matches
 }
 
-func (p *Pattern) matchChunk(chunk *Chunk, space []*Result, slab *util.Slab) []*Result {
+func (p *Pattern) matchChunk(chunk *Chunk, space []Result, slab *util.Slab) []Result {
-	matches := []*Result{}
+	matches := []Result{}
 
 	if space == nil {
-		for _, item := range *chunk {
+		for idx := 0; idx < chunk.count; idx++ {
-			if match, _, _ := p.MatchItem(item, false, slab); match != nil {
+			if match, _, _ := p.MatchItem(&chunk.items[idx], false, slab); match != nil {
-				matches = append(matches, match)
+				matches = append(matches, *match)
 			}
 		}
 	} else {
 		for _, result := range space {
 			if match, _, _ := p.MatchItem(result.item, false, slab); match != nil {
-				matches = append(matches, match)
+				matches = append(matches, *match)
 			}
 		}
 	}
@@ -300,20 +297,27 @@ func (p *Pattern) matchChunk(chunk *Chunk, space []*Result, slab *util.Slab) []*
 func (p *Pattern) MatchItem(item *Item, withPos bool, slab *util.Slab) (*Result, []Offset, *[]int) {
 	if p.extended {
 		if offsets, bonus, pos := p.extendedMatch(item, withPos, slab); len(offsets) == len(p.termSets) {
-			return buildResult(item, offsets, bonus), offsets, pos
+			result := buildResult(item, offsets, bonus)
+			return &result, offsets, pos
 		}
 		return nil, nil, nil
 	}
 	offset, bonus, pos := p.basicMatch(item, withPos, slab)
 	if sidx := offset[0]; sidx >= 0 {
 		offsets := []Offset{offset}
-		return buildResult(item, offsets, bonus), offsets, pos
+		result := buildResult(item, offsets, bonus)
+		return &result, offsets, pos
 	}
 	return nil, nil, nil
 }
 
 func (p *Pattern) basicMatch(item *Item, withPos bool, slab *util.Slab) (Offset, int, *[]int) {
-	input := p.prepareInput(item)
+	var input []Token
+	if len(p.nth) == 0 {
+		input = []Token{Token{text: &item.text, prefixLength: 0}}
+	} else {
+		input = p.transformInput(item)
+	}
 	if p.fuzzy {
 		return p.iter(p.fuzzyAlgo, input, p.caseSensitive, p.normalize, p.forward, p.text, withPos, slab)
 	}
@@ -321,7 +325,12 @@ func (p *Pattern) basicMatch(item *Item, withPos bool, slab *util.Slab) (Offset,
 }
 
 func (p *Pattern) extendedMatch(item *Item, withPos bool, slab *util.Slab) ([]Offset, int, *[]int) {
-	input := p.prepareInput(item)
+	var input []Token
+	if len(p.nth) == 0 {
+		input = []Token{Token{text: &item.text, prefixLength: 0}}
+	} else {
+		input = p.transformInput(item)
+	}
 	offsets := []Offset{}
 	var totalScore int
 	var allPos *[]int
@@ -365,25 +374,20 @@ func (p *Pattern) extendedMatch(item *Item, withPos bool, slab *util.Slab) ([]Of
 	return offsets, totalScore, allPos
 }
 
-func (p *Pattern) prepareInput(item *Item) []Token {
+func (p *Pattern) transformInput(item *Item) []Token {
 	if item.transformed != nil {
-		return item.transformed
+		return *item.transformed
 	}
 
-	var ret []Token
+	tokens := Tokenize(item.text.ToString(), p.delimiter)
-	if len(p.nth) == 0 {
+	ret := Transform(tokens, p.nth)
-		ret = []Token{Token{text: &item.text, prefixLength: 0}}
+	item.transformed = &ret
-	} else {
-		tokens := Tokenize(item.text, p.delimiter)
-		ret = Transform(tokens, p.nth)
-	}
-	item.transformed = ret
 	return ret
 }
 
 func (p *Pattern) iter(pfun algo.Algo, tokens []Token, caseSensitive bool, normalize bool, forward bool, pattern []rune, withPos bool, slab *util.Slab) (Offset, int, *[]int) {
 	for _, part := range tokens {
-		if res, pos := pfun(caseSensitive, normalize, forward, *part.text, pattern, withPos, slab); res.Start >= 0 {
+		if res, pos := pfun(caseSensitive, normalize, forward, part.text, pattern, withPos, slab); res.Start >= 0 {
 			sidx := int32(res.Start) + part.prefixLength
 			eidx := int32(res.End) + part.prefixLength
 			if pos != nil {

src/pattern_test.go

@@ -16,7 +16,7 @@ func init() {
 
 func TestParseTermsExtended(t *testing.T) {
 	terms := parseTerms(true, CaseSmart, false,
-		"| aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$ | ^iii$ ^xxx | 'yyy | | zzz$ | !ZZZ |")
+		"aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$ | ^iii$ ^xxx | 'yyy | zzz$ | !ZZZ |")
 	if len(terms) != 9 ||
 		terms[0][0].typ != termFuzzy || terms[0][0].inv ||
 		terms[1][0].typ != termExact || terms[1][0].inv ||
@@ -33,19 +33,11 @@ func TestParseTermsExtended(t *testing.T) {
 		terms[8][3].typ != termExact || !terms[8][3].inv {
 		t.Errorf("%s", terms)
 	}
-	for idx, termSet := range terms[:8] {
+	for _, termSet := range terms[:8] {
 		term := termSet[0]
 		if len(term.text) != 3 {
 			t.Errorf("%s", term)
 		}
-		if idx > 0 && len(term.origText) != 4+idx/5 {
-			t.Errorf("%s", term)
-		}
-	}
-	for _, term := range terms[8] {
-		if len(term.origText) != 4 {
-			t.Errorf("%s", term)
-		}
 	}
 }
 
@@ -66,7 +58,7 @@ func TestParseTermsExtendedExact(t *testing.T) {
 }
 
 func TestParseTermsEmpty(t *testing.T) {
-	terms := parseTerms(true, CaseSmart, false, "' $ ^ !' !^ !$")
+	terms := parseTerms(true, CaseSmart, false, "' ^ !' !^")
 	if len(terms) != 0 {
 		t.Errorf("%s", terms)
 	}
@@ -77,8 +69,9 @@ func TestExact(t *testing.T) {
 	clearPatternCache()
 	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true,
 		[]Range{}, Delimiter{}, []rune("'abc"))
+	chars := util.ToChars([]byte("aabbcc abc"))
 	res, pos := algo.ExactMatchNaive(
-		pattern.caseSensitive, pattern.normalize, pattern.forward, util.RunesToChars([]rune("aabbcc abc")), pattern.termSets[0][0].text, true, nil)
+		pattern.caseSensitive, pattern.normalize, pattern.forward, &chars, pattern.termSets[0][0].text, true, nil)
 	if res.Start != 7 || res.End != 10 {
 		t.Errorf("%s / %d / %d", pattern.termSets, res.Start, res.End)
 	}
@@ -93,8 +86,9 @@ func TestEqual(t *testing.T) {
 	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("^AbC$"))
 
 	match := func(str string, sidxExpected int, eidxExpected int) {
+		chars := util.ToChars([]byte(str))
 		res, pos := algo.EqualMatch(
-			pattern.caseSensitive, pattern.normalize, pattern.forward, util.RunesToChars([]rune(str)), pattern.termSets[0][0].text, true, nil)
+			pattern.caseSensitive, pattern.normalize, pattern.forward, &chars, pattern.termSets[0][0].text, true, nil)
 		if res.Start != sidxExpected || res.End != eidxExpected {
 			t.Errorf("%s / %d / %d", pattern.termSets, res.Start, res.End)
 		}
@@ -133,30 +127,29 @@ func TestCaseSensitivity(t *testing.T) {
 
 func TestOrigTextAndTransformed(t *testing.T) {
 	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("jg"))
-	tokens := Tokenize(util.RunesToChars([]rune("junegunn")), Delimiter{})
+	tokens := Tokenize("junegunn", Delimiter{})
 	trans := Transform(tokens, []Range{Range{1, 1}})
 
 	origBytes := []byte("junegunn.choi")
 	for _, extended := range []bool{false, true} {
-		chunk := Chunk{
+		chunk := Chunk{count: 1}
-			&Item{
+		chunk.items[0] = Item{
-				text:        util.RunesToChars([]rune("junegunn")),
+			text:        util.ToChars([]byte("junegunn")),
-				origText:    &origBytes,
+			origText:    &origBytes,
-				transformed: trans},
+			transformed: &trans}
-		}
 		pattern.extended = extended
 		matches := pattern.matchChunk(&chunk, nil, slab) // No cache
 		if !(matches[0].item.text.ToString() == "junegunn" &&
 			string(*matches[0].item.origText) == "junegunn.choi" &&
-			reflect.DeepEqual(matches[0].item.transformed, trans)) {
+			reflect.DeepEqual(*matches[0].item.transformed, trans)) {
 			t.Error("Invalid match result", matches)
 		}
 
-		match, offsets, pos := pattern.MatchItem(chunk[0], true, slab)
+		match, offsets, pos := pattern.MatchItem(&chunk.items[0], true, slab)
 		if !(match.item.text.ToString() == "junegunn" &&
 			string(*match.item.origText) == "junegunn.choi" &&
 			offsets[0][0] == 0 && offsets[0][1] == 5 &&
-			reflect.DeepEqual(match.item.transformed, trans)) {
+			reflect.DeepEqual(*match.item.transformed, trans)) {
 			t.Error("Invalid match result", match, offsets, extended)
 		}
 		if !((*pos)[0] == 4 && (*pos)[1] == 0) {
@@ -167,40 +160,47 @@ func TestOrigTextAndTransformed(t *testing.T) {
 
 func TestCacheKey(t *testing.T) {
 	test := func(extended bool, patStr string, expected string, cacheable bool) {
+		clearPatternCache()
 		pat := BuildPattern(true, algo.FuzzyMatchV2, extended, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune(patStr))
 		if pat.CacheKey() != expected {
 			t.Errorf("Expected: %s, actual: %s", expected, pat.CacheKey())
 		}
 		if pat.cacheable != cacheable {
-			t.Errorf("Expected: %s, actual: %s (%s)", cacheable, pat.cacheable, patStr)
+			t.Errorf("Expected: %t, actual: %t (%s)", cacheable, pat.cacheable, patStr)
 		}
 		clearPatternCache()
 	}
 	test(false, "foo !bar", "foo !bar", true)
 	test(false, "foo | bar !baz", "foo | bar !baz", true)
-	test(true, "foo  bar  baz", "foo bar baz", true)
+	test(true, "foo  bar  baz", "foo\tbar\tbaz", true)
 	test(true, "foo !bar", "foo", false)
-	test(true, "foo !bar   baz", "foo baz", false)
+	test(true, "foo !bar   baz", "foo\tbaz", false)
 	test(true, "foo | bar baz", "baz", false)
 	test(true, "foo | bar | baz", "", false)
 	test(true, "foo | bar !baz", "", false)
-	test(true, "| | | foo", "foo", true)
+	test(true, "| | foo", "", false)
+	test(true, "| | | foo", "foo", false)
 }
 
 func TestCacheable(t *testing.T) {
-	test := func(fuzzy bool, str string, cacheable bool) {
+	test := func(fuzzy bool, str string, expected string, cacheable bool) {
 		clearPatternCache()
 		pat := BuildPattern(fuzzy, algo.FuzzyMatchV2, true, CaseSmart, true, true, true, []Range{}, Delimiter{}, []rune(str))
+		if pat.CacheKey() != expected {
+			t.Errorf("Expected: %s, actual: %s", expected, pat.CacheKey())
+		}
 		if cacheable != pat.cacheable {
 			t.Errorf("Invalid Pattern.cacheable for \"%s\": %v (expected: %v)", str, pat.cacheable, cacheable)
 		}
+		clearPatternCache()
 	}
-	test(true, "foo bar", true)
+	test(true, "foo bar", "foo\tbar", true)
-	test(true, "foo 'bar", true)
+	test(true, "foo 'bar", "foo\tbar", false)
-	test(true, "foo !bar", false)
+	test(true, "foo !bar", "foo", false)
 
-	test(false, "foo bar", true)
+	test(false, "foo bar", "foo\tbar", true)
-	test(false, "foo '", true)
+	test(false, "foo 'bar", "foo", false)
-	test(false, "foo 'bar", false)
+	test(false, "foo '", "foo", true)
-	test(false, "foo !bar", false)
+	test(false, "foo 'bar", "foo", false)
+	test(false, "foo !bar", "foo", false)
 }

src/reader.go

@@ -4,6 +4,8 @@ import (
 	"bufio"
 	"io"
 	"os"
+	"sync/atomic"
+	"time"
 
 	"github.com/junegunn/fzf/src/util"
 )
@@ -13,20 +15,56 @@ type Reader struct {
 	pusher   func([]byte) bool
 	eventBox *util.EventBox
 	delimNil bool
+	event    int32
+}
+
+// NewReader returns new Reader object
+func NewReader(pusher func([]byte) bool, eventBox *util.EventBox, delimNil bool) *Reader {
+	return &Reader{pusher, eventBox, delimNil, int32(EvtReady)}
+}
+
+func (r *Reader) startEventPoller() {
+	go func() {
+		ptr := &r.event
+		pollInterval := readerPollIntervalMin
+		for {
+			if atomic.CompareAndSwapInt32(ptr, int32(EvtReadNew), int32(EvtReady)) {
+				r.eventBox.Set(EvtReadNew, true)
+				pollInterval = readerPollIntervalMin
+			} else if atomic.LoadInt32(ptr) == int32(EvtReadFin) {
+				return
+			} else {
+				pollInterval += readerPollIntervalStep
+				if pollInterval > readerPollIntervalMax {
+					pollInterval = readerPollIntervalMax
+				}
+			}
+			time.Sleep(pollInterval)
+		}
+	}()
+}
+
+func (r *Reader) fin(success bool) {
+	atomic.StoreInt32(&r.event, int32(EvtReadFin))
+	r.eventBox.Set(EvtReadFin, success)
 }
 
 // ReadSource reads data from the default command or from standard input
 func (r *Reader) ReadSource() {
+	r.startEventPoller()
+	var success bool
 	if util.IsTty() {
 		cmd := os.Getenv("FZF_DEFAULT_COMMAND")
 		if len(cmd) == 0 {
-			cmd = defaultCommand
+			// The default command for *nix requires bash
+			success = r.readFromCommand("bash", defaultCommand)
+		} else {
+			success = r.readFromCommand("sh", cmd)
 		}
-		r.readFromCommand(cmd)
 	} else {
-		r.readFromStdin()
+		success = r.readFromStdin()
 	}
-	r.eventBox.Set(EvtReadFin, nil)
+	r.fin(success)
 }
 
 func (r *Reader) feed(src io.Reader) {
@@ -40,7 +78,7 @@ func (r *Reader) feed(src io.Reader) {
 		// end in delim.
 		bytea, err := reader.ReadBytes(delim)
 		byteaLen := len(bytea)
-		if len(bytea) > 0 {
+		if byteaLen > 0 {
 			if err == nil {
 				// get rid of carriage return if under Windows:
 				if util.IsWindows() && byteaLen >= 2 && bytea[byteaLen-2] == byte('\r') {
@@ -50,7 +88,7 @@ func (r *Reader) feed(src io.Reader) {
 				}
 			}
 			if r.pusher(bytea) {
-				r.eventBox.Set(EvtReadNew, nil)
+				atomic.StoreInt32(&r.event, int32(EvtReadNew))
 			}
 		}
 		if err != nil {
@@ -59,20 +97,21 @@ func (r *Reader) feed(src io.Reader) {
 	}
 }
 
-func (r *Reader) readFromStdin() {
+func (r *Reader) readFromStdin() bool {
 	r.feed(os.Stdin)
+	return true
 }
 
-func (r *Reader) readFromCommand(cmd string) {
+func (r *Reader) readFromCommand(shell string, cmd string) bool {
-	listCommand := util.ExecCommand(cmd)
+	listCommand := util.ExecCommandWith(shell, cmd)
 	out, err := listCommand.StdoutPipe()
 	if err != nil {
-		return
+		return false
 	}
 	err = listCommand.Start()
 	if err != nil {
-		return
+		return false
 	}
-	defer listCommand.Wait()
 	r.feed(out)
+	return listCommand.Wait() == nil
 }

src/reader_test.go

@@ -2,6 +2,7 @@ package fzf
 
 import (
 	"testing"
+	"time"
 
 	"github.com/junegunn/fzf/src/util"
 )
@@ -11,7 +12,10 @@ func TestReadFromCommand(t *testing.T) {
 	eb := util.NewEventBox()
 	reader := Reader{
 		pusher:   func(s []byte) bool { strs = append(strs, string(s)); return true },
-		eventBox: eb}
+		eventBox: eb,
+		event:    int32(EvtReady)}
+
+	reader.startEventPoller()
 
 	// Check EventBox
 	if eb.Peek(EvtReadNew) {
@@ -19,21 +23,16 @@ func TestReadFromCommand(t *testing.T) {
 	}
 
 	// Normal command
-	reader.readFromCommand(`echo abc && echo def`)
+	reader.fin(reader.readFromCommand("sh", `echo abc && echo def`))
 	if len(strs) != 2 || strs[0] != "abc" || strs[1] != "def" {
 		t.Errorf("%s", strs)
 	}
 
 	// Check EventBox again
-	if !eb.Peek(EvtReadNew) {
+	eb.WaitFor(EvtReadFin)
-		t.Error("EvtReadNew should be set yet")
-	}
 
 	// Wait should return immediately
 	eb.Wait(func(events *util.Events) {
-		if _, found := (*events)[EvtReadNew]; !found {
-			t.Errorf("%s", events)
-		}
 		events.Clear()
 	})
 
@@ -42,8 +41,14 @@ func TestReadFromCommand(t *testing.T) {
 		t.Error("EvtReadNew should not be set yet")
 	}
 
+	// Make sure that event poller is finished
+	time.Sleep(readerPollIntervalMax)
+
+	// Restart event poller
+	reader.startEventPoller()
+
 	// Failing command
-	reader.readFromCommand(`no-such-command`)
+	reader.fin(reader.readFromCommand("sh", `no-such-command`))
 	strs = []string{}
 	if len(strs) > 0 {
 		t.Errorf("%s", strs)
@@ -51,6 +56,9 @@ func TestReadFromCommand(t *testing.T) {
 
 	// Check EventBox again
 	if eb.Peek(EvtReadNew) {
-		t.Error("Command failed. EvtReadNew should be set")
+		t.Error("Command failed. EvtReadNew should not be set")
+	}
+	if !eb.Peek(EvtReadFin) {
+		t.Error("EvtReadFin should be set")
 	}
 }

src/result.go

@@ -19,22 +19,17 @@ type colorOffset struct {
 	index  int32
 }
 
-type rank struct {
-	points [4]uint16
-	index  int32
-}
-
 type Result struct {
-	item *Item
+	item   *Item
-	rank rank
+	points [4]uint16
 }
 
-func buildResult(item *Item, offsets []Offset, score int) *Result {
+func buildResult(item *Item, offsets []Offset, score int) Result {
 	if len(offsets) > 1 {
 		sort.Sort(ByOrder(offsets))
 	}
 
-	result := Result{item: item, rank: rank{index: item.index}}
+	result := Result{item: item}
 	numChars := item.text.Length()
 	minBegin := math.MaxUint16
 	minEnd := math.MaxUint16
@@ -57,7 +52,7 @@ func buildResult(item *Item, offsets []Offset, score int) *Result {
 			// Higher is better
 			val = math.MaxUint16 - util.AsUint16(score)
 		case byLength:
-			val = util.AsUint16(int(item.TrimLength()))
+			val = item.TrimLength()
 		case byBegin, byEnd:
 			if validOffsetFound {
 				whitePrefixLen := 0
@@ -75,10 +70,10 @@ func buildResult(item *Item, offsets []Offset, score int) *Result {
 				}
 			}
 		}
-		result.rank.points[idx] = val
+		result.points[3-idx] = val
 	}
 
-	return &result
+	return result
 }
 
 // Sort criteria to use. Never changes once fzf is started.
@@ -86,11 +81,11 @@ var sortCriteria []criterion
 
 // Index returns ordinal index of the Item
 func (result *Result) Index() int32 {
-	return result.item.index
+	return result.item.Index()
 }
 
-func minRank() rank {
+func minRank() Result {
-	return rank{index: 0, points: [4]uint16{math.MaxUint16, 0, 0, 0}}
+	return Result{item: &minItem, points: [4]uint16{math.MaxUint16, 0, 0, 0}}
 }
 
 func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme, color tui.ColorPair, attr tui.Attr, current bool) []colorOffset {
@@ -201,7 +196,7 @@ func (a ByOrder) Less(i, j int) bool {
 }
 
 // ByRelevance is for sorting Items
-type ByRelevance []*Result
+type ByRelevance []Result
 
 func (a ByRelevance) Len() int {
 	return len(a)
@@ -212,11 +207,11 @@ func (a ByRelevance) Swap(i, j int) {
 }
 
 func (a ByRelevance) Less(i, j int) bool {
-	return compareRanks((*a[i]).rank, (*a[j]).rank, false)
+	return compareRanks(a[i], a[j], false)
 }
 
 // ByRelevanceTac is for sorting Items
-type ByRelevanceTac []*Result
+type ByRelevanceTac []Result
 
 func (a ByRelevanceTac) Len() int {
 	return len(a)
@@ -227,18 +222,5 @@ func (a ByRelevanceTac) Swap(i, j int) {
 }
 
 func (a ByRelevanceTac) Less(i, j int) bool {
-	return compareRanks((*a[i]).rank, (*a[j]).rank, true)
+	return compareRanks(a[i], a[j], true)
-}
-
-func compareRanks(irank rank, jrank rank, tac bool) bool {
-	for idx := 0; idx < 4; idx++ {
-		left := irank.points[idx]
-		right := jrank.points[idx]
-		if left < right {
-			return true
-		} else if left > right {
-			return false
-		}
-	}
-	return (irank.index <= jrank.index) != tac
 }

src/result_others.go

@@ -0,0 +1,16 @@
+// +build !386,!amd64
+
+package fzf
+
+func compareRanks(irank Result, jrank Result, tac bool) bool {
+	for idx := 3; idx >= 0; idx-- {
+		left := irank.points[idx]
+		right := jrank.points[idx]
+		if left < right {
+			return true
+		} else if left > right {
+			return false
+		}
+	}
+	return (irank.item.Index() <= jrank.item.Index()) != tac
+}

src/result_test.go

@@ -11,6 +11,11 @@ import (
 	"github.com/junegunn/fzf/src/util"
 )
 
+func withIndex(i *Item, index int) *Item {
+	(*i).text.Index = int32(index)
+	return i
+}
+
 func TestOffsetSort(t *testing.T) {
 	offsets := []Offset{
 		Offset{3, 5}, Offset{2, 7},
@@ -26,10 +31,10 @@ func TestOffsetSort(t *testing.T) {
 }
 
 func TestRankComparison(t *testing.T) {
-	rank := func(vals ...uint16) rank {
+	rank := func(vals ...uint16) Result {
-		return rank{
+		return Result{
 			points: [4]uint16{vals[0], vals[1], vals[2], vals[3]},
-			index:  int32(vals[4])}
+			item:   &Item{text: util.Chars{Index: int32(vals[4])}}}
 	}
 	if compareRanks(rank(3, 0, 0, 0, 5), rank(2, 0, 0, 0, 7), false) ||
 		!compareRanks(rank(3, 0, 0, 0, 5), rank(3, 0, 0, 0, 6), false) ||
@@ -52,36 +57,41 @@ func TestResultRank(t *testing.T) {
 	sortCriteria = []criterion{byScore, byLength}
 
 	strs := [][]rune{[]rune("foo"), []rune("foobar"), []rune("bar"), []rune("baz")}
-	item1 := buildResult(&Item{text: util.RunesToChars(strs[0]), index: 1, trimLength: -1}, []Offset{}, 2)
+	item1 := buildResult(
-	if item1.rank.points[0] != math.MaxUint16-2 || // Bonus
+		withIndex(&Item{text: util.RunesToChars(strs[0])}, 1), []Offset{}, 2)
-		item1.rank.points[1] != 3 || // Length
+	if item1.points[3] != math.MaxUint16-2 || // Bonus
-		item1.rank.points[2] != 0 || // Unused
+		item1.points[2] != 3 || // Length
-		item1.rank.points[3] != 0 || // Unused
+		item1.points[1] != 0 || // Unused
-		item1.item.index != 1 {
+		item1.points[0] != 0 || // Unused
-		t.Error(item1.rank)
+		item1.item.Index() != 1 {
+		t.Error(item1)
 	}
 	// Only differ in index
 	item2 := buildResult(&Item{text: util.RunesToChars(strs[0])}, []Offset{}, 2)
 
-	items := []*Result{item1, item2}
+	items := []Result{item1, item2}
 	sort.Sort(ByRelevance(items))
 	if items[0] != item2 || items[1] != item1 {
 		t.Error(items)
 	}
 
-	items = []*Result{item2, item1, item1, item2}
+	items = []Result{item2, item1, item1, item2}
 	sort.Sort(ByRelevance(items))
 	if items[0] != item2 || items[1] != item2 ||
 		items[2] != item1 || items[3] != item1 {
-		t.Error(items, item1, item1.item.index, item2, item2.item.index)
+		t.Error(items, item1, item1.item.Index(), item2, item2.item.Index())
 	}
 
 	// Sort by relevance
-	item3 := buildResult(&Item{index: 2}, []Offset{Offset{1, 3}, Offset{5, 7}}, 3)
+	item3 := buildResult(
-	item4 := buildResult(&Item{index: 2}, []Offset{Offset{1, 2}, Offset{6, 7}}, 4)
+		withIndex(&Item{}, 2), []Offset{Offset{1, 3}, Offset{5, 7}}, 3)
-	item5 := buildResult(&Item{index: 2}, []Offset{Offset{1, 3}, Offset{5, 7}}, 5)
+	item4 := buildResult(
-	item6 := buildResult(&Item{index: 2}, []Offset{Offset{1, 2}, Offset{6, 7}}, 6)
+		withIndex(&Item{}, 2), []Offset{Offset{1, 2}, Offset{6, 7}}, 4)
-	items = []*Result{item1, item2, item3, item4, item5, item6}
+	item5 := buildResult(
+		withIndex(&Item{}, 2), []Offset{Offset{1, 3}, Offset{5, 7}}, 5)
+	item6 := buildResult(
+		withIndex(&Item{}, 2), []Offset{Offset{1, 2}, Offset{6, 7}}, 6)
+	items = []Result{item1, item2, item3, item4, item5, item6}
 	sort.Sort(ByRelevance(items))
 	if !(items[0] == item6 && items[1] == item5 &&
 		items[2] == item4 && items[3] == item3 &&

src/result_x86.go

@@ -0,0 +1,16 @@
+// +build 386 amd64
+
+package fzf
+
+import "unsafe"
+
+func compareRanks(irank Result, jrank Result, tac bool) bool {
+	left := *(*uint64)(unsafe.Pointer(&irank.points[0]))
+	right := *(*uint64)(unsafe.Pointer(&jrank.points[0]))
+	if left < right {
+		return true
+	} else if left > right {
+		return false
+	}
+	return (irank.item.Index() <= jrank.item.Index()) != tac
+}

src/terminal.go

@@ -87,6 +87,7 @@ type Terminal struct {
 	margin     [4]sizeSpec
 	strong     tui.Attr
 	bordered   bool
+	cleanExit  bool
 	border     tui.Window
 	window     tui.Window
 	pborder    tui.Window
@@ -94,11 +95,13 @@ type Terminal struct {
 	count      int
 	progress   int
 	reading    bool
+	success    bool
 	jumping    jumpMode
 	jumpLabels string
 	printer    func(string)
 	merger     *Merger
 	selected   map[int32]selectedItem
+	version    int64
 	reqBox     *util.EventBox
 	preview    previewOpts
 	previewer  previewer
@@ -167,6 +170,7 @@ const (
 	actBeginningOfLine
 	actAbort
 	actAccept
+	actAcceptNonEmpty
 	actBackwardChar
 	actBackwardDeleteChar
 	actBackwardWord
@@ -200,6 +204,7 @@ const (
 	actJump
 	actJumpAccept
 	actPrintQuery
+	actReplaceQuery
 	actToggleSort
 	actTogglePreview
 	actTogglePreviewWrap
@@ -275,12 +280,18 @@ func defaultKeymap() map[int][]action {
 	keymap[tui.Rune] = toActions(actRune)
 	keymap[tui.Mouse] = toActions(actMouse)
 	keymap[tui.DoubleClick] = toActions(actAccept)
+	keymap[tui.LeftClick] = toActions(actIgnore)
+	keymap[tui.RightClick] = toActions(actToggle)
 	return keymap
 }
 
+func trimQuery(query string) []rune {
+	return []rune(strings.Replace(query, "\t", " ", -1))
+}
+
 // NewTerminal returns new Terminal object
 func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
-	input := []rune(opts.Query)
+	input := trimQuery(opts.Query)
 	var header []string
 	if opts.Reverse {
 		header = opts.Header
@@ -365,6 +376,7 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 		history:    opts.History,
 		margin:     opts.Margin,
 		bordered:   opts.Bordered,
+		cleanExit:  opts.ClearOnExit,
 		strong:     strongAttr,
 		cycle:      opts.Cycle,
 		header:     header,
@@ -372,6 +384,7 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 		ansi:       opts.Ansi,
 		tabstop:    opts.Tabstop,
 		reading:    true,
+		success:    true,
 		jumping:    jumpDisabled,
 		jumpLabels: opts.JumpLabels,
 		printer:    opts.Printer,
@@ -401,10 +414,11 @@ func (t *Terminal) Input() []rune {
 }
 
 // UpdateCount updates the count information
-func (t *Terminal) UpdateCount(cnt int, final bool) {
+func (t *Terminal) UpdateCount(cnt int, final bool, success bool) {
 	t.mutex.Lock()
 	t.count = cnt
 	t.reading = !final
+	t.success = success
 	t.mutex.Unlock()
 	t.reqBox.Set(reqInfo, nil)
 	if final {
@@ -613,10 +627,8 @@ func (t *Terminal) resizeWindows() {
 			width,
 			height, tui.BorderNone)
 	}
-	if !t.tui.IsOptimized() {
+	for i := 0; i < t.window.Height(); i++ {
-		for i := 0; i < t.window.Height(); i++ {
+		t.window.MoveAndClear(i, 0)
-			t.window.MoveAndClear(i, 0)
-		}
 	}
 	t.truncateQuery()
 }
@@ -682,6 +694,13 @@ func (t *Terminal) printInfo() {
 	if t.progress > 0 && t.progress < 100 {
 		output += fmt.Sprintf(" (%d%%)", t.progress)
 	}
+	if !t.success && t.count == 0 {
+		if len(os.Getenv("FZF_DEFAULT_COMMAND")) > 0 {
+			output = "[$FZF_DEFAULT_COMMAND failed]"
+		} else {
+			output = "[default command failed - $FZF_DEFAULT_COMMAND required]"
+		}
+	}
 	if pos+len(output) <= t.window.Width() {
 		t.window.CPrint(tui.ColInfo, 0, output)
 	}
@@ -704,12 +723,12 @@ func (t *Terminal) printHeader() {
 		trimmed, colors, newState := extractColor(lineStr, state, nil)
 		state = newState
 		item := &Item{
-			text:   util.RunesToChars([]rune(trimmed)),
+			text:   util.ToChars([]byte(trimmed)),
 			colors: colors}
 
 		t.move(line, 2, true)
-		t.printHighlighted(&Result{item: item},
+		t.printHighlighted(Result{item: item},
-			tui.AttrRegular, tui.ColHeader, tui.ColDefault, false, false)
+			tui.AttrRegular, tui.ColHeader, tui.ColHeader, false, false)
 	}
 }
 
@@ -736,7 +755,7 @@ func (t *Terminal) printList() {
 	}
 }
 
-func (t *Terminal) printItem(result *Result, line int, i int, current bool) {
+func (t *Terminal) printItem(result Result, line int, i int, current bool) {
 	item := result.item
 	_, selected := t.selected[item.Index()]
 	label := " "
@@ -752,7 +771,7 @@ func (t *Terminal) printItem(result *Result, line int, i int, current bool) {
 
 	// Avoid unnecessary redraw
 	newLine := itemLine{current: current, selected: selected, label: label,
-		result: *result, queryLen: len(t.input), width: 0}
+		result: result, queryLen: len(t.input), width: 0}
 	prevLine := t.prevLines[i]
 	if prevLine.current == newLine.current &&
 		prevLine.selected == newLine.selected &&
@@ -762,8 +781,7 @@ func (t *Terminal) printItem(result *Result, line int, i int, current bool) {
 		return
 	}
 
-	// Optimized renderer can simply erase to the end of the window
+	t.move(line, 0, false)
-	t.move(line, 0, t.tui.IsOptimized())
 	t.window.CPrint(tui.ColCursor, t.strong, label)
 	if current {
 		if selected {
@@ -780,11 +798,9 @@ func (t *Terminal) printItem(result *Result, line int, i int, current bool) {
 		}
 		newLine.width = t.printHighlighted(result, 0, tui.ColNormal, tui.ColMatch, false, true)
 	}
-	if !t.tui.IsOptimized() {
+	fillSpaces := prevLine.width - newLine.width
-		fillSpaces := prevLine.width - newLine.width
+	if fillSpaces > 0 {
-		if fillSpaces > 0 {
+		t.window.Print(strings.Repeat(" ", fillSpaces))
-			t.window.Print(strings.Repeat(" ", fillSpaces))
-		}
 	}
 	t.prevLines[i] = newLine
 }
@@ -834,7 +850,7 @@ func (t *Terminal) overflow(runes []rune, max int) bool {
 	return t.displayWidthWithLimit(runes, 0, max) > max
 }
 
-func (t *Terminal) printHighlighted(result *Result, attr tui.Attr, col1 tui.ColorPair, col2 tui.ColorPair, current bool, match bool) int {
+func (t *Terminal) printHighlighted(result Result, attr tui.Attr, col1 tui.ColorPair, col2 tui.ColorPair, current bool, match bool) int {
 	item := result.item
 
 	// Overflow
@@ -954,6 +970,7 @@ func (t *Terminal) printPreview() {
 	}
 	reader := bufio.NewReader(strings.NewReader(t.previewer.text))
 	lineNo := -t.previewer.offset
+	height := t.pwindow.Height()
 	var ansi *ansiState
 	for {
 		line, err := reader.ReadString('\n')
@@ -962,7 +979,8 @@ func (t *Terminal) printPreview() {
 			line = line[:len(line)-1]
 		}
 		lineNo++
-		if lineNo > t.pwindow.Height() {
+		if lineNo > height ||
+			t.pwindow.Y() == height-1 && t.pwindow.X() > 0 {
 			break
 		} else if lineNo > 0 {
 			var fillRet tui.FillReturn
@@ -975,7 +993,7 @@ func (t *Terminal) printPreview() {
 				if t.theme != nil && ansi != nil && ansi.colored() {
 					fillRet = t.pwindow.CFill(ansi.fg, ansi.bg, ansi.attr, str)
 				} else {
-					fillRet = t.pwindow.Fill(str)
+					fillRet = t.pwindow.CFill(tui.ColNormal.Fg(), tui.ColNormal.Bg(), tui.AttrRegular, str)
 				}
 				return fillRet == tui.FillContinue
 			})
@@ -992,7 +1010,7 @@ func (t *Terminal) printPreview() {
 		}
 	}
 	t.pwindow.FinishFill()
-	if t.previewer.lines > t.pwindow.Height() {
+	if t.previewer.lines > height {
 		offset := fmt.Sprintf("%d/%d", t.previewer.offset+1, t.previewer.lines)
 		pos := t.pwindow.Width() - len(offset)
 		if t.tui.DoesAutoWrap() {
@@ -1093,9 +1111,18 @@ func keyMatch(key int, event tui.Event) bool {
 		event.Type == tui.Mouse && key == tui.DoubleClick && event.MouseEvent.Double
 }
 
+func quoteEntryCmd(entry string) string {
+	escaped := strings.Replace(entry, `\`, `\\`, -1)
+	escaped = `"` + strings.Replace(escaped, `"`, `\"`, -1) + `"`
+	r, _ := regexp.Compile(`[&|<>()@^%!"]`)
+	return r.ReplaceAllStringFunc(escaped, func(match string) string {
+		return "^" + match
+	})
+}
+
 func quoteEntry(entry string) string {
 	if util.IsWindows() {
-		return strconv.Quote(strings.Replace(entry, "\"", "\\\"", -1))
+		return quoteEntryCmd(entry)
 	}
 	return "'" + strings.Replace(entry, "'", "'\\''", -1) + "'"
 }
@@ -1163,8 +1190,7 @@ func replacePlaceholder(template string, stripAnsi bool, delimiter Delimiter, fo
 		}
 
 		for idx, item := range items {
-			chars := util.RunesToChars([]rune(item.AsString(stripAnsi)))
+			tokens := Tokenize(item.AsString(stripAnsi), delimiter)
-			tokens := Tokenize(chars, delimiter)
 			trans := Transform(tokens, ranges)
 			str := string(joinTokens(trans))
 			if delimiter.str != nil {
@@ -1248,6 +1274,24 @@ func (t *Terminal) truncateQuery() {
 	t.cx = util.Constrain(t.cx, 0, len(t.input))
 }
 
+func (t *Terminal) selectItem(item *Item) {
+	t.selected[item.Index()] = selectedItem{time.Now(), item}
+	t.version++
+}
+
+func (t *Terminal) deselectItem(item *Item) {
+	delete(t.selected, item.Index())
+	t.version++
+}
+
+func (t *Terminal) toggleItem(item *Item) {
+	if _, found := t.selected[item.Index()]; !found {
+		t.selectItem(item)
+	} else {
+		t.deselectItem(item)
+	}
+}
+
 // Loop is called to start Terminal I/O
 func (t *Terminal) Loop() {
 	// prof := profile.Start(profile.ProfilePath("/tmp/"))
@@ -1326,6 +1370,12 @@ func (t *Terminal) Loop() {
 					command := replacePlaceholder(t.preview.command,
 						t.ansi, t.delimiter, false, string(t.input), request)
 					cmd := util.ExecCommand(command)
+					if t.pwindow != nil {
+						env := os.Environ()
+						env = append(env, fmt.Sprintf("LINES=%d", t.pwindow.Height()))
+						env = append(env, fmt.Sprintf("COLUMNS=%d", t.pwindow.Width()))
+						cmd.Env = env
+					}
 					out, _ := cmd.CombinedOutput()
 					t.reqBox.Set(reqPreviewDisplay, string(out))
 				} else {
@@ -1335,7 +1385,12 @@ func (t *Terminal) Loop() {
 		}()
 	}
 
-	exit := func(code int) {
+	exit := func(getCode func() int) {
+		if !t.cleanExit && t.fullscreen && t.inlineInfo {
+			t.placeCursor()
+		}
+		t.tui.Close()
+		code := getCode()
 		if code <= exitNoMatch && t.history != nil {
 			t.history.append(string(t.input))
 		}
@@ -1345,6 +1400,7 @@ func (t *Terminal) Loop() {
 
 	go func() {
 		var focused *Item
+		var version int64
 		for {
 			t.reqBox.Wait(func(events *util.Events) {
 				defer events.Clear()
@@ -1361,7 +1417,8 @@ func (t *Terminal) Loop() {
 					case reqList:
 						t.printList()
 						currentFocus := t.currentItem()
-						if currentFocus != focused {
+						if currentFocus != focused || version != t.version {
+							version = t.version
 							focused = currentFocus
 							if t.isPreviewEnabled() {
 								_, list := t.buildPlusList(t.preview.command, false)
@@ -1383,11 +1440,12 @@ func (t *Terminal) Loop() {
 					case reqRedraw:
 						t.redraw()
 					case reqClose:
-						t.tui.Close()
+						exit(func() int {
-						if t.output() {
+							if t.output() {
-							exit(exitOk)
+								return exitOk
-						}
+							}
-						exit(exitNoMatch)
+							return exitNoMatch
+						})
 					case reqPreviewDisplay:
 						t.previewer.text = value.(string)
 						t.previewer.lines = strings.Count(t.previewer.text, "\n")
@@ -1396,12 +1454,12 @@ func (t *Terminal) Loop() {
 					case reqPreviewRefresh:
 						t.printPreview()
 					case reqPrintQuery:
-						t.tui.Close()
+						exit(func() int {
-						t.printer(string(t.input))
+							t.printer(string(t.input))
-						exit(exitOk)
+							return exitOk
+						})
 					case reqQuit:
-						t.tui.Close()
+						exit(func() int { return exitInterrupt })
-						exit(exitInterrupt)
 					}
 				}
 				t.placeCursor()
@@ -1426,22 +1484,9 @@ func (t *Terminal) Loop() {
 				}
 			}
 		}
-		selectItem := func(item *Item) bool {
-			if _, found := t.selected[item.Index()]; !found {
-				t.selected[item.Index()] = selectedItem{time.Now(), item}
-				return true
-			}
-			return false
-		}
-		toggleY := func(y int) {
-			item := t.merger.Get(y).item
-			if !selectItem(item) {
-				delete(t.selected, item.Index())
-			}
-		}
 		toggle := func() {
 			if t.cy < t.merger.Length() {
-				toggleY(t.cy)
+				t.toggleItem(t.merger.Get(t.cy).item)
 				req(reqInfo)
 			}
 		}
@@ -1525,6 +1570,11 @@ func (t *Terminal) Loop() {
 				}
 			case actPrintQuery:
 				req(reqPrintQuery)
+			case actReplaceQuery:
+				if t.cy >= 0 && t.cy < t.merger.Length() {
+					t.input = t.merger.Get(t.cy).item.text.ToRunes()
+					t.cx = len(t.input)
+				}
 			case actAbort:
 				req(reqQuit)
 			case actDeleteChar:
@@ -1555,17 +1605,14 @@ func (t *Terminal) Loop() {
 			case actSelectAll:
 				if t.multi {
 					for i := 0; i < t.merger.Length(); i++ {
-						item := t.merger.Get(i).item
+						t.selectItem(t.merger.Get(i).item)
-						selectItem(item)
 					}
 					req(reqList, reqInfo)
 				}
 			case actDeselectAll:
 				if t.multi {
-					for i := 0; i < t.merger.Length(); i++ {
+					t.selected = make(map[int32]selectedItem)
-						item := t.merger.Get(i)
+					t.version++
-						delete(t.selected, item.Index())
-					}
 					req(reqList, reqInfo)
 				}
 			case actToggle:
@@ -1576,7 +1623,7 @@ func (t *Terminal) Loop() {
 			case actToggleAll:
 				if t.multi {
 					for i := 0; i < t.merger.Length(); i++ {
-						toggleY(i)
+						t.toggleItem(t.merger.Get(i).item)
 					}
 					req(reqList, reqInfo)
 				}
@@ -1610,6 +1657,10 @@ func (t *Terminal) Loop() {
 				req(reqList)
 			case actAccept:
 				req(reqClose)
+			case actAcceptNonEmpty:
+				if len(t.selected) > 0 || t.merger.Length() > 0 || !t.reading && t.count == 0 {
+					req(reqClose)
+				}
 			case actClearScreen:
 				req(reqRedraw)
 			case actTop:
@@ -1674,13 +1725,13 @@ func (t *Terminal) Loop() {
 			case actPreviousHistory:
 				if t.history != nil {
 					t.history.override(string(t.input))
-					t.input = []rune(t.history.previous())
+					t.input = trimQuery(t.history.previous())
 					t.cx = len(t.input)
 				}
 			case actNextHistory:
 				if t.history != nil {
 					t.history.override(string(t.input))
-					t.input = []rune(t.history.next())
+					t.input = trimQuery(t.history.next())
 					t.cx = len(t.input)
 				}
 			case actSigStop:
@@ -1734,6 +1785,10 @@ func (t *Terminal) Loop() {
 								toggle()
 							}
 							req(reqList)
+							if me.Left {
+								return doActions(t.keymap[tui.LeftClick], tui.LeftClick)
+							}
+							return doActions(t.keymap[tui.RightClick], tui.RightClick)
 						}
 					}
 				}

src/terminal_test.go

@@ -10,7 +10,7 @@ import (
 func newItem(str string) *Item {
 	bytes := []byte(str)
 	trimmed, _, _ := extractColor(str, nil, nil)
-	return &Item{origText: &bytes, text: util.RunesToChars([]rune(trimmed))}
+	return &Item{origText: &bytes, text: util.ToChars([]byte(trimmed))}
 }
 
 func TestReplacePlaceholder(t *testing.T) {
@@ -91,3 +91,22 @@ func TestReplacePlaceholder(t *testing.T) {
 	result = replacePlaceholder("echo {}/{1}/{3}/{2..3}", true, Delimiter{regex: regex}, false, "query", items1)
 	check("echo '  foo'\\''bar baz'/'f'/'r b'/''\\''bar b'")
 }
+
+func TestQuoteEntryCmd(t *testing.T) {
+	tests := map[string]string{
+		`"`:                       `^"\^"^"`,
+		`\`:                       `^"\\^"`,
+		`\"`:                      `^"\\\^"^"`,
+		`"\\\"`:                   `^"\^"\\\\\\\^"^"`,
+		`&|<>()@^%!`:              `^"^&^|^<^>^(^)^@^^^%^!^"`,
+		`%USERPROFILE%`:           `^"^%USERPROFILE^%^"`,
+		`C:\Program Files (x86)\`: `^"C:\\Program Files ^(x86^)\\^"`,
+	}
+
+	for input, expected := range tests {
+		escaped := quoteEntryCmd(input)
+		if escaped != expected {
+			t.Errorf("Input: %s, expected: %s, actual %s", input, expected, escaped)
+		}
+	}
+}

src/tokenizer.go

@@ -1,6 +1,7 @@
 package fzf
 
 import (
+	"bytes"
 	"regexp"
 	"strconv"
 	"strings"
@@ -74,14 +75,14 @@ func ParseRange(str *string) (Range, bool) {
 	return newRange(n, n), true
 }
 
-func withPrefixLengths(tokens []util.Chars, begin int) []Token {
+func withPrefixLengths(tokens []string, begin int) []Token {
 	ret := make([]Token, len(tokens))
 
 	prefixLength := begin
-	for idx, token := range tokens {
+	for idx := range tokens {
-		// NOTE: &tokens[idx] instead of &tokens
+		chars := util.ToChars([]byte(tokens[idx]))
-		ret[idx] = Token{&tokens[idx], int32(prefixLength)}
+		ret[idx] = Token{&chars, int32(prefixLength)}
-		prefixLength += token.Length()
+		prefixLength += chars.Length()
 	}
 	return ret
 }
@@ -92,16 +93,15 @@ const (
 	awkWhite
 )
 
-func awkTokenizer(input util.Chars) ([]util.Chars, int) {
+func awkTokenizer(input string) ([]string, int) {
 	// 9, 32
-	ret := []util.Chars{}
+	ret := []string{}
 	prefixLength := 0
 	state := awkNil
-	numChars := input.Length()
 	begin := 0
 	end := 0
-	for idx := 0; idx < numChars; idx++ {
+	for idx := 0; idx < len(input); idx++ {
-		r := input.Get(idx)
+		r := input[idx]
 		white := r == 9 || r == 32
 		switch state {
 		case awkNil:
@@ -119,19 +119,19 @@ func awkTokenizer(input util.Chars) ([]util.Chars, int) {
 			if white {
 				end = idx + 1
 			} else {
-				ret = append(ret, input.Slice(begin, end))
+				ret = append(ret, input[begin:end])
 				state, begin, end = awkBlack, idx, idx+1
 			}
 		}
 	}
 	if begin < end {
-		ret = append(ret, input.Slice(begin, end))
+		ret = append(ret, input[begin:end])
 	}
 	return ret, prefixLength
 }
 
 // Tokenize tokenizes the given string with the delimiter
-func Tokenize(text util.Chars, delimiter Delimiter) []Token {
+func Tokenize(text string, delimiter Delimiter) []Token {
 	if delimiter.str == nil && delimiter.regex == nil {
 		// AWK-style (\S+\s*)
 		tokens, prefixLength := awkTokenizer(text)
@@ -139,36 +139,31 @@ func Tokenize(text util.Chars, delimiter Delimiter) []Token {
 	}
 
 	if delimiter.str != nil {
-		return withPrefixLengths(text.Split(*delimiter.str), 0)
+		return withPrefixLengths(strings.SplitAfter(text, *delimiter.str), 0)
 	}
 
 	// FIXME performance
 	var tokens []string
 	if delimiter.regex != nil {
-		str := text.ToString()
+		for len(text) > 0 {
-		for len(str) > 0 {
+			loc := delimiter.regex.FindStringIndex(text)
-			loc := delimiter.regex.FindStringIndex(str)
+			if len(loc) < 2 {
-			if loc == nil {
+				loc = []int{0, len(text)}
-				loc = []int{0, len(str)}
 			}
 			last := util.Max(loc[1], 1)
-			tokens = append(tokens, str[:last])
+			tokens = append(tokens, text[:last])
-			str = str[last:]
+			text = text[last:]
 		}
 	}
-	asRunes := make([]util.Chars, len(tokens))
+	return withPrefixLengths(tokens, 0)
-	for i, token := range tokens {
-		asRunes[i] = util.RunesToChars([]rune(token))
-	}
-	return withPrefixLengths(asRunes, 0)
 }
 
-func joinTokens(tokens []Token) []rune {
+func joinTokens(tokens []Token) string {
-	ret := []rune{}
+	var output bytes.Buffer
 	for _, token := range tokens {
-		ret = append(ret, token.text.ToRunes()...)
+		output.WriteString(token.text.ToString())
 	}
-	return ret
+	return output.String()
 }
 
 // Transform is used to transform the input when --with-nth option is given
@@ -181,7 +176,7 @@ func Transform(tokens []Token, withNth []Range) []Token {
 		if r.begin == r.end {
 			idx := r.begin
 			if idx == rangeEllipsis {
-				chars := util.RunesToChars(joinTokens(tokens))
+				chars := util.ToChars([]byte(joinTokens(tokens)))
 				parts = append(parts, &chars)
 			} else {
 				if idx < 0 {
@@ -224,15 +219,15 @@ func Transform(tokens []Token, withNth []Range) []Token {
 		var merged util.Chars
 		switch len(parts) {
 		case 0:
-			merged = util.RunesToChars([]rune{})
+			merged = util.ToChars([]byte{})
 		case 1:
 			merged = *parts[0]
 		default:
-			runes := []rune{}
+			var output bytes.Buffer
 			for _, part := range parts {
-				runes = append(runes, part.ToRunes()...)
+				output.WriteString(part.ToString())
 			}
-			merged = util.RunesToChars(runes)
+			merged = util.ToChars([]byte(output.String()))
 		}
 
 		var prefixLength int32

src/tokenizer_test.go

@@ -2,8 +2,6 @@ package fzf
 
 import (
 	"testing"
-
-	"github.com/junegunn/fzf/src/util"
 )
 
 func TestParseRange(t *testing.T) {
@@ -47,19 +45,19 @@ func TestParseRange(t *testing.T) {
 func TestTokenize(t *testing.T) {
 	// AWK-style
 	input := "  abc:  def:  ghi  "
-	tokens := Tokenize(util.RunesToChars([]rune(input)), Delimiter{})
+	tokens := Tokenize(input, Delimiter{})
 	if tokens[0].text.ToString() != "abc:  " || tokens[0].prefixLength != 2 {
 		t.Errorf("%s", tokens)
 	}
 
 	// With delimiter
-	tokens = Tokenize(util.RunesToChars([]rune(input)), delimiterRegexp(":"))
+	tokens = Tokenize(input, delimiterRegexp(":"))
 	if tokens[0].text.ToString() != "  abc:" || tokens[0].prefixLength != 0 {
-		t.Errorf("%s", tokens)
+		t.Error(tokens[0].text.ToString(), tokens[0].prefixLength)
 	}
 
 	// With delimiter regex
-	tokens = Tokenize(util.RunesToChars([]rune(input)), delimiterRegexp("\\s+"))
+	tokens = Tokenize(input, delimiterRegexp("\\s+"))
 	if tokens[0].text.ToString() != "  " || tokens[0].prefixLength != 0 ||
 		tokens[1].text.ToString() != "abc:  " || tokens[1].prefixLength != 2 ||
 		tokens[2].text.ToString() != "def:  " || tokens[2].prefixLength != 8 ||
@@ -71,7 +69,7 @@ func TestTokenize(t *testing.T) {
 func TestTransform(t *testing.T) {
 	input := "  abc:  def:  ghi:  jkl"
 	{
-		tokens := Tokenize(util.RunesToChars([]rune(input)), Delimiter{})
+		tokens := Tokenize(input, Delimiter{})
 		{
 			ranges := splitNth("1,2,3")
 			tx := Transform(tokens, ranges)
@@ -93,7 +91,7 @@ func TestTransform(t *testing.T) {
 		}
 	}
 	{
-		tokens := Tokenize(util.RunesToChars([]rune(input)), delimiterRegexp(":"))
+		tokens := Tokenize(input, delimiterRegexp(":"))
 		{
 			ranges := splitNth("1..2,3,2..,1")
 			tx := Transform(tokens, ranges)

src/tui/dummy.go

@@ -33,7 +33,6 @@ func (r *FullscreenRenderer) Refresh()    {}
 func (r *FullscreenRenderer) Close()      {}
 
 func (r *FullscreenRenderer) DoesAutoWrap() bool { return false }
-func (r *FullscreenRenderer) IsOptimized() bool  { return false }
 func (r *FullscreenRenderer) GetChar() Event     { return Event{} }
 func (r *FullscreenRenderer) MaxX() int          { return 0 }
 func (r *FullscreenRenderer) MaxY() int          { return 0 }

src/tui/light.go

@@ -32,7 +32,8 @@ var offsetRegexp *regexp.Regexp = regexp.MustCompile("\x1b\\[([0-9]+);([0-9]+)R"
 func openTtyIn() *os.File {
 	in, err := os.OpenFile(consoleDevice, syscall.O_RDONLY, 0)
 	if err != nil {
-		panic("Failed to open " + consoleDevice)
+		fmt.Fprintln(os.Stderr, "Failed to open "+consoleDevice)
+		os.Exit(2)
 	}
 	return in
 }
@@ -104,6 +105,7 @@ type LightWindow struct {
 	posx     int
 	posy     int
 	tabstop  int
+	fg       Color
 	bg       Color
 }
 
@@ -182,10 +184,18 @@ func (r *LightRenderer) Init() {
 	if r.fullscreen {
 		r.smcup()
 	} else {
-		r.csi("J")
+		// We assume that --no-clear is used for repetitive relaunching of fzf.
+		// So we do not clear the lower bottom of the screen.
+		if r.clearOnExit {
+			r.csi("J")
+		}
 		y, x := r.findOffset()
 		r.mouse = r.mouse && y >= 0
-		if x > 0 {
+		// When --no-clear is used for repetitive relaunching, there is a small
+		// time frame between fzf processes where the user keystrokes are not
+		// captured by either of fzf process which can cause x offset to be
+		// increased and we're left with unwanted extra new line.
+		if x > 0 && r.clearOnExit {
 			r.upOneLine = true
 			r.makeSpace()
 		}
@@ -200,7 +210,9 @@ func (r *LightRenderer) Init() {
 	r.csi(fmt.Sprintf("%dA", r.MaxY()-1))
 	r.csi("G")
 	r.csi("K")
-	// r.csi("s")
+	if !r.clearOnExit && !r.fullscreen {
+		r.csi("s")
+	}
 	if !r.fullscreen && r.mouse {
 		r.yoffset, _ = r.findOffset()
 	}
@@ -411,10 +423,12 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 						return Event{F12, 0, nil}
 					}
 				}
-				// Bracketed paste mode \e[200~ / \e[201
+				// Bracketed paste mode: \e[200~ ... \e[201~
-				if r.buffer[3] == 48 && (r.buffer[4] == 48 || r.buffer[4] == 49) && r.buffer[5] == 126 {
+				if r.buffer[3] == '0' && (r.buffer[4] == '0' || r.buffer[4] == '1') && r.buffer[5] == '~' {
-					*sz = 6
+					// Immediately discard the sequence from the buffer and reread input
-					return Event{Invalid, 0, nil}
+					r.buffer = r.buffer[6:]
+					*sz = 0
+					return r.GetChar()
 				}
 				return Event{Invalid, 0, nil} // INS
 			case 51:
@@ -481,16 +495,19 @@ func (r *LightRenderer) mouseSequence(sz *int) Event {
 	}
 	*sz = 6
 	switch r.buffer[3] {
-	case 32, 36, 40, 48, // mouse-down / shift / cmd / ctrl
+	case 32, 34, 36, 40, 48, // mouse-down / shift / cmd / ctrl
 		35, 39, 43, 51: // mouse-up / shift / cmd / ctrl
 		mod := r.buffer[3] >= 36
+		left := r.buffer[3] == 32
 		down := r.buffer[3]%2 == 0
 		x := int(r.buffer[4] - 33)
 		y := int(r.buffer[5]-33) - r.yoffset
 		double := false
 		if down {
 			now := time.Now()
-			if now.Sub(r.prevDownTime) < doubleClickDuration {
+			if !left { // Right double click is not allowed
+				r.clickY = []int{}
+			} else if now.Sub(r.prevDownTime) < doubleClickDuration {
 				r.clickY = append(r.clickY, y)
 			} else {
 				r.clickY = []int{y}
@@ -503,14 +520,14 @@ func (r *LightRenderer) mouseSequence(sz *int) Event {
 			}
 		}
 
-		return Event{Mouse, 0, &MouseEvent{y, x, 0, down, double, mod}}
+		return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, mod}}
 	case 96, 100, 104, 112, // scroll-up / shift / cmd / ctrl
 		97, 101, 105, 113: // scroll-down / shift / cmd / ctrl
 		mod := r.buffer[3] >= 100
 		s := 1 - int(r.buffer[3]%2)*2
 		x := int(r.buffer[4] - 33)
 		y := int(r.buffer[5]-33) - r.yoffset
-		return Event{Mouse, 0, &MouseEvent{y, x, s, false, false, mod}}
+		return Event{Mouse, 0, &MouseEvent{y, x, s, false, false, false, mod}}
 	}
 	return Event{Invalid, 0, nil}
 }
@@ -584,10 +601,8 @@ func (r *LightRenderer) Close() {
 			}
 			r.csi("J")
 		}
-	} else if r.fullscreen {
+	} else if !r.fullscreen {
-		r.csi("G")
+		r.csi("u")
-	} else {
-		r.move(r.height, 0)
 	}
 	if r.mouse {
 		r.csi("?1000l")
@@ -608,10 +623,6 @@ func (r *LightRenderer) DoesAutoWrap() bool {
 	return false
 }
 
-func (r *LightRenderer) IsOptimized() bool {
-	return false
-}
-
 func (r *LightRenderer) NewWindow(top int, left int, width int, height int, borderStyle BorderStyle) Window {
 	w := &LightWindow{
 		renderer: r,
@@ -622,8 +633,10 @@ func (r *LightRenderer) NewWindow(top int, left int, width int, height int, bord
 		width:    width,
 		height:   height,
 		tabstop:  r.tabstop,
+		fg:       colDefault,
 		bg:       colDefault}
 	if r.theme != nil {
+		w.fg = r.theme.Fg
 		w.bg = r.theme.Bg
 	}
 	w.drawBorder()
@@ -697,6 +710,10 @@ func (w *LightWindow) X() int {
 	return w.posx
 }
 
+func (w *LightWindow) Y() int {
+	return w.posy
+}
+
 func (w *LightWindow) Enclose(y int, x int) bool {
 	return x >= w.left && x < (w.left+w.width) &&
 		y >= w.top && y < (w.top+w.height)
@@ -831,17 +848,20 @@ func (w *LightWindow) fill(str string, onMove func()) FillReturn {
 		for j, wl := range lines {
 			if w.posx >= w.Width()-1 && wl.displayWidth == 0 {
 				if w.posy < w.height-1 {
-					w.MoveAndClear(w.posy+1, 0)
+					w.Move(w.posy+1, 0)
 				}
 				return FillNextLine
 			}
 			w.stderrInternal(wl.text, false)
 			w.posx += wl.displayWidth
+
+			// Wrap line
 			if j < len(lines)-1 || i < len(allLines)-1 {
 				if w.posy+1 >= w.height {
 					return FillSuspend
 				}
-				w.MoveAndClear(w.posy+1, 0)
+				w.MoveAndClear(w.posy, w.posx)
+				w.Move(w.posy+1, 0)
 				onMove()
 			}
 		}
@@ -856,24 +876,28 @@ func (w *LightWindow) setBg() {
 }
 
 func (w *LightWindow) Fill(text string) FillReturn {
-	w.MoveAndClear(w.posy, w.posx)
+	w.Move(w.posy, w.posx)
 	w.setBg()
 	return w.fill(text, w.setBg)
 }
 
 func (w *LightWindow) CFill(fg Color, bg Color, attr Attr, text string) FillReturn {
-	w.MoveAndClear(w.posy, w.posx)
+	w.Move(w.posy, w.posx)
+	if fg == colDefault {
+		fg = w.fg
+	}
 	if bg == colDefault {
 		bg = w.bg
 	}
 	if w.csiColor(fg, bg, attr) {
-		return w.fill(text, func() { w.csiColor(fg, bg, attr) })
 		defer w.csi("m")
+		return w.fill(text, func() { w.csiColor(fg, bg, attr) })
 	}
 	return w.fill(text, w.setBg)
 }
 
 func (w *LightWindow) FinishFill() {
+	w.MoveAndClear(w.posy, w.posx)
 	for y := w.posy + 1; y < w.height; y++ {
 		w.MoveAndClear(y, 0)
 	}

src/tui/ncurses.go

@@ -1,505 +0,0 @@
-// +build ncurses
-// +build !windows
-// +build !tcell
-
-package tui
-
-/*
-#include <ncurses.h>
-#include <locale.h>
-#cgo !static LDFLAGS: -lncurses
-#cgo static LDFLAGS: -l:libncursesw.a -l:libtinfo.a -l:libgpm.a -ldl
-#cgo android static LDFLAGS: -l:libncurses.a -fPIE -march=armv7-a -mfpu=neon -mhard-float -Wl,--no-warn-mismatch
-
-FILE* c_tty() {
-	return fopen("/dev/tty", "r");
-}
-
-SCREEN* c_newterm(FILE* tty) {
-	return newterm(NULL, stderr, tty);
-}
-
-int c_getcurx(WINDOW* win) {
-	return getcurx(win);
-}
-*/
-import "C"
-
-import (
-	"os"
-	"strconv"
-	"strings"
-	"time"
-	"unicode/utf8"
-)
-
-func HasFullscreenRenderer() bool {
-	return true
-}
-
-type Attr C.uint
-
-type CursesWindow struct {
-	impl   *C.WINDOW
-	top    int
-	left   int
-	width  int
-	height int
-}
-
-func (w *CursesWindow) Top() int {
-	return w.top
-}
-
-func (w *CursesWindow) Left() int {
-	return w.left
-}
-
-func (w *CursesWindow) Width() int {
-	return w.width
-}
-
-func (w *CursesWindow) Height() int {
-	return w.height
-}
-
-func (w *CursesWindow) Refresh() {
-	C.wnoutrefresh(w.impl)
-}
-
-func (w *CursesWindow) FinishFill() {
-	// NO-OP
-}
-
-const (
-	Bold      Attr = C.A_BOLD
-	Dim            = C.A_DIM
-	Blink          = C.A_BLINK
-	Reverse        = C.A_REVERSE
-	Underline      = C.A_UNDERLINE
-)
-
-var Italic Attr = C.A_VERTICAL << 1 // FIXME
-
-const (
-	AttrRegular Attr = 0
-)
-
-var (
-	_screen   *C.SCREEN
-	_colorMap map[int]int16
-	_colorFn  func(ColorPair, Attr) (C.short, C.int)
-)
-
-func init() {
-	_colorMap = make(map[int]int16)
-	if strings.HasPrefix(C.GoString(C.curses_version()), "ncurses 5") {
-		Italic = C.A_NORMAL
-	}
-}
-
-func (a Attr) Merge(b Attr) Attr {
-	return a | b
-}
-
-func (r *FullscreenRenderer) defaultTheme() *ColorTheme {
-	if C.tigetnum(C.CString("colors")) >= 256 {
-		return Dark256
-	}
-	return Default16
-}
-
-func (r *FullscreenRenderer) Init() {
-	C.setlocale(C.LC_ALL, C.CString(""))
-	tty := C.c_tty()
-	if tty == nil {
-		errorExit("Failed to open /dev/tty")
-	}
-	_screen = C.c_newterm(tty)
-	if _screen == nil {
-		errorExit("Invalid $TERM: " + os.Getenv("TERM"))
-	}
-	C.set_term(_screen)
-	if r.mouse {
-		C.mousemask(C.ALL_MOUSE_EVENTS, nil)
-		C.mouseinterval(0)
-	}
-	C.noecho()
-	C.raw() // stty dsusp undef
-	C.nonl()
-	C.keypad(C.stdscr, true)
-
-	delay := 50
-	delayEnv := os.Getenv("ESCDELAY")
-	if len(delayEnv) > 0 {
-		num, err := strconv.Atoi(delayEnv)
-		if err == nil && num >= 0 {
-			delay = num
-		}
-	}
-	C.set_escdelay(C.int(delay))
-
-	if r.theme != nil {
-		C.start_color()
-		initTheme(r.theme, r.defaultTheme(), r.forceBlack)
-		initPairs(r.theme)
-		C.bkgd(C.chtype(C.COLOR_PAIR(C.int(ColNormal.index()))))
-		_colorFn = attrColored
-	} else {
-		initTheme(r.theme, nil, r.forceBlack)
-		_colorFn = attrMono
-	}
-
-	C.nodelay(C.stdscr, true)
-	ch := C.getch()
-	if ch != C.ERR {
-		C.ungetch(ch)
-	}
-	C.nodelay(C.stdscr, false)
-}
-
-func initPairs(theme *ColorTheme) {
-	C.assume_default_colors(C.int(theme.Fg), C.int(theme.Bg))
-	for _, pair := range []ColorPair{
-		ColNormal,
-		ColPrompt,
-		ColMatch,
-		ColCurrent,
-		ColCurrentMatch,
-		ColSpinner,
-		ColInfo,
-		ColCursor,
-		ColSelected,
-		ColHeader,
-		ColBorder} {
-		C.init_pair(C.short(pair.index()), C.short(pair.Fg()), C.short(pair.Bg()))
-	}
-}
-
-func (r *FullscreenRenderer) Pause(bool) {
-	C.endwin()
-}
-
-func (r *FullscreenRenderer) Resume(bool) {
-}
-
-func (r *FullscreenRenderer) Close() {
-	C.endwin()
-	C.delscreen(_screen)
-}
-
-func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int, borderStyle BorderStyle) Window {
-	win := C.newwin(C.int(height), C.int(width), C.int(top), C.int(left))
-	if r.theme != nil {
-		C.wbkgd(win, C.chtype(C.COLOR_PAIR(C.int(ColNormal.index()))))
-	}
-	// FIXME Does not implement BorderHorizontal
-	if borderStyle != BorderNone {
-		pair, attr := _colorFn(ColBorder, 0)
-		C.wcolor_set(win, pair, nil)
-		C.wattron(win, attr)
-		C.box(win, 0, 0)
-		C.wattroff(win, attr)
-		C.wcolor_set(win, 0, nil)
-	}
-
-	return &CursesWindow{
-		impl:   win,
-		top:    top,
-		left:   left,
-		width:  width,
-		height: height,
-	}
-}
-
-func attrColored(color ColorPair, a Attr) (C.short, C.int) {
-	return C.short(color.index()), C.int(a)
-}
-
-func attrMono(color ColorPair, a Attr) (C.short, C.int) {
-	return 0, C.int(attrFor(color, a))
-}
-
-func (r *FullscreenRenderer) MaxX() int {
-	return int(C.COLS)
-}
-
-func (r *FullscreenRenderer) MaxY() int {
-	return int(C.LINES)
-}
-
-func (w *CursesWindow) Close() {
-	C.delwin(w.impl)
-}
-
-func (w *CursesWindow) Enclose(y int, x int) bool {
-	return bool(C.wenclose(w.impl, C.int(y), C.int(x)))
-}
-
-func (w *CursesWindow) Move(y int, x int) {
-	C.wmove(w.impl, C.int(y), C.int(x))
-}
-
-func (w *CursesWindow) MoveAndClear(y int, x int) {
-	w.Move(y, x)
-	C.wclrtoeol(w.impl)
-}
-
-func (w *CursesWindow) Print(text string) {
-	C.waddstr(w.impl, C.CString(strings.Map(func(r rune) rune {
-		if r < 32 {
-			return -1
-		}
-		return r
-	}, text)))
-}
-
-func (w *CursesWindow) CPrint(color ColorPair, attr Attr, text string) {
-	p, a := _colorFn(color, attr)
-	C.wcolor_set(w.impl, p, nil)
-	C.wattron(w.impl, a)
-	w.Print(text)
-	C.wattroff(w.impl, a)
-	C.wcolor_set(w.impl, 0, nil)
-}
-
-func (r *FullscreenRenderer) Clear() {
-	C.clear()
-	C.endwin()
-}
-
-func (r *FullscreenRenderer) Refresh() {
-	C.refresh()
-}
-
-func (w *CursesWindow) Erase() {
-	C.werase(w.impl)
-}
-
-func (w *CursesWindow) X() int {
-	return int(C.c_getcurx(w.impl))
-}
-
-func (r *FullscreenRenderer) DoesAutoWrap() bool {
-	return true
-}
-
-func (r *FullscreenRenderer) IsOptimized() bool {
-	return true
-}
-
-func (w *CursesWindow) Fill(str string) FillReturn {
-	if C.waddstr(w.impl, C.CString(str)) == C.OK {
-		return FillContinue
-	}
-	return FillSuspend
-}
-
-func (w *CursesWindow) CFill(fg Color, bg Color, attr Attr, str string) FillReturn {
-	index := ColorPair{fg, bg, -1}.index()
-	C.wcolor_set(w.impl, C.short(index), nil)
-	C.wattron(w.impl, C.int(attr))
-	ret := w.Fill(str)
-	C.wattroff(w.impl, C.int(attr))
-	C.wcolor_set(w.impl, 0, nil)
-	return ret
-}
-
-func (r *FullscreenRenderer) RefreshWindows(windows []Window) {
-	for _, w := range windows {
-		w.Refresh()
-	}
-	C.doupdate()
-}
-
-func (p ColorPair) index() int16 {
-	if p.id >= 0 {
-		return p.id
-	}
-
-	// ncurses does not support 24-bit colors
-	if p.is24() {
-		return ColDefault.index()
-	}
-
-	key := p.key()
-	if found, prs := _colorMap[key]; prs {
-		return found
-	}
-
-	id := int16(len(_colorMap)) + ColUser.id
-	C.init_pair(C.short(id), C.short(p.Fg()), C.short(p.Bg()))
-	_colorMap[key] = id
-	return id
-}
-
-func consume(expects ...rune) bool {
-	for _, r := range expects {
-		if int(C.getch()) != int(r) {
-			return false
-		}
-	}
-	return true
-}
-
-func escSequence() Event {
-	C.nodelay(C.stdscr, true)
-	defer func() {
-		C.nodelay(C.stdscr, false)
-	}()
-	c := C.getch()
-	switch c {
-	case C.ERR:
-		return Event{ESC, 0, nil}
-	case CtrlM:
-		return Event{CtrlAltM, 0, nil}
-	case '/':
-		return Event{AltSlash, 0, nil}
-	case ' ':
-		return Event{AltSpace, 0, nil}
-	case 127, C.KEY_BACKSPACE:
-		return Event{AltBS, 0, nil}
-	case '[':
-		// Bracketed paste mode (printf "\e[?2004h")
-		// \e[200~ TEXT \e[201~
-		if consume('2', '0', '0', '~') {
-			return Event{Invalid, 0, nil}
-		}
-	}
-	if c >= 'a' && c <= 'z' {
-		return Event{AltA + int(c) - 'a', 0, nil}
-	}
-
-	if c >= '0' && c <= '9' {
-		return Event{Alt0 + int(c) - '0', 0, nil}
-	}
-
-	// Don't care. Ignore the rest.
-	for ; c != C.ERR; c = C.getch() {
-	}
-	return Event{Invalid, 0, nil}
-}
-
-func (r *FullscreenRenderer) GetChar() Event {
-	c := C.getch()
-	switch c {
-	case C.ERR:
-		// Unexpected error from blocking read
-		r.Close()
-		errorExit("Failed to read /dev/tty")
-	case C.KEY_UP:
-		return Event{Up, 0, nil}
-	case C.KEY_DOWN:
-		return Event{Down, 0, nil}
-	case C.KEY_LEFT:
-		return Event{Left, 0, nil}
-	case C.KEY_RIGHT:
-		return Event{Right, 0, nil}
-	case C.KEY_HOME:
-		return Event{Home, 0, nil}
-	case C.KEY_END:
-		return Event{End, 0, nil}
-	case C.KEY_BACKSPACE:
-		return Event{BSpace, 0, nil}
-	case C.KEY_F0 + 1:
-		return Event{F1, 0, nil}
-	case C.KEY_F0 + 2:
-		return Event{F2, 0, nil}
-	case C.KEY_F0 + 3:
-		return Event{F3, 0, nil}
-	case C.KEY_F0 + 4:
-		return Event{F4, 0, nil}
-	case C.KEY_F0 + 5:
-		return Event{F5, 0, nil}
-	case C.KEY_F0 + 6:
-		return Event{F6, 0, nil}
-	case C.KEY_F0 + 7:
-		return Event{F7, 0, nil}
-	case C.KEY_F0 + 8:
-		return Event{F8, 0, nil}
-	case C.KEY_F0 + 9:
-		return Event{F9, 0, nil}
-	case C.KEY_F0 + 10:
-		return Event{F10, 0, nil}
-	case C.KEY_F0 + 11:
-		return Event{F11, 0, nil}
-	case C.KEY_F0 + 12:
-		return Event{F12, 0, nil}
-	case C.KEY_DC:
-		return Event{Del, 0, nil}
-	case C.KEY_PPAGE:
-		return Event{PgUp, 0, nil}
-	case C.KEY_NPAGE:
-		return Event{PgDn, 0, nil}
-	case C.KEY_BTAB:
-		return Event{BTab, 0, nil}
-	case C.KEY_ENTER:
-		return Event{CtrlM, 0, nil}
-	case C.KEY_SLEFT:
-		return Event{SLeft, 0, nil}
-	case C.KEY_SRIGHT:
-		return Event{SRight, 0, nil}
-	case C.KEY_MOUSE:
-		var me C.MEVENT
-		if C.getmouse(&me) != C.ERR {
-			mod := ((me.bstate & C.BUTTON_SHIFT) | (me.bstate & C.BUTTON_CTRL) | (me.bstate & C.BUTTON_ALT)) > 0
-			x := int(me.x)
-			y := int(me.y)
-			/* Cannot use BUTTON1_DOUBLE_CLICKED due to mouseinterval(0) */
-			if (me.bstate & C.BUTTON1_PRESSED) > 0 {
-				now := time.Now()
-				if now.Sub(r.prevDownTime) < doubleClickDuration {
-					r.clickY = append(r.clickY, y)
-				} else {
-					r.clickY = []int{y}
-					r.prevDownTime = now
-				}
-				return Event{Mouse, 0, &MouseEvent{y, x, 0, true, false, mod}}
-			} else if (me.bstate & C.BUTTON1_RELEASED) > 0 {
-				double := false
-				if len(r.clickY) > 1 && r.clickY[0] == r.clickY[1] &&
-					time.Now().Sub(r.prevDownTime) < doubleClickDuration {
-					double = true
-				}
-				return Event{Mouse, 0, &MouseEvent{y, x, 0, false, double, mod}}
-			} else if (me.bstate&0x8000000) > 0 || (me.bstate&0x80) > 0 {
-				return Event{Mouse, 0, &MouseEvent{y, x, -1, false, false, mod}}
-			} else if (me.bstate & C.BUTTON4_PRESSED) > 0 {
-				return Event{Mouse, 0, &MouseEvent{y, x, 1, false, false, mod}}
-			}
-		}
-		return Event{Invalid, 0, nil}
-	case C.KEY_RESIZE:
-		return Event{Resize, 0, nil}
-	case ESC:
-		return escSequence()
-	case 127:
-		return Event{BSpace, 0, nil}
-	case 0:
-		return Event{CtrlSpace, 0, nil}
-	}
-	// CTRL-A ~ CTRL-Z
-	if c >= CtrlA && c <= CtrlZ {
-		return Event{int(c), 0, nil}
-	}
-
-	// Multi-byte character
-	buffer := []byte{byte(c)}
-	for {
-		r, _ := utf8.DecodeRune(buffer)
-		if r != utf8.RuneError {
-			return Event{Rune, r, nil}
-		}
-
-		c := C.getch()
-		if c == C.ERR {
-			break
-		}
-		if c >= C.KEY_CODE_YES {
-			C.ungetch(c)
-			break
-		}
-		buffer = append(buffer, byte(c))
-	}
-	return Event{Invalid, 0, nil}
-}

src/tui/tcell.go

@@ -164,11 +164,11 @@ func (w *TcellWindow) X() int {
 	return w.lastX
 }
 
-func (r *FullscreenRenderer) DoesAutoWrap() bool {
+func (w *TcellWindow) Y() int {
-	return false
+	return w.lastY
 }
 
-func (r *FullscreenRenderer) IsOptimized() bool {
+func (r *FullscreenRenderer) DoesAutoWrap() bool {
 	return false
 }
 
@@ -193,19 +193,22 @@ func (r *FullscreenRenderer) GetChar() Event {
 		button := ev.Buttons()
 		mod := ev.Modifiers() != 0
 		if button&tcell.WheelDown != 0 {
-			return Event{Mouse, 0, &MouseEvent{y, x, -1, false, false, mod}}
+			return Event{Mouse, 0, &MouseEvent{y, x, -1, false, false, false, mod}}
 		} else if button&tcell.WheelUp != 0 {
-			return Event{Mouse, 0, &MouseEvent{y, x, +1, false, false, mod}}
+			return Event{Mouse, 0, &MouseEvent{y, x, +1, false, false, false, mod}}
 		} else if runtime.GOOS != "windows" {
 			// double and single taps on Windows don't quite work due to
 			// the console acting on the events and not allowing us
 			// to consume them.
 
-			down := button&tcell.Button1 != 0 // left
+			left := button&tcell.Button1 != 0
+			down := left || button&tcell.Button3 != 0
 			double := false
 			if down {
 				now := time.Now()
-				if now.Sub(r.prevDownTime) < doubleClickDuration {
+				if !left {
+					r.clickY = []int{}
+				} else if now.Sub(r.prevDownTime) < doubleClickDuration {
 					r.clickY = append(r.clickY, x)
 				} else {
 					r.clickY = []int{x}
@@ -218,7 +221,7 @@ func (r *FullscreenRenderer) GetChar() Event {
 				}
 			}
 
-			return Event{Mouse, 0, &MouseEvent{y, x, 0, down, double, mod}}
+			return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, mod}}
 		}
 
 		// process keyboard:
@@ -405,14 +408,13 @@ func (w *TcellWindow) Close() {
 func fill(x, y, w, h int, r rune) {
 	for ly := 0; ly <= h; ly++ {
 		for lx := 0; lx <= w; lx++ {
-			_screen.SetContent(x+lx, y+ly, r, nil, ColDefault.style())
+			_screen.SetContent(x+lx, y+ly, r, nil, ColNormal.style())
 		}
 	}
 }
 
 func (w *TcellWindow) Erase() {
-	// TODO
+	fill(w.left-1, w.top, w.width+1, w.height, ' ')
-	fill(w.left, w.top, w.width, w.height, ' ')
 }
 
 func (w *TcellWindow) Enclose(y int, x int) bool {
@@ -429,13 +431,13 @@ func (w *TcellWindow) Move(y int, x int) {
 func (w *TcellWindow) MoveAndClear(y int, x int) {
 	w.Move(y, x)
 	for i := w.lastX; i < w.width; i++ {
-		_screen.SetContent(i+w.left, w.lastY+w.top, rune(' '), nil, ColDefault.style())
+		_screen.SetContent(i+w.left, w.lastY+w.top, rune(' '), nil, ColNormal.style())
 	}
 	w.lastX = x
 }
 
 func (w *TcellWindow) Print(text string) {
-	w.printString(text, ColDefault, 0)
+	w.printString(text, ColNormal, 0)
 }
 
 func (w *TcellWindow) printString(text string, pair ColorPair, a Attr) {
@@ -448,7 +450,7 @@ func (w *TcellWindow) printString(text string, pair ColorPair, a Attr) {
 			Reverse(a&Attr(tcell.AttrReverse) != 0).
 			Underline(a&Attr(tcell.AttrUnderline) != 0)
 	} else {
-		style = ColDefault.style().
+		style = ColNormal.style().
 			Reverse(a&Attr(tcell.AttrReverse) != 0 || pair == ColCurrent || pair == ColCurrentMatch).
 			Underline(a&Attr(tcell.AttrUnderline) != 0 || pair == ColMatch || pair == ColCurrentMatch)
 	}
@@ -499,7 +501,7 @@ func (w *TcellWindow) fillString(text string, pair ColorPair, a Attr) FillReturn
 	if w.color {
 		style = pair.style()
 	} else {
-		style = ColDefault.style()
+		style = ColNormal.style()
 	}
 	style = style.
 		Blink(a&Attr(tcell.AttrBlink) != 0).
@@ -539,11 +541,17 @@ func (w *TcellWindow) fillString(text string, pair ColorPair, a Attr) FillReturn
 }
 
 func (w *TcellWindow) Fill(str string) FillReturn {
-	return w.fillString(str, ColDefault, 0)
+	return w.fillString(str, ColNormal, 0)
 }
 
 func (w *TcellWindow) CFill(fg Color, bg Color, a Attr, str string) FillReturn {
-	return w.fillString(str, ColorPair{fg, bg, -1}, a)
+	if fg == colDefault {
+		fg = ColNormal.Fg()
+	}
+	if bg == colDefault {
+		bg = ColNormal.Bg()
+	}
+	return w.fillString(str, NewColorPair(fg, bg), a)
 }
 
 func (w *TcellWindow) drawBorder(around bool) {
@@ -556,7 +564,7 @@ func (w *TcellWindow) drawBorder(around bool) {
 	if w.color {
 		style = ColBorder.style()
 	} else {
-		style = ColDefault.style()
+		style = ColNormal.style()
 	}
 
 	for x := left; x < right; x++ {

src/tui/tui.go

@@ -44,6 +44,8 @@ const (
 	Resize
 	Mouse
 	DoubleClick
+	LeftClick
+	RightClick
 
 	BTab
 	BSpace
@@ -133,7 +135,7 @@ const (
 type ColorPair struct {
 	fg Color
 	bg Color
-	id int16
+	id int
 }
 
 func HexToColor(rrggbb string) Color {
@@ -155,12 +157,8 @@ func (p ColorPair) Bg() Color {
 	return p.bg
 }
 
-func (p ColorPair) key() int {
-	return (int(p.Fg()) << 8) + int(p.Bg())
-}
-
 func (p ColorPair) is24() bool {
-	return p.Fg().is24() || p.Bg().is24()
+	return p.fg.is24() || p.bg.is24()
 }
 
 type ColorTheme struct {
@@ -179,10 +177,6 @@ type ColorTheme struct {
 	Border       Color
 }
 
-func (t *ColorTheme) HasBg() bool {
-	return t.Bg != colDefault
-}
-
 type Event struct {
 	Type       int
 	Char       rune
@@ -193,6 +187,7 @@ type MouseEvent struct {
 	Y      int
 	X      int
 	S      int
+	Left   bool
 	Down   bool
 	Double bool
 	Mod    bool
@@ -220,7 +215,6 @@ type Renderer interface {
 	MaxX() int
 	MaxY() int
 	DoesAutoWrap() bool
-	IsOptimized() bool
 
 	NewWindow(top int, left int, width int, height int, borderStyle BorderStyle) Window
 }
@@ -236,6 +230,7 @@ type Window interface {
 	Close()
 
 	X() int
+	Y() int
 	Enclose(y int, x int) bool
 
 	Move(y int, x int)
@@ -270,7 +265,6 @@ var (
 	Dark256   *ColorTheme
 	Light256  *ColorTheme
 
-	ColDefault      ColorPair
 	ColNormal       ColorPair
 	ColPrompt       ColorPair
 	ColMatch        ColorPair
@@ -282,7 +276,6 @@ var (
 	ColSelected     ColorPair
 	ColHeader       ColorPair
 	ColBorder       ColorPair
-	ColUser         ColorPair
 )
 
 func EmptyTheme() *ColorTheme {
@@ -386,33 +379,36 @@ func initTheme(theme *ColorTheme, baseTheme *ColorTheme, forceBlack bool) {
 }
 
 func initPalette(theme *ColorTheme) {
-	ColDefault = ColorPair{colDefault, colDefault, 0}
+	idx := 0
-	if theme != nil {
+	pair := func(fg, bg Color) ColorPair {
-		ColNormal = ColorPair{theme.Fg, theme.Bg, 1}
+		idx++
-		ColPrompt = ColorPair{theme.Prompt, theme.Bg, 2}
+		return ColorPair{fg, bg, idx}
-		ColMatch = ColorPair{theme.Match, theme.Bg, 3}
+	}
-		ColCurrent = ColorPair{theme.Current, theme.DarkBg, 4}
+	if theme != nil {
-		ColCurrentMatch = ColorPair{theme.CurrentMatch, theme.DarkBg, 5}
+		ColNormal = pair(theme.Fg, theme.Bg)
-		ColSpinner = ColorPair{theme.Spinner, theme.Bg, 6}
+		ColPrompt = pair(theme.Prompt, theme.Bg)
-		ColInfo = ColorPair{theme.Info, theme.Bg, 7}
+		ColMatch = pair(theme.Match, theme.Bg)
-		ColCursor = ColorPair{theme.Cursor, theme.DarkBg, 8}
+		ColCurrent = pair(theme.Current, theme.DarkBg)
-		ColSelected = ColorPair{theme.Selected, theme.DarkBg, 9}
+		ColCurrentMatch = pair(theme.CurrentMatch, theme.DarkBg)
-		ColHeader = ColorPair{theme.Header, theme.Bg, 10}
+		ColSpinner = pair(theme.Spinner, theme.Bg)
-		ColBorder = ColorPair{theme.Border, theme.Bg, 11}
+		ColInfo = pair(theme.Info, theme.Bg)
-	} else {
+		ColCursor = pair(theme.Cursor, theme.DarkBg)
-		ColNormal = ColorPair{colDefault, colDefault, 1}
+		ColSelected = pair(theme.Selected, theme.DarkBg)
-		ColPrompt = ColorPair{colDefault, colDefault, 2}
+		ColHeader = pair(theme.Header, theme.Bg)
-		ColMatch = ColorPair{colDefault, colDefault, 3}
+		ColBorder = pair(theme.Border, theme.Bg)
-		ColCurrent = ColorPair{colDefault, colDefault, 4}
+	} else {
-		ColCurrentMatch = ColorPair{colDefault, colDefault, 5}
+		ColNormal = pair(colDefault, colDefault)
-		ColSpinner = ColorPair{colDefault, colDefault, 6}
+		ColPrompt = pair(colDefault, colDefault)
-		ColInfo = ColorPair{colDefault, colDefault, 7}
+		ColMatch = pair(colDefault, colDefault)
-		ColCursor = ColorPair{colDefault, colDefault, 8}
+		ColCurrent = pair(colDefault, colDefault)
-		ColSelected = ColorPair{colDefault, colDefault, 9}
+		ColCurrentMatch = pair(colDefault, colDefault)
-		ColHeader = ColorPair{colDefault, colDefault, 10}
+		ColSpinner = pair(colDefault, colDefault)
-		ColBorder = ColorPair{colDefault, colDefault, 11}
+		ColInfo = pair(colDefault, colDefault)
+		ColCursor = pair(colDefault, colDefault)
+		ColSelected = pair(colDefault, colDefault)
+		ColHeader = pair(colDefault, colDefault)
+		ColBorder = pair(colDefault, colDefault)
 	}
-	ColUser = ColorPair{colDefault, colDefault, 12}
 }
 
 func attrFor(color ColorPair, attr Attr) Attr {

src/util/chars.go

@@ -3,63 +3,103 @@ package util
 import (
 	"unicode"
 	"unicode/utf8"
+	"unsafe"
+)
+
+const (
+	overflow64 uint64 = 0x8080808080808080
+	overflow32 uint32 = 0x80808080
 )
 
 type Chars struct {
-	runes []rune
+	slice           []byte // or []rune
-	bytes []byte
+	inBytes         bool
+	trimLengthKnown bool
+	trimLength      uint16
+
+	// XXX Piggybacking item index here is a horrible idea. But I'm trying to
+	// minimize the memory footprint by not wasting padded spaces.
+	Index int32
+}
+
+func checkAscii(bytes []byte) (bool, int) {
+	i := 0
+	for ; i <= len(bytes)-8; i += 8 {
+		if (overflow64 & *(*uint64)(unsafe.Pointer(&bytes[i]))) > 0 {
+			return false, i
+		}
+	}
+	for ; i <= len(bytes)-4; i += 4 {
+		if (overflow32 & *(*uint32)(unsafe.Pointer(&bytes[i]))) > 0 {
+			return false, i
+		}
+	}
+	for ; i < len(bytes); i++ {
+		if bytes[i] >= utf8.RuneSelf {
+			return false, i
+		}
+	}
+	return true, 0
 }
 
 // ToChars converts byte array into rune array
-func ToChars(bytea []byte) Chars {
+func ToChars(bytes []byte) Chars {
-	var runes []rune
+	inBytes, bytesUntil := checkAscii(bytes)
-	ascii := true
+	if inBytes {
-	numBytes := len(bytea)
+		return Chars{slice: bytes, inBytes: inBytes}
-	for i := 0; i < numBytes; {
-		if bytea[i] < utf8.RuneSelf {
-			if !ascii {
-				runes = append(runes, rune(bytea[i]))
-			}
-			i++
-		} else {
-			if ascii {
-				ascii = false
-				runes = make([]rune, i, numBytes)
-				for j := 0; j < i; j++ {
-					runes[j] = rune(bytea[j])
-				}
-			}
-			r, sz := utf8.DecodeRune(bytea[i:])
-			i += sz
-			runes = append(runes, r)
-		}
 	}
-	if ascii {
+
-		return Chars{bytes: bytea}
+	runes := make([]rune, bytesUntil, len(bytes))
+	for i := 0; i < bytesUntil; i++ {
+		runes[i] = rune(bytes[i])
 	}
-	return Chars{runes: runes}
+	for i := bytesUntil; i < len(bytes); {
+		r, sz := utf8.DecodeRune(bytes[i:])
+		i += sz
+		runes = append(runes, r)
+	}
+	return RunesToChars(runes)
 }
 
 func RunesToChars(runes []rune) Chars {
-	return Chars{runes: runes}
+	return Chars{slice: *(*[]byte)(unsafe.Pointer(&runes)), inBytes: false}
+}
+
+func (chars *Chars) IsBytes() bool {
+	return chars.inBytes
+}
+
+func (chars *Chars) Bytes() []byte {
+	return chars.slice
+}
+
+func (chars *Chars) optionalRunes() []rune {
+	if chars.inBytes {
+		return nil
+	}
+	return *(*[]rune)(unsafe.Pointer(&chars.slice))
 }
 
 func (chars *Chars) Get(i int) rune {
-	if chars.runes != nil {
+	if runes := chars.optionalRunes(); runes != nil {
-		return chars.runes[i]
+		return runes[i]
 	}
-	return rune(chars.bytes[i])
+	return rune(chars.slice[i])
 }
 
 func (chars *Chars) Length() int {
-	if chars.runes != nil {
+	if runes := chars.optionalRunes(); runes != nil {
-		return len(chars.runes)
+		return len(runes)
 	}
-	return len(chars.bytes)
+	return len(chars.slice)
 }
 
 // TrimLength returns the length after trimming leading and trailing whitespaces
-func (chars *Chars) TrimLength() int {
+func (chars *Chars) TrimLength() uint16 {
+	if chars.trimLengthKnown {
+		return chars.trimLength
+	}
+	chars.trimLengthKnown = true
 	var i int
 	len := chars.Length()
 	for i = len - 1; i >= 0; i-- {
@@ -80,7 +120,8 @@ func (chars *Chars) TrimLength() int {
 			break
 		}
 	}
-	return i - j + 1
+	chars.trimLength = AsUint16(i - j + 1)
+	return chars.trimLength
 }
 
 func (chars *Chars) TrailingWhitespaces() int {
@@ -96,62 +137,31 @@ func (chars *Chars) TrailingWhitespaces() int {
 }
 
 func (chars *Chars) ToString() string {
-	if chars.runes != nil {
+	if runes := chars.optionalRunes(); runes != nil {
-		return string(chars.runes)
+		return string(runes)
 	}
-	return string(chars.bytes)
+	return string(chars.slice)
 }
 
 func (chars *Chars) ToRunes() []rune {
-	if chars.runes != nil {
+	if runes := chars.optionalRunes(); runes != nil {
-		return chars.runes
+		return runes
 	}
-	runes := make([]rune, len(chars.bytes))
+	bytes := chars.slice
-	for idx, b := range chars.bytes {
+	runes := make([]rune, len(bytes))
+	for idx, b := range bytes {
 		runes[idx] = rune(b)
 	}
 	return runes
 }
 
-func (chars *Chars) Slice(b int, e int) Chars {
+func (chars *Chars) CopyRunes(dest []rune) {
-	if chars.runes != nil {
+	if runes := chars.optionalRunes(); runes != nil {
-		return Chars{runes: chars.runes[b:e]}
+		copy(dest, runes)
+		return
 	}
-	return Chars{bytes: chars.bytes[b:e]}
+	for idx, b := range chars.slice[:len(dest)] {
-}
+		dest[idx] = rune(b)
-
+	}
-func (chars *Chars) Split(delimiter string) []Chars {
+	return
-	delim := []rune(delimiter)
-	numChars := chars.Length()
-	numDelim := len(delim)
-	begin := 0
-	ret := make([]Chars, 0, 1)
-
-	for index := 0; index < numChars; {
-		if index+numDelim <= numChars {
-			match := true
-			for off, d := range delim {
-				if chars.Get(index+off) != d {
-					match = false
-					break
-				}
-			}
-			// Found the delimiter
-			if match {
-				incr := Max(numDelim, 1)
-				ret = append(ret, chars.Slice(begin, index+incr))
-				index += incr
-				begin = index
-				continue
-			}
-		} else {
-			// Impossible to find the delimiter in the remaining substring
-			break
-		}
-		index++
-	}
-	if begin < numChars || len(ret) == 0 {
-		ret = append(ret, chars.Slice(begin, numChars))
-	}
-	return ret
 }

src/util/chars_test.go

@@ -2,27 +2,16 @@ package util
 
 import "testing"
 
-func TestToCharsNil(t *testing.T) {
-	bs := Chars{bytes: []byte{}}
-	if bs.bytes == nil || bs.runes != nil {
-		t.Error()
-	}
-	rs := RunesToChars([]rune{})
-	if rs.bytes != nil || rs.runes == nil {
-		t.Error()
-	}
-}
-
 func TestToCharsAscii(t *testing.T) {
 	chars := ToChars([]byte("foobar"))
-	if chars.ToString() != "foobar" || chars.runes != nil {
+	if !chars.inBytes || chars.ToString() != "foobar" || !chars.inBytes {
 		t.Error()
 	}
 }
 
 func TestCharsLength(t *testing.T) {
 	chars := ToChars([]byte("\tabc한글  "))
-	if chars.Length() != 8 || chars.TrimLength() != 5 {
+	if chars.inBytes || chars.Length() != 8 || chars.TrimLength() != 5 {
 		t.Error()
 	}
 }
@@ -36,7 +25,7 @@ func TestCharsToString(t *testing.T) {
 }
 
 func TestTrimLength(t *testing.T) {
-	check := func(str string, exp int) {
+	check := func(str string, exp uint16) {
 		chars := ToChars([]byte(str))
 		trimmed := chars.TrimLength()
 		if trimmed != exp {
@@ -55,28 +44,3 @@ func TestTrimLength(t *testing.T) {
 	check("  h   o  ", 5)
 	check("         ", 0)
 }
-
-func TestSplit(t *testing.T) {
-	check := func(str string, delim string, tokens ...string) {
-		input := ToChars([]byte(str))
-		result := input.Split(delim)
-		if len(result) != len(tokens) {
-			t.Errorf("Invalid Split result for '%s': %d tokens found (expected %d): %s",
-				str, len(result), len(tokens), result)
-		}
-		for idx, token := range tokens {
-			if result[idx].ToString() != token {
-				t.Errorf("Invalid Split result for '%s': %s (expected %s)",
-					str, result[idx].ToString(), token)
-			}
-		}
-	}
-	check("abc:def::", ":", "abc:", "def:", ":")
-	check("abc:def::", "-", "abc:def::")
-	check("abc", "", "a", "b", "c")
-	check("abc", "a", "a", "bc")
-	check("abc", "ab", "ab", "c")
-	check("abc", "abc", "abc")
-	check("abc", "abcd", "abc")
-	check("", "abcd", "")
-}

src/util/eventbox.go

@@ -26,23 +26,23 @@ func NewEventBox() *EventBox {
 // Wait blocks the goroutine until signaled
 func (b *EventBox) Wait(callback func(*Events)) {
 	b.cond.L.Lock()
-	defer b.cond.L.Unlock()
 
 	if len(b.events) == 0 {
 		b.cond.Wait()
 	}
 
 	callback(&b.events)
+	b.cond.L.Unlock()
 }
 
 // Set turns on the event type on the box
 func (b *EventBox) Set(event EventType, value interface{}) {
 	b.cond.L.Lock()
-	defer b.cond.L.Unlock()
 	b.events[event] = value
 	if _, found := b.ignore[event]; !found {
 		b.cond.Broadcast()
 	}
+	b.cond.L.Unlock()
 }
 
 // Clear clears the events
@@ -56,27 +56,27 @@ func (events *Events) Clear() {
 // Peek peeks at the event box if the given event is set
 func (b *EventBox) Peek(event EventType) bool {
 	b.cond.L.Lock()
-	defer b.cond.L.Unlock()
 	_, ok := b.events[event]
+	b.cond.L.Unlock()
 	return ok
 }
 
 // Watch deletes the events from the ignore list
 func (b *EventBox) Watch(events ...EventType) {
 	b.cond.L.Lock()
-	defer b.cond.L.Unlock()
 	for _, event := range events {
 		delete(b.ignore, event)
 	}
+	b.cond.L.Unlock()
 }
 
 // Unwatch adds the events to the ignore list
 func (b *EventBox) Unwatch(events ...EventType) {
 	b.cond.L.Lock()
-	defer b.cond.L.Unlock()
 	for _, event := range events {
 		b.ignore[event] = true
 	}
+	b.cond.L.Unlock()
 }
 
 // WaitFor blocks the execution until the event is received

src/util/util_unix.go

@@ -14,6 +14,11 @@ func ExecCommand(command string) *exec.Cmd {
 	if len(shell) == 0 {
 		shell = "sh"
 	}
+	return ExecCommandWith(shell, command)
+}
+
+// ExecCommandWith executes the given command with the specified shell
+func ExecCommandWith(shell string, command string) *exec.Cmd {
 	return exec.Command(shell, "-c", command)
 }
 

src/util/util_windows.go

@@ -3,20 +3,27 @@
 package util
 
 import (
+	"fmt"
 	"os"
 	"os/exec"
 	"syscall"
-
-	"github.com/mattn/go-shellwords"
 )
 
-// ExecCommand executes the given command with $SHELL
+// ExecCommand executes the given command with cmd
 func ExecCommand(command string) *exec.Cmd {
-	args, _ := shellwords.Parse(command)
+	return ExecCommandWith("cmd", command)
-	allArgs := make([]string, len(args)+1)
+}
-	allArgs[0] = "/c"
+
-	copy(allArgs[1:], args)
+// ExecCommandWith executes the given command with cmd. _shell parameter is
-	return exec.Command("cmd", allArgs...)
+// ignored on Windows.
+func ExecCommandWith(_shell string, command string) *exec.Cmd {
+	cmd := exec.Command("cmd")
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		HideWindow:    false,
+		CmdLine:       fmt.Sprintf(` /s /c "%s"`, command),
+		CreationFlags: 0,
+	}
+	return cmd
 }
 
 // IsWindows returns true on Windows

test/fzf.vader

@@ -6,11 +6,11 @@ Execute (Setup):
 
 Execute (fzf#run with dir option):
   let cwd = getcwd()
-  let result = fzf#run({ 'options': '--filter=vdr', 'dir': g:dir })
+  let result = fzf#run({ 'source': 'git ls-files', 'options': '--filter=vdr', 'dir': g:dir })
   AssertEqual ['fzf.vader'], result
   AssertEqual getcwd(), cwd
 
-  let result = sort(fzf#run({ 'options': '--filter e', 'dir': g:dir }))
+  let result = sort(fzf#run({ 'source': 'git ls-files', 'options': '--filter e', 'dir': g:dir }))
   AssertEqual ['fzf.vader', 'test_go.rb'], result
   AssertEqual getcwd(), cwd
 
@@ -19,7 +19,7 @@ Execute (fzf#run with Funcref command):
   function! g:FzfTest(e)
     call add(g:ret, a:e)
   endfunction
-  let result = sort(fzf#run({ 'sink': function('g:FzfTest'), 'options': '--filter e', 'dir': g:dir }))
+  let result = sort(fzf#run({ 'source': 'git ls-files', 'sink': function('g:FzfTest'), 'options': '--filter e', 'dir': g:dir }))
   AssertEqual ['fzf.vader', 'test_go.rb'], result
   AssertEqual ['fzf.vader', 'test_go.rb'], sort(g:ret)
 
@@ -140,7 +140,7 @@ Execute (fzf#wrap):
   let g:fzf_history_dir = '/tmp'
   let opts = fzf#wrap('foobar', {'options': '--color light'})
   Log opts
-  Assert opts.options =~ '--history /tmp/foobar'
+  Assert opts.options =~ "--history '/tmp/foobar'"
   Assert opts.options =~ '--color light'
 
   let g:fzf_colors = { 'fg': ['fg', 'Error'] }
@@ -149,21 +149,23 @@ Execute (fzf#wrap):
 
 Execute (fzf#shellescape with sh):
   AssertEqual '''''', fzf#shellescape('', 'sh')
+  AssertEqual '''\''', fzf#shellescape('\', 'sh')
   AssertEqual '''""''', fzf#shellescape('""', 'sh')
   AssertEqual '''foobar>''', fzf#shellescape('foobar>', 'sh')
-  AssertEqual '''\"''', fzf#shellescape('\"', 'sh')
+  AssertEqual '''\\\"\\\''', fzf#shellescape('\\\"\\\', 'sh')
   AssertEqual '''echo ''\''''a''\'''' && echo ''\''''b''\''''''', fzf#shellescape('echo ''a'' && echo ''b''', 'sh')
 
 Execute (fzf#shellescape with cmd.exe):
   AssertEqual '^"^"', fzf#shellescape('', 'cmd.exe')
+  AssertEqual '^"\\^"', fzf#shellescape('\', 'cmd.exe')
   AssertEqual '^"\^"\^"^"', fzf#shellescape('""', 'cmd.exe')
   AssertEqual '^"foobar^>^"', fzf#shellescape('foobar>', 'cmd.exe')
-  AssertEqual '^"\\\^"\\^"', fzf#shellescape('\\\\\\\\"\', 'cmd.exe')
+  AssertEqual '^"\\\\\\\^"\\\\\\^"', fzf#shellescape('\\\"\\\', 'cmd.exe')
   AssertEqual '^"echo ''a'' ^&^& echo ''b''^"', fzf#shellescape('echo ''a'' && echo ''b''', 'cmd.exe')
 
   AssertEqual '^"C:\Program Files ^(x86^)\\^"', fzf#shellescape('C:\Program Files (x86)\', 'cmd.exe')
   AssertEqual '^"C:/Program Files ^(x86^)/^"', fzf#shellescape('C:/Program Files (x86)/', 'cmd.exe')
-  " AssertEqual '^"%%USERPROFILE%%^", fzf#shellescape('%USERPROFILE%', 'cmd.exe')
+  AssertEqual '^"%%USERPROFILE%%^"', fzf#shellescape('%USERPROFILE%', 'cmd.exe')
 
 Execute (Cleanup):
   unlet g:dir