@c -*-texinfo-*-@c This is part of the GNU Emacs Lisp Reference Manual.@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2001,@c 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.@c See the file elisp.texi for copying conditions.@setfilename ../info/searching@node Searching and Matching, Syntax Tables, Non-ASCII Characters, Top@chapter Searching and Matching@cindex searching GNU Emacs provides two ways to search through a buffer for specifiedtext: exact string searches and regular expression searches. After aregular expression search, you can examine the @dfn{match data} todetermine which text matched the whole regular expression or variousportions of it.@menu* String Search:: Search for an exact match.* Searching and Case:: Case-independent or case-significant searching.* Regular Expressions:: Describing classes of strings.* Regexp Search:: Searching for a match for a regexp.* POSIX Regexps:: Searching POSIX-style for the longest match.* Match Data:: Finding out which part of the text matched, after a string or regexp search.* Search and Replace:: Commands that loop, searching and replacing.* Standard Regexps:: Useful regexps for finding sentences, pages,...@end menu The @samp{skip-chars@dots{}} functions also perform a kind of searching.@xref{Skipping Characters}. To search for changes in characterproperties, see @ref{Property Search}.@node String Search@section Searching for Strings@cindex string search These are the primitive functions for searching through the text in abuffer. They are meant for use in programs, but you may call theminteractively. If you do so, they prompt for the search string; thearguments @var{limit} and @var{noerror} are @code{nil}, and @var{repeat}is 1. These search functions convert the search string to multibyte if thebuffer is multibyte; they convert the search string to unibyte if thebuffer is unibyte. @xref{Text Representations}.@deffn Command search-forward string &optional limit noerror repeatThis function searches forward from point for an exact match for@var{string}. If successful, it sets point to the end of the occurrencefound, and returns the new value of point. If no match is found, thevalue and side effects depend on @var{noerror} (see below).@c Emacs 19 featureIn the following example, point is initially at the beginning of theline. Then @code{(search-forward "fox")} moves point after the lastletter of @samp{fox}:@example@group---------- Buffer: foo ----------@point{}The quick brown fox jumped over the lazy dog.---------- Buffer: foo ----------@end group@group(search-forward "fox") @result{} 20---------- Buffer: foo ----------The quick brown fox@point{} jumped over the lazy dog.---------- Buffer: foo ----------@end group@end exampleThe argument @var{limit} specifies the upper bound to the search. (Itmust be a position in the current buffer.) No match extending afterthat position is accepted. If @var{limit} is omitted or @code{nil}, itdefaults to the end of the accessible portion of the buffer.@kindex search-failedWhat happens when the search fails depends on the value of@var{noerror}. If @var{noerror} is @code{nil}, a @code{search-failed}error is signaled. If @var{noerror} is @code{t}, @code{search-forward}returns @code{nil} and does nothing. If @var{noerror} is neither@code{nil} nor @code{t}, then @code{search-forward} moves point to theupper bound and returns @code{nil}. (It would be more consistent now toreturn the new position of point in that case, but some existingprograms may depend on a value of @code{nil}.)The argument @var{noerror} only affects valid searches which fail tofind a match. Invalid arguments cause errors regardless of@var{noerror}.If @var{repeat} is supplied (it must be a positive number), then thesearch is repeated that many times (each time starting at the end of theprevious time's match). If these successive searches succeed, thefunction succeeds, moving point and returning its new value. Otherwisethe search fails, with results depending on the value of@var{noerror}, as described above.@end deffn@deffn Command search-backward string &optional limit noerror repeatThis function searches backward from point for @var{string}. It isjust like @code{search-forward} except that it searches backwards andleaves point at the beginning of the match.@end deffn@deffn Command word-search-forward string &optional limit noerror repeat@cindex word searchThis function searches forward from point for a ``word'' match for@var{string}. If it finds a match, it sets point to the end of thematch found, and returns the new value of point.@c Emacs 19 featureWord matching regards @var{string} as a sequence of words, disregardingpunctuation that separates them. It searches the buffer for the samesequence of words. Each word must be distinct in the buffer (searchingfor the word @samp{ball} does not match the word @samp{balls}), but thedetails of punctuation and spacing are ignored (searching for @samp{ballboy} does match @samp{ball. Boy!}).In this example, point is initially at the beginning of the buffer; thesearch leaves it between the @samp{y} and the @samp{!}.@example@group---------- Buffer: foo ----------@point{}He said "Please! Findthe ball boy!"---------- Buffer: foo ----------@end group@group(word-search-forward "Please find the ball, boy.") @result{} 35---------- Buffer: foo ----------He said "Please! Findthe ball boy@point{}!"---------- Buffer: foo ----------@end group@end exampleIf @var{limit} is non-@code{nil}, it must be a position in the currentbuffer; it specifies the upper bound to the search. The match foundmust not extend after that position.If @var{noerror} is @code{nil}, then @code{word-search-forward} signalsan error if the search fails. If @var{noerror} is @code{t}, then itreturns @code{nil} instead of signaling an error. If @var{noerror} isneither @code{nil} nor @code{t}, it moves point to @var{limit} (or theend of the accessible portion of the buffer) and returns @code{nil}.If @var{repeat} is non-@code{nil}, then the search is repeated that manytimes. Point is positioned at the end of the last match.@end deffn@deffn Command word-search-backward string &optional limit noerror repeatThis function searches backward from point for a word match to@var{string}. This function is just like @code{word-search-forward}except that it searches backward and normally leaves point at thebeginning of the match.@end deffn@node Searching and Case@section Searching and Case@cindex searching and case By default, searches in Emacs ignore the case of the text they aresearching through; if you specify searching for @samp{FOO}, then@samp{Foo} or @samp{foo} is also considered a match. This applies toregular expressions, too; thus, @samp{[aB]} would match @samp{a} or@samp{A} or @samp{b} or @samp{B}. If you do not want this feature, set the variable@code{case-fold-search} to @code{nil}. Then all letters must matchexactly, including case. This is a buffer-local variable; altering thevariable affects only the current buffer. (@xref{Intro toBuffer-Local}.) Alternatively, you may change the value of@code{default-case-fold-search}, which is the default value of@code{case-fold-search} for buffers that do not override it. Note that the user-level incremental search feature handles casedistinctions differently. When given a lower case letter, it looks fora match of either case, but when given an upper case letter, it looksfor an upper case letter only. But this has nothing to do with thesearching functions used in Lisp code.@defopt case-replaceThis variable determines whether the higher level replacementfunctions should preserve case. If the variable is @code{nil}, thatmeans to use the replacement text verbatim. A non-@code{nil} valuemeans to convert the case of the replacement text according to thetext being replaced.This variable is used by passing it as an argument to the function@code{replace-match}. @xref{Replacing Match}.@end defopt@defopt case-fold-searchThis buffer-local variable determines whether searches should ignorecase. If the variable is @code{nil} they do not ignore case; otherwisethey do ignore case.@end defopt@defvar default-case-fold-searchThe value of this variable is the default value for@code{case-fold-search} in buffers that do not override it. This is thesame as @code{(default-value 'case-fold-search)}.@end defvar@node Regular Expressions@section Regular Expressions@cindex regular expression@cindex regexp A @dfn{regular expression} (@dfn{regexp}, for short) is a pattern thatdenotes a (possibly infinite) set of strings. Searching for matches fora regexp is a very powerful operation. This section explains how to writeregexps; the following section says how to search for them.@findex re-builder@cindex authoring regular expressions For convenient interactive development of regular expressions, youcan use the @kbd{M-x re-builder} command. It provides a convenientinterface for creating regular expressions, by giving immediate visualfeedback in a separate buffer. As you edit the regexp, all itsmatches in the target buffer are highlighted. Each parenthesizedsub-expression of the regexp is shown in a distinct face, which makesit easier to verify even very complex regexps.@menu* Syntax of Regexps:: Rules for writing regular expressions.* Regexp Example:: Illustrates regular expression syntax.* Regexp Functions:: Functions for operating on regular expressions.@end menu@node Syntax of Regexps@subsection Syntax of Regular Expressions Regular expressions have a syntax in which a few characters arespecial constructs and the rest are @dfn{ordinary}. An ordinarycharacter is a simple regular expression that matches that characterand nothing else. The special characters are @samp{.}, @samp{*},@samp{+}, @samp{?}, @samp{[}, @samp{^}, @samp{$}, and @samp{\}; no newspecial characters will be defined in the future. The character@samp{]} is special if it ends a character alternative (see later).The character @samp{-} is special inside a character alternative. A@samp{[:} and balancing @samp{:]} enclose a character class inside acharacter alternative. Any other character appearing in a regularexpression is ordinary, unless a @samp{\} precedes it. For example, @samp{f} is not a special character, so it is ordinary, andtherefore @samp{f} is a regular expression that matches the string@samp{f} and no other string. (It does @emph{not} match the string@samp{fg}, but it does match a @emph{part} of that string.) Likewise,@samp{o} is a regular expression that matches only @samp{o}.@refill Any two regular expressions @var{a} and @var{b} can be concatenated. Theresult is a regular expression that matches a string if @var{a} matchessome amount of the beginning of that string and @var{b} matches the rest ofthe string.@refill As a simple example, we can concatenate the regular expressions @samp{f}and @samp{o} to get the regular expression @samp{fo}, which matches onlythe string @samp{fo}. Still trivial. To do something more powerful, youneed to use one of the special regular expression constructs.@menu* Regexp Special:: Special characters in regular expressions.* Char Classes:: Character classes used in regular expressions.* Regexp Backslash:: Backslash-sequences in regular expressions.@end menu@node Regexp Special@subsubsection Special Characters in Regular Expressions Here is a list of the characters that are special in a regularexpression.@need 800@table @asis@item @samp{.}@: @r{(Period)}@cindex @samp{.} in regexpis a special character that matches any single character except a newline.Using concatenation, we can make regular expressions like @samp{a.b}, whichmatches any three-character string that begins with @samp{a} and ends with@samp{b}.@refill@item @samp{*}@cindex @samp{*} in regexpis not a construct by itself; it is a postfix operator that means tomatch the preceding regular expression repetitively as many times aspossible. Thus, @samp{o*} matches any number of @samp{o}s (including no@samp{o}s).@samp{*} always applies to the @emph{smallest} possible precedingexpression. Thus, @samp{fo*} has a repeating @samp{o}, not a repeating@samp{fo}. It matches @samp{f}, @samp{fo}, @samp{foo}, and so on.The matcher processes a @samp{*} construct by matching, immediately, asmany repetitions as can be found. Then it continues with the rest ofthe pattern. If that fails, backtracking occurs, discarding some of thematches of the @samp{*}-modified construct in the hope that that willmake it possible to match the rest of the pattern. For example, inmatching @samp{ca*ar} against the string @samp{caaar}, the @samp{a*}first tries to match all three @samp{a}s; but the rest of the pattern is@samp{ar} and there is only @samp{r} left to match, so this try fails.The next alternative is for @samp{a*} to match only two @samp{a}s. Withthis choice, the rest of the regexp matches successfully.@strong{Warning:} Nested repetition operators take a long time,or even forever, if theylead to ambiguous matching. For example, trying to match the regularexpression @samp{\(x+y*\)*a} against the string@samp{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxz} could take hours before itultimately fails. Emacs must try each way of grouping the 35@samp{x}s before concluding that none of them can work. Even worse,@samp{\(x*\)*} can match the null string in infinitely many ways, soit causes an infinite loop. To avoid these problems, check nestedrepetitions carefully, to make sure that they do not cause combinatorialexplosions in backtracking.@item @samp{+}@cindex @samp{+} in regexpis a postfix operator, similar to @samp{*} except that it must matchthe preceding expression at least once. So, for example, @samp{ca+r}matches the strings @samp{car} and @samp{caaaar} but not the string@samp{cr}, whereas @samp{ca*r} matches all three strings.@item @samp{?}@cindex @samp{?} in regexpis a postfix operator, similar to @samp{*} except that it must match thepreceding expression either once or not at all. For example,@samp{ca?r} matches @samp{car} or @samp{cr}; nothing else.@item @samp{*?}, @samp{+?}, @samp{??}These are ``non-greedy'' variants of the operators @samp{*}, @samp{+}and @samp{?}. Where those operators match the largest possiblesubstring (consistent with matching the entire containing expression),the non-greedy variants match the smallest possible substring(consistent with matching the entire containing expression).For example, the regular expression @samp{c[ad]*a} when applied to thestring @samp{cdaaada} matches the whole string; but the regularexpression @samp{c[ad]*?a}, applied to that same string, matches just@samp{cda}. (The smallest possible match here for @samp{[ad]*?} thatpermits the whole expression to match is @samp{d}.)@item @samp{[ @dots{} ]}@cindex character alternative (in regexp)@cindex @samp{[} in regexp@cindex @samp{]} in regexpis a @dfn{character alternative}, which begins with @samp{[} and isterminated by @samp{]}. In the simplest case, the characters betweenthe two brackets are what this character alternative can match.Thus, @samp{[ad]} matches either one @samp{a} or one @samp{d}, and@samp{[ad]*} matches any string composed of just @samp{a}s and @samp{d}s(including the empty string), from which it follows that @samp{c[ad]*r}matches @samp{cr}, @samp{car}, @samp{cdr}, @samp{caddaar}, etc.You can also include character ranges in a character alternative, bywriting the starting and ending characters with a @samp{-} between them.Thus, @samp{[a-z]} matches any lower-case @acronym{ASCII} letter.Ranges may be intermixed freely with individual characters, as in@samp{[a-z$%.]}, which matches any lower case @acronym{ASCII} letteror @samp{$}, @samp{%} or period.Note that the usual regexp special characters are not special inside acharacter alternative. A completely different set of characters isspecial inside character alternatives: @samp{]}, @samp{-} and @samp{^}.To include a @samp{]} in a character alternative, you must make it thefirst character. For example, @samp{[]a]} matches @samp{]} or @samp{a}.To include a @samp{-}, write @samp{-} as the first or last character ofthe character alternative, or put it after a range. Thus, @samp{[]-]}matches both @samp{]} and @samp{-}.To include @samp{^} in a character alternative, put it anywhere but atthe beginning.The beginning and end of a range of multibyte characters must be inthe same character set (@pxref{Character Sets}). Thus,@code{"[\x8e0-\x97c]"} is invalid because character 0x8e0 (@samp{a}with grave accent) is in the Emacs character set for Latin-1 but thecharacter 0x97c (@samp{u} with diaeresis) is in the Emacs characterset for Latin-2. (We use Lisp string syntax to write that example,and a few others in the next few paragraphs, in order to include hexescape sequences in them.)If a range starts with a unibyte character @var{c} and ends with amultibyte character @var{c2}, the range is divided into two parts: oneis @samp{@var{c}..?\377}, the other is @samp{@var{c1}..@var{c2}}, where@var{c1} is the first character of the charset to which @var{c2}belongs.You cannot always match all non-@acronym{ASCII} characters with the regularexpression @code{"[\200-\377]"}. This works when searching a unibytebuffer or string (@pxref{Text Representations}), but not in a multibytebuffer or string, because many non-@acronym{ASCII} characters have codesabove octal 0377. However, the regular expression @code{"[^\000-\177]"}does match all non-@acronym{ASCII} characters (see below regarding @samp{^}),in both multibyte and unibyte representations, because only the@acronym{ASCII} characters are excluded.A character alternative can also specify namedcharacter classes (@pxref{Char Classes}). This is a POSIX feature whosesyntax is @samp{[:@var{class}:]}. Using a character class is equivalentto mentioning each of the characters in that class; but the latter isnot feasible in practice, since some classes include thousands ofdifferent characters.@item @samp{[^ @dots{} ]}@cindex @samp{^} in regexp@samp{[^} begins a @dfn{complemented character alternative}. Thismatches any character except the ones specified. Thus,@samp{[^a-z0-9A-Z]} matches all characters @emph{except} letters anddigits.@samp{^} is not special in a character alternative unless it is the firstcharacter. The character following the @samp{^} is treated as if itwere first (in other words, @samp{-} and @samp{]} are not special there).A complemented character alternative can match a newline, unless newline ismentioned as one of the characters not to match. This is in contrast tothe handling of regexps in programs such as @code{grep}.@item @samp{^}@cindex beginning of line in regexpWhen matching a buffer, @samp{^} matches the empty string, but only at thebeginning of a line in the text being matched (or the beginning of theaccessible portion of the buffer). Otherwise it fails to matchanything. Thus, @samp{^foo} matches a @samp{foo} that occurs at thebeginning of a line.When matching a string instead of a buffer, @samp{^} matches at thebeginning of the string or after a newline character.For historical compatibility reasons, @samp{^} can be used only at thebeginning of the regular expression, or after @samp{\(}, @samp{\(?:}or @samp{\|}.@item @samp{$}@cindex @samp{$} in regexp@cindex end of line in regexpis similar to @samp{^} but matches only at the end of a line (or theend of the accessible portion of the buffer). Thus, @samp{x+$}matches a string of one @samp{x} or more at the end of a line.When matching a string instead of a buffer, @samp{$} matches at the endof the string or before a newline character.For historical compatibility reasons, @samp{$} can be used only at theend of the regular expression, or before @samp{\)} or @samp{\|}.@item @samp{\}@cindex @samp{\} in regexphas two functions: it quotes the special characters (including@samp{\}), and it introduces additional special constructs.Because @samp{\} quotes special characters, @samp{\$} is a regularexpression that matches only @samp{$}, and @samp{\[} is a regularexpression that matches only @samp{[}, and so on.Note that @samp{\} also has special meaning in the read syntax of Lispstrings (@pxref{String Type}), and must be quoted with @samp{\}. Forexample, the regular expression that matches the @samp{\} character is@samp{\\}. To write a Lisp string that contains the characters@samp{\\}, Lisp syntax requires you to quote each @samp{\} with another@samp{\}. Therefore, the read syntax for a regular expression matching@samp{\} is @code{"\\\\"}.@refill@end table@strong{Please note:} For historical compatibility, special charactersare treated as ordinary ones if they are in contexts where their specialmeanings make no sense. For example, @samp{*foo} treats @samp{*} asordinary since there is no preceding expression on which the @samp{*}can act. It is poor practice to depend on this behavior; quote thespecial character anyway, regardless of where it appears.@refillAs a @samp{\} is not special inside a character alternative, it cannever remove the special meaning of @samp{-} or @samp{]}. So youshould not quote these characters when they have no special meaningeither. This would not clarify anything, since backslashes canlegitimately precede these characters where they @emph{have} specialmeaning, as in @samp{[^\]} (@code{"[^\\]"} for Lisp string syntax),which matches any single character except a backslash.In practice, most @samp{]} that occur in regular expressions close acharacter alternative and hence are special. However, occasionally aregular expression may try to match a complex pattern of literal@samp{[} and @samp{]}. In such situations, it sometimes may benecessary to carefully parse the regexp from the start to determinewhich square brackets enclose a character alternative. For example,@samp{[^][]]} consists of the complemented character alternative@samp{[^][]} (which matches any single character that is not a squarebracket), followed by a literal @samp{]}.The exact rules are that at the beginning of a regexp, @samp{[} isspecial and @samp{]} not. This lasts until the first unquoted@samp{[}, after which we are in a character alternative; @samp{[} isno longer special (except when it starts a character class) but @samp{]}is special, unless it immediately follows the special @samp{[} or that@samp{[} followed by a @samp{^}. This lasts until the next special@samp{]} that does not end a character class. This ends the characteralternative and restores the ordinary syntax of regular expressions;an unquoted @samp{[} is special again and a @samp{]} not.@node Char Classes@subsubsection Character Classes@cindex character classes in regexp Here is a table of the classes you can use in a character alternative,and what they mean:@table @samp@item [:ascii:]This matches any @acronym{ASCII} character (codes 0--127).@item [:alnum:]This matches any letter or digit. (At present, for multibytecharacters, it matches anything that has word syntax.)@item [:alpha:]This matches any letter. (At present, for multibyte characters, itmatches anything that has word syntax.)@item [:blank:]This matches space and tab only.@item [:cntrl:]This matches any @acronym{ASCII} control character.@item [:digit:]This matches @samp{0} through @samp{9}. Thus, @samp{[-+[:digit:]]}matches any digit, as well as @samp{+} and @samp{-}.@item [:graph:]This matches graphic characters---everything except @acronym{ASCII} controlcharacters, space, and the delete character.@item [:lower:]This matches any lower-case letter, as determined bythe current case table (@pxref{Case Tables}).@item [:multibyte:]This matches any multibyte character (@pxref{Text Representations}).@item [:nonascii:]This matches any non-@acronym{ASCII} character.@item [:print:]This matches printing characters---everything except @acronym{ASCII} controlcharacters and the delete character.@item [:punct:]This matches any punctuation character. (At present, for multibytecharacters, it matches anything that has non-word syntax.)@item [:space:]This matches any character that has whitespace syntax(@pxref{Syntax Class Table}).@item [:unibyte:]This matches any unibyte character (@pxref{Text Representations}).@item [:upper:]This matches any upper-case letter, as determined bythe current case table (@pxref{Case Tables}).@item [:word:]This matches any character that has word syntax (@pxref{Syntax ClassTable}).@item [:xdigit:]This matches the hexadecimal digits: @samp{0} through @samp{9}, @samp{a}through @samp{f} and @samp{A} through @samp{F}.@end table@node Regexp Backslash@subsubsection Backslash Constructs in Regular Expressions For the most part, @samp{\} followed by any character matches onlythat character. However, there are several exceptions: certaintwo-character sequences starting with @samp{\} that have specialmeanings. (The character after the @samp{\} in such a sequence isalways ordinary when used on its own.) Here is a table of the special@samp{\} constructs.@table @samp@item \|@cindex @samp{|} in regexp@cindex regexp alternativespecifies an alternative.Two regular expressions @var{a} and @var{b} with @samp{\|} inbetween form an expression that matches anything that either @var{a} or@var{b} matches.@refillThus, @samp{foo\|bar} matches either @samp{foo} or @samp{bar}but no other string.@refill@samp{\|} applies to the largest possible surrounding expressions. Only asurrounding @samp{\( @dots{} \)} grouping can limit the grouping power of@samp{\|}.@refillIf you need full backtracking capability to handle multiple uses of@samp{\|}, use the POSIX regular expression functions (@pxref{POSIXRegexps}).@item \@{@var{m}\@}is a postfix operator that repeats the previous pattern exactly @var{m}times. Thus, @samp{x\@{5\@}} matches the string @samp{xxxxx}and nothing else. @samp{c[ad]\@{3\@}r} matches string such as@samp{caaar}, @samp{cdddr}, @samp{cadar}, and so on.@item \@{@var{m},@var{n}\@}is a more general postfix operator that specifies repetition with aminimum of @var{m} repeats and a maximum of @var{n} repeats. If @var{m}is omitted, the minimum is 0; if @var{n} is omitted, there is nomaximum.For example, @samp{c[ad]\@{1,2\@}r} matches the strings @samp{car},@samp{cdr}, @samp{caar}, @samp{cadr}, @samp{cdar}, and @samp{cddr}, andnothing else.@*@samp{\@{0,1\@}} or @samp{\@{,1\@}} is equivalent to @samp{?}. @*@samp{\@{0,\@}} or @samp{\@{,\@}} is equivalent to @samp{*}. @*@samp{\@{1,\@}} is equivalent to @samp{+}.@item \( @dots{} \)@cindex @samp{(} in regexp@cindex @samp{)} in regexp@cindex regexp groupingis a grouping construct that serves three purposes:@enumerate@itemTo enclose a set of @samp{\|} alternatives for other operations. Thus,the regular expression @samp{\(foo\|bar\)x} matches either @samp{foox}or @samp{barx}.@itemTo enclose a complicated expression for the postfix operators @samp{*},@samp{+} and @samp{?} to operate on. Thus, @samp{ba\(na\)*} matches@samp{ba}, @samp{bana}, @samp{banana}, @samp{bananana}, etc., with anynumber (zero or more) of @samp{na} strings.@itemTo record a matched substring for future reference with@samp{\@var{digit}} (see below).@end enumerateThis last application is not a consequence of the idea of aparenthetical grouping; it is a separate feature that was assigned as asecond meaning to the same @samp{\( @dots{} \)} construct because, inpractice, there was usually no conflict between the two meanings. Butoccasionally there is a conflict, and that led to the introduction ofshy groups.@item \(?: @dots{} \)is the @dfn{shy group} construct. A shy group serves the first twopurposes of an ordinary group (controlling the nesting of otheroperators), but it does not get a number, so you cannot refer back toits value with @samp{\@var{digit}}.Shy groups are particularly useful for mechanically-constructed regularexpressions because they can be added automatically without altering thenumbering of any ordinary, non-shy groups.@item \@var{digit}matches the same text that matched the @var{digit}th occurrence of agrouping (@samp{\( @dots{} \)}) construct.In other words, after the end of a group, the matcher remembers thebeginning and end of the text matched by that group. Later on in theregular expression you can use @samp{\} followed by @var{digit} tomatch that same text, whatever it may have been.The strings matching the first nine grouping constructs appearing inthe entire regular expression passed to a search or matching functionare assigned numbers 1 through 9 in the order that the openparentheses appear in the regular expression. So you can use@samp{\1} through @samp{\9} to refer to the text matched by thecorresponding grouping constructs.For example, @samp{\(.*\)\1} matches any newline-free string that iscomposed of two identical halves. The @samp{\(.*\)} matches the firsthalf, which may be anything, but the @samp{\1} that follows must matchthe same exact text.If a @samp{\( @dots{} \)} construct matches more than once (which canhappen, for instance, if it is followed by @samp{*}), only the lastmatch is recorded.If a particular grouping construct in the regular expression was nevermatched---for instance, if it appears inside of an alternative thatwasn't used, or inside of a repetition that repeated zero times---thenthe corresponding @samp{\@var{digit}} construct never matchesanything. To use an artificial example,, @samp{\(foo\(b*\)\|lose\)\2}cannot match @samp{lose}: the second alternative inside the largergroup matches it, but then @samp{\2} is undefined and can't matchanything. But it can match @samp{foobb}, because the firstalternative matches @samp{foob} and @samp{\2} matches @samp{b}.@item \w@cindex @samp{\w} in regexpmatches any word-constituent character. The editor syntax tabledetermines which characters these are. @xref{Syntax Tables}.@item \W@cindex @samp{\W} in regexpmatches any character that is not a word constituent.@item \s@var{code}@cindex @samp{\s} in regexpmatches any character whose syntax is @var{code}. Here @var{code} is acharacter that represents a syntax code: thus, @samp{w} for wordconstituent, @samp{-} for whitespace, @samp{(} for open parenthesis,etc. To represent whitespace syntax, use either @samp{-} or a spacecharacter. @xref{Syntax Class Table}, for a list of syntax codes andthe characters that stand for them.@item \S@var{code}@cindex @samp{\S} in regexpmatches any character whose syntax is not @var{code}.@item \c@var{c}matches any character whose category is @var{c}. Here @var{c} is acharacter that represents a category: thus, @samp{c} for Chinesecharacters or @samp{g} for Greek characters in the standard categorytable.@item \C@var{c}matches any character whose category is not @var{c}.@end table The following regular expression constructs match the empty string---that is,they don't use up any characters---but whether they match depends on thecontext. For all, the beginning and end of the accessible portion ofthe buffer are treated as if they were the actual beginning and end ofthe buffer.@table @samp@item \`@cindex @samp{\`} in regexpmatches the empty string, but only at the beginningof the buffer or string being matched against.@item \'@cindex @samp{\'} in regexpmatches the empty string, but only at the end ofthe buffer or string being matched against.@item \=@cindex @samp{\=} in regexpmatches the empty string, but only at point.(This construct is not defined when matching against a string.)@item \b@cindex @samp{\b} in regexpmatches the empty string, but only at the beginning orend of a word. Thus, @samp{\bfoo\b} matches any occurrence of@samp{foo} as a separate word. @samp{\bballs?\b} matches@samp{ball} or @samp{balls} as a separate word.@refill@samp{\b} matches at the beginning or end of the buffer (or string)regardless of what text appears next to it.@item \B@cindex @samp{\B} in regexpmatches the empty string, but @emph{not} at the beginning orend of a word, nor at the beginning or end of the buffer (or string).@item \<@cindex @samp{\<} in regexpmatches the empty string, but only at the beginning of a word.@samp{\<} matches at the beginning of the buffer (or string) only if aword-constituent character follows.@item \>@cindex @samp{\>} in regexpmatches the empty string, but only at the end of a word. @samp{\>}matches at the end of the buffer (or string) only if the contents endwith a word-constituent character.@item \_<@cindex @samp{\_<} in regexpmatches the empty string, but only at the beginning of a symbol. Asymbol is a sequence of one or more word or symbol constituentcharacters. @samp{\_<} matches at the beginning of the buffer (orstring) only if a symbol-constituent character follows.@item \_>@cindex @samp{\_>} in regexpmatches the empty string, but only at the end of a symbol. @samp{\_>}matches at the end of the buffer (or string) only if the contents endwith a symbol-constituent character.@end table@kindex invalid-regexp Not every string is a valid regular expression. For example, a stringthat ends inside a character alternative without terminating @samp{]}is invalid, and so is a string that ends with a single @samp{\}. Ifan invalid regular expression is passed to any of the search functions,an @code{invalid-regexp} error is signaled.@node Regexp Example@comment node-name, next, previous, up@subsection Complex Regexp Example Here is a complicated regexp which was formerly used by Emacs torecognize the end of a sentence together with any whitespace thatfollows. (Nowadays Emacs uses a similar but more complex defaultregexp constructed by the function @code{sentence-end}.@xref{Standard Regexps}.) First, we show the regexp as a string in Lisp syntax to distinguishspaces from tab characters. The string constant begins and ends with adouble-quote. @samp{\"} stands for a double-quote as part of thestring, @samp{\\} for a backslash as part of the string, @samp{\t} for atab and @samp{\n} for a newline.@example"[.?!][]\"')@}]*\\($\\| $\\|\t\\|@ @ \\)[ \t\n]*"@end example@noindentIn contrast, if you evaluate this string, you will see the following:@example@group"[.?!][]\"')@}]*\\($\\| $\\|\t\\|@ @ \\)[ \t\n]*" @result{} "[.?!][]\"')@}]*\\($\\| $\\| \\|@ @ \\)[]*"@end group@end example@noindentIn this output, tab and newline appear as themselves. This regular expression contains four parts in succession and can bedeciphered as follows:@table @code@item [.?!]The first part of the pattern is a character alternative that matchesany one of three characters: period, question mark, and exclamationmark. The match must begin with one of these three characters. (Thisis one point where the new default regexp used by Emacs differs fromthe old. The new value also allows some non-@acronym{ASCII}characters that end a sentence without any following whitespace.)@item []\"')@}]*The second part of the pattern matches any closing braces and quotationmarks, zero or more of them, that may follow the period, question markor exclamation mark. The @code{\"} is Lisp syntax for a double-quote ina string. The @samp{*} at the end indicates that the immediatelypreceding regular expression (a character alternative, in this case) may berepeated zero or more times.@item \\($\\|@ $\\|\t\\|@ @ \\)The third part of the pattern matches the whitespace that follows theend of a sentence: the end of a line (optionally with a space), or atab, or two spaces. The double backslashes mark the parentheses andvertical bars as regular expression syntax; the parentheses delimit agroup and the vertical bars separate alternatives. The dollar sign isused to match the end of a line.@item [ \t\n]*Finally, the last part of the pattern matches any additional whitespacebeyond the minimum needed to end a sentence.@end table@node Regexp Functions@subsection Regular Expression Functions These functions operate on regular expressions.@defun regexp-quote stringThis function returns a regular expression whose only exact match is@var{string}. Using this regular expression in @code{looking-at} willsucceed only if the next characters in the buffer are @var{string};using it in a search function will succeed if the text being searchedcontains @var{string}.This allows you to request an exact string match or search when callinga function that wants a regular expression.@example@group(regexp-quote "^The cat$") @result{} "\\^The cat\\$"@end group@end exampleOne use of @code{regexp-quote} is to combine an exact string match withcontext described as a regular expression. For example, this searchesfor the string that is the value of @var{string}, surrounded bywhitespace:@example@group(re-search-forward (concat "\\s-" (regexp-quote string) "\\s-"))@end group@end example@end defun@defun regexp-opt strings &optional parenThis function returns an efficient regular expression that will matchany of the strings in the list @var{strings}. This is useful when youneed to make matching or searching as fast as possible---for example,for Font Lock mode.If the optional argument @var{paren} is non-@code{nil}, then thereturned regular expression is always enclosed by at least oneparentheses-grouping construct. If @var{paren} is @code{words}, thenthat construct is additionally surrounded by @samp{\<} and @samp{\>}.This simplified definition of @code{regexp-opt} produces aregular expression which is equivalent to the actual value(but not as efficient):@example(defun regexp-opt (strings paren) (let ((open-paren (if paren "\\(" "")) (close-paren (if paren "\\)" ""))) (concat open-paren (mapconcat 'regexp-quote strings "\\|") close-paren)))@end example@end defun@defun regexp-opt-depth regexpThis function returns the total number of grouping constructs(parenthesized expressions) in @var{regexp}. (This does not includeshy groups.)@end defun@node Regexp Search@section Regular Expression Searching@cindex regular expression searching@cindex regexp searching@cindex searching for regexp In GNU Emacs, you can search for the next match for a regularexpression either incrementally or not. For incremental searchcommands, see @ref{Regexp Search, , Regular Expression Search, emacs,The GNU Emacs Manual}. Here we describe only the search functionsuseful in programs. The principal one is @code{re-search-forward}. These search functions convert the regular expression to multibyte ifthe buffer is multibyte; they convert the regular expression to unibyteif the buffer is unibyte. @xref{Text Representations}.@deffn Command re-search-forward regexp &optional limit noerror repeatThis function searches forward in the current buffer for a string oftext that is matched by the regular expression @var{regexp}. Thefunction skips over any amount of text that is not matched by@var{regexp}, and leaves point at the end of the first match found.It returns the new value of point.If @var{limit} is non-@code{nil}, it must be a position in the currentbuffer. It specifies the upper bound to the search. No matchextending after that position is accepted.If @var{repeat} is supplied, it must be a positive number; the searchis repeated that many times; each repetition starts at the end of theprevious match. If all these successive searches succeed, the searchsucceeds, moving point and returning its new value. Otherwise thesearch fails. What @code{re-search-forward} does when the searchfails depends on the value of @var{noerror}:@table @asis@item @code{nil}Signal a @code{search-failed} error.@item @code{t}Do nothing and return @code{nil}.@item anything elseMove point to @var{limit} (or the end of the accessible portion of thebuffer) and return @code{nil}.@end tableIn the following example, point is initially before the @samp{T}.Evaluating the search call moves point to the end of that line (betweenthe @samp{t} of @samp{hat} and the newline).@example@group---------- Buffer: foo ----------I read "@point{}The cat in the hatcomes back" twice.---------- Buffer: foo ----------@end group@group(re-search-forward "[a-z]+" nil t 5) @result{} 27---------- Buffer: foo ----------I read "The cat in the hat@point{}comes back" twice.---------- Buffer: foo ----------@end group@end example@end deffn@deffn Command re-search-backward regexp &optional limit noerror repeatThis function searches backward in the current buffer for a string oftext that is matched by the regular expression @var{regexp}, leavingpoint at the beginning of the first text found.This function is analogous to @code{re-search-forward}, but they are notsimple mirror images. @code{re-search-forward} finds the match whosebeginning is as close as possible to the starting point. If@code{re-search-backward} were a perfect mirror image, it would find thematch whose end is as close as possible. However, in fact it finds thematch whose beginning is as close as possible (and yet ends before thestarting point). The reason for this is that matching a regularexpression at a given spot always works from beginning to end, andstarts at a specified beginning position.A true mirror-image of @code{re-search-forward} would require a specialfeature for matching regular expressions from end to beginning. It'snot worth the trouble of implementing that.@end deffn@defun string-match regexp string &optional startThis function returns the index of the start of the first match forthe regular expression @var{regexp} in @var{string}, or @code{nil} ifthere is no match. If @var{start} is non-@code{nil}, the search startsat that index in @var{string}.For example,@example@group(string-match "quick" "The quick brown fox jumped quickly.") @result{} 4@end group@group(string-match "quick" "The quick brown fox jumped quickly." 8) @result{} 27@end group@end example@noindentThe index of the first character of thestring is 0, the index of the second character is 1, and so on.After this function returns, the index of the first character beyondthe match is available as @code{(match-end 0)}. @xref{Match Data}.@example@group(string-match "quick" "The quick brown fox jumped quickly." 8) @result{} 27@end group@group(match-end 0) @result{} 32@end group@end example@end defun@defun looking-at regexpThis function determines whether the text in the current buffer directlyfollowing point matches the regular expression @var{regexp}. ``Directlyfollowing'' means precisely that: the search is ``anchored'' and it cansucceed only starting with the first character following point. Theresult is @code{t} if so, @code{nil} otherwise.This function does not move point, but it updates the match data, whichyou can access using @code{match-beginning} and @code{match-end}.@xref{Match Data}.In this example, point is located directly before the @samp{T}. If itwere anywhere else, the result would be @code{nil}.@example@group---------- Buffer: foo ----------I read "@point{}The cat in the hatcomes back" twice.---------- Buffer: foo ----------(looking-at "The cat in the hat$") @result{} t@end group@end example@end defun@defun looking-back regexp &optional limitThis function returns @code{t} if @var{regexp} matches text beforepoint, ending at point, and @code{nil} otherwise.Because regular expression matching works only going forward, this isimplemented by searching backwards from point for a match that ends atpoint. That can be quite slow if it has to search a long distance.You can bound the time required by specifying @var{limit}, which saysnot to search before @var{limit}. In this case, the match that isfound must begin at or after @var{limit}.@example@group---------- Buffer: foo ----------I read "@point{}The cat in the hatcomes back" twice.---------- Buffer: foo ----------(looking-back "read \"" 3) @result{} t(looking-back "read \"" 4) @result{} nil@end group@end example@end defun@defvar search-spaces-regexpIf this variable is non-@code{nil}, it should be a regular expressionthat says how to search for whitespace. In that case, any group ofspaces in a regular expression being searched for stands for use ofthis regular expression. However, spaces inside of constructs such as@samp{[@dots{}]} and @samp{*}, @samp{+}, @samp{?} are not affected by@code{search-spaces-regexp}.Since this variable affects all regular expression search and matchconstructs, you should bind it temporarily for as small as possiblea part of the code.@end defvar@node POSIX Regexps@section POSIX Regular Expression Searching The usual regular expression functions do backtracking when necessaryto handle the @samp{\|} and repetition constructs, but they continuethis only until they find @emph{some} match. Then they succeed andreport the first match found. This section describes alternative search functions which perform thefull backtracking specified by the POSIX standard for regular expressionmatching. They continue backtracking until they have tried allpossibilities and found all matches, so they can report the longestmatch, as required by POSIX. This is much slower, so use thesefunctions only when you really need the longest match. The POSIX search and match functions do not properly support thenon-greedy repetition operators. This is because POSIX backtrackingconflicts with the semantics of non-greedy repetition.@defun posix-search-forward regexp &optional limit noerror repeatThis is like @code{re-search-forward} except that it performs the fullbacktracking specified by the POSIX standard for regular expressionmatching.@end defun@defun posix-search-backward regexp &optional limit noerror repeatThis is like @code{re-search-backward} except that it performs the fullbacktracking specified by the POSIX standard for regular expressionmatching.@end defun@defun posix-looking-at regexpThis is like @code{looking-at} except that it performs the fullbacktracking specified by the POSIX standard for regular expressionmatching.@end defun@defun posix-string-match regexp string &optional startThis is like @code{string-match} except that it performs the fullbacktracking specified by the POSIX standard for regular expressionmatching.@end defun@node Match Data@section The Match Data@cindex match data Emacs keeps track of the start and end positions of the segments oftext found during a search; this is called the @dfn{match data}.Thanks to the match data, you can search for a complex pattern, suchas a date in a mail message, and then extract parts of the match undercontrol of the pattern. Because the match data normally describe the most recent search only,you must be careful not to do another search inadvertently between thesearch you wish to refer back to and the use of the match data. If youcan't avoid another intervening search, you must save and restore thematch data around it, to prevent it from being overwritten.@menu* Replacing Match:: Replacing a substring that was matched.* Simple Match Data:: Accessing single items of match data, such as where a particular subexpression started.* Entire Match Data:: Accessing the entire match data at once, as a list.* Saving Match Data:: Saving and restoring the match data.@end menu@node Replacing Match@subsection Replacing the Text that Matched This function replaces all or part of the text matched by the lastsearch. It works by means of the match data.@cindex case in replacements@defun replace-match replacement &optional fixedcase literal string subexpThis function replaces the text in the buffer (or in @var{string}) thatwas matched by the last search. It replaces that text with@var{replacement}.If you did the last search in a buffer, you should specify @code{nil}for @var{string} and make sure that the current buffer when you call@code{replace-match} is the one in which you did the searching ormatching. Then @code{replace-match} does the replacement by editingthe buffer; it leaves point at the end of the replacement text, andreturns @code{t}.If you did the search in a string, pass the same string as @var{string}.Then @code{replace-match} does the replacement by constructing andreturning a new string.If @var{fixedcase} is non-@code{nil}, then @code{replace-match} usesthe replacement text without case conversion; otherwise, it convertsthe replacement text depending upon the capitalization of the text tobe replaced. If the original text is all upper case, this convertsthe replacement text to upper case. If all words of the original textare capitalized, this capitalizes all the words of the replacementtext. If all the words are one-letter and they are all upper case,they are treated as capitalized words rather than all-upper-casewords.If @var{literal} is non-@code{nil}, then @var{replacement} is insertedexactly as it is, the only alterations being case changes as needed.If it is @code{nil} (the default), then the character @samp{\} is treatedspecially. If a @samp{\} appears in @var{replacement}, then it must bepart of one of the following sequences:@table @asis@item @samp{\&}@cindex @samp{&} in replacement@samp{\&} stands for the entire text being replaced.@item @samp{\@var{n}}@cindex @samp{\@var{n}} in replacement@samp{\@var{n}}, where @var{n} is a digit, stands for the text thatmatched the @var{n}th subexpression in the original regexp.Subexpressions are those expressions grouped inside @samp{\(@dots{}\)}.If the @var{n}th subexpression never matched, an empty string is substituted.@item @samp{\\}@cindex @samp{\} in replacement@samp{\\} stands for a single @samp{\} in the replacement text.@end tableThese substitutions occur after case conversion, if any,so the strings they substitute are never case-converted.If @var{subexp} is non-@code{nil}, that says to replace justsubexpression number @var{subexp} of the regexp that was matched, notthe entire match. For example, after matching @samp{foo \(ba*r\)},calling @code{replace-match} with 1 as @var{subexp} means to replacejust the text that matched @samp{\(ba*r\)}.@end defun@node Simple Match Data@subsection Simple Match Data Access This section explains how to use the match data to find out what wasmatched by the last search or match operation, if it succeeded. You can ask about the entire matching text, or about a particularparenthetical subexpression of a regular expression. The @var{count}argument in the functions below specifies which. If @var{count} iszero, you are asking about the entire match. If @var{count} ispositive, it specifies which subexpression you want. Recall that the subexpressions of a regular expression are thoseexpressions grouped with escaped parentheses, @samp{\(@dots{}\)}. The@var{count}th subexpression is found by counting occurrences of@samp{\(} from the beginning of the whole regular expression. The firstsubexpression is numbered 1, the second 2, and so on. Only regularexpressions can have subexpressions---after a simple string search, theonly information available is about the entire match. Every successful search sets the match data. Therefore, you shouldquery the match data immediately after searching, before calling anyother function that might perform another search. Alternatively, youmay save and restore the match data (@pxref{Saving Match Data}) aroundthe call to functions that could perform another search. A search which fails may or may not alter the match data. In thepast, a failing search did not do this, but we may change it in thefuture. So don't try to rely on the value of the match data aftera failing search.@defun match-string count &optional in-stringThis function returns, as a string, the text matched in the last searchor match operation. It returns the entire text if @var{count} is zero,or just the portion corresponding to the @var{count}th parentheticalsubexpression, if @var{count} is positive.If the last such operation was done against a string with@code{string-match}, then you should pass the same string as theargument @var{in-string}. After a buffer search or match,you should omit @var{in-string} or pass @code{nil} for it; but youshould make sure that the current buffer when you call@code{match-string} is the one in which you did the searching ormatching.The value is @code{nil} if @var{count} is out of range, or for asubexpression inside a @samp{\|} alternative that wasn't used or arepetition that repeated zero times.@end defun@defun match-string-no-properties count &optional in-stringThis function is like @code{match-string} except that the resulthas no text properties.@end defun@defun match-beginning countThis function returns the position of the start of text matched by thelast regular expression searched for, or a subexpression of it.If @var{count} is zero, then the value is the position of the start ofthe entire match. Otherwise, @var{count} specifies a subexpression inthe regular expression, and the value of the function is the startingposition of the match for that subexpression.The value is @code{nil} for a subexpression inside a @samp{\|}alternative that wasn't used or a repetition that repeated zero times.@end defun@defun match-end countThis function is like @code{match-beginning} except that it returns theposition of the end of the match, rather than the position of thebeginning.@end defun Here is an example of using the match data, with a comment showing thepositions within the text:@example@group(string-match "\\(qu\\)\\(ick\\)" "The quick fox jumped quickly.") ;0123456789 @result{} 4@end group@group(match-string 0 "The quick fox jumped quickly.") @result{} "quick"(match-string 1 "The quick fox jumped quickly.") @result{} "qu"(match-string 2 "The quick fox jumped quickly.") @result{} "ick"@end group@group(match-beginning 1) ; @r{The beginning of the match} @result{} 4 ; @r{with @samp{qu} is at index 4.}@end group@group(match-beginning 2) ; @r{The beginning of the match} @result{} 6 ; @r{with @samp{ick} is at index 6.}@end group@group(match-end 1) ; @r{The end of the match} @result{} 6 ; @r{with @samp{qu} is at index 6.}(match-end 2) ; @r{The end of the match} @result{} 9 ; @r{with @samp{ick} is at index 9.}@end group@end example Here is another example. Point is initially located at the beginningof the line. Searching moves point to between the space and the word@samp{in}. The beginning of the entire match is at the 9th character ofthe buffer (@samp{T}), and the beginning of the match for the firstsubexpression is at the 13th character (@samp{c}).@example@group(list (re-search-forward "The \\(cat \\)") (match-beginning 0) (match-beginning 1)) @result{} (9 9 13)@end group@group---------- Buffer: foo ----------I read "The cat @point{}in the hat comes back" twice. ^ ^ 9 13---------- Buffer: foo ----------@end group@end example@noindent(In this case, the index returned is a buffer position; the firstcharacter of the buffer counts as 1.)@node Entire Match Data@subsection Accessing the Entire Match Data The functions @code{match-data} and @code{set-match-data} read orwrite the entire match data, all at once.@defun match-data &optional integers reuse reseatThis function returns a list of positions (markers or integers) thatrecord all the information on what text the last search matched.Element zero is the position of the beginning of the match for thewhole expression; element one is the position of the end of the matchfor the expression. The next two elements are the positions of thebeginning and end of the match for the first subexpression, and so on.In general, element@ifnottexnumber 2@var{n}@end ifnottex@texnumber {\mathsurround=0pt $2n$}@end texcorresponds to @code{(match-beginning @var{n})}; andelement@ifnottexnumber 2@var{n} + 1@end ifnottex@texnumber {\mathsurround=0pt $2n+1$}@end texcorresponds to @code{(match-end @var{n})}.Normally all the elements are markers or @code{nil}, but if@var{integers} is non-@code{nil}, that means to use integers insteadof markers. (In that case, the buffer itself is appended as anadditional element at the end of the list, to facilitate completerestoration of the match data.) If the last match was done on astring with @code{string-match}, then integers are always used,since markers can't point into a string.If @var{reuse} is non-@code{nil}, it should be a list. In that case,@code{match-data} stores the match data in @var{reuse}. That is,@var{reuse} is destructively modified. @var{reuse} does not need tohave the right length. If it is not long enough to contain the matchdata, it is extended. If it is too long, the length of @var{reuse}stays the same, but the elements that were not used are set to@code{nil}. The purpose of this feature is to reduce the need forgarbage collection.If @var{reseat} is non-@code{nil}, all markers on the @var{reuse} listare reseated to point to nowhere.As always, there must be no possibility of intervening searches betweenthe call to a search function and the call to @code{match-data} that isintended to access the match data for that search.@example@group(match-data) @result{} (#<marker at 9 in foo> #<marker at 17 in foo> #<marker at 13 in foo> #<marker at 17 in foo>)@end group@end example@end defun@defun set-match-data match-list &optional reseatThis function sets the match data from the elements of @var{match-list},which should be a list that was the value of a previous call to@code{match-data}. (More precisely, anything that has the same formatwill work.)If @var{match-list} refers to a buffer that doesn't exist, you don't getan error; that sets the match data in a meaningless but harmless way.If @var{reseat} is non-@code{nil}, all markers on the @var{match-list} listare reseated to point to nowhere.@findex store-match-data@code{store-match-data} is a semi-obsolete alias for @code{set-match-data}.@end defun@node Saving Match Data@subsection Saving and Restoring the Match Data When you call a function that may do a search, you may need to saveand restore the match data around that call, if you want to preserve thematch data from an earlier search for later use. Here is an examplethat shows the problem that arises if you fail to save the match data:@example@group(re-search-forward "The \\(cat \\)") @result{} 48(foo) ; @r{Perhaps @code{foo} does} ; @r{more searching.}(match-end 0) @result{} 61 ; @r{Unexpected result---not 48!}@end group@end example You can save and restore the match data with @code{save-match-data}:@defmac save-match-data body@dots{}This macro executes @var{body}, saving and restoring the matchdata around it. The return value is the value of the last form in@var{body}.@end defmac You could use @code{set-match-data} together with @code{match-data} toimitate the effect of the special form @code{save-match-data}. Here ishow:@example@group(let ((data (match-data))) (unwind-protect @dots{} ; @r{Ok to change the original match data.} (set-match-data data)))@end group@end example Emacs automatically saves and restores the match data when it runsprocess filter functions (@pxref{Filter Functions}) and processsentinels (@pxref{Sentinels}).@ignore Here is a function which restores the match data provided the bufferassociated with it still exists.@smallexample@group(defun restore-match-data (data)@c It is incorrect to split the first line of a doc string.@c If there's a problem here, it should be solved in some other way. "Restore the match data DATA unless the buffer is missing." (catch 'foo (let ((d data))@end group (while d (and (car d) (null (marker-buffer (car d)))@group ;; @file{match-data} @r{buffer is deleted.} (throw 'foo nil)) (setq d (cdr d))) (set-match-data data))))@end group@end smallexample@end ignore@node Search and Replace@section Search and Replace@cindex replacement If you want to find all matches for a regexp in part of the buffer,and replace them, the best way is to write an explicit loop using@code{re-search-forward} and @code{replace-match}, like this:@example(while (re-search-forward "foo[ \t]+bar" nil t) (replace-match "foobar"))@end example@noindent@xref{Replacing Match,, Replacing the Text that Matched}, for adescription of @code{replace-match}. However, replacing matches in a string is more complex, especiallyif you want to do it efficiently. So Emacs provides a function to dothis.@defun replace-regexp-in-string regexp rep string &optional fixedcase literal subexp startThis function copies @var{string} and searches it for matches for@var{regexp}, and replaces them with @var{rep}. It returns themodified copy. If @var{start} is non-@code{nil}, the search formatches starts at that index in @var{string}, so matches startingbefore that index are not changed.This function uses @code{replace-match} to do the replacement, and itpasses the optional arguments @var{fixedcase}, @var{literal} and@var{subexp} along to @code{replace-match}.Instead of a string, @var{rep} can be a function. In that case,@code{replace-regexp-in-string} calls @var{rep} for each match,passing the text of the match as its sole argument. It collects thevalue @var{rep} returns and passes that to @code{replace-match} as thereplacement string. The match-data at this point are the resultof matching @var{regexp} against a substring of @var{string}.@end defun If you want to write a command along the lines of @code{query-replace},you can use @code{perform-replace} to do the work.@defun perform-replace from-string replacements query-flag regexp-flag delimited-flag &optional repeat-count map start endThis function is the guts of @code{query-replace} and relatedcommands. It searches for occurrences of @var{from-string} in thetext between positions @var{start} and @var{end} and replaces some orall of them. If @var{start} is @code{nil} (or omitted), point is usedinstead, and the end of the buffer's accessible portion is used for@var{end}.If @var{query-flag} is @code{nil}, it replaces alloccurrences; otherwise, it asks the user what to do about each one.If @var{regexp-flag} is non-@code{nil}, then @var{from-string} isconsidered a regular expression; otherwise, it must match literally. If@var{delimited-flag} is non-@code{nil}, then only replacementssurrounded by word boundaries are considered.The argument @var{replacements} specifies what to replace occurrenceswith. If it is a string, that string is used. It can also be a list ofstrings, to be used in cyclic order.If @var{replacements} is a cons cell, @code{(@var{function}. @var{data})}, this means to call @var{function} after each match toget the replacement text. This function is called with two arguments:@var{data}, and the number of replacements already made.If @var{repeat-count} is non-@code{nil}, it should be an integer. Thenit specifies how many times to use each of the strings in the@var{replacements} list before advancing cyclically to the next one.If @var{from-string} contains upper-case letters, then@code{perform-replace} binds @code{case-fold-search} to @code{nil}, andit uses the @code{replacements} without altering the case of them.Normally, the keymap @code{query-replace-map} defines the possibleuser responses for queries. The argument @var{map}, ifnon-@code{nil}, specifies a keymap to use instead of@code{query-replace-map}.@end defun@defvar query-replace-mapThis variable holds a special keymap that defines the valid userresponses for @code{perform-replace} and the commands that use it, aswell as @code{y-or-n-p} and @code{map-y-or-n-p}. This map is unusualin two ways:@itemize @bullet@itemThe ``key bindings'' are not commands, just symbols that are meaningfulto the functions that use this map.@itemPrefix keys are not supported; each key binding must be for asingle-event key sequence. This is because the functions don't use@code{read-key-sequence} to get the input; instead, they read a singleevent and look it up ``by hand.''@end itemize@end defvarHere are the meaningful ``bindings'' for @code{query-replace-map}.Several of them are meaningful only for @code{query-replace} andfriends.@table @code@item actDo take the action being considered---in other words, ``yes.''@item skipDo not take action for this question---in other words, ``no.''@item exitAnswer this question ``no,'' and give up on the entire series ofquestions, assuming that the answers will be ``no.''@item act-and-exitAnswer this question ``yes,'' and give up on the entire series ofquestions, assuming that subsequent answers will be ``no.''@item act-and-showAnswer this question ``yes,'' but show the results---don't advance yetto the next question.@item automaticAnswer this question and all subsequent questions in the series with``yes,'' without further user interaction.@item backupMove back to the previous place that a question was asked about.@item editEnter a recursive edit to deal with this question---instead of anyother action that would normally be taken.@item delete-and-editDelete the text being considered, then enter a recursive edit to replaceit.@item recenterRedisplay and center the window, then ask the same question again.@item quitPerform a quit right away. Only @code{y-or-n-p} and related functionsuse this answer.@item helpDisplay some help, then ask again.@end table@node Standard Regexps@section Standard Regular Expressions Used in Editing@cindex regexps used standardly in editing@cindex standard regexps used in editing This section describes some variables that hold regular expressionsused for certain purposes in editing:@defvar page-delimiterThis is the regular expression describing line-beginnings that separatepages. The default value is @code{"^\014"} (i.e., @code{"^^L"} or@code{"^\C-l"}); this matches a line that starts with a formfeedcharacter.@end defvar The following two regular expressions should @emph{not} assume thematch always starts at the beginning of a line; they should not use@samp{^} to anchor the match. Most often, the paragraph commands docheck for a match only at the beginning of a line, which means that@samp{^} would be superfluous. When there is a nonzero left margin,they accept matches that start after the left margin. In that case, a@samp{^} would be incorrect. However, a @samp{^} is harmless in modeswhere a left margin is never used.@defvar paragraph-separateThis is the regular expression for recognizing the beginning of a linethat separates paragraphs. (If you change this, you may have tochange @code{paragraph-start} also.) The default value is@w{@code{"[@ \t\f]*$"}}, which matches a line that consists entirely ofspaces, tabs, and form feeds (after its left margin).@end defvar@defvar paragraph-startThis is the regular expression for recognizing the beginning of a linethat starts @emph{or} separates paragraphs. The default value is@w{@code{"\f\\|[ \t]*$"}}, which matches a line containing onlywhitespace or starting with a form feed (after its left margin).@end defvar@defvar sentence-endIf non-@code{nil}, the value should be a regular expression describingthe end of a sentence, including the whitespace following thesentence. (All paragraph boundaries also end sentences, regardless.)If the value is @code{nil}, the default, then the function@code{sentence-end} has to construct the regexp. That is why youshould always call the function @code{sentence-end} to obtain theregexp to be used to recognize the end of a sentence.@end defvar@defun sentence-endThis function returns the value of the variable @code{sentence-end},if non-@code{nil}. Otherwise it returns a default value based on thevalues of the variables @code{sentence-end-double-space}(@pxref{Definition of sentence-end-double-space}),@code{sentence-end-without-period} and@code{sentence-end-without-space}.@end defun@ignore arch-tag: c2573ca2-18aa-4839-93b8-924043ef831f@end ignore