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