quartz: OutputPin_DeliverNewSegment() is unused so remove it.
[wine] / dlls / comctl32 / string.c
1 /*
2  * String manipulation functions
3  *
4  * Copyright 1998 Eric Kohl
5  *           1998 Juergen Schmied <j.schmied@metronet.de>
6  *           2000 Eric Kohl for CodeWeavers
7  * Copyright 2002 Jon Griffiths
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22  *
23  */
24
25 #include "config.h"
26 #include "wine/port.h"
27
28 #include <stdarg.h>
29 #include <string.h>
30 #include <stdlib.h> /* atoi */
31
32 #include "windef.h"
33 #include "winbase.h"
34 #include "winuser.h"
35 #include "winnls.h"
36
37 #include "comctl32.h"
38
39 #include "wine/unicode.h"
40
41 #include "wine/debug.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(commctrl);
44
45 /*************************************************************************
46  * COMCTL32_ChrCmpHelperA
47  *
48  * Internal helper for ChrCmpA/COMCTL32_ChrCmpIA.
49  *
50  * NOTES
51  *  Both this function and its Unicode counterpart are very inefficient. To
52  *  fix this, CompareString must be completely implemented and optimised
53  *  first. Then the core character test can be taken out of that function and
54  *  placed here, so that it need never be called at all. Until then, do not
55  *  attempt to optimise this code unless you are willing to test that it
56  *  still performs correctly.
57  */
58 static BOOL COMCTL32_ChrCmpHelperA(WORD ch1, WORD ch2, DWORD dwFlags)
59 {
60   char str1[3], str2[3];
61
62   str1[0] = LOBYTE(ch1);
63   if (IsDBCSLeadByte(str1[0]))
64   {
65     str1[1] = HIBYTE(ch1);
66     str1[2] = '\0';
67   }
68   else
69     str1[1] = '\0';
70
71   str2[0] = LOBYTE(ch2);
72   if (IsDBCSLeadByte(str2[0]))
73   {
74     str2[1] = HIBYTE(ch2);
75     str2[2] = '\0';
76   }
77   else
78     str2[1] = '\0';
79
80   return CompareStringA(GetThreadLocale(), dwFlags, str1, -1, str2, -1) - 2;
81 }
82
83 /*************************************************************************
84  * COMCTL32_ChrCmpA (internal)
85  *
86  * Internal helper function.
87  */
88 static BOOL COMCTL32_ChrCmpA(WORD ch1, WORD ch2)
89 {
90   return COMCTL32_ChrCmpHelperA(ch1, ch2, 0);
91 }
92
93 /*************************************************************************
94  * COMCTL32_ChrCmpIA    (internal)
95  *
96  * Compare two characters, ignoring case.
97  *
98  * PARAMS
99  *  ch1 [I] First character to compare
100  *  ch2 [I] Second character to compare
101  *
102  * RETURNS
103  *  FALSE, if the characters are equal.
104  *  Non-zero otherwise.
105  */
106 static BOOL COMCTL32_ChrCmpIA(WORD ch1, WORD ch2)
107 {
108   TRACE("(%d,%d)\n", ch1, ch2);
109
110   return COMCTL32_ChrCmpHelperA(ch1, ch2, NORM_IGNORECASE);
111 }
112
113 /*************************************************************************
114  * COMCTL32_ChrCmpIW
115  *
116  * Internal helper function.
117  */
118 static inline BOOL COMCTL32_ChrCmpIW(WCHAR ch1, WCHAR ch2)
119 {
120   return CompareStringW(GetThreadLocale(), NORM_IGNORECASE, &ch1, 1, &ch2, 1) - 2;
121 }
122
123 /**************************************************************************
124  * Str_GetPtrA [COMCTL32.233]
125  *
126  * Copies a string into a destination buffer.
127  *
128  * PARAMS
129  *     lpSrc   [I] Source string
130  *     lpDest  [O] Destination buffer
131  *     nMaxLen [I] Size of buffer in characters
132  *
133  * RETURNS
134  *     The number of characters copied.
135  */
136 INT WINAPI Str_GetPtrA (LPCSTR lpSrc, LPSTR lpDest, INT nMaxLen)
137 {
138     INT len;
139
140     TRACE("(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
141
142     if ((!lpDest || nMaxLen == 0) && lpSrc)
143         return (strlen(lpSrc) + 1);
144
145     if (nMaxLen == 0)
146         return 0;
147
148     if (lpSrc == NULL) {
149         lpDest[0] = '\0';
150         return 0;
151     }
152
153     len = strlen(lpSrc) + 1;
154     if (len >= nMaxLen)
155         len = nMaxLen;
156
157     RtlMoveMemory (lpDest, lpSrc, len - 1);
158     lpDest[len - 1] = '\0';
159
160     return len;
161 }
162
163 /**************************************************************************
164  * Str_SetPtrA [COMCTL32.234]
165  *
166  * Makes a copy of a string, allocating memory if necessary.
167  *
168  * PARAMS
169  *     lppDest [O] Pointer to destination string
170  *     lpSrc   [I] Source string
171  *
172  * RETURNS
173  *     Success: TRUE
174  *     Failure: FALSE
175  *
176  * NOTES
177  *     Set lpSrc to NULL to free the memory allocated by a previous call
178  *     to this function.
179  */
180 BOOL WINAPI Str_SetPtrA (LPSTR *lppDest, LPCSTR lpSrc)
181 {
182     TRACE("(%p %p)\n", lppDest, lpSrc);
183
184     if (lpSrc) {
185         LPSTR ptr = ReAlloc (*lppDest, strlen (lpSrc) + 1);
186         if (!ptr)
187             return FALSE;
188         strcpy (ptr, lpSrc);
189         *lppDest = ptr;
190     }
191     else {
192         Free (*lppDest);
193         *lppDest = NULL;
194     }
195
196     return TRUE;
197 }
198
199 /**************************************************************************
200  * Str_GetPtrW [COMCTL32.235]
201  *
202  * See Str_GetPtrA.
203  */
204 INT WINAPI Str_GetPtrW (LPCWSTR lpSrc, LPWSTR lpDest, INT nMaxLen)
205 {
206     INT len;
207
208     TRACE("(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
209
210     if (!lpDest && lpSrc)
211         return strlenW (lpSrc);
212
213     if (nMaxLen == 0)
214         return 0;
215
216     if (lpSrc == NULL) {
217         lpDest[0] = '\0';
218         return 0;
219     }
220
221     len = strlenW (lpSrc);
222     if (len >= nMaxLen)
223         len = nMaxLen - 1;
224
225     RtlMoveMemory (lpDest, lpSrc, len*sizeof(WCHAR));
226     lpDest[len] = '\0';
227
228     return len;
229 }
230
231 /**************************************************************************
232  * Str_SetPtrW [COMCTL32.236]
233  *
234  * See Str_SetPtrA.
235  */
236 BOOL WINAPI Str_SetPtrW (LPWSTR *lppDest, LPCWSTR lpSrc)
237 {
238     TRACE("(%p %p)\n", lppDest, lpSrc);
239
240     if (lpSrc) {
241         INT len = strlenW (lpSrc) + 1;
242         LPWSTR ptr = ReAlloc (*lppDest, len * sizeof(WCHAR));
243         if (!ptr)
244             return FALSE;
245         strcpyW (ptr, lpSrc);
246         *lppDest = ptr;
247     }
248     else {
249         Free (*lppDest);
250         *lppDest = NULL;
251     }
252
253     return TRUE;
254 }
255
256 /**************************************************************************
257  * StrChrA [COMCTL32.350]
258  *
259  * Find a given character in a string.
260  *
261  * PARAMS
262  *  lpszStr [I] String to search in.
263  *  ch      [I] Character to search for.
264  *
265  * RETURNS
266  *  Success: A pointer to the first occurrence of ch in lpszStr, or NULL if
267  *           not found.
268  *  Failure: NULL, if any arguments are invalid.
269  */
270 LPSTR WINAPI StrChrA(LPCSTR lpszStr, WORD ch)
271 {
272   TRACE("(%s,%i)\n", debugstr_a(lpszStr), ch);
273
274   if (lpszStr)
275   {
276     while (*lpszStr)
277     {
278       if (!COMCTL32_ChrCmpA(*lpszStr, ch))
279         return (LPSTR)lpszStr;
280       lpszStr = CharNextA(lpszStr);
281     }
282   }
283   return NULL;
284 }
285
286 /**************************************************************************
287  * StrCmpNIA [COMCTL32.353]
288  *
289  * Compare two strings, up to a maximum length, ignoring case.
290  *
291  * PARAMS
292  *  lpszStr  [I] First string to compare
293  *  lpszComp [I] Second string to compare
294  *  iLen     [I] Maximum number of chars to compare.
295  *
296  * RETURNS
297  *  An integer less than, equal to or greater than 0, indicating that
298  *  lpszStr is less than, the same, or greater than lpszComp.
299  */
300 INT WINAPI StrCmpNIA(LPCSTR lpszStr, LPCSTR lpszComp, INT iLen)
301 {
302   INT iRet;
303
304   TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszComp), iLen);
305
306   iRet = CompareStringA(GetThreadLocale(), NORM_IGNORECASE, lpszStr, iLen, lpszComp, iLen);
307   return iRet == CSTR_LESS_THAN ? -1 : iRet == CSTR_GREATER_THAN ? 1 : 0;
308 }
309
310 /*************************************************************************
311  * StrCmpNIW    [COMCTL32.361]
312  *
313  * See StrCmpNIA.
314  */
315 INT WINAPI StrCmpNIW(LPCWSTR lpszStr, LPCWSTR lpszComp, INT iLen)
316 {
317   INT iRet;
318
319   TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszComp), iLen);
320
321   iRet = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, lpszStr, iLen, lpszComp, iLen);
322   return iRet == CSTR_LESS_THAN ? -1 : iRet == CSTR_GREATER_THAN ? 1 : 0;
323 }
324
325 /*************************************************************************
326  * COMCTL32_StrStrHelperA
327  *
328  * Internal implementation of StrStrA/StrStrIA
329  */
330 static LPSTR COMCTL32_StrStrHelperA(LPCSTR lpszStr, LPCSTR lpszSearch,
331                                     INT (WINAPI *pStrCmpFn)(LPCSTR,LPCSTR,INT))
332 {
333   size_t iLen;
334
335   if (!lpszStr || !lpszSearch || !*lpszSearch)
336     return NULL;
337
338   iLen = strlen(lpszSearch);
339
340   while (*lpszStr)
341   {
342     if (!pStrCmpFn(lpszStr, lpszSearch, iLen))
343       return (LPSTR)lpszStr;
344     lpszStr = CharNextA(lpszStr);
345   }
346   return NULL;
347 }
348
349 /**************************************************************************
350  * StrStrIA [COMCTL32.355]
351  *
352  * Find a substring within a string, ignoring case.
353  *
354  * PARAMS
355  *  lpszStr    [I] String to search in
356  *  lpszSearch [I] String to look for
357  *
358  * RETURNS
359  *  The start of lpszSearch within lpszStr, or NULL if not found.
360  */
361 LPSTR WINAPI StrStrIA(LPCSTR lpszStr, LPCSTR lpszSearch)
362 {
363   TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
364
365   return COMCTL32_StrStrHelperA(lpszStr, lpszSearch, StrCmpNIA);
366 }
367
368 /**************************************************************************
369  * StrToIntA [COMCTL32.357]
370  *
371  * Read a signed integer from a string.
372  *
373  * PARAMS
374  *  lpszStr [I] String to read integer from
375  *
376  * RETURNS
377  *   The signed integer value represented by the string, or 0 if no integer is
378  *   present.
379  */
380 INT WINAPI StrToIntA (LPCSTR lpszStr)
381 {
382     return atoi(lpszStr);
383 }
384
385 /**************************************************************************
386  * StrStrIW [COMCTL32.363]
387  *
388  * See StrStrIA.
389  */
390 LPWSTR WINAPI StrStrIW(LPCWSTR lpszStr, LPCWSTR lpszSearch)
391 {
392   int iLen;
393
394   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch));
395
396   if (!lpszStr || !lpszSearch || !*lpszSearch)
397     return NULL;
398
399   iLen = strlenW(lpszSearch);
400
401   while (*lpszStr)
402   {
403     if (!StrCmpNIW(lpszStr, lpszSearch, iLen))
404       return (LPWSTR)lpszStr;
405     lpszStr++;
406   }
407   return NULL;
408 }
409
410 /**************************************************************************
411  * StrToIntW [COMCTL32.365]
412  *
413  * See StrToIntA.
414  */
415 INT WINAPI StrToIntW (LPCWSTR lpString)
416 {
417     return atoiW(lpString);
418 }
419
420 /*************************************************************************
421  * COMCTL32_StrSpnHelperA (internal)
422  *
423  * Internal implementation of StrSpnA/StrCSpnA/StrCSpnIA
424  */
425 static int COMCTL32_StrSpnHelperA(LPCSTR lpszStr, LPCSTR lpszMatch,
426                                   LPSTR (WINAPI *pStrChrFn)(LPCSTR,WORD),
427                                   BOOL bInvert)
428 {
429   LPCSTR lpszRead = lpszStr;
430   if (lpszStr && *lpszStr && lpszMatch)
431   {
432     while (*lpszRead)
433     {
434       LPCSTR lpszTest = pStrChrFn(lpszMatch, *lpszRead);
435
436       if (!bInvert && !lpszTest)
437         break;
438       if (bInvert && lpszTest)
439         break;
440       lpszRead = CharNextA(lpszRead);
441     };
442   }
443   return lpszRead - lpszStr;
444 }
445
446 /**************************************************************************
447  * StrCSpnA [COMCTL32.356]
448  *
449  * Find the length of the start of a string that does not contain certain
450  * characters.
451  *
452  * PARAMS
453  *  lpszStr   [I] String to search
454  *  lpszMatch [I] Characters that cannot be in the substring
455  *
456  * RETURNS
457  *  The length of the part of lpszStr containing only chars not in lpszMatch,
458  *  or 0 if any parameter is invalid.
459  */
460 int WINAPI StrCSpnA(LPCSTR lpszStr, LPCSTR lpszMatch)
461 {
462   TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
463
464   return COMCTL32_StrSpnHelperA(lpszStr, lpszMatch, StrChrA, TRUE);
465 }
466
467 /**************************************************************************
468  * StrChrW [COMCTL32.358]
469  *
470  * See StrChrA.
471  */
472 LPWSTR WINAPI StrChrW(LPCWSTR lpszStr, WCHAR ch)
473 {
474   LPWSTR lpszRet = NULL;
475
476   TRACE("(%s,%i)\n", debugstr_w(lpszStr), ch);
477
478   if (lpszStr)
479     lpszRet = strchrW(lpszStr, ch);
480   return lpszRet;
481 }
482
483 /**************************************************************************
484  * StrCmpNA [COMCTL32.352]
485  *
486  * Compare two strings, up to a maximum length.
487  *
488  * PARAMS
489  *  lpszStr  [I] First string to compare
490  *  lpszComp [I] Second string to compare
491  *  iLen     [I] Maximum number of chars to compare.
492  *
493  * RETURNS
494  *  An integer less than, equal to or greater than 0, indicating that
495  *  lpszStr is less than, the same, or greater than lpszComp.
496  */
497 INT WINAPI StrCmpNA(LPCSTR lpszStr, LPCSTR lpszComp, INT iLen)
498 {
499   INT iRet;
500
501   TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszComp), iLen);
502
503   iRet = CompareStringA(GetThreadLocale(), 0, lpszStr, iLen, lpszComp, iLen);
504   return iRet == CSTR_LESS_THAN ? -1 : iRet == CSTR_GREATER_THAN ? 1 : 0;
505 }
506
507 /**************************************************************************
508  * StrCmpNW [COMCTL32.360]
509  *
510  * See StrCmpNA.
511  */
512 INT WINAPI StrCmpNW(LPCWSTR lpszStr, LPCWSTR lpszComp, INT iLen)
513 {
514   INT iRet;
515
516   TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszComp), iLen);
517
518   iRet = CompareStringW(GetThreadLocale(), 0, lpszStr, iLen, lpszComp, iLen);
519   return iRet == CSTR_LESS_THAN ? -1 : iRet == CSTR_GREATER_THAN ? 1 : 0;
520 }
521
522 /**************************************************************************
523  * StrRChrA [COMCTL32.351]
524  *
525  * Find the last occurrence of a character in string.
526  *
527  * PARAMS
528  *  lpszStr [I] String to search in
529  *  lpszEnd [I] Place to end search, or NULL to search until the end of lpszStr
530  *  ch      [I] Character to search for.
531  *
532  * RETURNS
533  *  Success: A pointer to the last occurrence of ch in lpszStr before lpszEnd,
534  *           or NULL if not found.
535  *  Failure: NULL, if any arguments are invalid.
536  */
537 LPSTR WINAPI StrRChrA(LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch)
538 {
539   LPCSTR lpszRet = NULL;
540
541   TRACE("(%s,%s,%x)\n", debugstr_a(lpszStr), debugstr_a(lpszEnd), ch);
542
543   if (lpszStr)
544   {
545     WORD ch2;
546
547     if (!lpszEnd)
548       lpszEnd = lpszStr + lstrlenA(lpszStr);
549
550     while (*lpszStr && lpszStr <= lpszEnd)
551     {
552       ch2 = IsDBCSLeadByte(*lpszStr)? *lpszStr << 8 | lpszStr[1] : *lpszStr;
553
554       if (!COMCTL32_ChrCmpA(ch, ch2))
555         lpszRet = lpszStr;
556       lpszStr = CharNextA(lpszStr);
557     }
558   }
559   return (LPSTR)lpszRet;
560 }
561
562
563 /**************************************************************************
564  * StrRChrW [COMCTL32.359]
565  *
566  * See StrRChrA.
567  */
568 LPWSTR WINAPI StrRChrW(LPCWSTR str, LPCWSTR end, WORD ch)
569 {
570     WCHAR *ret = NULL;
571
572     if (!str) return NULL;
573     if (!end) end = str + strlenW(str);
574     while (str < end)
575     {
576         if (*str == ch) ret = (WCHAR *)str;
577         str++;
578     }
579     return ret;
580 }
581
582 /**************************************************************************
583  * StrStrA [COMCTL32.354]
584  *
585  * Find a substring within a string.
586  *
587  * PARAMS
588  *  lpszStr    [I] String to search in
589  *  lpszSearch [I] String to look for
590  *
591  * RETURNS
592  *  The start of lpszSearch within lpszStr, or NULL if not found.
593  */
594 LPSTR WINAPI StrStrA(LPCSTR lpszStr, LPCSTR lpszSearch)
595 {
596   TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
597
598   return COMCTL32_StrStrHelperA(lpszStr, lpszSearch, StrCmpNA);
599 }
600
601 /**************************************************************************
602  * StrStrW [COMCTL32.362]
603  *
604  * See StrStrA.
605  */
606 LPWSTR WINAPI StrStrW(LPCWSTR lpszStr, LPCWSTR lpszSearch)
607 {
608     if (!lpszStr || !lpszSearch) return NULL;
609     return strstrW( lpszStr, lpszSearch );
610 }
611
612 /*************************************************************************
613  * StrChrIA     [COMCTL32.366]
614  *
615  * Find a given character in a string, ignoring case.
616  *
617  * PARAMS
618  *  lpszStr [I] String to search in.
619  *  ch      [I] Character to search for.
620  *
621  * RETURNS
622  *  Success: A pointer to the first occurrence of ch in lpszStr, or NULL if
623  *           not found.
624  *  Failure: NULL, if any arguments are invalid.
625  */
626 LPSTR WINAPI StrChrIA(LPCSTR lpszStr, WORD ch)
627 {
628   TRACE("(%s,%i)\n", debugstr_a(lpszStr), ch);
629
630   if (lpszStr)
631   {
632     while (*lpszStr)
633     {
634       if (!COMCTL32_ChrCmpIA(*lpszStr, ch))
635         return (LPSTR)lpszStr;
636       lpszStr = CharNextA(lpszStr);
637     }
638   }
639   return NULL;
640 }
641
642 /*************************************************************************
643  * StrChrIW     [COMCTL32.367]
644  *
645  * See StrChrA.
646  */
647 LPWSTR WINAPI StrChrIW(LPCWSTR lpszStr, WCHAR ch)
648 {
649   TRACE("(%s,%i)\n", debugstr_w(lpszStr), ch);
650
651   if (lpszStr)
652   {
653     ch = toupperW(ch);
654     while (*lpszStr)
655     {
656       if (toupperW(*lpszStr) == ch)
657         return (LPWSTR)lpszStr;
658       lpszStr++;
659     }
660     lpszStr = NULL;
661   }
662   return (LPWSTR)lpszStr;
663 }
664
665 /*************************************************************************
666  * StrRStrIA    [COMCTL32.372]
667  *
668  * Find the last occurrence of a substring within a string.
669  *
670  * PARAMS
671  *  lpszStr    [I] String to search in
672  *  lpszEnd    [I] End of lpszStr
673  *  lpszSearch [I] String to look for
674  *
675  * RETURNS
676  *  The last occurrence lpszSearch within lpszStr, or NULL if not found.
677  */
678 LPSTR WINAPI StrRStrIA(LPCSTR lpszStr, LPCSTR lpszEnd, LPCSTR lpszSearch)
679 {
680   LPSTR lpszRet = NULL;
681   WORD ch1, ch2;
682   INT iLen;
683  
684   TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
685  
686   if (!lpszStr || !lpszSearch || !*lpszSearch)
687     return NULL;
688
689   if (!lpszEnd)
690     lpszEnd = lpszStr + lstrlenA(lpszStr);
691
692   if (IsDBCSLeadByte(*lpszSearch))
693     ch1 = *lpszSearch << 8 | lpszSearch[1];
694   else
695     ch1 = *lpszSearch;
696   iLen = lstrlenA(lpszSearch);
697
698   while (lpszStr <= lpszEnd  && *lpszStr)
699   {
700     ch2 = IsDBCSLeadByte(*lpszStr)? *lpszStr << 8 | lpszStr[1] : *lpszStr;
701     if (!COMCTL32_ChrCmpIA(ch1, ch2))
702     {
703       if (!StrCmpNIA(lpszStr, lpszSearch, iLen))
704         lpszRet = (LPSTR)lpszStr;
705     }
706     lpszStr = CharNextA(lpszStr);
707   }
708   return lpszRet;
709 }
710
711 /*************************************************************************
712  * StrRStrIW    [COMCTL32.373]
713  *
714  * See StrRStrIA.
715  */
716 LPWSTR WINAPI StrRStrIW(LPCWSTR lpszStr, LPCWSTR lpszEnd, LPCWSTR lpszSearch)
717 {
718   LPWSTR lpszRet = NULL;
719   INT iLen;
720
721   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch));
722
723   if (!lpszStr || !lpszSearch || !*lpszSearch)
724     return NULL;
725
726   if (!lpszEnd)
727     lpszEnd = lpszStr + strlenW(lpszStr);
728
729   iLen = strlenW(lpszSearch);
730
731   while (lpszStr <= lpszEnd  && *lpszStr)
732   {
733     if (!COMCTL32_ChrCmpIW(*lpszSearch, *lpszStr))
734     {
735       if (!StrCmpNIW(lpszStr, lpszSearch, iLen))
736         lpszRet = (LPWSTR)lpszStr;
737     }
738     lpszStr++;
739   }
740   return lpszRet;
741 }
742
743 /*************************************************************************
744  * StrCSpnIA    [COMCTL32.374]
745  *
746  * Find the length of the start of a string that does not contain certain
747  * characters, ignoring case.
748  *
749  * PARAMS
750  *  lpszStr   [I] String to search
751  *  lpszMatch [I] Characters that cannot be in the substring
752  *
753  * RETURNS
754  *  The length of the part of lpszStr containing only chars not in lpszMatch,
755  *  or 0 if any parameter is invalid.
756  */
757 int WINAPI StrCSpnIA(LPCSTR lpszStr, LPCSTR lpszMatch)
758 {
759   TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
760
761   return COMCTL32_StrSpnHelperA(lpszStr, lpszMatch, StrChrIA, TRUE);
762 }
763
764 /*************************************************************************
765  * StrCSpnIW    [COMCTL32.375]
766  *
767  * See StrCSpnIA.
768  */
769 int WINAPI StrCSpnIW(LPCWSTR lpszStr, LPCWSTR lpszMatch)
770 {
771   LPCWSTR lpszRead = lpszStr;
772
773   TRACE("(%s,%s)\n",debugstr_w(lpszStr), debugstr_w(lpszMatch));
774
775   if (lpszStr && *lpszStr && lpszMatch)
776   {
777     while (*lpszRead)
778     {
779       if (StrChrIW(lpszMatch, *lpszRead)) break;
780       lpszRead++;
781     }
782   }
783   return lpszRead - lpszStr;
784 }
785
786 /**************************************************************************
787  * StrRChrIA    [COMCTL32.368]
788  *
789  * Find the last occurrence of a character in string, ignoring case.
790  *
791  * PARAMS
792  *  lpszStr [I] String to search in
793  *  lpszEnd [I] Place to end search, or NULL to search until the end of lpszStr
794  *  ch      [I] Character to search for.
795  *
796  * RETURNS
797  *  Success: A pointer to the last occurrence of ch in lpszStr before lpszEnd,
798  *           or NULL if not found.
799  *  Failure: NULL, if any arguments are invalid.
800  */
801 LPSTR WINAPI StrRChrIA(LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch)
802 {
803   LPCSTR lpszRet = NULL;
804
805   TRACE("(%s,%s,%x)\n", debugstr_a(lpszStr), debugstr_a(lpszEnd), ch);
806
807   if (lpszStr)
808   {
809     WORD ch2;
810
811     if (!lpszEnd)
812       lpszEnd = lpszStr + lstrlenA(lpszStr);
813
814     while (*lpszStr && lpszStr <= lpszEnd)
815     {
816       ch2 = IsDBCSLeadByte(*lpszStr)? *lpszStr << 8 | lpszStr[1] : *lpszStr;
817
818       if (ch == ch2)
819         lpszRet = lpszStr;
820       lpszStr = CharNextA(lpszStr);
821     }
822   }
823   return (LPSTR)lpszRet;
824 }
825
826 /**************************************************************************
827  * StrRChrIW    [COMCTL32.369]
828  *
829  * See StrRChrIA.
830  */
831 LPWSTR WINAPI StrRChrIW(LPCWSTR str, LPCWSTR end, WORD ch)
832 {
833     WCHAR *ret = NULL;
834
835     if (!str) return NULL;
836     if (!end) end = str + strlenW(str);
837     while (str < end)
838     {
839         if (!COMCTL32_ChrCmpIW(*str, ch)) ret = (WCHAR *)str;
840         str++;
841     }
842     return ret;
843 }
844
845 /*************************************************************************
846  * StrCSpnW     [COMCTL32.364]
847  *
848  * See StrCSpnA.
849  */
850 int WINAPI StrCSpnW(LPCWSTR lpszStr, LPCWSTR lpszMatch)
851 {
852     if (!lpszStr || !lpszMatch) return 0;
853     return strcspnW( lpszStr, lpszMatch );
854 }
855
856 /*************************************************************************
857  * IntlStrEqWorkerA     [COMCTL32.376]
858  *
859  * Compare two strings.
860  *
861  * PARAMS
862  *  bCase    [I] Whether to compare case sensitively
863  *  lpszStr  [I] First string to compare
864  *  lpszComp [I] Second string to compare
865  *  iLen     [I] Length to compare
866  *
867  * RETURNS
868  *  TRUE  If the strings are equal.
869  *  FALSE Otherwise.
870  */
871 BOOL WINAPI IntlStrEqWorkerA(BOOL bCase, LPCSTR lpszStr, LPCSTR lpszComp,
872                              int iLen)
873 {
874   DWORD dwFlags = LOCALE_USE_CP_ACP;
875   int iRet;
876
877   TRACE("(%d,%s,%s,%d)\n", bCase,
878         debugstr_a(lpszStr), debugstr_a(lpszComp), iLen);
879
880   /* FIXME: These flags are undocumented and unknown by our CompareString.
881    *        We need defines for them.
882    */
883   dwFlags |= bCase ? 0x10000000 : 0x10000001;
884
885   iRet = CompareStringA(GetThreadLocale(),
886                         dwFlags, lpszStr, iLen, lpszComp, iLen);
887
888   if (!iRet)
889     iRet = CompareStringA(2048, dwFlags, lpszStr, iLen, lpszComp, iLen);
890
891   return iRet == 2 ? TRUE : FALSE;
892 }
893
894 /*************************************************************************
895  * IntlStrEqWorkerW     [COMCTL32.377]
896  *
897  * See IntlStrEqWorkerA.
898  */
899 BOOL WINAPI IntlStrEqWorkerW(BOOL bCase, LPCWSTR lpszStr, LPCWSTR lpszComp,
900                              int iLen)
901 {
902   DWORD dwFlags;
903   int iRet;
904
905   TRACE("(%d,%s,%s,%d)\n", bCase,
906         debugstr_w(lpszStr),debugstr_w(lpszComp), iLen);
907
908   /* FIXME: These flags are undocumented and unknown by our CompareString.
909    *        We need defines for them.
910    */
911   dwFlags = bCase ? 0x10000000 : 0x10000001;
912
913   iRet = CompareStringW(GetThreadLocale(),
914                         dwFlags, lpszStr, iLen, lpszComp, iLen);
915
916   if (!iRet)
917     iRet = CompareStringW(2048, dwFlags, lpszStr, iLen, lpszComp, iLen);
918
919   return iRet == 2 ? TRUE : FALSE;
920 }