source-git / mingw-pcre

Clone
Source Code
GIT

Blame pcre_jit_test.c

c8 master
  1.   a44bef40c322d76db5f05943430cca37e777d71f
  2.   pcre_jit_test.c
Blob History Raw
Packit 78a954 
/*************************************************
Packit 78a954 
*      Perl-Compatible Regular Expressions       *
Packit 78a954 
*************************************************/
Packit 78a954
Packit 78a954 
/* PCRE is a library of functions to support regular expressions whose syntax
Packit 78a954 
and semantics are as close as possible to those of the Perl 5 language.
Packit 78a954
Packit 78a954 
                  Main Library written by Philip Hazel
Packit 78a954 
           Copyright (c) 1997-2012 University of Cambridge
Packit 78a954
Packit 78a954 
  This JIT compiler regression test program was written by Zoltan Herczeg
Packit 78a954 
                      Copyright (c) 2010-2012
Packit 78a954
Packit 78a954 
-----------------------------------------------------------------------------
Packit 78a954 
Redistribution and use in source and binary forms, with or without
Packit 78a954 
modification, are permitted provided that the following conditions are met:
Packit 78a954
Packit 78a954 
    * Redistributions of source code must retain the above copyright notice,
Packit 78a954 
      this list of conditions and the following disclaimer.
Packit 78a954
Packit 78a954 
    * Redistributions in binary form must reproduce the above copyright
Packit 78a954 
      notice, this list of conditions and the following disclaimer in the
Packit 78a954 
      documentation and/or other materials provided with the distribution.
Packit 78a954
Packit 78a954 
    * Neither the name of the University of Cambridge nor the names of its
Packit 78a954 
      contributors may be used to endorse or promote products derived from
Packit 78a954 
      this software without specific prior written permission.
Packit 78a954
Packit 78a954 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
Packit 78a954 
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
Packit 78a954 
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
Packit 78a954 
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
Packit 78a954 
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
Packit 78a954 
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
Packit 78a954 
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
Packit 78a954 
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
Packit 78a954 
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
Packit 78a954 
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
Packit 78a954 
POSSIBILITY OF SUCH DAMAGE.
Packit 78a954 
-----------------------------------------------------------------------------
Packit 78a954 
*/
Packit 78a954
Packit 78a954 
#ifdef HAVE_CONFIG_H
Packit 78a954 
#include "config.h"
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
#include <stdio.h>
Packit 78a954 
#include <string.h>
Packit 78a954 
#include "pcre.h"
Packit 78a954
Packit 78a954
Packit 78a954 
#include "pcre_internal.h"
Packit 78a954
Packit 78a954 
/*
Packit 78a954 
 Letter characters:
Packit 78a954 
   \xe6\x92\xad = 0x64ad = 25773 (kanji)
Packit 78a954 
 Non-letter characters:
Packit 78a954 
   \xc2\xa1 = 0xa1 =  (Inverted Exclamation Mark)
Packit 78a954 
   \xf3\xa9\xb7\x80 = 0xe9dc0 = 957888
Packit 78a954 
   \xed\xa0\x80 = 55296 = 0xd800 (Invalid UTF character)
Packit 78a954 
   \xed\xb0\x80 = 56320 = 0xdc00 (Invalid UTF character)
Packit 78a954 
 Newlines:
Packit 78a954 
   \xc2\x85 = 0x85 = 133 (NExt Line = NEL)
Packit 78a954 
   \xe2\x80\xa8 = 0x2028 = 8232 (Line Separator)
Packit 78a954 
 Othercase pairs:
Packit 78a954 
   \xc3\xa9 = 0xe9 = 233 (e')
Packit 78a954 
      \xc3\x89 = 0xc9 = 201 (E')
Packit 78a954 
   \xc3\xa1 = 0xe1 = 225 (a')
Packit 78a954 
      \xc3\x81 = 0xc1 = 193 (A')
Packit 78a954 
   \x53 = 0x53 = S
Packit 78a954 
     \x73 = 0x73 = s
Packit 78a954 
     \xc5\xbf = 0x17f = 383 (long S)
Packit 78a954 
   \xc8\xba = 0x23a = 570
Packit 78a954 
      \xe2\xb1\xa5 = 0x2c65 = 11365
Packit 78a954 
   \xe1\xbd\xb8 = 0x1f78 = 8056
Packit 78a954 
      \xe1\xbf\xb8 = 0x1ff8 = 8184
Packit 78a954 
   \xf0\x90\x90\x80 = 0x10400 = 66560
Packit 78a954 
      \xf0\x90\x90\xa8 = 0x10428 = 66600
Packit 78a954 
   \xc7\x84 = 0x1c4 = 452
Packit 78a954 
     \xc7\x85 = 0x1c5 = 453
Packit 78a954 
     \xc7\x86 = 0x1c6 = 454
Packit 78a954 
 Caseless sets:
Packit 78a954 
   ucp_Armenian - \x{531}-\x{556} -> \x{561}-\x{586}
Packit 78a954 
   ucp_Coptic - \x{2c80}-\x{2ce3} -> caseless: XOR 0x1
Packit 78a954 
   ucp_Latin - \x{ff21}-\x{ff3a} -> \x{ff41]-\x{ff5a}
Packit 78a954
Packit 78a954 
 Mark property:
Packit 78a954 
   \xcc\x8d = 0x30d = 781
Packit 78a954 
 Special:
Packit 78a954 
   \xc2\x80 = 0x80 = 128 (lowest 2 byte character)
Packit 78a954 
   \xdf\xbf = 0x7ff = 2047 (highest 2 byte character)
Packit 78a954 
   \xe0\xa0\x80 = 0x800 = 2048 (lowest 2 byte character)
Packit 78a954 
   \xef\xbf\xbf = 0xffff = 65535 (highest 3 byte character)
Packit 78a954 
   \xf0\x90\x80\x80 = 0x10000 = 65536 (lowest 4 byte character)
Packit 78a954 
   \xf4\x8f\xbf\xbf = 0x10ffff = 1114111 (highest allowed utf character)
Packit 78a954 
*/
Packit 78a954
Packit 78a954 
static int regression_tests(void);
Packit 78a954
Packit 78a954 
int main(void)
Packit 78a954 
{
Packit 78a954 
	int jit = 0;
Packit 78a954 
#if defined SUPPORT_PCRE8
Packit 78a954 
	pcre_config(PCRE_CONFIG_JIT, &jit);
Packit 78a954 
#elif defined SUPPORT_PCRE16
Packit 78a954 
	pcre16_config(PCRE_CONFIG_JIT, &jit);
Packit 78a954 
#elif defined SUPPORT_PCRE32
Packit 78a954 
	pcre32_config(PCRE_CONFIG_JIT, &jit);
Packit 78a954 
#endif
Packit 78a954 
	if (!jit) {
Packit 78a954 
		printf("JIT must be enabled to run pcre_jit_test\n");
Packit 78a954 
		return 1;
Packit 78a954 
	}
Packit 78a954 
	return regression_tests();
Packit 78a954 
}
Packit 78a954
Packit 78a954 
/* --------------------------------------------------------------------------------------- */
Packit 78a954
Packit 78a954 
#if !(defined SUPPORT_PCRE8) && !(defined SUPPORT_PCRE16) && !(defined SUPPORT_PCRE32)
Packit 78a954 
#error SUPPORT_PCRE8 or SUPPORT_PCRE16 or SUPPORT_PCRE32 must be defined
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
#define MUA	(PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)
Packit 78a954 
#define MUAP	(PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)
Packit 78a954 
#define CMUA	(PCRE_CASELESS | PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)
Packit 78a954 
#define CMUAP	(PCRE_CASELESS | PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)
Packit 78a954 
#define MA	(PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF)
Packit 78a954 
#define MAP	(PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)
Packit 78a954 
#define CMA	(PCRE_CASELESS | PCRE_MULTILINE | PCRE_NEWLINE_ANYCRLF)
Packit 78a954
Packit 78a954 
#define OFFSET_MASK	0x00ffff
Packit 78a954 
#define F_NO8		0x010000
Packit 78a954 
#define F_NO16		0x020000
Packit 78a954 
#define F_NO32		0x020000
Packit 78a954 
#define F_NOMATCH	0x040000
Packit 78a954 
#define F_DIFF		0x080000
Packit 78a954 
#define F_FORCECONV	0x100000
Packit 78a954 
#define F_PROPERTY	0x200000
Packit 78a954 
#define F_STUDY		0x400000
Packit 78a954
Packit 78a954 
struct regression_test_case {
Packit 78a954 
	int flags;
Packit 78a954 
	int start_offset;
Packit 78a954 
	const char *pattern;
Packit 78a954 
	const char *input;
Packit 78a954 
};
Packit 78a954
Packit 78a954 
static struct regression_test_case regression_test_cases[] = {
Packit 78a954 
	/* Constant strings. */
Packit 78a954 
	{ MUA, 0, "AbC", "AbAbC" },
Packit 78a954 
	{ MUA, 0, "ACCEPT", "AACACCACCEACCEPACCEPTACCEPTT" },
Packit 78a954 
	{ CMUA, 0, "aA#\xc3\xa9\xc3\x81", "aA#Aa#\xc3\x89\xc3\xa1" },
Packit 78a954 
	{ MA, 0, "[^a]", "aAbB" },
Packit 78a954 
	{ CMA, 0, "[^m]", "mMnN" },
Packit 78a954 
	{ MA, 0, "a[^b][^#]", "abacd" },
Packit 78a954 
	{ CMA, 0, "A[^B][^E]", "abacd" },
Packit 78a954 
	{ CMUA, 0, "[^x][^#]", "XxBll" },
Packit 78a954 
	{ MUA, 0, "[^a]", "aaa\xc3\xa1#Ab" },
Packit 78a954 
	{ CMUA, 0, "[^A]", "aA\xe6\x92\xad" },
Packit 78a954 
	{ MUA, 0, "\\W(\\W)?\\w", "\r\n+bc" },
Packit 78a954 
	{ MUA, 0, "\\W(\\W)?\\w", "\n\r+bc" },
Packit 78a954 
	{ MUA, 0, "\\W(\\W)?\\w", "\r\r+bc" },
Packit 78a954 
	{ MUA, 0, "\\W(\\W)?\\w", "\n\n+bc" },
Packit 78a954 
	{ MUA, 0, "[axd]", "sAXd" },
Packit 78a954 
	{ CMUA, 0, "[axd]", "sAXd" },
Packit 78a954 
	{ CMUA, 0 | F_NOMATCH, "[^axd]", "DxA" },
Packit 78a954 
	{ MUA, 0, "[a-dA-C]", "\xe6\x92\xad\xc3\xa9.B" },
Packit 78a954 
	{ MUA, 0, "[^a-dA-C]", "\xe6\x92\xad\xc3\xa9" },
Packit 78a954 
	{ CMUA, 0, "[^\xc3\xa9]", "\xc3\xa9\xc3\x89." },
Packit 78a954 
	{ MUA, 0, "[^\xc3\xa9]", "\xc3\xa9\xc3\x89." },
Packit 78a954 
	{ MUA, 0, "[^a]", "\xc2\x80[]" },
Packit 78a954 
	{ CMUA, 0, "\xf0\x90\x90\xa7", "\xf0\x90\x91\x8f" },
Packit 78a954 
	{ CMA, 0, "1a2b3c4", "1a2B3c51A2B3C4" },
Packit 78a954 
	{ PCRE_CASELESS, 0, "\xff#a", "\xff#\xff\xfe##\xff#A" },
Packit 78a954 
	{ PCRE_CASELESS, 0, "\xfe", "\xff\xfc#\xfe\xfe" },
Packit 78a954 
	{ PCRE_CASELESS, 0, "a1", "Aa1" },
Packit 78a954 
	{ MA, 0, "\\Ca", "cda" },
Packit 78a954 
	{ CMA, 0, "\\Ca", "CDA" },
Packit 78a954 
	{ MA, 0 | F_NOMATCH, "\\Cx", "cda" },
Packit 78a954 
	{ CMA, 0 | F_NOMATCH, "\\Cx", "CDA" },
Packit 78a954 
	{ CMUAP, 0, "\xf0\x90\x90\x80\xf0\x90\x90\xa8", "\xf0\x90\x90\xa8\xf0\x90\x90\x80" },
Packit 78a954 
	{ CMUAP, 0, "\xf0\x90\x90\x80{2}", "\xf0\x90\x90\x80#\xf0\x90\x90\xa8\xf0\x90\x90\x80" },
Packit 78a954 
	{ CMUAP, 0, "\xf0\x90\x90\xa8{2}", "\xf0\x90\x90\x80#\xf0\x90\x90\xa8\xf0\x90\x90\x80" },
Packit 78a954 
	{ CMUAP, 0, "\xe1\xbd\xb8\xe1\xbf\xb8", "\xe1\xbf\xb8\xe1\xbd\xb8" },
Packit 78a954 
	{ MA, 0, "[3-57-9]", "5" },
Packit 78a954
Packit 78a954 
	/* Assertions. */
Packit 78a954 
	{ MUA, 0, "\\b[^A]", "A_B#" },
Packit 78a954 
	{ MA, 0 | F_NOMATCH, "\\b\\W", "\n*" },
Packit 78a954 
	{ MUA, 0, "\\B[^,]\\b[^s]\\b", "#X" },
Packit 78a954 
	{ MAP, 0, "\\B", "_\xa1" },
Packit 78a954 
	{ MAP, 0, "\\b_\\b[,A]\\B", "_," },
Packit 78a954 
	{ MUAP, 0, "\\b", "\xe6\x92\xad!" },
Packit 78a954 
	{ MUAP, 0, "\\B", "_\xc2\xa1\xc3\xa1\xc2\x85" },
Packit 78a954 
	{ MUAP, 0, "\\b[^A]\\B[^c]\\b[^_]\\B", "_\xc3\xa1\xe2\x80\xa8" },
Packit 78a954 
	{ MUAP, 0, "\\b\\w+\\B", "\xc3\x89\xc2\xa1\xe6\x92\xad\xc3\x81\xc3\xa1" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "\\b.", "\xcd\xbe" },
Packit 78a954 
	{ CMUAP, 0, "\\By", "\xf0\x90\x90\xa8y" },
Packit 78a954 
	{ MA, 0 | F_NOMATCH, "\\R^", "\n" },
Packit 78a954 
	{ MA, 1 | F_NOMATCH, "^", "\n" },
Packit 78a954 
	{ 0, 0, "^ab", "ab" },
Packit 78a954 
	{ 0, 0 | F_NOMATCH, "^ab", "aab" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 0, "^a", "\r\raa\n\naa\r\naa" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF, 0, "^-", "\xe2\x80\xa8--\xc2\x85-\r\n-" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "^-", "a--b--\x85--" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xe2\x80\xa8--" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xc2\x85--" },
Packit 78a954 
	{ 0, 0, "ab$", "ab" },
Packit 78a954 
	{ 0, 0 | F_NOMATCH, "ab$", "abab\n\n" },
Packit 78a954 
	{ PCRE_DOLLAR_ENDONLY, 0 | F_NOMATCH, "ab$", "abab\r\n" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 0, "a$", "\r\raa\n\naa\r\naa" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "a$", "aaa" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF, 0, "#$", "#\xc2\x85###\r#" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "#$", "#\xe2\x80\xa9" },
Packit 78a954 
	{ PCRE_NOTBOL | PCRE_NEWLINE_ANY, 0 | F_NOMATCH, "^a", "aa\naa" },
Packit 78a954 
	{ PCRE_NOTBOL | PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "^a", "aa\naa" },
Packit 78a954 
	{ PCRE_NOTEOL | PCRE_NEWLINE_ANY, 0 | F_NOMATCH, "a$", "aa\naa" },
Packit 78a954 
	{ PCRE_NOTEOL | PCRE_NEWLINE_ANY, 0 | F_NOMATCH, "a$", "aa\r\n" },
Packit 78a954 
	{ PCRE_UTF8 | PCRE_DOLLAR_ENDONLY | PCRE_NEWLINE_ANY, 0 | F_PROPERTY, "\\p{Any}{2,}$", "aa\r\n" },
Packit 78a954 
	{ PCRE_NOTEOL | PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "a$", "aa\naa" },
Packit 78a954 
	{ PCRE_NEWLINE_CR, 0, ".\\Z", "aaa" },
Packit 78a954 
	{ PCRE_NEWLINE_CR | PCRE_UTF8, 0, "a\\Z", "aaa\r" },
Packit 78a954 
	{ PCRE_NEWLINE_CR, 0, ".\\Z", "aaa\n" },
Packit 78a954 
	{ PCRE_NEWLINE_CRLF, 0, ".\\Z", "aaa\r" },
Packit 78a954 
	{ PCRE_NEWLINE_CRLF | PCRE_UTF8, 0, ".\\Z", "aaa\n" },
Packit 78a954 
	{ PCRE_NEWLINE_CRLF, 0, ".\\Z", "aaa\r\n" },
Packit 78a954 
	{ PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa" },
Packit 78a954 
	{ PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa\r" },
Packit 78a954 
	{ PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa\n" },
Packit 78a954 
	{ PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa\r\n" },
Packit 78a954 
	{ PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa\xe2\x80\xa8" },
Packit 78a954 
	{ PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa" },
Packit 78a954 
	{ PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa\r" },
Packit 78a954 
	{ PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa\n" },
Packit 78a954 
	{ PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".\\Z", "aaa\r\n" },
Packit 78a954 
	{ PCRE_NEWLINE_ANY | PCRE_UTF8, 0, ".\\Z", "aaa\xc2\x85" },
Packit 78a954 
	{ PCRE_NEWLINE_ANY | PCRE_UTF8, 0, ".\\Z", "aaa\xe2\x80\xa8" },
Packit 78a954 
	{ MA, 0, "\\Aa", "aaa" },
Packit 78a954 
	{ MA, 1 | F_NOMATCH, "\\Aa", "aaa" },
Packit 78a954 
	{ MA, 1, "\\Ga", "aaa" },
Packit 78a954 
	{ MA, 1 | F_NOMATCH, "\\Ga", "aba" },
Packit 78a954 
	{ MA, 0, "a\\z", "aaa" },
Packit 78a954 
	{ MA, 0 | F_NOMATCH, "a\\z", "aab" },
Packit 78a954
Packit 78a954 
	/* Brackets. */
Packit 78a954 
	{ MUA, 0, "(ab|bb|cd)", "bacde" },
Packit 78a954 
	{ MUA, 0, "(?:ab|a)(bc|c)", "ababc" },
Packit 78a954 
	{ MUA, 0, "((ab|(cc))|(bb)|(?:cd|efg))", "abac" },
Packit 78a954 
	{ CMUA, 0, "((aB|(Cc))|(bB)|(?:cd|EFg))", "AcCe" },
Packit 78a954 
	{ MUA, 0, "((ab|(cc))|(bb)|(?:cd|ebg))", "acebebg" },
Packit 78a954 
	{ MUA, 0, "(?:(a)|(?:b))(cc|(?:d|e))(a|b)k", "accabdbbccbk" },
Packit 78a954
Packit 78a954 
	/* Greedy and non-greedy ? operators. */
Packit 78a954 
	{ MUA, 0, "(?:a)?a", "laab" },
Packit 78a954 
	{ CMUA, 0, "(A)?A", "llaab" },
Packit 78a954 
	{ MUA, 0, "(a)?\?a", "aab" }, /* ?? is the prefix of trygraphs in GCC. */
Packit 78a954 
	{ MUA, 0, "(a)?a", "manm" },
Packit 78a954 
	{ CMUA, 0, "(a|b)?\?d((?:e)?)", "ABABdx" },
Packit 78a954 
	{ MUA, 0, "(a|b)?\?d((?:e)?)", "abcde" },
Packit 78a954 
	{ MUA, 0, "((?:ab)?\?g|b(?:g(nn|d)?\?)?)?\?(?:n)?m", "abgnbgnnbgdnmm" },
Packit 78a954
Packit 78a954 
	/* Greedy and non-greedy + operators */
Packit 78a954 
	{ MUA, 0, "(aa)+aa", "aaaaaaa" },
Packit 78a954 
	{ MUA, 0, "(aa)+?aa", "aaaaaaa" },
Packit 78a954 
	{ MUA, 0, "(?:aba|ab|a)+l", "ababamababal" },
Packit 78a954 
	{ MUA, 0, "(?:aba|ab|a)+?l", "ababamababal" },
Packit 78a954 
	{ MUA, 0, "(a(?:bc|cb|b|c)+?|ss)+e", "accssabccbcacbccbbXaccssabccbcacbccbbe" },
Packit 78a954 
	{ MUA, 0, "(a(?:bc|cb|b|c)+|ss)+?e", "accssabccbcacbccbbXaccssabccbcacbccbbe" },
Packit 78a954 
	{ MUA, 0, "(?:(b(c)+?)+)?\?(?:(bc)+|(cb)+)+(?:m)+", "bccbcccbcbccbcbPbccbcccbcbccbcbmmn" },
Packit 78a954
Packit 78a954 
	/* Greedy and non-greedy * operators */
Packit 78a954 
	{ CMUA, 0, "(?:AA)*AB", "aaaaaaamaaaaaaab" },
Packit 78a954 
	{ MUA, 0, "(?:aa)*?ab", "aaaaaaamaaaaaaab" },
Packit 78a954 
	{ MUA, 0, "(aa|ab)*ab", "aaabaaab" },
Packit 78a954 
	{ CMUA, 0, "(aa|Ab)*?aB", "aaabaaab" },
Packit 78a954 
	{ MUA, 0, "(a|b)*(?:a)*(?:b)*m", "abbbaaababanabbbaaababamm" },
Packit 78a954 
	{ MUA, 0, "(a|b)*?(?:a)*?(?:b)*?m", "abbbaaababanabbbaaababamm" },
Packit 78a954 
	{ MA, 0, "a(a(\\1*)a|(b)b+){0}a", "aa" },
Packit 78a954 
	{ MA, 0, "((?:a|)*){0}a", "a" },
Packit 78a954
Packit 78a954 
	/* Combining ? + * operators */
Packit 78a954 
	{ MUA, 0, "((bm)+)?\?(?:a)*(bm)+n|((am)+?)?(?:a)+(am)*n", "bmbmabmamaaamambmaman" },
Packit 78a954 
	{ MUA, 0, "(((ab)?cd)*ef)+g", "abcdcdefcdefefmabcdcdefcdefefgg" },
Packit 78a954 
	{ MUA, 0, "(((ab)?\?cd)*?ef)+?g", "abcdcdefcdefefmabcdcdefcdefefgg" },
Packit 78a954 
	{ MUA, 0, "(?:(ab)?c|(?:ab)+?d)*g", "ababcdccababddg" },
Packit 78a954 
	{ MUA, 0, "(?:(?:ab)?\?c|(ab)+d)*?g", "ababcdccababddg" },
Packit 78a954
Packit 78a954 
	/* Single character iterators. */
Packit 78a954 
	{ MUA, 0, "(a+aab)+aaaab", "aaaabcaaaabaabcaabcaaabaaaab" },
Packit 78a954 
	{ MUA, 0, "(a*a*aab)+x", "aaaaabaabaaabmaabx" },
Packit 78a954 
	{ MUA, 0, "(a*?(b|ab)a*?)+x", "aaaabcxbbaabaacbaaabaabax" },
Packit 78a954 
	{ MUA, 0, "(a+(ab|ad)a+)+x", "aaabaaaadaabaaabaaaadaaax" },
Packit 78a954 
	{ MUA, 0, "(a?(a)a?)+(aaa)", "abaaabaaaaaaaa" },
Packit 78a954 
	{ MUA, 0, "(a?\?(a)a?\?)+(b)", "aaaacaaacaacacbaaab" },
Packit 78a954 
	{ MUA, 0, "(a{0,4}(b))+d", "aaaaaabaabcaaaaabaaaaabd" },
Packit 78a954 
	{ MUA, 0, "(a{0,4}?[^b])+d+(a{0,4}[^b])d+", "aaaaadaaaacaadddaaddd" },
Packit 78a954 
	{ MUA, 0, "(ba{2})+c", "baabaaabacbaabaac" },
Packit 78a954 
	{ MUA, 0, "(a*+bc++)+", "aaabbcaaabcccab" },
Packit 78a954 
	{ MUA, 0, "(a?+[^b])+", "babaacacb" },
Packit 78a954 
	{ MUA, 0, "(a{0,3}+b)(a{0,3}+b)(a{0,3}+)[^c]", "abaabaaacbaabaaaac" },
Packit 78a954 
	{ CMUA, 0, "([a-c]+[d-f]+?)+?g", "aBdacdehAbDaFgA" },
Packit 78a954 
	{ CMUA, 0, "[c-f]+k", "DemmFke" },
Packit 78a954 
	{ MUA, 0, "([DGH]{0,4}M)+", "GGDGHDGMMHMDHHGHM" },
Packit 78a954 
	{ MUA, 0, "([a-c]{4,}s)+", "abasabbasbbaabsbba" },
Packit 78a954 
	{ CMUA, 0, "[ace]{3,7}", "AcbDAcEEcEd" },
Packit 78a954 
	{ CMUA, 0, "[ace]{3,7}?", "AcbDAcEEcEd" },
Packit 78a954 
	{ CMUA, 0, "[ace]{3,}", "AcbDAcEEcEd" },
Packit 78a954 
	{ CMUA, 0, "[ace]{3,}?", "AcbDAcEEcEd" },
Packit 78a954 
	{ MUA, 0, "[ckl]{2,}?g", "cdkkmlglglkcg" },
Packit 78a954 
	{ CMUA, 0, "[ace]{5}?", "AcCebDAcEEcEd" },
Packit 78a954 
	{ MUA, 0, "([AbC]{3,5}?d)+", "BACaAbbAEAACCbdCCbdCCAAbb" },
Packit 78a954 
	{ MUA, 0, "([^ab]{0,}s){2}", "abaabcdsABamsDDs" },
Packit 78a954 
	{ MUA, 0, "\\b\\w+\\B", "x,a_cd" },
Packit 78a954 
	{ MUAP, 0, "\\b[^\xc2\xa1]+\\B", "\xc3\x89\xc2\xa1\xe6\x92\xad\xc3\x81\xc3\xa1" },
Packit 78a954 
	{ CMUA, 0, "[^b]+(a*)([^c]?d{3})", "aaaaddd" },
Packit 78a954 
	{ CMUAP, 0, "\xe1\xbd\xb8{2}", "\xe1\xbf\xb8#\xe1\xbf\xb8\xe1\xbd\xb8" },
Packit 78a954 
	{ CMUA, 0, "[^\xf0\x90\x90\x80]{2,4}@", "\xf0\x90\x90\xa8\xf0\x90\x90\x80###\xf0\x90\x90\x80@@@" },
Packit 78a954 
	{ CMUA, 0, "[^\xe1\xbd\xb8][^\xc3\xa9]", "\xe1\xbd\xb8\xe1\xbf\xb8\xc3\xa9\xc3\x89#" },
Packit 78a954 
	{ MUA, 0, "[^\xe1\xbd\xb8][^\xc3\xa9]", "\xe1\xbd\xb8\xe1\xbf\xb8\xc3\xa9\xc3\x89#" },
Packit 78a954 
	{ MUA, 0, "[^\xe1\xbd\xb8]{3,}?", "##\xe1\xbd\xb8#\xe1\xbd\xb8#\xc3\x89#\xe1\xbd\xb8" },
Packit 78a954
Packit 78a954 
	/* Bracket repeats with limit. */
Packit 78a954 
	{ MUA, 0, "(?:(ab){2}){5}M", "abababababababababababM" },
Packit 78a954 
	{ MUA, 0, "(?:ab|abab){1,5}M", "abababababababababababM" },
Packit 78a954 
	{ MUA, 0, "(?>ab|abab){1,5}M", "abababababababababababM" },
Packit 78a954 
	{ MUA, 0, "(?:ab|abab){1,5}?M", "abababababababababababM" },
Packit 78a954 
	{ MUA, 0, "(?>ab|abab){1,5}?M", "abababababababababababM" },
Packit 78a954 
	{ MUA, 0, "(?:(ab){1,4}?){1,3}?M", "abababababababababababababM" },
Packit 78a954 
	{ MUA, 0, "(?:(ab){1,4}){1,3}abababababababababababM", "ababababababababababababM" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(?:(ab){1,4}){1,3}abababababababababababM", "abababababababababababM" },
Packit 78a954 
	{ MUA, 0, "(ab){4,6}?M", "abababababababM" },
Packit 78a954
Packit 78a954 
	/* Basic character sets. */
Packit 78a954 
	{ MUA, 0, "(?:\\s)+(?:\\S)+", "ab \t\xc3\xa9\xe6\x92\xad " },
Packit 78a954 
	{ MUA, 0, "(\\w)*(k)(\\W)?\?", "abcdef abck11" },
Packit 78a954 
	{ MUA, 0, "\\((\\d)+\\)\\D", "a() (83 (8)2 (9)ab" },
Packit 78a954 
	{ MUA, 0, "\\w(\\s|(?:\\d)*,)+\\w\\wb", "a 5, 4,, bb 5, 4,, aab" },
Packit 78a954 
	{ MUA, 0, "(\\v+)(\\V+)", "\x0e\xc2\x85\xe2\x80\xa8\x0b\x09\xe2\x80\xa9" },
Packit 78a954 
	{ 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" },
Packit 78a954 
	{ MUA, 0, "x[bcef]+", "xaxdxecbfg" },
Packit 78a954 
	{ MUA, 0, "x[bcdghij]+", "xaxexfxdgbjk" },
Packit 78a954 
	{ MUA, 0, "x[^befg]+", "xbxexacdhg" },
Packit 78a954 
	{ MUA, 0, "x[^bcdl]+", "xlxbxaekmd" },
Packit 78a954 
	{ MUA, 0, "x[^bcdghi]+", "xbxdxgxaefji" },
Packit 78a954 
	{ MUA, 0, "x[B-Fb-f]+", "xaxAxgxbfBFG" },
Packit 78a954 
	{ CMUA, 0, "\\x{e9}+", "#\xf0\x90\x90\xa8\xc3\xa8\xc3\xa9\xc3\x89\xc3\x88" },
Packit 78a954 
	{ CMUA, 0, "[^\\x{e9}]+", "\xc3\xa9#\xf0\x90\x90\xa8\xc3\xa8\xc3\x88\xc3\x89" },
Packit 78a954 
	{ MUA, 0, "[\\x02\\x7e]+", "\xc3\x81\xe1\xbf\xb8\xf0\x90\x90\xa8\x01\x02\x7e\x7f" },
Packit 78a954 
	{ MUA, 0, "[^\\x02\\x7e]+", "\x02\xc3\x81\xe1\xbf\xb8\xf0\x90\x90\xa8\x01\x7f\x7e" },
Packit 78a954 
	{ MUA, 0, "[\\x{81}-\\x{7fe}]+", "#\xe1\xbf\xb8\xf0\x90\x90\xa8\xc2\x80\xc2\x81\xdf\xbe\xdf\xbf" },
Packit 78a954 
	{ MUA, 0, "[^\\x{81}-\\x{7fe}]+", "\xc2\x81#\xe1\xbf\xb8\xf0\x90\x90\xa8\xc2\x80\xdf\xbf\xdf\xbe" },
Packit 78a954 
	{ MUA, 0, "[\\x{801}-\\x{fffe}]+", "#\xc3\xa9\xf0\x90\x90\x80\xe0\xa0\x80\xe0\xa0\x81\xef\xbf\xbe\xef\xbf\xbf" },
Packit 78a954 
	{ MUA, 0, "[^\\x{801}-\\x{fffe}]+", "\xe0\xa0\x81#\xc3\xa9\xf0\x90\x90\x80\xe0\xa0\x80\xef\xbf\xbf\xef\xbf\xbe" },
Packit 78a954 
	{ 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" },
Packit 78a954 
	{ 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" },
Packit 78a954
Packit 78a954 
	/* Unicode properties. */
Packit 78a954 
	{ MUAP, 0, "[1-5\xc3\xa9\\w]", "\xc3\xa1_" },
Packit 78a954 
	{ MUAP, 0 | F_PROPERTY, "[\xc3\x81\\p{Ll}]", "A_\xc3\x89\xc3\xa1" },
Packit 78a954 
	{ MUAP, 0, "[\\Wd-h_x-z]+", "a\xc2\xa1#_yhzdxi" },
Packit 78a954 
	{ MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\\P{Any}]", "abc" },
Packit 78a954 
	{ MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\\p{Any}]", "abc" },
Packit 78a954 
	{ MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\\P{Any}\xc3\xa1-\xc3\xa8]", "abc" },
Packit 78a954 
	{ MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\\p{Any}\xc3\xa1-\xc3\xa8]", "abc" },
Packit 78a954 
	{ MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },
Packit 78a954 
	{ MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },
Packit 78a954 
	{ MUAP, 0 | F_PROPERTY, "[\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },
Packit 78a954 
	{ MUAP, 0 | F_PROPERTY, "[^\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },
Packit 78a954 
	{ MUAP, 0, "[b-\xc3\xa9\\s]", "a\xc\xe6\x92\xad" },
Packit 78a954 
	{ CMUAP, 0, "[\xc2\x85-\xc2\x89\xc3\x89]", "\xc2\x84\xc3\xa9" },
Packit 78a954 
	{ MUAP, 0, "[^b-d^&\\s]{3,}", "db^ !a\xe2\x80\xa8_ae" },
Packit 78a954 
	{ MUAP, 0 | F_PROPERTY, "[^\\S\\P{Any}][\\sN]{1,3}[\\P{N}]{4}", "\xe2\x80\xaa\xa N\x9\xc3\xa9_0" },
Packit 78a954 
	{ MUA, 0 | F_PROPERTY, "[^\\P{L}\x9!D-F\xa]{2,3}", "\x9,.DF\xa.CG\xc3\x81" },
Packit 78a954 
	{ 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" },
Packit 78a954 
	{ 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" },
Packit 78a954 
	{ 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#" },
Packit 78a954 
	{ PCRE_UCP, 0, "[a-b\\s]{2,5}[^a]", "AB  baaa" },
Packit 78a954
Packit 78a954 
	/* Possible empty brackets. */
Packit 78a954 
	{ MUA, 0, "(?:|ab||bc|a)+d", "abcxabcabd" },
Packit 78a954 
	{ MUA, 0, "(|ab||bc|a)+d", "abcxabcabd" },
Packit 78a954 
	{ MUA, 0, "(?:|ab||bc|a)*d", "abcxabcabd" },
Packit 78a954 
	{ MUA, 0, "(|ab||bc|a)*d", "abcxabcabd" },
Packit 78a954 
	{ MUA, 0, "(?:|ab||bc|a)+?d", "abcxabcabd" },
Packit 78a954 
	{ MUA, 0, "(|ab||bc|a)+?d", "abcxabcabd" },
Packit 78a954 
	{ MUA, 0, "(?:|ab||bc|a)*?d", "abcxabcabd" },
Packit 78a954 
	{ MUA, 0, "(|ab||bc|a)*?d", "abcxabcabd" },
Packit 78a954 
	{ MUA, 0, "(((a)*?|(?:ba)+)+?|(?:|c|ca)*)*m", "abaacaccabacabalabaacaccabacabamm" },
Packit 78a954 
	{ MUA, 0, "(?:((?:a)*|(ba)+?)+|(|c|ca)*?)*?m", "abaacaccabacabalabaacaccabacabamm" },
Packit 78a954
Packit 78a954 
	/* Start offset. */
Packit 78a954 
	{ MUA, 3, "(\\d|(?:\\w)*\\w)+", "0ac01Hb" },
Packit 78a954 
	{ MUA, 4 | F_NOMATCH, "(\\w\\W\\w)+", "ab#d" },
Packit 78a954 
	{ MUA, 2 | F_NOMATCH, "(\\w\\W\\w)+", "ab#d" },
Packit 78a954 
	{ MUA, 1, "(\\w\\W\\w)+", "ab#d" },
Packit 78a954
Packit 78a954 
	/* Newline. */
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 0, "\\W{0,2}[^#]{3}", "\r\n#....." },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_NEWLINE_CR, 0, "\\W{0,2}[^#]{3}", "\r\n#....." },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 0, "\\W{1,3}[^#]", "\r\n##...." },
Packit 78a954 
	{ MUA | PCRE_NO_UTF8_CHECK, 1, "^.a", "\n\x80\nxa" },
Packit 78a954 
	{ MUA, 1, "^", "\r\n" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 1 | F_NOMATCH, "^", "\r\n" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 1, "^", "\r\na" },
Packit 78a954
Packit 78a954 
	/* Any character except newline or any newline. */
Packit 78a954 
	{ PCRE_NEWLINE_CRLF, 0, ".", "\r" },
Packit 78a954 
	{ PCRE_NEWLINE_CRLF | PCRE_UTF8, 0, ".(.).", "a\xc3\xa1\r\n\n\r\r" },
Packit 78a954 
	{ PCRE_NEWLINE_ANYCRLF, 0, ".(.)", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa8" },
Packit 78a954 
	{ PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".(.)", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa8" },
Packit 78a954 
	{ PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.).", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa9$de" },
Packit 78a954 
	{ PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0 | F_NOMATCH, ".(.).", "\xe2\x80\xa8\nb\r" },
Packit 78a954 
	{ PCRE_NEWLINE_ANY, 0, "(.)(.)", "#\x85#\r#\n#\r\n#\x84" },
Packit 78a954 
	{ PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.+)#", "#\rMn\xc2\x85#\n###" },
Packit 78a954 
	{ PCRE_BSR_ANYCRLF, 0, "\\R", "\r" },
Packit 78a954 
	{ PCRE_BSR_ANYCRLF, 0, "\\R", "\x85#\r\n#" },
Packit 78a954 
	{ PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\xe2\x80\xa8#c" },
Packit 78a954 
	{ PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\r\nc" },
Packit 78a954 
	{ PCRE_NEWLINE_CRLF | PCRE_BSR_UNICODE | PCRE_UTF8, 0, "(\\R.)+", "\xc2\x85\r\n#\xe2\x80\xa8\n\r\n\r" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "\\R+", "ab" },
Packit 78a954 
	{ MUA, 0, "\\R+", "ab\r\n\r" },
Packit 78a954 
	{ MUA, 0, "\\R*", "ab\r\n\r" },
Packit 78a954 
	{ MUA, 0, "\\R*", "\r\n\r" },
Packit 78a954 
	{ MUA, 0, "\\R{2,4}", "\r\nab\r\r" },
Packit 78a954 
	{ MUA, 0, "\\R{2,4}", "\r\nab\n\n\n\r\r\r" },
Packit 78a954 
	{ MUA, 0, "\\R{2,}", "\r\nab\n\n\n\r\r\r" },
Packit 78a954 
	{ MUA, 0, "\\R{0,3}", "\r\n\r\n\r\n\r\n\r\n" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "\\R+\\R\\R", "\r\n\r\n" },
Packit 78a954 
	{ MUA, 0, "\\R+\\R\\R", "\r\r\r" },
Packit 78a954 
	{ MUA, 0, "\\R*\\R\\R", "\n\r" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "\\R{2,4}\\R\\R", "\r\r\r" },
Packit 78a954 
	{ MUA, 0, "\\R{2,4}\\R\\R", "\r\r\r\r" },
Packit 78a954
Packit 78a954 
	/* Atomic groups (no fallback from "next" direction). */
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(?>ab)ab", "bab" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(?>(ab))ab", "bab" },
Packit 78a954 
	{ MUA, 0, "(?>ab)+abc(?>de)*def(?>gh)?ghe(?>ij)+?k(?>lm)*?n(?>op)?\?op",
Packit 78a954 
			"bababcdedefgheijijklmlmnop" },
Packit 78a954 
	{ MUA, 0, "(?>a(b)+a|(ab)?\?(b))an", "abban" },
Packit 78a954 
	{ MUA, 0, "(?>ab+a|(?:ab)?\?b)an", "abban" },
Packit 78a954 
	{ MUA, 0, "((?>ab|ad|)*?)(?>|c)*abad", "abababcababad" },
Packit 78a954 
	{ MUA, 0, "(?>(aa|b|)*+(?>(##)|###)*d|(aa)(?>(baa)?)m)", "aabaa#####da" },
Packit 78a954 
	{ MUA, 0, "((?>a|)+?)b", "aaacaaab" },
Packit 78a954 
	{ MUA, 0, "(?>x|)*$", "aaa" },
Packit 78a954 
	{ MUA, 0, "(?>(x)|)*$", "aaa" },
Packit 78a954 
	{ MUA, 0, "(?>x|())*$", "aaa" },
Packit 78a954 
	{ MUA, 0, "((?>[cxy]a|[a-d])*?)b", "aaa+ aaab" },
Packit 78a954 
	{ MUA, 0, "((?>[cxy](a)|[a-d])*?)b", "aaa+ aaab" },
Packit 78a954 
	{ MUA, 0, "(?>((?>(a+))))bab|(?>((?>(a+))))bb", "aaaabaaabaabab" },
Packit 78a954 
	{ MUA, 0, "(?>(?>a+))bab|(?>(?>a+))bb", "aaaabaaabaabab" },
Packit 78a954 
	{ MUA, 0, "(?>(a)c|(?>(c)|(a))a)b*?bab", "aaaabaaabaabab" },
Packit 78a954 
	{ MUA, 0, "(?>ac|(?>c|a)a)b*?bab", "aaaabaaabaabab" },
Packit 78a954 
	{ MUA, 0, "(?>(b)b|(a))*b(?>(c)|d)?x", "ababcaaabdbx" },
Packit 78a954 
	{ MUA, 0, "(?>bb|a)*b(?>c|d)?x", "ababcaaabdbx" },
Packit 78a954 
	{ MUA, 0, "(?>(bb)|a)*b(?>c|(d))?x", "ababcaaabdbx" },
Packit 78a954 
	{ MUA, 0, "(?>(a))*?(?>(a))+?(?>(a))??x", "aaaaaacccaaaaabax" },
Packit 78a954 
	{ MUA, 0, "(?>a)*?(?>a)+?(?>a)??x", "aaaaaacccaaaaabax" },
Packit 78a954 
	{ MUA, 0, "(?>(a)|)*?(?>(a)|)+?(?>(a)|)??x", "aaaaaacccaaaaabax" },
Packit 78a954 
	{ MUA, 0, "(?>a|)*?(?>a|)+?(?>a|)??x", "aaaaaacccaaaaabax" },
Packit 78a954 
	{ MUA, 0, "(?>a(?>(a{0,2}))*?b|aac)+b", "aaaaaaacaaaabaaaaacaaaabaacaaabb" },
Packit 78a954 
	{ CMA, 0, "(?>((?>a{32}|b+|(a*))?(?>c+|d*)?\?)+e)+?f", "aaccebbdde bbdaaaccebbdee bbdaaaccebbdeef" },
Packit 78a954 
	{ MUA, 0, "(?>(?:(?>aa|a||x)+?b|(?>aa|a||(x))+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" },
Packit 78a954 
	{ MUA, 0, "(?>(?:(?>aa|a||(x))+?b|(?>aa|a||x)+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" },
Packit 78a954 
	{ MUA, 0 | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d" },
Packit 78a954 
	{ MUA, 0 | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d#\xcc\x8d\xcc\x8d" },
Packit 78a954 
	{ MUA, 0 | F_PROPERTY, "\\X+..", "\xcc\x8d#\xcc\x8d#\xcc\x8d\xcc\x8d" },
Packit 78a954 
	{ MUA, 0 | F_PROPERTY, "\\X{2,4}", "abcdef" },
Packit 78a954 
	{ MUA, 0 | F_PROPERTY, "\\X{2,4}?", "abcdef" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH | F_PROPERTY, "\\X{2,4}..", "#\xcc\x8d##" },
Packit 78a954 
	{ MUA, 0 | F_PROPERTY, "\\X{2,4}..", "#\xcc\x8d#\xcc\x8d##" },
Packit 78a954 
	{ MUA, 0, "(c(ab)?+ab)+", "cabcababcab" },
Packit 78a954 
	{ MUA, 0, "(?>(a+)b)+aabab", "aaaabaaabaabab" },
Packit 78a954
Packit 78a954 
	/* Possessive quantifiers. */
Packit 78a954 
	{ MUA, 0, "(?:a|b)++m", "mababbaaxababbaam" },
Packit 78a954 
	{ MUA, 0, "(?:a|b)*+m", "mababbaaxababbaam" },
Packit 78a954 
	{ MUA, 0, "(?:a|b)*+m", "ababbaaxababbaam" },
Packit 78a954 
	{ MUA, 0, "(a|b)++m", "mababbaaxababbaam" },
Packit 78a954 
	{ MUA, 0, "(a|b)*+m", "mababbaaxababbaam" },
Packit 78a954 
	{ MUA, 0, "(a|b)*+m", "ababbaaxababbaam" },
Packit 78a954 
	{ MUA, 0, "(a|b(*ACCEPT))++m", "maaxab" },
Packit 78a954 
	{ MUA, 0, "(?:b*)++m", "bxbbxbbbxm" },
Packit 78a954 
	{ MUA, 0, "(?:b*)++m", "bxbbxbbbxbbm" },
Packit 78a954 
	{ MUA, 0, "(?:b*)*+m", "bxbbxbbbxm" },
Packit 78a954 
	{ MUA, 0, "(?:b*)*+m", "bxbbxbbbxbbm" },
Packit 78a954 
	{ MUA, 0, "(b*)++m", "bxbbxbbbxm" },
Packit 78a954 
	{ MUA, 0, "(b*)++m", "bxbbxbbbxbbm" },
Packit 78a954 
	{ MUA, 0, "(b*)*+m", "bxbbxbbbxm" },
Packit 78a954 
	{ MUA, 0, "(b*)*+m", "bxbbxbbbxbbm" },
Packit 78a954 
	{ MUA, 0, "(?:a|(b))++m", "mababbaaxababbaam" },
Packit 78a954 
	{ MUA, 0, "(?:(a)|b)*+m", "mababbaaxababbaam" },
Packit 78a954 
	{ MUA, 0, "(?:(a)|(b))*+m", "ababbaaxababbaam" },
Packit 78a954 
	{ MUA, 0, "(a|(b))++m", "mababbaaxababbaam" },
Packit 78a954 
	{ MUA, 0, "((a)|b)*+m", "mababbaaxababbaam" },
Packit 78a954 
	{ MUA, 0, "((a)|(b))*+m", "ababbaaxababbaam" },
Packit 78a954 
	{ MUA, 0, "(a|(b)(*ACCEPT))++m", "maaxab" },
Packit 78a954 
	{ MUA, 0, "(?:(b*))++m", "bxbbxbbbxm" },
Packit 78a954 
	{ MUA, 0, "(?:(b*))++m", "bxbbxbbbxbbm" },
Packit 78a954 
	{ MUA, 0, "(?:(b*))*+m", "bxbbxbbbxm" },
Packit 78a954 
	{ MUA, 0, "(?:(b*))*+m", "bxbbxbbbxbbm" },
Packit 78a954 
	{ MUA, 0, "((b*))++m", "bxbbxbbbxm" },
Packit 78a954 
	{ MUA, 0, "((b*))++m", "bxbbxbbbxbbm" },
Packit 78a954 
	{ MUA, 0, "((b*))*+m", "bxbbxbbbxm" },
Packit 78a954 
	{ MUA, 0, "((b*))*+m", "bxbbxbbbxbbm" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(?>(b{2,4}))(?:(?:(aa|c))++m|(?:(aa|c))+n)", "bbaacaaccaaaacxbbbmbn" },
Packit 78a954 
	{ MUA, 0, "((?:b)++a)+(cd)*+m", "bbababbacdcdnbbababbacdcdm" },
Packit 78a954 
	{ MUA, 0, "((?:(b))++a)+((c)d)*+m", "bbababbacdcdnbbababbacdcdm" },
Packit 78a954 
	{ MUA, 0, "(?:(?:(?:ab)*+k)++(?:n(?:cd)++)*+)*+m", "ababkkXababkkabkncXababkkabkncdcdncdXababkkabkncdcdncdkkabkncdXababkkabkncdcdncdkkabkncdm" },
Packit 78a954 
	{ MUA, 0, "(?:((ab)*+(k))++(n(?:c(d))++)*+)*+m", "ababkkXababkkabkncXababkkabkncdcdncdXababkkabkncdcdncdkkabkncdXababkkabkncdcdncdkkabkncdm" },
Packit 78a954
Packit 78a954 
	/* Back references. */
Packit 78a954 
	{ MUA, 0, "(aa|bb)(\\1*)(ll|)(\\3*)bbbbbbc", "aaaaaabbbbbbbbc" },
Packit 78a954 
	{ CMUA, 0, "(aa|bb)(\\1+)(ll|)(\\3+)bbbbbbc", "bBbbBbCbBbbbBbbcbbBbbbBBbbC" },
Packit 78a954 
	{ CMA, 0, "(a{2,4})\\1", "AaAaaAaA" },
Packit 78a954 
	{ MUA, 0, "(aa|bb)(\\1?)aa(\\1?)(ll|)(\\4+)bbc", "aaaaaaaabbaabbbbaabbbbc" },
Packit 78a954 
	{ MUA, 0, "(aa|bb)(\\1{0,5})(ll|)(\\3{0,5})cc", "bbxxbbbbxxaaaaaaaaaaaaaaaacc" },
Packit 78a954 
	{ MUA, 0, "(aa|bb)(\\1{3,5})(ll|)(\\3{3,5})cc", "bbbbbbbbbbbbaaaaaaccbbbbbbbbbbbbbbcc" },
Packit 78a954 
	{ MUA, 0, "(aa|bb)(\\1{3,})(ll|)(\\3{3,})cc", "bbbbbbbbbbbbaaaaaaccbbbbbbbbbbbbbbcc" },
Packit 78a954 
	{ MUA, 0, "(\\w+)b(\\1+)c", "GabGaGaDbGaDGaDc" },
Packit 78a954 
	{ MUA, 0, "(?:(aa)|b)\\1?b", "bb" },
Packit 78a954 
	{ CMUA, 0, "(aa|bb)(\\1*?)aa(\\1+?)", "bBBbaaAAaaAAaa" },
Packit 78a954 
	{ MUA, 0, "(aa|bb)(\\1*?)(dd|)cc(\\3+?)", "aaaaaccdd" },
Packit 78a954 
	{ CMUA, 0, "(?:(aa|bb)(\\1?\?)cc){2}(\\1?\?)", "aAaABBbbAAaAcCaAcCaA" },
Packit 78a954 
	{ MUA, 0, "(?:(aa|bb)(\\1{3,5}?)){2}(dd|)(\\3{3,5}?)", "aaaaaabbbbbbbbbbaaaaaaaaaaaaaa" },
Packit 78a954 
	{ CMA, 0, "(?:(aa|bb)(\\1{3,}?)){2}(dd|)(\\3{3,}?)", "aaaaaabbbbbbbbbbaaaaaaaaaaaaaa" },
Packit 78a954 
	{ MUA, 0, "(?:(aa|bb)(\\1{0,3}?)){2}(dd|)(\\3{0,3}?)b(\\1{0,3}?)(\\1{0,3})", "aaaaaaaaaaaaaaabaaaaa" },
Packit 78a954 
	{ MUA, 0, "(a(?:\\1|)a){3}b", "aaaaaaaaaaab" },
Packit 78a954 
	{ 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" },
Packit 78a954 
	{ MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{2,}", ".www." },
Packit 78a954 
	{ MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{0,2}", "wwwww." },
Packit 78a954 
	{ MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{1,2}ww", "wwww" },
Packit 78a954 
	{ MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{1,2}ww", "wwwww" },
Packit 78a954 
	{ PCRE_UCP, 0 | F_PROPERTY, "(\\P{N})\\1{2,}", ".www." },
Packit 78a954 
	{ CMUAP, 0, "(\xf0\x90\x90\x80)\\1", "\xf0\x90\x90\xa8\xf0\x90\x90\xa8" },
Packit 78a954 
	{ MUA | PCRE_DUPNAMES, 0 | F_NOMATCH, "\\k{1,3}(?aa)(?bb)", "aabb" },
Packit 78a954 
	{ MUA | PCRE_DUPNAMES | PCRE_JAVASCRIPT_COMPAT, 0, "\\k{1,3}(?aa)(?bb)", "aabb" },
Packit 78a954 
	{ MUA | PCRE_DUPNAMES | PCRE_JAVASCRIPT_COMPAT, 0, "\\k*(?aa)(?bb)", "aabb" },
Packit 78a954 
	{ MUA | PCRE_DUPNAMES, 0, "(?aa)(?bb)\\k{0,3}aaaaaa", "aabbaaaaaa" },
Packit 78a954 
	{ MUA | PCRE_DUPNAMES, 0, "(?aa)(?bb)\\k{2,5}bb", "aabbaaaabb" },
Packit 78a954 
	{ MUA | PCRE_DUPNAMES, 0, "(?:(?aa)|(?bb))\\k{0,3}m", "aaaaaaaabbbbaabbbbm" },
Packit 78a954 
	{ MUA | PCRE_DUPNAMES, 0 | F_NOMATCH, "\\k{1,3}?(?aa)(?bb)", "aabb" },
Packit 78a954 
	{ MUA | PCRE_DUPNAMES | PCRE_JAVASCRIPT_COMPAT, 0, "\\k{1,3}?(?aa)(?bb)", "aabb" },
Packit 78a954 
	{ MUA | PCRE_DUPNAMES, 0, "\\k*?(?aa)(?bb)", "aabb" },
Packit 78a954 
	{ MUA | PCRE_DUPNAMES, 0, "(?:(?aa)|(?bb))\\k{0,3}?m", "aaaaaabbbbbbaabbbbbbbbbbm" },
Packit 78a954 
	{ MUA | PCRE_DUPNAMES, 0, "(?:(?aa)|(?bb))\\k*?m", "aaaaaabbbbbbaabbbbbbbbbbm" },
Packit 78a954 
	{ MUA | PCRE_DUPNAMES, 0, "(?:(?aa)|(?bb))\\k{2,3}?", "aaaabbbbaaaabbbbbbbbbb" },
Packit 78a954 
	{ CMUA | PCRE_DUPNAMES, 0, "(?:(?AA)|(?BB))\\k{0,3}M", "aaaaaaaabbbbaabbbbm" },
Packit 78a954 
	{ CMUA | PCRE_DUPNAMES, 0, "(?:(?AA)|(?BB))\\k{1,3}M", "aaaaaaaabbbbaabbbbm" },
Packit 78a954 
	{ CMUA | PCRE_DUPNAMES, 0, "(?:(?AA)|(?BB))\\k{0,3}?M", "aaaaaabbbbbbaabbbbbbbbbbm" },
Packit 78a954 
	{ CMUA | PCRE_DUPNAMES, 0, "(?:(?AA)|(?BB))\\k{2,3}?", "aaaabbbbaaaabbbbbbbbbb" },
Packit 78a954
Packit 78a954 
	/* Assertions. */
Packit 78a954 
	{ MUA, 0, "(?=xx|yy|zz)\\w{4}", "abczzdefg" },
Packit 78a954 
	{ MUA, 0, "(?=((\\w+)b){3}|ab)", "dbbbb ab" },
Packit 78a954 
	{ MUA, 0, "(?!ab|bc|cd)[a-z]{2}", "Xabcdef" },
Packit 78a954 
	{ MUA, 0, "(?<=aaa|aa|a)a", "aaa" },
Packit 78a954 
	{ MUA, 2, "(?<=aaa|aa|a)a", "aaa" },
Packit 78a954 
	{ MA, 0, "(?<=aaa|aa|a)a", "aaa" },
Packit 78a954 
	{ MA, 2, "(?<=aaa|aa|a)a", "aaa" },
Packit 78a954 
	{ MUA, 0, "(\\d{2})(?!\\w+c|(((\\w?)m){2}n)+|\\1)", "x5656" },
Packit 78a954 
	{ MUA, 0, "((?=((\\d{2,6}\\w){2,}))\\w{5,20}K){2,}", "567v09708K12l00M00 567v09708K12l00M00K45K" },
Packit 78a954 
	{ MUA, 0, "(?=(?:(?=\\S+a)\\w*(b)){3})\\w+\\d", "bba bbab nbbkba nbbkba0kl" },
Packit 78a954 
	{ MUA, 0, "(?>a(?>(b+))a(?=(..)))*?k", "acabbcabbaabacabaabbakk" },
Packit 78a954 
	{ MUA, 0, "((?(?=(a))a)+k)", "bbak" },
Packit 78a954 
	{ MUA, 0, "((?(?=a)a)+k)", "bbak" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(?=(?>(a))m)amk", "a k" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(?!(?>(a))m)amk", "a k" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(?>(?=(a))am)amk", "a k" },
Packit 78a954 
	{ MUA, 0, "(?=(?>a|(?=(?>(b+))a|c)[a-c]+)*?m)[a-cm]+k", "aaam bbam baaambaam abbabba baaambaamk" },
Packit 78a954 
	{ MUA, 0, "(?> ?\?\\b(?(?=\\w{1,4}(a))m)\\w{0,8}bc){2,}?", "bca ssbc mabd ssbc mabc" },
Packit 78a954 
	{ MUA, 0, "(?:(?=ab)?[^n][^n])+m", "ababcdabcdcdabnababcdabcdcdabm" },
Packit 78a954 
	{ MUA, 0, "(?:(?=a(b))?[^n][^n])+m", "ababcdabcdcdabnababcdabcdcdabm" },
Packit 78a954 
	{ MUA, 0, "(?:(?=.(.))??\\1.)+m", "aabbbcbacccanaabbbcbacccam" },
Packit 78a954 
	{ MUA, 0, "(?:(?=.)??[a-c])+m", "abacdcbacacdcaccam" },
Packit 78a954 
	{ MUA, 0, "((?!a)?(?!([^a]))?)+$", "acbab" },
Packit 78a954 
	{ MUA, 0, "((?!a)?\?(?!([^a]))?\?)+$", "acbab" },
Packit 78a954
Packit 78a954 
	/* Not empty, ACCEPT, FAIL */
Packit 78a954 
	{ MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a*", "bcx" },
Packit 78a954 
	{ MUA | PCRE_NOTEMPTY, 0, "a*", "bcaad" },
Packit 78a954 
	{ MUA | PCRE_NOTEMPTY, 0, "a*?", "bcaad" },
Packit 78a954 
	{ MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*", "bcaad" },
Packit 78a954 
	{ MUA, 0, "a(*ACCEPT)b", "ab" },
Packit 78a954 
	{ MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a*(*ACCEPT)b", "bcx" },
Packit 78a954 
	{ MUA | PCRE_NOTEMPTY, 0, "a*(*ACCEPT)b", "bcaad" },
Packit 78a954 
	{ MUA | PCRE_NOTEMPTY, 0, "a*?(*ACCEPT)b", "bcaad" },
Packit 78a954 
	{ MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "(?:z|a*(*ACCEPT)b)", "bcx" },
Packit 78a954 
	{ MUA | PCRE_NOTEMPTY, 0, "(?:z|a*(*ACCEPT)b)", "bcaad" },
Packit 78a954 
	{ MUA | PCRE_NOTEMPTY, 0, "(?:z|a*?(*ACCEPT)b)", "bcaad" },
Packit 78a954 
	{ MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*(*ACCEPT)b", "bcx" },
Packit 78a954 
	{ MUA | PCRE_NOTEMPTY_ATSTART, 0 | F_NOMATCH, "a*(*ACCEPT)b", "" },
Packit 78a954 
	{ MUA, 0, "((a(*ACCEPT)b))", "ab" },
Packit 78a954 
	{ MUA, 0, "(a(*FAIL)a|a)", "aaa" },
Packit 78a954 
	{ MUA, 0, "(?=ab(*ACCEPT)b)a", "ab" },
Packit 78a954 
	{ MUA, 0, "(?=(?:x|ab(*ACCEPT)b))", "ab" },
Packit 78a954 
	{ MUA, 0, "(?=(a(b(*ACCEPT)b)))a", "ab" },
Packit 78a954 
	{ MUA | PCRE_NOTEMPTY, 0, "(?=a*(*ACCEPT))c", "c" },
Packit 78a954
Packit 78a954 
	/* Conditional blocks. */
Packit 78a954 
	{ MUA, 0, "(?(?=(a))a|b)+k", "ababbalbbadabak" },
Packit 78a954 
	{ MUA, 0, "(?(?!(b))a|b)+k", "ababbalbbadabak" },
Packit 78a954 
	{ MUA, 0, "(?(?=a)a|b)+k", "ababbalbbadabak" },
Packit 78a954 
	{ MUA, 0, "(?(?!b)a|b)+k", "ababbalbbadabak" },
Packit 78a954 
	{ MUA, 0, "(?(?=(a))a*|b*)+k", "ababbalbbadabak" },
Packit 78a954 
	{ MUA, 0, "(?(?!(b))a*|b*)+k", "ababbalbbadabak" },
Packit 78a954 
	{ MUA, 0, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },
Packit 78a954 
	{ MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },
Packit 78a954 
	{ MUA, 0 | F_DIFF, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" },
Packit 78a954 
	{ MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" },
Packit 78a954 
	{ MUA, 0, "(?(?=a)a*|b*)+k", "ababbalbbadabak" },
Packit 78a954 
	{ MUA, 0, "(?(?!b)a*|b*)+k", "ababbalbbadabak" },
Packit 78a954 
	{ MUA, 0, "(?(?=a)ab)", "a" },
Packit 78a954 
	{ MUA, 0, "(?(?
Packit 78a954 
	{ MUA, 0, "(?(DEFINE)a(b))", "a" },
Packit 78a954 
	{ MUA, 0, "a(?(DEFINE)(?:b|(?:c?)+)*)", "a" },
Packit 78a954 
	{ MUA, 0, "(?(?=.[a-c])[k-l]|[A-D])", "kdB" },
Packit 78a954 
	{ MUA, 0, "(?(?!.{0,4}[cd])(aa|bb)|(cc|dd))+", "aabbccddaa" },
Packit 78a954 
	{ MUA, 0, "(?(?=[^#@]*@)(aaab|aa|aba)|(aba|aab)){3,}", "aaabaaaba#aaabaaaba#aaabaaaba@" },
Packit 78a954 
	{ MUA, 0, "((?=\\w{5})\\w(?(?=\\w*k)\\d|[a-f_])*\\w\\s)+", "mol m10kk m088k _f_a_ mbkkl" },
Packit 78a954 
	{ MUA, 0, "(c)?\?(?(1)a|b)", "cdcaa" },
Packit 78a954 
	{ MUA, 0, "(c)?\?(?(1)a|b)", "cbb" },
Packit 78a954 
	{ MUA, 0 | F_DIFF, "(?(?=(a))(aaaa|a?))+aak", "aaaaab aaaaak" },
Packit 78a954 
	{ MUA, 0, "(?(?=a)(aaaa|a?))+aak", "aaaaab aaaaak" },
Packit 78a954 
	{ MUA, 0, "(?(?!(b))(aaaa|a?))+aak", "aaaaab aaaaak" },
Packit 78a954 
	{ MUA, 0, "(?(?!b)(aaaa|a?))+aak", "aaaaab aaaaak" },
Packit 78a954 
	{ MUA, 0 | F_DIFF, "(?(?=(a))a*)+aak", "aaaaab aaaaak" },
Packit 78a954 
	{ MUA, 0, "(?(?=a)a*)+aak", "aaaaab aaaaak" },
Packit 78a954 
	{ MUA, 0, "(?(?!(b))a*)+aak", "aaaaab aaaaak" },
Packit 78a954 
	{ MUA, 0, "(?(?!b)a*)+aak", "aaaaab aaaaak" },
Packit 78a954 
	{ MUA, 0, "(?(?=(?=(?!(x))a)aa)aaa|(?(?=(?!y)bb)bbb))*k", "abaabbaaabbbaaabbb abaabbaaabbbaaabbbk" },
Packit 78a954 
	{ MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)*l", "bc ddd abccabccl" },
Packit 78a954 
	{ MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+?dd", "bcabcacdb bdddd" },
Packit 78a954 
	{ MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+l", "ababccddabdbccd abcccl" },
Packit 78a954 
	{ MUA, 0, "((?:a|aa)(?(1)aaa))x", "aax" },
Packit 78a954 
	{ MUA, 0, "(?(?!)a|b)", "ab" },
Packit 78a954 
	{ MUA, 0, "(?(?!)a)", "ab" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(?(?!)a|b)", "ac" },
Packit 78a954
Packit 78a954 
	/* Set start of match. */
Packit 78a954 
	{ MUA, 0, "(?:\\Ka)*aaaab", "aaaaaaaa aaaaaaabb" },
Packit 78a954 
	{ MUA, 0, "(?>\\Ka\\Ka)*aaaab", "aaaaaaaa aaaaaaaaaabb" },
Packit 78a954 
	{ MUA, 0, "a+\\K(?<=\\Gaa)a", "aaaaaa" },
Packit 78a954 
	{ MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a\\K(*ACCEPT)b", "aa" },
Packit 78a954 
	{ MUA | PCRE_NOTEMPTY_ATSTART, 0, "a\\K(*ACCEPT)b", "aa" },
Packit 78a954
Packit 78a954 
	/* First line. */
Packit 78a954 
	{ MUA | PCRE_FIRSTLINE, 0 | F_PROPERTY, "\\p{Any}a", "bb\naaa" },
Packit 78a954 
	{ MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH | F_PROPERTY, "\\p{Any}a", "bb\r\naaa" },
Packit 78a954 
	{ MUA | PCRE_FIRSTLINE, 0, "(?<=a)", "a" },
Packit 78a954 
	{ MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[^a][^b]", "ab" },
Packit 78a954 
	{ MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "a", "\na" },
Packit 78a954 
	{ MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[abc]", "\na" },
Packit 78a954 
	{ MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^a", "\na" },
Packit 78a954 
	{ MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^(?<=\n)", "\na" },
Packit 78a954 
	{ MUA | PCRE_FIRSTLINE, 0, "\xf0\x90\x90\x80", "\xf0\x90\x90\x80" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\xc2\x85#" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\x85#" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^#", "\xe2\x80\xa8#" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_PROPERTY, "\\p{Any}", "\r\na" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, ".", "\r" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "a", "\ra" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_NOMATCH, "ba", "bbb\r\nba" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_NOMATCH | F_PROPERTY, "\\p{Any}{4}|a", "\r\na" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 1, ".", "\r\n" },
Packit 78a954 
	{ PCRE_FIRSTLINE | PCRE_NEWLINE_LF | PCRE_DOTALL, 0 | F_NOMATCH, "ab.", "ab" },
Packit 78a954 
	{ MUA | PCRE_FIRSTLINE, 1 | F_NOMATCH, "^[a-d0-9]", "\nxx\nd" },
Packit 78a954
Packit 78a954 
	/* Recurse. */
Packit 78a954 
	{ MUA, 0, "(a)(?1)", "aa" },
Packit 78a954 
	{ MUA, 0, "((a))(?1)", "aa" },
Packit 78a954 
	{ MUA, 0, "(b|a)(?1)", "aa" },
Packit 78a954 
	{ MUA, 0, "(b|(a))(?1)", "aa" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "((a)(b)(?:a*))(?1)", "aba" },
Packit 78a954 
	{ MUA, 0, "((a)(b)(?:a*))(?1)", "abab" },
Packit 78a954 
	{ MUA, 0, "((a+)c(?2))b(?1)", "aacaabaca" },
Packit 78a954 
	{ MUA, 0, "((?2)b|(a)){2}(?1)", "aabab" },
Packit 78a954 
	{ MUA, 0, "(?1)(a)*+(?2)(b(?1))", "aababa" },
Packit 78a954 
	{ MUA, 0, "(?1)(((a(*ACCEPT)))b)", "axaa" },
Packit 78a954 
	{ MUA, 0, "(?1)(?(DEFINE) (((ac(*ACCEPT)))b) )", "akaac" },
Packit 78a954 
	{ MUA, 0, "(a+)b(?1)b\\1", "abaaabaaaaa" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(?(DEFINE)(aa|a))(?1)ab", "aab" },
Packit 78a954 
	{ MUA, 0, "(?(DEFINE)(a\\Kb))(?1)+ababc", "abababxabababc" },
Packit 78a954 
	{ MUA, 0, "(a\\Kb)(?1)+ababc", "abababxababababc" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(a\\Kb)(?1)+ababc", "abababxababababxc" },
Packit 78a954 
	{ MUA, 0, "b|<(?R)*>", "<" },
Packit 78a954 
	{ MUA, 0, "(a\\K){0}(?:(?1)b|ac)", "ac" },
Packit 78a954 
	{ MUA, 0, "(?(DEFINE)(a(?2)|b)(b(?1)|(a)))(?:(?1)|(?2))m", "ababababnababababaam" },
Packit 78a954 
	{ MUA, 0, "(a)((?(R)a|b))(?2)", "aabbabaa" },
Packit 78a954 
	{ MUA, 0, "(a)((?(R2)a|b))(?2)", "aabbabaa" },
Packit 78a954 
	{ MUA, 0, "(a)((?(R1)a|b))(?2)", "ababba" },
Packit 78a954 
	{ MUA, 0, "(?(R0)aa|bb(?R))", "abba aabb bbaa" },
Packit 78a954 
	{ MUA, 0, "((?(R)(?:aaaa|a)|(?:(aaaa)|(a)))+)(?1)$", "aaaaaaaaaa aaaa" },
Packit 78a954 
	{ MUA, 0, "(?P<Name>a(?(R&Name)a|b))(?1)", "aab abb abaa" },
Packit 78a954 
	{ MUA, 0, "((?(R)a|(?1)){3})", "XaaaaaaaaaX" },
Packit 78a954 
	{ MUA, 0, "((?:(?(R)a|(?1))){3})", "XaaaaaaaaaX" },
Packit 78a954 
	{ MUA, 0, "((?(R)a|(?1)){1,3})aaaaaa", "aaaaaaaaXaaaaaaaaa" },
Packit 78a954 
	{ MUA, 0, "((?(R)a|(?1)){1,3}?)M", "aaaM" },
Packit 78a954
Packit 78a954 
	/* 16 bit specific tests. */
Packit 78a954 
	{ CMA, 0 | F_FORCECONV, "\xc3\xa1", "\xc3\x81\xc3\xa1" },
Packit 78a954 
	{ CMA, 0 | F_FORCECONV, "\xe1\xbd\xb8", "\xe1\xbf\xb8\xe1\xbd\xb8" },
Packit 78a954 
	{ CMA, 0 | F_FORCECONV, "[\xc3\xa1]", "\xc3\x81\xc3\xa1" },
Packit 78a954 
	{ CMA, 0 | F_FORCECONV, "[\xe1\xbd\xb8]", "\xe1\xbf\xb8\xe1\xbd\xb8" },
Packit 78a954 
	{ CMA, 0 | F_FORCECONV, "[a-\xed\xb0\x80]", "A" },
Packit 78a954 
	{ CMA, 0 | F_NO8 | F_FORCECONV, "[a-\\x{dc00}]", "B" },
Packit 78a954 
	{ CMA, 0 | F_NO8 | F_NOMATCH | F_FORCECONV, "[b-\\x{dc00}]", "a" },
Packit 78a954 
	{ 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" },
Packit 78a954 
	{ 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#" },
Packit 78a954 
	{ 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" },
Packit 78a954 
	{ CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xed\xb3\xbf]", "\xed\x9f\xbf\xed\xa0\x83" },
Packit 78a954 
	{ CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xed\xb3\xbf]", "\xed\xb4\x80\xed\xb3\xb0" },
Packit 78a954 
	{ CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\x9f\xbf\xed\xa0\x83" },
Packit 78a954 
	{ CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\xb4\x80\xed\xb3\xb0" },
Packit 78a954 
	{ 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#" },
Packit 78a954 
	{ 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" },
Packit 78a954 
	{ MA, 0 | F_FORCECONV, "[^\xed\xb0\x80]{3,}?", "##\xed\xb0\x80#\xed\xb0\x80#\xc3\x89#\xed\xb0\x80" },
Packit 78a954 
	{ MA, 0 | F_NO8 | F_FORCECONV, "[^\\x{dc00}]{3,}?", "##\xed\xb0\x80#\xed\xb0\x80#\xc3\x89#\xed\xb0\x80" },
Packit 78a954 
	{ CMA, 0 | F_FORCECONV, ".\\B.", "\xed\xa0\x80\xed\xb0\x80" },
Packit 78a954 
	{ 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" },
Packit 78a954 
	{ CMA, 0 | F_FORCECONV, "\\d*\\s*\\w*\xed\xa0\x80\xed\xa0\x80", "\xed\xa0\x80\xed\xa0\x80" },
Packit 78a954 
	{ CMA, 0 | F_FORCECONV | F_NOMATCH, "\\d*?\\D*?\\s*?\\S*?\\w*?\\W*?##", "\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80#" },
Packit 78a954 
	{ CMA | PCRE_EXTENDED, 0 | F_FORCECONV, "\xed\xa0\x80 \xed\xb0\x80 !", "\xed\xa0\x80\xed\xb0\x80!" },
Packit 78a954 
	{ CMA, 0 | F_FORCECONV, "\xed\xa0\x80+#[^#]+\xed\xa0\x80", "\xed\xa0\x80#a\xed\xa0\x80" },
Packit 78a954 
	{ CMA, 0 | F_FORCECONV, "(\xed\xa0\x80+)#\\1", "\xed\xa0\x80\xed\xa0\x80#\xed\xa0\x80\xed\xa0\x80" },
Packit 78a954 
	{ PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0 | F_NO8 | F_FORCECONV, "^-", "a--\xe2\x80\xa8--" },
Packit 78a954 
	{ PCRE_BSR_UNICODE, 0 | F_NO8 | F_FORCECONV, "\\R", "ab\xe2\x80\xa8" },
Packit 78a954 
	{ 0, 0 | F_NO8 | F_FORCECONV, "\\v", "ab\xe2\x80\xa9" },
Packit 78a954 
	{ 0, 0 | F_NO8 | F_FORCECONV, "\\h", "ab\xe1\xa0\x8e" },
Packit 78a954 
	{ 0, 0 | F_NO8 | F_FORCECONV, "\\v+?\\V+?#", "\xe2\x80\xa9\xe2\x80\xa9\xef\xbf\xbf\xef\xbf\xbf#" },
Packit 78a954 
	{ 0, 0 | F_NO8 | F_FORCECONV, "\\h+?\\H+?#", "\xe1\xa0\x8e\xe1\xa0\x8e\xef\xbf\xbf\xef\xbf\xbf#" },
Packit 78a954
Packit 78a954 
	/* Partial matching. */
Packit 78a954 
	{ MUA | PCRE_PARTIAL_SOFT, 0, "ab", "a" },
Packit 78a954 
	{ MUA | PCRE_PARTIAL_SOFT, 0, "ab|a", "a" },
Packit 78a954 
	{ MUA | PCRE_PARTIAL_HARD, 0, "ab|a", "a" },
Packit 78a954 
	{ MUA | PCRE_PARTIAL_SOFT, 0, "\\b#", "a" },
Packit 78a954 
	{ MUA | PCRE_PARTIAL_SOFT, 0, "(?<=a)b", "a" },
Packit 78a954 
	{ MUA | PCRE_PARTIAL_SOFT, 0, "abc|(?<=xxa)bc", "xxab" },
Packit 78a954 
	{ MUA | PCRE_PARTIAL_SOFT, 0, "a\\B", "a" },
Packit 78a954 
	{ MUA | PCRE_PARTIAL_HARD, 0, "a\\b", "a" },
Packit 78a954
Packit 78a954 
	/* (*MARK) verb. */
Packit 78a954 
	{ MUA, 0, "a(*MARK:aa)a", "ababaa" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "a(*:aa)a", "abab" },
Packit 78a954 
	{ MUA, 0, "a(*:aa)(b(*:bb)b|bc)", "abc" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "a(*:1)x|b(*:2)y", "abc" },
Packit 78a954 
	{ MUA, 0, "(?>a(*:aa))b|ac", "ac" },
Packit 78a954 
	{ MUA, 0, "(?(DEFINE)(a(*:aa)))(?1)", "a" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(?(DEFINE)((a)(*:aa)))(?1)b", "aa" },
Packit 78a954 
	{ MUA, 0, "(?(DEFINE)(a(*:aa)))a(?1)b|aac", "aac" },
Packit 78a954 
	{ MUA, 0, "(a(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
Packit 78a954 
	{ MUA, 0, "(a(*:aa)){0}(?:b(?1)b)+", "babba" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH | F_STUDY, "(a(*:aa)){0}(?:b(?1)b)+", "ba" },
Packit 78a954 
	{ MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
Packit 78a954 
	{ MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b)+", "babba" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH | F_STUDY, "(a\\K(*:aa)){0}(?:b(?1)b)+", "ba" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH | F_STUDY, "(*:mark)m", "a" },
Packit 78a954
Packit 78a954 
	/* (*COMMIT) verb. */
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "a(*COMMIT)b", "ac" },
Packit 78a954 
	{ MUA, 0, "aa(*COMMIT)b", "xaxaab" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "a(*COMMIT)(*:msg)b|ac", "ac" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(a(*COMMIT)b)++", "abac" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "((a)(*COMMIT)b)++", "abac" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(?=a(*COMMIT)b)ab|ad", "ad" },
Packit 78a954
Packit 78a954 
	/* (*PRUNE) verb. */
Packit 78a954 
	{ MUA, 0, "aa\\K(*PRUNE)b", "aaab" },
Packit 78a954 
	{ MUA, 0, "aa(*PRUNE:bb)b|a", "aa" },
Packit 78a954 
	{ MUA, 0, "(a)(a)(*PRUNE)b|(a)", "aa" },
Packit 78a954 
	{ MUA, 0, "(a)(a)(a)(a)(a)(a)(a)(a)(*PRUNE)b|(a)", "aaaaaaaa" },
Packit 78a954 
	{ MUA | PCRE_PARTIAL_SOFT, 0, "a(*PRUNE)a|", "a" },
Packit 78a954 
	{ MUA | PCRE_PARTIAL_SOFT, 0, "a(*PRUNE)a|m", "a" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(?=a(*PRUNE)b)ab|ad", "ad" },
Packit 78a954 
	{ MUA, 0, "a(*COMMIT)(*PRUNE)d|bc", "abc" },
Packit 78a954 
	{ MUA, 0, "(?=a(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(*COMMIT)(?=a(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
Packit 78a954 
	{ MUA, 0, "(?=(a)(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(*COMMIT)(?=(a)(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
Packit 78a954 
	{ MUA, 0, "(a(*COMMIT)b){0}a(?1)(*PRUNE)c|bc", "abc" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(a(*COMMIT)b){0}a(*COMMIT)(?1)(*PRUNE)c|bc", "abc" },
Packit 78a954 
	{ MUA, 0, "(a(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(*COMMIT)(a(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
Packit 78a954 
	{ MUA, 0, "((a)(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(*COMMIT)((a)(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
Packit 78a954 
	{ MUA, 0, "(?>a(*COMMIT)b)*abab(*PRUNE)d|ba", "ababab" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)*abab(*PRUNE)d|ba", "ababab" },
Packit 78a954 
	{ MUA, 0, "(?>a(*COMMIT)b)+abab(*PRUNE)d|ba", "ababab" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)+abab(*PRUNE)d|ba", "ababab" },
Packit 78a954 
	{ MUA, 0, "(?>a(*COMMIT)b)?ab(*PRUNE)d|ba", "aba" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)?ab(*PRUNE)d|ba", "aba" },
Packit 78a954 
	{ MUA, 0, "(?>a(*COMMIT)b)*?n(*PRUNE)d|ba", "abababn" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)*?n(*PRUNE)d|ba", "abababn" },
Packit 78a954 
	{ MUA, 0, "(?>a(*COMMIT)b)+?n(*PRUNE)d|ba", "abababn" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)+?n(*PRUNE)d|ba", "abababn" },
Packit 78a954 
	{ MUA, 0, "(?>a(*COMMIT)b)??n(*PRUNE)d|bn", "abn" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)??n(*PRUNE)d|bn", "abn" },
Packit 78a954
Packit 78a954 
	/* (*SKIP) verb. */
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(?=a(*SKIP)b)ab|ad", "ad" },
Packit 78a954
Packit 78a954 
	/* (*THEN) verb. */
Packit 78a954 
	{ MUA, 0, "((?:a(*THEN)|aab)(*THEN)c|a+)+m", "aabcaabcaabcaabcnacm" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "((?:a(*THEN)|aab)(*THEN)c|a+)+m", "aabcm" },
Packit 78a954 
	{ MUA, 0, "((?:a(*THEN)|aab)c|a+)+m", "aabcaabcnmaabcaabcm" },
Packit 78a954 
	{ MUA, 0, "((?:a|aab)(*THEN)c|a+)+m", "aam" },
Packit 78a954 
	{ MUA, 0, "((?:a(*COMMIT)|aab)(*THEN)c|a+)+m", "aam" },
Packit 78a954 
	{ MUA, 0, "(?(?=a(*THEN)b)ab|ad)", "ad" },
Packit 78a954 
	{ MUA, 0, "(?(?!a(*THEN)b)ad|add)", "add" },
Packit 78a954 
	{ MUA, 0 | F_NOMATCH, "(?(?=a)a(*THEN)b|ad)", "ad" },
Packit 78a954 
	{ MUA, 0, "(?!(?(?=a)ab|b(*THEN)d))bn|bnn", "bnn" },
Packit 78a954
Packit 78a954 
	/* Deep recursion. */
Packit 78a954 
	{ MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },
Packit 78a954 
	{ MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " },
Packit 78a954 
	{ MUA, 0, "((a?)+)+b", "aaaaaaaaaaaa b" },
Packit 78a954
Packit 78a954 
	/* Deep recursion: Stack limit reached. */
Packit 78a954 
	{ 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" },
Packit 78a954 
	{ MA, 0 | F_NOMATCH, "(?:a+)+b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
Packit 78a954 
	{ MA, 0 | F_NOMATCH, "(?:a+?)+?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
Packit 78a954 
	{ MA, 0 | F_NOMATCH, "(?:a*)*b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
Packit 78a954 
	{ MA, 0 | F_NOMATCH, "(?:a*?)*?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
Packit 78a954
Packit 78a954 
	{ 0, 0, NULL, NULL }
Packit 78a954 
};
Packit 78a954
Packit 78a954 
static const unsigned char *tables(int mode)
Packit 78a954 
{
Packit 78a954 
	/* The purpose of this function to allow valgrind
Packit 78a954 
	for reporting invalid reads and writes. */
Packit 78a954 
	static unsigned char *tables_copy;
Packit 78a954 
	const char *errorptr;
Packit 78a954 
	int erroroffset;
Packit 78a954 
	unsigned char *default_tables;
Packit 78a954 
#if defined SUPPORT_PCRE8
Packit 78a954 
	pcre *regex;
Packit 78a954 
	char null_str[1] = { 0 };
Packit 78a954 
#elif defined SUPPORT_PCRE16
Packit 78a954 
	pcre16 *regex;
Packit 78a954 
	PCRE_UCHAR16 null_str[1] = { 0 };
Packit 78a954 
#elif defined SUPPORT_PCRE32
Packit 78a954 
	pcre32 *regex;
Packit 78a954 
	PCRE_UCHAR32 null_str[1] = { 0 };
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
	if (mode) {
Packit 78a954 
		if (tables_copy)
Packit 78a954 
			free(tables_copy);
Packit 78a954 
		tables_copy = NULL;
Packit 78a954 
		return NULL;
Packit 78a954 
	}
Packit 78a954
Packit 78a954 
	if (tables_copy)
Packit 78a954 
		return tables_copy;
Packit 78a954
Packit 78a954 
	default_tables = NULL;
Packit 78a954 
#if defined SUPPORT_PCRE8
Packit 78a954 
	regex = pcre_compile(null_str, 0, &errorptr, &erroroffset, NULL);
Packit 78a954 
	if (regex) {
Packit 78a954 
		pcre_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
Packit 78a954 
		pcre_free(regex);
Packit 78a954 
	}
Packit 78a954 
#elif defined SUPPORT_PCRE16
Packit 78a954 
	regex = pcre16_compile(null_str, 0, &errorptr, &erroroffset, NULL);
Packit 78a954 
	if (regex) {
Packit 78a954 
		pcre16_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
Packit 78a954 
		pcre16_free(regex);
Packit 78a954 
	}
Packit 78a954 
#elif defined SUPPORT_PCRE32
Packit 78a954 
	regex = pcre32_compile(null_str, 0, &errorptr, &erroroffset, NULL);
Packit 78a954 
	if (regex) {
Packit 78a954 
		pcre32_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
Packit 78a954 
		pcre32_free(regex);
Packit 78a954 
	}
Packit 78a954 
#endif
Packit 78a954 
	/* Shouldn't ever happen. */
Packit 78a954 
	if (!default_tables)
Packit 78a954 
		return NULL;
Packit 78a954
Packit 78a954 
	/* Unfortunately this value cannot get from pcre_fullinfo.
Packit 78a954 
	Since this is a test program, this is acceptable at the moment. */
Packit 78a954 
	tables_copy = (unsigned char *)malloc(1088);
Packit 78a954 
	if (!tables_copy)
Packit 78a954 
		return NULL;
Packit 78a954
Packit 78a954 
	memcpy(tables_copy, default_tables, 1088);
Packit 78a954 
	return tables_copy;
Packit 78a954 
}
Packit 78a954
Packit 78a954 
#ifdef SUPPORT_PCRE8
Packit 78a954 
static pcre_jit_stack* callback8(void *arg)
Packit 78a954 
{
Packit 78a954 
	return (pcre_jit_stack *)arg;
Packit 78a954 
}
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954 
static pcre16_jit_stack* callback16(void *arg)
Packit 78a954 
{
Packit 78a954 
	return (pcre16_jit_stack *)arg;
Packit 78a954 
}
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954 
static pcre32_jit_stack* callback32(void *arg)
Packit 78a954 
{
Packit 78a954 
	return (pcre32_jit_stack *)arg;
Packit 78a954 
}
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
#ifdef SUPPORT_PCRE8
Packit 78a954 
static pcre_jit_stack *stack8;
Packit 78a954
Packit 78a954 
static pcre_jit_stack *getstack8(void)
Packit 78a954 
{
Packit 78a954 
	if (!stack8)
Packit 78a954 
		stack8 = pcre_jit_stack_alloc(1, 1024 * 1024);
Packit 78a954 
	return stack8;
Packit 78a954 
}
Packit 78a954
Packit 78a954 
static void setstack8(pcre_extra *extra)
Packit 78a954 
{
Packit 78a954 
	if (!extra) {
Packit 78a954 
		if (stack8)
Packit 78a954 
			pcre_jit_stack_free(stack8);
Packit 78a954 
		stack8 = NULL;
Packit 78a954 
		return;
Packit 78a954 
	}
Packit 78a954
Packit 78a954 
	pcre_assign_jit_stack(extra, callback8, getstack8());
Packit 78a954 
}
Packit 78a954 
#endif /* SUPPORT_PCRE8 */
Packit 78a954
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954 
static pcre16_jit_stack *stack16;
Packit 78a954
Packit 78a954 
static pcre16_jit_stack *getstack16(void)
Packit 78a954 
{
Packit 78a954 
	if (!stack16)
Packit 78a954 
		stack16 = pcre16_jit_stack_alloc(1, 1024 * 1024);
Packit 78a954 
	return stack16;
Packit 78a954 
}
Packit 78a954
Packit 78a954 
static void setstack16(pcre16_extra *extra)
Packit 78a954 
{
Packit 78a954 
	if (!extra) {
Packit 78a954 
		if (stack16)
Packit 78a954 
			pcre16_jit_stack_free(stack16);
Packit 78a954 
		stack16 = NULL;
Packit 78a954 
		return;
Packit 78a954 
	}
Packit 78a954
Packit 78a954 
	pcre16_assign_jit_stack(extra, callback16, getstack16());
Packit 78a954 
}
Packit 78a954 
#endif /* SUPPORT_PCRE16 */
Packit 78a954
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954 
static pcre32_jit_stack *stack32;
Packit 78a954
Packit 78a954 
static pcre32_jit_stack *getstack32(void)
Packit 78a954 
{
Packit 78a954 
	if (!stack32)
Packit 78a954 
		stack32 = pcre32_jit_stack_alloc(1, 1024 * 1024);
Packit 78a954 
	return stack32;
Packit 78a954 
}
Packit 78a954
Packit 78a954 
static void setstack32(pcre32_extra *extra)
Packit 78a954 
{
Packit 78a954 
	if (!extra) {
Packit 78a954 
		if (stack32)
Packit 78a954 
			pcre32_jit_stack_free(stack32);
Packit 78a954 
		stack32 = NULL;
Packit 78a954 
		return;
Packit 78a954 
	}
Packit 78a954
Packit 78a954 
	pcre32_assign_jit_stack(extra, callback32, getstack32());
Packit 78a954 
}
Packit 78a954 
#endif /* SUPPORT_PCRE32 */
Packit 78a954
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954
Packit 78a954 
static int convert_utf8_to_utf16(const char *input, PCRE_UCHAR16 *output, int *offsetmap, int max_length)
Packit 78a954 
{
Packit 78a954 
	unsigned char *iptr = (unsigned char*)input;
Packit 78a954 
	PCRE_UCHAR16 *optr = output;
Packit 78a954 
	unsigned int c;
Packit 78a954
Packit 78a954 
	if (max_length == 0)
Packit 78a954 
		return 0;
Packit 78a954
Packit 78a954 
	while (*iptr && max_length > 1) {
Packit 78a954 
		c = 0;
Packit 78a954 
		if (offsetmap)
Packit 78a954 
			*offsetmap++ = (int)(iptr - (unsigned char*)input);
Packit 78a954
Packit 78a954 
		if (*iptr < 0xc0)
Packit 78a954 
			c = *iptr++;
Packit 78a954 
		else if (!(*iptr & 0x20)) {
Packit 78a954 
			c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
Packit 78a954 
			iptr += 2;
Packit 78a954 
		} else if (!(*iptr & 0x10)) {
Packit 78a954 
			c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
Packit 78a954 
			iptr += 3;
Packit 78a954 
		} else if (!(*iptr & 0x08)) {
Packit 78a954 
			c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
Packit 78a954 
			iptr += 4;
Packit 78a954 
		}
Packit 78a954
Packit 78a954 
		if (c < 65536) {
Packit 78a954 
			*optr++ = c;
Packit 78a954 
			max_length--;
Packit 78a954 
		} else if (max_length <= 2) {
Packit 78a954 
			*optr = '\0';
Packit 78a954 
			return (int)(optr - output);
Packit 78a954 
		} else {
Packit 78a954 
			c -= 0x10000;
Packit 78a954 
			*optr++ = 0xd800 | ((c >> 10) & 0x3ff);
Packit 78a954 
			*optr++ = 0xdc00 | (c & 0x3ff);
Packit 78a954 
			max_length -= 2;
Packit 78a954 
			if (offsetmap)
Packit 78a954 
				offsetmap++;
Packit 78a954 
		}
Packit 78a954 
	}
Packit 78a954 
	if (offsetmap)
Packit 78a954 
		*offsetmap = (int)(iptr - (unsigned char*)input);
Packit 78a954 
	*optr = '\0';
Packit 78a954 
	return (int)(optr - output);
Packit 78a954 
}
Packit 78a954
Packit 78a954 
static int copy_char8_to_char16(const char *input, PCRE_UCHAR16 *output, int max_length)
Packit 78a954 
{
Packit 78a954 
	unsigned char *iptr = (unsigned char*)input;
Packit 78a954 
	PCRE_UCHAR16 *optr = output;
Packit 78a954
Packit 78a954 
	if (max_length == 0)
Packit 78a954 
		return 0;
Packit 78a954
Packit 78a954 
	while (*iptr && max_length > 1) {
Packit 78a954 
		*optr++ = *iptr++;
Packit 78a954 
		max_length--;
Packit 78a954 
	}
Packit 78a954 
	*optr = '\0';
Packit 78a954 
	return (int)(optr - output);
Packit 78a954 
}
Packit 78a954
Packit 78a954 
#define REGTEST_MAX_LENGTH16 4096
Packit 78a954 
static PCRE_UCHAR16 regtest_buf16[REGTEST_MAX_LENGTH16];
Packit 78a954 
static int regtest_offsetmap16[REGTEST_MAX_LENGTH16];
Packit 78a954
Packit 78a954 
#endif /* SUPPORT_PCRE16 */
Packit 78a954
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954
Packit 78a954 
static int convert_utf8_to_utf32(const char *input, PCRE_UCHAR32 *output, int *offsetmap, int max_length)
Packit 78a954 
{
Packit 78a954 
	unsigned char *iptr = (unsigned char*)input;
Packit 78a954 
	PCRE_UCHAR32 *optr = output;
Packit 78a954 
	unsigned int c;
Packit 78a954
Packit 78a954 
	if (max_length == 0)
Packit 78a954 
		return 0;
Packit 78a954
Packit 78a954 
	while (*iptr && max_length > 1) {
Packit 78a954 
		c = 0;
Packit 78a954 
		if (offsetmap)
Packit 78a954 
			*offsetmap++ = (int)(iptr - (unsigned char*)input);
Packit 78a954
Packit 78a954 
		if (*iptr < 0xc0)
Packit 78a954 
			c = *iptr++;
Packit 78a954 
		else if (!(*iptr & 0x20)) {
Packit 78a954 
			c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
Packit 78a954 
			iptr += 2;
Packit 78a954 
		} else if (!(*iptr & 0x10)) {
Packit 78a954 
			c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
Packit 78a954 
			iptr += 3;
Packit 78a954 
		} else if (!(*iptr & 0x08)) {
Packit 78a954 
			c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
Packit 78a954 
			iptr += 4;
Packit 78a954 
		}
Packit 78a954
Packit 78a954 
		*optr++ = c;
Packit 78a954 
		max_length--;
Packit 78a954 
	}
Packit 78a954 
	if (offsetmap)
Packit 78a954 
		*offsetmap = (int)(iptr - (unsigned char*)input);
Packit 78a954 
	*optr = 0;
Packit 78a954 
	return (int)(optr - output);
Packit 78a954 
}
Packit 78a954
Packit 78a954 
static int copy_char8_to_char32(const char *input, PCRE_UCHAR32 *output, int max_length)
Packit 78a954 
{
Packit 78a954 
	unsigned char *iptr = (unsigned char*)input;
Packit 78a954 
	PCRE_UCHAR32 *optr = output;
Packit 78a954
Packit 78a954 
	if (max_length == 0)
Packit 78a954 
		return 0;
Packit 78a954
Packit 78a954 
	while (*iptr && max_length > 1) {
Packit 78a954 
		*optr++ = *iptr++;
Packit 78a954 
		max_length--;
Packit 78a954 
	}
Packit 78a954 
	*optr = '\0';
Packit 78a954 
	return (int)(optr - output);
Packit 78a954 
}
Packit 78a954
Packit 78a954 
#define REGTEST_MAX_LENGTH32 4096
Packit 78a954 
static PCRE_UCHAR32 regtest_buf32[REGTEST_MAX_LENGTH32];
Packit 78a954 
static int regtest_offsetmap32[REGTEST_MAX_LENGTH32];
Packit 78a954
Packit 78a954 
#endif /* SUPPORT_PCRE32 */
Packit 78a954
Packit 78a954 
static int check_ascii(const char *input)
Packit 78a954 
{
Packit 78a954 
	const unsigned char *ptr = (unsigned char *)input;
Packit 78a954 
	while (*ptr) {
Packit 78a954 
		if (*ptr > 127)
Packit 78a954 
			return 0;
Packit 78a954 
		ptr++;
Packit 78a954 
	}
Packit 78a954 
	return 1;
Packit 78a954 
}
Packit 78a954
Packit 78a954 
static int regression_tests(void)
Packit 78a954 
{
Packit 78a954 
	struct regression_test_case *current = regression_test_cases;
Packit 78a954 
	const char *error;
Packit 78a954 
	char *cpu_info;
Packit 78a954 
	int i, err_offs;
Packit 78a954 
	int is_successful, is_ascii;
Packit 78a954 
	int total = 0;
Packit 78a954 
	int successful = 0;
Packit 78a954 
	int successful_row = 0;
Packit 78a954 
	int counter = 0;
Packit 78a954 
	int study_mode;
Packit 78a954 
	int utf = 0, ucp = 0;
Packit 78a954 
	int disabled_flags = 0;
Packit 78a954 
#ifdef SUPPORT_PCRE8
Packit 78a954 
	pcre *re8;
Packit 78a954 
	pcre_extra *extra8;
Packit 78a954 
	pcre_extra dummy_extra8;
Packit 78a954 
	int ovector8_1[32];
Packit 78a954 
	int ovector8_2[32];
Packit 78a954 
	int return_value8[2];
Packit 78a954 
	unsigned char *mark8_1, *mark8_2;
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954 
	pcre16 *re16;
Packit 78a954 
	pcre16_extra *extra16;
Packit 78a954 
	pcre16_extra dummy_extra16;
Packit 78a954 
	int ovector16_1[32];
Packit 78a954 
	int ovector16_2[32];
Packit 78a954 
	int return_value16[2];
Packit 78a954 
	PCRE_UCHAR16 *mark16_1, *mark16_2;
Packit 78a954 
	int length16;
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954 
	pcre32 *re32;
Packit 78a954 
	pcre32_extra *extra32;
Packit 78a954 
	pcre32_extra dummy_extra32;
Packit 78a954 
	int ovector32_1[32];
Packit 78a954 
	int ovector32_2[32];
Packit 78a954 
	int return_value32[2];
Packit 78a954 
	PCRE_UCHAR32 *mark32_1, *mark32_2;
Packit 78a954 
	int length32;
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
	/* This test compares the behaviour of interpreter and JIT. Although disabling
Packit 78a954 
	utf or ucp may make tests fail, if the pcre_exec result is the SAME, it is
Packit 78a954 
	still considered successful from pcre_jit_test point of view. */
Packit 78a954
Packit 78a954 
#if defined SUPPORT_PCRE8
Packit 78a954 
	pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);
Packit 78a954 
#elif defined SUPPORT_PCRE16
Packit 78a954 
	pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);
Packit 78a954 
#elif defined SUPPORT_PCRE32
Packit 78a954 
	pcre32_config(PCRE_CONFIG_JITTARGET, &cpu_info);
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
	printf("Running JIT regression tests\n");
Packit 78a954 
	printf("  target CPU of SLJIT compiler: %s\n", cpu_info);
Packit 78a954
Packit 78a954 
#if defined SUPPORT_PCRE8
Packit 78a954 
	pcre_config(PCRE_CONFIG_UTF8, &utf;;
Packit 78a954 
	pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp;;
Packit 78a954 
#elif defined SUPPORT_PCRE16
Packit 78a954 
	pcre16_config(PCRE_CONFIG_UTF16, &utf;;
Packit 78a954 
	pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp;;
Packit 78a954 
#elif defined SUPPORT_PCRE32
Packit 78a954 
	pcre32_config(PCRE_CONFIG_UTF32, &utf;;
Packit 78a954 
	pcre32_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp;;
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
	if (!utf)
Packit 78a954 
		disabled_flags |= PCRE_UTF8 | PCRE_UTF16 | PCRE_UTF32;
Packit 78a954 
	if (!ucp)
Packit 78a954 
		disabled_flags |= PCRE_UCP;
Packit 78a954 
#ifdef SUPPORT_PCRE8
Packit 78a954 
	printf("  in  8 bit mode with UTF-8  %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954 
	printf("  in 16 bit mode with UTF-16 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954 
	printf("  in 32 bit mode with UTF-32 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
	while (current->pattern) {
Packit 78a954 
		/* printf("\nPattern: %s :\n", current->pattern); */
Packit 78a954 
		total++;
Packit 78a954 
		is_ascii = 0;
Packit 78a954 
		if (!(current->start_offset & F_PROPERTY))
Packit 78a954 
			is_ascii = check_ascii(current->pattern) && check_ascii(current->input);
Packit 78a954
Packit 78a954 
		if (current->flags & PCRE_PARTIAL_SOFT)
Packit 78a954 
			study_mode = PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE;
Packit 78a954 
		else if (current->flags & PCRE_PARTIAL_HARD)
Packit 78a954 
			study_mode = PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE;
Packit 78a954 
		else
Packit 78a954 
			study_mode = PCRE_STUDY_JIT_COMPILE;
Packit 78a954 
		error = NULL;
Packit 78a954 
#ifdef SUPPORT_PCRE8
Packit 78a954 
		re8 = NULL;
Packit 78a954 
		if (!(current->start_offset & F_NO8))
Packit 78a954 
			re8 = pcre_compile(current->pattern,
Packit 78a954 
				current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
Packit 78a954 
				&error, &err_offs, tables(0));
Packit 78a954
Packit 78a954 
		extra8 = NULL;
Packit 78a954 
		if (re8) {
Packit 78a954 
			error = NULL;
Packit 78a954 
			extra8 = pcre_study(re8, study_mode, &error);
Packit 78a954 
			if (!extra8) {
Packit 78a954 
				printf("\n8 bit: Cannot study pattern: %s\n", current->pattern);
Packit 78a954 
				pcre_free(re8);
Packit 78a954 
				re8 = NULL;
Packit 78a954 
			}
Packit 78a954 
			else if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
Packit 78a954 
				printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);
Packit 78a954 
				pcre_free_study(extra8);
Packit 78a954 
				pcre_free(re8);
Packit 78a954 
				re8 = NULL;
Packit 78a954 
			}
Packit 78a954 
			extra8->flags |= PCRE_EXTRA_MARK;
Packit 78a954 
		} else if (((utf && ucp) || is_ascii) && !(current->start_offset & F_NO8))
Packit 78a954 
			printf("\n8 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954 
		if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
Packit 78a954 
			convert_utf8_to_utf16(current->pattern, regtest_buf16, NULL, REGTEST_MAX_LENGTH16);
Packit 78a954 
		else
Packit 78a954 
			copy_char8_to_char16(current->pattern, regtest_buf16, REGTEST_MAX_LENGTH16);
Packit 78a954
Packit 78a954 
		re16 = NULL;
Packit 78a954 
		if (!(current->start_offset & F_NO16))
Packit 78a954 
			re16 = pcre16_compile(regtest_buf16,
Packit 78a954 
				current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
Packit 78a954 
				&error, &err_offs, tables(0));
Packit 78a954
Packit 78a954 
		extra16 = NULL;
Packit 78a954 
		if (re16) {
Packit 78a954 
			error = NULL;
Packit 78a954 
			extra16 = pcre16_study(re16, study_mode, &error);
Packit 78a954 
			if (!extra16) {
Packit 78a954 
				printf("\n16 bit: Cannot study pattern: %s\n", current->pattern);
Packit 78a954 
				pcre16_free(re16);
Packit 78a954 
				re16 = NULL;
Packit 78a954 
			}
Packit 78a954 
			else if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
Packit 78a954 
				printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);
Packit 78a954 
				pcre16_free_study(extra16);
Packit 78a954 
				pcre16_free(re16);
Packit 78a954 
				re16 = NULL;
Packit 78a954 
			}
Packit 78a954 
			extra16->flags |= PCRE_EXTRA_MARK;
Packit 78a954 
		} else if (((utf && ucp) || is_ascii) && !(current->start_offset & F_NO16))
Packit 78a954 
			printf("\n16 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954 
		if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
Packit 78a954 
			convert_utf8_to_utf32(current->pattern, regtest_buf32, NULL, REGTEST_MAX_LENGTH32);
Packit 78a954 
		else
Packit 78a954 
			copy_char8_to_char32(current->pattern, regtest_buf32, REGTEST_MAX_LENGTH32);
Packit 78a954
Packit 78a954 
		re32 = NULL;
Packit 78a954 
		if (!(current->start_offset & F_NO32))
Packit 78a954 
			re32 = pcre32_compile(regtest_buf32,
Packit 78a954 
				current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
Packit 78a954 
				&error, &err_offs, tables(0));
Packit 78a954
Packit 78a954 
		extra32 = NULL;
Packit 78a954 
		if (re32) {
Packit 78a954 
			error = NULL;
Packit 78a954 
			extra32 = pcre32_study(re32, study_mode, &error);
Packit 78a954 
			if (!extra32) {
Packit 78a954 
				printf("\n32 bit: Cannot study pattern: %s\n", current->pattern);
Packit 78a954 
				pcre32_free(re32);
Packit 78a954 
				re32 = NULL;
Packit 78a954 
			}
Packit 78a954 
			if (!(extra32->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
Packit 78a954 
				printf("\n32 bit: JIT compiler does not support: %s\n", current->pattern);
Packit 78a954 
				pcre32_free_study(extra32);
Packit 78a954 
				pcre32_free(re32);
Packit 78a954 
				re32 = NULL;
Packit 78a954 
			}
Packit 78a954 
			extra32->flags |= PCRE_EXTRA_MARK;
Packit 78a954 
		} else if (((utf && ucp) || is_ascii) && !(current->start_offset & F_NO32))
Packit 78a954 
			printf("\n32 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
		counter++;
Packit 78a954 
		if ((counter & 0x3) != 0) {
Packit 78a954 
#ifdef SUPPORT_PCRE8
Packit 78a954 
			setstack8(NULL);
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954 
			setstack16(NULL);
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954 
			setstack32(NULL);
Packit 78a954 
#endif
Packit 78a954 
		}
Packit 78a954
Packit 78a954 
#ifdef SUPPORT_PCRE8
Packit 78a954 
		return_value8[0] = -1000;
Packit 78a954 
		return_value8[1] = -1000;
Packit 78a954 
		for (i = 0; i < 32; ++i)
Packit 78a954 
			ovector8_1[i] = -2;
Packit 78a954 
		for (i = 0; i < 32; ++i)
Packit 78a954 
			ovector8_2[i] = -2;
Packit 78a954 
		if (re8) {
Packit 78a954 
			mark8_1 = NULL;
Packit 78a954 
			mark8_2 = NULL;
Packit 78a954 
			extra8->mark = &mark8_1;
Packit 78a954
Packit 78a954 
			if ((counter & 0x1) != 0) {
Packit 78a954 
				setstack8(extra8);
Packit 78a954 
				return_value8[0] = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
Packit 78a954 
					current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | PCRE_NO_UTF8_CHECK), ovector8_1, 32);
Packit 78a954 
			} else
Packit 78a954 
				return_value8[0] = pcre_jit_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
Packit 78a954 
					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());
Packit 78a954 
			memset(&dummy_extra8, 0, sizeof(pcre_extra));
Packit 78a954 
			dummy_extra8.flags = PCRE_EXTRA_MARK;
Packit 78a954 
			if (current->start_offset & F_STUDY) {
Packit 78a954 
				dummy_extra8.flags |= PCRE_EXTRA_STUDY_DATA;
Packit 78a954 
				dummy_extra8.study_data = extra8->study_data;
Packit 78a954 
			}
Packit 78a954 
			dummy_extra8.mark = &mark8_2;
Packit 78a954 
			return_value8[1] = pcre_exec(re8, &dummy_extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
Packit 78a954 
				current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | PCRE_NO_UTF8_CHECK), ovector8_2, 32);
Packit 78a954 
		}
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954 
		return_value16[0] = -1000;
Packit 78a954 
		return_value16[1] = -1000;
Packit 78a954 
		for (i = 0; i < 32; ++i)
Packit 78a954 
			ovector16_1[i] = -2;
Packit 78a954 
		for (i = 0; i < 32; ++i)
Packit 78a954 
			ovector16_2[i] = -2;
Packit 78a954 
		if (re16) {
Packit 78a954 
			mark16_1 = NULL;
Packit 78a954 
			mark16_2 = NULL;
Packit 78a954 
			if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
Packit 78a954 
				length16 = convert_utf8_to_utf16(current->input, regtest_buf16, regtest_offsetmap16, REGTEST_MAX_LENGTH16);
Packit 78a954 
			else
Packit 78a954 
				length16 = copy_char8_to_char16(current->input, regtest_buf16, REGTEST_MAX_LENGTH16);
Packit 78a954 
			extra16->mark = &mark16_1;
Packit 78a954 
			if ((counter & 0x1) != 0) {
Packit 78a954 
				setstack16(extra16);
Packit 78a954 
				return_value16[0] = pcre16_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
Packit 78a954 
					current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | PCRE_NO_UTF8_CHECK), ovector16_1, 32);
Packit 78a954 
			} else
Packit 78a954 
				return_value16[0] = pcre16_jit_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
Packit 78a954 
					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());
Packit 78a954 
			memset(&dummy_extra16, 0, sizeof(pcre16_extra));
Packit 78a954 
			dummy_extra16.flags = PCRE_EXTRA_MARK;
Packit 78a954 
			if (current->start_offset & F_STUDY) {
Packit 78a954 
				dummy_extra16.flags |= PCRE_EXTRA_STUDY_DATA;
Packit 78a954 
				dummy_extra16.study_data = extra16->study_data;
Packit 78a954 
			}
Packit 78a954 
			dummy_extra16.mark = &mark16_2;
Packit 78a954 
			return_value16[1] = pcre16_exec(re16, &dummy_extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
Packit 78a954 
				current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | PCRE_NO_UTF8_CHECK), ovector16_2, 32);
Packit 78a954 
		}
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954 
		return_value32[0] = -1000;
Packit 78a954 
		return_value32[1] = -1000;
Packit 78a954 
		for (i = 0; i < 32; ++i)
Packit 78a954 
			ovector32_1[i] = -2;
Packit 78a954 
		for (i = 0; i < 32; ++i)
Packit 78a954 
			ovector32_2[i] = -2;
Packit 78a954 
		if (re32) {
Packit 78a954 
			mark32_1 = NULL;
Packit 78a954 
			mark32_2 = NULL;
Packit 78a954 
			if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
Packit 78a954 
				length32 = convert_utf8_to_utf32(current->input, regtest_buf32, regtest_offsetmap32, REGTEST_MAX_LENGTH32);
Packit 78a954 
			else
Packit 78a954 
				length32 = copy_char8_to_char32(current->input, regtest_buf32, REGTEST_MAX_LENGTH32);
Packit 78a954 
			extra32->mark = &mark32_1;
Packit 78a954 
			if ((counter & 0x1) != 0) {
Packit 78a954 
				setstack32(extra32);
Packit 78a954 
				return_value32[0] = pcre32_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
Packit 78a954 
					current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | PCRE_NO_UTF8_CHECK), ovector32_1, 32);
Packit 78a954 
			} else
Packit 78a954 
				return_value32[0] = pcre32_jit_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
Packit 78a954 
					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());
Packit 78a954 
			memset(&dummy_extra32, 0, sizeof(pcre32_extra));
Packit 78a954 
			dummy_extra32.flags = PCRE_EXTRA_MARK;
Packit 78a954 
			if (current->start_offset & F_STUDY) {
Packit 78a954 
				dummy_extra32.flags |= PCRE_EXTRA_STUDY_DATA;
Packit 78a954 
				dummy_extra32.study_data = extra32->study_data;
Packit 78a954 
			}
Packit 78a954 
			dummy_extra32.mark = &mark32_2;
Packit 78a954 
			return_value32[1] = pcre32_exec(re32, &dummy_extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
Packit 78a954 
				current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | PCRE_NO_UTF8_CHECK), ovector32_2, 32);
Packit 78a954 
		}
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
		/* printf("[%d-%d-%d|%d-%d|%d-%d|%d-%d]%s",
Packit 78a954 
			return_value8[0], return_value16[0], return_value32[0],
Packit 78a954 
			ovector8_1[0], ovector8_1[1],
Packit 78a954 
			ovector16_1[0], ovector16_1[1],
Packit 78a954 
			ovector32_1[0], ovector32_1[1],
Packit 78a954 
			(current->flags & PCRE_CASELESS) ? "C" : ""); */
Packit 78a954
Packit 78a954 
		/* If F_DIFF is set, just run the test, but do not compare the results.
Packit 78a954 
		Segfaults can still be captured. */
Packit 78a954
Packit 78a954 
		is_successful = 1;
Packit 78a954 
		if (!(current->start_offset & F_DIFF)) {
Packit 78a954 
#if defined SUPPORT_UTF && ((defined(SUPPORT_PCRE8) + defined(SUPPORT_PCRE16) + defined(SUPPORT_PCRE32)) >= 2)
Packit 78a954 
			if (!(current->start_offset & F_FORCECONV)) {
Packit 78a954 
				int return_value;
Packit 78a954
Packit 78a954 
				/* All results must be the same. */
Packit 78a954 
#ifdef SUPPORT_PCRE8
Packit 78a954 
				if ((return_value = return_value8[0]) != return_value8[1]) {
Packit 78a954 
					printf("\n8 bit: Return value differs(J8:%d,I8:%d): [%d] '%s' @ '%s'\n",
Packit 78a954 
						return_value8[0], return_value8[1], total, current->pattern, current->input);
Packit 78a954 
					is_successful = 0;
Packit 78a954 
				} else
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954 
				if ((return_value = return_value16[0]) != return_value16[1]) {
Packit 78a954 
					printf("\n16 bit: Return value differs(J16:%d,I16:%d): [%d] '%s' @ '%s'\n",
Packit 78a954 
						return_value16[0], return_value16[1], total, current->pattern, current->input);
Packit 78a954 
					is_successful = 0;
Packit 78a954 
				} else
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954 
				if ((return_value = return_value32[0]) != return_value32[1]) {
Packit 78a954 
					printf("\n32 bit: Return value differs(J32:%d,I32:%d): [%d] '%s' @ '%s'\n",
Packit 78a954 
						return_value32[0], return_value32[1], total, current->pattern, current->input);
Packit 78a954 
					is_successful = 0;
Packit 78a954 
				} else
Packit 78a954 
#endif
Packit 78a954 
#if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
Packit 78a954 
				if (return_value8[0] != return_value16[0]) {
Packit 78a954 
					printf("\n8 and 16 bit: Return value differs(J8:%d,J16:%d): [%d] '%s' @ '%s'\n",
Packit 78a954 
						return_value8[0], return_value16[0],
Packit 78a954 
						total, current->pattern, current->input);
Packit 78a954 
					is_successful = 0;
Packit 78a954 
				} else
Packit 78a954 
#endif
Packit 78a954 
#if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
Packit 78a954 
				if (return_value8[0] != return_value32[0]) {
Packit 78a954 
					printf("\n8 and 32 bit: Return value differs(J8:%d,J32:%d): [%d] '%s' @ '%s'\n",
Packit 78a954 
						return_value8[0], return_value32[0],
Packit 78a954 
						total, current->pattern, current->input);
Packit 78a954 
					is_successful = 0;
Packit 78a954 
				} else
Packit 78a954 
#endif
Packit 78a954 
#if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE32
Packit 78a954 
				if (return_value16[0] != return_value32[0]) {
Packit 78a954 
					printf("\n16 and 32 bit: Return value differs(J16:%d,J32:%d): [%d] '%s' @ '%s'\n",
Packit 78a954 
						return_value16[0], return_value32[0],
Packit 78a954 
						total, current->pattern, current->input);
Packit 78a954 
					is_successful = 0;
Packit 78a954 
				} else
Packit 78a954 
#endif
Packit 78a954 
				if (return_value >= 0 || return_value == PCRE_ERROR_PARTIAL) {
Packit 78a954 
					if (return_value == PCRE_ERROR_PARTIAL) {
Packit 78a954 
						return_value = 2;
Packit 78a954 
					} else {
Packit 78a954 
						return_value *= 2;
Packit 78a954 
					}
Packit 78a954 
#ifdef SUPPORT_PCRE8
Packit 78a954 
					return_value8[0] = return_value;
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954 
					return_value16[0] = return_value;
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954 
					return_value32[0] = return_value;
Packit 78a954 
#endif
Packit 78a954 
					/* Transform back the results. */
Packit 78a954 
					if (current->flags & PCRE_UTF8) {
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954 
						for (i = 0; i < return_value; ++i) {
Packit 78a954 
							if (ovector16_1[i] >= 0)
Packit 78a954 
								ovector16_1[i] = regtest_offsetmap16[ovector16_1[i]];
Packit 78a954 
							if (ovector16_2[i] >= 0)
Packit 78a954 
								ovector16_2[i] = regtest_offsetmap16[ovector16_2[i]];
Packit 78a954 
						}
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954 
						for (i = 0; i < return_value; ++i) {
Packit 78a954 
							if (ovector32_1[i] >= 0)
Packit 78a954 
								ovector32_1[i] = regtest_offsetmap32[ovector32_1[i]];
Packit 78a954 
							if (ovector32_2[i] >= 0)
Packit 78a954 
								ovector32_2[i] = regtest_offsetmap32[ovector32_2[i]];
Packit 78a954 
						}
Packit 78a954 
#endif
Packit 78a954 
					}
Packit 78a954
Packit 78a954 
					for (i = 0; i < return_value; ++i) {
Packit 78a954 
#if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
Packit 78a954 
						if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector16_1[i] || ovector8_1[i] != ovector16_2[i]) {
Packit 78a954 
							printf("\n8 and 16 bit: Ovector[%d] value differs(J8:%d,I8:%d,J16:%d,I16:%d): [%d] '%s' @ '%s' \n",
Packit 78a954 
								i, ovector8_1[i], ovector8_2[i], ovector16_1[i], ovector16_2[i],
Packit 78a954 
								total, current->pattern, current->input);
Packit 78a954 
							is_successful = 0;
Packit 78a954 
						}
Packit 78a954 
#endif
Packit 78a954 
#if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
Packit 78a954 
						if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector32_1[i] || ovector8_1[i] != ovector32_2[i]) {
Packit 78a954 
							printf("\n8 and 32 bit: Ovector[%d] value differs(J8:%d,I8:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
Packit 78a954 
								i, ovector8_1[i], ovector8_2[i], ovector32_1[i], ovector32_2[i],
Packit 78a954 
								total, current->pattern, current->input);
Packit 78a954 
							is_successful = 0;
Packit 78a954 
						}
Packit 78a954 
#endif
Packit 78a954 
#if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE16
Packit 78a954 
						if (ovector16_1[i] != ovector16_2[i] || ovector16_1[i] != ovector16_1[i] || ovector16_1[i] != ovector16_2[i]) {
Packit 78a954 
							printf("\n16 and 16 bit: Ovector[%d] value differs(J16:%d,I16:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
Packit 78a954 
								i, ovector16_1[i], ovector16_2[i], ovector16_1[i], ovector16_2[i],
Packit 78a954 
								total, current->pattern, current->input);
Packit 78a954 
							is_successful = 0;
Packit 78a954 
						}
Packit 78a954 
#endif
Packit 78a954 
					}
Packit 78a954 
				}
Packit 78a954 
			} else
Packit 78a954 
#endif /* more than one of SUPPORT_PCRE8, SUPPORT_PCRE16 and SUPPORT_PCRE32 */
Packit 78a954 
			{
Packit 78a954 
				/* Only the 8 bit and 16 bit results must be equal. */
Packit 78a954 
#ifdef SUPPORT_PCRE8
Packit 78a954 
				if (return_value8[0] != return_value8[1]) {
Packit 78a954 
					printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
Packit 78a954 
						return_value8[0], return_value8[1], total, current->pattern, current->input);
Packit 78a954 
					is_successful = 0;
Packit 78a954 
				} else if (return_value8[0] >= 0 || return_value8[0] == PCRE_ERROR_PARTIAL) {
Packit 78a954 
					if (return_value8[0] == PCRE_ERROR_PARTIAL)
Packit 78a954 
						return_value8[0] = 2;
Packit 78a954 
					else
Packit 78a954 
						return_value8[0] *= 2;
Packit 78a954
Packit 78a954 
					for (i = 0; i < return_value8[0]; ++i)
Packit 78a954 
						if (ovector8_1[i] != ovector8_2[i]) {
Packit 78a954 
							printf("\n8 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
Packit 78a954 
								i, ovector8_1[i], ovector8_2[i], total, current->pattern, current->input);
Packit 78a954 
							is_successful = 0;
Packit 78a954 
						}
Packit 78a954 
				}
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954 
				if (return_value16[0] != return_value16[1]) {
Packit 78a954 
					printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
Packit 78a954 
						return_value16[0], return_value16[1], total, current->pattern, current->input);
Packit 78a954 
					is_successful = 0;
Packit 78a954 
				} else if (return_value16[0] >= 0 || return_value16[0] == PCRE_ERROR_PARTIAL) {
Packit 78a954 
					if (return_value16[0] == PCRE_ERROR_PARTIAL)
Packit 78a954 
						return_value16[0] = 2;
Packit 78a954 
					else
Packit 78a954 
						return_value16[0] *= 2;
Packit 78a954
Packit 78a954 
					for (i = 0; i < return_value16[0]; ++i)
Packit 78a954 
						if (ovector16_1[i] != ovector16_2[i]) {
Packit 78a954 
							printf("\n16 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
Packit 78a954 
								i, ovector16_1[i], ovector16_2[i], total, current->pattern, current->input);
Packit 78a954 
							is_successful = 0;
Packit 78a954 
						}
Packit 78a954 
				}
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954 
				if (return_value32[0] != return_value32[1]) {
Packit 78a954 
					printf("\n32 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
Packit 78a954 
						return_value32[0], return_value32[1], total, current->pattern, current->input);
Packit 78a954 
					is_successful = 0;
Packit 78a954 
				} else if (return_value32[0] >= 0 || return_value32[0] == PCRE_ERROR_PARTIAL) {
Packit 78a954 
					if (return_value32[0] == PCRE_ERROR_PARTIAL)
Packit 78a954 
						return_value32[0] = 2;
Packit 78a954 
					else
Packit 78a954 
						return_value32[0] *= 2;
Packit 78a954
Packit 78a954 
					for (i = 0; i < return_value32[0]; ++i)
Packit 78a954 
						if (ovector32_1[i] != ovector32_2[i]) {
Packit 78a954 
							printf("\n32 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
Packit 78a954 
								i, ovector32_1[i], ovector32_2[i], total, current->pattern, current->input);
Packit 78a954 
							is_successful = 0;
Packit 78a954 
						}
Packit 78a954 
				}
Packit 78a954 
#endif
Packit 78a954 
			}
Packit 78a954 
		}
Packit 78a954
Packit 78a954 
		if (is_successful) {
Packit 78a954 
#ifdef SUPPORT_PCRE8
Packit 78a954 
			if (!(current->start_offset & F_NO8) && ((utf && ucp) || is_ascii)) {
Packit 78a954 
				if (return_value8[0] < 0 && !(current->start_offset & F_NOMATCH)) {
Packit 78a954 
					printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",
Packit 78a954 
						total, current->pattern, current->input);
Packit 78a954 
					is_successful = 0;
Packit 78a954 
				}
Packit 78a954
Packit 78a954 
				if (return_value8[0] >= 0 && (current->start_offset & F_NOMATCH)) {
Packit 78a954 
					printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",
Packit 78a954 
						total, current->pattern, current->input);
Packit 78a954 
					is_successful = 0;
Packit 78a954 
				}
Packit 78a954 
			}
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954 
			if (!(current->start_offset & F_NO16) && ((utf && ucp) || is_ascii)) {
Packit 78a954 
				if (return_value16[0] < 0 && !(current->start_offset & F_NOMATCH)) {
Packit 78a954 
					printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",
Packit 78a954 
						total, current->pattern, current->input);
Packit 78a954 
					is_successful = 0;
Packit 78a954 
				}
Packit 78a954
Packit 78a954 
				if (return_value16[0] >= 0 && (current->start_offset & F_NOMATCH)) {
Packit 78a954 
					printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",
Packit 78a954 
						total, current->pattern, current->input);
Packit 78a954 
					is_successful = 0;
Packit 78a954 
				}
Packit 78a954 
			}
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954 
			if (!(current->start_offset & F_NO32) && ((utf && ucp) || is_ascii)) {
Packit 78a954 
				if (return_value32[0] < 0 && !(current->start_offset & F_NOMATCH)) {
Packit 78a954 
					printf("32 bit: Test should match: [%d] '%s' @ '%s'\n",
Packit 78a954 
						total, current->pattern, current->input);
Packit 78a954 
					is_successful = 0;
Packit 78a954 
				}
Packit 78a954
Packit 78a954 
				if (return_value32[0] >= 0 && (current->start_offset & F_NOMATCH)) {
Packit 78a954 
					printf("32 bit: Test should not match: [%d] '%s' @ '%s'\n",
Packit 78a954 
						total, current->pattern, current->input);
Packit 78a954 
					is_successful = 0;
Packit 78a954 
				}
Packit 78a954 
			}
Packit 78a954 
#endif
Packit 78a954 
		}
Packit 78a954
Packit 78a954 
		if (is_successful) {
Packit 78a954 
#ifdef SUPPORT_PCRE8
Packit 78a954 
			if (mark8_1 != mark8_2) {
Packit 78a954 
				printf("8 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
Packit 78a954 
					total, current->pattern, current->input);
Packit 78a954 
				is_successful = 0;
Packit 78a954 
			}
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954 
			if (mark16_1 != mark16_2) {
Packit 78a954 
				printf("16 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
Packit 78a954 
					total, current->pattern, current->input);
Packit 78a954 
				is_successful = 0;
Packit 78a954 
			}
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954 
			if (mark32_1 != mark32_2) {
Packit 78a954 
				printf("32 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
Packit 78a954 
					total, current->pattern, current->input);
Packit 78a954 
				is_successful = 0;
Packit 78a954 
			}
Packit 78a954 
#endif
Packit 78a954 
		}
Packit 78a954
Packit 78a954 
#ifdef SUPPORT_PCRE8
Packit 78a954 
		if (re8) {
Packit 78a954 
			pcre_free_study(extra8);
Packit 78a954 
			pcre_free(re8);
Packit 78a954 
		}
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954 
		if (re16) {
Packit 78a954 
			pcre16_free_study(extra16);
Packit 78a954 
			pcre16_free(re16);
Packit 78a954 
		}
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954 
		if (re32) {
Packit 78a954 
			pcre32_free_study(extra32);
Packit 78a954 
			pcre32_free(re32);
Packit 78a954 
		}
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
		if (is_successful) {
Packit 78a954 
			successful++;
Packit 78a954 
			successful_row++;
Packit 78a954 
			printf(".");
Packit 78a954 
			if (successful_row >= 60) {
Packit 78a954 
				successful_row = 0;
Packit 78a954 
				printf("\n");
Packit 78a954 
			}
Packit 78a954 
		} else
Packit 78a954 
			successful_row = 0;
Packit 78a954
Packit 78a954 
		fflush(stdout);
Packit 78a954 
		current++;
Packit 78a954 
	}
Packit 78a954 
	tables(1);
Packit 78a954 
#ifdef SUPPORT_PCRE8
Packit 78a954 
	setstack8(NULL);
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE16
Packit 78a954 
	setstack16(NULL);
Packit 78a954 
#endif
Packit 78a954 
#ifdef SUPPORT_PCRE32
Packit 78a954 
	setstack32(NULL);
Packit 78a954 
#endif
Packit 78a954
Packit 78a954 
	if (total == successful) {
Packit 78a954 
		printf("\nAll JIT regression tests are successfully passed.\n");
Packit 78a954 
		return 0;
Packit 78a954 
	} else {
Packit 78a954 
		printf("\nSuccessful test ratio: %d%% (%d failed)\n", successful * 100 / total, total - successful);
Packit 78a954 
		return 1;
Packit 78a954 
	}
Packit 78a954 
}
Packit 78a954
Packit 78a954 
/* End of pcre_jit_test.c */

Powered by Pagure 5.14.1

SSH Hostkey/Fingerprint | Documentation