# 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

/abcd/
    abcd
    ab\=ps
    ab\=ph
    xyz

/abcd/jit=1
    abcd
    ab\=ps
    ab\=ph
    xyz
    xyz\=ps

/abcd/jit=2
    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+)*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
    
# End of testinput16