Diff for /embedaddon/pcre/pcre_jit_test.c between versions 1.1 and 1.1.1.4

version 1.1, 2012/02/21 23:05:51 version 1.1.1.4, 2013/07/22 08:25:55
Line 6 Line 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.
   
                   Main Library written by Philip Hazel                    Main Library written by Philip Hazel
           Copyright (c) 1997-2011 University of Cambridge           Copyright (c) 1997-2012 University of Cambridge
   
   This JIT compiler regression test program was written by Zoltan Herczeg    This JIT compiler regression test program was written by Zoltan Herczeg
                      Copyright (c) 2010-2011                      Copyright (c) 2010-2012
   
 -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
 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.
 #include <string.h>  #include <string.h>
 #include "pcre.h"  #include "pcre.h"
   
   
   #include "pcre_internal.h"
   
 #define PCRE_BUG 0x80000000  #define PCRE_BUG 0x80000000
   
 /*  /*
 Hungarian utf8 characters Letter characters:
 \xc3\xa9 = 0xe9 = 233 (e') \xc3\x89 = 0xc9 = 201 (E')   \xe6\x92\xad = 0x64ad = 25773 (kanji)
 \xc3\xa1 = 0xe1 = 225 (a') \xc3\x81 = 0xc1 = 193 (A') Non-letter characters:
 \xe6\x92\xad = 0x64ad = 25773 (a valid kanji)   \xc2\xa1 = 0xa1 =  (Inverted Exclamation Mark)
 \xc2\x85 = 0x85 (NExt Line = NEL)   \xf3\xa9\xb7\x80 = 0xe9dc0 = 957888
 \xc2\xa1 = 0xa1 (Inverted Exclamation Mark)   \xed\xa0\x80 = 55296 = 0xd800 (Invalid UTF character)
 \xe2\x80\xa8 = 0x2028 (Line Separator)   \xed\xb0\x80 = 56320 = 0xdc00 (Invalid UTF character)
 \xc8\xba = 570 \xe2\xb1\xa5 = 11365 (lowercase length != uppercase length) Newlines:
 \xcc\x8d = 781 (Something with Mark property)   \xc2\x85 = 0x85 = 133 (NExt Line = NEL)
    \xe2\x80\xa8 = 0x2028 = 8232 (Line Separator)
  Othercase pairs:
    \xc3\xa9 = 0xe9 = 233 (e')
       \xc3\x89 = 0xc9 = 201 (E')
    \xc3\xa1 = 0xe1 = 225 (a')
       \xc3\x81 = 0xc1 = 193 (A')
    \xc8\xba = 0x23a = 570
       \xe2\xb1\xa5 = 0x2c65 = 11365
    \xe1\xbd\xb8 = 0x1f78 = 8056
       \xe1\xbf\xb8 = 0x1ff8 = 8184
    \xf0\x90\x90\x80 = 0x10400 = 66560
       \xf0\x90\x90\xa8 = 0x10428 = 66600
  Mark property:
    \xcc\x8d = 0x30d = 781
  Special:
    \xdf\xbf = 0x7ff = 2047 (highest 2 byte character)
    \xe0\xa0\x80 = 0x800 = 2048 (lowest 2 byte character)
    \xef\xbf\xbf = 0xffff = 65535 (highest 3 byte character)
    \xf0\x90\x80\x80 = 0x10000 = 65536 (lowest 4 byte character)
    \xf4\x8f\xbf\xbf = 0x10ffff = 1114111 (highest allowed utf character)
 */  */
   
 static void setstack(pcre_extra *extra);  
 static int regression_tests(void);  static int regression_tests(void);
   
 int main(void)  int main(void)
 {  {
         int jit = 0;          int jit = 0;
   #if defined SUPPORT_PCRE8
         pcre_config(PCRE_CONFIG_JIT, &jit);          pcre_config(PCRE_CONFIG_JIT, &jit);
   #elif defined SUPPORT_PCRE16
           pcre16_config(PCRE_CONFIG_JIT, &jit);
   #elif defined SUPPORT_PCRE32
           pcre32_config(PCRE_CONFIG_JIT, &jit);
   #endif
         if (!jit) {          if (!jit) {
                 printf("JIT must be enabled to run pcre_jit_test\n");                  printf("JIT must be enabled to run pcre_jit_test\n");
                 return 1;                  return 1;
Line 76  int main(void) Line 104  int main(void)
         return regression_tests();          return regression_tests();
 }  }
   
static pcre_jit_stack* callback(void *arg)/* --------------------------------------------------------------------------------------- */
{ 
        return (pcre_jit_stack *)arg; 
} 
   
static void setstack(pcre_extra *extra)#if !(defined SUPPORT_PCRE8) && !(defined SUPPORT_PCRE16) && !(defined SUPPORT_PCRE32)
{#error SUPPORT_PCRE8 or SUPPORT_PCRE16 or SUPPORT_PCRE32 must be defined
        static pcre_jit_stack *stack;#endif
        if (stack) pcre_jit_stack_free(stack); 
        stack = pcre_jit_stack_alloc(1, 1024 * 1024); 
        pcre_assign_jit_stack(extra, callback, stack); 
} 
   
/* --------------------------------------------------------------------------------------- */#define MUA     (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)
 #define MUAP    (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)
 #define CMUA    (PCRE_CASELESS | PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)
 #define CMUAP   (PCRE_CASELESS | PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)
 #define MA      (PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF)
 #define MAP     (PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)
 #define CMA     (PCRE_CASELESS | PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF)
   
#define MUA     (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)#define OFFSET_MASK     0x00ffff
#define MUAP    (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)#define F_NO8           0x010000
#define CMUA    (PCRE_CASELESS | PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)#define F_NO16          0x020000
#define CMUAP   (PCRE_CASELESS | PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)#define F_NO32          0x020000
#define MA      (PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF)#define F_NOMATCH       0x040000
#define MAP     (PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)#define F_DIFF          0x080000
#define CMA     (PCRE_CASELESS | PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF)#define F_FORCECONV     0x100000
 #define F_PROPERTY      0x200000
 #define F_STUDY         0x400000
   
 struct regression_test_case {  struct regression_test_case {
         int flags;          int flags;
Line 124  static struct regression_test_case regression_test_cas Line 153  static struct regression_test_case regression_test_cas
         { MUA, 0, "\\W(\\W)?\\w", "\n\n+bc" },          { MUA, 0, "\\W(\\W)?\\w", "\n\n+bc" },
         { MUA, 0, "[axd]", "sAXd" },          { MUA, 0, "[axd]", "sAXd" },
         { CMUA, 0, "[axd]", "sAXd" },          { CMUA, 0, "[axd]", "sAXd" },
        { CMUA, 0, "[^axd]", "DxA" },        { CMUA, 0 | F_NOMATCH, "[^axd]", "DxA" },
         { MUA, 0, "[a-dA-C]", "\xe6\x92\xad\xc3\xa9.B" },          { MUA, 0, "[a-dA-C]", "\xe6\x92\xad\xc3\xa9.B" },
         { MUA, 0, "[^a-dA-C]", "\xe6\x92\xad\xc3\xa9" },          { MUA, 0, "[^a-dA-C]", "\xe6\x92\xad\xc3\xa9" },
         { CMUA, 0, "[^\xc3\xa9]", "\xc3\xa9\xc3\x89." },          { CMUA, 0, "[^\xc3\xa9]", "\xc3\xa9\xc3\x89." },
Line 137  static struct regression_test_case regression_test_cas Line 166  static struct regression_test_case regression_test_cas
         { PCRE_CASELESS, 0, "a1", "Aa1" },          { PCRE_CASELESS, 0, "a1", "Aa1" },
         { MA, 0, "\\Ca", "cda" },          { MA, 0, "\\Ca", "cda" },
         { CMA, 0, "\\Ca", "CDA" },          { CMA, 0, "\\Ca", "CDA" },
        { MA, 0, "\\Cx", "cda" },        { MA, 0 | F_NOMATCH, "\\Cx", "cda" },
        { CMA, 0, "\\Cx", "CDA" },        { CMA, 0 | F_NOMATCH, "\\Cx", "CDA" },
         { CMUAP, 0, "\xf0\x90\x90\x80\xf0\x90\x90\xa8", "\xf0\x90\x90\xa8\xf0\x90\x90\x80" },
         { CMUAP, 0, "\xf0\x90\x90\x80{2}", "\xf0\x90\x90\x80#\xf0\x90\x90\xa8\xf0\x90\x90\x80" },
         { CMUAP, 0, "\xf0\x90\x90\xa8{2}", "\xf0\x90\x90\x80#\xf0\x90\x90\xa8\xf0\x90\x90\x80" },
         { CMUAP, 0, "\xe1\xbd\xb8\xe1\xbf\xb8", "\xe1\xbf\xb8\xe1\xbd\xb8" },
   
         /* Assertions. */          /* Assertions. */
         { MUA, 0, "\\b[^A]", "A_B#" },          { MUA, 0, "\\b[^A]", "A_B#" },
        { MA, 0, "\\b\\W", "\n*" },        { MA, 0 | F_NOMATCH, "\\b\\W", "\n*" },
         { MUA, 0, "\\B[^,]\\b[^s]\\b", "#X" },          { MUA, 0, "\\B[^,]\\b[^s]\\b", "#X" },
         { MAP, 0, "\\B", "_\xa1" },          { MAP, 0, "\\B", "_\xa1" },
         { MAP, 0, "\\b_\\b[,A]\\B", "_," },          { MAP, 0, "\\b_\\b[,A]\\B", "_," },
Line 150  static struct regression_test_case regression_test_cas Line 183  static struct regression_test_case regression_test_cas
         { MUAP, 0, "\\B", "_\xc2\xa1\xc3\xa1\xc2\x85" },          { MUAP, 0, "\\B", "_\xc2\xa1\xc3\xa1\xc2\x85" },
         { 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" },
         { 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" },
        { MUA, 0, "\\b.", "\xcd\xbe" },        { MUA, 0 | F_NOMATCH, "\\b.", "\xcd\xbe" },
        { MA, 0, "\\R^", "\n" },        { CMUAP, 0, "\\By", "\xf0\x90\x90\xa8y" },
        { MA, 1, "^", "\n" },        { MA, 0 | F_NOMATCH, "\\R^", "\n" },
         { MA, 1 | F_NOMATCH, "^", "\n" },
         { 0, 0, "^ab", "ab" },          { 0, 0, "^ab", "ab" },
        { 0, 0, "^ab", "aab" },        { 0, 0 | F_NOMATCH, "^ab", "aab" },
         { 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" },
         { 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-" },
         { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "^-", "a--b--\x85--" },          { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "^-", "a--b--\x85--" },
         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xe2\x80\xa8--" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xe2\x80\xa8--" },
         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xc2\x85--" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xc2\x85--" },
         { 0, 0, "ab$", "ab" },          { 0, 0, "ab$", "ab" },
        { 0, 0, "ab$", "ab\r\n" },        { 0, 0 | F_NOMATCH, "ab$", "abab\n\n" },
         { PCRE_DOLLAR_ENDONLY, 0 | F_NOMATCH, "ab$", "abab\r\n" },
         { 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" },
         { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "a$", "aaa" },          { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "a$", "aaa" },
         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF, 0, "#$", "#\xc2\x85###\r#" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF, 0, "#$", "#\xc2\x85###\r#" },
         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "#$", "#\xe2\x80\xa9" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "#$", "#\xe2\x80\xa9" },
        { PCRE_NOTBOL | PCRE_NEWLINE_ANY, 0, "^a", "aa\naa" },        { PCRE_NOTBOL | PCRE_NEWLINE_ANY, 0 | F_NOMATCH, "^a", "aa\naa" },
         { PCRE_NOTBOL | PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "^a", "aa\naa" },          { PCRE_NOTBOL | PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "^a", "aa\naa" },
        { PCRE_NOTEOL | PCRE_NEWLINE_ANY, 0, "a$", "aa\naa" },        { PCRE_NOTEOL | PCRE_NEWLINE_ANY, 0 | F_NOMATCH, "a$", "aa\naa" },
        { PCRE_NOTEOL | PCRE_NEWLINE_ANY, 0, "a$", "aa\r\n" },        { PCRE_NOTEOL | PCRE_NEWLINE_ANY, 0 | F_NOMATCH, "a$", "aa\r\n" },
        { 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" },
         { PCRE_NOTEOL | PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "a$", "aa\naa" },          { PCRE_NOTEOL | PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "a$", "aa\naa" },
         { PCRE_NEWLINE_CR, 0, ".\\Z", "aaa" },          { PCRE_NEWLINE_CR, 0, ".\\Z", "aaa" },
         { PCRE_NEWLINE_CR | PCRE_UTF8, 0, "a\\Z", "aaa\r" },          { PCRE_NEWLINE_CR | PCRE_UTF8, 0, "a\\Z", "aaa\r" },
Line 190  static struct regression_test_case regression_test_cas Line 225  static struct regression_test_case regression_test_cas
         { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, ".\\Z", "aaa\xc2\x85" },          { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, ".\\Z", "aaa\xc2\x85" },
         { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, ".\\Z", "aaa\xe2\x80\xa8" },          { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, ".\\Z", "aaa\xe2\x80\xa8" },
         { MA, 0, "\\Aa", "aaa" },          { MA, 0, "\\Aa", "aaa" },
        { MA, 1, "\\Aa", "aaa" },        { MA, 1 | F_NOMATCH, "\\Aa", "aaa" },
         { MA, 1, "\\Ga", "aaa" },          { MA, 1, "\\Ga", "aaa" },
        { MA, 1, "\\Ga", "aba" },        { MA, 1 | F_NOMATCH, "\\Ga", "aba" },
         { MA, 0, "a\\z", "aaa" },          { MA, 0, "a\\z", "aaa" },
        { MA, 0, "a\\z", "aab" },        { MA, 0 | F_NOMATCH, "a\\z", "aab" },
   
         /* Brackets. */          /* Brackets. */
         { MUA, 0, "(ab|bb|cd)", "bacde" },          { MUA, 0, "(ab|bb|cd)", "bacde" },
Line 267  static struct regression_test_case regression_test_cas Line 302  static struct regression_test_case regression_test_cas
         { MUA, 0, "\\b\\w+\\B", "x,a_cd" },          { MUA, 0, "\\b\\w+\\B", "x,a_cd" },
         { 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" },
         { CMUA, 0, "[^b]+(a*)([^c]?d{3})", "aaaaddd" },          { CMUA, 0, "[^b]+(a*)([^c]?d{3})", "aaaaddd" },
           { CMUAP, 0, "\xe1\xbd\xb8{2}", "\xe1\xbf\xb8#\xe1\xbf\xb8\xe1\xbd\xb8" },
           { CMUA, 0, "[^\xf0\x90\x90\x80]{2,4}@", "\xf0\x90\x90\xa8\xf0\x90\x90\x80###\xf0\x90\x90\x80@@@" },
           { CMUA, 0, "[^\xe1\xbd\xb8][^\xc3\xa9]", "\xe1\xbd\xb8\xe1\xbf\xb8\xc3\xa9\xc3\x89#" },
           { MUA, 0, "[^\xe1\xbd\xb8][^\xc3\xa9]", "\xe1\xbd\xb8\xe1\xbf\xb8\xc3\xa9\xc3\x89#" },
           { MUA, 0, "[^\xe1\xbd\xb8]{3,}?", "##\xe1\xbd\xb8#\xe1\xbd\xb8#\xc3\x89#\xe1\xbd\xb8" },
   
           /* Bracket repeats with limit. */
           { MUA, 0, "(?:(ab){2}){5}M", "abababababababababababM" },
           { MUA, 0, "(?:ab|abab){1,5}M", "abababababababababababM" },
           { MUA, 0, "(?>ab|abab){1,5}M", "abababababababababababM" },
           { MUA, 0, "(?:ab|abab){1,5}?M", "abababababababababababM" },
           { MUA, 0, "(?>ab|abab){1,5}?M", "abababababababababababM" },
           { MUA, 0, "(?:(ab){1,4}?){1,3}?M", "abababababababababababababM" },
           { MUA, 0, "(?:(ab){1,4}){1,3}abababababababababababM", "ababababababababababababM" },
           { MUA, 0 | F_NOMATCH, "(?:(ab){1,4}){1,3}abababababababababababM", "abababababababababababM" },
           { MUA, 0, "(ab){4,6}?M", "abababababababM" },
   
         /* Basic character sets. */          /* Basic character sets. */
         { MUA, 0, "(?:\\s)+(?:\\S)+", "ab \t\xc3\xa9\xe6\x92\xad " },          { MUA, 0, "(?:\\s)+(?:\\S)+", "ab \t\xc3\xa9\xe6\x92\xad " },
         { MUA, 0, "(\\w)*(k)(\\W)?\?", "abcdef abck11" },          { MUA, 0, "(\\w)*(k)(\\W)?\?", "abcdef abck11" },
Line 278  static struct regression_test_case regression_test_cas Line 329  static struct regression_test_case regression_test_cas
   
         /* Unicode properties. */          /* Unicode properties. */
         { MUAP, 0, "[1-5\xc3\xa9\\w]", "\xc3\xa1_" },          { MUAP, 0, "[1-5\xc3\xa9\\w]", "\xc3\xa1_" },
        { MUAP, 0, "[\xc3\x81\\p{Ll}]", "A_\xc3\x89\xc3\xa1" },        { MUAP, 0 | F_PROPERTY, "[\xc3\x81\\p{Ll}]", "A_\xc3\x89\xc3\xa1" },
         { MUAP, 0, "[\\Wd-h_x-z]+", "a\xc2\xa1#_yhzdxi" },          { MUAP, 0, "[\\Wd-h_x-z]+", "a\xc2\xa1#_yhzdxi" },
        { MUAP, 0, "[\\P{Any}]", "abc" },        { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\\P{Any}]", "abc" },
        { MUAP, 0, "[^\\p{Any}]", "abc" },        { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\\p{Any}]", "abc" },
        { MUAP, 0, "[\\P{Any}\xc3\xa1-\xc3\xa8]", "abc" },        { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\\P{Any}\xc3\xa1-\xc3\xa8]", "abc" },
        { MUAP, 0, "[^\\p{Any}\xc3\xa1-\xc3\xa8]", "abc" },        { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\\p{Any}\xc3\xa1-\xc3\xa8]", "abc" },
        { MUAP, 0, "[\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },        { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },
        { MUAP, 0, "[^\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },        { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },
        { MUAP, 0, "[\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },        { MUAP, 0 | F_PROPERTY, "[\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },
        { MUAP, 0, "[^\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },        { MUAP, 0 | F_PROPERTY, "[^\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },
         { MUAP, 0, "[b-\xc3\xa9\\s]", "a\xc\xe6\x92\xad" },          { MUAP, 0, "[b-\xc3\xa9\\s]", "a\xc\xe6\x92\xad" },
         { CMUAP, 0, "[\xc2\x85-\xc2\x89\xc3\x89]", "\xc2\x84\xc3\xa9" },          { CMUAP, 0, "[\xc2\x85-\xc2\x89\xc3\x89]", "\xc2\x84\xc3\xa9" },
         { MUAP, 0, "[^b-d^&\\s]{3,}", "db^ !a\xe2\x80\xa8_ae" },          { MUAP, 0, "[^b-d^&\\s]{3,}", "db^ !a\xe2\x80\xa8_ae" },
        { 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" },
        { 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" },
         { 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" },
        { 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" },
        { 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#" },
         { PCRE_UCP, 0, "[a-b\\s]{2,5}[^a]", "AB  baaa" },          { PCRE_UCP, 0, "[a-b\\s]{2,5}[^a]", "AB  baaa" },
   
         /* Possible empty brackets. */          /* Possible empty brackets. */
Line 312  static struct regression_test_case regression_test_cas Line 363  static struct regression_test_case regression_test_cas
   
         /* Start offset. */          /* Start offset. */
         { MUA, 3, "(\\d|(?:\\w)*\\w)+", "0ac01Hb" },          { MUA, 3, "(\\d|(?:\\w)*\\w)+", "0ac01Hb" },
        { MUA, 4, "(\\w\\W\\w)+", "ab#d" },        { MUA, 4 | F_NOMATCH, "(\\w\\W\\w)+", "ab#d" },
        { MUA, 2, "(\\w\\W\\w)+", "ab#d" },        { MUA, 2 | F_NOMATCH, "(\\w\\W\\w)+", "ab#d" },
         { MUA, 1, "(\\w\\W\\w)+", "ab#d" },          { MUA, 1, "(\\w\\W\\w)+", "ab#d" },
   
         /* Newline. */          /* Newline. */
Line 327  static struct regression_test_case regression_test_cas Line 378  static struct regression_test_case regression_test_cas
         { 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" },
         { 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" },
         { 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" },
        { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".(.).", "\xe2\x80\xa8\nb\r" },        { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0 | F_NOMATCH, ".(.).", "\xe2\x80\xa8\nb\r" },
         { PCRE_NEWLINE_ANY, 0, "(.)(.)", "#\x85#\r#\n#\r\n#\x84" },          { PCRE_NEWLINE_ANY, 0, "(.)(.)", "#\x85#\r#\n#\r\n#\x84" },
         { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.+)#", "#\rMn\xc2\x85#\n###" },          { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.+)#", "#\rMn\xc2\x85#\n###" },
         { PCRE_BSR_ANYCRLF, 0, "\\R", "\r" },          { PCRE_BSR_ANYCRLF, 0, "\\R", "\r" },
Line 335  static struct regression_test_case regression_test_cas Line 386  static struct regression_test_case regression_test_cas
         { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\xe2\x80\xa8#c" },          { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\xe2\x80\xa8#c" },
         { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\r\nc" },          { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\r\nc" },
         { 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" },
        { MUA, 0, "\\R+", "ab" },        { MUA, 0 | F_NOMATCH, "\\R+", "ab" },
         { MUA, 0, "\\R+", "ab\r\n\r" },          { MUA, 0, "\\R+", "ab\r\n\r" },
         { MUA, 0, "\\R*", "ab\r\n\r" },          { MUA, 0, "\\R*", "ab\r\n\r" },
         { MUA, 0, "\\R*", "\r\n\r" },          { MUA, 0, "\\R*", "\r\n\r" },
Line 343  static struct regression_test_case regression_test_cas Line 394  static struct regression_test_case regression_test_cas
         { 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" },
         { MUA, 0, "\\R{2,}", "\r\nab\n\n\n\r\r\r" },          { MUA, 0, "\\R{2,}", "\r\nab\n\n\n\r\r\r" },
         { 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" },
        { MUA, 0, "\\R+\\R\\R", "\r\n\r\n" },        { MUA, 0 | F_NOMATCH, "\\R+\\R\\R", "\r\n\r\n" },
         { MUA, 0, "\\R+\\R\\R", "\r\r\r" },          { MUA, 0, "\\R+\\R\\R", "\r\r\r" },
         { MUA, 0, "\\R*\\R\\R", "\n\r" },          { MUA, 0, "\\R*\\R\\R", "\n\r" },
        { MUA, 0, "\\R{2,4}\\R\\R", "\r\r\r" },        { MUA, 0 | F_NOMATCH, "\\R{2,4}\\R\\R", "\r\r\r" },
         { MUA, 0, "\\R{2,4}\\R\\R", "\r\r\r\r" },          { MUA, 0, "\\R{2,4}\\R\\R", "\r\r\r\r" },
   
         /* Atomic groups (no fallback from "next" direction). */          /* Atomic groups (no fallback from "next" direction). */
        { MUA, 0, "(?>ab)ab", "bab" },        { MUA, 0 | F_NOMATCH, "(?>ab)ab", "bab" },
        { MUA, 0, "(?>(ab))ab", "bab" },        { MUA, 0 | F_NOMATCH, "(?>(ab))ab", "bab" },
         { 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",
                         "bababcdedefgheijijklmlmnop" },                          "bababcdedefgheijijklmlmnop" },
         { MUA, 0, "(?>a(b)+a|(ab)?\?(b))an", "abban" },          { MUA, 0, "(?>a(b)+a|(ab)?\?(b))an", "abban" },
Line 379  static struct regression_test_case regression_test_cas Line 430  static struct regression_test_case regression_test_cas
         { 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" },
         { 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" },
         { 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" },
        { MUA, 0, "\\X", "\xcc\x8d\xcc\x8d" },        { MUA, 0 | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d" },
        { MUA, 0, "\\X", "\xcc\x8d\xcc\x8d#\xcc\x8d\xcc\x8d" },        { MUA, 0 | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d#\xcc\x8d\xcc\x8d" },
        { MUA, 0, "\\X+..", "\xcc\x8d#\xcc\x8d#\xcc\x8d\xcc\x8d" },        { MUA, 0 | F_PROPERTY, "\\X+..", "\xcc\x8d#\xcc\x8d#\xcc\x8d\xcc\x8d" },
        { MUA, 0, "\\X{2,4}", "abcdef" },        { MUA, 0 | F_PROPERTY, "\\X{2,4}", "abcdef" },
        { MUA, 0, "\\X{2,4}?", "abcdef" },        { MUA, 0 | F_PROPERTY, "\\X{2,4}?", "abcdef" },
        { MUA, 0, "\\X{2,4}..", "#\xcc\x8d##" },        { MUA, 0 | F_NOMATCH | F_PROPERTY, "\\X{2,4}..", "#\xcc\x8d##" },
        { MUA, 0, "\\X{2,4}..", "#\xcc\x8d#\xcc\x8d##" },        { MUA, 0 | F_PROPERTY, "\\X{2,4}..", "#\xcc\x8d#\xcc\x8d##" },
         { MUA, 0, "(c(ab)?+ab)+", "cabcababcab" },          { MUA, 0, "(c(ab)?+ab)+", "cabcababcab" },
         { MUA, 0, "(?>(a+)b)+aabab", "aaaabaaabaabab" },          { MUA, 0, "(?>(a+)b)+aabab", "aaaabaaabaabab" },
   
Line 420  static struct regression_test_case regression_test_cas Line 471  static struct regression_test_case regression_test_cas
         { MUA, 0, "((b*))++m", "bxbbxbbbxbbm" },          { MUA, 0, "((b*))++m", "bxbbxbbbxbbm" },
         { MUA, 0, "((b*))*+m", "bxbbxbbbxm" },          { MUA, 0, "((b*))*+m", "bxbbxbbbxm" },
         { MUA, 0, "((b*))*+m", "bxbbxbbbxbbm" },          { MUA, 0, "((b*))*+m", "bxbbxbbbxbbm" },
        { 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" },
         { MUA, 0, "((?:b)++a)+(cd)*+m", "bbababbacdcdnbbababbacdcdm" },          { MUA, 0, "((?:b)++a)+(cd)*+m", "bbababbacdcdnbbababbacdcdm" },
         { MUA, 0, "((?:(b))++a)+((c)d)*+m", "bbababbacdcdnbbababbacdcdm" },          { MUA, 0, "((?:(b))++a)+((c)d)*+m", "bbababbacdcdnbbababbacdcdm" },
         { MUA, 0, "(?:(?:(?:ab)*+k)++(?:n(?:cd)++)*+)*+m", "ababkkXababkkabkncXababkkabkncdcdncdXababkkabkncdcdncdkkabkncdXababkkabkncdcdncdkkabkncdm" },          { MUA, 0, "(?:(?:(?:ab)*+k)++(?:n(?:cd)++)*+)*+m", "ababkkXababkkabkncXababkkabkncdcdncdXababkkabkncdcdncdkkabkncdXababkkabkncdcdncdkkabkncdm" },
Line 444  static struct regression_test_case regression_test_cas Line 495  static struct regression_test_case regression_test_cas
         { 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" },
         { MUA, 0, "(a(?:\\1|)a){3}b", "aaaaaaaaaaab" },          { MUA, 0, "(a(?:\\1|)a){3}b", "aaaaaaaaaaab" },
         { 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" },
        { MUAP, 0, "(\\P{N})\\1{2,}", ".www." },        { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{2,}", ".www." },
        { MUAP, 0, "(\\P{N})\\1{0,2}", "wwwww." },        { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{0,2}", "wwwww." },
        { MUAP, 0, "(\\P{N})\\1{1,2}ww", "wwww" },        { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{1,2}ww", "wwww" },
        { MUAP, 0, "(\\P{N})\\1{1,2}ww", "wwwww" },        { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{1,2}ww", "wwwww" },
        { PCRE_UCP, 0, "(\\P{N})\\1{2,}", ".www." },        { PCRE_UCP, 0 | F_PROPERTY, "(\\P{N})\\1{2,}", ".www." },
         { CMUAP, 0, "(\xf0\x90\x90\x80)\\1", "\xf0\x90\x90\xa8\xf0\x90\x90\xa8" },
   
         /* Assertions. */          /* Assertions. */
         { MUA, 0, "(?=xx|yy|zz)\\w{4}", "abczzdefg" },          { MUA, 0, "(?=xx|yy|zz)\\w{4}", "abczzdefg" },
Line 464  static struct regression_test_case regression_test_cas Line 516  static struct regression_test_case regression_test_cas
         { MUA, 0, "(?>a(?>(b+))a(?=(..)))*?k", "acabbcabbaabacabaabbakk" },          { MUA, 0, "(?>a(?>(b+))a(?=(..)))*?k", "acabbcabbaabacabaabbakk" },
         { MUA, 0, "((?(?=(a))a)+k)", "bbak" },          { MUA, 0, "((?(?=(a))a)+k)", "bbak" },
         { MUA, 0, "((?(?=a)a)+k)", "bbak" },          { MUA, 0, "((?(?=a)a)+k)", "bbak" },
        { MUA, 0, "(?=(?>(a))m)amk", "a k" },        { MUA, 0 | F_NOMATCH, "(?=(?>(a))m)amk", "a k" },
        { MUA, 0, "(?!(?>(a))m)amk", "a k" },        { MUA, 0 | F_NOMATCH, "(?!(?>(a))m)amk", "a k" },
        { MUA, 0, "(?>(?=(a))am)amk", "a k" },        { MUA, 0 | F_NOMATCH, "(?>(?=(a))am)amk", "a k" },
         { 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" },
         { 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" },
         { MUA, 0, "(?:(?=ab)?[^n][^n])+m", "ababcdabcdcdabnababcdabcdcdabm" },          { MUA, 0, "(?:(?=ab)?[^n][^n])+m", "ababcdabcdcdabnababcdabcdcdabm" },
Line 477  static struct regression_test_case regression_test_cas Line 529  static struct regression_test_case regression_test_cas
         { MUA, 0, "((?!a)?\?(?!([^a]))?\?)+$", "acbab" },          { MUA, 0, "((?!a)?\?(?!([^a]))?\?)+$", "acbab" },
   
         /* Not empty, ACCEPT, FAIL */          /* Not empty, ACCEPT, FAIL */
        { MUA | PCRE_NOTEMPTY, 0, "a*", "bcx" },        { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a*", "bcx" },
         { MUA | PCRE_NOTEMPTY, 0, "a*", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "a*", "bcaad" },
         { MUA | PCRE_NOTEMPTY, 0, "a*?", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "a*?", "bcaad" },
         { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*", "bcaad" },          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*", "bcaad" },
         { MUA, 0, "a(*ACCEPT)b", "ab" },          { MUA, 0, "a(*ACCEPT)b", "ab" },
        { MUA | PCRE_NOTEMPTY, 0, "a*(*ACCEPT)b", "bcx" },        { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a*(*ACCEPT)b", "bcx" },
         { MUA | PCRE_NOTEMPTY, 0, "a*(*ACCEPT)b", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "a*(*ACCEPT)b", "bcaad" },
         { MUA | PCRE_NOTEMPTY, 0, "a*?(*ACCEPT)b", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "a*?(*ACCEPT)b", "bcaad" },
        { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*(*ACCEPT)b)", "bcx" },        { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "(?:z|a*(*ACCEPT)b)", "bcx" },
         { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*(*ACCEPT)b)", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*(*ACCEPT)b)", "bcaad" },
         { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*?(*ACCEPT)b)", "bcaad" },          { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*?(*ACCEPT)b)", "bcaad" },
         { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*(*ACCEPT)b", "bcx" },          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*(*ACCEPT)b", "bcx" },
        { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*(*ACCEPT)b", "" },        { MUA | PCRE_NOTEMPTY_ATSTART, 0 | F_NOMATCH, "a*(*ACCEPT)b", "" },
         { MUA, 0, "((a(*ACCEPT)b))", "ab" },          { MUA, 0, "((a(*ACCEPT)b))", "ab" },
         { MUA, 0, "(a(*FAIL)a|a)", "aaa" },          { MUA, 0, "(a(*FAIL)a|a)", "aaa" },
         { MUA, 0, "(?=ab(*ACCEPT)b)a", "ab" },          { MUA, 0, "(?=ab(*ACCEPT)b)a", "ab" },
Line 506  static struct regression_test_case regression_test_cas Line 558  static struct regression_test_case regression_test_cas
         { MUA, 0, "(?(?!(b))a*|b*)+k", "ababbalbbadabak" },          { MUA, 0, "(?(?!(b))a*|b*)+k", "ababbalbbadabak" },
         { MUA, 0, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },          { MUA, 0, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },
         { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },          { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },
        { 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" },
         { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" },          { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" },
         { MUA, 0, "(?(?=a)a*|b*)+k", "ababbalbbadabak" },          { MUA, 0, "(?(?=a)a*|b*)+k", "ababbalbbadabak" },
         { MUA, 0, "(?(?!b)a*|b*)+k", "ababbalbbadabak" },          { MUA, 0, "(?(?!b)a*|b*)+k", "ababbalbbadabak" },
Line 520  static struct regression_test_case regression_test_cas Line 572  static struct regression_test_case regression_test_cas
         { 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" },
         { MUA, 0, "(c)?\?(?(1)a|b)", "cdcaa" },          { MUA, 0, "(c)?\?(?(1)a|b)", "cdcaa" },
         { MUA, 0, "(c)?\?(?(1)a|b)", "cbb" },          { MUA, 0, "(c)?\?(?(1)a|b)", "cbb" },
        { MUA | PCRE_BUG, 0, "(?(?=(a))(aaaa|a?))+aak", "aaaaab aaaaak" },        { MUA, 0 | F_DIFF, "(?(?=(a))(aaaa|a?))+aak", "aaaaab aaaaak" },
         { MUA, 0, "(?(?=a)(aaaa|a?))+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?=a)(aaaa|a?))+aak", "aaaaab aaaaak" },
         { MUA, 0, "(?(?!(b))(aaaa|a?))+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?!(b))(aaaa|a?))+aak", "aaaaab aaaaak" },
         { MUA, 0, "(?(?!b)(aaaa|a?))+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?!b)(aaaa|a?))+aak", "aaaaab aaaaak" },
        { MUA | PCRE_BUG, 0, "(?(?=(a))a*)+aak", "aaaaab aaaaak" },        { MUA, 0 | F_DIFF, "(?(?=(a))a*)+aak", "aaaaab aaaaak" },
         { MUA, 0, "(?(?=a)a*)+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?=a)a*)+aak", "aaaaab aaaaak" },
         { MUA, 0, "(?(?!(b))a*)+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?!(b))a*)+aak", "aaaaab aaaaak" },
         { MUA, 0, "(?(?!b)a*)+aak", "aaaaab aaaaak" },          { MUA, 0, "(?(?!b)a*)+aak", "aaaaab aaaaak" },
Line 532  static struct regression_test_case regression_test_cas Line 584  static struct regression_test_case regression_test_cas
         { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)*l", "bc ddd abccabccl" },          { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)*l", "bc ddd abccabccl" },
         { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+?dd", "bcabcacdb bdddd" },          { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+?dd", "bcabcacdb bdddd" },
         { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+l", "ababccddabdbccd abcccl" },          { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+l", "ababccddabdbccd abcccl" },
           { MUA, 0, "((?:a|aa)(?(1)aaa))x", "aax" },
   
         /* Set start of match. */          /* Set start of match. */
         { MUA, 0, "(?:\\Ka)*aaaab", "aaaaaaaa aaaaaaabb" },          { MUA, 0, "(?:\\Ka)*aaaab", "aaaaaaaa aaaaaaabb" },
         { MUA, 0, "(?>\\Ka\\Ka)*aaaab", "aaaaaaaa aaaaaaaaaabb" },          { MUA, 0, "(?>\\Ka\\Ka)*aaaab", "aaaaaaaa aaaaaaaaaabb" },
         { MUA, 0, "a+\\K(?<=\\Gaa)a", "aaaaaa" },          { MUA, 0, "a+\\K(?<=\\Gaa)a", "aaaaaa" },
        { MUA | PCRE_NOTEMPTY, 0, "a\\K(*ACCEPT)b", "aa" },        { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a\\K(*ACCEPT)b", "aa" },
         { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a\\K(*ACCEPT)b", "aa" },          { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a\\K(*ACCEPT)b", "aa" },
   
         /* First line. */          /* First line. */
        { MUA | PCRE_FIRSTLINE, 0, "\\p{Any}a", "bb\naaa" },        { MUA | PCRE_FIRSTLINE, 0 | F_PROPERTY, "\\p{Any}a", "bb\naaa" },
        { MUA | PCRE_FIRSTLINE, 0, "\\p{Any}a", "bb\r\naaa" },        { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH | F_PROPERTY, "\\p{Any}a", "bb\r\naaa" },
         { MUA | PCRE_FIRSTLINE, 0, "(?<=a)", "a" },          { MUA | PCRE_FIRSTLINE, 0, "(?<=a)", "a" },
        { MUA | PCRE_FIRSTLINE, 0, "[^a][^b]", "ab" },        { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[^a][^b]", "ab" },
        { MUA | PCRE_FIRSTLINE, 0, "a", "\na" },        { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "a", "\na" },
        { MUA | PCRE_FIRSTLINE, 0, "[abc]", "\na" },        { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[abc]", "\na" },
        { MUA | PCRE_FIRSTLINE, 0, "^a", "\na" },        { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^a", "\na" },
        { MUA | PCRE_FIRSTLINE, 0, "^(?<=\n)", "\na" },        { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^(?<=\n)", "\na" },
        { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0, "#", "\xc2\x85#" },        { MUA | PCRE_FIRSTLINE, 0, "\xf0\x90\x90\x80", "\xf0\x90\x90\x80" },
        { PCRE_MULTILINE | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0, "#", "\x85#" },        { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\xc2\x85#" },
        { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0, "^#", "\xe2\x80\xa8#" },        { PCRE_MULTILINE | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\x85#" },
        { 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#" },
         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_PROPERTY, "\\p{Any}", "\r\na" },
         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, ".", "\r" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, ".", "\r" },
         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "a", "\ra" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "a", "\ra" },
        { 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" },
        { 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" },
         { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 1, ".", "\r\n" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 1, ".", "\r\n" },
           { PCRE_FIRSTLINE | PCRE_NEWLINE_LF | PCRE_DOTALL, 0 | F_NOMATCH, "ab.", "ab" },
   
         /* Recurse. */          /* Recurse. */
         { MUA, 0, "(a)(?1)", "aa" },          { MUA, 0, "(a)(?1)", "aa" },
         { MUA, 0, "((a))(?1)", "aa" },          { MUA, 0, "((a))(?1)", "aa" },
         { MUA, 0, "(b|a)(?1)", "aa" },          { MUA, 0, "(b|a)(?1)", "aa" },
         { MUA, 0, "(b|(a))(?1)", "aa" },          { MUA, 0, "(b|(a))(?1)", "aa" },
        { MUA, 0, "((a)(b)(?:a*))(?1)", "aba" },        { MUA, 0 | F_NOMATCH, "((a)(b)(?:a*))(?1)", "aba" },
         { MUA, 0, "((a)(b)(?:a*))(?1)", "abab" },          { MUA, 0, "((a)(b)(?:a*))(?1)", "abab" },
         { MUA, 0, "((a+)c(?2))b(?1)", "aacaabaca" },          { MUA, 0, "((a+)c(?2))b(?1)", "aacaabaca" },
         { MUA, 0, "((?2)b|(a)){2}(?1)", "aabab" },          { MUA, 0, "((?2)b|(a)){2}(?1)", "aabab" },
Line 572  static struct regression_test_case regression_test_cas Line 627  static struct regression_test_case regression_test_cas
         { MUA, 0, "(?1)(((a(*ACCEPT)))b)", "axaa" },          { MUA, 0, "(?1)(((a(*ACCEPT)))b)", "axaa" },
         { MUA, 0, "(?1)(?(DEFINE) (((ac(*ACCEPT)))b) )", "akaac" },          { MUA, 0, "(?1)(?(DEFINE) (((ac(*ACCEPT)))b) )", "akaac" },
         { MUA, 0, "(a+)b(?1)b\\1", "abaaabaaaaa" },          { MUA, 0, "(a+)b(?1)b\\1", "abaaabaaaaa" },
        { MUA, 0, "(?(DEFINE)(aa|a))(?1)ab", "aab" },        { MUA, 0 | F_NOMATCH, "(?(DEFINE)(aa|a))(?1)ab", "aab" },
         { MUA, 0, "(?(DEFINE)(a\\Kb))(?1)+ababc", "abababxabababc" },          { MUA, 0, "(?(DEFINE)(a\\Kb))(?1)+ababc", "abababxabababc" },
         { MUA, 0, "(a\\Kb)(?1)+ababc", "abababxababababc" },          { MUA, 0, "(a\\Kb)(?1)+ababc", "abababxababababc" },
        { MUA, 0, "(a\\Kb)(?1)+ababc", "abababxababababxc" },        { MUA, 0 | F_NOMATCH, "(a\\Kb)(?1)+ababc", "abababxababababxc" },
         { MUA, 0, "b|<(?R)*>", "<<b>" },          { MUA, 0, "b|<(?R)*>", "<<b>" },
         { MUA, 0, "(a\\K){0}(?:(?1)b|ac)", "ac" },          { MUA, 0, "(a\\K){0}(?:(?1)b|ac)", "ac" },
         { 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" },
Line 585  static struct regression_test_case regression_test_cas Line 640  static struct regression_test_case regression_test_cas
         { MUA, 0, "(?(R0)aa|bb(?R))", "abba aabb bbaa" },          { MUA, 0, "(?(R0)aa|bb(?R))", "abba aabb bbaa" },
         { MUA, 0, "((?(R)(?:aaaa|a)|(?:(aaaa)|(a)))+)(?1)$", "aaaaaaaaaa aaaa" },          { MUA, 0, "((?(R)(?:aaaa|a)|(?:(aaaa)|(a)))+)(?1)$", "aaaaaaaaaa aaaa" },
         { MUA, 0, "(?P<Name>a(?(R&Name)a|b))(?1)", "aab abb abaa" },          { MUA, 0, "(?P<Name>a(?(R&Name)a|b))(?1)", "aab abb abaa" },
           { MUA, 0, "((?(R)a|(?1)){3})", "XaaaaaaaaaX" },
           { MUA, 0, "((?:(?(R)a|(?1))){3})", "XaaaaaaaaaX" },
           { MUA, 0, "((?(R)a|(?1)){1,3})aaaaaa", "aaaaaaaaXaaaaaaaaa" },
           { MUA, 0, "((?(R)a|(?1)){1,3}?)M", "aaaM" },
   
           /* 16 bit specific tests. */
           { CMA, 0 | F_FORCECONV, "\xc3\xa1", "\xc3\x81\xc3\xa1" },
           { CMA, 0 | F_FORCECONV, "\xe1\xbd\xb8", "\xe1\xbf\xb8\xe1\xbd\xb8" },
           { CMA, 0 | F_FORCECONV, "[\xc3\xa1]", "\xc3\x81\xc3\xa1" },
           { CMA, 0 | F_FORCECONV, "[\xe1\xbd\xb8]", "\xe1\xbf\xb8\xe1\xbd\xb8" },
           { CMA, 0 | F_FORCECONV, "[a-\xed\xb0\x80]", "A" },
           { CMA, 0 | F_NO8 | F_FORCECONV, "[a-\\x{dc00}]", "B" },
           { CMA, 0 | F_NO8 | F_NOMATCH | F_FORCECONV, "[b-\\x{dc00}]", "a" },
           { 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" },
           { 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#" },
           { 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" },
           { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xed\xb3\xbf]", "\xed\x9f\xbf\xed\xa0\x83" },
           { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xed\xb3\xbf]", "\xed\xb4\x80\xed\xb3\xb0" },
           { CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\x9f\xbf\xed\xa0\x83" },
           { CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\xb4\x80\xed\xb3\xb0" },
           { 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#" },
           { 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" },
           { MA, 0 | F_FORCECONV, "[^\xed\xb0\x80]{3,}?", "##\xed\xb0\x80#\xed\xb0\x80#\xc3\x89#\xed\xb0\x80" },
           { MA, 0 | F_NO8 | F_FORCECONV, "[^\\x{dc00}]{3,}?", "##\xed\xb0\x80#\xed\xb0\x80#\xc3\x89#\xed\xb0\x80" },
           { CMA, 0 | F_FORCECONV, ".\\B.", "\xed\xa0\x80\xed\xb0\x80" },
           { 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" },
           { CMA, 0 | F_FORCECONV, "\\d*\\s*\\w*\xed\xa0\x80\xed\xa0\x80", "\xed\xa0\x80\xed\xa0\x80" },
           { CMA, 0 | F_FORCECONV | F_NOMATCH, "\\d*?\\D*?\\s*?\\S*?\\w*?\\W*?##", "\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80#" },
           { CMA | PCRE_EXTENDED, 0 | F_FORCECONV, "\xed\xa0\x80 \xed\xb0\x80 !", "\xed\xa0\x80\xed\xb0\x80!" },
           { CMA, 0 | F_FORCECONV, "\xed\xa0\x80+#[^#]+\xed\xa0\x80", "\xed\xa0\x80#a\xed\xa0\x80" },
           { CMA, 0 | F_FORCECONV, "(\xed\xa0\x80+)#\\1", "\xed\xa0\x80\xed\xa0\x80#\xed\xa0\x80\xed\xa0\x80" },
           { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0 | F_NO8 | F_FORCECONV, "^-", "a--\xe2\x80\xa8--" },
           { PCRE_BSR_UNICODE, 0 | F_NO8 | F_FORCECONV, "\\R", "ab\xe2\x80\xa8" },
           { 0, 0 | F_NO8 | F_FORCECONV, "\\v", "ab\xe2\x80\xa9" },
           { 0, 0 | F_NO8 | F_FORCECONV, "\\h", "ab\xe1\xa0\x8e" },
           { 0, 0 | F_NO8 | F_FORCECONV, "\\v+?\\V+?#", "\xe2\x80\xa9\xe2\x80\xa9\xef\xbf\xbf\xef\xbf\xbf#" },
           { 0, 0 | F_NO8 | F_FORCECONV, "\\h+?\\H+?#", "\xe1\xa0\x8e\xe1\xa0\x8e\xef\xbf\xbf\xef\xbf\xbf#" },
   
           /* Partial matching. */
           { MUA | PCRE_PARTIAL_SOFT, 0, "ab", "a" },
           { MUA | PCRE_PARTIAL_SOFT, 0, "ab|a", "a" },
           { MUA | PCRE_PARTIAL_HARD, 0, "ab|a", "a" },
           { MUA | PCRE_PARTIAL_SOFT, 0, "\\b#", "a" },
           { MUA | PCRE_PARTIAL_SOFT, 0, "(?<=a)b", "a" },
           { MUA | PCRE_PARTIAL_SOFT, 0, "abc|(?<=xxa)bc", "xxab" },
           { MUA | PCRE_PARTIAL_SOFT, 0, "a\\B", "a" },
           { MUA | PCRE_PARTIAL_HARD, 0, "a\\b", "a" },
   
           /* (*MARK) verb. */
           { MUA, 0, "a(*MARK:aa)a", "ababaa" },
           { MUA, 0 | F_NOMATCH, "a(*:aa)a", "abab" },
           { MUA, 0, "a(*:aa)(b(*:bb)b|bc)", "abc" },
           { MUA, 0 | F_NOMATCH, "a(*:1)x|b(*:2)y", "abc" },
           { MUA, 0, "(?>a(*:aa))b|ac", "ac" },
           { MUA, 0, "(?(DEFINE)(a(*:aa)))(?1)", "a" },
           { MUA, 0 | F_NOMATCH, "(?(DEFINE)((a)(*:aa)))(?1)b", "aa" },
           { MUA, 0, "(?(DEFINE)(a(*:aa)))a(?1)b|aac", "aac" },
           { MUA, 0, "(a(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
           { MUA, 0, "(a(*:aa)){0}(?:b(?1)b)+", "babba" },
           { MUA, 0 | F_NOMATCH | F_STUDY, "(a(*:aa)){0}(?:b(?1)b)+", "ba" },
           { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
           { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b)+", "babba" },
           { MUA, 0 | F_NOMATCH | F_STUDY, "(a\\K(*:aa)){0}(?:b(?1)b)+", "ba" },
           { MUA, 0 | F_NOMATCH | F_STUDY, "(*:mark)m", "a" },
   
           /* (*COMMIT) verb. */
           { MUA, 0 | F_NOMATCH, "a(*COMMIT)b", "ac" },
           { MUA, 0, "aa(*COMMIT)b", "xaxaab" },
           { MUA, 0 | F_NOMATCH, "a(*COMMIT)(*:msg)b|ac", "ac" },
           { MUA, 0 | F_NOMATCH, "(a(*COMMIT)b)++", "abac" },
           { MUA, 0 | F_NOMATCH, "((a)(*COMMIT)b)++", "abac" },
           { MUA, 0 | F_NOMATCH, "(?=a(*COMMIT)b)ab|ad", "ad" },
   
           /* (*PRUNE) verb. */
           { MUA, 0, "aa\\K(*PRUNE)b", "aaab" },
           { MUA, 0, "aa(*PRUNE:bb)b|a", "aa" },
           { MUA, 0, "(a)(a)(*PRUNE)b|(a)", "aa" },
           { MUA, 0, "(a)(a)(a)(a)(a)(a)(a)(a)(*PRUNE)b|(a)", "aaaaaaaa" },
           { MUA | PCRE_PARTIAL_SOFT, 0, "a(*PRUNE)a|", "a" },
           { MUA | PCRE_PARTIAL_SOFT, 0, "a(*PRUNE)a|m", "a" },
           { MUA, 0 | F_NOMATCH, "(?=a(*PRUNE)b)ab|ad", "ad" },
           { MUA, 0, "a(*COMMIT)(*PRUNE)d|bc", "abc" },
           { MUA, 0, "(?=a(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
           { MUA, 0 | F_NOMATCH, "(*COMMIT)(?=a(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
           { MUA, 0, "(?=(a)(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
           { MUA, 0 | F_NOMATCH, "(*COMMIT)(?=(a)(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
           { MUA, 0, "(a(*COMMIT)b){0}a(?1)(*PRUNE)c|bc", "abc" },
           { MUA, 0 | F_NOMATCH, "(a(*COMMIT)b){0}a(*COMMIT)(?1)(*PRUNE)c|bc", "abc" },
           { MUA, 0, "(a(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
           { MUA, 0 | F_NOMATCH, "(*COMMIT)(a(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
           { MUA, 0, "((a)(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
           { MUA, 0 | F_NOMATCH, "(*COMMIT)((a)(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
           { MUA, 0, "(?>a(*COMMIT)b)*abab(*PRUNE)d|ba", "ababab" },
           { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)*abab(*PRUNE)d|ba", "ababab" },
           { MUA, 0, "(?>a(*COMMIT)b)+abab(*PRUNE)d|ba", "ababab" },
           { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)+abab(*PRUNE)d|ba", "ababab" },
           { MUA, 0, "(?>a(*COMMIT)b)?ab(*PRUNE)d|ba", "aba" },
           { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)?ab(*PRUNE)d|ba", "aba" },
           { MUA, 0, "(?>a(*COMMIT)b)*?n(*PRUNE)d|ba", "abababn" },
           { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)*?n(*PRUNE)d|ba", "abababn" },
           { MUA, 0, "(?>a(*COMMIT)b)+?n(*PRUNE)d|ba", "abababn" },
           { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)+?n(*PRUNE)d|ba", "abababn" },
           { MUA, 0, "(?>a(*COMMIT)b)??n(*PRUNE)d|bn", "abn" },
           { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)??n(*PRUNE)d|bn", "abn" },
   
           /* (*SKIP) verb. */
           { MUA, 0 | F_NOMATCH, "(?=a(*SKIP)b)ab|ad", "ad" },
   
           /* (*THEN) verb. */
           { MUA, 0, "((?:a(*THEN)|aab)(*THEN)c|a+)+m", "aabcaabcaabcaabcnacm" },
           { MUA, 0 | F_NOMATCH, "((?:a(*THEN)|aab)(*THEN)c|a+)+m", "aabcm" },
           { MUA, 0, "((?:a(*THEN)|aab)c|a+)+m", "aabcaabcnmaabcaabcm" },
           { MUA, 0, "((?:a|aab)(*THEN)c|a+)+m", "aam" },
           { MUA, 0, "((?:a(*COMMIT)|aab)(*THEN)c|a+)+m", "aam" },
           { MUA, 0, "(?(?=a(*THEN)b)ab|ad)", "ad" },
           { MUA, 0, "(?(?!a(*THEN)b)ad|add)", "add" },
           { MUA, 0 | F_NOMATCH, "(?(?=a)a(*THEN)b|ad)", "ad" },
           { MUA, 0, "(?!(?(?=a)ab|b(*THEN)d))bn|bnn", "bnn" },
   
         /* Deep recursion. */          /* Deep recursion. */
         { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },          { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },
         { MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " },          { MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " },
        { MUA, 0, "((a?)+)+b", "aaaaaaaaaaaaa b" },        { MUA, 0, "((a?)+)+b", "aaaaaaaaaaaa b" },
   
         /* Deep recursion: Stack limit reached. */          /* Deep recursion: Stack limit reached. */
        { 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" },
        { MA, 0, "(?:a+)+b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },        { MA, 0 | F_NOMATCH, "(?:a+)+b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
        { MA, 0, "(?:a+?)+?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },        { MA, 0 | F_NOMATCH, "(?:a+?)+?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
        { MA, 0, "(?:a*)*b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },        { MA, 0 | F_NOMATCH, "(?:a*)*b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
        { MA, 0, "(?:a*?)*?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },        { MA, 0 | F_NOMATCH, "(?:a*?)*?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
   
         { 0, 0, NULL, NULL }          { 0, 0, NULL, NULL }
 };  };
   
   static const unsigned char *tables(int mode)
   {
           /* The purpose of this function to allow valgrind
           for reporting invalid reads and writes. */
           static unsigned char *tables_copy;
           const char *errorptr;
           int erroroffset;
           unsigned char *default_tables;
   #if defined SUPPORT_PCRE8
           pcre *regex;
           char null_str[1] = { 0 };
   #elif defined SUPPORT_PCRE16
           pcre16 *regex;
           PCRE_UCHAR16 null_str[1] = { 0 };
   #elif defined SUPPORT_PCRE32
           pcre32 *regex;
           PCRE_UCHAR32 null_str[1] = { 0 };
   #endif
   
           if (mode) {
                   if (tables_copy)
                           free(tables_copy);
                   tables_copy = NULL;
                   return NULL;
           }
   
           if (tables_copy)
                   return tables_copy;
   
           default_tables = NULL;
   #if defined SUPPORT_PCRE8
           regex = pcre_compile(null_str, 0, &errorptr, &erroroffset, NULL);
           if (regex) {
                   pcre_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
                   pcre_free(regex);
           }
   #elif defined SUPPORT_PCRE16
           regex = pcre16_compile(null_str, 0, &errorptr, &erroroffset, NULL);
           if (regex) {
                   pcre16_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
                   pcre16_free(regex);
           }
   #elif defined SUPPORT_PCRE32
           regex = pcre32_compile(null_str, 0, &errorptr, &erroroffset, NULL);
           if (regex) {
                   pcre32_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
                   pcre32_free(regex);
           }
   #endif
           /* Shouldn't ever happen. */
           if (!default_tables)
                   return NULL;
   
           /* Unfortunately this value cannot get from pcre_fullinfo.
           Since this is a test program, this is acceptable at the moment. */
           tables_copy = (unsigned char *)malloc(1088);
           if (!tables_copy)
                   return NULL;
   
           memcpy(tables_copy, default_tables, 1088);
           return tables_copy;
   }
   
   #ifdef SUPPORT_PCRE8
   static pcre_jit_stack* callback8(void *arg)
   {
           return (pcre_jit_stack *)arg;
   }
   #endif
   
   #ifdef SUPPORT_PCRE16
   static pcre16_jit_stack* callback16(void *arg)
   {
           return (pcre16_jit_stack *)arg;
   }
   #endif
   
   #ifdef SUPPORT_PCRE32
   static pcre32_jit_stack* callback32(void *arg)
   {
           return (pcre32_jit_stack *)arg;
   }
   #endif
   
   #ifdef SUPPORT_PCRE8
   static pcre_jit_stack *stack8;
   
   static pcre_jit_stack *getstack8(void)
   {
           if (!stack8)
                   stack8 = pcre_jit_stack_alloc(1, 1024 * 1024);
           return stack8;
   }
   
   static void setstack8(pcre_extra *extra)
   {
           if (!extra) {
                   if (stack8)
                           pcre_jit_stack_free(stack8);
                   stack8 = NULL;
                   return;
           }
   
           pcre_assign_jit_stack(extra, callback8, getstack8());
   }
   #endif /* SUPPORT_PCRE8 */
   
   #ifdef SUPPORT_PCRE16
   static pcre16_jit_stack *stack16;
   
   static pcre16_jit_stack *getstack16(void)
   {
           if (!stack16)
                   stack16 = pcre16_jit_stack_alloc(1, 1024 * 1024);
           return stack16;
   }
   
   static void setstack16(pcre16_extra *extra)
   {
           if (!extra) {
                   if (stack16)
                           pcre16_jit_stack_free(stack16);
                   stack16 = NULL;
                   return;
           }
   
           pcre16_assign_jit_stack(extra, callback16, getstack16());
   }
   #endif /* SUPPORT_PCRE8 */
   
   #ifdef SUPPORT_PCRE32
   static pcre32_jit_stack *stack32;
   
   static pcre32_jit_stack *getstack32(void)
   {
           if (!stack32)
                   stack32 = pcre32_jit_stack_alloc(1, 1024 * 1024);
           return stack32;
   }
   
   static void setstack32(pcre32_extra *extra)
   {
           if (!extra) {
                   if (stack32)
                           pcre32_jit_stack_free(stack32);
                   stack32 = NULL;
                   return;
           }
   
           pcre32_assign_jit_stack(extra, callback32, getstack32());
   }
   #endif /* SUPPORT_PCRE8 */
   
   #ifdef SUPPORT_PCRE16
   
   static int convert_utf8_to_utf16(const char *input, PCRE_UCHAR16 *output, int *offsetmap, int max_length)
   {
           unsigned char *iptr = (unsigned char*)input;
           PCRE_UCHAR16 *optr = output;
           unsigned int c;
   
           if (max_length == 0)
                   return 0;
   
           while (*iptr && max_length > 1) {
                   c = 0;
                   if (offsetmap)
                           *offsetmap++ = (int)(iptr - (unsigned char*)input);
   
                   if (!(*iptr & 0x80))
                           c = *iptr++;
                   else if (!(*iptr & 0x20)) {
                           c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
                           iptr += 2;
                   } else if (!(*iptr & 0x10)) {
                           c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
                           iptr += 3;
                   } else if (!(*iptr & 0x08)) {
                           c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
                           iptr += 4;
                   }
   
                   if (c < 65536) {
                           *optr++ = c;
                           max_length--;
                   } else if (max_length <= 2) {
                           *optr = '\0';
                           return (int)(optr - output);
                   } else {
                           c -= 0x10000;
                           *optr++ = 0xd800 | ((c >> 10) & 0x3ff);
                           *optr++ = 0xdc00 | (c & 0x3ff);
                           max_length -= 2;
                           if (offsetmap)
                                   offsetmap++;
                   }
           }
           if (offsetmap)
                   *offsetmap = (int)(iptr - (unsigned char*)input);
           *optr = '\0';
           return (int)(optr - output);
   }
   
   static int copy_char8_to_char16(const char *input, PCRE_UCHAR16 *output, int max_length)
   {
           unsigned char *iptr = (unsigned char*)input;
           PCRE_UCHAR16 *optr = output;
   
           if (max_length == 0)
                   return 0;
   
           while (*iptr && max_length > 1) {
                   *optr++ = *iptr++;
                   max_length--;
           }
           *optr = '\0';
           return (int)(optr - output);
   }
   
   #define REGTEST_MAX_LENGTH16 4096
   static PCRE_UCHAR16 regtest_buf16[REGTEST_MAX_LENGTH16];
   static int regtest_offsetmap16[REGTEST_MAX_LENGTH16];
   
   #endif /* SUPPORT_PCRE16 */
   
   #ifdef SUPPORT_PCRE32
   
   static int convert_utf8_to_utf32(const char *input, PCRE_UCHAR32 *output, int *offsetmap, int max_length)
   {
           unsigned char *iptr = (unsigned char*)input;
           PCRE_UCHAR32 *optr = output;
           unsigned int c;
   
           if (max_length == 0)
                   return 0;
   
           while (*iptr && max_length > 1) {
                   c = 0;
                   if (offsetmap)
                           *offsetmap++ = (int)(iptr - (unsigned char*)input);
   
                   if (!(*iptr & 0x80))
                           c = *iptr++;
                   else if (!(*iptr & 0x20)) {
                           c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
                           iptr += 2;
                   } else if (!(*iptr & 0x10)) {
                           c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
                           iptr += 3;
                   } else if (!(*iptr & 0x08)) {
                           c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
                           iptr += 4;
                   }
   
                   *optr++ = c;
                   max_length--;
           }
           if (offsetmap)
                   *offsetmap = (int)(iptr - (unsigned char*)input);
           *optr = 0;
           return (int)(optr - output);
   }
   
   static int copy_char8_to_char32(const char *input, PCRE_UCHAR32 *output, int max_length)
   {
           unsigned char *iptr = (unsigned char*)input;
           PCRE_UCHAR32 *optr = output;
   
           if (max_length == 0)
                   return 0;
   
           while (*iptr && max_length > 1) {
                   *optr++ = *iptr++;
                   max_length--;
           }
           *optr = '\0';
           return (int)(optr - output);
   }
   
   #define REGTEST_MAX_LENGTH32 4096
   static PCRE_UCHAR32 regtest_buf32[REGTEST_MAX_LENGTH32];
   static int regtest_offsetmap32[REGTEST_MAX_LENGTH32];
   
   #endif /* SUPPORT_PCRE32 */
   
   static int check_ascii(const char *input)
   {
           const unsigned char *ptr = (unsigned char *)input;
           while (*ptr) {
                   if (*ptr > 127)
                           return 0;
                   ptr++;
           }
           return 1;
   }
   
 static int regression_tests(void)  static int regression_tests(void)
 {  {
         pcre *re;  
         struct regression_test_case *current = regression_test_cases;          struct regression_test_case *current = regression_test_cases;
         const char *error;          const char *error;
        pcre_extra *extra;        char *cpu_info;
        int utf8 = 0, ucp = 0; 
        int ovector1[32]; 
        int ovector2[32]; 
        int return_value1, return_value2; 
         int i, err_offs;          int i, err_offs;
        int total = 0, succesful = 0;        int is_successful, is_ascii_pattern, is_ascii_input;
         int total = 0;
         int successful = 0;
         int successful_row = 0;
         int counter = 0;          int counter = 0;
        int disabled_flags = PCRE_BUG;        int study_mode;
         int utf = 0, ucp = 0;
         int disabled_flags = 0;
 #ifdef SUPPORT_PCRE8
         pcre *re8;
         pcre_extra *extra8;
         pcre_extra dummy_extra8;
         int ovector8_1[32];
         int ovector8_2[32];
         int return_value8[2];
         unsigned char *mark8_1, *mark8_2;
 #endif
 #ifdef SUPPORT_PCRE16
         pcre16 *re16;
         pcre16_extra *extra16;
         pcre16_extra dummy_extra16;
         int ovector16_1[32];
         int ovector16_2[32];
         int return_value16[2];
         PCRE_UCHAR16 *mark16_1, *mark16_2;
         int length16;
 #endif
 #ifdef SUPPORT_PCRE32
         pcre32 *re32;
         pcre32_extra *extra32;
         pcre32_extra dummy_extra32;
         int ovector32_1[32];
         int ovector32_2[32];
         int return_value32[2];
         PCRE_UCHAR32 *mark32_1, *mark32_2;
         int length32;
 #endif
   
         /* This test compares the behaviour of interpreter and JIT. Although disabling          /* This test compares the behaviour of interpreter and JIT. Although disabling
        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
         still considered successful from pcre_jit_test point of view. */          still considered successful from pcre_jit_test point of view. */
   
        pcre_config(PCRE_CONFIG_UTF8, &utf8);#if defined SUPPORT_PCRE8
         pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);
 #elif defined SUPPORT_PCRE16
         pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);
 #elif defined SUPPORT_PCRE32
         pcre32_config(PCRE_CONFIG_JITTARGET, &cpu_info);
 #endif
 
         printf("Running JIT regression tests\n");
         printf("  target CPU of SLJIT compiler: %s\n", cpu_info);
 
 #if defined SUPPORT_PCRE8
         pcre_config(PCRE_CONFIG_UTF8, &utf);
         pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);          pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
        if (!utf8)#elif defined SUPPORT_PCRE16
                disabled_flags |= PCRE_UTF8;        pcre16_config(PCRE_CONFIG_UTF16, &utf);
         pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
 #elif defined SUPPORT_PCRE16
         pcre32_config(PCRE_CONFIG_UTF32, &utf);
         pcre32_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
 #endif
 
         if (!utf)
                 disabled_flags |= PCRE_UTF8 | PCRE_UTF16 | PCRE_UTF32;
         if (!ucp)          if (!ucp)
                 disabled_flags |= PCRE_UCP;                  disabled_flags |= PCRE_UCP;
   #ifdef SUPPORT_PCRE8
           printf("  in  8 bit mode with UTF-8  %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
   #endif
   #ifdef SUPPORT_PCRE16
           printf("  in 16 bit mode with UTF-16 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
   #endif
   #ifdef SUPPORT_PCRE32
           printf("  in 32 bit mode with UTF-32 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
   #endif
   
         printf("Running JIT regression tests with utf8 %s and ucp %s:\n", utf8 ? "enabled" : "disabled", ucp ? "enabled" : "disabled");  
         while (current->pattern) {          while (current->pattern) {
                 /* printf("\nPattern: %s :\n", current->pattern); */                  /* printf("\nPattern: %s :\n", current->pattern); */
                 total++;                  total++;
                   if (current->start_offset & F_PROPERTY) {
                           is_ascii_pattern = 0;
                           is_ascii_input = 0;
                   } else {
                           is_ascii_pattern = check_ascii(current->pattern);
                           is_ascii_input = check_ascii(current->input);
                   }
   
                   if (current->flags & PCRE_PARTIAL_SOFT)
                           study_mode = PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE;
                   else if (current->flags & PCRE_PARTIAL_HARD)
                           study_mode = PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE;
                   else
                           study_mode = PCRE_STUDY_JIT_COMPILE;
                 error = NULL;                  error = NULL;
                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
                 re8 = NULL;
                 if (!(current->start_offset & F_NO8))
                         re8 = pcre_compile(current->pattern,
                                 current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
                                 &error, &err_offs, tables(0));
   
                if (!re) {                extra8 = NULL;
                        if (utf8 && ucp)                if (re8) {
                                printf("\nCannot compile pattern: %s\n", current->pattern);                        error = NULL;
                        else {                        extra8 = pcre_study(re8, study_mode, &error);
                                /* Some patterns cannot be compiled when either of utf8                        if (!extra8) {
                                or ucp is disabled. We just skip them. */                                printf("\n8 bit: Cannot study pattern: %s\n", current->pattern);
                                printf(".");                                pcre_free(re8);
                                succesful++;                                re8 = NULL;
                         }                          }
                        current++;                        else if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
                        continue;                                printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);
                }                                pcre_free_study(extra8);
                                 pcre_free(re8);
                                 re8 = NULL;
                         }
                         extra8->flags |= PCRE_EXTRA_MARK;
                 } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO8))
                         printf("\n8 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
 #endif
 #ifdef SUPPORT_PCRE16
                 if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
                         convert_utf8_to_utf16(current->pattern, regtest_buf16, NULL, REGTEST_MAX_LENGTH16);
                 else
                         copy_char8_to_char16(current->pattern, regtest_buf16, REGTEST_MAX_LENGTH16);
   
                error = NULL;                re16 = NULL;
                extra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &error);                if (!(current->start_offset & F_NO16))
                if (!extra) {                        re16 = pcre16_compile(regtest_buf16,
                        printf("\nCannot study pattern: %s\n", current->pattern);                                current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
                        current++;                                &error, &err_offs, tables(0));
                        continue; 
                } 
   
                if (!(extra->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {                extra16 = NULL;
                        printf("\nJIT compiler does not support: %s\n", current->pattern);                if (re16) {
                        current++;                        error = NULL;
                        continue;                        extra16 = pcre16_study(re16, study_mode, &error);
                }                        if (!extra16) {
                                 printf("\n16 bit: Cannot study pattern: %s\n", current->pattern);
                                 pcre16_free(re16);
                                 re16 = NULL;
                         }
                         else if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
                                 printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);
                                 pcre16_free_study(extra16);
                                 pcre16_free(re16);
                                 re16 = NULL;
                         }
                         extra16->flags |= PCRE_EXTRA_MARK;
                 } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO16))
                         printf("\n16 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
 #endif
 #ifdef SUPPORT_PCRE32
                 if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
                         convert_utf8_to_utf32(current->pattern, regtest_buf32, NULL, REGTEST_MAX_LENGTH32);
                 else
                         copy_char8_to_char32(current->pattern, regtest_buf32, REGTEST_MAX_LENGTH32);
   
                   re32 = NULL;
                   if (!(current->start_offset & F_NO32))
                           re32 = pcre32_compile(regtest_buf32,
                                   current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
                                   &error, &err_offs, tables(0));
   
                   extra32 = NULL;
                   if (re32) {
                           error = NULL;
                           extra32 = pcre32_study(re32, study_mode, &error);
                           if (!extra32) {
                                   printf("\n32 bit: Cannot study pattern: %s\n", current->pattern);
                                   pcre32_free(re32);
                                   re32 = NULL;
                           }
                           if (!(extra32->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
                                   printf("\n32 bit: JIT compiler does not support: %s\n", current->pattern);
                                   pcre32_free_study(extra32);
                                   pcre32_free(re32);
                                   re32 = NULL;
                           }
                           extra32->flags |= PCRE_EXTRA_MARK;
                   } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO32))
                           printf("\n32 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
   #endif
   
                 counter++;                  counter++;
                if ((counter & 0x3) != 0)                if ((counter & 0x3) != 0) {
                        setstack(extra);#ifdef SUPPORT_PCRE8
                         setstack8(NULL);
 #endif
 #ifdef SUPPORT_PCRE16
                         setstack16(NULL);
 #endif
 #ifdef SUPPORT_PCRE32
                         setstack32(NULL);
 #endif
                 }
   
   #ifdef SUPPORT_PCRE8
                   return_value8[0] = -1000;
                   return_value8[1] = -1000;
                 for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
                        ovector1[i] = -2;                        ovector8_1[i] = -2;
                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);                for (i = 0; i < 32; ++i)
                         ovector8_2[i] = -2;
                 if (re8) {
                         mark8_1 = NULL;
                         mark8_2 = NULL;
                         extra8->mark = &mark8_1;
   
                           if ((counter & 0x1) != 0) {
                                   setstack8(extra8);
                                   return_value8[0] = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
                                           current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32);
                           } else
                                   return_value8[0] = pcre_jit_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
                                           current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32, getstack8());
                           memset(&dummy_extra8, 0, sizeof(pcre_extra));
                           dummy_extra8.flags = PCRE_EXTRA_MARK;
                           if (current->start_offset & F_STUDY) {
                                   dummy_extra8.flags |= PCRE_EXTRA_STUDY_DATA;
                                   dummy_extra8.study_data = extra8->study_data;
                           }
                           dummy_extra8.mark = &mark8_2;
                           return_value8[1] = pcre_exec(re8, &dummy_extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
                                   current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_2, 32);
                   }
   #endif
   
   #ifdef SUPPORT_PCRE16
                   return_value16[0] = -1000;
                   return_value16[1] = -1000;
                 for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
                        ovector2[i] = -2;                        ovector16_1[i] = -2;
                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);                for (i = 0; i < 32; ++i)
                         ovector16_2[i] = -2;
                 if (re16) {
                         mark16_1 = NULL;
                         mark16_2 = NULL;
                         if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
                                 length16 = convert_utf8_to_utf16(current->input, regtest_buf16, regtest_offsetmap16, REGTEST_MAX_LENGTH16);
                         else
                                 length16 = copy_char8_to_char16(current->input, regtest_buf16, REGTEST_MAX_LENGTH16);
                         extra16->mark = &mark16_1;
                         if ((counter & 0x1) != 0) {
                                 setstack16(extra16);
                                 return_value16[0] = pcre16_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
                                         current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32);
                         } else
                                 return_value16[0] = pcre16_jit_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
                                         current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32, getstack16());
                         memset(&dummy_extra16, 0, sizeof(pcre16_extra));
                         dummy_extra16.flags = PCRE_EXTRA_MARK;
                         if (current->start_offset & F_STUDY) {
                                 dummy_extra16.flags |= PCRE_EXTRA_STUDY_DATA;
                                 dummy_extra16.study_data = extra16->study_data;
                         }
                         dummy_extra16.mark = &mark16_2;
                         return_value16[1] = pcre16_exec(re16, &dummy_extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
                                 current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_2, 32);
                 }
 #endif
   
                /* If PCRE_BUG is set, just run the test, but do not compare the results.#ifdef SUPPORT_PCRE32
                Segfaults can still be captured. */                return_value32[0] = -1000;
                if (!(current->flags & PCRE_BUG)) {                return_value32[1] = -1000;
                        if (return_value1 != return_value2) {                for (i = 0; i < 32; ++i)
                                printf("\nReturn value differs(%d:%d): '%s' @ '%s'\n", return_value1, return_value2, current->pattern, current->input);                        ovector32_1[i] = -2;
                                current++;                for (i = 0; i < 32; ++i)
                                continue;                        ovector32_2[i] = -2;
                 if (re32) {
                         mark32_1 = NULL;
                         mark32_2 = NULL;
                         if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
                                 length32 = convert_utf8_to_utf32(current->input, regtest_buf32, regtest_offsetmap32, REGTEST_MAX_LENGTH32);
                         else
                                 length32 = copy_char8_to_char32(current->input, regtest_buf32, REGTEST_MAX_LENGTH32);
                         extra32->mark = &mark32_1;
                         if ((counter & 0x1) != 0) {
                                 setstack32(extra32);
                                 return_value32[0] = pcre32_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
                                         current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32);
                         } else
                                 return_value32[0] = pcre32_jit_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
                                         current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32, getstack32());
                         memset(&dummy_extra32, 0, sizeof(pcre32_extra));
                         dummy_extra32.flags = PCRE_EXTRA_MARK;
                         if (current->start_offset & F_STUDY) {
                                 dummy_extra32.flags |= PCRE_EXTRA_STUDY_DATA;
                                 dummy_extra32.study_data = extra32->study_data;
                         }                          }
                           dummy_extra32.mark = &mark32_2;
                           return_value32[1] = pcre32_exec(re32, &dummy_extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
                                   current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_2, 32);
                   }
   #endif
   
                        if (return_value1 >= 0) {                /* printf("[%d-%d-%d|%d-%d|%d-%d|%d-%d]%s",
                                return_value1 *= 2;                        return_value8[0], return_value16[0],
                                err_offs = 0;                        ovector8_1[0], ovector8_1[1],
                                for (i = 0; i < return_value1; ++i)                        ovector16_1[0], ovector16_1[1],
                                        if (ovector1[i] != ovector2[i]) {                        ovector32_1[0], ovector32_1[1],
                                                printf("\nOvector[%d] value differs(%d:%d): '%s' @ '%s' \n", i, ovector1[i], ovector2[i], current->pattern, current->input);                        (current->flags & PCRE_CASELESS) ? "C" : ""); */
                                                err_offs = 1;
                 /* If F_DIFF is set, just run the test, but do not compare the results.
                 Segfaults can still be captured. */
 
                 is_successful = 1;
                 if (!(current->start_offset & F_DIFF)) {
 #if defined SUPPORT_UTF && ((defined(SUPPORT_PCRE8) + defined(SUPPORT_PCRE16) + defined(SUPPORT_PCRE32)) >= 2)
                         if (!(current->start_offset & F_FORCECONV)) {
                                 int return_value;
 
                                 /* All results must be the same. */
 #ifdef SUPPORT_PCRE8
                                 if ((return_value = return_value8[0]) != return_value8[1]) {
                                         printf("\n8 bit: Return value differs(J8:%d,I8:%d): [%d] '%s' @ '%s'\n",
                                                 return_value8[0], return_value8[1], total, current->pattern, current->input);
                                         is_successful = 0;
                                 } else
 #endif
 #ifdef SUPPORT_PCRE16
                                 if ((return_value = return_value16[0]) != return_value16[1]) {
                                         printf("\n16 bit: Return value differs(J16:%d,I16:%d): [%d] '%s' @ '%s'\n",
                                                 return_value16[0], return_value16[1], total, current->pattern, current->input);
                                         is_successful = 0;
                                 } else
 #endif
 #ifdef SUPPORT_PCRE32
                                 if ((return_value = return_value32[0]) != return_value32[1]) {
                                         printf("\n32 bit: Return value differs(J32:%d,I32:%d): [%d] '%s' @ '%s'\n",
                                                 return_value32[0], return_value32[1], total, current->pattern, current->input);
                                         is_successful = 0;
                                 } else
 #endif
 #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
                                 if (return_value8[0] != return_value16[0]) {
                                         printf("\n8 and 16 bit: Return value differs(J8:%d,J16:%d): [%d] '%s' @ '%s'\n",
                                                 return_value8[0], return_value16[0],
                                                 total, current->pattern, current->input);
                                         is_successful = 0;
                                 } else
 #endif
 #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
                                 if (return_value8[0] != return_value32[0]) {
                                         printf("\n8 and 32 bit: Return value differs(J8:%d,J32:%d): [%d] '%s' @ '%s'\n",
                                                 return_value8[0], return_value32[0],
                                                 total, current->pattern, current->input);
                                         is_successful = 0;
                                 } else
 #endif
 #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE32
                                 if (return_value16[0] != return_value32[0]) {
                                         printf("\n16 and 32 bit: Return value differs(J16:%d,J32:%d): [%d] '%s' @ '%s'\n",
                                                 return_value16[0], return_value32[0],
                                                 total, current->pattern, current->input);
                                         is_successful = 0;
                                 } else
 #endif
                                 if (return_value >= 0 || return_value == PCRE_ERROR_PARTIAL) {
                                         if (return_value == PCRE_ERROR_PARTIAL) {
                                                 return_value = 2;
                                         } else {
                                                 return_value *= 2;
                                         }                                          }
                                if (err_offs) {#ifdef SUPPORT_PCRE8
                                        current++;                                        return_value8[0] = return_value;
                                        continue;#endif
 #ifdef SUPPORT_PCRE16
                                         return_value16[0] = return_value;
 #endif
 #ifdef SUPPORT_PCRE32
                                         return_value32[0] = return_value;
 #endif
                                         /* Transform back the results. */
                                         if (current->flags & PCRE_UTF8) {
 #ifdef SUPPORT_PCRE16
                                                 for (i = 0; i < return_value; ++i) {
                                                         if (ovector16_1[i] >= 0)
                                                                 ovector16_1[i] = regtest_offsetmap16[ovector16_1[i]];
                                                         if (ovector16_2[i] >= 0)
                                                                 ovector16_2[i] = regtest_offsetmap16[ovector16_2[i]];
                                                 }
 #endif
 #ifdef SUPPORT_PCRE32
                                                 for (i = 0; i < return_value; ++i) {
                                                         if (ovector32_1[i] >= 0)
                                                                 ovector32_1[i] = regtest_offsetmap32[ovector32_1[i]];
                                                         if (ovector32_2[i] >= 0)
                                                                 ovector32_2[i] = regtest_offsetmap32[ovector32_2[i]];
                                                 }
 #endif
                                         }
 
                                         for (i = 0; i < return_value; ++i) {
 #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
                                                 if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector16_1[i] || ovector8_1[i] != ovector16_2[i]) {
                                                         printf("\n8 and 16 bit: Ovector[%d] value differs(J8:%d,I8:%d,J16:%d,I16:%d): [%d] '%s' @ '%s' \n",
                                                                 i, ovector8_1[i], ovector8_2[i], ovector16_1[i], ovector16_2[i],
                                                                 total, current->pattern, current->input);
                                                         is_successful = 0;
                                                 }
 #endif
 #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
                                                 if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector32_1[i] || ovector8_1[i] != ovector32_2[i]) {
                                                         printf("\n8 and 32 bit: Ovector[%d] value differs(J8:%d,I8:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
                                                                 i, ovector8_1[i], ovector8_2[i], ovector32_1[i], ovector32_2[i],
                                                                 total, current->pattern, current->input);
                                                         is_successful = 0;
                                                 }
 #endif
 #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE16
                                                 if (ovector16_1[i] != ovector16_2[i] || ovector16_1[i] != ovector16_1[i] || ovector16_1[i] != ovector16_2[i]) {
                                                         printf("\n16 and 16 bit: Ovector[%d] value differs(J16:%d,I16:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
                                                                 i, ovector16_1[i], ovector16_2[i], ovector16_1[i], ovector16_2[i],
                                                                 total, current->pattern, current->input);
                                                         is_successful = 0;
                                                 }
 #endif
                                         }
                                 }                                  }
                           } else
   #endif /* more than one of SUPPORT_PCRE8, SUPPORT_PCRE16 and SUPPORT_PCRE32 */
                           {
                                   /* Only the 8 bit and 16 bit results must be equal. */
   #ifdef SUPPORT_PCRE8
                                   if (return_value8[0] != return_value8[1]) {
                                           printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
                                                   return_value8[0], return_value8[1], total, current->pattern, current->input);
                                           is_successful = 0;
                                   } else if (return_value8[0] >= 0 || return_value8[0] == PCRE_ERROR_PARTIAL) {
                                           if (return_value8[0] == PCRE_ERROR_PARTIAL)
                                                   return_value8[0] = 2;
                                           else
                                                   return_value8[0] *= 2;
   
                                           for (i = 0; i < return_value8[0]; ++i)
                                                   if (ovector8_1[i] != ovector8_2[i]) {
                                                           printf("\n8 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
                                                                   i, ovector8_1[i], ovector8_2[i], total, current->pattern, current->input);
                                                           is_successful = 0;
                                                   }
                                   }
   #endif
   
   #ifdef SUPPORT_PCRE16
                                   if (return_value16[0] != return_value16[1]) {
                                           printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
                                                   return_value16[0], return_value16[1], total, current->pattern, current->input);
                                           is_successful = 0;
                                   } else if (return_value16[0] >= 0 || return_value16[0] == PCRE_ERROR_PARTIAL) {
                                           if (return_value16[0] == PCRE_ERROR_PARTIAL)
                                                   return_value16[0] = 2;
                                           else
                                                   return_value16[0] *= 2;
   
                                           for (i = 0; i < return_value16[0]; ++i)
                                                   if (ovector16_1[i] != ovector16_2[i]) {
                                                           printf("\n16 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
                                                                   i, ovector16_1[i], ovector16_2[i], total, current->pattern, current->input);
                                                           is_successful = 0;
                                                   }
                                   }
   #endif
   
   #ifdef SUPPORT_PCRE32
                                   if (return_value32[0] != return_value32[1]) {
                                           printf("\n32 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
                                                   return_value32[0], return_value32[1], total, current->pattern, current->input);
                                           is_successful = 0;
                                   } else if (return_value32[0] >= 0 || return_value32[0] == PCRE_ERROR_PARTIAL) {
                                           if (return_value32[0] == PCRE_ERROR_PARTIAL)
                                                   return_value32[0] = 2;
                                           else
                                                   return_value32[0] *= 2;
   
                                           for (i = 0; i < return_value32[0]; ++i)
                                                   if (ovector32_1[i] != ovector32_2[i]) {
                                                           printf("\n32 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
                                                                   i, ovector32_1[i], ovector32_2[i], total, current->pattern, current->input);
                                                           is_successful = 0;
                                                   }
                                   }
   #endif
                         }                          }
                 }                  }
   
                pcre_free_study(extra);                if (is_successful) {
                pcre_free(re);#ifdef SUPPORT_PCRE8
                         if (!(current->start_offset & F_NO8) && ((utf && ucp) || is_ascii_input)) {
                                 if (return_value8[0] < 0 && !(current->start_offset & F_NOMATCH)) {
                                         printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",
                                                 total, current->pattern, current->input);
                                         is_successful = 0;
                                 }
   
                /* printf("[%d-%d]%s", ovector1[0], ovector1[1], (current->flags & PCRE_CASELESS) ? "C" : ""); */                                if (return_value8[0] >= 0 && (current->start_offset & F_NOMATCH)) {
                printf(".");                                        printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",
                                                 total, current->pattern, current->input);
                                         is_successful = 0;
                                 }
                         }
 #endif
 #ifdef SUPPORT_PCRE16
                         if (!(current->start_offset & F_NO16) && ((utf && ucp) || is_ascii_input)) {
                                 if (return_value16[0] < 0 && !(current->start_offset & F_NOMATCH)) {
                                         printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",
                                                 total, current->pattern, current->input);
                                         is_successful = 0;
                                 }
 
                                 if (return_value16[0] >= 0 && (current->start_offset & F_NOMATCH)) {
                                         printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",
                                                 total, current->pattern, current->input);
                                         is_successful = 0;
                                 }
                         }
 #endif
 #ifdef SUPPORT_PCRE32
                         if (!(current->start_offset & F_NO32) && ((utf && ucp) || is_ascii_input)) {
                                 if (return_value32[0] < 0 && !(current->start_offset & F_NOMATCH)) {
                                         printf("32 bit: Test should match: [%d] '%s' @ '%s'\n",
                                                 total, current->pattern, current->input);
                                         is_successful = 0;
                                 }
 
                                 if (return_value32[0] >= 0 && (current->start_offset & F_NOMATCH)) {
                                         printf("32 bit: Test should not match: [%d] '%s' @ '%s'\n",
                                                 total, current->pattern, current->input);
                                         is_successful = 0;
                                 }
                         }
 #endif
                 }
 
                 if (is_successful) {
 #ifdef SUPPORT_PCRE8
                         if (mark8_1 != mark8_2) {
                                 printf("8 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
                                         total, current->pattern, current->input);
                                 is_successful = 0;
                         }
 #endif
 #ifdef SUPPORT_PCRE16
                         if (mark16_1 != mark16_2) {
                                 printf("16 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
                                         total, current->pattern, current->input);
                                 is_successful = 0;
                         }
 #endif
 #ifdef SUPPORT_PCRE32
                         if (mark32_1 != mark32_2) {
                                 printf("32 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
                                         total, current->pattern, current->input);
                                 is_successful = 0;
                         }
 #endif
                 }
 
 #ifdef SUPPORT_PCRE8
                 if (re8) {
                         pcre_free_study(extra8);
                         pcre_free(re8);
                 }
 #endif
 #ifdef SUPPORT_PCRE16
                 if (re16) {
                         pcre16_free_study(extra16);
                         pcre16_free(re16);
                 }
 #endif
 #ifdef SUPPORT_PCRE32
                 if (re32) {
                         pcre32_free_study(extra32);
                         pcre32_free(re32);
                 }
 #endif
 
                 if (is_successful) {
                         successful++;
                         successful_row++;
                         printf(".");
                         if (successful_row >= 60) {
                                 successful_row = 0;
                                 printf("\n");
                         }
                 } else
                         successful_row = 0;
 
                 fflush(stdout);                  fflush(stdout);
                 current++;                  current++;
                 succesful++;  
         }          }
           tables(1);
   #ifdef SUPPORT_PCRE8
           setstack8(NULL);
   #endif
   #ifdef SUPPORT_PCRE16
           setstack16(NULL);
   #endif
   #ifdef SUPPORT_PCRE32
           setstack32(NULL);
   #endif
   
        if (total == succesful) {        if (total == successful) {
                 printf("\nAll JIT regression tests are successfully passed.\n");                  printf("\nAll JIT regression tests are successfully passed.\n");
                 return 0;                  return 0;
         } else {          } else {
                printf("\nSuccessful test ratio: %d%%\n", succesful * 100 / total);                printf("\nSuccessful test ratio: %d%% (%d failed)\n", successful * 100 / total, total - successful);
                 return 1;                  return 1;
         }          }
 }  }

Removed from v.1.1  
changed lines
  Added in v.1.1.1.4


FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>