Updated release image date.

[cslatevm.git] / src / lib / terminal.slate

prototypes ensureNamespace: #terminals &delegate: True.

terminals define: #Backend &parents: {PrettyPrinterMixin. Stream WrapperStream}.
"The device object/handle used for the terminal."

_@(Backend traits) defaultColumns [80].
_@(Backend traits) defaultRows [24].

_@(Backend traits) display: lineString cursorAt: index
"The basic method for line-oriented display and interaction."
[overrideThis].

b@(Backend traits) events
"Return a stream of events"
[overrideThis].

terminals define: #Terminal &parents: {Backend}
  &slots: {#console "The underlying console object"}.
"The abstract terminal type."
Terminal addLazySlot: #commandEditor initializer: [| :t | t LineEditor newOn: t]. "A line editor instance on demand"

Terminal traits define: #KeyboardInterrupt &parents: {Condition}
 &slots: {#terminal}.

c@(Terminal KeyboardInterrupt traits) newFor: t
[
  c new `>> [terminal := t. ]
].

t@(Terminal traits) interrupted
[(t KeyboardInterrupt newFor: t) signal].

_@(Terminal traits) newBasedOn: console@(ExternalResource traits)
[
  (DumbTerminal newOn: console interactor) `>> [
    console := console.
  ]
].

_@(Terminal traits) newBasedOn: console@(SmartConsole traits)
[
  (SmartTerminal newOn: console interactor) `>> [
    console := console.
  ]
].

t@(Terminal traits) events [t console events].

t@(Terminal traits) sessionDo: block
[
  t resource sessionDo: [| :r | block applyWith: t]
].

t@(Terminal traits) isSmart
"Answer whether all of certain cursor movement signals are defined."
[False].

t@(Terminal traits) echoes
[True].

t@(Terminal traits) columnLast
[t columns - 1].

t@(Terminal traits) columns
[t defaultColumns].

t@(Terminal traits) rowLast
[t rows - 1].

t@(Terminal traits) rows
[t defaultRows].

t@(Terminal traits) flush
[t console flush].

t@(Terminal traits) beep
"Send the beep/BEL character."
[
  "TODO: on cygwin it doesn't work in raw mode, only prints ^G"
  "Terminal traits define: #bell -> ({$\a code} as: ByteArray).
  t console write: 1 from: t bell."
  t flush.
].

t@(Terminal traits) page
"Display a simple header and page-down; exit if Q is pressed."
[
  t writer ; '--More--'.
  t flush.
  chord ::= t nextChord.
  t newLine.
  (chord = $q \/ [chord = $Q]) not
].

t@(Terminal traits) newLine
"Terminate the current line."
[t nextPut: $\n].

t@(Terminal traits) newColumn
[t nextPut: $\s].

terminals define: #DumbTerminal &parents: {Terminal}.
"The simple terminal type, not even VT100."

t@(DumbTerminal traits) display: line cursorAt: index
[
  "That's all we can do..."
].

terminals define: #SmartTerminal &parents: {Terminal}
  &slots: {#basePosition -> Tuple new*, 0, 0 "The screen coordinate where line editing started"}.
"The terminal type that understands control- and escape-sequences for redraws, etc."

t@(SmartTerminal traits) isSmart
"Answer whether all of certain cursor movement signals are defined."
[True].

t@(SmartTerminal traits) echoes
[False].

t@(SmartTerminal traits) newLine
[
  (console ::= t console) isCursorAtLastRow ifTrue:
    [console scroll].
  console moveCursorToBONL.
  t
].

t@(SmartTerminal traits) columns
[t console columns].

t@(SmartTerminal traits) rows
[t console rows].

t@(SmartTerminal traits) display: cmd cursorAt: cursorPos &incremental
[
  console ::= t console.
  (incremental `defaultsTo: False) ifFalse:
    [console moveCursorTo: t basePosition.
     "TODO more then a page long lines (baseline < 0)"
     t nextPutAll: cmd].
  "Ideally basePosition update should be done with scroll callbacks. It does not handle
  newlines in the command this way, and the console already keeps track of its state."
  (scroll ::= t basePosition second
     + ((t basePosition first + cmd size) // console width)
     - console rowLast) isPositive ifTrue:
       [t basePosition at: 1 put: t basePosition second - scroll].
  incremental ifFalse:
    [console clearToEOS].
  t moveCursorTo: cursorPos inCommand: cmd.
].

"TODO take control chars like \n's in cmd into account? generalize into SmartConsole"
t@(SmartTerminal traits) moveCursorTo: pos inCommand: cmd
[
  cols ::= t columns.
  pos += t basePosition first.
  t console moveCursorTo: (Tuple new*, (pos rem: cols), t basePosition second + (pos // cols)).
].

terminals define: #ConsoleLineEditor &parents: {Cloneable} &slots: {
  #terminal.
  #position -> 0. "Cursor position"
  #currentHistoryIndex -> 0.
  #killRing -> LinkedList new.
  #insertMode -> True.
  #mark.
  #currentYank.
  #lastYank.
  #prompt -> Nil.
  #currentWord -> Nil.
  #currentCompletions -> {}.
  #history -> ({ExtensibleArray new} as: ExtensibleArray new)
}.
"A line editor, used to manage some terminal interactions, and having editing
state and behavior."
ConsoleLineEditor addLazySlot: #reader initializer: [| :e | e ReadStream newOn: e].
ConsoleLineEditor traits keymap ::= Dictionary new.
ConsoleLineEditor traits controlKeymap ::= Dictionary new.
ConsoleLineEditor traits modifierKeymap ::= Dictionary new.
ConsoleLineEditor traits maxHistorySize ::= 50.

e@(ConsoleLineEditor traits) newOn: terminal
[
  e clone `>>
    [history := ExtensibleArray new*, (ExtensibleArray new).
     on: terminal. ]
].

e@(ConsoleLineEditor traits) on: terminal
[
  e terminal: terminal.
  e
].

e@(ConsoleLineEditor traits) lineString
[
  e history at: e currentHistoryIndex
].

e@(ConsoleLineEditor traits) lineString: line
[
  e history at: e currentHistoryIndex put: line
].

e@(ConsoleLineEditor traits) prepareToEditLine
"Take the current history item, duplicate it, and addFirst:
to edit a copy rather then the item in the history."
[| current |
  e currentHistoryIndex isPositive ifTrue:
    [current := e history at: e currentHistoryIndex.
     e history first isEmpty ifTrue:
       [e history removeFirst].
     e history addFirst: (ExtensibleArray newWithAll: current).
    [e history size > e maxHistorySize] whileTrue:
      [e history removeLast].
    e currentHistoryIndex := 0].
].

e@(ConsoleLineEditor traits) markCursorAsBasePosition
[
  e terminal basePosition := e terminal console cursorPosition
].

e@(ConsoleLineEditor traits) readLine &echoNewLine &showPrompt: prompt
[
  prompt `defaultsTo: True.
  e history first isEmpty ifFalse:
    [e history at: 0 infect: #(as: String) `er.
     e history addFirst: ExtensibleArray new.
     [e history size > e maxHistorySize]
       whileTrue: [e history removeLast]].
  e currentHistoryIndex := 0.
  e position := 0.
  prompt /\ [e prompt isNotNil] ifTrue: [e terminal ; e prompt].
  e markCursorAsBasePosition.
  e redrawLine.
  e continue &echoNewLine
].

e@(ConsoleLineEditor traits) moveCursorTo: pos
[
  e position := pos.
  e updateCursor.
].

e@(ConsoleLineEditor traits) hasInput
"Answer if the editor has events waiting to be processed"
[
  e terminal events hasNext
].

e@(ConsoleLineEditor traits) continue &echoNewLine
[
  echoNewLine `defaultsTo: False.
  (terminal ::= e terminal) events do:
    [| :event |
     [(event is: SmartConsole KeyDownEvent) ifTrue:
        [event keyName = #Enter ifTrue:
           [echoNewLine ifTrue: [terminal newLine].
            ^ (e lineString as: terminal collectionType)]].
      (e processEvent: event) ifTrue: [e redrawLine].
      terminal flush]
       on: Terminal KeyboardInterrupt do: [| :_ | e clear]].
].

e@(ConsoleLineEditor traits) clear
[
  e lineString clear.
  e position := 0.
  e redrawLine.
].

e@(ConsoleLineEditor traits) processEvent: event@(SmartConsole ResizeEvent traits)
[
  True "Simply force a redraw"
].

e@(ConsoleLineEditor traits) processEvent: event
"Process the event and return True if redraw is needed"
[| skipRedraw value |
  skipRedraw := False.

  "Choose value between keyName and char"
  event keyName
    ifNil: [event char ifNotNil: [value := event char]]
    ifNotNil: [value := event keyName].

  "Select keymap based on modifier keys"
  keymap ::= event controlState
    ifTrue: [e controlKeymap]
    ifFalse:
      [event altState
         ifTrue: [e modifierKeymap]
         ifFalse: [e keymap]].

  "Look for a mapping and execute handler if found"
  keymap at: value
    ifPresent: [| :handler |
      handler edits ifTrue: [e prepareToEditLine].
      skipRedraw := e handle: handler]
    ifAbsent:
      [event char ifNotNil:
         [e prepareToEditLine.
          skipRedraw := e handle: (e AddCharacter newFor: event char)]].

  skipRedraw isNil \/ [skipRedraw not]
].

e@(ConsoleLineEditor traits) redrawLine &incremental
"Re-run the display sequence for the current line."
[
  e terminal display: e lineString cursorAt: e position &incremental: incremental
].

e@(ConsoleLineEditor traits) updateCursor
[
  e terminal moveCursorTo: e position inCommand: e lineString
].

e@(ConsoleLineEditor traits) toggleInsert
"Toggle insert mode."
[
  e insertMode := e insertMode not
].

e@(ConsoleLineEditor traits) wordStart &dynamic
"Answer the position of the start of the nearest word (right under the cursor).
Dynamic means that if the cursor is already on the start of a word then it leaves that
word and goes one word back."
[| pos |
  line ::= e lineString.
  pos := e position.
  dynamic `defaultsTo: False.

  pos > line indexLast
    ifTrue: [pos := line indexLast]
    ifFalse: [dynamic ifTrue: [pos -= 1. pos isNegative ifTrue: [^ 0]]].
  [pos isPositive /\
    [(line at: pos) isDelimiter]]
      whileTrue: [pos -= 1].
  [pos >= 0 /\
    [(line at: pos) isDelimiter not]]
      whileTrue: [pos -= 1].
  (line includesKey: pos + 1)
    ifTrue: [pos + 1]
    ifFalse: [pos]
].

e@(ConsoleLineEditor traits) wordEnd &dynamic
"Answer the position of the end of the nearest word (right under the cursor).
Dynamic means that if the cursor is already on the end of a word then it leaves that
word and goes one word forward."
[| pos |
  line ::= e lineString.
  size ::= line size.
  pos := e position.
  dynamic `defaultsTo: False.

  pos > line indexLast
    ifTrue: [pos := line indexLast]
    ifFalse: [dynamic ifTrue: [pos += 1. pos >= size ifTrue: [^ size]]].
  (line at: pos) isDelimiter ifTrue: [^ pos].
  [pos < line indexLast /\
    [(line at: pos) isDelimiter]]
      whileTrue: [pos += 1].
  [pos < size /\
    [(line at: pos) isDelimiter not]]
      whileTrue: [pos += 1].
  pos
].

e@(ConsoleLineEditor traits) word
"Answer the word under the cursor, relying on wordStart and wordEnd."
[
  e lineString copyFrom: e wordStart to: e wordEnd - 1
].

e@(ConsoleLineEditor traits) completionsFor: word
"Answer the completions for the given word."
[overrideThis].

e@(ConsoleLineEditor traits) flushCompletions
[e currentCompletions: e currentCompletions new].

e@(ConsoleLineEditor traits) complete: word
"Answer a collection of the valid completions for a given word; this should
allow for varying strategies per context."
[
  word = e currentWord
    ifTrue: [e currentCompletions isEmpty
              ifTrue: [e currentCompletions := e completionsFor: word]]
    ifFalse: [e currentWord := word.
              e currentCompletions := e completionsFor: word].
  e currentCompletions
].

e@(ConsoleLineEditor traits) complete
"Answer a collection of valid completions for the word under the cursor."
[
  e complete: e word
].

e@(ConsoleLineEditor traits) rememberYank
[
  e currentYank := e position
].

e@(ConsoleLineEditor traits) forgetYank
[
  e lastYank := e yank.
  e currentYank := Nil
].

e@(ConsoleLineEditor traits) tryYank
[
  e currentYank := e lastYank
].

e@(ConsoleLineEditor traits) yank
[
  e rememberYank.
  e killRing next
    ifNil: [e terminal beep. e position]
    ifNotNilDo:
      [| :kill |
       e lineString := (e lineString copyFrom: 0 to: e currentYank)
         ; kill ; (e lineString copyFrom: e position).
       e position := e currentYank + kill size]
].

e@(ConsoleLineEditor traits) replaceWordWith: word
"Replace the word under the cursor with the given word.
Move cursor to end of the new word."
[
  (start ::= e wordStart) <= (end ::= e wordEnd)
    ifTrue: [e lineString at: start remove: end - start].
  e lineString at: start insertAll: word.
  e position := start.
  e position := e wordEnd.
].

e@(ConsoleLineEditor traits) isCursorInQuotedString
"A simple test to see if the cursor is between quotes."
[
  (start ::= e wordStart) isNotNil
    /\ [start isPositive]
    /\ [(e lineString at: start - 1) isQuote]
].

"Commands"
"TODO: refactor to re-use the UI Command abstraction?"

ConsoleLineEditor define: #Command &parents: {Cloneable}
  &slots: {#edits -> False}.

e@(ConsoleLineEditor traits) handle: _@(ConsoleLineEditor Command traits)
[overrideThis].

e@(ConsoleLineEditor traits) addCommand: name
"Defines and returns a new attribute-named command object, with no slots.
If one already exists, this re-uses it and ensures the slot properties."
[
  command ::= (e traits hasSlotNamed: name)
   ifTrue: [e traits atSlotNamed: name]
   ifFalse: [e Command clone].
  e traits addImmutableSlot: name valued: command.
  command
].

e@(ConsoleLineEditor traits) addEditingCommand: name
[
  (e addCommand: name) `>> [edits := True. ]
].

ConsoleLineEditor define: #AddCharacter &parents: {ConsoleLineEditor Command} &slots: {
  #char -> $\0.
  #edits -> True
}.

c@(ConsoleLineEditor AddCharacter traits) newFor: char
[c clone `setting: #{#char} to: {char}].

e@(ConsoleLineEditor traits) handle: c@(ConsoleLineEditor AddCharacter traits)
[
  e insertMode 
    ifTrue: [e lineString at: e position insert: c char]
    ifFalse: [
      e position = e lineString size
        ifTrue: [e lineString addLast: c char]
        ifFalse: [e lineString at: e position put: c char]].
  (e position += 1) = e lineString size /\ [e terminal console autoScrollsAtBottom]
    ifTrue: [e terminal nextPut: c char.
             e redrawLine &incremental: True. ^ True].
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #DeleteCharBackwards)
[
  e position isZero ifTrue: [^ True].
  e position := e position - 1.
  e lineString removeAt: e position.
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #DeleteCharForwards)
[
  e position >= e lineString size ifTrue: [^ True].
  e lineString removeAt: e position.
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #EOF)
[
  e lineString isEmpty
    ifTrue: [e reader exhausted]
    ifFalse: [e terminal beep].
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #KeyboardInterrupt)
[
  e terminal interrupted.
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #DeleteWordBackwards)
[| start |
  (start := e wordStart) > 0 ifTrue:
    [start -= 1].
  e lineString at: start remove: e position - start.
  e position := start.
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #DeleteWordForwards)
[| end |
  (end := e wordEnd) < e lineString size ifTrue:
    [end += 1].
  e lineString at: e position remove: end - e position.
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #UpcaseWord)
[
  end ::= e wordEnd.
  (e lineString sliceFrom: e position below: end)
    infect: #toUppercase `er.
  e position := end.
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #DowncaseWord)
[
  end ::= e wordEnd.
  (e lineString sliceFrom: e position below: end)
    infect: #toLowercase `er.
  e position := end.
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #CursorToBOL)
[
  e moveCursorTo: 0.
  True
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #CursorToEOL)
[
  e moveCursorTo: e lineString size.
  True
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #CursorCharForwards)
[
  e position < e lineString size ifTrue: [
    e moveCursorTo: e position + 1.
  ].
  True
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #CursorCharBackwards)
[
  e position isPositive ifTrue: [
    e moveCursorTo: e position - 1.
  ].
  True
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #CursorWordForwards)
[
  e moveCursorTo: e wordEnd.
  True
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #CursorWordBackwards)
[
  e moveCursorTo: (e wordStart &dynamic: True).
  True
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #Undo)
[e rewindState]. "FIX"

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #ToggleInsert)
[e toggleInsert].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #HistoryPrevious)
[
  e currentHistoryIndex < e history indexLast
    ifTrue: [e currentHistoryIndex := e currentHistoryIndex + 1.
      e position := e lineString size]
    ifFalse: [e terminal beep. ^ True].
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #HistoryNext)
[
  e currentHistoryIndex > 0
    ifTrue: [e currentHistoryIndex := e currentHistoryIndex - 1.
      e position := e lineString size]
    ifFalse: [e terminal beep. ^ True].
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #KillToEOL)
[
  e killRing addLast: (e lineString copyFrom: e position).
  e lineString := e lineString copyFrom: 0 to: e position.
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #KillToBOL)
[
  e killRing addLast: (e lineString copyFrom: 0 to: e position).
  e lineString := e lineString copyFrom: e position.
].

e@(ConsoleLineEditor traits) handle: _@(ConsoleLineEditor addCommand: #Yank)
[
  e tryYank
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #CopyRegion)
[
  e mark ifNotNil: [^ e position].
  start ::= e mark min: e position.
  end ::= e mark max: e position.
  e killRing addLast: (e lineString copyFrom: start to: end).
  e mark := Nil.
  e position
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #CutRegion)
[
  e mark ifNil: [^ e position].
  start ::= e mark min: e position.
  end ::= e mark max: e position.
  e killRing addLast: (e lineString copyFrom: start to: end).
  e mark := Nil.
  e lineString := (e lineString copyFrom: 0 to: start)
    ; (e lineString copyFrom: end).
  e position := start
].

e@(ConsoleLineEditor traits) handle: _@(ConsoleLineEditor addCommand: #SetMark)
[
  e mark := e position.
].

e@(ConsoleLineEditor traits) handle: _@(ConsoleLineEditor addCommand: #Help)
[
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #Complete)
[
  (completions ::= e complete) size caseOf: {
    0 -> [e terminal beep. ].
    1 -> [e replaceWordWith: completions first]
  } otherwise:
    [e printInColumns: completions.
     e terminal newLine.
     e prompt ifNotNil: [e terminal ; e prompt].
     e markCursorAsBasePosition.
     e redrawLine. ]
].

e@(ConsoleLineEditor traits) printInColumns: col
"TODO: Oly prints one column for now.
Could reuse some UI layouting algorithm"
[
  (term ::= e terminal) newLine.
  col
    do: [| :each | term ; '  ' ; each]
    separatedBy: [e terminal newLine].
].

[| :assoc | ConsoleLineEditor controlKeymap add: assoc] for: {
  $a -> ConsoleLineEditor CursorToBOL.
  $b -> ConsoleLineEditor CursorCharBackwards.
  $d -> ConsoleLineEditor EOF.
  $e -> ConsoleLineEditor CursorToEOL.
  $f -> ConsoleLineEditor CursorCharForwards.
  $k -> ConsoleLineEditor KillToEOL.
  $n -> ConsoleLineEditor HistoryNext.
  $p -> ConsoleLineEditor HistoryPrevious.
  $u -> ConsoleLineEditor CutRegion.
  $y -> ConsoleLineEditor Yank.
  $c -> ConsoleLineEditor KeyboardInterrupt.
  $- -> ConsoleLineEditor Undo.
  #Backspace -> ConsoleLineEditor DeleteWordBackwards.
  #Delete -> ConsoleLineEditor DeleteWordForwards.
  "Ctrl+Space can't be detected with ncurses (or with unix terminals in general?)"
  #Space     -> ConsoleLineEditor SetMark.
}.

[| :assoc | ConsoleLineEditor modifierKeymap add: assoc] for: {
  $b -> ConsoleLineEditor CursorWordBackwards.
  $f -> ConsoleLineEditor CursorWordForwards.
  $l -> ConsoleLineEditor DowncaseWord.
  $u -> ConsoleLineEditor UpcaseWord.
  $w -> ConsoleLineEditor CopyRegion.
}.

[| :assoc | ConsoleLineEditor keymap add: assoc] for: {
  #Tab         -> ConsoleLineEditor Complete.
  #Backspace   -> ConsoleLineEditor DeleteCharBackwards.
  "It must be special-cased because we can't easily return from a non-toplevel method"
  "#Return      -> ConsoleLineEditor FinishInput."
  #UpArrow     -> ConsoleLineEditor HistoryPrevious.
  #DownArrow   -> ConsoleLineEditor HistoryNext.
  #RightArrow  -> ConsoleLineEditor CursorCharForwards.
  #LeftArrow   -> ConsoleLineEditor CursorCharBackwards.
  #Insert      -> ConsoleLineEditor ToggleInsert.
  #Delete      -> ConsoleLineEditor DeleteCharForwards.
  #Home        -> ConsoleLineEditor CursorToBOL.
  #End         -> ConsoleLineEditor CursorToEOL
}.

ConsoleLineEditor traits define: #ReadStream &parents: {ReadStream} &slots: {
  #editor.
  #line.
  #position.
  #closed -> False
}.

s@(ConsoleLineEditor ReadStream traits) on: editor
[
  s editor := editor.
  s
].

s@(ConsoleLineEditor ReadStream traits) isAtEnd [s closed].
s@(ConsoleLineEditor ReadStream traits) elementType [s terminal elementType].
s@(ConsoleLineEditor ReadStream traits) collectionType [s terminal collectionType].

s@(ConsoleLineEditor ReadStream traits) next
[
  [s line isNil \/ [s line isEmpty]] whileTrue:
    [(s line := s editor readLine &echoNewLine: True) ifNil:
       [s closed := True.
        s exhausted.
        ^ Nil].
     s line := s line ; '\n'.
     s position := 0].
  result ::= s line at: s position.
  (s position += 1) = s line size ifTrue:
    [s line := Nil].
  result
].

"This is the default LineEditor that can be overridden by
adding a slot to terminal instances."
SmartTerminal traits LineEditor ::= ConsoleLineEditor.