chiark / gitweb /
Apply upstream revision 1631 (Closes: #815921)
[pcre3.git] / pcre_jit_test.c
1 /*************************************************
2 *      Perl-Compatible Regular Expressions       *
3 *************************************************/
4
5 /* PCRE is a library of functions to support regular expressions whose syntax
6 and semantics are as close as possible to those of the Perl 5 language.
7
8                   Main Library written by Philip Hazel
9            Copyright (c) 1997-2012 University of Cambridge
10
11   This JIT compiler regression test program was written by Zoltan Herczeg
12                       Copyright (c) 2010-2012
13
14 -----------------------------------------------------------------------------
15 Redistribution and use in source and binary forms, with or without
16 modification, are permitted provided that the following conditions are met:
17
18     * Redistributions of source code must retain the above copyright notice,
19       this list of conditions and the following disclaimer.
20
21     * Redistributions in binary form must reproduce the above copyright
22       notice, this list of conditions and the following disclaimer in the
23       documentation and/or other materials provided with the distribution.
24
25     * Neither the name of the University of Cambridge nor the names of its
26       contributors may be used to endorse or promote products derived from
27       this software without specific prior written permission.
28
29 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
30 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
33 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
34 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
35 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
36 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
37 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
38 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
39 POSSIBILITY OF SUCH DAMAGE.
40 -----------------------------------------------------------------------------
41 */
42
43 #ifdef HAVE_CONFIG_H
44 #include "config.h"
45 #endif
46
47 #include <stdio.h>
48 #include <string.h>
49 #include "pcre.h"
50
51
52 #include "pcre_internal.h"
53
54 /*
55  Letter characters:
56    \xe6\x92\xad = 0x64ad = 25773 (kanji)
57  Non-letter characters:
58    \xc2\xa1 = 0xa1 =  (Inverted Exclamation Mark)
59    \xf3\xa9\xb7\x80 = 0xe9dc0 = 957888
60    \xed\xa0\x80 = 55296 = 0xd800 (Invalid UTF character)
61    \xed\xb0\x80 = 56320 = 0xdc00 (Invalid UTF character)
62  Newlines:
63    \xc2\x85 = 0x85 = 133 (NExt Line = NEL)
64    \xe2\x80\xa8 = 0x2028 = 8232 (Line Separator)
65  Othercase pairs:
66    \xc3\xa9 = 0xe9 = 233 (e')
67       \xc3\x89 = 0xc9 = 201 (E')
68    \xc3\xa1 = 0xe1 = 225 (a')
69       \xc3\x81 = 0xc1 = 193 (A')
70    \x53 = 0x53 = S
71      \x73 = 0x73 = s
72      \xc5\xbf = 0x17f = 383 (long S)
73    \xc8\xba = 0x23a = 570
74       \xe2\xb1\xa5 = 0x2c65 = 11365
75    \xe1\xbd\xb8 = 0x1f78 = 8056
76       \xe1\xbf\xb8 = 0x1ff8 = 8184
77    \xf0\x90\x90\x80 = 0x10400 = 66560
78       \xf0\x90\x90\xa8 = 0x10428 = 66600
79    \xc7\x84 = 0x1c4 = 452
80      \xc7\x85 = 0x1c5 = 453
81      \xc7\x86 = 0x1c6 = 454
82  Caseless sets:
83    ucp_Armenian - \x{531}-\x{556} -> \x{561}-\x{586}
84    ucp_Coptic - \x{2c80}-\x{2ce3} -> caseless: XOR 0x1
85    ucp_Latin - \x{ff21}-\x{ff3a} -> \x{ff41]-\x{ff5a}
86
87  Mark property:
88    \xcc\x8d = 0x30d = 781
89  Special:
90    \xc2\x80 = 0x80 = 128 (lowest 2 byte character)
91    \xdf\xbf = 0x7ff = 2047 (highest 2 byte character)
92    \xe0\xa0\x80 = 0x800 = 2048 (lowest 2 byte character)
93    \xef\xbf\xbf = 0xffff = 65535 (highest 3 byte character)
94    \xf0\x90\x80\x80 = 0x10000 = 65536 (lowest 4 byte character)
95    \xf4\x8f\xbf\xbf = 0x10ffff = 1114111 (highest allowed utf character)
96 */
97
98 static int regression_tests(void);
99
100 int main(void)
101 {
102         int jit = 0;
103 #if defined SUPPORT_PCRE8
104         pcre_config(PCRE_CONFIG_JIT, &jit);
105 #elif defined SUPPORT_PCRE16
106         pcre16_config(PCRE_CONFIG_JIT, &jit);
107 #elif defined SUPPORT_PCRE32
108         pcre32_config(PCRE_CONFIG_JIT, &jit);
109 #endif
110         if (!jit) {
111                 printf("JIT must be enabled to run pcre_jit_test\n");
112                 return 1;
113         }
114         return regression_tests();
115 }
116
117 /* --------------------------------------------------------------------------------------- */
118
119 #if !(defined SUPPORT_PCRE8) && !(defined SUPPORT_PCRE16) && !(defined SUPPORT_PCRE32)
120 #error SUPPORT_PCRE8 or SUPPORT_PCRE16 or SUPPORT_PCRE32 must be defined
121 #endif
122
123 #define MUA     (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)
124 #define MUAP    (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)
125 #define CMUA    (PCRE_CASELESS | PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)
126 #define CMUAP   (PCRE_CASELESS | PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)
127 #define MA      (PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF)
128 #define MAP     (PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)
129 #define CMA     (PCRE_CASELESS | PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF)
130
131 #define OFFSET_MASK     0x00ffff
132 #define F_NO8           0x010000
133 #define F_NO16          0x020000
134 #define F_NO32          0x020000
135 #define F_NOMATCH       0x040000
136 #define F_DIFF          0x080000
137 #define F_FORCECONV     0x100000
138 #define F_PROPERTY      0x200000
139 #define F_STUDY         0x400000
140
141 struct regression_test_case {
142         int flags;
143         int start_offset;
144         const char *pattern;
145         const char *input;
146 };
147
148 static struct regression_test_case regression_test_cases[] = {
149         /* Constant strings. */
150         { MUA, 0, "AbC", "AbAbC" },
151         { MUA, 0, "ACCEPT", "AACACCACCEACCEPACCEPTACCEPTT" },
152         { CMUA, 0, "aA#\xc3\xa9\xc3\x81", "aA#Aa#\xc3\x89\xc3\xa1" },
153         { MA, 0, "[^a]", "aAbB" },
154         { CMA, 0, "[^m]", "mMnN" },
155         { MA, 0, "a[^b][^#]", "abacd" },
156         { CMA, 0, "A[^B][^E]", "abacd" },
157         { CMUA, 0, "[^x][^#]", "XxBll" },
158         { MUA, 0, "[^a]", "aaa\xc3\xa1#Ab" },
159         { CMUA, 0, "[^A]", "aA\xe6\x92\xad" },
160         { MUA, 0, "\\W(\\W)?\\w", "\r\n+bc" },
161         { MUA, 0, "\\W(\\W)?\\w", "\n\r+bc" },
162         { MUA, 0, "\\W(\\W)?\\w", "\r\r+bc" },
163         { MUA, 0, "\\W(\\W)?\\w", "\n\n+bc" },
164         { MUA, 0, "[axd]", "sAXd" },
165         { CMUA, 0, "[axd]", "sAXd" },
166         { CMUA, 0 | F_NOMATCH, "[^axd]", "DxA" },
167         { MUA, 0, "[a-dA-C]", "\xe6\x92\xad\xc3\xa9.B" },
168         { MUA, 0, "[^a-dA-C]", "\xe6\x92\xad\xc3\xa9" },
169         { CMUA, 0, "[^\xc3\xa9]", "\xc3\xa9\xc3\x89." },
170         { MUA, 0, "[^\xc3\xa9]", "\xc3\xa9\xc3\x89." },
171         { MUA, 0, "[^a]", "\xc2\x80[]" },
172         { CMUA, 0, "\xf0\x90\x90\xa7", "\xf0\x90\x91\x8f" },
173         { CMA, 0, "1a2b3c4", "1a2B3c51A2B3C4" },
174         { PCRE_CASELESS, 0, "\xff#a", "\xff#\xff\xfe##\xff#A" },
175         { PCRE_CASELESS, 0, "\xfe", "\xff\xfc#\xfe\xfe" },
176         { PCRE_CASELESS, 0, "a1", "Aa1" },
177         { MA, 0, "\\Ca", "cda" },
178         { CMA, 0, "\\Ca", "CDA" },
179         { MA, 0 | F_NOMATCH, "\\Cx", "cda" },
180         { CMA, 0 | F_NOMATCH, "\\Cx", "CDA" },
181         { CMUAP, 0, "\xf0\x90\x90\x80\xf0\x90\x90\xa8", "\xf0\x90\x90\xa8\xf0\x90\x90\x80" },
182         { CMUAP, 0, "\xf0\x90\x90\x80{2}", "\xf0\x90\x90\x80#\xf0\x90\x90\xa8\xf0\x90\x90\x80" },
183         { CMUAP, 0, "\xf0\x90\x90\xa8{2}", "\xf0\x90\x90\x80#\xf0\x90\x90\xa8\xf0\x90\x90\x80" },
184         { CMUAP, 0, "\xe1\xbd\xb8\xe1\xbf\xb8", "\xe1\xbf\xb8\xe1\xbd\xb8" },
185         { MA, 0, "[3-57-9]", "5" },
186
187         /* Assertions. */
188         { MUA, 0, "\\b[^A]", "A_B#" },
189         { MA, 0 | F_NOMATCH, "\\b\\W", "\n*" },
190         { MUA, 0, "\\B[^,]\\b[^s]\\b", "#X" },
191         { MAP, 0, "\\B", "_\xa1" },
192         { MAP, 0, "\\b_\\b[,A]\\B", "_," },
193         { MUAP, 0, "\\b", "\xe6\x92\xad!" },
194         { MUAP, 0, "\\B", "_\xc2\xa1\xc3\xa1\xc2\x85" },
195         { MUAP, 0, "\\b[^A]\\B[^c]\\b[^_]\\B", "_\xc3\xa1\xe2\x80\xa8" },
196         { MUAP, 0, "\\b\\w+\\B", "\xc3\x89\xc2\xa1\xe6\x92\xad\xc3\x81\xc3\xa1" },
197         { MUA, 0 | F_NOMATCH, "\\b.", "\xcd\xbe" },
198         { CMUAP, 0, "\\By", "\xf0\x90\x90\xa8y" },
199         { MA, 0 | F_NOMATCH, "\\R^", "\n" },
200         { MA, 1 | F_NOMATCH, "^", "\n" },
201         { 0, 0, "^ab", "ab" },
202         { 0, 0 | F_NOMATCH, "^ab", "aab" },
203         { PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 0, "^a", "\r\raa\n\naa\r\naa" },
204         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF, 0, "^-", "\xe2\x80\xa8--\xc2\x85-\r\n-" },
205         { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "^-", "a--b--\x85--" },
206         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xe2\x80\xa8--" },
207         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xc2\x85--" },
208         { 0, 0, "ab$", "ab" },
209         { 0, 0 | F_NOMATCH, "ab$", "abab\n\n" },
210         { PCRE_DOLLAR_ENDONLY, 0 | F_NOMATCH, "ab$", "abab\r\n" },
211         { PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 0, "a$", "\r\raa\n\naa\r\naa" },
212         { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "a$", "aaa" },
213         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF, 0, "#$", "#\xc2\x85###\r#" },
214         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "#$", "#\xe2\x80\xa9" },
215         { PCRE_NOTBOL | PCRE_NEWLINE_ANY, 0 | F_NOMATCH, "^a", "aa\naa" },
216         { PCRE_NOTBOL | PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "^a", "aa\naa" },
217         { PCRE_NOTEOL | PCRE_NEWLINE_ANY, 0 | F_NOMATCH, "a$", "aa\naa" },
218         { PCRE_NOTEOL | PCRE_NEWLINE_ANY, 0 | F_NOMATCH, "a$", "aa\r\n" },
219         { PCRE_UTF8 | PCRE_DOLLAR_ENDONLY | PCRE_NEWLINE_ANY, 0 | F_PROPERTY, "\\p{Any}{2,}$", "aa\r\n" },
220         { PCRE_NOTEOL | PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "a$", "aa\naa" },
221         { PCRE_NEWLINE_CR, 0, ".\\Z", "aaa" },
222         { PCRE_NEWLINE_CR | PCRE_UTF8, 0, "a\\Z", "aaa\r" },
223         { PCRE_NEWLINE_CR, 0, ".\\Z", "aaa\n" },
224         { PCRE_NEWLINE_CRLF, 0, ".\\Z", "aaa\r" },
225         { PCRE_NEWLINE_CRLF | PCRE_UTF8, 0, ".\\Z", "aaa\n" },
226         { PCRE_NEWLINE_CRLF, 0, ".\\Z", "aaa\r\n" },
227         { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa" },
228         { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa\r" },
229         { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa\n" },
230         { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa\r\n" },
231         { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa\xe2\x80\xa8" },
232         { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa" },
233         { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa\r" },
234         { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa\n" },
235         { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa\r\n" },
236         { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, ".\\Z", "aaa\xc2\x85" },
237         { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, ".\\Z", "aaa\xe2\x80\xa8" },
238         { MA, 0, "\\Aa", "aaa" },
239         { MA, 1 | F_NOMATCH, "\\Aa", "aaa" },
240         { MA, 1, "\\Ga", "aaa" },
241         { MA, 1 | F_NOMATCH, "\\Ga", "aba" },
242         { MA, 0, "a\\z", "aaa" },
243         { MA, 0 | F_NOMATCH, "a\\z", "aab" },
244
245         /* Brackets. */
246         { MUA, 0, "(ab|bb|cd)", "bacde" },
247         { MUA, 0, "(?:ab|a)(bc|c)", "ababc" },
248         { MUA, 0, "((ab|(cc))|(bb)|(?:cd|efg))", "abac" },
249         { CMUA, 0, "((aB|(Cc))|(bB)|(?:cd|EFg))", "AcCe" },
250         { MUA, 0, "((ab|(cc))|(bb)|(?:cd|ebg))", "acebebg" },
251         { MUA, 0, "(?:(a)|(?:b))(cc|(?:d|e))(a|b)k", "accabdbbccbk" },
252
253         /* Greedy and non-greedy ? operators. */
254         { MUA, 0, "(?:a)?a", "laab" },
255         { CMUA, 0, "(A)?A", "llaab" },
256         { MUA, 0, "(a)?\?a", "aab" }, /* ?? is the prefix of trygraphs in GCC. */
257         { MUA, 0, "(a)?a", "manm" },
258         { CMUA, 0, "(a|b)?\?d((?:e)?)", "ABABdx" },
259         { MUA, 0, "(a|b)?\?d((?:e)?)", "abcde" },
260         { MUA, 0, "((?:ab)?\?g|b(?:g(nn|d)?\?)?)?\?(?:n)?m", "abgnbgnnbgdnmm" },
261
262         /* Greedy and non-greedy + operators */
263         { MUA, 0, "(aa)+aa", "aaaaaaa" },
264         { MUA, 0, "(aa)+?aa", "aaaaaaa" },
265         { MUA, 0, "(?:aba|ab|a)+l", "ababamababal" },
266         { MUA, 0, "(?:aba|ab|a)+?l", "ababamababal" },
267         { MUA, 0, "(a(?:bc|cb|b|c)+?|ss)+e", "accssabccbcacbccbbXaccssabccbcacbccbbe" },
268         { MUA, 0, "(a(?:bc|cb|b|c)+|ss)+?e", "accssabccbcacbccbbXaccssabccbcacbccbbe" },
269         { MUA, 0, "(?:(b(c)+?)+)?\?(?:(bc)+|(cb)+)+(?:m)+", "bccbcccbcbccbcbPbccbcccbcbccbcbmmn" },
270
271         /* Greedy and non-greedy * operators */
272         { CMUA, 0, "(?:AA)*AB", "aaaaaaamaaaaaaab" },
273         { MUA, 0, "(?:aa)*?ab", "aaaaaaamaaaaaaab" },
274         { MUA, 0, "(aa|ab)*ab", "aaabaaab" },
275         { CMUA, 0, "(aa|Ab)*?aB", "aaabaaab" },
276         { MUA, 0, "(a|b)*(?:a)*(?:b)*m", "abbbaaababanabbbaaababamm" },
277         { MUA, 0, "(a|b)*?(?:a)*?(?:b)*?m", "abbbaaababanabbbaaababamm" },
278         { MA, 0, "a(a(\\1*)a|(b)b+){0}a", "aa" },
279         { MA, 0, "((?:a|)*){0}a", "a" },
280
281         /* Combining ? + * operators */
282         { MUA, 0, "((bm)+)?\?(?:a)*(bm)+n|((am)+?)?(?:a)+(am)*n", "bmbmabmamaaamambmaman" },
283         { MUA, 0, "(((ab)?cd)*ef)+g", "abcdcdefcdefefmabcdcdefcdefefgg" },
284         { MUA, 0, "(((ab)?\?cd)*?ef)+?g", "abcdcdefcdefefmabcdcdefcdefefgg" },
285         { MUA, 0, "(?:(ab)?c|(?:ab)+?d)*g", "ababcdccababddg" },
286         { MUA, 0, "(?:(?:ab)?\?c|(ab)+d)*?g", "ababcdccababddg" },
287
288         /* Single character iterators. */
289         { MUA, 0, "(a+aab)+aaaab", "aaaabcaaaabaabcaabcaaabaaaab" },
290         { MUA, 0, "(a*a*aab)+x", "aaaaabaabaaabmaabx" },
291         { MUA, 0, "(a*?(b|ab)a*?)+x", "aaaabcxbbaabaacbaaabaabax" },
292         { MUA, 0, "(a+(ab|ad)a+)+x", "aaabaaaadaabaaabaaaadaaax" },
293         { MUA, 0, "(a?(a)a?)+(aaa)", "abaaabaaaaaaaa" },
294         { MUA, 0, "(a?\?(a)a?\?)+(b)", "aaaacaaacaacacbaaab" },
295         { MUA, 0, "(a{0,4}(b))+d", "aaaaaabaabcaaaaabaaaaabd" },
296         { MUA, 0, "(a{0,4}?[^b])+d+(a{0,4}[^b])d+", "aaaaadaaaacaadddaaddd" },
297         { MUA, 0, "(ba{2})+c", "baabaaabacbaabaac" },
298         { MUA, 0, "(a*+bc++)+", "aaabbcaaabcccab" },
299         { MUA, 0, "(a?+[^b])+", "babaacacb" },
300         { MUA, 0, "(a{0,3}+b)(a{0,3}+b)(a{0,3}+)[^c]", "abaabaaacbaabaaaac" },
301         { CMUA, 0, "([a-c]+[d-f]+?)+?g", "aBdacdehAbDaFgA" },
302         { CMUA, 0, "[c-f]+k", "DemmFke" },
303         { MUA, 0, "([DGH]{0,4}M)+", "GGDGHDGMMHMDHHGHM" },
304         { MUA, 0, "([a-c]{4,}s)+", "abasabbasbbaabsbba" },
305         { CMUA, 0, "[ace]{3,7}", "AcbDAcEEcEd" },
306         { CMUA, 0, "[ace]{3,7}?", "AcbDAcEEcEd" },
307         { CMUA, 0, "[ace]{3,}", "AcbDAcEEcEd" },
308         { CMUA, 0, "[ace]{3,}?", "AcbDAcEEcEd" },
309         { MUA, 0, "[ckl]{2,}?g", "cdkkmlglglkcg" },
310         { CMUA, 0, "[ace]{5}?", "AcCebDAcEEcEd" },
311         { MUA, 0, "([AbC]{3,5}?d)+", "BACaAbbAEAACCbdCCbdCCAAbb" },
312         { MUA, 0, "([^ab]{0,}s){2}", "abaabcdsABamsDDs" },
313         { MUA, 0, "\\b\\w+\\B", "x,a_cd" },
314         { MUAP, 0, "\\b[^\xc2\xa1]+\\B", "\xc3\x89\xc2\xa1\xe6\x92\xad\xc3\x81\xc3\xa1" },
315         { CMUA, 0, "[^b]+(a*)([^c]?d{3})", "aaaaddd" },
316         { CMUAP, 0, "\xe1\xbd\xb8{2}", "\xe1\xbf\xb8#\xe1\xbf\xb8\xe1\xbd\xb8" },
317         { CMUA, 0, "[^\xf0\x90\x90\x80]{2,4}@", "\xf0\x90\x90\xa8\xf0\x90\x90\x80###\xf0\x90\x90\x80@@@" },
318         { CMUA, 0, "[^\xe1\xbd\xb8][^\xc3\xa9]", "\xe1\xbd\xb8\xe1\xbf\xb8\xc3\xa9\xc3\x89#" },
319         { MUA, 0, "[^\xe1\xbd\xb8][^\xc3\xa9]", "\xe1\xbd\xb8\xe1\xbf\xb8\xc3\xa9\xc3\x89#" },
320         { MUA, 0, "[^\xe1\xbd\xb8]{3,}?", "##\xe1\xbd\xb8#\xe1\xbd\xb8#\xc3\x89#\xe1\xbd\xb8" },
321
322         /* Bracket repeats with limit. */
323         { MUA, 0, "(?:(ab){2}){5}M", "abababababababababababM" },
324         { MUA, 0, "(?:ab|abab){1,5}M", "abababababababababababM" },
325         { MUA, 0, "(?>ab|abab){1,5}M", "abababababababababababM" },
326         { MUA, 0, "(?:ab|abab){1,5}?M", "abababababababababababM" },
327         { MUA, 0, "(?>ab|abab){1,5}?M", "abababababababababababM" },
328         { MUA, 0, "(?:(ab){1,4}?){1,3}?M", "abababababababababababababM" },
329         { MUA, 0, "(?:(ab){1,4}){1,3}abababababababababababM", "ababababababababababababM" },
330         { MUA, 0 | F_NOMATCH, "(?:(ab){1,4}){1,3}abababababababababababM", "abababababababababababM" },
331         { MUA, 0, "(ab){4,6}?M", "abababababababM" },
332
333         /* Basic character sets. */
334         { MUA, 0, "(?:\\s)+(?:\\S)+", "ab \t\xc3\xa9\xe6\x92\xad " },
335         { MUA, 0, "(\\w)*(k)(\\W)?\?", "abcdef abck11" },
336         { MUA, 0, "\\((\\d)+\\)\\D", "a() (83 (8)2 (9)ab" },
337         { MUA, 0, "\\w(\\s|(?:\\d)*,)+\\w\\wb", "a 5, 4,, bb 5, 4,, aab" },
338         { MUA, 0, "(\\v+)(\\V+)", "\x0e\xc2\x85\xe2\x80\xa8\x0b\x09\xe2\x80\xa9" },
339         { MUA, 0, "(\\h+)(\\H+)", "\xe2\x80\xa8\xe2\x80\x80\x20\xe2\x80\x8a\xe2\x81\x9f\xe3\x80\x80\x09\x20\xc2\xa0\x0a" },
340         { MUA, 0, "x[bcef]+", "xaxdxecbfg" },
341         { MUA, 0, "x[bcdghij]+", "xaxexfxdgbjk" },
342         { MUA, 0, "x[^befg]+", "xbxexacdhg" },
343         { MUA, 0, "x[^bcdl]+", "xlxbxaekmd" },
344         { MUA, 0, "x[^bcdghi]+", "xbxdxgxaefji" },
345         { MUA, 0, "x[B-Fb-f]+", "xaxAxgxbfBFG" },
346         { CMUA, 0, "\\x{e9}+", "#\xf0\x90\x90\xa8\xc3\xa8\xc3\xa9\xc3\x89\xc3\x88" },
347         { CMUA, 0, "[^\\x{e9}]+", "\xc3\xa9#\xf0\x90\x90\xa8\xc3\xa8\xc3\x88\xc3\x89" },
348         { MUA, 0, "[\\x02\\x7e]+", "\xc3\x81\xe1\xbf\xb8\xf0\x90\x90\xa8\x01\x02\x7e\x7f" },
349         { MUA, 0, "[^\\x02\\x7e]+", "\x02\xc3\x81\xe1\xbf\xb8\xf0\x90\x90\xa8\x01\x7f\x7e" },
350         { MUA, 0, "[\\x{81}-\\x{7fe}]+", "#\xe1\xbf\xb8\xf0\x90\x90\xa8\xc2\x80\xc2\x81\xdf\xbe\xdf\xbf" },
351         { MUA, 0, "[^\\x{81}-\\x{7fe}]+", "\xc2\x81#\xe1\xbf\xb8\xf0\x90\x90\xa8\xc2\x80\xdf\xbf\xdf\xbe" },
352         { MUA, 0, "[\\x{801}-\\x{fffe}]+", "#\xc3\xa9\xf0\x90\x90\x80\xe0\xa0\x80\xe0\xa0\x81\xef\xbf\xbe\xef\xbf\xbf" },
353         { MUA, 0, "[^\\x{801}-\\x{fffe}]+", "\xe0\xa0\x81#\xc3\xa9\xf0\x90\x90\x80\xe0\xa0\x80\xef\xbf\xbf\xef\xbf\xbe" },
354         { MUA, 0, "[\\x{10001}-\\x{10fffe}]+", "#\xc3\xa9\xe2\xb1\xa5\xf0\x90\x80\x80\xf0\x90\x80\x81\xf4\x8f\xbf\xbe\xf4\x8f\xbf\xbf" },
355         { MUA, 0, "[^\\x{10001}-\\x{10fffe}]+", "\xf0\x90\x80\x81#\xc3\xa9\xe2\xb1\xa5\xf0\x90\x80\x80\xf4\x8f\xbf\xbf\xf4\x8f\xbf\xbe" },
356
357         /* Unicode properties. */
358         { MUAP, 0, "[1-5\xc3\xa9\\w]", "\xc3\xa1_" },
359         { MUAP, 0 | F_PROPERTY, "[\xc3\x81\\p{Ll}]", "A_\xc3\x89\xc3\xa1" },
360         { MUAP, 0, "[\\Wd-h_x-z]+", "a\xc2\xa1#_yhzdxi" },
361         { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\\P{Any}]", "abc" },
362         { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\\p{Any}]", "abc" },
363         { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\\P{Any}\xc3\xa1-\xc3\xa8]", "abc" },
364         { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\\p{Any}\xc3\xa1-\xc3\xa8]", "abc" },
365         { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },
366         { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },
367         { MUAP, 0 | F_PROPERTY, "[\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },
368         { MUAP, 0 | F_PROPERTY, "[^\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },
369         { MUAP, 0, "[b-\xc3\xa9\\s]", "a\xc\xe6\x92\xad" },
370         { CMUAP, 0, "[\xc2\x85-\xc2\x89\xc3\x89]", "\xc2\x84\xc3\xa9" },
371         { MUAP, 0, "[^b-d^&\\s]{3,}", "db^ !a\xe2\x80\xa8_ae" },
372         { MUAP, 0 | F_PROPERTY, "[^\\S\\P{Any}][\\sN]{1,3}[\\P{N}]{4}", "\xe2\x80\xaa\xa N\x9\xc3\xa9_0" },
373         { MUA, 0 | F_PROPERTY, "[^\\P{L}\x9!D-F\xa]{2,3}", "\x9,.DF\xa.CG\xc3\x81" },
374         { CMUAP, 0, "[\xc3\xa1-\xc3\xa9_\xe2\x80\xa0-\xe2\x80\xaf]{1,5}[^\xe2\x80\xa0-\xe2\x80\xaf]", "\xc2\xa1\xc3\x89\xc3\x89\xe2\x80\xaf_\xe2\x80\xa0" },
375         { MUAP, 0 | F_PROPERTY, "[\xc3\xa2-\xc3\xa6\xc3\x81-\xc3\x84\xe2\x80\xa8-\xe2\x80\xa9\xe6\x92\xad\\p{Zs}]{2,}", "\xe2\x80\xa7\xe2\x80\xa9\xe6\x92\xad \xe6\x92\xae" },
376         { MUAP, 0 | F_PROPERTY, "[\\P{L&}]{2}[^\xc2\x85-\xc2\x89\\p{Ll}\\p{Lu}]{2}", "\xc3\xa9\xe6\x92\xad.a\xe6\x92\xad|\xc2\x8a#" },
377         { PCRE_UCP, 0, "[a-b\\s]{2,5}[^a]", "AB  baaa" },
378
379         /* Possible empty brackets. */
380         { MUA, 0, "(?:|ab||bc|a)+d", "abcxabcabd" },
381         { MUA, 0, "(|ab||bc|a)+d", "abcxabcabd" },
382         { MUA, 0, "(?:|ab||bc|a)*d", "abcxabcabd" },
383         { MUA, 0, "(|ab||bc|a)*d", "abcxabcabd" },
384         { MUA, 0, "(?:|ab||bc|a)+?d", "abcxabcabd" },
385         { MUA, 0, "(|ab||bc|a)+?d", "abcxabcabd" },
386         { MUA, 0, "(?:|ab||bc|a)*?d", "abcxabcabd" },
387         { MUA, 0, "(|ab||bc|a)*?d", "abcxabcabd" },
388         { MUA, 0, "(((a)*?|(?:ba)+)+?|(?:|c|ca)*)*m", "abaacaccabacabalabaacaccabacabamm" },
389         { MUA, 0, "(?:((?:a)*|(ba)+?)+|(|c|ca)*?)*?m", "abaacaccabacabalabaacaccabacabamm" },
390
391         /* Start offset. */
392         { MUA, 3, "(\\d|(?:\\w)*\\w)+", "0ac01Hb" },
393         { MUA, 4 | F_NOMATCH, "(\\w\\W\\w)+", "ab#d" },
394         { MUA, 2 | F_NOMATCH, "(\\w\\W\\w)+", "ab#d" },
395         { MUA, 1, "(\\w\\W\\w)+", "ab#d" },
396
397         /* Newline. */
398         { PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 0, "\\W{0,2}[^#]{3}", "\r\n#....." },
399         { PCRE_MULTILINE | PCRE_NEWLINE_CR, 0, "\\W{0,2}[^#]{3}", "\r\n#....." },
400         { PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 0, "\\W{1,3}[^#]", "\r\n##...." },
401         { MUA | PCRE_NO_UTF8_CHECK, 1, "^.a", "\n\x80\nxa" },
402         { MUA, 1, "^", "\r\n" },
403         { PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 1 | F_NOMATCH, "^", "\r\n" },
404         { PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 1, "^", "\r\na" },
405
406         /* Any character except newline or any newline. */
407         { PCRE_NEWLINE_CRLF, 0, ".", "\r" },
408         { PCRE_NEWLINE_CRLF | PCRE_UTF8, 0, ".(.).", "a\xc3\xa1\r\n\n\r\r" },
409         { PCRE_NEWLINE_ANYCRLF, 0, ".(.)", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa8" },
410         { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".(.)", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa8" },
411         { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.).", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa9$de" },
412         { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0 | F_NOMATCH, ".(.).", "\xe2\x80\xa8\nb\r" },
413         { PCRE_NEWLINE_ANY, 0, "(.)(.)", "#\x85#\r#\n#\r\n#\x84" },
414         { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.+)#", "#\rMn\xc2\x85#\n###" },
415         { PCRE_BSR_ANYCRLF, 0, "\\R", "\r" },
416         { PCRE_BSR_ANYCRLF, 0, "\\R", "\x85#\r\n#" },
417         { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\xe2\x80\xa8#c" },
418         { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\r\nc" },
419         { PCRE_NEWLINE_CRLF | PCRE_BSR_UNICODE | PCRE_UTF8, 0, "(\\R.)+", "\xc2\x85\r\n#\xe2\x80\xa8\n\r\n\r" },
420         { MUA, 0 | F_NOMATCH, "\\R+", "ab" },
421         { MUA, 0, "\\R+", "ab\r\n\r" },
422         { MUA, 0, "\\R*", "ab\r\n\r" },
423         { MUA, 0, "\\R*", "\r\n\r" },
424         { MUA, 0, "\\R{2,4}", "\r\nab\r\r" },
425         { MUA, 0, "\\R{2,4}", "\r\nab\n\n\n\r\r\r" },
426         { MUA, 0, "\\R{2,}", "\r\nab\n\n\n\r\r\r" },
427         { MUA, 0, "\\R{0,3}", "\r\n\r\n\r\n\r\n\r\n" },
428         { MUA, 0 | F_NOMATCH, "\\R+\\R\\R", "\r\n\r\n" },
429         { MUA, 0, "\\R+\\R\\R", "\r\r\r" },
430         { MUA, 0, "\\R*\\R\\R", "\n\r" },
431         { MUA, 0 | F_NOMATCH, "\\R{2,4}\\R\\R", "\r\r\r" },
432         { MUA, 0, "\\R{2,4}\\R\\R", "\r\r\r\r" },
433
434         /* Atomic groups (no fallback from "next" direction). */
435         { MUA, 0 | F_NOMATCH, "(?>ab)ab", "bab" },
436         { MUA, 0 | F_NOMATCH, "(?>(ab))ab", "bab" },
437         { MUA, 0, "(?>ab)+abc(?>de)*def(?>gh)?ghe(?>ij)+?k(?>lm)*?n(?>op)?\?op",
438                         "bababcdedefgheijijklmlmnop" },
439         { MUA, 0, "(?>a(b)+a|(ab)?\?(b))an", "abban" },
440         { MUA, 0, "(?>ab+a|(?:ab)?\?b)an", "abban" },
441         { MUA, 0, "((?>ab|ad|)*?)(?>|c)*abad", "abababcababad" },
442         { MUA, 0, "(?>(aa|b|)*+(?>(##)|###)*d|(aa)(?>(baa)?)m)", "aabaa#####da" },
443         { MUA, 0, "((?>a|)+?)b", "aaacaaab" },
444         { MUA, 0, "(?>x|)*$", "aaa" },
445         { MUA, 0, "(?>(x)|)*$", "aaa" },
446         { MUA, 0, "(?>x|())*$", "aaa" },
447         { MUA, 0, "((?>[cxy]a|[a-d])*?)b", "aaa+ aaab" },
448         { MUA, 0, "((?>[cxy](a)|[a-d])*?)b", "aaa+ aaab" },
449         { MUA, 0, "(?>((?>(a+))))bab|(?>((?>(a+))))bb", "aaaabaaabaabab" },
450         { MUA, 0, "(?>(?>a+))bab|(?>(?>a+))bb", "aaaabaaabaabab" },
451         { MUA, 0, "(?>(a)c|(?>(c)|(a))a)b*?bab", "aaaabaaabaabab" },
452         { MUA, 0, "(?>ac|(?>c|a)a)b*?bab", "aaaabaaabaabab" },
453         { MUA, 0, "(?>(b)b|(a))*b(?>(c)|d)?x", "ababcaaabdbx" },
454         { MUA, 0, "(?>bb|a)*b(?>c|d)?x", "ababcaaabdbx" },
455         { MUA, 0, "(?>(bb)|a)*b(?>c|(d))?x", "ababcaaabdbx" },
456         { MUA, 0, "(?>(a))*?(?>(a))+?(?>(a))??x", "aaaaaacccaaaaabax" },
457         { MUA, 0, "(?>a)*?(?>a)+?(?>a)??x", "aaaaaacccaaaaabax" },
458         { MUA, 0, "(?>(a)|)*?(?>(a)|)+?(?>(a)|)??x", "aaaaaacccaaaaabax" },
459         { MUA, 0, "(?>a|)*?(?>a|)+?(?>a|)??x", "aaaaaacccaaaaabax" },
460         { MUA, 0, "(?>a(?>(a{0,2}))*?b|aac)+b", "aaaaaaacaaaabaaaaacaaaabaacaaabb" },
461         { CMA, 0, "(?>((?>a{32}|b+|(a*))?(?>c+|d*)?\?)+e)+?f", "aaccebbdde bbdaaaccebbdee bbdaaaccebbdeef" },
462         { MUA, 0, "(?>(?:(?>aa|a||x)+?b|(?>aa|a||(x))+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" },
463         { MUA, 0, "(?>(?:(?>aa|a||(x))+?b|(?>aa|a||x)+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" },
464         { MUA, 0 | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d" },
465         { MUA, 0 | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d#\xcc\x8d\xcc\x8d" },
466         { MUA, 0 | F_PROPERTY, "\\X+..", "\xcc\x8d#\xcc\x8d#\xcc\x8d\xcc\x8d" },
467         { MUA, 0 | F_PROPERTY, "\\X{2,4}", "abcdef" },
468         { MUA, 0 | F_PROPERTY, "\\X{2,4}?", "abcdef" },
469         { MUA, 0 | F_NOMATCH | F_PROPERTY, "\\X{2,4}..", "#\xcc\x8d##" },
470         { MUA, 0 | F_PROPERTY, "\\X{2,4}..", "#\xcc\x8d#\xcc\x8d##" },
471         { MUA, 0, "(c(ab)?+ab)+", "cabcababcab" },
472         { MUA, 0, "(?>(a+)b)+aabab", "aaaabaaabaabab" },
473
474         /* Possessive quantifiers. */
475         { MUA, 0, "(?:a|b)++m", "mababbaaxababbaam" },
476         { MUA, 0, "(?:a|b)*+m", "mababbaaxababbaam" },
477         { MUA, 0, "(?:a|b)*+m", "ababbaaxababbaam" },
478         { MUA, 0, "(a|b)++m", "mababbaaxababbaam" },
479         { MUA, 0, "(a|b)*+m", "mababbaaxababbaam" },
480         { MUA, 0, "(a|b)*+m", "ababbaaxababbaam" },
481         { MUA, 0, "(a|b(*ACCEPT))++m", "maaxab" },
482         { MUA, 0, "(?:b*)++m", "bxbbxbbbxm" },
483         { MUA, 0, "(?:b*)++m", "bxbbxbbbxbbm" },
484         { MUA, 0, "(?:b*)*+m", "bxbbxbbbxm" },
485         { MUA, 0, "(?:b*)*+m", "bxbbxbbbxbbm" },
486         { MUA, 0, "(b*)++m", "bxbbxbbbxm" },
487         { MUA, 0, "(b*)++m", "bxbbxbbbxbbm" },
488         { MUA, 0, "(b*)*+m", "bxbbxbbbxm" },
489         { MUA, 0, "(b*)*+m", "bxbbxbbbxbbm" },
490         { MUA, 0, "(?:a|(b))++m", "mababbaaxababbaam" },
491         { MUA, 0, "(?:(a)|b)*+m", "mababbaaxababbaam" },
492         { MUA, 0, "(?:(a)|(b))*+m", "ababbaaxababbaam" },
493         { MUA, 0, "(a|(b))++m", "mababbaaxababbaam" },
494         { MUA, 0, "((a)|b)*+m", "mababbaaxababbaam" },
495         { MUA, 0, "((a)|(b))*+m", "ababbaaxababbaam" },
496         { MUA, 0, "(a|(b)(*ACCEPT))++m", "maaxab" },
497         { MUA, 0, "(?:(b*))++m", "bxbbxbbbxm" },
498         { MUA, 0, "(?:(b*))++m", "bxbbxbbbxbbm" },
499         { MUA, 0, "(?:(b*))*+m", "bxbbxbbbxm" },
500         { MUA, 0, "(?:(b*))*+m", "bxbbxbbbxbbm" },
501         { MUA, 0, "((b*))++m", "bxbbxbbbxm" },
502         { MUA, 0, "((b*))++m", "bxbbxbbbxbbm" },
503         { MUA, 0, "((b*))*+m", "bxbbxbbbxm" },
504         { MUA, 0, "((b*))*+m", "bxbbxbbbxbbm" },
505         { MUA, 0 | F_NOMATCH, "(?>(b{2,4}))(?:(?:(aa|c))++m|(?:(aa|c))+n)", "bbaacaaccaaaacxbbbmbn" },
506         { MUA, 0, "((?:b)++a)+(cd)*+m", "bbababbacdcdnbbababbacdcdm" },
507         { MUA, 0, "((?:(b))++a)+((c)d)*+m", "bbababbacdcdnbbababbacdcdm" },
508         { MUA, 0, "(?:(?:(?:ab)*+k)++(?:n(?:cd)++)*+)*+m", "ababkkXababkkabkncXababkkabkncdcdncdXababkkabkncdcdncdkkabkncdXababkkabkncdcdncdkkabkncdm" },
509         { MUA, 0, "(?:((ab)*+(k))++(n(?:c(d))++)*+)*+m", "ababkkXababkkabkncXababkkabkncdcdncdXababkkabkncdcdncdkkabkncdXababkkabkncdcdncdkkabkncdm" },
510
511         /* Back references. */
512         { MUA, 0, "(aa|bb)(\\1*)(ll|)(\\3*)bbbbbbc", "aaaaaabbbbbbbbc" },
513         { CMUA, 0, "(aa|bb)(\\1+)(ll|)(\\3+)bbbbbbc", "bBbbBbCbBbbbBbbcbbBbbbBBbbC" },
514         { CMA, 0, "(a{2,4})\\1", "AaAaaAaA" },
515         { MUA, 0, "(aa|bb)(\\1?)aa(\\1?)(ll|)(\\4+)bbc", "aaaaaaaabbaabbbbaabbbbc" },
516         { MUA, 0, "(aa|bb)(\\1{0,5})(ll|)(\\3{0,5})cc", "bbxxbbbbxxaaaaaaaaaaaaaaaacc" },
517         { MUA, 0, "(aa|bb)(\\1{3,5})(ll|)(\\3{3,5})cc", "bbbbbbbbbbbbaaaaaaccbbbbbbbbbbbbbbcc" },
518         { MUA, 0, "(aa|bb)(\\1{3,})(ll|)(\\3{3,})cc", "bbbbbbbbbbbbaaaaaaccbbbbbbbbbbbbbbcc" },
519         { MUA, 0, "(\\w+)b(\\1+)c", "GabGaGaDbGaDGaDc" },
520         { MUA, 0, "(?:(aa)|b)\\1?b", "bb" },
521         { CMUA, 0, "(aa|bb)(\\1*?)aa(\\1+?)", "bBBbaaAAaaAAaa" },
522         { MUA, 0, "(aa|bb)(\\1*?)(dd|)cc(\\3+?)", "aaaaaccdd" },
523         { CMUA, 0, "(?:(aa|bb)(\\1?\?)cc){2}(\\1?\?)", "aAaABBbbAAaAcCaAcCaA" },
524         { MUA, 0, "(?:(aa|bb)(\\1{3,5}?)){2}(dd|)(\\3{3,5}?)", "aaaaaabbbbbbbbbbaaaaaaaaaaaaaa" },
525         { CMA, 0, "(?:(aa|bb)(\\1{3,}?)){2}(dd|)(\\3{3,}?)", "aaaaaabbbbbbbbbbaaaaaaaaaaaaaa" },
526         { MUA, 0, "(?:(aa|bb)(\\1{0,3}?)){2}(dd|)(\\3{0,3}?)b(\\1{0,3}?)(\\1{0,3})", "aaaaaaaaaaaaaaabaaaaa" },
527         { MUA, 0, "(a(?:\\1|)a){3}b", "aaaaaaaaaaab" },
528         { MA, 0, "(a?)b(\\1\\1*\\1+\\1?\\1*?\\1+?\\1??\\1*+\\1++\\1?+\\1{4}\\1{3,5}\\1{4,}\\1{0,5}\\1{3,5}?\\1{4,}?\\1{0,5}?\\1{3,5}+\\1{4,}+\\1{0,5}+#){2}d", "bb#b##d" },
529         { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{2,}", ".www." },
530         { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{0,2}", "wwwww." },
531         { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{1,2}ww", "wwww" },
532         { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{1,2}ww", "wwwww" },
533         { PCRE_UCP, 0 | F_PROPERTY, "(\\P{N})\\1{2,}", ".www." },
534         { CMUAP, 0, "(\xf0\x90\x90\x80)\\1", "\xf0\x90\x90\xa8\xf0\x90\x90\xa8" },
535         { MUA | PCRE_DUPNAMES, 0 | F_NOMATCH, "\\k<A>{1,3}(?<A>aa)(?<A>bb)", "aabb" },
536         { MUA | PCRE_DUPNAMES | PCRE_JAVASCRIPT_COMPAT, 0, "\\k<A>{1,3}(?<A>aa)(?<A>bb)", "aabb" },
537         { MUA | PCRE_DUPNAMES | PCRE_JAVASCRIPT_COMPAT, 0, "\\k<A>*(?<A>aa)(?<A>bb)", "aabb" },
538         { MUA | PCRE_DUPNAMES, 0, "(?<A>aa)(?<A>bb)\\k<A>{0,3}aaaaaa", "aabbaaaaaa" },
539         { MUA | PCRE_DUPNAMES, 0, "(?<A>aa)(?<A>bb)\\k<A>{2,5}bb", "aabbaaaabb" },
540         { MUA | PCRE_DUPNAMES, 0, "(?:(?<A>aa)|(?<A>bb))\\k<A>{0,3}m", "aaaaaaaabbbbaabbbbm" },
541         { MUA | PCRE_DUPNAMES, 0 | F_NOMATCH, "\\k<A>{1,3}?(?<A>aa)(?<A>bb)", "aabb" },
542         { MUA | PCRE_DUPNAMES | PCRE_JAVASCRIPT_COMPAT, 0, "\\k<A>{1,3}?(?<A>aa)(?<A>bb)", "aabb" },
543         { MUA | PCRE_DUPNAMES, 0, "\\k<A>*?(?<A>aa)(?<A>bb)", "aabb" },
544         { MUA | PCRE_DUPNAMES, 0, "(?:(?<A>aa)|(?<A>bb))\\k<A>{0,3}?m", "aaaaaabbbbbbaabbbbbbbbbbm" },
545         { MUA | PCRE_DUPNAMES, 0, "(?:(?<A>aa)|(?<A>bb))\\k<A>*?m", "aaaaaabbbbbbaabbbbbbbbbbm" },
546         { MUA | PCRE_DUPNAMES, 0, "(?:(?<A>aa)|(?<A>bb))\\k<A>{2,3}?", "aaaabbbbaaaabbbbbbbbbb" },
547         { CMUA | PCRE_DUPNAMES, 0, "(?:(?<A>AA)|(?<A>BB))\\k<A>{0,3}M", "aaaaaaaabbbbaabbbbm" },
548         { CMUA | PCRE_DUPNAMES, 0, "(?:(?<A>AA)|(?<A>BB))\\k<A>{1,3}M", "aaaaaaaabbbbaabbbbm" },
549         { CMUA | PCRE_DUPNAMES, 0, "(?:(?<A>AA)|(?<A>BB))\\k<A>{0,3}?M", "aaaaaabbbbbbaabbbbbbbbbbm" },
550         { CMUA | PCRE_DUPNAMES, 0, "(?:(?<A>AA)|(?<A>BB))\\k<A>{2,3}?", "aaaabbbbaaaabbbbbbbbbb" },
551
552         /* Assertions. */
553         { MUA, 0, "(?=xx|yy|zz)\\w{4}", "abczzdefg" },
554         { MUA, 0, "(?=((\\w+)b){3}|ab)", "dbbbb ab" },
555         { MUA, 0, "(?!ab|bc|cd)[a-z]{2}", "Xabcdef" },
556         { MUA, 0, "(?<=aaa|aa|a)a", "aaa" },
557         { MUA, 2, "(?<=aaa|aa|a)a", "aaa" },
558         { MA, 0, "(?<=aaa|aa|a)a", "aaa" },
559         { MA, 2, "(?<=aaa|aa|a)a", "aaa" },
560         { MUA, 0, "(\\d{2})(?!\\w+c|(((\\w?)m){2}n)+|\\1)", "x5656" },
561         { MUA, 0, "((?=((\\d{2,6}\\w){2,}))\\w{5,20}K){2,}", "567v09708K12l00M00 567v09708K12l00M00K45K" },
562         { MUA, 0, "(?=(?:(?=\\S+a)\\w*(b)){3})\\w+\\d", "bba bbab nbbkba nbbkba0kl" },
563         { MUA, 0, "(?>a(?>(b+))a(?=(..)))*?k", "acabbcabbaabacabaabbakk" },
564         { MUA, 0, "((?(?=(a))a)+k)", "bbak" },
565         { MUA, 0, "((?(?=a)a)+k)", "bbak" },
566         { MUA, 0 | F_NOMATCH, "(?=(?>(a))m)amk", "a k" },
567         { MUA, 0 | F_NOMATCH, "(?!(?>(a))m)amk", "a k" },
568         { MUA, 0 | F_NOMATCH, "(?>(?=(a))am)amk", "a k" },
569         { MUA, 0, "(?=(?>a|(?=(?>(b+))a|c)[a-c]+)*?m)[a-cm]+k", "aaam bbam baaambaam abbabba baaambaamk" },
570         { MUA, 0, "(?> ?\?\\b(?(?=\\w{1,4}(a))m)\\w{0,8}bc){2,}?", "bca ssbc mabd ssbc mabc" },
571         { MUA, 0, "(?:(?=ab)?[^n][^n])+m", "ababcdabcdcdabnababcdabcdcdabm" },
572         { MUA, 0, "(?:(?=a(b))?[^n][^n])+m", "ababcdabcdcdabnababcdabcdcdabm" },
573         { MUA, 0, "(?:(?=.(.))??\\1.)+m", "aabbbcbacccanaabbbcbacccam" },
574         { MUA, 0, "(?:(?=.)??[a-c])+m", "abacdcbacacdcaccam" },
575         { MUA, 0, "((?!a)?(?!([^a]))?)+$", "acbab" },
576         { MUA, 0, "((?!a)?\?(?!([^a]))?\?)+$", "acbab" },
577
578         /* Not empty, ACCEPT, FAIL */
579         { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a*", "bcx" },
580         { MUA | PCRE_NOTEMPTY, 0, "a*", "bcaad" },
581         { MUA | PCRE_NOTEMPTY, 0, "a*?", "bcaad" },
582         { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*", "bcaad" },
583         { MUA, 0, "a(*ACCEPT)b", "ab" },
584         { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a*(*ACCEPT)b", "bcx" },
585         { MUA | PCRE_NOTEMPTY, 0, "a*(*ACCEPT)b", "bcaad" },
586         { MUA | PCRE_NOTEMPTY, 0, "a*?(*ACCEPT)b", "bcaad" },
587         { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "(?:z|a*(*ACCEPT)b)", "bcx" },
588         { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*(*ACCEPT)b)", "bcaad" },
589         { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*?(*ACCEPT)b)", "bcaad" },
590         { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*(*ACCEPT)b", "bcx" },
591         { MUA | PCRE_NOTEMPTY_ATSTART, 0 | F_NOMATCH, "a*(*ACCEPT)b", "" },
592         { MUA, 0, "((a(*ACCEPT)b))", "ab" },
593         { MUA, 0, "(a(*FAIL)a|a)", "aaa" },
594         { MUA, 0, "(?=ab(*ACCEPT)b)a", "ab" },
595         { MUA, 0, "(?=(?:x|ab(*ACCEPT)b))", "ab" },
596         { MUA, 0, "(?=(a(b(*ACCEPT)b)))a", "ab" },
597         { MUA | PCRE_NOTEMPTY, 0, "(?=a*(*ACCEPT))c", "c" },
598
599         /* Conditional blocks. */
600         { MUA, 0, "(?(?=(a))a|b)+k", "ababbalbbadabak" },
601         { MUA, 0, "(?(?!(b))a|b)+k", "ababbalbbadabak" },
602         { MUA, 0, "(?(?=a)a|b)+k", "ababbalbbadabak" },
603         { MUA, 0, "(?(?!b)a|b)+k", "ababbalbbadabak" },
604         { MUA, 0, "(?(?=(a))a*|b*)+k", "ababbalbbadabak" },
605         { MUA, 0, "(?(?!(b))a*|b*)+k", "ababbalbbadabak" },
606         { MUA, 0, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },
607         { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },
608         { MUA, 0 | F_DIFF, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" },
609         { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" },
610         { MUA, 0, "(?(?=a)a*|b*)+k", "ababbalbbadabak" },
611         { MUA, 0, "(?(?!b)a*|b*)+k", "ababbalbbadabak" },
612         { MUA, 0, "(?(?=a)ab)", "a" },
613         { MUA, 0, "(?(?<!b)c)", "b" },
614         { MUA, 0, "(?(DEFINE)a(b))", "a" },
615         { MUA, 0, "a(?(DEFINE)(?:b|(?:c?)+)*)", "a" },
616         { MUA, 0, "(?(?=.[a-c])[k-l]|[A-D])", "kdB" },
617         { MUA, 0, "(?(?!.{0,4}[cd])(aa|bb)|(cc|dd))+", "aabbccddaa" },
618         { MUA, 0, "(?(?=[^#@]*@)(aaab|aa|aba)|(aba|aab)){3,}", "aaabaaaba#aaabaaaba#aaabaaaba@" },
619         { MUA, 0, "((?=\\w{5})\\w(?(?=\\w*k)\\d|[a-f_])*\\w\\s)+", "mol m10kk m088k _f_a_ mbkkl" },
620         { MUA, 0, "(c)?\?(?(1)a|b)", "cdcaa" },
621         { MUA, 0, "(c)?\?(?(1)a|b)", "cbb" },
622         { MUA, 0 | F_DIFF, "(?(?=(a))(aaaa|a?))+aak", "aaaaab aaaaak" },
623         { MUA, 0, "(?(?=a)(aaaa|a?))+aak", "aaaaab aaaaak" },
624         { MUA, 0, "(?(?!(b))(aaaa|a?))+aak", "aaaaab aaaaak" },
625         { MUA, 0, "(?(?!b)(aaaa|a?))+aak", "aaaaab aaaaak" },
626         { MUA, 0 | F_DIFF, "(?(?=(a))a*)+aak", "aaaaab aaaaak" },
627         { MUA, 0, "(?(?=a)a*)+aak", "aaaaab aaaaak" },
628         { MUA, 0, "(?(?!(b))a*)+aak", "aaaaab aaaaak" },
629         { MUA, 0, "(?(?!b)a*)+aak", "aaaaab aaaaak" },
630         { MUA, 0, "(?(?=(?=(?!(x))a)aa)aaa|(?(?=(?!y)bb)bbb))*k", "abaabbaaabbbaaabbb abaabbaaabbbaaabbbk" },
631         { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)*l", "bc ddd abccabccl" },
632         { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+?dd", "bcabcacdb bdddd" },
633         { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+l", "ababccddabdbccd abcccl" },
634         { MUA, 0, "((?:a|aa)(?(1)aaa))x", "aax" },
635         { MUA, 0, "(?(?!)a|b)", "ab" },
636         { MUA, 0, "(?(?!)a)", "ab" },
637         { MUA, 0 | F_NOMATCH, "(?(?!)a|b)", "ac" },
638
639         /* Set start of match. */
640         { MUA, 0, "(?:\\Ka)*aaaab", "aaaaaaaa aaaaaaabb" },
641         { MUA, 0, "(?>\\Ka\\Ka)*aaaab", "aaaaaaaa aaaaaaaaaabb" },
642         { MUA, 0, "a+\\K(?<=\\Gaa)a", "aaaaaa" },
643         { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a\\K(*ACCEPT)b", "aa" },
644         { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a\\K(*ACCEPT)b", "aa" },
645
646         /* First line. */
647         { MUA | PCRE_FIRSTLINE, 0 | F_PROPERTY, "\\p{Any}a", "bb\naaa" },
648         { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH | F_PROPERTY, "\\p{Any}a", "bb\r\naaa" },
649         { MUA | PCRE_FIRSTLINE, 0, "(?<=a)", "a" },
650         { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[^a][^b]", "ab" },
651         { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "a", "\na" },
652         { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[abc]", "\na" },
653         { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^a", "\na" },
654         { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^(?<=\n)", "\na" },
655         { MUA | PCRE_FIRSTLINE, 0, "\xf0\x90\x90\x80", "\xf0\x90\x90\x80" },
656         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\xc2\x85#" },
657         { PCRE_MULTILINE | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\x85#" },
658         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^#", "\xe2\x80\xa8#" },
659         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_PROPERTY, "\\p{Any}", "\r\na" },
660         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, ".", "\r" },
661         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "a", "\ra" },
662         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_NOMATCH, "ba", "bbb\r\nba" },
663         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_NOMATCH | F_PROPERTY, "\\p{Any}{4}|a", "\r\na" },
664         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 1, ".", "\r\n" },
665         { PCRE_FIRSTLINE | PCRE_NEWLINE_LF | PCRE_DOTALL, 0 | F_NOMATCH, "ab.", "ab" },
666         { MUA | PCRE_FIRSTLINE, 1 | F_NOMATCH, "^[a-d0-9]", "\nxx\nd" },
667
668         /* Recurse. */
669         { MUA, 0, "(a)(?1)", "aa" },
670         { MUA, 0, "((a))(?1)", "aa" },
671         { MUA, 0, "(b|a)(?1)", "aa" },
672         { MUA, 0, "(b|(a))(?1)", "aa" },
673         { MUA, 0 | F_NOMATCH, "((a)(b)(?:a*))(?1)", "aba" },
674         { MUA, 0, "((a)(b)(?:a*))(?1)", "abab" },
675         { MUA, 0, "((a+)c(?2))b(?1)", "aacaabaca" },
676         { MUA, 0, "((?2)b|(a)){2}(?1)", "aabab" },
677         { MUA, 0, "(?1)(a)*+(?2)(b(?1))", "aababa" },
678         { MUA, 0, "(?1)(((a(*ACCEPT)))b)", "axaa" },
679         { MUA, 0, "(?1)(?(DEFINE) (((ac(*ACCEPT)))b) )", "akaac" },
680         { MUA, 0, "(a+)b(?1)b\\1", "abaaabaaaaa" },
681         { MUA, 0 | F_NOMATCH, "(?(DEFINE)(aa|a))(?1)ab", "aab" },
682         { MUA, 0, "(?(DEFINE)(a\\Kb))(?1)+ababc", "abababxabababc" },
683         { MUA, 0, "(a\\Kb)(?1)+ababc", "abababxababababc" },
684         { MUA, 0 | F_NOMATCH, "(a\\Kb)(?1)+ababc", "abababxababababxc" },
685         { MUA, 0, "b|<(?R)*>", "<<b>" },
686         { MUA, 0, "(a\\K){0}(?:(?1)b|ac)", "ac" },
687         { MUA, 0, "(?(DEFINE)(a(?2)|b)(b(?1)|(a)))(?:(?1)|(?2))m", "ababababnababababaam" },
688         { MUA, 0, "(a)((?(R)a|b))(?2)", "aabbabaa" },
689         { MUA, 0, "(a)((?(R2)a|b))(?2)", "aabbabaa" },
690         { MUA, 0, "(a)((?(R1)a|b))(?2)", "ababba" },
691         { MUA, 0, "(?(R0)aa|bb(?R))", "abba aabb bbaa" },
692         { MUA, 0, "((?(R)(?:aaaa|a)|(?:(aaaa)|(a)))+)(?1)$", "aaaaaaaaaa aaaa" },
693         { MUA, 0, "(?P<Name>a(?(R&Name)a|b))(?1)", "aab abb abaa" },
694         { MUA, 0, "((?(R)a|(?1)){3})", "XaaaaaaaaaX" },
695         { MUA, 0, "((?:(?(R)a|(?1))){3})", "XaaaaaaaaaX" },
696         { MUA, 0, "((?(R)a|(?1)){1,3})aaaaaa", "aaaaaaaaXaaaaaaaaa" },
697         { MUA, 0, "((?(R)a|(?1)){1,3}?)M", "aaaM" },
698
699         /* 16 bit specific tests. */
700         { CMA, 0 | F_FORCECONV, "\xc3\xa1", "\xc3\x81\xc3\xa1" },
701         { CMA, 0 | F_FORCECONV, "\xe1\xbd\xb8", "\xe1\xbf\xb8\xe1\xbd\xb8" },
702         { CMA, 0 | F_FORCECONV, "[\xc3\xa1]", "\xc3\x81\xc3\xa1" },
703         { CMA, 0 | F_FORCECONV, "[\xe1\xbd\xb8]", "\xe1\xbf\xb8\xe1\xbd\xb8" },
704         { CMA, 0 | F_FORCECONV, "[a-\xed\xb0\x80]", "A" },
705         { CMA, 0 | F_NO8 | F_FORCECONV, "[a-\\x{dc00}]", "B" },
706         { CMA, 0 | F_NO8 | F_NOMATCH | F_FORCECONV, "[b-\\x{dc00}]", "a" },
707         { CMA, 0 | F_NO8 | F_FORCECONV, "\xed\xa0\x80\\x{d800}\xed\xb0\x80\\x{dc00}", "\xed\xa0\x80\xed\xa0\x80\xed\xb0\x80\xed\xb0\x80" },
708         { CMA, 0 | F_NO8 | F_FORCECONV, "[\xed\xa0\x80\\x{d800}]{1,2}?[\xed\xb0\x80\\x{dc00}]{1,2}?#", "\xed\xa0\x80\xed\xa0\x80\xed\xb0\x80\xed\xb0\x80#" },
709         { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80\xed\xb0\x80#]{0,3}(?<=\xed\xb0\x80.)", "\xed\xa0\x80#\xed\xa0\x80##\xed\xb0\x80\xed\xa0\x80" },
710         { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xed\xb3\xbf]", "\xed\x9f\xbf\xed\xa0\x83" },
711         { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xed\xb3\xbf]", "\xed\xb4\x80\xed\xb3\xb0" },
712         { CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\x9f\xbf\xed\xa0\x83" },
713         { CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\xb4\x80\xed\xb3\xb0" },
714         { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xef\xbf\xbf]+[\x1-\xed\xb0\x80]+#", "\xed\xa0\x85\xc3\x81\xed\xa0\x85\xef\xbf\xb0\xc2\x85\xed\xa9\x89#" },
715         { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80][\xed\xb0\x80]{2,}", "\xed\xa0\x80\xed\xb0\x80\xed\xa0\x80\xed\xb0\x80\xed\xb0\x80\xed\xb0\x80" },
716         { MA, 0 | F_FORCECONV, "[^\xed\xb0\x80]{3,}?", "##\xed\xb0\x80#\xed\xb0\x80#\xc3\x89#\xed\xb0\x80" },
717         { MA, 0 | F_NO8 | F_FORCECONV, "[^\\x{dc00}]{3,}?", "##\xed\xb0\x80#\xed\xb0\x80#\xc3\x89#\xed\xb0\x80" },
718         { CMA, 0 | F_FORCECONV, ".\\B.", "\xed\xa0\x80\xed\xb0\x80" },
719         { CMA, 0 | F_FORCECONV, "\\D+(?:\\d+|.)\\S+(?:\\s+|.)\\W+(?:\\w+|.)\xed\xa0\x80\xed\xa0\x80", "\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80" },
720         { CMA, 0 | F_FORCECONV, "\\d*\\s*\\w*\xed\xa0\x80\xed\xa0\x80", "\xed\xa0\x80\xed\xa0\x80" },
721         { CMA, 0 | F_FORCECONV | F_NOMATCH, "\\d*?\\D*?\\s*?\\S*?\\w*?\\W*?##", "\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80#" },
722         { CMA | PCRE_EXTENDED, 0 | F_FORCECONV, "\xed\xa0\x80 \xed\xb0\x80 !", "\xed\xa0\x80\xed\xb0\x80!" },
723         { CMA, 0 | F_FORCECONV, "\xed\xa0\x80+#[^#]+\xed\xa0\x80", "\xed\xa0\x80#a\xed\xa0\x80" },
724         { CMA, 0 | F_FORCECONV, "(\xed\xa0\x80+)#\\1", "\xed\xa0\x80\xed\xa0\x80#\xed\xa0\x80\xed\xa0\x80" },
725         { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0 | F_NO8 | F_FORCECONV, "^-", "a--\xe2\x80\xa8--" },
726         { PCRE_BSR_UNICODE, 0 | F_NO8 | F_FORCECONV, "\\R", "ab\xe2\x80\xa8" },
727         { 0, 0 | F_NO8 | F_FORCECONV, "\\v", "ab\xe2\x80\xa9" },
728         { 0, 0 | F_NO8 | F_FORCECONV, "\\h", "ab\xe1\xa0\x8e" },
729         { 0, 0 | F_NO8 | F_FORCECONV, "\\v+?\\V+?#", "\xe2\x80\xa9\xe2\x80\xa9\xef\xbf\xbf\xef\xbf\xbf#" },
730         { 0, 0 | F_NO8 | F_FORCECONV, "\\h+?\\H+?#", "\xe1\xa0\x8e\xe1\xa0\x8e\xef\xbf\xbf\xef\xbf\xbf#" },
731
732         /* Partial matching. */
733         { MUA | PCRE_PARTIAL_SOFT, 0, "ab", "a" },
734         { MUA | PCRE_PARTIAL_SOFT, 0, "ab|a", "a" },
735         { MUA | PCRE_PARTIAL_HARD, 0, "ab|a", "a" },
736         { MUA | PCRE_PARTIAL_SOFT, 0, "\\b#", "a" },
737         { MUA | PCRE_PARTIAL_SOFT, 0, "(?<=a)b", "a" },
738         { MUA | PCRE_PARTIAL_SOFT, 0, "abc|(?<=xxa)bc", "xxab" },
739         { MUA | PCRE_PARTIAL_SOFT, 0, "a\\B", "a" },
740         { MUA | PCRE_PARTIAL_HARD, 0, "a\\b", "a" },
741
742         /* (*MARK) verb. */
743         { MUA, 0, "a(*MARK:aa)a", "ababaa" },
744         { MUA, 0 | F_NOMATCH, "a(*:aa)a", "abab" },
745         { MUA, 0, "a(*:aa)(b(*:bb)b|bc)", "abc" },
746         { MUA, 0 | F_NOMATCH, "a(*:1)x|b(*:2)y", "abc" },
747         { MUA, 0, "(?>a(*:aa))b|ac", "ac" },
748         { MUA, 0, "(?(DEFINE)(a(*:aa)))(?1)", "a" },
749         { MUA, 0 | F_NOMATCH, "(?(DEFINE)((a)(*:aa)))(?1)b", "aa" },
750         { MUA, 0, "(?(DEFINE)(a(*:aa)))a(?1)b|aac", "aac" },
751         { MUA, 0, "(a(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
752         { MUA, 0, "(a(*:aa)){0}(?:b(?1)b)+", "babba" },
753         { MUA, 0 | F_NOMATCH | F_STUDY, "(a(*:aa)){0}(?:b(?1)b)+", "ba" },
754         { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
755         { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b)+", "babba" },
756         { MUA, 0 | F_NOMATCH | F_STUDY, "(a\\K(*:aa)){0}(?:b(?1)b)+", "ba" },
757         { MUA, 0 | F_NOMATCH | F_STUDY, "(*:mark)m", "a" },
758
759         /* (*COMMIT) verb. */
760         { MUA, 0 | F_NOMATCH, "a(*COMMIT)b", "ac" },
761         { MUA, 0, "aa(*COMMIT)b", "xaxaab" },
762         { MUA, 0 | F_NOMATCH, "a(*COMMIT)(*:msg)b|ac", "ac" },
763         { MUA, 0 | F_NOMATCH, "(a(*COMMIT)b)++", "abac" },
764         { MUA, 0 | F_NOMATCH, "((a)(*COMMIT)b)++", "abac" },
765         { MUA, 0 | F_NOMATCH, "(?=a(*COMMIT)b)ab|ad", "ad" },
766
767         /* (*PRUNE) verb. */
768         { MUA, 0, "aa\\K(*PRUNE)b", "aaab" },
769         { MUA, 0, "aa(*PRUNE:bb)b|a", "aa" },
770         { MUA, 0, "(a)(a)(*PRUNE)b|(a)", "aa" },
771         { MUA, 0, "(a)(a)(a)(a)(a)(a)(a)(a)(*PRUNE)b|(a)", "aaaaaaaa" },
772         { MUA | PCRE_PARTIAL_SOFT, 0, "a(*PRUNE)a|", "a" },
773         { MUA | PCRE_PARTIAL_SOFT, 0, "a(*PRUNE)a|m", "a" },
774         { MUA, 0 | F_NOMATCH, "(?=a(*PRUNE)b)ab|ad", "ad" },
775         { MUA, 0, "a(*COMMIT)(*PRUNE)d|bc", "abc" },
776         { MUA, 0, "(?=a(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
777         { MUA, 0 | F_NOMATCH, "(*COMMIT)(?=a(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
778         { MUA, 0, "(?=(a)(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
779         { MUA, 0 | F_NOMATCH, "(*COMMIT)(?=(a)(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
780         { MUA, 0, "(a(*COMMIT)b){0}a(?1)(*PRUNE)c|bc", "abc" },
781         { MUA, 0 | F_NOMATCH, "(a(*COMMIT)b){0}a(*COMMIT)(?1)(*PRUNE)c|bc", "abc" },
782         { MUA, 0, "(a(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
783         { MUA, 0 | F_NOMATCH, "(*COMMIT)(a(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
784         { MUA, 0, "((a)(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
785         { MUA, 0 | F_NOMATCH, "(*COMMIT)((a)(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
786         { MUA, 0, "(?>a(*COMMIT)b)*abab(*PRUNE)d|ba", "ababab" },
787         { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)*abab(*PRUNE)d|ba", "ababab" },
788         { MUA, 0, "(?>a(*COMMIT)b)+abab(*PRUNE)d|ba", "ababab" },
789         { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)+abab(*PRUNE)d|ba", "ababab" },
790         { MUA, 0, "(?>a(*COMMIT)b)?ab(*PRUNE)d|ba", "aba" },
791         { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)?ab(*PRUNE)d|ba", "aba" },
792         { MUA, 0, "(?>a(*COMMIT)b)*?n(*PRUNE)d|ba", "abababn" },
793         { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)*?n(*PRUNE)d|ba", "abababn" },
794         { MUA, 0, "(?>a(*COMMIT)b)+?n(*PRUNE)d|ba", "abababn" },
795         { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)+?n(*PRUNE)d|ba", "abababn" },
796         { MUA, 0, "(?>a(*COMMIT)b)??n(*PRUNE)d|bn", "abn" },
797         { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)??n(*PRUNE)d|bn", "abn" },
798
799         /* (*SKIP) verb. */
800         { MUA, 0 | F_NOMATCH, "(?=a(*SKIP)b)ab|ad", "ad" },
801
802         /* (*THEN) verb. */
803         { MUA, 0, "((?:a(*THEN)|aab)(*THEN)c|a+)+m", "aabcaabcaabcaabcnacm" },
804         { MUA, 0 | F_NOMATCH, "((?:a(*THEN)|aab)(*THEN)c|a+)+m", "aabcm" },
805         { MUA, 0, "((?:a(*THEN)|aab)c|a+)+m", "aabcaabcnmaabcaabcm" },
806         { MUA, 0, "((?:a|aab)(*THEN)c|a+)+m", "aam" },
807         { MUA, 0, "((?:a(*COMMIT)|aab)(*THEN)c|a+)+m", "aam" },
808         { MUA, 0, "(?(?=a(*THEN)b)ab|ad)", "ad" },
809         { MUA, 0, "(?(?!a(*THEN)b)ad|add)", "add" },
810         { MUA, 0 | F_NOMATCH, "(?(?=a)a(*THEN)b|ad)", "ad" },
811         { MUA, 0, "(?!(?(?=a)ab|b(*THEN)d))bn|bnn", "bnn" },
812
813         /* Deep recursion. */
814         { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },
815         { MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " },
816         { MUA, 0, "((a?)+)+b", "aaaaaaaaaaaa b" },
817
818         /* Deep recursion: Stack limit reached. */
819         { MA, 0 | F_NOMATCH, "a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaa" },
820         { MA, 0 | F_NOMATCH, "(?:a+)+b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
821         { MA, 0 | F_NOMATCH, "(?:a+?)+?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
822         { MA, 0 | F_NOMATCH, "(?:a*)*b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
823         { MA, 0 | F_NOMATCH, "(?:a*?)*?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
824
825         { 0, 0, NULL, NULL }
826 };
827
828 static const unsigned char *tables(int mode)
829 {
830         /* The purpose of this function to allow valgrind
831         for reporting invalid reads and writes. */
832         static unsigned char *tables_copy;
833         const char *errorptr;
834         int erroroffset;
835         unsigned char *default_tables;
836 #if defined SUPPORT_PCRE8
837         pcre *regex;
838         char null_str[1] = { 0 };
839 #elif defined SUPPORT_PCRE16
840         pcre16 *regex;
841         PCRE_UCHAR16 null_str[1] = { 0 };
842 #elif defined SUPPORT_PCRE32
843         pcre32 *regex;
844         PCRE_UCHAR32 null_str[1] = { 0 };
845 #endif
846
847         if (mode) {
848                 if (tables_copy)
849                         free(tables_copy);
850                 tables_copy = NULL;
851                 return NULL;
852         }
853
854         if (tables_copy)
855                 return tables_copy;
856
857         default_tables = NULL;
858 #if defined SUPPORT_PCRE8
859         regex = pcre_compile(null_str, 0, &errorptr, &erroroffset, NULL);
860         if (regex) {
861                 pcre_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
862                 pcre_free(regex);
863         }
864 #elif defined SUPPORT_PCRE16
865         regex = pcre16_compile(null_str, 0, &errorptr, &erroroffset, NULL);
866         if (regex) {
867                 pcre16_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
868                 pcre16_free(regex);
869         }
870 #elif defined SUPPORT_PCRE32
871         regex = pcre32_compile(null_str, 0, &errorptr, &erroroffset, NULL);
872         if (regex) {
873                 pcre32_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
874                 pcre32_free(regex);
875         }
876 #endif
877         /* Shouldn't ever happen. */
878         if (!default_tables)
879                 return NULL;
880
881         /* Unfortunately this value cannot get from pcre_fullinfo.
882         Since this is a test program, this is acceptable at the moment. */
883         tables_copy = (unsigned char *)malloc(1088);
884         if (!tables_copy)
885                 return NULL;
886
887         memcpy(tables_copy, default_tables, 1088);
888         return tables_copy;
889 }
890
891 #ifdef SUPPORT_PCRE8
892 static pcre_jit_stack* callback8(void *arg)
893 {
894         return (pcre_jit_stack *)arg;
895 }
896 #endif
897
898 #ifdef SUPPORT_PCRE16
899 static pcre16_jit_stack* callback16(void *arg)
900 {
901         return (pcre16_jit_stack *)arg;
902 }
903 #endif
904
905 #ifdef SUPPORT_PCRE32
906 static pcre32_jit_stack* callback32(void *arg)
907 {
908         return (pcre32_jit_stack *)arg;
909 }
910 #endif
911
912 #ifdef SUPPORT_PCRE8
913 static pcre_jit_stack *stack8;
914
915 static pcre_jit_stack *getstack8(void)
916 {
917         if (!stack8)
918                 stack8 = pcre_jit_stack_alloc(1, 1024 * 1024);
919         return stack8;
920 }
921
922 static void setstack8(pcre_extra *extra)
923 {
924         if (!extra) {
925                 if (stack8)
926                         pcre_jit_stack_free(stack8);
927                 stack8 = NULL;
928                 return;
929         }
930
931         pcre_assign_jit_stack(extra, callback8, getstack8());
932 }
933 #endif /* SUPPORT_PCRE8 */
934
935 #ifdef SUPPORT_PCRE16
936 static pcre16_jit_stack *stack16;
937
938 static pcre16_jit_stack *getstack16(void)
939 {
940         if (!stack16)
941                 stack16 = pcre16_jit_stack_alloc(1, 1024 * 1024);
942         return stack16;
943 }
944
945 static void setstack16(pcre16_extra *extra)
946 {
947         if (!extra) {
948                 if (stack16)
949                         pcre16_jit_stack_free(stack16);
950                 stack16 = NULL;
951                 return;
952         }
953
954         pcre16_assign_jit_stack(extra, callback16, getstack16());
955 }
956 #endif /* SUPPORT_PCRE16 */
957
958 #ifdef SUPPORT_PCRE32
959 static pcre32_jit_stack *stack32;
960
961 static pcre32_jit_stack *getstack32(void)
962 {
963         if (!stack32)
964                 stack32 = pcre32_jit_stack_alloc(1, 1024 * 1024);
965         return stack32;
966 }
967
968 static void setstack32(pcre32_extra *extra)
969 {
970         if (!extra) {
971                 if (stack32)
972                         pcre32_jit_stack_free(stack32);
973                 stack32 = NULL;
974                 return;
975         }
976
977         pcre32_assign_jit_stack(extra, callback32, getstack32());
978 }
979 #endif /* SUPPORT_PCRE32 */
980
981 #ifdef SUPPORT_PCRE16
982
983 static int convert_utf8_to_utf16(const char *input, PCRE_UCHAR16 *output, int *offsetmap, int max_length)
984 {
985         unsigned char *iptr = (unsigned char*)input;
986         PCRE_UCHAR16 *optr = output;
987         unsigned int c;
988
989         if (max_length == 0)
990                 return 0;
991
992         while (*iptr && max_length > 1) {
993                 c = 0;
994                 if (offsetmap)
995                         *offsetmap++ = (int)(iptr - (unsigned char*)input);
996
997                 if (*iptr < 0xc0)
998                         c = *iptr++;
999                 else if (!(*iptr & 0x20)) {
1000                         c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
1001                         iptr += 2;
1002                 } else if (!(*iptr & 0x10)) {
1003                         c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
1004                         iptr += 3;
1005                 } else if (!(*iptr & 0x08)) {
1006                         c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
1007                         iptr += 4;
1008                 }
1009
1010                 if (c < 65536) {
1011                         *optr++ = c;
1012                         max_length--;
1013                 } else if (max_length <= 2) {
1014                         *optr = '\0';
1015                         return (int)(optr - output);
1016                 } else {
1017                         c -= 0x10000;
1018                         *optr++ = 0xd800 | ((c >> 10) & 0x3ff);
1019                         *optr++ = 0xdc00 | (c & 0x3ff);
1020                         max_length -= 2;
1021                         if (offsetmap)
1022                                 offsetmap++;
1023                 }
1024         }
1025         if (offsetmap)
1026                 *offsetmap = (int)(iptr - (unsigned char*)input);
1027         *optr = '\0';
1028         return (int)(optr - output);
1029 }
1030
1031 static int copy_char8_to_char16(const char *input, PCRE_UCHAR16 *output, int max_length)
1032 {
1033         unsigned char *iptr = (unsigned char*)input;
1034         PCRE_UCHAR16 *optr = output;
1035
1036         if (max_length == 0)
1037                 return 0;
1038
1039         while (*iptr && max_length > 1) {
1040                 *optr++ = *iptr++;
1041                 max_length--;
1042         }
1043         *optr = '\0';
1044         return (int)(optr - output);
1045 }
1046
1047 #define REGTEST_MAX_LENGTH16 4096
1048 static PCRE_UCHAR16 regtest_buf16[REGTEST_MAX_LENGTH16];
1049 static int regtest_offsetmap16[REGTEST_MAX_LENGTH16];
1050
1051 #endif /* SUPPORT_PCRE16 */
1052
1053 #ifdef SUPPORT_PCRE32
1054
1055 static int convert_utf8_to_utf32(const char *input, PCRE_UCHAR32 *output, int *offsetmap, int max_length)
1056 {
1057         unsigned char *iptr = (unsigned char*)input;
1058         PCRE_UCHAR32 *optr = output;
1059         unsigned int c;
1060
1061         if (max_length == 0)
1062                 return 0;
1063
1064         while (*iptr && max_length > 1) {
1065                 c = 0;
1066                 if (offsetmap)
1067                         *offsetmap++ = (int)(iptr - (unsigned char*)input);
1068
1069                 if (*iptr < 0xc0)
1070                         c = *iptr++;
1071                 else if (!(*iptr & 0x20)) {
1072                         c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
1073                         iptr += 2;
1074                 } else if (!(*iptr & 0x10)) {
1075                         c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
1076                         iptr += 3;
1077                 } else if (!(*iptr & 0x08)) {
1078                         c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
1079                         iptr += 4;
1080                 }
1081
1082                 *optr++ = c;
1083                 max_length--;
1084         }
1085         if (offsetmap)
1086                 *offsetmap = (int)(iptr - (unsigned char*)input);
1087         *optr = 0;
1088         return (int)(optr - output);
1089 }
1090
1091 static int copy_char8_to_char32(const char *input, PCRE_UCHAR32 *output, int max_length)
1092 {
1093         unsigned char *iptr = (unsigned char*)input;
1094         PCRE_UCHAR32 *optr = output;
1095
1096         if (max_length == 0)
1097                 return 0;
1098
1099         while (*iptr && max_length > 1) {
1100                 *optr++ = *iptr++;
1101                 max_length--;
1102         }
1103         *optr = '\0';
1104         return (int)(optr - output);
1105 }
1106
1107 #define REGTEST_MAX_LENGTH32 4096
1108 static PCRE_UCHAR32 regtest_buf32[REGTEST_MAX_LENGTH32];
1109 static int regtest_offsetmap32[REGTEST_MAX_LENGTH32];
1110
1111 #endif /* SUPPORT_PCRE32 */
1112
1113 static int check_ascii(const char *input)
1114 {
1115         const unsigned char *ptr = (unsigned char *)input;
1116         while (*ptr) {
1117                 if (*ptr > 127)
1118                         return 0;
1119                 ptr++;
1120         }
1121         return 1;
1122 }
1123
1124 static int regression_tests(void)
1125 {
1126         struct regression_test_case *current = regression_test_cases;
1127         const char *error;
1128         char *cpu_info;
1129         int i, err_offs;
1130         int is_successful, is_ascii;
1131         int total = 0;
1132         int successful = 0;
1133         int successful_row = 0;
1134         int counter = 0;
1135         int study_mode;
1136         int utf = 0, ucp = 0;
1137         int disabled_flags = 0;
1138 #ifdef SUPPORT_PCRE8
1139         pcre *re8;
1140         pcre_extra *extra8;
1141         pcre_extra dummy_extra8;
1142         int ovector8_1[32];
1143         int ovector8_2[32];
1144         int return_value8[2];
1145         unsigned char *mark8_1, *mark8_2;
1146 #endif
1147 #ifdef SUPPORT_PCRE16
1148         pcre16 *re16;
1149         pcre16_extra *extra16;
1150         pcre16_extra dummy_extra16;
1151         int ovector16_1[32];
1152         int ovector16_2[32];
1153         int return_value16[2];
1154         PCRE_UCHAR16 *mark16_1, *mark16_2;
1155         int length16;
1156 #endif
1157 #ifdef SUPPORT_PCRE32
1158         pcre32 *re32;
1159         pcre32_extra *extra32;
1160         pcre32_extra dummy_extra32;
1161         int ovector32_1[32];
1162         int ovector32_2[32];
1163         int return_value32[2];
1164         PCRE_UCHAR32 *mark32_1, *mark32_2;
1165         int length32;
1166 #endif
1167
1168         /* This test compares the behaviour of interpreter and JIT. Although disabling
1169         utf or ucp may make tests fail, if the pcre_exec result is the SAME, it is
1170         still considered successful from pcre_jit_test point of view. */
1171
1172 #if defined SUPPORT_PCRE8
1173         pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1174 #elif defined SUPPORT_PCRE16
1175         pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1176 #elif defined SUPPORT_PCRE32
1177         pcre32_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1178 #endif
1179
1180         printf("Running JIT regression tests\n");
1181         printf("  target CPU of SLJIT compiler: %s\n", cpu_info);
1182
1183 #if defined SUPPORT_PCRE8
1184         pcre_config(PCRE_CONFIG_UTF8, &utf);
1185         pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1186 #elif defined SUPPORT_PCRE16
1187         pcre16_config(PCRE_CONFIG_UTF16, &utf);
1188         pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1189 #elif defined SUPPORT_PCRE32
1190         pcre32_config(PCRE_CONFIG_UTF32, &utf);
1191         pcre32_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1192 #endif
1193
1194         if (!utf)
1195                 disabled_flags |= PCRE_UTF8 | PCRE_UTF16 | PCRE_UTF32;
1196         if (!ucp)
1197                 disabled_flags |= PCRE_UCP;
1198 #ifdef SUPPORT_PCRE8
1199         printf("  in  8 bit mode with UTF-8  %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
1200 #endif
1201 #ifdef SUPPORT_PCRE16
1202         printf("  in 16 bit mode with UTF-16 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
1203 #endif
1204 #ifdef SUPPORT_PCRE32
1205         printf("  in 32 bit mode with UTF-32 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
1206 #endif
1207
1208         while (current->pattern) {
1209                 /* printf("\nPattern: %s :\n", current->pattern); */
1210                 total++;
1211                 is_ascii = 0;
1212                 if (!(current->start_offset & F_PROPERTY))
1213                         is_ascii = check_ascii(current->pattern) && check_ascii(current->input);
1214
1215                 if (current->flags & PCRE_PARTIAL_SOFT)
1216                         study_mode = PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE;
1217                 else if (current->flags & PCRE_PARTIAL_HARD)
1218                         study_mode = PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE;
1219                 else
1220                         study_mode = PCRE_STUDY_JIT_COMPILE;
1221                 error = NULL;
1222 #ifdef SUPPORT_PCRE8
1223                 re8 = NULL;
1224                 if (!(current->start_offset & F_NO8))
1225                         re8 = pcre_compile(current->pattern,
1226                                 current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1227                                 &error, &err_offs, tables(0));
1228
1229                 extra8 = NULL;
1230                 if (re8) {
1231                         error = NULL;
1232                         extra8 = pcre_study(re8, study_mode, &error);
1233                         if (!extra8) {
1234                                 printf("\n8 bit: Cannot study pattern: %s\n", current->pattern);
1235                                 pcre_free(re8);
1236                                 re8 = NULL;
1237                         }
1238                         else if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1239                                 printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);
1240                                 pcre_free_study(extra8);
1241                                 pcre_free(re8);
1242                                 re8 = NULL;
1243                         }
1244                         extra8->flags |= PCRE_EXTRA_MARK;
1245                 } else if (((utf && ucp) || is_ascii) && !(current->start_offset & F_NO8))
1246                         printf("\n8 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1247 #endif
1248 #ifdef SUPPORT_PCRE16
1249                 if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1250                         convert_utf8_to_utf16(current->pattern, regtest_buf16, NULL, REGTEST_MAX_LENGTH16);
1251                 else
1252                         copy_char8_to_char16(current->pattern, regtest_buf16, REGTEST_MAX_LENGTH16);
1253
1254                 re16 = NULL;
1255                 if (!(current->start_offset & F_NO16))
1256                         re16 = pcre16_compile(regtest_buf16,
1257                                 current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1258                                 &error, &err_offs, tables(0));
1259
1260                 extra16 = NULL;
1261                 if (re16) {
1262                         error = NULL;
1263                         extra16 = pcre16_study(re16, study_mode, &error);
1264                         if (!extra16) {
1265                                 printf("\n16 bit: Cannot study pattern: %s\n", current->pattern);
1266                                 pcre16_free(re16);
1267                                 re16 = NULL;
1268                         }
1269                         else if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1270                                 printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);
1271                                 pcre16_free_study(extra16);
1272                                 pcre16_free(re16);
1273                                 re16 = NULL;
1274                         }
1275                         extra16->flags |= PCRE_EXTRA_MARK;
1276                 } else if (((utf && ucp) || is_ascii) && !(current->start_offset & F_NO16))
1277                         printf("\n16 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1278 #endif
1279 #ifdef SUPPORT_PCRE32
1280                 if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1281                         convert_utf8_to_utf32(current->pattern, regtest_buf32, NULL, REGTEST_MAX_LENGTH32);
1282                 else
1283                         copy_char8_to_char32(current->pattern, regtest_buf32, REGTEST_MAX_LENGTH32);
1284
1285                 re32 = NULL;
1286                 if (!(current->start_offset & F_NO32))
1287                         re32 = pcre32_compile(regtest_buf32,
1288                                 current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1289                                 &error, &err_offs, tables(0));
1290
1291                 extra32 = NULL;
1292                 if (re32) {
1293                         error = NULL;
1294                         extra32 = pcre32_study(re32, study_mode, &error);
1295                         if (!extra32) {
1296                                 printf("\n32 bit: Cannot study pattern: %s\n", current->pattern);
1297                                 pcre32_free(re32);
1298                                 re32 = NULL;
1299                         }
1300                         if (!(extra32->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1301                                 printf("\n32 bit: JIT compiler does not support: %s\n", current->pattern);
1302                                 pcre32_free_study(extra32);
1303                                 pcre32_free(re32);
1304                                 re32 = NULL;
1305                         }
1306                         extra32->flags |= PCRE_EXTRA_MARK;
1307                 } else if (((utf && ucp) || is_ascii) && !(current->start_offset & F_NO32))
1308                         printf("\n32 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1309 #endif
1310
1311                 counter++;
1312                 if ((counter & 0x3) != 0) {
1313 #ifdef SUPPORT_PCRE8
1314                         setstack8(NULL);
1315 #endif
1316 #ifdef SUPPORT_PCRE16
1317                         setstack16(NULL);
1318 #endif
1319 #ifdef SUPPORT_PCRE32
1320                         setstack32(NULL);
1321 #endif
1322                 }
1323
1324 #ifdef SUPPORT_PCRE8
1325                 return_value8[0] = -1000;
1326                 return_value8[1] = -1000;
1327                 for (i = 0; i < 32; ++i)
1328                         ovector8_1[i] = -2;
1329                 for (i = 0; i < 32; ++i)
1330                         ovector8_2[i] = -2;
1331                 if (re8) {
1332                         mark8_1 = NULL;
1333                         mark8_2 = NULL;
1334                         extra8->mark = &mark8_1;
1335
1336                         if ((counter & 0x1) != 0) {
1337                                 setstack8(extra8);
1338                                 return_value8[0] = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1339                                         current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | PCRE_NO_UTF8_CHECK), ovector8_1, 32);
1340                         } else
1341                                 return_value8[0] = pcre_jit_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1342                                         current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | PCRE_NO_UTF8_CHECK), ovector8_1, 32, getstack8());
1343                         memset(&dummy_extra8, 0, sizeof(pcre_extra));
1344                         dummy_extra8.flags = PCRE_EXTRA_MARK;
1345                         if (current->start_offset & F_STUDY) {
1346                                 dummy_extra8.flags |= PCRE_EXTRA_STUDY_DATA;
1347                                 dummy_extra8.study_data = extra8->study_data;
1348                         }
1349                         dummy_extra8.mark = &mark8_2;
1350                         return_value8[1] = pcre_exec(re8, &dummy_extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1351                                 current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | PCRE_NO_UTF8_CHECK), ovector8_2, 32);
1352                 }
1353 #endif
1354
1355 #ifdef SUPPORT_PCRE16
1356                 return_value16[0] = -1000;
1357                 return_value16[1] = -1000;
1358                 for (i = 0; i < 32; ++i)
1359                         ovector16_1[i] = -2;
1360                 for (i = 0; i < 32; ++i)
1361                         ovector16_2[i] = -2;
1362                 if (re16) {
1363                         mark16_1 = NULL;
1364                         mark16_2 = NULL;
1365                         if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1366                                 length16 = convert_utf8_to_utf16(current->input, regtest_buf16, regtest_offsetmap16, REGTEST_MAX_LENGTH16);
1367                         else
1368                                 length16 = copy_char8_to_char16(current->input, regtest_buf16, REGTEST_MAX_LENGTH16);
1369                         extra16->mark = &mark16_1;
1370                         if ((counter & 0x1) != 0) {
1371                                 setstack16(extra16);
1372                                 return_value16[0] = pcre16_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1373                                         current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | PCRE_NO_UTF8_CHECK), ovector16_1, 32);
1374                         } else
1375                                 return_value16[0] = pcre16_jit_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1376                                         current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | PCRE_NO_UTF8_CHECK), ovector16_1, 32, getstack16());
1377                         memset(&dummy_extra16, 0, sizeof(pcre16_extra));
1378                         dummy_extra16.flags = PCRE_EXTRA_MARK;
1379                         if (current->start_offset & F_STUDY) {
1380                                 dummy_extra16.flags |= PCRE_EXTRA_STUDY_DATA;
1381                                 dummy_extra16.study_data = extra16->study_data;
1382                         }
1383                         dummy_extra16.mark = &mark16_2;
1384                         return_value16[1] = pcre16_exec(re16, &dummy_extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1385                                 current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | PCRE_NO_UTF8_CHECK), ovector16_2, 32);
1386                 }
1387 #endif
1388
1389 #ifdef SUPPORT_PCRE32
1390                 return_value32[0] = -1000;
1391                 return_value32[1] = -1000;
1392                 for (i = 0; i < 32; ++i)
1393                         ovector32_1[i] = -2;
1394                 for (i = 0; i < 32; ++i)
1395                         ovector32_2[i] = -2;
1396                 if (re32) {
1397                         mark32_1 = NULL;
1398                         mark32_2 = NULL;
1399                         if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1400                                 length32 = convert_utf8_to_utf32(current->input, regtest_buf32, regtest_offsetmap32, REGTEST_MAX_LENGTH32);
1401                         else
1402                                 length32 = copy_char8_to_char32(current->input, regtest_buf32, REGTEST_MAX_LENGTH32);
1403                         extra32->mark = &mark32_1;
1404                         if ((counter & 0x1) != 0) {
1405                                 setstack32(extra32);
1406                                 return_value32[0] = pcre32_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1407                                         current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | PCRE_NO_UTF8_CHECK), ovector32_1, 32);
1408                         } else
1409                                 return_value32[0] = pcre32_jit_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1410                                         current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | PCRE_NO_UTF8_CHECK), ovector32_1, 32, getstack32());
1411                         memset(&dummy_extra32, 0, sizeof(pcre32_extra));
1412                         dummy_extra32.flags = PCRE_EXTRA_MARK;
1413                         if (current->start_offset & F_STUDY) {
1414                                 dummy_extra32.flags |= PCRE_EXTRA_STUDY_DATA;
1415                                 dummy_extra32.study_data = extra32->study_data;
1416                         }
1417                         dummy_extra32.mark = &mark32_2;
1418                         return_value32[1] = pcre32_exec(re32, &dummy_extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1419                                 current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | PCRE_NO_UTF8_CHECK), ovector32_2, 32);
1420                 }
1421 #endif
1422
1423                 /* printf("[%d-%d-%d|%d-%d|%d-%d|%d-%d]%s",
1424                         return_value8[0], return_value16[0], return_value32[0],
1425                         ovector8_1[0], ovector8_1[1],
1426                         ovector16_1[0], ovector16_1[1],
1427                         ovector32_1[0], ovector32_1[1],
1428                         (current->flags & PCRE_CASELESS) ? "C" : ""); */
1429
1430                 /* If F_DIFF is set, just run the test, but do not compare the results.
1431                 Segfaults can still be captured. */
1432
1433                 is_successful = 1;
1434                 if (!(current->start_offset & F_DIFF)) {
1435 #if defined SUPPORT_UTF && ((defined(SUPPORT_PCRE8) + defined(SUPPORT_PCRE16) + defined(SUPPORT_PCRE32)) >= 2)
1436                         if (!(current->start_offset & F_FORCECONV)) {
1437                                 int return_value;
1438
1439                                 /* All results must be the same. */
1440 #ifdef SUPPORT_PCRE8
1441                                 if ((return_value = return_value8[0]) != return_value8[1]) {
1442                                         printf("\n8 bit: Return value differs(J8:%d,I8:%d): [%d] '%s' @ '%s'\n",
1443                                                 return_value8[0], return_value8[1], total, current->pattern, current->input);
1444                                         is_successful = 0;
1445                                 } else
1446 #endif
1447 #ifdef SUPPORT_PCRE16
1448                                 if ((return_value = return_value16[0]) != return_value16[1]) {
1449                                         printf("\n16 bit: Return value differs(J16:%d,I16:%d): [%d] '%s' @ '%s'\n",
1450                                                 return_value16[0], return_value16[1], total, current->pattern, current->input);
1451                                         is_successful = 0;
1452                                 } else
1453 #endif
1454 #ifdef SUPPORT_PCRE32
1455                                 if ((return_value = return_value32[0]) != return_value32[1]) {
1456                                         printf("\n32 bit: Return value differs(J32:%d,I32:%d): [%d] '%s' @ '%s'\n",
1457                                                 return_value32[0], return_value32[1], total, current->pattern, current->input);
1458                                         is_successful = 0;
1459                                 } else
1460 #endif
1461 #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1462                                 if (return_value8[0] != return_value16[0]) {
1463                                         printf("\n8 and 16 bit: Return value differs(J8:%d,J16:%d): [%d] '%s' @ '%s'\n",
1464                                                 return_value8[0], return_value16[0],
1465                                                 total, current->pattern, current->input);
1466                                         is_successful = 0;
1467                                 } else
1468 #endif
1469 #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1470                                 if (return_value8[0] != return_value32[0]) {
1471                                         printf("\n8 and 32 bit: Return value differs(J8:%d,J32:%d): [%d] '%s' @ '%s'\n",
1472                                                 return_value8[0], return_value32[0],
1473                                                 total, current->pattern, current->input);
1474                                         is_successful = 0;
1475                                 } else
1476 #endif
1477 #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE32
1478                                 if (return_value16[0] != return_value32[0]) {
1479                                         printf("\n16 and 32 bit: Return value differs(J16:%d,J32:%d): [%d] '%s' @ '%s'\n",
1480                                                 return_value16[0], return_value32[0],
1481                                                 total, current->pattern, current->input);
1482                                         is_successful = 0;
1483                                 } else
1484 #endif
1485                                 if (return_value >= 0 || return_value == PCRE_ERROR_PARTIAL) {
1486                                         if (return_value == PCRE_ERROR_PARTIAL) {
1487                                                 return_value = 2;
1488                                         } else {
1489                                                 return_value *= 2;
1490                                         }
1491 #ifdef SUPPORT_PCRE8
1492                                         return_value8[0] = return_value;
1493 #endif
1494 #ifdef SUPPORT_PCRE16
1495                                         return_value16[0] = return_value;
1496 #endif
1497 #ifdef SUPPORT_PCRE32
1498                                         return_value32[0] = return_value;
1499 #endif
1500                                         /* Transform back the results. */
1501                                         if (current->flags & PCRE_UTF8) {
1502 #ifdef SUPPORT_PCRE16
1503                                                 for (i = 0; i < return_value; ++i) {
1504                                                         if (ovector16_1[i] >= 0)
1505                                                                 ovector16_1[i] = regtest_offsetmap16[ovector16_1[i]];
1506                                                         if (ovector16_2[i] >= 0)
1507                                                                 ovector16_2[i] = regtest_offsetmap16[ovector16_2[i]];
1508                                                 }
1509 #endif
1510 #ifdef SUPPORT_PCRE32
1511                                                 for (i = 0; i < return_value; ++i) {
1512                                                         if (ovector32_1[i] >= 0)
1513                                                                 ovector32_1[i] = regtest_offsetmap32[ovector32_1[i]];
1514                                                         if (ovector32_2[i] >= 0)
1515                                                                 ovector32_2[i] = regtest_offsetmap32[ovector32_2[i]];
1516                                                 }
1517 #endif
1518                                         }
1519
1520                                         for (i = 0; i < return_value; ++i) {
1521 #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1522                                                 if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector16_1[i] || ovector8_1[i] != ovector16_2[i]) {
1523                                                         printf("\n8 and 16 bit: Ovector[%d] value differs(J8:%d,I8:%d,J16:%d,I16:%d): [%d] '%s' @ '%s' \n",
1524                                                                 i, ovector8_1[i], ovector8_2[i], ovector16_1[i], ovector16_2[i],
1525                                                                 total, current->pattern, current->input);
1526                                                         is_successful = 0;
1527                                                 }
1528 #endif
1529 #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1530                                                 if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector32_1[i] || ovector8_1[i] != ovector32_2[i]) {
1531                                                         printf("\n8 and 32 bit: Ovector[%d] value differs(J8:%d,I8:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1532                                                                 i, ovector8_1[i], ovector8_2[i], ovector32_1[i], ovector32_2[i],
1533                                                                 total, current->pattern, current->input);
1534                                                         is_successful = 0;
1535                                                 }
1536 #endif
1537 #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE16
1538                                                 if (ovector16_1[i] != ovector16_2[i] || ovector16_1[i] != ovector16_1[i] || ovector16_1[i] != ovector16_2[i]) {
1539                                                         printf("\n16 and 16 bit: Ovector[%d] value differs(J16:%d,I16:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1540                                                                 i, ovector16_1[i], ovector16_2[i], ovector16_1[i], ovector16_2[i],
1541                                                                 total, current->pattern, current->input);
1542                                                         is_successful = 0;
1543                                                 }
1544 #endif
1545                                         }
1546                                 }
1547                         } else
1548 #endif /* more than one of SUPPORT_PCRE8, SUPPORT_PCRE16 and SUPPORT_PCRE32 */
1549                         {
1550                                 /* Only the 8 bit and 16 bit results must be equal. */
1551 #ifdef SUPPORT_PCRE8
1552                                 if (return_value8[0] != return_value8[1]) {
1553                                         printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1554                                                 return_value8[0], return_value8[1], total, current->pattern, current->input);
1555                                         is_successful = 0;
1556                                 } else if (return_value8[0] >= 0 || return_value8[0] == PCRE_ERROR_PARTIAL) {
1557                                         if (return_value8[0] == PCRE_ERROR_PARTIAL)
1558                                                 return_value8[0] = 2;
1559                                         else
1560                                                 return_value8[0] *= 2;
1561
1562                                         for (i = 0; i < return_value8[0]; ++i)
1563                                                 if (ovector8_1[i] != ovector8_2[i]) {
1564                                                         printf("\n8 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1565                                                                 i, ovector8_1[i], ovector8_2[i], total, current->pattern, current->input);
1566                                                         is_successful = 0;
1567                                                 }
1568                                 }
1569 #endif
1570
1571 #ifdef SUPPORT_PCRE16
1572                                 if (return_value16[0] != return_value16[1]) {
1573                                         printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1574                                                 return_value16[0], return_value16[1], total, current->pattern, current->input);
1575                                         is_successful = 0;
1576                                 } else if (return_value16[0] >= 0 || return_value16[0] == PCRE_ERROR_PARTIAL) {
1577                                         if (return_value16[0] == PCRE_ERROR_PARTIAL)
1578                                                 return_value16[0] = 2;
1579                                         else
1580                                                 return_value16[0] *= 2;
1581
1582                                         for (i = 0; i < return_value16[0]; ++i)
1583                                                 if (ovector16_1[i] != ovector16_2[i]) {
1584                                                         printf("\n16 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1585                                                                 i, ovector16_1[i], ovector16_2[i], total, current->pattern, current->input);
1586                                                         is_successful = 0;
1587                                                 }
1588                                 }
1589 #endif
1590
1591 #ifdef SUPPORT_PCRE32
1592                                 if (return_value32[0] != return_value32[1]) {
1593                                         printf("\n32 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1594                                                 return_value32[0], return_value32[1], total, current->pattern, current->input);
1595                                         is_successful = 0;
1596                                 } else if (return_value32[0] >= 0 || return_value32[0] == PCRE_ERROR_PARTIAL) {
1597                                         if (return_value32[0] == PCRE_ERROR_PARTIAL)
1598                                                 return_value32[0] = 2;
1599                                         else
1600                                                 return_value32[0] *= 2;
1601
1602                                         for (i = 0; i < return_value32[0]; ++i)
1603                                                 if (ovector32_1[i] != ovector32_2[i]) {
1604                                                         printf("\n32 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1605                                                                 i, ovector32_1[i], ovector32_2[i], total, current->pattern, current->input);
1606                                                         is_successful = 0;
1607                                                 }
1608                                 }
1609 #endif
1610                         }
1611                 }
1612
1613                 if (is_successful) {
1614 #ifdef SUPPORT_PCRE8
1615                         if (!(current->start_offset & F_NO8) && ((utf && ucp) || is_ascii)) {
1616                                 if (return_value8[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1617                                         printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",
1618                                                 total, current->pattern, current->input);
1619                                         is_successful = 0;
1620                                 }
1621
1622                                 if (return_value8[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1623                                         printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",
1624                                                 total, current->pattern, current->input);
1625                                         is_successful = 0;
1626                                 }
1627                         }
1628 #endif
1629 #ifdef SUPPORT_PCRE16
1630                         if (!(current->start_offset & F_NO16) && ((utf && ucp) || is_ascii)) {
1631                                 if (return_value16[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1632                                         printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",
1633                                                 total, current->pattern, current->input);
1634                                         is_successful = 0;
1635                                 }
1636
1637                                 if (return_value16[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1638                                         printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",
1639                                                 total, current->pattern, current->input);
1640                                         is_successful = 0;
1641                                 }
1642                         }
1643 #endif
1644 #ifdef SUPPORT_PCRE32
1645                         if (!(current->start_offset & F_NO32) && ((utf && ucp) || is_ascii)) {
1646                                 if (return_value32[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1647                                         printf("32 bit: Test should match: [%d] '%s' @ '%s'\n",
1648                                                 total, current->pattern, current->input);
1649                                         is_successful = 0;
1650                                 }
1651
1652                                 if (return_value32[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1653                                         printf("32 bit: Test should not match: [%d] '%s' @ '%s'\n",
1654                                                 total, current->pattern, current->input);
1655                                         is_successful = 0;
1656                                 }
1657                         }
1658 #endif
1659                 }
1660
1661                 if (is_successful) {
1662 #ifdef SUPPORT_PCRE8
1663                         if (mark8_1 != mark8_2) {
1664                                 printf("8 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1665                                         total, current->pattern, current->input);
1666                                 is_successful = 0;
1667                         }
1668 #endif
1669 #ifdef SUPPORT_PCRE16
1670                         if (mark16_1 != mark16_2) {
1671                                 printf("16 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1672                                         total, current->pattern, current->input);
1673                                 is_successful = 0;
1674                         }
1675 #endif
1676 #ifdef SUPPORT_PCRE32
1677                         if (mark32_1 != mark32_2) {
1678                                 printf("32 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1679                                         total, current->pattern, current->input);
1680                                 is_successful = 0;
1681                         }
1682 #endif
1683                 }
1684
1685 #ifdef SUPPORT_PCRE8
1686                 if (re8) {
1687                         pcre_free_study(extra8);
1688                         pcre_free(re8);
1689                 }
1690 #endif
1691 #ifdef SUPPORT_PCRE16
1692                 if (re16) {
1693                         pcre16_free_study(extra16);
1694                         pcre16_free(re16);
1695                 }
1696 #endif
1697 #ifdef SUPPORT_PCRE32
1698                 if (re32) {
1699                         pcre32_free_study(extra32);
1700                         pcre32_free(re32);
1701                 }
1702 #endif
1703
1704                 if (is_successful) {
1705                         successful++;
1706                         successful_row++;
1707                         printf(".");
1708                         if (successful_row >= 60) {
1709                                 successful_row = 0;
1710                                 printf("\n");
1711                         }
1712                 } else
1713                         successful_row = 0;
1714
1715                 fflush(stdout);
1716                 current++;
1717         }
1718         tables(1);
1719 #ifdef SUPPORT_PCRE8
1720         setstack8(NULL);
1721 #endif
1722 #ifdef SUPPORT_PCRE16
1723         setstack16(NULL);
1724 #endif
1725 #ifdef SUPPORT_PCRE32
1726         setstack32(NULL);
1727 #endif
1728
1729         if (total == successful) {
1730                 printf("\nAll JIT regression tests are successfully passed.\n");
1731                 return 0;
1732         } else {
1733                 printf("\nSuccessful test ratio: %d%% (%d failed)\n", successful * 100 / total, total - successful);
1734                 return 1;
1735         }
1736 }
1737
1738 /* End of pcre_jit_test.c */