dlls/kernelbase/string.c

   1 /*
   2  * Copyright 2019 Nikolay Sivov for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #include "windef.h"
  22 #include "winbase.h"
  23 #include "winnls.h"
  24 #include "shlwapi.h"
  25 #include "winternl.h"
  26
  27 #include "kernelbase.h"
  28 #include "wine/debug.h"
  29 #include "wine/exception.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(string);
  32
  33 #define isxdigit(ch) (((ch) >= '0' && (ch) <= '9') || \
  34                       ((ch) >= 'A' && (ch) <= 'F') || \
  35                       ((ch) >= 'a' && (ch) <= 'f'))
  36
  37 static BOOL char_compare(WORD ch1, WORD ch2, DWORD flags)
  38 {
  39     char str1[3], str2[3];
  40
  41     str1[0] = LOBYTE(ch1);
  42     if (IsDBCSLeadByte(str1[0]))
  43     {
  44         str1[1] = HIBYTE(ch1);
  45         str1[2] = '\0';
  46     }
  47     else
  48         str1[1] = '\0';
  49
  50     str2[0] = LOBYTE(ch2);
  51     if (IsDBCSLeadByte(str2[0]))
  52     {
  53         str2[1] = HIBYTE(ch2);
  54         str2[2] = '\0';
  55     }
  56     else
  57         str2[1] = '\0';
  58
  59     return CompareStringA(GetThreadLocale(), flags, str1, -1, str2, -1) - CSTR_EQUAL;
  60 }
  61
  62 int WINAPI lstrcmpA( LPCSTR str1, LPCSTR str2 )
  63 {
  64     if (!str1 && !str2) return 0;
  65     if (!str1) return -1;
  66     if (!str2) return 1;
  67     return CompareStringA( GetThreadLocale(), LOCALE_USE_CP_ACP, str1, -1, str2, -1 ) - 2;
  68 }
  69
  70 int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
  71 {
  72     if (!str1 && !str2) return 0;
  73     if (!str1) return -1;
  74     if (!str2) return 1;
  75     return CompareStringW( GetThreadLocale(), 0, str1, -1, str2, -1 ) - 2;
  76 }
  77
  78 int WINAPI lstrcmpiA(LPCSTR str1, LPCSTR str2)
  79 {
  80     if (!str1 && !str2) return 0;
  81     if (!str1) return -1;
  82     if (!str2) return 1;
  83     return CompareStringA( GetThreadLocale(), NORM_IGNORECASE|LOCALE_USE_CP_ACP, str1, -1, str2, -1 ) - 2;
  84 }
  85
  86 int WINAPI lstrcmpiW(LPCWSTR str1, LPCWSTR str2)
  87 {
  88     if (!str1 && !str2) return 0;
  89     if (!str1) return -1;
  90     if (!str2) return 1;
  91     return CompareStringW( GetThreadLocale(), NORM_IGNORECASE, str1, -1, str2, -1 ) - 2;
  92 }
  93
  94 LPSTR WINAPI KERNELBASE_lstrcpynA( LPSTR dst, LPCSTR src, INT n )
  95 {
  96     /* Note: this function differs from the UNIX strncpy, it _always_ writes
  97      * a terminating \0.
  98      *
  99      * Note: n is an INT but Windows treats it as unsigned, and will happily
 100      * copy a gazillion chars if n is negative.
 101      */
 102     __TRY
 103     {
 104         LPSTR d = dst;
 105         LPCSTR s = src;
 106         UINT count = n;
 107
 108         while ((count > 1) && *s)
 109         {
 110             count--;
 111             *d++ = *s++;
 112         }
 113         if (count) *d = 0;
 114     }
 115     __EXCEPT_PAGE_FAULT
 116     {
 117         SetLastError( ERROR_INVALID_PARAMETER );
 118         return 0;
 119     }
 120     __ENDTRY
 121     return dst;
 122 }
 123
 124 LPWSTR WINAPI KERNELBASE_lstrcpynW( LPWSTR dst, LPCWSTR src, INT n )
 125 {
 126     /* Note: this function differs from the UNIX strncpy, it _always_ writes
 127      * a terminating \0
 128      *
 129      * Note: n is an INT but Windows treats it as unsigned, and will happily
 130      * copy a gazillion chars if n is negative.
 131      */
 132     __TRY
 133     {
 134         LPWSTR d = dst;
 135         LPCWSTR s = src;
 136         UINT count = n;
 137
 138         while ((count > 1) && *s)
 139         {
 140             count--;
 141             *d++ = *s++;
 142         }
 143         if (count) *d = 0;
 144     }
 145     __EXCEPT_PAGE_FAULT
 146     {
 147         SetLastError( ERROR_INVALID_PARAMETER );
 148         return 0;
 149     }
 150     __ENDTRY
 151     return dst;
 152 }
 153
 154 INT WINAPI KERNELBASE_lstrlenA( LPCSTR str )
 155 {
 156     INT ret;
 157     __TRY
 158     {
 159         ret = strlen(str);
 160     }
 161     __EXCEPT_PAGE_FAULT
 162     {
 163         SetLastError( ERROR_INVALID_PARAMETER );
 164         return 0;
 165     }
 166     __ENDTRY
 167     return ret;
 168 }
 169
 170 INT WINAPI KERNELBASE_lstrlenW( LPCWSTR str )
 171 {
 172     INT ret;
 173     __TRY
 174     {
 175         ret = wcslen(str);
 176     }
 177     __EXCEPT_PAGE_FAULT
 178     {
 179         SetLastError( ERROR_INVALID_PARAMETER );
 180         return 0;
 181     }
 182     __ENDTRY
 183     return ret;
 184 }
 185
 186 DWORD WINAPI StrCmpCA(const char *str, const char *cmp)
 187 {
 188     return lstrcmpA(str, cmp);
 189 }
 190
 191 DWORD WINAPI StrCmpCW(const WCHAR *str, const WCHAR *cmp)
 192 {
 193     return lstrcmpW(str, cmp);
 194 }
 195
 196 DWORD WINAPI StrCmpICA(const char *str, const char *cmp)
 197 {
 198     return lstrcmpiA(str, cmp);
 199 }
 200
 201 DWORD WINAPI StrCmpICW(const WCHAR *str, const WCHAR *cmp)
 202 {
 203     return lstrcmpiW(str, cmp);
 204 }
 205
 206 DWORD WINAPI StrCmpNICA(const char *str, const char *cmp, DWORD len)
 207 {
 208     return StrCmpNIA(str, cmp, len);
 209 }
 210
 211 DWORD WINAPI StrCmpNICW(const WCHAR *str, const WCHAR *cmp, DWORD len)
 212 {
 213     return StrCmpNIW(str, cmp, len);
 214 }
 215
 216 char * WINAPI StrChrA(const char *str, WORD ch)
 217 {
 218     TRACE("%s, %#x\n", wine_dbgstr_a(str), ch);
 219
 220     if (!str)
 221         return NULL;
 222
 223     while (*str)
 224     {
 225         if (!char_compare(*str, ch, 0))
 226             return (char *)str;
 227         str = CharNextA(str);
 228     }
 229
 230     return NULL;
 231 }
 232
 233 WCHAR * WINAPI StrChrW(const WCHAR *str, WCHAR ch)
 234 {
 235     TRACE("%s, %#x\n", wine_dbgstr_w(str), ch);
 236
 237     if (!str)
 238         return NULL;
 239
 240     return wcschr(str, ch);
 241 }
 242
 243 char * WINAPI StrChrIA(const char *str, WORD ch)
 244 {
 245     TRACE("%s, %i\n", wine_dbgstr_a(str), ch);
 246
 247     if (!str)
 248         return NULL;
 249
 250     while (*str)
 251     {
 252         if (!ChrCmpIA(*str, ch))
 253             return (char *)str;
 254         str = CharNextA(str);
 255     }
 256
 257     return NULL;
 258 }
 259
 260 WCHAR * WINAPI StrChrIW(const WCHAR *str, WCHAR ch)
 261 {
 262     TRACE("%s, %#x\n", wine_dbgstr_w(str), ch);
 263
 264     if (!str)
 265         return NULL;
 266
 267     ch = towupper(ch);
 268     while (*str)
 269     {
 270         if (towupper(*str) == ch)
 271             return (WCHAR *)str;
 272         str++;
 273     }
 274     str = NULL;
 275
 276     return (WCHAR *)str;
 277 }
 278
 279 WCHAR * WINAPI StrChrNW(const WCHAR *str, WCHAR ch, UINT max_len)
 280 {
 281     TRACE("%s, %#x, %u\n", wine_dbgstr_wn(str, max_len), ch, max_len);
 282
 283     if (!str)
 284         return NULL;
 285
 286     while (*str && max_len-- > 0)
 287     {
 288         if (*str == ch)
 289             return (WCHAR *)str;
 290         str++;
 291     }
 292
 293     return NULL;
 294 }
 295
 296 char * WINAPI StrDupA(const char *str)
 297 {
 298     unsigned int len;
 299     char *ret;
 300
 301     TRACE("%s\n", wine_dbgstr_a(str));
 302
 303     len = str ? strlen(str) + 1 : 1;
 304     ret = LocalAlloc(LMEM_FIXED, len);
 305
 306     if (ret)
 307     {
 308         if (str)
 309             memcpy(ret, str, len);
 310         else
 311             *ret = '\0';
 312     }
 313
 314     return ret;
 315 }
 316
 317 WCHAR * WINAPI StrDupW(const WCHAR *str)
 318 {
 319     unsigned int len;
 320     WCHAR *ret;
 321
 322     TRACE("%s\n", wine_dbgstr_w(str));
 323
 324     len = (str ? lstrlenW(str) + 1 : 1) * sizeof(WCHAR);
 325     ret = LocalAlloc(LMEM_FIXED, len);
 326
 327     if (ret)
 328     {
 329         if (str)
 330             memcpy(ret, str, len);
 331         else
 332             *ret = '\0';
 333     }
 334
 335     return ret;
 336 }
 337
 338 BOOL WINAPI ChrCmpIA(WORD ch1, WORD ch2)
 339 {
 340     TRACE("%#x, %#x\n", ch1, ch2);
 341
 342     return char_compare(ch1, ch2, NORM_IGNORECASE);
 343 }
 344
 345 BOOL WINAPI ChrCmpIW(WCHAR ch1, WCHAR ch2)
 346 {
 347     return CompareStringW(GetThreadLocale(), NORM_IGNORECASE, &ch1, 1, &ch2, 1) - CSTR_EQUAL;
 348 }
 349
 350 char * WINAPI StrStrA(const char *str, const char *search)
 351 {
 352     const char *end;
 353     size_t len;
 354
 355     TRACE("%s, %s\n", wine_dbgstr_a(str), wine_dbgstr_a(search));
 356
 357     if (!str || !search || !*search) return NULL;
 358
 359     len = strlen(search);
 360     end = str + strlen(str);
 361
 362     while (str + len <= end)
 363     {
 364         if (!StrCmpNA(str, search, len)) return (char *)str;
 365         str = CharNextA(str);
 366     }
 367     return NULL;
 368 }
 369
 370 WCHAR * WINAPI StrStrW(const WCHAR *str, const WCHAR *search)
 371 {
 372     TRACE("%s, %s\n", wine_dbgstr_w(str), wine_dbgstr_w(search));
 373
 374     if (!str || !search || !*search)
 375         return NULL;
 376
 377     return wcsstr(str, search);
 378 }
 379
 380 WCHAR * WINAPI StrStrNW(const WCHAR *str, const WCHAR *search, UINT max_len)
 381 {
 382     unsigned int i, len;
 383
 384     TRACE("%s, %s, %u\n", wine_dbgstr_w(str), wine_dbgstr_w(search), max_len);
 385
 386     if (!str || !search || !*search || !max_len)
 387         return NULL;
 388
 389     len = lstrlenW(search);
 390
 391     for (i = max_len; *str && (i > 0); i--, str++)
 392     {
 393         if (!wcsncmp(str, search, len))
 394             return (WCHAR *)str;
 395     }
 396
 397     return NULL;
 398 }
 399
 400 int WINAPI StrCmpNIA(const char *str, const char *cmp, int len)
 401 {
 402     TRACE("%s, %s, %i\n", wine_dbgstr_a(str), wine_dbgstr_a(cmp), len);
 403     return CompareStringA(GetThreadLocale(), NORM_IGNORECASE, str, len, cmp, len) - CSTR_EQUAL;
 404 }
 405
 406 WCHAR * WINAPI StrStrNIW(const WCHAR *str, const WCHAR *search, UINT max_len)
 407 {
 408     unsigned int i, len;
 409
 410     TRACE("%s, %s, %u\n", wine_dbgstr_w(str), wine_dbgstr_w(search), max_len);
 411
 412     if (!str || !search || !*search || !max_len)
 413         return NULL;
 414
 415     len = lstrlenW(search);
 416
 417     for (i = max_len; *str && (i > 0); i--, str++)
 418     {
 419         if (!StrCmpNIW(str, search, len))
 420             return (WCHAR *)str;
 421     }
 422
 423     return NULL;
 424 }
 425
 426 int WINAPI StrCmpNA(const char *str, const char *comp, int len)
 427 {
 428     TRACE("%s, %s, %i\n", wine_dbgstr_a(str), wine_dbgstr_a(comp), len);
 429     return CompareStringA(GetThreadLocale(), 0, str, len, comp, len) - CSTR_EQUAL;
 430 }
 431
 432 int WINAPI StrCmpNW(const WCHAR *str, const WCHAR *comp, int len)
 433 {
 434     TRACE("%s, %s, %i\n", wine_dbgstr_w(str), wine_dbgstr_w(comp), len);
 435     return CompareStringW(GetThreadLocale(), 0, str, len, comp, len) - CSTR_EQUAL;
 436 }
 437
 438 DWORD WINAPI StrCmpNCA(const char *str, const char *comp, int len)
 439 {
 440     return StrCmpNA(str, comp, len);
 441 }
 442
 443 DWORD WINAPI StrCmpNCW(const WCHAR *str, const WCHAR *comp, int len)
 444 {
 445     return StrCmpNW(str, comp, len);
 446 }
 447
 448 int WINAPI StrCmpNIW(const WCHAR *str, const WCHAR *comp, int len)
 449 {
 450     TRACE("%s, %s, %i\n", wine_dbgstr_w(str), wine_dbgstr_w(comp), len);
 451     return CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str, len, comp, len) - CSTR_EQUAL;
 452 }
 453
 454 int WINAPI StrCmpW(const WCHAR *str, const WCHAR *comp)
 455 {
 456     TRACE("%s, %s\n", wine_dbgstr_w(str), wine_dbgstr_w(comp));
 457     return CompareStringW(GetThreadLocale(), 0, str, -1, comp, -1) - CSTR_EQUAL;
 458 }
 459
 460 int WINAPI StrCmpIW(const WCHAR *str, const WCHAR *comp)
 461 {
 462     TRACE("%s, %s\n", wine_dbgstr_w(str), wine_dbgstr_w(comp));
 463     return CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str, -1, comp, -1) - CSTR_EQUAL;
 464 }
 465
 466 WCHAR * WINAPI StrCpyNW(WCHAR *dst, const WCHAR *src, int count)
 467 {
 468     const WCHAR *s = src;
 469     WCHAR *d = dst;
 470
 471     TRACE("%p, %s, %i\n", dst, wine_dbgstr_w(src), count);
 472
 473     if (s)
 474     {
 475         while ((count > 1) && *s)
 476         {
 477             count--;
 478             *d++ = *s++;
 479         }
 480     }
 481     if (count) *d = 0;
 482
 483     return dst;
 484 }
 485
 486 char * WINAPI StrStrIA(const char *str, const char *search)
 487 {
 488     const char *end;
 489     size_t len;
 490
 491     TRACE("%s, %s\n", wine_dbgstr_a(str), debugstr_a(search));
 492
 493     if (!str || !search || !*search) return NULL;
 494
 495     len = strlen(search);
 496     end = str + strlen(str);
 497
 498     while (str + len <= end)
 499     {
 500         if (!StrCmpNIA(str, search, len)) return (char *)str;
 501         str = CharNextA(str);
 502     }
 503     return NULL;
 504 }
 505
 506 WCHAR * WINAPI StrStrIW(const WCHAR *str, const WCHAR *search)
 507 {
 508     unsigned int len;
 509     const WCHAR *end;
 510
 511     TRACE("%s, %s\n", wine_dbgstr_w(str), wine_dbgstr_w(search));
 512
 513     if (!str || !search || !*search)
 514         return NULL;
 515
 516     len = lstrlenW(search);
 517     end = str + lstrlenW(str);
 518
 519     while (str + len <= end)
 520     {
 521         if (!StrCmpNIW(str, search, len))
 522             return (WCHAR *)str;
 523         str++;
 524     }
 525
 526     return NULL;
 527 }
 528
 529 int WINAPI StrSpnA(const char *str, const char *match)
 530 {
 531     const char *ptr = str;
 532
 533     TRACE("%s, %s\n", wine_dbgstr_a(str), wine_dbgstr_a(match));
 534
 535     if (!str || !match) return 0;
 536
 537     while (*ptr)
 538     {
 539         if (!StrChrA(match, *ptr)) break;
 540         ptr = CharNextA(ptr);
 541     }
 542     return ptr - str;
 543 }
 544
 545 int WINAPI StrSpnW(const WCHAR *str, const WCHAR *match)
 546 {
 547     if (!str || !match) return 0;
 548     return wcsspn(str, match);
 549 }
 550
 551 int WINAPI StrCSpnA(const char *str, const char *match)
 552 {
 553     const char *ptr = str;
 554
 555     TRACE("%s, %s\n", wine_dbgstr_a(str), wine_dbgstr_a(match));
 556
 557     if (!str || !match) return 0;
 558
 559     while (*ptr)
 560     {
 561         if (StrChrA(match, *ptr)) break;
 562         ptr = CharNextA(ptr);
 563     }
 564     return ptr - str;
 565 }
 566
 567 int WINAPI StrCSpnW(const WCHAR *str, const WCHAR *match)
 568 {
 569     if (!str || !match)
 570         return 0;
 571
 572     return wcscspn(str, match);
 573 }
 574
 575 int WINAPI StrCSpnIA(const char *str, const char *match)
 576 {
 577     const char *ptr = str;
 578
 579     TRACE("%s, %s\n", wine_dbgstr_a(str), wine_dbgstr_a(match));
 580
 581     if (!str || !match) return 0;
 582
 583     while (*ptr)
 584     {
 585         if (StrChrIA(match, *ptr)) break;
 586         ptr = CharNextA(ptr);
 587     }
 588     return ptr - str;
 589 }
 590
 591 int WINAPI StrCSpnIW(const WCHAR *str, const WCHAR *match)
 592 {
 593     const WCHAR *ptr = str;
 594
 595     TRACE("%s, %s\n", wine_dbgstr_w(str), wine_dbgstr_w(match));
 596
 597     if (!str || !*str || !match)
 598         return 0;
 599
 600     while (*ptr)
 601     {
 602         if (StrChrIW(match, *ptr)) break;
 603         ptr++;
 604     }
 605
 606     return ptr - str;
 607 }
 608
 609 char * WINAPI StrRChrA(const char *str, const char *end, WORD ch)
 610 {
 611     const char *ret = NULL;
 612
 613     TRACE("%s, %s, %#x\n", wine_dbgstr_a(str), wine_dbgstr_a(end), ch);
 614
 615     if (!str) return NULL;
 616     if (!end) end = str + lstrlenA(str);
 617     while (*str && str <= end)
 618     {
 619         WORD ch2 = IsDBCSLeadByte(*str) ? *str << 8 | str[1] : *str;
 620         if (!char_compare(ch, ch2, 0)) ret = str;
 621         str = CharNextA(str);
 622     }
 623     return (char *)ret;
 624 }
 625
 626 WCHAR * WINAPI StrRChrW(const WCHAR *str, const WCHAR *end, WORD ch)
 627 {
 628     WCHAR *ret = NULL;
 629
 630     if (!str) return NULL;
 631     if (!end) end = str + lstrlenW(str);
 632     while (str < end)
 633     {
 634         if (*str == ch) ret = (WCHAR *)str;
 635         str++;
 636     }
 637     return ret;
 638 }
 639
 640 char * WINAPI StrRChrIA(const char *str, const char *end, WORD ch)
 641 {
 642     const char *ret = NULL;
 643
 644     TRACE("%s, %s, %#x\n", wine_dbgstr_a(str), wine_dbgstr_a(end), ch);
 645
 646     if (!str) return NULL;
 647     if (!end) end = str + lstrlenA(str);
 648
 649     while (*str && str <= end)
 650     {
 651         WORD ch2 = IsDBCSLeadByte(*str) ? *str << 8 | str[1] : *str;
 652         if (!ChrCmpIA(ch, ch2)) ret = str;
 653         str = CharNextA(str);
 654     }
 655     return (char *)ret;
 656 }
 657
 658 WCHAR * WINAPI StrRChrIW(const WCHAR *str, const WCHAR *end, WORD ch)
 659 {
 660     WCHAR *ret = NULL;
 661
 662     if (!str) return NULL;
 663     if (!end) end = str + lstrlenW(str);
 664     while (str < end)
 665     {
 666         if (!ChrCmpIW(*str, ch)) ret = (WCHAR *)str;
 667         str++;
 668     }
 669     return ret;
 670 }
 671
 672 char * WINAPI StrRStrIA(const char *str, const char *end, const char *search)
 673 {
 674     char *ret = NULL;
 675     WORD ch1, ch2;
 676     int len;
 677
 678     TRACE("%s, %s\n", wine_dbgstr_a(str), wine_dbgstr_a(search));
 679
 680     if (!str || !search || !*search)
 681         return NULL;
 682
 683     if (IsDBCSLeadByte(*search))
 684         ch1 = *search << 8 | (UCHAR)search[1];
 685     else
 686         ch1 = *search;
 687     len = lstrlenA(search);
 688
 689     if (!end)
 690         end = str + lstrlenA(str);
 691     else /* reproduce the broken behaviour on Windows */
 692         end += min(len - 1, lstrlenA(end));
 693
 694     while (str + len <= end && *str)
 695     {
 696         ch2 = IsDBCSLeadByte(*str) ? *str << 8 | (UCHAR)str[1] : *str;
 697         if (!ChrCmpIA(ch1, ch2))
 698         {
 699             if (!StrCmpNIA(str, search, len))
 700                 ret = (char *)str;
 701         }
 702
 703         str = CharNextA(str);
 704     }
 705
 706     return ret;
 707 }
 708
 709 WCHAR * WINAPI StrRStrIW(const WCHAR *str, const WCHAR *end, const WCHAR *search)
 710 {
 711     WCHAR *ret = NULL;
 712     int len;
 713
 714     TRACE("%s, %s\n", wine_dbgstr_w(str), wine_dbgstr_w(search));
 715
 716     if (!str || !search || !*search)
 717         return NULL;
 718
 719     len = lstrlenW(search);
 720
 721     if (!end)
 722         end = str + lstrlenW(str);
 723     else
 724         end += min(len - 1, lstrlenW(end));
 725
 726     while (str + len <= end && *str)
 727     {
 728         if (!ChrCmpIW(*search, *str))
 729         {
 730             if (!StrCmpNIW(str, search, len))
 731                 ret = (WCHAR *)str;
 732         }
 733         str++;
 734     }
 735
 736     return ret;
 737 }
 738
 739 char * WINAPI StrPBrkA(const char *str, const char *match)
 740 {
 741     TRACE("%s, %s\n", wine_dbgstr_a(str), wine_dbgstr_a(match));
 742
 743     if (!str || !match || !*match)
 744         return NULL;
 745
 746     while (*str)
 747     {
 748         if (StrChrA(match, *str))
 749             return (char *)str;
 750         str = CharNextA(str);
 751     }
 752
 753     return NULL;
 754 }
 755
 756 WCHAR * WINAPI StrPBrkW(const WCHAR *str, const WCHAR *match)
 757 {
 758     if (!str || !match) return NULL;
 759     return wcspbrk(str, match);
 760 }
 761
 762 BOOL WINAPI StrTrimA(char *str, const char *trim)
 763 {
 764     unsigned int len;
 765     BOOL ret = FALSE;
 766     char *ptr = str;
 767
 768     TRACE("%s, %s\n", debugstr_a(str), debugstr_a(trim));
 769
 770     if (!str || !*str)
 771         return FALSE;
 772
 773     while (*ptr && StrChrA(trim, *ptr))
 774         ptr = CharNextA(ptr); /* Skip leading matches */
 775
 776     len = strlen(ptr);
 777
 778     if (ptr != str)
 779     {
 780         memmove(str, ptr, len + 1);
 781         ret = TRUE;
 782     }
 783
 784     if (len > 0)
 785     {
 786         ptr = str + len;
 787         while (StrChrA(trim, ptr[-1]))
 788             ptr = CharPrevA(str, ptr); /* Skip trailing matches */
 789
 790         if (ptr != str + len)
 791         {
 792             *ptr = '\0';
 793             ret = TRUE;
 794         }
 795     }
 796
 797     return ret;
 798 }
 799
 800 BOOL WINAPI StrTrimW(WCHAR *str, const WCHAR *trim)
 801 {
 802     unsigned int len;
 803     WCHAR *ptr = str;
 804     BOOL ret = FALSE;
 805
 806     TRACE("%s, %s\n", wine_dbgstr_w(str), wine_dbgstr_w(trim));
 807
 808     if (!str || !*str)
 809         return FALSE;
 810
 811     while (*ptr && StrChrW(trim, *ptr))
 812         ptr++;
 813
 814     len = lstrlenW(ptr);
 815
 816     if (ptr != str)
 817     {
 818         memmove(str, ptr, (len + 1) * sizeof(WCHAR));
 819         ret = TRUE;
 820     }
 821
 822     if (len > 0)
 823     {
 824         ptr = str + len;
 825         while (StrChrW(trim, ptr[-1]))
 826             ptr--; /* Skip trailing matches */
 827
 828         if (ptr != str + len)
 829         {
 830             *ptr = '\0';
 831             ret = TRUE;
 832         }
 833     }
 834
 835     return ret;
 836 }
 837
 838 BOOL WINAPI StrToInt64ExA(const char *str, DWORD flags, LONGLONG *ret)
 839 {
 840     BOOL negative = FALSE;
 841     LONGLONG value = 0;
 842
 843     TRACE("%s, %#x, %p\n", wine_dbgstr_a(str), flags, ret);
 844
 845     if (!str || !ret)
 846         return FALSE;
 847
 848     if (flags > STIF_SUPPORT_HEX)
 849         WARN("Unknown flags %#x\n", flags);
 850
 851     /* Skip leading space, '+', '-' */
 852     while (*str == ' ' || *str == '\t' || *str == '\n') str++;
 853
 854     if (*str == '-')
 855     {
 856         negative = TRUE;
 857         str++;
 858     }
 859     else if (*str == '+')
 860         str++;
 861
 862     if (flags & STIF_SUPPORT_HEX && *str == '0' && (str[1] == 'x' || str[1] == 'X'))
 863     {
 864         /* Read hex number */
 865         str += 2;
 866
 867         if (!isxdigit(*str))
 868             return FALSE;
 869
 870         while (isxdigit(*str))
 871         {
 872             value *= 16;
 873             if (*str >= '0' && *str <= '9')
 874                 value += (*str - '0');
 875             else if (*str >= 'A' && *str <= 'F')
 876                 value += 10 + *str - 'A';
 877             else
 878                 value += 10 + *str - 'a';
 879             str++;
 880         }
 881
 882         *ret = value;
 883         return TRUE;
 884     }
 885
 886     /* Read decimal number */
 887     if (*str < '0' || *str > '9')
 888         return FALSE;
 889
 890     while (*str >= '0' && *str <= '9')
 891     {
 892         value *= 10;
 893         value += (*str - '0');
 894         str++;
 895     }
 896
 897     *ret = negative ? -value : value;
 898     return TRUE;
 899 }
 900
 901 BOOL WINAPI StrToInt64ExW(const WCHAR *str, DWORD flags, LONGLONG *ret)
 902 {
 903     BOOL negative = FALSE;
 904     LONGLONG value = 0;
 905
 906     TRACE("%s, %#x, %p\n", wine_dbgstr_w(str), flags, ret);
 907
 908     if (!str || !ret)
 909         return FALSE;
 910
 911     if (flags > STIF_SUPPORT_HEX)
 912         WARN("Unknown flags %#x.\n", flags);
 913
 914     /* Skip leading space, '+', '-' */
 915     while (*str == ' ' || *str == '\t' || *str == '\n') str++;
 916
 917     if (*str == '-')
 918     {
 919         negative = TRUE;
 920         str++;
 921     }
 922     else if (*str == '+')
 923         str++;
 924
 925     if (flags & STIF_SUPPORT_HEX && *str == '0' && (str[1] == 'x' || str[1] == 'X'))
 926     {
 927         /* Read hex number */
 928         str += 2;
 929
 930         if (!isxdigit(*str))
 931             return FALSE;
 932
 933         while (isxdigit(*str))
 934         {
 935             value *= 16;
 936             if (*str >= '0' && *str <= '9')
 937                 value += (*str - '0');
 938             else if (*str >= 'A' && *str <= 'Z')
 939                 value += 10 + (*str - 'A');
 940             else
 941                 value += 10 + (*str - 'a');
 942             str++;
 943         }
 944
 945         *ret = value;
 946         return TRUE;
 947     }
 948
 949     /* Read decimal number */
 950     if (*str < '0' || *str > '9')
 951         return FALSE;
 952
 953     while (*str >= '0' && *str <= '9')
 954     {
 955         value *= 10;
 956         value += (*str - '0');
 957         str++;
 958     }
 959
 960     *ret = negative ? -value : value;
 961     return TRUE;
 962 }
 963
 964 BOOL WINAPI StrToIntExA(const char *str, DWORD flags, INT *ret)
 965 {
 966     LONGLONG value;
 967     BOOL res;
 968
 969     TRACE("%s, %#x, %p\n", wine_dbgstr_a(str), flags, ret);
 970
 971     res = StrToInt64ExA(str, flags, &value);
 972     if (res) *ret = value;
 973     return res;
 974 }
 975
 976 BOOL WINAPI StrToIntExW(const WCHAR *str, DWORD flags, INT *ret)
 977 {
 978     LONGLONG value;
 979     BOOL res;
 980
 981     TRACE("%s, %#x, %p\n", wine_dbgstr_w(str), flags, ret);
 982
 983     res = StrToInt64ExW(str, flags, &value);
 984     if (res) *ret = value;
 985     return res;
 986 }
 987
 988 int WINAPI StrToIntA(const char *str)
 989 {
 990     int value = 0;
 991
 992     TRACE("%s\n", wine_dbgstr_a(str));
 993
 994     if (!str)
 995         return 0;
 996
 997     if (*str == '-' || (*str >= '0' && *str <= '9'))
 998         StrToIntExA(str, 0, &value);
 999
1000     return value;
1001 }
1002
1003 int WINAPI StrToIntW(const WCHAR *str)
1004 {
1005     int value = 0;
1006
1007     TRACE("%s\n", wine_dbgstr_w(str));
1008
1009     if (!str)
1010         return 0;
1011
1012     if (*str == '-' || (*str >= '0' && *str <= '9'))
1013         StrToIntExW(str, 0, &value);
1014     return value;
1015 }
1016
1017 char * WINAPI StrCpyNXA(char *dst, const char *src, int len)
1018 {
1019     TRACE("%p, %s, %i\n", dst, wine_dbgstr_a(src), len);
1020
1021     if (dst && src && len > 0)
1022     {
1023         while ((len-- > 1) && *src)
1024             *dst++ = *src++;
1025         if (len >= 0)
1026             *dst = '\0';
1027     }
1028
1029     return dst;
1030 }
1031
1032 WCHAR * WINAPI StrCpyNXW(WCHAR *dst, const WCHAR *src, int len)
1033 {
1034     TRACE("%p, %s, %i\n", dst, wine_dbgstr_w(src), len);
1035
1036     if (dst && src && len > 0)
1037     {
1038         while ((len-- > 1) && *src)
1039             *dst++ = *src++;
1040         if (len >= 0)
1041             *dst = '\0';
1042     }
1043
1044     return dst;
1045 }
1046
1047 LPSTR WINAPI CharLowerA(char *str)
1048 {
1049     if (IS_INTRESOURCE(str))
1050     {
1051         char ch = LOWORD(str);
1052         CharLowerBuffA( &ch, 1 );
1053         return (LPSTR)(UINT_PTR)(BYTE)ch;
1054     }
1055
1056     __TRY
1057     {
1058         CharLowerBuffA( str, strlen(str) );
1059     }
1060     __EXCEPT_PAGE_FAULT
1061     {
1062         SetLastError( ERROR_INVALID_PARAMETER );
1063         return NULL;
1064     }
1065     __ENDTRY
1066     return str;
1067 }
1068
1069 DWORD WINAPI CharLowerBuffA(char *str, DWORD len)
1070 {
1071     DWORD lenW;
1072     WCHAR buffer[32];
1073     WCHAR *strW = buffer;
1074
1075     if (!str) return 0; /* YES */
1076
1077     lenW = MultiByteToWideChar(CP_ACP, 0, str, len, NULL, 0);
1078     if (lenW > ARRAY_SIZE(buffer))
1079     {
1080         strW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
1081         if (!strW) return 0;
1082     }
1083     MultiByteToWideChar(CP_ACP, 0, str, len, strW, lenW);
1084     CharLowerBuffW(strW, lenW);
1085     len = WideCharToMultiByte(CP_ACP, 0, strW, lenW, str, len, NULL, NULL);
1086     if (strW != buffer) HeapFree(GetProcessHeap(), 0, strW);
1087     return len;
1088 }
1089
1090 DWORD WINAPI CharLowerBuffW(WCHAR *str, DWORD len)
1091 {
1092     if (!str) return 0; /* YES */
1093     return LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE, str, len, str, len);
1094 }
1095
1096 LPWSTR WINAPI CharLowerW(WCHAR *str)
1097 {
1098     if (!IS_INTRESOURCE(str))
1099     {
1100         CharLowerBuffW(str, lstrlenW(str));
1101         return str;
1102     }
1103     else
1104     {
1105         WCHAR ch = LOWORD(str);
1106         CharLowerBuffW(&ch, 1);
1107         return (LPWSTR)(UINT_PTR)ch;
1108     }
1109 }
1110
1111 LPSTR WINAPI CharNextA(const char *ptr)
1112 {
1113     if (!*ptr) return (LPSTR)ptr;
1114     if (IsDBCSLeadByte( ptr[0] ) && ptr[1]) return (LPSTR)(ptr + 2);
1115     return (LPSTR)(ptr + 1);
1116 }
1117
1118 LPSTR WINAPI CharNextExA(WORD codepage, const char *ptr, DWORD flags)
1119 {
1120     if (!*ptr) return (LPSTR)ptr;
1121     if (IsDBCSLeadByteEx( codepage, ptr[0] ) && ptr[1]) return (LPSTR)(ptr + 2);
1122     return (LPSTR)(ptr + 1);
1123 }
1124
1125 LPWSTR WINAPI CharNextW(const WCHAR *x)
1126 {
1127     if (*x) x++;
1128
1129     return (WCHAR *)x;
1130 }
1131
1132 LPSTR WINAPI CharPrevA(const char *start, const char *ptr)
1133 {
1134     while (*start && (start < ptr))
1135     {
1136         LPCSTR next = CharNextA(start);
1137         if (next >= ptr) break;
1138         start = next;
1139     }
1140     return (LPSTR)start;
1141 }
1142
1143 LPSTR WINAPI CharPrevExA(WORD codepage, const char *start, const char *ptr, DWORD flags)
1144 {
1145     while (*start && (start < ptr))
1146     {
1147         LPCSTR next = CharNextExA(codepage, start, flags);
1148         if (next >= ptr) break;
1149         start = next;
1150     }
1151     return (LPSTR)start;
1152 }
1153
1154 LPWSTR WINAPI CharPrevW(const WCHAR *start, const WCHAR *x)
1155 {
1156     if (x > start) return (LPWSTR)(x - 1);
1157     else return (LPWSTR)x;
1158 }
1159
1160 LPSTR WINAPI CharUpperA(LPSTR str)
1161 {
1162     if (IS_INTRESOURCE(str))
1163     {
1164         char ch = LOWORD(str);
1165         CharUpperBuffA(&ch, 1);
1166         return (LPSTR)(UINT_PTR)(BYTE)ch;
1167     }
1168
1169     __TRY
1170     {
1171         CharUpperBuffA(str, strlen(str));
1172     }
1173     __EXCEPT_PAGE_FAULT
1174     {
1175         SetLastError(ERROR_INVALID_PARAMETER);
1176         return NULL;
1177     }
1178     __ENDTRY
1179     return str;
1180 }
1181
1182 DWORD WINAPI CharUpperBuffA(LPSTR str, DWORD len)
1183 {
1184     DWORD lenW;
1185     WCHAR buffer[32];
1186     WCHAR *strW = buffer;
1187
1188     if (!str) return 0; /* YES */
1189
1190     lenW = MultiByteToWideChar(CP_ACP, 0, str, len, NULL, 0);
1191     if (lenW > ARRAY_SIZE(buffer))
1192     {
1193         strW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
1194         if (!strW) return 0;
1195     }
1196     MultiByteToWideChar(CP_ACP, 0, str, len, strW, lenW);
1197     CharUpperBuffW(strW, lenW);
1198     len = WideCharToMultiByte(CP_ACP, 0, strW, lenW, str, len, NULL, NULL);
1199     if (strW != buffer) HeapFree(GetProcessHeap(), 0, strW);
1200     return len;
1201 }
1202
1203 DWORD WINAPI CharUpperBuffW(WCHAR *str, DWORD len)
1204 {
1205     if (!str) return 0; /* YES */
1206     return LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE, str, len, str, len);
1207 }
1208
1209 LPWSTR WINAPI CharUpperW(WCHAR *str)
1210 {
1211     if (!IS_INTRESOURCE(str))
1212     {
1213         CharUpperBuffW(str, lstrlenW(str));
1214         return str;
1215     }
1216     else
1217     {
1218         WCHAR ch = LOWORD(str);
1219         CharUpperBuffW(&ch, 1);
1220         return (LPWSTR)(UINT_PTR)ch;
1221     }
1222 }
1223
1224 INT WINAPI DECLSPEC_HOTPATCH LoadStringW(HINSTANCE instance, UINT resource_id, LPWSTR buffer, INT buflen)
1225 {
1226     int string_num, i;
1227     HGLOBAL hmem;
1228     HRSRC hrsrc;
1229     WCHAR *p;
1230
1231     TRACE("instance = %p, id = %04x, buffer = %p, length = %d\n", instance, resource_id, buffer, buflen);
1232
1233     if (!buffer)
1234         return 0;
1235
1236     /* Use loword (incremented by 1) as resourceid */
1237     hrsrc = FindResourceW(instance, MAKEINTRESOURCEW((LOWORD(resource_id) >> 4) + 1), (LPWSTR)RT_STRING);
1238     if (!hrsrc) return 0;
1239     hmem = LoadResource(instance, hrsrc);
1240     if (!hmem) return 0;
1241
1242     p = LockResource(hmem);
1243     string_num = resource_id & 0x000f;
1244     for (i = 0; i < string_num; i++)
1245         p += *p + 1;
1246
1247     TRACE("strlen = %d\n", (int)*p );
1248
1249     /*if buflen == 0, then return a read-only pointer to the resource itself in buffer
1250     it is assumed that buffer is actually a (LPWSTR *) */
1251     if (buflen == 0)
1252     {
1253         *((LPWSTR *)buffer) = p + 1;
1254         return *p;
1255     }
1256
1257     i = min(buflen - 1, *p);
1258     if (i > 0)
1259     {
1260         memcpy(buffer, p + 1, i * sizeof (WCHAR));
1261         buffer[i] = 0;
1262     }
1263     else
1264     {
1265         if (buflen > 1)
1266         {
1267             buffer[0] = 0;
1268             return 0;
1269         }
1270     }
1271
1272     TRACE("returning %s\n", debugstr_w(buffer));
1273     return i;
1274 }
1275
1276 INT WINAPI DECLSPEC_HOTPATCH LoadStringA(HINSTANCE instance, UINT resource_id, LPSTR buffer, INT buflen)
1277 {
1278     DWORD retval = 0;
1279     HGLOBAL hmem;
1280     HRSRC hrsrc;
1281
1282     TRACE("instance = %p, id = %04x, buffer = %p, length = %d\n", instance, resource_id, buffer, buflen);
1283
1284     if (!buflen) return -1;
1285
1286     /* Use loword (incremented by 1) as resourceid */
1287     if ((hrsrc = FindResourceW(instance, MAKEINTRESOURCEW((LOWORD(resource_id) >> 4) + 1), (LPWSTR)RT_STRING )) &&
1288             (hmem = LoadResource(instance, hrsrc)))
1289     {
1290         const WCHAR *p = LockResource(hmem);
1291         unsigned int id = resource_id & 0x000f;
1292
1293         while (id--) p += *p + 1;
1294
1295         RtlUnicodeToMultiByteN(buffer, buflen - 1, &retval, p + 1, *p * sizeof(WCHAR));
1296     }
1297     buffer[retval] = 0;
1298     TRACE("returning %s\n", debugstr_a(buffer));
1299     return retval;
1300 }
1301
1302 int WINAPI StrCmpLogicalW(const WCHAR *str, const WCHAR *comp)
1303 {
1304     TRACE("%s, %s\n", wine_dbgstr_w(str), wine_dbgstr_w(comp));
1305
1306     if (!str || !comp)
1307         return 0;
1308
1309     while (*str)
1310     {
1311         if (!*comp)
1312             return 1;
1313         else if (*str >= '0' && *str <= '9')
1314         {
1315             int str_value, comp_value;
1316
1317             if (*comp < '0' || *comp > '9')
1318                 return -1;
1319
1320             /* Compare the numbers */
1321             StrToIntExW(str, 0, &str_value);
1322             StrToIntExW(comp, 0, &comp_value);
1323
1324             if (str_value < comp_value)
1325                 return -1;
1326             else if (str_value > comp_value)
1327                 return 1;
1328
1329             /* Skip */
1330             while (*str >= '0' && *str <= '9') str++;
1331             while (*comp >= '0' && *comp <= '9') comp++;
1332         }
1333         else if (*comp >= '0' && *comp <= '9')
1334             return 1;
1335         else
1336         {
1337             int diff = ChrCmpIW(*str, *comp);
1338             if (diff > 0)
1339                 return 1;
1340             else if (diff < 0)
1341                 return -1;
1342
1343             str++;
1344             comp++;
1345         }
1346     }
1347
1348     if (*comp)
1349       return -1;
1350
1351     return 0;
1352 }
1353
1354 BOOL WINAPI StrIsIntlEqualA(BOOL case_sensitive, const char *str, const char *cmp, int len)
1355 {
1356     DWORD flags;
1357
1358     TRACE("%d, %s, %s, %d\n", case_sensitive, wine_dbgstr_a(str), wine_dbgstr_a(cmp), len);
1359
1360     /* FIXME: This flag is undocumented and unknown by our CompareString.
1361      *        We need a define for it.
1362      */
1363     flags = 0x10000000;
1364     if (!case_sensitive)
1365         flags |= NORM_IGNORECASE;
1366
1367     return (CompareStringA(GetThreadLocale(), flags, str, len, cmp, len) == CSTR_EQUAL);
1368 }
1369
1370 BOOL WINAPI StrIsIntlEqualW(BOOL case_sensitive, const WCHAR *str, const WCHAR *cmp, int len)
1371 {
1372     DWORD flags;
1373
1374     TRACE("%d, %s, %s, %d\n", case_sensitive, debugstr_w(str), debugstr_w(cmp), len);
1375
1376     /* FIXME: This flag is undocumented and unknown by our CompareString.
1377      *        We need a define for it.
1378      */
1379     flags = 0x10000000;
1380     if (!case_sensitive)
1381         flags |= NORM_IGNORECASE;
1382
1383     return (CompareStringW(GetThreadLocale(), flags, str, len, cmp, len) == CSTR_EQUAL);
1384 }
1385
1386 char * WINAPI StrCatBuffA(char *str, const char *cat, INT max_len)
1387 {
1388     INT len;
1389
1390     TRACE("%p, %s, %d\n", str, wine_dbgstr_a(cat), max_len);
1391
1392     if (!str)
1393         return NULL;
1394
1395     len = strlen(str);
1396     max_len -= len;
1397     if (max_len > 0)
1398         StrCpyNA(str + len, cat, max_len);
1399
1400     return str;
1401 }
1402
1403 WCHAR * WINAPI StrCatBuffW(WCHAR *str, const WCHAR *cat, INT max_len)
1404 {
1405     INT len;
1406
1407     TRACE("%p, %s, %d\n", str, wine_dbgstr_w(cat), max_len);
1408
1409     if (!str)
1410         return NULL;
1411
1412     len = lstrlenW(str);
1413     max_len -= len;
1414     if (max_len > 0)
1415         StrCpyNW(str + len, cat, max_len);
1416
1417     return str;
1418 }
1419
1420 DWORD WINAPI StrCatChainW(WCHAR *str, DWORD max_len, DWORD at, const WCHAR *cat)
1421 {
1422     TRACE("%s, %u, %d, %s\n", wine_dbgstr_w(str), max_len, at, wine_dbgstr_w(cat));
1423
1424     if (at == -1)
1425         at = lstrlenW(str);
1426
1427     if (!max_len)
1428         return at;
1429
1430     if (at == max_len)
1431         at--;
1432
1433     if (cat && at < max_len)
1434     {
1435         str += at;
1436         while (at < max_len - 1 && *cat)
1437         {
1438             *str++ = *cat++;
1439             at++;
1440         }
1441         *str = 0;
1442     }
1443
1444     return at;
1445 }
1446
1447 DWORD WINAPI SHTruncateString(char *str, DWORD size)
1448 {
1449     char *last_byte;
1450
1451     if (!str || !size)
1452         return 0;
1453
1454     last_byte = str + size - 1;
1455
1456     while (str < last_byte)
1457         str += IsDBCSLeadByte(*str) ? 2 : 1;
1458
1459     if (str == last_byte && IsDBCSLeadByte(*str))
1460     {
1461         *str = '\0';
1462         size--;
1463     }
1464
1465     return size;
1466 }
1467
1468 HRESULT WINAPI SHLoadIndirectString(const WCHAR *src, WCHAR *dst, UINT dst_len, void **reserved)
1469 {
1470     WCHAR *dllname = NULL;
1471     HMODULE hmod = NULL;
1472     HRESULT hr = E_FAIL;
1473
1474     TRACE("%s, %p, %#x, %p\n", debugstr_w(src), dst, dst_len, reserved);
1475
1476     if (src[0] == '@')
1477     {
1478         WCHAR *index_str;
1479         int index;
1480
1481         dst[0] = 0;
1482         dllname = StrDupW(src + 1);
1483         index_str = wcschr(dllname, ',');
1484
1485         if(!index_str) goto end;
1486
1487         *index_str = 0;
1488         index_str++;
1489         index = wcstol(index_str, NULL, 10);
1490
1491         hmod = LoadLibraryW(dllname);
1492         if (!hmod) goto end;
1493
1494         if (index < 0)
1495         {
1496             if (LoadStringW(hmod, -index, dst, dst_len))
1497                 hr = S_OK;
1498         }
1499         else
1500             FIXME("can't handle non-negative indices (%d)\n", index);
1501     }
1502     else
1503     {
1504         if (dst != src)
1505             lstrcpynW(dst, src, dst_len);
1506         hr = S_OK;
1507     }
1508
1509     TRACE("returning %s\n", debugstr_w(dst));
1510 end:
1511     if (hmod) FreeLibrary(hmod);
1512     LocalFree(dllname);
1513     return hr;
1514 }