/*************************************************

* Perl-Compatible Regular Expressions *

*************************************************/

/* DO NOT EDIT THIS FILE! */

/* This file is automatically written by the merge-files.py script

included with the PCRE distribution for Python; it's produced from

several C files, and code is removed in the process. If you want to

modify the code or track down bugs, it will be much easier to work

with the code in its original, multiple-file form. Don't edit this

file by hand, or submit patches to it.

The Python-specific PCRE distribution can be retrieved from

http://starship.skyport.net/crew/amk/regex/

The unmodified original PCRE distribution is available at

ftp://ftp.cus.cam.ac.uk/pub/software/programs/pcre/, and is originally

written by: Philip Hazel <[email protected]>

Extensively modified by the Python String-SIG: <[email protected]>

Send bug reports to: <[email protected]>

(They'll figure out if it's a bug in PCRE or in the Python-specific

changes.)

Copyright (c) 1997 University of Cambridge

-----------------------------------------------------------------------------

Permission is granted to anyone to use this software for any purpose on any

computer system, and to redistribute it freely, subject to the following

restrictions:

1. This software is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

2. The origin of this software must not be misrepresented, either by

explicit claim or by omission.

3. Altered versions must be plainly marked as such, and must not be

misrepresented as being the original software.

-----------------------------------------------------------------------------

*/

#define FOR_PYTHON

#include "pcre-int.h"

#include "Python.h"

#include "mymalloc.h"

#include <ctype.h>

#include "graminit.h"

/*************************************************

* Perl-Compatible Regular Expressions *

*************************************************/

/* This file is automatically written by the makechartables auxiliary

program. If you edit it by hand, you might like to edit the Makefile to

prevent its ever being regenerated. */

/* This table is a lower casing table. */

unsigned char pcre_lcc[] = {

0, 1, 2, 3, 4, 5, 6, 7,

8, 9, 10, 11, 12, 13, 14, 15,

16, 17, 18, 19, 20, 21, 22, 23,

24, 25, 26, 27, 28, 29, 30, 31,

32, 33, 34, 35, 36, 37, 38, 39,

40, 41, 42, 43, 44, 45, 46, 47,

48, 49, 50, 51, 52, 53, 54, 55,

56, 57, 58, 59, 60, 61, 62, 63,

64, 97, 98, 99,100,101,102,103,

104,105,106,107,108,109,110,111,

112,113,114,115,116,117,118,119,

120,121,122, 91, 92, 93, 94, 95,

96, 97, 98, 99,100,101,102,103,

104,105,106,107,108,109,110,111,

112,113,114,115,116,117,118,119,

120,121,122,123,124,125,126,127,

128,129,130,131,132,133,134,135,

136,137,138,139,140,141,142,143,

144,145,146,147,148,149,150,151,

152,153,154,155,156,157,158,159,

160,161,162,163,164,165,166,167,

168,169,170,171,172,173,174,175,

176,177,178,179,180,181,182,183,

184,185,186,187,188,189,190,191,

192,193,194,195,196,197,198,199,

200,201,202,203,204,205,206,207,

208,209,210,211,212,213,214,215,

216,217,218,219,220,221,222,223,

224,225,226,227,228,229,230,231,

232,233,234,235,236,237,238,239,

240,241,242,243,244,245,246,247,

248,249,250,251,252,253,254,255 };

/* This table is a case flipping table. */

unsigned char pcre_fcc[] = {

0, 1, 2, 3, 4, 5, 6, 7,

8, 9, 10, 11, 12, 13, 14, 15,

16, 17, 18, 19, 20, 21, 22, 23,

24, 25, 26, 27, 28, 29, 30, 31,

32, 33, 34, 35, 36, 37, 38, 39,

40, 41, 42, 43, 44, 45, 46, 47,

48, 49, 50, 51, 52, 53, 54, 55,

56, 57, 58, 59, 60, 61, 62, 63,

64, 97, 98, 99,100,101,102,103,

104,105,106,107,108,109,110,111,

112,113,114,115,116,117,118,119,

120,121,122, 91, 92, 93, 94, 95,

96, 65, 66, 67, 68, 69, 70, 71,

72, 73, 74, 75, 76, 77, 78, 79,

80, 81, 82, 83, 84, 85, 86, 87,

88, 89, 90,123,124,125,126,127,

128,129,130,131,132,133,134,135,

136,137,138,139,140,141,142,143,

144,145,146,147,148,149,150,151,

152,153,154,155,156,157,158,159,

160,161,162,163,164,165,166,167,

168,169,170,171,172,173,174,175,

176,177,178,179,180,181,182,183,

184,185,186,187,188,189,190,191,

192,193,194,195,196,197,198,199,

200,201,202,203,204,205,206,207,

208,209,210,211,212,213,214,215,

216,217,218,219,220,221,222,223,

224,225,226,227,228,229,230,231,

232,233,234,235,236,237,238,239,

240,241,242,243,244,245,246,247,

248,249,250,251,252,253,254,255 };

/* This table contains bit maps for digits, letters, 'word' chars, and

white space. Each map is 32 bytes long and the bits run from the least

significant end of each byte. */

unsigned char pcre_cbits[] = {

0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

0xfe,0xff,0xff,0x07,0xfe,0xff,0xff,0x07,

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,

0xfe,0xff,0xff,0x87,0xfe,0xff,0xff,0x07,

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

0x00,0x3e,0x00,0x00,0x01,0x00,0x00,0x00,

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };

/* This table identifies various classes of character by individual bits:

0x01 white space character

0x02 letter

0x04 decimal digit

0x08 hexadecimal digit

0x10 alphanumeric or '_'

0x80 regular expression metacharacter or binary zero

*/

unsigned char pcre_ctypes[] = {

0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 */

0x00,0x01,0x01,0x01,0x01,0x01,0x00,0x00, /* 8- 15 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */

0x01,0x00,0x00,0x00,0x80,0x00,0x00,0x00, /* - ' */

0x80,0x80,0x80,0x80,0x00,0x00,0x80,0x00, /* ( - / */

0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c, /* 0 - 7 */

0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x80, /* 8 - ? */

0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* @ - G */

0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* H - O */

0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* P - W */

0x12,0x12,0x12,0x80,0x00,0x00,0x80,0x10, /* X - _ */

0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* ` - g */

0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* h - o */

0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* p - w */

0x12,0x12,0x12,0x80,0x80,0x00,0x00,0x00, /* x -127 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */

/* End of chartables.c */

/*************************************************

* Perl-Compatible Regular Expressions *

*************************************************/

/*

This is a library of functions to support regular expressions whose syntax

and semantics are as close as possible to those of the Perl 5 language. See

the file Tech.Notes for some information on the internals.

Written by: Philip Hazel <[email protected]>

Copyright (c) 1998 University of Cambridge

-----------------------------------------------------------------------------

Permission is granted to anyone to use this software for any purpose on any

computer system, and to redistribute it freely, subject to the following

restrictions:

1. This software is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

2. The origin of this software must not be misrepresented, either by

explicit claim or by omission.

3. Altered versions must be plainly marked as such, and must not be

misrepresented as being the original software.

-----------------------------------------------------------------------------

*/

/* Include the internals header, which itself includes Standard C headers plus

the external pcre header. */

/*************************************************

* Create bitmap of starting chars *

*************************************************/

/* This function scans a compiled unanchored expression and attempts to build a

bitmap of the set of initial characters. If it can't, it returns FALSE. As time

goes by, we may be able to get more clever at doing this.

Arguments:

code points to an expression

start_bits points to a 32-byte table, initialized to 0

Returns: TRUE if table built, FALSE otherwise

*/

static BOOL

set_start_bits(const uschar *code, uschar *start_bits)

{

register int c;

do

{

const uschar *tcode = code + 3;

BOOL try_next = TRUE;

while (try_next)

{

try_next = FALSE;

if ((int)*tcode >= OP_BRA || *tcode == OP_ASSERT)

{

if (!set_start_bits(tcode, start_bits)) return FALSE;

}

else switch(*tcode)

{

default:

return FALSE;

/* BRAZERO does the bracket, but carries on. */

case OP_BRAZERO:

case OP_BRAMINZERO:

if (!set_start_bits(++tcode, start_bits)) return FALSE;

do tcode += (tcode[1] << 8) + tcode[2]; while (*tcode == OP_ALT);

tcode += 3;

try_next = TRUE;

break;

/* Single-char * or ? sets the bit and tries the next item */

case OP_STAR:

case OP_MINSTAR:

case OP_QUERY:

case OP_MINQUERY:

start_bits[tcode[1]/8] |= (1 << (tcode[1]&7));

tcode += 2;

try_next = TRUE;

break;

/* Single-char upto sets the bit and tries the next */

case OP_UPTO:

case OP_MINUPTO:

start_bits[tcode[3]/8] |= (1 << (tcode[3]&7));

tcode += 4;

try_next = TRUE;

break;

/* At least one single char sets the bit and stops */

case OP_EXACT: /* Fall through */

tcode++;

case OP_CHARS: /* Fall through */

tcode++;

case OP_PLUS:

case OP_MINPLUS:

start_bits[tcode[1]/8] |= (1 << (tcode[1]&7));

break;

/* Single character type sets the bits and stops */

case OP_NOT_DIGIT:

for (c = 0; c < 32; c++) start_bits[c] |= ~pcre_cbits[c+cbit_digit];

break;

case OP_DIGIT:

for (c = 0; c < 32; c++) start_bits[c] |= pcre_cbits[c+cbit_digit];

break;

case OP_NOT_WHITESPACE:

for (c = 0; c < 32; c++) start_bits[c] |= ~pcre_cbits[c+cbit_space];

break;

case OP_WHITESPACE:

for (c = 0; c < 32; c++) start_bits[c] |= pcre_cbits[c+cbit_space];

break;

case OP_NOT_WORDCHAR:

for (c = 0; c < 32; c++)

start_bits[c] |= ~(pcre_cbits[c] | pcre_cbits[c+cbit_word]);

break;

case OP_WORDCHAR:

for (c = 0; c < 32; c++)

start_bits[c] |= (pcre_cbits[c] | pcre_cbits[c+cbit_word]);

break;

/* One or more character type fudges the pointer and restarts, knowing

it will hit a single character type and stop there. */

case OP_TYPEPLUS:

case OP_TYPEMINPLUS:

tcode++;

try_next = TRUE;

break;

case OP_TYPEEXACT:

tcode += 3;

try_next = TRUE;

break;

/* Zero or more repeats of character types set the bits and then

try again. */

case OP_TYPEUPTO:

case OP_TYPEMINUPTO:

tcode += 2; /* Fall through */

case OP_TYPESTAR:

case OP_TYPEMINSTAR:

case OP_TYPEQUERY:

case OP_TYPEMINQUERY:

switch(tcode[1])

{

case OP_NOT_DIGIT:

for (c = 0; c < 32; c++) start_bits[c] |= ~pcre_cbits[c+cbit_digit];

break;

case OP_DIGIT:

for (c = 0; c < 32; c++) start_bits[c] |= pcre_cbits[c+cbit_digit];

break;

case OP_NOT_WHITESPACE:

for (c = 0; c < 32; c++) start_bits[c] |= ~pcre_cbits[c+cbit_space];

break;

case OP_WHITESPACE:

for (c = 0; c < 32; c++) start_bits[c] |= pcre_cbits[c+cbit_space];

break;

case OP_NOT_WORDCHAR:

for (c = 0; c < 32; c++)

start_bits[c] |= ~(pcre_cbits[c] | pcre_cbits[c+cbit_word]);

break;

case OP_WORDCHAR:

for (c = 0; c < 32; c++)

start_bits[c] |= (pcre_cbits[c] | pcre_cbits[c+cbit_word]);

break;

}

tcode += 2;

try_next = TRUE;

break;

/* Character class: set the bits and either carry on or not,

according to the repeat count. */

case OP_CLASS:

case OP_NEGCLASS:

{

tcode++;

for (c = 0; c < 32; c++) start_bits[c] |= tcode[c];

tcode += 32;

switch (*tcode)

{

case OP_CRSTAR:

case OP_CRMINSTAR:

case OP_CRQUERY:

case OP_CRMINQUERY:

tcode++;

try_next = TRUE;

break;

case OP_CRRANGE:

case OP_CRMINRANGE:

if (((tcode[1] << 8) + tcode[2]) == 0)

{

tcode += 5;

try_next = TRUE;

}

break;

}

}

break; /* End of class handling */

} /* End of switch */

} /* End of try_next loop */

code += (code[1] << 8) + code[2]; /* Advance to next branch */

}

while (*code == OP_ALT);

return TRUE;

}

/*************************************************

* Study a compiled expression *

*************************************************/

/* This function is handed a compiled expression that it must study to produce

information that will speed up the matching. It returns a pcre_extra block

which then gets handed back to pcre_exec().

Arguments:

re points to the compiled expression

options contains option bits

errorptr points to where to place error messages;

set NULL unless error

Returns: pointer to a pcre_extra block,

NULL on error or if no optimization possible

*/

pcre_extra *

pcre_study(const pcre *external_re, int options, const char **errorptr)

{

BOOL caseless;

uschar start_bits[32];

real_pcre_extra *extra;

const real_pcre *re = (const real_pcre *)external_re;

*errorptr = NULL;

if (re == NULL || re->magic_number != MAGIC_NUMBER)

{

*errorptr = "argument is not a compiled regular expression";

return NULL;

}

if ((options & ~PUBLIC_STUDY_OPTIONS) != 0)

{

*errorptr = "unknown or incorrect option bit(s) set";

return NULL;

}

/* Caseless can either be from the compiled regex or from options. */

caseless = ((re->options | options) & PCRE_CASELESS) != 0;

/* For an anchored pattern, or an unchored pattern that has a first char, or a

multiline pattern that matches only at "line starts", no further processing at

present. */

if ((re->options & (PCRE_ANCHORED|PCRE_FIRSTSET|PCRE_STARTLINE)) != 0)

return NULL;

/* See if we can find a fixed set of initial characters for the pattern. */

memset(start_bits, 0, 32 * sizeof(uschar));

if (!set_start_bits(re->code, start_bits)) return NULL;

/* If this studying is caseless, scan the created bit map and duplicate the

bits for any letters. */

if (caseless)

{

register int c;

for (c = 0; c < 256; c++)

{

if ((start_bits[c/8] & (1 << (c&7))) != 0 &&

(pcre_ctypes[c] & ctype_letter) != 0)

{

int d = pcre_fcc[c];

start_bits[d/8] |= (1 << (d&7));

}

}

}

/* Get an "extra" block and put the information therein. */

extra = (real_pcre_extra *)(pcre_malloc)(sizeof(real_pcre_extra));

if (extra == NULL)

{

*errorptr = "failed to get memory";

return NULL;

}

extra->options = PCRE_STUDY_MAPPED | (caseless? PCRE_STUDY_CASELESS : 0);

memcpy(extra->start_bits, start_bits, sizeof(start_bits));

return (pcre_extra *)extra;

}

/* End of study.c */

/*************************************************

* Perl-Compatible Regular Expressions *

*************************************************/

/*

This is a library of functions to support regular expressions whose syntax

and semantics are as close as possible to those of the Perl 5 language. See

the file Tech.Notes for some information on the internals.

Written by: Philip Hazel <[email protected]>

Copyright (c) 1998 University of Cambridge

-----------------------------------------------------------------------------

Permission is granted to anyone to use this software for any purpose on any

computer system, and to redistribute it freely, subject to the following

restrictions:

1. This software is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

2. The origin of this software must not be misrepresented, either by

explicit claim or by omission.

3. Altered versions must be plainly marked as such, and must not be

misrepresented as being the original software.

-----------------------------------------------------------------------------

*/

/* Define DEBUG to get debugging output on stdout. */

/* #define DEBUG */

/* Use a macro for debugging printing, 'cause that eliminates the the use

of #ifdef inline, and there are *still* stupid compilers about that don't like

indented pre-processor statements. I suppose it's only been 10 years... */

#ifdef DEBUG

#define DPRINTF(p) printf p

#else

#define DPRINTF(p) /*nothing*/

#endif

/* Include the internals header, which itself includes Standard C headers plus

the external pcre header. */

#ifndef Py_eval_input

/* For Python 1.4, graminit.h has to be explicitly included */

#define Py_eval_input eval_input

#endif /* FOR_PYTHON */

/* Allow compilation as C++ source code, should anybody want to do that. */

#ifdef __cplusplus

#define class pcre_class

#endif

/* Min and max values for the common repeats; for the maxima, 0 => infinity */

static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };

static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };

/* Text forms of OP_ values and things, for debugging (not all used) */

#ifdef DEBUG

static const char *OP_names[] = {

"End", "\\A", "\\B", "\\b", "\\D", "\\d",

"\\S", "\\s", "\\W", "\\w", "Cut", "\\Z",

"localized \\B", "localized \\b", "localized \\W", "localized \\w",

"^", "$", "Any", "chars",

"not",

"*", "*?", "+", "+?", "?", "??", "{", "{", "{",

"*", "*?", "+", "+?", "?", "??", "{", "{", "{",

"*", "*?", "+", "+?", "?", "??", "{", "{", "{",

"*", "*?", "+", "+?", "?", "??", "{", "{",

"class", "negclass", "classL", "Ref",

"Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not", "Once",

"Brazero", "Braminzero", "Bra"

};

#endif

/* Table for handling escaped characters in the range '0'-'z'. Positive returns

are simple data values; negative values are for special things like \d and so

on. Zero means further processing is needed (for things like \x), or the escape

is invalid. */

static const short int escapes[] = {

0, 0, 0, 0, 0, 0, 0, 0, /* 0 - 7 */

0, 0, ':', ';', '<', '=', '>', '?', /* 8 - ? */

'@', -ESC_A, -ESC_B, 0, -ESC_D, 0, 0, 0, /* @ - G */

0, 0, 0, 0, 0, 0, 0, 0, /* H - O */

0, 0, 0, -ESC_S, 0, 0, 0, -ESC_W, /* P - W */

0, 0, -ESC_Z, '[', '\\', ']', '^', '_', /* X - _ */

'`', 7, -ESC_b, 0, -ESC_d, 0, '\f', 0, /* ` - g */

0, 0, 0, 0, 0, 0, '\n', 0, /* h - o */

0, 0, '\r', -ESC_s, '\t', 0, '\v', -ESC_w, /* p - w */

0, 0, 0 /* x - z */

};

/* Definition to allow mutual recursion */

static BOOL

compile_regex(int, int *, uschar **, const uschar **, const char **,

PyObject *);

/* Structure for passing "static" information around between the functions

doing the matching, so that they are thread-safe. */

typedef struct match_data {

int errorcode; /* As it says */

int *offset_vector; /* Offset vector */

int offset_end; /* One past the end */

BOOL offset_overflow; /* Set if too many extractions */

BOOL caseless; /* Case-independent flag */

BOOL runtime_caseless; /* Caseless forced at run time */

BOOL multiline; /* Multiline flag */

BOOL notbol; /* NOTBOL flag */

BOOL noteol; /* NOTEOL flag */

BOOL dotall; /* Dot matches any char */

BOOL endonly; /* Dollar not before final \n */

const uschar *start_subject; /* Start of the subject string */

const uschar *end_subject; /* End of the subject string */

jmp_buf fail_env; /* Environment for longjump() break out */

const uschar *end_match_ptr; /* Subject position at end match */

int end_offset_top; /* Highwater mark at end of match */

jmp_buf error_env; /* For longjmp() if an error occurs deep inside a

matching operation */

int length; /* Length of the allocated stacks */

int point; /* Point to add next item pushed onto stacks */

/* Pointers to the 6 stacks */

int *off_num, *offset_top, *r1, *r2;

const uschar **eptr, **ecode;

} match_data;

/*************************************************

* Global variables *

*************************************************/

/* PCRE is thread-clean and doesn't use any global variables in the normal

sense. However, it calls memory allocation and free functions via the two

indirections below, which are can be changed by the caller, but are shared

between all threads. */

void *(*pcre_malloc)(size_t) = malloc;

void (*pcre_free)(void *) = free;

/*************************************************

* Return version string *

*************************************************/

const char *

pcre_version(void)

{

return PCRE_VERSION;

}

/*************************************************

* Return info about a compiled pattern *

*************************************************/

/* This function picks potentially useful data out of the private

structure.

Arguments:

external_re points to compiled code

optptr where to pass back the options

first_char where to pass back the first character,

or -1 if multiline and all branches start ^,

or -2 otherwise

Returns: number of identifying extraction brackets

or negative values on error

*/

int

pcre_info(const pcre *external_re, int *optptr, int *first_char)

{

const real_pcre *re = (real_pcre *)external_re;

if (re == NULL) return PCRE_ERROR_NULL;

if (re->magic_number != MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC;

if (optptr != NULL) *optptr = (re->options & PUBLIC_OPTIONS);

if (first_char != NULL)

*first_char = ((re->options & PCRE_FIRSTSET) != 0)? re->first_char :

((re->options & PCRE_STARTLINE) != 0)? -1 : -2;

return re->top_bracket;

}

#ifdef DEBUG

/*************************************************

* Debugging function to print chars *

*************************************************/

/* Print a sequence of chars in printable format, stopping at the end of the

subject if the requested.

Arguments:

p points to characters

length number to print

is_subject TRUE if printing from within md->start_subject

md pointer to matching data block, if is_subject is TRUE

Returns: nothing

*/

static void

pchars(const uschar *p, int length, BOOL is_subject, match_data *md)

{

int c;

if (is_subject && length > md->end_subject - p) length = md->end_subject - p;

while (length-- > 0)

if (isprint(c = *(p++))) printf("%c", c); else printf("\\x%02x", c);

}

#endif

/*************************************************

* Check subpattern for empty operand *

*************************************************/

/* This function checks a bracketed subpattern to see if any of the paths

through it could match an empty string. This is used to diagnose an error if

such a subpattern is followed by a quantifier with an unlimited upper bound.

Argument:

code points to the opening bracket

Returns: TRUE or FALSE

*/

static BOOL

could_be_empty(uschar *code)

{

do {

uschar *cc = code + 3;

/* Scan along the opcodes for this branch; as soon as we find something

that matches a non-empty string, break out and advance to test the next

branch. If we get to the end of the branch, return TRUE for the whole

sub-expression. */

for (;;)

{

/* Test an embedded subpattern; if it could not be empty, break the

loop. Otherwise carry on in the branch. */

if ((int)(*cc) >= OP_BRA || (int)(*cc) == OP_ONCE)

{

if (!could_be_empty(cc)) break;

do cc += (cc[1] << 8) + cc[2]; while (*cc == OP_ALT);

cc += 3;

}

else switch (*cc)

{

/* Reached end of a branch: the subpattern may match the empty string */

case OP_ALT:

case OP_KET:

case OP_KETRMAX:

case OP_KETRMIN:

return TRUE;

/* Skip over entire bracket groups with zero lower bound */

case OP_BRAZERO:

case OP_BRAMINZERO:

cc++;

/* Fall through */

/* Skip over assertive subpatterns */

case OP_ASSERT:

case OP_ASSERT_NOT:

do cc += (cc[1] << 8) + cc[2]; while (*cc == OP_ALT);

cc += 3;

break;

/* Skip over things that don't match chars */

case OP_SOD:

case OP_EOD:

case OP_CIRC:

case OP_DOLL:

case OP_NOT_WORD_BOUNDARY:

case OP_WORD_BOUNDARY:

case OP_NOT_WORD_BOUNDARY_L:

case OP_WORD_BOUNDARY_L:

cc++;

break;

/* Skip over simple repeats with zero lower bound */

case OP_STAR:

case OP_MINSTAR:

case OP_QUERY:

case OP_MINQUERY:

case OP_NOTSTAR:

case OP_NOTMINSTAR:

case OP_NOTQUERY:

case OP_NOTMINQUERY:

case OP_TYPESTAR:

case OP_TYPEMINSTAR:

case OP_TYPEQUERY:

case OP_TYPEMINQUERY:

cc += 2;

break;

/* Skip over UPTOs (lower bound is zero) */

case OP_UPTO:

case OP_MINUPTO:

case OP_TYPEUPTO:

case OP_TYPEMINUPTO:

cc += 4;

break;

/* Check a class or a back reference for a zero minimum */

case OP_CLASS:

case OP_NEGCLASS:

case OP_REF:

case OP_CLASS_L:

switch(*cc)

{

case (OP_REF): cc += 2; break;

case (OP_CLASS): case (OP_NEGCLASS): cc += 1+32; break;

case (OP_CLASS_L): cc += 1+1+32; break;

}

switch (*cc)

{

case OP_CRSTAR:

case OP_CRMINSTAR:

case OP_CRQUERY:

case OP_CRMINQUERY:

cc++;

break;

case OP_CRRANGE:

case OP_CRMINRANGE:

if ((cc[1] << 8) + cc[2] != 0) goto NEXT_BRANCH;

cc += 3;

break;

default:

goto NEXT_BRANCH;

}

break;

/* Anything else matches at least one character */

default:

goto NEXT_BRANCH;

}

}

NEXT_BRANCH:

code += (code[1] << 8) + code[2];

}

while (*code == OP_ALT);

/* No branches match the empty string */

return FALSE;

}

/* Determine the length of a group ID in an expression like

(?P<foo_123>...)

Arguments:

ptr pattern position pointer (say that 3 times fast)

finalchar the character that will mark the end of the ID

errorptr points to the pointer to the error message

*/

static int

get_group_id(const uschar *ptr, char finalchar, const char **errorptr)

{

const uschar *start = ptr;

/* If the first character is not in \w, or is in \w but is a digit,

report an error */

if (!(pcre_ctypes[*ptr] & ctype_word) ||

(pcre_ctypes[*ptr++] & ctype_digit))

{

*errorptr = "(?P identifier must start with a letter or underscore";

return 0;

}

/* Increment ptr until we either hit a null byte, the desired

final character, or a non-word character */

for(; (*ptr != 0) && (*ptr != finalchar) &&

(pcre_ctypes[*ptr] & ctype_word); ptr++)

{

/* Empty loop body */

}

if (*ptr==finalchar)

return ptr-start;

if (*ptr==0)

{

*errorptr = "unterminated (?P identifier";

return 0;

}

*errorptr = "illegal character in (?P identifier";

return 0;

}

/*************************************************

* Handle escapes *

*************************************************/

/* This function is called when a \ has been encountered. It either returns a

positive value for a simple escape such as \n, or a negative value which

encodes one of the more complicated things such as \d. On entry, ptr is

pointing at the \. On exit, it is on the final character of the escape

sequence.

Arguments:

ptrptr points to the pattern position pointer

errorptr points to the pointer to the error message

bracount number of previous extracting brackets

options the options bits

isclass TRUE if inside a character class

Returns: zero or positive => a data character

negative => a special escape sequence

on error, errorptr is set

*/

static int

check_escape(const uschar **ptrptr, const char **errorptr, int bracount,

int options, BOOL isclass)

{

const uschar *ptr = *ptrptr;

int c = *(++ptr) & 255; /* Ensure > 0 on signed-char systems */

int i;

if (c == 0) *errorptr = ERR1;

/* Digits or letters may have special meaning; all others are literals. */

else if (c < '0' || c > 'z') {}