Objects/stringlib/find.h

   1 /* stringlib: find/index implementation */
   2
   3 #ifndef STRINGLIB_FIND_H
   4 #define STRINGLIB_FIND_H
   5
   6 #ifndef STRINGLIB_FASTSEARCH_H
   7 #error must include "stringlib/fastsearch.h" before including this module
   8 #endif
   9
  10 Py_LOCAL_INLINE(Py_ssize_t)
  11 stringlib_find(const STRINGLIB_CHAR* str, Py_ssize_t str_len,
  12                const STRINGLIB_CHAR* sub, Py_ssize_t sub_len,
  13                Py_ssize_t offset)
  14 {
  15     Py_ssize_t pos;
  16
  17     if (str_len < 0)
  18         return -1;
  19     if (sub_len == 0)
  20         return offset;
  21
  22     pos = fastsearch(str, str_len, sub, sub_len, FAST_SEARCH);
  23
  24     if (pos >= 0)
  25         pos += offset;
  26
  27     return pos;
  28 }
  29
  30 Py_LOCAL_INLINE(Py_ssize_t)
  31 stringlib_rfind(const STRINGLIB_CHAR* str, Py_ssize_t str_len,
  32                 const STRINGLIB_CHAR* sub, Py_ssize_t sub_len,
  33                 Py_ssize_t offset)
  34 {
  35     /* XXX - create reversefastsearch helper! */
  36     if (sub_len == 0) {
  37         if (str_len < 0)
  38             return -1;
  39         return str_len + offset;
  40     } else {
  41         Py_ssize_t j, pos = -1;
  42         for (j = str_len - sub_len; j >= 0; --j)
  43             if (STRINGLIB_CMP(str+j, sub, sub_len) == 0) {
  44                 pos = j + offset;
  45                 break;
  46             }
  47         return pos;
  48     }
  49 }
  50
  51 Py_LOCAL_INLINE(Py_ssize_t)
  52 stringlib_find_slice(const STRINGLIB_CHAR* str, Py_ssize_t str_len,
  53                      const STRINGLIB_CHAR* sub, Py_ssize_t sub_len,
  54                      Py_ssize_t start, Py_ssize_t end)
  55 {
  56     if (start < 0)
  57         start += str_len;
  58     if (start < 0)
  59         start = 0;
  60     if (end > str_len)
  61         end = str_len;
  62     if (end < 0)
  63         end += str_len;
  64     if (end < 0)
  65         end = 0;
  66
  67     return stringlib_find(
  68         str + start, end - start,
  69         sub, sub_len, start
  70         );
  71 }
  72
  73 Py_LOCAL_INLINE(Py_ssize_t)
  74 stringlib_rfind_slice(const STRINGLIB_CHAR* str, Py_ssize_t str_len,
  75                       const STRINGLIB_CHAR* sub, Py_ssize_t sub_len,
  76                       Py_ssize_t start, Py_ssize_t end)
  77 {
  78     if (start < 0)
  79         start += str_len;
  80     if (start < 0)
  81         start = 0;
  82     if (end > str_len)
  83         end = str_len;
  84     if (end < 0)
  85         end += str_len;
  86     if (end < 0)
  87         end = 0;
  88
  89     return stringlib_rfind(str + start, end - start, sub, sub_len, start);
  90 }
  91
  92 #if defined(STRINGLIB_STR) && !defined(FROM_BYTEARRAY)
  93
  94 Py_LOCAL_INLINE(int)
  95 stringlib_contains_obj(PyObject* str, PyObject* sub)
  96 {
  97     return stringlib_find(
  98         STRINGLIB_STR(str), STRINGLIB_LEN(str),
  99         STRINGLIB_STR(sub), STRINGLIB_LEN(sub), 0
 100         ) != -1;
 101 }
 102
 103 #endif /* STRINGLIB_STR */
 104
 105 #ifdef FROM_UNICODE
 106
 107 /*
 108 This function is a helper for the "find" family (find, rfind, index,
 109 rindex) of unicodeobject.c file, because they all have the same
 110 behaviour for the arguments.
 111
 112 It does not touch the variables received until it knows everything
 113 is ok.
 114
 115 Note that we receive a pointer to the pointer of the substring object,
 116 so when we create that object in this function we don't DECREF it,
 117 because it continues living in the caller functions (those functions,
 118 after finishing using the substring, must DECREF it).
 119 */
 120
 121 Py_LOCAL_INLINE(int)
 122 _ParseTupleFinds (PyObject *args, PyObject **substring,
 123                   Py_ssize_t *start, Py_ssize_t *end) {
 124     PyObject *tmp_substring;
 125     Py_ssize_t tmp_start = 0;
 126     Py_ssize_t tmp_end = PY_SSIZE_T_MAX;
 127     PyObject *obj_start=Py_None, *obj_end=Py_None;
 128
 129     if (!PyArg_ParseTuple(args, "O|OO:find", &tmp_substring,
 130          &obj_start, &obj_end))
 131         return 0;
 132
 133     /* To support None in "start" and "end" arguments, meaning
 134        the same as if they were not passed.
 135     */
 136     if (obj_start != Py_None)
 137         if (!_PyEval_SliceIndex(obj_start, &tmp_start))
 138             return 0;
 139     if (obj_end != Py_None)
 140         if (!_PyEval_SliceIndex(obj_end, &tmp_end))
 141             return 0;
 142
 143     tmp_substring = PyUnicode_FromObject(tmp_substring);
 144     if (!tmp_substring)
 145         return 0;
 146
 147     *start = tmp_start;
 148     *end = tmp_end;
 149     *substring = tmp_substring;
 150     return 1;
 151 }
 152
 153 #endif /* FROM_UNICODE */
 154
 155 #endif /* STRINGLIB_FIND_H */
 156
 157 /*
 158 Local variables:
 159 c-basic-offset: 4
 160 indent-tabs-mode: nil
 161 End:
 162 */