LCOV - code coverage report
Current view: | top level - Modules/_sre - sre.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 543 | 1290 | 42.1 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 52 | 90 | 57.8 %
|  |  | Branches: | 292 | 916 | 31.9 %

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

Generated by: LCOV version 1.14