1PCRE2(3) User Contributed Perl Documentation PCRE2(3)
2
6 re::engine::PCRE2 - PCRE2 regular expression engine with jit
7
9 use re::engine::PCRE2;
10 if ("Hello, world" =~ /(?<=Hello|Hi), (world)/) {
12 print "Greetings, $1!";
13 }
14
16 Replaces perl's regex engine in a given lexical scope with PCRE2
17 regular expressions provided by libpcre2-8.
18 This provides jit support and faster matching, but may fail in corner
20 cases. See pcre2compat
21 <http://www.pcre.org/current/doc/html/pcre2compat.html>. It is
22 typically 50% faster than the core regex engine. See "BENCHMARKS".
23 The goal is to pass the full core re testsuite, identify all
25 problematic patterns and fall-back to the core re engine. From the
26 1330 core tests, 46 currently fail. 90% of the most popular cpan
27 modules do work fine already. Note that older perl version do fail more
28 regression tests. See "FAILING TESTS".
29 Note that some packaged libpcre2-8 libraries do not enable the jit
31 compiler. "CFLAGS=-fPIC cmake -DPCRE2_SUPPORT_JIT=ON; make" PCRE2 then
32 silently falls back to the normal PCRE2 compiler and matcher.
33 Check with:
35 perl -Mre::engine::PCRE2 -e'print re::engine::PCRE2::JIT'
37
39 Since re::engine::PCRE2 derives from the "Regexp" package, you can call
40 compiled "qr//" objects with these methods. See PCRE2 NATIVE API MATCH
41 CONTEXT FUNCTIONS
42 <http://www.pcre.org/current/doc/html/pcre2api.html#SEC5> and
43 INFORMATION ABOUT A COMPILED PATTERN
44 <http://www.pcre.org/current/doc/html/pcre2api.html#SEC22>.
45 With older library versions which do not support a particular info
47 method, undef is returned. E.g. hasbackslashc and framesize.
48 _alloptions (RX)
50 The result of pcre2_pattern_info(PCRE2_INFO_ALLOPTIONS) as unsigned
51 integer.
52 my $q=qr/(a)/; print $q->_alloptions
54 => 64
55 64 stands for PCRE2_DUPNAMES which is always set. See pcre2.h
57 _argoptions (RX)
59 The result of pcre2_pattern_info(PCRE2_INFO_ARGOPTIONS) as unsigned
60 integer.
61 my $q=qr/(a)/i; print $q->_argoptions
63 => 72
64 72 = 64+8 64 stands for PCRE2_DUPNAMES which is always set. 8 for
66 PCRE2_CASELESS. See pcre2.h
67 backrefmax (RX)
69 Return the number of the highest back reference in the pattern.
70 my $q=qr/(a)\1/; print $q->backrefmax
72 => 1
73 my $q=qr/(a)(?(1)a|b)/; print $q->backrefmax
74 => 1
75 bsr (RX)
77 What character sequences the "\R" escape sequence matches. 1 means
78 that "\R" matches any Unicode line ending sequence; 2 means that
79 "\R" matches only CR, LF, or CRLF.
80 capturecount (RX)
82 Return the highest capturing subpattern number in the pattern. In
83 patterns where "(?|" is not used, this is also the total number of
84 capturing subpatterns.
85 my $q=qr/(a(b))/; print $q->capturecount
87 => 2
88 firstbitmap (RX)
90 In the absence of a single first code unit for a non-anchored
91 pattern, "pcre2_compile()" may construct a 256-bit table that
92 defines a fixed set of values for the first code unit in any match.
93 For example, a pattern that starts with "[abc]" results in a table
94 with three bits set. When code unit values greater than 255 are
95 supported, the flag bit for 255 means "any code unit of value 255
96 or above". If such a table was constructed, it is returned as
97 string.
98 firstcodetype (RX)
100 Return information about the first code unit of any matched string,
101 for a non-anchored pattern. If there is a fixed first value, for
102 example, the letter "c" from a pattern such as "(cat|cow|coyote)",
103 1 is returned, and the character value can be retrieved using
104 "firstcodeunit". If there is no fixed first value, but it is known
105 that a match can occur only at the start of the subject or
106 following a newline in the subject, 2 is returned. Otherwise, and
107 for anchored patterns, 0 is returned.
108 firstcodeunit (RX)
110 Return the value of the first code unit of any matched string in
111 the situation where "firstcodetype (RX)" returns 1; otherwise
112 return 0. The value is always less than 256.
113 my $q=qr/(cat|cow|coyote)/; print $q->firstcodetype, $q->firstcodeunit
115 => 1 99
116 framesize (RX)
118 Undocumented. Only available since pcre-10.24. Returns undef on
119 older versions. The pcre2_match() frame size.
120 hasbackslashc (RX)
122 Return 1 if the pattern contains any instances of \C, otherwise 0.
123 Note that \C is forbidden since perl 5.26 (?). With an older pcre2
124 library undef will be returned.
125 hascrorlf (RX)
127 Return 1 if the pattern contains any explicit matches for CR or LF
128 characters, otherwise 0. An explicit match is either a literal CR
129 or LF character, or \r or \n.
130 heaplimit (RX, [INT])
132 Get or set the backtracking heap limit in a match context. If the
133 option is not set, build-time 'HEAPLIMIT' option is in effect,
134 which is 20000000. See "config (OPTION)". Added only since 10.30,
135 with earlier versions it will return undef. The setter method is
136 not yet implemented.
137 jchanged (RX)
139 Return 1 if the (?J) or (?-J) option setting is used in the
140 pattern, otherwise 0. (?J) and (?-J) set and unset the local
141 PCRE2_DUPNAMES option, respectively.
142 jitsize (RX)
144 If the compiled pattern was successfully processed by
145 pcre2_jit_compile(), return the size of the JIT compiled code,
146 otherwise return zero.
147 lastcodetype (RX)
149 Returns 1 if there is a rightmost literal code unit that must exist
150 in any matched string, other than at its start. If there is no such
151 value, 0 is returned. When 1 is returned, the code unit value
152 itself can be retrieved using "lastcodeunit (RX)". For anchored
153 patterns, a last literal value is recorded only if it follows
154 something of variable length. For example, for the pattern
155 "/^a\d+z\d+/" the returned value is 1 (with "z" returned from
156 lastcodeunit), but for "/^a\dz\d/" the returned value is 0.
157 lastcodeunit (RX)
159 Return the value of the rightmost literal data unit that must exist
160 in any matched string, other than at its start, if such a value has
161 been recorded. If there is no such value, 0 is returned.
162 matchempty (RX)
164 Return 1 if the pattern might match an empty string, otherwise 0.
165 When a pattern contains recursive subroutine calls it is not always
166 possible to determine whether or not it can match an empty string.
167 PCRE2 takes a cautious approach and returns 1 in such cases.
168 matchlimit (RX, [INT])
170 Get or set the match_limit match context. Corresponds to the pcre-
171 specific "(*LIMIT_MATCH=nnnn)" option. If the option is not set,
172 build-time 'MATCHLIMIT' option is in effect, which is 10000000.
173 See "config (OPTION)".
174 maxlookbehind (RX)
176 Return the number of characters (not code units) in the longest
177 lookbehind assertion in the pattern. This information is useful
178 when doing multi-segment matching using the partial matching
179 facilities. Note that the simple assertions \b and \B require a
180 one-character lookbehind. \A also registers a one-character
181 lookbehind, though it does not actually inspect the previous
182 character. This is to ensure that at least one character from the
183 old segment is retained when a new segment is processed. Otherwise,
184 if there are no lookbehinds in the pattern, \A might match
185 incorrectly at the start of a new segment.
186 minlength (RX)
188 If a minimum length for matching subject strings was computed, its
189 value is returned. Otherwise the returned value is 0. The value is
190 a number of characters, which in UTF mode may be different from the
191 number of code units. The value is a lower bound to the length of
192 any matching string. There may not be any strings of that length
193 that do actually match, but every string that does match is at
194 least that long.
195 namecount (RX)
197 nameentrysize (RX)
198 PCRE2 supports the use of named as well as numbered capturing
199 parentheses. The names are just an additional way of identifying
200 the parentheses, which still acquire numbers. Several convenience
201 functions such as pcre2_substring_get_byname() are provided for
202 extracting captured substrings by name. It is also possible to
203 extract the data directly, by first converting the name to a number
204 in order to access the correct pointers in the output vector. To do
205 the conversion, you need to use the name-to-number map, which is
206 described by these three values.
207 The map consists of a number of fixed-size entries. namecount gives
209 the number of entries, and nameentrysize gives the size of each
210 entry in code units; The entry size depends on the length of the
211 longest name.
212 The nametable itself is not yet returned.
214 newline (RX, [INT]))
216 Get or set the newline regime. The default is the build-time
217 'NEWLINE' option, i.e. 2 on non-windows systems. See "config
218 (OPTION)". The setter method is not yet implemented.
219 recursionlimit (RX, [INT])
221 Get or set a recursion limit, i.e. the pcre specific
222 "(*LIMIT_RECURSION=nnnn)" option. The default is the build-time
223 'RECURSIONLIMIT' option. See "config (OPTION)". The setter method
224 is not yet implemented.
225 size (RX)
227 Return the size of the compiled pattern in bytes. This value
228 includes the size of the general data block that precedes the code
229 units of the compiled pattern itself. The value that is used when
230 "pcre2_compile()" is getting memory in which to place the compiled
231 pattern may be slightly larger than the value returned by this
232 option, because there are cases where the code that calculates the
233 size has to over-estimate. Processing a pattern with the JIT
234 compiler does not alter the value returned by this option.
235
237 import
238 import lexically sets the PCRE2 engine to be active.
239 import will later accept compile context options. See PCRE2 NATIVE
241 API COMPILE CONTEXT FUNCTIONS
242 <http://www.pcre.org/current/doc/html/pcre2api.html#SEC4>.
243 bsr => INT (default: 1)
245 max_pattern_length => INT
246 newline => INT (default: 2)
247 parenslimit => INT (default: 250)
248 matchlimit => INT (default: 10000000)
249 offsetlimit => INT (default: ?)
250 recursionlimit => INT (default: 10000000) i.e. the depthlimit
251 heaplimit => INT (default: 20000000) ony since 10.30
252 unimport
254 unimport sets the regex engine to the previous one. If PCRE2 with
255 the previous context options.
256 offsetlimit ([INT])
258 Get or set the offset_limit in the match context. The method is
259 not yet implemented.
260 parenslimit ([INT])
262 Get or set the parens_nest_limit in the match context. The default
263 is the build-time 'PARENSLIMIT' option, 250. See "config
264 (OPTION)". The method is not yet implemented.
265 ENGINE
267 Returns a pointer to the internal PCRE2 engine, suitable for the XS
268 API "(regexp*)re->engine" field.
269 JIT Returns 1 or 0, if the JIT engine is available or not.
271 config (OPTION)
273 Returns build-time information about libpcre2. Note that some of
274 these options may later be set'able at run-time.
275 OPTIONS can be one of the following strings:
277 JITTARGET
279 UNICODE_VERSION
280 VERSION
281 BSR
283 JIT
284 LINKSIZE
285 MATCHLIMIT
286 HEAPLIMIT (Only since 10.30)
287 NEWLINE
288 PARENSLIMIT
289 DEPTHLIMIT (Not always defined)
290 RECURSIONLIMIT (Obsolete synonym for DEPTHLIMIT)
291 STACKRECURSE (Obsolete. Always 0 in newer libs)
292 UNICODE
293 The first three options return a string, the rest an integer. In
295 case of internal errors, e.g. the new option is not yet supported
296 by libpcre, undef is returned. See
297 <http://www.pcre.org/current/doc/html/pcre2api.html#SEC17>.
298 NEWLINE returns an integer, representing:
300 PCRE2_NEWLINE_CR 1
302 PCRE2_NEWLINE_LF 2
303 PCRE2_NEWLINE_CRLF 3
304 PCRE2_NEWLINE_ANY 4 Any Unicode line ending
305 PCRE2_NEWLINE_ANYCRLF 5 Any of CR, LF, or CRLF
306 The default is OS specific.
308 BSR returns an integer, representing:
310 PCRE2_BSR_UNICODE 1
312 PCRE2_BSR_ANYCRLF 2
313 A value of PCRE2_BSR_UNICODE means that "\R" matches any Unicode
315 line ending sequence; a value of PCRE2_BSR_ANYCRLF means that "\R"
316 matches only CR, LF, or CRLF.
317 The default is 1 for UNICODE, as all libpcre2 libraries are now
319 compiled with unicode support builtin. ("--enable-unicode").
320
322 time perl5.24.1 -Mblib t/perl/regexp.t 10000 >/dev/null
323 Without PCRE2:
325 34.327s
327 With PCRE2:
329 17.922s - 50% faster
331
333 About 90% of all core tests and cpan modules do work with
334 re::engine::PCRE2 already, but there are still some unresolved
335 problems. Esp. when the pattern is not detectable or marked as UTF-8
336 but the subject is, the match will be performed without UTF-8.
337 Try the new faster matcher with "export PERL5OPT=-Mre::engine::PCRE2".
339 Known problematic popular modules are: Test-Harness-3.38,
341 Params-Util-1.07 t/12_main.t 552-553, 567-568, HTML-Parser-3.72
342 (unicode), DBI-1.636 (EUMM problem), DBD-SQLite-1.54 (xsubpp),
343 Sub-Name-0.21 t/exotic_names.t:105, XML-LibXML-2.0129 (local charset),
344 Module-Install-1.18 unrecognized character after (? or (?-,
345 Text-CSV_XS-1.28 (unicode), YAML-Syck-1.29, MD5-2.03, XML-Parser-2.44,
346 Module-Build-0.4222, libwww-perl-6.25.
347 As of 0.05 the following core regression tests still fail:
349 perl -C -Mblib t/perl/regexp.t | grep -a TODO
351 # new patterns and pcre2 fails: need to fallback
353 143..146, # \B{gcb} \B{lb} \B{sb} \B{wb}
354 352, # '^'i:ABC:y:$&:
355 402, # '(a+|b){0,1}?'i
356 409, # 'a*'i $&
357 578, # '(b.)c(?!\N)'s:a
358 654,655,664, # unicode
359 667, # '[[:^cntrl:]]+'u:a\x80:y:$&:a
360 # Pathological patterns that run into run-time PCRE_ERROR_MATCHLIMIT,
362 # even with huge set_match_limit 512mill
363 880 .. 897, # .X(.+)+[X][X]:bbbbXXXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
364 # aba =~ ^(a(b)?)+$ and aabbaa =~ ^(aa(bb)?)+$
366 941, # ^(a(b)?)+$:aba:y:-$1-$2-:-a-- => `-a-b-', match=1
367 942, # ^(aa(bb)?)+$:aabbaa:y:-$1-$2-:-aa-- => `-aa-bb-', match=1
368 947, # ^(a\1?){4}$:aaaaaa:y:$1:aa => `', match=
369 # empty codeblock
371 1005, #TODO (??{}):x:y:-:- => error `Eval-group not allowed at runtime, use re 'eval' in regex m/(??{})/ at (eval 5663) line 1.'
372 # XXX: <<<>>> pattern
374 1096, # ^(<(?:[^<>]+|(?3)|(?1))*>)()(!>!>!>)$:<<!>!>!>><>>!>!>!>:y:$1:<<!>!>!>><>> => `', match=
375 1126, # /^(?'main'<(?:[^<>]+|(?&crap)|(?&main))*>)(?'empty')(?'crap'!>!>!>)$/:<<!>!>!>><>>!>!>!>:yM:$+{main}:<<!>!>!>><>> => `', match=
376 # XXX: \R doesn't match an utf8::upgraded \x{85}, we need to
378 # always convert the subject and pattern to utf-8 for these cases
379 # to work
380 1378, # (utf8::upgrade($subject)) foo(\R+)bar:foo\r
381 1380, # (utf8::upgrade($subject)) (\R+)(\V):foo\r
382 1381, # (utf8::upgrade($subject)) foo(\R)bar:foo\x{85}bar:y:$1:\x{85} => `', match=
383 1382, # (utf8::upgrade($subject)) (\V)(\R):foo\x{85}bar:y:$1-$2:o-\x{85} => `�-�', match=1
384 1394, # (utf8::upgrade($subject)) foo(\v+)bar:foo\r
385 1396..1398, # (utf8::upgrade($subject)) (\v+)(\V):foo\r
386 1405,1407..1409, # (utf8::upgrade($subject)) foo(\h+)bar:foo\t\x{A0}bar:y:$1:\t\x{A0} => `', match=
387 # regressions in 5.8.x (only) introduced by change 30638
389 1433, # /^\s*i.*?o\s*$/s:io
390 1446, #/\N{}\xe4/i:\xc4:y:$&:\xc4 => error `Unknown charname '' is deprecated. Its use will be fatal in Perl 5.28 at (eval 7892) line 2.'
392 1484, # /abc\N {U+41}/x:-:c:-:Missing braces => `-', match=
393 1485, # /abc\N {SPACE}/x:-:c:-:Missing braces => `-', match=
394 1490, # /\N{U+BEEF.BEAD}/:-:c:-: => `-', match=
395 1495, # \c`:-:ac:-:\"\\c`\" is more clearly written simply as \"\\ \" => `-', match=
397 1496, # \c1:-:ac:-:\"\\c1\" is more clearly written simply as \"q\" => `-', match=
398 1514, # \c?:\x9F:ey:$&:\x9F => `\', match=
400 1575, # [\8\9]:\000:Sn:-:- => `-', match=
402 1576, # [\8\9]:-:sc:$&:Unrecognized escape \\8 in character class => `[', match=
403 1582, # [\0]:-:sc:-:Need exactly 3 octal digits => `-', match=
405 1584, # [\07]:-:sc:-:Need exactly 3 octal digits => `-', match=
406 1585, # [\07]:7\000:Sn:-:- => `-', match=
407 1586, # [\07]:-:sc:-:Need exactly 3 octal digits => `-', match=
408 1599, # /\xe0\pL/i:\xc0a:y:$&:\xc0a => `/', match=
410 1618, # ^_?[^\W_0-9]\w\z:\xAA\x{100}:y:$&:\xAA\x{100} => `^', match=
412 1621, # /s/ai:\x{17F}:y:$&:\x{17F} => `/', match=
413 1630, # /[^\x{1E9E}]/i:\x{DF}:Sn:-:- => `-', match=
415 1639, # /^\p{L}/:\x{3400}:y:$&:\x{3400} => `�', match=1
416 1642, # /[s\xDF]a/ui:ssa:Sy:$&:ssa => `sa', match=1
417 1648, # /ff/i:\x{FB00}\x{FB01}:y:$&:\x{FB00} => `/', match=
419 1649, # /ff/i:\x{FB01}\x{FB00}:y:$&:\x{FB00} => `/', match=
420 1650, # /fi/i:\x{FB01}\x{FB00}:y:$&:\x{FB01} => `/', match=
421 1651, # /fi/i:\x{FB00}\x{FB01}:y:$&:\x{FB01} => `/', match=
422 # These test that doesn't cut-off matching too soon in the string for
424 # multi-char folds
425 1669, # /ffiffl/i:abcdef\x{FB03}\x{FB04}:y:$&:\x{FB03}\x{FB04} => `/', match=
426 1670, # /\xdf\xdf/ui:abcdefssss:y:$&:ssss => `/', match=
427 1672, # /st/i:\x{DF}\x{FB05}:y:$&:\x{FB05} => `/', match=
428 1673, # /ssst/i:\x{DF}\x{FB05}:y:$&:\x{DF}\x{FB05} => `/', match=
429 # [perl #101970]
430 1678, # /[[:lower:]]/i:\x{100}:y:$&:\x{100} => `/', match=
431 1679, # /[[:upper:]]/i:\x{101}:y:$&:\x{101} => `/', match=
432 # Was matching 'ss' only and failing the entire match, not seeing the
433 # alternative that would succeed
434 1683, # /s\xDF/ui:\xDFs:y:$&:\xDFs => `/', match=
435 1684, # /sst/ui:s\N{LATIN SMALL LIGATURE ST}:y:$&:s\N{LATIN SMALL LIGATURE ST} => `/', match=
436 1685, # /sst/ui:s\N{LATIN SMALL LIGATURE LONG S T}:y:$&:s\N{LATIN SMALL LIGATURE LONG S T} => `/', match=
437 # [perl #111400]. Tests the first Y/N boundary above 255 for each of these.
439 1699, # /[[:alnum:]]/:\x{2c1}:y:-:- => `-', match=
440 1701, # /[[:alpha:]]/:\x{2c1}:y:-:- => `-', match=
441 1703, # /[[:graph:]]/:\x{377}:y:-:- => `-', match=
442 1706, # /[[:lower:]]/:\x{101}:y:-:- => `-', match=
443 1708, # /[[:print:]]/:\x{377}:y:-:- => `-', match=
444 1711, # /[[:punct:]]/:\x{37E}:y:-:- => `-', match=
445 1713, # /[[:upper:]]/:\x{100}:y:-:- => `-', match=
446 1715, # /[[:word:]]/:\x{2c1}:y:-:- => `-', match=
447 # $^N, $+ on backtrackracking
449 # BRANCH
450 1739, # ^(.)(?:(..)|B)[CX]:ABCDE:y:$^N-$+:A-A => `-', match=1
451 # TRIE
452 1741, # ^(.)(?:BC(.)|B)[CX]:ABCDE:y:$^N-$+:A-A => `-', match=1
453 # CURLYX
454 1743, # ^(.)(?:(.)+)*[BX]:ABCDE:y:$^N-$+:A-A => `-', match=1
455 # CURLYM
456 1746, # ^(.)(BC)*[BX]:ABCDE:y:$^N-$+:A-A => `-', match=1
457 # CURLYN
458 1749, # ^(.)(B)*.[CX]:ABCDE:y:$^N-$+:A-A => `-', match=1
459 # [perl #114220]
461 1793, # (utf8::upgrade($subject)) /[\H]/:\x{BF}:y:$&:\xBF => `�', match=1
462 1794, # (utf8::upgrade($subject)) /[\H]/:\x{A0}:n:-:- => false positive
463 1795, # (utf8::upgrade($subject)) /[\H]/:\x{A1}:y:$&:\xA1 => `�', match=1
464 # \W in pattern -> !UTF8: add UTF if subject is UTF8 [#15]
466 1804..1807, # \w:\x{200C}:y:$&:\x{200C} => `\', match=
467 #1805, # \W:\x{200C}:n:-:- => false positive
468 #1806, # \w:\x{200D}:y:$&:\x{200D} => `\', match=
469 #1807, # \W:\x{200D}:n:-:- => false positive
470 # again missing UTF [#15]
472 1818..1820, # /^\D{11}/a:\x{10FFFF}\x{10FFFF}\x{10FFFF}\x{10FFFF}\x{10FFFF}\x{10FFFF}\x{10FFFF}\x{10FFFF}\x{10FFFF}\x{10FFFF}:n:-:- => false positive
473 1823, # (utf8::upgrade($subject)) \Vn:\xFFn/:y:$&:\xFFn => `�n', match=1
474 1830, # a?\X:a\x{100}:y:$&:a\x{100} => `a�', match=1
475 1892, # /^\S+=/d:\x{3a3}=\x{3a0}:y:$&:\x{3a3}= => `Σ=', match=1
476 1893, # /^\S+=/u:\x{3a3}=\x{3a0}:y:$&:\x{3a3}= => `Σ=', match=1
477 1936, # /[a-z]/i:\N{KELVIN SIGN}:y:$&:\N{KELVIN SIGN} => `/', match=
478 1937, # /[A-Z]/ia:\N{KELVIN SIGN}:y:$&:\N{KELVIN SIGN} => `/', match=
479 1939, # /[A-Z]/i:\N{LATIN SMALL LETTER LONG S}:y:$&:\N{LATIN SMALL LETTER LONG S} => `/', match=
480 1964, # \N(?#comment){SPACE}:A:c:-:Missing braces on \\N{} => `-', match=
482 1983, # /(?xx:[a b])/x:\N{SPACE}:n:-:- => false positive
483 1985, # /(?xx)[a b]/x:\N{SPACE}:n:-:- => false positive
484 # [perl #125825]
486 1945, # /(a+){1}+a/:aaa:n:-:- => false positive
487 # [perl 128420] recursive matches
489 1976, # aa$|a(?R)a|a:aaa:y:$&:aaa => `a', match=1
490 Note that core tests suite also reveals that about a similar number of
492 fails occur with older perls, without PCRE2. Many of them pass with
493 PCRE2.
494 Failures in older perls:
496 -5.12: 629, 1367 (fatal)
498 -5.10: 40..51, 90..91, 93..94, 96..97, 105, 356, 539,
499 541, 543, 577, 1360, 1416, 1418, 1456..1457,
500 1461..1462
501 -5.12: 1448, 1521, 1524, 1577..1578, 1594..1596,
502 1598, 1674..1675
503 -5.14: 1633..1634
504 -5.16: 871, 1745, 1789, 1816
505 -5.18: 1674..1675, 1856..1857, 1885..1886, 1889
506 -5.20: 138..142
507 -5.22: 139, 1958, 1965
508 -5.24: 1977
509 Invalid tests for older perls (fatal):
511 -5.14: 1684..1996
513 -5.20: 1896..1996
514 -5.26: 1981..1996
515
517 Reini Urban <rurban@cpan.org>
518
520 Copyright 2007 Ævar Arnfjörð Bjarmason. Copyright 2017 Reini Urban.
521 The original version was copyright 2006 Audrey Tang <cpan@audreyt.org>
523 and Yves Orton.
524 This program is free software; you can redistribute it and/or modify it
526 under the same terms as Perl itself.
527perl v5.30.0 2019-07-26 PCRE2(3)