pcre_jit_test.c

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