| 1 |
|
/-- This set of tests is not Perl-compatible. It checks on special features |
| 2 |
|
of PCRE's API, error diagnostics, and the compiled code of some patterns. |
| 3 |
|
It also checks the non-Perl syntax the PCRE supports (Python, .NET, |
| 4 |
|
Oniguruma). Finally, there are some tests where PCRE and Perl differ, |
| 5 |
|
either because PCRE can't be compatible, or there is a possible Perl |
| 6 |
|
bug. --/ |
| 7 |
|
|
| 8 |
|
/-- Originally, the Perl 5.10 and 5.11 things were in here too, but now I have |
| 9 |
|
separated many (most?) of them out into test 11. However, there may still |
| 10 |
|
be some that were overlooked. --/ |
| 11 |
|
|
| 12 |
/(a)b|/I |
/(a)b|/I |
| 13 |
Capturing subpattern count = 1 |
Capturing subpattern count = 1 |
| 14 |
No options |
No options |
| 103 |
/(?X)[\B]/ |
/(?X)[\B]/ |
| 104 |
Failed: invalid escape sequence in character class at offset 6 |
Failed: invalid escape sequence in character class at offset 6 |
| 105 |
|
|
| 106 |
|
/(?X)[\R]/ |
| 107 |
|
Failed: invalid escape sequence in character class at offset 6 |
| 108 |
|
|
| 109 |
|
/(?X)[\X]/ |
| 110 |
|
Failed: invalid escape sequence in character class at offset 6 |
| 111 |
|
|
| 112 |
|
/[\B]/BZ |
| 113 |
|
------------------------------------------------------------------ |
| 114 |
|
Bra |
| 115 |
|
B |
| 116 |
|
Ket |
| 117 |
|
End |
| 118 |
|
------------------------------------------------------------------ |
| 119 |
|
|
| 120 |
|
/[\R]/BZ |
| 121 |
|
------------------------------------------------------------------ |
| 122 |
|
Bra |
| 123 |
|
R |
| 124 |
|
Ket |
| 125 |
|
End |
| 126 |
|
------------------------------------------------------------------ |
| 127 |
|
|
| 128 |
|
/[\X]/BZ |
| 129 |
|
------------------------------------------------------------------ |
| 130 |
|
Bra |
| 131 |
|
X |
| 132 |
|
Ket |
| 133 |
|
End |
| 134 |
|
------------------------------------------------------------------ |
| 135 |
|
|
| 136 |
/[z-a]/ |
/[z-a]/ |
| 137 |
Failed: range out of order in character class at offset 3 |
Failed: range out of order in character class at offset 3 |
| 138 |
|
|
| 175 |
No options |
No options |
| 176 |
No first char |
No first char |
| 177 |
No need char |
No need char |
| 178 |
|
Subject length lower bound = 3 |
| 179 |
Starting byte set: c d e |
Starting byte set: c d e |
| 180 |
this sentence eventually mentions a cat |
this sentence eventually mentions a cat |
| 181 |
0: cat |
0: cat |
| 187 |
Options: caseless |
Options: caseless |
| 188 |
No first char |
No first char |
| 189 |
No need char |
No need char |
| 190 |
|
Subject length lower bound = 3 |
| 191 |
Starting byte set: C D E c d e |
Starting byte set: C D E c d e |
| 192 |
this sentence eventually mentions a CAT cat |
this sentence eventually mentions a CAT cat |
| 193 |
0: CAT |
0: CAT |
| 199 |
No options |
No options |
| 200 |
No first char |
No first char |
| 201 |
No need char |
No need char |
| 202 |
|
Subject length lower bound = 1 |
| 203 |
Starting byte set: a b c d |
Starting byte set: a b c d |
| 204 |
|
|
| 205 |
/(a|[^\dZ])/IS |
/(a|[^\dZ])/IS |
| 207 |
No options |
No options |
| 208 |
No first char |
No first char |
| 209 |
No need char |
No need char |
| 210 |
|
Subject length lower bound = 1 |
| 211 |
Starting byte set: \x00 \x01 \x02 \x03 \x04 \x05 \x06 \x07 \x08 \x09 \x0a |
Starting byte set: \x00 \x01 \x02 \x03 \x04 \x05 \x06 \x07 \x08 \x09 \x0a |
| 212 |
\x0b \x0c \x0d \x0e \x0f \x10 \x11 \x12 \x13 \x14 \x15 \x16 \x17 \x18 \x19 |
\x0b \x0c \x0d \x0e \x0f \x10 \x11 \x12 \x13 \x14 \x15 \x16 \x17 \x18 \x19 |
| 213 |
\x1a \x1b \x1c \x1d \x1e \x1f \x20 ! " # $ % & ' ( ) * + , - . / : ; < = > |
\x1a \x1b \x1c \x1d \x1e \x1f \x20 ! " # $ % & ' ( ) * + , - . / : ; < = > |
| 228 |
No options |
No options |
| 229 |
No first char |
No first char |
| 230 |
No need char |
No need char |
| 231 |
|
Subject length lower bound = 1 |
| 232 |
Starting byte set: \x09 \x0a \x0c \x0d \x20 a b |
Starting byte set: \x09 \x0a \x0c \x0d \x20 a b |
| 233 |
|
|
| 234 |
/(ab\2)/ |
/(ab\2)/ |
| 562 |
No options |
No options |
| 563 |
No first char |
No first char |
| 564 |
No need char |
No need char |
| 565 |
|
Subject length lower bound = 1 |
| 566 |
Starting byte set: a b c d |
Starting byte set: a b c d |
| 567 |
|
|
| 568 |
/(?i)[abcd]/IS |
/(?i)[abcd]/IS |
| 570 |
Options: caseless |
Options: caseless |
| 571 |
No first char |
No first char |
| 572 |
No need char |
No need char |
| 573 |
|
Subject length lower bound = 1 |
| 574 |
Starting byte set: A B C D a b c d |
Starting byte set: A B C D a b c d |
| 575 |
|
|
| 576 |
/(?m)[xy]|(b|c)/IS |
/(?m)[xy]|(b|c)/IS |
| 578 |
Options: multiline |
Options: multiline |
| 579 |
No first char |
No first char |
| 580 |
No need char |
No need char |
| 581 |
|
Subject length lower bound = 1 |
| 582 |
Starting byte set: b c x y |
Starting byte set: b c x y |
| 583 |
|
|
| 584 |
/(^a|^b)/Im |
/(^a|^b)/Im |
| 643 |
No options |
No options |
| 644 |
First char = 'b' (caseless) |
First char = 'b' (caseless) |
| 645 |
No need char |
No need char |
| 646 |
Study returned NULL |
Subject length lower bound = 1 |
| 647 |
|
No set of starting bytes |
| 648 |
|
|
| 649 |
/(a*b|(?i:c*(?-i)d))/IS |
/(a*b|(?i:c*(?-i)d))/IS |
| 650 |
Capturing subpattern count = 1 |
Capturing subpattern count = 1 |
| 651 |
No options |
No options |
| 652 |
No first char |
No first char |
| 653 |
No need char |
No need char |
| 654 |
|
Subject length lower bound = 1 |
| 655 |
Starting byte set: C a b c d |
Starting byte set: C a b c d |
| 656 |
|
|
| 657 |
/a$/I |
/a$/I |
| 716 |
No options |
No options |
| 717 |
No first char |
No first char |
| 718 |
No need char |
No need char |
| 719 |
|
Subject length lower bound = 1 |
| 720 |
Starting byte set: a b |
Starting byte set: a b |
| 721 |
|
|
| 722 |
/(?<!foo)(alpha|omega)/IS |
/(?<!foo)(alpha|omega)/IS |
| 724 |
No options |
No options |
| 725 |
No first char |
No first char |
| 726 |
Need char = 'a' |
Need char = 'a' |
| 727 |
|
Subject length lower bound = 5 |
| 728 |
Starting byte set: a o |
Starting byte set: a o |
| 729 |
|
|
| 730 |
/(?!alphabet)[ab]/IS |
/(?!alphabet)[ab]/IS |
| 732 |
No options |
No options |
| 733 |
No first char |
No first char |
| 734 |
No need char |
No need char |
| 735 |
|
Subject length lower bound = 1 |
| 736 |
Starting byte set: a b |
Starting byte set: a b |
| 737 |
|
|
| 738 |
/(?<=foo\n)^bar/Im |
/(?<=foo\n)^bar/Im |
| 887 |
a |
a |
| 888 |
No match |
No match |
| 889 |
|
|
| 890 |
/This one is here because I think Perl 5.005_02 gets the setting of $1 wrong/I |
/This one is here because Perl behaves differently; see also the following/I |
| 891 |
Capturing subpattern count = 0 |
Capturing subpattern count = 0 |
| 892 |
No options |
No options |
| 893 |
First char = 'T' |
First char = 'T' |
| 899 |
Options: anchored |
Options: anchored |
| 900 |
No first char |
No first char |
| 901 |
No need char |
No need char |
| 902 |
|
aaaa |
| 903 |
|
No match |
| 904 |
aaaaaa |
aaaaaa |
| 905 |
0: aaaaaa |
No match |
| 906 |
1: aa |
|
| 907 |
|
/Perl does not fail these two for the final subjects. Neither did PCRE until/ |
| 908 |
|
/release 8.01. The problem is in backtracking into a subpattern that contains/ |
| 909 |
|
No match |
| 910 |
|
/a recursive reference to itself. PCRE has now made these into atomic patterns./ |
| 911 |
|
No match |
| 912 |
|
|
| 913 |
|
/^(xa|=?\1a){2}$/ |
| 914 |
|
xa=xaa |
| 915 |
|
0: xa=xaa |
| 916 |
|
1: =xaa |
| 917 |
|
** Failers |
| 918 |
|
No match |
| 919 |
|
xa=xaaa |
| 920 |
|
No match |
| 921 |
|
|
| 922 |
|
/^(xa|=?\1a)+$/ |
| 923 |
|
xa=xaa |
| 924 |
|
0: xa=xaa |
| 925 |
|
1: =xaa |
| 926 |
|
** Failers |
| 927 |
|
No match |
| 928 |
|
xa=xaaa |
| 929 |
|
No match |
| 930 |
|
|
| 931 |
/These are syntax tests from Perl 5.005/I |
/These are syntax tests from Perl 5.005/I |
| 932 |
Capturing subpattern count = 0 |
Capturing subpattern count = 0 |
| 1726 |
Options: anchored |
Options: anchored |
| 1727 |
No first char |
No first char |
| 1728 |
Need char = 'd' |
Need char = 'd' |
| 1729 |
Study returned NULL |
Subject length lower bound = 4 |
| 1730 |
|
No set of starting bytes |
| 1731 |
|
|
| 1732 |
/\( # ( at start |
/\( # ( at start |
| 1733 |
(?: # Non-capturing bracket |
(?: # Non-capturing bracket |
| 1885 |
0: (abcd(xyz<p>qrs)123) |
0: (abcd(xyz<p>qrs)123) |
| 1886 |
1: abcd(xyz<p>qrs)123 |
1: abcd(xyz<p>qrs)123 |
| 1887 |
2: 123 |
2: 123 |
|
3: <unset> |
|
| 1888 |
|
|
| 1889 |
/\( ( ( (?>[^()]+) | ((?R)) )* ) \) /Ix |
/\( ( ( (?>[^()]+) | ((?R)) )* ) \) /Ix |
| 1890 |
Capturing subpattern count = 3 |
Capturing subpattern count = 3 |
| 1959 |
No options |
No options |
| 1960 |
No first char |
No first char |
| 1961 |
No need char |
No need char |
| 1962 |
|
Subject length lower bound = 1 |
| 1963 |
Starting byte set: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z |
Starting byte set: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z |
| 1964 |
_ a b c d e f g h i j k l m n o p q r s t u v w x y z |
_ a b c d e f g h i j k l m n o p q r s t u v w x y z |
| 1965 |
|
|
| 2021 |
No options |
No options |
| 2022 |
No first char |
No first char |
| 2023 |
No need char |
No need char |
| 2024 |
|
Subject length lower bound = 1 |
| 2025 |
Starting byte set: \x09 \x0a \x0b \x0c \x0d \x20 |
Starting byte set: \x09 \x0a \x0b \x0c \x0d \x20 |
| 2026 |
|
|
| 2027 |
/^[[:cntrl:]]/DZ |
/^[[:cntrl:]]/DZ |
| 3228 |
Failed: POSIX named classes are supported only within a class at offset 0 |
Failed: POSIX named classes are supported only within a class at offset 0 |
| 3229 |
|
|
| 3230 |
/\l/I |
/\l/I |
| 3231 |
Failed: PCRE does not support \L, \l, \N, \U, or \u at offset 1 |
Failed: PCRE does not support \L, \l, \N{name}, \U, or \u at offset 1 |
| 3232 |
|
|
| 3233 |
/\L/I |
/\L/I |
| 3234 |
Failed: PCRE does not support \L, \l, \N, \U, or \u at offset 1 |
Failed: PCRE does not support \L, \l, \N{name}, \U, or \u at offset 1 |
| 3235 |
|
|
| 3236 |
/\N{name}/I |
/\N{name}/I |
| 3237 |
Failed: PCRE does not support \L, \l, \N, \U, or \u at offset 1 |
Failed: PCRE does not support \L, \l, \N{name}, \U, or \u at offset 1 |
| 3238 |
|
|
| 3239 |
/\u/I |
/\u/I |
| 3240 |
Failed: PCRE does not support \L, \l, \N, \U, or \u at offset 1 |
Failed: PCRE does not support \L, \l, \N{name}, \U, or \u at offset 1 |
| 3241 |
|
|
| 3242 |
/\U/I |
/\U/I |
| 3243 |
Failed: PCRE does not support \L, \l, \N, \U, or \u at offset 1 |
Failed: PCRE does not support \L, \l, \N{name}, \U, or \u at offset 1 |
| 3244 |
|
|
| 3245 |
/[/I |
/[/I |
| 3246 |
Failed: missing terminating ] for character class at offset 1 |
Failed: missing terminating ] for character class at offset 1 |
| 3492 |
No options |
No options |
| 3493 |
No first char |
No first char |
| 3494 |
No need char |
No need char |
| 3495 |
|
Subject length lower bound = 1 |
| 3496 |
Starting byte set: a b |
Starting byte set: a b |
| 3497 |
|
|
| 3498 |
/[^a]/I |
/[^a]/I |
| 3512 |
No options |
No options |
| 3513 |
No first char |
No first char |
| 3514 |
Need char = '6' |
Need char = '6' |
| 3515 |
|
Subject length lower bound = 4 |
| 3516 |
Starting byte set: 0 1 2 3 4 5 6 7 8 9 |
Starting byte set: 0 1 2 3 4 5 6 7 8 9 |
| 3517 |
|
|
| 3518 |
/a^b/I |
/a^b/I |
| 3546 |
Options: caseless |
Options: caseless |
| 3547 |
No first char |
No first char |
| 3548 |
No need char |
No need char |
| 3549 |
|
Subject length lower bound = 1 |
| 3550 |
Starting byte set: A B a b |
Starting byte set: A B a b |
| 3551 |
|
|
| 3552 |
/[ab](?i)cd/IS |
/[ab](?i)cd/IS |
| 3554 |
No options |
No options |
| 3555 |
No first char |
No first char |
| 3556 |
Need char = 'd' (caseless) |
Need char = 'd' (caseless) |
| 3557 |
|
Subject length lower bound = 3 |
| 3558 |
Starting byte set: a b |
Starting byte set: a b |
| 3559 |
|
|
| 3560 |
/abc(?C)def/I |
/abc(?C)def/I |
| 3905 |
No options |
No options |
| 3906 |
No first char |
No first char |
| 3907 |
No need char |
No need char |
| 3908 |
|
Subject length lower bound = 1 |
| 3909 |
Starting byte set: a b |
Starting byte set: a b |
| 3910 |
|
|
| 3911 |
/(?R)/I |
/(?R)/I |
| 4025 |
First char = 'a' |
First char = 'a' |
| 4026 |
Need char = 'b' |
Need char = 'b' |
| 4027 |
|
|
|
/^\W*(?:((.)\W*(?1)\W*\2|)|((.)\W*(?3)\W*\4|\W*.\W*))\W*$/Ii |
|
|
Capturing subpattern count = 4 |
|
|
Max back reference = 4 |
|
|
Options: anchored caseless |
|
|
No first char |
|
|
No need char |
|
|
1221 |
|
|
0: 1221 |
|
|
1: 1221 |
|
|
2: 1 |
|
|
Satan, oscillate my metallic sonatas! |
|
|
0: Satan, oscillate my metallic sonatas! |
|
|
1: <unset> |
|
|
2: <unset> |
|
|
3: Satan, oscillate my metallic sonatas |
|
|
4: S |
|
|
A man, a plan, a canal: Panama! |
|
|
0: A man, a plan, a canal: Panama! |
|
|
1: <unset> |
|
|
2: <unset> |
|
|
3: A man, a plan, a canal: Panama |
|
|
4: A |
|
|
Able was I ere I saw Elba. |
|
|
0: Able was I ere I saw Elba. |
|
|
1: <unset> |
|
|
2: <unset> |
|
|
3: Able was I ere I saw Elba |
|
|
4: A |
|
|
*** Failers |
|
|
No match |
|
|
The quick brown fox |
|
|
No match |
|
|
|
|
| 4028 |
/^(\d+|\((?1)([+*-])(?1)\)|-(?1))$/I |
/^(\d+|\((?1)([+*-])(?1)\)|-(?1))$/I |
| 4029 |
Capturing subpattern count = 2 |
Capturing subpattern count = 2 |
| 4030 |
Options: anchored |
Options: anchored |
| 4690 |
Options: caseless |
Options: caseless |
| 4691 |
No first char |
No first char |
| 4692 |
Need char = 'g' (caseless) |
Need char = 'g' (caseless) |
| 4693 |
Study returned NULL |
Subject length lower bound = 8 |
| 4694 |
|
No set of starting bytes |
| 4695 |
Baby Bjorn Active Carrier - With free SHIPPING!! |
Baby Bjorn Active Carrier - With free SHIPPING!! |
| 4696 |
0: Baby Bjorn Active Carrier - With free SHIPPING!! |
0: Baby Bjorn Active Carrier - With free SHIPPING!! |
| 4697 |
1: Baby Bjorn Active Carrier - With free SHIPPING!! |
1: Baby Bjorn Active Carrier - With free SHIPPING!! |
| 4709 |
No options |
No options |
| 4710 |
No first char |
No first char |
| 4711 |
Need char = 'b' |
Need char = 'b' |
| 4712 |
Study returned NULL |
Subject length lower bound = 1 |
| 4713 |
|
No set of starting bytes |
| 4714 |
|
|
| 4715 |
/(a|b)*.?c/ISDZ |
/(a|b)*.?c/ISDZ |
| 4716 |
------------------------------------------------------------------ |
------------------------------------------------------------------ |
| 4730 |
No options |
No options |
| 4731 |
No first char |
No first char |
| 4732 |
Need char = 'c' |
Need char = 'c' |
| 4733 |
Study returned NULL |
Subject length lower bound = 1 |
| 4734 |
|
No set of starting bytes |
| 4735 |
|
|
| 4736 |
/abc(?C255)de(?C)f/DZ |
/abc(?C255)de(?C)f/DZ |
| 4737 |
------------------------------------------------------------------ |
------------------------------------------------------------------ |
| 5514 |
No options |
No options |
| 5515 |
No first char |
No first char |
| 5516 |
No need char |
No need char |
| 5517 |
|
Subject length lower bound = 1 |
| 5518 |
Starting byte set: a b |
Starting byte set: a b |
| 5519 |
Compiled regex written to testsavedregex |
Compiled regex written to testsavedregex |
| 5520 |
Study data written to testsavedregex |
Study data written to testsavedregex |
| 5535 |
No options |
No options |
| 5536 |
No first char |
No first char |
| 5537 |
No need char |
No need char |
| 5538 |
|
Subject length lower bound = 1 |
| 5539 |
Starting byte set: a b |
Starting byte set: a b |
| 5540 |
Compiled regex written to testsavedregex |
Compiled regex written to testsavedregex |
| 5541 |
Study data written to testsavedregex |
Study data written to testsavedregex |
| 6248 |
No options |
No options |
| 6249 |
No first char |
No first char |
| 6250 |
Need char = ',' |
Need char = ',' |
| 6251 |
|
Subject length lower bound = 1 |
| 6252 |
Starting byte set: \x09 \x0a \x0c \x0d \x20 , |
Starting byte set: \x09 \x0a \x0c \x0d \x20 , |
| 6253 |
\x0b,\x0b |
\x0b,\x0b |
| 6254 |
0: , |
0: , |
| 6553 |
No options |
No options |
| 6554 |
No first char |
No first char |
| 6555 |
No need char |
No need char |
| 6556 |
|
Subject length lower bound = 1 |
| 6557 |
Starting byte set: C a b c d |
Starting byte set: C a b c d |
| 6558 |
|
|
| 6559 |
/()[ab]xyz/IS |
/()[ab]xyz/IS |
| 6561 |
No options |
No options |
| 6562 |
No first char |
No first char |
| 6563 |
Need char = 'z' |
Need char = 'z' |
| 6564 |
|
Subject length lower bound = 4 |
| 6565 |
Starting byte set: a b |
Starting byte set: a b |
| 6566 |
|
|
| 6567 |
/(|)[ab]xyz/IS |
/(|)[ab]xyz/IS |
| 6569 |
No options |
No options |
| 6570 |
No first char |
No first char |
| 6571 |
Need char = 'z' |
Need char = 'z' |
| 6572 |
|
Subject length lower bound = 4 |
| 6573 |
Starting byte set: a b |
Starting byte set: a b |
| 6574 |
|
|
| 6575 |
/(|c)[ab]xyz/IS |
/(|c)[ab]xyz/IS |
| 6577 |
No options |
No options |
| 6578 |
No first char |
No first char |
| 6579 |
Need char = 'z' |
Need char = 'z' |
| 6580 |
|
Subject length lower bound = 4 |
| 6581 |
Starting byte set: a b c |
Starting byte set: a b c |
| 6582 |
|
|
| 6583 |
/(|c?)[ab]xyz/IS |
/(|c?)[ab]xyz/IS |
| 6585 |
No options |
No options |
| 6586 |
No first char |
No first char |
| 6587 |
Need char = 'z' |
Need char = 'z' |
| 6588 |
|
Subject length lower bound = 4 |
| 6589 |
Starting byte set: a b c |
Starting byte set: a b c |
| 6590 |
|
|
| 6591 |
/(d?|c?)[ab]xyz/IS |
/(d?|c?)[ab]xyz/IS |
| 6593 |
No options |
No options |
| 6594 |
No first char |
No first char |
| 6595 |
Need char = 'z' |
Need char = 'z' |
| 6596 |
|
Subject length lower bound = 4 |
| 6597 |
Starting byte set: a b c d |
Starting byte set: a b c d |
| 6598 |
|
|
| 6599 |
/(d?|c)[ab]xyz/IS |
/(d?|c)[ab]xyz/IS |
| 6601 |
No options |
No options |
| 6602 |
No first char |
No first char |
| 6603 |
Need char = 'z' |
Need char = 'z' |
| 6604 |
|
Subject length lower bound = 4 |
| 6605 |
Starting byte set: a b c d |
Starting byte set: a b c d |
| 6606 |
|
|
| 6607 |
/^a*b\d/DZ |
/^a*b\d/DZ |
| 6694 |
No options |
No options |
| 6695 |
No first char |
No first char |
| 6696 |
No need char |
No need char |
| 6697 |
|
Subject length lower bound = 1 |
| 6698 |
Starting byte set: a b c d |
Starting byte set: a b c d |
| 6699 |
|
|
| 6700 |
/(a+|b*)[cd]/IS |
/(a+|b*)[cd]/IS |
| 6702 |
No options |
No options |
| 6703 |
No first char |
No first char |
| 6704 |
No need char |
No need char |
| 6705 |
|
Subject length lower bound = 1 |
| 6706 |
Starting byte set: a b c d |
Starting byte set: a b c d |
| 6707 |
|
|
| 6708 |
/(a*|b+)[cd]/IS |
/(a*|b+)[cd]/IS |
| 6710 |
No options |
No options |
| 6711 |
No first char |
No first char |
| 6712 |
No need char |
No need char |
| 6713 |
|
Subject length lower bound = 1 |
| 6714 |
Starting byte set: a b c d |
Starting byte set: a b c d |
| 6715 |
|
|
| 6716 |
/(a+|b+)[cd]/IS |
/(a+|b+)[cd]/IS |
| 6718 |
No options |
No options |
| 6719 |
No first char |
No first char |
| 6720 |
No need char |
No need char |
| 6721 |
|
Subject length lower bound = 2 |
| 6722 |
Starting byte set: a b |
Starting byte set: a b |
| 6723 |
|
|
| 6724 |
/(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((( |
/(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((( |
| 7524 |
^ |
^ |
| 7525 |
CBra 1 |
CBra 1 |
| 7526 |
Cond |
Cond |
| 7527 |
2 Cond ref |
2 Cond nref |
| 7528 |
y |
y |
| 7529 |
Ket |
Ket |
| 7530 |
[()] |
[()] |
| 7642 |
0: abcd: |
0: abcd: |
| 7643 |
1: abcd |
1: abcd |
| 7644 |
|
|
|
/(?'abc'\w+):\k<abc>{2}/ |
|
|
a:aaxyz |
|
|
0: a:aa |
|
|
1: a |
|
|
ab:ababxyz |
|
|
0: ab:abab |
|
|
1: ab |
|
|
** Failers |
|
|
No match |
|
|
a:axyz |
|
|
No match |
|
|
ab:abxyz |
|
|
No match |
|
|
|
|
| 7645 |
/(?'abc'a|b)(?<abc>d|e)\k<abc>{2}/J |
/(?'abc'a|b)(?<abc>d|e)\k<abc>{2}/J |
| 7646 |
adaa |
adaa |
| 7647 |
0: adaa |
0: adaa |
| 7668 |
bddd |
bddd |
| 7669 |
No match |
No match |
| 7670 |
|
|
|
/^(?<ab>a)? (?(<ab>)b|c) (?('ab')d|e)/x |
|
|
abd |
|
|
0: abd |
|
|
1: a |
|
|
ce |
|
|
0: ce |
|
|
|
|
| 7671 |
/(?(<bc))/ |
/(?(<bc))/ |
| 7672 |
Failed: malformed number or name after (?( at offset 6 |
Failed: malformed number or name after (?( at offset 6 |
| 7673 |
|
|
| 7698 |
1: abcabc1Xabc2XabcX |
1: abcabc1Xabc2XabcX |
| 7699 |
2: abcabc1Xabc2XabcX |
2: abcabc1Xabc2XabcX |
| 7700 |
|
|
|
/^(?(DEFINE) (?<A> a) (?<B> b) ) (?&A) (?&B) /x |
|
|
abcd |
|
|
0: ab |
|
|
1: <unset> |
|
|
2: <unset> |
|
|
|
|
|
/(?<NAME>(?&NAME_PAT))\s+(?<ADDR>(?&ADDRESS_PAT)) |
|
|
(?(DEFINE) |
|
|
(?<NAME_PAT>[a-z]+) |
|
|
(?<ADDRESS_PAT>\d+) |
|
|
)/x |
|
|
metcalfe 33 |
|
|
0: metcalfe 33 |
|
|
1: metcalfe |
|
|
2: 33 |
|
|
3: <unset> |
|
|
4: <unset> |
|
|
|
|
| 7701 |
/^(?(DEFINE) abc | xyz ) /x |
/^(?(DEFINE) abc | xyz ) /x |
| 7702 |
Failed: DEFINE group contains more than one branch at offset 22 |
Failed: DEFINE group contains more than one branch at offset 22 |
| 7703 |
|
|
| 7875 |
0: PXP |
0: PXP |
| 7876 |
1: P |
1: P |
| 7877 |
|
|
|
/(?(DEFINE)(?<byte>2[0-4]\d|25[0-5]|1\d\d|[1-9]?\d))\b(?&byte)(\.(?&byte)){3}/ |
|
|
1.2.3.4 |
|
|
0: 1.2.3.4 |
|
|
1: <unset> |
|
|
2: .4 |
|
|
131.111.10.206 |
|
|
0: 131.111.10.206 |
|
|
1: <unset> |
|
|
2: .206 |
|
|
10.0.0.0 |
|
|
0: 10.0.0.0 |
|
|
1: <unset> |
|
|
2: .0 |
|
|
** Failers |
|
|
No match |
|
|
10.6 |
|
|
No match |
|
|
455.3.4.5 |
|
|
No match |
|
|
|
|
|
/\b(?&byte)(\.(?&byte)){3}(?(DEFINE)(?<byte>2[0-4]\d|25[0-5]|1\d\d|[1-9]?\d))/ |
|
|
1.2.3.4 |
|
|
0: 1.2.3.4 |
|
|
1: .4 |
|
|
2: <unset> |
|
|
131.111.10.206 |
|
|
0: 131.111.10.206 |
|
|
1: .206 |
|
|
2: <unset> |
|
|
10.0.0.0 |
|
|
0: 10.0.0.0 |
|
|
1: .0 |
|
|
2: <unset> |
|
|
** Failers |
|
|
No match |
|
|
10.6 |
|
|
No match |
|
|
455.3.4.5 |
|
|
No match |
|
|
|
|
| 7878 |
/(?:a(?&abc)b)*(?<abc>x)/ |
/(?:a(?&abc)b)*(?<abc>x)/ |
| 7879 |
123axbaxbaxbx456 |
123axbaxbaxbx456 |
| 7880 |
0: axbaxbaxbx |
0: axbaxbaxbx |
| 7912 |
DEFabcABCXYZ |
DEFabcABCXYZ |
| 7913 |
No match |
No match |
| 7914 |
|
|
|
/^(a(b))\1\g1\g{1}\g-1\g{-1}\g{-02}Z/ |
|
|
ababababbbabZXXXX |
|
|
0: ababababbbabZ |
|
|
1: ab |
|
|
2: b |
|
|
|
|
| 7915 |
/^(a)\g-2/ |
/^(a)\g-2/ |
| 7916 |
Failed: reference to non-existent subpattern at offset 7 |
Failed: reference to non-existent subpattern at offset 7 |
| 7917 |
|
|
| 8167 |
0: Y! |
0: Y! |
| 8168 |
1: ! |
1: ! |
| 8169 |
|
|
|
/(foo)\Kbar/ |
|
|
foobar |
|
|
0: bar |
|
|
1: foo |
|
|
|
|
|
/(foo)(\Kbar|baz)/ |
|
|
foobar |
|
|
0: bar |
|
|
1: foo |
|
|
2: bar |
|
|
foobaz |
|
|
0: foobaz |
|
|
1: foo |
|
|
2: baz |
|
|
|
|
|
/(foo\Kbar)baz/ |
|
|
foobarbaz |
|
|
0: barbaz |
|
|
1: foobar |
|
|
|
|
| 8170 |
/(?<A>tom|bon)-\k{A}/ |
/(?<A>tom|bon)-\k{A}/ |
| 8171 |
tom-tom |
tom-tom |
| 8172 |
0: tom-tom |
0: tom-tom |
| 8179 |
tom-bon |
tom-bon |
| 8180 |
No match |
No match |
| 8181 |
|
|
|
/(?<A>tom|bon)-\g{A}/ |
|
|
tom-tom |
|
|
0: tom-tom |
|
|
1: tom |
|
|
bon-bon |
|
|
0: bon-bon |
|
|
1: bon |
|
|
|
|
| 8182 |
/\g{A/ |
/\g{A/ |
| 8183 |
Failed: syntax error in subpattern name (missing terminator) at offset 4 |
Failed: syntax error in subpattern name (missing terminator) at offset 4 |
| 8184 |
|
|
| 8273 |
3: <unset> |
3: <unset> |
| 8274 |
4: x |
4: x |
| 8275 |
|
|
|
/(?|(abc)|(xyz))\1/ |
|
|
abcabc |
|
|
0: abcabc |
|
|
1: abc |
|
|
xyzxyz |
|
|
0: xyzxyz |
|
|
1: xyz |
|
|
** Failers |
|
|
No match |
|
|
abcxyz |
|
|
No match |
|
|
xyzabc |
|
|
No match |
|
|
|
|
|
/(?|(abc)|(xyz))(?1)/ |
|
|
abcabc |
|
|
0: abcabc |
|
|
1: abc |
|
|
xyzabc |
|
|
0: xyzabc |
|
|
1: xyz |
|
|
** Failers |
|
|
No match |
|
|
xyzxyz |
|
|
No match |
|
|
|
|
|
/\H\h\V\v/ |
|
|
X X\x0a |
|
|
0: X X\x0a |
|
|
X\x09X\x0b |
|
|
0: X\x09X\x0b |
|
|
** Failers |
|
|
No match |
|
|
\xa0 X\x0a |
|
|
No match |
|
|
|
|
|
/\H*\h+\V?\v{3,4}/ |
|
|
\x09\x20\xa0X\x0a\x0b\x0c\x0d\x0a |
|
|
0: \x09 \xa0X\x0a\x0b\x0c\x0d |
|
|
\x09\x20\xa0\x0a\x0b\x0c\x0d\x0a |
|
|
0: \x09 \xa0\x0a\x0b\x0c\x0d |
|
|
\x09\x20\xa0\x0a\x0b\x0c |
|
|
0: \x09 \xa0\x0a\x0b\x0c |
|
|
** Failers |
|
|
No match |
|
|
\x09\x20\xa0\x0a\x0b |
|
|
No match |
|
|
|
|
|
/\H{3,4}/ |
|
|
XY ABCDE |
|
|
0: ABCD |
|
|
XY PQR ST |
|
|
0: PQR |
|
|
|
|
|
/.\h{3,4}./ |
|
|
XY AB PQRS |
|
|
0: B P |
|
|
|
|
|
/\h*X\h?\H+Y\H?Z/ |
|
|
>XNNNYZ |
|
|
0: XNNNYZ |
|
|
> X NYQZ |
|
|
0: X NYQZ |
|
|
** Failers |
|
|
No match |
|
|
>XYZ |
|
|
No match |
|
|
> X NY Z |
|
|
No match |
|
|
|
|
|
/\v*X\v?Y\v+Z\V*\x0a\V+\x0b\V{2,3}\x0c/ |
|
|
>XY\x0aZ\x0aA\x0bNN\x0c |
|
|
0: XY\x0aZ\x0aA\x0bNN\x0c |
|
|
>\x0a\x0dX\x0aY\x0a\x0bZZZ\x0aAAA\x0bNNN\x0c |
|
|
0: \x0a\x0dX\x0aY\x0a\x0bZZZ\x0aAAA\x0bNNN\x0c |
|
|
|
|
| 8276 |
/[\h]/BZ |
/[\h]/BZ |
| 8277 |
------------------------------------------------------------------ |
------------------------------------------------------------------ |
| 8278 |
Bra |
Bra |
| 8569 |
End |
End |
| 8570 |
------------------------------------------------------------------ |
------------------------------------------------------------------ |
| 8571 |
|
|
|
/^a+(*FAIL)/ |
|
|
aaaaaa |
|
|
No match |
|
|
|
|
|
/a+b?c+(*FAIL)/ |
|
|
aaabccc |
|
|
No match |
|
|
|
|
|
/a+b?(*PRUNE)c+(*FAIL)/ |
|
|
aaabccc |
|
|
No match |
|
|
|
|
|
/a+b?(*COMMIT)c+(*FAIL)/ |
|
|
aaabccc |
|
|
No match |
|
|
|
|
|
/a+b?(*SKIP)c+(*FAIL)/ |
|
|
aaabcccaaabccc |
|
|
No match |
|
|
|
|
|
/^(?:aaa(*THEN)\w{6}|bbb(*THEN)\w{5}|ccc(*THEN)\w{4}|\w{3})/ |
|
|
aaaxxxxxx |
|
|
0: aaaxxxxxx |
|
|
aaa++++++ |
|
|
0: aaa |
|
|
bbbxxxxx |
|
|
0: bbbxxxxx |
|
|
bbb+++++ |
|
|
0: bbb |
|
|
cccxxxx |
|
|
0: cccxxxx |
|
|
ccc++++ |
|
|
0: ccc |
|
|
dddddddd |
|
|
0: ddd |
|
|
|
|
|
/^(aaa(*THEN)\w{6}|bbb(*THEN)\w{5}|ccc(*THEN)\w{4}|\w{3})/ |
|
|
aaaxxxxxx |
|
|
0: aaaxxxxxx |
|
|
1: aaaxxxxxx |
|
|
aaa++++++ |
|
|
0: aaa |
|
|
1: aaa |
|
|
bbbxxxxx |
|
|
0: bbbxxxxx |
|
|
1: bbbxxxxx |
|
|
bbb+++++ |
|
|
0: bbb |
|
|
1: bbb |
|
|
cccxxxx |
|
|
0: cccxxxx |
|
|
1: cccxxxx |
|
|
ccc++++ |
|
|
0: ccc |
|
|
1: ccc |
|
|
dddddddd |
|
|
0: ddd |
|
|
1: ddd |
|
|
|
|
|
/a+b?(*THEN)c+(*FAIL)/ |
|
|
aaabccc |
|
|
No match |
|
|
|
|
|
/(A (A|B(*ACCEPT)|C) D)(E)/x |
|
|
ABX |
|
|
0: AB |
|
|
AADE |
|
|
0: AADE |
|
|
1: AAD |
|
|
2: A |
|
|
3: E |
|
|
ACDE |
|
|
0: ACDE |
|
|
1: ACD |
|
|
2: C |
|
|
3: E |
|
|
** Failers |
|
|
No match |
|
|
AD |
|
|
No match |
|
|
|
|
| 8572 |
/^a+(*FAIL)/C |
/^a+(*FAIL)/C |
| 8573 |
aaaaaa |
aaaaaa |
| 8574 |
--->aaaaaa |
--->aaaaaa |
| 8697 |
+13 ^ ^ (*FAIL) |
+13 ^ ^ (*FAIL) |
| 8698 |
No match |
No match |
| 8699 |
|
|
|
/a(*PRUNE:XXX)b/ |
|
|
Failed: (*VERB) with an argument is not supported at offset 8 |
|
|
|
|
| 8700 |
/a(*MARK)b/ |
/a(*MARK)b/ |
| 8701 |
Failed: (*VERB) not recognized at offset 7 |
Failed: (*MARK) must have an argument at offset 7 |
| 8702 |
|
|
| 8703 |
/(?i:A{1,}\6666666666)/ |
/(?i:A{1,}\6666666666)/ |
| 8704 |
Failed: number is too big at offset 19 |
Failed: number is too big at offset 19 |
| 9037 |
/[[:a\dz:]]/ |
/[[:a\dz:]]/ |
| 9038 |
Failed: unknown POSIX class name at offset 3 |
Failed: unknown POSIX class name at offset 3 |
| 9039 |
|
|
| 9040 |
/^(?<name>a|b\g<name>c)/ |
/(^(a|b\g<-1'c))/ |
| 9041 |
aaaa |
Failed: \g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number at offset 15 |
|
0: a |
|
|
1: a |
|
|
bacxxx |
|
|
0: bac |
|
|
1: bac |
|
|
bbaccxxx |
|
|
0: bbacc |
|
|
1: bbacc |
|
|
bbbacccxx |
|
|
0: bbbaccc |
|
|
1: bbbaccc |
|
| 9042 |
|
|
| 9043 |
/^(?<name>a|b\g'name'c)/ |
/^(?+1)(?<a>x|y){0}z/ |
| 9044 |
aaaa |
xzxx |
| 9045 |
0: a |
0: xz |
| 9046 |
1: a |
yzyy |
| 9047 |
bacxxx |
0: yz |
| 9048 |
0: bac |
** Failers |
| 9049 |
1: bac |
No match |
| 9050 |
bbaccxxx |
xxz |
| 9051 |
0: bbacc |
No match |
|
1: bbacc |
|
|
bbbacccxx |
|
|
0: bbbaccc |
|
|
1: bbbaccc |
|
| 9052 |
|
|
| 9053 |
/^(a|b\g<1>c)/ |
/(\3)(\1)(a)/ |
| 9054 |
aaaa |
cat |
| 9055 |
0: a |
No match |
|
1: a |
|
|
bacxxx |
|
|
0: bac |
|
|
1: bac |
|
|
bbaccxxx |
|
|
0: bbacc |
|
|
1: bbacc |
|
|
bbbacccxx |
|
|
0: bbbaccc |
|
|
1: bbbaccc |
|
| 9056 |
|
|
| 9057 |
/^(a|b\g'1'c)/ |
/(\3)(\1)(a)/<JS> |
| 9058 |
aaaa |
cat |
| 9059 |
0: a |
0: a |
| 9060 |
1: a |
1: |
| 9061 |
bacxxx |
2: |
| 9062 |
0: bac |
3: a |
| 9063 |
1: bac |
|
| 9064 |
bbaccxxx |
/TA]/ |
| 9065 |
0: bbacc |
The ACTA] comes |
| 9066 |
1: bbacc |
0: TA] |
|
bbbacccxx |
|
|
0: bbbaccc |
|
|
1: bbbaccc |
|
|
|
|
|
/^(a|b\g'-1'c)/ |
|
|
aaaa |
|
|
0: a |
|
|
1: a |
|
|
bacxxx |
|
|
0: bac |
|
|
1: bac |
|
|
bbaccxxx |
|
|
0: bbacc |
|
|
1: bbacc |
|
|
bbbacccxx |
|
|
0: bbbaccc |
|
|
1: bbbaccc |
|
|
|
|
|
/(^(a|b\g<-1>c))/ |
|
|
aaaa |
|
|
0: a |
|
|
1: a |
|
|
2: a |
|
|
bacxxx |
|
|
0: bac |
|
|
1: bac |
|
|
2: bac |
|
|
bbaccxxx |
|
|
0: bbacc |
|
|
1: bbacc |
|
|
2: bbacc |
|
|
bbbacccxx |
|
|
0: bbbaccc |
|
|
1: bbbaccc |
|
|
2: bbbaccc |
|
|
|
|
|
/(^(a|b\g<-1'c))/ |
|
|
Failed: \g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number at offset 15 |
|
|
|
|
|
/(^(a|b\g{-1}))/ |
|
|
bacxxx |
|
|
No match |
|
|
|
|
|
/(?-i:\g<name>)(?i:(?<name>a))/ |
|
|
XaaX |
|
|
0: aa |
|
|
1: a |
|
|
XAAX |
|
|
0: AA |
|
|
1: A |
|
|
|
|
|
/(?i:\g<name>)(?-i:(?<name>a))/ |
|
|
XaaX |
|
|
0: aa |
|
|
1: a |
|
|
** Failers |
|
|
No match |
|
|
XAAX |
|
|
No match |
|
|
|
|
|
/(?-i:\g<+1>)(?i:(a))/ |
|
|
XaaX |
|
|
0: aa |
|
|
1: a |
|
|
XAAX |
|
|
0: AA |
|
|
1: A |
|
|
|
|
|
/(?=(?<regex>(?#simplesyntax)\$(?<name>[a-zA-Z_\x{7f}-\x{ff}][a-zA-Z0-9_\x{7f}-\x{ff}]*)(?:\[(?<index>[a-zA-Z0-9_\x{7f}-\x{ff}]+|\$\g<name>)\]|->\g<name>(\(.*?\))?)?|(?#simple syntax withbraces)\$\{(?:\g<name>(?<indices>\[(?:\g<index>|'(?:\\.|[^'\\])*'|"(?:\g<regex>|\\.|[^"\\])*")\])?|\g<complex>|\$\{\g<complex>\})\}|(?#complexsyntax)\{(?<complex>\$(?<segment>\g<name>(\g<indices>*|\(.*?\))?)(?:->\g<segment>)*|\$\g<complex>|\$\{\g<complex>\})\}))\{/ |
|
|
|
|
|
/(?<n>a|b|c)\g<n>*/ |
|
|
abc |
|
|
0: abc |
|
|
1: a |
|
|
accccbbb |
|
|
0: accccbbb |
|
|
1: a |
|
|
|
|
|
/^(?+1)(?<a>x|y){0}z/ |
|
|
xzxx |
|
|
0: xz |
|
|
1: <unset> |
|
|
yzyy |
|
|
0: yz |
|
|
1: <unset> |
|
|
** Failers |
|
|
No match |
|
|
xxz |
|
|
No match |
|
|
|
|
|
/(\3)(\1)(a)/ |
|
|
cat |
|
|
No match |
|
|
|
|
|
/(\3)(\1)(a)/<JS> |
|
|
cat |
|
|
0: a |
|
|
1: |
|
|
2: |
|
|
3: a |
|
|
|
|
|
/TA]/ |
|
|
The ACTA] comes |
|
|
0: TA] |
|
| 9067 |
|
|
| 9068 |
/TA]/<JS> |
/TA]/<JS> |
| 9069 |
Failed: ] is an invalid data character in JavaScript compatibility mode at offset 2 |
Failed: ] is an invalid data character in JavaScript compatibility mode at offset 2 |
| 9159 |
No options |
No options |
| 9160 |
No first char |
No first char |
| 9161 |
No need char |
No need char |
| 9162 |
|
Subject length lower bound = 1 |
| 9163 |
Starting byte set: x y z |
Starting byte set: x y z |
| 9164 |
|
|
| 9165 |
/(?(?=.*b)b|^)/CI |
/(?(?=.*b)b|^)/CI |
| 9307 |
0: "ab" |
0: "ab" |
| 9308 |
1: |
1: |
| 9309 |
|
|
|
/^X(?5)(a)(?|(b)|(q))(c)(d)(Y)/ |
|
|
XYabcdY |
|
|
0: XYabcdY |
|
|
1: a |
|
|
2: b |
|
|
3: c |
|
|
4: d |
|
|
5: Y |
|
|
|
|
| 9310 |
/^X(?5)(a)(?|(b)|(q))(c)(d)Y/ |
/^X(?5)(a)(?|(b)|(q))(c)(d)Y/ |
| 9311 |
Failed: reference to non-existent subpattern at offset 5 |
Failed: reference to non-existent subpattern at offset 5 |
| 9312 |
|
|
| 9319 |
4: d |
4: d |
| 9320 |
5: Y |
5: Y |
| 9321 |
|
|
|
/^X(?7)(a)(?|(b)|(q)(r)(s))(c)(d)(Y)/ |
|
|
XYabcdY |
|
|
0: XYabcdY |
|
|
1: a |
|
|
2: b |
|
|
3: <unset> |
|
|
4: <unset> |
|
|
5: c |
|
|
6: d |
|
|
7: Y |
|
|
|
|
|
/^X(?7)(a)(?|(b|(r)(s))|(q))(c)(d)(Y)/ |
|
|
XYabcdY |
|
|
0: XYabcdY |
|
|
1: a |
|
|
2: b |
|
|
3: <unset> |
|
|
4: <unset> |
|
|
5: c |
|
|
6: d |
|
|
7: Y |
|
|
|
|
|
/^X(?7)(a)(?|(b|(?|(r)|(t))(s))|(q))(c)(d)(Y)/ |
|
|
XYabcdY |
|
|
0: XYabcdY |
|
|
1: a |
|
|
2: b |
|
|
3: <unset> |
|
|
4: <unset> |
|
|
5: c |
|
|
6: d |
|
|
7: Y |
|
|
|
|
| 9322 |
/Xa{2,4}b/ |
/Xa{2,4}b/ |
| 9323 |
X\P |
X\P |
| 9324 |
Partial match: X |
Partial match: X |
| 9675 |
End |
End |
| 9676 |
------------------------------------------------------------------ |
------------------------------------------------------------------ |
| 9677 |
|
|
| 9678 |
/abc\K|def\K/g+ |
/(ab)(x(y)z(cd(*ACCEPT)))pq/BZ |
| 9679 |
Xabcdefghi |
------------------------------------------------------------------ |
| 9680 |
0: |
Bra |
| 9681 |
0+ defghi |
CBra 1 |
| 9682 |
0: |
ab |
| 9683 |
0+ ghi |
Ket |
| 9684 |
|
CBra 2 |
| 9685 |
/ab\Kc|de\Kf/g+ |
x |
| 9686 |
Xabcdefghi |
CBra 3 |
| 9687 |
0: c |
y |
| 9688 |
0+ defghi |
Ket |
| 9689 |
0: f |
z |
| 9690 |
0+ ghi |
CBra 4 |
| 9691 |
|
cd |
| 9692 |
/(?=C)/g+ |
Close 4 |
| 9693 |
ABCDECBA |
Close 2 |
| 9694 |
0: |
*ACCEPT |
| 9695 |
0+ CDECBA |
Ket |
| 9696 |
0: |
Ket |
| 9697 |
0+ CBA |
pq |
| 9698 |
|
Ket |
| 9699 |
/^abc\K/+ |
End |
| 9700 |
abcdef |
------------------------------------------------------------------ |
|
0: |
|
|
0+ def |
|
|
** Failers |
|
|
No match |
|
|
defabcxyz |
|
|
No match |
|
| 9701 |
|
|
| 9702 |
/abc\K/+ |
/abc\K/+ |
| 9703 |
abcdef |
abcdef |
| 9769 |
xyz\N |
xyz\N |
| 9770 |
No match |
No match |
| 9771 |
|
|
| 9772 |
/ End of testinput2 / |
/^(?<name>a|b\g<name>c)/ |
| 9773 |
|
aaaa |
| 9774 |
|
0: a |
| 9775 |
|
1: a |
| 9776 |
|
bacxxx |
| 9777 |
|
0: bac |
| 9778 |
|
1: bac |
| 9779 |
|
bbaccxxx |
| 9780 |
|
0: bbacc |
| 9781 |
|
1: bbacc |
| 9782 |
|
bbbacccxx |
| 9783 |
|
0: bbbaccc |
| 9784 |
|
1: bbbaccc |
| 9785 |
|
|
| 9786 |
|
/^(?<name>a|b\g'name'c)/ |
| 9787 |
|
aaaa |
| 9788 |
|
0: a |
| 9789 |
|
1: a |
| 9790 |
|
bacxxx |
| 9791 |
|
0: bac |
| 9792 |
|
1: bac |
| 9793 |
|
bbaccxxx |
| 9794 |
|
0: bbacc |
| 9795 |
|
1: bbacc |
| 9796 |
|
bbbacccxx |
| 9797 |
|
0: bbbaccc |
| 9798 |
|
1: bbbaccc |
| 9799 |
|
|
| 9800 |
|
/^(a|b\g<1>c)/ |
| 9801 |
|
aaaa |
| 9802 |
|
0: a |
| 9803 |
|
1: a |
| 9804 |
|
bacxxx |
| 9805 |
|
0: bac |
| 9806 |
|
1: bac |
| 9807 |
|
bbaccxxx |
| 9808 |
|
0: bbacc |
| 9809 |
|
1: bbacc |
| 9810 |
|
bbbacccxx |
| 9811 |
|
0: bbbaccc |
| 9812 |
|
1: bbbaccc |
| 9813 |
|
|
| 9814 |
|
/^(a|b\g'1'c)/ |
| 9815 |
|
aaaa |
| 9816 |
|
0: a |
| 9817 |
|
1: a |
| 9818 |
|
bacxxx |
| 9819 |
|
0: bac |
| 9820 |
|
1: bac |
| 9821 |
|
bbaccxxx |
| 9822 |
|
0: bbacc |
| 9823 |
|
1: bbacc |
| 9824 |
|
bbbacccxx |
| 9825 |
|
0: bbbaccc |
| 9826 |
|
1: bbbaccc |
| 9827 |
|
|
| 9828 |
|
/^(a|b\g'-1'c)/ |
| 9829 |
|
aaaa |
| 9830 |
|
0: a |
| 9831 |
|
1: a |
| 9832 |
|
bacxxx |
| 9833 |
|
0: bac |
| 9834 |
|
1: bac |
| 9835 |
|
bbaccxxx |
| 9836 |
|
0: bbacc |
| 9837 |
|
1: bbacc |
| 9838 |
|
bbbacccxx |
| 9839 |
|
0: bbbaccc |
| 9840 |
|
1: bbbaccc |
| 9841 |
|
|
| 9842 |
|
/(^(a|b\g<-1>c))/ |
| 9843 |
|
aaaa |
| 9844 |
|
0: a |
| 9845 |
|
1: a |
| 9846 |
|
2: a |
| 9847 |
|
bacxxx |
| 9848 |
|
0: bac |
| 9849 |
|
1: bac |
| 9850 |
|
2: bac |
| 9851 |
|
bbaccxxx |
| 9852 |
|
0: bbacc |
| 9853 |
|
1: bbacc |
| 9854 |
|
2: bbacc |
| 9855 |
|
bbbacccxx |
| 9856 |
|
0: bbbaccc |
| 9857 |
|
1: bbbaccc |
| 9858 |
|
2: bbbaccc |
| 9859 |
|
|
| 9860 |
|
/(?-i:\g<name>)(?i:(?<name>a))/ |
| 9861 |
|
XaaX |
| 9862 |
|
0: aa |
| 9863 |
|
1: a |
| 9864 |
|
XAAX |
| 9865 |
|
0: AA |
| 9866 |
|
1: A |
| 9867 |
|
|
| 9868 |
|
/(?i:\g<name>)(?-i:(?<name>a))/ |
| 9869 |
|
XaaX |
| 9870 |
|
0: aa |
| 9871 |
|
1: a |
| 9872 |
|
** Failers |
| 9873 |
|
No match |
| 9874 |
|
XAAX |
| 9875 |
|
No match |
| 9876 |
|
|
| 9877 |
|
/(?-i:\g<+1>)(?i:(a))/ |
| 9878 |
|
XaaX |
| 9879 |
|
0: aa |
| 9880 |
|
1: a |
| 9881 |
|
XAAX |
| 9882 |
|
0: AA |
| 9883 |
|
1: A |
| 9884 |
|
|
| 9885 |
|
/(?=(?<regex>(?#simplesyntax)\$(?<name>[a-zA-Z_\x{7f}-\x{ff}][a-zA-Z0-9_\x{7f}-\x{ff}]*)(?:\[(?<index>[a-zA-Z0-9_\x{7f}-\x{ff}]+|\$\g<name>)\]|->\g<name>(\(.*?\))?)?|(?#simple syntax withbraces)\$\{(?:\g<name>(?<indices>\[(?:\g<index>|'(?:\\.|[^'\\])*'|"(?:\g<regex>|\\.|[^"\\])*")\])?|\g<complex>|\$\{\g<complex>\})\}|(?#complexsyntax)\{(?<complex>\$(?<segment>\g<name>(\g<indices>*|\(.*?\))?)(?:->\g<segment>)*|\$\g<complex>|\$\{\g<complex>\})\}))\{/ |
| 9886 |
|
|
| 9887 |
|
/(?<n>a|b|c)\g<n>*/ |
| 9888 |
|
abc |
| 9889 |
|
0: abc |
| 9890 |
|
1: a |
| 9891 |
|
accccbbb |
| 9892 |
|
0: accccbbb |
| 9893 |
|
1: a |
| 9894 |
|
|
| 9895 |
|
/^X(?7)(a)(?|(b)|(q)(r)(s))(c)(d)(Y)/ |
| 9896 |
|
XYabcdY |
| 9897 |
|
0: XYabcdY |
| 9898 |
|
1: a |
| 9899 |
|
2: b |
| 9900 |
|
3: <unset> |
| 9901 |
|
4: <unset> |
| 9902 |
|
5: c |
| 9903 |
|
6: d |
| 9904 |
|
7: Y |
| 9905 |
|
|
| 9906 |
|
/(?<=b(?1)|zzz)(a)/ |
| 9907 |
|
xbaax |
| 9908 |
|
0: a |
| 9909 |
|
1: a |
| 9910 |
|
xzzzax |
| 9911 |
|
0: a |
| 9912 |
|
1: a |
| 9913 |
|
|
| 9914 |
|
/(a)(?<=b\1)/ |
| 9915 |
|
Failed: lookbehind assertion is not fixed length at offset 10 |
| 9916 |
|
|
| 9917 |
|
/(a)(?<=b+(?1))/ |
| 9918 |
|
Failed: lookbehind assertion is not fixed length at offset 13 |
| 9919 |
|
|
| 9920 |
|
/(a+)(?<=b(?1))/ |
| 9921 |
|
Failed: lookbehind assertion is not fixed length at offset 14 |
| 9922 |
|
|
| 9923 |
|
/(a(?<=b(?1)))/ |
| 9924 |
|
Failed: lookbehind assertion is not fixed length at offset 13 |
| 9925 |
|
|
| 9926 |
|
/(?<=b(?1))xyz/ |
| 9927 |
|
Failed: reference to non-existent subpattern at offset 8 |
| 9928 |
|
|
| 9929 |
|
/(?<=b(?1))xyz(b+)pqrstuvew/ |
| 9930 |
|
Failed: lookbehind assertion is not fixed length at offset 26 |
| 9931 |
|
|
| 9932 |
|
/(a|bc)\1/SI |
| 9933 |
|
Capturing subpattern count = 1 |
| 9934 |
|
Max back reference = 1 |
| 9935 |
|
No options |
| 9936 |
|
No first char |
| 9937 |
|
No need char |
| 9938 |
|
Subject length lower bound = 2 |
| 9939 |
|
Starting byte set: a b |
| 9940 |
|
|
| 9941 |
|
/(a|bc)\1{2,3}/SI |
| 9942 |
|
Capturing subpattern count = 1 |
| 9943 |
|
Max back reference = 1 |
| 9944 |
|
No options |
| 9945 |
|
No first char |
| 9946 |
|
No need char |
| 9947 |
|
Subject length lower bound = 3 |
| 9948 |
|
Starting byte set: a b |
| 9949 |
|
|
| 9950 |
|
/(a|bc)(?1)/SI |
| 9951 |
|
Capturing subpattern count = 1 |
| 9952 |
|
No options |
| 9953 |
|
No first char |
| 9954 |
|
No need char |
| 9955 |
|
Subject length lower bound = 2 |
| 9956 |
|
Starting byte set: a b |
| 9957 |
|
|
| 9958 |
|
/(a|b\1)(a|b\1)/SI |
| 9959 |
|
Capturing subpattern count = 2 |
| 9960 |
|
Max back reference = 1 |
| 9961 |
|
No options |
| 9962 |
|
No first char |
| 9963 |
|
No need char |
| 9964 |
|
Subject length lower bound = 2 |
| 9965 |
|
Starting byte set: a b |
| 9966 |
|
|
| 9967 |
|
/(a|b\1){2}/SI |
| 9968 |
|
Capturing subpattern count = 1 |
| 9969 |
|
Max back reference = 1 |
| 9970 |
|
No options |
| 9971 |
|
No first char |
| 9972 |
|
No need char |
| 9973 |
|
Subject length lower bound = 2 |
| 9974 |
|
Starting byte set: a b |
| 9975 |
|
|
| 9976 |
|
/(a|bbbb\1)(a|bbbb\1)/SI |
| 9977 |
|
Capturing subpattern count = 2 |
| 9978 |
|
Max back reference = 1 |
| 9979 |
|
No options |
| 9980 |
|
No first char |
| 9981 |
|
No need char |
| 9982 |
|
Subject length lower bound = 2 |
| 9983 |
|
Starting byte set: a b |
| 9984 |
|
|
| 9985 |
|
/(a|bbbb\1){2}/SI |
| 9986 |
|
Capturing subpattern count = 1 |
| 9987 |
|
Max back reference = 1 |
| 9988 |
|
No options |
| 9989 |
|
No first char |
| 9990 |
|
No need char |
| 9991 |
|
Subject length lower bound = 2 |
| 9992 |
|
Starting byte set: a b |
| 9993 |
|
|
| 9994 |
|
/^From +([^ ]+) +[a-zA-Z][a-zA-Z][a-zA-Z] +[a-zA-Z][a-zA-Z][a-zA-Z] +[0-9]?[0-9] +[0-9][0-9]:[0-9][0-9]/SI |
| 9995 |
|
Capturing subpattern count = 1 |
| 9996 |
|
Options: anchored |
| 9997 |
|
No first char |
| 9998 |
|
Need char = ':' |
| 9999 |
|
Subject length lower bound = 22 |
| 10000 |
|
No set of starting bytes |
| 10001 |
|
|
| 10002 |
|
/ (?: [\040\t] | \( |
| 10003 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10004 |
|
\) )* # optional leading comment |
| 10005 |
|
(?: (?: |
| 10006 |
|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters... |
| 10007 |
|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom |
| 10008 |
|
| |
| 10009 |
|
" (?: # opening quote... |
| 10010 |
|
[^\\\x80-\xff\n\015"] # Anything except backslash and quote |
| 10011 |
|
| # or |
| 10012 |
|
\\ [^\x80-\xff] # Escaped something (something != CR) |
| 10013 |
|
)* " # closing quote |
| 10014 |
|
) # initial word |
| 10015 |
|
(?: (?: [\040\t] | \( |
| 10016 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10017 |
|
\) )* \. (?: [\040\t] | \( |
| 10018 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10019 |
|
\) )* (?: |
| 10020 |
|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters... |
| 10021 |
|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom |
| 10022 |
|
| |
| 10023 |
|
" (?: # opening quote... |
| 10024 |
|
[^\\\x80-\xff\n\015"] # Anything except backslash and quote |
| 10025 |
|
| # or |
| 10026 |
|
\\ [^\x80-\xff] # Escaped something (something != CR) |
| 10027 |
|
)* " # closing quote |
| 10028 |
|
) )* # further okay, if led by a period |
| 10029 |
|
(?: [\040\t] | \( |
| 10030 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10031 |
|
\) )* @ (?: [\040\t] | \( |
| 10032 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10033 |
|
\) )* (?: |
| 10034 |
|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters... |
| 10035 |
|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom |
| 10036 |
|
| \[ # [ |
| 10037 |
|
(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff |
| 10038 |
|
\] # ] |
| 10039 |
|
) # initial subdomain |
| 10040 |
|
(?: # |
| 10041 |
|
(?: [\040\t] | \( |
| 10042 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10043 |
|
\) )* \. # if led by a period... |
| 10044 |
|
(?: [\040\t] | \( |
| 10045 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10046 |
|
\) )* (?: |
| 10047 |
|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters... |
| 10048 |
|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom |
| 10049 |
|
| \[ # [ |
| 10050 |
|
(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff |
| 10051 |
|
\] # ] |
| 10052 |
|
) # ...further okay |
| 10053 |
|
)* |
| 10054 |
|
# address |
| 10055 |
|
| # or |
| 10056 |
|
(?: |
| 10057 |
|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters... |
| 10058 |
|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom |
| 10059 |
|
| |
| 10060 |
|
" (?: # opening quote... |
| 10061 |
|
[^\\\x80-\xff\n\015"] # Anything except backslash and quote |
| 10062 |
|
| # or |
| 10063 |
|
\\ [^\x80-\xff] # Escaped something (something != CR) |
| 10064 |
|
)* " # closing quote |
| 10065 |
|
) # one word, optionally followed by.... |
| 10066 |
|
(?: |
| 10067 |
|
[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037] | # atom and space parts, or... |
| 10068 |
|
\( |
| 10069 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10070 |
|
\) | # comments, or... |
| 10071 |
|
|
| 10072 |
|
" (?: # opening quote... |
| 10073 |
|
[^\\\x80-\xff\n\015"] # Anything except backslash and quote |
| 10074 |
|
| # or |
| 10075 |
|
\\ [^\x80-\xff] # Escaped something (something != CR) |
| 10076 |
|
)* " # closing quote |
| 10077 |
|
# quoted strings |
| 10078 |
|
)* |
| 10079 |
|
< (?: [\040\t] | \( |
| 10080 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10081 |
|
\) )* # leading < |
| 10082 |
|
(?: @ (?: [\040\t] | \( |
| 10083 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10084 |
|
\) )* (?: |
| 10085 |
|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters... |
| 10086 |
|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom |
| 10087 |
|
| \[ # [ |
| 10088 |
|
(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff |
| 10089 |
|
\] # ] |
| 10090 |
|
) # initial subdomain |
| 10091 |
|
(?: # |
| 10092 |
|
(?: [\040\t] | \( |
| 10093 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10094 |
|
\) )* \. # if led by a period... |
| 10095 |
|
(?: [\040\t] | \( |
| 10096 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10097 |
|
\) )* (?: |
| 10098 |
|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters... |
| 10099 |
|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom |
| 10100 |
|
| \[ # [ |
| 10101 |
|
(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff |
| 10102 |
|
\] # ] |
| 10103 |
|
) # ...further okay |
| 10104 |
|
)* |
| 10105 |
|
|
| 10106 |
|
(?: (?: [\040\t] | \( |
| 10107 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10108 |
|
\) )* , (?: [\040\t] | \( |
| 10109 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10110 |
|
\) )* @ (?: [\040\t] | \( |
| 10111 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10112 |
|
\) )* (?: |
| 10113 |
|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters... |
| 10114 |
|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom |
| 10115 |
|
| \[ # [ |
| 10116 |
|
(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff |
| 10117 |
|
\] # ] |
| 10118 |
|
) # initial subdomain |
| 10119 |
|
(?: # |
| 10120 |
|
(?: [\040\t] | \( |
| 10121 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10122 |
|
\) )* \. # if led by a period... |
| 10123 |
|
(?: [\040\t] | \( |
| 10124 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10125 |
|
\) )* (?: |
| 10126 |
|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters... |
| 10127 |
|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom |
| 10128 |
|
| \[ # [ |
| 10129 |
|
(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff |
| 10130 |
|
\] # ] |
| 10131 |
|
) # ...further okay |
| 10132 |
|
)* |
| 10133 |
|
)* # further okay, if led by comma |
| 10134 |
|
: # closing colon |
| 10135 |
|
(?: [\040\t] | \( |
| 10136 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10137 |
|
\) )* )? # optional route |
| 10138 |
|
(?: |
| 10139 |
|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters... |
| 10140 |
|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom |
| 10141 |
|
| |
| 10142 |
|
" (?: # opening quote... |
| 10143 |
|
[^\\\x80-\xff\n\015"] # Anything except backslash and quote |
| 10144 |
|
| # or |
| 10145 |
|
\\ [^\x80-\xff] # Escaped something (something != CR) |
| 10146 |
|
)* " # closing quote |
| 10147 |
|
) # initial word |
| 10148 |
|
(?: (?: [\040\t] | \( |
| 10149 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10150 |
|
\) )* \. (?: [\040\t] | \( |
| 10151 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10152 |
|
\) )* (?: |
| 10153 |
|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters... |
| 10154 |
|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom |
| 10155 |
|
| |
| 10156 |
|
" (?: # opening quote... |
| 10157 |
|
[^\\\x80-\xff\n\015"] # Anything except backslash and quote |
| 10158 |
|
| # or |
| 10159 |
|
\\ [^\x80-\xff] # Escaped something (something != CR) |
| 10160 |
|
)* " # closing quote |
| 10161 |
|
) )* # further okay, if led by a period |
| 10162 |
|
(?: [\040\t] | \( |
| 10163 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10164 |
|
\) )* @ (?: [\040\t] | \( |
| 10165 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10166 |
|
\) )* (?: |
| 10167 |
|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters... |
| 10168 |
|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom |
| 10169 |
|
| \[ # [ |
| 10170 |
|
(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff |
| 10171 |
|
\] # ] |
| 10172 |
|
) # initial subdomain |
| 10173 |
|
(?: # |
| 10174 |
|
(?: [\040\t] | \( |
| 10175 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10176 |
|
\) )* \. # if led by a period... |
| 10177 |
|
(?: [\040\t] | \( |
| 10178 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10179 |
|
\) )* (?: |
| 10180 |
|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+ # some number of atom characters... |
| 10181 |
|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom |
| 10182 |
|
| \[ # [ |
| 10183 |
|
(?: [^\\\x80-\xff\n\015\[\]] | \\ [^\x80-\xff] )* # stuff |
| 10184 |
|
\] # ] |
| 10185 |
|
) # ...further okay |
| 10186 |
|
)* |
| 10187 |
|
# address spec |
| 10188 |
|
(?: [\040\t] | \( |
| 10189 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10190 |
|
\) )* > # trailing > |
| 10191 |
|
# name and address |
| 10192 |
|
) (?: [\040\t] | \( |
| 10193 |
|
(?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] | \( (?: [^\\\x80-\xff\n\015()] | \\ [^\x80-\xff] )* \) )* |
| 10194 |
|
\) )* # optional trailing comment |
| 10195 |
|
/xSI |
| 10196 |
|
Capturing subpattern count = 0 |
| 10197 |
|
Contains explicit CR or LF match |
| 10198 |
|
Options: extended |
| 10199 |
|
No first char |
| 10200 |
|
No need char |
| 10201 |
|
Subject length lower bound = 3 |
| 10202 |
|
Starting byte set: \x09 \x20 ! " # $ % & ' ( * + - / 0 1 2 3 4 5 6 7 8 |
| 10203 |
|
9 = ? A B C D E F G H I J K L M N O P Q R S T U V W X Y Z ^ _ ` a b c d e |
| 10204 |
|
f g h i j k l m n o p q r s t u v w x y z { | } ~ \x7f |
| 10205 |
|
|
| 10206 |
|
/<tr([\w\W\s\d][^<>]{0,})><TD([\w\W\s\d][^<>]{0,})>([\d]{0,}\.)(.*)((<BR>([\w\W\s\d][^<>]{0,})|[\s]{0,}))<\/a><\/TD><TD([\w\W\s\d][^<>]{0,})>([\w\W\s\d][^<>]{0,})<\/TD><TD([\w\W\s\d][^<>]{0,})>([\w\W\s\d][^<>]{0,})<\/TD><\/TR>/isIS |
| 10207 |
|
Capturing subpattern count = 11 |
| 10208 |
|
Options: caseless dotall |
| 10209 |
|
First char = '<' |
| 10210 |
|
Need char = '>' |
| 10211 |
|
Subject length lower bound = 47 |
| 10212 |
|
No set of starting bytes |
| 10213 |
|
|
| 10214 |
|
"(?>.*/)foo"SI |
| 10215 |
|
Capturing subpattern count = 0 |
| 10216 |
|
No options |
| 10217 |
|
First char at start or follows newline |
| 10218 |
|
Need char = 'o' |
| 10219 |
|
Subject length lower bound = 4 |
| 10220 |
|
No set of starting bytes |
| 10221 |
|
|
| 10222 |
|
/(?(?=[^a-z]+[a-z]) \d{2}-[a-z]{3}-\d{2} | \d{2}-\d{2}-\d{2} ) /xSI |
| 10223 |
|
Capturing subpattern count = 0 |
| 10224 |
|
Options: extended |
| 10225 |
|
No first char |
| 10226 |
|
Need char = '-' |
| 10227 |
|
Subject length lower bound = 8 |
| 10228 |
|
No set of starting bytes |
| 10229 |
|
|
| 10230 |
|
/(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))/iSI |
| 10231 |
|
Capturing subpattern count = 1 |
| 10232 |
|
Options: caseless |
| 10233 |
|
No first char |
| 10234 |
|
No need char |
| 10235 |
|
Subject length lower bound = 1 |
| 10236 |
|
Starting byte set: A B C a b c |
| 10237 |
|
|
| 10238 |
|
/(?:c|d)(?:)(?:aaaaaaaa(?:)(?:bbbbbbbb)(?:bbbbbbbb(?:))(?:bbbbbbbb(?:)(?:bbbbbbbb)))/SI |
| 10239 |
|
Capturing subpattern count = 0 |
| 10240 |
|
No options |
| 10241 |
|
No first char |
| 10242 |
|
Need char = 'b' |
| 10243 |
|
Subject length lower bound = 41 |
| 10244 |
|
Starting byte set: c d |
| 10245 |
|
|
| 10246 |
|
/<a[\s]+href[\s]*=[\s]* # find <a href= |
| 10247 |
|
([\"\'])? # find single or double quote |
| 10248 |
|
(?(1) (.*?)\1 | ([^\s]+)) # if quote found, match up to next matching |
| 10249 |
|
# quote, otherwise match up to next space |
| 10250 |
|
/isxSI |
| 10251 |
|
Capturing subpattern count = 3 |
| 10252 |
|
Max back reference = 1 |
| 10253 |
|
Options: caseless extended dotall |
| 10254 |
|
First char = '<' |
| 10255 |
|
Need char = '=' |
| 10256 |
|
Subject length lower bound = 9 |
| 10257 |
|
No set of starting bytes |
| 10258 |
|
|
| 10259 |
|
/^(?!:) # colon disallowed at start |
| 10260 |
|
(?: # start of item |
| 10261 |
|
(?: [0-9a-f]{1,4} | # 1-4 hex digits or |
| 10262 |
|
(?(1)0 | () ) ) # if null previously matched, fail; else null |
| 10263 |
|
: # followed by colon |
| 10264 |
|
){1,7} # end item; 1-7 of them required |
| 10265 |
|
[0-9a-f]{1,4} $ # final hex number at end of string |
| 10266 |
|
(?(1)|.) # check that there was an empty component |
| 10267 |
|
/xiIS |
| 10268 |
|
Capturing subpattern count = 1 |
| 10269 |
|
Options: anchored caseless extended |
| 10270 |
|
No first char |
| 10271 |
|
Need char = ':' |
| 10272 |
|
Subject length lower bound = 2 |
| 10273 |
|
No set of starting bytes |
| 10274 |
|
|
| 10275 |
|
/(?|(?<a>A)|(?<a>B))/I |
| 10276 |
|
Capturing subpattern count = 1 |
| 10277 |
|
Named capturing subpatterns: |
| 10278 |
|
a 1 |
| 10279 |
|
a 1 |
| 10280 |
|
No options |
| 10281 |
|
No first char |
| 10282 |
|
No need char |
| 10283 |
|
AB\Ca |
| 10284 |
|
0: A |
| 10285 |
|
1: A |
| 10286 |
|
C A (1) a |
| 10287 |
|
BA\Ca |
| 10288 |
|
0: B |
| 10289 |
|
1: B |
| 10290 |
|
C B (1) a |
| 10291 |
|
|
| 10292 |
|
/(?|(?<a>A)|(?<b>B))/ |
| 10293 |
|
Failed: different names for subpatterns of the same number are not allowed at offset 15 |
| 10294 |
|
|
| 10295 |
|
/(?:a(?<quote> (?<apostrophe>')|(?<realquote>")) | |
| 10296 |
|
b(?<quote> (?<apostrophe>')|(?<realquote>")) ) |
| 10297 |
|
(?('quote')[a-z]+|[0-9]+)/JIx |
| 10298 |
|
Capturing subpattern count = 6 |
| 10299 |
|
Named capturing subpatterns: |
| 10300 |
|
apostrophe 2 |
| 10301 |
|
apostrophe 5 |
| 10302 |
|
quote 1 |
| 10303 |
|
quote 4 |
| 10304 |
|
realquote 3 |
| 10305 |
|
realquote 6 |
| 10306 |
|
Options: extended dupnames |
| 10307 |
|
No first char |
| 10308 |
|
No need char |
| 10309 |
|
a"aaaaa |
| 10310 |
|
0: a"aaaaa |
| 10311 |
|
1: " |
| 10312 |
|
2: <unset> |
| 10313 |
|
3: " |
| 10314 |
|
b"aaaaa |
| 10315 |
|
0: b"aaaaa |
| 10316 |
|
1: <unset> |
| 10317 |
|
2: <unset> |
| 10318 |
|
3: <unset> |
| 10319 |
|
4: " |
| 10320 |
|
5: <unset> |
| 10321 |
|
6: " |
| 10322 |
|
** Failers |
| 10323 |
|
No match |
| 10324 |
|
b"11111 |
| 10325 |
|
No match |
| 10326 |
|
a"11111 |
| 10327 |
|
No match |
| 10328 |
|
|
| 10329 |
|
/^(?|(a)(b)(c)(?<D>d)|(?<D>e)) (?('D')X|Y)/JDZx |
| 10330 |
|
------------------------------------------------------------------ |
| 10331 |
|
Bra |
| 10332 |
|
^ |
| 10333 |
|
Bra |
| 10334 |
|
CBra 1 |
| 10335 |
|
a |
| 10336 |
|
Ket |
| 10337 |
|
CBra 2 |
| 10338 |
|
b |
| 10339 |
|
Ket |
| 10340 |
|
CBra 3 |
| 10341 |
|
c |
| 10342 |
|
Ket |
| 10343 |
|
CBra 4 |
| 10344 |
|
d |
| 10345 |
|
Ket |
| 10346 |
|
Alt |
| 10347 |
|
CBra 1 |
| 10348 |
|
e |
| 10349 |
|
Ket |
| 10350 |
|
Ket |
| 10351 |
|
Cond |
| 10352 |
|
4 Cond nref |
| 10353 |
|
X |
| 10354 |
|
Alt |
| 10355 |
|
Y |
| 10356 |
|
Ket |
| 10357 |
|
Ket |
| 10358 |
|
End |
| 10359 |
|
------------------------------------------------------------------ |
| 10360 |
|
Capturing subpattern count = 4 |
| 10361 |
|
Named capturing subpatterns: |
| 10362 |
|
D 4 |
| 10363 |
|
D 1 |
| 10364 |
|
Options: anchored extended dupnames |
| 10365 |
|
No first char |
| 10366 |
|
No need char |
| 10367 |
|
abcdX |
| 10368 |
|
0: abcdX |
| 10369 |
|
1: a |
| 10370 |
|
2: b |
| 10371 |
|
3: c |
| 10372 |
|
4: d |
| 10373 |
|
eX |
| 10374 |
|
0: eX |
| 10375 |
|
1: e |
| 10376 |
|
** Failers |
| 10377 |
|
No match |
| 10378 |
|
abcdY |
| 10379 |
|
No match |
| 10380 |
|
ey |
| 10381 |
|
No match |
| 10382 |
|
|
| 10383 |
|
/(?<A>a) (b)(c) (?<A>d (?(R&A)$ | (?4)) )/JDZx |
| 10384 |
|
------------------------------------------------------------------ |
| 10385 |
|
Bra |
| 10386 |
|
CBra 1 |
| 10387 |
|
a |
| 10388 |
|
Ket |
| 10389 |
|
CBra 2 |
| 10390 |
|
b |
| 10391 |
|
Ket |
| 10392 |
|
CBra 3 |
| 10393 |
|
c |
| 10394 |
|
Ket |
| 10395 |
|
CBra 4 |
| 10396 |
|
d |
| 10397 |
|
Cond |
| 10398 |
|
Cond nrecurse 1 |
| 10399 |
|
$ |
| 10400 |
|
Alt |
| 10401 |
|
Once |
| 10402 |
|
Recurse |
| 10403 |
|
Ket |
| 10404 |
|
Ket |
| 10405 |
|
Ket |
| 10406 |
|
Ket |
| 10407 |
|
End |
| 10408 |
|
------------------------------------------------------------------ |
| 10409 |
|
Capturing subpattern count = 4 |
| 10410 |
|
Named capturing subpatterns: |
| 10411 |
|
A 1 |
| 10412 |
|
A 4 |
| 10413 |
|
Options: extended dupnames |
| 10414 |
|
First char = 'a' |
| 10415 |
|
Need char = 'd' |
| 10416 |
|
abcdd |
| 10417 |
|
0: abcdd |
| 10418 |
|
1: a |
| 10419 |
|
2: b |
| 10420 |
|
3: c |
| 10421 |
|
4: dd |
| 10422 |
|
** Failers |
| 10423 |
|
No match |
| 10424 |
|
abcdde |
| 10425 |
|
No match |
| 10426 |
|
|
| 10427 |
|
/abcd*/ |
| 10428 |
|
xxxxabcd\P |
| 10429 |
|
0: abcd |
| 10430 |
|
xxxxabcd\P\P |
| 10431 |
|
Partial match: abcd |
| 10432 |
|
|
| 10433 |
|
/abcd*/i |
| 10434 |
|
xxxxabcd\P |
| 10435 |
|
0: abcd |
| 10436 |
|
xxxxabcd\P\P |
| 10437 |
|
Partial match: abcd |
| 10438 |
|
XXXXABCD\P |
| 10439 |
|
0: ABCD |
| 10440 |
|
XXXXABCD\P\P |
| 10441 |
|
Partial match: ABCD |
| 10442 |
|
|
| 10443 |
|
/abc\d*/ |
| 10444 |
|
xxxxabc1\P |
| 10445 |
|
0: abc1 |
| 10446 |
|
xxxxabc1\P\P |
| 10447 |
|
Partial match: abc1 |
| 10448 |
|
|
| 10449 |
|
/(a)bc\1*/ |
| 10450 |
|
xxxxabca\P |
| 10451 |
|
0: abca |
| 10452 |
|
1: a |
| 10453 |
|
xxxxabca\P\P |
| 10454 |
|
Partial match: abca |
| 10455 |
|
|
| 10456 |
|
/abc[de]*/ |
| 10457 |
|
xxxxabcde\P |
| 10458 |
|
0: abcde |
| 10459 |
|
xxxxabcde\P\P |
| 10460 |
|
Partial match: abcde |
| 10461 |
|
|
| 10462 |
|
/-- This is not in the Perl 5.10 test because Perl seems currently to be broken |
| 10463 |
|
and not behaving as specified in that it *does* bumpalong after hitting |
| 10464 |
|
(*COMMIT). --/ |
| 10465 |
|
|
| 10466 |
|
/(?1)(A(*COMMIT)|B)D/ |
| 10467 |
|
ABD |
| 10468 |
|
0: ABD |
| 10469 |
|
1: B |
| 10470 |
|
XABD |
| 10471 |
|
0: ABD |
| 10472 |
|
1: B |
| 10473 |
|
BAD |
| 10474 |
|
0: BAD |
| 10475 |
|
1: A |
| 10476 |
|
ABXABD |
| 10477 |
|
0: ABD |
| 10478 |
|
1: B |
| 10479 |
|
** Failers |
| 10480 |
|
No match |
| 10481 |
|
ABX |
| 10482 |
|
No match |
| 10483 |
|
BAXBAD |
| 10484 |
|
No match |
| 10485 |
|
|
| 10486 |
|
/(\3)(\1)(a)/<JS> |
| 10487 |
|
cat |
| 10488 |
|
0: a |
| 10489 |
|
1: |
| 10490 |
|
2: |
| 10491 |
|
3: a |
| 10492 |
|
|
| 10493 |
|
/(\3)(\1)(a)/SI<JS> |
| 10494 |
|
Capturing subpattern count = 3 |
| 10495 |
|
Max back reference = 3 |
| 10496 |
|
Options: |
| 10497 |
|
No first char |
| 10498 |
|
Need char = 'a' |
| 10499 |
|
Subject length lower bound = 1 |
| 10500 |
|
No set of starting bytes |
| 10501 |
|
cat |
| 10502 |
|
0: a |
| 10503 |
|
1: |
| 10504 |
|
2: |
| 10505 |
|
3: a |
| 10506 |
|
|
| 10507 |
|
/(\3)(\1)(a)/SI |
| 10508 |
|
Capturing subpattern count = 3 |
| 10509 |
|
Max back reference = 3 |
| 10510 |
|
No options |
| 10511 |
|
No first char |
| 10512 |
|
Need char = 'a' |
| 10513 |
|
Subject length lower bound = 3 |
| 10514 |
|
No set of starting bytes |
| 10515 |
|
cat |
| 10516 |
|
No match |
| 10517 |
|
|
| 10518 |
|
/i(?(DEFINE)(?<s>a))/SI |
| 10519 |
|
Capturing subpattern count = 1 |
| 10520 |
|
Named capturing subpatterns: |
| 10521 |
|
s 1 |
| 10522 |
|
No options |
| 10523 |
|
First char = 'i' |
| 10524 |
|
No need char |
| 10525 |
|
Subject length lower bound = 1 |
| 10526 |
|
No set of starting bytes |
| 10527 |
|
i |
| 10528 |
|
0: i |
| 10529 |
|
|
| 10530 |
|
/()i(?(1)a)/SI |
| 10531 |
|
Capturing subpattern count = 1 |
| 10532 |
|
No options |
| 10533 |
|
No first char |
| 10534 |
|
Need char = 'i' |
| 10535 |
|
Subject length lower bound = 1 |
| 10536 |
|
Starting byte set: i |
| 10537 |
|
ia |
| 10538 |
|
0: ia |
| 10539 |
|
1: |
| 10540 |
|
|
| 10541 |
|
/(?i)a(?-i)b|c/BZ |
| 10542 |
|
------------------------------------------------------------------ |
| 10543 |
|
Bra |
| 10544 |
|
NC a |
| 10545 |
|
00 Opt |
| 10546 |
|
b |
| 10547 |
|
Alt |
| 10548 |
|
00 Opt |
| 10549 |
|
c |
| 10550 |
|
Ket |
| 10551 |
|
End |
| 10552 |
|
------------------------------------------------------------------ |
| 10553 |
|
XabX |
| 10554 |
|
0: ab |
| 10555 |
|
XAbX |
| 10556 |
|
0: Ab |
| 10557 |
|
CcC |
| 10558 |
|
0: c |
| 10559 |
|
** Failers |
| 10560 |
|
No match |
| 10561 |
|
XABX |
| 10562 |
|
No match |
| 10563 |
|
|
| 10564 |
|
/(?i)a(?s)b|c/BZ |
| 10565 |
|
------------------------------------------------------------------ |
| 10566 |
|
Bra |
| 10567 |
|
NC a |
| 10568 |
|
05 Opt |
| 10569 |
|
NC b |
| 10570 |
|
Alt |
| 10571 |
|
05 Opt |
| 10572 |
|
NC c |
| 10573 |
|
Ket |
| 10574 |
|
End |
| 10575 |
|
------------------------------------------------------------------ |
| 10576 |
|
|
| 10577 |
|
/(?i)a(?s-i)b|c/BZ |
| 10578 |
|
------------------------------------------------------------------ |
| 10579 |
|
Bra |
| 10580 |
|
NC a |
| 10581 |
|
04 Opt |
| 10582 |
|
b |
| 10583 |
|
Alt |
| 10584 |
|
04 Opt |
| 10585 |
|
c |
| 10586 |
|
Ket |
| 10587 |
|
End |
| 10588 |
|
------------------------------------------------------------------ |
| 10589 |
|
|
| 10590 |
|
/^(ab(c\1)d|x){2}$/BZ |
| 10591 |
|
------------------------------------------------------------------ |
| 10592 |
|
Bra |
| 10593 |
|
^ |
| 10594 |
|
Once |
| 10595 |
|
CBra 1 |
| 10596 |
|
ab |
| 10597 |
|
CBra 2 |
| 10598 |
|
c |
| 10599 |
|
\1 |
| 10600 |
|
Ket |
| 10601 |
|
d |
| 10602 |
|
Alt |
| 10603 |
|
x |
| 10604 |
|
Ket |
| 10605 |
|
Ket |
| 10606 |
|
Once |
| 10607 |
|
CBra 1 |
| 10608 |
|
ab |
| 10609 |
|
CBra 2 |
| 10610 |
|
c |
| 10611 |
|
\1 |
| 10612 |
|
Ket |
| 10613 |
|
d |
| 10614 |
|
Alt |
| 10615 |
|
x |
| 10616 |
|
Ket |
| 10617 |
|
Ket |
| 10618 |
|
$ |
| 10619 |
|
Ket |
| 10620 |
|
End |
| 10621 |
|
------------------------------------------------------------------ |
| 10622 |
|
xabcxd |
| 10623 |
|
0: xabcxd |
| 10624 |
|
1: abcxd |
| 10625 |
|
2: cx |
| 10626 |
|
|
| 10627 |
|
/^(?&t)*+(?(DEFINE)(?<t>.))$/BZ |
| 10628 |
|
------------------------------------------------------------------ |
| 10629 |
|
Bra |
| 10630 |
|
^ |
| 10631 |
|
Once |
| 10632 |
|
Brazero |
| 10633 |
|
Once |
| 10634 |
|
Recurse |
| 10635 |
|
KetRmax |
| 10636 |
|
Ket |
| 10637 |
|
Cond |
| 10638 |
|
Cond def |
| 10639 |
|
CBra 1 |
| 10640 |
|
Any |
| 10641 |
|
Ket |
| 10642 |
|
Ket |
| 10643 |
|
$ |
| 10644 |
|
Ket |
| 10645 |
|
End |
| 10646 |
|
------------------------------------------------------------------ |
| 10647 |
|
|
| 10648 |
|
/^(?&t)*(?(DEFINE)(?<t>.))$/BZ |
| 10649 |
|
------------------------------------------------------------------ |
| 10650 |
|
Bra |
| 10651 |
|
^ |
| 10652 |
|
Brazero |
| 10653 |
|
Once |
| 10654 |
|
Recurse |
| 10655 |
|
KetRmax |
| 10656 |
|
Cond |
| 10657 |
|
Cond def |
| 10658 |
|
CBra 1 |
| 10659 |
|
Any |
| 10660 |
|
Ket |
| 10661 |
|
Ket |
| 10662 |
|
$ |
| 10663 |
|
Ket |
| 10664 |
|
End |
| 10665 |
|
------------------------------------------------------------------ |
| 10666 |
|
|
| 10667 |
|
/ -- The first four of these are not in the Perl 5.10 test because Perl |
| 10668 |
|
documents that the use of \K in assertions is "not well defined". The |
| 10669 |
|
last is here because Perl gives the match as "b" rather than "ab". I |
| 10670 |
|
believe this to be a Perl bug. --/ |
| 10671 |
|
|
| 10672 |
|
/(?=a\Kb)ab/ |
| 10673 |
|
ab |
| 10674 |
|
0: b |
| 10675 |
|
|
| 10676 |
|
/(?!a\Kb)ac/ |
| 10677 |
|
ac |
| 10678 |
|
0: ac |
| 10679 |
|
|
| 10680 |
|
/^abc(?<=b\Kc)d/ |
| 10681 |
|
abcd |
| 10682 |
|
0: cd |
| 10683 |
|
|
| 10684 |
|
/^abc(?<!b\Kq)d/ |
| 10685 |
|
abcd |
| 10686 |
|
0: abcd |
| 10687 |
|
|
| 10688 |
|
/(?>a\Kb)z|(ab)/ |
| 10689 |
|
ab |
| 10690 |
|
0: ab |
| 10691 |
|
1: ab |
| 10692 |
|
|
| 10693 |
|
/----------------------/ |
| 10694 |
|
|
| 10695 |
|
/(?P<L1>(?P<L2>0|)|(?P>L2)(?P>L1))/ |
| 10696 |
|
Failed: recursive call could loop indefinitely at offset 31 |
| 10697 |
|
|
| 10698 |
|
/abc(*MARK:)pqr/ |
| 10699 |
|
Failed: (*MARK) must have an argument at offset 10 |
| 10700 |
|
|
| 10701 |
|
/abc(*:)pqr/ |
| 10702 |
|
Failed: (*MARK) must have an argument at offset 6 |
| 10703 |
|
|
| 10704 |
|
/abc(*FAIL:123)xyz/ |
| 10705 |
|
Failed: an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT) at offset 13 |
| 10706 |
|
|
| 10707 |
|
/--- This should, and does, fail. In Perl, it does not, which I think is a |
| 10708 |
|
bug because replacing the B in the pattern by (B|D) does make it fail. ---/ |
| 10709 |
|
|
| 10710 |
|
/A(*COMMIT)B/+K |
| 10711 |
|
ACABX |
| 10712 |
|
No match |
| 10713 |
|
|
| 10714 |
|
/--- These should be different, but in Perl 5.11 are not, which I think |
| 10715 |
|
is a bug in Perl. ---/ |
| 10716 |
|
|
| 10717 |
|
/A(*THEN)B|A(*THEN)C/K |
| 10718 |
|
AC |
| 10719 |
|
0: AC |
| 10720 |
|
|
| 10721 |
|
/A(*PRUNE)B|A(*PRUNE)C/K |
| 10722 |
|
AC |
| 10723 |
|
No match |
| 10724 |
|
|
| 10725 |
|
/--- A whole lot of tests of verbs with arguments are here rather than in test |
| 10726 |
|
11 because Perl doesn't seem to follow its specification entirely |
| 10727 |
|
correctly. ---/ |
| 10728 |
|
|
| 10729 |
|
/--- Perl 5.11 sets $REGERROR on the AC failure case here; PCRE does not. It is |
| 10730 |
|
not clear how Perl defines "involved in the failure of the match". ---/ |
| 10731 |
|
|
| 10732 |
|
/^(A(*THEN:A)B|C(*THEN:B)D)/K |
| 10733 |
|
AB |
| 10734 |
|
0: AB |
| 10735 |
|
1: AB |
| 10736 |
|
CD |
| 10737 |
|
0: CD |
| 10738 |
|
1: CD |
| 10739 |
|
** Failers |
| 10740 |
|
No match |
| 10741 |
|
AC |
| 10742 |
|
No match |
| 10743 |
|
CB |
| 10744 |
|
No match, mark = B |
| 10745 |
|
|
| 10746 |
|
/--- Check the use of names for success and failure. PCRE doesn't show these |
| 10747 |
|
names for success, though Perl does, contrary to its spec. ---/ |
| 10748 |
|
|
| 10749 |
|
/^(A(*PRUNE:A)B|C(*PRUNE:B)D)/K |
| 10750 |
|
AB |
| 10751 |
|
0: AB |
| 10752 |
|
1: AB |
| 10753 |
|
CD |
| 10754 |
|
0: CD |
| 10755 |
|
1: CD |
| 10756 |
|
** Failers |
| 10757 |
|
No match |
| 10758 |
|
AC |
| 10759 |
|
No match, mark = A |
| 10760 |
|
CB |
| 10761 |
|
No match, mark = B |
| 10762 |
|
|
| 10763 |
|
/--- An empty name does not pass back an empty string. It is the same as if no |
| 10764 |
|
name were given. ---/ |
| 10765 |
|
|
| 10766 |
|
/^(A(*PRUNE:)B|C(*PRUNE:B)D)/K |
| 10767 |
|
AB |
| 10768 |
|
0: AB |
| 10769 |
|
1: AB |
| 10770 |
|
CD |
| 10771 |
|
0: CD |
| 10772 |
|
1: CD |
| 10773 |
|
|
| 10774 |
|
/--- PRUNE goes to next bumpalong; COMMIT does not. ---/ |
| 10775 |
|
|
| 10776 |
|
/A(*PRUNE:A)B/K |
| 10777 |
|
ACAB |
| 10778 |
|
0: AB |
| 10779 |
|
|
| 10780 |
|
/(*MARK:A)(*PRUNE:B)(C|X)/K |
| 10781 |
|
C |
| 10782 |
|
0: C |
| 10783 |
|
1: C |
| 10784 |
|
MK: A |
| 10785 |
|
D |
| 10786 |
|
No match, mark = B |
| 10787 |
|
|
| 10788 |
|
/(*MARK:A)(*THEN:B)(C|X)/K |
| 10789 |
|
C |
| 10790 |
|
0: C |
| 10791 |
|
1: C |
| 10792 |
|
MK: A |
| 10793 |
|
D |
| 10794 |
|
No match, mark = B |
| 10795 |
|
|
| 10796 |
|
/--- This should fail, as the skip causes a bump to offset 3 (the skip) ---/ |
| 10797 |
|
|
| 10798 |
|
/A(*MARK:A)A+(*SKIP)(B|Z) | AC/xK |
| 10799 |
|
AAAC |
| 10800 |
|
No match |
| 10801 |
|
|
| 10802 |
|
/--- Same --/ |
| 10803 |
|
|
| 10804 |
|
/A(*MARK:A)A+(*MARK:B)(*SKIP:B)(B|Z) | AC/xK |
| 10805 |
|
AAAC |
| 10806 |
|
No match |
| 10807 |
|
|
| 10808 |
|
/--- This should fail; the SKIP advances by one, but when we get to AC, the |
| 10809 |
|
PRUNE kills it. ---/ |
| 10810 |
|
|
| 10811 |
|
/A(*PRUNE:A)A+(*SKIP:A)(B|Z) | AC/xK |
| 10812 |
|
AAAC |
| 10813 |
|
No match |
| 10814 |
|
|
| 10815 |
|
/A(*:A)A+(*SKIP)(B|Z) | AC/xK |
| 10816 |
|
AAAC |
| 10817 |
|
No match |
| 10818 |
|
|
| 10819 |
|
/--- This should fail, as a null name is the same as no name ---/ |
| 10820 |
|
|
| 10821 |
|
/A(*MARK:A)A+(*SKIP:)(B|Z) | AC/xK |
| 10822 |
|
AAAC |
| 10823 |
|
No match |
| 10824 |
|
|
| 10825 |
|
/--- This fails in PCRE, and I think that is in accordance with Perl's |
| 10826 |
|
documentation, though in Perl it succeeds. ---/ |
| 10827 |
|
|
| 10828 |
|
/A(*MARK:A)A+(*SKIP:B)(B|Z) | AAC/xK |
| 10829 |
|
AAAC |
| 10830 |
|
No match |
| 10831 |
|
|
| 10832 |
|
/--- Mark names can be duplicated ---/ |
| 10833 |
|
|
| 10834 |
|
/A(*:A)B|X(*:A)Y/K |
| 10835 |
|
AABC |
| 10836 |
|
0: AB |
| 10837 |
|
MK: A |
| 10838 |
|
XXYZ |
| 10839 |
|
0: XY |
| 10840 |
|
MK: A |
| 10841 |
|
|
| 10842 |
|
/^A(*:A)B|^X(*:A)Y/K |
| 10843 |
|
** Failers |
| 10844 |
|
No match |
| 10845 |
|
XAQQ |
| 10846 |
|
No match, mark = A |
| 10847 |
|
|
| 10848 |
|
/--- A check on what happens after hitting a mark and them bumping along to |
| 10849 |
|
something that does not even start. Perl reports tags after the failures here, |
| 10850 |
|
though it does not when the individual letters are made into something |
| 10851 |
|
more complicated. ---/ |
| 10852 |
|
|
| 10853 |
|
/A(*:A)B|XX(*:B)Y/K |
| 10854 |
|
AABC |
| 10855 |
|
0: AB |
| 10856 |
|
MK: A |
| 10857 |
|
XXYZ |
| 10858 |
|
0: XXY |
| 10859 |
|
MK: B |
| 10860 |
|
** Failers |
| 10861 |
|
No match |
| 10862 |
|
XAQQ |
| 10863 |
|
No match |
| 10864 |
|
XAQQXZZ |
| 10865 |
|
No match |
| 10866 |
|
AXQQQ |
| 10867 |
|
No match |
| 10868 |
|
AXXQQQ |
| 10869 |
|
No match |
| 10870 |
|
|
| 10871 |
|
/--- COMMIT at the start of a pattern should be the same as an anchor. Perl |
| 10872 |
|
optimizations defeat this. So does the PCRE optimization unless we disable it |
| 10873 |
|
with \Y. ---/ |
| 10874 |
|
|
| 10875 |
|
/(*COMMIT)ABC/ |
| 10876 |
|
ABCDEFG |
| 10877 |
|
0: ABC |
| 10878 |
|
** Failers |
| 10879 |
|
No match |
| 10880 |
|
DEFGABC\Y |
| 10881 |
|
No match |
| 10882 |
|
|
| 10883 |
|
/--- Repeat some tests with added studying. ---/ |
| 10884 |
|
|
| 10885 |
|
/A(*COMMIT)B/+KS |
| 10886 |
|
ACABX |
| 10887 |
|
No match |
| 10888 |
|
|
| 10889 |
|
/A(*THEN)B|A(*THEN)C/KS |
| 10890 |
|
AC |
| 10891 |
|
0: AC |
| 10892 |
|
|
| 10893 |
|
/A(*PRUNE)B|A(*PRUNE)C/KS |
| 10894 |
|
AC |
| 10895 |
|
No match |
| 10896 |
|
|
| 10897 |
|
/^(A(*THEN:A)B|C(*THEN:B)D)/KS |
| 10898 |
|
AB |
| 10899 |
|
0: AB |
| 10900 |
|
1: AB |
| 10901 |
|
CD |
| 10902 |
|
0: CD |
| 10903 |
|
1: CD |
| 10904 |
|
** Failers |
| 10905 |
|
No match |
| 10906 |
|
AC |
| 10907 |
|
No match |
| 10908 |
|
CB |
| 10909 |
|
No match, mark = B |
| 10910 |
|
|
| 10911 |
|
/^(A(*PRUNE:A)B|C(*PRUNE:B)D)/KS |
| 10912 |
|
AB |
| 10913 |
|
0: AB |
| 10914 |
|
1: AB |
| 10915 |
|
CD |
| 10916 |
|
0: CD |
| 10917 |
|
1: CD |
| 10918 |
|
** Failers |
| 10919 |
|
No match |
| 10920 |
|
AC |
| 10921 |
|
No match, mark = A |
| 10922 |
|
CB |
| 10923 |
|
No match, mark = B |
| 10924 |
|
|
| 10925 |
|
/^(A(*PRUNE:)B|C(*PRUNE:B)D)/KS |
| 10926 |
|
AB |
| 10927 |
|
0: AB |
| 10928 |
|
1: AB |
| 10929 |
|
CD |
| 10930 |
|
0: CD |
| 10931 |
|
1: CD |
| 10932 |
|
|
| 10933 |
|
/A(*PRUNE:A)B/KS |
| 10934 |
|
ACAB |
| 10935 |
|
0: AB |
| 10936 |
|
|
| 10937 |
|
/(*MARK:A)(*PRUNE:B)(C|X)/KS |
| 10938 |
|
C |
| 10939 |
|
0: C |
| 10940 |
|
1: C |
| 10941 |
|
MK: A |
| 10942 |
|
D |
| 10943 |
|
No match |
| 10944 |
|
|
| 10945 |
|
/(*MARK:A)(*THEN:B)(C|X)/KS |
| 10946 |
|
C |
| 10947 |
|
0: C |
| 10948 |
|
1: C |
| 10949 |
|
MK: A |
| 10950 |
|
D |
| 10951 |
|
No match |
| 10952 |
|
|
| 10953 |
|
/A(*MARK:A)A+(*SKIP)(B|Z) | AC/xKS |
| 10954 |
|
AAAC |
| 10955 |
|
No match |
| 10956 |
|
|
| 10957 |
|
/A(*MARK:A)A+(*MARK:B)(*SKIP:B)(B|Z) | AC/xKS |
| 10958 |
|
AAAC |
| 10959 |
|
No match |
| 10960 |
|
|
| 10961 |
|
/A(*PRUNE:A)A+(*SKIP:A)(B|Z) | AC/xKS |
| 10962 |
|
AAAC |
| 10963 |
|
No match |
| 10964 |
|
|
| 10965 |
|
/A(*:A)A+(*SKIP)(B|Z) | AC/xKS |
| 10966 |
|
AAAC |
| 10967 |
|
No match |
| 10968 |
|
|
| 10969 |
|
/A(*MARK:A)A+(*SKIP:)(B|Z) | AC/xKS |
| 10970 |
|
AAAC |
| 10971 |
|
No match |
| 10972 |
|
|
| 10973 |
|
/A(*MARK:A)A+(*SKIP:B)(B|Z) | AAC/xKS |
| 10974 |
|
AAAC |
| 10975 |
|
No match |
| 10976 |
|
|
| 10977 |
|
/A(*:A)B|XX(*:B)Y/KS |
| 10978 |
|
AABC |
| 10979 |
|
0: AB |
| 10980 |
|
MK: A |
| 10981 |
|
XXYZ |
| 10982 |
|
0: XXY |
| 10983 |
|
MK: B |
| 10984 |
|
** Failers |
| 10985 |
|
No match |
| 10986 |
|
XAQQ |
| 10987 |
|
No match |
| 10988 |
|
XAQQXZZ |
| 10989 |
|
No match |
| 10990 |
|
AXQQQ |
| 10991 |
|
No match |
| 10992 |
|
AXXQQQ |
| 10993 |
|
No match |
| 10994 |
|
|
| 10995 |
|
/(*COMMIT)ABC/ |
| 10996 |
|
ABCDEFG |
| 10997 |
|
0: ABC |
| 10998 |
|
** Failers |
| 10999 |
|
No match |
| 11000 |
|
DEFGABC\Y |
| 11001 |
|
No match |
| 11002 |
|
|
| 11003 |
|
/^(ab (c+(*THEN)cd) | xyz)/x |
| 11004 |
|
abcccd |
| 11005 |
|
No match |
| 11006 |
|
|
| 11007 |
|
/^(ab (c+(*PRUNE)cd) | xyz)/x |
| 11008 |
|
abcccd |
| 11009 |
|
No match |
| 11010 |
|
|
| 11011 |
|
/^(ab (c+(*FAIL)cd) | xyz)/x |
| 11012 |
|
abcccd |
| 11013 |
|
No match |
| 11014 |
|
|
| 11015 |
|
/--- Perl 5.11 gets some of these wrong ---/ |
| 11016 |
|
|
| 11017 |
|
/(?>.(*ACCEPT))*?5/ |
| 11018 |
|
abcde |
| 11019 |
|
0: a |
| 11020 |
|
|
| 11021 |
|
/(.(*ACCEPT))*?5/ |
| 11022 |
|
abcde |
| 11023 |
|
0: a |
| 11024 |
|
1: a |
| 11025 |
|
|
| 11026 |
|
/(.(*ACCEPT))5/ |
| 11027 |
|
abcde |
| 11028 |
|
0: a |
| 11029 |
|
1: a |
| 11030 |
|
|
| 11031 |
|
/(.(*ACCEPT))*5/ |
| 11032 |
|
abcde |
| 11033 |
|
0: a |
| 11034 |
|
1: a |
| 11035 |
|
|
| 11036 |
|
/A\NB./BZ |
| 11037 |
|
------------------------------------------------------------------ |
| 11038 |
|
Bra |
| 11039 |
|
A |
| 11040 |
|
Any |
| 11041 |
|
B |
| 11042 |
|
Any |
| 11043 |
|
Ket |
| 11044 |
|
End |
| 11045 |
|
------------------------------------------------------------------ |
| 11046 |
|
ACBD |
| 11047 |
|
0: ACBD |
| 11048 |
|
** Failers |
| 11049 |
|
No match |
| 11050 |
|
A\nB |
| 11051 |
|
No match |
| 11052 |
|
ACB\n |
| 11053 |
|
No match |
| 11054 |
|
|
| 11055 |
|
/A\NB./sBZ |
| 11056 |
|
------------------------------------------------------------------ |
| 11057 |
|
Bra |
| 11058 |
|
A |
| 11059 |
|
Any |
| 11060 |
|
B |
| 11061 |
|
AllAny |
| 11062 |
|
Ket |
| 11063 |
|
End |
| 11064 |
|
------------------------------------------------------------------ |
| 11065 |
|
ACBD |
| 11066 |
|
0: ACBD |
| 11067 |
|
ACB\n |
| 11068 |
|
0: ACB\x0a |
| 11069 |
|
** Failers |
| 11070 |
|
No match |
| 11071 |
|
A\nB |
| 11072 |
|
No match |
| 11073 |
|
|
| 11074 |
|
/A\NB/<crlf> |
| 11075 |
|
A\nB |
| 11076 |
|
0: A\x0aB |
| 11077 |
|
A\rB |
| 11078 |
|
0: A\x0dB |
| 11079 |
|
** Failers |
| 11080 |
|
No match |
| 11081 |
|
A\r\nB |
| 11082 |
|
No match |
| 11083 |
|
|
| 11084 |
|
/-- End of testinput2 --/ |
Parent Directory
| 
Revision Log
| 
Patch