Commit | Line | Data |
---|---|---|
6bf7aab6 | 1 | @c This is part of the Emacs manual. |
1de69f0c | 2 | @c Copyright (C) 1985, 86, 87, 93-95, 97, 2000 Free Software Foundation, Inc. |
6bf7aab6 DL |
3 | @c See file emacs.texi for copying conditions. |
4 | @node Search, Fixit, Display, Top | |
5 | @chapter Searching and Replacement | |
6 | @cindex searching | |
7 | @cindex finding strings within text | |
8 | ||
9 | Like other editors, Emacs has commands for searching for occurrences of | |
10 | a string. The principal search command is unusual in that it is | |
11 | @dfn{incremental}; it begins to search before you have finished typing the | |
12 | search string. There are also nonincremental search commands more like | |
13 | those of other editors. | |
14 | ||
15 | Besides the usual @code{replace-string} command that finds all | |
16 | occurrences of one string and replaces them with another, Emacs has a fancy | |
17 | replacement command called @code{query-replace} which asks interactively | |
18 | which occurrences to replace. | |
19 | ||
20 | @menu | |
21 | * Incremental Search:: Search happens as you type the string. | |
22 | * Nonincremental Search:: Specify entire string and then search. | |
23 | * Word Search:: Search for sequence of words. | |
24 | * Regexp Search:: Search for match for a regexp. | |
25 | * Regexps:: Syntax of regular expressions. | |
26 | * Search Case:: To ignore case while searching, or not. | |
27 | * Replace:: Search, and replace some or all matches. | |
28 | * Other Repeating Search:: Operating on all matches for some regexp. | |
29 | @end menu | |
30 | ||
31 | @node Incremental Search, Nonincremental Search, Search, Search | |
32 | @section Incremental Search | |
33 | ||
34 | @cindex incremental search | |
35 | An incremental search begins searching as soon as you type the first | |
36 | character of the search string. As you type in the search string, Emacs | |
37 | shows you where the string (as you have typed it so far) would be | |
38 | found. When you have typed enough characters to identify the place you | |
39 | want, you can stop. Depending on what you plan to do next, you may or | |
40 | may not need to terminate the search explicitly with @key{RET}. | |
41 | ||
42 | @c WideCommands | |
43 | @table @kbd | |
44 | @item C-s | |
45 | Incremental search forward (@code{isearch-forward}). | |
46 | @item C-r | |
47 | Incremental search backward (@code{isearch-backward}). | |
48 | @end table | |
49 | ||
50 | @kindex C-s | |
51 | @findex isearch-forward | |
52 | @kbd{C-s} starts an incremental search. @kbd{C-s} reads characters from | |
53 | the keyboard and positions the cursor at the first occurrence of the | |
54 | characters that you have typed. If you type @kbd{C-s} and then @kbd{F}, | |
55 | the cursor moves right after the first @samp{F}. Type an @kbd{O}, and see | |
56 | the cursor move to after the first @samp{FO}. After another @kbd{O}, the | |
57 | cursor is after the first @samp{FOO} after the place where you started the | |
58 | search. At each step, the buffer text that matches the search string is | |
59 | highlighted, if the terminal can do that; at each step, the current search | |
60 | string is updated in the echo area. | |
61 | ||
62 | If you make a mistake in typing the search string, you can cancel | |
63 | characters with @key{DEL}. Each @key{DEL} cancels the last character of | |
64 | search string. This does not happen until Emacs is ready to read another | |
65 | input character; first it must either find, or fail to find, the character | |
66 | you want to erase. If you do not want to wait for this to happen, use | |
67 | @kbd{C-g} as described below. | |
68 | ||
69 | When you are satisfied with the place you have reached, you can type | |
70 | @key{RET}, which stops searching, leaving the cursor where the search | |
71 | brought it. Also, any command not specially meaningful in searches | |
72 | stops the searching and is then executed. Thus, typing @kbd{C-a} would | |
73 | exit the search and then move to the beginning of the line. @key{RET} | |
74 | is necessary only if the next command you want to type is a printing | |
75 | character, @key{DEL}, @key{RET}, or another control character that is | |
76 | special within searches (@kbd{C-q}, @kbd{C-w}, @kbd{C-r}, @kbd{C-s}, | |
77 | @kbd{C-y}, @kbd{M-y}, @kbd{M-r}, or @kbd{M-s}). | |
78 | ||
79 | Sometimes you search for @samp{FOO} and find it, but not the one you | |
80 | expected to find. There was a second @samp{FOO} that you forgot about, | |
81 | before the one you were aiming for. In this event, type another @kbd{C-s} | |
82 | to move to the next occurrence of the search string. This can be done any | |
83 | number of times. If you overshoot, you can cancel some @kbd{C-s} | |
84 | characters with @key{DEL}. | |
85 | ||
86 | After you exit a search, you can search for the same string again by | |
87 | typing just @kbd{C-s C-s}: the first @kbd{C-s} is the key that invokes | |
88 | incremental search, and the second @kbd{C-s} means ``search again.'' | |
89 | ||
90 | To reuse earlier search strings, use the @dfn{search ring}. The | |
91 | commands @kbd{M-p} and @kbd{M-n} move through the ring to pick a search | |
92 | string to reuse. These commands leave the selected search ring element | |
93 | in the minibuffer, where you can edit it. Type @kbd{C-s} or @kbd{C-r} | |
94 | to terminate editing the string and search for it. | |
95 | ||
96 | If your string is not found at all, the echo area says @samp{Failing | |
97 | I-Search}. The cursor is after the place where Emacs found as much of your | |
98 | string as it could. Thus, if you search for @samp{FOOT}, and there is no | |
99 | @samp{FOOT}, you might see the cursor after the @samp{FOO} in @samp{FOOL}. | |
100 | At this point there are several things you can do. If your string was | |
101 | mistyped, you can rub some of it out and correct it. If you like the place | |
102 | you have found, you can type @key{RET} or some other Emacs command to | |
103 | ``accept what the search offered.'' Or you can type @kbd{C-g}, which | |
104 | removes from the search string the characters that could not be found (the | |
105 | @samp{T} in @samp{FOOT}), leaving those that were found (the @samp{FOO} in | |
106 | @samp{FOOT}). A second @kbd{C-g} at that point cancels the search | |
107 | entirely, returning point to where it was when the search started. | |
108 | ||
109 | An upper-case letter in the search string makes the search | |
110 | case-sensitive. If you delete the upper-case character from the search | |
111 | string, it ceases to have this effect. @xref{Search Case}. | |
112 | ||
113 | If a search is failing and you ask to repeat it by typing another | |
114 | @kbd{C-s}, it starts again from the beginning of the buffer. Repeating | |
115 | a failing reverse search with @kbd{C-r} starts again from the end. This | |
116 | is called @dfn{wrapping around}. @samp{Wrapped} appears in the search | |
117 | prompt once this has happened. If you keep on going past the original | |
118 | starting point of the search, it changes to @samp{Overwrapped}, which | |
119 | means that you are revisiting matches that you have already seen. | |
120 | ||
121 | @cindex quitting (in search) | |
122 | The @kbd{C-g} ``quit'' character does special things during searches; | |
123 | just what it does depends on the status of the search. If the search has | |
124 | found what you specified and is waiting for input, @kbd{C-g} cancels the | |
125 | entire search. The cursor moves back to where you started the search. If | |
126 | @kbd{C-g} is typed when there are characters in the search string that have | |
127 | not been found---because Emacs is still searching for them, or because it | |
128 | has failed to find them---then the search string characters which have not | |
129 | been found are discarded from the search string. With them gone, the | |
130 | search is now successful and waiting for more input, so a second @kbd{C-g} | |
131 | will cancel the entire search. | |
132 | ||
133 | To search for a newline, type @kbd{C-j}. To search for another | |
134 | control character, such as control-S or carriage return, you must quote | |
135 | it by typing @kbd{C-q} first. This function of @kbd{C-q} is analogous | |
136 | to its use for insertion (@pxref{Inserting Text}): it causes the | |
137 | following character to be treated the way any ``ordinary'' character is | |
138 | treated in the same context. You can also specify a character by its | |
139 | octal code: enter @kbd{C-q} followed by a sequence of octal digits. | |
140 | ||
141 | You can change to searching backwards with @kbd{C-r}. If a search fails | |
142 | because the place you started was too late in the file, you should do this. | |
143 | Repeated @kbd{C-r} keeps looking for more occurrences backwards. A | |
144 | @kbd{C-s} starts going forwards again. @kbd{C-r} in a search can be canceled | |
145 | with @key{DEL}. | |
146 | ||
147 | @kindex C-r | |
148 | @findex isearch-backward | |
149 | If you know initially that you want to search backwards, you can use | |
150 | @kbd{C-r} instead of @kbd{C-s} to start the search, because @kbd{C-r} as | |
151 | a key runs a command (@code{isearch-backward}) to search backward. A | |
152 | backward search finds matches that are entirely before the starting | |
153 | point, just as a forward search finds matches that begin after it. | |
154 | ||
155 | The characters @kbd{C-y} and @kbd{C-w} can be used in incremental | |
156 | search to grab text from the buffer into the search string. This makes | |
157 | it convenient to search for another occurrence of text at point. | |
158 | @kbd{C-w} copies the word after point as part of the search string, | |
159 | advancing point over that word. Another @kbd{C-s} to repeat the search | |
160 | will then search for a string including that word. @kbd{C-y} is similar | |
161 | to @kbd{C-w} but copies all the rest of the current line into the search | |
162 | string. Both @kbd{C-y} and @kbd{C-w} convert the text they copy to | |
163 | lower case if the search is currently not case-sensitive; this is so the | |
164 | search remains case-insensitive. | |
165 | ||
166 | The character @kbd{M-y} copies text from the kill ring into the search | |
167 | string. It uses the same text that @kbd{C-y} as a command would yank. | |
1de69f0c | 168 | @kbd{mouse-2} in the echo area does the same. |
6bf7aab6 DL |
169 | @xref{Yanking}. |
170 | ||
171 | When you exit the incremental search, it sets the mark to where point | |
172 | @emph{was}, before the search. That is convenient for moving back | |
173 | there. In Transient Mark mode, incremental search sets the mark without | |
174 | activating it, and does so only if the mark is not already active. | |
175 | ||
1de69f0c DL |
176 | @cindex lazy search highlighting |
177 | By default, Isearch uses @dfn{lazy highlighting}. All matches for | |
178 | the current search string in the buffer after the point where searching | |
179 | starts are highlighted. The extra highlighting makes it easier to | |
180 | anticipate where the cursor will end up each time you press @kbd{C-s} or | |
181 | @kbd{C-r} to repeat a pending search. Highlighting of these additional | |
182 | matches happens in a deferred fashion so as not to rob Isearch of its | |
183 | usual snappy response. | |
184 | @vindex isearch-lazy-highlight-cleanup | |
185 | By default the highlighting of matches is cleared when you end the | |
186 | search. Customize the variable @code{isearch-lazy-highlight-cleanup} to | |
187 | avoid cleaning up automatically. The command @kbd{M-x | |
188 | isearch-lazy-highlight-cleanup} can be used to clean up manually. | |
189 | @vindex isearch-lazy-highlight | |
190 | Customize the variable @code{isearch-lazy-highlight} to turn off this | |
191 | feature. | |
192 | ||
6bf7aab6 DL |
193 | @vindex isearch-mode-map |
194 | To customize the special characters that incremental search understands, | |
195 | alter their bindings in the keymap @code{isearch-mode-map}. For a list | |
196 | of bindings, look at the documentation of @code{isearch-mode} with | |
197 | @kbd{C-h f isearch-mode @key{RET}}. | |
198 | ||
199 | @subsection Slow Terminal Incremental Search | |
200 | ||
201 | Incremental search on a slow terminal uses a modified style of display | |
202 | that is designed to take less time. Instead of redisplaying the buffer at | |
203 | each place the search gets to, it creates a new single-line window and uses | |
204 | that to display the line that the search has found. The single-line window | |
205 | comes into play as soon as point gets outside of the text that is already | |
206 | on the screen. | |
207 | ||
208 | When you terminate the search, the single-line window is removed. | |
209 | Then Emacs redisplays the window in which the search was done, to show | |
210 | its new position of point. | |
211 | ||
212 | @ignore | |
213 | The three dots at the end of the search string, normally used to indicate | |
214 | that searching is going on, are not displayed in slow style display. | |
215 | @end ignore | |
216 | ||
217 | @vindex search-slow-speed | |
218 | The slow terminal style of display is used when the terminal baud rate is | |
219 | less than or equal to the value of the variable @code{search-slow-speed}, | |
220 | initially 1200. | |
221 | ||
222 | @vindex search-slow-window-lines | |
223 | The number of lines to use in slow terminal search display is controlled | |
224 | by the variable @code{search-slow-window-lines}. Its normal value is 1. | |
225 | ||
226 | @node Nonincremental Search, Word Search, Incremental Search, Search | |
227 | @section Nonincremental Search | |
228 | @cindex nonincremental search | |
229 | ||
230 | Emacs also has conventional nonincremental search commands, which require | |
231 | you to type the entire search string before searching begins. | |
232 | ||
233 | @table @kbd | |
234 | @item C-s @key{RET} @var{string} @key{RET} | |
235 | Search for @var{string}. | |
236 | @item C-r @key{RET} @var{string} @key{RET} | |
237 | Search backward for @var{string}. | |
238 | @end table | |
239 | ||
240 | To do a nonincremental search, first type @kbd{C-s @key{RET}}. This | |
241 | enters the minibuffer to read the search string; terminate the string | |
242 | with @key{RET}, and then the search takes place. If the string is not | |
243 | found, the search command gets an error. | |
244 | ||
245 | The way @kbd{C-s @key{RET}} works is that the @kbd{C-s} invokes | |
246 | incremental search, which is specially programmed to invoke nonincremental | |
247 | search if the argument you give it is empty. (Such an empty argument would | |
248 | otherwise be useless.) @kbd{C-r @key{RET}} also works this way. | |
249 | ||
250 | However, nonincremental searches performed using @kbd{C-s @key{RET}} do | |
251 | not call @code{search-forward} right away. The first thing done is to see | |
252 | if the next character is @kbd{C-w}, which requests a word search. | |
253 | @ifinfo | |
254 | @xref{Word Search}. | |
255 | @end ifinfo | |
256 | ||
257 | @findex search-forward | |
258 | @findex search-backward | |
259 | Forward and backward nonincremental searches are implemented by the | |
260 | commands @code{search-forward} and @code{search-backward}. These | |
261 | commands may be bound to keys in the usual manner. The feature that you | |
262 | can get to them via the incremental search commands exists for | |
263 | historical reasons, and to avoid the need to find suitable key sequences | |
264 | for them. | |
265 | ||
266 | @node Word Search, Regexp Search, Nonincremental Search, Search | |
267 | @section Word Search | |
268 | @cindex word search | |
269 | ||
270 | Word search searches for a sequence of words without regard to how the | |
271 | words are separated. More precisely, you type a string of many words, | |
272 | using single spaces to separate them, and the string can be found even if | |
273 | there are multiple spaces, newlines or other punctuation between the words. | |
274 | ||
275 | Word search is useful for editing a printed document made with a text | |
276 | formatter. If you edit while looking at the printed, formatted version, | |
277 | you can't tell where the line breaks are in the source file. With word | |
278 | search, you can search without having to know them. | |
279 | ||
280 | @table @kbd | |
281 | @item C-s @key{RET} C-w @var{words} @key{RET} | |
282 | Search for @var{words}, ignoring details of punctuation. | |
283 | @item C-r @key{RET} C-w @var{words} @key{RET} | |
284 | Search backward for @var{words}, ignoring details of punctuation. | |
285 | @end table | |
286 | ||
287 | Word search is a special case of nonincremental search and is invoked | |
288 | with @kbd{C-s @key{RET} C-w}. This is followed by the search string, | |
289 | which must always be terminated with @key{RET}. Being nonincremental, | |
290 | this search does not start until the argument is terminated. It works | |
291 | by constructing a regular expression and searching for that; see | |
292 | @ref{Regexp Search}. | |
293 | ||
294 | Use @kbd{C-r @key{RET} C-w} to do backward word search. | |
295 | ||
296 | @findex word-search-forward | |
297 | @findex word-search-backward | |
298 | Forward and backward word searches are implemented by the commands | |
299 | @code{word-search-forward} and @code{word-search-backward}. These | |
300 | commands may be bound to keys in the usual manner. The feature that you | |
301 | can get to them via the incremental search commands exists for historical | |
302 | reasons, and to avoid the need to find suitable key sequences for them. | |
303 | ||
304 | @node Regexp Search, Regexps, Word Search, Search | |
305 | @section Regular Expression Search | |
306 | @cindex regular expression | |
307 | @cindex regexp | |
308 | ||
309 | A @dfn{regular expression} (@dfn{regexp}, for short) is a pattern that | |
310 | denotes a class of alternative strings to match, possibly infinitely | |
311 | many. In GNU Emacs, you can search for the next match for a regexp | |
312 | either incrementally or not. | |
313 | ||
314 | @kindex C-M-s | |
315 | @findex isearch-forward-regexp | |
316 | @kindex C-M-r | |
317 | @findex isearch-backward-regexp | |
318 | Incremental search for a regexp is done by typing @kbd{C-M-s} | |
319 | (@code{isearch-forward-regexp}). This command reads a search string | |
320 | incrementally just like @kbd{C-s}, but it treats the search string as a | |
321 | regexp rather than looking for an exact match against the text in the | |
322 | buffer. Each time you add text to the search string, you make the | |
323 | regexp longer, and the new regexp is searched for. Invoking @kbd{C-s} | |
324 | with a prefix argument (its value does not matter) is another way to do | |
325 | a forward incremental regexp search. To search backward for a regexp, | |
326 | use @kbd{C-M-r} (@code{isearch-backward-regexp}), or @kbd{C-r} with a | |
327 | prefix argument. | |
328 | ||
329 | All of the control characters that do special things within an | |
330 | ordinary incremental search have the same function in incremental regexp | |
331 | search. Typing @kbd{C-s} or @kbd{C-r} immediately after starting the | |
332 | search retrieves the last incremental search regexp used; that is to | |
333 | say, incremental regexp and non-regexp searches have independent | |
334 | defaults. They also have separate search rings that you can access with | |
335 | @kbd{M-p} and @kbd{M-n}. | |
336 | ||
337 | If you type @key{SPC} in incremental regexp search, it matches any | |
338 | sequence of whitespace characters, including newlines. If you want | |
339 | to match just a space, type @kbd{C-q @key{SPC}}. | |
340 | ||
341 | Note that adding characters to the regexp in an incremental regexp | |
342 | search can make the cursor move back and start again. For example, if | |
343 | you have searched for @samp{foo} and you add @samp{\|bar}, the cursor | |
344 | backs up in case the first @samp{bar} precedes the first @samp{foo}. | |
345 | ||
346 | @findex re-search-forward | |
347 | @findex re-search-backward | |
348 | Nonincremental search for a regexp is done by the functions | |
349 | @code{re-search-forward} and @code{re-search-backward}. You can invoke | |
350 | these with @kbd{M-x}, or bind them to keys, or invoke them by way of | |
351 | incremental regexp search with @kbd{C-M-s @key{RET}} and @kbd{C-M-r | |
352 | @key{RET}}. | |
353 | ||
354 | If you use the incremental regexp search commands with a prefix | |
355 | argument, they perform ordinary string search, like | |
356 | @code{isearch-forward} and @code{isearch-backward}. @xref{Incremental | |
357 | Search}. | |
358 | ||
359 | @node Regexps, Search Case, Regexp Search, Search | |
360 | @section Syntax of Regular Expressions | |
361 | @cindex regexp syntax | |
362 | ||
363 | Regular expressions have a syntax in which a few characters are | |
364 | special constructs and the rest are @dfn{ordinary}. An ordinary | |
365 | character is a simple regular expression which matches that same | |
366 | character and nothing else. The special characters are @samp{$}, | |
367 | @samp{^}, @samp{.}, @samp{*}, @samp{+}, @samp{?}, @samp{[}, @samp{]} and | |
368 | @samp{\}. Any other character appearing in a regular expression is | |
369 | ordinary, unless a @samp{\} precedes it. | |
370 | ||
371 | For example, @samp{f} is not a special character, so it is ordinary, and | |
372 | therefore @samp{f} is a regular expression that matches the string | |
373 | @samp{f} and no other string. (It does @emph{not} match the string | |
374 | @samp{ff}.) Likewise, @samp{o} is a regular expression that matches | |
375 | only @samp{o}. (When case distinctions are being ignored, these regexps | |
376 | also match @samp{F} and @samp{O}, but we consider this a generalization | |
377 | of ``the same string,'' rather than an exception.) | |
378 | ||
379 | Any two regular expressions @var{a} and @var{b} can be concatenated. The | |
380 | result is a regular expression which matches a string if @var{a} matches | |
381 | some amount of the beginning of that string and @var{b} matches the rest of | |
382 | the string.@refill | |
383 | ||
384 | As a simple example, we can concatenate the regular expressions @samp{f} | |
385 | and @samp{o} to get the regular expression @samp{fo}, which matches only | |
386 | the string @samp{fo}. Still trivial. To do something nontrivial, you | |
387 | need to use one of the special characters. Here is a list of them. | |
388 | ||
389 | @table @kbd | |
390 | @item .@: @r{(Period)} | |
391 | is a special character that matches any single character except a newline. | |
392 | Using concatenation, we can make regular expressions like @samp{a.b}, which | |
393 | matches any three-character string that begins with @samp{a} and ends with | |
394 | @samp{b}.@refill | |
395 | ||
396 | @item * | |
397 | is not a construct by itself; it is a postfix operator that means to | |
398 | match the preceding regular expression repetitively as many times as | |
399 | possible. Thus, @samp{o*} matches any number of @samp{o}s (including no | |
400 | @samp{o}s). | |
401 | ||
402 | @samp{*} always applies to the @emph{smallest} possible preceding | |
403 | expression. Thus, @samp{fo*} has a repeating @samp{o}, not a repeating | |
404 | @samp{fo}. It matches @samp{f}, @samp{fo}, @samp{foo}, and so on. | |
405 | ||
406 | The matcher processes a @samp{*} construct by matching, immediately, | |
407 | as many repetitions as can be found. Then it continues with the rest | |
408 | of the pattern. If that fails, backtracking occurs, discarding some | |
409 | of the matches of the @samp{*}-modified construct in case that makes | |
410 | it possible to match the rest of the pattern. For example, in matching | |
411 | @samp{ca*ar} against the string @samp{caaar}, the @samp{a*} first | |
412 | tries to match all three @samp{a}s; but the rest of the pattern is | |
413 | @samp{ar} and there is only @samp{r} left to match, so this try fails. | |
414 | The next alternative is for @samp{a*} to match only two @samp{a}s. | |
415 | With this choice, the rest of the regexp matches successfully.@refill | |
416 | ||
417 | @item + | |
418 | is a postfix operator, similar to @samp{*} except that it must match | |
419 | the preceding expression at least once. So, for example, @samp{ca+r} | |
420 | matches the strings @samp{car} and @samp{caaaar} but not the string | |
421 | @samp{cr}, whereas @samp{ca*r} matches all three strings. | |
422 | ||
423 | @item ? | |
424 | is a postfix operator, similar to @samp{*} except that it can match the | |
425 | preceding expression either once or not at all. For example, | |
426 | @samp{ca?r} matches @samp{car} or @samp{cr}; nothing else. | |
427 | ||
8964fec7 | 428 | @item *?, +?, ?? |
f1a88ed9 | 429 | @cindex non-greedy regexp matching |
8964fec7 | 430 | are non-greedy variants of the operators above. The normal operators |
f1a88ed9 EZ |
431 | @samp{*}, @samp{+}, @samp{?} are @dfn{greedy} in that they match as much |
432 | as they can, while if you append a @samp{?} after them, it makes them | |
433 | non-greedy: they will match as little as possible. | |
8964fec7 | 434 | |
6bf7aab6 DL |
435 | @item [ @dots{} ] |
436 | is a @dfn{character set}, which begins with @samp{[} and is terminated | |
437 | by @samp{]}. In the simplest case, the characters between the two | |
438 | brackets are what this set can match. | |
439 | ||
440 | Thus, @samp{[ad]} matches either one @samp{a} or one @samp{d}, and | |
441 | @samp{[ad]*} matches any string composed of just @samp{a}s and @samp{d}s | |
442 | (including the empty string), from which it follows that @samp{c[ad]*r} | |
443 | matches @samp{cr}, @samp{car}, @samp{cdr}, @samp{caddaar}, etc. | |
444 | ||
445 | You can also include character ranges in a character set, by writing the | |
446 | starting and ending characters with a @samp{-} between them. Thus, | |
447 | @samp{[a-z]} matches any lower-case ASCII letter. Ranges may be | |
448 | intermixed freely with individual characters, as in @samp{[a-z$%.]}, | |
449 | which matches any lower-case ASCII letter or @samp{$}, @samp{%} or | |
450 | period. | |
451 | ||
452 | Note that the usual regexp special characters are not special inside a | |
453 | character set. A completely different set of special characters exists | |
454 | inside character sets: @samp{]}, @samp{-} and @samp{^}. | |
455 | ||
456 | To include a @samp{]} in a character set, you must make it the first | |
457 | character. For example, @samp{[]a]} matches @samp{]} or @samp{a}. To | |
458 | include a @samp{-}, write @samp{-} as the first or last character of the | |
459 | set, or put it after a range. Thus, @samp{[]-]} matches both @samp{]} | |
460 | and @samp{-}. | |
461 | ||
462 | To include @samp{^} in a set, put it anywhere but at the beginning of | |
463 | the set. | |
464 | ||
465 | When you use a range in case-insensitive search, you should write both | |
466 | ends of the range in upper case, or both in lower case, or both should | |
467 | be non-letters. The behavior of a mixed-case range such as @samp{A-z} | |
468 | is somewhat ill-defined, and it may change in future Emacs versions. | |
469 | ||
470 | @item [^ @dots{} ] | |
471 | @samp{[^} begins a @dfn{complemented character set}, which matches any | |
472 | character except the ones specified. Thus, @samp{[^a-z0-9A-Z]} matches | |
473 | all characters @emph{except} letters and digits. | |
474 | ||
475 | @samp{^} is not special in a character set unless it is the first | |
476 | character. The character following the @samp{^} is treated as if it | |
477 | were first (in other words, @samp{-} and @samp{]} are not special there). | |
478 | ||
479 | A complemented character set can match a newline, unless newline is | |
480 | mentioned as one of the characters not to match. This is in contrast to | |
481 | the handling of regexps in programs such as @code{grep}. | |
482 | ||
483 | @item ^ | |
484 | is a special character that matches the empty string, but only at the | |
485 | beginning of a line in the text being matched. Otherwise it fails to | |
486 | match anything. Thus, @samp{^foo} matches a @samp{foo} that occurs at | |
487 | the beginning of a line. | |
488 | ||
489 | @item $ | |
490 | is similar to @samp{^} but matches only at the end of a line. Thus, | |
491 | @samp{x+$} matches a string of one @samp{x} or more at the end of a line. | |
492 | ||
493 | @item \ | |
494 | has two functions: it quotes the special characters (including | |
495 | @samp{\}), and it introduces additional special constructs. | |
496 | ||
497 | Because @samp{\} quotes special characters, @samp{\$} is a regular | |
498 | expression that matches only @samp{$}, and @samp{\[} is a regular | |
499 | expression that matches only @samp{[}, and so on. | |
500 | @end table | |
501 | ||
502 | Note: for historical compatibility, special characters are treated as | |
503 | ordinary ones if they are in contexts where their special meanings make no | |
504 | sense. For example, @samp{*foo} treats @samp{*} as ordinary since there is | |
505 | no preceding expression on which the @samp{*} can act. It is poor practice | |
506 | to depend on this behavior; it is better to quote the special character anyway, | |
507 | regardless of where it appears.@refill | |
508 | ||
509 | For the most part, @samp{\} followed by any character matches only that | |
510 | character. However, there are several exceptions: two-character | |
511 | sequences starting with @samp{\} that have special meanings. The second | |
512 | character in the sequence is always an ordinary character when used on | |
513 | its own. Here is a table of @samp{\} constructs. | |
514 | ||
515 | @table @kbd | |
516 | @item \| | |
517 | specifies an alternative. Two regular expressions @var{a} and @var{b} | |
518 | with @samp{\|} in between form an expression that matches some text if | |
519 | either @var{a} matches it or @var{b} matches it. It works by trying to | |
520 | match @var{a}, and if that fails, by trying to match @var{b}. | |
521 | ||
522 | Thus, @samp{foo\|bar} matches either @samp{foo} or @samp{bar} | |
523 | but no other string.@refill | |
524 | ||
525 | @samp{\|} applies to the largest possible surrounding expressions. Only a | |
526 | surrounding @samp{\( @dots{} \)} grouping can limit the grouping power of | |
527 | @samp{\|}.@refill | |
528 | ||
529 | Full backtracking capability exists to handle multiple uses of @samp{\|}. | |
530 | ||
531 | @item \( @dots{} \) | |
532 | is a grouping construct that serves three purposes: | |
533 | ||
534 | @enumerate | |
535 | @item | |
536 | To enclose a set of @samp{\|} alternatives for other operations. | |
537 | Thus, @samp{\(foo\|bar\)x} matches either @samp{foox} or @samp{barx}. | |
538 | ||
539 | @item | |
540 | To enclose a complicated expression for the postfix operators @samp{*}, | |
541 | @samp{+} and @samp{?} to operate on. Thus, @samp{ba\(na\)*} matches | |
542 | @samp{bananana}, etc., with any (zero or more) number of @samp{na} | |
543 | strings.@refill | |
544 | ||
545 | @item | |
546 | To record a matched substring for future reference. | |
547 | @end enumerate | |
548 | ||
549 | This last application is not a consequence of the idea of a | |
550 | parenthetical grouping; it is a separate feature that is assigned as a | |
551 | second meaning to the same @samp{\( @dots{} \)} construct. In practice | |
552 | there is no conflict between the two meanings. | |
553 | ||
554 | @item \@var{d} | |
555 | matches the same text that matched the @var{d}th occurrence of a | |
556 | @samp{\( @dots{} \)} construct. | |
557 | ||
558 | After the end of a @samp{\( @dots{} \)} construct, the matcher remembers | |
559 | the beginning and end of the text matched by that construct. Then, | |
560 | later on in the regular expression, you can use @samp{\} followed by the | |
561 | digit @var{d} to mean ``match the same text matched the @var{d}th time | |
562 | by the @samp{\( @dots{} \)} construct.'' | |
563 | ||
564 | The strings matching the first nine @samp{\( @dots{} \)} constructs | |
565 | appearing in a regular expression are assigned numbers 1 through 9 in | |
566 | the order that the open-parentheses appear in the regular expression. | |
567 | So you can use @samp{\1} through @samp{\9} to refer to the text matched | |
568 | by the corresponding @samp{\( @dots{} \)} constructs. | |
569 | ||
570 | For example, @samp{\(.*\)\1} matches any newline-free string that is | |
571 | composed of two identical halves. The @samp{\(.*\)} matches the first | |
572 | half, which may be anything, but the @samp{\1} that follows must match | |
573 | the same exact text. | |
574 | ||
575 | If a particular @samp{\( @dots{} \)} construct matches more than once | |
576 | (which can easily happen if it is followed by @samp{*}), only the last | |
577 | match is recorded. | |
578 | ||
579 | @item \` | |
580 | matches the empty string, but only at the beginning | |
581 | of the buffer or string being matched against. | |
582 | ||
583 | @item \' | |
584 | matches the empty string, but only at the end of | |
585 | the buffer or string being matched against. | |
586 | ||
587 | @item \= | |
588 | matches the empty string, but only at point. | |
589 | ||
590 | @item \b | |
591 | matches the empty string, but only at the beginning or | |
592 | end of a word. Thus, @samp{\bfoo\b} matches any occurrence of | |
593 | @samp{foo} as a separate word. @samp{\bballs?\b} matches | |
594 | @samp{ball} or @samp{balls} as a separate word.@refill | |
595 | ||
596 | @samp{\b} matches at the beginning or end of the buffer | |
597 | regardless of what text appears next to it. | |
598 | ||
599 | @item \B | |
600 | matches the empty string, but @emph{not} at the beginning or | |
601 | end of a word. | |
602 | ||
603 | @item \< | |
604 | matches the empty string, but only at the beginning of a word. | |
605 | @samp{\<} matches at the beginning of the buffer only if a | |
606 | word-constituent character follows. | |
607 | ||
608 | @item \> | |
609 | matches the empty string, but only at the end of a word. @samp{\>} | |
610 | matches at the end of the buffer only if the contents end with a | |
611 | word-constituent character. | |
612 | ||
613 | @item \w | |
614 | matches any word-constituent character. The syntax table | |
615 | determines which characters these are. @xref{Syntax}. | |
616 | ||
617 | @item \W | |
618 | matches any character that is not a word-constituent. | |
619 | ||
620 | @item \s@var{c} | |
621 | matches any character whose syntax is @var{c}. Here @var{c} is a | |
622 | character that represents a syntax code: thus, @samp{w} for word | |
623 | constituent, @samp{-} for whitespace, @samp{(} for open parenthesis, | |
624 | etc. Represent a character of whitespace (which can be a newline) by | |
625 | either @samp{-} or a space character. | |
626 | ||
627 | @item \S@var{c} | |
628 | matches any character whose syntax is not @var{c}. | |
629 | @end table | |
630 | ||
631 | The constructs that pertain to words and syntax are controlled by the | |
632 | setting of the syntax table (@pxref{Syntax}). | |
633 | ||
634 | Here is a complicated regexp, used by Emacs to recognize the end of a | |
635 | sentence together with any whitespace that follows. It is given in Lisp | |
636 | syntax to enable you to distinguish the spaces from the tab characters. In | |
637 | Lisp syntax, the string constant begins and ends with a double-quote. | |
638 | @samp{\"} stands for a double-quote as part of the regexp, @samp{\\} for a | |
639 | backslash as part of the regexp, @samp{\t} for a tab and @samp{\n} for a | |
640 | newline. | |
641 | ||
642 | @example | |
643 | "[.?!][]\"')]*\\($\\|\t\\| \\)[ \t\n]*" | |
644 | @end example | |
645 | ||
646 | @noindent | |
647 | This contains four parts in succession: a character set matching period, | |
648 | @samp{?}, or @samp{!}; a character set matching close-brackets, quotes, | |
649 | or parentheses, repeated any number of times; an alternative in | |
650 | backslash-parentheses that matches end-of-line, a tab, or two spaces; | |
651 | and a character set matching whitespace characters, repeated any number | |
652 | of times. | |
653 | ||
654 | To enter the same regexp interactively, you would type @key{TAB} to | |
655 | enter a tab, and @kbd{C-j} to enter a newline. You would also type | |
656 | single backslashes as themselves, instead of doubling them for Lisp syntax. | |
657 | ||
658 | @node Search Case, Replace, Regexps, Search | |
659 | @section Searching and Case | |
660 | ||
661 | @vindex case-fold-search | |
662 | Incremental searches in Emacs normally ignore the case of the text | |
663 | they are searching through, if you specify the text in lower case. | |
664 | Thus, if you specify searching for @samp{foo}, then @samp{Foo} and | |
665 | @samp{foo} are also considered a match. Regexps, and in particular | |
666 | character sets, are included: @samp{[ab]} would match @samp{a} or | |
667 | @samp{A} or @samp{b} or @samp{B}.@refill | |
668 | ||
669 | An upper-case letter anywhere in the incremental search string makes | |
670 | the search case-sensitive. Thus, searching for @samp{Foo} does not find | |
671 | @samp{foo} or @samp{FOO}. This applies to regular expression search as | |
672 | well as to string search. The effect ceases if you delete the | |
673 | upper-case letter from the search string. | |
674 | ||
675 | If you set the variable @code{case-fold-search} to @code{nil}, then | |
676 | all letters must match exactly, including case. This is a per-buffer | |
677 | variable; altering the variable affects only the current buffer, but | |
678 | there is a default value which you can change as well. @xref{Locals}. | |
679 | This variable applies to nonincremental searches also, including those | |
680 | performed by the replace commands (@pxref{Replace}) and the minibuffer | |
681 | history matching commands (@pxref{Minibuffer History}). | |
682 | ||
683 | @node Replace, Other Repeating Search, Search Case, Search | |
684 | @section Replacement Commands | |
685 | @cindex replacement | |
686 | @cindex search-and-replace commands | |
687 | @cindex string substitution | |
688 | @cindex global substitution | |
689 | ||
690 | Global search-and-replace operations are not needed as often in Emacs | |
691 | as they are in other editors@footnote{In some editors, | |
692 | search-and-replace operations are the only convenient way to make a | |
693 | single change in the text.}, but they are available. In addition to the | |
694 | simple @kbd{M-x replace-string} command which is like that found in most | |
695 | editors, there is a @kbd{M-x query-replace} command which asks you, for | |
696 | each occurrence of the pattern, whether to replace it. | |
697 | ||
698 | The replace commands normally operate on the text from point to the | |
699 | end of the buffer; however, in Transient Mark mode, when the mark is | |
700 | active, they operate on the region. The replace commands all replace | |
701 | one string (or regexp) with one replacement string. It is possible to | |
702 | perform several replacements in parallel using the command | |
703 | @code{expand-region-abbrevs} (@pxref{Expanding Abbrevs}). | |
704 | ||
705 | @menu | |
706 | * Unconditional Replace:: Replacing all matches for a string. | |
707 | * Regexp Replace:: Replacing all matches for a regexp. | |
708 | * Replacement and Case:: How replacements preserve case of letters. | |
709 | * Query Replace:: How to use querying. | |
710 | @end menu | |
711 | ||
712 | @node Unconditional Replace, Regexp Replace, Replace, Replace | |
713 | @subsection Unconditional Replacement | |
714 | @findex replace-string | |
715 | @findex replace-regexp | |
716 | ||
717 | @table @kbd | |
718 | @item M-x replace-string @key{RET} @var{string} @key{RET} @var{newstring} @key{RET} | |
719 | Replace every occurrence of @var{string} with @var{newstring}. | |
720 | @item M-x replace-regexp @key{RET} @var{regexp} @key{RET} @var{newstring} @key{RET} | |
721 | Replace every match for @var{regexp} with @var{newstring}. | |
722 | @end table | |
723 | ||
724 | To replace every instance of @samp{foo} after point with @samp{bar}, | |
725 | use the command @kbd{M-x replace-string} with the two arguments | |
726 | @samp{foo} and @samp{bar}. Replacement happens only in the text after | |
727 | point, so if you want to cover the whole buffer you must go to the | |
728 | beginning first. All occurrences up to the end of the buffer are | |
729 | replaced; to limit replacement to part of the buffer, narrow to that | |
730 | part of the buffer before doing the replacement (@pxref{Narrowing}). | |
731 | In Transient Mark mode, when the region is active, replacement is | |
732 | limited to the region (@pxref{Transient Mark}). | |
733 | ||
734 | When @code{replace-string} exits, it leaves point at the last | |
735 | occurrence replaced. It sets the mark to the prior position of point | |
736 | (where the @code{replace-string} command was issued); use @kbd{C-u | |
737 | C-@key{SPC}} to move back there. | |
738 | ||
739 | A numeric argument restricts replacement to matches that are surrounded | |
740 | by word boundaries. The argument's value doesn't matter. | |
741 | ||
742 | @node Regexp Replace, Replacement and Case, Unconditional Replace, Replace | |
743 | @subsection Regexp Replacement | |
744 | ||
745 | The @kbd{M-x replace-string} command replaces exact matches for a | |
746 | single string. The similar command @kbd{M-x replace-regexp} replaces | |
747 | any match for a specified pattern. | |
748 | ||
749 | In @code{replace-regexp}, the @var{newstring} need not be constant: it | |
750 | can refer to all or part of what is matched by the @var{regexp}. | |
751 | @samp{\&} in @var{newstring} stands for the entire match being replaced. | |
752 | @samp{\@var{d}} in @var{newstring}, where @var{d} is a digit, stands for | |
753 | whatever matched the @var{d}th parenthesized grouping in @var{regexp}. | |
754 | To include a @samp{\} in the text to replace with, you must enter | |
755 | @samp{\\}. For example, | |
756 | ||
757 | @example | |
758 | M-x replace-regexp @key{RET} c[ad]+r @key{RET} \&-safe @key{RET} | |
759 | @end example | |
760 | ||
761 | @noindent | |
762 | replaces (for example) @samp{cadr} with @samp{cadr-safe} and @samp{cddr} | |
763 | with @samp{cddr-safe}. | |
764 | ||
765 | @example | |
766 | M-x replace-regexp @key{RET} \(c[ad]+r\)-safe @key{RET} \1 @key{RET} | |
767 | @end example | |
768 | ||
769 | @noindent | |
770 | performs the inverse transformation. | |
771 | ||
772 | @node Replacement and Case, Query Replace, Regexp Replace, Replace | |
773 | @subsection Replace Commands and Case | |
774 | ||
775 | If the first argument of a replace command is all lower case, the | |
776 | commands ignores case while searching for occurrences to | |
777 | replace---provided @code{case-fold-search} is non-@code{nil}. If | |
778 | @code{case-fold-search} is set to @code{nil}, case is always significant | |
779 | in all searches. | |
780 | ||
781 | @vindex case-replace | |
782 | In addition, when the @var{newstring} argument is all or partly lower | |
783 | case, replacement commands try to preserve the case pattern of each | |
784 | occurrence. Thus, the command | |
785 | ||
786 | @example | |
787 | M-x replace-string @key{RET} foo @key{RET} bar @key{RET} | |
788 | @end example | |
789 | ||
790 | @noindent | |
791 | replaces a lower case @samp{foo} with a lower case @samp{bar}, an | |
792 | all-caps @samp{FOO} with @samp{BAR}, and a capitalized @samp{Foo} with | |
793 | @samp{Bar}. (These three alternatives---lower case, all caps, and | |
794 | capitalized, are the only ones that @code{replace-string} can | |
795 | distinguish.) | |
796 | ||
797 | If upper-case letters are used in the replacement string, they remain | |
798 | upper case every time that text is inserted. If upper-case letters are | |
799 | used in the first argument, the second argument is always substituted | |
800 | exactly as given, with no case conversion. Likewise, if either | |
801 | @code{case-replace} or @code{case-fold-search} is set to @code{nil}, | |
802 | replacement is done without case conversion. | |
803 | ||
804 | @node Query Replace,, Replacement and Case, Replace | |
805 | @subsection Query Replace | |
806 | @cindex query replace | |
807 | ||
808 | @table @kbd | |
809 | @item M-% @var{string} @key{RET} @var{newstring} @key{RET} | |
810 | @itemx M-x query-replace @key{RET} @var{string} @key{RET} @var{newstring} @key{RET} | |
811 | Replace some occurrences of @var{string} with @var{newstring}. | |
812 | @item C-M-% @var{regexp} @key{RET} @var{newstring} @key{RET} | |
813 | @itemx M-x query-replace-regexp @key{RET} @var{regexp} @key{RET} @var{newstring} @key{RET} | |
814 | Replace some matches for @var{regexp} with @var{newstring}. | |
815 | @end table | |
816 | ||
817 | @kindex M-% | |
818 | @findex query-replace | |
819 | If you want to change only some of the occurrences of @samp{foo} to | |
820 | @samp{bar}, not all of them, then you cannot use an ordinary | |
821 | @code{replace-string}. Instead, use @kbd{M-%} (@code{query-replace}). | |
822 | This command finds occurrences of @samp{foo} one by one, displays each | |
823 | occurrence and asks you whether to replace it. A numeric argument to | |
824 | @code{query-replace} tells it to consider only occurrences that are | |
825 | bounded by word-delimiter characters. This preserves case, just like | |
826 | @code{replace-string}, provided @code{case-replace} is non-@code{nil}, | |
827 | as it normally is. | |
828 | ||
829 | @kindex C-M-% | |
830 | @findex query-replace-regexp | |
831 | Aside from querying, @code{query-replace} works just like | |
832 | @code{replace-string}, and @code{query-replace-regexp} works just like | |
833 | @code{replace-regexp}. This command is run by @kbd{C-M-%}. | |
834 | ||
835 | The things you can type when you are shown an occurrence of @var{string} | |
836 | or a match for @var{regexp} are: | |
837 | ||
838 | @ignore @c Not worth it. | |
839 | @kindex SPC @r{(query-replace)} | |
840 | @kindex DEL @r{(query-replace)} | |
841 | @kindex , @r{(query-replace)} | |
842 | @kindex RET @r{(query-replace)} | |
843 | @kindex . @r{(query-replace)} | |
844 | @kindex ! @r{(query-replace)} | |
845 | @kindex ^ @r{(query-replace)} | |
846 | @kindex C-r @r{(query-replace)} | |
847 | @kindex C-w @r{(query-replace)} | |
848 | @kindex C-l @r{(query-replace)} | |
849 | @end ignore | |
850 | ||
851 | @c WideCommands | |
852 | @table @kbd | |
853 | @item @key{SPC} | |
854 | to replace the occurrence with @var{newstring}. | |
855 | ||
856 | @item @key{DEL} | |
857 | to skip to the next occurrence without replacing this one. | |
858 | ||
859 | @item , @r{(Comma)} | |
860 | to replace this occurrence and display the result. You are then asked | |
861 | for another input character to say what to do next. Since the | |
862 | replacement has already been made, @key{DEL} and @key{SPC} are | |
863 | equivalent in this situation; both move to the next occurrence. | |
864 | ||
865 | You can type @kbd{C-r} at this point (see below) to alter the replaced | |
866 | text. You can also type @kbd{C-x u} to undo the replacement; this exits | |
867 | the @code{query-replace}, so if you want to do further replacement you | |
868 | must use @kbd{C-x @key{ESC} @key{ESC} @key{RET}} to restart | |
869 | (@pxref{Repetition}). | |
870 | ||
871 | @item @key{RET} | |
872 | to exit without doing any more replacements. | |
873 | ||
874 | @item .@: @r{(Period)} | |
875 | to replace this occurrence and then exit without searching for more | |
876 | occurrences. | |
877 | ||
878 | @item ! | |
879 | to replace all remaining occurrences without asking again. | |
880 | ||
881 | @item ^ | |
882 | to go back to the position of the previous occurrence (or what used to | |
883 | be an occurrence), in case you changed it by mistake. This works by | |
884 | popping the mark ring. Only one @kbd{^} in a row is meaningful, because | |
885 | only one previous replacement position is kept during @code{query-replace}. | |
886 | ||
887 | @item C-r | |
888 | to enter a recursive editing level, in case the occurrence needs to be | |
889 | edited rather than just replaced with @var{newstring}. When you are | |
890 | done, exit the recursive editing level with @kbd{C-M-c} to proceed to | |
891 | the next occurrence. @xref{Recursive Edit}. | |
892 | ||
893 | @item C-w | |
894 | to delete the occurrence, and then enter a recursive editing level as in | |
895 | @kbd{C-r}. Use the recursive edit to insert text to replace the deleted | |
896 | occurrence of @var{string}. When done, exit the recursive editing level | |
897 | with @kbd{C-M-c} to proceed to the next occurrence. | |
898 | ||
899 | @item C-l | |
900 | to redisplay the screen. Then you must type another character to | |
901 | specify what to do with this occurrence. | |
902 | ||
903 | @item C-h | |
904 | to display a message summarizing these options. Then you must type | |
905 | another character to specify what to do with this occurrence. | |
906 | @end table | |
907 | ||
908 | Some other characters are aliases for the ones listed above: @kbd{y}, | |
909 | @kbd{n} and @kbd{q} are equivalent to @key{SPC}, @key{DEL} and | |
910 | @key{RET}. | |
911 | ||
912 | Aside from this, any other character exits the @code{query-replace}, | |
913 | and is then reread as part of a key sequence. Thus, if you type | |
914 | @kbd{C-k}, it exits the @code{query-replace} and then kills to end of | |
915 | line. | |
916 | ||
917 | To restart a @code{query-replace} once it is exited, use @kbd{C-x | |
918 | @key{ESC} @key{ESC}}, which repeats the @code{query-replace} because it | |
919 | used the minibuffer to read its arguments. @xref{Repetition, C-x ESC | |
920 | ESC}. | |
921 | ||
922 | See also @ref{Transforming File Names}, for Dired commands to rename, | |
923 | copy, or link files by replacing regexp matches in file names. | |
924 | ||
925 | @node Other Repeating Search,, Replace, Search | |
926 | @section Other Search-and-Loop Commands | |
927 | ||
928 | Here are some other commands that find matches for a regular | |
929 | expression. They all operate from point to the end of the buffer, and | |
930 | all ignore case in matching, if the pattern contains no upper-case | |
931 | letters and @code{case-fold-search} is non-@code{nil}. | |
932 | ||
933 | @findex list-matching-lines | |
934 | @findex occur | |
935 | @findex count-matches | |
936 | @findex delete-non-matching-lines | |
937 | @findex delete-matching-lines | |
938 | @findex flush-lines | |
939 | @findex keep-lines | |
940 | ||
941 | @table @kbd | |
942 | @item M-x occur @key{RET} @var{regexp} @key{RET} | |
943 | Display a list showing each line in the buffer that contains a match for | |
944 | @var{regexp}. A numeric argument specifies the number of context lines | |
945 | to print before and after each matching line; the default is none. | |
946 | To limit the search to part of the buffer, narrow to that part | |
947 | (@pxref{Narrowing}). | |
948 | ||
949 | @kindex RET @r{(Occur mode)} | |
950 | The buffer @samp{*Occur*} containing the output serves as a menu for | |
951 | finding the occurrences in their original context. Click @kbd{Mouse-2} | |
952 | on an occurrence listed in @samp{*Occur*}, or position point there and | |
953 | type @key{RET}; this switches to the buffer that was searched and | |
954 | moves point to the original of the chosen occurrence. | |
955 | ||
956 | @item M-x list-matching-lines | |
957 | Synonym for @kbd{M-x occur}. | |
958 | ||
959 | @item M-x count-matches @key{RET} @var{regexp} @key{RET} | |
960 | Print the number of matches for @var{regexp} after point. | |
961 | ||
962 | @item M-x flush-lines @key{RET} @var{regexp} @key{RET} | |
963 | Delete each line that follows point and contains a match for | |
964 | @var{regexp}. | |
965 | ||
966 | @item M-x keep-lines @key{RET} @var{regexp} @key{RET} | |
967 | Delete each line that follows point and @emph{does not} contain a match | |
968 | for @var{regexp}. | |
969 | @end table | |
970 | ||
971 | In addition, you can use @code{grep} from Emacs to search a collection | |
972 | of files for matches for a regular expression, then visit the matches | |
973 | either sequentially or in arbitrary order. @xref{Grep Searching}. |