git.oblomov.eu Git - wine/blob - 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 inneficient. 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_ChrCmpHelperW
  85  *
  86  * Internal helper for COMCTL32_ChrCmpW/ChrCmpIW.
  87  */
  88 static BOOL COMCTL32_ChrCmpHelperW(WCHAR ch1, WCHAR ch2, DWORD dwFlags)
  89 {
  90   WCHAR str1[2], str2[2];
  91
  92   str1[0] = ch1;
  93   str1[1] = '\0';
  94   str2[0] = ch2;
  95   str2[1] = '\0';
  96   return CompareStringW(GetThreadLocale(), dwFlags, str1, 2, str2, 2) - 2;
  97 }
  98
  99 /*************************************************************************
 100  * COMCTL32_ChrCmpA (internal)
 101  *
 102  * Internal helper function.
 103  */
 104 static BOOL COMCTL32_ChrCmpA(WORD ch1, WORD ch2)
 105 {
 106   return COMCTL32_ChrCmpHelperA(ch1, ch2, 0);
 107 }
 108
 109 /*************************************************************************
 110  * COMCTL32_ChrCmpIA    (internal)
 111  *
 112  * Compare two characters, ignoring case.
 113  *
 114  * PARAMS
 115  *  ch1 [I] First character to compare
 116  *  ch2 [I] Second character to compare
 117  *
 118  * RETURNS
 119  *  FALSE, if the characters are equal.
 120  *  Non-zero otherwise.
 121  */
 122 static BOOL COMCTL32_ChrCmpIA(WORD ch1, WORD ch2)
 123 {
 124   TRACE("(%d,%d)\n", ch1, ch2);
 125
 126   return COMCTL32_ChrCmpHelperA(ch1, ch2, NORM_IGNORECASE);
 127 }
 128
 129 /*************************************************************************
 130  * COMCTL32_ChrCmpW
 131  *
 132  * Internal helper function.
 133  */
 134 static BOOL COMCTL32_ChrCmpW(WCHAR ch1, WCHAR ch2)
 135 {
 136   return COMCTL32_ChrCmpHelperW(ch1, ch2, 0);
 137 }
 138
 139 /*************************************************************************
 140  * COMCTL32_ChrCmpIW
 141  *
 142  * Internal helper function.
 143  */
 144 static BOOL COMCTL32_ChrCmpIW(WCHAR ch1, WCHAR ch2)
 145 {
 146   return COMCTL32_ChrCmpHelperW(ch1, ch2, NORM_IGNORECASE);
 147 }
 148
 149 /**************************************************************************
 150  * Str_GetPtrA [COMCTL32.233]
 151  *
 152  * Copies a string into a destination buffer.
 153  *
 154  * PARAMS
 155  *     lpSrc   [I] Source string
 156  *     lpDest  [O] Destination buffer
 157  *     nMaxLen [I] Size of buffer in characters
 158  *
 159  * RETURNS
 160  *     The number of characters copied.
 161  */
 162 INT WINAPI Str_GetPtrA (LPCSTR lpSrc, LPSTR lpDest, INT nMaxLen)
 163 {
 164     INT len;
 165
 166     TRACE("(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
 167
 168     if ((!lpDest || nMaxLen == 0) && lpSrc)
 169         return (strlen(lpSrc) + 1);
 170
 171     if (nMaxLen == 0)
 172         return 0;
 173
 174     if (lpSrc == NULL) {
 175         lpDest[0] = '\0';
 176         return 0;
 177     }
 178
 179     len = strlen(lpSrc) + 1;
 180     if (len >= nMaxLen)
 181         len = nMaxLen;
 182
 183     RtlMoveMemory (lpDest, lpSrc, len - 1);
 184     lpDest[len - 1] = '\0';
 185
 186     return len;
 187 }
 188
 189 /**************************************************************************
 190  * Str_SetPtrA [COMCTL32.234]
 191  *
 192  * Makes a copy of a string, allocating memory if necessary.
 193  *
 194  * PARAMS
 195  *     lppDest [O] Pointer to destination string
 196  *     lpSrc   [I] Source string
 197  *
 198  * RETURNS
 199  *     Success: TRUE
 200  *     Failure: FALSE
 201  *
 202  * NOTES
 203  *     Set lpSrc to NULL to free the memory allocated by a previous call
 204  *     to this function.
 205  */
 206 BOOL WINAPI Str_SetPtrA (LPSTR *lppDest, LPCSTR lpSrc)
 207 {
 208     TRACE("(%p %p)\n", lppDest, lpSrc);
 209
 210     if (lpSrc) {
 211         LPSTR ptr = ReAlloc (*lppDest, strlen (lpSrc) + 1);
 212         if (!ptr)
 213             return FALSE;
 214         strcpy (ptr, lpSrc);
 215         *lppDest = ptr;
 216     }
 217     else {
 218         if (*lppDest) {
 219             Free (*lppDest);
 220             *lppDest = NULL;
 221         }
 222     }
 223
 224     return TRUE;
 225 }
 226
 227 /**************************************************************************
 228  * Str_GetPtrW [COMCTL32.235]
 229  *
 230  * See Str_GetPtrA.
 231  */
 232 INT WINAPI Str_GetPtrW (LPCWSTR lpSrc, LPWSTR lpDest, INT nMaxLen)
 233 {
 234     INT len;
 235
 236     TRACE("(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
 237
 238     if (!lpDest && lpSrc)
 239         return strlenW (lpSrc);
 240
 241     if (nMaxLen == 0)
 242         return 0;
 243
 244     if (lpSrc == NULL) {
 245         lpDest[0] = L'\0';
 246         return 0;
 247     }
 248
 249     len = strlenW (lpSrc);
 250     if (len >= nMaxLen)
 251         len = nMaxLen - 1;
 252
 253     RtlMoveMemory (lpDest, lpSrc, len*sizeof(WCHAR));
 254     lpDest[len] = L'\0';
 255
 256     return len;
 257 }
 258
 259 /**************************************************************************
 260  * Str_SetPtrW [COMCTL32.236]
 261  *
 262  * See Str_SetPtrA.
 263  */
 264 BOOL WINAPI Str_SetPtrW (LPWSTR *lppDest, LPCWSTR lpSrc)
 265 {
 266     TRACE("(%p %p)\n", lppDest, lpSrc);
 267
 268     if (lpSrc) {
 269         INT len = strlenW (lpSrc) + 1;
 270         LPWSTR ptr = ReAlloc (*lppDest, len * sizeof(WCHAR));
 271         if (!ptr)
 272             return FALSE;
 273         strcpyW (ptr, lpSrc);
 274         *lppDest = ptr;
 275     }
 276     else {
 277         if (*lppDest) {
 278             Free (*lppDest);
 279             *lppDest = NULL;
 280         }
 281     }
 282
 283     return TRUE;
 284 }
 285
 286 /**************************************************************************
 287  * StrChrA [COMCTL32.350]
 288  *
 289  * Find a given character in a string.
 290  *
 291  * PARAMS
 292  *  lpszStr [I] String to search in.
 293  *  ch      [I] Character to search for.
 294  *
 295  * RETURNS
 296  *  Success: A pointer to the first occurrence of ch in lpszStr, or NULL if
 297  *           not found.
 298  *  Failure: NULL, if any arguments are invalid.
 299  */
 300 LPSTR WINAPI StrChrA(LPCSTR lpszStr, WORD ch)
 301 {
 302   TRACE("(%s,%i)\n", debugstr_a(lpszStr), ch);
 303
 304   if (lpszStr)
 305   {
 306     while (*lpszStr)
 307     {
 308       if (!COMCTL32_ChrCmpA(*lpszStr, ch))
 309         return (LPSTR)lpszStr;
 310       lpszStr = CharNextA(lpszStr);
 311     }
 312   }
 313   return NULL;
 314 }
 315
 316 /**************************************************************************
 317  * StrCmpNIA [COMCTL32.353]
 318  *
 319  * Compare two strings, up to a maximum length, ignoring case.
 320  *
 321  * PARAMS
 322  *  lpszStr  [I] First string to compare
 323  *  lpszComp [I] Second string to compare
 324  *  iLen     [I] Maximum number of chars to compare.
 325  *
 326  * RETURNS
 327  *  An integer less than, equal to or greater than 0, indicating that
 328  *  lpszStr is less than, the same, or greater than lpszComp.
 329  */
 330 INT WINAPI StrCmpNIA(LPCSTR lpszStr, LPCSTR lpszComp, INT iLen)
 331 {
 332   INT iRet;
 333
 334   TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszComp), iLen);
 335
 336   iRet = CompareStringA(GetThreadLocale(), NORM_IGNORECASE, lpszStr, iLen, lpszComp, iLen);
 337   return iRet == CSTR_LESS_THAN ? -1 : iRet == CSTR_GREATER_THAN ? 1 : 0;
 338 }
 339
 340 /*************************************************************************
 341  * StrCmpNIW    [COMCTL32.361]
 342  *
 343  * See StrCmpNIA.
 344  */
 345 INT WINAPI StrCmpNIW(LPCWSTR lpszStr, LPCWSTR lpszComp, INT iLen)
 346 {
 347   INT iRet;
 348
 349   TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszComp), iLen);
 350
 351   iRet = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, lpszStr, iLen, lpszComp, iLen);
 352   return iRet == CSTR_LESS_THAN ? -1 : iRet == CSTR_GREATER_THAN ? 1 : 0;
 353 }
 354
 355 /*************************************************************************
 356  * COMCTL32_StrStrHelperA
 357  *
 358  * Internal implementation of StrStrA/StrStrIA
 359  */
 360 static LPSTR COMCTL32_StrStrHelperA(LPCSTR lpszStr, LPCSTR lpszSearch,
 361                                     INT (WINAPI *pStrCmpFn)(LPCSTR,LPCSTR,INT))
 362 {
 363   size_t iLen;
 364
 365   if (!lpszStr || !lpszSearch || !*lpszSearch)
 366     return NULL;
 367
 368   iLen = strlen(lpszSearch);
 369
 370   while (*lpszStr)
 371   {
 372     if (!pStrCmpFn(lpszStr, lpszSearch, iLen))
 373       return (LPSTR)lpszStr;
 374     lpszStr = CharNextA(lpszStr);
 375   }
 376   return NULL;
 377 }
 378
 379 /*************************************************************************
 380  * COMCTL32_StrStrHelperW
 381  *
 382  * Internal implementation of StrStrW/StrStrIW
 383  */
 384 static LPWSTR COMCTL32_StrStrHelperW(LPCWSTR lpszStr, LPCWSTR lpszSearch,
 385                                      INT (WINAPI *pStrCmpFn)(LPCWSTR,LPCWSTR,INT))
 386 {
 387   int iLen;
 388
 389   if (!lpszStr || !lpszSearch || !*lpszSearch)
 390     return NULL;
 391
 392   iLen = strlenW(lpszSearch);
 393
 394   while (*lpszStr)
 395   {
 396     if (!pStrCmpFn(lpszStr, lpszSearch, iLen))
 397       return (LPWSTR)lpszStr;
 398     lpszStr = CharNextW(lpszStr);
 399   }
 400   return NULL;
 401 }
 402
 403 /**************************************************************************
 404  * StrStrIA [COMCTL32.355]
 405  *
 406  * Find a substring within a string, ignoring case.
 407  *
 408  * PARAMS
 409  *  lpszStr    [I] String to search in
 410  *  lpszSearch [I] String to look for
 411  *
 412  * RETURNS
 413  *  The start of lpszSearch within lpszStr, or NULL if not found.
 414  */
 415 LPSTR WINAPI StrStrIA(LPCSTR lpszStr, LPCSTR lpszSearch)
 416 {
 417   TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
 418
 419   return COMCTL32_StrStrHelperA(lpszStr, lpszSearch, StrCmpNIA);
 420 }
 421
 422 /**************************************************************************
 423  * StrToIntA [COMCTL32.357]
 424  *
 425  * Read a signed integer from a string.
 426  *
 427  * PARAMS
 428  *  lpszStr [I] String to read integer from
 429  *
 430  * RETURNS
 431  *   The signed integer value represented by the string, or 0 if no integer is
 432  *   present.
 433  */
 434 INT WINAPI StrToIntA (LPSTR lpszStr)
 435 {
 436     return atoi(lpszStr);
 437 }
 438
 439 /**************************************************************************
 440  * StrStrIW [COMCTL32.363]
 441  *
 442  * See StrStrIA.
 443  */
 444 LPWSTR WINAPI StrStrIW(LPCWSTR lpszStr, LPCWSTR lpszSearch)
 445 {
 446   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch));
 447
 448   return COMCTL32_StrStrHelperW(lpszStr, lpszSearch, StrCmpNIW);
 449 }
 450
 451 /**************************************************************************
 452  * StrToIntW [COMCTL32.365]
 453  *
 454  * See StrToIntA.
 455  */
 456 INT WINAPI StrToIntW (LPWSTR lpString)
 457 {
 458     return atoiW(lpString);
 459 }
 460
 461 /*************************************************************************
 462  * COMCTL32_StrSpnHelperA (internal)
 463  *
 464  * Internal implementation of StrSpnA/StrCSpnA/StrCSpnIA
 465  */
 466 static int COMCTL32_StrSpnHelperA(LPCSTR lpszStr, LPCSTR lpszMatch,
 467                                   LPSTR (WINAPI *pStrChrFn)(LPCSTR,WORD),
 468                                   BOOL bInvert)
 469 {
 470   LPCSTR lpszRead = lpszStr;
 471   if (lpszStr && *lpszStr && lpszMatch)
 472   {
 473     while (*lpszRead)
 474     {
 475       LPCSTR lpszTest = pStrChrFn(lpszMatch, *lpszRead);
 476
 477       if (!bInvert && !lpszTest)
 478         break;
 479       if (bInvert && lpszTest)
 480         break;
 481       lpszRead = CharNextA(lpszRead);
 482     };
 483   }
 484   return lpszRead - lpszStr;
 485 }
 486
 487 /**************************************************************************
 488  * StrCSpnA [COMCTL32.356]
 489  *
 490  * Find the length of the start of a string that does not contain certain
 491  * characters.
 492  *
 493  * PARAMS
 494  *  lpszStr   [I] String to search
 495  *  lpszMatch [I] Characters that cannot be in the substring
 496  *
 497  * RETURNS
 498  *  The length of the part of lpszStr containing only chars not in lpszMatch,
 499  *  or 0 if any parameter is invalid.
 500  */
 501 int WINAPI StrCSpnA(LPCSTR lpszStr, LPCSTR lpszMatch)
 502 {
 503   TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
 504
 505   return COMCTL32_StrSpnHelperA(lpszStr, lpszMatch, StrChrA, TRUE);
 506 }
 507
 508 /**************************************************************************
 509  * StrChrW [COMCTL32.358]
 510  *
 511  * See StrChrA.
 512  */
 513 LPWSTR WINAPI StrChrW(LPCWSTR lpszStr, WCHAR ch)
 514 {
 515   LPWSTR lpszRet = NULL;
 516
 517   TRACE("(%s,%i)\n", debugstr_w(lpszStr), ch);
 518
 519   if (lpszStr)
 520     lpszRet = strchrW(lpszStr, ch);
 521   return lpszRet;
 522 }
 523
 524 /**************************************************************************
 525  * StrCmpNA [COMCTL32.352]
 526  *
 527  * Compare two strings, up to a maximum length.
 528  *
 529  * PARAMS
 530  *  lpszStr  [I] First string to compare
 531  *  lpszComp [I] Second string to compare
 532  *  iLen     [I] Maximum number of chars to compare.
 533  *
 534  * RETURNS
 535  *  An integer less than, equal to or greater than 0, indicating that
 536  *  lpszStr is less than, the same, or greater than lpszComp.
 537  */
 538 INT WINAPI StrCmpNA(LPCSTR lpszStr, LPCSTR lpszComp, INT iLen)
 539 {
 540   INT iRet;
 541
 542   TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszComp), iLen);
 543
 544   iRet = CompareStringA(GetThreadLocale(), 0, lpszStr, iLen, lpszComp, iLen);
 545   return iRet == CSTR_LESS_THAN ? -1 : iRet == CSTR_GREATER_THAN ? 1 : 0;
 546 }
 547
 548 /**************************************************************************
 549  * StrCmpNW [COMCTL32.360]
 550  *
 551  * See StrCmpNA.
 552  */
 553 INT WINAPI StrCmpNW(LPCWSTR lpszStr, LPCWSTR lpszComp, INT iLen)
 554 {
 555   INT iRet;
 556
 557   TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszComp), iLen);
 558
 559   iRet = CompareStringW(GetThreadLocale(), 0, lpszStr, iLen, lpszComp, iLen);
 560   return iRet == CSTR_LESS_THAN ? -1 : iRet == CSTR_GREATER_THAN ? 1 : 0;
 561 }
 562
 563 /**************************************************************************
 564  * StrRChrA [COMCTL32.351]
 565  *
 566  * Find the last occurrence of a character in string.
 567  *
 568  * PARAMS
 569  *  lpszStr [I] String to search in
 570  *  lpszEnd [I] Place to end search, or NULL to search until the end of lpszStr
 571  *  ch      [I] Character to search for.
 572  *
 573  * RETURNS
 574  *  Success: A pointer to the last occurrence of ch in lpszStr before lpszEnd,
 575  *           or NULL if not found.
 576  *  Failure: NULL, if any arguments are invalid.
 577  */
 578 LPSTR WINAPI StrRChrA(LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch)
 579 {
 580   LPCSTR lpszRet = NULL;
 581
 582   TRACE("(%s,%s,%x)\n", debugstr_a(lpszStr), debugstr_a(lpszEnd), ch);
 583
 584   if (lpszStr)
 585   {
 586     WORD ch2;
 587
 588     if (!lpszEnd)
 589       lpszEnd = lpszStr + lstrlenA(lpszStr);
 590
 591     while (*lpszStr && lpszStr <= lpszEnd)
 592     {
 593       ch2 = IsDBCSLeadByte(*lpszStr)? *lpszStr << 8 | lpszStr[1] : *lpszStr;
 594
 595       if (!COMCTL32_ChrCmpA(ch, ch2))
 596         lpszRet = lpszStr;
 597       lpszStr = CharNextA(lpszStr);
 598     }
 599   }
 600   return (LPSTR)lpszRet;
 601 }
 602
 603
 604 /**************************************************************************
 605  * StrRChrW [COMCTL32.359]
 606  *
 607  * See StrRChrA.
 608  */
 609 LPWSTR WINAPI StrRChrW(LPCWSTR lpszStr, LPCWSTR lpszEnd, WORD ch)
 610 {
 611   LPCWSTR lpszRet = NULL;
 612
 613   TRACE("(%s,%s,%x)\n", debugstr_w(lpszStr), debugstr_w(lpszEnd), ch);
 614
 615   if (lpszStr)
 616   {
 617     if (!lpszEnd)
 618       lpszEnd = lpszStr + strlenW(lpszStr);
 619
 620     while (*lpszStr && lpszStr <= lpszEnd)
 621     {
 622       if (!COMCTL32_ChrCmpW(ch, *lpszStr))
 623         lpszRet = lpszStr;
 624       lpszStr = CharNextW(lpszStr);
 625     }
 626   }
 627   return (LPWSTR)lpszRet;
 628 }
 629
 630 /**************************************************************************
 631  * StrStrA [COMCTL32.354]
 632  *
 633  * Find a substring within a string.
 634  *
 635  * PARAMS
 636  *  lpszStr    [I] String to search in
 637  *  lpszSearch [I] String to look for
 638  *
 639  * RETURNS
 640  *  The start of lpszSearch within lpszStr, or NULL if not found.
 641  */
 642 LPSTR WINAPI StrStrA(LPCSTR lpszStr, LPCSTR lpszSearch)
 643 {
 644   TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
 645
 646   return COMCTL32_StrStrHelperA(lpszStr, lpszSearch, StrCmpNA);
 647 }
 648
 649 /**************************************************************************
 650  * StrStrW [COMCTL32.362]
 651  *
 652  * See StrStrA.
 653  */
 654 LPWSTR WINAPI StrStrW(LPCWSTR lpszStr, LPCWSTR lpszSearch)
 655 {
 656   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch));
 657
 658   return COMCTL32_StrStrHelperW(lpszStr, lpszSearch, StrCmpNW);
 659 }
 660
 661 /*************************************************************************
 662  * StrChrIA     [COMCTL32.366]
 663  *
 664  * Find a given character in a string, ignoring case.
 665  *
 666  * PARAMS
 667  *  lpszStr [I] String to search in.
 668  *  ch      [I] Character to search for.
 669  *
 670  * RETURNS
 671  *  Success: A pointer to the first occurrence of ch in lpszStr, or NULL if
 672  *           not found.
 673  *  Failure: NULL, if any arguments are invalid.
 674  */
 675 LPSTR WINAPI StrChrIA(LPCSTR lpszStr, WORD ch)
 676 {
 677   TRACE("(%s,%i)\n", debugstr_a(lpszStr), ch);
 678
 679   if (lpszStr)
 680   {
 681     while (*lpszStr)
 682     {
 683       if (!COMCTL32_ChrCmpIA(*lpszStr, ch))
 684         return (LPSTR)lpszStr;
 685       lpszStr = CharNextA(lpszStr);
 686     }
 687   }
 688   return NULL;
 689 }
 690
 691 /*************************************************************************
 692  * StrChrIW     [COMCTL32.367]
 693  *
 694  * See StrChrA.
 695  */
 696 LPWSTR WINAPI StrChrIW(LPCWSTR lpszStr, WCHAR ch)
 697 {
 698   TRACE("(%s,%i)\n", debugstr_w(lpszStr), ch);
 699
 700   if (lpszStr)
 701   {
 702     ch = toupperW(ch);
 703     while (*lpszStr)
 704     {
 705       if (toupperW(*lpszStr) == ch)
 706         return (LPWSTR)lpszStr;
 707       lpszStr = CharNextW(lpszStr);
 708     }
 709     lpszStr = NULL;
 710   }
 711   return (LPWSTR)lpszStr;
 712 }
 713
 714 /*************************************************************************
 715  * StrRStrIA    [COMCTL32.372]
 716  *
 717  * Find the last occurrence of a substring within a string.
 718  *
 719  * PARAMS
 720  *  lpszStr    [I] String to search in
 721  *  lpszEnd    [I] End of lpszStr
 722  *  lpszSearch [I] String to look for
 723  *
 724  * RETURNS
 725  *  The last occurrence lpszSearch within lpszStr, or NULL if not found.
 726  */
 727 LPSTR WINAPI StrRStrIA(LPCSTR lpszStr, LPCSTR lpszEnd, LPCSTR lpszSearch)
 728 {
 729   LPSTR lpszRet = NULL;
 730   WORD ch1, ch2;
 731   INT iLen;
 732
 733   TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
 734
 735   if (!lpszStr || !lpszSearch || !*lpszSearch)
 736     return NULL;
 737
 738   if (!lpszEnd)
 739     lpszEnd = lpszStr + lstrlenA(lpszStr);
 740
 741   if (IsDBCSLeadByte(*lpszSearch))
 742     ch1 = *lpszSearch << 8 | lpszSearch[1];
 743   else
 744     ch1 = *lpszSearch;
 745   iLen = lstrlenA(lpszSearch);
 746
 747   while (lpszStr <= lpszEnd  && *lpszStr)
 748   {
 749     ch2 = IsDBCSLeadByte(*lpszStr)? *lpszStr << 8 | lpszStr[1] : *lpszStr;
 750     if (!COMCTL32_ChrCmpIA(ch1, ch2))
 751     {
 752       if (!StrCmpNIA(lpszStr, lpszSearch, iLen))
 753         lpszRet = (LPSTR)lpszStr;
 754     }
 755     lpszStr = CharNextA(lpszStr);
 756   }
 757   return lpszRet;
 758 }
 759
 760 /*************************************************************************
 761  * StrRStrIW    [COMCTL32.373]
 762  *
 763  * See StrRStrIA.
 764  */
 765 LPWSTR WINAPI StrRStrIW(LPCWSTR lpszStr, LPCWSTR lpszEnd, LPCWSTR lpszSearch)
 766 {
 767   LPWSTR lpszRet = NULL;
 768   INT iLen;
 769
 770   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch));
 771
 772   if (!lpszStr || !lpszSearch || !*lpszSearch)
 773     return NULL;
 774
 775   if (!lpszEnd)
 776     lpszEnd = lpszStr + strlenW(lpszStr);
 777
 778   iLen = strlenW(lpszSearch);
 779
 780   while (lpszStr <= lpszEnd  && *lpszStr)
 781   {
 782     if (!COMCTL32_ChrCmpIW(*lpszSearch, *lpszStr))
 783     {
 784       if (!StrCmpNIW(lpszStr, lpszSearch, iLen))
 785         lpszRet = (LPWSTR)lpszStr;
 786     }
 787     lpszStr = CharNextW(lpszStr);
 788   }
 789   return lpszRet;
 790 }
 791
 792 /*************************************************************************
 793  * COMCTL32_StrSpnHelperW
 794  *
 795  * Internal implementation of StrSpnW/StrCSpnW/StrCSpnIW
 796  */
 797 static int COMCTL32_StrSpnHelperW(LPCWSTR lpszStr, LPCWSTR lpszMatch,
 798                                   LPWSTR (WINAPI *pStrChrFn)(LPCWSTR,WCHAR),
 799                                   BOOL bInvert)
 800 {
 801   LPCWSTR lpszRead = lpszStr;
 802   if (lpszStr && *lpszStr && lpszMatch)
 803   {
 804     while (*lpszRead)
 805     {
 806       LPCWSTR lpszTest = pStrChrFn(lpszMatch, *lpszRead);
 807
 808       if (!bInvert && !lpszTest)
 809         break;
 810       if (bInvert && lpszTest)
 811         break;
 812       lpszRead = CharNextW(lpszRead);
 813     };
 814   }
 815   return lpszRead - lpszStr;
 816 }
 817
 818 /*************************************************************************
 819  * StrCSpnIA    [COMCTL32.374]
 820  *
 821  * Find the length of the start of a string that does not contain certain
 822  * characters, ignoring case.
 823  *
 824  * PARAMS
 825  *  lpszStr   [I] String to search
 826  *  lpszMatch [I] Characters that cannot be in the substring
 827  *
 828  * RETURNS
 829  *  The length of the part of lpszStr containing only chars not in lpszMatch,
 830  *  or 0 if any parameter is invalid.
 831  */
 832 int WINAPI StrCSpnIA(LPCSTR lpszStr, LPCSTR lpszMatch)
 833 {
 834   TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
 835
 836   return COMCTL32_StrSpnHelperA(lpszStr, lpszMatch, StrChrIA, TRUE);
 837 }
 838
 839 /*************************************************************************
 840  * StrCSpnIW    [COMCTL32.375]
 841  *
 842  * See StrCSpnIA.
 843  */
 844 int WINAPI StrCSpnIW(LPCWSTR lpszStr, LPCWSTR lpszMatch)
 845 {
 846   TRACE("(%s,%s)\n",debugstr_w(lpszStr), debugstr_w(lpszMatch));
 847
 848   return COMCTL32_StrSpnHelperW(lpszStr, lpszMatch, StrChrIW, TRUE);
 849 }
 850
 851 /**************************************************************************
 852  * StrRChrIA    [COMCTL32.368]
 853  *
 854  * Find the last occurrence of a character in string, ignoring case.
 855  *
 856  * PARAMS
 857  *  lpszStr [I] String to search in
 858  *  lpszEnd [I] Place to end search, or NULL to search until the end of lpszStr
 859  *  ch      [I] Character to search for.
 860  *
 861  * RETURNS
 862  *  Success: A pointer to the last occurrence of ch in lpszStr before lpszEnd,
 863  *           or NULL if not found.
 864  *  Failure: NULL, if any arguments are invalid.
 865  */
 866 LPSTR WINAPI StrRChrIA(LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch)
 867 {
 868   LPCSTR lpszRet = NULL;
 869
 870   TRACE("(%s,%s,%x)\n", debugstr_a(lpszStr), debugstr_a(lpszEnd), ch);
 871
 872   if (lpszStr)
 873   {
 874     WORD ch2;
 875
 876     if (!lpszEnd)
 877       lpszEnd = lpszStr + lstrlenA(lpszStr);
 878
 879     while (*lpszStr && lpszStr <= lpszEnd)
 880     {
 881       ch2 = IsDBCSLeadByte(*lpszStr)? *lpszStr << 8 | lpszStr[1] : *lpszStr;
 882
 883       if (ch == ch2)
 884         lpszRet = lpszStr;
 885       lpszStr = CharNextA(lpszStr);
 886     }
 887   }
 888   return (LPSTR)lpszRet;
 889 }
 890
 891 /**************************************************************************
 892  * StrRChrIW    [COMCTL32.369]
 893  *
 894  * See StrRChrIA.
 895  */
 896 LPWSTR WINAPI StrRChrIW(LPCWSTR lpszStr, LPCWSTR lpszEnd, WORD ch)
 897 {
 898   LPCWSTR lpszRet = NULL;
 899
 900   TRACE("(%s,%s,%x)\n", debugstr_w(lpszStr), debugstr_w(lpszEnd), ch);
 901
 902   if (lpszStr)
 903   {
 904     if (!lpszEnd)
 905       lpszEnd = lpszStr + strlenW(lpszStr);
 906
 907     while (*lpszStr && lpszStr <= lpszEnd)
 908     {
 909       if (ch == *lpszStr)
 910         lpszRet = lpszStr;
 911       lpszStr = CharNextW(lpszStr);
 912     }
 913   }
 914   return (LPWSTR)lpszRet;
 915 }
 916
 917 /*************************************************************************
 918  * StrCSpnW     [COMCTL32.364]
 919  *
 920  * See StrCSpnA.
 921  */
 922 int WINAPI StrCSpnW(LPCWSTR lpszStr, LPCWSTR lpszMatch)
 923 {
 924   TRACE("(%s,%s)\n",debugstr_w(lpszStr), debugstr_w(lpszMatch));
 925
 926   return COMCTL32_StrSpnHelperW(lpszStr, lpszMatch, StrChrW, TRUE);
 927 }
 928
 929 /*************************************************************************
 930  * IntlStrEqWorkerA     [COMCTL32.376]
 931  *
 932  * Compare two strings.
 933  *
 934  * PARAMS
 935  *  bCase    [I] Whether to compare case sensitively
 936  *  lpszStr  [I] First string to compare
 937  *  lpszComp [I] Second string to compare
 938  *  iLen     [I] Length to compare
 939  *
 940  * RETURNS
 941  *  TRUE  If the strings are equal.
 942  *  FALSE Otherwise.
 943  */
 944 BOOL WINAPI IntlStrEqWorkerA(BOOL bCase, LPCSTR lpszStr, LPCSTR lpszComp,
 945                              int iLen)
 946 {
 947   DWORD dwFlags = LOCALE_USE_CP_ACP;
 948   int iRet;
 949
 950   TRACE("(%d,%s,%s,%d)\n", bCase,
 951         debugstr_a(lpszStr), debugstr_a(lpszComp), iLen);
 952
 953   /* FIXME: These flags are undocumented and unknown by our CompareString.
 954    *        We need defines for them.
 955    */
 956   dwFlags |= bCase ? 0x10000000 : 0x10000001;
 957
 958   iRet = CompareStringA(GetThreadLocale(),
 959                         dwFlags, lpszStr, iLen, lpszComp, iLen);
 960
 961   if (!iRet)
 962     iRet = CompareStringA(2048, dwFlags, lpszStr, iLen, lpszComp, iLen);
 963
 964   return iRet == 2 ? TRUE : FALSE;
 965 }
 966
 967 /*************************************************************************
 968  * IntlStrEqWorkerW     [COMCTL32.377]
 969  *
 970  * See IntlStrEqWorkerA.
 971  */
 972 BOOL WINAPI IntlStrEqWorkerW(BOOL bCase, LPCWSTR lpszStr, LPCWSTR lpszComp,
 973                              int iLen)
 974 {
 975   DWORD dwFlags;
 976   int iRet;
 977
 978   TRACE("(%d,%s,%s,%d)\n", bCase,
 979         debugstr_w(lpszStr),debugstr_w(lpszComp), iLen);
 980
 981   /* FIXME: These flags are undocumented and unknown by our CompareString.
 982    *        We need defines for them.
 983    */
 984   dwFlags = bCase ? 0x10000000 : 0x10000001;
 985
 986   iRet = CompareStringW(GetThreadLocale(),
 987                         dwFlags, lpszStr, iLen, lpszComp, iLen);
 988
 989   if (!iRet)
 990     iRet = CompareStringW(2048, dwFlags, lpszStr, iLen, lpszComp, iLen);
 991
 992   return iRet == 2 ? TRUE : FALSE;
 993 }