]> code.delx.au - gnu-emacs/blob - man/mini.texi
Don't say just "option" when talking about variables.
[gnu-emacs] / man / mini.texi
1 @c This is part of the Emacs manual.
2 @c Copyright (C) 1985, 86, 87, 93, 94, 95, 97, 00, 2001
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
8
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.
15
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.
22
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 (that is, 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}.
30
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}.
35
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:
39
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.
47
48 @item
49 If in the minibuffer you use a command whose purpose is to display a
50 message in the echo area, such as @kbd{C-x =}, the message hides the
51 minibuffer for a while. The minibuffer contents come back after a few
52 seconds, or as soon as you type anything.
53
54 @item
55 Echoing of keystrokes does not take place while the minibuffer is in
56 use.
57 @end itemize
58
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
66
67 @node Minibuffer File
68 @section Minibuffers for File Names
69
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.
75
76 @c Separate paragraph to clean up ugly page break--rms
77 @need 1500
78 For example, the minibuffer might start out with these contents:
79
80 @example
81 Find File: /u2/emacs/src/
82 @end example
83
84 @noindent
85 where @samp{Find File:@: } is the prompt. Typing @kbd{buffer.c} as
86 input specifies the file @file{/u2/emacs/src/buffer.c}. To find files
87 in 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}).
91
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:
98
99 @example
100 Find File: /u2/emacs/src//etc/termcap
101 @end example
102
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}.
111
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.
116
117 @node Minibuffer Edit
118 @section Editing in the Minibuffer
119
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.
123
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.)
128
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}.
137
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 ^}.
147
148 @vindex resize-mini-windows
149 The minibuffer window expands vertically as necessary to hold the
150 text 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 grows when the size of displayed text increases, but shrinks (back to
155 the normal size) only when the minibuffer becomes inactive.
156
157 @vindex max-mini-window-height
158 The variable @code{max-mini-window-height} controls the maximum
159 height for resizing the minibuffer window: a floating-point number
160 specifies a fraction of the frame's height; an integer specifies the
161 maximum number of lines; @code{nil} means do not resize the minibuffer
162 window automatically. The default value is 0.25.
163
164 If while in the minibuffer you issue a command that displays help text
165 of any sort in another window, you can use the @kbd{C-M-v} command while
166 in the minibuffer to scroll the help text. This lasts until you exit
167 the minibuffer. This feature is especially useful when you display
168 a buffer listing possible completions. @xref{Other Window}.
169
170 @vindex enable-recursive-minibuffers
171 Emacs normally disallows most commands that use the minibuffer while
172 the minibuffer is active. This rule is to prevent recursive minibuffers
173 from confusing novice users. If you want to be able to use such
174 commands in the minibuffer, set the variable
175 @code{enable-recursive-minibuffers} to a non-@code{nil} value.
176
177 @node Completion
178 @section Completion
179 @cindex completion
180
181 For certain kinds of arguments, you can use @dfn{completion} to enter
182 the argument value. Completion means that you type part of the
183 argument, then Emacs visibly fills in the rest, or as much as
184 can be determined from the part you have typed.
185
186 When completion is available, certain keys---@key{TAB}, @key{RET}, and
187 @key{SPC}---are rebound to complete the text in the minibuffer before point
188 into a longer string that it stands for, by matching it against a set of
189 @dfn{completion alternatives} provided by the command reading the
190 argument. @kbd{?} is defined to display a list of possible completions
191 of what you have inserted.
192
193 For example, when @kbd{M-x} uses the minibuffer to read the name of a
194 command, it provides a list of all available Emacs command names to
195 complete against. The completion keys match the minibuffer text
196 against all the command names, find any additional name characters
197 implied by the ones already present in the minibuffer, and add those
198 characters to the ones you have given. This is what makes it possible
199 to type @kbd{M-x ins @key{SPC} b @key{RET}} instead of @kbd{M-x
200 insert-buffer @key{RET}} (for example).
201
202 Case is normally significant in completion, because it is significant
203 in most of the names that you can complete (buffer names, file names and
204 command names). Thus, @samp{fo} does not complete to @samp{Foo}.
205 Completion does ignore case distinctions for certain arguments in which
206 case does not matter.
207
208 @menu
209 * Example: Completion Example. Examples of using completion.
210 * Commands: Completion Commands. A list of completion commands.
211 * Strict Completion:: Different types of completion.
212 * Options: Completion Options. Options for completion.
213 @end menu
214
215 @node Completion Example
216 @subsection Completion Example
217
218 @kindex TAB @r{(completion)}
219 @findex minibuffer-complete
220 A concrete example may help here. If you type @kbd{M-x au @key{TAB}},
221 the @key{TAB} looks for alternatives (in this case, command names) that
222 start with @samp{au}. There are several, including
223 @code{auto-fill-mode} and @code{auto-save-mode}---but they are all the
224 same as far as @code{auto-}, so the @samp{au} in the minibuffer changes
225 to @samp{auto-}.@refill
226
227 If you type @key{TAB} again immediately, there are multiple
228 possibilities for the very next character---it could be any of
229 @samp{cfilrs}---so no more characters are added; instead, @key{TAB}
230 displays a list of all possible completions in another window.
231
232 If you go on to type @kbd{f @key{TAB}}, this @key{TAB} sees
233 @samp{auto-f}. The only command name starting this way is
234 @code{auto-fill-mode}, so completion fills in the rest of that. You now
235 have @samp{auto-fill-mode} in the minibuffer after typing just @kbd{au
236 @key{TAB} f @key{TAB}}. Note that @key{TAB} has this effect because in
237 the minibuffer it is bound to the command @code{minibuffer-complete}
238 when completion is available.
239
240 @node Completion Commands
241 @subsection Completion Commands
242
243 Here is a list of the completion commands defined in the minibuffer
244 when completion is available.
245
246 @table @kbd
247 @item @key{TAB}
248 Complete the text before point in the minibuffer as much as possible
249 (@code{minibuffer-complete}).
250 @item @key{SPC}
251 Complete the minibuffer text before point, but don't go beyond one word
252 (@code{minibuffer-complete-word}).
253 @item @key{RET}
254 Submit the text in the minibuffer as the argument, possibly completing
255 first as described below (@code{minibuffer-complete-and-exit}).
256 @item ?
257 Display a list of all possible completions of the text in the minibuffer
258 (@code{minibuffer-list-completions}).
259 @end table
260
261 @kindex SPC
262 @findex minibuffer-complete-word
263 @key{SPC} completes much like @key{TAB}, but never goes beyond the
264 next hyphen or space. If you have @samp{auto-f} in the minibuffer and
265 type @key{SPC}, it finds that the completion is @samp{auto-fill-mode},
266 but it stops completing after @samp{fill-}. This gives
267 @samp{auto-fill-}. Another @key{SPC} at this point completes all the
268 way to @samp{auto-fill-mode}. The command that implements this
269 behavior is called @code{minibuffer-complete-word}.
270
271 Here are some commands you can use to choose a completion from a
272 window that displays a list of completions:
273
274 @table @kbd
275 @findex mouse-choose-completion
276 @item Mouse-2
277 Clicking mouse button 2 on a completion in the list of possible
278 completions chooses that completion (@code{mouse-choose-completion}).
279 You normally use this command while point is in the minibuffer, but you
280 must click in the list of completions, not in the minibuffer itself.
281
282 @findex switch-to-completions
283 @item @key{PRIOR}
284 @itemx M-v
285 Typing @key{PRIOR} or @key{PAGE-UP}, or @kbd{M-v}, while in the
286 minibuffer, selects the window showing the completion list buffer
287 (@code{switch-to-completions}). This paves the way for using the
288 commands below. (Selecting that window in the usual ways has the same
289 effect, but this way is more convenient.)
290
291 @findex choose-completion
292 @item @key{RET}
293 Typing @key{RET} @emph{in the completion list buffer} chooses the
294 completion that point is in or next to (@code{choose-completion}). To
295 use this command, you must first switch windows to the window that shows
296 the list of completions.
297
298 @findex next-completion
299 @item @key{RIGHT}
300 Typing the right-arrow key @key{RIGHT} @emph{in the completion list
301 buffer} moves point to the following completion (@code{next-completion}).
302
303 @findex previous-completion
304 @item @key{LEFT}
305 Typing the left-arrow key @key{LEFT} @emph{in the completion list
306 buffer} moves point toward the beginning of the buffer, to the previous
307 completion (@code{previous-completion}).
308 @end table
309
310 @node Strict Completion
311 @subsection Strict Completion
312
313 There are three different ways that @key{RET} can work in completing
314 minibuffers, depending on how the argument will be used.
315
316 @itemize @bullet
317 @item
318 @dfn{Strict} completion is used when it is meaningless to give any
319 argument except one of the known alternatives. For example, when
320 @kbd{C-x k} reads the name of a buffer to kill, it is meaningless to
321 give anything but the name of an existing buffer. In strict
322 completion, @key{RET} refuses to exit if the text in the minibuffer
323 does not complete to an exact match.
324
325 @item
326 @dfn{Cautious} completion is similar to strict completion, except that
327 @key{RET} exits only if the text was an exact match already, not
328 needing completion. If the text is not an exact match, @key{RET} does
329 not exit, but it does complete the text. If it completes to an exact
330 match, a second @key{RET} will exit.
331
332 Cautious completion is used for reading file names for files that must
333 already exist.
334
335 @item
336 @dfn{Permissive} completion is used when any string whatever is
337 meaningful, and the list of completion alternatives is just a guide.
338 For example, when @kbd{C-x C-f} reads the name of a file to visit, any
339 file name is allowed, in case you want to create a file. In
340 permissive completion, @key{RET} takes the text in the minibuffer
341 exactly as given, without completing it.
342 @end itemize
343
344 The completion commands display a list of all possible completions in
345 a window whenever there is more than one possibility for the very next
346 character. Also, typing @kbd{?} explicitly requests such a list. If
347 the list of completions is long, you can scroll it with @kbd{C-M-v}
348 (@pxref{Other Window}).
349
350 @node Completion Options
351 @subsection Completion Options
352
353 @vindex completion-ignored-extensions
354 @cindex ignored file names, in completion
355 When completion is done on file names, certain file names are usually
356 ignored. The variable @code{completion-ignored-extensions} contains a
357 list of strings; a file whose name ends in any of those strings is
358 ignored as a possible completion. The standard value of this variable
359 has several elements including @code{".o"}, @code{".elc"}, @code{".dvi"}
360 and @code{"~"}. The effect is that, for example, @samp{foo} can
361 complete to @samp{foo.c} even though @samp{foo.o} exists as well.
362 However, if @emph{all} the possible completions end in ``ignored''
363 strings, then they are not ignored. Ignored extensions do not apply to
364 lists of completions---those always mention all possible completions.
365
366 If an element of the list in @code{completion-ignored-extensions} ends
367 in a slash @file{/}, it indicates a subdirectory that should be ignored
368 when completing file names. (Elements of
369 @code{completion-ignored-extensions} which do not end in a slash are
370 never considered when a completion candidate is a directory; thus,
371 completion returns directories whose names end in @file{.elc} even
372 though there's an element @code{".elc"} in the list.)
373
374 @vindex completion-auto-help
375 Normally, a completion command that cannot determine even one
376 additional character automatically displays a list of all possible
377 completions. If the variable @code{completion-auto-help} is set to
378 @code{nil}, this automatic display is disabled, so you must type
379 @kbd{?} to display the list of completions.
380
381 @cindex Partial Completion mode
382 @vindex partial-completion-mode
383 @findex partial-completion-mode
384 Partial Completion mode implements a more powerful kind of
385 completion that can complete multiple words in parallel. For example,
386 it can complete the command name abbreviation @code{p-b} into
387 @code{print-buffer}, because no other command starts with two words
388 whose initials are @samp{p} and @samp{b}.
389
390 Partial completion of directories in file names uses @samp{*} to
391 indicate the places for completion; thus, @file{/u*/b*/f*} might
392 complete to @file{/usr/bin/foo}.
393
394 To enable this mode, use the command @kbd{M-x
395 partial-completion-mode}, or customize the variable
396 @code{partial-completion-mode}. This binds the partial completion
397 commands to @key{TAB}, @key{SPC}, @key{RET}, and @kbd{?}. The usual
398 completion commands are available on @kbd{M-@key{TAB}},
399 @kbd{M-@key{SPC}}, @kbd{M-@key{RET}} and @kbd{M-?}.
400
401 @vindex PC-include-file-path
402 @vindex PC-disable-includes
403 Another feature of Partial Completion mode is to extend
404 @code{find-file} so that the @samp{<@var{include}>} stands for the
405 file named @var{include} in some directory in the path
406 @code{PC-include-file-path}. If you set @code{PC-disable-includes} to
407 non-@code{nil}, this feature is disabled.
408
409 @cindex Icomplete mode
410 @findex icomplete-mode
411 Icomplete mode presents a constantly-updated display that tells you
412 what completions are available for the text you've entered so far. The
413 command to enable or disable this minor mode is @kbd{M-x
414 icomplete-mode}.
415
416 @node Minibuffer History
417 @section Minibuffer History
418 @cindex minibuffer history
419 @cindex history of minibuffer input
420
421 Every argument that you enter with the minibuffer is saved on a
422 @dfn{minibuffer history list} so that you can use it again later in
423 another argument. Special commands load the text of an earlier argument
424 in the minibuffer. They discard the old minibuffer contents, so you can
425 think of them as moving through the history of previous arguments.
426
427 @table @kbd
428 @item @key{UP}
429 @itemx M-p
430 Move to the next earlier argument string saved in the minibuffer history
431 (@code{previous-history-element}).
432 @item @key{DOWN}
433 @itemx M-n
434 Move to the next later argument string saved in the minibuffer history
435 (@code{next-history-element}).
436 @item M-r @var{regexp} @key{RET}
437 Move to an earlier saved argument in the minibuffer history that has a
438 match for @var{regexp} (@code{previous-matching-history-element}).
439 @item M-s @var{regexp} @key{RET}
440 Move to a later saved argument in the minibuffer history that has a
441 match for @var{regexp} (@code{next-matching-history-element}).
442 @end table
443
444 @kindex M-p @r{(minibuffer history)}
445 @kindex M-n @r{(minibuffer history)}
446 @findex next-history-element
447 @findex previous-history-element
448 The simplest way to reuse the saved arguments in the history list is
449 to move through the history list one element at a time. While in the
450 minibuffer, use @kbd{M-p} or up-arrow (@code{previous-history-element})
451 to ``move to'' the next earlier minibuffer input, and use @kbd{M-n} or
452 down-arrow (@code{next-history-element}) to ``move to'' the next later
453 input.
454
455 The previous input that you fetch from the history entirely replaces
456 the contents of the minibuffer. To use it as the argument, exit the
457 minibuffer as usual with @key{RET}. You can also edit the text before
458 you reuse it; this does not change the history element that you
459 ``moved'' to, but your new argument does go at the end of the history
460 list in its own right.
461
462 For many minibuffer arguments there is a ``default'' value. In some
463 cases, the minibuffer history commands know the default value. Then you
464 can insert the default value into the minibuffer as text by using
465 @kbd{M-n} to move ``into the future'' in the history. Eventually we
466 hope to make this feature available whenever the minibuffer has a
467 default value.
468
469 @findex previous-matching-history-element
470 @findex next-matching-history-element
471 @kindex M-r @r{(minibuffer history)}
472 @kindex M-s @r{(minibuffer history)}
473 There are also commands to search forward or backward through the
474 history; they search for history elements that match a regular
475 expression that you specify with the minibuffer. @kbd{M-r}
476 (@code{previous-matching-history-element}) searches older elements in
477 the history, while @kbd{M-s} (@code{next-matching-history-element})
478 searches newer elements. By special dispensation, these commands can
479 use the minibuffer to read their arguments even though you are already
480 in the minibuffer when you issue them. As with incremental searching,
481 an upper-case letter in the regular expression makes the search
482 case-sensitive (@pxref{Search Case}).
483
484 @ignore
485 We may change the precise way these commands read their arguments.
486 Perhaps they will search for a match for the string given so far in the
487 minibuffer; perhaps they will search for a literal match rather than a
488 regular expression match; perhaps they will only accept matches at the
489 beginning of a history element; perhaps they will read the string to
490 search for incrementally like @kbd{C-s}. To find out what interface is
491 actually available, type @kbd{C-h f previous-matching-history-element}.
492 @end ignore
493
494 All uses of the minibuffer record your input on a history list, but
495 there are separate history lists for different kinds of arguments. For
496 example, there is a list for file names, used by all the commands that
497 read file names. (As a special feature, this history list records
498 the absolute file name, no more and no less, even if that is not how
499 you entered the file name.)
500
501 There are several other very specific history lists, including one for
502 command names read by @kbd{M-x}, one for buffer names, one for arguments
503 of commands like @code{query-replace}, and one for compilation commands
504 read by @code{compile}. Finally, there is one ``miscellaneous'' history
505 list that most minibuffer arguments use.
506
507 @vindex history-length
508 The variable @code{history-length} specifies the maximum length of a
509 minibuffer history list; once a list gets that long, the oldest element
510 is deleted each time an element is added. If the value of
511 @code{history-length} is @code{t}, though, there is no maximum length
512 and elements are never deleted.
513
514 @vindex history-delete-duplicates
515 The variable @code{history-delete-duplicates} specifies whether to
516 delete duplicates in history. If the value of @code{history-delete-duplicates}
517 is @code{t}, that means when adding a new history element, all
518 previous identical elements are deleted.
519
520 @node Repetition
521 @section Repeating Minibuffer Commands
522 @cindex command history
523 @cindex history of commands
524
525 Every command that uses the minibuffer at least once is recorded on a
526 special history list, together with the values of its arguments, so that
527 you can repeat the entire command. In particular, every use of
528 @kbd{M-x} is recorded there, since @kbd{M-x} uses the minibuffer to read
529 the command name.
530
531 @findex list-command-history
532 @table @kbd
533 @item C-x @key{ESC} @key{ESC}
534 Re-execute a recent minibuffer command (@code{repeat-complex-command}).
535 @item M-x list-command-history
536 Display the entire command history, showing all the commands
537 @kbd{C-x @key{ESC} @key{ESC}} can repeat, most recent first.
538 @end table
539
540 @kindex C-x ESC ESC
541 @findex repeat-complex-command
542 @kbd{C-x @key{ESC} @key{ESC}} is used to re-execute a recent
543 minibuffer-using command. With no argument, it repeats the last such
544 command. A numeric argument specifies which command to repeat; one
545 means the last one, and larger numbers specify earlier ones.
546
547 @kbd{C-x @key{ESC} @key{ESC}} works by turning the previous command
548 into a Lisp expression and then entering a minibuffer initialized with
549 the text for that expression. If you type just @key{RET}, the command
550 is repeated as before. You can also change the command by editing the
551 Lisp expression. Whatever expression you finally submit is what will be
552 executed. The repeated command is added to the front of the command
553 history unless it is identical to the most recently executed command
554 already there.
555
556 Even if you don't understand Lisp syntax, it will probably be obvious
557 which command is displayed for repetition. If you do not change the
558 text, it will repeat exactly as before.
559
560 Once inside the minibuffer for @kbd{C-x @key{ESC} @key{ESC}}, you can
561 use the minibuffer history commands (@kbd{M-p}, @kbd{M-n}, @kbd{M-r},
562 @kbd{M-s}; @pxref{Minibuffer History}) to move through the history list
563 of saved entire commands. After finding the desired previous command,
564 you can edit its expression as usual and then resubmit it by typing
565 @key{RET} as usual.
566
567 @vindex isearch-resume-in-command-history
568 Incremental search does not, strictly speaking, use the minibuffer,
569 but it does something similar. Although it behaves like a complex command,
570 it normally does not appear in the history list for @kbd{C-x
571 @key{ESC} @key{ESC}}. You can make it appear in the history by
572 setting @code{isearch-resume-in-command-history} to a non-@code{nil}
573 value.
574
575 @vindex command-history
576 The list of previous minibuffer-using commands is stored as a Lisp
577 list in the variable @code{command-history}. Each element is a Lisp
578 expression which describes one command and its arguments. Lisp programs
579 can re-execute a command by calling @code{eval} with the
580 @code{command-history} element.
581
582 @ignore
583 arch-tag: ba913cfd-b70e-400f-b663-22b2c309227f
584 @end ignore