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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <math.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29
  30 #define NONAMELESSUNION
  31
  32 #include "windef.h"
  33 #include "winbase.h"
  34 #define NO_SHLWAPI_REG
  35 #define NO_SHLWAPI_STREAM
  36 #include "shlwapi.h"
  37 #include "wingdi.h"
  38 #include "winuser.h"
  39 #include "shlobj.h"
  40 #include "mlang.h"
  41 #include "ddeml.h"
  42 #include "wine/unicode.h"
  43 #include "wine/debug.h"
  44
  45 #include "resource.h"
  46
  47 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  48
  49 extern HINSTANCE shlwapi_hInstance;
  50
  51 static HRESULT _SHStrDupAA(LPCSTR,LPSTR*);
  52 static HRESULT _SHStrDupAW(LPCWSTR,LPSTR*);
  53
  54
  55 static void FillNumberFmt(NUMBERFMTW *fmt, LPWSTR decimal_buffer, int decimal_bufwlen,
  56                           LPWSTR thousand_buffer, int thousand_bufwlen)
  57 {
  58   WCHAR grouping[64];
  59   WCHAR *c;
  60
  61   GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_ILZERO|LOCALE_RETURN_NUMBER, (LPWSTR)&fmt->LeadingZero, sizeof(fmt->LeadingZero)/sizeof(WCHAR));
  62   GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_INEGNUMBER|LOCALE_RETURN_NUMBER, (LPWSTR)&fmt->LeadingZero, sizeof(fmt->NegativeOrder)/sizeof(WCHAR));
  63   fmt->NumDigits = 0;
  64   GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, decimal_buffer, decimal_bufwlen);
  65   GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, thousand_buffer, thousand_bufwlen);
  66   fmt->lpThousandSep = thousand_buffer;
  67   fmt->lpDecimalSep = decimal_buffer;
  68
  69   /*
  70    * Converting grouping string to number as described on
  71    * http://blogs.msdn.com/oldnewthing/archive/2006/04/18/578251.aspx
  72    */
  73   fmt->Grouping = 0;
  74   GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SGROUPING, grouping, sizeof(grouping)/sizeof(WCHAR));
  75   for (c = grouping; *c; c++)
  76     if (*c >= '0' && *c < '9')
  77     {
  78       fmt->Grouping *= 10;
  79       fmt->Grouping += *c - '0';
  80     }
  81
  82   if (fmt->Grouping % 10 == 0)
  83     fmt->Grouping /= 10;
  84   else
  85     fmt->Grouping *= 10;
  86 }
  87
  88 /*************************************************************************
  89  * FormatInt   [internal]
  90  *
  91  * Format an integer according to the current locale
  92  *
  93  * RETURNS
  94  *  The number of characters written on success or 0 on failure
  95  */
  96 static int FormatInt(LONGLONG qdwValue, LPWSTR pszBuf, int cchBuf)
  97 {
  98   NUMBERFMTW fmt;
  99   WCHAR decimal[8], thousand[8];
 100   WCHAR buf[24];
 101   WCHAR *c;
 102   BOOL neg = (qdwValue < 0);
 103
 104   FillNumberFmt(&fmt, decimal, sizeof decimal / sizeof (WCHAR),
 105                 thousand, sizeof thousand / sizeof (WCHAR));
 106
 107   c = &buf[24];
 108   *(--c) = 0;
 109   do
 110   {
 111     *(--c) = '0' + (qdwValue%10);
 112     qdwValue /= 10;
 113   } while (qdwValue > 0);
 114   if (neg)
 115     *(--c) = '-';
 116
 117   return GetNumberFormatW(LOCALE_USER_DEFAULT, 0, c, &fmt, pszBuf, cchBuf);
 118 }
 119
 120 /*************************************************************************
 121  * FormatDouble   [internal]
 122  *
 123  * Format an integer according to the current locale. Prints the specified number of digits
 124  * after the decimal point
 125  *
 126  * RETURNS
 127  *  The number of characters written on success or 0 on failure
 128  */
 129 static int FormatDouble(double value, int decimals, LPWSTR pszBuf, int cchBuf)
 130 {
 131   static const WCHAR flfmt[] = {'%','f',0};
 132   WCHAR buf[64];
 133   NUMBERFMTW fmt;
 134   WCHAR decimal[8], thousand[8];
 135
 136   snprintfW(buf, 64, flfmt, value);
 137
 138   FillNumberFmt(&fmt, decimal, sizeof decimal / sizeof (WCHAR),
 139                  thousand, sizeof thousand / sizeof (WCHAR));
 140   fmt.NumDigits = decimals;
 141   return GetNumberFormatW(LOCALE_USER_DEFAULT, 0, buf, &fmt, pszBuf, cchBuf);
 142 }
 143
 144 /*************************************************************************
 145  * SHLWAPI_ChrCmpHelperA
 146  *
 147  * Internal helper for SHLWAPI_ChrCmpA/ChrCMPIA.
 148  *
 149  * NOTES
 150  *  Both this function and its Unicode counterpart are very inefficient. To
 151  *  fix this, CompareString must be completely implemented and optimised
 152  *  first. Then the core character test can be taken out of that function and
 153  *  placed here, so that it need never be called at all. Until then, do not
 154  *  attempt to optimise this code unless you are willing to test that it
 155  *  still performs correctly.
 156  */
 157 static BOOL SHLWAPI_ChrCmpHelperA(WORD ch1, WORD ch2, DWORD dwFlags)
 158 {
 159   char str1[3], str2[3];
 160
 161   str1[0] = LOBYTE(ch1);
 162   if (IsDBCSLeadByte(str1[0]))
 163   {
 164     str1[1] = HIBYTE(ch1);
 165     str1[2] = '\0';
 166   }
 167   else
 168     str1[1] = '\0';
 169
 170   str2[0] = LOBYTE(ch2);
 171   if (IsDBCSLeadByte(str2[0]))
 172   {
 173     str2[1] = HIBYTE(ch2);
 174     str2[2] = '\0';
 175   }
 176   else
 177     str2[1] = '\0';
 178
 179   return CompareStringA(GetThreadLocale(), dwFlags, str1, -1, str2, -1) - CSTR_EQUAL;
 180 }
 181
 182 /*************************************************************************
 183  * SHLWAPI_ChrCmpA
 184  *
 185  * Internal helper function.
 186  */
 187 static BOOL WINAPI SHLWAPI_ChrCmpA(WORD ch1, WORD ch2)
 188 {
 189   return SHLWAPI_ChrCmpHelperA(ch1, ch2, 0);
 190 }
 191
 192 /*************************************************************************
 193  * ChrCmpIA     (SHLWAPI.385)
 194  *
 195  * Compare two characters, ignoring case.
 196  *
 197  * PARAMS
 198  *  ch1 [I] First character to compare
 199  *  ch2 [I] Second character to compare
 200  *
 201  * RETURNS
 202  *  FALSE, if the characters are equal.
 203  *  Non-zero otherwise.
 204  */
 205 BOOL WINAPI ChrCmpIA(WORD ch1, WORD ch2)
 206 {
 207   TRACE("(%d,%d)\n", ch1, ch2);
 208
 209   return SHLWAPI_ChrCmpHelperA(ch1, ch2, NORM_IGNORECASE);
 210 }
 211
 212 /*************************************************************************
 213  * ChrCmpIW     [SHLWAPI.386]
 214  *
 215  * See ChrCmpIA.
 216  */
 217 BOOL WINAPI ChrCmpIW(WCHAR ch1, WCHAR ch2)
 218 {
 219   return CompareStringW(GetThreadLocale(), NORM_IGNORECASE, &ch1, 1, &ch2, 1) - CSTR_EQUAL;
 220 }
 221
 222 /*************************************************************************
 223  * StrChrA      [SHLWAPI.@]
 224  *
 225  * Find a given character in a string.
 226  *
 227  * PARAMS
 228  *  lpszStr [I] String to search in.
 229  *  ch      [I] Character to search for.
 230  *
 231  * RETURNS
 232  *  Success: A pointer to the first occurrence of ch in lpszStr, or NULL if
 233  *           not found.
 234  *  Failure: NULL, if any arguments are invalid.
 235  */
 236 LPSTR WINAPI StrChrA(LPCSTR lpszStr, WORD ch)
 237 {
 238   TRACE("(%s,%i)\n", debugstr_a(lpszStr), ch);
 239
 240   if (lpszStr)
 241   {
 242     while (*lpszStr)
 243     {
 244       if (!SHLWAPI_ChrCmpA(*lpszStr, ch))
 245         return (LPSTR)lpszStr;
 246       lpszStr = CharNextA(lpszStr);
 247     }
 248   }
 249   return NULL;
 250 }
 251
 252 /*************************************************************************
 253  * StrChrW      [SHLWAPI.@]
 254  *
 255  * See StrChrA.
 256  */
 257 LPWSTR WINAPI StrChrW(LPCWSTR lpszStr, WCHAR ch)
 258 {
 259   LPWSTR lpszRet = NULL;
 260
 261   TRACE("(%s,%i)\n", debugstr_w(lpszStr), ch);
 262
 263   if (lpszStr)
 264     lpszRet = strchrW(lpszStr, ch);
 265   return lpszRet;
 266 }
 267
 268 /*************************************************************************
 269  * StrChrIA     [SHLWAPI.@]
 270  *
 271  * Find a given character in a string, ignoring case.
 272  *
 273  * PARAMS
 274  *  lpszStr [I] String to search in.
 275  *  ch      [I] Character to search for.
 276  *
 277  * RETURNS
 278  *  Success: A pointer to the first occurrence of ch in lpszStr, or NULL if
 279  *           not found.
 280  *  Failure: NULL, if any arguments are invalid.
 281  */
 282 LPSTR WINAPI StrChrIA(LPCSTR lpszStr, WORD ch)
 283 {
 284   TRACE("(%s,%i)\n", debugstr_a(lpszStr), ch);
 285
 286   if (lpszStr)
 287   {
 288     while (*lpszStr)
 289     {
 290       if (!ChrCmpIA(*lpszStr, ch))
 291         return (LPSTR)lpszStr;
 292       lpszStr = CharNextA(lpszStr);
 293     }
 294   }
 295   return NULL;
 296 }
 297
 298 /*************************************************************************
 299  * StrChrIW     [SHLWAPI.@]
 300  *
 301  * See StrChrA.
 302  */
 303 LPWSTR WINAPI StrChrIW(LPCWSTR lpszStr, WCHAR ch)
 304 {
 305   TRACE("(%s,%i)\n", debugstr_w(lpszStr), ch);
 306
 307   if (lpszStr)
 308   {
 309     ch = toupperW(ch);
 310     while (*lpszStr)
 311     {
 312       if (toupperW(*lpszStr) == ch)
 313         return (LPWSTR)lpszStr;
 314       lpszStr++;
 315     }
 316     lpszStr = NULL;
 317   }
 318   return (LPWSTR)lpszStr;
 319 }
 320
 321 /*************************************************************************
 322  * StrChrNW     [SHLWAPI.@]
 323  */
 324 LPWSTR WINAPI StrChrNW(LPCWSTR lpszStr, WCHAR ch, UINT cchMax)
 325 {
 326   TRACE("(%s(%i),%i)\n", debugstr_wn(lpszStr,cchMax), cchMax, ch);
 327
 328   if (lpszStr)
 329   {
 330     while (*lpszStr && cchMax-- > 0)
 331     {
 332       if (*lpszStr == ch)
 333         return (LPWSTR)lpszStr;
 334       lpszStr++;
 335     }
 336   }
 337   return NULL;
 338 }
 339
 340 /*************************************************************************
 341  * StrCmpIW     [SHLWAPI.@]
 342  *
 343  * Compare two strings, ignoring case.
 344  *
 345  * PARAMS
 346  *  lpszStr  [I] First string to compare
 347  *  lpszComp [I] Second string to compare
 348  *
 349  * RETURNS
 350  *  An integer less than, equal to or greater than 0, indicating that
 351  *  lpszStr is less than, the same, or greater than lpszComp.
 352  */
 353 int WINAPI StrCmpIW(LPCWSTR lpszStr, LPCWSTR lpszComp)
 354 {
 355   TRACE("(%s,%s)\n", debugstr_w(lpszStr),debugstr_w(lpszComp));
 356   return CompareStringW(GetThreadLocale(), NORM_IGNORECASE, lpszStr, -1, lpszComp, -1) - CSTR_EQUAL;
 357 }
 358
 359 /*************************************************************************
 360  * StrCmpNA     [SHLWAPI.@]
 361  *
 362  * Compare two strings, up to a maximum length.
 363  *
 364  * PARAMS
 365  *  lpszStr  [I] First string to compare
 366  *  lpszComp [I] Second string to compare
 367  *  iLen     [I] Number of chars to compare
 368  *
 369  * RETURNS
 370  *  An integer less than, equal to or greater than 0, indicating that
 371  *  lpszStr is less than, the same, or greater than lpszComp.
 372  */
 373 INT WINAPI StrCmpNA(LPCSTR lpszStr, LPCSTR lpszComp, INT iLen)
 374 {
 375   TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszComp), iLen);
 376   return CompareStringA(GetThreadLocale(), 0, lpszStr, iLen, lpszComp, iLen) - CSTR_EQUAL;
 377 }
 378
 379 /*************************************************************************
 380  * StrCmpNW     [SHLWAPI.@]
 381  *
 382  * See StrCmpNA.
 383  */
 384 INT WINAPI StrCmpNW(LPCWSTR lpszStr, LPCWSTR lpszComp, INT iLen)
 385 {
 386   TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszComp), iLen);
 387   return CompareStringW(GetThreadLocale(), 0, lpszStr, iLen, lpszComp, iLen) - CSTR_EQUAL;
 388 }
 389
 390 /*************************************************************************
 391  * StrCmpNIA    [SHLWAPI.@]
 392  *
 393  * Compare two strings, up to a maximum length, ignoring case.
 394  *
 395  * PARAMS
 396  *  lpszStr  [I] First string to compare
 397  *  lpszComp [I] Second string to compare
 398  *  iLen     [I] Number of chars to compare
 399  *
 400  * RETURNS
 401  *  An integer less than, equal to or greater than 0, indicating that
 402  *  lpszStr is less than, the same, or greater than lpszComp.
 403  */
 404 int WINAPI StrCmpNIA(LPCSTR lpszStr, LPCSTR lpszComp, int iLen)
 405 {
 406   TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszComp), iLen);
 407   return CompareStringA(GetThreadLocale(), NORM_IGNORECASE, lpszStr, iLen, lpszComp, iLen) - CSTR_EQUAL;
 408 }
 409
 410 /*************************************************************************
 411  * StrCmpNIW    [SHLWAPI.@]
 412  *
 413  * See StrCmpNIA.
 414  */
 415 INT WINAPI StrCmpNIW(LPCWSTR lpszStr, LPCWSTR lpszComp, int iLen)
 416 {
 417   TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszComp), iLen);
 418   return CompareStringW(GetThreadLocale(), NORM_IGNORECASE, lpszStr, iLen, lpszComp, iLen) - CSTR_EQUAL;
 419 }
 420
 421 /*************************************************************************
 422  * StrCmpW      [SHLWAPI.@]
 423  *
 424  * Compare two strings.
 425  *
 426  * PARAMS
 427  *  lpszStr  [I] First string to compare
 428  *  lpszComp [I] Second string to compare
 429  *
 430  * RETURNS
 431  *  An integer less than, equal to or greater than 0, indicating that
 432  *  lpszStr is less than, the same, or greater than lpszComp.
 433  */
 434 int WINAPI StrCmpW(LPCWSTR lpszStr, LPCWSTR lpszComp)
 435 {
 436   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszComp));
 437   return CompareStringW(GetThreadLocale(), 0, lpszStr, -1, lpszComp, -1) - CSTR_EQUAL;
 438 }
 439
 440 /*************************************************************************
 441  * StrCatW      [SHLWAPI.@]
 442  *
 443  * Concatenate two strings.
 444  *
 445  * PARAMS
 446  *  lpszStr [O] Initial string
 447  *  lpszSrc [I] String to concatenate
 448  *
 449  * RETURNS
 450  *  lpszStr.
 451  */
 452 LPWSTR WINAPI StrCatW(LPWSTR lpszStr, LPCWSTR lpszSrc)
 453 {
 454   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSrc));
 455
 456   if (lpszStr && lpszSrc)
 457     strcatW(lpszStr, lpszSrc);
 458   return lpszStr;
 459 }
 460
 461 /*************************************************************************
 462  * StrCatChainW [SHLWAPI.@]
 463  *
 464  * Concatenates two unicode strings.
 465  *
 466  * PARAMS
 467  *  lpszStr [O] Initial string
 468  *  cchMax  [I] Length of destination buffer
 469  *  ichAt   [I] Offset from the destination buffer to begin concatenation
 470  *  lpszCat [I] String to concatenate
 471  *
 472  * RETURNS
 473  *  The offset from the beginning of pszDst to the terminating NULL.
 474  */
 475 DWORD WINAPI StrCatChainW(LPWSTR lpszStr, DWORD cchMax, DWORD ichAt, LPCWSTR lpszCat)
 476 {
 477   TRACE("(%s,%u,%d,%s)\n", debugstr_w(lpszStr), cchMax, ichAt, debugstr_w(lpszCat));
 478
 479   if (ichAt == -1)
 480     ichAt = strlenW(lpszStr);
 481
 482   if (!cchMax)
 483     return ichAt;
 484
 485   if (ichAt == cchMax)
 486     ichAt--;
 487
 488   if (lpszCat && ichAt < cchMax)
 489   {
 490     lpszStr += ichAt;
 491     while (ichAt < cchMax - 1 && *lpszCat)
 492     {
 493       *lpszStr++ = *lpszCat++;
 494       ichAt++;
 495     }
 496     *lpszStr = 0;
 497   }
 498
 499   return ichAt;
 500 }
 501
 502 /*************************************************************************
 503  * StrCpyW      [SHLWAPI.@]
 504  *
 505  * Copy a string to another string.
 506  *
 507  * PARAMS
 508  *  lpszStr [O] Destination string
 509  *  lpszSrc [I] Source string
 510  *
 511  * RETURNS
 512  *  lpszStr.
 513  */
 514 LPWSTR WINAPI StrCpyW(LPWSTR lpszStr, LPCWSTR lpszSrc)
 515 {
 516   TRACE("(%p,%s)\n", lpszStr, debugstr_w(lpszSrc));
 517
 518   if (lpszStr && lpszSrc)
 519     strcpyW(lpszStr, lpszSrc);
 520   return lpszStr;
 521 }
 522
 523 /*************************************************************************
 524  * StrCpyNW     [SHLWAPI.@]
 525  *
 526  * Copy a string to another string, up to a maximum number of characters.
 527  *
 528  * PARAMS
 529  *  dst    [O] Destination string
 530  *  src    [I] Source string
 531  *  count  [I] Maximum number of chars to copy
 532  *
 533  * RETURNS
 534  *  dst.
 535  */
 536 LPWSTR WINAPI StrCpyNW(LPWSTR dst, LPCWSTR src, int count)
 537 {
 538   LPWSTR d = dst;
 539   LPCWSTR s = src;
 540
 541   TRACE("(%p,%s,%i)\n", dst, debugstr_w(src), count);
 542
 543   if (s)
 544   {
 545     while ((count > 1) && *s)
 546     {
 547       count--;
 548       *d++ = *s++;
 549     }
 550   }
 551   if (count) *d = 0;
 552
 553   return dst;
 554 }
 555
 556 /*************************************************************************
 557  * SHLWAPI_StrStrHelperA
 558  *
 559  * Internal implementation of StrStrA/StrStrIA
 560  */
 561 static LPSTR SHLWAPI_StrStrHelperA(LPCSTR lpszStr, LPCSTR lpszSearch,
 562                                    INT (WINAPI *pStrCmpFn)(LPCSTR,LPCSTR,INT))
 563 {
 564   size_t iLen;
 565   LPCSTR end;
 566
 567   if (!lpszStr || !lpszSearch || !*lpszSearch)
 568     return NULL;
 569
 570   iLen = strlen(lpszSearch);
 571   end = lpszStr + strlen(lpszStr);
 572
 573   while (lpszStr + iLen <= end)
 574   {
 575     if (!pStrCmpFn(lpszStr, lpszSearch, iLen))
 576       return (LPSTR)lpszStr;
 577     lpszStr = CharNextA(lpszStr);
 578   }
 579   return NULL;
 580 }
 581
 582 /*************************************************************************
 583  * StrStrA      [SHLWAPI.@]
 584  *
 585  * Find a substring within a string.
 586  *
 587  * PARAMS
 588  *  lpszStr    [I] String to search in
 589  *  lpszSearch [I] String to look for
 590  *
 591  * RETURNS
 592  *  The start of lpszSearch within lpszStr, or NULL if not found.
 593  */
 594 LPSTR WINAPI StrStrA(LPCSTR lpszStr, LPCSTR lpszSearch)
 595 {
 596   TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
 597
 598   return SHLWAPI_StrStrHelperA(lpszStr, lpszSearch, StrCmpNA);
 599 }
 600
 601 /*************************************************************************
 602  * StrStrW      [SHLWAPI.@]
 603  *
 604  * See StrStrA.
 605  */
 606 LPWSTR WINAPI StrStrW(LPCWSTR lpszStr, LPCWSTR lpszSearch)
 607 {
 608     TRACE("(%s, %s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch));
 609
 610     if (!lpszStr || !lpszSearch || !*lpszSearch) return NULL;
 611     return strstrW( lpszStr, lpszSearch );
 612 }
 613
 614 /*************************************************************************
 615  * StrRStrIA    [SHLWAPI.@]
 616  *
 617  * Find the last occurrence of a substring within a string.
 618  *
 619  * PARAMS
 620  *  lpszStr    [I] String to search in
 621  *  lpszEnd    [I] End of lpszStr
 622  *  lpszSearch [I] String to look for
 623  *
 624  * RETURNS
 625  *  The last occurrence lpszSearch within lpszStr, or NULL if not found.
 626  */
 627 LPSTR WINAPI StrRStrIA(LPCSTR lpszStr, LPCSTR lpszEnd, LPCSTR lpszSearch)
 628 {
 629   LPSTR lpszRet = NULL;
 630   WORD ch1, ch2;
 631   INT iLen;
 632
 633   TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
 634
 635   if (!lpszStr || !lpszSearch || !*lpszSearch)
 636     return NULL;
 637
 638   if (IsDBCSLeadByte(*lpszSearch))
 639     ch1 = *lpszSearch << 8 | (UCHAR)lpszSearch[1];
 640   else
 641     ch1 = *lpszSearch;
 642   iLen = lstrlenA(lpszSearch);
 643
 644   if (!lpszEnd)
 645     lpszEnd = lpszStr + lstrlenA(lpszStr);
 646   else /* reproduce the broken behaviour on Windows */
 647     lpszEnd += min(iLen - 1, lstrlenA(lpszEnd));
 648
 649   while (lpszStr + iLen <= lpszEnd && *lpszStr)
 650   {
 651     ch2 = IsDBCSLeadByte(*lpszStr)? *lpszStr << 8 | (UCHAR)lpszStr[1] : *lpszStr;
 652     if (!ChrCmpIA(ch1, ch2))
 653     {
 654       if (!StrCmpNIA(lpszStr, lpszSearch, iLen))
 655         lpszRet = (LPSTR)lpszStr;
 656     }
 657     lpszStr = CharNextA(lpszStr);
 658   }
 659   return lpszRet;
 660 }
 661
 662 /*************************************************************************
 663  * StrRStrIW    [SHLWAPI.@]
 664  *
 665  * See StrRStrIA.
 666  */
 667 LPWSTR WINAPI StrRStrIW(LPCWSTR lpszStr, LPCWSTR lpszEnd, LPCWSTR lpszSearch)
 668 {
 669   LPWSTR lpszRet = NULL;
 670   INT iLen;
 671
 672   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch));
 673
 674   if (!lpszStr || !lpszSearch || !*lpszSearch)
 675     return NULL;
 676
 677   iLen = strlenW(lpszSearch);
 678
 679   if (!lpszEnd)
 680     lpszEnd = lpszStr + strlenW(lpszStr);
 681   else /* reproduce the broken behaviour on Windows */
 682     lpszEnd += min(iLen - 1, lstrlenW(lpszEnd));
 683
 684   while (lpszStr + iLen <= lpszEnd && *lpszStr)
 685   {
 686     if (!ChrCmpIW(*lpszSearch, *lpszStr))
 687     {
 688       if (!StrCmpNIW(lpszStr, lpszSearch, iLen))
 689         lpszRet = (LPWSTR)lpszStr;
 690     }
 691     lpszStr++;
 692   }
 693   return lpszRet;
 694 }
 695
 696 /*************************************************************************
 697  * StrStrIA     [SHLWAPI.@]
 698  *
 699  * Find a substring within a string, ignoring case.
 700  *
 701  * PARAMS
 702  *  lpszStr    [I] String to search in
 703  *  lpszSearch [I] String to look for
 704  *
 705  * RETURNS
 706  *  The start of lpszSearch within lpszStr, or NULL if not found.
 707  */
 708 LPSTR WINAPI StrStrIA(LPCSTR lpszStr, LPCSTR lpszSearch)
 709 {
 710   TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
 711
 712   return SHLWAPI_StrStrHelperA(lpszStr, lpszSearch, StrCmpNIA);
 713 }
 714
 715 /*************************************************************************
 716  * StrStrIW     [SHLWAPI.@]
 717  *
 718  * See StrStrIA.
 719  */
 720 LPWSTR WINAPI StrStrIW(LPCWSTR lpszStr, LPCWSTR lpszSearch)
 721 {
 722   int iLen;
 723   LPCWSTR end;
 724
 725   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch));
 726
 727   if (!lpszStr || !lpszSearch || !*lpszSearch)
 728     return NULL;
 729
 730   iLen = strlenW(lpszSearch);
 731   end = lpszStr + strlenW(lpszStr);
 732
 733   while (lpszStr + iLen <= end)
 734   {
 735     if (!StrCmpNIW(lpszStr, lpszSearch, iLen))
 736       return (LPWSTR)lpszStr;
 737     lpszStr++;
 738   }
 739   return NULL;
 740 }
 741
 742 /*************************************************************************
 743  * StrStrNW     [SHLWAPI.@]
 744  *
 745  * Find a substring within a string up to a given number of initial characters.
 746  *
 747  * PARAMS
 748  *  lpFirst    [I] String to search in
 749  *  lpSrch     [I] String to look for
 750  *  cchMax     [I] Maximum number of initial search characters
 751  *
 752  * RETURNS
 753  *  The start of lpFirst within lpSrch, or NULL if not found.
 754  */
 755 LPWSTR WINAPI StrStrNW(LPCWSTR lpFirst, LPCWSTR lpSrch, UINT cchMax)
 756 {
 757     UINT i;
 758     int len;
 759
 760     TRACE("(%s, %s, %u)\n", debugstr_w(lpFirst), debugstr_w(lpSrch), cchMax);
 761
 762     if (!lpFirst || !lpSrch || !*lpSrch || !cchMax)
 763         return NULL;
 764
 765     len = strlenW(lpSrch);
 766
 767     for (i = cchMax; *lpFirst && (i > 0); i--, lpFirst++)
 768     {
 769         if (!strncmpW(lpFirst, lpSrch, len))
 770             return (LPWSTR)lpFirst;
 771     }
 772
 773     return NULL;
 774 }
 775
 776 /*************************************************************************
 777  * StrStrNIW    [SHLWAPI.@]
 778  *
 779  * Find a substring within a string up to a given number of initial characters,
 780  * ignoring case.
 781  *
 782  * PARAMS
 783  *  lpFirst    [I] String to search in
 784  *  lpSrch     [I] String to look for
 785  *  cchMax     [I] Maximum number of initial search characters
 786  *
 787  * RETURNS
 788  *  The start of lpFirst within lpSrch, or NULL if not found.
 789  */
 790 LPWSTR WINAPI StrStrNIW(LPCWSTR lpFirst, LPCWSTR lpSrch, UINT cchMax)
 791 {
 792     UINT i;
 793     int len;
 794
 795     TRACE("(%s, %s, %u)\n", debugstr_w(lpFirst), debugstr_w(lpSrch), cchMax);
 796
 797     if (!lpFirst || !lpSrch || !*lpSrch || !cchMax)
 798         return NULL;
 799
 800     len = strlenW(lpSrch);
 801
 802     for (i = cchMax; *lpFirst && (i > 0); i--, lpFirst++)
 803     {
 804         if (!strncmpiW(lpFirst, lpSrch, len))
 805             return (LPWSTR)lpFirst;
 806     }
 807
 808     return NULL;
 809 }
 810
 811 /*************************************************************************
 812  * StrToIntA    [SHLWAPI.@]
 813  *
 814  * Read a signed integer from a string.
 815  *
 816  * PARAMS
 817  *  lpszStr [I] String to read integer from
 818  *
 819  * RETURNS
 820  *   The signed integer value represented by the string, or 0 if no integer is
 821  *   present.
 822  *
 823  * NOTES
 824  *  No leading space is allowed before the number, although a leading '-' is.
 825  */
 826 int WINAPI StrToIntA(LPCSTR lpszStr)
 827 {
 828   int iRet = 0;
 829
 830   TRACE("(%s)\n", debugstr_a(lpszStr));
 831
 832   if (!lpszStr)
 833   {
 834     WARN("Invalid lpszStr would crash under Win32!\n");
 835     return 0;
 836   }
 837
 838   if (*lpszStr == '-' || isdigit(*lpszStr))
 839     StrToIntExA(lpszStr, 0, &iRet);
 840   return iRet;
 841 }
 842
 843 /*************************************************************************
 844  * StrToIntW    [SHLWAPI.@]
 845  *
 846  * See StrToIntA.
 847  */
 848 int WINAPI StrToIntW(LPCWSTR lpszStr)
 849 {
 850   int iRet = 0;
 851
 852   TRACE("(%s)\n", debugstr_w(lpszStr));
 853
 854   if (!lpszStr)
 855   {
 856     WARN("Invalid lpszStr would crash under Win32!\n");
 857     return 0;
 858   }
 859
 860   if (*lpszStr == '-' || isdigitW(*lpszStr))
 861     StrToIntExW(lpszStr, 0, &iRet);
 862   return iRet;
 863 }
 864
 865 /*************************************************************************
 866  * StrToIntExA  [SHLWAPI.@]
 867  *
 868  * Read an integer from a string.
 869  *
 870  * PARAMS
 871  *  lpszStr [I] String to read integer from
 872  *  dwFlags [I] Flags controlling the conversion
 873  *  lpiRet  [O] Destination for read integer.
 874  *
 875  * RETURNS
 876  *  Success: TRUE. lpiRet contains the integer value represented by the string.
 877  *  Failure: FALSE, if the string is invalid, or no number is present.
 878  *
 879  * NOTES
 880  *  Leading whitespace, '-' and '+' are allowed before the number. If
 881  *  dwFlags includes STIF_SUPPORT_HEX, hexadecimal numbers are allowed, if
 882  *  preceded by '0x'. If this flag is not set, or there is no '0x' prefix,
 883  *  the string is treated as a decimal string. A leading '-' is ignored for
 884  *  hexadecimal numbers.
 885  */
 886 BOOL WINAPI StrToIntExA(LPCSTR lpszStr, DWORD dwFlags, LPINT lpiRet)
 887 {
 888   LONGLONG li;
 889   BOOL bRes;
 890
 891   TRACE("(%s,%08X,%p)\n", debugstr_a(lpszStr), dwFlags, lpiRet);
 892
 893   bRes = StrToInt64ExA(lpszStr, dwFlags, &li);
 894   if (bRes) *lpiRet = li;
 895   return bRes;
 896 }
 897
 898 /*************************************************************************
 899  * StrToInt64ExA        [SHLWAPI.@]
 900  *
 901  * See StrToIntExA.
 902  */
 903 BOOL WINAPI StrToInt64ExA(LPCSTR lpszStr, DWORD dwFlags, LONGLONG *lpiRet)
 904 {
 905   BOOL bNegative = FALSE;
 906   LONGLONG iRet = 0;
 907
 908   TRACE("(%s,%08X,%p)\n", debugstr_a(lpszStr), dwFlags, lpiRet);
 909
 910   if (!lpszStr || !lpiRet)
 911   {
 912     WARN("Invalid parameter would crash under Win32!\n");
 913     return FALSE;
 914   }
 915   if (dwFlags > STIF_SUPPORT_HEX) WARN("Unknown flags %08x\n", dwFlags);
 916
 917   /* Skip leading space, '+', '-' */
 918   while (isspace(*lpszStr))
 919     lpszStr = CharNextA(lpszStr);
 920
 921   if (*lpszStr == '-')
 922   {
 923     bNegative = TRUE;
 924     lpszStr++;
 925   }
 926   else if (*lpszStr == '+')
 927     lpszStr++;
 928
 929   if (dwFlags & STIF_SUPPORT_HEX &&
 930       *lpszStr == '0' && tolower(lpszStr[1]) == 'x')
 931   {
 932     /* Read hex number */
 933     lpszStr += 2;
 934
 935     if (!isxdigit(*lpszStr))
 936       return FALSE;
 937
 938     while (isxdigit(*lpszStr))
 939     {
 940       iRet = iRet * 16;
 941       if (isdigit(*lpszStr))
 942         iRet += (*lpszStr - '0');
 943       else
 944         iRet += 10 + (tolower(*lpszStr) - 'a');
 945       lpszStr++;
 946     }
 947     *lpiRet = iRet;
 948     return TRUE;
 949   }
 950
 951   /* Read decimal number */
 952   if (!isdigit(*lpszStr))
 953     return FALSE;
 954
 955   while (isdigit(*lpszStr))
 956   {
 957     iRet = iRet * 10;
 958     iRet += (*lpszStr - '0');
 959     lpszStr++;
 960   }
 961   *lpiRet = bNegative ? -iRet : iRet;
 962   return TRUE;
 963 }
 964
 965 /*************************************************************************
 966  * StrToIntExW  [SHLWAPI.@]
 967  *
 968  * See StrToIntExA.
 969  */
 970 BOOL WINAPI StrToIntExW(LPCWSTR lpszStr, DWORD dwFlags, LPINT lpiRet)
 971 {
 972   LONGLONG li;
 973   BOOL bRes;
 974
 975   TRACE("(%s,%08X,%p)\n", debugstr_w(lpszStr), dwFlags, lpiRet);
 976
 977   bRes = StrToInt64ExW(lpszStr, dwFlags, &li);
 978   if (bRes) *lpiRet = li;
 979   return bRes;
 980 }
 981
 982 /*************************************************************************
 983  * StrToInt64ExW        [SHLWAPI.@]
 984  *
 985  * See StrToIntExA.
 986  */
 987 BOOL WINAPI StrToInt64ExW(LPCWSTR lpszStr, DWORD dwFlags, LONGLONG *lpiRet)
 988 {
 989   BOOL bNegative = FALSE;
 990   LONGLONG iRet = 0;
 991
 992   TRACE("(%s,%08X,%p)\n", debugstr_w(lpszStr), dwFlags, lpiRet);
 993
 994   if (!lpszStr || !lpiRet)
 995   {
 996     WARN("Invalid parameter would crash under Win32!\n");
 997     return FALSE;
 998   }
 999   if (dwFlags > STIF_SUPPORT_HEX) WARN("Unknown flags %08x\n", dwFlags);
1000
1001   /* Skip leading space, '+', '-' */
1002   while (isspaceW(*lpszStr)) lpszStr++;
1003
1004   if (*lpszStr == '-')
1005   {
1006     bNegative = TRUE;
1007     lpszStr++;
1008   }
1009   else if (*lpszStr == '+')
1010     lpszStr++;
1011
1012   if (dwFlags & STIF_SUPPORT_HEX &&
1013       *lpszStr == '0' && tolowerW(lpszStr[1]) == 'x')
1014   {
1015     /* Read hex number */
1016     lpszStr += 2;
1017
1018     if (!isxdigitW(*lpszStr))
1019       return FALSE;
1020
1021     while (isxdigitW(*lpszStr))
1022     {
1023       iRet = iRet * 16;
1024       if (isdigitW(*lpszStr))
1025         iRet += (*lpszStr - '0');
1026       else
1027         iRet += 10 + (tolowerW(*lpszStr) - 'a');
1028       lpszStr++;
1029     }
1030     *lpiRet = iRet;
1031     return TRUE;
1032   }
1033
1034   /* Read decimal number */
1035   if (!isdigitW(*lpszStr))
1036     return FALSE;
1037
1038   while (isdigitW(*lpszStr))
1039   {
1040     iRet = iRet * 10;
1041     iRet += (*lpszStr - '0');
1042     lpszStr++;
1043   }
1044   *lpiRet = bNegative ? -iRet : iRet;
1045   return TRUE;
1046 }
1047
1048 /*************************************************************************
1049  * StrDupA      [SHLWAPI.@]
1050  *
1051  * Duplicate a string.
1052  *
1053  * PARAMS
1054  *  lpszStr [I] String to duplicate.
1055  *
1056  * RETURNS
1057  *  Success: A pointer to a new string containing the contents of lpszStr
1058  *  Failure: NULL, if memory cannot be allocated
1059  *
1060  * NOTES
1061  *  The string memory is allocated with LocalAlloc(), and so should be released
1062  *  by calling LocalFree().
1063  */
1064 LPSTR WINAPI StrDupA(LPCSTR lpszStr)
1065 {
1066   int iLen;
1067   LPSTR lpszRet;
1068
1069   TRACE("(%s)\n",debugstr_a(lpszStr));
1070
1071   iLen = lpszStr ? strlen(lpszStr) + 1 : 1;
1072   lpszRet = LocalAlloc(LMEM_FIXED, iLen);
1073
1074   if (lpszRet)
1075   {
1076     if (lpszStr)
1077       memcpy(lpszRet, lpszStr, iLen);
1078     else
1079       *lpszRet = '\0';
1080   }
1081   return lpszRet;
1082 }
1083
1084 /*************************************************************************
1085  * StrDupW      [SHLWAPI.@]
1086  *
1087  * See StrDupA.
1088  */
1089 LPWSTR WINAPI StrDupW(LPCWSTR lpszStr)
1090 {
1091   int iLen;
1092   LPWSTR lpszRet;
1093
1094   TRACE("(%s)\n",debugstr_w(lpszStr));
1095
1096   iLen = (lpszStr ? strlenW(lpszStr) + 1 : 1) * sizeof(WCHAR);
1097   lpszRet = LocalAlloc(LMEM_FIXED, iLen);
1098
1099   if (lpszRet)
1100   {
1101     if (lpszStr)
1102       memcpy(lpszRet, lpszStr, iLen);
1103     else
1104       *lpszRet = '\0';
1105   }
1106   return lpszRet;
1107 }
1108
1109 /*************************************************************************
1110  * SHLWAPI_StrSpnHelperA
1111  *
1112  * Internal implementation of StrSpnA/StrCSpnA/StrCSpnIA
1113  */
1114 static int SHLWAPI_StrSpnHelperA(LPCSTR lpszStr, LPCSTR lpszMatch,
1115                                  LPSTR (WINAPI *pStrChrFn)(LPCSTR,WORD),
1116                                  BOOL bInvert)
1117 {
1118   LPCSTR lpszRead = lpszStr;
1119   if (lpszStr && *lpszStr && lpszMatch)
1120   {
1121     while (*lpszRead)
1122     {
1123       LPCSTR lpszTest = pStrChrFn(lpszMatch, *lpszRead);
1124
1125       if (!bInvert && !lpszTest)
1126         break;
1127       if (bInvert && lpszTest)
1128         break;
1129       lpszRead = CharNextA(lpszRead);
1130     };
1131   }
1132   return lpszRead - lpszStr;
1133 }
1134
1135 /*************************************************************************
1136  * StrSpnA      [SHLWAPI.@]
1137  *
1138  * Find the length of the start of a string that contains only certain
1139  * characters.
1140  *
1141  * PARAMS
1142  *  lpszStr   [I] String to search
1143  *  lpszMatch [I] Characters that can be in the substring
1144  *
1145  * RETURNS
1146  *  The length of the part of lpszStr containing only chars from lpszMatch,
1147  *  or 0 if any parameter is invalid.
1148  */
1149 int WINAPI StrSpnA(LPCSTR lpszStr, LPCSTR lpszMatch)
1150 {
1151   TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
1152
1153   return SHLWAPI_StrSpnHelperA(lpszStr, lpszMatch, StrChrA, FALSE);
1154 }
1155
1156 /*************************************************************************
1157  * StrSpnW      [SHLWAPI.@]
1158  *
1159  * See StrSpnA.
1160  */
1161 int WINAPI StrSpnW(LPCWSTR lpszStr, LPCWSTR lpszMatch)
1162 {
1163     if (!lpszStr || !lpszMatch) return 0;
1164     return strspnW( lpszStr, lpszMatch );
1165 }
1166
1167 /*************************************************************************
1168  * StrCSpnA     [SHLWAPI.@]
1169  *
1170  * Find the length of the start of a string that does not contain certain
1171  * characters.
1172  *
1173  * PARAMS
1174  *  lpszStr   [I] String to search
1175  *  lpszMatch [I] Characters that cannot be in the substring
1176  *
1177  * RETURNS
1178  *  The length of the part of lpszStr containing only chars not in lpszMatch,
1179  *  or 0 if any parameter is invalid.
1180  */
1181 int WINAPI StrCSpnA(LPCSTR lpszStr, LPCSTR lpszMatch)
1182 {
1183   TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
1184
1185   return SHLWAPI_StrSpnHelperA(lpszStr, lpszMatch, StrChrA, TRUE);
1186 }
1187
1188 /*************************************************************************
1189  * StrCSpnW     [SHLWAPI.@]
1190  *
1191  * See StrCSpnA.
1192  */
1193 int WINAPI StrCSpnW(LPCWSTR lpszStr, LPCWSTR lpszMatch)
1194 {
1195     if (!lpszStr || !lpszMatch) return 0;
1196     return strcspnW( lpszStr, lpszMatch );
1197 }
1198
1199 /*************************************************************************
1200  * StrCSpnIA    [SHLWAPI.@]
1201  *
1202  * Find the length of the start of a string that does not contain certain
1203  * characters, ignoring case.
1204  *
1205  * PARAMS
1206  *  lpszStr   [I] String to search
1207  *  lpszMatch [I] Characters that cannot be in the substring
1208  *
1209  * RETURNS
1210  *  The length of the part of lpszStr containing only chars not in lpszMatch,
1211  *  or 0 if any parameter is invalid.
1212  */
1213 int WINAPI StrCSpnIA(LPCSTR lpszStr, LPCSTR lpszMatch)
1214 {
1215   TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
1216
1217   return SHLWAPI_StrSpnHelperA(lpszStr, lpszMatch, StrChrIA, TRUE);
1218 }
1219
1220 /*************************************************************************
1221  * StrCSpnIW    [SHLWAPI.@]
1222  *
1223  * See StrCSpnIA.
1224  */
1225 int WINAPI StrCSpnIW(LPCWSTR lpszStr, LPCWSTR lpszMatch)
1226 {
1227   LPCWSTR lpszRead = lpszStr;
1228
1229   TRACE("(%s,%s)\n",debugstr_w(lpszStr), debugstr_w(lpszMatch));
1230
1231   if (lpszStr && *lpszStr && lpszMatch)
1232   {
1233     while (*lpszRead)
1234     {
1235       if (StrChrIW(lpszMatch, *lpszRead)) break;
1236       lpszRead++;
1237     }
1238   }
1239   return lpszRead - lpszStr;
1240 }
1241
1242 /*************************************************************************
1243  * StrPBrkA     [SHLWAPI.@]
1244  *
1245  * Search a string for any of a group of characters.
1246  *
1247  * PARAMS
1248  *  lpszStr   [I] String to search
1249  *  lpszMatch [I] Characters to match
1250  *
1251  * RETURNS
1252  *  A pointer to the first matching character in lpszStr, or NULL if no
1253  *  match was found.
1254  */
1255 LPSTR WINAPI StrPBrkA(LPCSTR lpszStr, LPCSTR lpszMatch)
1256 {
1257   TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
1258
1259   if (lpszStr && lpszMatch && *lpszMatch)
1260   {
1261     while (*lpszStr)
1262     {
1263       if (StrChrA(lpszMatch, *lpszStr))
1264         return (LPSTR)lpszStr;
1265       lpszStr = CharNextA(lpszStr);
1266     }
1267   }
1268   return NULL;
1269 }
1270
1271 /*************************************************************************
1272  * StrPBrkW     [SHLWAPI.@]
1273  *
1274  * See StrPBrkA.
1275  */
1276 LPWSTR WINAPI StrPBrkW(LPCWSTR lpszStr, LPCWSTR lpszMatch)
1277 {
1278     if (!lpszStr || !lpszMatch) return NULL;
1279     return strpbrkW( lpszStr, lpszMatch );
1280 }
1281
1282 /*************************************************************************
1283  * SHLWAPI_StrRChrHelperA
1284  *
1285  * Internal implementation of StrRChrA/StrRChrIA.
1286  */
1287 static LPSTR SHLWAPI_StrRChrHelperA(LPCSTR lpszStr,
1288                                     LPCSTR lpszEnd, WORD ch,
1289                                     BOOL (WINAPI *pChrCmpFn)(WORD,WORD))
1290 {
1291   LPCSTR lpszRet = NULL;
1292
1293   if (lpszStr)
1294   {
1295     WORD ch2;
1296
1297     if (!lpszEnd)
1298       lpszEnd = lpszStr + lstrlenA(lpszStr);
1299
1300     while (*lpszStr && lpszStr <= lpszEnd)
1301     {
1302       ch2 = IsDBCSLeadByte(*lpszStr)? *lpszStr << 8 | lpszStr[1] : *lpszStr;
1303
1304       if (!pChrCmpFn(ch, ch2))
1305         lpszRet = lpszStr;
1306       lpszStr = CharNextA(lpszStr);
1307     }
1308   }
1309   return (LPSTR)lpszRet;
1310 }
1311
1312 /**************************************************************************
1313  * StrRChrA     [SHLWAPI.@]
1314  *
1315  * Find the last occurrence of a character in string.
1316  *
1317  * PARAMS
1318  *  lpszStr [I] String to search in
1319  *  lpszEnd [I] Place to end search, or NULL to search until the end of lpszStr
1320  *  ch      [I] Character to search for.
1321  *
1322  * RETURNS
1323  *  Success: A pointer to the last occurrence of ch in lpszStr before lpszEnd,
1324  *           or NULL if not found.
1325  *  Failure: NULL, if any arguments are invalid.
1326  */
1327 LPSTR WINAPI StrRChrA(LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch)
1328 {
1329   TRACE("(%s,%s,%x)\n", debugstr_a(lpszStr), debugstr_a(lpszEnd), ch);
1330
1331   return SHLWAPI_StrRChrHelperA(lpszStr, lpszEnd, ch, SHLWAPI_ChrCmpA);
1332 }
1333
1334 /**************************************************************************
1335  * StrRChrW     [SHLWAPI.@]
1336  *
1337  * See StrRChrA.
1338  */
1339 LPWSTR WINAPI StrRChrW(LPCWSTR str, LPCWSTR end, WORD ch)
1340 {
1341     WCHAR *ret = NULL;
1342
1343     if (!str) return NULL;
1344     if (!end) end = str + strlenW(str);
1345     while (str < end)
1346     {
1347         if (*str == ch) ret = (WCHAR *)str;
1348         str++;
1349     }
1350     return ret;
1351 }
1352
1353 /**************************************************************************
1354  * StrRChrIA    [SHLWAPI.@]
1355  *
1356  * Find the last occurrence of a character in string, ignoring case.
1357  *
1358  * PARAMS
1359  *  lpszStr [I] String to search in
1360  *  lpszEnd [I] Place to end search, or NULL to search until the end of lpszStr
1361  *  ch      [I] Character to search for.
1362  *
1363  * RETURNS
1364  *  Success: A pointer to the last occurrence of ch in lpszStr before lpszEnd,
1365  *           or NULL if not found.
1366  *  Failure: NULL, if any arguments are invalid.
1367  */
1368 LPSTR WINAPI StrRChrIA(LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch)
1369 {
1370   TRACE("(%s,%s,%x)\n", debugstr_a(lpszStr), debugstr_a(lpszEnd), ch);
1371
1372   return SHLWAPI_StrRChrHelperA(lpszStr, lpszEnd, ch, ChrCmpIA);
1373 }
1374
1375 /**************************************************************************
1376  * StrRChrIW    [SHLWAPI.@]
1377  *
1378  * See StrRChrIA.
1379  */
1380 LPWSTR WINAPI StrRChrIW(LPCWSTR str, LPCWSTR end, WORD ch)
1381 {
1382     WCHAR *ret = NULL;
1383
1384     if (!str) return NULL;
1385     if (!end) end = str + strlenW(str);
1386     while (str < end)
1387     {
1388         if (!ChrCmpIW(*str, ch)) ret = (WCHAR *)str;
1389         str++;
1390     }
1391     return ret;
1392 }
1393
1394 /*************************************************************************
1395  * StrCatBuffA  [SHLWAPI.@]
1396  *
1397  * Concatenate two strings together.
1398  *
1399  * PARAMS
1400  *  lpszStr [O] String to concatenate to
1401  *  lpszCat [I] String to add to lpszCat
1402  *  cchMax  [I] Maximum number of characters for the whole string
1403  *
1404  * RETURNS
1405  *  lpszStr.
1406  *
1407  * NOTES
1408  *  cchMax determines the number of characters in the final length of the
1409  *  string, not the number appended to lpszStr from lpszCat.
1410  */
1411 LPSTR WINAPI StrCatBuffA(LPSTR lpszStr, LPCSTR lpszCat, INT cchMax)
1412 {
1413   INT iLen;
1414
1415   TRACE("(%p,%s,%d)\n", lpszStr, debugstr_a(lpszCat), cchMax);
1416
1417   if (!lpszStr)
1418   {
1419     WARN("Invalid lpszStr would crash under Win32!\n");
1420     return NULL;
1421   }
1422
1423   iLen = strlen(lpszStr);
1424   cchMax -= iLen;
1425
1426   if (cchMax > 0)
1427     StrCpyNA(lpszStr + iLen, lpszCat, cchMax);
1428   return lpszStr;
1429 }
1430
1431 /*************************************************************************
1432  * StrCatBuffW  [SHLWAPI.@]
1433  *
1434  * See StrCatBuffA.
1435  */
1436 LPWSTR WINAPI StrCatBuffW(LPWSTR lpszStr, LPCWSTR lpszCat, INT cchMax)
1437 {
1438   INT iLen;
1439
1440   TRACE("(%p,%s,%d)\n", lpszStr, debugstr_w(lpszCat), cchMax);
1441
1442   if (!lpszStr)
1443   {
1444     WARN("Invalid lpszStr would crash under Win32!\n");
1445     return NULL;
1446   }
1447
1448   iLen = strlenW(lpszStr);
1449   cchMax -= iLen;
1450
1451   if (cchMax > 0)
1452     StrCpyNW(lpszStr + iLen, lpszCat, cchMax);
1453   return lpszStr;
1454 }
1455
1456 /*************************************************************************
1457  * StrRetToBufA                                 [SHLWAPI.@]
1458  *
1459  * Convert a STRRET to a normal string.
1460  *
1461  * PARAMS
1462  *  lpStrRet [O] STRRET to convert
1463  *  pIdl     [I] ITEMIDLIST for lpStrRet->uType == STRRET_OFFSET
1464  *  lpszDest [O] Destination for normal string
1465  *  dwLen    [I] Length of lpszDest
1466  *
1467  * RETURNS
1468  *  Success: S_OK. lpszDest contains up to dwLen characters of the string.
1469  *           If lpStrRet is of type STRRET_WSTR, its memory is freed with
1470  *           CoTaskMemFree() and its type set to STRRET_CSTRA.
1471  *  Failure: E_FAIL, if any parameters are invalid.
1472  */
1473 HRESULT WINAPI StrRetToBufA (LPSTRRET src, const ITEMIDLIST *pidl, LPSTR dest, UINT len)
1474 {
1475         /* NOTE:
1476          *  This routine is identical to that in dlls/shell32/shellstring.c.
1477          *  It was duplicated because not every version of Shlwapi.dll exports
1478          *  StrRetToBufA. If you change one routine, change them both.
1479          */
1480         TRACE("dest=%p len=0x%x strret=%p pidl=%p\n", dest, len, src, pidl);
1481
1482         if (!src)
1483         {
1484           WARN("Invalid lpStrRet would crash under Win32!\n");
1485           if (dest)
1486             *dest = '\0';
1487           return E_FAIL;
1488         }
1489
1490         if (!dest || !len)
1491           return E_FAIL;
1492
1493         *dest = '\0';
1494
1495         switch (src->uType)
1496         {
1497           case STRRET_WSTR:
1498             WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, dest, len, NULL, NULL);
1499             CoTaskMemFree(src->u.pOleStr);
1500             break;
1501
1502           case STRRET_CSTR:
1503             lstrcpynA(dest, src->u.cStr, len);
1504             break;
1505
1506           case STRRET_OFFSET:
1507             lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
1508             break;
1509
1510           default:
1511             FIXME("unknown type!\n");
1512             return E_NOTIMPL;
1513         }
1514         return S_OK;
1515 }
1516
1517 /*************************************************************************
1518  * StrRetToBufW [SHLWAPI.@]
1519  *
1520  * See StrRetToBufA.
1521  */
1522 HRESULT WINAPI StrRetToBufW (LPSTRRET src, const ITEMIDLIST *pidl, LPWSTR dest, UINT len)
1523 {
1524     TRACE("dest=%p len=0x%x strret=%p pidl=%p\n", dest, len, src, pidl);
1525
1526     if (!dest || !len)
1527         return E_FAIL;
1528
1529     if (!src)
1530     {
1531         WARN("Invalid lpStrRet would crash under Win32!\n");
1532         if (dest)
1533             *dest = '\0';
1534         return E_FAIL;
1535     }
1536
1537     *dest = '\0';
1538
1539     switch (src->uType) {
1540     case STRRET_WSTR: {
1541         size_t dst_len;
1542         if (!src->u.pOleStr)
1543             return E_FAIL;
1544         dst_len = strlenW(src->u.pOleStr);
1545         memcpy(dest, src->u.pOleStr, min(dst_len, len-1) * sizeof(WCHAR));
1546         dest[min(dst_len, len-1)] = 0;
1547         CoTaskMemFree(src->u.pOleStr);
1548         if (len <= dst_len)
1549         {
1550             dest[0] = 0;
1551             return E_NOT_SUFFICIENT_BUFFER;
1552         }
1553         break;
1554     }
1555
1556     case STRRET_CSTR:
1557         if (!MultiByteToWideChar( CP_ACP, 0, src->u.cStr, -1, dest, len ))
1558             dest[len-1] = 0;
1559         break;
1560
1561     case STRRET_OFFSET:
1562         if (pidl)
1563         {
1564             if (!MultiByteToWideChar( CP_ACP, 0, ((LPCSTR)&pidl->mkid)+src->u.uOffset, -1,
1565                                       dest, len ))
1566                 dest[len-1] = 0;
1567         }
1568         break;
1569
1570     default:
1571         FIXME("unknown type!\n");
1572         return E_NOTIMPL;
1573     }
1574
1575     return S_OK;
1576 }
1577
1578 /*************************************************************************
1579  * StrRetToStrA                                 [SHLWAPI.@]
1580  *
1581  * Converts a STRRET to a normal string.
1582  *
1583  * PARAMS
1584  *  lpStrRet [O] STRRET to convert
1585  *  pidl     [I] ITEMIDLIST for lpStrRet->uType == STRRET_OFFSET
1586  *  ppszName [O] Destination for converted string
1587  *
1588  * RETURNS
1589  *  Success: S_OK. ppszName contains the new string, allocated with CoTaskMemAlloc().
1590  *  Failure: E_FAIL, if any parameters are invalid.
1591  */
1592 HRESULT WINAPI StrRetToStrA(LPSTRRET lpStrRet, const ITEMIDLIST *pidl, LPSTR *ppszName)
1593 {
1594   HRESULT hRet = E_FAIL;
1595
1596   switch (lpStrRet->uType)
1597   {
1598   case STRRET_WSTR:
1599     hRet = _SHStrDupAW(lpStrRet->u.pOleStr, ppszName);
1600     CoTaskMemFree(lpStrRet->u.pOleStr);
1601     break;
1602
1603   case STRRET_CSTR:
1604     hRet = _SHStrDupAA(lpStrRet->u.cStr, ppszName);
1605     break;
1606
1607   case STRRET_OFFSET:
1608     hRet = _SHStrDupAA(((LPCSTR)&pidl->mkid) + lpStrRet->u.uOffset, ppszName);
1609     break;
1610
1611   default:
1612     *ppszName = NULL;
1613   }
1614
1615   return hRet;
1616 }
1617
1618 /*************************************************************************
1619  * StrRetToStrW                                 [SHLWAPI.@]
1620  *
1621  * See StrRetToStrA.
1622  */
1623 HRESULT WINAPI StrRetToStrW(LPSTRRET lpStrRet, const ITEMIDLIST *pidl, LPWSTR *ppszName)
1624 {
1625   HRESULT hRet = E_FAIL;
1626
1627   switch (lpStrRet->uType)
1628   {
1629   case STRRET_WSTR:
1630     hRet = SHStrDupW(lpStrRet->u.pOleStr, ppszName);
1631     CoTaskMemFree(lpStrRet->u.pOleStr);
1632     break;
1633
1634   case STRRET_CSTR:
1635     hRet = SHStrDupA(lpStrRet->u.cStr, ppszName);
1636     break;
1637
1638   case STRRET_OFFSET:
1639     hRet = SHStrDupA(((LPCSTR)&pidl->mkid) + lpStrRet->u.uOffset, ppszName);
1640     break;
1641
1642   default:
1643     *ppszName = NULL;
1644   }
1645
1646   return hRet;
1647 }
1648
1649 /* Create an ASCII string copy using SysAllocString() */
1650 static HRESULT _SHStrDupAToBSTR(LPCSTR src, BSTR *pBstrOut)
1651 {
1652     *pBstrOut = NULL;
1653
1654     if (src)
1655     {
1656         INT len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
1657         WCHAR* szTemp = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1658
1659         if (szTemp)
1660         {
1661             MultiByteToWideChar(CP_ACP, 0, src, -1, szTemp, len);
1662             *pBstrOut = SysAllocString(szTemp);
1663             HeapFree(GetProcessHeap(), 0, szTemp);
1664
1665             if (*pBstrOut)
1666                 return S_OK;
1667         }
1668     }
1669     return E_OUTOFMEMORY;
1670 }
1671
1672 /*************************************************************************
1673  * StrRetToBSTR [SHLWAPI.@]
1674  *
1675  * Converts a STRRET to a BSTR.
1676  *
1677  * PARAMS
1678  *  lpStrRet [O] STRRET to convert
1679  *  pidl     [I] ITEMIDLIST for lpStrRet->uType = STRRET_OFFSET
1680  *  pBstrOut [O] Destination for converted BSTR
1681  *
1682  * RETURNS
1683  *  Success: S_OK. pBstrOut contains the new string.
1684  *  Failure: E_FAIL, if any parameters are invalid.
1685  */
1686 HRESULT WINAPI StrRetToBSTR(STRRET *lpStrRet, LPCITEMIDLIST pidl, BSTR* pBstrOut)
1687 {
1688   HRESULT hRet = E_FAIL;
1689
1690   switch (lpStrRet->uType)
1691   {
1692   case STRRET_WSTR:
1693     *pBstrOut = SysAllocString(lpStrRet->u.pOleStr);
1694     if (*pBstrOut)
1695       hRet = S_OK;
1696     CoTaskMemFree(lpStrRet->u.pOleStr);
1697     break;
1698
1699   case STRRET_CSTR:
1700     hRet = _SHStrDupAToBSTR(lpStrRet->u.cStr, pBstrOut);
1701     break;
1702
1703   case STRRET_OFFSET:
1704     hRet = _SHStrDupAToBSTR(((LPCSTR)&pidl->mkid) + lpStrRet->u.uOffset, pBstrOut);
1705     break;
1706
1707   default:
1708     *pBstrOut = NULL;
1709   }
1710
1711   return hRet;
1712 }
1713
1714 /*************************************************************************
1715  * StrFormatKBSizeA     [SHLWAPI.@]
1716  *
1717  * Create a formatted string containing a byte count in Kilobytes.
1718  *
1719  * PARAMS
1720  *  llBytes  [I] Byte size to format
1721  *  lpszDest [I] Destination for formatted string
1722  *  cchMax   [I] Size of lpszDest
1723  *
1724  * RETURNS
1725  *  lpszDest.
1726  */
1727 LPSTR WINAPI StrFormatKBSizeA(LONGLONG llBytes, LPSTR lpszDest, UINT cchMax)
1728 {
1729   WCHAR wszBuf[256];
1730
1731   if (!StrFormatKBSizeW(llBytes, wszBuf, 256))
1732     return NULL;
1733   if (!WideCharToMultiByte(CP_ACP, 0, wszBuf, -1, lpszDest, cchMax, NULL, NULL))
1734     return NULL;
1735   return lpszDest;
1736 }
1737
1738 /*************************************************************************
1739  * StrFormatKBSizeW     [SHLWAPI.@]
1740  *
1741  * See StrFormatKBSizeA.
1742  */
1743 LPWSTR WINAPI StrFormatKBSizeW(LONGLONG llBytes, LPWSTR lpszDest, UINT cchMax)
1744 {
1745   static const WCHAR kb[] = {' ','K','B',0};
1746   LONGLONG llKB = (llBytes + 1023) >> 10;
1747   int len;
1748
1749   TRACE("(0x%s,%p,%d)\n", wine_dbgstr_longlong(llBytes), lpszDest, cchMax);
1750
1751   if (!FormatInt(llKB, lpszDest, cchMax))
1752     return NULL;
1753
1754   len = lstrlenW(lpszDest);
1755   if (cchMax - len < 4)
1756       return NULL;
1757   lstrcatW(lpszDest, kb);
1758   return lpszDest;
1759 }
1760
1761 /*************************************************************************
1762  * StrNCatA     [SHLWAPI.@]
1763  *
1764  * Concatenate two strings together.
1765  *
1766  * PARAMS
1767  *  lpszStr [O] String to concatenate to
1768  *  lpszCat [I] String to add to lpszCat
1769  *  cchMax  [I] Maximum number of characters to concatenate
1770  *
1771  * RETURNS
1772  *  lpszStr.
1773  *
1774  * NOTES
1775  *  cchMax determines the number of characters that are appended to lpszStr,
1776  *  not the total length of the string.
1777  */
1778 LPSTR WINAPI StrNCatA(LPSTR lpszStr, LPCSTR lpszCat, INT cchMax)
1779 {
1780   LPSTR lpszRet = lpszStr;
1781
1782   TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszCat), cchMax);
1783
1784   if (!lpszStr)
1785   {
1786     WARN("Invalid lpszStr would crash under Win32!\n");
1787     return NULL;
1788   }
1789
1790   StrCpyNA(lpszStr + strlen(lpszStr), lpszCat, cchMax);
1791   return lpszRet;
1792 }
1793
1794 /*************************************************************************
1795  * StrNCatW     [SHLWAPI.@]
1796  *
1797  * See StrNCatA.
1798  */
1799 LPWSTR WINAPI StrNCatW(LPWSTR lpszStr, LPCWSTR lpszCat, INT cchMax)
1800 {
1801   LPWSTR lpszRet = lpszStr;
1802
1803   TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszCat), cchMax);
1804
1805   if (!lpszStr)
1806   {
1807     WARN("Invalid lpszStr would crash under Win32\n");
1808     return NULL;
1809   }
1810
1811   StrCpyNW(lpszStr + strlenW(lpszStr), lpszCat, cchMax);
1812   return lpszRet;
1813 }
1814
1815 /*************************************************************************
1816  * StrTrimA     [SHLWAPI.@]
1817  *
1818  * Remove characters from the start and end of a string.
1819  *
1820  * PARAMS
1821  *  lpszStr  [O] String to remove characters from
1822  *  lpszTrim [I] Characters to remove from lpszStr
1823  *
1824  * RETURNS
1825  *  TRUE  If lpszStr was valid and modified
1826  *  FALSE Otherwise
1827  */
1828 BOOL WINAPI StrTrimA(LPSTR lpszStr, LPCSTR lpszTrim)
1829 {
1830   DWORD dwLen;
1831   LPSTR lpszRead = lpszStr;
1832   BOOL bRet = FALSE;
1833
1834   TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszTrim));
1835
1836   if (lpszRead && *lpszRead)
1837   {
1838     while (*lpszRead && StrChrA(lpszTrim, *lpszRead))
1839       lpszRead = CharNextA(lpszRead); /* Skip leading matches */
1840
1841     dwLen = strlen(lpszRead);
1842
1843     if (lpszRead != lpszStr)
1844     {
1845       memmove(lpszStr, lpszRead, dwLen + 1);
1846       bRet = TRUE;
1847     }
1848     if (dwLen > 0)
1849     {
1850       lpszRead = lpszStr + dwLen;
1851       while (StrChrA(lpszTrim, lpszRead[-1]))
1852         lpszRead = CharPrevA(lpszStr, lpszRead); /* Skip trailing matches */
1853
1854       if (lpszRead != lpszStr + dwLen)
1855       {
1856         *lpszRead = '\0';
1857         bRet = TRUE;
1858       }
1859     }
1860   }
1861   return bRet;
1862 }
1863
1864 /*************************************************************************
1865  * StrTrimW     [SHLWAPI.@]
1866  *
1867  * See StrTrimA.
1868  */
1869 BOOL WINAPI StrTrimW(LPWSTR lpszStr, LPCWSTR lpszTrim)
1870 {
1871   DWORD dwLen;
1872   LPWSTR lpszRead = lpszStr;
1873   BOOL bRet = FALSE;
1874
1875   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszTrim));
1876
1877   if (lpszRead && *lpszRead)
1878   {
1879     while (*lpszRead && StrChrW(lpszTrim, *lpszRead)) lpszRead++;
1880
1881     dwLen = strlenW(lpszRead);
1882
1883     if (lpszRead != lpszStr)
1884     {
1885       memmove(lpszStr, lpszRead, (dwLen + 1) * sizeof(WCHAR));
1886       bRet = TRUE;
1887     }
1888     if (dwLen > 0)
1889     {
1890       lpszRead = lpszStr + dwLen;
1891       while (StrChrW(lpszTrim, lpszRead[-1]))
1892         lpszRead--; /* Skip trailing matches */
1893
1894       if (lpszRead != lpszStr + dwLen)
1895       {
1896         *lpszRead = '\0';
1897         bRet = TRUE;
1898       }
1899     }
1900   }
1901   return bRet;
1902 }
1903
1904 /*************************************************************************
1905  *      _SHStrDupAA     [INTERNAL]
1906  *
1907  * Duplicates a ASCII string to ASCII. The destination buffer is allocated.
1908  */
1909 static HRESULT _SHStrDupAA(LPCSTR src, LPSTR * dest)
1910 {
1911         HRESULT hr;
1912         int len = 0;
1913
1914         if (src) {
1915             len = lstrlenA(src) + 1;
1916             *dest = CoTaskMemAlloc(len);
1917         } else {
1918             *dest = NULL;
1919         }
1920
1921         if (*dest) {
1922             lstrcpynA(*dest,src, len);
1923             hr = S_OK;
1924         } else {
1925             hr = E_OUTOFMEMORY;
1926         }
1927
1928         TRACE("%s->(%p)\n", debugstr_a(src), *dest);
1929         return hr;
1930 }
1931
1932 /*************************************************************************
1933  * SHStrDupA    [SHLWAPI.@]
1934  *
1935  * Return a Unicode copy of a string, in memory allocated by CoTaskMemAlloc().
1936  *
1937  * PARAMS
1938  *  lpszStr   [I] String to copy
1939  *  lppszDest [O] Destination for the new string copy
1940  *
1941  * RETURNS
1942  *  Success: S_OK. lppszDest contains the new string in Unicode format.
1943  *  Failure: E_OUTOFMEMORY, If any arguments are invalid or memory allocation
1944  *           fails.
1945  */
1946 HRESULT WINAPI SHStrDupA(LPCSTR lpszStr, LPWSTR * lppszDest)
1947 {
1948   HRESULT hRet;
1949   int len = 0;
1950
1951   if (lpszStr)
1952   {
1953     len = MultiByteToWideChar(CP_ACP, 0, lpszStr, -1, NULL, 0) * sizeof(WCHAR);
1954     *lppszDest = CoTaskMemAlloc(len);
1955   }
1956   else
1957     *lppszDest = NULL;
1958
1959   if (*lppszDest)
1960   {
1961     MultiByteToWideChar(CP_ACP, 0, lpszStr, -1, *lppszDest, len/sizeof(WCHAR));
1962     hRet = S_OK;
1963   }
1964   else
1965     hRet = E_OUTOFMEMORY;
1966
1967   TRACE("%s->(%p)\n", debugstr_a(lpszStr), *lppszDest);
1968   return hRet;
1969 }
1970
1971 /*************************************************************************
1972  *      _SHStrDupAW     [INTERNAL]
1973  *
1974  * Duplicates a UNICODE to a ASCII string. The destination buffer is allocated.
1975  */
1976 static HRESULT _SHStrDupAW(LPCWSTR src, LPSTR * dest)
1977 {
1978         HRESULT hr;
1979         int len = 0;
1980
1981         if (src) {
1982             len = WideCharToMultiByte(CP_ACP, 0, src, -1, NULL, 0, NULL, NULL);
1983             *dest = CoTaskMemAlloc(len);
1984         } else {
1985             *dest = NULL;
1986         }
1987
1988         if (*dest) {
1989             WideCharToMultiByte(CP_ACP, 0, src, -1, *dest, len, NULL, NULL);
1990             hr = S_OK;
1991         } else {
1992             hr = E_OUTOFMEMORY;
1993         }
1994
1995         TRACE("%s->(%p)\n", debugstr_w(src), *dest);
1996         return hr;
1997 }
1998
1999 /*************************************************************************
2000  * SHStrDupW    [SHLWAPI.@]
2001  *
2002  * See SHStrDupA.
2003  */
2004 HRESULT WINAPI SHStrDupW(LPCWSTR src, LPWSTR * dest)
2005 {
2006         HRESULT hr;
2007         int len = 0;
2008
2009         if (src) {
2010             len = (lstrlenW(src) + 1) * sizeof(WCHAR);
2011             *dest = CoTaskMemAlloc(len);
2012         } else {
2013             *dest = NULL;
2014         }
2015
2016         if (*dest) {
2017             memcpy(*dest, src, len);
2018             hr = S_OK;
2019         } else {
2020             hr = E_OUTOFMEMORY;
2021         }
2022
2023         TRACE("%s->(%p)\n", debugstr_w(src), *dest);
2024         return hr;
2025 }
2026
2027 /*************************************************************************
2028  * SHLWAPI_WriteReverseNum
2029  *
2030  * Internal helper for SHLWAPI_WriteTimeClass.
2031  */
2032 static inline LPWSTR SHLWAPI_WriteReverseNum(LPWSTR lpszOut, DWORD dwNum)
2033 {
2034   *lpszOut-- = '\0';
2035
2036   /* Write a decimal number to a string, backwards */
2037   do
2038   {
2039     DWORD dwNextDigit = dwNum % 10;
2040     *lpszOut-- = '0' + dwNextDigit;
2041     dwNum = (dwNum - dwNextDigit) / 10;
2042   } while (dwNum > 0);
2043
2044   return lpszOut;
2045 }
2046
2047 /*************************************************************************
2048  * SHLWAPI_FormatSignificant
2049  *
2050  * Internal helper for SHLWAPI_WriteTimeClass.
2051  */
2052 static inline int SHLWAPI_FormatSignificant(LPWSTR lpszNum, int dwDigits)
2053 {
2054   /* Zero non significant digits, return remaining significant digits */
2055   while (*lpszNum)
2056   {
2057     lpszNum++;
2058     if (--dwDigits == 0)
2059     {
2060       while (*lpszNum)
2061         *lpszNum++ = '0';
2062       return 0;
2063     }
2064   }
2065   return dwDigits;
2066 }
2067
2068 /*************************************************************************
2069  * SHLWAPI_WriteTimeClass
2070  *
2071  * Internal helper for StrFromTimeIntervalW.
2072  */
2073 static int SHLWAPI_WriteTimeClass(LPWSTR lpszOut, DWORD dwValue,
2074                                   UINT uClassStringId, int iDigits)
2075 {
2076   WCHAR szBuff[64], *szOut = szBuff + 32;
2077
2078   szOut = SHLWAPI_WriteReverseNum(szOut, dwValue);
2079   iDigits = SHLWAPI_FormatSignificant(szOut + 1, iDigits);
2080   *szOut = ' ';
2081   LoadStringW(shlwapi_hInstance, uClassStringId, szBuff + 32, 32);
2082   strcatW(lpszOut, szOut);
2083   return iDigits;
2084 }
2085
2086 /*************************************************************************
2087  * StrFromTimeIntervalA [SHLWAPI.@]
2088  *
2089  * Format a millisecond time interval into a string
2090  *
2091  * PARAMS
2092  *  lpszStr  [O] Output buffer for formatted time interval
2093  *  cchMax   [I] Size of lpszStr
2094  *  dwMS     [I] Number of milliseconds
2095  *  iDigits  [I] Number of digits to print
2096  *
2097  * RETURNS
2098  *  The length of the formatted string, or 0 if any parameter is invalid.
2099  *
2100  * NOTES
2101  *  This implementation mimics the Win32 behaviour of always writing a leading
2102  *  space before the time interval begins.
2103  *
2104  *  iDigits is used to provide approximate times if accuracy is not important.
2105  *  This number of digits will be written of the first non-zero time class
2106  *  (hours/minutes/seconds). If this does not complete the time classification,
2107  *  the remaining digits are changed to zeros (i.e. The time is _not_ rounded).
2108  *  If there are digits remaining following the writing of a time class, the
2109  *  next time class will be written.
2110  *
2111  *  For example, given dwMS represents 138 hours,43 minutes and 15 seconds, the
2112  *  following will result from the given values of iDigits:
2113  *
2114  *|  iDigits    1        2        3        4               5               ...
2115  *|  lpszStr   "100 hr" "130 hr" "138 hr" "138 hr 40 min" "138 hr 43 min"  ...
2116  */
2117 INT WINAPI StrFromTimeIntervalA(LPSTR lpszStr, UINT cchMax, DWORD dwMS,
2118                                 int iDigits)
2119 {
2120   INT iRet = 0;
2121
2122   TRACE("(%p,%d,%d,%d)\n", lpszStr, cchMax, dwMS, iDigits);
2123
2124   if (lpszStr && cchMax)
2125   {
2126     WCHAR szBuff[128];
2127     StrFromTimeIntervalW(szBuff, sizeof(szBuff)/sizeof(WCHAR), dwMS, iDigits);
2128     WideCharToMultiByte(CP_ACP,0,szBuff,-1,lpszStr,cchMax,0,0);
2129   }
2130   return iRet;
2131 }
2132
2133
2134 /*************************************************************************
2135  * StrFromTimeIntervalW [SHLWAPI.@]
2136  *
2137  * See StrFromTimeIntervalA.
2138  */
2139 INT WINAPI StrFromTimeIntervalW(LPWSTR lpszStr, UINT cchMax, DWORD dwMS,
2140                                 int iDigits)
2141 {
2142   INT iRet = 0;
2143
2144   TRACE("(%p,%d,%d,%d)\n", lpszStr, cchMax, dwMS, iDigits);
2145
2146   if (lpszStr && cchMax)
2147   {
2148     WCHAR szCopy[128];
2149     DWORD dwHours, dwMinutes;
2150
2151     if (!iDigits || cchMax == 1)
2152     {
2153       *lpszStr = '\0';
2154       return 0;
2155     }
2156
2157     /* Calculate the time classes */
2158     dwMS = (dwMS + 500) / 1000;
2159     dwHours = dwMS / 3600;
2160     dwMS -= dwHours * 3600;
2161     dwMinutes = dwMS / 60;
2162     dwMS -= dwMinutes * 60;
2163
2164     szCopy[0] = '\0';
2165
2166     if (dwHours)
2167       iDigits = SHLWAPI_WriteTimeClass(szCopy, dwHours, IDS_TIME_INTERVAL_HOURS, iDigits);
2168
2169     if (dwMinutes && iDigits)
2170       iDigits = SHLWAPI_WriteTimeClass(szCopy, dwMinutes, IDS_TIME_INTERVAL_MINUTES, iDigits);
2171
2172     if (iDigits) /* Always write seconds if we have significant digits */
2173       SHLWAPI_WriteTimeClass(szCopy, dwMS, IDS_TIME_INTERVAL_SECONDS, iDigits);
2174
2175     lstrcpynW(lpszStr, szCopy, cchMax);
2176     iRet = strlenW(lpszStr);
2177   }
2178   return iRet;
2179 }
2180
2181 /*************************************************************************
2182  * StrIsIntlEqualA      [SHLWAPI.@]
2183  *
2184  * Compare two strings.
2185  *
2186  * PARAMS
2187  *  bCase    [I] Whether to compare case sensitively
2188  *  lpszStr  [I] First string to compare
2189  *  lpszComp [I] Second string to compare
2190  *  iLen     [I] Length to compare
2191  *
2192  * RETURNS
2193  *  TRUE  If the strings are equal.
2194  *  FALSE Otherwise.
2195  */
2196 BOOL WINAPI StrIsIntlEqualA(BOOL bCase, LPCSTR lpszStr, LPCSTR lpszComp,
2197                             int iLen)
2198 {
2199   DWORD dwFlags;
2200
2201   TRACE("(%d,%s,%s,%d)\n", bCase,
2202         debugstr_a(lpszStr), debugstr_a(lpszComp), iLen);
2203
2204   /* FIXME: This flag is undocumented and unknown by our CompareString.
2205    *        We need a define for it.
2206    */
2207   dwFlags = 0x10000000;
2208   if (!bCase) dwFlags |= NORM_IGNORECASE;
2209
2210   return (CompareStringA(GetThreadLocale(), dwFlags, lpszStr, iLen, lpszComp, iLen) == CSTR_EQUAL);
2211 }
2212
2213 /*************************************************************************
2214  * StrIsIntlEqualW      [SHLWAPI.@]
2215  *
2216  * See StrIsIntlEqualA.
2217  */
2218 BOOL WINAPI StrIsIntlEqualW(BOOL bCase, LPCWSTR lpszStr, LPCWSTR lpszComp,
2219                             int iLen)
2220 {
2221   DWORD dwFlags;
2222
2223   TRACE("(%d,%s,%s,%d)\n", bCase,
2224         debugstr_w(lpszStr),debugstr_w(lpszComp), iLen);
2225
2226   /* FIXME: This flag is undocumented and unknown by our CompareString.
2227    *        We need a define for it.
2228    */
2229   dwFlags = 0x10000000;
2230   if (!bCase) dwFlags |= NORM_IGNORECASE;
2231
2232   return (CompareStringW(GetThreadLocale(), dwFlags, lpszStr, iLen, lpszComp, iLen) == CSTR_EQUAL);
2233 }
2234
2235 /*************************************************************************
2236  * @    [SHLWAPI.399]
2237  *
2238  * Copy a string to another string, up to a maximum number of characters.
2239  *
2240  * PARAMS
2241  *  lpszDest [O] Destination string
2242  *  lpszSrc  [I] Source string
2243  *  iLen     [I] Maximum number of chars to copy
2244  *
2245  * RETURNS
2246  *  Success: A pointer to the last character written to lpszDest.
2247  *  Failure: lpszDest, if any arguments are invalid.
2248  */
2249 LPSTR WINAPI StrCpyNXA(LPSTR lpszDest, LPCSTR lpszSrc, int iLen)
2250 {
2251   TRACE("(%p,%s,%i)\n", lpszDest, debugstr_a(lpszSrc), iLen);
2252
2253   if (lpszDest && lpszSrc && iLen > 0)
2254   {
2255     while ((iLen-- > 1) && *lpszSrc)
2256       *lpszDest++ = *lpszSrc++;
2257     if (iLen >= 0)
2258      *lpszDest = '\0';
2259   }
2260   return lpszDest;
2261 }
2262
2263 /*************************************************************************
2264  * @    [SHLWAPI.400]
2265  *
2266  * Unicode version of StrCpyNXA.
2267  */
2268 LPWSTR WINAPI StrCpyNXW(LPWSTR lpszDest, LPCWSTR lpszSrc, int iLen)
2269 {
2270   TRACE("(%p,%s,%i)\n", lpszDest, debugstr_w(lpszSrc), iLen);
2271
2272   if (lpszDest && lpszSrc && iLen > 0)
2273   {
2274     while ((iLen-- > 1) && *lpszSrc)
2275       *lpszDest++ = *lpszSrc++;
2276     if (iLen >= 0)
2277      *lpszDest = '\0';
2278   }
2279   return lpszDest;
2280 }
2281
2282 /*************************************************************************
2283  * StrCmpLogicalW       [SHLWAPI.@]
2284  *
2285  * Compare two strings, ignoring case and comparing digits as numbers.
2286  *
2287  * PARAMS
2288  *  lpszStr  [I] First string to compare
2289  *  lpszComp [I] Second string to compare
2290  *  iLen     [I] Length to compare
2291  *
2292  * RETURNS
2293  *  TRUE  If the strings are equal.
2294  *  FALSE Otherwise.
2295  */
2296 INT WINAPI StrCmpLogicalW(LPCWSTR lpszStr, LPCWSTR lpszComp)
2297 {
2298   INT iDiff;
2299
2300   TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszComp));
2301
2302   if (lpszStr && lpszComp)
2303   {
2304     while (*lpszStr)
2305     {
2306       if (!*lpszComp)
2307         return 1;
2308       else if (isdigitW(*lpszStr))
2309       {
2310         int iStr, iComp;
2311
2312         if (!isdigitW(*lpszComp))
2313           return -1;
2314
2315         /* Compare the numbers */
2316         StrToIntExW(lpszStr, 0, &iStr);
2317         StrToIntExW(lpszComp, 0, &iComp);
2318
2319         if (iStr < iComp)
2320           return -1;
2321         else if (iStr > iComp)
2322           return 1;
2323
2324         /* Skip */
2325         while (isdigitW(*lpszStr))
2326           lpszStr++;
2327         while (isdigitW(*lpszComp))
2328           lpszComp++;
2329       }
2330       else if (isdigitW(*lpszComp))
2331         return 1;
2332       else
2333       {
2334         iDiff = ChrCmpIW(*lpszStr,*lpszComp);
2335         if (iDiff > 0)
2336           return 1;
2337         else if (iDiff < 0)
2338           return -1;
2339
2340         lpszStr++;
2341         lpszComp++;
2342       }
2343     }
2344     if (*lpszComp)
2345       return -1;
2346   }
2347   return 0;
2348 }
2349
2350 /* Structure for formatting byte strings */
2351 typedef struct tagSHLWAPI_BYTEFORMATS
2352 {
2353   LONGLONG dLimit;
2354   double   dDivisor;
2355   double   dNormaliser;
2356   int      nDecimals;
2357   WCHAR     wPrefix;
2358 } SHLWAPI_BYTEFORMATS;
2359
2360 /*************************************************************************
2361  * StrFormatByteSizeW   [SHLWAPI.@]
2362  *
2363  * Create a string containing an abbreviated byte count of up to 2^63-1.
2364  *
2365  * PARAMS
2366  *  llBytes  [I] Byte size to format
2367  *  lpszDest [I] Destination for formatted string
2368  *  cchMax   [I] Size of lpszDest
2369  *
2370  * RETURNS
2371  *  lpszDest.
2372  *
2373  * NOTES
2374  *  There is no StrFormatByteSize64W function, it is called StrFormatByteSizeW().
2375  */
2376 LPWSTR WINAPI StrFormatByteSizeW(LONGLONG llBytes, LPWSTR lpszDest, UINT cchMax)
2377 {
2378 #define KB ((ULONGLONG)1024)
2379 #define MB (KB*KB)
2380 #define GB (KB*KB*KB)
2381 #define TB (KB*KB*KB*KB)
2382 #define PB (KB*KB*KB*KB*KB)
2383
2384   static const SHLWAPI_BYTEFORMATS bfFormats[] =
2385   {
2386     { 10*KB, 10.24, 100.0, 2, 'K' }, /* 10 KB */
2387     { 100*KB, 102.4, 10.0, 1, 'K' }, /* 100 KB */
2388     { 1000*KB, 1024.0, 1.0, 0, 'K' }, /* 1000 KB */
2389     { 10*MB, 10485.76, 100.0, 2, 'M' }, /* 10 MB */
2390     { 100*MB, 104857.6, 10.0, 1, 'M' }, /* 100 MB */
2391     { 1000*MB, 1048576.0, 1.0, 0, 'M' }, /* 1000 MB */
2392     { 10*GB, 10737418.24, 100.0, 2, 'G' }, /* 10 GB */
2393     { 100*GB, 107374182.4, 10.0, 1, 'G' }, /* 100 GB */
2394     { 1000*GB, 1073741824.0, 1.0, 0, 'G' }, /* 1000 GB */
2395     { 10*TB, 10485.76, 100.0, 2, 'T' }, /* 10 TB */
2396     { 100*TB, 104857.6, 10.0, 1, 'T' }, /* 100 TB */
2397     { 1000*TB, 1048576.0, 1.0, 0, 'T' }, /* 1000 TB */
2398     { 10*PB, 10737418.24, 100.00, 2, 'P' }, /* 10 PB */
2399     { 100*PB, 107374182.4, 10.00, 1, 'P' }, /* 100 PB */
2400     { 1000*PB, 1073741824.0, 1.00, 0, 'P' }, /* 1000 PB */
2401     { 0, 10995116277.76, 100.00, 2, 'E' } /* EB's, catch all */
2402   };
2403   WCHAR wszAdd[] = {' ','?','B',0};
2404   double dBytes;
2405   UINT i = 0;
2406
2407   TRACE("(0x%s,%p,%d)\n", wine_dbgstr_longlong(llBytes), lpszDest, cchMax);
2408
2409   if (!lpszDest || !cchMax)
2410     return lpszDest;
2411
2412   if (llBytes < 1024)  /* 1K */
2413   {
2414     WCHAR wszBytesFormat[64];
2415     LoadStringW(shlwapi_hInstance, IDS_BYTES_FORMAT, wszBytesFormat, 64);
2416     snprintfW(lpszDest, cchMax, wszBytesFormat, (int)llBytes);
2417     return lpszDest;
2418   }
2419
2420   /* Note that if this loop completes without finding a match, i will be
2421    * pointing at the last entry, which is a catch all for > 1000 PB
2422    */
2423   while (i < sizeof(bfFormats) / sizeof(SHLWAPI_BYTEFORMATS) - 1)
2424   {
2425     if (llBytes < bfFormats[i].dLimit)
2426       break;
2427     i++;
2428   }
2429   /* Above 1 TB we encounter problems with FP accuracy. So for amounts above
2430    * this number we integer shift down by 1 MB first. The table above has
2431    * the divisors scaled down from the '< 10 TB' entry onwards, to account
2432    * for this. We also add a small fudge factor to get the correct result for
2433    * counts that lie exactly on a 1024 byte boundary.
2434    */
2435   if (i > 8)
2436     dBytes = (double)(llBytes >> 20) + 0.001; /* Scale down by 1 MB */
2437   else
2438     dBytes = (double)llBytes + 0.00001;
2439
2440   dBytes = floor(dBytes / bfFormats[i].dDivisor) / bfFormats[i].dNormaliser;
2441
2442   if (!FormatDouble(dBytes, bfFormats[i].nDecimals, lpszDest, cchMax))
2443     return NULL;
2444   wszAdd[1] = bfFormats[i].wPrefix;
2445   StrCatBuffW(lpszDest, wszAdd, cchMax);
2446   return lpszDest;
2447 }
2448
2449 /*************************************************************************
2450  * StrFormatByteSize64A [SHLWAPI.@]
2451  *
2452  * See StrFormatByteSizeW.
2453  */
2454 LPSTR WINAPI StrFormatByteSize64A(LONGLONG llBytes, LPSTR lpszDest, UINT cchMax)
2455 {
2456   WCHAR wszBuff[32];
2457
2458   StrFormatByteSizeW(llBytes, wszBuff, sizeof(wszBuff)/sizeof(WCHAR));
2459
2460   if (lpszDest)
2461     WideCharToMultiByte(CP_ACP, 0, wszBuff, -1, lpszDest, cchMax, 0, 0);
2462   return lpszDest;
2463 }
2464
2465 /*************************************************************************
2466  * StrFormatByteSizeA   [SHLWAPI.@]
2467  *
2468  * Create a string containing an abbreviated byte count of up to 2^31-1.
2469  *
2470  * PARAMS
2471  *  dwBytes  [I] Byte size to format
2472  *  lpszDest [I] Destination for formatted string
2473  *  cchMax   [I] Size of lpszDest
2474  *
2475  * RETURNS
2476  *  lpszDest.
2477  *
2478  * NOTES
2479  *  The Ascii and Unicode versions of this function accept a different
2480  *  integer type for dwBytes. See StrFormatByteSize64A().
2481  */
2482 LPSTR WINAPI StrFormatByteSizeA(DWORD dwBytes, LPSTR lpszDest, UINT cchMax)
2483 {
2484   TRACE("(%d,%p,%d)\n", dwBytes, lpszDest, cchMax);
2485
2486   return StrFormatByteSize64A(dwBytes, lpszDest, cchMax);
2487 }
2488
2489 /*************************************************************************
2490  *      @       [SHLWAPI.162]
2491  *
2492  * Remove a hanging lead byte from the end of a string, if present.
2493  *
2494  * PARAMS
2495  *  lpStr [I] String to check for a hanging lead byte
2496  *  size  [I] Length of lpStr
2497  *
2498  * RETURNS
2499  *  Success: The new length of the string. Any hanging lead bytes are removed.
2500  *  Failure: 0, if any parameters are invalid.
2501  */
2502 DWORD WINAPI SHTruncateString(LPSTR lpStr, DWORD size)
2503 {
2504   if (lpStr && size)
2505   {
2506     LPSTR lastByte = lpStr + size - 1;
2507
2508     while(lpStr < lastByte)
2509       lpStr += IsDBCSLeadByte(*lpStr) ? 2 : 1;
2510
2511     if(lpStr == lastByte && IsDBCSLeadByte(*lpStr))
2512     {
2513       *lpStr = '\0';
2514       size--;
2515     }
2516     return size;
2517   }
2518   return 0;
2519 }
2520
2521 /*************************************************************************
2522  *      @       [SHLWAPI.203]
2523  *
2524  * Remove a single non-trailing ampersand ('&') from a string.
2525  *
2526  * PARAMS
2527  *  lpszStr [I/O] String to remove ampersand from.
2528  *
2529  * RETURNS
2530  *  The character after the first ampersand in lpszStr, or the first character
2531  *  in lpszStr if there is no ampersand in the string.
2532  */
2533 char WINAPI SHStripMneumonicA(LPCSTR lpszStr)
2534 {
2535   LPSTR lpszIter, lpszTmp;
2536   char ch;
2537
2538   TRACE("(%s)\n", debugstr_a(lpszStr));
2539
2540   ch = *lpszStr;
2541
2542   if ((lpszIter = StrChrA(lpszStr, '&')))
2543   {
2544     lpszTmp = CharNextA(lpszIter);
2545     if (*lpszTmp)
2546     {
2547       if (*lpszTmp != '&')
2548         ch =  *lpszTmp;
2549
2550       memmove( lpszIter, lpszTmp, strlen(lpszTmp) + 1 );
2551     }
2552   }
2553
2554   return ch;
2555 }
2556
2557 /*************************************************************************
2558  *      @       [SHLWAPI.225]
2559  *
2560  * Unicode version of SHStripMneumonicA.
2561  */
2562 WCHAR WINAPI SHStripMneumonicW(LPCWSTR lpszStr)
2563 {
2564   LPWSTR lpszIter, lpszTmp;
2565   WCHAR ch;
2566
2567   TRACE("(%s)\n", debugstr_w(lpszStr));
2568
2569   ch = *lpszStr;
2570
2571   if ((lpszIter = StrChrW(lpszStr, '&')))
2572   {
2573     lpszTmp = lpszIter + 1;
2574     if (*lpszTmp)
2575     {
2576       if (*lpszTmp != '&')
2577         ch =  *lpszTmp;
2578
2579       memmove( lpszIter, lpszTmp, (strlenW(lpszTmp) + 1) * sizeof(WCHAR) );
2580     }
2581   }
2582
2583   return ch;
2584 }
2585
2586 /*************************************************************************
2587  *      @       [SHLWAPI.216]
2588  *
2589  * Convert an Ascii string to Unicode.
2590  *
2591  * PARAMS
2592  * dwCp     [I] Code page for the conversion
2593  * lpSrcStr [I] Source Ascii string to convert
2594  * lpDstStr [O] Destination for converted Unicode string
2595  * iLen     [I] Length of lpDstStr
2596  *
2597  * RETURNS
2598  *  The return value of the MultiByteToWideChar() function called on lpSrcStr.
2599  */
2600 DWORD WINAPI SHAnsiToUnicodeCP(DWORD dwCp, LPCSTR lpSrcStr, LPWSTR lpDstStr, int iLen)
2601 {
2602   DWORD dwRet;
2603
2604   dwRet = MultiByteToWideChar(dwCp, 0, lpSrcStr, -1, lpDstStr, iLen);
2605   TRACE("%s->%s,ret=%d\n", debugstr_a(lpSrcStr), debugstr_w(lpDstStr), dwRet);
2606   return dwRet;
2607 }
2608
2609 /*************************************************************************
2610  *      @       [SHLWAPI.215]
2611  *
2612  * Convert an Ascii string to Unicode.
2613  *
2614  * PARAMS
2615  * lpSrcStr [I] Source Ascii string to convert
2616  * lpDstStr [O] Destination for converted Unicode string
2617  * iLen     [I] Length of lpDstStr
2618  *
2619  * RETURNS
2620  *  The return value of the MultiByteToWideChar() function called on lpSrcStr.
2621  *
2622  * NOTES
2623  *  This function simply calls SHAnsiToUnicodeCP with code page CP_ACP.
2624  */
2625 DWORD WINAPI SHAnsiToUnicode(LPCSTR lpSrcStr, LPWSTR lpDstStr, int iLen)
2626 {
2627   return SHAnsiToUnicodeCP(CP_ACP, lpSrcStr, lpDstStr, iLen);
2628 }
2629
2630 /*************************************************************************
2631  *      @       [SHLWAPI.218]
2632  *
2633  * Convert a Unicode string to Ascii.
2634  *
2635  * PARAMS
2636  *  CodePage [I] Code page to use for the conversion
2637  *  lpSrcStr [I] Source Unicode string to convert
2638  *  lpDstStr [O] Destination for converted Ascii string
2639  *  dstlen   [I] Length of buffer at lpDstStr
2640  *
2641  * RETURNS
2642  *  Success: The length in bytes of the result at lpDstStr (including the terminator)
2643  *  Failure: When using CP_UTF8, CP_UTF7 or 0xc350 as codePage, 0 is returned and
2644  *           the result is not nul-terminated.
2645  *           When using a different codepage, the length in bytes of the truncated
2646  *           result at lpDstStr (including the terminator) is returned and
2647  *           lpDstStr is always nul-terminated.
2648  *
2649  */
2650 DWORD WINAPI SHUnicodeToAnsiCP(UINT CodePage, LPCWSTR lpSrcStr, LPSTR lpDstStr, int dstlen)
2651 {
2652   static const WCHAR emptyW[] = { '\0' };
2653   int len , reqLen;
2654   LPSTR mem;
2655
2656   if (!lpDstStr || !dstlen)
2657     return 0;
2658
2659   if (!lpSrcStr)
2660     lpSrcStr = emptyW;
2661
2662   *lpDstStr = '\0';
2663
2664   len = strlenW(lpSrcStr) + 1;
2665
2666   switch (CodePage)
2667   {
2668   case CP_WINUNICODE:
2669     CodePage = CP_UTF8; /* Fall through... */
2670   case 0x0000C350: /* FIXME: CP_ #define */
2671   case CP_UTF7:
2672   case CP_UTF8:
2673     {
2674       DWORD dwMode = 0;
2675       INT lenW = len - 1;
2676       INT needed = dstlen - 1;
2677       HRESULT hr;
2678
2679       /* try the user supplied buffer first */
2680       hr = ConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &lenW, lpDstStr, &needed);
2681       if (hr == S_OK)
2682       {
2683         lpDstStr[needed] = '\0';
2684         return needed + 1;
2685       }
2686
2687       /* user buffer too small. exclude termination and copy as much as possible */
2688       lenW = len;
2689       hr = ConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &lenW, NULL, &needed);
2690       needed++;
2691       mem = HeapAlloc(GetProcessHeap(), 0, needed);
2692       if (!mem)
2693         return 0;
2694
2695       hr = ConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &len, mem, &needed);
2696       if (hr == S_OK)
2697       {
2698           reqLen = SHTruncateString(mem, dstlen);
2699           if (reqLen > 0) memcpy(lpDstStr, mem, reqLen-1);
2700       }
2701       HeapFree(GetProcessHeap(), 0, mem);
2702       return 0;
2703     }
2704   default:
2705     break;
2706   }
2707
2708   /* try the user supplied buffer first */
2709   reqLen = WideCharToMultiByte(CodePage, 0, lpSrcStr, len, lpDstStr, dstlen, NULL, NULL);
2710
2711   if (!reqLen && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
2712   {
2713     reqLen = WideCharToMultiByte(CodePage, 0, lpSrcStr, len, NULL, 0, NULL, NULL);
2714     if (reqLen)
2715     {
2716       mem = HeapAlloc(GetProcessHeap(), 0, reqLen);
2717       if (mem)
2718       {
2719         WideCharToMultiByte(CodePage, 0, lpSrcStr, len, mem, reqLen, NULL, NULL);
2720
2721         reqLen = SHTruncateString(mem, dstlen -1);
2722         reqLen++;
2723
2724         lstrcpynA(lpDstStr, mem, reqLen);
2725         HeapFree(GetProcessHeap(), 0, mem);
2726         lpDstStr[reqLen-1] = '\0';
2727       }
2728     }
2729   }
2730   return reqLen;
2731 }
2732
2733 /*************************************************************************
2734  *      @       [SHLWAPI.217]
2735  *
2736  * Convert a Unicode string to Ascii.
2737  *
2738  * PARAMS
2739  *  lpSrcStr [I] Source Unicode string to convert
2740  *  lpDstStr [O] Destination for converted Ascii string
2741  *  iLen     [O] Length of lpDstStr in characters
2742  *
2743  * RETURNS
2744  *  See SHUnicodeToAnsiCP
2745
2746  * NOTES
2747  *  This function simply calls SHUnicodeToAnsiCP() with CodePage = CP_ACP.
2748  */
2749 INT WINAPI SHUnicodeToAnsi(LPCWSTR lpSrcStr, LPSTR lpDstStr, INT iLen)
2750 {
2751     return SHUnicodeToAnsiCP(CP_ACP, lpSrcStr, lpDstStr, iLen);
2752 }
2753
2754 /*************************************************************************
2755  *      @       [SHLWAPI.345]
2756  *
2757  * Copy one string to another.
2758  *
2759  * PARAMS
2760  *  lpszSrc [I] Source string to copy
2761  *  lpszDst [O] Destination for copy
2762  *  iLen    [I] Length of lpszDst in characters
2763  *
2764  * RETURNS
2765  *  The length of the copied string, including the terminating NUL. lpszDst
2766  *  contains iLen characters of lpszSrc.
2767  */
2768 DWORD WINAPI SHAnsiToAnsi(LPCSTR lpszSrc, LPSTR lpszDst, int iLen)
2769 {
2770     LPSTR lpszRet;
2771
2772     TRACE("(%s,%p,0x%08x)\n", debugstr_a(lpszSrc), lpszDst, iLen);
2773
2774     lpszRet = StrCpyNXA(lpszDst, lpszSrc, iLen);
2775     return lpszRet - lpszDst + 1;
2776 }
2777
2778 /*************************************************************************
2779  *      @       [SHLWAPI.346]
2780  *
2781  * Unicode version of SSHAnsiToAnsi.
2782  */
2783 DWORD WINAPI SHUnicodeToUnicode(LPCWSTR lpszSrc, LPWSTR lpszDst, int iLen)
2784 {
2785     LPWSTR lpszRet;
2786
2787     TRACE("(%s,%p,0x%08x)\n", debugstr_w(lpszSrc), lpszDst, iLen);
2788
2789     lpszRet = StrCpyNXW(lpszDst, lpszSrc, iLen);
2790     return lpszRet - lpszDst + 1;
2791 }
2792
2793 /*************************************************************************
2794  *      @       [SHLWAPI.364]
2795  *
2796  * Determine if an Ascii string converts to Unicode and back identically.
2797  *
2798  * PARAMS
2799  *  lpSrcStr [I] Source Unicode string to convert
2800  *  lpDst    [O] Destination for resulting Ascii string
2801  *  iLen     [I] Length of lpDst in characters
2802  *
2803  * RETURNS
2804  *  TRUE, since Ascii strings always convert identically.
2805  */
2806 BOOL WINAPI DoesStringRoundTripA(LPCSTR lpSrcStr, LPSTR lpDst, INT iLen)
2807 {
2808   lstrcpynA(lpDst, lpSrcStr, iLen);
2809   return TRUE;
2810 }
2811
2812 /*************************************************************************
2813  *      @       [SHLWAPI.365]
2814  *
2815  * Determine if a Unicode string converts to Ascii and back identically.
2816  *
2817  * PARAMS
2818  *  lpSrcStr [I] Source Unicode string to convert
2819  *  lpDst    [O] Destination for resulting Ascii string
2820  *  iLen     [I] Length of lpDst in characters
2821  *
2822  * RETURNS
2823  *  TRUE, if lpSrcStr converts to Ascii and back identically,
2824  *  FALSE otherwise.
2825  */
2826 BOOL WINAPI DoesStringRoundTripW(LPCWSTR lpSrcStr, LPSTR lpDst, INT iLen)
2827 {
2828     WCHAR szBuff[MAX_PATH];
2829
2830     SHUnicodeToAnsi(lpSrcStr, lpDst, iLen);
2831     SHAnsiToUnicode(lpDst, szBuff, MAX_PATH);
2832     return !strcmpW(lpSrcStr, szBuff);
2833 }
2834
2835 /*************************************************************************
2836  *      SHLoadIndirectString    [SHLWAPI.@]
2837  *
2838  * If passed a string that begins with '@', extract the string from the
2839  * appropriate resource, otherwise do a straight copy.
2840  *
2841  */
2842 HRESULT WINAPI SHLoadIndirectString(LPCWSTR src, LPWSTR dst, UINT dst_len, void **reserved)
2843 {
2844     WCHAR *dllname = NULL;
2845     HMODULE hmod = NULL;
2846     HRESULT hr = E_FAIL;
2847
2848     TRACE("(%s %p %08x %p)\n", debugstr_w(src), dst, dst_len, reserved);
2849
2850     if(src[0] == '@')
2851     {
2852         WCHAR *index_str;
2853         int index;
2854
2855         dst[0] = 0;
2856         dllname = StrDupW(src + 1);
2857         index_str = strchrW(dllname, ',');
2858
2859         if(!index_str) goto end;
2860
2861         *index_str = 0;
2862         index_str++;
2863         index = atoiW(index_str);
2864
2865         hmod = LoadLibraryW(dllname);
2866         if(!hmod) goto end;
2867
2868         if(index < 0)
2869         {
2870             if(LoadStringW(hmod, -index, dst, dst_len))
2871                 hr = S_OK;
2872         }
2873         else
2874             FIXME("can't handle non-negative indices (%d)\n", index);
2875     }
2876     else
2877     {
2878         if(dst != src)
2879             lstrcpynW(dst, src, dst_len);
2880         hr = S_OK;
2881     }
2882
2883     TRACE("returning %s\n", debugstr_w(dst));
2884 end:
2885     if(hmod) FreeLibrary(hmod);
2886     LocalFree(dllname);
2887     return hr;
2888 }
2889
2890 BOOL WINAPI IsCharSpaceA(CHAR c)
2891 {
2892     WORD CharType;
2893     return GetStringTypeA(GetSystemDefaultLCID(), CT_CTYPE1, &c, 1, &CharType) && (CharType & C1_SPACE);
2894 }
2895
2896 /*************************************************************************
2897  *      @       [SHLWAPI.29]
2898  *
2899  * Determine if a Unicode character is a space.
2900  *
2901  * PARAMS
2902  *  wc [I] Character to check.
2903  *
2904  * RETURNS
2905  *  TRUE, if wc is a space,
2906  *  FALSE otherwise.
2907  */
2908 BOOL WINAPI IsCharSpaceW(WCHAR wc)
2909 {
2910     WORD CharType;
2911
2912     return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_SPACE);
2913 }