Commit | Line | Data |
---|---|---|
6bf7aab6 | 1 | @c This is part of the Emacs manual. |
b65d8176 TTN |
2 | @c Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 2000, 2001, 2002, |
3 | @c 2003, 2004, 2005 Free Software Foundation, Inc. | |
6bf7aab6 DL |
4 | @c See file emacs.texi for copying conditions. |
5 | @node Search, Fixit, Display, Top | |
6 | @chapter Searching and Replacement | |
7 | @cindex searching | |
8 | @cindex finding strings within text | |
9 | ||
10 | Like other editors, Emacs has commands for searching for occurrences of | |
11 | a string. The principal search command is unusual in that it is | |
12 | @dfn{incremental}; it begins to search before you have finished typing the | |
13 | search string. There are also nonincremental search commands more like | |
14 | those of other editors. | |
15 | ||
16 | Besides the usual @code{replace-string} command that finds all | |
a76af65d RS |
17 | occurrences of one string and replaces them with another, Emacs has a |
18 | more flexible replacement command called @code{query-replace}, which | |
19 | asks interactively which occurrences to replace. | |
6bf7aab6 DL |
20 | |
21 | @menu | |
a57bfc9f EZ |
22 | * Incremental Search:: Search happens as you type the string. |
23 | * Nonincremental Search:: Specify entire string and then search. | |
24 | * Word Search:: Search for sequence of words. | |
25 | * Regexp Search:: Search for match for a regexp. | |
26 | * Regexps:: Syntax of regular expressions. | |
c118d09e RS |
27 | * Regexp Backslash:: Regular expression constructs starting with `\'. |
28 | * Regexp Example:: A complex regular expression explained. | |
a57bfc9f | 29 | * Search Case:: To ignore case while searching, or not. |
a57bfc9f EZ |
30 | * Replace:: Search, and replace some or all matches. |
31 | * Other Repeating Search:: Operating on all matches for some regexp. | |
6bf7aab6 DL |
32 | @end menu |
33 | ||
f2fd3623 | 34 | @node Incremental Search |
6bf7aab6 DL |
35 | @section Incremental Search |
36 | ||
6bf7aab6 DL |
37 | An incremental search begins searching as soon as you type the first |
38 | character of the search string. As you type in the search string, Emacs | |
39 | shows you where the string (as you have typed it so far) would be | |
40 | found. When you have typed enough characters to identify the place you | |
41 | want, you can stop. Depending on what you plan to do next, you may or | |
42 | may not need to terminate the search explicitly with @key{RET}. | |
43 | ||
44 | @c WideCommands | |
45 | @table @kbd | |
46 | @item C-s | |
47 | Incremental search forward (@code{isearch-forward}). | |
48 | @item C-r | |
49 | Incremental search backward (@code{isearch-backward}). | |
50 | @end table | |
51 | ||
f2fd3623 RS |
52 | @menu |
53 | * Basic Isearch:: Basic incremental search commands. | |
54 | * Repeat Isearch:: Searching for the same string again. | |
55 | * Error in Isearch:: When your string is not found. | |
56 | * Special Isearch:: Special input in incremental search. | |
57 | * Non-ASCII Isearch:: How to search for non-ASCII characters. | |
58 | * Isearch Yank:: Commands that grab text into the search string | |
59 | or else edit the search string. | |
60 | * Highlight Isearch:: Isearch highlights the other possible matches. | |
61 | * Isearch Scroll:: Scrolling during an incremental search. | |
62 | * Slow Isearch:: Incremental search features for slow terminals. | |
63 | @end menu | |
64 | ||
65 | @node Basic Isearch | |
66 | @subsection Basics of Incremental Search | |
67 | @cindex incremental search | |
68 | ||
6bf7aab6 DL |
69 | @kindex C-s |
70 | @findex isearch-forward | |
a76af65d RS |
71 | @kbd{C-s} starts a forward incremental search. It reads characters |
72 | from the keyboard, and moves point past the next occurrence of those | |
73 | characters. If you type @kbd{C-s} and then @kbd{F}, that puts the | |
e9c80604 | 74 | cursor after the first @samp{F} (the first following the starting point, since |
a76af65d RS |
75 | this is a forward search). Then if you type an @kbd{O}, you will see |
76 | the cursor move just after the first @samp{FO} (the @samp{F} in that | |
77 | @samp{FO} may or may not be the first @samp{F}). After another | |
78 | @kbd{O}, the cursor moves after the first @samp{FOO} after the place | |
79 | where you started the search. At each step, the buffer text that | |
80 | matches the search string is highlighted, if the terminal can do that; | |
81 | the current search string is always displayed in the echo area. | |
6bf7aab6 DL |
82 | |
83 | If you make a mistake in typing the search string, you can cancel | |
84 | characters with @key{DEL}. Each @key{DEL} cancels the last character of | |
85 | search string. This does not happen until Emacs is ready to read another | |
86 | input character; first it must either find, or fail to find, the character | |
87 | you want to erase. If you do not want to wait for this to happen, use | |
88 | @kbd{C-g} as described below. | |
89 | ||
90 | When you are satisfied with the place you have reached, you can type | |
91 | @key{RET}, which stops searching, leaving the cursor where the search | |
92 | brought it. Also, any command not specially meaningful in searches | |
b20a1c88 RS |
93 | stops the searching and is then executed. Thus, typing @kbd{C-a} |
94 | would exit the search and then move to the beginning of the line. | |
95 | @key{RET} is necessary only if the next command you want to type is a | |
96 | printing character, @key{DEL}, @key{RET}, or another character that is | |
6bf7aab6 | 97 | special within searches (@kbd{C-q}, @kbd{C-w}, @kbd{C-r}, @kbd{C-s}, |
f98a8ffd | 98 | @kbd{C-y}, @kbd{M-y}, @kbd{M-r}, @kbd{M-c}, @kbd{M-e}, and some other |
b20a1c88 | 99 | meta-characters). |
6bf7aab6 | 100 | |
f2fd3623 RS |
101 | When you exit the incremental search, it sets the mark where point |
102 | @emph{was} before the search. That is convenient for moving back | |
103 | there. In Transient Mark mode, incremental search sets the mark | |
104 | without activating it, and does so only if the mark is not already | |
105 | active. | |
106 | ||
107 | @node Repeat Isearch | |
108 | @subsection Repeating Incremental Search | |
109 | ||
a76af65d | 110 | Sometimes you search for @samp{FOO} and find one, but not the one you |
91cf1909 RS |
111 | expected to find. There was a second @samp{FOO} that you forgot |
112 | about, before the one you were aiming for. In this event, type | |
113 | another @kbd{C-s} to move to the next occurrence of the search string. | |
114 | You can repeat this any number of times. If you overshoot, you can | |
115 | cancel some @kbd{C-s} characters with @key{DEL}. | |
6bf7aab6 DL |
116 | |
117 | After you exit a search, you can search for the same string again by | |
118 | typing just @kbd{C-s C-s}: the first @kbd{C-s} is the key that invokes | |
119 | incremental search, and the second @kbd{C-s} means ``search again.'' | |
120 | ||
f2fd3623 RS |
121 | If a search is failing and you ask to repeat it by typing another |
122 | @kbd{C-s}, it starts again from the beginning of the buffer. | |
123 | Repeating a failing reverse search with @kbd{C-r} starts again from | |
124 | the end. This is called @dfn{wrapping around}, and @samp{Wrapped} | |
125 | appears in the search prompt once this has happened. If you keep on | |
126 | going past the original starting point of the search, it changes to | |
127 | @samp{Overwrapped}, which means that you are revisiting matches that | |
128 | you have already seen. | |
129 | ||
6bf7aab6 DL |
130 | To reuse earlier search strings, use the @dfn{search ring}. The |
131 | commands @kbd{M-p} and @kbd{M-n} move through the ring to pick a search | |
132 | string to reuse. These commands leave the selected search ring element | |
f98a8ffd JL |
133 | in the minibuffer, where you can edit it. To edit the current search |
134 | string in the minibuffer without replacing it with items from the | |
135 | search ring, type @kbd{M-e}. Type @kbd{C-s} or @kbd{C-r} | |
6bf7aab6 DL |
136 | to terminate editing the string and search for it. |
137 | ||
f2fd3623 RS |
138 | You can change to searching backwards with @kbd{C-r}. If a search fails |
139 | because the place you started was too late in the file, you should do this. | |
140 | Repeated @kbd{C-r} keeps looking for more occurrences backwards. A | |
141 | @kbd{C-s} starts going forwards again. @kbd{C-r} in a search can be canceled | |
142 | with @key{DEL}. | |
143 | ||
144 | @kindex C-r | |
145 | @findex isearch-backward | |
146 | If you know initially that you want to search backwards, you can use | |
147 | @kbd{C-r} instead of @kbd{C-s} to start the search, because @kbd{C-r} as | |
148 | a key runs a command (@code{isearch-backward}) to search backward. A | |
149 | backward search finds matches that are entirely before the starting | |
150 | point, just as a forward search finds matches that begin after it. | |
151 | ||
152 | @node Error in Isearch | |
153 | @subsection Errors in Incremental Search | |
154 | ||
6bf7aab6 DL |
155 | If your string is not found at all, the echo area says @samp{Failing |
156 | I-Search}. The cursor is after the place where Emacs found as much of your | |
157 | string as it could. Thus, if you search for @samp{FOOT}, and there is no | |
158 | @samp{FOOT}, you might see the cursor after the @samp{FOO} in @samp{FOOL}. | |
159 | At this point there are several things you can do. If your string was | |
160 | mistyped, you can rub some of it out and correct it. If you like the place | |
161 | you have found, you can type @key{RET} or some other Emacs command to | |
a76af65d | 162 | remain there. Or you can type @kbd{C-g}, which |
6bf7aab6 DL |
163 | removes from the search string the characters that could not be found (the |
164 | @samp{T} in @samp{FOOT}), leaving those that were found (the @samp{FOO} in | |
165 | @samp{FOOT}). A second @kbd{C-g} at that point cancels the search | |
166 | entirely, returning point to where it was when the search started. | |
167 | ||
f2fd3623 RS |
168 | @cindex quitting (in search) |
169 | The @kbd{C-g} ``quit'' character does special things during searches; | |
170 | just what it does depends on the status of the search. If the search has | |
171 | found what you specified and is waiting for input, @kbd{C-g} cancels the | |
172 | entire search. The cursor moves back to where you started the search. If | |
173 | @kbd{C-g} is typed when there are characters in the search string that have | |
174 | not been found---because Emacs is still searching for them, or because it | |
175 | has failed to find them---then the search string characters which have not | |
176 | been found are discarded from the search string. With them gone, the | |
177 | search is now successful and waiting for more input, so a second @kbd{C-g} | |
178 | will cancel the entire search. | |
179 | ||
180 | @node Special Isearch | |
181 | @subsection Special Input for Incremental Search | |
182 | ||
6bf7aab6 DL |
183 | An upper-case letter in the search string makes the search |
184 | case-sensitive. If you delete the upper-case character from the search | |
185 | string, it ceases to have this effect. @xref{Search Case}. | |
186 | ||
91cf1909 RS |
187 | To search for a newline, type @kbd{C-j}. To search for another |
188 | control character, such as control-S or carriage return, you must quote | |
189 | it by typing @kbd{C-q} first. This function of @kbd{C-q} is analogous | |
190 | to its use for insertion (@pxref{Inserting Text}): it causes the | |
191 | following character to be treated the way any ``ordinary'' character is | |
192 | treated in the same context. You can also specify a character by its | |
193 | octal code: enter @kbd{C-q} followed by a sequence of octal digits. | |
194 | ||
f2fd3623 RS |
195 | @kbd{M-%} typed in incremental search invokes @code{query-replace} |
196 | or @code{query-replace-regexp} (depending on search mode) with the | |
197 | current search string used as the string to replace. @xref{Query | |
198 | Replace}. | |
199 | ||
200 | Entering @key{RET} when the search string is empty launches | |
201 | nonincremental search (@pxref{Nonincremental Search}). | |
202 | ||
203 | @vindex isearch-mode-map | |
204 | To customize the special characters that incremental search understands, | |
205 | alter their bindings in the keymap @code{isearch-mode-map}. For a list | |
206 | of bindings, look at the documentation of @code{isearch-mode} with | |
207 | @kbd{C-h f isearch-mode @key{RET}}. | |
208 | ||
8624d250 | 209 | @node Non-ASCII Isearch |
f2fd3623 RS |
210 | @subsection Isearch for Non-@acronym{ASCII} Characters |
211 | ||
76dd3692 | 212 | @cindex searching for non-@acronym{ASCII} characters |
4a1b539b | 213 | @cindex input method, during incremental search |
f2fd3623 | 214 | |
47a14a31 | 215 | To enter non-@acronym{ASCII} characters in an incremental search, |
f2fd3623 RS |
216 | you must use an input method (@pxref{Input Methods}). If an input |
217 | method is enabled in the current buffer when you start the search, you | |
218 | can use it while you type the search string also. Emacs indicates | |
219 | that by including the input method mnemonic in its prompt, like this: | |
4a1b539b EZ |
220 | |
221 | @example | |
91cf1909 | 222 | I-search [@var{im}]: |
4a1b539b EZ |
223 | @end example |
224 | ||
225 | @noindent | |
226 | @findex isearch-toggle-input-method | |
227 | @findex isearch-toggle-specified-input-method | |
228 | where @var{im} is the mnemonic of the active input method. You can | |
229 | toggle (enable or disable) the input method while you type the search | |
230 | string with @kbd{C-\} (@code{isearch-toggle-input-method}). You can | |
231 | turn on a certain (non-default) input method with @kbd{C-^} | |
232 | (@code{isearch-toggle-specified-input-method}), which prompts for the | |
e9c80604 RS |
233 | name of the input method. The input method you enable during |
234 | incremental search remains enabled in the current buffer afterwards. | |
4a1b539b | 235 | |
f2fd3623 RS |
236 | @node Isearch Yank |
237 | @subsection Isearch Yanking | |
6bf7aab6 | 238 | |
f98a8ffd | 239 | The characters @kbd{C-w} and @kbd{C-y} can be used in incremental |
1e9ec40b RS |
240 | search to grab text from the buffer into the search string. This |
241 | makes it convenient to search for another occurrence of text at point. | |
242 | @kbd{C-w} copies the character or word after point as part of the | |
243 | search string, advancing point over it. (The decision, whether to | |
244 | copy a character or a word, is heuristic.) Another @kbd{C-s} to | |
245 | repeat the search will then search for a string including that | |
246 | character or word. | |
247 | ||
248 | @kbd{C-y} is similar to @kbd{C-w} but copies all the rest of the | |
0b4fe585 EZ |
249 | current line into the search string. If point is already at the end |
250 | of a line, it grabs the entire next line. Both @kbd{C-y} and | |
251 | @kbd{C-w} convert the text they copy to lower case if the search is | |
252 | currently not case-sensitive; this is so the search remains | |
253 | case-insensitive. | |
6bf7aab6 | 254 | |
f98a8ffd JL |
255 | @kbd{C-M-w} and @kbd{C-M-y} modify the search string by only one |
256 | character at a time: @kbd{C-M-w} deletes the last character from the | |
257 | search string and @kbd{C-M-y} copies the character after point to the | |
258 | end of the search string. An alternative method to add the character | |
259 | after point into the search string is to enter the minibuffer by | |
260 | @kbd{M-e} and to type @kbd{C-f} at the end of the search string in the | |
261 | minibuffer. | |
262 | ||
6bf7aab6 DL |
263 | The character @kbd{M-y} copies text from the kill ring into the search |
264 | string. It uses the same text that @kbd{C-y} as a command would yank. | |
91cf1909 | 265 | @kbd{Mouse-2} in the echo area does the same. |
6bf7aab6 DL |
266 | @xref{Yanking}. |
267 | ||
f2fd3623 RS |
268 | @node Highlight Isearch |
269 | @subsection Lazy Search Highlighting | |
1de69f0c | 270 | @cindex lazy search highlighting |
1de69f0c | 271 | @vindex isearch-lazy-highlight |
f2fd3623 | 272 | |
91cf1909 RS |
273 | When you pause for a little while during incremental search, it |
274 | highlights all other possible matches for the search string. This | |
275 | makes it easier to anticipate where you can get to by typing @kbd{C-s} | |
276 | or @kbd{C-r} to repeat the search. The short delay before highlighting | |
277 | other matches helps indicate which match is the current one. | |
278 | If you don't like this feature, you can turn it off by setting | |
279 | @code{isearch-lazy-highlight} to @code{nil}. | |
1de69f0c | 280 | |
24346b4e | 281 | @cindex faces for highlighting search matches |
6f515f89 | 282 | You can control how this highlighting looks by customizing the faces |
8bcc4f6b RS |
283 | @code{isearch} (used for the current match) and @code{lazy-highlight} |
284 | (for all the other matches). The latter is also used for other matches | |
285 | inside @code{query-replace}. | |
24346b4e | 286 | |
f2fd3623 | 287 | @node Isearch Scroll |
a57bfc9f EZ |
288 | @subsection Scrolling During Incremental Search |
289 | ||
290 | Vertical scrolling during incremental search can be enabled by | |
291 | setting the customizable variable @code{isearch-allow-scroll} to a | |
bf301e70 | 292 | non-@code{nil} value. |
a57bfc9f EZ |
293 | |
294 | You can then use the vertical scroll-bar or certain keyboard | |
295 | commands such as @kbd{@key{PRIOR}} (@code{scroll-down}), | |
296 | @kbd{@key{NEXT}} (@code{scroll-up}) and @kbd{C-l} (@code{recenter}) | |
297 | within the search, thus letting you see more of the text near the | |
298 | current match. You must run these commands via their key sequences to | |
c778ed49 | 299 | stay in the search---typing M-x @var{command-name} will always |
a57bfc9f EZ |
300 | terminate a search. |
301 | ||
302 | You can give prefix arguments to these commands in the usual way. | |
bf301e70 | 303 | The current match cannot be scrolled out of the window---this is |
a57bfc9f EZ |
304 | intentional. |
305 | ||
306 | Several other commands, such as @kbd{C-x 2} | |
307 | (@code{split-window-vertically}) and @kbd{C-x ^} | |
308 | (@code{enlarge-window}) which don't scroll the window, are | |
309 | nevertheless made available under this rubric, since they are likewise | |
310 | handy during a search. | |
311 | ||
f2fd3623 RS |
312 | You can make other commands usable within an incremental search by |
313 | giving the command a non-@code{nil} @code{isearch-scroll} property. | |
c778ed49 LT |
314 | For example, to make @kbd{C-h l} usable within an incremental search |
315 | in all future Emacs sessions, use @kbd{C-h c} to find what command it | |
316 | runs. (You type @kbd{C-h c C-h l}; it says @code{view-lossage}.) Then | |
317 | you can put the following line in your @file{.emacs} file (@pxref{Init File}): | |
318 | ||
319 | @example | |
320 | (put 'view-lossage 'isearch-scroll t) | |
321 | @end example | |
322 | ||
323 | @noindent | |
f2fd3623 RS |
324 | This works for commands that don't permanently change point, the |
325 | buffer contents, the match data, the current buffer, or the selected | |
326 | window and frame. The command must not delete the current window and | |
327 | must not itself attempt an incremental search. | |
a57bfc9f | 328 | |
f2fd3623 | 329 | @node Slow Isearch |
6bf7aab6 DL |
330 | @subsection Slow Terminal Incremental Search |
331 | ||
332 | Incremental search on a slow terminal uses a modified style of display | |
333 | that is designed to take less time. Instead of redisplaying the buffer at | |
334 | each place the search gets to, it creates a new single-line window and uses | |
335 | that to display the line that the search has found. The single-line window | |
6f515f89 | 336 | comes into play as soon as point moves outside of the text that is already |
6bf7aab6 DL |
337 | on the screen. |
338 | ||
339 | When you terminate the search, the single-line window is removed. | |
6f515f89 | 340 | Emacs then redisplays the window in which the search was done, to show |
6bf7aab6 DL |
341 | its new position of point. |
342 | ||
6bf7aab6 DL |
343 | @vindex search-slow-speed |
344 | The slow terminal style of display is used when the terminal baud rate is | |
345 | less than or equal to the value of the variable @code{search-slow-speed}, | |
c778ed49 LT |
346 | initially 1200. See also the discussion of the variable @code{baud-rate} |
347 | (@pxref{baud-rate,, Customization of Display}). | |
6bf7aab6 DL |
348 | |
349 | @vindex search-slow-window-lines | |
350 | The number of lines to use in slow terminal search display is controlled | |
351 | by the variable @code{search-slow-window-lines}. Its normal value is 1. | |
352 | ||
f2fd3623 | 353 | @node Nonincremental Search |
6bf7aab6 DL |
354 | @section Nonincremental Search |
355 | @cindex nonincremental search | |
356 | ||
357 | Emacs also has conventional nonincremental search commands, which require | |
358 | you to type the entire search string before searching begins. | |
359 | ||
360 | @table @kbd | |
361 | @item C-s @key{RET} @var{string} @key{RET} | |
362 | Search for @var{string}. | |
363 | @item C-r @key{RET} @var{string} @key{RET} | |
364 | Search backward for @var{string}. | |
365 | @end table | |
366 | ||
367 | To do a nonincremental search, first type @kbd{C-s @key{RET}}. This | |
368 | enters the minibuffer to read the search string; terminate the string | |
369 | with @key{RET}, and then the search takes place. If the string is not | |
a76af65d RS |
370 | found, the search command signals an error. |
371 | ||
372 | When you type @kbd{C-s @key{RET}}, the @kbd{C-s} invokes incremental | |
373 | search as usual. That command is specially programmed to invoke | |
374 | nonincremental search, @code{search-forward}, if the string you | |
375 | specify is empty. (Such an empty argument would otherwise be | |
376 | useless.) But it does not call @code{search-forward} right away. First | |
377 | it checks the next input character to see if is @kbd{C-w}, | |
378 | which specifies a word search. | |
6bf7aab6 DL |
379 | @ifinfo |
380 | @xref{Word Search}. | |
381 | @end ifinfo | |
a76af65d | 382 | @kbd{C-r @key{RET}} does likewise, for a reverse incremental search. |
6bf7aab6 DL |
383 | |
384 | @findex search-forward | |
385 | @findex search-backward | |
386 | Forward and backward nonincremental searches are implemented by the | |
387 | commands @code{search-forward} and @code{search-backward}. These | |
388 | commands may be bound to keys in the usual manner. The feature that you | |
389 | can get to them via the incremental search commands exists for | |
a76af65d | 390 | historical reasons, and to avoid the need to find key sequences |
6bf7aab6 DL |
391 | for them. |
392 | ||
f2fd3623 | 393 | @node Word Search |
6bf7aab6 DL |
394 | @section Word Search |
395 | @cindex word search | |
396 | ||
397 | Word search searches for a sequence of words without regard to how the | |
398 | words are separated. More precisely, you type a string of many words, | |
6f515f89 EZ |
399 | using single spaces to separate them, and the string can be found even |
400 | if there are multiple spaces, newlines, or other punctuation characters | |
401 | between these words. | |
6bf7aab6 DL |
402 | |
403 | Word search is useful for editing a printed document made with a text | |
404 | formatter. If you edit while looking at the printed, formatted version, | |
405 | you can't tell where the line breaks are in the source file. With word | |
406 | search, you can search without having to know them. | |
407 | ||
408 | @table @kbd | |
409 | @item C-s @key{RET} C-w @var{words} @key{RET} | |
410 | Search for @var{words}, ignoring details of punctuation. | |
411 | @item C-r @key{RET} C-w @var{words} @key{RET} | |
412 | Search backward for @var{words}, ignoring details of punctuation. | |
413 | @end table | |
414 | ||
415 | Word search is a special case of nonincremental search and is invoked | |
416 | with @kbd{C-s @key{RET} C-w}. This is followed by the search string, | |
417 | which must always be terminated with @key{RET}. Being nonincremental, | |
418 | this search does not start until the argument is terminated. It works | |
419 | by constructing a regular expression and searching for that; see | |
420 | @ref{Regexp Search}. | |
421 | ||
422 | Use @kbd{C-r @key{RET} C-w} to do backward word search. | |
423 | ||
424 | @findex word-search-forward | |
425 | @findex word-search-backward | |
426 | Forward and backward word searches are implemented by the commands | |
427 | @code{word-search-forward} and @code{word-search-backward}. These | |
a76af65d RS |
428 | commands may be bound to keys in the usual manner. They are available |
429 | via the incremental search commands both for historical reasons and | |
430 | to avoid the need to find suitable key sequences for them. | |
6bf7aab6 | 431 | |
f2fd3623 | 432 | @node Regexp Search |
6bf7aab6 DL |
433 | @section Regular Expression Search |
434 | @cindex regular expression | |
435 | @cindex regexp | |
436 | ||
a76af65d RS |
437 | A @dfn{regular expression} (@dfn{regexp}, for short) is a pattern |
438 | that denotes a class of alternative strings to match, possibly | |
439 | infinitely many. GNU Emacs provides both incremental and | |
f2fd3623 RS |
440 | nonincremental ways to search for a match for a regexp. The syntax of |
441 | regular expressions is explained in the following section. | |
6bf7aab6 DL |
442 | |
443 | @kindex C-M-s | |
444 | @findex isearch-forward-regexp | |
445 | @kindex C-M-r | |
446 | @findex isearch-backward-regexp | |
447 | Incremental search for a regexp is done by typing @kbd{C-M-s} | |
f98a8ffd JL |
448 | (@code{isearch-forward-regexp}), by invoking @kbd{C-s} with a |
449 | prefix argument (whose value does not matter), or by typing @kbd{M-r} | |
450 | within a forward incremental search. This command reads a | |
a76af65d RS |
451 | search string incrementally just like @kbd{C-s}, but it treats the |
452 | search string as a regexp rather than looking for an exact match | |
453 | against the text in the buffer. Each time you add text to the search | |
454 | string, you make the regexp longer, and the new regexp is searched | |
455 | for. To search backward for a regexp, use @kbd{C-M-r} | |
f98a8ffd JL |
456 | (@code{isearch-backward-regexp}), @kbd{C-r} with a prefix argument, |
457 | or @kbd{M-r} within a backward incremental search. | |
6bf7aab6 DL |
458 | |
459 | All of the control characters that do special things within an | |
460 | ordinary incremental search have the same function in incremental regexp | |
461 | search. Typing @kbd{C-s} or @kbd{C-r} immediately after starting the | |
462 | search retrieves the last incremental search regexp used; that is to | |
463 | say, incremental regexp and non-regexp searches have independent | |
464 | defaults. They also have separate search rings that you can access with | |
465 | @kbd{M-p} and @kbd{M-n}. | |
466 | ||
467 | If you type @key{SPC} in incremental regexp search, it matches any | |
468 | sequence of whitespace characters, including newlines. If you want | |
469 | to match just a space, type @kbd{C-q @key{SPC}}. | |
470 | ||
471 | Note that adding characters to the regexp in an incremental regexp | |
472 | search can make the cursor move back and start again. For example, if | |
473 | you have searched for @samp{foo} and you add @samp{\|bar}, the cursor | |
474 | backs up in case the first @samp{bar} precedes the first @samp{foo}. | |
475 | ||
476 | @findex re-search-forward | |
477 | @findex re-search-backward | |
478 | Nonincremental search for a regexp is done by the functions | |
479 | @code{re-search-forward} and @code{re-search-backward}. You can invoke | |
480 | these with @kbd{M-x}, or bind them to keys, or invoke them by way of | |
481 | incremental regexp search with @kbd{C-M-s @key{RET}} and @kbd{C-M-r | |
482 | @key{RET}}. | |
483 | ||
484 | If you use the incremental regexp search commands with a prefix | |
485 | argument, they perform ordinary string search, like | |
486 | @code{isearch-forward} and @code{isearch-backward}. @xref{Incremental | |
487 | Search}. | |
488 | ||
f2fd3623 | 489 | @node Regexps |
6bf7aab6 | 490 | @section Syntax of Regular Expressions |
4946337d | 491 | @cindex syntax of regexps |
6bf7aab6 | 492 | |
872d74eb RS |
493 | This manual describes regular expression features that users |
494 | typically want to use. There are additional features that are | |
495 | mainly used in Lisp programs; see @ref{Regular Expressions,,, | |
5485e3ec | 496 | elisp, The Emacs Lisp Reference Manual}. |
872d74eb | 497 | |
6bf7aab6 DL |
498 | Regular expressions have a syntax in which a few characters are |
499 | special constructs and the rest are @dfn{ordinary}. An ordinary | |
500 | character is a simple regular expression which matches that same | |
501 | character and nothing else. The special characters are @samp{$}, | |
502 | @samp{^}, @samp{.}, @samp{*}, @samp{+}, @samp{?}, @samp{[}, @samp{]} and | |
503 | @samp{\}. Any other character appearing in a regular expression is | |
96e29ebe EZ |
504 | ordinary, unless a @samp{\} precedes it. (When you use regular |
505 | expressions in a Lisp program, each @samp{\} must be doubled, see the | |
506 | example near the end of this section.) | |
6bf7aab6 DL |
507 | |
508 | For example, @samp{f} is not a special character, so it is ordinary, and | |
509 | therefore @samp{f} is a regular expression that matches the string | |
510 | @samp{f} and no other string. (It does @emph{not} match the string | |
511 | @samp{ff}.) Likewise, @samp{o} is a regular expression that matches | |
512 | only @samp{o}. (When case distinctions are being ignored, these regexps | |
513 | also match @samp{F} and @samp{O}, but we consider this a generalization | |
514 | of ``the same string,'' rather than an exception.) | |
515 | ||
516 | Any two regular expressions @var{a} and @var{b} can be concatenated. The | |
517 | result is a regular expression which matches a string if @var{a} matches | |
518 | some amount of the beginning of that string and @var{b} matches the rest of | |
519 | the string.@refill | |
520 | ||
521 | As a simple example, we can concatenate the regular expressions @samp{f} | |
522 | and @samp{o} to get the regular expression @samp{fo}, which matches only | |
523 | the string @samp{fo}. Still trivial. To do something nontrivial, you | |
524 | need to use one of the special characters. Here is a list of them. | |
525 | ||
f3143102 RS |
526 | @table @asis |
527 | @item @kbd{.}@: @r{(Period)} | |
6bf7aab6 DL |
528 | is a special character that matches any single character except a newline. |
529 | Using concatenation, we can make regular expressions like @samp{a.b}, which | |
530 | matches any three-character string that begins with @samp{a} and ends with | |
531 | @samp{b}.@refill | |
532 | ||
f3143102 | 533 | @item @kbd{*} |
6bf7aab6 DL |
534 | is not a construct by itself; it is a postfix operator that means to |
535 | match the preceding regular expression repetitively as many times as | |
536 | possible. Thus, @samp{o*} matches any number of @samp{o}s (including no | |
537 | @samp{o}s). | |
538 | ||
539 | @samp{*} always applies to the @emph{smallest} possible preceding | |
540 | expression. Thus, @samp{fo*} has a repeating @samp{o}, not a repeating | |
541 | @samp{fo}. It matches @samp{f}, @samp{fo}, @samp{foo}, and so on. | |
542 | ||
543 | The matcher processes a @samp{*} construct by matching, immediately, | |
544 | as many repetitions as can be found. Then it continues with the rest | |
545 | of the pattern. If that fails, backtracking occurs, discarding some | |
546 | of the matches of the @samp{*}-modified construct in case that makes | |
547 | it possible to match the rest of the pattern. For example, in matching | |
548 | @samp{ca*ar} against the string @samp{caaar}, the @samp{a*} first | |
549 | tries to match all three @samp{a}s; but the rest of the pattern is | |
550 | @samp{ar} and there is only @samp{r} left to match, so this try fails. | |
551 | The next alternative is for @samp{a*} to match only two @samp{a}s. | |
552 | With this choice, the rest of the regexp matches successfully.@refill | |
553 | ||
f3143102 | 554 | @item @kbd{+} |
6bf7aab6 DL |
555 | is a postfix operator, similar to @samp{*} except that it must match |
556 | the preceding expression at least once. So, for example, @samp{ca+r} | |
557 | matches the strings @samp{car} and @samp{caaaar} but not the string | |
558 | @samp{cr}, whereas @samp{ca*r} matches all three strings. | |
559 | ||
f3143102 | 560 | @item @kbd{?} |
6bf7aab6 DL |
561 | is a postfix operator, similar to @samp{*} except that it can match the |
562 | preceding expression either once or not at all. For example, | |
563 | @samp{ca?r} matches @samp{car} or @samp{cr}; nothing else. | |
564 | ||
f3143102 | 565 | @item @kbd{*?}, @kbd{+?}, @kbd{??} |
f1a88ed9 | 566 | @cindex non-greedy regexp matching |
8964fec7 | 567 | are non-greedy variants of the operators above. The normal operators |
91cf1909 RS |
568 | @samp{*}, @samp{+}, @samp{?} are @dfn{greedy} in that they match as |
569 | much as they can, as long as the overall regexp can still match. With | |
570 | a following @samp{?}, they are non-greedy: they will match as little | |
571 | as possible. | |
572 | ||
573 | Thus, both @samp{ab*} and @samp{ab*?} can match the string @samp{a} | |
574 | and the string @samp{abbbb}; but if you try to match them both against | |
575 | the text @samp{abbb}, @samp{ab*} will match it all (the longest valid | |
576 | match), while @samp{ab*?} will match just @samp{a} (the shortest | |
577 | valid match). | |
578 | ||
bed0fc91 RS |
579 | Non-greedy operators match the shortest possible string starting at a |
580 | given starting point; in a forward search, though, the earliest | |
581 | possible starting point for match is always the one chosen. Thus, if | |
582 | you search for @samp{a.*?$} against the text @samp{abbab} followed by | |
583 | a newline, it matches the whole string. Since it @emph{can} match | |
584 | starting at the first @samp{a}, it does. | |
585 | ||
f3143102 | 586 | @item @kbd{\@{@var{n}\@}} |
91cf1909 RS |
587 | is a postfix operator that specifies repetition @var{n} times---that |
588 | is, the preceding regular expression must match exactly @var{n} times | |
589 | in a row. For example, @samp{x\@{4\@}} matches the string @samp{xxxx} | |
590 | and nothing else. | |
8964fec7 | 591 | |
f3143102 | 592 | @item @kbd{\@{@var{n},@var{m}\@}} |
91cf1909 RS |
593 | is a postfix operator that specifies repetition between @var{n} and |
594 | @var{m} times---that is, the preceding regular expression must match | |
595 | at least @var{n} times, but no more than @var{m} times. If @var{m} is | |
596 | omitted, then there is no upper limit, but the preceding regular | |
597 | expression must match at least @var{n} times.@* @samp{\@{0,1\@}} is | |
598 | equivalent to @samp{?}. @* @samp{\@{0,\@}} is equivalent to | |
599 | @samp{*}. @* @samp{\@{1,\@}} is equivalent to @samp{+}. | |
8a44227a | 600 | |
f3143102 | 601 | @item @kbd{[ @dots{} ]} |
6bf7aab6 DL |
602 | is a @dfn{character set}, which begins with @samp{[} and is terminated |
603 | by @samp{]}. In the simplest case, the characters between the two | |
604 | brackets are what this set can match. | |
605 | ||
606 | Thus, @samp{[ad]} matches either one @samp{a} or one @samp{d}, and | |
607 | @samp{[ad]*} matches any string composed of just @samp{a}s and @samp{d}s | |
608 | (including the empty string), from which it follows that @samp{c[ad]*r} | |
609 | matches @samp{cr}, @samp{car}, @samp{cdr}, @samp{caddaar}, etc. | |
610 | ||
611 | You can also include character ranges in a character set, by writing the | |
612 | starting and ending characters with a @samp{-} between them. Thus, | |
76dd3692 | 613 | @samp{[a-z]} matches any lower-case @acronym{ASCII} letter. Ranges may be |
6bf7aab6 | 614 | intermixed freely with individual characters, as in @samp{[a-z$%.]}, |
76dd3692 | 615 | which matches any lower-case @acronym{ASCII} letter or @samp{$}, @samp{%} or |
6bf7aab6 DL |
616 | period. |
617 | ||
618 | Note that the usual regexp special characters are not special inside a | |
619 | character set. A completely different set of special characters exists | |
620 | inside character sets: @samp{]}, @samp{-} and @samp{^}. | |
621 | ||
622 | To include a @samp{]} in a character set, you must make it the first | |
623 | character. For example, @samp{[]a]} matches @samp{]} or @samp{a}. To | |
624 | include a @samp{-}, write @samp{-} as the first or last character of the | |
625 | set, or put it after a range. Thus, @samp{[]-]} matches both @samp{]} | |
626 | and @samp{-}. | |
627 | ||
628 | To include @samp{^} in a set, put it anywhere but at the beginning of | |
b20a1c88 | 629 | the set. (At the beginning, it complements the set---see below.) |
6bf7aab6 DL |
630 | |
631 | When you use a range in case-insensitive search, you should write both | |
632 | ends of the range in upper case, or both in lower case, or both should | |
633 | be non-letters. The behavior of a mixed-case range such as @samp{A-z} | |
634 | is somewhat ill-defined, and it may change in future Emacs versions. | |
635 | ||
f3143102 | 636 | @item @kbd{[^ @dots{} ]} |
6bf7aab6 DL |
637 | @samp{[^} begins a @dfn{complemented character set}, which matches any |
638 | character except the ones specified. Thus, @samp{[^a-z0-9A-Z]} matches | |
76dd3692 | 639 | all characters @emph{except} @acronym{ASCII} letters and digits. |
6bf7aab6 DL |
640 | |
641 | @samp{^} is not special in a character set unless it is the first | |
642 | character. The character following the @samp{^} is treated as if it | |
643 | were first (in other words, @samp{-} and @samp{]} are not special there). | |
644 | ||
645 | A complemented character set can match a newline, unless newline is | |
646 | mentioned as one of the characters not to match. This is in contrast to | |
647 | the handling of regexps in programs such as @code{grep}. | |
648 | ||
f3143102 | 649 | @item @kbd{^} |
6bf7aab6 DL |
650 | is a special character that matches the empty string, but only at the |
651 | beginning of a line in the text being matched. Otherwise it fails to | |
652 | match anything. Thus, @samp{^foo} matches a @samp{foo} that occurs at | |
653 | the beginning of a line. | |
654 | ||
40d0bf85 RS |
655 | For historical compatibility reasons, @samp{^} can be used with this |
656 | meaning only at the beginning of the regular expression, or after | |
657 | @samp{\(} or @samp{\|}. | |
658 | ||
f3143102 | 659 | @item @kbd{$} |
6bf7aab6 DL |
660 | is similar to @samp{^} but matches only at the end of a line. Thus, |
661 | @samp{x+$} matches a string of one @samp{x} or more at the end of a line. | |
662 | ||
40d0bf85 RS |
663 | For historical compatibility reasons, @samp{$} can be used with this |
664 | meaning only at the end of the regular expression, or before @samp{\)} | |
665 | or @samp{\|}. | |
666 | ||
f3143102 | 667 | @item @kbd{\} |
6bf7aab6 DL |
668 | has two functions: it quotes the special characters (including |
669 | @samp{\}), and it introduces additional special constructs. | |
670 | ||
671 | Because @samp{\} quotes special characters, @samp{\$} is a regular | |
672 | expression that matches only @samp{$}, and @samp{\[} is a regular | |
673 | expression that matches only @samp{[}, and so on. | |
c118d09e RS |
674 | |
675 | See the following section for the special constructs that begin | |
676 | with @samp{\}. | |
6bf7aab6 DL |
677 | @end table |
678 | ||
c118d09e | 679 | Note: for historical compatibility, special characters are treated as |
6bf7aab6 DL |
680 | ordinary ones if they are in contexts where their special meanings make no |
681 | sense. For example, @samp{*foo} treats @samp{*} as ordinary since there is | |
682 | no preceding expression on which the @samp{*} can act. It is poor practice | |
683 | to depend on this behavior; it is better to quote the special character anyway, | |
c118d09e RS |
684 | regardless of where it appears. |
685 | ||
686 | @node Regexp Backslash | |
687 | @section Backslash in Regular Expressions | |
6bf7aab6 | 688 | |
c118d09e RS |
689 | For the most part, @samp{\} followed by any character matches only |
690 | that character. However, there are several exceptions: two-character | |
691 | sequences starting with @samp{\} that have special meanings. The | |
692 | second character in the sequence is always an ordinary character when | |
693 | used on its own. Here is a table of @samp{\} constructs. | |
6bf7aab6 DL |
694 | |
695 | @table @kbd | |
696 | @item \| | |
697 | specifies an alternative. Two regular expressions @var{a} and @var{b} | |
698 | with @samp{\|} in between form an expression that matches some text if | |
699 | either @var{a} matches it or @var{b} matches it. It works by trying to | |
700 | match @var{a}, and if that fails, by trying to match @var{b}. | |
701 | ||
702 | Thus, @samp{foo\|bar} matches either @samp{foo} or @samp{bar} | |
703 | but no other string.@refill | |
704 | ||
705 | @samp{\|} applies to the largest possible surrounding expressions. Only a | |
706 | surrounding @samp{\( @dots{} \)} grouping can limit the grouping power of | |
707 | @samp{\|}.@refill | |
708 | ||
709 | Full backtracking capability exists to handle multiple uses of @samp{\|}. | |
710 | ||
711 | @item \( @dots{} \) | |
712 | is a grouping construct that serves three purposes: | |
713 | ||
714 | @enumerate | |
715 | @item | |
716 | To enclose a set of @samp{\|} alternatives for other operations. | |
717 | Thus, @samp{\(foo\|bar\)x} matches either @samp{foox} or @samp{barx}. | |
718 | ||
719 | @item | |
720 | To enclose a complicated expression for the postfix operators @samp{*}, | |
721 | @samp{+} and @samp{?} to operate on. Thus, @samp{ba\(na\)*} matches | |
722 | @samp{bananana}, etc., with any (zero or more) number of @samp{na} | |
723 | strings.@refill | |
724 | ||
725 | @item | |
726 | To record a matched substring for future reference. | |
727 | @end enumerate | |
728 | ||
729 | This last application is not a consequence of the idea of a | |
730 | parenthetical grouping; it is a separate feature that is assigned as a | |
731 | second meaning to the same @samp{\( @dots{} \)} construct. In practice | |
91cf1909 RS |
732 | there is usually no conflict between the two meanings; when there is |
733 | a conflict, you can use a ``shy'' group. | |
95cd4c40 SM |
734 | |
735 | @item \(?: @dots{} \) | |
91cf1909 RS |
736 | @cindex shy group, in regexp |
737 | specifies a ``shy'' group that does not record the matched substring; | |
738 | you can't refer back to it with @samp{\@var{d}}. This is useful | |
739 | in mechanically combining regular expressions, so that you | |
740 | can add groups for syntactic purposes without interfering with | |
741 | the numbering of the groups that were written by the user. | |
6bf7aab6 DL |
742 | |
743 | @item \@var{d} | |
744 | matches the same text that matched the @var{d}th occurrence of a | |
745 | @samp{\( @dots{} \)} construct. | |
746 | ||
747 | After the end of a @samp{\( @dots{} \)} construct, the matcher remembers | |
748 | the beginning and end of the text matched by that construct. Then, | |
749 | later on in the regular expression, you can use @samp{\} followed by the | |
750 | digit @var{d} to mean ``match the same text matched the @var{d}th time | |
751 | by the @samp{\( @dots{} \)} construct.'' | |
752 | ||
753 | The strings matching the first nine @samp{\( @dots{} \)} constructs | |
754 | appearing in a regular expression are assigned numbers 1 through 9 in | |
755 | the order that the open-parentheses appear in the regular expression. | |
756 | So you can use @samp{\1} through @samp{\9} to refer to the text matched | |
757 | by the corresponding @samp{\( @dots{} \)} constructs. | |
758 | ||
759 | For example, @samp{\(.*\)\1} matches any newline-free string that is | |
760 | composed of two identical halves. The @samp{\(.*\)} matches the first | |
761 | half, which may be anything, but the @samp{\1} that follows must match | |
762 | the same exact text. | |
763 | ||
764 | If a particular @samp{\( @dots{} \)} construct matches more than once | |
765 | (which can easily happen if it is followed by @samp{*}), only the last | |
766 | match is recorded. | |
767 | ||
768 | @item \` | |
4aa2d40e RS |
769 | matches the empty string, but only at the beginning of the string or |
770 | buffer (or its accessible portion) being matched against. | |
6bf7aab6 DL |
771 | |
772 | @item \' | |
4aa2d40e RS |
773 | matches the empty string, but only at the end of the string or buffer |
774 | (or its accessible portion) being matched against. | |
6bf7aab6 DL |
775 | |
776 | @item \= | |
777 | matches the empty string, but only at point. | |
778 | ||
779 | @item \b | |
780 | matches the empty string, but only at the beginning or | |
781 | end of a word. Thus, @samp{\bfoo\b} matches any occurrence of | |
782 | @samp{foo} as a separate word. @samp{\bballs?\b} matches | |
783 | @samp{ball} or @samp{balls} as a separate word.@refill | |
784 | ||
785 | @samp{\b} matches at the beginning or end of the buffer | |
786 | regardless of what text appears next to it. | |
787 | ||
788 | @item \B | |
789 | matches the empty string, but @emph{not} at the beginning or | |
790 | end of a word. | |
791 | ||
792 | @item \< | |
793 | matches the empty string, but only at the beginning of a word. | |
794 | @samp{\<} matches at the beginning of the buffer only if a | |
795 | word-constituent character follows. | |
796 | ||
797 | @item \> | |
798 | matches the empty string, but only at the end of a word. @samp{\>} | |
799 | matches at the end of the buffer only if the contents end with a | |
800 | word-constituent character. | |
801 | ||
802 | @item \w | |
803 | matches any word-constituent character. The syntax table | |
804 | determines which characters these are. @xref{Syntax}. | |
805 | ||
806 | @item \W | |
807 | matches any character that is not a word-constituent. | |
808 | ||
6ccc7fbc | 809 | @item \_< |
49561cf6 SM |
810 | matches the empty string, but only at the beginning of a symbol. |
811 | A symbol is a sequence of one or more symbol-constituent characters. | |
812 | A symbol-constituent character is a character whose syntax is either | |
0cb23e1d | 813 | @samp{w} or @samp{_}. @samp{\_<} matches at the beginning of the |
49561cf6 | 814 | buffer only if a symbol-constituent character follows. |
6ccc7fbc SM |
815 | |
816 | @item \_> | |
7695a3ae LT |
817 | matches the empty string, but only at the end of a symbol. @samp{\_>} |
818 | matches at the end of the buffer only if the contents end with a | |
819 | symbol-constituent character. | |
6ccc7fbc | 820 | |
6bf7aab6 DL |
821 | @item \s@var{c} |
822 | matches any character whose syntax is @var{c}. Here @var{c} is a | |
b20a1c88 RS |
823 | character that designates a particular syntax class: thus, @samp{w} |
824 | for word constituent, @samp{-} or @samp{ } for whitespace, @samp{.} | |
825 | for ordinary punctuation, etc. @xref{Syntax}. | |
6bf7aab6 DL |
826 | |
827 | @item \S@var{c} | |
828 | matches any character whose syntax is not @var{c}. | |
4a1b539b EZ |
829 | |
830 | @cindex categories of characters | |
831 | @cindex characters which belong to a specific language | |
832 | @findex describe-categories | |
833 | @item \c@var{c} | |
834 | matches any character that belongs to the category @var{c}. For | |
835 | example, @samp{\cc} matches Chinese characters, @samp{\cg} matches | |
836 | Greek characters, etc. For the description of the known categories, | |
837 | type @kbd{M-x describe-categories @key{RET}}. | |
838 | ||
839 | @item \C@var{c} | |
840 | matches any character that does @emph{not} belong to category | |
841 | @var{c}. | |
6bf7aab6 DL |
842 | @end table |
843 | ||
844 | The constructs that pertain to words and syntax are controlled by the | |
845 | setting of the syntax table (@pxref{Syntax}). | |
846 | ||
c118d09e RS |
847 | @node Regexp Example |
848 | @section Regular Expression Example | |
849 | ||
850 | Here is a complicated regexp---a simplified version of the regexp | |
851 | that Emacs uses, by default, to recognize the end of a sentence | |
28fe88fc LT |
852 | together with any whitespace that follows. We show its Lisp syntax to |
853 | distinguish the spaces from the tab characters. In Lisp syntax, the | |
854 | string constant begins and ends with a double-quote. @samp{\"} stands | |
855 | for a double-quote as part of the regexp, @samp{\\} for a backslash as | |
856 | part of the regexp, @samp{\t} for a tab, and @samp{\n} for a newline. | |
6bf7aab6 DL |
857 | |
858 | @example | |
b20a1c88 | 859 | "[.?!][]\"')]*\\($\\| $\\|\t\\| \\)[ \t\n]*" |
6bf7aab6 DL |
860 | @end example |
861 | ||
862 | @noindent | |
b20a1c88 RS |
863 | This contains four parts in succession: a character set matching |
864 | period, @samp{?}, or @samp{!}; a character set matching | |
865 | close-brackets, quotes, or parentheses, repeated zero or more times; a | |
866 | set of alternatives within backslash-parentheses that matches either | |
867 | end-of-line, a space at the end of a line, a tab, or two spaces; and a | |
868 | character set matching whitespace characters, repeated any number of | |
869 | times. | |
6bf7aab6 | 870 | |
31b5be12 RS |
871 | To enter the same regexp in incremental search, you would type |
872 | @key{TAB} to enter a tab, and @kbd{C-j} to enter a newline. You would | |
873 | also type single backslashes as themselves, instead of doubling them | |
874 | for Lisp syntax. In commands that use ordinary minibuffer input to | |
875 | read a regexp, you would quote the @kbd{C-j} by preceding it with a | |
876 | @kbd{C-q} to prevent @kbd{C-j} from exiting the minibuffer. | |
6bf7aab6 | 877 | |
f2fd3623 | 878 | @node Search Case |
6bf7aab6 DL |
879 | @section Searching and Case |
880 | ||
6bf7aab6 DL |
881 | Incremental searches in Emacs normally ignore the case of the text |
882 | they are searching through, if you specify the text in lower case. | |
883 | Thus, if you specify searching for @samp{foo}, then @samp{Foo} and | |
884 | @samp{foo} are also considered a match. Regexps, and in particular | |
885 | character sets, are included: @samp{[ab]} would match @samp{a} or | |
886 | @samp{A} or @samp{b} or @samp{B}.@refill | |
887 | ||
888 | An upper-case letter anywhere in the incremental search string makes | |
889 | the search case-sensitive. Thus, searching for @samp{Foo} does not find | |
890 | @samp{foo} or @samp{FOO}. This applies to regular expression search as | |
891 | well as to string search. The effect ceases if you delete the | |
892 | upper-case letter from the search string. | |
893 | ||
b20a1c88 RS |
894 | Typing @kbd{M-c} within an incremental search toggles the case |
895 | sensitivity of that search. The effect does not extend beyond the | |
896 | current incremental search to the next one, but it does override the | |
897 | effect of including an upper-case letter in the current search. | |
898 | ||
899 | @vindex case-fold-search | |
f2fd3623 | 900 | @vindex default-case-fold-search |
6bf7aab6 DL |
901 | If you set the variable @code{case-fold-search} to @code{nil}, then |
902 | all letters must match exactly, including case. This is a per-buffer | |
903 | variable; altering the variable affects only the current buffer, but | |
f2fd3623 RS |
904 | there is a default value in @code{default-case-fold-search} that you |
905 | can also set. @xref{Locals}. This variable applies to nonincremental | |
906 | searches also, including those performed by the replace commands | |
907 | (@pxref{Replace}) and the minibuffer history matching commands | |
908 | (@pxref{Minibuffer History}). | |
a57bfc9f | 909 | |
f2fd3623 | 910 | @node Replace |
6bf7aab6 DL |
911 | @section Replacement Commands |
912 | @cindex replacement | |
913 | @cindex search-and-replace commands | |
914 | @cindex string substitution | |
915 | @cindex global substitution | |
916 | ||
a76af65d RS |
917 | Global search-and-replace operations are not needed often in Emacs, |
918 | but they are available. In addition to the simple @kbd{M-x | |
f98a8ffd | 919 | replace-string} command which replaces all occurrences, |
7860977a | 920 | there is @kbd{M-%} (@code{query-replace}), which presents each occurrence |
a76af65d | 921 | of the pattern and asks you whether to replace it. |
6bf7aab6 DL |
922 | |
923 | The replace commands normally operate on the text from point to the | |
293fa54a EZ |
924 | end of the buffer; however, in Transient Mark mode (@pxref{Transient |
925 | Mark}), when the mark is active, they operate on the region. The | |
926 | replace commands all replace one string (or regexp) with one | |
927 | replacement string. It is possible to perform several replacements in | |
928 | parallel using the command @code{expand-region-abbrevs} | |
929 | (@pxref{Expanding Abbrevs}). | |
6bf7aab6 DL |
930 | |
931 | @menu | |
a57bfc9f EZ |
932 | * Unconditional Replace:: Replacing all matches for a string. |
933 | * Regexp Replace:: Replacing all matches for a regexp. | |
934 | * Replacement and Case:: How replacements preserve case of letters. | |
935 | * Query Replace:: How to use querying. | |
6bf7aab6 DL |
936 | @end menu |
937 | ||
938 | @node Unconditional Replace, Regexp Replace, Replace, Replace | |
939 | @subsection Unconditional Replacement | |
940 | @findex replace-string | |
6bf7aab6 DL |
941 | |
942 | @table @kbd | |
943 | @item M-x replace-string @key{RET} @var{string} @key{RET} @var{newstring} @key{RET} | |
944 | Replace every occurrence of @var{string} with @var{newstring}. | |
6bf7aab6 DL |
945 | @end table |
946 | ||
947 | To replace every instance of @samp{foo} after point with @samp{bar}, | |
948 | use the command @kbd{M-x replace-string} with the two arguments | |
949 | @samp{foo} and @samp{bar}. Replacement happens only in the text after | |
950 | point, so if you want to cover the whole buffer you must go to the | |
951 | beginning first. All occurrences up to the end of the buffer are | |
952 | replaced; to limit replacement to part of the buffer, narrow to that | |
953 | part of the buffer before doing the replacement (@pxref{Narrowing}). | |
954 | In Transient Mark mode, when the region is active, replacement is | |
955 | limited to the region (@pxref{Transient Mark}). | |
956 | ||
957 | When @code{replace-string} exits, it leaves point at the last | |
958 | occurrence replaced. It sets the mark to the prior position of point | |
959 | (where the @code{replace-string} command was issued); use @kbd{C-u | |
960 | C-@key{SPC}} to move back there. | |
961 | ||
962 | A numeric argument restricts replacement to matches that are surrounded | |
963 | by word boundaries. The argument's value doesn't matter. | |
964 | ||
46b1e9bb RS |
965 | What if you want to exchange @samp{x} and @samp{y}: replace every @samp{x} with a @samp{y} and vice versa? You can do it this way: |
966 | ||
967 | @example | |
a8e3c8d6 DK |
968 | M-x replace-string @key{RET} x @key{RET} @@TEMP@@ @key{RET} |
969 | M-< M-x replace-string @key{RET} y @key{RET} x @key{RET} | |
970 | M-< M-x replace-string @key{RET} @@TEMP@@ @key{RET} y @key{RET} | |
46b1e9bb RS |
971 | @end example |
972 | ||
973 | @noindent | |
974 | This works provided the string @samp{@@TEMP@@} does not appear | |
975 | in your text. | |
976 | ||
6bf7aab6 DL |
977 | @node Regexp Replace, Replacement and Case, Unconditional Replace, Replace |
978 | @subsection Regexp Replacement | |
f2fd3623 | 979 | @findex replace-regexp |
6bf7aab6 DL |
980 | |
981 | The @kbd{M-x replace-string} command replaces exact matches for a | |
982 | single string. The similar command @kbd{M-x replace-regexp} replaces | |
983 | any match for a specified pattern. | |
984 | ||
f2fd3623 RS |
985 | @table @kbd |
986 | @item M-x replace-regexp @key{RET} @var{regexp} @key{RET} @var{newstring} @key{RET} | |
987 | Replace every match for @var{regexp} with @var{newstring}. | |
988 | @end table | |
989 | ||
a745ff66 RS |
990 | In @code{replace-regexp}, the @var{newstring} need not be constant: |
991 | it can refer to all or part of what is matched by the @var{regexp}. | |
992 | @samp{\&} in @var{newstring} stands for the entire match being | |
993 | replaced. @samp{\@var{d}} in @var{newstring}, where @var{d} is a | |
994 | digit, stands for whatever matched the @var{d}th parenthesized | |
995 | grouping in @var{regexp}. @samp{\#} refers to the count of | |
996 | replacements already made in this command, as a decimal number. In | |
997 | the first replacement, @samp{\#} stands for @samp{0}; in the second, | |
998 | for @samp{1}; and so on. For example, | |
6bf7aab6 DL |
999 | |
1000 | @example | |
1001 | M-x replace-regexp @key{RET} c[ad]+r @key{RET} \&-safe @key{RET} | |
1002 | @end example | |
1003 | ||
1004 | @noindent | |
1005 | replaces (for example) @samp{cadr} with @samp{cadr-safe} and @samp{cddr} | |
1006 | with @samp{cddr-safe}. | |
1007 | ||
1008 | @example | |
1009 | M-x replace-regexp @key{RET} \(c[ad]+r\)-safe @key{RET} \1 @key{RET} | |
1010 | @end example | |
1011 | ||
1012 | @noindent | |
a745ff66 RS |
1013 | performs the inverse transformation. To include a @samp{\} in the |
1014 | text to replace with, you must enter @samp{\\}. | |
1015 | ||
c778ed49 LT |
1016 | If you want to enter part of the replacement string by hand each |
1017 | time, use @samp{\?} in the replacement string. Each replacement will | |
1018 | ask you to edit the replacement string in the minibuffer, putting | |
1019 | point where the @samp{\?} was. | |
1020 | ||
1021 | The remainder of this subsection is intended for specialized tasks | |
1022 | and requires knowledge of Lisp. Most readers can skip it. | |
1023 | ||
1024 | You can use Lisp expressions to calculate parts of the | |
a745ff66 RS |
1025 | replacement string. To do this, write @samp{\,} followed by the |
1026 | expression in the replacement string. Each replacement calculates the | |
074f1b8b RS |
1027 | value of the expression and converts it to text without quoting (if |
1028 | it's a string, this means using the string's contents), and uses it in | |
a745ff66 RS |
1029 | the replacement string in place of the expression itself. If the |
1030 | expression is a symbol, one space in the replacement string after the | |
074f1b8b RS |
1031 | symbol name goes with the symbol name, so the value replaces them |
1032 | both. | |
1033 | ||
1034 | Inside such an expression, you can use some special sequences. | |
1035 | @samp{\&} and @samp{\@var{n}} refer here, as usual, to the entire | |
1036 | match as a string, and to a submatch as a string. @var{n} may be | |
1037 | multiple digits, and the value of @samp{\@var{n}} is @code{nil} if | |
1038 | subexpression @var{n} did not match. You can also use @samp{\#&} and | |
1039 | @samp{\#@var{n}} to refer to those matches as numbers (this is valid | |
1040 | when the match or submatch has the form of a numeral). @samp{\#} here | |
1041 | too stands for the number of already-completed replacements. | |
a8e3c8d6 DK |
1042 | |
1043 | Repeating our example to exchange @samp{x} and @samp{y}, we can thus | |
1044 | do it also this way: | |
1045 | ||
1046 | @example | |
1047 | M-x replace-regexp @key{RET} \(x\)\|y @key{RET} | |
1048 | \,(if \1 "y" "x") @key{RET} | |
1ed5c59c DK |
1049 | @end example |
1050 | ||
074f1b8b | 1051 | For computing replacement strings for @samp{\,}, the @code{format} |
5485e3ec | 1052 | function is often useful (@pxref{Formatting Strings,,, elisp, The Emacs |
074f1b8b | 1053 | Lisp Reference Manual}). For example, to add consecutively numbered |
a745ff66 RS |
1054 | strings like @samp{ABC00042} to columns 73 @w{to 80} (unless they are |
1055 | already occupied), you can use | |
1ed5c59c DK |
1056 | |
1057 | @example | |
1058 | M-x replace-regexp @key{RET} ^.\@{0,72\@}$ @key{RET} | |
1059 | \,(format "%-72sABC%05d" \& \#) @key{RET} | |
a8e3c8d6 DK |
1060 | @end example |
1061 | ||
6bf7aab6 DL |
1062 | @node Replacement and Case, Query Replace, Regexp Replace, Replace |
1063 | @subsection Replace Commands and Case | |
1064 | ||
1065 | If the first argument of a replace command is all lower case, the | |
e7ad2d23 | 1066 | command ignores case while searching for occurrences to |
6bf7aab6 DL |
1067 | replace---provided @code{case-fold-search} is non-@code{nil}. If |
1068 | @code{case-fold-search} is set to @code{nil}, case is always significant | |
1069 | in all searches. | |
1070 | ||
1071 | @vindex case-replace | |
1072 | In addition, when the @var{newstring} argument is all or partly lower | |
1073 | case, replacement commands try to preserve the case pattern of each | |
1074 | occurrence. Thus, the command | |
1075 | ||
1076 | @example | |
1077 | M-x replace-string @key{RET} foo @key{RET} bar @key{RET} | |
1078 | @end example | |
1079 | ||
1080 | @noindent | |
1081 | replaces a lower case @samp{foo} with a lower case @samp{bar}, an | |
1082 | all-caps @samp{FOO} with @samp{BAR}, and a capitalized @samp{Foo} with | |
1083 | @samp{Bar}. (These three alternatives---lower case, all caps, and | |
1084 | capitalized, are the only ones that @code{replace-string} can | |
1085 | distinguish.) | |
1086 | ||
1087 | If upper-case letters are used in the replacement string, they remain | |
1088 | upper case every time that text is inserted. If upper-case letters are | |
1089 | used in the first argument, the second argument is always substituted | |
1090 | exactly as given, with no case conversion. Likewise, if either | |
1091 | @code{case-replace} or @code{case-fold-search} is set to @code{nil}, | |
1092 | replacement is done without case conversion. | |
1093 | ||
1094 | @node Query Replace,, Replacement and Case, Replace | |
1095 | @subsection Query Replace | |
1096 | @cindex query replace | |
1097 | ||
1098 | @table @kbd | |
1099 | @item M-% @var{string} @key{RET} @var{newstring} @key{RET} | |
1100 | @itemx M-x query-replace @key{RET} @var{string} @key{RET} @var{newstring} @key{RET} | |
1101 | Replace some occurrences of @var{string} with @var{newstring}. | |
1102 | @item C-M-% @var{regexp} @key{RET} @var{newstring} @key{RET} | |
1103 | @itemx M-x query-replace-regexp @key{RET} @var{regexp} @key{RET} @var{newstring} @key{RET} | |
1104 | Replace some matches for @var{regexp} with @var{newstring}. | |
1105 | @end table | |
1106 | ||
1107 | @kindex M-% | |
1108 | @findex query-replace | |
1109 | If you want to change only some of the occurrences of @samp{foo} to | |
1110 | @samp{bar}, not all of them, then you cannot use an ordinary | |
1111 | @code{replace-string}. Instead, use @kbd{M-%} (@code{query-replace}). | |
1112 | This command finds occurrences of @samp{foo} one by one, displays each | |
b20a1c88 RS |
1113 | occurrence and asks you whether to replace it. Aside from querying, |
1114 | @code{query-replace} works just like @code{replace-string}. It | |
1115 | preserves case, like @code{replace-string}, provided | |
1116 | @code{case-replace} is non-@code{nil}, as it normally is. A numeric | |
1117 | argument means consider only occurrences that are bounded by | |
1118 | word-delimiter characters. | |
6bf7aab6 DL |
1119 | |
1120 | @kindex C-M-% | |
1121 | @findex query-replace-regexp | |
b20a1c88 | 1122 | @kbd{C-M-%} performs regexp search and replace (@code{query-replace-regexp}). |
8bcc4f6b RS |
1123 | It works like @code{replace-regexp} except that it queries |
1124 | like @code{query-replace}. | |
1125 | ||
1126 | @cindex faces for highlighting query replace | |
1127 | These commands highlight the current match using the face | |
1128 | @code{query-replace}. They highlight other matches using | |
1129 | @code{lazy-highlight} just like incremental search (@pxref{Incremental | |
1130 | Search}). | |
6bf7aab6 | 1131 | |
b20a1c88 RS |
1132 | The characters you can type when you are shown a match for the string |
1133 | or regexp are: | |
6bf7aab6 DL |
1134 | |
1135 | @ignore @c Not worth it. | |
1136 | @kindex SPC @r{(query-replace)} | |
1137 | @kindex DEL @r{(query-replace)} | |
1138 | @kindex , @r{(query-replace)} | |
1139 | @kindex RET @r{(query-replace)} | |
1140 | @kindex . @r{(query-replace)} | |
1141 | @kindex ! @r{(query-replace)} | |
1142 | @kindex ^ @r{(query-replace)} | |
1143 | @kindex C-r @r{(query-replace)} | |
1144 | @kindex C-w @r{(query-replace)} | |
1145 | @kindex C-l @r{(query-replace)} | |
1146 | @end ignore | |
1147 | ||
1148 | @c WideCommands | |
1149 | @table @kbd | |
1150 | @item @key{SPC} | |
1151 | to replace the occurrence with @var{newstring}. | |
1152 | ||
1153 | @item @key{DEL} | |
1154 | to skip to the next occurrence without replacing this one. | |
1155 | ||
1156 | @item , @r{(Comma)} | |
1157 | to replace this occurrence and display the result. You are then asked | |
1158 | for another input character to say what to do next. Since the | |
1159 | replacement has already been made, @key{DEL} and @key{SPC} are | |
1160 | equivalent in this situation; both move to the next occurrence. | |
1161 | ||
1162 | You can type @kbd{C-r} at this point (see below) to alter the replaced | |
1163 | text. You can also type @kbd{C-x u} to undo the replacement; this exits | |
1164 | the @code{query-replace}, so if you want to do further replacement you | |
1165 | must use @kbd{C-x @key{ESC} @key{ESC} @key{RET}} to restart | |
1166 | (@pxref{Repetition}). | |
1167 | ||
1168 | @item @key{RET} | |
1169 | to exit without doing any more replacements. | |
1170 | ||
1171 | @item .@: @r{(Period)} | |
1172 | to replace this occurrence and then exit without searching for more | |
1173 | occurrences. | |
1174 | ||
1175 | @item ! | |
1176 | to replace all remaining occurrences without asking again. | |
1177 | ||
1178 | @item ^ | |
1179 | to go back to the position of the previous occurrence (or what used to | |
a8e3c8d6 DK |
1180 | be an occurrence), in case you changed it by mistake or want to |
1181 | reexamine it. | |
6bf7aab6 DL |
1182 | |
1183 | @item C-r | |
1184 | to enter a recursive editing level, in case the occurrence needs to be | |
1185 | edited rather than just replaced with @var{newstring}. When you are | |
1186 | done, exit the recursive editing level with @kbd{C-M-c} to proceed to | |
1187 | the next occurrence. @xref{Recursive Edit}. | |
1188 | ||
1189 | @item C-w | |
1190 | to delete the occurrence, and then enter a recursive editing level as in | |
1191 | @kbd{C-r}. Use the recursive edit to insert text to replace the deleted | |
1192 | occurrence of @var{string}. When done, exit the recursive editing level | |
1193 | with @kbd{C-M-c} to proceed to the next occurrence. | |
1194 | ||
91cf1909 RS |
1195 | @item e |
1196 | to edit the replacement string in the minibuffer. When you exit the | |
1197 | minibuffer by typing @key{RET}, the minibuffer contents replace the | |
1198 | current occurrence of the pattern. They also become the new | |
1199 | replacement string for any further occurrences. | |
1200 | ||
6bf7aab6 DL |
1201 | @item C-l |
1202 | to redisplay the screen. Then you must type another character to | |
1203 | specify what to do with this occurrence. | |
1204 | ||
1205 | @item C-h | |
1206 | to display a message summarizing these options. Then you must type | |
1207 | another character to specify what to do with this occurrence. | |
1208 | @end table | |
1209 | ||
1210 | Some other characters are aliases for the ones listed above: @kbd{y}, | |
1211 | @kbd{n} and @kbd{q} are equivalent to @key{SPC}, @key{DEL} and | |
1212 | @key{RET}. | |
1213 | ||
1214 | Aside from this, any other character exits the @code{query-replace}, | |
1215 | and is then reread as part of a key sequence. Thus, if you type | |
1216 | @kbd{C-k}, it exits the @code{query-replace} and then kills to end of | |
1217 | line. | |
1218 | ||
1219 | To restart a @code{query-replace} once it is exited, use @kbd{C-x | |
1220 | @key{ESC} @key{ESC}}, which repeats the @code{query-replace} because it | |
1221 | used the minibuffer to read its arguments. @xref{Repetition, C-x ESC | |
1222 | ESC}. | |
1223 | ||
1224 | See also @ref{Transforming File Names}, for Dired commands to rename, | |
1225 | copy, or link files by replacing regexp matches in file names. | |
1226 | ||
f2fd3623 | 1227 | @node Other Repeating Search |
6bf7aab6 DL |
1228 | @section Other Search-and-Loop Commands |
1229 | ||
1230 | Here are some other commands that find matches for a regular | |
91cf1909 RS |
1231 | expression. They all ignore case in matching, if the pattern contains |
1232 | no upper-case letters and @code{case-fold-search} is non-@code{nil}. | |
8cab3b9a CW |
1233 | Aside from @code{occur} and its variants, all operate on the text from |
1234 | point to the end of the buffer, or on the active region in Transient | |
1235 | Mark mode. | |
6bf7aab6 DL |
1236 | |
1237 | @findex list-matching-lines | |
1238 | @findex occur | |
8cab3b9a CW |
1239 | @findex multi-occur |
1240 | @findex multi-occur-by-filename-regexp | |
9c99d206 | 1241 | @findex how-many |
6bf7aab6 DL |
1242 | @findex delete-non-matching-lines |
1243 | @findex delete-matching-lines | |
1244 | @findex flush-lines | |
1245 | @findex keep-lines | |
1246 | ||
1247 | @table @kbd | |
1248 | @item M-x occur @key{RET} @var{regexp} @key{RET} | |
91cf1909 RS |
1249 | Display a list showing each line in the buffer that contains a match |
1250 | for @var{regexp}. To limit the search to part of the buffer, narrow | |
1251 | to that part (@pxref{Narrowing}). A numeric argument @var{n} | |
f8635375 | 1252 | specifies that @var{n} lines of context are to be displayed before and |
c778ed49 LT |
1253 | after each matching line. Currently, @code{occur} can not correctly |
1254 | handle multiline matches. | |
6bf7aab6 DL |
1255 | |
1256 | @kindex RET @r{(Occur mode)} | |
74308f28 RS |
1257 | @kindex o @r{(Occur mode)} |
1258 | @kindex C-o @r{(Occur mode)} | |
6bf7aab6 | 1259 | The buffer @samp{*Occur*} containing the output serves as a menu for |
74308f28 RS |
1260 | finding the occurrences in their original context. Click |
1261 | @kbd{Mouse-2} on an occurrence listed in @samp{*Occur*}, or position | |
1262 | point there and type @key{RET}; this switches to the buffer that was | |
1263 | searched and moves point to the original of the chosen occurrence. | |
1264 | @kbd{o} and @kbd{C-o} display the match in another window; @kbd{C-o} | |
1265 | does not select it. | |
6bf7aab6 | 1266 | |
d4bc156f | 1267 | Occur mode supports the @code{next-error} functionality described in |
c778ed49 | 1268 | @ref{Compilation Mode}. |
d4bc156f | 1269 | |
6bf7aab6 DL |
1270 | @item M-x list-matching-lines |
1271 | Synonym for @kbd{M-x occur}. | |
1272 | ||
8cab3b9a | 1273 | @item M-x multi-occur @key{RET} @var{buffers} @key{RET} @var{regexp} @key{RET} |
db639d24 | 1274 | This function is just like @code{occur}, except it is able to search |
8cab3b9a CW |
1275 | through multiple buffers. |
1276 | ||
1277 | @item M-x multi-occur-by-filename-regexp @key{RET} @var{bufregexp} @key{RET} @var{regexp} @key{RET} | |
db639d24 | 1278 | This function is similar to @code{multi-occur}, except the buffers to |
8cab3b9a CW |
1279 | search are specified by a regexp on their filename. |
1280 | ||
9c99d206 | 1281 | @item M-x how-many @key{RET} @var{regexp} @key{RET} |
91cf1909 RS |
1282 | Print the number of matches for @var{regexp} that exist in the buffer |
1283 | after point. In Transient Mark mode, if the region is active, the | |
1284 | command operates on the region instead. | |
6bf7aab6 DL |
1285 | |
1286 | @item M-x flush-lines @key{RET} @var{regexp} @key{RET} | |
c778ed49 LT |
1287 | This command deletes each line that contains a match for @var{regexp}, |
1288 | operating on the text after point; it deletes the current line | |
1289 | if it contains a match starting after point. In Transient Mark mode, | |
1290 | if the region is active, the command operates on the region instead; | |
1291 | it deletes a line partially contained in the region if it contains a | |
1292 | match entirely contained in the region. | |
1293 | ||
1294 | If a match is split across lines, @code{flush-lines} deletes all those | |
1295 | lines. It deletes the lines before starting to look for the next | |
1296 | match; hence, it ignores a match starting on the same line at which | |
1297 | another match ended. | |
6bf7aab6 DL |
1298 | |
1299 | @item M-x keep-lines @key{RET} @var{regexp} @key{RET} | |
c778ed49 LT |
1300 | This command deletes each line that @emph{does not} contain a match for |
1301 | @var{regexp}, operating on the text after point; if point is not at the | |
1302 | beginning of a line, it always keeps the current line. In Transient | |
1303 | Mark mode, if the region is active, the command operates on the region | |
1304 | instead; it never deletes lines that are only partially contained in | |
1305 | the region (a newline that ends a line counts as part of that line). | |
1306 | ||
1307 | If a match is split across lines, this command keeps all those lines. | |
6bf7aab6 DL |
1308 | @end table |
1309 | ||
91cf1909 | 1310 | You can also search multiple files under control of a tags table |
c778ed49 | 1311 | (@pxref{Tags Search}) or through the Dired @kbd{A} command |
91cf1909 RS |
1312 | (@pxref{Operating on Files}), or ask the @code{grep} program to do it |
1313 | (@pxref{Grep Searching}). | |
ab5796a9 MB |
1314 | |
1315 | @ignore | |
1316 | arch-tag: fd9d8e77-66af-491c-b212-d80999613e3e | |
1317 | @end ignore |