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