659 lines
28 KiB
Text
659 lines
28 KiB
Text
@c This is part of the Emacs manual.
|
|
@c Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 2000, 2001,
|
|
@c 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
|
|
@c See file emacs.texi for copying conditions.
|
|
@node Minibuffer, M-x, Basic, Top
|
|
@chapter The Minibuffer
|
|
@cindex minibuffer
|
|
|
|
The @dfn{minibuffer} is where Emacs commands read complicated
|
|
arguments, such as file names, buffer names, Emacs command names, or
|
|
Lisp expressions. We call it the ``minibuffer'' because it's a
|
|
special-purpose buffer with a small amount of screen space. You can
|
|
use the usual Emacs editing commands in the minibuffer to edit the
|
|
argument text.
|
|
|
|
@cindex prompt
|
|
When the minibuffer is in use, it appears in the echo area, with a
|
|
cursor. The minibuffer display starts with a @dfn{prompt} in a
|
|
distinct color, usually ending with a colon. The prompt states what
|
|
kind of input is expected, and how it will be used.
|
|
|
|
The simplest way to enter a minibuffer argument is to type the text,
|
|
then @key{RET} to submit the argument and exit the minibuffer. You
|
|
can cancel the minibuffer, and the command that wants the argument, by
|
|
typing @kbd{C-g}.
|
|
|
|
@cindex default argument
|
|
Sometimes, a @dfn{default argument} appears in the prompt, inside
|
|
parentheses before the colon. The default will be used as the
|
|
argument value if you just type @key{RET}. For example, commands that
|
|
read buffer names usually show a buffer name as the default; you can
|
|
type @key{RET} to operate on that default buffer.
|
|
|
|
Since the minibuffer appears in the echo area, it can conflict with
|
|
other uses of the echo area. If an error occurs while the minibuffer
|
|
is active, the error message hides the minibuffer for a few seconds,
|
|
or until you type something; then the minibuffer comes back. If a
|
|
command such as @kbd{C-x =} needs to display a message in the echo
|
|
area, the message hides the minibuffer for a few seconds, or until you
|
|
type something; then the minibuffer comes back. While the minibuffer
|
|
is in use, keystrokes do not echo.
|
|
|
|
@menu
|
|
* Minibuffer File:: Entering file names with the minibuffer.
|
|
* 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.
|
|
* Passwords:: Entering passwords in the echo area.
|
|
@end menu
|
|
|
|
@node Minibuffer File
|
|
@section Minibuffers for File Names
|
|
|
|
Commands such as @kbd{C-x C-f} (@code{find-file}) use the minibuffer
|
|
to read a file name argument (@pxref{Basic Files}). When the
|
|
minibuffer is used to read a file name, it typically starts out with
|
|
some initial text ending in a slash. This is the @dfn{default
|
|
directory}. For example, it may start out like this:
|
|
|
|
@example
|
|
Find File: /u2/emacs/src/
|
|
@end example
|
|
|
|
@noindent
|
|
Here, @samp{Find File:@: } is the prompt and @samp{/u2/emacs/src/} is
|
|
the default directory. If you now type @kbd{buffer.c} as input, that
|
|
specifies the file @file{/u2/emacs/src/buffer.c}. @xref{File Names},
|
|
for information about the default directory.
|
|
|
|
You can specify the parent directory by adding @file{..}: for
|
|
example, @file{/u2/emacs/src/../lisp/simple.el} is equivalent to
|
|
@file{/u2/emacs/lisp/simple.el}. Alternatively, you can use
|
|
@kbd{M-@key{DEL}} to kill directory names backwards (@pxref{Words}).
|
|
|
|
To specify a file in a completely different directory, you can kill
|
|
the entire default with @kbd{C-a C-k} (@pxref{Minibuffer Edit}).
|
|
Alternatively, you can ignore the default, and enter an absolute file
|
|
name starting with a slash or a tilde after the default directory.
|
|
For example, you can specify @file{/etc/termcap} as follows:
|
|
|
|
@example
|
|
Find File: /u2/emacs/src//etc/termcap
|
|
@end example
|
|
|
|
@noindent
|
|
@cindex // in file name
|
|
@cindex double slash in file name
|
|
@cindex slashes repeated in file name
|
|
@findex file-name-shadow-mode
|
|
Emacs interprets a double slash as ``ignore everything before the
|
|
second slash in the pair.'' In the example above,
|
|
@file{/u2/emacs/src/} is ignored, so the argument you supplied is
|
|
@file{/etc/termcap}. The ignored part of the file name is dimmed if
|
|
the terminal allows it (to disable this dimming, turn off File Name
|
|
Shadow mode with the command @kbd{M-x file-name-shadow-mode}.)
|
|
|
|
@cindex home directory shorthand
|
|
Emacs interprets @file{~/} as your home directory. Thus,
|
|
@file{~/foo/bar.txt} specifies a file named @file{bar.txt}, inside a
|
|
directory named @file{foo}, which is in turn located in your home
|
|
directory. In addition, @file{~@var{user-id}/} means the home
|
|
directory of a user whose login name is @var{user-id}. Any leading
|
|
directory name in front of the @file{~} is ignored: thus,
|
|
@file{/u2/emacs/~/foo/bar.txt} is equivalent to @file{~/foo/bar.txt}.
|
|
|
|
On MS-Windows and MS-DOS systems, where a user doesn't always have a
|
|
home directory, Emacs uses several alternatives. For MS-Windows, see
|
|
@ref{Windows HOME}; for MS-DOS, see
|
|
@ifnottex
|
|
@ref{MS-DOS File Names, HOME on MS-DOS}.
|
|
@end ifnottex
|
|
@iftex
|
|
@ref{MS-DOS File Names, HOME on MS-DOS,, emacs, the Emacs Manual}, in
|
|
the main Emacs manual.
|
|
@end iftex
|
|
On these systems, the @file{~@var{user-id}/} construct is supported
|
|
only for the current user, i.e., only if @var{user-id} is the current
|
|
user's login name.
|
|
|
|
@vindex insert-default-directory
|
|
To prevent Emacs from inserting the default directory when reading
|
|
file names, change the variable @code{insert-default-directory} to
|
|
@code{nil}. In that case, the minibuffer starts out empty.
|
|
Nonetheless, relative file name arguments are still interpreted based
|
|
on the same default directory.
|
|
|
|
@node Minibuffer Edit
|
|
@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 argument text.
|
|
(The prompt, however, is @dfn{read-only}, and cannot be changed.)
|
|
|
|
Since @key{RET} in the minibuffer is defined to exit the minibuffer,
|
|
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}. (The newline character is really the
|
|
@acronym{ASCII} character control-J.)
|
|
|
|
Inside a minibuffer, the keys @kbd{@key{TAB}}, @kbd{@key{SPC}}, and
|
|
@kbd{@key{?}} are often bound to commands that perform
|
|
@dfn{completion}. @xref{Completion}. You can use @kbd{C-q}
|
|
(@code{quoted-insert}) to insert a @key{TAB}, @key{SPC}, or @key{?}
|
|
character. For example, @kbd{C-q @key{TAB}} inserts a @key{TAB}
|
|
character. @xref{Inserting Text}.
|
|
|
|
For convenience, @kbd{C-a} (@code{move-beginning-of-line}) in a
|
|
minibuffer moves point to the beginning of the argument text, not the
|
|
beginning of the prompt. For example, this allows you to erase the
|
|
entire argument with @kbd{C-a C-k}.
|
|
|
|
@cindex height of minibuffer
|
|
@cindex size of minibuffer
|
|
@cindex growing minibuffer
|
|
@cindex resizing minibuffer
|
|
When the minibuffer is active, the echo area is treated much like an
|
|
ordinary Emacs window. For instance, you can switch to another window
|
|
(with @kbd{C-x o}), edit text there, then return to the minibuffer
|
|
window to finish the argument. You can even kill text in another
|
|
window, return to the minibuffer window, and yank the text into the
|
|
argument. There are some restrictions on the minibuffer window,
|
|
however: for instance, you cannot split it. @xref{Windows}.
|
|
|
|
@vindex resize-mini-windows
|
|
Normally, the minibuffer window occupies a single screen line.
|
|
However, if you add two or more lines' worth of text into the
|
|
minibuffer, it expands automatically to accomodate the text. The
|
|
variable @code{resize-mini-windows} controls the resizing of the
|
|
minibuffer. The default value is @code{grow-only}, which means the
|
|
behavior we have just described. If the value is @code{t}, the
|
|
minibuffer window will also shrink automatically if you remove some
|
|
lines of text from the minibuffer, down to a minimum of one screen
|
|
line. If the value is @code{nil}, the minibuffer window never changes
|
|
size automatically, but you can use the usual window-resizing commands
|
|
on it (@pxref{Windows}).
|
|
|
|
@vindex max-mini-window-height
|
|
The variable @code{max-mini-window-height} controls the maximum
|
|
height for resizing the minibuffer window. A floating-point number
|
|
specifies a fraction of the frame's height; an integer specifies the
|
|
maximum number of lines; @code{nil} means do not resize the minibuffer
|
|
window automatically. The default value is 0.25.
|
|
|
|
The @kbd{C-M-v} command in the minibuffer scrolls the help text from
|
|
commands that display help text of any sort in another window. You
|
|
can also scroll the help text with @kbd{M-@key{prior}} and
|
|
@kbd{M-@key{next}} (or, equivalently, @kbd{M-@key{PageUp}} and
|
|
@kbd{M-@key{PageDown}}). This is especially useful with long lists of
|
|
possible completions. @xref{Other Window}.
|
|
|
|
@vindex enable-recursive-minibuffers
|
|
Emacs normally disallows most commands that use the minibuffer while
|
|
the minibuffer is active. To allow such commands in the minibuffer,
|
|
set the variable @code{enable-recursive-minibuffers} to @code{t}.
|
|
|
|
@node Completion
|
|
@section Completion
|
|
@c This node is referenced in the tutorial. When renaming or deleting
|
|
@c it, the tutorial needs to be adjusted.
|
|
@cindex completion
|
|
|
|
Sometimes, you can use a feature called @dfn{completion} to help you
|
|
enter arguments. This means that after you type part of the argument,
|
|
Emacs can fill in the rest, or some of it, based on what you have
|
|
typed so far.
|
|
|
|
When completion is available, certain keys (usually @key{TAB},
|
|
@key{RET}, and @key{SPC}) are rebound to complete the text in the
|
|
minibuffer into a longer string chosen from a set of @dfn{completion
|
|
alternatives}. The set of completion alternatives depends on the
|
|
command that requested the argument, and on what you have typed so
|
|
far. In addition, you can usually type @kbd{?} to display a list of
|
|
possible completions.
|
|
|
|
For example, @kbd{M-x} uses the minibuffer to read the name of a
|
|
command, so completion works by matching the minibuffer text against
|
|
the names of existing Emacs commands. So, to run the command
|
|
@code{insert-buffer}, you can type @kbd{M-x ins @key{SPC} b @key{RET}}
|
|
instead of the full @kbd{M-x insert-buffer @key{RET}}.
|
|
|
|
Case is significant in completion when it is significant in the
|
|
argument you are entering, such as command names. Thus,
|
|
@samp{insert-buffer} is not a valid completion for @samp{IN}.
|
|
Completion ignores case distinctions for certain arguments in which
|
|
case does not matter.
|
|
|
|
@menu
|
|
* Example: Completion Example. Examples of using completion.
|
|
* Commands: Completion Commands. A list of completion commands.
|
|
* Strict Completion:: Different types of completion.
|
|
* Options: Completion Options. Options for completion.
|
|
@end menu
|
|
|
|
@node Completion Example
|
|
@subsection Completion Example
|
|
|
|
@kindex TAB @r{(completion)}
|
|
A concrete example may help here. If you type @kbd{M-x a u
|
|
@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{autoconf-mode}, but they all
|
|
begin with @code{auto}, so the @samp{au} in the minibuffer completes
|
|
to @samp{auto}.
|
|
|
|
If you type @key{TAB} again immediately, it cannot determine the
|
|
next character; it could be @samp{-}, @samp{a}, or @samp{c}. So it
|
|
does not add any characters; instead, @key{TAB} displays a list of all
|
|
possible completions in another window.
|
|
|
|
Next, type @kbd{- f}. The minibuffer now contains @samp{auto-f},
|
|
and the only command name that starts with this is
|
|
@code{auto-fill-mode}. If you now type @key{TAB}, completion fills in
|
|
the rest of the argument @samp{auto-fill-mode} into the minibuffer.
|
|
You have been able to enter @samp{auto-fill-mode} by typing just
|
|
@kbd{a u @key{TAB} - f @key{TAB}}.
|
|
|
|
@node Completion Commands
|
|
@subsection Completion Commands
|
|
|
|
Here is a list of the completion commands defined in the minibuffer
|
|
when completion is allowed.
|
|
|
|
@table @kbd
|
|
@item @key{TAB}
|
|
@findex minibuffer-complete
|
|
Complete the text in the minibuffer as much as possible; if unable to
|
|
complete, display a list of possible completions
|
|
(@code{minibuffer-complete}).
|
|
@item @key{SPC}
|
|
Complete up to one word from the minibuffer text before point
|
|
(@code{minibuffer-complete-word}). @key{SPC} for completion is not
|
|
available when entering a file name, since file names often include
|
|
spaces.
|
|
@item @key{RET}
|
|
Submit the text in the minibuffer as the argument, possibly completing
|
|
first as described in the next
|
|
@iftex
|
|
subsection (@code{minibuffer-complete-and-exit}).
|
|
@end iftex
|
|
@ifnottex
|
|
node (@code{minibuffer-complete-and-exit}). @xref{Strict Completion}.
|
|
@end ifnottex
|
|
@item ?
|
|
Display a list of possible completions of the text before point
|
|
(@code{minibuffer-completion-help}).
|
|
@end table
|
|
|
|
@kindex TAB
|
|
@findex minibuffer-complete
|
|
@key{TAB} (@code{minibuffer-complete}) is the most fundamental
|
|
completion command. It searches for all possible completion
|
|
alternatives that match the existing minibuffer text, and attempts to
|
|
complete as much as it can. The matching of completion alternatives
|
|
to the minibuffer text is performed according to somewhat intricate
|
|
rules, which are designed so that plausible completions are offered
|
|
under most circumstances. A valid completion alternative must satisfy
|
|
the following criteria:
|
|
|
|
@itemize @bullet
|
|
@item
|
|
The minibuffer text before point must be the same as the beginning of
|
|
the completion alternative. If there is any minibuffer text after
|
|
point, it must be a substring of the remainder of the completion
|
|
alternative.
|
|
|
|
@item
|
|
If no completion alternative satisfies the above rules, try using
|
|
@dfn{partial completion} rules: divide the minibuffer text into words
|
|
separated by hyphens or spaces, and complete each word separately.
|
|
Thus, when completing command names, @samp{em-l-m} completes to
|
|
@samp{emacs-lisp-mode}.
|
|
|
|
@item
|
|
If there is still no completion alternative, try the first rule again,
|
|
but ignore the minibuffer text after point (i.e., don't try matching
|
|
it).
|
|
@end itemize
|
|
|
|
@noindent
|
|
When performing these comparisons, a @samp{*} in the minibuffer text
|
|
acts as a @dfn{wildcard}---it matches any character at the
|
|
corresponding position in the completion alternative.
|
|
|
|
@kindex SPC
|
|
@findex minibuffer-complete-word
|
|
@key{SPC} (@code{minibuffer-complete-word}) completes like
|
|
@key{TAB}, but only up to 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 only inserts @samp{ill-},
|
|
giving @samp{auto-fill-}. Another @key{SPC} at this point completes
|
|
all the way to @samp{auto-fill-mode}.
|
|
|
|
If @key{TAB} or @key{SPC} is unable to complete, it displays a list
|
|
of possible completions (if there are any) in a separate window. You
|
|
can choose a completion from this list using the following commands:
|
|
|
|
@table @kbd
|
|
@findex mouse-choose-completion
|
|
@item Mouse-1
|
|
@itemx Mouse-2
|
|
Clicking mouse button 1 or 2 on a completion possibility chooses that
|
|
completion (@code{mouse-choose-completion}).
|
|
|
|
@findex switch-to-completions
|
|
@item M-v
|
|
@itemx @key{PageUp}
|
|
@itemx @key{prior}
|
|
Typing @kbd{M-v}, while in the minibuffer, selects the window showing
|
|
the completion list buffer (@code{switch-to-completions}). This paves
|
|
the way for using the commands below. Typing @key{PageUp} or
|
|
@key{prior} does the same, as does selecting that window in other
|
|
ways.
|
|
|
|
@findex choose-completion
|
|
@item @key{RET}
|
|
Typing @key{RET}, while 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 to the completion list window.
|
|
|
|
@findex next-completion
|
|
@item @key{Right}
|
|
Typing the right-arrow key @key{Right}, while in the completion list
|
|
buffer, moves point to the following completion possibility
|
|
(@code{next-completion}).
|
|
|
|
@findex previous-completion
|
|
@item @key{Left}
|
|
Typing the left-arrow key @key{Left}, while in the completion list
|
|
buffer, moves point to the previous completion possibility
|
|
(@code{previous-completion}).
|
|
@end table
|
|
|
|
@node Strict Completion
|
|
@subsection Strict Completion
|
|
|
|
There are three different ways that @key{RET} can do completion,
|
|
depending on how the argument will be used.
|
|
|
|
@itemize @bullet
|
|
@item
|
|
@dfn{Strict} completion accepts only known completion candidates. For
|
|
example, when @kbd{C-x k} reads the name of a buffer to kill, only the
|
|
name of an existing buffer makes sense. In strict completion,
|
|
@key{RET} refuses to exit if the text in the minibuffer does not
|
|
complete to an exact match.
|
|
|
|
@item
|
|
@dfn{Cautious} completion is similar to strict completion, except that
|
|
@key{RET} exits only if the text is an already exact match.
|
|
Otherwise, @key{RET} does not exit, but it does complete the text. If
|
|
that completes to an exact match, a second @key{RET} will exit.
|
|
|
|
Cautious completion is used for reading file names for files that must
|
|
already exist, for example.
|
|
|
|
@item
|
|
@dfn{Permissive} completion allows any input; the completion
|
|
candidates are just suggestions. For example, when @kbd{C-x C-f}
|
|
reads the name of a file to visit, any file name is allowed, including
|
|
nonexistent file (in case you want to create a file). In permissive
|
|
completion, @key{RET} does not complete, it just submits the argument
|
|
as you have entered it.
|
|
@end itemize
|
|
|
|
The completion commands display a list of all possible completions
|
|
whenever they can't determine even one more character by completion.
|
|
Also, typing @kbd{?} explicitly requests such a list. You can scroll
|
|
the list with @kbd{C-M-v} (@pxref{Other Window}).
|
|
|
|
@node Completion Options
|
|
@subsection Completion Options
|
|
|
|
@vindex completion-auto-help
|
|
If @code{completion-auto-help} is set to @code{nil}, the completion
|
|
commands never display the completion list buffer; you must type
|
|
@kbd{?} to display the list. If the value is @code{lazy}, Emacs only
|
|
shows the completion list buffer on the second attempt to complete.
|
|
In other words, if there is nothing to complete, the first @key{TAB}
|
|
echoes @samp{Next char not unique}; the second @key{TAB} does the
|
|
completion list buffer.
|
|
|
|
@vindex completion-ignored-extensions
|
|
@cindex ignored file names, in completion
|
|
When completing file names, certain file names are usually ignored.
|
|
The variable @code{completion-ignored-extensions} contains a list of
|
|
strings; a file name ending in any of those strings is ignored as a
|
|
completion candidate. The standard value of this variable has several
|
|
elements including @code{".o"}, @code{".elc"}, and @code{"~"}. For
|
|
example, if a directory contains @samp{foo.c} and @samp{foo.elc},
|
|
@samp{foo} completes to @samp{foo.c}. However, if @emph{all} possible
|
|
completions end in ``ignored'' strings, they are not ignored: in the
|
|
previous example, @samp{foo.e} completes to @samp{foo.elc}.
|
|
Displaying a list of possible completions disregards
|
|
@code{completion-ignored-extensions}; it shows them all.
|
|
|
|
If an element of @code{completion-ignored-extensions} ends in a
|
|
slash (@file{/}), it's a subdirectory name; that directory and its
|
|
contents are ignored. Elements of
|
|
@code{completion-ignored-extensions} that do not end in a slash are
|
|
ordinary file names.
|
|
|
|
@cindex case-sensitivity and completion
|
|
@vindex read-file-name-completion-ignore-case
|
|
@vindex read-buffer-completion-ignore-case
|
|
When completing file names, Emacs ignores case differences if the
|
|
variable @code{read-file-name-completion-ignore-case} is
|
|
non-@code{nil}. The default value is @code{nil} on systems that have
|
|
case-sensitive file-names, such as GNU/Linux; it is non-@code{nil} on
|
|
systems that have case-insensitive file-names, such as Microsoft
|
|
Windows. When completing buffer names, Emacs ignores case differences
|
|
if @code{read-buffer-completion-ignore-case} is non-@code{nil} (the
|
|
default value is @code{nil}).
|
|
|
|
@vindex completion-styles
|
|
You can customize the matching rules for completion alternatives
|
|
using the variable @code{completion-styles}. Its value should be a
|
|
list of symbols, each representing a @dfn{completion style}; valid
|
|
style symbols are @code{basic}, @code{partial-completion},
|
|
@code{emacs22}, @code{emacs21}, and @code{initials}. When completing,
|
|
Emacs attempts to use the first completion style in the list; if this
|
|
does not return any completion alternatives, it tries the next
|
|
completion style in the list, and so on. The completion rules
|
|
described in @ref{Completion Commands} correspond to the default value
|
|
of @code{completion-styles}, which is @code{(basic partial-completion
|
|
emacs22)}.
|
|
|
|
@cindex Icomplete mode
|
|
@findex icomplete-mode
|
|
Icomplete mode presents a constantly-updated display that tells you
|
|
what completions are available for the text you've entered so far. The
|
|
command to enable or disable this minor mode is @kbd{M-x
|
|
icomplete-mode}.
|
|
|
|
@node Minibuffer History
|
|
@section Minibuffer History
|
|
@cindex minibuffer history
|
|
@cindex history of minibuffer input
|
|
|
|
Every argument that you enter with the minibuffer is saved in a
|
|
@dfn{minibuffer history list} so you can easily use it again later.
|
|
You can use the following arguments to quickly fetch an earlier
|
|
argument into the minibuffer:
|
|
|
|
@table @kbd
|
|
@item M-p
|
|
@itemx @key{Up}
|
|
Move to the previous item in the minibuffer history, an earlier
|
|
argument (@code{previous-history-element}).
|
|
@item M-n
|
|
@itemx @key{Down}
|
|
Move to the next item in the minibuffer history
|
|
(@code{next-history-element}).
|
|
@item M-r @var{regexp} @key{RET}
|
|
Move to an earlier item in the minibuffer history that
|
|
matches @var{regexp} (@code{previous-matching-history-element}).
|
|
@item M-s @var{regexp} @key{RET}
|
|
Move to a later item in the minibuffer history that matches
|
|
@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
|
|
While in the minibuffer, typing @kbd{M-p} or @key{Up}
|
|
(@code{previous-history-element}) moves up through the minibuffer
|
|
history list, one item at a time. Each @kbd{M-p} fetches an earlier
|
|
item from the history list into the minibuffer, replacing its existing
|
|
contents. Similarly, typing @kbd{M-n} or @key{Down}
|
|
(@code{next-history-element}) moves back down the history list,
|
|
fetching later entries into the minibuffer. You can think of these
|
|
commands as ``backwards'' and ``forwards'' through the history list.
|
|
|
|
If you type @kbd{M-n} in the minibuffer when there are no later
|
|
entries in the minibuffer history (e.g., if you haven't previously
|
|
typed @kbd{M-p}), Emacs tries fetching from a list of default
|
|
argument: values that you are likely to enter. You can think of this
|
|
as moving through the ``future list'' instead of the ``history list''.
|
|
|
|
The input that @kbd{M-p} or @kbd{M-n} fetches into the minibuffer
|
|
entirely replaces the existing contents of the minibuffer, so you can
|
|
simply type @key{RET} to use it as an argument. 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.
|
|
|
|
@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. @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. These
|
|
commands are unusual: they use the minibuffer to read the regular
|
|
expression even though they are invoked from the minibuffer. As with
|
|
incremental searching, an upper-case letter in the regular expression
|
|
makes the search case-sensitive (@pxref{Search Case}). You can also
|
|
search through the history using an incremental search (@pxref{Isearch
|
|
Minibuffer}).
|
|
|
|
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. (As a special feature, this history list
|
|
records the absolute file name, even if the name you entered was not
|
|
absolute.)
|
|
|
|
There are several other specific history lists, including one for
|
|
buffer names, one for arguments of commands like @code{query-replace},
|
|
one used by @kbd{M-x} for command names, and one used by
|
|
@code{compile} for compilation commands. Finally, there is one
|
|
``miscellaneous'' history list that most minibuffer arguments use.
|
|
|
|
@vindex history-length
|
|
The variable @code{history-length} specifies the maximum length of a
|
|
minibuffer history list; adding a new element deletes the oldest
|
|
element if the list gets too long. If the value of
|
|
@code{history-length} is @code{t}, there is no maximum length.
|
|
|
|
@vindex history-delete-duplicates
|
|
The variable @code{history-delete-duplicates} specifies whether to
|
|
delete duplicates in history. If it is non-@code{nil}, adding a new
|
|
element deletes from the list all other elements that are equal to it.
|
|
The default is @code{nil}.
|
|
|
|
@node Repetition
|
|
@section Repeating Minibuffer Commands
|
|
@cindex command history
|
|
@cindex history of commands
|
|
|
|
Every command that uses the minibuffer once is recorded on a special
|
|
history list, the @dfn{command history}, 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
|
|
@table @kbd
|
|
@item C-x @key{ESC} @key{ESC}
|
|
Re-execute a recent minibuffer command from the command history
|
|
(@code{repeat-complex-command}).
|
|
@item M-x list-command-history
|
|
Display the entire command history, showing all the commands
|
|
@kbd{C-x @key{ESC} @key{ESC}} can repeat, most recent first.
|
|
@end table
|
|
|
|
@kindex C-x ESC ESC
|
|
@findex repeat-complex-command
|
|
@kbd{C-x @key{ESC} @key{ESC}} is used to re-execute a recent command
|
|
that used the minibuffer. With no argument, it repeats the last such
|
|
command. A numeric argument specifies which command to repeat; 1
|
|
means the last one, 2 the previous, and so on.
|
|
|
|
@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. Even if you don't understand Lisp
|
|
syntax, it will probably be obvious which command is displayed for
|
|
repetition. If you type just @key{RET}, that repeats the command
|
|
unchanged. You can also change the command by editing the Lisp
|
|
expression before you execute it. The repeated command is added to
|
|
the front of the command history unless it is identical to the most
|
|
recently item.
|
|
|
|
Once inside the minibuffer for @kbd{C-x @key{ESC} @key{ESC}}, you can
|
|
use the minibuffer history commands (@kbd{M-p}, @kbd{M-n}, @kbd{M-r},
|
|
@kbd{M-s}; @pxref{Minibuffer History}) to move through the history list
|
|
of saved entire commands. After finding the desired previous command,
|
|
you can edit its expression as usual and then repeat it by typing
|
|
@key{RET}.
|
|
|
|
@vindex isearch-resume-in-command-history
|
|
Incremental search does not, strictly speaking, use the minibuffer.
|
|
Therefore, although it behaves like a complex command, it normally
|
|
does not appear in the history list for @kbd{C-x @key{ESC} @key{ESC}}.
|
|
You can make incremental search commands appear in the history by
|
|
setting @code{isearch-resume-in-command-history} to a non-@code{nil}
|
|
value. @xref{Incremental Search}.
|
|
|
|
@vindex command-history
|
|
The list of previous minibuffer-using commands is stored as a Lisp
|
|
list in the variable @code{command-history}. Each element is a Lisp
|
|
expression which describes one command and its arguments. Lisp programs
|
|
can re-execute a command by calling @code{eval} with the
|
|
@code{command-history} element.
|
|
|
|
@node Passwords
|
|
@section Entering passwords
|
|
|
|
Sometimes, you may need to enter a password into Emacs. For instance,
|
|
when you tell Emacs to visit a file on another machine via a network
|
|
protocol such as FTP, you often need to supply a password to gain
|
|
access to the machine (@pxref{Remote Files}).
|
|
|
|
Entering a password is, in a basic sense, similar to using a
|
|
minibuffer. Emacs displays a prompt in the echo area (such as
|
|
@samp{Password: }); after you type the required password, press
|
|
@key{RET} to submit it. To prevent others from seeing your password,
|
|
every character you type is displayed as a dot (@samp{.}) instead of
|
|
its usual form.
|
|
|
|
Most of the features and commands associated with the minibuffer can
|
|
@emph{not} be used when entering a password. There is no history or
|
|
completion, and you cannot change windows or perform any other action
|
|
with Emacs until you have submitted the password.
|
|
|
|
While you are typing the password, you may press @key{DEL} to delete
|
|
backwards, removing the last character entered. @key{C-u} deletes
|
|
everything you have typed so far. @kbd{C-g} quits the password prompt
|
|
(@pxref{Quitting}). @kbd{C-y} inserts the current kill into the
|
|
password (@pxref{Killing}). You may type either @key{RET} or
|
|
@key{ESC} to submit the password. Any other self-inserting character
|
|
key inserts the associated character into the password, and all other
|
|
input is ignored.
|
|
|
|
@ignore
|
|
arch-tag: ba913cfd-b70e-400f-b663-22b2c309227f
|
|
@end ignore
|