1 @c This is part of the Emacs manual.
2 @c Copyright (C) 1985-1987, 1993-1995, 1997, 2000-2011
3 @c Free Software Foundation, Inc.
4 @c See file emacs.texi for copying conditions.
5 @node Search, Fixit, Display, Top
6 @chapter Searching and Replacement
8 @cindex finding strings within text
10 Like other editors, Emacs has commands to search for occurrences of
11 a string. Emacs also has commands to replace occurrences of a string
12 with a different string. There are also commands that do the same
13 thing, but search for patterns instead of fixed strings.
15 You can also search multiple files under the control of a tags table
16 (@pxref{Tags Search}) or through the Dired @kbd{A} command
17 (@pxref{Operating on Files}), or ask the @code{grep} program to do it
18 (@pxref{Grep Searching}).
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.
27 * Regexp Backslash:: Regular expression constructs starting with `\'.
28 * Regexp Example:: A complex regular expression explained.
29 * Search Case:: To ignore case while searching, or not.
30 * Replace:: Search, and replace some or all matches.
31 * Other Repeating Search:: Operating on all matches for some regexp.
34 @node Incremental Search
35 @section Incremental Search
36 @cindex incremental search
39 The principal search command in Emacs is @dfn{incremental}: it
40 begins searching as soon as you type the first character of the search
41 string. As you type in the search string, Emacs shows you where the
42 string (as you have typed it so far) would be found. When you have
43 typed enough characters to identify the place you want, you can stop.
44 Depending on what you plan to do next, you may or may not need to
45 terminate the search explicitly with @key{RET}.
49 Incremental search forward (@code{isearch-forward}).
51 Incremental search backward (@code{isearch-backward}).
55 * Basic Isearch:: Basic incremental search commands.
56 * Repeat Isearch:: Searching for the same string again.
57 * Error in Isearch:: When your string is not found.
58 * Special Isearch:: Special input in incremental search.
59 * Isearch Yank:: Commands that grab text into the search string
60 or else edit the search string.
61 * Isearch Scroll:: Scrolling during an incremental search.
62 * Isearch Minibuffer:: Incremental search of the minibuffer history.
63 * Slow Isearch:: Incremental search features for slow terminals.
67 @subsection Basics of Incremental Search
71 Begin incremental search (@code{isearch-forward}).
73 Begin reverse incremental search (@code{isearch-backward}).
77 @findex isearch-forward
78 @kbd{C-s} (@code{isearch-forward}) starts a forward incremental
79 search. It reads characters from the keyboard, and moves point just
80 past the end of the next occurrence of those characters in the buffer.
82 For instance, if you type @kbd{C-s} and then @kbd{F}, that puts the
83 cursor after the first @samp{F} that occurs in the buffer after the
84 starting point. Then if you then type @kbd{O}, the cursor moves to
85 just after the first @samp{FO}; the @samp{F} in that @samp{FO} might
86 not be the first @samp{F} previously found. After another @kbd{O},
87 the cursor moves to just after the first @samp{FOO}.
89 @cindex faces for highlighting search matches
90 At each step, Emacs highlights the @dfn{current match}---the buffer
91 text that matches the search string---using the @code{isearch} face
92 (@pxref{Faces}). The current search string is also displayed in the
95 If you make a mistake typing the search string, type @key{DEL}.
96 Each @key{DEL} cancels the last character of the search string.
98 When you are satisfied with the place you have reached, type
99 @key{RET}. This stops searching, leaving the cursor where the search
100 brought it. Also, any command not specially meaningful in searches
101 stops the searching and is then executed. Thus, typing @kbd{C-a}
102 exits the search and then moves to the beginning of the line.
103 @key{RET} is necessary only if the next command you want to type is a
104 printing character, @key{DEL}, @key{RET}, or another character that is
105 special within searches (@kbd{C-q}, @kbd{C-w}, @kbd{C-r}, @kbd{C-s},
106 @kbd{C-y}, @kbd{M-y}, @kbd{M-r}, @kbd{M-c}, @kbd{M-e}, and some others
109 As a special exception, entering @key{RET} when the search string is
110 empty launches nonincremental search (@pxref{Nonincremental Search}).
112 When you exit the incremental search, it adds the original value of
113 point to the mark ring, without activating the mark; you can thus use
114 @kbd{C-u C-@key{SPC}} to return to where you were before beginning the
115 search. @xref{Mark Ring}. It only does this if the mark was not
119 @findex isearch-backward
120 To search backwards, use @kbd{C-r} (@code{isearch-backward}) instead
121 of @kbd{C-s} to start the search. A backward search finds matches
122 that end before the starting point, just as a forward search finds
123 matches that begin after it.
126 @subsection Repeating Incremental Search
128 Suppose you search forward for @samp{FOO} and find a match, but not
129 the one you expected to find: the @samp{FOO} you were aiming for
130 occurs later in the buffer. In this event, type another @kbd{C-s} to
131 move to the next occurrence of the search string. You can repeat this
132 any number of times. If you overshoot, you can cancel some @kbd{C-s}
133 characters with @key{DEL}. Similarly, each @kbd{C-r} in a backward
134 incremental search repeats the backward search.
136 @cindex lazy search highlighting
137 @vindex isearch-lazy-highlight
138 If you pause for a little while during incremental search, Emacs
139 highlights all the other possible matches for the search string that
140 are present on the screen. This helps you anticipate where you can
141 get to by typing @kbd{C-s} or @kbd{C-r} to repeat the search. The
142 other matches are highlighted differently from the current match,
143 using the customizable face @code{lazy-highlight} (@pxref{Faces}). If
144 you don't like this feature, you can disable it by setting
145 @code{isearch-lazy-highlight} to @code{nil}.
147 After exiting a search, you can search for the same string again by
148 typing just @kbd{C-s C-s}. The first @kbd{C-s} is the key that
149 invokes incremental search, and the second @kbd{C-s} means ``search
150 again.'' Similarly, @kbd{C-r C-r} searches backward for the last
151 search string. In determining the last search string, it doesn't
152 matter whether the string was searched for with @kbd{C-s} or
155 If you are searching forward but you realize you were looking for
156 something before the starting point, type @kbd{C-r} to switch to a
157 backward search, leaving the search string unchanged. Similarly,
158 @kbd{C-s} in a backward search switches to a forward search.
160 If a search is failing and you ask to repeat it by typing another
161 @kbd{C-s}, it starts again from the beginning of the buffer.
162 Repeating a failing reverse search with @kbd{C-r} starts again from
163 the end. This is called @dfn{wrapping around}, and @samp{Wrapped}
164 appears in the search prompt once this has happened. If you keep on
165 going past the original starting point of the search, it changes to
166 @samp{Overwrapped}, which means that you are revisiting matches that
167 you have already seen.
170 To reuse earlier search strings, use the @dfn{search ring}. The
171 commands @kbd{M-p} and @kbd{M-n} move through the ring to pick a
172 search string to reuse. These commands leave the selected search ring
173 element in the minibuffer, where you can edit it. To edit the current
174 search string in the minibuffer without replacing it with items from
175 the search ring, type @kbd{M-e}. Type @kbd{C-s} or @kbd{C-r} to
176 terminate editing the string and search for it.
178 @node Error in Isearch
179 @subsection Errors in Incremental Search
181 If your string is not found at all, the echo area says @samp{Failing
182 I-Search}. The cursor is after the place where Emacs found as much of
183 your string as it could. Thus, if you search for @samp{FOOT}, and
184 there is no @samp{FOOT}, you might see the cursor after the @samp{FOO}
185 in @samp{FOOL}. In the echo area, the part of the search string that
186 failed to match is highlighted using the customizable face
189 At this point, there are several things you can do. If your string
190 was mistyped, you can use @key{DEL} to erase some of it and correct
191 it. If you like the place you have found, you can type @key{RET} to
192 remain there. Or you can type @kbd{C-g}, which removes from the
193 search string the characters that could not be found (the @samp{T} in
194 @samp{FOOT}), leaving those that were found (the @samp{FOO} in
195 @samp{FOOT}). A second @kbd{C-g} at that point cancels the search
196 entirely, returning point to where it was when the search started.
198 @cindex quitting (in search)
199 The quit command, @kbd{C-g}, does special things during searches;
200 just what it does depends on the status of the search. If the search
201 has found what you specified and is waiting for input, @kbd{C-g}
202 cancels the entire search, moving the cursor back to where you started
203 the search. If @kbd{C-g} is typed when there are characters in the
204 search string that have not been found---because Emacs is still
205 searching for them, or because it has failed to find them---then the
206 search string characters which have not been found are discarded from
207 the search string. With them gone, the search is now successful and
208 waiting for more input, so a second @kbd{C-g} will cancel the entire
211 @node Special Isearch
212 @subsection Special Input for Incremental Search
214 Some of the characters you type during incremental search have
217 If the search string you entered contains only lower-case letters,
218 the search is case-insensitive; as long as an upper-case letter exists
219 in the search string, the search becomes case-sensitive. If you
220 delete the upper-case character from the search string, it ceases to
221 have this effect. @xref{Search Case}.
223 To search for a newline character, type @kbd{C-j}.
225 To search for other control characters, such as @key{control-S},
226 quote it by typing @kbd{C-q} first (@pxref{Inserting Text}). To
227 search for non-@acronym{ASCII} characters, you can either use
228 @kbd{C-q} and enter its octal code, or use an input method
229 (@pxref{Input Methods}). If an input method is enabled in the current
230 buffer when you start the search, you can use it in the search string
231 also. While typing the search string, you can toggle the input method
232 with the command @kbd{C-\} (@code{isearch-toggle-input-method}). You
233 can also turn on a non-default input method with @kbd{C-^}
234 (@code{isearch-toggle-specified-input-method}), which prompts for the
235 name of the input method. When an input method is active during
236 incremental search, the search prompt includes the input method
244 @findex isearch-toggle-input-method
245 @findex isearch-toggle-specified-input-method
246 where @var{im} is the mnemonic of the active input method. Any input
247 method you enable during incremental search remains enabled in the
248 current buffer afterwards.
250 @kindex M-% @r{(Incremental search)}
251 Typing @kbd{M-%} in incremental search invokes @code{query-replace}
252 or @code{query-replace-regexp} (depending on search mode) with the
253 current search string used as the string to replace. @xref{Query
256 @kindex M-TAB @r{(Incremental search)}
257 Typing @kbd{M-@key{TAB}} in incremental search invokes
258 @code{isearch-complete}, which attempts to complete the search string
259 using the search ring as a list of completion alternatives.
260 @xref{Completion}. In many operating systems, the @kbd{M-@key{TAB}}
261 key sequence is captured by the window manager; you then need to
262 rebind @code{isearch-complete} to another key sequence if you want to
263 use it (@pxref{Rebinding}).
265 @vindex isearch-mode-map
266 When incremental search is active, you can type @kbd{C-h C-h} to
267 access interactive help options, including a list of special
268 keybindings. These keybindings are part of the keymap
269 @code{isearch-mode-map} (@pxref{Keymaps}).
272 @subsection Isearch Yanking
274 Within incremental search, you can use @kbd{C-w} and @kbd{C-y} to grab
275 text from the buffer into the search string. This makes it convenient
276 to search for another occurrence of text at point.
278 @kbd{C-w} copies the character or word after point and adds it to
279 the search string, advancing point over it. (The decision, whether to
280 copy a character or a word, is heuristic.)
282 @kbd{C-y} is similar to @kbd{C-w} but copies all the rest of the
283 current line into the search string. If point is already at the end
284 of a line, it grabs the entire next line. If the search is currently
285 case-insensitive, both @kbd{C-y} and @kbd{C-w} convert the text they
286 copy to lower case, so that the search remains case-insensitive.
288 @kbd{C-M-w} and @kbd{C-M-y} modify the search string by only one
289 character at a time: @kbd{C-M-w} deletes the last character from the
290 search string and @kbd{C-M-y} copies the character after point to the
291 end of the search string. An alternative method to add the character
292 after point into the search string is to enter the minibuffer by
293 @kbd{M-e} and to type @kbd{C-f} at the end of the search string in the
296 The character @kbd{M-y} copies text from the kill ring into the
297 search string. It uses the same text that @kbd{C-y} would yank.
298 @kbd{Mouse-2} in the echo area does the same. @xref{Yanking}.
301 @subsection Scrolling During Incremental Search
303 @vindex isearch-allow-scroll
304 You can enable the use of vertical scrolling during incremental
305 search (without exiting the search) by setting the customizable
306 variable @code{isearch-allow-scroll} to a non-@code{nil} value. This
307 applies to using the vertical scroll-bar and to certain keyboard
308 commands such as @key{prior} (@code{scroll-down}), @key{next}
309 (@code{scroll-up}) and @kbd{C-l} (@code{recenter}). You must run
310 these commands via their key sequences to stay in the search---typing
311 @kbd{M-x} will terminate the search. You can give prefix arguments to
312 these commands in the usual way.
314 This feature won't let you scroll the current match out of visibility,
317 The feature also affects some other commands, such as @kbd{C-x 2}
318 (@code{split-window-vertically}) and @kbd{C-x ^}
319 (@code{enlarge-window}) which don't exactly scroll but do affect where
320 the text appears on the screen. In general, it applies to any command
321 whose name has a non-@code{nil} @code{isearch-scroll} property. So you
322 can control which commands are affected by changing these properties.
324 For example, to make @kbd{C-h l} usable within an incremental search
325 in all future Emacs sessions, use @kbd{C-h c} to find what command it
326 runs. (You type @kbd{C-h c C-h l}; it says @code{view-lossage}.)
327 Then you can put the following line in your @file{.emacs} file
331 (put 'view-lossage 'isearch-scroll t)
335 This feature can be applied to any command that doesn't permanently
336 change point, the buffer contents, the match data, the current buffer,
337 or the selected window and frame. The command must not itself attempt
338 an incremental search.
340 @node Isearch Minibuffer
341 @subsection Searching the Minibuffer
342 @cindex minibuffer history, searching
344 If you start an incremental search while the minibuffer is active,
345 Emacs searches the contents of the minibuffer. Unlike searching an
346 ordinary buffer, the search string is not shown in the echo area,
347 because that is used to display the minibuffer.
349 If an incremental search fails in the minibuffer, it tries searching
350 the minibuffer history. @xref{Minibuffer History}. You can visualize
351 the minibuffer and its history as a series of ``pages'', with the
352 earliest history element on the first page and the current minibuffer
353 on the last page. A forward search, @kbd{C-s}, searches forward to
354 later pages; a reverse search, @kbd{C-r}, searches backwards to
355 earlier pages. Like in ordinary buffer search, a failing search can
356 wrap around, going from the last page to the first page or vice versa.
358 When the current match is on a history element, that history element
359 is pulled into the minibuffer. If you exit the incremental search
360 normally (e.g. by typing @key{RET}), it remains in the minibuffer
361 afterwards. Cancelling the search, with @kbd{C-g}, restores the
362 contents of the minibuffer when you began the search.
365 @subsection Slow Terminal Incremental Search
367 Incremental search on a slow terminal uses a modified style of display
368 that is designed to take less time. Instead of redisplaying the buffer at
369 each place the search gets to, it creates a new single-line window and uses
370 that to display the line that the search has found. The single-line window
371 comes into play as soon as point moves outside of the text that is already
374 When you terminate the search, the single-line window is removed.
375 Emacs then redisplays the window in which the search was done, to show
376 its new position of point.
378 @vindex search-slow-speed
379 The slow terminal style of display is used when the terminal baud rate is
380 less than or equal to the value of the variable @code{search-slow-speed},
381 initially 1200. See also the discussion of the variable @code{baud-rate}
382 (@pxref{baud-rate,, Customization of Display}).
384 @vindex search-slow-window-lines
385 The number of lines to use in slow terminal search display is controlled
386 by the variable @code{search-slow-window-lines}. Its normal value is 1.
388 @node Nonincremental Search
389 @section Nonincremental Search
390 @cindex nonincremental search
392 Emacs also has conventional nonincremental search commands, which require
393 you to type the entire search string before searching begins.
396 @item C-s @key{RET} @var{string} @key{RET}
397 Search for @var{string}.
398 @item C-r @key{RET} @var{string} @key{RET}
399 Search backward for @var{string}.
402 To start a nonincremental search, first type @kbd{C-s @key{RET}}.
403 This enters the minibuffer to read the search string; terminate the
404 string with @key{RET}, and then the search takes place. If the string
405 is not found, the search command signals an error.
407 When you type @kbd{C-s @key{RET}}, the @kbd{C-s} invokes incremental
408 search as usual. That command is specially programmed to invoke
409 nonincremental search, @code{search-forward}, if the string you
410 specify is empty. (Such an empty argument would otherwise be
411 useless.) @kbd{C-r @key{RET}} does likewise, for a reverse
414 @findex search-forward
415 @findex search-backward
416 Forward and backward nonincremental searches are implemented by the
417 commands @code{search-forward} and @code{search-backward}. These
418 commands may be bound to other keys in the usual manner.
424 A @dfn{word search} finds a sequence of words without regard to the
425 type of punctuation between them. For instance, if you enter a search
426 string that consists of two words separated by a single space, the
427 search matches any sequence of those two words separated by one or
428 more spaces, newlines, or other punctuation characters. This is
429 particularly useful for searching text documents, because you don't
430 have to worry whether the words you are looking for are separated by
435 If incremental search is active, toggle word search mode
436 (@code{isearch-toggle-word}); otherwise, begin an incremental forward
437 word search (@code{isearch-forward-word}).
438 @item M-s w @key{RET} @var{words} @key{RET}
439 Search for @var{words}, using a forward nonincremental word search.
440 @item M-s w C-r @key{RET} @var{words} @key{RET}
441 Search backward for @var{words}, using a nonincremental word search.
445 @findex isearch-forward-word
446 To begin a forward incremental word search, type @kbd{M-s w}. If
447 incremental search is not already active, this runs the command
448 @code{isearch-forward-word}. If incremental search is already active
449 (whether a forward or backward search), @kbd{M-s w} switches to a word
450 search while keeping the direction of the search and the current
451 search string unchanged. You can toggle word search back off by
452 typing @kbd{M-s w} again.
454 @findex word-search-forward
455 @findex word-search-backward
456 To begin a nonincremental word search, type @kbd{M-s w @key{RET}}
457 for a forward search, or @kbd{M-s w C-r @key{RET}} for a backward search.
458 These run the commands @code{word-search-forward} and
459 @code{word-search-backward} respectively.
461 Incremental and nonincremental word searches differ slightly in the
462 way they find a match. In a nonincremental word search, the last word
463 in the search string must exactly match a whole word. In an
464 incremental word search, the matching is more lax: the last word in
465 the search string can match part of a word, so that the matching
466 proceeds incrementally as you type. This additional laxity does not
467 apply to the lazy highlight, which always matches whole words.
470 @section Regular Expression Search
471 @cindex regexp search
472 @cindex search for a regular expression
474 A @dfn{regular expression} (or @dfn{regexp} for short) is a pattern
475 that denotes a class of alternative strings to match. GNU Emacs
476 provides both incremental and nonincremental ways to search for a
477 match for a regexp. The syntax of regular expressions is explained in
478 the following section.
482 Begin incremental regexp search (@code{isearch-forward-regexp}).
484 Begin reverse incremental regexp search (@code{isearch-backward-regexp}).
488 @findex isearch-forward-regexp
490 @findex isearch-backward-regexp
491 Incremental search for a regexp is done by typing @kbd{C-M-s}
492 (@code{isearch-forward-regexp}), by invoking @kbd{C-s} with a
493 prefix argument (whose value does not matter), or by typing @kbd{M-r}
494 within a forward incremental search. This command reads a
495 search string incrementally just like @kbd{C-s}, but it treats the
496 search string as a regexp rather than looking for an exact match
497 against the text in the buffer. Each time you add text to the search
498 string, you make the regexp longer, and the new regexp is searched
499 for. To search backward for a regexp, use @kbd{C-M-r}
500 (@code{isearch-backward-regexp}), @kbd{C-r} with a prefix argument,
501 or @kbd{M-r} within a backward incremental search.
503 All of the special key sequences in an ordinary incremental search
504 do similar things in an incremental regexp search. For instance,
505 typing @kbd{C-s} immediately after starting the search retrieves the
506 last incremental search regexp used and searches forward for it.
507 Incremental regexp and non-regexp searches have independent defaults.
508 They also have separate search rings, which you can access with
509 @kbd{M-p} and @kbd{M-n}.
511 @vindex search-whitespace-regexp
512 If you type @key{SPC} in incremental regexp search, it matches any
513 sequence of whitespace characters, including newlines. If you want to
514 match just a space, type @kbd{C-q @key{SPC}}. You can control what a
515 bare space matches by setting the variable
516 @code{search-whitespace-regexp} to the desired regexp.
518 In some cases, adding characters to the regexp in an incremental
519 regexp search can make the cursor move back and start again. For
520 example, if you have searched for @samp{foo} and you add @samp{\|bar},
521 the cursor backs up in case the first @samp{bar} precedes the first
522 @samp{foo}. @xref{Regexps}.
524 Forward and backward regexp search are not symmetrical, because
525 regexp matching in Emacs always operates forward, starting with the
526 beginning of the regexp. Thus, forward regexp search scans forward,
527 trying a forward match at each possible starting position. Backward
528 regexp search scans backward, trying a forward match at each possible
529 starting position. These search methods are not mirror images.
531 @findex re-search-forward
532 @findex re-search-backward
533 Nonincremental search for a regexp is done by the functions
534 @code{re-search-forward} and @code{re-search-backward}. You can
535 invoke these with @kbd{M-x}, or by way of incremental regexp search
536 with @kbd{C-M-s @key{RET}} and @kbd{C-M-r @key{RET}}.
538 If you use the incremental regexp search commands with a prefix
539 argument, they perform ordinary string search, like
540 @code{isearch-forward} and @code{isearch-backward}. @xref{Incremental
544 @section Syntax of Regular Expressions
545 @cindex syntax of regexps
546 @cindex regular expression
549 This manual describes regular expression features that users
550 typically use. @xref{Regular Expressions,,, elisp, The Emacs Lisp
551 Reference Manual}, for additional features used mainly in Lisp
554 Regular expressions have a syntax in which a few characters are
555 special constructs and the rest are @dfn{ordinary}. An ordinary
556 character matches that same character and nothing else. The special
557 characters are @samp{$^.*+?[\}. The character @samp{]} is special if
558 it ends a character alternative (see later). The character @samp{-}
559 is special inside a character alternative. Any other character
560 appearing in a regular expression is ordinary, unless a @samp{\}
561 precedes it. (When you use regular expressions in a Lisp program,
562 each @samp{\} must be doubled, see the example near the end of this
565 For example, @samp{f} is not a special character, so it is ordinary, and
566 therefore @samp{f} is a regular expression that matches the string
567 @samp{f} and no other string. (It does @emph{not} match the string
568 @samp{ff}.) Likewise, @samp{o} is a regular expression that matches
569 only @samp{o}. (When case distinctions are being ignored, these regexps
570 also match @samp{F} and @samp{O}, but we consider this a generalization
571 of ``the same string,'' rather than an exception.)
573 Any two regular expressions @var{a} and @var{b} can be concatenated.
574 The result is a regular expression which matches a string if @var{a}
575 matches some amount of the beginning of that string and @var{b}
576 matches the rest of the string. For example, concatenating the
577 regular expressions @samp{f} and @samp{o} gives the regular expression
578 @samp{fo}, which matches only the string @samp{fo}. Still trivial.
579 To do something nontrivial, you need to use one of the special
580 characters. Here is a list of them.
583 @item @kbd{.}@: @r{(Period)}
584 is a special character that matches any single character except a
585 newline. For example, the regular expressions @samp{a.b} matches any
586 three-character string that begins with @samp{a} and ends with
590 is not a construct by itself; it is a postfix operator that means to
591 match the preceding regular expression repetitively any number of
592 times, as many times as possible. Thus, @samp{o*} matches any number
593 of @samp{o}s, including no @samp{o}s.
595 @samp{*} always applies to the @emph{smallest} possible preceding
596 expression. Thus, @samp{fo*} has a repeating @samp{o}, not a repeating
597 @samp{fo}. It matches @samp{f}, @samp{fo}, @samp{foo}, and so on.
599 The matcher processes a @samp{*} construct by matching, immediately,
600 as many repetitions as can be found. Then it continues with the rest
601 of the pattern. If that fails, backtracking occurs, discarding some
602 of the matches of the @samp{*}-modified construct in case that makes
603 it possible to match the rest of the pattern. For example, in matching
604 @samp{ca*ar} against the string @samp{caaar}, the @samp{a*} first
605 tries to match all three @samp{a}s; but the rest of the pattern is
606 @samp{ar} and there is only @samp{r} left to match, so this try fails.
607 The next alternative is for @samp{a*} to match only two @samp{a}s.
608 With this choice, the rest of the regexp matches successfully.@refill
611 is a postfix operator, similar to @samp{*} except that it must match
612 the preceding expression at least once. Thus, @samp{ca+r} matches the
613 strings @samp{car} and @samp{caaaar} but not the string @samp{cr},
614 whereas @samp{ca*r} matches all three strings.
617 is a postfix operator, similar to @samp{*} except that it can match
618 the preceding expression either once or not at all. Thus, @samp{ca?r}
619 matches @samp{car} or @samp{cr}, and nothing else.
621 @item @kbd{*?}, @kbd{+?}, @kbd{??}
622 @cindex non-greedy regexp matching
623 are non-@dfn{greedy} variants of the operators above. The normal
624 operators @samp{*}, @samp{+}, @samp{?} match as much as they can, as
625 long as the overall regexp can still match. With a following
626 @samp{?}, they will match as little as possible.
628 Thus, both @samp{ab*} and @samp{ab*?} can match the string @samp{a}
629 and the string @samp{abbbb}; but if you try to match them both against
630 the text @samp{abbb}, @samp{ab*} will match it all (the longest valid
631 match), while @samp{ab*?} will match just @samp{a} (the shortest
634 Non-greedy operators match the shortest possible string starting at a
635 given starting point; in a forward search, though, the earliest
636 possible starting point for match is always the one chosen. Thus, if
637 you search for @samp{a.*?$} against the text @samp{abbab} followed by
638 a newline, it matches the whole string. Since it @emph{can} match
639 starting at the first @samp{a}, it does.
641 @item @kbd{\@{@var{n}\@}}
642 is a postfix operator specifying @var{n} repetitions---that is, the
643 preceding regular expression must match exactly @var{n} times in a
644 row. For example, @samp{x\@{4\@}} matches the string @samp{xxxx} and
647 @item @kbd{\@{@var{n},@var{m}\@}}
648 is a postfix operator specifying between @var{n} and @var{m}
649 repetitions---that is, the preceding regular expression must match at
650 least @var{n} times, but no more than @var{m} times. If @var{m} is
651 omitted, then there is no upper limit, but the preceding regular
652 expression must match at least @var{n} times.@* @samp{\@{0,1\@}} is
653 equivalent to @samp{?}. @* @samp{\@{0,\@}} is equivalent to
654 @samp{*}. @* @samp{\@{1,\@}} is equivalent to @samp{+}.
656 @item @kbd{[ @dots{} ]}
657 is a @dfn{character set}, beginning with @samp{[} and terminated by
660 In the simplest case, the characters between the two brackets are what
661 this set can match. Thus, @samp{[ad]} matches either one @samp{a} or
662 one @samp{d}, and @samp{[ad]*} matches any string composed of just
663 @samp{a}s and @samp{d}s (including the empty string). It follows that
664 @samp{c[ad]*r} matches @samp{cr}, @samp{car}, @samp{cdr},
667 You can also include character ranges in a character set, by writing the
668 starting and ending characters with a @samp{-} between them. Thus,
669 @samp{[a-z]} matches any lower-case @acronym{ASCII} letter. Ranges may be
670 intermixed freely with individual characters, as in @samp{[a-z$%.]},
671 which matches any lower-case @acronym{ASCII} letter or @samp{$}, @samp{%} or
674 You can also include certain special @dfn{character classes} in a
675 character set. A @samp{[:} and balancing @samp{:]} enclose a
676 character class inside a character alternative. For instance,
677 @samp{[[:alnum:]]} matches any letter or digit. @xref{Char Classes,,,
678 elisp, The Emacs Lisp Reference Manual}, for a list of character
681 To include a @samp{]} in a character set, you must make it the first
682 character. For example, @samp{[]a]} matches @samp{]} or @samp{a}. To
683 include a @samp{-}, write @samp{-} as the first or last character of the
684 set, or put it after a range. Thus, @samp{[]-]} matches both @samp{]}
687 To include @samp{^} in a set, put it anywhere but at the beginning of
688 the set. (At the beginning, it complements the set---see below.)
690 When you use a range in case-insensitive search, you should write both
691 ends of the range in upper case, or both in lower case, or both should
692 be non-letters. The behavior of a mixed-case range such as @samp{A-z}
693 is somewhat ill-defined, and it may change in future Emacs versions.
695 @item @kbd{[^ @dots{} ]}
696 @samp{[^} begins a @dfn{complemented character set}, which matches any
697 character except the ones specified. Thus, @samp{[^a-z0-9A-Z]} matches
698 all characters @emph{except} @acronym{ASCII} letters and digits.
700 @samp{^} is not special in a character set unless it is the first
701 character. The character following the @samp{^} is treated as if it
702 were first (in other words, @samp{-} and @samp{]} are not special there).
704 A complemented character set can match a newline, unless newline is
705 mentioned as one of the characters not to match. This is in contrast to
706 the handling of regexps in programs such as @code{grep}.
709 is a special character that matches the empty string, but only at the
710 beginning of a line in the text being matched. Otherwise it fails to
711 match anything. Thus, @samp{^foo} matches a @samp{foo} that occurs at
712 the beginning of a line.
714 For historical compatibility reasons, @samp{^} can be used with this
715 meaning only at the beginning of the regular expression, or after
716 @samp{\(} or @samp{\|}.
719 is similar to @samp{^} but matches only at the end of a line. Thus,
720 @samp{x+$} matches a string of one @samp{x} or more at the end of a line.
722 For historical compatibility reasons, @samp{$} can be used with this
723 meaning only at the end of the regular expression, or before @samp{\)}
727 has two functions: it quotes the special characters (including
728 @samp{\}), and it introduces additional special constructs.
730 Because @samp{\} quotes special characters, @samp{\$} is a regular
731 expression that matches only @samp{$}, and @samp{\[} is a regular
732 expression that matches only @samp{[}, and so on.
734 See the following section for the special constructs that begin
738 Note: for historical compatibility, special characters are treated as
739 ordinary ones if they are in contexts where their special meanings make no
740 sense. For example, @samp{*foo} treats @samp{*} as ordinary since there is
741 no preceding expression on which the @samp{*} can act. It is poor practice
742 to depend on this behavior; it is better to quote the special character anyway,
743 regardless of where it appears.
745 As a @samp{\} is not special inside a character alternative, it can
746 never remove the special meaning of @samp{-} or @samp{]}. So you
747 should not quote these characters when they have no special meaning
748 either. This would not clarify anything, since backslashes can
749 legitimately precede these characters where they @emph{have} special
750 meaning, as in @samp{[^\]} (@code{"[^\\]"} for Lisp string syntax),
751 which matches any single character except a backslash.
753 @node Regexp Backslash
754 @section Backslash in Regular Expressions
756 For the most part, @samp{\} followed by any character matches only
757 that character. However, there are several exceptions: two-character
758 sequences starting with @samp{\} that have special meanings. The
759 second character in the sequence is always an ordinary character when
760 used on its own. Here is a table of @samp{\} constructs.
764 specifies an alternative. Two regular expressions @var{a} and @var{b}
765 with @samp{\|} in between form an expression that matches some text if
766 either @var{a} matches it or @var{b} matches it. It works by trying to
767 match @var{a}, and if that fails, by trying to match @var{b}.
769 Thus, @samp{foo\|bar} matches either @samp{foo} or @samp{bar}
770 but no other string.@refill
772 @samp{\|} applies to the largest possible surrounding expressions. Only a
773 surrounding @samp{\( @dots{} \)} grouping can limit the grouping power of
776 Full backtracking capability exists to handle multiple uses of @samp{\|}.
779 is a grouping construct that serves three purposes:
783 To enclose a set of @samp{\|} alternatives for other operations.
784 Thus, @samp{\(foo\|bar\)x} matches either @samp{foox} or @samp{barx}.
787 To enclose a complicated expression for the postfix operators @samp{*},
788 @samp{+} and @samp{?} to operate on. Thus, @samp{ba\(na\)*} matches
789 @samp{bananana}, etc., with any (zero or more) number of @samp{na}
793 To record a matched substring for future reference.
796 This last application is not a consequence of the idea of a
797 parenthetical grouping; it is a separate feature that is assigned as a
798 second meaning to the same @samp{\( @dots{} \)} construct. In practice
799 there is usually no conflict between the two meanings; when there is
800 a conflict, you can use a ``shy'' group.
802 @item \(?: @dots{} \)
803 @cindex shy group, in regexp
804 specifies a ``shy'' group that does not record the matched substring;
805 you can't refer back to it with @samp{\@var{d}}. This is useful
806 in mechanically combining regular expressions, so that you
807 can add groups for syntactic purposes without interfering with
808 the numbering of the groups that are meant to be referred to.
811 @cindex back reference, in regexp
812 matches the same text that matched the @var{d}th occurrence of a
813 @samp{\( @dots{} \)} construct. This is called a @dfn{back
816 After the end of a @samp{\( @dots{} \)} construct, the matcher remembers
817 the beginning and end of the text matched by that construct. Then,
818 later on in the regular expression, you can use @samp{\} followed by the
819 digit @var{d} to mean ``match the same text matched the @var{d}th time
820 by the @samp{\( @dots{} \)} construct.''
822 The strings matching the first nine @samp{\( @dots{} \)} constructs
823 appearing in a regular expression are assigned numbers 1 through 9 in
824 the order that the open-parentheses appear in the regular expression.
825 So you can use @samp{\1} through @samp{\9} to refer to the text matched
826 by the corresponding @samp{\( @dots{} \)} constructs.
828 For example, @samp{\(.*\)\1} matches any newline-free string that is
829 composed of two identical halves. The @samp{\(.*\)} matches the first
830 half, which may be anything, but the @samp{\1} that follows must match
833 If a particular @samp{\( @dots{} \)} construct matches more than once
834 (which can easily happen if it is followed by @samp{*}), only the last
838 matches the empty string, but only at the beginning of the string or
839 buffer (or its accessible portion) being matched against.
842 matches the empty string, but only at the end of the string or buffer
843 (or its accessible portion) being matched against.
846 matches the empty string, but only at point.
849 matches the empty string, but only at the beginning or
850 end of a word. Thus, @samp{\bfoo\b} matches any occurrence of
851 @samp{foo} as a separate word. @samp{\bballs?\b} matches
852 @samp{ball} or @samp{balls} as a separate word.@refill
854 @samp{\b} matches at the beginning or end of the buffer
855 regardless of what text appears next to it.
858 matches the empty string, but @emph{not} at the beginning or
862 matches the empty string, but only at the beginning of a word.
863 @samp{\<} matches at the beginning of the buffer only if a
864 word-constituent character follows.
867 matches the empty string, but only at the end of a word. @samp{\>}
868 matches at the end of the buffer only if the contents end with a
869 word-constituent character.
872 matches any word-constituent character. The syntax table
873 determines which characters these are. @xref{Syntax}.
876 matches any character that is not a word-constituent.
879 matches the empty string, but only at the beginning of a symbol.
880 A symbol is a sequence of one or more symbol-constituent characters.
881 A symbol-constituent character is a character whose syntax is either
882 @samp{w} or @samp{_}. @samp{\_<} matches at the beginning of the
883 buffer only if a symbol-constituent character follows.
886 matches the empty string, but only at the end of a symbol. @samp{\_>}
887 matches at the end of the buffer only if the contents end with a
888 symbol-constituent character.
891 matches any character whose syntax is @var{c}. Here @var{c} is a
892 character that designates a particular syntax class: thus, @samp{w}
893 for word constituent, @samp{-} or @samp{ } for whitespace, @samp{.}
894 for ordinary punctuation, etc. @xref{Syntax}.
897 matches any character whose syntax is not @var{c}.
899 @cindex categories of characters
900 @cindex characters which belong to a specific language
901 @findex describe-categories
903 matches any character that belongs to the category @var{c}. For
904 example, @samp{\cc} matches Chinese characters, @samp{\cg} matches
905 Greek characters, etc. For the description of the known categories,
906 type @kbd{M-x describe-categories @key{RET}}.
909 matches any character that does @emph{not} belong to category
913 The constructs that pertain to words and syntax are controlled by the
914 setting of the syntax table (@pxref{Syntax}).
917 @section Regular Expression Example
919 Here is an example of a regexp---the regexp that Emacs uses, by
920 default, to recognize the end of a sentence, not including the
921 following space (i.e., the variable @code{sentence-end-base}):
930 This contains two parts in succession: a character set matching
931 period, @samp{?}, or @samp{!}, and a character set matching
932 close-brackets, quotes, or parentheses, repeated zero or more times.
935 @section Searching and Case
937 Searches in Emacs normally ignore the case of the text they are
938 searching through, if you specify the text in lower case. Thus, if
939 you specify searching for @samp{foo}, then @samp{Foo} and @samp{foo}
940 are also considered a match. Regexps, and in particular character
941 sets, are included: @samp{[ab]} would match @samp{a} or @samp{A} or
942 @samp{b} or @samp{B}.@refill
944 An upper-case letter anywhere in the incremental search string makes
945 the search case-sensitive. Thus, searching for @samp{Foo} does not find
946 @samp{foo} or @samp{FOO}. This applies to regular expression search as
947 well as to string search. The effect ceases if you delete the
948 upper-case letter from the search string.
950 Typing @kbd{M-c} within an incremental search toggles the case
951 sensitivity of that search. The effect does not extend beyond the
952 current incremental search to the next one, but it does override the
953 effect of adding or removing an upper-case letter in the current
956 @vindex case-fold-search
957 If you set the variable @code{case-fold-search} to @code{nil}, then
958 all letters must match exactly, including case. This is a per-buffer
959 variable; altering the variable normally affects only the current buffer,
960 unless you change its default value. @xref{Locals}.
961 This variable applies to nonincremental searches also, including those
962 performed by the replace commands (@pxref{Replace}) and the minibuffer
963 history matching commands (@pxref{Minibuffer History}).
965 Several related variables control case-sensitivity of searching and
966 matching for specific commands or activities. For instance,
967 @code{tags-case-fold-search} controls case sensitivity for
968 @code{find-tag}. To find these variables, do @kbd{M-x
969 apropos-variable @key{RET} case-fold-search @key{RET}}.
972 @section Replacement Commands
974 @cindex search-and-replace commands
975 @cindex string substitution
976 @cindex global substitution
978 Emacs provides several commands for performing search-and-replace
979 operations. In addition to the simple @kbd{M-x replace-string}
980 command, there is @kbd{M-%} (@code{query-replace}), which presents
981 each occurrence of the pattern and asks you whether to replace it.
983 The replace commands normally operate on the text from point to the
984 end of the buffer. When the mark is active, they operate on the
985 region instead (@pxref{Mark}). The basic replace commands replace one
986 @dfn{search string} (or regexp) with one @dfn{replacement string}. It
987 is possible to perform several replacements in parallel, using the
988 command @code{expand-region-abbrevs} (@pxref{Expanding Abbrevs}).
991 * Unconditional Replace:: Replacing all matches for a string.
992 * Regexp Replace:: Replacing all matches for a regexp.
993 * Replacement and Case:: How replacements preserve case of letters.
994 * Query Replace:: How to use querying.
997 @node Unconditional Replace, Regexp Replace, Replace, Replace
998 @subsection Unconditional Replacement
999 @findex replace-string
1002 @item M-x replace-string @key{RET} @var{string} @key{RET} @var{newstring} @key{RET}
1003 Replace every occurrence of @var{string} with @var{newstring}.
1006 To replace every instance of @samp{foo} after point with @samp{bar},
1007 use the command @kbd{M-x replace-string} with the two arguments
1008 @samp{foo} and @samp{bar}. Replacement happens only in the text after
1009 point, so if you want to cover the whole buffer you must go to the
1010 beginning first. All occurrences up to the end of the buffer are
1011 replaced; to limit replacement to part of the buffer, activate the
1012 region around that part. When the region is active, replacement is
1013 limited to the region (@pxref{Mark}).
1015 When @code{replace-string} exits, it leaves point at the last
1016 occurrence replaced. It adds the prior position of point (where the
1017 @code{replace-string} command was issued) to the mark ring, without
1018 activating the mark; use @kbd{C-u C-@key{SPC}} to move back there.
1021 A prefix argument restricts replacement to matches that are
1022 surrounded by word boundaries. The argument's value doesn't matter.
1024 @xref{Replacement and Case}, for details about case-sensitivity in
1027 @node Regexp Replace, Replacement and Case, Unconditional Replace, Replace
1028 @subsection Regexp Replacement
1029 @findex replace-regexp
1031 The @kbd{M-x replace-string} command replaces exact matches for a
1032 single string. The similar command @kbd{M-x replace-regexp} replaces
1033 any match for a specified pattern.
1036 @item M-x replace-regexp @key{RET} @var{regexp} @key{RET} @var{newstring} @key{RET}
1037 Replace every match for @var{regexp} with @var{newstring}.
1040 @cindex back reference, in regexp replacement
1041 In @code{replace-regexp}, the @var{newstring} need not be constant:
1042 it can refer to all or part of what is matched by the @var{regexp}.
1043 @samp{\&} in @var{newstring} stands for the entire match being
1044 replaced. @samp{\@var{d}} in @var{newstring}, where @var{d} is a
1045 digit, stands for whatever matched the @var{d}th parenthesized
1046 grouping in @var{regexp}. (This is called a ``back reference.'')
1047 @samp{\#} refers to the count of replacements already made in this
1048 command, as a decimal number. In the first replacement, @samp{\#}
1049 stands for @samp{0}; in the second, for @samp{1}; and so on. For
1053 M-x replace-regexp @key{RET} c[ad]+r @key{RET} \&-safe @key{RET}
1057 replaces (for example) @samp{cadr} with @samp{cadr-safe} and @samp{cddr}
1058 with @samp{cddr-safe}.
1061 M-x replace-regexp @key{RET} \(c[ad]+r\)-safe @key{RET} \1 @key{RET}
1065 performs the inverse transformation. To include a @samp{\} in the
1066 text to replace with, you must enter @samp{\\}.
1068 If you want to enter part of the replacement string by hand each
1069 time, use @samp{\?} in the replacement string. Each replacement will
1070 ask you to edit the replacement string in the minibuffer, putting
1071 point where the @samp{\?} was.
1073 The remainder of this subsection is intended for specialized tasks
1074 and requires knowledge of Lisp. Most readers can skip it.
1076 You can use Lisp expressions to calculate parts of the
1077 replacement string. To do this, write @samp{\,} followed by the
1078 expression in the replacement string. Each replacement calculates the
1079 value of the expression and converts it to text without quoting (if
1080 it's a string, this means using the string's contents), and uses it in
1081 the replacement string in place of the expression itself. If the
1082 expression is a symbol, one space in the replacement string after the
1083 symbol name goes with the symbol name, so the value replaces them
1086 Inside such an expression, you can use some special sequences.
1087 @samp{\&} and @samp{\@var{n}} refer here, as usual, to the entire
1088 match as a string, and to a submatch as a string. @var{n} may be
1089 multiple digits, and the value of @samp{\@var{n}} is @code{nil} if
1090 subexpression @var{n} did not match. You can also use @samp{\#&} and
1091 @samp{\#@var{n}} to refer to those matches as numbers (this is valid
1092 when the match or submatch has the form of a numeral). @samp{\#} here
1093 too stands for the number of already-completed replacements.
1095 Repeating our example to exchange @samp{x} and @samp{y}, we can thus
1096 do it also this way:
1099 M-x replace-regexp @key{RET} \(x\)\|y @key{RET}
1100 \,(if \1 "y" "x") @key{RET}
1103 For computing replacement strings for @samp{\,}, the @code{format}
1104 function is often useful (@pxref{Formatting Strings,,, elisp, The Emacs
1105 Lisp Reference Manual}). For example, to add consecutively numbered
1106 strings like @samp{ABC00042} to columns 73 @w{to 80} (unless they are
1107 already occupied), you can use
1110 M-x replace-regexp @key{RET} ^.\@{0,72\@}$ @key{RET}
1111 \,(format "%-72sABC%05d" \& \#) @key{RET}
1114 @node Replacement and Case, Query Replace, Regexp Replace, Replace
1115 @subsection Replace Commands and Case
1117 If the first argument of a replace command is all lower case, the
1118 command ignores case while searching for occurrences to
1119 replace---provided @code{case-fold-search} is non-@code{nil}. If
1120 @code{case-fold-search} is set to @code{nil}, case is always significant
1123 @vindex case-replace
1124 In addition, when the @var{newstring} argument is all or partly lower
1125 case, replacement commands try to preserve the case pattern of each
1126 occurrence. Thus, the command
1129 M-x replace-string @key{RET} foo @key{RET} bar @key{RET}
1133 replaces a lower case @samp{foo} with a lower case @samp{bar}, an
1134 all-caps @samp{FOO} with @samp{BAR}, and a capitalized @samp{Foo} with
1135 @samp{Bar}. (These three alternatives---lower case, all caps, and
1136 capitalized, are the only ones that @code{replace-string} can
1139 If upper-case letters are used in the replacement string, they remain
1140 upper case every time that text is inserted. If upper-case letters are
1141 used in the first argument, the second argument is always substituted
1142 exactly as given, with no case conversion. Likewise, if either
1143 @code{case-replace} or @code{case-fold-search} is set to @code{nil},
1144 replacement is done without case conversion.
1146 @node Query Replace,, Replacement and Case, Replace
1147 @subsection Query Replace
1148 @cindex query replace
1151 @item M-% @var{string} @key{RET} @var{newstring} @key{RET}
1152 @itemx M-x query-replace @key{RET} @var{string} @key{RET} @var{newstring} @key{RET}
1153 Replace some occurrences of @var{string} with @var{newstring}.
1154 @item C-M-% @var{regexp} @key{RET} @var{newstring} @key{RET}
1155 @itemx M-x query-replace-regexp @key{RET} @var{regexp} @key{RET} @var{newstring} @key{RET}
1156 Replace some matches for @var{regexp} with @var{newstring}.
1160 @findex query-replace
1161 If you want to change only some of the occurrences of @samp{foo} to
1162 @samp{bar}, not all of them, use @kbd{M-%} (@code{query-replace}).
1163 This command finds occurrences of @samp{foo} one by one, displays each
1164 occurrence and asks you whether to replace it. Aside from querying,
1165 @code{query-replace} works just like @code{replace-string}
1166 (@pxref{Unconditional Replace}). In particular, it preserves case
1167 provided @code{case-replace} is non-@code{nil}, as it normally is
1168 (@pxref{Replacement and Case}). A numeric argument means consider
1169 only occurrences that are bounded by word-delimiter characters.
1172 @findex query-replace-regexp
1173 @kbd{C-M-%} performs regexp search and replace (@code{query-replace-regexp}).
1174 It works like @code{replace-regexp} except that it queries
1175 like @code{query-replace}.
1177 @cindex faces for highlighting query replace
1178 These commands highlight the current match using the face
1179 @code{query-replace}. They highlight other matches using
1180 @code{lazy-highlight} just like incremental search (@pxref{Incremental
1181 Search}). By default, @code{query-replace-regexp} will show
1182 substituted replacement string for the current match in the
1183 minibuffer. If you want to keep special sequences @samp{\&} and
1184 @samp{\@var{n}} unexpanded, customize
1185 @code{query-replace-show-replacement} variable.
1187 The characters you can type when you are shown a match for the string
1190 @ignore @c Not worth it.
1191 @kindex SPC @r{(query-replace)}
1192 @kindex DEL @r{(query-replace)}
1193 @kindex , @r{(query-replace)}
1194 @kindex RET @r{(query-replace)}
1195 @kindex . @r{(query-replace)}
1196 @kindex ! @r{(query-replace)}
1197 @kindex ^ @r{(query-replace)}
1198 @kindex C-r @r{(query-replace)}
1199 @kindex C-w @r{(query-replace)}
1200 @kindex C-l @r{(query-replace)}
1206 to replace the occurrence with @var{newstring}.
1209 to skip to the next occurrence without replacing this one.
1212 to replace this occurrence and display the result. You are then asked
1213 for another input character to say what to do next. Since the
1214 replacement has already been made, @key{DEL} and @key{SPC} are
1215 equivalent in this situation; both move to the next occurrence.
1217 You can type @kbd{C-r} at this point (see below) to alter the replaced
1218 text. You can also type @kbd{C-x u} to undo the replacement; this exits
1219 the @code{query-replace}, so if you want to do further replacement you
1220 must use @kbd{C-x @key{ESC} @key{ESC} @key{RET}} to restart
1221 (@pxref{Repetition}).
1224 to exit without doing any more replacements.
1226 @item .@: @r{(Period)}
1227 to replace this occurrence and then exit without searching for more
1231 to replace all remaining occurrences without asking again.
1234 to go back to the position of the previous occurrence (or what used to
1235 be an occurrence), in case you changed it by mistake or want to
1239 to enter a recursive editing level, in case the occurrence needs to be
1240 edited rather than just replaced with @var{newstring}. When you are
1241 done, exit the recursive editing level with @kbd{C-M-c} to proceed to
1242 the next occurrence. @xref{Recursive Edit}.
1245 to delete the occurrence, and then enter a recursive editing level as in
1246 @kbd{C-r}. Use the recursive edit to insert text to replace the deleted
1247 occurrence of @var{string}. When done, exit the recursive editing level
1248 with @kbd{C-M-c} to proceed to the next occurrence.
1251 to edit the replacement string in the minibuffer. When you exit the
1252 minibuffer by typing @key{RET}, the minibuffer contents replace the
1253 current occurrence of the pattern. They also become the new
1254 replacement string for any further occurrences.
1257 to redisplay the screen. Then you must type another character to
1258 specify what to do with this occurrence.
1261 to display a message summarizing these options. Then you must type
1262 another character to specify what to do with this occurrence.
1265 Some other characters are aliases for the ones listed above: @kbd{y},
1266 @kbd{n} and @kbd{q} are equivalent to @key{SPC}, @key{DEL} and
1269 Aside from this, any other character exits the @code{query-replace},
1270 and is then reread as part of a key sequence. Thus, if you type
1271 @kbd{C-k}, it exits the @code{query-replace} and then kills to end of
1274 To restart a @code{query-replace} once it is exited, use @kbd{C-x
1275 @key{ESC} @key{ESC}}, which repeats the @code{query-replace} because it
1276 used the minibuffer to read its arguments. @xref{Repetition, C-x ESC
1279 @xref{Operating on Files}, for the Dired @kbd{Q} command which
1280 performs query replace on selected files. See also @ref{Transforming
1281 File Names}, for Dired commands to rename, copy, or link files by
1282 replacing regexp matches in file names.
1284 @node Other Repeating Search
1285 @section Other Search-and-Loop Commands
1287 Here are some other commands that find matches for a regular
1288 expression. They all ignore case in matching, if the pattern contains
1289 no upper-case letters and @code{case-fold-search} is non-@code{nil}.
1290 Aside from @code{occur} and its variants, all operate on the text from
1291 point to the end of the buffer, or on the region if it is active.
1293 @findex list-matching-lines
1296 @findex multi-occur-in-matching-buffers
1302 @item M-x multi-isearch-buffers
1303 Prompt for one or more buffer names, ending with @key{RET}; then,
1304 begin a multi-buffer incremental search in those buffers. (If the
1305 search fails in one buffer, the next @kbd{C-s} tries searching the
1306 next specified buffer, and so forth.) With a prefix argument, prompt
1307 for a regexp and begin a multi-buffer incremental search in buffers
1308 matching that regexp.
1310 @item M-x multi-isearch-buffers-regexp
1311 This command is just like @code{multi-isearch-buffers}, except it
1312 performs an incremental regexp search.
1315 Prompt for a regexp, and display a list showing each line in the
1316 buffer that contains a match for it. To limit the search to part of
1317 the buffer, narrow to that part (@pxref{Narrowing}). A numeric
1318 argument @var{n} specifies that @var{n} lines of context are to be
1319 displayed before and after each matching line.
1321 @kindex RET @r{(Occur mode)}
1322 @kindex o @r{(Occur mode)}
1323 @kindex C-o @r{(Occur mode)}
1324 The buffer @samp{*Occur*} containing the output serves as a menu for
1325 finding the occurrences in their original context. Click
1326 @kbd{Mouse-2} on an occurrence listed in @samp{*Occur*}, or position
1327 point there and type @key{RET}; this switches to the buffer that was
1328 searched and moves point to the original of the chosen occurrence.
1329 @kbd{o} and @kbd{C-o} display the match in another window; @kbd{C-o}
1332 After using @kbd{M-x occur}, you can use @code{next-error} to visit
1333 the occurrences found, one by one. @ref{Compilation Mode}.
1337 Run @code{occur} using the search string of the last incremental
1338 string search. You can also run @kbd{M-s o} when an incremental
1339 search is active; this uses the current search string.
1341 @item M-x list-matching-lines
1342 Synonym for @kbd{M-x occur}.
1344 @item M-x multi-occur
1345 This command is just like @code{occur}, except it is able to search
1346 through multiple buffers. It asks you to specify the buffer names one
1349 @item M-x multi-occur-in-matching-buffers
1350 This command is similar to @code{multi-occur}, except the buffers to
1351 search are specified by a regular expression that matches visited file
1352 names. With a prefix argument, it uses the regular expression to
1353 match buffer names instead.
1356 Prompt for a regexp, and print the number of matches for it in the
1357 buffer after point. If the region is active, this operates on the
1360 @item M-x flush-lines
1361 Prompt for a regexp, and delete each line that contains a match for
1362 it, operating on the text after point. This command deletes the
1363 current line if it contains a match starting after point. If the
1364 region is active, it operates on the region instead; if a line
1365 partially contained in the region contains a match entirely contained
1366 in the region, it is deleted.
1368 If a match is split across lines, @code{flush-lines} deletes all those
1369 lines. It deletes the lines before starting to look for the next
1370 match; hence, it ignores a match starting on the same line at which
1371 another match ended.
1373 @item M-x keep-lines
1374 Prompt for a regexp, and delete each line that @emph{does not} contain
1375 a match for it, operating on the text after point. If point is not at
1376 the beginning of a line, this command always keeps the current line.
1377 If the region is active, the command operates on the region instead;
1378 it never deletes lines that are only partially contained in the region
1379 (a newline that ends a line counts as part of that line).
1381 If a match is split across lines, this command keeps all those lines.