Description: This page describes yash's line-editing feature.

# Line-editing

With the line-editing feature, you can edit the command text when you input a command to an interactive shell. It not only works as a simple visual-interface editor, but also is integrated with the command history. You can recall, edit, and execute commands in the history with line-editing instead of using the fc built-in.

Line-editing has two editing modes, the vi and emacs modes, which each have their own key binding settings. By switching editing modes, you can change key bindings used in line-editing. Each mode has a corresponding shell option, which determines whether the mode is currently active or not. No more than one mode can be active at a time, so the options for the other modes are automatically turned off when you turn on the option for one mode. The whole line-editing feature is deactivated when those options are off.

When an interactive shell is started, the vi mode is automatically activated if the standard input and error are both connected to a terminal.

Line-editing can be used only when the standard input and error are both connected to a terminal. If not, the shell silently falls back to the normal input mechanism. While line-editing is being used, the shell uses the termios interface to change I/O settings of the terminal and the terminfo interface to parse input key sequences.

## Shell options on line-editing

The following options can be set by the set built-in to enable line-editing and choose an editing mode to activate:

vi

  activates the vi mode.

emacs

  activates the emacs mode.

The other line-editing-related options are:

le-always-rp

  When this options is enabled, the right prompt is always visible: when the cursor reaches the right prompt, it moves to the next line from the original position, which would otherwise be overwritten by input text.

le-comp-debug

  When enabled, internal information is printed during completion, which will help debugging completion scripts.

le-conv-meta

  When enabled, the 8th bit of each input byte is always treated as a meta-key flag, regardless of terminfo data.

le-no-conv-meta

  When enabled, the 8th bit of each input byte is never treated as a meta-key flag, regardless of terminfo data.

  The le-conv-meta and le-no-conv-meta options cannot be both enabled at a time. When either is enabled, the other is automatically disabled. When neither is enabled, the 8th bit may be treated as a meta-key flag depending on terminfo data.

le-predict

  activates command line prediction.

le-predict-empty

  When enabled, and command line prediction is active, suggestions are also provided for empty input lines.

le-prompt-sp

  When enabled, the shell prints a special character sequence before printing each prompt so that every prompt is printed at the beginning of a line.

  This option is enabled by default.

le-visible-bell

  When enabled, the shell flashes the terminal instead of sounding an alarm when an alert is required.

le-trim-right

  When enabled, the right prompt, set by YASH_PS1R will right justify all the way to the edge of the screen, the default behaviour is to leave an empty space for the cursor when the prompt is too large.

## Editing modes

The vi mode is an editing mode that offers key bindings similar to that of the vi editor. The vi mode has two sub-modes that are switched during editing: the insert and command modes. The sub-mode is always reset to the insert mode when line-editing is started for a new command line. In the insert mode, most characters are inserted to the buffer as typed. In the command mode, input characters are treated as commands that move the cursor, insert/delete text, etc.

The emacs mode offers key bindings similar to the emacs editor. Most characters are inserted to the buffer as typed, but more characters are treated as commands than the vi insert mode.

Another sub-mode is used while you enter search keywords. The sub-mode is called the search mode, which offers slightly different key bindings depending on the active editing mode.

## Line-editing commands

All characters the user enters while line-editing is active are treated as line-editing commands listed below. The bindkey built-in allows customizing the key bindings of each mode (except for the search mode).

The list below shows not only the functions of commands but also the default key bindings. The keywords “vi-insert”, “vi-command”, “vi-search”, “emacs”, “emacs-search” means the vi insert mode, the vi command mode, the search mode for the vi mode (the vi search mode), the emacs mode, and the search mode for the emacs mode (the emacs search mode), respectively.

Some commands take an argument that affects the function of the commands. For example, the forward-char command moves the cursor by as many characters as specified by the argument. To specify an argument, use the digit-argument command just before another command that takes an argument.

### Basic editing commands

noop

  Do nothing.

  vi-command

    ``\^[``

alert

  Alert.

self-insert

  Insert the input character at the current cursor position. Characters escaped by escape sequences cannot be inserted.

  vi-insert
  emacs

    ``\\``

insert-tab

  Insert a tab character at the current cursor position.

  emacs

    ``\^[``\^I``

expect-verbatim

  Insert a character that is entered just after this command at the current cursor position. This command can input a character that cannot be input by the self-insert command, except a null character (`'\0'`).

  vi-insert
  vi-search
  emacs-search

    ``\^V``

  emacs

    ``\^Q``, ``\^V``

digit-argument

  Pass the input digit to the next command as an argument.

  This command can be bound to a digit or hyphen. To pass “12” as an argument to the forward-char command in the vi mode, for example, enter `12l`.

  vi-command

    `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`

  emacs

    ``\^[`0`, ``\^[`1`, ``\^[`2`, ``\^[`3`, ``\^[`4`, ``\^[`5`, ``\^[`6`, ``\^[`7`, ``\^[`8`, ``\^[`9`, ``\^[`-`

bol-or-digit

  Like the beginning-of-line command if there is no argument; like the digit-argument command otherwise.

  vi-command

    `0`

accept-line

  Finish editing the current line. A newline is automatically appended to the line. The line will be executed by the shell.

  If command line prediction is active, the current prediction (if any) is ignored. See also the accept-prediction command.

  vi-insert
  vi-command
  emacs

    ``\^J``, ``\^M``, ``\et``

  emacs-search

    ``\^M``, ``\et``

abort-line

  Abandon the current buffer and finish editing as if an empty line was input.

  vi-insert
  vi-command
  vi-search
  emacs
  emacs-search

    ``\!``, ``\^C``

eof

  Abandon the current buffer and finish editing as if the shell reached the end of input. This normally makes the shell exit.

eof-if-empty

  Like the eof command if the buffer is empty; like the alert command otherwise.

  vi-insert
  vi-command

    ``\#``, ``\^D``

eof-or-delete

  Like the eof command if the buffer is empty; like the delete-char command otherwise.

  emacs

    ``\#``, ``\^D``

accept-with-hash

  If the current line does not begin with a hash sign (`#`) or there is no argument specified for this command, a hash sign is inserted at the beginning of the line. Otherwise, the beginning hash sign is removed from the line. Finally, the line is accepted like the accept-line command.

  vi-command

    `#`

  emacs

    ``\^[`#`

accept-prediction

  Like the accept-line command, but include the predicted part.

setmode-viinsert

  Switch to the vi insert mode.

  vi-command

    `i`, ``\I``

setmode-vicommand

  Switch to the vi command mode.

  vi-insert

    ``\^[``

setmode-emacs

  Switch to the emacs mode.

expect-char
abort-expect-char

  These commands are not meant for use by the user. They are used by the shell to implement some other commands.

redraw-all

  Reprint the prompt and the current line to the terminal. If any argument is passed, the terminal screen is cleared.

  vi-insert
  vi-command
  vi-search
  emacs
  emacs-search

    ``\^L``

clear-and-redraw-all

  Clear the terminal screen and reprint the prompt and the current line. If any argument is passed, the screen is not cleared.

### Motion commands

Motion commands move the cursor on the line. Most motion commands accept an argument. When passed an argument, they repeat the cursor motion as many times as specified by the argument. Passing “4” as an argument to the forward-char command, for example, advances the cursor by four characters.

The shell has several definitions of words as units of distance: A bigword is one or more adjacent non-whitespace characters. A semiword is one or more adjacent characters that contain no whitespaces or punctuations. An emacsword is one or more adjacent alphanumeric characters. A viword is either:

- one or more adjacent alphanumeric characters and/or underscores (`_`), or

- one or more adjacent characters that contain none of alphanumeric characters, underscores, and whitespaces.

forward-char

  Move the cursor to the next character.

  vi-insert

    ``\R``

  vi-command

    `l`, `` (a space), ``\R``

  emacs

    ``\R``, ``\^F``

backward-char

  Move the cursor to the previous character.

  vi-insert

    ``\L``

  vi-command

    `h`, ``\B``, ``\L``, ``\?``, ``\^H``,

  emacs

    ``\L``, ``\^B``

forward-bigword

  Move the cursor to the next bigword.

  vi-command

    `W`

end-of-bigword

  Move the cursor to the next end of a bigword.

  vi-command

    `E`

backward-bigword

  Move the cursor to the previous bigword.

  vi-command

    `B`

forward-semiword

  Move the cursor to the next semiword.

end-of-semiword

  Move the cursor to the next end of a semiword.

backward-semiword

  Move the cursor to the previous semiword.

forward-viword

  Move the cursor to the next viword.

  vi-command

    `w`

end-of-viword

  Move the cursor to the next end of a viword.

  vi-command

    `e`

backward-viword

  Move the cursor to the previous viword.

  vi-command

    `b`

forward-emacsword

  Move the cursor to the next emacsword.

  emacs

    ``\^[`f`, ``\^[`F`

backward-emacsword

  Move the cursor to the previous emacsword.

  emacs

    ``\^[`b`, ``\^[`B`

beginning-of-line

  Move the cursor to the beginning of the line.

  vi-insert
  vi-command

    ``\H``

  emacs

    ``\H``, ``\^A``

end-of-line

  Move the cursor to the end of the line.

  vi-insert

    ``\E``

  vi-command

    `$`, ``\E``

  emacs

    ``\E``, ``\^E``

go-to-column

  Move the cursor to the nth character on the line, where n is the argument. Assume n = 1 when no argument.

  vi-command

    `|`

first-nonblank

  Move the cursor to the first non-blank character on the line.

  vi-command

    `^`

find-char

  Move the cursor to the first position where a character that is entered just after this command appears after the current cursor position.

  vi-command

    `f`

  emacs

    ``\^]``

find-char-rev

  Move the cursor to the last position where a character that is entered just after this command appears before the current cursor position.

  vi-command

    `F`

  emacs

    ``\^[``\^]``

till-char

  Move the cursor to the first position just before a character that is entered just after this command appears after the current cursor position.

  vi-command

    `t`

till-char-rev

  Move the cursor to the last position just after a character that is entered just after this command appears before the current cursor position.

  vi-command

    `T`

refind-char

  Redo the last find-char, find-char-rev, till-char, till-char-rev command.

  vi-command

    `;`

refind-char-rev

  Redo the last find-char, find-char-rev, till-char, till-char-rev command in the reverse direction.

  vi-command

    `,`

### Editing commands

Editing commands modify contents of the buffer. Most editing commands accept an argument. When passed an argument, they repeat the modification as many times as specified by the argument.

Texts deleted by commands whose name starts with “kill” are saved in kill ring, from which deleted contents can be restored to the buffer. The most recent 32 texts are kept in the kill ring.

delete-char

  Delete a character at the current cursor position if no argument is passed; like the kill-char command otherwise.

  vi-insert
  emacs

    ``\X``

delete-bigword

  Delete a bigword at the current cursor position if no argument is passed; like the kill-bigword command otherwise.

delete-semiword

  Delete a semiword at the current cursor position if no argument is passed; like the kill-semiword command otherwise.

delete-viword

  Delete a viword at the current cursor position if no argument is passed; like the kill-viword command otherwise.

delete-emacsword

  Delete a emacsword at the current cursor position if no argument is passed; like the kill-emacsword command otherwise.

backward-delete-char

  Delete a character just before the current cursor position if no argument is passed; like the backward-kill-char command otherwise.

  vi-insert
  emacs

    ``\B``, ``\?``, ``\^H``

backward-delete-bigword

  Delete a bigword just before the current cursor position if no argument is passed; like the backward-kill-bigword command otherwise.

backward-delete-semiword

  Delete a semiword just before the current cursor position if no argument is passed; like the backward-kill-semiword command otherwise.

  vi-insert

    ``\^W``

backward-delete-viword

  Delete a viword just before the current cursor position if no argument is passed; like the backward-kill-viword command otherwise.

backward-delete-emacsword

  Delete a emacsword just before the current cursor position if no argument is passed; like the backward-kill-emacsword command otherwise.

delete-line

  Delete the whole buffer contents.

forward-delete-line

  Delete all characters from the current cursor position to the end of the buffer.

backward-delete-line

  Delete all characters before the current cursor position.

  vi-insert

    ``\$``, ``\^U``

kill-char

  Delete a character at the current cursor position and add it to the kill ring.

  vi-command

    `x`, ``\X``

kill-bigword

  Delete a bigword at the current cursor position and add it to the kill ring.

kill-semiword

  Delete a semiword at the current cursor position and add it to the kill ring.

kill-viword

  Delete a viword at the current cursor position and add it to the kill ring.

kill-emacsword

  Delete a emacsword at the current cursor position and add it to the kill ring.

  emacs

    ``\^[`d`, ``\^[`D`

backward-kill-char

  Delete a character just before the current cursor position and add it to the kill ring.

  vi-command

    `X`

backward-kill-bigword

  Delete a bigword just before the current cursor position and add it to the kill ring.

  emacs

    ``\^W``

backward-kill-semiword

  Delete a semiword just before the current cursor position and add it to the kill ring.

backward-kill-viword

  Delete a viword just before the current cursor position and add it to the kill ring.

backward-kill-emacsword

  Delete a emacsword just before the current cursor position and add it to the kill ring.

  emacs

    ``\^[``\B``, ``\^[``\?``, ``\^[``\^H``

kill-line

  Delete the whole buffer contents and add it to the kill ring.

forward-kill-line

  Delete all characters from the current cursor position to the end of the buffer and add it to the kill ring.

  emacs

    ``\^K``

backward-kill-line

  Delete all characters before the current cursor position and add it to the kill ring.

  emacs

    ``\$``, ``\^U``, ``\^X``\B``, ``\^X``\?``

put-before

  Insert the last-killed text before the current cursor position and move the cursor to the last character that was inserted.

  vi-command

    `P`

put

  Insert the last-killed text after the current cursor position and move the cursor to the last character that was inserted.

  vi-command

    `p`

put-left

  Insert the last-killed text before the current cursor position and move the cursor to the last character that was inserted.

  emacs

    ``\^Y``

put-pop

  Replace the just put text with the next older killed text.

  This command can be used only just after the put-before, put, put-left, or put-pop command.

  emacs

    ``\^[`y`, ``\^[`Y`

undo

  Cancel modification by the last editing command.

  vi

    `u`

  emacs

    ``\^_``, ``\^X``\$``, ``\^X``\^U``

undo-all

  Cancel all modification in the current buffer, restoring the initial contents.

  vi

    `U`

  emacs

    ``\^[``\^R``, ``\^[`r`, ``\^[`R`

cancel-undo

  Cancel cancellation by the last undo or undo-all command.

  vi

    ``\^R``

cancel-undo-all

  Cancel all cancellation by all most recent undo and undo-all commands.

redo

  Repeat modification by the last editing command.

  vi-command

    `.`

### Completion commands

complete

  Complete a word just before the cursor position and, if there is more than one candidate, show a list of the candidates.

complete-next-candidate

  Like the complete command when candidates are not being listed; otherwise, select the next candidate in the list.

  vi-insert
  emacs

    ``\^I``

complete-prev-candidate

  Like the complete command when candidates are not being listed; otherwise, select the previous candidate in the list.

  vi-insert
  emacs

    ``\bt``

complete-next-column

  Like the complete command when candidates are not being listed; otherwise, select the first candidate in the next column in the list.

complete-prev-column

  Like the complete command when candidates are not being listed; otherwise, select the first candidate in the previous column in the list.

complete-next-page

  Like the complete command when candidates are not being listed; otherwise, select the first candidate in the next page in the list.

complete-prev-page

  Like the complete command when candidates are not being listed; otherwise, select the first candidate in the previous page in the list.

complete-list

  Complete a word just before the cursor position.

  If you pass no argument, a list of completion candidates is shown. Otherwise, the word is completed with the nth candidate where n is the argument.

  emacs

    ``\^[`?`, ``\^[`=`

complete-all

  Replace a word just before the cursor position with all possible completion candidates, each separated by a space.

  emacs

    ``\^[`*`

complete-max

  Complete a word just before the cursor position with the longest prefix of all possible completion candidates.

complete-max-then-list

  Works like the complete-max command for the first use, then like the complete command when used successively.

complete-max-then-next-candidate

  Works like the complete-max command for the first use, then like the complete-next-candidate command when used successively.

complete-max-then-prev-candidate

  Works like the complete-max command for the first use, then like the complete-prev-candidate command when used successively.

clear-candidates

  Clear the list of completion candidates.

### Vi-specific commands

vi-replace-char

  Replace the character at the cursor position with a character that is entered just after this command.

  vi-command

    `r`

vi-insert-beginning

  Move the cursor to the beginning of the line and switch to the vi insert mode.

  vi-command

    `I`

vi-append

  Move the cursor to the next character and switch to the vi insert mode.

  vi-command

    `I`

vi-append-to-eol

  Move the cursor to the end of the line and switch to the vi insert mode.

  vi-command

    `A`

vi-replace

  Switch to the vi insert mode and start overwriting. While overwriting, the self-insert command replaces the character at cursor position rather than inserting a character. Overwriting ends when the editing mode is changed.

  vi-command

    `R`

vi-switch-case

  Switch case of characters between the current and next cursor positions. This command must be followed by a motion command, which determines the next cursor position.

vi-switch-case-char

  Switch case of the character at the current cursor position and move the cursor to the next character.

  vi-command

    `~`

vi-yank

  Add to the kill ring the characters between the current and next cursor positions. This command must be followed by a motion command, which determines the next cursor position.

  vi-command

    `y`

vi-yank-to-eol

  Add to the kill ring the characters from the current cursor position to the end of the line.

  vi-command

    `Y`

vi-delete

  Delete characters between the current and next cursor positions and add it to the kill ring. This command must be followed by a motion command, which determines the next cursor position.

  vi-command

    `d`

vi-delete-to-eol

  Delete the characters from the current cursor position to the end of the line and add it to the kill ring.

  vi-command

    `D`

vi-change

  Delete characters between the current and next cursor positions and switch to the vi insert mode. This command must be followed by a motion command, which determines the next cursor position.

  vi-command

    `c`

vi-change-to-eol

  Delete the characters from the current cursor position to the end of the line and switch to the vi insert mode.

  vi-command

    `C`

vi-change-line

  Delete the whole buffer contents and switch to the vi insert mode.

  vi-command

    `S`

vi-yank-and-change

  Like the vi-change command, but the deleted text is added to the kill ring.

vi-yank-and-change-to-eol

  Like the vi-change-to-eol command, but the deleted text is added to the kill ring.

vi-yank-and-change-line

  Like the vi-change-line command, but the deleted text is added to the kill ring.

vi-substitute

  Delete a character at the current cursor position, add it to the kill ring, and switch to the vi insert mode.

  vi-command

    `s`

vi-append-last-bigword

  Insert a space and the last bigword in the most recent command history entry just after the current cursor position and switch to the vi insert mode. If argument n is passed, the nth bigword in the entry is inserted instead of the last.

  vi-command

    `_`

vi-exec-alias

  Execute the value of an alias named `_c` as editing commands where c is a character input just after this command.

  vi-command

    `@`

vi-edit-and-accept

  Start an editor to edit the current buffer contents. If argument n is passed, the entry whose number is n is edited instead. If the `VISUAL` or `EDITOR` variable is defined, its value is used as the editor name. Otherwise, `vi` is used. When the editor finished, the edited buffer contents is accepted like the accept-line command unless the exit status of the editor is non-zero.

  vi-command

    `v`

vi-complete-list

  Like the complete-list command, but also switch to the vi insert mode.

  vi-command

    `=`

vi-complete-all

  Like the complete-all command, but also switch to the vi insert mode.

  vi-command

    `*`

vi-complete-max

  Like the complete-max command, but also switch to the vi insert mode.

  vi-command

    ``\\``

vi-search-forward

  Switch to the vi search mode and start forward history search.

  vi-command

    `?`

vi-search-backward

  Switch to the vi search mode and start backward history search.

  vi-command

    `/`

### Emacs-specific commands

emacs-transpose-chars

  Move a character just before the cursor to the right.

  emacs

    ``\^T``

emacs-transpose-words

  Move an emacsword just before the cursor to the right.

  emacs

    ``\^[`t`, ``\^[`T`

emacs-downcase-word

  Make an emacsword just after the cursor lowercase.

  emacs

    ``\^[`l`, ``\^[`L`

emacs-upcase-word

  Make an emacsword just after the cursor uppercase.

  emacs

    ``\^[`u`, ``\^[`U`

emacs-capitalize-word

  Capitalize the first letter of an emacsword just after the cursor.

  emacs

    ``\^[`c`, ``\^[`C`

emacs-delete-horizontal-space

  Delete spaces around the cursor. If any argument was passed, delete spaces just before the cursor only.

  emacs

    ``\^[``\\``

emacs-just-one-space

  Delete spaces around the cursor and leave one space. If an argument is specified, leave as many spaces as the argument.

  emacs

    ``\^[`` (Escape followed by a space)

emacs-search-forward

  Switch to the emacs search mode and start forward history search.

  emacs

    ``\^S``

emacs-search-forward-current

  The same as emacs-search-forward, but the search is initialised with the current contents of the line-edit buffer.

emacs-search-backward

  Switch to the emacs search mode and start backward history search.

  emacs

    ``\^R``

emacs-search-backward-current

  The same as emacs-search-backward, but the search is initialised with the current contents of the line-edit buffer.

### History-related commands

oldest-history

  Recall the oldest entry in the history. If argument n is passed, the entry whose number is n is recalled instead. The cursor position remains unchanged.

newest-history

  Recall the newest entry in the history. If argument n is passed, the entry whose number is n is recalled instead. The cursor position remains unchanged.

return-history

  Return to the initial buffer corresponding to none of existing history entries. If argument n is passed, the entry whose number is n is recalled instead. The cursor position remains unchanged.

oldest-history-bol

  Recall the oldest entry in the history and move the cursor to the beginning of the line. If argument n is passed, the entry whose number is n is recalled instead.

  vi-command

    `G`

newest-history-bol

  Recall the newest entry in the history and move the cursor to the beginning of the line. If argument n is passed, the entry whose number is n is recalled instead.

return-history-bol

  Return to the initial buffer corresponding to none of existing history entries and move the cursor to the beginning of the line. If argument n is passed, the entry whose number is n is recalled instead.

  vi-command

    `g`

oldest-history-eol

  Recall the oldest entry in the history and move the cursor to the end of the line. If argument n is passed, the entry whose number is n is recalled instead.

  emacs

    ``\^[`<`

newest-history-eol

  Recall the newest entry in the history and move the cursor to the end of the line. If argument n is passed, the entry whose number is n is recalled instead.

return-history-eol

  Return to the initial buffer corresponding to none of existing history entries and move the cursor to the end of the line. If argument n is passed, the entry whose number is n is recalled instead.

  emacs

    ``\^[`>`

next-history

  Recall the next history entry. The cursor position remains unchanged.

prev-history

  Recall the previous history entry. The cursor position remains unchanged.

next-history-bol

  Recall the next history entry and move the cursor to the beginning of the line.

  vi-command

    `j`, `+`, ``\D``, ``\^N``

prev-history-bol

  Recall the previous history entry and move the cursor to the beginning of the line.

  vi-command

    `k`, `-`, ``\U``, ``\^P``

next-history-eol

  Recall the next history entry and move the cursor to the end of the line.

  vi-insert
  emacs

    ``\D``, ``\^N``

prev-history-eol

  Recall the previous history entry and move the cursor to the end of the line.

  vi-insert
  emacs

    ``\U``, ``\^P``

search-again

  Repeat the last command history search.

  vi-command

    `n`

search-again-rev

  Repeat the last command history search in the reverse direction.

  vi-command

    `N`

search-again-forward

  Repeat the last command history search in the forward direction.

search-again-backward

  Repeat the last command history search in the backward direction.

beginning-search-forward

  Recall the next history entry that starts with the same text as the text from the beginning of the line up to the current cursor position. The cursor position remains unchanged.

beginning-search-backward

  Recall the previous history entry that starts with the same text as the text from the beginning of the line up to the current cursor position. The cursor position remains unchanged.

### Search mode commands

srch-self-insert

  Insert the input character at the current cursor position. Characters escaped by escape sequences cannot be inserted.

  vi-search
  emacs-search

    ``\\``

srch-backward-delete-char

  Delete the last character in the search text. If the text is empty:

  - like the srch-abort-search command when in the vi search mode, or

  - like the alert command when in the emacs search mode.

  vi-search
  emacs-search

    ``\B``, ``\?``, ``\^H``

srch-backward-delete-line

  Delete the whole search text.

  vi-search
  emacs-search

    ``\$``, ``\^U``

srch-continue-forward

  Find the next matching history entry.

  emacs-search

    ``\^S``

srch-continue-backward

  Find the previous matching history entry.

  emacs-search

    ``\^R``

srch-accept-search

  Finish the search mode, accepting the result being shown.

  vi-search

    ``\^J``, ``\^M``, ``\et``

  emacs-search

    ``\^J``, ``\^[``

srch-abort-search

  Abort search and restore the previous buffer contents.

  vi-search

    ``\^[``

  emacs-search

    ``\^G``

## Escape sequences

In the bindkey built-in, escape sequences are used to represent special keys such as function keys and arrow keys. Every escape sequence starts with a backslash (`\`) and thus there is also an escape sequence for a backslash itself.

Below are available escape sequences:

`\\`

  Backslash (`\`)

`\B`

  Backspace

`\D`

  Down arrow

`\E`

  End

`\H`

  Home

`\I`

  Insert (Insert-char, Enter-insert-mode)

`\L`

  Left arrow

`\N`

  Page-down (Next-page)

`\P`

  Page-up (Previous-page)

`\R`

  Right arrow

`\U`

  Up arrow

`\X`

  Delete

`\!`

  INTR

`\#`

  EOF

`\$`

  KILL

`\?`

  ERASE

`\^@`

  Ctrl + @

`\^A`, `\^B`, …, `\^Z`

  Ctrl + A, Ctrl + B, …, Ctrl + Z

  Note that Ctrl + I, Ctrl + J, and Ctrl + M are tab, newline, and carriage return, respectively.

`\^[`

  Ctrl + [ (Escape)

`\^\`

  Ctrl + \

`\^]`

  Ctrl + ]

`\^^`

  Ctrl + ^

`\^_`

  Ctrl + _

`\^?`

  Ctrl + ? (Delete)

`\F00`, `\F01`, …, `\F63`

  F0, F1, …, F63

`\a1`

  Top-left on keypad

`\a3`

  Top-right on keypad

`\b2`

  Center on keypad

`\bg`

  Beginning

`\bt`

  Back-tab

`\c1`

  Bottom-left on keypad

`\c3`

  Bottom-right on keypad

`\ca`

  Clear-all-tabs

`\cl`

  Close

`\cn`

  Cancel

`\co`

  Command

`\cp`

  Copy

`\cr`

  Create

`\cs`

  Clear-screen or erase

`\ct`

  Clear-tab

`\dl`

  Delete-line

`\ei`

  Exit-insert-mode

`\el`

  Clear-to-end-of-line

`\es`

  Clear-to-end-of-screen

`\et`

  Enter (Send)

`\ex`

  Exit

`\fd`

  Find

`\hp`

  Help

`\il`

  Insert-line

`\ll`

  Home-down

`\me`

  Message

`\mk`

  Mark

`\ms`

  Mouse event

`\mv`

  Move

`\nx`

  Next-object

`\on`

  Open

`\op`

  Options

`\pr`

  Print (Copy)

`\pv`

  Previous-object

`\rd`

  Redo

`\re`

  Resume

`\rf`

  Ref (Reference)

`\rh`

  Refresh

`\rp`

  Replace

`\rs`

  Restart

`\sf`

  Scroll-forward (Scroll-down)

`\sl`

  Select

`\sr`

  Scroll-backward (Scroll-up)

`\st`

  Set-tab

`\su`

  Suspend

`\sv`

  Save

`\ud`

  Undo

`\SE`

  Shift + End

`\SH`

  Shift + Home

`\SI`

  Shift + Insert

`\SL`

  Shift + Left arrow

`\SR`

  Shift + Right arrow

`\SX`

  Shift + Delete

`\Sbg`

  Shift + Beginning

`\Scn`

  Shift + Cancel

`\Sco`

  Shift + Command

`\Scp`

  Shift + Copy

`\Scr`

  Shift + Create

`\Sdl`

  Shift + Delete-line

`\Sel`

  Shift + End-of-line

`\Sex`

  Shift + Exit

`\Sfd`

  Shift + Find

`\Shp`

  Shift + Help

`\Smg`

  Shift + Message

`\Smv`

  Shift + Move

`\Snx`

  Shift + Next

`\Sop`

  Shift + Options

`\Spr`

  Shift + Print

`\Spv`

  Shift + Previous

`\Srd`

  Shift + Redo

`\Sre`

  Shift + Resume

`\Srp`

  Shift + Replace

`\Ssu`

  Shift + Suspend

`\Ssv`

  Shift + Save

`\Sud`

  Shift + Undo

INTR, EOF, KILL, and ERASE are special characters configured by the stty command. In a typical configuration, they are sent by typing Ctrl+C, Ctrl+D, Ctrl+U, and Ctrl+H, respectively, but some configuration uses Ctrl+? instead of Ctrl+H for ERASE.

## Command line completion

By using the complete and complete-next-candidate commands, etc., you can complete command names, options, and operands. By default, the complete-next-candidate command is bound with the Tab key in the vi insert and emacs modes.

Type a few first letters of a command name or pathname and hit the Tab key, and a list of matching names will be shown. You can choose a candidate from the list to complete the name by hitting the Tab key again. If there is only one matching name, no list will be shown and the name will directly be completed.

If the name to be completed contains characters like `*` and `?`, it is treated as a pattern. The name on the command line will be directly substituted with all possible names matching the pattern (you cannot choose from a list).

Normally, command names are completed with command names and command arguments with pathnames. However, completion functions can be defined to refine completion results.

### Completion details

When doing completion for the first time after the shell has been started, the INIT file is loaded as if the command string `. -AL completion/INIT` is executed. If the file is not found, it is silently ignored. This automatic loading is mainly intended for loading completion functions bundled with the shell, but you can let the shell load your own functions by putting a file in the load path.

When completing a command name, the shell executes the `completion//command` function and when completing a command argument, the `completion//argument` function. If those completion functions are not defined, the shell just completes with command names or pathnames. When completing other names, such as the user name in tilde expansion and the parameter name in parameter expansion, completion functions are never used: the shell just completes with user names, parameter names, or whatever applicable.

Completion functions are executed without any arguments. The following local variables are automatically defined while executing completion functions:

`IFS`

  The value is the three characters of a space, a tab, and a newline, which are the default value of the variable.

`WORDS`

  This variable is an array whose elements are a command name and arguments that have already been entered before the argument being completed. When completing a command name, the array has no elements.

`TARGETWORD`

  The value is the partially entered command name or argument that is being completed.

Completion candidates are generated by executing the complete built-in during a completion function.

Completion functions must not perform I/O to the terminal, or displayed text will be corrupted. Completion functions should run as quickly as possible for better user experience.

While a completion function is being executed:

- the POSIXly-correct mode and the err-return option are temporarily disabled,

- the err-exit option is temporarily ignored, and

- traps are not executed.

## Command line prediction

This is an experimental feature. When the le-predict option is enabled, the shell automatically tries to predict a command string fragment that follows the part of the command you have already typed in line-editing.

For example, assume you have once typed the command `ls Documents`. Next time you start typing `ls Doc`, the shell will show `uments` just after the cursor. If you are satisfied with this suggestion, you can move the cursor to the right by the forward-char or any other motion commands instead of typing the rest of the command. After moving the cursor after the last `s`, you can use the accept-line command to execute the command. You can also use the accept-prediction command to immediately execute the suggested command without moving the cursor.

To distinguish the typed and predicted parts of a command string, you can change the font style of those parts by setting the `PS1S` and `PS1P` variables.

When you move the cursor to the right, the predicted part up to the cursor becomes the typed part as if you actually typed it. Moving the cursor to the left does not turn the typed part back to the prediction. Use deletion commands such as backward-delete-char to delete typed command fragment.

The predicted part of the command is shown only when the cursor is at the end of the typed part.

By default, the predicted part is shown after you start typing a command string. By enabling the le-predict-empty option, the predicted part is also shown before you type the first character of the command string.

The prediction algorithm suggests command fragments on the basis of the command history. The algorithm considers recent history entries more probable. It also takes command succession patterns into account. A predicted command fragment is not always a complete valid command because less probable part of the fragment is excluded from prediction.