static const char copyright[] =

" SRE 2.2.2 Copyright (c) 1997-2002 by Secret Labs AB ";

#define PY_SSIZE_T_CLEAN

#include "Python.h"

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

#include "sre.h"

#define SRE_CODE_BITS (8 * sizeof(SRE_CODE))

#include <ctype.h>

#if !defined(SRE_MODULE)

#define SRE_MODULE "sre"

#define SRE_PY_MODULE "re"

#undef VERBOSE

#undef USE_BUILTIN_COPY

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

#define LOCAL(type) static __inline type __fastcall

#elif defined(USE_INLINE)

#define LOCAL(type) static inline type

#define LOCAL(type) static type

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

#define SRE_ERROR_INTERRUPTED -10 /* signal handler raised exception */

#if defined(VERBOSE)

#define TRACE(v) printf v

#define TRACE(v)

#define SRE_IS_DIGIT(ch)\

((ch) < 128 && Py_ISDIGIT(ch))

#define SRE_IS_SPACE(ch)\

((ch) < 128 && Py_ISSPACE(ch))

#define SRE_IS_LINEBREAK(ch)\

((ch) == '\n')

#define SRE_IS_ALNUM(ch)\

((ch) < 128 && Py_ISALNUM(ch))

#define SRE_IS_WORD(ch)\

((ch) < 128 && (Py_ISALNUM(ch) || (ch) == '_'))

static unsigned int sre_lower(unsigned int ch)

{

return ((ch) < 128 ? Py_TOLOWER(ch) : ch);

}

static unsigned int sre_upper(unsigned int ch)

{

return ((ch) < 128 ? Py_TOUPPER(ch) : ch);

}

#define SRE_LOC_IS_ALNUM(ch) (!((ch) & ~255) ? 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 ? (unsigned int)tolower((ch)) : ch);

}

static unsigned int sre_upper_locale(unsigned int ch)

{

return ((ch) < 256 ? (unsigned int)toupper((ch)) : ch);

}

#define SRE_UNI_IS_DIGIT(ch) Py_UNICODE_ISDECIMAL(ch)

#define SRE_UNI_IS_SPACE(ch) Py_UNICODE_ISSPACE(ch)

#define SRE_UNI_IS_LINEBREAK(ch) Py_UNICODE_ISLINEBREAK(ch)

#define SRE_UNI_IS_ALNUM(ch) Py_UNICODE_ISALNUM(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(ch);

}

static unsigned int sre_upper_unicode(unsigned int ch)

{

return (unsigned int) Py_UNICODE_TOUPPER(ch);

}

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

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

}

return 0;

}

static void

data_stack_dealloc(SRE_STATE* state)

{

if (state->data_stack) {

PyMem_FREE(state->data_stack);

state->data_stack = NULL;

}

state->data_stack_size = state->data_stack_base = 0;

}

static int

data_stack_grow(SRE_STATE* state, Py_ssize_t size)

{

Py_ssize_t minsize, cursize;

minsize = state->data_stack_base+size;

cursize = state->data_stack_size;

if (cursize < minsize) {

void* stack;

cursize = minsize+minsize/4+1024;

TRACE(("allocate/grow stack %" PY_FORMAT_SIZE_T "d\n", cursize));

stack = PyMem_REALLOC(state->data_stack, cursize);

if (!stack) {

data_stack_dealloc(state);

return SRE_ERROR_MEMORY;

}

state->data_stack = (char *)stack;

state->data_stack_size = cursize;

}

return 0;

}

#define SRE_CHAR Py_UCS1

#define SIZEOF_SRE_CHAR 1

#define SRE(F) sre_ucs1_##F

#include "sre_lib.h"

#define SRE_CHAR Py_UCS2

#define SIZEOF_SRE_CHAR 2

#define SRE(F) sre_ucs2_##F

#include "sre_lib.h"

#define SRE_CHAR Py_UCS4

#define SIZEOF_SRE_CHAR 4

#define SRE(F) sre_ucs4_##F

#include "sre_lib.h"

static PyObject*pattern_new_match(PatternObject*, SRE_STATE*, Py_ssize_t);

static PyObject *pattern_scanner(PatternObject *, PyObject *, Py_ssize_t, Py_ssize_t);

static PyTypeObject Pattern_Type;

static PyTypeObject Match_Type;

static PyTypeObject Scanner_Type;

static int

_sre_getcodesize_impl(PyObject *module)

{

return sizeof(SRE_CODE);

}

static int

_sre_getlower_impl(PyObject *module, int character, int flags)

{

if (flags & SRE_FLAG_LOCALE)

return sre_lower_locale(character);

if (flags & SRE_FLAG_UNICODE)

return sre_lower_unicode(character);

return sre_lower(character);

}

LOCAL(void)

state_reset(SRE_STATE* state)

{

/* FIXME: dynamic! */

/*memset(state->mark, 0, sizeof(*state->mark) * SRE_MARK_SIZE);*/

state->lastmark = -1;

state->lastindex = -1;

state->repeat = NULL;

data_stack_dealloc(state);

}

static void*

getstring(PyObject* string, Py_ssize_t* p_length,

int* p_isbytes, int* p_charsize,

Py_buffer *view)

{

/* given a python object, return a data pointer, a length (in

/* Unicode objects do not support the buffer API. So, get the data

if (PyUnicode_Check(string)) {

if (PyUnicode_READY(string) == -1)

return NULL;

*p_length = PyUnicode_GET_LENGTH(string);

*p_charsize = PyUnicode_KIND(string);

*p_isbytes = 0;

return PyUnicode_DATA(string);

}

/* get pointer to byte string buffer */

if (PyObject_GetBuffer(string, view, PyBUF_SIMPLE) != 0) {

PyErr_SetString(PyExc_TypeError, "expected string or bytes-like object");

return NULL;

}

*p_length = view->len;

*p_charsize = 1;

*p_isbytes = 1;

if (view->buf == NULL) {

PyErr_SetString(PyExc_ValueError, "Buffer is NULL");

PyBuffer_Release(view);

view->buf = NULL;

return NULL;

}

return view->buf;

}

LOCAL(PyObject*)

state_init(SRE_STATE* state, PatternObject* pattern, PyObject* string,

Py_ssize_t start, Py_ssize_t end)

{

/* prepare state object */

Py_ssize_t length;

int isbytes, charsize;

void* ptr;

memset(state, 0, sizeof(SRE_STATE));

state->mark = PyMem_New(void *, pattern->groups * 2);

if (!state->mark) {

PyErr_NoMemory();

goto err;

}

state->lastmark = -1;

state->lastindex = -1;

state->buffer.buf = NULL;

ptr = getstring(string, &length, &isbytes, &charsize, &state->buffer);

if (!ptr)

goto err;

if (isbytes && pattern->isbytes == 0) {

PyErr_SetString(PyExc_TypeError,

"cannot use a string pattern on a bytes-like object");

goto err;

}

if (!isbytes && pattern->isbytes > 0) {

PyErr_SetString(PyExc_TypeError,

"cannot use a bytes pattern on a string-like object");

goto err;

}

/* adjust boundaries */

if (start < 0)

start = 0;

else if (start > length)

start = length;

if (end < 0)

end = 0;

else if (end > length)

end = length;

state->isbytes = isbytes;

state->charsize = charsize;

state->beginning = ptr;

state->start = (void*) ((char*) ptr + start * state->charsize);

state->end = (void*) ((char*) ptr + end * state->charsize);

Py_INCREF(string);

state->string = string;

state->pos = start;

state->endpos = end;

if (pattern->flags & SRE_FLAG_LOCALE) {

state->lower = sre_lower_locale;

state->upper = sre_upper_locale;

}

else if (pattern->flags & SRE_FLAG_UNICODE) {

state->lower = sre_lower_unicode;

state->upper = sre_upper_unicode;

}

else {

state->lower = sre_lower;

state->upper = sre_upper;

}

return string;

err:

PyMem_Del(state->mark);

state->mark = NULL;

if (state->buffer.buf)

PyBuffer_Release(&state->buffer);

return NULL;

}

LOCAL(void)

state_fini(SRE_STATE* state)

{

if (state->buffer.buf)

PyBuffer_Release(&state->buffer);

Py_XDECREF(state->string);

data_stack_dealloc(state);

PyMem_Del(state->mark);

state->mark = NULL;

}

#define STATE_OFFSET(state, member)\

(((char*)(member) - (char*)(state)->beginning) / (state)->charsize)

LOCAL(PyObject*)

getslice(int isbytes, const void *ptr,

PyObject* string, Py_ssize_t start, Py_ssize_t end)

{

if (isbytes) {

if (PyBytes_CheckExact(string) &&

start == 0 && end == PyBytes_GET_SIZE(string)) {

Py_INCREF(string);

return string;

}

return PyBytes_FromStringAndSize(

(const char *)ptr + start, end - start);

}

else {

return PyUnicode_Substring(string, start, end);

}

}

LOCAL(PyObject*)

state_getslice(SRE_STATE* state, Py_ssize_t index, PyObject* string, int empty)

{

Py_ssize_t i, j;

index = (index - 1) * 2;

if (string == Py_None || index >= state->lastmark || !state->mark[index] || !state->mark[index+1]) {

if (empty)

/* want empty string */

i = j = 0;

else {

Py_RETURN_NONE;

}

} else {

i = STATE_OFFSET(state, state->mark[index]);

j = STATE_OFFSET(state, state->mark[index+1]);

}

return getslice(state->isbytes, state->beginning, string, i, j);

}

static void

pattern_error(Py_ssize_t status)

{

switch (status) {

case SRE_ERROR_RECURSION_LIMIT:

/* This error code seems to be unused. */

PyErr_SetString(

PyExc_RecursionError,

"maximum recursion limit exceeded"

);

break;

case SRE_ERROR_MEMORY:

PyErr_NoMemory();

break;

case SRE_ERROR_INTERRUPTED:

/* An exception has already been raised, so let it fly */

break;

default:

/* other error codes indicate compiler/engine bugs */

PyErr_SetString(

PyExc_RuntimeError,

"internal error in regular expression engine"

);

}

}

static void

pattern_dealloc(PatternObject* self)

{

if (self->weakreflist != NULL)

PyObject_ClearWeakRefs((PyObject *) self);

Py_XDECREF(self->pattern);

Py_XDECREF(self->groupindex);

Py_XDECREF(self->indexgroup);

PyObject_DEL(self);

}

LOCAL(Py_ssize_t)

sre_match(SRE_STATE* state, SRE_CODE* pattern, int match_all)

{

if (state->charsize == 1)

return sre_ucs1_match(state, pattern, match_all);

if (state->charsize == 2)

return sre_ucs2_match(state, pattern, match_all);

assert(state->charsize == 4);

return sre_ucs4_match(state, pattern, match_all);

}

LOCAL(Py_ssize_t)

sre_search(SRE_STATE* state, SRE_CODE* pattern)

{

if (state->charsize == 1)

return sre_ucs1_search(state, pattern);

if (state->charsize == 2)

return sre_ucs2_search(state, pattern);

assert(state->charsize == 4);

return sre_ucs4_search(state, pattern);

}

static PyObject *

_sre_SRE_Pattern_match_impl(PatternObject *self, PyObject *string,

Py_ssize_t pos, Py_ssize_t endpos)

{

SRE_STATE state;

Py_ssize_t status;

PyObject *match;

if (!state_init(&state, (PatternObject *)self, string, pos, endpos))

return NULL;

state.ptr = state.start;

TRACE(("|%p|%p|MATCH\n", PatternObject_GetCode(self), state.ptr));

status = sre_match(&state, PatternObject_GetCode(self), 0);

TRACE(("|%p|%p|END\n", PatternObject_GetCode(self), state.ptr));

if (PyErr_Occurred()) {

state_fini(&state);

return NULL;

}

match = pattern_new_match(self, &state, status);

state_fini(&state);

return match;

}

static PyObject *

_sre_SRE_Pattern_fullmatch_impl(PatternObject *self, PyObject *string,

Py_ssize_t pos, Py_ssize_t endpos)

{

SRE_STATE state;

Py_ssize_t status;

PyObject *match;

if (!state_init(&state, self, string, pos, endpos))

return NULL;

state.ptr = state.start;

TRACE(("|%p|%p|FULLMATCH\n", PatternObject_GetCode(self), state.ptr));

status = sre_match(&state, PatternObject_GetCode(self), 1);

TRACE(("|%p|%p|END\n", PatternObject_GetCode(self), state.ptr));

if (PyErr_Occurred()) {

state_fini(&state);

return NULL;

}

match = pattern_new_match(self, &state, status);

state_fini(&state);

return match;

}

static PyObject *

_sre_SRE_Pattern_search_impl(PatternObject *self, PyObject *string,

Py_ssize_t pos, Py_ssize_t endpos)

{

SRE_STATE state;

Py_ssize_t status;

PyObject *match;

if (!state_init(&state, self, string, pos, endpos))

return NULL;

TRACE(("|%p|%p|SEARCH\n", PatternObject_GetCode(self), state.ptr));

status = sre_search(&state, PatternObject_GetCode(self));

TRACE(("|%p|%p|END\n", PatternObject_GetCode(self), state.ptr));

if (PyErr_Occurred()) {

state_fini(&state);

return NULL;

}

match = pattern_new_match(self, &state, status);

state_fini(&state);

return match;

}

static PyObject*

call(const char* module, const char* function, PyObject* args)

{

PyObject* name;

PyObject* mod;

PyObject* func;

PyObject* result;

if (!args)

return NULL;

name = PyUnicode_FromString(module);

if (!name)

return NULL;

mod = PyImport_Import(name);

Py_DECREF(name);

if (!mod)

return NULL;

func = PyObject_GetAttrString(mod, function);

Py_DECREF(mod);

if (!func)

return NULL;

result = PyObject_CallObject(func, args);

Py_DECREF(func);

Py_DECREF(args);

return result;

}

#ifdef USE_BUILTIN_COPY

static int

deepcopy(PyObject** object, PyObject* memo)

{

PyObject* copy;

copy = call(

"copy", "deepcopy",

PyTuple_Pack(2, *object, memo)

);

if (!copy)

return 0;

Py_SETREF(*object, copy);

return 1; /* success */

}

static PyObject *

_sre_SRE_Pattern_findall_impl(PatternObject *self, PyObject *string,

Py_ssize_t pos, Py_ssize_t endpos)

{

SRE_STATE state;

PyObject* list;

Py_ssize_t status;

Py_ssize_t i, b, e;

if (!state_init(&state, self, string, pos, endpos))

return NULL;

list = PyList_New(0);

if (!list) {

state_fini(&state);

return NULL;

}

while (state.start <= state.end) {

PyObject* item;

state_reset(&state);

state.ptr = state.start;

status = sre_search(&state, PatternObject_GetCode(self));

if (PyErr_Occurred())

goto error;

if (status <= 0) {

if (status == 0)

break;

pattern_error(status);

goto error;

}

/* don't bother to build a match object */

switch (self->groups) {

case 0:

b = STATE_OFFSET(&state, state.start);

e = STATE_OFFSET(&state, state.ptr);

item = getslice(state.isbytes, state.beginning,

string, b, e);

if (!item)

goto error;

break;

case 1:

item = state_getslice(&state, 1, string, 1);

if (!item)

goto error;

break;

default:

item = PyTuple_New(self->groups);

if (!item)

goto error;

for (i = 0; i < self->groups; i++) {

PyObject* o = state_getslice(&state, i+1, string, 1);

if (!o) {

Py_DECREF(item);

goto error;

}

PyTuple_SET_ITEM(item, i, o);

}

break;

}

status = PyList_Append(list, item);

Py_DECREF(item);

if (status < 0)

goto error;

if (state.ptr == state.start)

state.start = (void*) ((char*) state.ptr + state.charsize);

else

state.start = state.ptr;

}

state_fini(&state);

return list;

error:

Py_DECREF(list);

state_fini(&state);

return NULL;

}

static PyObject *

_sre_SRE_Pattern_finditer_impl(PatternObject *self, PyObject *string,

Py_ssize_t pos, Py_ssize_t endpos)

{

PyObject* scanner;

PyObject* search;

PyObject* iterator;

scanner = pattern_scanner(self, string, pos, endpos);

if (!scanner)

return NULL;

search = PyObject_GetAttrString(scanner, "search");

Py_DECREF(scanner);

if (!search)

return NULL;

iterator = PyCallIter_New(search, Py_None);

Py_DECREF(search);

return iterator;

}

static PyObject *

_sre_SRE_Pattern_scanner_impl(PatternObject *self, PyObject *string,

Py_ssize_t pos, Py_ssize_t endpos)

{

return pattern_scanner(self, string, pos, endpos);

}

static PyObject *

_sre_SRE_Pattern_split_impl(PatternObject *self, PyObject *string,

Py_ssize_t maxsplit)

{

SRE_STATE state;

PyObject* list;

PyObject* item;

Py_ssize_t status;

Py_ssize_t n;

Py_ssize_t i;

void* last;

assert(self->codesize != 0);

if (self->code[0] != SRE_OP_INFO || self->code[3] == 0) {

if (self->code[0] == SRE_OP_INFO && self->code[4] == 0) {

PyErr_SetString(PyExc_ValueError,

"split() requires a non-empty pattern match.");

return NULL;

}

if (PyErr_WarnEx(PyExc_FutureWarning,

"split() requires a non-empty pattern match.",

1) < 0)

return NULL;

}

if (!state_init(&state, self, string, 0, PY_SSIZE_T_MAX))

return NULL;

list = PyList_New(0);

if (!list) {

state_fini(&state);

return NULL;

}

n = 0;

last = state.start;

while (!maxsplit || n < maxsplit) {

state_reset(&state);

state.ptr = state.start;

status = sre_search(&state, PatternObject_GetCode(self));

if (PyErr_Occurred())

goto error;

if (status <= 0) {

if (status == 0)

break;

pattern_error(status);

goto error;

}

if (state.start == state.ptr) {

if (last == state.end || state.ptr == state.end)

break;

/* skip one character */

state.start = (void*) ((char*) state.ptr + state.charsize);

continue;

}

/* get segment before this match */

item = getslice(state.isbytes, state.beginning,

string, STATE_OFFSET(&state, last),

STATE_OFFSET(&state, state.start)

);

if (!item)

goto error;

status = PyList_Append(list, item);

Py_DECREF(item);

if (status < 0)

goto error;

/* add groups (if any) */

for (i = 0; i < self->groups; i++) {

item = state_getslice(&state, i+1, string, 0);

if (!item)

goto error;

status = PyList_Append(list, item);

Py_DECREF(item);

if (status < 0)

goto error;

}

n = n + 1;

last = state.start = state.ptr;

}

/* get segment following last match (even if empty) */

item = getslice(state.isbytes, state.beginning,

string, STATE_OFFSET(&state, last), state.endpos

);

if (!item)

goto error;

status = PyList_Append(list, item);

Py_DECREF(item);

if (status < 0)

goto error;

state_fini(&state);

return list;

error:

Py_DECREF(list);

state_fini(&state);

return NULL;

}

static PyObject*

pattern_subx(PatternObject* self, PyObject* ptemplate, PyObject* string,

Py_ssize_t count, Py_ssize_t subn)

{

SRE_STATE state;

PyObject* list;

PyObject* joiner;

PyObject* item;

PyObject* filter;