202 lines
3.2 KiB
Plaintext
202 lines
3.2 KiB
Plaintext
# This test is run only when JIT support is available. It checks JIT complete
|
|
# and partial modes, and things that are different with JIT.
|
|
|
|
#pattern jitverify
|
|
|
|
# JIT does not support this pattern (callout at start of condition).
|
|
|
|
/(?(?C1)(?=a)a)/I
|
|
|
|
# Check that an infinite recursion loop is caught.
|
|
|
|
/(?(R)a*(?1)|((?R))b)/
|
|
aaaabcde
|
|
|
|
/abcd/I
|
|
abcd
|
|
xyz
|
|
|
|
/(*NO_JIT)abcd/I
|
|
abcd
|
|
xyz
|
|
|
|
/abcd/
|
|
abcd
|
|
ab\=ps
|
|
ab\=ph
|
|
xyz
|
|
|
|
/abcd/jitfast
|
|
abcd
|
|
ab\=ps
|
|
ab\=ph
|
|
xyz
|
|
|
|
/abcd/jit=1
|
|
abcd
|
|
ab\=ps
|
|
ab\=ph
|
|
xyz
|
|
xyz\=ps
|
|
|
|
/abcd/jit=1,jitfast
|
|
abcd
|
|
ab\=ps
|
|
ab\=ph
|
|
xyz
|
|
xyz\=ps
|
|
|
|
/abcd/jit=2
|
|
abcd
|
|
ab\=ps
|
|
ab\=ph
|
|
xyz
|
|
|
|
/abcd/jit=2,jitfast
|
|
abcd
|
|
ab\=ps
|
|
ab\=ph
|
|
xyz
|
|
|
|
/abcd/jit=3
|
|
abcd
|
|
ab\=ps
|
|
ab\=ph
|
|
xyz
|
|
|
|
/abcd/jit=4
|
|
abcd
|
|
ab\=ps
|
|
ab\=ph
|
|
xyz
|
|
|
|
/abcd/jit=5
|
|
abcd
|
|
ab\=ps
|
|
ab\=ph
|
|
xyz
|
|
|
|
/abcd/jit=6
|
|
abcd
|
|
ab\=ps
|
|
ab\=ph
|
|
xyz
|
|
|
|
/abcd/jit=7
|
|
abcd
|
|
ab\=ps
|
|
ab\=ph
|
|
xyz
|
|
|
|
/abcd/I,jit=2
|
|
|
|
/(*NO_START_OPT)a(*:m)b/mark
|
|
a
|
|
|
|
/^12345678abcd/m
|
|
12345678abcd
|
|
|
|
# Limits tests that give different output with JIT.
|
|
|
|
/(a+)*zz/I
|
|
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaazzbbbbbb\=find_limits
|
|
aaaaaaaaaaaaaz\=find_limits
|
|
|
|
!((?:\s|//.*\\n|/[*](?:\\n|.)*?[*]/)*)!I
|
|
/* this is a C style comment */\=find_limits
|
|
|
|
/^(?>a)++/
|
|
aa\=find_limits
|
|
aaaaaaaaa\=find_limits
|
|
|
|
/(a)(?1)++/
|
|
aa\=find_limits
|
|
aaaaaaaaa\=find_limits
|
|
|
|
/a(?:.)*?a/ims
|
|
abbbbbbbbbbbbbbbbbbbbba\=find_limits
|
|
|
|
/a(?:.(*THEN))*?a/ims
|
|
abbbbbbbbbbbbbbbbbbbbba\=find_limits
|
|
|
|
/a(?:.(*THEN:ABC))*?a/ims
|
|
abbbbbbbbbbbbbbbbbbbbba\=find_limits
|
|
|
|
/^(?>a+)(?>b+)(?>c+)(?>d+)(?>e+)/
|
|
aabbccddee\=find_limits
|
|
|
|
/^(?>(a+))(?>(b+))(?>(c+))(?>(d+))(?>(e+))/
|
|
aabbccddee\=find_limits
|
|
|
|
/^(?>(a+))(?>b+)(?>(c+))(?>d+)(?>(e+))/
|
|
aabbccddee\=find_limits
|
|
|
|
/^(?>(a+))(?>b+)(?>(c+))(?>d+)(?>(e+))/jitfast
|
|
aabbccddee\=find_limits
|
|
aabbccddee\=jitstack=1
|
|
|
|
/(a+)*zz/
|
|
aaaaaaaaaaaaaz
|
|
aaaaaaaaaaaaaz\=match_limit=3000
|
|
|
|
/(*LIMIT_MATCH=3000)(a+)*zz/I
|
|
aaaaaaaaaaaaaz
|
|
aaaaaaaaaaaaaz\=match_limit=60000
|
|
|
|
/(*LIMIT_MATCH=60000)(*LIMIT_MATCH=3000)(a+)*zz/I
|
|
aaaaaaaaaaaaaz
|
|
|
|
/(*LIMIT_MATCH=60000)(a+)*zz/I
|
|
aaaaaaaaaaaaaz
|
|
aaaaaaaaaaaaaz\=match_limit=3000
|
|
|
|
# These three have infinitely nested recursions.
|
|
|
|
/((?2))((?1))/
|
|
abc
|
|
|
|
/((?(R2)a+|(?1)b))/
|
|
aaaabcde
|
|
|
|
/(?(R)a*(?1)|((?R))b)/
|
|
aaaabcde
|
|
|
|
# Invalid options disable JIT when called via pcre2_match(), causing the
|
|
# match to happen via the interpreter, but for fast JIT invalid options are
|
|
# ignored, so an unanchored match happens.
|
|
|
|
/abcd/
|
|
abcd\=anchored
|
|
fail abcd\=anchored
|
|
|
|
/abcd/jitfast
|
|
abcd\=anchored
|
|
succeed abcd\=anchored
|
|
|
|
# Push/pop does not lose the JIT information, though jitverify applies only to
|
|
# compilation, but serializing (save/load) discards JIT data completely.
|
|
|
|
/^abc\Kdef/info,push
|
|
#pop jitverify
|
|
abcdef
|
|
|
|
/^abc\Kdef/info,push
|
|
#save testsaved1
|
|
#load testsaved1
|
|
#pop jitverify
|
|
abcdef
|
|
|
|
#load testsaved1
|
|
#pop jit,jitverify
|
|
abcdef
|
|
|
|
# Test pattern compilation
|
|
|
|
/(?:a|b|c|d|e)(?R)/jit=1
|
|
|
|
/(?:a|b|c|d|e)(?R)(?R)/jit=1
|
|
|
|
/(a(?:a|b|c|d|e)b){8,16}/jit=1
|
|
|
|
# End of testinput16
|