void runSuccess() {
char s1[] = "AAAA";
//@ assert \valid(s1+(0..\block_length(s1)-1));
//@ assert \exists integer x; s1[x] == '\0';
mbrlen(s1, 3, anystate());
mbrlen(s1, 4, NULL);
}
TEST(wchar, mbrlen) {
char bytes[] = { 'h', 'e', 'l', 'l', 'o', '\0' };
EXPECT_EQ(0U, mbrlen(&bytes[0], 0, NULL));
EXPECT_EQ(1U, mbrlen(&bytes[0], 1, NULL));
EXPECT_EQ(1U, mbrlen(&bytes[4], 1, NULL));
EXPECT_EQ(0U, mbrlen(&bytes[5], 1, NULL));
}
/* adjust pointed byte and find mbstate of the point of string.
adjusted point will be point <= adjusted_point, and returns
differences of the byte(adjusted_point - point).
if point is invalied (point < 0 || more than string length),
it returns -1 */
int
_rl_adjust_point(char *string, int point, mbstate_t *ps)
{
size_t tmp = 0;
size_t length;
int pos = 0;
length = strlen(string);
if (point < 0)
return -1;
if ((int)length < point)
return -1;
while (pos < point)
{
tmp = mbrlen((string + pos), (length - (size_t)pos), ps);
if((size_t)(tmp) == (size_t)-1L || (size_t)(tmp) == (size_t)-2L)
{
/* in this case, bytes are invalid or shorted to compose
multibyte char, so assume that the first byte represents
a single character anyway. */
pos++;
/* clear the state of the byte sequence, because
in this case effect of mbstate is undefined */
if (ps)
memset(ps, 0, sizeof(mbstate_t));
}
else if (tmp == 0)
pos++;
else
pos += (int)tmp;
}
return (pos - point);
}
static int ui_draw_chars(char *chars, int x, int y, uint16_t fg, uint16_t bg) {
int width = tb_width();
int pointer = 0;
int counter = 0;
int length;
mbstate_t state;
wchar_t ch;
// Initialize multi-byte state
mbrlen(NULL, 0, &state);
while (chars[pointer] != '\0') {
length = mbrtowc(&ch, chars + pointer, 4, &state);
tb_change_cell(x + pointer, y, ch, fg, bg);
pointer += length;
counter++;
}
// Draw spaces for the remaining of the line
for (int i = counter; i < width; i++) {
tb_change_cell(x + i, y, ' ', fg, bg);
}
return counter;
}
/*
* Parse a multibyte character out of the string, set it past the parsed
* character.
*/
static int
string_to_char(const char **stringp)
{
int result;
#ifdef USE_WIDE_CURSES
const char *string = *stringp;
size_t have = strlen(string);
size_t check;
size_t len;
wchar_t cmp2[2];
mbstate_t state;
memset(&state, 0, sizeof(state));
len = mbrlen(string, have, &state);
if ((int) len > 0 && len <= have) {
memset(&state, 0, sizeof(state));
memset(cmp2, 0, sizeof(cmp2));
check = mbrtowc(cmp2, string, len, &state);
if ((int) check <= 0)
cmp2[0] = 0;
*stringp += len;
} else {
cmp2[0] = UCH(*string);
*stringp += 1;
}
result = cmp2[0];
#else
const char *string = *stringp;
result = UCH(*string);
*stringp += 1;
#endif
return result;
}
int str_nextoff(const char *p, int opos)
{
if(ioncore_g.enc_sb)
return (*(p+opos)=='\0' ? 0 : 1);
if(ioncore_g.enc_utf8){
int pos=opos;
while(p[pos]){
pos++;
if((p[pos]&0xC0)!=0x80)
break;
}
return pos-opos;
}
assert(ioncore_g.use_mb);
{
mbstate_t ps;
int l;
memset(&ps, 0, sizeof(ps));
l=mbrlen(p+opos, strlen(p+opos), &ps);
if(l<0){
warn(TR("Invalid multibyte string."));
return 0;
}
return l;
}
}
size_t mymbslen(const char *s, size_t max_len) {
#if !defined(WIN32) && !defined(WIN64)
size_t result, pos = 0, len = 0;
mbstate_t mbstate;
memset(&mbstate, '\0', sizeof(mbstate));
while (pos < max_len) {
result = mbrlen(s + pos, max_len - pos, &mbstate);
if (result < (size_t)0) {
return -1;
}
if (result == 0) { /* L'\0' encountered */
return len;
}
pos += result;
len++;
}
return len;
#else
size_t len;
if (max_len == 0) {
return 0;
}
len = MultiByteToWideChar(CP_UTF8, 0, s, SIZE_T_TO_MAX_INT(max_len), NULL, 0);
return len == 0 ? -1 : len;
#endif
}
static char *
mbstrstr (const char *haystack, const char *needle)
{
#if DO_MULTIBYTE
if (MB_CUR_MAX > 1)
{
size_t hlen = strlen (haystack);
size_t nlen = strlen (needle);
mbstate_t mbstate;
size_t step;
memset (&mbstate, 0, sizeof (mbstate_t));
while (hlen >= nlen)
{
if (memcmp (haystack, needle, nlen) == 0)
return (char *) haystack;
step = mbrlen (haystack, hlen, &mbstate);
if (step <= 0)
break;
haystack += step;
hlen -= step;
}
return NULL;
}
#endif
return strstr (haystack, needle);
}
/* return the number of bytes parsed from the multibyte sequence starting
at src, if a non-L'\0' wide character was recognized. It returns 0,
if a L'\0' wide character was recognized. It returns (size_t)(-1),
if an invalid multibyte sequence was encountered. It returns (size_t)(-2)
if it couldn't parse a complete multibyte character. */
int
_rl_get_char_len(char *src, mbstate_t *ps)
{
size_t tmp;
tmp = mbrlen((const char *)src, (size_t)strlen(src), ps);
if (tmp == (size_t)(-2))
{
/* shorted to compose multibyte char */
if (ps)
memset (ps, 0, sizeof(mbstate_t));
return -2;
}
else if (tmp == (size_t)(-1))
{
/* invalid to compose multibyte char */
/* initialize the conversion state */
if (ps)
memset (ps, 0, sizeof(mbstate_t));
return -1;
}
else if (tmp == (size_t)0)
return 0;
else
return (int)tmp;
}
int FdoCommonOSUtil::ismbslead(const unsigned char *string, const unsigned char *current)
{
#ifdef _WIN32
return _ismbslead(string, current);
#else // _WIN32
mbstate_t pstate;
int i = 0;
int curPos = 0;
int inquiryPos = (int)(current - string);
int ret = 0;
memset(&pstate, 0, sizeof(pstate));
do
{
if (inquiryPos == curPos)
{
ret = -1;
break;
}
i = mbrlen((const char*)(string + curPos), MB_CUR_MAX, &pstate);
if (i < 0)
throw FdoException::Create(FdoException::NLSGetMessage(FDO_NLSID(FDO_1_INVALID_INPUT_ON_CLASS_FUNCTION),
L"FdoCommonOSUtil::ismbslead",
L"string"));
if (i > 0)
curPos += i;
}
while (i > 0);
return ret;
#endif
}
int
mblen(
const char *s,
size_t n
)
{
/* s may be NULL */
return (int)mbrlen(s, n, NULL);
}
/*
* Create a new binary string from a raw binary buffer.
*/
struct bwstring *
bwscsbdup(const unsigned char *str, size_t len)
{
struct bwstring *ret;
ret = bwsalloc(len);
if (str) {
if (MB_CUR_MAX == 1)
memcpy(ret->data.cstr, str, len);
else {
mbstate_t mbs;
const char *s;
size_t charlen, chars, cptr;
charlen = chars = 0;
cptr = 0;
s = (const char *) str;
memset(&mbs, 0, sizeof(mbs));
while (cptr < len) {
size_t n = MB_CUR_MAX;
if (n > len - cptr)
n = len - cptr;
charlen = mbrlen(s + cptr, n, &mbs);
switch (charlen) {
case 0:
/* FALLTHROUGH */
case (size_t) -1:
/* FALLTHROUGH */
case (size_t) -2:
ret->data.wstr[chars++] =
(unsigned char) s[cptr];
++cptr;
break;
default:
n = mbrtowc(ret->data.wstr + (chars++),
s + cptr, charlen, &mbs);
if ((n == (size_t)-1) || (n == (size_t)-2))
/* NOTREACHED */
err(2, "mbrtowc error");
cptr += charlen;
};
}
ret->len = chars;
ret->data.wstr[ret->len] = L'\0';
}
}
return (ret);
}
int _RTL_FUNC mblen(const char *s, size_t n)
{
size_t rv ;
if (!s || !*s)
return 0 ;
if (n ==0)
return -1 ;
rv = mbrlen(s,n,&__getRtlData()->mblen_st);
if (rv == (size_t)-2)
rv = (size_t)-1;
return (int)rv;
}
size_t _Locale_mbtowc(struct _Locale_ctype *l,
wchar_t *to,
const char *from, size_t n,
mbstate_t *shift_state)
{
int ret;
if (to)
ret = mbrtowc(to, from, n, shift_state);
else
ret = mbrlen(from, n, shift_state);
return ret;
}
static void
gl_transpose(void)
/* switch character under cursor and to left of cursor */
{
int c;
if (gl_pos > 0 && gl_cnt > gl_pos) {
if(mbcslocale) {
int l_len = 0;
int r_len = 0;
int i = 0;
int j = 0;
mbstate_t mb_st;
mbs_init(&mb_st);
for (i = 0; i < gl_pos;) {
l_len = mbrlen(gl_buf+i, MB_CUR_MAX, &mb_st);
i += l_len;
}
mbs_init(&mb_st);
r_len = mbrlen(gl_buf+gl_pos, MB_CUR_MAX, &mb_st);
for (i = 0; i < r_len; i++) {
for(j = 0; j < l_len; j++) {
c = gl_buf[gl_pos+i-j];
gl_buf[gl_pos+i-j] = gl_buf[gl_pos+i-j-1];
gl_buf[gl_pos+i-j-1] = (char)c;
}
}
gl_extent = l_len + r_len;
gl_fixup(gl_prompt, gl_pos - l_len, gl_pos + (r_len - l_len));
} else {
c = gl_buf[gl_pos-1];
gl_buf[gl_pos-1] = gl_buf[gl_pos];
gl_buf[gl_pos] = (char) c;
gl_extent = 2;
gl_fixup(gl_prompt, gl_pos-1, gl_pos);
}
} else
gl_beep();
}
void testValues() {
f = 2;
size_t result;
char s1[] = "AAAA";
//@ assert \valid(s1+(0..\block_length(s1)-1));
//@ assert \exists integer x; s1[x] == '\0';
result = mbrlen(s1, 4, anystate());
//@ assert 0 <= result <= 4 || result == (size_t)(-1) || result == (size_t)(-2);
//@ assert result == (size_t)(-1) ==> errno != 0;
//@ assert f == 2;
//@ assert vacuous: \false;
}
bool
is_mb_middle (const char **good, const char *buf, const char *end,
size_t match_len)
{
const char *p = *good;
const char *prev = p;
mbstate_t cur_state;
/* TODO: can be optimized for UTF-8. */
memset(&cur_state, 0, sizeof(mbstate_t));
while (p < buf)
{
size_t mbclen = mbrlen(p, end - p, &cur_state);
/* Store the beginning of the previous complete multibyte character. */
if (mbclen != (size_t) -2)
prev = p;
if (mbclen == (size_t) -1 || mbclen == (size_t) -2 || mbclen == 0)
{
/* An invalid sequence, or a truncated multibyte character.
We treat it as a single byte character. */
mbclen = 1;
memset(&cur_state, 0, sizeof cur_state);
}
p += mbclen;
}
*good = prev;
if (p > buf)
return true;
/* P == BUF here. */
return 0 < match_len && match_len < mbrlen (p, end - p, &cur_state);
}
// Convert and map inconvertible Unicode characters.
// We use it for extended ASCII names in Unix.
void CharToWideMap(const char *Src,wchar *Dest,size_t DestSize,bool &Success)
{
// Map inconvertible characters to private use Unicode area 0xE000.
// Mark such string by placing special non-character code before
// first inconvertible character.
Success=false;
bool MarkAdded=false;
uint SrcPos=0,DestPos=0;
while (DestPos<DestSize)
{
if (Src[SrcPos]==0)
{
Dest[DestPos]=0;
Success=true;
break;
}
mbstate_t ps;
memset(&ps,0,sizeof(ps));
if (mbrtowc(Dest+DestPos,Src+SrcPos,MB_CUR_MAX,&ps)==-1)
{
// For security reasons we do not want to map low ASCII characters,
// so we do not have additional .. and path separator codes.
if (byte(Src[SrcPos])>=0x80)
{
if (!MarkAdded)
{
Dest[DestPos++]=MappedStringMark;
MarkAdded=true;
if (DestPos>=DestSize)
break;
}
Dest[DestPos++]=byte(Src[SrcPos++])+MapAreaStart;
}
else
break;
}
else
{
memset(&ps,0,sizeof(ps));
int Length=mbrlen(Src+SrcPos,MB_CUR_MAX,&ps);
SrcPos+=Max(Length,1);
DestPos++;
}
}
}
static int
_inp_offset_to_col(char *str, int offset)
{
int i = 0;
int col = 0;
while (i < offset && str[i] != '\0') {
gunichar uni = g_utf8_get_char(&str[i]);
size_t ch_len = mbrlen(&str[i], 4, NULL);
i += ch_len;
col++;
if (g_unichar_iswide(uni)) {
col++;
}
}
return col;
}
// Convert and restore mapped inconvertible Unicode characters.
// We use it for extended ASCII names in Unix.
bool WideToCharMap(const wchar *Src,char *Dest,size_t DestSize,bool &Success)
{
// String with inconvertible characters mapped to private use Unicode area
// must have the mark code somewhere.
if (wcschr(Src,(wchar)MappedStringMark)==NULL)
return false;
Success=true;
uint SrcPos=0,DestPos=0;
while (DestPos<DestSize-MB_CUR_MAX)
{
if (Src[SrcPos]==0)
{
Dest[DestPos]=0;
break;
}
if (uint(Src[SrcPos])==MappedStringMark)
{
SrcPos++;
continue;
}
// For security reasons do not retore low ASCII codes, so mapping cannot
// be used to hide control codes like path separators.
if (uint(Src[SrcPos])>=MapAreaStart+0x80 && uint(Src[SrcPos])<MapAreaStart+0x100)
Dest[DestPos++]=char(uint(Src[SrcPos++])-MapAreaStart);
else
{
mbstate_t ps;
memset(&ps,0,sizeof(ps));
if (wcrtomb(Dest+DestPos,Src[SrcPos],&ps)==-1)
Success=false;
SrcPos++;
memset(&ps,0,sizeof(ps));
int Length=mbrlen(Dest+DestPos,MB_CUR_MAX,&ps);
DestPos+=Max(Length,1);
}
}
return true;
}
/*
* Based on a starting multibyte state and an input buffer, determine
* how many wchar_t's would be output. This doesn't use mbsnrtowcs()
* so that it can handle embedded null characters.
*/
static size_t
wbuflen(const mbstate_t *state, const char *buf, int len)
{
mbstate_t lenstate;
size_t charlen, count;
count = 0;
lenstate = *state;
while (len > 0) {
charlen = mbrlen(buf, len, &lenstate);
if (charlen == (size_t)-1)
return (-1);
if (charlen == (size_t)-2)
break;
if (charlen == 0)
/* XXX: Not sure how else to handle this. */
charlen = 1;
len -= charlen;
buf += charlen;
count++;
}
return (count);
}
void
stripsuffix(char *p, const char *suffix, size_t suffixlen)
{
char *q, *r;
mbstate_t mbs;
size_t n;
if (suffixlen && (q = strchr(p, '\0') - suffixlen) > p &&
strcmp(suffix, q) == 0) {
/* Ensure that the match occurred on a character boundary. */
memset(&mbs, 0, sizeof(mbs));
for (r = p; r < q; r += n) {
n = mbrlen(r, MB_LEN_MAX, &mbs);
if (n == (size_t)-1 || n == (size_t)-2) {
memset(&mbs, 0, sizeof(mbs));
n = 1;
}
}
/* Chop off the suffix. */
if (q == r)
*q = '\0';
}
}
void main()
{
int i, j, k;
_setmbcp( 932 );
j = 1;
for( i = 0; j > 0; i += j ) {
j = mbrlen( &chars[i], MB_CUR_MAX, NULL );
printf( "%d bytes in character ", j );
if( errno == EILSEQ ) {
printf( " - illegal multibyte character\n" );
} else {
if( j == 0 ) {
k = 0;
} else if ( j == 1 ) {
k = chars[i];
} else if( j == 2 ) {
k = chars[i]<<8 | chars[i+1];
}
printf( "(%#6.4x)\n", k );
}
}
}
int str_prevoff(const char *p, int pos)
{
if(ioncore_g.enc_sb)
return (pos>0 ? 1 : 0);
if(ioncore_g.enc_utf8){
int opos=pos;
while(pos>0){
pos--;
if((p[pos]&0xC0)!=0x80)
break;
}
return opos-pos;
}
assert(ioncore_g.use_mb);
{
/* *sigh* */
int l, prev=0;
mbstate_t ps;
memset(&ps, 0, sizeof(ps));
while(1){
l=mbrlen(p+prev, pos-prev, &ps);
if(l<0){
warn(TR("Invalid multibyte string."));
return 0;
}
if(prev+l>=pos)
return pos-prev;
prev+=l;
}
}
}
int str_len(const char *p)
{
if(ioncore_g.enc_sb)
return strlen(p);
if(ioncore_g.enc_utf8){
int len=0;
while(*p){
if(((*p)&0xC0)!=0x80)
len++;
p++;
}
return len;
}
assert(ioncore_g.use_mb);
{
mbstate_t ps;
int len=0, bytes=strlen(p), l;
memset(&ps, 0, sizeof(ps));
while(bytes>0){
l=mbrlen(p, bytes, &ps);
if(l<=0){
warn(TR("Invalid multibyte string."));
break;
}
len++;
bytes-=l;
p += l;
}
return len;
}
}
/*
* Convert a multibyte character string argument for the %s format to a wide
* string representation. ``prec'' specifies the maximum number of bytes
* to output. If ``prec'' is greater than or equal to zero, we can't assume
* that the multibyte character string ends in a null character.
*
* Returns NULL on failure.
* To find out what happened check errno for ENOMEM, EILSEQ and EINVAL.
*/
static wchar_t *
__mbsconv(char *mbsarg, int prec)
{
mbstate_t mbs;
wchar_t *convbuf, *wcp;
const char *p;
size_t insize, nchars, nconv;
if (mbsarg == NULL)
return (NULL);
/*
* Supplied argument is a multibyte string; convert it to wide
* characters first.
*/
if (prec >= 0) {
/*
* String is not guaranteed to be NUL-terminated. Find the
* number of characters to print.
*/
p = mbsarg;
insize = nchars = nconv = 0;
memset(&mbs, 0, sizeof(mbs));
while (nchars != (size_t)prec) {
nconv = mbrlen(p, MB_CUR_MAX, &mbs);
if (nconv == (size_t)0 || nconv == (size_t)-1 ||
nconv == (size_t)-2)
break;
p += nconv;
nchars++;
insize += nconv;
}
if (nconv == (size_t)-1 || nconv == (size_t)-2)
return (NULL);
} else
insize = strlen(mbsarg);
/*
* Allocate buffer for the result and perform the conversion,
* converting at most `size' bytes of the input multibyte string to
* wide characters for printing.
*/
convbuf = calloc(insize + 1, sizeof(*convbuf));
if (convbuf == NULL)
return (NULL);
wcp = convbuf;
p = mbsarg;
memset(&mbs, 0, sizeof(mbs));
nconv = 0;
while (insize != 0) {
nconv = mbrtowc(wcp, p, insize, &mbs);
if (nconv == 0 || nconv == (size_t)-1 || nconv == (size_t)-2)
break;
wcp++;
p += nconv;
insize -= nconv;
}
if (nconv == (size_t)-1 || nconv == (size_t)-2) {
free(convbuf);
return (NULL);
}
*wcp = '\0';
return (convbuf);
}
/* get number of characters in a mult-byte character string */
int
mbslen(const char *s, size_t *ncharsp)
{
#ifdef HAVE_XLOCALE
static locale_t loc = 0;
static int initialized = 0;
#endif /* HAVE_XLOCALE */
#ifdef WIN32
char *my_locale=0;
unsigned int i;
#endif /* WIN32 */
int _status;
size_t nbytes;
int nchars;
mbstate_t mbs;
#ifdef HAVE_XLOCALE
if (! initialized) {
initialized = 1;
loc = newlocale(LC_CTYPE_MASK, "UTF-8", LC_GLOBAL_LOCALE);
}
if (loc == 0) {
/* unable to create the UTF-8 locale */
assert(loc != 0); /* should never happen */
#endif /* HAVE_XLOCALE */
#ifdef WIN32
if (!setlocale(LC_CTYPE, 0))
ABORT(R_INTERNAL);
if (!(my_locale = r_strdup(setlocale(LC_CTYPE, 0))))
ABORT(R_NO_MEMORY);
for (i=0; i<strlen(my_locale); i++)
my_locale[i] = toupper(my_locale[i]);
if (!strstr(my_locale, "UTF-8") && !strstr(my_locale, "UTF8"))
ABORT(R_NOT_FOUND);
#else
/* can't count UTF-8 characters with mbrlen if the locale isn't UTF-8 */
/* null-checking setlocale is required because Android */
char *locale = setlocale(LC_CTYPE, 0);
/* some systems use "utf8" instead of "UTF-8" like Fedora 17 */
if (!locale || (!strcasestr(locale, "UTF-8") && !strcasestr(locale, "UTF8")))
ABORT(R_NOT_FOUND);
#endif
#ifdef HAVE_XLOCALE
}
#endif /* HAVE_XLOCALE */
memset(&mbs, 0, sizeof(mbs));
nchars = 0;
#ifdef HAVE_XLOCALE
while (*s != '\0' && (nbytes = mbrlen_l(s, strlen(s), &mbs, loc)) != 0)
#else
while (*s != '\0' && (nbytes = mbrlen(s, strlen(s), &mbs)) != 0)
#endif /* HAVE_XLOCALE */
{
if (nbytes == (size_t)-1) /* should never happen */ {
ABORT(R_INTERNAL);
}
if (nbytes == (size_t)-2) /* encoding error */ {
ABORT(R_BAD_DATA);
}
s += nbytes;
++nchars;
}
*ncharsp = nchars;
_status = 0;
abort:
#ifdef WIN32
RFREE(my_locale);
#endif
return _status;
}
ATF_TC_BODY(mbrlen_test, tc)
{
mbstate_t s;
size_t len;
char buf[MB_LEN_MAX + 1];
/* C/POSIX locale. */
ATF_REQUIRE(MB_CUR_MAX == 1);
/* Null wide character, internal state. */
memset(buf, 0xcc, sizeof(buf));
buf[0] = 0;
ATF_REQUIRE(mbrlen(buf, 1, NULL) == 0);
/* Null wide character. */
memset(&s, 0, sizeof(s));
ATF_REQUIRE(mbrlen(buf, 1, &s) == 0);
/* Latin letter A, internal state. */
ATF_REQUIRE(mbrlen(NULL, 0, NULL) == 0);
buf[0] = 'A';
ATF_REQUIRE(mbrlen(buf, 1, NULL) == 1);
/* Latin letter A. */
memset(&s, 0, sizeof(s));
ATF_REQUIRE(mbrlen(buf, 1, &s) == 1);
/* Incomplete character sequence. */
memset(&s, 0, sizeof(s));
ATF_REQUIRE(mbrlen(buf, 0, &s) == (size_t)-2);
/* Japanese (EUC) locale. */
ATF_REQUIRE(strcmp(setlocale(LC_CTYPE, "ja_JP.eucJP"), "ja_JP.eucJP") == 0);
ATF_REQUIRE(MB_CUR_MAX > 1);
/* Null wide character, internal state. */
ATF_REQUIRE(mbrlen(NULL, 0, NULL) == 0);
memset(buf, 0xcc, sizeof(buf));
buf[0] = 0;
ATF_REQUIRE(mbrlen(buf, 1, NULL) == 0);
/* Null wide character. */
memset(&s, 0, sizeof(s));
ATF_REQUIRE(mbrlen(buf, 1, &s) == 0);
/* Latin letter A, internal state. */
ATF_REQUIRE(mbrlen(NULL, 0, NULL) == 0);
buf[0] = 'A';
ATF_REQUIRE(mbrlen(buf, 1, NULL) == 1);
/* Latin letter A. */
memset(&s, 0, sizeof(s));
ATF_REQUIRE(mbrlen(buf, 1, &s) == 1);
/* Incomplete character sequence (zero length). */
memset(&s, 0, sizeof(s));
ATF_REQUIRE(mbrlen(buf, 0, &s) == (size_t)-2);
/* Incomplete character sequence (truncated double-byte). */
memset(buf, 0xcc, sizeof(buf));
buf[0] = 0xa3;
buf[1] = 0x00;
memset(&s, 0, sizeof(s));
ATF_REQUIRE(mbrlen(buf, 1, &s) == (size_t)-2);
/* Same as above, but complete. */
buf[1] = 0xc1;
memset(&s, 0, sizeof(s));
ATF_REQUIRE(mbrlen(buf, 2, &s) == 2);
}
int main()
{
mbstate_t mb = {0};
size_t s = 0;
tm tm = {0};
wint_t w = 0;
::FILE* fp = 0;
__darwin_va_list va;
char* ns = 0;
wchar_t* ws = 0;
static_assert((std::is_same<decltype(fwprintf(fp, L"")), int>::value), "");
static_assert((std::is_same<decltype(fwscanf(fp, L"")), int>::value), "");
static_assert((std::is_same<decltype(swprintf(ws, s, L"")), int>::value), "");
static_assert((std::is_same<decltype(swscanf(L"", L"")), int>::value), "");
static_assert((std::is_same<decltype(vfwprintf(fp, L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vfwscanf(fp, L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vswprintf(ws, s, L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vswscanf(L"", L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vwprintf(L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vwscanf(L"", va)), int>::value), "");
static_assert((std::is_same<decltype(wprintf(L"")), int>::value), "");
static_assert((std::is_same<decltype(wscanf(L"")), int>::value), "");
static_assert((std::is_same<decltype(fgetwc(fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(fgetws(ws, 0, fp)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(fputwc(L' ', fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(fputws(L"", fp)), int>::value), "");
static_assert((std::is_same<decltype(fwide(fp, 0)), int>::value), "");
static_assert((std::is_same<decltype(getwc(fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(getwchar()), wint_t>::value), "");
static_assert((std::is_same<decltype(putwc(L' ', fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(putwchar(L' ')), wint_t>::value), "");
static_assert((std::is_same<decltype(ungetwc(L' ', fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(wcstod(L"", (wchar_t**)0)), double>::value), "");
static_assert((std::is_same<decltype(wcstof(L"", (wchar_t**)0)), float>::value), "");
static_assert((std::is_same<decltype(wcstold(L"", (wchar_t**)0)), long double>::value), "");
static_assert((std::is_same<decltype(wcstol(L"", (wchar_t**)0, 0)), long>::value), "");
static_assert((std::is_same<decltype(wcstoll(L"", (wchar_t**)0, 0)), long long>::value), "");
static_assert((std::is_same<decltype(wcstoul(L"", (wchar_t**)0, 0)), unsigned long>::value), "");
static_assert((std::is_same<decltype(wcstoull(L"", (wchar_t**)0, 0)), unsigned long long>::value), "");
static_assert((std::is_same<decltype(wcscpy(ws, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsncpy(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcscat(ws, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsncat(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcscmp(L"", L"")), int>::value), "");
static_assert((std::is_same<decltype(wcscoll(L"", L"")), int>::value), "");
static_assert((std::is_same<decltype(wcsncmp(L"", L"", s)), int>::value), "");
static_assert((std::is_same<decltype(wcsxfrm(ws, L"", s)), size_t>::value), "");
static_assert((std::is_same<decltype(wcschr((wchar_t*)0, L' ')), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcscspn(L"", L"")), size_t>::value), "");
static_assert((std::is_same<decltype(wcslen(L"")), size_t>::value), "");
static_assert((std::is_same<decltype(wcspbrk((wchar_t*)0, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsrchr((wchar_t*)0, L' ')), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsspn(L"", L"")), size_t>::value), "");
static_assert((std::is_same<decltype(wcsstr((wchar_t*)0, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcstok(ws, L"", (wchar_t**)0)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemchr((wchar_t*)0, L' ', s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemcmp(L"", L"", s)), int>::value), "");
static_assert((std::is_same<decltype(wmemcpy(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemmove(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemset(ws, L' ', s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsftime(ws, s, L"", &tm)), size_t>::value), "");
static_assert((std::is_same<decltype(btowc(0)), wint_t>::value), "");
static_assert((std::is_same<decltype(wctob(w)), int>::value), "");
static_assert((std::is_same<decltype(mbsinit(&mb)), int>::value), "");
static_assert((std::is_same<decltype(mbrlen("", s, &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(mbrtowc(ws, "", s, &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(wcrtomb(ns, L' ', &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(mbsrtowcs(ws, (const char**)0, s, &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(wcsrtombs(ns, (const wchar_t**)0, s, &mb)), size_t>::value), "");
}
void TestAddendum( void )
{
wchar_t wc;
wchar_t wcs[10];
wchar_t * wcsPtr;
int status;
mbstate_t state;
unsigned char mbc[MB_LEN_MAX];
unsigned char mbcs[10*MB_LEN_MAX+1];
unsigned char * mbcsPtr;
errno_t rc;
size_t retval;
int violations = NumViolations;
status = wctob( L'!' );
VERIFY( status == '!' );
status = mbtowc( &wc, "\x90\x90", 2 );
#ifndef DUMMY_DBCS
VERIFY( status == 2 );
status = wctob( wc );
VERIFY( status == EOF );
#else
VERIFY( status == 1 );
status = wctob( wc );
VERIFY( status == 0x90 );
#endif
status = sisinit( NULL );
VERIFY( status != 0 );
state = 0;
status = sisinit( &state );
VERIFY( status == 0 );
state = 123;
status = sisinit( &state );
VERIFY( status == 0 );
status = mbrlen( "\0""!", 2, &state );
VERIFY( status == 0 );
status = mbrlen( "!", 2, &state );
VERIFY( status == 1 );
wc = L'\0';
rc = wcrtomb_s( &retval, mbc, MB_LEN_MAX, wc, &state );
VERIFY( rc == 0 );
VERIFY( *mbc == '\0' );
VERIFY( retval == 1 );
VERIFY( violations == NumViolations );
rc = wcrtomb_s( &retval, mbc, MB_LEN_MAX, L'X', &state );
VERIFY( rc == 0 );
VERIFY( *mbc == 'X' );
VERIFY( retval == 1 );
VERIFY( violations == NumViolations );
rc = wcrtomb_s( &retval, NULL, 0, L'X', &state );
VERIFY( rc == 0 );
VERIFY( retval == 1 );
VERIFY( violations == NumViolations );
_mbscpy( mbcs, "Foo!\x90\x90" );
mbcsPtr = mbcs;
wcs[5] = wcs[6] = L'-';
rc = mbsrtowcs_s( &retval, wcs, 10, (const char**)(&mbcsPtr), 6, &state );
VERIFY( rc == 0 );
VERIFY( retval == 5 );
VERIFY( wcs[0] == L'F' );
VERIFY( wcs[1] == L'o' );
VERIFY( wcs[2] == L'o' );
VERIFY( wcs[3] == L'!' );
mbcsPtr = mbcs;
rc = mbsrtowcs_s( &retval, NULL, 0, (const char**)(&mbcsPtr), 1, &state );
VERIFY( rc == 0 );
VERIFY( retval == 5 );
wcsPtr = wcs;
_mbsset( mbcs, _mbsnextc("#") );
rc = wcsrtombs_s( &retval, mbcs, 10, (const wchar_t**)(&wcsPtr), 6, &state );
VERIFY( rc == 0 );
VERIFY( retval == 6 );
mbcs[retval] = '\0';
VERIFY( _mbscmp( mbcs, "Foo!\x90\x90" ) == 0 );
wcsPtr = wcs;
rc = wcsrtombs_s( &retval, NULL, 0, (const wchar_t**)(&wcsPtr), 20, &state );
VERIFY( rc == 0 );
VERIFY( retval == 6 );
/***********************************************************************/
/* test runtime-constraints */
/***********************************************************************/
*mbc = 'X';
rc = wcrtomb_s( NULL, mbc, MB_LEN_MAX, wc, &state );
VERIFY( rc != 0 );
VERIFY( *mbc == '\0' );
VERIFY( ++violations == NumViolations );
*mbc = 'X';
rc = wcrtomb_s( &retval, mbc, MB_LEN_MAX, L'X', NULL );
VERIFY( rc != 0 );
VERIFY( *mbc == '\0' );
VERIFY( retval == -1 );
VERIFY( ++violations == NumViolations );
rc = wcrtomb_s( &retval, NULL, MB_LEN_MAX, L'X', &state );
VERIFY( rc != 0 );
VERIFY( retval == -1 );
VERIFY( ++violations == NumViolations );
*mbc = 'X';
rc = wcrtomb_s( &retval, mbc, 0, L'X', &state );
VERIFY( rc != 0 );
VERIFY( *mbc == 'X' );
VERIFY( retval == -1 );
VERIFY( ++violations == NumViolations );
#if RSIZE_MAX != SIZE_MAX
rc = wcrtomb_s( &retval, mbc, ~0, L'X', &state );
VERIFY( rc != 0 );
VERIFY( retval == -1 );
VERIFY( *mbc == 'X' );
VERIFY( ++violations == NumViolations );
#endif
mbcsPtr = mbcs;
rc = mbsrtowcs_s( NULL, NULL, 0, (const char**)(&mbcsPtr), 1, &state );
VERIFY( rc != 0 );
VERIFY( ++violations == NumViolations );
rc = mbsrtowcs_s( &retval, NULL, 0, NULL, 1, &state );
VERIFY( rc != 0 );
VERIFY( retval == -1 );
VERIFY( ++violations == NumViolations );
mbcsPtr = NULL;
rc = mbsrtowcs_s( &retval, NULL, 0, (const char**)(&mbcsPtr), 1, &state );
VERIFY( rc != 0 );
VERIFY( retval == -1 );
VERIFY( ++violations == NumViolations );
rc = mbsrtowcs_s( &retval, NULL, 0, (const char**)(&wcsPtr), 1, NULL );
VERIFY( rc != 0 );
VERIFY( retval == -1 );
VERIFY( ++violations == NumViolations );
rc = mbsrtowcs_s( &retval, NULL, 111, (const char**)(&wcsPtr), 1, &state );
VERIFY( rc != 0 );
VERIFY( retval == -1 );
VERIFY( ++violations == NumViolations );
wcsPtr = wcs;
rc = wcsrtombs_s( &retval, mbcs, 5, (const wchar_t**)(&wcsPtr), 10, &state );
VERIFY( rc != 0 );
VERIFY( retval == -1 );
VERIFY( ++violations == NumViolations );
}
