package readline import ( "bytes" "fmt" "os" "regexp" ) var rxMultiline = regexp.MustCompile(`[\r\n]+`) // Readline displays the readline prompt. // It will return a string (user entered data) or an error. func (rl *Instance) Readline() (string, error) { fd := int(os.Stdin.Fd()) state, err := MakeRaw(fd) if err != nil { return "", err } defer Restore(fd, state) // In Vim mode, we always start in Input mode. The prompt needs this. rl.modeViMode = VimInsert // Prompt Init // Here we have to either print prompt // and return new line (multiline) if rl.Multiline { fmt.Println(rl.mainPrompt) } rl.stillOnRefresh = false rl.computePrompt() // initialise the prompt for first print // Line Init & Cursor rl.line = []rune{} rl.currentComp = []rune{} // No virtual completion yet rl.lineComp = []rune{} // So no virtual line either rl.modeViMode = VimInsert rl.pos = 0 rl.posY = 0 rl.tcPrefix = "" // Completion && hints init rl.resetHintText() rl.resetTabCompletion() rl.getHintText() // History Init // We need this set to the last command, so that we can access it quickly rl.histPos = 0 rl.viUndoHistory = []undoItem{{line: "", pos: 0}} // Multisplit if len(rl.multisplit) > 0 { r := []rune(rl.multisplit[0]) rl.editorInput(r) rl.carridgeReturn() if len(rl.multisplit) > 1 { rl.multisplit = rl.multisplit[1:] } else { rl.multisplit = []string{} } return string(rl.line), nil } // Finally, print any hints or completions // if the TabCompletion engines so desires rl.renderHelpers() // Start handling keystrokes. Classified by subject for most. for { rl.viUndoSkipAppend = false b := make([]byte, 1024) var i int if !rl.skipStdinRead { var err error i, err = os.Stdin.Read(b) if err != nil { return "", err } } rl.skipStdinRead = false r := []rune(string(b)) if isMultiline(r[:i]) || len(rl.multiline) > 0 { rl.multiline = append(rl.multiline, b[:i]...) if i == len(b) { continue } if !rl.allowMultiline(rl.multiline) { rl.multiline = []byte{} continue } s := string(rl.multiline) rl.multisplit = rxMultiline.Split(s, -1) r = []rune(rl.multisplit[0]) rl.modeViMode = VimInsert rl.editorInput(r) rl.carridgeReturn() rl.multiline = []byte{} if len(rl.multisplit) > 1 { rl.multisplit = rl.multisplit[1:] } else { rl.multisplit = []string{} } return string(rl.line), nil } s := string(r[:i]) if rl.evtKeyPress[s] != nil { rl.clearHelpers() ret := rl.evtKeyPress[s](s, rl.line, rl.pos) rl.clearLine() rl.line = append(ret.NewLine, []rune{}...) rl.updateHelpers() // rl.echo rl.pos = ret.NewPos if ret.ClearHelpers { rl.resetHelpers() } else { rl.updateHelpers() } if len(ret.HintText) > 0 { rl.hintText = ret.HintText rl.clearHelpers() rl.renderHelpers() } if !ret.ForwardKey { continue } if ret.CloseReadline { rl.clearHelpers() return string(rl.line), nil } } // Before anything: we can never be both in modeTabCompletion and compConfirmWait, // because we need to confirm before entering completion. If both are true, there // is a problem (at least, the user has escaped the confirm hint some way). if (rl.modeTabCompletion && rl.searchMode != HistoryFind) && rl.compConfirmWait { rl.compConfirmWait = false } switch b[0] { // Errors & Returns -------------------------------------------------------------------------------- case charCtrlC: if rl.modeTabCompletion { rl.resetVirtualComp(true) rl.resetHelpers() rl.renderHelpers() continue } rl.clearHelpers() return "", CtrlC case charEOF: rl.clearHelpers() return "", EOF // Clear screen case charCtrlL: print(seqClearScreen) print(seqCursorTopLeft) if rl.Multiline { fmt.Println(rl.mainPrompt) } print(seqClearScreenBelow) rl.resetHintText() rl.getHintText() rl.renderHelpers() // Line Editing ------------------------------------------------------------------------------------ case charCtrlU: if rl.modeTabCompletion { rl.resetVirtualComp(true) } // Delete everything from the beginning of the line to the cursor position rl.saveBufToRegister(rl.line[:rl.pos]) rl.deleteToBeginning() rl.resetHelpers() rl.updateHelpers() case charBackspace, charBackspace2: // When currently in history completion, we refresh and automatically // insert the first (filtered) candidate, virtually if rl.modeAutoFind && rl.searchMode == HistoryFind { rl.resetVirtualComp(true) rl.backspaceTabFind() // Then update the printing, with the new candidate rl.updateVirtualComp() rl.renderHelpers() rl.viUndoSkipAppend = true continue } // Normal completion search does only refresh the search pattern and the comps if rl.modeTabFind || rl.modeAutoFind { rl.backspaceTabFind() rl.viUndoSkipAppend = true } else { // Always cancel any virtual completion rl.resetVirtualComp(false) // Vim mode has different behaviors if rl.InputMode == Vim { if rl.modeViMode == VimInsert { rl.backspace() } else if rl.pos != 0 { rl.pos-- } rl.renderHelpers() continue } // Else emacs deletes a character rl.backspace() rl.renderHelpers() } // Emacs Bindings ---------------------------------------------------------------------------------- case charCtrlW: if rl.modeTabCompletion { rl.resetVirtualComp(false) } // This is only available in Insert mode if rl.modeViMode != VimInsert { continue } rl.saveToRegister(rl.viJumpB(tokeniseLine)) rl.viDeleteByAdjust(rl.viJumpB(tokeniseLine)) rl.updateHelpers() case charCtrlY: if rl.modeTabCompletion { rl.resetVirtualComp(false) } // paste after the cursor position rl.viUndoSkipAppend = true buffer := rl.pasteFromRegister() rl.insert(buffer) rl.updateHelpers() case charCtrlE: if rl.modeTabCompletion { rl.resetVirtualComp(false) } // This is only available in Insert mode if rl.modeViMode != VimInsert { continue } if len(rl.line) > 0 { rl.pos = len(rl.line) } rl.viUndoSkipAppend = true rl.updateHelpers() case charCtrlA: if rl.modeTabCompletion { rl.resetVirtualComp(false) } // This is only available in Insert mode if rl.modeViMode != VimInsert { continue } rl.viUndoSkipAppend = true rl.pos = 0 rl.updateHelpers() // Command History --------------------------------------------------------------------------------- // NOTE: The alternative history source is triggered by Alt+r, // but because this is a sequence, the alternative history code // trigger is in the below rl.escapeSeq(r) function. case charCtrlR: rl.resetVirtualComp(false) // For some modes only, if we are in vim Keys mode, // we toogle back to insert mode. For others, we return // without getting the completions. if rl.modeViMode != VimInsert { rl.modeViMode = VimInsert rl.computePrompt() } rl.mainHist = true // false before rl.searchMode = HistoryFind rl.modeAutoFind = true rl.modeTabCompletion = true rl.modeTabFind = true rl.updateTabFind([]rune{}) rl.viUndoSkipAppend = true // Tab Completion & Completion Search --------------------------------------------------------------- case charTab: // The user cannot show completions if currently in Vim Normal mode if rl.InputMode == Vim && rl.modeViMode != VimInsert { continue } // If we have asked for completions, already printed, and we want to move selection. if rl.modeTabCompletion && !rl.compConfirmWait { rl.tabCompletionSelect = true rl.moveTabCompletionHighlight(1, 0) rl.updateVirtualComp() rl.renderHelpers() rl.viUndoSkipAppend = true } else { // Else we might be asked to confirm printing (if too many suggestions), or not. rl.getTabCompletion() // If too many completions and no yet confirmed, ask user for completion // comps, lines := rl.getCompletionCount() // if ((lines > GetTermLength()) || (lines > rl.MaxTabCompleterRows)) && !rl.compConfirmWait { // sentence := fmt.Sprintf("%s show all %d completions (%d lines) ? tab to confirm", // FOREWHITE, comps, lines) // rl.promptCompletionConfirm(sentence) // continue // } rl.compConfirmWait = false rl.modeTabCompletion = true // Also here, if only one candidate is available, automatically // insert it and don't bother printing completions. // Quit the tab completion mode to avoid asking to the user // to press Enter twice to actually run the command. if rl.hasOneCandidate() { rl.insertCandidate() // Refresh first, and then quit the completion mode rl.updateHelpers() // REDUNDANT WITH getTabCompletion() rl.viUndoSkipAppend = true rl.resetTabCompletion() continue } rl.updateHelpers() // REDUNDANT WITH getTabCompletion() rl.viUndoSkipAppend = true continue } case charCtrlF: rl.resetVirtualComp(true) if !rl.modeTabCompletion { rl.modeTabCompletion = true } if rl.compConfirmWait { rl.resetHelpers() } // Both these settings apply to when we already // are in completion mode and when we are not. rl.searchMode = CompletionFind rl.modeAutoFind = true // Switch from history to completion search if rl.modeTabCompletion && rl.searchMode == HistoryFind { rl.searchMode = CompletionFind } rl.updateTabFind([]rune{}) rl.viUndoSkipAppend = true case charCtrlG: if rl.modeAutoFind && rl.searchMode == HistoryFind { rl.resetVirtualComp(false) rl.resetTabFind() rl.resetHelpers() rl.renderHelpers() continue } if rl.modeAutoFind { rl.resetTabFind() rl.resetHelpers() rl.renderHelpers() } case '\r': fallthrough case '\n': if rl.modeTabCompletion { cur := rl.getCurrentGroup() // Check that there is a group indeed, as we might have no completions. if cur == nil { rl.clearHelpers() rl.resetTabCompletion() rl.renderHelpers() continue } // IF we have a prefix and completions printed, but no candidate // (in which case the completion is ""), we immediately return. completion := cur.getCurrentCell(rl) prefix := len(rl.tcPrefix) if prefix > len(completion) { rl.carridgeReturn() return string(rl.line), nil } // Else, we insert the completion candidate in the real input line. // By default we add a space, unless completion group asks otherwise. rl.compAddSpace = true rl.resetVirtualComp(false) // If we were in history completion, immediately execute the line. if rl.modeAutoFind && rl.searchMode == HistoryFind { rl.carridgeReturn() return string(rl.line), nil } // Reset completions and update input line rl.clearHelpers() rl.resetTabCompletion() rl.renderHelpers() continue } rl.carridgeReturn() return string(rl.line), nil // Vim -------------------------------------------------------------------------------------- case charEscape: // If we were waiting for completion confirm, abort if rl.compConfirmWait { rl.compConfirmWait = false rl.renderHelpers() } // We always refresh the completion candidates, except if we are currently // cycling through them, because then it would just append the candidate. if rl.modeTabCompletion { if string(r[:i]) != seqShiftTab && string(r[:i]) != seqForwards && string(r[:i]) != seqBackwards && string(r[:i]) != seqUp && string(r[:i]) != seqDown { rl.resetVirtualComp(false) } } // Once helpers of all sorts are cleared, we can process // the change of input modes, etc. rl.escapeSeq(r[:i]) // Dispatch -------------------------------------------------------------------------------------- default: // If we were waiting for completion confirm, abort if rl.compConfirmWait { rl.resetVirtualComp(false) rl.compConfirmWait = false rl.renderHelpers() } // When currently in history completion, we refresh and automatically // insert the first (filtered) candidate, virtually if rl.modeAutoFind && rl.searchMode == HistoryFind { rl.resetVirtualComp(true) rl.updateTabFind(r[:i]) rl.updateVirtualComp() rl.renderHelpers() rl.viUndoSkipAppend = true continue } // Not sure that CompletionFind is useful, nor one of the other two if rl.modeAutoFind || rl.modeTabFind { rl.resetVirtualComp(false) rl.updateTabFind(r[:i]) rl.viUndoSkipAppend = true } else { rl.resetVirtualComp(false) rl.editorInput(r[:i]) if len(rl.multiline) > 0 && rl.modeViMode == VimKeys { rl.skipStdinRead = true } } rl.clearHelpers() } rl.undoAppendHistory() } } // editorInput is an unexported function used to determine what mode of text // entry readline is currently configured for and then update the line entries // accordingly. func (rl *Instance) editorInput(r []rune) { switch rl.modeViMode { case VimKeys: rl.vi(r[0]) rl.refreshVimStatus() case VimDelete: rl.viDelete(r[0]) rl.refreshVimStatus() case VimReplaceOnce: rl.modeViMode = VimKeys rl.deleteX() rl.insert([]rune{r[0]}) rl.refreshVimStatus() case VimReplaceMany: for _, char := range r { rl.deleteX() rl.insert([]rune{char}) } rl.refreshVimStatus() default: // For some reason Ctrl+k messes with the input line, so ignore it. if r[0] == 11 { return } // We reset the history nav counter each time we come here: // We don't need it when inserting text. rl.histNavIdx = 0 rl.insert(r) } if len(rl.multisplit) == 0 { rl.syntaxCompletion() } } // viEscape - In case th user is using Vim input, and the escape sequence has not // been handled by other cases, we dispatch it to Vim and handle a few cases here. func (rl *Instance) viEscape(r []rune) { // Sometimes the escape sequence is interleaved with another one, // but key strokes might be in the wrong order, so we double check // and escape the mode only if needed. if rl.modeViMode == VimInsert && len(r) == 1 && r[0] == 27 { if len(rl.line) > 0 && rl.pos > 0 { rl.pos-- } rl.modeViMode = VimKeys rl.viIteration = "" rl.refreshVimStatus() return } } func (rl *Instance) escapeSeq(r []rune) { switch string(r) { // Vim escape sequences & dispatching -------------------------------------------------------- case string(charEscape): switch { case rl.modeAutoFind: rl.resetTabFind() rl.clearHelpers() rl.resetTabCompletion() rl.resetHelpers() rl.renderHelpers() case rl.modeTabFind: rl.resetTabFind() rl.resetTabCompletion() case rl.modeTabCompletion: rl.clearHelpers() rl.resetTabCompletion() rl.renderHelpers() default: // No matter the input mode, we exit // any completion confirm if there's one. if rl.compConfirmWait { rl.compConfirmWait = false rl.clearHelpers() rl.renderHelpers() return } // If we are in Vim mode, the escape key has its usage. // Otherwise in emacs mode the escape key does nothing. if rl.InputMode == Vim { rl.viEscape(r) return } // This refreshed and actually prints the new Vim status // if we have indeed change the Vim mode. rl.clearHelpers() rl.renderHelpers() } rl.viUndoSkipAppend = true // Tab completion movements ------------------------------------------------------------------ case seqShiftTab: if rl.modeTabCompletion && !rl.compConfirmWait { rl.tabCompletionReverse = true rl.moveTabCompletionHighlight(-1, 0) rl.updateVirtualComp() rl.tabCompletionReverse = false rl.renderHelpers() rl.viUndoSkipAppend = true return } case seqUp: if rl.modeTabCompletion { rl.tabCompletionSelect = true rl.tabCompletionReverse = true rl.moveTabCompletionHighlight(-1, 0) rl.updateVirtualComp() rl.tabCompletionReverse = false rl.renderHelpers() return } rl.mainHist = true rl.walkHistory(1) case seqDown: if rl.modeTabCompletion { rl.tabCompletionSelect = true rl.moveTabCompletionHighlight(1, 0) rl.updateVirtualComp() rl.renderHelpers() return } rl.mainHist = true rl.walkHistory(-1) case seqForwards: if rl.modeTabCompletion { rl.tabCompletionSelect = true rl.moveTabCompletionHighlight(1, 0) rl.updateVirtualComp() rl.renderHelpers() return } if (rl.modeViMode == VimInsert && rl.pos < len(rl.line)) || (rl.modeViMode != VimInsert && rl.pos < len(rl.line)-1) { moveCursorForwards(1) rl.pos++ } rl.updateHelpers() rl.viUndoSkipAppend = true case seqBackwards: if rl.modeTabCompletion { rl.tabCompletionSelect = true rl.tabCompletionReverse = true rl.moveTabCompletionHighlight(-1, 0) rl.updateVirtualComp() rl.tabCompletionReverse = false rl.renderHelpers() return } if rl.pos > 0 { moveCursorBackwards(1) rl.pos-- } rl.viUndoSkipAppend = true rl.updateHelpers() // Registers ------------------------------------------------------------------------------- case seqAltQuote: if rl.modeViMode != VimInsert { return } rl.modeTabCompletion = true rl.modeAutoFind = true rl.searchMode = RegisterFind // Else we might be asked to confirm printing (if too many suggestions), or not. rl.getTabCompletion() rl.viUndoSkipAppend = true rl.renderHelpers() // Movement ------------------------------------------------------------------------------- case seqCtrlLeftArrow: rl.moveCursorByAdjust(rl.viJumpB(tokeniseLine)) rl.updateHelpers() return case seqCtrlRightArrow: rl.moveCursorByAdjust(rl.viJumpW(tokeniseLine)) rl.updateHelpers() return case seqDelete: if rl.modeTabFind { rl.backspaceTabFind() } else { rl.deleteBackspace() } case seqHome, seqHomeSc: if rl.modeTabCompletion { return } moveCursorBackwards(rl.pos) rl.pos = 0 rl.viUndoSkipAppend = true case seqEnd, seqEndSc: if rl.modeTabCompletion { return } moveCursorForwards(len(rl.line) - rl.pos) rl.pos = len(rl.line) rl.viUndoSkipAppend = true case seqAltR: rl.resetVirtualComp(false) // For some modes only, if we are in vim Keys mode, // we toogle back to insert mode. For others, we return // without getting the completions. if rl.modeViMode != VimInsert { rl.modeViMode = VimInsert } rl.mainHist = false // true before rl.searchMode = HistoryFind rl.modeAutoFind = true rl.modeTabCompletion = true rl.modeTabFind = true rl.updateTabFind([]rune{}) rl.viUndoSkipAppend = true default: if rl.modeTabFind { return } // alt+numeric append / delete if len(r) == 2 && '1' <= r[1] && r[1] <= '9' { if rl.modeViMode == VimDelete { rl.viDelete(r[1]) return } line, err := rl.mainHistory.GetLine(rl.mainHistory.Len() - 1) if err != nil { return } if !rl.mainHist { line, err = rl.altHistory.GetLine(rl.altHistory.Len() - 1) if err != nil { return } } tokens, _, _ := tokeniseSplitSpaces([]rune(line), 0) pos := int(r[1]) - 48 // convert ASCII to integer if pos > len(tokens) { return } rl.insert([]rune(tokens[pos-1])) } else { rl.viUndoSkipAppend = true } } } func (rl *Instance) carridgeReturn() { rl.clearHelpers() print("\r\n") if rl.HistoryAutoWrite { var err error // Main history if rl.mainHistory != nil { rl.histPos, err = rl.mainHistory.Write(string(rl.line)) if err != nil { print(err.Error() + "\r\n") } } // Alternative history if rl.altHistory != nil { rl.histPos, err = rl.altHistory.Write(string(rl.line)) if err != nil { print(err.Error() + "\r\n") } } } } func isMultiline(r []rune) bool { for i := range r { if (r[i] == '\r' || r[i] == '\n') && i != len(r)-1 { return true } } return false } func (rl *Instance) allowMultiline(data []byte) bool { rl.clearHelpers() printf("\r\nWARNING: %d bytes of multiline data was dumped into the shell!", len(data)) for { print("\r\nDo you wish to proceed (yes|no|preview)? [y/n/p] ") b := make([]byte, 1024) i, err := os.Stdin.Read(b) if err != nil { return false } s := string(b[:i]) print(s) switch s { case "y", "Y": print("\r\n" + rl.mainPrompt) return true case "n", "N": print("\r\n" + rl.mainPrompt) return false case "p", "P": preview := string(bytes.Replace(data, []byte{'\r'}, []byte{'\r', '\n'}, -1)) if rl.SyntaxHighlighter != nil { preview = rl.SyntaxHighlighter([]rune(preview)) } print("\r\n" + preview) default: print("\r\nInvalid response. Please answer `y` (yes), `n` (no) or `p` (preview)") } } }