← Back to branch summary

~ubuntu-branches/ubuntu/maverick/python3.1/maverick

« back to all changes in this revision

Viewing changes to Objects/stringlib/find.h

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-03-23 00:01:27 UTC
  • Revision ID: james.westby@ubuntu.com-20090323000127-5fstfxju4ufrhthq
Tags: upstream-3.1~a1+20090322
Import upstream version 3.1~a1+20090322

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
#ifdef STRINGLIB_WANT_CONTAINS_OBJ
 
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
*/