/* -*- Mode: C; tab-width: 4 -*-

*

* Secret Labs' Regular Expression Engine

*

* regular expression matching engine

*

* partial history:

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

* 99-11-13 fl added categories, branching, and more (0.2)

* 99-11-16 fl some tweaks to compile on non-Windows platforms

* 99-12-18 fl non-literals, generic maximizing repeat (0.3)

* 00-02-28 fl tons of changes (not all to the better ;-) (0.4)

* 00-03-06 fl first alpha, sort of (0.5)

* 00-03-14 fl removed most compatibility stuff (0.6)

* 00-05-10 fl towards third alpha (0.8.2)

* 00-05-13 fl added experimental scanner stuff (0.8.3)

* 00-05-27 fl final bug hunt (0.8.4)

* 00-06-21 fl less bugs, more taste (0.8.5)

* 00-06-25 fl major changes to better deal with nested repeats (0.9)

* 00-06-28 fl fixed findall (0.9.1)

* 00-06-29 fl fixed split, added more scanner features (0.9.2)

* 00-06-30 fl added fast search optimization (0.9.3)

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

* 00-07-02 fl added charset optimizations, etc (0.9.5)

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

*

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

*

* Portions of this engine have been developed in cooperation with

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

* other compatibility work.

*/

#ifndef SRE_RECURSIVE

char copyright[] = " SRE 0.9.5 Copyright (c) 1997-2000 by Secret Labs AB ";

#include "Python.h"

#include "sre.h"

#if defined(HAVE_LIMITS_H)

#include <limits.h>

#else

#define INT_MAX 2147483647

#endif

#include <ctype.h>

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

#define MODULE "sre"

/* defining this one enables tracing */

#undef DEBUG

#if PY_VERSION_HEX >= 0x01060000

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

#define HAVE_UNICODE

#endif

/* optional features */

#define USE_FAST_SEARCH

#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

#else

#define LOCAL(type) static inline type

#endif

/* error codes */

#define SRE_ERROR_ILLEGAL -1 /* illegal opcode */

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

#if defined(DEBUG)

#define TRACE(v) printf v

#else

#define TRACE(v)

#endif

#define PTR(ptr) ((SRE_CHAR*) (ptr) - (SRE_CHAR*) state->beginning)

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

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

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 };

static unsigned int sre_lower(unsigned int ch)

{

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

}

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

/* locale-specific character predicates */

static unsigned int sre_lower_locale(unsigned int ch)

{

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

}

#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) == '_')

/* unicode-specific character predicates */

#if defined(HAVE_UNICODE)

static unsigned int sre_lower_unicode(unsigned int ch)

{

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

}

#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_IS_ALNUM((ch)) || (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);

#endif

}

return 0;

}

/* helpers */

LOCAL(int)

stack_free(SRE_STATE* state)

{

if (state->stack) {

TRACE(("release stack\n"));

free(state->stack);

state->stack = NULL;

}

state->stacksize = 0;

return 0;

}

static int /* shouldn't be LOCAL */

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

{

SRE_STACK* stack;

int stacksize;

/* grow the stack to a suitable size; we need at least lo entries,

at most hi entries. if for some reason hi is lower than lo, lo

wins */

stacksize = state->stacksize;

if (stacksize == 0) {

/* create new stack */

stacksize = 512;

if (stacksize < lo)

stacksize = lo;

else if (stacksize > hi)

stacksize = hi;

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

stack = malloc(sizeof(SRE_STACK) * stacksize);

} else {

/* grow the stack (typically by a factor of two) */

while (stacksize < lo)

stacksize = 2 * stacksize;

/* FIXME: <fl> could trim size if it's much larger than hi,

as long it's larger than lo */

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

stack = realloc(state->stack, sizeof(SRE_STACK) * stacksize);

}

if (!stack) {

stack_free(state);

return SRE_ERROR_MEMORY;

}

state->stack = stack;

state->stacksize = stacksize;

return 0;

}

/* generate 8-bit version */

#define SRE_CHAR unsigned char

#define SRE_AT sre_at

#define SRE_MEMBER sre_member

#define SRE_MATCH sre_match

#define SRE_SEARCH sre_search

#if defined(HAVE_UNICODE)

#define SRE_RECURSIVE

#include "_sre.c"

#undef SRE_RECURSIVE

#undef SRE_SEARCH

#undef SRE_MATCH

#undef SRE_MEMBER

#undef SRE_AT

#undef SRE_CHAR

/* generate 16-bit unicode version */

#define SRE_CHAR Py_UNICODE

#define SRE_AT sre_uat

#define SRE_MEMBER sre_umember

#define SRE_MATCH sre_umatch

#define SRE_SEARCH sre_usearch

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

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_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;

}

return 0;

}

LOCAL(int)

SRE_MEMBER(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_NEGATE:

ok = !ok;

break;

case SRE_OP_FAILURE:

return !ok;

case SRE_OP_LITERAL:

/* args: <literal> */

if (ch == set[0])

return ok;

set++;

break;

case SRE_OP_RANGE:

/* args: <lower> <upper> */

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

return ok;

set += 2;

break;

case SRE_OP_CHARSET:

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

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

return ok;

set += 16;

break;

case SRE_OP_CATEGORY:

/* args: <category> */

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

return ok;

set += 1;

break;

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)

{

/* check if string matches the given pattern. returns -1 for

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

SRE_CHAR* end = state->end;

SRE_CHAR* ptr = state->ptr;

int stack;

int stackbase;

int lastmark;

int i, count;

SRE_STACK* sp;

/* FIXME: this is a hack! */

void* mark_copy[SRE_MARK_SIZE];

void* mark = NULL;

TRACE(("%8d: enter\n", PTR(ptr)));

if (pattern[0] == SRE_OP_INFO) {

/* optimization info block */

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

}

stackbase = stack = state->stackbase;

lastmark = state->lastmark;

retry:

for (;;) {

switch (*pattern++) {

case SRE_OP_FAILURE:

/* immediate failure */

TRACE(("%8d: failure\n", PTR(ptr)));

goto failure;

case SRE_OP_SUCCESS:

/* end of pattern */

TRACE(("%8d: success\n", PTR(ptr)));

state->ptr = ptr;

goto success;

case SRE_OP_AT:

/* match at given position */

/* args: <at> */

TRACE(("%8d: position %d\n", PTR(ptr), *pattern));

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

goto failure;

pattern++;

break;

case SRE_OP_CATEGORY:

/* match at given category */

/* args: <category> */

TRACE(("%8d: category %d [category %d]\n", PTR(ptr),

*ptr, *pattern));

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

goto failure;

TRACE(("%8d: category ok\n", PTR(ptr)));

pattern++;

ptr++;

break;

case SRE_OP_LITERAL:

/* match literal string */

/* args: <code> */

TRACE(("%8d: literal %c\n", PTR(ptr), pattern[0]));

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

goto failure;

pattern++;

ptr++;

break;

case SRE_OP_NOT_LITERAL:

/* match anything that is not literal character */

/* args: <code> */

TRACE(("%8d: literal not %c\n", PTR(ptr), pattern[0]));

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

goto failure;

pattern++;

ptr++;

break;

case SRE_OP_ANY:

/* match anything */

TRACE(("%8d: anything\n", PTR(ptr)));

if (ptr >= end)

goto failure;

ptr++;

break;

case SRE_OP_IN:

/* match set member (or non_member) */

/* args: <skip> <set> */

TRACE(("%8d: set %c\n", PTR(ptr), *ptr));

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

goto failure;

pattern += pattern[0];

ptr++;

break;

case SRE_OP_GROUP:

/* match backreference */

TRACE(("%8d: group %d\n", PTR(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)

goto failure;

while (p < e) {

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

goto failure;

p++; ptr++;

}

}

pattern++;

break;

case SRE_OP_GROUP_IGNORE:

/* match backreference */

TRACE(("%8d: group ignore %d\n", PTR(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)

goto failure;

while (p < e) {

if (ptr >= end ||

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

goto failure;

p++; ptr++;

}

}

pattern++;

break;

case SRE_OP_LITERAL_IGNORE:

TRACE(("%8d: literal lower(%c)\n", PTR(ptr), pattern[0]));

if (ptr >= end ||

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

goto failure;

pattern++;

ptr++;

break;

case SRE_OP_NOT_LITERAL_IGNORE:

TRACE(("%8d: literal not lower(%c)\n", PTR(ptr), pattern[0]));

if (ptr >= end ||

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

goto failure;

pattern++;

ptr++;

break;

case SRE_OP_IN_IGNORE:

TRACE(("%8d: set lower(%c)\n", PTR(ptr), *ptr));

if (ptr >= end

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

goto failure;

pattern += pattern[0];

ptr++;

break;

case SRE_OP_MARK:

/* set mark */

/* args: <mark> */

TRACE(("%8d: set mark %d\n", PTR(ptr), pattern[0]));

if (state->lastmark < pattern[0]+1)

state->lastmark = pattern[0]+1;

if (!mark) {

mark = mark_copy;

memcpy(mark, state->mark, state->lastmark*sizeof(void*));

}

state->mark[pattern[0]] = ptr;

pattern++;

break;

case SRE_OP_INDEX:

/* set index */

/* args: <index> */

TRACE(("%8d: set index %d\n", PTR(ptr), pattern[0]));

state->lastindex = pattern[0];

pattern++;

break;

case SRE_OP_JUMP:

case SRE_OP_INFO:

/* jump forward */

/* args: <skip> */

TRACE(("%8d: jump +%d\n", PTR(ptr), pattern[0]));

pattern += pattern[0];

break;

case SRE_OP_ASSERT:

/* assert subpattern */

/* args: <skip> <back> <pattern> */

TRACE(("%8d: assert subpattern %d\n", PTR(ptr), pattern[1]));

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

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

goto failure;

i = SRE_MATCH(state, pattern + 2);

if (i < 0)

return i;

if (!i)

goto failure;

pattern += pattern[0];

break;

case SRE_OP_ASSERT_NOT:

/* assert not subpattern */

/* args: <skip> <pattern> */

TRACE(("%8d: assert not subpattern %d\n", PTR(ptr), pattern[1]));

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

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

goto failure;

i = SRE_MATCH(state, pattern + 2);

if (i < 0)

return i;

if (i)

goto failure;

pattern += pattern[0];

break;

#if 0

case SRE_OP_MAX_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 instead */

/* args: <skip> <min> <max> <step> */

TRACE(("%8d: max repeat one {%d,%d}\n", PTR(ptr),

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

count = 0;

if (pattern[3] == SRE_OP_ANY) {

/* repeated wildcard. skip to the end of the target

string, and backtrack from there */

/* FIXME: must look for line endings */

if (ptr + pattern[1] > end)

goto failure; /* cannot match */

count = pattern[2];

if (count > end - ptr)

count = end - ptr;

ptr += count;

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

/* repeated literal */

SRE_CODE chr = pattern[4];

while (count < (int) pattern[2]) {

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

break;

ptr++;

count++;

}

} else if (pattern[3] == SRE_OP_LITERAL_IGNORE) {

/* repeated literal */

SRE_CODE chr = pattern[4];

while (count < (int) pattern[2]) {

if (ptr >= end || (SRE_CODE) state->lower(*ptr) != chr)

break;

ptr++;

count++;

}

} else if (pattern[3] == SRE_OP_NOT_LITERAL) {

/* repeated non-literal */

SRE_CODE chr = pattern[4];

while (count < (int) pattern[2]) {

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

break;

ptr++;

count++;

}

} else if (pattern[3] == SRE_OP_NOT_LITERAL_IGNORE) {

/* repeated non-literal */

SRE_CODE chr = pattern[4];

while (count < (int) pattern[2]) {

if (ptr >= end || (SRE_CODE) state->lower(ptr[0]) == chr)

break;

ptr++;

count++;

}

} else if (pattern[3] == SRE_OP_IN) {

/* repeated set */

while (count < (int) pattern[2]) {

if (ptr >= end || !SRE_MEMBER(pattern + 5, *ptr))

break;

ptr++;

count++;

}

} else {

/* repeated single character pattern */

state->ptr = ptr;

while (count < (int) pattern[2]) {

i = SRE_MATCH(state, pattern + 3);

if (i < 0)

return i;

if (!i)

break;

count++;

}

state->ptr = ptr;

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

TRACE(("%8d: repeat %d found\n", PTR(ptr), count));

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

goto failure;

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

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

TRACE(("%8d: tail is empty\n", PTR(ptr)));

state->ptr = ptr;

goto success;

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

/* tail starts with a literal. skip positions where

the rest of the pattern cannot possibly match */

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

TRACE(("%8d: tail is literal %d\n", PTR(ptr), chr));

for (;;) {

TRACE(("%8d: scan for tail match\n", PTR(ptr)));

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

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

ptr--;

count--;

}

TRACE(("%8d: check tail\n", PTR(ptr)));

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

break;

state->ptr = ptr;

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

if (i > 0) {

TRACE(("%8d: repeat %d picked\n", PTR(ptr), count));

goto success;

}

TRACE(("%8d: BACKTRACK\n", PTR(ptr)));

ptr--;

count--;

}

} else {

/* general case */

TRACE(("%8d: tail is pattern\n", PTR(ptr)));

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

state->ptr = ptr;

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

if (i < 0)

return i;

if (i) {

TRACE(("%8d: repeat %d picked\n", PTR(ptr), count));

goto success;

}

TRACE(("%8d: BACKTRACK\n", PTR(ptr)));

ptr--;

count--;

}

}

goto failure;

#endif

case SRE_OP_MAX_REPEAT:

/* match repeated sequence (maximizing regexp) */

/* args: <skip> <1=min> <2=max> <3=save> <4=item> */

TRACE(("%8d: max repeat (%d %d)\n", PTR(ptr),

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

count = 0;

state->ptr = ptr;

/* match minimum number of items */

while (count < (int) pattern[1]) {

i = SRE_MATCH(state, pattern + 4);

if (i < 0)

return i;

if (!i)

goto failure;

if (state->ptr == ptr) {

/* if the match was successful but empty, set the

count to max and terminate the scanning loop */

count = (int) pattern[2];

break;

}

count++;

ptr = state->ptr;

}

TRACE(("%8d: found %d leading items\n", PTR(ptr), count));

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

goto failure;

/* match maximum number of items, pushing alternate end

points to the stack */

while (pattern[2] == 65535 || count < (int) pattern[2]) {

/* this position was valid; add it to the retry

stack */

if (stack >= state->stacksize) {

i = stack_extend(state, stack + 1,

stackbase + pattern[2]);

if (i < 0)

return i; /* out of memory */

}

TRACE(("%8d: stack[%d]\n", PTR(ptr), stack));

TRACE((" ptr %d mark %d %d %d\n",

PTR(ptr), pattern[3], PTR(mark0), PTR(mark1)));

sp = state->stack + stack;

sp->ptr = ptr;

sp->pattern = pattern + pattern[0];

sp->mark = pattern[3];

if (pattern[3] != 65535) {

sp->mark0 = state->mark[pattern[3]];

sp->mark1 = state->mark[pattern[3]+1];

}

stack++;

state->stackbase = stack;

i = SRE_MATCH(state, pattern + 4);

state->stackbase = stackbase;

if (i < 0)

return i;

if (!i)

break;

if (state->ptr == ptr) {

count = (int) pattern[2];

break;

}

/* move forward */

ptr = state->ptr;

count++;

}

/* when we get here, count is the number of successful

matches, and ptr points to the tail. */

TRACE(("%8d: skip +%d\n", PTR(ptr), pattern[0]));

pattern += pattern[0];

break;

case SRE_OP_MIN_REPEAT:

/* match repeated sequence (minimizing regexp) */

/* args: <skip> <1=min> <2=max> <3=save> <4=item> */

TRACE(("%8d: min repeat %d %d\n", PTR(ptr),

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

count = 0;

state->ptr = ptr;

/* match minimum number of items */

while (count < (int) pattern[1]) {

i = SRE_MATCH(state, pattern + 4);

if (i < 0)

return i;

if (!i)

goto failure;

count++;

}

/* move forward until the tail matches. */

while (count <= (int) pattern[2]) {

ptr = state->ptr;

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

if (i > 0) {

TRACE(("%8d: repeat %d picked\n", PTR(ptr), count));

goto success;

}

state->ptr = ptr; /* backtrack */

i = SRE_MATCH(state, pattern + 4);

if (i < 0)

return i;

if (!i)

goto failure;

count++;

}

goto failure;

case SRE_OP_BRANCH:

/* match one of several subpatterns */

/* format: <branch> <size> <head> ... <null> <tail> */

TRACE(("%8d: branch\n", PTR(ptr)));

while (*pattern) {

if (pattern[1] != SRE_OP_LITERAL ||

(ptr < end && (SRE_CODE) ptr[0] == pattern[2])) {

TRACE(("%8d: branch check\n", PTR(ptr)));

state->ptr = ptr;

i = SRE_MATCH(state, pattern + 1);

if (i < 0)

return i;

if (i) {

TRACE(("%8d: branch succeeded\n", PTR(ptr)));

goto success;

}

}

pattern += *pattern;

}

TRACE(("%8d: branch failed\n", PTR(ptr)));

goto failure;

case SRE_OP_REPEAT:

/* TEMPLATE: match repeated sequence (no backtracking) */

/* args: <skip> <min> <max> */

TRACE(("%8d: repeat %d %d\n", PTR(ptr), pattern[1], pattern[2]));

count = 0;

state->ptr = ptr;

while (count < (int) pattern[2]) {

i = SRE_MATCH(state, pattern + 3);

if (i < 0)

return i;

if (!i)

break;

if (state->ptr == ptr) {

count = (int) pattern[2];

break;

}

count++;

}

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

goto failure;

TRACE(("%8d: repeat %d matches\n", PTR(ptr), count));

pattern += pattern[0];

ptr = state->ptr;

break;

default:

TRACE(("%8d: unknown opcode %d\n", PTR(ptr), pattern[-1]));

return SRE_ERROR_ILLEGAL;

}

}

failure:

TRACE(("%8d: leave (failure)\n", PTR(ptr)));

if (stack-- > stackbase) {

TRACE(("%8d: pop stack[%d]\n", stack));

sp = state->stack + stack;

ptr = sp->ptr;

pattern = sp->pattern;

if (sp->mark != 65535) {

state->mark[sp->mark] = sp->mark0;

state->mark[sp->mark+1] = sp->mark1;

}

TRACE(("%8d: retry (%d)\n", PTR(ptr), stack));

goto retry;

}

state->lastmark = lastmark;

state->stackbase = stackbase;

if (mark)

memcpy(state->mark, mark, state->lastmark*sizeof(void*));

return 0;

success:

TRACE(("%8d: leave (success)\n", PTR(ptr)));

state->stackbase = stackbase;

return 1;

}

LOCAL(int)

SRE_SEARCH(SRE_STATE* state, SRE_CODE* pattern)

{

SRE_CHAR* ptr = state->start;

SRE_CHAR* end = state->end;

int status = 0;

int prefix_len = 0;

SRE_CODE* prefix = NULL;

SRE_CODE* charset = NULL;

SRE_CODE* overlap = NULL;

int flags = 0;

if (pattern[0] == SRE_OP_INFO) {

/* optimization info block */

/* args: <1=skip> <2=flags> <3=min> <4=max> <5=prefix info> */

flags = pattern[2];

if (pattern[3] > 0) {

/* adjust end point (but make sure we leave at least one

character in there, so literal search will work) */

end -= pattern[3]-1;

if (end <= ptr)