cmd/bpa-operator/vendor/golang.org/x/crypto/ssh/terminal/terminal.go

   1 // Copyright 2011 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package terminal
   6
   7 import (
   8         "bytes"
   9         "io"
  10         "strconv"
  11         "sync"
  12         "unicode/utf8"
  13 )
  14
  15 // EscapeCodes contains escape sequences that can be written to the terminal in
  16 // order to achieve different styles of text.
  17 type EscapeCodes struct {
  18         // Foreground colors
  19         Black, Red, Green, Yellow, Blue, Magenta, Cyan, White []byte
  20
  21         // Reset all attributes
  22         Reset []byte
  23 }
  24
  25 var vt100EscapeCodes = EscapeCodes{
  26         Black:   []byte{keyEscape, '[', '3', '0', 'm'},
  27         Red:     []byte{keyEscape, '[', '3', '1', 'm'},
  28         Green:   []byte{keyEscape, '[', '3', '2', 'm'},
  29         Yellow:  []byte{keyEscape, '[', '3', '3', 'm'},
  30         Blue:    []byte{keyEscape, '[', '3', '4', 'm'},
  31         Magenta: []byte{keyEscape, '[', '3', '5', 'm'},
  32         Cyan:    []byte{keyEscape, '[', '3', '6', 'm'},
  33         White:   []byte{keyEscape, '[', '3', '7', 'm'},
  34
  35         Reset: []byte{keyEscape, '[', '0', 'm'},
  36 }
  37
  38 // Terminal contains the state for running a VT100 terminal that is capable of
  39 // reading lines of input.
  40 type Terminal struct {
  41         // AutoCompleteCallback, if non-null, is called for each keypress with
  42         // the full input line and the current position of the cursor (in
  43         // bytes, as an index into |line|). If it returns ok=false, the key
  44         // press is processed normally. Otherwise it returns a replacement line
  45         // and the new cursor position.
  46         AutoCompleteCallback func(line string, pos int, key rune) (newLine string, newPos int, ok bool)
  47
  48         // Escape contains a pointer to the escape codes for this terminal.
  49         // It's always a valid pointer, although the escape codes themselves
  50         // may be empty if the terminal doesn't support them.
  51         Escape *EscapeCodes
  52
  53         // lock protects the terminal and the state in this object from
  54         // concurrent processing of a key press and a Write() call.
  55         lock sync.Mutex
  56
  57         c      io.ReadWriter
  58         prompt []rune
  59
  60         // line is the current line being entered.
  61         line []rune
  62         // pos is the logical position of the cursor in line
  63         pos int
  64         // echo is true if local echo is enabled
  65         echo bool
  66         // pasteActive is true iff there is a bracketed paste operation in
  67         // progress.
  68         pasteActive bool
  69
  70         // cursorX contains the current X value of the cursor where the left
  71         // edge is 0. cursorY contains the row number where the first row of
  72         // the current line is 0.
  73         cursorX, cursorY int
  74         // maxLine is the greatest value of cursorY so far.
  75         maxLine int
  76
  77         termWidth, termHeight int
  78
  79         // outBuf contains the terminal data to be sent.
  80         outBuf []byte
  81         // remainder contains the remainder of any partial key sequences after
  82         // a read. It aliases into inBuf.
  83         remainder []byte
  84         inBuf     [256]byte
  85
  86         // history contains previously entered commands so that they can be
  87         // accessed with the up and down keys.
  88         history stRingBuffer
  89         // historyIndex stores the currently accessed history entry, where zero
  90         // means the immediately previous entry.
  91         historyIndex int
  92         // When navigating up and down the history it's possible to return to
  93         // the incomplete, initial line. That value is stored in
  94         // historyPending.
  95         historyPending string
  96 }
  97
  98 // NewTerminal runs a VT100 terminal on the given ReadWriter. If the ReadWriter is
  99 // a local terminal, that terminal must first have been put into raw mode.
 100 // prompt is a string that is written at the start of each input line (i.e.
 101 // "> ").
 102 func NewTerminal(c io.ReadWriter, prompt string) *Terminal {
 103         return &Terminal{
 104                 Escape:       &vt100EscapeCodes,
 105                 c:            c,
 106                 prompt:       []rune(prompt),
 107                 termWidth:    80,
 108                 termHeight:   24,
 109                 echo:         true,
 110                 historyIndex: -1,
 111         }
 112 }
 113
 114 const (
 115         keyCtrlD     = 4
 116         keyCtrlU     = 21
 117         keyEnter     = '\r'
 118         keyEscape    = 27
 119         keyBackspace = 127
 120         keyUnknown   = 0xd800 /* UTF-16 surrogate area */ + iota
 121         keyUp
 122         keyDown
 123         keyLeft
 124         keyRight
 125         keyAltLeft
 126         keyAltRight
 127         keyHome
 128         keyEnd
 129         keyDeleteWord
 130         keyDeleteLine
 131         keyClearScreen
 132         keyPasteStart
 133         keyPasteEnd
 134 )
 135
 136 var (
 137         crlf       = []byte{'\r', '\n'}
 138         pasteStart = []byte{keyEscape, '[', '2', '0', '0', '~'}
 139         pasteEnd   = []byte{keyEscape, '[', '2', '0', '1', '~'}
 140 )
 141
 142 // bytesToKey tries to parse a key sequence from b. If successful, it returns
 143 // the key and the remainder of the input. Otherwise it returns utf8.RuneError.
 144 func bytesToKey(b []byte, pasteActive bool) (rune, []byte) {
 145         if len(b) == 0 {
 146                 return utf8.RuneError, nil
 147         }
 148
 149         if !pasteActive {
 150                 switch b[0] {
 151                 case 1: // ^A
 152                         return keyHome, b[1:]
 153                 case 5: // ^E
 154                         return keyEnd, b[1:]
 155                 case 8: // ^H
 156                         return keyBackspace, b[1:]
 157                 case 11: // ^K
 158                         return keyDeleteLine, b[1:]
 159                 case 12: // ^L
 160                         return keyClearScreen, b[1:]
 161                 case 23: // ^W
 162                         return keyDeleteWord, b[1:]
 163                 case 14: // ^N
 164                         return keyDown, b[1:]
 165                 case 16: // ^P
 166                         return keyUp, b[1:]
 167                 }
 168         }
 169
 170         if b[0] != keyEscape {
 171                 if !utf8.FullRune(b) {
 172                         return utf8.RuneError, b
 173                 }
 174                 r, l := utf8.DecodeRune(b)
 175                 return r, b[l:]
 176         }
 177
 178         if !pasteActive && len(b) >= 3 && b[0] == keyEscape && b[1] == '[' {
 179                 switch b[2] {
 180                 case 'A':
 181                         return keyUp, b[3:]
 182                 case 'B':
 183                         return keyDown, b[3:]
 184                 case 'C':
 185                         return keyRight, b[3:]
 186                 case 'D':
 187                         return keyLeft, b[3:]
 188                 case 'H':
 189                         return keyHome, b[3:]
 190                 case 'F':
 191                         return keyEnd, b[3:]
 192                 }
 193         }
 194
 195         if !pasteActive && len(b) >= 6 && b[0] == keyEscape && b[1] == '[' && b[2] == '1' && b[3] == ';' && b[4] == '3' {
 196                 switch b[5] {
 197                 case 'C':
 198                         return keyAltRight, b[6:]
 199                 case 'D':
 200                         return keyAltLeft, b[6:]
 201                 }
 202         }
 203
 204         if !pasteActive && len(b) >= 6 && bytes.Equal(b[:6], pasteStart) {
 205                 return keyPasteStart, b[6:]
 206         }
 207
 208         if pasteActive && len(b) >= 6 && bytes.Equal(b[:6], pasteEnd) {
 209                 return keyPasteEnd, b[6:]
 210         }
 211
 212         // If we get here then we have a key that we don't recognise, or a
 213         // partial sequence. It's not clear how one should find the end of a
 214         // sequence without knowing them all, but it seems that [a-zA-Z~] only
 215         // appears at the end of a sequence.
 216         for i, c := range b[0:] {
 217                 if c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c == '~' {
 218                         return keyUnknown, b[i+1:]
 219                 }
 220         }
 221
 222         return utf8.RuneError, b
 223 }
 224
 225 // queue appends data to the end of t.outBuf
 226 func (t *Terminal) queue(data []rune) {
 227         t.outBuf = append(t.outBuf, []byte(string(data))...)
 228 }
 229
 230 var eraseUnderCursor = []rune{' ', keyEscape, '[', 'D'}
 231 var space = []rune{' '}
 232
 233 func isPrintable(key rune) bool {
 234         isInSurrogateArea := key >= 0xd800 && key <= 0xdbff
 235         return key >= 32 && !isInSurrogateArea
 236 }
 237
 238 // moveCursorToPos appends data to t.outBuf which will move the cursor to the
 239 // given, logical position in the text.
 240 func (t *Terminal) moveCursorToPos(pos int) {
 241         if !t.echo {
 242                 return
 243         }
 244
 245         x := visualLength(t.prompt) + pos
 246         y := x / t.termWidth
 247         x = x % t.termWidth
 248
 249         up := 0
 250         if y < t.cursorY {
 251                 up = t.cursorY - y
 252         }
 253
 254         down := 0
 255         if y > t.cursorY {
 256                 down = y - t.cursorY
 257         }
 258
 259         left := 0
 260         if x < t.cursorX {
 261                 left = t.cursorX - x
 262         }
 263
 264         right := 0
 265         if x > t.cursorX {
 266                 right = x - t.cursorX
 267         }
 268
 269         t.cursorX = x
 270         t.cursorY = y
 271         t.move(up, down, left, right)
 272 }
 273
 274 func (t *Terminal) move(up, down, left, right int) {
 275         m := []rune{}
 276
 277         // 1 unit up can be expressed as ^[[A or ^[A
 278         // 5 units up can be expressed as ^[[5A
 279
 280         if up == 1 {
 281                 m = append(m, keyEscape, '[', 'A')
 282         } else if up > 1 {
 283                 m = append(m, keyEscape, '[')
 284                 m = append(m, []rune(strconv.Itoa(up))...)
 285                 m = append(m, 'A')
 286         }
 287
 288         if down == 1 {
 289                 m = append(m, keyEscape, '[', 'B')
 290         } else if down > 1 {
 291                 m = append(m, keyEscape, '[')
 292                 m = append(m, []rune(strconv.Itoa(down))...)
 293                 m = append(m, 'B')
 294         }
 295
 296         if right == 1 {
 297                 m = append(m, keyEscape, '[', 'C')
 298         } else if right > 1 {
 299                 m = append(m, keyEscape, '[')
 300                 m = append(m, []rune(strconv.Itoa(right))...)
 301                 m = append(m, 'C')
 302         }
 303
 304         if left == 1 {
 305                 m = append(m, keyEscape, '[', 'D')
 306         } else if left > 1 {
 307                 m = append(m, keyEscape, '[')
 308                 m = append(m, []rune(strconv.Itoa(left))...)
 309                 m = append(m, 'D')
 310         }
 311
 312         t.queue(m)
 313 }
 314
 315 func (t *Terminal) clearLineToRight() {
 316         op := []rune{keyEscape, '[', 'K'}
 317         t.queue(op)
 318 }
 319
 320 const maxLineLength = 4096
 321
 322 func (t *Terminal) setLine(newLine []rune, newPos int) {
 323         if t.echo {
 324                 t.moveCursorToPos(0)
 325                 t.writeLine(newLine)
 326                 for i := len(newLine); i < len(t.line); i++ {
 327                         t.writeLine(space)
 328                 }
 329                 t.moveCursorToPos(newPos)
 330         }
 331         t.line = newLine
 332         t.pos = newPos
 333 }
 334
 335 func (t *Terminal) advanceCursor(places int) {
 336         t.cursorX += places
 337         t.cursorY += t.cursorX / t.termWidth
 338         if t.cursorY > t.maxLine {
 339                 t.maxLine = t.cursorY
 340         }
 341         t.cursorX = t.cursorX % t.termWidth
 342
 343         if places > 0 && t.cursorX == 0 {
 344                 // Normally terminals will advance the current position
 345                 // when writing a character. But that doesn't happen
 346                 // for the last character in a line. However, when
 347                 // writing a character (except a new line) that causes
 348                 // a line wrap, the position will be advanced two
 349                 // places.
 350                 //
 351                 // So, if we are stopping at the end of a line, we
 352                 // need to write a newline so that our cursor can be
 353                 // advanced to the next line.
 354                 t.outBuf = append(t.outBuf, '\r', '\n')
 355         }
 356 }
 357
 358 func (t *Terminal) eraseNPreviousChars(n int) {
 359         if n == 0 {
 360                 return
 361         }
 362
 363         if t.pos < n {
 364                 n = t.pos
 365         }
 366         t.pos -= n
 367         t.moveCursorToPos(t.pos)
 368
 369         copy(t.line[t.pos:], t.line[n+t.pos:])
 370         t.line = t.line[:len(t.line)-n]
 371         if t.echo {
 372                 t.writeLine(t.line[t.pos:])
 373                 for i := 0; i < n; i++ {
 374                         t.queue(space)
 375                 }
 376                 t.advanceCursor(n)
 377                 t.moveCursorToPos(t.pos)
 378         }
 379 }
 380
 381 // countToLeftWord returns then number of characters from the cursor to the
 382 // start of the previous word.
 383 func (t *Terminal) countToLeftWord() int {
 384         if t.pos == 0 {
 385                 return 0
 386         }
 387
 388         pos := t.pos - 1
 389         for pos > 0 {
 390                 if t.line[pos] != ' ' {
 391                         break
 392                 }
 393                 pos--
 394         }
 395         for pos > 0 {
 396                 if t.line[pos] == ' ' {
 397                         pos++
 398                         break
 399                 }
 400                 pos--
 401         }
 402
 403         return t.pos - pos
 404 }
 405
 406 // countToRightWord returns then number of characters from the cursor to the
 407 // start of the next word.
 408 func (t *Terminal) countToRightWord() int {
 409         pos := t.pos
 410         for pos < len(t.line) {
 411                 if t.line[pos] == ' ' {
 412                         break
 413                 }
 414                 pos++
 415         }
 416         for pos < len(t.line) {
 417                 if t.line[pos] != ' ' {
 418                         break
 419                 }
 420                 pos++
 421         }
 422         return pos - t.pos
 423 }
 424
 425 // visualLength returns the number of visible glyphs in s.
 426 func visualLength(runes []rune) int {
 427         inEscapeSeq := false
 428         length := 0
 429
 430         for _, r := range runes {
 431                 switch {
 432                 case inEscapeSeq:
 433                         if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') {
 434                                 inEscapeSeq = false
 435                         }
 436                 case r == '\x1b':
 437                         inEscapeSeq = true
 438                 default:
 439                         length++
 440                 }
 441         }
 442
 443         return length
 444 }
 445
 446 // handleKey processes the given key and, optionally, returns a line of text
 447 // that the user has entered.
 448 func (t *Terminal) handleKey(key rune) (line string, ok bool) {
 449         if t.pasteActive && key != keyEnter {
 450                 t.addKeyToLine(key)
 451                 return
 452         }
 453
 454         switch key {
 455         case keyBackspace:
 456                 if t.pos == 0 {
 457                         return
 458                 }
 459                 t.eraseNPreviousChars(1)
 460         case keyAltLeft:
 461                 // move left by a word.
 462                 t.pos -= t.countToLeftWord()
 463                 t.moveCursorToPos(t.pos)
 464         case keyAltRight:
 465                 // move right by a word.
 466                 t.pos += t.countToRightWord()
 467                 t.moveCursorToPos(t.pos)
 468         case keyLeft:
 469                 if t.pos == 0 {
 470                         return
 471                 }
 472                 t.pos--
 473                 t.moveCursorToPos(t.pos)
 474         case keyRight:
 475                 if t.pos == len(t.line) {
 476                         return
 477                 }
 478                 t.pos++
 479                 t.moveCursorToPos(t.pos)
 480         case keyHome:
 481                 if t.pos == 0 {
 482                         return
 483                 }
 484                 t.pos = 0
 485                 t.moveCursorToPos(t.pos)
 486         case keyEnd:
 487                 if t.pos == len(t.line) {
 488                         return
 489                 }
 490                 t.pos = len(t.line)
 491                 t.moveCursorToPos(t.pos)
 492         case keyUp:
 493                 entry, ok := t.history.NthPreviousEntry(t.historyIndex + 1)
 494                 if !ok {
 495                         return "", false
 496                 }
 497                 if t.historyIndex == -1 {
 498                         t.historyPending = string(t.line)
 499                 }
 500                 t.historyIndex++
 501                 runes := []rune(entry)
 502                 t.setLine(runes, len(runes))
 503         case keyDown:
 504                 switch t.historyIndex {
 505                 case -1:
 506                         return
 507                 case 0:
 508                         runes := []rune(t.historyPending)
 509                         t.setLine(runes, len(runes))
 510                         t.historyIndex--
 511                 default:
 512                         entry, ok := t.history.NthPreviousEntry(t.historyIndex - 1)
 513                         if ok {
 514                                 t.historyIndex--
 515                                 runes := []rune(entry)
 516                                 t.setLine(runes, len(runes))
 517                         }
 518                 }
 519         case keyEnter:
 520                 t.moveCursorToPos(len(t.line))
 521                 t.queue([]rune("\r\n"))
 522                 line = string(t.line)
 523                 ok = true
 524                 t.line = t.line[:0]
 525                 t.pos = 0
 526                 t.cursorX = 0
 527                 t.cursorY = 0
 528                 t.maxLine = 0
 529         case keyDeleteWord:
 530                 // Delete zero or more spaces and then one or more characters.
 531                 t.eraseNPreviousChars(t.countToLeftWord())
 532         case keyDeleteLine:
 533                 // Delete everything from the current cursor position to the
 534                 // end of line.
 535                 for i := t.pos; i < len(t.line); i++ {
 536                         t.queue(space)
 537                         t.advanceCursor(1)
 538                 }
 539                 t.line = t.line[:t.pos]
 540                 t.moveCursorToPos(t.pos)
 541         case keyCtrlD:
 542                 // Erase the character under the current position.
 543                 // The EOF case when the line is empty is handled in
 544                 // readLine().
 545                 if t.pos < len(t.line) {
 546                         t.pos++
 547                         t.eraseNPreviousChars(1)
 548                 }
 549         case keyCtrlU:
 550                 t.eraseNPreviousChars(t.pos)
 551         case keyClearScreen:
 552                 // Erases the screen and moves the cursor to the home position.
 553                 t.queue([]rune("\x1b[2J\x1b[H"))
 554                 t.queue(t.prompt)
 555                 t.cursorX, t.cursorY = 0, 0
 556                 t.advanceCursor(visualLength(t.prompt))
 557                 t.setLine(t.line, t.pos)
 558         default:
 559                 if t.AutoCompleteCallback != nil {
 560                         prefix := string(t.line[:t.pos])
 561                         suffix := string(t.line[t.pos:])
 562
 563                         t.lock.Unlock()
 564                         newLine, newPos, completeOk := t.AutoCompleteCallback(prefix+suffix, len(prefix), key)
 565                         t.lock.Lock()
 566
 567                         if completeOk {
 568                                 t.setLine([]rune(newLine), utf8.RuneCount([]byte(newLine)[:newPos]))
 569                                 return
 570                         }
 571                 }
 572                 if !isPrintable(key) {
 573                         return
 574                 }
 575                 if len(t.line) == maxLineLength {
 576                         return
 577                 }
 578                 t.addKeyToLine(key)
 579         }
 580         return
 581 }
 582
 583 // addKeyToLine inserts the given key at the current position in the current
 584 // line.
 585 func (t *Terminal) addKeyToLine(key rune) {
 586         if len(t.line) == cap(t.line) {
 587                 newLine := make([]rune, len(t.line), 2*(1+len(t.line)))
 588                 copy(newLine, t.line)
 589                 t.line = newLine
 590         }
 591         t.line = t.line[:len(t.line)+1]
 592         copy(t.line[t.pos+1:], t.line[t.pos:])
 593         t.line[t.pos] = key
 594         if t.echo {
 595                 t.writeLine(t.line[t.pos:])
 596         }
 597         t.pos++
 598         t.moveCursorToPos(t.pos)
 599 }
 600
 601 func (t *Terminal) writeLine(line []rune) {
 602         for len(line) != 0 {
 603                 remainingOnLine := t.termWidth - t.cursorX
 604                 todo := len(line)
 605                 if todo > remainingOnLine {
 606                         todo = remainingOnLine
 607                 }
 608                 t.queue(line[:todo])
 609                 t.advanceCursor(visualLength(line[:todo]))
 610                 line = line[todo:]
 611         }
 612 }
 613
 614 // writeWithCRLF writes buf to w but replaces all occurrences of \n with \r\n.
 615 func writeWithCRLF(w io.Writer, buf []byte) (n int, err error) {
 616         for len(buf) > 0 {
 617                 i := bytes.IndexByte(buf, '\n')
 618                 todo := len(buf)
 619                 if i >= 0 {
 620                         todo = i
 621                 }
 622
 623                 var nn int
 624                 nn, err = w.Write(buf[:todo])
 625                 n += nn
 626                 if err != nil {
 627                         return n, err
 628                 }
 629                 buf = buf[todo:]
 630
 631                 if i >= 0 {
 632                         if _, err = w.Write(crlf); err != nil {
 633                                 return n, err
 634                         }
 635                         n++
 636                         buf = buf[1:]
 637                 }
 638         }
 639
 640         return n, nil
 641 }
 642
 643 func (t *Terminal) Write(buf []byte) (n int, err error) {
 644         t.lock.Lock()
 645         defer t.lock.Unlock()
 646
 647         if t.cursorX == 0 && t.cursorY == 0 {
 648                 // This is the easy case: there's nothing on the screen that we
 649                 // have to move out of the way.
 650                 return writeWithCRLF(t.c, buf)
 651         }
 652
 653         // We have a prompt and possibly user input on the screen. We
 654         // have to clear it first.
 655         t.move(0 /* up */, 0 /* down */, t.cursorX /* left */, 0 /* right */)
 656         t.cursorX = 0
 657         t.clearLineToRight()
 658
 659         for t.cursorY > 0 {
 660                 t.move(1 /* up */, 0, 0, 0)
 661                 t.cursorY--
 662                 t.clearLineToRight()
 663         }
 664
 665         if _, err = t.c.Write(t.outBuf); err != nil {
 666                 return
 667         }
 668         t.outBuf = t.outBuf[:0]
 669
 670         if n, err = writeWithCRLF(t.c, buf); err != nil {
 671                 return
 672         }
 673
 674         t.writeLine(t.prompt)
 675         if t.echo {
 676                 t.writeLine(t.line)
 677         }
 678
 679         t.moveCursorToPos(t.pos)
 680
 681         if _, err = t.c.Write(t.outBuf); err != nil {
 682                 return
 683         }
 684         t.outBuf = t.outBuf[:0]
 685         return
 686 }
 687
 688 // ReadPassword temporarily changes the prompt and reads a password, without
 689 // echo, from the terminal.
 690 func (t *Terminal) ReadPassword(prompt string) (line string, err error) {
 691         t.lock.Lock()
 692         defer t.lock.Unlock()
 693
 694         oldPrompt := t.prompt
 695         t.prompt = []rune(prompt)
 696         t.echo = false
 697
 698         line, err = t.readLine()
 699
 700         t.prompt = oldPrompt
 701         t.echo = true
 702
 703         return
 704 }
 705
 706 // ReadLine returns a line of input from the terminal.
 707 func (t *Terminal) ReadLine() (line string, err error) {
 708         t.lock.Lock()
 709         defer t.lock.Unlock()
 710
 711         return t.readLine()
 712 }
 713
 714 func (t *Terminal) readLine() (line string, err error) {
 715         // t.lock must be held at this point
 716
 717         if t.cursorX == 0 && t.cursorY == 0 {
 718                 t.writeLine(t.prompt)
 719                 t.c.Write(t.outBuf)
 720                 t.outBuf = t.outBuf[:0]
 721         }
 722
 723         lineIsPasted := t.pasteActive
 724
 725         for {
 726                 rest := t.remainder
 727                 lineOk := false
 728                 for !lineOk {
 729                         var key rune
 730                         key, rest = bytesToKey(rest, t.pasteActive)
 731                         if key == utf8.RuneError {
 732                                 break
 733                         }
 734                         if !t.pasteActive {
 735                                 if key == keyCtrlD {
 736                                         if len(t.line) == 0 {
 737                                                 return "", io.EOF
 738                                         }
 739                                 }
 740                                 if key == keyPasteStart {
 741                                         t.pasteActive = true
 742                                         if len(t.line) == 0 {
 743                                                 lineIsPasted = true
 744                                         }
 745                                         continue
 746                                 }
 747                         } else if key == keyPasteEnd {
 748                                 t.pasteActive = false
 749                                 continue
 750                         }
 751                         if !t.pasteActive {
 752                                 lineIsPasted = false
 753                         }
 754                         line, lineOk = t.handleKey(key)
 755                 }
 756                 if len(rest) > 0 {
 757                         n := copy(t.inBuf[:], rest)
 758                         t.remainder = t.inBuf[:n]
 759                 } else {
 760                         t.remainder = nil
 761                 }
 762                 t.c.Write(t.outBuf)
 763                 t.outBuf = t.outBuf[:0]
 764                 if lineOk {
 765                         if t.echo {
 766                                 t.historyIndex = -1
 767                                 t.history.Add(line)
 768                         }
 769                         if lineIsPasted {
 770                                 err = ErrPasteIndicator
 771                         }
 772                         return
 773                 }
 774
 775                 // t.remainder is a slice at the beginning of t.inBuf
 776                 // containing a partial key sequence
 777                 readBuf := t.inBuf[len(t.remainder):]
 778                 var n int
 779
 780                 t.lock.Unlock()
 781                 n, err = t.c.Read(readBuf)
 782                 t.lock.Lock()
 783
 784                 if err != nil {
 785                         return
 786                 }
 787
 788                 t.remainder = t.inBuf[:n+len(t.remainder)]
 789         }
 790 }
 791
 792 // SetPrompt sets the prompt to be used when reading subsequent lines.
 793 func (t *Terminal) SetPrompt(prompt string) {
 794         t.lock.Lock()
 795         defer t.lock.Unlock()
 796
 797         t.prompt = []rune(prompt)
 798 }
 799
 800 func (t *Terminal) clearAndRepaintLinePlusNPrevious(numPrevLines int) {
 801         // Move cursor to column zero at the start of the line.
 802         t.move(t.cursorY, 0, t.cursorX, 0)
 803         t.cursorX, t.cursorY = 0, 0
 804         t.clearLineToRight()
 805         for t.cursorY < numPrevLines {
 806                 // Move down a line
 807                 t.move(0, 1, 0, 0)
 808                 t.cursorY++
 809                 t.clearLineToRight()
 810         }
 811         // Move back to beginning.
 812         t.move(t.cursorY, 0, 0, 0)
 813         t.cursorX, t.cursorY = 0, 0
 814
 815         t.queue(t.prompt)
 816         t.advanceCursor(visualLength(t.prompt))
 817         t.writeLine(t.line)
 818         t.moveCursorToPos(t.pos)
 819 }
 820
 821 func (t *Terminal) SetSize(width, height int) error {
 822         t.lock.Lock()
 823         defer t.lock.Unlock()
 824
 825         if width == 0 {
 826                 width = 1
 827         }
 828
 829         oldWidth := t.termWidth
 830         t.termWidth, t.termHeight = width, height
 831
 832         switch {
 833         case width == oldWidth:
 834                 // If the width didn't change then nothing else needs to be
 835                 // done.
 836                 return nil
 837         case len(t.line) == 0 && t.cursorX == 0 && t.cursorY == 0:
 838                 // If there is nothing on current line and no prompt printed,
 839                 // just do nothing
 840                 return nil
 841         case width < oldWidth:
 842                 // Some terminals (e.g. xterm) will truncate lines that were
 843                 // too long when shinking. Others, (e.g. gnome-terminal) will
 844                 // attempt to wrap them. For the former, repainting t.maxLine
 845                 // works great, but that behaviour goes badly wrong in the case
 846                 // of the latter because they have doubled every full line.
 847
 848                 // We assume that we are working on a terminal that wraps lines
 849                 // and adjust the cursor position based on every previous line
 850                 // wrapping and turning into two. This causes the prompt on
 851                 // xterms to move upwards, which isn't great, but it avoids a
 852                 // huge mess with gnome-terminal.
 853                 if t.cursorX >= t.termWidth {
 854                         t.cursorX = t.termWidth - 1
 855                 }
 856                 t.cursorY *= 2
 857                 t.clearAndRepaintLinePlusNPrevious(t.maxLine * 2)
 858         case width > oldWidth:
 859                 // If the terminal expands then our position calculations will
 860                 // be wrong in the future because we think the cursor is
 861                 // |t.pos| chars into the string, but there will be a gap at
 862                 // the end of any wrapped line.
 863                 //
 864                 // But the position will actually be correct until we move, so
 865                 // we can move back to the beginning and repaint everything.
 866                 t.clearAndRepaintLinePlusNPrevious(t.maxLine)
 867         }
 868
 869         _, err := t.c.Write(t.outBuf)
 870         t.outBuf = t.outBuf[:0]
 871         return err
 872 }
 873
 874 type pasteIndicatorError struct{}
 875
 876 func (pasteIndicatorError) Error() string {
 877         return "terminal: ErrPasteIndicator not correctly handled"
 878 }
 879
 880 // ErrPasteIndicator may be returned from ReadLine as the error, in addition
 881 // to valid line data. It indicates that bracketed paste mode is enabled and
 882 // that the returned line consists only of pasted data. Programs may wish to
 883 // interpret pasted data more literally than typed data.
 884 var ErrPasteIndicator = pasteIndicatorError{}
 885
 886 // SetBracketedPasteMode requests that the terminal bracket paste operations
 887 // with markers. Not all terminals support this but, if it is supported, then
 888 // enabling this mode will stop any autocomplete callback from running due to
 889 // pastes. Additionally, any lines that are completely pasted will be returned
 890 // from ReadLine with the error set to ErrPasteIndicator.
 891 func (t *Terminal) SetBracketedPasteMode(on bool) {
 892         if on {
 893                 io.WriteString(t.c, "\x1b[?2004h")
 894         } else {
 895                 io.WriteString(t.c, "\x1b[?2004l")
 896         }
 897 }
 898
 899 // stRingBuffer is a ring buffer of strings.
 900 type stRingBuffer struct {
 901         // entries contains max elements.
 902         entries []string
 903         max     int
 904         // head contains the index of the element most recently added to the ring.
 905         head int
 906         // size contains the number of elements in the ring.
 907         size int
 908 }
 909
 910 func (s *stRingBuffer) Add(a string) {
 911         if s.entries == nil {
 912                 const defaultNumEntries = 100
 913                 s.entries = make([]string, defaultNumEntries)
 914                 s.max = defaultNumEntries
 915         }
 916
 917         s.head = (s.head + 1) % s.max
 918         s.entries[s.head] = a
 919         if s.size < s.max {
 920                 s.size++
 921         }
 922 }
 923
 924 // NthPreviousEntry returns the value passed to the nth previous call to Add.
 925 // If n is zero then the immediately prior value is returned, if one, then the
 926 // next most recent, and so on. If such an element doesn't exist then ok is
 927 // false.
 928 func (s *stRingBuffer) NthPreviousEntry(n int) (value string, ok bool) {
 929         if n >= s.size {
 930                 return "", false
 931         }
 932         index := s.head - n
 933         if index < 0 {
 934                 index += s.max
 935         }
 936         return s.entries[index], true
 937 }
 938
 939 // readPasswordLine reads from reader until it finds \n or io.EOF.
 940 // The slice returned does not include the \n.
 941 // readPasswordLine also ignores any \r it finds.
 942 func readPasswordLine(reader io.Reader) ([]byte, error) {
 943         var buf [1]byte
 944         var ret []byte
 945
 946         for {
 947                 n, err := reader.Read(buf[:])
 948                 if n > 0 {
 949                         switch buf[0] {
 950                         case '\n':
 951                                 return ret, nil
 952                         case '\r':
 953                                 // remove \r from passwords on Windows
 954                         default:
 955                                 ret = append(ret, buf[0])
 956                         }
 957                         continue
 958                 }
 959                 if err != nil {
 960                         if err == io.EOF && len(ret) > 0 {
 961                                 return ret, nil
 962                         }
 963                         return ret, err
 964                 }
 965         }
 966 }