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

* 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 doesn't have a fixed URL

yet; write Philip Hazel <[email protected]> for the latest version.

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-internal.h"

#include "Python.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 an upper casing table. */

unsigned char pcre_ucc[] = {

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, 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, 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 identifies various classes of character by individual bits:

1 white space character

2 decimal digit

4 hexadecimal digit

8 alphanumeric or '_'

16 octal digit

128 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, /* ( - / */

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

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

0x00,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x08, /* @ - G */

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

0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08, /* P - W */

0x08,0x08,0x08,0x80,0x00,0x00,0x80,0x08, /* X - _ */

0x00,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x08, /* ` - g */

0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08, /* h - o */

0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08, /* p - w */

0x08,0x08,0x08,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 pcre-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.

Written by: Philip Hazel <[email protected]>

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.

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

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

*/

/* This module contains the actual definition of global variables that are

shared between the different modules. In fact, these are limited to the

indirections for memory management functions. */

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

the external pcre header. */

/* Store get and free functions. */

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

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

/* End of pcre-globals.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) 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.

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

*/

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

the external pcre header. */

/* Character types for class type bits */

static char class_types[] = { ctype_digit, ctype_space, ctype_word };

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

* Set a range of bits in the map *

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

/* This function is called for character types.

Arguments:

start_bits points to the bit map

type a character type bit

include TRUE to include the type;

FALSE to include all but the type

Returns: nothing

*/

static void

set_type_bits(uschar *start_bits, int type, BOOL include)

{

int i;

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

if (((pcre_ctypes[i] & type) != 0) == include) start_bits[i/8] |= (1<<(i%8));

}

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

* Set one bit in the map *

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

/* This function is called to set a bit in the map for a given character,

or both cases of a letter if caseless. It could be replaced by a macro if

better performance is wanted.

Arguments:

start_bits points to 32-byte table

c the character

caseless TRUE if caseless

Returns: nothing

*/

static void

set_bit(uschar *start_bits, int c, BOOL caseless)

{

if (caseless)

{

int d = pcre_ucc[c];

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

c = pcre_lcc[c];

}

start_bits[c/8] |= (1<<(c%8));

}

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

* 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

caseless TRUE if caseless

Returns: TRUE if table built, FALSE otherwise

*/

static BOOL

set_start_bits(uschar *code, uschar *start_bits, BOOL caseless)

{

do

{

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, caseless)) 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, caseless)) 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:

set_bit(start_bits, tcode[1], caseless);

tcode += 2;

try_next = TRUE;

break;

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

case OP_UPTO:

case OP_MINUPTO:

set_bit(start_bits, tcode[3], caseless);

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:

set_bit(start_bits, tcode[1], caseless);

break;

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

case OP_NOT_DIGIT:

set_type_bits(start_bits, ctype_digit, FALSE);

break;

case OP_DIGIT:

set_type_bits(start_bits, ctype_digit, TRUE);

break;

case OP_NOT_WHITESPACE:

set_type_bits(start_bits, ctype_space, FALSE);

break;

case OP_WHITESPACE:

set_type_bits(start_bits, ctype_space, TRUE);

break;

case OP_NOT_WORDCHAR:

set_type_bits(start_bits, ctype_word, FALSE);

break;

case OP_WORDCHAR:

set_type_bits(start_bits, ctype_word, TRUE);

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:

set_type_bits(start_bits, ctype_digit, FALSE);

break;

case OP_DIGIT:

set_type_bits(start_bits, ctype_digit, TRUE);

break;

case OP_NOT_WHITESPACE:

set_type_bits(start_bits, ctype_space, FALSE);

break;

case OP_WHITESPACE:

set_type_bits(start_bits, ctype_space, TRUE);

break;

case OP_NOT_WORDCHAR:

set_type_bits(start_bits, ctype_word, FALSE);

break;

case OP_WORDCHAR:

set_type_bits(start_bits, ctype_word, TRUE);

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:

{

uschar *base = tcode;

uschar *data, *end;

uschar *bitmap = start_bits;

uschar local[32];

int flags = base[1];

int i;

tcode += 4 + 2 * tcode[2] + tcode[3]; /* Advance past the item */

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;

}

/* For a negated class, we have to build a separate table of all

the bits in the class, and then turn all other bits on in the main

table. Otherwise there are problems with things like [^\da]. */

if (*base == OP_NEGCLASS)

{

memset(local, 0, 32);

bitmap = local;

}

/* Character types */

for (i = 0; flags != 0; i++)

{

if ((flags & 1) != 0)

set_type_bits(bitmap, class_types[i/2], (i & 1) == 0);

flags >>= 1;

}

/* Ranges and individual characters */

data = base + 4;

end = data + base[2] * 2;

while (data < end)

{

for (i = *data; i <= data[1]; i++) set_bit(bitmap, i, caseless);

data += 2;

}

end += base[3];

while (data < end) set_bit(bitmap, *data++, caseless);

/* If a negated class, transfer data from local map to the main one */

if (bitmap != start_bits)

for (i = 0; i < 32; i++) start_bits[i] |= ~local[i];

}

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(pcre *external_re, int options, char **errorptr)

{

BOOL caseless;

uschar start_bits[32];

real_pcre_extra *extra;

real_pcre *re = (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;

}

/* 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;

/* Determine the caseless state from the compiled pattern and the current

options. */

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

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

memset(start_bits, 0, 32);

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

/* 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, 32);

return (pcre_extra *)extra;

}

/* End of pcre-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) 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 DEBUG to get debugging output on stdout. */

/* #define DEBUG */

/* 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

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

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

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

/* Text forms of OP_ values and things, for debugging */

#ifdef DEBUG

static char *OP_names[] = { "End", "\\A", "\\B", "\\b", "\\D", "\\d",

"\\S", "\\s", "\\W", "\\w", "\\Z", "^", "$", "Any", "chars",

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

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

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

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

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

"Brazero", "Braminzero", "Bra"

};

static char *class_names[] = { "\\d", "\\D", "\\s", "\\S", "\\w", "\\W" };

#endif

/* Table of character type operators that correspond to the bits in the

character class flags, starting at the least significant end. */

static char class_ops[] = {

OP_DIGIT, OP_NOT_DIGIT,

OP_WHITESPACE, OP_NOT_WHITESPACE,

OP_WORDCHAR, OP_NOT_WORDCHAR };

/* 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. */

/* PYTHON: Python doesn't support \e, but does support \v */

static 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_regexp(BOOL, int *, uschar **, uschar **,

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 multiline; /* Multiline flag */

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

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

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

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

BOOL dotall; /* Dotall flag */

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;

uschar **eptr, **ecode;

} match_data;

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

* Return version string *

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

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(pcre *external_re, int *optptr, int *first_char)

{

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 pchars(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)

{

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 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_BRAZERO:

case OP_BRAMINZERO:

case OP_NOT_WORD_BOUNDARY:

case OP_WORD_BOUNDARY:

cc++;

break;

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

case OP_STAR:

case OP_MINSTAR:

case OP_QUERY:

case OP_MINQUERY:

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:

cc += (*cc == OP_REF)? 2 : 4 + 2 * cc[2] + cc[3];

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(uschar *ptr, char finalchar, char **errorptr)

{

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++)