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