mirror of
https://github.com/reactos/reactos.git
synced 2024-08-21 10:53:15 +00:00
![Bișoc George](/assets/img/avatar_default.png)
This is a partial sync of the CRT library with wcsrtombs_l and _mbstowcs_l functions from WINE. The _wctomb_s_l implementation of WINE which is used by _wctomb_s, _wctomb_l and wctomb brings failed results of the wctomb unit testcase and at the same time it crashes the whole testcase after. Therefore I will not address the wctomb function for the moment being.
484 lines
10 KiB
C
484 lines
10 KiB
C
/*
|
|
* PROJECT: ReactOS CRT library
|
|
* LICENSE: LGPL - See COPYING in the top level directory
|
|
* FILE: lib/sdk/crt/string/wcs.c
|
|
* PURPOSE: wcs* CRT functions
|
|
* PROGRAMMERS: Wine team
|
|
* Ported to ReactOS by Aleksey Bragin (aleksey@reactos.org)
|
|
*/
|
|
|
|
/*
|
|
* msvcrt.dll wide-char functions
|
|
*
|
|
* Copyright 1999 Alexandre Julliard
|
|
* Copyright 2000 Jon Griffiths
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
#include <precomp.h>
|
|
#include <assert.h>
|
|
|
|
#ifndef _LIBCNT_
|
|
#include <internal/wine/msvcrt.h>
|
|
#endif
|
|
|
|
#include "wine/unicode.h"
|
|
#undef sprintf
|
|
#undef wsprintf
|
|
#undef snprintf
|
|
#undef vsnprintf
|
|
#undef vprintf
|
|
#undef vwprintf
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma function(_wcsset)
|
|
#endif
|
|
|
|
#ifndef _LIBCNT_
|
|
/*********************************************************************
|
|
* _wcsdup (MSVCRT.@)
|
|
*/
|
|
wchar_t* CDECL _wcsdup( const wchar_t* str )
|
|
{
|
|
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 (MSVCRT.@)
|
|
*/
|
|
INT CDECL _wcsicoll( const wchar_t* str1, const wchar_t* str2 )
|
|
{
|
|
/* FIXME: handle collates */
|
|
return strcmpiW( str1, str2 );
|
|
}
|
|
#endif
|
|
|
|
/*********************************************************************
|
|
* _wcsnset (MSVCRT.@)
|
|
*/
|
|
wchar_t* CDECL _wcsnset( wchar_t* str, wchar_t c, size_t n )
|
|
{
|
|
wchar_t* ret = str;
|
|
while ((n-- > 0) && *str) *str++ = c;
|
|
return ret;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _wcsrev (MSVCRT.@)
|
|
*/
|
|
wchar_t* CDECL _wcsrev( wchar_t* str )
|
|
{
|
|
wchar_t* ret = str;
|
|
wchar_t* end = str + strlenW(str) - 1;
|
|
while (end > str)
|
|
{
|
|
wchar_t t = *end;
|
|
*end-- = *str;
|
|
*str++ = t;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
#ifndef _LIBCNT_
|
|
/*********************************************************************
|
|
* _wcsset (MSVCRT.@)
|
|
*/
|
|
wchar_t* CDECL _wcsset( wchar_t* str, wchar_t c )
|
|
{
|
|
wchar_t* ret = str;
|
|
while (*str) *str++ = c;
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************
|
|
* _wcsupr_s (MSVCRT.@)
|
|
*
|
|
*/
|
|
INT CDECL _wcsupr_s( wchar_t* str, size_t n )
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* wcstod (MSVCRT.@)
|
|
*/
|
|
double CDECL wcstod(const wchar_t* lpszStr, wchar_t** end)
|
|
{
|
|
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;
|
|
}
|
|
#endif
|
|
|
|
/*********************************************************************
|
|
* wcscoll (MSVCRT.@)
|
|
*/
|
|
int CDECL wcscoll( const wchar_t* str1, const wchar_t* str2 )
|
|
{
|
|
/* FIXME: handle collates */
|
|
return strcmpW( str1, str2 );
|
|
}
|
|
|
|
/*********************************************************************
|
|
* wcspbrk (MSVCRT.@)
|
|
*/
|
|
wchar_t* CDECL wcspbrk( const wchar_t* str, const wchar_t* accept )
|
|
{
|
|
const wchar_t* p;
|
|
while (*str)
|
|
{
|
|
for (p = accept; *p; p++) if (*p == *str) return (wchar_t*)str;
|
|
str++;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
#ifndef _LIBCNT_
|
|
|
|
/*********************************************************************
|
|
* wctomb (MSVCRT.@)
|
|
*/
|
|
/*********************************************************************
|
|
* wctomb (MSVCRT.@)
|
|
*/
|
|
INT CDECL wctomb( char *dst, wchar_t ch )
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* wcsrtombs_l (INTERNAL)
|
|
*/
|
|
static size_t CDECL wcsrtombs_l(char *mbstr, const wchar_t **wcstr,
|
|
size_t count, _locale_t locale)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _wcstombs_l (MSVCRT.@)
|
|
*/
|
|
size_t CDECL _wcstombs_l(char *mbstr, const wchar_t *wcstr, size_t count, _locale_t locale)
|
|
{
|
|
return wcsrtombs_l(mbstr, &wcstr, count, locale);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* wcstombs (MSVCRT.@)
|
|
*/
|
|
size_t CDECL wcstombs(char *mbstr, const wchar_t *wcstr, size_t count)
|
|
{
|
|
return wcsrtombs_l(mbstr, &wcstr, count, NULL);
|
|
}
|
|
#endif
|
|
|
|
/*********************************************************************
|
|
* wcscpy_s (MSVCRT.@)
|
|
*/
|
|
INT CDECL wcscpy_s( wchar_t* wcDest, size_t numElement, const wchar_t *wcSrc)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/******************************************************************
|
|
* wcsncpy_s (MSVCRT.@)
|
|
*/
|
|
INT CDECL wcsncpy_s( wchar_t* wcDest, size_t numElement, const wchar_t *wcSrc,
|
|
size_t count )
|
|
{
|
|
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;
|
|
}
|
|
|
|
/******************************************************************
|
|
* wcscat_s (MSVCRT.@)
|
|
*
|
|
*/
|
|
INT CDECL wcscat_s(wchar_t* dst, size_t elem, const wchar_t* src)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* wcsncat_s (MSVCRT.@)
|
|
*
|
|
*/
|
|
INT CDECL wcsncat_s(wchar_t *dst, size_t elem,
|
|
const wchar_t *src, size_t count)
|
|
{
|
|
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;
|
|
}
|
|
|