/[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 1245 by zherczeg, Sat Feb 9 11:30:51 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          /* Basic character sets. */          /* Basic character sets. */
312          { 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 318  static struct regression_test_case regre
318    
319          /* Unicode properties. */          /* Unicode properties. */
320          { MUAP, 0, "[1-5\xc3\xa9\\w]", "\xc3\xa1_" },          { MUAP, 0, "[1-5\xc3\xa9\\w]", "\xc3\xa1_" },
321          { MUAP, 0, "[\xc3\x81\\p{Ll}]", "A_\xc3\x89\xc3\xa1" },          { MUAP, 0 | F_PROPERTY, "[\xc3\x81\\p{Ll}]", "A_\xc3\x89\xc3\xa1" },
322          { MUAP, 0, "[\\Wd-h_x-z]+", "a\xc2\xa1#_yhzdxi" },          { MUAP, 0, "[\\Wd-h_x-z]+", "a\xc2\xa1#_yhzdxi" },
323          { MUAP, 0, "[\\P{Any}]", "abc" },          { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\\P{Any}]", "abc" },
324          { MUAP, 0, "[^\\p{Any}]", "abc" },          { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\\p{Any}]", "abc" },
325          { MUAP, 0, "[\\P{Any}\xc3\xa1-\xc3\xa8]", "abc" },          { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\\P{Any}\xc3\xa1-\xc3\xa8]", "abc" },
326          { MUAP, 0, "[^\\p{Any}\xc3\xa1-\xc3\xa8]", "abc" },          { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\\p{Any}\xc3\xa1-\xc3\xa8]", "abc" },
327          { MUAP, 0, "[\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },          { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },
328          { MUAP, 0, "[^\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },          { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },
329          { MUAP, 0, "[\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },          { MUAP, 0 | F_PROPERTY, "[\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },
330          { MUAP, 0, "[^\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },          { MUAP, 0 | F_PROPERTY, "[^\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },
331          { MUAP, 0, "[b-\xc3\xa9\\s]", "a\xc\xe6\x92\xad" },          { MUAP, 0, "[b-\xc3\xa9\\s]", "a\xc\xe6\x92\xad" },
332          { CMUAP, 0, "[\xc2\x85-\xc2\x89\xc3\x89]", "\xc2\x84\xc3\xa9" },          { CMUAP, 0, "[\xc2\x85-\xc2\x89\xc3\x89]", "\xc2\x84\xc3\xa9" },
333          { MUAP, 0, "[^b-d^&\\s]{3,}", "db^ !a\xe2\x80\xa8_ae" },          { MUAP, 0, "[^b-d^&\\s]{3,}", "db^ !a\xe2\x80\xa8_ae" },
334          { 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" },
335          { 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" },
336          { 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" },
337          { 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" },
338          { 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#" },
339          { PCRE_UCP, 0, "[a-b\\s]{2,5}[^a]", "AB  baaa" },          { PCRE_UCP, 0, "[a-b\\s]{2,5}[^a]", "AB  baaa" },
340    
341          /* Possible empty brackets. */          /* Possible empty brackets. */
# Line 312  static struct regression_test_case regre Line 352  static struct regression_test_case regre
352    
353          /* Start offset. */          /* Start offset. */
354          { MUA, 3, "(\\d|(?:\\w)*\\w)+", "0ac01Hb" },          { MUA, 3, "(\\d|(?:\\w)*\\w)+", "0ac01Hb" },
355          { MUA, 4, "(\\w\\W\\w)+", "ab#d" },          { MUA, 4 | F_NOMATCH, "(\\w\\W\\w)+", "ab#d" },
356          { MUA, 2, "(\\w\\W\\w)+", "ab#d" },          { MUA, 2 | F_NOMATCH, "(\\w\\W\\w)+", "ab#d" },
357          { MUA, 1, "(\\w\\W\\w)+", "ab#d" },          { MUA, 1, "(\\w\\W\\w)+", "ab#d" },
358    
359          /* Newline. */          /* Newline. */
# Line 327  static struct regression_test_case regre Line 367  static struct regression_test_case regre
367          { 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" },
368          { 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" },
369          { 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" },
370          { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".(.).", "\xe2\x80\xa8\nb\r" },          { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0 | F_NOMATCH, ".(.).", "\xe2\x80\xa8\nb\r" },
371          { PCRE_NEWLINE_ANY, 0, "(.)(.)", "#\x85#\r#\n#\r\n#\x84" },          { PCRE_NEWLINE_ANY, 0, "(.)(.)", "#\x85#\r#\n#\r\n#\x84" },
372          { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.+)#", "#\rMn\xc2\x85#\n###" },          { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.+)#", "#\rMn\xc2\x85#\n###" },
373          { PCRE_BSR_ANYCRLF, 0, "\\R", "\r" },          { PCRE_BSR_ANYCRLF, 0, "\\R", "\r" },
# Line 335  static struct regression_test_case regre Line 375  static struct regression_test_case regre
375          { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\xe2\x80\xa8#c" },          { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\xe2\x80\xa8#c" },
376          { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\r\nc" },          { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\r\nc" },
377          { 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" },
378          { MUA, 0, "\\R+", "ab" },          { MUA, 0 | F_NOMATCH, "\\R+", "ab" },
379          { MUA, 0, "\\R+", "ab\r\n\r" },          { MUA, 0, "\\R+", "ab\r\n\r" },
380          { MUA, 0, "\\R*", "ab\r\n\r" },          { MUA, 0, "\\R*", "ab\r\n\r" },
381          { MUA, 0, "\\R*", "\r\n\r" },          { MUA, 0, "\\R*", "\r\n\r" },
# Line 343  static struct regression_test_case regre Line 383  static struct regression_test_case regre
383          { 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" },
384          { MUA, 0, "\\R{2,}", "\r\nab\n\n\n\r\r\r" },          { MUA, 0, "\\R{2,}", "\r\nab\n\n\n\r\r\r" },
385          { 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" },
386          { MUA, 0, "\\R+\\R\\R", "\r\n\r\n" },          { MUA, 0 | F_NOMATCH, "\\R+\\R\\R", "\r\n\r\n" },
387          { MUA, 0, "\\R+\\R\\R", "\r\r\r" },          { MUA, 0, "\\R+\\R\\R", "\r\r\r" },
388          { MUA, 0, "\\R*\\R\\R", "\n\r" },          { MUA, 0, "\\R*\\R\\R", "\n\r" },
389          { MUA, 0, "\\R{2,4}\\R\\R", "\r\r\r" },          { MUA, 0 | F_NOMATCH, "\\R{2,4}\\R\\R", "\r\r\r" },
390          { MUA, 0, "\\R{2,4}\\R\\R", "\r\r\r\r" },          { MUA, 0, "\\R{2,4}\\R\\R", "\r\r\r\r" },
391    
392          /* Atomic groups (no fallback from "next" direction). */          /* Atomic groups (no fallback from "next" direction). */
393          { MUA, 0, "(?>ab)ab", "bab" },          { MUA, 0 | F_NOMATCH, "(?>ab)ab", "bab" },
394          { MUA, 0, "(?>(ab))ab", "bab" },          { MUA, 0 | F_NOMATCH, "(?>(ab))ab", "bab" },
395          { 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",
396                          "bababcdedefgheijijklmlmnop" },                          "bababcdedefgheijijklmlmnop" },
397          { 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 419  static struct regression_test_case regre
419          { 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" },
420          { 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" },
421          { 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" },
422          { MUA, 0, "\\X", "\xcc\x8d\xcc\x8d" },          { MUA, 0 | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d" },
423          { MUA, 0, "\\X", "\xcc\x8d\xcc\x8d#\xcc\x8d\xcc\x8d" },          { MUA, 0 | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d#\xcc\x8d\xcc\x8d" },
424          { MUA, 0, "\\X+..", "\xcc\x8d#\xcc\x8d#\xcc\x8d\xcc\x8d" },          { MUA, 0 | F_PROPERTY, "\\X+..", "\xcc\x8d#\xcc\x8d#\xcc\x8d\xcc\x8d" },
425          { MUA, 0, "\\X{2,4}", "abcdef" },          { MUA, 0 | F_PROPERTY, "\\X{2,4}", "abcdef" },
426          { MUA, 0, "\\X{2,4}?", "abcdef" },          { MUA, 0 | F_PROPERTY, "\\X{2,4}?", "abcdef" },
427          { MUA, 0, "\\X{2,4}..", "#\xcc\x8d##" },          { MUA, 0 | F_NOMATCH | F_PROPERTY, "\\X{2,4}..", "#\xcc\x8d##" },
428          { MUA, 0, "\\X{2,4}..", "#\xcc\x8d#\xcc\x8d##" },          { MUA, 0 | F_PROPERTY, "\\X{2,4}..", "#\xcc\x8d#\xcc\x8d##" },
429          { MUA, 0, "(c(ab)?+ab)+", "cabcababcab" },          { MUA, 0, "(c(ab)?+ab)+", "cabcababcab" },
430          { MUA, 0, "(?>(a+)b)+aabab", "aaaabaaabaabab" },          { MUA, 0, "(?>(a+)b)+aabab", "aaaabaaabaabab" },
431    
# Line 420  static struct regression_test_case regre Line 460  static struct regression_test_case regre
460          { MUA, 0, "((b*))++m", "bxbbxbbbxbbm" },          { MUA, 0, "((b*))++m", "bxbbxbbbxbbm" },
461          { MUA, 0, "((b*))*+m", "bxbbxbbbxm" },          { MUA, 0, "((b*))*+m", "bxbbxbbbxm" },
462          { MUA, 0, "((b*))*+m", "bxbbxbbbxbbm" },          { MUA, 0, "((b*))*+m", "bxbbxbbbxbbm" },
463          { 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" },
464          { MUA, 0, "((?:b)++a)+(cd)*+m", "bbababbacdcdnbbababbacdcdm" },          { MUA, 0, "((?:b)++a)+(cd)*+m", "bbababbacdcdnbbababbacdcdm" },
465          { MUA, 0, "((?:(b))++a)+((c)d)*+m", "bbababbacdcdnbbababbacdcdm" },          { MUA, 0, "((?:(b))++a)+((c)d)*+m", "bbababbacdcdnbbababbacdcdm" },
466          { 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 484  static struct regression_test_case regre
484          { 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" },
485          { MUA, 0, "(a(?:\\1|)a){3}b", "aaaaaaaaaaab" },          { MUA, 0, "(a(?:\\1|)a){3}b", "aaaaaaaaaaab" },
486          { 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" },
487          { MUAP, 0, "(\\P{N})\\1{2,}", ".www." },          { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{2,}", ".www." },
488          { MUAP, 0, "(\\P{N})\\1{0,2}", "wwwww." },          { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{0,2}", "wwwww." },
489          { MUAP, 0, "(\\P{N})\\1{1,2}ww", "wwww" },          { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{1,2}ww", "wwww" },
490          { MUAP, 0, "(\\P{N})\\1{1,2}ww", "wwwww" },          { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{1,2}ww", "wwwww" },
491          { PCRE_UCP, 0, "(\\P{N})\\1{2,}", ".www." },          { PCRE_UCP, 0 | F_PROPERTY, "(\\P{N})\\1{2,}", ".www." },
492            { CMUAP, 0, "(\xf0\x90\x90\x80)\\1", "\xf0\x90\x90\xa8\xf0\x90\x90\xa8" },
493    
494          /* Assertions. */          /* Assertions. */
495          { 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 505  static struct regression_test_case regre
505          { MUA, 0, "(?>a(?>(b+))a(?=(..)))*?k", "acabbcabbaabacabaabbakk" },          { MUA, 0, "(?>a(?>(b+))a(?=(..)))*?k", "acabbcabbaabacabaabbakk" },
506          { MUA, 0, "((?(?=(a))a)+k)", "bbak" },          { MUA, 0, "((?(?=(a))a)+k)", "bbak" },
507          { MUA, 0, "((?(?=a)a)+k)", "bbak" },          { MUA, 0, "((?(?=a)a)+k)", "bbak" },
508          { MUA, 0, "(?=(?>(a))m)amk", "a k" },          { MUA, 0 | F_NOMATCH, "(?=(?>(a))m)amk", "a k" },
509          { MUA, 0, "(?!(?>(a))m)amk", "a k" },          { MUA, 0 | F_NOMATCH, "(?!(?>(a))m)amk", "a k" },
510          { MUA, 0, "(?>(?=(a))am)amk", "a k" },          { MUA, 0 | F_NOMATCH, "(?>(?=(a))am)amk", "a k" },
511          { 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" },
512          { 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" },
513          { MUA, 0, "(?:(?=ab)?[^n][^n])+m", "ababcdabcdcdabnababcdabcdcdabm" },          { MUA, 0, "(?:(?=ab)?[^n][^n])+m", "ababcdabcdcdabnababcdabcdcdabm" },
# Line 477  static struct regression_test_case regre Line 518  static struct regression_test_case regre
518          { MUA, 0, "((?!a)?\?(?!([^a]))?\?)+$", "acbab" },          { MUA, 0, "((?!a)?\?(?!([^a]))?\?)+$", "acbab" },
519    
520          /* Not empty, ACCEPT, FAIL */          /* Not empty, ACCEPT, FAIL */
521          { MUA | PCRE_NOTEMPTY, 0, "a*", "bcx" },          { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a*", "bcx" },
522          { MUA | PCRE_NOTEMPTY, 0, "a*", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "a*", "bcaad" },
523          { MUA | PCRE_NOTEMPTY, 0, "a*?", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "a*?", "bcaad" },
524          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*", "bcaad" },          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*", "bcaad" },
525          { MUA, 0, "a(*ACCEPT)b", "ab" },          { MUA, 0, "a(*ACCEPT)b", "ab" },
526          { MUA | PCRE_NOTEMPTY, 0, "a*(*ACCEPT)b", "bcx" },          { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a*(*ACCEPT)b", "bcx" },
527          { MUA | PCRE_NOTEMPTY, 0, "a*(*ACCEPT)b", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "a*(*ACCEPT)b", "bcaad" },
528          { MUA | PCRE_NOTEMPTY, 0, "a*?(*ACCEPT)b", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "a*?(*ACCEPT)b", "bcaad" },
529          { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*(*ACCEPT)b)", "bcx" },          { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "(?:z|a*(*ACCEPT)b)", "bcx" },
530          { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*(*ACCEPT)b)", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*(*ACCEPT)b)", "bcaad" },
531          { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*?(*ACCEPT)b)", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*?(*ACCEPT)b)", "bcaad" },
532          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*(*ACCEPT)b", "bcx" },          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*(*ACCEPT)b", "bcx" },
533          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*(*ACCEPT)b", "" },          { MUA | PCRE_NOTEMPTY_ATSTART, 0 | F_NOMATCH, "a*(*ACCEPT)b", "" },
534          { MUA, 0, "((a(*ACCEPT)b))", "ab" },          { MUA, 0, "((a(*ACCEPT)b))", "ab" },
535          { MUA, 0, "(a(*FAIL)a|a)", "aaa" },          { MUA, 0, "(a(*FAIL)a|a)", "aaa" },
536          { MUA, 0, "(?=ab(*ACCEPT)b)a", "ab" },          { MUA, 0, "(?=ab(*ACCEPT)b)a", "ab" },
# Line 506  static struct regression_test_case regre Line 547  static struct regression_test_case regre
547          { MUA, 0, "(?(?!(b))a*|b*)+k", "ababbalbbadabak" },          { MUA, 0, "(?(?!(b))a*|b*)+k", "ababbalbbadabak" },
548          { MUA, 0, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },          { MUA, 0, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },
549          { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },          { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },
550          { 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" },
551          { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" },          { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" },
552          { MUA, 0, "(?(?=a)a*|b*)+k", "ababbalbbadabak" },          { MUA, 0, "(?(?=a)a*|b*)+k", "ababbalbbadabak" },
553          { MUA, 0, "(?(?!b)a*|b*)+k", "ababbalbbadabak" },          { MUA, 0, "(?(?!b)a*|b*)+k", "ababbalbbadabak" },
# Line 520  static struct regression_test_case regre Line 561  static struct regression_test_case regre
561          { 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" },
562          { MUA, 0, "(c)?\?(?(1)a|b)", "cdcaa" },          { MUA, 0, "(c)?\?(?(1)a|b)", "cdcaa" },
563          { MUA, 0, "(c)?\?(?(1)a|b)", "cbb" },          { MUA, 0, "(c)?\?(?(1)a|b)", "cbb" },
564          { MUA | PCRE_BUG, 0, "(?(?=(a))(aaaa|a?))+aak", "aaaaab aaaaak" },          { MUA, 0 | F_DIFF, "(?(?=(a))(aaaa|a?))+aak", "aaaaab aaaaak" },
565          { MUA, 0, "(?(?=a)(aaaa|a?))+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?=a)(aaaa|a?))+aak", "aaaaab aaaaak" },
566          { MUA, 0, "(?(?!(b))(aaaa|a?))+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?!(b))(aaaa|a?))+aak", "aaaaab aaaaak" },
567          { MUA, 0, "(?(?!b)(aaaa|a?))+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?!b)(aaaa|a?))+aak", "aaaaab aaaaak" },
568          { MUA | PCRE_BUG, 0, "(?(?=(a))a*)+aak", "aaaaab aaaaak" },          { MUA, 0 | F_DIFF, "(?(?=(a))a*)+aak", "aaaaab aaaaak" },
569          { MUA, 0, "(?(?=a)a*)+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?=a)a*)+aak", "aaaaab aaaaak" },
570          { MUA, 0, "(?(?!(b))a*)+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?!(b))a*)+aak", "aaaaab aaaaak" },
571          { MUA, 0, "(?(?!b)a*)+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?!b)a*)+aak", "aaaaab aaaaak" },
572          { MUA, 0, "(?(?=(?=(?!(x))a)aa)aaa|(?(?=(?!y)bb)bbb))*k", "abaabbaaabbbaaabbb abaabbaaabbbaaabbbk" },          { MUA, 0, "(?(?=(?=(?!(x))a)aa)aaa|(?(?=(?!y)bb)bbb))*k", "abaabbaaabbbaaabbb abaabbaaabbbaaabbbk" },
573            { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)*l", "bc ddd abccabccl" },
574            { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+?dd", "bcabcacdb bdddd" },
575            { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+l", "ababccddabdbccd abcccl" },
576            { MUA, 0, "((?:a|aa)(?(1)aaa))x", "aax" },
577    
578          /* Set start of match. */          /* Set start of match. */
579          { MUA, 0, "(?:\\Ka)*aaaab", "aaaaaaaa aaaaaaabb" },          { MUA, 0, "(?:\\Ka)*aaaab", "aaaaaaaa aaaaaaabb" },
580          { MUA, 0, "(?>\\Ka\\Ka)*aaaab", "aaaaaaaa aaaaaaaaaabb" },          { MUA, 0, "(?>\\Ka\\Ka)*aaaab", "aaaaaaaa aaaaaaaaaabb" },
581          { MUA, 0, "a+\\K(?<=\\Gaa)a", "aaaaaa" },          { MUA, 0, "a+\\K(?<=\\Gaa)a", "aaaaaa" },
582          { MUA | PCRE_NOTEMPTY, 0, "a\\K(*ACCEPT)b", "aa" },          { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a\\K(*ACCEPT)b", "aa" },
583          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a\\K(*ACCEPT)b", "aa" },          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a\\K(*ACCEPT)b", "aa" },
584    
585          /* First line. */          /* First line. */
586          { MUA | PCRE_FIRSTLINE, 0, "\\p{Any}a", "bb\naaa" },          { MUA | PCRE_FIRSTLINE, 0 | F_PROPERTY, "\\p{Any}a", "bb\naaa" },
587          { MUA | PCRE_FIRSTLINE, 0, "\\p{Any}a", "bb\r\naaa" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH | F_PROPERTY, "\\p{Any}a", "bb\r\naaa" },
588          { MUA | PCRE_FIRSTLINE, 0, "(?<=a)", "a" },          { MUA | PCRE_FIRSTLINE, 0, "(?<=a)", "a" },
589          { MUA | PCRE_FIRSTLINE, 0, "[^a][^b]", "ab" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[^a][^b]", "ab" },
590          { MUA | PCRE_FIRSTLINE, 0, "a", "\na" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "a", "\na" },
591          { MUA | PCRE_FIRSTLINE, 0, "[abc]", "\na" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[abc]", "\na" },
592          { MUA | PCRE_FIRSTLINE, 0, "^a", "\na" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^a", "\na" },
593          { MUA | PCRE_FIRSTLINE, 0, "^(?<=\n)", "\na" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^(?<=\n)", "\na" },
594          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0, "#", "\xc2\x85#" },          { MUA | PCRE_FIRSTLINE, 0, "\xf0\x90\x90\x80", "\xf0\x90\x90\x80" },
595          { PCRE_MULTILINE | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0, "#", "\x85#" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\xc2\x85#" },
596          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0, "^#", "\xe2\x80\xa8#" },          { PCRE_MULTILINE | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\x85#" },
597          { 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#" },
598            { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_PROPERTY, "\\p{Any}", "\r\na" },
599          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, ".", "\r" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, ".", "\r" },
600          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "a", "\ra" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "a", "\ra" },
601          { 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" },
602          { 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" },
603          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 1, ".", "\r\n" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 1, ".", "\r\n" },
604            { PCRE_FIRSTLINE | PCRE_NEWLINE_LF | PCRE_DOTALL, 0 | F_NOMATCH, "ab.", "ab" },
605    
606          /* Recurse. */          /* Recurse. */
607          { MUA, 0, "(a)(?1)", "aa" },          { MUA, 0, "(a)(?1)", "aa" },
608          { MUA, 0, "((a))(?1)", "aa" },          { MUA, 0, "((a))(?1)", "aa" },
609          { MUA, 0, "(b|a)(?1)", "aa" },          { MUA, 0, "(b|a)(?1)", "aa" },
610          { MUA, 0, "(b|(a))(?1)", "aa" },          { MUA, 0, "(b|(a))(?1)", "aa" },
611          { MUA, 0, "((a)(b)(?:a*))(?1)", "aba" },          { MUA, 0 | F_NOMATCH, "((a)(b)(?:a*))(?1)", "aba" },
612          { MUA, 0, "((a)(b)(?:a*))(?1)", "abab" },          { MUA, 0, "((a)(b)(?:a*))(?1)", "abab" },
613          { MUA, 0, "((a+)c(?2))b(?1)", "aacaabaca" },          { MUA, 0, "((a+)c(?2))b(?1)", "aacaabaca" },
614          { 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 616  static struct regression_test_case regre
616          { MUA, 0, "(?1)(((a(*ACCEPT)))b)", "axaa" },          { MUA, 0, "(?1)(((a(*ACCEPT)))b)", "axaa" },
617          { MUA, 0, "(?1)(?(DEFINE) (((ac(*ACCEPT)))b) )", "akaac" },          { MUA, 0, "(?1)(?(DEFINE) (((ac(*ACCEPT)))b) )", "akaac" },
618          { MUA, 0, "(a+)b(?1)b\\1", "abaaabaaaaa" },          { MUA, 0, "(a+)b(?1)b\\1", "abaaabaaaaa" },
619          { MUA, 0, "(?(DEFINE)(aa|a))(?1)ab", "aab" },          { MUA, 0 | F_NOMATCH, "(?(DEFINE)(aa|a))(?1)ab", "aab" },
620          { MUA, 0, "(?(DEFINE)(a\\Kb))(?1)+ababc", "abababxabababc" },          { MUA, 0, "(?(DEFINE)(a\\Kb))(?1)+ababc", "abababxabababc" },
621          { MUA, 0, "(a\\Kb)(?1)+ababc", "abababxababababc" },          { MUA, 0, "(a\\Kb)(?1)+ababc", "abababxababababc" },
622          { MUA, 0, "(a\\Kb)(?1)+ababc", "abababxababababxc" },          { MUA, 0 | F_NOMATCH, "(a\\Kb)(?1)+ababc", "abababxababababxc" },
623          { MUA, 0, "b|<(?R)*>", "<<b>" },          { MUA, 0, "b|<(?R)*>", "<<b>" },
624          { MUA, 0, "(a\\K){0}(?:(?1)b|ac)", "ac" },          { MUA, 0, "(a\\K){0}(?:(?1)b|ac)", "ac" },
625          { 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" },
626            { MUA, 0, "(a)((?(R)a|b))(?2)", "aabbabaa" },
627            { MUA, 0, "(a)((?(R2)a|b))(?2)", "aabbabaa" },
628            { MUA, 0, "(a)((?(R1)a|b))(?2)", "ababba" },
629            { MUA, 0, "(?(R0)aa|bb(?R))", "abba aabb bbaa" },
630            { MUA, 0, "((?(R)(?:aaaa|a)|(?:(aaaa)|(a)))+)(?1)$", "aaaaaaaaaa aaaa" },
631            { MUA, 0, "(?P<Name>a(?(R&Name)a|b))(?1)", "aab abb abaa" },
632    
633            /* 16 bit specific tests. */
634            { CMA, 0 | F_FORCECONV, "\xc3\xa1", "\xc3\x81\xc3\xa1" },
635            { CMA, 0 | F_FORCECONV, "\xe1\xbd\xb8", "\xe1\xbf\xb8\xe1\xbd\xb8" },
636            { CMA, 0 | F_FORCECONV, "[\xc3\xa1]", "\xc3\x81\xc3\xa1" },
637            { CMA, 0 | F_FORCECONV, "[\xe1\xbd\xb8]", "\xe1\xbf\xb8\xe1\xbd\xb8" },
638            { CMA, 0 | F_FORCECONV, "[a-\xed\xb0\x80]", "A" },
639            { CMA, 0 | F_NO8 | F_FORCECONV, "[a-\\x{dc00}]", "B" },
640            { CMA, 0 | F_NO8 | F_NOMATCH | F_FORCECONV, "[b-\\x{dc00}]", "a" },
641            { 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" },
642            { 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#" },
643            { 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" },
644            { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xed\xb3\xbf]", "\xed\x9f\xbf\xed\xa0\x83" },
645            { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xed\xb3\xbf]", "\xed\xb4\x80\xed\xb3\xb0" },
646            { CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\x9f\xbf\xed\xa0\x83" },
647            { CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\xb4\x80\xed\xb3\xb0" },
648            { 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#" },
649            { 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" },
650            { MA, 0 | F_FORCECONV, "[^\xed\xb0\x80]{3,}?", "##\xed\xb0\x80#\xed\xb0\x80#\xc3\x89#\xed\xb0\x80" },
651            { MA, 0 | F_NO8 | F_FORCECONV, "[^\\x{dc00}]{3,}?", "##\xed\xb0\x80#\xed\xb0\x80#\xc3\x89#\xed\xb0\x80" },
652            { CMA, 0 | F_FORCECONV, ".\\B.", "\xed\xa0\x80\xed\xb0\x80" },
653            { 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" },
654            { CMA, 0 | F_FORCECONV, "\\d*\\s*\\w*\xed\xa0\x80\xed\xa0\x80", "\xed\xa0\x80\xed\xa0\x80" },
655            { CMA, 0 | F_FORCECONV | F_NOMATCH, "\\d*?\\D*?\\s*?\\S*?\\w*?\\W*?##", "\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80#" },
656            { CMA | PCRE_EXTENDED, 0 | F_FORCECONV, "\xed\xa0\x80 \xed\xb0\x80 !", "\xed\xa0\x80\xed\xb0\x80!" },
657            { CMA, 0 | F_FORCECONV, "\xed\xa0\x80+#[^#]+\xed\xa0\x80", "\xed\xa0\x80#a\xed\xa0\x80" },
658            { CMA, 0 | F_FORCECONV, "(\xed\xa0\x80+)#\\1", "\xed\xa0\x80\xed\xa0\x80#\xed\xa0\x80\xed\xa0\x80" },
659            { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0 | F_NO8 | F_FORCECONV, "^-", "a--\xe2\x80\xa8--" },
660            { PCRE_BSR_UNICODE, 0 | F_NO8 | F_FORCECONV, "\\R", "ab\xe2\x80\xa8" },
661            { 0, 0 | F_NO8 | F_FORCECONV, "\\v", "ab\xe2\x80\xa9" },
662            { 0, 0 | F_NO8 | F_FORCECONV, "\\h", "ab\xe1\xa0\x8e" },
663            { 0, 0 | F_NO8 | F_FORCECONV, "\\v+?\\V+?#", "\xe2\x80\xa9\xe2\x80\xa9\xef\xbf\xbf\xef\xbf\xbf#" },
664            { 0, 0 | F_NO8 | F_FORCECONV, "\\h+?\\H+?#", "\xe1\xa0\x8e\xe1\xa0\x8e\xef\xbf\xbf\xef\xbf\xbf#" },
665    
666            /* Partial matching. */
667            { MUA | PCRE_PARTIAL_SOFT, 0, "ab", "a" },
668            { MUA | PCRE_PARTIAL_SOFT, 0, "ab|a", "a" },
669            { MUA | PCRE_PARTIAL_HARD, 0, "ab|a", "a" },
670            { MUA | PCRE_PARTIAL_SOFT, 0, "\\b#", "a" },
671            { MUA | PCRE_PARTIAL_SOFT, 0, "(?<=a)b", "a" },
672            { MUA | PCRE_PARTIAL_SOFT, 0, "abc|(?<=xxa)bc", "xxab" },
673            { MUA | PCRE_PARTIAL_SOFT, 0, "a\\B", "a" },
674            { MUA | PCRE_PARTIAL_HARD, 0, "a\\b", "a" },
675    
676            /* (*MARK) verb. */
677            { MUA, 0, "a(*MARK:aa)a", "ababaa" },
678            { MUA, 0 | F_NOMATCH, "a(*:aa)a", "abab" },
679            { MUA, 0, "a(*:aa)(b(*:bb)b|bc)", "abc" },
680            { MUA, 0 | F_NOMATCH, "a(*:1)x|b(*:2)y", "abc" },
681            { MUA, 0, "(?>a(*:aa))b|ac", "ac" },
682            { MUA, 0, "(?(DEFINE)(a(*:aa)))(?1)", "a" },
683            { MUA, 0 | F_NOMATCH, "(?(DEFINE)((a)(*:aa)))(?1)b", "aa" },
684            { MUA, 0, "(?(DEFINE)(a(*:aa)))a(?1)b|aac", "aac" },
685            { MUA, 0, "(a(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
686            { MUA, 0, "(a(*:aa)){0}(?:b(?1)b)+", "babba" },
687            { MUA, 0 | F_NOMATCH | F_STUDY, "(a(*:aa)){0}(?:b(?1)b)+", "ba" },
688            { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
689            { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b)+", "babba" },
690            { MUA, 0 | F_NOMATCH | F_STUDY, "(a\\K(*:aa)){0}(?:b(?1)b)+", "ba" },
691            { MUA, 0 | F_NOMATCH | F_STUDY, "(*:mark)m", "a" },
692    
693            /* (*COMMIT) verb. */
694            { MUA, 0 | F_NOMATCH, "a(*COMMIT)b", "ac" },
695            { MUA, 0, "aa(*COMMIT)b", "xaxaab" },
696            { MUA, 0 | F_NOMATCH, "a(*COMMIT)(*:msg)b|ac", "ac" },
697            { MUA, 0, "(?=a(*COMMIT)b|ac)ac|(*:m)(a)c", "ac" },
698            { MUA, 0, "(?!a(*COMMIT)(*:msg)b)a(c)|cd", "acd" },
699    
700          /* Deep recursion. */          /* Deep recursion. */
701          { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },          { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },
702          { MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " },          { MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " },
703          { MUA, 0, "((a?)+)+b", "aaaaaaaaaaaaa b" },          { MUA, 0, "((a?)+)+b", "aaaaaaaaaaaa b" },
704    
705          /* Deep recursion: Stack limit reached. */          /* Deep recursion: Stack limit reached. */
706          { 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" },
707          { MA, 0, "(?:a+)+b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },          { MA, 0 | F_NOMATCH, "(?:a+)+b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
708          { MA, 0, "(?:a+?)+?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },          { MA, 0 | F_NOMATCH, "(?:a+?)+?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
709          { MA, 0, "(?:a*)*b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },          { MA, 0 | F_NOMATCH, "(?:a*)*b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
710          { MA, 0, "(?:a*?)*?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },          { MA, 0 | F_NOMATCH, "(?:a*?)*?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
711    
712          { 0, 0, NULL, NULL }          { 0, 0, NULL, NULL }
713  };  };
714    
715    static const unsigned char *tables(int mode)
716    {
717            /* The purpose of this function to allow valgrind
718            for reporting invalid reads and writes. */
719            static unsigned char *tables_copy;
720            const char *errorptr;
721            int erroroffset;
722            unsigned char *default_tables;
723    #if defined SUPPORT_PCRE8
724            pcre *regex;
725            char null_str[1] = { 0 };
726    #elif defined SUPPORT_PCRE16
727            pcre16 *regex;
728            PCRE_UCHAR16 null_str[1] = { 0 };
729    #elif defined SUPPORT_PCRE32
730            pcre32 *regex;
731            PCRE_UCHAR32 null_str[1] = { 0 };
732    #endif
733    
734            if (mode) {
735                    if (tables_copy)
736                            free(tables_copy);
737                    tables_copy = NULL;
738                    return NULL;
739            }
740    
741            if (tables_copy)
742                    return tables_copy;
743    
744            default_tables = NULL;
745    #if defined SUPPORT_PCRE8
746            regex = pcre_compile(null_str, 0, &errorptr, &erroroffset, NULL);
747            if (regex) {
748                    pcre_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
749                    pcre_free(regex);
750            }
751    #elif defined SUPPORT_PCRE16
752            regex = pcre16_compile(null_str, 0, &errorptr, &erroroffset, NULL);
753            if (regex) {
754                    pcre16_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
755                    pcre16_free(regex);
756            }
757    #elif defined SUPPORT_PCRE32
758            regex = pcre32_compile(null_str, 0, &errorptr, &erroroffset, NULL);
759            if (regex) {
760                    pcre32_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
761                    pcre32_free(regex);
762            }
763    #endif
764            /* Shouldn't ever happen. */
765            if (!default_tables)
766                    return NULL;
767    
768            /* Unfortunately this value cannot get from pcre_fullinfo.
769            Since this is a test program, this is acceptable at the moment. */
770            tables_copy = (unsigned char *)malloc(1088);
771            if (!tables_copy)
772                    return NULL;
773    
774            memcpy(tables_copy, default_tables, 1088);
775            return tables_copy;
776    }
777    
778    #ifdef SUPPORT_PCRE8
779    static pcre_jit_stack* callback8(void *arg)
780    {
781            return (pcre_jit_stack *)arg;
782    }
783    #endif
784    
785    #ifdef SUPPORT_PCRE16
786    static pcre16_jit_stack* callback16(void *arg)
787    {
788            return (pcre16_jit_stack *)arg;
789    }
790    #endif
791    
792    #ifdef SUPPORT_PCRE32
793    static pcre32_jit_stack* callback32(void *arg)
794    {
795            return (pcre32_jit_stack *)arg;
796    }
797    #endif
798    
799    #ifdef SUPPORT_PCRE8
800    static pcre_jit_stack *stack8;
801    
802    static pcre_jit_stack *getstack8(void)
803    {
804            if (!stack8)
805                    stack8 = pcre_jit_stack_alloc(1, 1024 * 1024);
806            return stack8;
807    }
808    
809    static void setstack8(pcre_extra *extra)
810    {
811            if (!extra) {
812                    if (stack8)
813                            pcre_jit_stack_free(stack8);
814                    stack8 = NULL;
815                    return;
816            }
817    
818            pcre_assign_jit_stack(extra, callback8, getstack8());
819    }
820    #endif /* SUPPORT_PCRE8 */
821    
822    #ifdef SUPPORT_PCRE16
823    static pcre16_jit_stack *stack16;
824    
825    static pcre16_jit_stack *getstack16(void)
826    {
827            if (!stack16)
828                    stack16 = pcre16_jit_stack_alloc(1, 1024 * 1024);
829            return stack16;
830    }
831    
832    static void setstack16(pcre16_extra *extra)
833    {
834            if (!extra) {
835                    if (stack16)
836                            pcre16_jit_stack_free(stack16);
837                    stack16 = NULL;
838                    return;
839            }
840    
841            pcre16_assign_jit_stack(extra, callback16, getstack16());
842    }
843    #endif /* SUPPORT_PCRE8 */
844    
845    #ifdef SUPPORT_PCRE32
846    static pcre32_jit_stack *stack32;
847    
848    static pcre32_jit_stack *getstack32(void)
849    {
850            if (!stack32)
851                    stack32 = pcre32_jit_stack_alloc(1, 1024 * 1024);
852            return stack32;
853    }
854    
855    static void setstack32(pcre32_extra *extra)
856    {
857            if (!extra) {
858                    if (stack32)
859                            pcre32_jit_stack_free(stack32);
860                    stack32 = NULL;
861                    return;
862            }
863    
864            pcre32_assign_jit_stack(extra, callback32, getstack32());
865    }
866    #endif /* SUPPORT_PCRE8 */
867    
868    #ifdef SUPPORT_PCRE16
869    
870    static int convert_utf8_to_utf16(const char *input, PCRE_UCHAR16 *output, int *offsetmap, int max_length)
871    {
872            unsigned char *iptr = (unsigned char*)input;
873            PCRE_UCHAR16 *optr = output;
874            unsigned int c;
875    
876            if (max_length == 0)
877                    return 0;
878    
879            while (*iptr && max_length > 1) {
880                    c = 0;
881                    if (offsetmap)
882                            *offsetmap++ = (int)(iptr - (unsigned char*)input);
883    
884                    if (!(*iptr & 0x80))
885                            c = *iptr++;
886                    else if (!(*iptr & 0x20)) {
887                            c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
888                            iptr += 2;
889                    } else if (!(*iptr & 0x10)) {
890                            c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
891                            iptr += 3;
892                    } else if (!(*iptr & 0x08)) {
893                            c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
894                            iptr += 4;
895                    }
896    
897                    if (c < 65536) {
898                            *optr++ = c;
899                            max_length--;
900                    } else if (max_length <= 2) {
901                            *optr = '\0';
902                            return (int)(optr - output);
903                    } else {
904                            c -= 0x10000;
905                            *optr++ = 0xd800 | ((c >> 10) & 0x3ff);
906                            *optr++ = 0xdc00 | (c & 0x3ff);
907                            max_length -= 2;
908                            if (offsetmap)
909                                    offsetmap++;
910                    }
911            }
912            if (offsetmap)
913                    *offsetmap = (int)(iptr - (unsigned char*)input);
914            *optr = '\0';
915            return (int)(optr - output);
916    }
917    
918    static int copy_char8_to_char16(const char *input, PCRE_UCHAR16 *output, int max_length)
919    {
920            unsigned char *iptr = (unsigned char*)input;
921            PCRE_UCHAR16 *optr = output;
922    
923            if (max_length == 0)
924                    return 0;
925    
926            while (*iptr && max_length > 1) {
927                    *optr++ = *iptr++;
928                    max_length--;
929            }
930            *optr = '\0';
931            return (int)(optr - output);
932    }
933    
934    #define REGTEST_MAX_LENGTH16 4096
935    static PCRE_UCHAR16 regtest_buf16[REGTEST_MAX_LENGTH16];
936    static int regtest_offsetmap16[REGTEST_MAX_LENGTH16];
937    
938    #endif /* SUPPORT_PCRE16 */
939    
940    #ifdef SUPPORT_PCRE32
941    
942    static int convert_utf8_to_utf32(const char *input, PCRE_UCHAR32 *output, int *offsetmap, int max_length)
943    {
944            unsigned char *iptr = (unsigned char*)input;
945            PCRE_UCHAR32 *optr = output;
946            unsigned int c;
947    
948            if (max_length == 0)
949                    return 0;
950    
951            while (*iptr && max_length > 1) {
952                    c = 0;
953                    if (offsetmap)
954                            *offsetmap++ = (int)(iptr - (unsigned char*)input);
955    
956                    if (!(*iptr & 0x80))
957                            c = *iptr++;
958                    else if (!(*iptr & 0x20)) {
959                            c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
960                            iptr += 2;
961                    } else if (!(*iptr & 0x10)) {
962                            c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
963                            iptr += 3;
964                    } else if (!(*iptr & 0x08)) {
965                            c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
966                            iptr += 4;
967                    }
968    
969                    *optr++ = c;
970                    max_length--;
971            }
972            if (offsetmap)
973                    *offsetmap = (int)(iptr - (unsigned char*)input);
974            *optr = 0;
975            return (int)(optr - output);
976    }
977    
978    static int copy_char8_to_char32(const char *input, PCRE_UCHAR32 *output, int max_length)
979    {
980            unsigned char *iptr = (unsigned char*)input;
981            PCRE_UCHAR32 *optr = output;
982    
983            if (max_length == 0)
984                    return 0;
985    
986            while (*iptr && max_length > 1) {
987                    *optr++ = *iptr++;
988                    max_length--;
989            }
990            *optr = '\0';
991            return (int)(optr - output);
992    }
993    
994    #define REGTEST_MAX_LENGTH32 4096
995    static PCRE_UCHAR32 regtest_buf32[REGTEST_MAX_LENGTH32];
996    static int regtest_offsetmap32[REGTEST_MAX_LENGTH32];
997    
998    #endif /* SUPPORT_PCRE32 */
999    
1000    static int check_ascii(const char *input)
1001    {
1002            const unsigned char *ptr = (unsigned char *)input;
1003            while (*ptr) {
1004                    if (*ptr > 127)
1005                            return 0;
1006                    ptr++;
1007            }
1008            return 1;
1009    }
1010    
1011  static int regression_tests(void)  static int regression_tests(void)
1012  {  {
         pcre *re;  
1013          struct regression_test_case *current = regression_test_cases;          struct regression_test_case *current = regression_test_cases;
1014          const char *error;          const char *error;
1015          pcre_extra *extra;          char *cpu_info;
         int utf8 = 0, ucp = 0;  
         int ovector1[32];  
         int ovector2[32];  
         int return_value1, return_value2;  
1016          int i, err_offs;          int i, err_offs;
1017          int total = 0, succesful = 0;          int is_successful, is_ascii_pattern, is_ascii_input;
1018            int total = 0;
1019            int successful = 0;
1020            int successful_row = 0;
1021          int counter = 0;          int counter = 0;
1022          int disabled_flags = PCRE_BUG;          int study_mode;
1023            int utf = 0, ucp = 0;
1024            int disabled_flags = 0;
1025    #ifdef SUPPORT_PCRE8
1026            pcre *re8;
1027            pcre_extra *extra8;
1028            pcre_extra dummy_extra8;
1029            int ovector8_1[32];
1030            int ovector8_2[32];
1031            int return_value8[2];
1032            unsigned char *mark8_1, *mark8_2;
1033    #endif
1034    #ifdef SUPPORT_PCRE16
1035            pcre16 *re16;
1036            pcre16_extra *extra16;
1037            pcre16_extra dummy_extra16;
1038            int ovector16_1[32];
1039            int ovector16_2[32];
1040            int return_value16[2];
1041            PCRE_UCHAR16 *mark16_1, *mark16_2;
1042            int length16;
1043    #endif
1044    #ifdef SUPPORT_PCRE32
1045            pcre32 *re32;
1046            pcre32_extra *extra32;
1047            pcre32_extra dummy_extra32;
1048            int ovector32_1[32];
1049            int ovector32_2[32];
1050            int return_value32[2];
1051            PCRE_UCHAR32 *mark32_1, *mark32_2;
1052            int length32;
1053    #endif
1054    
1055          /* This test compares the behaviour of interpreter and JIT. Although disabling          /* This test compares the behaviour of interpreter and JIT. Although disabling
1056          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
1057          still considered successful from pcre_jit_test point of view. */          still considered successful from pcre_jit_test point of view. */
1058    
1059          pcre_config(PCRE_CONFIG_UTF8, &utf8);  #if defined SUPPORT_PCRE8
1060            pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1061    #elif defined SUPPORT_PCRE16
1062            pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1063    #elif defined SUPPORT_PCRE32
1064            pcre32_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1065    #endif
1066    
1067            printf("Running JIT regression tests\n");
1068            printf("  target CPU of SLJIT compiler: %s\n", cpu_info);
1069    
1070    #if defined SUPPORT_PCRE8
1071            pcre_config(PCRE_CONFIG_UTF8, &utf);
1072          pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);          pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1073          if (!utf8)  #elif defined SUPPORT_PCRE16
1074                  disabled_flags |= PCRE_UTF8;          pcre16_config(PCRE_CONFIG_UTF16, &utf);
1075            pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1076    #elif defined SUPPORT_PCRE16
1077            pcre32_config(PCRE_CONFIG_UTF32, &utf);
1078            pcre32_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1079    #endif
1080    
1081            if (!utf)
1082                    disabled_flags |= PCRE_UTF8 | PCRE_UTF16 | PCRE_UTF32;
1083          if (!ucp)          if (!ucp)
1084                  disabled_flags |= PCRE_UCP;                  disabled_flags |= PCRE_UCP;
1085    #ifdef SUPPORT_PCRE8
1086            printf("  in  8 bit mode with UTF-8  %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
1087    #endif
1088    #ifdef SUPPORT_PCRE16
1089            printf("  in 16 bit mode with UTF-16 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
1090    #endif
1091    #ifdef SUPPORT_PCRE32
1092            printf("  in 32 bit mode with UTF-32 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
1093    #endif
1094    
         printf("Running JIT regression tests with utf8 %s and ucp %s:\n", utf8 ? "enabled" : "disabled", ucp ? "enabled" : "disabled");  
1095          while (current->pattern) {          while (current->pattern) {
1096                  /* printf("\nPattern: %s :\n", current->pattern); */                  /* printf("\nPattern: %s :\n", current->pattern); */
1097                  total++;                  total++;
1098                    if (current->start_offset & F_PROPERTY) {
1099                            is_ascii_pattern = 0;
1100                            is_ascii_input = 0;
1101                    } else {
1102                            is_ascii_pattern = check_ascii(current->pattern);
1103                            is_ascii_input = check_ascii(current->input);
1104                    }
1105    
1106                    if (current->flags & PCRE_PARTIAL_SOFT)
1107                            study_mode = PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE;
1108                    else if (current->flags & PCRE_PARTIAL_HARD)
1109                            study_mode = PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE;
1110                    else
1111                            study_mode = PCRE_STUDY_JIT_COMPILE;
1112                  error = NULL;                  error = NULL;
1113                  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
1114                    re8 = NULL;
1115                  if (!re) {                  if (!(current->start_offset & F_NO8))
1116                          if (utf8 && ucp)                          re8 = pcre_compile(current->pattern,
1117                                  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),
1118                          else {                                  &error, &err_offs, tables(0));
1119                                  /* Some patterns cannot be compiled when either of utf8  
1120                                  or ucp is disabled. We just skip them. */                  extra8 = NULL;
1121                                  printf(".");                  if (re8) {
1122                                  succesful++;                          error = NULL;
1123                            extra8 = pcre_study(re8, study_mode, &error);
1124                            if (!extra8) {
1125                                    printf("\n8 bit: Cannot study pattern: %s\n", current->pattern);
1126                                    pcre_free(re8);
1127                                    re8 = NULL;
1128                          }                          }
1129                          current++;                          else if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1130                          continue;                                  printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);
1131                  }                                  pcre_free_study(extra8);
1132                                    pcre_free(re8);
1133                                    re8 = NULL;
1134                            }
1135                            extra8->flags |= PCRE_EXTRA_MARK;
1136                    } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO8))
1137                            printf("\n8 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1138    #endif
1139    #ifdef SUPPORT_PCRE16
1140                    if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1141                            convert_utf8_to_utf16(current->pattern, regtest_buf16, NULL, REGTEST_MAX_LENGTH16);
1142                    else
1143                            copy_char8_to_char16(current->pattern, regtest_buf16, REGTEST_MAX_LENGTH16);
1144    
1145                    re16 = NULL;
1146                    if (!(current->start_offset & F_NO16))
1147                            re16 = pcre16_compile(regtest_buf16,
1148                                    current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1149                                    &error, &err_offs, tables(0));
1150    
1151                    extra16 = NULL;
1152                    if (re16) {
1153                            error = NULL;
1154                            extra16 = pcre16_study(re16, study_mode, &error);
1155                            if (!extra16) {
1156                                    printf("\n16 bit: Cannot study pattern: %s\n", current->pattern);
1157                                    pcre16_free(re16);
1158                                    re16 = NULL;
1159                            }
1160                            else if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1161                                    printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);
1162                                    pcre16_free_study(extra16);
1163                                    pcre16_free(re16);
1164                                    re16 = NULL;
1165                            }
1166                            extra16->flags |= PCRE_EXTRA_MARK;
1167                    } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO16))
1168                            printf("\n16 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1169    #endif
1170    #ifdef SUPPORT_PCRE32
1171                    if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1172                            convert_utf8_to_utf32(current->pattern, regtest_buf32, NULL, REGTEST_MAX_LENGTH32);
1173                    else
1174                            copy_char8_to_char32(current->pattern, regtest_buf32, REGTEST_MAX_LENGTH32);
1175    
1176                    re32 = NULL;
1177                    if (!(current->start_offset & F_NO32))
1178                            re32 = pcre32_compile(regtest_buf32,
1179                                    current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1180                                    &error, &err_offs, tables(0));
1181    
1182                    extra32 = NULL;
1183                    if (re32) {
1184                            error = NULL;
1185                            extra32 = pcre32_study(re32, study_mode, &error);
1186                            if (!extra32) {
1187                                    printf("\n32 bit: Cannot study pattern: %s\n", current->pattern);
1188                                    pcre32_free(re32);
1189                                    re32 = NULL;
1190                            }
1191                            if (!(extra32->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1192                                    printf("\n32 bit: JIT compiler does not support: %s\n", current->pattern);
1193                                    pcre32_free_study(extra32);
1194                                    pcre32_free(re32);
1195                                    re32 = NULL;
1196                            }
1197                            extra32->flags |= PCRE_EXTRA_MARK;
1198                    } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO32))
1199                            printf("\n32 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1200    #endif
1201    
1202                  error = NULL;                  counter++;
1203                  extra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &error);                  if ((counter & 0x3) != 0) {
1204                  if (!extra) {  #ifdef SUPPORT_PCRE8
1205                          printf("\nCannot study pattern: %s\n", current->pattern);                          setstack8(NULL);
1206                          current++;  #endif
1207                          continue;  #ifdef SUPPORT_PCRE16
1208                            setstack16(NULL);
1209    #endif
1210    #ifdef SUPPORT_PCRE32
1211                            setstack32(NULL);
1212    #endif
1213                  }                  }
1214    
1215                  if (!(extra->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {  #ifdef SUPPORT_PCRE8
1216                          printf("\nJIT compiler does not support: %s\n", current->pattern);                  return_value8[0] = -1000;
1217                          current++;                  return_value8[1] = -1000;
1218                          continue;                  for (i = 0; i < 32; ++i)
1219                            ovector8_1[i] = -2;
1220                    for (i = 0; i < 32; ++i)
1221                            ovector8_2[i] = -2;
1222                    if (re8) {
1223                            mark8_1 = NULL;
1224                            mark8_2 = NULL;
1225                            extra8->mark = &mark8_1;
1226    
1227                            if ((counter & 0x1) != 0) {
1228                                    setstack8(extra8);
1229                                    return_value8[0] = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1230                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32);
1231                            } else
1232                                    return_value8[0] = pcre_jit_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1233                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32, getstack8());
1234                            memset(&dummy_extra8, 0, sizeof(pcre_extra));
1235                            dummy_extra8.flags = PCRE_EXTRA_MARK;
1236                            if (current->start_offset & F_STUDY) {
1237                                    dummy_extra8.flags |= PCRE_EXTRA_STUDY_DATA;
1238                                    dummy_extra8.study_data = extra8->study_data;
1239                            }
1240                            dummy_extra8.mark = &mark8_2;
1241                            return_value8[1] = pcre_exec(re8, &dummy_extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1242                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_2, 32);
1243                  }                  }
1244    #endif
1245    
1246                  counter++;  #ifdef SUPPORT_PCRE16
1247                  if ((counter & 0x3) != 0)                  return_value16[0] = -1000;
1248                          setstack(extra);                  return_value16[1] = -1000;
1249                    for (i = 0; i < 32; ++i)
1250                            ovector16_1[i] = -2;
1251                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1252                          ovector1[i] = -2;                          ovector16_2[i] = -2;
1253                  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) {
1254                            mark16_1 = NULL;
1255                            mark16_2 = NULL;
1256                            if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1257                                    length16 = convert_utf8_to_utf16(current->input, regtest_buf16, regtest_offsetmap16, REGTEST_MAX_LENGTH16);
1258                            else
1259                                    length16 = copy_char8_to_char16(current->input, regtest_buf16, REGTEST_MAX_LENGTH16);
1260                            extra16->mark = &mark16_1;
1261                            if ((counter & 0x1) != 0) {
1262                                    setstack16(extra16);
1263                                    return_value16[0] = pcre16_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1264                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32);
1265                            } else
1266                                    return_value16[0] = pcre16_jit_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1267                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32, getstack16());
1268                            memset(&dummy_extra16, 0, sizeof(pcre16_extra));
1269                            dummy_extra16.flags = PCRE_EXTRA_MARK;
1270                            if (current->start_offset & F_STUDY) {
1271                                    dummy_extra16.flags |= PCRE_EXTRA_STUDY_DATA;
1272                                    dummy_extra16.study_data = extra16->study_data;
1273                            }
1274                            dummy_extra16.mark = &mark16_2;
1275                            return_value16[1] = pcre16_exec(re16, &dummy_extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1276                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_2, 32);
1277                    }
1278    #endif
1279    
1280    #ifdef SUPPORT_PCRE32
1281                    return_value32[0] = -1000;
1282                    return_value32[1] = -1000;
1283                    for (i = 0; i < 32; ++i)
1284                            ovector32_1[i] = -2;
1285                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1286                          ovector2[i] = -2;                          ovector32_2[i] = -2;
1287                  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) {
1288                            mark32_1 = NULL;
1289                            mark32_2 = NULL;
1290                            if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1291                                    length32 = convert_utf8_to_utf32(current->input, regtest_buf32, regtest_offsetmap32, REGTEST_MAX_LENGTH32);
1292                            else
1293                                    length32 = copy_char8_to_char32(current->input, regtest_buf32, REGTEST_MAX_LENGTH32);
1294                            extra32->mark = &mark32_1;
1295                            if ((counter & 0x1) != 0) {
1296                                    setstack32(extra32);
1297                                    return_value32[0] = pcre32_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1298                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32);
1299                            } else
1300                                    return_value32[0] = pcre32_jit_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1301                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32, getstack32());
1302                            memset(&dummy_extra32, 0, sizeof(pcre32_extra));
1303                            dummy_extra32.flags = PCRE_EXTRA_MARK;
1304                            if (current->start_offset & F_STUDY) {
1305                                    dummy_extra32.flags |= PCRE_EXTRA_STUDY_DATA;
1306                                    dummy_extra32.study_data = extra32->study_data;
1307                            }
1308                            dummy_extra32.mark = &mark32_2;
1309                            return_value32[1] = pcre32_exec(re32, &dummy_extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1310                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_2, 32);
1311                    }
1312    #endif
1313    
1314                    /* printf("[%d-%d-%d|%d-%d|%d-%d|%d-%d]%s",
1315                            return_value8[0], return_value16[0],
1316                            ovector8_1[0], ovector8_1[1],
1317                            ovector16_1[0], ovector16_1[1],
1318                            ovector32_1[0], ovector32_1[1],
1319                            (current->flags & PCRE_CASELESS) ? "C" : ""); */
1320    
1321                  /* 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.
1322                  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;  
                         }  
1323    
1324                          if (return_value1 >= 0) {                  is_successful = 1;
1325                                  return_value1 *= 2;                  if (!(current->start_offset & F_DIFF)) {
1326                                  err_offs = 0;  #if defined SUPPORT_UTF && ((defined(SUPPORT_PCRE8) + defined(SUPPORT_PCRE16) + defined(SUPPORT_PCRE32)) >= 2)
1327                                  for (i = 0; i < return_value1; ++i)                          if (!(current->start_offset & F_FORCECONV)) {
1328                                          if (ovector1[i] != ovector2[i]) {                                  int return_value;
1329                                                  printf("\nOvector[%d] value differs(%d:%d): '%s' @ '%s' \n", i, ovector1[i], ovector2[i], current->pattern, current->input);  
1330                                                  err_offs = 1;                                  /* All results must be the same. */
1331    #ifdef SUPPORT_PCRE8
1332                                    if ((return_value = return_value8[0]) != return_value8[1]) {
1333                                            printf("\n8 bit: Return value differs(J8:%d,I8:%d): [%d] '%s' @ '%s'\n",
1334                                                    return_value8[0], return_value8[1], total, current->pattern, current->input);
1335                                            is_successful = 0;
1336                                    } else
1337    #endif
1338    #ifdef SUPPORT_PCRE16
1339                                    if ((return_value = return_value16[0]) != return_value16[1]) {
1340                                            printf("\n16 bit: Return value differs(J16:%d,I16:%d): [%d] '%s' @ '%s'\n",
1341                                                    return_value16[0], return_value16[1], total, current->pattern, current->input);
1342                                            is_successful = 0;
1343                                    } else
1344    #endif
1345    #ifdef SUPPORT_PCRE32
1346                                    if ((return_value = return_value32[0]) != return_value32[1]) {
1347                                            printf("\n32 bit: Return value differs(J32:%d,I32:%d): [%d] '%s' @ '%s'\n",
1348                                                    return_value32[0], return_value32[1], total, current->pattern, current->input);
1349                                            is_successful = 0;
1350                                    } else
1351    #endif
1352    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1353                                    if (return_value8[0] != return_value16[0]) {
1354                                            printf("\n8 and 16 bit: Return value differs(J8:%d,J16:%d): [%d] '%s' @ '%s'\n",
1355                                                    return_value8[0], return_value16[0],
1356                                                    total, current->pattern, current->input);
1357                                            is_successful = 0;
1358                                    } else
1359    #endif
1360    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1361                                    if (return_value8[0] != return_value32[0]) {
1362                                            printf("\n8 and 32 bit: Return value differs(J8:%d,J32:%d): [%d] '%s' @ '%s'\n",
1363                                                    return_value8[0], return_value32[0],
1364                                                    total, current->pattern, current->input);
1365                                            is_successful = 0;
1366                                    } else
1367    #endif
1368    #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE32
1369                                    if (return_value16[0] != return_value32[0]) {
1370                                            printf("\n16 and 32 bit: Return value differs(J16:%d,J32:%d): [%d] '%s' @ '%s'\n",
1371                                                    return_value16[0], return_value32[0],
1372                                                    total, current->pattern, current->input);
1373                                            is_successful = 0;
1374                                    } else
1375    #endif
1376                                    if (return_value >= 0 || return_value == PCRE_ERROR_PARTIAL) {
1377                                            if (return_value == PCRE_ERROR_PARTIAL) {
1378                                                    return_value = 2;
1379                                            } else {
1380                                                    return_value *= 2;
1381                                            }
1382    #ifdef SUPPORT_PCRE8
1383                                            return_value8[0] = return_value;
1384    #endif
1385    #ifdef SUPPORT_PCRE16
1386                                            return_value16[0] = return_value;
1387    #endif
1388    #ifdef SUPPORT_PCRE32
1389                                            return_value32[0] = return_value;
1390    #endif
1391                                            /* Transform back the results. */
1392                                            if (current->flags & PCRE_UTF8) {
1393    #ifdef SUPPORT_PCRE16
1394                                                    for (i = 0; i < return_value; ++i) {
1395                                                            if (ovector16_1[i] >= 0)
1396                                                                    ovector16_1[i] = regtest_offsetmap16[ovector16_1[i]];
1397                                                            if (ovector16_2[i] >= 0)
1398                                                                    ovector16_2[i] = regtest_offsetmap16[ovector16_2[i]];
1399                                                    }
1400    #endif
1401    #ifdef SUPPORT_PCRE32
1402                                                    for (i = 0; i < return_value; ++i) {
1403                                                            if (ovector32_1[i] >= 0)
1404                                                                    ovector32_1[i] = regtest_offsetmap32[ovector32_1[i]];
1405                                                            if (ovector32_2[i] >= 0)
1406                                                                    ovector32_2[i] = regtest_offsetmap32[ovector32_2[i]];
1407                                                    }
1408    #endif
1409                                            }
1410    
1411                                            for (i = 0; i < return_value; ++i) {
1412    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1413                                                    if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector16_1[i] || ovector8_1[i] != ovector16_2[i]) {
1414                                                            printf("\n8 and 16 bit: Ovector[%d] value differs(J8:%d,I8:%d,J16:%d,I16:%d): [%d] '%s' @ '%s' \n",
1415                                                                    i, ovector8_1[i], ovector8_2[i], ovector16_1[i], ovector16_2[i],
1416                                                                    total, current->pattern, current->input);
1417                                                            is_successful = 0;
1418                                                    }
1419    #endif
1420    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1421                                                    if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector32_1[i] || ovector8_1[i] != ovector32_2[i]) {
1422                                                            printf("\n8 and 32 bit: Ovector[%d] value differs(J8:%d,I8:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1423                                                                    i, ovector8_1[i], ovector8_2[i], ovector32_1[i], ovector32_2[i],
1424                                                                    total, current->pattern, current->input);
1425                                                            is_successful = 0;
1426                                                    }
1427    #endif
1428    #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE16
1429                                                    if (ovector16_1[i] != ovector16_2[i] || ovector16_1[i] != ovector16_1[i] || ovector16_1[i] != ovector16_2[i]) {
1430                                                            printf("\n16 and 16 bit: Ovector[%d] value differs(J16:%d,I16:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1431                                                                    i, ovector16_1[i], ovector16_2[i], ovector16_1[i], ovector16_2[i],
1432                                                                    total, current->pattern, current->input);
1433                                                            is_successful = 0;
1434                                                    }
1435    #endif
1436                                          }                                          }
                                 if (err_offs) {  
                                         current++;  
                                         continue;  
1437                                  }                                  }
1438                            } else
1439    #endif /* more than one of SUPPORT_PCRE8, SUPPORT_PCRE16 and SUPPORT_PCRE32 */
1440                            {
1441                                    /* Only the 8 bit and 16 bit results must be equal. */
1442    #ifdef SUPPORT_PCRE8
1443                                    if (return_value8[0] != return_value8[1]) {
1444                                            printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1445                                                    return_value8[0], return_value8[1], total, current->pattern, current->input);
1446                                            is_successful = 0;
1447                                    } else if (return_value8[0] >= 0 || return_value8[0] == PCRE_ERROR_PARTIAL) {
1448                                            if (return_value8[0] == PCRE_ERROR_PARTIAL)
1449                                                    return_value8[0] = 2;
1450                                            else
1451                                                    return_value8[0] *= 2;
1452    
1453                                            for (i = 0; i < return_value8[0]; ++i)
1454                                                    if (ovector8_1[i] != ovector8_2[i]) {
1455                                                            printf("\n8 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1456                                                                    i, ovector8_1[i], ovector8_2[i], total, current->pattern, current->input);
1457                                                            is_successful = 0;
1458                                                    }
1459                                    }
1460    #endif
1461    
1462    #ifdef SUPPORT_PCRE16
1463                                    if (return_value16[0] != return_value16[1]) {
1464                                            printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1465                                                    return_value16[0], return_value16[1], total, current->pattern, current->input);
1466                                            is_successful = 0;
1467                                    } else if (return_value16[0] >= 0 || return_value16[0] == PCRE_ERROR_PARTIAL) {
1468                                            if (return_value16[0] == PCRE_ERROR_PARTIAL)
1469                                                    return_value16[0] = 2;
1470                                            else
1471                                                    return_value16[0] *= 2;
1472    
1473                                            for (i = 0; i < return_value16[0]; ++i)
1474                                                    if (ovector16_1[i] != ovector16_2[i]) {
1475                                                            printf("\n16 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1476                                                                    i, ovector16_1[i], ovector16_2[i], total, current->pattern, current->input);
1477                                                            is_successful = 0;
1478                                                    }
1479                                    }
1480    #endif
1481    
1482    #ifdef SUPPORT_PCRE32
1483                                    if (return_value32[0] != return_value32[1]) {
1484                                            printf("\n32 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1485                                                    return_value32[0], return_value32[1], total, current->pattern, current->input);
1486                                            is_successful = 0;
1487                                    } else if (return_value32[0] >= 0 || return_value32[0] == PCRE_ERROR_PARTIAL) {
1488                                            if (return_value32[0] == PCRE_ERROR_PARTIAL)
1489                                                    return_value32[0] = 2;
1490                                            else
1491                                                    return_value32[0] *= 2;
1492    
1493                                            for (i = 0; i < return_value32[0]; ++i)
1494                                                    if (ovector32_1[i] != ovector32_2[i]) {
1495                                                            printf("\n32 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1496                                                                    i, ovector32_1[i], ovector32_2[i], total, current->pattern, current->input);
1497                                                            is_successful = 0;
1498                                                    }
1499                                    }
1500    #endif
1501                          }                          }
1502                  }                  }
1503    
1504                  pcre_free_study(extra);                  if (is_successful) {
1505                  pcre_free(re);  #ifdef SUPPORT_PCRE8
1506                            if (!(current->start_offset & F_NO8) && ((utf && ucp) || is_ascii_input)) {
1507                                    if (return_value8[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1508                                            printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",
1509                                                    total, current->pattern, current->input);
1510                                            is_successful = 0;
1511                                    }
1512    
1513                                    if (return_value8[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1514                                            printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",
1515                                                    total, current->pattern, current->input);
1516                                            is_successful = 0;
1517                                    }
1518                            }
1519    #endif
1520    #ifdef SUPPORT_PCRE16
1521                            if (!(current->start_offset & F_NO16) && ((utf && ucp) || is_ascii_input)) {
1522                                    if (return_value16[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1523                                            printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",
1524                                                    total, current->pattern, current->input);
1525                                            is_successful = 0;
1526                                    }
1527    
1528                                    if (return_value16[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1529                                            printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",
1530                                                    total, current->pattern, current->input);
1531                                            is_successful = 0;
1532                                    }
1533                            }
1534    #endif
1535    #ifdef SUPPORT_PCRE32
1536                            if (!(current->start_offset & F_NO32) && ((utf && ucp) || is_ascii_input)) {
1537                                    if (return_value32[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1538                                            printf("32 bit: Test should match: [%d] '%s' @ '%s'\n",
1539                                                    total, current->pattern, current->input);
1540                                            is_successful = 0;
1541                                    }
1542    
1543                                    if (return_value32[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1544                                            printf("32 bit: Test should not match: [%d] '%s' @ '%s'\n",
1545                                                    total, current->pattern, current->input);
1546                                            is_successful = 0;
1547                                    }
1548                            }
1549    #endif
1550                    }
1551    
1552                    if (is_successful) {
1553    #ifdef SUPPORT_PCRE8
1554                            if (mark8_1 != mark8_2) {
1555                                    printf("8 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1556                                            total, current->pattern, current->input);
1557                                    is_successful = 0;
1558                            }
1559    #endif
1560    #ifdef SUPPORT_PCRE16
1561                            if (mark16_1 != mark16_2) {
1562                                    printf("16 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1563                                            total, current->pattern, current->input);
1564                                    is_successful = 0;
1565                            }
1566    #endif
1567    #ifdef SUPPORT_PCRE32
1568                            if (mark32_1 != mark32_2) {
1569                                    printf("32 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1570                                            total, current->pattern, current->input);
1571                                    is_successful = 0;
1572                            }
1573    #endif
1574                    }
1575    
1576    #ifdef SUPPORT_PCRE8
1577                    if (re8) {
1578                            pcre_free_study(extra8);
1579                            pcre_free(re8);
1580                    }
1581    #endif
1582    #ifdef SUPPORT_PCRE16
1583                    if (re16) {
1584                            pcre16_free_study(extra16);
1585                            pcre16_free(re16);
1586                    }
1587    #endif
1588    #ifdef SUPPORT_PCRE32
1589                    if (re32) {
1590                            pcre32_free_study(extra32);
1591                            pcre32_free(re32);
1592                    }
1593    #endif
1594    
1595                    if (is_successful) {
1596                            successful++;
1597                            successful_row++;
1598                            printf(".");
1599                            if (successful_row >= 60) {
1600                                    successful_row = 0;
1601                                    printf("\n");
1602                            }
1603                    } else
1604                            successful_row = 0;
1605    
                 /* printf("[%d-%d]%s", ovector1[0], ovector1[1], (current->flags & PCRE_CASELESS) ? "C" : ""); */  
                 printf(".");  
1606                  fflush(stdout);                  fflush(stdout);
1607                  current++;                  current++;
                 succesful++;  
1608          }          }
1609            tables(1);
1610    #ifdef SUPPORT_PCRE8
1611            setstack8(NULL);
1612    #endif
1613    #ifdef SUPPORT_PCRE16
1614            setstack16(NULL);
1615    #endif
1616    #ifdef SUPPORT_PCRE32
1617            setstack32(NULL);
1618    #endif
1619    
1620          if (total == succesful) {          if (total == successful) {
1621                  printf("\nAll JIT regression tests are successfully passed.\n");                  printf("\nAll JIT regression tests are successfully passed.\n");
1622                  return 0;                  return 0;
1623          } else {          } else {
1624                  printf("\nSuccessful test ratio: %d%%\n", succesful * 100 / total);                  printf("\nSuccessful test ratio: %d%% (%d failed)\n", successful * 100 / total, total - successful);
1625                  return 1;                  return 1;
1626          }          }
1627  }  }

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

  ViewVC Help
Powered by ViewVC 1.1.5