/[pcre]/code/trunk/pcre_jit_test.c
ViewVC logotype

Diff of /code/trunk/pcre_jit_test.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 736 by zherczeg, Sun Oct 16 15:48:03 2011 UTC revision 1308 by zherczeg, Tue Apr 2 06:58:55 2013 UTC
# Line 6  Line 6 
6  and semantics are as close as possible to those of the Perl 5 language.  and semantics are as close as possible to those of the Perl 5 language.
7    
8                    Main Library written by Philip Hazel                    Main Library written by Philip Hazel
9             Copyright (c) 1997-2011 University of Cambridge             Copyright (c) 1997-2012 University of Cambridge
10    
11    This JIT compiler regression test program was written by Zoltan Herczeg    This JIT compiler regression test program was written by Zoltan Herczeg
12                        Copyright (c) 2010-2011                        Copyright (c) 2010-2012
13    
14  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
15  Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
# Line 48  POSSIBILITY OF SUCH DAMAGE. Line 48  POSSIBILITY OF SUCH DAMAGE.
48  #include <string.h>  #include <string.h>
49  #include "pcre.h"  #include "pcre.h"
50    
51    
52    #include "pcre_internal.h"
53    
54  #define PCRE_BUG 0x80000000  #define PCRE_BUG 0x80000000
55    
56  /*  /*
57   Hungarian utf8 characters   Letter characters:
58   \xc3\xa9 = 0xe9 = 233 (e') \xc3\x89 = 0xc9 = 201 (E')     \xe6\x92\xad = 0x64ad = 25773 (kanji)
59   \xc3\xa1 = 0xe1 = 225 (a') \xc3\x81 = 0xc1 = 193 (A')   Non-letter characters:
60   \xe6\x92\xad = 0x64ad = 25773 (a valid kanji)     \xc2\xa1 = 0xa1 =  (Inverted Exclamation Mark)
61   \xc2\x85 = 0x85 (NExt Line = NEL)     \xf3\xa9\xb7\x80 = 0xe9dc0 = 957888
62   \xc2\xa1 = 0xa1 (Inverted Exclamation Mark)     \xed\xa0\x80 = 55296 = 0xd800 (Invalid UTF character)
63   \xe2\x80\xa8 = 0x2028 (Line Separator)     \xed\xb0\x80 = 56320 = 0xdc00 (Invalid UTF character)
64   \xc8\xba = 570 \xe2\xb1\xa5 = 11365 (lowercase length != uppercase length)   Newlines:
65   \xcc\x8d = 781 (Something with Mark property)     \xc2\x85 = 0x85 = 133 (NExt Line = NEL)
66       \xe2\x80\xa8 = 0x2028 = 8232 (Line Separator)
67     Othercase pairs:
68       \xc3\xa9 = 0xe9 = 233 (e')
69          \xc3\x89 = 0xc9 = 201 (E')
70       \xc3\xa1 = 0xe1 = 225 (a')
71          \xc3\x81 = 0xc1 = 193 (A')
72       \xc8\xba = 0x23a = 570
73          \xe2\xb1\xa5 = 0x2c65 = 11365
74       \xe1\xbd\xb8 = 0x1f78 = 8056
75          \xe1\xbf\xb8 = 0x1ff8 = 8184
76       \xf0\x90\x90\x80 = 0x10400 = 66560
77          \xf0\x90\x90\xa8 = 0x10428 = 66600
78     Mark property:
79       \xcc\x8d = 0x30d = 781
80     Special:
81       \xdf\xbf = 0x7ff = 2047 (highest 2 byte character)
82       \xe0\xa0\x80 = 0x800 = 2048 (lowest 2 byte character)
83       \xef\xbf\xbf = 0xffff = 65535 (highest 3 byte character)
84       \xf0\x90\x80\x80 = 0x10000 = 65536 (lowest 4 byte character)
85       \xf4\x8f\xbf\xbf = 0x10ffff = 1114111 (highest allowed utf character)
86  */  */
87    
 static void setstack(pcre_extra *extra);  
88  static int regression_tests(void);  static int regression_tests(void);
89    
90  int main(void)  int main(void)
91  {  {
92          int jit = 0;          int jit = 0;
93    #if defined SUPPORT_PCRE8
94          pcre_config(PCRE_CONFIG_JIT, &jit);          pcre_config(PCRE_CONFIG_JIT, &jit);
95    #elif defined SUPPORT_PCRE16
96            pcre16_config(PCRE_CONFIG_JIT, &jit);
97    #elif defined SUPPORT_PCRE32
98            pcre32_config(PCRE_CONFIG_JIT, &jit);
99    #endif
100          if (!jit) {          if (!jit) {
101                  printf("JIT must be enabled to run pcre_jit_test\n");                  printf("JIT must be enabled to run pcre_jit_test\n");
102                  return 1;                  return 1;
# Line 76  int main(void) Line 104  int main(void)
104          return regression_tests();          return regression_tests();
105  }  }
106    
 static pcre_jit_stack* callback(void *arg)  
 {  
         return (pcre_jit_stack *)arg;  
 }  
   
 static void setstack(pcre_extra *extra)  
 {  
         static pcre_jit_stack *stack;  
         if (stack) pcre_jit_stack_free(stack);  
         stack = pcre_jit_stack_alloc(1, 1024 * 1024);  
         pcre_assign_jit_stack(extra, callback, stack);  
 }  
   
107  /* --------------------------------------------------------------------------------------- */  /* --------------------------------------------------------------------------------------- */
108    
109  #define MUA     (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)  #if !(defined SUPPORT_PCRE8) && !(defined SUPPORT_PCRE16) && !(defined SUPPORT_PCRE32)
110  #define MUAP    (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)  #error SUPPORT_PCRE8 or SUPPORT_PCRE16 or SUPPORT_PCRE32 must be defined
111  #define CMUA    (PCRE_CASELESS | PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)  #endif
112  #define CMUAP   (PCRE_CASELESS | PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)  
113  #define MA      (PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF)  #define MUA     (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)
114  #define MAP     (PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)  #define MUAP    (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)
115  #define CMA     (PCRE_CASELESS | PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF)  #define CMUA    (PCRE_CASELESS | PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)
116    #define CMUAP   (PCRE_CASELESS | PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)
117    #define MA      (PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF)
118    #define MAP     (PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)
119    #define CMA     (PCRE_CASELESS | PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF)
120    
121    #define OFFSET_MASK     0x00ffff
122    #define F_NO8           0x010000
123    #define F_NO16          0x020000
124    #define F_NO32          0x020000
125    #define F_NOMATCH       0x040000
126    #define F_DIFF          0x080000
127    #define F_FORCECONV     0x100000
128    #define F_PROPERTY      0x200000
129    #define F_STUDY         0x400000
130    
131  struct regression_test_case {  struct regression_test_case {
132          int flags;          int flags;
# Line 124  static struct regression_test_case regre Line 153  static struct regression_test_case regre
153          { MUA, 0, "\\W(\\W)?\\w", "\n\n+bc" },          { MUA, 0, "\\W(\\W)?\\w", "\n\n+bc" },
154          { MUA, 0, "[axd]", "sAXd" },          { MUA, 0, "[axd]", "sAXd" },
155          { CMUA, 0, "[axd]", "sAXd" },          { CMUA, 0, "[axd]", "sAXd" },
156          { CMUA, 0, "[^axd]", "DxA" },          { CMUA, 0 | F_NOMATCH, "[^axd]", "DxA" },
157          { MUA, 0, "[a-dA-C]", "\xe6\x92\xad\xc3\xa9.B" },          { MUA, 0, "[a-dA-C]", "\xe6\x92\xad\xc3\xa9.B" },
158          { MUA, 0, "[^a-dA-C]", "\xe6\x92\xad\xc3\xa9" },          { MUA, 0, "[^a-dA-C]", "\xe6\x92\xad\xc3\xa9" },
159          { CMUA, 0, "[^\xc3\xa9]", "\xc3\xa9\xc3\x89." },          { CMUA, 0, "[^\xc3\xa9]", "\xc3\xa9\xc3\x89." },
# Line 137  static struct regression_test_case regre Line 166  static struct regression_test_case regre
166          { PCRE_CASELESS, 0, "a1", "Aa1" },          { PCRE_CASELESS, 0, "a1", "Aa1" },
167          { MA, 0, "\\Ca", "cda" },          { MA, 0, "\\Ca", "cda" },
168          { CMA, 0, "\\Ca", "CDA" },          { CMA, 0, "\\Ca", "CDA" },
169          { MA, 0, "\\Cx", "cda" },          { MA, 0 | F_NOMATCH, "\\Cx", "cda" },
170          { CMA, 0, "\\Cx", "CDA" },          { CMA, 0 | F_NOMATCH, "\\Cx", "CDA" },
171            { CMUAP, 0, "\xf0\x90\x90\x80\xf0\x90\x90\xa8", "\xf0\x90\x90\xa8\xf0\x90\x90\x80" },
172            { CMUAP, 0, "\xf0\x90\x90\x80{2}", "\xf0\x90\x90\x80#\xf0\x90\x90\xa8\xf0\x90\x90\x80" },
173            { CMUAP, 0, "\xf0\x90\x90\xa8{2}", "\xf0\x90\x90\x80#\xf0\x90\x90\xa8\xf0\x90\x90\x80" },
174            { CMUAP, 0, "\xe1\xbd\xb8\xe1\xbf\xb8", "\xe1\xbf\xb8\xe1\xbd\xb8" },
175    
176          /* Assertions. */          /* Assertions. */
177          { MUA, 0, "\\b[^A]", "A_B#" },          { MUA, 0, "\\b[^A]", "A_B#" },
178          { MA, 0, "\\b\\W", "\n*" },          { MA, 0 | F_NOMATCH, "\\b\\W", "\n*" },
179          { MUA, 0, "\\B[^,]\\b[^s]\\b", "#X" },          { MUA, 0, "\\B[^,]\\b[^s]\\b", "#X" },
180          { MAP, 0, "\\B", "_\xa1" },          { MAP, 0, "\\B", "_\xa1" },
181          { MAP, 0, "\\b_\\b[,A]\\B", "_," },          { MAP, 0, "\\b_\\b[,A]\\B", "_," },
# Line 150  static struct regression_test_case regre Line 183  static struct regression_test_case regre
183          { MUAP, 0, "\\B", "_\xc2\xa1\xc3\xa1\xc2\x85" },          { MUAP, 0, "\\B", "_\xc2\xa1\xc3\xa1\xc2\x85" },
184          { MUAP, 0, "\\b[^A]\\B[^c]\\b[^_]\\B", "_\xc3\xa1\xe2\x80\xa8" },          { MUAP, 0, "\\b[^A]\\B[^c]\\b[^_]\\B", "_\xc3\xa1\xe2\x80\xa8" },
185          { MUAP, 0, "\\b\\w+\\B", "\xc3\x89\xc2\xa1\xe6\x92\xad\xc3\x81\xc3\xa1" },          { MUAP, 0, "\\b\\w+\\B", "\xc3\x89\xc2\xa1\xe6\x92\xad\xc3\x81\xc3\xa1" },
186          { MUA, 0, "\\b.", "\xcd\xbe" },          { MUA, 0 | F_NOMATCH, "\\b.", "\xcd\xbe" },
187          { MA, 0, "\\R^", "\n" },          { CMUAP, 0, "\\By", "\xf0\x90\x90\xa8y" },
188          { MA, 1, "^", "\n" },          { MA, 0 | F_NOMATCH, "\\R^", "\n" },
189            { MA, 1 | F_NOMATCH, "^", "\n" },
190          { 0, 0, "^ab", "ab" },          { 0, 0, "^ab", "ab" },
191          { 0, 0, "^ab", "aab" },          { 0, 0 | F_NOMATCH, "^ab", "aab" },
192          { PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 0, "^a", "\r\raa\n\naa\r\naa" },          { PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 0, "^a", "\r\raa\n\naa\r\naa" },
193          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF, 0, "^-", "\xe2\x80\xa8--\xc2\x85-\r\n-" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF, 0, "^-", "\xe2\x80\xa8--\xc2\x85-\r\n-" },
194          { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "^-", "a--b--\x85--" },          { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "^-", "a--b--\x85--" },
195          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xe2\x80\xa8--" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xe2\x80\xa8--" },
196          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xc2\x85--" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xc2\x85--" },
197          { 0, 0, "ab$", "ab" },          { 0, 0, "ab$", "ab" },
198          { 0, 0, "ab$", "ab\r\n" },          { 0, 0 | F_NOMATCH, "ab$", "abab\n\n" },
199            { PCRE_DOLLAR_ENDONLY, 0 | F_NOMATCH, "ab$", "abab\r\n" },
200          { PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 0, "a$", "\r\raa\n\naa\r\naa" },          { PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 0, "a$", "\r\raa\n\naa\r\naa" },
201          { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "a$", "aaa" },          { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "a$", "aaa" },
202          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF, 0, "#$", "#\xc2\x85###\r#" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF, 0, "#$", "#\xc2\x85###\r#" },
203          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "#$", "#\xe2\x80\xa9" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "#$", "#\xe2\x80\xa9" },
204          { PCRE_NOTBOL | PCRE_NEWLINE_ANY, 0, "^a", "aa\naa" },          { PCRE_NOTBOL | PCRE_NEWLINE_ANY, 0 | F_NOMATCH, "^a", "aa\naa" },
205          { PCRE_NOTBOL | PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "^a", "aa\naa" },          { PCRE_NOTBOL | PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "^a", "aa\naa" },
206          { PCRE_NOTEOL | PCRE_NEWLINE_ANY, 0, "a$", "aa\naa" },          { PCRE_NOTEOL | PCRE_NEWLINE_ANY, 0 | F_NOMATCH, "a$", "aa\naa" },
207          { PCRE_NOTEOL | PCRE_NEWLINE_ANY, 0, "a$", "aa\r\n" },          { PCRE_NOTEOL | PCRE_NEWLINE_ANY, 0 | F_NOMATCH, "a$", "aa\r\n" },
208          { PCRE_UTF8 | PCRE_DOLLAR_ENDONLY | PCRE_NEWLINE_ANY, 0, "\\p{Any}{2,}$", "aa\r\n" },          { PCRE_UTF8 | PCRE_DOLLAR_ENDONLY | PCRE_NEWLINE_ANY, 0 | F_PROPERTY, "\\p{Any}{2,}$", "aa\r\n" },
209          { PCRE_NOTEOL | PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "a$", "aa\naa" },          { PCRE_NOTEOL | PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "a$", "aa\naa" },
210          { PCRE_NEWLINE_CR, 0, ".\\Z", "aaa" },          { PCRE_NEWLINE_CR, 0, ".\\Z", "aaa" },
211          { PCRE_NEWLINE_CR | PCRE_UTF8, 0, "a\\Z", "aaa\r" },          { PCRE_NEWLINE_CR | PCRE_UTF8, 0, "a\\Z", "aaa\r" },
# Line 190  static struct regression_test_case regre Line 225  static struct regression_test_case regre
225          { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, ".\\Z", "aaa\xc2\x85" },          { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, ".\\Z", "aaa\xc2\x85" },
226          { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, ".\\Z", "aaa\xe2\x80\xa8" },          { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, ".\\Z", "aaa\xe2\x80\xa8" },
227          { MA, 0, "\\Aa", "aaa" },          { MA, 0, "\\Aa", "aaa" },
228          { MA, 1, "\\Aa", "aaa" },          { MA, 1 | F_NOMATCH, "\\Aa", "aaa" },
229          { MA, 1, "\\Ga", "aaa" },          { MA, 1, "\\Ga", "aaa" },
230          { MA, 1, "\\Ga", "aba" },          { MA, 1 | F_NOMATCH, "\\Ga", "aba" },
231          { MA, 0, "a\\z", "aaa" },          { MA, 0, "a\\z", "aaa" },
232          { MA, 0, "a\\z", "aab" },          { MA, 0 | F_NOMATCH, "a\\z", "aab" },
233    
234          /* Brackets. */          /* Brackets. */
235          { MUA, 0, "(ab|bb|cd)", "bacde" },          { MUA, 0, "(ab|bb|cd)", "bacde" },
# Line 267  static struct regression_test_case regre Line 302  static struct regression_test_case regre
302          { MUA, 0, "\\b\\w+\\B", "x,a_cd" },          { MUA, 0, "\\b\\w+\\B", "x,a_cd" },
303          { MUAP, 0, "\\b[^\xc2\xa1]+\\B", "\xc3\x89\xc2\xa1\xe6\x92\xad\xc3\x81\xc3\xa1" },          { MUAP, 0, "\\b[^\xc2\xa1]+\\B", "\xc3\x89\xc2\xa1\xe6\x92\xad\xc3\x81\xc3\xa1" },
304          { CMUA, 0, "[^b]+(a*)([^c]?d{3})", "aaaaddd" },          { CMUA, 0, "[^b]+(a*)([^c]?d{3})", "aaaaddd" },
305            { CMUAP, 0, "\xe1\xbd\xb8{2}", "\xe1\xbf\xb8#\xe1\xbf\xb8\xe1\xbd\xb8" },
306            { CMUA, 0, "[^\xf0\x90\x90\x80]{2,4}@", "\xf0\x90\x90\xa8\xf0\x90\x90\x80###\xf0\x90\x90\x80@@@" },
307            { CMUA, 0, "[^\xe1\xbd\xb8][^\xc3\xa9]", "\xe1\xbd\xb8\xe1\xbf\xb8\xc3\xa9\xc3\x89#" },
308            { MUA, 0, "[^\xe1\xbd\xb8][^\xc3\xa9]", "\xe1\xbd\xb8\xe1\xbf\xb8\xc3\xa9\xc3\x89#" },
309            { MUA, 0, "[^\xe1\xbd\xb8]{3,}?", "##\xe1\xbd\xb8#\xe1\xbd\xb8#\xc3\x89#\xe1\xbd\xb8" },
310    
311            /* Bracket repeats with limit. */
312            { MUA, 0, "(?:(ab){2}){5}M", "abababababababababababM" },
313            { MUA, 0, "(?:ab|abab){1,5}M", "abababababababababababM" },
314            { MUA, 0, "(?>ab|abab){1,5}M", "abababababababababababM" },
315            { MUA, 0, "(?:ab|abab){1,5}?M", "abababababababababababM" },
316            { MUA, 0, "(?>ab|abab){1,5}?M", "abababababababababababM" },
317            { MUA, 0, "(?:(ab){1,4}?){1,3}?M", "abababababababababababababM" },
318            { MUA, 0, "(?:(ab){1,4}){1,3}abababababababababababM", "ababababababababababababM" },
319            { MUA, 0 | F_NOMATCH, "(?:(ab){1,4}){1,3}abababababababababababM", "abababababababababababM" },
320            { MUA, 0, "(ab){4,6}?M", "abababababababM" },
321    
322          /* Basic character sets. */          /* Basic character sets. */
323          { MUA, 0, "(?:\\s)+(?:\\S)+", "ab \t\xc3\xa9\xe6\x92\xad " },          { MUA, 0, "(?:\\s)+(?:\\S)+", "ab \t\xc3\xa9\xe6\x92\xad " },
# Line 278  static struct regression_test_case regre Line 329  static struct regression_test_case regre
329    
330          /* Unicode properties. */          /* Unicode properties. */
331          { MUAP, 0, "[1-5\xc3\xa9\\w]", "\xc3\xa1_" },          { MUAP, 0, "[1-5\xc3\xa9\\w]", "\xc3\xa1_" },
332          { MUAP, 0, "[\xc3\x81\\p{Ll}]", "A_\xc3\x89\xc3\xa1" },          { MUAP, 0 | F_PROPERTY, "[\xc3\x81\\p{Ll}]", "A_\xc3\x89\xc3\xa1" },
333          { MUAP, 0, "[\\Wd-h_x-z]+", "a\xc2\xa1#_yhzdxi" },          { MUAP, 0, "[\\Wd-h_x-z]+", "a\xc2\xa1#_yhzdxi" },
334          { MUAP, 0, "[\\P{Any}]", "abc" },          { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\\P{Any}]", "abc" },
335          { MUAP, 0, "[^\\p{Any}]", "abc" },          { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\\p{Any}]", "abc" },
336          { MUAP, 0, "[\\P{Any}\xc3\xa1-\xc3\xa8]", "abc" },          { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\\P{Any}\xc3\xa1-\xc3\xa8]", "abc" },
337          { MUAP, 0, "[^\\p{Any}\xc3\xa1-\xc3\xa8]", "abc" },          { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\\p{Any}\xc3\xa1-\xc3\xa8]", "abc" },
338          { MUAP, 0, "[\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },          { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },
339          { MUAP, 0, "[^\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },          { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },
340          { MUAP, 0, "[\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },          { MUAP, 0 | F_PROPERTY, "[\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },
341          { MUAP, 0, "[^\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },          { MUAP, 0 | F_PROPERTY, "[^\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },
342          { MUAP, 0, "[b-\xc3\xa9\\s]", "a\xc\xe6\x92\xad" },          { MUAP, 0, "[b-\xc3\xa9\\s]", "a\xc\xe6\x92\xad" },
343          { CMUAP, 0, "[\xc2\x85-\xc2\x89\xc3\x89]", "\xc2\x84\xc3\xa9" },          { CMUAP, 0, "[\xc2\x85-\xc2\x89\xc3\x89]", "\xc2\x84\xc3\xa9" },
344          { MUAP, 0, "[^b-d^&\\s]{3,}", "db^ !a\xe2\x80\xa8_ae" },          { MUAP, 0, "[^b-d^&\\s]{3,}", "db^ !a\xe2\x80\xa8_ae" },
345          { MUAP, 0, "[^\\S\\P{Any}][\\sN]{1,3}[\\P{N}]{4}", "\xe2\x80\xaa\xa N\x9\xc3\xa9_0" },          { MUAP, 0 | F_PROPERTY, "[^\\S\\P{Any}][\\sN]{1,3}[\\P{N}]{4}", "\xe2\x80\xaa\xa N\x9\xc3\xa9_0" },
346          { MUA, 0, "[^\\P{L}\x9!D-F\xa]{2,3}", "\x9,.DF\xa.CG\xc3\x81" },          { MUA, 0 | F_PROPERTY, "[^\\P{L}\x9!D-F\xa]{2,3}", "\x9,.DF\xa.CG\xc3\x81" },
347          { 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" },          { 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" },
348          { MUAP, 0, "[\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" },          { 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" },
349          { MUAP, 0, "[\\P{L&}]{2}[^\xc2\x85-\xc2\x89\\p{Ll}\\p{Lu}]{2}", "\xc3\xa9\xe6\x92\xad.a\xe6\x92\xad|\xc2\x8a#" },          { 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#" },
350          { PCRE_UCP, 0, "[a-b\\s]{2,5}[^a]", "AB  baaa" },          { PCRE_UCP, 0, "[a-b\\s]{2,5}[^a]", "AB  baaa" },
351    
352          /* Possible empty brackets. */          /* Possible empty brackets. */
# Line 312  static struct regression_test_case regre Line 363  static struct regression_test_case regre
363    
364          /* Start offset. */          /* Start offset. */
365          { MUA, 3, "(\\d|(?:\\w)*\\w)+", "0ac01Hb" },          { MUA, 3, "(\\d|(?:\\w)*\\w)+", "0ac01Hb" },
366          { MUA, 4, "(\\w\\W\\w)+", "ab#d" },          { MUA, 4 | F_NOMATCH, "(\\w\\W\\w)+", "ab#d" },
367          { MUA, 2, "(\\w\\W\\w)+", "ab#d" },          { MUA, 2 | F_NOMATCH, "(\\w\\W\\w)+", "ab#d" },
368          { MUA, 1, "(\\w\\W\\w)+", "ab#d" },          { MUA, 1, "(\\w\\W\\w)+", "ab#d" },
369    
370          /* Newline. */          /* Newline. */
# Line 327  static struct regression_test_case regre Line 378  static struct regression_test_case regre
378          { PCRE_NEWLINE_ANYCRLF, 0, ".(.)", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa8" },          { PCRE_NEWLINE_ANYCRLF, 0, ".(.)", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa8" },
379          { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".(.)", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa8" },          { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".(.)", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa8" },
380          { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.).", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa9$de" },          { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.).", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa9$de" },
381          { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".(.).", "\xe2\x80\xa8\nb\r" },          { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0 | F_NOMATCH, ".(.).", "\xe2\x80\xa8\nb\r" },
382          { PCRE_NEWLINE_ANY, 0, "(.)(.)", "#\x85#\r#\n#\r\n#\x84" },          { PCRE_NEWLINE_ANY, 0, "(.)(.)", "#\x85#\r#\n#\r\n#\x84" },
383          { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.+)#", "#\rMn\xc2\x85#\n###" },          { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.+)#", "#\rMn\xc2\x85#\n###" },
384          { PCRE_BSR_ANYCRLF, 0, "\\R", "\r" },          { PCRE_BSR_ANYCRLF, 0, "\\R", "\r" },
# Line 335  static struct regression_test_case regre Line 386  static struct regression_test_case regre
386          { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\xe2\x80\xa8#c" },          { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\xe2\x80\xa8#c" },
387          { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\r\nc" },          { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\r\nc" },
388          { PCRE_NEWLINE_CRLF | PCRE_BSR_UNICODE | PCRE_UTF8, 0, "(\\R.)+", "\xc2\x85\r\n#\xe2\x80\xa8\n\r\n\r" },          { PCRE_NEWLINE_CRLF | PCRE_BSR_UNICODE | PCRE_UTF8, 0, "(\\R.)+", "\xc2\x85\r\n#\xe2\x80\xa8\n\r\n\r" },
389          { MUA, 0, "\\R+", "ab" },          { MUA, 0 | F_NOMATCH, "\\R+", "ab" },
390          { MUA, 0, "\\R+", "ab\r\n\r" },          { MUA, 0, "\\R+", "ab\r\n\r" },
391          { MUA, 0, "\\R*", "ab\r\n\r" },          { MUA, 0, "\\R*", "ab\r\n\r" },
392          { MUA, 0, "\\R*", "\r\n\r" },          { MUA, 0, "\\R*", "\r\n\r" },
# Line 343  static struct regression_test_case regre Line 394  static struct regression_test_case regre
394          { MUA, 0, "\\R{2,4}", "\r\nab\n\n\n\r\r\r" },          { MUA, 0, "\\R{2,4}", "\r\nab\n\n\n\r\r\r" },
395          { MUA, 0, "\\R{2,}", "\r\nab\n\n\n\r\r\r" },          { MUA, 0, "\\R{2,}", "\r\nab\n\n\n\r\r\r" },
396          { MUA, 0, "\\R{0,3}", "\r\n\r\n\r\n\r\n\r\n" },          { MUA, 0, "\\R{0,3}", "\r\n\r\n\r\n\r\n\r\n" },
397          { MUA, 0, "\\R+\\R\\R", "\r\n\r\n" },          { MUA, 0 | F_NOMATCH, "\\R+\\R\\R", "\r\n\r\n" },
398          { MUA, 0, "\\R+\\R\\R", "\r\r\r" },          { MUA, 0, "\\R+\\R\\R", "\r\r\r" },
399          { MUA, 0, "\\R*\\R\\R", "\n\r" },          { MUA, 0, "\\R*\\R\\R", "\n\r" },
400          { MUA, 0, "\\R{2,4}\\R\\R", "\r\r\r" },          { MUA, 0 | F_NOMATCH, "\\R{2,4}\\R\\R", "\r\r\r" },
401          { MUA, 0, "\\R{2,4}\\R\\R", "\r\r\r\r" },          { MUA, 0, "\\R{2,4}\\R\\R", "\r\r\r\r" },
402    
403          /* Atomic groups (no fallback from "next" direction). */          /* Atomic groups (no fallback from "next" direction). */
404          { MUA, 0, "(?>ab)ab", "bab" },          { MUA, 0 | F_NOMATCH, "(?>ab)ab", "bab" },
405          { MUA, 0, "(?>(ab))ab", "bab" },          { MUA, 0 | F_NOMATCH, "(?>(ab))ab", "bab" },
406          { MUA, 0, "(?>ab)+abc(?>de)*def(?>gh)?ghe(?>ij)+?k(?>lm)*?n(?>op)?\?op",          { MUA, 0, "(?>ab)+abc(?>de)*def(?>gh)?ghe(?>ij)+?k(?>lm)*?n(?>op)?\?op",
407                          "bababcdedefgheijijklmlmnop" },                          "bababcdedefgheijijklmlmnop" },
408          { MUA, 0, "(?>a(b)+a|(ab)?\?(b))an", "abban" },          { MUA, 0, "(?>a(b)+a|(ab)?\?(b))an", "abban" },
# Line 379  static struct regression_test_case regre Line 430  static struct regression_test_case regre
430          { CMA, 0, "(?>((?>a{32}|b+|(a*))?(?>c+|d*)?\?)+e)+?f", "aaccebbdde bbdaaaccebbdee bbdaaaccebbdeef" },          { CMA, 0, "(?>((?>a{32}|b+|(a*))?(?>c+|d*)?\?)+e)+?f", "aaccebbdde bbdaaaccebbdee bbdaaaccebbdeef" },
431          { MUA, 0, "(?>(?:(?>aa|a||x)+?b|(?>aa|a||(x))+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" },          { MUA, 0, "(?>(?:(?>aa|a||x)+?b|(?>aa|a||(x))+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" },
432          { MUA, 0, "(?>(?:(?>aa|a||(x))+?b|(?>aa|a||x)+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" },          { MUA, 0, "(?>(?:(?>aa|a||(x))+?b|(?>aa|a||x)+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" },
433          { MUA, 0, "\\X", "\xcc\x8d\xcc\x8d" },          { MUA, 0 | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d" },
434          { MUA, 0, "\\X", "\xcc\x8d\xcc\x8d#\xcc\x8d\xcc\x8d" },          { MUA, 0 | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d#\xcc\x8d\xcc\x8d" },
435          { MUA, 0, "\\X+..", "\xcc\x8d#\xcc\x8d#\xcc\x8d\xcc\x8d" },          { MUA, 0 | F_PROPERTY, "\\X+..", "\xcc\x8d#\xcc\x8d#\xcc\x8d\xcc\x8d" },
436          { MUA, 0, "\\X{2,4}", "abcdef" },          { MUA, 0 | F_PROPERTY, "\\X{2,4}", "abcdef" },
437          { MUA, 0, "\\X{2,4}?", "abcdef" },          { MUA, 0 | F_PROPERTY, "\\X{2,4}?", "abcdef" },
438          { MUA, 0, "\\X{2,4}..", "#\xcc\x8d##" },          { MUA, 0 | F_NOMATCH | F_PROPERTY, "\\X{2,4}..", "#\xcc\x8d##" },
439          { MUA, 0, "\\X{2,4}..", "#\xcc\x8d#\xcc\x8d##" },          { MUA, 0 | F_PROPERTY, "\\X{2,4}..", "#\xcc\x8d#\xcc\x8d##" },
440          { MUA, 0, "(c(ab)?+ab)+", "cabcababcab" },          { MUA, 0, "(c(ab)?+ab)+", "cabcababcab" },
441          { MUA, 0, "(?>(a+)b)+aabab", "aaaabaaabaabab" },          { MUA, 0, "(?>(a+)b)+aabab", "aaaabaaabaabab" },
442    
# Line 420  static struct regression_test_case regre Line 471  static struct regression_test_case regre
471          { MUA, 0, "((b*))++m", "bxbbxbbbxbbm" },          { MUA, 0, "((b*))++m", "bxbbxbbbxbbm" },
472          { MUA, 0, "((b*))*+m", "bxbbxbbbxm" },          { MUA, 0, "((b*))*+m", "bxbbxbbbxm" },
473          { MUA, 0, "((b*))*+m", "bxbbxbbbxbbm" },          { MUA, 0, "((b*))*+m", "bxbbxbbbxbbm" },
474          { MUA, 0, "(?>(b{2,4}))(?:(?:(aa|c))++m|(?:(aa|c))+n)", "bbaacaaccaaaacxbbbmbn" },          { MUA, 0 | F_NOMATCH, "(?>(b{2,4}))(?:(?:(aa|c))++m|(?:(aa|c))+n)", "bbaacaaccaaaacxbbbmbn" },
475          { MUA, 0, "((?:b)++a)+(cd)*+m", "bbababbacdcdnbbababbacdcdm" },          { MUA, 0, "((?:b)++a)+(cd)*+m", "bbababbacdcdnbbababbacdcdm" },
476          { MUA, 0, "((?:(b))++a)+((c)d)*+m", "bbababbacdcdnbbababbacdcdm" },          { MUA, 0, "((?:(b))++a)+((c)d)*+m", "bbababbacdcdnbbababbacdcdm" },
477          { MUA, 0, "(?:(?:(?:ab)*+k)++(?:n(?:cd)++)*+)*+m", "ababkkXababkkabkncXababkkabkncdcdncdXababkkabkncdcdncdkkabkncdXababkkabkncdcdncdkkabkncdm" },          { MUA, 0, "(?:(?:(?:ab)*+k)++(?:n(?:cd)++)*+)*+m", "ababkkXababkkabkncXababkkabkncdcdncdXababkkabkncdcdncdkkabkncdXababkkabkncdcdncdkkabkncdm" },
# Line 444  static struct regression_test_case regre Line 495  static struct regression_test_case regre
495          { MUA, 0, "(?:(aa|bb)(\\1{0,3}?)){2}(dd|)(\\3{0,3}?)b(\\1{0,3}?)(\\1{0,3})", "aaaaaaaaaaaaaaabaaaaa" },          { MUA, 0, "(?:(aa|bb)(\\1{0,3}?)){2}(dd|)(\\3{0,3}?)b(\\1{0,3}?)(\\1{0,3})", "aaaaaaaaaaaaaaabaaaaa" },
496          { MUA, 0, "(a(?:\\1|)a){3}b", "aaaaaaaaaaab" },          { MUA, 0, "(a(?:\\1|)a){3}b", "aaaaaaaaaaab" },
497          { 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" },          { 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" },
498          { MUAP, 0, "(\\P{N})\\1{2,}", ".www." },          { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{2,}", ".www." },
499          { MUAP, 0, "(\\P{N})\\1{0,2}", "wwwww." },          { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{0,2}", "wwwww." },
500          { MUAP, 0, "(\\P{N})\\1{1,2}ww", "wwww" },          { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{1,2}ww", "wwww" },
501          { MUAP, 0, "(\\P{N})\\1{1,2}ww", "wwwww" },          { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{1,2}ww", "wwwww" },
502          { PCRE_UCP, 0, "(\\P{N})\\1{2,}", ".www." },          { PCRE_UCP, 0 | F_PROPERTY, "(\\P{N})\\1{2,}", ".www." },
503            { CMUAP, 0, "(\xf0\x90\x90\x80)\\1", "\xf0\x90\x90\xa8\xf0\x90\x90\xa8" },
504    
505          /* Assertions. */          /* Assertions. */
506          { MUA, 0, "(?=xx|yy|zz)\\w{4}", "abczzdefg" },          { MUA, 0, "(?=xx|yy|zz)\\w{4}", "abczzdefg" },
# Line 464  static struct regression_test_case regre Line 516  static struct regression_test_case regre
516          { MUA, 0, "(?>a(?>(b+))a(?=(..)))*?k", "acabbcabbaabacabaabbakk" },          { MUA, 0, "(?>a(?>(b+))a(?=(..)))*?k", "acabbcabbaabacabaabbakk" },
517          { MUA, 0, "((?(?=(a))a)+k)", "bbak" },          { MUA, 0, "((?(?=(a))a)+k)", "bbak" },
518          { MUA, 0, "((?(?=a)a)+k)", "bbak" },          { MUA, 0, "((?(?=a)a)+k)", "bbak" },
519          { MUA, 0, "(?=(?>(a))m)amk", "a k" },          { MUA, 0 | F_NOMATCH, "(?=(?>(a))m)amk", "a k" },
520          { MUA, 0, "(?!(?>(a))m)amk", "a k" },          { MUA, 0 | F_NOMATCH, "(?!(?>(a))m)amk", "a k" },
521          { MUA, 0, "(?>(?=(a))am)amk", "a k" },          { MUA, 0 | F_NOMATCH, "(?>(?=(a))am)amk", "a k" },
522          { MUA, 0, "(?=(?>a|(?=(?>(b+))a|c)[a-c]+)*?m)[a-cm]+k", "aaam bbam baaambaam abbabba baaambaamk" },          { MUA, 0, "(?=(?>a|(?=(?>(b+))a|c)[a-c]+)*?m)[a-cm]+k", "aaam bbam baaambaam abbabba baaambaamk" },
523          { MUA, 0, "(?> ?\?\\b(?(?=\\w{1,4}(a))m)\\w{0,8}bc){2,}?", "bca ssbc mabd ssbc mabc" },          { MUA, 0, "(?> ?\?\\b(?(?=\\w{1,4}(a))m)\\w{0,8}bc){2,}?", "bca ssbc mabd ssbc mabc" },
524          { MUA, 0, "(?:(?=ab)?[^n][^n])+m", "ababcdabcdcdabnababcdabcdcdabm" },          { MUA, 0, "(?:(?=ab)?[^n][^n])+m", "ababcdabcdcdabnababcdabcdcdabm" },
# Line 477  static struct regression_test_case regre Line 529  static struct regression_test_case regre
529          { MUA, 0, "((?!a)?\?(?!([^a]))?\?)+$", "acbab" },          { MUA, 0, "((?!a)?\?(?!([^a]))?\?)+$", "acbab" },
530    
531          /* Not empty, ACCEPT, FAIL */          /* Not empty, ACCEPT, FAIL */
532          { MUA | PCRE_NOTEMPTY, 0, "a*", "bcx" },          { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a*", "bcx" },
533          { MUA | PCRE_NOTEMPTY, 0, "a*", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "a*", "bcaad" },
534          { MUA | PCRE_NOTEMPTY, 0, "a*?", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "a*?", "bcaad" },
535          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*", "bcaad" },          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*", "bcaad" },
536          { MUA, 0, "a(*ACCEPT)b", "ab" },          { MUA, 0, "a(*ACCEPT)b", "ab" },
537          { MUA | PCRE_NOTEMPTY, 0, "a*(*ACCEPT)b", "bcx" },          { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a*(*ACCEPT)b", "bcx" },
538          { MUA | PCRE_NOTEMPTY, 0, "a*(*ACCEPT)b", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "a*(*ACCEPT)b", "bcaad" },
539          { MUA | PCRE_NOTEMPTY, 0, "a*?(*ACCEPT)b", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "a*?(*ACCEPT)b", "bcaad" },
540          { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*(*ACCEPT)b)", "bcx" },          { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "(?:z|a*(*ACCEPT)b)", "bcx" },
541          { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*(*ACCEPT)b)", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*(*ACCEPT)b)", "bcaad" },
542          { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*?(*ACCEPT)b)", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*?(*ACCEPT)b)", "bcaad" },
543          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*(*ACCEPT)b", "bcx" },          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*(*ACCEPT)b", "bcx" },
544          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*(*ACCEPT)b", "" },          { MUA | PCRE_NOTEMPTY_ATSTART, 0 | F_NOMATCH, "a*(*ACCEPT)b", "" },
545          { MUA, 0, "((a(*ACCEPT)b))", "ab" },          { MUA, 0, "((a(*ACCEPT)b))", "ab" },
546          { MUA, 0, "(a(*FAIL)a|a)", "aaa" },          { MUA, 0, "(a(*FAIL)a|a)", "aaa" },
547          { MUA, 0, "(?=ab(*ACCEPT)b)a", "ab" },          { MUA, 0, "(?=ab(*ACCEPT)b)a", "ab" },
# Line 506  static struct regression_test_case regre Line 558  static struct regression_test_case regre
558          { MUA, 0, "(?(?!(b))a*|b*)+k", "ababbalbbadabak" },          { MUA, 0, "(?(?!(b))a*|b*)+k", "ababbalbbadabak" },
559          { MUA, 0, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },          { MUA, 0, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },
560          { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },          { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },
561          { MUA | PCRE_BUG, 0, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" },          { MUA, 0 | F_DIFF, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" },
562          { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" },          { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" },
563          { MUA, 0, "(?(?=a)a*|b*)+k", "ababbalbbadabak" },          { MUA, 0, "(?(?=a)a*|b*)+k", "ababbalbbadabak" },
564          { MUA, 0, "(?(?!b)a*|b*)+k", "ababbalbbadabak" },          { MUA, 0, "(?(?!b)a*|b*)+k", "ababbalbbadabak" },
# Line 520  static struct regression_test_case regre Line 572  static struct regression_test_case regre
572          { MUA, 0, "((?=\\w{5})\\w(?(?=\\w*k)\\d|[a-f_])*\\w\\s)+", "mol m10kk m088k _f_a_ mbkkl" },          { MUA, 0, "((?=\\w{5})\\w(?(?=\\w*k)\\d|[a-f_])*\\w\\s)+", "mol m10kk m088k _f_a_ mbkkl" },
573          { MUA, 0, "(c)?\?(?(1)a|b)", "cdcaa" },          { MUA, 0, "(c)?\?(?(1)a|b)", "cdcaa" },
574          { MUA, 0, "(c)?\?(?(1)a|b)", "cbb" },          { MUA, 0, "(c)?\?(?(1)a|b)", "cbb" },
575          { MUA | PCRE_BUG, 0, "(?(?=(a))(aaaa|a?))+aak", "aaaaab aaaaak" },          { MUA, 0 | F_DIFF, "(?(?=(a))(aaaa|a?))+aak", "aaaaab aaaaak" },
576          { MUA, 0, "(?(?=a)(aaaa|a?))+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?=a)(aaaa|a?))+aak", "aaaaab aaaaak" },
577          { MUA, 0, "(?(?!(b))(aaaa|a?))+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?!(b))(aaaa|a?))+aak", "aaaaab aaaaak" },
578          { MUA, 0, "(?(?!b)(aaaa|a?))+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?!b)(aaaa|a?))+aak", "aaaaab aaaaak" },
579          { MUA | PCRE_BUG, 0, "(?(?=(a))a*)+aak", "aaaaab aaaaak" },          { MUA, 0 | F_DIFF, "(?(?=(a))a*)+aak", "aaaaab aaaaak" },
580          { MUA, 0, "(?(?=a)a*)+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?=a)a*)+aak", "aaaaab aaaaak" },
581          { MUA, 0, "(?(?!(b))a*)+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?!(b))a*)+aak", "aaaaab aaaaak" },
582          { MUA, 0, "(?(?!b)a*)+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?!b)a*)+aak", "aaaaab aaaaak" },
583          { MUA, 0, "(?(?=(?=(?!(x))a)aa)aaa|(?(?=(?!y)bb)bbb))*k", "abaabbaaabbbaaabbb abaabbaaabbbaaabbbk" },          { MUA, 0, "(?(?=(?=(?!(x))a)aa)aaa|(?(?=(?!y)bb)bbb))*k", "abaabbaaabbbaaabbb abaabbaaabbbaaabbbk" },
584            { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)*l", "bc ddd abccabccl" },
585            { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+?dd", "bcabcacdb bdddd" },
586            { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+l", "ababccddabdbccd abcccl" },
587            { MUA, 0, "((?:a|aa)(?(1)aaa))x", "aax" },
588    
589          /* Set start of match. */          /* Set start of match. */
590          { MUA, 0, "(?:\\Ka)*aaaab", "aaaaaaaa aaaaaaabb" },          { MUA, 0, "(?:\\Ka)*aaaab", "aaaaaaaa aaaaaaabb" },
591          { MUA, 0, "(?>\\Ka\\Ka)*aaaab", "aaaaaaaa aaaaaaaaaabb" },          { MUA, 0, "(?>\\Ka\\Ka)*aaaab", "aaaaaaaa aaaaaaaaaabb" },
592          { MUA, 0, "a+\\K(?<=\\Gaa)a", "aaaaaa" },          { MUA, 0, "a+\\K(?<=\\Gaa)a", "aaaaaa" },
593          { MUA | PCRE_NOTEMPTY, 0, "a\\K(*ACCEPT)b", "aa" },          { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a\\K(*ACCEPT)b", "aa" },
594          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a\\K(*ACCEPT)b", "aa" },          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a\\K(*ACCEPT)b", "aa" },
595    
596          /* First line. */          /* First line. */
597          { MUA | PCRE_FIRSTLINE, 0, "\\p{Any}a", "bb\naaa" },          { MUA | PCRE_FIRSTLINE, 0 | F_PROPERTY, "\\p{Any}a", "bb\naaa" },
598          { MUA | PCRE_FIRSTLINE, 0, "\\p{Any}a", "bb\r\naaa" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH | F_PROPERTY, "\\p{Any}a", "bb\r\naaa" },
599          { MUA | PCRE_FIRSTLINE, 0, "(?<=a)", "a" },          { MUA | PCRE_FIRSTLINE, 0, "(?<=a)", "a" },
600          { MUA | PCRE_FIRSTLINE, 0, "[^a][^b]", "ab" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[^a][^b]", "ab" },
601          { MUA | PCRE_FIRSTLINE, 0, "a", "\na" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "a", "\na" },
602          { MUA | PCRE_FIRSTLINE, 0, "[abc]", "\na" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[abc]", "\na" },
603          { MUA | PCRE_FIRSTLINE, 0, "^a", "\na" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^a", "\na" },
604          { MUA | PCRE_FIRSTLINE, 0, "^(?<=\n)", "\na" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^(?<=\n)", "\na" },
605          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0, "#", "\xc2\x85#" },          { MUA | PCRE_FIRSTLINE, 0, "\xf0\x90\x90\x80", "\xf0\x90\x90\x80" },
606          { PCRE_MULTILINE | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0, "#", "\x85#" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\xc2\x85#" },
607          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0, "^#", "\xe2\x80\xa8#" },          { PCRE_MULTILINE | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\x85#" },
608          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "\\p{Any}", "\r\na" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^#", "\xe2\x80\xa8#" },
609            { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_PROPERTY, "\\p{Any}", "\r\na" },
610          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, ".", "\r" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, ".", "\r" },
611          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "a", "\ra" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "a", "\ra" },
612          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "ba", "bbb\r\nba" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_NOMATCH, "ba", "bbb\r\nba" },
613          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "\\p{Any}{4}|a", "\r\na" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_NOMATCH | F_PROPERTY, "\\p{Any}{4}|a", "\r\na" },
614          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 1, ".", "\r\n" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 1, ".", "\r\n" },
615            { PCRE_FIRSTLINE | PCRE_NEWLINE_LF | PCRE_DOTALL, 0 | F_NOMATCH, "ab.", "ab" },
616    
617          /* Recurse. */          /* Recurse. */
618          { MUA, 0, "(a)(?1)", "aa" },          { MUA, 0, "(a)(?1)", "aa" },
619          { MUA, 0, "((a))(?1)", "aa" },          { MUA, 0, "((a))(?1)", "aa" },
620          { MUA, 0, "(b|a)(?1)", "aa" },          { MUA, 0, "(b|a)(?1)", "aa" },
621          { MUA, 0, "(b|(a))(?1)", "aa" },          { MUA, 0, "(b|(a))(?1)", "aa" },
622          { MUA, 0, "((a)(b)(?:a*))(?1)", "aba" },          { MUA, 0 | F_NOMATCH, "((a)(b)(?:a*))(?1)", "aba" },
623          { MUA, 0, "((a)(b)(?:a*))(?1)", "abab" },          { MUA, 0, "((a)(b)(?:a*))(?1)", "abab" },
624          { MUA, 0, "((a+)c(?2))b(?1)", "aacaabaca" },          { MUA, 0, "((a+)c(?2))b(?1)", "aacaabaca" },
625          { MUA, 0, "((?2)b|(a)){2}(?1)", "aabab" },          { MUA, 0, "((?2)b|(a)){2}(?1)", "aabab" },
# Line 569  static struct regression_test_case regre Line 627  static struct regression_test_case regre
627          { MUA, 0, "(?1)(((a(*ACCEPT)))b)", "axaa" },          { MUA, 0, "(?1)(((a(*ACCEPT)))b)", "axaa" },
628          { MUA, 0, "(?1)(?(DEFINE) (((ac(*ACCEPT)))b) )", "akaac" },          { MUA, 0, "(?1)(?(DEFINE) (((ac(*ACCEPT)))b) )", "akaac" },
629          { MUA, 0, "(a+)b(?1)b\\1", "abaaabaaaaa" },          { MUA, 0, "(a+)b(?1)b\\1", "abaaabaaaaa" },
630          { MUA, 0, "(?(DEFINE)(aa|a))(?1)ab", "aab" },          { MUA, 0 | F_NOMATCH, "(?(DEFINE)(aa|a))(?1)ab", "aab" },
631          { MUA, 0, "(?(DEFINE)(a\\Kb))(?1)+ababc", "abababxabababc" },          { MUA, 0, "(?(DEFINE)(a\\Kb))(?1)+ababc", "abababxabababc" },
632          { MUA, 0, "(a\\Kb)(?1)+ababc", "abababxababababc" },          { MUA, 0, "(a\\Kb)(?1)+ababc", "abababxababababc" },
633          { MUA, 0, "(a\\Kb)(?1)+ababc", "abababxababababxc" },          { MUA, 0 | F_NOMATCH, "(a\\Kb)(?1)+ababc", "abababxababababxc" },
634          { MUA, 0, "b|<(?R)*>", "<<b>" },          { MUA, 0, "b|<(?R)*>", "<<b>" },
635          { MUA, 0, "(a\\K){0}(?:(?1)b|ac)", "ac" },          { MUA, 0, "(a\\K){0}(?:(?1)b|ac)", "ac" },
636          { MUA, 0, "(?(DEFINE)(a(?2)|b)(b(?1)|(a)))(?:(?1)|(?2))m", "ababababnababababaam" },          { MUA, 0, "(?(DEFINE)(a(?2)|b)(b(?1)|(a)))(?:(?1)|(?2))m", "ababababnababababaam" },
637            { MUA, 0, "(a)((?(R)a|b))(?2)", "aabbabaa" },
638            { MUA, 0, "(a)((?(R2)a|b))(?2)", "aabbabaa" },
639            { MUA, 0, "(a)((?(R1)a|b))(?2)", "ababba" },
640            { MUA, 0, "(?(R0)aa|bb(?R))", "abba aabb bbaa" },
641            { MUA, 0, "((?(R)(?:aaaa|a)|(?:(aaaa)|(a)))+)(?1)$", "aaaaaaaaaa aaaa" },
642            { MUA, 0, "(?P<Name>a(?(R&Name)a|b))(?1)", "aab abb abaa" },
643            { MUA, 0, "((?(R)a|(?1)){3})", "XaaaaaaaaaX" },
644            { MUA, 0, "((?:(?(R)a|(?1))){3})", "XaaaaaaaaaX" },
645            { MUA, 0, "((?(R)a|(?1)){1,3})aaaaaa", "aaaaaaaaXaaaaaaaaa" },
646            { MUA, 0, "((?(R)a|(?1)){1,3}?)M", "aaaM" },
647    
648            /* 16 bit specific tests. */
649            { CMA, 0 | F_FORCECONV, "\xc3\xa1", "\xc3\x81\xc3\xa1" },
650            { CMA, 0 | F_FORCECONV, "\xe1\xbd\xb8", "\xe1\xbf\xb8\xe1\xbd\xb8" },
651            { CMA, 0 | F_FORCECONV, "[\xc3\xa1]", "\xc3\x81\xc3\xa1" },
652            { CMA, 0 | F_FORCECONV, "[\xe1\xbd\xb8]", "\xe1\xbf\xb8\xe1\xbd\xb8" },
653            { CMA, 0 | F_FORCECONV, "[a-\xed\xb0\x80]", "A" },
654            { CMA, 0 | F_NO8 | F_FORCECONV, "[a-\\x{dc00}]", "B" },
655            { CMA, 0 | F_NO8 | F_NOMATCH | F_FORCECONV, "[b-\\x{dc00}]", "a" },
656            { 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" },
657            { 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#" },
658            { 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" },
659            { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xed\xb3\xbf]", "\xed\x9f\xbf\xed\xa0\x83" },
660            { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xed\xb3\xbf]", "\xed\xb4\x80\xed\xb3\xb0" },
661            { CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\x9f\xbf\xed\xa0\x83" },
662            { CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\xb4\x80\xed\xb3\xb0" },
663            { 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#" },
664            { 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" },
665            { MA, 0 | F_FORCECONV, "[^\xed\xb0\x80]{3,}?", "##\xed\xb0\x80#\xed\xb0\x80#\xc3\x89#\xed\xb0\x80" },
666            { MA, 0 | F_NO8 | F_FORCECONV, "[^\\x{dc00}]{3,}?", "##\xed\xb0\x80#\xed\xb0\x80#\xc3\x89#\xed\xb0\x80" },
667            { CMA, 0 | F_FORCECONV, ".\\B.", "\xed\xa0\x80\xed\xb0\x80" },
668            { 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" },
669            { CMA, 0 | F_FORCECONV, "\\d*\\s*\\w*\xed\xa0\x80\xed\xa0\x80", "\xed\xa0\x80\xed\xa0\x80" },
670            { CMA, 0 | F_FORCECONV | F_NOMATCH, "\\d*?\\D*?\\s*?\\S*?\\w*?\\W*?##", "\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80#" },
671            { CMA | PCRE_EXTENDED, 0 | F_FORCECONV, "\xed\xa0\x80 \xed\xb0\x80 !", "\xed\xa0\x80\xed\xb0\x80!" },
672            { CMA, 0 | F_FORCECONV, "\xed\xa0\x80+#[^#]+\xed\xa0\x80", "\xed\xa0\x80#a\xed\xa0\x80" },
673            { CMA, 0 | F_FORCECONV, "(\xed\xa0\x80+)#\\1", "\xed\xa0\x80\xed\xa0\x80#\xed\xa0\x80\xed\xa0\x80" },
674            { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0 | F_NO8 | F_FORCECONV, "^-", "a--\xe2\x80\xa8--" },
675            { PCRE_BSR_UNICODE, 0 | F_NO8 | F_FORCECONV, "\\R", "ab\xe2\x80\xa8" },
676            { 0, 0 | F_NO8 | F_FORCECONV, "\\v", "ab\xe2\x80\xa9" },
677            { 0, 0 | F_NO8 | F_FORCECONV, "\\h", "ab\xe1\xa0\x8e" },
678            { 0, 0 | F_NO8 | F_FORCECONV, "\\v+?\\V+?#", "\xe2\x80\xa9\xe2\x80\xa9\xef\xbf\xbf\xef\xbf\xbf#" },
679            { 0, 0 | F_NO8 | F_FORCECONV, "\\h+?\\H+?#", "\xe1\xa0\x8e\xe1\xa0\x8e\xef\xbf\xbf\xef\xbf\xbf#" },
680    
681            /* Partial matching. */
682            { MUA | PCRE_PARTIAL_SOFT, 0, "ab", "a" },
683            { MUA | PCRE_PARTIAL_SOFT, 0, "ab|a", "a" },
684            { MUA | PCRE_PARTIAL_HARD, 0, "ab|a", "a" },
685            { MUA | PCRE_PARTIAL_SOFT, 0, "\\b#", "a" },
686            { MUA | PCRE_PARTIAL_SOFT, 0, "(?<=a)b", "a" },
687            { MUA | PCRE_PARTIAL_SOFT, 0, "abc|(?<=xxa)bc", "xxab" },
688            { MUA | PCRE_PARTIAL_SOFT, 0, "a\\B", "a" },
689            { MUA | PCRE_PARTIAL_HARD, 0, "a\\b", "a" },
690    
691            /* (*MARK) verb. */
692            { MUA, 0, "a(*MARK:aa)a", "ababaa" },
693            { MUA, 0 | F_NOMATCH, "a(*:aa)a", "abab" },
694            { MUA, 0, "a(*:aa)(b(*:bb)b|bc)", "abc" },
695            { MUA, 0 | F_NOMATCH, "a(*:1)x|b(*:2)y", "abc" },
696            { MUA, 0, "(?>a(*:aa))b|ac", "ac" },
697            { MUA, 0, "(?(DEFINE)(a(*:aa)))(?1)", "a" },
698            { MUA, 0 | F_NOMATCH, "(?(DEFINE)((a)(*:aa)))(?1)b", "aa" },
699            { MUA, 0, "(?(DEFINE)(a(*:aa)))a(?1)b|aac", "aac" },
700            { MUA, 0, "(a(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
701            { MUA, 0, "(a(*:aa)){0}(?:b(?1)b)+", "babba" },
702            { MUA, 0 | F_NOMATCH | F_STUDY, "(a(*:aa)){0}(?:b(?1)b)+", "ba" },
703            { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
704            { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b)+", "babba" },
705            { MUA, 0 | F_NOMATCH | F_STUDY, "(a\\K(*:aa)){0}(?:b(?1)b)+", "ba" },
706            { MUA, 0 | F_NOMATCH | F_STUDY, "(*:mark)m", "a" },
707    
708            /* (*COMMIT) verb. */
709            { MUA, 0 | F_NOMATCH, "a(*COMMIT)b", "ac" },
710            { MUA, 0, "aa(*COMMIT)b", "xaxaab" },
711            { MUA, 0 | F_NOMATCH, "a(*COMMIT)(*:msg)b|ac", "ac" },
712            { MUA, 0 | F_NOMATCH, "(a(*COMMIT)b)++", "abac" },
713            { MUA, 0 | F_NOMATCH, "((a)(*COMMIT)b)++", "abac" },
714            { MUA, 0 | F_NOMATCH, "(?=a(*COMMIT)b)ab|ad", "ad" },
715    
716            /* (*PRUNE) verb. */
717            { MUA, 0, "aa\\K(*PRUNE)b", "aaab" },
718            { MUA, 0, "aa(*PRUNE:bb)b|a", "aa" },
719            { MUA, 0, "(a)(a)(*PRUNE)b|(a)", "aa" },
720            { MUA, 0, "(a)(a)(a)(a)(a)(a)(a)(a)(*PRUNE)b|(a)", "aaaaaaaa" },
721            { MUA | PCRE_PARTIAL_SOFT, 0, "a(*PRUNE)a|", "a" },
722            { MUA | PCRE_PARTIAL_SOFT, 0, "a(*PRUNE)a|m", "a" },
723            { MUA, 0 | F_NOMATCH, "(?=a(*PRUNE)b)ab|ad", "ad" },
724            { MUA, 0, "a(*COMMIT)(*PRUNE)d|bc", "abc" },
725            { MUA, 0, "(?=a(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
726            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?=a(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
727            { MUA, 0, "(?=(a)(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
728            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?=(a)(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
729            { MUA, 0, "(a(*COMMIT)b){0}a(?1)(*PRUNE)c|bc", "abc" },
730            { MUA, 0 | F_NOMATCH, "(a(*COMMIT)b){0}a(*COMMIT)(?1)(*PRUNE)c|bc", "abc" },
731            { MUA, 0, "(a(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
732            { MUA, 0 | F_NOMATCH, "(*COMMIT)(a(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
733            { MUA, 0, "((a)(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
734            { MUA, 0 | F_NOMATCH, "(*COMMIT)((a)(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
735            { MUA, 0, "(?>a(*COMMIT)b)*abab(*PRUNE)d|ba", "ababab" },
736            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)*abab(*PRUNE)d|ba", "ababab" },
737            { MUA, 0, "(?>a(*COMMIT)b)+abab(*PRUNE)d|ba", "ababab" },
738            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)+abab(*PRUNE)d|ba", "ababab" },
739            { MUA, 0, "(?>a(*COMMIT)b)?ab(*PRUNE)d|ba", "aba" },
740            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)?ab(*PRUNE)d|ba", "aba" },
741            { MUA, 0, "(?>a(*COMMIT)b)*?n(*PRUNE)d|ba", "abababn" },
742            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)*?n(*PRUNE)d|ba", "abababn" },
743            { MUA, 0, "(?>a(*COMMIT)b)+?n(*PRUNE)d|ba", "abababn" },
744            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)+?n(*PRUNE)d|ba", "abababn" },
745            { MUA, 0, "(?>a(*COMMIT)b)??n(*PRUNE)d|bn", "abn" },
746            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)??n(*PRUNE)d|bn", "abn" },
747    
748            /* (*SKIP) verb. */
749            { MUA, 0 | F_NOMATCH, "(?=a(*SKIP)b)ab|ad", "ad" },
750    
751            /* (*THEN) verb. */
752            { MUA, 0, "((?:a(*THEN)|aab)(*THEN)c|a+)+m", "aabcaabcaabcaabcnacm" },
753            { MUA, 0 | F_NOMATCH, "((?:a(*THEN)|aab)(*THEN)c|a+)+m", "aabcm" },
754            { MUA, 0, "((?:a(*THEN)|aab)c|a+)+m", "aabcaabcnmaabcaabcm" },
755            { MUA, 0, "((?:a|aab)(*THEN)c|a+)+m", "aam" },
756            { MUA, 0, "((?:a(*COMMIT)|aab)(*THEN)c|a+)+m", "aam" },
757            { MUA, 0, "(?(?=a(*THEN)b)ab|ad)", "ad" },
758            { MUA, 0, "(?(?!a(*THEN)b)ad|add)", "add" },
759            { MUA, 0 | F_NOMATCH, "(?(?=a)a(*THEN)b|ad)", "ad" },
760            { MUA, 0, "(?!(?(?=a)ab|b(*THEN)d))bn|bnn", "bnn" },
761    
762          /* Deep recursion. */          /* Deep recursion. */
763          { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },          { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },
764          { MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " },          { MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " },
765          { MUA, 0, "((a?)+)+b", "aaaaaaaaaaaaa b" },          { MUA, 0, "((a?)+)+b", "aaaaaaaaaaaa b" },
766    
767          /* Deep recursion: Stack limit reached. */          /* Deep recursion: Stack limit reached. */
768          { MA, 0, "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" },          { 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" },
769          { MA, 0, "(?:a+)+b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },          { MA, 0 | F_NOMATCH, "(?:a+)+b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
770          { MA, 0, "(?:a+?)+?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },          { MA, 0 | F_NOMATCH, "(?:a+?)+?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
771          { MA, 0, "(?:a*)*b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },          { MA, 0 | F_NOMATCH, "(?:a*)*b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
772          { MA, 0, "(?:a*?)*?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },          { MA, 0 | F_NOMATCH, "(?:a*?)*?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
773    
774          { 0, 0, NULL, NULL }          { 0, 0, NULL, NULL }
775  };  };
776    
777    static const unsigned char *tables(int mode)
778    {
779            /* The purpose of this function to allow valgrind
780            for reporting invalid reads and writes. */
781            static unsigned char *tables_copy;
782            const char *errorptr;
783            int erroroffset;
784            unsigned char *default_tables;
785    #if defined SUPPORT_PCRE8
786            pcre *regex;
787            char null_str[1] = { 0 };
788    #elif defined SUPPORT_PCRE16
789            pcre16 *regex;
790            PCRE_UCHAR16 null_str[1] = { 0 };
791    #elif defined SUPPORT_PCRE32
792            pcre32 *regex;
793            PCRE_UCHAR32 null_str[1] = { 0 };
794    #endif
795    
796            if (mode) {
797                    if (tables_copy)
798                            free(tables_copy);
799                    tables_copy = NULL;
800                    return NULL;
801            }
802    
803            if (tables_copy)
804                    return tables_copy;
805    
806            default_tables = NULL;
807    #if defined SUPPORT_PCRE8
808            regex = pcre_compile(null_str, 0, &errorptr, &erroroffset, NULL);
809            if (regex) {
810                    pcre_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
811                    pcre_free(regex);
812            }
813    #elif defined SUPPORT_PCRE16
814            regex = pcre16_compile(null_str, 0, &errorptr, &erroroffset, NULL);
815            if (regex) {
816                    pcre16_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
817                    pcre16_free(regex);
818            }
819    #elif defined SUPPORT_PCRE32
820            regex = pcre32_compile(null_str, 0, &errorptr, &erroroffset, NULL);
821            if (regex) {
822                    pcre32_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
823                    pcre32_free(regex);
824            }
825    #endif
826            /* Shouldn't ever happen. */
827            if (!default_tables)
828                    return NULL;
829    
830            /* Unfortunately this value cannot get from pcre_fullinfo.
831            Since this is a test program, this is acceptable at the moment. */
832            tables_copy = (unsigned char *)malloc(1088);
833            if (!tables_copy)
834                    return NULL;
835    
836            memcpy(tables_copy, default_tables, 1088);
837            return tables_copy;
838    }
839    
840    #ifdef SUPPORT_PCRE8
841    static pcre_jit_stack* callback8(void *arg)
842    {
843            return (pcre_jit_stack *)arg;
844    }
845    #endif
846    
847    #ifdef SUPPORT_PCRE16
848    static pcre16_jit_stack* callback16(void *arg)
849    {
850            return (pcre16_jit_stack *)arg;
851    }
852    #endif
853    
854    #ifdef SUPPORT_PCRE32
855    static pcre32_jit_stack* callback32(void *arg)
856    {
857            return (pcre32_jit_stack *)arg;
858    }
859    #endif
860    
861    #ifdef SUPPORT_PCRE8
862    static pcre_jit_stack *stack8;
863    
864    static pcre_jit_stack *getstack8(void)
865    {
866            if (!stack8)
867                    stack8 = pcre_jit_stack_alloc(1, 1024 * 1024);
868            return stack8;
869    }
870    
871    static void setstack8(pcre_extra *extra)
872    {
873            if (!extra) {
874                    if (stack8)
875                            pcre_jit_stack_free(stack8);
876                    stack8 = NULL;
877                    return;
878            }
879    
880            pcre_assign_jit_stack(extra, callback8, getstack8());
881    }
882    #endif /* SUPPORT_PCRE8 */
883    
884    #ifdef SUPPORT_PCRE16
885    static pcre16_jit_stack *stack16;
886    
887    static pcre16_jit_stack *getstack16(void)
888    {
889            if (!stack16)
890                    stack16 = pcre16_jit_stack_alloc(1, 1024 * 1024);
891            return stack16;
892    }
893    
894    static void setstack16(pcre16_extra *extra)
895    {
896            if (!extra) {
897                    if (stack16)
898                            pcre16_jit_stack_free(stack16);
899                    stack16 = NULL;
900                    return;
901            }
902    
903            pcre16_assign_jit_stack(extra, callback16, getstack16());
904    }
905    #endif /* SUPPORT_PCRE8 */
906    
907    #ifdef SUPPORT_PCRE32
908    static pcre32_jit_stack *stack32;
909    
910    static pcre32_jit_stack *getstack32(void)
911    {
912            if (!stack32)
913                    stack32 = pcre32_jit_stack_alloc(1, 1024 * 1024);
914            return stack32;
915    }
916    
917    static void setstack32(pcre32_extra *extra)
918    {
919            if (!extra) {
920                    if (stack32)
921                            pcre32_jit_stack_free(stack32);
922                    stack32 = NULL;
923                    return;
924            }
925    
926            pcre32_assign_jit_stack(extra, callback32, getstack32());
927    }
928    #endif /* SUPPORT_PCRE8 */
929    
930    #ifdef SUPPORT_PCRE16
931    
932    static int convert_utf8_to_utf16(const char *input, PCRE_UCHAR16 *output, int *offsetmap, int max_length)
933    {
934            unsigned char *iptr = (unsigned char*)input;
935            PCRE_UCHAR16 *optr = output;
936            unsigned int c;
937    
938            if (max_length == 0)
939                    return 0;
940    
941            while (*iptr && max_length > 1) {
942                    c = 0;
943                    if (offsetmap)
944                            *offsetmap++ = (int)(iptr - (unsigned char*)input);
945    
946                    if (!(*iptr & 0x80))
947                            c = *iptr++;
948                    else if (!(*iptr & 0x20)) {
949                            c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
950                            iptr += 2;
951                    } else if (!(*iptr & 0x10)) {
952                            c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
953                            iptr += 3;
954                    } else if (!(*iptr & 0x08)) {
955                            c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
956                            iptr += 4;
957                    }
958    
959                    if (c < 65536) {
960                            *optr++ = c;
961                            max_length--;
962                    } else if (max_length <= 2) {
963                            *optr = '\0';
964                            return (int)(optr - output);
965                    } else {
966                            c -= 0x10000;
967                            *optr++ = 0xd800 | ((c >> 10) & 0x3ff);
968                            *optr++ = 0xdc00 | (c & 0x3ff);
969                            max_length -= 2;
970                            if (offsetmap)
971                                    offsetmap++;
972                    }
973            }
974            if (offsetmap)
975                    *offsetmap = (int)(iptr - (unsigned char*)input);
976            *optr = '\0';
977            return (int)(optr - output);
978    }
979    
980    static int copy_char8_to_char16(const char *input, PCRE_UCHAR16 *output, int max_length)
981    {
982            unsigned char *iptr = (unsigned char*)input;
983            PCRE_UCHAR16 *optr = output;
984    
985            if (max_length == 0)
986                    return 0;
987    
988            while (*iptr && max_length > 1) {
989                    *optr++ = *iptr++;
990                    max_length--;
991            }
992            *optr = '\0';
993            return (int)(optr - output);
994    }
995    
996    #define REGTEST_MAX_LENGTH16 4096
997    static PCRE_UCHAR16 regtest_buf16[REGTEST_MAX_LENGTH16];
998    static int regtest_offsetmap16[REGTEST_MAX_LENGTH16];
999    
1000    #endif /* SUPPORT_PCRE16 */
1001    
1002    #ifdef SUPPORT_PCRE32
1003    
1004    static int convert_utf8_to_utf32(const char *input, PCRE_UCHAR32 *output, int *offsetmap, int max_length)
1005    {
1006            unsigned char *iptr = (unsigned char*)input;
1007            PCRE_UCHAR32 *optr = output;
1008            unsigned int c;
1009    
1010            if (max_length == 0)
1011                    return 0;
1012    
1013            while (*iptr && max_length > 1) {
1014                    c = 0;
1015                    if (offsetmap)
1016                            *offsetmap++ = (int)(iptr - (unsigned char*)input);
1017    
1018                    if (!(*iptr & 0x80))
1019                            c = *iptr++;
1020                    else if (!(*iptr & 0x20)) {
1021                            c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
1022                            iptr += 2;
1023                    } else if (!(*iptr & 0x10)) {
1024                            c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
1025                            iptr += 3;
1026                    } else if (!(*iptr & 0x08)) {
1027                            c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
1028                            iptr += 4;
1029                    }
1030    
1031                    *optr++ = c;
1032                    max_length--;
1033            }
1034            if (offsetmap)
1035                    *offsetmap = (int)(iptr - (unsigned char*)input);
1036            *optr = 0;
1037            return (int)(optr - output);
1038    }
1039    
1040    static int copy_char8_to_char32(const char *input, PCRE_UCHAR32 *output, int max_length)
1041    {
1042            unsigned char *iptr = (unsigned char*)input;
1043            PCRE_UCHAR32 *optr = output;
1044    
1045            if (max_length == 0)
1046                    return 0;
1047    
1048            while (*iptr && max_length > 1) {
1049                    *optr++ = *iptr++;
1050                    max_length--;
1051            }
1052            *optr = '\0';
1053            return (int)(optr - output);
1054    }
1055    
1056    #define REGTEST_MAX_LENGTH32 4096
1057    static PCRE_UCHAR32 regtest_buf32[REGTEST_MAX_LENGTH32];
1058    static int regtest_offsetmap32[REGTEST_MAX_LENGTH32];
1059    
1060    #endif /* SUPPORT_PCRE32 */
1061    
1062    static int check_ascii(const char *input)
1063    {
1064            const unsigned char *ptr = (unsigned char *)input;
1065            while (*ptr) {
1066                    if (*ptr > 127)
1067                            return 0;
1068                    ptr++;
1069            }
1070            return 1;
1071    }
1072    
1073  static int regression_tests(void)  static int regression_tests(void)
1074  {  {
         pcre *re;  
1075          struct regression_test_case *current = regression_test_cases;          struct regression_test_case *current = regression_test_cases;
1076          const char *error;          const char *error;
1077          pcre_extra *extra;          char *cpu_info;
         int utf8 = 0, ucp = 0;  
         int ovector1[32];  
         int ovector2[32];  
         int return_value1, return_value2;  
1078          int i, err_offs;          int i, err_offs;
1079          int total = 0, succesful = 0;          int is_successful, is_ascii_pattern, is_ascii_input;
1080            int total = 0;
1081            int successful = 0;
1082            int successful_row = 0;
1083          int counter = 0;          int counter = 0;
1084          int disabled_flags = PCRE_BUG;          int study_mode;
1085            int utf = 0, ucp = 0;
1086            int disabled_flags = 0;
1087    #ifdef SUPPORT_PCRE8
1088            pcre *re8;
1089            pcre_extra *extra8;
1090            pcre_extra dummy_extra8;
1091            int ovector8_1[32];
1092            int ovector8_2[32];
1093            int return_value8[2];
1094            unsigned char *mark8_1, *mark8_2;
1095    #endif
1096    #ifdef SUPPORT_PCRE16
1097            pcre16 *re16;
1098            pcre16_extra *extra16;
1099            pcre16_extra dummy_extra16;
1100            int ovector16_1[32];
1101            int ovector16_2[32];
1102            int return_value16[2];
1103            PCRE_UCHAR16 *mark16_1, *mark16_2;
1104            int length16;
1105    #endif
1106    #ifdef SUPPORT_PCRE32
1107            pcre32 *re32;
1108            pcre32_extra *extra32;
1109            pcre32_extra dummy_extra32;
1110            int ovector32_1[32];
1111            int ovector32_2[32];
1112            int return_value32[2];
1113            PCRE_UCHAR32 *mark32_1, *mark32_2;
1114            int length32;
1115    #endif
1116    
1117          /* This test compares the behaviour of interpreter and JIT. Although disabling          /* This test compares the behaviour of interpreter and JIT. Although disabling
1118          utf8 or ucp may make tests fail, if the pcre_exec result is the SAME, it is          utf or ucp may make tests fail, if the pcre_exec result is the SAME, it is
1119          still considered successful from pcre_jit_test point of view. */          still considered successful from pcre_jit_test point of view. */
1120    
1121          pcre_config(PCRE_CONFIG_UTF8, &utf8);  #if defined SUPPORT_PCRE8
1122            pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1123    #elif defined SUPPORT_PCRE16
1124            pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1125    #elif defined SUPPORT_PCRE32
1126            pcre32_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1127    #endif
1128    
1129            printf("Running JIT regression tests\n");
1130            printf("  target CPU of SLJIT compiler: %s\n", cpu_info);
1131    
1132    #if defined SUPPORT_PCRE8
1133            pcre_config(PCRE_CONFIG_UTF8, &utf);
1134          pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);          pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1135          if (!utf8)  #elif defined SUPPORT_PCRE16
1136                  disabled_flags |= PCRE_UTF8;          pcre16_config(PCRE_CONFIG_UTF16, &utf);
1137            pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1138    #elif defined SUPPORT_PCRE16
1139            pcre32_config(PCRE_CONFIG_UTF32, &utf);
1140            pcre32_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1141    #endif
1142    
1143            if (!utf)
1144                    disabled_flags |= PCRE_UTF8 | PCRE_UTF16 | PCRE_UTF32;
1145          if (!ucp)          if (!ucp)
1146                  disabled_flags |= PCRE_UCP;                  disabled_flags |= PCRE_UCP;
1147    #ifdef SUPPORT_PCRE8
1148            printf("  in  8 bit mode with UTF-8  %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
1149    #endif
1150    #ifdef SUPPORT_PCRE16
1151            printf("  in 16 bit mode with UTF-16 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
1152    #endif
1153    #ifdef SUPPORT_PCRE32
1154            printf("  in 32 bit mode with UTF-32 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
1155    #endif
1156    
         printf("Running JIT regression tests with utf8 %s and ucp %s:\n", utf8 ? "enabled" : "disabled", ucp ? "enabled" : "disabled");  
1157          while (current->pattern) {          while (current->pattern) {
1158                  /* printf("\nPattern: %s :\n", current->pattern); */                  /* printf("\nPattern: %s :\n", current->pattern); */
1159                  total++;                  total++;
1160                    if (current->start_offset & F_PROPERTY) {
1161                            is_ascii_pattern = 0;
1162                            is_ascii_input = 0;
1163                    } else {
1164                            is_ascii_pattern = check_ascii(current->pattern);
1165                            is_ascii_input = check_ascii(current->input);
1166                    }
1167    
1168                    if (current->flags & PCRE_PARTIAL_SOFT)
1169                            study_mode = PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE;
1170                    else if (current->flags & PCRE_PARTIAL_HARD)
1171                            study_mode = PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE;
1172                    else
1173                            study_mode = PCRE_STUDY_JIT_COMPILE;
1174                  error = NULL;                  error = NULL;
1175                  re = pcre_compile(current->pattern, current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | disabled_flags), &error, &err_offs, NULL);  #ifdef SUPPORT_PCRE8
1176                    re8 = NULL;
1177                  if (!re) {                  if (!(current->start_offset & F_NO8))
1178                          if (utf8 && ucp)                          re8 = pcre_compile(current->pattern,
1179                                  printf("\nCannot compile pattern: %s\n", current->pattern);                                  current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1180                          else {                                  &error, &err_offs, tables(0));
1181                                  /* Some patterns cannot be compiled when either of utf8  
1182                                  or ucp is disabled. We just skip them. */                  extra8 = NULL;
1183                                  printf(".");                  if (re8) {
1184                                  succesful++;                          error = NULL;
1185                            extra8 = pcre_study(re8, study_mode, &error);
1186                            if (!extra8) {
1187                                    printf("\n8 bit: Cannot study pattern: %s\n", current->pattern);
1188                                    pcre_free(re8);
1189                                    re8 = NULL;
1190                          }                          }
1191                          current++;                          else if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1192                          continue;                                  printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);
1193                  }                                  pcre_free_study(extra8);
1194                                    pcre_free(re8);
1195                                    re8 = NULL;
1196                            }
1197                            extra8->flags |= PCRE_EXTRA_MARK;
1198                    } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO8))
1199                            printf("\n8 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1200    #endif
1201    #ifdef SUPPORT_PCRE16
1202                    if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1203                            convert_utf8_to_utf16(current->pattern, regtest_buf16, NULL, REGTEST_MAX_LENGTH16);
1204                    else
1205                            copy_char8_to_char16(current->pattern, regtest_buf16, REGTEST_MAX_LENGTH16);
1206    
1207                    re16 = NULL;
1208                    if (!(current->start_offset & F_NO16))
1209                            re16 = pcre16_compile(regtest_buf16,
1210                                    current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1211                                    &error, &err_offs, tables(0));
1212    
1213                    extra16 = NULL;
1214                    if (re16) {
1215                            error = NULL;
1216                            extra16 = pcre16_study(re16, study_mode, &error);
1217                            if (!extra16) {
1218                                    printf("\n16 bit: Cannot study pattern: %s\n", current->pattern);
1219                                    pcre16_free(re16);
1220                                    re16 = NULL;
1221                            }
1222                            else if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1223                                    printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);
1224                                    pcre16_free_study(extra16);
1225                                    pcre16_free(re16);
1226                                    re16 = NULL;
1227                            }
1228                            extra16->flags |= PCRE_EXTRA_MARK;
1229                    } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO16))
1230                            printf("\n16 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1231    #endif
1232    #ifdef SUPPORT_PCRE32
1233                    if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1234                            convert_utf8_to_utf32(current->pattern, regtest_buf32, NULL, REGTEST_MAX_LENGTH32);
1235                    else
1236                            copy_char8_to_char32(current->pattern, regtest_buf32, REGTEST_MAX_LENGTH32);
1237    
1238                    re32 = NULL;
1239                    if (!(current->start_offset & F_NO32))
1240                            re32 = pcre32_compile(regtest_buf32,
1241                                    current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1242                                    &error, &err_offs, tables(0));
1243    
1244                    extra32 = NULL;
1245                    if (re32) {
1246                            error = NULL;
1247                            extra32 = pcre32_study(re32, study_mode, &error);
1248                            if (!extra32) {
1249                                    printf("\n32 bit: Cannot study pattern: %s\n", current->pattern);
1250                                    pcre32_free(re32);
1251                                    re32 = NULL;
1252                            }
1253                            if (!(extra32->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1254                                    printf("\n32 bit: JIT compiler does not support: %s\n", current->pattern);
1255                                    pcre32_free_study(extra32);
1256                                    pcre32_free(re32);
1257                                    re32 = NULL;
1258                            }
1259                            extra32->flags |= PCRE_EXTRA_MARK;
1260                    } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO32))
1261                            printf("\n32 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1262    #endif
1263    
1264                  error = NULL;                  counter++;
1265                  extra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &error);                  if ((counter & 0x3) != 0) {
1266                  if (!extra) {  #ifdef SUPPORT_PCRE8
1267                          printf("\nCannot study pattern: %s\n", current->pattern);                          setstack8(NULL);
1268                          current++;  #endif
1269                          continue;  #ifdef SUPPORT_PCRE16
1270                            setstack16(NULL);
1271    #endif
1272    #ifdef SUPPORT_PCRE32
1273                            setstack32(NULL);
1274    #endif
1275                  }                  }
1276    
1277                  if (!(extra->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {  #ifdef SUPPORT_PCRE8
1278                          printf("\nJIT compiler does not support: %s\n", current->pattern);                  return_value8[0] = -1000;
1279                          current++;                  return_value8[1] = -1000;
1280                          continue;                  for (i = 0; i < 32; ++i)
1281                            ovector8_1[i] = -2;
1282                    for (i = 0; i < 32; ++i)
1283                            ovector8_2[i] = -2;
1284                    if (re8) {
1285                            mark8_1 = NULL;
1286                            mark8_2 = NULL;
1287                            extra8->mark = &mark8_1;
1288    
1289                            if ((counter & 0x1) != 0) {
1290                                    setstack8(extra8);
1291                                    return_value8[0] = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1292                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32);
1293                            } else
1294                                    return_value8[0] = pcre_jit_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1295                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32, getstack8());
1296                            memset(&dummy_extra8, 0, sizeof(pcre_extra));
1297                            dummy_extra8.flags = PCRE_EXTRA_MARK;
1298                            if (current->start_offset & F_STUDY) {
1299                                    dummy_extra8.flags |= PCRE_EXTRA_STUDY_DATA;
1300                                    dummy_extra8.study_data = extra8->study_data;
1301                            }
1302                            dummy_extra8.mark = &mark8_2;
1303                            return_value8[1] = pcre_exec(re8, &dummy_extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1304                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_2, 32);
1305                  }                  }
1306    #endif
1307    
1308                  counter++;  #ifdef SUPPORT_PCRE16
1309                  if ((counter & 0x3) != 0)                  return_value16[0] = -1000;
1310                          setstack(extra);                  return_value16[1] = -1000;
1311                    for (i = 0; i < 32; ++i)
1312                            ovector16_1[i] = -2;
1313                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1314                          ovector1[i] = -2;                          ovector16_2[i] = -2;
1315                  return_value1 = pcre_exec(re, extra, current->input, strlen(current->input), current->start_offset, current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector1, 32);                  if (re16) {
1316                            mark16_1 = NULL;
1317                            mark16_2 = NULL;
1318                            if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1319                                    length16 = convert_utf8_to_utf16(current->input, regtest_buf16, regtest_offsetmap16, REGTEST_MAX_LENGTH16);
1320                            else
1321                                    length16 = copy_char8_to_char16(current->input, regtest_buf16, REGTEST_MAX_LENGTH16);
1322                            extra16->mark = &mark16_1;
1323                            if ((counter & 0x1) != 0) {
1324                                    setstack16(extra16);
1325                                    return_value16[0] = pcre16_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1326                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32);
1327                            } else
1328                                    return_value16[0] = pcre16_jit_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1329                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32, getstack16());
1330                            memset(&dummy_extra16, 0, sizeof(pcre16_extra));
1331                            dummy_extra16.flags = PCRE_EXTRA_MARK;
1332                            if (current->start_offset & F_STUDY) {
1333                                    dummy_extra16.flags |= PCRE_EXTRA_STUDY_DATA;
1334                                    dummy_extra16.study_data = extra16->study_data;
1335                            }
1336                            dummy_extra16.mark = &mark16_2;
1337                            return_value16[1] = pcre16_exec(re16, &dummy_extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1338                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_2, 32);
1339                    }
1340    #endif
1341    
1342    #ifdef SUPPORT_PCRE32
1343                    return_value32[0] = -1000;
1344                    return_value32[1] = -1000;
1345                    for (i = 0; i < 32; ++i)
1346                            ovector32_1[i] = -2;
1347                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1348                          ovector2[i] = -2;                          ovector32_2[i] = -2;
1349                  return_value2 = pcre_exec(re, NULL, current->input, strlen(current->input), current->start_offset, current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector2, 32);                  if (re32) {
1350                            mark32_1 = NULL;
1351                            mark32_2 = NULL;
1352                            if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1353                                    length32 = convert_utf8_to_utf32(current->input, regtest_buf32, regtest_offsetmap32, REGTEST_MAX_LENGTH32);
1354                            else
1355                                    length32 = copy_char8_to_char32(current->input, regtest_buf32, REGTEST_MAX_LENGTH32);
1356                            extra32->mark = &mark32_1;
1357                            if ((counter & 0x1) != 0) {
1358                                    setstack32(extra32);
1359                                    return_value32[0] = pcre32_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1360                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32);
1361                            } else
1362                                    return_value32[0] = pcre32_jit_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1363                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32, getstack32());
1364                            memset(&dummy_extra32, 0, sizeof(pcre32_extra));
1365                            dummy_extra32.flags = PCRE_EXTRA_MARK;
1366                            if (current->start_offset & F_STUDY) {
1367                                    dummy_extra32.flags |= PCRE_EXTRA_STUDY_DATA;
1368                                    dummy_extra32.study_data = extra32->study_data;
1369                            }
1370                            dummy_extra32.mark = &mark32_2;
1371                            return_value32[1] = pcre32_exec(re32, &dummy_extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1372                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_2, 32);
1373                    }
1374    #endif
1375    
1376                    /* printf("[%d-%d-%d|%d-%d|%d-%d|%d-%d]%s",
1377                            return_value8[0], return_value16[0],
1378                            ovector8_1[0], ovector8_1[1],
1379                            ovector16_1[0], ovector16_1[1],
1380                            ovector32_1[0], ovector32_1[1],
1381                            (current->flags & PCRE_CASELESS) ? "C" : ""); */
1382    
1383                  /* If PCRE_BUG is set, just run the test, but do not compare the results.                  /* If F_DIFF is set, just run the test, but do not compare the results.
1384                  Segfaults can still be captured. */                  Segfaults can still be captured. */
                 if (!(current->flags & PCRE_BUG)) {  
                         if (return_value1 != return_value2) {  
                                 printf("\nReturn value differs(%d:%d): '%s' @ '%s'\n", return_value1, return_value2, current->pattern, current->input);  
                                 current++;  
                                 continue;  
                         }  
1385    
1386                          if (return_value1 >= 0) {                  is_successful = 1;
1387                                  return_value1 *= 2;                  if (!(current->start_offset & F_DIFF)) {
1388                                  err_offs = 0;  #if defined SUPPORT_UTF && ((defined(SUPPORT_PCRE8) + defined(SUPPORT_PCRE16) + defined(SUPPORT_PCRE32)) >= 2)
1389                                  for (i = 0; i < return_value1; ++i)                          if (!(current->start_offset & F_FORCECONV)) {
1390                                          if (ovector1[i] != ovector2[i]) {                                  int return_value;
1391                                                  printf("\nOvector[%d] value differs(%d:%d): '%s' @ '%s' \n", i, ovector1[i], ovector2[i], current->pattern, current->input);  
1392                                                  err_offs = 1;                                  /* All results must be the same. */
1393    #ifdef SUPPORT_PCRE8
1394                                    if ((return_value = return_value8[0]) != return_value8[1]) {
1395                                            printf("\n8 bit: Return value differs(J8:%d,I8:%d): [%d] '%s' @ '%s'\n",
1396                                                    return_value8[0], return_value8[1], total, current->pattern, current->input);
1397                                            is_successful = 0;
1398                                    } else
1399    #endif
1400    #ifdef SUPPORT_PCRE16
1401                                    if ((return_value = return_value16[0]) != return_value16[1]) {
1402                                            printf("\n16 bit: Return value differs(J16:%d,I16:%d): [%d] '%s' @ '%s'\n",
1403                                                    return_value16[0], return_value16[1], total, current->pattern, current->input);
1404                                            is_successful = 0;
1405                                    } else
1406    #endif
1407    #ifdef SUPPORT_PCRE32
1408                                    if ((return_value = return_value32[0]) != return_value32[1]) {
1409                                            printf("\n32 bit: Return value differs(J32:%d,I32:%d): [%d] '%s' @ '%s'\n",
1410                                                    return_value32[0], return_value32[1], total, current->pattern, current->input);
1411                                            is_successful = 0;
1412                                    } else
1413    #endif
1414    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1415                                    if (return_value8[0] != return_value16[0]) {
1416                                            printf("\n8 and 16 bit: Return value differs(J8:%d,J16:%d): [%d] '%s' @ '%s'\n",
1417                                                    return_value8[0], return_value16[0],
1418                                                    total, current->pattern, current->input);
1419                                            is_successful = 0;
1420                                    } else
1421    #endif
1422    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1423                                    if (return_value8[0] != return_value32[0]) {
1424                                            printf("\n8 and 32 bit: Return value differs(J8:%d,J32:%d): [%d] '%s' @ '%s'\n",
1425                                                    return_value8[0], return_value32[0],
1426                                                    total, current->pattern, current->input);
1427                                            is_successful = 0;
1428                                    } else
1429    #endif
1430    #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE32
1431                                    if (return_value16[0] != return_value32[0]) {
1432                                            printf("\n16 and 32 bit: Return value differs(J16:%d,J32:%d): [%d] '%s' @ '%s'\n",
1433                                                    return_value16[0], return_value32[0],
1434                                                    total, current->pattern, current->input);
1435                                            is_successful = 0;
1436                                    } else
1437    #endif
1438                                    if (return_value >= 0 || return_value == PCRE_ERROR_PARTIAL) {
1439                                            if (return_value == PCRE_ERROR_PARTIAL) {
1440                                                    return_value = 2;
1441                                            } else {
1442                                                    return_value *= 2;
1443                                            }
1444    #ifdef SUPPORT_PCRE8
1445                                            return_value8[0] = return_value;
1446    #endif
1447    #ifdef SUPPORT_PCRE16
1448                                            return_value16[0] = return_value;
1449    #endif
1450    #ifdef SUPPORT_PCRE32
1451                                            return_value32[0] = return_value;
1452    #endif
1453                                            /* Transform back the results. */
1454                                            if (current->flags & PCRE_UTF8) {
1455    #ifdef SUPPORT_PCRE16
1456                                                    for (i = 0; i < return_value; ++i) {
1457                                                            if (ovector16_1[i] >= 0)
1458                                                                    ovector16_1[i] = regtest_offsetmap16[ovector16_1[i]];
1459                                                            if (ovector16_2[i] >= 0)
1460                                                                    ovector16_2[i] = regtest_offsetmap16[ovector16_2[i]];
1461                                                    }
1462    #endif
1463    #ifdef SUPPORT_PCRE32
1464                                                    for (i = 0; i < return_value; ++i) {
1465                                                            if (ovector32_1[i] >= 0)
1466                                                                    ovector32_1[i] = regtest_offsetmap32[ovector32_1[i]];
1467                                                            if (ovector32_2[i] >= 0)
1468                                                                    ovector32_2[i] = regtest_offsetmap32[ovector32_2[i]];
1469                                                    }
1470    #endif
1471                                            }
1472    
1473                                            for (i = 0; i < return_value; ++i) {
1474    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1475                                                    if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector16_1[i] || ovector8_1[i] != ovector16_2[i]) {
1476                                                            printf("\n8 and 16 bit: Ovector[%d] value differs(J8:%d,I8:%d,J16:%d,I16:%d): [%d] '%s' @ '%s' \n",
1477                                                                    i, ovector8_1[i], ovector8_2[i], ovector16_1[i], ovector16_2[i],
1478                                                                    total, current->pattern, current->input);
1479                                                            is_successful = 0;
1480                                                    }
1481    #endif
1482    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1483                                                    if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector32_1[i] || ovector8_1[i] != ovector32_2[i]) {
1484                                                            printf("\n8 and 32 bit: Ovector[%d] value differs(J8:%d,I8:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1485                                                                    i, ovector8_1[i], ovector8_2[i], ovector32_1[i], ovector32_2[i],
1486                                                                    total, current->pattern, current->input);
1487                                                            is_successful = 0;
1488                                                    }
1489    #endif
1490    #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE16
1491                                                    if (ovector16_1[i] != ovector16_2[i] || ovector16_1[i] != ovector16_1[i] || ovector16_1[i] != ovector16_2[i]) {
1492                                                            printf("\n16 and 16 bit: Ovector[%d] value differs(J16:%d,I16:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1493                                                                    i, ovector16_1[i], ovector16_2[i], ovector16_1[i], ovector16_2[i],
1494                                                                    total, current->pattern, current->input);
1495                                                            is_successful = 0;
1496                                                    }
1497    #endif
1498                                          }                                          }
                                 if (err_offs) {  
                                         current++;  
                                         continue;  
1499                                  }                                  }
1500                            } else
1501    #endif /* more than one of SUPPORT_PCRE8, SUPPORT_PCRE16 and SUPPORT_PCRE32 */
1502                            {
1503                                    /* Only the 8 bit and 16 bit results must be equal. */
1504    #ifdef SUPPORT_PCRE8
1505                                    if (return_value8[0] != return_value8[1]) {
1506                                            printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1507                                                    return_value8[0], return_value8[1], total, current->pattern, current->input);
1508                                            is_successful = 0;
1509                                    } else if (return_value8[0] >= 0 || return_value8[0] == PCRE_ERROR_PARTIAL) {
1510                                            if (return_value8[0] == PCRE_ERROR_PARTIAL)
1511                                                    return_value8[0] = 2;
1512                                            else
1513                                                    return_value8[0] *= 2;
1514    
1515                                            for (i = 0; i < return_value8[0]; ++i)
1516                                                    if (ovector8_1[i] != ovector8_2[i]) {
1517                                                            printf("\n8 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1518                                                                    i, ovector8_1[i], ovector8_2[i], total, current->pattern, current->input);
1519                                                            is_successful = 0;
1520                                                    }
1521                                    }
1522    #endif
1523    
1524    #ifdef SUPPORT_PCRE16
1525                                    if (return_value16[0] != return_value16[1]) {
1526                                            printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1527                                                    return_value16[0], return_value16[1], total, current->pattern, current->input);
1528                                            is_successful = 0;
1529                                    } else if (return_value16[0] >= 0 || return_value16[0] == PCRE_ERROR_PARTIAL) {
1530                                            if (return_value16[0] == PCRE_ERROR_PARTIAL)
1531                                                    return_value16[0] = 2;
1532                                            else
1533                                                    return_value16[0] *= 2;
1534    
1535                                            for (i = 0; i < return_value16[0]; ++i)
1536                                                    if (ovector16_1[i] != ovector16_2[i]) {
1537                                                            printf("\n16 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1538                                                                    i, ovector16_1[i], ovector16_2[i], total, current->pattern, current->input);
1539                                                            is_successful = 0;
1540                                                    }
1541                                    }
1542    #endif
1543    
1544    #ifdef SUPPORT_PCRE32
1545                                    if (return_value32[0] != return_value32[1]) {
1546                                            printf("\n32 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1547                                                    return_value32[0], return_value32[1], total, current->pattern, current->input);
1548                                            is_successful = 0;
1549                                    } else if (return_value32[0] >= 0 || return_value32[0] == PCRE_ERROR_PARTIAL) {
1550                                            if (return_value32[0] == PCRE_ERROR_PARTIAL)
1551                                                    return_value32[0] = 2;
1552                                            else
1553                                                    return_value32[0] *= 2;
1554    
1555                                            for (i = 0; i < return_value32[0]; ++i)
1556                                                    if (ovector32_1[i] != ovector32_2[i]) {
1557                                                            printf("\n32 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1558                                                                    i, ovector32_1[i], ovector32_2[i], total, current->pattern, current->input);
1559                                                            is_successful = 0;
1560                                                    }
1561                                    }
1562    #endif
1563                          }                          }
1564                  }                  }
1565    
1566                  pcre_free_study(extra);                  if (is_successful) {
1567                  pcre_free(re);  #ifdef SUPPORT_PCRE8
1568                            if (!(current->start_offset & F_NO8) && ((utf && ucp) || is_ascii_input)) {
1569                                    if (return_value8[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1570                                            printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",
1571                                                    total, current->pattern, current->input);
1572                                            is_successful = 0;
1573                                    }
1574    
1575                                    if (return_value8[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1576                                            printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",
1577                                                    total, current->pattern, current->input);
1578                                            is_successful = 0;
1579                                    }
1580                            }
1581    #endif
1582    #ifdef SUPPORT_PCRE16
1583                            if (!(current->start_offset & F_NO16) && ((utf && ucp) || is_ascii_input)) {
1584                                    if (return_value16[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1585                                            printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",
1586                                                    total, current->pattern, current->input);
1587                                            is_successful = 0;
1588                                    }
1589    
1590                                    if (return_value16[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1591                                            printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",
1592                                                    total, current->pattern, current->input);
1593                                            is_successful = 0;
1594                                    }
1595                            }
1596    #endif
1597    #ifdef SUPPORT_PCRE32
1598                            if (!(current->start_offset & F_NO32) && ((utf && ucp) || is_ascii_input)) {
1599                                    if (return_value32[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1600                                            printf("32 bit: Test should match: [%d] '%s' @ '%s'\n",
1601                                                    total, current->pattern, current->input);
1602                                            is_successful = 0;
1603                                    }
1604    
1605                                    if (return_value32[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1606                                            printf("32 bit: Test should not match: [%d] '%s' @ '%s'\n",
1607                                                    total, current->pattern, current->input);
1608                                            is_successful = 0;
1609                                    }
1610                            }
1611    #endif
1612                    }
1613    
1614                    if (is_successful) {
1615    #ifdef SUPPORT_PCRE8
1616                            if (mark8_1 != mark8_2) {
1617                                    printf("8 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1618                                            total, current->pattern, current->input);
1619                                    is_successful = 0;
1620                            }
1621    #endif
1622    #ifdef SUPPORT_PCRE16
1623                            if (mark16_1 != mark16_2) {
1624                                    printf("16 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1625                                            total, current->pattern, current->input);
1626                                    is_successful = 0;
1627                            }
1628    #endif
1629    #ifdef SUPPORT_PCRE32
1630                            if (mark32_1 != mark32_2) {
1631                                    printf("32 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1632                                            total, current->pattern, current->input);
1633                                    is_successful = 0;
1634                            }
1635    #endif
1636                    }
1637    
1638    #ifdef SUPPORT_PCRE8
1639                    if (re8) {
1640                            pcre_free_study(extra8);
1641                            pcre_free(re8);
1642                    }
1643    #endif
1644    #ifdef SUPPORT_PCRE16
1645                    if (re16) {
1646                            pcre16_free_study(extra16);
1647                            pcre16_free(re16);
1648                    }
1649    #endif
1650    #ifdef SUPPORT_PCRE32
1651                    if (re32) {
1652                            pcre32_free_study(extra32);
1653                            pcre32_free(re32);
1654                    }
1655    #endif
1656    
1657                    if (is_successful) {
1658                            successful++;
1659                            successful_row++;
1660                            printf(".");
1661                            if (successful_row >= 60) {
1662                                    successful_row = 0;
1663                                    printf("\n");
1664                            }
1665                    } else
1666                            successful_row = 0;
1667    
                 /* printf("[%d-%d]%s", ovector1[0], ovector1[1], (current->flags & PCRE_CASELESS) ? "C" : ""); */  
                 printf(".");  
1668                  fflush(stdout);                  fflush(stdout);
1669                  current++;                  current++;
                 succesful++;  
1670          }          }
1671            tables(1);
1672    #ifdef SUPPORT_PCRE8
1673            setstack8(NULL);
1674    #endif
1675    #ifdef SUPPORT_PCRE16
1676            setstack16(NULL);
1677    #endif
1678    #ifdef SUPPORT_PCRE32
1679            setstack32(NULL);
1680    #endif
1681    
1682          if (total == succesful) {          if (total == successful) {
1683                  printf("\nAll JIT regression tests are successfully passed.\n");                  printf("\nAll JIT regression tests are successfully passed.\n");
1684                  return 0;                  return 0;
1685          } else {          } else {
1686                  printf("\nSuccessful test ratio: %d%%\n", succesful * 100 / total);                  printf("\nSuccessful test ratio: %d%% (%d failed)\n", successful * 100 / total, total - successful);
1687                  return 1;                  return 1;
1688          }          }
1689  }  }

Legend:
Removed from v.736  
changed lines
  Added in v.1308

  ViewVC Help
Powered by ViewVC 1.1.5