59bfc16ae3
<jimb@zwingli.cygnus.com> and David Taylor <taylor@texas.cygnus.com> as part of a project to merge in changes made by HP; HP did not create ChangeLog entries. * config/mp-enable-tui: New file. (TUI_CFLAGS): Search devo's include directory, as long as we're totally ruining modularity. (INCLUDE_SRCDIR): New var. (GDB_TUI_SRCDIR): Fix syntax error. * configure.in: Check the --enable-tui flag; if it's set, include a makefile fragment that #defines TUI and adds the needed #include directories. (*-*-hpux*): New host; use sysdep-hpux.h. * Makefile.in (.c.o): Check the variable set in the makefile fragment above. * display.c (term_goto): declare it. (insert_some_chars): set it. (delete_chars): set it. * readline.c: add tui include files surrounded by TUI. (rl_reset): new function, move some of rl_abort functionality to here. (rl_abort): call rl_reset. (rl_getc): tui changes. (init_terminal_io): tui changes. * readline.h (tui_version, fputc_unfiltered, fputs_unfiltered, tui_tputs): declare if TUI is defined. * rltty.c (prepare_terminal_settings): additional comment. * signals.c: add tui include files surrounded by TUI. move #if and #endif to column 1 so HP's compiler will accept them. Remove declaration of tuiDoAndReturnToTop since it's declared in tui.h. (rl_handle_sigwinch): call tuiDoAndReturnToTop if TUI defined. (rl_handle_sigwinch_on_clear): define if TUI defined. (rl_set_signals): if TUI, avoid infinite recursion. (rl_clear_signals): install rl_handle_sigwinch_on_clear. * sysdep-hpux.h: New file.
566 lines
21 KiB
Text
566 lines
21 KiB
Text
@ignore
|
|
This file documents the end user interface to the GNU command line
|
|
editing feautres. It is to be an appendix to manuals for programs which
|
|
use these features. There is a document entitled "readline.texinfo"
|
|
which contains both end-user and programmer documentation for the GNU
|
|
Readline Library.
|
|
|
|
Copyright (C) 1988 Free Software Foundation, Inc.
|
|
|
|
Authored by Brian Fox.
|
|
|
|
Permission is granted to process this file through Tex and print the
|
|
results, provided the printed document carries copying permission notice
|
|
identical to this one except for the removal of this paragraph (this
|
|
paragraph not being relevant to the printed manual).
|
|
|
|
Permission is granted to make and distribute verbatim copies of this manual
|
|
provided the copyright notice and this permission notice are preserved on
|
|
all copies.
|
|
|
|
Permission is granted to copy and distribute modified versions of this
|
|
manual under the conditions for verbatim copying, provided also that the
|
|
GNU Copyright statement is available to the distributee, and provided that
|
|
the entire resulting derived work is distributed under the terms of a
|
|
permission notice identical to this one.
|
|
|
|
Permission is granted to copy and distribute translations of this manual
|
|
into another language, under the above conditions for modified versions.
|
|
@end ignore
|
|
|
|
@node Command Line Editing
|
|
@appendix Command Line Editing
|
|
|
|
This text describes GNU's command line editing interface.
|
|
|
|
@menu
|
|
* Introduction and Notation:: Notation used in this text.
|
|
* Readline Interaction:: The minimum set of commands for editing a line.
|
|
* Readline Init File:: Customizing Readline from a user's view.
|
|
@end menu
|
|
|
|
@node Introduction and Notation, Readline Interaction, Command Line Editing, Command Line Editing
|
|
@section Introduction to Line Editing
|
|
|
|
The following paragraphs describe the notation we use to represent
|
|
keystrokes.
|
|
|
|
The text @key{C-k} is read as `Control-K' and describes the character
|
|
produced when the Control key is depressed and the @key{k} key is struck.
|
|
|
|
The text @key{M-k} is read as `Meta-K' and describes the character
|
|
produced when the meta key (if you have one) is depressed, and the @key{k}
|
|
key is struck. If you do not have a meta key, the identical keystroke
|
|
can be generated by typing @key{ESC} @i{first}, and then typing @key{k}.
|
|
Either process is known as @dfn{metafying} the @key{k} key.
|
|
|
|
The text @key{M-C-k} is read as `Meta-Control-k' and describes the
|
|
character produced by @dfn{metafying} @key{C-k}.
|
|
|
|
In addition, several keys have their own names. Specifically,
|
|
@key{DEL}, @key{ESC}, @key{LFD}, @key{SPC}, @key{RET}, and @key{TAB} all
|
|
stand for themselves when seen in this text, or in an init file
|
|
(@pxref{Readline Init File}, for more info).
|
|
|
|
@node Readline Interaction, Readline Init File, Introduction and Notation, Command Line Editing
|
|
@section Readline Interaction
|
|
@cindex interaction, readline
|
|
|
|
Often during an interactive session you type in a long line of text,
|
|
only to notice that the first word on the line is misspelled. The
|
|
Readline library gives you a set of commands for manipulating the text
|
|
as you type it in, allowing you to just fix your typo, and not forcing
|
|
you to retype the majority of the line. Using these editing commands,
|
|
you move the cursor to the place that needs correction, and delete or
|
|
insert the text of the corrections. Then, when you are satisfied with
|
|
the line, you simply press @key{RET}. You do not have to be at the
|
|
end of the line to press @key{RET}; the entire line is accepted
|
|
regardless of the location of the cursor within the line.
|
|
|
|
@menu
|
|
* Readline Bare Essentials:: The least you need to know about Readline.
|
|
* Readline Movement Commands:: Moving about the input line.
|
|
* Readline Killing Commands:: How to delete text, and how to get it back!
|
|
* Readline Arguments:: Giving numeric arguments to commands.
|
|
@end menu
|
|
|
|
@node Readline Bare Essentials, Readline Movement Commands, Readline Interaction, Readline Interaction
|
|
@subsection Readline Bare Essentials
|
|
|
|
In order to enter characters into the line, simply type them. The typed
|
|
character appears where the cursor was, and then the cursor moves one
|
|
space to the right. If you mistype a character, you can use @key{DEL} to
|
|
back up, and delete the mistyped character.
|
|
|
|
Sometimes you may miss typing a character that you wanted to type, and
|
|
not notice your error until you have typed several other characters. In
|
|
that case, you can type @key{C-b} to move the cursor to the left, and then
|
|
correct your mistake. Aftwerwards, you can move the cursor to the right
|
|
with @key{C-f}.
|
|
|
|
When you add text in the middle of a line, you will notice that characters
|
|
to the right of the cursor get `pushed over' to make room for the text
|
|
that you have inserted. Likewise, when you delete text behind the cursor,
|
|
characters to the right of the cursor get `pulled back' to fill in the
|
|
blank space created by the removal of the text. A list of the basic bare
|
|
essentials for editing the text of an input line follows.
|
|
|
|
@table @asis
|
|
@item @key{C-b}
|
|
Move back one character.
|
|
@item @key{C-f}
|
|
Move forward one character.
|
|
@item @key{DEL}
|
|
Delete the character to the left of the cursor.
|
|
@item @key{C-d}
|
|
Delete the character underneath the cursor.
|
|
@item @w{Printing characters}
|
|
Insert itself into the line at the cursor.
|
|
@item @key{C-_}
|
|
Undo the last thing that you did. You can undo all the way back to an
|
|
empty line.
|
|
@end table
|
|
|
|
@node Readline Movement Commands, Readline Killing Commands, Readline Bare Essentials, Readline Interaction
|
|
@subsection Readline Movement Commands
|
|
|
|
The above table describes the most basic possible keystrokes that you need
|
|
in order to do editing of the input line. For your convenience, many
|
|
other commands have been added in addition to @key{C-b}, @key{C-f},
|
|
@key{C-d}, and @key{DEL}. Here are some commands for moving more rapidly
|
|
about the line.
|
|
|
|
@table @key
|
|
@item C-a
|
|
Move to the start of the line.
|
|
@item C-e
|
|
Move to the end of the line.
|
|
@item M-f
|
|
Move forward a word.
|
|
@item M-b
|
|
Move backward a word.
|
|
@item C-l
|
|
Clear the screen, reprinting the current line at the top.
|
|
@end table
|
|
|
|
Notice how @key{C-f} moves forward a character, while @key{M-f} moves
|
|
forward a word. It is a loose convention that control keystrokes
|
|
operate on characters while meta keystrokes operate on words.
|
|
|
|
@node Readline Killing Commands, Readline Arguments, Readline Movement Commands, Readline Interaction
|
|
@subsection Readline Killing Commands
|
|
|
|
@dfn{Killing} text means to delete the text from the line, but to save
|
|
it away for later use, usually by @dfn{yanking} it back into the line.
|
|
If the description for a command says that it `kills' text, then you can
|
|
be sure that you can get the text back in a different (or the same)
|
|
place later.
|
|
|
|
Here is the list of commands for killing text.
|
|
|
|
@table @key
|
|
@item C-k
|
|
Kill the text from the current cursor position to the end of the line.
|
|
|
|
@item M-d
|
|
Kill from the cursor to the end of the current word, or if between
|
|
words, to the end of the next word.
|
|
|
|
@item M-DEL
|
|
Kill from the cursor to the start of the previous word, or if between
|
|
words, to the start of the previous word.
|
|
|
|
@item C-w
|
|
Kill from the cursor to the previous whitespace. This is different than
|
|
@key{M-DEL} because the word boundaries differ.
|
|
|
|
@end table
|
|
|
|
And, here is how to @dfn{yank} the text back into the line.
|
|
|
|
@table @key
|
|
@item C-y
|
|
Yank the most recently killed text back into the buffer at the cursor.
|
|
|
|
@item M-y
|
|
Rotate the kill-ring, and yank the new top. You can only do this if
|
|
the prior command is @key{C-y} or @key{M-y}.
|
|
@end table
|
|
|
|
When you use a kill command, the text is saved in a @dfn{kill-ring}.
|
|
Any number of consecutive kills save all of the killed text together, so
|
|
that when you yank it back, you get it in one clean sweep. The kill
|
|
ring is not line specific; the text that you killed on a previously
|
|
typed line is available to be yanked back later, when you are typing
|
|
another line.
|
|
|
|
@node Readline Arguments,, Readline Killing Commands, Readline Interaction
|
|
@subsection Readline Arguments
|
|
|
|
You can pass numeric arguments to Readline commands. Sometimes the
|
|
argument acts as a repeat count, other times it is the @i{sign} of the
|
|
argument that is significant. If you pass a negative argument to a
|
|
command which normally acts in a forward direction, that command will
|
|
act in a backward direction. For example, to kill text back to the
|
|
start of the line, you might type @key{M--} @key{C-k}.
|
|
|
|
The general way to pass numeric arguments to a command is to type meta
|
|
digits before the command. If the first `digit' you type is a minus
|
|
sign (@key{-}), then the sign of the argument will be negative. Once
|
|
you have typed one meta digit to get the argument started, you can type
|
|
the remainder of the digits, and then the command. For example, to give
|
|
the @key{C-d} command an argument of 10, you could type @key{M-1 0 C-d}.
|
|
|
|
|
|
@node Readline Init File,, Readline Interaction, Command Line Editing
|
|
@section Readline Init File
|
|
|
|
Although the Readline library comes with a set of @sc{gnu} Emacs-like
|
|
keybindings, it is possible that you would like to use a different set
|
|
of keybindings. You can customize programs that use Readline by putting
|
|
commands in an @dfn{init} file in your home directory. The name of this
|
|
file is @file{~/.inputrc}.
|
|
|
|
When a program which uses the Readline library starts up, the
|
|
@file{~/.inputrc} file is read, and the keybindings are set.
|
|
|
|
In addition, the @key{C-x C-r} command re-reads this init file, thus
|
|
incorporating any changes that you might have made to it.
|
|
|
|
@menu
|
|
* Readline Init Syntax:: Syntax for the commands in @file{~/.inputrc}.
|
|
* Readline vi Mode:: Switching to @code{vi} mode in Readline.
|
|
@end menu
|
|
|
|
@node Readline Init Syntax, Readline vi Mode, Readline Init File, Readline Init File
|
|
@subsection Readline Init Syntax
|
|
|
|
There are only four constructs allowed in the @file{~/.inputrc}
|
|
file:
|
|
|
|
@table @asis
|
|
@item Variable Settings
|
|
You can change the state of a few variables in Readline. You do this by
|
|
using the @code{set} command within the init file. Here is how you
|
|
would specify that you wish to use @code{vi} line editing commands:
|
|
|
|
@example
|
|
set editing-mode vi
|
|
@end example
|
|
|
|
Right now, there are only a few variables which can be set; so few in
|
|
fact, that we just iterate them here:
|
|
|
|
@table @code
|
|
|
|
@item editing-mode
|
|
@vindex editing-mode
|
|
The @code{editing-mode} variable controls which editing mode you are
|
|
using. By default, @sc{gnu} Readline starts up in Emacs editing mode, where
|
|
the keystrokes are most similar to Emacs. This variable can either be
|
|
set to @code{emacs} or @code{vi}.
|
|
|
|
@item horizontal-scroll-mode
|
|
@vindex horizontal-scroll-mode
|
|
This variable can either be set to @code{On} or @code{Off}. Setting it
|
|
to @code{On} means that the text of the lines that you edit will scroll
|
|
horizontally on a single screen line when they are larger than the width
|
|
of the screen, instead of wrapping onto a new screen line. By default,
|
|
this variable is set to @code{Off}.
|
|
|
|
@item mark-modified-lines
|
|
@vindex mark-modified-lines
|
|
This variable when set to @code{On}, says to display an asterisk
|
|
(@samp{*}) at the starts of history lines which have been modified.
|
|
This variable is off by default.
|
|
|
|
@item prefer-visible-bell
|
|
@vindex prefer-visible-bell
|
|
If this variable is set to @code{On} it means to use a visible bell if
|
|
one is available, rather than simply ringing the terminal bell. By
|
|
default, the value is @code{Off}.
|
|
@end table
|
|
|
|
@item Key Bindings
|
|
The syntax for controlling keybindings in the @file{~/.inputrc} file is
|
|
simple. First you have to know the @i{name} of the command that you
|
|
want to change. The following pages contain tables of the command name,
|
|
the default keybinding, and a short description of what the command
|
|
does.
|
|
|
|
Once you know the name of the command, simply place the name of the key
|
|
you wish to bind the command to, a colon, and then the name of the
|
|
command on a line in the @file{~/.inputrc} file. The name of the key
|
|
can be expressed in different ways, depending on which is most
|
|
comfortable for you.
|
|
|
|
@table @asis
|
|
@item @w{@var{keyname}: @var{function-name} or @var{macro}}
|
|
@var{keyname} is the name of a key spelled out in English. For example:
|
|
@example
|
|
Control-u: universal-argument
|
|
Meta-Rubout: backward-kill-word
|
|
Control-o: ">&output"
|
|
@end example
|
|
|
|
In the above example, @key{C-u} is bound to the function
|
|
@code{universal-argument}, and @key{C-o} is bound to run the macro
|
|
expressed on the right hand side (that is, to insert the text
|
|
@samp{>&output} into the line).
|
|
|
|
@item @w{"@var{keyseq}": @var{function-name} or @var{macro}}
|
|
@var{keyseq} differs from @var{keyname} above in that strings denoting
|
|
an entire key sequence can be specified. Simply place the key sequence
|
|
in double quotes. @sc{gnu} Emacs style key escapes can be used, as in the
|
|
following example:
|
|
|
|
@example
|
|
"\C-u": universal-argument
|
|
"\C-x\C-r": re-read-init-file
|
|
"\e[11~": "Function Key 1"
|
|
@end example
|
|
|
|
In the above example, @key{C-u} is bound to the function
|
|
@code{universal-argument} (just as it was in the first example),
|
|
@key{C-x C-r} is bound to the function @code{re-read-init-file}, and
|
|
@key{ESC [ 1 1 ~} is bound to insert the text @samp{Function Key 1}.
|
|
|
|
@end table
|
|
@end table
|
|
|
|
@menu
|
|
* Commands For Moving:: Moving about the line.
|
|
* Commands For History:: Getting at previous lines.
|
|
* Commands For Text:: Commands for changing text.
|
|
* Commands For Killing:: Commands for killing and yanking.
|
|
* Numeric Arguments:: Specifying numeric arguments, repeat counts.
|
|
* Commands For Completion:: Getting Readline to do the typing for you.
|
|
* Miscellaneous Commands:: Other miscillaneous commands.
|
|
@end menu
|
|
|
|
@need 2000
|
|
@node Commands For Moving, Commands For History, Readline Init Syntax, Readline Init Syntax
|
|
@subsubsection Commands For Moving
|
|
|
|
@ftable @code
|
|
@item beginning-of-line (@key{C-a})
|
|
Move to the start of the current line.
|
|
|
|
@item end-of-line (@key{C-e})
|
|
Move to the end of the line.
|
|
|
|
@item forward-char (@key{C-f})
|
|
Move forward a character.
|
|
|
|
@item backward-char (@key{C-b})
|
|
Move back a character.
|
|
|
|
@item forward-word (@key{M-f})
|
|
Move forward to the end of the next word.
|
|
|
|
@item backward-word (@key{M-b})
|
|
Move back to the start of this, or the previous, word.
|
|
|
|
@item clear-screen (@key{C-l})
|
|
Clear the screen leaving the current line at the top of the screen.
|
|
|
|
@end ftable
|
|
|
|
@need 2000
|
|
@node Commands For History, Commands For Text, Commands For Moving, Readline Init Syntax
|
|
@subsubsection Commands For Manipulating The History
|
|
|
|
@ftable @code
|
|
@item accept-line (Newline, Return)
|
|
Accept the line regardless of where the cursor is. If this line is
|
|
non-empty, add it to the history list. If this line was a history
|
|
line, then restore the history line to its original state.
|
|
|
|
@item previous-history (@key{C-p})
|
|
Move `up' through the history list.
|
|
|
|
@item next-history (@key{C-n})
|
|
Move `down' through the history list.
|
|
|
|
@item beginning-of-history (@key{M-<})
|
|
Move to the first line in the history.
|
|
|
|
@item end-of-history (@key{M->})
|
|
Move to the end of the input history, i.e., the line you are entering.
|
|
|
|
@item reverse-search-history (@key{C-r})
|
|
Search backward starting at the current line and moving `up' through
|
|
the history as necessary. This is an incremental search.
|
|
|
|
@item forward-search-history (@key{C-s})
|
|
Search forward starting at the current line and moving `down' through
|
|
the the history as necessary.
|
|
|
|
@end ftable
|
|
|
|
@need 2000
|
|
@node Commands For Text, Commands For Killing, Commands For History, Readline Init Syntax
|
|
@subsubsection Commands For Changing Text
|
|
|
|
@ftable @code
|
|
@item delete-char (@key{C-d})
|
|
Delete the character under the cursor. If the cursor is at the
|
|
beginning of the line, and there are no characters in the line, and
|
|
the last character typed was not @key{C-d}, then return EOF.
|
|
|
|
@item backward-delete-char (Rubout)
|
|
Delete the character behind the cursor. A numeric argument says to kill
|
|
the characters instead of deleting them.
|
|
|
|
@item quoted-insert (@key{C-q}, @key{C-v})
|
|
Add the next character that you type to the line verbatim. This is
|
|
how to insert things like @key{C-q} for example.
|
|
|
|
@item tab-insert (@key{M-TAB})
|
|
Insert a tab character.
|
|
|
|
@item self-insert (a, b, A, 1, !, ...)
|
|
Insert yourself.
|
|
|
|
@item transpose-chars (@key{C-t})
|
|
Drag the character before point forward over the character at point.
|
|
Point moves forward as well. If point is at the end of the line, then
|
|
transpose the two characters before point. Negative arguments don't work.
|
|
|
|
@item transpose-words (@key{M-t})
|
|
Drag the word behind the cursor past the word in front of the cursor
|
|
moving the cursor over that word as well.
|
|
|
|
@item upcase-word (@key{M-u})
|
|
Uppercase all letters in the current (or following) word. With a
|
|
negative argument, do the previous word, but do not move point.
|
|
|
|
@item downcase-word (@key{M-l})
|
|
Lowercase all letters in the current (or following) word. With a
|
|
negative argument, do the previous word, but do not move point.
|
|
|
|
@item capitalize-word (@key{M-c})
|
|
Uppercase the first letter in the current (or following) word. With a
|
|
negative argument, do the previous word, but do not move point.
|
|
|
|
@end ftable
|
|
|
|
@need 2000
|
|
@node Commands For Killing, Numeric Arguments, Commands For Text, Readline Init Syntax
|
|
@subsubsection Killing And Yanking
|
|
|
|
@ftable @code
|
|
@item kill-line (@key{C-k})
|
|
Kill the text from the current cursor position to the end of the line.
|
|
|
|
@item backward-kill-line ()
|
|
Kill backward to the beginning of the line. This is normally unbound.
|
|
|
|
@item kill-word (@key{M-d})
|
|
Kill from the cursor to the end of the current word, or if between
|
|
words, to the end of the next word.
|
|
|
|
@item backward-kill-word (@key{M-DEL})
|
|
Kill the word behind the cursor.
|
|
|
|
@item unix-line-discard (@key{C-u})
|
|
Kill the whole line the way @key{C-u} used to in Unix line input.
|
|
The killed text is saved on the kill-ring.
|
|
|
|
@item unix-word-rubout (@key{C-w})
|
|
Kill the word the way @key{C-w} used to in Unix line input.
|
|
The killed text is saved on the kill-ring. This is different than
|
|
backward-kill-word because the word boundaries differ.
|
|
|
|
@item yank (@key{C-y})
|
|
Yank the top of the kill ring into the buffer at point.
|
|
|
|
@item yank-pop (@key{M-y})
|
|
Rotate the kill-ring, and yank the new top. You can only do this if
|
|
the prior command is yank or yank-pop.
|
|
@end ftable
|
|
|
|
@need 2000
|
|
@node Numeric Arguments, Commands For Completion, Commands For Killing, Readline Init Syntax
|
|
@subsubsection Specifying Numeric Arguments
|
|
|
|
@ftable @code
|
|
|
|
@item digit-argument (@key{M-0}, @key{M-1}, ... @key{M--})
|
|
Add this digit to the argument already accumulating, or start a new
|
|
argument. @key{M--} starts a negative argument.
|
|
|
|
@item universal-argument ()
|
|
Do what @key{C-u} does in @sc{gnu} Emacs. By default, this is not bound.
|
|
@end ftable
|
|
|
|
|
|
@need 2000
|
|
@node Commands For Completion, Miscellaneous Commands, Numeric Arguments, Readline Init Syntax
|
|
@subsubsection Letting Readline Type For You
|
|
|
|
@ftable @code
|
|
@item complete (TAB)
|
|
Attempt to do completion on the text before point. This is
|
|
implementation defined. Generally, if you are typing a filename
|
|
argument, you can do filename completion; if you are typing a command,
|
|
you can do command completion, if you are typing in a symbol to GDB, you
|
|
can do symbol name completion, if you are typing in a variable to Bash,
|
|
you can do variable name completion.
|
|
|
|
@item possible-completions (M-?)
|
|
List the possible completions of the text before point.
|
|
@end ftable
|
|
|
|
@need 2000
|
|
@node Miscellaneous Commands,, Commands For Completion, Readline Init Syntax
|
|
@subsubsection Some Miscellaneous Commands
|
|
|
|
@ftable @code
|
|
|
|
@item re-read-init-file (@key{C-x} @key{C-r})
|
|
Read in the contents of your @file{~/.inputrc} file, and incorporate
|
|
any bindings found there.
|
|
|
|
@item abort (@key{C-g})
|
|
Stop running the current editing command.
|
|
|
|
@ignore
|
|
@c I have no idea what this means, and can't figure it out by
|
|
@c experiment, and can't find it in the readline source.
|
|
@c doc@cygnus.com, 20may1993.
|
|
@item do-uppercase-version (@key{M-a}, @key{M-b}, ...)
|
|
Run the command that is bound to your uppercase brother.
|
|
@end ignore
|
|
|
|
@item prefix-meta (ESC)
|
|
Make the next character that you type be metafied. This is for people
|
|
without a meta key. Typing @key{ESC f} is equivalent to typing
|
|
@key{M-f}.
|
|
|
|
@item undo (@key{C-_})
|
|
Incremental undo, separately remembered for each line.
|
|
|
|
@item revert-line (@key{M-r})
|
|
Undo all changes made to this line. This is like typing the `undo'
|
|
command enough times to get back to the beginning.
|
|
@end ftable
|
|
|
|
@need 2000
|
|
@node Readline vi Mode,, Readline Init Syntax, Readline Init File
|
|
@subsection Readline @code{vi} Mode
|
|
|
|
@cindex @code{vi} style command editing
|
|
@kindex toggle-editing-mode
|
|
While the Readline library does not have a full set of @code{vi} editing
|
|
functions, it does contain enough to allow simple editing of the line.
|
|
|
|
In order to switch interactively between @sc{gnu} Emacs and @code{vi}
|
|
editing modes, use the command @key{M-C-j} (toggle-editing-mode).
|
|
|
|
When you enter a line in @code{vi} mode, you are already placed in `insertion'
|
|
mode, as if you had typed an `i'. Pressing @key{ESC} switches you into
|
|
`edit' mode, where you can edit the text of the line with the standard
|
|
@code{vi} movement keys, move to previous history lines with `k', and following
|
|
lines with `j', and so forth.
|
|
|