Doc fixes.
[emacs.git] / man / mini.texi
blobb714f6a2f33bba58f32dcad381ae4b8cb86f2d64
1 @c This is part of the Emacs manual.
2 @c Copyright (C) 1985, 86, 87, 93, 94, 95, 97, 2000
3 @c   Free Software Foundation, Inc.
4 @c See file emacs.texi for copying conditions.
5 @node Minibuffer, M-x, Basic, Top
6 @chapter The Minibuffer
7 @cindex minibuffer
9   The @dfn{minibuffer} is the facility used by Emacs commands to read
10 arguments more complicated than a single number.  Minibuffer arguments
11 can be file names, buffer names, Lisp function names, Emacs command
12 names, Lisp expressions, and many other things, depending on the command
13 reading the argument.  You can use the usual Emacs editing commands in
14 the minibuffer to edit the argument text.
16 @cindex prompt
17   When the minibuffer is in use, it appears in the echo area, and the
18 terminal's cursor moves there.  The beginning of the minibuffer line
19 displays a @dfn{prompt} which says what kind of input you should supply and
20 how it will be used.  Often this prompt is derived from the name of the
21 command that the argument is for.  The prompt normally ends with a colon.
23 @cindex default argument
24   Sometimes a @dfn{default argument} appears in parentheses after the
25 colon; it too is part of the prompt.  The default will be used as the
26 argument value if you enter an empty argument (for example, just type
27 @key{RET}).  For example, commands that read buffer names always show a
28 default, which is the name of the buffer that will be used if you type
29 just @key{RET}.
31   The simplest way to enter a minibuffer argument is to type the text
32 you want, terminated by @key{RET} which exits the minibuffer.  You can
33 cancel the command that wants the argument, and get out of the
34 minibuffer, by typing @kbd{C-g}.
36   Since the minibuffer uses the screen space of the echo area, it can
37 conflict with other ways Emacs customarily uses the echo area.  Here is how
38 Emacs handles such conflicts:
40 @itemize @bullet
41 @item
42 If a command gets an error while you are in the minibuffer, this does
43 not cancel the minibuffer.  However, the echo area is needed for the
44 error message and therefore the minibuffer itself is hidden for a
45 while.  It comes back after a few seconds, or as soon as you type
46 anything.
48 @item
49 If in the minibuffer you use a command whose purpose is to print a
50 message in the echo area, such as @kbd{C-x =}, the message is printed
51 normally, and the minibuffer is hidden for a while.  It comes back
52 after a few seconds, or as soon as you type anything.
54 @item
55 Echoing of keystrokes does not take place while the minibuffer is in
56 use.
57 @end itemize
59 @menu
60 * File: Minibuffer File.  Entering file names with the minibuffer.
61 * Edit: Minibuffer Edit.  How to edit in the minibuffer.
62 * Completion::            An abbreviation facility for minibuffer input.
63 * Minibuffer History::    Reusing recent minibuffer arguments.
64 * Repetition::            Re-executing commands that used the minibuffer.
65 @end menu
67 @node Minibuffer File
68 @section Minibuffers for File Names
70   Sometimes the minibuffer starts out with text in it.  For example, when
71 you are supposed to give a file name, the minibuffer starts out containing
72 the @dfn{default directory}, which ends with a slash.  This is to inform
73 you which directory the file will be found in if you do not specify a
74 directory.
76 @c Separate paragraph to clean up ugly pagebreak--rms
77 @need 1500
78   For example, the minibuffer might start out with these contents:
80 @example
81 Find File: /u2/emacs/src/
82 @end example
84 @noindent
85 where @samp{Find File:@: } is the prompt.  Typing @kbd{buffer.c}
86 specifies the file @file{/u2/emacs/src/buffer.c}.  To find files in
87 nearby directories, use @kbd{..}; thus, if you type
88 @kbd{../lisp/simple.el}, you will get the file named
89 @file{/u2/emacs/lisp/simple.el}.  Alternatively, you can kill with
90 @kbd{M-@key{DEL}} the directory names you don't want (@pxref{Words}).
92   If you don't want any of the default, you can kill it with @kbd{C-a
93 C-k}.  But you don't need to kill the default; you can simply ignore it.
94 Insert an absolute file name, one starting with a slash or a tilde,
95 after the default directory.  For example, to specify the file
96 @file{/etc/termcap}, just insert that name, giving these minibuffer
97 contents:
99 @example
100 Find File: /u2/emacs/src//etc/termcap
101 @end example
103 @noindent
104 @cindex // in file name
105 @cindex double slash in file name
106 @cindex slashes repeated in file name
107 GNU Emacs gives a special meaning to a double slash (which is not
108 normally a useful thing to write): it means, ``ignore everything before
109 the second slash in the pair.''  Thus, @samp{/u2/emacs/src/} is ignored
110 in the example above, and you get the file @file{/etc/termcap}.
112   If you set @code{insert-default-directory} to @code{nil}, the default
113 directory is not inserted in the minibuffer.  This way, the minibuffer
114 starts out empty.  But the name you type, if relative, is still
115 interpreted with respect to the same default directory.
117 @node Minibuffer Edit
118 @section Editing in the Minibuffer
120   The minibuffer is an Emacs buffer (albeit a peculiar one), and the usual
121 Emacs commands are available for editing the text of an argument you are
122 entering.
124   Since @key{RET} in the minibuffer is defined to exit the minibuffer,
125 you can't use it to insert a newline in the minibuffer.  To do that,
126 type @kbd{C-o} or @kbd{C-q C-j}.  (Recall that a newline is really the
127 character control-J.)
129   The minibuffer has its own window which always has space on the screen
130 but acts as if it were not there when the minibuffer is not in use.  When
131 the minibuffer is in use, its window is just like the others; you can
132 switch to another window with @kbd{C-x o}, edit text in other windows and
133 perhaps even visit more files, before returning to the minibuffer to submit
134 the argument.  You can kill text in another window, return to the
135 minibuffer window, and then yank the text to use it in the argument.
136 @xref{Windows}.
138 @cindex height of minibuffer
139 @cindex size of minibuffer
140 @cindex growing minibuffer
141 @cindex resizing minibuffer
142   There are some restrictions on the use of the minibuffer window,
143 however.  You cannot switch buffers in it---the minibuffer and its
144 window are permanently attached.  Also, you cannot split or kill the
145 minibuffer window.  But you can make it taller in the normal fashion
146 with @kbd{C-x ^}.
148 @vindex resize-mini-windows
149   The minibuffer window expands vertically as necessary to hold the text
150 that you put in the minibuffer if @code{resize-mini-windows} is
151 non-@code{nil}.  If @code{resize-mini-windows} is @code{t}, the window
152 is always resized to fit the size of the text it displays.  If
153 @code{resize-mini-windows} is the symbol @code{grow-only}, the window
154 is enlarged only, until it becomes empty again, at which point it
155 shrinks to its normal size again.
157 @vindex max-mini-window-height
158   Customize the variable @code{max-mini-window-height} to control the
159 maximum height for resizing the minibuffer window: if a floating-point
160 number, it specifies a fraction of the frame's height; if an integer,
161 it specifies the maximum number of lines; if nil, the minibuffer
162 window is not resized.  The default value is 0.25.
164 @vindex minibuffer-scroll-overlap
165   Scrolling works specially in the minibuffer window.  When the
166 minibuffer is just one line high, and it contains a long line of text
167 that won't fit on the screen, scrolling automatically maintains an
168 overlap of a certain number of characters from one continuation line to
169 the next.  The variable @code{minibuffer-scroll-overlap} specifies how
170 many characters of overlap; the default is 20.
172   If while in the minibuffer you issue a command that displays help text
173 of any sort in another window, you can use the @kbd{C-M-v} command while
174 in the minibuffer to scroll the help text.  This lasts until you exit
175 the minibuffer.  This feature is especially useful if a completing
176 minibuffer gives you a list of possible completions.  @xref{Other Window}.
178 @vindex enable-recursive-minibuffers
179   Emacs normally disallows most commands that use the minibuffer while
180 the minibuffer is active.  This rule is to prevent recursive minibuffers
181 from confusing novice users.  If you want to be able to use such
182 commands in the minibuffer, set the variable
183 @code{enable-recursive-minibuffers} to a non-@code{nil} value.
185 @node Completion
186 @section Completion
187 @cindex completion
189   For certain kinds of arguments, you can use @dfn{completion} to enter
190 the argument value.  Completion means that you type part of the
191 argument, then Emacs visibly fills in the rest, or as much as
192 can be determined from the part you have typed.
194   When completion is available, certain keys---@key{TAB}, @key{RET}, and
195 @key{SPC}---are rebound to complete the text present in the minibuffer
196 into a longer string that it stands for, by matching it against a set of
197 @dfn{completion alternatives} provided by the command reading the
198 argument.  @kbd{?} is defined to display a list of possible completions
199 of what you have inserted.
201   For example, when @kbd{M-x} uses the minibuffer to read the name of a
202 command, it provides a list of all available Emacs command names to
203 complete against.  The completion keys match the text in the minibuffer
204 against all the command names, find any additional name characters
205 implied by the ones already present in the minibuffer, and add those
206 characters to the ones you have given.  This is what makes it possible
207 to type @kbd{M-x ins @key{SPC} b @key{RET}} instead of @kbd{M-x
208 insert-buffer @key{RET}} (for example).
210   Case is normally significant in completion, because it is significant
211 in most of the names that you can complete (buffer names, file names and
212 command names).  Thus, @samp{fo} does not complete to @samp{Foo}.
213 Completion does ignore case distinctions for certain arguments in which
214 case does not matter.
216 @menu
217 * Example: Completion Example.
218 * Commands: Completion Commands.
219 * Strict Completion::
220 * Options: Completion Options.
221 @end menu
223 @node Completion Example
224 @subsection Completion Example
226 @kindex TAB @r{(completion)}
227 @findex minibuffer-complete
228   A concrete example may help here.  If you type @kbd{M-x au @key{TAB}},
229 the @key{TAB} looks for alternatives (in this case, command names) that
230 start with @samp{au}.  There are several, including
231 @code{auto-fill-mode} and @code{auto-save-mode}---but they are all the
232 same as far as @code{auto-}, so the @samp{au} in the minibuffer changes
233 to @samp{auto-}.@refill
235   If you type @key{TAB} again immediately, there are multiple
236 possibilities for the very next character---it could be any of
237 @samp{cfilrs}---so no more characters are added; instead, @key{TAB}
238 displays a list of all possible completions in another window.
240   If you go on to type @kbd{f @key{TAB}}, this @key{TAB} sees
241 @samp{auto-f}.  The only command name starting this way is
242 @code{auto-fill-mode}, so completion fills in the rest of that.  You now
243 have @samp{auto-fill-mode} in the minibuffer after typing just @kbd{au
244 @key{TAB} f @key{TAB}}.  Note that @key{TAB} has this effect because in
245 the minibuffer it is bound to the command @code{minibuffer-complete}
246 when completion is available.
248 @node Completion Commands
249 @subsection Completion Commands
251   Here is a list of the completion commands defined in the minibuffer
252 when completion is available.
254 @table @kbd
255 @item @key{TAB}
256 Complete the text in the minibuffer as much as possible
257 (@code{minibuffer-complete}).
258 @item @key{SPC}
259 Complete the minibuffer text, but don't go beyond one word
260 (@code{minibuffer-complete-word}).
261 @item @key{RET}
262 Submit the text in the minibuffer as the argument, possibly completing
263 first as described below (@code{minibuffer-complete-and-exit}).
264 @item ?
265 Print a list of all possible completions of the text in the minibuffer
266 (@code{minibuffer-list-completions}).
267 @end table
269 @kindex SPC
270 @findex minibuffer-complete-word
271   @key{SPC} completes much like @key{TAB}, but never goes beyond the
272 next hyphen or space.  If you have @samp{auto-f} in the minibuffer and
273 type @key{SPC}, it finds that the completion is @samp{auto-fill-mode},
274 but it stops completing after @samp{fill-}.  This gives
275 @samp{auto-fill-}.  Another @key{SPC} at this point completes all the
276 way to @samp{auto-fill-mode}.  @key{SPC} in the minibuffer when
277 completion is available runs the command
278 @code{minibuffer-complete-word}.
280   Here are some commands you can use to choose a completion from a
281 window that displays a list of completions:
283 @table @kbd
284 @findex mouse-choose-completion
285 @item Mouse-2
286 Clicking mouse button 2 on a completion in the list of possible
287 completions chooses that completion (@code{mouse-choose-completion}).
288 You normally use this command while point is in the minibuffer; but you
289 must click in the list of completions, not in the minibuffer itself.
291 @findex switch-to-completions
292 @item @key{PRIOR}
293 @itemx M-v
294 Typing @key{PRIOR} or @key{PAGE-UP}, or @kbd{M-v}, while in the
295 minibuffer, selects the window showing the completion list buffer
296 (@code{switch-to-completions}).  This paves the way for using the
297 commands below.  (Selecting that window in the usual ways has the same
298 effect, but this way is more convenient.)
300 @findex choose-completion
301 @item @key{RET}
302 Typing @key{RET} @emph{in the completion list buffer} chooses the
303 completion that point is in or next to (@code{choose-completion}).  To
304 use this command, you must first switch windows to the window that shows
305 the list of completions.
307 @findex next-completion
308 @item @key{RIGHT}
309 Typing the right-arrow key @key{RIGHT} @emph{in the completion list
310 buffer} moves point to the following completion (@code{next-completion}).
312 @findex previous-completion
313 @item @key{LEFT}
314 Typing the left-arrow key @key{LEFT} @emph{in the completion list
315 buffer} moves point toward the beginning of the buffer, to the previous
316 completion (@code{previous-completion}).
317 @end table
319 @node Strict Completion
320 @subsection Strict Completion
322   There are three different ways that @key{RET} can work in completing
323 minibuffers, depending on how the argument will be used.
325 @itemize @bullet
326 @item
327 @dfn{Strict} completion is used when it is meaningless to give any
328 argument except one of the known alternatives.  For example, when
329 @kbd{C-x k} reads the name of a buffer to kill, it is meaningless to
330 give anything but the name of an existing buffer.  In strict
331 completion, @key{RET} refuses to exit if the text in the minibuffer
332 does not complete to an exact match.
334 @item
335 @dfn{Cautious} completion is similar to strict completion, except that
336 @key{RET} exits only if the text was an exact match already, not
337 needing completion.  If the text is not an exact match, @key{RET} does
338 not exit, but it does complete the text.  If it completes to an exact
339 match, a second @key{RET} will exit.
341 Cautious completion is used for reading file names for files that must
342 already exist.
344 @item
345 @dfn{Permissive} completion is used when any string whatever is
346 meaningful, and the list of completion alternatives is just a guide.
347 For example, when @kbd{C-x C-f} reads the name of a file to visit, any
348 file name is allowed, in case you want to create a file.  In
349 permissive completion, @key{RET} takes the text in the minibuffer
350 exactly as given, without completing it.
351 @end itemize
353   The completion commands display a list of all possible completions in
354 a window whenever there is more than one possibility for the very next
355 character.  Also, typing @kbd{?} explicitly requests such a list.  If
356 the list of completions is long, you can scroll it with @kbd{C-M-v}
357 (@pxref{Other Window}).
359 @node Completion Options
360 @subsection Completion Options
362 @vindex completion-ignored-extensions
363   When completion is done on file names, certain file names are usually
364 ignored.  The variable @code{completion-ignored-extensions} contains a
365 list of strings; a file whose name ends in any of those strings is
366 ignored as a possible completion.  The standard value of this variable
367 has several elements including @code{".o"}, @code{".elc"}, @code{".dvi"}
368 and @code{"~"}.  The effect is that, for example, @samp{foo} can
369 complete to @samp{foo.c} even though @samp{foo.o} exists as well.
370 However, if @emph{all} the possible completions end in ``ignored''
371 strings, then they are not ignored.  Ignored extensions do not apply to
372 lists of completions---those always mention all possible completions.
374 @vindex completion-auto-help
375   Normally, a completion command that finds the next character is undetermined
376 automatically displays a list of all possible completions.  If the variable
377 @code{completion-auto-help} is set to @code{nil}, this does not happen,
378 and you must type @kbd{?} to display the possible completions.
380 @pindex complete
381 @cindex Partial Completion mode
382 @vindex partial-completion-mode
383 @findex partial-completion-mode
384 @vindex PC-include-file-path
385 @vindex PC-disable-includes
386   The @code{complete} library implements a more powerful kind of
387 completion that can complete multiple words at a time.  For example, it
388 can complete the command name abbreviation @code{p-b} into
389 @code{print-buffer}, because no other command starts with two words
390 whose initials are @samp{p} and @samp{b}.  To enable this, use the
391 command @kbd{M-x partial-completion-mode} or customize the option
392 @code{partial-completion-mode}.  Unless the option
393 @code{PC-disable-includes} is @code{t}, Partial Completion mode also
394 extends @kbd{M-x find-file} so that the @samp{<@dots{}>} sequence is
395 interpreted as a file on the path @code{PC-include-file-path} and
396 partial completion of file names is possible.  Partial completion of
397 directories in file names requires @samp{*}s to indicate the
398 completions: @file{/u*/b*/f*} might expand to @file{/usr/bin/foo}.  When
399 Partial Completion mode is active, the Meta versions of the @kbd{TAB},
400 @kbd{SPC}, @kbd{RET} and @kbd{?} keys act as those keys do by default
401 for completion.
403 @cindex Icomplete mode
404 @findex icomplete-mode
405   Icomplete mode presents a constantly-updated display that tells you
406 what completions are available for the text you've entered so far.  The
407 command to enable or disable this minor mode is @kbd{M-x
408 icomplete-mode}.
410 @node Minibuffer History
411 @section Minibuffer History
412 @cindex minibuffer history
413 @cindex history of minibuffer input
415   Every argument that you enter with the minibuffer is saved on a
416 @dfn{minibuffer history list} so that you can use it again later in
417 another argument.  Special commands load the text of an earlier argument
418 in the minibuffer.  They discard the old minibuffer contents, so you can
419 think of them as moving through the history of previous arguments.
421 @table @kbd
422 @item @key{UP}
423 @itemx M-p
424 Move to the next earlier argument string saved in the minibuffer history
425 (@code{previous-history-element}).
426 @item @key{DOWN}
427 @itemx M-n
428 Move to the next later argument string saved in the minibuffer history
429 (@code{next-history-element}).
430 @item M-r @var{regexp} @key{RET}
431 Move to an earlier saved argument in the minibuffer history that has a
432 match for @var{regexp} (@code{previous-matching-history-element}).
433 @item M-s @var{regexp} @key{RET}
434 Move to a later saved argument in the minibuffer history that has a
435 match for @var{regexp} (@code{next-matching-history-element}).
436 @end table
438 @kindex M-p @r{(minibuffer history)}
439 @kindex M-n @r{(minibuffer history)}
440 @findex next-history-element
441 @findex previous-history-element
442   The simplest way to reuse the saved arguments in the history list is
443 to move through the history list one element at a time.  While in the
444 minibuffer, use @kbd{M-p} or up-arrow (@code{previous-history-element})
445 to ``move to'' the next earlier minibuffer input, and use @kbd{M-n} or
446 down-arrow (@code{next-history-element}) to ``move to'' the next later
447 input.
449   The previous input that you fetch from the history entirely replaces
450 the contents of the minibuffer.  To use it as the argument, exit the
451 minibuffer as usual with @key{RET}.  You can also edit the text before
452 you reuse it; this does not change the history element that you
453 ``moved'' to, but your new argument does go at the end of the history
454 list in its own right.
456   For many minibuffer arguments there is a ``default'' value.  In some
457 cases, the minibuffer history commands know the default value.  Then you
458 can insert the default value into the minibuffer as text by using
459 @kbd{M-n} to move ``into the future'' in the history.  Eventually we
460 hope to make this feature available whenever the minibuffer has a
461 default value.
463 @findex previous-matching-history-element
464 @findex next-matching-history-element
465 @kindex M-r @r{(minibuffer history)}
466 @kindex M-s @r{(minibuffer history)}
467   There are also commands to search forward or backward through the
468 history; they search for history elements that match a regular
469 expression that you specify with the minibuffer.  @kbd{M-r}
470 (@code{previous-matching-history-element}) searches older elements in
471 the history, while @kbd{M-s} (@code{next-matching-history-element})
472 searches newer elements.  By special dispensation, these commands can
473 use the minibuffer to read their arguments even though you are already
474 in the minibuffer when you issue them.  As with incremental searching,
475 an uppercase letter in the regular expression makes the search
476 case-sensitive (@pxref{Search Case}).
478 @ignore
479   We may change the precise way these commands read their arguments.
480 Perhaps they will search for a match for the string given so far in the
481 minibuffer; perhaps they will search for a literal match rather than a
482 regular expression match; perhaps they will only accept matches at the
483 beginning of a history element; perhaps they will read the string to
484 search for incrementally like @kbd{C-s}.  To find out what interface is
485 actually available, type @kbd{C-h f previous-matching-history-element}.
486 @end ignore
488   All uses of the minibuffer record your input on a history list, but
489 there are separate history lists for different kinds of arguments.  For
490 example, there is a list for file names, used by all the commands that
491 read file names.  (As a special feature, this history list records
492 the absolute file name, no more and no less, even if that is not how
493 you entered the file name.)
495   There are several other very specific history lists, including one for
496 command names read by @kbd{M-x}, one for buffer names, one for arguments
497 of commands like @code{query-replace}, and one for compilation commands
498 read by @code{compile}.  Finally, there is one ``miscellaneous'' history
499 list that most minibuffer arguments use.
501 @vindex history-length
502   The variable @code{history-length} specifies the maximum length of a
503 minibuffer history list; once a list gets that long, the oldest element
504 is deleted each time an element is added.  If the value of
505 @code{history-length} is @code{t}, though, there is no maximum length
506 and elements are never deleted.
508 @node Repetition
509 @section Repeating Minibuffer Commands
510 @cindex command history
511 @cindex history of commands
513   Every command that uses the minibuffer at least once is recorded on a
514 special history list, together with the values of its arguments, so that
515 you can repeat the entire command.  In particular, every use of
516 @kbd{M-x} is recorded there, since @kbd{M-x} uses the minibuffer to read
517 the command name.
519 @findex list-command-history
520 @c widecommands
521 @table @kbd
522 @item C-x @key{ESC} @key{ESC}
523 Re-execute a recent minibuffer command (@code{repeat-complex-command}).
524 @item M-x list-command-history
525 Display the entire command history, showing all the commands
526 @kbd{C-x @key{ESC} @key{ESC}} can repeat, most recent first.
527 @end table
529 @kindex C-x ESC ESC
530 @findex repeat-complex-command
531   @kbd{C-x @key{ESC} @key{ESC}} is used to re-execute a recent
532 minibuffer-using command.  With no argument, it repeats the last such
533 command.  A numeric argument specifies which command to repeat; one
534 means the last one, and larger numbers specify earlier ones.
536   @kbd{C-x @key{ESC} @key{ESC}} works by turning the previous command
537 into a Lisp expression and then entering a minibuffer initialized with
538 the text for that expression.  If you type just @key{RET}, the command
539 is repeated as before.  You can also change the command by editing the
540 Lisp expression.  Whatever expression you finally submit is what will be
541 executed.  The repeated command is added to the front of the command
542 history unless it is identical to the most recently executed command
543 already there.
545   Even if you don't understand Lisp syntax, it will probably be obvious
546 which command is displayed for repetition.  If you do not change the
547 text, it will repeat exactly as before.
549   Once inside the minibuffer for @kbd{C-x @key{ESC} @key{ESC}}, you can
550 use the minibuffer history commands (@kbd{M-p}, @kbd{M-n}, @kbd{M-r},
551 @kbd{M-s}; @pxref{Minibuffer History}) to move through the history list
552 of saved entire commands.  After finding the desired previous command,
553 you can edit its expression as usual and then resubmit it by typing
554 @key{RET} as usual.
556 @vindex command-history
557   The list of previous minibuffer-using commands is stored as a Lisp
558 list in the variable @code{command-history}.  Each element is a Lisp
559 expression which describes one command and its arguments.  Lisp programs
560 can re-execute a command by calling @code{eval} with the
561 @code{command-history} element.