1# These are: 2# 3# (1) Tests of the match-limiting features. The results are different for 4# interpretive or JIT matching, so this test should not be run with JIT. The 5# same tests are run using JIT in test 17. 6 7# (2) Other tests that must not be run with JIT. 8 9# These tests are first so that they don't inherit a large enough heap frame 10# vector from a previous test. 11 12/(*LIMIT_HEAP=21)\[(a)]{60}/expand 13 \[a]{60} 14 15"(*LIMIT_HEAP=21)()((?))()()()()()()()()()()()()()()()()()()()()()()()(())()()()()()()()()()()()()()()()()()()()()()(())()()()()()()()()()()()()()" 16 xx 17 18# ----------------------------------------------------------------------- 19 20/(a+)*zz/I 21 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaazzbbbbbb\=find_limits_noheap 22 aaaaaaaaaaaaaz\=find_limits_noheap 23 24!((?:\s|//.*\\n|/[*](?:\\n|.)*?[*]/)*)!I 25 /* this is a C style comment */\=find_limits_noheap 26 27/^(?>a)++/ 28 aa\=find_limits_noheap 29 aaaaaaaaa\=find_limits_noheap 30 31/(a)(?1)++/ 32 aa\=find_limits_noheap 33 aaaaaaaaa\=find_limits_noheap 34 35/a(?:.)*?a/ims 36 abbbbbbbbbbbbbbbbbbbbba\=find_limits_noheap 37 38/a(?:.(*THEN))*?a/ims 39 abbbbbbbbbbbbbbbbbbbbba\=find_limits_noheap 40 41/a(?:.(*THEN:ABC))*?a/ims 42 abbbbbbbbbbbbbbbbbbbbba\=find_limits_noheap 43 44/^(?>a+)(?>b+)(?>c+)(?>d+)(?>e+)/ 45 aabbccddee\=find_limits_noheap 46 47/^(?>(a+))(?>(b+))(?>(c+))(?>(d+))(?>(e+))/ 48 aabbccddee\=find_limits_noheap 49 50/^(?>(a+))(?>b+)(?>(c+))(?>d+)(?>(e+))/ 51 aabbccddee\=find_limits_noheap 52 53/(*LIMIT_MATCH=12bc)abc/ 54 55/(*LIMIT_MATCH=4294967290)abc/ 56 57/(*LIMIT_DEPTH=4294967280)abc/I 58 59/(a+)*zz/ 60\= Expect no match 61 aaaaaaaaaaaaaz 62\= Expect limit exceeded 63 aaaaaaaaaaaaaz\=match_limit=3000 64 65/(a+)*zz/ 66\= Expect limit exceeded 67 aaaaaaaaaaaaaz\=depth_limit=10 68 69/(*LIMIT_MATCH=3000)(a+)*zz/I 70\= Expect limit exceeded 71 aaaaaaaaaaaaaz 72\= Expect limit exceeded 73 aaaaaaaaaaaaaz\=match_limit=60000 74 75/(*LIMIT_MATCH=60000)(*LIMIT_MATCH=3000)(a+)*zz/I 76\= Expect limit exceeded 77 aaaaaaaaaaaaaz 78 79/(*LIMIT_MATCH=60000)(a+)*zz/I 80\= Expect no match 81 aaaaaaaaaaaaaz 82\= Expect limit exceeded 83 aaaaaaaaaaaaaz\=match_limit=3000 84 85/(*LIMIT_DEPTH=10)(a+)*zz/I 86\= Expect limit exceeded 87 aaaaaaaaaaaaaz 88\= Expect limit exceeded 89 aaaaaaaaaaaaaz\=depth_limit=1000 90 91/(*LIMIT_DEPTH=10)(*LIMIT_DEPTH=1000)(a+)*zz/I 92\= Expect no match 93 aaaaaaaaaaaaaz 94 95/(*LIMIT_DEPTH=1000)(a+)*zz/I 96\= Expect no match 97 aaaaaaaaaaaaaz 98\= Expect limit exceeded 99 aaaaaaaaaaaaaz\=depth_limit=10 100 101# These three have infinitely nested recursions. 102 103/((?2))((?1))/ 104 abc 105 106/((?(R2)a+|(?1)b))()/ 107 aaaabcde 108 109/(?(R)a*(?1)|((?R))b)/ 110 aaaabcde 111 112# The allusedtext modifier does not work with JIT, which does not maintain 113# the leftchar/rightchar data. 114 115/abc(?=xyz)/allusedtext 116 abcxyzpqr 117 abcxyzpqr\=aftertext 118 119/(?<=pqr)abc(?=xyz)/allusedtext 120 xyzpqrabcxyzpqr 121 xyzpqrabcxyzpqr\=aftertext 122 123/a\b/ 124 a.\=allusedtext 125 a\=allusedtext 126 127/abc\Kxyz/ 128 abcxyz\=allusedtext 129 130/abc(?=xyz(*ACCEPT))/ 131 abcxyz\=allusedtext 132 133/abc(?=abcde)(?=ab)/allusedtext 134 abcabcdefg 135 136#subject allusedtext 137 138/(?<=abc)123/ 139 xyzabc123pqr 140 xyzabc12\=ps 141 xyzabc12\=ph 142 143/\babc\b/ 144 +++abc+++ 145 +++ab\=ps 146 +++ab\=ph 147 148/(?<=abc)def/ 149 abc\=ph 150 151/(?<=123)(*MARK:xx)abc/mark 152 xxxx123a\=ph 153 xxxx123a\=ps 154 155/(?<=(?<=a)b)c.*/I 156 abc\=ph 157\= Expect no match 158 xbc\=ph 159 160/(?<=ab)c.*/I 161 abc\=ph 162\= Expect no match 163 xbc\=ph 164 165/abc(?<=bc)def/ 166 xxxabcd\=ph 167 168/(?<=ab)cdef/ 169 xxabcd\=ph 170 171/(?<=(?<=(?<=a)b)c)./I 172 123abcXYZ 173 174/(?<=ab(cd(?<=...)))./I 175 abcdX 176 177/(?<=ab((?<=...)cd))./I 178 ZabcdX 179 180/(?<=((?<=(?<=ab).))(?1)(?1))./I 181 abxZ 182 183#subject 184# ------------------------------------------------------------------- 185 186# These tests provoke recursion loops, which give a different error message 187# when JIT is used. 188 189/(?R)/I 190 abcd 191 192/(a|(?R))/I 193 abcd 194 defg 195 196/(ab|(bc|(de|(?R))))/I 197 abcd 198 fghi 199 200/(ab|(bc|(de|(?1))))/I 201 abcd 202 fghi 203 204/x(ab|(bc|(de|(?1)x)x)x)/I 205 xab123 206 xfghi 207 208/(?!\w)(?R)/ 209 abcd 210 =abc 211 212/(?=\w)(?R)/ 213 =abc 214 abcd 215 216/(?<!\w)(?R)/ 217 abcd 218 219/(?<=\w)(?R)/ 220 abcd 221 222/(a+|(?R)b)/ 223 aaa 224 bbb 225 226/[^\xff]((?1))/BI 227 abcd 228 229# These tests don't behave the same with JIT 230 231/\w+(?C1)/BI,no_auto_possess 232 abc\=callout_fail=1 233 234/(*NO_AUTO_POSSESS)\w+(?C1)/BI 235 abc\=callout_fail=1 236 237# This test breaks the JIT stack limit 238 239/(|]+){2,2452}/ 240 (|]+){2,2452} 241 242/b(?<!ax)(?!cx)/allusedtext 243 abc 244 abcz 245 246# This test triggers the recursion limit in the interpreter, but completes in 247# JIT. It's in testinput2 with disable_recurse_loop_check to get it to work 248# in the interpreter. 249 250/(a(?1)z||(?1)++)$/ 251 abcd 252 253# End of testinput15 254