0.17.0

Similarly to --bind or --color.

--expect used to replace the previously specified keys, and
fzf#wrap({'options': '--expect=f1'}) wouldn't work as expected. It
forced us to come up with some ugly hacks like the following:

13b27c45c8/autoload/fzf/vim.vim (L1086)

.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,6 +1,23 @@
 CHANGELOG
 =========
 
+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

README-VIM.md

@@ -55,6 +55,19 @@ 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%' }

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
 
@@ -20,7 +24,7 @@ Table of Contents
 
    * [Installation](#installation)
       * [Using git](#using-git)
-      * [Using Homebrew](#using-homebrew)
+      * [Using Homebrew or Linuxbrew](#using-homebrew-or-linuxbrew)
       * [As Vim plugin](#as-vim-plugin)
       * [Windows](#windows)
    * [Upgrading fzf](#upgrading-fzf)
@@ -42,6 +46,10 @@ 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)
       * [git ls-tree for fast traversal](#git-ls-tree-for-fast-traversal)
@@ -75,9 +83,10 @@ git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
 ~/.fzf/install
 ```
 
-### Using Homebrew
+### Using Homebrew or Linuxbrew
 
-On OS X, you can use [Homebrew](http://brew.sh/) to install fzf.
+Alternatively, you can use [Homebrew](http://brew.sh/) or
+[Linuxbrew](http://linuxbrew.sh/) to install fzf.
 
 ```sh
 brew install fzf
@@ -383,13 +392,94 @@ 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.16.11.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`
 
 [ag](https://github.com/ggreer/the_silver_searcher) or
-[pt](https://github.com/monochromegane/the_platinum_searcher) will do the
+[rg](https://github.com/BurntSushi/ripgrep) will do the
 filtering:
 
 ```sh
@@ -426,10 +516,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

bin/fzf-tmux

@@ -146,6 +146,7 @@ cleanup() {
   fi
 
   if [ $# -gt 0 ]; then
+    trap - EXIT
     exit 130
   fi
 }
@@ -170,21 +171,22 @@ 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
+  cat $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 "cd $(printf %q "$PWD");$envs 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 $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: August 14 2017
 FZF - TABLE OF CONTENTS                                            *fzf* *fzf-toc*
 ==============================================================================
 
@@ -80,6 +80,19 @@ 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%' }

install

@@ -2,7 +2,7 @@
 
 set -u
 
-version=0.16.9
+version=0.17.0
 auto_completion=
 key_bindings=
 update_config=2
@@ -171,6 +171,8 @@ case "$archi" in
   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
 

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 "Jul 2017" "fzf 0.16.9" "fzf-tmux - open fzf in tmux split pane"
+.TH fzf-tmux 1 "Aug 2017" "fzf 0.17.0" "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 "Jul 2017" "fzf 0.16.9" "fzf - a command-line fuzzy finder"
+.TH fzf 1 "Aug 2017" "fzf 0.17.0" "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
@@ -328,10 +331,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"
@@ -357,6 +362,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
@@ -404,6 +412,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

plugin/fzf.vim

@@ -66,8 +66,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, ...)
@@ -201,7 +201,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'
@@ -217,7 +220,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)
@@ -337,13 +340,6 @@ try
     set shell=sh
   endif
 
-  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', ''))
@@ -466,11 +462,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()
@@ -688,7 +684,7 @@ function! s:execute_term(dict, command, temps) abort
       lcd -
     endif
   endtry
-  setlocal nospell bufhidden=wipe nobuflisted
+  setlocal nospell bufhidden=wipe nobuflisted nonumber
   setf fzf
   startinsert
   return []
@@ -719,7 +715,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
@@ -743,7 +739,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
@@ -756,7 +752,7 @@ let s:default_action = {
 function! s:shortpath()
   let short = pathshorten(fnamemodify(getcwd(), ':~:.'))
   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

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,159 +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)
-
-	// Phase 1. Check if there's a match and calculate bonus for each point
-	pidx, lastIdx, prevClass := 0, 0, charNonWord
 	input.CopyRunes(T)
-	for idx := 0; idx < N; idx++ {
+
-		char := T[idx]
+	// Phase 2. Calculate bonus for each point
+	maxScore, maxScorePos := int16(0), 0
+	pidx, lastIdx := 0, 0
+	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(T[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
@@ -452,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
@@ -512,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
@@ -595,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
 	}
@@ -607,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)
@@ -661,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
 	}
@@ -688,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 {
@@ -719,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

@@ -73,15 +73,13 @@ func extractColor(str string, state *ansiState, proc func(string, *ansiState) bo
 	runeCount := 0
 	for idx := 0; idx < len(str); {
 		idx += findAnsiStart(str[idx:])
-
-		// No sign of ANSI code
 		if idx == len(str) {
 			break
 		}
 
 		// Make sure that we found an ANSI code
 		offset := ansiRegex.FindStringIndex(str[idx:])
-		if offset == nil {
+		if len(offset) < 2 {
 			idx++
 			continue
 		}
@@ -117,22 +115,30 @@ func extractColor(str string, state *ansiState, proc func(string, *ansiState) bo
 		}
 	}
 
-	rest := str[prevIdx:]
+	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
+	}
-			runeCount += utf8.RuneCountInString(rest)
+	if len(rest) > 0 && state != nil {
-			(&offsets[len(offsets)-1]).offset[1] = int32(runeCount)
+		// 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_test.go

@@ -4,9 +4,8 @@ import "testing"
 
 func TestChunkCache(t *testing.T) {
 	cache := NewChunkCache()
-	chunk2 := make(Chunk, chunkSize)
 	chunk1p := &Chunk{}
-	chunk2p := &chunk2
+	chunk2p := &Chunk{count: chunkSize}
 	items1 := []Result{Result{}}
 	items2 := []Result{Result{}, Result{}}
 	cache.Add(chunk1p, "foo", items1)

src/chunklist.go

@@ -3,16 +3,17 @@ package fzf
 import "sync"
 
 // Chunk is a list of Items whose size has the upper limit of chunkSize
-type Chunk []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,23 +22,21 @@ 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++
-		return false
+		return true
 	}
-	*c = append(*c, item)
+	return false
-	return true
 }
 
 // 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,30 +48,25 @@ 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)
@@ -82,5 +76,7 @@ func (cl *ChunkList) Snapshot() ([]*Chunk, int) {
 		newChunk := *ret[cnt-1]
 		ret[cnt-1] = &newChunk
 	}
-	return ret, cl.count
+
+	cl.mutex.Unlock()
+	return ret, CountItems(ret)
 }

src/chunklist_test.go

@@ -11,10 +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 {
-		chars := util.ToChars(s)
+		item.text = util.ToChars(s)
-		chars.Index = int32(i * 2)
+		return true
-		return Item{text: chars}
 	})
 
 	// Snapshot
@@ -40,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() {
@@ -67,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.9"
+	version = "0.17.0"
 
 	// 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
@@ -68,7 +71,7 @@ const (
 	EvtSearchProgress
 	EvtSearchFin
 	EvtHeader
-	EvtClose
+	EvtReady
 )
 
 const (

src/core.go

@@ -69,54 +69,58 @@ func Run(opts *Options, revision string) {
 			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
 			}
 		}
 	}
 
 	// 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 nilItem
+				return false
 			}
-			chars, colors := ansiProcessor(data)
+			item.text, item.colors = ansiProcessor(data)
-			chars.Index = int32(index)
+			item.text.Index = itemIndex
-			return Item{text: chars, colors: colors}
+			itemIndex++
+			return true
 		})
 	} else {
-		chunkList = NewChunkList(func(data []byte, index int) Item {
+		chunkList = NewChunkList(func(item *Item, data []byte) bool {
 			tokens := Tokenize(string(data), opts.Delimiter)
 			trans := Transform(tokens, opts.WithNth)
 			transformed := joinTokens(trans)
 			if len(header) < opts.HeaderLines {
 				header = append(header, transformed)
 				eventBox.Set(EvtHeader, header)
-				return nilItem
+				return false
 			}
-			trimmed, colors := ansiProcessor([]byte(transformed))
+			item.text, item.colors = ansiProcessor([]byte(transformed))
-			trimmed.Index = int32(index)
+			item.text.Index = itemIndex
-			return Item{text: trimmed, colors: colors, origText: &data}
+			item.origText = &data
+			itemIndex++
+			return true
 		})
 	}
 
 	// 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()
 	}
 
@@ -149,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 {
 							opts.Printer(item.text.ToString())
 							found = true
 						}
 					}
 					return false
-				}, eventBox, opts.ReadZero}
+				}, eventBox, opts.ReadZero)
 			reader.ReadSource()
 		} else {
 			eventBox.Unwatch(EvtReadNew)
@@ -205,7 +209,9 @@ 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 {
 
@@ -213,6 +219,9 @@ func Run(opts *Options, revision string) {
 					reading = reading && evt == EvtReadNew
 					snapshot, count := chunkList.Snapshot()
 					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:
@@ -265,6 +274,7 @@ func Run(opts *Options, revision string) {
 					}
 				}
 			}
+			events.Clear()
 		})
 		if delay && reading {
 			dur := util.DurWithin(

src/item.go

@@ -17,11 +17,7 @@ func (item *Item) Index() int32 {
 	return item.text.Index
 }
 
-var nilItem = Item{text: util.Chars{Index: -1}}
+var minItem = Item{text: util.Chars{Index: -1}}
-
-func (item *Item) Nil() bool {
-	return item.Index() < 0
-}
 
 func (item *Item) TrimLength() uint16 {
 	return item.text.TrimLength()

src/merger.go

@@ -29,7 +29,7 @@ func PassMerger(chunks *[]*Chunk, tac bool) *Merger {
 		count:   0}
 
 	for _, chunk := range *mg.chunks {
-		mg.count += len(*chunk)
+		mg.count += chunk.count
 	}
 	return &mg
 }
@@ -65,7 +65,7 @@ func (mg *Merger) Get(idx int) Result {
 			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 {

src/merger_test.go

@@ -17,7 +17,7 @@ func assert(t *testing.T, cond bool, msg ...string) {
 
 func randResult() Result {
 	str := fmt.Sprintf("%d", rand.Uint32())
-	chars := util.RunesToChars([]rune(str))
+	chars := util.ToChars([]byte(str))
 	chars.Index = rand.Int31()
 	return Result{item: &Item{text: chars}}
 }

src/options.go

@@ -962,7 +962,9 @@ 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":
@@ -1140,7 +1142,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 {

src/options_test.go

@@ -414,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,18 +235,22 @@ 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
@@ -267,8 +278,8 @@ func (p *Pattern) matchChunk(chunk *Chunk, space []Result, slab *util.Slab) []Re
 	matches := []Result{}
 
 	if space == nil {
-		for idx := range *chunk {
+		for idx := 0; idx < chunk.count; idx++ {
-			if match, _, _ := p.MatchItem(&(*chunk)[idx], false, slab); match != nil {
+			if match, _, _ := p.MatchItem(&chunk.items[idx], false, slab); match != nil {
 				matches = append(matches, *match)
 			}
 		}
@@ -301,7 +312,12 @@ func (p *Pattern) MatchItem(item *Item, withPos bool, slab *util.Slab) (*Result,
 }
 
 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)
 	}
@@ -309,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
@@ -353,11 +374,7 @@ 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 len(p.nth) == 0 {
-		return []Token{Token{text: &item.text, prefixLength: 0}}
-	}
-
 	if item.transformed != nil {
 		return *item.transformed
 	}
@@ -370,7 +387,7 @@ func (p *Pattern) prepareInput(item *Item) []Token {
 
 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)
 		}
@@ -138,12 +132,11 @@ func TestOrigTextAndTransformed(t *testing.T) {
 
 	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" &&
@@ -152,7 +145,7 @@ func TestOrigTextAndTransformed(t *testing.T) {
 			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 &&
@@ -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,10 +15,43 @@ 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")
@@ -27,7 +62,7 @@ func (r *Reader) ReadSource() {
 	} else {
 		success = r.readFromStdin()
 	}
-	r.eventBox.Set(EvtReadFin, success)
+	r.fin(success)
 }
 
 func (r *Reader) feed(src io.Reader) {
@@ -41,7 +76,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') {
@@ -51,7 +86,7 @@ func (r *Reader) feed(src io.Reader) {
 				}
 			}
 			if r.pusher(bytea) {
-				r.eventBox.Set(EvtReadNew, true)
+				atomic.StoreInt32(&r.event, int32(EvtReadNew))
 			}
 		}
 		if err != 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(`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(`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

@@ -70,7 +70,7 @@ func buildResult(item *Item, offsets []Offset, score int) Result {
 				}
 			}
 		}
-		result.points[idx] = val
+		result.points[3-idx] = val
 	}
 
 	return result
@@ -85,7 +85,7 @@ func (result *Result) Index() int32 {
 }
 
 func minRank() Result {
-	return Result{item: &nilItem, 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 {
@@ -224,16 +224,3 @@ func (a ByRelevanceTac) Swap(i, j int) {
 func (a ByRelevanceTac) Less(i, j int) bool {
 	return compareRanks(a[i], a[j], true)
 }
-
-func compareRanks(irank Result, jrank Result, 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.item.Index() <= jrank.item.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

@@ -59,10 +59,10 @@ func TestResultRank(t *testing.T) {
 	strs := [][]rune{[]rune("foo"), []rune("foobar"), []rune("bar"), []rune("baz")}
 	item1 := buildResult(
 		withIndex(&Item{text: util.RunesToChars(strs[0])}, 1), []Offset{}, 2)
-	if item1.points[0] != math.MaxUint16-2 || // Bonus
+	if item1.points[3] != math.MaxUint16-2 || // Bonus
-		item1.points[1] != 3 || // Length
+		item1.points[2] != 3 || // Length
-		item1.points[2] != 0 || // Unused
+		item1.points[1] != 0 || // Unused
-		item1.points[3] != 0 || // Unused
+		item1.points[0] != 0 || // Unused
 		item1.item.Index() != 1 {
 		t.Error(item1)
 	}

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

@@ -101,6 +101,7 @@ type Terminal struct {
 	printer    func(string)
 	merger     *Merger
 	selected   map[int32]selectedItem
+	version    int64
 	reqBox     *util.EventBox
 	preview    previewOpts
 	previewer  previewer
@@ -280,9 +281,13 @@ func defaultKeymap() map[int][]action {
 	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
@@ -712,7 +717,7 @@ 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)
@@ -1173,8 +1178,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.ToString(), delimiter)
 			trans := Transform(tokens, ranges)
 			str := string(joinTokens(trans))
 			if delimiter.str != nil {
@@ -1258,6 +1262,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/"))
@@ -1360,6 +1382,7 @@ func (t *Terminal) Loop() {
 
 	go func() {
 		var focused *Item
+		var version int64
 		for {
 			t.reqBox.Wait(func(events *util.Events) {
 				defer events.Clear()
@@ -1376,7 +1399,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)
@@ -1442,22 +1466,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)
 			}
 		}
@@ -1571,17 +1582,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:
@@ -1592,7 +1600,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)
 				}
@@ -1690,13 +1698,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:

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) {

src/tokenizer.go

@@ -147,7 +147,7 @@ func Tokenize(text string, delimiter Delimiter) []Token {
 	if delimiter.regex != nil {
 		for len(text) > 0 {
 			loc := delimiter.regex.FindStringIndex(text)
-			if loc == nil {
+			if len(loc) < 2 {
 				loc = []int{0, len(text)}
 			}
 			last := util.Max(loc[1], 1)

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
 }
@@ -208,7 +209,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()
 	}
@@ -882,8 +885,8 @@ func (w *LightWindow) CFill(fg Color, bg Color, attr Attr, text string) FillRetu
 		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)
 }

src/util/chars.go

@@ -24,12 +24,12 @@ type Chars struct {
 
 func checkAscii(bytes []byte) (bool, int) {
 	i := 0
-	for ; i < len(bytes)-8; i += 8 {
+	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 {
+	for ; i <= len(bytes)-4; i += 4 {
 		if (overflow32 & *(*uint32)(unsafe.Pointer(&bytes[i]))) > 0 {
 			return false, i
 		}
@@ -65,6 +65,14 @@ func RunesToChars(runes []rune) Chars {
 	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
@@ -152,7 +160,7 @@ func (chars *Chars) CopyRunes(dest []rune) {
 		copy(dest, runes)
 		return
 	}
-	for idx, b := range chars.slice {
+	for idx, b := range chars.slice[:len(dest)] {
 		dest[idx] = rune(b)
 	}
 	return

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

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,16 +149,18 @@ 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')