1 : /* Copyright (c) 2007 Paul Rosenfeld
2 : James Antill -- See LICENSE file for terms. */
3 : #ifndef USTR_SUB_H
4 : #error " Include ustr-sub.h before this file."
5 : #endif
6 :
7 : USTR_CONF_i_PROTO int ustrp__sub_undef(struct Ustr_pool *p, struct Ustr **ps1,
8 : size_t pos, size_t len)
9 920 : {
10 : size_t clen;
11 :
12 459 : USTR_ASSERT(ps1 && ustrp__assert_valid(!!p, *ps1));
13 :
14 920 : if (!len)
15 236 : return (USTR_TRUE);
16 :
17 684 : clen = ustrp__assert_valid_subustr(!!p, *ps1, pos, 1);
18 684 : if (!clen)
19 2 : return (USTR_FALSE);
20 682 : --pos;
21 :
22 682 : if ((clen - pos) < len)
23 : { /* need to expand s1, it's basically like ustr_set() with an offset */
24 64 : if (!ustrp__add_undef(p, ps1, len - (clen - pos)))
25 12 : return (USTR_FALSE);
26 : }
27 618 : else if (!ustrp__sc_ensure_owner(p, ps1))
28 6 : return (USTR_FALSE);
29 :
30 664 : return (USTR_TRUE);
31 : }
32 : USTR_CONF_I_PROTO
33 : int ustr_sub_undef(struct Ustr **ps1, size_t pos, size_t len)
34 6 : { return (ustrp__sub_undef(0, ps1, pos, len)); }
35 : USTR_CONF_I_PROTO int ustrp_sub_undef(struct Ustr_pool *p, struct Ustrp **ps1,
36 : size_t pos, size_t len)
37 4 : {
38 4 : struct Ustr *tmp = &(*ps1)->s;
39 4 : int ret = ustrp__sub_undef(p, &tmp, pos, len);
40 4 : *ps1 = USTRP(tmp);
41 4 : return (ret);
42 : }
43 :
44 : USTR_CONF_i_PROTO int ustrp__sub_buf(struct Ustr_pool *p, struct Ustr **ps1,
45 : size_t pos, const void *buf, size_t len)
46 722 : {
47 722 : if (!ustrp__sub_undef(p, ps1, pos, len))
48 10 : return (USTR_FALSE);
49 712 : --pos;
50 :
51 712 : ustr__memcpy(*ps1, pos, buf, len);
52 :
53 712 : return (USTR_TRUE);
54 : }
55 : USTR_CONF_I_PROTO
56 : int ustr_sub_buf(struct Ustr **ps1, size_t pos, const void *buf, size_t len)
57 20 : { return (ustrp__sub_buf(0, ps1, pos, buf, len)); }
58 : USTR_CONF_I_PROTO int ustrp_sub_buf(struct Ustr_pool *p, struct Ustrp **ps1,
59 : size_t pos, const void *buf, size_t len)
60 8 : {
61 8 : struct Ustr *tmp = &(*ps1)->s;
62 8 : int ret = ustrp__sub_buf(p, &tmp, pos, buf, len);
63 8 : *ps1 = USTRP(tmp);
64 8 : return (ret);
65 : }
66 :
67 : USTR_CONF_i_PROTO int ustrp__sub(struct Ustr_pool *p, struct Ustr **ps1,
68 : size_t pos, const struct Ustr *s2)
69 84 : {
70 84 : if (*ps1 == s2)
71 44 : return (ustrp__ins_subustr(p, ps1, pos - 1, s2, 1, pos - 1));
72 :
73 40 : return (ustrp__sub_buf(p, ps1, pos, ustr_cstr(s2), ustr_len(s2)));
74 : }
75 : USTR_CONF_I_PROTO
76 : int ustr_sub(struct Ustr **ps1, size_t pos, const struct Ustr *s2)
77 32 : { return (ustrp__sub(0, ps1, pos, s2)); }
78 : USTR_CONF_I_PROTO int ustrp_sub(struct Ustr_pool *p, struct Ustrp **ps1,
79 : size_t pos, const struct Ustrp *s2)
80 4 : {
81 4 : struct Ustr *tmp = &(*ps1)->s;
82 4 : int ret = ustrp__sub(p, &tmp, pos, &s2->s);
83 4 : *ps1 = USTRP(tmp);
84 4 : return (ret);
85 : }
86 :
87 : USTR_CONF_i_PROTO
88 : int ustrp__sub_subustr(struct Ustr_pool *p, struct Ustr **ps1, size_t pos1,
89 : const struct Ustr *s2, size_t pos2, size_t len2)
90 80 : {
91 80 : size_t clen2 = 0;
92 :
93 80 : if (!len2)
94 8 : return (USTR_TRUE);
95 :
96 72 : if (!(clen2 = ustrp__assert_valid_subustr(!!p, s2, pos2, len2)))
97 4 : return (USTR_FALSE);
98 :
99 68 : if (clen2 == len2)
100 16 : return (ustrp__sub(p, ps1, pos1, s2));
101 :
102 52 : if ((*ps1 == s2) && ustr_owner(*ps1))
103 : {
104 44 : struct Ustr *tmp = USTR_NULL;
105 44 : int ret = USTR_FALSE;
106 :
107 44 : if (pos1 == pos2) /* delete from end */
108 5 : return (ustrp__del(p, ps1, ((ustr_len(*ps1) - pos1) + 1) - len2));
109 :
110 : /* This is somewhat difficult to do "well". So punt. */
111 40 : if (!(tmp = ustrp__dup_subustr(p, s2, pos2, len2)))
112 8 : return (USTR_FALSE);
113 :
114 32 : ret = ustrp__sub(p, ps1, pos1, tmp);
115 32 : ustrp__free(p, tmp);
116 :
117 32 : return (ret);
118 : }
119 :
120 8 : --pos2;
121 :
122 8 : return (ustrp__sub_buf(p, ps1, pos1, ustr_cstr(s2) + pos2, len2));
123 : }
124 : USTR_CONF_I_PROTO
125 : int ustr_sub_subustr(struct Ustr **ps1, size_t pos1,
126 : const struct Ustr *s2, size_t pos2, size_t len2)
127 76 : { return (ustrp__sub_subustr(0, ps1, pos1, s2, pos2, len2)); }
128 : USTR_CONF_I_PROTO
129 : int ustrp_sub_subustrp(struct Ustr_pool *p, struct Ustrp **ps1, size_t pos1,
130 : const struct Ustrp *s2, size_t pos2, size_t len2)
131 4 : {
132 4 : struct Ustr *tmp = &(*ps1)->s;
133 4 : int ret = ustrp__sub_subustr(p, &tmp, pos1, &s2->s, pos2, len2);
134 4 : *ps1 = USTRP(tmp);
135 4 : return (ret);
136 : }
137 :
138 : USTR_CONF_i_PROTO int ustrp__sub_rep_chr(struct Ustr_pool *p, struct Ustr **ps1,
139 : size_t pos, char chr, size_t len)
140 176 : {
141 176 : if (!ustrp__sub_undef(p, ps1, pos, len))
142 4 : return (USTR_FALSE);
143 172 : --pos;
144 :
145 172 : ustr__memset(*ps1, pos, chr, len);
146 :
147 172 : return (USTR_TRUE);
148 : }
149 : USTR_CONF_I_PROTO
150 : int ustr_sub_rep_chr(struct Ustr **ps1, size_t pos, char chr, size_t len)
151 24 : { return (ustrp__sub_rep_chr(0, ps1, pos, chr, len)); }
152 : USTR_CONF_I_PROTO int ustrp_sub_rep_chr(struct Ustr_pool *p, struct Ustrp **ps1,
153 : size_t pos, char chr, size_t len)
154 4 : {
155 4 : struct Ustr *tmp = &(*ps1)->s;
156 4 : int ret = ustrp__sub_rep_chr(p, &tmp, pos, chr, len);
157 4 : *ps1 = USTRP(tmp);
158 4 : return (ret);
159 : }
160 :
161 : USTR_CONF_i_PROTO int ustrp__sc_sub_undef(struct Ustr_pool *p,struct Ustr **ps1,
162 : size_t pos, size_t olen, size_t len)
163 244 : {
164 120 : USTR_ASSERT(ps1);
165 :
166 244 : if (!olen)
167 8 : return (ustrp__ins_undef(p, ps1, pos - 1, len));
168 :
169 236 : if (!ustrp__assert_valid_subustr(!!p, *ps1, pos, olen))
170 4 : return (USTR_FALSE);
171 :
172 232 : if (len == olen)
173 92 : return (ustrp__sc_ensure_owner(p, ps1));
174 :
175 : /* work at end, so we don't have to memmove as much */
176 140 : if (len < olen)
177 76 : return (ustrp__del_subustr(p, ps1, pos + len, olen - len));
178 :
179 64 : return (ustrp__ins_undef( p, ps1, pos + olen - 1, len - olen));
180 : }
181 : USTR_CONF_I_PROTO
182 : int ustr_sc_sub_undef(struct Ustr **ps1, size_t pos, size_t olen, size_t len)
183 6 : { return (ustrp__sc_sub_undef(0, ps1, pos, olen, len)); }
184 : USTR_CONF_I_PROTO int ustrp_sc_sub_undef(struct Ustr_pool *p,struct Ustrp **ps1,
185 : size_t pos, size_t olen, size_t len)
186 4 : {
187 4 : struct Ustr *tmp = &(*ps1)->s;
188 4 : int ret = ustrp__sc_sub_undef(p, &tmp, pos, olen, len);
189 4 : *ps1 = USTRP(tmp);
190 4 : return (ret);
191 : }
192 :
193 : USTR_CONF_i_PROTO
194 : int ustrp__sc_sub_buf(struct Ustr_pool *p, struct Ustr **ps1,
195 : size_t pos, size_t olen, const void *buf, size_t len)
196 170 : {
197 170 : if (!ustrp__sc_sub_undef(p, ps1, pos, olen, len))
198 4 : return (USTR_FALSE);
199 :
200 166 : return (ustrp__sub_buf(p, ps1, pos, buf, len));
201 : }
202 : USTR_CONF_I_PROTO
203 : int ustr_sc_sub_buf(struct Ustr **ps1,
204 : size_t pos, size_t olen, const void *buf, size_t len)
205 8 : { return (ustrp__sc_sub_buf(0, ps1, pos, olen, buf, len)); }
206 : USTR_CONF_I_PROTO
207 : int ustrp_sc_sub_buf(struct Ustr_pool *p, struct Ustrp **ps1,
208 : size_t pos, size_t olen, const void *buf, size_t len)
209 8 : {
210 8 : struct Ustr *tmp = &(*ps1)->s;
211 8 : int ret = ustrp__sc_sub_buf(p, &tmp, pos, olen, buf, len);
212 8 : *ps1 = USTRP(tmp);
213 8 : return (ret);
214 : }
215 :
216 : USTR_CONF_i_PROTO
217 : int ustrp__sc_sub(struct Ustr_pool *p, struct Ustr **ps1,size_t pos,size_t olen,
218 : const struct Ustr *s2)
219 100 : {
220 100 : if (!olen)
221 4 : return (ustrp__ins(p, ps1, pos - 1, s2));
222 :
223 96 : if ((*ps1 == s2) && ustr_owner(*ps1))
224 : {
225 26 : size_t clen = ustrp__assert_valid_subustr(!!p, *ps1, pos, olen);
226 26 : size_t alen = (clen - olen);
227 26 : size_t epos = ( pos + olen);
228 26 : size_t elen = (clen - epos) + 1;
229 : char *ptr;
230 :
231 26 : if (!clen)
232 2 : return (USTR_FALSE);
233 :
234 : /*
235 : abcd/1.2 => abcdcd
236 : abcd/2.2 => aabcdd
237 : abcd/3.2 => ababcd
238 : */
239 :
240 24 : if (!ustrp__add_undef(p, ps1, alen))
241 4 : return (USTR_FALSE);
242 :
243 20 : ptr = ustr_wstr(*ps1);
244 20 : if (pos != 1)
245 : {
246 16 : size_t bpos = pos - 1;
247 16 : size_t blen = bpos;
248 :
249 : /* move current data, to make room */
250 16 : memmove(ptr + bpos, ptr, clen);
251 16 : memcpy(ptr, ptr + bpos, blen);
252 16 : epos += blen;
253 16 : clen += blen;
254 : }
255 20 : ustr__memcpy(*ps1, clen, ptr + epos - 1, elen);
256 :
257 10 : USTR_ASSERT(ps1 && ustrp__assert_valid(!!p, *ps1));
258 20 : return (USTR_TRUE);
259 : }
260 :
261 70 : return (ustrp__sc_sub_buf(p, ps1, pos, olen, ustr_cstr(s2), ustr_len(s2)));
262 : }
263 : USTR_CONF_I_PROTO
264 : int ustr_sc_sub(struct Ustr **ps1,size_t pos,size_t olen,
265 : const struct Ustr *s2)
266 52 : { return (ustrp__sc_sub(0, ps1, pos, olen, s2)); }
267 : USTR_CONF_I_PROTO
268 : int ustrp_sc_sub(struct Ustr_pool *p, struct Ustrp **ps1,size_t pos,size_t olen,
269 : const struct Ustrp *s2)
270 4 : {
271 4 : struct Ustr *tmp = &(*ps1)->s;
272 4 : int ret = ustrp__sc_sub(p, &tmp, pos, olen, &s2->s);
273 4 : *ps1 = USTRP(tmp);
274 4 : return (ret);
275 : }
276 :
277 : USTR_CONF_i_PROTO
278 : int ustrp__sc_sub_subustr(struct Ustr_pool *p,
279 : struct Ustr **ps1, size_t pos1, size_t len1,
280 : const struct Ustr *s2, size_t pos2, size_t len2)
281 76 : {
282 76 : size_t clen2 = 0;
283 :
284 76 : if (!len2)
285 12 : return (ustrp__del_subustr(p, ps1, pos1, len1));
286 :
287 64 : if (!(clen2 = ustrp__assert_valid_subustr(!!p, s2, pos2, len2)))
288 4 : return (USTR_FALSE);
289 :
290 60 : if (clen2 == len2)
291 4 : return (ustrp__sc_sub(p, ps1, pos1, len1, s2));
292 :
293 56 : if ((*ps1 == s2) && ustr_owner(*ps1))
294 : {
295 44 : struct Ustr *tmp = USTR_NULL;
296 44 : int ret = USTR_FALSE;
297 :
298 : /* This is somewhat difficult to do "well". So punt. */
299 44 : if (!(tmp = ustrp__dup_subustr(p, s2, pos2, len2)))
300 4 : return (USTR_FALSE);
301 :
302 40 : ret = ustrp__sc_sub(p, ps1, pos1, len1, tmp);
303 40 : ustrp__free(p, tmp);
304 :
305 40 : return (ret);
306 : }
307 :
308 12 : --pos2;
309 :
310 12 : return (ustrp__sc_sub_buf(p, ps1, pos1, len1, ustr_cstr(s2) + pos2, len2));
311 : }
312 : USTR_CONF_I_PROTO
313 : int ustr_sc_sub_subustr(struct Ustr **ps1, size_t pos1, size_t len1,
314 : const struct Ustr *s2, size_t pos2, size_t len2)
315 72 : { return (ustrp__sc_sub_subustr(0, ps1, pos1, len1, s2, pos2, len2)); }
316 : USTR_CONF_I_PROTO
317 : int ustrp_sc_sub_subustrp(struct Ustr_pool *p,
318 : struct Ustrp **ps1, size_t pos1, size_t len1,
319 : const struct Ustrp *s2, size_t pos2, size_t len2)
320 4 : {
321 4 : struct Ustr *tmp = &(*ps1)->s;
322 4 : int ret = ustrp__sc_sub_subustr(p, &tmp, pos1, len1, &s2->s, pos2, len2);
323 4 : *ps1 = USTRP(tmp);
324 4 : return (ret);
325 : }
326 :
327 : USTR_CONF_i_PROTO
328 : int ustrp__sc_sub_rep_chr(struct Ustr_pool *p, struct Ustr **ps1,
329 : size_t pos, size_t olen, char chr, size_t len)
330 56 : {
331 56 : if (!ustrp__sc_sub_undef(p, ps1, pos, olen, len))
332 4 : return (USTR_FALSE);
333 :
334 52 : return (ustrp__sub_rep_chr(p, ps1, pos, chr, len));
335 : }
336 : USTR_CONF_I_PROTO int ustr_sc_sub_rep_chr(struct Ustr **ps1, size_t pos,
337 : size_t olen, char chr, size_t len)
338 16 : { return (ustrp__sc_sub_rep_chr(0, ps1, pos, olen, chr, len)); }
339 : USTR_CONF_I_PROTO
340 : int ustrp_sc_sub_rep_chr(struct Ustr_pool *p, struct Ustrp **ps1,
341 : size_t pos, size_t olen, char chr, size_t len)
342 4 : {
343 4 : struct Ustr *tmp = &(*ps1)->s;
344 4 : int ret = ustrp__sc_sub_rep_chr(p, &tmp, pos, olen, chr, len);
345 4 : *ps1 = USTRP(tmp);
346 4 : return (ret);
347 : }
348 :
349 : #ifdef USTR_FMT_H
350 : # if USTR_CONF_HAVE_VA_COPY
351 : USTR_CONF_i_PROTO
352 : int ustrp__sub_vfmt_lim(struct Ustr_pool *p, struct Ustr **ps1, size_t pos,
353 : size_t lim, const char *fmt, va_list ap)
354 56 : { /* NOTE: Copy and pasted so we can use ustrp_set_undef() */
355 : va_list nap;
356 56 : int rc = -1;
357 : char buf[USTR__SNPRINTF_LOCAL];
358 : char *ptr;
359 : char save_end;
360 :
361 56 : USTR__VA_COPY(nap, ap);
362 56 : rc = USTR_CONF_VSNPRINTF_BEG(buf, sizeof(buf), fmt, nap);
363 56 : va_end(nap);
364 :
365 56 : if ((rc == -1) && ((rc = ustr__retard_vfmt_ret(fmt, ap)) == -1))
366 4 : return (USTR_FALSE);
367 :
368 52 : if (lim && ((size_t)rc > lim))
369 12 : rc = lim;
370 :
371 52 : if ((size_t)rc < sizeof(buf)) /* everything is done */
372 40 : return (ustrp__sub_buf(p, ps1, pos, buf, rc));
373 :
374 12 : if (!ustrp__sub_undef(p, ps1, pos--, rc))
375 4 : return (USTR_FALSE);
376 :
377 8 : ptr = ustr_wstr(*ps1);
378 :
379 8 : save_end = ptr[pos + rc]; /* might be NIL, might be a char */
380 8 : USTR_CONF_VSNPRINTF_END(ptr + pos, rc + 1, fmt, ap);
381 8 : ptr[pos + rc] = save_end;
382 :
383 4 : USTR_ASSERT(ustrp__assert_valid(!!p, *ps1));
384 :
385 8 : return (USTR_TRUE);
386 : }
387 : USTR_CONF_I_PROTO int ustr_sub_vfmt_lim(struct Ustr **ps1,size_t pos,size_t lim,
388 : const char *fmt, va_list ap)
389 44 : { return (ustrp__sub_vfmt_lim(0, ps1, pos, lim, fmt, ap)); }
390 : USTR_CONF_I_PROTO
391 : int ustrp_sub_vfmt_lim(struct Ustr_pool *p,struct Ustrp **ps1, size_t pos,
392 : size_t lim, const char *fmt, va_list ap)
393 12 : {
394 12 : struct Ustr *tmp = &(*ps1)->s;
395 12 : int ret = ustrp__sub_vfmt_lim(p, &tmp, pos, lim, fmt, ap);
396 12 : *ps1 = USTRP(tmp);
397 12 : return (ret);
398 : }
399 :
400 : USTR_CONF_I_PROTO int ustr_sub_fmt_lim(struct Ustr **ps1, size_t pos,
401 : size_t lim, const char *fmt, ...)
402 20 : {
403 : va_list ap;
404 20 : int ret = USTR_FALSE;
405 :
406 20 : va_start(ap, fmt);
407 20 : ret = ustr_sub_vfmt_lim(ps1, pos, lim, fmt, ap);
408 20 : va_end(ap);
409 :
410 20 : return (ret);
411 : }
412 :
413 : USTR_CONF_I_PROTO
414 : int ustrp_sub_fmt_lim(struct Ustr_pool *p, struct Ustrp **ps1, size_t pos,
415 : size_t lim, const char*fmt, ...)
416 4 : {
417 : va_list ap;
418 4 : int ret = USTR_FALSE;
419 :
420 4 : va_start(ap, fmt);
421 4 : ret = ustrp_sub_vfmt_lim(p, ps1, pos, lim, fmt, ap);
422 4 : va_end(ap);
423 :
424 4 : return (ret);
425 : }
426 :
427 : USTR_CONF_I_PROTO int ustr_sub_vfmt(struct Ustr **ps1, size_t pos,
428 : const char *fmt, va_list ap)
429 24 : { return (ustr_sub_vfmt_lim(ps1, pos, 0, fmt, ap)); }
430 :
431 : USTR_CONF_I_PROTO int ustrp_sub_vfmt(struct Ustr_pool *p, struct Ustrp **ps1,
432 : size_t pos, const char *fmt, va_list ap)
433 8 : { return (ustrp_sub_vfmt_lim(p, ps1, pos, 0, fmt, ap)); }
434 :
435 : USTR_CONF_I_PROTO
436 : int ustr_sub_fmt(struct Ustr **ps1, size_t pos, const char *fmt, ...)
437 24 : {
438 : va_list ap;
439 24 : int ret = USTR_FALSE;
440 :
441 24 : va_start(ap, fmt);
442 24 : ret = ustr_sub_vfmt(ps1, pos, fmt, ap);
443 24 : va_end(ap);
444 :
445 24 : return (ret);
446 : }
447 :
448 : USTR_CONF_I_PROTO int ustrp_sub_fmt(struct Ustr_pool *p, struct Ustrp **ps1,
449 : size_t pos, const char *fmt, ...)
450 8 : {
451 : va_list ap;
452 8 : int ret = USTR_FALSE;
453 :
454 8 : va_start(ap, fmt);
455 8 : ret = ustrp_sub_vfmt(p, ps1, pos, fmt, ap);
456 8 : va_end(ap);
457 :
458 8 : return (ret);
459 : }
460 :
461 : USTR_CONF_i_PROTO
462 : int ustrp__sc_sub_vfmt_lim(struct Ustr_pool *p, struct Ustr **ps1, size_t pos,
463 : size_t len, size_t lim, const char *fmt, va_list ap)
464 52 : { /* NOTE: Copy and pasted so we can use ustrp_set_undef() */
465 : va_list nap;
466 52 : int rc = -1;
467 : char buf[USTR__SNPRINTF_LOCAL];
468 : char *ptr;
469 : char save_end;
470 :
471 52 : USTR__VA_COPY(nap, ap);
472 52 : rc = USTR_CONF_VSNPRINTF_BEG(buf, sizeof(buf), fmt, nap);
473 52 : va_end(nap);
474 :
475 52 : if ((rc == -1) && ((rc = ustr__retard_vfmt_ret(fmt, ap)) == -1))
476 4 : return (USTR_FALSE);
477 :
478 48 : if (lim && ((size_t)rc > lim))
479 16 : rc = lim;
480 :
481 48 : if ((size_t)rc < sizeof(buf)) /* everything is done */
482 40 : return (ustrp__sc_sub_buf(p, ps1, pos, len, buf, rc));
483 :
484 8 : if (!ustrp__sc_sub_undef(p, ps1, pos--, len, rc))
485 4 : return (USTR_FALSE);
486 :
487 4 : ptr = ustr_wstr(*ps1);
488 :
489 4 : save_end = ptr[pos + rc]; /* might be NIL if at end, might be a char */
490 4 : USTR_CONF_VSNPRINTF_END(ptr + pos, rc + 1, fmt, ap);
491 4 : ptr[pos + rc] = save_end;
492 :
493 2 : USTR_ASSERT(ustrp__assert_valid(!!p, *ps1));
494 :
495 4 : return (USTR_TRUE);
496 : }
497 : USTR_CONF_I_PROTO
498 : int ustr_sc_sub_vfmt_lim(struct Ustr **ps1,size_t pos, size_t len,
499 : size_t lim, const char *fmt, va_list ap)
500 40 : { return (ustrp__sc_sub_vfmt_lim(0, ps1, pos, len, lim, fmt, ap)); }
501 : USTR_CONF_I_PROTO
502 : int ustrp_sc_sub_vfmt_lim(struct Ustr_pool *p,struct Ustrp **ps1, size_t pos,
503 : size_t len, size_t lim, const char *fmt, va_list ap)
504 12 : {
505 12 : struct Ustr *tmp = &(*ps1)->s;
506 12 : int ret = ustrp__sc_sub_vfmt_lim(p, &tmp, pos, len, lim, fmt, ap);
507 12 : *ps1 = USTRP(tmp);
508 12 : return (ret);
509 : }
510 :
511 : USTR_CONF_I_PROTO
512 : int ustr_sc_sub_fmt_lim(struct Ustr **ps1, size_t pos, size_t len,
513 : size_t lim, const char *fmt, ...)
514 28 : {
515 : va_list ap;
516 28 : int ret = USTR_FALSE;
517 :
518 28 : va_start(ap, fmt);
519 28 : ret = ustr_sc_sub_vfmt_lim(ps1, pos, len, lim, fmt, ap);
520 28 : va_end(ap);
521 :
522 28 : return (ret);
523 : }
524 :
525 : USTR_CONF_I_PROTO
526 : int ustrp_sc_sub_fmt_lim(struct Ustr_pool *p, struct Ustrp **ps1, size_t pos,
527 : size_t len, size_t lim, const char*fmt, ...)
528 4 : {
529 : va_list ap;
530 4 : int ret = USTR_FALSE;
531 :
532 4 : va_start(ap, fmt);
533 4 : ret = ustrp_sc_sub_vfmt_lim(p, ps1, pos, len, lim, fmt, ap);
534 4 : va_end(ap);
535 :
536 4 : return (ret);
537 : }
538 :
539 : USTR_CONF_I_PROTO int ustr_sc_sub_vfmt(struct Ustr **ps1, size_t pos,
540 : size_t len, const char *fmt, va_list ap)
541 12 : { return (ustr_sc_sub_vfmt_lim(ps1, pos, len, 0, fmt, ap)); }
542 :
543 : USTR_CONF_I_PROTO
544 : int ustrp_sc_sub_vfmt(struct Ustr_pool *p, struct Ustrp **ps1,
545 : size_t pos, size_t len, const char *fmt, va_list ap)
546 8 : { return (ustrp_sc_sub_vfmt_lim(p, ps1, pos, len, 0, fmt, ap)); }
547 :
548 : USTR_CONF_I_PROTO int ustr_sc_sub_fmt(struct Ustr **ps1, size_t pos, size_t len,
549 : const char *fmt, ...)
550 12 : {
551 : va_list ap;
552 12 : int ret = USTR_FALSE;
553 :
554 12 : va_start(ap, fmt);
555 12 : ret = ustr_sc_sub_vfmt(ps1, pos, len, fmt, ap);
556 12 : va_end(ap);
557 :
558 12 : return (ret);
559 : }
560 :
561 : USTR_CONF_I_PROTO
562 : int ustrp_sc_sub_fmt(struct Ustr_pool *p, struct Ustrp **ps1,
563 : size_t pos, size_t len, const char *fmt, ...)
564 8 : {
565 : va_list ap;
566 8 : int ret = USTR_FALSE;
567 :
568 8 : va_start(ap, fmt);
569 8 : ret = ustrp_sc_sub_vfmt(p, ps1, pos, len, fmt, ap);
570 8 : va_end(ap);
571 :
572 8 : return (ret);
573 : }
574 : # endif
575 : #endif
|
