LCOV - code coverage report
Current view: | top level - Objects/stringlib - find.h (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 32 | 38 | 84.2 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 7 | 22 | 31.8 %
|  |  | Branches: | 12 | 18 | 66.7 %

               Branch data     Line data    Source code
           1                 :            : /* stringlib: find/index implementation */
           2                 :            :
           3                 :            : #ifndef STRINGLIB_FASTSEARCH_H
           4                 :            : #error must include "stringlib/fastsearch.h" before including this module
           5                 :            : #endif
           6                 :            :
           7                 :            : Py_LOCAL_INLINE(Py_ssize_t)
           8                 :       1016 : STRINGLIB(find)(const STRINGLIB_CHAR* str, Py_ssize_t str_len,
           9                 :            :                const STRINGLIB_CHAR* sub, Py_ssize_t sub_len,
          10                 :            :                Py_ssize_t offset)
          11                 :            : {
          12                 :            :     Py_ssize_t pos;
          13                 :            :
          14                 :            :     assert(str_len >= 0);
          15         [ -  + ]:       1016 :     if (sub_len == 0)
          16                 :          0 :         return offset;
          17                 :            :
          18                 :       1016 :     pos = FASTSEARCH(str, str_len, sub, sub_len, -1, FAST_SEARCH);
          19                 :            :
          20         [ +  + ]:       1016 :     if (pos >= 0)
          21                 :        398 :         pos += offset;
          22                 :            :
          23                 :       1016 :     return pos;
          24                 :            : }
          25                 :            :
          26                 :            : Py_LOCAL_INLINE(Py_ssize_t)
          27                 :         22 : STRINGLIB(rfind)(const STRINGLIB_CHAR* str, Py_ssize_t str_len,
          28                 :            :                 const STRINGLIB_CHAR* sub, Py_ssize_t sub_len,
          29                 :            :                 Py_ssize_t offset)
          30                 :            : {
          31                 :            :     Py_ssize_t pos;
          32                 :            :
          33                 :            :     assert(str_len >= 0);
          34         [ -  + ]:         22 :     if (sub_len == 0)
          35                 :          0 :         return str_len + offset;
          36                 :            :
          37                 :         22 :     pos = FASTSEARCH(str, str_len, sub, sub_len, -1, FAST_RSEARCH);
          38                 :            :
          39         [ -  + ]:         22 :     if (pos >= 0)
          40                 :          0 :         pos += offset;
          41                 :            :
          42                 :         22 :     return pos;
          43                 :            : }
          44                 :            :
          45                 :            : Py_LOCAL_INLINE(Py_ssize_t)
          46                 :        127 : STRINGLIB(find_slice)(const STRINGLIB_CHAR* str, Py_ssize_t str_len,
          47                 :            :                      const STRINGLIB_CHAR* sub, Py_ssize_t sub_len,
          48                 :            :                      Py_ssize_t start, Py_ssize_t end)
          49                 :            : {
          50                 :        127 :     return STRINGLIB(find)(str + start, end - start, sub, sub_len, start);
          51                 :            : }
          52                 :            :
          53                 :            : Py_LOCAL_INLINE(Py_ssize_t)
          54                 :         22 : STRINGLIB(rfind_slice)(const STRINGLIB_CHAR* str, Py_ssize_t str_len,
          55                 :            :                       const STRINGLIB_CHAR* sub, Py_ssize_t sub_len,
          56                 :            :                       Py_ssize_t start, Py_ssize_t end)
          57                 :            : {
          58                 :         22 :     return STRINGLIB(rfind)(str + start, end - start, sub, sub_len, start);
          59                 :            : }
          60                 :            :
          61                 :            : #ifdef STRINGLIB_WANT_CONTAINS_OBJ
          62                 :            :
          63                 :            : Py_LOCAL_INLINE(int)
          64                 :            : STRINGLIB(contains_obj)(PyObject* str, PyObject* sub)
          65                 :            : {
          66                 :            :     return STRINGLIB(find)(
          67                 :            :         STRINGLIB_STR(str), STRINGLIB_LEN(str),
          68                 :            :         STRINGLIB_STR(sub), STRINGLIB_LEN(sub), 0
          69                 :            :         ) != -1;
          70                 :            : }
          71                 :            :
          72                 :            : #endif /* STRINGLIB_WANT_CONTAINS_OBJ */
          73                 :            :
          74                 :            : /*
          75                 :            : This function is a helper for the "find" family (find, rfind, index,
          76                 :            : rindex) and for count, startswith and endswith, because they all have
          77                 :            : the same behaviour for the arguments.
          78                 :            :
          79                 :            : It does not touch the variables received until it knows everything
          80                 :            : is ok.
          81                 :            : */
          82                 :            :
          83                 :            : #define FORMAT_BUFFER_SIZE 50
          84                 :            :
          85                 :            : Py_LOCAL_INLINE(int)
          86                 :      23511 : STRINGLIB(parse_args_finds)(const char * function_name, PyObject *args,
          87                 :            :                            PyObject **subobj,
          88                 :            :                            Py_ssize_t *start, Py_ssize_t *end)
          89                 :            : {
          90                 :            :     PyObject *tmp_subobj;
          91                 :      23511 :     Py_ssize_t tmp_start = 0;
          92                 :      23511 :     Py_ssize_t tmp_end = PY_SSIZE_T_MAX;
          93                 :      23511 :     PyObject *obj_start=Py_None, *obj_end=Py_None;
          94                 :      23511 :     char format[FORMAT_BUFFER_SIZE] = "O|OO:";
          95                 :      23511 :     size_t len = strlen(format);
          96                 :            :
          97                 :      23511 :     strncpy(format + len, function_name, FORMAT_BUFFER_SIZE - len - 1);
          98                 :      23511 :     format[FORMAT_BUFFER_SIZE - 1] = '\0';
          99                 :            :
         100         [ -  + ]:      23511 :     if (!PyArg_ParseTuple(args, format, &tmp_subobj, &obj_start, &obj_end))
         101                 :          0 :         return 0;
         102                 :            :
         103                 :            :     /* To support None in "start" and "end" arguments, meaning
         104                 :            :        the same as if they were not passed.
         105                 :            :     */
         106         [ +  + ]:      23511 :     if (obj_start != Py_None)
         107         [ -  + ]:        834 :         if (!_PyEval_SliceIndex(obj_start, &tmp_start))
         108                 :          0 :             return 0;
         109         [ +  + ]:      23511 :     if (obj_end != Py_None)
         110         [ -  + ]:        113 :         if (!_PyEval_SliceIndex(obj_end, &tmp_end))
         111                 :          0 :             return 0;
         112                 :            :
         113                 :      23511 :     *start = tmp_start;
         114                 :      23511 :     *end = tmp_end;
         115                 :      23511 :     *subobj = tmp_subobj;
         116                 :      23511 :     return 1;
         117                 :            : }
         118                 :            :
         119                 :            : #undef FORMAT_BUFFER_SIZE

Generated by: LCOV version 1.14