diff options
Diffstat (limited to 'Doc/Zsh/zle.yo')
| -rw-r--r-- | Doc/Zsh/zle.yo | 1076 |
1 files changed, 1076 insertions, 0 deletions
diff --git a/Doc/Zsh/zle.yo b/Doc/Zsh/zle.yo new file mode 100644 index 000000000..fccf538bd --- /dev/null +++ b/Doc/Zsh/zle.yo @@ -0,0 +1,1076 @@ +texinode(Zsh Line Editor)(Programmable Completion)(Shell Builtin Commands)(Top) +chapter(Zsh Line Editor) +cindex(line editor) +cindex(editor, line) +sect(Description) +pindex(ZLE, use of) +If the tt(ZLE) option is set (it is by default) +and the shell input is attached to the terminal, the user +is allowed to edit command lines. + +There are two display modes. The first, multiline mode, is the +default. It only works if the tt(TERM) parameter is set to a valid +terminal type that can move the cursor up. The second, single line +mode, is used if tt(TERM) is invalid or incapable of moving the +cursor up, or if the tt(SINGLE_LINE_ZLE) option is set. +pindex(SINGLE_LINE_ZLE, use of) +cindex(ksh, editor mode) +cindex(editor ksh style) +This mode +is similar to bf(ksh), and uses no termcap sequences. If tt(TERM) is +"emacs", the tt(ZLE) option will be unset by default. +sect(Keymaps) +cindex(keymaps) +cindex(key bindings) +cindex(bindings, key) +A keymap in ZLE contains a set of bindings between key sequences +and ZLE commands. The empty key sequence cannot be bound. + +There can be any number of keymaps at any time, and each keymap has one +or more names. If all of a keymap's names are deleted, it disappears. +findex(bindkey, use of) +tt(bindkey) can be used to manipulate keymap names. + +Initially, there are four keymaps: + +startsitem() +sitem(tt(emacs))(EMACS emulation) +sitem(tt(viins))(vi emulation - insert mode) +sitem(tt(vicmd))(vi emulation - command mode) +sitem(tt(.safe))(fallback keymap) +endsitem() + +The `tt(.safe)' keymap is special. It can never be altered, and the name +can never be removed. However, it can be linked to other names, which can +be removed. In the future other special keymaps may be added; users should +avoid using names beginning with `tt(.)' for their own keymaps. + +vindex(VISUAL) +vindex(EDITOR) +In addition to these four names, either `tt(emacs)' or `tt(viins)' is +also linked to the name `tt(main)'. If one of the tt(VISUAL) or +tt(EDITOR) environment variables contain the string `tt(vi)' when the shell +starts up then it will be `tt(viins)', otherwise it will be `tt(emacs)'. +tt(bindkey)'s tt(-e) and tt(-v) +options provide a convenient way to override this default choice. + +When the editor starts up, it will select the `tt(main)' keymap. +If that keymap doesn't exist, it will use `tt(.safe)' instead. + +In the `tt(.safe)' keymap, each single key is bound to tt(self-insert), +except for ^J (line feed) and ^M (return) which are bound to tt(accept-line). +This is deliberately not pleasant to use; if you are using it, it +means you deleted the main keymap, and you should put it back. +subsect(Reading Commands) +When ZLE is reading a command from the terminal, it may read a sequence +that is bound to some command and is also a prefix of a longer bound string. +In this case ZLE will wait a certain time to see if more characters +are typed, and if not (or they don't match any longer string) it will +execute the binding. This timeout is defined by the tt(KEYTIMEOUT) parameter; +its default is 0.4 sec. No timeout is done if the prefix string is not bound. + +As well as ZLE commands, key sequences can be bound to other strings, by using +`tt(bindkey -s)'. +When such a sequence is read, the replacement string is pushed back as input, +and the command reading process starts again using these fake keystrokes. +This input can itself invoke further replacement strings, but in order to +detect loops the process will be stopped if there are twenty such replacements +without a real command being read. +sect(Widgets) +cindex(widgets) +All actions in the editor are performed by `widgets'. A widget's job is +simply to perform some small action. The ZLE commands that key sequences +in keymaps are bound to are in fact widgets. Widgets can be user-defined +or built in. + +There are 162 standard widgets built in to ZLE (see sectref(Standard Widgets)). +Other built-in widgets can be defined by other modules (see +ifzman(zmanref(zshmodules))\ +ifnzman(noderef(Zsh Modules))\ +). Each built-in widget has two names: its normal canonical name, and the +same name preceded by a `tt(.)'. The `tt(.)' name is special: it can't be +rebound to a different widget. This makes the widget available even when +its usual name has been redefined. + +User-defined widgets are defined using `tt(zle -N)', and implemented +as shell functions. When the widget is executed, the corresponding +shell function is executed, and can perform editing (or other) actions. +It is recommended that user-defined widgets should not have names +starting with `tt(.)'. +sect(User-Defined Widgets) +cindex(widgets, user-defined) +User-defined widgets, being implemented as shell functions, +can execute any normal shell command. They can also run other widgets +(whether built-in or user-defined) using the tt(zle) builtin command. +Finally, they can examine and edit the ZLE buffer being edited by +reading and setting the special parameters described below. + +cindex(parameters, editor) +cindex(parameters, zle) +These special parameters are always available in widget functions, but +are not in any way special outside ZLE. If they have some normal value +outside ZLE, that value is temporarily inaccessible, but will return +when the widget function exits. These special parameters in fact have +local scope, like parameters created in a function using tt(local). + +startitem() +vindex(BUFFER) +item(tt(BUFFER) (scalar))( +The entire contents of the edit buffer. If it is written to, the +cursor remains at the same offset, unless that would put it outside the +buffer. +) +vindex(CURSOR) +item(tt(CURSOR) (integer))( +The offset of the cursor, within the edit buffer. This is in the range +0 to tt($#BUFFER), and is by definition equal to tt($#LBUFFER). +Attempts to move the cursor outside the buffer will result in the +cursor being moved to the appropriate end of the buffer. +) +vindex(LBUFFER) +item(tt(LBUFFER) (scalar))( +The part of the buffer that lies to the left of the cursor position. +If it is assigned to, only that part of the buffer is replaced, and the +cursor remains between the new tt($LBUFFER) and the old tt($RBUFFER). +) +vindex(RBUFFER) +item(tt(RBUFFER) (scalar))( +The part of the buffer that lies to the right of the cursor position. +If it is assigned to, only that part of the buffer is replaced, and the +cursor remains between the old tt($LBUFFER) and the new tt($RBUFFER). +) +enditem() +sect(Standard Widgets) +cindex(widgets, standard) +The following is a list of all the standard widgets, +and their default bindings in emacs mode, +vi command mode and vi insert mode +(the `tt(emacs)', `tt(vicmd)' and `tt(viins)' keymaps, respectively). +startmenu() +menu(Movement) +menu(History Control) +menu(Modifying Text) +menu(Arguments) +menu(Completion) +menu(Miscellaneous) +endmenu() +texinode(Movement)(History Control)()(Zsh Line Editor) +subsect(Movement) +startitem() +tindex(vi-backward-blank-word) +item(tt(vi-backward-blank-word) (unbound) (B) (unbound))( +Move backward one word, where a word is defined as a series of +non-blank characters. +) +tindex(backward-char) +item(tt(backward-char) (^B ESC-[D) (unbound) (unbound))( +Move backward one character. +) +tindex(vi-backward-char) +item(tt(vi-backward-char) (unbound) (^H h ^?) (unbound))( +Move backward one character, without changing lines. +) +tindex(backward-word) +item(tt(backward-word) (ESC-B ESC-b) (unbound) (unbound))( +Move to the beginning of the previous word. +) +tindex(emacs-backward-word) +item(tt(emacs-backward-word))( +Move to the beginning of the previous word. +) +tindex(vi-backward-word) +item(tt(vi-backward-word) (unbound) (b) (unbound))( +Move to the beginning of the previous word, vi-style. +) +tindex(beginning-of-line) +item(tt(beginning-of-line) (^A) (unbound) (unbound))( +Move to the beginning of the line. If already at the beginning +of the line, move to the beginning of the previous line, if any. +) +tindex(vi-beginning-of-line) +item(tt(vi-beginning-of-line))( +Move to the beginning of the line, without changing lines. +) +tindex(end-of-line) +item(tt(end-of-line) (^E) (unbound) (unbound))( +Move to the end of the line. If already at the end +of the line, move to the end of the next line, if any. +) +tindex(vi-end-of-line) +item(tt(vi-end-of-line) (unbound) ($) (unbound))( +Move to the end of the line. +If an argument is given to this command, the cursor will be moved to +the end of the line (argument - 1) lines down. +) +tindex(vi-forward-blank-word) +item(tt(vi-forward-blank-word) (unbound) (W) (unbound))( +Move forward one word, where a word is defined as a series of +non-blank characters. +) +tindex(vi-forward-blank-word-end) +item(tt(vi-forward-blank-word-end) (unbound) (E) (unbound))( +Move to the end of the current word, or, if at the end of the current word, +to the end of the next word, +where a word is defined as a series of non-blank characters. +) +tindex(forward-char) +item(tt(forward-char) (^F ESC-[C) (unbound) (unbound))( +Move forward one character. +) +tindex(vi-forward-char) +item(tt(vi-forward-char) (unbound) (space l) (unbound))( +Move forward one character. +) +tindex(vi-find-next-char) +item(tt(vi-find-next-char) (^X^F) (f) (unbound))( +Read a character from the keyboard, and move to +the next occurrence of it in the line. +) +tindex(vi-find-next-char-skip) +item(tt(vi-find-next-char-skip) (unbound) (t) (unbound))( +Read a character from the keyboard, and move to +the position just before the next occurrence of it in the line. +) +tindex(vi-find-prev-char) +item(tt(vi-find-prev-char) (unbound) (F) (unbound))( +Read a character from the keyboard, and move to +the previous occurrence of it in the line. +) +tindex(vi-find-prev-char-skip) +item(tt(vi-find-prev-char-skip) (unbound) (T) (unbound))( +Read a character from the keyboard, and move to +the position just after the previous occurrence of it in the line. +) +tindex(vi-first-non-blank) +item(tt(vi-first-non-blank) (unbound) (^) (unbound))( +Move to the first non-blank character in the line. +) +tindex(vi-forward-word) +item(tt(vi-forward-word) (unbound) (w) (unbound))( +Move forward one word, vi-style. +) +tindex(forward-word) +item(tt(forward-word) (ESC-F ESC-f) (unbound) (unbound))( +Move to the beginning of the next word. +The editor's idea of a word is specified with the tt(WORDCHARS) +parameter. +) +tindex(emacs-forward-word) +item(tt(emacs-forward-word))( +Move to the end of the next word. +) +tindex(vi-forward-word-end) +item(tt(vi-forward-word-end) (unbound) (e) (unbound))( +Move to the end of the next word. +) +tindex(vi-goto-column) +item(tt(vi-goto-column) (ESC-|) (|) (unbound))( +Move to the column specified by the numeric argument. +) +tindex(vi-goto-mark) +item(tt(vi-goto-mark) (unbound) (`) (unbound))( +Move to the specified mark. +) +tindex(vi-goto-mark-line) +item(tt(vi-goto-mark-line) (unbound) (') (unbound))( +Move to beginning of the line containing the specified mark. +) +tindex(vi-repeat-find) +item(tt(vi-repeat-find) (unbound) (;) (unbound))( +Repeat the last tt(vi-find) command. +) +tindex(vi-rev-repeat-find) +item(tt(vi-rev-repeat-find) (unbound) (,) (unbound))( +Repeat the last tt(vi-find) command in the opposite direction. +) +enditem() +texinode(History Control)(Modifying Text)(Movement)(Zsh Line Editor) +subsect(History Control) +startitem() +tindex(beginning-of-buffer-or-history) +item(tt(beginning-of-buffer-or-history) (ESC-<) (unbound) (unbound))( +Move to the beginning of the buffer, or if already there, +move to the first event in the history list. +) +tindex(beginning-of-line-hist) +item(tt(beginning-of-line-hist))( +Move to the beginning of the line. If already at the +beginning of the buffer, move to the previous history line. +) +tindex(beginning-of-history) +item(tt(beginning-of-history))( +Move to the first event in the history list. +) +tindex(down-line-or-history) +item(tt(down-line-or-history) (^N ESC-[B) (j) (unbound))( +Move down a line in the buffer, or if already at the bottom line, +move to the next event in the history list. +) +tindex(vi-down-line-or-history) +item(tt(vi-down-line-or-history) (unbound) (PLUS()) (unbound))( +Move down a line in the buffer, or if already at the bottom line, +move to the next event in the history list. +Then move to the first non-blank character on the line. +) +tindex(down-line-or-search) +item(tt(down-line-or-search))( +Move down a line in the buffer, or if already at the bottom line, +search forward in the history for a line beginning with the first +word in the buffer. +) +tindex(down-history) +item(tt(down-history) (unbound) (^N) (unbound))( +Move to the next event in the history list. +) +tindex(history-beginning-search-backward) +item(tt(history-beginning-search-backward))( +Search backward in the history for a line beginning with the current +line up to the cursor. +This leaves the cursor in its original position. +) +tindex(end-of-buffer-or-history) +item(tt(end-of-buffer-or-history) (ESC->) (unbound) (unbound))( +Move to the end of the buffer, or if already there, +move to the last event in the history list. +) +tindex(end-of-line-hist) +item(tt(end-of-line-hist))( +Move to the end of the line. If already at the end of +the buffer, move to the next history line. +) +tindex(end-of-history) +item(tt(end-of-history))( +Move to the last event in the history list. +) +tindex(vi-fetch-history) +item(tt(vi-fetch-history) (unbound) (G) (unbound))( +Fetch the history line specified by the numeric argument. +This defaults to the current history line +(i.e. the one that isn't history yet). +) +tindex(history-incremental-search-backward) +item(tt(history-incremental-search-backward) (^R ^Xr) (unbound) (unbound))( +Search backward incrementally for a specified string. The search is +case-insensitive if the search string does not have uppercase letters and no +numeric argument was given. The string may begin with `tt(^)' to anchor the +search to the beginning of the line. + +A restricted set of editing functions +is available in the mini-buffer. An interrupt signal, as defined by the stty +setting, will stop the search and go back to the original line. An undefined +key will have the same effect. The supported functions are: +tt(backward-delete-char), +tt(vi-backward-delete-char), +tt(clear-screen), +tt(redisplay), +tt(quoted-insert), +tt(vi-quoted-insert), +tt(accept-and-hold), +tt(accept-and-infer-next-history), +tt(accept-line) and +tt(accept-line-and-down-history). + +tt(magic-space) just inserts a space. +tt(vi-cmd-mode) toggles between the `tt(main)' and `tt(vicmd)' keymaps; +the `tt(main)' keymap (insert mode) will be selected initially. +tt(history-incremental-search-backward) will get the +next occurrence of the contents of the mini-buffer. +tt(history-incremental-search-forward) inverts the sense of the search. +tt(vi-repeat-search) and tt(vi-rev-repeat-search) are similarly supported. +The direction of the search is indicated in the mini-buffer. + +Any multi-character string +that is not bound to one of the above functions will beep and interrupt the +search, leaving the last found line in the buffer. Any single character that +is not bound to one of the above functions, or tt(self-insert) or +tt(self-insert-unmeta), will have the same effect but the function will be +executed. +) +tindex(history-incremental-search-forward) +item(tt(history-incremental-search-forward) (^S ^Xs) (unbound) (unbound))( +Search forward incrementally for a specified string. The search is +case-insensitive if the search string does not have uppercase letters and no +numeric argument was given. The string may begin with `tt(^)' to anchor the +search to the beginning of the line. The functions available in the +mini-buffer are the same as for tt(history-incremental-search-backward). +) +tindex(history-search-backward) +item(tt(history-search-backward) (ESC-P ESC-p) (unbound) (unbound))( +Search backward in the history for a line beginning with the first +word in the buffer. +) +tindex(vi-history-search-backward) +item(tt(vi-history-search-backward) (unbound) (/) (unbound))( +Search backward in the history for a specified string. +The string may begin with `tt(^)' to anchor the search to the +beginning of the line. + +A restricted set of editing functions is available in +the mini-buffer. An interrupt signal, as defined by the stty setting, will +stop the search. +The functions available in the mini-buffer are: +tt(accept-line), +tt(backward-delete-char), +tt(vi-backward-delete-char), +tt(backward-kill-word), +tt(vi-backward-kill-word), +tt(clear-screen), +tt(redisplay), +tt(quoted-insert) +and +tt(vi-quoted-insert). + +tt(vi-cmd-mode) is treated the same as accept-line, and +tt(magic-space) is treated as a space. +Any other character that is not bound to self-insert or +self-insert-unmeta will beep and be ignored. If the function is called from vi +command mode, the bindings of the current insert mode will be used. +) +tindex(history-search-forward) +item(tt(history-search-forward) (ESC-N ESC-n) (unbound) (unbound))( +Search forward in the history for a line beginning with the first +word in the buffer. +) +tindex(vi-history-search-forward) +item(tt(vi-history-search-forward) (unbound) (?) (unbound))( +Search forward in the history for a specified string. +The string may begin with `tt(^)' to anchor the search to the +beginning of the line. The functions available in the mini-buffer are the same +as for tt(vi-history-search-backward). +) +tindex(infer-next-history) +item(tt(infer-next-history) (^X^N) (unbound) (unbound))( +Search in the history list for a line matching the current one and +fetch the event following it. +) +tindex(insert-last-word) +item(tt(insert-last-word) (ESC-_ ESC-.) (unbound) (unbound))( +Insert the last word from the previous history event at the +cursor position. If a positive numeric argument is given, +insert that word from the end of the previous history event. +If the argument is zero or negative insert that word from the +left (zero inserts the previous command word). +) +tindex(vi-repeat-search) +item(tt(vi-repeat-search) (unbound) (n) (unbound))( +Repeat the last vi history search. +) +tindex(vi-rev-repeat-search) +item(tt(vi-rev-repeat-search) (unbound) (N) (unbound))( +Repeat the last vi history search, but in reverse. +) +tindex(up-line-or-history) +item(tt(up-line-or-history) (^P ESC-[A) (k) (unbound))( +Move up a line in the buffer, or if already at the top line, +move to the previous event in the history list. +) +tindex(vi-up-line-or-history) +item(tt(vi-up-line-or-history) (unbound) (-) (unbound))( +Move up a line in the buffer, or if already at the top line, +move to the previous event in the history list. +Then move to the first non-blank character on the line. +) +tindex(up-line-or-search) +item(tt(up-line-or-search))( +Move up a line in the buffer, or if already at the top line, +search backward in the history for a line beginning with the +first word in the buffer. +) +tindex(up-history) +item(tt(up-history) (unbound) (^P) (unbound))( +Move to the previous event in the history list. +) +tindex(history-beginning-search-forward) +item(tt(history-beginning-search-forward))( +Search forward in the history for a line beginning with the current +line up to the cursor. +This leaves the cursor in its original position. +) +enditem() +texinode(Modifying Text)(Arguments)(History Control)(Zsh Line Editor) +subsect(Modifying Text) +startitem() +tindex(vi-add-eol) +item(tt(vi-add-eol) (unbound) (A) (unbound))( +Move to the end of the line and enter insert mode. +) +tindex(vi-add-next) +item(tt(vi-add-next) (unbound) (a) (unbound))( +Enter insert mode after the current cursor position, without changing lines. +) +tindex(backward-delete-char) +item(tt(backward-delete-char) (^H ^?) (unbound) (unbound))( +Delete the character behind the cursor. +) +tindex(vi-backward-delete-char) +item(tt(vi-backward-delete-char) (unbound) (X) (^H))( +Delete the character behind the cursor, without changing lines. +If in insert mode, this won't delete past the point where insert mode was +last entered. +) +tindex(backward-delete-word) +item(tt(backward-delete-word))( +Delete the word behind the cursor. +) +tindex(backward-kill-line) +item(tt(backward-kill-line))( +Kill from the beginning of the line to the cursor position. +) +tindex(backward-kill-word) +item(tt(backward-kill-word) (^W ESC-^H ESC-^?) (unbound) (unbound))( +Kill the word behind the cursor. +) +tindex(vi-backward-kill-word) +item(tt(vi-backward-kill-word) (unbound) (unbound) (^W))( +Kill the word behind the cursor, without going past the point where insert +mode was last entered. +) +tindex(capitalize-word) +item(tt(capitalize-word) (ESC-C ESC-c) (unbound) (unbound))( +Capitalize the current word and move past it. +) +tindex(vi-change) +item(tt(vi-change) (unbound) (c) (unbound))( +Read a movement command from the keyboard, and kill +from the cursor position to the endpoint of the movement. +Then enter insert mode. +If the command is tt(vi-change), change the current line. +) +tindex(vi-change-eol) +item(tt(vi-change-eol) (unbound) (C) (unbound))( +Kill to the end of the line and enter insert mode. +) +tindex(vi-change-whole-line) +item(tt(vi-change-whole-line) (unbound) (S) (unbound))( +Kill the current line and enter insert mode. +) +tindex(copy-region-as-kill) +item(tt(copy-region-as-kill) (ESC-W ESC-w) (unbound) (unbound))( +Copy the area from the cursor to the mark to the kill buffer. +) +tindex(copy-prev-word) +item(tt(copy-prev-word) (ESC-^_) (unbound) (unbound))( +Duplicate the word behind the cursor. +) +tindex(vi-delete) +item(tt(vi-delete) (unbound) (d) (unbound))( +Read a movement command from the keyboard, and kill +from the cursor position to the endpoint of the movement. +If the command is tt(vi-delete), kill the current line. +) +tindex(delete-char) +item(tt(delete-char))( +Delete the character under the cursor. +) +tindex(vi-delete-char) +item(tt(vi-delete-char) (unbound) (x) (unbound))( +Delete the character under the cursor, +without going past the end of the line. +) +tindex(delete-word) +item(tt(delete-word))( +Delete the current word. +) +tindex(down-case-word) +item(tt(down-case-word) (ESC-L ESC-l) (unbound) (unbound))( +Convert the current word to all lowercase and move past it. +) +tindex(kill-word) +item(tt(kill-word) (ESC-D ESC-d) (unbound) (unbound))( +Kill the current word. +) +tindex(gosmacs-transpose-chars) +item(tt(gosmacs-transpose-chars))( +Exchange the two characters behind the cursor. +) +tindex(vi-indent) +item(tt(vi-indent) (unbound) (>) (unbound))( +Indent a number of lines. +) +tindex(vi-insert) +item(tt(vi-insert) (unbound) (i) (unbound))( +Enter insert mode. +) +tindex(vi-insert-bol) +item(tt(vi-insert-bol) (unbound) (I) (unbound))( +Move to the first non-blank character on the line and enter insert mode. +) +tindex(vi-join) +item(tt(vi-join) (^X^J) (J) (unbound))( +Join the current line with the next one. +) +tindex(kill-line) +item(tt(kill-line) (^K) (unbound) (unbound))( +Kill from the cursor to the end of the line. +If already on the end of the line, kill the newline character. +) +tindex(vi-kill-line) +item(tt(vi-kill-line) (unbound) (unbound) (^U))( +Kill from the cursor back to wherever insert mode was last entered. +) +tindex(vi-kill-eol) +item(tt(vi-kill-eol) (unbound) (D) (unbound))( +Kill from the cursor to the end of the line. +) +tindex(kill-region) +item(tt(kill-region))( +Kill from the cursor to the mark. +) +tindex(kill-buffer) +item(tt(kill-buffer) (^X^K) (unbound) (unbound))( +Kill the entire buffer. +) +tindex(kill-whole-line) +item(tt(kill-whole-line) (^U) (unbound) (unbound))( +Kill the current line. +) +tindex(vi-match-bracket) +item(tt(vi-match-bracket) (^X^B) (%) (unbound))( +Move to the bracket character (one of tt({}), tt(()) or tt([])) that +matches the one under the cursor. +If the cursor is not on a bracket character, move forward without going +past the end of the line to find one, and then go to the matching bracket. +) +tindex(vi-open-line-above) +item(tt(vi-open-line-above) (unbound) (O) (unbound))( +Open a line above the cursor and enter insert mode. +) +tindex(vi-open-line-below) +item(tt(vi-open-line-below) (unbound) (o) (unbound))( +Open a line below the cursor and enter insert mode. +) +tindex(vi-oper-swap-case) +item(tt(vi-oper-swap-case))( +Read a movement command from the keyboard, and swap +the case of all characters +from the cursor position to the endpoint of the movement. +If the movement command is tt(vi-oper-swap-case), +swap the case of all characters on the current line. +) +tindex(overwrite-mode) +item(tt(overwrite-mode) (^X^O) (unbound) (unbound))( +Toggle between overwrite mode and insert mode. +) +tindex(vi-put-before) +item(tt(vi-put-before) (unbound) (P) (unbound))( +Insert the contents of the kill buffer before the cursor. +If the kill buffer contains a sequence of lines (as opposed to characters), +paste it above the current line. +) +tindex(vi-put-after) +item(tt(vi-put-after) (unbound) (p) (unbound))( +Insert the contents of the kill buffer after the cursor. +If the kill buffer contains a sequence of lines (as opposed to characters), +paste it below the current line. +) +tindex(quoted-insert) +item(tt(quoted-insert) (^V) (unbound) (unbound))( +Insert the next character typed into the buffer literally. +An interrupt character will not be inserted. +) +tindex(vi-quoted-insert) +item(tt(vi-quoted-insert) (unbound) (unbound) (^Q ^V))( +Display a `tt(^)' at the cursor position, and +insert the next character typed into the buffer literally. +An interrupt character will not be inserted. +) +tindex(quote-line) +item(tt(quote-line) (ESC-') (unbound) (unbound))( +Quote the current line; that is, put a `tt(')' character at the +beginning and the end, and convert all `tt(')' characters +to `tt('\'')'. +) +tindex(quote-region) +item(tt(quote-region) (ESC-") (unbound) (unbound))( +Quote the region from the cursor to the mark. +) +tindex(vi-replace) +item(tt(vi-replace) (unbound) (R) (unbound))( +Enter overwrite mode. +) +tindex(vi-repeat-change) +item(tt(vi-repeat-change) (unbound) (.) (unbound))( +Repeat the last vi mode text modification. +If a count was used with the modification, it is remembered. +If a count is given to this command, it overrides the remembered count, +and is remembered for future uses of this command. +The cut buffer specification is similarly remembered. +) +tindex(vi-replace-chars) +item(tt(vi-replace-chars) (unbound) (r) (unbound))( +Replace the character under the cursor with a character +read from the keyboard. +) +tindex(self-insert) +item(tt(self-insert) (printable characters) (unbound) (printable characters and some control characters))( +Insert a character into the buffer at the cursor position. +) +tindex(self-insert-unmeta) +item(tt(self-insert-unmeta) (ESC-^I ESC-^J ESC-^M) (unbound) (unbound))( +Insert a character into the buffer after stripping the meta bit +and converting ^M to ^J. +) +tindex(vi-substitute) +item(tt(vi-substitute) (unbound) (s) (unbound))( +Substitute the next characte+CHAR(r)(s). +) +tindex(vi-swap-case) +item(tt(vi-swap-case) (unbound) (~) (unbound))( +Swap the case of the character under the cursor and move past it. +) +tindex(transpose-chars) +item(tt(transpose-chars) (^T) (unbound) (unbound))( +Exchange the two characters to the left of the +cursor if at end of line, else exchange the +character under the cursor with the character +to the left. +) +tindex(transpose-words) +item(tt(transpose-words) (ESC-T ESC-t) (unbound) (unbound))( +Exchange the current word with the one before it. +) +tindex(vi-unindent) +item(tt(vi-unindent) (unbound) (<) (unbound))( +Unindent a number of lines. +) +tindex(up-case-word) +item(tt(up-case-word) (ESC-U ESC-u) (unbound) (unbound))( +Convert the current word to all caps and move past it. +) +tindex(yank) +item(tt(yank) (^Y) (unbound) (unbound))( +Insert the contents of the kill buffer at the cursor position. +) +tindex(yank-pop) +item(tt(yank-pop) (ESC-y) (unbound) (unbound))( +Remove the text just yanked, rotate the kill-ring, +and yank the new top. Only works following +tt(yank) or tt(yank-pop). +) +tindex(vi-yank) +item(tt(vi-yank) (unbound) (y) (unbound))( +Read a movement command from the keyboard, and copy the region +from the cursor position to the endpoint of the movement +into the kill buffer. +If the command is tt(vi-yank), copy the current line. +) +tindex(vi-yank-whole-line) +item(tt(vi-yank-whole-line) (unbound) (Y) (unbound))( +Copy the current line into the kill buffer. +) +tindex(vi-yank-eol) +item(tt(vi-yank-eol))( +Copy the region from the cursor position to the end of the line +into the kill buffer. +Arguably, this is what Y should do in vi, but it isn't what it actually does. +) +enditem() +texinode(Arguments)(Completion)(Modifying Text)(Zsh Line Editor) +subsect(Arguments) +startitem() +tindex(digit-argument) +item(tt(digit-argument) (ESC-0..ESC-9) (1-9) (unbound))( +Start a new numeric argument, or add to the current one. +See also tt(vi-digit-or-beginning-of-line). +) +tindex(neg-argument) +item(tt(neg-argument) (ESC--) (unbound) (unbound))( +Changes the sign of the following argument. +) +tindex(universal-argument) +item(tt(universal-argument))( +Multiply the argument of the next command by 4. Alternatively, if +this command is followed by an integer (positive or negative), use +that as the argument for the next command. Thus digits cannot be +repeated using this command. For example, if this command occurs +twice, followed immediately by tt(forward-char), move forward sixteen +spaces; if instead it is followed by tt(-2), then tt(forward-char), +move backward two spaces. +) +enditem() +texinode(Completion)(Miscellaneous)(Arguments)(Zsh Line Editor) +subsect(Completion) +startitem() +tindex(accept-and-menu-complete) +item(tt(accept-and-menu-complete))( +In a menu completion, insert the current completion into the buffer, +and advance to the next possible completion. +) +tindex(complete-word) +item(tt(complete-word))( +Attempt completion on the current word. +) +tindex(delete-char-or-list) +item(tt(delete-char-or-list) (^D) (unbound) (unbound))( +Delete the character under the cursor. If the cursor +is at the end of the line, list possible completions for the +current word. +) +tindex(expand-cmd-path) +item(tt(expand-cmd-path))( +Expand the current command to its full pathname. +) +tindex(expand-or-complete) +item(tt(expand-or-complete) (TAB) (unbound) (TAB))( +Attempt shell expansion on the current word. +If that fails, +attempt completion. +) +tindex(expand-or-complete-prefix) +item(tt(expand-or-complete-prefix))( +Attempt shell expansion on the current word up to cursor. +) +tindex(expand-history) +item(tt(expand-history) (ESC-space ESC-!) (unbound) (unbound))( +Perform history expansion on the edit buffer. +) +tindex(expand-word) +item(tt(expand-word) (^X*) (unbound) (unbound))( +Attempt shell expansion on the current word. +) +tindex(list-choices) +item(tt(list-choices) (ESC-^D) (^D =) (^D))( +List possible completions for the current word. +) +tindex(list-expand) +item(tt(list-expand) (^Xg ^XG) (^G) (^G))( +List the expansion of the current word. +) +tindex(magic-space) +item(tt(magic-space))( +Perform history expansion and insert a space into the +buffer. This is intended to be bound to space. +) +tindex(menu-complete) +pindex(MENU_COMPLETE, use of) +item(tt(menu-complete))( +Like tt(complete-word), except that menu completion is used. +See the tt(MENU_COMPLETE) option. +) +tindex(menu-expand-or-complete) +item(tt(menu-expand-or-complete))( +Like tt(expand-or-complete), except that menu completion is used. +) +tindex(reverse-menu-complete) +item(tt(reverse-menu-complete))( +Perform menu completion, like tt(menu-complete), except that if +a menu completion is already in progress, move to the em(previous) +completion rather than the next. +) +enditem() +texinode(Miscellaneous)()(Completion)(Zsh Line Editor) +subsect(Miscellaneous) +startitem() +tindex(accept-and-hold) +item(tt(accept-and-hold) (ESC-A ESC-a) (unbound) (unbound))( +Push the contents of the buffer on the buffer stack +and execute it. +) +tindex(accept-and-infer-next-history) +item(tt(accept-and-infer-next-history))( +Execute the contents of the buffer. +Then search the history list for a line matching the current one +and push the event following onto the buffer stack. +) +tindex(accept-line) +item(tt(accept-line) (^J ^M) (^J ^M) (^J ^M))( +Finish editing the buffer. Normally this causes the buffer to be +executed as a shell command. +) +tindex(accept-line-and-down-history) +item(tt(accept-line-and-down-history) (^O) (unbound) (unbound))( +Execute the current line, and push the next history +event on the the buffer stack. +) +tindex(vi-cmd-mode) +item(tt(vi-cmd-mode) (^X^V) (unbound) (^[))( +Enter command mode; that is, select the `tt(vicmd)' keymap. +Yes, this is bound by default in emacs mode. +) +tindex(vi-caps-lock-panic) +item(tt(vi-caps-lock-panic))( +Hang until any lowercase key is pressed. +This is for vi users without the mental capacity to keep +track of their caps lock key (like the author). +) +tindex(clear-screen) +item(tt(clear-screen) (^L ESC-^L) (^L) (^L))( +Clear the screen and redraw the prompt. +) +tindex(describe-key-briefly) +item(tt(describe-key-briefly))( +Reads a key sequence, then prints the function bound to that sequence. +) +tindex(exchange-point-and-mark) +item(tt(exchange-point-and-mark) (^X^X) (unbound) (unbound))( +Exchange the cursor position with the position of the mark. +) +tindex(execute-named-cmd) +item(tt(execute-named-cmd) (ESC-x) (unbound) (unbound))( +Read the name of an editor command and +execute it. A restricted set of editing functions is available in the +mini-buffer. An interrupt signal, as defined by the stty setting, will +abort the function. The allowed functions are: +tt(backward-delete-char), +tt(vi-backward-delete-char), +tt(clear-screen), +tt(redisplay), +tt(quoted-insert), +tt(vi-quoted-insert), +tt(backward-kill-word), +tt(vi-backward-kill-word), +tt(kill-whole-line), +tt(vi-kill-line), +tt(backward-kill-line), +tt(list-choices), +tt(delete-char-or-list), +tt(complete-word), +tt(accept-line), +tt(expand-or-complete) and +tt(expand-or-complete-prefix). + +tt(kill-region) kills the last word, +and vi-cmd-mode is treated the same as accept-line. +The space and tab characters, if not bound to one of +these functions, will complete the name and then list the +possibilities if the tt(AUTO_LIST) option is set. +Any other character that is not bound to tt(self-insert) or +tt(self-insert-unmeta) will beep and be ignored. +The bindings of the current insert mode will be used. +) +tindex(execute-last-named-cmd) +item(tt(execute-last-named-cmd) (ESC-z) (unbound) (unbound))( +Redo the last function executed with tt(execute-named-cmd). +) +tindex(get-line) +item(tt(get-line) (ESC-G ESC-g) (unbound) (unbound))( +Pop the top line off the buffer stack and insert it at the +cursor position. +) +tindex(pound-insert) +item(tt(pound-insert) (unbound) (#) (unbound))( +If there is no # character at the beginning of the buffer, +add one to the beginning of each line. +If there is one, remove a # from each line that has one. +In either case, accept the current line. +The tt(INTERACTIVE_COMMENTS) option must be set +for this to have any usefulness. +) +tindex(vi-pound-insert) +item(tt(vi-pound-insert))( +If there is no # character at the beginning of the current line, +add one. If there is one, remove it. +The tt(INTERACTIVE_COMMENTS) option must be set +for this to have any usefulness. +) +tindex(push-input) +item(tt(push-input))( +Push the entire current multiline construct onto the buffer stack and +return to the top-level (tt(PS1)) prompt. +If the current parser construct is only a single line, this is exactly +like tt(push-line). +Next time the editor starts up or is popped with tt(get-line), the +construct will be popped off the top of the buffer stack and loaded +into the editing buffer. +) +tindex(push-line) +item(tt(push-line) (^Q ESC-Q ESC-q) (unbound) (unbound))( +Push the current buffer onto the buffer stack and clear +the buffer. +Next time the editor starts up, the buffer will be popped +off the top of the buffer stack and loaded into the editing +buffer. +) +tindex(push-line-or-edit) +item(tt(push-line-or-edit))( +At the top-level (tt(PS1)) prompt, equivalent to tt(push-line). +At a secondary (tt(PS2)) prompt, move the entire current multiline +construct into the editor buffer. +The latter is equivalent to tt(push-input) followed by tt(get-line). +) +tindex(redisplay) +item(tt(redisplay) (unbound) (^R) (^R))( +Redisplays the edit buffer. +) +tindex(send-break) +item(tt(send-break) (^G ESC-^G) (unbound) (unbound))( +Abort the current editor function, e.g. tt(execute-named-command), or the +editor itself, e.g. if you are in tt(vared). Otherwise abort the parsing of +the current line. +) +tindex(run-help) +item(tt(run-help) (ESC-H ESC-h) (unbound) (unbound))( +Push the buffer onto the buffer stack, and execute the +command `tt(run-help) var(cmd)', where var(cmd) is the current +command. tt(run-help) is normally aliased to var(man). +) +tindex(vi-set-buffer) +item(tt(vi-set-buffer) (unbound) (") (unbound))( +Specify a buffer to be used in the following command. +There are 35 buffers that can be specified: +the 26 `named' buffers tt("a) to tt("z) +and the nine `queued' buffers tt("1) to tt("9). The named buffers can also +be specified as tt("A) to tt("Z). + +When a buffer is specified for a cut command, the text being cut replaces +the previous contents of the specified buffer. If a named buffer +is specified using a capital, the newly cut text is appended to the buffer +instead of overwriting it. + +If no buffer is specified for a cut command, tt("1) is used, and the +contents of tt("1) to tt("8) are each shifted along one buffer; the contents of +tt("9) is lost. +) +tindex(vi-set-mark) +item(tt(vi-set-mark) (unbound) (m) (unbound))( +Set the specified mark at the cursor position. +) +tindex(set-mark-command) +item(tt(set-mark-command) (^@) (unbound) (unbound))( +Set the mark at the cursor position. +) +tindex(spell-word) +item(tt(spell-word) (ESC-$ ESC-S ESC-s) (unbound) (unbound))( +Attempt spelling correction on the current word. +) +tindex(undefined-key) +item(tt(undefined-key))( +This command is executed when a key sequence that is not bound to any +command is typed. By default it beeps. +) +tindex(undo) +item(tt(undo) (^_ ^Xu ^X^U) (unbound) (unbound))( +Incrementally undo the last text modification. +) +tindex(redo) +item(tt(redo))( +Incrementally redo undone text modifications. +) +tindex(vi-undo-change) +item(tt(vi-undo-change) (unbound) (u) (unbound))( +Undo the last text modification. +If repeated, redo the modification. +) +tindex(what-cursor-position) +item(tt(what-cursor-position) (^X=) (unbound) (unbound))( +Print the character under the cursor, its code as an octal, decimal and +hexadecimal number, the current cursor position within the buffer and the +column of the cursor in the current line. +) +tindex(where-is) +item(tt(where-is))( +Read the name of an editor command and and print the listing of key +sequences that invoke the specified command. +) +tindex(which-command) +item(tt(which-command) (ESC-?) (unbound) (unbound))( +Push the buffer onto the buffer stack, and execute the +command `tt(which-command) var(cmd)'. where var(cmd) is the current +command. tt(which-command) is normally aliased to var(whence). +) +tindex(vi-digit-or-beginning-of-line) +item(tt(vi-digit-or-beginning-of-line) (unbound) (0) (unbound))( +If the last command executed was a digit as part of an argument, +continue the argument. Otherwise, execute vi-beginning-of-line. +) +enditem() |