4 * Copyright 1993 Yngvi Sigurjonsson
5 * Copyright 1996 Alexandre Julliard
10 #include "wine/winbase16.h"
11 #include "wine/winuser16.h"
12 #include "wine/keyboard16.h"
18 static const BYTE STRING_Oem2Ansi
[256] =
19 "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\244"
20 "\020\021\022\023\266\247\026\027\030\031\032\033\034\035\036\037"
21 "\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
22 "\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
23 "\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
24 "\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
25 "\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
26 "\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
27 "\307\374\351\342\344\340\345\347\352\353\350\357\356\354\304\305"
28 "\311\346\306\364\366\362\373\371\377\326\334\242\243\245\120\203"
29 "\341\355\363\372\361\321\252\272\277\137\254\275\274\241\253\273"
30 "\137\137\137\246\246\246\246\053\053\246\246\053\053\053\053\053"
31 "\053\055\055\053\055\053\246\246\053\053\055\055\246\055\053\055"
32 "\055\055\055\053\053\053\053\053\053\053\053\137\137\246\137\137"
33 "\137\337\137\266\137\137\265\137\137\137\137\137\137\137\137\137"
34 "\137\261\137\137\137\137\367\137\260\225\267\137\156\262\137\137";
36 static const BYTE STRING_Ansi2Oem
[256] =
37 "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017"
38 "\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
39 "\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
40 "\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
41 "\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
42 "\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
43 "\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
44 "\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
45 "\200\201\054\237\054\137\375\374\210\045\123\074\117\215\216\217"
46 "\220\140\047\042\042\371\055\137\230\231\163\076\157\235\236\131"
47 "\040\255\233\234\017\235\335\025\042\143\246\256\252\055\162\137"
48 "\370\361\375\063\047\346\024\372\054\061\247\257\254\253\137\250"
49 "\101\101\101\101\216\217\222\200\105\220\105\105\111\111\111\111"
50 "\104\245\117\117\117\117\231\170\117\125\125\125\232\131\137\341"
51 "\205\240\203\141\204\206\221\207\212\202\210\211\215\241\214\213"
52 "\144\244\225\242\223\157\224\366\157\227\243\226\201\171\137\230";
54 #define OEM_TO_ANSI(ch) (STRING_Oem2Ansi[(unsigned char)(ch)])
55 #define ANSI_TO_OEM(ch) (STRING_Ansi2Oem[(unsigned char)(ch)])
57 /* Internaly used by strchr family functions */
58 static BOOL
ChrCmpA( WORD word1
, WORD word2
);
59 static BOOL
ChrCmpW( WORD word1
, WORD word2
);
61 extern LPWSTR __cdecl
CRTDLL_wcschr(LPCWSTR str
,WCHAR xchar
);
64 /***********************************************************************
65 * hmemcpy (KERNEL.348)
67 void WINAPI
hmemcpy16( LPVOID dst
, LPCVOID src
, LONG count
)
69 memcpy( dst
, src
, count
);
73 /***********************************************************************
74 * lstrcat16 (KERNEL.89)
76 SEGPTR WINAPI
lstrcat16( SEGPTR dst
, LPCSTR src
)
78 lstrcatA( (LPSTR
)PTR_SEG_TO_LIN(dst
), src
);
83 /***********************************************************************
84 * lstrcat32A (KERNEL32.599)
86 LPSTR WINAPI
lstrcatA( LPSTR dst
, LPCSTR src
)
88 TRACE(string
,"Append %s to %s\n",
89 debugstr_a (src
), debugstr_a (dst
));
90 /* Windows does not check for NULL pointers here, so we don't either */
96 /***********************************************************************
97 * lstrcat32W (KERNEL32.600)
99 LPWSTR WINAPI
lstrcatW( LPWSTR dst
, LPCWSTR src
)
101 register LPWSTR p
= dst
;
102 TRACE(string
,"Append L%s to L%s\n",
103 debugstr_w (src
), debugstr_w (dst
));
104 /* Windows does not check for NULL pointers here, so we don't either */
106 while ((*p
++ = *src
++));
111 /***********************************************************************
112 * lstrcatn16 (KERNEL.352)
114 SEGPTR WINAPI
lstrcatn16( SEGPTR dst
, LPCSTR src
, INT16 n
)
116 lstrcatnA( (LPSTR
)PTR_SEG_TO_LIN(dst
), src
, n
);
121 /***********************************************************************
122 * lstrcatn32A (Not a Windows API)
124 LPSTR WINAPI
lstrcatnA( LPSTR dst
, LPCSTR src
, INT n
)
126 register LPSTR p
= dst
;
127 TRACE(string
,"strcatn add %d chars from %s to %s\n",
128 n
, debugstr_an (src
, n
), debugstr_a (dst
));
130 if ((n
-= (INT
)(p
- dst
)) <= 0) return dst
;
131 lstrcpynA( p
, src
, n
);
136 /***********************************************************************
137 * lstrcatn32W (Not a Windows API)
139 LPWSTR WINAPI
lstrcatnW( LPWSTR dst
, LPCWSTR src
, INT n
)
141 register LPWSTR p
= dst
;
142 TRACE(string
,"strcatn add %d chars from L%s to L%s\n",
143 n
, debugstr_wn (src
, n
), debugstr_w (dst
));
145 if ((n
-= (INT
)(p
- dst
)) <= 0) return dst
;
146 lstrcpynW( p
, src
, n
);
151 /***********************************************************************
152 * lstrcmp16 (USER.430)
154 INT16 WINAPI
lstrcmp16( LPCSTR str1
, LPCSTR str2
)
156 return (INT16
)strcmp( str1
, str2
);
160 /***********************************************************************
161 * lstrcmp32A (KERNEL.602)
163 INT WINAPI
lstrcmpA( LPCSTR str1
, LPCSTR str2
)
165 return CompareStringA(LOCALE_SYSTEM_DEFAULT
,0,str1
,-1,str2
,-1) - 2 ;
169 /***********************************************************************
170 * lstrcmp32W (KERNEL.603)
171 * FIXME : should call CompareString32W, when it is implemented.
172 * This implementation is not "word sort", as it should.
174 INT WINAPI
lstrcmpW( LPCWSTR str1
, LPCWSTR str2
)
176 TRACE(string
,"L%s and L%s\n",
177 debugstr_w (str1
), debugstr_w (str2
));
178 if (!str1
|| !str2
) {
179 SetLastError(ERROR_INVALID_PARAMETER
);
182 while (*str1
&& (*str1
== *str2
)) { str1
++; str2
++; }
183 return (INT
)(*str1
- *str2
);
187 /***********************************************************************
188 * lstrcmpi16 (USER.471)
190 INT16 WINAPI
lstrcmpi16( LPCSTR str1
, LPCSTR str2
)
192 return (INT16
)lstrcmpiA( str1
, str2
);
196 /***********************************************************************
197 * lstrcmpi32A (KERNEL32.605)
199 INT WINAPI
lstrcmpiA( LPCSTR str1
, LPCSTR str2
)
200 { TRACE(string
,"strcmpi %s and %s\n",
201 debugstr_a (str1
), debugstr_a (str2
));
202 return CompareStringA(LOCALE_SYSTEM_DEFAULT
,NORM_IGNORECASE
,str1
,-1,str2
,-1)-2;
206 /***********************************************************************
207 * lstrcmpi32W (KERNEL32.606)
209 INT WINAPI
lstrcmpiW( LPCWSTR str1
, LPCWSTR str2
)
214 /* Too much! (From registry loading.) */
215 TRACE(string
,"strcmpi L%s and L%s\n",
216 debugstr_w (str1
), debugstr_w (str2
));
218 if (!str1
|| !str2
) {
219 SetLastError(ERROR_INVALID_PARAMETER
);
224 if ((*str1
<0x100 ) && (*str2
<0x100)) {
225 if ((res
= toupper(*str1
) - toupper(*str2
)) != 0) return res
;
227 if ((res
= towupper(*str1
) - towupper(*str2
)) != 0) return res
;
232 return towupper(*str1
) - towupper(*str2
);
236 /***********************************************************************
237 * lstrcpy16 (KERNEL.88)
239 SEGPTR WINAPI
lstrcpy16( SEGPTR dst
, LPCSTR src
)
241 lstrcpyA( (LPSTR
)PTR_SEG_TO_LIN(dst
), src
);
246 /***********************************************************************
247 * lstrcpy32A (KERNEL32.608)
249 LPSTR WINAPI
lstrcpyA( LPSTR dst
, LPCSTR src
)
251 TRACE(string
,"strcpy %s\n", debugstr_a (src
));
252 /* In real windows the whole function is protected by an exception handler
253 * that returns ERROR_INVALID_PARAMETER on faulty parameters
254 * We currently just check for NULL.
257 SetLastError(ERROR_INVALID_PARAMETER
);
265 /***********************************************************************
266 * lstrcpy32W (KERNEL32.609)
268 LPWSTR WINAPI
lstrcpyW( LPWSTR dst
, LPCWSTR src
)
270 register LPWSTR p
= dst
;
271 TRACE(string
,"strcpy L%s\n", debugstr_w (src
));
272 /* In real windows the whole function is protected by an exception handler
273 * that returns ERROR_INVALID_PARAMETER on faulty parameters
274 * We currently just check for NULL.
277 SetLastError(ERROR_INVALID_PARAMETER
);
280 while ((*p
++ = *src
++));
285 /***********************************************************************
286 * lstrcpyn16 (KERNEL.353)
288 SEGPTR WINAPI
lstrcpyn16( SEGPTR dst
, LPCSTR src
, INT16 n
)
290 lstrcpynA( (LPSTR
)PTR_SEG_TO_LIN(dst
), src
, n
);
295 /***********************************************************************
296 * lstrcpyn32A (KERNEL32.611)
297 * Note: this function differs from the UNIX strncpy, it _always_ writes
300 LPSTR WINAPI
lstrcpynA( LPSTR dst
, LPCSTR src
, INT n
)
303 TRACE(string
,"strcpyn %s for %d chars\n",
304 debugstr_an (src
,n
), n
);
305 /* In real windows the whole function is protected by an exception handler
306 * that returns ERROR_INVALID_PARAMETER on faulty parameters
307 * We currently just check for NULL.
310 SetLastError(ERROR_INVALID_PARAMETER
);
313 while ((n
-- > 1) && *src
) *p
++ = *src
++;
319 /***********************************************************************
320 * lstrcpyn32W (KERNEL32.612)
321 * Note: this function differs from the UNIX strncpy, it _always_ writes
324 LPWSTR WINAPI
lstrcpynW( LPWSTR dst
, LPCWSTR src
, INT n
)
327 TRACE(string
,"strcpyn L%s for %d chars\n",
328 debugstr_wn (src
,n
), n
);
329 /* In real windows the whole function is protected by an exception handler
330 * that returns ERROR_INVALID_PARAMETER on faulty parameters
331 * We currently just check for NULL.
334 SetLastError(ERROR_INVALID_PARAMETER
);
337 while ((n
-- > 1) && *src
) *p
++ = *src
++;
343 /***********************************************************************
344 * lstrlen16 (KERNEL.90)
346 INT16 WINAPI
lstrlen16( LPCSTR str
)
348 return (INT16
)lstrlenA( str
);
352 /***********************************************************************
353 * lstrlen32A (KERNEL32.614)
355 INT WINAPI
lstrlenA( LPCSTR str
)
357 /* looks weird, but win3.1 KERNEL got a GeneralProtection handler
358 * in lstrlen() ... we check only for NULL pointer reference.
361 TRACE(string
,"strlen %s\n", debugstr_a (str
));
363 return (INT
)strlen(str
);
367 /***********************************************************************
368 * lstrlen32W (KERNEL32.615)
370 INT WINAPI
lstrlenW( LPCWSTR str
)
373 TRACE(string
,"strlen L%s\n", debugstr_w (str
));
375 while (*str
++) len
++;
380 /***********************************************************************
381 * lstrncmp32A (Not a Windows API)
383 INT WINAPI
lstrncmpA( LPCSTR str1
, LPCSTR str2
, INT n
)
385 TRACE(string
,"strncmp %s and %s for %d chars\n",
386 debugstr_an (str1
, n
), debugstr_an (str2
, n
), n
);
387 return (INT
)strncmp( str1
, str2
, n
);
391 /***********************************************************************
392 * lstrncmp32W (Not a Windows API)
394 INT WINAPI
lstrncmpW( LPCWSTR str1
, LPCWSTR str2
, INT n
)
396 TRACE(string
,"strncmp L%s and L%s for %d chars\n",
397 debugstr_wn (str1
, n
), debugstr_wn (str2
, n
), n
);
399 while ((--n
> 0) && *str1
&& (*str1
== *str2
)) { str1
++; str2
++; }
400 return (INT
)(*str1
- *str2
);
404 /***********************************************************************
405 * lstrncmpi32A (Not a Windows API)
407 INT WINAPI
lstrncmpiA( LPCSTR str1
, LPCSTR str2
, INT n
)
411 TRACE(string
,"strncmpi %s and %s for %d chars\n",
412 debugstr_an (str1
, n
), debugstr_an (str2
, n
), n
);
414 while ((--n
> 0) && *str1
)
415 if ( (res
= toupper(*str1
++) - toupper(*str2
++)) ) return res
;
417 return toupper(*str1
) - toupper(*str2
);
421 /***********************************************************************
422 * lstrncmpi32W (Not a Windows API)
424 INT WINAPI
lstrncmpiW( LPCWSTR str1
, LPCWSTR str2
, INT n
)
428 TRACE(string
,"strncmpi L%s and L%s for %d chars\n",
429 debugstr_wn (str1
, n
), debugstr_wn (str2
, n
), n
);
431 while ((--n
> 0) && *str1
)
433 if ((res
= towupper(*str1
) - towupper(*str2
)) != 0) return res
;
437 return towupper(*str1
) - towupper(*str2
);
441 /***********************************************************************
442 * lstrcpyAtoW (Not a Windows API)
444 LPWSTR WINAPI
lstrcpyAtoW( LPWSTR dst
, LPCSTR src
)
446 register LPWSTR p
= dst
;
448 TRACE(string
,"%s\n",src
);
450 while ((*p
++ = (WCHAR
)(unsigned char)*src
++));
455 /***********************************************************************
456 * lstrcpyWtoA (Not a Windows API)
458 LPSTR WINAPI
lstrcpyWtoA( LPSTR dst
, LPCWSTR src
)
460 register LPSTR p
= dst
;
462 TRACE(string
,"L%s\n",debugstr_w(src
));
464 while ((*p
++ = (CHAR
)*src
++));
469 /***********************************************************************
470 * lstrcpynAtoW (Not a Windows API)
471 * Note: this function differs from the UNIX strncpy, it _always_ writes
474 LPWSTR WINAPI
lstrcpynAtoW( LPWSTR dst
, LPCSTR src
, INT n
)
478 TRACE(string
,"%s %i\n",src
, n
);
480 while ((n
-- > 1) && *src
) *p
++ = (WCHAR
)(unsigned char)*src
++;
486 /***********************************************************************
487 * lstrcpynWtoA (Not a Windows API)
488 * Note: this function differs from the UNIX strncpy, it _always_ writes
491 LPSTR WINAPI
lstrcpynWtoA( LPSTR dst
, LPCWSTR src
, INT n
)
495 TRACE(string
,"L%s %i\n",debugstr_w(src
), n
);
497 while ((n
-- > 1) && *src
) *p
++ = (CHAR
)*src
++;
502 /***********************************************************************
503 * UnicodeToAnsi (KERNEL.434)
505 INT16 WINAPI
UnicodeToAnsi16( LPCWSTR src
, LPSTR dst
, INT16 codepage
)
507 if ( codepage
!= -1 )
508 FIXME( string
, "codepage %d not supported\n", codepage
);
510 lstrcpyWtoA( dst
, src
);
512 return (INT16
)lstrlenA( dst
);
516 /***********************************************************************
519 void WINAPI
Copy16( LPVOID src
, LPVOID dst
, WORD size
)
521 memcpy( dst
, src
, size
);
525 /***********************************************************************
526 * RtlFillMemory (KERNEL32.441)
528 VOID WINAPI
RtlFillMemory( LPVOID ptr
, UINT len
, UINT fill
)
530 memset( ptr
, fill
, len
);
534 /***********************************************************************
535 * RtlMoveMemory (KERNEL32.442)
537 VOID WINAPI
RtlMoveMemory( LPVOID dst
, LPCVOID src
, UINT len
)
539 memmove( dst
, src
, len
);
543 /***********************************************************************
544 * RtlZeroMemory (KERNEL32.444)
546 VOID WINAPI
RtlZeroMemory( LPVOID ptr
, UINT len
)
548 memset( ptr
, 0, len
);
552 /***********************************************************************
553 * AnsiToOem16 (KEYBOARD.5)
555 INT16 WINAPI
AnsiToOem16( LPCSTR s
, LPSTR d
)
562 /***********************************************************************
563 * OemToAnsi16 (KEYBOARD.6)
565 INT16 WINAPI
OemToAnsi16( LPCSTR s
, LPSTR d
)
572 /***********************************************************************
573 * AnsiToOemBuff16 (KEYBOARD.134)
575 void WINAPI
AnsiToOemBuff16( LPCSTR s
, LPSTR d
, UINT16 len
)
577 CharToOemBuffA( s
, d
, len
? len
: 65536 );
581 /***********************************************************************
582 * OemToAnsiBuff16 (KEYBOARD.135)
584 void WINAPI
OemToAnsiBuff16( LPCSTR s
, LPSTR d
, UINT16 len
)
586 OemToCharBuffA( s
, d
, len
? len
: 65536 );
590 /***********************************************************************
591 * CharToOem32A (USER32.37)
593 BOOL WINAPI
CharToOemA( LPCSTR s
, LPSTR d
)
596 if (!s
|| !d
) return TRUE
;
597 TRACE(string
,"CharToOem %s\n", debugstr_a (s
));
598 while ((*d
++ = ANSI_TO_OEM(*s
++)));
599 TRACE(string
," to %s\n", debugstr_a (oldd
));
604 /***********************************************************************
605 * CharToOemBuff32A (USER32.38)
607 BOOL WINAPI
CharToOemBuffA( LPCSTR s
, LPSTR d
, DWORD len
)
609 while (len
--) *d
++ = ANSI_TO_OEM(*s
++);
614 /***********************************************************************
615 * CharToOemBuff32W (USER32.39)
617 BOOL WINAPI
CharToOemBuffW( LPCWSTR s
, LPSTR d
, DWORD len
)
619 while (len
--) *d
++ = ANSI_TO_OEM(*s
++);
624 /***********************************************************************
625 * CharToOem32W (USER32.40)
627 BOOL WINAPI
CharToOemW( LPCWSTR s
, LPSTR d
)
630 if (!s
|| !d
) return TRUE
;
631 TRACE(string
,"CharToOem L%s\n", debugstr_w (s
));
632 while ((*d
++ = ANSI_TO_OEM(*s
++)));
633 TRACE(string
," to %s\n", debugstr_a (oldd
));
638 /***********************************************************************
639 * OemToChar32A (USER32.402)
641 BOOL WINAPI
OemToCharA( LPCSTR s
, LPSTR d
)
644 TRACE(string
,"OemToChar %s\n", debugstr_a (s
));
645 while ((*d
++ = OEM_TO_ANSI(*s
++)));
646 TRACE(string
," to %s\n", debugstr_a (oldd
));
651 /***********************************************************************
652 * OemToCharBuff32A (USER32.403)
654 BOOL WINAPI
OemToCharBuffA( LPCSTR s
, LPSTR d
, DWORD len
)
656 TRACE(string
,"OemToCharBuff %s\n", debugstr_an (s
, len
));
657 while (len
--) *d
++ = OEM_TO_ANSI(*s
++);
662 /***********************************************************************
663 * OemToCharBuff32W (USER32.404)
665 BOOL WINAPI
OemToCharBuffW( LPCSTR s
, LPWSTR d
, DWORD len
)
667 TRACE(string
,"OemToCharBuff %s\n", debugstr_an (s
, len
));
668 while (len
--) *d
++ = (WCHAR
)OEM_TO_ANSI(*s
++);
673 /***********************************************************************
674 * OemToChar32W (USER32.405)
676 BOOL WINAPI
OemToCharW( LPCSTR s
, LPWSTR d
)
678 while ((*d
++ = (WCHAR
)OEM_TO_ANSI(*s
++)));
682 /***********************************************************************
683 * WideCharToLocal (Not a Windows API)
684 * similar lstrcpyWtoA, should handle codepages properly
687 * strlen of the destination string
690 INT WINAPI
WideCharToLocal(
695 TRACE(string
,"(%p, %s, %i)\n", pLocal
, debugstr_w(pWide
),dwChars
);
696 WideCharToMultiByte(CP_ACP
,0,pWide
,-1,pLocal
,dwChars
,NULL
,NULL
);
697 return strlen(pLocal
);
699 /***********************************************************************
700 * LocalToWideChar (Not a Windows API)
701 * similar lstrcpyAtoW, should handle codepages properly
704 * strlen of the destination string
706 INT WINAPI
LocalToWideChar(
711 TRACE(string
,"(%p, %s, %i)\n",pWide
, pLocal
, dwChars
);
712 MultiByteToWideChar(CP_ACP
,0,pLocal
,-1,pWide
,dwChars
);
713 return lstrlenW(pWide
);
717 /***********************************************************************
718 * lstrrchr (Not a Windows API)
720 * This is the implementation meant to be invoked form within
721 * COMCTL32_StrRChrA and shell32(TODO)...
723 * Return a pointer to the last occurence of wMatch in lpStart
724 * not looking further than lpEnd...
726 LPSTR WINAPI
lstrrchr( LPCSTR lpStart
, LPCSTR lpEnd
, WORD wMatch
)
728 LPCSTR lpGotIt
= NULL
;
730 TRACE(string
,"(%s, %s)\n", lpStart
, lpEnd
);
732 if (!lpEnd
) lpEnd
= lpStart
+ strlen(lpStart
);
734 for(; lpStart
< lpEnd
; lpStart
= CharNextA(lpStart
))
735 if (!ChrCmpA( GET_WORD(lpStart
), wMatch
))
738 return ((LPSTR
)lpGotIt
);
741 /***********************************************************************
742 * lstrrchrw (Not a Windows API)
744 * This is the implementation meant to be invoked form within
745 * COMCTL32_StrRChrW and shell32(TODO)...
747 * Return a pointer to the last occurence of wMatch in lpStart
748 * not looking further than lpEnd...
750 LPWSTR WINAPI
lstrrchrw( LPCWSTR lpStart
, LPCWSTR lpEnd
, WORD wMatch
)
752 LPCWSTR lpGotIt
= NULL
;
754 TRACE(string
,"(%p, %p, %c)\n", lpStart
, lpEnd
, wMatch
);
755 if (!lpEnd
) lpEnd
= lpStart
+ lstrlenW(lpStart
);
757 for(; lpStart
< lpEnd
; lpStart
= CharNextW(lpStart
))
758 if (!ChrCmpW( GET_WORD(lpStart
), wMatch
))
761 return (LPWSTR
)lpGotIt
;
764 /***********************************************************************
765 * strstrw (Not a Windows API)
767 * This is the implementation meant to be invoked form within
768 * COMCTL32_StrStrW and shell32(TODO)...
771 LPWSTR WINAPI
strstrw( LPCWSTR lpFirst
, LPCWSTR lpSrch
) {
772 UINT uSrchLen
= (UINT
)lstrlenW(lpSrch
);
773 WORD wMatchBeg
= *(WORD
*)lpSrch
;
775 TRACE(string
,"(%p, %p)\n", lpFirst
, lpSrch
);
778 ((lpFirst
=CRTDLL_wcschr(lpFirst
, wMatchBeg
))!=0) &&
779 lstrncmpW(lpFirst
, lpSrch
, uSrchLen
);
783 return (LPWSTR
)lpFirst
;
787 /***********************************************************************
789 * This fuction returns FALSE if both words match, TRUE otherwise...
791 static BOOL
ChrCmpA( WORD word1
, WORD word2
) {
792 if (LOBYTE(word1
) == LOBYTE(word2
)) {
793 if (IsDBCSLeadByte(LOBYTE(word1
))) {
794 return (word1
!= word2
);
801 /***********************************************************************
803 * This fuction returns FALSE if both words match, TRUE otherwise...
805 static BOOL
ChrCmpW( WORD word1
, WORD word2
) {
806 return (word1
!= word2
);