ustr-set-code.h
#ifndef USTR_SET_H
#error " You should have already included ustr-set.h, or just include ustr.h."
#endif
USTR_CONF_i_PROTO
int ustrp__set_undef(struct Ustr_pool *p, struct Ustr **ps1, size_t nlen)
{
struct Ustr *s1 = USTR_NULL;
struct Ustr *ret = USTR_NULL;
size_t clen = 0;
size_t sz = 0;
size_t oh = 0;
size_t osz = 0;
size_t nsz = 0;
int alloc = USTR_FALSE;
USTR_ASSERT(ps1 && ustrp__assert_valid(!!p, *ps1));
s1 = *ps1;
clen = ustr_len(s1);
if (nlen == clen)
{
if (ustr_owner(s1))
return (USTR_TRUE);
}
else if (ustr__rw_mod(s1, nlen, &sz, &oh, &osz, &nsz, &alloc))
{
if (nlen > clen)
return (ustrp__add_undef(p, ps1, (nlen - clen)));
else
return (ustrp__del(p, ps1, (clen - nlen)));
}
else if (ustr_limited(s1))
goto fail_enomem;
if (!(ret = ustrp__dupx_undef(p, USTR__DUPX_FROM(s1), nlen)))
goto fail_enomem;
ustrp__sc_free2(p, ps1, ret);
return (USTR_TRUE);
fail_enomem:
ustr_setf_enomem_err(s1);
return (USTR_FALSE);
}
USTR_CONF_I_PROTO int ustr_set_undef(struct Ustr **ps1, size_t nlen)
{ return (ustrp__set_undef(0, ps1, nlen)); }
USTR_CONF_I_PROTO
int ustrp_set_undef(struct Ustr_pool *p, struct Ustrp **ps1, size_t nlen)
{
struct Ustr *tmp = &(*ps1)->s;
int ret = ustrp__set_undef(p, &tmp, nlen);
*ps1 = USTRP(tmp);
return (ret);
}
USTR_CONF_i_PROTO int ustrp__set_empty(struct Ustr_pool *p, struct Ustr **ps1)
{
struct Ustr *ret = USTR_NULL;
USTR_ASSERT(ps1 && ustrp__assert_valid(!!p, *ps1));
if (ustr_sized(*ps1) && ustr_owner(*ps1))
return (ustrp__del(p, ps1, ustr_len(*ps1)));
if (!(ret = ustrp__dupx_empty(p, USTR__DUPX_FROM(*ps1))))
{
ustr_setf_enomem_err(*ps1);
return (USTR_FALSE);
}
ustrp__sc_free2(p, ps1, ret);
return (USTR_TRUE);
}
USTR_CONF_I_PROTO int ustr_set_empty(struct Ustr **ps1)
{ return (ustrp__set_empty(0, ps1)); }
USTR_CONF_I_PROTO int ustrp_set_empty(struct Ustr_pool *p, struct Ustrp **ps1)
{
struct Ustr *tmp = &(*ps1)->s;
int ret = ustrp__set_empty(p, &tmp);
*ps1 = USTRP(tmp);
return (ret);
}
USTR_CONF_i_PROTO int ustrp__set_buf(struct Ustr_pool *p, struct Ustr **ps1,
const void *buf, size_t len)
{
USTR_ASSERT(ps1 && ustrp__assert_valid(!!p, *ps1));
if (!ustrp__set_undef(p, ps1, len))
return (USTR_FALSE);
ustr__memcpy(*ps1, 0, buf, len);
USTR_ASSERT(ustrp__assert_valid(!!p, *ps1));
return (USTR_TRUE);
}
USTR_CONF_I_PROTO
int ustr_set_buf(struct Ustr **ps1, const void *buf, size_t len)
{ return (ustrp__set_buf(0, ps1, buf, len)); }
USTR_CONF_I_PROTO int ustrp_set_buf(struct Ustr_pool *p, struct Ustrp **ps1,
const void *buf, size_t len)
{
struct Ustr *tmp = &(*ps1)->s;
int ret = ustrp__set_buf(p, &tmp, buf, len);
*ps1 = USTRP(tmp);
return (ret);
}
USTR_CONF_i_PROTO
int ustrp__set(struct Ustr_pool *p, struct Ustr **ps1, const struct Ustr *s2)
{
struct Ustr *ret = USTR_NULL;
USTR_ASSERT(ps1 &&
ustrp__assert_valid(!!p, *ps1) && ustrp__assert_valid(!!p, s2));
if (*ps1 == s2)
return (USTR_TRUE);
if (ustr__treat_as_buf(*ps1, 0, ustr_len(s2)))
return (ustrp__set_buf(p, ps1, ustr_cstr(s2), ustr_len(s2)));
if (!(ret = ustrp__dupx(p, USTR__DUPX_FROM(*ps1), s2)))
{
ustr_setf_enomem_err(*ps1);
return (USTR_FALSE);
}
ustrp__sc_free2(p, ps1, ret);
return (USTR_TRUE);
}
USTR_CONF_I_PROTO int ustr_set(struct Ustr **ps1, const struct Ustr *s2)
{ return (ustrp__set(0, ps1, s2)); }
USTR_CONF_I_PROTO
int ustrp_set(struct Ustr_pool *p, struct Ustrp **ps1, const struct Ustrp *s2)
{
struct Ustr *tmp = &(*ps1)->s;
int ret = ustrp__set(p, &tmp, &s2->s);
*ps1 = USTRP(tmp);
return (ret);
}
USTR_CONF_i_PROTO
int ustrp__set_subustr(struct Ustr_pool *p, struct Ustr **ps1,
const struct Ustr *s2, size_t pos, size_t len)
{
size_t clen = 0;
USTR_ASSERT(ps1 && ustrp__assert_valid(!!p, *ps1));
if (!len)
return (ustrp__del(p, ps1, ustr_len(*ps1)));
clen = ustrp__assert_valid_subustr(!!p, s2, pos, len);
if (!clen)
return (USTR_FALSE);
if (len == clen)
return (ustrp__set(p, ps1, s2));
if ((*ps1 == s2) && ustr_owner(s2) && ustr_alloc(s2))
{
--pos;
ustrp__del(p, ps1, clen - (pos + len));
ustrp__del_subustr(p, ps1, 1, pos);
return (USTR_TRUE);
}
return (ustrp__set_buf(p, ps1, ustr_cstr(s2) + pos - 1, len));
}
USTR_CONF_I_PROTO int ustr_set_subustr(struct Ustr **ps1, const struct Ustr *s2,
size_t pos, size_t len)
{ return (ustrp__set_subustr(0, ps1, s2, pos, len)); }
USTR_CONF_I_PROTO
int ustrp_set_subustrp(struct Ustr_pool *p, struct Ustrp **ps1,
const struct Ustrp *s2, size_t pos, size_t len)
{
struct Ustr *tmp = &(*ps1)->s;
int ret = ustrp__set_subustr(p, &tmp, &s2->s, pos, len);
*ps1 = USTRP(tmp);
return (ret);
}
USTR_CONF_i_PROTO int ustrp__set_rep_chr(struct Ustr_pool *p, struct Ustr **ps1,
char chr, size_t len)
{
USTR_ASSERT(ps1 && ustrp__assert_valid(!!p, *ps1));
if (!ustrp__set_undef(p, ps1, len))
return (USTR_FALSE);
ustr__memset(*ps1, 0, chr, len);
USTR_ASSERT(ustrp__assert_valid(!!p, *ps1));
return (USTR_TRUE);
}
USTR_CONF_I_PROTO
int ustr_set_rep_chr(struct Ustr **ps1, char chr, size_t len)
{ return (ustrp__set_rep_chr(0, ps1, chr, len)); }
USTR_CONF_I_PROTO int ustrp_set_rep_chr(struct Ustr_pool *p, struct Ustrp **ps1,
char chr, size_t len)
{
struct Ustr *tmp = &(*ps1)->s;
int ret = ustrp__set_rep_chr(p, &tmp, chr, len);
*ps1 = USTRP(tmp);
return (ret);
}
#ifdef USTR_FMT_H
# if USTR_CONF_HAVE_VA_COPY
USTR_CONF_i_PROTO
int ustrp__set_vfmt_lim(struct Ustr_pool *p, struct Ustr **ps1, size_t lim,
const char *fmt, va_list ap)
{
va_list nap;
int rc = -1;
char buf[USTR__SNPRINTF_LOCAL];
USTR__VA_COPY(nap, ap);
rc = USTR_CONF_VSNPRINTF_BEG(buf, sizeof(buf), fmt, nap);
va_end(nap);
if ((rc == -1) && ((rc = ustr__retard_vfmt_ret(fmt, ap)) == -1))
return (USTR_FALSE);
if (lim && ((size_t)rc > lim))
rc = lim;
if ((size_t)rc < sizeof(buf))
return (ustrp__set_buf(p, ps1, buf, rc));
if (!ustrp__set_undef(p, ps1, rc))
return (USTR_FALSE);
USTR_CONF_VSNPRINTF_END(ustr_wstr(*ps1), rc + 1, fmt, ap);
USTR_ASSERT(ustrp__assert_valid(!!p, *ps1));
return (USTR_TRUE);
}
USTR_CONF_I_PROTO int ustr_set_vfmt_lim(struct Ustr **ps1, size_t lim,
const char *fmt, va_list ap)
{ return (ustrp__set_vfmt_lim(0, ps1, lim, fmt, ap)); }
USTR_CONF_I_PROTO
int ustrp_set_vfmt_lim(struct Ustr_pool *p,struct Ustrp **ps1, size_t lim,
const char *fmt, va_list ap)
{
struct Ustr *tmp = &(*ps1)->s;
int ret = ustrp__set_vfmt_lim(p, &tmp, lim, fmt, ap);
*ps1 = USTRP(tmp);
return (ret);
}
USTR_CONF_I_PROTO
int ustr_set_fmt_lim(struct Ustr **ps1, size_t lim, const char *fmt, ...)
{
va_list ap;
int ret = USTR_FALSE;
va_start(ap, fmt);
ret = ustr_set_vfmt_lim(ps1, lim, fmt, ap);
va_end(ap);
return (ret);
}
USTR_CONF_I_PROTO
int ustrp_set_fmt_lim(struct Ustr_pool *p, struct Ustrp **ps1, size_t lim,
const char*fmt, ...)
{
va_list ap;
int ret = USTR_FALSE;
va_start(ap, fmt);
ret = ustrp_set_vfmt_lim(p, ps1, lim, fmt, ap);
va_end(ap);
return (ret);
}
USTR_CONF_I_PROTO int ustr_set_vfmt(struct Ustr **ps1,
const char *fmt, va_list ap)
{ return (ustr_set_vfmt_lim(ps1, 0, fmt, ap)); }
USTR_CONF_I_PROTO int ustrp_set_vfmt(struct Ustr_pool *p, struct Ustrp **ps1,
const char *fmt, va_list ap)
{ return (ustrp_set_vfmt_lim(p, ps1, 0, fmt, ap)); }
USTR_CONF_I_PROTO int ustr_set_fmt(struct Ustr **ps1, const char *fmt, ...)
{
va_list ap;
int ret = USTR_FALSE;
va_start(ap, fmt);
ret = ustr_set_vfmt(ps1, fmt, ap);
va_end(ap);
return (ret);
}
USTR_CONF_I_PROTO int ustrp_set_fmt(struct Ustr_pool *p, struct Ustrp **ps1,
const char *fmt, ...)
{
va_list ap;
int ret = USTR_FALSE;
va_start(ap, fmt);
ret = ustrp_set_vfmt(p, ps1, fmt, ap);
va_end(ap);
return (ret);
}
# endif
#endif