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