void xfail_tst(void)
{
vstr_add_rep_chr(s1, 0, 'x', 8);
vstr_add_cstr_buf(s2, s2->len, "aB");
ASSERT(!vstr_srch_case_vstr_fwd(s1, 1, 8, s2, 4, s2->len));
}
int main(int argc, char *argv[])
{
Vstr_base *s1 = ex_init(NULL);
mpz_t bignum;
const char *loc_num_name = NULL;
Vstr_ref *ref = NULL;
const unsigned int num_flags = (VSTR_FLAG_PARSE_NUM_SEP |
VSTR_FLAG_PARSE_NUM_SPACE);
if (argc < 2)
errx(EXIT_FAILURE, "No count specified");
vstr_cntl_conf(s1->conf, VSTR_CNTL_CONF_SET_FMT_CHAR_ESC, '$');
vstr_fmt_add(s1->conf, "<dMPZ:%p>", ex_usr_dmpz_cb,
VSTR_TYPE_FMT_PTR_VOID, VSTR_TYPE_FMT_END);
vstr_fmt_add(s1->conf, "<oMPZ:%p>", ex_usr_ompz_cb,
VSTR_TYPE_FMT_PTR_VOID, VSTR_TYPE_FMT_END);
vstr_fmt_add(s1->conf, "<xMPZ:%p>", ex_usr_xmpz_cb,
VSTR_TYPE_FMT_PTR_VOID, VSTR_TYPE_FMT_END);
vstr_fmt_add(s1->conf, "<bMPZ:%p>", ex_usr_bmpz_cb,
VSTR_TYPE_FMT_PTR_VOID, VSTR_TYPE_FMT_END);
setlocale(LC_ALL, "");
loc_num_name = setlocale(LC_NUMERIC, NULL);
if (!vstr_cntl_conf(s1->conf, VSTR_CNTL_CONF_SET_LOC_CSTR_AUTO_NAME_NUMERIC,
loc_num_name))
errx(EXIT_FAILURE, "Couldn't change numeric locale info");
mpz_init(bignum);
if (!vstr_add_cstr_ptr(s1, 0, argv[1]) ||
!vstr_parse_num(s1, 1, s1->len, num_flags, NULL, NULL, vmpz_num, bignum))
errno = ENOMEM, err(EXIT_FAILURE, "Couldn't init number");
vstr_del(s1, 1, s1->len);
#if (EX_GMP_NUMS_USE_TST)
{
mpz_abs(bignum, bignum);
mpz_neg(bignum, bignum);
do
{
mpz_neg(bignum, bignum);
vstr_add_fmt(s1, s1->len, "%%'20.40d = <$'20.40<dMPZ:%p>>\n",
(void *)bignum);
if (mpz_fits_slong_p(bignum))
vstr_add_fmt(s1, s1->len, "%%'20.40d = <%'20.40ld>\n",
mpz_get_si(bignum));
vstr_add_fmt(s1, s1->len, "%%'40.20d = <$'40.20<dMPZ:%p>>\n",
(void *)bignum);
if (mpz_fits_slong_p(bignum))
vstr_add_fmt(s1, s1->len, "%%'40.20d = <%'40.20ld>\n",
mpz_get_si(bignum));
vstr_add_fmt(s1, s1->len, "%%'20.40o = <$'20.40<oMPZ:%p>>\n",
(void *)bignum);
if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum))
vstr_add_fmt(s1, s1->len, "%%'20.40o = <%'20.40lo>\n",
mpz_get_si(bignum));
vstr_add_fmt(s1, s1->len, "%%'40.20o = <$'40.20<oMPZ:%p>>\n",
(void *)bignum);
if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum))
vstr_add_fmt(s1, s1->len, "%%'40.20o = <%'40.20lo>\n",
mpz_get_si(bignum));
vstr_add_fmt(s1, s1->len, "%%'20.40x = <$'20.40<xMPZ:%p>>\n",
(void *)bignum);
if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum))
vstr_add_fmt(s1, s1->len, "%%'20.40x = <%'20.40lx>\n",
mpz_get_si(bignum));
vstr_add_fmt(s1, s1->len, "%%'40.20x = <$'40.20<xMPZ:%p>>\n",
(void *)bignum);
if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum))
vstr_add_fmt(s1, s1->len, "%%'40.20x = <%'40.20lx>\n",
mpz_get_si(bignum));
vstr_add_fmt(s1, s1->len, "%%#'40d = <$#'40<dMPZ:%p>>\n",
(void *)bignum);
if (mpz_fits_slong_p(bignum))
vstr_add_fmt(s1, s1->len, "%%#'40d = <%#'40ld>\n",
mpz_get_si(bignum));
vstr_add_fmt(s1, s1->len, "%%#'-40d = <$#'-40<dMPZ:%p>>\n",
(void *)bignum);
if (mpz_fits_slong_p(bignum))
vstr_add_fmt(s1, s1->len, "%%#'-40d = <%#'-40ld>\n",
mpz_get_si(bignum));
vstr_add_fmt(s1, s1->len, "%%#'40o = <$#'40<oMPZ:%p>>\n",
(void *)bignum);
if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum))
vstr_add_fmt(s1, s1->len, "%%#'40o = <%#'40lo>\n",
mpz_get_si(bignum));
vstr_add_fmt(s1, s1->len, "%%#'-40o = <$#'-40<oMPZ:%p>>\n",
(void *)bignum);
if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum))
vstr_add_fmt(s1, s1->len, "%%#'-40o = <%#'-40lo>\n",
mpz_get_si(bignum));
vstr_add_fmt(s1, s1->len, "%%#'40x = <$#'40<xMPZ:%p>>\n",
(void *)bignum);
if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum))
vstr_add_fmt(s1, s1->len, "%%#'40x = <%#'40lx>\n",
mpz_get_si(bignum));
vstr_add_fmt(s1, s1->len, "%%#'-40x = <$#'-40<xMPZ:%p>>\n",
(void *)bignum);
if ((mpz_sgn(bignum) != -1) && mpz_fits_slong_p(bignum))
vstr_add_fmt(s1, s1->len, "%%#'-40x = <%#'-40lx>\n",
mpz_get_si(bignum));
vstr_add_fmt(s1, s1->len, "%%#'b = <$#'<bMPZ:%p>>\n",
(void *)bignum);
vstr_add_rep_chr(s1, s1->len, '-', 79);
vstr_add_rep_chr(s1, s1->len, '\n', 1);
} while (mpz_sgn(bignum) > 0);
mpz_abs(bignum, bignum);
}
#endif
if (!(ref = vstr_ref_make_strdup("_")))
errno = ENOMEM, err(EXIT_FAILURE, "Ref seperator");
if (!vstr_cntl_conf(NULL, VSTR_CNTL_CONF_SET_LOC_REF_THOU_SEP, 2, ref, 1) ||
!vstr_cntl_conf(NULL, VSTR_CNTL_CONF_SET_LOC_REF_THOU_SEP, 8, ref, 1) ||
!vstr_cntl_conf(NULL, VSTR_CNTL_CONF_SET_LOC_REF_THOU_SEP, 16, ref, 1) ||
FALSE)
errno = ENOMEM, err(EXIT_FAILURE, "Add seperator");
vstr_ref_del(ref);
if (!(ref = vstr_ref_make_strdup("\4")))
errno = ENOMEM, err(EXIT_FAILURE, "Ref grouping");
if (!vstr_cntl_conf(NULL, VSTR_CNTL_CONF_SET_LOC_REF_THOU_GRP, 2, ref) ||
!vstr_cntl_conf(NULL, VSTR_CNTL_CONF_SET_LOC_REF_THOU_GRP, 16, ref) ||
FALSE)
errno = ENOMEM, err(EXIT_FAILURE, "Add grouping");
vstr_ref_del(ref);
vstr_add_fmt(s1, s1->len, " Input: %s\n", argv[1]);
vstr_add_fmt(s1, s1->len, " %%#'x = $#'<xMPZ:%p>\n",
(void *)bignum);
vstr_add_fmt(s1, s1->len, " %%#'d = $#'<dMPZ:%p>\n",
(void *)bignum);
vstr_add_fmt(s1, s1->len, " %%#'o = $#'<oMPZ:%p>\n",
(void *)bignum);
vstr_add_fmt(s1, s1->len, " %%#'b = $#'<bMPZ:%p>\n",
(void *)bignum);
if (s1->conf->malloc_bad)
errno = ENOMEM, err(EXIT_FAILURE, "Add string data");
io_put_all(s1, STDOUT_FILENO);
exit (ex_exit(s1, NULL));
}
int vstr_x_conv_base64_encode(Vstr_base *dst, size_t dpos,
const Vstr_base *src, size_t spos, size_t slen,
unsigned int flags)
{
unsigned char sbuf[3];
unsigned char dbuf[4];
size_t orig_dpos = dpos;
size_t orig_dlen = dst->len;
unsigned int nonl = 76 / 4;
while (slen)
{
unsigned int i24 = 0;
unsigned int used = 3;
/* operate on 24 bits at once, zero extending */
/* 3 8bit bytes IN */
if (slen >= 3)
vstr_export_buf(src, spos, used, sbuf, sizeof(sbuf));
else
{
vstr_export_buf(src, spos, slen, sbuf, sizeof(sbuf));
switch (used = slen)
{
case 1: sbuf[1] = 0;
case 2: sbuf[2] = 0;
ASSERT_NO_SWITCH_DEF();
}
}
i24 |= sbuf[0]; i24 <<= 8;
i24 |= sbuf[1]; i24 <<= 8;
i24 |= sbuf[2];
/* 4 6bit "bytes" OUT */
ASSERT(sizeof(b64) == 64);
ASSERT(((i24 & 0x00FC0000) >> 18) < 64);
ASSERT(((i24 & 0x0003F000) >> 12) < 64);
ASSERT(((i24 & 0x00000FC0) >> 6) < 64);
ASSERT(((i24 & 0x0000003F) < 64));
dbuf[0] = (i24 & 0x00FC0000) >> 18; dbuf[0] = b64[dbuf[0]];
dbuf[1] = (i24 & 0x0003F000) >> 12; dbuf[1] = b64[dbuf[1]];
dbuf[2] = (i24 & 0x00000FC0) >> 6; dbuf[2] = b64[dbuf[2]];
dbuf[3] = (i24 & 0x0000003F); dbuf[3] = b64[dbuf[3]];
if (used == 3)
{
if (!vstr_add_buf(dst, dpos, dbuf, sizeof(dbuf)))
goto failed_add;
dpos += sizeof(dbuf);
}
else
{ /* if we didn't use 3 8bit bytes, we are at the end ... so do special
* case for = byte endings */
unsigned int out_map[3] = {0, 2, 3};
ASSERT(used && (out_map[used] <= sizeof(dbuf)));
if (!vstr_add_buf(dst, dpos, dbuf, out_map[used]))
goto failed_add;
dpos += out_map[used];
if (!vstr_add_rep_chr(dst, dpos, '=', 4 - out_map[used]))
goto failed_add;
dpos += 4 - out_map[used];
}
slen -= used; spos += used;
if (flags && (!--nonl || !slen)) /* ever 76 output bytes, newline */
{
nonl = 76 / 4;
if (!vstr_add_cstr_buf(dst, dpos, "\n"))
goto failed_add;
++dpos;
}
}
return (TRUE);
failed_add:
vstr_del(dst, orig_dpos, dst->len - orig_dlen);
return (FALSE);
}
int tst(void)
{
unsigned int scan = 1;
size_t pos = 1;
while (scan <= 111)
vstr_add_rep_chr(s1, s1->len, scan++, 1);
vstr_add_non(s1, s1->len, 11);
scan += 11;
while (scan <= 255)
vstr_add_rep_chr(s1, s1->len, scan++, 1);
vstr_add_rep_chr(s1, s1->len, 0, 11);
ASSERT(s1->len == 266);
{
Vstr_iter iter[1];
ASSERT(vstr_iter_fwd_beg(s1, 1, s1->len, iter));
ASSERT(iter->num == 1);
ASSERT(vstr_iter_len(iter) == 266);
ASSERT(vstr_iter_fwd_nxt(iter));
ASSERT(!vstr_iter_fwd_beg(s1, 1, 0, iter));
ASSERT(!iter->node);
}
while (pos <= 266)
{
Vstr_iter iter[1];
unsigned int ern;
size_t len = vstr_sc_posdiff(pos, 266);
ASSERT(vstr_iter_fwd_beg(s1, pos, len, iter));
ASSERT(vstr_iter_pos(iter, pos, len) == pos);
ASSERT(vstr_iter_len(iter) == len);
scan = pos;
while (scan <= 266)
{
unsigned char val = 0;
ASSERT(vstr_iter_pos(iter, pos, len) == scan);
ASSERT(vstr_iter_len(iter) == vstr_sc_posdiff(scan, 266));
val = vstr_iter_fwd_chr(iter, &ern);
ASSERT(ern != VSTR_TYPE_ITER_END);
ASSERT((ern == VSTR_TYPE_ITER_NON) || (ern == VSTR_TYPE_ITER_DEF));
if (ern != VSTR_TYPE_ITER_NON)
ASSERT((val == scan) || ((val == 0) && (scan >= 256) && (scan <= 266)));
else
ASSERT((scan > 111) && (scan <= 123) && (val == 0));
++scan;
}
ASSERT(!vstr_iter_len(iter));
ASSERT(!vstr_iter_fwd_chr(iter, &ern) && (ern == VSTR_TYPE_ITER_END));
ASSERT(!vstr_iter_fwd_chr(iter, &ern) && (ern == VSTR_TYPE_ITER_END));
ASSERT(!vstr_iter_fwd_chr(iter, &ern) && (ern == VSTR_TYPE_ITER_END));
ASSERT(!vstr_iter_fwd_chr(iter, &ern) && (ern == VSTR_TYPE_ITER_END));
ASSERT(!vstr_iter_len(iter));
++pos;
}
/* tst for fwd_buf/fwd_cstr */
{
Vstr_iter iter[1];
unsigned int ern;
ASSERT(vstr_iter_fwd_beg(s1, 1, s1->len, iter));
ASSERT(vstr_iter_pos(iter, 1, s1->len) == 1);
ASSERT(vstr_iter_len(iter) == s1->len);
ASSERT(vstr_iter_fwd_buf(iter, 1, NULL, 0, NULL) == 1);
ASSERT(vstr_iter_pos(iter, 1, s1->len) == 2);
ASSERT(vstr_iter_len(iter) == (s1->len - 1));
ASSERT(vstr_iter_fwd_buf(iter, 265, NULL, 0, NULL) == 265);
ASSERT(!vstr_iter_len(iter));
ASSERT(!vstr_iter_fwd_chr(iter, &ern) && (ern == VSTR_TYPE_ITER_END));
memset(buf, 114, sizeof(buf));
ASSERT(vstr_iter_fwd_beg(s1, 1, s1->len, iter));
ASSERT(vstr_iter_fwd_buf(iter, 267, buf, sizeof(buf), &ern) == 266);
ASSERT(ern == VSTR_TYPE_ITER_DEF);
ASSERT(vstr_iter_fwd_buf(iter, 263, buf, 1, &ern) == 0);
ASSERT(ern == VSTR_TYPE_ITER_END);
ASSERT(vstr_iter_fwd_beg(s1, 1, s1->len, iter));
scan = 0;
while (scan < 111)
ASSERT(buf[scan++] == vstr_iter_fwd_chr(iter, NULL));
ASSERT(vstr_iter_fwd_buf(iter, 11, NULL, 0, NULL) == 11);
while (scan < 122)
ASSERT(buf[scan++] == 114);
while (scan < 255)
ASSERT(buf[scan++] == vstr_iter_fwd_chr(iter, NULL));
while (scan < 266)
ASSERT(buf[scan++] == 0);
ASSERT(vstr_iter_fwd_beg(s1, 2, 110, iter));
ASSERT(vstr_iter_fwd_cstr(iter, 263, buf, sizeof(buf), &ern) == 110);
ASSERT(vstr_iter_fwd_beg(s1, 2, 110, iter));
scan = 0;
while (scan < 110)
ASSERT(buf[scan++] == vstr_iter_fwd_chr(iter, NULL));
ASSERT(buf[scan] == 0);
ASSERT(vstr_iter_fwd_beg(s1, 4, 2, iter));
ASSERT(vstr_iter_fwd_cstr(iter, 263, buf, 2, &ern) == 2);
ASSERT(buf[0] == 4);
ASSERT(buf[1] == 0);
}
return (EXIT_SUCCESS);
}
int tst(void)
{
int ret = 0;
int mfail_count = 0;
sprintf(buf, "%d %d %u %u", INT_MAX, INT_MIN, 0, UINT_MAX);
/* 1 */
VSTR_ADD_CSTR_BUF(s2, 0, buf);
VSTR_ADD_CSTR_BUF(s3, 0, buf);
vstr_mov(s1, 0, s2, 1, s2->len);
TST_B_TST(ret, 1, !VSTR_CMP_CSTR_EQ(s1, 1, s1->len, buf));
vstr_del(s1, 1, s1->len);
vstr_mov(s1, 0, s3, 1, s3->len);
TST_B_TST(ret, 2, !VSTR_CMP_CSTR_EQ(s1, 1, s1->len, buf));
vstr_del(s1, 1, s1->len);
/* 2 */
VSTR_ADD_CSTR_PTR(s2, 0, buf);
VSTR_ADD_CSTR_PTR(s3, 0, buf);
vstr_mov(s1, 0, s2, 1, s2->len);
TST_B_TST(ret, 3, !VSTR_CMP_CSTR_EQ(s1, 1, s1->len, buf));
vstr_del(s1, 1, s1->len);
vstr_mov(s1, 0, s3, 1, s3->len);
TST_B_TST(ret, 4, !VSTR_CMP_CSTR_EQ(s1, 1, s1->len, buf));
vstr_del(s1, 1, s1->len);
/* 3 */
VSTR_ADD_CSTR_BUF(s2, 0, buf);
VSTR_ADD_CSTR_BUF(s3, 0, buf);
vstr_mov(s1, 0, s2, 9, s2->len - 8);
vstr_mov(s1, 0, s2, 1, 8);
TST_B_TST(ret, 5, !VSTR_CMP_CSTR_EQ(s1, 1, s1->len, buf));
vstr_del(s1, 1, s1->len);
vstr_mov(s1, 0, s3, 9, s3->len - 8);
vstr_mov(s1, 0, s3, 1, 8);
TST_B_TST(ret, 6, !VSTR_CMP_CSTR_EQ(s1, 1, s1->len, buf));
vstr_del(s1, 1, s1->len);
/* 4 */
VSTR_ADD_CSTR_PTR(s2, 0, buf);
VSTR_ADD_CSTR_PTR(s3, 0, buf);
vstr_mov(s1, 0, s2, 9, s2->len - 8);
vstr_mov(s1, 0, s2, 1, 8);
TST_B_TST(ret, 5, !VSTR_CMP_CSTR_EQ(s1, 1, s1->len, buf));
/* no delete */
TST_B_TST(ret, 7, !vstr_mov(s1, 0, s1, 1, s1->len));
TST_B_TST(ret, 8, !vstr_mov(s1, 8, s1, 1, s1->len));
TST_B_TST(ret, 9, !VSTR_CMP_CSTR_EQ(s1, 1, s1->len, buf));
vstr_del(s1, 1, s1->len);
VSTR_ADD_CSTR_PTR(s1, 0, buf);
TST_B_TST(ret, 10, !vstr_mov(s1, 4, s1, 8, s1->len - 7));
TST_B_TST(ret, 11, !vstr_mov(s3, s3->len, s3, 5, 3));
TST_B_TST(ret, 12, !VSTR_CMP_EQ(s1, 1, s1->len, s3, 1, s3->len));
TST_B_TST(ret, 13, !vstr_mov(s3, 4, s3, s3->len - 2, 3));
TST_B_TST(ret, 13, !vstr_mov(s1, 4, s1, s1->len - 2, 3));
TST_B_TST(ret, 15, !VSTR_CMP_EQ(s1, 1, s1->len, s3, 1, s3->len));
TST_B_TST(ret, 16, !VSTR_CMP_CSTR_EQ(s1, 1, s1->len, buf));
TST_B_TST(ret, 16, !vstr_add_rep_chr(s1, 0, 'x', 16));
TST_B_TST(ret, 16, !vstr_add_vstr(s1, 0, s1, 1, 16, VSTR_TYPE_ADD_BUF_PTR));
#ifndef VSTR_AUTOCONF_NDEBUG
/* split poisoning screws this up in debug mode ...
* should work ok otherwise */
TST_B_TST(ret, 16, !vstr_sub_cstr_ptr(s1, 1, 16, "xxxxxxxxxxxxxxxx"));
#endif
do
{
vstr_free_spare_nodes(s1->conf, VSTR_TYPE_NODE_BUF, 1000);
vstr_free_spare_nodes(s1->conf, VSTR_TYPE_NODE_PTR, 1000);
vstr_free_spare_nodes(s3->conf, VSTR_TYPE_NODE_BUF, 1000);
vstr_free_spare_nodes(s3->conf, VSTR_TYPE_NODE_PTR, 1000);
tst_mfail_num(++mfail_count);
} while (!vstr_mov(s3, 0, s1, 2, 8));
tst_mfail_num(0);
mfail_count = 0;
do
{
vstr_free_spare_nodes(s1->conf, VSTR_TYPE_NODE_BUF, 1000);
vstr_free_spare_nodes(s1->conf, VSTR_TYPE_NODE_PTR, 1000);
vstr_free_spare_nodes(s3->conf, VSTR_TYPE_NODE_BUF, 1000);
vstr_free_spare_nodes(s3->conf, VSTR_TYPE_NODE_PTR, 1000);
tst_mfail_num(++mfail_count);
} while (!vstr_mov(s3, 8, s1, 2, 8));
tst_mfail_num(0);
TST_B_TST(ret, 18, !VSTR_CMP_EQ(s1, 1, s1->len, s3, 1, s3->len));
TST_B_TST(ret, 19, !vstr_mov(s1, 4, s1, 9, 4));
TST_B_TST(ret, 20, !vstr_mov(s1, 4, s1, 9, 2));
TST_B_TST(ret, 21, !vstr_mov(s1, 6, s1, 9, 1));
TST_B_TST(ret, 22, !vstr_mov(s1, 7, s1, 9, 1));
TST_B_TST(ret, 23, !VSTR_CMP_EQ(s1, 1, s1->len, s3, 1, s3->len));
TST_B_TST(ret, 20, !vstr_mov(s1, 16, s1, 17 - 4, 2)); /* magic num */
TST_B_TST(ret, 21, !vstr_mov(s1, 16, s1, 17 - 4, 1));
TST_B_TST(ret, 22, !vstr_mov(s1, 16, s1, 17 - 4, 1));
TST_B_TST(ret, 23, !VSTR_CMP_EQ(s1, 1, s1->len, s3, 1, s3->len));
mfail_count = 0;
do
{
vstr_free_spare_nodes(s1->conf, VSTR_TYPE_NODE_BUF, 1000);
vstr_free_spare_nodes(s1->conf, VSTR_TYPE_NODE_PTR, 1000);
vstr_free_spare_nodes(s4->conf, VSTR_TYPE_NODE_BUF, 1000);
vstr_free_spare_nodes(s4->conf, VSTR_TYPE_NODE_PTR, 1000);
tst_mfail_num(++mfail_count);
} while (!vstr_mov(s4, 0, s1, 1, s1->len));
tst_mfail_num(0);
TST_B_TST(ret, 24, !VSTR_CMP_EQ(s3, 1, s3->len, s4, 1, s4->len));
{
unsigned int count = 0;
count = s4->len;
while (count > 0)
{
mfail_count = 0;
do
{
vstr_free_spare_nodes(s4->conf, VSTR_TYPE_NODE_BUF, 1000);
vstr_free_spare_nodes(s4->conf, VSTR_TYPE_NODE_PTR, 1000);
tst_mfail_num(++mfail_count);
} while (!vstr_mov(s4, 0, s4, s4->len, 1));
tst_mfail_num(0);
--count;
}
}
TST_B_TST(ret, 26, !VSTR_CMP_EQ(s3, 1, s3->len, s4, 1, s4->len));
return (TST_B_RET(ret));
}
