Branch data Line data Source code
1 : : /*
2 : : * Secret Labs' Regular Expression Engine
3 : : *
4 : : * regular expression matching engine
5 : : *
6 : : * partial history:
7 : : * 1999-10-24 fl created (based on existing template matcher code)
8 : : * 2000-03-06 fl first alpha, sort of
9 : : * 2000-08-01 fl fixes for 1.6b1
10 : : * 2000-08-07 fl use PyOS_CheckStack() if available
11 : : * 2000-09-20 fl added expand method
12 : : * 2001-03-20 fl lots of fixes for 2.1b2
13 : : * 2001-04-15 fl export copyright as Python attribute, not global
14 : : * 2001-04-28 fl added __copy__ methods (work in progress)
15 : : * 2001-05-14 fl fixes for 1.5.2 compatibility
16 : : * 2001-07-01 fl added BIGCHARSET support (from Martin von Loewis)
17 : : * 2001-10-18 fl fixed group reset issue (from Matthew Mueller)
18 : : * 2001-10-20 fl added split primitive; re-enable unicode for 1.6/2.0/2.1
19 : : * 2001-10-21 fl added sub/subn primitive
20 : : * 2001-10-24 fl added finditer primitive (for 2.2 only)
21 : : * 2001-12-07 fl fixed memory leak in sub/subn (Guido van Rossum)
22 : : * 2002-11-09 fl fixed empty sub/subn return type
23 : : * 2003-04-18 mvl fully support 4-byte codes
24 : : * 2003-10-17 gn implemented non recursive scheme
25 : : * 2013-02-04 mrab added fullmatch primitive
26 : : *
27 : : * Copyright (c) 1997-2001 by Secret Labs AB. All rights reserved.
28 : : *
29 : : * This version of the SRE library can be redistributed under CNRI's
30 : : * Python 1.6 license. For any other use, please contact Secret Labs
31 : : * AB (info@pythonware.com).
32 : : *
33 : : * Portions of this engine have been developed in cooperation with
34 : : * CNRI. Hewlett-Packard provided funding for 1.6 integration and
35 : : * other compatibility work.
36 : : */
37 : :
38 : : static const char copyright[] =
39 : : " SRE 2.2.2 Copyright (c) 1997-2002 by Secret Labs AB ";
40 : :
41 : : #define PY_SSIZE_T_CLEAN
42 : :
43 : : #include "Python.h"
44 : : #include "pycore_long.h" // _PyLong_GetZero()
45 : : #include "pycore_moduleobject.h" // _PyModule_GetState()
46 : : #include "structmember.h" // PyMemberDef
47 : :
48 : : #include "sre.h"
49 : :
50 : : #define SRE_CODE_BITS (8 * sizeof(SRE_CODE))
51 : :
52 : : #include <ctype.h>
53 : :
54 : : /* name of this module, minus the leading underscore */
55 : : #if !defined(SRE_MODULE)
56 : : #define SRE_MODULE "sre"
57 : : #endif
58 : :
59 : : #define SRE_PY_MODULE "re"
60 : :
61 : : /* defining this one enables tracing */
62 : : #undef VERBOSE
63 : :
64 : : /* -------------------------------------------------------------------- */
65 : :
66 : : #if defined(_MSC_VER)
67 : : #pragma optimize("agtw", on) /* doesn't seem to make much difference... */
68 : : #pragma warning(disable: 4710) /* who cares if functions are not inlined ;-) */
69 : : /* fastest possible local call under MSVC */
70 : : #define LOCAL(type) static __inline type __fastcall
71 : : #else
72 : : #define LOCAL(type) static inline type
73 : : #endif
74 : :
75 : : /* error codes */
76 : : #define SRE_ERROR_ILLEGAL -1 /* illegal opcode */
77 : : #define SRE_ERROR_STATE -2 /* illegal state */
78 : : #define SRE_ERROR_RECURSION_LIMIT -3 /* runaway recursion */
79 : : #define SRE_ERROR_MEMORY -9 /* out of memory */
80 : : #define SRE_ERROR_INTERRUPTED -10 /* signal handler raised exception */
81 : :
82 : : #if defined(VERBOSE)
83 : : #define TRACE(v) printf v
84 : : #else
85 : : #define TRACE(v)
86 : : #endif
87 : :
88 : : /* -------------------------------------------------------------------- */
89 : : /* search engine state */
90 : :
91 : : #define SRE_IS_DIGIT(ch)\
92 : : ((ch) <= '9' && Py_ISDIGIT(ch))
93 : : #define SRE_IS_SPACE(ch)\
94 : : ((ch) <= ' ' && Py_ISSPACE(ch))
95 : : #define SRE_IS_LINEBREAK(ch)\
96 : : ((ch) == '\n')
97 : : #define SRE_IS_WORD(ch)\
98 : : ((ch) <= 'z' && (Py_ISALNUM(ch) || (ch) == '_'))
99 : :
100 : 99152 : static unsigned int sre_lower_ascii(unsigned int ch)
101 : : {
102 [ + + ]: 99152 : return ((ch) < 128 ? Py_TOLOWER(ch) : ch);
103 : : }
104 : :
105 : : /* locale-specific character predicates */
106 : : /* !(c & ~N) == (c < N+1) for any unsigned c, this avoids
107 : : * warnings when c's type supports only numbers < N+1 */
108 : : #define SRE_LOC_IS_ALNUM(ch) (!((ch) & ~255) ? isalnum((ch)) : 0)
109 : : #define SRE_LOC_IS_WORD(ch) (SRE_LOC_IS_ALNUM((ch)) || (ch) == '_')
110 : :
111 : 527 : static unsigned int sre_lower_locale(unsigned int ch)
112 : : {
113 [ + - ]: 527 : return ((ch) < 256 ? (unsigned int)tolower((ch)) : ch);
114 : : }
115 : :
116 : 161 : static unsigned int sre_upper_locale(unsigned int ch)
117 : : {
118 [ + - ]: 161 : return ((ch) < 256 ? (unsigned int)toupper((ch)) : ch);
119 : : }
120 : :
121 : : /* unicode-specific character predicates */
122 : :
123 : : #define SRE_UNI_IS_DIGIT(ch) Py_UNICODE_ISDECIMAL(ch)
124 : : #define SRE_UNI_IS_SPACE(ch) Py_UNICODE_ISSPACE(ch)
125 : : #define SRE_UNI_IS_LINEBREAK(ch) Py_UNICODE_ISLINEBREAK(ch)
126 : : #define SRE_UNI_IS_ALNUM(ch) Py_UNICODE_ISALNUM(ch)
127 : : #define SRE_UNI_IS_WORD(ch) (SRE_UNI_IS_ALNUM(ch) || (ch) == '_')
128 : :
129 : 314560 : static unsigned int sre_lower_unicode(unsigned int ch)
130 : : {
131 : 314560 : return (unsigned int) Py_UNICODE_TOLOWER(ch);
132 : : }
133 : :
134 : 60621 : static unsigned int sre_upper_unicode(unsigned int ch)
135 : : {
136 : 60621 : return (unsigned int) Py_UNICODE_TOUPPER(ch);
137 : : }
138 : :
139 : : LOCAL(int)
140 : 40840579 : sre_category(SRE_CODE category, unsigned int ch)
141 : : {
142 [ + + + + : 40840579 : switch (category) {
+ + - - +
+ + + + +
+ + - -
- ]
143 : :
144 : 6603343 : case SRE_CATEGORY_DIGIT:
145 [ + + + + ]: 6603343 : return SRE_IS_DIGIT(ch);
146 : 35 : case SRE_CATEGORY_NOT_DIGIT:
147 [ + + - + ]: 35 : return !SRE_IS_DIGIT(ch);
148 : 7571468 : case SRE_CATEGORY_SPACE:
149 [ + + + - ]: 7571468 : return SRE_IS_SPACE(ch);
150 : 71 : case SRE_CATEGORY_NOT_SPACE:
151 [ + + - + ]: 71 : return !SRE_IS_SPACE(ch);
152 : 14609 : case SRE_CATEGORY_WORD:
153 [ + + + + : 14609 : return SRE_IS_WORD(ch);
+ + ]
154 : 7 : case SRE_CATEGORY_NOT_WORD:
155 [ + + + - : 7 : return !SRE_IS_WORD(ch);
+ - ]
156 : 0 : case SRE_CATEGORY_LINEBREAK:
157 : 0 : return SRE_IS_LINEBREAK(ch);
158 : 0 : case SRE_CATEGORY_NOT_LINEBREAK:
159 : 0 : return !SRE_IS_LINEBREAK(ch);
160 : :
161 : 39 : case SRE_CATEGORY_LOC_WORD:
162 [ + - + + : 39 : return SRE_LOC_IS_WORD(ch);
+ + ]
163 : 1 : case SRE_CATEGORY_LOC_NOT_WORD:
164 [ + - + - : 1 : return !SRE_LOC_IS_WORD(ch);
+ - ]
165 : :
166 : 5949979 : case SRE_CATEGORY_UNI_DIGIT:
167 : 5949979 : return SRE_UNI_IS_DIGIT(ch);
168 : 57 : case SRE_CATEGORY_UNI_NOT_DIGIT:
169 : 57 : return !SRE_UNI_IS_DIGIT(ch);
170 : 2166234 : case SRE_CATEGORY_UNI_SPACE:
171 : 2166234 : return SRE_UNI_IS_SPACE(ch);
172 : 426606 : case SRE_CATEGORY_UNI_NOT_SPACE:
173 : 426606 : return !SRE_UNI_IS_SPACE(ch);
174 : 18106378 : case SRE_CATEGORY_UNI_WORD:
175 [ + + + + ]: 18106378 : return SRE_UNI_IS_WORD(ch);
176 : 1752 : case SRE_CATEGORY_UNI_NOT_WORD:
177 [ + + + + ]: 1752 : return !SRE_UNI_IS_WORD(ch);
178 : 0 : case SRE_CATEGORY_UNI_LINEBREAK:
179 : 0 : return SRE_UNI_IS_LINEBREAK(ch);
180 : 0 : case SRE_CATEGORY_UNI_NOT_LINEBREAK:
181 : 0 : return !SRE_UNI_IS_LINEBREAK(ch);
182 : : }
183 : 0 : return 0;
184 : : }
185 : :
186 : : LOCAL(int)
187 : 472 : char_loc_ignore(SRE_CODE pattern, SRE_CODE ch)
188 : : {
189 : : return ch == pattern
190 [ + + ]: 429 : || (SRE_CODE) sre_lower_locale(ch) == pattern
191 [ + + + + ]: 901 : || (SRE_CODE) sre_upper_locale(ch) == pattern;
192 : : }
193 : :
194 : :
195 : : /* helpers */
196 : :
197 : : static void
198 : 14203481 : data_stack_dealloc(SRE_STATE* state)
199 : : {
200 [ + + ]: 14203481 : if (state->data_stack) {
201 : 10464294 : PyMem_Free(state->data_stack);
202 : 10464294 : state->data_stack = NULL;
203 : : }
204 : 14203481 : state->data_stack_size = state->data_stack_base = 0;
205 : 14203481 : }
206 : :
207 : : static int
208 : 10623311 : data_stack_grow(SRE_STATE* state, Py_ssize_t size)
209 : : {
210 : : Py_ssize_t minsize, cursize;
211 : 10623311 : minsize = state->data_stack_base+size;
212 : 10623311 : cursize = state->data_stack_size;
213 [ + - ]: 10623311 : if (cursize < minsize) {
214 : : void* stack;
215 : 10623311 : cursize = minsize+minsize/4+1024;
216 : : TRACE(("allocate/grow stack %zd\n", cursize));
217 : 10623311 : stack = PyMem_Realloc(state->data_stack, cursize);
218 [ - + ]: 10623311 : if (!stack) {
219 : 0 : data_stack_dealloc(state);
220 : 0 : return SRE_ERROR_MEMORY;
221 : : }
222 : 10623311 : state->data_stack = (char *)stack;
223 : 10623311 : state->data_stack_size = cursize;
224 : : }
225 : 10623311 : return 0;
226 : : }
227 : :
228 : : /* generate 8-bit version */
229 : :
230 : : #define SRE_CHAR Py_UCS1
231 : : #define SIZEOF_SRE_CHAR 1
232 : : #define SRE(F) sre_ucs1_##F
233 : : #include "sre_lib.h"
234 : :
235 : : /* generate 16-bit unicode version */
236 : :
237 : : #define SRE_CHAR Py_UCS2
238 : : #define SIZEOF_SRE_CHAR 2
239 : : #define SRE(F) sre_ucs2_##F
240 : : #include "sre_lib.h"
241 : :
242 : : /* generate 32-bit unicode version */
243 : :
244 : : #define SRE_CHAR Py_UCS4
245 : : #define SIZEOF_SRE_CHAR 4
246 : : #define SRE(F) sre_ucs4_##F
247 : : #include "sre_lib.h"
248 : :
249 : : /* -------------------------------------------------------------------- */
250 : : /* factories and destructors */
251 : :
252 : : /* module state */
253 : : typedef struct {
254 : : PyTypeObject *Pattern_Type;
255 : : PyTypeObject *Match_Type;
256 : : PyTypeObject *Scanner_Type;
257 : : } _sremodulestate;
258 : :
259 : : static _sremodulestate *
260 : 13928644 : get_sre_module_state(PyObject *m)
261 : : {
262 : 13928644 : _sremodulestate *state = (_sremodulestate *)_PyModule_GetState(m);
263 : : assert(state);
264 : 13928644 : return state;
265 : : }
266 : :
267 : : static struct PyModuleDef sremodule;
268 : : #define get_sre_module_state_by_class(cls) \
269 : : (get_sre_module_state(PyType_GetModule(cls)))
270 : :
271 : : /* see sre.h for object declarations */
272 : : static PyObject*pattern_new_match(_sremodulestate *, PatternObject*, SRE_STATE*, Py_ssize_t);
273 : : static PyObject *pattern_scanner(_sremodulestate *, PatternObject *, PyObject *, Py_ssize_t, Py_ssize_t);
274 : :
275 : : /*[clinic input]
276 : : module _sre
277 : : class _sre.SRE_Pattern "PatternObject *" "get_sre_module_state_by_class(tp)->Pattern_Type"
278 : : class _sre.SRE_Match "MatchObject *" "get_sre_module_state_by_class(tp)->Match_Type"
279 : : class _sre.SRE_Scanner "ScannerObject *" "get_sre_module_state_by_class(tp)->Scanner_Type"
280 : : [clinic start generated code]*/
281 : : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=fe2966e32b66a231]*/
282 : :
283 : : /*[clinic input]
284 : : _sre.getcodesize -> int
285 : : [clinic start generated code]*/
286 : :
287 : : static int
288 : 0 : _sre_getcodesize_impl(PyObject *module)
289 : : /*[clinic end generated code: output=e0db7ce34a6dd7b1 input=bd6f6ecf4916bb2b]*/
290 : : {
291 : 0 : return sizeof(SRE_CODE);
292 : : }
293 : :
294 : : /*[clinic input]
295 : : _sre.ascii_iscased -> bool
296 : :
297 : : character: int
298 : : /
299 : :
300 : : [clinic start generated code]*/
301 : :
302 : : static int
303 : 10588 : _sre_ascii_iscased_impl(PyObject *module, int character)
304 : : /*[clinic end generated code: output=4f454b630fbd19a2 input=9f0bd952812c7ed3]*/
305 : : {
306 : 10588 : unsigned int ch = (unsigned int)character;
307 [ + + + + ]: 10588 : return ch < 128 && Py_ISALPHA(ch);
308 : : }
309 : :
310 : : /*[clinic input]
311 : : _sre.unicode_iscased -> bool
312 : :
313 : : character: int
314 : : /
315 : :
316 : : [clinic start generated code]*/
317 : :
318 : : static int
319 : 61338 : _sre_unicode_iscased_impl(PyObject *module, int character)
320 : : /*[clinic end generated code: output=9c5ddee0dc2bc258 input=51e42c3b8dddb78e]*/
321 : : {
322 : 61338 : unsigned int ch = (unsigned int)character;
323 [ + + + + ]: 61338 : return ch != sre_lower_unicode(ch) || ch != sre_upper_unicode(ch);
324 : : }
325 : :
326 : : /*[clinic input]
327 : : _sre.ascii_tolower -> int
328 : :
329 : : character: int
330 : : /
331 : :
332 : : [clinic start generated code]*/
333 : :
334 : : static int
335 : 97098 : _sre_ascii_tolower_impl(PyObject *module, int character)
336 : : /*[clinic end generated code: output=228294ed6ff2a612 input=272c609b5b61f136]*/
337 : : {
338 : 97098 : return sre_lower_ascii(character);
339 : : }
340 : :
341 : : /*[clinic input]
342 : : _sre.unicode_tolower -> int
343 : :
344 : : character: int
345 : : /
346 : :
347 : : [clinic start generated code]*/
348 : :
349 : : static int
350 : 102901 : _sre_unicode_tolower_impl(PyObject *module, int character)
351 : : /*[clinic end generated code: output=6422272d7d7fee65 input=91d708c5f3c2045a]*/
352 : : {
353 : 102901 : return sre_lower_unicode(character);
354 : : }
355 : :
356 : : LOCAL(void)
357 : 3006308 : state_reset(SRE_STATE* state)
358 : : {
359 : : /* state->mark will be set to 0 in SRE_OP_MARK dynamically. */
360 : : /*memset(state->mark, 0, sizeof(*state->mark) * SRE_MARK_SIZE);*/
361 : :
362 : 3006308 : state->lastmark = -1;
363 : 3006308 : state->lastindex = -1;
364 : :
365 : 3006308 : state->repeat = NULL;
366 : :
367 : 3006308 : data_stack_dealloc(state);
368 : 3006308 : }
369 : :
370 : : static const void*
371 : 12040498 : getstring(PyObject* string, Py_ssize_t* p_length,
372 : : int* p_isbytes, int* p_charsize,
373 : : Py_buffer *view)
374 : : {
375 : : /* given a python object, return a data pointer, a length (in
376 : : characters), and a character size. return NULL if the object
377 : : is not a string (or not compatible) */
378 : :
379 : : /* Unicode objects do not support the buffer API. So, get the data
380 : : directly instead. */
381 [ + + ]: 12040498 : if (PyUnicode_Check(string)) {
382 [ - + ]: 11960794 : if (PyUnicode_READY(string) == -1)
383 : 0 : return NULL;
384 : 11960794 : *p_length = PyUnicode_GET_LENGTH(string);
385 : 11960794 : *p_charsize = PyUnicode_KIND(string);
386 : 11960794 : *p_isbytes = 0;
387 : 11960794 : return PyUnicode_DATA(string);
388 : : }
389 : :
390 : : /* get pointer to byte string buffer */
391 [ + + ]: 79704 : if (PyObject_GetBuffer(string, view, PyBUF_SIMPLE) != 0) {
392 : 7 : PyErr_Format(PyExc_TypeError, "expected string or bytes-like "
393 : 7 : "object, got '%.200s'", Py_TYPE(string)->tp_name);
394 : 7 : return NULL;
395 : : }
396 : :
397 : 79697 : *p_length = view->len;
398 : 79697 : *p_charsize = 1;
399 : 79697 : *p_isbytes = 1;
400 : :
401 [ - + ]: 79697 : if (view->buf == NULL) {
402 : 0 : PyErr_SetString(PyExc_ValueError, "Buffer is NULL");
403 : 0 : PyBuffer_Release(view);
404 : 0 : view->buf = NULL;
405 : 0 : return NULL;
406 : : }
407 : 79697 : return view->buf;
408 : : }
409 : :
410 : : LOCAL(PyObject*)
411 : 11197192 : state_init(SRE_STATE* state, PatternObject* pattern, PyObject* string,
412 : : Py_ssize_t start, Py_ssize_t end)
413 : : {
414 : : /* prepare state object */
415 : :
416 : : Py_ssize_t length;
417 : : int isbytes, charsize;
418 : : const void* ptr;
419 : :
420 : 11197192 : memset(state, 0, sizeof(SRE_STATE));
421 : :
422 [ + - ]: 11197192 : state->mark = PyMem_New(const void *, pattern->groups * 2);
423 [ - + ]: 11197192 : if (!state->mark) {
424 : : PyErr_NoMemory();
425 : 0 : goto err;
426 : : }
427 : 11197192 : state->lastmark = -1;
428 : 11197192 : state->lastindex = -1;
429 : :
430 : 11197192 : state->buffer.buf = NULL;
431 : 11197192 : ptr = getstring(string, &length, &isbytes, &charsize, &state->buffer);
432 [ + + ]: 11197192 : if (!ptr)
433 : 7 : goto err;
434 : :
435 [ + + + + ]: 11197185 : if (isbytes && pattern->isbytes == 0) {
436 : 7 : PyErr_SetString(PyExc_TypeError,
437 : : "cannot use a string pattern on a bytes-like object");
438 : 7 : goto err;
439 : : }
440 [ + + + + ]: 11197178 : if (!isbytes && pattern->isbytes > 0) {
441 : 6 : PyErr_SetString(PyExc_TypeError,
442 : : "cannot use a bytes pattern on a string-like object");
443 : 6 : goto err;
444 : : }
445 : :
446 : : /* adjust boundaries */
447 [ - + ]: 11197172 : if (start < 0)
448 : 0 : start = 0;
449 [ + + ]: 11197172 : else if (start > length)
450 : 4 : start = length;
451 : :
452 [ - + ]: 11197172 : if (end < 0)
453 : 0 : end = 0;
454 [ + + ]: 11197172 : else if (end > length)
455 : 11196834 : end = length;
456 : :
457 : 11197172 : state->isbytes = isbytes;
458 : 11197172 : state->charsize = charsize;
459 : 11197172 : state->match_all = 0;
460 : 11197172 : state->must_advance = 0;
461 : :
462 : 11197172 : state->beginning = ptr;
463 : :
464 : 11197172 : state->start = (void*) ((char*) ptr + start * state->charsize);
465 : 11197172 : state->end = (void*) ((char*) ptr + end * state->charsize);
466 : :
467 : 11197172 : Py_INCREF(string);
468 : 11197172 : state->string = string;
469 : 11197172 : state->pos = start;
470 : 11197172 : state->endpos = end;
471 : :
472 : 11197172 : return string;
473 : 20 : err:
474 : : /* We add an explicit cast here because MSVC has a bug when
475 : : compiling C code where it believes that `const void**` cannot be
476 : : safely casted to `void*`, see bpo-39943 for details. */
477 : 20 : PyMem_Free((void*) state->mark);
478 : 20 : state->mark = NULL;
479 [ + + ]: 20 : if (state->buffer.buf)
480 : 7 : PyBuffer_Release(&state->buffer);
481 : 20 : return NULL;
482 : : }
483 : :
484 : : LOCAL(void)
485 : 11197173 : state_fini(SRE_STATE* state)
486 : : {
487 [ + + ]: 11197173 : if (state->buffer.buf)
488 : 36115 : PyBuffer_Release(&state->buffer);
489 : 11197173 : Py_XDECREF(state->string);
490 : 11197173 : data_stack_dealloc(state);
491 : : /* See above PyMem_Del for why we explicitly cast here. */
492 : 11197173 : PyMem_Free((void*) state->mark);
493 : 11197173 : state->mark = NULL;
494 : 11197173 : }
495 : :
496 : : /* calculate offset from start of string */
497 : : #define STATE_OFFSET(state, member)\
498 : : (((char*)(member) - (char*)(state)->beginning) / (state)->charsize)
499 : :
500 : : LOCAL(PyObject*)
501 : 1157497 : getslice(int isbytes, const void *ptr,
502 : : PyObject* string, Py_ssize_t start, Py_ssize_t end)
503 : : {
504 [ + + ]: 1157497 : if (isbytes) {
505 [ + + + + ]: 39895 : if (PyBytes_CheckExact(string) &&
506 [ + + ]: 4556 : start == 0 && end == PyBytes_GET_SIZE(string)) {
507 : 881 : Py_INCREF(string);
508 : 881 : return string;
509 : : }
510 : 39014 : return PyBytes_FromStringAndSize(
511 : : (const char *)ptr + start, end - start);
512 : : }
513 : : else {
514 : 1117602 : return PyUnicode_Substring(string, start, end);
515 : : }
516 : : }
517 : :
518 : : LOCAL(PyObject*)
519 : 154709 : state_getslice(SRE_STATE* state, Py_ssize_t index, PyObject* string, int empty)
520 : : {
521 : : Py_ssize_t i, j;
522 : :
523 : 154709 : index = (index - 1) * 2;
524 : :
525 [ + - + + : 154709 : if (string == Py_None || index >= state->lastmark || !state->mark[index] || !state->mark[index+1]) {
+ + - + ]
526 [ + + ]: 4870 : if (empty)
527 : : /* want empty string */
528 : 4862 : i = j = 0;
529 : : else {
530 : 8 : Py_RETURN_NONE;
531 : : }
532 : : } else {
533 : 149839 : i = STATE_OFFSET(state, state->mark[index]);
534 : 149839 : j = STATE_OFFSET(state, state->mark[index+1]);
535 : :
536 : : /* check wrong span */
537 [ - + ]: 149839 : if (i > j) {
538 : 0 : PyErr_SetString(PyExc_SystemError,
539 : : "The span of capturing group is wrong,"
540 : : " please report a bug for the re module.");
541 : 0 : return NULL;
542 : : }
543 : : }
544 : :
545 : 154701 : return getslice(state->isbytes, state->beginning, string, i, j);
546 : : }
547 : :
548 : : static void
549 : 0 : pattern_error(Py_ssize_t status)
550 : : {
551 [ # # # # ]: 0 : switch (status) {
552 : 0 : case SRE_ERROR_RECURSION_LIMIT:
553 : : /* This error code seems to be unused. */
554 : 0 : PyErr_SetString(
555 : : PyExc_RecursionError,
556 : : "maximum recursion limit exceeded"
557 : : );
558 : 0 : break;
559 : 0 : case SRE_ERROR_MEMORY:
560 : : PyErr_NoMemory();
561 : 0 : break;
562 : 0 : case SRE_ERROR_INTERRUPTED:
563 : : /* An exception has already been raised, so let it fly */
564 : 0 : break;
565 : 0 : default:
566 : : /* other error codes indicate compiler/engine bugs */
567 : 0 : PyErr_SetString(
568 : : PyExc_RuntimeError,
569 : : "internal error in regular expression engine"
570 : : );
571 : : }
572 : 0 : }
573 : :
574 : : static int
575 : 1843051 : pattern_traverse(PatternObject *self, visitproc visit, void *arg)
576 : : {
577 [ + - - + ]: 1843051 : Py_VISIT(Py_TYPE(self));
578 [ + + - + ]: 1843051 : Py_VISIT(self->groupindex);
579 [ + + - + ]: 1843051 : Py_VISIT(self->indexgroup);
580 [ + - - + ]: 1843051 : Py_VISIT(self->pattern);
581 : 1843051 : return 0;
582 : : }
583 : :
584 : : static int
585 : 58504 : pattern_clear(PatternObject *self)
586 : : {
587 [ + + ]: 58504 : Py_CLEAR(self->groupindex);
588 [ + + ]: 58504 : Py_CLEAR(self->indexgroup);
589 [ + + ]: 58504 : Py_CLEAR(self->pattern);
590 : 58504 : return 0;
591 : : }
592 : :
593 : : static void
594 : 53807 : pattern_dealloc(PatternObject* self)
595 : : {
596 : 53807 : PyTypeObject *tp = Py_TYPE(self);
597 : :
598 : 53807 : PyObject_GC_UnTrack(self);
599 [ - + ]: 53807 : if (self->weakreflist != NULL) {
600 : 0 : PyObject_ClearWeakRefs((PyObject *) self);
601 : : }
602 : 53807 : (void)pattern_clear(self);
603 : 53807 : tp->tp_free(self);
604 : 53807 : Py_DECREF(tp);
605 : 53807 : }
606 : :
607 : : LOCAL(Py_ssize_t)
608 : 8318623 : sre_match(SRE_STATE* state, SRE_CODE* pattern)
609 : : {
610 [ + + ]: 8318623 : if (state->charsize == 1)
611 : 8314001 : return sre_ucs1_match(state, pattern, 1);
612 [ + + ]: 4622 : if (state->charsize == 2)
613 : 4179 : return sre_ucs2_match(state, pattern, 1);
614 : : assert(state->charsize == 4);
615 : 443 : return sre_ucs4_match(state, pattern, 1);
616 : : }
617 : :
618 : : LOCAL(Py_ssize_t)
619 : 3095652 : sre_search(SRE_STATE* state, SRE_CODE* pattern)
620 : : {
621 [ + + ]: 3095652 : if (state->charsize == 1)
622 : 3091399 : return sre_ucs1_search(state, pattern);
623 [ + + ]: 4253 : if (state->charsize == 2)
624 : 4194 : return sre_ucs2_search(state, pattern);
625 : : assert(state->charsize == 4);
626 : 59 : return sre_ucs4_search(state, pattern);
627 : : }
628 : :
629 : : /*[clinic input]
630 : : _sre.SRE_Pattern.match
631 : :
632 : : cls: defining_class
633 : : /
634 : : string: object
635 : : pos: Py_ssize_t = 0
636 : : endpos: Py_ssize_t(c_default="PY_SSIZE_T_MAX") = sys.maxsize
637 : :
638 : : Matches zero or more characters at the beginning of the string.
639 : : [clinic start generated code]*/
640 : :
641 : : static PyObject *
642 : 8306927 : _sre_SRE_Pattern_match_impl(PatternObject *self, PyTypeObject *cls,
643 : : PyObject *string, Py_ssize_t pos,
644 : : Py_ssize_t endpos)
645 : : /*[clinic end generated code: output=ec6208ea58a0cca0 input=4bdb9c3e564d13ac]*/
646 : : {
647 : 8306927 : _sremodulestate *module_state = get_sre_module_state_by_class(cls);
648 : : SRE_STATE state;
649 : : Py_ssize_t status;
650 : : PyObject *match;
651 : :
652 [ + + ]: 8306927 : if (!state_init(&state, (PatternObject *)self, string, pos, endpos))
653 : 13 : return NULL;
654 : :
655 : 8306914 : state.ptr = state.start;
656 : :
657 : : TRACE(("|%p|%p|MATCH\n", PatternObject_GetCode(self), state.ptr));
658 : :
659 : 8306914 : status = sre_match(&state, PatternObject_GetCode(self));
660 : :
661 : : TRACE(("|%p|%p|END\n", PatternObject_GetCode(self), state.ptr));
662 [ - + ]: 8306914 : if (PyErr_Occurred()) {
663 : 0 : state_fini(&state);
664 : 0 : return NULL;
665 : : }
666 : :
667 : 8306914 : match = pattern_new_match(module_state, self, &state, status);
668 : 8306914 : state_fini(&state);
669 : 8306914 : return match;
670 : : }
671 : :
672 : : /*[clinic input]
673 : : _sre.SRE_Pattern.fullmatch
674 : :
675 : : cls: defining_class
676 : : /
677 : : string: object
678 : : pos: Py_ssize_t = 0
679 : : endpos: Py_ssize_t(c_default="PY_SSIZE_T_MAX") = sys.maxsize
680 : :
681 : : Matches against all of the string.
682 : : [clinic start generated code]*/
683 : :
684 : : static PyObject *
685 : 11693 : _sre_SRE_Pattern_fullmatch_impl(PatternObject *self, PyTypeObject *cls,
686 : : PyObject *string, Py_ssize_t pos,
687 : : Py_ssize_t endpos)
688 : : /*[clinic end generated code: output=625b75b027ef94da input=50981172ab0fcfdd]*/
689 : : {
690 : 11693 : _sremodulestate *module_state = get_sre_module_state_by_class(cls);
691 : : SRE_STATE state;
692 : : Py_ssize_t status;
693 : : PyObject *match;
694 : :
695 [ - + ]: 11693 : if (!state_init(&state, self, string, pos, endpos))
696 : 0 : return NULL;
697 : :
698 : 11693 : state.ptr = state.start;
699 : :
700 : : TRACE(("|%p|%p|FULLMATCH\n", PatternObject_GetCode(self), state.ptr));
701 : :
702 : 11693 : state.match_all = 1;
703 : 11693 : status = sre_match(&state, PatternObject_GetCode(self));
704 : :
705 : : TRACE(("|%p|%p|END\n", PatternObject_GetCode(self), state.ptr));
706 [ - + ]: 11693 : if (PyErr_Occurred()) {
707 : 0 : state_fini(&state);
708 : 0 : return NULL;
709 : : }
710 : :
711 : 11693 : match = pattern_new_match(module_state, self, &state, status);
712 : 11693 : state_fini(&state);
713 : 11693 : return match;
714 : : }
715 : :
716 : : /*[clinic input]
717 : : _sre.SRE_Pattern.search
718 : :
719 : : cls: defining_class
720 : : /
721 : : string: object
722 : : pos: Py_ssize_t = 0
723 : : endpos: Py_ssize_t(c_default="PY_SSIZE_T_MAX") = sys.maxsize
724 : :
725 : : Scan through string looking for a match, and return a corresponding match object instance.
726 : :
727 : : Return None if no position in the string matches.
728 : : [clinic start generated code]*/
729 : :
730 : : static PyObject *
731 : 89362 : _sre_SRE_Pattern_search_impl(PatternObject *self, PyTypeObject *cls,
732 : : PyObject *string, Py_ssize_t pos,
733 : : Py_ssize_t endpos)
734 : : /*[clinic end generated code: output=bd7f2d9d583e1463 input=afa9afb66a74a4b3]*/
735 : : {
736 : 89362 : _sremodulestate *module_state = get_sre_module_state_by_class(cls);
737 : : SRE_STATE state;
738 : : Py_ssize_t status;
739 : : PyObject *match;
740 : :
741 [ + + ]: 89362 : if (!state_init(&state, self, string, pos, endpos))
742 : 2 : return NULL;
743 : :
744 : : TRACE(("|%p|%p|SEARCH\n", PatternObject_GetCode(self), state.ptr));
745 : :
746 : 89360 : status = sre_search(&state, PatternObject_GetCode(self));
747 : :
748 : : TRACE(("|%p|%p|END\n", PatternObject_GetCode(self), state.ptr));
749 : :
750 [ - + ]: 89360 : if (PyErr_Occurred()) {
751 : 0 : state_fini(&state);
752 : 0 : return NULL;
753 : : }
754 : :
755 : 89360 : match = pattern_new_match(module_state, self, &state, status);
756 : 89360 : state_fini(&state);
757 : 89360 : return match;
758 : : }
759 : :
760 : : static PyObject*
761 : 10745 : call(const char* module, const char* function, PyObject* args)
762 : : {
763 : : PyObject* func;
764 : : PyObject* result;
765 : :
766 [ - + ]: 10745 : if (!args)
767 : 0 : return NULL;
768 : 10745 : func = _PyImport_GetModuleAttrString(module, function);
769 [ - + ]: 10745 : if (!func)
770 : 0 : return NULL;
771 : 10745 : result = PyObject_CallObject(func, args);
772 : 10745 : Py_DECREF(func);
773 : 10745 : Py_DECREF(args);
774 : 10745 : return result;
775 : : }
776 : :
777 : : /*[clinic input]
778 : : _sre.SRE_Pattern.findall
779 : :
780 : : string: object
781 : : pos: Py_ssize_t = 0
782 : : endpos: Py_ssize_t(c_default="PY_SSIZE_T_MAX") = sys.maxsize
783 : :
784 : : Return a list of all non-overlapping matches of pattern in string.
785 : : [clinic start generated code]*/
786 : :
787 : : static PyObject *
788 : 36302 : _sre_SRE_Pattern_findall_impl(PatternObject *self, PyObject *string,
789 : : Py_ssize_t pos, Py_ssize_t endpos)
790 : : /*[clinic end generated code: output=f4966baceea60aca input=5b6a4ee799741563]*/
791 : : {
792 : : SRE_STATE state;
793 : : PyObject* list;
794 : : Py_ssize_t status;
795 : : Py_ssize_t i, b, e;
796 : :
797 [ - + ]: 36302 : if (!state_init(&state, self, string, pos, endpos))
798 : 0 : return NULL;
799 : :
800 : 36302 : list = PyList_New(0);
801 [ - + ]: 36302 : if (!list) {
802 : 0 : state_fini(&state);
803 : 0 : return NULL;
804 : : }
805 : :
806 [ + - ]: 168412 : while (state.start <= state.end) {
807 : :
808 : : PyObject* item;
809 : :
810 : 168412 : state_reset(&state);
811 : :
812 : 168412 : state.ptr = state.start;
813 : :
814 : 168412 : status = sre_search(&state, PatternObject_GetCode(self));
815 [ - + ]: 168412 : if (PyErr_Occurred())
816 : 0 : goto error;
817 : :
818 [ + + ]: 168412 : if (status <= 0) {
819 [ + - ]: 36302 : if (status == 0)
820 : 36302 : break;
821 : 0 : pattern_error(status);
822 : 0 : goto error;
823 : : }
824 : :
825 : : /* don't bother to build a match object */
826 [ + + + ]: 132110 : switch (self->groups) {
827 : 39132 : case 0:
828 : 39132 : b = STATE_OFFSET(&state, state.start);
829 : 39132 : e = STATE_OFFSET(&state, state.ptr);
830 : 39132 : item = getslice(state.isbytes, state.beginning,
831 : : string, b, e);
832 [ - + ]: 39132 : if (!item)
833 : 0 : goto error;
834 : 39132 : break;
835 : 57261 : case 1:
836 : 57261 : item = state_getslice(&state, 1, string, 1);
837 [ - + ]: 57261 : if (!item)
838 : 0 : goto error;
839 : 57261 : break;
840 : 35717 : default:
841 : 35717 : item = PyTuple_New(self->groups);
842 [ - + ]: 35717 : if (!item)
843 : 0 : goto error;
844 [ + + ]: 107195 : for (i = 0; i < self->groups; i++) {
845 : 71478 : PyObject* o = state_getslice(&state, i+1, string, 1);
846 [ - + ]: 71478 : if (!o) {
847 : 0 : Py_DECREF(item);
848 : 0 : goto error;
849 : : }
850 : 71478 : PyTuple_SET_ITEM(item, i, o);
851 : : }
852 : 35717 : break;
853 : : }
854 : :
855 : 132110 : status = PyList_Append(list, item);
856 : 132110 : Py_DECREF(item);
857 [ - + ]: 132110 : if (status < 0)
858 : 0 : goto error;
859 : :
860 : 132110 : state.must_advance = (state.ptr == state.start);
861 : 132110 : state.start = state.ptr;
862 : : }
863 : :
864 : 36302 : state_fini(&state);
865 : 36302 : return list;
866 : :
867 : 0 : error:
868 : 0 : Py_DECREF(list);
869 : 0 : state_fini(&state);
870 : 0 : return NULL;
871 : :
872 : : }
873 : :
874 : : /*[clinic input]
875 : : _sre.SRE_Pattern.finditer
876 : :
877 : : cls: defining_class
878 : : /
879 : : string: object
880 : : pos: Py_ssize_t = 0
881 : : endpos: Py_ssize_t(c_default="PY_SSIZE_T_MAX") = sys.maxsize
882 : :
883 : : Return an iterator over all non-overlapping matches for the RE pattern in string.
884 : :
885 : : For each match, the iterator returns a match object.
886 : : [clinic start generated code]*/
887 : :
888 : : static PyObject *
889 : 2660775 : _sre_SRE_Pattern_finditer_impl(PatternObject *self, PyTypeObject *cls,
890 : : PyObject *string, Py_ssize_t pos,
891 : : Py_ssize_t endpos)
892 : : /*[clinic end generated code: output=1791dbf3618ade56 input=812e332a4848cbaf]*/
893 : : {
894 : 2660775 : _sremodulestate *module_state = get_sre_module_state_by_class(cls);
895 : : PyObject* scanner;
896 : : PyObject* search;
897 : : PyObject* iterator;
898 : :
899 : 2660775 : scanner = pattern_scanner(module_state, self, string, pos, endpos);
900 [ + + ]: 2660775 : if (!scanner)
901 : 1 : return NULL;
902 : :
903 : 2660774 : search = PyObject_GetAttrString(scanner, "search");
904 : 2660774 : Py_DECREF(scanner);
905 [ - + ]: 2660774 : if (!search)
906 : 0 : return NULL;
907 : :
908 : 2660774 : iterator = PyCallIter_New(search, Py_None);
909 : 2660774 : Py_DECREF(search);
910 : :
911 : 2660774 : return iterator;
912 : : }
913 : :
914 : : /*[clinic input]
915 : : _sre.SRE_Pattern.scanner
916 : :
917 : : cls: defining_class
918 : : /
919 : : string: object
920 : : pos: Py_ssize_t = 0
921 : : endpos: Py_ssize_t(c_default="PY_SSIZE_T_MAX") = sys.maxsize
922 : :
923 : : [clinic start generated code]*/
924 : :
925 : : static PyObject *
926 : 6 : _sre_SRE_Pattern_scanner_impl(PatternObject *self, PyTypeObject *cls,
927 : : PyObject *string, Py_ssize_t pos,
928 : : Py_ssize_t endpos)
929 : : /*[clinic end generated code: output=f70cd506112f1bd9 input=2e487e5151bcee4c]*/
930 : : {
931 : 6 : _sremodulestate *module_state = get_sre_module_state_by_class(cls);
932 : :
933 : 6 : return pattern_scanner(module_state, self, string, pos, endpos);
934 : : }
935 : :
936 : : /*[clinic input]
937 : : _sre.SRE_Pattern.split
938 : :
939 : : string: object
940 : : maxsplit: Py_ssize_t = 0
941 : :
942 : : Split string by the occurrences of pattern.
943 : : [clinic start generated code]*/
944 : :
945 : : static PyObject *
946 : 16477 : _sre_SRE_Pattern_split_impl(PatternObject *self, PyObject *string,
947 : : Py_ssize_t maxsplit)
948 : : /*[clinic end generated code: output=7ac66f381c45e0be input=1eeeb10dafc9947a]*/
949 : : {
950 : : SRE_STATE state;
951 : : PyObject* list;
952 : : PyObject* item;
953 : : Py_ssize_t status;
954 : : Py_ssize_t n;
955 : : Py_ssize_t i;
956 : : const void* last;
957 : :
958 : : assert(self->codesize != 0);
959 : :
960 [ - + ]: 16477 : if (!state_init(&state, self, string, 0, PY_SSIZE_T_MAX))
961 : 0 : return NULL;
962 : :
963 : 16477 : list = PyList_New(0);
964 [ - + ]: 16477 : if (!list) {
965 : 0 : state_fini(&state);
966 : 0 : return NULL;
967 : : }
968 : :
969 : 16477 : n = 0;
970 : 16477 : last = state.start;
971 : :
972 [ + + + + ]: 43893 : while (!maxsplit || n < maxsplit) {
973 : :
974 : 41572 : state_reset(&state);
975 : :
976 : 41572 : state.ptr = state.start;
977 : :
978 : 41572 : status = sre_search(&state, PatternObject_GetCode(self));
979 [ - + ]: 41572 : if (PyErr_Occurred())
980 : 0 : goto error;
981 : :
982 [ + + ]: 41572 : if (status <= 0) {
983 [ + - ]: 14156 : if (status == 0)
984 : 14156 : break;
985 : 0 : pattern_error(status);
986 : 0 : goto error;
987 : : }
988 : :
989 : : /* get segment before this match */
990 : 27416 : item = getslice(state.isbytes, state.beginning,
991 : 27416 : string, STATE_OFFSET(&state, last),
992 : 27416 : STATE_OFFSET(&state, state.start)
993 : : );
994 [ - + ]: 27416 : if (!item)
995 : 0 : goto error;
996 : 27416 : status = PyList_Append(list, item);
997 : 27416 : Py_DECREF(item);
998 [ - + ]: 27416 : if (status < 0)
999 : 0 : goto error;
1000 : :
1001 : : /* add groups (if any) */
1002 [ + + ]: 53386 : for (i = 0; i < self->groups; i++) {
1003 : 25970 : item = state_getslice(&state, i+1, string, 0);
1004 [ - + ]: 25970 : if (!item)
1005 : 0 : goto error;
1006 : 25970 : status = PyList_Append(list, item);
1007 : 25970 : Py_DECREF(item);
1008 [ - + ]: 25970 : if (status < 0)
1009 : 0 : goto error;
1010 : : }
1011 : :
1012 : 27416 : n = n + 1;
1013 : 27416 : state.must_advance = (state.ptr == state.start);
1014 : 27416 : last = state.start = state.ptr;
1015 : :
1016 : : }
1017 : :
1018 : : /* get segment following last match (even if empty) */
1019 : 16477 : item = getslice(state.isbytes, state.beginning,
1020 : 16477 : string, STATE_OFFSET(&state, last), state.endpos
1021 : : );
1022 [ - + ]: 16477 : if (!item)
1023 : 0 : goto error;
1024 : 16477 : status = PyList_Append(list, item);
1025 : 16477 : Py_DECREF(item);
1026 [ - + ]: 16477 : if (status < 0)
1027 : 0 : goto error;
1028 : :
1029 : 16477 : state_fini(&state);
1030 : 16477 : return list;
1031 : :
1032 : 0 : error:
1033 : 0 : Py_DECREF(list);
1034 : 0 : state_fini(&state);
1035 : 0 : return NULL;
1036 : :
1037 : : }
1038 : :
1039 : : static PyObject*
1040 : 75728 : pattern_subx(_sremodulestate* module_state,
1041 : : PatternObject* self,
1042 : : PyObject* ptemplate,
1043 : : PyObject* string,
1044 : : Py_ssize_t count,
1045 : : Py_ssize_t subn)
1046 : : {
1047 : : SRE_STATE state;
1048 : : PyObject* list;
1049 : : PyObject* joiner;
1050 : : PyObject* item;
1051 : : PyObject* filter;
1052 : : PyObject* match;
1053 : : const void* ptr;
1054 : : Py_ssize_t status;
1055 : : Py_ssize_t n;
1056 : : Py_ssize_t i, b, e;
1057 : : int isbytes, charsize;
1058 : : int filter_is_callable;
1059 : : Py_buffer view;
1060 : :
1061 [ + + ]: 75728 : if (PyCallable_Check(ptemplate)) {
1062 : : /* sub/subn takes either a function or a template */
1063 : 24277 : filter = ptemplate;
1064 : 24277 : Py_INCREF(filter);
1065 : 24277 : filter_is_callable = 1;
1066 : : } else {
1067 : : /* if not callable, check if it's a literal string */
1068 : : int literal;
1069 : 51451 : view.buf = NULL;
1070 : 51451 : ptr = getstring(ptemplate, &n, &isbytes, &charsize, &view);
1071 [ + - ]: 51451 : if (ptr) {
1072 [ + + ]: 51451 : if (charsize == 1)
1073 : 51448 : literal = memchr(ptr, '\\', n) == NULL;
1074 : : else
1075 : 3 : literal = PyUnicode_FindChar(ptemplate, '\\', 0, n, 1) == -1;
1076 : : } else {
1077 : 0 : PyErr_Clear();
1078 : 0 : literal = 0;
1079 : : }
1080 [ + + ]: 51451 : if (view.buf)
1081 : 110 : PyBuffer_Release(&view);
1082 [ + + ]: 51451 : if (literal) {
1083 : 40708 : filter = ptemplate;
1084 : 40708 : Py_INCREF(filter);
1085 : 40708 : filter_is_callable = 0;
1086 : : } else {
1087 : : /* not a literal; hand it over to the template compiler */
1088 : 10743 : filter = call(
1089 : : SRE_PY_MODULE, "_subx",
1090 : : PyTuple_Pack(2, self, ptemplate)
1091 : : );
1092 [ + + ]: 10743 : if (!filter)
1093 : 78 : return NULL;
1094 : 10665 : filter_is_callable = PyCallable_Check(filter);
1095 : : }
1096 : : }
1097 : :
1098 [ + + ]: 75650 : if (!state_init(&state, self, string, 0, PY_SSIZE_T_MAX)) {
1099 : 4 : Py_DECREF(filter);
1100 : 4 : return NULL;
1101 : : }
1102 : :
1103 : 75646 : list = PyList_New(0);
1104 [ - + ]: 75646 : if (!list) {
1105 : 0 : Py_DECREF(filter);
1106 : 0 : state_fini(&state);
1107 : 0 : return NULL;
1108 : : }
1109 : :
1110 : 75646 : n = i = 0;
1111 : :
1112 [ + + + + ]: 118775 : while (!count || n < count) {
1113 : :
1114 : 118618 : state_reset(&state);
1115 : :
1116 : 118618 : state.ptr = state.start;
1117 : :
1118 : 118618 : status = sre_search(&state, PatternObject_GetCode(self));
1119 [ - + ]: 118618 : if (PyErr_Occurred())
1120 : 0 : goto error;
1121 : :
1122 [ + + ]: 118618 : if (status <= 0) {
1123 [ + - ]: 75471 : if (status == 0)
1124 : 75471 : break;
1125 : 0 : pattern_error(status);
1126 : 0 : goto error;
1127 : : }
1128 : :
1129 : 43147 : b = STATE_OFFSET(&state, state.start);
1130 : 43147 : e = STATE_OFFSET(&state, state.ptr);
1131 : :
1132 [ + + ]: 43147 : if (i < b) {
1133 : : /* get segment before this match */
1134 : 37686 : item = getslice(state.isbytes, state.beginning,
1135 : : string, i, b);
1136 [ - + ]: 37686 : if (!item)
1137 : 0 : goto error;
1138 : 37686 : status = PyList_Append(list, item);
1139 : 37686 : Py_DECREF(item);
1140 [ - + ]: 37686 : if (status < 0)
1141 : 0 : goto error;
1142 : :
1143 : : }
1144 : :
1145 [ + + ]: 43147 : if (filter_is_callable) {
1146 : : /* pass match object through filter */
1147 : 5477 : match = pattern_new_match(module_state, self, &state, 1);
1148 [ - + ]: 5477 : if (!match)
1149 : 0 : goto error;
1150 : 5477 : item = PyObject_CallOneArg(filter, match);
1151 : 5477 : Py_DECREF(match);
1152 [ + + ]: 5477 : if (!item)
1153 : 18 : goto error;
1154 : : } else {
1155 : : /* filter is literal string */
1156 : 37670 : item = filter;
1157 : 37670 : Py_INCREF(item);
1158 : : }
1159 : :
1160 : : /* add to list */
1161 [ + - ]: 43129 : if (item != Py_None) {
1162 : 43129 : status = PyList_Append(list, item);
1163 : 43129 : Py_DECREF(item);
1164 [ - + ]: 43129 : if (status < 0)
1165 : 0 : goto error;
1166 : : }
1167 : :
1168 : 43129 : i = e;
1169 : 43129 : n = n + 1;
1170 : 43129 : state.must_advance = (state.ptr == state.start);
1171 : 43129 : state.start = state.ptr;
1172 : : }
1173 : :
1174 : : /* get segment following last match */
1175 [ + + ]: 75628 : if (i < state.endpos) {
1176 : 68461 : item = getslice(state.isbytes, state.beginning,
1177 : : string, i, state.endpos);
1178 [ - + ]: 68461 : if (!item)
1179 : 0 : goto error;
1180 : 68461 : status = PyList_Append(list, item);
1181 : 68461 : Py_DECREF(item);
1182 [ - + ]: 68461 : if (status < 0)
1183 : 0 : goto error;
1184 : : }
1185 : :
1186 : 75628 : state_fini(&state);
1187 : :
1188 : 75628 : Py_DECREF(filter);
1189 : :
1190 : : /* convert list to single string (also removes list) */
1191 : 75628 : joiner = getslice(state.isbytes, state.beginning, string, 0, 0);
1192 [ - + ]: 75628 : if (!joiner) {
1193 : 0 : Py_DECREF(list);
1194 : 0 : return NULL;
1195 : : }
1196 [ + + ]: 75628 : if (PyList_GET_SIZE(list) == 0) {
1197 : 410 : Py_DECREF(list);
1198 : 410 : item = joiner;
1199 : : }
1200 : : else {
1201 [ + + ]: 75218 : if (state.isbytes)
1202 : 300 : item = _PyBytes_Join(joiner, list);
1203 : : else
1204 : 74918 : item = PyUnicode_Join(joiner, list);
1205 : 75218 : Py_DECREF(joiner);
1206 : 75218 : Py_DECREF(list);
1207 [ + + ]: 75218 : if (!item)
1208 : 2 : return NULL;
1209 : : }
1210 : :
1211 [ + + ]: 75626 : if (subn)
1212 : 175 : return Py_BuildValue("Nn", item, n);
1213 : :
1214 : 75451 : return item;
1215 : :
1216 : 18 : error:
1217 : 18 : Py_DECREF(list);
1218 : 18 : state_fini(&state);
1219 : 18 : Py_DECREF(filter);
1220 : 18 : return NULL;
1221 : :
1222 : : }
1223 : :
1224 : : /*[clinic input]
1225 : : _sre.SRE_Pattern.sub
1226 : :
1227 : : cls: defining_class
1228 : : /
1229 : : repl: object
1230 : : string: object
1231 : : count: Py_ssize_t = 0
1232 : :
1233 : : Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl.
1234 : : [clinic start generated code]*/
1235 : :
1236 : : static PyObject *
1237 : 75553 : _sre_SRE_Pattern_sub_impl(PatternObject *self, PyTypeObject *cls,
1238 : : PyObject *repl, PyObject *string, Py_ssize_t count)
1239 : : /*[clinic end generated code: output=4be141ab04bca60d input=d8d1d4ac2311a07c]*/
1240 : : {
1241 : 75553 : _sremodulestate *module_state = get_sre_module_state_by_class(cls);
1242 : :
1243 : 75553 : return pattern_subx(module_state, self, repl, string, count, 0);
1244 : : }
1245 : :
1246 : : /*[clinic input]
1247 : : _sre.SRE_Pattern.subn
1248 : :
1249 : : cls: defining_class
1250 : : /
1251 : : repl: object
1252 : : string: object
1253 : : count: Py_ssize_t = 0
1254 : :
1255 : : Return the tuple (new_string, number_of_subs_made) found by replacing the leftmost non-overlapping occurrences of pattern with the replacement repl.
1256 : : [clinic start generated code]*/
1257 : :
1258 : : static PyObject *
1259 : 175 : _sre_SRE_Pattern_subn_impl(PatternObject *self, PyTypeObject *cls,
1260 : : PyObject *repl, PyObject *string,
1261 : : Py_ssize_t count)
1262 : : /*[clinic end generated code: output=da02fd85258b1e1f input=8b78a65b8302e58d]*/
1263 : : {
1264 : 175 : _sremodulestate *module_state = get_sre_module_state_by_class(cls);
1265 : :
1266 : 175 : return pattern_subx(module_state, self, repl, string, count, 1);
1267 : : }
1268 : :
1269 : : /*[clinic input]
1270 : : _sre.SRE_Pattern.__copy__
1271 : :
1272 : : [clinic start generated code]*/
1273 : :
1274 : : static PyObject *
1275 : 1 : _sre_SRE_Pattern___copy___impl(PatternObject *self)
1276 : : /*[clinic end generated code: output=85dedc2db1bd8694 input=a730a59d863bc9f5]*/
1277 : : {
1278 : 1 : Py_INCREF(self);
1279 : 1 : return (PyObject *)self;
1280 : : }
1281 : :
1282 : : /*[clinic input]
1283 : : _sre.SRE_Pattern.__deepcopy__
1284 : :
1285 : : memo: object
1286 : : /
1287 : :
1288 : : [clinic start generated code]*/
1289 : :
1290 : : static PyObject *
1291 : 1 : _sre_SRE_Pattern___deepcopy__(PatternObject *self, PyObject *memo)
1292 : : /*[clinic end generated code: output=2ad25679c1f1204a input=a465b1602f997bed]*/
1293 : : {
1294 : 1 : Py_INCREF(self);
1295 : 1 : return (PyObject *)self;
1296 : : }
1297 : :
1298 : : static PyObject *
1299 : 18 : pattern_repr(PatternObject *obj)
1300 : : {
1301 : : static const struct {
1302 : : const char *name;
1303 : : int value;
1304 : : } flag_names[] = {
1305 : : {"re.TEMPLATE", SRE_FLAG_TEMPLATE},
1306 : : {"re.IGNORECASE", SRE_FLAG_IGNORECASE},
1307 : : {"re.LOCALE", SRE_FLAG_LOCALE},
1308 : : {"re.MULTILINE", SRE_FLAG_MULTILINE},
1309 : : {"re.DOTALL", SRE_FLAG_DOTALL},
1310 : : {"re.UNICODE", SRE_FLAG_UNICODE},
1311 : : {"re.VERBOSE", SRE_FLAG_VERBOSE},
1312 : : {"re.DEBUG", SRE_FLAG_DEBUG},
1313 : : {"re.ASCII", SRE_FLAG_ASCII},
1314 : : };
1315 : 18 : PyObject *result = NULL;
1316 : : PyObject *flag_items;
1317 : : size_t i;
1318 : 18 : int flags = obj->flags;
1319 : :
1320 : : /* Omit re.UNICODE for valid string patterns. */
1321 [ + + ]: 18 : if (obj->isbytes == 0 &&
1322 [ + - ]: 15 : (flags & (SRE_FLAG_LOCALE|SRE_FLAG_UNICODE|SRE_FLAG_ASCII)) ==
1323 : : SRE_FLAG_UNICODE)
1324 : 15 : flags &= ~SRE_FLAG_UNICODE;
1325 : :
1326 : 18 : flag_items = PyList_New(0);
1327 [ - + ]: 18 : if (!flag_items)
1328 : 0 : return NULL;
1329 : :
1330 [ + + ]: 180 : for (i = 0; i < Py_ARRAY_LENGTH(flag_names); i++) {
1331 [ + + ]: 162 : if (flags & flag_names[i].value) {
1332 : 11 : PyObject *item = PyUnicode_FromString(flag_names[i].name);
1333 [ - + ]: 11 : if (!item)
1334 : 0 : goto done;
1335 : :
1336 [ - + ]: 11 : if (PyList_Append(flag_items, item) < 0) {
1337 : 0 : Py_DECREF(item);
1338 : 0 : goto done;
1339 : : }
1340 : 11 : Py_DECREF(item);
1341 : 11 : flags &= ~flag_names[i].value;
1342 : : }
1343 : : }
1344 [ + + ]: 18 : if (flags) {
1345 : 2 : PyObject *item = PyUnicode_FromFormat("0x%x", flags);
1346 [ - + ]: 2 : if (!item)
1347 : 0 : goto done;
1348 : :
1349 [ - + ]: 2 : if (PyList_Append(flag_items, item) < 0) {
1350 : 0 : Py_DECREF(item);
1351 : 0 : goto done;
1352 : : }
1353 : 2 : Py_DECREF(item);
1354 : : }
1355 : :
1356 [ + + ]: 18 : if (PyList_Size(flag_items) > 0) {
1357 : : PyObject *flags_result;
1358 : 9 : PyObject *sep = PyUnicode_FromString("|");
1359 [ - + ]: 9 : if (!sep)
1360 : 0 : goto done;
1361 : 9 : flags_result = PyUnicode_Join(sep, flag_items);
1362 : 9 : Py_DECREF(sep);
1363 [ - + ]: 9 : if (!flags_result)
1364 : 0 : goto done;
1365 : 9 : result = PyUnicode_FromFormat("re.compile(%.200R, %S)",
1366 : : obj->pattern, flags_result);
1367 : 9 : Py_DECREF(flags_result);
1368 : : }
1369 : : else {
1370 : 9 : result = PyUnicode_FromFormat("re.compile(%.200R)", obj->pattern);
1371 : : }
1372 : :
1373 : 18 : done:
1374 : 18 : Py_DECREF(flag_items);
1375 : 18 : return result;
1376 : : }
1377 : :
1378 : : PyDoc_STRVAR(pattern_doc, "Compiled regular expression object.");
1379 : :
1380 : : /* PatternObject's 'groupindex' method. */
1381 : : static PyObject *
1382 : 636 : pattern_groupindex(PatternObject *self, void *Py_UNUSED(ignored))
1383 : : {
1384 [ + + ]: 636 : if (self->groupindex == NULL)
1385 : 582 : return PyDict_New();
1386 : 54 : return PyDictProxy_New(self->groupindex);
1387 : : }
1388 : :
1389 : : static int _validate(PatternObject *self); /* Forward */
1390 : :
1391 : : /*[clinic input]
1392 : : _sre.compile
1393 : :
1394 : : pattern: object
1395 : : flags: int
1396 : : code: object(subclass_of='&PyList_Type')
1397 : : groups: Py_ssize_t
1398 : : groupindex: object(subclass_of='&PyDict_Type')
1399 : : indexgroup: object(subclass_of='&PyTuple_Type')
1400 : :
1401 : : [clinic start generated code]*/
1402 : :
1403 : : static PyObject *
1404 : 53861 : _sre_compile_impl(PyObject *module, PyObject *pattern, int flags,
1405 : : PyObject *code, Py_ssize_t groups, PyObject *groupindex,
1406 : : PyObject *indexgroup)
1407 : : /*[clinic end generated code: output=ef9c2b3693776404 input=0a68476dbbe5db30]*/
1408 : : {
1409 : : /* "compile" pattern descriptor to pattern object */
1410 : :
1411 : 53861 : _sremodulestate *module_state = get_sre_module_state(module);
1412 : : PatternObject* self;
1413 : : Py_ssize_t i, n;
1414 : :
1415 : 53861 : n = PyList_GET_SIZE(code);
1416 : : /* coverity[ampersand_in_size] */
1417 : 53861 : self = PyObject_GC_NewVar(PatternObject, module_state->Pattern_Type, n);
1418 [ - + ]: 53861 : if (!self)
1419 : 0 : return NULL;
1420 : 53861 : self->weakreflist = NULL;
1421 : 53861 : self->pattern = NULL;
1422 : 53861 : self->groupindex = NULL;
1423 : 53861 : self->indexgroup = NULL;
1424 : :
1425 : 53861 : self->codesize = n;
1426 : :
1427 [ + + ]: 4391522 : for (i = 0; i < n; i++) {
1428 : 4337662 : PyObject *o = PyList_GET_ITEM(code, i);
1429 : 4337662 : unsigned long value = PyLong_AsUnsignedLong(o);
1430 : 4337662 : self->code[i] = (SRE_CODE) value;
1431 [ + + ]: 4337662 : if ((unsigned long) self->code[i] != value) {
1432 : 1 : PyErr_SetString(PyExc_OverflowError,
1433 : : "regular expression code size limit exceeded");
1434 : 1 : break;
1435 : : }
1436 : : }
1437 : 53861 : PyObject_GC_Track(self);
1438 : :
1439 [ + + ]: 53861 : if (PyErr_Occurred()) {
1440 : 1 : Py_DECREF(self);
1441 : 1 : return NULL;
1442 : : }
1443 : :
1444 [ + + ]: 53860 : if (pattern == Py_None) {
1445 : 1 : self->isbytes = -1;
1446 : : }
1447 : : else {
1448 : : Py_ssize_t p_length;
1449 : : int charsize;
1450 : : Py_buffer view;
1451 : 53859 : view.buf = NULL;
1452 [ - + ]: 53859 : if (!getstring(pattern, &p_length, &self->isbytes,
1453 : : &charsize, &view)) {
1454 : 0 : Py_DECREF(self);
1455 : 0 : return NULL;
1456 : : }
1457 [ + + ]: 53859 : if (view.buf)
1458 : 5262 : PyBuffer_Release(&view);
1459 : : }
1460 : :
1461 : 53860 : Py_INCREF(pattern);
1462 : 53860 : self->pattern = pattern;
1463 : :
1464 : 53860 : self->flags = flags;
1465 : :
1466 : 53860 : self->groups = groups;
1467 : :
1468 [ + + ]: 53860 : if (PyDict_GET_SIZE(groupindex) > 0) {
1469 : 5932 : Py_INCREF(groupindex);
1470 : 5932 : self->groupindex = groupindex;
1471 [ + - ]: 5932 : if (PyTuple_GET_SIZE(indexgroup) > 0) {
1472 : 5932 : Py_INCREF(indexgroup);
1473 : 5932 : self->indexgroup = indexgroup;
1474 : : }
1475 : : }
1476 : :
1477 [ - + ]: 53860 : if (!_validate(self)) {
1478 : 0 : Py_DECREF(self);
1479 : 0 : return NULL;
1480 : : }
1481 : :
1482 : 53860 : return (PyObject*) self;
1483 : : }
1484 : :
1485 : : /* -------------------------------------------------------------------- */
1486 : : /* Code validation */
1487 : :
1488 : : /* To learn more about this code, have a look at the _compile() function in
1489 : : Lib/sre_compile.py. The validation functions below checks the code array
1490 : : for conformance with the code patterns generated there.
1491 : :
1492 : : The nice thing about the generated code is that it is position-independent:
1493 : : all jumps are relative jumps forward. Also, jumps don't cross each other:
1494 : : the target of a later jump is always earlier than the target of an earlier
1495 : : jump. IOW, this is okay:
1496 : :
1497 : : J---------J-------T--------T
1498 : : \ \_____/ /
1499 : : \______________________/
1500 : :
1501 : : but this is not:
1502 : :
1503 : : J---------J-------T--------T
1504 : : \_________\_____/ /
1505 : : \____________/
1506 : :
1507 : : It also helps that SRE_CODE is always an unsigned type.
1508 : : */
1509 : :
1510 : : /* Defining this one enables tracing of the validator */
1511 : : #undef VVERBOSE
1512 : :
1513 : : /* Trace macro for the validator */
1514 : : #if defined(VVERBOSE)
1515 : : #define VTRACE(v) printf v
1516 : : #else
1517 : : #define VTRACE(v) do {} while(0) /* do nothing */
1518 : : #endif
1519 : :
1520 : : /* Report failure */
1521 : : #define FAIL do { VTRACE(("FAIL: %d\n", __LINE__)); return 0; } while (0)
1522 : :
1523 : : /* Extract opcode, argument, or skip count from code array */
1524 : : #define GET_OP \
1525 : : do { \
1526 : : VTRACE(("%p: ", code)); \
1527 : : if (code >= end) FAIL; \
1528 : : op = *code++; \
1529 : : VTRACE(("%lu (op)\n", (unsigned long)op)); \
1530 : : } while (0)
1531 : : #define GET_ARG \
1532 : : do { \
1533 : : VTRACE(("%p= ", code)); \
1534 : : if (code >= end) FAIL; \
1535 : : arg = *code++; \
1536 : : VTRACE(("%lu (arg)\n", (unsigned long)arg)); \
1537 : : } while (0)
1538 : : #define GET_SKIP_ADJ(adj) \
1539 : : do { \
1540 : : VTRACE(("%p= ", code)); \
1541 : : if (code >= end) FAIL; \
1542 : : skip = *code; \
1543 : : VTRACE(("%lu (skip to %p)\n", \
1544 : : (unsigned long)skip, code+skip)); \
1545 : : if (skip-adj > (uintptr_t)(end - code)) \
1546 : : FAIL; \
1547 : : code++; \
1548 : : } while (0)
1549 : : #define GET_SKIP GET_SKIP_ADJ(0)
1550 : :
1551 : : static int
1552 : 148508 : _validate_charset(SRE_CODE *code, SRE_CODE *end)
1553 : : {
1554 : : /* Some variables are manipulated by the macros above */
1555 : : SRE_CODE op;
1556 : : SRE_CODE arg;
1557 : : SRE_CODE offset;
1558 : : int i;
1559 : :
1560 [ + + ]: 374348 : while (code < end) {
1561 [ - + ]: 225840 : GET_OP;
1562 [ + + + + : 225840 : switch (op) {
+ + - ]
1563 : :
1564 : 13860 : case SRE_OP_NEGATE:
1565 : 13860 : break;
1566 : :
1567 : 65683 : case SRE_OP_LITERAL:
1568 [ - + ]: 65683 : GET_ARG;
1569 : 65683 : break;
1570 : :
1571 : 30810 : case SRE_OP_RANGE:
1572 : : case SRE_OP_RANGE_UNI_IGNORE:
1573 [ - + ]: 30810 : GET_ARG;
1574 [ - + ]: 30810 : GET_ARG;
1575 : 30810 : break;
1576 : :
1577 : 29621 : case SRE_OP_CHARSET:
1578 : 29621 : offset = 256/SRE_CODE_BITS; /* 256-bit bitmap */
1579 [ - + ]: 29621 : if (offset > (uintptr_t)(end - code))
1580 : 0 : FAIL;
1581 : 29621 : code += offset;
1582 : 29621 : break;
1583 : :
1584 : 2684 : case SRE_OP_BIGCHARSET:
1585 [ - + ]: 2684 : GET_ARG; /* Number of blocks */
1586 : 2684 : offset = 256/sizeof(SRE_CODE); /* 256-byte table */
1587 [ - + ]: 2684 : if (offset > (uintptr_t)(end - code))
1588 : 0 : FAIL;
1589 : : /* Make sure that each byte points to a valid block */
1590 [ + + ]: 689788 : for (i = 0; i < 256; i++) {
1591 [ - + ]: 687104 : if (((unsigned char *)code)[i] >= arg)
1592 : 0 : FAIL;
1593 : : }
1594 : 2684 : code += offset;
1595 : 2684 : offset = arg * (256/SRE_CODE_BITS); /* 256-bit bitmap times arg */
1596 [ - + ]: 2684 : if (offset > (uintptr_t)(end - code))
1597 : 0 : FAIL;
1598 : 2684 : code += offset;
1599 : 2684 : break;
1600 : :
1601 : 83182 : case SRE_OP_CATEGORY:
1602 [ - + + - ]: 83182 : GET_ARG;
1603 : : switch (arg) {
1604 : 83182 : case SRE_CATEGORY_DIGIT:
1605 : : case SRE_CATEGORY_NOT_DIGIT:
1606 : : case SRE_CATEGORY_SPACE:
1607 : : case SRE_CATEGORY_NOT_SPACE:
1608 : : case SRE_CATEGORY_WORD:
1609 : : case SRE_CATEGORY_NOT_WORD:
1610 : : case SRE_CATEGORY_LINEBREAK:
1611 : : case SRE_CATEGORY_NOT_LINEBREAK:
1612 : : case SRE_CATEGORY_LOC_WORD:
1613 : : case SRE_CATEGORY_LOC_NOT_WORD:
1614 : : case SRE_CATEGORY_UNI_DIGIT:
1615 : : case SRE_CATEGORY_UNI_NOT_DIGIT:
1616 : : case SRE_CATEGORY_UNI_SPACE:
1617 : : case SRE_CATEGORY_UNI_NOT_SPACE:
1618 : : case SRE_CATEGORY_UNI_WORD:
1619 : : case SRE_CATEGORY_UNI_NOT_WORD:
1620 : : case SRE_CATEGORY_UNI_LINEBREAK:
1621 : : case SRE_CATEGORY_UNI_NOT_LINEBREAK:
1622 : 83182 : break;
1623 : 0 : default:
1624 : 0 : FAIL;
1625 : : }
1626 : 83182 : break;
1627 : :
1628 : 0 : default:
1629 : 0 : FAIL;
1630 : :
1631 : : }
1632 : : }
1633 : :
1634 : 148508 : return 1;
1635 : : }
1636 : :
1637 : : static int
1638 : 314876 : _validate_inner(SRE_CODE *code, SRE_CODE *end, Py_ssize_t groups)
1639 : : {
1640 : : /* Some variables are manipulated by the macros above */
1641 : : SRE_CODE op;
1642 : : SRE_CODE arg;
1643 : : SRE_CODE skip;
1644 : :
1645 : : VTRACE(("code=%p, end=%p\n", code, end));
1646 : :
1647 [ - + ]: 314876 : if (code > end)
1648 : 0 : FAIL;
1649 : :
1650 [ + + ]: 1359861 : while (code < end) {
1651 [ - + ]: 1044985 : GET_OP;
1652 [ + + - + : 1044985 : switch (op) {
+ + + + +
+ + + + +
- ]
1653 : :
1654 : 147232 : case SRE_OP_MARK:
1655 : : /* We don't check whether marks are properly nested; the
1656 : : sre_match() code is robust even if they don't, and the worst
1657 : : you can get is nonsensical match results. */
1658 [ - + ]: 147232 : GET_ARG;
1659 [ - + ]: 147232 : if (arg > 2 * (size_t)groups + 1) {
1660 : : VTRACE(("arg=%d, groups=%d\n", (int)arg, (int)groups));
1661 : 0 : FAIL;
1662 : : }
1663 : 147232 : break;
1664 : :
1665 : 475895 : case SRE_OP_LITERAL:
1666 : : case SRE_OP_NOT_LITERAL:
1667 : : case SRE_OP_LITERAL_IGNORE:
1668 : : case SRE_OP_NOT_LITERAL_IGNORE:
1669 : : case SRE_OP_LITERAL_UNI_IGNORE:
1670 : : case SRE_OP_NOT_LITERAL_UNI_IGNORE:
1671 : : case SRE_OP_LITERAL_LOC_IGNORE:
1672 : : case SRE_OP_NOT_LITERAL_LOC_IGNORE:
1673 [ - + ]: 475895 : GET_ARG;
1674 : : /* The arg is just a character, nothing to check */
1675 : 475895 : break;
1676 : :
1677 : 0 : case SRE_OP_SUCCESS:
1678 : : case SRE_OP_FAILURE:
1679 : : /* Nothing to check; these normally end the matching process */
1680 : 0 : break;
1681 : :
1682 : 30365 : case SRE_OP_AT:
1683 [ - + + - ]: 30365 : GET_ARG;
1684 : : switch (arg) {
1685 : 30365 : case SRE_AT_BEGINNING:
1686 : : case SRE_AT_BEGINNING_STRING:
1687 : : case SRE_AT_BEGINNING_LINE:
1688 : : case SRE_AT_END:
1689 : : case SRE_AT_END_LINE:
1690 : : case SRE_AT_END_STRING:
1691 : : case SRE_AT_BOUNDARY:
1692 : : case SRE_AT_NON_BOUNDARY:
1693 : : case SRE_AT_LOC_BOUNDARY:
1694 : : case SRE_AT_LOC_NON_BOUNDARY:
1695 : : case SRE_AT_UNI_BOUNDARY:
1696 : : case SRE_AT_UNI_NON_BOUNDARY:
1697 : 30365 : break;
1698 : 0 : default:
1699 : 0 : FAIL;
1700 : : }
1701 : 30365 : break;
1702 : :
1703 : 12682 : case SRE_OP_ANY:
1704 : : case SRE_OP_ANY_ALL:
1705 : : /* These have no operands */
1706 : 12682 : break;
1707 : :
1708 : 142464 : case SRE_OP_IN:
1709 : : case SRE_OP_IN_IGNORE:
1710 : : case SRE_OP_IN_UNI_IGNORE:
1711 : : case SRE_OP_IN_LOC_IGNORE:
1712 [ - + - + ]: 142464 : GET_SKIP;
1713 : : /* Stop 1 before the end; we check the FAILURE below */
1714 [ - + ]: 142464 : if (!_validate_charset(code, code+skip-2))
1715 : 0 : FAIL;
1716 [ - + ]: 142464 : if (code[skip-2] != SRE_OP_FAILURE)
1717 : 0 : FAIL;
1718 : 142464 : code += skip-1;
1719 : 142464 : break;
1720 : :
1721 : 53860 : case SRE_OP_INFO:
1722 : : {
1723 : : /* A minimal info field is
1724 : : <INFO> <1=skip> <2=flags> <3=min> <4=max>;
1725 : : If SRE_INFO_PREFIX or SRE_INFO_CHARSET is in the flags,
1726 : : more follows. */
1727 : : SRE_CODE flags, i;
1728 : : SRE_CODE *newcode;
1729 [ - + - + ]: 53860 : GET_SKIP;
1730 : 53860 : newcode = code+skip-1;
1731 [ - + ]: 53860 : GET_ARG; flags = arg;
1732 [ - + ]: 53860 : GET_ARG;
1733 [ - + ]: 53860 : GET_ARG;
1734 : : /* Check that only valid flags are present */
1735 [ - + ]: 53860 : if ((flags & ~(SRE_INFO_PREFIX |
1736 : : SRE_INFO_LITERAL |
1737 : : SRE_INFO_CHARSET)) != 0)
1738 : 0 : FAIL;
1739 : : /* PREFIX and CHARSET are mutually exclusive */
1740 [ + + ]: 53860 : if ((flags & SRE_INFO_PREFIX) &&
1741 [ - + ]: 13262 : (flags & SRE_INFO_CHARSET))
1742 : 0 : FAIL;
1743 : : /* LITERAL implies PREFIX */
1744 [ + + ]: 53860 : if ((flags & SRE_INFO_LITERAL) &&
1745 [ - + ]: 4900 : !(flags & SRE_INFO_PREFIX))
1746 : 0 : FAIL;
1747 : : /* Validate the prefix */
1748 [ + + ]: 53860 : if (flags & SRE_INFO_PREFIX) {
1749 : : SRE_CODE prefix_len;
1750 [ - + ]: 13262 : GET_ARG; prefix_len = arg;
1751 [ - + ]: 13262 : GET_ARG;
1752 : : /* Here comes the prefix string */
1753 [ - + ]: 13262 : if (prefix_len > (uintptr_t)(newcode - code))
1754 : 0 : FAIL;
1755 : 13262 : code += prefix_len;
1756 : : /* And here comes the overlap table */
1757 [ - + ]: 13262 : if (prefix_len > (uintptr_t)(newcode - code))
1758 : 0 : FAIL;
1759 : : /* Each overlap value should be < prefix_len */
1760 [ + + ]: 103865 : for (i = 0; i < prefix_len; i++) {
1761 [ - + ]: 90603 : if (code[i] >= prefix_len)
1762 : 0 : FAIL;
1763 : : }
1764 : 13262 : code += prefix_len;
1765 : : }
1766 : : /* Validate the charset */
1767 [ + + ]: 53860 : if (flags & SRE_INFO_CHARSET) {
1768 [ - + ]: 6044 : if (!_validate_charset(code, newcode-1))
1769 : 0 : FAIL;
1770 [ - + ]: 6044 : if (newcode[-1] != SRE_OP_FAILURE)
1771 : 0 : FAIL;
1772 : 6044 : code = newcode;
1773 : : }
1774 [ - + ]: 47816 : else if (code != newcode) {
1775 : : VTRACE(("code=%p, newcode=%p\n", code, newcode));
1776 : 0 : FAIL;
1777 : : }
1778 : : }
1779 : 53860 : break;
1780 : :
1781 : 24388 : case SRE_OP_BRANCH:
1782 : : {
1783 : 24388 : SRE_CODE *target = NULL;
1784 : : for (;;) {
1785 [ - + - + ]: 128452 : GET_SKIP;
1786 [ + + ]: 128452 : if (skip == 0)
1787 : 24388 : break;
1788 : : /* Stop 2 before the end; we check the JUMP below */
1789 [ - + ]: 104064 : if (!_validate_inner(code, code+skip-3, groups))
1790 : 0 : FAIL;
1791 : 104064 : code += skip-3;
1792 : : /* Check that it ends with a JUMP, and that each JUMP
1793 : : has the same target */
1794 [ - + ]: 104064 : GET_OP;
1795 [ - + ]: 104064 : if (op != SRE_OP_JUMP)
1796 : 0 : FAIL;
1797 [ - + - + ]: 104064 : GET_SKIP;
1798 [ + + ]: 104064 : if (target == NULL)
1799 : 24388 : target = code+skip-1;
1800 [ - + ]: 79676 : else if (code+skip-1 != target)
1801 : 0 : FAIL;
1802 : : }
1803 : : }
1804 : 24388 : break;
1805 : :
1806 : 124896 : case SRE_OP_REPEAT_ONE:
1807 : : case SRE_OP_MIN_REPEAT_ONE:
1808 : : case SRE_OP_POSSESSIVE_REPEAT_ONE:
1809 : : {
1810 : : SRE_CODE min, max;
1811 [ - + - + ]: 124896 : GET_SKIP;
1812 [ - + ]: 124896 : GET_ARG; min = arg;
1813 [ - + ]: 124896 : GET_ARG; max = arg;
1814 [ - + ]: 124896 : if (min > max)
1815 : 0 : FAIL;
1816 : : if (max > SRE_MAXREPEAT)
1817 : : FAIL;
1818 [ - + ]: 124896 : if (!_validate_inner(code, code+skip-4, groups))
1819 : 0 : FAIL;
1820 : 124896 : code += skip-4;
1821 [ - + ]: 124896 : GET_OP;
1822 [ - + ]: 124896 : if (op != SRE_OP_SUCCESS)
1823 : 0 : FAIL;
1824 : : }
1825 : 124896 : break;
1826 : :
1827 : 19816 : case SRE_OP_REPEAT:
1828 : : case SRE_OP_POSSESSIVE_REPEAT:
1829 : : {
1830 : 19816 : SRE_CODE op1 = op, min, max;
1831 [ - + - + ]: 19816 : GET_SKIP;
1832 [ - + ]: 19816 : GET_ARG; min = arg;
1833 [ - + ]: 19816 : GET_ARG; max = arg;
1834 [ - + ]: 19816 : if (min > max)
1835 : 0 : FAIL;
1836 : : if (max > SRE_MAXREPEAT)
1837 : : FAIL;
1838 [ - + ]: 19816 : if (!_validate_inner(code, code+skip-3, groups))
1839 : 0 : FAIL;
1840 : 19816 : code += skip-3;
1841 [ - + ]: 19816 : GET_OP;
1842 [ + + ]: 19816 : if (op1 == SRE_OP_POSSESSIVE_REPEAT) {
1843 [ - + ]: 21 : if (op != SRE_OP_SUCCESS)
1844 : 0 : FAIL;
1845 : : }
1846 : : else {
1847 [ + + - + ]: 19795 : if (op != SRE_OP_MAX_UNTIL && op != SRE_OP_MIN_UNTIL)
1848 : 0 : FAIL;
1849 : : }
1850 : : }
1851 : 19816 : break;
1852 : :
1853 : 61 : case SRE_OP_ATOMIC_GROUP:
1854 : : {
1855 [ - + - + ]: 61 : GET_SKIP;
1856 [ - + ]: 61 : if (!_validate_inner(code, code+skip-2, groups))
1857 : 0 : FAIL;
1858 : 61 : code += skip-2;
1859 [ - + ]: 61 : GET_OP;
1860 [ - + ]: 61 : if (op != SRE_OP_SUCCESS)
1861 : 0 : FAIL;
1862 : : }
1863 : 61 : break;
1864 : :
1865 : 1167 : case SRE_OP_GROUPREF:
1866 : : case SRE_OP_GROUPREF_IGNORE:
1867 : : case SRE_OP_GROUPREF_UNI_IGNORE:
1868 : : case SRE_OP_GROUPREF_LOC_IGNORE:
1869 [ - + ]: 1167 : GET_ARG;
1870 [ - + ]: 1167 : if (arg >= (size_t)groups)
1871 : 0 : FAIL;
1872 : 1167 : break;
1873 : :
1874 : 29 : case SRE_OP_GROUPREF_EXISTS:
1875 : : /* The regex syntax for this is: '(?(group)then|else)', where
1876 : : 'group' is either an integer group number or a group name,
1877 : : 'then' and 'else' are sub-regexes, and 'else' is optional. */
1878 [ - + ]: 29 : GET_ARG;
1879 [ - + ]: 29 : if (arg >= (size_t)groups)
1880 : 0 : FAIL;
1881 [ - + - + ]: 29 : GET_SKIP_ADJ(1);
1882 : 29 : code--; /* The skip is relative to the first arg! */
1883 : : /* There are two possibilities here: if there is both a 'then'
1884 : : part and an 'else' part, the generated code looks like:
1885 : :
1886 : : GROUPREF_EXISTS
1887 : : <group>
1888 : : <skipyes>
1889 : : ...then part...
1890 : : JUMP
1891 : : <skipno>
1892 : : (<skipyes> jumps here)
1893 : : ...else part...
1894 : : (<skipno> jumps here)
1895 : :
1896 : : If there is only a 'then' part, it looks like:
1897 : :
1898 : : GROUPREF_EXISTS
1899 : : <group>
1900 : : <skip>
1901 : : ...then part...
1902 : : (<skip> jumps here)
1903 : :
1904 : : There is no direct way to decide which it is, and we don't want
1905 : : to allow arbitrary jumps anywhere in the code; so we just look
1906 : : for a JUMP opcode preceding our skip target.
1907 : : */
1908 [ + + + - ]: 29 : if (skip >= 3 && skip-3 < (uintptr_t)(end - code) &&
1909 [ + + ]: 28 : code[skip-3] == SRE_OP_JUMP)
1910 : : {
1911 : : VTRACE(("both then and else parts present\n"));
1912 [ - + ]: 20 : if (!_validate_inner(code+1, code+skip-3, groups))
1913 : 0 : FAIL;
1914 : 20 : code += skip-2; /* Position after JUMP, at <skipno> */
1915 [ - + - + ]: 20 : GET_SKIP;
1916 [ - + ]: 20 : if (!_validate_inner(code, code+skip-1, groups))
1917 : 0 : FAIL;
1918 : 20 : code += skip-1;
1919 : : }
1920 : : else {
1921 : : VTRACE(("only a then part present\n"));
1922 [ - + ]: 9 : if (!_validate_inner(code+1, code+skip-1, groups))
1923 : 0 : FAIL;
1924 : 9 : code += skip-1;
1925 : : }
1926 : 29 : break;
1927 : :
1928 : 12130 : case SRE_OP_ASSERT:
1929 : : case SRE_OP_ASSERT_NOT:
1930 [ - + - + ]: 12130 : GET_SKIP;
1931 [ - + ]: 12130 : GET_ARG; /* 0 for lookahead, width for lookbehind */
1932 : 12130 : code--; /* Back up over arg to simplify math below */
1933 [ - + ]: 12130 : if (arg & 0x80000000)
1934 : 0 : FAIL; /* Width too large */
1935 : : /* Stop 1 before the end; we check the SUCCESS below */
1936 [ - + ]: 12130 : if (!_validate_inner(code+1, code+skip-2, groups))
1937 : 0 : FAIL;
1938 : 12130 : code += skip-2;
1939 [ - + ]: 12130 : GET_OP;
1940 [ - + ]: 12130 : if (op != SRE_OP_SUCCESS)
1941 : 0 : FAIL;
1942 : 12130 : break;
1943 : :
1944 : 0 : default:
1945 : 0 : FAIL;
1946 : :
1947 : : }
1948 : : }
1949 : :
1950 : : VTRACE(("okay\n"));
1951 : 314876 : return 1;
1952 : : }
1953 : :
1954 : : static int
1955 : 53860 : _validate_outer(SRE_CODE *code, SRE_CODE *end, Py_ssize_t groups)
1956 : : {
1957 [ + - + - : 53860 : if (groups < 0 || (size_t)groups > SRE_MAXGROUPS ||
+ - ]
1958 [ - + ]: 53860 : code >= end || end[-1] != SRE_OP_SUCCESS)
1959 : 0 : FAIL;
1960 : 53860 : return _validate_inner(code, end-1, groups);
1961 : : }
1962 : :
1963 : : static int
1964 : 53860 : _validate(PatternObject *self)
1965 : : {
1966 [ - + ]: 53860 : if (!_validate_outer(self->code, self->code+self->codesize, self->groups))
1967 : : {
1968 : 0 : PyErr_SetString(PyExc_RuntimeError, "invalid SRE code");
1969 : 0 : return 0;
1970 : : }
1971 : : else
1972 : : VTRACE(("Success!\n"));
1973 : 53860 : return 1;
1974 : : }
1975 : :
1976 : : /* -------------------------------------------------------------------- */
1977 : : /* match methods */
1978 : :
1979 : : static int
1980 : 43590 : match_traverse(MatchObject *self, visitproc visit, void *arg)
1981 : : {
1982 [ + - - + ]: 43590 : Py_VISIT(Py_TYPE(self));
1983 [ + - - + ]: 43590 : Py_VISIT(self->string);
1984 [ - + - - ]: 43590 : Py_VISIT(self->regs);
1985 [ + - - + ]: 43590 : Py_VISIT(self->pattern);
1986 : 43590 : return 0;
1987 : : }
1988 : :
1989 : : static int
1990 : 7962343 : match_clear(MatchObject *self)
1991 : : {
1992 [ + + ]: 7962343 : Py_CLEAR(self->string);
1993 [ + + ]: 7962343 : Py_CLEAR(self->regs);
1994 [ + + ]: 7962343 : Py_CLEAR(self->pattern);
1995 : 7962343 : return 0;
1996 : : }
1997 : :
1998 : : static void
1999 : 7962294 : match_dealloc(MatchObject* self)
2000 : : {
2001 : 7962294 : PyTypeObject *tp = Py_TYPE(self);
2002 : :
2003 : 7962294 : PyObject_GC_UnTrack(self);
2004 : 7962294 : (void)match_clear(self);
2005 : 7962294 : tp->tp_free(self);
2006 : 7962294 : Py_DECREF(tp);
2007 : 7962294 : }
2008 : :
2009 : : static PyObject*
2010 : 1074532 : match_getslice_by_index(MatchObject* self, Py_ssize_t index, PyObject* def)
2011 : : {
2012 : : Py_ssize_t length;
2013 : : int isbytes, charsize;
2014 : : Py_buffer view;
2015 : : PyObject *result;
2016 : : const void* ptr;
2017 : : Py_ssize_t i, j;
2018 : :
2019 : : assert(0 <= index && index < self->groups);
2020 : 1074532 : index *= 2;
2021 : :
2022 [ + - + + ]: 1074532 : if (self->string == Py_None || self->mark[index] < 0) {
2023 : : /* return default value if the string or group is undefined */
2024 : 336536 : Py_INCREF(def);
2025 : 336536 : return def;
2026 : : }
2027 : :
2028 : 737996 : ptr = getstring(self->string, &length, &isbytes, &charsize, &view);
2029 [ - + ]: 737996 : if (ptr == NULL)
2030 : 0 : return NULL;
2031 : :
2032 : 737996 : i = self->mark[index];
2033 : 737996 : j = self->mark[index+1];
2034 : 737996 : i = Py_MIN(i, length);
2035 : 737996 : j = Py_MIN(j, length);
2036 : 737996 : result = getslice(isbytes, ptr, self->string, i, j);
2037 [ + + + - ]: 737996 : if (isbytes && view.buf != NULL)
2038 : 38203 : PyBuffer_Release(&view);
2039 : 737996 : return result;
2040 : : }
2041 : :
2042 : : static Py_ssize_t
2043 : 8448625 : match_getindex(MatchObject* self, PyObject* index)
2044 : : {
2045 : : Py_ssize_t i;
2046 : :
2047 [ + + ]: 8448625 : if (index == NULL)
2048 : : /* Default value */
2049 : 432129 : return 0;
2050 : :
2051 [ + + ]: 8016496 : if (PyIndex_Check(index)) {
2052 : 7275811 : i = PyNumber_AsSsize_t(index, NULL);
2053 : : }
2054 : : else {
2055 : 740685 : i = -1;
2056 : :
2057 [ + + ]: 740685 : if (self->pattern->groupindex) {
2058 : 740684 : index = PyDict_GetItemWithError(self->pattern->groupindex, index);
2059 [ + + + - ]: 740684 : if (index && PyLong_Check(index)) {
2060 : 740679 : i = PyLong_AsSsize_t(index);
2061 : : }
2062 : : }
2063 : : }
2064 [ + + + + ]: 8016496 : if (i < 0 || i >= self->groups) {
2065 : : /* raise IndexError if we were given a bad group number */
2066 [ + - ]: 28402 : if (!PyErr_Occurred()) {
2067 : 28402 : PyErr_SetString(PyExc_IndexError, "no such group");
2068 : : }
2069 : 28402 : return -1;
2070 : : }
2071 : :
2072 : 7988094 : return i;
2073 : : }
2074 : :
2075 : : static PyObject*
2076 : 813388 : match_getslice(MatchObject* self, PyObject* index, PyObject* def)
2077 : : {
2078 : 813388 : Py_ssize_t i = match_getindex(self, index);
2079 : :
2080 [ + + ]: 813388 : if (i < 0) {
2081 : 28402 : return NULL;
2082 : : }
2083 : :
2084 : 784986 : return match_getslice_by_index(self, i, def);
2085 : : }
2086 : :
2087 : : /*[clinic input]
2088 : : _sre.SRE_Match.expand
2089 : :
2090 : : template: object
2091 : :
2092 : : Return the string obtained by doing backslash substitution on the string template, as done by the sub() method.
2093 : : [clinic start generated code]*/
2094 : :
2095 : : static PyObject *
2096 : 2 : _sre_SRE_Match_expand_impl(MatchObject *self, PyObject *template)
2097 : : /*[clinic end generated code: output=931b58ccc323c3a1 input=4bfdb22c2f8b146a]*/
2098 : : {
2099 : : /* delegate to Python code */
2100 : 2 : return call(
2101 : : SRE_PY_MODULE, "_expand",
2102 : : PyTuple_Pack(3, self->pattern, self, template)
2103 : : );
2104 : : }
2105 : :
2106 : : static PyObject*
2107 : 763001 : match_group(MatchObject* self, PyObject* args)
2108 : : {
2109 : : PyObject* result;
2110 : : Py_ssize_t i, size;
2111 : :
2112 : 763001 : size = PyTuple_GET_SIZE(args);
2113 : :
2114 [ + + + ]: 763001 : switch (size) {
2115 : 20890 : case 0:
2116 : 20890 : result = match_getslice(self, _PyLong_GetZero(), Py_None);
2117 : 20890 : break;
2118 : 723579 : case 1:
2119 : 723579 : result = match_getslice(self, PyTuple_GET_ITEM(args, 0), Py_None);
2120 : 723579 : break;
2121 : 18532 : default:
2122 : : /* fetch multiple items */
2123 : 18532 : result = PyTuple_New(size);
2124 [ - + ]: 18532 : if (!result)
2125 : 0 : return NULL;
2126 [ + + ]: 73247 : for (i = 0; i < size; i++) {
2127 : 54715 : PyObject* item = match_getslice(
2128 : : self, PyTuple_GET_ITEM(args, i), Py_None
2129 : : );
2130 [ - + ]: 54715 : if (!item) {
2131 : 0 : Py_DECREF(result);
2132 : 0 : return NULL;
2133 : : }
2134 : 54715 : PyTuple_SET_ITEM(result, i, item);
2135 : : }
2136 : 18532 : break;
2137 : : }
2138 : 763001 : return result;
2139 : : }
2140 : :
2141 : : static PyObject*
2142 : 27 : match_getitem(MatchObject* self, PyObject* name)
2143 : : {
2144 : 27 : return match_getslice(self, name, Py_None);
2145 : : }
2146 : :
2147 : : /*[clinic input]
2148 : : _sre.SRE_Match.groups
2149 : :
2150 : : default: object = None
2151 : : Is used for groups that did not participate in the match.
2152 : :
2153 : : Return a tuple containing all the subgroups of the match, from 1.
2154 : : [clinic start generated code]*/
2155 : :
2156 : : static PyObject *
2157 : 136914 : _sre_SRE_Match_groups_impl(MatchObject *self, PyObject *default_value)
2158 : : /*[clinic end generated code: output=daf8e2641537238a input=bb069ef55dabca91]*/
2159 : : {
2160 : : PyObject* result;
2161 : : Py_ssize_t index;
2162 : :
2163 : 136914 : result = PyTuple_New(self->groups-1);
2164 [ - + ]: 136914 : if (!result)
2165 : 0 : return NULL;
2166 : :
2167 [ + + ]: 426452 : for (index = 1; index < self->groups; index++) {
2168 : : PyObject* item;
2169 : 289538 : item = match_getslice_by_index(self, index, default_value);
2170 [ - + ]: 289538 : if (!item) {
2171 : 0 : Py_DECREF(result);
2172 : 0 : return NULL;
2173 : : }
2174 : 289538 : PyTuple_SET_ITEM(result, index-1, item);
2175 : : }
2176 : :
2177 : 136914 : return result;
2178 : : }
2179 : :
2180 : : /*[clinic input]
2181 : : _sre.SRE_Match.groupdict
2182 : :
2183 : : default: object = None
2184 : : Is used for groups that did not participate in the match.
2185 : :
2186 : : Return a dictionary containing all the named subgroups of the match, keyed by the subgroup name.
2187 : : [clinic start generated code]*/
2188 : :
2189 : : static PyObject *
2190 : 4365 : _sre_SRE_Match_groupdict_impl(MatchObject *self, PyObject *default_value)
2191 : : /*[clinic end generated code: output=29917c9073e41757 input=0ded7960b23780aa]*/
2192 : : {
2193 : : PyObject *result;
2194 : : PyObject *key;
2195 : : PyObject *value;
2196 : 4365 : Py_ssize_t pos = 0;
2197 : : Py_hash_t hash;
2198 : :
2199 : 4365 : result = PyDict_New();
2200 [ + - + + ]: 4365 : if (!result || !self->pattern->groupindex)
2201 : 146 : return result;
2202 : :
2203 [ + + ]: 18396 : while (_PyDict_Next(self->pattern->groupindex, &pos, &key, &value, &hash)) {
2204 : : int status;
2205 : 14177 : Py_INCREF(key);
2206 : 14177 : value = match_getslice(self, key, default_value);
2207 [ - + ]: 14177 : if (!value) {
2208 : 0 : Py_DECREF(key);
2209 : 0 : goto failed;
2210 : : }
2211 : 14177 : status = _PyDict_SetItem_KnownHash(result, key, value, hash);
2212 : 14177 : Py_DECREF(value);
2213 : 14177 : Py_DECREF(key);
2214 [ - + ]: 14177 : if (status < 0)
2215 : 0 : goto failed;
2216 : : }
2217 : :
2218 : 4219 : return result;
2219 : :
2220 : 0 : failed:
2221 : 0 : Py_DECREF(result);
2222 : 0 : return NULL;
2223 : : }
2224 : :
2225 : : /*[clinic input]
2226 : : _sre.SRE_Match.start -> Py_ssize_t
2227 : :
2228 : : group: object(c_default="NULL") = 0
2229 : : /
2230 : :
2231 : : Return index of the start of the substring matched by group.
2232 : : [clinic start generated code]*/
2233 : :
2234 : : static Py_ssize_t
2235 : 78337 : _sre_SRE_Match_start_impl(MatchObject *self, PyObject *group)
2236 : : /*[clinic end generated code: output=3f6e7f9df2fb5201 input=ced8e4ed4b33ee6c]*/
2237 : : {
2238 : 78337 : Py_ssize_t index = match_getindex(self, group);
2239 : :
2240 [ - + ]: 78337 : if (index < 0) {
2241 : 0 : return -1;
2242 : : }
2243 : :
2244 : : /* mark is -1 if group is undefined */
2245 : 78337 : return self->mark[index*2];
2246 : : }
2247 : :
2248 : : /*[clinic input]
2249 : : _sre.SRE_Match.end -> Py_ssize_t
2250 : :
2251 : : group: object(c_default="NULL") = 0
2252 : : /
2253 : :
2254 : : Return index of the end of the substring matched by group.
2255 : : [clinic start generated code]*/
2256 : :
2257 : : static Py_ssize_t
2258 : 393180 : _sre_SRE_Match_end_impl(MatchObject *self, PyObject *group)
2259 : : /*[clinic end generated code: output=f4240b09911f7692 input=1b799560c7f3d7e6]*/
2260 : : {
2261 : 393180 : Py_ssize_t index = match_getindex(self, group);
2262 : :
2263 [ - + ]: 393180 : if (index < 0) {
2264 : 0 : return -1;
2265 : : }
2266 : :
2267 : : /* mark is -1 if group is undefined */
2268 : 393180 : return self->mark[index*2+1];
2269 : : }
2270 : :
2271 : : LOCAL(PyObject*)
2272 : 7163722 : _pair(Py_ssize_t i1, Py_ssize_t i2)
2273 : : {
2274 : : PyObject* pair;
2275 : : PyObject* item;
2276 : :
2277 : 7163722 : pair = PyTuple_New(2);
2278 [ - + ]: 7163722 : if (!pair)
2279 : 0 : return NULL;
2280 : :
2281 : 7163722 : item = PyLong_FromSsize_t(i1);
2282 [ - + ]: 7163722 : if (!item)
2283 : 0 : goto error;
2284 : 7163722 : PyTuple_SET_ITEM(pair, 0, item);
2285 : :
2286 : 7163722 : item = PyLong_FromSsize_t(i2);
2287 [ - + ]: 7163722 : if (!item)
2288 : 0 : goto error;
2289 : 7163722 : PyTuple_SET_ITEM(pair, 1, item);
2290 : :
2291 : 7163722 : return pair;
2292 : :
2293 : 0 : error:
2294 : 0 : Py_DECREF(pair);
2295 : 0 : return NULL;
2296 : : }
2297 : :
2298 : : /*[clinic input]
2299 : : _sre.SRE_Match.span
2300 : :
2301 : : group: object(c_default="NULL") = 0
2302 : : /
2303 : :
2304 : : For match object m, return the 2-tuple (m.start(group), m.end(group)).
2305 : : [clinic start generated code]*/
2306 : :
2307 : : static PyObject *
2308 : 7163720 : _sre_SRE_Match_span_impl(MatchObject *self, PyObject *group)
2309 : : /*[clinic end generated code: output=f02ae40594d14fe6 input=8fa6014e982d71d4]*/
2310 : : {
2311 : 7163720 : Py_ssize_t index = match_getindex(self, group);
2312 : :
2313 [ - + ]: 7163720 : if (index < 0) {
2314 : 0 : return NULL;
2315 : : }
2316 : :
2317 : : /* marks are -1 if group is undefined */
2318 : 7163720 : return _pair(self->mark[index*2], self->mark[index*2+1]);
2319 : : }
2320 : :
2321 : : static PyObject*
2322 : 1 : match_regs(MatchObject* self)
2323 : : {
2324 : : PyObject* regs;
2325 : : PyObject* item;
2326 : : Py_ssize_t index;
2327 : :
2328 : 1 : regs = PyTuple_New(self->groups);
2329 [ - + ]: 1 : if (!regs)
2330 : 0 : return NULL;
2331 : :
2332 [ + + ]: 3 : for (index = 0; index < self->groups; index++) {
2333 : 2 : item = _pair(self->mark[index*2], self->mark[index*2+1]);
2334 [ - + ]: 2 : if (!item) {
2335 : 0 : Py_DECREF(regs);
2336 : 0 : return NULL;
2337 : : }
2338 : 2 : PyTuple_SET_ITEM(regs, index, item);
2339 : : }
2340 : :
2341 : 1 : Py_INCREF(regs);
2342 : 1 : self->regs = regs;
2343 : :
2344 : 1 : return regs;
2345 : : }
2346 : :
2347 : : /*[clinic input]
2348 : : _sre.SRE_Match.__copy__
2349 : :
2350 : : [clinic start generated code]*/
2351 : :
2352 : : static PyObject *
2353 : 1 : _sre_SRE_Match___copy___impl(MatchObject *self)
2354 : : /*[clinic end generated code: output=a779c5fc8b5b4eb4 input=3bb4d30b6baddb5b]*/
2355 : : {
2356 : 1 : Py_INCREF(self);
2357 : 1 : return (PyObject *)self;
2358 : : }
2359 : :
2360 : : /*[clinic input]
2361 : : _sre.SRE_Match.__deepcopy__
2362 : :
2363 : : memo: object
2364 : : /
2365 : :
2366 : : [clinic start generated code]*/
2367 : :
2368 : : static PyObject *
2369 : 1 : _sre_SRE_Match___deepcopy__(MatchObject *self, PyObject *memo)
2370 : : /*[clinic end generated code: output=ba7cb46d655e4ee2 input=779d12a31c2c325e]*/
2371 : : {
2372 : 1 : Py_INCREF(self);
2373 : 1 : return (PyObject *)self;
2374 : : }
2375 : :
2376 : : PyDoc_STRVAR(match_doc,
2377 : : "The result of re.match() and re.search().\n\
2378 : : Match objects always have a boolean value of True.");
2379 : :
2380 : : PyDoc_STRVAR(match_group_doc,
2381 : : "group([group1, ...]) -> str or tuple.\n\
2382 : : Return subgroup(s) of the match by indices or names.\n\
2383 : : For 0 returns the entire match.");
2384 : :
2385 : : static PyObject *
2386 : 18 : match_lastindex_get(MatchObject *self, void *Py_UNUSED(ignored))
2387 : : {
2388 [ + + ]: 18 : if (self->lastindex >= 0)
2389 : 17 : return PyLong_FromSsize_t(self->lastindex);
2390 : 1 : Py_RETURN_NONE;
2391 : : }
2392 : :
2393 : : static PyObject *
2394 : 1083 : match_lastgroup_get(MatchObject *self, void *Py_UNUSED(ignored))
2395 : : {
2396 [ + - ]: 1083 : if (self->pattern->indexgroup &&
2397 [ + - + - ]: 2166 : self->lastindex >= 0 &&
2398 : 1083 : self->lastindex < PyTuple_GET_SIZE(self->pattern->indexgroup))
2399 : : {
2400 : 1083 : PyObject *result = PyTuple_GET_ITEM(self->pattern->indexgroup,
2401 : : self->lastindex);
2402 : 1083 : Py_INCREF(result);
2403 : 1083 : return result;
2404 : : }
2405 : 0 : Py_RETURN_NONE;
2406 : : }
2407 : :
2408 : : static PyObject *
2409 : 1 : match_regs_get(MatchObject *self, void *Py_UNUSED(ignored))
2410 : : {
2411 [ - + ]: 1 : if (self->regs) {
2412 : 0 : Py_INCREF(self->regs);
2413 : 0 : return self->regs;
2414 : : } else
2415 : 1 : return match_regs(self);
2416 : : }
2417 : :
2418 : : static PyObject *
2419 : 8 : match_repr(MatchObject *self)
2420 : : {
2421 : : PyObject *result;
2422 : 8 : PyObject *group0 = match_getslice_by_index(self, 0, Py_None);
2423 [ - + ]: 8 : if (group0 == NULL)
2424 : 0 : return NULL;
2425 : 8 : result = PyUnicode_FromFormat(
2426 : : "<%s object; span=(%zd, %zd), match=%.50R>",
2427 : 8 : Py_TYPE(self)->tp_name,
2428 : : self->mark[0], self->mark[1], group0);
2429 : 8 : Py_DECREF(group0);
2430 : 8 : return result;
2431 : : }
2432 : :
2433 : :
2434 : : static PyObject*
2435 : 11091150 : pattern_new_match(_sremodulestate* module_state,
2436 : : PatternObject* pattern,
2437 : : SRE_STATE* state,
2438 : : Py_ssize_t status)
2439 : : {
2440 : : /* create match object (from state object) */
2441 : :
2442 : : MatchObject* match;
2443 : : Py_ssize_t i, j;
2444 : : char* base;
2445 : : int n;
2446 : :
2447 [ + + ]: 11091150 : if (status > 0) {
2448 : :
2449 : : /* create match object (with room for extra group marks) */
2450 : : /* coverity[ampersand_in_size] */
2451 : 7962294 : match = PyObject_GC_NewVar(MatchObject,
2452 : : module_state->Match_Type,
2453 : : 2*(pattern->groups+1));
2454 [ - + ]: 7962294 : if (!match)
2455 : 0 : return NULL;
2456 : :
2457 : 7962294 : Py_INCREF(pattern);
2458 : 7962294 : match->pattern = pattern;
2459 : :
2460 : 7962294 : Py_INCREF(state->string);
2461 : 7962294 : match->string = state->string;
2462 : :
2463 : 7962294 : match->regs = NULL;
2464 : 7962294 : match->groups = pattern->groups+1;
2465 : :
2466 : : /* fill in group slices */
2467 : :
2468 : 7962294 : base = (char*) state->beginning;
2469 : 7962294 : n = state->charsize;
2470 : :
2471 : 7962294 : match->mark[0] = ((char*) state->start - base) / n;
2472 : 7962294 : match->mark[1] = ((char*) state->ptr - base) / n;
2473 : :
2474 [ + + ]: 159489545 : for (i = j = 0; i < pattern->groups; i++, j+=2)
2475 [ + + + + : 151527251 : if (j+1 <= state->lastmark && state->mark[j] && state->mark[j+1]) {
+ - ]
2476 : 17061706 : match->mark[j+2] = ((char*) state->mark[j] - base) / n;
2477 : 17061706 : match->mark[j+3] = ((char*) state->mark[j+1] - base) / n;
2478 : :
2479 : : /* check wrong span */
2480 [ - + ]: 17061706 : if (match->mark[j+2] > match->mark[j+3]) {
2481 : 0 : PyErr_SetString(PyExc_SystemError,
2482 : : "The span of capturing group is wrong,"
2483 : : " please report a bug for the re module.");
2484 : 0 : Py_DECREF(match);
2485 : 0 : return NULL;
2486 : : }
2487 : : } else
2488 : 134465545 : match->mark[j+2] = match->mark[j+3] = -1; /* undefined */
2489 : :
2490 : 7962294 : match->pos = state->pos;
2491 : 7962294 : match->endpos = state->endpos;
2492 : :
2493 : 7962294 : match->lastindex = state->lastindex;
2494 : :
2495 : 7962294 : PyObject_GC_Track(match);
2496 : 7962294 : return (PyObject*) match;
2497 : :
2498 [ + - ]: 3128856 : } else if (status == 0) {
2499 : :
2500 : : /* no match */
2501 : 3128856 : Py_RETURN_NONE;
2502 : :
2503 : : }
2504 : :
2505 : : /* internal error */
2506 : 0 : pattern_error(status);
2507 : 0 : return NULL;
2508 : : }
2509 : :
2510 : :
2511 : : /* -------------------------------------------------------------------- */
2512 : : /* scanner methods (experimental) */
2513 : :
2514 : : static int
2515 : 76 : scanner_traverse(ScannerObject *self, visitproc visit, void *arg)
2516 : : {
2517 [ + - - + ]: 76 : Py_VISIT(Py_TYPE(self));
2518 [ + - - + ]: 76 : Py_VISIT(self->pattern);
2519 : 76 : return 0;
2520 : : }
2521 : :
2522 : : static int
2523 : 2660781 : scanner_clear(ScannerObject *self)
2524 : : {
2525 [ + + ]: 2660781 : Py_CLEAR(self->pattern);
2526 : 2660781 : return 0;
2527 : : }
2528 : :
2529 : : static void
2530 : 2660781 : scanner_dealloc(ScannerObject* self)
2531 : : {
2532 : 2660781 : PyTypeObject *tp = Py_TYPE(self);
2533 : :
2534 : 2660781 : PyObject_GC_UnTrack(self);
2535 : 2660781 : state_fini(&self->state);
2536 : 2660781 : (void)scanner_clear(self);
2537 : 2660781 : tp->tp_free(self);
2538 : 2660781 : Py_DECREF(tp);
2539 : 2660781 : }
2540 : :
2541 : : static int
2542 : 2677706 : scanner_begin(ScannerObject* self)
2543 : : {
2544 [ - + ]: 2677706 : if (self->executing) {
2545 : 0 : PyErr_SetString(PyExc_ValueError,
2546 : : "regular expression scanner already executing");
2547 : 0 : return 0;
2548 : : }
2549 : 2677706 : self->executing = 1;
2550 : 2677706 : return 1;
2551 : : }
2552 : :
2553 : : static void
2554 : 2677706 : scanner_end(ScannerObject* self)
2555 : : {
2556 : : assert(self->executing);
2557 : 2677706 : self->executing = 0;
2558 : 2677706 : }
2559 : :
2560 : : /*[clinic input]
2561 : : _sre.SRE_Scanner.match
2562 : :
2563 : : cls: defining_class
2564 : : /
2565 : :
2566 : : [clinic start generated code]*/
2567 : :
2568 : : static PyObject *
2569 : 16 : _sre_SRE_Scanner_match_impl(ScannerObject *self, PyTypeObject *cls)
2570 : : /*[clinic end generated code: output=6e22c149dc0f0325 input=b5146e1f30278cb7]*/
2571 : : {
2572 : 16 : _sremodulestate *module_state = get_sre_module_state_by_class(cls);
2573 : 16 : SRE_STATE* state = &self->state;
2574 : : PyObject* match;
2575 : : Py_ssize_t status;
2576 : :
2577 [ - + ]: 16 : if (!scanner_begin(self)) {
2578 : 0 : return NULL;
2579 : : }
2580 [ - + ]: 16 : if (state->start == NULL) {
2581 : 0 : scanner_end(self);
2582 : 0 : Py_RETURN_NONE;
2583 : : }
2584 : :
2585 : 16 : state_reset(state);
2586 : :
2587 : 16 : state->ptr = state->start;
2588 : :
2589 : 16 : status = sre_match(state, PatternObject_GetCode(self->pattern));
2590 [ - + ]: 16 : if (PyErr_Occurred()) {
2591 : 0 : scanner_end(self);
2592 : 0 : return NULL;
2593 : : }
2594 : :
2595 : 16 : match = pattern_new_match(module_state, (PatternObject*) self->pattern,
2596 : : state, status);
2597 : :
2598 [ + + ]: 16 : if (status == 0)
2599 : 1 : state->start = NULL;
2600 : : else {
2601 : 15 : state->must_advance = (state->ptr == state->start);
2602 : 15 : state->start = state->ptr;
2603 : : }
2604 : :
2605 : 16 : scanner_end(self);
2606 : 16 : return match;
2607 : : }
2608 : :
2609 : :
2610 : : /*[clinic input]
2611 : : _sre.SRE_Scanner.search
2612 : :
2613 : : cls: defining_class
2614 : : /
2615 : :
2616 : : [clinic start generated code]*/
2617 : :
2618 : : static PyObject *
2619 : 2677690 : _sre_SRE_Scanner_search_impl(ScannerObject *self, PyTypeObject *cls)
2620 : : /*[clinic end generated code: output=23e8fc78013f9161 input=056c2d37171d0bf2]*/
2621 : : {
2622 : 2677690 : _sremodulestate *module_state = get_sre_module_state_by_class(cls);
2623 : 2677690 : SRE_STATE* state = &self->state;
2624 : : PyObject* match;
2625 : : Py_ssize_t status;
2626 : :
2627 [ - + ]: 2677690 : if (!scanner_begin(self)) {
2628 : 0 : return NULL;
2629 : : }
2630 [ - + ]: 2677690 : if (state->start == NULL) {
2631 : 0 : scanner_end(self);
2632 : 0 : Py_RETURN_NONE;
2633 : : }
2634 : :
2635 : 2677690 : state_reset(state);
2636 : :
2637 : 2677690 : state->ptr = state->start;
2638 : :
2639 : 2677690 : status = sre_search(state, PatternObject_GetCode(self->pattern));
2640 [ - + ]: 2677690 : if (PyErr_Occurred()) {
2641 : 0 : scanner_end(self);
2642 : 0 : return NULL;
2643 : : }
2644 : :
2645 : 2677690 : match = pattern_new_match(module_state, (PatternObject*) self->pattern,
2646 : : state, status);
2647 : :
2648 [ + + ]: 2677690 : if (status == 0)
2649 : 2660686 : state->start = NULL;
2650 : : else {
2651 : 17004 : state->must_advance = (state->ptr == state->start);
2652 : 17004 : state->start = state->ptr;
2653 : : }
2654 : :
2655 : 2677690 : scanner_end(self);
2656 : 2677690 : return match;
2657 : : }
2658 : :
2659 : : static PyObject *
2660 : 2660781 : pattern_scanner(_sremodulestate *module_state,
2661 : : PatternObject *self,
2662 : : PyObject *string,
2663 : : Py_ssize_t pos,
2664 : : Py_ssize_t endpos)
2665 : : {
2666 : : ScannerObject* scanner;
2667 : :
2668 : : /* create scanner object */
2669 : 2660781 : scanner = PyObject_GC_New(ScannerObject, module_state->Scanner_Type);
2670 [ - + ]: 2660781 : if (!scanner)
2671 : 0 : return NULL;
2672 : 2660781 : scanner->pattern = NULL;
2673 : 2660781 : scanner->executing = 0;
2674 : :
2675 : : /* create search state object */
2676 [ + + ]: 2660781 : if (!state_init(&scanner->state, self, string, pos, endpos)) {
2677 : 1 : Py_DECREF(scanner);
2678 : 1 : return NULL;
2679 : : }
2680 : :
2681 : 2660780 : Py_INCREF(self);
2682 : 2660780 : scanner->pattern = (PyObject*) self;
2683 : :
2684 : 2660780 : PyObject_GC_Track(scanner);
2685 : 2660780 : return (PyObject*) scanner;
2686 : : }
2687 : :
2688 : : static Py_hash_t
2689 : 10831 : pattern_hash(PatternObject *self)
2690 : : {
2691 : : Py_hash_t hash, hash2;
2692 : :
2693 : 10831 : hash = PyObject_Hash(self->pattern);
2694 [ - + ]: 10831 : if (hash == -1) {
2695 : 0 : return -1;
2696 : : }
2697 : :
2698 : 10831 : hash2 = _Py_HashBytes(self->code, sizeof(self->code[0]) * self->codesize);
2699 : 10831 : hash ^= hash2;
2700 : :
2701 : 10831 : hash ^= self->flags;
2702 : 10831 : hash ^= self->isbytes;
2703 : 10831 : hash ^= self->codesize;
2704 : :
2705 [ - + ]: 10831 : if (hash == -1) {
2706 : 0 : hash = -2;
2707 : : }
2708 : 10831 : return hash;
2709 : : }
2710 : :
2711 : : static PyObject*
2712 : 847 : pattern_richcompare(PyObject *lefto, PyObject *righto, int op)
2713 : : {
2714 : 847 : PyTypeObject *tp = Py_TYPE(lefto);
2715 : 847 : _sremodulestate *module_state = get_sre_module_state_by_class(tp);
2716 : : PatternObject *left, *right;
2717 : : int cmp;
2718 : :
2719 [ + + + + ]: 847 : if (op != Py_EQ && op != Py_NE) {
2720 : 2 : Py_RETURN_NOTIMPLEMENTED;
2721 : : }
2722 : :
2723 [ + + ]: 845 : if (!Py_IS_TYPE(righto, module_state->Pattern_Type))
2724 : : {
2725 : 790 : Py_RETURN_NOTIMPLEMENTED;
2726 : : }
2727 : :
2728 [ + + ]: 55 : if (lefto == righto) {
2729 : : /* a pattern is equal to itself */
2730 : 9 : return PyBool_FromLong(op == Py_EQ);
2731 : : }
2732 : :
2733 : 46 : left = (PatternObject *)lefto;
2734 : 46 : right = (PatternObject *)righto;
2735 : :
2736 : 92 : cmp = (left->flags == right->flags
2737 [ + - ]: 44 : && left->isbytes == right->isbytes
2738 [ + + + + ]: 90 : && left->codesize == right->codesize);
2739 [ + + ]: 46 : if (cmp) {
2740 : : /* Compare the code and the pattern because the same pattern can
2741 : : produce different codes depending on the locale used to compile the
2742 : : pattern when the re.LOCALE flag is used. Don't compare groups,
2743 : : indexgroup nor groupindex: they are derivated from the pattern. */
2744 : 8 : cmp = (memcmp(left->code, right->code,
2745 : 8 : sizeof(left->code[0]) * left->codesize) == 0);
2746 : : }
2747 [ + + ]: 46 : if (cmp) {
2748 : 3 : cmp = PyObject_RichCompareBool(left->pattern, right->pattern,
2749 : : Py_EQ);
2750 [ - + ]: 3 : if (cmp < 0) {
2751 : 0 : return NULL;
2752 : : }
2753 : : }
2754 [ + + ]: 46 : if (op == Py_NE) {
2755 : 3 : cmp = !cmp;
2756 : : }
2757 : 46 : return PyBool_FromLong(cmp);
2758 : : }
2759 : :
2760 : : #include "clinic/sre.c.h"
2761 : :
2762 : : static PyMethodDef pattern_methods[] = {
2763 : : _SRE_SRE_PATTERN_MATCH_METHODDEF
2764 : : _SRE_SRE_PATTERN_FULLMATCH_METHODDEF
2765 : : _SRE_SRE_PATTERN_SEARCH_METHODDEF
2766 : : _SRE_SRE_PATTERN_SUB_METHODDEF
2767 : : _SRE_SRE_PATTERN_SUBN_METHODDEF
2768 : : _SRE_SRE_PATTERN_FINDALL_METHODDEF
2769 : : _SRE_SRE_PATTERN_SPLIT_METHODDEF
2770 : : _SRE_SRE_PATTERN_FINDITER_METHODDEF
2771 : : _SRE_SRE_PATTERN_SCANNER_METHODDEF
2772 : : _SRE_SRE_PATTERN___COPY___METHODDEF
2773 : : _SRE_SRE_PATTERN___DEEPCOPY___METHODDEF
2774 : : {"__class_getitem__", Py_GenericAlias, METH_O|METH_CLASS,
2775 : : PyDoc_STR("See PEP 585")},
2776 : : {NULL, NULL}
2777 : : };
2778 : :
2779 : : static PyGetSetDef pattern_getset[] = {
2780 : : {"groupindex", (getter)pattern_groupindex, (setter)NULL,
2781 : : "A dictionary mapping group names to group numbers."},
2782 : : {NULL} /* Sentinel */
2783 : : };
2784 : :
2785 : : #define PAT_OFF(x) offsetof(PatternObject, x)
2786 : : static PyMemberDef pattern_members[] = {
2787 : : {"pattern", T_OBJECT, PAT_OFF(pattern), READONLY,
2788 : : "The pattern string from which the RE object was compiled."},
2789 : : {"flags", T_INT, PAT_OFF(flags), READONLY,
2790 : : "The regex matching flags."},
2791 : : {"groups", T_PYSSIZET, PAT_OFF(groups), READONLY,
2792 : : "The number of capturing groups in the pattern."},
2793 : : {"__weaklistoffset__", T_PYSSIZET, offsetof(PatternObject, weakreflist), READONLY},
2794 : : {NULL} /* Sentinel */
2795 : : };
2796 : :
2797 : : static PyType_Slot pattern_slots[] = {
2798 : : {Py_tp_dealloc, (destructor)pattern_dealloc},
2799 : : {Py_tp_repr, (reprfunc)pattern_repr},
2800 : : {Py_tp_hash, (hashfunc)pattern_hash},
2801 : : {Py_tp_doc, (void *)pattern_doc},
2802 : : {Py_tp_richcompare, pattern_richcompare},
2803 : : {Py_tp_methods, pattern_methods},
2804 : : {Py_tp_members, pattern_members},
2805 : : {Py_tp_getset, pattern_getset},
2806 : : {Py_tp_traverse, pattern_traverse},
2807 : : {Py_tp_clear, pattern_clear},
2808 : : {0, NULL},
2809 : : };
2810 : :
2811 : : static PyType_Spec pattern_spec = {
2812 : : .name = "re.Pattern",
2813 : : .basicsize = sizeof(PatternObject),
2814 : : .itemsize = sizeof(SRE_CODE),
2815 : : .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE |
2816 : : Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_HAVE_GC),
2817 : : .slots = pattern_slots,
2818 : : };
2819 : :
2820 : : static PyMethodDef match_methods[] = {
2821 : : {"group", (PyCFunction) match_group, METH_VARARGS, match_group_doc},
2822 : : _SRE_SRE_MATCH_START_METHODDEF
2823 : : _SRE_SRE_MATCH_END_METHODDEF
2824 : : _SRE_SRE_MATCH_SPAN_METHODDEF
2825 : : _SRE_SRE_MATCH_GROUPS_METHODDEF
2826 : : _SRE_SRE_MATCH_GROUPDICT_METHODDEF
2827 : : _SRE_SRE_MATCH_EXPAND_METHODDEF
2828 : : _SRE_SRE_MATCH___COPY___METHODDEF
2829 : : _SRE_SRE_MATCH___DEEPCOPY___METHODDEF
2830 : : {"__class_getitem__", Py_GenericAlias, METH_O|METH_CLASS,
2831 : : PyDoc_STR("See PEP 585")},
2832 : : {NULL, NULL}
2833 : : };
2834 : :
2835 : : static PyGetSetDef match_getset[] = {
2836 : : {"lastindex", (getter)match_lastindex_get, (setter)NULL,
2837 : : "The integer index of the last matched capturing group."},
2838 : : {"lastgroup", (getter)match_lastgroup_get, (setter)NULL,
2839 : : "The name of the last matched capturing group."},
2840 : : {"regs", (getter)match_regs_get, (setter)NULL},
2841 : : {NULL}
2842 : : };
2843 : :
2844 : : #define MATCH_OFF(x) offsetof(MatchObject, x)
2845 : : static PyMemberDef match_members[] = {
2846 : : {"string", T_OBJECT, MATCH_OFF(string), READONLY,
2847 : : "The string passed to match() or search()."},
2848 : : {"re", T_OBJECT, MATCH_OFF(pattern), READONLY,
2849 : : "The regular expression object."},
2850 : : {"pos", T_PYSSIZET, MATCH_OFF(pos), READONLY,
2851 : : "The index into the string at which the RE engine started looking for a match."},
2852 : : {"endpos", T_PYSSIZET, MATCH_OFF(endpos), READONLY,
2853 : : "The index into the string beyond which the RE engine will not go."},
2854 : : {NULL}
2855 : : };
2856 : :
2857 : : /* FIXME: implement setattr("string", None) as a special case (to
2858 : : detach the associated string, if any */
2859 : : static PyType_Slot match_slots[] = {
2860 : : {Py_tp_dealloc, match_dealloc},
2861 : : {Py_tp_repr, match_repr},
2862 : : {Py_tp_doc, (void *)match_doc},
2863 : : {Py_tp_methods, match_methods},
2864 : : {Py_tp_members, match_members},
2865 : : {Py_tp_getset, match_getset},
2866 : : {Py_tp_traverse, match_traverse},
2867 : : {Py_tp_clear, match_clear},
2868 : :
2869 : : /* As mapping.
2870 : : *
2871 : : * Match objects do not support length or assignment, but do support
2872 : : * __getitem__.
2873 : : */
2874 : : {Py_mp_subscript, match_getitem},
2875 : :
2876 : : {0, NULL},
2877 : : };
2878 : :
2879 : : static PyType_Spec match_spec = {
2880 : : .name = "re.Match",
2881 : : .basicsize = sizeof(MatchObject),
2882 : : .itemsize = sizeof(Py_ssize_t),
2883 : : .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE |
2884 : : Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_HAVE_GC),
2885 : : .slots = match_slots,
2886 : : };
2887 : :
2888 : : static PyMethodDef scanner_methods[] = {
2889 : : _SRE_SRE_SCANNER_MATCH_METHODDEF
2890 : : _SRE_SRE_SCANNER_SEARCH_METHODDEF
2891 : : {NULL, NULL}
2892 : : };
2893 : :
2894 : : #define SCAN_OFF(x) offsetof(ScannerObject, x)
2895 : : static PyMemberDef scanner_members[] = {
2896 : : {"pattern", T_OBJECT, SCAN_OFF(pattern), READONLY},
2897 : : {NULL} /* Sentinel */
2898 : : };
2899 : :
2900 : : static PyType_Slot scanner_slots[] = {
2901 : : {Py_tp_dealloc, scanner_dealloc},
2902 : : {Py_tp_methods, scanner_methods},
2903 : : {Py_tp_members, scanner_members},
2904 : : {Py_tp_traverse, scanner_traverse},
2905 : : {Py_tp_clear, scanner_clear},
2906 : : {0, NULL},
2907 : : };
2908 : :
2909 : : static PyType_Spec scanner_spec = {
2910 : : .name = "_" SRE_MODULE ".SRE_Scanner",
2911 : : .basicsize = sizeof(ScannerObject),
2912 : : .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE |
2913 : : Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_HAVE_GC),
2914 : : .slots = scanner_slots,
2915 : : };
2916 : :
2917 : : static PyMethodDef _functions[] = {
2918 : : _SRE_COMPILE_METHODDEF
2919 : : _SRE_GETCODESIZE_METHODDEF
2920 : : _SRE_ASCII_ISCASED_METHODDEF
2921 : : _SRE_UNICODE_ISCASED_METHODDEF
2922 : : _SRE_ASCII_TOLOWER_METHODDEF
2923 : : _SRE_UNICODE_TOLOWER_METHODDEF
2924 : : {NULL, NULL}
2925 : : };
2926 : :
2927 : : static int
2928 : 46194 : sre_traverse(PyObject *module, visitproc visit, void *arg)
2929 : : {
2930 : 46194 : _sremodulestate *state = get_sre_module_state(module);
2931 : :
2932 [ + + - + ]: 46194 : Py_VISIT(state->Pattern_Type);
2933 [ + + - + ]: 46194 : Py_VISIT(state->Match_Type);
2934 [ + + - + ]: 46194 : Py_VISIT(state->Scanner_Type);
2935 : :
2936 : 46194 : return 0;
2937 : : }
2938 : :
2939 : : static int
2940 : 3692 : sre_clear(PyObject *module)
2941 : : {
2942 : 3692 : _sremodulestate *state = get_sre_module_state(module);
2943 : :
2944 [ + + ]: 3692 : Py_CLEAR(state->Pattern_Type);
2945 [ + + ]: 3692 : Py_CLEAR(state->Match_Type);
2946 [ + + ]: 3692 : Py_CLEAR(state->Scanner_Type);
2947 : :
2948 : 3692 : return 0;
2949 : : }
2950 : :
2951 : : static void
2952 : 1846 : sre_free(void *module)
2953 : : {
2954 : 1846 : sre_clear((PyObject *)module);
2955 : 1846 : }
2956 : :
2957 : : #define CREATE_TYPE(m, type, spec) \
2958 : : do { \
2959 : : type = (PyTypeObject *)PyType_FromModuleAndSpec(m, spec, NULL); \
2960 : : if (type == NULL) { \
2961 : : goto error; \
2962 : : } \
2963 : : } while (0)
2964 : :
2965 : : #define ADD_ULONG_CONSTANT(module, name, value) \
2966 : : do { \
2967 : : PyObject *o = PyLong_FromUnsignedLong(value); \
2968 : : if (!o) \
2969 : : goto error; \
2970 : : int res = PyModule_AddObjectRef(module, name, o); \
2971 : : Py_DECREF(o); \
2972 : : if (res < 0) { \
2973 : : goto error; \
2974 : : } \
2975 : : } while (0)
2976 : :
2977 : : static int
2978 : 1853 : sre_exec(PyObject *m)
2979 : : {
2980 : : _sremodulestate *state;
2981 : :
2982 : : /* Create heap types */
2983 : 1853 : state = get_sre_module_state(m);
2984 [ - + ]: 1853 : CREATE_TYPE(m, state->Pattern_Type, &pattern_spec);
2985 [ - + ]: 1853 : CREATE_TYPE(m, state->Match_Type, &match_spec);
2986 [ - + ]: 1853 : CREATE_TYPE(m, state->Scanner_Type, &scanner_spec);
2987 : :
2988 [ - + ]: 1853 : if (PyModule_AddIntConstant(m, "MAGIC", SRE_MAGIC) < 0) {
2989 : 0 : goto error;
2990 : : }
2991 : :
2992 [ - + ]: 1853 : if (PyModule_AddIntConstant(m, "CODESIZE", sizeof(SRE_CODE)) < 0) {
2993 : 0 : goto error;
2994 : : }
2995 : :
2996 [ - + - + ]: 1853 : ADD_ULONG_CONSTANT(m, "MAXREPEAT", SRE_MAXREPEAT);
2997 [ - + - + ]: 1853 : ADD_ULONG_CONSTANT(m, "MAXGROUPS", SRE_MAXGROUPS);
2998 : :
2999 [ - + ]: 1853 : if (PyModule_AddStringConstant(m, "copyright", copyright) < 0) {
3000 : 0 : goto error;
3001 : : }
3002 : :
3003 : 1853 : return 0;
3004 : :
3005 : 0 : error:
3006 : 0 : return -1;
3007 : : }
3008 : :
3009 : : static PyModuleDef_Slot sre_slots[] = {
3010 : : {Py_mod_exec, sre_exec},
3011 : : {0, NULL},
3012 : : };
3013 : :
3014 : : static struct PyModuleDef sremodule = {
3015 : : .m_base = PyModuleDef_HEAD_INIT,
3016 : : .m_name = "_" SRE_MODULE,
3017 : : .m_size = sizeof(_sremodulestate),
3018 : : .m_methods = _functions,
3019 : : .m_slots = sre_slots,
3020 : : .m_traverse = sre_traverse,
3021 : : .m_free = sre_free,
3022 : : .m_clear = sre_clear,
3023 : : };
3024 : :
3025 : : PyMODINIT_FUNC
3026 : 1853 : PyInit__sre(void)
3027 : : {
3028 : 1853 : return PyModuleDef_Init(&sremodule);
3029 : : }
3030 : :
3031 : : /* vim:ts=4:sw=4:et
3032 : : */
|
