|
0
|
1
|
|
|
2 @node Minibuffer, M-x, Undo, Top
|
|
|
3 @chapter The Minibuffer
|
|
|
4 @cindex minibuffer
|
|
|
5
|
|
398
|
6 The @dfn{minibuffer} is the facility used by XEmacs commands to read
|
|
|
7 arguments more complicated than a single number. Minibuffer arguments
|
|
|
8 can be file names, buffer names, Lisp function names, XEmacs command
|
|
|
9 names, Lisp expressions, and many other things, depending on the command
|
|
|
10 reading the argument. You can use the usual XEmacs editing commands in
|
|
|
11 the minibuffer to edit the argument text.
|
|
0
|
12
|
|
|
13 @cindex prompt
|
|
|
14 When the minibuffer is in use, it appears in the echo area, and the
|
|
|
15 cursor moves there. The beginning of the minibuffer line displays a
|
|
398
|
16 @dfn{prompt} which says what kind of input you should supply and how it
|
|
|
17 will be used. Often this prompt is derived from the name of the command
|
|
|
18 that the argument is for. The prompt normally ends with a colon.
|
|
0
|
19
|
|
|
20 @cindex default argument
|
|
|
21 Sometimes a @dfn{default argument} appears in parentheses after the
|
|
|
22 colon; it, too, is part of the prompt. The default is used as the
|
|
|
23 argument value if you enter an empty argument (e.g., by just typing @key{RET}).
|
|
|
24 For example, commands that read buffer names always show a default, which
|
|
|
25 is the name of the buffer that will be used if you type just @key{RET}.
|
|
|
26
|
|
|
27 @kindex C-g
|
|
398
|
28 The simplest way to enter a minibuffer argument is to type the text
|
|
|
29 you want, terminated by @key{RET} which exits the minibuffer. You can
|
|
|
30 cancel the command that wants the argument, and get out of the
|
|
|
31 minibuffer, by typing @kbd{C-g}.
|
|
0
|
32
|
|
|
33 Since the minibuffer uses the screen space of the echo area, it can
|
|
398
|
34 conflict with other ways XEmacs customarily uses the echo area. Here is
|
|
|
35 how XEmacs handles such conflicts:
|
|
0
|
36
|
|
|
37 @itemize @bullet
|
|
|
38 @item
|
|
|
39 If a command gets an error while you are in the minibuffer, this does
|
|
|
40 not cancel the minibuffer. However, the echo area is needed for the
|
|
|
41 error message and therefore the minibuffer itself is hidden for a
|
|
|
42 while. It comes back after a few seconds, or as soon as you type
|
|
|
43 anything.
|
|
|
44
|
|
|
45 @item
|
|
398
|
46 If in the minibuffer you use a command whose purpose is to print a
|
|
|
47 message in the echo area, such as @kbd{C-x =}, the message is printed
|
|
|
48 normally, and the minibuffer is hidden for a while. It comes back
|
|
0
|
49 after a few seconds, or as soon as you type anything.
|
|
|
50
|
|
|
51 @item
|
|
|
52 Echoing of keystrokes does not take place while the minibuffer is in
|
|
|
53 use.
|
|
|
54 @end itemize
|
|
|
55
|
|
|
56 @menu
|
|
|
57 * File: Minibuffer File. Entering file names with the minibuffer.
|
|
|
58 * Edit: Minibuffer Edit. How to edit in the minibuffer.
|
|
|
59 * Completion:: An abbreviation facility for minibuffer input.
|
|
398
|
60 * Minibuffer History:: Reusing recent minibuffer arguments.
|
|
0
|
61 * Repetition:: Re-executing commands that used the minibuffer.
|
|
|
62 @end menu
|
|
|
63
|
|
|
64 @node Minibuffer File, Minibuffer Edit, Minibuffer, Minibuffer
|
|
|
65 @section Minibuffers for File Names
|
|
|
66
|
|
|
67 Sometimes the minibuffer starts out with text in it. For example, when
|
|
|
68 you are supposed to give a file name, the minibuffer starts out containing
|
|
398
|
69 the @dfn{default directory}, which ends with a slash. This is to inform
|
|
|
70 you which directory the file will be found in if you do not specify a
|
|
|
71 directory.
|
|
|
72
|
|
|
73 For example, the minibuffer might start out with these contents:
|
|
0
|
74
|
|
|
75 @example
|
|
|
76 Find File: /u2/emacs/src/
|
|
|
77 @end example
|
|
|
78
|
|
|
79 @noindent
|
|
398
|
80 where @samp{Find File:@: } is the prompt. Typing @kbd{buffer.c}
|
|
|
81 specifies the file @file{/u2/emacs/src/buffer.c}. To find files in
|
|
|
82 nearby directories, use @kbd{..}; thus, if you type
|
|
|
83 @kbd{../lisp/simple.el}, you will get the file named
|
|
|
84 @file{/u2/emacs/lisp/simple.el}. Alternatively, you can kill with
|
|
|
85 @kbd{M-@key{DEL}} the directory names you don't want (@pxref{Words}).
|
|
0
|
86
|
|
398
|
87 If you don't want any of the default, you can kill it with @kbd{C-a
|
|
|
88 C-k}. But you don't need to kill the default; you can simply ignore it.
|
|
|
89 Insert an absolute file name, one starting with a slash or a tilde,
|
|
|
90 after the default directory. For example, to specify the file
|
|
|
91 @file{/etc/termcap}, just insert that name, giving these minibuffer
|
|
|
92 contents:
|
|
0
|
93
|
|
|
94 @example
|
|
|
95 Find File: /u2/emacs/src//etc/termcap
|
|
|
96 @end example
|
|
|
97
|
|
|
98 @noindent
|
|
398
|
99 @cindex // in file name
|
|
|
100 @cindex double slash in file name
|
|
|
101 @cindex slashes repeated in file name
|
|
|
102 XEmacs gives a special meaning to a double slash (which is not normally
|
|
|
103 a useful thing to write): it means, ``ignore everything before the
|
|
|
104 second slash in the pair.'' Thus, @samp{/u2/emacs/src/} is ignored in
|
|
|
105 the example above, and you get the file @file{/etc/termcap}.
|
|
0
|
106
|
|
|
107 @vindex insert-default-directory
|
|
|
108 If you set @code{insert-default-directory} to @code{nil}, the default
|
|
|
109 directory is not inserted in the minibuffer. This way, the minibuffer
|
|
|
110 starts out empty. But the name you type, if relative, is still
|
|
|
111 interpreted with respect to the same default directory.
|
|
|
112
|
|
|
113 @node Minibuffer Edit, Completion, Minibuffer File, Minibuffer
|
|
|
114 @section Editing in the Minibuffer
|
|
|
115
|
|
398
|
116 The minibuffer is an XEmacs buffer (albeit a peculiar one), and the
|
|
|
117 usual XEmacs commands are available for editing the text of an argument
|
|
|
118 you are entering.
|
|
0
|
119
|
|
|
120 Since @key{RET} in the minibuffer is defined to exit the minibuffer,
|
|
398
|
121 you can't use it to insert a newline in the minibuffer. To do that,
|
|
|
122 type @kbd{C-o} or @kbd{C-q C-j}. (Recall that a newline is really the
|
|
|
123 character control-J.)
|
|
0
|
124
|
|
398
|
125 The minibuffer has its own window which always has space on the screen
|
|
|
126 but acts as if it were not there when the minibuffer is not in use.
|
|
|
127 When the minibuffer is in use, its window is just like the others; you
|
|
|
128 can switch to another window with @kbd{C-x o}, edit text in other
|
|
|
129 windows and perhaps even visit more files, before returning to the
|
|
|
130 minibuffer to submit the argument. You can kill text in another window,
|
|
|
131 return to the minibuffer window, and then yank the text to use it in the
|
|
|
132 argument. @xref{Windows}.
|
|
0
|
133
|
|
398
|
134 There are some restrictions on the use of the minibuffer window,
|
|
|
135 however. You cannot switch buffers in it---the minibuffer and its
|
|
|
136 window are permanently attached. Also, you cannot split or kill the
|
|
|
137 minibuffer window. But you can make it taller in the normal fashion with
|
|
|
138 @kbd{C-x ^}.
|
|
0
|
139
|
|
|
140 @kindex C-M-v
|
|
398
|
141 If while in the minibuffer you issue a command that displays help text
|
|
|
142 of any sort in another window, you can use the @kbd{C-M-v} command while
|
|
|
143 in the minibuffer to scroll the help text. This lasts until you exit
|
|
|
144 the minibuffer. This feature is especially useful if a completing
|
|
|
145 minibuffer gives you a list of possible completions. @xref{Other Window}.
|
|
0
|
146
|
|
398
|
147 @vindex minibuffer-confirm-incomplete
|
|
0
|
148 If the variable @code{minibuffer-confirm-incomplete} is @code{t}, you
|
|
|
149 are asked for confirmation if there is no known completion for the text
|
|
|
150 you typed. For example, if you attempted to visit a non-existent file,
|
|
|
151 the minibuffer might read:
|
|
|
152 @example
|
|
398
|
153 Find File: chocolate_bar.c [no completions, confirm]
|
|
0
|
154 @end example
|
|
|
155 If you press @kbd{Return} again, that confirms the filename. Otherwise,
|
|
|
156 you can continue editing it.
|
|
|
157
|
|
398
|
158 XEmacs supports recursive use of the minibuffer. However, it is easy
|
|
|
159 to do this by accident (because of autorepeating keyboards, for example)
|
|
|
160 and get confused. Therefore, most XEmacs commands that use the
|
|
|
161 minibuffer refuse to operate if the minibuffer window is selected. If
|
|
|
162 the minibuffer is active but you have switched to a different window,
|
|
|
163 recursive use of the minibuffer is allowed---if you know enough to try
|
|
|
164 to do this, you probably will not get confused.
|
|
0
|
165
|
|
|
166 @vindex enable-recursive-minibuffers
|
|
398
|
167 If you set the variable @code{enable-recursive-minibuffers} to a
|
|
0
|
168 non-@code{nil}, recursive use of the minibuffer is always allowed.
|
|
|
169
|
|
398
|
170 @node Completion, Minibuffer History, Minibuffer Edit, Minibuffer
|
|
0
|
171 @section Completion
|
|
|
172 @cindex completion
|
|
|
173
|
|
398
|
174 For certain kinds of arguments, you can use @dfn{completion} to enter
|
|
|
175 the argument value. Completion means that you type part of the
|
|
|
176 argument, then XEmacs visibly fills in the rest, or as much as
|
|
|
177 can be determined from the part you have typed.
|
|
0
|
178
|
|
|
179 When completion is available, certain keys---@key{TAB}, @key{RET}, and
|
|
398
|
180 @key{SPC}---are rebound to complete the text present in the
|
|
0
|
181 minibuffer into a longer string that it stands for, by matching it
|
|
|
182 against a set of @dfn{completion alternatives} provided by the command
|
|
|
183 reading the argument. @kbd{?} is defined to display a list of possible
|
|
|
184 completions of what you have inserted.
|
|
|
185
|
|
398
|
186 For example, when @kbd{M-x} uses the minibuffer to read the name of a
|
|
|
187 command, it provides a list of all available XEmacs command names to
|
|
|
188 complete against. The completion keys match the text in the minibuffer
|
|
|
189 against all the command names, find any additional name characters
|
|
|
190 implied by the ones already present in the minibuffer, and add those
|
|
|
191 characters to the ones you have given. This is what makes it possible
|
|
|
192 to type @kbd{M-x inse @key{SPC} b @key{RET}} instead of @kbd{M-x
|
|
|
193 insert-buffer @key{RET}} (for example).
|
|
0
|
194
|
|
398
|
195 Case is normally significant in completion because it is significant
|
|
|
196 in most of the names that you can complete (buffer names, file names and
|
|
|
197 command names). Thus, @samp{fo} does not complete to @samp{Foo}. When
|
|
|
198 you are completing a name in which case does not matter, case may be
|
|
|
199 ignored for completion's sake if specified by program.
|
|
0
|
200
|
|
|
201 When a completion list is displayed, the completions will highlight as
|
|
|
202 you move the mouse over them. Clicking the middle mouse button on any
|
|
|
203 highlighted completion will ``select'' it just as if you had typed it in
|
|
|
204 and hit @key{RET}.
|
|
|
205
|
|
398
|
206 @menu
|
|
|
207 * Example: Completion Example.
|
|
|
208 * Commands: Completion Commands.
|
|
|
209 * Strict Completion::
|
|
|
210 * Options: Completion Options.
|
|
|
211 @end menu
|
|
|
212
|
|
|
213 @node Completion Example, Completion Commands, Completion, Completion
|
|
|
214 @subsection Completion Example
|
|
0
|
215
|
|
|
216 @kindex TAB
|
|
|
217 @findex minibuffer-complete
|
|
398
|
218 A concrete example may help here. If you type @kbd{M-x au @key{TAB}},
|
|
|
219 the @key{TAB} looks for alternatives (in this case, command names) that
|
|
|
220 start with @samp{au}. There are several, including
|
|
|
221 @code{auto-fill-mode} and @code{auto-save-mode}---but they are all the
|
|
|
222 same as far as @code{auto}, so the @samp{au} in the minibuffer changes
|
|
|
223 to @samp{auto}.
|
|
0
|
224
|
|
398
|
225 If you type @key{TAB} again immediately, there are multiple
|
|
|
226 possibilities for the very next character---it could be any of
|
|
|
227 @samp{c-}---so no more characters are added; instead, @key{TAB}
|
|
|
228 displays a list of all possible completions in another window.
|
|
0
|
229
|
|
|
230 If you go on to type @kbd{f @key{TAB}}, this @key{TAB} sees
|
|
|
231 @samp{auto-f}. The only command name starting this way is
|
|
398
|
232 @code{auto-fill-mode}, so completion fills in the rest of that. You now
|
|
|
233 have @samp{auto-fill-mode} in the minibuffer after typing just @kbd{au
|
|
|
234 @key{TAB} f @key{TAB}}. Note that @key{TAB} has this effect because in
|
|
|
235 the minibuffer it is bound to the command @code{minibuffer-complete}
|
|
|
236 when completion is available.
|
|
0
|
237
|
|
398
|
238 @node Completion Commands, Strict Completion, Completion Example, Completion
|
|
0
|
239 @subsection Completion Commands
|
|
|
240
|
|
398
|
241 Here is a list of the completion commands defined in the minibuffer
|
|
0
|
242 when completion is available.
|
|
|
243
|
|
|
244 @table @kbd
|
|
|
245 @item @key{TAB}
|
|
398
|
246 Complete the text in the minibuffer as much as possible
|
|
0
|
247 (@code{minibuffer-complete}).
|
|
|
248 @item @key{SPC}
|
|
398
|
249 Complete the minibuffer text, but don't go beyond one word
|
|
|
250 (@code{minibuffer-complete-word}).
|
|
0
|
251 @item @key{RET}
|
|
|
252 Submit the text in the minibuffer as the argument, possibly completing
|
|
|
253 first as described below (@code{minibuffer-complete-and-exit}).
|
|
|
254 @item ?
|
|
|
255 Print a list of all possible completions of the text in the minibuffer
|
|
|
256 (@code{minibuffer-list-completions}).
|
|
|
257 @item @key{button2}
|
|
|
258 Select the highlighted text under the mouse as a minibuffer response.
|
|
|
259 When the minibuffer is being used to prompt the user for a completion,
|
|
|
260 any valid completions which are visible on the screen will be highlighted
|
|
|
261 when the mouse moves over them. Clicking @key{button2} will select the
|
|
|
262 highlighted completion and exit the minibuffer.
|
|
|
263 (@code{minibuf-select-highlighted-completion}).
|
|
|
264 @end table
|
|
|
265
|
|
|
266 @kindex SPC
|
|
|
267 @findex minibuffer-complete-word
|
|
398
|
268 @key{SPC} completes much like @key{TAB}, but never goes beyond the
|
|
|
269 next hyphen or space. If you have @samp{auto-f} in the minibuffer and
|
|
|
270 type @key{SPC}, it finds that the completion is @samp{auto-fill-mode},
|
|
|
271 but it stops completing after @samp{fill-}. This gives
|
|
|
272 @samp{auto-fill-}. Another @key{SPC} at this point completes all the
|
|
|
273 way to @samp{auto-fill-mode}. @key{SPC} in the minibuffer when
|
|
|
274 completion is available runs the command
|
|
|
275 @code{minibuffer-complete-word}.
|
|
|
276
|
|
|
277 Here are some commands you can use to choose a completion from a
|
|
|
278 window that displays a list of completions:
|
|
|
279
|
|
|
280 @table @kbd
|
|
|
281 @findex mouse-choose-completion
|
|
|
282 @item button2up
|
|
|
283 Clicking mouse button 2 on a completion in the list of possible
|
|
|
284 completions chooses that completion (@code{mouse-choose-completion}).
|
|
|
285 You normally use this command while point is in the minibuffer; but you
|
|
|
286 must click in the list of completions, not in the minibuffer itself.
|
|
|
287
|
|
|
288 @findex choose-completion
|
|
|
289 @item @key{RET}
|
|
|
290 Typing @key{RET} @emph{in the completion list buffer} chooses the
|
|
|
291 completion that point is in or next to (@code{choose-completion}). To
|
|
|
292 use this command, you must first switch windows to the window that shows
|
|
|
293 the list of completions.
|
|
|
294
|
|
|
295 @findex next-list-mode-item
|
|
|
296 @item @key{RIGHT}
|
|
|
297 @itemx @key{TAB}
|
|
|
298 @itemx C-f
|
|
|
299 Typing the right-arrow key @key{RIGHT}, @key{TAB} or @kbd{C-f} @emph{in
|
|
|
300 the completion list buffer} moves point to the following completion
|
|
|
301 (@code{next-list-mode-item}).
|
|
|
302
|
|
|
303 @findex previous-list-mode-item
|
|
|
304 @item @key{LEFT}
|
|
|
305 @itemx C-b
|
|
|
306 Typing the left-arrow key @key{LEFT} or @kbd{C-b} @emph{in the
|
|
|
307 completion list buffer} moves point toward the beginning of the buffer,
|
|
|
308 to the previous completion (@code{previous-list-mode-item}).
|
|
|
309 @end table
|
|
|
310
|
|
|
311 @node Strict Completion, Completion Options, Completion Commands, Completion
|
|
|
312 @subsection Strict Completion
|
|
0
|
313
|
|
|
314 There are three different ways that @key{RET} can work in completing
|
|
|
315 minibuffers, depending on how the argument will be used.
|
|
|
316
|
|
|
317 @itemize @bullet
|
|
|
318 @item
|
|
|
319 @dfn{Strict} completion is used when it is meaningless to give any
|
|
|
320 argument except one of the known alternatives. For example, when
|
|
|
321 @kbd{C-x k} reads the name of a buffer to kill, it is meaningless to
|
|
|
322 give anything but the name of an existing buffer. In strict
|
|
|
323 completion, @key{RET} refuses to exit if the text in the minibuffer
|
|
|
324 does not complete to an exact match.
|
|
|
325
|
|
|
326 @item
|
|
|
327 @dfn{Cautious} completion is similar to strict completion, except that
|
|
|
328 @key{RET} exits only if the text was an exact match already, not
|
|
|
329 needing completion. If the text is not an exact match, @key{RET} does
|
|
|
330 not exit, but it does complete the text. If it completes to an exact
|
|
|
331 match, a second @key{RET} will exit.
|
|
|
332
|
|
|
333 Cautious completion is used for reading file names for files that must
|
|
|
334 already exist.
|
|
|
335
|
|
|
336 @item
|
|
398
|
337 @dfn{Permissive} completion is used when any string whatever is
|
|
0
|
338 meaningful, and the list of completion alternatives is just a guide.
|
|
|
339 For example, when @kbd{C-x C-f} reads the name of a file to visit, any
|
|
|
340 file name is allowed, in case you want to create a file. In
|
|
|
341 permissive completion, @key{RET} takes the text in the minibuffer
|
|
|
342 exactly as given, without completing it.
|
|
|
343 @end itemize
|
|
|
344
|
|
398
|
345 The completion commands display a list of all possible completions in
|
|
|
346 a window whenever there is more than one possibility for the very next
|
|
|
347 character. Also, typing @kbd{?} explicitly requests such a list. If
|
|
|
348 the list of completions is long, you can scroll it with @kbd{C-M-v}
|
|
|
349 (@pxref{Other Window}).
|
|
|
350
|
|
|
351 @node Completion Options, , Strict Completion, Completion
|
|
|
352 @subsection Completion Options
|
|
0
|
353
|
|
|
354 @vindex completion-ignored-extensions
|
|
|
355 When completion is done on file names, certain file names are usually
|
|
398
|
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.
|
|
0
|
365
|
|
|
366 @vindex completion-auto-help
|
|
|
367 If a completion command finds the next character is undetermined, it
|
|
|
368 automatically displays a list of all possible completions. If the variable
|
|
|
369 @code{completion-auto-help} is set to @code{nil}, this does not happen,
|
|
|
370 and you must type @kbd{?} to display the possible completions.
|
|
|
371
|
|
|
372 @vindex minibuffer-confirm-incomplete
|
|
|
373 If the variable @code{minibuffer-confirm-incomplete} is set to @code{t},
|
|
|
374 then in contexts where @code{completing-read} allows answers that are
|
|
|
375 not valid completions, an extra @key{RET} must be typed to confirm the
|
|
|
376 response. This is helpful for catching typos.
|
|
|
377
|
|
398
|
378 @node Minibuffer History, Repetition, Completion, Minibuffer
|
|
|
379 @section Minibuffer History
|
|
|
380 @cindex minibuffer history
|
|
|
381 @cindex history of minibuffer input
|
|
|
382
|
|
|
383 Every argument that you enter with the minibuffer is saved on a
|
|
|
384 @dfn{minibuffer history list} so that you can use it again later in
|
|
|
385 another argument. Special commands load the text of an earlier argument
|
|
|
386 in the minibuffer. They discard the old minibuffer contents, so you can
|
|
|
387 think of them as moving through the history of previous arguments.
|
|
|
388
|
|
|
389 @table @kbd
|
|
|
390 @item @key{UP}
|
|
|
391 @itemx M-p
|
|
|
392 Move to the next earlier argument string saved in the minibuffer history
|
|
|
393 (@code{previous-history-element}).
|
|
|
394 @item @key{DOWN}
|
|
|
395 @itemx M-n
|
|
|
396 Move to the next later argument string saved in the minibuffer history
|
|
|
397 (@code{next-history-element}).
|
|
|
398 @item M-r @var{regexp} @key{RET}
|
|
|
399 Move to an earlier saved argument in the minibuffer history that has a
|
|
|
400 match for @var{regexp} (@code{previous-matching-history-element}).
|
|
|
401 @item M-s @var{regexp} @key{RET}
|
|
|
402 Move to a later saved argument in the minibuffer history that has a
|
|
|
403 match for @var{regexp} (@code{next-matching-history-element}).
|
|
|
404 @end table
|
|
|
405
|
|
|
406 @kindex M-p @r{(minibuffer history)}
|
|
|
407 @kindex M-n @r{(minibuffer history)}
|
|
|
408 @findex next-history-element
|
|
|
409 @findex previous-history-element
|
|
|
410 The simplest way to reuse the saved arguments in the history list is
|
|
|
411 to move through the history list one element at a time. While in the
|
|
|
412 minibuffer, use @kbd{M-p} or up-arrow (@code{previous-history-element})
|
|
|
413 to ``move to'' the next earlier minibuffer input, and use @kbd{M-n} or
|
|
|
414 down-arrow (@code{next-history-element}) to ``move to'' the next later
|
|
|
415 input.
|
|
|
416
|
|
|
417 The previous input that you fetch from the history entirely replaces
|
|
|
418 the contents of the minibuffer. To use it as the argument, exit the
|
|
|
419 minibuffer as usual with @key{RET}. You can also edit the text before
|
|
|
420 you reuse it; this does not change the history element that you
|
|
|
421 ``moved'' to, but your new argument does go at the end of the history
|
|
|
422 list in its own right.
|
|
|
423
|
|
|
424 For many minibuffer arguments there is a ``default'' value. In some
|
|
|
425 cases, the minibuffer history commands know the default value. Then you
|
|
|
426 can insert the default value into the minibuffer as text by using
|
|
|
427 @kbd{M-n} to move ``into the future'' in the history.
|
|
|
428
|
|
|
429 @findex previous-matching-history-element
|
|
|
430 @findex next-matching-history-element
|
|
|
431 @kindex M-r @r{(minibuffer history)}
|
|
|
432 @kindex M-s @r{(minibuffer history)}
|
|
|
433 There are also commands to search forward or backward through the
|
|
|
434 history; they search for history elements that match a regular
|
|
|
435 expression that you specify with the minibuffer. @kbd{M-r}
|
|
|
436 (@code{previous-matching-history-element}) searches older elements in
|
|
|
437 the history, while @kbd{M-s} (@code{next-matching-history-element})
|
|
|
438 searches newer elements. By special dispensation, these commands can
|
|
|
439 use the minibuffer to read their arguments even though you are already
|
|
|
440 in the minibuffer when you issue them. As with incremental searching,
|
|
|
441 an uppercase letter in the regular expression makes the search
|
|
|
442 case-sensitive (@pxref{Search Case}).
|
|
|
443
|
|
|
444 All uses of the minibuffer record your input on a history list, but
|
|
|
445 there are separate history lists for different kinds of arguments. For
|
|
|
446 example, there is a list for file names, used by all the commands that
|
|
|
447 read file names.
|
|
|
448
|
|
|
449 There are several other very specific history lists, including one for
|
|
|
450 command names read by @kbd{M-x}, one for buffer names, one for arguments
|
|
|
451 of commands like @code{query-replace}, and one for compilation commands
|
|
|
452 read by @code{compile}. Finally, there is one ``miscellaneous'' history
|
|
|
453 list that most minibuffer arguments use.
|
|
|
454
|
|
|
455 @c Do wee need this?
|
|
|
456 @ignore
|
|
|
457 @vindex history-length
|
|
|
458 The variable @code{history-length} specifies the maximum length of a
|
|
|
459 minibuffer history list; once a list gets that long, the oldest element
|
|
|
460 is deleted each time an element is added. If the value of
|
|
|
461 @code{history-length} is @code{t}, though, there is no maximum length
|
|
|
462 and elements are never deleted.
|
|
|
463 @end ignore
|
|
|
464
|
|
|
465 @node Repetition, , Minibuffer History, Minibuffer
|
|
0
|
466 @section Repeating Minibuffer Commands
|
|
|
467 @cindex command history
|
|
|
468 @cindex history of commands
|
|
|
469
|
|
|
470 Every command that uses the minibuffer at least once is recorded on a
|
|
398
|
471 special history list, together with the values of its arguments, so that
|
|
|
472 you can repeat the entire command. In particular, every use of
|
|
|
473 @kbd{M-x} is recorded there, since @kbd{M-x} uses the minibuffer to read
|
|
|
474 the command name.
|
|
0
|
475
|
|
|
476 @findex list-command-history
|
|
|
477 @c widecommands
|
|
|
478 @table @kbd
|
|
398
|
479 @item C-x @key{ESC} @key{ESC}
|
|
|
480 Re-execute a recent minibuffer command (@code{repeat-complex-command}).
|
|
0
|
481 @item M-p
|
|
|
482 Within @kbd{C-x @key{ESC}}, move to previous recorded command
|
|
|
483 (@code{previous-history-element}).
|
|
|
484 @item M-n
|
|
|
485 Within @kbd{C-x @key{ESC}}, move to the next (more recent) recorded
|
|
398
|
486 command (@code{next-history-element}).
|
|
0
|
487 @item M-x list-command-history
|
|
|
488 Display the entire command history, showing all the commands
|
|
398
|
489 @kbd{C-x @key{ESC} @key{ESC}} can repeat, most recent first.
|
|
0
|
490 @end table
|
|
|
491
|
|
398
|
492 @kindex C-x ESC ESC
|
|
0
|
493 @findex repeat-complex-command
|
|
398
|
494 @kbd{C-x @key{ESC} @key{ESC}} is used to re-execute a recent
|
|
|
495 minibuffer-using command. With no argument, it repeats the last such
|
|
|
496 command. A numeric argument specifies which command to repeat; one
|
|
|
497 means the last one, and larger numbers specify earlier ones.
|
|
0
|
498
|
|
398
|
499 @kbd{C-x @key{ESC} @key{ESC}} works by turning the previous command
|
|
|
500 into a Lisp expression and then entering a minibuffer initialized with
|
|
|
501 the text for that expression. If you type just @key{RET}, the command
|
|
|
502 is repeated as before. You can also change the command by editing the
|
|
|
503 Lisp expression. Whatever expression you finally submit is what will be
|
|
|
504 executed. The repeated command is added to the front of the command
|
|
|
505 history unless it is identical to the most recently executed command
|
|
|
506 already there.
|
|
0
|
507
|
|
|
508 Even if you don't understand Lisp syntax, it will probably be obvious
|
|
|
509 which command is displayed for repetition. If you do not change the text,
|
|
|
510 you can be sure the command will repeat exactly as before.
|
|
|
511
|
|
|
512 @kindex M-n
|
|
|
513 @kindex M-p
|
|
|
514 @findex next-complex-command
|
|
|
515 @findex previous-complex-command
|
|
398
|
516 If you are in the minibuffer for @kbd{C-x @key{ESC} @key{ESC}} and the
|
|
|
517 command shown to you is not the one you want to repeat, you can move
|
|
|
518 around the list of previous commands using @kbd{M-n} and @kbd{M-p}.
|
|
|
519 @kbd{M-p} replaces the contents of the minibuffer with the next earlier
|
|
|
520 recorded command, and @kbd{M-n} replaces it with the next later command.
|
|
|
521 After finding the desired previous command, you can edit its expression
|
|
|
522 and then resubmit it by typing @key{RET}. Any editing you have done on
|
|
|
523 the command to be repeated is lost if you use @kbd{M-n} or @kbd{M-p}.
|
|
0
|
524
|
|
398
|
525 @kbd{M-n} and @kbd{M-p} are specially defined within @kbd{C-x @key{ESC}
|
|
|
526 @key{ESC}} to run the commands @code{previous-history-element} and
|
|
0
|
527 @code{next-history-element}.
|
|
|
528
|
|
|
529 @vindex command-history
|
|
|
530 The list of previous commands using the minibuffer is stored as a Lisp
|
|
|
531 list in the variable @code{command-history}. Each element of the list
|
|
|
532 is a Lisp expression which describes one command and its arguments.
|
|
|
533 Lisp programs can reexecute a command by feeding the corresponding
|
|
|
534 @code{command-history} element to @code{eval}.
|
