This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Remove duplicate information and refer to other pods
[perl5.git] / pod / perlre.pod
CommitLineData
a0d0e21e 1=head1 NAME
d74e8afc 2X<regular expression> X<regex> X<regexp>
a0d0e21e
LW
3
4perlre - Perl regular expressions
5
6=head1 DESCRIPTION
7
5d458dd8 8This page describes the syntax of regular expressions in Perl.
91e0c79e 9
cc46d5f2 10If you haven't used regular expressions before, a quick-start
91e0c79e
MJD
11introduction is available in L<perlrequick>, and a longer tutorial
12introduction is available in L<perlretut>.
13
14For reference on how regular expressions are used in matching
15operations, plus various examples of the same, see discussions of
16C<m//>, C<s///>, C<qr//> and C<??> in L<perlop/"Regexp Quote-Like
17Operators">.
cb1a09d0 18
0d017f4d
WL
19
20=head2 Modifiers
21
19799a22 22Matching operations can have various modifiers. Modifiers
5a964f20 23that relate to the interpretation of the regular expression inside
19799a22 24are listed below. Modifiers that alter the way a regular expression
5d458dd8 25is used by Perl are detailed in L<perlop/"Regexp Quote-Like Operators"> and
1e66bd83 26L<perlop/"Gory details of parsing quoted constructs">.
a0d0e21e 27
55497cff 28=over 4
29
54310121 30=item m
d74e8afc 31X</m> X<regex, multiline> X<regexp, multiline> X<regular expression, multiline>
55497cff 32
33Treat string as multiple lines. That is, change "^" and "$" from matching
14218588 34the start or end of the string to matching the start or end of any
7f761169 35line anywhere within the string.
55497cff 36
54310121 37=item s
d74e8afc
ITB
38X</s> X<regex, single-line> X<regexp, single-line>
39X<regular expression, single-line>
55497cff 40
41Treat string as single line. That is, change "." to match any character
19799a22 42whatsoever, even a newline, which normally it would not match.
55497cff 43
34d67d80 44Used together, as C</ms>, they let the "." match any character whatsoever,
fb55449c 45while still allowing "^" and "$" to match, respectively, just after
19799a22 46and just before newlines within the string.
7b8d334a 47
87e95b7f
YO
48=item i
49X</i> X<regex, case-insensitive> X<regexp, case-insensitive>
50X<regular expression, case-insensitive>
51
52Do case-insensitive pattern matching.
53
54If C<use locale> is in effect, the case map is taken from the current
55locale. See L<perllocale>.
56
54310121 57=item x
d74e8afc 58X</x>
55497cff 59
60Extend your pattern's legibility by permitting whitespace and comments.
61
87e95b7f
YO
62=item p
63X</p> X<regex, preserve> X<regexp, preserve>
64
632a1772 65Preserve the string matched such that ${^PREMATCH}, ${^MATCH}, and
87e95b7f
YO
66${^POSTMATCH} are available for use after matching.
67
e2e6bec7
DN
68=item g and c
69X</g> X</c>
70
71Global matching, and keep the Current position after failed matching.
72Unlike i, m, s and x, these two flags affect the way the regex is used
73rather than the regex itself. See
74L<perlretut/"Using regular expressions in Perl"> for further explanation
75of the g and c modifiers.
76
55497cff 77=back
a0d0e21e
LW
78
79These are usually written as "the C</x> modifier", even though the delimiter
14218588 80in question might not really be a slash. Any of these
a0d0e21e 81modifiers may also be embedded within the regular expression itself using
14218588 82the C<(?...)> construct. See below.
a0d0e21e 83
4633a7c4 84The C</x> modifier itself needs a little more explanation. It tells
7b059540 85the regular expression parser to ignore most whitespace that is neither
55497cff 86backslashed nor within a character class. You can use this to break up
4633a7c4 87your regular expression into (slightly) more readable parts. The C<#>
54310121 88character is also treated as a metacharacter introducing a comment,
55497cff 89just as in ordinary Perl code. This also means that if you want real
14218588 90whitespace or C<#> characters in the pattern (outside a character
f9a3ff1a 91class, where they are unaffected by C</x>), then you'll either have to
7b059540
KW
92escape them (using backslashes or C<\Q...\E>) or encode them using octal,
93hex, or C<\N{}> escapes. Taken together, these features go a long way towards
8933a740
RGS
94making Perl's regular expressions more readable. Note that you have to
95be careful not to include the pattern delimiter in the comment--perl has
96no way of knowing you did not intend to close the pattern early. See
97the C-comment deletion code in L<perlop>. Also note that anything inside
7651b971
KW
98a C<\Q...\E> stays unaffected by C</x>. And note that C</x> doesn't affect
99whether space interpretation within a single multi-character construct. For
100example in C<\x{...}>, regardless of the C</x> modifier, there can be no
101spaces. Same for a L<quantifier|Quantifiers> such as C<{3}> or
f9e949fd
KW
102C<{5,}>. Similarly, C<(?:...)> can't have a space between the C<?> and C<:>,
103but can between the C<(> and C<?>. Within any delimiters for such a
104construct, allowed spaces are not affected by C</x>, and depend on the
105construct. For example, C<\x{...}> can't have spaces because hexadecimal
106numbers don't have spaces in them. But, Unicode properties can have spaces, so
107in C<\p{...}> there can be spaces that follow the Unicode rules, for which see
108L<perluniprops.pod/Properties accessible through \p{} and \P{}>.
d74e8afc 109X</x>
a0d0e21e
LW
110
111=head2 Regular Expressions
112
04838cea
RGS
113=head3 Metacharacters
114
384f06ae 115The patterns used in Perl pattern matching evolved from those supplied in
14218588 116the Version 8 regex routines. (The routines are derived
19799a22
GS
117(distantly) from Henry Spencer's freely redistributable reimplementation
118of the V8 routines.) See L<Version 8 Regular Expressions> for
119details.
a0d0e21e
LW
120
121In particular the following metacharacters have their standard I<egrep>-ish
122meanings:
d74e8afc
ITB
123X<metacharacter>
124X<\> X<^> X<.> X<$> X<|> X<(> X<()> X<[> X<[]>
125
a0d0e21e 126
54310121 127 \ Quote the next metacharacter
a0d0e21e
LW
128 ^ Match the beginning of the line
129 . Match any character (except newline)
c07a80fd 130 $ Match the end of the line (or before newline at the end)
a0d0e21e
LW
131 | Alternation
132 () Grouping
133 [] Character class
134
14218588
GS
135By default, the "^" character is guaranteed to match only the
136beginning of the string, the "$" character only the end (or before the
137newline at the end), and Perl does certain optimizations with the
a0d0e21e
LW
138assumption that the string contains only one line. Embedded newlines
139will not be matched by "^" or "$". You may, however, wish to treat a
4a6725af 140string as a multi-line buffer, such that the "^" will match after any
0d520e8e
YO
141newline within the string (except if the newline is the last character in
142the string), and "$" will match before any newline. At the
a0d0e21e
LW
143cost of a little more overhead, you can do this by using the /m modifier
144on the pattern match operator. (Older programs did this by setting C<$*>,
f02c194e 145but this practice has been removed in perl 5.9.)
d74e8afc 146X<^> X<$> X</m>
a0d0e21e 147
14218588 148To simplify multi-line substitutions, the "." character never matches a
55497cff 149newline unless you use the C</s> modifier, which in effect tells Perl to pretend
f02c194e 150the string is a single line--even if it isn't.
d74e8afc 151X<.> X</s>
a0d0e21e 152
04838cea
RGS
153=head3 Quantifiers
154
a0d0e21e 155The following standard quantifiers are recognized:
d74e8afc 156X<metacharacter> X<quantifier> X<*> X<+> X<?> X<{n}> X<{n,}> X<{n,m}>
a0d0e21e
LW
157
158 * Match 0 or more times
159 + Match 1 or more times
160 ? Match 1 or 0 times
161 {n} Match exactly n times
162 {n,} Match at least n times
163 {n,m} Match at least n but not more than m times
164
165(If a curly bracket occurs in any other context, it is treated
b975c076 166as a regular character. In particular, the lower bound
527e91da
BB
167is not optional.) The "*" quantifier is equivalent to C<{0,}>, the "+"
168quantifier to C<{1,}>, and the "?" quantifier to C<{0,1}>. n and m are limited
d0b16107 169to non-negative integral values less than a preset limit defined when perl is built.
9c79236d
GS
170This is usually 32766 on the most common platforms. The actual limit can
171be seen in the error message generated by code such as this:
172
820475bd 173 $_ **= $_ , / {$_} / for 2 .. 42;
a0d0e21e 174
54310121 175By default, a quantified subpattern is "greedy", that is, it will match as
176many times as possible (given a particular starting location) while still
177allowing the rest of the pattern to match. If you want it to match the
178minimum number of times possible, follow the quantifier with a "?". Note
179that the meanings don't change, just the "greediness":
0d017f4d 180X<metacharacter> X<greedy> X<greediness>
d74e8afc 181X<?> X<*?> X<+?> X<??> X<{n}?> X<{n,}?> X<{n,m}?>
a0d0e21e 182
0d017f4d
WL
183 *? Match 0 or more times, not greedily
184 +? Match 1 or more times, not greedily
185 ?? Match 0 or 1 time, not greedily
186 {n}? Match exactly n times, not greedily
187 {n,}? Match at least n times, not greedily
188 {n,m}? Match at least n but not more than m times, not greedily
a0d0e21e 189
b9b4dddf
YO
190By default, when a quantified subpattern does not allow the rest of the
191overall pattern to match, Perl will backtrack. However, this behaviour is
0d017f4d 192sometimes undesirable. Thus Perl provides the "possessive" quantifier form
b9b4dddf
YO
193as well.
194
0d017f4d
WL
195 *+ Match 0 or more times and give nothing back
196 ++ Match 1 or more times and give nothing back
197 ?+ Match 0 or 1 time and give nothing back
b9b4dddf 198 {n}+ Match exactly n times and give nothing back (redundant)
04838cea
RGS
199 {n,}+ Match at least n times and give nothing back
200 {n,m}+ Match at least n but not more than m times and give nothing back
b9b4dddf
YO
201
202For instance,
203
204 'aaaa' =~ /a++a/
205
206will never match, as the C<a++> will gobble up all the C<a>'s in the
207string and won't leave any for the remaining part of the pattern. This
208feature can be extremely useful to give perl hints about where it
209shouldn't backtrack. For instance, the typical "match a double-quoted
210string" problem can be most efficiently performed when written as:
211
212 /"(?:[^"\\]++|\\.)*+"/
213
0d017f4d 214as we know that if the final quote does not match, backtracking will not
b9b4dddf
YO
215help. See the independent subexpression C<< (?>...) >> for more details;
216possessive quantifiers are just syntactic sugar for that construct. For
217instance the above example could also be written as follows:
218
219 /"(?>(?:(?>[^"\\]+)|\\.)*)"/
220
04838cea
RGS
221=head3 Escape sequences
222
5f05dabc 223Because patterns are processed as double quoted strings, the following
a0d0e21e 224also work:
0d017f4d 225X<\t> X<\n> X<\r> X<\f> X<\e> X<\a> X<\l> X<\u> X<\L> X<\U> X<\E> X<\Q>
d0b16107 226X<\0> X<\c> X<\N{}> X<\x>
a0d0e21e 227
0f36ee90 228 \t tab (HT, TAB)
229 \n newline (LF, NL)
230 \r return (CR)
231 \f form feed (FF)
232 \a alarm (bell) (BEL)
233 \e escape (think troff) (ESC)
0d017f4d
WL
234 \033 octal char (example: ESC)
235 \x1B hex char (example: ESC)
196ac2fc 236 \x{263a} long hex char (example: Unicode SMILEY)
0d017f4d 237 \cK control char (example: VT)
196ac2fc 238 \N{name} named Unicode character
e526e8bb 239 \N{U+263D} Unicode character (example: FIRST QUARTER MOON)
cb1a09d0
AD
240 \l lowercase next char (think vi)
241 \u uppercase next char (think vi)
242 \L lowercase till \E (think vi)
243 \U uppercase till \E (think vi)
244 \E end case modification (think vi)
5a964f20 245 \Q quote (disable) pattern metacharacters till \E
a0d0e21e 246
a034a98d 247If C<use locale> is in effect, the case map used by C<\l>, C<\L>, C<\u>
423cee85 248and C<\U> is taken from the current locale. See L<perllocale>. For
4a2d328f 249documentation of C<\N{name}>, see L<charnames>.
a034a98d 250
1d2dff63
GS
251You cannot include a literal C<$> or C<@> within a C<\Q> sequence.
252An unescaped C<$> or C<@> interpolates the corresponding variable,
253while escaping will cause the literal string C<\$> to be matched.
254You'll need to write something like C<m/\Quser\E\@\Qhost/>.
255
e1d1eefb 256=head3 Character Classes and other Special Escapes
04838cea 257
a0d0e21e 258In addition, Perl defines the following:
d0b16107 259X<\g> X<\k> X<\K> X<backreference>
a0d0e21e 260
81714fb9
YO
261 \w Match a "word" character (alphanumeric plus "_")
262 \W Match a non-"word" character
263 \s Match a whitespace character
264 \S Match a non-whitespace character
265 \d Match a digit character
266 \D Match a non-digit character
267 \pP Match P, named property. Use \p{Prop} for longer names.
268 \PP Match non-P
0111a78f 269 \X Match Unicode "eXtended grapheme cluster"
81714fb9
YO
270 \C Match a single C char (octet) even under Unicode.
271 NOTE: breaks up characters into their UTF-8 bytes,
272 so you may end up with malformed pieces of UTF-8.
273 Unsupported in lookbehind.
5d458dd8 274 \1 Backreference to a specific group.
c74340f9 275 '1' may actually be any positive integer.
2bf803e2
YO
276 \g1 Backreference to a specific or previous group,
277 \g{-1} number may be negative indicating a previous buffer and may
278 optionally be wrapped in curly brackets for safer parsing.
1f1031fe 279 \g{name} Named backreference
81714fb9 280 \k<name> Named backreference
ee9b8eae 281 \K Keep the stuff left of the \K, don't include it in $&
b3b85878 282 \N Any character but \n (experimental)
e1d1eefb
YO
283 \v Vertical whitespace
284 \V Not vertical whitespace
285 \h Horizontal whitespace
286 \H Not horizontal whitespace
2ddf2931 287 \R Linebreak
a0d0e21e 288
d0b16107
KW
289See L<perlrecharclass/Backslashed sequences> for details on
290on C<\w>, C<\W>, C<\s>, C<\S>, C<\d>, C<\D>, C<\p>, C<\P>, C<\N>, C<\v>, C<\V>,
291C<\h>, and C<\H>.
292See L<perlrebackslash/Misc> for details on C<\R> and C<\X>.
e1d1eefb 293
df225385 294Note that C<\N> has two meanings. When of the form C<\N{NAME}>, it matches the
e526e8bb
KW
295character whose name is C<NAME>; and similarly when of the form
296C<\N{U+I<wide hex char>}>, it matches the character whose Unicode ordinal is
297I<wide hex char>. Otherwise it matches any character but C<\n>.
df225385 298
b8c5462f 299The POSIX character class syntax
d74e8afc 300X<character class>
b8c5462f 301
820475bd 302 [:class:]
b8c5462f 303
0d017f4d 304is also available. Note that the C<[> and C<]> brackets are I<literal>;
5496314a
SP
305they must always be used within a character class expression.
306
307 # this is correct:
308 $string =~ /[[:alpha:]]/;
309
310 # this is not, and will generate a warning:
311 $string =~ /[:alpha:]/;
312
d0b16107
KW
313The following Posix-style character classes are available:
314
315 [[:alpha:]] Any alphabetical character.
316 [[:alnum:]] Any alphanumerical character.
317 [[:ascii:]] Any character in the ASCII character set.
318 [[:blank:]] A GNU extension, equal to a space or a horizontal tab
319 [[:cntrl:]] Any control character.
320 [[:digit:]] Any decimal digit, equivalent to "\d".
321 [[:graph:]] Any printable character, excluding a space.
322 [[:lower:]] Any lowercase character.
323 [[:print:]] Any printable character, including a space.
324 [[:punct:]] Any graphical character excluding "word" characters.
325 [[:space:]] Any whitespace character. "\s" plus the vertical tab ("\cK").
326 [[:upper:]] Any uppercase character.
327 [[:word:]] A Perl extension, equivalent to "\w".
328 [[:xdigit:]] Any hexadecimal digit.
b8c5462f
JH
329
330You can negate the [::] character classes by prefixing the class name
d0b16107 331with a '^'. This is a Perl extension.
93733859 332
d0b16107 333The POSIX character classes
54c18d04
MK
334[.cc.] and [=cc=] are recognized but B<not> supported and trying to
335use them will cause an error.
b8c5462f 336
d0b16107
KW
337Details on POSIX character classes are in
338L<perlrecharclass/Posix Character Classes>.
339
04838cea
RGS
340=head3 Assertions
341
a0d0e21e 342Perl defines the following zero-width assertions:
d74e8afc
ITB
343X<zero-width assertion> X<assertion> X<regex, zero-width assertion>
344X<regexp, zero-width assertion>
345X<regular expression, zero-width assertion>
346X<\b> X<\B> X<\A> X<\Z> X<\z> X<\G>
a0d0e21e
LW
347
348 \b Match a word boundary
0d017f4d 349 \B Match except at a word boundary
b85d18e9
IZ
350 \A Match only at beginning of string
351 \Z Match only at end of string, or before newline at the end
352 \z Match only at end of string
9da458fc
IZ
353 \G Match only at pos() (e.g. at the end-of-match position
354 of prior m//g)
a0d0e21e 355
14218588 356A word boundary (C<\b>) is a spot between two characters
19799a22
GS
357that has a C<\w> on one side of it and a C<\W> on the other side
358of it (in either order), counting the imaginary characters off the
359beginning and end of the string as matching a C<\W>. (Within
360character classes C<\b> represents backspace rather than a word
361boundary, just as it normally does in any double-quoted string.)
362The C<\A> and C<\Z> are just like "^" and "$", except that they
363won't match multiple times when the C</m> modifier is used, while
364"^" and "$" will match at every internal line boundary. To match
365the actual end of the string and not ignore an optional trailing
366newline, use C<\z>.
d74e8afc 367X<\b> X<\A> X<\Z> X<\z> X</m>
19799a22
GS
368
369The C<\G> assertion can be used to chain global matches (using
370C<m//g>), as described in L<perlop/"Regexp Quote-Like Operators">.
371It is also useful when writing C<lex>-like scanners, when you have
372several patterns that you want to match against consequent substrings
373of your string, see the previous reference. The actual location
374where C<\G> will match can also be influenced by using C<pos()> as
58e23c8d
YO
375an lvalue: see L<perlfunc/pos>. Note that the rule for zero-length
376matches is modified somewhat, in that contents to the left of C<\G> is
377not counted when determining the length of the match. Thus the following
378will not match forever:
d74e8afc 379X<\G>
c47ff5f1 380
58e23c8d
YO
381 $str = 'ABC';
382 pos($str) = 1;
383 while (/.\G/g) {
384 print $&;
385 }
386
387It will print 'A' and then terminate, as it considers the match to
388be zero-width, and thus will not match at the same position twice in a
389row.
390
391It is worth noting that C<\G> improperly used can result in an infinite
392loop. Take care when using patterns that include C<\G> in an alternation.
393
04838cea
RGS
394=head3 Capture buffers
395
0d017f4d
WL
396The bracketing construct C<( ... )> creates capture buffers. To refer
397to the current contents of a buffer later on, within the same pattern,
398use \1 for the first, \2 for the second, and so on.
399Outside the match use "$" instead of "\". (The
81714fb9 400\<digit> notation works in certain circumstances outside
14218588
GS
401the match. See the warning below about \1 vs $1 for details.)
402Referring back to another part of the match is called a
403I<backreference>.
d74e8afc
ITB
404X<regex, capture buffer> X<regexp, capture buffer>
405X<regular expression, capture buffer> X<backreference>
14218588
GS
406
407There is no limit to the number of captured substrings that you may
408use. However Perl also uses \10, \11, etc. as aliases for \010,
fb55449c
JH
409\011, etc. (Recall that 0 means octal, so \011 is the character at
410number 9 in your coded character set; which would be the 10th character,
81714fb9
YO
411a horizontal tab under ASCII.) Perl resolves this
412ambiguity by interpreting \10 as a backreference only if at least 10
413left parentheses have opened before it. Likewise \11 is a
414backreference only if at least 11 left parentheses have opened
415before it. And so on. \1 through \9 are always interpreted as
5624f11d 416backreferences.
40863337
ML
417If the bracketing group did not match, the associated backreference won't
418match either. (This can happen if the bracketing group is optional, or
419in a different branch of an alternation.)
420
1f1031fe 421X<\g{1}> X<\g{-1}> X<\g{name}> X<relative backreference> X<named backreference>
2bf803e2 422In order to provide a safer and easier way to construct patterns using
99d59c4d
RGS
423backreferences, Perl provides the C<\g{N}> notation (starting with perl
4245.10.0). The curly brackets are optional, however omitting them is less
425safe as the meaning of the pattern can be changed by text (such as digits)
426following it. When N is a positive integer the C<\g{N}> notation is
427exactly equivalent to using normal backreferences. When N is a negative
428integer then it is a relative backreference referring to the previous N'th
429capturing group. When the bracket form is used and N is not an integer, it
430is treated as a reference to a named buffer.
2bf803e2
YO
431
432Thus C<\g{-1}> refers to the last buffer, C<\g{-2}> refers to the
433buffer before that. For example:
5624f11d
YO
434
435 /
436 (Y) # buffer 1
437 ( # buffer 2
438 (X) # buffer 3
2bf803e2
YO
439 \g{-1} # backref to buffer 3
440 \g{-3} # backref to buffer 1
5624f11d
YO
441 )
442 /x
443
2bf803e2 444and would match the same as C</(Y) ( (X) \3 \1 )/x>.
14218588 445
99d59c4d 446Additionally, as of Perl 5.10.0 you may use named capture buffers and named
1f1031fe 447backreferences. The notation is C<< (?<name>...) >> to declare and C<< \k<name> >>
0d017f4d
WL
448to reference. You may also use apostrophes instead of angle brackets to delimit the
449name; and you may use the bracketed C<< \g{name} >> backreference syntax.
450It's possible to refer to a named capture buffer by absolute and relative number as well.
451Outside the pattern, a named capture buffer is available via the C<%+> hash.
452When different buffers within the same pattern have the same name, C<$+{name}>
453and C<< \k<name> >> refer to the leftmost defined group. (Thus it's possible
454to do things with named capture buffers that would otherwise require C<(??{})>
455code to accomplish.)
456X<named capture buffer> X<regular expression, named capture buffer>
64c5a566 457X<%+> X<$+{name}> X<< \k<name> >>
81714fb9 458
14218588 459Examples:
a0d0e21e
LW
460
461 s/^([^ ]*) *([^ ]*)/$2 $1/; # swap first two words
462
81714fb9
YO
463 /(.)\1/ # find first doubled char
464 and print "'$1' is the first doubled character\n";
465
466 /(?<char>.)\k<char>/ # ... a different way
467 and print "'$+{char}' is the first doubled character\n";
468
0d017f4d 469 /(?'char'.)\1/ # ... mix and match
81714fb9 470 and print "'$1' is the first doubled character\n";
c47ff5f1 471
14218588 472 if (/Time: (..):(..):(..)/) { # parse out values
a0d0e21e
LW
473 $hours = $1;
474 $minutes = $2;
475 $seconds = $3;
476 }
c47ff5f1 477
14218588
GS
478Several special variables also refer back to portions of the previous
479match. C<$+> returns whatever the last bracket match matched.
480C<$&> returns the entire matched string. (At one point C<$0> did
481also, but now it returns the name of the program.) C<$`> returns
77ea4f6d
JV
482everything before the matched string. C<$'> returns everything
483after the matched string. And C<$^N> contains whatever was matched by
484the most-recently closed group (submatch). C<$^N> can be used in
485extended patterns (see below), for example to assign a submatch to a
81714fb9 486variable.
d74e8afc 487X<$+> X<$^N> X<$&> X<$`> X<$'>
14218588 488
665e98b9 489The numbered match variables ($1, $2, $3, etc.) and the related punctuation
77ea4f6d 490set (C<$+>, C<$&>, C<$`>, C<$'>, and C<$^N>) are all dynamically scoped
14218588
GS
491until the end of the enclosing block or until the next successful
492match, whichever comes first. (See L<perlsyn/"Compound Statements">.)
d74e8afc
ITB
493X<$+> X<$^N> X<$&> X<$`> X<$'>
494X<$1> X<$2> X<$3> X<$4> X<$5> X<$6> X<$7> X<$8> X<$9>
495
14218588 496
0d017f4d 497B<NOTE>: Failed matches in Perl do not reset the match variables,
5146ce24 498which makes it easier to write code that tests for a series of more
665e98b9
JH
499specific cases and remembers the best match.
500
14218588
GS
501B<WARNING>: Once Perl sees that you need one of C<$&>, C<$`>, or
502C<$'> anywhere in the program, it has to provide them for every
503pattern match. This may substantially slow your program. Perl
504uses the same mechanism to produce $1, $2, etc, so you also pay a
505price for each pattern that contains capturing parentheses. (To
506avoid this cost while retaining the grouping behaviour, use the
507extended regular expression C<(?: ... )> instead.) But if you never
508use C<$&>, C<$`> or C<$'>, then patterns I<without> capturing
509parentheses will not be penalized. So avoid C<$&>, C<$'>, and C<$`>
510if you can, but if you can't (and some algorithms really appreciate
511them), once you've used them once, use them at will, because you've
512already paid the price. As of 5.005, C<$&> is not so costly as the
513other two.
d74e8afc 514X<$&> X<$`> X<$'>
68dc0745 515
99d59c4d 516As a workaround for this problem, Perl 5.10.0 introduces C<${^PREMATCH}>,
cde0cee5
YO
517C<${^MATCH}> and C<${^POSTMATCH}>, which are equivalent to C<$`>, C<$&>
518and C<$'>, B<except> that they are only guaranteed to be defined after a
87e95b7f 519successful match that was executed with the C</p> (preserve) modifier.
cde0cee5
YO
520The use of these variables incurs no global performance penalty, unlike
521their punctuation char equivalents, however at the trade-off that you
522have to tell perl when you want to use them.
87e95b7f 523X</p> X<p modifier>
cde0cee5 524
19799a22
GS
525Backslashed metacharacters in Perl are alphanumeric, such as C<\b>,
526C<\w>, C<\n>. Unlike some other regular expression languages, there
527are no backslashed symbols that aren't alphanumeric. So anything
c47ff5f1 528that looks like \\, \(, \), \<, \>, \{, or \} is always
19799a22
GS
529interpreted as a literal character, not a metacharacter. This was
530once used in a common idiom to disable or quote the special meanings
531of regular expression metacharacters in a string that you want to
36bbe248 532use for a pattern. Simply quote all non-"word" characters:
a0d0e21e
LW
533
534 $pattern =~ s/(\W)/\\$1/g;
535
f1cbbd6e 536(If C<use locale> is set, then this depends on the current locale.)
14218588
GS
537Today it is more common to use the quotemeta() function or the C<\Q>
538metaquoting escape sequence to disable all metacharacters' special
539meanings like this:
a0d0e21e
LW
540
541 /$unquoted\Q$quoted\E$unquoted/
542
9da458fc
IZ
543Beware that if you put literal backslashes (those not inside
544interpolated variables) between C<\Q> and C<\E>, double-quotish
545backslash interpolation may lead to confusing results. If you
546I<need> to use literal backslashes within C<\Q...\E>,
547consult L<perlop/"Gory details of parsing quoted constructs">.
548
19799a22
GS
549=head2 Extended Patterns
550
14218588
GS
551Perl also defines a consistent extension syntax for features not
552found in standard tools like B<awk> and B<lex>. The syntax is a
553pair of parentheses with a question mark as the first thing within
554the parentheses. The character after the question mark indicates
555the extension.
19799a22 556
14218588
GS
557The stability of these extensions varies widely. Some have been
558part of the core language for many years. Others are experimental
559and may change without warning or be completely removed. Check
560the documentation on an individual feature to verify its current
561status.
19799a22 562
14218588
GS
563A question mark was chosen for this and for the minimal-matching
564construct because 1) question marks are rare in older regular
565expressions, and 2) whenever you see one, you should stop and
566"question" exactly what is going on. That's psychology...
a0d0e21e
LW
567
568=over 10
569
cc6b7395 570=item C<(?#text)>
d74e8afc 571X<(?#)>
a0d0e21e 572
14218588 573A comment. The text is ignored. If the C</x> modifier enables
19799a22 574whitespace formatting, a simple C<#> will suffice. Note that Perl closes
259138e3
GS
575the comment as soon as it sees a C<)>, so there is no way to put a literal
576C<)> in the comment.
a0d0e21e 577
f7819f85 578=item C<(?pimsx-imsx)>
d74e8afc 579X<(?)>
19799a22 580
0b6d1084
JH
581One or more embedded pattern-match modifiers, to be turned on (or
582turned off, if preceded by C<->) for the remainder of the pattern or
583the remainder of the enclosing pattern group (if any). This is
584particularly useful for dynamic patterns, such as those read in from a
0d017f4d
WL
585configuration file, taken from an argument, or specified in a table
586somewhere. Consider the case where some patterns want to be case
587sensitive and some do not: The case insensitive ones merely need to
588include C<(?i)> at the front of the pattern. For example:
19799a22
GS
589
590 $pattern = "foobar";
5d458dd8 591 if ( /$pattern/i ) { }
19799a22
GS
592
593 # more flexible:
594
595 $pattern = "(?i)foobar";
5d458dd8 596 if ( /$pattern/ ) { }
19799a22 597
0b6d1084 598These modifiers are restored at the end of the enclosing group. For example,
19799a22
GS
599
600 ( (?i) blah ) \s+ \1
601
0d017f4d
WL
602will match C<blah> in any case, some spaces, and an exact (I<including the case>!)
603repetition of the previous word, assuming the C</x> modifier, and no C</i>
604modifier outside this group.
19799a22 605
8eb5594e
DR
606These modifiers do not carry over into named subpatterns called in the
607enclosing group. In other words, a pattern such as C<((?i)(&NAME))> does not
608change the case-sensitivity of the "NAME" pattern.
609
5530442b 610Note that the C<p> modifier is special in that it can only be enabled,
cde0cee5 611not disabled, and that its presence anywhere in a pattern has a global
5530442b 612effect. Thus C<(?-p)> and C<(?-p:...)> are meaningless and will warn
cde0cee5
YO
613when executed under C<use warnings>.
614
5a964f20 615=item C<(?:pattern)>
d74e8afc 616X<(?:)>
a0d0e21e 617
ca9dfc88
IZ
618=item C<(?imsx-imsx:pattern)>
619
5a964f20
TC
620This is for clustering, not capturing; it groups subexpressions like
621"()", but doesn't make backreferences as "()" does. So
a0d0e21e 622
5a964f20 623 @fields = split(/\b(?:a|b|c)\b/)
a0d0e21e
LW
624
625is like
626
5a964f20 627 @fields = split(/\b(a|b|c)\b/)
a0d0e21e 628
19799a22
GS
629but doesn't spit out extra fields. It's also cheaper not to capture
630characters if you don't need to.
a0d0e21e 631
19799a22 632Any letters between C<?> and C<:> act as flags modifiers as with
5d458dd8 633C<(?imsx-imsx)>. For example,
ca9dfc88
IZ
634
635 /(?s-i:more.*than).*million/i
636
14218588 637is equivalent to the more verbose
ca9dfc88
IZ
638
639 /(?:(?s-i)more.*than).*million/i
640
594d7033
YO
641=item C<(?|pattern)>
642X<(?|)> X<Branch reset>
643
644This is the "branch reset" pattern, which has the special property
645that the capture buffers are numbered from the same starting point
99d59c4d 646in each alternation branch. It is available starting from perl 5.10.0.
4deaaa80 647
693596a8
RGS
648Capture buffers are numbered from left to right, but inside this
649construct the numbering is restarted for each branch.
4deaaa80
PJ
650
651The numbering within each branch will be as normal, and any buffers
652following this construct will be numbered as though the construct
653contained only one branch, that being the one with the most capture
654buffers in it.
655
656This construct will be useful when you want to capture one of a
657number of alternative matches.
658
659Consider the following pattern. The numbers underneath show in
660which buffer the captured content will be stored.
594d7033
YO
661
662
663 # before ---------------branch-reset----------- after
664 / ( a ) (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x
665 # 1 2 2 3 2 3 4
666
ab106183
A
667Be careful when using the branch reset pattern in combination with
668named captures. Named captures are implemented as being aliases to
669numbered buffers holding the captures, and that interferes with the
670implementation of the branch reset pattern. If you are using named
671captures in a branch reset pattern, it's best to use the same names,
672in the same order, in each of the alternations:
673
674 /(?| (?<a> x ) (?<b> y )
675 | (?<a> z ) (?<b> w )) /x
676
677Not doing so may lead to surprises:
678
679 "12" =~ /(?| (?<a> \d+ ) | (?<b> \D+))/x;
680 say $+ {a}; # Prints '12'
681 say $+ {b}; # *Also* prints '12'.
682
683The problem here is that both the buffer named C<< a >> and the buffer
684named C<< b >> are aliases for the buffer belonging to C<< $1 >>.
90a18110 685
ee9b8eae
YO
686=item Look-Around Assertions
687X<look-around assertion> X<lookaround assertion> X<look-around> X<lookaround>
688
689Look-around assertions are zero width patterns which match a specific
690pattern without including it in C<$&>. Positive assertions match when
691their subpattern matches, negative assertions match when their subpattern
692fails. Look-behind matches text up to the current match position,
693look-ahead matches text following the current match position.
694
695=over 4
696
5a964f20 697=item C<(?=pattern)>
d74e8afc 698X<(?=)> X<look-ahead, positive> X<lookahead, positive>
a0d0e21e 699
19799a22 700A zero-width positive look-ahead assertion. For example, C</\w+(?=\t)/>
a0d0e21e
LW
701matches a word followed by a tab, without including the tab in C<$&>.
702
5a964f20 703=item C<(?!pattern)>
d74e8afc 704X<(?!)> X<look-ahead, negative> X<lookahead, negative>
a0d0e21e 705
19799a22 706A zero-width negative look-ahead assertion. For example C</foo(?!bar)/>
a0d0e21e 707matches any occurrence of "foo" that isn't followed by "bar". Note
19799a22
GS
708however that look-ahead and look-behind are NOT the same thing. You cannot
709use this for look-behind.
7b8d334a 710
5a964f20 711If you are looking for a "bar" that isn't preceded by a "foo", C</(?!foo)bar/>
7b8d334a
GS
712will not do what you want. That's because the C<(?!foo)> is just saying that
713the next thing cannot be "foo"--and it's not, it's a "bar", so "foobar" will
714match. You would have to do something like C</(?!foo)...bar/> for that. We
715say "like" because there's the case of your "bar" not having three characters
716before it. You could cover that this way: C</(?:(?!foo)...|^.{0,2})bar/>.
717Sometimes it's still easier just to say:
a0d0e21e 718
a3cb178b 719 if (/bar/ && $` !~ /foo$/)
a0d0e21e 720
19799a22 721For look-behind see below.
c277df42 722
ee9b8eae
YO
723=item C<(?<=pattern)> C<\K>
724X<(?<=)> X<look-behind, positive> X<lookbehind, positive> X<\K>
c277df42 725
c47ff5f1 726A zero-width positive look-behind assertion. For example, C</(?<=\t)\w+/>
19799a22
GS
727matches a word that follows a tab, without including the tab in C<$&>.
728Works only for fixed-width look-behind.
c277df42 729
ee9b8eae
YO
730There is a special form of this construct, called C<\K>, which causes the
731regex engine to "keep" everything it had matched prior to the C<\K> and
732not include it in C<$&>. This effectively provides variable length
733look-behind. The use of C<\K> inside of another look-around assertion
734is allowed, but the behaviour is currently not well defined.
735
c62285ac 736For various reasons C<\K> may be significantly more efficient than the
ee9b8eae
YO
737equivalent C<< (?<=...) >> construct, and it is especially useful in
738situations where you want to efficiently remove something following
739something else in a string. For instance
740
741 s/(foo)bar/$1/g;
742
743can be rewritten as the much more efficient
744
745 s/foo\Kbar//g;
746
5a964f20 747=item C<(?<!pattern)>
d74e8afc 748X<(?<!)> X<look-behind, negative> X<lookbehind, negative>
c277df42 749
19799a22
GS
750A zero-width negative look-behind assertion. For example C</(?<!bar)foo/>
751matches any occurrence of "foo" that does not follow "bar". Works
752only for fixed-width look-behind.
c277df42 753
ee9b8eae
YO
754=back
755
81714fb9
YO
756=item C<(?'NAME'pattern)>
757
758=item C<< (?<NAME>pattern) >>
759X<< (?<NAME>) >> X<(?'NAME')> X<named capture> X<capture>
760
761A named capture buffer. Identical in every respect to normal capturing
90a18110
RGS
762parentheses C<()> but for the additional fact that C<%+> or C<%-> may be
763used after a successful match to refer to a named buffer. See C<perlvar>
764for more details on the C<%+> and C<%-> hashes.
81714fb9
YO
765
766If multiple distinct capture buffers have the same name then the
767$+{NAME} will refer to the leftmost defined buffer in the match.
768
0d017f4d 769The forms C<(?'NAME'pattern)> and C<< (?<NAME>pattern) >> are equivalent.
81714fb9
YO
770
771B<NOTE:> While the notation of this construct is the same as the similar
0d017f4d 772function in .NET regexes, the behavior is not. In Perl the buffers are
81714fb9
YO
773numbered sequentially regardless of being named or not. Thus in the
774pattern
775
776 /(x)(?<foo>y)(z)/
777
778$+{foo} will be the same as $2, and $3 will contain 'z' instead of
779the opposite which is what a .NET regex hacker might expect.
780
1f1031fe
YO
781Currently NAME is restricted to simple identifiers only.
782In other words, it must match C</^[_A-Za-z][_A-Za-z0-9]*\z/> or
783its Unicode extension (see L<utf8>),
784though it isn't extended by the locale (see L<perllocale>).
81714fb9 785
1f1031fe 786B<NOTE:> In order to make things easier for programmers with experience
ae5648b3 787with the Python or PCRE regex engines, the pattern C<< (?PE<lt>NAMEE<gt>pattern) >>
0d017f4d 788may be used instead of C<< (?<NAME>pattern) >>; however this form does not
64c5a566 789support the use of single quotes as a delimiter for the name.
81714fb9 790
1f1031fe
YO
791=item C<< \k<NAME> >>
792
793=item C<< \k'NAME' >>
81714fb9
YO
794
795Named backreference. Similar to numeric backreferences, except that
796the group is designated by name and not number. If multiple groups
797have the same name then it refers to the leftmost defined group in
798the current match.
799
0d017f4d 800It is an error to refer to a name not defined by a C<< (?<NAME>) >>
81714fb9
YO
801earlier in the pattern.
802
803Both forms are equivalent.
804
1f1031fe 805B<NOTE:> In order to make things easier for programmers with experience
0d017f4d 806with the Python or PCRE regex engines, the pattern C<< (?P=NAME) >>
64c5a566 807may be used instead of C<< \k<NAME> >>.
1f1031fe 808
cc6b7395 809=item C<(?{ code })>
d74e8afc 810X<(?{})> X<regex, code in> X<regexp, code in> X<regular expression, code in>
c277df42 811
19799a22 812B<WARNING>: This extended regular expression feature is considered
b9b4dddf
YO
813experimental, and may be changed without notice. Code executed that
814has side effects may not perform identically from version to version
815due to the effect of future optimisations in the regex engine.
c277df42 816
cc46d5f2 817This zero-width assertion evaluates any embedded Perl code. It
19799a22
GS
818always succeeds, and its C<code> is not interpolated. Currently,
819the rules to determine where the C<code> ends are somewhat convoluted.
820
77ea4f6d
JV
821This feature can be used together with the special variable C<$^N> to
822capture the results of submatches in variables without having to keep
823track of the number of nested parentheses. For example:
824
825 $_ = "The brown fox jumps over the lazy dog";
826 /the (\S+)(?{ $color = $^N }) (\S+)(?{ $animal = $^N })/i;
827 print "color = $color, animal = $animal\n";
828
754091cb
RGS
829Inside the C<(?{...})> block, C<$_> refers to the string the regular
830expression is matching against. You can also use C<pos()> to know what is
fa11829f 831the current position of matching within this string.
754091cb 832
19799a22
GS
833The C<code> is properly scoped in the following sense: If the assertion
834is backtracked (compare L<"Backtracking">), all changes introduced after
835C<local>ization are undone, so that
b9ac3b5b
GS
836
837 $_ = 'a' x 8;
5d458dd8 838 m<
b9ac3b5b
GS
839 (?{ $cnt = 0 }) # Initialize $cnt.
840 (
5d458dd8 841 a
b9ac3b5b
GS
842 (?{
843 local $cnt = $cnt + 1; # Update $cnt, backtracking-safe.
844 })
5d458dd8 845 )*
b9ac3b5b
GS
846 aaaa
847 (?{ $res = $cnt }) # On success copy to non-localized
848 # location.
849 >x;
850
0d017f4d 851will set C<$res = 4>. Note that after the match, C<$cnt> returns to the globally
14218588 852introduced value, because the scopes that restrict C<local> operators
b9ac3b5b
GS
853are unwound.
854
19799a22
GS
855This assertion may be used as a C<(?(condition)yes-pattern|no-pattern)>
856switch. If I<not> used in this way, the result of evaluation of
857C<code> is put into the special variable C<$^R>. This happens
858immediately, so C<$^R> can be used from other C<(?{ code })> assertions
859inside the same regular expression.
b9ac3b5b 860
19799a22
GS
861The assignment to C<$^R> above is properly localized, so the old
862value of C<$^R> is restored if the assertion is backtracked; compare
863L<"Backtracking">.
b9ac3b5b 864
19799a22
GS
865For reasons of security, this construct is forbidden if the regular
866expression involves run-time interpolation of variables, unless the
867perilous C<use re 'eval'> pragma has been used (see L<re>), or the
868variables contain results of C<qr//> operator (see
5d458dd8 869L<perlop/"qr/STRING/imosx">).
871b0233 870
0d017f4d 871This restriction is due to the wide-spread and remarkably convenient
19799a22 872custom of using run-time determined strings as patterns. For example:
871b0233
IZ
873
874 $re = <>;
875 chomp $re;
876 $string =~ /$re/;
877
14218588
GS
878Before Perl knew how to execute interpolated code within a pattern,
879this operation was completely safe from a security point of view,
880although it could raise an exception from an illegal pattern. If
881you turn on the C<use re 'eval'>, though, it is no longer secure,
882so you should only do so if you are also using taint checking.
883Better yet, use the carefully constrained evaluation within a Safe
cc46d5f2 884compartment. See L<perlsec> for details about both these mechanisms.
871b0233 885
e95d7314
GG
886B<WARNING>: Use of lexical (C<my>) variables in these blocks is
887broken. The result is unpredictable and will make perl unstable. The
888workaround is to use global (C<our>) variables.
889
890B<WARNING>: Because Perl's regex engine is currently not re-entrant,
891interpolated code may not invoke the regex engine either directly with
892C<m//> or C<s///>), or indirectly with functions such as
893C<split>. Invoking the regex engine in these blocks will make perl
894unstable.
8988a1bb 895
14455d6c 896=item C<(??{ code })>
d74e8afc
ITB
897X<(??{})>
898X<regex, postponed> X<regexp, postponed> X<regular expression, postponed>
0f5d15d6 899
19799a22 900B<WARNING>: This extended regular expression feature is considered
b9b4dddf
YO
901experimental, and may be changed without notice. Code executed that
902has side effects may not perform identically from version to version
903due to the effect of future optimisations in the regex engine.
0f5d15d6 904
19799a22
GS
905This is a "postponed" regular subexpression. The C<code> is evaluated
906at run time, at the moment this subexpression may match. The result
907of evaluation is considered as a regular expression and matched as
61528107 908if it were inserted instead of this construct. Note that this means
6bda09f9
YO
909that the contents of capture buffers defined inside an eval'ed pattern
910are not available outside of the pattern, and vice versa, there is no
911way for the inner pattern to refer to a capture buffer defined outside.
912Thus,
913
914 ('a' x 100)=~/(??{'(.)' x 100})/
915
81714fb9 916B<will> match, it will B<not> set $1.
0f5d15d6 917
428594d9 918The C<code> is not interpolated. As before, the rules to determine
19799a22
GS
919where the C<code> ends are currently somewhat convoluted.
920
921The following pattern matches a parenthesized group:
0f5d15d6
IZ
922
923 $re = qr{
924 \(
925 (?:
926 (?> [^()]+ ) # Non-parens without backtracking
927 |
14455d6c 928 (??{ $re }) # Group with matching parens
0f5d15d6
IZ
929 )*
930 \)
931 }x;
932
6bda09f9
YO
933See also C<(?PARNO)> for a different, more efficient way to accomplish
934the same task.
935
0b370c0a
A
936For reasons of security, this construct is forbidden if the regular
937expression involves run-time interpolation of variables, unless the
938perilous C<use re 'eval'> pragma has been used (see L<re>), or the
939variables contain results of C<qr//> operator (see
940L<perlop/"qr/STRING/imosx">).
941
5d458dd8 942Because perl's regex engine is not currently re-entrant, delayed
8988a1bb
DD
943code may not invoke the regex engine either directly with C<m//> or C<s///>),
944or indirectly with functions such as C<split>.
945
5d458dd8
YO
946Recursing deeper than 50 times without consuming any input string will
947result in a fatal error. The maximum depth is compiled into perl, so
6bda09f9
YO
948changing it requires a custom build.
949
542fa716
YO
950=item C<(?PARNO)> C<(?-PARNO)> C<(?+PARNO)> C<(?R)> C<(?0)>
951X<(?PARNO)> X<(?1)> X<(?R)> X<(?0)> X<(?-1)> X<(?+1)> X<(?-PARNO)> X<(?+PARNO)>
6bda09f9 952X<regex, recursive> X<regexp, recursive> X<regular expression, recursive>
542fa716 953X<regex, relative recursion>
6bda09f9 954
81714fb9
YO
955Similar to C<(??{ code })> except it does not involve compiling any code,
956instead it treats the contents of a capture buffer as an independent
61528107 957pattern that must match at the current position. Capture buffers
81714fb9 958contained by the pattern will have the value as determined by the
6bda09f9
YO
959outermost recursion.
960
894be9b7
YO
961PARNO is a sequence of digits (not starting with 0) whose value reflects
962the paren-number of the capture buffer to recurse to. C<(?R)> recurses to
963the beginning of the whole pattern. C<(?0)> is an alternate syntax for
542fa716
YO
964C<(?R)>. If PARNO is preceded by a plus or minus sign then it is assumed
965to be relative, with negative numbers indicating preceding capture buffers
966and positive ones following. Thus C<(?-1)> refers to the most recently
967declared buffer, and C<(?+1)> indicates the next buffer to be declared.
c74340f9
YO
968Note that the counting for relative recursion differs from that of
969relative backreferences, in that with recursion unclosed buffers B<are>
970included.
6bda09f9 971
81714fb9 972The following pattern matches a function foo() which may contain
f145b7e9 973balanced parentheses as the argument.
6bda09f9
YO
974
975 $re = qr{ ( # paren group 1 (full function)
81714fb9 976 foo
6bda09f9
YO
977 ( # paren group 2 (parens)
978 \(
979 ( # paren group 3 (contents of parens)
980 (?:
981 (?> [^()]+ ) # Non-parens without backtracking
982 |
983 (?2) # Recurse to start of paren group 2
984 )*
985 )
986 \)
987 )
988 )
989 }x;
990
991If the pattern was used as follows
992
993 'foo(bar(baz)+baz(bop))'=~/$re/
994 and print "\$1 = $1\n",
995 "\$2 = $2\n",
996 "\$3 = $3\n";
997
998the output produced should be the following:
999
1000 $1 = foo(bar(baz)+baz(bop))
1001 $2 = (bar(baz)+baz(bop))
81714fb9 1002 $3 = bar(baz)+baz(bop)
6bda09f9 1003
81714fb9 1004If there is no corresponding capture buffer defined, then it is a
61528107 1005fatal error. Recursing deeper than 50 times without consuming any input
81714fb9 1006string will also result in a fatal error. The maximum depth is compiled
6bda09f9
YO
1007into perl, so changing it requires a custom build.
1008
542fa716
YO
1009The following shows how using negative indexing can make it
1010easier to embed recursive patterns inside of a C<qr//> construct
1011for later use:
1012
1013 my $parens = qr/(\((?:[^()]++|(?-1))*+\))/;
1014 if (/foo $parens \s+ + \s+ bar $parens/x) {
1015 # do something here...
1016 }
1017
81714fb9 1018B<Note> that this pattern does not behave the same way as the equivalent
0d017f4d 1019PCRE or Python construct of the same form. In Perl you can backtrack into
6bda09f9 1020a recursed group, in PCRE and Python the recursed into group is treated
542fa716
YO
1021as atomic. Also, modifiers are resolved at compile time, so constructs
1022like (?i:(?1)) or (?:(?i)(?1)) do not affect how the sub-pattern will
1023be processed.
6bda09f9 1024
894be9b7
YO
1025=item C<(?&NAME)>
1026X<(?&NAME)>
1027
0d017f4d
WL
1028Recurse to a named subpattern. Identical to C<(?PARNO)> except that the
1029parenthesis to recurse to is determined by name. If multiple parentheses have
894be9b7
YO
1030the same name, then it recurses to the leftmost.
1031
1032It is an error to refer to a name that is not declared somewhere in the
1033pattern.
1034
1f1031fe
YO
1035B<NOTE:> In order to make things easier for programmers with experience
1036with the Python or PCRE regex engines the pattern C<< (?P>NAME) >>
64c5a566 1037may be used instead of C<< (?&NAME) >>.
1f1031fe 1038
e2e6a0f1
YO
1039=item C<(?(condition)yes-pattern|no-pattern)>
1040X<(?()>
286f584a 1041
e2e6a0f1 1042=item C<(?(condition)yes-pattern)>
286f584a 1043
e2e6a0f1
YO
1044Conditional expression. C<(condition)> should be either an integer in
1045parentheses (which is valid if the corresponding pair of parentheses
1046matched), a look-ahead/look-behind/evaluate zero-width assertion, a
1047name in angle brackets or single quotes (which is valid if a buffer
1048with the given name matched), or the special symbol (R) (true when
1049evaluated inside of recursion or eval). Additionally the R may be
1050followed by a number, (which will be true when evaluated when recursing
1051inside of the appropriate group), or by C<&NAME>, in which case it will
1052be true only when evaluated during recursion in the named group.
1053
1054Here's a summary of the possible predicates:
1055
1056=over 4
1057
1058=item (1) (2) ...
1059
1060Checks if the numbered capturing buffer has matched something.
1061
1062=item (<NAME>) ('NAME')
1063
1064Checks if a buffer with the given name has matched something.
1065
1066=item (?{ CODE })
1067
1068Treats the code block as the condition.
1069
1070=item (R)
1071
1072Checks if the expression has been evaluated inside of recursion.
1073
1074=item (R1) (R2) ...
1075
1076Checks if the expression has been evaluated while executing directly
1077inside of the n-th capture group. This check is the regex equivalent of
1078
1079 if ((caller(0))[3] eq 'subname') { ... }
1080
1081In other words, it does not check the full recursion stack.
1082
1083=item (R&NAME)
1084
1085Similar to C<(R1)>, this predicate checks to see if we're executing
1086directly inside of the leftmost group with a given name (this is the same
1087logic used by C<(?&NAME)> to disambiguate). It does not check the full
1088stack, but only the name of the innermost active recursion.
1089
1090=item (DEFINE)
1091
1092In this case, the yes-pattern is never directly executed, and no
1093no-pattern is allowed. Similar in spirit to C<(?{0})> but more efficient.
1094See below for details.
1095
1096=back
1097
1098For example:
1099
1100 m{ ( \( )?
1101 [^()]+
1102 (?(1) \) )
1103 }x
1104
1105matches a chunk of non-parentheses, possibly included in parentheses
1106themselves.
1107
1108A special form is the C<(DEFINE)> predicate, which never executes directly
1109its yes-pattern, and does not allow a no-pattern. This allows to define
1110subpatterns which will be executed only by using the recursion mechanism.
1111This way, you can define a set of regular expression rules that can be
1112bundled into any pattern you choose.
1113
1114It is recommended that for this usage you put the DEFINE block at the
1115end of the pattern, and that you name any subpatterns defined within it.
1116
1117Also, it's worth noting that patterns defined this way probably will
1118not be as efficient, as the optimiser is not very clever about
1119handling them.
1120
1121An example of how this might be used is as follows:
1122
2bf803e2 1123 /(?<NAME>(?&NAME_PAT))(?<ADDR>(?&ADDRESS_PAT))
e2e6a0f1 1124 (?(DEFINE)
2bf803e2
YO
1125 (?<NAME_PAT>....)
1126 (?<ADRESS_PAT>....)
e2e6a0f1
YO
1127 )/x
1128
1129Note that capture buffers matched inside of recursion are not accessible
0d017f4d 1130after the recursion returns, so the extra layer of capturing buffers is
e2e6a0f1
YO
1131necessary. Thus C<$+{NAME_PAT}> would not be defined even though
1132C<$+{NAME}> would be.
286f584a 1133
c47ff5f1 1134=item C<< (?>pattern) >>
6bda09f9 1135X<backtrack> X<backtracking> X<atomic> X<possessive>
5a964f20 1136
19799a22
GS
1137An "independent" subexpression, one which matches the substring
1138that a I<standalone> C<pattern> would match if anchored at the given
9da458fc 1139position, and it matches I<nothing other than this substring>. This
19799a22
GS
1140construct is useful for optimizations of what would otherwise be
1141"eternal" matches, because it will not backtrack (see L<"Backtracking">).
9da458fc
IZ
1142It may also be useful in places where the "grab all you can, and do not
1143give anything back" semantic is desirable.
19799a22 1144
c47ff5f1 1145For example: C<< ^(?>a*)ab >> will never match, since C<< (?>a*) >>
19799a22
GS
1146(anchored at the beginning of string, as above) will match I<all>
1147characters C<a> at the beginning of string, leaving no C<a> for
1148C<ab> to match. In contrast, C<a*ab> will match the same as C<a+b>,
1149since the match of the subgroup C<a*> is influenced by the following
1150group C<ab> (see L<"Backtracking">). In particular, C<a*> inside
1151C<a*ab> will match fewer characters than a standalone C<a*>, since
1152this makes the tail match.
1153
c47ff5f1 1154An effect similar to C<< (?>pattern) >> may be achieved by writing
19799a22
GS
1155C<(?=(pattern))\1>. This matches the same substring as a standalone
1156C<a+>, and the following C<\1> eats the matched string; it therefore
c47ff5f1 1157makes a zero-length assertion into an analogue of C<< (?>...) >>.
19799a22
GS
1158(The difference between these two constructs is that the second one
1159uses a capturing group, thus shifting ordinals of backreferences
1160in the rest of a regular expression.)
1161
1162Consider this pattern:
c277df42 1163
871b0233 1164 m{ \(
e2e6a0f1
YO
1165 (
1166 [^()]+ # x+
1167 |
871b0233
IZ
1168 \( [^()]* \)
1169 )+
e2e6a0f1 1170 \)
871b0233 1171 }x
5a964f20 1172
19799a22
GS
1173That will efficiently match a nonempty group with matching parentheses
1174two levels deep or less. However, if there is no such group, it
1175will take virtually forever on a long string. That's because there
1176are so many different ways to split a long string into several
1177substrings. This is what C<(.+)+> is doing, and C<(.+)+> is similar
1178to a subpattern of the above pattern. Consider how the pattern
1179above detects no-match on C<((()aaaaaaaaaaaaaaaaaa> in several
1180seconds, but that each extra letter doubles this time. This
1181exponential performance will make it appear that your program has
14218588 1182hung. However, a tiny change to this pattern
5a964f20 1183
e2e6a0f1
YO
1184 m{ \(
1185 (
1186 (?> [^()]+ ) # change x+ above to (?> x+ )
1187 |
871b0233
IZ
1188 \( [^()]* \)
1189 )+
e2e6a0f1 1190 \)
871b0233 1191 }x
c277df42 1192
c47ff5f1 1193which uses C<< (?>...) >> matches exactly when the one above does (verifying
5a964f20
TC
1194this yourself would be a productive exercise), but finishes in a fourth
1195the time when used on a similar string with 1000000 C<a>s. Be aware,
1196however, that this pattern currently triggers a warning message under
9f1b1f2d 1197the C<use warnings> pragma or B<-w> switch saying it
6bab786b 1198C<"matches null string many times in regex">.
c277df42 1199
c47ff5f1 1200On simple groups, such as the pattern C<< (?> [^()]+ ) >>, a comparable
19799a22 1201effect may be achieved by negative look-ahead, as in C<[^()]+ (?! [^()] )>.
c277df42
IZ
1202This was only 4 times slower on a string with 1000000 C<a>s.
1203
9da458fc
IZ
1204The "grab all you can, and do not give anything back" semantic is desirable
1205in many situations where on the first sight a simple C<()*> looks like
1206the correct solution. Suppose we parse text with comments being delimited
1207by C<#> followed by some optional (horizontal) whitespace. Contrary to
4375e838 1208its appearance, C<#[ \t]*> I<is not> the correct subexpression to match
9da458fc
IZ
1209the comment delimiter, because it may "give up" some whitespace if
1210the remainder of the pattern can be made to match that way. The correct
1211answer is either one of these:
1212
1213 (?>#[ \t]*)
1214 #[ \t]*(?![ \t])
1215
1216For example, to grab non-empty comments into $1, one should use either
1217one of these:
1218
1219 / (?> \# [ \t]* ) ( .+ ) /x;
1220 / \# [ \t]* ( [^ \t] .* ) /x;
1221
1222Which one you pick depends on which of these expressions better reflects
1223the above specification of comments.
1224
6bda09f9
YO
1225In some literature this construct is called "atomic matching" or
1226"possessive matching".
1227
b9b4dddf
YO
1228Possessive quantifiers are equivalent to putting the item they are applied
1229to inside of one of these constructs. The following equivalences apply:
1230
1231 Quantifier Form Bracketing Form
1232 --------------- ---------------
1233 PAT*+ (?>PAT*)
1234 PAT++ (?>PAT+)
1235 PAT?+ (?>PAT?)
1236 PAT{min,max}+ (?>PAT{min,max})
1237
e2e6a0f1
YO
1238=back
1239
1240=head2 Special Backtracking Control Verbs
1241
1242B<WARNING:> These patterns are experimental and subject to change or
0d017f4d 1243removal in a future version of Perl. Their usage in production code should
e2e6a0f1
YO
1244be noted to avoid problems during upgrades.
1245
1246These special patterns are generally of the form C<(*VERB:ARG)>. Unless
1247otherwise stated the ARG argument is optional; in some cases, it is
1248forbidden.
1249
1250Any pattern containing a special backtracking verb that allows an argument
e1020413 1251has the special behaviour that when executed it sets the current package's
5d458dd8
YO
1252C<$REGERROR> and C<$REGMARK> variables. When doing so the following
1253rules apply:
e2e6a0f1 1254
5d458dd8
YO
1255On failure, the C<$REGERROR> variable will be set to the ARG value of the
1256verb pattern, if the verb was involved in the failure of the match. If the
1257ARG part of the pattern was omitted, then C<$REGERROR> will be set to the
1258name of the last C<(*MARK:NAME)> pattern executed, or to TRUE if there was
1259none. Also, the C<$REGMARK> variable will be set to FALSE.
e2e6a0f1 1260
5d458dd8
YO
1261On a successful match, the C<$REGERROR> variable will be set to FALSE, and
1262the C<$REGMARK> variable will be set to the name of the last
1263C<(*MARK:NAME)> pattern executed. See the explanation for the
1264C<(*MARK:NAME)> verb below for more details.
e2e6a0f1 1265
5d458dd8
YO
1266B<NOTE:> C<$REGERROR> and C<$REGMARK> are not magic variables like C<$1>
1267and most other regex related variables. They are not local to a scope, nor
1268readonly, but instead are volatile package variables similar to C<$AUTOLOAD>.
1269Use C<local> to localize changes to them to a specific scope if necessary.
e2e6a0f1
YO
1270
1271If a pattern does not contain a special backtracking verb that allows an
5d458dd8 1272argument, then C<$REGERROR> and C<$REGMARK> are not touched at all.
e2e6a0f1
YO
1273
1274=over 4
1275
1276=item Verbs that take an argument
1277
1278=over 4
1279
5d458dd8 1280=item C<(*PRUNE)> C<(*PRUNE:NAME)>
f7819f85 1281X<(*PRUNE)> X<(*PRUNE:NAME)>
54612592 1282
5d458dd8
YO
1283This zero-width pattern prunes the backtracking tree at the current point
1284when backtracked into on failure. Consider the pattern C<A (*PRUNE) B>,
1285where A and B are complex patterns. Until the C<(*PRUNE)> verb is reached,
1286A may backtrack as necessary to match. Once it is reached, matching
1287continues in B, which may also backtrack as necessary; however, should B
1288not match, then no further backtracking will take place, and the pattern
1289will fail outright at the current starting position.
54612592
YO
1290
1291The following example counts all the possible matching strings in a
1292pattern (without actually matching any of them).
1293
e2e6a0f1 1294 'aaab' =~ /a+b?(?{print "$&\n"; $count++})(*FAIL)/;
54612592
YO
1295 print "Count=$count\n";
1296
1297which produces:
1298
1299 aaab
1300 aaa
1301 aa
1302 a
1303 aab
1304 aa
1305 a
1306 ab
1307 a
1308 Count=9
1309
5d458dd8 1310If we add a C<(*PRUNE)> before the count like the following
54612592 1311
5d458dd8 1312 'aaab' =~ /a+b?(*PRUNE)(?{print "$&\n"; $count++})(*FAIL)/;
54612592
YO
1313 print "Count=$count\n";
1314
1315we prevent backtracking and find the count of the longest matching
353c6505 1316at each matching starting point like so:
54612592
YO
1317
1318 aaab
1319 aab
1320 ab
1321 Count=3
1322
5d458dd8 1323Any number of C<(*PRUNE)> assertions may be used in a pattern.
54612592 1324
5d458dd8
YO
1325See also C<< (?>pattern) >> and possessive quantifiers for other ways to
1326control backtracking. In some cases, the use of C<(*PRUNE)> can be
1327replaced with a C<< (?>pattern) >> with no functional difference; however,
1328C<(*PRUNE)> can be used to handle cases that cannot be expressed using a
1329C<< (?>pattern) >> alone.
54612592 1330
e2e6a0f1 1331
5d458dd8
YO
1332=item C<(*SKIP)> C<(*SKIP:NAME)>
1333X<(*SKIP)>
e2e6a0f1 1334
5d458dd8 1335This zero-width pattern is similar to C<(*PRUNE)>, except that on
e2e6a0f1 1336failure it also signifies that whatever text that was matched leading up
5d458dd8
YO
1337to the C<(*SKIP)> pattern being executed cannot be part of I<any> match
1338of this pattern. This effectively means that the regex engine "skips" forward
1339to this position on failure and tries to match again, (assuming that
1340there is sufficient room to match).
1341
1342The name of the C<(*SKIP:NAME)> pattern has special significance. If a
1343C<(*MARK:NAME)> was encountered while matching, then it is that position
1344which is used as the "skip point". If no C<(*MARK)> of that name was
1345encountered, then the C<(*SKIP)> operator has no effect. When used
1346without a name the "skip point" is where the match point was when
1347executing the (*SKIP) pattern.
1348
1349Compare the following to the examples in C<(*PRUNE)>, note the string
24b23f37
YO
1350is twice as long:
1351
5d458dd8 1352 'aaabaaab' =~ /a+b?(*SKIP)(?{print "$&\n"; $count++})(*FAIL)/;
24b23f37
YO
1353 print "Count=$count\n";
1354
1355outputs
1356
1357 aaab
1358 aaab
1359 Count=2
1360
5d458dd8 1361Once the 'aaab' at the start of the string has matched, and the C<(*SKIP)>
353c6505 1362executed, the next starting point will be where the cursor was when the
5d458dd8
YO
1363C<(*SKIP)> was executed.
1364
5d458dd8
YO
1365=item C<(*MARK:NAME)> C<(*:NAME)>
1366X<(*MARK)> C<(*MARK:NAME)> C<(*:NAME)>
1367
1368This zero-width pattern can be used to mark the point reached in a string
1369when a certain part of the pattern has been successfully matched. This
1370mark may be given a name. A later C<(*SKIP)> pattern will then skip
1371forward to that point if backtracked into on failure. Any number of
b4222fa9 1372C<(*MARK)> patterns are allowed, and the NAME portion may be duplicated.
5d458dd8
YO
1373
1374In addition to interacting with the C<(*SKIP)> pattern, C<(*MARK:NAME)>
1375can be used to "label" a pattern branch, so that after matching, the
1376program can determine which branches of the pattern were involved in the
1377match.
1378
1379When a match is successful, the C<$REGMARK> variable will be set to the
1380name of the most recently executed C<(*MARK:NAME)> that was involved
1381in the match.
1382
1383This can be used to determine which branch of a pattern was matched
c62285ac 1384without using a separate capture buffer for each branch, which in turn
5d458dd8
YO
1385can result in a performance improvement, as perl cannot optimize
1386C</(?:(x)|(y)|(z))/> as efficiently as something like
1387C</(?:x(*MARK:x)|y(*MARK:y)|z(*MARK:z))/>.
1388
1389When a match has failed, and unless another verb has been involved in
1390failing the match and has provided its own name to use, the C<$REGERROR>
1391variable will be set to the name of the most recently executed
1392C<(*MARK:NAME)>.
1393
1394See C<(*SKIP)> for more details.
1395
b62d2d15
YO
1396As a shortcut C<(*MARK:NAME)> can be written C<(*:NAME)>.
1397
5d458dd8
YO
1398=item C<(*THEN)> C<(*THEN:NAME)>
1399
241e7389 1400This is similar to the "cut group" operator C<::> from Perl 6. Like
5d458dd8
YO
1401C<(*PRUNE)>, this verb always matches, and when backtracked into on
1402failure, it causes the regex engine to try the next alternation in the
1403innermost enclosing group (capturing or otherwise).
1404
1405Its name comes from the observation that this operation combined with the
1406alternation operator (C<|>) can be used to create what is essentially a
1407pattern-based if/then/else block:
1408
1409 ( COND (*THEN) FOO | COND2 (*THEN) BAR | COND3 (*THEN) BAZ )
1410
1411Note that if this operator is used and NOT inside of an alternation then
1412it acts exactly like the C<(*PRUNE)> operator.
1413
1414 / A (*PRUNE) B /
1415
1416is the same as
1417
1418 / A (*THEN) B /
1419
1420but
1421
1422 / ( A (*THEN) B | C (*THEN) D ) /
1423
1424is not the same as
1425
1426 / ( A (*PRUNE) B | C (*PRUNE) D ) /
1427
1428as after matching the A but failing on the B the C<(*THEN)> verb will
1429backtrack and try C; but the C<(*PRUNE)> verb will simply fail.
24b23f37 1430
e2e6a0f1
YO
1431=item C<(*COMMIT)>
1432X<(*COMMIT)>
24b23f37 1433
241e7389 1434This is the Perl 6 "commit pattern" C<< <commit> >> or C<:::>. It's a
5d458dd8
YO
1435zero-width pattern similar to C<(*SKIP)>, except that when backtracked
1436into on failure it causes the match to fail outright. No further attempts
1437to find a valid match by advancing the start pointer will occur again.
1438For example,
24b23f37 1439
e2e6a0f1 1440 'aaabaaab' =~ /a+b?(*COMMIT)(?{print "$&\n"; $count++})(*FAIL)/;
24b23f37
YO
1441 print "Count=$count\n";
1442
1443outputs
1444
1445 aaab
1446 Count=1
1447
e2e6a0f1
YO
1448In other words, once the C<(*COMMIT)> has been entered, and if the pattern
1449does not match, the regex engine will not try any further matching on the
1450rest of the string.
c277df42 1451
e2e6a0f1 1452=back
9af228c6 1453
e2e6a0f1 1454=item Verbs without an argument
9af228c6
YO
1455
1456=over 4
1457
e2e6a0f1
YO
1458=item C<(*FAIL)> C<(*F)>
1459X<(*FAIL)> X<(*F)>
9af228c6 1460
e2e6a0f1
YO
1461This pattern matches nothing and always fails. It can be used to force the
1462engine to backtrack. It is equivalent to C<(?!)>, but easier to read. In
1463fact, C<(?!)> gets optimised into C<(*FAIL)> internally.
9af228c6 1464
e2e6a0f1 1465It is probably useful only when combined with C<(?{})> or C<(??{})>.
9af228c6 1466
e2e6a0f1
YO
1467=item C<(*ACCEPT)>
1468X<(*ACCEPT)>
9af228c6 1469
e2e6a0f1
YO
1470B<WARNING:> This feature is highly experimental. It is not recommended
1471for production code.
9af228c6 1472
e2e6a0f1
YO
1473This pattern matches nothing and causes the end of successful matching at
1474the point at which the C<(*ACCEPT)> pattern was encountered, regardless of
1475whether there is actually more to match in the string. When inside of a
0d017f4d 1476nested pattern, such as recursion, or in a subpattern dynamically generated
e2e6a0f1 1477via C<(??{})>, only the innermost pattern is ended immediately.
9af228c6 1478
e2e6a0f1
YO
1479If the C<(*ACCEPT)> is inside of capturing buffers then the buffers are
1480marked as ended at the point at which the C<(*ACCEPT)> was encountered.
1481For instance:
9af228c6 1482
e2e6a0f1 1483 'AB' =~ /(A (A|B(*ACCEPT)|C) D)(E)/x;
9af228c6 1484
e2e6a0f1 1485will match, and C<$1> will be C<AB> and C<$2> will be C<B>, C<$3> will not
0d017f4d 1486be set. If another branch in the inner parentheses were matched, such as in the
e2e6a0f1 1487string 'ACDE', then the C<D> and C<E> would have to be matched as well.
9af228c6
YO
1488
1489=back
c277df42 1490
a0d0e21e
LW
1491=back
1492
c07a80fd 1493=head2 Backtracking
d74e8afc 1494X<backtrack> X<backtracking>
c07a80fd 1495
35a734be
IZ
1496NOTE: This section presents an abstract approximation of regular
1497expression behavior. For a more rigorous (and complicated) view of
1498the rules involved in selecting a match among possible alternatives,
0d017f4d 1499see L<Combining RE Pieces>.
35a734be 1500
c277df42 1501A fundamental feature of regular expression matching involves the
5a964f20 1502notion called I<backtracking>, which is currently used (when needed)
0d017f4d 1503by all regular non-possessive expression quantifiers, namely C<*>, C<*?>, C<+>,
9da458fc
IZ
1504C<+?>, C<{n,m}>, and C<{n,m}?>. Backtracking is often optimized
1505internally, but the general principle outlined here is valid.
c07a80fd 1506
1507For a regular expression to match, the I<entire> regular expression must
1508match, not just part of it. So if the beginning of a pattern containing a
1509quantifier succeeds in a way that causes later parts in the pattern to
1510fail, the matching engine backs up and recalculates the beginning
1511part--that's why it's called backtracking.
1512
1513Here is an example of backtracking: Let's say you want to find the
1514word following "foo" in the string "Food is on the foo table.":
1515
1516 $_ = "Food is on the foo table.";
1517 if ( /\b(foo)\s+(\w+)/i ) {
1518 print "$2 follows $1.\n";
1519 }
1520
1521When the match runs, the first part of the regular expression (C<\b(foo)>)
1522finds a possible match right at the beginning of the string, and loads up
1523$1 with "Foo". However, as soon as the matching engine sees that there's
1524no whitespace following the "Foo" that it had saved in $1, it realizes its
68dc0745 1525mistake and starts over again one character after where it had the
c07a80fd 1526tentative match. This time it goes all the way until the next occurrence
1527of "foo". The complete regular expression matches this time, and you get
1528the expected output of "table follows foo."
1529
1530Sometimes minimal matching can help a lot. Imagine you'd like to match
1531everything between "foo" and "bar". Initially, you write something
1532like this:
1533
1534 $_ = "The food is under the bar in the barn.";
1535 if ( /foo(.*)bar/ ) {
1536 print "got <$1>\n";
1537 }
1538
1539Which perhaps unexpectedly yields:
1540
1541 got <d is under the bar in the >
1542
1543That's because C<.*> was greedy, so you get everything between the
14218588 1544I<first> "foo" and the I<last> "bar". Here it's more effective
c07a80fd 1545to use minimal matching to make sure you get the text between a "foo"
1546and the first "bar" thereafter.
1547
1548 if ( /foo(.*?)bar/ ) { print "got <$1>\n" }
1549 got <d is under the >
1550
0d017f4d 1551Here's another example. Let's say you'd like to match a number at the end
b6e13d97 1552of a string, and you also want to keep the preceding part of the match.
c07a80fd 1553So you write this:
1554
1555 $_ = "I have 2 numbers: 53147";
1556 if ( /(.*)(\d*)/ ) { # Wrong!
1557 print "Beginning is <$1>, number is <$2>.\n";
1558 }
1559
1560That won't work at all, because C<.*> was greedy and gobbled up the
1561whole string. As C<\d*> can match on an empty string the complete
1562regular expression matched successfully.
1563
8e1088bc 1564 Beginning is <I have 2 numbers: 53147>, number is <>.
c07a80fd 1565
1566Here are some variants, most of which don't work:
1567
1568 $_ = "I have 2 numbers: 53147";
1569 @pats = qw{
1570 (.*)(\d*)
1571 (.*)(\d+)
1572 (.*?)(\d*)
1573 (.*?)(\d+)
1574 (.*)(\d+)$
1575 (.*?)(\d+)$
1576 (.*)\b(\d+)$
1577 (.*\D)(\d+)$
1578 };
1579
1580 for $pat (@pats) {
1581 printf "%-12s ", $pat;
1582 if ( /$pat/ ) {
1583 print "<$1> <$2>\n";
1584 } else {
1585 print "FAIL\n";
1586 }
1587 }
1588
1589That will print out:
1590
1591 (.*)(\d*) <I have 2 numbers: 53147> <>
1592 (.*)(\d+) <I have 2 numbers: 5314> <7>
1593 (.*?)(\d*) <> <>
1594 (.*?)(\d+) <I have > <2>
1595 (.*)(\d+)$ <I have 2 numbers: 5314> <7>
1596 (.*?)(\d+)$ <I have 2 numbers: > <53147>
1597 (.*)\b(\d+)$ <I have 2 numbers: > <53147>
1598 (.*\D)(\d+)$ <I have 2 numbers: > <53147>
1599
1600As you see, this can be a bit tricky. It's important to realize that a
1601regular expression is merely a set of assertions that gives a definition
1602of success. There may be 0, 1, or several different ways that the
1603definition might succeed against a particular string. And if there are
5a964f20
TC
1604multiple ways it might succeed, you need to understand backtracking to
1605know which variety of success you will achieve.
c07a80fd 1606
19799a22 1607When using look-ahead assertions and negations, this can all get even
8b19b778 1608trickier. Imagine you'd like to find a sequence of non-digits not
c07a80fd 1609followed by "123". You might try to write that as
1610
871b0233
IZ
1611 $_ = "ABC123";
1612 if ( /^\D*(?!123)/ ) { # Wrong!
1613 print "Yup, no 123 in $_\n";
1614 }
c07a80fd 1615
1616But that isn't going to match; at least, not the way you're hoping. It
1617claims that there is no 123 in the string. Here's a clearer picture of
9b9391b2 1618why that pattern matches, contrary to popular expectations:
c07a80fd 1619
4358a253
SS
1620 $x = 'ABC123';
1621 $y = 'ABC445';
c07a80fd 1622
4358a253
SS
1623 print "1: got $1\n" if $x =~ /^(ABC)(?!123)/;
1624 print "2: got $1\n" if $y =~ /^(ABC)(?!123)/;
c07a80fd 1625
4358a253
SS
1626 print "3: got $1\n" if $x =~ /^(\D*)(?!123)/;
1627 print "4: got $1\n" if $y =~ /^(\D*)(?!123)/;
c07a80fd 1628
1629This prints
1630
1631 2: got ABC
1632 3: got AB
1633 4: got ABC
1634
5f05dabc 1635You might have expected test 3 to fail because it seems to a more
c07a80fd 1636general purpose version of test 1. The important difference between
1637them is that test 3 contains a quantifier (C<\D*>) and so can use
1638backtracking, whereas test 1 will not. What's happening is
1639that you've asked "Is it true that at the start of $x, following 0 or more
5f05dabc 1640non-digits, you have something that's not 123?" If the pattern matcher had
c07a80fd 1641let C<\D*> expand to "ABC", this would have caused the whole pattern to
54310121 1642fail.
14218588 1643
c07a80fd 1644The search engine will initially match C<\D*> with "ABC". Then it will
14218588 1645try to match C<(?!123> with "123", which fails. But because
c07a80fd 1646a quantifier (C<\D*>) has been used in the regular expression, the
1647search engine can backtrack and retry the match differently
54310121 1648in the hope of matching the complete regular expression.
c07a80fd 1649
5a964f20
TC
1650The pattern really, I<really> wants to succeed, so it uses the
1651standard pattern back-off-and-retry and lets C<\D*> expand to just "AB" this
c07a80fd 1652time. Now there's indeed something following "AB" that is not
14218588 1653"123". It's "C123", which suffices.
c07a80fd 1654
14218588
GS
1655We can deal with this by using both an assertion and a negation.
1656We'll say that the first part in $1 must be followed both by a digit
1657and by something that's not "123". Remember that the look-aheads
1658are zero-width expressions--they only look, but don't consume any
1659of the string in their match. So rewriting this way produces what
c07a80fd 1660you'd expect; that is, case 5 will fail, but case 6 succeeds:
1661
4358a253
SS
1662 print "5: got $1\n" if $x =~ /^(\D*)(?=\d)(?!123)/;
1663 print "6: got $1\n" if $y =~ /^(\D*)(?=\d)(?!123)/;
c07a80fd 1664
1665 6: got ABC
1666
5a964f20 1667In other words, the two zero-width assertions next to each other work as though
19799a22 1668they're ANDed together, just as you'd use any built-in assertions: C</^$/>
c07a80fd 1669matches only if you're at the beginning of the line AND the end of the
1670line simultaneously. The deeper underlying truth is that juxtaposition in
1671regular expressions always means AND, except when you write an explicit OR
1672using the vertical bar. C</ab/> means match "a" AND (then) match "b",
1673although the attempted matches are made at different positions because "a"
1674is not a zero-width assertion, but a one-width assertion.
1675
0d017f4d 1676B<WARNING>: Particularly complicated regular expressions can take
14218588 1677exponential time to solve because of the immense number of possible
0d017f4d 1678ways they can use backtracking to try for a match. For example, without
9da458fc
IZ
1679internal optimizations done by the regular expression engine, this will
1680take a painfully long time to run:
c07a80fd 1681
e1901655
IZ
1682 'aaaaaaaaaaaa' =~ /((a{0,5}){0,5})*[c]/
1683
1684And if you used C<*>'s in the internal groups instead of limiting them
1685to 0 through 5 matches, then it would take forever--or until you ran
1686out of stack space. Moreover, these internal optimizations are not
1687always applicable. For example, if you put C<{0,5}> instead of C<*>
1688on the external group, no current optimization is applicable, and the
1689match takes a long time to finish.
c07a80fd 1690
9da458fc
IZ
1691A powerful tool for optimizing such beasts is what is known as an
1692"independent group",
c47ff5f1 1693which does not backtrack (see L<C<< (?>pattern) >>>). Note also that
9da458fc 1694zero-length look-ahead/look-behind assertions will not backtrack to make
5d458dd8 1695the tail match, since they are in "logical" context: only
14218588 1696whether they match is considered relevant. For an example
9da458fc 1697where side-effects of look-ahead I<might> have influenced the
c47ff5f1 1698following match, see L<C<< (?>pattern) >>>.
c277df42 1699
a0d0e21e 1700=head2 Version 8 Regular Expressions
d74e8afc 1701X<regular expression, version 8> X<regex, version 8> X<regexp, version 8>
a0d0e21e 1702
5a964f20 1703In case you're not familiar with the "regular" Version 8 regex
a0d0e21e
LW
1704routines, here are the pattern-matching rules not described above.
1705
54310121 1706Any single character matches itself, unless it is a I<metacharacter>
a0d0e21e 1707with a special meaning described here or above. You can cause
5a964f20 1708characters that normally function as metacharacters to be interpreted
5f05dabc 1709literally by prefixing them with a "\" (e.g., "\." matches a ".", not any
0d017f4d
WL
1710character; "\\" matches a "\"). This escape mechanism is also required
1711for the character used as the pattern delimiter.
1712
1713A series of characters matches that series of characters in the target
1714string, so the pattern C<blurfl> would match "blurfl" in the target
1715string.
a0d0e21e
LW
1716
1717You can specify a character class, by enclosing a list of characters
5d458dd8 1718in C<[]>, which will match any character from the list. If the
a0d0e21e 1719first character after the "[" is "^", the class matches any character not
14218588 1720in the list. Within a list, the "-" character specifies a
5a964f20 1721range, so that C<a-z> represents all characters between "a" and "z",
8a4f6ac2
GS
1722inclusive. If you want either "-" or "]" itself to be a member of a
1723class, put it at the start of the list (possibly after a "^"), or
1724escape it with a backslash. "-" is also taken literally when it is
1725at the end of the list, just before the closing "]". (The
84850974
DD
1726following all specify the same class of three characters: C<[-az]>,
1727C<[az-]>, and C<[a\-z]>. All are different from C<[a-z]>, which
5d458dd8
YO
1728specifies a class containing twenty-six characters, even on EBCDIC-based
1729character sets.) Also, if you try to use the character
1730classes C<\w>, C<\W>, C<\s>, C<\S>, C<\d>, or C<\D> as endpoints of
1731a range, the "-" is understood literally.
a0d0e21e 1732
8ada0baa
JH
1733Note also that the whole range idea is rather unportable between
1734character sets--and even within character sets they may cause results
1735you probably didn't expect. A sound principle is to use only ranges
0d017f4d 1736that begin from and end at either alphabetics of equal case ([a-e],
8ada0baa
JH
1737[A-E]), or digits ([0-9]). Anything else is unsafe. If in doubt,
1738spell out the character sets in full.
1739
54310121 1740Characters may be specified using a metacharacter syntax much like that
a0d0e21e
LW
1741used in C: "\n" matches a newline, "\t" a tab, "\r" a carriage return,
1742"\f" a form feed, etc. More generally, \I<nnn>, where I<nnn> is a string
5d458dd8
YO
1743of octal digits, matches the character whose coded character set value
1744is I<nnn>. Similarly, \xI<nn>, where I<nn> are hexadecimal digits,
1745matches the character whose numeric value is I<nn>. The expression \cI<x>
1746matches the character control-I<x>. Finally, the "." metacharacter
fb55449c 1747matches any character except "\n" (unless you use C</s>).
a0d0e21e
LW
1748
1749You can specify a series of alternatives for a pattern using "|" to
1750separate them, so that C<fee|fie|foe> will match any of "fee", "fie",
5a964f20 1751or "foe" in the target string (as would C<f(e|i|o)e>). The
a0d0e21e
LW
1752first alternative includes everything from the last pattern delimiter
1753("(", "[", or the beginning of the pattern) up to the first "|", and
1754the last alternative contains everything from the last "|" to the next
14218588
GS
1755pattern delimiter. That's why it's common practice to include
1756alternatives in parentheses: to minimize confusion about where they
a3cb178b
GS
1757start and end.
1758
5a964f20 1759Alternatives are tried from left to right, so the first
a3cb178b
GS
1760alternative found for which the entire expression matches, is the one that
1761is chosen. This means that alternatives are not necessarily greedy. For
628afcb5 1762example: when matching C<foo|foot> against "barefoot", only the "foo"
a3cb178b
GS
1763part will match, as that is the first alternative tried, and it successfully
1764matches the target string. (This might not seem important, but it is
1765important when you are capturing matched text using parentheses.)
1766
5a964f20 1767Also remember that "|" is interpreted as a literal within square brackets,
a3cb178b 1768so if you write C<[fee|fie|foe]> you're really only matching C<[feio|]>.
a0d0e21e 1769
14218588
GS
1770Within a pattern, you may designate subpatterns for later reference
1771by enclosing them in parentheses, and you may refer back to the
1772I<n>th subpattern later in the pattern using the metacharacter
1773\I<n>. Subpatterns are numbered based on the left to right order
1774of their opening parenthesis. A backreference matches whatever
1775actually matched the subpattern in the string being examined, not
1776the rules for that subpattern. Therefore, C<(0|0x)\d*\s\1\d*> will
1777match "0x1234 0x4321", but not "0x1234 01234", because subpattern
17781 matched "0x", even though the rule C<0|0x> could potentially match
1779the leading 0 in the second number.
cb1a09d0 1780
0d017f4d 1781=head2 Warning on \1 Instead of $1
cb1a09d0 1782
5a964f20 1783Some people get too used to writing things like:
cb1a09d0
AD
1784
1785 $pattern =~ s/(\W)/\\\1/g;
1786
1787This is grandfathered for the RHS of a substitute to avoid shocking the
1788B<sed> addicts, but it's a dirty habit to get into. That's because in
d1be9408 1789PerlThink, the righthand side of an C<s///> is a double-quoted string. C<\1> in
cb1a09d0
AD
1790the usual double-quoted string means a control-A. The customary Unix
1791meaning of C<\1> is kludged in for C<s///>. However, if you get into the habit
1792of doing that, you get yourself into trouble if you then add an C</e>
1793modifier.
1794
5a964f20 1795 s/(\d+)/ \1 + 1 /eg; # causes warning under -w
cb1a09d0
AD
1796
1797Or if you try to do
1798
1799 s/(\d+)/\1000/;
1800
1801You can't disambiguate that by saying C<\{1}000>, whereas you can fix it with
14218588 1802C<${1}000>. The operation of interpolation should not be confused
cb1a09d0
AD
1803with the operation of matching a backreference. Certainly they mean two
1804different things on the I<left> side of the C<s///>.
9fa51da4 1805
0d017f4d 1806=head2 Repeated Patterns Matching a Zero-length Substring
c84d73f1 1807
19799a22 1808B<WARNING>: Difficult material (and prose) ahead. This section needs a rewrite.
c84d73f1
IZ
1809
1810Regular expressions provide a terse and powerful programming language. As
1811with most other power tools, power comes together with the ability
1812to wreak havoc.
1813
1814A common abuse of this power stems from the ability to make infinite
628afcb5 1815loops using regular expressions, with something as innocuous as:
c84d73f1
IZ
1816
1817 'foo' =~ m{ ( o? )* }x;
1818
0d017f4d 1819The C<o?> matches at the beginning of C<'foo'>, and since the position
c84d73f1 1820in the string is not moved by the match, C<o?> would match again and again
527e91da 1821because of the C<*> quantifier. Another common way to create a similar cycle
c84d73f1
IZ
1822is with the looping modifier C<//g>:
1823
1824 @matches = ( 'foo' =~ m{ o? }xg );
1825
1826or
1827
1828 print "match: <$&>\n" while 'foo' =~ m{ o? }xg;
1829
1830or the loop implied by split().
1831
1832However, long experience has shown that many programming tasks may
14218588
GS
1833be significantly simplified by using repeated subexpressions that
1834may match zero-length substrings. Here's a simple example being:
c84d73f1
IZ
1835
1836 @chars = split //, $string; # // is not magic in split
1837 ($whitewashed = $string) =~ s/()/ /g; # parens avoid magic s// /
1838
9da458fc 1839Thus Perl allows such constructs, by I<forcefully breaking
c84d73f1 1840the infinite loop>. The rules for this are different for lower-level
527e91da 1841loops given by the greedy quantifiers C<*+{}>, and for higher-level
c84d73f1
IZ
1842ones like the C</g> modifier or split() operator.
1843
19799a22
GS
1844The lower-level loops are I<interrupted> (that is, the loop is
1845broken) when Perl detects that a repeated expression matched a
1846zero-length substring. Thus
c84d73f1
IZ
1847
1848 m{ (?: NON_ZERO_LENGTH | ZERO_LENGTH )* }x;
1849
5d458dd8 1850is made equivalent to
c84d73f1 1851
5d458dd8
YO
1852 m{ (?: NON_ZERO_LENGTH )*
1853 |
1854 (?: ZERO_LENGTH )?
c84d73f1
IZ
1855 }x;
1856
1857The higher level-loops preserve an additional state between iterations:
5d458dd8 1858whether the last match was zero-length. To break the loop, the following
c84d73f1 1859match after a zero-length match is prohibited to have a length of zero.
5d458dd8 1860This prohibition interacts with backtracking (see L<"Backtracking">),
c84d73f1
IZ
1861and so the I<second best> match is chosen if the I<best> match is of
1862zero length.
1863
19799a22 1864For example:
c84d73f1
IZ
1865
1866 $_ = 'bar';
1867 s/\w??/<$&>/g;
1868
20fb949f 1869results in C<< <><b><><a><><r><> >>. At each position of the string the best
5d458dd8 1870match given by non-greedy C<??> is the zero-length match, and the I<second
c84d73f1
IZ
1871best> match is what is matched by C<\w>. Thus zero-length matches
1872alternate with one-character-long matches.
1873
5d458dd8 1874Similarly, for repeated C<m/()/g> the second-best match is the match at the
c84d73f1
IZ
1875position one notch further in the string.
1876
19799a22 1877The additional state of being I<matched with zero-length> is associated with
c84d73f1 1878the matched string, and is reset by each assignment to pos().
9da458fc
IZ
1879Zero-length matches at the end of the previous match are ignored
1880during C<split>.
c84d73f1 1881
0d017f4d 1882=head2 Combining RE Pieces
35a734be
IZ
1883
1884Each of the elementary pieces of regular expressions which were described
1885before (such as C<ab> or C<\Z>) could match at most one substring
1886at the given position of the input string. However, in a typical regular
1887expression these elementary pieces are combined into more complicated
1888patterns using combining operators C<ST>, C<S|T>, C<S*> etc
1889(in these examples C<S> and C<T> are regular subexpressions).
1890
1891Such combinations can include alternatives, leading to a problem of choice:
1892if we match a regular expression C<a|ab> against C<"abc">, will it match
1893substring C<"a"> or C<"ab">? One way to describe which substring is
1894actually matched is the concept of backtracking (see L<"Backtracking">).
1895However, this description is too low-level and makes you think
1896in terms of a particular implementation.
1897
1898Another description starts with notions of "better"/"worse". All the
1899substrings which may be matched by the given regular expression can be
1900sorted from the "best" match to the "worst" match, and it is the "best"
1901match which is chosen. This substitutes the question of "what is chosen?"
1902by the question of "which matches are better, and which are worse?".
1903
1904Again, for elementary pieces there is no such question, since at most
1905one match at a given position is possible. This section describes the
1906notion of better/worse for combining operators. In the description
1907below C<S> and C<T> are regular subexpressions.
1908
13a2d996 1909=over 4
35a734be
IZ
1910
1911=item C<ST>
1912
1913Consider two possible matches, C<AB> and C<A'B'>, C<A> and C<A'> are
1914substrings which can be matched by C<S>, C<B> and C<B'> are substrings
5d458dd8 1915which can be matched by C<T>.
35a734be
IZ
1916
1917If C<A> is better match for C<S> than C<A'>, C<AB> is a better
1918match than C<A'B'>.
1919
1920If C<A> and C<A'> coincide: C<AB> is a better match than C<AB'> if
1921C<B> is better match for C<T> than C<B'>.
1922
1923=item C<S|T>
1924
1925When C<S> can match, it is a better match than when only C<T> can match.
1926
1927Ordering of two matches for C<S> is the same as for C<S>. Similar for
1928two matches for C<T>.
1929
1930=item C<S{REPEAT_COUNT}>
1931
1932Matches as C<SSS...S> (repeated as many times as necessary).
1933
1934=item C<S{min,max}>
1935
1936Matches as C<S{max}|S{max-1}|...|S{min+1}|S{min}>.
1937
1938=item C<S{min,max}?>
1939
1940Matches as C<S{min}|S{min+1}|...|S{max-1}|S{max}>.
1941
1942=item C<S?>, C<S*>, C<S+>
1943
1944Same as C<S{0,1}>, C<S{0,BIG_NUMBER}>, C<S{1,BIG_NUMBER}> respectively.
1945
1946=item C<S??>, C<S*?>, C<S+?>
1947
1948Same as C<S{0,1}?>, C<S{0,BIG_NUMBER}?>, C<S{1,BIG_NUMBER}?> respectively.
1949
c47ff5f1 1950=item C<< (?>S) >>
35a734be
IZ
1951
1952Matches the best match for C<S> and only that.
1953
1954=item C<(?=S)>, C<(?<=S)>
1955
1956Only the best match for C<S> is considered. (This is important only if
1957C<S> has capturing parentheses, and backreferences are used somewhere
1958else in the whole regular expression.)
1959
1960=item C<(?!S)>, C<(?<!S)>
1961
1962For this grouping operator there is no need to describe the ordering, since
1963only whether or not C<S> can match is important.
1964
6bda09f9 1965=item C<(??{ EXPR })>, C<(?PARNO)>
35a734be
IZ
1966
1967The ordering is the same as for the regular expression which is
6bda09f9 1968the result of EXPR, or the pattern contained by capture buffer PARNO.
35a734be
IZ
1969
1970=item C<(?(condition)yes-pattern|no-pattern)>
1971
1972Recall that which of C<yes-pattern> or C<no-pattern> actually matches is
1973already determined. The ordering of the matches is the same as for the
1974chosen subexpression.
1975
1976=back
1977
1978The above recipes describe the ordering of matches I<at a given position>.
1979One more rule is needed to understand how a match is determined for the
1980whole regular expression: a match at an earlier position is always better
1981than a match at a later position.
1982
0d017f4d 1983=head2 Creating Custom RE Engines
c84d73f1
IZ
1984
1985Overloaded constants (see L<overload>) provide a simple way to extend
1986the functionality of the RE engine.
1987
1988Suppose that we want to enable a new RE escape-sequence C<\Y|> which
0d017f4d 1989matches at a boundary between whitespace characters and non-whitespace
c84d73f1
IZ
1990characters. Note that C<(?=\S)(?<!\S)|(?!\S)(?<=\S)> matches exactly
1991at these positions, so we want to have each C<\Y|> in the place of the
1992more complicated version. We can create a module C<customre> to do
1993this:
1994
1995 package customre;
1996 use overload;
1997
1998 sub import {
1999 shift;
2000 die "No argument to customre::import allowed" if @_;
2001 overload::constant 'qr' => \&convert;
2002 }
2003
2004 sub invalid { die "/$_[0]/: invalid escape '\\$_[1]'"}
2005
580a9fe1
RGS
2006 # We must also take care of not escaping the legitimate \\Y|
2007 # sequence, hence the presence of '\\' in the conversion rules.
5d458dd8 2008 my %rules = ( '\\' => '\\\\',
c84d73f1
IZ
2009 'Y|' => qr/(?=\S)(?<!\S)|(?!\S)(?<=\S)/ );
2010 sub convert {
2011 my $re = shift;
5d458dd8 2012 $re =~ s{
c84d73f1
IZ
2013 \\ ( \\ | Y . )
2014 }
5d458dd8 2015 { $rules{$1} or invalid($re,$1) }sgex;
c84d73f1
IZ
2016 return $re;
2017 }
2018
2019Now C<use customre> enables the new escape in constant regular
2020expressions, i.e., those without any runtime variable interpolations.
2021As documented in L<overload>, this conversion will work only over
2022literal parts of regular expressions. For C<\Y|$re\Y|> the variable
2023part of this regular expression needs to be converted explicitly
2024(but only if the special meaning of C<\Y|> should be enabled inside $re):
2025
2026 use customre;
2027 $re = <>;
2028 chomp $re;
2029 $re = customre::convert $re;
2030 /\Y|$re\Y|/;
2031
1f1031fe
YO
2032=head1 PCRE/Python Support
2033
99d59c4d 2034As of Perl 5.10.0, Perl supports several Python/PCRE specific extensions
1f1031fe 2035to the regex syntax. While Perl programmers are encouraged to use the
99d59c4d 2036Perl specific syntax, the following are also accepted:
1f1031fe
YO
2037
2038=over 4
2039
ae5648b3 2040=item C<< (?PE<lt>NAMEE<gt>pattern) >>
1f1031fe
YO
2041
2042Define a named capture buffer. Equivalent to C<< (?<NAME>pattern) >>.
2043
2044=item C<< (?P=NAME) >>
2045
2046Backreference to a named capture buffer. Equivalent to C<< \g{NAME} >>.
2047
2048=item C<< (?P>NAME) >>
2049
2050Subroutine call to a named capture buffer. Equivalent to C<< (?&NAME) >>.
2051
ee9b8eae 2052=back
1f1031fe 2053
19799a22
GS
2054=head1 BUGS
2055
78288b8e
KW
2056There are numerous problems with case insensitive matching of characters
2057outside the ASCII range, especially with those whose folds are multiple
2058characters, such as ligatures like C<LATIN SMALL LIGATURE FF>.
2059
f253210b
KW
2060In a bracketed character class with case insensitive matching, ranges only work
2061for ASCII characters. For example,
2062C<m/[\N{CYRILLIC CAPITAL LETTER A}-\N{CYRILLIC CAPITAL LETTER YA}]/i>
2063doesn't match all the Russian upper and lower case letters.
2064
88c9975e
KW
2065Many regular expression constructs don't work on EBCDIC platforms.
2066
9da458fc
IZ
2067This document varies from difficult to understand to completely
2068and utterly opaque. The wandering prose riddled with jargon is
2069hard to fathom in several places.
2070
2071This document needs a rewrite that separates the tutorial content
2072from the reference content.
19799a22
GS
2073
2074=head1 SEE ALSO
9fa51da4 2075
91e0c79e
MJD
2076L<perlrequick>.
2077
2078L<perlretut>.
2079
9b599b2a
GS
2080L<perlop/"Regexp Quote-Like Operators">.
2081
1e66bd83
PP
2082L<perlop/"Gory details of parsing quoted constructs">.
2083
14218588
GS
2084L<perlfaq6>.
2085
9b599b2a
GS
2086L<perlfunc/pos>.
2087
2088L<perllocale>.
2089
fb55449c
JH
2090L<perlebcdic>.
2091
14218588
GS
2092I<Mastering Regular Expressions> by Jeffrey Friedl, published
2093by O'Reilly and Associates.