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