/[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 698 by ph10, Mon Sep 19 15:43:02 2011 UTC revision 1276 by zherczeg, Sun Mar 10 17:35:23 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 135  static struct regression_test_case regre Line 164  static struct regression_test_case regre
164          { PCRE_CASELESS, 0, "\xff#a", "\xff#\xff\xfe##\xff#A" },          { PCRE_CASELESS, 0, "\xff#a", "\xff#\xff\xfe##\xff#A" },
165          { PCRE_CASELESS, 0, "\xfe", "\xff\xfc#\xfe\xfe" },          { PCRE_CASELESS, 0, "\xfe", "\xff\xfc#\xfe\xfe" },
166          { PCRE_CASELESS, 0, "a1", "Aa1" },          { PCRE_CASELESS, 0, "a1", "Aa1" },
167            { MA, 0, "\\Ca", "cda" },
168            { CMA, 0, "\\Ca", "CDA" },
169            { MA, 0 | F_NOMATCH, "\\Cx", "cda" },
170            { 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 146  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 186  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 263  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 274  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 308  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 323  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 331  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 339  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 375  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 416  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 440  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 460  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 473  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 502  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 516  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 565  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            { MUA, 0, "(?=(a)(*COMMIT)b)|ac", "ac" },
700            { MUA, 0, "(?=(a)+(*COMMIT)b)|ac", "ac" },
701            { MUA, 0 | F_NOMATCH, "(a(*COMMIT)b)++", "abac" },
702            { MUA, 0 | F_NOMATCH, "((a)(*COMMIT)b)++", "abac" },
703    
704            /* (*PRUNE) verb. */
705            { MUA, 0, "aa\\K(*PRUNE)b", "aaab" },
706            { MUA, 0, "aa(*PRUNE:bb)b|a", "aa" },
707            { MUA, 0, "(a)(a)(*PRUNE)b|(a)", "aa" },
708            { MUA, 0, "(a)(a)(a)(a)(a)(a)(a)(a)(*PRUNE)b|(a)", "aaaaaaaa" },
709            { MUA | PCRE_PARTIAL_SOFT, 0, "a(*PRUNE)a|", "a" },
710            { MUA | PCRE_PARTIAL_SOFT, 0, "a(*PRUNE)a|m", "a" },
711            { MUA, 0 | F_NOMATCH, "a(*COMMIT)(*PRUNE)d|bc", "abc" },
712            { MUA, 0, "(?=a(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
713            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?=a(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
714            { MUA, 0, "(?=(a)(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
715            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?=(a)(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
716            { MUA, 0, "(a(*COMMIT)b){0}a(?1)(*PRUNE)c|bc", "abc" },
717            { MUA, 0 | F_NOMATCH, "(a(*COMMIT)b){0}a(*COMMIT)(?1)(*PRUNE)c|bc", "abc" },
718            { MUA, 0, "(a(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
719            { MUA, 0 | F_NOMATCH, "(*COMMIT)(a(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
720            { MUA, 0, "((a)(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
721            { MUA, 0 | F_NOMATCH, "(*COMMIT)((a)(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
722    
723          /* Deep recursion. */          /* Deep recursion. */
724          { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },          { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },
725          { MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " },          { MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " },
726          { MUA, 0, "((a?)+)+b", "aaaaaaaaaaaaa b" },          { MUA, 0, "((a?)+)+b", "aaaaaaaaaaaa b" },
727    
728          /* Deep recursion: Stack limit reached. */          /* Deep recursion: Stack limit reached. */
729          { 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" },
730          { MA, 0, "(?:a+)+b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },          { MA, 0 | F_NOMATCH, "(?:a+)+b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
731          { MA, 0, "(?:a+?)+?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },          { MA, 0 | F_NOMATCH, "(?:a+?)+?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
732          { MA, 0, "(?:a*)*b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },          { MA, 0 | F_NOMATCH, "(?:a*)*b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
733          { MA, 0, "(?:a*?)*?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },          { MA, 0 | F_NOMATCH, "(?:a*?)*?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
734    
735          { 0, 0, NULL, NULL }          { 0, 0, NULL, NULL }
736  };  };
737    
738    static const unsigned char *tables(int mode)
739    {
740            /* The purpose of this function to allow valgrind
741            for reporting invalid reads and writes. */
742            static unsigned char *tables_copy;
743            const char *errorptr;
744            int erroroffset;
745            unsigned char *default_tables;
746    #if defined SUPPORT_PCRE8
747            pcre *regex;
748            char null_str[1] = { 0 };
749    #elif defined SUPPORT_PCRE16
750            pcre16 *regex;
751            PCRE_UCHAR16 null_str[1] = { 0 };
752    #elif defined SUPPORT_PCRE32
753            pcre32 *regex;
754            PCRE_UCHAR32 null_str[1] = { 0 };
755    #endif
756    
757            if (mode) {
758                    if (tables_copy)
759                            free(tables_copy);
760                    tables_copy = NULL;
761                    return NULL;
762            }
763    
764            if (tables_copy)
765                    return tables_copy;
766    
767            default_tables = NULL;
768    #if defined SUPPORT_PCRE8
769            regex = pcre_compile(null_str, 0, &errorptr, &erroroffset, NULL);
770            if (regex) {
771                    pcre_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
772                    pcre_free(regex);
773            }
774    #elif defined SUPPORT_PCRE16
775            regex = pcre16_compile(null_str, 0, &errorptr, &erroroffset, NULL);
776            if (regex) {
777                    pcre16_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
778                    pcre16_free(regex);
779            }
780    #elif defined SUPPORT_PCRE32
781            regex = pcre32_compile(null_str, 0, &errorptr, &erroroffset, NULL);
782            if (regex) {
783                    pcre32_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
784                    pcre32_free(regex);
785            }
786    #endif
787            /* Shouldn't ever happen. */
788            if (!default_tables)
789                    return NULL;
790    
791            /* Unfortunately this value cannot get from pcre_fullinfo.
792            Since this is a test program, this is acceptable at the moment. */
793            tables_copy = (unsigned char *)malloc(1088);
794            if (!tables_copy)
795                    return NULL;
796    
797            memcpy(tables_copy, default_tables, 1088);
798            return tables_copy;
799    }
800    
801    #ifdef SUPPORT_PCRE8
802    static pcre_jit_stack* callback8(void *arg)
803    {
804            return (pcre_jit_stack *)arg;
805    }
806    #endif
807    
808    #ifdef SUPPORT_PCRE16
809    static pcre16_jit_stack* callback16(void *arg)
810    {
811            return (pcre16_jit_stack *)arg;
812    }
813    #endif
814    
815    #ifdef SUPPORT_PCRE32
816    static pcre32_jit_stack* callback32(void *arg)
817    {
818            return (pcre32_jit_stack *)arg;
819    }
820    #endif
821    
822    #ifdef SUPPORT_PCRE8
823    static pcre_jit_stack *stack8;
824    
825    static pcre_jit_stack *getstack8(void)
826    {
827            if (!stack8)
828                    stack8 = pcre_jit_stack_alloc(1, 1024 * 1024);
829            return stack8;
830    }
831    
832    static void setstack8(pcre_extra *extra)
833    {
834            if (!extra) {
835                    if (stack8)
836                            pcre_jit_stack_free(stack8);
837                    stack8 = NULL;
838                    return;
839            }
840    
841            pcre_assign_jit_stack(extra, callback8, getstack8());
842    }
843    #endif /* SUPPORT_PCRE8 */
844    
845    #ifdef SUPPORT_PCRE16
846    static pcre16_jit_stack *stack16;
847    
848    static pcre16_jit_stack *getstack16(void)
849    {
850            if (!stack16)
851                    stack16 = pcre16_jit_stack_alloc(1, 1024 * 1024);
852            return stack16;
853    }
854    
855    static void setstack16(pcre16_extra *extra)
856    {
857            if (!extra) {
858                    if (stack16)
859                            pcre16_jit_stack_free(stack16);
860                    stack16 = NULL;
861                    return;
862            }
863    
864            pcre16_assign_jit_stack(extra, callback16, getstack16());
865    }
866    #endif /* SUPPORT_PCRE8 */
867    
868    #ifdef SUPPORT_PCRE32
869    static pcre32_jit_stack *stack32;
870    
871    static pcre32_jit_stack *getstack32(void)
872    {
873            if (!stack32)
874                    stack32 = pcre32_jit_stack_alloc(1, 1024 * 1024);
875            return stack32;
876    }
877    
878    static void setstack32(pcre32_extra *extra)
879    {
880            if (!extra) {
881                    if (stack32)
882                            pcre32_jit_stack_free(stack32);
883                    stack32 = NULL;
884                    return;
885            }
886    
887            pcre32_assign_jit_stack(extra, callback32, getstack32());
888    }
889    #endif /* SUPPORT_PCRE8 */
890    
891    #ifdef SUPPORT_PCRE16
892    
893    static int convert_utf8_to_utf16(const char *input, PCRE_UCHAR16 *output, int *offsetmap, int max_length)
894    {
895            unsigned char *iptr = (unsigned char*)input;
896            PCRE_UCHAR16 *optr = output;
897            unsigned int c;
898    
899            if (max_length == 0)
900                    return 0;
901    
902            while (*iptr && max_length > 1) {
903                    c = 0;
904                    if (offsetmap)
905                            *offsetmap++ = (int)(iptr - (unsigned char*)input);
906    
907                    if (!(*iptr & 0x80))
908                            c = *iptr++;
909                    else if (!(*iptr & 0x20)) {
910                            c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
911                            iptr += 2;
912                    } else if (!(*iptr & 0x10)) {
913                            c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
914                            iptr += 3;
915                    } else if (!(*iptr & 0x08)) {
916                            c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
917                            iptr += 4;
918                    }
919    
920                    if (c < 65536) {
921                            *optr++ = c;
922                            max_length--;
923                    } else if (max_length <= 2) {
924                            *optr = '\0';
925                            return (int)(optr - output);
926                    } else {
927                            c -= 0x10000;
928                            *optr++ = 0xd800 | ((c >> 10) & 0x3ff);
929                            *optr++ = 0xdc00 | (c & 0x3ff);
930                            max_length -= 2;
931                            if (offsetmap)
932                                    offsetmap++;
933                    }
934            }
935            if (offsetmap)
936                    *offsetmap = (int)(iptr - (unsigned char*)input);
937            *optr = '\0';
938            return (int)(optr - output);
939    }
940    
941    static int copy_char8_to_char16(const char *input, PCRE_UCHAR16 *output, int max_length)
942    {
943            unsigned char *iptr = (unsigned char*)input;
944            PCRE_UCHAR16 *optr = output;
945    
946            if (max_length == 0)
947                    return 0;
948    
949            while (*iptr && max_length > 1) {
950                    *optr++ = *iptr++;
951                    max_length--;
952            }
953            *optr = '\0';
954            return (int)(optr - output);
955    }
956    
957    #define REGTEST_MAX_LENGTH16 4096
958    static PCRE_UCHAR16 regtest_buf16[REGTEST_MAX_LENGTH16];
959    static int regtest_offsetmap16[REGTEST_MAX_LENGTH16];
960    
961    #endif /* SUPPORT_PCRE16 */
962    
963    #ifdef SUPPORT_PCRE32
964    
965    static int convert_utf8_to_utf32(const char *input, PCRE_UCHAR32 *output, int *offsetmap, int max_length)
966    {
967            unsigned char *iptr = (unsigned char*)input;
968            PCRE_UCHAR32 *optr = output;
969            unsigned int c;
970    
971            if (max_length == 0)
972                    return 0;
973    
974            while (*iptr && max_length > 1) {
975                    c = 0;
976                    if (offsetmap)
977                            *offsetmap++ = (int)(iptr - (unsigned char*)input);
978    
979                    if (!(*iptr & 0x80))
980                            c = *iptr++;
981                    else if (!(*iptr & 0x20)) {
982                            c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
983                            iptr += 2;
984                    } else if (!(*iptr & 0x10)) {
985                            c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
986                            iptr += 3;
987                    } else if (!(*iptr & 0x08)) {
988                            c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
989                            iptr += 4;
990                    }
991    
992                    *optr++ = c;
993                    max_length--;
994            }
995            if (offsetmap)
996                    *offsetmap = (int)(iptr - (unsigned char*)input);
997            *optr = 0;
998            return (int)(optr - output);
999    }
1000    
1001    static int copy_char8_to_char32(const char *input, PCRE_UCHAR32 *output, int max_length)
1002    {
1003            unsigned char *iptr = (unsigned char*)input;
1004            PCRE_UCHAR32 *optr = output;
1005    
1006            if (max_length == 0)
1007                    return 0;
1008    
1009            while (*iptr && max_length > 1) {
1010                    *optr++ = *iptr++;
1011                    max_length--;
1012            }
1013            *optr = '\0';
1014            return (int)(optr - output);
1015    }
1016    
1017    #define REGTEST_MAX_LENGTH32 4096
1018    static PCRE_UCHAR32 regtest_buf32[REGTEST_MAX_LENGTH32];
1019    static int regtest_offsetmap32[REGTEST_MAX_LENGTH32];
1020    
1021    #endif /* SUPPORT_PCRE32 */
1022    
1023    static int check_ascii(const char *input)
1024    {
1025            const unsigned char *ptr = (unsigned char *)input;
1026            while (*ptr) {
1027                    if (*ptr > 127)
1028                            return 0;
1029                    ptr++;
1030            }
1031            return 1;
1032    }
1033    
1034  static int regression_tests(void)  static int regression_tests(void)
1035  {  {
         pcre *re;  
1036          struct regression_test_case *current = regression_test_cases;          struct regression_test_case *current = regression_test_cases;
1037          const char *error;          const char *error;
1038          pcre_extra *extra;          char *cpu_info;
         int utf8 = 0, ucp = 0;  
         int ovector1[32];  
         int ovector2[32];  
         int return_value1, return_value2;  
1039          int i, err_offs;          int i, err_offs;
1040          int total = 0, succesful = 0;          int is_successful, is_ascii_pattern, is_ascii_input;
1041            int total = 0;
1042            int successful = 0;
1043            int successful_row = 0;
1044          int counter = 0;          int counter = 0;
1045          int disabled_flags = PCRE_BUG;          int study_mode;
1046            int utf = 0, ucp = 0;
1047            int disabled_flags = 0;
1048    #ifdef SUPPORT_PCRE8
1049            pcre *re8;
1050            pcre_extra *extra8;
1051            pcre_extra dummy_extra8;
1052            int ovector8_1[32];
1053            int ovector8_2[32];
1054            int return_value8[2];
1055            unsigned char *mark8_1, *mark8_2;
1056    #endif
1057    #ifdef SUPPORT_PCRE16
1058            pcre16 *re16;
1059            pcre16_extra *extra16;
1060            pcre16_extra dummy_extra16;
1061            int ovector16_1[32];
1062            int ovector16_2[32];
1063            int return_value16[2];
1064            PCRE_UCHAR16 *mark16_1, *mark16_2;
1065            int length16;
1066    #endif
1067    #ifdef SUPPORT_PCRE32
1068            pcre32 *re32;
1069            pcre32_extra *extra32;
1070            pcre32_extra dummy_extra32;
1071            int ovector32_1[32];
1072            int ovector32_2[32];
1073            int return_value32[2];
1074            PCRE_UCHAR32 *mark32_1, *mark32_2;
1075            int length32;
1076    #endif
1077    
1078          /* This test compares the behaviour of interpreter and JIT. Although disabling          /* This test compares the behaviour of interpreter and JIT. Although disabling
1079          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
1080          still considered successful from pcre_jit_test point of view. */          still considered successful from pcre_jit_test point of view. */
1081    
1082          pcre_config(PCRE_CONFIG_UTF8, &utf8);  #if defined SUPPORT_PCRE8
1083            pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1084    #elif defined SUPPORT_PCRE16
1085            pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1086    #elif defined SUPPORT_PCRE32
1087            pcre32_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1088    #endif
1089    
1090            printf("Running JIT regression tests\n");
1091            printf("  target CPU of SLJIT compiler: %s\n", cpu_info);
1092    
1093    #if defined SUPPORT_PCRE8
1094            pcre_config(PCRE_CONFIG_UTF8, &utf);
1095          pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);          pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1096          if (!utf8)  #elif defined SUPPORT_PCRE16
1097                  disabled_flags |= PCRE_UTF8;          pcre16_config(PCRE_CONFIG_UTF16, &utf);
1098            pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1099    #elif defined SUPPORT_PCRE16
1100            pcre32_config(PCRE_CONFIG_UTF32, &utf);
1101            pcre32_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1102    #endif
1103    
1104            if (!utf)
1105                    disabled_flags |= PCRE_UTF8 | PCRE_UTF16 | PCRE_UTF32;
1106          if (!ucp)          if (!ucp)
1107                  disabled_flags |= PCRE_UCP;                  disabled_flags |= PCRE_UCP;
1108    #ifdef SUPPORT_PCRE8
1109            printf("  in  8 bit mode with UTF-8  %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
1110    #endif
1111    #ifdef SUPPORT_PCRE16
1112            printf("  in 16 bit mode with UTF-16 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
1113    #endif
1114    #ifdef SUPPORT_PCRE32
1115            printf("  in 32 bit mode with UTF-32 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
1116    #endif
1117    
         printf("Running JIT regression tests with utf8 %s and ucp %s:\n", utf8 ? "enabled" : "disabled", ucp ? "enabled" : "disabled");  
1118          while (current->pattern) {          while (current->pattern) {
1119                  /* printf("\nPattern: %s :\n", current->pattern); */                  /* printf("\nPattern: %s :\n", current->pattern); */
1120                  total++;                  total++;
1121                    if (current->start_offset & F_PROPERTY) {
1122                            is_ascii_pattern = 0;
1123                            is_ascii_input = 0;
1124                    } else {
1125                            is_ascii_pattern = check_ascii(current->pattern);
1126                            is_ascii_input = check_ascii(current->input);
1127                    }
1128    
1129                    if (current->flags & PCRE_PARTIAL_SOFT)
1130                            study_mode = PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE;
1131                    else if (current->flags & PCRE_PARTIAL_HARD)
1132                            study_mode = PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE;
1133                    else
1134                            study_mode = PCRE_STUDY_JIT_COMPILE;
1135                  error = NULL;                  error = NULL;
1136                  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
1137                    re8 = NULL;
1138                  if (!re) {                  if (!(current->start_offset & F_NO8))
1139                          if (utf8 && ucp)                          re8 = pcre_compile(current->pattern,
1140                                  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),
1141                          else {                                  &error, &err_offs, tables(0));
1142                                  /* Some patterns cannot be compiled when either of utf8  
1143                                  or ucp is disabled. We just skip them. */                  extra8 = NULL;
1144                                  printf(".");                  if (re8) {
1145                                  succesful++;                          error = NULL;
1146                            extra8 = pcre_study(re8, study_mode, &error);
1147                            if (!extra8) {
1148                                    printf("\n8 bit: Cannot study pattern: %s\n", current->pattern);
1149                                    pcre_free(re8);
1150                                    re8 = NULL;
1151                          }                          }
1152                          current++;                          else if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1153                          continue;                                  printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);
1154                  }                                  pcre_free_study(extra8);
1155                                    pcre_free(re8);
1156                                    re8 = NULL;
1157                            }
1158                            extra8->flags |= PCRE_EXTRA_MARK;
1159                    } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO8))
1160                            printf("\n8 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1161    #endif
1162    #ifdef SUPPORT_PCRE16
1163                    if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1164                            convert_utf8_to_utf16(current->pattern, regtest_buf16, NULL, REGTEST_MAX_LENGTH16);
1165                    else
1166                            copy_char8_to_char16(current->pattern, regtest_buf16, REGTEST_MAX_LENGTH16);
1167    
1168                    re16 = NULL;
1169                    if (!(current->start_offset & F_NO16))
1170                            re16 = pcre16_compile(regtest_buf16,
1171                                    current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1172                                    &error, &err_offs, tables(0));
1173    
1174                    extra16 = NULL;
1175                    if (re16) {
1176                            error = NULL;
1177                            extra16 = pcre16_study(re16, study_mode, &error);
1178                            if (!extra16) {
1179                                    printf("\n16 bit: Cannot study pattern: %s\n", current->pattern);
1180                                    pcre16_free(re16);
1181                                    re16 = NULL;
1182                            }
1183                            else if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1184                                    printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);
1185                                    pcre16_free_study(extra16);
1186                                    pcre16_free(re16);
1187                                    re16 = NULL;
1188                            }
1189                            extra16->flags |= PCRE_EXTRA_MARK;
1190                    } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO16))
1191                            printf("\n16 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1192    #endif
1193    #ifdef SUPPORT_PCRE32
1194                    if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1195                            convert_utf8_to_utf32(current->pattern, regtest_buf32, NULL, REGTEST_MAX_LENGTH32);
1196                    else
1197                            copy_char8_to_char32(current->pattern, regtest_buf32, REGTEST_MAX_LENGTH32);
1198    
1199                    re32 = NULL;
1200                    if (!(current->start_offset & F_NO32))
1201                            re32 = pcre32_compile(regtest_buf32,
1202                                    current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1203                                    &error, &err_offs, tables(0));
1204    
1205                    extra32 = NULL;
1206                    if (re32) {
1207                            error = NULL;
1208                            extra32 = pcre32_study(re32, study_mode, &error);
1209                            if (!extra32) {
1210                                    printf("\n32 bit: Cannot study pattern: %s\n", current->pattern);
1211                                    pcre32_free(re32);
1212                                    re32 = NULL;
1213                            }
1214                            if (!(extra32->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1215                                    printf("\n32 bit: JIT compiler does not support: %s\n", current->pattern);
1216                                    pcre32_free_study(extra32);
1217                                    pcre32_free(re32);
1218                                    re32 = NULL;
1219                            }
1220                            extra32->flags |= PCRE_EXTRA_MARK;
1221                    } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO32))
1222                            printf("\n32 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1223    #endif
1224    
1225                  error = NULL;                  counter++;
1226                  extra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &error);                  if ((counter & 0x3) != 0) {
1227                  if (!extra) {  #ifdef SUPPORT_PCRE8
1228                          printf("\nCannot study pattern: %s\n", current->pattern);                          setstack8(NULL);
1229                          current++;  #endif
1230                          continue;  #ifdef SUPPORT_PCRE16
1231                            setstack16(NULL);
1232    #endif
1233    #ifdef SUPPORT_PCRE32
1234                            setstack32(NULL);
1235    #endif
1236                  }                  }
1237    
1238                  if (!(extra->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {  #ifdef SUPPORT_PCRE8
1239                          printf("\nJIT compiler does not support: %s\n", current->pattern);                  return_value8[0] = -1000;
1240                          current++;                  return_value8[1] = -1000;
1241                          continue;                  for (i = 0; i < 32; ++i)
1242                            ovector8_1[i] = -2;
1243                    for (i = 0; i < 32; ++i)
1244                            ovector8_2[i] = -2;
1245                    if (re8) {
1246                            mark8_1 = NULL;
1247                            mark8_2 = NULL;
1248                            extra8->mark = &mark8_1;
1249    
1250                            if ((counter & 0x1) != 0) {
1251                                    setstack8(extra8);
1252                                    return_value8[0] = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1253                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32);
1254                            } else
1255                                    return_value8[0] = pcre_jit_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1256                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32, getstack8());
1257                            memset(&dummy_extra8, 0, sizeof(pcre_extra));
1258                            dummy_extra8.flags = PCRE_EXTRA_MARK;
1259                            if (current->start_offset & F_STUDY) {
1260                                    dummy_extra8.flags |= PCRE_EXTRA_STUDY_DATA;
1261                                    dummy_extra8.study_data = extra8->study_data;
1262                            }
1263                            dummy_extra8.mark = &mark8_2;
1264                            return_value8[1] = pcre_exec(re8, &dummy_extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1265                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_2, 32);
1266                  }                  }
1267    #endif
1268    
1269                  counter++;  #ifdef SUPPORT_PCRE16
1270                  if ((counter & 0x3) != 0)                  return_value16[0] = -1000;
1271                          setstack(extra);                  return_value16[1] = -1000;
1272                    for (i = 0; i < 32; ++i)
1273                            ovector16_1[i] = -2;
1274                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1275                          ovector1[i] = -2;                          ovector16_2[i] = -2;
1276                  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) {
1277                            mark16_1 = NULL;
1278                            mark16_2 = NULL;
1279                            if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1280                                    length16 = convert_utf8_to_utf16(current->input, regtest_buf16, regtest_offsetmap16, REGTEST_MAX_LENGTH16);
1281                            else
1282                                    length16 = copy_char8_to_char16(current->input, regtest_buf16, REGTEST_MAX_LENGTH16);
1283                            extra16->mark = &mark16_1;
1284                            if ((counter & 0x1) != 0) {
1285                                    setstack16(extra16);
1286                                    return_value16[0] = pcre16_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1287                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32);
1288                            } else
1289                                    return_value16[0] = pcre16_jit_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1290                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32, getstack16());
1291                            memset(&dummy_extra16, 0, sizeof(pcre16_extra));
1292                            dummy_extra16.flags = PCRE_EXTRA_MARK;
1293                            if (current->start_offset & F_STUDY) {
1294                                    dummy_extra16.flags |= PCRE_EXTRA_STUDY_DATA;
1295                                    dummy_extra16.study_data = extra16->study_data;
1296                            }
1297                            dummy_extra16.mark = &mark16_2;
1298                            return_value16[1] = pcre16_exec(re16, &dummy_extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1299                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_2, 32);
1300                    }
1301    #endif
1302    
1303    #ifdef SUPPORT_PCRE32
1304                    return_value32[0] = -1000;
1305                    return_value32[1] = -1000;
1306                    for (i = 0; i < 32; ++i)
1307                            ovector32_1[i] = -2;
1308                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1309                          ovector2[i] = -2;                          ovector32_2[i] = -2;
1310                  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) {
1311                            mark32_1 = NULL;
1312                            mark32_2 = NULL;
1313                            if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1314                                    length32 = convert_utf8_to_utf32(current->input, regtest_buf32, regtest_offsetmap32, REGTEST_MAX_LENGTH32);
1315                            else
1316                                    length32 = copy_char8_to_char32(current->input, regtest_buf32, REGTEST_MAX_LENGTH32);
1317                            extra32->mark = &mark32_1;
1318                            if ((counter & 0x1) != 0) {
1319                                    setstack32(extra32);
1320                                    return_value32[0] = pcre32_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1321                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32);
1322                            } else
1323                                    return_value32[0] = pcre32_jit_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1324                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32, getstack32());
1325                            memset(&dummy_extra32, 0, sizeof(pcre32_extra));
1326                            dummy_extra32.flags = PCRE_EXTRA_MARK;
1327                            if (current->start_offset & F_STUDY) {
1328                                    dummy_extra32.flags |= PCRE_EXTRA_STUDY_DATA;
1329                                    dummy_extra32.study_data = extra32->study_data;
1330                            }
1331                            dummy_extra32.mark = &mark32_2;
1332                            return_value32[1] = pcre32_exec(re32, &dummy_extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1333                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_2, 32);
1334                    }
1335    #endif
1336    
1337                    /* printf("[%d-%d-%d|%d-%d|%d-%d|%d-%d]%s",
1338                            return_value8[0], return_value16[0],
1339                            ovector8_1[0], ovector8_1[1],
1340                            ovector16_1[0], ovector16_1[1],
1341                            ovector32_1[0], ovector32_1[1],
1342                            (current->flags & PCRE_CASELESS) ? "C" : ""); */
1343    
1344                  /* 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.
1345                  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;  
                         }  
1346    
1347                          if (return_value1 >= 0) {                  is_successful = 1;
1348                                  return_value1 *= 2;                  if (!(current->start_offset & F_DIFF)) {
1349                                  err_offs = 0;  #if defined SUPPORT_UTF && ((defined(SUPPORT_PCRE8) + defined(SUPPORT_PCRE16) + defined(SUPPORT_PCRE32)) >= 2)
1350                                  for (i = 0; i < return_value1; ++i)                          if (!(current->start_offset & F_FORCECONV)) {
1351                                          if (ovector1[i] != ovector2[i]) {                                  int return_value;
1352                                                  printf("\nOvector[%d] value differs(%d:%d): '%s' @ '%s' \n", i, ovector1[i], ovector2[i], current->pattern, current->input);  
1353                                                  err_offs = 1;                                  /* All results must be the same. */
1354    #ifdef SUPPORT_PCRE8
1355                                    if ((return_value = return_value8[0]) != return_value8[1]) {
1356                                            printf("\n8 bit: Return value differs(J8:%d,I8:%d): [%d] '%s' @ '%s'\n",
1357                                                    return_value8[0], return_value8[1], total, current->pattern, current->input);
1358                                            is_successful = 0;
1359                                    } else
1360    #endif
1361    #ifdef SUPPORT_PCRE16
1362                                    if ((return_value = return_value16[0]) != return_value16[1]) {
1363                                            printf("\n16 bit: Return value differs(J16:%d,I16:%d): [%d] '%s' @ '%s'\n",
1364                                                    return_value16[0], return_value16[1], total, current->pattern, current->input);
1365                                            is_successful = 0;
1366                                    } else
1367    #endif
1368    #ifdef SUPPORT_PCRE32
1369                                    if ((return_value = return_value32[0]) != return_value32[1]) {
1370                                            printf("\n32 bit: Return value differs(J32:%d,I32:%d): [%d] '%s' @ '%s'\n",
1371                                                    return_value32[0], return_value32[1], total, current->pattern, current->input);
1372                                            is_successful = 0;
1373                                    } else
1374    #endif
1375    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1376                                    if (return_value8[0] != return_value16[0]) {
1377                                            printf("\n8 and 16 bit: Return value differs(J8:%d,J16:%d): [%d] '%s' @ '%s'\n",
1378                                                    return_value8[0], return_value16[0],
1379                                                    total, current->pattern, current->input);
1380                                            is_successful = 0;
1381                                    } else
1382    #endif
1383    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1384                                    if (return_value8[0] != return_value32[0]) {
1385                                            printf("\n8 and 32 bit: Return value differs(J8:%d,J32:%d): [%d] '%s' @ '%s'\n",
1386                                                    return_value8[0], return_value32[0],
1387                                                    total, current->pattern, current->input);
1388                                            is_successful = 0;
1389                                    } else
1390    #endif
1391    #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE32
1392                                    if (return_value16[0] != return_value32[0]) {
1393                                            printf("\n16 and 32 bit: Return value differs(J16:%d,J32:%d): [%d] '%s' @ '%s'\n",
1394                                                    return_value16[0], return_value32[0],
1395                                                    total, current->pattern, current->input);
1396                                            is_successful = 0;
1397                                    } else
1398    #endif
1399                                    if (return_value >= 0 || return_value == PCRE_ERROR_PARTIAL) {
1400                                            if (return_value == PCRE_ERROR_PARTIAL) {
1401                                                    return_value = 2;
1402                                            } else {
1403                                                    return_value *= 2;
1404                                            }
1405    #ifdef SUPPORT_PCRE8
1406                                            return_value8[0] = return_value;
1407    #endif
1408    #ifdef SUPPORT_PCRE16
1409                                            return_value16[0] = return_value;
1410    #endif
1411    #ifdef SUPPORT_PCRE32
1412                                            return_value32[0] = return_value;
1413    #endif
1414                                            /* Transform back the results. */
1415                                            if (current->flags & PCRE_UTF8) {
1416    #ifdef SUPPORT_PCRE16
1417                                                    for (i = 0; i < return_value; ++i) {
1418                                                            if (ovector16_1[i] >= 0)
1419                                                                    ovector16_1[i] = regtest_offsetmap16[ovector16_1[i]];
1420                                                            if (ovector16_2[i] >= 0)
1421                                                                    ovector16_2[i] = regtest_offsetmap16[ovector16_2[i]];
1422                                                    }
1423    #endif
1424    #ifdef SUPPORT_PCRE32
1425                                                    for (i = 0; i < return_value; ++i) {
1426                                                            if (ovector32_1[i] >= 0)
1427                                                                    ovector32_1[i] = regtest_offsetmap32[ovector32_1[i]];
1428                                                            if (ovector32_2[i] >= 0)
1429                                                                    ovector32_2[i] = regtest_offsetmap32[ovector32_2[i]];
1430                                                    }
1431    #endif
1432                                            }
1433    
1434                                            for (i = 0; i < return_value; ++i) {
1435    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1436                                                    if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector16_1[i] || ovector8_1[i] != ovector16_2[i]) {
1437                                                            printf("\n8 and 16 bit: Ovector[%d] value differs(J8:%d,I8:%d,J16:%d,I16:%d): [%d] '%s' @ '%s' \n",
1438                                                                    i, ovector8_1[i], ovector8_2[i], ovector16_1[i], ovector16_2[i],
1439                                                                    total, current->pattern, current->input);
1440                                                            is_successful = 0;
1441                                                    }
1442    #endif
1443    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1444                                                    if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector32_1[i] || ovector8_1[i] != ovector32_2[i]) {
1445                                                            printf("\n8 and 32 bit: Ovector[%d] value differs(J8:%d,I8:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1446                                                                    i, ovector8_1[i], ovector8_2[i], ovector32_1[i], ovector32_2[i],
1447                                                                    total, current->pattern, current->input);
1448                                                            is_successful = 0;
1449                                                    }
1450    #endif
1451    #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE16
1452                                                    if (ovector16_1[i] != ovector16_2[i] || ovector16_1[i] != ovector16_1[i] || ovector16_1[i] != ovector16_2[i]) {
1453                                                            printf("\n16 and 16 bit: Ovector[%d] value differs(J16:%d,I16:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1454                                                                    i, ovector16_1[i], ovector16_2[i], ovector16_1[i], ovector16_2[i],
1455                                                                    total, current->pattern, current->input);
1456                                                            is_successful = 0;
1457                                                    }
1458    #endif
1459                                          }                                          }
                                 if (err_offs) {  
                                         current++;  
                                         continue;  
1460                                  }                                  }
1461                            } else
1462    #endif /* more than one of SUPPORT_PCRE8, SUPPORT_PCRE16 and SUPPORT_PCRE32 */
1463                            {
1464                                    /* Only the 8 bit and 16 bit results must be equal. */
1465    #ifdef SUPPORT_PCRE8
1466                                    if (return_value8[0] != return_value8[1]) {
1467                                            printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1468                                                    return_value8[0], return_value8[1], total, current->pattern, current->input);
1469                                            is_successful = 0;
1470                                    } else if (return_value8[0] >= 0 || return_value8[0] == PCRE_ERROR_PARTIAL) {
1471                                            if (return_value8[0] == PCRE_ERROR_PARTIAL)
1472                                                    return_value8[0] = 2;
1473                                            else
1474                                                    return_value8[0] *= 2;
1475    
1476                                            for (i = 0; i < return_value8[0]; ++i)
1477                                                    if (ovector8_1[i] != ovector8_2[i]) {
1478                                                            printf("\n8 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1479                                                                    i, ovector8_1[i], ovector8_2[i], total, current->pattern, current->input);
1480                                                            is_successful = 0;
1481                                                    }
1482                                    }
1483    #endif
1484    
1485    #ifdef SUPPORT_PCRE16
1486                                    if (return_value16[0] != return_value16[1]) {
1487                                            printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1488                                                    return_value16[0], return_value16[1], total, current->pattern, current->input);
1489                                            is_successful = 0;
1490                                    } else if (return_value16[0] >= 0 || return_value16[0] == PCRE_ERROR_PARTIAL) {
1491                                            if (return_value16[0] == PCRE_ERROR_PARTIAL)
1492                                                    return_value16[0] = 2;
1493                                            else
1494                                                    return_value16[0] *= 2;
1495    
1496                                            for (i = 0; i < return_value16[0]; ++i)
1497                                                    if (ovector16_1[i] != ovector16_2[i]) {
1498                                                            printf("\n16 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1499                                                                    i, ovector16_1[i], ovector16_2[i], total, current->pattern, current->input);
1500                                                            is_successful = 0;
1501                                                    }
1502                                    }
1503    #endif
1504    
1505    #ifdef SUPPORT_PCRE32
1506                                    if (return_value32[0] != return_value32[1]) {
1507                                            printf("\n32 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1508                                                    return_value32[0], return_value32[1], total, current->pattern, current->input);
1509                                            is_successful = 0;
1510                                    } else if (return_value32[0] >= 0 || return_value32[0] == PCRE_ERROR_PARTIAL) {
1511                                            if (return_value32[0] == PCRE_ERROR_PARTIAL)
1512                                                    return_value32[0] = 2;
1513                                            else
1514                                                    return_value32[0] *= 2;
1515    
1516                                            for (i = 0; i < return_value32[0]; ++i)
1517                                                    if (ovector32_1[i] != ovector32_2[i]) {
1518                                                            printf("\n32 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1519                                                                    i, ovector32_1[i], ovector32_2[i], total, current->pattern, current->input);
1520                                                            is_successful = 0;
1521                                                    }
1522                                    }
1523    #endif
1524                          }                          }
1525                  }                  }
1526    
1527                  pcre_free_study(extra);                  if (is_successful) {
1528                  pcre_free(re);  #ifdef SUPPORT_PCRE8
1529                            if (!(current->start_offset & F_NO8) && ((utf && ucp) || is_ascii_input)) {
1530                                    if (return_value8[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1531                                            printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",
1532                                                    total, current->pattern, current->input);
1533                                            is_successful = 0;
1534                                    }
1535    
1536                                    if (return_value8[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1537                                            printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",
1538                                                    total, current->pattern, current->input);
1539                                            is_successful = 0;
1540                                    }
1541                            }
1542    #endif
1543    #ifdef SUPPORT_PCRE16
1544                            if (!(current->start_offset & F_NO16) && ((utf && ucp) || is_ascii_input)) {
1545                                    if (return_value16[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1546                                            printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",
1547                                                    total, current->pattern, current->input);
1548                                            is_successful = 0;
1549                                    }
1550    
1551                                    if (return_value16[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1552                                            printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",
1553                                                    total, current->pattern, current->input);
1554                                            is_successful = 0;
1555                                    }
1556                            }
1557    #endif
1558    #ifdef SUPPORT_PCRE32
1559                            if (!(current->start_offset & F_NO32) && ((utf && ucp) || is_ascii_input)) {
1560                                    if (return_value32[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1561                                            printf("32 bit: Test should match: [%d] '%s' @ '%s'\n",
1562                                                    total, current->pattern, current->input);
1563                                            is_successful = 0;
1564                                    }
1565    
1566                                    if (return_value32[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1567                                            printf("32 bit: Test should not match: [%d] '%s' @ '%s'\n",
1568                                                    total, current->pattern, current->input);
1569                                            is_successful = 0;
1570                                    }
1571                            }
1572    #endif
1573                    }
1574    
1575                    if (is_successful) {
1576    #ifdef SUPPORT_PCRE8
1577                            if (mark8_1 != mark8_2) {
1578                                    printf("8 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1579                                            total, current->pattern, current->input);
1580                                    is_successful = 0;
1581                            }
1582    #endif
1583    #ifdef SUPPORT_PCRE16
1584                            if (mark16_1 != mark16_2) {
1585                                    printf("16 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1586                                            total, current->pattern, current->input);
1587                                    is_successful = 0;
1588                            }
1589    #endif
1590    #ifdef SUPPORT_PCRE32
1591                            if (mark32_1 != mark32_2) {
1592                                    printf("32 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1593                                            total, current->pattern, current->input);
1594                                    is_successful = 0;
1595                            }
1596    #endif
1597                    }
1598    
1599    #ifdef SUPPORT_PCRE8
1600                    if (re8) {
1601                            pcre_free_study(extra8);
1602                            pcre_free(re8);
1603                    }
1604    #endif
1605    #ifdef SUPPORT_PCRE16
1606                    if (re16) {
1607                            pcre16_free_study(extra16);
1608                            pcre16_free(re16);
1609                    }
1610    #endif
1611    #ifdef SUPPORT_PCRE32
1612                    if (re32) {
1613                            pcre32_free_study(extra32);
1614                            pcre32_free(re32);
1615                    }
1616    #endif
1617    
1618                    if (is_successful) {
1619                            successful++;
1620                            successful_row++;
1621                            printf(".");
1622                            if (successful_row >= 60) {
1623                                    successful_row = 0;
1624                                    printf("\n");
1625                            }
1626                    } else
1627                            successful_row = 0;
1628    
                 /* printf("[%d-%d]%s", ovector1[0], ovector1[1], (current->flags & PCRE_CASELESS) ? "C" : ""); */  
                 printf(".");  
1629                  fflush(stdout);                  fflush(stdout);
1630                  current++;                  current++;
                 succesful++;  
1631          }          }
1632            tables(1);
1633    #ifdef SUPPORT_PCRE8
1634            setstack8(NULL);
1635    #endif
1636    #ifdef SUPPORT_PCRE16
1637            setstack16(NULL);
1638    #endif
1639    #ifdef SUPPORT_PCRE32
1640            setstack32(NULL);
1641    #endif
1642    
1643          if (total == succesful) {          if (total == successful) {
1644                  printf("\nAll JIT regression tests are successfully passed.\n");                  printf("\nAll JIT regression tests are successfully passed.\n");
1645                  return 0;                  return 0;
1646          } else {          } else {
1647                  printf("\nSuccessful test ratio: %d%%\n", succesful * 100 / total);                  printf("\nSuccessful test ratio: %d%% (%d failed)\n", successful * 100 / total, total - successful);
1648                  return 1;                  return 1;
1649          }          }
1650  }  }

Legend:
Removed from v.698  
changed lines
  Added in v.1276

  ViewVC Help
Powered by ViewVC 1.1.5