wcs.c File Reference

#include <precomp.h>
#include <assert.h>
#include <internal/wine/msvcrt.h>
#include "wine/unicode.h"

Include dependency graph for wcs.c:

Go to the source code of this file.

Functions
wchar_t *CDECL	_wcsdup (const wchar_t *str)
INT CDECL	_wcsicoll (const wchar_t *str1, const wchar_t *str2)
wchar_t *CDECL	_wcsnset (wchar_t *str, wchar_t c, size_t n)
wchar_t *CDECL	_wcsrev (wchar_t *str)
wchar_t *CDECL	_wcsset (wchar_t *str, wchar_t c)
INT CDECL	_wcsupr_s (wchar_t *str, size_t n)
double CDECL	wcstod (const wchar_t *lpszStr, wchar_t **end)
int CDECL	wcscoll (const wchar_t *str1, const wchar_t *str2)
wchar_t *CDECL	wcspbrk (const wchar_t *str, const wchar_t *accept)
INT CDECL	wctomb (char *dst, wchar_t ch)
static size_t CDECL	wcsrtombs_l (char *mbstr, const wchar_t **wcstr, size_t count, _locale_t locale)
size_t CDECL	_wcstombs_l (char *mbstr, const wchar_t *wcstr, size_t count, _locale_t locale)
size_t CDECL	wcstombs (char *mbstr, const wchar_t *wcstr, size_t count)
INT CDECL	wcscpy_s (wchar_t *wcDest, size_t numElement, const wchar_t *wcSrc)
INT CDECL	wcsncpy_s (wchar_t *wcDest, size_t numElement, const wchar_t *wcSrc, size_t count)
INT CDECL	wcscat_s (wchar_t *dst, size_t elem, const wchar_t *src)
INT CDECL	wcsncat_s (wchar_t *dst, size_t elem, const wchar_t *src, size_t count)

Function Documentation

_wcsdup()

wchar_t *CDECL _wcsdup

(

const wchar_t *

str

)

Definition at line 53 of file wcs.c.

{
  wchar_t* ret = NULL;
  if (str)
  {
    size_t size = (strlenW(str) + 1) * sizeof(wchar_t);
    ret = malloc( size );
    if (ret) memcpy( ret, str, size );
  }
  return ret;
}

_wcsicoll()

INT CDECL _wcsicoll	(	const wchar_t *	str1,
		const wchar_t *	str2
	)

Definition at line 67 of file wcs.c.

{
  /* FIXME: handle collates */
  return strcmpiW( str1, str2 );
}

_wcsnset()

wchar_t *CDECL _wcsnset	(	wchar_t *	str,
		wchar_t	c,
		size_t	n
	)

Definition at line 77 of file wcs.c.

{
  wchar_t* ret = str;
  while ((n-- > 0) && *str) *str++ = c;
  return ret;
}

_wcsrev()

wchar_t *CDECL _wcsrev

(

wchar_t *

str

)

Definition at line 87 of file wcs.c.

{
  wchar_t* ret = str;
  wchar_t* end = str + strlenW(str) - 1;
  while (end > str)
  {
    wchar_t t = *end;
    *end--  = *str;
    *str++  = t;
  }
  return ret;
}

_wcsset()

wchar_t *CDECL _wcsset	(	wchar_t *	str,
		wchar_t	c
	)

Definition at line 104 of file wcs.c.

{
  wchar_t* ret = str;
  while (*str) *str++ = c;
  return ret;
}

_wcstombs_l()

size_t CDECL _wcstombs_l	(	char *	mbstr,
		const wchar_t *	wcstr,
		size_t	count,
		_locale_t	locale
	)

Definition at line 328 of file wcs.c.

{
    return wcsrtombs_l(mbstr, &wcstr, count, locale);
}

_wcsupr_s()

INT CDECL _wcsupr_s	(	wchar_t *	str,
		size_t	n
	)

Definition at line 115 of file wcs.c.

{
  wchar_t* ptr = str;
 
  if (!str || !n)
  {
    if (str) *str = '\0';
    _set_errno(EINVAL);
    return EINVAL;
  }
 
  while (n--)
  {
    if (!*ptr) return 0;
    *ptr = toupperW(*ptr);
    ptr++;
  }
 
  /* MSDN claims that the function should return and set errno to
   * ERANGE, which doesn't seem to be true based on the tests. */
  *str = '\0';
  _set_errno(EINVAL);
  return EINVAL;
}

wcscat_s()

INT CDECL wcscat_s	(	wchar_t *	dst,
		size_t	elem,
		const wchar_t *	src
	)

Definition at line 406 of file wcs.c.

{
    wchar_t* ptr = dst;
 
    if (!dst || elem == 0) return EINVAL;
    if (!src)
    {
        dst[0] = '\0';
        return EINVAL;
    }
 
    /* seek to end of dst string (or elem if no end of string is found */
    while (ptr < dst + elem && *ptr != '\0') ptr++;
    while (ptr < dst + elem)
    {
        if ((*ptr++ = *src++) == '\0') return 0;
    }
    /* not enough space */
    dst[0] = '\0';
    return ERANGE;
}

wcscoll()

int CDECL wcscoll	(	const wchar_t *	str1,
		const wchar_t *	str2
	)

Definition at line 216 of file wcs.c.

{
  /* FIXME: handle collates */
  return strcmpW( str1, str2 );
}

wcscpy_s()

INT CDECL wcscpy_s	(	wchar_t *	wcDest,
		size_t	numElement,
		const wchar_t *	wcSrc
	)

Definition at line 345 of file wcs.c.

{
    size_t size = 0;
 
    if(!wcDest || !numElement)
        return EINVAL;
 
    wcDest[0] = 0;
 
    if(!wcSrc)
    {
        return EINVAL;
    }
 
    size = strlenW(wcSrc) + 1;
 
    if(size > numElement)
    {
        return ERANGE;
    }
 
    memcpy( wcDest, wcSrc, size*sizeof(WCHAR) );
 
    return 0;
}

wcsncat_s()

INT CDECL wcsncat_s	(	wchar_t *	dst,
		size_t	elem,
		const wchar_t *	src,
		size_t	count
	)

Definition at line 432 of file wcs.c.

{
    size_t srclen;
    wchar_t dststart;
    INT ret = 0;
 
    if (!MSVCRT_CHECK_PMT(dst != NULL) || !MSVCRT_CHECK_PMT(elem > 0))
    {
#ifndef _LIBCNT_
        _set_errno(EINVAL);
#endif
        return EINVAL;
    }
    if (!MSVCRT_CHECK_PMT(src != NULL || count == 0))
        return EINVAL;
    if (count == 0)
        return 0;
 
    for (dststart = 0; dststart < elem; dststart++)
    {
        if (dst[dststart] == '\0')
            break;
    }
    if (dststart == elem)
    {
        MSVCRT_INVALID_PMT("dst[elem] is not NULL terminated\n", EINVAL);
        return EINVAL;
    }
 
    if (count == _TRUNCATE)
    {
        srclen = strlenW(src);
        if (srclen >= (elem - dststart))
        {
            srclen = elem - dststart - 1;
            ret = STRUNCATE;
        }
    }
    else
        srclen = min(strlenW(src), count);
    if (srclen < (elem - dststart))
    {
        memcpy(&dst[dststart], src, srclen*sizeof(wchar_t));
        dst[dststart+srclen] = '\0';
        return ret;
    }
    MSVCRT_INVALID_PMT("dst[elem] is too small", ERANGE);
    dst[0] = '\0';
    return ERANGE;
}

wcsncpy_s()

INT CDECL wcsncpy_s	(	wchar_t *	wcDest,
		size_t	numElement,
		const wchar_t *	wcSrc,
		size_t	count
	)

Definition at line 374 of file wcs.c.

{
    size_t size = 0;
 
    if (!wcDest || !numElement)
        return EINVAL;
 
    wcDest[0] = 0;
 
    if (!wcSrc)
    {
        return EINVAL;
    }
 
    size = min(strlenW(wcSrc), count);
 
    if (size >= numElement)
    {
        return ERANGE;
    }
 
    memcpy( wcDest, wcSrc, size*sizeof(WCHAR) );
    wcDest[size] = '\0';
 
    return 0;
}

wcspbrk()

wchar_t *CDECL wcspbrk	(	const wchar_t *	str,
		const wchar_t *	accept
	)

Definition at line 225 of file wcs.c.

{
  const wchar_t* p;
  while (*str)
  {
    for (p = accept; *p; p++) if (*p == *str) return (wchar_t*)str;
      str++;
  }
  return NULL;
}

wcsrtombs_l()

static size_t CDECL wcsrtombs_l ( char *  mbstr, const wchar_t **  wcstr, size_t  count, _locale_t  locale  )

static

Definition at line 260 of file wcs.c.

{
    MSVCRT_pthreadlocinfo locinfo;
    size_t tmp = 0;
    BOOL used_default;
 
    if(!locale)
        locinfo = get_locinfo();
    else
        locinfo = ((MSVCRT__locale_t)locale)->locinfo;
 
    if(!locinfo->lc_codepage) {
        size_t i;
 
        if(!mbstr)
            return strlenW(*wcstr);
 
        for(i=0; i<count; i++) {
            if((*wcstr)[i] > 255) {
                _set_errno(EILSEQ);
                return -1;
            }
 
            mbstr[i] = (*wcstr)[i];
            if(!(*wcstr)[i]) break;
        }
        return i;
    }
 
    if(!mbstr) {
        tmp = WideCharToMultiByte(locinfo->lc_codepage, WC_NO_BEST_FIT_CHARS,
                *wcstr, -1, NULL, 0, NULL, &used_default);
        if(!tmp || used_default) {
            _set_errno(EILSEQ);
            return -1;
        }
        return tmp-1;
    }
 
    while(**wcstr) {
        char buf[3];
        size_t i, size;
 
        size = WideCharToMultiByte(locinfo->lc_codepage, WC_NO_BEST_FIT_CHARS,
                *wcstr, 1, buf, 3, NULL, &used_default);
        if(!size || used_default) {
            _set_errno(EILSEQ);
            return -1;
        }
        if(tmp+size > count)
            return tmp;
 
        for(i=0; i<size; i++)
            mbstr[tmp++] = buf[i];
        (*wcstr)++;
    }
 
    if(tmp < count) {
        mbstr[tmp] = '\0';
        *wcstr = NULL;
    }
    return tmp;
}

Referenced by _wcstombs_l(), and wcstombs().

wcstod()

double CDECL wcstod	(	const wchar_t *	lpszStr,
		wchar_t **	end
	)

Definition at line 143 of file wcs.c.

{
  const wchar_t* str = lpszStr;
  int negative = 0;
  double ret = 0, divisor = 10.0;
 
  TRACE("(%s,%p) semi-stub\n", debugstr_w(lpszStr), end);
 
  /* FIXME:
   * - Should set errno on failure
   * - Should fail on overflow
   * - Need to check which input formats are allowed
   */
  while (isspaceW(*str))
    str++;
 
  if (*str == '-')
  {
    negative = 1;
    str++;
  }
 
  while (isdigitW(*str))
  {
    ret = ret * 10.0 + (*str - '0');
    str++;
  }
  if (*str == '.')
    str++;
  while (isdigitW(*str))
  {
    ret = ret + (*str - '0') / divisor;
    divisor *= 10;
    str++;
  }
 
  if (*str == 'E' || *str == 'e' || *str == 'D' || *str == 'd')
  {
    int negativeExponent = 0;
    int exponent = 0;
    if (*(++str) == '-')
    {
      negativeExponent = 1;
      str++;
    }
    while (isdigitW(*str))
    {
      exponent = exponent * 10 + (*str - '0');
      str++;
    }
    if (exponent != 0)
    {
      if (negativeExponent)
        ret = ret / pow(10.0, exponent);
      else
        ret = ret * pow(10.0, exponent);
    }
  }
 
  if (negative)
    ret = -ret;
 
  if (end)
    *end = (wchar_t*)str;
 
  TRACE("returning %g\n", ret);
  return ret;
}

wcstombs()

size_t CDECL wcstombs	(	char *	mbstr,
		const wchar_t *	wcstr,
		size_t	count
	)

Definition at line 336 of file wcs.c.

{
    return wcsrtombs_l(mbstr, &wcstr, count, NULL);
}

wctomb()

INT CDECL wctomb	(	char *	dst,
		wchar_t	ch
	)

Definition at line 244 of file wcs.c.

{
    BOOL error;
    INT size;
 
    size = WideCharToMultiByte(get_locinfo()->lc_codepage, 0, &ch, 1, dst, dst ? 6 : 0, NULL, &error);
    if(!size || error) {
        *_errno() = EINVAL;
        return EOF;
    }
    return size;
}