自学教程：C++ wcrtomb函数代码示例

char *rxvt_wcstombs (const wchar_t *str, int len){  if (len < 0) len = wcslen (str);  mbstate mbs;  char *r = (char *)rxvt_malloc (len * MB_CUR_MAX + 1);  char *dst = r;  while (len--)    {      ssize_t l = wcrtomb (dst, *str++, mbs);      if (l < 0)        {          *dst++ = '?';          wcrtomb (0, 0, mbs); // reset undefined state        }      else        dst += l;    }  *dst++ = 0;  return (char *)rxvt_realloc (r, dst - r);}

static intdo_test (void){  unsigned char buf[7] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };  const unsigned char bufcheck[7] = { 0x25, 0xe2, 0x82, 0xac, 0xce, 0xbb, 0 };  const wchar_t srcbuf[4] = { 0x25, 0x20ac, 0x03bb, 0 };  mbstate_t state;  const wchar_t *src;  char *dst;  int result = 0;  const char *used_locale;  setlocale (LC_CTYPE, "de_DE.UTF-8");  /* Double check.  */  used_locale = setlocale (LC_CTYPE, NULL);  printf ("used locale: /"%s/"/n", used_locale);  result = strcmp (used_locale, "de_DE.UTF-8");  memset (&state, '/0', sizeof (state));  src = srcbuf;  dst = (char *) buf;  show (wcrtomb (dst, *src++, &state), 1, buf + 1);  show (wcrtomb (dst, *src++, &state), 3, buf + 4);  show (wcrtomb (dst, *src++, &state), 2, buf + 6);  show (wcrtomb (dst, *src, &state), 1, buf + 7);  if (memcmp (buf, bufcheck, 7))    {      puts ("wrong results");      result = 1;    }  return result;}

static int print_macro (FILE *f, int maxwidth, const char **macro){  int n = maxwidth;  wchar_t wc;  int w;  size_t k;  size_t len = mutt_strlen (*macro);  mbstate_t mbstate1, mbstate2;  memset (&mbstate1, 0, sizeof (mbstate1));  memset (&mbstate2, 0, sizeof (mbstate2));  for (; len && (k = mbrtowc (&wc, *macro, len, &mbstate1)); *macro += k, len -= k)  {    if (k == (size_t)(-1) || k == (size_t)(-2))    {      k = (k == (size_t)(-1)) ? 1 : len;      wc = replacement_char ();    }    /* glibc-2.1.3's wcwidth() returns 1 for unprintable chars! */    if (IsWPrint (wc) && (w = wcwidth (wc)) >= 0)    {      if (w > n)	break;      n -= w;      {	char buf[MB_LEN_MAX*2];	size_t n1, n2;	if ((n1 = wcrtomb (buf, wc, &mbstate2)) != (size_t)(-1) &&	    (n2 = wcrtomb (buf + n1, 0, &mbstate2)) != (size_t)(-1))	  fputs (buf, f);      }    }    else if (wc < 0x20 || wc == 0x7f)    {      if (2 > n)	break;      n -= 2;      if (wc == '/033')	fprintf (f, "//e");      else if (wc == '/n')	fprintf (f, "//n");      else if (wc == '/r')	fprintf (f, "//r");      else if (wc == '/t')	fprintf (f, "//t");      else	fprintf (f, "^%c", (char)((wc + '@') & 0x7f));    }    else    {      if (1 > n)	break;      n -= 1;      fprintf (f, "?");    }  }  return (maxwidth - n);}

unsigned long ILAnsiGetByteCount(const unsigned short *chars,								 unsigned long count){#ifdef IL_CONFIG_LATIN1	return count;#else#if HAVE_WCRTOMB	/* Use the re-entrant function to perform the conversion */	mbstate_t state;	char buf[MB_LEN_MAX+1];	size_t chlen;	unsigned short ch;	unsigned long len = 0;	ILMemZero(&state, sizeof(state));	wcrtomb(buf, 0, &state);	while(count > 0)	{		ch = *chars++;		if(ch != 0)		{			chlen = wcrtomb(buf, (wchar_t)ch, &state);			if(chlen != (size_t)(-1))			{				len += (unsigned long)chlen;			}		}		else		{			++len;		}		--count;	}	return len;#else	/* Use the non re-entrant function to perform the conversion	   and just hope that the underlying libc takes care of the	   thread-safety issues for us */	char buf[MB_LEN_MAX+1];	int chlen;	unsigned long len = 0;	wctomb((char *)0, 0);	while(count > 0)	{		chlen = wctomb(buf, (wchar_t)(*chars));		if(chlen > 0)		{			len += (unsigned long)chlen;		}		++chars;		--count;	}	return len;#endif#endif}

/** * Return true if the input wide-character is one of the special * characters used to define the syntax of the dictionary. */static int is_special(wchar_t wc, mbstate_t *ps){	char buff[MB_LEN_MAX];	int nr = wcrtomb(buff, wc, ps);	if (1 != nr) return FALSE;	return (NULL != strchr(SPECIAL, buff[0]));}

/* EXTPROTO */char*rxvt_wcstombs (const wchar_t* str, int len){	mbstate_t	mbs;	char*	r;	char*	dst;	if (len < 0)		len = wcslen (str);	memset (&mbs, 0, sizeof (mbs));	r = (char *)rxvt_malloc (len * MB_CUR_MAX + 1);	dst = r;	while (len--) {		int l = wcrtomb (dst, *str++, &mbs);		if (l < 0)			*dst++ = '?';		else			dst += l;	}	*dst++ = 0;	return r;}

static intdo_test (const char *loc){  char buf[100];  size_t n;  mbstate_t state;  const char *nloc;  int res;  nloc = setlocale (LC_ALL, loc);  if (nloc == NULL)    {      printf ("could not set locale /"%s/"/n", loc);      return 1;    }  printf ("new locale: %s/n", nloc);  memset (&state, '/0', sizeof (state));  errno = 0;  n = wcrtomb (buf, (wchar_t) -15l, &state);  printf ("n = %zd, errno = %d (%s)/n", n, errno, strerror (errno));  res = n != (size_t) -1 || errno != EILSEQ;  if (res)    puts ("*** FAIL");  putchar ('/n');  return res;}

/* * Like __fputwc_unlock, but handles fake string (__SSTR) files properly. * File must already be locked. */static wint_t__xfputwc(wchar_t wc, FILE *fp, locale_t locale){	mbstate_t mbs;	char buf[MB_LEN_MAX];	struct __suio uio;	struct __siov iov;	size_t len;	if ((fp->_flags & __SSTR) == 0)		return (__fputwc_unlock(wc, fp, locale));	memset(&mbs, 0, sizeof(mbs));	len = wcrtomb(buf, wc, &mbs);	if (len == (size_t)-1) {		fp->_flags |= __SERR;		errno = EILSEQ;		return (WEOF);	}	uio.uio_iov = &iov;	uio.uio_resid = len;	uio.uio_iovcnt = 1;	iov.iov_base = buf;	iov.iov_len = len;	return (__sfvwrite(fp, &uio) != EOF ? (wint_t)wc : WEOF);}

int__printf_render_chr(struct __printf_io *io, const struct printf_info *pi, const void *const *arg){	int i;	wint_t ii;	unsigned char c;	static const mbstate_t initial;		/* XXX: this is bogus! */	mbstate_t mbs;	size_t mbseqlen;	char buf[MB_CUR_MAX];	if (pi->is_long || pi->spec == 'C') {		ii = *((wint_t *)arg[0]);		mbs = initial;		mbseqlen = wcrtomb(buf, (wchar_t)ii, &mbs);		if (mbseqlen == (size_t) -1)			return (-1);		return (__printf_out(io, pi, buf, mbseqlen));	}	i = *((int *)arg[0]);	c = i;	i = __printf_out(io, pi, &c, 1);	__printf_flush(io);	return (i);}

wadd_wch(WINDOW *win, const cchar_t *wch){    PUTC_DATA;    int n;    int code = ERR;    TR(TRACE_VIRTPUT | TRACE_CCALLS, (T_CALLED("wadd_wch(%p, %s)"), win,				      _tracech_t(wch)));    if (win != 0) {	PUTC_INIT;	for (PUTC_i = 0; PUTC_i < CCHARW_MAX; ++PUTC_i) {	    attr_t attrs = (wch->attr & A_ATTRIBUTES);	    if ((PUTC_ch = wch->chars[PUTC_i]) == L'/0')		break;	    if ((PUTC_n = wcrtomb(PUTC_buf, PUTC_ch, &PUT_st)) <= 0) {		code = ERR;		if (is8bits(PUTC_ch))		    code = waddch(win, UChar(PUTC_ch) | attrs);		break;	    }	    for (n = 0; n < PUTC_n; n++) {		if ((code = waddch(win, UChar(PUTC_buf[n]) | attrs)) == ERR) {		    break;		}	    }	    if (code == ERR)		break;	}    }    TR(TRACE_VIRTPUT | TRACE_CCALLS, (T_RETURN("%d"), code));    return (code);}

wecho_wchar(WINDOW *win, const cchar_t * wch){    PUTC_DATA;    int n;    int code = ERR;    TR(TRACE_VIRTPUT | TRACE_CCALLS, (T_CALLED("wecho_wchar(%p, %s)"), win,				      _tracech_t(wch)));    if (win != 0) {	PUTC_INIT;	while (PUTC_i < CCHARW_MAX) {	    if ((PUTC_ch = wch->chars[PUTC_i++]) == L'/0')		break;	    if ((PUTC_n = wcrtomb(PUTC_buf, PUTC_ch, &PUT_st)) <= 0) {		code = ERR;		if (is8bits(PUTC_ch))		    code = waddch(win, UChar(PUTC_ch) | wch->attr);		break;	    }	    for (n = 0; n < PUTC_n; n++) {		if ((code = waddch(win, UChar(PUTC_buf[n]) | wch->attr)) == ERR) {		    break;		}	    }	    if (code == ERR)		break;	}	wrefresh(win);    }    TR(TRACE_VIRTPUT | TRACE_CCALLS, (T_RETURN("%d"), code));    return (code);}

voidui_init(bool force_ascii){        // Cell character 0 is always a space        strcpy(ui_chars[0], " ");#ifdef __STDC_ISO_10646__        if (force_ascii) {                ui_ascii = true;                return;        }        // Encode Unicode cell characters using system locale        char *origLocale = setlocale(LC_CTYPE, NULL);        setlocale(LC_CTYPE, "");        int ch;        mbstate_t mbs;        memset(&mbs, 0, sizeof mbs);        for (ch = 1; ch < NCHARS; ch++) {                int len = wcrtomb(ui_chars[ch], 0x2580 + ch, &mbs);                if (len == -1 || !mbsinit(&mbs)) {                        ui_ascii = true;                        break;                }                ui_chars[ch][len] = 0;        }        // Restore the original locale        setlocale(LC_CTYPE, origLocale);#else        ui_ascii = true;#endif}

/* * Update the current column position for a character. */static intnewpos(int col, wint_t ch){	char buf[MB_LEN_MAX];	size_t len;	int w;	if (bflag) {		len = wcrtomb(buf, ch, NULL);		col += len;	} else		switch (ch) {		case '/b':			if (col > 0)				--col;			break;		case '/r':			col = 0;			break;		case '/t':			col = (col + 8) & ~7;			break;		default:			if ((w = wcwidth(ch)) > 0)				col += w;			break;		}	return (col);}

static __inline intconvert_string(FILE *fp, char * mbp, int width, locale_t locale){	mbstate_t mbs;	size_t nconv;	wint_t wi;	int nread;	mbs = initial_mbs;	nread = 0;	while ((wi = __fgetwc(fp, locale)) != WEOF && width-- != 0 &&	    !iswspace(wi)) {		if (mbp != SUPPRESS_PTR) {			nconv = wcrtomb(mbp, wi, &mbs);			if (nconv == (size_t)-1)				return (-1);			mbp += nconv;		}		nread++;	}	if (wi != WEOF)		__ungetwc(wi, fp, locale);	if (mbp != SUPPRESS_PTR)		*mbp = 0;	return (nread);}

static __inline intconvert_ccl(FILE *fp, char * mbp, int width, const struct ccl *ccl,    locale_t locale){	mbstate_t mbs;	size_t nconv;	wint_t wi;	int n;	n = 0;	mbs = initial_mbs;	while ((wi = __fgetwc(fp, locale)) != WEOF &&	    width-- != 0 && inccl(ccl, wi)) {		if (mbp != SUPPRESS_PTR) {			nconv = wcrtomb(mbp, wi, &mbs);			if (nconv == (size_t)-1)				return (-1);			mbp += nconv;		}		n++;	}	if (wi != WEOF)		__ungetwc(wi, fp, locale);	if (mbp != SUPPRESS_PTR)		*mbp = 0;	return (n);}

/* Convert the *N-byte string, BEG, to lowercase, and write the   NUL-terminated result into malloc'd storage.  Upon success, set *N   to the length (in bytes) of the resulting string (not including the   trailing NUL byte), and return a pointer to the lowercase string.   Upon memory allocation failure, this function exits.   Note that on input, *N must be larger than zero.   Note that while this function returns a pointer to malloc'd storage,   the caller must not free it, since this function retains a pointer   to the buffer and reuses it on any subsequent call.  As a consequence,   this function is not thread-safe.  */char *mbtolower (const char *beg, size_t *n){  static char *out;  static size_t outalloc;  size_t outlen, mb_cur_max;  mbstate_t is, os;  const char *end;  char *p;  assert (0 < *n);  if (*n > outalloc)    {      out = xrealloc (out, *n);      outalloc = *n;    }  /* appease clang-2.6 */  assert (out);  memset (&is, 0, sizeof (is));  memset (&os, 0, sizeof (os));  end = beg + *n;  mb_cur_max = MB_CUR_MAX;  p = out;  outlen = 0;  while (beg < end)    {      wchar_t wc;      size_t mbclen = mbrtowc(&wc, beg, end - beg, &is);      if (outlen + mb_cur_max >= outalloc)        {          out = x2nrealloc (out, &outalloc, 1);          p = out + outlen;        }      if (mbclen == (size_t) -1 || mbclen == (size_t) -2 || mbclen == 0)        {          /* An invalid sequence, or a truncated multi-octet character.             We treat it as a single-octet character.  */          *p++ = *beg++;          outlen++;          memset (&is, 0, sizeof (is));          memset (&os, 0, sizeof (os));        }      else        {          beg += mbclen;          mbclen = wcrtomb (p, towlower ((wint_t) wc), &os);          p += mbclen;          outlen += mbclen;        }    }  *n = p - out;  *p = 0;  return out;}

_tracecchar_t2(int bufnum, const cchar_t *ch){    char *result = _nc_trace_buf(bufnum, BUFSIZ);    attr_t attr;    const char *found;    if (result != 0) {	strcpy(result, l_brace);	if (ch != 0) {	    attr = AttrOfD(ch);	    if ((found = _nc_altcharset_name(attr, (chtype) CharOfD(ch))) != 0) {		(void) _nc_trace_bufcat(bufnum, found);		attr &= ~A_ALTCHARSET;	    } else if (isWidecExt(CHDEREF(ch))) {		(void) _nc_trace_bufcat(bufnum, "{NAC}");		attr &= ~A_CHARTEXT;	    } else {		PUTC_DATA;		int n;		PUTC_INIT;		(void) _nc_trace_bufcat(bufnum, "{ ");		for (PUTC_i = 0; PUTC_i < CCHARW_MAX; ++PUTC_i) {		    PUTC_ch = ch->chars[PUTC_i];		    if (PUTC_ch == L'/0') {			if (PUTC_i == 0)			    result = _nc_trace_bufcat(bufnum, "//000");			break;		    }		    PUTC_n = wcrtomb(PUTC_buf, ch->chars[PUTC_i], &PUT_st);		    if (PUTC_n <= 0) {			if (PUTC_ch != L'/0') {			    /* it could not be a multibyte sequence */			    (void) _nc_trace_bufcat(bufnum,						    _nc_tracechar(CURRENT_SCREEN,								  UChar(ch->chars[PUTC_i])));			}			break;		    }		    for (n = 0; n < PUTC_n; n++) {			if (n)			    (void) _nc_trace_bufcat(bufnum, ", ");			(void) _nc_trace_bufcat(bufnum,						_nc_tracechar(CURRENT_SCREEN,							      UChar(PUTC_buf[n])));		    }		}		(void) _nc_trace_bufcat(bufnum, " }");	    }	    if (attr != A_NORMAL) {		(void) _nc_trace_bufcat(bufnum, " | ");		(void) _nc_trace_bufcat(bufnum, _traceattr2(bufnum + 20, attr));	    }	}	result = _nc_trace_bufcat(bufnum, r_brace);    }    return result;}

/** * mutt_addwch - addwch would be provided by an up-to-date curses library * @param wc Wide char to display * @retval  0 Success * @retval -1 Error */int mutt_addwch(wchar_t wc){  char buf[MB_LEN_MAX * 2];  mbstate_t mbstate;  size_t n1, n2;  memset(&mbstate, 0, sizeof(mbstate));  if (((n1 = wcrtomb(buf, wc, &mbstate)) == (size_t)(-1)) ||      ((n2 = wcrtomb(buf + n1, 0, &mbstate)) == (size_t)(-1)))  {    return -1; /* ERR */  }  else  {    return addstr(buf);  }}

/* * Convert a wide character string argument for the %ls format to a multibyte * string representation. If not -1, prec specifies the maximum number of * bytes to output, and also means that we can't assume that the wide char * string is null-terminated. */static char *__wcsconv(wchar_t *wcsarg, int prec){	mbstate_t mbs;	char buf[MB_LEN_MAX];	wchar_t *p;	char *convbuf;	size_t clen, nbytes;	/* Allocate space for the maximum number of bytes we could output. */	if (prec < 0) {		memset(&mbs, 0, sizeof(mbs));		p = wcsarg;		nbytes = wcsrtombs(NULL, (const wchar_t **)&p, 0, &mbs);		if (nbytes == (size_t)-1) {			errno = EILSEQ;			return (NULL);		}	} else {		/*		 * Optimisation: if the output precision is small enough,		 * just allocate enough memory for the maximum instead of		 * scanning the string.		 */		if (prec < 128)			nbytes = prec;		else {			nbytes = 0;			p = wcsarg;			memset(&mbs, 0, sizeof(mbs));			for (;;) {				clen = wcrtomb(buf, *p++, &mbs);				if (clen == 0 || clen == (size_t)-1 ||				    nbytes + clen > (size_t)prec)					break;				nbytes += clen;			}			if (clen == (size_t)-1) {				errno = EILSEQ;				return (NULL);			}		}	}	if ((convbuf = malloc(nbytes + 1)) == NULL)		return (NULL);	/* Fill the output buffer. */	p = wcsarg;	memset(&mbs, 0, sizeof(mbs));	if ((nbytes = wcsrtombs(convbuf, (const wchar_t **)&p,	    nbytes, &mbs)) == (size_t)-1) {		free(convbuf);		errno = EILSEQ;		return (NULL);	}	convbuf[nbytes] = '/0';	return (convbuf);}

size_t wcsrtombs(char *s, const wchar_t **ws, size_t n, mbstate_t *st){	const wchar_t *ws2;	char buf[4];	size_t N = n, l;	if (!s) {		for (n=0, ws2=*ws; *ws2; ws2++) {			if (*ws2 >= 0x80) {				l = wcrtomb(buf, *ws2, 0);				if (!(l+1)) return -1;				n += l;			} else n++;		}		return n;	}	while (n>=4 && **ws) {		if (**ws >= 0x80) {			l = wcrtomb(s, **ws, 0);			if (!(l+1)) return -1;			s += l;			n -= l;		} else {			*s++ = **ws;			n--;		}		(*ws)++;	}	while (n && **ws) {		if (**ws >= 0x80) {			l = wcrtomb(buf, **ws, 0);			if (!(l+1)) return -1;			if (l>n) return N-n;			wcrtomb(s, **ws, 0);			s += l;			n -= l;		} else {			*s++ = **ws;			n--;		}		(*ws)++;	}	if (n) *s = 0;	*ws = 0;	return N-n;}

TEST(wchar, wctomb_wcrtomb) {  // wctomb and wcrtomb behave differently when s == NULL.  EXPECT_EQ(0, wctomb(NULL, L'h'));  EXPECT_EQ(0, wctomb(NULL, L'/0'));  EXPECT_EQ(1U, wcrtomb(NULL, L'/0', NULL));  EXPECT_EQ(1U, wcrtomb(NULL, L'h', NULL));  char bytes[MB_LEN_MAX];  // wctomb and wcrtomb behave similarly for the null wide character.  EXPECT_EQ(1, wctomb(bytes, L'/0'));  EXPECT_EQ(1U, wcrtomb(bytes, L'/0', NULL));  // ...and for regular characters.  memset(bytes, 0, sizeof(bytes));  EXPECT_EQ(1, wctomb(bytes, L'h'));  EXPECT_EQ('h', bytes[0]);  memset(bytes, 0, sizeof(bytes));  EXPECT_EQ(1U, wcrtomb(bytes, L'h', NULL));  EXPECT_EQ('h', bytes[0]);  ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));  uselocale(LC_GLOBAL_LOCALE);  // 1-byte UTF-8.  memset(bytes, 0, sizeof(bytes));  EXPECT_EQ(1U, wcrtomb(bytes, L'h', NULL));  EXPECT_EQ('h', bytes[0]);  // 2-byte UTF-8.  memset(bytes, 0, sizeof(bytes));  EXPECT_EQ(2U, wcrtomb(bytes, 0x00a2, NULL));  EXPECT_EQ('/xc2', bytes[0]);  EXPECT_EQ('/xa2', bytes[1]);  // 3-byte UTF-8.  memset(bytes, 0, sizeof(bytes));  EXPECT_EQ(3U, wcrtomb(bytes, 0x20ac, NULL));  EXPECT_EQ('/xe2', bytes[0]);  EXPECT_EQ('/x82', bytes[1]);  EXPECT_EQ('/xac', bytes[2]);  // 4-byte UTF-8.  memset(bytes, 0, sizeof(bytes));  EXPECT_EQ(4U, wcrtomb(bytes, 0x24b62, NULL));  EXPECT_EQ('/xf0', bytes[0]);  EXPECT_EQ('/xa4', bytes[1]);  EXPECT_EQ('/xad', bytes[2]);  EXPECT_EQ('/xa2', bytes[3]);  // Invalid code point.  EXPECT_EQ(static_cast<size_t>(-1), wcrtomb(bytes, 0xffffffff, NULL));  EXPECT_EQ(EILSEQ, errno);}

 wchar2bytes(wchar_t wc):  bytes(new char[MB_CUR_MAX*2 + sizeof(wchar_t)*2 + 2 + 1]) {   mbstate_t ps;   memset(&ps, 0, sizeof(ps));//initialize mbstate   size_t n;   if ((n = wcrtomb(bytes, wc, &ps)) == size_t(-1))     snprintf(bytes, NumberOf(bytes), "U+%04X", int(wc));   else     bytes[n] = 0; }

bool make_invalid_wchar(wchar_t &w) {    std::setlocale(LC_ALL,"C");    w=(wchar_t)WEOF;    std::mbstate_t ps=std::mbstate_t();    char s[MB_LEN_MAX];    size_t r=wcrtomb(s,w,&ps);    return r==(size_t)-1;}

static int_inp_printable(const wint_t ch){    char bytes[MB_CUR_MAX+1];    size_t utf_len = wcrtomb(bytes, ch, NULL);    bytes[utf_len] = '/0';    gunichar unichar = g_utf8_get_char(bytes);    return g_unichar_isprint(unichar) && (ch != KEY_MOUSE);}

static intwriteCharacter (const wchar_t *character, mbstate_t *state) {  char bytes[0X1000];  size_t result = wcrtomb(bytes, (character? *character: WC_C('/0')), state);  if (result == (size_t)-1) return 0;  if (!character) result -= 1;  fwrite(bytes, 1, result, outputStream);  return !ferror(outputStream);}

/* Check the multibyte character s[0..n-1].  */static voidcheck_character (const char *s, size_t n){  wchar_t wc;  char buf[64];  int iret;  size_t ret;  wc = (wchar_t) 0xBADFACE;  iret = mbtowc (&wc, s, n);  ASSERT (iret == n);  ret = wcrtomb (buf, wc, NULL);  ASSERT (ret == n);  ASSERT (memcmp (buf, s, n) == 0);  /* Test special calling convention, passing a NULL pointer.  */  ret = wcrtomb (NULL, wc, NULL);  ASSERT (ret == 1);}

static intreally_getch(WINDOW *win, int *fkey){    int ch;#ifdef USE_WIDE_CURSES    int code;    mbstate_t state;    wchar_t my_wchar;    wint_t my_wint;    /*     * We get a wide character, translate it to multibyte form to avoid     * having to change the rest of the code to use wide-characters.     */    if (used_last_getc >= have_last_getc) {	used_last_getc = 0;	have_last_getc = 0;	ch = ERR;	*fkey = 0;	code = wget_wch(win, &my_wint);	my_wchar = (wchar_t) my_wint;	switch (code) {	case KEY_CODE_YES:	    ch = *fkey = my_wchar;	    last_getc = my_wchar;	    break;	case OK:	    memset(&state, 0, sizeof(state));	    have_last_getc = (int) wcrtomb(last_getc_bytes, my_wchar, &state);	    if (have_last_getc < 0) {		have_last_getc = used_last_getc = 0;		last_getc_bytes[0] = (char) my_wchar;	    }	    ch = (int) CharOf(last_getc_bytes[used_last_getc++]);	    last_getc = my_wchar;	    break;	case ERR:	    ch = ERR;	    last_getc = ERR;	    break;	default:	    break;	}    } else {	ch = (int) CharOf(last_getc_bytes[used_last_getc++]);    }#else    ch = wgetch(win);    last_getc = ch;    *fkey = (ch > KEY_MIN && ch < KEY_MAX);#endif    return ch;}

int wctob(wint_t wc){	mbstate_t ps;	memset(&ps, 0, sizeof(ps));	char mb[MB_CUR_MAX];	int saved_errno = errno;	size_t status = wcrtomb(mb, wc, &ps);	if ( status == (size_t) -1 )		return errno = saved_errno, EOF;	if ( 2 <= status )		return EOF;	return (int) (unsigned char) mb[0];}

TEST(wchar, wcrtomb_start_state) {  char out[MB_LEN_MAX];  mbstate_t ps;  // Any non-initial state is invalid when calling wcrtomb.  memset(&ps, 0, sizeof(ps));  EXPECT_EQ(static_cast<size_t>(-2), mbrtowc(NULL, "/xc2", 1, &ps));  EXPECT_EQ(static_cast<size_t>(-1), wcrtomb(out, 0x00a2, &ps));  EXPECT_EQ(EILSEQ, errno);  // If the first argument to wcrtomb is NULL or the second is L'/0' the shift  // state should be reset.  memset(&ps, 0, sizeof(ps));  EXPECT_EQ(static_cast<size_t>(-2), mbrtowc(NULL, "/xc2", 1, &ps));  EXPECT_EQ(1U, wcrtomb(NULL, 0x00a2, &ps));  EXPECT_TRUE(mbsinit(&ps));  memset(&ps, 0, sizeof(ps));  EXPECT_EQ(static_cast<size_t>(-2), mbrtowc(NULL, "/xf0/xa4", 1, &ps));  EXPECT_EQ(1U, wcrtomb(out, L'/0', &ps));  EXPECT_TRUE(mbsinit(&ps));}

static voidh_wctomb(const struct test *t, char tc){	wchar_t wcs[16 + 2];	char buf[128];	char cs[MB_LEN_MAX];	const char *pcs;	char *str;	mbstate_t st;	mbstate_t *stp = NULL;	size_t sz, ret, i;	ATF_REQUIRE_STREQ(setlocale(LC_ALL, "C"), "C");	ATF_REQUIRE(setlocale(LC_CTYPE, t->locale) != NULL);	(void)strvis(buf, t->data, VIS_WHITE | VIS_OCTAL);	(void)printf("Checking sequence: /"%s/"/n", buf);	ATF_REQUIRE((str = setlocale(LC_ALL, NULL)) != NULL);	(void)printf("Using locale: %s/n", str);	if (tc == TC_WCRTOMB_ST) {		(void)memset(&st, 0, sizeof(st));		stp = &st;	}	wcs[t->wclen] = L'X'; /* poison */	pcs = t->data;	sz = mbsrtowcs(wcs, &pcs, t->wclen + 2, NULL);	ATF_REQUIRE_EQ_MSG(sz, t->wclen, "mbsrtowcs() returned: "		"%zu, expected: %zu", sz, t->wclen);	ATF_REQUIRE_EQ(wcs[t->wclen], 0);	for (i = 0; i < t->wclen + 1; i++) {		if (tc == TC_WCTOMB)			ret = wctomb(cs, wcs[i]);		else			ret = wcrtomb(cs, wcs[i], stp);		if (ret == t->mblen[i])			continue;		(void)printf("At position %zd:/n", i);		(void)printf("  expected: %zd/n", t->mblen[i]);		(void)printf("  got     : %zd/n", ret);		atf_tc_fail("Test failed");		/* NOTREACHED */	}	(void)printf("Ok./n");}