@chapter The Minibuffer
@cindex minibuffer
- Emacs commands use the @dfn{minibuffer} to read arguments more
-complicated than a single number. Minibuffer arguments can be file
-names, buffer names, Lisp function names, Emacs command names, Lisp
-expressions, and many other things, depending on the command reading the
-argument. To edit the argument in the minibuffer, you can use Emacs
-editing commands.
-
+ The @dfn{minibuffer} is the facility used by XEmacs commands to read
+arguments more complicated than a single number. Minibuffer arguments
+can be file names, buffer names, Lisp function names, XEmacs command
+names, Lisp expressions, and many other things, depending on the command
+reading the argument. You can use the usual XEmacs editing commands in
+the minibuffer to edit the argument text.
@cindex prompt
When the minibuffer is in use, it appears in the echo area, and the
cursor moves there. The beginning of the minibuffer line displays a
-@dfn{prompt} indicating what kind of input you should supply and how it
-will be used. The prompt is often derived from the name of the command
-the argument is for. The prompt normally ends with a colon.
+@dfn{prompt} which says what kind of input you should supply and how it
+will be used. Often this prompt is derived from the name of the command
+that the argument is for. The prompt normally ends with a colon.
@cindex default argument
Sometimes a @dfn{default argument} appears in parentheses after the
is the name of the buffer that will be used if you type just @key{RET}.
@kindex C-g
- The simplest way to give a minibuffer argument is to type the text you
-want, terminated by @key{RET} to exit the minibuffer. To get out
-of the minibuffer and cancel the command that it was for, type
-@kbd{C-g}.
+ The simplest way to enter a minibuffer argument is to type the text
+you want, terminated by @key{RET} which exits the minibuffer. You can
+cancel the command that wants the argument, and get out of the
+minibuffer, by typing @kbd{C-g}.
Since the minibuffer uses the screen space of the echo area, it can
-conflict with other ways Emacs customarily uses the echo area. Here is how
-Emacs handles such conflicts:
+conflict with other ways XEmacs customarily uses the echo area. Here is
+how XEmacs handles such conflicts:
@itemize @bullet
@item
anything.
@item
-If you use a command in the minibuffer whose purpose is to print a
-message in the echo area (for example @kbd{C-x =}) the message is
-displayed normally, and the minibuffer is hidden for a while. It comes back
+If in the minibuffer you use a command whose purpose is to print a
+message in the echo area, such as @kbd{C-x =}, the message is printed
+normally, and the minibuffer is hidden for a while. It comes back
after a few seconds, or as soon as you type anything.
@item
* File: Minibuffer File. Entering file names with the minibuffer.
* Edit: Minibuffer Edit. How to edit in the minibuffer.
* Completion:: An abbreviation facility for minibuffer input.
+* Minibuffer History:: Reusing recent minibuffer arguments.
* Repetition:: Re-executing commands that used the minibuffer.
@end menu
Sometimes the minibuffer starts out with text in it. For example, when
you are supposed to give a file name, the minibuffer starts out containing
-the @dfn{default directory}, which ends with a slash. This informs
-you in which directory the file will be looked for if you do not specify
-a different one. For example, the minibuffer might start out with:
+the @dfn{default directory}, which ends with a slash. This is to inform
+you which directory the file will be found in if you do not specify a
+directory.
+
+ For example, the minibuffer might start out with these contents:
@example
Find File: /u2/emacs/src/
@end example
@noindent
-where @samp{Find File:@: } is the prompt. Typing @kbd{buffer.c} specifies
-the file
-@*@file{/u2/emacs/src/buffer.c}. To find files in nearby
-directories, use @samp{..}; thus, if you type @kbd{../lisp/simple.el}, the
-file that you visit will be the one named
-@*@file{/u2/emacs/lisp/simple.el}.
-Alternatively, you can use @kbd{M-@key{DEL}} to kill directory names you
-don't want (@pxref{Words}).@refill
-
- You can also type an absolute file name, one starting with a slash or a
-tilde, ignoring the default directory. For example, to find the file
-@file{/etc/termcap}, just type the name, giving:
+where @samp{Find File:@: } is the prompt. Typing @kbd{buffer.c}
+specifies the file @file{/u2/emacs/src/buffer.c}. To find files in
+nearby directories, use @kbd{..}; thus, if you type
+@kbd{../lisp/simple.el}, you will get the file named
+@file{/u2/emacs/lisp/simple.el}. Alternatively, you can kill with
+@kbd{M-@key{DEL}} the directory names you don't want (@pxref{Words}).
+
+ If you don't want any of the default, you can kill it with @kbd{C-a
+C-k}. But you don't need to kill the default; you can simply ignore it.
+Insert an absolute file name, one starting with a slash or a tilde,
+after the default directory. For example, to specify the file
+@file{/etc/termcap}, just insert that name, giving these minibuffer
+contents:
@example
Find File: /u2/emacs/src//etc/termcap
@end example
@noindent
-Two slashes in a row are not normally meaningful in Unix file names, but
-they are allowed in XEmacs. They mean, ``ignore everything before the
-second slash in the pair.'' Thus, @samp{/u2/emacs/src/} is ignored, and
-you get the file @file{/etc/termcap}.
+@cindex // in file name
+@cindex double slash in file name
+@cindex slashes repeated in file name
+XEmacs gives a special meaning to a double slash (which is not normally
+a useful thing to write): it means, ``ignore everything before the
+second slash in the pair.'' Thus, @samp{/u2/emacs/src/} is ignored in
+the example above, and you get the file @file{/etc/termcap}.
@vindex insert-default-directory
If you set @code{insert-default-directory} to @code{nil}, the default
@node Minibuffer Edit, Completion, Minibuffer File, Minibuffer
@section Editing in the Minibuffer
- The minibuffer is an Emacs buffer (albeit a peculiar one), and the usual
-Emacs commands are available for editing the text of an argument you are
-entering.
+ The minibuffer is an XEmacs buffer (albeit a peculiar one), and the
+usual XEmacs commands are available for editing the text of an argument
+you are entering.
Since @key{RET} in the minibuffer is defined to exit the minibuffer,
-you must use @kbd{C-o} or @kbd{C-q @key{LFD}} to insert a newline into
-the minibuffer. (Recall that a newline is really the @key{LFD}
-character.)
-
- The minibuffer has its own window, which always has space on the screen
-but acts as if it were not there when the minibuffer is not in use. The
-minibuffer window is just like the others; you can switch to another
-window with @kbd{C-x o}, edit text in other windows, and perhaps even
-visit more files before returning to the minibuffer to submit the
-argument. You can kill text in another window, return to the minibuffer
-window, and then yank the text to use it in the argument. @xref{Windows}.
-
- There are, however, some restrictions on the use of the minibuffer window.
-You cannot switch buffers in it---the minibuffer and its window are
-permanently attached. You also cannot split or kill the minibuffer
-window, but you can make it taller with @kbd{C-x ^}.
+you can't use it to insert a newline in the minibuffer. To do that,
+type @kbd{C-o} or @kbd{C-q C-j}. (Recall that a newline is really the
+character control-J.)
+
+ The minibuffer has its own window which always has space on the screen
+but acts as if it were not there when the minibuffer is not in use.
+When the minibuffer is in use, its window is just like the others; you
+can switch to another window with @kbd{C-x o}, edit text in other
+windows and perhaps even visit more files, before returning to the
+minibuffer to submit the argument. You can kill text in another window,
+return to the minibuffer window, and then yank the text to use it in the
+argument. @xref{Windows}.
+
+ There are some restrictions on the use of the minibuffer window,
+however. You cannot switch buffers in it---the minibuffer and its
+window are permanently attached. Also, you cannot split or kill the
+minibuffer window. But you can make it taller in the normal fashion with
+@kbd{C-x ^}.
@kindex C-M-v
- If you are in the minibuffer and issue a command that displays help
-text in another window, that window will be scrolled if you type
-@kbd{M-C-v} while in the minibuffer until you exit the minibuffer. This
-feature is helpful if a completing minibuffer gives you a long list of
-possible completions.
+ If while in the minibuffer you issue a command that displays help text
+of any sort in another window, you can use the @kbd{C-M-v} command while
+in the minibuffer to scroll the help text. This lasts until you exit
+the minibuffer. This feature is especially useful if a completing
+minibuffer gives you a list of possible completions. @xref{Other Window}.
+@vindex minibuffer-confirm-incomplete
If the variable @code{minibuffer-confirm-incomplete} is @code{t}, you
are asked for confirmation if there is no known completion for the text
you typed. For example, if you attempted to visit a non-existent file,
the minibuffer might read:
@example
- Find File:chocolate_bar.c [no completions, confirm]
+ Find File: chocolate_bar.c [no completions, confirm]
@end example
If you press @kbd{Return} again, that confirms the filename. Otherwise,
you can continue editing it.
- Emacs supports recursive use of the minibuffer. However, it is
-easy to do this by accident (because of autorepeating keyboards, for
-example) and get confused. Therefore, most Emacs commands that use the
-minibuffer refuse to operate if the minibuffer window is selected. If the
-minibuffer is active but you have switched to a different window, recursive
-use of the minibuffer is allowed---if you know enough to try to do this,
-you probably will not get confused.
+ XEmacs supports recursive use of the minibuffer. However, it is easy
+to do this by accident (because of autorepeating keyboards, for example)
+and get confused. Therefore, most XEmacs commands that use the
+minibuffer refuse to operate if the minibuffer window is selected. If
+the minibuffer is active but you have switched to a different window,
+recursive use of the minibuffer is allowed---if you know enough to try
+to do this, you probably will not get confused.
@vindex enable-recursive-minibuffers
- If you set the variable @code{enable-recursive-minibuffers} to be
+ If you set the variable @code{enable-recursive-minibuffers} to a
non-@code{nil}, recursive use of the minibuffer is always allowed.
-@node Completion, Repetition, Minibuffer Edit, Minibuffer
+@node Completion, Minibuffer History, Minibuffer Edit, Minibuffer
@section Completion
@cindex completion
- When appropriate, the minibuffer provides a @dfn{completion} facility.
-You type the beginning of an argument and one of the completion keys,
-and Emacs visibly fills in the rest, depending on what you have already
-typed.
+ For certain kinds of arguments, you can use @dfn{completion} to enter
+the argument value. Completion means that you type part of the
+argument, then XEmacs visibly fills in the rest, or as much as
+can be determined from the part you have typed.
When completion is available, certain keys---@key{TAB}, @key{RET}, and
-@key{SPC}---are redefined to complete an abbreviation present in the
+@key{SPC}---are rebound to complete the text present in the
minibuffer into a longer string that it stands for, by matching it
against a set of @dfn{completion alternatives} provided by the command
reading the argument. @kbd{?} is defined to display a list of possible
completions of what you have inserted.
- For example, when the minibuffer is being used by @kbd{Meta-x} to read
-the name of a command, it is given a list of all available Emacs command
-names to complete against. The completion keys match the text in the
-minibuffer against all the command names, find any additional characters of
-the name that are implied by the ones already present in the minibuffer,
-and add those characters to the ones you have given.
-
- Case is normally significant in completion because it is significant in
-most of the names that you can complete (buffer names, file names, and
-command names). Thus, @samp{fo} will not complete to @samp{Foo}. When you
-are completing a name in which case does not matter, case may be ignored
-for completion's sake if specified by program.
+ For example, when @kbd{M-x} uses the minibuffer to read the name of a
+command, it provides a list of all available XEmacs command names to
+complete against. The completion keys match the text in the minibuffer
+against all the command names, find any additional name characters
+implied by the ones already present in the minibuffer, and add those
+characters to the ones you have given. This is what makes it possible
+to type @kbd{M-x inse @key{SPC} b @key{RET}} instead of @kbd{M-x
+insert-buffer @key{RET}} (for example).
+
+ Case is normally significant in completion because it is significant
+in most of the names that you can complete (buffer names, file names and
+command names). Thus, @samp{fo} does not complete to @samp{Foo}. When
+you are completing a name in which case does not matter, case may be
+ignored for completion's sake if specified by program.
When a completion list is displayed, the completions will highlight as
you move the mouse over them. Clicking the middle mouse button on any
highlighted completion will ``select'' it just as if you had typed it in
and hit @key{RET}.
-@subsection A Completion Example
+@menu
+* Example: Completion Example.
+* Commands: Completion Commands.
+* Strict Completion::
+* Options: Completion Options.
+@end menu
+
+@node Completion Example, Completion Commands, Completion, Completion
+@subsection Completion Example
@kindex TAB
@findex minibuffer-complete
- Consider the following example. If you type @kbd{Meta-x au @key{TAB}},
-@key{TAB} looks for alternatives (in this case, command names) that
-start with @samp{au}. There are only two commands: @code{auto-fill-mode} and
-@code{auto-save-mode}. They are the same as far as @code{auto-}, so the
-@samp{au} in the minibuffer changes to @samp{auto-}.@refill
-
- If you type @key{TAB} again immediately, there are multiple possibilities
-for the very next character---it could be @samp{s} or @samp{f}---so no more
-characters are added; but a list of all possible completions is displayed
-in another window.
+ A concrete example may help here. If you type @kbd{M-x au @key{TAB}},
+the @key{TAB} looks for alternatives (in this case, command names) that
+start with @samp{au}. There are several, including
+@code{auto-fill-mode} and @code{auto-save-mode}---but they are all the
+same as far as @code{auto}, so the @samp{au} in the minibuffer changes
+to @samp{auto}.
+
+ If you type @key{TAB} again immediately, there are multiple
+possibilities for the very next character---it could be any of
+@samp{c-}---so no more characters are added; instead, @key{TAB}
+displays a list of all possible completions in another window.
If you go on to type @kbd{f @key{TAB}}, this @key{TAB} sees
@samp{auto-f}. The only command name starting this way is
-@code{auto-fill-mode}, so completion inserts the rest of that command. You
-now have @samp{auto-fill-mode} in the minibuffer after typing just @kbd{au
-@key{TAB} f @key{TAB}}. Note that @key{TAB} has this effect because in the
-minibuffer it is bound to the function @code{minibuffer-complete} when
-completion is supposed to be done.@refill
+@code{auto-fill-mode}, so completion fills in the rest of that. You now
+have @samp{auto-fill-mode} in the minibuffer after typing just @kbd{au
+@key{TAB} f @key{TAB}}. Note that @key{TAB} has this effect because in
+the minibuffer it is bound to the command @code{minibuffer-complete}
+when completion is available.
+@node Completion Commands, Strict Completion, Completion Example, Completion
@subsection Completion Commands
- Here is a list of all the completion commands defined in the minibuffer
+ Here is a list of the completion commands defined in the minibuffer
when completion is available.
@table @kbd
@item @key{TAB}
-Complete the text in the minibuffer as much as possible @*
+Complete the text in the minibuffer as much as possible
(@code{minibuffer-complete}).
@item @key{SPC}
-Complete the text in the minibuffer but don't add or fill out more
-than one word (@code{minibuffer-complete-word}).
+Complete the minibuffer text, but don't go beyond one word
+(@code{minibuffer-complete-word}).
@item @key{RET}
Submit the text in the minibuffer as the argument, possibly completing
first as described below (@code{minibuffer-complete-and-exit}).
@kindex SPC
@findex minibuffer-complete-word
-@key{SPC} completes in a way that is similar to @key{TAB}, but it never
-goes beyond the next hyphen or space. If you have @samp{auto-f} in the
-minibuffer and type @key{SPC}, it finds that the completion is
- @samp{auto-fill-mode}, but it stops completing after @samp{fill-}.
-The result is @samp{auto-fill-}. Another @key{SPC} at this point
-completes all the way to @samp{auto-fill-mode}. @key{SPC} in the
-minibuffer runs the function @code{minibuffer-complete-word} when
-completion is available.@refill
+ @key{SPC} completes much like @key{TAB}, but never goes beyond the
+next hyphen or space. If you have @samp{auto-f} in the minibuffer and
+type @key{SPC}, it finds that the completion is @samp{auto-fill-mode},
+but it stops completing after @samp{fill-}. This gives
+@samp{auto-fill-}. Another @key{SPC} at this point completes all the
+way to @samp{auto-fill-mode}. @key{SPC} in the minibuffer when
+completion is available runs the command
+@code{minibuffer-complete-word}.
+
+ Here are some commands you can use to choose a completion from a
+window that displays a list of completions:
+
+@table @kbd
+@findex mouse-choose-completion
+@item button2up
+Clicking mouse button 2 on a completion in the list of possible
+completions chooses that completion (@code{mouse-choose-completion}).
+You normally use this command while point is in the minibuffer; but you
+must click in the list of completions, not in the minibuffer itself.
+
+@findex choose-completion
+@item @key{RET}
+Typing @key{RET} @emph{in the completion list buffer} chooses the
+completion that point is in or next to (@code{choose-completion}). To
+use this command, you must first switch windows to the window that shows
+the list of completions.
+
+@findex next-list-mode-item
+@item @key{RIGHT}
+@itemx @key{TAB}
+@itemx C-f
+Typing the right-arrow key @key{RIGHT}, @key{TAB} or @kbd{C-f} @emph{in
+the completion list buffer} moves point to the following completion
+(@code{next-list-mode-item}).
+
+@findex previous-list-mode-item
+@item @key{LEFT}
+@itemx C-b
+Typing the left-arrow key @key{LEFT} or @kbd{C-b} @emph{in the
+completion list buffer} moves point toward the beginning of the buffer,
+to the previous completion (@code{previous-list-mode-item}).
+@end table
+
+@node Strict Completion, Completion Options, Completion Commands, Completion
+@subsection Strict Completion
There are three different ways that @key{RET} can work in completing
minibuffers, depending on how the argument will be used.
already exist.
@item
-@dfn{Permissive} completion is used when any string is
+@dfn{Permissive} completion is used when any string whatever is
meaningful, and the list of completion alternatives is just a guide.
For example, when @kbd{C-x C-f} reads the name of a file to visit, any
file name is allowed, in case you want to create a file. In
exactly as given, without completing it.
@end itemize
- The completion commands display a list of all possible completions in a
-window whenever there is more than one possibility for the very next
-character. Typing @kbd{?} explicitly requests such a list. The
-list of completions counts as help text, so @kbd{C-M-v} typed in the
-minibuffer scrolls the list.
+ The completion commands display a list of all possible completions in
+a window whenever there is more than one possibility for the very next
+character. Also, typing @kbd{?} explicitly requests such a list. If
+the list of completions is long, you can scroll it with @kbd{C-M-v}
+(@pxref{Other Window}).
+
+@node Completion Options, , Strict Completion, Completion
+@subsection Completion Options
@vindex completion-ignored-extensions
When completion is done on file names, certain file names are usually
-ignored. The variable @code{completion-ignored-extensions} contains a list
-of strings; a file whose name ends in any of those strings is ignored as a
-possible completion. The standard value of this variable has several
-elements including @code{".o"}, @code{".elc"}, @code{".dvi"} and @code{"~"}.
-The effect is that, for example, @samp{foo} completes to @samp{foo.c}
-even though @samp{foo.o} exists as well. If the only possible completions
-are files that end in ``ignored'' strings, they are not ignored.@refill
+ignored. The variable @code{completion-ignored-extensions} contains a
+list of strings; a file whose name ends in any of those strings is
+ignored as a possible completion. The standard value of this variable
+has several elements including @code{".o"}, @code{".elc"}, @code{".dvi"}
+and @code{"~"}. The effect is that, for example, @samp{foo} can
+complete to @samp{foo.c} even though @samp{foo.o} exists as well.
+However, if @emph{all} the possible completions end in ``ignored''
+strings, then they are not ignored. Ignored extensions do not apply to
+lists of completions---those always mention all possible completions.
@vindex completion-auto-help
If a completion command finds the next character is undetermined, it
not valid completions, an extra @key{RET} must be typed to confirm the
response. This is helpful for catching typos.
-@node Repetition,, Completion, Minibuffer
+@node Minibuffer History, Repetition, Completion, Minibuffer
+@section Minibuffer History
+@cindex minibuffer history
+@cindex history of minibuffer input
+
+ Every argument that you enter with the minibuffer is saved on a
+@dfn{minibuffer history list} so that you can use it again later in
+another argument. Special commands load the text of an earlier argument
+in the minibuffer. They discard the old minibuffer contents, so you can
+think of them as moving through the history of previous arguments.
+
+@table @kbd
+@item @key{UP}
+@itemx M-p
+Move to the next earlier argument string saved in the minibuffer history
+(@code{previous-history-element}).
+@item @key{DOWN}
+@itemx M-n
+Move to the next later argument string saved in the minibuffer history
+(@code{next-history-element}).
+@item M-r @var{regexp} @key{RET}
+Move to an earlier saved argument in the minibuffer history that has a
+match for @var{regexp} (@code{previous-matching-history-element}).
+@item M-s @var{regexp} @key{RET}
+Move to a later saved argument in the minibuffer history that has a
+match for @var{regexp} (@code{next-matching-history-element}).
+@end table
+
+@kindex M-p @r{(minibuffer history)}
+@kindex M-n @r{(minibuffer history)}
+@findex next-history-element
+@findex previous-history-element
+ The simplest way to reuse the saved arguments in the history list is
+to move through the history list one element at a time. While in the
+minibuffer, use @kbd{M-p} or up-arrow (@code{previous-history-element})
+to ``move to'' the next earlier minibuffer input, and use @kbd{M-n} or
+down-arrow (@code{next-history-element}) to ``move to'' the next later
+input.
+
+ The previous input that you fetch from the history entirely replaces
+the contents of the minibuffer. To use it as the argument, exit the
+minibuffer as usual with @key{RET}. You can also edit the text before
+you reuse it; this does not change the history element that you
+``moved'' to, but your new argument does go at the end of the history
+list in its own right.
+
+ For many minibuffer arguments there is a ``default'' value. In some
+cases, the minibuffer history commands know the default value. Then you
+can insert the default value into the minibuffer as text by using
+@kbd{M-n} to move ``into the future'' in the history.
+
+@findex previous-matching-history-element
+@findex next-matching-history-element
+@kindex M-r @r{(minibuffer history)}
+@kindex M-s @r{(minibuffer history)}
+ There are also commands to search forward or backward through the
+history; they search for history elements that match a regular
+expression that you specify with the minibuffer. @kbd{M-r}
+(@code{previous-matching-history-element}) searches older elements in
+the history, while @kbd{M-s} (@code{next-matching-history-element})
+searches newer elements. By special dispensation, these commands can
+use the minibuffer to read their arguments even though you are already
+in the minibuffer when you issue them. As with incremental searching,
+an uppercase letter in the regular expression makes the search
+case-sensitive (@pxref{Search Case}).
+
+ All uses of the minibuffer record your input on a history list, but
+there are separate history lists for different kinds of arguments. For
+example, there is a list for file names, used by all the commands that
+read file names.
+
+ There are several other very specific history lists, including one for
+command names read by @kbd{M-x}, one for buffer names, one for arguments
+of commands like @code{query-replace}, and one for compilation commands
+read by @code{compile}. Finally, there is one ``miscellaneous'' history
+list that most minibuffer arguments use.
+
+@c Do wee need this?
+@ignore
+@vindex history-length
+ The variable @code{history-length} specifies the maximum length of a
+minibuffer history list; once a list gets that long, the oldest element
+is deleted each time an element is added. If the value of
+@code{history-length} is @code{t}, though, there is no maximum length
+and elements are never deleted.
+@end ignore
+
+@node Repetition, , Minibuffer History, Minibuffer
@section Repeating Minibuffer Commands
@cindex command history
@cindex history of commands
Every command that uses the minibuffer at least once is recorded on a
-special history list, together with the values of the minibuffer arguments,
-so that you can repeat the command easily. In particular, every
-use of @kbd{Meta-x} is recorded, since @kbd{M-x} uses the minibuffer to
-read the command name.
+special history list, together with the values of its arguments, so that
+you can repeat the entire command. In particular, every use of
+@kbd{M-x} is recorded there, since @kbd{M-x} uses the minibuffer to read
+the command name.
@findex list-command-history
@c widecommands
@table @kbd
-@item C-x @key{ESC}
-Re-execute a recent minibuffer command @*(@code{repeat-complex-command}).
+@item C-x @key{ESC} @key{ESC}
+Re-execute a recent minibuffer command (@code{repeat-complex-command}).
@item M-p
Within @kbd{C-x @key{ESC}}, move to previous recorded command
(@code{previous-history-element}).
@item M-n
Within @kbd{C-x @key{ESC}}, move to the next (more recent) recorded
-command (@code{next-history-element}).@refill
+command (@code{next-history-element}).
@item M-x list-command-history
Display the entire command history, showing all the commands
-@kbd{C-x @key{ESC}} can repeat, most recent first.@refill
+@kbd{C-x @key{ESC} @key{ESC}} can repeat, most recent first.
@end table
-@kindex C-x ESC
+@kindex C-x ESC ESC
@findex repeat-complex-command
- @kbd{C-x @key{ESC}} is used to re-execute a recent command that used
-the minibuffer. With no argument, it repeats the last command. A numeric
-argument specifies which command to repeat; 1 means the last one, and
-larger numbers specify earlier commands.
-
- @kbd{C-x @key{ESC}} works by turning the previous command into a Lisp
-expression and then entering a minibuffer initialized with the text for
-that expression. If you type just @key{RET}, the command is repeated as
-before. You can also change the command by editing the Lisp expression.
-The expression you finally submit will be executed. The repeated
-command is added to the front of the command history unless it is
-identical to the most recently executed command already there.
+ @kbd{C-x @key{ESC} @key{ESC}} is used to re-execute a recent
+minibuffer-using command. With no argument, it repeats the last such
+command. A numeric argument specifies which command to repeat; one
+means the last one, and larger numbers specify earlier ones.
+
+ @kbd{C-x @key{ESC} @key{ESC}} works by turning the previous command
+into a Lisp expression and then entering a minibuffer initialized with
+the text for that expression. If you type just @key{RET}, the command
+is repeated as before. You can also change the command by editing the
+Lisp expression. Whatever expression you finally submit is what will be
+executed. The repeated command is added to the front of the command
+history unless it is identical to the most recently executed command
+already there.
Even if you don't understand Lisp syntax, it will probably be obvious
which command is displayed for repetition. If you do not change the text,
@kindex M-p
@findex next-complex-command
@findex previous-complex-command
- If you are in the minibuffer for @kbd{C-x @key{ESC}} and the command shown
-to you is not the one you want to repeat, you can move around the list of
-previous commands using @kbd{M-n} and @kbd{M-p}. @kbd{M-p} replaces the
-contents of the minibuffer with the next earlier recorded command, and
-@kbd{M-n} replaces it with the next later command. After finding the
-desired previous command, you can edit its expression and then
-resubmit it by typing @key{RET}. Any editing you have done on the
-command to be repeated is lost if you use @kbd{M-n} or @kbd{M-p}.
-
-@kbd{M-n} and @kbd{M-p} are specially defined within @kbd{C-x @key{ESC}}
-to run the commands @code{previous-history-element} and
+ If you are in the minibuffer for @kbd{C-x @key{ESC} @key{ESC}} and the
+command shown to you is not the one you want to repeat, you can move
+around the list of previous commands using @kbd{M-n} and @kbd{M-p}.
+@kbd{M-p} replaces the contents of the minibuffer with the next earlier
+recorded command, and @kbd{M-n} replaces it with the next later command.
+After finding the desired previous command, you can edit its expression
+and then resubmit it by typing @key{RET}. Any editing you have done on
+the command to be repeated is lost if you use @kbd{M-n} or @kbd{M-p}.
+
+@kbd{M-n} and @kbd{M-p} are specially defined within @kbd{C-x @key{ESC}
+@key{ESC}} to run the commands @code{previous-history-element} and
@code{next-history-element}.
@vindex command-history
projects / chise / xemacs-chise.git.1 / blobdiff