/*

* Secret Labs' Regular Expression Engine

*

* regular expression matching engine

*

* partial history:

* 1999-10-24 fl created (based on existing template matcher code)

* 2000-03-06 fl first alpha, sort of

* 2000-06-30 fl added fast search optimization

* 2000-06-30 fl added assert (lookahead) primitives, etc

* 2000-07-02 fl added charset optimizations, etc

* 2000-07-03 fl store code in pattern object, lookbehind, etc

* 2000-07-08 fl added regs attribute

* 2000-07-21 fl reset lastindex in scanner methods

* 2000-08-01 fl fixes for 1.6b1

* 2000-08-03 fl added recursion limit

* 2000-08-07 fl use PyOS_CheckStack() if available

* 2000-08-08 fl changed findall to return empty strings instead of None

* 2000-08-27 fl properly propagate memory errors

* 2000-09-02 fl return -1 instead of None for start/end/span

* 2000-09-20 fl added expand method

* 2000-09-21 fl don't use the buffer interface for unicode strings

* 2000-10-03 fl fixed assert_not primitive; support keyword arguments

* 2000-10-24 fl really fixed assert_not; reset groups in findall

* 2000-12-21 fl fixed memory leak in groupdict

* 2001-01-02 fl properly reset pointer after failed assertion in MIN_UNTIL

* 2001-01-15 fl avoid recursion for MIN_UNTIL; fixed uppercase literal bug

* 2001-01-16 fl fixed memory leak in pattern destructor

* 2001-03-20 fl lots of fixes for 2.1b2

* 2001-04-15 fl export copyright as Python attribute, not global

* 2001-04-28 fl added __copy__ methods (work in progress)

* 2001-05-14 fl fixes for 1.5.2

* 2001-07-01 fl added BIGCHARSET support (from Martin von Loewis)

* 2001-10-18 fl fixed group reset issue (from Matthew Mueller)

* 2001-10-20 fl added split primitive; reenable unicode for 1.6/2.0/2.1

* 2001-10-21 fl added sub/subn primitive

* 2001-10-22 fl check for literal sub/subn templates

* 2001-10-24 fl added finditer primitive (for 2.2 only)

* 2001-12-07 fl fixed memory leak in sub/subn (Guido van Rossum)

*

* Copyright (c) 1997-2001 by Secret Labs AB. All rights reserved.

*

* This version of the SRE library can be redistributed under CNRI's

* Python 1.6 license. For any other use, please contact Secret Labs

* AB ([email protected]).

*

* Portions of this engine have been developed in cooperation with

* CNRI. Hewlett-Packard provided funding for 1.6 integration and

* other compatibility work.

*/

#ifndef SRE_RECURSIVE

static char copyright[] =

" SRE 2.2.1 Copyright (c) 1997-2001 by Secret Labs AB ";

#include "Python.h"

#include "structmember.h" /* offsetof */

#include "sre.h"

#include <ctype.h>

/* name of this module, minus the leading underscore */

#if !defined(SRE_MODULE)

#define SRE_MODULE "sre"

#endif

/* defining this one enables tracing */

#undef VERBOSE

#if PY_VERSION_HEX >= 0x01060000

#if PY_VERSION_HEX < 0x02020000 || defined(Py_USING_UNICODE)

/* defining this enables unicode support (default under 1.6a1 and later) */

#define HAVE_UNICODE

#endif

#endif

/* -------------------------------------------------------------------- */

/* optional features */

/* prevent run-away recursion (bad patterns on long strings) */

#if !defined(USE_STACKCHECK)

#if defined(MS_WIN64) || defined(__LP64__) || defined(_LP64)

/* require smaller recursion limit for a number of 64-bit platforms:

Win64 (MS_WIN64), Linux64 (__LP64__), Monterey (64-bit AIX) (_LP64) */

/* FIXME: maybe the limit should be 40000 / sizeof(void*) ? */

#define USE_RECURSION_LIMIT 7500

#else

#define USE_RECURSION_LIMIT 10000

#endif

#endif

/* enables fast searching */

#define USE_FAST_SEARCH

/* enables aggressive inlining (always on for Visual C) */

#undef USE_INLINE

/* enables copy/deepcopy handling (work in progress) */

#undef USE_BUILTIN_COPY

#if PY_VERSION_HEX < 0x01060000

#define PyObject_DEL(op) PyMem_DEL((op))

#endif

/* -------------------------------------------------------------------- */

#if defined(_MSC_VER)

#pragma optimize("agtw", on) /* doesn't seem to make much difference... */

#pragma warning(disable: 4710) /* who cares if functions are not inlined ;-) */

/* fastest possible local call under MSVC */

#define LOCAL(type) static __inline type __fastcall

#elif defined(USE_INLINE)

#define LOCAL(type) static inline type

#else

#define LOCAL(type) static type

#endif

/* error codes */

#define SRE_ERROR_ILLEGAL -1 /* illegal opcode */

#define SRE_ERROR_STATE -2 /* illegal state */

#define SRE_ERROR_RECURSION_LIMIT -3 /* runaway recursion */

#define SRE_ERROR_MEMORY -9 /* out of memory */

#if defined(VERBOSE)

#define TRACE(v) printf v

#else

#define TRACE(v)

#endif

/* -------------------------------------------------------------------- */

/* search engine state */

/* default character predicates (run sre_chars.py to regenerate tables) */

#define SRE_DIGIT_MASK 1

#define SRE_SPACE_MASK 2

#define SRE_LINEBREAK_MASK 4

#define SRE_ALNUM_MASK 8

#define SRE_WORD_MASK 16

/* FIXME: this assumes ASCII. create tables in init_sre() instead */

static char sre_char_info[128] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 6, 2,

2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 25, 25, 25, 25, 25, 25, 25,

25, 25, 0, 0, 0, 0, 0, 0, 0, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,

24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 0, 0,

0, 0, 16, 0, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,

24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 0, 0, 0, 0, 0 };

static char sre_char_lower[128] = { 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 };

#define SRE_IS_DIGIT(ch)\

((ch) < 128 ? (sre_char_info[(ch)] & SRE_DIGIT_MASK) : 0)

#define SRE_IS_SPACE(ch)\

((ch) < 128 ? (sre_char_info[(ch)] & SRE_SPACE_MASK) : 0)

#define SRE_IS_LINEBREAK(ch)\

((ch) < 128 ? (sre_char_info[(ch)] & SRE_LINEBREAK_MASK) : 0)

#define SRE_IS_ALNUM(ch)\

((ch) < 128 ? (sre_char_info[(ch)] & SRE_ALNUM_MASK) : 0)

#define SRE_IS_WORD(ch)\

((ch) < 128 ? (sre_char_info[(ch)] & SRE_WORD_MASK) : 0)

static unsigned int sre_lower(unsigned int ch)

{

return ((ch) < 128 ? sre_char_lower[ch] : ch);

}

/* locale-specific character predicates */

#define SRE_LOC_IS_DIGIT(ch) ((ch) < 256 ? isdigit((ch)) : 0)

#define SRE_LOC_IS_SPACE(ch) ((ch) < 256 ? isspace((ch)) : 0)

#define SRE_LOC_IS_LINEBREAK(ch) ((ch) == '\n')

#define SRE_LOC_IS_ALNUM(ch) ((ch) < 256 ? isalnum((ch)) : 0)

#define SRE_LOC_IS_WORD(ch) (SRE_LOC_IS_ALNUM((ch)) || (ch) == '_')

static unsigned int sre_lower_locale(unsigned int ch)

{

return ((ch) < 256 ? tolower((ch)) : ch);

}

/* unicode-specific character predicates */

#if defined(HAVE_UNICODE)

#define SRE_UNI_IS_DIGIT(ch) Py_UNICODE_ISDIGIT((Py_UNICODE)(ch))

#define SRE_UNI_IS_SPACE(ch) Py_UNICODE_ISSPACE((Py_UNICODE)(ch))

#define SRE_UNI_IS_LINEBREAK(ch) Py_UNICODE_ISLINEBREAK((Py_UNICODE)(ch))

#define SRE_UNI_IS_ALNUM(ch) Py_UNICODE_ISALNUM((Py_UNICODE)(ch))

#define SRE_UNI_IS_WORD(ch) (SRE_UNI_IS_ALNUM((ch)) || (ch) == '_')

static unsigned int sre_lower_unicode(unsigned int ch)

{

return (unsigned int) Py_UNICODE_TOLOWER((Py_UNICODE)(ch));

}

#endif

LOCAL(int)

sre_category(SRE_CODE category, unsigned int ch)

{

switch (category) {

case SRE_CATEGORY_DIGIT:

return SRE_IS_DIGIT(ch);

case SRE_CATEGORY_NOT_DIGIT:

return !SRE_IS_DIGIT(ch);

case SRE_CATEGORY_SPACE:

return SRE_IS_SPACE(ch);

case SRE_CATEGORY_NOT_SPACE:

return !SRE_IS_SPACE(ch);

case SRE_CATEGORY_WORD:

return SRE_IS_WORD(ch);

case SRE_CATEGORY_NOT_WORD:

return !SRE_IS_WORD(ch);

case SRE_CATEGORY_LINEBREAK:

return SRE_IS_LINEBREAK(ch);

case SRE_CATEGORY_NOT_LINEBREAK:

return !SRE_IS_LINEBREAK(ch);

case SRE_CATEGORY_LOC_WORD:

return SRE_LOC_IS_WORD(ch);

case SRE_CATEGORY_LOC_NOT_WORD:

return !SRE_LOC_IS_WORD(ch);

#if defined(HAVE_UNICODE)

case SRE_CATEGORY_UNI_DIGIT:

return SRE_UNI_IS_DIGIT(ch);

case SRE_CATEGORY_UNI_NOT_DIGIT:

return !SRE_UNI_IS_DIGIT(ch);

case SRE_CATEGORY_UNI_SPACE:

return SRE_UNI_IS_SPACE(ch);

case SRE_CATEGORY_UNI_NOT_SPACE:

return !SRE_UNI_IS_SPACE(ch);

case SRE_CATEGORY_UNI_WORD:

return SRE_UNI_IS_WORD(ch);

case SRE_CATEGORY_UNI_NOT_WORD:

return !SRE_UNI_IS_WORD(ch);

case SRE_CATEGORY_UNI_LINEBREAK:

return SRE_UNI_IS_LINEBREAK(ch);

case SRE_CATEGORY_UNI_NOT_LINEBREAK:

return !SRE_UNI_IS_LINEBREAK(ch);

#else

case SRE_CATEGORY_UNI_DIGIT:

return SRE_IS_DIGIT(ch);

case SRE_CATEGORY_UNI_NOT_DIGIT:

return !SRE_IS_DIGIT(ch);

case SRE_CATEGORY_UNI_SPACE:

return SRE_IS_SPACE(ch);

case SRE_CATEGORY_UNI_NOT_SPACE:

return !SRE_IS_SPACE(ch);

case SRE_CATEGORY_UNI_WORD:

return SRE_LOC_IS_WORD(ch);

case SRE_CATEGORY_UNI_NOT_WORD:

return !SRE_LOC_IS_WORD(ch);

case SRE_CATEGORY_UNI_LINEBREAK:

return SRE_IS_LINEBREAK(ch);

case SRE_CATEGORY_UNI_NOT_LINEBREAK:

return !SRE_IS_LINEBREAK(ch);

#endif

}

return 0;

}

/* helpers */

static void

mark_fini(SRE_STATE* state)

{

if (state->mark_stack) {

free(state->mark_stack);

state->mark_stack = NULL;

}

state->mark_stack_size = state->mark_stack_base = 0;

}

static int

mark_save(SRE_STATE* state, int lo, int hi)

{

void* stack;

int size;

int minsize, newsize;

if (hi <= lo)

return 0;

size = (hi - lo) + 1;

newsize = state->mark_stack_size;

minsize = state->mark_stack_base + size;

if (newsize < minsize) {

/* create new stack */

if (!newsize) {

newsize = 512;

if (newsize < minsize)

newsize = minsize;

TRACE(("allocate stack %d\n", newsize));

stack = malloc(sizeof(void*) * newsize);

} else {

/* grow the stack */

while (newsize < minsize)

newsize += newsize;

TRACE(("grow stack to %d\n", newsize));

stack = realloc(state->mark_stack, sizeof(void*) * newsize);

}

if (!stack) {

mark_fini(state);

return SRE_ERROR_MEMORY;

}

state->mark_stack = stack;

state->mark_stack_size = newsize;

}

TRACE(("copy %d:%d to %d (%d)\n", lo, hi, state->mark_stack_base, size));

memcpy(state->mark_stack + state->mark_stack_base, state->mark + lo,

size * sizeof(void*));

state->mark_stack_base += size;

return 0;

}

static int

mark_restore(SRE_STATE* state, int lo, int hi)

{

int size;

if (hi <= lo)

return 0;

size = (hi - lo) + 1;

state->mark_stack_base -= size;

TRACE(("copy %d:%d from %d\n", lo, hi, state->mark_stack_base));

memcpy(state->mark + lo, state->mark_stack + state->mark_stack_base,

size * sizeof(void*));

return 0;

}

/* generate 8-bit version */

#define SRE_CHAR unsigned char

#define SRE_AT sre_at

#define SRE_COUNT sre_count

#define SRE_CHARSET sre_charset

#define SRE_INFO sre_info

#define SRE_MATCH sre_match

#define SRE_SEARCH sre_search

#define SRE_LITERAL_TEMPLATE sre_literal_template

#if defined(HAVE_UNICODE)

#define SRE_RECURSIVE

#include "_sre.c"

#undef SRE_RECURSIVE

#undef SRE_LITERAL_TEMPLATE

#undef SRE_SEARCH

#undef SRE_MATCH

#undef SRE_INFO

#undef SRE_CHARSET

#undef SRE_COUNT

#undef SRE_AT

#undef SRE_CHAR

/* generate 16-bit unicode version */

#define SRE_CHAR Py_UNICODE

#define SRE_AT sre_uat

#define SRE_COUNT sre_ucount

#define SRE_CHARSET sre_ucharset

#define SRE_INFO sre_uinfo

#define SRE_MATCH sre_umatch

#define SRE_SEARCH sre_usearch

#define SRE_LITERAL_TEMPLATE sre_uliteral_template

#endif

#endif /* SRE_RECURSIVE */

/* -------------------------------------------------------------------- */

/* String matching engine */

/* the following section is compiled twice, with different character

settings */

LOCAL(int)

SRE_AT(SRE_STATE* state, SRE_CHAR* ptr, SRE_CODE at)

{

/* check if pointer is at given position */

int this, that;

switch (at) {

case SRE_AT_BEGINNING:

case SRE_AT_BEGINNING_STRING:

return ((void*) ptr == state->beginning);

case SRE_AT_BEGINNING_LINE:

return ((void*) ptr == state->beginning ||

SRE_IS_LINEBREAK((int) ptr[-1]));

case SRE_AT_END:

return (((void*) (ptr+1) == state->end &&

SRE_IS_LINEBREAK((int) ptr[0])) ||

((void*) ptr == state->end));

case SRE_AT_END_LINE:

return ((void*) ptr == state->end ||

SRE_IS_LINEBREAK((int) ptr[0]));

case SRE_AT_END_STRING:

return ((void*) ptr == state->end);

case SRE_AT_BOUNDARY:

if (state->beginning == state->end)

return 0;

that = ((void*) ptr > state->beginning) ?

SRE_IS_WORD((int) ptr[-1]) : 0;

this = ((void*) ptr < state->end) ?

SRE_IS_WORD((int) ptr[0]) : 0;

return this != that;

case SRE_AT_NON_BOUNDARY:

if (state->beginning == state->end)

return 0;

that = ((void*) ptr > state->beginning) ?

SRE_IS_WORD((int) ptr[-1]) : 0;

this = ((void*) ptr < state->end) ?

SRE_IS_WORD((int) ptr[0]) : 0;

return this == that;

case SRE_AT_LOC_BOUNDARY:

if (state->beginning == state->end)

return 0;

that = ((void*) ptr > state->beginning) ?

SRE_LOC_IS_WORD((int) ptr[-1]) : 0;

this = ((void*) ptr < state->end) ?

SRE_LOC_IS_WORD((int) ptr[0]) : 0;

return this != that;

case SRE_AT_LOC_NON_BOUNDARY:

if (state->beginning == state->end)

return 0;

that = ((void*) ptr > state->beginning) ?

SRE_LOC_IS_WORD((int) ptr[-1]) : 0;

this = ((void*) ptr < state->end) ?

SRE_LOC_IS_WORD((int) ptr[0]) : 0;

return this == that;

#if defined(HAVE_UNICODE)

case SRE_AT_UNI_BOUNDARY:

if (state->beginning == state->end)

return 0;

that = ((void*) ptr > state->beginning) ?

SRE_UNI_IS_WORD((int) ptr[-1]) : 0;

this = ((void*) ptr < state->end) ?

SRE_UNI_IS_WORD((int) ptr[0]) : 0;

return this != that;

case SRE_AT_UNI_NON_BOUNDARY:

if (state->beginning == state->end)

return 0;

that = ((void*) ptr > state->beginning) ?

SRE_UNI_IS_WORD((int) ptr[-1]) : 0;

this = ((void*) ptr < state->end) ?

SRE_UNI_IS_WORD((int) ptr[0]) : 0;

return this == that;

#endif

}

return 0;

}

LOCAL(int)

SRE_CHARSET(SRE_CODE* set, SRE_CODE ch)

{

/* check if character is a member of the given set */

int ok = 1;

for (;;) {

switch (*set++) {

case SRE_OP_LITERAL:

/* <LITERAL> <code> */

if (ch == set[0])

return ok;

set++;

break;

case SRE_OP_RANGE:

/* <RANGE> <lower> <upper> */

if (set[0] <= ch && ch <= set[1])

return ok;

set += 2;

break;

case SRE_OP_CHARSET:

/* <CHARSET> <bitmap> (16 bits per code word) */

if (ch < 256 && (set[ch >> 4] & (1 << (ch & 15))))

return ok;

set += 16;

break;

case SRE_OP_BIGCHARSET:

/* <BIGCHARSET> <blockcount> <256 blockindices> <blocks> */

{

int count, block;

count = *(set++);

block = ((unsigned char*)set)[ch >> 8];

set += 128;

if (set[block*16 + ((ch & 255)>>4)] & (1 << (ch & 15)))

return ok;

set += count*16;

break;

}

case SRE_OP_CATEGORY:

/* <CATEGORY> <code> */

if (sre_category(set[0], (int) ch))

return ok;

set += 1;

break;

case SRE_OP_NEGATE:

ok = !ok;

break;

case SRE_OP_FAILURE:

return !ok;

default:

/* internal error -- there's not much we can do about it

here, so let's just pretend it didn't match... */

return 0;

}

}

}

LOCAL(int) SRE_MATCH(SRE_STATE* state, SRE_CODE* pattern, int level);

LOCAL(int)

SRE_COUNT(SRE_STATE* state, SRE_CODE* pattern, int maxcount, int level)

{

SRE_CODE chr;

SRE_CHAR* ptr = state->ptr;

SRE_CHAR* end = state->end;

int i;

/* adjust end */

if (maxcount < end - ptr && maxcount != 65535)

end = ptr + maxcount;

switch (pattern[0]) {

case SRE_OP_ANY:

/* repeated dot wildcard. */

TRACE(("|%p|%p|COUNT ANY\n", pattern, ptr));

while (ptr < end && !SRE_IS_LINEBREAK(*ptr))

ptr++;

break;

case SRE_OP_ANY_ALL:

/* repeated dot wildcare. skip to the end of the target

string, and backtrack from there */

TRACE(("|%p|%p|COUNT ANY_ALL\n", pattern, ptr));

ptr = end;

break;

case SRE_OP_LITERAL:

/* repeated literal */

chr = pattern[1];

TRACE(("|%p|%p|COUNT LITERAL %d\n", pattern, ptr, chr));

while (ptr < end && (SRE_CODE) *ptr == chr)

ptr++;

break;

case SRE_OP_LITERAL_IGNORE:

/* repeated literal */

chr = pattern[1];

TRACE(("|%p|%p|COUNT LITERAL_IGNORE %d\n", pattern, ptr, chr));

while (ptr < end && (SRE_CODE) state->lower(*ptr) == chr)

ptr++;

break;

case SRE_OP_NOT_LITERAL:

/* repeated non-literal */

chr = pattern[1];

TRACE(("|%p|%p|COUNT NOT_LITERAL %d\n", pattern, ptr, chr));

while (ptr < end && (SRE_CODE) *ptr != chr)

ptr++;

break;

case SRE_OP_NOT_LITERAL_IGNORE:

/* repeated non-literal */

chr = pattern[1];

TRACE(("|%p|%p|COUNT NOT_LITERAL_IGNORE %d\n", pattern, ptr, chr));

while (ptr < end && (SRE_CODE) state->lower(*ptr) != chr)

ptr++;

break;

case SRE_OP_IN:

/* repeated set */

TRACE(("|%p|%p|COUNT IN\n", pattern, ptr));

while (ptr < end && SRE_CHARSET(pattern + 2, *ptr))

ptr++;

break;

default:

/* repeated single character pattern */

TRACE(("|%p|%p|COUNT SUBPATTERN\n", pattern, ptr));

while ((SRE_CHAR*) state->ptr < end) {

i = SRE_MATCH(state, pattern, level);

if (i < 0)

return i;

if (!i)

break;

}

TRACE(("|%p|%p|COUNT %d\n", pattern, ptr,

(SRE_CHAR*) state->ptr - ptr));

return (SRE_CHAR*) state->ptr - ptr;

}

TRACE(("|%p|%p|COUNT %d\n", pattern, ptr, ptr - (SRE_CHAR*) state->ptr));

return ptr - (SRE_CHAR*) state->ptr;

}

#if 0 /* not used in this release */

LOCAL(int)

SRE_INFO(SRE_STATE* state, SRE_CODE* pattern)

{

/* check if an SRE_OP_INFO block matches at the current position.

returns the number of SRE_CODE objects to skip if successful, 0

if no match */

SRE_CHAR* end = state->end;

SRE_CHAR* ptr = state->ptr;

int i;

/* check minimal length */

if (pattern[3] && (end - ptr) < pattern[3])

return 0;

/* check known prefix */

if (pattern[2] & SRE_INFO_PREFIX && pattern[5] > 1) {

/* <length> <skip> <prefix data> <overlap data> */

for (i = 0; i < pattern[5]; i++)

if ((SRE_CODE) ptr[i] != pattern[7 + i])

return 0;

return pattern[0] + 2 * pattern[6];

}

return pattern[0];

}

#endif

LOCAL(int)

SRE_MATCH(SRE_STATE* state, SRE_CODE* pattern, int level)

{

/* check if string matches the given pattern. returns <0 for

error, 0 for failure, and 1 for success */

SRE_CHAR* end = state->end;

SRE_CHAR* ptr = state->ptr;

int i, count;

SRE_REPEAT* rp;

int lastmark;

SRE_CODE chr;

SRE_REPEAT rep; /* FIXME: <fl> allocate in STATE instead */

TRACE(("|%p|%p|ENTER %d\n", pattern, ptr, level));

#if defined(USE_STACKCHECK)

if (level % 10 == 0 && PyOS_CheckStack())

return SRE_ERROR_RECURSION_LIMIT;

#endif

#if defined(USE_RECURSION_LIMIT)

if (level > USE_RECURSION_LIMIT)

return SRE_ERROR_RECURSION_LIMIT;

#endif

if (pattern[0] == SRE_OP_INFO) {

/* optimization info block */

/* <INFO> <1=skip> <2=flags> <3=min> ... */

if (pattern[3] && (end - ptr) < pattern[3]) {

TRACE(("reject (got %d chars, need %d)\n",

(end - ptr), pattern[3]));

return 0;

}

pattern += pattern[1] + 1;

}

for (;;) {

switch (*pattern++) {

case SRE_OP_FAILURE:

/* immediate failure */

TRACE(("|%p|%p|FAILURE\n", pattern, ptr));

return 0;

case SRE_OP_SUCCESS:

/* end of pattern */

TRACE(("|%p|%p|SUCCESS\n", pattern, ptr));

state->ptr = ptr;

return 1;

case SRE_OP_AT:

/* match at given position */

/* <AT> <code> */

TRACE(("|%p|%p|AT %d\n", pattern, ptr, *pattern));

if (!SRE_AT(state, ptr, *pattern))

return 0;

pattern++;

break;

case SRE_OP_CATEGORY:

/* match at given category */

/* <CATEGORY> <code> */

TRACE(("|%p|%p|CATEGORY %d\n", pattern, ptr, *pattern));

if (ptr >= end || !sre_category(pattern[0], ptr[0]))

return 0;

pattern++;

ptr++;

break;

case SRE_OP_LITERAL:

/* match literal string */

/* <LITERAL> <code> */

TRACE(("|%p|%p|LITERAL %d\n", pattern, ptr, *pattern));

if (ptr >= end || (SRE_CODE) ptr[0] != pattern[0])

return 0;

pattern++;

ptr++;

break;

case SRE_OP_NOT_LITERAL:

/* match anything that is not literal character */

/* <NOT_LITERAL> <code> */

TRACE(("|%p|%p|NOT_LITERAL %d\n", pattern, ptr, *pattern));

if (ptr >= end || (SRE_CODE) ptr[0] == pattern[0])

return 0;

pattern++;

ptr++;

break;

case SRE_OP_ANY:

/* match anything (except a newline) */

/* <ANY> */

TRACE(("|%p|%p|ANY\n", pattern, ptr));

if (ptr >= end || SRE_IS_LINEBREAK(ptr[0]))

return 0;

ptr++;

break;

case SRE_OP_ANY_ALL:

/* match anything */

/* <ANY_ALL> */

TRACE(("|%p|%p|ANY_ALL\n", pattern, ptr));

if (ptr >= end)

return 0;

ptr++;

break;

case SRE_OP_IN:

/* match set member (or non_member) */

/* <IN> <skip> <set> */

TRACE(("|%p|%p|IN\n", pattern, ptr));

if (ptr >= end || !SRE_CHARSET(pattern + 1, *ptr))

return 0;

pattern += pattern[0];

ptr++;

break;

case SRE_OP_GROUPREF:

/* match backreference */

TRACE(("|%p|%p|GROUPREF %d\n", pattern, ptr, pattern[0]));

i = pattern[0];

{

SRE_CHAR* p = (SRE_CHAR*) state->mark[i+i];

SRE_CHAR* e = (SRE_CHAR*) state->mark[i+i+1];

if (!p || !e || e < p)

return 0;

while (p < e) {

if (ptr >= end || *ptr != *p)

return 0;

p++; ptr++;

}

}

pattern++;

break;

case SRE_OP_GROUPREF_IGNORE:

/* match backreference */

TRACE(("|%p|%p|GROUPREF_IGNORE %d\n", pattern, ptr, pattern[0]));

i = pattern[0];

{

SRE_CHAR* p = (SRE_CHAR*) state->mark[i+i];

SRE_CHAR* e = (SRE_CHAR*) state->mark[i+i+1];

if (!p || !e || e < p)

return 0;

while (p < e) {

if (ptr >= end ||

state->lower(*ptr) != state->lower(*p))

return 0;

p++; ptr++;

}

}

pattern++;

break;

case SRE_OP_LITERAL_IGNORE:

TRACE(("|%p|%p|LITERAL_IGNORE %d\n", pattern, ptr, pattern[0]));

if (ptr >= end ||

state->lower(*ptr) != state->lower(*pattern))

return 0;

pattern++;

ptr++;

break;

case SRE_OP_NOT_LITERAL_IGNORE:

TRACE(("|%p|%p|NOT_LITERAL_IGNORE %d\n", pattern, ptr, *pattern));

if (ptr >= end ||

state->lower(*ptr) == state->lower(*pattern))

return 0;

pattern++;

ptr++;

break;

case SRE_OP_IN_IGNORE:

TRACE(("|%p|%p|IN_IGNORE\n", pattern, ptr));

if (ptr >= end

|| !SRE_CHARSET(pattern + 1, (SRE_CODE) state->lower(*ptr)))

return 0;

pattern += pattern[0];

ptr++;

break;

case SRE_OP_MARK:

/* set mark */

/* <MARK> <gid> */

TRACE(("|%p|%p|MARK %d\n", pattern, ptr, pattern[0]));

i = pattern[0];

if (i & 1)

state->lastindex = i/2 + 1;

if (i > state->lastmark)

state->lastmark = i;

state->mark[i] = ptr;

pattern++;

break;

case SRE_OP_JUMP:

case SRE_OP_INFO:

/* jump forward */

/* <JUMP> <offset> */

TRACE(("|%p|%p|JUMP %d\n", pattern, ptr, pattern[0]));

pattern += pattern[0];

break;

case SRE_OP_ASSERT:

/* assert subpattern */

/* <ASSERT> <skip> <back> <pattern> */

TRACE(("|%p|%p|ASSERT %d\n", pattern, ptr, pattern[1]));

state->ptr = ptr - pattern[1];

if (state->ptr < state->beginning)

return 0;

i = SRE_MATCH(state, pattern + 2, level + 1);

if (i <= 0)

return i;

pattern += pattern[0];

break;

case SRE_OP_ASSERT_NOT:

/* assert not subpattern */

/* <ASSERT_NOT> <skip> <back> <pattern> */

TRACE(("|%p|%p|ASSERT_NOT %d\n", pattern, ptr, pattern[1]));

state->ptr = ptr - pattern[1];

if (state->ptr >= state->beginning) {

i = SRE_MATCH(state, pattern + 2, level + 1);

if (i < 0)

return i;

if (i)

return 0;

}

pattern += pattern[0];

break;

case SRE_OP_BRANCH:

/* alternation */

/* <BRANCH> <0=skip> code <JUMP> ... <NULL> */

TRACE(("|%p|%p|BRANCH\n", pattern, ptr));

lastmark = state->lastmark;

for (; pattern[0]; pattern += pattern[0]) {

if (pattern[1] == SRE_OP_LITERAL &&

(ptr >= end || (SRE_CODE) *ptr != pattern[2]))

continue;

if (pattern[1] == SRE_OP_IN &&

(ptr >= end || !SRE_CHARSET(pattern + 3, (SRE_CODE) *ptr)))

continue;

state->ptr = ptr;

i = SRE_MATCH(state, pattern + 1, level + 1);

if (i)

return i;

if (state->lastmark > lastmark) {

memset(

state->mark + lastmark + 1, 0,

(state->lastmark - lastmark) * sizeof(void*)

);

state->lastmark = lastmark;

}

}

return 0;

case SRE_OP_REPEAT_ONE:

/* match repeated sequence (maximizing regexp) */

/* this operator only works if the repeated item is

exactly one character wide, and we're not already

collecting backtracking points. for other cases,

use the MAX_REPEAT operator */

/* <REPEAT_ONE> <skip> <1=min> <2=max> item <SUCCESS> tail */

TRACE(("|%p|%p|REPEAT_ONE %d %d\n", pattern, ptr,

pattern[1], pattern[2]));

if (ptr + pattern[1] > end)

return 0; /* cannot match */

state->ptr = ptr;

count = SRE_COUNT(state, pattern + 3, pattern[2], level + 1);

if (count < 0)

return count;

ptr += count;

/* when we arrive here, count contains the number of

matches, and ptr points to the tail of the target

string. check if the rest of the pattern matches,

and backtrack if not. */

if (count < (int) pattern[1])

return 0;

if (pattern[pattern[0]] == SRE_OP_SUCCESS) {

/* tail is empty. we're finished */

state->ptr = ptr;

return 1;

} else if (pattern[pattern[0]] == SRE_OP_LITERAL) {

/* tail starts with a literal. skip positions where

the rest of the pattern cannot possibly match */

chr = pattern[pattern[0]+1];

for (;;) {

while (count >= (int) pattern[1] &&

(ptr >= end || *ptr != chr)) {

ptr--;

count--;

}

if (count < (int) pattern[1])

break;

state->ptr = ptr;

i = SRE_MATCH(state, pattern + pattern[0], level + 1);

if (i)

return i;

ptr--;

count--;

}

} else {

/* general case */

lastmark = state->lastmark;

while (count >= (int) pattern[1]) {

state->ptr = ptr;

i = SRE_MATCH(state, pattern + pattern[0], level + 1);

if (i)

return i;

ptr--;

count--;

if (state->lastmark > lastmark) {