win32/pcre/pcre_dfa_exec.c - diff

Return to pcre_dfa_exec.c CVS log

Up to [parser3project] / win32 / pcre

Diff for /win32/pcre/pcre_dfa_exec.c between versions 1.5 and 1.8

version 1.5, 2011/02/01 05:03:42	version 1.8, 2015/10/13 00:25:40
Line 7 and semantics are as close as possible t	Line 7 and semantics are as close as possible t
below for why this module is different).	below for why this module is different).

Written by Philip Hazel	Written by Philip Hazel
Copyright (c) 1997-2010 University of Cambridge	Copyright (c) 1997-2014 University of Cambridge

-----------------------------------------------------------------------------	-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without	Redistribution and use in source and binary forms, with or without
Line 38 POSSIBILITY OF SUCH DAMAGE.	Line 38 POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------	-----------------------------------------------------------------------------
*/	*/


/* This module contains the external function pcre_dfa_exec(), which is an	/* This module contains the external function pcre_dfa_exec(), which is an
alternative matching function that uses a sort of DFA algorithm (not a true	alternative matching function that uses a sort of DFA algorithm (not a true
FSM). This is NOT Perl- compatible, but it has advantages in certain	FSM). This is NOT Perl-compatible, but it has advantages in certain
applications. */	applications. */


Line 113 small value. Non-zero values in the tabl	Line 112 small value. Non-zero values in the tabl
the character is to be found. *NOTE* If the start of this table is	the character is to be found. *NOTE* If the start of this table is
modified, the three tables that follow must also be modified. */	modified, the three tables that follow must also be modified. */

static const uschar coptable[] = {	static const pcre_uint8 coptable[] = {
0, /* End */	0, /* End */
0, 0, 0, 0, 0, /* \A, \G, \K, \B, \b */	0, 0, 0, 0, 0, /* \A, \G, \K, \B, \b */
0, 0, 0, 0, 0, 0, /* \D, \d, \S, \s, \W, \w */	0, 0, 0, 0, 0, 0, /* \D, \d, \S, \s, \W, \w */
Line 121 static const uschar coptable[] = {	Line 120 static const uschar coptable[] = {
0, 0, /* \P, \p */	0, 0, /* \P, \p */
0, 0, 0, 0, 0, /* \R, \H, \h, \V, \v */	0, 0, 0, 0, 0, /* \R, \H, \h, \V, \v */
0, /* \X */	0, /* \X */
0, 0, 0, 0, 0, /* \Z, \z, Opt, ^, $ */	0, 0, 0, 0, 0, 0, /* \Z, \z, $, $M, ^, ^M */
1, /* Char */	1, /* Char */
1, /* Charnc */	1, /* Chari */
1, /* not */	1, /* not */
	1, /* noti */
/* Positive single-char repeats */	/* Positive single-char repeats */
1, 1, 1, 1, 1, 1, /* , ?, +, +?, ?, ?? */	1, 1, 1, 1, 1, 1, /* , ?, +, +?, ?, ?? */
3, 3, 3, /* upto, minupto, exact */	1+IMM2_SIZE, 1+IMM2_SIZE, /* upto, minupto */
1, 1, 1, 3, /* +, ++, ?+, upto+ /	1+IMM2_SIZE, /* exact */
	1, 1, 1, 1+IMM2_SIZE, /* +, ++, ?+, upto+ /
	1, 1, 1, 1, 1, 1, /* I, ?I, +I, +?I, ?I, ??I */
	1+IMM2_SIZE, 1+IMM2_SIZE, /* upto I, minupto I */
	1+IMM2_SIZE, /* exact I */
	1, 1, 1, 1+IMM2_SIZE, /* +I, ++I, ?+I, upto+I /
/* Negative single-char repeats - only for chars < 256 */	/* Negative single-char repeats - only for chars < 256 */
1, 1, 1, 1, 1, 1, /* NOT , ?, +, +?, ?, ?? */	1, 1, 1, 1, 1, 1, /* NOT , ?, +, +?, ?, ?? */
3, 3, 3, /* NOT upto, minupto, exact */	1+IMM2_SIZE, 1+IMM2_SIZE, /* NOT upto, minupto */
1, 1, 1, 3, /* NOT +, ++, ?+, updo+ /	1+IMM2_SIZE, /* NOT exact */
	1, 1, 1, 1+IMM2_SIZE, /* NOT +, ++, ?+, upto+ /
	1, 1, 1, 1, 1, 1, /* NOT I, ?I, +I, +?I, ?I, ??I */
	1+IMM2_SIZE, 1+IMM2_SIZE, /* NOT upto I, minupto I */
	1+IMM2_SIZE, /* NOT exact I */
	1, 1, 1, 1+IMM2_SIZE, /* NOT +I, ++I, ?+I, upto+I /
/* Positive type repeats */	/* Positive type repeats */
1, 1, 1, 1, 1, 1, /* Type , ?, +, +?, ?, ?? */	1, 1, 1, 1, 1, 1, /* Type , ?, +, +?, ?, ?? */
3, 3, 3, /* Type upto, minupto, exact */	1+IMM2_SIZE, 1+IMM2_SIZE, /* Type upto, minupto */
1, 1, 1, 3, /* Type +, ++, ?+, upto+ /	1+IMM2_SIZE, /* Type exact */
	1, 1, 1, 1+IMM2_SIZE, /* Type +, ++, ?+, upto+ /
/* Character class & ref repeats */	/* Character class & ref repeats */
0, 0, 0, 0, 0, 0, /* , ?, +, +?, ?, ?? */	0, 0, 0, 0, 0, 0, /* , ?, +, +?, ?, ?? */
0, 0, /* CRRANGE, CRMINRANGE */	0, 0, /* CRRANGE, CRMINRANGE */
	0, 0, 0, 0, /* Possessive +, ++, ?+, CRPOSRANGE /
0, /* CLASS */	0, /* CLASS */
0, /* NCLASS */	0, /* NCLASS */
0, /* XCLASS - variable length */	0, /* XCLASS - variable length */
0, /* REF */	0, /* REF */
	0, /* REFI */
	0, /* DNREF */
	0, /* DNREFI */
0, /* RECURSE */	0, /* RECURSE */
0, /* CALLOUT */	0, /* CALLOUT */
0, /* Alt */	0, /* Alt */
0, /* Ket */	0, /* Ket */
0, /* KetRmax */	0, /* KetRmax */
0, /* KetRmin */	0, /* KetRmin */
	0, /* KetRpos */
	0, /* Reverse */
0, /* Assert */	0, /* Assert */
0, /* Assert not */	0, /* Assert not */
0, /* Assert behind */	0, /* Assert behind */
0, /* Assert behind not */	0, /* Assert behind not */
0, /* Reverse */	0, 0, /* ONCE, ONCE_NC */
0, 0, 0, 0, /* ONCE, BRA, CBRA, COND */	0, 0, 0, 0, 0, /* BRA, BRAPOS, CBRA, CBRAPOS, COND */
0, 0, 0, /* SBRA, SCBRA, SCOND */	0, 0, 0, 0, 0, /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND */
0, 0, /* CREF, NCREF */	0, 0, /* CREF, DNCREF */
0, 0, /* RREF, NRREF */	0, 0, /* RREF, DNRREF */
0, /* DEF */	0, /* DEF */
0, 0, /* BRAZERO, BRAMINZERO */	0, 0, 0, /* BRAZERO, BRAMINZERO, BRAPOSZERO */
0, 0, 0, /* MARK, PRUNE, PRUNE_ARG, */	0, 0, 0, /* MARK, PRUNE, PRUNE_ARG */
0, 0, 0, 0, /* SKIP, SKIP_ARG, THEN, THEN_ARG, */	0, 0, 0, 0, /* SKIP, SKIP_ARG, THEN, THEN_ARG */
0, 0, 0, 0, 0 /* COMMIT, FAIL, ACCEPT, CLOSE, SKIPZERO */	0, 0, 0, 0, /* COMMIT, FAIL, ACCEPT, ASSERT_ACCEPT */
	0, 0 /* CLOSE, SKIPZERO */
};	};

/* This table identifies those opcodes that inspect a character. It is used to	/* This table identifies those opcodes that inspect a character. It is used to
Line 171 remember the fact that a character could	Line 189 remember the fact that a character could
the subject is reached. *NOTE* If the start of this table is modified, the	the subject is reached. *NOTE* If the start of this table is modified, the
two tables that follow must also be modified. */	two tables that follow must also be modified. */

static const uschar poptable[] = {	static const pcre_uint8 poptable[] = {
0, /* End */	0, /* End */
0, 0, 0, 1, 1, /* \A, \G, \K, \B, \b */	0, 0, 0, 1, 1, /* \A, \G, \K, \B, \b */
1, 1, 1, 1, 1, 1, /* \D, \d, \S, \s, \W, \w */	1, 1, 1, 1, 1, 1, /* \D, \d, \S, \s, \W, \w */
Line 179 static const uschar poptable[] = {	Line 197 static const uschar poptable[] = {
1, 1, /* \P, \p */	1, 1, /* \P, \p */
1, 1, 1, 1, 1, /* \R, \H, \h, \V, \v */	1, 1, 1, 1, 1, /* \R, \H, \h, \V, \v */
1, /* \X */	1, /* \X */
0, 0, 0, 0, 0, /* \Z, \z, Opt, ^, $ */	0, 0, 0, 0, 0, 0, /* \Z, \z, $, $M, ^, ^M */
1, /* Char */	1, /* Char */
1, /* Charnc */	1, /* Chari */
1, /* not */	1, /* not */
	1, /* noti */
/* Positive single-char repeats */	/* Positive single-char repeats */
1, 1, 1, 1, 1, 1, /* , ?, +, +?, ?, ?? */	1, 1, 1, 1, 1, 1, /* , ?, +, +?, ?, ?? */
1, 1, 1, /* upto, minupto, exact */	1, 1, 1, /* upto, minupto, exact */
1, 1, 1, 1, /* +, ++, ?+, upto+ /	1, 1, 1, 1, /* +, ++, ?+, upto+ /
	1, 1, 1, 1, 1, 1, /* I, ?I, +I, +?I, ?I, ??I */
	1, 1, 1, /* upto I, minupto I, exact I */
	1, 1, 1, 1, /* +I, ++I, ?+I, upto+I /
/* Negative single-char repeats - only for chars < 256 */	/* Negative single-char repeats - only for chars < 256 */
1, 1, 1, 1, 1, 1, /* NOT , ?, +, +?, ?, ?? */	1, 1, 1, 1, 1, 1, /* NOT , ?, +, +?, ?, ?? */
1, 1, 1, /* NOT upto, minupto, exact */	1, 1, 1, /* NOT upto, minupto, exact */
1, 1, 1, 1, /* NOT +, ++, ?+, upto+ /	1, 1, 1, 1, /* NOT +, ++, ?+, upto+ /
	1, 1, 1, 1, 1, 1, /* NOT I, ?I, +I, +?I, ?I, ??I */
	1, 1, 1, /* NOT upto I, minupto I, exact I */
	1, 1, 1, 1, /* NOT +I, ++I, ?+I, upto+I /
/* Positive type repeats */	/* Positive type repeats */
1, 1, 1, 1, 1, 1, /* Type , ?, +, +?, ?, ?? */	1, 1, 1, 1, 1, 1, /* Type , ?, +, +?, ?, ?? */
1, 1, 1, /* Type upto, minupto, exact */	1, 1, 1, /* Type upto, minupto, exact */
Line 198 static const uschar poptable[] = {	Line 223 static const uschar poptable[] = {
/* Character class & ref repeats */	/* Character class & ref repeats */
1, 1, 1, 1, 1, 1, /* , ?, +, +?, ?, ?? */	1, 1, 1, 1, 1, 1, /* , ?, +, +?, ?, ?? */
1, 1, /* CRRANGE, CRMINRANGE */	1, 1, /* CRRANGE, CRMINRANGE */
	1, 1, 1, 1, /* Possessive +, ++, ?+, CRPOSRANGE /
1, /* CLASS */	1, /* CLASS */
1, /* NCLASS */	1, /* NCLASS */
1, /* XCLASS - variable length */	1, /* XCLASS - variable length */
0, /* REF */	0, /* REF */
	0, /* REFI */
	0, /* DNREF */
	0, /* DNREFI */
0, /* RECURSE */	0, /* RECURSE */
0, /* CALLOUT */	0, /* CALLOUT */
0, /* Alt */	0, /* Alt */
0, /* Ket */	0, /* Ket */
0, /* KetRmax */	0, /* KetRmax */
0, /* KetRmin */	0, /* KetRmin */
	0, /* KetRpos */
	0, /* Reverse */
0, /* Assert */	0, /* Assert */
0, /* Assert not */	0, /* Assert not */
0, /* Assert behind */	0, /* Assert behind */
0, /* Assert behind not */	0, /* Assert behind not */
0, /* Reverse */	0, 0, /* ONCE, ONCE_NC */
0, 0, 0, 0, /* ONCE, BRA, CBRA, COND */	0, 0, 0, 0, 0, /* BRA, BRAPOS, CBRA, CBRAPOS, COND */
0, 0, 0, /* SBRA, SCBRA, SCOND */	0, 0, 0, 0, 0, /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND */
0, 0, /* CREF, NCREF */	0, 0, /* CREF, DNCREF */
0, 0, /* RREF, NRREF */	0, 0, /* RREF, DNRREF */
0, /* DEF */	0, /* DEF */
0, 0, /* BRAZERO, BRAMINZERO */	0, 0, 0, /* BRAZERO, BRAMINZERO, BRAPOSZERO */
0, 0, 0, /* MARK, PRUNE, PRUNE_ARG, */	0, 0, 0, /* MARK, PRUNE, PRUNE_ARG */
0, 0, 0, 0, /* SKIP, SKIP_ARG, THEN, THEN_ARG, */	0, 0, 0, 0, /* SKIP, SKIP_ARG, THEN, THEN_ARG */
0, 0, 0, 0, 0 /* COMMIT, FAIL, ACCEPT, CLOSE, SKIPZERO */	0, 0, 0, 0, /* COMMIT, FAIL, ACCEPT, ASSERT_ACCEPT */
	0, 0 /* CLOSE, SKIPZERO */
};	};

/* These 2 tables allow for compact code for testing for \D, \d, \S, \s, \W,	/* These 2 tables allow for compact code for testing for \D, \d, \S, \s, \W,
and \w */	and \w */

static const uschar toptable1[] = {	static const pcre_uint8 toptable1[] = {
0, 0, 0, 0, 0, 0,	0, 0, 0, 0, 0, 0,
ctype_digit, ctype_digit,	ctype_digit, ctype_digit,
ctype_space, ctype_space,	ctype_space, ctype_space,
Line 235 static const uschar toptable1[] = {	Line 267 static const uschar toptable1[] = {
0, 0 /* OP_ANY, OP_ALLANY */	0, 0 /* OP_ANY, OP_ALLANY */
};	};

static const uschar toptable2[] = {	static const pcre_uint8 toptable2[] = {
0, 0, 0, 0, 0, 0,	0, 0, 0, 0, 0, 0,
ctype_digit, 0,	ctype_digit, 0,
ctype_space, 0,	ctype_space, 0,
Line 252 these structures in, is a vector of ints	Line 284 these structures in, is a vector of ints
typedef struct stateblock {	typedef struct stateblock {
int offset; /* Offset to opcode */	int offset; /* Offset to opcode */
int count; /* Count for repeats */	int count; /* Count for repeats */
int ims; /* ims flag bits */
int data; /* Some use extra data */	int data; /* Some use extra data */
} stateblock;	} stateblock;

#define INTS_PER_STATEBLOCK (sizeof(stateblock)/sizeof(int))	#define INTS_PER_STATEBLOCK (int)(sizeof(stateblock)/sizeof(int))


#ifdef PCRE_DEBUG	#ifdef PCRE_DEBUG
Line 275 Returns: nothing	Line 306 Returns: nothing
*/	*/

static void	static void
pchars(unsigned char p, int length, FILE f)	pchars(const pcre_uchar p, int length, FILE f)
{	{
int c;	pcre_uint32 c;
while (length-- > 0)	while (length-- > 0)
{	{
if (isprint(c = *(p++)))	if (isprint(c = *(p++)))
fprintf(f, "%c", c);	fprintf(f, "%c", c);
else	else
fprintf(f, "\\x%02x", c);	fprintf(f, "\\x{%02x}", c);
}	}
}	}
#endif	#endif
Line 308 Arguments:	Line 339 Arguments:
offsetcount size of same	offsetcount size of same
workspace vector of workspace	workspace vector of workspace
wscount size of same	wscount size of same
ims the current ims flags
rlevel function call recursion level	rlevel function call recursion level
recursing regex recursive call level

Returns: > 0 => number of match offset pairs placed in offsets	Returns: > 0 => number of match offset pairs placed in offsets
= 0 => offsets overflowed; longest matches are present	= 0 => offsets overflowed; longest matches are present
Line 325 for the current character, one for the f	Line 354 for the current character, one for the f
{ \	{ \
next_active_state->offset = (x); \	next_active_state->offset = (x); \
next_active_state->count = (y); \	next_active_state->count = (y); \
next_active_state->ims = ims; \
next_active_state++; \	next_active_state++; \
DPRINTF(("%.sADD_ACTIVE(%d,%d)\n", rlevel2-2, SP, (x), (y))); \	DPRINTF(("%.sADD_ACTIVE(%d,%d)\n", rlevel2-2, SP, (x), (y))); \
} \	} \
Line 336 for the current character, one for the f	Line 364 for the current character, one for the f
{ \	{ \
next_active_state->offset = (x); \	next_active_state->offset = (x); \
next_active_state->count = (y); \	next_active_state->count = (y); \
next_active_state->ims = ims; \
next_active_state->data = (z); \	next_active_state->data = (z); \
next_active_state++; \	next_active_state++; \
DPRINTF(("%.sADD_ACTIVE_DATA(%d,%d,%d)\n", rlevel2-2, SP, (x), (y), (z))); \	DPRINTF(("%.sADD_ACTIVE_DATA(%d,%d,%d)\n", rlevel2-2, SP, (x), (y), (z))); \
Line 348 for the current character, one for the f	Line 375 for the current character, one for the f
{ \	{ \
next_new_state->offset = (x); \	next_new_state->offset = (x); \
next_new_state->count = (y); \	next_new_state->count = (y); \
next_new_state->ims = ims; \
next_new_state++; \	next_new_state++; \
DPRINTF(("%.sADD_NEW(%d,%d)\n", rlevel2-2, SP, (x), (y))); \	DPRINTF(("%.sADD_NEW(%d,%d)\n", rlevel2-2, SP, (x), (y))); \
} \	} \
Line 359 for the current character, one for the f	Line 385 for the current character, one for the f
{ \	{ \
next_new_state->offset = (x); \	next_new_state->offset = (x); \
next_new_state->count = (y); \	next_new_state->count = (y); \
next_new_state->ims = ims; \
next_new_state->data = (z); \	next_new_state->data = (z); \
next_new_state++; \	next_new_state++; \
DPRINTF(("%.sADD_NEW_DATA(%d,%d,%d)\n", rlevel2-2, SP, (x), (y), (z))); \	DPRINTF(("%.sADD_NEW_DATA(%d,%d,%d) line %d\n", rlevel2-2, SP, \
	(x), (y), (z), __LINE__)); \
} \	} \
else return PCRE_ERROR_DFA_WSSIZE	else return PCRE_ERROR_DFA_WSSIZE

Line 371 for the current character, one for the f	Line 397 for the current character, one for the f
static int	static int
internal_dfa_exec(	internal_dfa_exec(
dfa_match_data *md,	dfa_match_data *md,
const uschar *this_start_code,	const pcre_uchar *this_start_code,
const uschar *current_subject,	const pcre_uchar *current_subject,
int start_offset,	int start_offset,
int *offsets,	int *offsets,
int offsetcount,	int offsetcount,
int *workspace,	int *workspace,
int wscount,	int wscount,
int ims,	int rlevel)
int rlevel,
int recursing)
{	{
stateblock active_states, new_states, *temp_states;	stateblock active_states, new_states, *temp_states;
stateblock next_active_state, next_new_state;	stateblock next_active_state, next_new_state;

const uschar ctypes, lcc, *fcc;	const pcre_uint8 ctypes, lcc, *fcc;
const uschar *ptr;	const pcre_uchar *ptr;
const uschar end_code, first_op;	const pcre_uchar end_code, first_op;

	dfa_recursion_info new_recursive;

int active_count, new_count, match_count;	int active_count, new_count, match_count;

/* Some fields in the md block are frequently referenced, so we load them into	/* Some fields in the md block are frequently referenced, so we load them into
independent variables in the hope that this will perform better. */	independent variables in the hope that this will perform better. */

const uschar *start_subject = md->start_subject;	const pcre_uchar *start_subject = md->start_subject;
const uschar *end_subject = md->end_subject;	const pcre_uchar *end_subject = md->end_subject;
const uschar *start_code = md->start_code;	const pcre_uchar *start_code = md->start_code;

#ifdef SUPPORT_UTF8	#ifdef SUPPORT_UTF
BOOL utf8 = (md->poptions & PCRE_UTF8) != 0;	BOOL utf = (md->poptions & PCRE_UTF8) != 0;
#else	#else
BOOL utf8 = FALSE;	BOOL utf = FALSE;
#endif	#endif

	BOOL reset_could_continue = FALSE;

rlevel++;	rlevel++;
offsetcount &= (-2);	offsetcount &= (-2);

Line 412 wscount = (wscount - (wscount % (INTS_PE	Line 440 wscount = (wscount - (wscount % (INTS_PE
(2 * INTS_PER_STATEBLOCK);	(2 * INTS_PER_STATEBLOCK);

DPRINTF(("\n%.*s---------------------\n"	DPRINTF(("\n%.*s---------------------\n"
"%.*sCall to internal_dfa_exec f=%d r=%d\n",	"%.*sCall to internal_dfa_exec f=%d\n",
rlevel2-2, SP, rlevel2-2, SP, rlevel, recursing));	rlevel2-2, SP, rlevel2-2, SP, rlevel));

ctypes = md->tables + ctypes_offset;	ctypes = md->tables + ctypes_offset;
lcc = md->tables + lcc_offset;	lcc = md->tables + lcc_offset;
Line 426 next_new_state = new_states = active_sta	Line 454 next_new_state = new_states = active_sta
new_count = 0;	new_count = 0;

first_op = this_start_code + 1 + LINK_SIZE +	first_op = this_start_code + 1 + LINK_SIZE +
((this_start_code == OP_CBRA \|\| this_start_code == OP_SCBRA)? 2:0);	((this_start_code == OP_CBRA \|\| this_start_code == OP_SCBRA \|\|
	this_start_code == OP_CBRAPOS \|\| this_start_code == OP_SCBRAPOS)
	? IMM2_SIZE:0);

/* The first thing in any (sub) pattern is a bracket of some sort. Push all	/* The first thing in any (sub) pattern is a bracket of some sort. Push all
the alternative states onto the list, and find out where the end is. This	the alternative states onto the list, and find out where the end is. This
Line 454 if (*first_op == OP_REVERSE)	Line 484 if (*first_op == OP_REVERSE)
/* If we can't go back the amount required for the longest lookbehind	/* If we can't go back the amount required for the longest lookbehind
pattern, go back as far as we can; some alternatives may still be viable. */	pattern, go back as far as we can; some alternatives may still be viable. */

#ifdef SUPPORT_UTF8	#ifdef SUPPORT_UTF
/* In character mode we have to step back character by character */	/* In character mode we have to step back character by character */

if (utf8)	if (utf)
{	{
for (gone_back = 0; gone_back < max_back; gone_back++)	for (gone_back = 0; gone_back < max_back; gone_back++)
{	{
if (current_subject <= start_subject) break;	if (current_subject <= start_subject) break;
current_subject--;	current_subject--;
while (current_subject > start_subject &&	ACROSSCHAR(current_subject > start_subject, *current_subject, current_subject--);
(*current_subject & 0xc0) == 0x80)
current_subject--;
}	}
}	}
else	else
Line 525 else	Line 553 else
else	else
{	{
int length = 1 + LINK_SIZE +	int length = 1 + LINK_SIZE +
((this_start_code == OP_CBRA \|\| this_start_code == OP_SCBRA)? 2:0);	((this_start_code == OP_CBRA \|\| this_start_code == OP_SCBRA \|\|
	this_start_code == OP_CBRAPOS \|\| this_start_code == OP_SCBRAPOS)
	? IMM2_SIZE:0);
do	do
{	{
ADD_NEW((int)(end_code - start_code + length), 0);	ADD_NEW((int)(end_code - start_code + length), 0);
Line 538 else	Line 568 else

workspace[0] = 0; /* Bit indicating which vector is current */	workspace[0] = 0; /* Bit indicating which vector is current */

DPRINTF(("%.sEnd state = %d\n", rlevel2-2, SP, end_code - start_code));	DPRINTF(("%.sEnd state = %d\n", rlevel2-2, SP, (int)(end_code - start_code)));

/* Loop for scanning the subject */	/* Loop for scanning the subject */

Line 547 for (;;)	Line 577 for (;;)
{	{
int i, j;	int i, j;
int clen, dlen;	int clen, dlen;
unsigned int c, d;	pcre_uint32 c, d;
int forced_fail = 0;	int forced_fail = 0;
BOOL could_continue = FALSE;	BOOL partial_newline = FALSE;
	BOOL could_continue = reset_could_continue;
	reset_could_continue = FALSE;

/* Make the new state list into the active state list and empty the	/* Make the new state list into the active state list and empty the
new state list. */	new state list. */
Line 565 for (;;)	Line 597 for (;;)

#ifdef PCRE_DEBUG	#ifdef PCRE_DEBUG
printf("%.sNext character: rest of subject = \"", rlevel2-2, SP);	printf("%.sNext character: rest of subject = \"", rlevel2-2, SP);
pchars((uschar )ptr, strlen((char )ptr), stdout);	pchars(ptr, STRLEN_UC(ptr), stdout);
printf("\"\n");	printf("\"\n");

printf("%.sActive states: ", rlevel2-2, SP);	printf("%.sActive states: ", rlevel2-2, SP);
Line 585 for (;;)	Line 617 for (;;)

if (ptr < end_subject)	if (ptr < end_subject)
{	{
clen = 1; /* Number of bytes in the character */	clen = 1; /* Number of data items in the character */
#ifdef SUPPORT_UTF8	#ifdef SUPPORT_UTF
if (utf8) { GETCHARLEN(c, ptr, clen); } else	GETCHARLENTEST(c, ptr, clen);
#endif /* SUPPORT_UTF8 */	#else
c = *ptr;	c = *ptr;
	#endif /* SUPPORT_UTF */
}	}
else	else
{	{
Line 605 for (;;)	Line 638 for (;;)
for (i = 0; i < active_count; i++)	for (i = 0; i < active_count; i++)
{	{
stateblock *current_state = active_states + i;	stateblock *current_state = active_states + i;
const uschar *code;	BOOL caseless = FALSE;
	const pcre_uchar *code;
int state_offset = current_state->offset;	int state_offset = current_state->offset;
int count, codevalue, rrc;	int codevalue, rrc;
	int count;

#ifdef PCRE_DEBUG	#ifdef PCRE_DEBUG
printf ("%.sProcessing state %d c=", rlevel2-2, SP, state_offset);	printf ("%.sProcessing state %d c=", rlevel2-2, SP, state_offset);
Line 616 for (;;)	Line 651 for (;;)
else printf("0x%02x\n", c);	else printf("0x%02x\n", c);
#endif	#endif

/* This variable is referred to implicity in the ADD_xxx macros. */

ims = current_state->ims;

/* A negative offset is a special case meaning "hold off going to this	/* A negative offset is a special case meaning "hold off going to this
(negated) state until the number of characters in the data field have	(negated) state until the number of characters in the data field have
been skipped". */	been skipped". If the could_continue flag was passed over from a previous
	state, arrange for it to passed on. */

if (state_offset < 0)	if (state_offset < 0)
{	{
Line 631 for (;;)	Line 663 for (;;)
DPRINTF(("%.sSkipping this character\n", rlevel2-2, SP));	DPRINTF(("%.sSkipping this character\n", rlevel2-2, SP));
ADD_NEW_DATA(state_offset, current_state->count,	ADD_NEW_DATA(state_offset, current_state->count,
current_state->data - 1);	current_state->data - 1);
	if (could_continue) reset_could_continue = TRUE;
continue;	continue;
}	}
else	else
Line 670 for (;;)	Line 703 for (;;)
permitted.	permitted.

We also use this mechanism for opcodes such as OP_TYPEPLUS that take an	We also use this mechanism for opcodes such as OP_TYPEPLUS that take an
argument that is not a data character - but is always one byte long. We	argument that is not a data character - but is always one byte long because
have to take special action to deal with \P, \p, \H, \h, \V, \v and \X in	the values are small. We have to take special action to deal with \P, \p,
this case. To keep the other cases fast, convert these ones to new opcodes.	\H, \h, \V, \v and \X in this case. To keep the other cases fast, convert
*/	these ones to new opcodes. */

if (coptable[codevalue] > 0)	if (coptable[codevalue] > 0)
{	{
dlen = 1;	dlen = 1;
#ifdef SUPPORT_UTF8	#ifdef SUPPORT_UTF
if (utf8) { GETCHARLEN(d, (code + coptable[codevalue]), dlen); } else	if (utf) { GETCHARLEN(d, (code + coptable[codevalue]), dlen); } else
#endif /* SUPPORT_UTF8 */	#endif /* SUPPORT_UTF */
d = code[coptable[codevalue]];	d = code[coptable[codevalue]];
if (codevalue >= OP_TYPESTAR)	if (codevalue >= OP_TYPESTAR)
{	{
Line 725 for (;;)	Line 758 for (;;)

/* ========================================================================== */	/* ========================================================================== */
/* Reached a closing bracket. If not at the end of the pattern, carry	/* Reached a closing bracket. If not at the end of the pattern, carry
on with the next opcode. Otherwise, unless we have an empty string and	on with the next opcode. For repeating opcodes, also add the repeat
	state. Note that KETRPOS will always be encountered at the end of the
	subpattern, because the possessive subpattern repeats are always handled
	using recursive calls. Thus, it never adds any new states.

	At the end of the (sub)pattern, unless we have an empty string and
PCRE_NOTEMPTY is set, or PCRE_NOTEMPTY_ATSTART is set and we are at the	PCRE_NOTEMPTY is set, or PCRE_NOTEMPTY_ATSTART is set and we are at the
start of the subject, save the match data, shifting up all previous	start of the subject, save the match data, shifting up all previous
matches so we always have the longest first. */	matches so we always have the longest first. */
Line 733 for (;;)	Line 771 for (;;)
case OP_KET:	case OP_KET:
case OP_KETRMIN:	case OP_KETRMIN:
case OP_KETRMAX:	case OP_KETRMAX:
	case OP_KETRPOS:
if (code != end_code)	if (code != end_code)
{	{
ADD_ACTIVE(state_offset + 1 + LINK_SIZE, 0);	ADD_ACTIVE(state_offset + 1 + LINK_SIZE, 0);
Line 749 for (;;)	Line 788 for (;;)
current_subject > start_subject + md->start_offset)))	current_subject > start_subject + md->start_offset)))
{	{
if (match_count < 0) match_count = (offsetcount >= 2)? 1 : 0;	if (match_count < 0) match_count = (offsetcount >= 2)? 1 : 0;
else if (match_count > 0 && ++match_count * 2 >= offsetcount)	else if (match_count > 0 && ++match_count * 2 > offsetcount)
match_count = 0;	match_count = 0;
count = ((match_count == 0)? offsetcount : match_count * 2) - 2;	count = ((match_count == 0)? offsetcount : match_count * 2) - 2;
if (count > 0) memmove(offsets + 2, offsets, count * sizeof(int));	if (count > 0) memmove(offsets + 2, offsets, count * sizeof(int));
Line 758 for (;;)	Line 797 for (;;)
offsets[0] = (int)(current_subject - start_subject);	offsets[0] = (int)(current_subject - start_subject);
offsets[1] = (int)(ptr - start_subject);	offsets[1] = (int)(ptr - start_subject);
DPRINTF(("%.sSet matched string = \"%.s\"\n", rlevel*2-2, SP,	DPRINTF(("%.sSet matched string = \"%.s\"\n", rlevel*2-2, SP,
offsets[1] - offsets[0], current_subject));	offsets[1] - offsets[0], (char *)current_subject));
}	}
if ((md->moptions & PCRE_DFA_SHORTEST) != 0)	if ((md->moptions & PCRE_DFA_SHORTEST) != 0)
{	{
Line 795 for (;;)	Line 834 for (;;)
/-----------------------------------------------------------------/	/-----------------------------------------------------------------/
case OP_CBRA:	case OP_CBRA:
case OP_SCBRA:	case OP_SCBRA:
ADD_ACTIVE((int)(code - start_code + 3 + LINK_SIZE), 0);	ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE + IMM2_SIZE), 0);
code += GET(code, 1);	code += GET(code, 1);
while (*code == OP_ALT)	while (*code == OP_ALT)
{	{
Line 822 for (;;)	Line 861 for (;;)

/-----------------------------------------------------------------/	/-----------------------------------------------------------------/
case OP_CIRC:	case OP_CIRC:
	if (ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0)
	{ ADD_ACTIVE(state_offset + 1, 0); }
	break;

	/-----------------------------------------------------------------/
	case OP_CIRCM:
if ((ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0) \|\|	if ((ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0) \|\|
((ims & PCRE_MULTILINE) != 0 &&	(ptr != end_subject && WAS_NEWLINE(ptr)))
ptr != end_subject &&
WAS_NEWLINE(ptr)))
{ ADD_ACTIVE(state_offset + 1, 0); }	{ ADD_ACTIVE(state_offset + 1, 0); }
break;	break;

Line 840 for (;;)	Line 883 for (;;)
break;	break;

/-----------------------------------------------------------------/	/-----------------------------------------------------------------/
case OP_OPT:
ims = code[1];
ADD_ACTIVE(state_offset + 2, 0);
break;

/-----------------------------------------------------------------/
case OP_SOD:	case OP_SOD:
if (ptr == start_subject) { ADD_ACTIVE(state_offset + 1, 0); }	if (ptr == start_subject) { ADD_ACTIVE(state_offset + 1, 0); }
break;	break;
Line 865 for (;;)	Line 902 for (;;)
/-----------------------------------------------------------------/	/-----------------------------------------------------------------/
case OP_ANY:	case OP_ANY:
if (clen > 0 && !IS_NEWLINE(ptr))	if (clen > 0 && !IS_NEWLINE(ptr))
{ ADD_NEW(state_offset + 1, 0); }	{
	if (ptr + 1 >= md->end_subject &&
	(md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
	NLBLOCK->nltype == NLTYPE_FIXED &&
	NLBLOCK->nllen == 2 &&
	c == NLBLOCK->nl[0])
	{
	could_continue = partial_newline = TRUE;
	}
	else
	{
	ADD_NEW(state_offset + 1, 0);
	}
	}
break;	break;

/-----------------------------------------------------------------/	/-----------------------------------------------------------------/
Line 890 for (;;)	Line 940 for (;;)
could_continue = TRUE;	could_continue = TRUE;
else if (clen == 0 \|\|	else if (clen == 0 \|\|
((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) &&	((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) &&
((ims & PCRE_MULTILINE) != 0 \|\| ptr == end_subject - md->nllen)	(ptr == end_subject - md->nllen)
))	))
{ ADD_ACTIVE(state_offset + 1, 0); }	{ ADD_ACTIVE(state_offset + 1, 0); }
	else if (ptr + 1 >= md->end_subject &&
	(md->moptions & (PCRE_PARTIAL_HARD\|PCRE_PARTIAL_SOFT)) != 0 &&
	NLBLOCK->nltype == NLTYPE_FIXED &&
	NLBLOCK->nllen == 2 &&
	c == NLBLOCK->nl[0])
	{
	if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
	{
	reset_could_continue = TRUE;
	ADD_NEW_DATA(-(state_offset + 1), 0, 1);
	}
	else could_continue = partial_newline = TRUE;
	}
	}
	break;

	/-----------------------------------------------------------------/
	case OP_DOLLM:
	if ((md->moptions & PCRE_NOTEOL) == 0)
	{
	if (clen == 0 && (md->moptions & PCRE_PARTIAL_HARD) != 0)
	could_continue = TRUE;
	else if (clen == 0 \|\|
	((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr)))
	{ ADD_ACTIVE(state_offset + 1, 0); }
	else if (ptr + 1 >= md->end_subject &&
	(md->moptions & (PCRE_PARTIAL_HARD\|PCRE_PARTIAL_SOFT)) != 0 &&
	NLBLOCK->nltype == NLTYPE_FIXED &&
	NLBLOCK->nllen == 2 &&
	c == NLBLOCK->nl[0])
	{
	if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
	{
	reset_could_continue = TRUE;
	ADD_NEW_DATA(-(state_offset + 1), 0, 1);
	}
	else could_continue = partial_newline = TRUE;
	}
}	}
else if ((ims & PCRE_MULTILINE) != 0 && IS_NEWLINE(ptr))	else if (IS_NEWLINE(ptr))
{ ADD_ACTIVE(state_offset + 1, 0); }	{ ADD_ACTIVE(state_offset + 1, 0); }
break;	break;

Line 925 for (;;)	Line 1013 for (;;)

if (ptr > start_subject)	if (ptr > start_subject)
{	{
const uschar *temp = ptr - 1;	const pcre_uchar *temp = ptr - 1;
if (temp < md->start_used_ptr) md->start_used_ptr = temp;	if (temp < md->start_used_ptr) md->start_used_ptr = temp;
#ifdef SUPPORT_UTF8	#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
if (utf8) BACKCHAR(temp);	if (utf) { BACKCHAR(temp); }
#endif	#endif
GETCHARTEST(d, temp);	GETCHARTEST(d, temp);
#ifdef SUPPORT_UCP	#ifdef SUPPORT_UCP
Line 980 for (;;)	Line 1068 for (;;)
if (clen > 0)	if (clen > 0)
{	{
BOOL OK;	BOOL OK;
	const pcre_uint32 *cp;
const ucd_record * prop = GET_UCD(c);	const ucd_record * prop = GET_UCD(c);
switch(code[1])	switch(code[1])
{	{
Line 993 for (;;)	Line 1082 for (;;)
break;	break;

case PT_GC:	case PT_GC:
OK = _pcre_ucp_gentype[prop->chartype] == code[2];	OK = PRIV(ucp_gentype)[prop->chartype] == code[2];
break;	break;

case PT_PC:	case PT_PC:
Line 1007 for (;;)	Line 1096 for (;;)
/* These are specials for combination cases. */	/* These are specials for combination cases. */

case PT_ALNUM:	case PT_ALNUM:
OK = _pcre_ucp_gentype[prop->chartype] == ucp_L \|\|	OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L \|\|
_pcre_ucp_gentype[prop->chartype] == ucp_N;	PRIV(ucp_gentype)[prop->chartype] == ucp_N;
break;	break;

case PT_SPACE: /* Perl space */	/* Perl space used to exclude VT, but from Perl 5.18 it is included,
OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z \|\|	which means that Perl space and POSIX space are now identical. PCRE
c == CHAR_HT \|\| c == CHAR_NL \|\| c == CHAR_FF \|\| c == CHAR_CR;	was changed at release 8.34. */
break;

	case PT_SPACE: /* Perl space */
case PT_PXSPACE: /* POSIX space */	case PT_PXSPACE: /* POSIX space */
OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z \|\|	switch(c)
c == CHAR_HT \|\| c == CHAR_NL \|\| c == CHAR_VT \|\|	{
c == CHAR_FF \|\| c == CHAR_CR;	HSPACE_CASES:
	VSPACE_CASES:
	OK = TRUE;
	break;

	default:
	OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z;
	break;
	}
break;	break;

case PT_WORD:	case PT_WORD:
OK = _pcre_ucp_gentype[prop->chartype] == ucp_L \|\|	OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L \|\|
_pcre_ucp_gentype[prop->chartype] == ucp_N \|\|	PRIV(ucp_gentype)[prop->chartype] == ucp_N \|\|
c == CHAR_UNDERSCORE;	c == CHAR_UNDERSCORE;
break;	break;

	case PT_CLIST:
	cp = PRIV(ucd_caseless_sets) + code[2];
	for (;;)
	{
	if (c < *cp) { OK = FALSE; break; }
	if (c == *cp++) { OK = TRUE; break; }
	}
	break;

	case PT_UCNC:
	OK = c == CHAR_DOLLAR_SIGN \|\| c == CHAR_COMMERCIAL_AT \|\|
	c == CHAR_GRAVE_ACCENT \|\| (c >= 0xa0 && c <= 0xd7ff) \|\|
	c >= 0xe000;
	break;

/* Should never occur, but keep compilers from grumbling. */	/* Should never occur, but keep compilers from grumbling. */

default:	default:
Line 1055 for (;;)	Line 1167 for (;;)
if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }	if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
if (clen > 0)	if (clen > 0)
{	{
if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) \|\|	if (d == OP_ANY && ptr + 1 >= md->end_subject &&
	(md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
	NLBLOCK->nltype == NLTYPE_FIXED &&
	NLBLOCK->nllen == 2 &&
	c == NLBLOCK->nl[0])
	{
	could_continue = partial_newline = TRUE;
	}
	else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) \|\|
(c < 256 &&	(c < 256 &&
(d != OP_ANY \|\| !IS_NEWLINE(ptr)) &&	(d != OP_ANY \|\| !IS_NEWLINE(ptr)) &&
((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))	((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
Line 1078 for (;;)	Line 1198 for (;;)
ADD_ACTIVE(state_offset + 2, 0);	ADD_ACTIVE(state_offset + 2, 0);
if (clen > 0)	if (clen > 0)
{	{
if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) \|\|	if (d == OP_ANY && ptr + 1 >= md->end_subject &&
	(md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
	NLBLOCK->nltype == NLTYPE_FIXED &&
	NLBLOCK->nllen == 2 &&
	c == NLBLOCK->nl[0])
	{
	could_continue = partial_newline = TRUE;
	}
	else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) \|\|
(c < 256 &&	(c < 256 &&
(d != OP_ANY \|\| !IS_NEWLINE(ptr)) &&	(d != OP_ANY \|\| !IS_NEWLINE(ptr)) &&
((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))	((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
Line 1100 for (;;)	Line 1228 for (;;)
ADD_ACTIVE(state_offset + 2, 0);	ADD_ACTIVE(state_offset + 2, 0);
if (clen > 0)	if (clen > 0)
{	{
if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) \|\|	if (d == OP_ANY && ptr + 1 >= md->end_subject &&
	(md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
	NLBLOCK->nltype == NLTYPE_FIXED &&
	NLBLOCK->nllen == 2 &&
	c == NLBLOCK->nl[0])
	{
	could_continue = partial_newline = TRUE;
	}
	else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) \|\|
(c < 256 &&	(c < 256 &&
(d != OP_ANY \|\| !IS_NEWLINE(ptr)) &&	(d != OP_ANY \|\| !IS_NEWLINE(ptr)) &&
((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))	((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
Line 1120 for (;;)	Line 1256 for (;;)
count = current_state->count; /* Number already matched */	count = current_state->count; /* Number already matched */
if (clen > 0)	if (clen > 0)
{	{
if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) \|\|	if (d == OP_ANY && ptr + 1 >= md->end_subject &&
	(md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
	NLBLOCK->nltype == NLTYPE_FIXED &&
	NLBLOCK->nllen == 2 &&
	c == NLBLOCK->nl[0])
	{
	could_continue = partial_newline = TRUE;
	}
	else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) \|\|
(c < 256 &&	(c < 256 &&
(d != OP_ANY \|\| !IS_NEWLINE(ptr)) &&	(d != OP_ANY \|\| !IS_NEWLINE(ptr)) &&
((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))	((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
{	{
if (++count >= GET2(code, 1))	if (++count >= (int)GET2(code, 1))
{ ADD_NEW(state_offset + 4, 0); }	{ ADD_NEW(state_offset + 1 + IMM2_SIZE + 1, 0); }
else	else
{ ADD_NEW(state_offset, count); }	{ ADD_NEW(state_offset, count); }
}	}
Line 1137 for (;;)	Line 1281 for (;;)
case OP_TYPEUPTO:	case OP_TYPEUPTO:
case OP_TYPEMINUPTO:	case OP_TYPEMINUPTO:
case OP_TYPEPOSUPTO:	case OP_TYPEPOSUPTO:
ADD_ACTIVE(state_offset + 4, 0);	ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0);
count = current_state->count; /* Number already matched */	count = current_state->count; /* Number already matched */
if (clen > 0)	if (clen > 0)
{	{
if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) \|\|	if (d == OP_ANY && ptr + 1 >= md->end_subject &&
	(md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
	NLBLOCK->nltype == NLTYPE_FIXED &&
	NLBLOCK->nllen == 2 &&
	c == NLBLOCK->nl[0])
	{
	could_continue = partial_newline = TRUE;
	}
	else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) \|\|
(c < 256 &&	(c < 256 &&
(d != OP_ANY \|\| !IS_NEWLINE(ptr)) &&	(d != OP_ANY \|\| !IS_NEWLINE(ptr)) &&
((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))	((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
Line 1151 for (;;)	Line 1303 for (;;)
active_count--; /* Remove non-match possibility */	active_count--; /* Remove non-match possibility */
next_active_state--;	next_active_state--;
}	}
if (++count >= GET2(code, 1))	if (++count >= (int)GET2(code, 1))
{ ADD_NEW(state_offset + 4, 0); }	{ ADD_NEW(state_offset + 2 + IMM2_SIZE, 0); }
else	else
{ ADD_NEW(state_offset, count); }	{ ADD_NEW(state_offset, count); }
}	}
Line 1174 for (;;)	Line 1326 for (;;)
if (clen > 0)	if (clen > 0)
{	{
BOOL OK;	BOOL OK;
	const pcre_uint32 *cp;
const ucd_record * prop = GET_UCD(c);	const ucd_record * prop = GET_UCD(c);
switch(code[2])	switch(code[2])
{	{
Line 1187 for (;;)	Line 1340 for (;;)
break;	break;

case PT_GC:	case PT_GC:
OK = _pcre_ucp_gentype[prop->chartype] == code[3];	OK = PRIV(ucp_gentype)[prop->chartype] == code[3];
break;	break;

case PT_PC:	case PT_PC:
Line 1201 for (;;)	Line 1354 for (;;)
/* These are specials for combination cases. */	/* These are specials for combination cases. */

case PT_ALNUM:	case PT_ALNUM:
OK = _pcre_ucp_gentype[prop->chartype] == ucp_L \|\|	OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L \|\|
_pcre_ucp_gentype[prop->chartype] == ucp_N;	PRIV(ucp_gentype)[prop->chartype] == ucp_N;
break;	break;

case PT_SPACE: /* Perl space */	/* Perl space used to exclude VT, but from Perl 5.18 it is included,
OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z \|\|	which means that Perl space and POSIX space are now identical. PCRE
c == CHAR_HT \|\| c == CHAR_NL \|\| c == CHAR_FF \|\| c == CHAR_CR;	was changed at release 8.34. */
break;

	case PT_SPACE: /* Perl space */
case PT_PXSPACE: /* POSIX space */	case PT_PXSPACE: /* POSIX space */
OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z \|\|	switch(c)
c == CHAR_HT \|\| c == CHAR_NL \|\| c == CHAR_VT \|\|	{
c == CHAR_FF \|\| c == CHAR_CR;	HSPACE_CASES:
	VSPACE_CASES:
	OK = TRUE;
	break;

	default:
	OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z;
	break;
	}
break;	break;

case PT_WORD:	case PT_WORD:
OK = _pcre_ucp_gentype[prop->chartype] == ucp_L \|\|	OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L \|\|
_pcre_ucp_gentype[prop->chartype] == ucp_N \|\|	PRIV(ucp_gentype)[prop->chartype] == ucp_N \|\|
c == CHAR_UNDERSCORE;	c == CHAR_UNDERSCORE;
break;	break;

	case PT_CLIST:
	cp = PRIV(ucd_caseless_sets) + code[3];
	for (;;)
	{
	if (c < *cp) { OK = FALSE; break; }
	if (c == *cp++) { OK = TRUE; break; }
	}
	break;

	case PT_UCNC:
	OK = c == CHAR_DOLLAR_SIGN \|\| c == CHAR_COMMERCIAL_AT \|\|
	c == CHAR_GRAVE_ACCENT \|\| (c >= 0xa0 && c <= 0xd7ff) \|\|
	c >= 0xe000;
	break;

/* Should never occur, but keep compilers from grumbling. */	/* Should never occur, but keep compilers from grumbling. */

default:	default:
Line 1248 for (;;)	Line 1424 for (;;)
case OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS:	case OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS:
count = current_state->count; /* Already matched */	count = current_state->count; /* Already matched */
if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }	if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
if (clen > 0 && UCD_CATEGORY(c) != ucp_M)	if (clen > 0)
{	{
const uschar *nptr = ptr + clen;	int lgb, rgb;
	const pcre_uchar *nptr = ptr + clen;
int ncount = 0;	int ncount = 0;
if (count > 0 && codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS)	if (count > 0 && codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS)
{	{
active_count--; /* Remove non-match possibility */	active_count--; /* Remove non-match possibility */
next_active_state--;	next_active_state--;
}	}
	lgb = UCD_GRAPHBREAK(c);
while (nptr < end_subject)	while (nptr < end_subject)
{	{
int nd;	dlen = 1;
int ndlen = 1;	if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
GETCHARLEN(nd, nptr, ndlen);	rgb = UCD_GRAPHBREAK(d);
if (UCD_CATEGORY(nd) != ucp_M) break;	if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
ncount++;	ncount++;
nptr += ndlen;	lgb = rgb;
	nptr += dlen;
}	}
count++;	count++;
ADD_NEW_DATA(-state_offset, count, ncount);	ADD_NEW_DATA(-state_offset, count, ncount);
Line 1283 for (;;)	Line 1462 for (;;)
int ncount = 0;	int ncount = 0;
switch (c)	switch (c)
{	{
case 0x000b:	case CHAR_VT:
case 0x000c:	case CHAR_FF:
case 0x0085:	case CHAR_NEL:
	#ifndef EBCDIC
case 0x2028:	case 0x2028:
case 0x2029:	case 0x2029:
	#endif /* Not EBCDIC */
if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;	if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
goto ANYNL01;	goto ANYNL01;

case 0x000d:	case CHAR_CR:
if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;	if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1;
/* Fall through */	/* Fall through */

ANYNL01:	ANYNL01:
case 0x000a:	case CHAR_LF:
if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS)	if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS)
{	{
active_count--; /* Remove non-match possibility */	active_count--; /* Remove non-match possibility */
Line 1323 for (;;)	Line 1504 for (;;)
BOOL OK;	BOOL OK;
switch (c)	switch (c)
{	{
case 0x000a:	VSPACE_CASES:
case 0x000b:
case 0x000c:
case 0x000d:
case 0x0085:
case 0x2028:
case 0x2029:
OK = TRUE;	OK = TRUE;
break;	break;

Line 1362 for (;;)	Line 1537 for (;;)
BOOL OK;	BOOL OK;
switch (c)	switch (c)
{	{
case 0x09: /* HT */	HSPACE_CASES:
case 0x20: /* SPACE */
case 0xa0: /* NBSP */
case 0x1680: /* OGHAM SPACE MARK */
case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */
case 0x2000: /* EN QUAD */
case 0x2001: /* EM QUAD */
case 0x2002: /* EN SPACE */
case 0x2003: /* EM SPACE */
case 0x2004: /* THREE-PER-EM SPACE */
case 0x2005: /* FOUR-PER-EM SPACE */
case 0x2006: /* SIX-PER-EM SPACE */
case 0x2007: /* FIGURE SPACE */
case 0x2008: /* PUNCTUATION SPACE */
case 0x2009: /* THIN SPACE */
case 0x200A: /* HAIR SPACE */
case 0x202f: /* NARROW NO-BREAK SPACE */
case 0x205f: /* MEDIUM MATHEMATICAL SPACE */
case 0x3000: /* IDEOGRAPHIC SPACE */
OK = TRUE;	OK = TRUE;
break;	break;

Line 1421 for (;;)	Line 1578 for (;;)
if (clen > 0)	if (clen > 0)
{	{
BOOL OK;	BOOL OK;
	const pcre_uint32 *cp;
const ucd_record * prop = GET_UCD(c);	const ucd_record * prop = GET_UCD(c);
switch(code[2])	switch(code[2])
{	{
Line 1434 for (;;)	Line 1592 for (;;)
break;	break;

case PT_GC:	case PT_GC:
OK = _pcre_ucp_gentype[prop->chartype] == code[3];	OK = PRIV(ucp_gentype)[prop->chartype] == code[3];
break;	break;

case PT_PC:	case PT_PC:
Line 1448 for (;;)	Line 1606 for (;;)
/* These are specials for combination cases. */	/* These are specials for combination cases. */

case PT_ALNUM:	case PT_ALNUM:
OK = _pcre_ucp_gentype[prop->chartype] == ucp_L \|\|	OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L \|\|
_pcre_ucp_gentype[prop->chartype] == ucp_N;	PRIV(ucp_gentype)[prop->chartype] == ucp_N;
break;	break;

case PT_SPACE: /* Perl space */	/* Perl space used to exclude VT, but from Perl 5.18 it is included,
OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z \|\|	which means that Perl space and POSIX space are now identical. PCRE
c == CHAR_HT \|\| c == CHAR_NL \|\| c == CHAR_FF \|\| c == CHAR_CR;	was changed at release 8.34. */
break;

	case PT_SPACE: /* Perl space */
case PT_PXSPACE: /* POSIX space */	case PT_PXSPACE: /* POSIX space */
OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z \|\|	switch(c)
c == CHAR_HT \|\| c == CHAR_NL \|\| c == CHAR_VT \|\|	{
c == CHAR_FF \|\| c == CHAR_CR;	HSPACE_CASES:
	VSPACE_CASES:
	OK = TRUE;
	break;

	default:
	OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z;
	break;
	}
break;	break;

case PT_WORD:	case PT_WORD:
OK = _pcre_ucp_gentype[prop->chartype] == ucp_L \|\|	OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L \|\|
_pcre_ucp_gentype[prop->chartype] == ucp_N \|\|	PRIV(ucp_gentype)[prop->chartype] == ucp_N \|\|
c == CHAR_UNDERSCORE;	c == CHAR_UNDERSCORE;
break;	break;

	case PT_CLIST:
	cp = PRIV(ucd_caseless_sets) + code[3];
	for (;;)
	{
	if (c < *cp) { OK = FALSE; break; }
	if (c == *cp++) { OK = TRUE; break; }
	}
	break;

	case PT_UCNC:
	OK = c == CHAR_DOLLAR_SIGN \|\| c == CHAR_COMMERCIAL_AT \|\|
	c == CHAR_GRAVE_ACCENT \|\| (c >= 0xa0 && c <= 0xd7ff) \|\|
	c >= 0xe000;
	break;

/* Should never occur, but keep compilers from grumbling. */	/* Should never occur, but keep compilers from grumbling. */

default:	default:
Line 1504 for (;;)	Line 1685 for (;;)
QS2:	QS2:

ADD_ACTIVE(state_offset + 2, 0);	ADD_ACTIVE(state_offset + 2, 0);
if (clen > 0 && UCD_CATEGORY(c) != ucp_M)	if (clen > 0)
{	{
const uschar *nptr = ptr + clen;	int lgb, rgb;
	const pcre_uchar *nptr = ptr + clen;
int ncount = 0;	int ncount = 0;
if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR \|\|	if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR \|\|
codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSQUERY)	codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSQUERY)
Line 1514 for (;;)	Line 1696 for (;;)
active_count--; /* Remove non-match possibility */	active_count--; /* Remove non-match possibility */
next_active_state--;	next_active_state--;
}	}
	lgb = UCD_GRAPHBREAK(c);
while (nptr < end_subject)	while (nptr < end_subject)
{	{
int nd;	dlen = 1;
int ndlen = 1;	if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
GETCHARLEN(nd, nptr, ndlen);	rgb = UCD_GRAPHBREAK(d);
if (UCD_CATEGORY(nd) != ucp_M) break;	if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
ncount++;	ncount++;
nptr += ndlen;	lgb = rgb;
	nptr += dlen;
}	}
ADD_NEW_DATA(-(state_offset + count), 0, ncount);	ADD_NEW_DATA(-(state_offset + count), 0, ncount);
}	}
Line 1547 for (;;)	Line 1731 for (;;)
int ncount = 0;	int ncount = 0;
switch (c)	switch (c)
{	{
case 0x000b:	case CHAR_VT:
case 0x000c:	case CHAR_FF:
case 0x0085:	case CHAR_NEL:
	#ifndef EBCDIC
case 0x2028:	case 0x2028:
case 0x2029:	case 0x2029:
	#endif /* Not EBCDIC */
if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;	if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
goto ANYNL02;	goto ANYNL02;

case 0x000d:	case CHAR_CR:
if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;	if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1;
/* Fall through */	/* Fall through */

ANYNL02:	ANYNL02:
case 0x000a:	case CHAR_LF:
if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR \|\|	if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR \|\|
codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY)	codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY)
{	{
active_count--; /* Remove non-match possibility */	active_count--; /* Remove non-match possibility */
next_active_state--;	next_active_state--;
}	}
ADD_NEW_DATA(-(state_offset + count), 0, ncount);	ADD_NEW_DATA(-(state_offset + (int)count), 0, ncount);
break;	break;

default:	default:
Line 1595 for (;;)	Line 1781 for (;;)
BOOL OK;	BOOL OK;
switch (c)	switch (c)
{	{
case 0x000a:	VSPACE_CASES:
case 0x000b:
case 0x000c:
case 0x000d:
case 0x0085:
case 0x2028:
case 0x2029:
OK = TRUE;	OK = TRUE;
break;	break;

Line 1617 for (;;)	Line 1797 for (;;)
active_count--; /* Remove non-match possibility */	active_count--; /* Remove non-match possibility */
next_active_state--;	next_active_state--;
}	}
ADD_NEW_DATA(-(state_offset + count), 0, 0);	ADD_NEW_DATA(-(state_offset + (int)count), 0, 0);
}	}
}	}
break;	break;
Line 1641 for (;;)	Line 1821 for (;;)
BOOL OK;	BOOL OK;
switch (c)	switch (c)
{	{
case 0x09: /* HT */	HSPACE_CASES:
case 0x20: /* SPACE */
case 0xa0: /* NBSP */
case 0x1680: /* OGHAM SPACE MARK */
case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */
case 0x2000: /* EN QUAD */
case 0x2001: /* EM QUAD */
case 0x2002: /* EN SPACE */
case 0x2003: /* EM SPACE */
case 0x2004: /* THREE-PER-EM SPACE */
case 0x2005: /* FOUR-PER-EM SPACE */
case 0x2006: /* SIX-PER-EM SPACE */
case 0x2007: /* FIGURE SPACE */
case 0x2008: /* PUNCTUATION SPACE */
case 0x2009: /* THIN SPACE */
case 0x200A: /* HAIR SPACE */
case 0x202f: /* NARROW NO-BREAK SPACE */
case 0x205f: /* MEDIUM MATHEMATICAL SPACE */
case 0x3000: /* IDEOGRAPHIC SPACE */
OK = TRUE;	OK = TRUE;
break;	break;

Line 1676 for (;;)	Line 1838 for (;;)
active_count--; /* Remove non-match possibility */	active_count--; /* Remove non-match possibility */
next_active_state--;	next_active_state--;
}	}
ADD_NEW_DATA(-(state_offset + count), 0, 0);	ADD_NEW_DATA(-(state_offset + (int)count), 0, 0);
}	}
}	}
break;	break;
Line 1688 for (;;)	Line 1850 for (;;)
case OP_PROP_EXTRA + OP_TYPEMINUPTO:	case OP_PROP_EXTRA + OP_TYPEMINUPTO:
case OP_PROP_EXTRA + OP_TYPEPOSUPTO:	case OP_PROP_EXTRA + OP_TYPEPOSUPTO:
if (codevalue != OP_PROP_EXTRA + OP_TYPEEXACT)	if (codevalue != OP_PROP_EXTRA + OP_TYPEEXACT)
{ ADD_ACTIVE(state_offset + 6, 0); }	{ ADD_ACTIVE(state_offset + 1 + IMM2_SIZE + 3, 0); }
count = current_state->count; /* Number already matched */	count = current_state->count; /* Number already matched */
if (clen > 0)	if (clen > 0)
{	{
BOOL OK;	BOOL OK;
	const pcre_uint32 *cp;
const ucd_record * prop = GET_UCD(c);	const ucd_record * prop = GET_UCD(c);
switch(code[4])	switch(code[1 + IMM2_SIZE + 1])
{	{
case PT_ANY:	case PT_ANY:
OK = TRUE;	OK = TRUE;
Line 1706 for (;;)	Line 1869 for (;;)
break;	break;

case PT_GC:	case PT_GC:
OK = _pcre_ucp_gentype[prop->chartype] == code[5];	OK = PRIV(ucp_gentype)[prop->chartype] == code[1 + IMM2_SIZE + 2];
break;	break;

case PT_PC:	case PT_PC:
OK = prop->chartype == code[5];	OK = prop->chartype == code[1 + IMM2_SIZE + 2];
break;	break;

case PT_SC:	case PT_SC:
OK = prop->script == code[5];	OK = prop->script == code[1 + IMM2_SIZE + 2];
break;	break;

/* These are specials for combination cases. */	/* These are specials for combination cases. */

case PT_ALNUM:	case PT_ALNUM:
OK = _pcre_ucp_gentype[prop->chartype] == ucp_L \|\|	OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L \|\|
_pcre_ucp_gentype[prop->chartype] == ucp_N;	PRIV(ucp_gentype)[prop->chartype] == ucp_N;
break;	break;

case PT_SPACE: /* Perl space */	/* Perl space used to exclude VT, but from Perl 5.18 it is included,
OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z \|\|	which means that Perl space and POSIX space are now identical. PCRE
c == CHAR_HT \|\| c == CHAR_NL \|\| c == CHAR_FF \|\| c == CHAR_CR;	was changed at release 8.34. */
break;

	case PT_SPACE: /* Perl space */
case PT_PXSPACE: /* POSIX space */	case PT_PXSPACE: /* POSIX space */
OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z \|\|	switch(c)
c == CHAR_HT \|\| c == CHAR_NL \|\| c == CHAR_VT \|\|	{
c == CHAR_FF \|\| c == CHAR_CR;	HSPACE_CASES:
	VSPACE_CASES:
	OK = TRUE;
	break;

	default:
	OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z;
	break;
	}
break;	break;

case PT_WORD:	case PT_WORD:
OK = _pcre_ucp_gentype[prop->chartype] == ucp_L \|\|	OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L \|\|
_pcre_ucp_gentype[prop->chartype] == ucp_N \|\|	PRIV(ucp_gentype)[prop->chartype] == ucp_N \|\|
c == CHAR_UNDERSCORE;	c == CHAR_UNDERSCORE;
break;	break;

	case PT_CLIST:
	cp = PRIV(ucd_caseless_sets) + code[1 + IMM2_SIZE + 2];
	for (;;)
	{
	if (c < *cp) { OK = FALSE; break; }
	if (c == *cp++) { OK = TRUE; break; }
	}
	break;

	case PT_UCNC:
	OK = c == CHAR_DOLLAR_SIGN \|\| c == CHAR_COMMERCIAL_AT \|\|
	c == CHAR_GRAVE_ACCENT \|\| (c >= 0xa0 && c <= 0xd7ff) \|\|
	c >= 0xe000;
	break;

/* Should never occur, but keep compilers from grumbling. */	/* Should never occur, but keep compilers from grumbling. */

default:	default:
Line 1755 for (;;)	Line 1941 for (;;)
active_count--; /* Remove non-match possibility */	active_count--; /* Remove non-match possibility */
next_active_state--;	next_active_state--;
}	}
if (++count >= GET2(code, 1))	if (++count >= (int)GET2(code, 1))
{ ADD_NEW(state_offset + 6, 0); }	{ ADD_NEW(state_offset + 1 + IMM2_SIZE + 3, 0); }
else	else
{ ADD_NEW(state_offset, count); }	{ ADD_NEW(state_offset, count); }
}	}
Line 1769 for (;;)	Line 1955 for (;;)
case OP_EXTUNI_EXTRA + OP_TYPEMINUPTO:	case OP_EXTUNI_EXTRA + OP_TYPEMINUPTO:
case OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO:	case OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO:
if (codevalue != OP_EXTUNI_EXTRA + OP_TYPEEXACT)	if (codevalue != OP_EXTUNI_EXTRA + OP_TYPEEXACT)
{ ADD_ACTIVE(state_offset + 4, 0); }	{ ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); }
count = current_state->count; /* Number already matched */	count = current_state->count; /* Number already matched */
if (clen > 0 && UCD_CATEGORY(c) != ucp_M)	if (clen > 0)
{	{
const uschar *nptr = ptr + clen;	int lgb, rgb;
	const pcre_uchar *nptr = ptr + clen;
int ncount = 0;	int ncount = 0;
if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO)	if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO)
{	{
active_count--; /* Remove non-match possibility */	active_count--; /* Remove non-match possibility */
next_active_state--;	next_active_state--;
}	}
	lgb = UCD_GRAPHBREAK(c);
while (nptr < end_subject)	while (nptr < end_subject)
{	{
int nd;	dlen = 1;
int ndlen = 1;	if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
GETCHARLEN(nd, nptr, ndlen);	rgb = UCD_GRAPHBREAK(d);
if (UCD_CATEGORY(nd) != ucp_M) break;	if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
ncount++;	ncount++;
nptr += ndlen;	lgb = rgb;
	nptr += dlen;
}	}
if (++count >= GET2(code, 1))	if (nptr >= end_subject && (md->moptions & PCRE_PARTIAL_HARD) != 0)
{ ADD_NEW_DATA(-(state_offset + 4), 0, ncount); }	reset_could_continue = TRUE;
	if (++count >= (int)GET2(code, 1))
	{ ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, ncount); }
else	else
{ ADD_NEW_DATA(-state_offset, count, ncount); }	{ ADD_NEW_DATA(-state_offset, count, ncount); }
}	}
Line 1803 for (;;)	Line 1994 for (;;)
case OP_ANYNL_EXTRA + OP_TYPEMINUPTO:	case OP_ANYNL_EXTRA + OP_TYPEMINUPTO:
case OP_ANYNL_EXTRA + OP_TYPEPOSUPTO:	case OP_ANYNL_EXTRA + OP_TYPEPOSUPTO:
if (codevalue != OP_ANYNL_EXTRA + OP_TYPEEXACT)	if (codevalue != OP_ANYNL_EXTRA + OP_TYPEEXACT)
{ ADD_ACTIVE(state_offset + 4, 0); }	{ ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); }
count = current_state->count; /* Number already matched */	count = current_state->count; /* Number already matched */
if (clen > 0)	if (clen > 0)
{	{
int ncount = 0;	int ncount = 0;
switch (c)	switch (c)
{	{
case 0x000b:	case CHAR_VT:
case 0x000c:	case CHAR_FF:
case 0x0085:	case CHAR_NEL:
	#ifndef EBCDIC
case 0x2028:	case 0x2028:
case 0x2029:	case 0x2029:
	#endif /* Not EBCDIC */
if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;	if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
goto ANYNL03;	goto ANYNL03;

case 0x000d:	case CHAR_CR:
if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;	if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1;
/* Fall through */	/* Fall through */

ANYNL03:	ANYNL03:
case 0x000a:	case CHAR_LF:
if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO)	if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO)
{	{
active_count--; /* Remove non-match possibility */	active_count--; /* Remove non-match possibility */
next_active_state--;	next_active_state--;
}	}
if (++count >= GET2(code, 1))	if (++count >= (int)GET2(code, 1))
{ ADD_NEW_DATA(-(state_offset + 4), 0, ncount); }	{ ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, ncount); }
else	else
{ ADD_NEW_DATA(-state_offset, count, ncount); }	{ ADD_NEW_DATA(-state_offset, count, ncount); }
break;	break;
Line 1847 for (;;)	Line 2040 for (;;)
case OP_VSPACE_EXTRA + OP_TYPEMINUPTO:	case OP_VSPACE_EXTRA + OP_TYPEMINUPTO:
case OP_VSPACE_EXTRA + OP_TYPEPOSUPTO:	case OP_VSPACE_EXTRA + OP_TYPEPOSUPTO:
if (codevalue != OP_VSPACE_EXTRA + OP_TYPEEXACT)	if (codevalue != OP_VSPACE_EXTRA + OP_TYPEEXACT)
{ ADD_ACTIVE(state_offset + 4, 0); }	{ ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); }
count = current_state->count; /* Number already matched */	count = current_state->count; /* Number already matched */
if (clen > 0)	if (clen > 0)
{	{
BOOL OK;	BOOL OK;
switch (c)	switch (c)
{	{
case 0x000a:	VSPACE_CASES:
case 0x000b:
case 0x000c:
case 0x000d:
case 0x0085:
case 0x2028:
case 0x2029:
OK = TRUE;	OK = TRUE;
break;	break;

Line 1875 for (;;)	Line 2062 for (;;)
active_count--; /* Remove non-match possibility */	active_count--; /* Remove non-match possibility */
next_active_state--;	next_active_state--;
}	}
if (++count >= GET2(code, 1))	if (++count >= (int)GET2(code, 1))
{ ADD_NEW_DATA(-(state_offset + 4), 0, 0); }	{ ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, 0); }
else	else
{ ADD_NEW_DATA(-state_offset, count, 0); }	{ ADD_NEW_DATA(-state_offset, count, 0); }
}	}
Line 1889 for (;;)	Line 2076 for (;;)
case OP_HSPACE_EXTRA + OP_TYPEMINUPTO:	case OP_HSPACE_EXTRA + OP_TYPEMINUPTO:
case OP_HSPACE_EXTRA + OP_TYPEPOSUPTO:	case OP_HSPACE_EXTRA + OP_TYPEPOSUPTO:
if (codevalue != OP_HSPACE_EXTRA + OP_TYPEEXACT)	if (codevalue != OP_HSPACE_EXTRA + OP_TYPEEXACT)
{ ADD_ACTIVE(state_offset + 4, 0); }	{ ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); }
count = current_state->count; /* Number already matched */	count = current_state->count; /* Number already matched */
if (clen > 0)	if (clen > 0)
{	{
BOOL OK;	BOOL OK;
switch (c)	switch (c)
{	{
case 0x09: /* HT */	HSPACE_CASES:
case 0x20: /* SPACE */
case 0xa0: /* NBSP */
case 0x1680: /* OGHAM SPACE MARK */
case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */
case 0x2000: /* EN QUAD */
case 0x2001: /* EM QUAD */
case 0x2002: /* EN SPACE */
case 0x2003: /* EM SPACE */
case 0x2004: /* THREE-PER-EM SPACE */
case 0x2005: /* FOUR-PER-EM SPACE */
case 0x2006: /* SIX-PER-EM SPACE */
case 0x2007: /* FIGURE SPACE */
case 0x2008: /* PUNCTUATION SPACE */
case 0x2009: /* THIN SPACE */
case 0x200A: /* HAIR SPACE */
case 0x202f: /* NARROW NO-BREAK SPACE */
case 0x205f: /* MEDIUM MATHEMATICAL SPACE */
case 0x3000: /* IDEOGRAPHIC SPACE */
OK = TRUE;	OK = TRUE;
break;	break;

Line 1930 for (;;)	Line 2099 for (;;)
active_count--; /* Remove non-match possibility */	active_count--; /* Remove non-match possibility */
next_active_state--;	next_active_state--;
}	}
if (++count >= GET2(code, 1))	if (++count >= (int)GET2(code, 1))
{ ADD_NEW_DATA(-(state_offset + 4), 0, 0); }	{ ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, 0); }
else	else
{ ADD_NEW_DATA(-state_offset, count, 0); }	{ ADD_NEW_DATA(-state_offset, count, 0); }
}	}
Line 1950 for (;;)	Line 2119 for (;;)
break;	break;

/-----------------------------------------------------------------/	/-----------------------------------------------------------------/
case OP_CHARNC:	case OP_CHARI:
if (clen == 0) break;	if (clen == 0) break;

#ifdef SUPPORT_UTF8	#ifdef SUPPORT_UTF
if (utf8)	if (utf)
{	{
if (c == d) { ADD_NEW(state_offset + dlen + 1, 0); } else	if (c == d) { ADD_NEW(state_offset + dlen + 1, 0); } else
{	{
unsigned int othercase;	unsigned int othercase;
if (c < 128) othercase = fcc[c]; else	if (c < 128)
	othercase = fcc[c];
/* If we have Unicode property support, we can use it to test the	else
other case of the character. */	/* If we have Unicode property support, we can use it to test the
	other case of the character. */
#ifdef SUPPORT_UCP	#ifdef SUPPORT_UCP
othercase = UCD_OTHERCASE(c);	othercase = UCD_OTHERCASE(c);
#else	#else
othercase = NOTACHAR;	othercase = NOTACHAR;
#endif	#endif

if (d == othercase) { ADD_NEW(state_offset + dlen + 1, 0); }	if (d == othercase) { ADD_NEW(state_offset + dlen + 1, 0); }
}	}
}	}
else	else
#endif /* SUPPORT_UTF8 */	#endif /* SUPPORT_UTF */
	/* Not UTF mode */
/* Non-UTF-8 mode */
{	{
if (lcc[c] == lcc[d]) { ADD_NEW(state_offset + 2, 0); }	if (TABLE_GET(c, lcc, c) == TABLE_GET(d, lcc, d))
	{ ADD_NEW(state_offset + 2, 0); }
}	}
break;	break;

Line 1990 for (;;)	Line 2159 for (;;)
to wait for them to pass before continuing. */	to wait for them to pass before continuing. */

case OP_EXTUNI:	case OP_EXTUNI:
if (clen > 0 && UCD_CATEGORY(c) != ucp_M)	if (clen > 0)
{	{
const uschar *nptr = ptr + clen;	int lgb, rgb;
	const pcre_uchar *nptr = ptr + clen;
int ncount = 0;	int ncount = 0;
	lgb = UCD_GRAPHBREAK(c);
while (nptr < end_subject)	while (nptr < end_subject)
{	{
int nclen = 1;	dlen = 1;
GETCHARLEN(c, nptr, nclen);	if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
if (UCD_CATEGORY(c) != ucp_M) break;	rgb = UCD_GRAPHBREAK(d);
	if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
ncount++;	ncount++;
nptr += nclen;	lgb = rgb;
	nptr += dlen;
}	}
	if (nptr >= end_subject && (md->moptions & PCRE_PARTIAL_HARD) != 0)
	reset_could_continue = TRUE;
ADD_NEW_DATA(-(state_offset + 1), 0, ncount);	ADD_NEW_DATA(-(state_offset + 1), 0, ncount);
}	}
break;	break;
Line 2015 for (;;)	Line 2190 for (;;)
case OP_ANYNL:	case OP_ANYNL:
if (clen > 0) switch(c)	if (clen > 0) switch(c)
{	{
case 0x000b:	case CHAR_VT:
case 0x000c:	case CHAR_FF:
case 0x0085:	case CHAR_NEL:
	#ifndef EBCDIC
case 0x2028:	case 0x2028:
case 0x2029:	case 0x2029:
	#endif /* Not EBCDIC */
if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;	if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;

case 0x000a:	case CHAR_LF:
ADD_NEW(state_offset + 1, 0);	ADD_NEW(state_offset + 1, 0);
break;	break;

case 0x000d:	case CHAR_CR:
if (ptr + 1 < end_subject && ptr[1] == 0x0a)	if (ptr + 1 >= end_subject)
	{
	ADD_NEW(state_offset + 1, 0);
	if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
	reset_could_continue = TRUE;
	}
	else if (UCHAR21TEST(ptr + 1) == CHAR_LF)
{	{
ADD_NEW_DATA(-(state_offset + 1), 0, 1);	ADD_NEW_DATA(-(state_offset + 1), 0, 1);
}	}
Line 2043 for (;;)	Line 2226 for (;;)
case OP_NOT_VSPACE:	case OP_NOT_VSPACE:
if (clen > 0) switch(c)	if (clen > 0) switch(c)
{	{
case 0x000a:	VSPACE_CASES:
case 0x000b:
case 0x000c:
case 0x000d:
case 0x0085:
case 0x2028:
case 0x2029:
break;	break;

default:	default:
Line 2062 for (;;)	Line 2239 for (;;)
case OP_VSPACE:	case OP_VSPACE:
if (clen > 0) switch(c)	if (clen > 0) switch(c)
{	{
case 0x000a:	VSPACE_CASES:
case 0x000b:
case 0x000c:
case 0x000d:
case 0x0085:
case 0x2028:
case 0x2029:
ADD_NEW(state_offset + 1, 0);	ADD_NEW(state_offset + 1, 0);
break;	break;

default: break;	default:
	break;
}	}
break;	break;

Line 2080 for (;;)	Line 2252 for (;;)
case OP_NOT_HSPACE:	case OP_NOT_HSPACE:
if (clen > 0) switch(c)	if (clen > 0) switch(c)
{	{
case 0x09: /* HT */	HSPACE_CASES:
case 0x20: /* SPACE */
case 0xa0: /* NBSP */
case 0x1680: /* OGHAM SPACE MARK */
case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */
case 0x2000: /* EN QUAD */
case 0x2001: /* EM QUAD */
case 0x2002: /* EN SPACE */
case 0x2003: /* EM SPACE */
case 0x2004: /* THREE-PER-EM SPACE */
case 0x2005: /* FOUR-PER-EM SPACE */
case 0x2006: /* SIX-PER-EM SPACE */
case 0x2007: /* FIGURE SPACE */
case 0x2008: /* PUNCTUATION SPACE */
case 0x2009: /* THIN SPACE */
case 0x200A: /* HAIR SPACE */
case 0x202f: /* NARROW NO-BREAK SPACE */
case 0x205f: /* MEDIUM MATHEMATICAL SPACE */
case 0x3000: /* IDEOGRAPHIC SPACE */
break;	break;

default:	default:
Line 2111 for (;;)	Line 2265 for (;;)
case OP_HSPACE:	case OP_HSPACE:
if (clen > 0) switch(c)	if (clen > 0) switch(c)
{	{
case 0x09: /* HT */	HSPACE_CASES:
case 0x20: /* SPACE */
case 0xa0: /* NBSP */
case 0x1680: /* OGHAM SPACE MARK */
case 0x180e: /* MONGOLIAN VOWEL SEPARATOR */
case 0x2000: /* EN QUAD */
case 0x2001: /* EM QUAD */
case 0x2002: /* EN SPACE */
case 0x2003: /* EM SPACE */
case 0x2004: /* THREE-PER-EM SPACE */
case 0x2005: /* FOUR-PER-EM SPACE */
case 0x2006: /* SIX-PER-EM SPACE */
case 0x2007: /* FIGURE SPACE */
case 0x2008: /* PUNCTUATION SPACE */
case 0x2009: /* THIN SPACE */
case 0x200A: /* HAIR SPACE */
case 0x202f: /* NARROW NO-BREAK SPACE */
case 0x205f: /* MEDIUM MATHEMATICAL SPACE */
case 0x3000: /* IDEOGRAPHIC SPACE */
ADD_NEW(state_offset + 1, 0);	ADD_NEW(state_offset + 1, 0);
break;	break;

	default:
	break;
}	}
break;	break;

/-----------------------------------------------------------------/	/-----------------------------------------------------------------/
/* Match a negated single character. This is only used for one-byte	/* Match a negated single character casefully. */
characters, that is, we know that d < 256. The character we are
checking (c) can be multibyte. */

case OP_NOT:	case OP_NOT:
	if (clen > 0 && c != d) { ADD_NEW(state_offset + dlen + 1, 0); }
	break;

	/-----------------------------------------------------------------/
	/* Match a negated single character caselessly. */

	case OP_NOTI:
if (clen > 0)	if (clen > 0)
{	{
unsigned int otherd = ((ims & PCRE_CASELESS) != 0)? fcc[d] : d;	unsigned int otherd;
if (c != d && c != otherd) { ADD_NEW(state_offset + dlen + 1, 0); }	#ifdef SUPPORT_UTF
	if (utf && d >= 128)
	{
	#ifdef SUPPORT_UCP
	otherd = UCD_OTHERCASE(d);
	#endif /* SUPPORT_UCP */
	}
	else
	#endif /* SUPPORT_UTF */
	otherd = TABLE_GET(d, fcc, d);
	if (c != d && c != otherd)
	{ ADD_NEW(state_offset + dlen + 1, 0); }
}	}
break;	break;

/-----------------------------------------------------------------/	/-----------------------------------------------------------------/
	case OP_PLUSI:
	case OP_MINPLUSI:
	case OP_POSPLUSI:
	case OP_NOTPLUSI:
	case OP_NOTMINPLUSI:
	case OP_NOTPOSPLUSI:
	caseless = TRUE;
	codevalue -= OP_STARI - OP_STAR;

	/* Fall through */
case OP_PLUS:	case OP_PLUS:
case OP_MINPLUS:	case OP_MINPLUS:
case OP_POSPLUS:	case OP_POSPLUS:
Line 2159 for (;;)	Line 2324 for (;;)
if (count > 0) { ADD_ACTIVE(state_offset + dlen + 1, 0); }	if (count > 0) { ADD_ACTIVE(state_offset + dlen + 1, 0); }
if (clen > 0)	if (clen > 0)
{	{
unsigned int otherd = NOTACHAR;	pcre_uint32 otherd = NOTACHAR;
if ((ims & PCRE_CASELESS) != 0)	if (caseless)
{	{
#ifdef SUPPORT_UTF8	#ifdef SUPPORT_UTF
if (utf8 && d >= 128)	if (utf && d >= 128)
{	{
#ifdef SUPPORT_UCP	#ifdef SUPPORT_UCP
otherd = UCD_OTHERCASE(d);	otherd = UCD_OTHERCASE(d);
#endif /* SUPPORT_UCP */	#endif /* SUPPORT_UCP */
}	}
else	else
#endif /* SUPPORT_UTF8 */	#endif /* SUPPORT_UTF */
otherd = fcc[d];	otherd = TABLE_GET(d, fcc, d);
}	}
if ((c == d \|\| c == otherd) == (codevalue < OP_NOTSTAR))	if ((c == d \|\| c == otherd) == (codevalue < OP_NOTSTAR))
{	{
Line 2188 for (;;)	Line 2353 for (;;)
break;	break;

/-----------------------------------------------------------------/	/-----------------------------------------------------------------/
	case OP_QUERYI:
	case OP_MINQUERYI:
	case OP_POSQUERYI:
	case OP_NOTQUERYI:
	case OP_NOTMINQUERYI:
	case OP_NOTPOSQUERYI:
	caseless = TRUE;
	codevalue -= OP_STARI - OP_STAR;
	/* Fall through */
case OP_QUERY:	case OP_QUERY:
case OP_MINQUERY:	case OP_MINQUERY:
case OP_POSQUERY:	case OP_POSQUERY:
Line 2197 for (;;)	Line 2371 for (;;)
ADD_ACTIVE(state_offset + dlen + 1, 0);	ADD_ACTIVE(state_offset + dlen + 1, 0);
if (clen > 0)	if (clen > 0)
{	{
unsigned int otherd = NOTACHAR;	pcre_uint32 otherd = NOTACHAR;
if ((ims & PCRE_CASELESS) != 0)	if (caseless)
{	{
#ifdef SUPPORT_UTF8	#ifdef SUPPORT_UTF
if (utf8 && d >= 128)	if (utf && d >= 128)
{	{
#ifdef SUPPORT_UCP	#ifdef SUPPORT_UCP
otherd = UCD_OTHERCASE(d);	otherd = UCD_OTHERCASE(d);
#endif /* SUPPORT_UCP */	#endif /* SUPPORT_UCP */
}	}
else	else
#endif /* SUPPORT_UTF8 */	#endif /* SUPPORT_UTF */
otherd = fcc[d];	otherd = TABLE_GET(d, fcc, d);
}	}
if ((c == d \|\| c == otherd) == (codevalue < OP_NOTSTAR))	if ((c == d \|\| c == otherd) == (codevalue < OP_NOTSTAR))
{	{
Line 2224 for (;;)	Line 2398 for (;;)
break;	break;

/-----------------------------------------------------------------/	/-----------------------------------------------------------------/
	case OP_STARI:
	case OP_MINSTARI:
	case OP_POSSTARI:
	case OP_NOTSTARI:
	case OP_NOTMINSTARI:
	case OP_NOTPOSSTARI:
	caseless = TRUE;
	codevalue -= OP_STARI - OP_STAR;
	/* Fall through */
case OP_STAR:	case OP_STAR:
case OP_MINSTAR:	case OP_MINSTAR:
case OP_POSSTAR:	case OP_POSSTAR:
Line 2233 for (;;)	Line 2416 for (;;)
ADD_ACTIVE(state_offset + dlen + 1, 0);	ADD_ACTIVE(state_offset + dlen + 1, 0);
if (clen > 0)	if (clen > 0)
{	{
unsigned int otherd = NOTACHAR;	pcre_uint32 otherd = NOTACHAR;
if ((ims & PCRE_CASELESS) != 0)	if (caseless)
{	{
#ifdef SUPPORT_UTF8	#ifdef SUPPORT_UTF
if (utf8 && d >= 128)	if (utf && d >= 128)
{	{
#ifdef SUPPORT_UCP	#ifdef SUPPORT_UCP
otherd = UCD_OTHERCASE(d);	otherd = UCD_OTHERCASE(d);
#endif /* SUPPORT_UCP */	#endif /* SUPPORT_UCP */
}	}
else	else
#endif /* SUPPORT_UTF8 */	#endif /* SUPPORT_UTF */
otherd = fcc[d];	otherd = TABLE_GET(d, fcc, d);
}	}
if ((c == d \|\| c == otherd) == (codevalue < OP_NOTSTAR))	if ((c == d \|\| c == otherd) == (codevalue < OP_NOTSTAR))
{	{
Line 2260 for (;;)	Line 2443 for (;;)
break;	break;

/-----------------------------------------------------------------/	/-----------------------------------------------------------------/
	case OP_EXACTI:
	case OP_NOTEXACTI:
	caseless = TRUE;
	codevalue -= OP_STARI - OP_STAR;
	/* Fall through */
case OP_EXACT:	case OP_EXACT:
case OP_NOTEXACT:	case OP_NOTEXACT:
count = current_state->count; /* Number already matched */	count = current_state->count; /* Number already matched */
if (clen > 0)	if (clen > 0)
{	{
unsigned int otherd = NOTACHAR;	pcre_uint32 otherd = NOTACHAR;
if ((ims & PCRE_CASELESS) != 0)	if (caseless)
{	{
#ifdef SUPPORT_UTF8	#ifdef SUPPORT_UTF
if (utf8 && d >= 128)	if (utf && d >= 128)
{	{
#ifdef SUPPORT_UCP	#ifdef SUPPORT_UCP
otherd = UCD_OTHERCASE(d);	otherd = UCD_OTHERCASE(d);
#endif /* SUPPORT_UCP */	#endif /* SUPPORT_UCP */
}	}
else	else
#endif /* SUPPORT_UTF8 */	#endif /* SUPPORT_UTF */
otherd = fcc[d];	otherd = TABLE_GET(d, fcc, d);
}	}
if ((c == d \|\| c == otherd) == (codevalue < OP_NOTSTAR))	if ((c == d \|\| c == otherd) == (codevalue < OP_NOTSTAR))
{	{
if (++count >= GET2(code, 1))	if (++count >= (int)GET2(code, 1))
{ ADD_NEW(state_offset + dlen + 3, 0); }	{ ADD_NEW(state_offset + dlen + 1 + IMM2_SIZE, 0); }
else	else
{ ADD_NEW(state_offset, count); }	{ ADD_NEW(state_offset, count); }
}	}
Line 2290 for (;;)	Line 2478 for (;;)
break;	break;

/-----------------------------------------------------------------/	/-----------------------------------------------------------------/
	case OP_UPTOI:
	case OP_MINUPTOI:
	case OP_POSUPTOI:
	case OP_NOTUPTOI:
	case OP_NOTMINUPTOI:
	case OP_NOTPOSUPTOI:
	caseless = TRUE;
	codevalue -= OP_STARI - OP_STAR;
	/* Fall through */
case OP_UPTO:	case OP_UPTO:
case OP_MINUPTO:	case OP_MINUPTO:
case OP_POSUPTO:	case OP_POSUPTO:
case OP_NOTUPTO:	case OP_NOTUPTO:
case OP_NOTMINUPTO:	case OP_NOTMINUPTO:
case OP_NOTPOSUPTO:	case OP_NOTPOSUPTO:
ADD_ACTIVE(state_offset + dlen + 3, 0);	ADD_ACTIVE(state_offset + dlen + 1 + IMM2_SIZE, 0);
count = current_state->count; /* Number already matched */	count = current_state->count; /* Number already matched */
if (clen > 0)	if (clen > 0)
{	{
unsigned int otherd = NOTACHAR;	pcre_uint32 otherd = NOTACHAR;
if ((ims & PCRE_CASELESS) != 0)	if (caseless)
{	{
#ifdef SUPPORT_UTF8	#ifdef SUPPORT_UTF
if (utf8 && d >= 128)	if (utf && d >= 128)
{	{
#ifdef SUPPORT_UCP	#ifdef SUPPORT_UCP
otherd = UCD_OTHERCASE(d);	otherd = UCD_OTHERCASE(d);
#endif /* SUPPORT_UCP */	#endif /* SUPPORT_UCP */
}	}
else	else
#endif /* SUPPORT_UTF8 */	#endif /* SUPPORT_UTF */
otherd = fcc[d];	otherd = TABLE_GET(d, fcc, d);
}	}
if ((c == d \|\| c == otherd) == (codevalue < OP_NOTSTAR))	if ((c == d \|\| c == otherd) == (codevalue < OP_NOTSTAR))
{	{
Line 2321 for (;;)	Line 2518 for (;;)
active_count--; /* Remove non-match possibility */	active_count--; /* Remove non-match possibility */
next_active_state--;	next_active_state--;
}	}
if (++count >= GET2(code, 1))	if (++count >= (int)GET2(code, 1))
{ ADD_NEW(state_offset + dlen + 3, 0); }	{ ADD_NEW(state_offset + dlen + 1 + IMM2_SIZE, 0); }
else	else
{ ADD_NEW(state_offset, count); }	{ ADD_NEW(state_offset, count); }
}	}
Line 2339 for (;;)	Line 2536 for (;;)
{	{
BOOL isinclass = FALSE;	BOOL isinclass = FALSE;
int next_state_offset;	int next_state_offset;
const uschar *ecode;	const pcre_uchar *ecode;

/* For a simple class, there is always just a 32-byte table, and we	/* For a simple class, there is always just a 32-byte table, and we
can set isinclass from it. */	can set isinclass from it. */

if (codevalue != OP_XCLASS)	if (codevalue != OP_XCLASS)
{	{
ecode = code + 33;	ecode = code + 1 + (32 / sizeof(pcre_uchar));
if (clen > 0)	if (clen > 0)
{	{
isinclass = (c > 255)? (codevalue == OP_NCLASS) :	isinclass = (c > 255)? (codevalue == OP_NCLASS) :
((code[1 + c/8] & (1 << (c&7))) != 0);	((((pcre_uint8 *)(code + 1))[c/8] & (1 << (c&7))) != 0);
}	}
}	}

Line 2361 for (;;)	Line 2558 for (;;)
else	else
{	{
ecode = code + GET(code, 1);	ecode = code + GET(code, 1);
if (clen > 0) isinclass = _pcre_xclass(c, code + 1 + LINK_SIZE);	if (clen > 0) isinclass = PRIV(xclass)(c, code + 1 + LINK_SIZE, utf);
}	}

/* At this point, isinclass is set for all kinds of class, and ecode	/* At this point, isinclass is set for all kinds of class, and ecode
Line 2374 for (;;)	Line 2571 for (;;)
{	{
case OP_CRSTAR:	case OP_CRSTAR:
case OP_CRMINSTAR:	case OP_CRMINSTAR:
	case OP_CRPOSSTAR:
ADD_ACTIVE(next_state_offset + 1, 0);	ADD_ACTIVE(next_state_offset + 1, 0);
if (isinclass) { ADD_NEW(state_offset, 0); }	if (isinclass)
	{
	if (*ecode == OP_CRPOSSTAR)
	{
	active_count--; /* Remove non-match possibility */
	next_active_state--;
	}
	ADD_NEW(state_offset, 0);
	}
break;	break;

case OP_CRPLUS:	case OP_CRPLUS:
case OP_CRMINPLUS:	case OP_CRMINPLUS:
	case OP_CRPOSPLUS:
count = current_state->count; /* Already matched */	count = current_state->count; /* Already matched */
if (count > 0) { ADD_ACTIVE(next_state_offset + 1, 0); }	if (count > 0) { ADD_ACTIVE(next_state_offset + 1, 0); }
if (isinclass) { count++; ADD_NEW(state_offset, count); }	if (isinclass)
	{
	if (count > 0 && *ecode == OP_CRPOSPLUS)
	{
	active_count--; /* Remove non-match possibility */
	next_active_state--;
	}
	count++;
	ADD_NEW(state_offset, count);
	}
break;	break;

case OP_CRQUERY:	case OP_CRQUERY:
case OP_CRMINQUERY:	case OP_CRMINQUERY:
	case OP_CRPOSQUERY:
ADD_ACTIVE(next_state_offset + 1, 0);	ADD_ACTIVE(next_state_offset + 1, 0);
if (isinclass) { ADD_NEW(next_state_offset + 1, 0); }	if (isinclass)
	{
	if (*ecode == OP_CRPOSQUERY)
	{
	active_count--; /* Remove non-match possibility */
	next_active_state--;
	}
	ADD_NEW(next_state_offset + 1, 0);
	}
break;	break;

case OP_CRRANGE:	case OP_CRRANGE:
case OP_CRMINRANGE:	case OP_CRMINRANGE:
	case OP_CRPOSRANGE:
count = current_state->count; /* Already matched */	count = current_state->count; /* Already matched */
if (count >= GET2(ecode, 1))	if (count >= (int)GET2(ecode, 1))
{ ADD_ACTIVE(next_state_offset + 5, 0); }	{ ADD_ACTIVE(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }
if (isinclass)	if (isinclass)
{	{
int max = GET2(ecode, 3);	int max = (int)GET2(ecode, 1 + IMM2_SIZE);
	if (*ecode == OP_CRPOSRANGE)
	{
	active_count--; /* Remove non-match possibility */
	next_active_state--;
	}
if (++count >= max && max != 0) /* Max 0 => no limit */	if (++count >= max && max != 0) /* Max 0 => no limit */
{ ADD_NEW(next_state_offset + 5, 0); }	{ ADD_NEW(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }
else	else
{ ADD_NEW(state_offset, count); }	{ ADD_NEW(state_offset, count); }
}	}
Line 2431 for (;;)	Line 2662 for (;;)
int rc;	int rc;
int local_offsets[2];	int local_offsets[2];
int local_workspace[1000];	int local_workspace[1000];
const uschar *endasscode = code + GET(code, 1);	const pcre_uchar *endasscode = code + GET(code, 1);

while (*endasscode == OP_ALT) endasscode += GET(endasscode, 1);	while (*endasscode == OP_ALT) endasscode += GET(endasscode, 1);

Line 2444 for (;;)	Line 2675 for (;;)
sizeof(local_offsets)/sizeof(int), /* size of same */	sizeof(local_offsets)/sizeof(int), /* size of same */
local_workspace, /* workspace vector */	local_workspace, /* workspace vector */
sizeof(local_workspace)/sizeof(int), /* size of same */	sizeof(local_workspace)/sizeof(int), /* size of same */
ims, /* the current ims flags */	rlevel); /* function recursion level */
rlevel, /* function recursion level */
recursing); /* pass on regex recursion */

if (rc == PCRE_ERROR_DFA_UITEM) return rc;	if (rc == PCRE_ERROR_DFA_UITEM) return rc;
if ((rc >= 0) == (codevalue == OP_ASSERT \|\| codevalue == OP_ASSERTBACK))	if ((rc >= 0) == (codevalue == OP_ASSERT \|\| codevalue == OP_ASSERTBACK))
Line 2470 for (;;)	Line 2699 for (;;)
if (code[LINK_SIZE+1] == OP_CALLOUT)	if (code[LINK_SIZE+1] == OP_CALLOUT)
{	{
rrc = 0;	rrc = 0;
if (pcre_callout != NULL)	if (PUBL(callout) != NULL)
{	{
pcre_callout_block cb;	PUBL(callout_block) cb;
cb.version = 1; /* Version 1 of the callout block */	cb.version = 1; /* Version 1 of the callout block */
cb.callout_number = code[LINK_SIZE+2];	cb.callout_number = code[LINK_SIZE+2];
cb.offset_vector = offsets;	cb.offset_vector = offsets;
	#if defined COMPILE_PCRE8
cb.subject = (PCRE_SPTR)start_subject;	cb.subject = (PCRE_SPTR)start_subject;
	#elif defined COMPILE_PCRE16
	cb.subject = (PCRE_SPTR16)start_subject;
	#elif defined COMPILE_PCRE32
	cb.subject = (PCRE_SPTR32)start_subject;
	#endif
cb.subject_length = (int)(end_subject - start_subject);	cb.subject_length = (int)(end_subject - start_subject);
cb.start_match = (int)(current_subject - start_subject);	cb.start_match = (int)(current_subject - start_subject);
cb.current_position = (int)(ptr - start_subject);	cb.current_position = (int)(ptr - start_subject);
Line 2485 for (;;)	Line 2720 for (;;)
cb.capture_top = 1;	cb.capture_top = 1;
cb.capture_last = -1;	cb.capture_last = -1;
cb.callout_data = md->callout_data;	cb.callout_data = md->callout_data;
if ((rrc = (pcre_callout)(&cb)) < 0) return rrc; / Abandon */	cb.mark = NULL; /* No (MARK) support /
	if ((rrc = (PUBL(callout))(&cb)) < 0) return rrc; / Abandon */
}	}
if (rrc > 0) break; /* Fail this thread */	if (rrc > 0) break; /* Fail this thread */
code += _pcre_OP_lengths[OP_CALLOUT]; /* Skip callout data */	code += PRIV(OP_lengths)[OP_CALLOUT]; /* Skip callout data */
}	}

condcode = code[LINK_SIZE+1];	condcode = code[LINK_SIZE+1];

/* Back reference conditions are not supported */	/* Back reference conditions and duplicate named recursion conditions
	are not supported */

if (condcode == OP_CREF \|\| condcode == OP_NCREF)	if (condcode == OP_CREF \|\| condcode == OP_DNCREF \|\|
	condcode == OP_DNRREF)
return PCRE_ERROR_DFA_UCOND;	return PCRE_ERROR_DFA_UCOND;

/* The DEFINE condition is always false */	/* The DEFINE condition is always false, and the assertion (?!) is
	converted to OP_FAIL. */

if (condcode == OP_DEF)	if (condcode == OP_DEF \|\| condcode == OP_FAIL)
{ ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }	{ ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }

/* The only supported version of OP_RREF is for the value RREF_ANY,	/* The only supported version of OP_RREF is for the value RREF_ANY,
which means "test if in any recursion". We can't test for specifically	which means "test if in any recursion". We can't test for specifically
recursed groups. */	recursed groups. */

else if (condcode == OP_RREF \|\| condcode == OP_NRREF)	else if (condcode == OP_RREF)
{	{
int value = GET2(code, LINK_SIZE+2);	int value = GET2(code, LINK_SIZE + 2);
if (value != RREF_ANY) return PCRE_ERROR_DFA_UCOND;	if (value != RREF_ANY) return PCRE_ERROR_DFA_UCOND;
if (recursing > 0)	if (md->recursive != NULL)
{ ADD_ACTIVE(state_offset + LINK_SIZE + 4, 0); }	{ ADD_ACTIVE(state_offset + LINK_SIZE + 2 + IMM2_SIZE, 0); }
else { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }	else { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
}	}

Line 2521 for (;;)	Line 2760 for (;;)
else	else
{	{
int rc;	int rc;
const uschar *asscode = code + LINK_SIZE + 1;	const pcre_uchar *asscode = code + LINK_SIZE + 1;
const uschar *endasscode = asscode + GET(asscode, 1);	const pcre_uchar *endasscode = asscode + GET(asscode, 1);

while (*endasscode == OP_ALT) endasscode += GET(endasscode, 1);	while (*endasscode == OP_ALT) endasscode += GET(endasscode, 1);

Line 2535 for (;;)	Line 2774 for (;;)
sizeof(local_offsets)/sizeof(int), /* size of same */	sizeof(local_offsets)/sizeof(int), /* size of same */
local_workspace, /* workspace vector */	local_workspace, /* workspace vector */
sizeof(local_workspace)/sizeof(int), /* size of same */	sizeof(local_workspace)/sizeof(int), /* size of same */
ims, /* the current ims flags */	rlevel); /* function recursion level */
rlevel, /* function recursion level */
recursing); /* pass on regex recursion */

if (rc == PCRE_ERROR_DFA_UITEM) return rc;	if (rc == PCRE_ERROR_DFA_UITEM) return rc;
if ((rc >= 0) ==	if ((rc >= 0) ==
Line 2552 for (;;)	Line 2789 for (;;)
/-----------------------------------------------------------------/	/-----------------------------------------------------------------/
case OP_RECURSE:	case OP_RECURSE:
{	{
	dfa_recursion_info *ri;
int local_offsets[1000];	int local_offsets[1000];
int local_workspace[1000];	int local_workspace[1000];
	const pcre_uchar *callpat = start_code + GET(code, 1);
	int recno = (callpat == md->start_code)? 0 :
	GET2(callpat, 1 + LINK_SIZE);
int rc;	int rc;

DPRINTF(("%.sStarting regex recursion %d\n", rlevel2-2, SP,	DPRINTF(("%.sStarting regex recursion\n", rlevel2-2, SP));
recursing + 1));
	/* Check for repeating a recursion without advancing the subject
	pointer. This should catch convoluted mutual recursions. (Some simple
	cases are caught at compile time.) */

	for (ri = md->recursive; ri != NULL; ri = ri->prevrec)
	if (recno == ri->group_num && ptr == ri->subject_position)
	return PCRE_ERROR_RECURSELOOP;

	/* Remember this recursion and where we started it so as to
	catch infinite loops. */

	new_recursive.group_num = recno;
	new_recursive.subject_position = ptr;
	new_recursive.prevrec = md->recursive;
	md->recursive = &new_recursive;

rc = internal_dfa_exec(	rc = internal_dfa_exec(
md, /* fixed match data */	md, /* fixed match data */
start_code + GET(code, 1), /* this subexpression's code */	callpat, /* this subexpression's code */
ptr, /* where we currently are */	ptr, /* where we currently are */
(int)(ptr - start_subject), /* start offset */	(int)(ptr - start_subject), /* start offset */
local_offsets, /* offset vector */	local_offsets, /* offset vector */
sizeof(local_offsets)/sizeof(int), /* size of same */	sizeof(local_offsets)/sizeof(int), /* size of same */
local_workspace, /* workspace vector */	local_workspace, /* workspace vector */
sizeof(local_workspace)/sizeof(int), /* size of same */	sizeof(local_workspace)/sizeof(int), /* size of same */
ims, /* the current ims flags */	rlevel); /* function recursion level */
rlevel, /* function recursion level */
recursing + 1); /* regex recurse level */	md->recursive = new_recursive.prevrec; /* Done this recursion */

DPRINTF(("%.sReturn from regex recursion %d: rc=%d\n", rlevel2-2, SP,	DPRINTF(("%.sReturn from regex recursion: rc=%d\n", rlevel2-2, SP,
recursing + 1, rc));	rc));

/* Ran out of internal offsets */	/* Ran out of internal offsets */

Line 2587 for (;;)	Line 2843 for (;;)
{	{
for (rc = rc*2 - 2; rc >= 0; rc -= 2)	for (rc = rc*2 - 2; rc >= 0; rc -= 2)
{	{
const uschar *p = start_subject + local_offsets[rc];
const uschar *pp = start_subject + local_offsets[rc+1];
int charcount = local_offsets[rc+1] - local_offsets[rc];	int charcount = local_offsets[rc+1] - local_offsets[rc];
while (p < pp) if ((*p++ & 0xc0) == 0x80) charcount--;	#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
	if (utf)
	{
	const pcre_uchar *p = start_subject + local_offsets[rc];
	const pcre_uchar *pp = start_subject + local_offsets[rc+1];
	while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;
	}
	#endif
if (charcount > 0)	if (charcount > 0)
{	{
ADD_NEW_DATA(-(state_offset + LINK_SIZE + 1), 0, (charcount - 1));	ADD_NEW_DATA(-(state_offset + LINK_SIZE + 1), 0, (charcount - 1));
Line 2606 for (;;)	Line 2867 for (;;)
break;	break;

/-----------------------------------------------------------------/	/-----------------------------------------------------------------/
	case OP_BRAPOS:
	case OP_SBRAPOS:
	case OP_CBRAPOS:
	case OP_SCBRAPOS:
	case OP_BRAPOSZERO:
	{
	int charcount, matched_count;
	const pcre_uchar *local_ptr = ptr;
	BOOL allow_zero;

	if (codevalue == OP_BRAPOSZERO)
	{
	allow_zero = TRUE;
	codevalue = (++code); / Codevalue will be one of above BRAs */
	}
	else allow_zero = FALSE;

	/* Loop to match the subpattern as many times as possible as if it were
	a complete pattern. */

	for (matched_count = 0;; matched_count++)
	{
	int local_offsets[2];
	int local_workspace[1000];

	int rc = internal_dfa_exec(
	md, /* fixed match data */
	code, /* this subexpression's code */
	local_ptr, /* where we currently are */
	(int)(ptr - start_subject), /* start offset */
	local_offsets, /* offset vector */
	sizeof(local_offsets)/sizeof(int), /* size of same */
	local_workspace, /* workspace vector */
	sizeof(local_workspace)/sizeof(int), /* size of same */
	rlevel); /* function recursion level */

	/* Failed to match */

	if (rc < 0)
	{
	if (rc != PCRE_ERROR_NOMATCH) return rc;
	break;
	}

	/* Matched: break the loop if zero characters matched. */

	charcount = local_offsets[1] - local_offsets[0];
	if (charcount == 0) break;
	local_ptr += charcount; /* Advance temporary position ptr */
	}

	/* At this point we have matched the subpattern matched_count
	times, and local_ptr is pointing to the character after the end of the
	last match. */

	if (matched_count > 0 \|\| allow_zero)
	{
	const pcre_uchar *end_subpattern = code;
	int next_state_offset;

	do { end_subpattern += GET(end_subpattern, 1); }
	while (*end_subpattern == OP_ALT);
	next_state_offset =
	(int)(end_subpattern - start_code + LINK_SIZE + 1);

	/* Optimization: if there are no more active states, and there
	are no new states yet set up, then skip over the subject string
	right here, to save looping. Otherwise, set up the new state to swing
	into action when the end of the matched substring is reached. */

	if (i + 1 >= active_count && new_count == 0)
	{
	ptr = local_ptr;
	clen = 0;
	ADD_NEW(next_state_offset, 0);
	}
	else
	{
	const pcre_uchar *p = ptr;
	const pcre_uchar *pp = local_ptr;
	charcount = (int)(pp - p);
	#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
	if (utf) while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;
	#endif
	ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));
	}
	}
	}
	break;

	/-----------------------------------------------------------------/
case OP_ONCE:	case OP_ONCE:
	case OP_ONCE_NC:
{	{
int local_offsets[2];	int local_offsets[2];
int local_workspace[1000];	int local_workspace[1000];
Line 2620 for (;;)	Line 2973 for (;;)
sizeof(local_offsets)/sizeof(int), /* size of same */	sizeof(local_offsets)/sizeof(int), /* size of same */
local_workspace, /* workspace vector */	local_workspace, /* workspace vector */
sizeof(local_workspace)/sizeof(int), /* size of same */	sizeof(local_workspace)/sizeof(int), /* size of same */
ims, /* the current ims flags */	rlevel); /* function recursion level */
rlevel, /* function recursion level */
recursing); /* pass on regex recursion */

if (rc >= 0)	if (rc >= 0)
{	{
const uschar *end_subpattern = code;	const pcre_uchar *end_subpattern = code;
int charcount = local_offsets[1] - local_offsets[0];	int charcount = local_offsets[1] - local_offsets[0];
int next_state_offset, repeat_state_offset;	int next_state_offset, repeat_state_offset;

Line 2656 for (;;)	Line 3007 for (;;)
/* Optimization: if there are no more active states, and there	/* Optimization: if there are no more active states, and there
are no new states yet set up, then skip over the subject string	are no new states yet set up, then skip over the subject string
right here, to save looping. Otherwise, set up the new state to swing	right here, to save looping. Otherwise, set up the new state to swing
into action when the end of the substring is reached. */	into action when the end of the matched substring is reached. */

else if (i + 1 >= active_count && new_count == 0)	else if (i + 1 >= active_count && new_count == 0)
{	{
Line 2679 for (;;)	Line 3030 for (;;)
}	}
else	else
{	{
const uschar *p = start_subject + local_offsets[0];	#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
const uschar *pp = start_subject + local_offsets[1];	if (utf)
while (p < pp) if ((*p++ & 0xc0) == 0x80) charcount--;	{
	const pcre_uchar *p = start_subject + local_offsets[0];
	const pcre_uchar *pp = start_subject + local_offsets[1];
	while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;
	}
	#endif
ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));	ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));
if (repeat_state_offset >= 0)	if (repeat_state_offset >= 0)
{ ADD_NEW_DATA(-repeat_state_offset, 0, (charcount - 1)); }	{ ADD_NEW_DATA(-repeat_state_offset, 0, (charcount - 1)); }
}	}

}	}
else if (rc != PCRE_ERROR_NOMATCH) return rc;	else if (rc != PCRE_ERROR_NOMATCH) return rc;
}	}
Line 2698 for (;;)	Line 3053 for (;;)

case OP_CALLOUT:	case OP_CALLOUT:
rrc = 0;	rrc = 0;
if (pcre_callout != NULL)	if (PUBL(callout) != NULL)
{	{
pcre_callout_block cb;	PUBL(callout_block) cb;
cb.version = 1; /* Version 1 of the callout block */	cb.version = 1; /* Version 1 of the callout block */
cb.callout_number = code[1];	cb.callout_number = code[1];
cb.offset_vector = offsets;	cb.offset_vector = offsets;
	#if defined COMPILE_PCRE8
cb.subject = (PCRE_SPTR)start_subject;	cb.subject = (PCRE_SPTR)start_subject;
	#elif defined COMPILE_PCRE16
	cb.subject = (PCRE_SPTR16)start_subject;
	#elif defined COMPILE_PCRE32
	cb.subject = (PCRE_SPTR32)start_subject;
	#endif
cb.subject_length = (int)(end_subject - start_subject);	cb.subject_length = (int)(end_subject - start_subject);
cb.start_match = (int)(current_subject - start_subject);	cb.start_match = (int)(current_subject - start_subject);
cb.current_position = (int)(ptr - start_subject);	cb.current_position = (int)(ptr - start_subject);
Line 2713 for (;;)	Line 3074 for (;;)
cb.capture_top = 1;	cb.capture_top = 1;
cb.capture_last = -1;	cb.capture_last = -1;
cb.callout_data = md->callout_data;	cb.callout_data = md->callout_data;
if ((rrc = (pcre_callout)(&cb)) < 0) return rrc; / Abandon */	cb.mark = NULL; /* No (MARK) support /
	if ((rrc = (PUBL(callout))(&cb)) < 0) return rrc; / Abandon */
}	}
if (rrc == 0)	if (rrc == 0)
{ ADD_ACTIVE(state_offset + _pcre_OP_lengths[OP_CALLOUT], 0); }	{ ADD_ACTIVE(state_offset + PRIV(OP_lengths)[OP_CALLOUT], 0); }
break;	break;


Line 2745 for (;;)	Line 3107 for (;;)
if (new_count <= 0)	if (new_count <= 0)
{	{
if (rlevel == 1 && /* Top level, and */	if (rlevel == 1 && /* Top level, and */
could_continue && /* Some could go on */	could_continue && /* Some could go on, and */
forced_fail != workspace[1] && /* Not all forced fail & */	forced_fail != workspace[1] && /* Not all forced fail & */
( /* either... */	( /* either... */
(md->moptions & PCRE_PARTIAL_HARD) != 0 /* Hard partial */	(md->moptions & PCRE_PARTIAL_HARD) != 0 /* Hard partial */
Line 2753 for (;;)	Line 3115 for (;;)
((md->moptions & PCRE_PARTIAL_SOFT) != 0 && /* Soft partial and */	((md->moptions & PCRE_PARTIAL_SOFT) != 0 && /* Soft partial and */
match_count < 0) /* no matches */	match_count < 0) /* no matches */
) && /* And... */	) && /* And... */
ptr >= end_subject && /* Reached end of subject */	(
ptr > md->start_used_ptr) /* Inspected non-empty string */	partial_newline \|\| /* Either partial NL */
{	( /* or ... */
if (offsetcount >= 2)	ptr >= end_subject && /* End of subject and */
{	ptr > md->start_used_ptr) /* Inspected non-empty string */
offsets[0] = (int)(md->start_used_ptr - start_subject);	)
offsets[1] = (int)(end_subject - start_subject);	)
}
match_count = PCRE_ERROR_PARTIAL;	match_count = PCRE_ERROR_PARTIAL;
}

DPRINTF(("%.*sEnd of internal_dfa_exec %d: returning %d\n"	DPRINTF(("%.*sEnd of internal_dfa_exec %d: returning %d\n"
"%.s---------------------\n\n", rlevel2-2, SP, rlevel, match_count,	"%.s---------------------\n\n", rlevel2-2, SP, rlevel, match_count,
rlevel*2-2, SP));	rlevel*2-2, SP));
Line 2813 Returns: > 0 => number of match	Line 3172 Returns: > 0 => number of match
< -1 => some kind of unexpected problem	< -1 => some kind of unexpected problem
*/	*/

	#if defined COMPILE_PCRE8
PCRE_EXP_DEFN int PCRE_CALL_CONVENTION	PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
pcre_dfa_exec(const pcre argument_re, const pcre_extra extra_data,	pcre_dfa_exec(const pcre argument_re, const pcre_extra extra_data,
const char subject, int length, int start_offset, int options, int offsets,	const char subject, int length, int start_offset, int options, int offsets,
int offsetcount, int *workspace, int wscount)	int offsetcount, int *workspace, int wscount)
	#elif defined COMPILE_PCRE16
	PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
	pcre16_dfa_exec(const pcre16 argument_re, const pcre16_extra extra_data,
	PCRE_SPTR16 subject, int length, int start_offset, int options, int *offsets,
	int offsetcount, int *workspace, int wscount)
	#elif defined COMPILE_PCRE32
	PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
	pcre32_dfa_exec(const pcre32 argument_re, const pcre32_extra extra_data,
	PCRE_SPTR32 subject, int length, int start_offset, int options, int *offsets,
	int offsetcount, int *workspace, int wscount)
	#endif
{	{
real_pcre re = (real_pcre )argument_re;	REAL_PCRE re = (REAL_PCRE )argument_re;
dfa_match_data match_block;	dfa_match_data match_block;
dfa_match_data *md = &match_block;	dfa_match_data *md = &match_block;
BOOL utf8, anchored, startline, firstline;	BOOL utf, anchored, startline, firstline;
const uschar current_subject, end_subject, *lcc;	const pcre_uchar current_subject, end_subject;

pcre_study_data internal_study;
const pcre_study_data *study = NULL;	const pcre_study_data *study = NULL;
real_pcre internal_re;

const uschar *req_byte_ptr;	const pcre_uchar *req_char_ptr;
const uschar *start_bits = NULL;	const pcre_uint8 *start_bits = NULL;
BOOL first_byte_caseless = FALSE;	BOOL has_first_char = FALSE;
BOOL req_byte_caseless = FALSE;	BOOL has_req_char = FALSE;
int first_byte = -1;	pcre_uchar first_char = 0;
int req_byte = -1;	pcre_uchar first_char2 = 0;
int req_byte2 = -1;	pcre_uchar req_char = 0;
	pcre_uchar req_char2 = 0;
int newline;	int newline;

/* Plausibility checks */	/* Plausibility checks */
Line 2844 if (re == NULL \|\| subject == NULL \|\| wor	Line 3213 if (re == NULL \|\| subject == NULL \|\| wor
(offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;	(offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;	if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
if (wscount < 20) return PCRE_ERROR_DFA_WSSIZE;	if (wscount < 20) return PCRE_ERROR_DFA_WSSIZE;
	if (length < 0) return PCRE_ERROR_BADLENGTH;
if (start_offset < 0 \|\| start_offset > length) return PCRE_ERROR_BADOFFSET;	if (start_offset < 0 \|\| start_offset > length) return PCRE_ERROR_BADOFFSET;

/* We need to find the pointer to any study data before we test for byte	/* Check that the first field in the block is the magic number. If it is not,
flipping, so we scan the extra_data block first. This may set two fields in the	return with PCRE_ERROR_BADMAGIC. However, if the magic number is equal to
match block, so we must initialize them beforehand. However, the other fields	REVERSED_MAGIC_NUMBER we return with PCRE_ERROR_BADENDIANNESS, which
in the match block must not be set until after the byte flipping. */	means that the pattern is likely compiled with different endianness. */

	if (re->magic_number != MAGIC_NUMBER)
	return re->magic_number == REVERSED_MAGIC_NUMBER?
	PCRE_ERROR_BADENDIANNESS:PCRE_ERROR_BADMAGIC;
	if ((re->flags & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;

	/* If restarting after a partial match, do some sanity checks on the contents
	of the workspace. */

	if ((options & PCRE_DFA_RESTART) != 0)
	{
	if ((workspace[0] & (-2)) != 0 \|\| workspace[1] < 1 \|\|
	workspace[1] > (wscount - 2)/INTS_PER_STATEBLOCK)
	return PCRE_ERROR_DFA_BADRESTART;
	}

	/* Set up study, callout, and table data */

md->tables = re->tables;	md->tables = re->tables;
md->callout_data = NULL;	md->callout_data = NULL;

if (extra_data != NULL)	if (extra_data != NULL)
{	{
unsigned int flags = extra_data->flags;	unsigned long int flags = extra_data->flags;
if ((flags & PCRE_EXTRA_STUDY_DATA) != 0)	if ((flags & PCRE_EXTRA_STUDY_DATA) != 0)
study = (const pcre_study_data *)extra_data->study_data;	study = (const pcre_study_data *)extra_data->study_data;
if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0) return PCRE_ERROR_DFA_UMLIMIT;	if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0) return PCRE_ERROR_DFA_UMLIMIT;
Line 2868 if (extra_data != NULL)	Line 3255 if (extra_data != NULL)
md->tables = extra_data->tables;	md->tables = extra_data->tables;
}	}

/* Check that the first field in the block is the magic number. If it is not,
test for a regex that was compiled on a host of opposite endianness. If this is
the case, flipped values are put in internal_re and internal_study if there was
study data too. */

if (re->magic_number != MAGIC_NUMBER)
{
re = _pcre_try_flipped(re, &internal_re, study, &internal_study);
if (re == NULL) return PCRE_ERROR_BADMAGIC;
if (study != NULL) study = &internal_study;
}

/* Set some local values */	/* Set some local values */

current_subject = (const unsigned char *)subject + start_offset;	current_subject = (const pcre_uchar *)subject + start_offset;
end_subject = (const unsigned char *)subject + length;	end_subject = (const pcre_uchar *)subject + length;
req_byte_ptr = current_subject - 1;	req_char_ptr = current_subject - 1;

#ifdef SUPPORT_UTF8	#ifdef SUPPORT_UTF
utf8 = (re->options & PCRE_UTF8) != 0;	/* PCRE_UTF(16\|32) have the same value as PCRE_UTF8. */
	utf = (re->options & PCRE_UTF8) != 0;
#else	#else
utf8 = FALSE;	utf = FALSE;
#endif	#endif

anchored = (options & (PCRE_ANCHORED\|PCRE_DFA_RESTART)) != 0 \|\|	anchored = (options & (PCRE_ANCHORED\|PCRE_DFA_RESTART)) != 0 \|\|
Line 2897 anchored = (options & (PCRE_ANCHORED\|PCR	Line 3273 anchored = (options & (PCRE_ANCHORED\|PCR

/* The remaining fixed data for passing around. */	/* The remaining fixed data for passing around. */

md->start_code = (const uschar *)argument_re +	md->start_code = (const pcre_uchar *)argument_re +
re->name_table_offset + re->name_count * re->name_entry_size;	re->name_table_offset + re->name_count * re->name_entry_size;
md->start_subject = (const unsigned char *)subject;	md->start_subject = (const pcre_uchar *)subject;
md->end_subject = end_subject;	md->end_subject = end_subject;
md->start_offset = start_offset;	md->start_offset = start_offset;
md->moptions = options;	md->moptions = options;
Line 2960 else	Line 3336 else
/* Check a UTF-8 string if required. Unfortunately there's no way of passing	/* Check a UTF-8 string if required. Unfortunately there's no way of passing
back the character offset. */	back the character offset. */

#ifdef SUPPORT_UTF8	#ifdef SUPPORT_UTF
if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)	if (utf && (options & PCRE_NO_UTF8_CHECK) == 0)
{	{
int tb;	int erroroffset;
if ((tb = _pcre_valid_utf8((uschar *)subject, length)) >= 0)	int errorcode = PRIV(valid_utf)((pcre_uchar *)subject, length, &erroroffset);
return (tb == length && (options & PCRE_PARTIAL_HARD) != 0)?	if (errorcode != 0)
PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
if (start_offset > 0 && start_offset < length)
{	{
tb = ((USPTR)subject)[start_offset] & 0xc0;	if (offsetcount >= 2)
if (tb == 0x80) return PCRE_ERROR_BADUTF8_OFFSET;	{
	offsets[0] = erroroffset;
	offsets[1] = errorcode;
	}
	#if defined COMPILE_PCRE8
	return (errorcode <= PCRE_UTF8_ERR5 && (options & PCRE_PARTIAL_HARD) != 0) ?
	PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
	#elif defined COMPILE_PCRE16
	return (errorcode <= PCRE_UTF16_ERR1 && (options & PCRE_PARTIAL_HARD) != 0) ?
	PCRE_ERROR_SHORTUTF16 : PCRE_ERROR_BADUTF16;
	#elif defined COMPILE_PCRE32
	return PCRE_ERROR_BADUTF32;
	#endif
}	}
	#if defined COMPILE_PCRE8 \|\| defined COMPILE_PCRE16
	if (start_offset > 0 && start_offset < length &&
	NOT_FIRSTCHAR(((PCRE_PUCHAR)subject)[start_offset]))
	return PCRE_ERROR_BADUTF8_OFFSET;
	#endif
}	}
#endif	#endif

Line 2979 if (utf8 && (options & PCRE_NO_UTF8_CHEC	Line 3370 if (utf8 && (options & PCRE_NO_UTF8_CHEC
is a feature that makes it possible to save compiled regex and re-use them	is a feature that makes it possible to save compiled regex and re-use them
in other programs later. */	in other programs later. */

if (md->tables == NULL) md->tables = _pcre_default_tables;	if (md->tables == NULL) md->tables = PRIV(default_tables);

/* The lower casing table and the "must be at the start of a line" flag are	/* The "must be at the start of a line" flags are used in a loop when finding
used in a loop when finding where to start. */	where to start. */

lcc = md->tables + lcc_offset;
startline = (re->flags & PCRE_STARTLINE) != 0;	startline = (re->flags & PCRE_STARTLINE) != 0;
firstline = (re->options & PCRE_FIRSTLINE) != 0;	firstline = (re->options & PCRE_FIRSTLINE) != 0;

Line 2998 if (!anchored)	Line 3388 if (!anchored)
{	{
if ((re->flags & PCRE_FIRSTSET) != 0)	if ((re->flags & PCRE_FIRSTSET) != 0)
{	{
first_byte = re->first_byte & 255;	has_first_char = TRUE;
if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)	first_char = first_char2 = (pcre_uchar)(re->first_char);
first_byte = lcc[first_byte];	if ((re->flags & PCRE_FCH_CASELESS) != 0)
	{
	first_char2 = TABLE_GET(first_char, md->tables + fcc_offset, first_char);
	#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
	if (utf && first_char > 127)
	first_char2 = UCD_OTHERCASE(first_char);
	#endif
	}
}	}
else	else
{	{
Line 3015 character" set. */	Line 3412 character" set. */

if ((re->flags & PCRE_REQCHSET) != 0)	if ((re->flags & PCRE_REQCHSET) != 0)
{	{
req_byte = re->req_byte & 255;	has_req_char = TRUE;
req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;	req_char = req_char2 = (pcre_uchar)(re->req_char);
req_byte2 = (md->tables + fcc_offset)[req_byte]; /* case flipped */	if ((re->flags & PCRE_RCH_CASELESS) != 0)
	{
	req_char2 = TABLE_GET(req_char, md->tables + fcc_offset, req_char);
	#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
	if (utf && req_char > 127)
	req_char2 = UCD_OTHERCASE(req_char);
	#endif
	}
}	}

/* Call the main matching function, looping for a non-anchored regex after a	/* Call the main matching function, looping for a non-anchored regex after a
Line 3030 for (;;)	Line 3434 for (;;)

if ((options & PCRE_DFA_RESTART) == 0)	if ((options & PCRE_DFA_RESTART) == 0)
{	{
const uschar *save_end_subject = end_subject;	const pcre_uchar *save_end_subject = end_subject;

/* If firstline is TRUE, the start of the match is constrained to the first	/* If firstline is TRUE, the start of the match is constrained to the first
line of a multiline string. Implement this by temporarily adjusting	line of a multiline string. Implement this by temporarily adjusting
Line 3039 for (;;)	Line 3443 for (;;)

if (firstline)	if (firstline)
{	{
USPTR t = current_subject;	PCRE_PUCHAR t = current_subject;
#ifdef SUPPORT_UTF8	#ifdef SUPPORT_UTF
if (utf8)	if (utf)
{	{
while (t < md->end_subject && !IS_NEWLINE(t))	while (t < md->end_subject && !IS_NEWLINE(t))
{	{
t++;	t++;
while (t < end_subject && (*t & 0xc0) == 0x80) t++;	ACROSSCHAR(t < end_subject, *t, t++);
}	}
}	}
else	else
Line 3063 for (;;)	Line 3467 for (;;)

if (((options \| re->options) & PCRE_NO_START_OPTIMIZE) == 0)	if (((options \| re->options) & PCRE_NO_START_OPTIMIZE) == 0)
{	{
/* Advance to a known first byte. */	/* Advance to a known first pcre_uchar (i.e. data item) */

if (first_byte >= 0)	if (has_first_char)
{	{
if (first_byte_caseless)	if (first_char != first_char2)
	{
	pcre_uchar csc;
while (current_subject < end_subject &&	while (current_subject < end_subject &&
lcc[*current_subject] != first_byte)	(csc = UCHAR21TEST(current_subject)) != first_char && csc != first_char2)
current_subject++;	current_subject++;
	}
else	else
while (current_subject < end_subject &&	while (current_subject < end_subject &&
*current_subject != first_byte)	UCHAR21TEST(current_subject) != first_char)
current_subject++;	current_subject++;
}	}

Line 3083 for (;;)	Line 3490 for (;;)
{	{
if (current_subject > md->start_subject + start_offset)	if (current_subject > md->start_subject + start_offset)
{	{
#ifdef SUPPORT_UTF8	#ifdef SUPPORT_UTF
if (utf8)	if (utf)
{	{
while (current_subject < end_subject &&	while (current_subject < end_subject &&
!WAS_NEWLINE(current_subject))	!WAS_NEWLINE(current_subject))
{	{
current_subject++;	current_subject++;
while(current_subject < end_subject &&	ACROSSCHAR(current_subject < end_subject, *current_subject,
(*current_subject & 0xc0) == 0x80)	current_subject++);
current_subject++;
}	}
}	}
else	else
Line 3104 for (;;)	Line 3510 for (;;)
ANYCRLF, and we are now at a LF, advance the match position by one	ANYCRLF, and we are now at a LF, advance the match position by one
more character. */	more character. */

if (current_subject[-1] == CHAR_CR &&	if (UCHAR21TEST(current_subject - 1) == CHAR_CR &&
(md->nltype == NLTYPE_ANY \|\| md->nltype == NLTYPE_ANYCRLF) &&	(md->nltype == NLTYPE_ANY \|\| md->nltype == NLTYPE_ANYCRLF) &&
current_subject < end_subject &&	current_subject < end_subject &&
*current_subject == CHAR_NL)	UCHAR21TEST(current_subject) == CHAR_NL)
current_subject++;	current_subject++;
}	}
}	}

/* Or to a non-unique first char after study */	/* Advance to a non-unique first pcre_uchar after study */

else if (start_bits != NULL)	else if (start_bits != NULL)
{	{
while (current_subject < end_subject)	while (current_subject < end_subject)
{	{
register unsigned int c = *current_subject;	register pcre_uint32 c = UCHAR21TEST(current_subject);
if ((start_bits[c/8] & (1 << (c&7))) == 0)	#ifndef COMPILE_PCRE8
{	if (c > 255) c = 255;
current_subject++;
#ifdef SUPPORT_UTF8
if (utf8)
while(current_subject < end_subject &&
(*current_subject & 0xc0) == 0x80) current_subject++;
#endif	#endif
}	if ((start_bits[c/8] & (1 << (c&7))) != 0) break;
else break;	current_subject++;
}	}
}	}
}	}
Line 3141 for (;;)	Line 3542 for (;;)
disabling is explicitly requested (and of course, by the test above, this	disabling is explicitly requested (and of course, by the test above, this
code is not obeyed when restarting after a partial match). */	code is not obeyed when restarting after a partial match). */

if ((options & PCRE_NO_START_OPTIMIZE) == 0 &&	if (((options \| re->options) & PCRE_NO_START_OPTIMIZE) == 0 &&
(options & (PCRE_PARTIAL_HARD\|PCRE_PARTIAL_SOFT)) == 0)	(options & (PCRE_PARTIAL_HARD\|PCRE_PARTIAL_SOFT)) == 0)
{	{
/* If the pattern was studied, a minimum subject length may be set. This	/* If the pattern was studied, a minimum subject length may be set. This
is a lower bound; no actual string of that length may actually match the	is a lower bound; no actual string of that length may actually match the
pattern. Although the value is, strictly, in characters, we treat it as	pattern. Although the value is, strictly, in characters, we treat it as
bytes to avoid spending too much time in this optimization. */	in pcre_uchar units to avoid spending too much time in this optimization.
	*/

if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&	if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
(pcre_uint32)(end_subject - current_subject) < study->minlength)	(pcre_uint32)(end_subject - current_subject) < study->minlength)
return PCRE_ERROR_NOMATCH;	return PCRE_ERROR_NOMATCH;

/* If req_byte is set, we know that that character must appear in the	/* If req_char is set, we know that that pcre_uchar must appear in the
subject for the match to succeed. If the first character is set, req_byte	subject for the match to succeed. If the first pcre_uchar is set,
must be later in the subject; otherwise the test starts at the match	req_char must be later in the subject; otherwise the test starts at the
point. This optimization can save a huge amount of work in patterns with	match point. This optimization can save a huge amount of work in patterns
nested unlimited repeats that aren't going to match. Writing separate	with nested unlimited repeats that aren't going to match. Writing
code for cased/caseless versions makes it go faster, as does using an	separate code for cased/caseless versions makes it go faster, as does
autoincrement and backing off on a match.	using an autoincrement and backing off on a match.

HOWEVER: when the subject string is very, very long, searching to its end	HOWEVER: when the subject string is very, very long, searching to its end
can take a long time, and give bad performance on quite ordinary	can take a long time, and give bad performance on quite ordinary
patterns. This showed up when somebody was matching /^C/ on a 32-megabyte	patterns. This showed up when somebody was matching /^C/ on a 32-megabyte
string... so we don't do this when the string is sufficiently long. */	string... so we don't do this when the string is sufficiently long. */

if (req_byte >= 0 && end_subject - current_subject < REQ_BYTE_MAX)	if (has_req_char && end_subject - current_subject < REQ_BYTE_MAX)
{	{
register const uschar *p = current_subject + ((first_byte >= 0)? 1 : 0);	register PCRE_PUCHAR p = current_subject + (has_first_char? 1:0);

/* We don't need to repeat the search if we haven't yet reached the	/* We don't need to repeat the search if we haven't yet reached the
place we found it at last time. */	place we found it at last time. */

if (p > req_byte_ptr)	if (p > req_char_ptr)
{	{
if (req_byte_caseless)	if (req_char != req_char2)
{	{
while (p < end_subject)	while (p < end_subject)
{	{
register int pp = *p++;	register pcre_uint32 pp = UCHAR21INCTEST(p);
if (pp == req_byte \|\| pp == req_byte2) { p--; break; }	if (pp == req_char \|\| pp == req_char2) { p--; break; }
}	}
}	}
else	else
{	{
while (p < end_subject)	while (p < end_subject)
{	{
if (*p++ == req_byte) { p--; break; }	if (UCHAR21INCTEST(p) == req_char) { p--; break; }
}	}
}	}

/* If we can't find the required character, break the matching loop,	/* If we can't find the required pcre_uchar, break the matching loop,
which will cause a return or PCRE_ERROR_NOMATCH. */	which will cause a return or PCRE_ERROR_NOMATCH. */

if (p >= end_subject) break;	if (p >= end_subject) break;

/* If we have found the required character, save the point where we	/* If we have found the required pcre_uchar, save the point where we
found it, so that we don't search again next time round the loop if	found it, so that we don't search again next time round the loop if
the start hasn't passed this character yet. */	the start hasn't passed this point yet. */

req_byte_ptr = p;	req_char_ptr = p;
}	}
}	}
}	}
Line 3209 for (;;)	Line 3611 for (;;)
/* OK, now we can do the business */	/* OK, now we can do the business */

md->start_used_ptr = current_subject;	md->start_used_ptr = current_subject;
	md->recursive = NULL;

rc = internal_dfa_exec(	rc = internal_dfa_exec(
md, /* fixed match data */	md, /* fixed match data */
Line 3219 for (;;)	Line 3622 for (;;)
offsetcount, /* size of same */	offsetcount, /* size of same */
workspace, /* workspace vector */	workspace, /* workspace vector */
wscount, /* size of same */	wscount, /* size of same */
re->options & (PCRE_CASELESS\|PCRE_MULTILINE\|PCRE_DOTALL), /* ims flags */	0); /* function recurse level */
0, /* function recurse level */
0); /* regex recurse level */

/* Anything other than "no match" means we are done, always; otherwise, carry	/* Anything other than "no match" means we are done, always; otherwise, carry
on only if not anchored. */	on only if not anchored. */

if (rc != PCRE_ERROR_NOMATCH \|\| anchored) return rc;	if (rc != PCRE_ERROR_NOMATCH \|\| anchored)
	{
	if (rc == PCRE_ERROR_PARTIAL && offsetcount >= 2)
	{
	offsets[0] = (int)(md->start_used_ptr - (PCRE_PUCHAR)subject);
	offsets[1] = (int)(end_subject - (PCRE_PUCHAR)subject);
	if (offsetcount > 2)
	offsets[2] = (int)(current_subject - (PCRE_PUCHAR)subject);
	}
	return rc;
	}

/* Advance to the next subject character unless we are at the end of a line	/* Advance to the next subject character unless we are at the end of a line
and firstline is set. */	and firstline is set. */

if (firstline && IS_NEWLINE(current_subject)) break;	if (firstline && IS_NEWLINE(current_subject)) break;
current_subject++;	current_subject++;
if (utf8)	#ifdef SUPPORT_UTF
	if (utf)
{	{
while (current_subject < end_subject && (*current_subject & 0xc0) == 0x80)	ACROSSCHAR(current_subject < end_subject, *current_subject,
current_subject++;	current_subject++);
}	}
	#endif
if (current_subject > end_subject) break;	if (current_subject > end_subject) break;

/* If we have just passed a CR and we are now at a LF, and the pattern does	/* If we have just passed a CR and we are now at a LF, and the pattern does
not contain any explicit matches for \r or \n, and the newline option is CRLF	not contain any explicit matches for \r or \n, and the newline option is CRLF
or ANY or ANYCRLF, advance the match position by one more character. */	or ANY or ANYCRLF, advance the match position by one more character. */

if (current_subject[-1] == CHAR_CR &&	if (UCHAR21TEST(current_subject - 1) == CHAR_CR &&
current_subject < end_subject &&	current_subject < end_subject &&
*current_subject == CHAR_NL &&	UCHAR21TEST(current_subject) == CHAR_NL &&
(re->flags & PCRE_HASCRORLF) == 0 &&	(re->flags & PCRE_HASCRORLF) == 0 &&
(md->nltype == NLTYPE_ANY \|\|	(md->nltype == NLTYPE_ANY \|\|
md->nltype == NLTYPE_ANYCRLF \|\|	md->nltype == NLTYPE_ANYCRLF \|\|

E-mail:

Removed from v.1.5
changed lines
	Added in v.1.8