1 : /* Copyright (c) 2007 James Antill -- See LICENSE file for terms. */
2 :
3 : #ifndef USTR_SPN_H
4 : #error " You should have already included ustr-spn.h, or just include ustr.h."
5 : #endif
6 :
7 : #ifndef USTR_SRCH_H
8 : #error " You should have already included ustr-srch.h, or just include ustr.h."
9 : #endif
10 :
11 : USTR_CONF_I_PROTO
12 : size_t ustr_spn_chr_fwd(const struct Ustr *s1, size_t off, char chr)
13 52 : {
14 52 : const char *ptr = 0;
15 52 : size_t len = 0;
16 52 : size_t clen = 0;
17 :
18 29 : USTR_ASSERT(ustr_assert_valid(s1));
19 :
20 39 : ptr = ustr_cstr(s1);
21 39 : len = ustr_len(s1);
22 :
23 52 : USTR_ASSERT_RET(off <= len, 0);
24 52 : ptr += off;
25 52 : len -= off;
26 :
27 52 : clen = len;
28 320158 : while (len)
29 : {
30 320092 : if (*ptr != chr)
31 38 : break;
32 :
33 320054 : ++ptr;
34 320054 : --len;
35 : }
36 :
37 52 : return (clen - len);
38 : }
39 :
40 : USTR_CONF_I_PROTO
41 : size_t ustr_spn_chr_rev(const struct Ustr *s1, size_t off, char chr)
42 52 : {
43 52 : const char *ptr = 0;
44 52 : size_t len = 0;
45 52 : size_t clen = 0;
46 :
47 26 : USTR_ASSERT(ustr_assert_valid(s1));
48 :
49 41 : ptr = ustr_cstr(s1);
50 41 : len = ustr_len(s1);
51 :
52 52 : USTR_ASSERT_RET(off <= len, 0);
53 52 : len -= off;
54 :
55 52 : clen = len;
56 52 : ptr += len;
57 378 : while (len)
58 : {
59 326 : --ptr;
60 :
61 326 : if (*ptr != chr)
62 52 : break;
63 :
64 274 : --len;
65 : }
66 :
67 52 : return (clen - len);
68 : }
69 :
70 : USTR_CONF_I_PROTO size_t ustr_spn_chrs_fwd(const struct Ustr *s1, size_t off,
71 : const char *chrs, size_t slen)
72 516 : {
73 516 : const char *ptr = 0;
74 516 : size_t len = 0;
75 516 : size_t clen = 0;
76 :
77 345 : USTR_ASSERT(chrs);
78 :
79 516 : if (slen == 1)
80 40 : return (ustr_spn_chr_fwd(s1, off, *chrs));
81 :
82 322 : USTR_ASSERT(ustr_assert_valid(s1));
83 :
84 319 : ptr = ustr_cstr(s1);
85 319 : len = ustr_len(s1);
86 :
87 476 : USTR_ASSERT_RET(off <= len, 0);
88 476 : ptr += off;
89 476 : len -= off;
90 :
91 476 : clen = len;
92 2778 : while (len)
93 : {
94 2198 : if (!memchr(chrs, *ptr, slen))
95 372 : break;
96 :
97 1826 : ++ptr;
98 1826 : --len;
99 : }
100 :
101 476 : return (clen - len);
102 : }
103 :
104 : USTR_CONF_I_PROTO size_t ustr_spn_chrs_rev(const struct Ustr *s1, size_t off,
105 : const char *chrs, size_t slen)
106 216 : {
107 216 : const char *ptr = 0;
108 216 : size_t len = 0;
109 216 : size_t clen = 0;
110 :
111 108 : USTR_ASSERT(chrs);
112 :
113 216 : if (slen == 1)
114 40 : return (ustr_spn_chr_rev(s1, off, *chrs));
115 :
116 88 : USTR_ASSERT(ustr_assert_valid(s1));
117 :
118 136 : ptr = ustr_cstr(s1);
119 176 : len = clen = ustr_len(s1);
120 :
121 176 : USTR_ASSERT_RET(off <= len, 0);
122 176 : len -= off;
123 :
124 176 : clen = len;
125 176 : ptr += len;
126 1664 : while (len)
127 : {
128 1472 : --ptr;
129 :
130 1472 : if (!memchr(chrs, *ptr, slen))
131 160 : break;
132 :
133 1312 : --len;
134 : }
135 :
136 176 : return (clen - len);
137 : }
138 :
139 : USTR_CONF_I_PROTO
140 : size_t ustr_cspn_chr_fwd(const struct Ustr *s1, size_t off, char chr)
141 132 : {
142 132 : size_t f_pos = ustr_srch_chr_fwd(s1, off, chr);
143 :
144 132 : if (!f_pos)
145 58 : return (ustr_len(s1) - off);
146 :
147 74 : return (f_pos - off - 1);
148 : }
149 :
150 : USTR_CONF_I_PROTO
151 : size_t ustr_cspn_chr_rev(const struct Ustr *s1, size_t off, char chr)
152 96 : {
153 96 : size_t f_pos = ustr_srch_chr_rev(s1, off, chr);
154 :
155 96 : if (!f_pos)
156 62 : return (ustr_len(s1) - off);
157 :
158 34 : return ((ustr_len(s1) - f_pos) - off);
159 : }
160 :
161 : USTR_CONF_I_PROTO size_t ustr_cspn_chrs_fwd(const struct Ustr *s1, size_t off,
162 : const char *chrs, size_t slen)
163 584 : {
164 584 : const char *ptr = 0;
165 584 : size_t len = 0;
166 584 : size_t clen = 0;
167 :
168 292 : USTR_ASSERT(chrs);
169 :
170 584 : if (slen == 1)
171 108 : return (ustr_cspn_chr_fwd(s1, off, *chrs));
172 :
173 238 : USTR_ASSERT(ustr_assert_valid(s1));
174 :
175 364 : ptr = ustr_cstr(s1);
176 364 : len = ustr_len(s1);
177 :
178 476 : USTR_ASSERT_RET(off <= len, 0);
179 476 : ptr += off;
180 476 : len -= off;
181 :
182 476 : clen = len;
183 2632 : while (len)
184 : {
185 2064 : if (memchr(chrs, *ptr, slen))
186 384 : break;
187 :
188 1680 : ++ptr;
189 1680 : --len;
190 : }
191 :
192 476 : return (clen - len);
193 : }
194 :
195 : USTR_CONF_I_PROTO size_t ustr_cspn_chrs_rev(const struct Ustr *s1, size_t off,
196 : const char *chrs, size_t slen)
197 188 : {
198 188 : const char *ptr = 0;
199 188 : size_t len = 0;
200 188 : size_t clen = 0;
201 :
202 94 : USTR_ASSERT(chrs);
203 :
204 188 : if (slen == 1)
205 84 : return (ustr_cspn_chr_rev(s1, off, *chrs));
206 :
207 52 : USTR_ASSERT(ustr_assert_valid(s1));
208 :
209 82 : ptr = ustr_cstr(s1);
210 82 : len = ustr_len(s1);
211 :
212 104 : USTR_ASSERT_RET(off <= len, 0);
213 104 : len -= off;
214 :
215 104 : clen = len;
216 104 : ptr += len;
217 1416 : while (len)
218 : {
219 1260 : --ptr;
220 :
221 1260 : if (memchr(chrs, *ptr, slen))
222 52 : break;
223 :
224 1208 : --len;
225 : }
226 :
227 104 : return (clen - len);
228 : }
229 :
230 : #ifdef USTR_UTF8_H
231 : USTR_CONF_I_PROTO size_t ustr_utf8_spn_chrs_fwd(const struct Ustr*s1,size_t off,
232 : const char *pchrs, size_t slen)
233 24 : {
234 24 : const unsigned char *chrs = (const unsigned char *)pchrs;
235 24 : const unsigned char *ptr = 0;
236 24 : size_t ret = 0;
237 :
238 12 : USTR_ASSERT(chrs);
239 12 : USTR_ASSERT(ustr_assert_valid(s1));
240 :
241 24 : ptr = (const unsigned char *)ustr_cstr(s1);
242 :
243 24 : if (off)
244 12 : off = ustr_utf8_chars2bytes(s1, 1, off, 0);
245 24 : ptr += off;
246 :
247 96 : while (*ptr)
248 : {
249 72 : const unsigned char *bptr = ptr;
250 :
251 72 : ptr = ustr__utf8_next(ptr);
252 72 : if (!ptr || !USTR__SYS_MEMMEM(chrs, slen, bptr, ptr - bptr))
253 : break;
254 :
255 48 : ++ret;
256 : }
257 :
258 24 : return (ret);
259 : }
260 :
261 : USTR_CONF_I_PROTO size_t ustr_utf8_spn_chrs_rev(const struct Ustr*s1,size_t off,
262 : const char *pchrs, size_t slen)
263 36 : {
264 36 : const unsigned char *chrs = (const unsigned char *)pchrs;
265 36 : const unsigned char *ptr = 0;
266 36 : size_t len = 0;
267 36 : size_t ret = 0;
268 :
269 18 : USTR_ASSERT(chrs);
270 18 : USTR_ASSERT(ustr_assert_valid(s1));
271 :
272 36 : ptr = (const unsigned char *)ustr_cstr(s1);
273 27 : len = ustr_len(s1);
274 :
275 36 : if (off)
276 : {
277 12 : size_t ulen = ustr_utf8_len(s1);
278 : size_t dummy;
279 12 : off = ustr_utf8_chars2bytes(s1, ulen - off, off, &dummy);
280 : }
281 36 : len -= off;
282 :
283 120 : while (len)
284 : {
285 84 : const unsigned char *eptr = ptr + len;
286 84 : const unsigned char *bptr = ustr__utf8_prev(eptr, len);
287 :
288 84 : if (!bptr || !USTR__SYS_MEMMEM(chrs, slen, bptr, eptr - bptr))
289 : break;
290 :
291 48 : ++ret;
292 48 : len -= (eptr - bptr);
293 : }
294 :
295 36 : return (ret);
296 : }
297 :
298 : USTR_CONF_I_PROTO
299 : size_t ustr_utf8_cspn_chrs_fwd(const struct Ustr *s1, size_t off,
300 : const char *pchrs, size_t slen)
301 68 : {
302 68 : const unsigned char *chrs = (const unsigned char *)pchrs;
303 68 : const unsigned char *ptr = 0;
304 68 : size_t ret = 0;
305 :
306 34 : USTR_ASSERT(chrs);
307 34 : USTR_ASSERT(ustr_assert_valid(s1));
308 :
309 68 : ptr = (const unsigned char *)ustr_cstr(s1);
310 :
311 68 : if (off)
312 36 : off = ustr_utf8_chars2bytes(s1, 1, off, 0);
313 68 : ptr += off;
314 :
315 656 : while (*ptr)
316 : {
317 536 : const unsigned char *bptr = ptr;
318 :
319 536 : ptr = ustr__utf8_next(ptr);
320 536 : if (USTR__SYS_MEMMEM(chrs, slen, bptr, ptr - bptr))
321 16 : break;
322 :
323 520 : ++ret;
324 : }
325 :
326 68 : return (ret);
327 : }
328 :
329 : USTR_CONF_I_PROTO
330 : size_t ustr_utf8_cspn_chrs_rev(const struct Ustr *s1, size_t off,
331 : const char *pchrs, size_t slen)
332 68 : {
333 68 : const unsigned char *chrs = (const unsigned char *)pchrs;
334 68 : const unsigned char *ptr = 0;
335 68 : size_t len = 0;
336 68 : size_t ret = 0;
337 :
338 34 : USTR_ASSERT(chrs);
339 34 : USTR_ASSERT(ustr_assert_valid(s1));
340 :
341 68 : ptr = (const unsigned char *)ustr_cstr(s1);
342 51 : len = ustr_len(s1);
343 :
344 68 : if (off)
345 : {
346 36 : size_t ulen = ustr_utf8_len(s1);
347 : size_t dummy;
348 36 : off = ustr_utf8_chars2bytes(s1, ulen - off, off, &dummy);
349 : }
350 68 : len -= off;
351 :
352 660 : while (len)
353 : {
354 544 : const unsigned char *eptr = ptr + len;
355 544 : const unsigned char *bptr = ustr__utf8_prev(eptr, len);
356 :
357 544 : if (!bptr || USTR__SYS_MEMMEM(chrs, slen, bptr, eptr - bptr))
358 : break;
359 :
360 524 : ++ret;
361 524 : len -= (eptr - bptr);
362 : }
363 :
364 68 : return (ret);
365 : }
366 : #endif
|