Some manual changes done to the library were lost with this update. They will be added in the next commit.
		
			
				
	
	
		
			7691 lines
		
	
	
		
			122 KiB
		
	
	
	
		
			Plaintext
		
	
	
	
	
	
			
		
		
	
	
			7691 lines
		
	
	
		
			122 KiB
		
	
	
	
		
			Plaintext
		
	
	
	
	
	
# This set of tests check the DFA matching functionality of pcre2_dfa_match(),
 | 
						|
# excluding UTF and Unicode property support. All matches are done using DFA,
 | 
						|
# forced by setting a default subject modifier at the start.
 | 
						|
    
 | 
						|
#forbid_utf
 | 
						|
#subject dfa
 | 
						|
#newline_default lf anycrlf any
 | 
						|
     
 | 
						|
/abc/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    
 | 
						|
/ab*c/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    abbbbc
 | 
						|
 0: abbbbc
 | 
						|
    ac
 | 
						|
 0: ac
 | 
						|
    
 | 
						|
/ab+c/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    abbbbbbc
 | 
						|
 0: abbbbbbc
 | 
						|
\= Expect no match 
 | 
						|
    ac
 | 
						|
No match
 | 
						|
    ab
 | 
						|
No match
 | 
						|
    
 | 
						|
/a*/no_auto_possess
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
 1: 
 | 
						|
    aaaaaaaaaaaaaaaaa
 | 
						|
Matched, but offsets vector is too small to show all matches
 | 
						|
 0: aaaaaaaaaaaaaaaaa
 | 
						|
 1: aaaaaaaaaaaaaaaa
 | 
						|
 2: aaaaaaaaaaaaaaa
 | 
						|
 3: aaaaaaaaaaaaaa
 | 
						|
 4: aaaaaaaaaaaaa
 | 
						|
 5: aaaaaaaaaaaa
 | 
						|
 6: aaaaaaaaaaa
 | 
						|
 7: aaaaaaaaaa
 | 
						|
 8: aaaaaaaaa
 | 
						|
 9: aaaaaaaa
 | 
						|
10: aaaaaaa
 | 
						|
11: aaaaaa
 | 
						|
12: aaaaa
 | 
						|
13: aaaa
 | 
						|
14: aaa
 | 
						|
    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\=ovector=10 
 | 
						|
Matched, but offsets vector is too small to show all matches
 | 
						|
 0: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 | 
						|
 1: aaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 | 
						|
 2: aaaaaaaaaaaaaaaaaaaaaaaaaaaa
 | 
						|
 3: aaaaaaaaaaaaaaaaaaaaaaaaaaa
 | 
						|
 4: aaaaaaaaaaaaaaaaaaaaaaaaaa
 | 
						|
 5: aaaaaaaaaaaaaaaaaaaaaaaaa
 | 
						|
 6: aaaaaaaaaaaaaaaaaaaaaaaa
 | 
						|
 7: aaaaaaaaaaaaaaaaaaaaaaa
 | 
						|
 8: aaaaaaaaaaaaaaaaaaaaaa
 | 
						|
 9: aaaaaaaaaaaaaaaaaaaaa
 | 
						|
    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\=dfa_shortest
 | 
						|
 0: 
 | 
						|
    
 | 
						|
/(a|abcd|african)/
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
    abcd
 | 
						|
 0: abcd
 | 
						|
 1: a
 | 
						|
    african
 | 
						|
 0: african
 | 
						|
 1: a
 | 
						|
    
 | 
						|
/^abc/
 | 
						|
    abcdef
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    xyzabc
 | 
						|
No match
 | 
						|
    xyz\nabc    
 | 
						|
No match
 | 
						|
    
 | 
						|
/^abc/m
 | 
						|
    abcdef
 | 
						|
 0: abc
 | 
						|
    xyz\nabc    
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    xyzabc
 | 
						|
No match
 | 
						|
    
 | 
						|
/\Aabc/
 | 
						|
    abcdef
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    xyzabc
 | 
						|
No match
 | 
						|
    xyz\nabc    
 | 
						|
No match
 | 
						|
    
 | 
						|
/\Aabc/m
 | 
						|
    abcdef
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    xyzabc
 | 
						|
No match
 | 
						|
    xyz\nabc    
 | 
						|
No match
 | 
						|
    
 | 
						|
/\Gabc/
 | 
						|
    abcdef
 | 
						|
 0: abc
 | 
						|
    xyzabc\=offset=3
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    xyzabc    
 | 
						|
No match
 | 
						|
    xyzabc\=offset=2
 | 
						|
No match
 | 
						|
    
 | 
						|
/x\dy\Dz/
 | 
						|
    x9yzz
 | 
						|
 0: x9yzz
 | 
						|
    x0y+z
 | 
						|
 0: x0y+z
 | 
						|
\= Expect no match
 | 
						|
    xyz
 | 
						|
No match
 | 
						|
    xxy0z     
 | 
						|
No match
 | 
						|
    
 | 
						|
/x\sy\Sz/
 | 
						|
    x yzz
 | 
						|
 0: x yzz
 | 
						|
    x y+z
 | 
						|
 0: x y+z
 | 
						|
\= Expect no match
 | 
						|
    xyz
 | 
						|
No match
 | 
						|
    xxyyz
 | 
						|
No match
 | 
						|
    
 | 
						|
/x\wy\Wz/
 | 
						|
    xxy+z
 | 
						|
 0: xxy+z
 | 
						|
\= Expect no match
 | 
						|
    xxy0z
 | 
						|
No match
 | 
						|
    x+y+z         
 | 
						|
No match
 | 
						|
    
 | 
						|
/x.y/
 | 
						|
    x+y
 | 
						|
 0: x+y
 | 
						|
    x-y
 | 
						|
 0: x-y
 | 
						|
\= Expect no match
 | 
						|
    x\ny
 | 
						|
No match
 | 
						|
    
 | 
						|
/x.y/s
 | 
						|
    x+y
 | 
						|
 0: x+y
 | 
						|
    x-y
 | 
						|
 0: x-y
 | 
						|
    x\ny
 | 
						|
 0: x\x0ay
 | 
						|
 | 
						|
/(a.b(?s)c.d|x.y)p.q/
 | 
						|
    a+bc+dp+q
 | 
						|
 0: a+bc+dp+q
 | 
						|
    a+bc\ndp+q
 | 
						|
 0: a+bc\x0adp+q
 | 
						|
    x\nyp+q 
 | 
						|
 0: x\x0ayp+q
 | 
						|
\= Expect no match 
 | 
						|
    a\nbc\ndp+q
 | 
						|
No match
 | 
						|
    a+bc\ndp\nq
 | 
						|
No match
 | 
						|
    x\nyp\nq 
 | 
						|
No match
 | 
						|
 | 
						|
/a\d\z/
 | 
						|
    ba0
 | 
						|
 0: a0
 | 
						|
\= Expect no match
 | 
						|
    ba0\n
 | 
						|
No match
 | 
						|
    ba0\ncd   
 | 
						|
No match
 | 
						|
 | 
						|
/a\d\z/m
 | 
						|
    ba0
 | 
						|
 0: a0
 | 
						|
\= Expect no match
 | 
						|
    ba0\n
 | 
						|
No match
 | 
						|
    ba0\ncd   
 | 
						|
No match
 | 
						|
 | 
						|
/a\d\Z/
 | 
						|
    ba0
 | 
						|
 0: a0
 | 
						|
    ba0\n
 | 
						|
 0: a0
 | 
						|
\= Expect no match
 | 
						|
    ba0\ncd   
 | 
						|
No match
 | 
						|
 | 
						|
/a\d\Z/m
 | 
						|
    ba0
 | 
						|
 0: a0
 | 
						|
    ba0\n
 | 
						|
 0: a0
 | 
						|
\= Expect no match
 | 
						|
    ba0\ncd   
 | 
						|
No match
 | 
						|
 | 
						|
/a\d$/
 | 
						|
    ba0
 | 
						|
 0: a0
 | 
						|
    ba0\n
 | 
						|
 0: a0
 | 
						|
\= Expect no match
 | 
						|
    ba0\ncd   
 | 
						|
No match
 | 
						|
 | 
						|
/a\d$/m
 | 
						|
    ba0
 | 
						|
 0: a0
 | 
						|
    ba0\n
 | 
						|
 0: a0
 | 
						|
    ba0\ncd   
 | 
						|
 0: a0
 | 
						|
 | 
						|
/abc/i
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    aBc
 | 
						|
 0: aBc
 | 
						|
    ABC
 | 
						|
 0: ABC
 | 
						|
    
 | 
						|
/[^a]/
 | 
						|
    abcd
 | 
						|
 0: b
 | 
						|
    
 | 
						|
/ab?\w/
 | 
						|
    abz
 | 
						|
 0: abz
 | 
						|
 1: ab
 | 
						|
    abbz
 | 
						|
 0: abb
 | 
						|
 1: ab
 | 
						|
    azz  
 | 
						|
 0: az
 | 
						|
 | 
						|
/x{0,3}yz/
 | 
						|
    ayzq
 | 
						|
 0: yz
 | 
						|
    axyzq
 | 
						|
 0: xyz
 | 
						|
    axxyz
 | 
						|
 0: xxyz
 | 
						|
    axxxyzq
 | 
						|
 0: xxxyz
 | 
						|
    axxxxyzq
 | 
						|
 0: xxxyz
 | 
						|
\= Expect no match
 | 
						|
    ax
 | 
						|
No match
 | 
						|
    axx     
 | 
						|
No match
 | 
						|
      
 | 
						|
/x{3}yz/
 | 
						|
    axxxyzq
 | 
						|
 0: xxxyz
 | 
						|
    axxxxyzq
 | 
						|
 0: xxxyz
 | 
						|
\= Expect no match
 | 
						|
    ax
 | 
						|
No match
 | 
						|
    axx     
 | 
						|
No match
 | 
						|
    ayzq
 | 
						|
No match
 | 
						|
    axyzq
 | 
						|
No match
 | 
						|
    axxyz
 | 
						|
No match
 | 
						|
      
 | 
						|
/x{2,3}yz/
 | 
						|
    axxyz
 | 
						|
 0: xxyz
 | 
						|
    axxxyzq
 | 
						|
 0: xxxyz
 | 
						|
    axxxxyzq
 | 
						|
 0: xxxyz
 | 
						|
\= Expect no match
 | 
						|
    ax
 | 
						|
No match
 | 
						|
    axx     
 | 
						|
No match
 | 
						|
    ayzq
 | 
						|
No match
 | 
						|
    axyzq
 | 
						|
No match
 | 
						|
      
 | 
						|
/[^a]+/no_auto_possess
 | 
						|
    bac
 | 
						|
 0: b
 | 
						|
    bcdefax
 | 
						|
 0: bcdef
 | 
						|
 1: bcde
 | 
						|
 2: bcd
 | 
						|
 3: bc
 | 
						|
 4: b
 | 
						|
\= Expect no match
 | 
						|
    aaaaa   
 | 
						|
No match
 | 
						|
 | 
						|
/[^a]*/no_auto_possess
 | 
						|
    bac
 | 
						|
 0: b
 | 
						|
 1: 
 | 
						|
    bcdefax
 | 
						|
 0: bcdef
 | 
						|
 1: bcde
 | 
						|
 2: bcd
 | 
						|
 3: bc
 | 
						|
 4: b
 | 
						|
 5: 
 | 
						|
    aaaaa   
 | 
						|
 0: 
 | 
						|
    
 | 
						|
/[^a]{3,5}/no_auto_possess
 | 
						|
    xyz
 | 
						|
 0: xyz
 | 
						|
    awxyza
 | 
						|
 0: wxyz
 | 
						|
 1: wxy
 | 
						|
    abcdefa
 | 
						|
 0: bcdef
 | 
						|
 1: bcde
 | 
						|
 2: bcd
 | 
						|
    abcdefghijk
 | 
						|
 0: bcdef
 | 
						|
 1: bcde
 | 
						|
 2: bcd
 | 
						|
\= Expect no match
 | 
						|
    axya
 | 
						|
No match
 | 
						|
    axa
 | 
						|
No match
 | 
						|
    aaaaa         
 | 
						|
No match
 | 
						|
 | 
						|
/\d*/
 | 
						|
    1234b567
 | 
						|
 0: 1234
 | 
						|
    xyz
 | 
						|
 0: 
 | 
						|
    
 | 
						|
/\D*/
 | 
						|
    a1234b567
 | 
						|
 0: a
 | 
						|
    xyz
 | 
						|
 0: xyz
 | 
						|
     
 | 
						|
/\d+/
 | 
						|
    ab1234c56
 | 
						|
 0: 1234
 | 
						|
\= Expect no match
 | 
						|
    xyz
 | 
						|
No match
 | 
						|
    
 | 
						|
/\D+/
 | 
						|
    ab123c56
 | 
						|
 0: ab
 | 
						|
\= Expect no match
 | 
						|
    789
 | 
						|
No match
 | 
						|
    
 | 
						|
/\d?A/
 | 
						|
    045ABC
 | 
						|
 0: 5A
 | 
						|
    ABC
 | 
						|
 0: A
 | 
						|
\= Expect no match
 | 
						|
    XYZ
 | 
						|
No match
 | 
						|
    
 | 
						|
/\D?A/
 | 
						|
    ABC
 | 
						|
 0: A
 | 
						|
    BAC
 | 
						|
 0: BA
 | 
						|
    9ABC             
 | 
						|
 0: A
 | 
						|
 | 
						|
/a+/
 | 
						|
    aaaa
 | 
						|
 0: aaaa
 | 
						|
 | 
						|
/^.*xyz/
 | 
						|
    xyz
 | 
						|
 0: xyz
 | 
						|
    ggggggggxyz
 | 
						|
 0: ggggggggxyz
 | 
						|
    
 | 
						|
/^.+xyz/
 | 
						|
    abcdxyz
 | 
						|
 0: abcdxyz
 | 
						|
    axyz
 | 
						|
 0: axyz
 | 
						|
\= Expect no match
 | 
						|
    xyz
 | 
						|
No match
 | 
						|
    
 | 
						|
/^.?xyz/
 | 
						|
    xyz
 | 
						|
 0: xyz
 | 
						|
    cxyz       
 | 
						|
 0: cxyz
 | 
						|
 | 
						|
/^\d{2,3}X/
 | 
						|
    12X
 | 
						|
 0: 12X
 | 
						|
    123X
 | 
						|
 0: 123X
 | 
						|
\= Expect no match
 | 
						|
    X
 | 
						|
No match
 | 
						|
    1X
 | 
						|
No match
 | 
						|
    1234X     
 | 
						|
No match
 | 
						|
 | 
						|
/^[abcd]\d/
 | 
						|
    a45
 | 
						|
 0: a4
 | 
						|
    b93
 | 
						|
 0: b9
 | 
						|
    c99z
 | 
						|
 0: c9
 | 
						|
    d04
 | 
						|
 0: d0
 | 
						|
\= Expect no match
 | 
						|
    e45
 | 
						|
No match
 | 
						|
    abcd      
 | 
						|
No match
 | 
						|
    abcd1234
 | 
						|
No match
 | 
						|
    1234  
 | 
						|
No match
 | 
						|
 | 
						|
/^[abcd]*\d/
 | 
						|
    a45
 | 
						|
 0: a4
 | 
						|
    b93
 | 
						|
 0: b9
 | 
						|
    c99z
 | 
						|
 0: c9
 | 
						|
    d04
 | 
						|
 0: d0
 | 
						|
    abcd1234
 | 
						|
 0: abcd1
 | 
						|
    1234  
 | 
						|
 0: 1
 | 
						|
\= Expect no match
 | 
						|
    e45
 | 
						|
No match
 | 
						|
    abcd      
 | 
						|
No match
 | 
						|
 | 
						|
/^[abcd]+\d/
 | 
						|
    a45
 | 
						|
 0: a4
 | 
						|
    b93
 | 
						|
 0: b9
 | 
						|
    c99z
 | 
						|
 0: c9
 | 
						|
    d04
 | 
						|
 0: d0
 | 
						|
    abcd1234
 | 
						|
 0: abcd1
 | 
						|
\= Expect no match
 | 
						|
    1234  
 | 
						|
No match
 | 
						|
    e45
 | 
						|
No match
 | 
						|
    abcd      
 | 
						|
No match
 | 
						|
 | 
						|
/^a+X/
 | 
						|
    aX
 | 
						|
 0: aX
 | 
						|
    aaX 
 | 
						|
 0: aaX
 | 
						|
 | 
						|
/^[abcd]?\d/
 | 
						|
    a45
 | 
						|
 0: a4
 | 
						|
    b93
 | 
						|
 0: b9
 | 
						|
    c99z
 | 
						|
 0: c9
 | 
						|
    d04
 | 
						|
 0: d0
 | 
						|
    1234  
 | 
						|
 0: 1
 | 
						|
\= Expect no match
 | 
						|
    abcd1234
 | 
						|
No match
 | 
						|
    e45
 | 
						|
No match
 | 
						|
 | 
						|
/^[abcd]{2,3}\d/
 | 
						|
    ab45
 | 
						|
 0: ab4
 | 
						|
    bcd93
 | 
						|
 0: bcd9
 | 
						|
\= Expect no match
 | 
						|
    1234 
 | 
						|
No match
 | 
						|
    a36 
 | 
						|
No match
 | 
						|
    abcd1234
 | 
						|
No match
 | 
						|
    ee45
 | 
						|
No match
 | 
						|
 | 
						|
/^(abc)*\d/
 | 
						|
    abc45
 | 
						|
 0: abc4
 | 
						|
    abcabcabc45
 | 
						|
 0: abcabcabc4
 | 
						|
    42xyz 
 | 
						|
 0: 4
 | 
						|
 | 
						|
/^(abc)+\d/
 | 
						|
    abc45
 | 
						|
 0: abc4
 | 
						|
    abcabcabc45
 | 
						|
 0: abcabcabc4
 | 
						|
\= Expect no match
 | 
						|
    42xyz 
 | 
						|
No match
 | 
						|
 | 
						|
/^(abc)?\d/
 | 
						|
    abc45
 | 
						|
 0: abc4
 | 
						|
    42xyz 
 | 
						|
 0: 4
 | 
						|
\= Expect no match
 | 
						|
    abcabcabc45
 | 
						|
No match
 | 
						|
 | 
						|
/^(abc){2,3}\d/
 | 
						|
    abcabc45
 | 
						|
 0: abcabc4
 | 
						|
    abcabcabc45
 | 
						|
 0: abcabcabc4
 | 
						|
\= Expect no match
 | 
						|
    abcabcabcabc45
 | 
						|
No match
 | 
						|
    abc45
 | 
						|
No match
 | 
						|
    42xyz 
 | 
						|
No match
 | 
						|
 | 
						|
/1(abc|xyz)2(?1)3/
 | 
						|
    1abc2abc3456
 | 
						|
 0: 1abc2abc3
 | 
						|
    1abc2xyz3456 
 | 
						|
 0: 1abc2xyz3
 | 
						|
 | 
						|
/^(a*\w|ab)=(a*\w|ab)/
 | 
						|
    ab=ab
 | 
						|
 0: ab=ab
 | 
						|
 1: ab=a
 | 
						|
 | 
						|
/^(a*\w|ab)=(?1)/
 | 
						|
    ab=ab
 | 
						|
 0: ab=ab
 | 
						|
 1: ab=a
 | 
						|
 | 
						|
/^([^()]|\((?1)*\))*$/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    a(b)c
 | 
						|
 0: a(b)c
 | 
						|
    a(b(c))d  
 | 
						|
 0: a(b(c))d
 | 
						|
\= Expect no match)
 | 
						|
    a(b(c)d  
 | 
						|
No match
 | 
						|
 | 
						|
/^>abc>([^()]|\((?1)*\))*<xyz<$/
 | 
						|
    >abc>123<xyz<
 | 
						|
 0: >abc>123<xyz<
 | 
						|
    >abc>1(2)3<xyz<
 | 
						|
 0: >abc>1(2)3<xyz<
 | 
						|
    >abc>(1(2)3)<xyz<
 | 
						|
 0: >abc>(1(2)3)<xyz<
 | 
						|
 | 
						|
/^(?>a*)\d/
 | 
						|
    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa9876
 | 
						|
 0: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa9
 | 
						|
\= Expect no match 
 | 
						|
    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 | 
						|
No match
 | 
						|
 | 
						|
/< (?: (?(R) \d++  | [^<>]*+) | (?R)) * >/x
 | 
						|
    <>
 | 
						|
 0: <>
 | 
						|
    <abcd>
 | 
						|
 0: <abcd>
 | 
						|
    <abc <123> hij>
 | 
						|
 0: <abc <123> hij>
 | 
						|
    <abc <def> hij>
 | 
						|
 0: <def>
 | 
						|
    <abc<>def> 
 | 
						|
 0: <abc<>def>
 | 
						|
    <abc<>      
 | 
						|
 0: <>
 | 
						|
\= Expect no match
 | 
						|
    <abc
 | 
						|
No match
 | 
						|
 | 
						|
/^(?(?=abc)\w{3}:|\d\d)$/
 | 
						|
    abc:                          
 | 
						|
 0: abc:
 | 
						|
    12                             
 | 
						|
 0: 12
 | 
						|
\= Expect no match                     
 | 
						|
    123                       
 | 
						|
No match
 | 
						|
    xyz                        
 | 
						|
No match
 | 
						|
                                
 | 
						|
/^(?(?!abc)\d\d|\w{3}:)$/
 | 
						|
    abc:                        
 | 
						|
 0: abc:
 | 
						|
    12         
 | 
						|
 0: 12
 | 
						|
\= Expect no match
 | 
						|
    123
 | 
						|
No match
 | 
						|
    xyz    
 | 
						|
No match
 | 
						|
 | 
						|
/^(?=abc)\w{5}:$/
 | 
						|
    abcde:                          
 | 
						|
 0: abcde:
 | 
						|
\= Expect no match                     
 | 
						|
    abc.. 
 | 
						|
No match
 | 
						|
    123                       
 | 
						|
No match
 | 
						|
    vwxyz                        
 | 
						|
No match
 | 
						|
                                
 | 
						|
/^(?!abc)\d\d$/
 | 
						|
    12         
 | 
						|
 0: 12
 | 
						|
\= Expect no match
 | 
						|
    abcde:
 | 
						|
No match
 | 
						|
    abc..  
 | 
						|
No match
 | 
						|
    123
 | 
						|
No match
 | 
						|
    vwxyz    
 | 
						|
No match
 | 
						|
 | 
						|
/(?<=abc|xy)123/
 | 
						|
    abc12345
 | 
						|
 0: 123
 | 
						|
    wxy123z
 | 
						|
 0: 123
 | 
						|
\= Expect no match
 | 
						|
    123abc
 | 
						|
No match
 | 
						|
 | 
						|
/(?<!abc|xy)123/
 | 
						|
    123abc
 | 
						|
 0: 123
 | 
						|
    mno123456 
 | 
						|
 0: 123
 | 
						|
\= Expect no match
 | 
						|
    abc12345
 | 
						|
No match
 | 
						|
    wxy123z
 | 
						|
No match
 | 
						|
 | 
						|
/abc(?C1)xyz/
 | 
						|
    abcxyz
 | 
						|
--->abcxyz
 | 
						|
  1 ^  ^       x
 | 
						|
 0: abcxyz
 | 
						|
    123abcxyz999 
 | 
						|
--->123abcxyz999
 | 
						|
  1    ^  ^          x
 | 
						|
 0: abcxyz
 | 
						|
 | 
						|
/(ab|cd){3,4}/auto_callout
 | 
						|
  ababab
 | 
						|
--->ababab
 | 
						|
 +0 ^          (
 | 
						|
 +1 ^          a
 | 
						|
 +4 ^          c
 | 
						|
 +2 ^^         b
 | 
						|
 +3 ^ ^        |
 | 
						|
 +1 ^ ^        a
 | 
						|
 +4 ^ ^        c
 | 
						|
 +2 ^  ^       b
 | 
						|
 +3 ^   ^      |
 | 
						|
 +1 ^   ^      a
 | 
						|
 +4 ^   ^      c
 | 
						|
 +2 ^    ^     b
 | 
						|
 +3 ^     ^    |
 | 
						|
+12 ^     ^    
 | 
						|
 +1 ^     ^    a
 | 
						|
 +4 ^     ^    c
 | 
						|
 0: ababab
 | 
						|
  abcdabcd
 | 
						|
--->abcdabcd
 | 
						|
 +0 ^            (
 | 
						|
 +1 ^            a
 | 
						|
 +4 ^            c
 | 
						|
 +2 ^^           b
 | 
						|
 +3 ^ ^          |
 | 
						|
 +1 ^ ^          a
 | 
						|
 +4 ^ ^          c
 | 
						|
 +5 ^  ^         d
 | 
						|
 +6 ^   ^        ){3,4}
 | 
						|
 +1 ^   ^        a
 | 
						|
 +4 ^   ^        c
 | 
						|
 +2 ^    ^       b
 | 
						|
 +3 ^     ^      |
 | 
						|
+12 ^     ^      
 | 
						|
 +1 ^     ^      a
 | 
						|
 +4 ^     ^      c
 | 
						|
 +5 ^      ^     d
 | 
						|
 +6 ^       ^    ){3,4}
 | 
						|
+12 ^       ^    
 | 
						|
 0: abcdabcd
 | 
						|
 1: abcdab
 | 
						|
  abcdcdcdcdcd  
 | 
						|
--->abcdcdcdcdcd
 | 
						|
 +0 ^                (
 | 
						|
 +1 ^                a
 | 
						|
 +4 ^                c
 | 
						|
 +2 ^^               b
 | 
						|
 +3 ^ ^              |
 | 
						|
 +1 ^ ^              a
 | 
						|
 +4 ^ ^              c
 | 
						|
 +5 ^  ^             d
 | 
						|
 +6 ^   ^            ){3,4}
 | 
						|
 +1 ^   ^            a
 | 
						|
 +4 ^   ^            c
 | 
						|
 +5 ^    ^           d
 | 
						|
 +6 ^     ^          ){3,4}
 | 
						|
+12 ^     ^          
 | 
						|
 +1 ^     ^          a
 | 
						|
 +4 ^     ^          c
 | 
						|
 +5 ^      ^         d
 | 
						|
 +6 ^       ^        ){3,4}
 | 
						|
+12 ^       ^        
 | 
						|
 0: abcdcdcd
 | 
						|
 1: abcdcd
 | 
						|
 | 
						|
/^abc/
 | 
						|
    abcdef
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    abcdef\=notbol
 | 
						|
No match
 | 
						|
 | 
						|
/^(a*|xyz)/
 | 
						|
    bcd
 | 
						|
 0: 
 | 
						|
    aaabcd
 | 
						|
 0: aaa
 | 
						|
    xyz
 | 
						|
 0: xyz
 | 
						|
 1: 
 | 
						|
    xyz\=notempty
 | 
						|
 0: xyz
 | 
						|
\= Expect no match
 | 
						|
    bcd\=notempty
 | 
						|
No match
 | 
						|
    
 | 
						|
/xyz$/
 | 
						|
    xyz
 | 
						|
 0: xyz
 | 
						|
    xyz\n
 | 
						|
 0: xyz
 | 
						|
\= Expect no match
 | 
						|
    xyz\=noteol
 | 
						|
No match
 | 
						|
    xyz\n\=noteol
 | 
						|
No match
 | 
						|
    
 | 
						|
/xyz$/m
 | 
						|
    xyz
 | 
						|
 0: xyz
 | 
						|
    xyz\n 
 | 
						|
 0: xyz
 | 
						|
    abcxyz\npqr 
 | 
						|
 0: xyz
 | 
						|
    abcxyz\npqr\=noteol
 | 
						|
 0: xyz
 | 
						|
    xyz\n\=noteol
 | 
						|
 0: xyz
 | 
						|
\= Expect no match
 | 
						|
    xyz\=noteol
 | 
						|
No match
 | 
						|
 | 
						|
/\Gabc/
 | 
						|
    abcdef
 | 
						|
 0: abc
 | 
						|
    defabcxyz\=offset=3
 | 
						|
 0: abc
 | 
						|
\= Expect no match 
 | 
						|
    defabcxyz
 | 
						|
No match
 | 
						|
 | 
						|
/^abcdef/
 | 
						|
    ab\=ps
 | 
						|
Partial match: ab
 | 
						|
    abcde\=ps
 | 
						|
Partial match: abcde
 | 
						|
    abcdef\=ps
 | 
						|
 0: abcdef
 | 
						|
\= Expect no match
 | 
						|
    abx\=ps
 | 
						|
No match
 | 
						|
 | 
						|
/^a{2,4}\d+z/
 | 
						|
    a\=ps
 | 
						|
Partial match: a
 | 
						|
    aa\=ps
 | 
						|
Partial match: aa
 | 
						|
    aa2\=ps
 | 
						|
Partial match: aa2
 | 
						|
    aaa\=ps
 | 
						|
Partial match: aaa
 | 
						|
    aaa23\=ps
 | 
						|
Partial match: aaa23
 | 
						|
    aaaa12345\=ps
 | 
						|
Partial match: aaaa12345
 | 
						|
    aa0z\=ps
 | 
						|
 0: aa0z
 | 
						|
    aaaa4444444444444z\=ps
 | 
						|
 0: aaaa4444444444444z
 | 
						|
\= Expect no match
 | 
						|
    az\=ps
 | 
						|
No match
 | 
						|
    aaaaa\=ps
 | 
						|
No match
 | 
						|
    a56\=ps
 | 
						|
No match
 | 
						|
 | 
						|
/^abcdef/
 | 
						|
   abc\=ps
 | 
						|
Partial match: abc
 | 
						|
   def\=dfa_restart
 | 
						|
 0: def
 | 
						|
   
 | 
						|
/(?<=foo)bar/
 | 
						|
   foob\=ps,offset=2
 | 
						|
Partial match: foob
 | 
						|
               <<<
 | 
						|
   foobar...\=ps,dfa_restart,offset=4
 | 
						|
 0: ar
 | 
						|
   foobar\=offset=2
 | 
						|
 0: bar
 | 
						|
\= Expect no match
 | 
						|
   xyzfo\=ps
 | 
						|
No match
 | 
						|
   obar\=dfa_restart
 | 
						|
No match
 | 
						|
 | 
						|
/(ab*(cd|ef))+X/
 | 
						|
    lkjhlkjhlkjhlkjhabbbbbbcdaefabbbbbbbefa\=ps,notbol,noteol
 | 
						|
Partial match: abbbbbbcdaefabbbbbbbefa
 | 
						|
    cdabbbbbbbb\=ps,notbol,dfa_restart,noteol
 | 
						|
Partial match: cdabbbbbbbb
 | 
						|
    efabbbbbbbbbbbbbbbb\=ps,notbol,dfa_restart,noteol
 | 
						|
Partial match: efabbbbbbbbbbbbbbbb
 | 
						|
    bbbbbbbbbbbbcdXyasdfadf\=ps,notbol,dfa_restart,noteol
 | 
						|
 0: bbbbbbbbbbbbcdX
 | 
						|
\= Expect no match
 | 
						|
    adfadadaklhlkalkajhlkjahdfasdfasdfladsfjkj\=ps,noteol
 | 
						|
No match
 | 
						|
 | 
						|
/the quick brown fox/
 | 
						|
    the quick brown fox
 | 
						|
 0: the quick brown fox
 | 
						|
    What do you know about the quick brown fox?
 | 
						|
 0: the quick brown fox
 | 
						|
\= Expect no match
 | 
						|
    The quick brown FOX
 | 
						|
No match
 | 
						|
    What do you know about THE QUICK BROWN FOX?
 | 
						|
No match
 | 
						|
 | 
						|
/The quick brown fox/i
 | 
						|
    the quick brown fox
 | 
						|
 0: the quick brown fox
 | 
						|
    The quick brown FOX
 | 
						|
 0: The quick brown FOX
 | 
						|
    What do you know about the quick brown fox?
 | 
						|
 0: the quick brown fox
 | 
						|
    What do you know about THE QUICK BROWN FOX?
 | 
						|
 0: THE QUICK BROWN FOX
 | 
						|
 | 
						|
/abcd\t\n\r\f\a\e\071\x3b\$\\\?caxyz/
 | 
						|
    abcd\t\n\r\f\a\e9;\$\\?caxyz
 | 
						|
 0: abcd\x09\x0a\x0d\x0c\x07\x1b9;$\?caxyz
 | 
						|
 | 
						|
/a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/
 | 
						|
    abxyzpqrrrabbxyyyypqAzz
 | 
						|
 0: abxyzpqrrrabbxyyyypqAzz
 | 
						|
    abxyzpqrrrabbxyyyypqAzz
 | 
						|
 0: abxyzpqrrrabbxyyyypqAzz
 | 
						|
    aabxyzpqrrrabbxyyyypqAzz
 | 
						|
 0: aabxyzpqrrrabbxyyyypqAzz
 | 
						|
    aaabxyzpqrrrabbxyyyypqAzz
 | 
						|
 0: aaabxyzpqrrrabbxyyyypqAzz
 | 
						|
    aaaabxyzpqrrrabbxyyyypqAzz
 | 
						|
 0: aaaabxyzpqrrrabbxyyyypqAzz
 | 
						|
    abcxyzpqrrrabbxyyyypqAzz
 | 
						|
 0: abcxyzpqrrrabbxyyyypqAzz
 | 
						|
    aabcxyzpqrrrabbxyyyypqAzz
 | 
						|
 0: aabcxyzpqrrrabbxyyyypqAzz
 | 
						|
    aaabcxyzpqrrrabbxyyyypAzz
 | 
						|
 0: aaabcxyzpqrrrabbxyyyypAzz
 | 
						|
    aaabcxyzpqrrrabbxyyyypqAzz
 | 
						|
 0: aaabcxyzpqrrrabbxyyyypqAzz
 | 
						|
    aaabcxyzpqrrrabbxyyyypqqAzz
 | 
						|
 0: aaabcxyzpqrrrabbxyyyypqqAzz
 | 
						|
    aaabcxyzpqrrrabbxyyyypqqqAzz
 | 
						|
 0: aaabcxyzpqrrrabbxyyyypqqqAzz
 | 
						|
    aaabcxyzpqrrrabbxyyyypqqqqAzz
 | 
						|
 0: aaabcxyzpqrrrabbxyyyypqqqqAzz
 | 
						|
    aaabcxyzpqrrrabbxyyyypqqqqqAzz
 | 
						|
 0: aaabcxyzpqrrrabbxyyyypqqqqqAzz
 | 
						|
    aaabcxyzpqrrrabbxyyyypqqqqqqAzz
 | 
						|
 0: aaabcxyzpqrrrabbxyyyypqqqqqqAzz
 | 
						|
    aaaabcxyzpqrrrabbxyyyypqAzz
 | 
						|
 0: aaaabcxyzpqrrrabbxyyyypqAzz
 | 
						|
    abxyzzpqrrrabbxyyyypqAzz
 | 
						|
 0: abxyzzpqrrrabbxyyyypqAzz
 | 
						|
    aabxyzzzpqrrrabbxyyyypqAzz
 | 
						|
 0: aabxyzzzpqrrrabbxyyyypqAzz
 | 
						|
    aaabxyzzzzpqrrrabbxyyyypqAzz
 | 
						|
 0: aaabxyzzzzpqrrrabbxyyyypqAzz
 | 
						|
    aaaabxyzzzzpqrrrabbxyyyypqAzz
 | 
						|
 0: aaaabxyzzzzpqrrrabbxyyyypqAzz
 | 
						|
    abcxyzzpqrrrabbxyyyypqAzz
 | 
						|
 0: abcxyzzpqrrrabbxyyyypqAzz
 | 
						|
    aabcxyzzzpqrrrabbxyyyypqAzz
 | 
						|
 0: aabcxyzzzpqrrrabbxyyyypqAzz
 | 
						|
    aaabcxyzzzzpqrrrabbxyyyypqAzz
 | 
						|
 0: aaabcxyzzzzpqrrrabbxyyyypqAzz
 | 
						|
    aaaabcxyzzzzpqrrrabbxyyyypqAzz
 | 
						|
 0: aaaabcxyzzzzpqrrrabbxyyyypqAzz
 | 
						|
    aaaabcxyzzzzpqrrrabbbxyyyypqAzz
 | 
						|
 0: aaaabcxyzzzzpqrrrabbbxyyyypqAzz
 | 
						|
    aaaabcxyzzzzpqrrrabbbxyyyyypqAzz
 | 
						|
 0: aaaabcxyzzzzpqrrrabbbxyyyyypqAzz
 | 
						|
    aaabcxyzpqrrrabbxyyyypABzz
 | 
						|
 0: aaabcxyzpqrrrabbxyyyypABzz
 | 
						|
    aaabcxyzpqrrrabbxyyyypABBzz
 | 
						|
 0: aaabcxyzpqrrrabbxyyyypABBzz
 | 
						|
    >>>aaabxyzpqrrrabbxyyyypqAzz
 | 
						|
 0: aaabxyzpqrrrabbxyyyypqAzz
 | 
						|
    >aaaabxyzpqrrrabbxyyyypqAzz
 | 
						|
 0: aaaabxyzpqrrrabbxyyyypqAzz
 | 
						|
    >>>>abcxyzpqrrrabbxyyyypqAzz
 | 
						|
 0: abcxyzpqrrrabbxyyyypqAzz
 | 
						|
\= Expect no match
 | 
						|
    abxyzpqrrabbxyyyypqAzz
 | 
						|
No match
 | 
						|
    abxyzpqrrrrabbxyyyypqAzz
 | 
						|
No match
 | 
						|
    abxyzpqrrrabxyyyypqAzz
 | 
						|
No match
 | 
						|
    aaaabcxyzzzzpqrrrabbbxyyyyyypqAzz
 | 
						|
No match
 | 
						|
    aaaabcxyzzzzpqrrrabbbxyyypqAzz
 | 
						|
No match
 | 
						|
    aaabcxyzpqrrrabbxyyyypqqqqqqqAzz
 | 
						|
No match
 | 
						|
 | 
						|
/^(abc){1,2}zz/
 | 
						|
    abczz
 | 
						|
 0: abczz
 | 
						|
    abcabczz
 | 
						|
 0: abcabczz
 | 
						|
\= Expect no match
 | 
						|
    zz
 | 
						|
No match
 | 
						|
    abcabcabczz
 | 
						|
No match
 | 
						|
    >>abczz
 | 
						|
No match
 | 
						|
 | 
						|
/^(b+?|a){1,2}?c/
 | 
						|
    bc
 | 
						|
 0: bc
 | 
						|
    bbc
 | 
						|
 0: bbc
 | 
						|
    bbbc
 | 
						|
 0: bbbc
 | 
						|
    bac
 | 
						|
 0: bac
 | 
						|
    bbac
 | 
						|
 0: bbac
 | 
						|
    aac
 | 
						|
 0: aac
 | 
						|
    abbbbbbbbbbbc
 | 
						|
 0: abbbbbbbbbbbc
 | 
						|
    bbbbbbbbbbbac
 | 
						|
 0: bbbbbbbbbbbac
 | 
						|
\= Expect no match
 | 
						|
    aaac
 | 
						|
No match
 | 
						|
    abbbbbbbbbbbac
 | 
						|
No match
 | 
						|
 | 
						|
/^(b+|a){1,2}c/
 | 
						|
    bc
 | 
						|
 0: bc
 | 
						|
    bbc
 | 
						|
 0: bbc
 | 
						|
    bbbc
 | 
						|
 0: bbbc
 | 
						|
    bac
 | 
						|
 0: bac
 | 
						|
    bbac
 | 
						|
 0: bbac
 | 
						|
    aac
 | 
						|
 0: aac
 | 
						|
    abbbbbbbbbbbc
 | 
						|
 0: abbbbbbbbbbbc
 | 
						|
    bbbbbbbbbbbac
 | 
						|
 0: bbbbbbbbbbbac
 | 
						|
\= Expect no match
 | 
						|
    aaac
 | 
						|
No match
 | 
						|
    abbbbbbbbbbbac
 | 
						|
No match
 | 
						|
 | 
						|
/^(b+|a){1,2}?bc/
 | 
						|
    bbc
 | 
						|
 0: bbc
 | 
						|
 | 
						|
/^(b*|ba){1,2}?bc/
 | 
						|
    babc
 | 
						|
 0: babc
 | 
						|
    bbabc
 | 
						|
 0: bbabc
 | 
						|
    bababc
 | 
						|
 0: bababc
 | 
						|
\= Expect no match
 | 
						|
    bababbc
 | 
						|
No match
 | 
						|
    babababc
 | 
						|
No match
 | 
						|
 | 
						|
/^(ba|b*){1,2}?bc/
 | 
						|
    babc
 | 
						|
 0: babc
 | 
						|
    bbabc
 | 
						|
 0: bbabc
 | 
						|
    bababc
 | 
						|
 0: bababc
 | 
						|
\= Expect no match
 | 
						|
    bababbc
 | 
						|
No match
 | 
						|
    babababc
 | 
						|
No match
 | 
						|
 | 
						|
/^\ca\cA\c[\c{\c:/
 | 
						|
    \x01\x01\e;z
 | 
						|
 0: \x01\x01\x1b;z
 | 
						|
 | 
						|
/^[ab\]cde]/
 | 
						|
    athing
 | 
						|
 0: a
 | 
						|
    bthing
 | 
						|
 0: b
 | 
						|
    ]thing
 | 
						|
 0: ]
 | 
						|
    cthing
 | 
						|
 0: c
 | 
						|
    dthing
 | 
						|
 0: d
 | 
						|
    ething
 | 
						|
 0: e
 | 
						|
\= Expect no match
 | 
						|
    fthing
 | 
						|
No match
 | 
						|
    [thing
 | 
						|
No match
 | 
						|
    \\thing
 | 
						|
No match
 | 
						|
 | 
						|
/^[]cde]/
 | 
						|
    ]thing
 | 
						|
 0: ]
 | 
						|
    cthing
 | 
						|
 0: c
 | 
						|
    dthing
 | 
						|
 0: d
 | 
						|
    ething
 | 
						|
 0: e
 | 
						|
\= Expect no match
 | 
						|
    athing
 | 
						|
No match
 | 
						|
    fthing
 | 
						|
No match
 | 
						|
 | 
						|
/^[^ab\]cde]/
 | 
						|
    fthing
 | 
						|
 0: f
 | 
						|
    [thing
 | 
						|
 0: [
 | 
						|
    \\thing
 | 
						|
 0: \
 | 
						|
\= Expect no match
 | 
						|
    athing
 | 
						|
No match
 | 
						|
    bthing
 | 
						|
No match
 | 
						|
    ]thing
 | 
						|
No match
 | 
						|
    cthing
 | 
						|
No match
 | 
						|
    dthing
 | 
						|
No match
 | 
						|
    ething
 | 
						|
No match
 | 
						|
 | 
						|
/^[^]cde]/
 | 
						|
    athing
 | 
						|
 0: a
 | 
						|
    fthing
 | 
						|
 0: f
 | 
						|
\= Expect no match
 | 
						|
    ]thing
 | 
						|
No match
 | 
						|
    cthing
 | 
						|
No match
 | 
						|
    dthing
 | 
						|
No match
 | 
						|
    ething
 | 
						|
No match
 | 
						|
 | 
						|
/^\�/
 | 
						|
    �
 | 
						|
 0: \x81
 | 
						|
 | 
						|
/^�/
 | 
						|
    �
 | 
						|
 0: \xff
 | 
						|
 | 
						|
/^[0-9]+$/
 | 
						|
    0
 | 
						|
 0: 0
 | 
						|
    1
 | 
						|
 0: 1
 | 
						|
    2
 | 
						|
 0: 2
 | 
						|
    3
 | 
						|
 0: 3
 | 
						|
    4
 | 
						|
 0: 4
 | 
						|
    5
 | 
						|
 0: 5
 | 
						|
    6
 | 
						|
 0: 6
 | 
						|
    7
 | 
						|
 0: 7
 | 
						|
    8
 | 
						|
 0: 8
 | 
						|
    9
 | 
						|
 0: 9
 | 
						|
    10
 | 
						|
 0: 10
 | 
						|
    100
 | 
						|
 0: 100
 | 
						|
\= Expect no match
 | 
						|
    abc
 | 
						|
No match
 | 
						|
 | 
						|
/^.*nter/
 | 
						|
    enter
 | 
						|
 0: enter
 | 
						|
    inter
 | 
						|
 0: inter
 | 
						|
    uponter
 | 
						|
 0: uponter
 | 
						|
 | 
						|
/^xxx[0-9]+$/
 | 
						|
    xxx0
 | 
						|
 0: xxx0
 | 
						|
    xxx1234
 | 
						|
 0: xxx1234
 | 
						|
\= Expect no match
 | 
						|
    xxx
 | 
						|
No match
 | 
						|
 | 
						|
/^.+[0-9][0-9][0-9]$/
 | 
						|
    x123
 | 
						|
 0: x123
 | 
						|
    xx123
 | 
						|
 0: xx123
 | 
						|
    123456
 | 
						|
 0: 123456
 | 
						|
    x1234
 | 
						|
 0: x1234
 | 
						|
\= Expect no match
 | 
						|
    123
 | 
						|
No match
 | 
						|
 | 
						|
/^.+?[0-9][0-9][0-9]$/
 | 
						|
    x123
 | 
						|
 0: x123
 | 
						|
    xx123
 | 
						|
 0: xx123
 | 
						|
    123456
 | 
						|
 0: 123456
 | 
						|
    x1234
 | 
						|
 0: x1234
 | 
						|
\= Expect no match
 | 
						|
    123
 | 
						|
No match
 | 
						|
 | 
						|
/^([^!]+)!(.+)=apquxz\.ixr\.zzz\.ac\.uk$/
 | 
						|
    abc!pqr=apquxz.ixr.zzz.ac.uk
 | 
						|
 0: abc!pqr=apquxz.ixr.zzz.ac.uk
 | 
						|
\= Expect no match
 | 
						|
    !pqr=apquxz.ixr.zzz.ac.uk
 | 
						|
No match
 | 
						|
    abc!=apquxz.ixr.zzz.ac.uk
 | 
						|
No match
 | 
						|
    abc!pqr=apquxz:ixr.zzz.ac.uk
 | 
						|
No match
 | 
						|
    abc!pqr=apquxz.ixr.zzz.ac.ukk
 | 
						|
No match
 | 
						|
 | 
						|
/:/
 | 
						|
    Well, we need a colon: somewhere
 | 
						|
 0: :
 | 
						|
\= Expect no match
 | 
						|
    No match without a colon
 | 
						|
No match
 | 
						|
 | 
						|
/([\da-f:]+)$/i
 | 
						|
    0abc
 | 
						|
 0: 0abc
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    fed
 | 
						|
 0: fed
 | 
						|
    E
 | 
						|
 0: E
 | 
						|
    ::
 | 
						|
 0: ::
 | 
						|
    5f03:12C0::932e
 | 
						|
 0: 5f03:12C0::932e
 | 
						|
    fed def
 | 
						|
 0: def
 | 
						|
    Any old stuff
 | 
						|
 0: ff
 | 
						|
\= Expect no match
 | 
						|
    0zzz
 | 
						|
No match
 | 
						|
    gzzz
 | 
						|
No match
 | 
						|
    fed\x20
 | 
						|
No match
 | 
						|
    Any old rubbish
 | 
						|
No match
 | 
						|
 | 
						|
/^.*\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/
 | 
						|
    .1.2.3
 | 
						|
 0: .1.2.3
 | 
						|
    A.12.123.0
 | 
						|
 0: A.12.123.0
 | 
						|
\= Expect no match
 | 
						|
    .1.2.3333
 | 
						|
No match
 | 
						|
    1.2.3
 | 
						|
No match
 | 
						|
    1234.2.3
 | 
						|
No match
 | 
						|
 | 
						|
/^(\d+)\s+IN\s+SOA\s+(\S+)\s+(\S+)\s*\(\s*$/
 | 
						|
    1 IN SOA non-sp1 non-sp2(
 | 
						|
 0: 1 IN SOA non-sp1 non-sp2(
 | 
						|
    1    IN    SOA    non-sp1    non-sp2   (
 | 
						|
 0: 1    IN    SOA    non-sp1    non-sp2   (
 | 
						|
\= Expect no match
 | 
						|
    1IN SOA non-sp1 non-sp2(
 | 
						|
No match
 | 
						|
 | 
						|
/^[a-zA-Z\d][a-zA-Z\d\-]*(\.[a-zA-Z\d][a-zA-z\d\-]*)*\.$/
 | 
						|
    a.
 | 
						|
 0: a.
 | 
						|
    Z.
 | 
						|
 0: Z.
 | 
						|
    2.
 | 
						|
 0: 2.
 | 
						|
    ab-c.pq-r.
 | 
						|
 0: ab-c.pq-r.
 | 
						|
    sxk.zzz.ac.uk.
 | 
						|
 0: sxk.zzz.ac.uk.
 | 
						|
    x-.y-.
 | 
						|
 0: x-.y-.
 | 
						|
\= Expect no match
 | 
						|
    -abc.peq.
 | 
						|
No match
 | 
						|
 | 
						|
/^\*\.[a-z]([a-z\-\d]*[a-z\d]+)?(\.[a-z]([a-z\-\d]*[a-z\d]+)?)*$/
 | 
						|
    *.a
 | 
						|
 0: *.a
 | 
						|
    *.b0-a
 | 
						|
 0: *.b0-a
 | 
						|
    *.c3-b.c
 | 
						|
 0: *.c3-b.c
 | 
						|
    *.c-a.b-c
 | 
						|
 0: *.c-a.b-c
 | 
						|
\= Expect no match
 | 
						|
    *.0
 | 
						|
No match
 | 
						|
    *.a-
 | 
						|
No match
 | 
						|
    *.a-b.c-
 | 
						|
No match
 | 
						|
    *.c-a.0-c
 | 
						|
No match
 | 
						|
 | 
						|
/^(?=ab(de))(abd)(e)/
 | 
						|
    abde
 | 
						|
 0: abde
 | 
						|
 | 
						|
/^(?!(ab)de|x)(abd)(f)/
 | 
						|
    abdf
 | 
						|
 0: abdf
 | 
						|
 | 
						|
/^(?=(ab(cd)))(ab)/
 | 
						|
    abcd
 | 
						|
 0: ab
 | 
						|
 | 
						|
/^[\da-f](\.[\da-f])*$/i
 | 
						|
    a.b.c.d
 | 
						|
 0: a.b.c.d
 | 
						|
    A.B.C.D
 | 
						|
 0: A.B.C.D
 | 
						|
    a.b.c.1.2.3.C
 | 
						|
 0: a.b.c.1.2.3.C
 | 
						|
 | 
						|
/^\".*\"\s*(;.*)?$/
 | 
						|
    \"1234\"
 | 
						|
 0: "1234"
 | 
						|
    \"abcd\" ;
 | 
						|
 0: "abcd" ;
 | 
						|
    \"\" ; rhubarb
 | 
						|
 0: "" ; rhubarb
 | 
						|
\= Expect no match
 | 
						|
    \"1234\" : things
 | 
						|
No match
 | 
						|
 | 
						|
/^$/
 | 
						|
    \
 | 
						|
 0: 
 | 
						|
 | 
						|
/   ^    a   (?# begins with a)  b\sc (?# then b c) $ (?# then end)/x
 | 
						|
    ab c
 | 
						|
 0: ab c
 | 
						|
\= Expect no match
 | 
						|
    abc
 | 
						|
No match
 | 
						|
    ab cde
 | 
						|
No match
 | 
						|
 | 
						|
/(?x)   ^    a   (?# begins with a)  b\sc (?# then b c) $ (?# then end)/
 | 
						|
    ab c
 | 
						|
 0: ab c
 | 
						|
\= Expect no match
 | 
						|
    abc
 | 
						|
No match
 | 
						|
    ab cde
 | 
						|
No match
 | 
						|
 | 
						|
/^   a\ b[c ]d       $/x
 | 
						|
    a bcd
 | 
						|
 0: a bcd
 | 
						|
    a b d
 | 
						|
 0: a b d
 | 
						|
\= Expect no match
 | 
						|
    abcd
 | 
						|
No match
 | 
						|
    ab d
 | 
						|
No match
 | 
						|
 | 
						|
/^(a(b(c)))(d(e(f)))(h(i(j)))(k(l(m)))$/
 | 
						|
    abcdefhijklm
 | 
						|
 0: abcdefhijklm
 | 
						|
 | 
						|
/^(?:a(b(c)))(?:d(e(f)))(?:h(i(j)))(?:k(l(m)))$/
 | 
						|
    abcdefhijklm
 | 
						|
 0: abcdefhijklm
 | 
						|
 | 
						|
/^[\w][\W][\s][\S][\d][\D][\b][\n][\c]][\022]/
 | 
						|
    a+ Z0+\x08\n\x1d\x12
 | 
						|
 0: a+ Z0+\x08\x0a\x1d\x12
 | 
						|
 | 
						|
/^[.^$|()*+?{,}]+/
 | 
						|
    .^\$(*+)|{?,?}
 | 
						|
 0: .^$(*+)|{?,?}
 | 
						|
 | 
						|
/^a*\w/
 | 
						|
    z
 | 
						|
 0: z
 | 
						|
    az
 | 
						|
 0: az
 | 
						|
 1: a
 | 
						|
    aaaz
 | 
						|
 0: aaaz
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
 3: a
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
    aa
 | 
						|
 0: aa
 | 
						|
 1: a
 | 
						|
    aaaa
 | 
						|
 0: aaaa
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
 3: a
 | 
						|
    a+
 | 
						|
 0: a
 | 
						|
    aa+
 | 
						|
 0: aa
 | 
						|
 1: a
 | 
						|
 | 
						|
/^a*?\w/
 | 
						|
    z
 | 
						|
 0: z
 | 
						|
    az
 | 
						|
 0: az
 | 
						|
 1: a
 | 
						|
    aaaz
 | 
						|
 0: aaaz
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
 3: a
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
    aa
 | 
						|
 0: aa
 | 
						|
 1: a
 | 
						|
    aaaa
 | 
						|
 0: aaaa
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
 3: a
 | 
						|
    a+
 | 
						|
 0: a
 | 
						|
    aa+
 | 
						|
 0: aa
 | 
						|
 1: a
 | 
						|
 | 
						|
/^a+\w/
 | 
						|
    az
 | 
						|
 0: az
 | 
						|
    aaaz
 | 
						|
 0: aaaz
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
    aa
 | 
						|
 0: aa
 | 
						|
    aaaa
 | 
						|
 0: aaaa
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
    aa+
 | 
						|
 0: aa
 | 
						|
 | 
						|
/^a+?\w/
 | 
						|
    az
 | 
						|
 0: az
 | 
						|
    aaaz
 | 
						|
 0: aaaz
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
    aa
 | 
						|
 0: aa
 | 
						|
    aaaa
 | 
						|
 0: aaaa
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
    aa+
 | 
						|
 0: aa
 | 
						|
 | 
						|
/^\d{8}\w{2,}/
 | 
						|
    1234567890
 | 
						|
 0: 1234567890
 | 
						|
    12345678ab
 | 
						|
 0: 12345678ab
 | 
						|
    12345678__
 | 
						|
 0: 12345678__
 | 
						|
\= Expect no match
 | 
						|
    1234567
 | 
						|
No match
 | 
						|
 | 
						|
/^[aeiou\d]{4,5}$/
 | 
						|
    uoie
 | 
						|
 0: uoie
 | 
						|
    1234
 | 
						|
 0: 1234
 | 
						|
    12345
 | 
						|
 0: 12345
 | 
						|
    aaaaa
 | 
						|
 0: aaaaa
 | 
						|
\= Expect no match
 | 
						|
    123456
 | 
						|
No match
 | 
						|
 | 
						|
/^[aeiou\d]{4,5}?/
 | 
						|
    uoie
 | 
						|
 0: uoie
 | 
						|
    1234
 | 
						|
 0: 1234
 | 
						|
    12345
 | 
						|
 0: 12345
 | 
						|
 1: 1234
 | 
						|
    aaaaa
 | 
						|
 0: aaaaa
 | 
						|
 1: aaaa
 | 
						|
    123456
 | 
						|
 0: 12345
 | 
						|
 1: 1234
 | 
						|
 | 
						|
/^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]/
 | 
						|
    From abcd  Mon Sep 01 12:33:02 1997
 | 
						|
 0: From abcd  Mon Sep 01 12:33
 | 
						|
 | 
						|
/^From\s+\S+\s+([a-zA-Z]{3}\s+){2}\d{1,2}\s+\d\d:\d\d/
 | 
						|
    From abcd  Mon Sep 01 12:33:02 1997
 | 
						|
 0: From abcd  Mon Sep 01 12:33
 | 
						|
    From abcd  Mon Sep  1 12:33:02 1997
 | 
						|
 0: From abcd  Mon Sep  1 12:33
 | 
						|
\= Expect no match
 | 
						|
    From abcd  Sep 01 12:33:02 1997
 | 
						|
No match
 | 
						|
 | 
						|
/^12.34/s
 | 
						|
    12\n34
 | 
						|
 0: 12\x0a34
 | 
						|
    12\r34
 | 
						|
 0: 12\x0d34
 | 
						|
 | 
						|
/\w+(?=\t)/
 | 
						|
    the quick brown\t fox
 | 
						|
 0: brown
 | 
						|
 | 
						|
/foo(?!bar)(.*)/
 | 
						|
    foobar is foolish see?
 | 
						|
 0: foolish see?
 | 
						|
 | 
						|
/(?:(?!foo)...|^.{0,2})bar(.*)/
 | 
						|
    foobar crowbar etc
 | 
						|
 0: rowbar etc
 | 
						|
    barrel
 | 
						|
 0: barrel
 | 
						|
    2barrel
 | 
						|
 0: 2barrel
 | 
						|
    A barrel
 | 
						|
 0: A barrel
 | 
						|
 | 
						|
/^(\D*)(?=\d)(?!123)/
 | 
						|
    abc456
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    abc123
 | 
						|
No match
 | 
						|
 | 
						|
/^1234(?# test newlines
 | 
						|
  inside)/
 | 
						|
    1234
 | 
						|
 0: 1234
 | 
						|
 | 
						|
/^1234 #comment in extended re
 | 
						|
  /x
 | 
						|
    1234
 | 
						|
 0: 1234
 | 
						|
 | 
						|
/#rhubarb
 | 
						|
  abcd/x
 | 
						|
    abcd
 | 
						|
 0: abcd
 | 
						|
 | 
						|
/^abcd#rhubarb/x
 | 
						|
    abcd
 | 
						|
 0: abcd
 | 
						|
 | 
						|
/(?!^)abc/
 | 
						|
    the abc
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    abc
 | 
						|
No match
 | 
						|
 | 
						|
/(?=^)abc/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    the abc
 | 
						|
No match
 | 
						|
 | 
						|
/^[ab]{1,3}(ab*|b)/no_auto_possess
 | 
						|
    aabbbbb
 | 
						|
 0: aabbbbb
 | 
						|
 1: aabbbb
 | 
						|
 2: aabbb
 | 
						|
 3: aabb
 | 
						|
 4: aab
 | 
						|
 5: aa
 | 
						|
 | 
						|
/^[ab]{1,3}?(ab*|b)/no_auto_possess
 | 
						|
    aabbbbb
 | 
						|
 0: aabbbbb
 | 
						|
 1: aabbbb
 | 
						|
 2: aabbb
 | 
						|
 3: aabb
 | 
						|
 4: aab
 | 
						|
 5: aa
 | 
						|
 | 
						|
/^[ab]{1,3}?(ab*?|b)/no_auto_possess
 | 
						|
    aabbbbb
 | 
						|
 0: aabbbbb
 | 
						|
 1: aabbbb
 | 
						|
 2: aabbb
 | 
						|
 3: aabb
 | 
						|
 4: aab
 | 
						|
 5: aa
 | 
						|
 | 
						|
/^[ab]{1,3}(ab*?|b)/no_auto_possess
 | 
						|
    aabbbbb
 | 
						|
 0: aabbbbb
 | 
						|
 1: aabbbb
 | 
						|
 2: aabbb
 | 
						|
 3: aabb
 | 
						|
 4: aab
 | 
						|
 5: aa
 | 
						|
 | 
						|
/  (?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*                          # optional leading comment
 | 
						|
(?:    (?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|
 | 
						|
" (?:                      # opening quote...
 | 
						|
[^\\\x80-\xff\n\015"]                #   Anything except backslash and quote
 | 
						|
|                     #    or
 | 
						|
\\ [^\x80-\xff]           #   Escaped something (something != CR)
 | 
						|
)* "  # closing quote
 | 
						|
)                    # initial word
 | 
						|
(?:  (?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*  \.  (?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*   (?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|
 | 
						|
" (?:                      # opening quote...
 | 
						|
[^\\\x80-\xff\n\015"]                #   Anything except backslash and quote
 | 
						|
|                     #    or
 | 
						|
\\ [^\x80-\xff]           #   Escaped something (something != CR)
 | 
						|
)* "  # closing quote
 | 
						|
)  )* # further okay, if led by a period
 | 
						|
(?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*  @  (?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*    (?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|   \[                         # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
 | 
						|
\]                        #           ]
 | 
						|
)                           # initial subdomain
 | 
						|
(?:                                  #
 | 
						|
(?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*  \.                        # if led by a period...
 | 
						|
(?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*   (?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|   \[                         # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
 | 
						|
\]                        #           ]
 | 
						|
)                     #   ...further okay
 | 
						|
)*
 | 
						|
# address
 | 
						|
|                     #  or
 | 
						|
(?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|
 | 
						|
" (?:                      # opening quote...
 | 
						|
[^\\\x80-\xff\n\015"]                #   Anything except backslash and quote
 | 
						|
|                     #    or
 | 
						|
\\ [^\x80-\xff]           #   Escaped something (something != CR)
 | 
						|
)* "  # closing quote
 | 
						|
)             # one word, optionally followed by....
 | 
						|
(?:
 | 
						|
[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037]  |  # atom and space parts, or...
 | 
						|
\(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)       |  # comments, or...
 | 
						|
 | 
						|
" (?:                      # opening quote...
 | 
						|
[^\\\x80-\xff\n\015"]                #   Anything except backslash and quote
 | 
						|
|                     #    or
 | 
						|
\\ [^\x80-\xff]           #   Escaped something (something != CR)
 | 
						|
)* "  # closing quote
 | 
						|
# quoted strings
 | 
						|
)*
 | 
						|
<  (?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*                     # leading <
 | 
						|
(?:  @  (?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*    (?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|   \[                         # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
 | 
						|
\]                        #           ]
 | 
						|
)                           # initial subdomain
 | 
						|
(?:                                  #
 | 
						|
(?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*  \.                        # if led by a period...
 | 
						|
(?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*   (?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|   \[                         # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
 | 
						|
\]                        #           ]
 | 
						|
)                     #   ...further okay
 | 
						|
)*
 | 
						|
 | 
						|
(?:  (?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*  ,  (?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*  @  (?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*    (?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|   \[                         # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
 | 
						|
\]                        #           ]
 | 
						|
)                           # initial subdomain
 | 
						|
(?:                                  #
 | 
						|
(?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*  \.                        # if led by a period...
 | 
						|
(?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*   (?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|   \[                         # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
 | 
						|
\]                        #           ]
 | 
						|
)                     #   ...further okay
 | 
						|
)*
 | 
						|
)* # further okay, if led by comma
 | 
						|
:                                # closing colon
 | 
						|
(?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*  )? #       optional route
 | 
						|
(?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|
 | 
						|
" (?:                      # opening quote...
 | 
						|
[^\\\x80-\xff\n\015"]                #   Anything except backslash and quote
 | 
						|
|                     #    or
 | 
						|
\\ [^\x80-\xff]           #   Escaped something (something != CR)
 | 
						|
)* "  # closing quote
 | 
						|
)                    # initial word
 | 
						|
(?:  (?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*  \.  (?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*   (?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|
 | 
						|
" (?:                      # opening quote...
 | 
						|
[^\\\x80-\xff\n\015"]                #   Anything except backslash and quote
 | 
						|
|                     #    or
 | 
						|
\\ [^\x80-\xff]           #   Escaped something (something != CR)
 | 
						|
)* "  # closing quote
 | 
						|
)  )* # further okay, if led by a period
 | 
						|
(?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*  @  (?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*    (?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|   \[                         # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
 | 
						|
\]                        #           ]
 | 
						|
)                           # initial subdomain
 | 
						|
(?:                                  #
 | 
						|
(?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*  \.                        # if led by a period...
 | 
						|
(?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*   (?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|   \[                         # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*    #    stuff
 | 
						|
\]                        #           ]
 | 
						|
)                     #   ...further okay
 | 
						|
)*
 | 
						|
#       address spec
 | 
						|
(?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*  > #                  trailing >
 | 
						|
# name and address
 | 
						|
)  (?: [\040\t] |  \(
 | 
						|
(?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  |  \( (?:  [^\\\x80-\xff\n\015()]  |  \\ [^\x80-\xff]  )* \)  )*
 | 
						|
\)  )*                       # optional trailing comment
 | 
						|
/x
 | 
						|
    Alan Other <user\@dom.ain>
 | 
						|
 0: Alan Other <user@dom.ain>
 | 
						|
    <user\@dom.ain>
 | 
						|
 0: user@dom.ain
 | 
						|
 1: user@dom
 | 
						|
    user\@dom.ain
 | 
						|
 0: user@dom.ain
 | 
						|
 1: user@dom
 | 
						|
    \"A. Other\" <user.1234\@dom.ain> (a comment)
 | 
						|
 0: "A. Other" <user.1234@dom.ain> (a comment)
 | 
						|
 1: "A. Other" <user.1234@dom.ain> 
 | 
						|
 2: "A. Other" <user.1234@dom.ain>
 | 
						|
    A. Other <user.1234\@dom.ain> (a comment)
 | 
						|
 0:  Other <user.1234@dom.ain> (a comment)
 | 
						|
 1:  Other <user.1234@dom.ain> 
 | 
						|
 2:  Other <user.1234@dom.ain>
 | 
						|
    \"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"\@x400-re.lay
 | 
						|
 0: "/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/"@x400-re.lay
 | 
						|
 1: "/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/"@x400-re
 | 
						|
    A missing angle <user\@some.where
 | 
						|
 0: user@some.where
 | 
						|
 1: user@some
 | 
						|
\= Expect no match
 | 
						|
    The quick brown fox
 | 
						|
No match
 | 
						|
 | 
						|
/[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
# optional leading comment
 | 
						|
(?:
 | 
						|
(?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
# Atom
 | 
						|
|                       #  or
 | 
						|
"                                     # "
 | 
						|
[^\\\x80-\xff\n\015"] *                            #   normal
 | 
						|
(?:  \\ [^\x80-\xff]  [^\\\x80-\xff\n\015"] * )*        #   ( special normal* )*
 | 
						|
"                                     #        "
 | 
						|
# Quoted string
 | 
						|
)
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
(?:
 | 
						|
\.
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
(?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
# Atom
 | 
						|
|                       #  or
 | 
						|
"                                     # "
 | 
						|
[^\\\x80-\xff\n\015"] *                            #   normal
 | 
						|
(?:  \\ [^\x80-\xff]  [^\\\x80-\xff\n\015"] * )*        #   ( special normal* )*
 | 
						|
"                                     #        "
 | 
						|
# Quoted string
 | 
						|
)
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
# additional words
 | 
						|
)*
 | 
						|
@
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
(?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|
 | 
						|
\[                            # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
 | 
						|
\]                           #           ]
 | 
						|
)
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
# optional trailing comments
 | 
						|
(?:
 | 
						|
\.
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
(?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|
 | 
						|
\[                            # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
 | 
						|
\]                           #           ]
 | 
						|
)
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
# optional trailing comments
 | 
						|
)*
 | 
						|
# address
 | 
						|
|                             #  or
 | 
						|
(?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
# Atom
 | 
						|
|                       #  or
 | 
						|
"                                     # "
 | 
						|
[^\\\x80-\xff\n\015"] *                            #   normal
 | 
						|
(?:  \\ [^\x80-\xff]  [^\\\x80-\xff\n\015"] * )*        #   ( special normal* )*
 | 
						|
"                                     #        "
 | 
						|
# Quoted string
 | 
						|
)
 | 
						|
# leading word
 | 
						|
[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037] *               # "normal" atoms and or spaces
 | 
						|
(?:
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
|
 | 
						|
"                                     # "
 | 
						|
[^\\\x80-\xff\n\015"] *                            #   normal
 | 
						|
(?:  \\ [^\x80-\xff]  [^\\\x80-\xff\n\015"] * )*        #   ( special normal* )*
 | 
						|
"                                     #        "
 | 
						|
) # "special" comment or quoted string
 | 
						|
[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037] *            #  more "normal"
 | 
						|
)*
 | 
						|
<
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
# <
 | 
						|
(?:
 | 
						|
@
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
(?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|
 | 
						|
\[                            # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
 | 
						|
\]                           #           ]
 | 
						|
)
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
# optional trailing comments
 | 
						|
(?:
 | 
						|
\.
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
(?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|
 | 
						|
\[                            # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
 | 
						|
\]                           #           ]
 | 
						|
)
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
# optional trailing comments
 | 
						|
)*
 | 
						|
(?: ,
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
@
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
(?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|
 | 
						|
\[                            # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
 | 
						|
\]                           #           ]
 | 
						|
)
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
# optional trailing comments
 | 
						|
(?:
 | 
						|
\.
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
(?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|
 | 
						|
\[                            # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
 | 
						|
\]                           #           ]
 | 
						|
)
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
# optional trailing comments
 | 
						|
)*
 | 
						|
)*  # additional domains
 | 
						|
:
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
# optional trailing comments
 | 
						|
)?     #       optional route
 | 
						|
(?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
# Atom
 | 
						|
|                       #  or
 | 
						|
"                                     # "
 | 
						|
[^\\\x80-\xff\n\015"] *                            #   normal
 | 
						|
(?:  \\ [^\x80-\xff]  [^\\\x80-\xff\n\015"] * )*        #   ( special normal* )*
 | 
						|
"                                     #        "
 | 
						|
# Quoted string
 | 
						|
)
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
(?:
 | 
						|
\.
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
(?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
# Atom
 | 
						|
|                       #  or
 | 
						|
"                                     # "
 | 
						|
[^\\\x80-\xff\n\015"] *                            #   normal
 | 
						|
(?:  \\ [^\x80-\xff]  [^\\\x80-\xff\n\015"] * )*        #   ( special normal* )*
 | 
						|
"                                     #        "
 | 
						|
# Quoted string
 | 
						|
)
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
# additional words
 | 
						|
)*
 | 
						|
@
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
(?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|
 | 
						|
\[                            # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
 | 
						|
\]                           #           ]
 | 
						|
)
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
# optional trailing comments
 | 
						|
(?:
 | 
						|
\.
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
(?:
 | 
						|
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+    # some number of atom characters...
 | 
						|
(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]) # ..not followed by something that could be part of an atom
 | 
						|
|
 | 
						|
\[                            # [
 | 
						|
(?: [^\\\x80-\xff\n\015\[\]] |  \\ [^\x80-\xff]  )*     #    stuff
 | 
						|
\]                           #           ]
 | 
						|
)
 | 
						|
[\040\t]*                    # Nab whitespace.
 | 
						|
(?:
 | 
						|
\(                              #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                             #     normal*
 | 
						|
(?:                                 #       (
 | 
						|
(?:  \\ [^\x80-\xff]  |
 | 
						|
\(                            #  (
 | 
						|
[^\\\x80-\xff\n\015()] *                            #     normal*
 | 
						|
(?:  \\ [^\x80-\xff]   [^\\\x80-\xff\n\015()] * )*        #     (special normal*)*
 | 
						|
\)                           #                       )
 | 
						|
)    #         special
 | 
						|
[^\\\x80-\xff\n\015()] *                         #         normal*
 | 
						|
)*                                  #            )*
 | 
						|
\)                             #                )
 | 
						|
[\040\t]* )*    # If comment found, allow more spaces.
 | 
						|
# optional trailing comments
 | 
						|
)*
 | 
						|
#       address spec
 | 
						|
>                    #                 >
 | 
						|
# name and address
 | 
						|
)
 | 
						|
/x
 | 
						|
    Alan Other <user\@dom.ain>
 | 
						|
 0: Alan Other <user@dom.ain>
 | 
						|
    <user\@dom.ain>
 | 
						|
 0: user@dom.ain
 | 
						|
 1: user@dom
 | 
						|
    user\@dom.ain
 | 
						|
 0: user@dom.ain
 | 
						|
 1: user@dom
 | 
						|
    \"A. Other\" <user.1234\@dom.ain> (a comment)
 | 
						|
 0: "A. Other" <user.1234@dom.ain>
 | 
						|
    A. Other <user.1234\@dom.ain> (a comment)
 | 
						|
 0:  Other <user.1234@dom.ain>
 | 
						|
    \"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"\@x400-re.lay
 | 
						|
 0: "/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/"@x400-re.lay
 | 
						|
 1: "/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/"@x400-re
 | 
						|
    A missing angle <user\@some.where
 | 
						|
 0: user@some.where
 | 
						|
 1: user@some
 | 
						|
\= Expect no match
 | 
						|
    The quick brown fox
 | 
						|
No match
 | 
						|
 | 
						|
/abc\0def\00pqr\000xyz\0000AB/
 | 
						|
    abc\0def\00pqr\000xyz\0000AB
 | 
						|
 0: abc\x00def\x00pqr\x00xyz\x000AB
 | 
						|
    abc456 abc\0def\00pqr\000xyz\0000ABCDE
 | 
						|
 0: abc\x00def\x00pqr\x00xyz\x000AB
 | 
						|
 | 
						|
/abc\x0def\x00pqr\x000xyz\x0000AB/
 | 
						|
    abc\x0def\x00pqr\x000xyz\x0000AB
 | 
						|
 0: abc\x0def\x00pqr\x000xyz\x0000AB
 | 
						|
    abc456 abc\x0def\x00pqr\x000xyz\x0000ABCDE
 | 
						|
 0: abc\x0def\x00pqr\x000xyz\x0000AB
 | 
						|
 | 
						|
/^[\000-\037]/
 | 
						|
    \0A
 | 
						|
 0: \x00
 | 
						|
    \01B
 | 
						|
 0: \x01
 | 
						|
    \037C
 | 
						|
 0: \x1f
 | 
						|
 | 
						|
/\0*/
 | 
						|
    \0\0\0\0
 | 
						|
 0: \x00\x00\x00\x00
 | 
						|
 | 
						|
/A\x0{2,3}Z/
 | 
						|
    The A\x0\x0Z
 | 
						|
 0: A\x00\x00Z
 | 
						|
    An A\0\x0\0Z
 | 
						|
 0: A\x00\x00\x00Z
 | 
						|
\= Expect no match
 | 
						|
    A\0Z
 | 
						|
No match
 | 
						|
    A\0\x0\0\x0Z
 | 
						|
No match
 | 
						|
 | 
						|
/^\s/
 | 
						|
    \040abc
 | 
						|
 0:  
 | 
						|
    \x0cabc
 | 
						|
 0: \x0c
 | 
						|
    \nabc
 | 
						|
 0: \x0a
 | 
						|
    \rabc
 | 
						|
 0: \x0d
 | 
						|
    \tabc
 | 
						|
 0: \x09
 | 
						|
\= Expect no match
 | 
						|
    abc
 | 
						|
No match
 | 
						|
 | 
						|
/^a	b
 | 
						|
      c/x
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
 | 
						|
/ab{1,3}bc/
 | 
						|
    abbbbc
 | 
						|
 0: abbbbc
 | 
						|
    abbbc
 | 
						|
 0: abbbc
 | 
						|
    abbc
 | 
						|
 0: abbc
 | 
						|
\= Expect no match
 | 
						|
    abc
 | 
						|
No match
 | 
						|
    abbbbbc
 | 
						|
No match
 | 
						|
 | 
						|
/([^.]*)\.([^:]*):[T ]+(.*)/
 | 
						|
    track1.title:TBlah blah blah
 | 
						|
 0: track1.title:TBlah blah blah
 | 
						|
 | 
						|
/([^.]*)\.([^:]*):[T ]+(.*)/i
 | 
						|
    track1.title:TBlah blah blah
 | 
						|
 0: track1.title:TBlah blah blah
 | 
						|
 | 
						|
/([^.]*)\.([^:]*):[t ]+(.*)/i
 | 
						|
    track1.title:TBlah blah blah
 | 
						|
 0: track1.title:TBlah blah blah
 | 
						|
 | 
						|
/^[W-c]+$/
 | 
						|
    WXY_^abc
 | 
						|
 0: WXY_^abc
 | 
						|
\= Expect no match
 | 
						|
    wxy
 | 
						|
No match
 | 
						|
 | 
						|
/^[W-c]+$/i
 | 
						|
    WXY_^abc
 | 
						|
 0: WXY_^abc
 | 
						|
    wxy_^ABC
 | 
						|
 0: wxy_^ABC
 | 
						|
 | 
						|
/^[\x3f-\x5F]+$/i
 | 
						|
    WXY_^abc
 | 
						|
 0: WXY_^abc
 | 
						|
    wxy_^ABC
 | 
						|
 0: wxy_^ABC
 | 
						|
 | 
						|
/^abc$/m
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    qqq\nabc
 | 
						|
 0: abc
 | 
						|
    abc\nzzz
 | 
						|
 0: abc
 | 
						|
    qqq\nabc\nzzz
 | 
						|
 0: abc
 | 
						|
 | 
						|
/^abc$/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    qqq\nabc
 | 
						|
No match
 | 
						|
    abc\nzzz
 | 
						|
No match
 | 
						|
    qqq\nabc\nzzz
 | 
						|
No match
 | 
						|
 | 
						|
/\Aabc\Z/m
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    abc\n 
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    qqq\nabc
 | 
						|
No match
 | 
						|
    abc\nzzz
 | 
						|
No match
 | 
						|
    qqq\nabc\nzzz
 | 
						|
No match
 | 
						|
    
 | 
						|
/\A(.)*\Z/s
 | 
						|
    abc\ndef
 | 
						|
 0: abc\x0adef
 | 
						|
 | 
						|
/\A(.)*\Z/m
 | 
						|
\= Expect no match
 | 
						|
    abc\ndef
 | 
						|
No match
 | 
						|
 | 
						|
/(?:b)|(?::+)/
 | 
						|
    b::c
 | 
						|
 0: b
 | 
						|
    c::b
 | 
						|
 0: ::
 | 
						|
 | 
						|
/[-az]+/
 | 
						|
    az-
 | 
						|
 0: az-
 | 
						|
\= Expect no match
 | 
						|
    b
 | 
						|
No match
 | 
						|
 | 
						|
/[az-]+/
 | 
						|
    za-
 | 
						|
 0: za-
 | 
						|
\= Expect no match
 | 
						|
    b
 | 
						|
No match
 | 
						|
 | 
						|
/[a\-z]+/
 | 
						|
    a-z
 | 
						|
 0: a-z
 | 
						|
\= Expect no match
 | 
						|
    b
 | 
						|
No match
 | 
						|
 | 
						|
/[a-z]+/
 | 
						|
    abcdxyz
 | 
						|
 0: abcdxyz
 | 
						|
 | 
						|
/[\d-]+/
 | 
						|
    12-34
 | 
						|
 0: 12-34
 | 
						|
\= Expect no match
 | 
						|
    aaa
 | 
						|
No match
 | 
						|
 | 
						|
/[\d-z]+/
 | 
						|
    12-34z
 | 
						|
 0: 12-34z
 | 
						|
\= Expect no match
 | 
						|
    aaa
 | 
						|
No match
 | 
						|
 | 
						|
/\x5c/
 | 
						|
    \\
 | 
						|
 0: \
 | 
						|
 | 
						|
/\x20Z/
 | 
						|
    the Zoo
 | 
						|
 0:  Z
 | 
						|
\= Expect no match
 | 
						|
    Zulu
 | 
						|
No match
 | 
						|
 | 
						|
/ab{3cd/
 | 
						|
    ab{3cd
 | 
						|
 0: ab{3cd
 | 
						|
 | 
						|
/ab{3,cd/
 | 
						|
    ab{3,cd
 | 
						|
 0: ab{3,cd
 | 
						|
 | 
						|
/ab{3,4a}cd/
 | 
						|
    ab{3,4a}cd
 | 
						|
 0: ab{3,4a}cd
 | 
						|
 | 
						|
/{4,5a}bc/
 | 
						|
    {4,5a}bc
 | 
						|
 0: {4,5a}bc
 | 
						|
 | 
						|
/^a.b/newline=lf
 | 
						|
    a\rb
 | 
						|
 0: a\x0db
 | 
						|
\= Expect no match
 | 
						|
    a\nb
 | 
						|
No match
 | 
						|
 | 
						|
/abc$/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    abc\n
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    abc\ndef
 | 
						|
No match
 | 
						|
 | 
						|
/(abc)\123/
 | 
						|
    abc\x53
 | 
						|
 0: abcS
 | 
						|
 | 
						|
/(abc)\223/
 | 
						|
    abc\x93
 | 
						|
 0: abc\x93
 | 
						|
 | 
						|
/(abc)\323/
 | 
						|
    abc\xd3
 | 
						|
 0: abc\xd3
 | 
						|
 | 
						|
/(abc)\100/
 | 
						|
    abc\x40
 | 
						|
 0: abc@
 | 
						|
    abc\100
 | 
						|
 0: abc@
 | 
						|
 | 
						|
/(abc)\1000/
 | 
						|
    abc\x400
 | 
						|
 0: abc@0
 | 
						|
    abc\x40\x30
 | 
						|
 0: abc@0
 | 
						|
    abc\1000
 | 
						|
 0: abc@0
 | 
						|
    abc\100\x30
 | 
						|
 0: abc@0
 | 
						|
    abc\100\060
 | 
						|
 0: abc@0
 | 
						|
    abc\100\60
 | 
						|
 0: abc@0
 | 
						|
 | 
						|
/(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\12\123/
 | 
						|
    abcdefghijk\12S
 | 
						|
 0: abcdefghijk\x0aS
 | 
						|
 | 
						|
/a{0}bc/
 | 
						|
    bc
 | 
						|
 0: bc
 | 
						|
 | 
						|
/(a|(bc)){0,0}?xyz/
 | 
						|
    xyz
 | 
						|
 0: xyz
 | 
						|
 | 
						|
/abc[\10]de/
 | 
						|
    abc\010de
 | 
						|
 0: abc\x08de
 | 
						|
 | 
						|
/abc[\1]de/
 | 
						|
    abc\1de
 | 
						|
 0: abc\x01de
 | 
						|
 | 
						|
/(abc)[\1]de/
 | 
						|
    abc\1de
 | 
						|
 0: abc\x01de
 | 
						|
 | 
						|
/(?s)a.b/
 | 
						|
    a\nb
 | 
						|
 0: a\x0ab
 | 
						|
 | 
						|
/^([^a])([^\b])([^c]*)([^d]{3,4})/
 | 
						|
    baNOTccccd
 | 
						|
 0: baNOTcccc
 | 
						|
 1: baNOTccc
 | 
						|
 2: baNOTcc
 | 
						|
 3: baNOTc
 | 
						|
    baNOTcccd
 | 
						|
 0: baNOTccc
 | 
						|
 1: baNOTcc
 | 
						|
 2: baNOTc
 | 
						|
    baNOTccd
 | 
						|
 0: baNOTcc
 | 
						|
 1: baNOTc
 | 
						|
    bacccd
 | 
						|
 0: baccc
 | 
						|
\= Expect no match
 | 
						|
    anything
 | 
						|
No match
 | 
						|
    b\bc   
 | 
						|
No match
 | 
						|
    baccd
 | 
						|
No match
 | 
						|
 | 
						|
/[^a]/
 | 
						|
    Abc
 | 
						|
 0: A
 | 
						|
  
 | 
						|
/[^a]/i
 | 
						|
    Abc 
 | 
						|
 0: b
 | 
						|
 | 
						|
/[^a]+/
 | 
						|
    AAAaAbc
 | 
						|
 0: AAA
 | 
						|
  
 | 
						|
/[^a]+/i
 | 
						|
    AAAaAbc 
 | 
						|
 0: bc
 | 
						|
 | 
						|
/[^a]+/
 | 
						|
    bbb\nccc
 | 
						|
 0: bbb\x0accc
 | 
						|
   
 | 
						|
/[^k]$/
 | 
						|
    abc
 | 
						|
 0: c
 | 
						|
\= Expect no match
 | 
						|
    abk   
 | 
						|
No match
 | 
						|
   
 | 
						|
/[^k]{2,3}$/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    kbc
 | 
						|
 0: bc
 | 
						|
    kabc 
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    abk
 | 
						|
No match
 | 
						|
    akb
 | 
						|
No match
 | 
						|
    akk 
 | 
						|
No match
 | 
						|
 | 
						|
/^\d{8,}\@.+[^k]$/
 | 
						|
    12345678\@a.b.c.d
 | 
						|
 0: 12345678@a.b.c.d
 | 
						|
    123456789\@x.y.z
 | 
						|
 0: 123456789@x.y.z
 | 
						|
\= Expect no match
 | 
						|
    12345678\@x.y.uk
 | 
						|
No match
 | 
						|
    1234567\@a.b.c.d       
 | 
						|
No match
 | 
						|
 | 
						|
/[^a]/
 | 
						|
    aaaabcd
 | 
						|
 0: b
 | 
						|
    aaAabcd 
 | 
						|
 0: A
 | 
						|
 | 
						|
/[^a]/i
 | 
						|
    aaaabcd
 | 
						|
 0: b
 | 
						|
    aaAabcd 
 | 
						|
 0: b
 | 
						|
 | 
						|
/[^az]/
 | 
						|
    aaaabcd
 | 
						|
 0: b
 | 
						|
    aaAabcd 
 | 
						|
 0: A
 | 
						|
 | 
						|
/[^az]/i
 | 
						|
    aaaabcd
 | 
						|
 0: b
 | 
						|
    aaAabcd 
 | 
						|
 0: b
 | 
						|
 | 
						|
/\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377/
 | 
						|
 \000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377
 | 
						|
 0: \x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff
 | 
						|
 | 
						|
/P[^*]TAIRE[^*]{1,6}?LL/
 | 
						|
    xxxxxxxxxxxPSTAIREISLLxxxxxxxxx
 | 
						|
 0: PSTAIREISLL
 | 
						|
 | 
						|
/P[^*]TAIRE[^*]{1,}?LL/
 | 
						|
    xxxxxxxxxxxPSTAIREISLLxxxxxxxxx
 | 
						|
 0: PSTAIREISLL
 | 
						|
 | 
						|
/(\.\d\d[1-9]?)\d+/
 | 
						|
    1.230003938
 | 
						|
 0: .230003938
 | 
						|
    1.875000282   
 | 
						|
 0: .875000282
 | 
						|
    1.235  
 | 
						|
 0: .235
 | 
						|
                  
 | 
						|
/(\.\d\d((?=0)|\d(?=\d)))/
 | 
						|
    1.230003938      
 | 
						|
 0: .230
 | 
						|
 1: .23
 | 
						|
    1.875000282
 | 
						|
 0: .875
 | 
						|
\= Expect no match 
 | 
						|
    1.235 
 | 
						|
No match
 | 
						|
    
 | 
						|
/a(?)b/
 | 
						|
    ab 
 | 
						|
 0: ab
 | 
						|
 
 | 
						|
/\b(foo)\s+(\w+)/i
 | 
						|
    Food is on the foo table
 | 
						|
 0: foo table
 | 
						|
    
 | 
						|
/foo(.*)bar/
 | 
						|
    The food is under the bar in the barn.
 | 
						|
 0: food is under the bar in the bar
 | 
						|
 1: food is under the bar
 | 
						|
    
 | 
						|
/foo(.*?)bar/
 | 
						|
    The food is under the bar in the barn.
 | 
						|
 0: food is under the bar in the bar
 | 
						|
 1: food is under the bar
 | 
						|
 | 
						|
/(.*)(\d*)/no_auto_possess
 | 
						|
    I have 2 numbers: 53147
 | 
						|
Matched, but offsets vector is too small to show all matches
 | 
						|
 0: I have 2 numbers: 53147
 | 
						|
 1: I have 2 numbers: 5314
 | 
						|
 2: I have 2 numbers: 531
 | 
						|
 3: I have 2 numbers: 53
 | 
						|
 4: I have 2 numbers: 5
 | 
						|
 5: I have 2 numbers: 
 | 
						|
 6: I have 2 numbers:
 | 
						|
 7: I have 2 numbers
 | 
						|
 8: I have 2 number
 | 
						|
 9: I have 2 numbe
 | 
						|
10: I have 2 numb
 | 
						|
11: I have 2 num
 | 
						|
12: I have 2 nu
 | 
						|
13: I have 2 n
 | 
						|
14: I have 2 
 | 
						|
    
 | 
						|
/(.*)(\d+)/
 | 
						|
    I have 2 numbers: 53147
 | 
						|
 0: I have 2 numbers: 53147
 | 
						|
 1: I have 2
 | 
						|
 
 | 
						|
/(.*?)(\d*)/no_auto_possess
 | 
						|
    I have 2 numbers: 53147
 | 
						|
Matched, but offsets vector is too small to show all matches
 | 
						|
 0: I have 2 numbers: 53147
 | 
						|
 1: I have 2 numbers: 5314
 | 
						|
 2: I have 2 numbers: 531
 | 
						|
 3: I have 2 numbers: 53
 | 
						|
 4: I have 2 numbers: 5
 | 
						|
 5: I have 2 numbers: 
 | 
						|
 6: I have 2 numbers:
 | 
						|
 7: I have 2 numbers
 | 
						|
 8: I have 2 number
 | 
						|
 9: I have 2 numbe
 | 
						|
10: I have 2 numb
 | 
						|
11: I have 2 num
 | 
						|
12: I have 2 nu
 | 
						|
13: I have 2 n
 | 
						|
14: I have 2 
 | 
						|
 | 
						|
/(.*?)(\d+)/
 | 
						|
    I have 2 numbers: 53147
 | 
						|
 0: I have 2 numbers: 53147
 | 
						|
 1: I have 2
 | 
						|
 | 
						|
/(.*)(\d+)$/
 | 
						|
    I have 2 numbers: 53147
 | 
						|
 0: I have 2 numbers: 53147
 | 
						|
 | 
						|
/(.*?)(\d+)$/
 | 
						|
    I have 2 numbers: 53147
 | 
						|
 0: I have 2 numbers: 53147
 | 
						|
 | 
						|
/(.*)\b(\d+)$/
 | 
						|
    I have 2 numbers: 53147
 | 
						|
 0: I have 2 numbers: 53147
 | 
						|
 | 
						|
/(.*\D)(\d+)$/
 | 
						|
    I have 2 numbers: 53147
 | 
						|
 0: I have 2 numbers: 53147
 | 
						|
 | 
						|
/^\D*(?!123)/
 | 
						|
    ABC123
 | 
						|
 0: AB
 | 
						|
 1: A
 | 
						|
 2: 
 | 
						|
     
 | 
						|
/^(\D*)(?=\d)(?!123)/
 | 
						|
    ABC445
 | 
						|
 0: ABC
 | 
						|
\= Expect no match
 | 
						|
    ABC123
 | 
						|
No match
 | 
						|
    
 | 
						|
/^[W-]46]/
 | 
						|
    W46]789 
 | 
						|
 0: W46]
 | 
						|
    -46]789
 | 
						|
 0: -46]
 | 
						|
\= Expect no match
 | 
						|
    Wall
 | 
						|
No match
 | 
						|
    Zebra
 | 
						|
No match
 | 
						|
    42
 | 
						|
No match
 | 
						|
    [abcd] 
 | 
						|
No match
 | 
						|
    ]abcd[
 | 
						|
No match
 | 
						|
       
 | 
						|
/^[W-\]46]/
 | 
						|
    W46]789 
 | 
						|
 0: W
 | 
						|
    Wall
 | 
						|
 0: W
 | 
						|
    Zebra
 | 
						|
 0: Z
 | 
						|
    Xylophone  
 | 
						|
 0: X
 | 
						|
    42
 | 
						|
 0: 4
 | 
						|
    [abcd] 
 | 
						|
 0: [
 | 
						|
    ]abcd[
 | 
						|
 0: ]
 | 
						|
    \\backslash 
 | 
						|
 0: \
 | 
						|
\= Expect no match
 | 
						|
    -46]789
 | 
						|
No match
 | 
						|
    well
 | 
						|
No match
 | 
						|
    
 | 
						|
/\d\d\/\d\d\/\d\d\d\d/
 | 
						|
    01/01/2000
 | 
						|
 0: 01/01/2000
 | 
						|
 | 
						|
/word (?:[a-zA-Z0-9]+ ){0,10}otherword/
 | 
						|
  word cat dog elephant mussel cow horse canary baboon snake shark otherword
 | 
						|
 0: word cat dog elephant mussel cow horse canary baboon snake shark otherword
 | 
						|
\= Expect no match
 | 
						|
  word cat dog elephant mussel cow horse canary baboon snake shark
 | 
						|
No match
 | 
						|
 | 
						|
/word (?:[a-zA-Z0-9]+ ){0,300}otherword/
 | 
						|
\= Expect no match
 | 
						|
  word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope
 | 
						|
No match
 | 
						|
 | 
						|
/^(a){0,0}/
 | 
						|
    bcd
 | 
						|
 0: 
 | 
						|
    abc
 | 
						|
 0: 
 | 
						|
    aab     
 | 
						|
 0: 
 | 
						|
 | 
						|
/^(a){0,1}/
 | 
						|
    bcd
 | 
						|
 0: 
 | 
						|
    abc
 | 
						|
 0: a
 | 
						|
 1: 
 | 
						|
    aab  
 | 
						|
 0: a
 | 
						|
 1: 
 | 
						|
 | 
						|
/^(a){0,2}/
 | 
						|
    bcd
 | 
						|
 0: 
 | 
						|
    abc
 | 
						|
 0: a
 | 
						|
 1: 
 | 
						|
    aab  
 | 
						|
 0: aa
 | 
						|
 1: a
 | 
						|
 2: 
 | 
						|
 | 
						|
/^(a){0,3}/
 | 
						|
    bcd
 | 
						|
 0: 
 | 
						|
    abc
 | 
						|
 0: a
 | 
						|
 1: 
 | 
						|
    aab
 | 
						|
 0: aa
 | 
						|
 1: a
 | 
						|
 2: 
 | 
						|
    aaa   
 | 
						|
 0: aaa
 | 
						|
 1: aa
 | 
						|
 2: a
 | 
						|
 3: 
 | 
						|
 | 
						|
/^(a){0,}/
 | 
						|
    bcd
 | 
						|
 0: 
 | 
						|
    abc
 | 
						|
 0: a
 | 
						|
 1: 
 | 
						|
    aab
 | 
						|
 0: aa
 | 
						|
 1: a
 | 
						|
 2: 
 | 
						|
    aaa
 | 
						|
 0: aaa
 | 
						|
 1: aa
 | 
						|
 2: a
 | 
						|
 3: 
 | 
						|
    aaaaaaaa    
 | 
						|
 0: aaaaaaaa
 | 
						|
 1: aaaaaaa
 | 
						|
 2: aaaaaa
 | 
						|
 3: aaaaa
 | 
						|
 4: aaaa
 | 
						|
 5: aaa
 | 
						|
 6: aa
 | 
						|
 7: a
 | 
						|
 8: 
 | 
						|
 | 
						|
/^(a){1,1}/
 | 
						|
    abc
 | 
						|
 0: a
 | 
						|
    aab  
 | 
						|
 0: a
 | 
						|
\= Expect no match
 | 
						|
    bcd
 | 
						|
No match
 | 
						|
 | 
						|
/^(a){1,2}/
 | 
						|
    abc
 | 
						|
 0: a
 | 
						|
    aab  
 | 
						|
 0: aa
 | 
						|
 1: a
 | 
						|
\= Expect no match
 | 
						|
    bcd
 | 
						|
No match
 | 
						|
 | 
						|
/^(a){1,3}/
 | 
						|
    abc
 | 
						|
 0: a
 | 
						|
    aab
 | 
						|
 0: aa
 | 
						|
 1: a
 | 
						|
    aaa   
 | 
						|
 0: aaa
 | 
						|
 1: aa
 | 
						|
 2: a
 | 
						|
\= Expect no match
 | 
						|
    bcd
 | 
						|
No match
 | 
						|
 | 
						|
/^(a){1,}/
 | 
						|
    abc
 | 
						|
 0: a
 | 
						|
    aab
 | 
						|
 0: aa
 | 
						|
 1: a
 | 
						|
    aaa
 | 
						|
 0: aaa
 | 
						|
 1: aa
 | 
						|
 2: a
 | 
						|
    aaaaaaaa    
 | 
						|
 0: aaaaaaaa
 | 
						|
 1: aaaaaaa
 | 
						|
 2: aaaaaa
 | 
						|
 3: aaaaa
 | 
						|
 4: aaaa
 | 
						|
 5: aaa
 | 
						|
 6: aa
 | 
						|
 7: a
 | 
						|
\= Expect no match
 | 
						|
    bcd
 | 
						|
No match
 | 
						|
 | 
						|
/.*\.gif/
 | 
						|
    borfle\nbib.gif\nno
 | 
						|
 0: bib.gif
 | 
						|
 | 
						|
/.{0,}\.gif/
 | 
						|
    borfle\nbib.gif\nno
 | 
						|
 0: bib.gif
 | 
						|
 | 
						|
/.*\.gif/m
 | 
						|
    borfle\nbib.gif\nno
 | 
						|
 0: bib.gif
 | 
						|
 | 
						|
/.*\.gif/s
 | 
						|
    borfle\nbib.gif\nno
 | 
						|
 0: borfle\x0abib.gif
 | 
						|
 | 
						|
/.*\.gif/ms
 | 
						|
    borfle\nbib.gif\nno
 | 
						|
 0: borfle\x0abib.gif
 | 
						|
    
 | 
						|
/.*$/
 | 
						|
    borfle\nbib.gif\nno
 | 
						|
 0: no
 | 
						|
 | 
						|
/.*$/m
 | 
						|
    borfle\nbib.gif\nno
 | 
						|
 0: borfle
 | 
						|
 | 
						|
/.*$/s
 | 
						|
    borfle\nbib.gif\nno
 | 
						|
 0: borfle\x0abib.gif\x0ano
 | 
						|
 | 
						|
/.*$/ms
 | 
						|
    borfle\nbib.gif\nno
 | 
						|
 0: borfle\x0abib.gif\x0ano
 | 
						|
 1: borfle\x0abib.gif
 | 
						|
 2: borfle
 | 
						|
    
 | 
						|
/.*$/
 | 
						|
    borfle\nbib.gif\nno\n
 | 
						|
 0: no
 | 
						|
 | 
						|
/.*$/m
 | 
						|
    borfle\nbib.gif\nno\n
 | 
						|
 0: borfle
 | 
						|
 | 
						|
/.*$/s
 | 
						|
    borfle\nbib.gif\nno\n
 | 
						|
 0: borfle\x0abib.gif\x0ano\x0a
 | 
						|
 1: borfle\x0abib.gif\x0ano
 | 
						|
 | 
						|
/.*$/ms
 | 
						|
    borfle\nbib.gif\nno\n
 | 
						|
 0: borfle\x0abib.gif\x0ano\x0a
 | 
						|
 1: borfle\x0abib.gif\x0ano
 | 
						|
 2: borfle\x0abib.gif
 | 
						|
 3: borfle
 | 
						|
    
 | 
						|
/(.*X|^B)/
 | 
						|
    abcde\n1234Xyz
 | 
						|
 0: 1234X
 | 
						|
    BarFoo 
 | 
						|
 0: B
 | 
						|
\= Expect no match
 | 
						|
    abcde\nBar  
 | 
						|
No match
 | 
						|
 | 
						|
/(.*X|^B)/m
 | 
						|
    abcde\n1234Xyz
 | 
						|
 0: 1234X
 | 
						|
    BarFoo 
 | 
						|
 0: B
 | 
						|
    abcde\nBar  
 | 
						|
 0: B
 | 
						|
 | 
						|
/(.*X|^B)/s
 | 
						|
    abcde\n1234Xyz
 | 
						|
 0: abcde\x0a1234X
 | 
						|
    BarFoo 
 | 
						|
 0: B
 | 
						|
\= Expect no match
 | 
						|
    abcde\nBar  
 | 
						|
No match
 | 
						|
 | 
						|
/(.*X|^B)/ms
 | 
						|
    abcde\n1234Xyz
 | 
						|
 0: abcde\x0a1234X
 | 
						|
    BarFoo 
 | 
						|
 0: B
 | 
						|
    abcde\nBar  
 | 
						|
 0: B
 | 
						|
 | 
						|
/(?s)(.*X|^B)/
 | 
						|
    abcde\n1234Xyz
 | 
						|
 0: abcde\x0a1234X
 | 
						|
    BarFoo 
 | 
						|
 0: B
 | 
						|
\= Expect no match 
 | 
						|
    abcde\nBar  
 | 
						|
No match
 | 
						|
 | 
						|
/(?s:.*X|^B)/
 | 
						|
    abcde\n1234Xyz
 | 
						|
 0: abcde\x0a1234X
 | 
						|
    BarFoo 
 | 
						|
 0: B
 | 
						|
\= Expect no match 
 | 
						|
    abcde\nBar  
 | 
						|
No match
 | 
						|
 | 
						|
/^.*B/
 | 
						|
\= Expect no match
 | 
						|
    abc\nB
 | 
						|
No match
 | 
						|
     
 | 
						|
/(?s)^.*B/
 | 
						|
    abc\nB
 | 
						|
 0: abc\x0aB
 | 
						|
 | 
						|
/(?m)^.*B/
 | 
						|
    abc\nB
 | 
						|
 0: B
 | 
						|
     
 | 
						|
/(?ms)^.*B/
 | 
						|
    abc\nB
 | 
						|
 0: abc\x0aB
 | 
						|
 | 
						|
/(?ms)^B/
 | 
						|
    abc\nB
 | 
						|
 0: B
 | 
						|
 | 
						|
/(?s)B$/
 | 
						|
    B\n
 | 
						|
 0: B
 | 
						|
 | 
						|
/^[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]/
 | 
						|
    123456654321
 | 
						|
 0: 123456654321
 | 
						|
  
 | 
						|
/^\d\d\d\d\d\d\d\d\d\d\d\d/
 | 
						|
    123456654321 
 | 
						|
 0: 123456654321
 | 
						|
 | 
						|
/^[\d][\d][\d][\d][\d][\d][\d][\d][\d][\d][\d][\d]/
 | 
						|
    123456654321
 | 
						|
 0: 123456654321
 | 
						|
  
 | 
						|
/^[abc]{12}/
 | 
						|
    abcabcabcabc
 | 
						|
 0: abcabcabcabc
 | 
						|
    
 | 
						|
/^[a-c]{12}/
 | 
						|
    abcabcabcabc
 | 
						|
 0: abcabcabcabc
 | 
						|
    
 | 
						|
/^(a|b|c){12}/
 | 
						|
    abcabcabcabc 
 | 
						|
 0: abcabcabcabc
 | 
						|
 | 
						|
/^[abcdefghijklmnopqrstuvwxy0123456789]/
 | 
						|
    n
 | 
						|
 0: n
 | 
						|
\= Expect no match 
 | 
						|
    z 
 | 
						|
No match
 | 
						|
 | 
						|
/abcde{0,0}/
 | 
						|
    abcd
 | 
						|
 0: abcd
 | 
						|
\= Expect no match
 | 
						|
    abce  
 | 
						|
No match
 | 
						|
 | 
						|
/ab[cd]{0,0}e/
 | 
						|
    abe
 | 
						|
 0: abe
 | 
						|
\= Expect no match
 | 
						|
    abcde 
 | 
						|
No match
 | 
						|
    
 | 
						|
/ab(c){0,0}d/
 | 
						|
    abd
 | 
						|
 0: abd
 | 
						|
\= Expect no match
 | 
						|
    abcd   
 | 
						|
No match
 | 
						|
 | 
						|
/a(b*)/
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
    abbbb
 | 
						|
 0: abbbb
 | 
						|
\= Expect no match
 | 
						|
    bbbbb    
 | 
						|
No match
 | 
						|
    
 | 
						|
/ab\d{0}e/
 | 
						|
    abe
 | 
						|
 0: abe
 | 
						|
\= Expect no match
 | 
						|
    ab1e   
 | 
						|
No match
 | 
						|
    
 | 
						|
/"([^\\"]+|\\.)*"/
 | 
						|
    the \"quick\" brown fox
 | 
						|
 0: "quick"
 | 
						|
    \"the \\\"quick\\\" brown fox\" 
 | 
						|
 0: "the \"quick\" brown fox"
 | 
						|
 | 
						|
/.*?/g,aftertext
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
 0+ 
 | 
						|
 1: ab
 | 
						|
 2: a
 | 
						|
 3: 
 | 
						|
 0: 
 | 
						|
 0+ 
 | 
						|
  
 | 
						|
/\b/g,aftertext
 | 
						|
    abc 
 | 
						|
 0: 
 | 
						|
 0+ abc
 | 
						|
 0: 
 | 
						|
 0+ 
 | 
						|
 | 
						|
/\b/g,aftertext
 | 
						|
    abc 
 | 
						|
 0: 
 | 
						|
 0+ abc
 | 
						|
 0: 
 | 
						|
 0+ 
 | 
						|
 | 
						|
//g
 | 
						|
    abc
 | 
						|
 0: 
 | 
						|
 0: 
 | 
						|
 0: 
 | 
						|
 0: 
 | 
						|
 | 
						|
/<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>/is
 | 
						|
  <TR BGCOLOR='#DBE9E9'><TD align=left valign=top>43.<a href='joblist.cfm?JobID=94 6735&Keyword='>Word Processor<BR>(N-1286)</a></TD><TD align=left valign=top>Lega lstaff.com</TD><TD align=left valign=top>CA - Statewide</TD></TR>
 | 
						|
 0: <TR BGCOLOR='#DBE9E9'><TD align=left valign=top>43.<a href='joblist.cfm?JobID=94 6735&Keyword='>Word Processor<BR>(N-1286)</a></TD><TD align=left valign=top>Lega lstaff.com</TD><TD align=left valign=top>CA - Statewide</TD></TR>
 | 
						|
 | 
						|
/a[^a]b/
 | 
						|
    acb
 | 
						|
 0: acb
 | 
						|
    a\nb
 | 
						|
 0: a\x0ab
 | 
						|
    
 | 
						|
/a.b/
 | 
						|
    acb
 | 
						|
 0: acb
 | 
						|
\= Expect no match 
 | 
						|
    a\nb   
 | 
						|
No match
 | 
						|
    
 | 
						|
/a[^a]b/s
 | 
						|
    acb
 | 
						|
 0: acb
 | 
						|
    a\nb  
 | 
						|
 0: a\x0ab
 | 
						|
    
 | 
						|
/a.b/s
 | 
						|
    acb
 | 
						|
 0: acb
 | 
						|
    a\nb  
 | 
						|
 0: a\x0ab
 | 
						|
 | 
						|
/^(b+?|a){1,2}?c/
 | 
						|
    bac
 | 
						|
 0: bac
 | 
						|
    bbac
 | 
						|
 0: bbac
 | 
						|
    bbbac
 | 
						|
 0: bbbac
 | 
						|
    bbbbac
 | 
						|
 0: bbbbac
 | 
						|
    bbbbbac 
 | 
						|
 0: bbbbbac
 | 
						|
 | 
						|
/^(b+|a){1,2}?c/
 | 
						|
    bac
 | 
						|
 0: bac
 | 
						|
    bbac
 | 
						|
 0: bbac
 | 
						|
    bbbac
 | 
						|
 0: bbbac
 | 
						|
    bbbbac
 | 
						|
 0: bbbbac
 | 
						|
    bbbbbac 
 | 
						|
 0: bbbbbac
 | 
						|
    
 | 
						|
/(?!\A)x/m
 | 
						|
    a\bx\n  
 | 
						|
 0: x
 | 
						|
\= Expect no match
 | 
						|
    x\nb\n
 | 
						|
No match
 | 
						|
    
 | 
						|
/\x0{ab}/
 | 
						|
    \0{ab} 
 | 
						|
 0: \x00{ab}
 | 
						|
 | 
						|
/(A|B)*?CD/
 | 
						|
    CD 
 | 
						|
 0: CD
 | 
						|
    
 | 
						|
/(A|B)*CD/
 | 
						|
    CD 
 | 
						|
 0: CD
 | 
						|
 | 
						|
/(?<!bar)foo/
 | 
						|
    foo
 | 
						|
 0: foo
 | 
						|
    catfood
 | 
						|
 0: foo
 | 
						|
    arfootle
 | 
						|
 0: foo
 | 
						|
    rfoosh
 | 
						|
 0: foo
 | 
						|
\= Expect no match
 | 
						|
    barfoo
 | 
						|
No match
 | 
						|
    towbarfoo
 | 
						|
No match
 | 
						|
 | 
						|
/\w{3}(?<!bar)foo/
 | 
						|
    catfood
 | 
						|
 0: catfoo
 | 
						|
\= Expect no match
 | 
						|
    foo
 | 
						|
No match
 | 
						|
    barfoo
 | 
						|
No match
 | 
						|
    towbarfoo
 | 
						|
No match
 | 
						|
 | 
						|
/(?<=(foo)a)bar/
 | 
						|
    fooabar
 | 
						|
 0: bar
 | 
						|
\= Expect no match
 | 
						|
    bar
 | 
						|
No match
 | 
						|
    foobbar
 | 
						|
No match
 | 
						|
      
 | 
						|
/\Aabc\z/m
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    abc\n   
 | 
						|
No match
 | 
						|
    qqq\nabc
 | 
						|
No match
 | 
						|
    abc\nzzz
 | 
						|
No match
 | 
						|
    qqq\nabc\nzzz
 | 
						|
No match
 | 
						|
 | 
						|
"(?>.*/)foo"
 | 
						|
\= Expect no match
 | 
						|
    /this/is/a/very/long/line/in/deed/with/very/many/slashes/in/it/you/see/
 | 
						|
No match
 | 
						|
 | 
						|
"(?>.*/)foo"
 | 
						|
    /this/is/a/very/long/line/in/deed/with/very/many/slashes/in/and/foo
 | 
						|
 0: /this/is/a/very/long/line/in/deed/with/very/many/slashes/in/and/foo
 | 
						|
 | 
						|
/(?>(\.\d\d[1-9]?))\d+/
 | 
						|
    1.230003938
 | 
						|
 0: .230003938
 | 
						|
    1.875000282
 | 
						|
 0: .875000282
 | 
						|
\= Expect no match 
 | 
						|
    1.235 
 | 
						|
No match
 | 
						|
 | 
						|
/^((?>\w+)|(?>\s+))*$/
 | 
						|
    now is the time for all good men to come to the aid of the party
 | 
						|
 0: now is the time for all good men to come to the aid of the party
 | 
						|
\= Expect no match
 | 
						|
    this is not a line with only words and spaces!
 | 
						|
No match
 | 
						|
    
 | 
						|
/(\d+)(\w)/
 | 
						|
    12345a
 | 
						|
 0: 12345a
 | 
						|
 1: 12345
 | 
						|
 2: 1234
 | 
						|
 3: 123
 | 
						|
 4: 12
 | 
						|
    12345+ 
 | 
						|
 0: 12345
 | 
						|
 1: 1234
 | 
						|
 2: 123
 | 
						|
 3: 12
 | 
						|
 | 
						|
/((?>\d+))(\w)/
 | 
						|
    12345a
 | 
						|
 0: 12345a
 | 
						|
\= Expect no match
 | 
						|
    12345+ 
 | 
						|
No match
 | 
						|
 | 
						|
/(?>a+)b/
 | 
						|
    aaab
 | 
						|
 0: aaab
 | 
						|
 | 
						|
/((?>a+)b)/
 | 
						|
    aaab
 | 
						|
 0: aaab
 | 
						|
 | 
						|
/(?>(a+))b/
 | 
						|
    aaab
 | 
						|
 0: aaab
 | 
						|
 | 
						|
/(?>b)+/
 | 
						|
    aaabbbccc
 | 
						|
 0: bbb
 | 
						|
 1: bb
 | 
						|
 2: b
 | 
						|
 | 
						|
/(?>a+|b+|c+)*c/
 | 
						|
    aaabbbbccccd
 | 
						|
 0: aaabbbbcccc
 | 
						|
 1: aaabbbbc
 | 
						|
    
 | 
						|
/(a+|b+|c+)*c/
 | 
						|
    aaabbbbccccd
 | 
						|
 0: aaabbbbcccc
 | 
						|
 1: aaabbbbccc
 | 
						|
 2: aaabbbbcc
 | 
						|
 3: aaabbbbc
 | 
						|
 | 
						|
/((?>[^()]+)|\([^()]*\))+/
 | 
						|
    ((abc(ade)ufh()()x
 | 
						|
 0: abc(ade)ufh()()x
 | 
						|
 1: abc(ade)ufh()()
 | 
						|
 2: abc(ade)ufh()
 | 
						|
 3: abc(ade)ufh
 | 
						|
 4: abc(ade)
 | 
						|
 5: abc
 | 
						|
    
 | 
						|
/\(((?>[^()]+)|\([^()]+\))+\)/
 | 
						|
    (abc)
 | 
						|
 0: (abc)
 | 
						|
    (abc(def)xyz)
 | 
						|
 0: (abc(def)xyz)
 | 
						|
\= Expect no match
 | 
						|
    ((()aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa   
 | 
						|
No match
 | 
						|
 | 
						|
/a(?-i)b/i
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
    Ab
 | 
						|
 0: Ab
 | 
						|
\= Expect no match 
 | 
						|
    aB
 | 
						|
No match
 | 
						|
    AB
 | 
						|
No match
 | 
						|
        
 | 
						|
/(a (?x)b c)d e/
 | 
						|
    a bcd e
 | 
						|
 0: a bcd e
 | 
						|
\= Expect no match
 | 
						|
    a b cd e
 | 
						|
No match
 | 
						|
    abcd e   
 | 
						|
No match
 | 
						|
    a bcde 
 | 
						|
No match
 | 
						|
 
 | 
						|
/(a b(?x)c d (?-x)e f)/
 | 
						|
    a bcde f
 | 
						|
 0: a bcde f
 | 
						|
\= Expect no match
 | 
						|
    abcdef  
 | 
						|
No match
 | 
						|
 | 
						|
/(a(?i)b)c/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    aBc
 | 
						|
 0: aBc
 | 
						|
\= Expect no match
 | 
						|
    abC
 | 
						|
No match
 | 
						|
    aBC  
 | 
						|
No match
 | 
						|
    Abc
 | 
						|
No match
 | 
						|
    ABc
 | 
						|
No match
 | 
						|
    ABC
 | 
						|
No match
 | 
						|
    AbC
 | 
						|
No match
 | 
						|
    
 | 
						|
/a(?i:b)c/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    aBc
 | 
						|
 0: aBc
 | 
						|
\= Expect no match 
 | 
						|
    ABC
 | 
						|
No match
 | 
						|
    abC
 | 
						|
No match
 | 
						|
    aBC
 | 
						|
No match
 | 
						|
    
 | 
						|
/a(?i:b)*c/
 | 
						|
    aBc
 | 
						|
 0: aBc
 | 
						|
    aBBc
 | 
						|
 0: aBBc
 | 
						|
\= Expect no match 
 | 
						|
    aBC
 | 
						|
No match
 | 
						|
    aBBC
 | 
						|
No match
 | 
						|
    
 | 
						|
/a(?=b(?i)c)\w\wd/
 | 
						|
    abcd
 | 
						|
 0: abcd
 | 
						|
    abCd
 | 
						|
 0: abCd
 | 
						|
\= Expect no match
 | 
						|
    aBCd
 | 
						|
No match
 | 
						|
    abcD     
 | 
						|
No match
 | 
						|
    
 | 
						|
/(?s-i:more.*than).*million/i
 | 
						|
    more than million
 | 
						|
 0: more than million
 | 
						|
    more than MILLION
 | 
						|
 0: more than MILLION
 | 
						|
    more \n than Million 
 | 
						|
 0: more \x0a than Million
 | 
						|
\= Expect no match
 | 
						|
    MORE THAN MILLION    
 | 
						|
No match
 | 
						|
    more \n than \n million 
 | 
						|
No match
 | 
						|
 | 
						|
/(?:(?s-i)more.*than).*million/i
 | 
						|
    more than million
 | 
						|
 0: more than million
 | 
						|
    more than MILLION
 | 
						|
 0: more than MILLION
 | 
						|
    more \n than Million 
 | 
						|
 0: more \x0a than Million
 | 
						|
\= Expect no match
 | 
						|
    MORE THAN MILLION    
 | 
						|
No match
 | 
						|
    more \n than \n million 
 | 
						|
No match
 | 
						|
    
 | 
						|
/(?>a(?i)b+)+c/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    aBbc
 | 
						|
 0: aBbc
 | 
						|
    aBBc 
 | 
						|
 0: aBBc
 | 
						|
\= Expect no match
 | 
						|
    Abc
 | 
						|
No match
 | 
						|
    abAb    
 | 
						|
No match
 | 
						|
    abbC 
 | 
						|
No match
 | 
						|
    
 | 
						|
/(?=a(?i)b)\w\wc/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    aBc
 | 
						|
 0: aBc
 | 
						|
\= Expect no match
 | 
						|
    Ab 
 | 
						|
No match
 | 
						|
    abC
 | 
						|
No match
 | 
						|
    aBC     
 | 
						|
No match
 | 
						|
    
 | 
						|
/(?<=a(?i)b)(\w\w)c/
 | 
						|
    abxxc
 | 
						|
 0: xxc
 | 
						|
    aBxxc
 | 
						|
 0: xxc
 | 
						|
\= Expect no match
 | 
						|
    Abxxc
 | 
						|
No match
 | 
						|
    ABxxc
 | 
						|
No match
 | 
						|
    abxxC      
 | 
						|
No match
 | 
						|
 | 
						|
/^(?(?=abc)\w{3}:|\d\d)$/
 | 
						|
    abc:
 | 
						|
 0: abc:
 | 
						|
    12
 | 
						|
 0: 12
 | 
						|
\= Expect no match
 | 
						|
    123
 | 
						|
No match
 | 
						|
    xyz    
 | 
						|
No match
 | 
						|
 | 
						|
/^(?(?!abc)\d\d|\w{3}:)$/
 | 
						|
    abc:
 | 
						|
 0: abc:
 | 
						|
    12
 | 
						|
 0: 12
 | 
						|
\= Expect no match
 | 
						|
    123
 | 
						|
No match
 | 
						|
    xyz    
 | 
						|
No match
 | 
						|
    
 | 
						|
/(?(?<=foo)bar|cat)/
 | 
						|
    foobar
 | 
						|
 0: bar
 | 
						|
    cat
 | 
						|
 0: cat
 | 
						|
    fcat
 | 
						|
 0: cat
 | 
						|
    focat   
 | 
						|
 0: cat
 | 
						|
\= Expect no match
 | 
						|
    foocat  
 | 
						|
No match
 | 
						|
 | 
						|
/(?(?<!foo)cat|bar)/
 | 
						|
    foobar
 | 
						|
 0: bar
 | 
						|
    cat
 | 
						|
 0: cat
 | 
						|
    fcat
 | 
						|
 0: cat
 | 
						|
    focat   
 | 
						|
 0: cat
 | 
						|
\= Expect no match
 | 
						|
    foocat  
 | 
						|
No match
 | 
						|
 | 
						|
/(?>a*)*/
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
 1: 
 | 
						|
    aa
 | 
						|
 0: aa
 | 
						|
 1: 
 | 
						|
    aaaa
 | 
						|
 0: aaaa
 | 
						|
 1: 
 | 
						|
    
 | 
						|
/(abc|)+/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
 1: 
 | 
						|
    abcabc
 | 
						|
 0: abcabc
 | 
						|
 1: abc
 | 
						|
 2: 
 | 
						|
    abcabcabc
 | 
						|
 0: abcabcabc
 | 
						|
 1: abcabc
 | 
						|
 2: abc
 | 
						|
 3: 
 | 
						|
    xyz      
 | 
						|
 0: 
 | 
						|
 | 
						|
/([a]*)*/
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
 1: 
 | 
						|
    aaaaa 
 | 
						|
 0: aaaaa
 | 
						|
 1: aaaa
 | 
						|
 2: aaa
 | 
						|
 3: aa
 | 
						|
 4: a
 | 
						|
 5: 
 | 
						|
 
 | 
						|
/([ab]*)*/
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
 1: 
 | 
						|
    b
 | 
						|
 0: b
 | 
						|
 1: 
 | 
						|
    ababab
 | 
						|
 0: ababab
 | 
						|
 1: ababa
 | 
						|
 2: abab
 | 
						|
 3: aba
 | 
						|
 4: ab
 | 
						|
 5: a
 | 
						|
 6: 
 | 
						|
    aaaabcde
 | 
						|
 0: aaaab
 | 
						|
 1: aaaa
 | 
						|
 2: aaa
 | 
						|
 3: aa
 | 
						|
 4: a
 | 
						|
 5: 
 | 
						|
    bbbb    
 | 
						|
 0: bbbb
 | 
						|
 1: bbb
 | 
						|
 2: bb
 | 
						|
 3: b
 | 
						|
 4: 
 | 
						|
 
 | 
						|
/([^a]*)*/
 | 
						|
    b
 | 
						|
 0: b
 | 
						|
 1: 
 | 
						|
    bbbb
 | 
						|
 0: bbbb
 | 
						|
 1: bbb
 | 
						|
 2: bb
 | 
						|
 3: b
 | 
						|
 4: 
 | 
						|
    aaa   
 | 
						|
 0: 
 | 
						|
 
 | 
						|
/([^ab]*)*/
 | 
						|
    cccc
 | 
						|
 0: cccc
 | 
						|
 1: ccc
 | 
						|
 2: cc
 | 
						|
 3: c
 | 
						|
 4: 
 | 
						|
    abab  
 | 
						|
 0: 
 | 
						|
 
 | 
						|
/([a]*?)*/
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
 1: 
 | 
						|
    aaaa 
 | 
						|
 0: aaaa
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
 3: a
 | 
						|
 4: 
 | 
						|
 
 | 
						|
/([ab]*?)*/
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
 1: 
 | 
						|
    b
 | 
						|
 0: b
 | 
						|
 1: 
 | 
						|
    abab
 | 
						|
 0: abab
 | 
						|
 1: aba
 | 
						|
 2: ab
 | 
						|
 3: a
 | 
						|
 4: 
 | 
						|
    baba   
 | 
						|
 0: baba
 | 
						|
 1: bab
 | 
						|
 2: ba
 | 
						|
 3: b
 | 
						|
 4: 
 | 
						|
 
 | 
						|
/([^a]*?)*/
 | 
						|
    b
 | 
						|
 0: b
 | 
						|
 1: 
 | 
						|
    bbbb
 | 
						|
 0: bbbb
 | 
						|
 1: bbb
 | 
						|
 2: bb
 | 
						|
 3: b
 | 
						|
 4: 
 | 
						|
    aaa   
 | 
						|
 0: 
 | 
						|
 
 | 
						|
/([^ab]*?)*/
 | 
						|
    c
 | 
						|
 0: c
 | 
						|
 1: 
 | 
						|
    cccc
 | 
						|
 0: cccc
 | 
						|
 1: ccc
 | 
						|
 2: cc
 | 
						|
 3: c
 | 
						|
 4: 
 | 
						|
    baba   
 | 
						|
 0: 
 | 
						|
 
 | 
						|
/(?>a*)*/
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
 1: 
 | 
						|
    aaabcde 
 | 
						|
 0: aaa
 | 
						|
 1: 
 | 
						|
 
 | 
						|
/((?>a*))*/
 | 
						|
    aaaaa
 | 
						|
 0: aaaaa
 | 
						|
 1: 
 | 
						|
    aabbaa 
 | 
						|
 0: aa
 | 
						|
 1: 
 | 
						|
 
 | 
						|
/((?>a*?))*/
 | 
						|
    aaaaa
 | 
						|
 0: aaaaa
 | 
						|
 1: 
 | 
						|
    aabbaa 
 | 
						|
 0: aa
 | 
						|
 1: 
 | 
						|
 | 
						|
/(?(?=[^a-z]+[a-z])  \d{2}-[a-z]{3}-\d{2}  |  \d{2}-\d{2}-\d{2} ) /x
 | 
						|
    12-sep-98
 | 
						|
 0: 12-sep-98
 | 
						|
    12-09-98
 | 
						|
 0: 12-09-98
 | 
						|
\= Expect no match
 | 
						|
    sep-12-98
 | 
						|
No match
 | 
						|
        
 | 
						|
/(?i:saturday|sunday)/
 | 
						|
    saturday
 | 
						|
 0: saturday
 | 
						|
    sunday
 | 
						|
 0: sunday
 | 
						|
    Saturday
 | 
						|
 0: Saturday
 | 
						|
    Sunday
 | 
						|
 0: Sunday
 | 
						|
    SATURDAY
 | 
						|
 0: SATURDAY
 | 
						|
    SUNDAY
 | 
						|
 0: SUNDAY
 | 
						|
    SunDay
 | 
						|
 0: SunDay
 | 
						|
    
 | 
						|
/(a(?i)bc|BB)x/
 | 
						|
    abcx
 | 
						|
 0: abcx
 | 
						|
    aBCx
 | 
						|
 0: aBCx
 | 
						|
    bbx
 | 
						|
 0: bbx
 | 
						|
    BBx
 | 
						|
 0: BBx
 | 
						|
\= Expect no match
 | 
						|
    abcX
 | 
						|
No match
 | 
						|
    aBCX
 | 
						|
No match
 | 
						|
    bbX
 | 
						|
No match
 | 
						|
    BBX               
 | 
						|
No match
 | 
						|
 | 
						|
/^([ab](?i)[cd]|[ef])/
 | 
						|
    ac
 | 
						|
 0: ac
 | 
						|
    aC
 | 
						|
 0: aC
 | 
						|
    bD
 | 
						|
 0: bD
 | 
						|
    elephant
 | 
						|
 0: e
 | 
						|
    Europe 
 | 
						|
 0: E
 | 
						|
    frog
 | 
						|
 0: f
 | 
						|
    France
 | 
						|
 0: F
 | 
						|
\= Expect no match
 | 
						|
    Africa     
 | 
						|
No match
 | 
						|
 | 
						|
/^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)/
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
    aBd
 | 
						|
 0: aBd
 | 
						|
    xy
 | 
						|
 0: xy
 | 
						|
    xY
 | 
						|
 0: xY
 | 
						|
    zebra
 | 
						|
 0: z
 | 
						|
    Zambesi
 | 
						|
 0: Z
 | 
						|
\= Expect no match
 | 
						|
    aCD  
 | 
						|
No match
 | 
						|
    XY  
 | 
						|
No match
 | 
						|
 | 
						|
/(?<=foo\n)^bar/m
 | 
						|
    foo\nbar
 | 
						|
 0: bar
 | 
						|
\= Expect no match
 | 
						|
    bar
 | 
						|
No match
 | 
						|
    baz\nbar   
 | 
						|
No match
 | 
						|
 | 
						|
/(?<=(?<!foo)bar)baz/
 | 
						|
    barbaz
 | 
						|
 0: baz
 | 
						|
    barbarbaz 
 | 
						|
 0: baz
 | 
						|
    koobarbaz 
 | 
						|
 0: baz
 | 
						|
\= Expect no match
 | 
						|
    baz
 | 
						|
No match
 | 
						|
    foobarbaz 
 | 
						|
No match
 | 
						|
 | 
						|
# The following tests are taken from the Perl 5.005 test suite; some of them
 | 
						|
# are compatible with 5.004, but I'd rather not have to sort them out.
 | 
						|
 | 
						|
/abc/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    xabcy
 | 
						|
 0: abc
 | 
						|
    ababc
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    xbc
 | 
						|
No match
 | 
						|
    axc
 | 
						|
No match
 | 
						|
    abx
 | 
						|
No match
 | 
						|
 | 
						|
/ab*c/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
 | 
						|
/ab*bc/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    abbc
 | 
						|
 0: abbc
 | 
						|
    abbbbc
 | 
						|
 0: abbbbc
 | 
						|
 | 
						|
/.{1}/
 | 
						|
    abbbbc
 | 
						|
 0: a
 | 
						|
 | 
						|
/.{3,4}/
 | 
						|
    abbbbc
 | 
						|
 0: abbb
 | 
						|
 | 
						|
/ab{0,}bc/
 | 
						|
    abbbbc
 | 
						|
 0: abbbbc
 | 
						|
 | 
						|
/ab+bc/
 | 
						|
    abbc
 | 
						|
 0: abbc
 | 
						|
\= Expect no match
 | 
						|
    abc
 | 
						|
No match
 | 
						|
    abq
 | 
						|
No match
 | 
						|
 | 
						|
/ab+bc/
 | 
						|
    abbbbc
 | 
						|
 0: abbbbc
 | 
						|
 | 
						|
/ab{1,}bc/
 | 
						|
    abbbbc
 | 
						|
 0: abbbbc
 | 
						|
 | 
						|
/ab{1,3}bc/
 | 
						|
    abbbbc
 | 
						|
 0: abbbbc
 | 
						|
 | 
						|
/ab{3,4}bc/
 | 
						|
    abbbbc
 | 
						|
 0: abbbbc
 | 
						|
 | 
						|
/ab{4,5}bc/
 | 
						|
\= Expect no match
 | 
						|
    abq
 | 
						|
No match
 | 
						|
    abbbbc
 | 
						|
No match
 | 
						|
 | 
						|
/ab?bc/
 | 
						|
    abbc
 | 
						|
 0: abbc
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
 | 
						|
/ab{0,1}bc/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
 | 
						|
/ab?bc/
 | 
						|
 | 
						|
/ab?c/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
 | 
						|
/ab{0,1}c/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
 | 
						|
/^abc$/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    abbbbc
 | 
						|
No match
 | 
						|
    abcc
 | 
						|
No match
 | 
						|
 | 
						|
/^abc/
 | 
						|
    abcc
 | 
						|
 0: abc
 | 
						|
 | 
						|
/^abc$/
 | 
						|
 | 
						|
/abc$/
 | 
						|
    aabc
 | 
						|
 0: abc
 | 
						|
    aabc
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    aabcd
 | 
						|
No match
 | 
						|
 | 
						|
/^/
 | 
						|
    abc
 | 
						|
 0: 
 | 
						|
 | 
						|
/$/
 | 
						|
    abc
 | 
						|
 0: 
 | 
						|
 | 
						|
/a.c/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    axc
 | 
						|
 0: axc
 | 
						|
 | 
						|
/a.*c/
 | 
						|
    axyzc
 | 
						|
 0: axyzc
 | 
						|
 | 
						|
/a[bc]d/
 | 
						|
    abd
 | 
						|
 0: abd
 | 
						|
\= Expect no match
 | 
						|
    axyzd
 | 
						|
No match
 | 
						|
    abc
 | 
						|
No match
 | 
						|
 | 
						|
/a[b-d]e/
 | 
						|
    ace
 | 
						|
 0: ace
 | 
						|
 | 
						|
/a[b-d]/
 | 
						|
    aac
 | 
						|
 0: ac
 | 
						|
 | 
						|
/a[-b]/
 | 
						|
    a-
 | 
						|
 0: a-
 | 
						|
 | 
						|
/a[b-]/
 | 
						|
    a-
 | 
						|
 0: a-
 | 
						|
 | 
						|
/a]/
 | 
						|
    a]
 | 
						|
 0: a]
 | 
						|
 | 
						|
/a[]]b/
 | 
						|
    a]b
 | 
						|
 0: a]b
 | 
						|
 | 
						|
/a[^bc]d/
 | 
						|
    aed
 | 
						|
 0: aed
 | 
						|
\= Expect no match
 | 
						|
    abd
 | 
						|
No match
 | 
						|
    abd
 | 
						|
No match
 | 
						|
 | 
						|
/a[^-b]c/
 | 
						|
    adc
 | 
						|
 0: adc
 | 
						|
 | 
						|
/a[^]b]c/
 | 
						|
    adc
 | 
						|
 0: adc
 | 
						|
    a-c
 | 
						|
 0: a-c
 | 
						|
\= Expect no match
 | 
						|
    a]c
 | 
						|
No match
 | 
						|
 | 
						|
/\ba\b/
 | 
						|
    a-
 | 
						|
 0: a
 | 
						|
    -a
 | 
						|
 0: a
 | 
						|
    -a-
 | 
						|
 0: a
 | 
						|
 | 
						|
/\by\b/
 | 
						|
\= Expect no match
 | 
						|
    xy
 | 
						|
No match
 | 
						|
    yz
 | 
						|
No match
 | 
						|
    xyz
 | 
						|
No match
 | 
						|
 | 
						|
/\Ba\B/
 | 
						|
\= Expect no match
 | 
						|
    a-
 | 
						|
No match
 | 
						|
    -a
 | 
						|
No match
 | 
						|
    -a-
 | 
						|
No match
 | 
						|
 | 
						|
/\By\b/
 | 
						|
    xy
 | 
						|
 0: y
 | 
						|
 | 
						|
/\by\B/
 | 
						|
    yz
 | 
						|
 0: y
 | 
						|
 | 
						|
/\By\B/
 | 
						|
    xyz
 | 
						|
 0: y
 | 
						|
 | 
						|
/\w/
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
 | 
						|
/\W/
 | 
						|
    -
 | 
						|
 0: -
 | 
						|
\= Expect no match
 | 
						|
    a
 | 
						|
No match
 | 
						|
 | 
						|
/a\sb/
 | 
						|
    a b
 | 
						|
 0: a b
 | 
						|
 | 
						|
/a\Sb/
 | 
						|
    a-b
 | 
						|
 0: a-b
 | 
						|
\= Expect no match
 | 
						|
    a b
 | 
						|
No match
 | 
						|
 | 
						|
/\d/
 | 
						|
    1
 | 
						|
 0: 1
 | 
						|
 | 
						|
/\D/
 | 
						|
    -
 | 
						|
 0: -
 | 
						|
\= Expect no match
 | 
						|
    1
 | 
						|
No match
 | 
						|
 | 
						|
/[\w]/
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
 | 
						|
/[\W]/
 | 
						|
    -
 | 
						|
 0: -
 | 
						|
\= Expect no match
 | 
						|
    a
 | 
						|
No match
 | 
						|
 | 
						|
/a[\s]b/
 | 
						|
    a b
 | 
						|
 0: a b
 | 
						|
 | 
						|
/a[\S]b/
 | 
						|
    a-b
 | 
						|
 0: a-b
 | 
						|
\= Expect no match
 | 
						|
    a b
 | 
						|
No match
 | 
						|
 | 
						|
/[\d]/
 | 
						|
    1
 | 
						|
 0: 1
 | 
						|
 | 
						|
/[\D]/
 | 
						|
    -
 | 
						|
 0: -
 | 
						|
\= Expect no match
 | 
						|
    1
 | 
						|
No match
 | 
						|
 | 
						|
/ab|cd/
 | 
						|
    abc
 | 
						|
 0: ab
 | 
						|
    abcd
 | 
						|
 0: ab
 | 
						|
 | 
						|
/()ef/
 | 
						|
    def
 | 
						|
 0: ef
 | 
						|
 | 
						|
/$b/
 | 
						|
 | 
						|
/a\(b/
 | 
						|
    a(b
 | 
						|
 0: a(b
 | 
						|
 | 
						|
/a\(*b/
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
    a((b
 | 
						|
 0: a((b
 | 
						|
 | 
						|
/a\\b/
 | 
						|
    a\\b
 | 
						|
 0: a\b
 | 
						|
\= Expect no match
 | 
						|
    a\b
 | 
						|
No match
 | 
						|
 | 
						|
/((a))/
 | 
						|
    abc
 | 
						|
 0: a
 | 
						|
 | 
						|
/(a)b(c)/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
 | 
						|
/a+b+c/
 | 
						|
    aabbabc
 | 
						|
 0: abc
 | 
						|
 | 
						|
/a{1,}b{1,}c/
 | 
						|
    aabbabc
 | 
						|
 0: abc
 | 
						|
 | 
						|
/a.+?c/
 | 
						|
    abcabc
 | 
						|
 0: abcabc
 | 
						|
 1: abc
 | 
						|
 | 
						|
/(a+|b)*/
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 1: a
 | 
						|
 2: 
 | 
						|
 | 
						|
/(a+|b){0,}/
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 1: a
 | 
						|
 2: 
 | 
						|
 | 
						|
/(a+|b)+/
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 1: a
 | 
						|
 | 
						|
/(a+|b){1,}/
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 1: a
 | 
						|
 | 
						|
/(a+|b)?/
 | 
						|
    ab
 | 
						|
 0: a
 | 
						|
 1: 
 | 
						|
 | 
						|
/(a+|b){0,1}/
 | 
						|
    ab
 | 
						|
 0: a
 | 
						|
 1: 
 | 
						|
 | 
						|
/[^ab]*/
 | 
						|
    cde
 | 
						|
 0: cde
 | 
						|
 | 
						|
/abc/
 | 
						|
\= Expect no match
 | 
						|
    b
 | 
						|
No match
 | 
						|
 | 
						|
/a*/
 | 
						|
 | 
						|
/([abc])*d/
 | 
						|
    abbbcd
 | 
						|
 0: abbbcd
 | 
						|
 | 
						|
/([abc])*bcd/
 | 
						|
    abcd
 | 
						|
 0: abcd
 | 
						|
 | 
						|
/a|b|c|d|e/
 | 
						|
    e
 | 
						|
 0: e
 | 
						|
 | 
						|
/(a|b|c|d|e)f/
 | 
						|
    ef
 | 
						|
 0: ef
 | 
						|
 | 
						|
/abcd*efg/
 | 
						|
    abcdefg
 | 
						|
 0: abcdefg
 | 
						|
 | 
						|
/ab*/
 | 
						|
    xabyabbbz
 | 
						|
 0: ab
 | 
						|
    xayabbbz
 | 
						|
 0: a
 | 
						|
 | 
						|
/(ab|cd)e/
 | 
						|
    abcde
 | 
						|
 0: cde
 | 
						|
 | 
						|
/[abhgefdc]ij/
 | 
						|
    hij
 | 
						|
 0: hij
 | 
						|
 | 
						|
/^(ab|cd)e/
 | 
						|
 | 
						|
/(abc|)ef/
 | 
						|
    abcdef
 | 
						|
 0: ef
 | 
						|
 | 
						|
/(a|b)c*d/
 | 
						|
    abcd
 | 
						|
 0: bcd
 | 
						|
 | 
						|
/(ab|ab*)bc/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
 | 
						|
/a([bc]*)c*/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
 1: a
 | 
						|
 | 
						|
/a([bc]*)(c*d)/
 | 
						|
    abcd
 | 
						|
 0: abcd
 | 
						|
 | 
						|
/a([bc]+)(c*d)/
 | 
						|
    abcd
 | 
						|
 0: abcd
 | 
						|
 | 
						|
/a([bc]*)(c+d)/
 | 
						|
    abcd
 | 
						|
 0: abcd
 | 
						|
 | 
						|
/a[bcd]*dcdcde/
 | 
						|
    adcdcde
 | 
						|
 0: adcdcde
 | 
						|
 | 
						|
/a[bcd]+dcdcde/
 | 
						|
\= Expect no match
 | 
						|
    abcde
 | 
						|
No match
 | 
						|
    adcdcde
 | 
						|
No match
 | 
						|
 | 
						|
/(ab|a)b*c/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
 | 
						|
/((a)(b)c)(d)/
 | 
						|
    abcd
 | 
						|
 0: abcd
 | 
						|
 | 
						|
/[a-zA-Z_][a-zA-Z0-9_]*/
 | 
						|
    alpha
 | 
						|
 0: alpha
 | 
						|
 | 
						|
/^a(bc+|b[eh])g|.h$/
 | 
						|
    abh
 | 
						|
 0: bh
 | 
						|
 | 
						|
/(bc+d$|ef*g.|h?i(j|k))/
 | 
						|
    effgz
 | 
						|
 0: effgz
 | 
						|
    ij
 | 
						|
 0: ij
 | 
						|
    reffgz
 | 
						|
 0: effgz
 | 
						|
\= Expect no match
 | 
						|
    effg
 | 
						|
No match
 | 
						|
    bcdd
 | 
						|
No match
 | 
						|
 | 
						|
/((((((((((a))))))))))/
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
 | 
						|
/(((((((((a)))))))))/
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
 | 
						|
/multiple words of text/
 | 
						|
\= Expect no match
 | 
						|
    aa
 | 
						|
No match
 | 
						|
    uh-uh
 | 
						|
No match
 | 
						|
 | 
						|
/multiple words/
 | 
						|
    multiple words, yeah
 | 
						|
 0: multiple words
 | 
						|
 | 
						|
/(.*)c(.*)/
 | 
						|
    abcde
 | 
						|
 0: abcde
 | 
						|
 | 
						|
/\((.*), (.*)\)/
 | 
						|
    (a, b)
 | 
						|
 0: (a, b)
 | 
						|
 | 
						|
/[k]/
 | 
						|
 | 
						|
/abcd/
 | 
						|
    abcd
 | 
						|
 0: abcd
 | 
						|
 | 
						|
/a(bc)d/
 | 
						|
    abcd
 | 
						|
 0: abcd
 | 
						|
 | 
						|
/a[-]?c/
 | 
						|
    ac
 | 
						|
 0: ac
 | 
						|
 | 
						|
/abc/i
 | 
						|
    ABC
 | 
						|
 0: ABC
 | 
						|
    XABCY
 | 
						|
 0: ABC
 | 
						|
    ABABC
 | 
						|
 0: ABC
 | 
						|
\= Expect no match
 | 
						|
    aaxabxbaxbbx
 | 
						|
No match
 | 
						|
    XBC
 | 
						|
No match
 | 
						|
    AXC
 | 
						|
No match
 | 
						|
    ABX
 | 
						|
No match
 | 
						|
 | 
						|
/ab*c/i
 | 
						|
    ABC
 | 
						|
 0: ABC
 | 
						|
 | 
						|
/ab*bc/i
 | 
						|
    ABC
 | 
						|
 0: ABC
 | 
						|
    ABBC
 | 
						|
 0: ABBC
 | 
						|
 | 
						|
/ab*?bc/i
 | 
						|
    ABBBBC
 | 
						|
 0: ABBBBC
 | 
						|
 | 
						|
/ab{0,}?bc/i
 | 
						|
    ABBBBC
 | 
						|
 0: ABBBBC
 | 
						|
 | 
						|
/ab+?bc/i
 | 
						|
    ABBC
 | 
						|
 0: ABBC
 | 
						|
 | 
						|
/ab+bc/i
 | 
						|
\= Expect no match
 | 
						|
    ABC
 | 
						|
No match
 | 
						|
    ABQ
 | 
						|
No match
 | 
						|
 | 
						|
/ab{1,}bc/i
 | 
						|
 | 
						|
/ab+bc/i
 | 
						|
    ABBBBC
 | 
						|
 0: ABBBBC
 | 
						|
 | 
						|
/ab{1,}?bc/i
 | 
						|
    ABBBBC
 | 
						|
 0: ABBBBC
 | 
						|
 | 
						|
/ab{1,3}?bc/i
 | 
						|
    ABBBBC
 | 
						|
 0: ABBBBC
 | 
						|
 | 
						|
/ab{3,4}?bc/i
 | 
						|
    ABBBBC
 | 
						|
 0: ABBBBC
 | 
						|
 | 
						|
/ab{4,5}?bc/i
 | 
						|
\= Expect no match
 | 
						|
    ABQ
 | 
						|
No match
 | 
						|
    ABBBBC
 | 
						|
No match
 | 
						|
 | 
						|
/ab??bc/i
 | 
						|
    ABBC
 | 
						|
 0: ABBC
 | 
						|
    ABC
 | 
						|
 0: ABC
 | 
						|
 | 
						|
/ab{0,1}?bc/i
 | 
						|
    ABC
 | 
						|
 0: ABC
 | 
						|
 | 
						|
/ab??bc/i
 | 
						|
 | 
						|
/ab??c/i
 | 
						|
    ABC
 | 
						|
 0: ABC
 | 
						|
 | 
						|
/ab{0,1}?c/i
 | 
						|
    ABC
 | 
						|
 0: ABC
 | 
						|
 | 
						|
/^abc$/i
 | 
						|
    ABC
 | 
						|
 0: ABC
 | 
						|
\= Expect no match
 | 
						|
    ABBBBC
 | 
						|
No match
 | 
						|
    ABCC
 | 
						|
No match
 | 
						|
 | 
						|
/^abc/i
 | 
						|
    ABCC
 | 
						|
 0: ABC
 | 
						|
 | 
						|
/^abc$/i
 | 
						|
 | 
						|
/abc$/i
 | 
						|
    AABC
 | 
						|
 0: ABC
 | 
						|
 | 
						|
/^/i
 | 
						|
    ABC
 | 
						|
 0: 
 | 
						|
 | 
						|
/$/i
 | 
						|
    ABC
 | 
						|
 0: 
 | 
						|
 | 
						|
/a.c/i
 | 
						|
    ABC
 | 
						|
 0: ABC
 | 
						|
    AXC
 | 
						|
 0: AXC
 | 
						|
 | 
						|
/a.*?c/i
 | 
						|
    AXYZC
 | 
						|
 0: AXYZC
 | 
						|
 | 
						|
/a.*c/i
 | 
						|
    AABC
 | 
						|
 0: AABC
 | 
						|
\= Expect no match
 | 
						|
    AXYZD
 | 
						|
No match
 | 
						|
 | 
						|
/a[bc]d/i
 | 
						|
    ABD
 | 
						|
 0: ABD
 | 
						|
 | 
						|
/a[b-d]e/i
 | 
						|
    ACE
 | 
						|
 0: ACE
 | 
						|
\= Expect no match
 | 
						|
    ABC
 | 
						|
No match
 | 
						|
    ABD
 | 
						|
No match
 | 
						|
 | 
						|
/a[b-d]/i
 | 
						|
    AAC
 | 
						|
 0: AC
 | 
						|
 | 
						|
/a[-b]/i
 | 
						|
    A-
 | 
						|
 0: A-
 | 
						|
 | 
						|
/a[b-]/i
 | 
						|
    A-
 | 
						|
 0: A-
 | 
						|
 | 
						|
/a]/i
 | 
						|
    A]
 | 
						|
 0: A]
 | 
						|
 | 
						|
/a[]]b/i
 | 
						|
    A]B
 | 
						|
 0: A]B
 | 
						|
 | 
						|
/a[^bc]d/i
 | 
						|
    AED
 | 
						|
 0: AED
 | 
						|
 | 
						|
/a[^-b]c/i
 | 
						|
    ADC
 | 
						|
 0: ADC
 | 
						|
\= Expect no match
 | 
						|
    ABD
 | 
						|
No match
 | 
						|
    A-C
 | 
						|
No match
 | 
						|
 | 
						|
/a[^]b]c/i
 | 
						|
    ADC
 | 
						|
 0: ADC
 | 
						|
 | 
						|
/ab|cd/i
 | 
						|
    ABC
 | 
						|
 0: AB
 | 
						|
    ABCD
 | 
						|
 0: AB
 | 
						|
 | 
						|
/()ef/i
 | 
						|
    DEF
 | 
						|
 0: EF
 | 
						|
 | 
						|
/$b/i
 | 
						|
\= Expect no match
 | 
						|
    A]C
 | 
						|
No match
 | 
						|
    B
 | 
						|
No match
 | 
						|
 | 
						|
/a\(b/i
 | 
						|
    A(B
 | 
						|
 0: A(B
 | 
						|
 | 
						|
/a\(*b/i
 | 
						|
    AB
 | 
						|
 0: AB
 | 
						|
    A((B
 | 
						|
 0: A((B
 | 
						|
 | 
						|
/a\\b/i
 | 
						|
\= Expect no match
 | 
						|
    A\=notbol
 | 
						|
No match
 | 
						|
 | 
						|
/((a))/i
 | 
						|
    ABC
 | 
						|
 0: A
 | 
						|
 | 
						|
/(a)b(c)/i
 | 
						|
    ABC
 | 
						|
 0: ABC
 | 
						|
 | 
						|
/a+b+c/i
 | 
						|
    AABBABC
 | 
						|
 0: ABC
 | 
						|
 | 
						|
/a{1,}b{1,}c/i
 | 
						|
    AABBABC
 | 
						|
 0: ABC
 | 
						|
 | 
						|
/a.+?c/i
 | 
						|
    ABCABC
 | 
						|
 0: ABCABC
 | 
						|
 1: ABC
 | 
						|
 | 
						|
/a.*?c/i
 | 
						|
    ABCABC
 | 
						|
 0: ABCABC
 | 
						|
 1: ABC
 | 
						|
 | 
						|
/a.{0,5}?c/i
 | 
						|
    ABCABC
 | 
						|
 0: ABCABC
 | 
						|
 1: ABC
 | 
						|
 | 
						|
/(a+|b)*/i
 | 
						|
    AB
 | 
						|
 0: AB
 | 
						|
 1: A
 | 
						|
 2: 
 | 
						|
 | 
						|
/(a+|b){0,}/i
 | 
						|
    AB
 | 
						|
 0: AB
 | 
						|
 1: A
 | 
						|
 2: 
 | 
						|
 | 
						|
/(a+|b)+/i
 | 
						|
    AB
 | 
						|
 0: AB
 | 
						|
 1: A
 | 
						|
 | 
						|
/(a+|b){1,}/i
 | 
						|
    AB
 | 
						|
 0: AB
 | 
						|
 1: A
 | 
						|
 | 
						|
/(a+|b)?/i
 | 
						|
    AB
 | 
						|
 0: A
 | 
						|
 1: 
 | 
						|
 | 
						|
/(a+|b){0,1}/i
 | 
						|
    AB
 | 
						|
 0: A
 | 
						|
 1: 
 | 
						|
 | 
						|
/(a+|b){0,1}?/i
 | 
						|
    AB
 | 
						|
 0: A
 | 
						|
 1: 
 | 
						|
 | 
						|
/[^ab]*/i
 | 
						|
    CDE
 | 
						|
 0: CDE
 | 
						|
 | 
						|
/abc/i
 | 
						|
 | 
						|
/a*/i
 | 
						|
 | 
						|
/([abc])*d/i
 | 
						|
    ABBBCD
 | 
						|
 0: ABBBCD
 | 
						|
 | 
						|
/([abc])*bcd/i
 | 
						|
    ABCD
 | 
						|
 0: ABCD
 | 
						|
 | 
						|
/a|b|c|d|e/i
 | 
						|
    E
 | 
						|
 0: E
 | 
						|
 | 
						|
/(a|b|c|d|e)f/i
 | 
						|
    EF
 | 
						|
 0: EF
 | 
						|
 | 
						|
/abcd*efg/i
 | 
						|
    ABCDEFG
 | 
						|
 0: ABCDEFG
 | 
						|
 | 
						|
/ab*/i
 | 
						|
    XABYABBBZ
 | 
						|
 0: AB
 | 
						|
    XAYABBBZ
 | 
						|
 0: A
 | 
						|
 | 
						|
/(ab|cd)e/i
 | 
						|
    ABCDE
 | 
						|
 0: CDE
 | 
						|
 | 
						|
/[abhgefdc]ij/i
 | 
						|
    HIJ
 | 
						|
 0: HIJ
 | 
						|
 | 
						|
/^(ab|cd)e/i
 | 
						|
\= Expect no match
 | 
						|
    ABCDE
 | 
						|
No match
 | 
						|
 | 
						|
/(abc|)ef/i
 | 
						|
    ABCDEF
 | 
						|
 0: EF
 | 
						|
 | 
						|
/(a|b)c*d/i
 | 
						|
    ABCD
 | 
						|
 0: BCD
 | 
						|
 | 
						|
/(ab|ab*)bc/i
 | 
						|
    ABC
 | 
						|
 0: ABC
 | 
						|
 | 
						|
/a([bc]*)c*/i
 | 
						|
    ABC
 | 
						|
 0: ABC
 | 
						|
 1: A
 | 
						|
 | 
						|
/a([bc]*)(c*d)/i
 | 
						|
    ABCD
 | 
						|
 0: ABCD
 | 
						|
 | 
						|
/a([bc]+)(c*d)/i
 | 
						|
    ABCD
 | 
						|
 0: ABCD
 | 
						|
 | 
						|
/a([bc]*)(c+d)/i
 | 
						|
    ABCD
 | 
						|
 0: ABCD
 | 
						|
 | 
						|
/a[bcd]*dcdcde/i
 | 
						|
    ADCDCDE
 | 
						|
 0: ADCDCDE
 | 
						|
 | 
						|
/a[bcd]+dcdcde/i
 | 
						|
 | 
						|
/(ab|a)b*c/i
 | 
						|
    ABC
 | 
						|
 0: ABC
 | 
						|
 | 
						|
/((a)(b)c)(d)/i
 | 
						|
    ABCD
 | 
						|
 0: ABCD
 | 
						|
 | 
						|
/[a-zA-Z_][a-zA-Z0-9_]*/i
 | 
						|
    ALPHA
 | 
						|
 0: ALPHA
 | 
						|
 | 
						|
/^a(bc+|b[eh])g|.h$/i
 | 
						|
    ABH
 | 
						|
 0: BH
 | 
						|
 | 
						|
/(bc+d$|ef*g.|h?i(j|k))/i
 | 
						|
    EFFGZ
 | 
						|
 0: EFFGZ
 | 
						|
    IJ
 | 
						|
 0: IJ
 | 
						|
    REFFGZ
 | 
						|
 0: EFFGZ
 | 
						|
\= Expect no match
 | 
						|
    ADCDCDE
 | 
						|
No match
 | 
						|
    EFFG
 | 
						|
No match
 | 
						|
    BCDD
 | 
						|
No match
 | 
						|
 | 
						|
/((((((((((a))))))))))/i
 | 
						|
    A
 | 
						|
 0: A
 | 
						|
 | 
						|
/(((((((((a)))))))))/i
 | 
						|
    A
 | 
						|
 0: A
 | 
						|
 | 
						|
/(?:(?:(?:(?:(?:(?:(?:(?:(?:(a))))))))))/i
 | 
						|
    A
 | 
						|
 0: A
 | 
						|
 | 
						|
/(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))/i
 | 
						|
    C
 | 
						|
 0: C
 | 
						|
 | 
						|
/multiple words of text/i
 | 
						|
\= Expect no match
 | 
						|
    AA
 | 
						|
No match
 | 
						|
    UH-UH
 | 
						|
No match
 | 
						|
 | 
						|
/multiple words/i
 | 
						|
    MULTIPLE WORDS, YEAH
 | 
						|
 0: MULTIPLE WORDS
 | 
						|
 | 
						|
/(.*)c(.*)/i
 | 
						|
    ABCDE
 | 
						|
 0: ABCDE
 | 
						|
 | 
						|
/\((.*), (.*)\)/i
 | 
						|
    (A, B)
 | 
						|
 0: (A, B)
 | 
						|
 | 
						|
/[k]/i
 | 
						|
 | 
						|
/abcd/i
 | 
						|
    ABCD
 | 
						|
 0: ABCD
 | 
						|
 | 
						|
/a(bc)d/i
 | 
						|
    ABCD
 | 
						|
 0: ABCD
 | 
						|
 | 
						|
/a[-]?c/i
 | 
						|
    AC
 | 
						|
 0: AC
 | 
						|
 | 
						|
/a(?!b)./
 | 
						|
    abad
 | 
						|
 0: ad
 | 
						|
 | 
						|
/a(?=d)./
 | 
						|
    abad
 | 
						|
 0: ad
 | 
						|
 | 
						|
/a(?=c|d)./
 | 
						|
    abad
 | 
						|
 0: ad
 | 
						|
 | 
						|
/a(?:b|c|d)(.)/
 | 
						|
    ace
 | 
						|
 0: ace
 | 
						|
 | 
						|
/a(?:b|c|d)*(.)/
 | 
						|
    ace
 | 
						|
 0: ace
 | 
						|
 1: ac
 | 
						|
 | 
						|
/a(?:b|c|d)+?(.)/
 | 
						|
    ace
 | 
						|
 0: ace
 | 
						|
    acdbcdbe
 | 
						|
 0: acdbcdbe
 | 
						|
 1: acdbcdb
 | 
						|
 2: acdbcd
 | 
						|
 3: acdbc
 | 
						|
 4: acdb
 | 
						|
 5: acd
 | 
						|
 | 
						|
/a(?:b|c|d)+(.)/
 | 
						|
    acdbcdbe
 | 
						|
 0: acdbcdbe
 | 
						|
 1: acdbcdb
 | 
						|
 2: acdbcd
 | 
						|
 3: acdbc
 | 
						|
 4: acdb
 | 
						|
 5: acd
 | 
						|
 | 
						|
/a(?:b|c|d){2}(.)/
 | 
						|
    acdbcdbe
 | 
						|
 0: acdb
 | 
						|
 | 
						|
/a(?:b|c|d){4,5}(.)/
 | 
						|
    acdbcdbe
 | 
						|
 0: acdbcdb
 | 
						|
 1: acdbcd
 | 
						|
 | 
						|
/a(?:b|c|d){4,5}?(.)/
 | 
						|
    acdbcdbe
 | 
						|
 0: acdbcdb
 | 
						|
 1: acdbcd
 | 
						|
 | 
						|
/((foo)|(bar))*/
 | 
						|
    foobar
 | 
						|
 0: foobar
 | 
						|
 1: foo
 | 
						|
 2: 
 | 
						|
 | 
						|
/a(?:b|c|d){6,7}(.)/
 | 
						|
    acdbcdbe
 | 
						|
 0: acdbcdbe
 | 
						|
 | 
						|
/a(?:b|c|d){6,7}?(.)/
 | 
						|
    acdbcdbe
 | 
						|
 0: acdbcdbe
 | 
						|
 | 
						|
/a(?:b|c|d){5,6}(.)/
 | 
						|
    acdbcdbe
 | 
						|
 0: acdbcdbe
 | 
						|
 1: acdbcdb
 | 
						|
 | 
						|
/a(?:b|c|d){5,6}?(.)/
 | 
						|
    acdbcdbe
 | 
						|
 0: acdbcdbe
 | 
						|
 1: acdbcdb
 | 
						|
 | 
						|
/a(?:b|c|d){5,7}(.)/
 | 
						|
    acdbcdbe
 | 
						|
 0: acdbcdbe
 | 
						|
 1: acdbcdb
 | 
						|
 | 
						|
/a(?:b|c|d){5,7}?(.)/
 | 
						|
    acdbcdbe
 | 
						|
 0: acdbcdbe
 | 
						|
 1: acdbcdb
 | 
						|
 | 
						|
/a(?:b|(c|e){1,2}?|d)+?(.)/
 | 
						|
    ace
 | 
						|
 0: ace
 | 
						|
 | 
						|
/^(.+)?B/
 | 
						|
    AB
 | 
						|
 0: AB
 | 
						|
 | 
						|
/^([^a-z])|(\^)$/
 | 
						|
    .
 | 
						|
 0: .
 | 
						|
 | 
						|
/^[<>]&/
 | 
						|
    <&OUT
 | 
						|
 0: <&
 | 
						|
 | 
						|
/(?:(f)(o)(o)|(b)(a)(r))*/
 | 
						|
    foobar
 | 
						|
 0: foobar
 | 
						|
 1: foo
 | 
						|
 2: 
 | 
						|
 | 
						|
/(?<=a)b/
 | 
						|
    ab
 | 
						|
 0: b
 | 
						|
\= Expect no match
 | 
						|
    cb
 | 
						|
No match
 | 
						|
    b
 | 
						|
No match
 | 
						|
 | 
						|
/(?<!c)b/
 | 
						|
    ab
 | 
						|
 0: b
 | 
						|
    b
 | 
						|
 0: b
 | 
						|
    b
 | 
						|
 0: b
 | 
						|
 | 
						|
/(?:..)*a/
 | 
						|
    aba
 | 
						|
 0: aba
 | 
						|
 1: a
 | 
						|
 | 
						|
/(?:..)*?a/
 | 
						|
    aba
 | 
						|
 0: aba
 | 
						|
 1: a
 | 
						|
 | 
						|
/^(){3,5}/
 | 
						|
    abc
 | 
						|
 0: 
 | 
						|
 | 
						|
/^(a+)*ax/
 | 
						|
    aax
 | 
						|
 0: aax
 | 
						|
 | 
						|
/^((a|b)+)*ax/
 | 
						|
    aax
 | 
						|
 0: aax
 | 
						|
 | 
						|
/^((a|bc)+)*ax/
 | 
						|
    aax
 | 
						|
 0: aax
 | 
						|
 | 
						|
/(a|x)*ab/
 | 
						|
    cab
 | 
						|
 0: ab
 | 
						|
 | 
						|
/(a)*ab/
 | 
						|
    cab
 | 
						|
 0: ab
 | 
						|
 | 
						|
/(?:(?i)a)b/
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 | 
						|
/((?i)a)b/
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 | 
						|
/(?:(?i)a)b/
 | 
						|
    Ab
 | 
						|
 0: Ab
 | 
						|
 | 
						|
/((?i)a)b/
 | 
						|
    Ab
 | 
						|
 0: Ab
 | 
						|
 | 
						|
/(?:(?i)a)b/
 | 
						|
\= Expect no match
 | 
						|
    cb
 | 
						|
No match
 | 
						|
    aB
 | 
						|
No match
 | 
						|
 | 
						|
/((?i)a)b/
 | 
						|
 | 
						|
/(?i:a)b/
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 | 
						|
/((?i:a))b/
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 | 
						|
/(?i:a)b/
 | 
						|
    Ab
 | 
						|
 0: Ab
 | 
						|
 | 
						|
/((?i:a))b/
 | 
						|
    Ab
 | 
						|
 0: Ab
 | 
						|
 | 
						|
/(?i:a)b/
 | 
						|
\= Expect no match
 | 
						|
    aB
 | 
						|
No match
 | 
						|
    aB
 | 
						|
No match
 | 
						|
 | 
						|
/((?i:a))b/
 | 
						|
 | 
						|
/(?:(?-i)a)b/i
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 | 
						|
/((?-i)a)b/i
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 | 
						|
/(?:(?-i)a)b/i
 | 
						|
    aB
 | 
						|
 0: aB
 | 
						|
 | 
						|
/((?-i)a)b/i
 | 
						|
    aB
 | 
						|
 0: aB
 | 
						|
 | 
						|
/(?:(?-i)a)b/i
 | 
						|
    aB
 | 
						|
 0: aB
 | 
						|
\= Expect no match
 | 
						|
    Ab
 | 
						|
No match
 | 
						|
 | 
						|
/((?-i)a)b/i
 | 
						|
 | 
						|
/(?:(?-i)a)b/i
 | 
						|
    aB
 | 
						|
 0: aB
 | 
						|
 | 
						|
/((?-i)a)b/i
 | 
						|
    aB
 | 
						|
 0: aB
 | 
						|
 | 
						|
/(?:(?-i)a)b/i
 | 
						|
\= Expect no match
 | 
						|
    Ab
 | 
						|
No match
 | 
						|
    AB
 | 
						|
No match
 | 
						|
 | 
						|
/((?-i)a)b/i
 | 
						|
 | 
						|
/(?-i:a)b/i
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 | 
						|
/((?-i:a))b/i
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 | 
						|
/(?-i:a)b/i
 | 
						|
    aB
 | 
						|
 0: aB
 | 
						|
 | 
						|
/((?-i:a))b/i
 | 
						|
    aB
 | 
						|
 0: aB
 | 
						|
 | 
						|
/(?-i:a)b/i
 | 
						|
\= Expect no match
 | 
						|
    AB
 | 
						|
No match
 | 
						|
    Ab
 | 
						|
No match
 | 
						|
 | 
						|
/((?-i:a))b/i
 | 
						|
 | 
						|
/(?-i:a)b/i
 | 
						|
    aB
 | 
						|
 0: aB
 | 
						|
 | 
						|
/((?-i:a))b/i
 | 
						|
    aB
 | 
						|
 0: aB
 | 
						|
 | 
						|
/(?-i:a)b/i
 | 
						|
\= Expect no match
 | 
						|
    Ab
 | 
						|
No match
 | 
						|
    AB
 | 
						|
No match
 | 
						|
 | 
						|
/((?-i:a))b/i
 | 
						|
 | 
						|
/((?-i:a.))b/i
 | 
						|
\= Expect no match
 | 
						|
    AB
 | 
						|
No match
 | 
						|
    a\nB
 | 
						|
No match
 | 
						|
 | 
						|
/((?s-i:a.))b/i
 | 
						|
    a\nB
 | 
						|
 0: a\x0aB
 | 
						|
 | 
						|
/(?:c|d)(?:)(?:a(?:)(?:b)(?:b(?:))(?:b(?:)(?:b)))/
 | 
						|
    cabbbb
 | 
						|
 0: cabbbb
 | 
						|
 | 
						|
/(?:c|d)(?:)(?:aaaaaaaa(?:)(?:bbbbbbbb)(?:bbbbbbbb(?:))(?:bbbbbbbb(?:)(?:bbbbbbbb)))/
 | 
						|
    caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
 | 
						|
 0: caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
 | 
						|
 | 
						|
/foo\w*\d{4}baz/
 | 
						|
    foobar1234baz
 | 
						|
 0: foobar1234baz
 | 
						|
 | 
						|
/x(~~)*(?:(?:F)?)?/
 | 
						|
    x~~
 | 
						|
 0: x~~
 | 
						|
 1: x
 | 
						|
 | 
						|
/^a(?#xxx){3}c/
 | 
						|
    aaac
 | 
						|
 0: aaac
 | 
						|
 | 
						|
/^a (?#xxx) (?#yyy) {3}c/x
 | 
						|
    aaac
 | 
						|
 0: aaac
 | 
						|
 | 
						|
/(?<![cd])b/
 | 
						|
\= Expect no match
 | 
						|
    B\nB
 | 
						|
No match
 | 
						|
    dbcb
 | 
						|
No match
 | 
						|
 | 
						|
/(?<![cd])[ab]/
 | 
						|
    dbaacb
 | 
						|
 0: a
 | 
						|
 | 
						|
/(?<!(c|d))b/
 | 
						|
 | 
						|
/(?<!(c|d))[ab]/
 | 
						|
    dbaacb
 | 
						|
 0: a
 | 
						|
 | 
						|
/(?<!cd)[ab]/
 | 
						|
    cdaccb
 | 
						|
 0: b
 | 
						|
 | 
						|
/^(?:a?b?)*$/
 | 
						|
\= Expect no match
 | 
						|
    dbcb
 | 
						|
No match
 | 
						|
    a--
 | 
						|
No match
 | 
						|
 | 
						|
/((?s)^a(.))((?m)^b$)/
 | 
						|
    a\nb\nc\n
 | 
						|
 0: a\x0ab
 | 
						|
 | 
						|
/((?m)^b$)/
 | 
						|
    a\nb\nc\n
 | 
						|
 0: b
 | 
						|
 | 
						|
/(?m)^b/
 | 
						|
    a\nb\n
 | 
						|
 0: b
 | 
						|
 | 
						|
/(?m)^(b)/
 | 
						|
    a\nb\n
 | 
						|
 0: b
 | 
						|
 | 
						|
/((?m)^b)/
 | 
						|
    a\nb\n
 | 
						|
 0: b
 | 
						|
 | 
						|
/\n((?m)^b)/
 | 
						|
    a\nb\n
 | 
						|
 0: \x0ab
 | 
						|
 | 
						|
/((?s).)c(?!.)/
 | 
						|
    a\nb\nc\n
 | 
						|
 0: \x0ac
 | 
						|
    a\nb\nc\n
 | 
						|
 0: \x0ac
 | 
						|
 | 
						|
/((?s)b.)c(?!.)/
 | 
						|
    a\nb\nc\n
 | 
						|
 0: b\x0ac
 | 
						|
    a\nb\nc\n
 | 
						|
 0: b\x0ac
 | 
						|
 | 
						|
/^b/
 | 
						|
 | 
						|
/()^b/
 | 
						|
\= Expect no match
 | 
						|
    a\nb\nc\n
 | 
						|
No match
 | 
						|
    a\nb\nc\n
 | 
						|
No match
 | 
						|
 | 
						|
/((?m)^b)/
 | 
						|
    a\nb\nc\n
 | 
						|
 0: b
 | 
						|
 | 
						|
/(?(?!a)a|b)/
 | 
						|
 | 
						|
/(?(?!a)b|a)/
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
 | 
						|
/(?(?=a)b|a)/
 | 
						|
\= Expect no match
 | 
						|
    a
 | 
						|
No match
 | 
						|
    a
 | 
						|
No match
 | 
						|
 | 
						|
/(?(?=a)a|b)/
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
 | 
						|
/(\w+:)+/
 | 
						|
    one:
 | 
						|
 0: one:
 | 
						|
 | 
						|
/$(?<=^(a))/
 | 
						|
    a
 | 
						|
 0: 
 | 
						|
 | 
						|
/([\w:]+::)?(\w+)$/
 | 
						|
    abcd
 | 
						|
 0: abcd
 | 
						|
    xy:z:::abcd
 | 
						|
 0: xy:z:::abcd
 | 
						|
 | 
						|
/^[^bcd]*(c+)/
 | 
						|
    aexycd
 | 
						|
 0: aexyc
 | 
						|
 | 
						|
/(a*)b+/
 | 
						|
    caab
 | 
						|
 0: aab
 | 
						|
 | 
						|
/([\w:]+::)?(\w+)$/
 | 
						|
    abcd
 | 
						|
 0: abcd
 | 
						|
    xy:z:::abcd
 | 
						|
 0: xy:z:::abcd
 | 
						|
\= Expect no match
 | 
						|
    abcd:
 | 
						|
No match
 | 
						|
    abcd:
 | 
						|
No match
 | 
						|
 | 
						|
/^[^bcd]*(c+)/
 | 
						|
    aexycd
 | 
						|
 0: aexyc
 | 
						|
 | 
						|
/(>a+)ab/
 | 
						|
 | 
						|
/(?>a+)b/
 | 
						|
    aaab
 | 
						|
 0: aaab
 | 
						|
 | 
						|
/([[:]+)/
 | 
						|
    a:[b]:
 | 
						|
 0: :[
 | 
						|
 | 
						|
/([[=]+)/
 | 
						|
    a=[b]=
 | 
						|
 0: =[
 | 
						|
 | 
						|
/([[.]+)/
 | 
						|
    a.[b].
 | 
						|
 0: .[
 | 
						|
 | 
						|
/((?>a+)b)/
 | 
						|
    aaab
 | 
						|
 0: aaab
 | 
						|
 | 
						|
/(?>(a+))b/
 | 
						|
    aaab
 | 
						|
 0: aaab
 | 
						|
 | 
						|
/((?>[^()]+)|\([^()]*\))+/
 | 
						|
    ((abc(ade)ufh()()x
 | 
						|
 0: abc(ade)ufh()()x
 | 
						|
 1: abc(ade)ufh()()
 | 
						|
 2: abc(ade)ufh()
 | 
						|
 3: abc(ade)ufh
 | 
						|
 4: abc(ade)
 | 
						|
 5: abc
 | 
						|
 | 
						|
/a\Z/
 | 
						|
\= Expect no match
 | 
						|
    aaab
 | 
						|
No match
 | 
						|
    a\nb\n
 | 
						|
No match
 | 
						|
 | 
						|
/b\Z/
 | 
						|
    a\nb\n
 | 
						|
 0: b
 | 
						|
 | 
						|
/b\z/
 | 
						|
 | 
						|
/b\Z/
 | 
						|
    a\nb
 | 
						|
 0: b
 | 
						|
 | 
						|
/b\z/
 | 
						|
    a\nb
 | 
						|
 0: b
 | 
						|
    
 | 
						|
/(?>.*)(?<=(abcd|wxyz))/
 | 
						|
    alphabetabcd
 | 
						|
 0: alphabetabcd
 | 
						|
    endingwxyz
 | 
						|
 0: endingwxyz
 | 
						|
\= Expect no match
 | 
						|
    a rather long string that doesn't end with one of them
 | 
						|
No match
 | 
						|
 | 
						|
/word (?>(?:(?!otherword)[a-zA-Z0-9]+ ){0,30})otherword/
 | 
						|
    word cat dog elephant mussel cow horse canary baboon snake shark otherword
 | 
						|
 0: word cat dog elephant mussel cow horse canary baboon snake shark otherword
 | 
						|
\= Expect no match
 | 
						|
    word cat dog elephant mussel cow horse canary baboon snake shark
 | 
						|
No match
 | 
						|
  
 | 
						|
/word (?>[a-zA-Z0-9]+ ){0,30}otherword/
 | 
						|
\= Expect no match
 | 
						|
    word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope
 | 
						|
No match
 | 
						|
 | 
						|
/(?<=\d{3}(?!999))foo/
 | 
						|
    999foo
 | 
						|
 0: foo
 | 
						|
    123999foo 
 | 
						|
 0: foo
 | 
						|
\= Expect no match
 | 
						|
    123abcfoo
 | 
						|
No match
 | 
						|
    
 | 
						|
/(?<=(?!...999)\d{3})foo/
 | 
						|
    999foo
 | 
						|
 0: foo
 | 
						|
    123999foo 
 | 
						|
 0: foo
 | 
						|
\= Expect no match
 | 
						|
    123abcfoo
 | 
						|
No match
 | 
						|
 | 
						|
/(?<=\d{3}(?!999)...)foo/
 | 
						|
    123abcfoo
 | 
						|
 0: foo
 | 
						|
    123456foo 
 | 
						|
 0: foo
 | 
						|
\= Expect no match
 | 
						|
    123999foo  
 | 
						|
No match
 | 
						|
    
 | 
						|
/(?<=\d{3}...)(?<!999)foo/
 | 
						|
    123abcfoo   
 | 
						|
 0: foo
 | 
						|
    123456foo 
 | 
						|
 0: foo
 | 
						|
\= Expect no match
 | 
						|
    123999foo  
 | 
						|
No match
 | 
						|
 | 
						|
/((Z)+|A)*/
 | 
						|
    ZABCDEFG
 | 
						|
 0: ZA
 | 
						|
 1: Z
 | 
						|
 2: 
 | 
						|
 | 
						|
/(Z()|A)*/
 | 
						|
    ZABCDEFG
 | 
						|
 0: ZA
 | 
						|
 1: Z
 | 
						|
 2: 
 | 
						|
 | 
						|
/(Z(())|A)*/
 | 
						|
    ZABCDEFG
 | 
						|
 0: ZA
 | 
						|
 1: Z
 | 
						|
 2: 
 | 
						|
 | 
						|
/((?>Z)+|A)*/
 | 
						|
    ZABCDEFG
 | 
						|
 0: ZA
 | 
						|
 1: Z
 | 
						|
 2: 
 | 
						|
 | 
						|
/((?>)+|A)*/
 | 
						|
    ZABCDEFG
 | 
						|
 0: 
 | 
						|
 | 
						|
/a*/g
 | 
						|
    abbab
 | 
						|
 0: a
 | 
						|
 0: 
 | 
						|
 0: 
 | 
						|
 0: a
 | 
						|
 0: 
 | 
						|
 0: 
 | 
						|
 | 
						|
/^[\d-a]/
 | 
						|
    abcde
 | 
						|
 0: a
 | 
						|
    -things
 | 
						|
 0: -
 | 
						|
    0digit
 | 
						|
 0: 0
 | 
						|
\= Expect no match
 | 
						|
    bcdef    
 | 
						|
No match
 | 
						|
    
 | 
						|
/[[:space:]]+/
 | 
						|
    > \x09\x0a\x0c\x0d\x0b<
 | 
						|
 0:  \x09\x0a\x0c\x0d\x0b
 | 
						|
     
 | 
						|
/[[:blank:]]+/
 | 
						|
    > \x09\x0a\x0c\x0d\x0b<
 | 
						|
 0:  \x09
 | 
						|
     
 | 
						|
/[\s]+/
 | 
						|
    > \x09\x0a\x0c\x0d\x0b<
 | 
						|
 0:  \x09\x0a\x0c\x0d\x0b
 | 
						|
     
 | 
						|
/\s+/
 | 
						|
    > \x09\x0a\x0c\x0d\x0b<
 | 
						|
 0:  \x09\x0a\x0c\x0d\x0b
 | 
						|
     
 | 
						|
/ab/x
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 | 
						|
/(?!\A)x/m
 | 
						|
  a\nxb\n
 | 
						|
 0: x
 | 
						|
 | 
						|
/(?!^)x/m
 | 
						|
\= Expect no match
 | 
						|
    a\nxb\n
 | 
						|
No match
 | 
						|
 | 
						|
/abc\Qabc\Eabc/
 | 
						|
    abcabcabc
 | 
						|
 0: abcabcabc
 | 
						|
    
 | 
						|
/abc\Q(*+|\Eabc/
 | 
						|
    abc(*+|abc 
 | 
						|
 0: abc(*+|abc
 | 
						|
 | 
						|
/   abc\Q abc\Eabc/x
 | 
						|
    abc abcabc
 | 
						|
 0: abc abcabc
 | 
						|
\= Expect no match
 | 
						|
    abcabcabc  
 | 
						|
No match
 | 
						|
    
 | 
						|
/abc#comment
 | 
						|
    \Q#not comment
 | 
						|
    literal\E/x
 | 
						|
    abc#not comment\n    literal     
 | 
						|
 0: abc#not comment\x0a    literal
 | 
						|
 | 
						|
/abc#comment
 | 
						|
    \Q#not comment
 | 
						|
    literal/x
 | 
						|
    abc#not comment\n    literal     
 | 
						|
 0: abc#not comment\x0a    literal
 | 
						|
 | 
						|
/abc#comment
 | 
						|
    \Q#not comment
 | 
						|
    literal\E #more comment
 | 
						|
    /x
 | 
						|
    abc#not comment\n    literal     
 | 
						|
 0: abc#not comment\x0a    literal
 | 
						|
 | 
						|
/abc#comment
 | 
						|
    \Q#not comment
 | 
						|
    literal\E #more comment/x
 | 
						|
    abc#not comment\n    literal     
 | 
						|
 0: abc#not comment\x0a    literal
 | 
						|
 | 
						|
/\Qabc\$xyz\E/
 | 
						|
    abc\\\$xyz
 | 
						|
 0: abc\$xyz
 | 
						|
 | 
						|
/\Qabc\E\$\Qxyz\E/
 | 
						|
    abc\$xyz
 | 
						|
 0: abc$xyz
 | 
						|
 | 
						|
/\Gabc/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    xyzabc  
 | 
						|
No match
 | 
						|
 | 
						|
/\Gabc./g
 | 
						|
    abc1abc2xyzabc3
 | 
						|
 0: abc1
 | 
						|
 0: abc2
 | 
						|
 | 
						|
/abc./g
 | 
						|
    abc1abc2xyzabc3 
 | 
						|
 0: abc1
 | 
						|
 0: abc2
 | 
						|
 0: abc3
 | 
						|
 | 
						|
/a(?x: b c )d/
 | 
						|
    XabcdY
 | 
						|
 0: abcd
 | 
						|
\= Expect no match 
 | 
						|
    Xa b c d Y 
 | 
						|
No match
 | 
						|
 | 
						|
/((?x)x y z | a b c)/
 | 
						|
    XabcY
 | 
						|
 0: abc
 | 
						|
    AxyzB 
 | 
						|
 0: xyz
 | 
						|
 | 
						|
/(?i)AB(?-i)C/
 | 
						|
    XabCY
 | 
						|
 0: abC
 | 
						|
\= Expect no match
 | 
						|
    XabcY  
 | 
						|
No match
 | 
						|
 | 
						|
/((?i)AB(?-i)C|D)E/
 | 
						|
    abCE
 | 
						|
 0: abCE
 | 
						|
    DE
 | 
						|
 0: DE
 | 
						|
\= Expect no match
 | 
						|
    abcE
 | 
						|
No match
 | 
						|
    abCe  
 | 
						|
No match
 | 
						|
    dE
 | 
						|
No match
 | 
						|
    De    
 | 
						|
No match
 | 
						|
 | 
						|
/[z\Qa-d]\E]/
 | 
						|
    z
 | 
						|
 0: z
 | 
						|
    a
 | 
						|
 0: a
 | 
						|
    -
 | 
						|
 0: -
 | 
						|
    d
 | 
						|
 0: d
 | 
						|
    ] 
 | 
						|
 0: ]
 | 
						|
\= Expect no match
 | 
						|
    b     
 | 
						|
No match
 | 
						|
 | 
						|
/(a+)*b/
 | 
						|
\= Expect no match
 | 
						|
    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 
 | 
						|
No match
 | 
						|
    
 | 
						|
/(?i)reg(?:ul(?:[a�]|ae)r|ex)/
 | 
						|
    REGular
 | 
						|
 0: REGular
 | 
						|
    regulaer
 | 
						|
 0: regulaer
 | 
						|
    Regex  
 | 
						|
 0: Regex
 | 
						|
    regul�r 
 | 
						|
 0: regul\xe4r
 | 
						|
 | 
						|
/����[�-��-�]+/
 | 
						|
    �����
 | 
						|
 0: \xc5\xe6\xe5\xe4\xe0
 | 
						|
    �����
 | 
						|
 0: \xc5\xe6\xe5\xe4\xff
 | 
						|
    �����
 | 
						|
 0: \xc5\xe6\xe5\xe4\xc0
 | 
						|
    �����
 | 
						|
 0: \xc5\xe6\xe5\xe4\xdf
 | 
						|
 | 
						|
/(?<=Z)X./
 | 
						|
    \x84XAZXB
 | 
						|
 0: XB
 | 
						|
 | 
						|
/^(?(2)a|(1)(2))+$/
 | 
						|
    123a
 | 
						|
Failed: error -40: backreference condition or recursion test is not supported for DFA matching
 | 
						|
 | 
						|
/(?<=a|bbbb)c/
 | 
						|
    ac
 | 
						|
 0: c
 | 
						|
    bbbbc
 | 
						|
 0: c
 | 
						|
 | 
						|
/line\nbreak/
 | 
						|
    this is a line\nbreak
 | 
						|
 0: line\x0abreak
 | 
						|
    line one\nthis is a line\nbreak in the second line 
 | 
						|
 0: line\x0abreak
 | 
						|
 | 
						|
/line\nbreak/firstline
 | 
						|
    this is a line\nbreak
 | 
						|
 0: line\x0abreak
 | 
						|
\= Expect no match 
 | 
						|
    line one\nthis is a line\nbreak in the second line 
 | 
						|
No match
 | 
						|
 | 
						|
/line\nbreak/m,firstline
 | 
						|
    this is a line\nbreak
 | 
						|
 0: line\x0abreak
 | 
						|
\= Expect no match 
 | 
						|
    line one\nthis is a line\nbreak in the second line 
 | 
						|
No match
 | 
						|
 | 
						|
/1234/
 | 
						|
    123\=ps
 | 
						|
Partial match: 123
 | 
						|
\= Expect no match 
 | 
						|
    a4\=ps,dfa_restart
 | 
						|
No match
 | 
						|
 | 
						|
/1234/
 | 
						|
    123\=ps
 | 
						|
Partial match: 123
 | 
						|
    4\=ps,dfa_restart
 | 
						|
 0: 4
 | 
						|
 | 
						|
/^/gm
 | 
						|
    a\nb\nc\n
 | 
						|
 0: 
 | 
						|
 0: 
 | 
						|
 0: 
 | 
						|
    \ 
 | 
						|
 0: 
 | 
						|
    
 | 
						|
/(?<=C\n)^/gm
 | 
						|
    A\nC\nC\n 
 | 
						|
 0: 
 | 
						|
 | 
						|
/(?s)A?B/
 | 
						|
    AB
 | 
						|
 0: AB
 | 
						|
    aB  
 | 
						|
 0: B
 | 
						|
 | 
						|
/(?s)A*B/
 | 
						|
    AB
 | 
						|
 0: AB
 | 
						|
    aB  
 | 
						|
 0: B
 | 
						|
 | 
						|
/(?m)A?B/
 | 
						|
    AB
 | 
						|
 0: AB
 | 
						|
    aB  
 | 
						|
 0: B
 | 
						|
 | 
						|
/(?m)A*B/
 | 
						|
    AB
 | 
						|
 0: AB
 | 
						|
    aB  
 | 
						|
 0: B
 | 
						|
 | 
						|
/Content-Type\x3A[^\r\n]{6,}/
 | 
						|
    Content-Type:xxxxxyyy 
 | 
						|
 0: Content-Type:xxxxxyyy
 | 
						|
 | 
						|
/Content-Type\x3A[^\r\n]{6,}z/
 | 
						|
    Content-Type:xxxxxyyyz
 | 
						|
 0: Content-Type:xxxxxyyyz
 | 
						|
 | 
						|
/Content-Type\x3A[^a]{6,}/
 | 
						|
    Content-Type:xxxyyy 
 | 
						|
 0: Content-Type:xxxyyy
 | 
						|
 | 
						|
/Content-Type\x3A[^a]{6,}z/
 | 
						|
    Content-Type:xxxyyyz
 | 
						|
 0: Content-Type:xxxyyyz
 | 
						|
 | 
						|
/^abc/Im,newline=lf
 | 
						|
Capturing subpattern count = 0
 | 
						|
Options: multiline
 | 
						|
Forced newline is LF
 | 
						|
First code unit at start or follows newline
 | 
						|
Last code unit = 'c'
 | 
						|
Subject length lower bound = 3
 | 
						|
    xyz\nabc
 | 
						|
 0: abc
 | 
						|
    xyz\r\nabc
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    xyz\rabc
 | 
						|
No match
 | 
						|
    xyzabc\r
 | 
						|
No match
 | 
						|
    xyzabc\rpqr
 | 
						|
No match
 | 
						|
    xyzabc\r\n
 | 
						|
No match
 | 
						|
    xyzabc\r\npqr
 | 
						|
No match
 | 
						|
 | 
						|
/^abc/Im,newline=crlf
 | 
						|
Capturing subpattern count = 0
 | 
						|
Options: multiline
 | 
						|
Forced newline is CRLF
 | 
						|
First code unit at start or follows newline
 | 
						|
Last code unit = 'c'
 | 
						|
Subject length lower bound = 3
 | 
						|
    xyz\r\nabclf>
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    xyz\nabclf
 | 
						|
No match
 | 
						|
    xyz\rabclf
 | 
						|
No match
 | 
						|
    
 | 
						|
/^abc/Im,newline=cr
 | 
						|
Capturing subpattern count = 0
 | 
						|
Options: multiline
 | 
						|
Forced newline is CR
 | 
						|
First code unit at start or follows newline
 | 
						|
Last code unit = 'c'
 | 
						|
Subject length lower bound = 3
 | 
						|
    xyz\rabc
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    xyz\nabc
 | 
						|
No match
 | 
						|
    xyz\r\nabc
 | 
						|
No match
 | 
						|
 | 
						|
/.*/I,newline=lf
 | 
						|
Capturing subpattern count = 0
 | 
						|
May match empty string
 | 
						|
Forced newline is LF
 | 
						|
First code unit at start or follows newline
 | 
						|
Subject length lower bound = 0
 | 
						|
    abc\ndef
 | 
						|
 0: abc
 | 
						|
    abc\rdef
 | 
						|
 0: abc\x0ddef
 | 
						|
    abc\r\ndef
 | 
						|
 0: abc\x0d
 | 
						|
 | 
						|
/.*/I,newline=cr
 | 
						|
Capturing subpattern count = 0
 | 
						|
May match empty string
 | 
						|
Forced newline is CR
 | 
						|
First code unit at start or follows newline
 | 
						|
Subject length lower bound = 0
 | 
						|
    abc\ndef
 | 
						|
 0: abc\x0adef
 | 
						|
    abc\rdef
 | 
						|
 0: abc
 | 
						|
    abc\r\ndef
 | 
						|
 0: abc
 | 
						|
 | 
						|
/.*/I,newline=crlf
 | 
						|
Capturing subpattern count = 0
 | 
						|
May match empty string
 | 
						|
Forced newline is CRLF
 | 
						|
First code unit at start or follows newline
 | 
						|
Subject length lower bound = 0
 | 
						|
    abc\ndef
 | 
						|
 0: abc\x0adef
 | 
						|
    abc\rdef
 | 
						|
 0: abc\x0ddef
 | 
						|
    abc\r\ndef
 | 
						|
 0: abc
 | 
						|
 | 
						|
/\w+(.)(.)?def/Is
 | 
						|
Capturing subpattern count = 2
 | 
						|
Options: dotall
 | 
						|
Starting code units: 0 1 2 3 4 5 6 7 8 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 f g h i j k l m n o p q r s t u v w x y z 
 | 
						|
Last code unit = 'f'
 | 
						|
Subject length lower bound = 5
 | 
						|
    abc\ndef
 | 
						|
 0: abc\x0adef
 | 
						|
    abc\rdef
 | 
						|
 0: abc\x0ddef
 | 
						|
    abc\r\ndef
 | 
						|
 0: abc\x0d\x0adef
 | 
						|
 | 
						|
/\w+(.)(.)?def/s
 | 
						|
    abc\ndef
 | 
						|
 0: abc\x0adef
 | 
						|
    abc\rdef
 | 
						|
 0: abc\x0ddef
 | 
						|
    abc\r\ndef
 | 
						|
 0: abc\x0d\x0adef
 | 
						|
 | 
						|
/^\w+=.*(\\\n.*)*/
 | 
						|
    abc=xyz\\\npqr
 | 
						|
 0: abc=xyz\\x0apqr
 | 
						|
 1: abc=xyz\\x0apq
 | 
						|
 2: abc=xyz\\x0ap
 | 
						|
 3: abc=xyz\\x0a
 | 
						|
 4: abc=xyz\
 | 
						|
 5: abc=xyz
 | 
						|
 6: abc=xy
 | 
						|
 7: abc=x
 | 
						|
 8: abc=
 | 
						|
 | 
						|
/^(a()*)*/
 | 
						|
    aaaa
 | 
						|
 0: aaaa
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
 3: a
 | 
						|
 4: 
 | 
						|
 | 
						|
/^(?:a(?:(?:))*)*/
 | 
						|
    aaaa
 | 
						|
 0: aaaa
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
 3: a
 | 
						|
 4: 
 | 
						|
 | 
						|
/^(a()+)+/
 | 
						|
    aaaa
 | 
						|
 0: aaaa
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
 3: a
 | 
						|
 | 
						|
/^(?:a(?:(?:))+)+/
 | 
						|
    aaaa
 | 
						|
 0: aaaa
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
 3: a
 | 
						|
 | 
						|
/(a|)*\d/
 | 
						|
  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4
 | 
						|
 0: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4
 | 
						|
\= Expect no match
 | 
						|
  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 | 
						|
No match
 | 
						|
 | 
						|
/(?>a|)*\d/
 | 
						|
  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4
 | 
						|
 0: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4
 | 
						|
\= Expect no match
 | 
						|
  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 | 
						|
No match
 | 
						|
 | 
						|
/(?:a|)*\d/
 | 
						|
  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4
 | 
						|
 0: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4
 | 
						|
\= Expect no match
 | 
						|
  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 | 
						|
No match
 | 
						|
 | 
						|
/^a.b/newline=lf
 | 
						|
    a\rb
 | 
						|
 0: a\x0db
 | 
						|
\= Expect no match
 | 
						|
    a\nb
 | 
						|
No match
 | 
						|
 | 
						|
/^a.b/newline=cr
 | 
						|
    a\nb
 | 
						|
 0: a\x0ab
 | 
						|
\= Expect no match
 | 
						|
    a\rb
 | 
						|
No match
 | 
						|
 | 
						|
/^a.b/newline=anycrlf
 | 
						|
    a\x85b
 | 
						|
 0: a\x85b
 | 
						|
\= Expect no match
 | 
						|
    a\rb
 | 
						|
No match
 | 
						|
 | 
						|
/^a.b/newline=any
 | 
						|
\= Expect no match
 | 
						|
    a\nb
 | 
						|
No match
 | 
						|
    a\rb
 | 
						|
No match
 | 
						|
    a\x85b
 | 
						|
No match
 | 
						|
 | 
						|
/^abc./gmx,newline=any
 | 
						|
    abc1 \x0aabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\x0aabc6 \x85abc7 JUNK
 | 
						|
 0: abc1
 | 
						|
 0: abc2
 | 
						|
 0: abc3
 | 
						|
 0: abc4
 | 
						|
 0: abc5
 | 
						|
 0: abc6
 | 
						|
 0: abc7
 | 
						|
 | 
						|
/abc.$/gmx,newline=any
 | 
						|
    abc1\x0a abc2\x0b abc3\x0c abc4\x0d abc5\x0d\x0a abc6\x85 abc9
 | 
						|
 0: abc1
 | 
						|
 0: abc2
 | 
						|
 0: abc3
 | 
						|
 0: abc4
 | 
						|
 0: abc5
 | 
						|
 0: abc6
 | 
						|
 0: abc9
 | 
						|
 | 
						|
/^a\Rb/bsr=unicode
 | 
						|
    a\nb
 | 
						|
 0: a\x0ab
 | 
						|
    a\rb
 | 
						|
 0: a\x0db
 | 
						|
    a\r\nb
 | 
						|
 0: a\x0d\x0ab
 | 
						|
    a\x0bb
 | 
						|
 0: a\x0bb
 | 
						|
    a\x0cb
 | 
						|
 0: a\x0cb
 | 
						|
    a\x85b   
 | 
						|
 0: a\x85b
 | 
						|
\= Expect no match
 | 
						|
    a\n\rb    
 | 
						|
No match
 | 
						|
 | 
						|
/^a\R*b/bsr=unicode
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
    a\nb
 | 
						|
 0: a\x0ab
 | 
						|
    a\rb
 | 
						|
 0: a\x0db
 | 
						|
    a\r\nb
 | 
						|
 0: a\x0d\x0ab
 | 
						|
    a\x0bb
 | 
						|
 0: a\x0bb
 | 
						|
    a\x0cb
 | 
						|
 0: a\x0cb
 | 
						|
    a\x85b   
 | 
						|
 0: a\x85b
 | 
						|
    a\n\rb    
 | 
						|
 0: a\x0a\x0db
 | 
						|
    a\n\r\x85\x0cb 
 | 
						|
 0: a\x0a\x0d\x85\x0cb
 | 
						|
 | 
						|
/^a\R+b/bsr=unicode
 | 
						|
    a\nb
 | 
						|
 0: a\x0ab
 | 
						|
    a\rb
 | 
						|
 0: a\x0db
 | 
						|
    a\r\nb
 | 
						|
 0: a\x0d\x0ab
 | 
						|
    a\x0bb
 | 
						|
 0: a\x0bb
 | 
						|
    a\x0cb
 | 
						|
 0: a\x0cb
 | 
						|
    a\x85b   
 | 
						|
 0: a\x85b
 | 
						|
    a\n\rb    
 | 
						|
 0: a\x0a\x0db
 | 
						|
    a\n\r\x85\x0cb 
 | 
						|
 0: a\x0a\x0d\x85\x0cb
 | 
						|
\= Expect no match
 | 
						|
    ab  
 | 
						|
No match
 | 
						|
    
 | 
						|
/^a\R{1,3}b/bsr=unicode
 | 
						|
    a\nb
 | 
						|
 0: a\x0ab
 | 
						|
    a\n\rb
 | 
						|
 0: a\x0a\x0db
 | 
						|
    a\n\r\x85b
 | 
						|
 0: a\x0a\x0d\x85b
 | 
						|
    a\r\n\r\nb 
 | 
						|
 0: a\x0d\x0a\x0d\x0ab
 | 
						|
    a\r\n\r\n\r\nb 
 | 
						|
 0: a\x0d\x0a\x0d\x0a\x0d\x0ab
 | 
						|
    a\n\r\n\rb
 | 
						|
 0: a\x0a\x0d\x0a\x0db
 | 
						|
    a\n\n\r\nb 
 | 
						|
 0: a\x0a\x0a\x0d\x0ab
 | 
						|
\= Expect no match
 | 
						|
    a\n\n\n\rb
 | 
						|
No match
 | 
						|
    a\r
 | 
						|
No match
 | 
						|
 | 
						|
/.+foo/
 | 
						|
    afoo
 | 
						|
 0: afoo
 | 
						|
\= Expect no match 
 | 
						|
    \r\nfoo 
 | 
						|
No match
 | 
						|
    \nfoo 
 | 
						|
No match
 | 
						|
 | 
						|
/.+foo/newline=crlf
 | 
						|
    afoo
 | 
						|
 0: afoo
 | 
						|
    \nfoo 
 | 
						|
 0: \x0afoo
 | 
						|
\= Expect no match 
 | 
						|
    \r\nfoo 
 | 
						|
No match
 | 
						|
 | 
						|
/.+foo/newline=any
 | 
						|
    afoo
 | 
						|
 0: afoo
 | 
						|
\= Expect no match 
 | 
						|
    \nfoo 
 | 
						|
No match
 | 
						|
    \r\nfoo 
 | 
						|
No match
 | 
						|
 | 
						|
/.+foo/s
 | 
						|
    afoo
 | 
						|
 0: afoo
 | 
						|
    \r\nfoo 
 | 
						|
 0: \x0d\x0afoo
 | 
						|
    \nfoo 
 | 
						|
 0: \x0afoo
 | 
						|
 | 
						|
/^$/gm,newline=any
 | 
						|
    abc\r\rxyz
 | 
						|
 0: 
 | 
						|
    abc\n\rxyz  
 | 
						|
 0: 
 | 
						|
\= Expect no match 
 | 
						|
    abc\r\nxyz
 | 
						|
No match
 | 
						|
 | 
						|
/^X/m
 | 
						|
    XABC
 | 
						|
 0: X
 | 
						|
\= Expect no match 
 | 
						|
    XABC\=notbol
 | 
						|
No match
 | 
						|
 | 
						|
/(?m)^$/g,newline=any,aftertext
 | 
						|
    abc\r\n\r\n
 | 
						|
 0: 
 | 
						|
 0+ \x0d\x0a
 | 
						|
 | 
						|
/(?m)^$|^\r\n/g,newline=any,aftertext
 | 
						|
    abc\r\n\r\n
 | 
						|
 0: \x0d\x0a
 | 
						|
 0+ 
 | 
						|
 1: 
 | 
						|
    
 | 
						|
/(?m)$/g,newline=any,aftertext
 | 
						|
    abc\r\n\r\n
 | 
						|
 0: 
 | 
						|
 0+ \x0d\x0a\x0d\x0a
 | 
						|
 0: 
 | 
						|
 0+ \x0d\x0a
 | 
						|
 0: 
 | 
						|
 0+ 
 | 
						|
 | 
						|
/(?|(abc)|(xyz))/
 | 
						|
   >abc<
 | 
						|
 0: abc
 | 
						|
   >xyz< 
 | 
						|
 0: xyz
 | 
						|
 | 
						|
/(x)(?|(abc)|(xyz))(x)/
 | 
						|
    xabcx
 | 
						|
 0: xabcx
 | 
						|
    xxyzx 
 | 
						|
 0: xxyzx
 | 
						|
 | 
						|
/(x)(?|(abc)(pqr)|(xyz))(x)/
 | 
						|
    xabcpqrx
 | 
						|
 0: xabcpqrx
 | 
						|
    xxyzx 
 | 
						|
 0: xxyzx
 | 
						|
 | 
						|
/(?|(abc)|(xyz))(?1)/
 | 
						|
    abcabc
 | 
						|
 0: abcabc
 | 
						|
    xyzabc 
 | 
						|
 0: xyzabc
 | 
						|
\= Expect no match 
 | 
						|
    xyzxyz 
 | 
						|
No match
 | 
						|
 
 | 
						|
/\H\h\V\v/
 | 
						|
    X X\x0a
 | 
						|
 0: X X\x0a
 | 
						|
    X\x09X\x0b
 | 
						|
 0: X\x09X\x0b
 | 
						|
\= Expect 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
 | 
						|
\= Expect 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
 | 
						|
 1: B    
 | 
						|
 | 
						|
/\h*X\h?\H+Y\H?Z/
 | 
						|
    >XNNNYZ
 | 
						|
 0: XNNNYZ
 | 
						|
    >  X NYQZ
 | 
						|
 0:   X NYQZ
 | 
						|
\= Expect 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
 | 
						|
 | 
						|
/.+A/newline=crlf
 | 
						|
\= Expect no match
 | 
						|
    \r\nA
 | 
						|
No match
 | 
						|
    
 | 
						|
/\nA/newline=crlf
 | 
						|
    \r\nA 
 | 
						|
 0: \x0aA
 | 
						|
 | 
						|
/[\r\n]A/newline=crlf
 | 
						|
    \r\nA 
 | 
						|
 0: \x0aA
 | 
						|
 | 
						|
/(\r|\n)A/newline=crlf
 | 
						|
    \r\nA 
 | 
						|
 0: \x0aA
 | 
						|
 | 
						|
/a\Rb/I,bsr=anycrlf
 | 
						|
Capturing subpattern count = 0
 | 
						|
\R matches CR, LF, or CRLF
 | 
						|
First code unit = 'a'
 | 
						|
Last code unit = 'b'
 | 
						|
Subject length lower bound = 3
 | 
						|
    a\rb
 | 
						|
 0: a\x0db
 | 
						|
    a\nb
 | 
						|
 0: a\x0ab
 | 
						|
    a\r\nb
 | 
						|
 0: a\x0d\x0ab
 | 
						|
\= Expect no match
 | 
						|
    a\x85b
 | 
						|
No match
 | 
						|
    a\x0bb     
 | 
						|
No match
 | 
						|
 | 
						|
/a\Rb/I,bsr=unicode
 | 
						|
Capturing subpattern count = 0
 | 
						|
\R matches any Unicode newline
 | 
						|
First code unit = 'a'
 | 
						|
Last code unit = 'b'
 | 
						|
Subject length lower bound = 3
 | 
						|
    a\rb
 | 
						|
 0: a\x0db
 | 
						|
    a\nb
 | 
						|
 0: a\x0ab
 | 
						|
    a\r\nb
 | 
						|
 0: a\x0d\x0ab
 | 
						|
    a\x85b
 | 
						|
 0: a\x85b
 | 
						|
    a\x0bb     
 | 
						|
 0: a\x0bb
 | 
						|
    
 | 
						|
/a\R?b/I,bsr=anycrlf
 | 
						|
Capturing subpattern count = 0
 | 
						|
\R matches CR, LF, or CRLF
 | 
						|
First code unit = 'a'
 | 
						|
Last code unit = 'b'
 | 
						|
Subject length lower bound = 2
 | 
						|
    a\rb
 | 
						|
 0: a\x0db
 | 
						|
    a\nb
 | 
						|
 0: a\x0ab
 | 
						|
    a\r\nb
 | 
						|
 0: a\x0d\x0ab
 | 
						|
\= Expect no match
 | 
						|
    a\x85b
 | 
						|
No match
 | 
						|
    a\x0bb     
 | 
						|
No match
 | 
						|
 | 
						|
/a\R?b/I,bsr=unicode
 | 
						|
Capturing subpattern count = 0
 | 
						|
\R matches any Unicode newline
 | 
						|
First code unit = 'a'
 | 
						|
Last code unit = 'b'
 | 
						|
Subject length lower bound = 2
 | 
						|
    a\rb
 | 
						|
 0: a\x0db
 | 
						|
    a\nb
 | 
						|
 0: a\x0ab
 | 
						|
    a\r\nb
 | 
						|
 0: a\x0d\x0ab
 | 
						|
    a\x85b
 | 
						|
 0: a\x85b
 | 
						|
    a\x0bb     
 | 
						|
 0: a\x0bb
 | 
						|
    
 | 
						|
/a\R{2,4}b/I,bsr=anycrlf
 | 
						|
Capturing subpattern count = 0
 | 
						|
\R matches CR, LF, or CRLF
 | 
						|
First code unit = 'a'
 | 
						|
Last code unit = 'b'
 | 
						|
Subject length lower bound = 4
 | 
						|
    a\r\n\nb
 | 
						|
 0: a\x0d\x0a\x0ab
 | 
						|
    a\n\r\rb
 | 
						|
 0: a\x0a\x0d\x0db
 | 
						|
    a\r\n\r\n\r\n\r\nb
 | 
						|
 0: a\x0d\x0a\x0d\x0a\x0d\x0a\x0d\x0ab
 | 
						|
\= Expect no match
 | 
						|
    a\x0b\x0bb     
 | 
						|
No match
 | 
						|
    a\x85\x85b
 | 
						|
No match
 | 
						|
 | 
						|
/a\R{2,4}b/I,bsr=unicode
 | 
						|
Capturing subpattern count = 0
 | 
						|
\R matches any Unicode newline
 | 
						|
First code unit = 'a'
 | 
						|
Last code unit = 'b'
 | 
						|
Subject length lower bound = 4
 | 
						|
    a\r\rb
 | 
						|
 0: a\x0d\x0db
 | 
						|
    a\n\n\nb
 | 
						|
 0: a\x0a\x0a\x0ab
 | 
						|
    a\r\n\n\r\rb
 | 
						|
 0: a\x0d\x0a\x0a\x0d\x0db
 | 
						|
    a\x85\x85b
 | 
						|
 0: a\x85\x85b
 | 
						|
    a\x0b\x0bb     
 | 
						|
 0: a\x0b\x0bb
 | 
						|
\= Expect no match 
 | 
						|
    a\r\r\r\r\rb 
 | 
						|
No match
 | 
						|
    
 | 
						|
/a(?!)|\wbc/
 | 
						|
    abc 
 | 
						|
 0: abc
 | 
						|
 | 
						|
/a[]b/alt_bsux,allow_empty_class,match_unset_backref,dupnames
 | 
						|
\= Expect no match
 | 
						|
    ab
 | 
						|
No match
 | 
						|
 | 
						|
/a[]+b/alt_bsux,allow_empty_class,match_unset_backref,dupnames
 | 
						|
\= Expect no match
 | 
						|
    ab 
 | 
						|
No match
 | 
						|
 | 
						|
/a[]*+b/alt_bsux,allow_empty_class,match_unset_backref,dupnames
 | 
						|
\= Expect no match
 | 
						|
    ab 
 | 
						|
No match
 | 
						|
 | 
						|
/a[^]b/alt_bsux,allow_empty_class,match_unset_backref,dupnames
 | 
						|
    aXb
 | 
						|
 0: aXb
 | 
						|
    a\nb 
 | 
						|
 0: a\x0ab
 | 
						|
\= Expect no match
 | 
						|
    ab  
 | 
						|
No match
 | 
						|
    
 | 
						|
/a[^]+b/alt_bsux,allow_empty_class,match_unset_backref,dupnames
 | 
						|
    aXb
 | 
						|
 0: aXb
 | 
						|
    a\nX\nXb 
 | 
						|
 0: a\x0aX\x0aXb
 | 
						|
\= Expect no match
 | 
						|
    ab  
 | 
						|
No match
 | 
						|
 | 
						|
/X$/dollar_endonly
 | 
						|
    X
 | 
						|
 0: X
 | 
						|
\= Expect no match 
 | 
						|
    X\n 
 | 
						|
No match
 | 
						|
 | 
						|
/X$/
 | 
						|
    X
 | 
						|
 0: X
 | 
						|
    X\n 
 | 
						|
 0: X
 | 
						|
 | 
						|
/xyz/auto_callout
 | 
						|
  xyz 
 | 
						|
--->xyz
 | 
						|
 +0 ^       x
 | 
						|
 +1 ^^      y
 | 
						|
 +2 ^ ^     z
 | 
						|
 +3 ^  ^    
 | 
						|
 0: xyz
 | 
						|
  abcxyz 
 | 
						|
--->abcxyz
 | 
						|
 +0    ^       x
 | 
						|
 +1    ^^      y
 | 
						|
 +2    ^ ^     z
 | 
						|
 +3    ^  ^    
 | 
						|
 0: xyz
 | 
						|
\= Expect no match 
 | 
						|
  abc
 | 
						|
No match
 | 
						|
  abcxypqr  
 | 
						|
No match
 | 
						|
 | 
						|
/xyz/auto_callout,no_start_optimize
 | 
						|
  abcxyz 
 | 
						|
--->abcxyz
 | 
						|
 +0 ^          x
 | 
						|
 +0  ^         x
 | 
						|
 +0   ^        x
 | 
						|
 +0    ^       x
 | 
						|
 +1    ^^      y
 | 
						|
 +2    ^ ^     z
 | 
						|
 +3    ^  ^    
 | 
						|
 0: xyz
 | 
						|
\= Expect no match 
 | 
						|
  abc
 | 
						|
--->abc
 | 
						|
 +0 ^       x
 | 
						|
 +0  ^      x
 | 
						|
 +0   ^     x
 | 
						|
 +0    ^    x
 | 
						|
No match
 | 
						|
  abcxypqr  
 | 
						|
--->abcxypqr
 | 
						|
 +0 ^            x
 | 
						|
 +0  ^           x
 | 
						|
 +0   ^          x
 | 
						|
 +0    ^         x
 | 
						|
 +1    ^^        y
 | 
						|
 +2    ^ ^       z
 | 
						|
 +0     ^        x
 | 
						|
 +0      ^       x
 | 
						|
 +0       ^      x
 | 
						|
 +0        ^     x
 | 
						|
 +0         ^    x
 | 
						|
No match
 | 
						|
 | 
						|
/(*NO_START_OPT)xyz/auto_callout
 | 
						|
  abcxyz 
 | 
						|
--->abcxyz
 | 
						|
+15 ^          x
 | 
						|
+15  ^         x
 | 
						|
+15   ^        x
 | 
						|
+15    ^       x
 | 
						|
+16    ^^      y
 | 
						|
+17    ^ ^     z
 | 
						|
+18    ^  ^    
 | 
						|
 0: xyz
 | 
						|
  
 | 
						|
/(?C)ab/
 | 
						|
  ab
 | 
						|
--->ab
 | 
						|
  0 ^      a
 | 
						|
 0: ab
 | 
						|
  ab\=callout_none
 | 
						|
 0: ab
 | 
						|
  
 | 
						|
/ab/auto_callout
 | 
						|
  ab
 | 
						|
--->ab
 | 
						|
 +0 ^      a
 | 
						|
 +1 ^^     b
 | 
						|
 +2 ^ ^    
 | 
						|
 0: ab
 | 
						|
  ab\=callout_none
 | 
						|
 0: ab
 | 
						|
 | 
						|
/^"((?(?=[a])[^"])|b)*"$/auto_callout
 | 
						|
    "ab"
 | 
						|
--->"ab"
 | 
						|
 +0 ^        ^
 | 
						|
 +1 ^        "
 | 
						|
 +2 ^^       (
 | 
						|
+21 ^^       "
 | 
						|
 +3 ^^       (?
 | 
						|
+18 ^^       b
 | 
						|
 +5 ^^       (?=
 | 
						|
 +8  ^       [a]
 | 
						|
+11  ^^      )
 | 
						|
+12 ^^       [^"]
 | 
						|
+16 ^ ^      )
 | 
						|
+17 ^ ^      |
 | 
						|
+21 ^ ^      "
 | 
						|
 +3 ^ ^      (?
 | 
						|
+18 ^ ^      b
 | 
						|
 +5 ^ ^      (?=
 | 
						|
 +8   ^      [a]
 | 
						|
+19 ^  ^     )*
 | 
						|
+21 ^  ^     "
 | 
						|
 +3 ^  ^     (?
 | 
						|
+18 ^  ^     b
 | 
						|
 +5 ^  ^     (?=
 | 
						|
 +8    ^     [a]
 | 
						|
+17 ^  ^     |
 | 
						|
+22 ^   ^    $
 | 
						|
+23 ^   ^    
 | 
						|
 0: "ab"
 | 
						|
    "ab"\=callout_none
 | 
						|
 0: "ab"
 | 
						|
 | 
						|
/\d+X|9+Y/
 | 
						|
    ++++123999\=ps
 | 
						|
Partial match: 123999
 | 
						|
    ++++123999Y\=ps
 | 
						|
 0: 999Y
 | 
						|
 | 
						|
/Z(*F)/
 | 
						|
\= Expect no match 
 | 
						|
    Z\=ps
 | 
						|
No match
 | 
						|
    ZA\=ps
 | 
						|
No match
 | 
						|
    
 | 
						|
/Z(?!)/
 | 
						|
\= Expect no match 
 | 
						|
    Z\=ps
 | 
						|
No match
 | 
						|
    ZA\=ps
 | 
						|
No match
 | 
						|
 | 
						|
/dog(sbody)?/
 | 
						|
    dogs\=ps
 | 
						|
 0: dog
 | 
						|
    dogs\=ph
 | 
						|
Partial match: dogs
 | 
						|
    
 | 
						|
/dog(sbody)??/
 | 
						|
    dogs\=ps
 | 
						|
 0: dog
 | 
						|
    dogs\=ph
 | 
						|
Partial match: dogs
 | 
						|
 | 
						|
/dog|dogsbody/
 | 
						|
    dogs\=ps
 | 
						|
 0: dog
 | 
						|
    dogs\=ph
 | 
						|
Partial match: dogs
 | 
						|
 
 | 
						|
/dogsbody|dog/
 | 
						|
    dogs\=ps
 | 
						|
 0: dog
 | 
						|
    dogs\=ph
 | 
						|
Partial match: dogs
 | 
						|
 | 
						|
/Z(*F)Q|ZXY/
 | 
						|
    Z\=ps
 | 
						|
Partial match: Z
 | 
						|
\= Expect no match 
 | 
						|
    ZA\=ps
 | 
						|
No match
 | 
						|
    X\=ps
 | 
						|
No match
 | 
						|
 | 
						|
/\bthe cat\b/
 | 
						|
    the cat\=ps
 | 
						|
 0: the cat
 | 
						|
    the cat\=ph
 | 
						|
Partial match: the cat
 | 
						|
 | 
						|
/dog(sbody)?/
 | 
						|
    dogs\=ps
 | 
						|
 0: dog
 | 
						|
    body\=dfa_restart
 | 
						|
 0: body
 | 
						|
 | 
						|
/dog(sbody)?/
 | 
						|
    dogs\=ph
 | 
						|
Partial match: dogs
 | 
						|
    body\=dfa_restart
 | 
						|
 0: body
 | 
						|
 | 
						|
/abc/
 | 
						|
   abc\=ps
 | 
						|
 0: abc
 | 
						|
   abc\=ph
 | 
						|
 0: abc
 | 
						|
 | 
						|
/abc\K123/
 | 
						|
    xyzabc123pqr
 | 
						|
Failed: error -42: pattern contains an item that is not supported for DFA matching
 | 
						|
    
 | 
						|
/(?<=abc)123/
 | 
						|
    xyzabc123pqr 
 | 
						|
 0: 123
 | 
						|
    xyzabc12\=ps
 | 
						|
Partial match: abc12
 | 
						|
               <<<
 | 
						|
    xyzabc12\=ph
 | 
						|
Partial match: abc12
 | 
						|
               <<<
 | 
						|
 | 
						|
/\babc\b/
 | 
						|
    +++abc+++
 | 
						|
 0: abc
 | 
						|
    +++ab\=ps
 | 
						|
Partial match: +ab
 | 
						|
               <
 | 
						|
    +++ab\=ph
 | 
						|
Partial match: +ab
 | 
						|
               <
 | 
						|
 | 
						|
/(?=C)/g,aftertext
 | 
						|
    ABCDECBA
 | 
						|
 0: 
 | 
						|
 0+ CDECBA
 | 
						|
 0: 
 | 
						|
 0+ CBA
 | 
						|
 | 
						|
/(abc|def|xyz)/I
 | 
						|
Capturing subpattern count = 1
 | 
						|
Starting code units: a d x 
 | 
						|
Subject length lower bound = 3
 | 
						|
    terhjk;abcdaadsfe
 | 
						|
 0: abc
 | 
						|
    the quick xyz brown fox 
 | 
						|
 0: xyz
 | 
						|
\= Expect no match
 | 
						|
    thejk;adlfj aenjl;fda asdfasd ehj;kjxyasiupd
 | 
						|
No match
 | 
						|
 | 
						|
/(abc|def|xyz)/I,no_start_optimize
 | 
						|
Capturing subpattern count = 1
 | 
						|
Options: no_start_optimize
 | 
						|
Subject length lower bound = 0
 | 
						|
    terhjk;abcdaadsfe
 | 
						|
 0: abc
 | 
						|
    the quick xyz brown fox
 | 
						|
 0: xyz
 | 
						|
\= Expect no match
 | 
						|
    thejk;adlfj aenjl;fda asdfasd ehj;kjxyasiupd
 | 
						|
No match
 | 
						|
 | 
						|
/abcd*/aftertext
 | 
						|
    xxxxabcd\=ps
 | 
						|
 0: abcd
 | 
						|
 0+ 
 | 
						|
    xxxxabcd\=ph
 | 
						|
Partial match: abcd
 | 
						|
    dddxxx\=dfa_restart
 | 
						|
 0: ddd
 | 
						|
 0+ xxx
 | 
						|
    xxxxabcd\=ph
 | 
						|
Partial match: abcd
 | 
						|
    xxx\=dfa_restart
 | 
						|
 0: 
 | 
						|
 0+ xxx
 | 
						|
 | 
						|
/abcd*/i
 | 
						|
    xxxxabcd\=ps
 | 
						|
 0: abcd
 | 
						|
    xxxxabcd\=ph
 | 
						|
Partial match: abcd
 | 
						|
    XXXXABCD\=ps
 | 
						|
 0: ABCD
 | 
						|
    XXXXABCD\=ph
 | 
						|
Partial match: ABCD
 | 
						|
 | 
						|
/abc\d*/
 | 
						|
    xxxxabc1\=ps
 | 
						|
 0: abc1
 | 
						|
    xxxxabc1\=ph
 | 
						|
Partial match: abc1
 | 
						|
 | 
						|
/abc[de]*/
 | 
						|
    xxxxabcde\=ps
 | 
						|
 0: abcde
 | 
						|
    xxxxabcde\=ph
 | 
						|
Partial match: abcde
 | 
						|
 | 
						|
/(?:(?1)|B)(A(*F)|C)/
 | 
						|
    ABCD
 | 
						|
 0: BC
 | 
						|
    CCD
 | 
						|
 0: CC
 | 
						|
\= Expect no match
 | 
						|
    CAD   
 | 
						|
No match
 | 
						|
 | 
						|
/^(?:(?1)|B)(A(*F)|C)/
 | 
						|
    CCD
 | 
						|
 0: CC
 | 
						|
    BCD 
 | 
						|
 0: BC
 | 
						|
\= Expect no match
 | 
						|
    ABCD
 | 
						|
No match
 | 
						|
    CAD
 | 
						|
No match
 | 
						|
    BAD    
 | 
						|
No match
 | 
						|
 | 
						|
/^(?!a(*SKIP)b)/
 | 
						|
    ac
 | 
						|
Failed: error -42: pattern contains an item that is not supported for DFA matching
 | 
						|
    
 | 
						|
/^(?=a(*SKIP)b|ac)/
 | 
						|
    ac
 | 
						|
Failed: error -42: pattern contains an item that is not supported for DFA matching
 | 
						|
    
 | 
						|
/^(?=a(*THEN)b|ac)/
 | 
						|
    ac
 | 
						|
Failed: error -42: pattern contains an item that is not supported for DFA matching
 | 
						|
    
 | 
						|
/^(?=a(*PRUNE)b)/
 | 
						|
    ab  
 | 
						|
Failed: error -42: pattern contains an item that is not supported for DFA matching
 | 
						|
 | 
						|
/^(?(?!a(*SKIP)b))/
 | 
						|
    ac
 | 
						|
Failed: error -42: pattern contains an item that is not supported for DFA matching
 | 
						|
 | 
						|
/(?<=abc)def/
 | 
						|
    abc\=ph
 | 
						|
Partial match: abc
 | 
						|
               <<<
 | 
						|
 | 
						|
/abc$/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    abc\=ps
 | 
						|
 0: abc
 | 
						|
    abc\=ph
 | 
						|
Partial match: abc
 | 
						|
 | 
						|
/abc$/m
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    abc\n
 | 
						|
 0: abc
 | 
						|
    abc\=ph
 | 
						|
Partial match: abc
 | 
						|
    abc\n\=ph
 | 
						|
 0: abc
 | 
						|
    abc\=ps
 | 
						|
 0: abc
 | 
						|
    abc\n\=ps
 | 
						|
 0: abc
 | 
						|
 | 
						|
/abc\z/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    abc\=ps
 | 
						|
 0: abc
 | 
						|
    abc\=ph
 | 
						|
Partial match: abc
 | 
						|
 | 
						|
/abc\Z/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    abc\=ps
 | 
						|
 0: abc
 | 
						|
    abc\=ph
 | 
						|
Partial match: abc
 | 
						|
 | 
						|
/abc\b/
 | 
						|
    abc
 | 
						|
 0: abc
 | 
						|
    abc\=ps
 | 
						|
 0: abc
 | 
						|
    abc\=ph
 | 
						|
Partial match: abc
 | 
						|
 | 
						|
/abc\B/
 | 
						|
    abc\=ps
 | 
						|
Partial match: abc
 | 
						|
    abc\=ph
 | 
						|
Partial match: abc
 | 
						|
\= Expect no match 
 | 
						|
    abc
 | 
						|
No match
 | 
						|
 | 
						|
/.+/
 | 
						|
    abc\=offset=0
 | 
						|
 0: abc
 | 
						|
    abc\=offset=1
 | 
						|
 0: bc
 | 
						|
    abc\=offset=2
 | 
						|
 0: c
 | 
						|
\= Bad offsets
 | 
						|
    abc\=offset=4
 | 
						|
Failed: error -33: bad offset value
 | 
						|
    abc\=offset=-4 
 | 
						|
** Invalid value in 'offset=-4'
 | 
						|
\= Expect no match 
 | 
						|
    abc\=offset=3
 | 
						|
No match
 | 
						|
 | 
						|
/^(?:a)++\w/
 | 
						|
     aaaab
 | 
						|
 0: aaaab
 | 
						|
\= Expect no match 
 | 
						|
     aaaa 
 | 
						|
No match
 | 
						|
     bbb 
 | 
						|
No match
 | 
						|
 | 
						|
/^(?:aa|(?:a)++\w)/
 | 
						|
     aaaab
 | 
						|
 0: aaaab
 | 
						|
 1: aa
 | 
						|
     aaaa 
 | 
						|
 0: aa
 | 
						|
\= Expect no match 
 | 
						|
     bbb 
 | 
						|
No match
 | 
						|
 | 
						|
/^(?:a)*+\w/
 | 
						|
     aaaab
 | 
						|
 0: aaaab
 | 
						|
     bbb 
 | 
						|
 0: b
 | 
						|
\= Expect no match 
 | 
						|
     aaaa 
 | 
						|
No match
 | 
						|
 | 
						|
/^(a)++\w/
 | 
						|
     aaaab
 | 
						|
 0: aaaab
 | 
						|
\= Expect no match 
 | 
						|
     aaaa 
 | 
						|
No match
 | 
						|
     bbb 
 | 
						|
No match
 | 
						|
 | 
						|
/^(a|)++\w/
 | 
						|
     aaaab
 | 
						|
 0: aaaab
 | 
						|
\= Expect no match 
 | 
						|
     aaaa 
 | 
						|
No match
 | 
						|
     bbb 
 | 
						|
No match
 | 
						|
 | 
						|
/(?=abc){3}abc/aftertext
 | 
						|
    abcabcabc
 | 
						|
 0: abc
 | 
						|
 0+ abcabc
 | 
						|
\= Expect no match
 | 
						|
    xyz  
 | 
						|
No match
 | 
						|
    
 | 
						|
/(?=abc)+abc/aftertext
 | 
						|
    abcabcabc
 | 
						|
 0: abc
 | 
						|
 0+ abcabc
 | 
						|
\= Expect no match
 | 
						|
    xyz  
 | 
						|
No match
 | 
						|
    
 | 
						|
/(?=abc)++abc/aftertext
 | 
						|
    abcabcabc
 | 
						|
 0: abc
 | 
						|
 0+ abcabc
 | 
						|
\= Expect no match
 | 
						|
    xyz  
 | 
						|
No match
 | 
						|
    
 | 
						|
/(?=abc){0}xyz/
 | 
						|
    xyz 
 | 
						|
 0: xyz
 | 
						|
 | 
						|
/(?=abc){1}xyz/
 | 
						|
\= Expect no match
 | 
						|
    xyz 
 | 
						|
No match
 | 
						|
    
 | 
						|
/(?=(a))?./
 | 
						|
    ab
 | 
						|
 0: a
 | 
						|
    bc
 | 
						|
 0: b
 | 
						|
      
 | 
						|
/(?=(a))??./
 | 
						|
    ab
 | 
						|
 0: a
 | 
						|
    bc
 | 
						|
 0: b
 | 
						|
 | 
						|
/^(?=(a)){0}b(?1)/
 | 
						|
    backgammon
 | 
						|
 0: ba
 | 
						|
 | 
						|
/^(?=(?1))?[az]([abc])d/
 | 
						|
    abd 
 | 
						|
 0: abd
 | 
						|
    zcdxx 
 | 
						|
 0: zcd
 | 
						|
 | 
						|
/^(?!a){0}\w+/
 | 
						|
    aaaaa
 | 
						|
 0: aaaaa
 | 
						|
 | 
						|
/(?<=(abc))?xyz/
 | 
						|
    abcxyz
 | 
						|
 0: xyz
 | 
						|
    pqrxyz 
 | 
						|
 0: xyz
 | 
						|
 | 
						|
/((?2))((?1))/
 | 
						|
    abc
 | 
						|
Failed: error -52: nested recursion at the same subject position
 | 
						|
 | 
						|
/(?(R)a+|(?R)b)/
 | 
						|
    aaaabcde
 | 
						|
 0: aaaab
 | 
						|
 | 
						|
/(?(R)a+|((?R))b)/
 | 
						|
    aaaabcde
 | 
						|
 0: aaaab
 | 
						|
 | 
						|
/((?(R)a+|(?1)b))/
 | 
						|
    aaaabcde
 | 
						|
 0: aaaab
 | 
						|
 | 
						|
/((?(R2)a+|(?1)b))()/
 | 
						|
    aaaabcde
 | 
						|
Failed: error -40: backreference condition or recursion test is not supported for DFA matching
 | 
						|
 | 
						|
/(?(R)a*(?1)|((?R))b)/
 | 
						|
    aaaabcde
 | 
						|
Failed: error -52: nested recursion at the same subject position
 | 
						|
 | 
						|
/(a+)/no_auto_possess
 | 
						|
    aaaa\=ovector=3
 | 
						|
Matched, but offsets vector is too small to show all matches
 | 
						|
 0: aaaa
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
    aaaa\=ovector=4
 | 
						|
 0: aaaa
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
 3: a
 | 
						|
 | 
						|
/^\R/
 | 
						|
    \r\=ps
 | 
						|
 0: \x0d
 | 
						|
    \r\=ph
 | 
						|
Partial match: \x0d
 | 
						|
    
 | 
						|
/^\R{2,3}x/
 | 
						|
    \r\=ps
 | 
						|
Partial match: \x0d
 | 
						|
    \r\=ph
 | 
						|
Partial match: \x0d
 | 
						|
    \r\r\=ps
 | 
						|
Partial match: \x0d\x0d
 | 
						|
    \r\r\=ph
 | 
						|
Partial match: \x0d\x0d
 | 
						|
    \r\r\r\=ps
 | 
						|
Partial match: \x0d\x0d\x0d
 | 
						|
    \r\r\r\=ph
 | 
						|
Partial match: \x0d\x0d\x0d
 | 
						|
    \r\rx
 | 
						|
 0: \x0d\x0dx
 | 
						|
    \r\r\rx    
 | 
						|
 0: \x0d\x0d\x0dx
 | 
						|
 | 
						|
/^\R{2,3}?x/
 | 
						|
    \r\=ps
 | 
						|
Partial match: \x0d
 | 
						|
    \r\=ph
 | 
						|
Partial match: \x0d
 | 
						|
    \r\r\=ps
 | 
						|
Partial match: \x0d\x0d
 | 
						|
    \r\r\=ph
 | 
						|
Partial match: \x0d\x0d
 | 
						|
    \r\r\r\=ps
 | 
						|
Partial match: \x0d\x0d\x0d
 | 
						|
    \r\r\r\=ph
 | 
						|
Partial match: \x0d\x0d\x0d
 | 
						|
    \r\rx
 | 
						|
 0: \x0d\x0dx
 | 
						|
    \r\r\rx    
 | 
						|
 0: \x0d\x0d\x0dx
 | 
						|
    
 | 
						|
/^\R?x/
 | 
						|
    \r\=ps
 | 
						|
Partial match: \x0d
 | 
						|
    \r\=ph
 | 
						|
Partial match: \x0d
 | 
						|
    x
 | 
						|
 0: x
 | 
						|
    \rx  
 | 
						|
 0: \x0dx
 | 
						|
 | 
						|
/^\R+x/
 | 
						|
    \r\=ps
 | 
						|
Partial match: \x0d
 | 
						|
    \r\=ph
 | 
						|
Partial match: \x0d
 | 
						|
    \r\n\=ps
 | 
						|
Partial match: \x0d\x0a
 | 
						|
    \r\n\=ph
 | 
						|
Partial match: \x0d\x0a
 | 
						|
    \rx  
 | 
						|
 0: \x0dx
 | 
						|
 | 
						|
/^a$/newline=crlf
 | 
						|
    a\r\=ps
 | 
						|
Partial match: a\x0d
 | 
						|
    a\r\=ph
 | 
						|
Partial match: a\x0d
 | 
						|
 | 
						|
/^a$/m,newline=crlf
 | 
						|
    a\r\=ps
 | 
						|
Partial match: a\x0d
 | 
						|
    a\r\=ph
 | 
						|
Partial match: a\x0d
 | 
						|
 | 
						|
/^(a$|a\r)/newline=crlf
 | 
						|
    a\r\=ps
 | 
						|
 0: a\x0d
 | 
						|
    a\r\=ph
 | 
						|
Partial match: a\x0d
 | 
						|
 | 
						|
/^(a$|a\r)/m,newline=crlf
 | 
						|
    a\r\=ps
 | 
						|
 0: a\x0d
 | 
						|
    a\r\=ph
 | 
						|
Partial match: a\x0d
 | 
						|
 | 
						|
/./newline=crlf
 | 
						|
    \r\=ps
 | 
						|
 0: \x0d
 | 
						|
    \r\=ph
 | 
						|
Partial match: \x0d
 | 
						|
  
 | 
						|
/.{2,3}/newline=crlf
 | 
						|
    \r\=ps
 | 
						|
Partial match: \x0d
 | 
						|
    \r\=ph
 | 
						|
Partial match: \x0d
 | 
						|
    \r\r\=ps
 | 
						|
 0: \x0d\x0d
 | 
						|
    \r\r\=ph
 | 
						|
Partial match: \x0d\x0d
 | 
						|
    \r\r\r\=ps
 | 
						|
 0: \x0d\x0d\x0d
 | 
						|
    \r\r\r\=ph
 | 
						|
Partial match: \x0d\x0d\x0d
 | 
						|
 | 
						|
/.{2,3}?/newline=crlf
 | 
						|
    \r\=ps
 | 
						|
Partial match: \x0d
 | 
						|
    \r\=ph
 | 
						|
Partial match: \x0d
 | 
						|
    \r\r\=ps
 | 
						|
 0: \x0d\x0d
 | 
						|
    \r\r\=ph
 | 
						|
Partial match: \x0d\x0d
 | 
						|
    \r\r\r\=ps
 | 
						|
 0: \x0d\x0d\x0d
 | 
						|
 1: \x0d\x0d
 | 
						|
    \r\r\r\=ph
 | 
						|
Partial match: \x0d\x0d\x0d
 | 
						|
 | 
						|
# Test simple validity check for restarts 
 | 
						|
 | 
						|
/abcdef/
 | 
						|
   abc\=dfa_restart
 | 
						|
Failed: error -38: invalid data in workspace for DFA restart
 | 
						|
 | 
						|
/<H((?(?!<H|F>)(.)|(?R))++)*F>/
 | 
						|
    text <H more text <H texting more  hexA0-"\xA0"    hex above 7F-"\xBC" F> text xxxxx <H text F> text F> text2 <H text sample F> more text.
 | 
						|
 0: <H more text <H texting more  hexA0-"\xa0"    hex above 7F-"\xbc" F> text xxxxx <H text F> text F>
 | 
						|
 | 
						|
/^(?>.{4})abc|^\w\w.xabcd/
 | 
						|
    xxxxabcd
 | 
						|
 0: xxxxabcd
 | 
						|
 1: xxxxabc
 | 
						|
    xx\xa0xabcd 
 | 
						|
 0: xx\xa0xabcd
 | 
						|
 1: xx\xa0xabc
 | 
						|
 | 
						|
/^(.{4}){2}+abc|^\w\w.x\w\w\w\wabcd/
 | 
						|
    xxxxxxxxabcd
 | 
						|
 0: xxxxxxxxabcd
 | 
						|
 1: xxxxxxxxabc
 | 
						|
    xx\xa0xxxxxabcd 
 | 
						|
 0: xx\xa0xxxxxabcd
 | 
						|
 1: xx\xa0xxxxxabc
 | 
						|
 | 
						|
/abcd/
 | 
						|
    abcd\=ovector=0
 | 
						|
 0: abcd
 | 
						|
 | 
						|
# These tests show up auto-possessification 
 | 
						|
 | 
						|
/[ab]*/
 | 
						|
    aaaa
 | 
						|
 0: aaaa
 | 
						|
    
 | 
						|
/[ab]*?/
 | 
						|
    aaaa
 | 
						|
 0: aaaa
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
 3: a
 | 
						|
 4: 
 | 
						|
    
 | 
						|
/[ab]?/
 | 
						|
    aaaa
 | 
						|
 0: a
 | 
						|
    
 | 
						|
/[ab]??/
 | 
						|
    aaaa
 | 
						|
 0: a
 | 
						|
 1: 
 | 
						|
    
 | 
						|
/[ab]+/
 | 
						|
    aaaa
 | 
						|
 0: aaaa
 | 
						|
    
 | 
						|
/[ab]+?/
 | 
						|
    aaaa
 | 
						|
 0: aaaa
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
 3: a
 | 
						|
    
 | 
						|
/[ab]{2,3}/
 | 
						|
    aaaa
 | 
						|
 0: aaa
 | 
						|
    
 | 
						|
/[ab]{2,3}?/
 | 
						|
    aaaa
 | 
						|
 0: aaa
 | 
						|
 1: aa
 | 
						|
    
 | 
						|
/[ab]{2,}/
 | 
						|
    aaaa    
 | 
						|
 0: aaaa
 | 
						|
 | 
						|
/[ab]{2,}?/
 | 
						|
    aaaa    
 | 
						|
 0: aaaa
 | 
						|
 1: aaa
 | 
						|
 2: aa
 | 
						|
 | 
						|
'\A(?:[^\"]++|\"(?:[^\"]*+|\"\")*+\")++'
 | 
						|
    NON QUOTED \"QUOT\"\"ED\" AFTER \"NOT MATCHED
 | 
						|
 0: NON QUOTED "QUOT""ED" AFTER 
 | 
						|
 | 
						|
'\A(?:[^\"]++|\"(?:[^\"]++|\"\")*+\")++'
 | 
						|
    NON QUOTED \"QUOT\"\"ED\" AFTER \"NOT MATCHED
 | 
						|
 0: NON QUOTED "QUOT""ED" AFTER 
 | 
						|
 | 
						|
/abc(?=xyz)/allusedtext
 | 
						|
    abcxyzpqr
 | 
						|
 0: abcxyz
 | 
						|
       >>>
 | 
						|
    abcxyzpqr\=aftertext
 | 
						|
 0: abcxyz
 | 
						|
       >>>
 | 
						|
 0+ xyzpqr
 | 
						|
    
 | 
						|
/(?<=pqr)abc(?=xyz)/allusedtext
 | 
						|
    xyzpqrabcxyzpqr
 | 
						|
 0: pqrabcxyz
 | 
						|
    <<<   >>>
 | 
						|
    xyzpqrabcxyzpqr\=aftertext
 | 
						|
 0: pqrabcxyz
 | 
						|
    <<<   >>>
 | 
						|
 0+ xyzpqr
 | 
						|
    
 | 
						|
/a\b/
 | 
						|
    a.\=allusedtext
 | 
						|
 0: a.
 | 
						|
     >
 | 
						|
    a\=allusedtext  
 | 
						|
 0: a
 | 
						|
 | 
						|
/abc(?=abcde)(?=ab)/allusedtext
 | 
						|
    abcabcdefg
 | 
						|
 0: abcabcde
 | 
						|
       >>>>>
 | 
						|
 | 
						|
/a*?b*?/
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 1: a
 | 
						|
 2: 
 | 
						|
 | 
						|
/(*NOTEMPTY)a*?b*?/
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 1: a
 | 
						|
    ba
 | 
						|
 0: b
 | 
						|
    cb  
 | 
						|
 0: b
 | 
						|
 | 
						|
/(*NOTEMPTY_ATSTART)a*?b*?/aftertext
 | 
						|
    ab
 | 
						|
 0: ab
 | 
						|
 0+ 
 | 
						|
 1: a
 | 
						|
    cdab 
 | 
						|
 0: 
 | 
						|
 0+ dab
 | 
						|
 | 
						|
/(a)(b)|(c)/
 | 
						|
    XcX\=ovector=2,get=1,get=2,get=3,get=4,getall
 | 
						|
 0: c
 | 
						|
Get substring 1 failed (-55): requested value is not set
 | 
						|
Get substring 2 failed (-54): requested value is not available
 | 
						|
Get substring 3 failed (-54): requested value is not available
 | 
						|
Get substring 4 failed (-54): requested value is not available
 | 
						|
 0L c
 | 
						|
 | 
						|
/(?<A>aa)/
 | 
						|
    aa\=get=A
 | 
						|
 0: aa
 | 
						|
Get substring 'A' failed (-41): function is not supported for DFA matching
 | 
						|
    aa\=copy=A 
 | 
						|
 0: aa
 | 
						|
Copy substring 'A' failed (-41): function is not supported for DFA matching
 | 
						|
 | 
						|
/a+/no_auto_possess
 | 
						|
    a\=ovector=2,get=1,get=2,getall
 | 
						|
 0: a
 | 
						|
Get substring 1 failed (-55): requested value is not set
 | 
						|
Get substring 2 failed (-54): requested value is not available
 | 
						|
 0L a
 | 
						|
    aaa\=ovector=2,get=1,get=2,getall
 | 
						|
Matched, but offsets vector is too small to show all matches
 | 
						|
 0: aaa
 | 
						|
 1: aa
 | 
						|
 1G aa (2)
 | 
						|
Get substring 2 failed (-54): requested value is not available
 | 
						|
 0L aaa
 | 
						|
 1L aa
 | 
						|
 | 
						|
/a(b)c(d)/
 | 
						|
    abc\=ph,copy=0,copy=1,getall
 | 
						|
Partial match: abc
 | 
						|
 0C abc (3)
 | 
						|
Copy substring 1 failed (-2): partial match
 | 
						|
get substring list failed (-2): partial match
 | 
						|
 | 
						|
/ab(?C" any text with spaces ")cde/B
 | 
						|
------------------------------------------------------------------
 | 
						|
        Bra
 | 
						|
        ab
 | 
						|
        CalloutStr " any text with spaces " 6 30 1
 | 
						|
        cde
 | 
						|
        Ket
 | 
						|
        End
 | 
						|
------------------------------------------------------------------
 | 
						|
    abcde
 | 
						|
Callout (6): " any text with spaces "
 | 
						|
--->abcde
 | 
						|
    ^ ^       c
 | 
						|
 0: abcde
 | 
						|
    12abcde
 | 
						|
Callout (6): " any text with spaces "
 | 
						|
--->12abcde
 | 
						|
      ^ ^       c
 | 
						|
 0: abcde
 | 
						|
 | 
						|
/^a(b)c(?C1)def/
 | 
						|
      abcdef
 | 
						|
--->abcdef
 | 
						|
  1 ^  ^       d
 | 
						|
 0: abcdef
 | 
						|
 | 
						|
/^a(b)c(?C"AB")def/
 | 
						|
      abcdef
 | 
						|
Callout (10): "AB"
 | 
						|
--->abcdef
 | 
						|
    ^  ^       d
 | 
						|
 0: abcdef
 | 
						|
 | 
						|
/^a(b)c(?C1)def/
 | 
						|
      abcdef\=callout_capture
 | 
						|
Callout 1: last capture = 0
 | 
						|
 0: 
 | 
						|
--->abcdef
 | 
						|
    ^  ^       d
 | 
						|
 0: abcdef
 | 
						|
 | 
						|
/^a(b)c(?C{AB})def/B
 | 
						|
------------------------------------------------------------------
 | 
						|
        Bra
 | 
						|
        ^
 | 
						|
        a
 | 
						|
        CBra 1
 | 
						|
        b
 | 
						|
        Ket
 | 
						|
        c
 | 
						|
        CalloutStr {AB} 10 14 1
 | 
						|
        def
 | 
						|
        Ket
 | 
						|
        End
 | 
						|
------------------------------------------------------------------
 | 
						|
      abcdef\=callout_capture
 | 
						|
Callout (10): {AB} last capture = 0
 | 
						|
 0: 
 | 
						|
--->abcdef
 | 
						|
    ^  ^       d
 | 
						|
 0: abcdef
 | 
						|
 | 
						|
/^(?(?C25)(?=abc)abcd|xyz)/B
 | 
						|
------------------------------------------------------------------
 | 
						|
        Bra
 | 
						|
        ^
 | 
						|
        Cond
 | 
						|
        Callout 25 9 3
 | 
						|
        Assert
 | 
						|
        abc
 | 
						|
        Ket
 | 
						|
        abcd
 | 
						|
        Alt
 | 
						|
        xyz
 | 
						|
        Ket
 | 
						|
        Ket
 | 
						|
        End
 | 
						|
------------------------------------------------------------------
 | 
						|
    abcdefg
 | 
						|
--->abcdefg
 | 
						|
 25 ^           (?=
 | 
						|
 0: abcd
 | 
						|
    xyz123 
 | 
						|
--->xyz123
 | 
						|
 25 ^          (?=
 | 
						|
 0: xyz
 | 
						|
 | 
						|
/^(?(?C$abc$)(?=abc)abcd|xyz)/B
 | 
						|
------------------------------------------------------------------
 | 
						|
        Bra
 | 
						|
        ^
 | 
						|
        Cond
 | 
						|
        CalloutStr $abc$ 7 12 3
 | 
						|
        Assert
 | 
						|
        abc
 | 
						|
        Ket
 | 
						|
        abcd
 | 
						|
        Alt
 | 
						|
        xyz
 | 
						|
        Ket
 | 
						|
        Ket
 | 
						|
        End
 | 
						|
------------------------------------------------------------------
 | 
						|
    abcdefg
 | 
						|
Callout (7): $abc$
 | 
						|
--->abcdefg
 | 
						|
    ^           (?=
 | 
						|
 0: abcd
 | 
						|
    xyz123 
 | 
						|
Callout (7): $abc$
 | 
						|
--->xyz123
 | 
						|
    ^          (?=
 | 
						|
 0: xyz
 | 
						|
 | 
						|
/^ab(?C'first')cd(?C"second")ef/
 | 
						|
    abcdefg
 | 
						|
Callout (7): 'first'
 | 
						|
--->abcdefg
 | 
						|
    ^ ^         c
 | 
						|
Callout (20): "second"
 | 
						|
--->abcdefg
 | 
						|
    ^   ^       e
 | 
						|
 0: abcdef
 | 
						|
 | 
						|
/(?:a(?C`code`)){3}X/
 | 
						|
    aaaXY
 | 
						|
Callout (8): `code`
 | 
						|
--->aaaXY
 | 
						|
    ^^        ){3}
 | 
						|
Callout (8): `code`
 | 
						|
--->aaaXY
 | 
						|
    ^ ^       ){3}
 | 
						|
Callout (8): `code`
 | 
						|
--->aaaXY
 | 
						|
    ^  ^      ){3}
 | 
						|
 0: aaaX
 | 
						|
 | 
						|
# Binary zero in callout string
 | 
						|
/"a(?C'x" 00 "z')b"/hex
 | 
						|
    abcdefgh
 | 
						|
Callout (5): 'x\x00z'
 | 
						|
--->abcdefgh
 | 
						|
    ^^           b
 | 
						|
 0: ab
 | 
						|
 | 
						|
/(?(?!)a|b)/
 | 
						|
    bbb
 | 
						|
 0: b
 | 
						|
\= Expect no match
 | 
						|
    aaa 
 | 
						|
No match
 | 
						|
 | 
						|
/^/gm
 | 
						|
    \n\n\n
 | 
						|
 0: 
 | 
						|
 0: 
 | 
						|
 0: 
 | 
						|
 | 
						|
/^/gm,alt_circumflex
 | 
						|
    \n\n\n
 | 
						|
 0: 
 | 
						|
 0: 
 | 
						|
 0: 
 | 
						|
 0: 
 | 
						|
 | 
						|
/abc/use_offset_limit
 | 
						|
    1234abcde\=offset_limit=100
 | 
						|
 0: abc
 | 
						|
    1234abcde\=offset_limit=9
 | 
						|
 0: abc
 | 
						|
    1234abcde\=offset_limit=4
 | 
						|
 0: abc
 | 
						|
    1234abcde\=offset_limit=4,offset=4
 | 
						|
 0: abc
 | 
						|
\= Expect no match
 | 
						|
    1234abcde\=offset_limit=4,offset=5
 | 
						|
No match
 | 
						|
    1234abcde\=offset_limit=3
 | 
						|
No match
 | 
						|
 | 
						|
/(?<=abc)/use_offset_limit
 | 
						|
    1234abc\=offset_limit=7
 | 
						|
 0: 
 | 
						|
\= Expect no match
 | 
						|
    1234abc\=offset_limit=6
 | 
						|
No match
 | 
						|
 | 
						|
/abcd/null_context
 | 
						|
    abcd\=null_context
 | 
						|
 0: abcd
 | 
						|
 | 
						|
/()()a+/no_auto_possess
 | 
						|
    aaa\=allcaptures
 | 
						|
** Ignored after DFA matching: allcaptures
 | 
						|
 0: aaa
 | 
						|
 1: aa
 | 
						|
 2: a
 | 
						|
    a\=allcaptures
 | 
						|
** Ignored after DFA matching: allcaptures
 | 
						|
 0: a
 | 
						|
 | 
						|
/(*LIMIT_RECURSION=100)^((.)(?1)|.)$/
 | 
						|
\= Expect recursion limit exceeded
 | 
						|
    a[00]([00]([00]([00]([00]([00]([00]([00]([00]([00]([00]([00]([00]([00]([00]([00]([00]([00]([00]([00]([00]([00]([00]([00]
 | 
						|
Failed: error -53: recursion limit exceeded
 | 
						|
 | 
						|
# End of testinput6
 |