dlls/shlwapi/string.c

   1 /*
   2  * Shlwapi string functions
   3  *
   4  * Copyright 1998 Juergen Schmied
   5  * Copyright 2002 Jon Griffiths
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #define COM_NO_WINDOWS_H
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <ctype.h>
  27 #include <math.h>
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31
  32 #include "winerror.h"
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "wingdi.h"
  36 #include "winuser.h"
  37 #include "winreg.h"
  38 #define NO_SHLWAPI_STREAM
  39 #include "shlwapi.h"
  40 #include "shlobj.h"
  41 #include "wine/unicode.h"
  42 #include "wine/debug.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  45
  46 static HRESULT WINAPI _SHStrDupAA(LPCSTR src, LPSTR * dest);
  47 static HRESULT WINAPI _SHStrDupAW(LPCWSTR src, LPSTR * dest);
  48
  49 /*************************************************************************
  50  * SHLWAPI_ChrCmpHelperA
  51  *
  52  * Internal helper for SHLWAPI_ChrCmpA/ChrCMPIA.
  53  *
  54  * NOTES
  55  *  Both this function and its Unicode counterpart are very inneficient. To
  56  *  fix this, CompareString must be completely implemented and optimised
  57  *  first. Then the core character test can be taken out of that function and
  58  *  placed here, so that it need never be called at all. Until then, do not
  59  *  attempt to optimise this code unless you are willing to test that it
  60  *  still performs correctly.
  61  */
  62 static BOOL WINAPI SHLWAPI_ChrCmpHelperA(WORD ch1, WORD ch2, DWORD dwFlags)
  63 {
  64   char str1[3], str2[3];
  65
  66   str1[0] = LOBYTE(ch1);
  67   if (IsDBCSLeadByte(ch1))
  68   {
  69     str1[1] = HIBYTE(ch1);
  70     str1[2] = '\0';
  71   }
  72   else
  73     str1[1] = '\0';
  74
  75   str2[0] = LOBYTE(ch2);
  76   if (IsDBCSLeadByte(ch2))
  77   {
  78     str2[1] = HIBYTE(ch2);
  79     str2[2] = '\0';
  80   }
  81   else
  82     str2[1] = '\0';
  83
  84   return CompareStringA(GetThreadLocale(), dwFlags, str1, -1, str2, -1) - 2;
  85 }
  86
  87 /*************************************************************************
  88  * SHLWAPI_ChrCmpHelperW
  89  *
  90  * Internal helper for SHLWAPI_ChrCmpW/ChrCmpIW.
  91  */
  92 static BOOL WINAPI SHLWAPI_ChrCmpHelperW(WCHAR ch1, WCHAR ch2, DWORD dwFlags)
  93 {
  94   WCHAR str1[2], str2[2];
  95
  96   str1[0] = ch1;
  97   str1[1] = '\0';
  98   str2[0] = ch2;
  99   str2[1] = '\0';
 100   return CompareStringW(GetThreadLocale(), dwFlags, str1, 2, str2, 2) - 2;
 101 }
 102
 103 /*************************************************************************
 104  * SHLWAPI_ChrCmpA
 105  *
 106  * Internal helper function.
 107  */
 108 static BOOL WINAPI SHLWAPI_ChrCmpA(WORD ch1, WORD ch2)
 109 {
 110   return SHLWAPI_ChrCmpHelperA(ch1, ch2, 0);
 111 }
 112
 113 /*************************************************************************
 114  * ChrCmpIA     [SHLWAPI.385]
 115  *
 116  * Compare two characters, ignoring case.
 117  *
 118  * PARAMS
 119  *  ch1 [I] First character to compare
 120  *  ch2 [I] Second character to compare
 121  *
 122  * RETURNS
 123  *  FALSE, if the characters are equal.
 124  *  Non-zero otherwise.
 125  */
 126 BOOL WINAPI ChrCmpIA(WORD ch1, WORD ch2)
 127 {
 128   TRACE("(%d,%d)\n", ch1, ch2);
 129
 130   return SHLWAPI_ChrCmpHelperA(ch1, ch2, NORM_IGNORECASE);
 131 }
 132
 133 /*************************************************************************
 134  * SHLWAPI_ChrCmpW
 135  *
 136  * Internal helper function.
 137  */
 138 static BOOL WINAPI SHLWAPI_ChrCmpW(WCHAR ch1, WCHAR ch2)
 139 {
 140   return SHLWAPI_ChrCmpHelperW(ch1, ch2, 0);
 141 }
 142
 143 /*************************************************************************
 144  * ChrCmpIW     [SHLWAPI.386]
 145  *
 146  * See ChrCmpIA.
 147  */
 148 BOOL WINAPI ChrCmpIW(WCHAR ch1, WCHAR ch2)
 149 {
 150   return SHLWAPI_ChrCmpHelperW(ch1, ch2, NORM_IGNORECASE);
 151 }
 152
 153 /*************************************************************************
 154  * StrChrA      [SHLWAPI.@]
 155  *
 156  * Find a given character in a string.
 157  *
 158  * PARAMS
 159  *  lpszStr [I] String to search in.
 160  *  ch      [I] Character to search for.
 161  *
 162  * RETURNS
 163  *  Success: A pointer to the first occurrence of ch in lpszStr, or NULL if
 164  *           not found.
 165  *  Failure: NULL, if any arguments are invalid.
 166  */
 167 LPSTR WINAPI StrChrA(LPCSTR lpszStr, WORD ch)
 168 {
 169   TRACE("(%s,%i)\n", debugstr_a(lpszStr), ch);
 170
 171   if (lpszStr)
 172   {
 173     while (*lpszStr)
 174     {
 175       if (!SHLWAPI_ChrCmpA(*lpszStr, ch))
 176         return (LPSTR)lpszStr;
 177       lpszStr = CharNextA(lpszStr);
 178     }
 179   }
 180   return NULL;
 181 }
 182
 183 /*************************************************************************
 184  * StrChrW      [SHLWAPI.@]
 185  *
 186  * See StrChrA.
 187  */
 188 LPWSTR WINAPI StrChrW(LPCWSTR lpszStr, WCHAR ch)
 189 {
 190   LPWSTR lpszRet = NULL;
 191
 192   TRACE("(%s,%i)\n", debugstr_w(lpszStr), ch);
 193
 194   if (lpszStr)
 195     lpszRet = strchrW(lpszStr, ch);
 196   return lpszRet;
 197 }
 198
 199 /*************************************************************************
 200  * StrChrIA     [SHLWAPI.@]
 201  *
 202  * Find a given character in a string, ignoring case.
 203  *
 204  * PARAMS
 205  *  lpszStr [I] String to search in.
 206  *  ch      [I] Character to search for.
 207  *
 208  * RETURNS
 209  *  Success: A pointer to the first occurrence of ch in lpszStr, or NULL if
 210  *           not found.
 211  *  Failure: NULL, if any arguments are invalid.
 212  */
 213 LPSTR WINAPI StrChrIA(LPCSTR lpszStr, WORD ch)
 214 {
 215   TRACE("(%s,%i)\n", debugstr_a(lpszStr), ch);
 216
 217   if (lpszStr)
 218   {
 219     while (*lpszStr)
 220     {
 221       if (!ChrCmpIA(*lpszStr, ch))
 222         return (LPSTR)lpszStr;
 223       lpszStr = CharNextA(lpszStr);
 224     }
 225   }
 226   return NULL;
 227 }
 228
 229 /*************************************************************************
 230  * StrChrIW     [SHLWAPI.@]
 231  *
 232  * See StrChrA.
 233  */
 234 LPWSTR WINAPI StrChrIW(LPCWSTR lpszStr, WCHAR ch)
 235 {
 236   TRACE("(%s,%i)\n", debugstr_w(lpszStr), ch);
 237
 238   if (lpszStr)
 239   {
 240     ch = toupperW(ch);
 241     while (*lpszStr)
 242     {
 243       if (toupperW(*lpszStr) == ch)
 244         return (LPWSTR)lpszStr;
 245       lpszStr = CharNextW(lpszStr);
 246     }
 247     lpszStr = NULL;
 248   }
 249   return (LPWSTR)lpszStr;
 250 }
 251
 252 /*************************************************************************
 253  * StrCmpIW     [SHLWAPI.@]
 254  *
 255  * Compare two strings, ignoring case.
 256  *
 257  * PARAMS
 258  *  lpszStr  [I] First string to compare
 259  *  lpszComp [I] Second string to compare
 260  *
 261  * RETURNS
 262  *  An integer less than, equal to or greater than 0, indicating that
 263  *  lpszStr is less than, the same, or greater than lpszComp.
 264  */
 265 int WINAPI StrCmpIW(LPCWSTR lpszStr, LPCWSTR lpszComp)
 266 {
 267   INT iRet;
 268
 269   TRACE("(%s,%s)\n", debugstr_w(lpszStr),debugstr_w(lpszComp));
 270
 271   iRet = strcmpiW(lpszStr, lpszComp);
 272   return iRet < 0 ? -1 : iRet ? 1 : 0;
 273 }
 274
 275 /*************************************************************************
 276  * SHLWAPI_StrCmpNHelperA
 277  *
 278  * Internal helper for StrCmpNA/StrCmpNIA.
 279  */
 280 static INT WINAPI SHLWAPI_StrCmpNHelperA(LPCSTR lpszStr, LPCSTR lpszComp,
 281                                          INT iLen,
 282                                          BOOL (WINAPI *pChrCmpFn)(WORD,WORD))
 283 {
 284   if (!lpszStr)
 285   {
 286     if (!lpszComp)
 287       return 0;
 288     return 1;
 289   }
 290   else if (!lpszComp)
 291     return -1;
 292
 293   while (iLen-- > 0)
 294   {
 295     int iDiff;
 296     WORD ch1, ch2;
 297
 298     ch1 = IsDBCSLeadByte(*lpszStr)? *lpszStr << 8 | lpszStr[1] : *lpszStr;
 299     ch2 = IsDBCSLeadByte(*lpszComp)? *lpszComp << 8 | lpszComp[1] : *lpszComp;
 300
 301     if ((iDiff = pChrCmpFn(ch1, ch2)) < 0)
 302       return -1;
 303     else if (iDiff > 0)
 304       return 1;
 305     else if (!*lpszStr && !*lpszComp)
 306       return 0;
 307
 308     lpszStr = CharNextA(lpszStr);
 309     lpszComp = CharNextA(lpszComp);
 310   }
 311   return 0;
 312 }
 313
 314 /*************************************************************************
 315  * StrCmpNA     [SHLWAPI.@]
 316  *
 317  * Compare two strings, up to a maximum length.
 318  *
 319  * PARAMS
 320  *  lpszStr  [I] First string to compare
 321  *  lpszComp [I] Second string to compare
 322  *  iLen     [I] Maximum number of chars to compare.
 323  *
 324  * RETURNS
 325  *  An integer less than, equal to or greater than 0, indicating that
 326  *  lpszStr is less than, the same, or greater than lpszComp.
 327  */
 328 INT WINAPI StrCmpNA(LPCSTR lpszStr, LPCSTR lpszComp, INT iLen)
 329 {
 330   TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszComp), iLen);
 331
 332   return SHLWAPI_StrCmpNHelperA(lpszStr, lpszComp, iLen, SHLWAPI_ChrCmpA);
 333 }
 334
 335 /*************************************************************************
 336  * StrCmpNW     [SHLWAPI.@]
 337  *
 338  * See StrCmpNA.
 339  */
 340 INT WINAPI StrCmpNW(LPCWSTR lpszStr, LPCWSTR lpszComp, INT iLen)
 341 {
 342   INT iRet;
 343
 344   TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszComp), iLen);
 345
 346   iRet = strncmpW(lpszStr, lpszComp, iLen);
 347   return iRet < 0 ? -1 : iRet ? 1 : 0;
 348 }
 349
 350 /*************************************************************************
 351  * StrCmpNIA    [SHLWAPI.@]
 352  *
 353  * Compare two strings, up to a maximum length, ignoring case.
 354  *
 355  * PARAMS
 356  *  lpszStr  [I] First string to compare
 357  *  lpszComp [I] Second string to compare
 358  *  iLen     [I] Maximum number of chars to compare.
 359  *
 360  * RETURNS
 361  *  An integer less than, equal to or greater than 0, indicating that
 362  *  lpszStr is less than, the same, or greater than lpszComp.
 363  *
 364  * NOTES
 365  *  The Win32 version of this function is _completely_ broken for cases
 366  *  where iLen is greater than the length of lpszComp. Examples:
 367  *
 368  *  StrCmpNIA("foo.gif", "foo", 5) is -1 under Win32; Should return 1.
 369  *  StrCmpNIA("\", "\\", 3) is 0 under Win32; Should return -1.
 370  *  StrCmpNIA("\", "\..\foo\", 3) is 1 under Win32; Should return -1.
 371  *
 372  *  This implementation behaves correctly, since it is unlikely any
 373  *  applications actually rely on this function being broken.
 374  */
 375 int WINAPI StrCmpNIA(LPCSTR lpszStr, LPCSTR lpszComp, int iLen)
 376 {
 377   TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszComp), iLen);
 378
 379   return SHLWAPI_StrCmpNHelperA(lpszStr, lpszComp, iLen, ChrCmpIA);
 380 }
 381
 382 /*************************************************************************
 383  * StrCmpNIW    [SHLWAPI.@]
 384  *
 385  * See StrCmpNIA.
 386  */
 387 INT WINAPI StrCmpNIW(LPCWSTR lpszStr, LPCWSTR lpszComp, int iLen)
 388 {
 389   INT iRet;
 390
 391   TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszComp), iLen);
 392
 393   iRet = strncmpiW(lpszStr, lpszComp, iLen);
 394   return iRet < 0 ? -1 : iRet ? 1 : 0;
 395 }
 396
 397 /*************************************************************************
 398  * StrCmpW      [SHLWAPI.@]
 399  *
 400  * Compare two strings.
 401  *
 402  * PARAMS
 403  *  lpszStr  [I] First string to compare
 404  *  lpszComp [I] Second string to compare
 405  *
 406  * RETURNS
 407  *  An integer less than, equal to or greater than 0, indicating that
 408  *  lpszStr is less than, the same, or greater than lpszComp.
 409  */
 410 int WINAPI StrCmpW(LPCWSTR lpszStr, LPCWSTR lpszComp)
 411 {
 412   INT iRet;
 413
 414   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszComp));
 415
 416   iRet = strcmpW(lpszStr, lpszComp);
 417   return iRet < 0 ? -1 : iRet ? 1 : 0;
 418 }
 419
 420 /*************************************************************************
 421  * StrCatW      [SHLWAPI.@]
 422  *
 423  * Concatanate two strings.
 424  *
 425  * PARAMS
 426  *  lpszStr [O] Initial string
 427  *  lpszSrc [I] String to concatanate
 428  *
 429  * RETURNS
 430  *  lpszStr.
 431  */
 432 LPWSTR WINAPI StrCatW(LPWSTR lpszStr, LPCWSTR lpszSrc)
 433 {
 434   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSrc));
 435
 436   strcatW(lpszStr, lpszSrc);
 437   return lpszStr;
 438 }
 439
 440 /*************************************************************************
 441  * StrCpyW      [SHLWAPI.@]
 442  *
 443  * Copy a string to another string.
 444  *
 445  * PARAMS
 446  *  lpszStr [O] Destination string
 447  *  lpszSrc [I] Source string
 448  *
 449  * RETURNS
 450  *  lpszStr.
 451  */
 452 LPWSTR WINAPI StrCpyW(LPWSTR lpszStr, LPCWSTR lpszSrc)
 453 {
 454   TRACE("(%p,%s)\n", lpszStr, debugstr_w(lpszSrc));
 455
 456   strcpyW(lpszStr, lpszSrc);
 457   return lpszStr;
 458 }
 459
 460 /*************************************************************************
 461  * StrCpyNW     [SHLWAPI.@]
 462  *
 463  * Copy a string to another string, up to a maximum number of characters.
 464  *
 465  * PARAMS
 466  *  lpszStr  [O] Destination string
 467  *  lpszSrc  [I] Source string
 468  *  iLen     [I] Maximum number of chars to copy
 469  *
 470  * RETURNS
 471  *  lpszStr.
 472  */
 473 LPWSTR WINAPI StrCpyNW(LPWSTR lpszStr, LPCWSTR lpszSrc, int iLen)
 474 {
 475   TRACE("(%p,%s,%i)\n", lpszStr, debugstr_w(lpszSrc), iLen);
 476
 477   lstrcpynW(lpszStr, lpszSrc, iLen);
 478   return lpszStr;
 479 }
 480
 481
 482
 483 /*************************************************************************
 484  * SHLWAPI_StrStrHelperA
 485  *
 486  * Internal implementation of StrStrA/StrStrIA
 487  */
 488 static LPSTR WINAPI SHLWAPI_StrStrHelperA(LPCSTR lpszStr, LPCSTR lpszSearch,
 489                                          int (*pStrCmpFn)(LPCSTR,LPCSTR,size_t))
 490 {
 491   size_t iLen;
 492
 493   if (!lpszStr || !lpszSearch || !*lpszSearch)
 494     return NULL;
 495
 496   iLen = strlen(lpszSearch);
 497
 498   while (*lpszStr)
 499   {
 500     if (!pStrCmpFn(lpszStr, lpszSearch, iLen))
 501       return (LPSTR)lpszStr;
 502     lpszStr = CharNextA(lpszStr);
 503   }
 504   return NULL;
 505 }
 506
 507 /*************************************************************************
 508  * SHLWAPI_StrStrHelperW
 509  *
 510  * Internal implementation of StrStrW/StrStrIW
 511  */
 512 static LPWSTR WINAPI SHLWAPI_StrStrHelperW(LPCWSTR lpszStr, LPCWSTR lpszSearch,
 513                                           int (*pStrCmpFn)(LPCWSTR,LPCWSTR,int))
 514 {
 515   int iLen;
 516
 517   if (!lpszStr || !lpszSearch || !*lpszSearch)
 518     return NULL;
 519
 520   iLen = strlenW(lpszSearch);
 521
 522   while (*lpszStr)
 523   {
 524     if (!pStrCmpFn(lpszStr, lpszSearch, iLen))
 525       return (LPWSTR)lpszStr;
 526     lpszStr = CharNextW(lpszStr);
 527   }
 528   return NULL;
 529 }
 530
 531 /*************************************************************************
 532  * StrStrA      [SHLWAPI.@]
 533  *
 534  * Find a substring within a string.
 535  *
 536  * PARAMS
 537  *  lpszStr    [I] String to search in
 538  *  lpszSearch [I] String to look for
 539  *
 540  * RETURNS
 541  *  The start of lpszSearch within lpszStr, or NULL if not found.
 542  */
 543 LPSTR WINAPI StrStrA(LPCSTR lpszStr, LPCSTR lpszSearch)
 544 {
 545   TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
 546
 547   return SHLWAPI_StrStrHelperA(lpszStr, lpszSearch, strncmp);
 548 }
 549
 550 /*************************************************************************
 551  * StrStrW      [SHLWAPI.@]
 552  *
 553  * See StrStrA.
 554  */
 555 LPWSTR WINAPI StrStrW(LPCWSTR lpszStr, LPCWSTR lpszSearch)
 556 {
 557   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch));
 558
 559   return SHLWAPI_StrStrHelperW(lpszStr, lpszSearch, strncmpW);
 560 }
 561
 562 /*************************************************************************
 563  * StrRStrIA    [SHLWAPI.@]
 564  *
 565  * Find the last occurence of a substring within a string.
 566  *
 567  * PARAMS
 568  *  lpszStr    [I] String to search in
 569  *  lpszEnd    [I] End of lpszStr
 570  *  lpszSearch [I] String to look for
 571  *
 572  * RETURNS
 573  *  The last occurence lpszSearch within lpszStr, or NULL if not found.
 574  */
 575 LPSTR WINAPI StrRStrIA(LPCSTR lpszStr, LPCSTR lpszEnd, LPCSTR lpszSearch)
 576 {
 577   LPSTR lpszRet = NULL;
 578   WORD ch1, ch2;
 579   INT iLen;
 580
 581   TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
 582
 583   if (!lpszStr || !lpszSearch || !*lpszSearch)
 584     return NULL;
 585
 586   if (!lpszEnd)
 587     lpszEnd = lpszStr + lstrlenA(lpszStr);
 588
 589   if (IsDBCSLeadByte(*lpszSearch))
 590     ch1 = *lpszSearch << 8 | lpszSearch[1];
 591   else
 592     ch1 = *lpszSearch;
 593   iLen = lstrlenA(lpszSearch);
 594
 595   while (lpszStr <= lpszEnd  && *lpszStr)
 596   {
 597     ch2 = IsDBCSLeadByte(*lpszStr)? *lpszStr << 8 | lpszStr[1] : *lpszStr;
 598     if (!ChrCmpIA(ch1, ch2))
 599     {
 600       if (!StrCmpNIA(lpszStr, lpszSearch, iLen))
 601         lpszRet = (LPSTR)lpszStr;
 602     }
 603     lpszStr = CharNextA(lpszStr);
 604   }
 605   return lpszRet;
 606 }
 607
 608 /*************************************************************************
 609  * StrRStrIW    [SHLWAPI.@]
 610  *
 611  * See StrRStrIA.
 612  */
 613 LPWSTR WINAPI StrRStrIW(LPCWSTR lpszStr, LPCWSTR lpszEnd, LPCWSTR lpszSearch)
 614 {
 615   LPWSTR lpszRet = NULL;
 616   INT iLen;
 617
 618   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch));
 619
 620   if (!lpszStr || !lpszSearch || !*lpszSearch)
 621     return NULL;
 622
 623   if (!lpszEnd)
 624     lpszEnd = lpszStr + strlenW(lpszStr);
 625
 626   iLen = strlenW(lpszSearch);
 627
 628   while (lpszStr <= lpszEnd  && *lpszStr)
 629   {
 630     if (!ChrCmpIA(*lpszSearch, *lpszStr))
 631     {
 632       if (!StrCmpNIW(lpszStr, lpszSearch, iLen))
 633         lpszRet = (LPWSTR)lpszStr;
 634     }
 635     lpszStr = CharNextW(lpszStr);
 636   }
 637   return lpszRet;
 638 }
 639
 640 /*************************************************************************
 641  * StrStrIA     [SHLWAPI.@]
 642  *
 643  * Find a substring within a string, ignoring case.
 644  *
 645  * PARAMS
 646  *  lpszStr    [I] String to search in
 647  *  lpszSearch [I] String to look for
 648  *
 649  * RETURNS
 650  *  The start of lpszSearch within lpszStr, or NULL if not found.
 651  */
 652 LPSTR WINAPI StrStrIA(LPCSTR lpszStr, LPCSTR lpszSearch)
 653 {
 654   TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
 655
 656   return SHLWAPI_StrStrHelperA(lpszStr, lpszSearch, strncasecmp);
 657 }
 658
 659 /*************************************************************************
 660  * StrStrIW     [SHLWAPI.@]
 661  *
 662  * See StrStrIA.
 663  */
 664 LPWSTR WINAPI StrStrIW(LPCWSTR lpszStr, LPCWSTR lpszSearch)
 665 {
 666   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch));
 667
 668   return SHLWAPI_StrStrHelperW(lpszStr, lpszSearch, strncmpiW);
 669 }
 670
 671 /*************************************************************************
 672  * StrToIntA    [SHLWAPI.@]
 673  *
 674  * Read an integer from a string.
 675  *
 676  * PARAMS
 677  *  lpszStr [I] String to read integer from
 678  *
 679  * RETURNS
 680  *   The integer value represented by the string, or 0 if no integer is
 681  *   present.
 682  *
 683  * NOTES
 684  *  No leading space is allowed before the number, although a leading '-' is.
 685  */
 686 int WINAPI StrToIntA(LPCSTR lpszStr)
 687 {
 688   int iRet = 0;
 689
 690   TRACE("(%s)\n", debugstr_a(lpszStr));
 691
 692   if (!lpszStr)
 693   {
 694     WARN("Invalid lpszStr would crash under Win32!\n");
 695     return 0;
 696   }
 697
 698   if (*lpszStr == '-' || isdigit(*lpszStr))
 699     StrToIntExA(lpszStr, 0, &iRet);
 700   return iRet;
 701 }
 702
 703 /*************************************************************************
 704  * StrToIntW    [SHLWAPI.@]
 705  *
 706  * See StrToIntA.
 707  */
 708 int WINAPI StrToIntW(LPCWSTR lpszStr)
 709 {
 710   int iRet = 0;
 711
 712   TRACE("(%s)\n", debugstr_w(lpszStr));
 713
 714   if (!lpszStr)
 715   {
 716     WARN("Invalid lpszStr would crash under Win32!\n");
 717     return 0;
 718   }
 719
 720   if (*lpszStr == '-' || isdigitW(*lpszStr))
 721     StrToIntExW(lpszStr, 0, &iRet);
 722   return iRet;
 723 }
 724
 725 /*************************************************************************
 726  * StrToIntExA  [SHLWAPI.@]
 727  *
 728  * Read an integer from a string.
 729  *
 730  * PARAMS
 731  *  lpszStr [I] String to read integer from
 732  *  dwFlags [I] Flags controlling the conversion
 733  *  lpiRet  [O] Destination for read integer.
 734  *
 735  * RETURNS
 736  *  Success: TRUE. lpiRet contains the integer value represented by the string.
 737  *  Failure: FALSE, if the string is invalid, or no number is present.
 738  *
 739  * NOTES
 740  *  Leading whitespace, '-' and '+' are allowed before the number. If
 741  *  dwFlags includes STIF_SUPPORT_HEX, hexidecimal numbers are allowed, if
 742  *  preceeded by '0x'. If this flag is not set, or there is no '0x' prefix,
 743  *  the string is treated as a decimal string. A leading '-' is ignored for
 744  *  hexidecimal numbers.
 745  */
 746 BOOL WINAPI StrToIntExA(LPCSTR lpszStr, DWORD dwFlags, LPINT lpiRet)
 747 {
 748   BOOL bNegative = FALSE;
 749   int iRet = 0;
 750
 751   TRACE("(%s,%08lX,%p)\n", debugstr_a(lpszStr), dwFlags, lpiRet);
 752
 753   if (!lpszStr || !lpiRet)
 754   {
 755     WARN("Invalid parameter would crash under Win32!\n");
 756     return FALSE;
 757   }
 758   if (dwFlags > STIF_SUPPORT_HEX)
 759   {
 760     WARN("Unknown flags (%08lX)!\n", dwFlags & ~STIF_SUPPORT_HEX);
 761   }
 762
 763   /* Skip leading space, '+', '-' */
 764   while (isspace(*lpszStr))
 765     lpszStr = CharNextA(lpszStr);
 766
 767   if (*lpszStr == '-')
 768   {
 769     bNegative = TRUE;
 770     lpszStr++;
 771   }
 772   else if (*lpszStr == '+')
 773     lpszStr++;
 774
 775   if (dwFlags & STIF_SUPPORT_HEX &&
 776       *lpszStr == '0' && tolower(lpszStr[1]) == 'x')
 777   {
 778     /* Read hex number */
 779     lpszStr += 2;
 780
 781     if (!isxdigit(*lpszStr))
 782       return FALSE;
 783
 784     while (isxdigit(*lpszStr))
 785     {
 786       iRet = iRet * 16;
 787       if (isdigit(*lpszStr))
 788         iRet += (*lpszStr - '0');
 789       else
 790         iRet += 10 + (tolower(*lpszStr) - 'a');
 791       lpszStr++;
 792     }
 793     *lpiRet = iRet;
 794     return TRUE;
 795   }
 796
 797   /* Read decimal number */
 798   if (!isdigit(*lpszStr))
 799     return FALSE;
 800
 801   while (isdigit(*lpszStr))
 802   {
 803     iRet = iRet * 10;
 804     iRet += (*lpszStr - '0');
 805     lpszStr++;
 806   }
 807   *lpiRet = bNegative ? -iRet : iRet;
 808   return TRUE;
 809 }
 810
 811 /*************************************************************************
 812  * StrToIntExW  [SHLWAPI.@]
 813  *
 814  * See StrToIntExA.
 815  */
 816 BOOL WINAPI StrToIntExW(LPCWSTR lpszStr, DWORD dwFlags, LPINT lpiRet)
 817 {
 818   BOOL bNegative = FALSE;
 819   int iRet = 0;
 820
 821   TRACE("(%s,%08lX,%p)\n", debugstr_w(lpszStr), dwFlags, lpiRet);
 822
 823   if (!lpszStr || !lpiRet)
 824   {
 825     WARN("Invalid parameter would crash under Win32!\n");
 826     return FALSE;
 827   }
 828   if (dwFlags > STIF_SUPPORT_HEX)
 829   {
 830     WARN("Unknown flags (%08lX)!\n", dwFlags & ~STIF_SUPPORT_HEX);
 831   }
 832
 833   /* Skip leading space, '+', '-' */
 834   while (isspaceW(*lpszStr))
 835     lpszStr = CharNextW(lpszStr);
 836
 837   if (*lpszStr == '-')
 838   {
 839     bNegative = TRUE;
 840     lpszStr++;
 841   }
 842   else if (*lpszStr == '+')
 843     lpszStr++;
 844
 845   if (dwFlags & STIF_SUPPORT_HEX &&
 846       *lpszStr == '0' && tolowerW(lpszStr[1]) == 'x')
 847   {
 848     /* Read hex number */
 849     lpszStr += 2;
 850
 851     if (!isxdigitW(*lpszStr))
 852       return FALSE;
 853
 854     while (isxdigitW(*lpszStr))
 855     {
 856       iRet = iRet * 16;
 857       if (isdigitW(*lpszStr))
 858         iRet += (*lpszStr - '0');
 859       else
 860         iRet += 10 + (tolowerW(*lpszStr) - 'a');
 861       lpszStr++;
 862     }
 863     *lpiRet = iRet;
 864     return TRUE;
 865   }
 866
 867   /* Read decimal number */
 868   if (!isdigitW(*lpszStr))
 869     return FALSE;
 870
 871   while (isdigitW(*lpszStr))
 872   {
 873     iRet = iRet * 10;
 874     iRet += (*lpszStr - '0');
 875     lpszStr++;
 876   }
 877   *lpiRet = bNegative ? -iRet : iRet;
 878   return TRUE;
 879 }
 880
 881 /*************************************************************************
 882  * StrDupA      [SHLWAPI.@]
 883  *
 884  * Duplicate a string.
 885  *
 886  * PARAMS
 887  *  lpszStr [I] String to duplicate.
 888  *
 889  * RETURNS
 890  *  Success: A pointer to a new string containing the contents of lpszStr
 891  *  Failure: NULL, if memory cannot be allocated
 892  *
 893  * NOTES
 894  *  The string memory is allocated with LocalAlloc, and so should be released
 895  *  by calling LocalFree.
 896  */
 897 LPSTR WINAPI StrDupA(LPCSTR lpszStr)
 898 {
 899   int iLen;
 900   LPSTR lpszRet;
 901
 902   TRACE("(%s)\n",debugstr_a(lpszStr));
 903
 904   iLen = lpszStr ? strlen(lpszStr) + 1 : 1;
 905   lpszRet = (LPSTR)LocalAlloc(LMEM_FIXED, iLen);
 906
 907   if (lpszRet)
 908   {
 909     if (lpszStr)
 910       memcpy(lpszRet, lpszStr, iLen);
 911     else
 912       *lpszRet = '\0';
 913   }
 914   return lpszRet;
 915 }
 916
 917 /*************************************************************************
 918  * StrDupW      [SHLWAPI.@]
 919  *
 920  * See StrDupA.
 921  */
 922 LPWSTR WINAPI StrDupW(LPCWSTR lpszStr)
 923 {
 924   int iLen;
 925   LPWSTR lpszRet;
 926
 927   TRACE("(%s)\n",debugstr_w(lpszStr));
 928
 929   iLen = (lpszStr ? strlenW(lpszStr) + 1 : 1) * sizeof(WCHAR);
 930   lpszRet = (LPWSTR)LocalAlloc(LMEM_FIXED, iLen);
 931
 932   if (lpszRet)
 933   {
 934     if (lpszStr)
 935       memcpy(lpszRet, lpszStr, iLen);
 936     else
 937       *lpszRet = '\0';
 938   }
 939   return lpszRet;
 940 }
 941
 942 /*************************************************************************
 943  * SHLWAPI_StrSpnHelperA
 944  *
 945  * Internal implementation of StrSpnA/StrCSpnA/StrCSpnIA
 946  */
 947 static int WINAPI SHLWAPI_StrSpnHelperA(LPCSTR lpszStr, LPCSTR lpszMatch,
 948                                         LPSTR (WINAPI *pStrChrFn)(LPCSTR,WORD),
 949                                         BOOL bInvert)
 950 {
 951   LPCSTR lpszRead = lpszStr;
 952   if (lpszStr && *lpszStr && lpszMatch)
 953   {
 954     while (*lpszRead)
 955     {
 956       LPCSTR lpszTest = pStrChrFn(lpszMatch, *lpszRead);
 957
 958       if (!bInvert && !lpszTest)
 959         break;
 960       if (bInvert && lpszTest)
 961         break;
 962       lpszRead = CharNextA(lpszRead);
 963     };
 964   }
 965   return lpszRead - lpszStr;
 966 }
 967
 968 /*************************************************************************
 969  * SHLWAPI_StrSpnHelperW
 970  *
 971  * Internal implementation of StrSpnW/StrCSpnW/StrCSpnIW
 972  */
 973 static int WINAPI SHLWAPI_StrSpnHelperW(LPCWSTR lpszStr, LPCWSTR lpszMatch,
 974                                       LPWSTR (WINAPI *pStrChrFn)(LPCWSTR,WCHAR),
 975                                       BOOL bInvert)
 976 {
 977   LPCWSTR lpszRead = lpszStr;
 978   if (lpszStr && *lpszStr && lpszMatch)
 979   {
 980     while (*lpszRead)
 981     {
 982       LPCWSTR lpszTest = pStrChrFn(lpszMatch, *lpszRead);
 983
 984       if (!bInvert && !lpszTest)
 985         break;
 986       if (bInvert && lpszTest)
 987         break;
 988       lpszRead = CharNextW(lpszRead);
 989     };
 990   }
 991   return lpszRead - lpszStr;
 992 }
 993
 994 /*************************************************************************
 995  * StrSpnA      [SHLWAPI.@]
 996  *
 997  * Find the length of the start of a string that contains only certain
 998  * characters.
 999  *
1000  * PARAMS
1001  *  lpszStr   [I] String to search
1002  *  lpszMatch [I] Characters that can be in the substring
1003  *
1004  * RETURNS
1005  *  The length of the part of lpszStr containing only chars from lpszMatch,
1006  *  or 0 if any parameter is invalid.
1007  */
1008 int WINAPI StrSpnA(LPCSTR lpszStr, LPCSTR lpszMatch)
1009 {
1010   TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
1011
1012   return SHLWAPI_StrSpnHelperA(lpszStr, lpszMatch, StrChrA, FALSE);
1013 }
1014
1015 /*************************************************************************
1016  * StrSpnW      [SHLWAPI.@]
1017  *
1018  * See StrSpnA.
1019  */
1020 int WINAPI StrSpnW(LPCWSTR lpszStr, LPCWSTR lpszMatch)
1021 {
1022   TRACE("(%s,%s)\n",debugstr_w(lpszStr), debugstr_w(lpszMatch));
1023
1024   return SHLWAPI_StrSpnHelperW(lpszStr, lpszMatch, StrChrW, FALSE);
1025 }
1026
1027 /*************************************************************************
1028  * StrCSpnA     [SHLWAPI.@]
1029  *
1030  * Find the length of the start of a string that does not contain certain
1031  * characters.
1032  *
1033  * PARAMS
1034  *  lpszStr   [I] String to search
1035  *  lpszMatch [I] Characters that cannot be in the substring
1036  *
1037  * RETURNS
1038  *  The length of the part of lpszStr containing only chars not in lpszMatch,
1039  *  or 0 if any parameter is invalid.
1040  */
1041 int WINAPI StrCSpnA(LPCSTR lpszStr, LPCSTR lpszMatch)
1042 {
1043   TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
1044
1045   return SHLWAPI_StrSpnHelperA(lpszStr, lpszMatch, StrChrA, TRUE);
1046 }
1047
1048 /*************************************************************************
1049  * StrCSpnW     [SHLWAPI.@]
1050  *
1051  * See StrCSpnA.
1052  */
1053 int WINAPI StrCSpnW(LPCWSTR lpszStr, LPCWSTR lpszMatch)
1054 {
1055   TRACE("(%s,%s)\n",debugstr_w(lpszStr), debugstr_w(lpszMatch));
1056
1057   return SHLWAPI_StrSpnHelperW(lpszStr, lpszMatch, StrChrW, TRUE);
1058 }
1059
1060 /*************************************************************************
1061  * StrCSpnIA    [SHLWAPI.@]
1062  *
1063  * Find the length of the start of a string that does not contain certain
1064  * characters, ignoring case.
1065  *
1066  * PARAMS
1067  *  lpszStr   [I] String to search
1068  *  lpszMatch [I] Characters that cannot be in the substring
1069  *
1070  * RETURNS
1071  *  The length of the part of lpszStr containing only chars not in lpszMatch,
1072  *  or 0 if any parameter is invalid.
1073  */
1074 int WINAPI StrCSpnIA(LPCSTR lpszStr, LPCSTR lpszMatch)
1075 {
1076   TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
1077
1078   return SHLWAPI_StrSpnHelperA(lpszStr, lpszMatch, StrChrIA, TRUE);
1079 }
1080
1081 /*************************************************************************
1082  * StrCSpnIW    [SHLWAPI.@]
1083  *
1084  * See StrCSpnIA.
1085  */
1086 int WINAPI StrCSpnIW(LPCWSTR lpszStr, LPCWSTR lpszMatch)
1087 {
1088   TRACE("(%s,%s)\n",debugstr_w(lpszStr), debugstr_w(lpszMatch));
1089
1090   return SHLWAPI_StrSpnHelperW(lpszStr, lpszMatch, StrChrIW, TRUE);
1091 }
1092
1093 /*************************************************************************
1094  * StrPBrkA     [SHLWAPI.@]
1095  *
1096  * Search a string for any of a group of characters.
1097  *
1098  * PARAMS
1099  *  lpszStr   [I] String to search
1100  *  lpszMatch [I] Characters to match
1101  *
1102  * RETURNS
1103  *  A pointer to the first matching character in lpszStr, or NULL if no
1104  *  match was found.
1105  */
1106 LPSTR WINAPI StrPBrkA(LPCSTR lpszStr, LPCSTR lpszMatch)
1107 {
1108   TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
1109
1110   if (lpszStr && lpszMatch && *lpszMatch)
1111   {
1112     while (*lpszStr)
1113     {
1114       if (StrChrA(lpszMatch, *lpszStr))
1115         return (LPSTR)lpszStr;
1116       lpszStr = CharNextA(lpszStr);
1117     };
1118   }
1119   return NULL;
1120 }
1121
1122 /*************************************************************************
1123  * StrPBrkW     [SHLWAPI.@]
1124  *
1125  * See StrPBrkA.
1126  */
1127 LPWSTR WINAPI StrPBrkW(LPCWSTR lpszStr, LPCWSTR lpszMatch)
1128 {
1129   TRACE("(%s,%s)\n",debugstr_w(lpszStr), debugstr_w(lpszMatch));
1130
1131   if (lpszStr && lpszMatch && *lpszMatch)
1132   {
1133     while (*lpszStr);
1134     {
1135       if (StrChrW(lpszMatch, *lpszStr))
1136         return (LPWSTR)lpszStr;
1137       lpszStr = CharNextW(lpszStr);
1138     } while (*lpszStr);
1139   }
1140   return NULL;
1141 }
1142
1143 /*************************************************************************
1144  * SHLWAPI_StrRChrHelperA
1145  *
1146  * Internal implementation of StrRChrA/StrRChrIA.
1147  */
1148 static LPSTR WINAPI SHLWAPI_StrRChrHelperA(LPCSTR lpszStr,
1149                                            LPCSTR lpszEnd, WORD ch,
1150                                            BOOL (WINAPI *pChrCmpFn)(WORD,WORD))
1151 {
1152   LPCSTR lpszRet = NULL;
1153
1154   if (lpszStr)
1155   {
1156     WORD ch2;
1157
1158     if (!lpszEnd)
1159       lpszEnd = lpszStr + lstrlenA(lpszStr);
1160
1161     while (*lpszStr && lpszStr <= lpszEnd)
1162     {
1163       ch2 = IsDBCSLeadByte(*lpszStr)? *lpszStr << 8 | lpszStr[1] : *lpszStr;
1164
1165       if (!pChrCmpFn(ch, ch2))
1166         lpszRet = lpszStr;
1167       lpszStr = CharNextA(lpszStr);
1168     }
1169   }
1170   return (LPSTR)lpszRet;
1171 }
1172
1173 /*************************************************************************
1174  * SHLWAPI_StrRChrHelperW
1175  *
1176  * Internal implementation of StrRChrW/StrRChrIW.
1177  */
1178 static LPWSTR WINAPI SHLWAPI_StrRChrHelperW(LPCWSTR lpszStr,
1179                                          LPCWSTR lpszEnd, WCHAR ch,
1180                                          BOOL (WINAPI *pChrCmpFn)(WCHAR,WCHAR))
1181 {
1182   LPCWSTR lpszRet = NULL;
1183
1184   if (lpszStr)
1185   {
1186     if (!lpszEnd)
1187       lpszEnd = lpszStr + strlenW(lpszStr);
1188
1189     while (*lpszStr && lpszStr <= lpszEnd)
1190     {
1191       if (!pChrCmpFn(ch, *lpszStr))
1192         lpszRet = lpszStr;
1193       lpszStr = CharNextW(lpszStr);
1194     }
1195   }
1196   return (LPWSTR)lpszRet;
1197 }
1198
1199 /**************************************************************************
1200  * StrRChrA     [SHLWAPI.@]
1201  *
1202  * Find the last occurence of a character in string.
1203  *
1204  * PARAMS
1205  *  lpszStr [I] String to search in
1206  *  lpszEnd [I] Place to end search, or NULL to search until the end of lpszStr
1207  *  ch      [I] Character to search for.
1208  *
1209  * RETURNS
1210  *  Success: A pointer to the last occurrence of ch in lpszStr before lpszEnd,
1211  *           or NULL if not found.
1212  *  Failure: NULL, if any arguments are invalid.
1213  */
1214 LPSTR WINAPI StrRChrA(LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch)
1215 {
1216   TRACE("(%s,%s,%x)\n", debugstr_a(lpszStr), debugstr_a(lpszEnd), ch);
1217
1218   return SHLWAPI_StrRChrHelperA(lpszStr, lpszEnd, ch, SHLWAPI_ChrCmpA);
1219 }
1220
1221 /**************************************************************************
1222  * StrRChrW     [SHLWAPI.@]
1223  *
1224  * See StrRChrA.
1225  */
1226 LPWSTR WINAPI StrRChrW(LPCWSTR lpszStr, LPCWSTR lpszEnd, WORD ch)
1227 {
1228   TRACE("(%s,%s,%x)\n", debugstr_w(lpszStr), debugstr_w(lpszEnd), ch);
1229
1230   return SHLWAPI_StrRChrHelperW(lpszStr, lpszEnd, ch, SHLWAPI_ChrCmpW);
1231 }
1232
1233 /**************************************************************************
1234  * StrRChrIA    [SHLWAPI.@]
1235  *
1236  * Find the last occurence of a character in string, ignoring case.
1237  *
1238  * PARAMS
1239  *  lpszStr [I] String to search in
1240  *  lpszEnd [I] Place to end search, or NULL to search until the end of lpszStr
1241  *  ch      [I] Character to search for.
1242  *
1243  * RETURNS
1244  *  Success: A pointer to the last occurrence of ch in lpszStr before lpszEnd,
1245  *           or NULL if not found.
1246  *  Failure: NULL, if any arguments are invalid.
1247  */
1248 LPSTR WINAPI StrRChrIA(LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch)
1249 {
1250   TRACE("(%s,%s,%x)\n", debugstr_a(lpszStr), debugstr_a(lpszEnd), ch);
1251
1252   return SHLWAPI_StrRChrHelperA(lpszStr, lpszEnd, ch, ChrCmpIA);
1253 }
1254
1255 /**************************************************************************
1256  * StrRChrIW    [SHLWAPI.@]
1257  *
1258  * See StrRChrIA.
1259  */
1260 LPWSTR WINAPI StrRChrIW(LPCWSTR lpszStr, LPCWSTR lpszEnd, WORD ch)
1261 {
1262   TRACE("(%s,%s,%x)\n", debugstr_w(lpszStr), debugstr_w(lpszEnd), ch);
1263
1264   return SHLWAPI_StrRChrHelperW(lpszStr, lpszEnd, ch, ChrCmpIW);
1265 }
1266
1267 /*************************************************************************
1268  * StrCatBuffA  [SHLWAPI.@]
1269  *
1270  * Concatenate two strings together.
1271  *
1272  * PARAMS
1273  *  lpszStr [O] String to concatenate to
1274  *  lpszCat [I] String to add to lpszCat
1275  *  cchMax  [I] Maximum number of characters for the whole string
1276  *
1277  * RETURNS
1278  *  lpszStr.
1279  *
1280  * NOTES
1281  *  cchMax dtermines the number of characters in the final length of the
1282  *  string, not the number appended to lpszStr from lpszCat.
1283  */
1284 LPSTR WINAPI StrCatBuffA(LPSTR lpszStr, LPCSTR lpszCat, INT cchMax)
1285 {
1286   INT iLen;
1287
1288   TRACE("(%p,%s,%d)\n", lpszStr, debugstr_a(lpszCat), cchMax);
1289
1290   if (!lpszStr)
1291   {
1292     WARN("Invalid lpszStr would crash under Win32!\n");
1293     return NULL;
1294   }
1295
1296   iLen = strlen(lpszStr);
1297   cchMax -= iLen;
1298
1299   if (cchMax > 0)
1300     StrCpyNA(lpszStr + iLen, lpszCat, cchMax);
1301   return lpszStr;
1302 }
1303
1304 /*************************************************************************
1305  * StrCatBuffW  [SHLWAPI.@]
1306  *
1307  * See StrCatBuffA.
1308  */
1309 LPWSTR WINAPI StrCatBuffW(LPWSTR lpszStr, LPCWSTR lpszCat, INT cchMax)
1310 {
1311   INT iLen;
1312
1313   TRACE("(%p,%s,%d)\n", lpszStr, debugstr_w(lpszCat), cchMax);
1314
1315   if (!lpszStr)
1316   {
1317     WARN("Invalid lpszStr would crash under Win32!\n");
1318     return NULL;
1319   }
1320
1321   iLen = strlenW(lpszStr);
1322   cchMax -= iLen;
1323
1324   if (cchMax > 0)
1325     StrCpyNW(lpszStr + iLen, lpszCat, cchMax);
1326   return lpszStr;
1327 }
1328
1329 /*************************************************************************
1330  * StrRetToBufA                                 [SHLWAPI.@]
1331  *
1332  * Convert a STRRET to a normal string.
1333  *
1334  * PARAMS
1335  *  lpStrRet [O] STRRET to convert
1336  *  pIdl     [I] ITEMIDLIST for lpStrRet->uType = STRRET_OFFSETA
1337  *  lpszDest [O] Destination for normal string
1338  *  dwLen    [I] Length of lpszDest
1339  *
1340  * RETURNS
1341  *  Success: S_OK. lpszDest contains up to dwLen characters of the string.
1342  *           If lpStrRet is of type STRRET_WSTR, its memory is freed with
1343  *           CoTaskMemFree and its type set to STRRET_CSTRA.
1344  *  Failure: E_FAIL, if any parameters are invalid.
1345  */
1346 HRESULT WINAPI StrRetToBufA (LPSTRRET src, const ITEMIDLIST *pidl, LPSTR dest, DWORD len)
1347 {
1348         /* NOTE:
1349          *  This routine is identical to that in dlls/shell32/shellstring.c.
1350          *  It was duplicated because not every version of Shlwapi.dll exports
1351          *  StrRetToBufA. If you change one routine, change them both.
1352          */
1353         TRACE("dest=%p len=0x%lx strret=%p pidl=%p stub\n",dest,len,src,pidl);
1354
1355         if (!src)
1356         {
1357           WARN("Invalid lpStrRet would crash under Win32!\n");
1358           if (dest)
1359             *dest = '\0';
1360           return E_FAIL;
1361         }
1362
1363         if (!dest || !len)
1364           return E_FAIL;
1365
1366         *dest = '\0';
1367
1368         switch (src->uType)
1369         {
1370           case STRRET_WSTR:
1371             WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, dest, len, NULL, NULL);
1372             CoTaskMemFree(src->u.pOleStr);
1373             break;
1374
1375           case STRRET_CSTR:
1376             lstrcpynA((LPSTR)dest, src->u.cStr, len);
1377             break;
1378
1379           case STRRET_OFFSET:
1380             lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
1381             break;
1382
1383           default:
1384             FIXME("unknown type!\n");
1385             return FALSE;
1386         }
1387         return S_OK;
1388 }
1389
1390 /*************************************************************************
1391  * StrRetToBufW [SHLWAPI.@]
1392  *
1393  * See StrRetToBufA.
1394  */
1395 HRESULT WINAPI StrRetToBufW (LPSTRRET src, const ITEMIDLIST *pidl, LPWSTR dest, DWORD len)
1396 {
1397         TRACE("dest=%p len=0x%lx strret=%p pidl=%p stub\n",dest,len,src,pidl);
1398
1399         if (!src)
1400         {
1401           WARN("Invalid lpStrRet would crash under Win32!\n");
1402           if (dest)
1403             *dest = '\0';
1404           return E_FAIL;
1405         }
1406
1407         if (!dest || !len)
1408           return E_FAIL;
1409
1410         *dest = '\0';
1411
1412         switch (src->uType)
1413         {
1414           case STRRET_WSTR:
1415             lstrcpynW((LPWSTR)dest, src->u.pOleStr, len);
1416             CoTaskMemFree(src->u.pOleStr);
1417             break;
1418
1419           case STRRET_CSTR:
1420               if (!MultiByteToWideChar( CP_ACP, 0, src->u.cStr, -1, dest, len ) && len)
1421                   dest[len-1] = 0;
1422             break;
1423
1424           case STRRET_OFFSET:
1425             if (pidl)
1426             {
1427               if (!MultiByteToWideChar( CP_ACP, 0, ((LPCSTR)&pidl->mkid)+src->u.uOffset, -1,
1428                                         dest, len ) && len)
1429                   dest[len-1] = 0;
1430             }
1431             break;
1432
1433           default:
1434             FIXME("unknown type!\n");
1435             return FALSE;
1436         }
1437         return S_OK;
1438 }
1439
1440 /*************************************************************************
1441  * StrRetToStrA                                 [SHLWAPI.@]
1442  *
1443  * converts a STRRET to a normal string
1444  */
1445 HRESULT WINAPI StrRetToStrA(LPSTRRET pstr, const ITEMIDLIST * pidl, LPSTR* ppszName)
1446 {
1447         HRESULT ret = E_FAIL;
1448
1449         switch (pstr->uType) {
1450             case STRRET_WSTR:
1451                 ret = _SHStrDupAW(pstr->u.pOleStr, ppszName);
1452                 CoTaskMemFree(pstr->u.pOleStr);
1453                 break;
1454
1455             case STRRET_CSTR:
1456                 ret = _SHStrDupAA(pstr->u.cStr, ppszName);
1457                 break;
1458
1459             case STRRET_OFFSET:
1460                 ret = _SHStrDupAA(((LPCSTR)&pidl->mkid)+pstr->u.uOffset, ppszName);
1461                 break;
1462
1463             default:
1464                 *ppszName = NULL;
1465         }
1466         return ret;
1467 }
1468
1469 /*************************************************************************
1470  * StrRetToStrW                                 [SHLWAPI.@]
1471  *
1472  * converts a STRRET to a normal string
1473  */
1474 HRESULT WINAPI StrRetToStrW(LPSTRRET pstr, const ITEMIDLIST * pidl, LPWSTR* ppszName)
1475 {
1476         HRESULT ret = E_FAIL;
1477
1478         switch (pstr->uType) {
1479             case STRRET_WSTR:
1480                 ret = SHStrDupW(pstr->u.pOleStr, ppszName);
1481                 CoTaskMemFree(pstr->u.pOleStr);
1482                 break;
1483
1484             case STRRET_CSTR:
1485                 ret = SHStrDupA(pstr->u.cStr, ppszName);
1486                 break;
1487
1488             case STRRET_OFFSET:
1489                 ret = SHStrDupA(((LPCSTR)&pidl->mkid)+pstr->u.uOffset, ppszName);
1490                 break;
1491
1492             default:
1493                 *ppszName = NULL;
1494         }
1495         return ret;
1496 }
1497
1498 /*************************************************************************
1499  * StrFormatKBSizeA     [SHLWAPI.@]
1500  *
1501  * Create a formatted string containing a byte count in Kilobytes.
1502  *
1503  * PARAMS
1504  *  llBytes  [I] Byte size to format
1505  *  lpszDest [I] Destination for formatted string
1506  *  cchMax   [I] Size of lpszDest
1507  *
1508  * RETURNS
1509  *  lpszDest.
1510  */
1511 LPSTR WINAPI StrFormatKBSizeA(LONGLONG llBytes, LPSTR lpszDest, UINT cchMax)
1512 {
1513   char szBuff[256], *szOut = szBuff + sizeof(szBuff) - 1;
1514   LONGLONG ulKB = (llBytes + 1023) >> 10;
1515
1516   TRACE("(%lld,%p,%d)\n", llBytes, lpszDest, cchMax);
1517
1518   *szOut-- = '\0';
1519   *szOut-- = 'B';
1520   *szOut-- = 'K';
1521   *szOut-- = ' ';
1522
1523   do
1524   {
1525     LONGLONG ulNextDigit = ulKB % 10;
1526     *szOut-- = '0' + ulNextDigit;
1527     ulKB = (ulKB - ulNextDigit) / 10;
1528   } while (ulKB > 0);
1529
1530   strncpy(lpszDest, szOut + 1, cchMax);
1531   return lpszDest;
1532 }
1533
1534 /*************************************************************************
1535  * StrFormatKBSizeW     [SHLWAPI.@]
1536  *
1537  * See StrFormatKBSizeA.
1538  */
1539 LPWSTR WINAPI StrFormatKBSizeW(LONGLONG llBytes, LPWSTR lpszDest, UINT cchMax)
1540 {
1541   WCHAR szBuff[256], *szOut = szBuff + sizeof(szBuff) - 1;
1542   LONGLONG ulKB = (llBytes + 1023) >> 10;
1543
1544   TRACE("(%lld,%p,%d)\n", llBytes, lpszDest, cchMax);
1545
1546   *szOut-- = '\0';
1547   *szOut-- = 'B';
1548   *szOut-- = 'K';
1549   *szOut-- = ' ';
1550
1551   do
1552   {
1553     LONGLONG ulNextDigit = ulKB % 10;
1554     *szOut-- = '0' + ulNextDigit;
1555     ulKB = (ulKB - ulNextDigit) / 10;
1556   } while (ulKB > 0);
1557
1558   strncpyW(lpszDest, szOut + 1, cchMax);
1559   return lpszDest;
1560 }
1561
1562 /*************************************************************************
1563  * StrNCatA     [SHLWAPI.@]
1564  *
1565  * Concatenate two strings together.
1566  *
1567  * PARAMS
1568  *  lpszStr [O] String to concatenate to
1569  *  lpszCat [I] String to add to lpszCat
1570  *  cchMax  [I] Maximum number of characters to concatenate
1571  *
1572  * RETURNS
1573  *  lpszStr.
1574  *
1575  * NOTES
1576  *  cchMax dtermines the number of characters that are appended to lpszStr,
1577  *  not the total length of the string.
1578  */
1579 LPSTR WINAPI StrNCatA(LPSTR lpszStr, LPCSTR lpszCat, INT cchMax)
1580 {
1581   LPSTR lpszRet = lpszStr;
1582
1583   TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszCat), cchMax);
1584
1585   if (!lpszStr)
1586   {
1587     WARN("Invalid lpszStr would crash under Win32!\n");
1588     return NULL;
1589   }
1590
1591   StrCpyNA(lpszStr + strlen(lpszStr), lpszCat, cchMax);
1592   return lpszRet;
1593 }
1594
1595 /*************************************************************************
1596  * StrNCatW     [SHLWAPI.@]
1597  *
1598  * See StrNCatA.
1599  */
1600 LPWSTR WINAPI StrNCatW(LPWSTR lpszStr, LPCWSTR lpszCat, INT cchMax)
1601 {
1602   LPWSTR lpszRet = lpszStr;
1603
1604   TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszCat), cchMax);
1605
1606   if (!lpszStr)
1607   {
1608     WARN("Invalid lpszStr would crash under Win32\n");
1609     return NULL;
1610   }
1611
1612   StrCpyNW(lpszStr + strlenW(lpszStr), lpszCat, cchMax);
1613   return lpszRet;
1614 }
1615
1616 /*************************************************************************
1617  * StrTrimA     [SHLWAPI.@]
1618  *
1619  * Remove characters from the start and end of a string.
1620  *
1621  * PARAMS
1622  *  lpszStr  [O] String to remove characters from
1623  *  lpszTrim [I] Characters to remove from lpszStr
1624  *
1625  * RETURNS
1626  *  TRUE  If lpszStr was valid and modified
1627  *  FALSE Otherwise
1628  */
1629 BOOL WINAPI StrTrimA(LPSTR lpszStr, LPCSTR lpszTrim)
1630 {
1631   DWORD dwLen;
1632   LPSTR lpszRead = lpszStr;
1633   BOOL bRet = FALSE;
1634
1635   TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszTrim));
1636
1637   if (lpszRead && *lpszRead)
1638   {
1639     while (*lpszRead && StrChrA(lpszTrim, *lpszRead))
1640       lpszRead = CharNextA(lpszRead); /* Skip leading matches */
1641
1642     dwLen = strlen(lpszRead);
1643
1644     if (lpszRead != lpszStr)
1645     {
1646       memmove(lpszStr, lpszRead, dwLen + 1);
1647       bRet = TRUE;
1648     }
1649     if (dwLen > 0)
1650     {
1651       lpszRead = lpszStr + dwLen;
1652       while (StrChrA(lpszTrim, lpszRead[-1]))
1653         lpszRead = CharPrevA(lpszStr, lpszRead); /* Skip trailing matches */
1654
1655       if (lpszRead != lpszStr + dwLen)
1656       {
1657         *lpszRead = '\0';
1658         bRet = TRUE;
1659       }
1660     }
1661   }
1662   return bRet;
1663 }
1664
1665 /*************************************************************************
1666  * StrTrimW     [SHLWAPI.@]
1667  *
1668  * See StrTrimA.
1669  */
1670 BOOL WINAPI StrTrimW(LPWSTR lpszStr, LPCWSTR lpszTrim)
1671 {
1672   DWORD dwLen;
1673   LPWSTR lpszRead = lpszStr;
1674   BOOL bRet = FALSE;
1675
1676   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszTrim));
1677
1678   if (lpszRead && *lpszRead)
1679   {
1680     while (*lpszRead && StrChrW(lpszTrim, *lpszRead))
1681       lpszRead = CharNextW(lpszRead); /* Skip leading matches */
1682
1683     dwLen = strlenW(lpszRead);
1684
1685     if (lpszRead != lpszStr)
1686     {
1687       memmove(lpszStr, lpszRead, (dwLen + 1) * sizeof(WCHAR));
1688       bRet = TRUE;
1689     }
1690     if (dwLen > 0)
1691     {
1692       lpszRead = lpszStr + dwLen;
1693       while (StrChrW(lpszTrim, lpszRead[-1]))
1694         lpszRead = CharPrevW(lpszStr, lpszRead); /* Skip trailing matches */
1695
1696       if (lpszRead != lpszStr + dwLen)
1697       {
1698         *lpszRead = '\0';
1699         bRet = TRUE;
1700       }
1701     }
1702   }
1703   return bRet;
1704 }
1705
1706 /*************************************************************************
1707  *      _SHStrDupA      [INTERNAL]
1708  *
1709  * Duplicates a ASCII string to ASCII. The destination buffer is allocated.
1710  */
1711 static HRESULT WINAPI _SHStrDupAA(LPCSTR src, LPSTR * dest)
1712 {
1713         HRESULT hr;
1714         int len = 0;
1715
1716         if (src) {
1717             len = lstrlenA(src);
1718             *dest = CoTaskMemAlloc(len);
1719         } else {
1720             *dest = NULL;
1721         }
1722
1723         if (*dest) {
1724             lstrcpynA(*dest,src, len);
1725             hr = S_OK;
1726         } else {
1727             hr = E_OUTOFMEMORY;
1728         }
1729
1730         TRACE("%s->(%p)\n", debugstr_a(src), *dest);
1731         return hr;
1732 }
1733
1734 /*************************************************************************
1735  * SHStrDupA
1736  *
1737  * Return a Unicode copy of a string, in memory allocated by CoTaskMemAlloc.
1738  *
1739  * PARAMS
1740  *  lpszStr   [I] String to copy
1741  *  lppszDest [O] Destination for the new string copy
1742  *
1743  * RETURNS
1744  *  Success: S_OK. lppszDest contains the new string in Unicode format.
1745  *  Failure: E_OUTOFMEMORY, If any arguments are invalid or memory allocation
1746  *           fails.
1747  */
1748 HRESULT WINAPI SHStrDupA(LPCSTR src, LPWSTR * dest)
1749 {
1750         HRESULT hr;
1751         int len = 0;
1752
1753         if (src) {
1754             len = (MultiByteToWideChar(0,0,src,-1,0,0) + 1)* sizeof(WCHAR);
1755             *dest = CoTaskMemAlloc(len);
1756         } else {
1757             *dest = NULL;
1758         }
1759
1760         if (*dest) {
1761             MultiByteToWideChar(0,0,src,-1,*dest,len);
1762             hr = S_OK;
1763         } else {
1764             hr = E_OUTOFMEMORY;
1765         }
1766
1767         TRACE("%s->(%p)\n", debugstr_a(src), *dest);
1768         return hr;
1769 }
1770
1771 /*************************************************************************
1772  *      _SHStrDupAW     [INTERNAL]
1773  *
1774  * Duplicates a UNICODE to a ASCII string. The destination buffer is allocated.
1775  */
1776 static HRESULT WINAPI _SHStrDupAW(LPCWSTR src, LPSTR * dest)
1777 {
1778         HRESULT hr;
1779         int len = 0;
1780
1781         if (src) {
1782             len = WideCharToMultiByte(CP_ACP, 0, src, -1, NULL, 0, NULL, NULL);
1783             *dest = CoTaskMemAlloc(len);
1784         } else {
1785             *dest = NULL;
1786         }
1787
1788         if (*dest) {
1789             WideCharToMultiByte(CP_ACP, 0, src, -1, *dest, len, NULL, NULL);
1790             hr = S_OK;
1791         } else {
1792             hr = E_OUTOFMEMORY;
1793         }
1794
1795         TRACE("%s->(%p)\n", debugstr_w(src), *dest);
1796         return hr;
1797 }
1798
1799 /*************************************************************************
1800  * SHStrDupW
1801  *
1802  * See SHStrDupA.
1803  */
1804 HRESULT WINAPI SHStrDupW(LPCWSTR src, LPWSTR * dest)
1805 {
1806         HRESULT hr;
1807         int len = 0;
1808
1809         if (src) {
1810             len = (lstrlenW(src) + 1) * sizeof(WCHAR);
1811             *dest = CoTaskMemAlloc(len);
1812         } else {
1813             *dest = NULL;
1814         }
1815
1816         if (*dest) {
1817             memcpy(*dest, src, len);
1818             hr = S_OK;
1819         } else {
1820             hr = E_OUTOFMEMORY;
1821         }
1822
1823         TRACE("%s->(%p)\n", debugstr_w(src), *dest);
1824         return hr;
1825 }
1826
1827 /*************************************************************************
1828  * SHLWAPI_WriteReverseNum
1829  *
1830  * Internal helper for SHLWAPI_WriteTimeClass.
1831  */
1832 inline static LPWSTR SHLWAPI_WriteReverseNum(LPWSTR lpszOut, DWORD dwNum)
1833 {
1834   *lpszOut-- = '\0';
1835
1836   /* Write a decimal number to a string, backwards */
1837   do
1838   {
1839     DWORD dwNextDigit = dwNum % 10;
1840     *lpszOut-- = '0' + dwNextDigit;
1841     dwNum = (dwNum - dwNextDigit) / 10;
1842   } while (dwNum > 0);
1843
1844   return lpszOut;
1845 }
1846
1847 /*************************************************************************
1848  * SHLWAPI_FormatSignificant
1849  *
1850  * Internal helper for SHLWAPI_WriteTimeClass.
1851  */
1852 inline static int SHLWAPI_FormatSignificant(LPWSTR lpszNum, int dwDigits)
1853 {
1854   /* Zero non significant digits, return remaining significant digits */
1855   while (*lpszNum)
1856   {
1857     lpszNum++;
1858     if (--dwDigits == 0)
1859     {
1860       while (*lpszNum)
1861         *lpszNum++ = '0';
1862       return 0;
1863     }
1864   }
1865   return dwDigits;
1866 }
1867
1868 /*************************************************************************
1869  * SHLWAPI_WriteTimeClass
1870  *
1871  * Internal helper for StrFromTimeIntervalW.
1872  */
1873 static int SHLWAPI_WriteTimeClass(LPWSTR lpszOut, DWORD dwValue,
1874                                   LPCWSTR lpszClass, int iDigits)
1875 {
1876   WCHAR szBuff[64], *szOut = szBuff + 32;
1877
1878   szOut = SHLWAPI_WriteReverseNum(szOut, dwValue);
1879   iDigits = SHLWAPI_FormatSignificant(szOut + 1, iDigits);
1880   *szOut = ' ';
1881   strcpyW(szBuff + 32, lpszClass);
1882   strcatW(lpszOut, szOut);
1883   return iDigits;
1884 }
1885
1886 /*************************************************************************
1887  * StrFromTimeIntervalA [SHLWAPI.@]
1888  *
1889  * Format a millisecond time interval into a string
1890  *
1891  * PARAMS
1892  *  lpszStr  [O] Output buffer for formatted time interval
1893  *  cchMax   [I] Size of lpszStr
1894  *  dwMS     [I] Number of milliseconds
1895  *  iDigits  [I] Number of digits to print
1896  *
1897  * RETURNS
1898  *  The length of the formatted string, or 0 if any parameter is invalid.
1899  *
1900  * NOTES
1901  *  This implementation mimics the Win32 behaviour of always writing a leading
1902  *  space before the time interval begins.
1903  *  iDigits is used to provide approximate times if accuracy is not important.
1904  *  This number of digits will be written of the first non-zero time class
1905  *  (hours/minutes/seconds). If this does not complete the time classification,
1906  *  the remaining digits are changed to zeros (i.e. The time is _not_ rounded).
1907  *  If there are digits remaining following the writing of a time class, the
1908  *  next time class will be written.
1909  *  For example, given dwMS represents 138 hours,43 minutes and 15 seconds, the
1910  *  following will result from the given values of iDigits:
1911  *
1912  *  iDigits    1        2        3        4               5               ...
1913  *  lpszStr   "100 hr" "130 hr" "138 hr" "138 hr 40 min" "138 hr 43 min"  ...
1914  */
1915 INT WINAPI StrFromTimeIntervalA(LPSTR lpszStr, UINT cchMax, DWORD dwMS,
1916                                 int iDigits)
1917 {
1918   INT iRet = 0;
1919
1920   TRACE("(%p,%d,%ld,%d)\n", lpszStr, cchMax, dwMS, iDigits);
1921
1922   if (lpszStr && cchMax)
1923   {
1924     WCHAR szBuff[128];
1925     StrFromTimeIntervalW(szBuff, sizeof(szBuff)/sizeof(WCHAR), dwMS, iDigits);
1926     WideCharToMultiByte(CP_ACP,0,szBuff,-1,lpszStr,cchMax,0,0);
1927   }
1928   return iRet;
1929 }
1930
1931
1932 /*************************************************************************
1933  * StrFromTimeIntervalW [SHLWAPI.@]
1934  *
1935  * See StrFromTimeIntervalA.
1936  */
1937 INT WINAPI StrFromTimeIntervalW(LPWSTR lpszStr, UINT cchMax, DWORD dwMS,
1938                                 int iDigits)
1939 {
1940   static const WCHAR szHr[] = {' ','h','r','\0'};
1941   static const WCHAR szMin[] = {' ','m','i','n','\0'};
1942   static const WCHAR szSec[] = {' ','s','e','c','\0'};
1943   INT iRet = 0;
1944
1945   TRACE("(%p,%d,%ld,%d)\n", lpszStr, cchMax, dwMS, iDigits);
1946
1947   if (lpszStr && cchMax)
1948   {
1949     WCHAR szCopy[128];
1950     DWORD dwHours, dwMinutes;
1951
1952     if (!iDigits || cchMax == 1)
1953     {
1954       *lpszStr = '\0';
1955       return 0;
1956     }
1957
1958     /* Calculate the time classes */
1959     dwMS = (dwMS + 500) / 1000;
1960     dwHours = dwMS / 3600;
1961     dwMS -= dwHours * 3600;
1962     dwMinutes = dwMS / 60;
1963     dwMS -= dwMinutes * 60;
1964
1965     szCopy[0] = '\0';
1966
1967     if (dwHours)
1968       iDigits = SHLWAPI_WriteTimeClass(szCopy, dwHours, szHr, iDigits);
1969
1970     if (dwMinutes && iDigits)
1971       iDigits = SHLWAPI_WriteTimeClass(szCopy, dwMinutes, szMin, iDigits);
1972
1973     if (iDigits) /* Always write seconds if we have significant digits */
1974       SHLWAPI_WriteTimeClass(szCopy, dwMS, szSec, iDigits);
1975
1976     strncpyW(lpszStr, szCopy, cchMax);
1977     iRet = strlenW(lpszStr);
1978   }
1979   return iRet;
1980 }
1981
1982 /*************************************************************************
1983  * StrIsIntlEqualA      [SHLWAPI.@]
1984  *
1985  * Compare two strings.
1986  *
1987  * PARAMS
1988  *  bCase    [I] Whether to compare case sensitively
1989  *  lpszStr  [I] First string to compare
1990  *  lpszComp [I] Second string to compare
1991  *  iLen     [I] Length to compare
1992  *
1993  * RETURNS
1994  *  TRUE  If the strings are equal.
1995  *  FALSE Otherwise.
1996  */
1997 BOOL WINAPI StrIsIntlEqualA(BOOL bCase, LPCSTR lpszStr, LPCSTR lpszComp,
1998                             int iLen)
1999 {
2000   DWORD dwFlags = LOCALE_USE_CP_ACP;
2001   int iRet;
2002
2003   TRACE("(%d,%s,%s,%d)\n", bCase,
2004         debugstr_a(lpszStr), debugstr_a(lpszComp), iLen);
2005
2006   /* FIXME: These flags are undocumented and unknown by our CompareString.
2007    *        We need defines for them.
2008    */
2009   dwFlags |= bCase ? 0x10000000 : 0x10000001;
2010
2011   iRet = CompareStringA(GetThreadLocale(),
2012                         dwFlags, lpszStr, iLen, lpszComp, iLen);
2013
2014   if (!iRet)
2015     iRet = CompareStringA(2048, dwFlags, lpszStr, iLen, lpszComp, iLen);
2016
2017   return iRet == 2 ? TRUE : FALSE;
2018 }
2019
2020 /*************************************************************************
2021  * StrIsIntlEqualW      [SHLWAPI.@]
2022  *
2023  * See StrIsIntlEqualA.
2024  */
2025 BOOL WINAPI StrIsIntlEqualW(BOOL bCase, LPCWSTR lpszStr, LPCWSTR lpszComp,
2026                             int iLen)
2027 {
2028   DWORD dwFlags;
2029   int iRet;
2030
2031   TRACE("(%d,%s,%s,%d)\n", bCase,
2032         debugstr_w(lpszStr),debugstr_w(lpszComp), iLen);
2033
2034   /* FIXME: These flags are undocumented and unknown by our CompareString.
2035    *        We need defines for them.
2036    */
2037   dwFlags = bCase ? 0x10000000 : 0x10000001;
2038
2039   iRet = CompareStringW(GetThreadLocale(),
2040                         dwFlags, lpszStr, iLen, lpszComp, iLen);
2041
2042   if (!iRet)
2043     iRet = CompareStringW(2048, dwFlags, lpszStr, iLen, lpszComp, iLen);
2044
2045   return iRet == 2 ? TRUE : FALSE;
2046 }
2047
2048 /*************************************************************************
2049  * @    [SHLWAPI.399]
2050  *
2051  * Copy a string to another string, up to a maximum number of characters.
2052  *
2053  * PARAMS
2054  *  lpszDest [O] Destination string
2055  *  lpszSrc  [I] Source string
2056  *  iLen     [I] Maximum number of chars to copy
2057  *
2058  * RETURNS
2059  *  Success: A pointer to the last character written.
2060  *  Failure: lpszDest, if any arguments are invalid.
2061  */
2062 LPSTR WINAPI SHLWAPI_399(LPSTR lpszDest, LPCSTR lpszSrc, int iLen)
2063 {
2064   TRACE("(%p,%s,%i)\n", lpszDest, debugstr_a(lpszSrc), iLen);
2065
2066   if (lpszDest && lpszSrc && iLen > 0)
2067   {
2068     while ((iLen-- > 1) && *lpszSrc)
2069       *lpszDest++ = *lpszSrc++;
2070     if (iLen >= 0)
2071      *lpszDest = '\0';
2072   }
2073   return lpszDest;
2074 }
2075
2076 /*************************************************************************
2077  * @    [SHLWAPI.400]
2078  *
2079  * Unicode version of SHLWAPI_399.
2080  */
2081 LPWSTR WINAPI SHLWAPI_400(LPWSTR lpszDest, LPCWSTR lpszSrc, int iLen)
2082 {
2083   TRACE("(%p,%s,%i)\n", lpszDest, debugstr_w(lpszSrc), iLen);
2084
2085   if (lpszDest && lpszSrc && iLen > 0)
2086   {
2087     while ((iLen-- > 1) && *lpszSrc)
2088       *lpszDest++ = *lpszSrc++;
2089     if (iLen >= 0)
2090      *lpszDest = '\0';
2091   }
2092   return lpszDest;
2093 }
2094
2095 /*************************************************************************
2096  * StrCmpLogicalW       [SHLWAPI.@]
2097  *
2098  * Compare two strings, ignoring case and comparing digits as numbers.
2099  *
2100  * PARAMS
2101  *  lpszStr  [I] First string to compare
2102  *  lpszComp [I] Second string to compare
2103  *  iLen     [I] Length to compare
2104  *
2105  * RETURNS
2106  *  TRUE  If the strings are equal.
2107  *  FALSE Otherwise.
2108  */
2109 INT WINAPI StrCmpLogicalW(LPCWSTR lpszStr, LPCWSTR lpszComp)
2110 {
2111   INT iDiff;
2112
2113   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszComp));
2114
2115   if (lpszStr && lpszComp)
2116   {
2117     while (*lpszStr)
2118     {
2119       if (!*lpszComp)
2120         return 1;
2121       else if (isdigitW(*lpszStr))
2122       {
2123         int iStr, iComp;
2124
2125         if (!isdigitW(*lpszComp))
2126           return -1;
2127
2128         /* Compare the numbers */
2129         StrToIntExW(lpszStr, 0, &iStr);
2130         StrToIntExW(lpszComp, 0, &iComp);
2131
2132         if (iStr < iComp)
2133           return -1;
2134         else if (iStr > iComp)
2135           return 1;
2136
2137         /* Skip */
2138         while (isdigitW(*lpszStr))
2139           lpszStr++;
2140         while (isdigitW(*lpszComp))
2141           lpszComp++;
2142       }
2143       else if (isdigitW(*lpszComp))
2144         return 1;
2145       else
2146       {
2147         iDiff = SHLWAPI_ChrCmpHelperA(*lpszStr,*lpszComp,NORM_IGNORECASE);
2148         if (iDiff > 0)
2149           return 1;
2150         else if (iDiff < 0)
2151           return -1;
2152
2153         lpszStr++;
2154         lpszComp++;
2155       }
2156     }
2157     if (*lpszComp)
2158       return -1;
2159   }
2160   return 0;
2161 }
2162
2163 /* Structure for formatting byte strings */
2164 typedef struct tagSHLWAPI_BYTEFORMATS
2165 {
2166   LONGLONG dLimit;
2167   double   dDivisor;
2168   double   dNormaliser;
2169   LPCSTR   lpszFormat;
2170   CHAR     wPrefix;
2171 } SHLWAPI_BYTEFORMATS;
2172
2173 /*************************************************************************
2174  * StrFormatByteSize64A [SHLWAPI.@]
2175  *
2176  * Create a string containing an abbreviated byte count of up to 2^63-1.
2177  *
2178  * PARAMS
2179  *  llBytes  [I] Byte size to format
2180  *  lpszDest [I] Destination for formatted string
2181  *  cchMax   [I] Size of lpszDest
2182  *
2183  * RETURNS
2184  *  lpszDest.
2185  *
2186  * NOTES
2187  *  There is no StrFormatByteSize64W function, it is called StrFormatByteSizeW.
2188  */
2189 LPSTR WINAPI StrFormatByteSize64A(LONGLONG llBytes, LPSTR lpszDest, UINT cchMax)
2190 {
2191   static const char szBytes[] = "%ld bytes";
2192   static const char sz3_0[] = "%3.0f";
2193   static const char sz3_1[] = "%3.1f";
2194   static const char sz3_2[] = "%3.2f";
2195
2196   static const SHLWAPI_BYTEFORMATS bfFormats[] =
2197   {
2198     { 10240, 10.24, 100.0, sz3_2, 'K' }, /* 10 KB */
2199     { 102400, 102.4, 10.0, sz3_1, 'K' }, /* 100 KB */
2200     { 1024000, 1024.0, 1.0, sz3_0, 'K' }, /* 1000 KB */
2201     { 10485760, 10485.76, 100.0, sz3_2, 'M' }, /* 10 MB */
2202     { 104857600, 104857.6, 10.0, sz3_1, 'M' }, /* 100 MB */
2203     { 1048576000, 1048576.0, 1.0, sz3_0, 'M' }, /* 1000 MB */
2204     { 10737418240, 10737418.24, 100.0, sz3_2, 'G' }, /* 10 GB */
2205     { 107374182400, 107374182.4, 10.0, sz3_1, 'G' }, /* 100 GB */
2206     { 1073741824000, 1073741824.0, 1.0, sz3_0, 'G' }, /* 1000 GB */
2207     { 10995116277760, 10485.76, 100.0, sz3_2, 'T' }, /* 10 TB */
2208     { 109951162777600, 104857.6, 10.0, sz3_1, 'T' }, /* 100 TB */
2209     { 1099511627776000, 1048576.0, 1.0, sz3_0, 'T' }, /* 1000 TB */
2210     { 11258999068426240, 10737418.24, 100.00, sz3_2, 'P' }, /* 10 PB */
2211     { 112589990684262400, 107374182.4, 10.00, sz3_1, 'P' }, /* 100 PB */
2212     { 1125899906842624000, 1073741824.0, 1.00, sz3_0, 'P' }, /* 1000 PB */
2213     { 0, 10995116277.76, 100.00, sz3_2, 'E' } /* EB's, catch all */
2214   };
2215   char szBuff[32];
2216   char szAdd[4];
2217   double dBytes;
2218   UINT i = 0;
2219
2220   TRACE("(%lld,%p,%d)\n", llBytes, lpszDest, cchMax);
2221
2222   if (!lpszDest || !cchMax)
2223     return lpszDest;
2224
2225   if (llBytes < 1024)  /* 1K */
2226   {
2227     snprintf (lpszDest, cchMax, szBytes, (long)llBytes);
2228     return lpszDest;
2229   }
2230
2231   /* Note that if this loop completes without finding a match, i will be
2232    * pointing at the last entry, which is a catch all for > 1000 PB
2233    */
2234   while (i < sizeof(bfFormats) / sizeof(SHLWAPI_BYTEFORMATS) - 1)
2235   {
2236     if (llBytes < bfFormats[i].dLimit)
2237       break;
2238     i++;
2239   }
2240   /* Above 1 TB we encounter problems with FP accuracy. So for amounts above
2241    * this number we integer shift down by 1 MB first. The table above has
2242    * the divisors scaled down from the '< 10 TB' entry onwards, to account
2243    * for this. We also add a small fudge factor to get the correct result for
2244    * counts that lie exactly on a 1024 byte boundary.
2245    */
2246   if (i > 8)
2247     dBytes = (double)(llBytes >> 20) + 0.001; /* Scale down by I MB */
2248   else
2249     dBytes = (double)llBytes + 0.00001;
2250
2251   dBytes = floor(dBytes / bfFormats[i].dDivisor) / bfFormats[i].dNormaliser;
2252
2253   sprintf(szBuff, bfFormats[i].lpszFormat, dBytes);
2254   szAdd[0] = ' ';
2255   szAdd[1] = bfFormats[i].wPrefix;
2256   szAdd[2] = 'B';
2257   szAdd[3] = '\0';
2258   strcat(szBuff, szAdd);
2259   strncpy(lpszDest, szBuff, cchMax);
2260   return lpszDest;
2261 }
2262
2263 /*************************************************************************
2264  * StrFormatByteSizeW   [SHLWAPI.@]
2265  *
2266  * See StrFormatByteSize64A.
2267  */
2268 LPWSTR WINAPI StrFormatByteSizeW(LONGLONG llBytes, LPWSTR lpszDest,
2269                                  UINT cchMax)
2270 {
2271   char szBuff[32];
2272
2273   StrFormatByteSize64A(llBytes, szBuff, sizeof(szBuff));
2274
2275   if (lpszDest)
2276     MultiByteToWideChar(CP_ACP, 0, szBuff, -1, lpszDest, cchMax);
2277   return lpszDest;
2278 }
2279
2280 /*************************************************************************
2281  * StrFormatByteSizeA   [SHLWAPI.@]
2282  *
2283  * Create a string containing an abbreviated byte count of up to 2^31-1.
2284  *
2285  * PARAMS
2286  *  dwBytes  [I] Byte size to format
2287  *  lpszDest [I] Destination for formatted string
2288  *  cchMax   [I] Size of lpszDest
2289  *
2290  * RETURNS
2291  *  lpszDest.
2292  *
2293  * NOTES
2294  *  The ASCII and Unicode versions of this function accept a different
2295  *  integer size for dwBytes. See StrFormatByteSize64A.
2296  */
2297 LPSTR WINAPI StrFormatByteSizeA(DWORD dwBytes, LPSTR lpszDest, UINT cchMax)
2298 {
2299   TRACE("(%ld,%p,%d)\n", dwBytes, lpszDest, cchMax);
2300
2301   return StrFormatByteSize64A(dwBytes, lpszDest, cchMax);
2302 }