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