예제 #1
0
/*
 * Non-MT-safe version.
 */
wint_t
__fputwc(wchar_t wc, FILE *fp)
{
	char buf[MB_LEN_MAX];
	size_t i, len;

	if (MB_CUR_MAX == 1 && wc > 0 && wc <= UCHAR_MAX) {
		/*
		 * Assume single-byte locale with no special encoding.
		 * A more careful test would be to check
		 * _CurrentRuneLocale->encoding.
		 */
		*buf = (unsigned char)wc;
		len = 1;
	} else {
		if ((len = __wcrtomb(buf, wc, &fp->_mbstate)) == (size_t)-1) {
			fp->_flags |= __SERR;
			return (WEOF);
		}
	}

	for (i = 0; i < len; i++)
		if (__sputc((unsigned char)buf[i], fp) == EOF)
			return (WEOF);

	return ((wint_t)wc);
}
예제 #2
0
파일: wcrtomb.c 프로젝트: mariuz/haiku
size_t
wcrtomb(char *s, wchar_t wc, mbstate_t *ps)
{
	static mbstate_t mbs;

	if (ps == NULL)
		ps = &mbs;
	return (__wcrtomb(s, wc, ps));
}
예제 #3
0
파일: wctomb_chk.c 프로젝트: bminor/glibc
int
__wctomb_chk (char *s, wchar_t wchar, size_t buflen)
{
  /* We do not have to implement the full wctomb semantics since we
     know that S cannot be NULL when we come here.  */
  if (buflen < MB_CUR_MAX)
    __chk_fail ();

  return __wcrtomb (s, wchar, &__wctomb_state);
}
예제 #4
0
int
wctomb(char *s, wchar_t wchar)
{
	static const mbstate_t initial;
	static mbstate_t mbs;
	size_t rval;

	if (s == NULL) {
		/* No support for state dependent encodings. */
		mbs = initial;
		return (0);
	}
	if ((rval = __wcrtomb(s, wchar, &mbs)) == (size_t)-1)
		return (-1);
	return ((int)rval);
}
예제 #5
0
/*
 * Non-MT-safe version.
 */
wint_t
__ungetwc(wint_t wc, FILE *fp)
{
	char buf[MB_LEN_MAX];
	size_t len;

	if (wc == WEOF)
		return (WEOF);
	if ((len = __wcrtomb(buf, wc, &fp->_mbstate)) == (size_t)-1) {
		fp->_flags |= __SERR;
		return (WEOF);
	}
	while (len-- != 0)
		if (__ungetc((unsigned char)buf[len], fp) == EOF)
			return (WEOF);

	return (wc);
}
예제 #6
0
size_t _Locale_wctomb(struct _Locale_ctype *l,
		      char *to, size_t n,
		      const wchar_t c,
		      mbstate_t *shift_state)
{
  char buf [MB_LEN_MAX];
  int ret;
  char* mb = buf;
  ret = __wcrtomb(mb, c, shift_state);

  if (ret > n)
    return (size_t)-2;
  else if (ret <= 0)
    return ret;

  n = ret;
  while (n--)
    *to++ = *mb++;

  return ret;
}
예제 #7
0
파일: wctomb.c 프로젝트: AubrCool/glibc
/* Convert WCHAR into its multibyte character representation,
   putting this in S and returning its length.

   Attention: this function should NEVER be intentionally used.
   The interface is completely stupid.  The state is shared between
   all conversion functions.  You should use instead the restartable
   version `wcrtomb'.  */
int
wctomb (char *s, wchar_t wchar)
{
  /* If S is NULL the function has to return null or not null
     depending on the encoding having a state depending encoding or
     not.  */
  if (s == NULL)
    {
      const struct gconv_fcts *fcts;

      /* Get the conversion functions.  */
      fcts = get_gconv_fcts (_NL_CURRENT_DATA (LC_CTYPE));

      /* This is an extension in the Unix standard which does not directly
	 violate ISO C.  */
      memset (&__wctomb_state, '\0', sizeof __wctomb_state);

      return fcts->tomb->__stateful;
    }

  return __wcrtomb (s, wchar, &__wctomb_state);
}
예제 #8
0
/*
 * Non-MT-safe version.
 */
wint_t
__ungetwc(wint_t wc, FILE *fp)
{
	char buf[MB_LEN_MAX];
	size_t len;

	if (wc == WEOF)
		return (WEOF);
#ifndef __SYMBIAN32__	
	if ((len = __wcrtomb(buf, wc, &fp->_extra->mbstate)) == (size_t)-1) {
#else //__SYMBIAN32__
	if ((len = wcrtomb(buf, wc, &fp->_extra->mbstate)) == (size_t)-1) {
#endif //__SYMBIAN32__
		fp->_flags |= __SERR;
		return (WEOF);
	}
	while (len-- != 0)
		if (__ungetc((unsigned char)buf[len], fp) == EOF)
			return (WEOF);

	return (wc);
}

/*
 * MT-safe version.
 */
EXPORT_C wint_t
ungetwc(wint_t wc, FILE *fp)
{
	wint_t r;

	FLOCKFILE(fp);
	ORIENT(fp, 1);
	r = __ungetwc(wc, fp);
	FUNLOCKFILE(fp);

	return (r);
}