/*

* 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-08-01 fl fixes for 1.6b1

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

* 2000-09-20 fl added expand method

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

* 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; re-enable unicode for 1.6/2.0/2.1

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

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

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

* 2002-11-09 fl fixed empty sub/subn return type

* 2003-04-18 mvl fully support 4-byte codes

* 2003-10-17 gn implemented non recursive scheme

* 2013-02-04 mrab added fullmatch primitive

*

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

*/

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 "pycore_long.h" // _PyLong_GetZero()

#include "pycore_moduleobject.h" // _PyModule_GetState()

#include "structmember.h" // PyMemberDef

#include "sre.h"

#define SRE_CODE_BITS (8 * sizeof(SRE_CODE))

#include <ctype.h>

/* defining this one enables tracing */

#undef VERBOSE

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

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

#else

#define TRACE(v)

#endif

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

/* search engine state */

#define SRE_IS_DIGIT(ch)\

((ch) <= '9' && Py_ISDIGIT(ch))

#define SRE_IS_SPACE(ch)\

((ch) <= ' ' && Py_ISSPACE(ch))

#define SRE_IS_LINEBREAK(ch)\

((ch) == '\n')

#define SRE_IS_WORD(ch)\

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

static unsigned int sre_lower_ascii(unsigned int ch)

{

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

}

/* locale-specific character predicates */

/* !(c & ~N) == (c < N+1) for any unsigned c, this avoids

* warnings when c's type supports only numbers < N+1 */

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

}

/* unicode-specific character predicates */

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

}

LOCAL(int)

char_loc_ignore(SRE_CODE pattern, SRE_CODE ch)

{

return ch == pattern

|| (SRE_CODE) sre_lower_locale(ch) == pattern

|| (SRE_CODE) sre_upper_locale(ch) == pattern;

}

/* helpers */

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 %zd\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;

}

/* generate 8-bit version */

#define SRE_CHAR Py_UCS1

#define SIZEOF_SRE_CHAR 1

#define SRE(F) sre_ucs1_##F

#include "sre_lib.h"

/* generate 16-bit unicode version */

#define SRE_CHAR Py_UCS2

#define SIZEOF_SRE_CHAR 2

#define SRE(F) sre_ucs2_##F

#include "sre_lib.h"

/* generate 32-bit unicode version */

#define SRE_CHAR Py_UCS4

#define SIZEOF_SRE_CHAR 4

#define SRE(F) sre_ucs4_##F

#include "sre_lib.h"

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

/* factories and destructors */

/* module state */

typedef struct {

PyTypeObject *Pattern_Type;

PyTypeObject *Match_Type;

PyTypeObject *Scanner_Type;

PyTypeObject *Template_Type;

PyObject *compile_template; // reference to re._compile_template

} _sremodulestate;

static _sremodulestate *

get_sre_module_state(PyObject *m)

{

_sremodulestate *state = (_sremodulestate *)_PyModule_GetState(m);

assert(state);

return state;

}

static struct PyModuleDef sremodule;

#define get_sre_module_state_by_class(cls) \

(get_sre_module_state(PyType_GetModule(cls)))

/* see sre.h for object declarations */

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

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

/*[clinic input]

module _sre

class _sre.SRE_Pattern "PatternObject *" "get_sre_module_state_by_class(tp)->Pattern_Type"

class _sre.SRE_Match "MatchObject *" "get_sre_module_state_by_class(tp)->Match_Type"

class _sre.SRE_Scanner "ScannerObject *" "get_sre_module_state_by_class(tp)->Scanner_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=fe2966e32b66a231]*/

/*[clinic input]

_sre.getcodesize -> int

[clinic start generated code]*/

static int

_sre_getcodesize_impl(PyObject *module)

/*[clinic end generated code: output=e0db7ce34a6dd7b1 input=bd6f6ecf4916bb2b]*/

{

return sizeof(SRE_CODE);

}

/*[clinic input]

_sre.ascii_iscased -> bool

character: int

/

[clinic start generated code]*/

static int

_sre_ascii_iscased_impl(PyObject *module, int character)

/*[clinic end generated code: output=4f454b630fbd19a2 input=9f0bd952812c7ed3]*/

{

unsigned int ch = (unsigned int)character;

return ch < 128 && Py_ISALPHA(ch);

}

/*[clinic input]

_sre.unicode_iscased -> bool

character: int

/

[clinic start generated code]*/

static int

_sre_unicode_iscased_impl(PyObject *module, int character)

/*[clinic end generated code: output=9c5ddee0dc2bc258 input=51e42c3b8dddb78e]*/

{

unsigned int ch = (unsigned int)character;

return ch != sre_lower_unicode(ch) || ch != sre_upper_unicode(ch);

}

/*[clinic input]

_sre.ascii_tolower -> int

character: int

/

[clinic start generated code]*/

static int

_sre_ascii_tolower_impl(PyObject *module, int character)

/*[clinic end generated code: output=228294ed6ff2a612 input=272c609b5b61f136]*/

{

return sre_lower_ascii(character);

}

/*[clinic input]

_sre.unicode_tolower -> int

character: int

/

[clinic start generated code]*/

static int

_sre_unicode_tolower_impl(PyObject *module, int character)

/*[clinic end generated code: output=6422272d7d7fee65 input=91d708c5f3c2045a]*/

{

return sre_lower_unicode(character);

}

LOCAL(void)

state_reset(SRE_STATE* state)

{

/* state->mark will be set to 0 in SRE_OP_MARK dynamically. */

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

state->lastmark = -1;

state->lastindex = -1;

state->repeat = NULL;

data_stack_dealloc(state);

}

static const 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

characters), and a character size. return NULL if the object

is not a string (or not compatible) */

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

directly instead. */

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_Format(PyExc_TypeError, "expected string or bytes-like "

"object, got '%.200s'", Py_TYPE(string)->tp_name);

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;

const void* ptr;

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

state->mark = PyMem_New(const 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->match_all = 0;

state->must_advance = 0;

state->beginning = ptr;

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

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

state->string = Py_NewRef(string);

state->pos = start;

state->endpos = end;

return string;

err:

/* We add an explicit cast here because MSVC has a bug when

compiling C code where it believes that `const void**` cannot be

safely casted to `void*`, see bpo-39943 for details. */

PyMem_Free((void*) 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);

/* See above PyMem_Del for why we explicitly cast here. */

PyMem_Free((void*) state->mark);

state->mark = NULL;

}

/* calculate offset from start of string */

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

return Py_NewRef(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]);

/* check wrong span */

if (i > j) {

PyErr_SetString(PyExc_SystemError,

"The span of capturing group is wrong,"

" please report a bug for the re module.");

return NULL;

}

}

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 int

pattern_traverse(PatternObject *self, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(self));

Py_VISIT(self->groupindex);

Py_VISIT(self->indexgroup);

Py_VISIT(self->pattern);

return 0;

}

static int

pattern_clear(PatternObject *self)

{

Py_CLEAR(self->groupindex);

Py_CLEAR(self->indexgroup);

Py_CLEAR(self->pattern);

return 0;

}

static void

pattern_dealloc(PatternObject* self)

{

PyTypeObject *tp = Py_TYPE(self);

PyObject_GC_UnTrack(self);

if (self->weakreflist != NULL) {

PyObject_ClearWeakRefs((PyObject *) self);

}

(void)pattern_clear(self);

tp->tp_free(self);

Py_DECREF(tp);

}

LOCAL(Py_ssize_t)

sre_match(SRE_STATE* state, SRE_CODE* pattern)

{

if (state->charsize == 1)

return sre_ucs1_match(state, pattern, 1);

if (state->charsize == 2)

return sre_ucs2_match(state, pattern, 1);

assert(state->charsize == 4);

return sre_ucs4_match(state, pattern, 1);

}

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

}

/*[clinic input]

_sre.SRE_Pattern.match

cls: defining_class

/

string: object

pos: Py_ssize_t = 0

endpos: Py_ssize_t(c_default="PY_SSIZE_T_MAX") = sys.maxsize

Matches zero or more characters at the beginning of the string.

[clinic start generated code]*/

static PyObject *

_sre_SRE_Pattern_match_impl(PatternObject *self, PyTypeObject *cls,

PyObject *string, Py_ssize_t pos,

Py_ssize_t endpos)

/*[clinic end generated code: output=ec6208ea58a0cca0 input=4bdb9c3e564d13ac]*/

{

_sremodulestate *module_state = get_sre_module_state_by_class(cls);

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

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

if (PyErr_Occurred()) {

state_fini(&state);

return NULL;

}

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

state_fini(&state);

return match;

}

/*[clinic input]

_sre.SRE_Pattern.fullmatch

cls: defining_class

/

string: object

pos: Py_ssize_t = 0

endpos: Py_ssize_t(c_default="PY_SSIZE_T_MAX") = sys.maxsize

Matches against all of the string.

[clinic start generated code]*/

static PyObject *

_sre_SRE_Pattern_fullmatch_impl(PatternObject *self, PyTypeObject *cls,

PyObject *string, Py_ssize_t pos,

Py_ssize_t endpos)

/*[clinic end generated code: output=625b75b027ef94da input=50981172ab0fcfdd]*/

{

_sremodulestate *module_state = get_sre_module_state_by_class(cls);

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

state.match_all = 1;

status = sre_match(&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(module_state, self, &state, status);

state_fini(&state);

return match;

}

/*[clinic input]

_sre.SRE_Pattern.search

cls: defining_class

/

string: object

pos: Py_ssize_t = 0

endpos: Py_ssize_t(c_default="PY_SSIZE_T_MAX") = sys.maxsize

Scan through string looking for a match, and return a corresponding match object instance.

Return None if no position in the string matches.

[clinic start generated code]*/

static PyObject *

_sre_SRE_Pattern_search_impl(PatternObject *self, PyTypeObject *cls,

PyObject *string, Py_ssize_t pos,

Py_ssize_t endpos)

/*[clinic end generated code: output=bd7f2d9d583e1463 input=afa9afb66a74a4b3]*/

{

_sremodulestate *module_state = get_sre_module_state_by_class(cls);

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(module_state, self, &state, status);

state_fini(&state);

return match;

}

/*[clinic input]

_sre.SRE_Pattern.findall

string: object

pos: Py_ssize_t = 0

endpos: Py_ssize_t(c_default="PY_SSIZE_T_MAX") = sys.maxsize

Return a list of all non-overlapping matches of pattern in string.

[clinic start generated code]*/

static PyObject *

_sre_SRE_Pattern_findall_impl(PatternObject *self, PyObject *string,

Py_ssize_t pos, Py_ssize_t endpos)

/*[clinic end generated code: output=f4966baceea60aca input=5b6a4ee799741563]*/

{

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;

state.must_advance = (state.ptr == state.start);

state.start = state.ptr;

}

state_fini(&state);

return list;

error:

Py_DECREF(list);

state_fini(&state);

return NULL;

}

/*[clinic input]

_sre.SRE_Pattern.finditer

cls: defining_class

/

string: object

pos: Py_ssize_t = 0

endpos: Py_ssize_t(c_default="PY_SSIZE_T_MAX") = sys.maxsize

Return an iterator over all non-overlapping matches for the RE pattern in string.

For each match, the iterator returns a match object.

[clinic start generated code]*/

static PyObject *

_sre_SRE_Pattern_finditer_impl(PatternObject *self, PyTypeObject *cls,

PyObject *string, Py_ssize_t pos,

Py_ssize_t endpos)

/*[clinic end generated code: output=1791dbf3618ade56 input=812e332a4848cbaf]*/

{

_sremodulestate *module_state = get_sre_module_state_by_class(cls);

PyObject* scanner;

PyObject* search;

PyObject* iterator;

scanner = pattern_scanner(module_state, 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;

}

/*[clinic input]

_sre.SRE_Pattern.scanner

cls: defining_class

/

string: object

pos: Py_ssize_t = 0

endpos: Py_ssize_t(c_default="PY_SSIZE_T_MAX") = sys.maxsize

[clinic start generated code]*/

static PyObject *

_sre_SRE_Pattern_scanner_impl(PatternObject *self, PyTypeObject *cls,

PyObject *string, Py_ssize_t pos,

Py_ssize_t endpos)

/*[clinic end generated code: output=f70cd506112f1bd9 input=2e487e5151bcee4c]*/

{

_sremodulestate *module_state = get_sre_module_state_by_class(cls);

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

}

/*[clinic input]

_sre.SRE_Pattern.split

string: object

maxsplit: Py_ssize_t = 0

Split string by the occurrences of pattern.

[clinic start generated code]*/

static PyObject *

_sre_SRE_Pattern_split_impl(PatternObject *self, PyObject *string,

Py_ssize_t maxsplit)

/*[clinic end generated code: output=7ac66f381c45e0be input=1eeeb10dafc9947a]*/

{

SRE_STATE state;

PyObject* list;

PyObject* item;

Py_ssize_t status;

Py_ssize_t n;

Py_ssize_t i;

const void* last;

assert(self->codesize != 0);

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;

}

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

state.must_advance = (state.ptr == state.start);

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