browseui: Fix several memory leaks in the tests.
[wine] / 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 }