559 lines
13 KiB
C
559 lines
13 KiB
C
/*
|
|
* CRTDLL multi-byte string functions
|
|
*
|
|
* Copyright 1999 Alexandre Julliard
|
|
* Copyright 2000 Jon Griffths
|
|
*
|
|
* NOTES
|
|
* See msdn.microsoft.com
|
|
* /library/devprods/vs6/visualc/vccore/_crt__ismbb_routines.htm
|
|
* For details and CP 932 information.
|
|
*
|
|
* This code assumes that MB_LEN_MAX is 2 and that [0,0] is an
|
|
* invalid MB char. If that changes, this will need to too.
|
|
*
|
|
* CRTDLL reports valid CP 932 multibyte chars when the current
|
|
* code page is not 932. MSVCRT fixes this bug - we implement
|
|
* MSVCRT's behaviour, since its correct. However, MSVCRT fails
|
|
* to set the code page correctly when the locale is changed, so
|
|
* it must be explicitly set to get matching results.
|
|
*
|
|
* FIXME
|
|
* Not currently binary compatable with win32. CRTDLL_mbctype must be
|
|
* populated correctly and the ismb* functions should reference it.
|
|
*/
|
|
|
|
#include "crtdll.h"
|
|
|
|
DEFAULT_DEBUG_CHANNEL(crtdll);
|
|
|
|
UCHAR CRTDLL_mbctype[257];
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbscmp (CRTDLL.??)
|
|
*
|
|
* Compare two multibyte strings.
|
|
*/
|
|
INT __cdecl CRTDLL__mbscmp( LPCSTR str, LPCSTR cmp )
|
|
{
|
|
if (CRTDLL__mb_cur_max_dll > 1)
|
|
{
|
|
UINT strc, cmpc;
|
|
do {
|
|
if (!*str)
|
|
return *cmp ? -1 : 0;
|
|
if (!*cmp)
|
|
return 1;
|
|
strc = CRTDLL__mbsnextc(str);
|
|
cmpc = CRTDLL__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 strcmp(str, cmp); /* ASCII CP */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbsicmp (CRTDLL.??)
|
|
*
|
|
* Compare two multibyte strings case insensitively.
|
|
*/
|
|
INT __cdecl CRTDLL__mbsicmp( LPCSTR str, LPCSTR cmp )
|
|
{
|
|
/* FIXME: No tolower() for mb strings yet */
|
|
if (CRTDLL__mb_cur_max_dll > 1)
|
|
return CRTDLL__mbscmp( str, cmp );
|
|
return strcasecmp( str, cmp ); /* ASCII CP */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbsncmp (CRTDLL.??)
|
|
*
|
|
* Compare two multibyte strings to 'len' characters.
|
|
*/
|
|
INT __cdecl CRTDLL__mbsncmp( LPCSTR str, LPCSTR cmp, UINT len )
|
|
{
|
|
if (!len)
|
|
return 0;
|
|
|
|
if (CRTDLL__mb_cur_max_dll > 1)
|
|
{
|
|
UINT strc, cmpc;
|
|
while (len--)
|
|
{
|
|
if (!*str)
|
|
return *cmp ? -1 : 0;
|
|
if (!*cmp)
|
|
return 1;
|
|
strc = CRTDLL__mbsnextc(str);
|
|
cmpc = CRTDLL__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 strncmp(str, cmp, len); /* ASCII CP */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbsnicmp (CRTDLL.??)
|
|
*
|
|
* Compare two multibyte strings case insensitively to 'len' characters.
|
|
*/
|
|
INT __cdecl CRTDLL__mbsnicmp( LPCSTR str, LPCSTR cmp, UINT len )
|
|
{
|
|
/* FIXME: No tolower() for mb strings yet */
|
|
if (CRTDLL__mb_cur_max_dll > 1)
|
|
return CRTDLL__mbsncmp( str, cmp, len );
|
|
return strncasecmp( str, cmp, len ); /* ASCII CP */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbsinc (CRTDLL.205)
|
|
*
|
|
* Return the next character of a string.
|
|
*/
|
|
LPSTR __cdecl CRTDLL__mbsinc( LPCSTR str )
|
|
{
|
|
if (CRTDLL__mb_cur_max_dll > 1 &&
|
|
CRTDLL_isleadbyte(*str))
|
|
return (LPSTR)str + 2; /* MB char */
|
|
|
|
return (LPSTR)str + 1; /* ASCII CP or SB char */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbsninc (CRTDLL.??)
|
|
*
|
|
* Return the 'num'th character of a string.
|
|
*/
|
|
LPSTR CRTDLL__mbsninc( LPCSTR str, INT num )
|
|
{
|
|
if (!str || num < 1)
|
|
return NULL;
|
|
if (CRTDLL__mb_cur_max_dll > 1)
|
|
{
|
|
while(num--)
|
|
str = CRTDLL__mbsinc( str );
|
|
return (LPSTR)str;
|
|
}
|
|
return (LPSTR)str + num; /* ASCII CP */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbslen (CRTDLL.206)
|
|
*
|
|
* Get the length of a string.
|
|
*/
|
|
INT __cdecl CRTDLL__mbslen( LPCSTR str )
|
|
{
|
|
if (CRTDLL__mb_cur_max_dll > 1)
|
|
{
|
|
INT len = 0;
|
|
while (*str)
|
|
{
|
|
str += CRTDLL_isleadbyte( *str ) ? 2 : 1;
|
|
len++;
|
|
}
|
|
return len;
|
|
}
|
|
return strlen( str ); /* ASCII CP */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbsrchr (CRTDLL.223)
|
|
*/
|
|
LPSTR __cdecl CRTDLL__mbsrchr(LPCSTR s,CHAR x)
|
|
{
|
|
/* FIXME: handle multibyte strings */
|
|
return strrchr(s,x);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* mbtowc (CRTDLL.430)
|
|
*/
|
|
INT __cdecl CRTDLL_mbtowc( WCHAR *dst, LPCSTR str, INT n )
|
|
{
|
|
if (n <= 0) return 0;
|
|
if (!str) return 0;
|
|
if (!MultiByteToWideChar( CP_ACP, 0, str, n, dst, 1 )) return 0;
|
|
/* return the number of bytes from src that have been used */
|
|
if (!*str) return 0;
|
|
if (n >= 2 && CRTDLL_isleadbyte(*str) && str[1]) return 2;
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbccpy (CRTDLL.??)
|
|
*
|
|
* Copy one multibyte character to another
|
|
*/
|
|
VOID __cdecl CRTDLL__mbccpy(LPSTR dest, LPSTR src)
|
|
{
|
|
*dest++ = *src;
|
|
if (CRTDLL__mb_cur_max_dll > 1 && CRTDLL_isleadbyte(*src))
|
|
*dest = *++src; /* MB char */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbsdec (CRTDLL.??)
|
|
*
|
|
* Return the character before 'cur'.
|
|
*/
|
|
LPSTR __cdecl CRTDLL__mbsdec( LPCSTR start, LPCSTR cur )
|
|
{
|
|
if (CRTDLL__mb_cur_max_dll > 1)
|
|
return (LPSTR)(CRTDLL__ismbstrail(start,cur-1) ? cur - 2 : cur -1);
|
|
|
|
return (LPSTR)cur - 1; /* ASCII CP or SB char */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbbtombc (CRTDLL.??)
|
|
*
|
|
* Convert a single byte character to a multi byte character.
|
|
*/
|
|
USHORT __cdecl CRTDLL__mbbtombc( USHORT c )
|
|
{
|
|
if (CRTDLL__mb_cur_max_dll > 1 &&
|
|
((c >= 0x20 && c <=0x7e) || (c >= 0xa1 && c <= 0xdf)))
|
|
{
|
|
/* FIXME: I can't get this function to return anything
|
|
* different to what I pass it...
|
|
*/
|
|
}
|
|
return c; /* ASCII CP or no MB char */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbclen (CRTDLL.??)
|
|
*
|
|
* Get the length of a multibyte character.
|
|
*/
|
|
INT __cdecl CRTDLL__mbclen( LPCSTR str )
|
|
{
|
|
return CRTDLL_isleadbyte( *str ) ? 2 : 1;
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _ismbbkana (CRTDLL.??)
|
|
*
|
|
* Is the given single byte character Katakana?
|
|
*/
|
|
INT __cdecl CRTDLL__ismbbkana( UINT c )
|
|
{
|
|
/* FIXME: use lc_ctype when supported, not lc_all */
|
|
if (__CRTDLL_current_lc_all_cp == 932)
|
|
{
|
|
/* Japanese/Katakana, CP 932 */
|
|
return (c >= 0xa1 && c <= 0xdf);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _ismbchira (CRTDLL.??)
|
|
*
|
|
* Is the given character Hiragana?
|
|
*/
|
|
INT __cdecl CRTDLL__ismbchira( UINT c )
|
|
{
|
|
/* FIXME: use lc_ctype when supported, not lc_all */
|
|
if (__CRTDLL_current_lc_all_cp == 932)
|
|
{
|
|
/* Japanese/Hiragana, CP 932 */
|
|
return (c >= 0x829f && c <= 0x82f1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _ismbckata (CRTDLL.??)
|
|
*
|
|
* Is the given double byte character Katakana?
|
|
*/
|
|
INT __cdecl CRTDLL__ismbckata( UINT c )
|
|
{
|
|
/* FIXME: use lc_ctype when supported, not lc_all */
|
|
if (__CRTDLL_current_lc_all_cp == 932)
|
|
{
|
|
if ( c < 256)
|
|
return CRTDLL__ismbbkana( c );
|
|
/* Japanese/Katakana, CP 932 */
|
|
return (c >= 0x8340 && c <= 0x8396 && c != 0x837f);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _ismbblead (CRTDLL.??)
|
|
*
|
|
* Is the given single byte character a lead byte?
|
|
*/
|
|
INT __cdecl CRTDLL__ismbblead( UINT c )
|
|
{
|
|
/* FIXME: should reference CRTDLL_mbctype */
|
|
return CRTDLL__mb_cur_max_dll > 1 && CRTDLL_isleadbyte( c );
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _ismbbtrail (CRTDLL.??)
|
|
*
|
|
* Is the given single byte character a trail byte?
|
|
*/
|
|
INT __cdecl CRTDLL__ismbbtrail( UINT c )
|
|
{
|
|
/* FIXME: should reference CRTDLL_mbctype */
|
|
return !CRTDLL__ismbblead( c );
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _ismbslead (CRTDLL.??)
|
|
*
|
|
* Is the character pointed to 'str' a lead byte?
|
|
*/
|
|
INT __cdecl CRTDLL__ismbslead( LPCSTR start, LPCSTR str )
|
|
{
|
|
/* Lead bytes can also be trail bytes if caller messed up
|
|
* iterating through the string...
|
|
*/
|
|
if (CRTDLL__mb_cur_max_dll > 1)
|
|
{
|
|
while (start < str)
|
|
start += CRTDLL_isleadbyte ( *str ) ? 2 : 1;
|
|
|
|
if (start == str)
|
|
return CRTDLL_isleadbyte( *str );
|
|
}
|
|
return 0; /* Must have been a trail, we skipped it */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _ismbstrail (CRTDLL.??)
|
|
*
|
|
* Is the character pointed to 'str' a trail byte?
|
|
*/
|
|
INT __cdecl CRTDLL__ismbstrail( LPCSTR start, LPCSTR str )
|
|
{
|
|
/* Must not be a lead, and must be preceeded by one */
|
|
return !CRTDLL__ismbslead( start, str ) && CRTDLL_isleadbyte(str[-1]);
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbsset (CRTDLL.??)
|
|
*
|
|
* Fill a multibyte string with a value.
|
|
*/
|
|
LPSTR __cdecl CRTDLL__mbsset( LPSTR str, UINT c )
|
|
{
|
|
LPSTR ret = str;
|
|
|
|
if (CRTDLL__mb_cur_max_dll == 1 || c < 256)
|
|
return CRTDLL__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;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _mbsnset (CRTDLL.??)
|
|
*
|
|
* Fill a multibyte string with a value up to 'len' characters.
|
|
*/
|
|
LPSTR __cdecl CRTDLL__mbsnset( LPSTR str, UINT c, UINT len )
|
|
{
|
|
LPSTR ret = str;
|
|
|
|
if (!len)
|
|
return ret;
|
|
|
|
if (CRTDLL__mb_cur_max_dll == 1 || c < 256)
|
|
return CRTDLL__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;
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbstrlen (CRTDLL.??)
|
|
*
|
|
* Get the length of a multibyte string.
|
|
*/
|
|
INT __cdecl CRTDLL__mbstrlen( LPCSTR str )
|
|
{
|
|
if (CRTDLL__mb_cur_max_dll > 1)
|
|
{
|
|
INT len = 0;
|
|
while (*str)
|
|
{
|
|
str += CRTDLL_isleadbyte ( *str ) ? 2 : 1;
|
|
len++;
|
|
}
|
|
return len;
|
|
}
|
|
return strlen( str ); /* ASCII CP */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbsnextc (CRTDLL.??)
|
|
*
|
|
* Get the next character from a multibyte string.
|
|
*/
|
|
UINT __cdecl CRTDLL__mbsnextc( LPCSTR str )
|
|
{
|
|
if (CRTDLL__mb_cur_max_dll > 1 && CRTDLL_isleadbyte( *str ))
|
|
return *str << 8 | str[1];
|
|
|
|
return *str; /* ASCII CP or SB char */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbsncpy (CRTDLL.??)
|
|
*
|
|
* Copy one multibyte string to another up to 'len' characters.
|
|
*/
|
|
LPSTR __cdecl CRTDLL__mbsncpy( LPSTR dst, LPCSTR src, UINT len )
|
|
{
|
|
if (!len)
|
|
return dst;
|
|
if (CRTDLL__mb_cur_max_dll > 1)
|
|
{
|
|
LPSTR ret = dst;
|
|
while (src[0] && src[1] && len--)
|
|
{
|
|
*dst++ = *src++;
|
|
*dst++ = *src++;
|
|
}
|
|
if (len--)
|
|
{
|
|
*dst++ = *src++; /* Last char or '\0' */
|
|
while(len--)
|
|
*dst++ = '\0';
|
|
}
|
|
return ret;
|
|
}
|
|
return strncpy( dst, src, len ); /* ASCII CP */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbschr (CRTDLL.??)
|
|
*
|
|
* Find a multibyte character in a multibyte string.
|
|
*/
|
|
LPSTR __cdecl CRTDLL__mbschr( LPCSTR str, UINT c )
|
|
{
|
|
if (CRTDLL__mb_cur_max_dll > 1)
|
|
{
|
|
UINT next;
|
|
while((next = CRTDLL__mbsnextc( str )))
|
|
{
|
|
if (next == c)
|
|
return (LPSTR)str;
|
|
str += next > 255 ? 2 : 1;
|
|
}
|
|
return c ? NULL : (LPSTR)str;
|
|
}
|
|
return strchr( str, c ); /* ASCII CP */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbsnccnt (CRTDLL.??)
|
|
*
|
|
* Return the number of mutibyte characters in 'len' bytes of a string.
|
|
*/
|
|
UINT __cdecl CRTDLL__mbsnccnt( LPCSTR str, UINT len )
|
|
{
|
|
int ret = 0;
|
|
|
|
if (CRTDLL__mb_cur_max_dll > 1)
|
|
{
|
|
while(*str && len-- > 0)
|
|
{
|
|
if (CRTDLL_isleadbyte ( *str ))
|
|
{
|
|
str++;
|
|
len--;
|
|
}
|
|
ret++;
|
|
str++;
|
|
}
|
|
return ret;
|
|
}
|
|
return min( strlen( str ), len ); /* ASCII CP */
|
|
}
|
|
|
|
|
|
/*********************************************************************
|
|
* _mbsncat (CRTDLL.??)
|
|
*
|
|
* Add 'len' characters from one multibyte string to another.
|
|
*/
|
|
LPSTR __cdecl CRTDLL__mbsncat( LPSTR dst, LPCSTR src, UINT len )
|
|
{
|
|
if (CRTDLL__mb_cur_max_dll > 1)
|
|
{
|
|
LPSTR res = dst;
|
|
dst += CRTDLL__mbslen( dst );
|
|
while (*src && len--)
|
|
{
|
|
*dst = *src;
|
|
if (CRTDLL_isleadbyte( *src ))
|
|
*++dst = *++src;
|
|
dst++;
|
|
src++;
|
|
}
|
|
*dst++ = '\0';
|
|
return res;
|
|
}
|
|
return strncat( dst, src, len ); /* ASCII CP */
|
|
}
|
|
|