[llgo] cmd/llgoi: use line editor

[axw]

Summary

This diff adds line-editing to llgoi, by
vendoring and using github.com/peterh/liner.
I have only implemented the basics here;
follow-ups will come later to add persisted
history, and completion,

[pcc]

Thanks for working on this much-needed usability improvement.

I played around with your change locally, and it seems to break one of the tests (llgoi/panic.test).

cmd/llgoi/llgoi.go

522

It looks like liner doesn't do this for us, so we probably need to keep doing it ourselves.

539

It doesn't look like liner deals with multi-line history entries very well. (e.g. try typing "{<nl>}<nl><up>" and then editing the line). Can we maybe strip newlines and apply semicolon insertion where necessary instead of saving the literal newlines?

[axw]

In D9811#174002, @pcc wrote:

Thanks for working on this much-needed usability improvement.

I played around with your change locally, and it seems to break one of the tests (llgoi/panic.test).

Fixed. Prompt() doesn't return the newline, so we need to add one.

[axw]

Collapse history lines, add semicolons

Also, append newlines to lines passed
to readLine, and reinstate newline
written when in terminal mode.

[axw]

Sorry, just realised I hadn't submitted my replies. PTAL.

cmd/llgoi/llgoi.go

522

Reinstated.

539

I've done that now. Lines are collapsed, and semicolons (added by go/scanner) are written where necessary.

[pcc]

Please add liner to the list of third-party packages in LICENSE.TXT. Other than that, LGTM.

update_third_party.sh

104

Wouldn't this leave a .git directory in third_party/liner?

[axw]

Fix update_third_party.sh, update LICENSE.TXT

[axw]

Thanks, updated LICENSE.TXT.

update_third_party.sh

104

Yes, added && rm -fr .git.

CMakeLists.txt

 llvm_add_go_executable(cc-wrapper llvm.org/llgo/cmd/cc-wrapper DEPENDS
   cmd/cc-wrapper/main.go
 )
 
 llvm_add_go_executable(llgoi llvm.org/llgo/cmd/llgoi
   DEPENDS libgo ${CMAKE_BINARY_DIR}/bin/llgo${CMAKE_EXECUTABLE_SUFFIX}
           ${CMAKE_BINARY_DIR}/lib/go/llgo-${LLGO_VERSION}/cgo
           ${CMAKE_BINARY_DIR}/bin/llgo-go${CMAKE_EXECUTABLE_SUFFIX}
-          cmd/llgoi/isatty_posix.go
           cmd/llgoi/llgoi.go
   GOFLAGS "cc=${CMAKE_BINARY_DIR}/bin/clang"
           "cxx=${CMAKE_BINARY_DIR}/bin/clang++"
           "go=${CMAKE_BINARY_DIR}/bin/llgo-go"
 )
 
 install(FILES ${CMAKE_BINARY_DIR}/bin/llgo${CMAKE_EXECUTABLE_SUFFIX}
               ${CMAKE_BINARY_DIR}/bin/llgoi${CMAKE_EXECUTABLE_SUFFIX}

cmd/llgoi/isatty_posix.go

-//===- isatty_posix.go - isatty implementation for POSIX ------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Implements isatty for POSIX systems.
-//
-//===----------------------------------------------------------------------===//
-
-package main
-
-// +build !windows
-
-/*
-#include <unistd.h>
-*/
-import "C"
-
-import (
-  "os"
-)
-
-func isatty(file *os.File) bool {
-  return C.isatty(C.int(file.Fd())) != 0
-}

cmd/llgoi/llgoi.go

 //===- llgoi.go - llgo-based Go REPL --------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This is llgoi, a Go REPL based on llgo and the LLVM JIT.
 //
 //===----------------------------------------------------------------------===//
 
 package main
 
 import (
-  "bufio"
   "bytes"
   "errors"
   "fmt"
   "go/ast"
   "go/build"
   "go/parser"
   "go/scanner"
   "go/token"
   "io"
   "os"
   "os/exec"
   "path/filepath"
   "runtime/debug"
   "strconv"
   "strings"
   "unsafe"
 
   "llvm.org/llgo/driver"
   "llvm.org/llgo/irgen"
   "llvm.org/llgo/third_party/gotools/go/types"
+  "llvm.org/llgo/third_party/liner"
   "llvm.org/llvm/bindings/go/llvm"
 )
 
 func getInstPrefix() (string, error) {
   path, err := exec.LookPath(os.Args[0])
   if err != nil {
     return "", err
   }
type line struct {
   assigns  []string
 
   parens, bracks, braces int
 }
 
 type interp struct {
   engine llvm.ExecutionEngine
 
+  liner       *liner.State
   pendingLine line
 
   copts irgen.CompilerOptions
 
   imports []*types.Package
   scope   map[string]types.Object
 
   pkgmap map[string]*types.Package
if pkg, ok := pkgmap[pkgpath]; ok && pkg.Complete() {
       return pkg, nil
     }
     return origImporter(pkgmap, pkgpath)
   }
   return nil
 }
 
 func (in *interp) init() error {
+  in.liner = liner.NewLiner()
   in.scope = make(map[string]types.Object)
   in.pkgmap = make(map[string]*types.Package)
 
   err := in.makeCompilerOptions()
   if err != nil {
     return err
   }
 
   return nil
 }
 
 func (in *interp) dispose() {
+  in.liner.Close()
   in.engine.Dispose()
 }
 
 func (in *interp) loadSourcePackageFromCode(pkgcode, pkgpath string, copts irgen.CompilerOptions) (*types.Package, error) {
   fset := token.NewFileSet()
   file, err := parser.ParseFile(fset, "<input>", pkgcode, parser.DeclarationErrors|parser.ParseComments)
   if err != nil {
     return nil, err
func (in *interp) loadPackage(pkgpath string) (*types.Package, error) {
   files, err := driver.ParseFiles(fset, inputs)
   if err != nil {
     return nil, err
   }
 
   return in.loadSourcePackage(fset, files, pkgpath, in.copts)
 }
 
+// readLine accumulates lines of input, including trailing newlines,
+// executing statements as they are completed.
 func (in *interp) readLine(line string) error {
   if !in.pendingLine.ready() {
     return in.readExprLine(line, nil)
   }
 
   var s scanner.Scanner
   fset := token.NewFileSet()
   file := fset.AddFile("", fset.Base(), len(line))
case token.IDENT:
 
     fallthrough
 
   default:
     return in.readExprLine(line, nil)
   }
 }
 
+// formatHistory reformats the provided Go source by collapsing all lines
+// and adding semicolons where required, suitable for adding to line history.
+func formatHistory(input []byte) string {
+  var buf bytes.Buffer
+  var s scanner.Scanner
+  fset := token.NewFileSet()
+  file := fset.AddFile("", fset.Base(), len(input))
+  s.Init(file, input, nil, 0)
+  pos, tok, lit := s.Scan()
+  for tok != token.EOF {
+    if int(pos)-1 > buf.Len() {
+      n := int(pos) - 1 - buf.Len()
+      buf.WriteString(strings.Repeat(" ", n))
+    }
+    var semicolon bool
+    if tok == token.SEMICOLON {
+      semicolon = true
+    } else if lit != "" {
+      buf.WriteString(lit)
+    } else {
+      buf.WriteString(tok.String())
+    }
+    pos, tok, lit = s.Scan()
+    if semicolon {
+      switch tok {
+      case token.RBRACE, token.RPAREN, token.EOF:
+      default:
+        buf.WriteRune(';')
+      }
+    }
+  }
+  return buf.String()
+}
+
 func main() {
   llvm.LinkInMCJIT()
   llvm.InitializeNativeTarget()
   llvm.InitializeNativeAsmPrinter()
 
   var in interp
   err := in.init()
   if err != nil {
     panic(err)
   }
   defer in.dispose()
 
-  tty := isatty(os.Stdin)
-
-  r := bufio.NewReader(os.Stdin)
+  var buf bytes.Buffer
   for {
-    if tty {
-      if in.pendingLine.ready() {
-        os.Stdout.WriteString("(llgo) ")
-      } else {
-        os.Stdout.WriteString("       ")
-      }
+    if in.pendingLine.ready() && buf.Len() > 0 {
+      history := formatHistory(buf.Bytes())
+      in.liner.AppendHistory(history)
+      buf.Reset()
+    prompt := "(llgo) "
+    if !in.pendingLine.ready() {
+      prompt = strings.Repeat(" ", len(prompt))
     }
-    line, err := r.ReadString('\n')
+    line, err := in.liner.Prompt(prompt)
     if err == io.EOF {
       break
     } else if err != nil {
       panic(err)
     }
-
-    err = in.readLine(line)
+    if line == "" {
+      continue
+    }
+    buf.WriteString(line + "\n")
+    err = in.readLine(line + "\n")
     if err != nil {
       fmt.Println(err)
     }
   }
 
-  if tty {
-    os.Stdout.WriteString("\n")
+  if liner.TerminalSupported() {
+    fmt.Println()
   }
 }

third_party/liner/COPYING

+Copyright © 2012 Peter Harris
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next
+paragraph) shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+

third_party/liner/README.md

+Liner
+=====
+
+Liner is a command line editor with history. It was inspired by linenoise;
+everything Unix-like is a VT100 (or is trying very hard to be). If your
+terminal is not pretending to be a VT100, change it. Liner also support
+Windows.
+
+Liner is released under the X11 license (which is similar to the new BSD
+license).
+
+Line Editing
+------------
+
+The following line editing commands are supported on platforms and terminals
+that Liner supports:
+
+Keystroke    | Action
+---------    | ------
+Ctrl-A, Home | Move cursor to beginning of line
+Ctrl-E, End  | Move cursor to end of line
+Ctrl-B, Left | Move cursor one character left
+Ctrl-F, Right| Move cursor one character right
+Ctrl-Left    | Move cursor to previous word
+Ctrl-Right   | Move cursor to next word
+Ctrl-D, Del  | (if line is *not* empty) Delete character under cursor
+Ctrl-D       | (if line *is* empty) End of File - usually quits application
+Ctrl-C       | Reset input (create new empty prompt)
+Ctrl-L       | Clear screen (line is unmodified)
+Ctrl-T       | Transpose previous character with current character
+Ctrl-H, BackSpace | Delete character before cursor
+Ctrl-W       | Delete word leading up to cursor
+Ctrl-K       | Delete from cursor to end of line
+Ctrl-U       | Delete from start of line to cursor
+Ctrl-P, Up   | Previous match from history
+Ctrl-N, Down | Next match from history
+Ctrl-R       | Reverse Search history (Ctrl-S forward, Ctrl-G cancel)
+Ctrl-Y       | Paste from Yank buffer (Alt-Y to paste next yank instead)
+Tab          | Next completion
+Shift-Tab    | (after Tab) Previous completion
+
+Getting started
+-----------------
+
+```go
+package main
+
+import (
+  "log"
+  "os"
+  "strings"
+
+  "github.com/peterh/liner"
+)
+
+var (
+  history_fn = "/tmp/.liner_history"
+  names      = []string{"john", "james", "mary", "nancy"}
+)
+
+func main() {
+  line := liner.NewLiner()
+  defer line.Close()
+
+  line.SetCompleter(func(line string) (c []string) {
+    for _, n := range names {
+      if strings.HasPrefix(n, strings.ToLower(line)) {
+        c = append(c, n)
+      }
+    }
+    return
+  })
+
+  if f, err := os.Open(history_fn); err == nil {
+    line.ReadHistory(f)
+    f.Close()
+  }
+
+  if name, err := line.Prompt("What is your name? "); err != nil {
+    log.Print("Error reading line: ", err)
+  } else {
+    log.Print("Got: ", name)
+    line.AppendHistory(name)
+  }
+
+  if f, err := os.Create(history_fn); err != nil {
+    log.Print("Error writing history file: ", err)
+  } else {
+    line.WriteHistory(f)
+    f.Close()
+  }
+}
+```
+
+For documentation, see http://godoc.org/github.com/peterh/liner

third_party/liner/bsdinput.go

+// +build openbsd freebsd netbsd
+
+package liner
+
+import "syscall"
+
+const (
+  getTermios = syscall.TIOCGETA
+  setTermios = syscall.TIOCSETA
+)
+
+const (
+  // Input flags
+  inpck  = 0x010
+  istrip = 0x020
+  icrnl  = 0x100
+  ixon   = 0x200
+
+  // Output flags
+  opost = 0x1
+
+  // Control flags
+  cs8 = 0x300
+
+  // Local flags
+  isig   = 0x080
+  icanon = 0x100
+  iexten = 0x400
+)
+
+type termios struct {
+  Iflag  uint32
+  Oflag  uint32
+  Cflag  uint32
+  Lflag  uint32
+  Cc     [20]byte
+  Ispeed int32
+  Ospeed int32
+}

third_party/liner/common.go

+/*
+Package liner implements a simple command line editor, inspired by linenoise
+(https://github.com/antirez/linenoise/). This package supports WIN32 in
+addition to the xterm codes supported by everything else.
+*/
+package liner
+
+import (
+  "bufio"
+  "bytes"
+  "container/ring"
+  "errors"
+  "fmt"
+  "io"
+  "strings"
+  "sync"
+  "unicode/utf8"
+)
+
+type commonState struct {
+  terminalSupported bool
+  outputRedirected  bool
+  inputRedirected   bool
+  history           []string
+  historyMutex      sync.RWMutex
+  completer         WordCompleter
+  columns           int
+  killRing          *ring.Ring
+  ctrlCAborts       bool
+  r                 *bufio.Reader
+  tabStyle          TabStyle
+}
+
+// TabStyle is used to select how tab completions are displayed.
+type TabStyle int
+
+// Two tab styles are currently available:
+//
+// TabCircular cycles through each completion item and displays it directly on
+// the prompt
+//
+// TabPrints prints the list of completion items to the screen after a second
+// tab key is pressed. This behaves similar to GNU readline and BASH (which
+// uses readline)
+const (
+  TabCircular TabStyle = iota
+  TabPrints
+)
+
+// ErrPromptAborted is returned from Prompt or PasswordPrompt when the user presses Ctrl-C
+// if SetCtrlCAborts(true) has been called on the State
+var ErrPromptAborted = errors.New("prompt aborted")
+
+// ErrNotTerminalOutput is returned from Prompt or PasswordPrompt if the
+// platform is normally supported, but stdout has been redirected
+var ErrNotTerminalOutput = errors.New("standard output is not a terminal")
+
+// Max elements to save on the killring
+const KillRingMax = 60
+
+// HistoryLimit is the maximum number of entries saved in the scrollback history.
+const HistoryLimit = 1000
+
+// ReadHistory reads scrollback history from r. Returns the number of lines
+// read, and any read error (except io.EOF).
+func (s *State) ReadHistory(r io.Reader) (num int, err error) {
+  s.historyMutex.Lock()
+  defer s.historyMutex.Unlock()
+
+  in := bufio.NewReader(r)
+  num = 0
+  for {
+    line, part, err := in.ReadLine()
+    if err == io.EOF {
+      break
+    }
+    if err != nil {
+      return num, err
+    }
+    if part {
+      return num, fmt.Errorf("line %d is too long", num+1)
+    }
+    if !utf8.Valid(line) {
+      return num, fmt.Errorf("invalid string at line %d", num+1)
+    }
+    num++
+    s.history = append(s.history, string(line))
+    if len(s.history) > HistoryLimit {
+      s.history = s.history[1:]
+    }
+  }
+  return num, nil
+}
+
+// WriteHistory writes scrollback history to w. Returns the number of lines
+// successfully written, and any write error.
+//
+// Unlike the rest of liner's API, WriteHistory is safe to call
+// from another goroutine while Prompt is in progress.
+// This exception is to facilitate the saving of the history buffer
+// during an unexpected exit (for example, due to Ctrl-C being invoked)
+func (s *State) WriteHistory(w io.Writer) (num int, err error) {
+  s.historyMutex.RLock()
+  defer s.historyMutex.RUnlock()
+
+  for _, item := range s.history {
+    _, err := fmt.Fprintln(w, item)
+    if err != nil {
+      return num, err
+    }
+    num++
+  }
+  return num, nil
+}
+
+// AppendHistory appends an entry to the scrollback history. AppendHistory
+// should be called iff Prompt returns a valid command.
+func (s *State) AppendHistory(item string) {
+  s.historyMutex.Lock()
+  defer s.historyMutex.Unlock()
+
+  if len(s.history) > 0 {
+    if item == s.history[len(s.history)-1] {
+      return
+    }
+  }
+  s.history = append(s.history, item)
+  if len(s.history) > HistoryLimit {
+    s.history = s.history[1:]
+  }
+}
+
+// Returns the history lines starting with prefix
+func (s *State) getHistoryByPrefix(prefix string) (ph []string) {
+  for _, h := range s.history {
+    if strings.HasPrefix(h, prefix) {
+      ph = append(ph, h)
+    }
+  }
+  return
+}
+
+// Returns the history lines matching the inteligent search
+func (s *State) getHistoryByPattern(pattern string) (ph []string, pos []int) {
+  if pattern == "" {
+    return
+  }
+  for _, h := range s.history {
+    if i := strings.Index(h, pattern); i >= 0 {
+      ph = append(ph, h)
+      pos = append(pos, i)
+    }
+  }
+  return
+}
+
+// Completer takes the currently edited line content at the left of the cursor
+// and returns a list of completion candidates.
+// If the line is "Hello, wo!!!" and the cursor is before the first '!', "Hello, wo" is passed
+// to the completer which may return {"Hello, world", "Hello, Word"} to have "Hello, world!!!".
+type Completer func(line string) []string
+
+// WordCompleter takes the currently edited line with the cursor position and
+// returns the completion candidates for the partial word to be completed.
+// If the line is "Hello, wo!!!" and the cursor is before the first '!', ("Hello, wo!!!", 9) is passed
+// to the completer which may returns ("Hello, ", {"world", "Word"}, "!!!") to have "Hello, world!!!".
+type WordCompleter func(line string, pos int) (head string, completions []string, tail string)
+
+// SetCompleter sets the completion function that Liner will call to
+// fetch completion candidates when the user presses tab.
+func (s *State) SetCompleter(f Completer) {
+  if f == nil {
+    s.completer = nil
+    return
+  }
+  s.completer = func(line string, pos int) (string, []string, string) {
+    return "", f(line[:pos]), line[pos:]
+  }
+}
+
+// SetWordCompleter sets the completion function that Liner will call to
+// fetch completion candidates when the user presses tab.
+func (s *State) SetWordCompleter(f WordCompleter) {
+  s.completer = f
+}
+
+// SetTabCompletionStyle sets the behvavior when the Tab key is pressed
+// for auto-completion.  TabCircular is the default behavior and cycles
+// through the list of candidates at the prompt.  TabPrints will print
+// the available completion candidates to the screen similar to BASH
+// and GNU Readline
+func (s *State) SetTabCompletionStyle(tabStyle TabStyle) {
+  s.tabStyle = tabStyle
+}
+
+// ModeApplier is the interface that wraps a representation of the terminal
+// mode. ApplyMode sets the terminal to this mode.
+type ModeApplier interface {
+  ApplyMode() error
+}
+
+// SetCtrlCAborts sets whether Prompt on a supported terminal will return an
+// ErrPromptAborted when Ctrl-C is pressed. The default is false (will not
+// return when Ctrl-C is pressed). Unsupported terminals typically raise SIGINT
+// (and Prompt does not return) regardless of the value passed to SetCtrlCAborts.
+func (s *State) SetCtrlCAborts(aborts bool) {
+  s.ctrlCAborts = aborts
+}
+
+func (s *State) promptUnsupported(p string) (string, error) {
+  if !s.inputRedirected || !s.terminalSupported {
+    fmt.Print(p)
+  }
+  linebuf, _, err := s.r.ReadLine()
+  if err != nil {
+    return "", err
+  }
+  return string(bytes.TrimSpace(linebuf)), nil
+}

third_party/liner/fallbackinput.go

+// +build !windows,!linux,!darwin,!openbsd,!freebsd,!netbsd
+
+package liner
+
+import (
+  "bufio"
+  "errors"
+  "os"
+)
+
+// State represents an open terminal
+type State struct {
+  commonState
+}
+
+// Prompt displays p, and then waits for user input. Prompt does not support
+// line editing on this operating system.
+func (s *State) Prompt(p string) (string, error) {
+  return s.promptUnsupported(p)
+}
+
+// PasswordPrompt is not supported in this OS.
+func (s *State) PasswordPrompt(p string) (string, error) {
+  return "", errors.New("liner: function not supported in this terminal")
+}
+
+// NewLiner initializes a new *State
+//
+// Note that this operating system uses a fallback mode without line
+// editing. Patches welcome.
+func NewLiner() *State {
+  var s State
+  s.r = bufio.NewReader(os.Stdin)
+  return &s
+}
+
+// Close returns the terminal to its previous mode
+func (s *State) Close() error {
+  return nil
+}
+
+// TerminalSupported returns false because line editing is not
+// supported on this platform.
+func TerminalSupported() bool {
+  return false
+}
+
+type noopMode struct{}
+
+func (n noopMode) ApplyMode() error {
+  return nil
+}
+
+// TerminalMode returns a noop InputModeSetter on this platform.
+func TerminalMode() (ModeApplier, error) {
+  return noopMode{}, nil
+}

third_party/liner/input.go

+// +build linux darwin openbsd freebsd netbsd
+
+package liner
+
+import (
+  "bufio"
+  "errors"
+  "os"
+  "os/signal"
+  "strconv"
+  "strings"
+  "syscall"
+  "time"
+)
+
+type nexter struct {
+  r   rune
+  err error
+}
+
+// State represents an open terminal
+type State struct {
+  commonState
+  origMode    termios
+  defaultMode termios
+  next        <-chan nexter
+  winch       chan os.Signal
+  pending     []rune
+  useCHA      bool
+}
+
+// NewLiner initializes a new *State, and sets the terminal into raw mode. To
+// restore the terminal to its previous state, call State.Close().
+//
+// Note if you are still using Go 1.0: NewLiner handles SIGWINCH, so it will
+// leak a channel every time you call it. Therefore, it is recommened that you
+// upgrade to a newer release of Go, or ensure that NewLiner is only called
+// once.
+func NewLiner() *State {
+  var s State
+  s.r = bufio.NewReader(os.Stdin)
+
+  s.terminalSupported = TerminalSupported()
+  if m, err := TerminalMode(); err == nil {
+    s.origMode = *m.(*termios)
+  } else {
+    s.inputRedirected = true
+  }
+  if _, err := getMode(syscall.Stdout); err != 0 {
+    s.outputRedirected = true
+  }
+  if s.inputRedirected && s.outputRedirected {
+    s.terminalSupported = false
+  }
+  if s.terminalSupported && !s.inputRedirected && !s.outputRedirected {
+    mode := s.origMode
+    mode.Iflag &^= icrnl | inpck | istrip | ixon
+    mode.Cflag |= cs8
+    mode.Lflag &^= syscall.ECHO | icanon | iexten
+    mode.ApplyMode()
+
+    winch := make(chan os.Signal, 1)
+    signal.Notify(winch, syscall.SIGWINCH)
+    s.winch = winch
+
+    s.checkOutput()
+  }
+
+  if !s.outputRedirected {
+    s.getColumns()
+    s.outputRedirected = s.columns <= 0
+  }
+
+  return &s
+}
+
+var errTimedOut = errors.New("timeout")
+
+func (s *State) startPrompt() {
+  if s.terminalSupported {
+    if m, err := TerminalMode(); err == nil {
+      s.defaultMode = *m.(*termios)
+      mode := s.defaultMode
+      mode.Lflag &^= isig
+      mode.ApplyMode()
+    }
+  }
+  s.restartPrompt()
+}
+
+func (s *State) restartPrompt() {
+  next := make(chan nexter)
+  go func() {
+    for {
+      var n nexter
+      n.r, _, n.err = s.r.ReadRune()
+      next <- n
+      // Shut down nexter loop when an end condition has been reached
+      if n.err != nil || n.r == '\n' || n.r == '\r' || n.r == ctrlC || n.r == ctrlD {
+        close(next)
+        return
+      }
+    }
+  }()
+  s.next = next
+}
+
+func (s *State) stopPrompt() {
+  if s.terminalSupported {
+    s.defaultMode.ApplyMode()
+  }
+}
+
+func (s *State) nextPending(timeout <-chan time.Time) (rune, error) {
+  select {
+  case thing, ok := <-s.next:
+    if !ok {
+      return 0, errors.New("liner: internal error")
+    }
+    if thing.err != nil {
+      return 0, thing.err
+    }
+    s.pending = append(s.pending, thing.r)
+    return thing.r, nil
+  case <-timeout:
+    rv := s.pending[0]
+    s.pending = s.pending[1:]
+    return rv, errTimedOut
+  }
+  // not reached
+  return 0, nil
+}
+
+func (s *State) readNext() (interface{}, error) {
+  if len(s.pending) > 0 {
+    rv := s.pending[0]
+    s.pending = s.pending[1:]
+    return rv, nil
+  }
+  var r rune
+  select {
+  case thing, ok := <-s.next:
+    if !ok {
+      return 0, errors.New("liner: internal error")
+    }
+    if thing.err != nil {
+      return nil, thing.err
+    }
+    r = thing.r
+  case <-s.winch:
+    s.getColumns()
+    return winch, nil
+  }
+  if r != esc {
+    return r, nil
+  }
+  s.pending = append(s.pending, r)
+
+  // Wait at most 50 ms for the rest of the escape sequence
+  // If nothing else arrives, it was an actual press of the esc key
+  timeout := time.After(50 * time.Millisecond)
+  flag, err := s.nextPending(timeout)
+  if err != nil {
+    if err == errTimedOut {
+      return flag, nil
+    }
+    return unknown, err
+  }
+
+  switch flag {
+  case '[':
+    code, err := s.nextPending(timeout)
+    if err != nil {
+      if err == errTimedOut {
+        return code, nil
+      }
+      return unknown, err
+    }
+    switch code {
+    case 'A':
+      s.pending = s.pending[:0] // escape code complete
+      return up, nil
+    case 'B':
+      s.pending = s.pending[:0] // escape code complete
+      return down, nil
+    case 'C':
+      s.pending = s.pending[:0] // escape code complete
+      return right, nil
+    case 'D':
+      s.pending = s.pending[:0] // escape code complete
+      return left, nil
+    case 'F':
+      s.pending = s.pending[:0] // escape code complete
+      return end, nil
+    case 'H':
+      s.pending = s.pending[:0] // escape code complete
+      return home, nil
+    case 'Z':
+      s.pending = s.pending[:0] // escape code complete
+      return shiftTab, nil
+    case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+      num := []rune{code}
+      for {
+        code, err := s.nextPending(timeout)
+        if err != nil {
+          if err == errTimedOut {
+            return code, nil
+          }
+          return nil, err
+        }
+        switch code {
+        case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+          num = append(num, code)
+        case ';':
+          // Modifier code to follow
+          // This only supports Ctrl-left and Ctrl-right for now
+          x, _ := strconv.ParseInt(string(num), 10, 32)
+          if x != 1 {
+            // Can't be left or right
+            rv := s.pending[0]
+            s.pending = s.pending[1:]
+            return rv, nil
+          }
+          num = num[:0]
+          for {
+            code, err = s.nextPending(timeout)
+            if err != nil {
+              if err == errTimedOut {
+                rv := s.pending[0]
+                s.pending = s.pending[1:]
+                return rv, nil
+              }
+              return nil, err
+            }
+            switch code {
+            case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+              num = append(num, code)
+            case 'C', 'D':
+              // right, left
+              mod, _ := strconv.ParseInt(string(num), 10, 32)
+              if mod != 5 {
+                // Not bare Ctrl
+                rv := s.pending[0]
+                s.pending = s.pending[1:]
+                return rv, nil
+              }
+              s.pending = s.pending[:0] // escape code complete
+              if code == 'C' {
+                return wordRight, nil
+              }
+              return wordLeft, nil
+            default:
+              // Not left or right
+              rv := s.pending[0]
+              s.pending = s.pending[1:]
+              return rv, nil
+            }
+          }
+        case '~':
+          s.pending = s.pending[:0] // escape code complete
+          x, _ := strconv.ParseInt(string(num), 10, 32)
+          switch x {
+          case 2:
+            return insert, nil
+          case 3:
+            return del, nil
+          case 5:
+            return pageUp, nil
+          case 6:
+            return pageDown, nil
+          case 7:
+            return home, nil
+          case 8:
+            return end, nil
+          case 15:
+            return f5, nil
+          case 17:
+            return f6, nil
+          case 18:
+            return f7, nil
+          case 19:
+            return f8, nil
+          case 20:
+            return f9, nil
+          case 21:
+            return f10, nil
+          case 23:
+            return f11, nil
+          case 24:
+            return f12, nil
+          default:
+            return unknown, nil
+          }
+        default:
+          // unrecognized escape code
+          rv := s.pending[0]
+          s.pending = s.pending[1:]
+          return rv, nil
+        }
+      }
+    }
+
+  case 'O':
+    code, err := s.nextPending(timeout)
+    if err != nil {
+      if err == errTimedOut {
+        return code, nil
+      }
+      return nil, err
+    }
+    s.pending = s.pending[:0] // escape code complete
+    switch code {
+    case 'c':
+      return wordRight, nil
+    case 'd':
+      return wordLeft, nil
+    case 'H':
+      return home, nil
+    case 'F':
+      return end, nil
+    case 'P':
+      return f1, nil
+    case 'Q':
+      return f2, nil
+    case 'R':
+      return f3, nil
+    case 'S':
+      return f4, nil
+    default:
+      return unknown, nil
+    }
+  case 'y':
+    s.pending = s.pending[:0] // escape code complete
+    return altY, nil
+  default:
+    rv := s.pending[0]
+    s.pending = s.pending[1:]
+    return rv, nil
+  }
+
+  // not reached
+  return r, nil
+}
+
+// Close returns the terminal to its previous mode
+func (s *State) Close() error {
+  stopSignal(s.winch)
+  if !s.inputRedirected {
+    s.origMode.ApplyMode()
+  }
+  return nil
+}
+
+// TerminalSupported returns true if the current terminal supports
+// line editing features, and false if liner will use the 'dumb'
+// fallback for input.
+// Note that TerminalSupported does not check all factors that may
+// cause liner to not fully support the terminal (such as stdin redirection)
+func TerminalSupported() bool {
+  bad := map[string]bool{"": true, "dumb": true, "cons25": true}
+  return !bad[strings.ToLower(os.Getenv("TERM"))]
+}

third_party/liner/input_darwin.go

+// +build darwin
+
+package liner
+
+import "syscall"
+
+const (
+  getTermios = syscall.TIOCGETA
+  setTermios = syscall.TIOCSETA
+)
+
+const (
+  // Input flags
+  inpck  = 0x010
+  istrip = 0x020
+  icrnl  = 0x100
+  ixon   = 0x200
+
+  // Output flags
+  opost = 0x1
+
+  // Control flags
+  cs8 = 0x300
+
+  // Local flags
+  isig   = 0x080
+  icanon = 0x100
+  iexten = 0x400
+)
+
+type termios struct {
+  Iflag  uintptr
+  Oflag  uintptr
+  Cflag  uintptr
+  Lflag  uintptr
+  Cc     [20]byte
+  Ispeed uintptr
+  Ospeed uintptr
+}

third_party/liner/input_linux.go

+// +build linux
+
+package liner
+
+import "syscall"
+
+const (
+  getTermios = syscall.TCGETS
+  setTermios = syscall.TCSETS
+)
+
+const (
+  icrnl  = syscall.ICRNL
+  inpck  = syscall.INPCK
+  istrip = syscall.ISTRIP
+  ixon   = syscall.IXON
+  opost  = syscall.OPOST
+  cs8    = syscall.CS8
+  isig   = syscall.ISIG
+  icanon = syscall.ICANON
+  iexten = syscall.IEXTEN
+)
+
+type termios struct {
+  syscall.Termios
+}

third_party/liner/input_test.go

+// +build !windows
+
+package liner
+
+import (
+  "bufio"
+  "bytes"
+  "testing"
+)
+
+func (s *State) expectRune(t *testing.T, r rune) {
+  item, err := s.readNext()
+  if err != nil {
+    t.Fatalf("Expected rune '%c', got error %s\n", r, err)
+  }
+  if v, ok := item.(rune); !ok {
+    t.Fatalf("Expected rune '%c', got non-rune %v\n", r, v)
+  } else {
+    if v != r {
+      t.Fatalf("Expected rune '%c', got rune '%c'\n", r, v)
+    }
+  }
+}
+
+func (s *State) expectAction(t *testing.T, a action) {
+  item, err := s.readNext()
+  if err != nil {
+    t.Fatalf("Expected Action %d, got error %s\n", a, err)
+  }
+  if v, ok := item.(action); !ok {
+    t.Fatalf("Expected Action %d, got non-Action %v\n", a, v)
+  } else {
+    if v != a {
+      t.Fatalf("Expected Action %d, got Action %d\n", a, v)
+    }
+  }
+}
+
+func TestTypes(t *testing.T) {
+  input := []byte{'A', 27, 'B', 27, 91, 68, 27, '[', '1', ';', '5', 'D', 'e'}
+  var s State
+  s.r = bufio.NewReader(bytes.NewBuffer(input))
+
+  next := make(chan nexter)
+  go func() {
+    for {
+      var n nexter
+      n.r, _, n.err = s.r.ReadRune()
+      next <- n
+    }
+  }()
+  s.next = next
+
+  s.expectRune(t, 'A')
+  s.expectRune(t, 27)
+  s.expectRune(t, 'B')
+  s.expectAction(t, left)
+  s.expectAction(t, wordLeft)
+
+  s.expectRune(t, 'e')
+}

third_party/liner/input_windows.go

+package liner
+
+import (
+  "bufio"
+  "os"
+  "syscall"
+  "unsafe"
+)
+
+var (
+  kernel32 = syscall.NewLazyDLL("kernel32.dll")
+
+  procGetStdHandle               = kernel32.NewProc("GetStdHandle")
+  procReadConsoleInput           = kernel32.NewProc("ReadConsoleInputW")
+  procGetConsoleMode             = kernel32.NewProc("GetConsoleMode")
+  procSetConsoleMode             = kernel32.NewProc("SetConsoleMode")
+  procSetConsoleCursorPosition   = kernel32.NewProc("SetConsoleCursorPosition")
+  procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
+  procFillConsoleOutputCharacter = kernel32.NewProc("FillConsoleOutputCharacterW")
+)
+
+// These names are from the Win32 api, so they use underscores (contrary to
+// what golint suggests)
+const (
+  std_input_handle     = uint32(-10 & 0xFFFFFFFF)
+  std_output_handle    = uint32(-11 & 0xFFFFFFFF)
+  std_error_handle     = uint32(-12 & 0xFFFFFFFF)
+  invalid_handle_value = ^uintptr(0)
+)
+
+type inputMode uint32
+
+// State represents an open terminal
+type State struct {
+  commonState
+  handle      syscall.Handle
+  hOut        syscall.Handle
+  origMode    inputMode
+  defaultMode inputMode
+  key         interface{}
+  repeat      uint16
+}
+
+const (
+  enableEchoInput      = 0x4
+  enableInsertMode     = 0x20
+  enableLineInput      = 0x2
+  enableMouseInput     = 0x10
+  enableProcessedInput = 0x1
+  enableQuickEditMode  = 0x40
+  enableWindowInput    = 0x8
+)
+
+// NewLiner initializes a new *State, and sets the terminal into raw mode. To
+// restore the terminal to its previous state, call State.Close().
+func NewLiner() *State {
+  var s State
+  hIn, _, _ := procGetStdHandle.Call(uintptr(std_input_handle))
+  s.handle = syscall.Handle(hIn)
+  hOut, _, _ := procGetStdHandle.Call(uintptr(std_output_handle))
+  s.hOut = syscall.Handle(hOut)
+
+  s.terminalSupported = true
+  if m, err := TerminalMode(); err == nil {
+    s.origMode = m.(inputMode)
+    mode := s.origMode
+    mode &^= enableEchoInput
+    mode &^= enableInsertMode
+    mode &^= enableLineInput
+    mode &^= enableMouseInput
+    mode |= enableWindowInput
+    mode.ApplyMode()
+  } else {
+    s.inputRedirected = true
+    s.r = bufio.NewReader(os.Stdin)
+  }
+
+  s.getColumns()
+  s.outputRedirected = s.columns <= 0
+
+  return &s
+}
+
+// These names are from the Win32 api, so they use underscores (contrary to
+// what golint suggests)
+const (
+  focus_event              = 0x0010
+  key_event                = 0x0001
+  menu_event               = 0x0008
+  mouse_event              = 0x0002
+  window_buffer_size_event = 0x0004
+)
+
+type input_record struct {
+  eventType uint16
+  pad       uint16
+  blob      [16]byte
+}
+
+type key_event_record struct {
+  KeyDown         int32
+  RepeatCount     uint16
+  VirtualKeyCode  uint16
+  VirtualScanCode uint16
+  Char            int16
+  ControlKeyState uint32
+}
+
+// These names are from the Win32 api, so they use underscores (contrary to
+// what golint suggests)
+const (
+  vk_tab    = 0x09
+  vk_prior  = 0x21
+  vk_next   = 0x22
+  vk_end    = 0x23
+  vk_home   = 0x24
+  vk_left   = 0x25
+  vk_up     = 0x26
+  vk_right  = 0x27
+  vk_down   = 0x28
+  vk_insert = 0x2d
+  vk_delete = 0x2e
+  vk_f1     = 0x70
+  vk_f2     = 0x71
+  vk_f3     = 0x72
+  vk_f4     = 0x73
+  vk_f5     = 0x74
+  vk_f6     = 0x75
+  vk_f7     = 0x76
+  vk_f8     = 0x77
+  vk_f9     = 0x78
+  vk_f10    = 0x79
+  vk_f11    = 0x7a
+  vk_f12    = 0x7b
+  yKey      = 0x59
+)
+
+const (
+  shiftPressed     = 0x0010
+  leftAltPressed   = 0x0002
+  leftCtrlPressed  = 0x0008
+  rightAltPressed  = 0x0001
+  rightCtrlPressed = 0x0004
+
+  modKeys = shiftPressed | leftAltPressed | rightAltPressed | leftCtrlPressed | rightCtrlPressed
+)
+
+func (s *State) readNext() (interface{}, error) {
+  if s.repeat > 0 {
+    s.repeat--
+    return s.key, nil
+  }
+
+  var input input_record
+  pbuf := uintptr(unsafe.Pointer(&input))
+  var rv uint32
+  prv := uintptr(unsafe.Pointer(&rv))
+
+  for {
+    ok, _, err := procReadConsoleInput.Call(uintptr(s.handle), pbuf, 1, prv)
+
+    if ok == 0 {
+      return nil, err
+    }
+
+    if input.eventType == window_buffer_size_event {
+      xy := (*coord)(unsafe.Pointer(&input.blob[0]))
+      s.columns = int(xy.x)
+      return winch, nil
+    }
+    if input.eventType != key_event {
+      continue
+    }
+    ke := (*key_event_record)(unsafe.Pointer(&input.blob[0]))
+    if ke.KeyDown == 0 {
+      continue
+    }
+
+    if ke.VirtualKeyCode == vk_tab && ke.ControlKeyState&modKeys == shiftPressed {
+      s.key = shiftTab
+    } else if ke.VirtualKeyCode == yKey && (ke.ControlKeyState&modKeys == leftAltPressed ||
+      ke.ControlKeyState&modKeys == rightAltPressed) {
+      s.key = altY
+    } else if ke.Char > 0 {
+      s.key = rune(ke.Char)
+    } else {
+      switch ke.VirtualKeyCode {
+      case vk_prior:
+        s.key = pageUp
+      case vk_next:
+        s.key = pageDown
+      case vk_end:
+        s.key = end
+      case vk_home:
+        s.key = home
+      case vk_left:
+        s.key = left
+        if ke.ControlKeyState&(leftCtrlPressed|rightCtrlPressed) != 0 {
+          if ke.ControlKeyState&modKeys == ke.ControlKeyState&(leftCtrlPressed|rightCtrlPressed) {
+            s.key = wordLeft
+          }
+        }
+      case vk_right:
+        s.key = right
+        if ke.ControlKeyState&(leftCtrlPressed|rightCtrlPressed) != 0 {
+          if ke.ControlKeyState&modKeys == ke.ControlKeyState&(leftCtrlPressed|rightCtrlPressed) {
+            s.key = wordRight
+          }
+        }
+      case vk_up:
+        s.key = up
+      case vk_down:
+        s.key = down
+      case vk_insert:
+        s.key = insert
+      case vk_delete:
+        s.key = del
+      case vk_f1:
+        s.key = f1
+      case vk_f2:
+        s.key = f2
+      case vk_f3:
+        s.key = f3
+      case vk_f4:
+        s.key = f4
+      case vk_f5:
+        s.key = f5
+      case vk_f6:
+        s.key = f6
+      case vk_f7:
+        s.key = f7
+      case vk_f8:
+        s.key = f8
+      case vk_f9:
+        s.key = f9
+      case vk_f10:
+        s.key = f10
+      case vk_f11:
+        s.key = f11
+      case vk_f12:
+        s.key = f12
+      default:
+        // Eat modifier keys
+        // TODO: return Action(Unknown) if the key isn't a
+        // modifier.
+        continue
+      }
+    }
+
+    if ke.RepeatCount > 1 {
+      s.repeat = ke.RepeatCount - 1
+    }
+    return s.key, nil
+  }
+  return unknown, nil
+}
+
+// Close returns the terminal to its previous mode
+func (s *State) Close() error {
+  s.origMode.ApplyMode()
+  return nil
+}
+
+func (s *State) startPrompt() {
+  if m, err := TerminalMode(); err == nil {
+    s.defaultMode = m.(inputMode)
+    mode := s.defaultMode
+    mode &^= enableProcessedInput
+    mode.ApplyMode()
+  }
+}
+
+func (s *State) restartPrompt() {
+}
+
+func (s *State) stopPrompt() {
+  s.defaultMode.ApplyMode()
+}
+
+// TerminalSupported returns true because line editing is always
+// supported on Windows.
+func TerminalSupported() bool {
+  return true
+}
+
+func (mode inputMode) ApplyMode() error {
+  hIn, _, err := procGetStdHandle.Call(uintptr(std_input_handle))
+  if hIn == invalid_handle_value || hIn == 0 {
+    return err
+  }
+  ok, _, err := procSetConsoleMode.Call(hIn, uintptr(mode))
+  if ok != 0 {
+    err = nil
+  }
+  return err
+}
+
+// TerminalMode returns the current terminal input mode as an InputModeSetter.
+//
+// This function is provided for convenience, and should
+// not be necessary for most users of liner.
+func TerminalMode() (ModeApplier, error) {
+  var mode inputMode
+  hIn, _, err := procGetStdHandle.Call(uintptr(std_input_handle))
+  if hIn == invalid_handle_value || hIn == 0 {
+    return nil, err
+  }
+  ok, _, err := procGetConsoleMode.Call(hIn, uintptr(unsafe.Pointer(&mode)))
+  if ok != 0 {
+    err = nil
+  }
+  return mode, err
+}

third_party/liner/line.go

+// +build windows linux darwin openbsd freebsd netbsd
+
+package liner
+
+import (
+  "container/ring"
+  "errors"
+  "fmt"
+  "io"
+  "strings"
+  "unicode"
+  "unicode/utf8"
+)
+
+type action int
+
+const (
+  left action = iota
+  right
+  up
+  down
+  home
+  end
+  insert
+  del
+  pageUp
+  pageDown
+  f1
+  f2
+  f3
+  f4
+  f5
+  f6
+  f7
+  f8
+  f9
+  f10
+  f11
+  f12
+  altY
+  shiftTab
+  wordLeft
+  wordRight
+  winch
+  unknown
+)
+
+const (
+  ctrlA = 1
+  ctrlB = 2
+  ctrlC = 3
+  ctrlD = 4
+  ctrlE = 5
+  ctrlF = 6
+  ctrlG = 7
+  ctrlH = 8
+  tab   = 9
+  lf    = 10
+  ctrlK = 11
+  ctrlL = 12
+  cr    = 13
+  ctrlN = 14
+  ctrlO = 15
+  ctrlP = 16
+  ctrlQ = 17
+  ctrlR = 18
+  ctrlS = 19
+  ctrlT = 20
+  ctrlU = 21
+  ctrlV = 22
+  ctrlW = 23
+  ctrlX = 24
+  ctrlY = 25
+  ctrlZ = 26
+  esc   = 27
+  bs    = 127
+)
+
+const (
+  beep = "\a"
+)
+
+type tabDirection int
+
+const (
+  tabForward tabDirection = iota
+  tabReverse
+)
+
+func (s *State) refresh(prompt []rune, buf []rune, pos int) error {
+  s.cursorPos(0)
+  _, err := fmt.Print(string(prompt))
+  if err != nil {
+    return err
+  }
+
+  pLen := countGlyphs(prompt)
+  bLen := countGlyphs(buf)
+  pos = countGlyphs(buf[:pos])
+  if pLen+bLen < s.columns {
+    _, err = fmt.Print(string(buf))
+    s.eraseLine()
+    s.cursorPos(pLen + pos)
+  } else {
+    // Find space available
+    space := s.columns - pLen
+    space-- // space for cursor
+    start := pos - space/2
+    end := start + space
+    if end > bLen {
+      end = bLen
+      start = end - space
+    }
+    if start < 0 {
+      start = 0
+      end = space
+    }
+    pos -= start
+
+    // Leave space for markers
+    if start > 0 {
+      start++
+    }
+    if end < bLen {
+      end--
+    }
+    startRune := len(getPrefixGlyphs(buf, start))
+    line := getPrefixGlyphs(buf[startRune:], end-start)
+
+    // Output
+    if start > 0 {
+      fmt.Print("{")
+    }
+    fmt.Print(string(line))
+    if end < bLen {
+      fmt.Print("}")
+    }
+
+    // Set cursor position
+    s.eraseLine()
+    s.cursorPos(pLen + pos)
+  }
+  return err
+}
+
+func longestCommonPrefix(strs []string) string {
+  if len(strs) == 0 {
+    return ""
+  }
+  longest := strs[0]
+
+  for _, str := range strs[1:] {
+    for !strings.HasPrefix(str, longest) {
+      longest = longest[:len(longest)-1]
+    }
+  }
+  // Remove trailing partial runes
+  longest = strings.TrimRight(longest, "\uFFFD")
+  return longest
+}
+
+func (s *State) circularTabs(items []string) func(tabDirection) (string, error) {
+  item := -1
+  return func(direction tabDirection) (string, error) {
+    if direction == tabForward {
+      if item < len(items)-1 {
+        item++
+      } else {
+        item = 0
+      }
+    } else if direction == tabReverse {
+      if item > 0 {
+        item--
+      } else {
+        item = len(items) - 1
+      }
+    }
+    return items[item], nil
+  }
+}
+
+func (s *State) printedTabs(items []string) func(tabDirection) (string, error) {
+  numTabs := 1
+  prefix := longestCommonPrefix(items)
+  return func(direction tabDirection) (string, error) {
+    if len(items) == 1 {
+      return items[0], nil
+    }
+
+    if numTabs == 2 {
+      if len(items) > 100 {
+        fmt.Printf("\nDisplay all %d possibilities? (y or n) ", len(items))
+        for {
+          next, err := s.readNext()
+          if err != nil {
+            return prefix, err
+          }
+
+          if key, ok := next.(rune); ok {
+            if unicode.ToLower(key) == 'n' {
+              return prefix, nil
+            } else if unicode.ToLower(key) == 'y' {
+              break
+            }
+          }
+        }
+      }
+      fmt.Println("")
+      maxWidth := 0
+      for _, item := range items {
+        if len(item) >= maxWidth {
+          maxWidth = len(item) + 1
+        }
+      }
+
+      numColumns := s.columns / maxWidth
+      numRows := len(items) / numColumns
+      if len(items)%numColumns > 0 {
+        numRows++
+      }
+
+      if len(items) <= numColumns {
+        maxWidth = 0
+      }
+      for i := 0; i < numRows; i++ {
+        for j := 0; j < numColumns*numRows; j += numRows {
+          if i+j < len(items) {
+            if maxWidth > 0 {
+              fmt.Printf("%-*s", maxWidth, items[i+j])
+            } else {
+              fmt.Printf("%v ", items[i+j])
+            }
+          }
+        }
+        fmt.Println("")
+      }
+    } else {
+      numTabs++
+    }
+    return prefix, nil
+  }
+}
+
+func (s *State) tabComplete(p []rune, line []rune, pos int) ([]rune, int, interface{}, error) {
+  if s.completer == nil {
+    return line, pos, rune(esc), nil
+  }
+  head, list, tail := s.completer(string(line), pos)
+  if len(list) <= 0 {
+    return line, pos, rune(esc), nil
+  }
+  hl := utf8.RuneCountInString(head)
+  if len(list) == 1 {
+    s.refresh(p, []rune(head+list[0]+tail), hl+utf8.RuneCountInString(list[0]))
+    return []rune(head + list[0] + tail), hl + utf8.RuneCountInString(list[0]), rune(esc), nil
+  }
+
+  direction := tabForward
+  tabPrinter := s.circularTabs(list)
+  if s.tabStyle == TabPrints {
+    tabPrinter = s.printedTabs(list)
+  }
+
+  for {
+    pick, err := tabPrinter(direction)
+    if err != nil {
+      return line, pos, rune(esc), err
+    }
+    s.refresh(p, []rune(head+pick+tail), hl+utf8.RuneCountInString(pick))
+
+    next, err := s.readNext()
+    if err != nil {
+      return line, pos, rune(esc), err
+    }
+    if key, ok := next.(rune); ok {
+      if key == tab {
+        direction = tabForward
+        continue
+      }
+      if key == esc {
+        return line, pos, rune(esc), nil
+      }
+    }
+    if a, ok := next.(action); ok && a == shiftTab {
+      direction = tabReverse
+      continue
+    }
+    return []rune(head + pick + tail), hl + utf8.RuneCountInString(pick), next, nil
+  }
+  // Not reached
+  return line, pos, rune(esc), nil
+}
+
+// reverse intelligent search, implements a bash-like history search.
+func (s *State) reverseISearch(origLine []rune, origPos int) ([]rune, int, interface{}, error) {
+  p := "(reverse-i-search)`': "
+  s.refresh([]rune(p), origLine, origPos)
+
+  line := []rune{}
+  pos := 0
+  foundLine := string(origLine)
+  foundPos := origPos
+
+  getLine := func() ([]rune, []rune, int) {
+    search := string(line)
+    prompt := "(reverse-i-search)`%s': "
+    return []rune(fmt.Sprintf(prompt, search)), []rune(foundLine), foundPos
+  }
+
+  history, positions := s.getHistoryByPattern(string(line))
+  historyPos := len(history) - 1
+
+  for {
+    next, err := s.readNext()
+    if err != nil {
+      return []rune(foundLine), foundPos, rune(esc), err
+    }
+
+    switch v := next.(type) {
+    case rune:
+      switch v {
+      case ctrlR: // Search backwards
+        if historyPos > 0 && historyPos < len(history) {
+          historyPos--
+          foundLine = history[historyPos]
+          foundPos = positions[historyPos]
+        } else {
+          fmt.Print(beep)
+        }
+      case ctrlS: // Search forward
+        if historyPos < len(history)-1 && historyPos >= 0 {
+          historyPos++
+          foundLine = history[historyPos]
+          foundPos = positions[historyPos]
+        } else {
+          fmt.Print(beep)
+        }
+      case ctrlH, bs: // Backspace
+        if pos <= 0 {
+          fmt.Print(beep)
+        } else {
+          n := len(getSuffixGlyphs(line[:pos], 1))
+          line = append(line[:pos-n], line[pos:]...)
+          pos -= n
+
+          // For each char deleted, display the last matching line of history
+          history, positions := s.getHistoryByPattern(string(line))
+          historyPos = len(history) - 1
+          if len(history) > 0 {
+            foundLine = history[historyPos]
+            foundPos = positions[historyPos]
+          } else {
+            foundLine = ""
+            foundPos = 0
+          }
+        }
+      case ctrlG: // Cancel
+        return origLine, origPos, rune(esc), err
+
+      case tab, cr, lf, ctrlA, ctrlB, ctrlD, ctrlE, ctrlF, ctrlK,
+        ctrlL, ctrlN, ctrlO, ctrlP, ctrlQ, ctrlT, ctrlU, ctrlV, ctrlW, ctrlX, ctrlY, ctrlZ:
+        fallthrough
+      case 0, ctrlC, esc, 28, 29, 30, 31:
+        return []rune(foundLine), foundPos, next, err
+      default:
+        line = append(line[:pos], append([]rune{v}, line[pos:]...)...)
+        pos++
+
+        // For each keystroke typed, display the last matching line of history
+        history, positions = s.getHistoryByPattern(string(line))
+        historyPos = len(history) - 1
+        if len(history) > 0 {
+          foundLine = history[historyPos]
+          foundPos = positions[historyPos]
+        } else {
+          foundLine = ""
+          foundPos = 0
+        }
+      }
+    case action:
+      return []rune(foundLine), foundPos, next, err
+    }
+    s.refresh(getLine())
+  }
+}
+
+// addToKillRing adds some text to the kill ring. If mode is 0 it adds it to a
+// new node in the end of the kill ring, and move the current pointer to the new
+// node. If mode is 1 or 2 it appends or prepends the text to the current entry
+// of the killRing.
+func (s *State) addToKillRing(text []rune, mode int) {
+  // Don't use the same underlying array as text
+  killLine := make([]rune, len(text))
+  copy(killLine, text)
+
+  // Point killRing to a newNode, procedure depends on the killring state and
+  // append mode.
+  if mode == 0 { // Add new node to killRing
+    if s.killRing == nil { // if killring is empty, create a new one
+      s.killRing = ring.New(1)
+    } else if s.killRing.Len() >= KillRingMax { // if killring is "full"
+      s.killRing = s.killRing.Next()
+    } else { // Normal case
+      s.killRing.Link(ring.New(1))
+      s.killRing = s.killRing.Next()
+    }
+  } else {
+    if s.killRing == nil { // if killring is empty, create a new one
+      s.killRing = ring.New(1)
+      s.killRing.Value = []rune{}
+    }
+    if mode == 1 { // Append to last entry
+      killLine = append(s.killRing.Value.([]rune), killLine...)
+    } else if mode == 2 { // Prepend to last entry
+      killLine = append(killLine, s.killRing.Value.([]rune)...)
+    }
+  }
+
+  // Save text in the current killring node
+  s.killRing.Value = killLine
+}
+
+func (s *State) yank(p []rune, text []rune, pos int) ([]rune, int, interface{}, error) {
+  if s.killRing == nil {
+    return text, pos, rune(esc), nil
+  }
+
+  lineStart := text[:pos]
+  lineEnd := text[pos:]
+  var line []rune
+
+  for {
+    value := s.killRing.Value.([]rune)
+    line = make([]rune, 0)
+    line = append(line, lineStart...)
+    line = append(line, value...)
+    line = append(line, lineEnd...)
+
+    pos = len(lineStart) + len(value)
+    s.refresh(p, line, pos)
+
+    next, err := s.readNext()
+    if err != nil {
+      return line, pos, next, err
+    }
+
+    switch v := next.(type) {
+    case rune:
+      return line, pos, next, nil
+    case action:
+      switch v {
+      case altY:
+        s.killRing = s.killRing.Prev()
+      default:
+        return line, pos, next, nil
+      }
+    }
+  }
+
+  return line, pos, esc, nil
+}
+
+// Prompt displays p and returns a line of user input, not including a trailing
+// newline character. An io.EOF error is returned if the user signals end-of-file
+// by pressing Ctrl-D. Prompt allows line editing if the terminal supports it.
+func (s *State) Prompt(prompt string) (string, error) {
+  if s.inputRedirected || !s.terminalSupported {
+    return s.promptUnsupported(prompt)
+  }
+  if s.outputRedirected {
+    return "", ErrNotTerminalOutput
+  }
+
+  s.historyMutex.RLock()
+  defer s.historyMutex.RUnlock()
+
+  s.startPrompt()
+  defer s.stopPrompt()
+  s.getColumns()
+
+  fmt.Print(prompt)
+  p := []rune(prompt)
+  var line []rune
+  pos := 0
+  historyEnd := ""
+  prefixHistory := s.getHistoryByPrefix(string(line))
+  historyPos := len(prefixHistory)
+  historyAction := false // used to mark history related actions
+  killAction := 0        // used to mark kill related actions
+mainLoop:
+  for {
+    next, err := s.readNext()
+  haveNext:
+    if err != nil {
+      return "", err
+    }
+
+    historyAction = false
+    switch v := next.(type) {
+    case rune:
+      switch v {
+      case cr, lf:
+        fmt.Println()
+        break mainLoop
+      case ctrlA: // Start of line
+        pos = 0
+        s.refresh(p, line, pos)
+      case ctrlE: // End of line
+        pos = len(line)
+        s.refresh(p, line, pos)
+      case ctrlB: // left
+        if pos > 0 {
+          pos -= len(getSuffixGlyphs(line[:pos], 1))
+          s.refresh(p, line, pos)
+        } else {
+          fmt.Print(beep)
+        }
+      case ctrlF: // right
+        if pos < len(line) {
+          pos += len(getPrefixGlyphs(line[pos:], 1))
+          s.refresh(p, line, pos)
+        } else {
+          fmt.Print(beep)
+        }
+      case ctrlD: // del
+        if pos == 0 && len(line) == 0 {
+          // exit
+          return "", io.EOF
+        }
+
+        // ctrlD is a potential EOF, so the rune reader shuts down.
+        // Therefore, if it isn't actually an EOF, we must re-startPrompt.
+        s.restartPrompt()
+
+        if pos >= len(line) {
+          fmt.Print(beep)
+        } else {
+          n := len(getPrefixGlyphs(line[pos:], 1))
+          line = append(line[:pos], line[pos+n:]...)
+          s.refresh(p, line, pos)
+        }
+      case ctrlK: // delete remainder of line
+        if pos >= len(line) {
+          fmt.Print(beep)
+        } else {
+          if killAction > 0 {
+            s.addToKillRing(line[pos:], 1) // Add in apend mode
+          } else {
+            s.addToKillRing(line[pos:], 0) // Add in normal mode
+          }
+
+          killAction = 2 // Mark that there was a kill action
+          line = line[:pos]
+          s.refresh(p, line, pos)
+        }
+      case ctrlP: // up
+        historyAction = true
+        if historyPos > 0 {
+          if historyPos == len(prefixHistory) {
+            historyEnd = string(line)
+          }
+          historyPos--
+          line = []rune(prefixHistory[historyPos])
+          pos = len(line)
+          s.refresh(p, line, pos)
+        } else {
+          fmt.Print(beep)
+        }
+      case ctrlN: // down
+        historyAction = true
+        if historyPos < len(prefixHistory) {
+          historyPos++
+          if historyPos == len(prefixHistory) {
+            line = []rune(historyEnd)
+          } else {
+            line = []rune(prefixHistory[historyPos])
+          }
+          pos = len(line)
+          s.refresh(p, line, pos)
+        } else {
+          fmt.Print(beep)
+        }
+      case ctrlT: // transpose prev glyph with glyph under cursor
+        if len(line) < 2 || pos < 1 {
+          fmt.Print(beep)
+        } else {
+          if pos == len(line) {
+            pos -= len(getSuffixGlyphs(line, 1))
+          }
+          prev := getSuffixGlyphs(line[:pos], 1)
+          next := getPrefixGlyphs(line[pos:], 1)
+          scratch := make([]rune, len(prev))
+          copy(scratch, prev)
+          copy(line[pos-len(prev):], next)
+          copy(line[pos-len(prev)+len(next):], scratch)
+          pos += len(next)
+          s.refresh(p, line, pos)
+        }
+      case ctrlL: // clear screen
+        s.eraseScreen()
+        s.refresh(p, line, pos)
+      case ctrlC: // reset
+        fmt.Println("^C")
+        if s.ctrlCAborts {
+          return "", ErrPromptAborted
+        }
+        line = line[:0]
+        pos = 0
+        fmt.Print(prompt)
+        s.restartPrompt()
+      case ctrlH, bs: // Backspace
+        if pos <= 0 {
+          fmt.Print(beep)
+        } else {
+          n := len(getSuffixGlyphs(line[:pos], 1))
+          line = append(line[:pos-n], line[pos:]...)
+          pos -= n
+          s.refresh(p, line, pos)
+        }
+      case ctrlU: // Erase line before cursor
+        if killAction > 0 {
+          s.addToKillRing(line[:pos], 2) // Add in prepend mode
+        } else {
+          s.addToKillRing(line[:pos], 0) // Add in normal mode
+        }
+
+        killAction = 2 // Mark that there was some killing
+        line = line[pos:]
+        pos = 0
+        s.refresh(p, line, pos)
+      case ctrlW: // Erase word
+        if pos == 0 {
+          fmt.Print(beep)
+          break
+        }
+        // Remove whitespace to the left
+        var buf []rune // Store the deleted chars in a buffer
+        for {
+          if pos == 0 || !unicode.IsSpace(line[pos-1]) {
+            break
+          }
+          buf = append(buf, line[pos-1])
+          line = append(line[:pos-1], line[pos:]...)
+          pos--
+        }
+        // Remove non-whitespace to the left
+        for {
+          if pos == 0 || unicode.IsSpace(line[pos-1]) {
+            break
+          }
+          buf = append(buf, line[pos-1])
+          line = append(line[:pos-1], line[pos:]...)
+          pos--
+        }
+        // Invert the buffer and save the result on the killRing
+        var newBuf []rune
+        for i := len(buf) - 1; i >= 0; i-- {
+          newBuf = append(newBuf, buf[i])
+        }
+        if killAction > 0 {
+          s.addToKillRing(newBuf, 2) // Add in prepend mode
+        } else {
+          s.addToKillRing(newBuf, 0) // Add in normal mode
+        }
+        killAction = 2 // Mark that there was some killing
+
+        s.refresh(p, line, pos)
+      case ctrlY: // Paste from Yank buffer
+        line, pos, next, err = s.yank(p, line, pos)
+        goto haveNext
+      case ctrlR: // Reverse Search
+        line, pos, next, err = s.reverseISearch(line, pos)
+        s.refresh(p, line, pos)
+        goto haveNext
+      case tab: // Tab completion
+        line, pos, next, err = s.tabComplete(p, line, pos)
+        goto haveNext
+      // Catch keys that do nothing, but you don't want them to beep
+      case esc:
+        // DO NOTHING
+      // Unused keys
+      case ctrlG, ctrlO, ctrlQ, ctrlS, ctrlV, ctrlX, ctrlZ:
+        fallthrough
+      // Catch unhandled control codes (anything <= 31)
+      case 0, 28, 29, 30, 31:
+        fmt.Print(beep)
+      default:
+        if pos == len(line) && len(p)+len(line) < s.columns-1 {
+          line = append(line, v)
+          fmt.Printf("%c", v)
+          pos++
+        } else {
+          line = append(line[:pos], append([]rune{v}, line[pos:]...)...)
+          pos++
+          s.refresh(p, line, pos)
+        }
+      }
+    case action:
+      switch v {
+      case del:
+        if pos >= len(line) {
+          fmt.Print(beep)
+        } else {
+          n := len(getPrefixGlyphs(line[pos:], 1))
+          line = append(line[:pos], line[pos+n:]...)
+        }
+      case left:
+        if pos > 0 {
+          pos -= len(getSuffixGlyphs(line[:pos], 1))
+        } else {
+          fmt.Print(beep)
+        }
+      case wordLeft:
+        if pos > 0 {
+          for {
+            pos--
+            if pos == 0 || unicode.IsSpace(line[pos-1]) {
+              break
+            }
+          }
+        } else {
+          fmt.Print(beep)
+        }
+      case right:
+        if pos < len(line) {
+          pos += len(getPrefixGlyphs(line[pos:], 1))
+        } else {
+          fmt.Print(beep)
+        }
+      case wordRight:
+        if pos < len(line) {
+          for {
+            pos++
+            if pos == len(line) || unicode.IsSpace(line[pos]) {
+              break
+            }
+          }
+        } else {
+          fmt.Print(beep)
+        }
+      case up:
+        historyAction = true
+        if historyPos > 0 {
+          if historyPos == len(prefixHistory) {
+            historyEnd = string(line)
+          }
+          historyPos--
+          line = []rune(prefixHistory[historyPos])
+          pos = len(line)
+        } else {
+          fmt.Print(beep)
+        }
+      case down:
+        historyAction = true
+        if historyPos < len(prefixHistory) {
+          historyPos++
+          if historyPos == len(prefixHistory) {
+            line = []rune(historyEnd)
+          } else {
+            line = []rune(prefixHistory[historyPos])
+          }
+          pos = len(line)
+        } else {
+          fmt.Print(beep)
+        }
+      case home: // Start of line
+        pos = 0
+      case end: // End of line
+        pos = len(line)
+      }
+      s.refresh(p, line, pos)
+    }
+    if !historyAction {
+      prefixHistory = s.getHistoryByPrefix(string(line))
+      historyPos = len(prefixHistory)
+    }
+    if killAction > 0 {
+      killAction--
+    }
+  }
+  return string(line), nil
+}
+
+// PasswordPrompt displays p, and then waits for user input. The input typed by
+// the user is not displayed in the terminal.
+func (s *State) PasswordPrompt(prompt string) (string, error) {
+  if !s.terminalSupported {
+    return "", errors.New("liner: function not supported in this terminal")
+  }
+  if s.inputRedirected {
+    return s.promptUnsupported(prompt)
+  }
+  if s.outputRedirected {
+    return "", ErrNotTerminalOutput
+  }
+
+  s.startPrompt()
+  defer s.stopPrompt()
+  s.getColumns()
+
+  fmt.Print(prompt)
+  p := []rune(prompt)
+  var line []rune
+  pos := 0
+
+mainLoop:
+  for {
+    next, err := s.readNext()
+    if err != nil {
+      return "", err
+    }
+
+    switch v := next.(type) {
+    case rune:
+      switch v {
+      case cr, lf:
+        fmt.Println()
+        break mainLoop
+      case ctrlD: // del
+        if pos == 0 && len(line) == 0 {
+          // exit
+          return "", io.EOF
+        }
+
+        // ctrlD is a potential EOF, so the rune reader shuts down.
+        // Therefore, if it isn't actually an EOF, we must re-startPrompt.
+        s.restartPrompt()
+      case ctrlL: // clear screen
+        s.eraseScreen()
+        s.refresh(p, []rune{}, 0)
+      case ctrlH, bs: // Backspace
+        if pos <= 0 {
+          fmt.Print(beep)
+        } else {
+          n := len(getSuffixGlyphs(line[:pos], 1))
+          line = append(line[:pos-n], line[pos:]...)
+          pos -= n
+        }
+      case ctrlC:
+        fmt.Println("^C")
+        if s.ctrlCAborts {
+          return "", ErrPromptAborted
+        }
+        line = line[:0]
+        pos = 0
+        fmt.Print(prompt)
+        s.restartPrompt()
+      // Unused keys
+      case esc, tab, ctrlA, ctrlB, ctrlE, ctrlF, ctrlG, ctrlK, ctrlN, ctrlO, ctrlP, ctrlQ, ctrlR, ctrlS,
+        ctrlT, ctrlU, ctrlV, ctrlW, ctrlX, ctrlY, ctrlZ:
+        fallthrough
+      // Catch unhandled control codes (anything <= 31)
+      case 0, 28, 29, 30, 31:
+        fmt.Print(beep)
+      default:
+        line = append(line[:pos], append([]rune{v}, line[pos:]...)...)
+        pos++
+      }
+    }
+  }
+  return string(line), nil
+}

third_party/liner/line_test.go

+package liner
+
+import (
+  "bytes"
+  "strings"
+  "testing"
+)
+
+func TestAppend(t *testing.T) {
+  var s State
+  s.AppendHistory("foo")
+  s.AppendHistory("bar")
+
+  var out bytes.Buffer
+  num, err := s.WriteHistory(&out)
+  if err != nil {
+    t.Fatal("Unexpected error writing history", err)
+  }
+  if num != 2 {
+    t.Fatalf("Expected 2 history entries, got %d", num)
+  }
+
+  s.AppendHistory("baz")
+  num, err = s.WriteHistory(&out)
+  if err != nil {
+    t.Fatal("Unexpected error writing history", err)
+  }
+  if num != 3 {
+    t.Fatalf("Expected 3 history entries, got %d", num)
+  }
+
+  s.AppendHistory("baz")
+  num, err = s.WriteHistory(&out)
+  if err != nil {
+    t.Fatal("Unexpected error writing history", err)
+  }
+  if num != 3 {
+    t.Fatalf("Expected 3 history entries after duplicate append, got %d", num)
+  }
+
+  s.AppendHistory("baz")
+
+}
+
+func TestHistory(t *testing.T) {
+  input := `foo
+bar
+baz
+quux
+dingle`
+
+  var s State
+  num, err := s.ReadHistory(strings.NewReader(input))
+  if err != nil {
+    t.Fatal("Unexpected error reading history", err)
+  }
+  if num != 5 {
+    t.Fatal("Wrong number of history entries read")
+  }
+
+  var out bytes.Buffer
+  num, err = s.WriteHistory(&out)
+  if err != nil {
+    t.Fatal("Unexpected error writing history", err)
+  }
+  if num != 5 {
+    t.Fatal("Wrong number of history entries written")
+  }
+  if strings.TrimSpace(out.String()) != input {
+    t.Fatal("Round-trip failure")
+  }
+
+  // Test reading with a trailing newline present
+  var s2 State
+  num, err = s2.ReadHistory(&out)
+  if err != nil {
+    t.Fatal("Unexpected error reading history the 2nd time", err)
+  }
+  if num != 5 {
+    t.Fatal("Wrong number of history entries read the 2nd time")
+  }
+
+  num, err = s.ReadHistory(strings.NewReader(input + "\n\xff"))
+  if err == nil {
+    t.Fatal("Unexpected success reading corrupted history", err)
+  }
+  if num != 5 {
+    t.Fatal("Wrong number of history entries read the 3rd time")
+  }
+}

third_party/liner/output.go

+// +build linux darwin openbsd freebsd netbsd
+
+package liner
+
+import (
+  "fmt"
+  "os"
+  "strings"
+  "syscall"
+  "unsafe"
+)
+
+func (s *State) cursorPos(x int) {
+  if s.useCHA {
+    // 'G' is "Cursor Character Absolute (CHA)"
+    fmt.Printf("\x1b[%dG", x+1)
+  } else {
+    // 'C' is "Cursor Forward (CUF)"
+    fmt.Print("\r")
+    if x > 0 {
+      fmt.Printf("\x1b[%dC", x)
+    }
+  }
+}
+
+func (s *State) eraseLine() {
+  fmt.Print("\x1b[0K")
+}
+
+func (s *State) eraseScreen() {
+  fmt.Print("\x1b[H\x1b[2J")
+}
+
+type winSize struct {
+  row, col       uint16
+  xpixel, ypixel uint16
+}
+
+func (s *State) getColumns() {
+  var ws winSize
+  ok, _, _ := syscall.Syscall(syscall.SYS_IOCTL, uintptr(syscall.Stdout),
+    syscall.TIOCGWINSZ, uintptr(unsafe.Pointer(&ws)))
+  if ok < 0 {
+    s.columns = 80
+  }
+  s.columns = int(ws.col)
+}
+
+func (s *State) checkOutput() {
+  // xterm is known to support CHA
+  if strings.Contains(strings.ToLower(os.Getenv("TERM")), "xterm") {
+    s.useCHA = true
+    return
+  }
+
+  // The test for functional ANSI CHA is unreliable (eg the Windows
+  // telnet command does not support reading the cursor position with
+  // an ANSI DSR request, despite setting TERM=ansi)
+
+  // Assume CHA isn't supported (which should be safe, although it
+  // does result in occasional visible cursor jitter)
+  s.useCHA = false
+}

third_party/liner/output_windows.go

+package liner
+
+import (
+  "unsafe"
+)
+
+type coord struct {
+  x, y int16
+}
+type smallRect struct {
+  left, top, right, bottom int16
+}
+
+type consoleScreenBufferInfo struct {
+  dwSize              coord
+  dwCursorPosition    coord
+  wAttributes         int16
+  srWindow            smallRect
+  dwMaximumWindowSize coord
+}
+
+func (s *State) cursorPos(x int) {
+  var sbi consoleScreenBufferInfo
+  procGetConsoleScreenBufferInfo.Call(uintptr(s.hOut), uintptr(unsafe.Pointer(&sbi)))
+  procSetConsoleCursorPosition.Call(uintptr(s.hOut),
+    uintptr(int(x)&0xFFFF|int(sbi.dwCursorPosition.y)<<16))
+}
+
+func (s *State) eraseLine() {
+  var sbi consoleScreenBufferInfo
+  procGetConsoleScreenBufferInfo.Call(uintptr(s.hOut), uintptr(unsafe.Pointer(&sbi)))
+  var numWritten uint32
+  procFillConsoleOutputCharacter.Call(uintptr(s.hOut), uintptr(' '),
+    uintptr(sbi.dwSize.x-sbi.dwCursorPosition.x),
+    uintptr(int(sbi.dwCursorPosition.x)&0xFFFF|int(sbi.dwCursorPosition.y)<<16),
+    uintptr(unsafe.Pointer(&numWritten)))
+}
+
+func (s *State) eraseScreen() {
+  var sbi consoleScreenBufferInfo
+  procGetConsoleScreenBufferInfo.Call(uintptr(s.hOut), uintptr(unsafe.Pointer(&sbi)))
+  var numWritten uint32
+  procFillConsoleOutputCharacter.Call(uintptr(s.hOut), uintptr(' '),
+    uintptr(sbi.dwSize.x)*uintptr(sbi.dwSize.y),
+    0,
+    uintptr(unsafe.Pointer(&numWritten)))
+  procSetConsoleCursorPosition.Call(uintptr(s.hOut), 0)
+}
+
+func (s *State) getColumns() {
+  var sbi consoleScreenBufferInfo
+  procGetConsoleScreenBufferInfo.Call(uintptr(s.hOut), uintptr(unsafe.Pointer(&sbi)))
+  s.columns = int(sbi.dwSize.x)
+}

third_party/liner/prefix_test.go

+// +build windows linux darwin openbsd freebsd netbsd
+
+package liner
+
+import "testing"
+
+type testItem struct {
+  list   []string
+  prefix string
+}
+
+func TestPrefix(t *testing.T) {
+  list := []testItem{
+    {[]string{"food", "foot"}, "foo"},
+    {[]string{"foo", "foot"}, "foo"},
+    {[]string{"food", "foo"}, "foo"},
+    {[]string{"food", "foe", "foot"}, "fo"},
+    {[]string{"food", "foot", "barbeque"}, ""},
+    {[]string{"cafeteria", "café"}, "caf"},
+    {[]string{"cafe", "café"}, "caf"},
+    {[]string{"cafè", "café"}, "caf"},
+    {[]string{"cafés", "café"}, "café"},
+    {[]string{"áéíóú", "áéíóú"}, "áéíóú"},
+    {[]string{"éclairs", "éclairs"}, "éclairs"},
+    {[]string{"éclairs are the best", "éclairs are great", "éclairs"}, "éclairs"},
+    {[]string{"éclair", "éclairs"}, "éclair"},
+    {[]string{"éclairs", "éclair"}, "éclair"},
+    {[]string{"éclair", "élan"}, "é"},
+  }
+
+  for _, test := range list {
+    lcp := longestCommonPrefix(test.list)
+    if lcp != test.prefix {
+      t.Errorf("%s != %s for %+v", lcp, test.prefix, test.list)
+    }
+  }
+}

third_party/liner/race_test.go

+// +build race
+
+package liner
+
+import (
+  "io/ioutil"
+  "os"
+  "sync"
+  "testing"
+)
+
+func TestWriteHistory(t *testing.T) {
+  oldout := os.Stdout
+  defer func() { os.Stdout = oldout }()
+  oldin := os.Stdout
+  defer func() { os.Stdin = oldin }()
+
+  newinr, newinw, err := os.Pipe()
+  if err != nil {
+    t.Fatal(err)
+  }
+  os.Stdin = newinr
+  newoutr, newoutw, err := os.Pipe()
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer newoutr.Close()
+  os.Stdout = newoutw
+
+  var wait sync.WaitGroup
+  wait.Add(1)
+  s := NewLiner()
+  go func() {
+    s.AppendHistory("foo")
+    s.AppendHistory("bar")
+    s.Prompt("")
+    wait.Done()
+  }()
+
+  s.WriteHistory(ioutil.Discard)
+
+  newinw.Close()
+  wait.Wait()
+}

third_party/liner/signal.go

+// +build go1.1,!windows
+
+package liner
+
+import (
+  "os"
+  "os/signal"
+)
+
+func stopSignal(c chan<- os.Signal) {
+  signal.Stop(c)
+}

third_party/liner/signal_legacy.go

+// +build !go1.1,!windows
+
+package liner
+
+import (
+  "os"
+)
+
+func stopSignal(c chan<- os.Signal) {
+  // signal.Stop does not exist before Go 1.1
+}

third_party/liner/unixmode.go

+// +build linux darwin freebsd openbsd netbsd
+
+package liner
+
+import (
+  "syscall"
+  "unsafe"
+)
+
+func (mode *termios) ApplyMode() error {
+  _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, uintptr(syscall.Stdin), setTermios, uintptr(unsafe.Pointer(mode)))
+
+  if errno != 0 {
+    return errno
+  }
+  return nil
+}
+
+// TerminalMode returns the current terminal input mode as an InputModeSetter.
+//
+// This function is provided for convenience, and should
+// not be necessary for most users of liner.
+func TerminalMode() (ModeApplier, error) {
+  mode, errno := getMode(syscall.Stdin)
+
+  if errno != 0 {
+    return nil, errno
+  }
+  return mode, nil
+}
+
+func getMode(handle int) (*termios, syscall.Errno) {
+  var mode termios
+  _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, uintptr(handle), getTermios, uintptr(unsafe.Pointer(&mode)))
+
+  return &mode, errno
+}

third_party/liner/width.go

+package liner
+
+import "unicode"
+
+// These character classes are mostly zero width (when combined).
+// A few might not be, depending on the user's font. Fixing this
+// is non-trivial, given that some terminals don't support
+// ANSI DSR/CPR
+var zeroWidth = []*unicode.RangeTable{
+  unicode.Mn,
+  unicode.Me,
+  unicode.Cc,
+  unicode.Cf,
+}
+
+var doubleWidth = []*unicode.RangeTable{
+  unicode.Han,
+  unicode.Hangul,
+  unicode.Hiragana,
+  unicode.Katakana,
+}
+
+// countGlyphs considers zero-width characters to be zero glyphs wide,
+// and members of Chinese, Japanese, and Korean scripts to be 2 glyphs wide.
+func countGlyphs(s []rune) int {
+  n := 0
+  for _, r := range s {
+    switch {
+    case unicode.IsOneOf(zeroWidth, r):
+    case unicode.IsOneOf(doubleWidth, r):
+      n += 2
+    default:
+      n++
+    }
+  }
+  return n
+}
+
+func getPrefixGlyphs(s []rune, num int) []rune {
+  p := 0
+  for n := 0; n < num && p < len(s); p++ {
+    if !unicode.IsOneOf(zeroWidth, s[p]) {
+      n++
+    }
+  }
+  for p < len(s) && unicode.IsOneOf(zeroWidth, s[p]) {
+    p++
+  }
+  return s[:p]
+}
+
+func getSuffixGlyphs(s []rune, num int) []rune {
+  p := len(s)
+  for n := 0; n < num && p > 0; p-- {
+    if !unicode.IsOneOf(zeroWidth, s[p-1]) {
+      n++
+    }
+  }
+  return s[p:]
+}

third_party/liner/width_test.go

+package liner
+
+import (
+  "strconv"
+  "testing"
+)
+
+func accent(in []rune) []rune {
+  var out []rune
+  for _, r := range in {
+    out = append(out, r)
+    out = append(out, '\u0301')
+  }
+  return out
+}
+
+type testCase struct {
+  s      []rune
+  glyphs int
+}
+
+var testCases = []testCase{
+  {[]rune("query"), 5},
+  {[]rune("私"), 2},
+  {[]rune("hello世界"), 9},
+}
+
+func TestCountGlyphs(t *testing.T) {
+  for _, testCase := range testCases {
+    count := countGlyphs(testCase.s)
+    if count != testCase.glyphs {
+      t.Errorf("ASCII count incorrect. %d != %d", count, testCase.glyphs)
+    }
+    count = countGlyphs(accent(testCase.s))
+    if count != testCase.glyphs {
+      t.Errorf("Accent count incorrect. %d != %d", count, testCase.glyphs)
+    }
+  }
+}
+
+func compare(a, b []rune, name string, t *testing.T) {
+  if len(a) != len(b) {
+    t.Errorf(`"%s" != "%s" in %s"`, string(a), string(b), name)
+    return
+  }
+  for i := range a {
+    if a[i] != b[i] {
+      t.Errorf(`"%s" != "%s" in %s"`, string(a), string(b), name)
+      return
+    }
+  }
+}
+
+func TestPrefixGlyphs(t *testing.T) {
+  for _, testCase := range testCases {
+    for i := 0; i <= len(testCase.s); i++ {
+      iter := strconv.Itoa(i)
+      out := getPrefixGlyphs(testCase.s, i)
+      compare(out, testCase.s[:i], "ascii prefix "+iter, t)
+      out = getPrefixGlyphs(accent(testCase.s), i)
+      compare(out, accent(testCase.s[:i]), "accent prefix "+iter, t)
+    }
+    out := getPrefixGlyphs(testCase.s, 999)
+    compare(out, testCase.s, "ascii prefix overflow", t)
+    out = getPrefixGlyphs(accent(testCase.s), 999)
+    compare(out, accent(testCase.s), "accent prefix overflow", t)
+
+    out = getPrefixGlyphs(testCase.s, -3)
+    if len(out) != 0 {
+      t.Error("ascii prefix negative")
+    }
+    out = getPrefixGlyphs(accent(testCase.s), -3)
+    if len(out) != 0 {
+      t.Error("accent prefix negative")
+    }
+  }
+}
+
+func TestSuffixGlyphs(t *testing.T) {
+  for _, testCase := range testCases {
+    for i := 0; i <= len(testCase.s); i++ {
+      iter := strconv.Itoa(i)
+      out := getSuffixGlyphs(testCase.s, i)
+      compare(out, testCase.s[len(testCase.s)-i:], "ascii suffix "+iter, t)
+      out = getSuffixGlyphs(accent(testCase.s), i)
+      compare(out, accent(testCase.s[len(testCase.s)-i:]), "accent suffix "+iter, t)
+    }
+    out := getSuffixGlyphs(testCase.s, 999)
+    compare(out, testCase.s, "ascii suffix overflow", t)
+    out = getSuffixGlyphs(accent(testCase.s), 999)
+    compare(out, accent(testCase.s), "accent suffix overflow", t)
+
+    out = getSuffixGlyphs(testCase.s, -3)
+    if len(out) != 0 {
+      t.Error("ascii suffix negative")
+    }
+    out = getSuffixGlyphs(accent(testCase.s), -3)
+    if len(out) != 0 {
+      t.Error("accent suffix negative")
+    }
+  }
+}

update_third_party.sh

 #!/bin/sh -e
 
+scriptpath=$(readlink -f "$0")
+llgosrcdir=$(dirname "$scriptpath")
+cd $llgosrcdir
+
 gofrontendrepo=https://code.google.com/p/gofrontend
 gofrontendrev=15a24202fa42
 
 gccrepo=svn://gcc.gnu.org/svn/gcc/trunk
 gccrev=219477
 
 gotoolsrepo=https://go.googlesource.com/tools
 gotoolsrev=d4e70101500b43ffe705d4c45e50dd4f1c8e3b2e
 
+linerrepo=https://github.com/peterh/liner.git
+linerrev=1bb0d1c1a25ed393d8feb09bab039b2b1b1fbced
+
 tempdir=$(mktemp -d /tmp/update_third_party.XXXXXX)
 gofrontenddir=$tempdir/gofrontend
 gotoolsdir=$tempdir/go.tools
+linerdir=third_party/liner
 
 rm -rf third_party
 mkdir -p third_party/gofrontend third_party/gotools
 
 # --------------------- gofrontend ---------------------
 
 hg clone -r $gofrontendrev $gofrontendrepo $gofrontenddir
 

 
 mkdir -p third_party/gofrontend/include third_party/gofrontend/libgcc
 
 # Copy in our versions of GCC files.
 cp include/dwarf2.h third_party/gofrontend/include/
 cp include/filenames.h third_party/gofrontend/include/
 cp include/unwind-pe.h third_party/gofrontend/libgcc/
 
+# Note: this expects the llgo source tree to be located at llvm/tools/llgo.
 cp ../../autoconf/config.guess third_party/gofrontend/
 cp ../../autoconf/config.sub third_party/gofrontend/
 
 for d in libbacktrace libffi ; do
   svn export -r $gccrev $gccrepo/$d third_party/gofrontend/$d
 done
 
 # Remove GPL licensed files, and files that confuse our license check.

 (cd $gotoolsdir && git checkout $gotoolsrev)
 
 cp -r $gotoolsdir/LICENSE $gotoolsdir/go third_party/gotools
 
 # Vendor the go.tools repository.
 find third_party/gotools -name '*.go' | xargs sed -i -e \
   's,"golang.org/x/tools/,"llvm.org/llgo/third_party/gotools/,g'
 
+# --------------------- peterh/liner -----------------
+
+git clone $linerrepo $linerdir
+(cd $linerdir && git checkout $linerrev)
+
 # --------------------- license check ---------------------
 
 # We don't want any GPL licensed code without an autoconf/libtool
 # exception, or any GPLv3 licensed code.
 
 for i in `grep -lr 'General Public License' third_party` ; do
   if grep -q 'configuration script generated by Autoconf, you may include it under' $i || \
      grep -q 'is built using GNU Libtool, you may include this file under the' $i ; then