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