1 : #ifndef VSTR__HEADER_H
2 : # error " You must _just_ #include <vstr.h>"
3 : #endif
4 : /*
5 : * Copyright (C) 2002, 2003, 2004 James Antill
6 : *
7 : * This library is free software; you can redistribute it and/or
8 : * modify it under the terms of the GNU Lesser General Public
9 : * License as published by the Free Software Foundation; either
10 : * version 2 of the License, or (at your option) any later version.
11 : *
12 : * This library is distributed in the hope that it will be useful,
13 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : * Lesser General Public License for more details.
16 : *
17 : * You should have received a copy of the GNU Lesser General Public
18 : * License along with this library; if not, write to the Free Software
19 : * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 : *
21 : * email: james@and.org
22 : */
23 : /* exported functions which are inlined */
24 : /* NOTE: this implementation can change when the ABI changes ... DO NOT use
25 : * undocumented knowledge from here */
26 :
27 : #ifndef VSTR__ASSERT
28 : # define VSTR__ASSERT(x) /* do nothing */
29 : #endif
30 :
31 : #ifndef VSTR__ASSERT_RET
32 : # define VSTR__ASSERT_RET(x, y) do { if (x) {} else return (y); } while (0)
33 : #endif
34 :
35 : #ifndef VSTR__ASSERT_RET_VOID
36 : # define VSTR__ASSERT_RET_VOID(x) do { if (x) {} else return; } while (0)
37 : #endif
38 :
39 : #ifndef VSTR__ASSERT_NO_SWITCH_DEF
40 : # define VSTR__ASSERT_NO_SWITCH_DEF() break; default: break
41 : #endif
42 :
43 : /* cast so it warns for ptrs */
44 : #undef VSTR__TRUE
45 : #define VSTR__TRUE ((int)1)
46 : #undef VSTR__FALSE
47 : #define VSTR__FALSE ((int)0)
48 :
49 : #ifdef VSTR_AUTOCONF_USE_WRAP_MEMCPY
50 : extern inline void *vstr_wrap_memcpy(void *passed_s1, const void *passed_s2,
51 : size_t n)
52 2704329 : {
53 2704329 : unsigned char *s1 = passed_s1;
54 2704329 : const unsigned char *s2 = passed_s2;
55 :
56 2704329 : if ((n > 7) || VSTR__AT_COMPILE_CONST_P(n))
57 381497 : memcpy(passed_s1, passed_s2, n);
58 2322832 : else switch (n)
59 : {
60 85280 : case 7: s1[6] = s2[6];
61 228377 : case 6: s1[5] = s2[5];
62 379719 : case 5: s1[4] = s2[4];
63 518067 : case 4: s1[3] = s2[3];
64 683013 : case 3: s1[2] = s2[2];
65 1166798 : case 2: s1[1] = s2[1];
66 2321428 : case 1: s1[0] = s2[0];
67 : case 0:
68 : break;
69 : }
70 :
71 2704329 : return (passed_s1);
72 : }
73 : #else
74 : # define vstr_wrap_memcpy(x, y, z) memcpy(x, y, z)
75 : #endif
76 :
77 : #ifdef VSTR_AUTOCONF_USE_WRAP_MEMCMP
78 : extern inline int vstr_wrap_memcmp(const void *passed_s1,
79 : const void *passed_s2, size_t n)
80 239870478 : {
81 239870478 : const unsigned char *s1 = passed_s1;
82 239870478 : const unsigned char *s2 = passed_s2;
83 239870478 : int ret = 0;
84 239870478 : int tmp = 0;
85 :
86 239870478 : if ((n > 7) || VSTR__AT_COMPILE_CONST_P(n))
87 150366297 : ret = memcmp(passed_s1, passed_s2, n);
88 89504181 : else switch (n)
89 : {
90 34180288 : case 7: tmp = s1[6] - s2[6]; if (tmp) ret = tmp;
91 59398824 : case 6: tmp = s1[5] - s2[5]; if (tmp) ret = tmp;
92 66495875 : case 5: tmp = s1[4] - s2[4]; if (tmp) ret = tmp;
93 75179887 : case 4: tmp = s1[3] - s2[3]; if (tmp) ret = tmp;
94 81019943 : case 3: tmp = s1[2] - s2[2]; if (tmp) ret = tmp;
95 87426540 : case 2: tmp = s1[1] - s2[1]; if (tmp) ret = tmp;
96 89504181 : case 1: tmp = s1[0] - s2[0]; if (tmp) ret = tmp;
97 : case 0:
98 : break;
99 : }
100 :
101 239870478 : return (ret);
102 : }
103 : #else
104 : # define vstr_wrap_memcmp(x, y, z) memcmp(x, y, z)
105 : #endif
106 :
107 : #ifdef VSTR_AUTOCONF_USE_WRAP_MEMCHR
108 : extern inline void *vstr_wrap_memchr(const void *passed_s1, int c, size_t n)
109 8268273 : {
110 8268273 : const unsigned char *s1 = passed_s1;
111 8268273 : const void *ret = 0;
112 8268273 : int tmp = 0;
113 :
114 8268273 : switch (n)
115 : {
116 41597 : case 7: tmp = s1[6] == c; if (tmp) ret = s1 + 6;
117 60603 : case 6: tmp = s1[5] == c; if (tmp) ret = s1 + 5;
118 65086 : case 5: tmp = s1[4] == c; if (tmp) ret = s1 + 4;
119 79122 : case 4: tmp = s1[3] == c; if (tmp) ret = s1 + 3;
120 452003 : case 3: tmp = s1[2] == c; if (tmp) ret = s1 + 2;
121 1306533 : case 2: tmp = s1[1] == c; if (tmp) ret = s1 + 1;
122 1375050 : case 1: tmp = s1[0] == c; if (tmp) ret = s1 + 0;
123 160657 : break;
124 6893223 : default: ret = memchr(s1, c, n);
125 8268273 : break;
126 : }
127 :
128 8268273 : return ((void *)ret);
129 : }
130 : #else
131 : # define vstr_wrap_memchr(x, y, z) memchr(x, y, z)
132 : #endif
133 :
134 : #ifdef VSTR_AUTOCONF_USE_WRAP_MEMSET
135 : extern inline void *vstr_wrap_memset(void *passed_s1, int c, size_t n)
136 528176 : {
137 528176 : unsigned char *s1 = passed_s1;
138 :
139 528176 : if ((n > 7) || VSTR__AT_COMPILE_CONST_P(n))
140 54014 : memset(passed_s1, c, n);
141 528176 : switch (n)
142 : {
143 3390 : case 7: s1[6] = c;
144 12192 : case 6: s1[5] = c;
145 16228 : case 5: s1[4] = c;
146 267033 : case 4: s1[3] = c;
147 292146 : case 3: s1[2] = c;
148 328868 : case 2: s1[1] = c;
149 474142 : case 1: s1[0] = c;
150 : case 0:
151 : break;
152 : }
153 :
154 528176 : return (passed_s1);
155 : }
156 : #else
157 : # define vstr_wrap_memset(x, y, z) memset(x, y, z)
158 : #endif
159 :
160 : #ifdef VSTR_AUTOCONF_USE_WRAP_MEMMOVE
161 : extern inline void *vstr_wrap_memmove(void *s1, const void *s2, size_t n)
162 14728 : {
163 14728 : if (n < 8)
164 : {
165 8087 : unsigned char tmp[8];
166 8087 : vstr_wrap_memcpy(tmp, s2, n);
167 8087 : vstr_wrap_memcpy(s1, tmp, n);
168 8087 : return (s1);
169 : }
170 :
171 6641 : return memmove(s1, s2, n);
172 : }
173 : #else
174 : # define vstr_wrap_memmove(x, y, z) memmove(x, y, z)
175 : #endif
176 :
177 : /* needed at the top so vstr_del() etc. can use it */
178 : extern inline void vstr_ref_del(struct Vstr_ref *tmp)
179 237718 : {
180 237718 : if (!tmp)
181 12693 : return; /* std. free semantics */
182 :
183 225025 : if (!--tmp->ref)
184 50757 : (*tmp->func)(tmp);
185 : }
186 :
187 : extern inline struct Vstr_ref *vstr_ref_add(struct Vstr_ref *tmp)
188 176372 : {
189 176372 : ++tmp->ref;
190 :
191 176372 : return (tmp);
192 : }
193 :
194 : extern inline void *vstr_cache_get(const struct Vstr_base *base,
195 : unsigned int pos)
196 19275068 : {
197 19275068 : if (!pos)
198 5 : return (NULL);
199 :
200 19275063 : if (!base->cache_available)
201 55697 : return (NULL);
202 :
203 8848077 : VSTR__ASSERT(VSTR__CACHE(base));
204 :
205 19219366 : --pos;
206 :
207 19219366 : if (pos >= VSTR__CACHE(base)->sz)
208 5105584 : return (NULL);
209 :
210 14113782 : return (VSTR__CACHE(base)->data[pos]);
211 : }
212 :
213 : extern inline void *vstr_data_get(struct Vstr_conf *conf,
214 : unsigned int pos)
215 263 : {
216 263 : struct Vstr_ref *data = NULL;
217 :
218 263 : if (!conf)
219 64 : return (vstr_extern_inline_data_get(pos));
220 :
221 199 : VSTR__ASSERT_RET(pos && (pos <= conf->data_usr_len), NULL);
222 :
223 195 : if (!(data = conf->data_usr_ents[pos - 1].data))
224 70 : return (NULL);
225 :
226 125 : return (data->ptr);
227 : }
228 :
229 : extern inline void vstr_data_set(struct Vstr_conf *conf,
230 : unsigned int pos, struct Vstr_ref *ref)
231 65 : {
232 65 : if (!conf)
233 : {
234 20 : vstr_extern_inline_data_set(pos, ref);
235 20 : return;
236 : }
237 :
238 45 : VSTR__ASSERT_RET_VOID(pos && (pos <= conf->data_usr_len));
239 :
240 45 : vstr_ref_del(conf->data_usr_ents[pos - 1].data);
241 45 : conf->data_usr_ents[pos - 1].data = ref ? vstr_ref_add(ref) : NULL;
242 : }
243 :
244 : extern inline
245 : int vstr_cache__pos(const struct Vstr_base *base,
246 : struct Vstr_node *node, size_t pos, unsigned int num)
247 1125337 : {
248 1125337 : struct Vstr__cache_data_pos *data = NULL;
249 :
250 1125337 : if (!base->cache_available)
251 4145 : return (VSTR__FALSE);
252 :
253 1121192 : data = vstr_cache_get(base, 1);
254 233371 : VSTR__ASSERT(data);
255 :
256 1121192 : data->node = node;
257 1121192 : data->pos = pos;
258 1121192 : data->num = num;
259 :
260 1121192 : return (VSTR__TRUE);
261 : }
262 :
263 : extern inline size_t vstr_sc_posdiff(size_t beg_pos, size_t end_pos)
264 219686 : {
265 219686 : return ((end_pos - beg_pos) + 1);
266 : }
267 :
268 : extern inline size_t vstr_sc_poslast(size_t beg_pos, size_t diff_pos)
269 238335235 : {
270 238335235 : return (beg_pos + (diff_pos - 1));
271 : }
272 :
273 : extern inline
274 : struct Vstr_node *vstr_base__pos(const struct Vstr_base *base,
275 : size_t *pos, unsigned int *num, int cache)
276 240572606 : {
277 240572606 : size_t orig_pos = *pos;
278 240572606 : struct Vstr_node *scan = base->beg;
279 240572606 : struct Vstr__cache_data_pos *data = NULL;
280 240572606 : unsigned int dummy_num = 0;
281 :
282 240572606 : if (!num) num = &dummy_num;
283 :
284 240572606 : *pos += base->used;
285 240572606 : *num = 1;
286 :
287 240572606 : if (*pos <= base->beg->len)
288 237042897 : return (base->beg);
289 :
290 : /* must be more than one node */
291 :
292 3529709 : if (orig_pos > (base->len - base->end->len))
293 : {
294 2375586 : *pos = orig_pos - (base->len - base->end->len);
295 2375586 : *num = base->num;
296 2375586 : return (base->end);
297 : }
298 :
299 1154123 : if ((data = vstr_cache_get(base, 1)) && data->node && (data->pos <= orig_pos))
300 : {
301 1014651 : scan = data->node;
302 1014651 : *num = data->num;
303 1014651 : *pos = (orig_pos - data->pos) + 1;
304 : }
305 :
306 3340351 : while (*pos > scan->len)
307 : {
308 2186228 : *pos -= scan->len;
309 :
310 616895 : VSTR__ASSERT(scan->next);
311 2186228 : scan = scan->next;
312 2186228 : ++*num;
313 : }
314 :
315 1154123 : if (cache)
316 1125337 : vstr_cache__pos(base, scan, (orig_pos - *pos) + 1, *num);
317 :
318 1154123 : return (scan);
319 : }
320 :
321 : extern inline char *vstr_export__node_ptr(const struct Vstr_node *node)
322 580558605 : {
323 580558605 : switch (node->type)
324 : {
325 : case VSTR_TYPE_NODE_BUF:
326 92147402 : return (((struct Vstr_node_buf *)node)->buf);
327 : case VSTR_TYPE_NODE_PTR:
328 155718834 : return (((const struct Vstr_node_ptr *)node)->ptr);
329 : case VSTR_TYPE_NODE_REF:
330 332690835 : return (((char *)((const struct Vstr_node_ref *)node)->ref->ptr) +
331 : ((const struct Vstr_node_ref *)node)->off);
332 : case VSTR_TYPE_NODE_NON:
333 244 : VSTR__ASSERT_NO_SWITCH_DEF();
334 : }
335 :
336 1534 : return (NULL);
337 : }
338 :
339 : extern inline char vstr_export_chr(const struct Vstr_base *base, size_t pos)
340 861836 : {
341 861836 : struct Vstr_node *node = NULL;
342 861836 : const char *tmp = NULL;
343 :
344 861836 : node = vstr_base__pos(base, &pos, NULL, VSTR__TRUE);
345 209923 : VSTR__ASSERT(pos);
346 :
347 : /* errors, requests for data from NON nodes and real data are all == 0 */
348 861836 : if (!node) return (0);
349 :
350 861836 : if (!(tmp = vstr_export__node_ptr(node)))
351 80 : return (0);
352 :
353 861756 : return (*(tmp + --pos));
354 : }
355 :
356 : extern inline size_t vstr_iter_len(struct Vstr_iter *iter)
357 11409517 : {
358 11409517 : return (iter->len + iter->remaining);
359 : }
360 : extern inline size_t vstr_iter_pos(struct Vstr_iter *iter,
361 : size_t pos, size_t len)
362 357787 : {
363 357787 : VSTR__ASSERT_RET((len >= (iter->len + iter->remaining)), 0);
364 :
365 357787 : return (pos + (len - vstr_iter_len(iter)));
366 : }
367 :
368 : extern inline int vstr_iter_fwd_beg(const struct Vstr_base *base,
369 : size_t pos, size_t len,
370 : struct Vstr_iter *iter)
371 237299329 : {
372 237299329 : VSTR__ASSERT_RET(base && iter, 0);
373 :
374 237299325 : iter->node = NULL;
375 :
376 237299325 : VSTR__ASSERT_RET(pos && (((pos <= base->len) &&
377 : (vstr_sc_poslast(pos, len) <= base->len)) || !len),
378 : VSTR__FALSE);
379 :
380 237299205 : if (!len)
381 20304 : return (VSTR__FALSE);
382 :
383 237278901 : iter->node = vstr_base__pos(base, &pos, &iter->num, VSTR__TRUE);
384 237278901 : --pos;
385 :
386 237278901 : iter->len = iter->node->len - pos;
387 237278901 : if (iter->len > len)
388 219183462 : iter->len = len;
389 237278901 : len -= iter->len;
390 :
391 237278901 : iter->remaining = len;
392 :
393 237278901 : iter->ptr = NULL;
394 237278901 : if (iter->node->type != VSTR_TYPE_NODE_NON)
395 237263614 : iter->ptr = vstr_export__node_ptr(iter->node) + pos;
396 :
397 237278901 : return (VSTR__TRUE);
398 : }
399 :
400 : extern inline int vstr_iter_fwd_nxt(struct Vstr_iter *iter)
401 7131730 : {
402 7131730 : if (!iter->remaining)
403 : {
404 274489 : iter->len = 0;
405 274489 : iter->node = NULL;
406 274489 : return (VSTR__FALSE);
407 : }
408 :
409 6857241 : iter->node = iter->node->next;
410 6857241 : ++iter->num;
411 :
412 6857241 : iter->len = iter->node->len;
413 :
414 2431339 : VSTR__ASSERT(iter->len);
415 :
416 6857241 : if (iter->len > iter->remaining)
417 668692 : iter->len = iter->remaining;
418 6857241 : iter->remaining -= iter->len;
419 :
420 6857241 : iter->ptr = NULL;
421 6857241 : if (iter->node->type != VSTR_TYPE_NODE_NON)
422 6689988 : iter->ptr = vstr_export__node_ptr(iter->node);
423 :
424 6857241 : return (VSTR__TRUE);
425 : }
426 :
427 : extern inline char vstr_iter_fwd_chr(struct Vstr_iter *iter, unsigned int *ern)
428 587284 : {
429 587284 : unsigned int dummy_ern;
430 :
431 587284 : if (!ern)
432 404404 : ern = &dummy_ern;
433 :
434 587284 : if (!iter->len && !vstr_iter_fwd_nxt(iter))
435 : {
436 5325 : *ern = VSTR_TYPE_ITER_END;
437 5325 : return (0);
438 : }
439 :
440 118282 : VSTR__ASSERT(iter->len);
441 581959 : --iter->len;
442 :
443 118282 : VSTR__ASSERT(iter->node);
444 581959 : if (iter->node->type == VSTR_TYPE_NODE_NON)
445 : {
446 6435 : *ern = VSTR_TYPE_ITER_NON;
447 6435 : return (0);
448 : }
449 :
450 575524 : *ern = VSTR_TYPE_ITER_DEF;
451 575524 : return (*iter->ptr++);
452 : }
453 :
454 : extern inline size_t vstr_iter_fwd_buf(struct Vstr_iter *iter, size_t len,
455 : void *passed_buf, size_t buf_len,
456 : unsigned int *ern)
457 35 : {
458 35 : size_t orig_len = len;
459 35 : char *buf = passed_buf;
460 35 : unsigned int dummy_ern;
461 :
462 7 : VSTR__ASSERT(buf || !buf_len);
463 :
464 35 : if (!ern)
465 15 : ern = &dummy_ern;
466 :
467 35 : if (!iter->len && !vstr_iter_fwd_nxt(iter))
468 : {
469 5 : *ern = VSTR_TYPE_ITER_END;
470 5 : return (0);
471 : }
472 :
473 30 : *ern = VSTR_TYPE_ITER_DEF;
474 130 : while ((iter->len || vstr_iter_fwd_nxt(iter)) && len)
475 : {
476 100 : size_t tmp = len;
477 100 : size_t tmp_buf_len = 0;
478 :
479 20 : VSTR__ASSERT(iter->len);
480 20 : VSTR__ASSERT(iter->node);
481 :
482 100 : if (tmp > iter->len)
483 85 : tmp = iter->len;
484 :
485 100 : tmp_buf_len = tmp;
486 100 : if (tmp_buf_len > buf_len)
487 50 : tmp_buf_len = buf_len;
488 :
489 100 : len -= tmp;
490 100 : iter->len -= tmp;
491 :
492 100 : if (tmp_buf_len && (iter->node->type != VSTR_TYPE_NODE_NON))
493 50 : vstr_wrap_memcpy(buf, iter->ptr, tmp_buf_len);
494 100 : if (tmp_buf_len)
495 : {
496 55 : buf += tmp_buf_len;
497 55 : buf_len -= tmp_buf_len;
498 : }
499 100 : if (iter->node->type != VSTR_TYPE_NODE_NON)
500 85 : iter->ptr += tmp;
501 : }
502 :
503 30 : return (orig_len - len);
504 : }
505 :
506 : extern inline size_t vstr_iter_fwd_cstr(struct Vstr_iter *iter, size_t len,
507 : char *buf, size_t buf_len,
508 : unsigned int *ern)
509 14 : {
510 14 : size_t ret = 0;
511 :
512 2 : VSTR__ASSERT(buf);
513 :
514 14 : if (!buf_len)
515 4 : return (0);
516 :
517 10 : --buf_len;
518 10 : buf[buf_len] = 0;
519 10 : ret = vstr_iter_fwd_buf(iter, len, buf, buf_len, ern);
520 10 : if (ret < buf_len)
521 5 : buf[ret] = 0;
522 :
523 10 : return (ret);
524 : }
525 :
526 : extern inline unsigned int vstr_num(const struct Vstr_base *base,
527 : size_t pos, size_t len)
528 313 : {
529 313 : struct Vstr_iter dummy_iter;
530 313 : struct Vstr_iter *iter = &dummy_iter;
531 313 : unsigned int beg_num = 0;
532 :
533 313 : VSTR__ASSERT_RET(base, VSTR__FALSE);
534 :
535 313 : if (pos == 1 && len == base->len)
536 288 : return (base->num);
537 :
538 25 : if (!vstr_iter_fwd_beg(base, pos, len, iter))
539 10 : return (0);
540 :
541 15 : beg_num = iter->num;
542 20 : while (vstr_iter_fwd_nxt(iter))
543 : { /* do nothing */; }
544 :
545 15 : return ((iter->num - beg_num) + 1);
546 : }
547 :
548 : extern inline int vstr_add_buf(struct Vstr_base *base, size_t pos,
549 : const void *buffer, size_t len)
550 2383693 : {
551 2383693 : VSTR__ASSERT_RET(!(!base || !buffer || (pos > base->len)), VSTR__FALSE);
552 :
553 2383685 : if (!len) return (VSTR__TRUE);
554 :
555 2349826 : if (base->len && (pos == base->len) &&
556 : (base->end->type == VSTR_TYPE_NODE_BUF) &&
557 : (len <= (base->conf->buf_sz - base->end->len)) &&
558 : (!base->cache_available || base->cache_internal))
559 : {
560 2040123 : struct Vstr_node *scan = base->end;
561 :
562 524832 : VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
563 524832 : VSTR__ASSERT(vstr__check_real_nodes(base));
564 :
565 2040123 : vstr_wrap_memcpy(((struct Vstr_node_buf *)scan)->buf + scan->len,
566 : buffer, len);
567 2040123 : scan->len += len;
568 2040123 : base->len += len;
569 :
570 2040123 : if (base->iovec_upto_date)
571 : {
572 869382 : unsigned int num = base->num + VSTR__CACHE(base)->vec->off - 1;
573 869382 : VSTR__CACHE(base)->vec->v[num].iov_len += len;
574 : }
575 :
576 524832 : VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
577 524832 : VSTR__ASSERT(vstr__check_real_nodes(base));
578 :
579 2040123 : return (VSTR__TRUE);
580 : }
581 :
582 309703 : return (vstr_extern_inline_add_buf(base, pos, buffer, len));
583 : }
584 :
585 : extern inline int vstr_add_rep_chr(struct Vstr_base *base, size_t pos,
586 : char chr, size_t len)
587 263383 : { /* almost embarassingly similar to add_buf */
588 263383 : VSTR__ASSERT_RET(!(!base || (pos > base->len)), VSTR__FALSE);
589 :
590 263379 : if (!len) return (VSTR__TRUE);
591 :
592 261803 : if (base->len && (pos == base->len) &&
593 : (base->end->type == VSTR_TYPE_NODE_BUF) &&
594 : (len <= (base->conf->buf_sz - base->end->len)) &&
595 : (!base->cache_available || base->cache_internal))
596 : {
597 159433 : struct Vstr_node *scan = base->end;
598 :
599 43206 : VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
600 43206 : VSTR__ASSERT(vstr__check_real_nodes(base));
601 :
602 159433 : vstr_wrap_memset(((struct Vstr_node_buf *)scan)->buf + scan->len, chr, len);
603 159433 : scan->len += len;
604 159433 : base->len += len;
605 :
606 159433 : if (base->iovec_upto_date)
607 : {
608 32682 : unsigned int num = base->num + VSTR__CACHE(base)->vec->off - 1;
609 32682 : VSTR__CACHE(base)->vec->v[num].iov_len += len;
610 : }
611 :
612 43206 : VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
613 43206 : VSTR__ASSERT(vstr__check_real_nodes(base));
614 :
615 159433 : return (VSTR__TRUE);
616 : }
617 :
618 102370 : return (vstr_extern_inline_add_rep_chr(base, pos, chr, len));
619 : }
620 :
621 : extern inline int vstr_del(struct Vstr_base *base, size_t pos, size_t len)
622 5923189 : {
623 5923189 : VSTR__ASSERT_RET(!(!base || ((pos > base->len) && len)), VSTR__FALSE);
624 :
625 5923181 : if (!len) return (VSTR__TRUE);
626 :
627 5409977 : if (!base->cache_available || base->cache_internal)
628 : {
629 5408487 : size_t end_len = 0;
630 :
631 5408487 : if ((pos == 1) && ((len + base->used) < base->beg->len))
632 : { /* delete from beginning, in one node */
633 5064055 : struct Vstr_node *scan = base->beg;
634 5064055 : struct Vstr__cache_data_cstr *cdata = NULL;
635 5064055 : struct Vstr__cache_data_pos *pdata = NULL;
636 :
637 1147304 : VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
638 1147304 : VSTR__ASSERT(vstr__check_real_nodes(base));
639 :
640 5064055 : base->len -= len;
641 :
642 5064055 : switch (scan->type)
643 : {
644 : case VSTR_TYPE_NODE_BUF:
645 4258754 : base->used += len;
646 4258754 : break;
647 : case VSTR_TYPE_NODE_NON:
648 35 : scan->len -= len;
649 35 : break;
650 : case VSTR_TYPE_NODE_PTR:
651 : {
652 3519 : char *tmp = ((struct Vstr_node_ptr *)scan)->ptr;
653 3519 : ((struct Vstr_node_ptr *)scan)->ptr = tmp + len;
654 3519 : scan->len -= len;
655 : }
656 3519 : break;
657 : case VSTR_TYPE_NODE_REF:
658 801747 : ((struct Vstr_node_ref *)scan)->off += len;
659 801747 : scan->len -= len;
660 : break;
661 : }
662 :
663 5064055 : if ((cdata = vstr_cache_get(base, 3)) && cdata->ref && cdata->len)
664 : {
665 3279 : size_t data_end_pos = vstr_sc_poslast(cdata->pos, cdata->len);
666 3279 : size_t end_pos = vstr_sc_poslast(1, len);
667 :
668 3279 : if (cdata->pos > end_pos)
669 55 : cdata->pos -= len;
670 3224 : else if (data_end_pos <= end_pos)
671 134 : cdata->len = 0;
672 : else
673 : {
674 3090 : cdata->len -= vstr_sc_posdiff(cdata->pos, end_pos);
675 3090 : cdata->off += vstr_sc_posdiff(cdata->pos, end_pos);
676 :
677 3090 : cdata->pos = pos;
678 : }
679 : }
680 5064055 : if (base->iovec_upto_date)
681 : {
682 5057637 : unsigned int num = VSTR__CACHE(base)->vec->off;
683 :
684 5057637 : if (scan->type != VSTR_TYPE_NODE_NON)
685 : {
686 5057637 : char *tmp = VSTR__CACHE(base)->vec->v[num].iov_base;
687 5057637 : VSTR__CACHE(base)->vec->v[num].iov_base = tmp + len;
688 : }
689 5057637 : VSTR__CACHE(base)->vec->v[num].iov_len -= len;
690 : }
691 5064055 : if ((pdata = vstr_cache_get(base, 1)))
692 5062730 : pdata->node = NULL;
693 :
694 1147304 : VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
695 1147304 : VSTR__ASSERT(vstr__check_real_nodes(base));
696 :
697 5064055 : return (VSTR__TRUE);
698 : }
699 :
700 344432 : end_len = base->end->len;
701 344432 : if (base->beg == base->end)
702 : {
703 14274 : VSTR__ASSERT(base->num == 1);
704 48523 : end_len += base->used;
705 : }
706 :
707 344432 : if ((pos > (base->len - (end_len - 1))) &&
708 : (len == vstr_sc_posdiff(pos, base->len)))
709 : { /* delete from end, in one node */
710 19560 : struct Vstr_node *scan = base->end;
711 19560 : struct Vstr__cache_data_cstr *cdata = NULL;
712 19560 : struct Vstr__cache_data_pos *pdata = NULL;
713 :
714 6675 : VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
715 6675 : VSTR__ASSERT(vstr__check_real_nodes(base));
716 :
717 19560 : base->len -= len;
718 19560 : scan->len -= len;
719 :
720 19560 : if ((cdata = vstr_cache_get(base, 3)) && cdata->ref && cdata->len)
721 : {
722 20 : size_t data_end_pos = vstr_sc_poslast(cdata->pos, cdata->len);
723 :
724 20 : if (data_end_pos >= pos)
725 20 : cdata->len = 0;
726 : }
727 19560 : if (base->iovec_upto_date)
728 : {
729 2760 : unsigned int num = base->num + VSTR__CACHE(base)->vec->off - 1;
730 :
731 2760 : VSTR__CACHE(base)->vec->v[num].iov_len -= len;
732 : }
733 19560 : if ((pdata = vstr_cache_get(base, 1)))
734 17302 : pdata->node = NULL;
735 :
736 6675 : VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
737 6675 : VSTR__ASSERT(vstr__check_real_nodes(base));
738 :
739 19560 : return (VSTR__TRUE);
740 : }
741 : }
742 :
743 326362 : return (vstr_extern_inline_del(base, pos, len));
744 : }
745 :
746 : extern inline int vstr_sc_reduce(struct Vstr_base *base,
747 : size_t pos, size_t len, size_t reduce)
748 19899 : {
749 19899 : VSTR__ASSERT_RET(len >= reduce, 0);
750 :
751 19899 : if (!len) return (VSTR__TRUE);
752 :
753 19854 : return (vstr_del(base, pos + (len - reduce), reduce));
754 : }
755 :
756 : extern inline int vstr_sects_add(struct Vstr_sects *sects,
757 : size_t pos, size_t len)
758 101195 : {
759 101195 : if (!sects->sz || (sects->num >= sects->sz))
760 : {
761 633 : if (!sects->can_add_sz)
762 180 : return (VSTR__FALSE);
763 :
764 453 : if (!vstr_extern_inline_sects_add(sects, pos, len))
765 24 : return (VSTR__FALSE);
766 : }
767 :
768 100991 : sects->ptr[sects->num].pos = pos;
769 100991 : sects->ptr[sects->num].len = len;
770 100991 : ++sects->num;
771 :
772 100991 : return (VSTR__TRUE);
773 : }
774 :
775 : /* do inline versions of macro functions */
776 : /* cmp */
777 : extern inline int vstr_cmp_eq(const struct Vstr_base *s1, size_t p1, size_t l1,
778 : const struct Vstr_base *s2, size_t p2, size_t l2)
779 424 : { return ((l1 == l2) && !vstr_cmp(s1, p1, l1, s2, p2, l1)); }
780 : extern inline int vstr_cmp_buf_eq(const struct Vstr_base *s1,
781 : size_t p1, size_t l1,
782 : const void *buf, size_t buf_len)
783 229483198 : { return ((l1 == buf_len) && !vstr_cmp_buf(s1, p1, l1, buf, buf_len)); }
784 : extern inline int vstr_cmp_cstr(const struct Vstr_base *s1,
785 : size_t p1, size_t l1,
786 : const char *buf)
787 385 : { return (vstr_cmp_buf(s1, p1, l1, buf, strlen(buf))); }
788 : extern inline int vstr_cmp_cstr_eq(const struct Vstr_base *s1,
789 : size_t p1, size_t l1,
790 : const char *buf)
791 47123 : { return (vstr_cmp_buf_eq(s1, p1, l1, buf, strlen(buf))); }
792 :
793 : /* cmp case */
794 : extern inline int vstr_cmp_case_eq(const struct Vstr_base *s1,
795 : size_t p1, size_t l1,
796 : const struct Vstr_base *s2,
797 : size_t p2, size_t l2)
798 10 : { return ((l1 == l2) && !vstr_cmp_case(s1, p1, l1, s2, p2, l1)); }
799 : extern inline int vstr_cmp_case_buf_eq(const struct Vstr_base *s1,
800 : size_t p1, size_t l1,
801 : const char *buf, size_t buf_len)
802 120190 : { return ((l1 == buf_len) && !vstr_cmp_case_buf(s1, p1, l1, buf, buf_len)); }
803 : extern inline int vstr_cmp_case_cstr(const struct Vstr_base *s1,
804 : size_t p1, size_t l1,
805 : const char *buf)
806 385 : { return (vstr_cmp_case_buf(s1, p1, l1, buf, strlen(buf))); }
807 : extern inline int vstr_cmp_case_cstr_eq(const struct Vstr_base *s1,
808 : size_t p1, size_t l1, const char *buf)
809 5858 : { return (vstr_cmp_case_buf_eq(s1, p1, l1, buf, strlen(buf))); }
810 :
811 : /* cmp vers */
812 : extern inline int vstr_cmp_vers_eq(const struct Vstr_base *s1,
813 : size_t p1, size_t l1,
814 : const struct Vstr_base *s2,
815 : size_t p2, size_t l2)
816 20 : { return ((l1 == l2) && !vstr_cmp_vers(s1, p1, l1, s2, p2, l1)); }
817 : extern inline int vstr_cmp_vers_buf_eq(const struct Vstr_base *s1,
818 : size_t p1, size_t l1,
819 : const char *buf, size_t buf_len)
820 30 : { return ((l1 == buf_len) && !vstr_cmp_vers_buf(s1, p1, l1, buf, buf_len)); }
821 : extern inline int vstr_cmp_vers_cstr(const struct Vstr_base *s1,
822 : size_t p1, size_t l1, const char *buf)
823 595 : { return (vstr_cmp_vers_buf(s1, p1, l1, buf, strlen(buf))); }
824 : extern inline int vstr_cmp_vers_cstr_eq(const struct Vstr_base *s1,
825 : size_t p1, size_t l1, const char *buf)
826 10 : { return (vstr_cmp_vers_buf_eq(s1, p1, l1, buf, strlen(buf))); }
827 :
828 : /* add */
829 : extern inline int vstr_add_cstr_buf(struct Vstr_base *s1, size_t pa1,
830 : const char *buf)
831 425441 : { return (vstr_add_buf(s1, pa1, buf, strlen(buf))); }
832 : extern inline int vstr_add_cstr_ptr(struct Vstr_base *s1, size_t pa1,
833 : const char *ptr)
834 362718 : { return (vstr_add_ptr(s1, pa1, ptr, strlen(ptr))); }
835 : extern inline int vstr_add_cstr_ref(struct Vstr_base *s1, size_t pa1,
836 : struct Vstr_ref *ref, size_t off)
837 45 : { return (vstr_add_ref(s1, pa1, ref, off,
838 : strlen(((const char *)ref->ptr) + off))); }
839 :
840 : /* dup */
841 : extern inline struct Vstr_base *vstr_dup_cstr_buf(struct Vstr_conf *conf,
842 : const char *buf)
843 42 : { return (vstr_dup_buf(conf, buf, strlen(buf))); }
844 : extern inline struct Vstr_base *vstr_dup_cstr_ptr(struct Vstr_conf *conf,
845 : const char *ptr)
846 42 : { return (vstr_dup_ptr(conf, ptr, strlen(ptr))); }
847 : extern inline struct Vstr_base *vstr_dup_cstr_ref(struct Vstr_conf *conf,
848 : struct Vstr_ref *ref,
849 : size_t off)
850 15 : { return (vstr_dup_ref(conf, ref, off,
851 : strlen(((const char *)ref->ptr) + off))); }
852 :
853 : /* sub */
854 : extern inline int vstr_sub_cstr_buf(struct Vstr_base *s1, size_t p1, size_t l1,
855 : const char *buf)
856 150 : { return (vstr_sub_buf(s1, p1, l1, buf, strlen(buf))); }
857 : extern inline int vstr_sub_cstr_ptr(struct Vstr_base *s1, size_t p1, size_t l1,
858 : const char *ptr)
859 21 : { return (vstr_sub_ptr(s1, p1, l1, ptr, strlen(ptr))); }
860 : extern inline int vstr_sub_cstr_ref(struct Vstr_base *s1, size_t p1, size_t l1,
861 : struct Vstr_ref *ref, size_t off)
862 10 : { return (vstr_sub_ref(s1, p1, l1, ref, off,
863 : strlen(((const char *)ref->ptr) + off))); }
864 :
865 : /* srch */
866 : extern inline size_t vstr_srch_cstr_buf_fwd(const struct Vstr_base *s1,
867 : size_t p1, size_t l1,
868 : const char *buf)
869 249998 : { return (vstr_srch_buf_fwd(s1, p1, l1, buf, strlen(buf))); }
870 : extern inline size_t vstr_srch_cstr_buf_rev(const struct Vstr_base *s1,
871 : size_t p1, size_t l1,
872 : const char *buf)
873 84 : { return (vstr_srch_buf_rev(s1, p1, l1, buf, strlen(buf))); }
874 :
875 : extern inline size_t vstr_srch_cstr_chrs_fwd(const struct Vstr_base *s1,
876 : size_t p1, size_t l1,
877 : const char *chrs)
878 34853 : { return (vstr_srch_chrs_fwd(s1, p1, l1, chrs, strlen(chrs))); }
879 : extern inline size_t vstr_srch_cstr_chrs_rev(const struct Vstr_base *s1,
880 : size_t p1, size_t l1,
881 : const char *chrs)
882 15 : { return (vstr_srch_chrs_rev(s1, p1, l1, chrs, strlen(chrs))); }
883 :
884 : extern inline size_t vstr_csrch_cstr_chrs_fwd(const struct Vstr_base *s1,
885 : size_t p1, size_t l1,
886 : const char *chrs)
887 15 : { return (vstr_csrch_chrs_fwd(s1, p1, l1, chrs, strlen(chrs))); }
888 : extern inline size_t vstr_csrch_cstr_chrs_rev(const struct Vstr_base *s1,
889 : size_t p1, size_t l1,
890 : const char *chrs)
891 15 : { return (vstr_csrch_chrs_rev(s1, p1, l1, chrs, strlen(chrs))); }
892 :
893 : extern inline size_t vstr_srch_case_cstr_buf_fwd(const struct Vstr_base *s1,
894 : size_t p1, size_t l1,
895 : const char *buf)
896 13374 : { return (vstr_srch_case_buf_fwd(s1, p1, l1, buf, strlen(buf))); }
897 : extern inline size_t vstr_srch_case_cstr_buf_rev(const struct Vstr_base *s1,
898 : size_t p1, size_t l1,
899 : const char *buf)
900 24 : { return (vstr_srch_case_buf_rev(s1, p1, l1, buf, strlen(buf))); }
901 :
902 : /* spn */
903 : extern inline size_t vstr_spn_cstr_chrs_fwd(const struct Vstr_base *s1,
904 : size_t p1, size_t l1,
905 : const char *chrs)
906 170765 : { return (vstr_spn_chrs_fwd(s1, p1, l1, chrs, strlen(chrs))); }
907 : extern inline size_t vstr_spn_cstr_chrs_rev(const struct Vstr_base *s1,
908 : size_t p1, size_t l1,
909 : const char *chrs)
910 28314 : { return (vstr_spn_chrs_rev(s1, p1, l1, chrs, strlen(chrs))); }
911 :
912 : extern inline size_t vstr_cspn_cstr_chrs_fwd(const struct Vstr_base *s1,
913 : size_t p1, size_t l1,
914 : const char *chrs)
915 609525 : { return (vstr_cspn_chrs_fwd(s1, p1, l1, chrs, strlen(chrs))); }
916 : extern inline size_t vstr_cspn_cstr_chrs_rev(const struct Vstr_base *s1,
917 : size_t p1, size_t l1,
918 : const char *chrs)
919 36 : { return (vstr_cspn_chrs_rev(s1, p1, l1, chrs, strlen(chrs))); }
920 :
921 : /* split */
922 : extern inline size_t vstr_split_cstr_buf(const struct Vstr_base *s1,
923 : size_t p1, size_t l1,
924 : const char *buf,
925 : struct Vstr_sects *sect,
926 : unsigned int lim, unsigned int flags)
927 115 : { return (vstr_split_buf(s1, p1, l1, buf, strlen(buf), sect, lim, flags)); }
928 : extern inline size_t vstr_split_cstr_chrs(const struct Vstr_base *s1,
929 : size_t p1, size_t l1,
930 : const char *chrs,
931 : struct Vstr_sects *sect,
932 : unsigned int lim, unsigned int flags)
933 9259 : { return (vstr_split_chrs(s1, p1, l1, chrs, strlen(chrs), sect, lim, flags)); }
934 :
935 :
936 : /* simple inlines that can't easily be macros... */
937 : /* cmp */
938 : extern inline int vstr_cmp_bod(const struct Vstr_base *s1, size_t p1, size_t l1,
939 : const struct Vstr_base *s2, size_t p2, size_t l2)
940 : {
941 20 : size_t tmp = l1; if (tmp > l2) tmp = l2;
942 20 : return (vstr_cmp(s1, p1, tmp, s2, p2, tmp));
943 : }
944 : extern inline int vstr_cmp_eod(const struct Vstr_base *s1, size_t p1, size_t l1,
945 : const struct Vstr_base *s2, size_t p2, size_t l2)
946 835866 : {
947 835866 : size_t tmp = l1; if (tmp > l2) tmp = l2;
948 835866 : p1 += (l1 - tmp);
949 835866 : p2 += (l2 - tmp);
950 835866 : return (vstr_cmp(s1, p1, tmp, s2, p2, tmp));
951 : }
952 : extern inline int vstr_cmp_bod_eq(const struct Vstr_base *s1,
953 : size_t p1, size_t l1,
954 : const struct Vstr_base *s2,
955 : size_t p2, size_t l2)
956 30 : { return (!vstr_cmp_bod(s1, p1, l1, s2, p2, l2)); }
957 : extern inline int vstr_cmp_eod_eq(const struct Vstr_base *s1,
958 : size_t p1, size_t l1,
959 : const struct Vstr_base *s2,
960 : size_t p2, size_t l2)
961 835861 : { return (!vstr_cmp_eod(s1, p1, l1, s2, p2, l2)); }
962 :
963 : /* cmp buf */
964 : extern inline int vstr_cmp_bod_buf(const struct Vstr_base *s1,
965 : size_t p1, size_t l1,
966 : const void *buf, size_t buf_len)
967 : {
968 4560756 : size_t tmp = l1; if (tmp > buf_len) tmp = buf_len;
969 4560756 : return (vstr_cmp_buf(s1, p1, tmp, buf, tmp));
970 : }
971 : extern inline int vstr_cmp_eod_buf(const struct Vstr_base *s1,
972 : size_t p1, size_t l1,
973 : const void *pbuf, size_t buf_len)
974 22018 : {
975 22018 : const char *buf = (const char *)pbuf;
976 22018 : size_t tmp = l1; if (tmp > buf_len) tmp = buf_len;
977 22018 : p1 += (l1 - tmp);
978 22018 : buf += (buf_len - tmp);
979 22018 : return (vstr_cmp_buf(s1, p1, tmp, buf, tmp));
980 : }
981 : extern inline int vstr_cmp_bod_buf_eq(const struct Vstr_base *s1,
982 : size_t p1, size_t l1,
983 : const void *pbuf, size_t buf_len)
984 9121492 : { return (!vstr_cmp_bod_buf(s1, p1, l1, pbuf, buf_len)); }
985 : extern inline int vstr_cmp_eod_buf_eq(const struct Vstr_base *s1,
986 : size_t p1, size_t l1,
987 : const void *pbuf, size_t buf_len)
988 22008 : { return (!vstr_cmp_eod_buf(s1, p1, l1, pbuf, buf_len)); }
989 :
990 : /* cmp cstr */
991 : extern inline int vstr_cmp_bod_cstr(const struct Vstr_base *s1,
992 : size_t p1, size_t l1,
993 : const char *buf)
994 5 : { return (vstr_cmp_bod_buf(s1, p1, l1, buf, strlen(buf))); }
995 : extern inline int vstr_cmp_eod_cstr(const struct Vstr_base *s1,
996 : size_t p1, size_t l1,
997 : const char *buf)
998 5 : { return (vstr_cmp_eod_buf(s1, p1, l1, buf, strlen(buf))); }
999 : extern inline int vstr_cmp_bod_cstr_eq(const struct Vstr_base *s1,
1000 : size_t p1, size_t l1,
1001 : const char *buf)
1002 4560245 : { return (vstr_cmp_bod_buf_eq(s1, p1, l1, buf, strlen(buf))); }
1003 : extern inline int vstr_cmp_eod_cstr_eq(const struct Vstr_base *s1,
1004 : size_t p1, size_t l1,
1005 : const char *buf)
1006 21087 : { return (vstr_cmp_eod_buf_eq(s1, p1, l1, buf, strlen(buf))); }
1007 :
1008 : /* cmp case */
1009 : extern inline int vstr_cmp_case_bod(const struct Vstr_base *s1,
1010 : size_t p1, size_t l1,
1011 : const struct Vstr_base *s2,
1012 : size_t p2, size_t l2)
1013 : {
1014 20 : size_t tmp = l1; if (tmp > l2) tmp = l2;
1015 20 : return (vstr_cmp_case(s1, p1, tmp, s2, p2, tmp));
1016 : }
1017 : extern inline int vstr_cmp_case_eod(const struct Vstr_base *s1,
1018 : size_t p1, size_t l1,
1019 : const struct Vstr_base *s2,
1020 : size_t p2, size_t l2)
1021 20 : {
1022 20 : size_t tmp = l1; if (tmp > l2) tmp = l2;
1023 20 : p1 += (l1 - tmp);
1024 20 : p2 += (l2 - tmp);
1025 20 : return (vstr_cmp_case(s1, p1, tmp, s2, p2, tmp));
1026 : }
1027 : extern inline int vstr_cmp_case_bod_eq(const struct Vstr_base *s1,
1028 : size_t p1, size_t l1,
1029 : const struct Vstr_base *s2,
1030 : size_t p2, size_t l2)
1031 30 : { return (!vstr_cmp_case_bod(s1, p1, l1, s2, p2, l2)); }
1032 : extern inline int vstr_cmp_case_eod_eq(const struct Vstr_base *s1,
1033 : size_t p1, size_t l1,
1034 : const struct Vstr_base *s2,
1035 : size_t p2, size_t l2)
1036 15 : { return (!vstr_cmp_case_eod(s1, p1, l1, s2, p2, l2)); }
1037 :
1038 : /* cmp case buf */
1039 : extern inline int vstr_cmp_case_bod_buf(const struct Vstr_base *s1,
1040 : size_t p1, size_t l1,
1041 : const char *buf, size_t buf_len)
1042 : {
1043 20033 : size_t tmp = l1; if (tmp > buf_len) tmp = buf_len;
1044 20033 : return (vstr_cmp_case_buf(s1, p1, tmp, buf, tmp));
1045 : }
1046 : extern inline int vstr_cmp_case_eod_buf(const struct Vstr_base *s1,
1047 : size_t p1, size_t l1,
1048 : const char *buf, size_t buf_len)
1049 25 : {
1050 25 : size_t tmp = l1; if (tmp > buf_len) tmp = buf_len;
1051 25 : p1 += (l1 - tmp);
1052 25 : buf += (buf_len - tmp);
1053 25 : return (vstr_cmp_case_buf(s1, p1, tmp, buf, tmp));
1054 : }
1055 : extern inline int vstr_cmp_case_bod_buf_eq(const struct Vstr_base *s1,
1056 : size_t p1, size_t l1,
1057 : const char *buf, size_t buf_len)
1058 40046 : { return (!vstr_cmp_case_bod_buf(s1, p1, l1, buf, buf_len)); }
1059 : extern inline int vstr_cmp_case_eod_buf_eq(const struct Vstr_base *s1,
1060 : size_t p1, size_t l1,
1061 : const char *buf, size_t buf_len)
1062 15 : { return (!vstr_cmp_case_eod_buf(s1, p1, l1, buf, buf_len)); }
1063 :
1064 : /* cmp case cstr */
1065 : extern inline int vstr_cmp_case_bod_cstr(const struct Vstr_base *s1,
1066 : size_t p1, size_t l1,
1067 : const char *buf)
1068 5 : { return (vstr_cmp_case_bod_buf(s1, p1, l1, buf, strlen(buf))); }
1069 : extern inline int vstr_cmp_case_eod_cstr(const struct Vstr_base *s1,
1070 : size_t p1, size_t l1,
1071 : const char *buf)
1072 5 : { return (vstr_cmp_case_eod_buf(s1, p1, l1, buf, strlen(buf))); }
1073 : extern inline int vstr_cmp_case_bod_cstr_eq(const struct Vstr_base *s1,
1074 : size_t p1, size_t l1,
1075 : const char *buf)
1076 20018 : { return (vstr_cmp_case_bod_buf_eq(s1, p1, l1, buf, strlen(buf))); }
1077 : extern inline int vstr_cmp_case_eod_cstr_eq(const struct Vstr_base *s1,
1078 : size_t p1, size_t l1,
1079 : const char *buf)
1080 10 : { return (vstr_cmp_case_eod_buf_eq(s1, p1, l1, buf, strlen(buf))); }
1081 :
1082 : /* cmp vers */
1083 : extern inline int vstr_cmp_vers_bod(const struct Vstr_base *s1,
1084 : size_t p1, size_t l1,
1085 : const struct Vstr_base *s2,
1086 : size_t p2, size_t l2)
1087 : {
1088 20 : size_t tmp = l1; if (tmp > l2) tmp = l2;
1089 20 : return (vstr_cmp_vers(s1, p1, tmp, s2, p2, tmp));
1090 : }
1091 : extern inline int vstr_cmp_vers_eod(const struct Vstr_base *s1,
1092 : size_t p1, size_t l1,
1093 : const struct Vstr_base *s2,
1094 : size_t p2, size_t l2)
1095 20 : {
1096 20 : size_t tmp = l1; if (tmp > l2) tmp = l2;
1097 20 : p1 += (l1 - tmp);
1098 20 : p2 += (l2 - tmp);
1099 20 : return (vstr_cmp_vers(s1, p1, tmp, s2, p2, tmp));
1100 : }
1101 : extern inline int vstr_cmp_vers_bod_eq(const struct Vstr_base *s1,
1102 : size_t p1, size_t l1,
1103 : const struct Vstr_base *s2,
1104 : size_t p2, size_t l2)
1105 30 : { return (!vstr_cmp_vers_bod(s1, p1, l1, s2, p2, l2)); }
1106 : extern inline int vstr_cmp_vers_eod_eq(const struct Vstr_base *s1,
1107 : size_t p1, size_t l1,
1108 : const struct Vstr_base *s2,
1109 : size_t p2, size_t l2)
1110 15 : { return (!vstr_cmp_vers_eod(s1, p1, l1, s2, p2, l2)); }
1111 :
1112 : /* cmp vers buf */
1113 : extern inline int vstr_cmp_vers_bod_buf(const struct Vstr_base *s1,
1114 : size_t p1, size_t l1,
1115 : const char *buf, size_t buf_len)
1116 : {
1117 25 : size_t tmp = l1; if (tmp > buf_len) tmp = buf_len;
1118 25 : return (vstr_cmp_vers_buf(s1, p1, tmp, buf, tmp));
1119 : }
1120 : extern inline int vstr_cmp_vers_eod_buf(const struct Vstr_base *s1,
1121 : size_t p1, size_t l1,
1122 : const char *buf, size_t buf_len)
1123 25 : {
1124 25 : size_t tmp = l1; if (tmp > buf_len) tmp = buf_len;
1125 25 : p1 += (l1 - tmp);
1126 25 : buf += (buf_len - tmp);
1127 25 : return (vstr_cmp_vers_buf(s1, p1, tmp, buf, tmp));
1128 : }
1129 : extern inline int vstr_cmp_vers_bod_buf_eq(const struct Vstr_base *s1,
1130 : size_t p1, size_t l1,
1131 : const char *buf, size_t buf_len)
1132 30 : { return (!vstr_cmp_vers_bod_buf(s1, p1, l1, buf, buf_len)); }
1133 : extern inline int vstr_cmp_vers_eod_buf_eq(const struct Vstr_base *s1,
1134 : size_t p1, size_t l1,
1135 : const char *buf, size_t buf_len)
1136 15 : { return (!vstr_cmp_vers_eod_buf(s1, p1, l1, buf, buf_len)); }
1137 :
1138 : /* cmp vers cstr */
1139 : extern inline int vstr_cmp_vers_bod_cstr(const struct Vstr_base *s1,
1140 : size_t p1, size_t l1,
1141 : const char *buf)
1142 5 : { return (vstr_cmp_vers_bod_buf(s1, p1, l1, buf, strlen(buf))); }
1143 : extern inline int vstr_cmp_vers_eod_cstr(const struct Vstr_base *s1,
1144 : size_t p1, size_t l1,
1145 : const char *buf)
1146 5 : { return (vstr_cmp_vers_eod_buf(s1, p1, l1, buf, strlen(buf))); }
1147 : extern inline int vstr_cmp_vers_bod_cstr_eq(const struct Vstr_base *s1,
1148 : size_t p1, size_t l1,
1149 : const char *buf)
1150 10 : { return (vstr_cmp_vers_bod_buf_eq(s1, p1, l1, buf, strlen(buf))); }
1151 : extern inline int vstr_cmp_vers_eod_cstr_eq(const struct Vstr_base *s1,
1152 : size_t p1, size_t l1,
1153 : const char *buf)
1154 10 : { return (vstr_cmp_vers_eod_buf_eq(s1, p1, l1, buf, strlen(buf))); }
1155 :
1156 : /* ref */
1157 : extern inline struct Vstr_ref *vstr_ref_make_strdup(const char *val)
1158 28100 : { return (vstr_ref_make_memdup(val, strlen(val) + 1)); }
1159 :
1160 : /* sc */
1161 : extern inline int vstr_sc_add_cstr_grpbasenum_buf(struct Vstr_base *s1,
1162 : size_t p1, unsigned int nb,
1163 : const char *val)
1164 15 : { return (vstr_sc_add_grpbasenum_buf(s1, p1, nb, val, strlen(val))); }
1165 : extern inline int vstr_sc_add_cstr_grpbasenum_ptr(struct Vstr_base *s1,
1166 : size_t p1, unsigned int nb,
1167 : const char *val)
1168 12 : { return (vstr_sc_add_grpbasenum_ptr(s1, p1, nb, val, strlen(val))); }
1169 : extern inline int vstr_sc_add_cstr_grpbasenum_ref(struct Vstr_base *s1,
1170 : size_t p1, unsigned int nb,
1171 : struct Vstr_ref *ref,
1172 : size_t off)
1173 12 : { return (vstr_sc_add_grpbasenum_ref(s1, p1, nb, ref, off,
1174 : strlen(((const char *)ref->ptr) + off))); }
1175 : extern inline int vstr_sc_add_grpnum_buf(struct Vstr_base *s1, size_t p1,
1176 : const void *val, size_t len)
1177 1646 : { return (vstr_sc_add_grpbasenum_buf(s1, p1, 0, val, len)); }
1178 : extern inline int vstr_sc_add_cstr_grpnum_buf(struct Vstr_base *s1, size_t p1,
1179 : const char *val)
1180 6 : { return (vstr_sc_add_grpnum_buf(s1, p1, val, strlen(val))); }
1181 :
1182 : /* binary */
1183 : extern inline int vstr_sc_add_b_uint16(struct Vstr_base *s1, size_t p1,
1184 : VSTR_AUTOCONF_uint_least16_t data)
1185 : {
1186 20 : unsigned char buf[2];
1187 :
1188 20 : buf[1] = data & 0xFF; data >>= 8;
1189 20 : buf[0] = data & 0xFF;
1190 :
1191 20 : return (vstr_add_buf(s1, p1, buf, sizeof(buf)));
1192 : }
1193 : extern inline int vstr_sc_add_b_uint32(struct Vstr_base *s1, size_t p1,
1194 : VSTR_AUTOCONF_uint_least32_t data)
1195 50 : {
1196 50 : unsigned char buf[4];
1197 :
1198 50 : buf[3] = data & 0xFF; data >>= 8;
1199 50 : buf[2] = data & 0xFF; data >>= 8;
1200 50 : buf[1] = data & 0xFF; data >>= 8;
1201 50 : buf[0] = data & 0xFF;
1202 :
1203 50 : return (vstr_add_buf(s1, p1, buf, sizeof(buf)));
1204 : }
1205 :
1206 : extern inline int vstr_sc_sub_b_uint16(struct Vstr_base *s1,
1207 : size_t p1, size_t l1,
1208 : VSTR_AUTOCONF_uint_least16_t data)
1209 5 : {
1210 5 : unsigned char buf[2];
1211 :
1212 5 : buf[1] = data & 0xFF; data >>= 8;
1213 5 : buf[0] = data & 0xFF;
1214 :
1215 5 : return (vstr_sub_buf(s1, p1, l1, buf, sizeof(buf)));
1216 : }
1217 : extern inline int vstr_sc_sub_b_uint32(struct Vstr_base *s1,
1218 : size_t p1, size_t l1,
1219 : VSTR_AUTOCONF_uint_least32_t data)
1220 5 : {
1221 5 : unsigned char buf[4];
1222 :
1223 5 : buf[3] = data & 0xFF; data >>= 8;
1224 5 : buf[2] = data & 0xFF; data >>= 8;
1225 5 : buf[1] = data & 0xFF; data >>= 8;
1226 5 : buf[0] = data & 0xFF;
1227 :
1228 5 : return (vstr_sub_buf(s1, p1, l1, buf, sizeof(buf)));
1229 : }
1230 :
1231 : extern inline VSTR_AUTOCONF_uint_least16_t
1232 : vstr_sc_parse_b_uint16(struct Vstr_base *s1, size_t p1)
1233 54 : {
1234 54 : unsigned char buf[2];
1235 54 : VSTR_AUTOCONF_uint_least16_t num = 0;
1236 :
1237 54 : if (!vstr_export_buf(s1, p1, sizeof(buf), buf, sizeof(buf)))
1238 4 : return (0);
1239 :
1240 50 : num += buf[0]; num <<= 8;
1241 50 : num += buf[1];
1242 :
1243 50 : return (num);
1244 : }
1245 : extern inline VSTR_AUTOCONF_uint_least32_t
1246 : vstr_sc_parse_b_uint32(struct Vstr_base *s1, size_t p1)
1247 64 : {
1248 64 : unsigned char buf[4];
1249 64 : VSTR_AUTOCONF_uint_least32_t num = 0;
1250 :
1251 64 : if (!vstr_export_buf(s1, p1, sizeof(buf), buf, sizeof(buf)))
1252 4 : return (0);
1253 :
1254 60 : num += buf[0]; num <<= 8;
1255 60 : num += buf[1]; num <<= 8;
1256 60 : num += buf[2]; num <<= 8;
1257 60 : num += buf[3];
1258 :
1259 60 : return (num);
1260 : }
1261 :
1262 : #undef VSTR__ASSERT
1263 : #undef VSTR__ASSERT_RET
1264 : #undef VSTR__ASSERT_NO_SWITCH_DEF
1265 : #undef VSTR__TRUE
1266 : #undef VSTR__FALSE
|