659 lines
18 KiB
C
659 lines
18 KiB
C
/*
|
|
* String functions
|
|
*
|
|
* Copyright 1993 Yngvi Sigurjonsson
|
|
* Copyright 1996 Alexandre Julliard
|
|
*/
|
|
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "wingdi.h"
|
|
#include "winuser.h"
|
|
#include "ntddk.h"
|
|
#include "wine/winbase16.h"
|
|
#include "wine/winuser16.h"
|
|
#include "wine/keyboard16.h"
|
|
#include "wine/exception.h"
|
|
#include "winerror.h"
|
|
#include "crtdll.h"
|
|
#include "ldt.h"
|
|
#include "debugtools.h"
|
|
#include "winnls.h"
|
|
|
|
DEFAULT_DEBUG_CHANNEL(string)
|
|
|
|
static const BYTE STRING_Oem2Ansi[256] =
|
|
"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\244"
|
|
"\020\021\022\023\266\247\026\027\030\031\032\033\034\035\036\037"
|
|
"\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
|
|
"\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
|
|
"\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
|
|
"\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
|
|
"\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
|
|
"\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
|
|
"\307\374\351\342\344\340\345\347\352\353\350\357\356\354\304\305"
|
|
"\311\346\306\364\366\362\373\371\377\326\334\242\243\245\120\203"
|
|
"\341\355\363\372\361\321\252\272\277\137\254\275\274\241\253\273"
|
|
"\137\137\137\246\246\246\246\053\053\246\246\053\053\053\053\053"
|
|
"\053\055\055\053\055\053\246\246\053\053\055\055\246\055\053\055"
|
|
"\055\055\055\053\053\053\053\053\053\053\053\137\137\246\137\137"
|
|
"\137\337\137\266\137\137\265\137\137\137\137\137\137\137\137\137"
|
|
"\137\261\137\137\137\137\367\137\260\225\267\137\156\262\137\137";
|
|
|
|
static const BYTE STRING_Ansi2Oem[256] =
|
|
"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017"
|
|
"\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
|
|
"\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
|
|
"\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
|
|
"\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
|
|
"\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
|
|
"\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
|
|
"\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
|
|
"\200\201\054\237\054\137\375\374\210\045\123\074\117\215\216\217"
|
|
"\220\140\047\042\042\371\055\137\230\231\163\076\157\235\236\131"
|
|
"\040\255\233\234\017\235\335\025\042\143\246\256\252\055\162\137"
|
|
"\370\361\375\063\047\346\024\372\054\061\247\257\254\253\137\250"
|
|
"\101\101\101\101\216\217\222\200\105\220\105\105\111\111\111\111"
|
|
"\104\245\117\117\117\117\231\170\117\125\125\125\232\131\137\341"
|
|
"\205\240\203\141\204\206\221\207\212\202\210\211\215\241\214\213"
|
|
"\144\244\225\242\223\157\224\366\157\227\243\226\201\171\137\230";
|
|
|
|
#define OEM_TO_ANSI(ch) (STRING_Oem2Ansi[(unsigned char)(ch)])
|
|
#define ANSI_TO_OEM(ch) (STRING_Ansi2Oem[(unsigned char)(ch)])
|
|
|
|
/* Internaly used by strchr family functions */
|
|
static BOOL ChrCmpA( WORD word1, WORD word2);
|
|
|
|
|
|
/* filter for page-fault exceptions */
|
|
static WINE_EXCEPTION_FILTER(page_fault)
|
|
{
|
|
if (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION)
|
|
return EXCEPTION_EXECUTE_HANDLER;
|
|
return EXCEPTION_CONTINUE_SEARCH;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* hmemcpy (KERNEL.348)
|
|
*/
|
|
void WINAPI hmemcpy16( LPVOID dst, LPCVOID src, LONG count )
|
|
{
|
|
memcpy( dst, src, count );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcat16 (KERNEL.89)
|
|
*/
|
|
SEGPTR WINAPI lstrcat16( SEGPTR dst, LPCSTR src )
|
|
{
|
|
/* Windows does not check for NULL pointers here, so we don't either */
|
|
strcat( (LPSTR)PTR_SEG_TO_LIN(dst), src );
|
|
return dst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcatA (KERNEL32.599)
|
|
*/
|
|
LPSTR WINAPI lstrcatA( LPSTR dst, LPCSTR src )
|
|
{
|
|
__TRY
|
|
{
|
|
strcat( dst, src );
|
|
}
|
|
__EXCEPT(page_fault)
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return NULL;
|
|
}
|
|
__ENDTRY
|
|
return dst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcatW (KERNEL32.600)
|
|
*/
|
|
LPWSTR WINAPI lstrcatW( LPWSTR dst, LPCWSTR src )
|
|
{
|
|
__TRY
|
|
{
|
|
CRTDLL_wcscat( dst, src );
|
|
}
|
|
__EXCEPT(page_fault)
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return NULL;
|
|
}
|
|
__ENDTRY
|
|
return dst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcatn16 (KERNEL.352)
|
|
*/
|
|
SEGPTR WINAPI lstrcatn16( SEGPTR dst, LPCSTR src, INT16 n )
|
|
{
|
|
LPSTR p = (LPSTR)PTR_SEG_TO_LIN(dst);
|
|
|
|
while (*p) p++;
|
|
if ((n -= (p - (LPSTR)PTR_SEG_TO_LIN(dst))) <= 0) return dst;
|
|
lstrcpynA( p, src, n );
|
|
return dst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcmp16 (USER.430)
|
|
*/
|
|
INT16 WINAPI lstrcmp16( LPCSTR str1, LPCSTR str2 )
|
|
{
|
|
return (INT16)strcmp( str1, str2 );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcmpA (KERNEL.602)
|
|
*/
|
|
INT WINAPI lstrcmpA( LPCSTR str1, LPCSTR str2 )
|
|
{
|
|
return CompareStringA(LOCALE_SYSTEM_DEFAULT,0,str1,-1,str2,-1) - 2 ;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcmpW (KERNEL.603)
|
|
* FIXME : should call CompareStringW, when it is implemented.
|
|
* This implementation is not "word sort", as it should.
|
|
*/
|
|
INT WINAPI lstrcmpW( LPCWSTR str1, LPCWSTR str2 )
|
|
{
|
|
TRACE("%s and %s\n",
|
|
debugstr_w (str1), debugstr_w (str2));
|
|
if (!str1 || !str2) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return 0;
|
|
}
|
|
while (*str1 && (*str1 == *str2)) { str1++; str2++; }
|
|
return (INT)(*str1 - *str2);
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcmpi16 (USER.471)
|
|
*/
|
|
INT16 WINAPI lstrcmpi16( LPCSTR str1, LPCSTR str2 )
|
|
{
|
|
return (INT16)lstrcmpiA( str1, str2 );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcmpiA (KERNEL32.605)
|
|
*/
|
|
INT WINAPI lstrcmpiA( LPCSTR str1, LPCSTR str2 )
|
|
{ TRACE("strcmpi %s and %s\n",
|
|
debugstr_a (str1), debugstr_a (str2));
|
|
return CompareStringA(LOCALE_SYSTEM_DEFAULT,NORM_IGNORECASE,str1,-1,str2,-1)-2;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcmpiW (KERNEL32.606)
|
|
*/
|
|
INT WINAPI lstrcmpiW( LPCWSTR str1, LPCWSTR str2 )
|
|
{
|
|
INT res;
|
|
|
|
#if 0
|
|
/* Too much! (From registry loading.) */
|
|
TRACE("strcmpi %s and %s\n",
|
|
debugstr_w (str1), debugstr_w (str2));
|
|
#endif
|
|
if (!str1 || !str2) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return 0;
|
|
}
|
|
while (*str1)
|
|
{
|
|
if ((*str1<0x100 ) && (*str2<0x100)) {
|
|
if ((res = toupper(*str1) - toupper(*str2)) != 0) return res;
|
|
} else {
|
|
if ((res = NTDLL_towupper(*str1) - NTDLL_towupper(*str2)) != 0) return res;
|
|
}
|
|
str1++;
|
|
str2++;
|
|
}
|
|
return NTDLL_towupper(*str1) - NTDLL_towupper(*str2);
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcpy16 (KERNEL.88)
|
|
*/
|
|
SEGPTR WINAPI lstrcpy16( SEGPTR dst, LPCSTR src )
|
|
{
|
|
if (!lstrcpyA( PTR_SEG_TO_LIN(dst), src )) dst = 0;
|
|
return dst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcpyA (KERNEL32.608)
|
|
*/
|
|
LPSTR WINAPI lstrcpyA( LPSTR dst, LPCSTR src )
|
|
{
|
|
__TRY
|
|
{
|
|
/* this is how Windows does it */
|
|
memmove( dst, src, strlen(src)+1 );
|
|
}
|
|
__EXCEPT(page_fault)
|
|
{
|
|
ERR("(%p, %p): page fault occurred ! Caused by bug ?\n", dst, src);
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return NULL;
|
|
}
|
|
__ENDTRY
|
|
return dst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcpyW (KERNEL32.609)
|
|
*/
|
|
LPWSTR WINAPI lstrcpyW( LPWSTR dst, LPCWSTR src )
|
|
{
|
|
__TRY
|
|
{
|
|
CRTDLL_wcscpy( dst, src );
|
|
}
|
|
__EXCEPT(page_fault)
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return NULL;
|
|
}
|
|
__ENDTRY
|
|
return dst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcpyn16 (KERNEL.353)
|
|
*/
|
|
SEGPTR WINAPI lstrcpyn16( SEGPTR dst, LPCSTR src, INT16 n )
|
|
{
|
|
lstrcpynA( (LPSTR)PTR_SEG_TO_LIN(dst), src, n );
|
|
return dst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcpynA (KERNEL32.611)
|
|
* Note: this function differs from the UNIX strncpy, it _always_ writes
|
|
* a terminating \0
|
|
*/
|
|
LPSTR WINAPI lstrcpynA( LPSTR dst, LPCSTR src, INT n )
|
|
{
|
|
LPSTR p = dst;
|
|
TRACE("(%p, %s, %i)\n", dst, debugstr_an(src,n), n);
|
|
/* In real windows the whole function is protected by an exception handler
|
|
* that returns ERROR_INVALID_PARAMETER on faulty parameters
|
|
* We currently just check for NULL.
|
|
*/
|
|
if (!dst || !src) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return 0;
|
|
}
|
|
while ((n-- > 1) && *src) *p++ = *src++;
|
|
if (n >= 0) *p = 0;
|
|
return dst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcpynW (KERNEL32.612)
|
|
* Note: this function differs from the UNIX strncpy, it _always_ writes
|
|
* a terminating \0
|
|
*/
|
|
LPWSTR WINAPI lstrcpynW( LPWSTR dst, LPCWSTR src, INT n )
|
|
{
|
|
LPWSTR p = dst;
|
|
TRACE("(%p, %s, %i)\n", dst, debugstr_wn(src,n), n);
|
|
/* In real windows the whole function is protected by an exception handler
|
|
* that returns ERROR_INVALID_PARAMETER on faulty parameters
|
|
* We currently just check for NULL.
|
|
*/
|
|
if (!dst || !src) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return 0;
|
|
}
|
|
while ((n-- > 1) && *src) *p++ = *src++;
|
|
if (n >= 0) *p = 0;
|
|
return dst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrlen16 (KERNEL.90)
|
|
*/
|
|
INT16 WINAPI lstrlen16( LPCSTR str )
|
|
{
|
|
return (INT16)lstrlenA( str );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrlenA (KERNEL32.614)
|
|
*/
|
|
INT WINAPI lstrlenA( LPCSTR str )
|
|
{
|
|
INT ret;
|
|
__TRY
|
|
{
|
|
ret = strlen(str);
|
|
}
|
|
__EXCEPT(page_fault)
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return 0;
|
|
}
|
|
__ENDTRY
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrlenW (KERNEL32.615)
|
|
*/
|
|
INT WINAPI lstrlenW( LPCWSTR str )
|
|
{
|
|
INT ret;
|
|
__TRY
|
|
{
|
|
ret = CRTDLL_wcslen(str);
|
|
}
|
|
__EXCEPT(page_fault)
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return 0;
|
|
}
|
|
__ENDTRY
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcpyAtoW (Not a Windows API)
|
|
*/
|
|
LPWSTR WINAPI lstrcpyAtoW( LPWSTR dst, LPCSTR src )
|
|
{
|
|
MultiByteToWideChar( CP_ACP, 0, src, -1, dst, 0x7fffffff );
|
|
return dst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcpyWtoA (Not a Windows API)
|
|
*/
|
|
LPSTR WINAPI lstrcpyWtoA( LPSTR dst, LPCWSTR src )
|
|
{
|
|
WideCharToMultiByte( CP_ACP, 0, src, -1, dst, 0x7fffffff, NULL, NULL );
|
|
return dst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcpynAtoW (Not a Windows API)
|
|
* Note: this function differs from the UNIX strncpy, it _always_ writes
|
|
* a terminating \0
|
|
*/
|
|
LPWSTR WINAPI lstrcpynAtoW( LPWSTR dst, LPCSTR src, INT n )
|
|
{
|
|
if (n > 0 && !MultiByteToWideChar( CP_ACP, 0, src, -1, dst, n )) dst[n-1] = 0;
|
|
return dst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* lstrcpynWtoA (Not a Windows API)
|
|
* Note: this function differs from the UNIX strncpy, it _always_ writes
|
|
* a terminating \0
|
|
*
|
|
* The terminating zero should be written at the end of the string, not
|
|
* the end of the buffer, as some programs specify the wrong size for
|
|
* the buffer (eg. winnt's sol.exe)
|
|
*/
|
|
LPSTR WINAPI lstrcpynWtoA( LPSTR dst, LPCWSTR src, INT n )
|
|
{
|
|
if (n > 0 && !WideCharToMultiByte( CP_ACP, 0, src, -1, dst, n, NULL, NULL )) dst[n-1] = 0;
|
|
return dst;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* UnicodeToAnsi (KERNEL.434)
|
|
*/
|
|
INT16 WINAPI UnicodeToAnsi16( LPCWSTR src, LPSTR dst, INT16 codepage )
|
|
{
|
|
if ( codepage != -1 )
|
|
FIXME("codepage %d not supported\n", codepage );
|
|
|
|
lstrcpyWtoA( dst, src );
|
|
|
|
return (INT16)lstrlenA( dst );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* Copy (GDI.250)
|
|
*/
|
|
void WINAPI Copy16( LPVOID src, LPVOID dst, WORD size )
|
|
{
|
|
memcpy( dst, src, size );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* AnsiToOem16 (KEYBOARD.5)
|
|
*/
|
|
INT16 WINAPI AnsiToOem16( LPCSTR s, LPSTR d )
|
|
{
|
|
CharToOemA( s, d );
|
|
return -1;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* OemToAnsi16 (KEYBOARD.6)
|
|
*/
|
|
INT16 WINAPI OemToAnsi16( LPCSTR s, LPSTR d )
|
|
{
|
|
OemToCharA( s, d );
|
|
return -1;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* AnsiToOemBuff16 (KEYBOARD.134)
|
|
*/
|
|
void WINAPI AnsiToOemBuff16( LPCSTR s, LPSTR d, UINT16 len )
|
|
{
|
|
if (len != 0) CharToOemBuffA( s, d, len );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* OemToAnsiBuff16 (KEYBOARD.135)
|
|
*/
|
|
void WINAPI OemToAnsiBuff16( LPCSTR s, LPSTR d, UINT16 len )
|
|
{
|
|
if (len != 0) OemToCharBuffA( s, d, len );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CharToOemA (USER32.37)
|
|
*/
|
|
BOOL WINAPI CharToOemA( LPCSTR s, LPSTR d )
|
|
{
|
|
LPSTR oldd = d;
|
|
if (!s || !d) return TRUE;
|
|
TRACE("CharToOem %s\n", debugstr_a (s));
|
|
while ((*d++ = ANSI_TO_OEM(*s++)));
|
|
TRACE(" to %s\n", debugstr_a (oldd));
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CharToOemBuffA (USER32.38)
|
|
*/
|
|
BOOL WINAPI CharToOemBuffA( LPCSTR s, LPSTR d, DWORD len )
|
|
{
|
|
while (len--) *d++ = ANSI_TO_OEM(*s++);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CharToOemBuffW (USER32.39)
|
|
*/
|
|
BOOL WINAPI CharToOemBuffW( LPCWSTR s, LPSTR d, DWORD len )
|
|
{
|
|
while (len--) *d++ = ANSI_TO_OEM(*s++);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CharToOemW (USER32.40)
|
|
*/
|
|
BOOL WINAPI CharToOemW( LPCWSTR s, LPSTR d )
|
|
{
|
|
LPSTR oldd = d;
|
|
if (!s || !d) return TRUE;
|
|
TRACE("CharToOem %s\n", debugstr_w (s));
|
|
while ((*d++ = ANSI_TO_OEM(*s++)));
|
|
TRACE(" to %s\n", debugstr_a (oldd));
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* OemToCharA (USER32.402)
|
|
*/
|
|
BOOL WINAPI OemToCharA( LPCSTR s, LPSTR d )
|
|
{
|
|
LPSTR oldd = d;
|
|
TRACE("OemToChar %s\n", debugstr_a (s));
|
|
while ((*d++ = OEM_TO_ANSI(*s++)));
|
|
TRACE(" to %s\n", debugstr_a (oldd));
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* OemToCharBuffA (USER32.403)
|
|
*/
|
|
BOOL WINAPI OemToCharBuffA( LPCSTR s, LPSTR d, DWORD len )
|
|
{
|
|
TRACE("OemToCharBuff %s\n", debugstr_an (s, len));
|
|
while (len--) *d++ = OEM_TO_ANSI(*s++);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* OemToCharBuffW (USER32.404)
|
|
*/
|
|
BOOL WINAPI OemToCharBuffW( LPCSTR s, LPWSTR d, DWORD len )
|
|
{
|
|
TRACE("OemToCharBuff %s\n", debugstr_an (s, len));
|
|
while (len--) *d++ = (WCHAR)OEM_TO_ANSI(*s++);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* OemToCharW (USER32.405)
|
|
*/
|
|
BOOL WINAPI OemToCharW( LPCSTR s, LPWSTR d )
|
|
{
|
|
while ((*d++ = (WCHAR)OEM_TO_ANSI(*s++)));
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lstrrchr (Not a Windows API)
|
|
*
|
|
* This is the implementation meant to be invoked from within
|
|
* COMCTL32_StrRChrA and shell32(TODO)...
|
|
*
|
|
* Return a pointer to the last occurence of wMatch in lpStart
|
|
* not looking further than lpEnd...
|
|
*/
|
|
LPSTR WINAPI lstrrchr( LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch )
|
|
{
|
|
LPCSTR lpGotIt = NULL;
|
|
|
|
TRACE("(%p, %p, %x)\n", lpStart, lpEnd, wMatch);
|
|
|
|
if (!lpEnd) lpEnd = lpStart + strlen(lpStart);
|
|
|
|
for(; lpStart < lpEnd; lpStart = CharNextA(lpStart))
|
|
if (!ChrCmpA( GET_WORD(lpStart), wMatch))
|
|
lpGotIt = lpStart;
|
|
|
|
return ((LPSTR)lpGotIt);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ChrCmpW
|
|
* This fuction returns FALSE if both words match, TRUE otherwise...
|
|
*/
|
|
static BOOL ChrCmpW( WORD word1, WORD word2) {
|
|
return (word1 != word2);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* lstrrchrw (Not a Windows API)
|
|
*
|
|
* This is the implementation meant to be invoked form within
|
|
* COMCTL32_StrRChrW and shell32(TODO)...
|
|
*
|
|
* Return a pointer to the last occurence of wMatch in lpStart
|
|
* not looking further than lpEnd...
|
|
*/
|
|
LPWSTR WINAPI lstrrchrw( LPCWSTR lpStart, LPCWSTR lpEnd, WORD wMatch )
|
|
{
|
|
LPCWSTR lpGotIt = NULL;
|
|
|
|
TRACE("(%p, %p, %x)\n", lpStart, lpEnd, wMatch);
|
|
if (!lpEnd) lpEnd = lpStart + lstrlenW(lpStart);
|
|
|
|
for(; lpStart < lpEnd; lpStart = CharNextW(lpStart))
|
|
if (!ChrCmpW( GET_WORD(lpStart), wMatch))
|
|
lpGotIt = lpStart;
|
|
|
|
return (LPWSTR)lpGotIt;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ChrCmpA
|
|
* This fuction returns FALSE if both words match, TRUE otherwise...
|
|
*/
|
|
static BOOL ChrCmpA( WORD word1, WORD word2) {
|
|
if (LOBYTE(word1) == LOBYTE(word2)) {
|
|
if (IsDBCSLeadByte(LOBYTE(word1))) {
|
|
return (word1 != word2);
|
|
}
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|