mirror of
https://github.com/python/cpython.git
synced 2024-12-06 00:05:32 +08:00
04e00a4cf4
after a return or goto).
4751 lines
134 KiB
C
4751 lines
134 KiB
C
|
|
/*************************************************
|
|
* 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 <ph10@cam.ac.uk>
|
|
|
|
Extensively modified by the Python String-SIG: <string-sig@python.org>
|
|
Send bug reports to: <string-sig@python.org>
|
|
(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 <ph10@cam.ac.uk>
|
|
|
|
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 <ph10@cam.ac.uk>
|
|
|
|
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') {}
|
|
|
|
/* Do an initial lookup in a table. A non-zero result is something that can be
|
|
returned immediately. Otherwise further processing may be required. */
|
|
|
|
else if ((i = escapes[c - '0']) != 0) c = i;
|
|
|
|
/* Escapes that need further processing, or are illegal. */
|
|
|
|
else
|
|
{
|
|
|
|
switch (c)
|
|
{
|
|
/* The handling of escape sequences consisting of a string of digits
|
|
starting with one that is not zero is not straightforward. By experiment,
|
|
the way Perl works seems to be as follows:
|
|
|
|
Outside a character class, the digits are read as a decimal number. If the
|
|
number is less than 10, or if there are that many previous extracting
|
|
left brackets, then it is a back reference. Otherwise, up to three octal
|
|
digits are read to form an escaped byte. Thus \123 is likely to be octal
|
|
123 (cf \0123, which is octal 012 followed by the literal 3). If the octal
|
|
value is greater than 377, the least significant 8 bits are taken. Inside a
|
|
character class, \ followed by a digit is always an octal number. */
|
|
|
|
case '1': case '2': case '3': case '4': case '5':
|
|
case '6': case '7': case '8': case '9':
|
|
|
|
{
|
|
/* PYTHON: Try to compute an octal value for a character */
|
|
for(c=0, i=0; ptr[i]!=0 && i<3; i++)
|
|
{
|
|
if (( pcre_ctypes[ ptr[i] ] & ctype_odigit) != 0)
|
|
c = c * 8 + ptr[i]-'0';
|
|
else
|
|
break; /* Non-octal character--break out of the loop */
|
|
}
|
|
/* It's a character if there were exactly 3 octal digits, or if
|
|
we're inside a character class and there was at least one
|
|
octal digit. */
|
|
if ( (i == 3) || (isclass && i!=0) )
|
|
{
|
|
ptr += i-1;
|
|
break;
|
|
}
|
|
c = ptr[0]; /* Restore the first character after the \ */
|
|
c -= '0'; i = 1;
|
|
while (i<2 && (pcre_ctypes[ptr[1]] & ctype_digit) != 0)
|
|
{
|
|
c = c * 10 + ptr[1] - '0';
|
|
ptr++; i++;
|
|
}
|
|
if (c > 255 - ESC_REF) *errorptr = "back reference too big";
|
|
c = -(ESC_REF + c);
|
|
}
|
|
break;
|
|
|
|
/* \0 always starts an octal number, but we may drop through to here with a
|
|
larger first octal digit */
|
|
|
|
case '0':
|
|
c -= '0';
|
|
while(i++ < 2 && (pcre_ctypes[ptr[1]] & ctype_digit) != 0 &&
|
|
ptr[1] != '8' && ptr[1] != '9')
|
|
c = c * 8 + *(++ptr) - '0';
|
|
break;
|
|
|
|
/* Special escapes not starting with a digit are straightforward */
|
|
|
|
case 'x':
|
|
c = 0;
|
|
while ( (pcre_ctypes[ptr[1]] & ctype_xdigit) != 0)
|
|
{
|
|
ptr++;
|
|
c = c * 16 + pcre_lcc[*ptr] -
|
|
(((pcre_ctypes[*ptr] & ctype_digit) != 0)? '0' : 'W');
|
|
c &= 255;
|
|
}
|
|
break;
|
|
|
|
|
|
/* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
|
|
other alphameric following \ is an error if PCRE_EXTRA was set; otherwise,
|
|
for Perl compatibility, it is a literal. */
|
|
|
|
default:
|
|
if ((options & PCRE_EXTRA) != 0) switch(c)
|
|
{
|
|
case 'X':
|
|
c = -ESC_X; /* This could be a lookup if it ever got into Perl */
|
|
break;
|
|
|
|
default:
|
|
*errorptr = ERR3;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
*ptrptr = ptr;
|
|
return c;
|
|
}
|
|
|
|
|
|
|
|
/*************************************************
|
|
* Check for counted repeat *
|
|
*************************************************/
|
|
|
|
/* This function is called when a '{' is encountered in a place where it might
|
|
start a quantifier. It looks ahead to see if it really is a quantifier or not.
|
|
It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
|
|
where the ddds are digits.
|
|
|
|
Arguments:
|
|
p pointer to the first char after '{'
|
|
|
|
Returns: TRUE or FALSE
|
|
*/
|
|
|
|
static BOOL
|
|
is_counted_repeat(const uschar *p)
|
|
{
|
|
if ((pcre_ctypes[*p++] & ctype_digit) == 0) return FALSE;
|
|
while ((pcre_ctypes[*p] & ctype_digit) != 0) p++;
|
|
if (*p == '}') return TRUE;
|
|
|
|
if (*p++ != ',') return FALSE;
|
|
if (*p == '}') return TRUE;
|
|
|
|
if ((pcre_ctypes[*p++] & ctype_digit) == 0) return FALSE;
|
|
while ((pcre_ctypes[*p] & ctype_digit) != 0) p++;
|
|
return (*p == '}');
|
|
}
|
|
|
|
|
|
|
|
/*************************************************
|
|
* Read repeat counts *
|
|
*************************************************/
|
|
|
|
/* Read an item of the form {n,m} and return the values. This is called only
|
|
after is_counted_repeat() has confirmed that a repeat-count quantifier exists,
|
|
so the syntax is guaranteed to be correct, but we need to check the values.
|
|
|
|
Arguments:
|
|
p pointer to first char after '{'
|
|
minp pointer to int for min
|
|
maxp pointer to int for max
|
|
returned as -1 if no max
|
|
errorptr points to pointer to error message
|
|
|
|
Returns: pointer to '}' on success;
|
|
current ptr on error, with errorptr set
|
|
*/
|
|
|
|
static const uschar *
|
|
read_repeat_counts(const uschar *p, int *minp, int *maxp, const char **errorptr)
|
|
{
|
|
int min = 0;
|
|
int max = -1;
|
|
|
|
while ((pcre_ctypes[*p] & ctype_digit) != 0) min = min * 10 + *p++ - '0';
|
|
|
|
if (*p == '}') max = min; else
|
|
{
|
|
if (*(++p) != '}')
|
|
{
|
|
max = 0;
|
|
while((pcre_ctypes[*p] & ctype_digit) != 0) max = max * 10 + *p++ - '0';
|
|
if (max < min)
|
|
{
|
|
*errorptr = ERR4;
|
|
return p;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Do paranoid checks, then fill in the required variables, and pass back the
|
|
pointer to the terminating '}'. */
|
|
|
|
if (min > 65535 || max > 65535)
|
|
*errorptr = ERR5;
|
|
else
|
|
{
|
|
*minp = min;
|
|
*maxp = max;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
|
|
|
|
/*************************************************
|
|
* Compile one branch *
|
|
*************************************************/
|
|
|
|
/* Scan the pattern, compiling it into the code vector.
|
|
|
|
Arguments:
|
|
options the option bits
|
|
bracket points to number of brackets used
|
|
code points to the pointer to the current code point
|
|
ptrptr points to the current pattern pointer
|
|
errorptr points to pointer to error message
|
|
|
|
Returns: TRUE on success
|
|
FALSE, with *errorptr set on error
|
|
*/
|
|
|
|
static BOOL
|
|
compile_branch(int options, int *brackets, uschar **codeptr,
|
|
const uschar **ptrptr, const char **errorptr, PyObject *dictionary)
|
|
{
|
|
int repeat_type, op_type;
|
|
int repeat_min, repeat_max;
|
|
int bravalue, length;
|
|
int greedy_default, greedy_non_default;
|
|
register int c;
|
|
register uschar *code = *codeptr;
|
|
const uschar *ptr = *ptrptr;
|
|
const uschar *oldptr;
|
|
uschar *previous = NULL;
|
|
uschar class[32];
|
|
uschar *class_flag; /* Pointer to the single-byte flag for OP_CLASS_L */
|
|
|
|
/* Set up the default and non-default settings for greediness */
|
|
|
|
greedy_default = ((options & PCRE_UNGREEDY) != 0);
|
|
greedy_non_default = greedy_default ^ 1;
|
|
|
|
/* Switch on next character until the end of the branch */
|
|
|
|
for (;; ptr++)
|
|
{
|
|
BOOL negate_class;
|
|
int class_charcount;
|
|
int class_lastchar;
|
|
|
|
c = *ptr;
|
|
if ((options & PCRE_EXTENDED) != 0)
|
|
{
|
|
if ((pcre_ctypes[c] & ctype_space) != 0) continue;
|
|
if (c == '#')
|
|
{
|
|
while ((c = *(++ptr)) != 0 && c != '\n');
|
|
continue;
|
|
}
|
|
}
|
|
|
|
switch(c)
|
|
{
|
|
/* The branch terminates at end of string, |, or ). */
|
|
|
|
case 0:
|
|
case '|':
|
|
case ')':
|
|
*codeptr = code;
|
|
*ptrptr = ptr;
|
|
return TRUE;
|
|
|
|
/* Handle single-character metacharacters */
|
|
|
|
case '^':
|
|
previous = NULL;
|
|
*code++ = OP_CIRC;
|
|
break;
|
|
|
|
case '$':
|
|
previous = NULL;
|
|
*code++ = OP_DOLL;
|
|
break;
|
|
|
|
case '.':
|
|
previous = code;
|
|
*code++ = OP_ANY;
|
|
break;
|
|
|
|
/* Character classes. These always build a 32-byte bitmap of the permitted
|
|
characters, except in the special case where there is only one character.
|
|
For negated classes, we build the map as usual, then invert it at the end.
|
|
*/
|
|
|
|
case '[':
|
|
previous = code;
|
|
if (options & PCRE_LOCALE)
|
|
{
|
|
*code++ = OP_CLASS_L;
|
|
/* Set the flag for localized classes (like \w) to 0 */
|
|
class_flag = code;
|
|
*class_flag = 0;
|
|
}
|
|
else
|
|
{
|
|
*code++ = OP_CLASS;
|
|
class_flag = NULL;
|
|
}
|
|
|
|
/* If the first character is '^', set the negation flag, and use a
|
|
different opcode. This only matters if caseless matching is specified at
|
|
runtime. */
|
|
|
|
if ((c = *(++ptr)) == '^')
|
|
{
|
|
negate_class = TRUE;
|
|
if (*(code-1)==OP_CLASS) *(code-1) = OP_NEGCLASS;
|
|
c = *(++ptr);
|
|
}
|
|
else negate_class = FALSE;
|
|
|
|
/* Keep a count of chars so that we can optimize the case of just a single
|
|
character. */
|
|
|
|
class_charcount = 0;
|
|
class_lastchar = -1;
|
|
|
|
/* Initialize the 32-char bit map to all zeros. We have to build the
|
|
map in a temporary bit of store, in case the class contains only 1
|
|
character, because in that case the compiled code doesn't use the
|
|
bit map. */
|
|
|
|
memset(class, 0, 32 * sizeof(uschar));
|
|
|
|
/* Process characters until ] is reached. By writing this as a "do" it
|
|
means that an initial ] is taken as a data character. */
|
|
|
|
do
|
|
{
|
|
if (c == 0)
|
|
{
|
|
*errorptr = ERR6;
|
|
goto FAILED;
|
|
}
|
|
|
|
/* Backslash may introduce a single character, or it may introduce one
|
|
of the specials, which just set a flag. Escaped items are checked for
|
|
validity in the pre-compiling pass. The sequence \b is a special case.
|
|
Inside a class (and only there) it is treated as backspace. Elsewhere
|
|
it marks a word boundary. Other escapes have preset maps ready to
|
|
or into the one we are building. We assume they have more than one
|
|
character in them, so set class_count bigger than one. */
|
|
|
|
if (c == '\\')
|
|
{
|
|
c = check_escape(&ptr, errorptr, *brackets, options, TRUE);
|
|
if (-c == ESC_b) c = '\b';
|
|
else if (c < 0)
|
|
{
|
|
class_charcount = 10;
|
|
switch (-c)
|
|
{
|
|
case ESC_d:
|
|
{
|
|
for (c = 0; c < 32; c++) class[c] |= pcre_cbits[c+cbit_digit];
|
|
}
|
|
continue;
|
|
|
|
case ESC_D:
|
|
{
|
|
for (c = 0; c < 32; c++) class[c] |= ~pcre_cbits[c+cbit_digit];
|
|
}
|
|
continue;
|
|
|
|
case ESC_w:
|
|
if (options & PCRE_LOCALE)
|
|
{
|
|
*class_flag |= 1;
|
|
}
|
|
else
|
|
{
|
|
for (c = 0; c < 32; c++)
|
|
class[c] |= (pcre_cbits[c] | pcre_cbits[c+cbit_word]);
|
|
}
|
|
continue;
|
|
|
|
case ESC_W:
|
|
if (options & PCRE_LOCALE)
|
|
{
|
|
*class_flag |= 2;
|
|
}
|
|
else
|
|
{
|
|
for (c = 0; c < 32; c++)
|
|
class[c] |= ~(pcre_cbits[c] | pcre_cbits[c+cbit_word]);
|
|
}
|
|
continue;
|
|
|
|
case ESC_s:
|
|
{
|
|
for (c = 0; c < 32; c++) class[c] |= pcre_cbits[c+cbit_space];
|
|
}
|
|
continue;
|
|
|
|
case ESC_S:
|
|
{
|
|
for (c = 0; c < 32; c++) class[c] |= ~pcre_cbits[c+cbit_space];
|
|
}
|
|
continue;
|
|
|
|
default:
|
|
*errorptr = ERR7;
|
|
goto FAILED;
|
|
}
|
|
}
|
|
/* Fall through if single character */
|
|
}
|
|
|
|
/* A single character may be followed by '-' to form a range. However,
|
|
Perl does not permit ']' to be the end of the range. A '-' character
|
|
here is treated as a literal. */
|
|
|
|
if (ptr[1] == '-' && ptr[2] != ']')
|
|
{
|
|
int d;
|
|
ptr += 2;
|
|
d = *ptr;
|
|
|
|
if (d == 0)
|
|
{
|
|
*errorptr = ERR6;
|
|
goto FAILED;
|
|
}
|
|
|
|
/* The second part of a range can be a single-character escape, but
|
|
not any of the other escapes. */
|
|
|
|
if (d == '\\')
|
|
{
|
|
d = check_escape(&ptr, errorptr, *brackets, options, TRUE);
|
|
if (d < 0)
|
|
{
|
|
if (d == -ESC_b) d = '\b'; else
|
|
{
|
|
*errorptr = ERR7;
|
|
goto FAILED;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (d < c)
|
|
{
|
|
*errorptr = ERR8;
|
|
goto FAILED;
|
|
}
|
|
|
|
for (; c <= d; c++)
|
|
{
|
|
class[c/8] |= (1 << (c&7));
|
|
if ((options & PCRE_CASELESS) != 0)
|
|
{
|
|
int uc = pcre_fcc[c]; /* flip case */
|
|
class[uc/8] |= (1 << (uc&7));
|
|
}
|
|
class_charcount++; /* in case a one-char range */
|
|
class_lastchar = c;
|
|
}
|
|
continue; /* Go get the next char in the class */
|
|
}
|
|
|
|
/* Handle a lone single character - we can get here for a normal
|
|
non-escape char, or after \ that introduces a single character. */
|
|
|
|
class [c/8] |= (1 << (c&7));
|
|
if ((options & PCRE_CASELESS) != 0)
|
|
{
|
|
c = pcre_fcc[c]; /* flip case */
|
|
class[c/8] |= (1 << (c&7));
|
|
}
|
|
class_charcount++;
|
|
class_lastchar = c;
|
|
}
|
|
|
|
/* Loop until ']' reached; the check for end of string happens inside the
|
|
loop. This "while" is the end of the "do" above. */
|
|
|
|
while ((c = *(++ptr)) != ']');
|
|
|
|
/* If class_charcount is 1 and class_lastchar is not negative, we saw
|
|
precisely one character. This doesn't need the whole 32-byte bit map.
|
|
We turn it into a 1-character OP_CHAR if it's positive, or OP_NOT if
|
|
it's negative. */
|
|
|
|
if (class_charcount == 1 && class_lastchar >= 0)
|
|
{
|
|
if (negate_class)
|
|
{
|
|
code[-1] = OP_NOT;
|
|
}
|
|
else
|
|
{
|
|
code[-1] = OP_CHARS;
|
|
*code++ = 1;
|
|
}
|
|
*code++ = class_lastchar;
|
|
}
|
|
|
|
/* Otherwise, negate the 32-byte map if necessary, and copy it into
|
|
the code vector. */
|
|
|
|
else
|
|
{
|
|
/* If this is a localized opcode, bump the code pointer up */
|
|
if (class_flag) code++;
|
|
if (negate_class)
|
|
{
|
|
if (class_flag) *class_flag = (*class_flag) ^ 63;
|
|
for (c = 0; c < 32; c++) code[c] = ~class[c];
|
|
}
|
|
else
|
|
memcpy(code, class, 32);
|
|
code += 32;
|
|
}
|
|
break;
|
|
|
|
/* Various kinds of repeat */
|
|
|
|
case '{':
|
|
if (!is_counted_repeat(ptr+1)) goto NORMAL_CHAR;
|
|
ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorptr);
|
|
if (*errorptr != NULL) goto FAILED;
|
|
goto REPEAT;
|
|
|
|
case '*':
|
|
repeat_min = 0;
|
|
repeat_max = -1;
|
|
goto REPEAT;
|
|
|
|
case '+':
|
|
repeat_min = 1;
|
|
repeat_max = -1;
|
|
goto REPEAT;
|
|
|
|
case '?':
|
|
repeat_min = 0;
|
|
repeat_max = 1;
|
|
|
|
REPEAT:
|
|
if (previous == NULL)
|
|
{
|
|
*errorptr = ERR9;
|
|
goto FAILED;
|
|
}
|
|
|
|
/* If the next character is '?' this is a minimizing repeat, by default,
|
|
but if PCRE_UNGREEDY is set, it works the other way round. Advance to the
|
|
next character. */
|
|
|
|
if (ptr[1] == '?')
|
|
{ repeat_type = greedy_non_default; ptr++; }
|
|
else repeat_type = greedy_default;
|
|
|
|
/* If the maximum is zero then the minimum must also be zero; Perl allows
|
|
this case, so we do too - by simply omitting the item altogether. */
|
|
|
|
if (repeat_max == 0) code = previous;
|
|
|
|
/* If previous was a string of characters, chop off the last one and use it
|
|
as the subject of the repeat. If there was only one character, we can
|
|
abolish the previous item altogether. */
|
|
|
|
else if (*previous == OP_CHARS)
|
|
{
|
|
int len = previous[1];
|
|
if (len == 1)
|
|
{
|
|
c = previous[2];
|
|
code = previous;
|
|
}
|
|
else
|
|
{
|
|
c = previous[len+1];
|
|
previous[1]--;
|
|
code--;
|
|
}
|
|
op_type = 0; /* Use single-char op codes */
|
|
goto OUTPUT_SINGLE_REPEAT; /* Code shared with single character types */
|
|
}
|
|
|
|
/* If previous was a single negated character ([^a] or similar), we use
|
|
one of the special opcodes, replacing it. The code is shared with single-
|
|
character repeats by adding a suitable offset into repeat_type. */
|
|
|
|
else if ((int)*previous == OP_NOT)
|
|
{
|
|
op_type = OP_NOTSTAR - OP_STAR; /* Use "not" opcodes */
|
|
c = previous[1];
|
|
code = previous;
|
|
goto OUTPUT_SINGLE_REPEAT;
|
|
}
|
|
|
|
/* If previous was a character type match (\d or similar), abolish it and
|
|
create a suitable repeat item. The code is shared with single-character
|
|
repeats by adding a suitable offset into repeat_type. */
|
|
|
|
else if ((int)*previous < OP_CIRC || *previous == OP_ANY)
|
|
{
|
|
op_type = OP_TYPESTAR - OP_STAR; /* Use type opcodes */
|
|
c = *previous;
|
|
code = previous;
|
|
|
|
OUTPUT_SINGLE_REPEAT:
|
|
repeat_type += op_type; /* Combine both values for many cases */
|
|
|
|
/* A minimum of zero is handled either as the special case * or ?, or as
|
|
an UPTO, with the maximum given. */
|
|
|
|
if (repeat_min == 0)
|
|
{
|
|
if (repeat_max == -1) *code++ = OP_STAR + repeat_type;
|
|
else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;
|
|
else
|
|
{
|
|
*code++ = OP_UPTO + repeat_type;
|
|
*code++ = repeat_max >> 8;
|
|
*code++ = (repeat_max & 255);
|
|
}
|
|
}
|
|
|
|
/* The case {1,} is handled as the special case + */
|
|
|
|
else if (repeat_min == 1 && repeat_max == -1)
|
|
*code++ = OP_PLUS + repeat_type;
|
|
|
|
/* The case {n,n} is just an EXACT, while the general case {n,m} is
|
|
handled as an EXACT followed by an UPTO. An EXACT of 1 is optimized. */
|
|
|
|
else
|
|
{
|
|
if (repeat_min != 1)
|
|
{
|
|
*code++ = OP_EXACT + op_type; /* NB EXACT doesn't have repeat_type */
|
|
*code++ = repeat_min >> 8;
|
|
*code++ = (repeat_min & 255);
|
|
}
|
|
|
|
/* If the mininum is 1 and the previous item was a character string,
|
|
we either have to put back the item that got cancelled if the string
|
|
length was 1, or add the character back onto the end of a longer
|
|
string. For a character type nothing need be done; it will just get
|
|
put back naturally. Note that the final character is always going to
|
|
get added below. */
|
|
|
|
else if (*previous == OP_CHARS)
|
|
{
|
|
if (code == previous) code += 2; else previous[1]++;
|
|
}
|
|
|
|
/* For a single negated character we also have to put back the
|
|
item that got cancelled. */
|
|
|
|
else if (*previous == OP_NOT) code++;
|
|
|
|
/* If the maximum is unlimited, insert an OP_STAR. */
|
|
|
|
if (repeat_max < 0)
|
|
{
|
|
*code++ = c;
|
|
*code++ = OP_STAR + repeat_type;
|
|
}
|
|
|
|
/* Else insert an UPTO if the max is greater than the min. */
|
|
|
|
else if (repeat_max != repeat_min)
|
|
{
|
|
*code++ = c;
|
|
repeat_max -= repeat_min;
|
|
*code++ = OP_UPTO + repeat_type;
|
|
*code++ = repeat_max >> 8;
|
|
*code++ = (repeat_max & 255);
|
|
}
|
|
}
|
|
|
|
/* The character or character type itself comes last in all cases. */
|
|
|
|
*code++ = c;
|
|
}
|
|
|
|
/* If previous was a character class or a back reference, we put the repeat
|
|
stuff after it. */
|
|
|
|
else if (*previous == OP_CLASS || *previous == OP_NEGCLASS ||
|
|
*previous==OP_CLASS_L || *previous == OP_REF)
|
|
{
|
|
if (repeat_min == 0 && repeat_max == -1)
|
|
*code++ = OP_CRSTAR + repeat_type;
|
|
else if (repeat_min == 1 && repeat_max == -1)
|
|
*code++ = OP_CRPLUS + repeat_type;
|
|
else if (repeat_min == 0 && repeat_max == 1)
|
|
*code++ = OP_CRQUERY + repeat_type;
|
|
else
|
|
{
|
|
*code++ = OP_CRRANGE + repeat_type;
|
|
*code++ = repeat_min >> 8;
|
|
*code++ = repeat_min & 255;
|
|
if (repeat_max == -1) repeat_max = 0; /* 2-byte encoding for max */
|
|
*code++ = repeat_max >> 8;
|
|
*code++ = repeat_max & 255;
|
|
}
|
|
}
|
|
|
|
/* If previous was a bracket group, we may have to replicate it in certain
|
|
cases. If the maximum repeat count is unlimited, check that the bracket
|
|
group cannot match the empty string, and diagnose an error if it can. */
|
|
|
|
else if ((int)*previous >= OP_BRA)
|
|
{
|
|
int i;
|
|
int len = code - previous;
|
|
|
|
if (repeat_max == -1 && could_be_empty(previous))
|
|
{
|
|
*errorptr = ERR10;
|
|
goto FAILED;
|
|
}
|
|
|
|
/* If the minimum is greater than zero, and the maximum is unlimited or
|
|
equal to the minimum, the first copy remains where it is, and is
|
|
replicated up to the minimum number of times. This case includes the +
|
|
repeat, but of course no replication is needed in that case. */
|
|
|
|
if (repeat_min > 0 && (repeat_max == -1 || repeat_max == repeat_min))
|
|
{
|
|
for (i = 1; i < repeat_min; i++)
|
|
{
|
|
memcpy(code, previous, len);
|
|
code += len;
|
|
}
|
|
}
|
|
|
|
/* If the minimum is zero, stick BRAZERO in front of the first copy.
|
|
Then, if there is a fixed upper limit, replicated up to that many times,
|
|
sticking BRAZERO in front of all the optional ones. */
|
|
|
|
else
|
|
{
|
|
if (repeat_min == 0)
|
|
{
|
|
memmove(previous+1, previous, len);
|
|
code++;
|
|
*previous++ = OP_BRAZERO + repeat_type;
|
|
}
|
|
|
|
for (i = 1; i < repeat_min; i++)
|
|
{
|
|
memcpy(code, previous, len);
|
|
code += len;
|
|
}
|
|
|
|
for (i = (repeat_min > 0)? repeat_min : 1; i < repeat_max; i++)
|
|
{
|
|
*code++ = OP_BRAZERO + repeat_type;
|
|
memcpy(code, previous, len);
|
|
code += len;
|
|
}
|
|
}
|
|
|
|
/* If the maximum is unlimited, set a repeater in the final copy. */
|
|
|
|
if (repeat_max == -1) code[-3] = OP_KETRMAX + repeat_type;
|
|
}
|
|
|
|
/* Else there's some kind of shambles */
|
|
|
|
else
|
|
{
|
|
*errorptr = ERR11;
|
|
goto FAILED;
|
|
}
|
|
|
|
/* In all case we no longer have a previous item. */
|
|
|
|
previous = NULL;
|
|
break;
|
|
|
|
|
|
/* Start of nested bracket sub-expression, or comment or lookahead.
|
|
First deal with special things that can come after a bracket; all are
|
|
introduced by ?, and the appearance of any of them means that this is not a
|
|
referencing group. They were checked for validity in the first pass over
|
|
the string, so we don't have to check for syntax errors here. */
|
|
|
|
case '(':
|
|
previous = code; /* Only real brackets can be repeated */
|
|
if (*(++ptr) == '?')
|
|
{
|
|
bravalue = OP_BRA;
|
|
|
|
switch (*(++ptr))
|
|
{
|
|
case '#':
|
|
case 'i':
|
|
case 'L':
|
|
case 'm':
|
|
case 's':
|
|
case 'x':
|
|
ptr++;
|
|
while (*ptr != ')') ptr++;
|
|
previous = NULL;
|
|
continue;
|
|
|
|
case ':': /* Non-extracting bracket */
|
|
ptr++;
|
|
break;
|
|
|
|
case '=': /* Assertions can't be repeated */
|
|
bravalue = OP_ASSERT;
|
|
ptr++;
|
|
previous = NULL;
|
|
break;
|
|
|
|
case '!':
|
|
bravalue = OP_ASSERT_NOT;
|
|
ptr++;
|
|
previous = NULL;
|
|
break;
|
|
|
|
case ('P'):
|
|
ptr++;
|
|
if (*ptr=='<')
|
|
{
|
|
/* (?P<groupname>...) */
|
|
int idlen;
|
|
PyObject *string, *intobj;
|
|
|
|
ptr++;
|
|
idlen = get_group_id(ptr, '>', errorptr);
|
|
if (*errorptr) {
|
|
goto FAILED;
|
|
}
|
|
string = PyString_FromStringAndSize((char*)ptr, idlen);
|
|
intobj = PyInt_FromLong( brackets[0] + 1 );
|
|
if (intobj == NULL || string == NULL)
|
|
{
|
|
Py_XDECREF(string);
|
|
Py_XDECREF(intobj);
|
|
*errorptr = "exception raised";
|
|
goto FAILED;
|
|
}
|
|
PyDict_SetItem(dictionary, string, intobj);
|
|
Py_DECREF(string); Py_DECREF(intobj); /* XXX DECREF commented out! */
|
|
ptr += idlen+1; /* Point to rest of expression */
|
|
goto do_grouping_bracket;
|
|
}
|
|
if (*ptr=='=')
|
|
{
|
|
/* (?P=groupname) */
|
|
int idlen, refnum;
|
|
PyObject *string, *intobj;
|
|
|
|
ptr++;
|
|
idlen = get_group_id(ptr, ')', errorptr);
|
|
if (*errorptr) {
|
|
goto FAILED;
|
|
}
|
|
string = PyString_FromStringAndSize((char *)ptr, idlen);
|
|
if (string==NULL) {
|
|
*errorptr = "exception raised";
|
|
goto FAILED;
|
|
}
|
|
intobj = PyDict_GetItem(dictionary, string);
|
|
if (intobj==NULL) {
|
|
Py_DECREF(string);
|
|
*errorptr = "?P= group identifier isn't defined";
|
|
goto FAILED;
|
|
}
|
|
|
|
refnum = PyInt_AsLong(intobj);
|
|
Py_DECREF(string);
|
|
/* The caller doesn't own the reference to the value
|
|
returned from PyDict_GetItem, so intobj is not
|
|
DECREF'ed. */
|
|
|
|
*code++ = OP_REF;
|
|
*code++ = refnum;
|
|
/* The continue will cause the top-level for() loop to
|
|
be resumed, so ptr will be immediately incremented.
|
|
Therefore, the following line adds just idlen, not
|
|
idlen+1 */
|
|
ptr += idlen;
|
|
continue;
|
|
}
|
|
/* The character after ?P is neither < nor =, so
|
|
report an error. Add more Python-extensions here. */
|
|
*errorptr="unknown after (?P";
|
|
goto FAILED;
|
|
|
|
case '>': /* "Match once" brackets */
|
|
if ((options & PCRE_EXTRA) != 0) /* Not yet standard */
|
|
{
|
|
bravalue = OP_ONCE;
|
|
ptr++;
|
|
previous = NULL;
|
|
break;
|
|
}
|
|
/* Else fall through */
|
|
|
|
default:
|
|
*errorptr = ERR12;
|
|
goto FAILED;
|
|
}
|
|
}
|
|
|
|
/* Else we have a referencing group */
|
|
|
|
else
|
|
{
|
|
do_grouping_bracket:
|
|
if (++(*brackets) > EXTRACT_MAX)
|
|
{
|
|
*errorptr = ERR13;
|
|
goto FAILED;
|
|
}
|
|
bravalue = OP_BRA + *brackets;
|
|
}
|
|
|
|
/* Process nested bracketed re; at end pointer is on the bracket. We copy
|
|
code into a non-register variable in order to be able to pass its address
|
|
because some compilers complain otherwise. */
|
|
|
|
*code = bravalue;
|
|
{
|
|
uschar *mcode = code;
|
|
if (!compile_regex(options, brackets, &mcode, &ptr, errorptr, dictionary))
|
|
goto FAILED;
|
|
code = mcode;
|
|
}
|
|
|
|
if (*ptr != ')')
|
|
{
|
|
*errorptr = ERR14;
|
|
goto FAILED;
|
|
}
|
|
break;
|
|
|
|
/* Check \ for being a real metacharacter; if not, fall through and handle
|
|
it as a data character at the start of a string. Escape items are checked
|
|
for validity in the pre-compiling pass. */
|
|
|
|
case '\\':
|
|
oldptr = ptr;
|
|
c = check_escape(&ptr, errorptr, *brackets, options, FALSE);
|
|
|
|
/* Handle metacharacters introduced by \. For ones like \d, the ESC_ values
|
|
are arranged to be the negation of the corresponding OP_values. For the
|
|
back references, the values are ESC_REF plus the reference number. Only
|
|
back references and those types that consume a character may be repeated.
|
|
We can test for values between ESC_b and ESC_Z for the latter; this may
|
|
have to change if any new ones are ever created. */
|
|
|
|
if (c < 0)
|
|
{
|
|
if (-c >= ESC_REF)
|
|
{
|
|
int refnum = -c - ESC_REF;
|
|
if (*brackets < refnum)
|
|
{
|
|
*errorptr = ERR15;
|
|
goto FAILED;
|
|
}
|
|
previous = code;
|
|
*code++ = OP_REF;
|
|
*code++ = refnum;
|
|
}
|
|
else
|
|
{
|
|
previous = (-c > ESC_b && -c < ESC_X)? code : NULL;
|
|
if ( (options & PCRE_LOCALE) != 0)
|
|
{
|
|
switch (c)
|
|
{
|
|
case (-ESC_b): c = -OP_WORD_BOUNDARY_L; break;
|
|
case (-ESC_B): c = -OP_NOT_WORD_BOUNDARY_L; break;
|
|
case (-ESC_w): c = -OP_WORDCHAR_L; break;
|
|
case (-ESC_W): c = -OP_NOT_WORDCHAR_L; break;
|
|
}
|
|
}
|
|
*code++ = -c;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
/* Data character: Reset and fall through */
|
|
|
|
ptr = oldptr;
|
|
c = '\\';
|
|
|
|
/* Handle a run of data characters until a metacharacter is encountered.
|
|
The first character is guaranteed not to be whitespace or # when the
|
|
extended flag is set. */
|
|
|
|
NORMAL_CHAR:
|
|
default:
|
|
previous = code;
|
|
*code = OP_CHARS;
|
|
code += 2;
|
|
length = 0;
|
|
|
|
do
|
|
{
|
|
if ((options & PCRE_EXTENDED) != 0)
|
|
{
|
|
if ((pcre_ctypes[c] & ctype_space) != 0) continue;
|
|
if (c == '#')
|
|
{
|
|
while ((c = *(++ptr)) != 0 && c != '\n');
|
|
if (c == 0) break;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/* Backslash may introduce a data char or a metacharacter. Escaped items
|
|
are checked for validity in the pre-compiling pass. Stop the string
|
|
before a metaitem. */
|
|
|
|
if (c == '\\')
|
|
{
|
|
oldptr = ptr;
|
|
c = check_escape(&ptr, errorptr, *brackets, options, FALSE);
|
|
if (c < 0) { ptr = oldptr; break; }
|
|
}
|
|
|
|
/* Ordinary character or single-char escape */
|
|
|
|
*code++ = c;
|
|
length++;
|
|
}
|
|
|
|
/* This "while" is the end of the "do" above. */
|
|
|
|
while (length < 255 && (pcre_ctypes[c = *(++ptr)] & ctype_meta) == 0);
|
|
|
|
/* Compute the length and set it in the data vector, and advance to
|
|
the next state. */
|
|
|
|
previous[1] = length;
|
|
if (length < 255) ptr--;
|
|
break;
|
|
}
|
|
} /* end of big loop */
|
|
|
|
/* Control never reaches here by falling through, only by a goto for all the
|
|
error states. Pass back the position in the pattern so that it can be displayed
|
|
to the user for diagnosing the error. */
|
|
|
|
FAILED:
|
|
*ptrptr = ptr;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*************************************************
|
|
* Compile sequence of alternatives *
|
|
*************************************************/
|
|
|
|
/* On entry, ptr is pointing past the bracket character, but on return
|
|
it points to the closing bracket, or vertical bar, or end of string.
|
|
The code variable is pointing at the byte into which the BRA operator has been
|
|
stored.
|
|
|
|
Argument:
|
|
options the option bits
|
|
brackets -> int containing the number of extracting brackets used
|
|
codeptr -> the address of the current code pointer
|
|
ptrptr -> the address of the current pattern pointer
|
|
errorptr -> pointer to error message
|
|
|
|
Returns: TRUE on success
|
|
*/
|
|
|
|
static BOOL
|
|
compile_regex(int options, int *brackets, uschar **codeptr,
|
|
const uschar **ptrptr, const char **errorptr, PyObject *dictionary)
|
|
{
|
|
const uschar *ptr = *ptrptr;
|
|
uschar *code = *codeptr;
|
|
uschar *start_bracket = code;
|
|
|
|
for (;;)
|
|
{
|
|
int length;
|
|
uschar *last_branch = code;
|
|
|
|
code += 3;
|
|
if (!compile_branch(options, brackets, &code, &ptr, errorptr, dictionary))
|
|
{
|
|
*ptrptr = ptr;
|
|
return FALSE;
|
|
}
|
|
|
|
/* Fill in the length of the last branch */
|
|
|
|
length = code - last_branch;
|
|
last_branch[1] = length >> 8;
|
|
last_branch[2] = length & 255;
|
|
|
|
/* Reached end of expression, either ')' or end of pattern. Insert a
|
|
terminating ket and the length of the whole bracketed item, and return,
|
|
leaving the pointer at the terminating char. */
|
|
|
|
if (*ptr != '|')
|
|
{
|
|
length = code - start_bracket;
|
|
*code++ = OP_KET;
|
|
*code++ = length >> 8;
|
|
*code++ = length & 255;
|
|
*codeptr = code;
|
|
*ptrptr = ptr;
|
|
return TRUE;
|
|
}
|
|
|
|
/* Another branch follows; insert an "or" node and advance the pointer. */
|
|
|
|
*code = OP_ALT;
|
|
ptr++;
|
|
}
|
|
/* Control never reaches here */
|
|
}
|
|
|
|
|
|
|
|
/*************************************************
|
|
* Check for anchored expression *
|
|
*************************************************/
|
|
|
|
/* Try to find out if this is an anchored regular expression. Consider each
|
|
alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket
|
|
all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then
|
|
it's anchored. However, if this is a multiline pattern, then only OP_SOD
|
|
counts, since OP_CIRC can match in the middle.
|
|
|
|
A branch is also implicitly anchored if it starts with .* because that will try
|
|
the rest of the pattern at all possible matching points, so there is no point
|
|
trying them again.
|
|
|
|
Argument: points to start of expression (the bracket)
|
|
Returns: TRUE or FALSE
|
|
*/
|
|
|
|
static BOOL
|
|
is_anchored(register const uschar *code, BOOL multiline)
|
|
{
|
|
do {
|
|
int op = (int)code[3];
|
|
if (op >= OP_BRA || op == OP_ASSERT || op == OP_ONCE)
|
|
{ if (!is_anchored(code+3, multiline)) return FALSE; }
|
|
else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR)
|
|
{ if (code[4] != OP_ANY) return FALSE; }
|
|
else if (op != OP_SOD && (multiline || op != OP_CIRC)) return FALSE;
|
|
code += (code[1] << 8) + code[2];
|
|
}
|
|
while (*code == OP_ALT);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
/*************************************************
|
|
* Check for start with \n line expression *
|
|
*************************************************/
|
|
|
|
/* This is called for multiline expressions to try to find out if every branch
|
|
starts with ^ so that "first char" processing can be done to speed things up.
|
|
|
|
Argument: points to start of expression (the bracket)
|
|
Returns: TRUE or FALSE
|
|
*/
|
|
|
|
static BOOL
|
|
is_startline(const uschar *code)
|
|
{
|
|
do {
|
|
if ((int)code[3] >= OP_BRA || code[3] == OP_ASSERT)
|
|
{ if (!is_startline(code+3)) return FALSE; }
|
|
else if (code[3] != OP_CIRC) return FALSE;
|
|
code += (code[1] << 8) + code[2];
|
|
}
|
|
while (*code == OP_ALT);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
/*************************************************
|
|
* Check for fixed first char *
|
|
*************************************************/
|
|
|
|
/* Try to find out if there is a fixed first character. This is called for
|
|
unanchored expressions, as it speeds up their processing quite considerably.
|
|
Consider each alternative branch. If they all start with the same char, or with
|
|
a bracket all of whose alternatives start with the same char (recurse ad lib),
|
|
then we return that char, otherwise -1.
|
|
|
|
Argument: points to start of expression (the bracket)
|
|
Returns: -1 or the fixed first char
|
|
*/
|
|
|
|
static int
|
|
find_firstchar(uschar *code)
|
|
{
|
|
register int c = -1;
|
|
do
|
|
{
|
|
register int charoffset = 4;
|
|
|
|
if ((int)code[3] >= OP_BRA || code[3] == OP_ASSERT)
|
|
{
|
|
register int d;
|
|
if ((d = find_firstchar(code+3)) < 0) return -1;
|
|
if (c < 0) c = d; else if (c != d) return -1;
|
|
}
|
|
|
|
else switch(code[3])
|
|
{
|
|
default:
|
|
return -1;
|
|
|
|
case OP_EXACT: /* Fall through */
|
|
charoffset++;
|
|
|
|
case OP_CHARS: /* Fall through */
|
|
charoffset++;
|
|
|
|
case OP_PLUS:
|
|
case OP_MINPLUS:
|
|
if (c < 0) c = code[charoffset]; else if (c != code[charoffset]) return -1;
|
|
break;
|
|
}
|
|
code += (code[1] << 8) + code[2];
|
|
}
|
|
while (*code == OP_ALT);
|
|
return c;
|
|
}
|
|
|
|
|
|
|
|
/*************************************************
|
|
* Compile a Regular Expression *
|
|
*************************************************/
|
|
|
|
/* This function takes a string and returns a pointer to a block of store
|
|
holding a compiled version of the expression.
|
|
|
|
Arguments:
|
|
pattern the regular expression
|
|
options various option bits
|
|
errorptr pointer to pointer to error text
|
|
erroroffset ptr offset in pattern where error was detected
|
|
|
|
Returns: pointer to compiled data block, or NULL on error,
|
|
with errorptr and erroroffset set
|
|
*/
|
|
|
|
pcre *
|
|
pcre_compile(const char *pattern, int options, const char **errorptr,
|
|
int *erroroffset, PyObject *dictionary)
|
|
{
|
|
real_pcre *re;
|
|
int spaces = 0;
|
|
int length = 3; /* For initial BRA plus length */
|
|
int runlength;
|
|
int c, size;
|
|
int bracount = 0;
|
|
int brastack[200];
|
|
int top_backref = 0;
|
|
unsigned int brastackptr = 0;
|
|
uschar *code;
|
|
const uschar *ptr;
|
|
|
|
#ifdef DEBUG
|
|
uschar *code_base, *code_end;
|
|
#endif
|
|
|
|
/* We can't pass back an error message if errorptr is NULL; I guess the best we
|
|
can do is just return NULL. */
|
|
|
|
if (errorptr == NULL) return NULL;
|
|
*errorptr = NULL;
|
|
|
|
/* However, we can give a message for this error */
|
|
|
|
if (erroroffset == NULL)
|
|
{
|
|
*errorptr = ERR16;
|
|
return NULL;
|
|
}
|
|
*erroroffset = 0;
|
|
|
|
if ((options & ~PUBLIC_OPTIONS) != 0)
|
|
{
|
|
*errorptr = ERR17;
|
|
return NULL;
|
|
}
|
|
|
|
DPRINTF(("------------------------------------------------------------------\n"));
|
|
DPRINTF(("%s\n", pattern));
|
|
|
|
/* The first thing to do is to make a pass over the pattern to compute the
|
|
amount of store required to hold the compiled code. This does not have to be
|
|
perfect as long as errors are overestimates. At the same time we can detect any
|
|
internal flag settings. Make an attempt to correct for any counted white space
|
|
if an "extended" flag setting appears late in the pattern. We can't be so
|
|
clever for #-comments. */
|
|
|
|
ptr = (const uschar *)(pattern - 1);
|
|
while ((c = *(++ptr)) != 0)
|
|
{
|
|
int min, max;
|
|
int class_charcount;
|
|
|
|
if ((pcre_ctypes[c] & ctype_space) != 0)
|
|
{
|
|
if ((options & PCRE_EXTENDED) != 0) continue;
|
|
spaces++;
|
|
}
|
|
|
|
if (c == '#' && (options & PCRE_EXTENDED) != 0)
|
|
{
|
|
while ((c = *(++ptr)) != 0 && c != '\n');
|
|
continue;
|
|
}
|
|
|
|
switch(c)
|
|
{
|
|
/* A backslashed item may be an escaped "normal" character or a
|
|
character type. For a "normal" character, put the pointers and
|
|
character back so that tests for whitespace etc. in the input
|
|
are done correctly. */
|
|
|
|
case '\\':
|
|
{
|
|
const uschar *save_ptr = ptr;
|
|
c = check_escape(&ptr, errorptr, bracount, options, FALSE);
|
|
if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
|
|
if (c >= 0)
|
|
{
|
|
ptr = save_ptr;
|
|
c = '\\';
|
|
goto NORMAL_CHAR;
|
|
}
|
|
}
|
|
length++;
|
|
|
|
/* A back reference needs an additional char, plus either one or 5
|
|
bytes for a repeat. We also need to keep the value of the highest
|
|
back reference. */
|
|
|
|
if (c <= -ESC_REF)
|
|
{
|
|
int refnum = -c - ESC_REF;
|
|
if (refnum > top_backref) top_backref = refnum;
|
|
length++; /* For single back reference */
|
|
if (ptr[1] == '{' && is_counted_repeat(ptr+2))
|
|
{
|
|
ptr = read_repeat_counts(ptr+2, &min, &max, errorptr);
|
|
if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
|
|
if ((min == 0 && (max == 1 || max == -1)) ||
|
|
(min == 1 && max == -1))
|
|
length++;
|
|
else length += 5;
|
|
if (ptr[1] == '?') ptr++;
|
|
}
|
|
}
|
|
continue;
|
|
|
|
case '^':
|
|
case '.':
|
|
case '$':
|
|
case '*': /* These repeats won't be after brackets; */
|
|
case '+': /* those are handled separately */
|
|
case '?':
|
|
length++;
|
|
continue;
|
|
|
|
/* This covers the cases of repeats after a single char, metachar, class,
|
|
or back reference. */
|
|
|
|
case '{':
|
|
if (!is_counted_repeat(ptr+1)) goto NORMAL_CHAR;
|
|
ptr = read_repeat_counts(ptr+1, &min, &max, errorptr);
|
|
if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
|
|
if ((min == 0 && (max == 1 || max == -1)) ||
|
|
(min == 1 && max == -1))
|
|
length++;
|
|
else
|
|
{
|
|
length--; /* Uncount the original char or metachar */
|
|
if (min == 1) length++; else if (min > 0) length += 4;
|
|
if (max > 0) length += 4; else length += 2;
|
|
}
|
|
if (ptr[1] == '?') ptr++;
|
|
continue;
|
|
|
|
/* An alternation contains an offset to the next branch or ket. */
|
|
case '|':
|
|
length += 3;
|
|
continue;
|
|
|
|
/* A character class uses 33 characters. Don't worry about character types
|
|
that aren't allowed in classes - they'll get picked up during the compile.
|
|
A character class that contains only one character uses 2 or 3 bytes,
|
|
depending on whether it is negated or not. Notice this where we can. */
|
|
|
|
case '[':
|
|
class_charcount = 0;
|
|
if (*(++ptr) == '^') ptr++;
|
|
do
|
|
{
|
|
if (*ptr == '\\')
|
|
{
|
|
int ch = check_escape(&ptr, errorptr, bracount, options, TRUE);
|
|
if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
|
|
if (-ch == ESC_b) class_charcount++; else class_charcount = 10;
|
|
}
|
|
else class_charcount++;
|
|
ptr++;
|
|
}
|
|
while (*ptr != 0 && *ptr != ']');
|
|
|
|
/* Repeats for negated single chars are handled by the general code */
|
|
|
|
if (class_charcount == 1) length += 3; else
|
|
{
|
|
length += 33;
|
|
if (options & PCRE_LOCALE) length++; /* Add a byte for the localization flag */
|
|
|
|
/* A repeat needs either 1 or 5 bytes. */
|
|
|
|
if (*ptr != 0 && ptr[1] == '{' && is_counted_repeat(ptr+2))
|
|
{
|
|
ptr = read_repeat_counts(ptr+2, &min, &max, errorptr);
|
|
if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
|
|
if ((min == 0 && (max == 1 || max == -1)) ||
|
|
(min == 1 && max == -1))
|
|
length++;
|
|
else length += 5;
|
|
if (ptr[1] == '?') ptr++;
|
|
}
|
|
}
|
|
continue;
|
|
|
|
/* Brackets may be genuine groups or special things */
|
|
|
|
case '(':
|
|
|
|
/* Handle special forms of bracket, which all start (? */
|
|
|
|
if (ptr[1] == '?') switch (c = ptr[2])
|
|
{
|
|
/* Skip over comments entirely */
|
|
case '#':
|
|
ptr += 3;
|
|
while (*ptr != 0 && *ptr != ')') ptr++;
|
|
if (*ptr == 0)
|
|
{
|
|
*errorptr = ERR18;
|
|
goto PCRE_ERROR_RETURN;
|
|
}
|
|
continue;
|
|
|
|
/* Non-referencing groups and lookaheads just move the pointer on, and
|
|
then behave like a non-special bracket, except that they don't increment
|
|
the count of extracting brackets. */
|
|
|
|
case ':':
|
|
case '=':
|
|
case '!':
|
|
ptr += 2;
|
|
break;
|
|
|
|
case ('P'):
|
|
{
|
|
int idlen;
|
|
switch (*ptr++) {
|
|
case ('<'):
|
|
idlen = get_group_id(ptr++, '>', errorptr);
|
|
if (*errorptr) goto PCRE_ERROR_RETURN;
|
|
ptr += idlen+1;
|
|
break;
|
|
case ('='):
|
|
idlen = get_group_id(ptr++, ')', errorptr);
|
|
if (*errorptr) goto PCRE_ERROR_RETURN;
|
|
ptr += idlen+1;
|
|
length++;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* Ditto for the "once only" bracket, allowed only if the extra bit
|
|
is set. */
|
|
|
|
case '>':
|
|
if ((options & PCRE_EXTRA) != 0)
|
|
{
|
|
ptr += 2;
|
|
break;
|
|
}
|
|
/* Else fall through */
|
|
|
|
/* Else loop setting valid options until ) is met. Anything else is an
|
|
error. */
|
|
|
|
default:
|
|
ptr += 2;
|
|
for (;; ptr++)
|
|
{
|
|
if ((c = *ptr) == 'i')
|
|
{
|
|
options |= PCRE_CASELESS;
|
|
continue;
|
|
}
|
|
else if ((c = *ptr) == 'L')
|
|
{
|
|
options |= PCRE_LOCALE;
|
|
continue;
|
|
}
|
|
else if ((c = *ptr) == 'm')
|
|
{
|
|
options |= PCRE_MULTILINE;
|
|
continue;
|
|
}
|
|
else if (c == 's')
|
|
{
|
|
options |= PCRE_DOTALL;
|
|
continue;
|
|
}
|
|
else if (c == 'x')
|
|
{
|
|
options |= PCRE_EXTENDED;
|
|
length -= spaces; /* Already counted spaces */
|
|
continue;
|
|
}
|
|
else if (c == ')') break;
|
|
|
|
*errorptr = ERR12;
|
|
goto PCRE_ERROR_RETURN;
|
|
}
|
|
continue; /* End of this bracket handling */
|
|
}
|
|
|
|
/* Extracting brackets must be counted so we can process escapes in a
|
|
Perlish way. */
|
|
|
|
else bracount++;
|
|
|
|
/* Non-special forms of bracket. Save length for computing whole length
|
|
at end if there's a repeat that requires duplication of the group. */
|
|
|
|
if (brastackptr >= sizeof(brastack)/sizeof(int))
|
|
{
|
|
*errorptr = ERR19;
|
|
goto PCRE_ERROR_RETURN;
|
|
}
|
|
|
|
brastack[brastackptr++] = length;
|
|
length += 3;
|
|
continue;
|
|
|
|
/* Handle ket. Look for subsequent max/min; for certain sets of values we
|
|
have to replicate this bracket up to that many times. If brastackptr is
|
|
0 this is an unmatched bracket which will generate an error, but take care
|
|
not to try to access brastack[-1]. */
|
|
|
|
case ')':
|
|
length += 3;
|
|
{
|
|
int minval = 1;
|
|
int maxval = 1;
|
|
int duplength = (brastackptr > 0)? length - brastack[--brastackptr] : 0;
|
|
|
|
/* Leave ptr at the final char; for read_repeat_counts this happens
|
|
automatically; for the others we need an increment. */
|
|
|
|
if ((c = ptr[1]) == '{' && is_counted_repeat(ptr+2))
|
|
{
|
|
ptr = read_repeat_counts(ptr+2, &minval, &maxval, errorptr);
|
|
if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
|
|
}
|
|
else if (c == '*') { minval = 0; maxval = -1; ptr++; }
|
|
else if (c == '+') { maxval = -1; ptr++; }
|
|
else if (c == '?') { minval = 0; ptr++; }
|
|
|
|
/* If there is a minimum > 1 we have to replicate up to minval-1 times;
|
|
if there is a limited maximum we have to replicate up to maxval-1 times
|
|
and allow for a BRAZERO item before each optional copy, as we also have
|
|
to do before the first copy if the minimum is zero. */
|
|
|
|
if (minval == 0) length++;
|
|
else if (minval > 1) length += (minval - 1) * duplength;
|
|
if (maxval > minval) length += (maxval - minval) * (duplength + 1);
|
|
}
|
|
continue;
|
|
|
|
/* Non-special character. For a run of such characters the length required
|
|
is the number of characters + 2, except that the maximum run length is 255.
|
|
We won't get a skipped space or a non-data escape or the start of a #
|
|
comment as the first character, so the length can't be zero. */
|
|
|
|
NORMAL_CHAR:
|
|
default:
|
|
length += 2;
|
|
runlength = 0;
|
|
do
|
|
{
|
|
if ((pcre_ctypes[c] & ctype_space) != 0)
|
|
{
|
|
if ((options & PCRE_EXTENDED) != 0) continue;
|
|
spaces++;
|
|
}
|
|
|
|
if (c == '#' && (options & PCRE_EXTENDED) != 0)
|
|
{
|
|
while ((c = *(++ptr)) != 0 && c != '\n');
|
|
continue;
|
|
}
|
|
|
|
/* Backslash may introduce a data char or a metacharacter; stop the
|
|
string before the latter. */
|
|
|
|
if (c == '\\')
|
|
{
|
|
const uschar *saveptr = ptr;
|
|
c = check_escape(&ptr, errorptr, bracount, options, FALSE);
|
|
if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
|
|
if (c < 0) { ptr = saveptr; break; }
|
|
}
|
|
|
|
/* Ordinary character or single-char escape */
|
|
|
|
runlength++;
|
|
}
|
|
|
|
/* This "while" is the end of the "do" above. */
|
|
|
|
while (runlength < 255 && (pcre_ctypes[c = *(++ptr)] & ctype_meta) == 0);
|
|
|
|
ptr--;
|
|
length += runlength;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
length += 4; /* For final KET and END */
|
|
|
|
if (length > 65539)
|
|
{
|
|
*errorptr = ERR20;
|
|
return NULL;
|
|
}
|
|
|
|
/* Compute the size of data block needed and get it, either from malloc or
|
|
externally provided function. We specify "code[0]" in the offsetof() expression
|
|
rather than just "code", because it has been reported that one broken compiler
|
|
fails on "code" because it is also an independent variable. It should make no
|
|
difference to the value of the offsetof(). */
|
|
|
|
size = length + offsetof(real_pcre, code[0]);
|
|
re = (real_pcre *)(pcre_malloc)(size+50);
|
|
|
|
if (re == NULL)
|
|
{
|
|
*errorptr = ERR21;
|
|
return NULL;
|
|
}
|
|
|
|
/* Put in the magic number and the options. */
|
|
|
|
re->magic_number = MAGIC_NUMBER;
|
|
re->options = options;
|
|
|
|
/* Set up a starting, non-extracting bracket, then compile the expression. On
|
|
error, *errorptr will be set non-NULL, so we don't need to look at the result
|
|
of the function here. */
|
|
|
|
ptr = (const uschar *)pattern;
|
|
code = re->code;
|
|
*code = OP_BRA;
|
|
bracount = 0;
|
|
(void)compile_regex(options, &bracount, &code, &ptr, errorptr, dictionary);
|
|
re->top_bracket = bracount;
|
|
re->top_backref = top_backref;
|
|
|
|
/* If not reached end of pattern on success, there's an excess bracket. */
|
|
|
|
if (*errorptr == NULL && *ptr != 0) *errorptr = ERR22;
|
|
|
|
/* Fill in the terminating state and check for disastrous overflow, but
|
|
if debugging, leave the test till after things are printed out. */
|
|
|
|
*code++ = OP_END;
|
|
|
|
|
|
#ifndef DEBUG
|
|
if (code - re->code > length) *errorptr = ERR23;
|
|
#endif
|
|
|
|
/* Failed to compile */
|
|
|
|
if (*errorptr != NULL)
|
|
{
|
|
(pcre_free)(re);
|
|
PCRE_ERROR_RETURN:
|
|
*erroroffset = ptr - (const uschar *)pattern;
|
|
return NULL;
|
|
}
|
|
|
|
/* If the anchored option was not passed, set flag if we can determine that it
|
|
is anchored by virtue of ^ characters or \A or anything else. Otherwise, see if
|
|
we can determine what the first character has to be, because that speeds up
|
|
unanchored matches no end. In the case of multiline matches, an alternative is
|
|
to set the PCRE_STARTLINE flag if all branches start with ^. */
|
|
|
|
if ((options & PCRE_ANCHORED) == 0)
|
|
{
|
|
if (is_anchored(re->code, (options & PCRE_MULTILINE) != 0))
|
|
re->options |= PCRE_ANCHORED;
|
|
else
|
|
{
|
|
int ch = find_firstchar(re->code);
|
|
if (ch >= 0)
|
|
{
|
|
re->first_char = ch;
|
|
re->options |= PCRE_FIRSTSET;
|
|
}
|
|
else if (is_startline(re->code))
|
|
re->options |= PCRE_STARTLINE;
|
|
}
|
|
}
|
|
|
|
/* Print out the compiled data for debugging */
|
|
|
|
#ifdef DEBUG
|
|
|
|
printf("Length = %d top_bracket = %d top_backref=%d\n",
|
|
length, re->top_bracket, re->top_backref);
|
|
|
|
if (re->options != 0)
|
|
{
|
|
printf("%s%s%s%s%s%s%s%s\n",
|
|
((re->options & PCRE_ANCHORED) != 0)? "anchored " : "",
|
|
((re->options & PCRE_CASELESS) != 0)? "caseless " : "",
|
|
((re->options & PCRE_EXTENDED) != 0)? "extended " : "",
|
|
((re->options & PCRE_MULTILINE) != 0)? "multiline " : "",
|
|
((re->options & PCRE_DOTALL) != 0)? "dotall " : "",
|
|
((re->options & PCRE_DOLLAR_ENDONLY) != 0)? "endonly " : "",
|
|
((re->options & PCRE_EXTRA) != 0)? "extra " : "",
|
|
((re->options & PCRE_UNGREEDY) != 0)? "ungreedy " : "");
|
|
}
|
|
|
|
if ((re->options & PCRE_FIRSTSET) != 0)
|
|
{
|
|
if (isprint(re->first_char)) printf("First char = %c\n", re->first_char);
|
|
else printf("First char = \\x%02x\n", re->first_char);
|
|
}
|
|
|
|
code_end = code;
|
|
code_base = code = re->code;
|
|
|
|
while (code < code_end)
|
|
{
|
|
int charlength;
|
|
|
|
printf("%3d ", code - code_base);
|
|
|
|
if (*code >= OP_BRA)
|
|
{
|
|
printf("%3d Bra %d", (code[1] << 8) + code[2], *code - OP_BRA);
|
|
code += 2;
|
|
}
|
|
|
|
else switch(*code)
|
|
{
|
|
case OP_CHARS:
|
|
charlength = *(++code);
|
|
printf("%3d ", charlength);
|
|
while (charlength-- > 0)
|
|
if (isprint(c = *(++code))) printf("%c", c); else printf("\\x%02x", c);
|
|
break;
|
|
|
|
case OP_KETRMAX:
|
|
case OP_KETRMIN:
|
|
case OP_ALT:
|
|
case OP_KET:
|
|
case OP_ASSERT:
|
|
case OP_ASSERT_NOT:
|
|
case OP_ONCE:
|
|
printf("%3d %s", (code[1] << 8) + code[2], OP_names[*code]);
|
|
code += 2;
|
|
break;
|
|
|
|
case OP_STAR:
|
|
case OP_MINSTAR:
|
|
case OP_PLUS:
|
|
case OP_MINPLUS:
|
|
case OP_QUERY:
|
|
case OP_MINQUERY:
|
|
case OP_TYPESTAR:
|
|
case OP_TYPEMINSTAR:
|
|
case OP_TYPEPLUS:
|
|
case OP_TYPEMINPLUS:
|
|
case OP_TYPEQUERY:
|
|
case OP_TYPEMINQUERY:
|
|
if (*code >= OP_TYPESTAR)
|
|
printf(" %s", OP_names[code[1]]);
|
|
else if (isprint(c = code[1])) printf(" %c", c);
|
|
else printf(" \\x%02x", c);
|
|
printf("%s", OP_names[*code++]);
|
|
break;
|
|
|
|
case OP_EXACT:
|
|
case OP_UPTO:
|
|
case OP_MINUPTO:
|
|
if (isprint(c = code[3])) printf(" %c{", c);
|
|
else printf(" \\x%02x{", c);
|
|
if (*code != OP_EXACT) printf("0,");
|
|
printf("%d}", (code[1] << 8) + code[2]);
|
|
if (*code == OP_MINUPTO) printf("?");
|
|
code += 3;
|
|
break;
|
|
|
|
case OP_TYPEEXACT:
|
|
case OP_TYPEUPTO:
|
|
case OP_TYPEMINUPTO:
|
|
printf(" %s{", OP_names[code[3]]);
|
|
if (*code != OP_TYPEEXACT) printf(",");
|
|
printf("%d}", (code[1] << 8) + code[2]);
|
|
if (*code == OP_TYPEMINUPTO) printf("?");
|
|
code += 3;
|
|
break;
|
|
|
|
case OP_NOT:
|
|
if (isprint(c = *(++code))) printf(" [^%c]", c);
|
|
else printf(" [^\\x%02x]", c);
|
|
break;
|
|
|
|
case OP_NOTSTAR:
|
|
case OP_NOTMINSTAR:
|
|
case OP_NOTPLUS:
|
|
case OP_NOTMINPLUS:
|
|
case OP_NOTQUERY:
|
|
case OP_NOTMINQUERY:
|
|
if (isprint(c = code[1])) printf(" [^%c]", c);
|
|
else printf(" [^\\x%02x]", c);
|
|
printf("%s", OP_names[*code++]);
|
|
break;
|
|
|
|
case OP_NOTEXACT:
|
|
case OP_NOTUPTO:
|
|
case OP_NOTMINUPTO:
|
|
if (isprint(c = code[3])) printf(" [^%c]{", c);
|
|
else printf(" [^\\x%02x]{", c);
|
|
if (*code != OP_NOTEXACT) printf(",");
|
|
printf("%d}", (code[1] << 8) + code[2]);
|
|
if (*code == OP_NOTMINUPTO) printf("?");
|
|
code += 3;
|
|
break;
|
|
|
|
case OP_REF:
|
|
printf(" \\%d", *(++code));
|
|
code ++;
|
|
goto CLASS_REF_REPEAT;
|
|
|
|
case OP_CLASS:
|
|
case OP_NEGCLASS:
|
|
case OP_CLASS_L:
|
|
{
|
|
int i, min, max;
|
|
|
|
if (*code==OP_CLASS_L)
|
|
{
|
|
code++;
|
|
printf("Locflag = %i ", *code++);
|
|
printf(" [");
|
|
}
|
|
else
|
|
{
|
|
if (*code++ == OP_CLASS) printf(" [");
|
|
else printf(" ^[");
|
|
}
|
|
|
|
|
|
for (i = 0; i < 256; i++)
|
|
{
|
|
if ((code[i/8] & (1 << (i&7))) != 0)
|
|
{
|
|
int j;
|
|
for (j = i+1; j < 256; j++)
|
|
if ((code[j/8] & (1 << (j&7))) == 0) break;
|
|
if (i == '-' || i == ']') printf("\\");
|
|
if (isprint(i)) printf("%c", i); else printf("\\x%02x", i);
|
|
if (--j > i)
|
|
{
|
|
printf("-");
|
|
if (j == '-' || j == ']') printf("\\");
|
|
if (isprint(j)) printf("%c", j); else printf("\\x%02x", j);
|
|
}
|
|
i = j;
|
|
}
|
|
}
|
|
printf("]");
|
|
code += 32;
|
|
/* code ++;*/
|
|
|
|
CLASS_REF_REPEAT:
|
|
|
|
switch(*code)
|
|
{
|
|
case OP_CRSTAR:
|
|
case OP_CRMINSTAR:
|
|
case OP_CRPLUS:
|
|
case OP_CRMINPLUS:
|
|
case OP_CRQUERY:
|
|
case OP_CRMINQUERY:
|
|
printf("%s", OP_names[*code]);
|
|
break;
|
|
|
|
case OP_CRRANGE:
|
|
case OP_CRMINRANGE:
|
|
min = (code[1] << 8) + code[2];
|
|
max = (code[3] << 8) + code[4];
|
|
if (max == 0) printf("{%d,}", min);
|
|
else printf("{%d,%d}", min, max);
|
|
if (*code == OP_CRMINRANGE) printf("?");
|
|
code += 4;
|
|
break;
|
|
|
|
default:
|
|
code--;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* Anything else is just a one-node item */
|
|
|
|
default:
|
|
printf(" %s", OP_names[*code]);
|
|
break;
|
|
}
|
|
|
|
code++;
|
|
printf("\n");
|
|
}
|
|
printf("------------------------------------------------------------------\n");
|
|
|
|
/* This check is done here in the debugging case so that the code that
|
|
was compiled can be seen. */
|
|
|
|
if (code - re->code > length)
|
|
{
|
|
printf("length=%i, code length=%i\n", length, code-re->code);
|
|
*errorptr = ERR23;
|
|
(pcre_free)(re);
|
|
*erroroffset = ptr - (uschar *)pattern;
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
return (pcre *)re;
|
|
}
|
|
|
|
|
|
|
|
/*************************************************
|
|
* Match a character type *
|
|
*************************************************/
|
|
|
|
/* Not used in all the places it might be as it's sometimes faster
|
|
to put the code inline.
|
|
|
|
Arguments:
|
|
type the character type
|
|
c the character
|
|
dotall the dotall flag
|
|
|
|
Returns: TRUE if character is of the type
|
|
*/
|
|
|
|
static BOOL
|
|
match_type(int type, int c, BOOL dotall)
|
|
{
|
|
|
|
#ifdef DEBUG
|
|
if (isprint(c)) printf("matching subject %c against ", c);
|
|
else printf("matching subject \\x%02x against ", c);
|
|
printf("%s\n", OP_names[type]);
|
|
#endif
|
|
|
|
switch(type)
|
|
{
|
|
case OP_ANY: return dotall || c != '\n';
|
|
case OP_NOT_DIGIT: return (pcre_ctypes[c] & ctype_digit) == 0;
|
|
case OP_DIGIT: return (pcre_ctypes[c] & ctype_digit) != 0;
|
|
case OP_NOT_WHITESPACE: return (pcre_ctypes[c] & ctype_space) == 0;
|
|
case OP_WHITESPACE: return (pcre_ctypes[c] & ctype_space) != 0;
|
|
case OP_NOT_WORDCHAR: return (pcre_ctypes[c] & ctype_word) == 0;
|
|
case OP_WORDCHAR: return (pcre_ctypes[c] & ctype_word) != 0;
|
|
case OP_NOT_WORDCHAR_L: return (c!='_' && !isalnum(c));
|
|
case OP_WORDCHAR_L: return (c=='_' || isalnum(c));
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
/*************************************************
|
|
* Match a back-reference *
|
|
*************************************************/
|
|
|
|
/* If a back reference hasn't been set, the match fails.
|
|
|
|
Arguments:
|
|
number reference number
|
|
eptr points into the subject
|
|
length length to be matched
|
|
md points to match data block
|
|
|
|
Returns: TRUE if matched
|
|
*/
|
|
|
|
static BOOL
|
|
match_ref(int number, register const uschar *eptr, int length, match_data *md)
|
|
{
|
|
const uschar *p = md->start_subject + md->offset_vector[number];
|
|
|
|
#ifdef DEBUG
|
|
if (eptr >= md->end_subject)
|
|
printf("matching subject <null>");
|
|
else
|
|
{
|
|
printf("matching subject ");
|
|
pchars(eptr, length, TRUE, md);
|
|
}
|
|
printf(" against backref ");
|
|
pchars(p, length, FALSE, md);
|
|
printf("\n");
|
|
#endif
|
|
|
|
/* Always fail if not enough characters left */
|
|
|
|
if (length > md->end_subject - p) return FALSE;
|
|
|
|
/* Separate the caseless case for speed */
|
|
|
|
if (md->caseless)
|
|
{ while (length-- > 0) if (pcre_lcc[*p++] != pcre_lcc[*eptr++]) return FALSE; }
|
|
else
|
|
{ while (length-- > 0) if (*p++ != *eptr++) return FALSE; }
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static int free_stack(match_data *md)
|
|
{
|
|
/* Free any stack space that was allocated by the call to match(). */
|
|
if (md->off_num) free(md->off_num);
|
|
if (md->offset_top) free(md->offset_top);
|
|
if (md->r1) free(md->r1);
|
|
if (md->r2) free(md->r2);
|
|
if (md->eptr) free((char *)md->eptr);
|
|
if (md->ecode) free((char *)md->ecode);
|
|
return 0;
|
|
}
|
|
|
|
static int grow_stack(match_data *md)
|
|
{
|
|
if (md->length != 0)
|
|
{
|
|
md->length = md->length + md->length/2;
|
|
}
|
|
else
|
|
{
|
|
int string_len = md->end_subject - md->start_subject + 1;
|
|
if (string_len < 80) {md->length = string_len; }
|
|
else {md->length = 80;}
|
|
}
|
|
PyMem_RESIZE(md->offset_top, int, md->length);
|
|
PyMem_RESIZE(md->eptr, const uschar *, md->length);
|
|
PyMem_RESIZE(md->ecode, const uschar *, md->length);
|
|
PyMem_RESIZE(md->off_num, int, md->length);
|
|
PyMem_RESIZE(md->r1, int, md->length);
|
|
PyMem_RESIZE(md->r2, int, md->length);
|
|
if (md->offset_top == NULL || md->eptr == NULL || md->ecode == NULL ||
|
|
md->off_num == NULL || md->r1 == NULL || md->r2 == NULL)
|
|
{
|
|
PyErr_NoMemory();
|
|
longjmp(md->error_env, 1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*************************************************
|
|
* Match from current position *
|
|
*************************************************/
|
|
|
|
/* On entry ecode points to the first opcode, and eptr to the first character.
|
|
|
|
Arguments:
|
|
eptr pointer in subject
|
|
ecode position in code
|
|
offset_top current top pointer
|
|
md pointer to "static" info for the match
|
|
|
|
Returns: TRUE if matched
|
|
*/
|
|
|
|
static BOOL
|
|
match(register const uschar *eptr, register const uschar *ecode, int offset_top,
|
|
match_data *md)
|
|
{
|
|
int save_stack_position = md->point;
|
|
match_loop:
|
|
|
|
#define SUCCEED goto succeed
|
|
#define FAIL goto fail
|
|
|
|
for (;;)
|
|
{
|
|
int min, max, ctype;
|
|
register int i;
|
|
register int c;
|
|
BOOL minimize = FALSE;
|
|
|
|
/* Opening bracket. Check the alternative branches in turn, failing if none
|
|
match. We have to set the start offset if required and there is space
|
|
in the offset vector so that it is available for subsequent back references
|
|
if the bracket matches. However, if the bracket fails, we must put back the
|
|
previous value of both offsets in case they were set by a previous copy of
|
|
the same bracket. Don't worry about setting the flag for the error case here;
|
|
that is handled in the code for KET. */
|
|
|
|
if ((int)*ecode >= OP_BRA)
|
|
{
|
|
int number = (*ecode - OP_BRA) << 1;
|
|
int save_offset1 = 0, save_offset2 = 0;
|
|
|
|
DPRINTF(("start bracket %d\n", number/2));
|
|
|
|
if (number > 0 && number < md->offset_end)
|
|
{
|
|
save_offset1 = md->offset_vector[number];
|
|
save_offset2 = md->offset_vector[number+1];
|
|
md->offset_vector[number] = eptr - md->start_subject;
|
|
|
|
DPRINTF(("saving %d %d\n", save_offset1, save_offset2));
|
|
}
|
|
|
|
/* Recurse for all the alternatives. */
|
|
|
|
do
|
|
{
|
|
if (match(eptr, ecode+3, offset_top, md)) SUCCEED;
|
|
ecode += (ecode[1] << 8) + ecode[2];
|
|
}
|
|
while (*ecode == OP_ALT);
|
|
|
|
DPRINTF(("bracket %d failed\n", number/2));
|
|
|
|
if (number > 0 && number < md->offset_end)
|
|
{
|
|
md->offset_vector[number] = save_offset1;
|
|
md->offset_vector[number+1] = save_offset2;
|
|
}
|
|
|
|
FAIL;
|
|
}
|
|
|
|
/* Other types of node can be handled by a switch */
|
|
|
|
switch(*ecode)
|
|
{
|
|
case OP_END:
|
|
md->end_match_ptr = eptr; /* Record where we ended */
|
|
md->end_offset_top = offset_top; /* and how many extracts were taken */
|
|
SUCCEED;
|
|
|
|
/* The equivalent of Prolog's "cut" - if the rest doesn't match, the
|
|
whole thing doesn't match, so we have to get out via a longjmp(). */
|
|
|
|
case OP_CUT:
|
|
if (match(eptr, ecode+1, offset_top, md)) SUCCEED;
|
|
longjmp(md->fail_env, 1);
|
|
|
|
/* Assertion brackets. Check the alternative branches in turn - the
|
|
matching won't pass the KET for an assertion. If any one branch matches,
|
|
the assertion is true. */
|
|
|
|
case OP_ASSERT:
|
|
do
|
|
{
|
|
if (match(eptr, ecode+3, offset_top, md)) break;
|
|
ecode += (ecode[1] << 8) + ecode[2];
|
|
}
|
|
while (*ecode == OP_ALT);
|
|
if (*ecode == OP_KET) FAIL;
|
|
|
|
/* Continue from after the assertion, updating the offsets high water
|
|
mark, since extracts may have been taken during the assertion. */
|
|
|
|
do ecode += (ecode[1] << 8) + ecode[2]; while (*ecode == OP_ALT);
|
|
ecode += 3;
|
|
offset_top = md->end_offset_top;
|
|
continue;
|
|
|
|
/* Negative assertion: all branches must fail to match */
|
|
|
|
case OP_ASSERT_NOT:
|
|
do
|
|
{
|
|
if (match(eptr, ecode+3, offset_top, md)) FAIL;
|
|
ecode += (ecode[1] << 8) + ecode[2];
|
|
}
|
|
while (*ecode == OP_ALT);
|
|
ecode += 3;
|
|
continue;
|
|
|
|
/* "Once" brackets are like assertion brackets except that after a match,
|
|
the point in the subject string is not moved back. Thus there can never be
|
|
a move back into the brackets. Check the alternative branches in turn - the
|
|
matching won't pass the KET for this kind of subpattern. If any one branch
|
|
matches, we carry on, leaving the subject pointer. */
|
|
|
|
case OP_ONCE:
|
|
do
|
|
{
|
|
if (match(eptr, ecode+3, offset_top, md)) break;
|
|
ecode += (ecode[1] << 8) + ecode[2];
|
|
}
|
|
while (*ecode == OP_ALT);
|
|
if (*ecode == OP_KET) FAIL;
|
|
|
|
/* Continue as from after the assertion, updating the offsets high water
|
|
mark, since extracts may have been taken. */
|
|
|
|
do ecode += (ecode[1] << 8) + ecode[2]; while (*ecode == OP_ALT);
|
|
ecode += 3;
|
|
offset_top = md->end_offset_top;
|
|
eptr = md->end_match_ptr;
|
|
continue;
|
|
|
|
/* An alternation is the end of a branch; scan along to find the end of the
|
|
bracketed group and go to there. */
|
|
|
|
case OP_ALT:
|
|
do ecode += (ecode[1] << 8) + ecode[2]; while (*ecode == OP_ALT);
|
|
break;
|
|
|
|
/* BRAZERO and BRAMINZERO occur just before a bracket group, indicating
|
|
that it may occur zero times. It may repeat infinitely, or not at all -
|
|
i.e. it could be ()* or ()? in the pattern. Brackets with fixed upper
|
|
repeat limits are compiled as a number of copies, with the optional ones
|
|
preceded by BRAZERO or BRAMINZERO. */
|
|
|
|
case OP_BRAZERO:
|
|
{
|
|
const uschar *next = ecode+1;
|
|
if (match(eptr, next, offset_top, md)) SUCCEED;
|
|
do next += (next[1] << 8) + next[2]; while (*next == OP_ALT);
|
|
ecode = next + 3;
|
|
}
|
|
break;
|
|
|
|
case OP_BRAMINZERO:
|
|
{
|
|
const uschar *next = ecode+1;
|
|
do next += (next[1] << 8) + next[2]; while (*next == OP_ALT);
|
|
if (match(eptr, next+3, offset_top, md)) SUCCEED;
|
|
ecode++;
|
|
}
|
|
break;;
|
|
|
|
/* End of a group, repeated or non-repeating. If we are at the end of
|
|
an assertion "group", stop matching and SUCCEED, but record the
|
|
current high water mark for use by positive assertions. */
|
|
|
|
case OP_KET:
|
|
case OP_KETRMIN:
|
|
case OP_KETRMAX:
|
|
{
|
|
int number;
|
|
const uschar *prev = ecode - (ecode[1] << 8) - ecode[2];
|
|
|
|
if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT || *prev == OP_ONCE)
|
|
{
|
|
md->end_match_ptr = eptr; /* For ONCE */
|
|
md->end_offset_top = offset_top;
|
|
SUCCEED;
|
|
}
|
|
|
|
/* In all other cases we have to check the group number back at the
|
|
start and if necessary complete handling an extraction by setting the
|
|
final offset and bumping the high water mark. */
|
|
|
|
number = (*prev - OP_BRA) << 1;
|
|
|
|
DPRINTF(("end bracket %d\n", number/2));
|
|
|
|
if (number > 0)
|
|
{
|
|
if (number >= md->offset_end) md->offset_overflow = TRUE; else
|
|
{
|
|
md->offset_vector[number+1] = eptr - md->start_subject;
|
|
if (offset_top <= number) offset_top = number + 2;
|
|
}
|
|
}
|
|
|
|
/* For a non-repeating ket, just advance to the next node and continue at
|
|
this level. */
|
|
|
|
if (*ecode == OP_KET)
|
|
{
|
|
ecode += 3;
|
|
break;
|
|
}
|
|
|
|
/* The repeating kets try the rest of the pattern or restart from the
|
|
preceding bracket, in the appropriate order. */
|
|
|
|
if (*ecode == OP_KETRMIN)
|
|
{
|
|
const uschar *ptr;
|
|
if (match(eptr, ecode+3, offset_top, md)) goto succeed;
|
|
/* Handle alternation inside the BRA...KET; push the additional
|
|
alternatives onto the stack */
|
|
ptr=prev;
|
|
do {
|
|
ptr += (ptr[1]<<8)+ ptr[2];
|
|
if (*ptr==OP_ALT)
|
|
{
|
|
if (md->length == md->point)
|
|
{
|
|
grow_stack(md);
|
|
}
|
|
md->offset_top[md->point] = offset_top;
|
|
md->eptr[md->point] = eptr;
|
|
md->ecode[md->point] = ptr+3;
|
|
md->r1[md->point] = 0;
|
|
md->r2[md->point] = 0;
|
|
md->off_num[md->point] = 0;
|
|
md->point++;
|
|
}
|
|
} while (*ptr==OP_ALT);
|
|
ecode=prev+3; goto match_loop;
|
|
}
|
|
else /* OP_KETRMAX */
|
|
{
|
|
const uschar *ptr;
|
|
/*int points_pushed=0;*/
|
|
|
|
/* Push one failure point, that will resume matching at the code after
|
|
the KETRMAX opcode. */
|
|
if (md->length == md->point)
|
|
{
|
|
grow_stack(md);
|
|
}
|
|
md->offset_top[md->point] = offset_top;
|
|
md->eptr[md->point] = eptr;
|
|
md->ecode[md->point] = ecode+3;
|
|
md->r1[md->point] = md->offset_vector[number];
|
|
md->r2[md->point] = md->offset_vector[number+1];
|
|
md->off_num[md->point] = number;
|
|
md->point++;
|
|
|
|
md->offset_vector[number] = eptr - md->start_subject;
|
|
/* Handle alternation inside the BRA...KET; push each of the
|
|
additional alternatives onto the stack */
|
|
ptr=prev;
|
|
do {
|
|
ptr += (ptr[1]<<8)+ ptr[2];
|
|
if (*ptr==OP_ALT)
|
|
{
|
|
if (md->length == md->point)
|
|
if (md->length == md->point)
|
|
{
|
|
grow_stack(md);
|
|
}
|
|
md->offset_top[md->point] = offset_top;
|
|
md->eptr[md->point] = eptr;
|
|
md->ecode[md->point] = ptr+3;
|
|
md->r1[md->point] = 0;
|
|
md->r2[md->point] = 0;
|
|
md->off_num[md->point] = 0;
|
|
md->point++;
|
|
/*points_pushed++;*/
|
|
}
|
|
} while (*ptr==OP_ALT);
|
|
/* Jump to the first (or only) alternative and resume trying to match */
|
|
ecode=prev+3; goto match_loop;
|
|
}
|
|
}
|
|
|
|
/* Start of subject unless notbol, or after internal newline if multiline */
|
|
|
|
case OP_CIRC:
|
|
if (md->notbol && eptr == md->start_subject) FAIL;
|
|
if (md->multiline)
|
|
{
|
|
if (eptr != md->start_subject && eptr[-1] != '\n') FAIL;
|
|
ecode++;
|
|
break;
|
|
}
|
|
/* ... else fall through */
|
|
|
|
/* Start of subject assertion */
|
|
|
|
case OP_SOD:
|
|
if (eptr != md->start_subject) FAIL;
|
|
ecode++;
|
|
break;
|
|
|
|
/* Assert before internal newline if multiline, or before
|
|
a terminating newline unless endonly is set, else end of subject unless
|
|
noteol is set. */
|
|
|
|
case OP_DOLL:
|
|
if (md->noteol && eptr >= md->end_subject) FAIL;
|
|
if (md->multiline)
|
|
{
|
|
if (eptr < md->end_subject && *eptr != '\n') FAIL;
|
|
ecode++;
|
|
break;
|
|
}
|
|
else if (!md->endonly)
|
|
{
|
|
if (eptr < md->end_subject - 1 ||
|
|
(eptr == md->end_subject - 1 && *eptr != '\n')) FAIL;
|
|
ecode++;
|
|
break;
|
|
}
|
|
/* ... else fall through */
|
|
|
|
/* End of subject assertion */
|
|
|
|
case OP_EOD:
|
|
if (eptr < md->end_subject) FAIL;
|
|
ecode++;
|
|
break;
|
|
|
|
/* Word boundary assertions */
|
|
|
|
case OP_NOT_WORD_BOUNDARY:
|
|
case OP_WORD_BOUNDARY:
|
|
{
|
|
BOOL prev_is_word = (eptr != md->start_subject) &&
|
|
((pcre_ctypes[eptr[-1]] & ctype_word) != 0);
|
|
BOOL cur_is_word = (eptr < md->end_subject) &&
|
|
((pcre_ctypes[*eptr] & ctype_word) != 0);
|
|
if ((*ecode++ == OP_WORD_BOUNDARY)?
|
|
cur_is_word == prev_is_word : cur_is_word != prev_is_word)
|
|
FAIL;
|
|
}
|
|
break;
|
|
|
|
case OP_NOT_WORD_BOUNDARY_L:
|
|
case OP_WORD_BOUNDARY_L:
|
|
{
|
|
BOOL prev_is_word = (eptr != md->start_subject) &&
|
|
(isalnum(eptr[-1]) || eptr[-1]=='_');
|
|
BOOL cur_is_word = (eptr < md->end_subject) &&
|
|
(isalnum(*eptr) || *eptr=='_');
|
|
if ((*ecode++ == OP_WORD_BOUNDARY_L)?
|
|
cur_is_word == prev_is_word : cur_is_word != prev_is_word)
|
|
FAIL;
|
|
}
|
|
break;
|
|
|
|
|
|
/* Match a single character type; inline for speed */
|
|
|
|
case OP_ANY:
|
|
if (!md->dotall && eptr < md->end_subject && *eptr == '\n') FAIL;
|
|
if (eptr++ >= md->end_subject) FAIL;
|
|
ecode++;
|
|
break;
|
|
|
|
case OP_NOT_DIGIT:
|
|
if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_digit) != 0)
|
|
FAIL;
|
|
ecode++;
|
|
break;
|
|
|
|
case OP_DIGIT:
|
|
if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_digit) == 0)
|
|
FAIL;
|
|
ecode++;
|
|
break;
|
|
|
|
case OP_NOT_WHITESPACE:
|
|
if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_space) != 0)
|
|
FAIL;
|
|
ecode++;
|
|
break;
|
|
|
|
case OP_WHITESPACE:
|
|
if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_space) == 0)
|
|
FAIL;
|
|
ecode++;
|
|
break;
|
|
|
|
case OP_NOT_WORDCHAR:
|
|
if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_word) != 0)
|
|
FAIL;
|
|
ecode++;
|
|
break;
|
|
|
|
case OP_WORDCHAR:
|
|
if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_word) == 0)
|
|
FAIL;
|
|
ecode++;
|
|
break;
|
|
|
|
case OP_NOT_WORDCHAR_L:
|
|
if (eptr >= md->end_subject || (*eptr=='_' || isalnum(*eptr) ))
|
|
FAIL;
|
|
eptr++;
|
|
ecode++;
|
|
break;
|
|
|
|
case OP_WORDCHAR_L:
|
|
if (eptr >= md->end_subject || (*eptr!='_' && !isalnum(*eptr) ))
|
|
FAIL;
|
|
eptr++;
|
|
ecode++;
|
|
break;
|
|
|
|
/* Match a back reference, possibly repeatedly. Look past the end of the
|
|
item to see if there is repeat information following. The code is similar
|
|
to that for character classes, but repeated for efficiency. Then obey
|
|
similar code to character type repeats - written out again for speed.
|
|
However, if the referenced string is the empty string, always treat
|
|
it as matched, any number of times (otherwise there could be infinite
|
|
loops). */
|
|
|
|
case OP_REF:
|
|
{
|
|
int length;
|
|
int number = ecode[1] << 1; /* Doubled reference number */
|
|
ecode += 2; /* Advance past the item */
|
|
|
|
if (number >= offset_top || md->offset_vector[number] < 0)
|
|
{
|
|
md->errorcode = PCRE_ERROR_BADREF;
|
|
FAIL;
|
|
}
|
|
|
|
length = md->offset_vector[number+1] - md->offset_vector[number];
|
|
|
|
switch (*ecode)
|
|
{
|
|
case OP_CRSTAR:
|
|
case OP_CRMINSTAR:
|
|
case OP_CRPLUS:
|
|
case OP_CRMINPLUS:
|
|
case OP_CRQUERY:
|
|
case OP_CRMINQUERY:
|
|
c = *ecode++ - OP_CRSTAR;
|
|
minimize = (c & 1) != 0;
|
|
min = rep_min[c]; /* Pick up values from tables; */
|
|
max = rep_max[c]; /* zero for max => infinity */
|
|
if (max == 0) max = INT_MAX;
|
|
break;
|
|
|
|
case OP_CRRANGE:
|
|
case OP_CRMINRANGE:
|
|
minimize = (*ecode == OP_CRMINRANGE);
|
|
min = (ecode[1] << 8) + ecode[2];
|
|
max = (ecode[3] << 8) + ecode[4];
|
|
if (max == 0) max = INT_MAX;
|
|
ecode += 5;
|
|
break;
|
|
|
|
default: /* No repeat follows */
|
|
if (!match_ref(number, eptr, length, md)) FAIL;
|
|
eptr += length;
|
|
continue; /* With the main loop */
|
|
}
|
|
|
|
/* If the length of the reference is zero, just continue with the
|
|
main loop. */
|
|
|
|
if (length == 0) continue;
|
|
|
|
/* First, ensure the minimum number of matches are present. We get back
|
|
the length of the reference string explicitly rather than passing the
|
|
address of eptr, so that eptr can be a register variable. */
|
|
|
|
for (i = 1; i <= min; i++)
|
|
{
|
|
if (!match_ref(number, eptr, length, md)) FAIL;
|
|
eptr += length;
|
|
}
|
|
|
|
/* If min = max, continue at the same level without recursion.
|
|
They are not both allowed to be zero. */
|
|
|
|
if (min == max) continue;
|
|
|
|
/* If minimizing, keep trying and advancing the pointer */
|
|
|
|
if (minimize)
|
|
{
|
|
for (i = min;; i++)
|
|
{
|
|
if (match(eptr, ecode, offset_top, md)) SUCCEED;
|
|
if (i >= max || !match_ref(number, eptr, length, md))
|
|
FAIL;
|
|
eptr += length;
|
|
}
|
|
/* Control never gets here */
|
|
}
|
|
|
|
/* If maximizing, find the longest string and work backwards */
|
|
|
|
else
|
|
{
|
|
const uschar *pp = eptr;
|
|
for (i = min; i < max; i++)
|
|
{
|
|
if (!match_ref(number, eptr, length, md)) break;
|
|
eptr += length;
|
|
}
|
|
while (eptr >= pp)
|
|
{
|
|
if (match(eptr, ecode, offset_top, md)) SUCCEED;
|
|
eptr -= length;
|
|
}
|
|
FAIL;
|
|
}
|
|
}
|
|
/* Control never gets here */
|
|
|
|
/* Match a character class, possibly repeatedly. Look past the end of the
|
|
item to see if there is repeat information following. Then obey similar
|
|
code to character type repeats - written out again for speed. If caseless
|
|
matching was set at runtime but not at compile time, we have to check both
|
|
versions of a character, and we have to behave differently for positive and
|
|
negative classes. This is the only time where OP_CLASS and OP_NEGCLASS are
|
|
treated differently. */
|
|
|
|
case OP_CLASS:
|
|
case OP_NEGCLASS:
|
|
{
|
|
BOOL nasty_case = *ecode == OP_NEGCLASS && md->runtime_caseless;
|
|
const uschar *data = ecode + 1; /* Save for matching */
|
|
ecode += 33; /* Advance past the item */
|
|
|
|
switch (*ecode)
|
|
{
|
|
case OP_CRSTAR:
|
|
case OP_CRMINSTAR:
|
|
case OP_CRPLUS:
|
|
case OP_CRMINPLUS:
|
|
case OP_CRQUERY:
|
|
case OP_CRMINQUERY:
|
|
c = *ecode++ - OP_CRSTAR;
|
|
minimize = (c & 1) != 0;
|
|
min = rep_min[c]; /* Pick up values from tables; */
|
|
max = rep_max[c]; /* zero for max => infinity */
|
|
if (max == 0) max = INT_MAX;
|
|
break;
|
|
|
|
case OP_CRRANGE:
|
|
case OP_CRMINRANGE:
|
|
minimize = (*ecode == OP_CRMINRANGE);
|
|
min = (ecode[1] << 8) + ecode[2];
|
|
max = (ecode[3] << 8) + ecode[4];
|
|
if (max == 0) max = INT_MAX;
|
|
ecode += 5;
|
|
break;
|
|
|
|
default: /* No repeat follows */
|
|
min = max = 1;
|
|
break;
|
|
}
|
|
|
|
/* First, ensure the minimum number of matches are present. */
|
|
|
|
for (i = 1; i <= min; i++)
|
|
{
|
|
if (eptr >= md->end_subject) FAIL;
|
|
c = *eptr++;
|
|
|
|
/* Either not runtime caseless, or it was a positive class. For
|
|
runtime caseless, continue if either case is in the map. */
|
|
|
|
if (!nasty_case)
|
|
{
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue;
|
|
if (md->runtime_caseless)
|
|
{
|
|
c = pcre_fcc[c];
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue;
|
|
}
|
|
}
|
|
|
|
/* Runtime caseless and it was a negative class. Continue only if
|
|
both cases are in the map. */
|
|
|
|
else
|
|
{
|
|
if ((data[c/8] & (1 << (c&7))) == 0) FAIL;
|
|
c = pcre_fcc[c];
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue;
|
|
}
|
|
|
|
FAIL;
|
|
}
|
|
|
|
/* If max == min we can continue with the main loop without the
|
|
need to recurse. */
|
|
|
|
if (min == max) continue;
|
|
|
|
/* If minimizing, keep testing the rest of the expression and advancing
|
|
the pointer while it matches the class. */
|
|
|
|
if (minimize)
|
|
{
|
|
for (i = min;; i++)
|
|
{
|
|
if (match(eptr, ecode, offset_top, md)) SUCCEED;
|
|
if (i >= max || eptr >= md->end_subject) FAIL;
|
|
c = *eptr++;
|
|
|
|
/* Either not runtime caseless, or it was a positive class. For
|
|
runtime caseless, continue if either case is in the map. */
|
|
|
|
if (!nasty_case)
|
|
{
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue;
|
|
if (md->runtime_caseless)
|
|
{
|
|
c = pcre_fcc[c];
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue;
|
|
}
|
|
}
|
|
|
|
/* Runtime caseless and it was a negative class. Continue only if
|
|
both cases are in the map. */
|
|
|
|
else
|
|
{
|
|
if ((data[c/8] & (1 << (c&7))) == 0) return FALSE;
|
|
c = pcre_fcc[c];
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue;
|
|
}
|
|
|
|
FAIL;
|
|
}
|
|
/* Control never gets here */
|
|
}
|
|
|
|
/* If maximizing, find the longest possible run, then work backwards. */
|
|
|
|
else
|
|
{
|
|
const uschar *pp = eptr;
|
|
for (i = min; i < max; eptr++, i++)
|
|
{
|
|
if (eptr >= md->end_subject) break;
|
|
c = *eptr;
|
|
|
|
/* Either not runtime caseless, or it was a positive class. For
|
|
runtime caseless, continue if either case is in the map. */
|
|
|
|
if (!nasty_case)
|
|
{
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue;
|
|
if (md->runtime_caseless)
|
|
{
|
|
c = pcre_fcc[c];
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue;
|
|
}
|
|
}
|
|
|
|
/* Runtime caseless and it was a negative class. Continue only if
|
|
both cases are in the map. */
|
|
|
|
else
|
|
{
|
|
if ((data[c/8] & (1 << (c&7))) == 0) break;
|
|
c = pcre_fcc[c];
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
while (eptr >= pp)
|
|
if (match(eptr--, ecode, offset_top, md)) SUCCEED;
|
|
FAIL;
|
|
}
|
|
}
|
|
/* Control never gets here */
|
|
|
|
/* OP_CLASS_L opcode: handles localized character classes */
|
|
|
|
case OP_CLASS_L:
|
|
{
|
|
const uschar *data = ecode + 1; /* Save for matching */
|
|
const uschar locale_flag = *data;
|
|
ecode++; data++; /* The localization support adds an extra byte */
|
|
|
|
ecode += 33; /* Advance past the item */
|
|
|
|
switch (*ecode)
|
|
{
|
|
case OP_CRSTAR:
|
|
case OP_CRMINSTAR:
|
|
case OP_CRPLUS:
|
|
case OP_CRMINPLUS:
|
|
case OP_CRQUERY:
|
|
case OP_CRMINQUERY:
|
|
c = *ecode++ - OP_CRSTAR;
|
|
minimize = (c & 1) != 0;
|
|
min = rep_min[c]; /* Pick up values from tables; */
|
|
max = rep_max[c]; /* zero for max => infinity */
|
|
if (max == 0) max = INT_MAX;
|
|
break;
|
|
|
|
case OP_CRRANGE:
|
|
case OP_CRMINRANGE:
|
|
minimize = (*ecode == OP_CRMINRANGE);
|
|
min = (ecode[1] << 8) + ecode[2];
|
|
max = (ecode[3] << 8) + ecode[4];
|
|
if (max == 0) max = INT_MAX;
|
|
ecode += 5;
|
|
break;
|
|
|
|
default: /* No repeat follows */
|
|
if (eptr >= md->end_subject) FAIL;
|
|
c = *eptr++;
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue; /* With main loop */
|
|
if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */
|
|
if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */
|
|
#if 0
|
|
if ( (locale_flag & 4) && isdigit(c) ) continue; /* Locale \d */
|
|
if ( (locale_flag & 8) && !isdigit(c) ) continue; /* Locale \D */
|
|
if ( (locale_flag & 16) && isspace(c) ) continue; /* Locale \s */
|
|
if ( (locale_flag & 32) && !isspace(c) ) continue; /* Locale \S */
|
|
#endif
|
|
|
|
if (md->runtime_caseless)
|
|
{
|
|
c = pcre_fcc[c];
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue; /* With main loop */
|
|
|
|
if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */
|
|
if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */
|
|
}
|
|
FAIL;
|
|
}
|
|
|
|
/* First, ensure the minimum number of matches are present. */
|
|
|
|
for (i = 1; i <= min; i++)
|
|
{
|
|
if (eptr >= md->end_subject) FAIL;
|
|
c = *eptr++;
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue;
|
|
if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */
|
|
if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */
|
|
|
|
if (md->runtime_caseless)
|
|
{
|
|
c = pcre_fcc[c];
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue;
|
|
if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */
|
|
if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */
|
|
}
|
|
FAIL;
|
|
}
|
|
|
|
/* If max == min we can continue with the main loop without the
|
|
need to recurse. */
|
|
|
|
if (min == max) continue;
|
|
|
|
/* If minimizing, keep testing the rest of the expression and advancing
|
|
the pointer while it matches the class. */
|
|
|
|
if (minimize)
|
|
{
|
|
for (i = min;; i++)
|
|
{
|
|
if (match(eptr, ecode, offset_top, md)) SUCCEED;
|
|
if (i >= max || eptr >= md->end_subject) FAIL;
|
|
c = *eptr++;
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue;
|
|
if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */
|
|
if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */
|
|
|
|
if (md->runtime_caseless)
|
|
{
|
|
c = pcre_fcc[c];
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue;
|
|
if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */
|
|
if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */
|
|
}
|
|
FAIL;
|
|
}
|
|
/* Control never gets here */
|
|
}
|
|
|
|
/* If maximizing, find the longest possible run, then work backwards. */
|
|
|
|
else
|
|
{
|
|
const uschar *pp = eptr;
|
|
for (i = min; i < max; eptr++, i++)
|
|
{
|
|
if (eptr >= md->end_subject) break;
|
|
c = *eptr;
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue;
|
|
if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */
|
|
if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */
|
|
if (md->runtime_caseless)
|
|
{
|
|
c = pcre_fcc[c];
|
|
if ((data[c/8] & (1 << (c&7))) != 0) continue;
|
|
if ( (locale_flag & 1) && (isalnum(c) || c=='_') ) continue; /* Locale \w */
|
|
if ( (locale_flag & 2) && (!isalnum(c) && c!='_') ) continue; /* Locale \W */
|
|
}
|
|
break;
|
|
}
|
|
|
|
while (eptr >= pp)
|
|
if (match(eptr--, ecode, offset_top, md)) SUCCEED;
|
|
FAIL;
|
|
}
|
|
}
|
|
/* Control never gets here */
|
|
|
|
/* Match a run of characters */
|
|
|
|
case OP_CHARS:
|
|
{
|
|
register int length = ecode[1];
|
|
ecode += 2;
|
|
|
|
#ifdef DEBUG /* Sigh. Some compilers never learn. */
|
|
if (eptr >= md->end_subject)
|
|
printf("matching subject <null> against pattern ");
|
|
else
|
|
{
|
|
printf("matching subject ");
|
|
pchars(eptr, length, TRUE, md);
|
|
printf(" against pattern ");
|
|
}
|
|
pchars(ecode, length, FALSE, md);
|
|
printf("\n");
|
|
#endif
|
|
|
|
if (length > md->end_subject - eptr) FAIL;
|
|
if (md->caseless)
|
|
{
|
|
while (length-- > 0) if (pcre_lcc[*ecode++] != pcre_lcc[*eptr++]) FAIL;
|
|
}
|
|
else
|
|
{
|
|
while (length-- > 0) if (*ecode++ != *eptr++) FAIL;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* Match a single character repeatedly; different opcodes share code. */
|
|
|
|
case OP_EXACT:
|
|
min = max = (ecode[1] << 8) + ecode[2];
|
|
ecode += 3;
|
|
goto REPEATCHAR;
|
|
|
|
case OP_UPTO:
|
|
case OP_MINUPTO:
|
|
min = 0;
|
|
max = (ecode[1] << 8) + ecode[2];
|
|
minimize = *ecode == OP_MINUPTO;
|
|
ecode += 3;
|
|
goto REPEATCHAR;
|
|
|
|
case OP_STAR:
|
|
case OP_MINSTAR:
|
|
case OP_PLUS:
|
|
case OP_MINPLUS:
|
|
case OP_QUERY:
|
|
case OP_MINQUERY:
|
|
c = *ecode++ - OP_STAR;
|
|
minimize = (c & 1) != 0;
|
|
min = rep_min[c]; /* Pick up values from tables; */
|
|
max = rep_max[c]; /* zero for max => infinity */
|
|
if (max == 0) max = INT_MAX;
|
|
|
|
/* Common code for all repeated single-character matches. We can give
|
|
up quickly if there are fewer than the minimum number of characters left in
|
|
the subject. */
|
|
|
|
REPEATCHAR:
|
|
if (min > md->end_subject - eptr) FAIL;
|
|
c = *ecode++;
|
|
|
|
/* The code is duplicated for the caseless and caseful cases, for speed,
|
|
since matching characters is likely to be quite common. First, ensure the
|
|
minimum number of matches are present. If min = max, continue at the same
|
|
level without recursing. Otherwise, if minimizing, keep trying the rest of
|
|
the expression and advancing one matching character if failing, up to the
|
|
maximum. Alternatively, if maximizing, find the maximum number of
|
|
characters and work backwards. */
|
|
|
|
DPRINTF(("matching %c{%d,%d} against subject %.*s\n", c, min, max,
|
|
max, eptr));
|
|
|
|
if (md->caseless)
|
|
{
|
|
c = pcre_lcc[c];
|
|
for (i = 1; i <= min; i++) if (c != pcre_lcc[*eptr++]) FAIL;
|
|
if (min == max) continue;
|
|
if (minimize)
|
|
{
|
|
for (i = min;; i++)
|
|
{
|
|
if (match(eptr, ecode, offset_top, md)) SUCCEED;
|
|
if (i >= max || eptr >= md->end_subject || c != pcre_lcc[*eptr++])
|
|
FAIL;
|
|
}
|
|
/* Control never gets here */
|
|
}
|
|
else
|
|
{
|
|
const uschar *pp = eptr;
|
|
for (i = min; i < max; i++)
|
|
{
|
|
if (eptr >= md->end_subject || c != pcre_lcc[*eptr]) break;
|
|
eptr++;
|
|
}
|
|
while (eptr >= pp)
|
|
if (match(eptr--, ecode, offset_top, md)) SUCCEED;
|
|
FAIL;
|
|
}
|
|
/* Control never gets here */
|
|
}
|
|
|
|
/* Caseful comparisons */
|
|
|
|
else
|
|
{
|
|
for (i = 1; i <= min; i++) if (c != *eptr++) FAIL;
|
|
if (min == max) continue;
|
|
if (minimize)
|
|
{
|
|
for (i = min;; i++)
|
|
{
|
|
if (match(eptr, ecode, offset_top, md)) SUCCEED;
|
|
if (i >= max || eptr >= md->end_subject || c != *eptr++) FAIL;
|
|
}
|
|
/* Control never gets here */
|
|
}
|
|
else
|
|
{
|
|
const uschar *pp = eptr;
|
|
for (i = min; i < max; i++)
|
|
{
|
|
if (eptr >= md->end_subject || c != *eptr) break;
|
|
eptr++;
|
|
}
|
|
while (eptr >= pp)
|
|
if (match(eptr--, ecode, offset_top, md)) SUCCEED;
|
|
FAIL;
|
|
}
|
|
}
|
|
/* Control never gets here */
|
|
|
|
/* Match a negated single character */
|
|
|
|
case OP_NOT:
|
|
if (eptr >= md->end_subject) FAIL;
|
|
ecode++;
|
|
if (md->caseless)
|
|
{
|
|
if (pcre_lcc[*ecode++] == pcre_lcc[*eptr++]) FAIL;
|
|
}
|
|
else
|
|
{
|
|
if (*ecode++ == *eptr++) FAIL;
|
|
}
|
|
break;
|
|
|
|
/* Match a negated single character repeatedly. This is almost a repeat of
|
|
the code for a repeated single character, but I haven't found a nice way of
|
|
commoning these up that doesn't require a test of the positive/negative
|
|
option for each character match. Maybe that wouldn't add very much to the
|
|
time taken, but character matching *is* what this is all about... */
|
|
|
|
case OP_NOTEXACT:
|
|
min = max = (ecode[1] << 8) + ecode[2];
|
|
ecode += 3;
|
|
goto REPEATNOTCHAR;
|
|
|
|
case OP_NOTUPTO:
|
|
case OP_NOTMINUPTO:
|
|
min = 0;
|
|
max = (ecode[1] << 8) + ecode[2];
|
|
minimize = *ecode == OP_NOTMINUPTO;
|
|
ecode += 3;
|
|
goto REPEATNOTCHAR;
|
|
|
|
case OP_NOTSTAR:
|
|
case OP_NOTMINSTAR:
|
|
case OP_NOTPLUS:
|
|
case OP_NOTMINPLUS:
|
|
case OP_NOTQUERY:
|
|
case OP_NOTMINQUERY:
|
|
c = *ecode++ - OP_NOTSTAR;
|
|
minimize = (c & 1) != 0;
|
|
min = rep_min[c]; /* Pick up values from tables; */
|
|
max = rep_max[c]; /* zero for max => infinity */
|
|
if (max == 0) max = INT_MAX;
|
|
|
|
/* Common code for all repeated single-character matches. We can give
|
|
up quickly if there are fewer than the minimum number of characters left in
|
|
the subject. */
|
|
|
|
REPEATNOTCHAR:
|
|
if (min > md->end_subject - eptr) FAIL;
|
|
c = *ecode++;
|
|
|
|
/* The code is duplicated for the caseless and caseful cases, for speed,
|
|
since matching characters is likely to be quite common. First, ensure the
|
|
minimum number of matches are present. If min = max, continue at the same
|
|
level without recursing. Otherwise, if minimizing, keep trying the rest of
|
|
the expression and advancing one matching character if failing, up to the
|
|
maximum. Alternatively, if maximizing, find the maximum number of
|
|
characters and work backwards. */
|
|
|
|
DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", c, min, max,
|
|
max, eptr));
|
|
|
|
if (md->caseless)
|
|
{
|
|
c = pcre_lcc[c];
|
|
for (i = 1; i <= min; i++) if (c == pcre_lcc[*eptr++]) FAIL;
|
|
if (min == max) continue;
|
|
if (minimize)
|
|
{
|
|
for (i = min;; i++)
|
|
{
|
|
if (match(eptr, ecode, offset_top, md)) SUCCEED;
|
|
if (i >= max || eptr >= md->end_subject || c == pcre_lcc[*eptr++])
|
|
FAIL;
|
|
}
|
|
/* Control never gets here */
|
|
}
|
|
else
|
|
{
|
|
const uschar *pp = eptr;
|
|
for (i = min; i < max; i++)
|
|
{
|
|
if (eptr >= md->end_subject || c == pcre_lcc[*eptr]) break;
|
|
eptr++;
|
|
}
|
|
while (eptr >= pp)
|
|
if (match(eptr--, ecode, offset_top, md)) SUCCEED;
|
|
FAIL;
|
|
}
|
|
/* Control never gets here */
|
|
}
|
|
|
|
/* Caseful comparisons */
|
|
|
|
else
|
|
{
|
|
for (i = 1; i <= min; i++) if (c == *eptr++) FAIL;
|
|
if (min == max) continue;
|
|
if (minimize)
|
|
{
|
|
for (i = min;; i++)
|
|
{
|
|
if (match(eptr, ecode, offset_top, md)) SUCCEED;
|
|
if (i >= max || eptr >= md->end_subject || c == *eptr++) FAIL;
|
|
}
|
|
/* Control never gets here */
|
|
}
|
|
else
|
|
{
|
|
const uschar *pp = eptr;
|
|
for (i = min; i < max; i++)
|
|
{
|
|
if (eptr >= md->end_subject || c == *eptr) break;
|
|
eptr++;
|
|
}
|
|
while (eptr >= pp)
|
|
if (match(eptr--, ecode, offset_top, md)) SUCCEED;
|
|
FAIL;
|
|
}
|
|
}
|
|
/* Control never gets here */
|
|
|
|
/* Match a single character type repeatedly; several different opcodes
|
|
share code. This is very similar to the code for single characters, but we
|
|
repeat it in the interests of efficiency. */
|
|
|
|
case OP_TYPEEXACT:
|
|
min = max = (ecode[1] << 8) + ecode[2];
|
|
minimize = TRUE;
|
|
ecode += 3;
|
|
goto REPEATTYPE;
|
|
|
|
case OP_TYPEUPTO:
|
|
case OP_TYPEMINUPTO:
|
|
min = 0;
|
|
max = (ecode[1] << 8) + ecode[2];
|
|
minimize = *ecode == OP_TYPEMINUPTO;
|
|
ecode += 3;
|
|
goto REPEATTYPE;
|
|
|
|
case OP_TYPESTAR:
|
|
case OP_TYPEMINSTAR:
|
|
case OP_TYPEPLUS:
|
|
case OP_TYPEMINPLUS:
|
|
case OP_TYPEQUERY:
|
|
case OP_TYPEMINQUERY:
|
|
c = *ecode++ - OP_TYPESTAR;
|
|
minimize = (c & 1) != 0;
|
|
min = rep_min[c]; /* Pick up values from tables; */
|
|
max = rep_max[c]; /* zero for max => infinity */
|
|
if (max == 0) max = INT_MAX;
|
|
|
|
/* Common code for all repeated single character type matches */
|
|
|
|
REPEATTYPE:
|
|
ctype = *ecode++; /* Code for the character type */
|
|
|
|
/* First, ensure the minimum number of matches are present. Use inline
|
|
code for maximizing the speed, and do the type test once at the start
|
|
(i.e. keep it out of the loop). Also test that there are at least the
|
|
minimum number of characters before we start. */
|
|
|
|
if (min > md->end_subject - eptr) FAIL;
|
|
if (min > 0) switch(ctype)
|
|
{
|
|
case OP_ANY:
|
|
if (!md->dotall)
|
|
{ for (i = 1; i <= min; i++) if (*eptr++ == '\n') FAIL; }
|
|
else eptr += min;
|
|
break;
|
|
|
|
case OP_NOT_DIGIT:
|
|
for (i = 1; i <= min; i++)
|
|
if ((pcre_ctypes[*eptr++] & ctype_digit) != 0) FAIL;
|
|
break;
|
|
|
|
case OP_DIGIT:
|
|
for (i = 1; i <= min; i++)
|
|
if ((pcre_ctypes[*eptr++] & ctype_digit) == 0) FAIL;
|
|
break;
|
|
|
|
case OP_NOT_WHITESPACE:
|
|
for (i = 1; i <= min; i++)
|
|
if ((pcre_ctypes[*eptr++] & ctype_space) != 0) FAIL;
|
|
break;
|
|
|
|
case OP_WHITESPACE:
|
|
for (i = 1; i <= min; i++)
|
|
if ((pcre_ctypes[*eptr++] & ctype_space) == 0) FAIL;
|
|
break;
|
|
|
|
case OP_NOT_WORDCHAR:
|
|
for (i = 1; i <= min; i++) if ((pcre_ctypes[*eptr++] & ctype_word) != 0)
|
|
FAIL;
|
|
break;
|
|
|
|
case OP_WORDCHAR:
|
|
for (i = 1; i <= min; i++) if ((pcre_ctypes[*eptr++] & ctype_word) == 0)
|
|
FAIL;
|
|
break;
|
|
|
|
case OP_NOT_WORDCHAR_L:
|
|
for (i = 1; i <= min; i++, eptr++) if (*eptr=='_' || isalnum(*eptr))
|
|
FAIL;
|
|
break;
|
|
|
|
case OP_WORDCHAR_L:
|
|
for (i = 1; i <= min; i++, eptr++) if (*eptr!='_' && !isalnum(*eptr))
|
|
FAIL;
|
|
break;
|
|
}
|
|
|
|
/* If min = max, continue at the same level without recursing */
|
|
|
|
if (min == max) continue;
|
|
|
|
/* If minimizing, we have to test the rest of the pattern before each
|
|
subsequent match, so inlining isn't much help; just use the function. */
|
|
|
|
if (minimize)
|
|
{
|
|
for (i = min;; i++)
|
|
{
|
|
if (match(eptr, ecode, offset_top, md)) SUCCEED;
|
|
if (i >= max || eptr >= md->end_subject ||
|
|
!match_type(ctype, *eptr++, md->dotall))
|
|
FAIL;
|
|
}
|
|
/* Control never gets here */
|
|
}
|
|
|
|
/* If maximizing it is worth using inline code for speed, doing the type
|
|
test once at the start (i.e. keep it out of the loop). */
|
|
|
|
else
|
|
{
|
|
const uschar *pp = eptr;
|
|
switch(ctype)
|
|
{
|
|
case OP_ANY:
|
|
if (!md->dotall)
|
|
{
|
|
for (i = min; i < max; i++)
|
|
{
|
|
if (eptr >= md->end_subject || *eptr == '\n') break;
|
|
eptr++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
c = max - min;
|
|
if (c > md->end_subject - eptr) c = md->end_subject - eptr;
|
|
eptr += c;
|
|
}
|
|
break;
|
|
|
|
case OP_NOT_DIGIT:
|
|
for (i = min; i < max; i++)
|
|
{
|
|
if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_digit) != 0)
|
|
break;
|
|
eptr++;
|
|
}
|
|
break;
|
|
|
|
case OP_DIGIT:
|
|
for (i = min; i < max; i++)
|
|
{
|
|
if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_digit) == 0)
|
|
break;
|
|
eptr++;
|
|
}
|
|
break;
|
|
|
|
case OP_NOT_WHITESPACE:
|
|
for (i = min; i < max; i++)
|
|
{
|
|
if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_space) != 0)
|
|
break;
|
|
eptr++;
|
|
}
|
|
break;
|
|
|
|
case OP_WHITESPACE:
|
|
for (i = min; i < max; i++)
|
|
{
|
|
if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_space) == 0)
|
|
break;
|
|
eptr++;
|
|
}
|
|
break;
|
|
|
|
case OP_NOT_WORDCHAR:
|
|
for (i = min; i < max; i++)
|
|
{
|
|
if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_word) != 0)
|
|
break;
|
|
eptr++;
|
|
}
|
|
break;
|
|
|
|
case OP_WORDCHAR:
|
|
for (i = min; i < max; i++)
|
|
{
|
|
if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_word) == 0)
|
|
break;
|
|
eptr++;
|
|
}
|
|
break;
|
|
case OP_NOT_WORDCHAR_L:
|
|
for (i = min; i < max; i++)
|
|
{
|
|
if (eptr >= md->end_subject || (*eptr=='_' || isalnum(*eptr) ) )
|
|
break;
|
|
eptr++;
|
|
}
|
|
break;
|
|
|
|
case OP_WORDCHAR_L:
|
|
for (i = min; i < max; i++)
|
|
{
|
|
if (eptr >= md->end_subject || (*eptr!='_' && !isalnum(*eptr) ) )
|
|
break;
|
|
eptr++;
|
|
}
|
|
break;
|
|
}
|
|
|
|
while (eptr >= pp)
|
|
if (match(eptr--, ecode, offset_top, md)) SUCCEED;
|
|
FAIL;
|
|
}
|
|
/* Control never gets here */
|
|
|
|
/* There's been some horrible disaster. */
|
|
|
|
default:
|
|
DPRINTF(("Unknown opcode %d\n", *ecode));
|
|
md->errorcode = PCRE_ERROR_UNKNOWN_NODE;
|
|
FAIL;
|
|
}
|
|
|
|
/* Do not stick any code in here without much thought; it is assumed
|
|
that "continue" in the code above comes out to here to repeat the main
|
|
loop. */
|
|
|
|
} /* End of main loop */
|
|
/* Control never reaches here */
|
|
|
|
fail:
|
|
if (md->point > save_stack_position)
|
|
{
|
|
/* If there are still points remaining on the stack, pop the next one off */
|
|
int off_num;
|
|
|
|
md->point--;
|
|
offset_top = md->offset_top[md->point];
|
|
eptr = md->eptr[md->point];
|
|
ecode = md->ecode[md->point];
|
|
off_num = md->off_num[md->point];
|
|
md->offset_vector[off_num] = md->r1[md->point];
|
|
md->offset_vector[off_num+1] = md->r2[md->point];
|
|
goto match_loop;
|
|
}
|
|
/* Failure, and nothing left on the stack, so end this function call */
|
|
|
|
/* Restore the top of the stack to where it was before this function
|
|
call. This lets us use one stack for everything; recursive calls
|
|
can push and pop information, and may increase the stack. When
|
|
the call returns, the parent function can resume pushing and
|
|
popping wherever it was. */
|
|
|
|
md->point = save_stack_position;
|
|
return FALSE;
|
|
|
|
succeed:
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
/*************************************************
|
|
* Segregate setjmp() *
|
|
*************************************************/
|
|
|
|
/* The -Wall option of gcc gives warnings for all local variables when setjmp()
|
|
is used, even if the coding conforms to the rules of ANSI C. To avoid this, we
|
|
hide it in a separate function. This is called only when PCRE_EXTRA is set,
|
|
since it's needed only for the extension \X option, and with any luck, a good
|
|
compiler will spot the tail recursion and compile it efficiently.
|
|
|
|
Arguments:
|
|
eptr pointer in subject
|
|
ecode position in code
|
|
offset_top current top pointer
|
|
md pointer to "static" info for the match
|
|
|
|
Returns: TRUE if matched
|
|
*/
|
|
|
|
static BOOL
|
|
match_with_setjmp(const uschar *eptr, const uschar *ecode, int offset_top,
|
|
match_data *match_block)
|
|
{
|
|
return setjmp(match_block->fail_env) == 0 &&
|
|
match(eptr, ecode, offset_top, match_block);
|
|
}
|
|
|
|
|
|
|
|
/*************************************************
|
|
* Execute a Regular Expression *
|
|
*************************************************/
|
|
|
|
/* This function applies a compiled re to a subject string and picks out
|
|
portions of the string if it matches. Two elements in the vector are set for
|
|
each substring: the offsets to the start and end of the substring.
|
|
|
|
Arguments:
|
|
external_re points to the compiled expression
|
|
external_extra points to "hints" from pcre_study() or is NULL
|
|
subject points to the subject string
|
|
length length of subject string (may contain binary zeros)
|
|
options option bits
|
|
offsets points to a vector of ints to be filled in with offsets
|
|
offsetcount the number of elements in the vector
|
|
|
|
Returns: > 0 => success; value is the number of elements filled in
|
|
= 0 => success, but offsets is not big enough
|
|
-1 => failed to match
|
|
< -1 => some kind of unexpected problem
|
|
*/
|
|
|
|
int
|
|
pcre_exec(const pcre *external_re, const pcre_extra *external_extra,
|
|
const char *subject, int length, int start_pos, int options,
|
|
int *offsets, int offsetcount)
|
|
{
|
|
/* The "volatile" directives are to make gcc -Wall stop complaining
|
|
that these variables can be clobbered by the longjmp. Hopefully
|
|
they won't cost too much performance. */
|
|
volatile int resetcount, ocount;
|
|
volatile int first_char = -1;
|
|
match_data match_block;
|
|
const uschar *start_bits = NULL;
|
|
const uschar *start_match = (const uschar *)subject + start_pos;
|
|
const uschar *end_subject;
|
|
const real_pcre *re = (const real_pcre *)external_re;
|
|
const real_pcre_extra *extra = (const real_pcre_extra *)external_extra;
|
|
volatile BOOL using_temporary_offsets = FALSE;
|
|
volatile BOOL anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
|
|
volatile BOOL startline = (re->options & PCRE_STARTLINE) != 0;
|
|
|
|
if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;
|
|
|
|
if (re == NULL || subject == NULL ||
|
|
(offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
|
|
if (re->magic_number != MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC;
|
|
|
|
match_block.start_subject = (const uschar *)subject;
|
|
match_block.end_subject = match_block.start_subject + length;
|
|
end_subject = match_block.end_subject;
|
|
|
|
match_block.caseless = ((re->options | options) & PCRE_CASELESS) != 0;
|
|
match_block.runtime_caseless = match_block.caseless &&
|
|
(re->options & PCRE_CASELESS) == 0;
|
|
|
|
match_block.multiline = ((re->options | options) & PCRE_MULTILINE) != 0;
|
|
match_block.dotall = ((re->options | options) & PCRE_DOTALL) != 0;
|
|
match_block.endonly = ((re->options | options) & PCRE_DOLLAR_ENDONLY) != 0;
|
|
|
|
match_block.notbol = (options & PCRE_NOTBOL) != 0;
|
|
match_block.noteol = (options & PCRE_NOTEOL) != 0;
|
|
|
|
match_block.errorcode = PCRE_ERROR_NOMATCH; /* Default error */
|
|
|
|
/* Set the stack state to empty */
|
|
match_block.off_num = match_block.offset_top = NULL;
|
|
match_block.r1 = match_block.r2 = NULL;
|
|
match_block.eptr = match_block.ecode = NULL;
|
|
match_block.point = match_block.length = 0;
|
|
|
|
/* If the expression has got more back references than the offsets supplied can
|
|
hold, we get a temporary bit of working store to use during the matching.
|
|
Otherwise, we can use the vector supplied, rounding down its size to a multiple
|
|
of 2. */
|
|
|
|
ocount = offsetcount & (-2);
|
|
if (re->top_backref > 0 && re->top_backref >= ocount/2)
|
|
{
|
|
ocount = re->top_backref * 2 + 2;
|
|
match_block.offset_vector = (int *)(pcre_malloc)(ocount * sizeof(int));
|
|
if (match_block.offset_vector == NULL) return PCRE_ERROR_NOMEMORY;
|
|
using_temporary_offsets = TRUE;
|
|
DPRINTF(("Got memory to hold back references\n"));
|
|
}
|
|
else match_block.offset_vector = offsets;
|
|
|
|
match_block.offset_end = ocount;
|
|
match_block.offset_overflow = FALSE;
|
|
|
|
/* Compute the minimum number of offsets that we need to reset each time. Doing
|
|
this makes a huge difference to execution time when there aren't many brackets
|
|
in the pattern. */
|
|
|
|
resetcount = 2 + re->top_bracket * 2;
|
|
if (resetcount > offsetcount) resetcount = ocount;
|
|
|
|
/* If MULTILINE is set at exec time but was not set at compile time, and the
|
|
anchored flag is set, we must re-check because a setting provoked by ^ in the
|
|
pattern is not right in multi-line mode. Calling is_anchored() again here does
|
|
the right check, because multiline is now set. If it now yields FALSE, the
|
|
expression must have had ^ starting some of its branches. Check to see if
|
|
that is true for *all* branches, and if so, set the startline flag. */
|
|
|
|
if (match_block.multiline && anchored && (re->options & PCRE_MULTILINE) == 0 &&
|
|
!is_anchored(re->code, match_block.multiline))
|
|
{
|
|
anchored = FALSE;
|
|
if (is_startline(re->code)) startline = TRUE;
|
|
}
|
|
|
|
/* Set up the first character to match, if available. The first_char value is
|
|
never set for an anchored regular expression, but the anchoring may be forced
|
|
at run time, so we have to test for anchoring. The first char may be unset for
|
|
an unanchored pattern, of course. If there's no first char and the pattern was
|
|
studied, the may be a bitmap of possible first characters. However, we can
|
|
use this only if the caseless state of the studying was correct. */
|
|
|
|
if (!anchored)
|
|
{
|
|
if ((re->options & PCRE_FIRSTSET) != 0)
|
|
{
|
|
first_char = re->first_char;
|
|
if (match_block.caseless) first_char = pcre_lcc[first_char];
|
|
}
|
|
else
|
|
if (!startline && extra != NULL &&
|
|
(extra->options & PCRE_STUDY_MAPPED) != 0 &&
|
|
((extra->options & PCRE_STUDY_CASELESS) != 0) == match_block.caseless)
|
|
start_bits = extra->start_bits;
|
|
}
|
|
|
|
/* Loop for unanchored matches; for anchored regexps the loop runs just once. */
|
|
|
|
do
|
|
{
|
|
int rc;
|
|
register int *iptr = match_block.offset_vector;
|
|
register int *iend = iptr + resetcount;
|
|
|
|
/* Reset the maximum number of extractions we might see. */
|
|
|
|
while (iptr < iend) *iptr++ = -1;
|
|
|
|
/* Advance to a unique first char if possible */
|
|
|
|
if (first_char >= 0)
|
|
{
|
|
if (match_block.caseless)
|
|
while (start_match < end_subject && pcre_lcc[*start_match] != first_char)
|
|
start_match++;
|
|
else
|
|
while (start_match < end_subject && *start_match != first_char)
|
|
start_match++;
|
|
}
|
|
|
|
/* Or to just after \n for a multiline match if possible */
|
|
|
|
else if (startline)
|
|
{
|
|
if (start_match > match_block.start_subject)
|
|
{
|
|
while (start_match < end_subject && start_match[-1] != '\n')
|
|
start_match++;
|
|
}
|
|
}
|
|
|
|
/* Or to a non-unique first char */
|
|
|
|
else if (start_bits != NULL)
|
|
{
|
|
while (start_match < end_subject)
|
|
{
|
|
register int c = *start_match;
|
|
if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++; else break;
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG /* Sigh. Some compilers never learn. */
|
|
printf(">>>> Match against: ");
|
|
pchars(start_match, end_subject - start_match, TRUE, &match_block);
|
|
printf("\n");
|
|
#endif
|
|
|
|
/* When a match occurs, substrings will be set for all internal extractions;
|
|
we just need to set up the whole thing as substring 0 before returning. If
|
|
there were too many extractions, set the return code to zero. In the case
|
|
where we had to get some local store to hold offsets for backreferences, copy
|
|
those back references that we can. In this case there need not be overflow
|
|
if certain parts of the pattern were not used.
|
|
|
|
Before starting the match, we have to set up a longjmp() target to enable
|
|
the "cut" operation to fail a match completely without backtracking. This
|
|
is done in a separate function to avoid compiler warnings. We need not do
|
|
it unless PCRE_EXTRA is set, since only in that case is the "cut" operation
|
|
enabled. */
|
|
|
|
/* To handle errors such as running out of memory for the failure
|
|
stack, we need to save this location via setjmp(), so
|
|
error-handling code can call longjmp() to jump out of deeply-nested code. */
|
|
if (setjmp(match_block.error_env)==0)
|
|
{
|
|
|
|
if ((re->options & PCRE_EXTRA) != 0)
|
|
{
|
|
if (!match_with_setjmp(start_match, re->code, 2, &match_block))
|
|
continue;
|
|
}
|
|
else if (!match(start_match, re->code, 2, &match_block)) continue;
|
|
|
|
/* Copy the offset information from temporary store if necessary */
|
|
|
|
if (using_temporary_offsets)
|
|
{
|
|
if (offsetcount >= 4)
|
|
{
|
|
memcpy(offsets + 2, match_block.offset_vector + 2,
|
|
(offsetcount - 2) * sizeof(int));
|
|
DPRINTF(("Copied offsets from temporary memory\n"));
|
|
}
|
|
if (match_block.end_offset_top > offsetcount)
|
|
match_block.offset_overflow = TRUE;
|
|
|
|
DPRINTF(("Freeing temporary memory\n"));
|
|
(pcre_free)(match_block.offset_vector);
|
|
}
|
|
|
|
rc = match_block.offset_overflow? 0 : match_block.end_offset_top/2;
|
|
|
|
if (match_block.offset_end < 2) rc = 0; else
|
|
{
|
|
offsets[0] = start_match - match_block.start_subject;
|
|
offsets[1] = match_block.end_match_ptr - match_block.start_subject;
|
|
}
|
|
|
|
DPRINTF((">>>> returning %d\n", rc));
|
|
free_stack(&match_block);
|
|
return rc;
|
|
} /* End of (if setjmp(match_block.error_env)...) */
|
|
free_stack(&match_block);
|
|
|
|
/* Return an error code; pcremodule.c will preserve the exception */
|
|
if (PyErr_Occurred()) return PCRE_ERROR_NOMEMORY;
|
|
}
|
|
while (!anchored &&
|
|
match_block.errorcode == PCRE_ERROR_NOMATCH &&
|
|
start_match++ < end_subject);
|
|
|
|
if (using_temporary_offsets)
|
|
{
|
|
DPRINTF(("Freeing temporary memory\n"));
|
|
(pcre_free)(match_block.offset_vector);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
printf(">>>> returning %d\n", match_block.errorcode);
|
|
#endif
|
|
|
|
return match_block.errorcode;
|
|
}
|
|
|
|
/* End of pcre.c */
|