Sweden-Number/dlls/msvcrt/mbcs.c

1810 lines
44 KiB
C

/*
* msvcrt.dll mbcs functions
*
* Copyright 1999 Alexandre Julliard
* Copyright 2000 Jon Griffths
*
* 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
*
* FIXME
* Not currently binary compatible with win32. MSVCRT_mbctype must be
* populated correctly and the ismb* functions should reference it.
*/
#include "msvcrt.h"
#include "wine/unicode.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
unsigned char MSVCRT_mbctype[257] = { 0 };
static int g_mbcp_is_multibyte = 0;
int MSVCRT___mb_cur_max = 1;
/* It seems that the data about valid trail bytes is not available from kernel32
* so we have to store is here. The format is the same as for lead bytes in CPINFO */
struct cp_extra_info_t
{
int cp;
BYTE TrailBytes[MAX_LEADBYTES];
};
static struct cp_extra_info_t g_cpextrainfo[] =
{
{932, {0x40, 0x7e, 0x80, 0xfc, 0, 0}},
{936, {0x40, 0xfe, 0, 0}},
{949, {0x41, 0xfe, 0, 0}},
{950, {0x40, 0x7e, 0xa1, 0xfe, 0, 0}},
{1361, {0x31, 0x7e, 0x81, 0xfe, 0, 0}},
{20932, {1, 255, 0, 0}}, /* seems to give different results on different systems */
{0, {1, 255, 0, 0}} /* match all with FIXME */
};
/* Maps multibyte cp932 punctuation marks to single byte equivalents */
static const unsigned char mbctombb_932_punct[] = {
0x20,0xa4,0xa1,0x2c,0x2e,0xa5,0x3a,0x3b,0x3f,0x21,0xde,0xdf,0x00,0x00,0x00,0x5e,
0x7e,0x5f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x00,0x00,0x2f,0x00,
0x00,0x00,0x7c,0x00,0x00,0x60,0x27,0x00,0x22,0x28,0x29,0x00,0x00,0x5b,0x5d,0x7b,
0x7d,0x00,0x00,0x00,0x00,0xa2,0xa3,0x00,0x00,0x00,0x00,0x2b,0x2d,0x00,0x00,0x00,
0x00,0x3d,0x00,0x3c,0x3e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x5c,
0x24,0x00,0x00,0x25,0x23,0x26,0x2a,0x40};
/* Maps multibyte cp932 hiragana/katakana to single-byte equivalents */
static const unsigned char mbctombb_932_kana[] = {
0xa7,0xb1,0xa8,0xb2,0xa9,0xb3,0xaa,0xb4,0xab,0xb5,0xb6,0xb6,0xb7,0xb7,0xb8,0xb8,
0xb9,0xb9,0xba,0xba,0xbb,0xbb,0xbc,0xbc,0xbd,0xbd,0xbe,0xbe,0xbf,0xbf,0xc0,0xc0,
0xc1,0xc1,0xaf,0xc2,0xc2,0xc3,0xc3,0xc4,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xca,
0xca,0xcb,0xcb,0xcb,0xcc,0xcc,0xcc,0xcd,0xcd,0xcd,0xce,0xce,0xce,0xcf,0xd0,0xd1,
0xd2,0xd3,0xac,0xd4,0xad,0xd5,0xae,0xd6,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdc,0xb2,
0xb4,0xa6,0xdd,0xb3,0xb6,0xb9};
static MSVCRT_wchar_t msvcrt_mbc_to_wc(unsigned int ch)
{
MSVCRT_wchar_t chW;
char mbch[2];
int n_chars;
if (ch <= 0xff) {
mbch[0] = ch;
n_chars = 1;
} else {
mbch[0] = (ch >> 8) & 0xff;
mbch[1] = ch & 0xff;
n_chars = 2;
}
if (!MultiByteToWideChar(get_locale()->locinfo->lc_codepage, 0, mbch, n_chars, &chW, 1))
{
WARN("MultiByteToWideChar failed on %x\n", ch);
return 0;
}
return chW;
}
static inline MSVCRT_size_t u_strlen( const unsigned char *str )
{
return strlen( (const char*) str );
}
static inline unsigned char* u_strncat( unsigned char* dst, const unsigned char* src, MSVCRT_size_t len )
{
return (unsigned char*)strncat( (char*)dst, (const char*)src, len);
}
static inline int u_strcmp( const unsigned char *s1, const unsigned char *s2 )
{
return strcmp( (const char*)s1, (const char*)s2 );
}
static inline int u_strcasecmp( const unsigned char *s1, const unsigned char *s2 )
{
return strcasecmp( (const char*)s1, (const char*)s2 );
}
static inline int u_strncmp( const unsigned char *s1, const unsigned char *s2, MSVCRT_size_t len )
{
return strncmp( (const char*)s1, (const char*)s2, len );
}
static inline int u_strncasecmp( const unsigned char *s1, const unsigned char *s2, MSVCRT_size_t len )
{
return strncasecmp( (const char*)s1, (const char*)s2, len );
}
static inline unsigned char *u_strchr( const unsigned char *s, unsigned char x )
{
return (unsigned char*) strchr( (const char*)s, x );
}
static inline unsigned char *u_strrchr( const unsigned char *s, unsigned char x )
{
return (unsigned char*) strrchr( (const char*)s, x );
}
static inline unsigned char *u_strtok( unsigned char *s, const unsigned char *delim )
{
return (unsigned char*) strtok( (char*)s, (const char*)delim );
}
static inline unsigned char *u__strset( unsigned char *s, unsigned char c )
{
return (unsigned char*) _strset( (char*)s, c);
}
static inline unsigned char *u__strnset( unsigned char *s, unsigned char c, MSVCRT_size_t len )
{
return (unsigned char*) MSVCRT__strnset( (char*)s, c, len );
}
static inline MSVCRT_size_t u_strcspn( const unsigned char *s, const unsigned char *rej )
{
return strcspn( (const char *)s, (const char*)rej );
}
/*********************************************************************
* __p__mbctype (MSVCRT.@)
*/
unsigned char* CDECL __p__mbctype(void)
{
return MSVCRT_mbctype;
}
/*********************************************************************
* ___mb_cur_max_func(MSVCRT.@)
*/
int* CDECL MSVCRT____mb_cur_max_func(void)
{
return &get_locale()->locinfo->mb_cur_max;
}
/* ___mb_cur_max_l_func - not exported in native msvcrt */
int* CDECL ___mb_cur_max_l_func(MSVCRT__locale_t locale)
{
if(!locale)
locale = get_locale();
return &locale->locinfo->mb_cur_max;
}
/*********************************************************************
* _setmbcp (MSVCRT.@)
*/
int CDECL _setmbcp(int cp)
{
MSVCRT__locale_t locale = get_locale();
int newcp;
CPINFO cpi;
BYTE *bytes;
WORD chartypes[256];
WORD *curr_type;
char bufA[256];
WCHAR bufW[256];
int charcount;
int ret;
int i;
switch (cp)
{
case _MB_CP_ANSI:
newcp = GetACP();
break;
case _MB_CP_OEM:
newcp = GetOEMCP();
break;
case _MB_CP_LOCALE:
newcp = locale->locinfo->lc_codepage;
break;
case _MB_CP_SBCS:
newcp = 20127; /* ASCII */
break;
default:
newcp = cp;
break;
}
if (!GetCPInfo(newcp, &cpi))
{
WARN("Codepage %d not found\n", newcp);
*MSVCRT__errno() = MSVCRT_EINVAL;
return -1;
}
/* setup the _mbctype */
memset(MSVCRT_mbctype, 0, sizeof(MSVCRT_mbctype));
bytes = cpi.LeadByte;
while (bytes[0] || bytes[1])
{
for (i = bytes[0]; i <= bytes[1]; i++)
MSVCRT_mbctype[i + 1] |= _M1;
bytes += 2;
}
if (cpi.MaxCharSize > 1)
{
/* trail bytes not available through kernel32 but stored in a structure in msvcrt */
struct cp_extra_info_t *cpextra = g_cpextrainfo;
g_mbcp_is_multibyte = 1;
while (TRUE)
{
if (cpextra->cp == 0 || cpextra->cp == newcp)
{
if (cpextra->cp == 0)
FIXME("trail bytes data not available for DBCS codepage %d - assuming all bytes\n", newcp);
bytes = cpextra->TrailBytes;
while (bytes[0] || bytes[1])
{
for (i = bytes[0]; i <= bytes[1]; i++)
MSVCRT_mbctype[i + 1] |= _M2;
bytes += 2;
}
break;
}
cpextra++;
}
}
else
g_mbcp_is_multibyte = 0;
/* we can't use GetStringTypeA directly because we don't have a locale - only a code page
*/
charcount = 0;
for (i = 0; i < 256; i++)
if (!(MSVCRT_mbctype[i + 1] & _M1))
bufA[charcount++] = i;
ret = MultiByteToWideChar(newcp, 0, bufA, charcount, bufW, charcount);
if (ret != charcount)
ERR("MultiByteToWideChar of chars failed for cp %d, ret=%d (exp %d), error=%d\n", newcp, ret, charcount, GetLastError());
GetStringTypeW(CT_CTYPE1, bufW, charcount, chartypes);
curr_type = chartypes;
for (i = 0; i < 256; i++)
if (!(MSVCRT_mbctype[i + 1] & _M1))
{
if ((*curr_type) & C1_UPPER)
MSVCRT_mbctype[i + 1] |= _SBUP;
if ((*curr_type) & C1_LOWER)
MSVCRT_mbctype[i + 1] |= _SBLOW;
curr_type++;
}
if (newcp == 932) /* CP932 only - set _MP and _MS */
{
/* On Windows it's possible to calculate the _MP and _MS from CT_CTYPE1
* and CT_CTYPE3. But as of Wine 0.9.43 we return wrong values what makes
* it hard. As this is set only for codepage 932 we hardcode it what gives
* also faster execution.
*/
for (i = 161; i <= 165; i++)
MSVCRT_mbctype[i + 1] |= _MP;
for (i = 166; i <= 223; i++)
MSVCRT_mbctype[i + 1] |= _MS;
}
locale->locinfo->lc_collate_cp = newcp;
locale->locinfo->lc_codepage = newcp;
TRACE("(%d) -> %d\n", cp, locale->locinfo->lc_codepage);
return 0;
}
/*********************************************************************
* _getmbcp (MSVCRT.@)
*/
int CDECL _getmbcp(void)
{
/* FIXME: get_locale()->mbcinfo->mbcodepage should be used here */
return get_locale()->locinfo->lc_codepage;
}
/*********************************************************************
* _mbsnextc(MSVCRT.@)
*/
unsigned int CDECL _mbsnextc(const unsigned char* str)
{
if(_ismbblead(*str))
return *str << 8 | str[1];
return *str;
}
/*********************************************************************
* _mbctolower(MSVCRT.@)
*/
unsigned int CDECL _mbctolower(unsigned int c)
{
if (MSVCRT_isleadbyte(c))
{
FIXME("Handle MBC chars\n");
return c;
}
return tolower(c); /* ASCII CP or SB char */
}
/*********************************************************************
* _mbctoupper(MSVCRT.@)
*/
unsigned int CDECL _mbctoupper(unsigned int c)
{
if (MSVCRT_isleadbyte(c))
{
FIXME("Handle MBC chars\n");
return c;
}
return toupper(c); /* ASCII CP or SB char */
}
/*********************************************************************
* _mbctombb (MSVCRT.@)
*/
unsigned int CDECL _mbctombb(unsigned int c)
{
unsigned int value;
if(get_locale()->locinfo->lc_codepage == 932)
{
if(c >= 0x829f && c <= 0x82f1) /* Hiragana */
return mbctombb_932_kana[c - 0x829f];
if(c >= 0x8340 && c <= 0x8396 && c != 0x837f) /* Katakana */
return mbctombb_932_kana[c - 0x8340 - (c >= 0x837f ? 1 : 0)];
if(c >= 0x8140 && c <= 0x8197) /* Punctuation */
{
value = mbctombb_932_punct[c - 0x8140];
return value ? value : c;
}
if((c >= 0x824f && c <= 0x8258) || /* Fullwidth digits */
(c >= 0x8260 && c <= 0x8279)) /* Fullwidth capitals letters */
return c - 0x821f;
if(c >= 0x8281 && c <= 0x829a) /* Fullwidth small letters */
return c - 0x8220;
/* all other cases return c */
}
return c;
}
/*********************************************************************
* _mbcjistojms(MSVCRT.@)
*
* Converts a jis character to sjis.
* Based on description from
* http://www.slayers.ne.jp/~oouchi/code/jistosjis.html
*/
unsigned int CDECL _mbcjistojms(unsigned int c)
{
/* Conversion takes place only when codepage is 932.
In all other cases, c is returned unchanged */
if(get_locale()->locinfo->lc_codepage == 932)
{
if(HIBYTE(c) >= 0x21 && HIBYTE(c) <= 0x7e &&
LOBYTE(c) >= 0x21 && LOBYTE(c) <= 0x7e)
{
if(HIBYTE(c) % 2)
c += 0x1f;
else
c += 0x7d;
if(LOBYTE(c) > 0x7F)
c += 0x1;
c = (((HIBYTE(c) - 0x21)/2 + 0x81) << 8) | LOBYTE(c);
if(HIBYTE(c) > 0x9f)
c += 0x4000;
}
else
return 0; /* Codepage is 932, but c can't be converted */
}
return c;
}
/*********************************************************************
* _mbsdec(MSVCRT.@)
*/
unsigned char* CDECL _mbsdec(const unsigned char* start, const unsigned char* cur)
{
if(get_locale()->locinfo->mb_cur_max > 1)
return (unsigned char *)(_ismbstrail(start,cur-1) ? cur - 2 : cur -1);
return (unsigned char *)cur - 1; /* ASCII CP or SB char */
}
/*********************************************************************
* _mbclen(MSVCRT.@)
*/
unsigned int CDECL _mbclen(const unsigned char* str)
{
return _ismbblead(*str) ? 2 : 1;
}
/*********************************************************************
* _mbsinc(MSVCRT.@)
*/
unsigned char* CDECL _mbsinc(const unsigned char* str)
{
return (unsigned char *)(str + _mbclen(str));
}
/*********************************************************************
* _mbsninc(MSVCRT.@)
*/
unsigned char* CDECL _mbsninc(const unsigned char* str, MSVCRT_size_t num)
{
if(!str)
return NULL;
while (num > 0 && *str)
{
if (_ismbblead(*str))
{
if (!*(str+1))
break;
str++;
}
str++;
num--;
}
return (unsigned char*)str;
}
/*********************************************************************
* _mbslen(MSVCRT.@)
*/
MSVCRT_size_t CDECL _mbslen(const unsigned char* str)
{
MSVCRT_size_t len = 0;
while(*str)
{
if (_ismbblead(*str))
{
str++;
if (!*str) /* count only full chars */
break;
}
str++;
len++;
}
return len;
}
/*********************************************************************
* _mbccpy(MSVCRT.@)
*/
void CDECL _mbccpy(unsigned char* dest, const unsigned char* src)
{
*dest = *src;
if(_ismbblead(*src))
*++dest = *++src; /* MB char */
}
/*********************************************************************
* _mbsncpy(MSVCRT.@)
* REMARKS
* The parameter n is the number or characters to copy, not the size of
* the buffer. Use _mbsnbcpy for a function analogical to strncpy
*/
unsigned char* CDECL _mbsncpy(unsigned char* dst, const unsigned char* src, MSVCRT_size_t n)
{
unsigned char* ret = dst;
if(!n)
return dst;
if (g_mbcp_is_multibyte)
{
while (*src && n)
{
n--;
if (_ismbblead(*src))
{
if (!*(src+1))
{
*dst++ = 0;
*dst++ = 0;
break;
}
*dst++ = *src++;
}
*dst++ = *src++;
}
}
else
{
while (n)
{
n--;
if (!(*dst++ = *src++)) break;
}
}
while (n--) *dst++ = 0;
return ret;
}
/*********************************************************************
* _mbsnbcpy_s(MSVCRT.@)
* REMARKS
* Unlike _mbsnbcpy this function does not pad the rest of the dest
* string with 0
*/
int CDECL _mbsnbcpy_s(unsigned char* dst, MSVCRT_size_t size, const unsigned char* src, MSVCRT_size_t n)
{
MSVCRT_size_t pos = 0;
if(!dst || size == 0)
return MSVCRT_EINVAL;
if(!src)
{
dst[0] = '\0';
return MSVCRT_EINVAL;
}
if(!n)
return 0;
if(g_mbcp_is_multibyte)
{
int is_lead = 0;
while (*src && n)
{
if(pos == size)
{
dst[0] = '\0';
return MSVCRT_ERANGE;
}
is_lead = (!is_lead && _ismbblead(*src));
n--;
dst[pos++] = *src++;
}
if (is_lead) /* if string ends with a lead, remove it */
dst[pos - 1] = 0;
}
else
{
while (n)
{
n--;
if(pos == size)
{
dst[0] = '\0';
return MSVCRT_ERANGE;
}
if(!(*src)) break;
dst[pos++] = *src++;
}
}
if(pos < size)
dst[pos] = '\0';
else
{
dst[0] = '\0';
return MSVCRT_ERANGE;
}
return 0;
}
/*********************************************************************
* _mbsnbcpy(MSVCRT.@)
* REMARKS
* Like strncpy this function doesn't enforce the string to be
* NUL-terminated
*/
unsigned char* CDECL _mbsnbcpy(unsigned char* dst, const unsigned char* src, MSVCRT_size_t n)
{
unsigned char* ret = dst;
if(!n)
return dst;
if(g_mbcp_is_multibyte)
{
int is_lead = 0;
while (*src && n)
{
is_lead = (!is_lead && _ismbblead(*src));
n--;
*dst++ = *src++;
}
if (is_lead) /* if string ends with a lead, remove it */
*(dst - 1) = 0;
}
else
{
while (n)
{
n--;
if (!(*dst++ = *src++)) break;
}
}
while (n--) *dst++ = 0;
return ret;
}
/*********************************************************************
* _mbscmp(MSVCRT.@)
*/
int CDECL _mbscmp(const unsigned char* str, const unsigned char* cmp)
{
if(get_locale()->locinfo->mb_cur_max > 1)
{
unsigned int strc, cmpc;
do {
if(!*str)
return *cmp ? -1 : 0;
if(!*cmp)
return 1;
strc = _mbsnextc(str);
cmpc = _mbsnextc(cmp);
if(strc != cmpc)
return strc < cmpc ? -1 : 1;
str +=(strc > 255) ? 2 : 1;
cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
} while(1);
}
return u_strcmp(str, cmp); /* ASCII CP */
}
/*********************************************************************
* _mbsicoll(MSVCRT.@)
* FIXME: handle locales.
*/
int CDECL _mbsicoll(const unsigned char* str, const unsigned char* cmp)
{
if(get_locale()->locinfo->mb_cur_max > 1)
{
unsigned int strc, cmpc;
do {
if(!*str)
return *cmp ? -1 : 0;
if(!*cmp)
return 1;
strc = _mbctolower(_mbsnextc(str));
cmpc = _mbctolower(_mbsnextc(cmp));
if(strc != cmpc)
return strc < cmpc ? -1 : 1;
str +=(strc > 255) ? 2 : 1;
cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
} while(1);
}
return u_strcasecmp(str, cmp); /* ASCII CP */
}
/*********************************************************************
* _mbscoll(MSVCRT.@)
* Performs a case-sensitive comparison according to the current code page
* RETURN
* _NLSCMPERROR if error
* FIXME: handle locales.
*/
int CDECL _mbscoll(const unsigned char* str, const unsigned char* cmp)
{
if(get_locale()->locinfo->mb_cur_max > 1)
{
unsigned int strc, cmpc;
do {
if(!*str)
return *cmp ? -1 : 0;
if(!*cmp)
return 1;
strc = _mbsnextc(str);
cmpc = _mbsnextc(cmp);
if(strc != cmpc)
return strc < cmpc ? -1 : 1;
str +=(strc > 255) ? 2 : 1;
cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
} while(1);
}
return u_strcmp(str, cmp); /* ASCII CP */
}
/*********************************************************************
* _mbsicmp(MSVCRT.@)
*/
int CDECL _mbsicmp(const unsigned char* str, const unsigned char* cmp)
{
if(get_locale()->locinfo->mb_cur_max > 1)
{
unsigned int strc, cmpc;
do {
if(!*str)
return *cmp ? -1 : 0;
if(!*cmp)
return 1;
strc = _mbctolower(_mbsnextc(str));
cmpc = _mbctolower(_mbsnextc(cmp));
if(strc != cmpc)
return strc < cmpc ? -1 : 1;
str +=(strc > 255) ? 2 : 1;
cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
} while(1);
}
return u_strcasecmp(str, cmp); /* ASCII CP */
}
/*********************************************************************
* _mbsncmp(MSVCRT.@)
*/
int CDECL _mbsncmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
{
if(!len)
return 0;
if(get_locale()->locinfo->mb_cur_max > 1)
{
unsigned int strc, cmpc;
while(len--)
{
int inc;
if(!*str)
return *cmp ? -1 : 0;
if(!*cmp)
return 1;
strc = _mbsnextc(str);
cmpc = _mbsnextc(cmp);
if(strc != cmpc)
return strc < cmpc ? -1 : 1;
inc=(strc > 255) ? 2 : 1; /* Equal, use same increment */
str += inc;
cmp += inc;
}
return 0; /* Matched len chars */
}
return u_strncmp(str, cmp, len); /* ASCII CP */
}
/*********************************************************************
* _mbsnbcmp(MSVCRT.@)
*/
int CDECL _mbsnbcmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
{
if (!len)
return 0;
if(get_locale()->locinfo->mb_cur_max > 1)
{
unsigned int strc, cmpc;
while (len)
{
int clen;
if(!*str)
return *cmp ? -1 : 0;
if(!*cmp)
return 1;
if (MSVCRT_isleadbyte(*str))
{
strc=(len>=2)?_mbsnextc(str):0;
clen=2;
}
else
{
strc=*str;
clen=1;
}
if (MSVCRT_isleadbyte(*cmp))
cmpc=(len>=2)?_mbsnextc(cmp):0;
else
cmpc=*str;
if(strc != cmpc)
return strc < cmpc ? -1 : 1;
len -= clen;
str += clen;
cmp += clen;
}
return 0; /* Matched len chars */
}
return u_strncmp(str,cmp,len);
}
/*********************************************************************
* _mbsnicmp(MSVCRT.@)
*
* Compare two multibyte strings case insensitively to 'len' characters.
*/
int CDECL _mbsnicmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
{
/* FIXME: No tolower() for mb strings yet */
if(get_locale()->locinfo->mb_cur_max > 1)
{
unsigned int strc, cmpc;
while(len--)
{
if(!*str)
return *cmp ? -1 : 0;
if(!*cmp)
return 1;
strc = _mbctolower(_mbsnextc(str));
cmpc = _mbctolower(_mbsnextc(cmp));
if(strc != cmpc)
return strc < cmpc ? -1 : 1;
str +=(strc > 255) ? 2 : 1;
cmp +=(strc > 255) ? 2 : 1; /* Equal, use same increment */
}
return 0; /* Matched len chars */
}
return u_strncasecmp(str, cmp, len); /* ASCII CP */
}
/*********************************************************************
* _mbsnbicmp(MSVCRT.@)
*/
int CDECL _mbsnbicmp(const unsigned char* str, const unsigned char* cmp, MSVCRT_size_t len)
{
if (!len)
return 0;
if(get_locale()->locinfo->mb_cur_max > 1)
{
unsigned int strc, cmpc;
while (len)
{
int clen;
if(!*str)
return *cmp ? -1 : 0;
if(!*cmp)
return 1;
if (MSVCRT_isleadbyte(*str))
{
strc=(len>=2)?_mbsnextc(str):0;
clen=2;
}
else
{
strc=*str;
clen=1;
}
if (MSVCRT_isleadbyte(*cmp))
cmpc=(len>=2)?_mbsnextc(cmp):0;
else
cmpc=*str;
strc = _mbctolower(strc);
cmpc = _mbctolower(cmpc);
if(strc != cmpc)
return strc < cmpc ? -1 : 1;
len -= clen;
str += clen;
cmp += clen;
}
return 0; /* Matched len bytes */
}
return u_strncasecmp(str,cmp,len);
}
/*********************************************************************
* _mbscat (MSVCRT.@)
*/
unsigned char * CDECL _mbscat( unsigned char *dst, const unsigned char *src )
{
strcat( (char *)dst, (const char *)src );
return dst;
}
/*********************************************************************
* _mbscpy (MSVCRT.@)
*/
unsigned char* CDECL _mbscpy( unsigned char *dst, const unsigned char *src )
{
strcpy( (char *)dst, (const char *)src );
return dst;
}
/*********************************************************************
* _mbsstr (MSVCRT.@)
*/
unsigned char * CDECL _mbsstr(const unsigned char *haystack, const unsigned char *needle)
{
return (unsigned char *)strstr( (const char *)haystack, (const char *)needle );
}
/*********************************************************************
* _mbschr(MSVCRT.@)
*
* Find a multibyte character in a multibyte string.
*/
unsigned char* CDECL _mbschr(const unsigned char* s, unsigned int x)
{
if(get_locale()->locinfo->mb_cur_max > 1)
{
unsigned int c;
while (1)
{
c = _mbsnextc(s);
if (c == x)
return (unsigned char*)s;
if (!c)
return NULL;
s += c > 255 ? 2 : 1;
}
}
return u_strchr(s, x); /* ASCII CP */
}
/*********************************************************************
* _mbsrchr(MSVCRT.@)
*/
unsigned char* CDECL _mbsrchr(const unsigned char* s, unsigned int x)
{
if(get_locale()->locinfo->mb_cur_max > 1)
{
unsigned int c;
unsigned char* match=NULL;
if(!s)
return NULL;
while (1) {
c = _mbsnextc(s);
if (c == x)
match=(unsigned char*)s;
if (!c)
return match;
s +=(c > 255) ? 2 : 1;
}
}
return u_strrchr(s, x);
}
/*********************************************************************
* _mbstok(MSVCRT.@)
*
* Find and extract tokens from strings
*/
unsigned char* CDECL _mbstok(unsigned char *str, const unsigned char *delim)
{
thread_data_t *data = msvcrt_get_thread_data();
unsigned char *ret;
if(get_locale()->locinfo->mb_cur_max > 1)
{
unsigned int c;
if (!str)
if (!(str = data->mbstok_next)) return NULL;
while ((c = _mbsnextc(str)) && _mbschr(delim, c)) {
str += c > 255 ? 2 : 1;
}
if (!*str) return NULL;
ret = str++;
while ((c = _mbsnextc(str)) && !_mbschr(delim, c)) {
str += c > 255 ? 2 : 1;
}
if (*str) {
*str++ = 0;
if (c > 255) *str++ = 0;
}
data->mbstok_next = str;
return ret;
}
return u_strtok(str, delim); /* ASCII CP */
}
/*********************************************************************
* mbtowc(MSVCRT.@)
*/
int CDECL MSVCRT_mbtowc(MSVCRT_wchar_t *dst, const char* str, MSVCRT_size_t n)
{
/* temp var needed because MultiByteToWideChar wants non NULL destination */
MSVCRT_wchar_t tmpdst = '\0';
if(n <= 0 || !str)
return 0;
if(!MultiByteToWideChar(CP_ACP, 0, str, n, &tmpdst, 1))
return -1;
if(dst)
*dst = tmpdst;
/* return the number of bytes from src that have been used */
if(!*str)
return 0;
if(n >= 2 && MSVCRT_isleadbyte(*str) && str[1])
return 2;
return 1;
}
/*********************************************************************
* _mbbtombc(MSVCRT.@)
*/
unsigned int CDECL _mbbtombc(unsigned int c)
{
if(get_locale()->locinfo->mb_cur_max > 1 &&
((c >= 0x20 && c <=0x7e) ||(c >= 0xa1 && c <= 0xdf)))
{
/* FIXME: I can't get this function to return anything
* different from what I pass it...
*/
}
return c; /* ASCII CP or no MB char */
}
/*********************************************************************
* _mbbtype(MSVCRT.@)
*/
int CDECL _mbbtype(unsigned char c, int type)
{
if (type == 1)
{
if ((c >= 0x20 && c <= 0x7e) || (c >= 0xa1 && c <= 0xdf))
return _MBC_SINGLE;
else if ((c >= 0x40 && c <= 0x7e) || (c >= 0x80 && c <= 0xfc))
return _MBC_TRAIL;
else
return _MBC_ILLEGAL;
}
else
{
if ((c >= 0x20 && c <= 0x7e) || (c >= 0xa1 && c <= 0xdf))
return _MBC_SINGLE;
else if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfc))
return _MBC_LEAD;
else
return _MBC_ILLEGAL;
}
}
/*********************************************************************
* _ismbbkana(MSVCRT.@)
*/
int CDECL _ismbbkana(unsigned int c)
{
/* FIXME: use lc_ctype when supported, not lc_all */
if(get_locale()->locinfo->lc_codepage == 932)
{
/* Japanese/Katakana, CP 932 */
return (c >= 0xa1 && c <= 0xdf);
}
return 0;
}
/*********************************************************************
* _ismbcdigit(MSVCRT.@)
*/
int CDECL _ismbcdigit(unsigned int ch)
{
MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
return (get_char_typeW( wch ) & C1_DIGIT);
}
/*********************************************************************
* _ismbcgraph(MSVCRT.@)
*/
int CDECL _ismbcgraph(unsigned int ch)
{
MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
return (get_char_typeW( wch ) & (C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA));
}
/*********************************************************************
* _ismbcalpha (MSVCRT.@)
*/
int CDECL _ismbcalpha(unsigned int ch)
{
MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
return (get_char_typeW( wch ) & C1_ALPHA);
}
/*********************************************************************
* _ismbclower (MSVCRT.@)
*/
int CDECL _ismbclower(unsigned int ch)
{
MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
return (get_char_typeW( wch ) & C1_UPPER);
}
/*********************************************************************
* _ismbcupper (MSVCRT.@)
*/
int CDECL _ismbcupper(unsigned int ch)
{
MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
return (get_char_typeW( wch ) & C1_LOWER);
}
/*********************************************************************
* _ismbcsymbol(MSVCRT.@)
*/
int CDECL _ismbcsymbol(unsigned int ch)
{
MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
WORD ctype;
if (!GetStringTypeW(CT_CTYPE3, &wch, 1, &ctype))
{
WARN("GetStringTypeW failed on %x\n", ch);
return 0;
}
return ((ctype & C3_SYMBOL) != 0);
}
/*********************************************************************
* _ismbcalnum (MSVCRT.@)
*/
int CDECL _ismbcalnum(unsigned int ch)
{
MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
return (get_char_typeW( wch ) & (C1_ALPHA | C1_DIGIT));
}
/*********************************************************************
* _ismbcspace (MSVCRT.@)
*/
int CDECL _ismbcspace(unsigned int ch)
{
MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
return (get_char_typeW( wch ) & C1_SPACE);
}
/*********************************************************************
* _ismbcprint (MSVCRT.@)
*/
int CDECL _ismbcprint(unsigned int ch)
{
MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
return (get_char_typeW( wch ) & (C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA | C1_SPACE));
}
/*********************************************************************
* _ismbcpunct(MSVCRT.@)
*/
int CDECL _ismbcpunct(unsigned int ch)
{
MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
return (get_char_typeW( wch ) & C1_PUNCT);
}
/*********************************************************************
* _ismbchira(MSVCRT.@)
*/
int CDECL _ismbchira(unsigned int c)
{
/* FIXME: use lc_ctype when supported, not lc_all */
if(get_locale()->locinfo->lc_codepage == 932)
{
/* Japanese/Hiragana, CP 932 */
return (c >= 0x829f && c <= 0x82f1);
}
return 0;
}
/*********************************************************************
* _ismbckata(MSVCRT.@)
*/
int CDECL _ismbckata(unsigned int c)
{
/* FIXME: use lc_ctype when supported, not lc_all */
if(get_locale()->locinfo->lc_codepage == 932)
{
if(c < 256)
return _ismbbkana(c);
/* Japanese/Katakana, CP 932 */
return (c >= 0x8340 && c <= 0x8396 && c != 0x837f);
}
return 0;
}
/*********************************************************************
* _ismbblead(MSVCRT.@)
*/
int CDECL _ismbblead(unsigned int c)
{
return (MSVCRT_mbctype[(c&0xff) + 1] & _M1) != 0;
}
/*********************************************************************
* _ismbbtrail(MSVCRT.@)
*/
int CDECL _ismbbtrail(unsigned int c)
{
return (MSVCRT_mbctype[(c&0xff) + 1] & _M2) != 0;
}
/*********************************************************************
* _ismbclegal(MSVCRT.@)
*/
int CDECL _ismbclegal(unsigned int c)
{
return _ismbblead(HIBYTE(c)) && _ismbbtrail(LOBYTE(c));
}
/*********************************************************************
* _ismbslead(MSVCRT.@)
*/
int CDECL _ismbslead(const unsigned char* start, const unsigned char* str)
{
int lead = 0;
if(!g_mbcp_is_multibyte)
return 0;
/* Lead bytes can also be trail bytes so we need to analyse the string
*/
while (start <= str)
{
if (!*start)
return 0;
lead = !lead && _ismbblead(*start);
start++;
}
return lead ? -1 : 0;
}
/*********************************************************************
* _ismbstrail(MSVCRT.@)
*/
int CDECL _ismbstrail(const unsigned char* start, const unsigned char* str)
{
/* Note: this function doesn't check _ismbbtrail */
if ((str > start) && _ismbslead(start, str-1))
return -1;
else
return 0;
}
/*********************************************************************
* _mbsbtype (MSVCRT.@)
*/
int CDECL _mbsbtype(const unsigned char *str, MSVCRT_size_t count)
{
int lead = 0;
const unsigned char *end = str + count;
int mbcp = g_mbcp_is_multibyte;
/* Lead bytes can also be trail bytes so we need to analyse the string.
* Also we must return _MBC_ILLEGAL for chars past the end of the string
*/
while (str < end) /* Note: we skip the last byte - will check after the loop */
{
if (!*str)
return _MBC_ILLEGAL;
lead = mbcp && !lead && _ismbblead(*str);
str++;
}
if (lead)
if (_ismbbtrail(*str))
return _MBC_TRAIL;
else
return _MBC_ILLEGAL;
else
if (_ismbblead(*str))
return _MBC_LEAD;
else
return _MBC_SINGLE;
}
/*********************************************************************
* _mbsset(MSVCRT.@)
*/
unsigned char* CDECL _mbsset(unsigned char* str, unsigned int c)
{
unsigned char* ret = str;
if(get_locale()->locinfo->mb_cur_max == 1 || c < 256)
return u__strset(str, c); /* ASCII CP or SB char */
c &= 0xffff; /* Strip high bits */
while(str[0] && str[1])
{
*str++ = c >> 8;
*str++ = c & 0xff;
}
if(str[0])
str[0] = '\0'; /* FIXME: OK to shorten? */
return ret;
}
/*********************************************************************
* _mbsnbset(MSVCRT.@)
*/
unsigned char* CDECL _mbsnbset(unsigned char *str, unsigned int c, MSVCRT_size_t len)
{
unsigned char *ret = str;
if(!len)
return ret;
if(get_locale()->locinfo->mb_cur_max == 1 || c < 256)
return u__strnset(str, c, len); /* ASCII CP or SB char */
c &= 0xffff; /* Strip high bits */
while(str[0] && str[1] && (len > 1))
{
*str++ = c >> 8;
len--;
*str++ = c & 0xff;
len--;
}
if(len && str[0]) {
/* as per msdn pad with a blank character */
str[0] = ' ';
}
return ret;
}
/*********************************************************************
* _mbsnset(MSVCRT.@)
*/
unsigned char* CDECL _mbsnset(unsigned char* str, unsigned int c, MSVCRT_size_t len)
{
unsigned char *ret = str;
if(!len)
return ret;
if(get_locale()->locinfo->mb_cur_max == 1 || c < 256)
return u__strnset(str, c, len); /* ASCII CP or SB char */
c &= 0xffff; /* Strip high bits */
while(str[0] && str[1] && len--)
{
*str++ = c >> 8;
*str++ = c & 0xff;
}
if(len && str[0])
str[0] = '\0'; /* FIXME: OK to shorten? */
return ret;
}
/*********************************************************************
* _mbsnccnt(MSVCRT.@)
* 'c' is for 'character'.
*/
MSVCRT_size_t CDECL _mbsnccnt(const unsigned char* str, MSVCRT_size_t len)
{
MSVCRT_size_t ret;
if(get_locale()->locinfo->mb_cur_max > 1)
{
ret=0;
while(*str && len-- > 0)
{
if(MSVCRT_isleadbyte(*str))
{
if (!len)
break;
len--;
str++;
}
str++;
ret++;
}
return ret;
}
ret=u_strlen(str);
return min(ret, len); /* ASCII CP */
}
/*********************************************************************
* _mbsnbcnt(MSVCRT.@)
* 'b' is for byte count.
*/
MSVCRT_size_t CDECL _mbsnbcnt(const unsigned char* str, MSVCRT_size_t len)
{
MSVCRT_size_t ret;
if(get_locale()->locinfo->mb_cur_max > 1)
{
const unsigned char* xstr = str;
while(*xstr && len-- > 0)
{
if (MSVCRT_isleadbyte(*xstr++))
xstr++;
}
return xstr-str;
}
ret=u_strlen(str);
return min(ret, len); /* ASCII CP */
}
/*********************************************************************
* _mbsnbcat(MSVCRT.@)
*/
unsigned char* CDECL _mbsnbcat(unsigned char* dst, const unsigned char* src, MSVCRT_size_t len)
{
if(get_locale()->locinfo->mb_cur_max > 1)
{
unsigned char *res = dst;
while (*dst) {
if (MSVCRT_isleadbyte(*dst++)) {
if (*dst) {
dst++;
} else {
/* as per msdn overwrite the lead byte in front of '\0' */
dst--;
break;
}
}
}
while (*src && len--) *dst++ = *src++;
*dst = '\0';
return res;
}
return u_strncat(dst, src, len); /* ASCII CP */
}
/*********************************************************************
* _mbsncat(MSVCRT.@)
*/
unsigned char* CDECL _mbsncat(unsigned char* dst, const unsigned char* src, MSVCRT_size_t len)
{
if(get_locale()->locinfo->mb_cur_max > 1)
{
unsigned char *res = dst;
while (*dst)
{
if (MSVCRT_isleadbyte(*dst++))
dst++;
}
while (*src && len--)
{
*dst++ = *src;
if(MSVCRT_isleadbyte(*src++))
*dst++ = *src++;
}
*dst = '\0';
return res;
}
return u_strncat(dst, src, len); /* ASCII CP */
}
/*********************************************************************
* _mbslwr(MSVCRT.@)
*/
unsigned char* CDECL _mbslwr(unsigned char* s)
{
unsigned char *ret = s;
if (!s)
return NULL;
if (get_locale()->locinfo->mb_cur_max > 1)
{
unsigned int c;
while (*s)
{
c = _mbctolower(_mbsnextc(s));
/* Note that I assume that the size of the character is unchanged */
if (c > 255)
{
*s++=(c>>8);
c=c & 0xff;
}
*s++=c;
}
}
else for ( ; *s; s++) *s = tolower(*s);
return ret;
}
/*********************************************************************
* _mbsupr(MSVCRT.@)
*/
unsigned char* CDECL _mbsupr(unsigned char* s)
{
unsigned char *ret = s;
if (!s)
return NULL;
if (get_locale()->locinfo->mb_cur_max > 1)
{
unsigned int c;
while (*s)
{
c = _mbctoupper(_mbsnextc(s));
/* Note that I assume that the size of the character is unchanged */
if (c > 255)
{
*s++=(c>>8);
c=c & 0xff;
}
*s++=c;
}
}
else for ( ; *s; s++) *s = toupper(*s);
return ret;
}
/*********************************************************************
* _mbsspn (MSVCRT.@)
*/
MSVCRT_size_t CDECL _mbsspn(const unsigned char* string, const unsigned char* set)
{
const unsigned char *p, *q;
for (p = string; *p; p++)
{
if (MSVCRT_isleadbyte(*p))
{
for (q = set; *q; q++)
{
if (!q[1])
break;
if ((*p == *q) && (p[1] == q[1]))
break;
q++;
}
if (!q[0] || !q[1]) break;
}
else
{
for (q = set; *q; q++)
if (*p == *q)
break;
if (!*q) break;
}
}
return p - string;
}
/*********************************************************************
* _mbsspnp (MSVCRT.@)
*/
unsigned char* CDECL _mbsspnp(const unsigned char* string, const unsigned char* set)
{
const unsigned char *p, *q;
for (p = string; *p; p++)
{
if (MSVCRT_isleadbyte(*p))
{
for (q = set; *q; q++)
{
if (!q[1])
break;
if ((*p == *q) && (p[1] == q[1]))
break;
q++;
}
if (!q[0] || !q[1]) break;
}
else
{
for (q = set; *q; q++)
if (*p == *q)
break;
if (!*q) break;
}
}
if (*p == '\0')
return NULL;
return (unsigned char *)p;
}
/*********************************************************************
* _mbscspn(MSVCRT.@)
*/
MSVCRT_size_t CDECL _mbscspn(const unsigned char* str, const unsigned char* cmp)
{
if (get_locale()->locinfo->mb_cur_max > 1)
FIXME("don't handle double character case\n");
return u_strcspn(str, cmp);
}
/*********************************************************************
* _mbsrev (MSVCRT.@)
*/
unsigned char* CDECL _mbsrev(unsigned char* str)
{
int i, len = _mbslen(str);
unsigned char *p, *temp=MSVCRT_malloc(len*2);
if(!temp)
return str;
/* unpack multibyte string to temp buffer */
p=str;
for(i=0; i<len; i++)
{
if (MSVCRT_isleadbyte(*p))
{
temp[i*2]=*p++;
temp[i*2+1]=*p++;
}
else
{
temp[i*2]=*p++;
temp[i*2+1]=0;
}
}
/* repack it in the reverse order */
p=str;
for(i=len-1; i>=0; i--)
{
if(MSVCRT_isleadbyte(temp[i*2]))
{
*p++=temp[i*2];
*p++=temp[i*2+1];
}
else
{
*p++=temp[i*2];
}
}
MSVCRT_free(temp);
return str;
}
/*********************************************************************
* _mbspbrk (MSVCRT.@)
*/
unsigned char* CDECL _mbspbrk(const unsigned char* str, const unsigned char* accept)
{
const unsigned char* p;
while(*str)
{
for(p = accept; *p; p += (MSVCRT_isleadbyte(*p)?2:1) )
{
if (*p == *str)
if( !MSVCRT_isleadbyte(*p) || ( *(p+1) == *(str+1) ) )
return (unsigned char*)str;
}
str += (MSVCRT_isleadbyte(*str)?2:1);
}
return NULL;
}
/*
* Functions depending on locale codepage
*/
/*********************************************************************
* mblen(MSVCRT.@)
* REMARKS
* Unlike most of the multibyte string functions this function uses
* the locale codepage, not the codepage set by _setmbcp
*/
int CDECL MSVCRT_mblen(const char* str, MSVCRT_size_t size)
{
if (str && *str && size)
{
if(get_locale()->locinfo->mb_cur_max == 1)
return 1; /* ASCII CP */
return !MSVCRT_isleadbyte(*str) ? 1 : (size>1 ? 2 : -1);
}
return 0;
}
/*********************************************************************
* _mbstrlen_l(MSVCRT.@)
*/
MSVCRT_size_t CDECL _mbstrlen_l(const char* str, MSVCRT__locale_t locale)
{
if(!locale)
locale = get_locale();
if(locale->locinfo->mb_cur_max > 1) {
MSVCRT_size_t len = 0;
while(*str) {
/* FIXME: According to the documentation we are supposed to test for
* multi-byte character validity. Whatever that means
*/
str += MSVCRT_isleadbyte(*str) ? 2 : 1;
len++;
}
return len;
}
return strlen(str);
}
/*********************************************************************
* _mbstrlen(MSVCRT.@)
*/
MSVCRT_size_t CDECL _mbstrlen(const char* str)
{
return _mbstrlen_l(str, NULL);
}
/*********************************************************************
* _mbstowcs_l(MSVCRT.@)
*/
MSVCRT_size_t CDECL MSVCRT__mbstowcs_l(MSVCRT_wchar_t *wcstr, const char *mbstr,
MSVCRT_size_t count, MSVCRT__locale_t locale)
{
MSVCRT_size_t tmp;
if(!locale)
locale = get_locale();
tmp = _mbstrlen_l(mbstr, locale);
if(tmp>count && wcstr)
tmp = count;
tmp = MultiByteToWideChar(locale->locinfo->lc_codepage, 0,
mbstr, tmp, wcstr, count);
if(tmp<count && wcstr)
wcstr[tmp] = '\0';
return tmp;
}
/*********************************************************************
* mbstowcs(MSVCRT.@)
*/
MSVCRT_size_t CDECL MSVCRT_mbstowcs(MSVCRT_wchar_t *wcstr,
const char *mbstr, MSVCRT_size_t count)
{
return MSVCRT__mbstowcs_l(wcstr, mbstr, count, NULL);
}
/*********************************************************************
* _mbstowcs_s_l(MSVCRT.@)
*/
int CDECL MSVCRT__mbstowcs_s_l(MSVCRT_size_t *ret, MSVCRT_wchar_t *wcstr,
MSVCRT_size_t size, const char *mbstr,
MSVCRT_size_t count, MSVCRT__locale_t locale)
{
MSVCRT_size_t conv;
if(!wcstr && !size) {
conv = MSVCRT__mbstowcs_l(NULL, mbstr, 0, locale);
if(ret)
*ret = conv;
return 0;
}
if(!mbstr || !wcstr) {
MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
if(wcstr && size)
wcstr[0] = '\0';
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
}
if(count==_TRUNCATE || size<count)
conv = size;
else
conv = count;
conv = MSVCRT__mbstowcs_l(wcstr, mbstr, conv, locale);
if(conv<size)
wcstr[conv++] = '\0';
else if(conv==size && (count==_TRUNCATE || wcstr[conv-1]=='\0'))
wcstr[conv-1] = '\0';
else {
MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
if(size)
wcstr[0] = '\0';
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
}
if(ret)
*ret = conv;
return 0;
}
/*********************************************************************
* mbstowcs_s(MSVCRT.@)
*/
int CDECL MSVCRT__mbstowcs_s(MSVCRT_size_t *ret, MSVCRT_wchar_t *wcstr,
MSVCRT_size_t size, const char *mbstr, MSVCRT_size_t count)
{
return MSVCRT__mbstowcs_s_l(ret, wcstr, size, mbstr, count, NULL);
}