/* * Shlwapi string functions * * Copyright 1998 Juergen Schmied * Copyright 2002 Jon Griffiths * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" #include "wine/port.h" #include #include #include #include #define NONAMELESSUNION #include "windef.h" #include "winbase.h" #define NO_SHLWAPI_REG #define NO_SHLWAPI_STREAM #include "shlwapi.h" #include "wingdi.h" #include "winuser.h" #include "shlobj.h" #include "mlang.h" #include "ddeml.h" #include "wine/unicode.h" #include "wine/debug.h" #include "resource.h" WINE_DEFAULT_DEBUG_CHANNEL(shell); extern HINSTANCE shlwapi_hInstance; static HRESULT _SHStrDupAA(LPCSTR,LPSTR*); static HRESULT _SHStrDupAW(LPCWSTR,LPSTR*); static void FillNumberFmt(NUMBERFMTW *fmt, LPWSTR decimal_buffer, int decimal_bufwlen, LPWSTR thousand_buffer, int thousand_bufwlen) { WCHAR grouping[64]; WCHAR *c; GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_ILZERO|LOCALE_RETURN_NUMBER, (LPWSTR)&fmt->LeadingZero, sizeof(fmt->LeadingZero)/sizeof(WCHAR)); GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_INEGNUMBER|LOCALE_RETURN_NUMBER, (LPWSTR)&fmt->LeadingZero, sizeof(fmt->NegativeOrder)/sizeof(WCHAR)); fmt->NumDigits = 0; GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, decimal_buffer, decimal_bufwlen); GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, thousand_buffer, thousand_bufwlen); fmt->lpThousandSep = thousand_buffer; fmt->lpDecimalSep = decimal_buffer; /* * Converting grouping string to number as described on * http://blogs.msdn.com/oldnewthing/archive/2006/04/18/578251.aspx */ fmt->Grouping = 0; GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SGROUPING, grouping, sizeof(grouping)/sizeof(WCHAR)); for (c = grouping; *c; c++) if (*c >= '0' && *c < '9') { fmt->Grouping *= 10; fmt->Grouping += *c - '0'; } if (fmt->Grouping % 10 == 0) fmt->Grouping /= 10; else fmt->Grouping *= 10; } /************************************************************************* * FormatInt [internal] * * Format an integer according to the current locale * * RETURNS * The number of characters written on success or 0 on failure */ static int FormatInt(LONGLONG qdwValue, LPWSTR pszBuf, int cchBuf) { NUMBERFMTW fmt; WCHAR decimal[8], thousand[8]; WCHAR buf[24]; WCHAR *c; BOOL neg = (qdwValue < 0); FillNumberFmt(&fmt, decimal, sizeof decimal / sizeof (WCHAR), thousand, sizeof thousand / sizeof (WCHAR)); c = &buf[24]; *(--c) = 0; do { *(--c) = '0' + (qdwValue%10); qdwValue /= 10; } while (qdwValue > 0); if (neg) *(--c) = '-'; return GetNumberFormatW(LOCALE_USER_DEFAULT, 0, c, &fmt, pszBuf, cchBuf); } /************************************************************************* * FormatDouble [internal] * * Format an integer according to the current locale. Prints the specified number of digits * after the decimal point * * RETURNS * The number of characters written on success or 0 on failure */ static int FormatDouble(double value, int decimals, LPWSTR pszBuf, int cchBuf) { static const WCHAR flfmt[] = {'%','f',0}; WCHAR buf[64]; NUMBERFMTW fmt; WCHAR decimal[8], thousand[8]; snprintfW(buf, 64, flfmt, value); FillNumberFmt(&fmt, decimal, sizeof decimal / sizeof (WCHAR), thousand, sizeof thousand / sizeof (WCHAR)); fmt.NumDigits = decimals; return GetNumberFormatW(LOCALE_USER_DEFAULT, 0, buf, &fmt, pszBuf, cchBuf); } /************************************************************************* * SHLWAPI_ChrCmpHelperA * * Internal helper for SHLWAPI_ChrCmpA/ChrCMPIA. * * NOTES * Both this function and its Unicode counterpart are very inefficient. To * fix this, CompareString must be completely implemented and optimised * first. Then the core character test can be taken out of that function and * placed here, so that it need never be called at all. Until then, do not * attempt to optimise this code unless you are willing to test that it * still performs correctly. */ static BOOL SHLWAPI_ChrCmpHelperA(WORD ch1, WORD ch2, DWORD dwFlags) { char str1[3], str2[3]; str1[0] = LOBYTE(ch1); if (IsDBCSLeadByte(str1[0])) { str1[1] = HIBYTE(ch1); str1[2] = '\0'; } else str1[1] = '\0'; str2[0] = LOBYTE(ch2); if (IsDBCSLeadByte(str2[0])) { str2[1] = HIBYTE(ch2); str2[2] = '\0'; } else str2[1] = '\0'; return CompareStringA(GetThreadLocale(), dwFlags, str1, -1, str2, -1) - CSTR_EQUAL; } /************************************************************************* * SHLWAPI_ChrCmpA * * Internal helper function. */ static BOOL WINAPI SHLWAPI_ChrCmpA(WORD ch1, WORD ch2) { return SHLWAPI_ChrCmpHelperA(ch1, ch2, 0); } /************************************************************************* * ChrCmpIA (SHLWAPI.385) * * Compare two characters, ignoring case. * * PARAMS * ch1 [I] First character to compare * ch2 [I] Second character to compare * * RETURNS * FALSE, if the characters are equal. * Non-zero otherwise. */ BOOL WINAPI ChrCmpIA(WORD ch1, WORD ch2) { TRACE("(%d,%d)\n", ch1, ch2); return SHLWAPI_ChrCmpHelperA(ch1, ch2, NORM_IGNORECASE); } /************************************************************************* * ChrCmpIW [SHLWAPI.386] * * See ChrCmpIA. */ BOOL WINAPI ChrCmpIW(WCHAR ch1, WCHAR ch2) { return CompareStringW(GetThreadLocale(), NORM_IGNORECASE, &ch1, 1, &ch2, 1) - CSTR_EQUAL; } /************************************************************************* * StrChrA [SHLWAPI.@] * * Find a given character in a string. * * PARAMS * lpszStr [I] String to search in. * ch [I] Character to search for. * * RETURNS * Success: A pointer to the first occurrence of ch in lpszStr, or NULL if * not found. * Failure: NULL, if any arguments are invalid. */ LPSTR WINAPI StrChrA(LPCSTR lpszStr, WORD ch) { TRACE("(%s,%i)\n", debugstr_a(lpszStr), ch); if (lpszStr) { while (*lpszStr) { if (!SHLWAPI_ChrCmpA(*lpszStr, ch)) return (LPSTR)lpszStr; lpszStr = CharNextA(lpszStr); } } return NULL; } /************************************************************************* * StrChrW [SHLWAPI.@] * * See StrChrA. */ LPWSTR WINAPI StrChrW(LPCWSTR lpszStr, WCHAR ch) { LPWSTR lpszRet = NULL; TRACE("(%s,%i)\n", debugstr_w(lpszStr), ch); if (lpszStr) lpszRet = strchrW(lpszStr, ch); return lpszRet; } /************************************************************************* * StrChrIA [SHLWAPI.@] * * Find a given character in a string, ignoring case. * * PARAMS * lpszStr [I] String to search in. * ch [I] Character to search for. * * RETURNS * Success: A pointer to the first occurrence of ch in lpszStr, or NULL if * not found. * Failure: NULL, if any arguments are invalid. */ LPSTR WINAPI StrChrIA(LPCSTR lpszStr, WORD ch) { TRACE("(%s,%i)\n", debugstr_a(lpszStr), ch); if (lpszStr) { while (*lpszStr) { if (!ChrCmpIA(*lpszStr, ch)) return (LPSTR)lpszStr; lpszStr = CharNextA(lpszStr); } } return NULL; } /************************************************************************* * StrChrIW [SHLWAPI.@] * * See StrChrA. */ LPWSTR WINAPI StrChrIW(LPCWSTR lpszStr, WCHAR ch) { TRACE("(%s,%i)\n", debugstr_w(lpszStr), ch); if (lpszStr) { ch = toupperW(ch); while (*lpszStr) { if (toupperW(*lpszStr) == ch) return (LPWSTR)lpszStr; lpszStr++; } lpszStr = NULL; } return (LPWSTR)lpszStr; } /************************************************************************* * StrChrNW [SHLWAPI.@] */ LPWSTR WINAPI StrChrNW(LPCWSTR lpszStr, WCHAR ch, UINT cchMax) { TRACE("(%s(%i),%i)\n", debugstr_wn(lpszStr,cchMax), cchMax, ch); if (lpszStr) { while (*lpszStr && cchMax-- > 0) { if (*lpszStr == ch) return (LPWSTR)lpszStr; lpszStr++; } } return NULL; } /************************************************************************* * StrCmpIW [SHLWAPI.@] * * Compare two strings, ignoring case. * * PARAMS * lpszStr [I] First string to compare * lpszComp [I] Second string to compare * * RETURNS * An integer less than, equal to or greater than 0, indicating that * lpszStr is less than, the same, or greater than lpszComp. */ int WINAPI StrCmpIW(LPCWSTR lpszStr, LPCWSTR lpszComp) { TRACE("(%s,%s)\n", debugstr_w(lpszStr),debugstr_w(lpszComp)); return CompareStringW(GetThreadLocale(), NORM_IGNORECASE, lpszStr, -1, lpszComp, -1) - CSTR_EQUAL; } /************************************************************************* * StrCmpNA [SHLWAPI.@] * * Compare two strings, up to a maximum length. * * PARAMS * lpszStr [I] First string to compare * lpszComp [I] Second string to compare * iLen [I] Number of chars to compare * * RETURNS * An integer less than, equal to or greater than 0, indicating that * lpszStr is less than, the same, or greater than lpszComp. */ INT WINAPI StrCmpNA(LPCSTR lpszStr, LPCSTR lpszComp, INT iLen) { TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszComp), iLen); return CompareStringA(GetThreadLocale(), 0, lpszStr, iLen, lpszComp, iLen) - CSTR_EQUAL; } /************************************************************************* * StrCmpNW [SHLWAPI.@] * * See StrCmpNA. */ INT WINAPI StrCmpNW(LPCWSTR lpszStr, LPCWSTR lpszComp, INT iLen) { TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszComp), iLen); return CompareStringW(GetThreadLocale(), 0, lpszStr, iLen, lpszComp, iLen) - CSTR_EQUAL; } /************************************************************************* * StrCmpNIA [SHLWAPI.@] * * Compare two strings, up to a maximum length, ignoring case. * * PARAMS * lpszStr [I] First string to compare * lpszComp [I] Second string to compare * iLen [I] Number of chars to compare * * RETURNS * An integer less than, equal to or greater than 0, indicating that * lpszStr is less than, the same, or greater than lpszComp. */ int WINAPI StrCmpNIA(LPCSTR lpszStr, LPCSTR lpszComp, int iLen) { TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszComp), iLen); return CompareStringA(GetThreadLocale(), NORM_IGNORECASE, lpszStr, iLen, lpszComp, iLen) - CSTR_EQUAL; } /************************************************************************* * StrCmpNIW [SHLWAPI.@] * * See StrCmpNIA. */ INT WINAPI StrCmpNIW(LPCWSTR lpszStr, LPCWSTR lpszComp, int iLen) { TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszComp), iLen); return CompareStringW(GetThreadLocale(), NORM_IGNORECASE, lpszStr, iLen, lpszComp, iLen) - CSTR_EQUAL; } /************************************************************************* * StrCmpW [SHLWAPI.@] * * Compare two strings. * * PARAMS * lpszStr [I] First string to compare * lpszComp [I] Second string to compare * * RETURNS * An integer less than, equal to or greater than 0, indicating that * lpszStr is less than, the same, or greater than lpszComp. */ int WINAPI StrCmpW(LPCWSTR lpszStr, LPCWSTR lpszComp) { TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszComp)); return CompareStringW(GetThreadLocale(), 0, lpszStr, -1, lpszComp, -1) - CSTR_EQUAL; } /************************************************************************* * StrCatW [SHLWAPI.@] * * Concatenate two strings. * * PARAMS * lpszStr [O] Initial string * lpszSrc [I] String to concatenate * * RETURNS * lpszStr. */ LPWSTR WINAPI StrCatW(LPWSTR lpszStr, LPCWSTR lpszSrc) { TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSrc)); if (lpszStr && lpszSrc) strcatW(lpszStr, lpszSrc); return lpszStr; } /************************************************************************* * StrCatChainW [SHLWAPI.@] * * Concatenates two unicode strings. * * PARAMS * lpszStr [O] Initial string * cchMax [I] Length of destination buffer * ichAt [I] Offset from the destination buffer to begin concatenation * lpszCat [I] String to concatenate * * RETURNS * The offset from the beginning of pszDst to the terminating NULL. */ DWORD WINAPI StrCatChainW(LPWSTR lpszStr, DWORD cchMax, DWORD ichAt, LPCWSTR lpszCat) { TRACE("(%s,%u,%d,%s)\n", debugstr_w(lpszStr), cchMax, ichAt, debugstr_w(lpszCat)); if (ichAt == -1) ichAt = strlenW(lpszStr); if (!cchMax) return ichAt; if (ichAt == cchMax) ichAt--; if (lpszCat && ichAt < cchMax) { lpszStr += ichAt; while (ichAt < cchMax - 1 && *lpszCat) { *lpszStr++ = *lpszCat++; ichAt++; } *lpszStr = 0; } return ichAt; } /************************************************************************* * StrCpyW [SHLWAPI.@] * * Copy a string to another string. * * PARAMS * lpszStr [O] Destination string * lpszSrc [I] Source string * * RETURNS * lpszStr. */ LPWSTR WINAPI StrCpyW(LPWSTR lpszStr, LPCWSTR lpszSrc) { TRACE("(%p,%s)\n", lpszStr, debugstr_w(lpszSrc)); if (lpszStr && lpszSrc) strcpyW(lpszStr, lpszSrc); return lpszStr; } /************************************************************************* * StrCpyNW [SHLWAPI.@] * * Copy a string to another string, up to a maximum number of characters. * * PARAMS * dst [O] Destination string * src [I] Source string * count [I] Maximum number of chars to copy * * RETURNS * dst. */ LPWSTR WINAPI StrCpyNW(LPWSTR dst, LPCWSTR src, int count) { LPWSTR d = dst; LPCWSTR s = src; TRACE("(%p,%s,%i)\n", dst, debugstr_w(src), count); if (s) { while ((count > 1) && *s) { count--; *d++ = *s++; } } if (count) *d = 0; return dst; } /************************************************************************* * SHLWAPI_StrStrHelperA * * Internal implementation of StrStrA/StrStrIA */ static LPSTR SHLWAPI_StrStrHelperA(LPCSTR lpszStr, LPCSTR lpszSearch, INT (WINAPI *pStrCmpFn)(LPCSTR,LPCSTR,INT)) { size_t iLen; LPCSTR end; if (!lpszStr || !lpszSearch || !*lpszSearch) return NULL; iLen = strlen(lpszSearch); end = lpszStr + strlen(lpszStr); while (lpszStr + iLen <= end) { if (!pStrCmpFn(lpszStr, lpszSearch, iLen)) return (LPSTR)lpszStr; lpszStr = CharNextA(lpszStr); } return NULL; } /************************************************************************* * StrStrA [SHLWAPI.@] * * Find a substring within a string. * * PARAMS * lpszStr [I] String to search in * lpszSearch [I] String to look for * * RETURNS * The start of lpszSearch within lpszStr, or NULL if not found. */ LPSTR WINAPI StrStrA(LPCSTR lpszStr, LPCSTR lpszSearch) { TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch)); return SHLWAPI_StrStrHelperA(lpszStr, lpszSearch, StrCmpNA); } /************************************************************************* * StrStrW [SHLWAPI.@] * * See StrStrA. */ LPWSTR WINAPI StrStrW(LPCWSTR lpszStr, LPCWSTR lpszSearch) { TRACE("(%s, %s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch)); if (!lpszStr || !lpszSearch || !*lpszSearch) return NULL; return strstrW( lpszStr, lpszSearch ); } /************************************************************************* * StrRStrIA [SHLWAPI.@] * * Find the last occurrence of a substring within a string. * * PARAMS * lpszStr [I] String to search in * lpszEnd [I] End of lpszStr * lpszSearch [I] String to look for * * RETURNS * The last occurrence lpszSearch within lpszStr, or NULL if not found. */ LPSTR WINAPI StrRStrIA(LPCSTR lpszStr, LPCSTR lpszEnd, LPCSTR lpszSearch) { LPSTR lpszRet = NULL; WORD ch1, ch2; INT iLen; TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch)); if (!lpszStr || !lpszSearch || !*lpszSearch) return NULL; if (IsDBCSLeadByte(*lpszSearch)) ch1 = *lpszSearch << 8 | (UCHAR)lpszSearch[1]; else ch1 = *lpszSearch; iLen = lstrlenA(lpszSearch); if (!lpszEnd) lpszEnd = lpszStr + lstrlenA(lpszStr); else /* reproduce the broken behaviour on Windows */ lpszEnd += min(iLen - 1, lstrlenA(lpszEnd)); while (lpszStr + iLen <= lpszEnd && *lpszStr) { ch2 = IsDBCSLeadByte(*lpszStr)? *lpszStr << 8 | (UCHAR)lpszStr[1] : *lpszStr; if (!ChrCmpIA(ch1, ch2)) { if (!StrCmpNIA(lpszStr, lpszSearch, iLen)) lpszRet = (LPSTR)lpszStr; } lpszStr = CharNextA(lpszStr); } return lpszRet; } /************************************************************************* * StrRStrIW [SHLWAPI.@] * * See StrRStrIA. */ LPWSTR WINAPI StrRStrIW(LPCWSTR lpszStr, LPCWSTR lpszEnd, LPCWSTR lpszSearch) { LPWSTR lpszRet = NULL; INT iLen; TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch)); if (!lpszStr || !lpszSearch || !*lpszSearch) return NULL; iLen = strlenW(lpszSearch); if (!lpszEnd) lpszEnd = lpszStr + strlenW(lpszStr); else /* reproduce the broken behaviour on Windows */ lpszEnd += min(iLen - 1, lstrlenW(lpszEnd)); while (lpszStr + iLen <= lpszEnd && *lpszStr) { if (!ChrCmpIW(*lpszSearch, *lpszStr)) { if (!StrCmpNIW(lpszStr, lpszSearch, iLen)) lpszRet = (LPWSTR)lpszStr; } lpszStr++; } return lpszRet; } /************************************************************************* * StrStrIA [SHLWAPI.@] * * Find a substring within a string, ignoring case. * * PARAMS * lpszStr [I] String to search in * lpszSearch [I] String to look for * * RETURNS * The start of lpszSearch within lpszStr, or NULL if not found. */ LPSTR WINAPI StrStrIA(LPCSTR lpszStr, LPCSTR lpszSearch) { TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch)); return SHLWAPI_StrStrHelperA(lpszStr, lpszSearch, StrCmpNIA); } /************************************************************************* * StrStrIW [SHLWAPI.@] * * See StrStrIA. */ LPWSTR WINAPI StrStrIW(LPCWSTR lpszStr, LPCWSTR lpszSearch) { int iLen; LPCWSTR end; TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch)); if (!lpszStr || !lpszSearch || !*lpszSearch) return NULL; iLen = strlenW(lpszSearch); end = lpszStr + strlenW(lpszStr); while (lpszStr + iLen <= end) { if (!StrCmpNIW(lpszStr, lpszSearch, iLen)) return (LPWSTR)lpszStr; lpszStr++; } return NULL; } /************************************************************************* * StrStrNW [SHLWAPI.@] * * Find a substring within a string up to a given number of initial characters. * * PARAMS * lpFirst [I] String to search in * lpSrch [I] String to look for * cchMax [I] Maximum number of initial search characters * * RETURNS * The start of lpFirst within lpSrch, or NULL if not found. */ LPWSTR WINAPI StrStrNW(LPCWSTR lpFirst, LPCWSTR lpSrch, UINT cchMax) { UINT i; int len; TRACE("(%s, %s, %u)\n", debugstr_w(lpFirst), debugstr_w(lpSrch), cchMax); if (!lpFirst || !lpSrch || !*lpSrch || !cchMax) return NULL; len = strlenW(lpSrch); for (i = cchMax; *lpFirst && (i > 0); i--, lpFirst++) { if (!strncmpW(lpFirst, lpSrch, len)) return (LPWSTR)lpFirst; } return NULL; } /************************************************************************* * StrStrNIW [SHLWAPI.@] * * Find a substring within a string up to a given number of initial characters, * ignoring case. * * PARAMS * lpFirst [I] String to search in * lpSrch [I] String to look for * cchMax [I] Maximum number of initial search characters * * RETURNS * The start of lpFirst within lpSrch, or NULL if not found. */ LPWSTR WINAPI StrStrNIW(LPCWSTR lpFirst, LPCWSTR lpSrch, UINT cchMax) { UINT i; int len; TRACE("(%s, %s, %u)\n", debugstr_w(lpFirst), debugstr_w(lpSrch), cchMax); if (!lpFirst || !lpSrch || !*lpSrch || !cchMax) return NULL; len = strlenW(lpSrch); for (i = cchMax; *lpFirst && (i > 0); i--, lpFirst++) { if (!strncmpiW(lpFirst, lpSrch, len)) return (LPWSTR)lpFirst; } return NULL; } /************************************************************************* * StrToIntA [SHLWAPI.@] * * Read a signed integer from a string. * * PARAMS * lpszStr [I] String to read integer from * * RETURNS * The signed integer value represented by the string, or 0 if no integer is * present. * * NOTES * No leading space is allowed before the number, although a leading '-' is. */ int WINAPI StrToIntA(LPCSTR lpszStr) { int iRet = 0; TRACE("(%s)\n", debugstr_a(lpszStr)); if (!lpszStr) { WARN("Invalid lpszStr would crash under Win32!\n"); return 0; } if (*lpszStr == '-' || isdigit(*lpszStr)) StrToIntExA(lpszStr, 0, &iRet); return iRet; } /************************************************************************* * StrToIntW [SHLWAPI.@] * * See StrToIntA. */ int WINAPI StrToIntW(LPCWSTR lpszStr) { int iRet = 0; TRACE("(%s)\n", debugstr_w(lpszStr)); if (!lpszStr) { WARN("Invalid lpszStr would crash under Win32!\n"); return 0; } if (*lpszStr == '-' || isdigitW(*lpszStr)) StrToIntExW(lpszStr, 0, &iRet); return iRet; } /************************************************************************* * StrToIntExA [SHLWAPI.@] * * Read an integer from a string. * * PARAMS * lpszStr [I] String to read integer from * dwFlags [I] Flags controlling the conversion * lpiRet [O] Destination for read integer. * * RETURNS * Success: TRUE. lpiRet contains the integer value represented by the string. * Failure: FALSE, if the string is invalid, or no number is present. * * NOTES * Leading whitespace, '-' and '+' are allowed before the number. If * dwFlags includes STIF_SUPPORT_HEX, hexadecimal numbers are allowed, if * preceded by '0x'. If this flag is not set, or there is no '0x' prefix, * the string is treated as a decimal string. A leading '-' is ignored for * hexadecimal numbers. */ BOOL WINAPI StrToIntExA(LPCSTR lpszStr, DWORD dwFlags, LPINT lpiRet) { LONGLONG li; BOOL bRes; TRACE("(%s,%08X,%p)\n", debugstr_a(lpszStr), dwFlags, lpiRet); bRes = StrToInt64ExA(lpszStr, dwFlags, &li); if (bRes) *lpiRet = li; return bRes; } /************************************************************************* * StrToInt64ExA [SHLWAPI.@] * * See StrToIntExA. */ BOOL WINAPI StrToInt64ExA(LPCSTR lpszStr, DWORD dwFlags, LONGLONG *lpiRet) { BOOL bNegative = FALSE; LONGLONG iRet = 0; TRACE("(%s,%08X,%p)\n", debugstr_a(lpszStr), dwFlags, lpiRet); if (!lpszStr || !lpiRet) { WARN("Invalid parameter would crash under Win32!\n"); return FALSE; } if (dwFlags > STIF_SUPPORT_HEX) WARN("Unknown flags %08x\n", dwFlags); /* Skip leading space, '+', '-' */ while (isspace(*lpszStr)) lpszStr = CharNextA(lpszStr); if (*lpszStr == '-') { bNegative = TRUE; lpszStr++; } else if (*lpszStr == '+') lpszStr++; if (dwFlags & STIF_SUPPORT_HEX && *lpszStr == '0' && tolower(lpszStr[1]) == 'x') { /* Read hex number */ lpszStr += 2; if (!isxdigit(*lpszStr)) return FALSE; while (isxdigit(*lpszStr)) { iRet = iRet * 16; if (isdigit(*lpszStr)) iRet += (*lpszStr - '0'); else iRet += 10 + (tolower(*lpszStr) - 'a'); lpszStr++; } *lpiRet = iRet; return TRUE; } /* Read decimal number */ if (!isdigit(*lpszStr)) return FALSE; while (isdigit(*lpszStr)) { iRet = iRet * 10; iRet += (*lpszStr - '0'); lpszStr++; } *lpiRet = bNegative ? -iRet : iRet; return TRUE; } /************************************************************************* * StrToIntExW [SHLWAPI.@] * * See StrToIntExA. */ BOOL WINAPI StrToIntExW(LPCWSTR lpszStr, DWORD dwFlags, LPINT lpiRet) { LONGLONG li; BOOL bRes; TRACE("(%s,%08X,%p)\n", debugstr_w(lpszStr), dwFlags, lpiRet); bRes = StrToInt64ExW(lpszStr, dwFlags, &li); if (bRes) *lpiRet = li; return bRes; } /************************************************************************* * StrToInt64ExW [SHLWAPI.@] * * See StrToIntExA. */ BOOL WINAPI StrToInt64ExW(LPCWSTR lpszStr, DWORD dwFlags, LONGLONG *lpiRet) { BOOL bNegative = FALSE; LONGLONG iRet = 0; TRACE("(%s,%08X,%p)\n", debugstr_w(lpszStr), dwFlags, lpiRet); if (!lpszStr || !lpiRet) { WARN("Invalid parameter would crash under Win32!\n"); return FALSE; } if (dwFlags > STIF_SUPPORT_HEX) WARN("Unknown flags %08x\n", dwFlags); /* Skip leading space, '+', '-' */ while (isspaceW(*lpszStr)) lpszStr++; if (*lpszStr == '-') { bNegative = TRUE; lpszStr++; } else if (*lpszStr == '+') lpszStr++; if (dwFlags & STIF_SUPPORT_HEX && *lpszStr == '0' && tolowerW(lpszStr[1]) == 'x') { /* Read hex number */ lpszStr += 2; if (!isxdigitW(*lpszStr)) return FALSE; while (isxdigitW(*lpszStr)) { iRet = iRet * 16; if (isdigitW(*lpszStr)) iRet += (*lpszStr - '0'); else iRet += 10 + (tolowerW(*lpszStr) - 'a'); lpszStr++; } *lpiRet = iRet; return TRUE; } /* Read decimal number */ if (!isdigitW(*lpszStr)) return FALSE; while (isdigitW(*lpszStr)) { iRet = iRet * 10; iRet += (*lpszStr - '0'); lpszStr++; } *lpiRet = bNegative ? -iRet : iRet; return TRUE; } /************************************************************************* * StrDupA [SHLWAPI.@] * * Duplicate a string. * * PARAMS * lpszStr [I] String to duplicate. * * RETURNS * Success: A pointer to a new string containing the contents of lpszStr * Failure: NULL, if memory cannot be allocated * * NOTES * The string memory is allocated with LocalAlloc(), and so should be released * by calling LocalFree(). */ LPSTR WINAPI StrDupA(LPCSTR lpszStr) { int iLen; LPSTR lpszRet; TRACE("(%s)\n",debugstr_a(lpszStr)); iLen = lpszStr ? strlen(lpszStr) + 1 : 1; lpszRet = LocalAlloc(LMEM_FIXED, iLen); if (lpszRet) { if (lpszStr) memcpy(lpszRet, lpszStr, iLen); else *lpszRet = '\0'; } return lpszRet; } /************************************************************************* * StrDupW [SHLWAPI.@] * * See StrDupA. */ LPWSTR WINAPI StrDupW(LPCWSTR lpszStr) { int iLen; LPWSTR lpszRet; TRACE("(%s)\n",debugstr_w(lpszStr)); iLen = (lpszStr ? strlenW(lpszStr) + 1 : 1) * sizeof(WCHAR); lpszRet = LocalAlloc(LMEM_FIXED, iLen); if (lpszRet) { if (lpszStr) memcpy(lpszRet, lpszStr, iLen); else *lpszRet = '\0'; } return lpszRet; } /************************************************************************* * SHLWAPI_StrSpnHelperA * * Internal implementation of StrSpnA/StrCSpnA/StrCSpnIA */ static int SHLWAPI_StrSpnHelperA(LPCSTR lpszStr, LPCSTR lpszMatch, LPSTR (WINAPI *pStrChrFn)(LPCSTR,WORD), BOOL bInvert) { LPCSTR lpszRead = lpszStr; if (lpszStr && *lpszStr && lpszMatch) { while (*lpszRead) { LPCSTR lpszTest = pStrChrFn(lpszMatch, *lpszRead); if (!bInvert && !lpszTest) break; if (bInvert && lpszTest) break; lpszRead = CharNextA(lpszRead); }; } return lpszRead - lpszStr; } /************************************************************************* * StrSpnA [SHLWAPI.@] * * Find the length of the start of a string that contains only certain * characters. * * PARAMS * lpszStr [I] String to search * lpszMatch [I] Characters that can be in the substring * * RETURNS * The length of the part of lpszStr containing only chars from lpszMatch, * or 0 if any parameter is invalid. */ int WINAPI StrSpnA(LPCSTR lpszStr, LPCSTR lpszMatch) { TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch)); return SHLWAPI_StrSpnHelperA(lpszStr, lpszMatch, StrChrA, FALSE); } /************************************************************************* * StrSpnW [SHLWAPI.@] * * See StrSpnA. */ int WINAPI StrSpnW(LPCWSTR lpszStr, LPCWSTR lpszMatch) { if (!lpszStr || !lpszMatch) return 0; return strspnW( lpszStr, lpszMatch ); } /************************************************************************* * StrCSpnA [SHLWAPI.@] * * Find the length of the start of a string that does not contain certain * characters. * * PARAMS * lpszStr [I] String to search * lpszMatch [I] Characters that cannot be in the substring * * RETURNS * The length of the part of lpszStr containing only chars not in lpszMatch, * or 0 if any parameter is invalid. */ int WINAPI StrCSpnA(LPCSTR lpszStr, LPCSTR lpszMatch) { TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch)); return SHLWAPI_StrSpnHelperA(lpszStr, lpszMatch, StrChrA, TRUE); } /************************************************************************* * StrCSpnW [SHLWAPI.@] * * See StrCSpnA. */ int WINAPI StrCSpnW(LPCWSTR lpszStr, LPCWSTR lpszMatch) { if (!lpszStr || !lpszMatch) return 0; return strcspnW( lpszStr, lpszMatch ); } /************************************************************************* * StrCSpnIA [SHLWAPI.@] * * Find the length of the start of a string that does not contain certain * characters, ignoring case. * * PARAMS * lpszStr [I] String to search * lpszMatch [I] Characters that cannot be in the substring * * RETURNS * The length of the part of lpszStr containing only chars not in lpszMatch, * or 0 if any parameter is invalid. */ int WINAPI StrCSpnIA(LPCSTR lpszStr, LPCSTR lpszMatch) { TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch)); return SHLWAPI_StrSpnHelperA(lpszStr, lpszMatch, StrChrIA, TRUE); } /************************************************************************* * StrCSpnIW [SHLWAPI.@] * * See StrCSpnIA. */ int WINAPI StrCSpnIW(LPCWSTR lpszStr, LPCWSTR lpszMatch) { LPCWSTR lpszRead = lpszStr; TRACE("(%s,%s)\n",debugstr_w(lpszStr), debugstr_w(lpszMatch)); if (lpszStr && *lpszStr && lpszMatch) { while (*lpszRead) { if (StrChrIW(lpszMatch, *lpszRead)) break; lpszRead++; } } return lpszRead - lpszStr; } /************************************************************************* * StrPBrkA [SHLWAPI.@] * * Search a string for any of a group of characters. * * PARAMS * lpszStr [I] String to search * lpszMatch [I] Characters to match * * RETURNS * A pointer to the first matching character in lpszStr, or NULL if no * match was found. */ LPSTR WINAPI StrPBrkA(LPCSTR lpszStr, LPCSTR lpszMatch) { TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch)); if (lpszStr && lpszMatch && *lpszMatch) { while (*lpszStr) { if (StrChrA(lpszMatch, *lpszStr)) return (LPSTR)lpszStr; lpszStr = CharNextA(lpszStr); } } return NULL; } /************************************************************************* * StrPBrkW [SHLWAPI.@] * * See StrPBrkA. */ LPWSTR WINAPI StrPBrkW(LPCWSTR lpszStr, LPCWSTR lpszMatch) { if (!lpszStr || !lpszMatch) return NULL; return strpbrkW( lpszStr, lpszMatch ); } /************************************************************************* * SHLWAPI_StrRChrHelperA * * Internal implementation of StrRChrA/StrRChrIA. */ static LPSTR SHLWAPI_StrRChrHelperA(LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch, BOOL (WINAPI *pChrCmpFn)(WORD,WORD)) { LPCSTR lpszRet = NULL; if (lpszStr) { WORD ch2; if (!lpszEnd) lpszEnd = lpszStr + lstrlenA(lpszStr); while (*lpszStr && lpszStr <= lpszEnd) { ch2 = IsDBCSLeadByte(*lpszStr)? *lpszStr << 8 | lpszStr[1] : *lpszStr; if (!pChrCmpFn(ch, ch2)) lpszRet = lpszStr; lpszStr = CharNextA(lpszStr); } } return (LPSTR)lpszRet; } /************************************************************************** * StrRChrA [SHLWAPI.@] * * Find the last occurrence of a character in string. * * PARAMS * lpszStr [I] String to search in * lpszEnd [I] Place to end search, or NULL to search until the end of lpszStr * ch [I] Character to search for. * * RETURNS * Success: A pointer to the last occurrence of ch in lpszStr before lpszEnd, * or NULL if not found. * Failure: NULL, if any arguments are invalid. */ LPSTR WINAPI StrRChrA(LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch) { TRACE("(%s,%s,%x)\n", debugstr_a(lpszStr), debugstr_a(lpszEnd), ch); return SHLWAPI_StrRChrHelperA(lpszStr, lpszEnd, ch, SHLWAPI_ChrCmpA); } /************************************************************************** * StrRChrW [SHLWAPI.@] * * See StrRChrA. */ LPWSTR WINAPI StrRChrW(LPCWSTR str, LPCWSTR end, WORD ch) { WCHAR *ret = NULL; if (!str) return NULL; if (!end) end = str + strlenW(str); while (str < end) { if (*str == ch) ret = (WCHAR *)str; str++; } return ret; } /************************************************************************** * StrRChrIA [SHLWAPI.@] * * Find the last occurrence of a character in string, ignoring case. * * PARAMS * lpszStr [I] String to search in * lpszEnd [I] Place to end search, or NULL to search until the end of lpszStr * ch [I] Character to search for. * * RETURNS * Success: A pointer to the last occurrence of ch in lpszStr before lpszEnd, * or NULL if not found. * Failure: NULL, if any arguments are invalid. */ LPSTR WINAPI StrRChrIA(LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch) { TRACE("(%s,%s,%x)\n", debugstr_a(lpszStr), debugstr_a(lpszEnd), ch); return SHLWAPI_StrRChrHelperA(lpszStr, lpszEnd, ch, ChrCmpIA); } /************************************************************************** * StrRChrIW [SHLWAPI.@] * * See StrRChrIA. */ LPWSTR WINAPI StrRChrIW(LPCWSTR str, LPCWSTR end, WORD ch) { WCHAR *ret = NULL; if (!str) return NULL; if (!end) end = str + strlenW(str); while (str < end) { if (!ChrCmpIW(*str, ch)) ret = (WCHAR *)str; str++; } return ret; } /************************************************************************* * StrCatBuffA [SHLWAPI.@] * * Concatenate two strings together. * * PARAMS * lpszStr [O] String to concatenate to * lpszCat [I] String to add to lpszCat * cchMax [I] Maximum number of characters for the whole string * * RETURNS * lpszStr. * * NOTES * cchMax determines the number of characters in the final length of the * string, not the number appended to lpszStr from lpszCat. */ LPSTR WINAPI StrCatBuffA(LPSTR lpszStr, LPCSTR lpszCat, INT cchMax) { INT iLen; TRACE("(%p,%s,%d)\n", lpszStr, debugstr_a(lpszCat), cchMax); if (!lpszStr) { WARN("Invalid lpszStr would crash under Win32!\n"); return NULL; } iLen = strlen(lpszStr); cchMax -= iLen; if (cchMax > 0) StrCpyNA(lpszStr + iLen, lpszCat, cchMax); return lpszStr; } /************************************************************************* * StrCatBuffW [SHLWAPI.@] * * See StrCatBuffA. */ LPWSTR WINAPI StrCatBuffW(LPWSTR lpszStr, LPCWSTR lpszCat, INT cchMax) { INT iLen; TRACE("(%p,%s,%d)\n", lpszStr, debugstr_w(lpszCat), cchMax); if (!lpszStr) { WARN("Invalid lpszStr would crash under Win32!\n"); return NULL; } iLen = strlenW(lpszStr); cchMax -= iLen; if (cchMax > 0) StrCpyNW(lpszStr + iLen, lpszCat, cchMax); return lpszStr; } /************************************************************************* * StrRetToBufA [SHLWAPI.@] * * Convert a STRRET to a normal string. * * PARAMS * lpStrRet [O] STRRET to convert * pIdl [I] ITEMIDLIST for lpStrRet->uType == STRRET_OFFSET * lpszDest [O] Destination for normal string * dwLen [I] Length of lpszDest * * RETURNS * Success: S_OK. lpszDest contains up to dwLen characters of the string. * If lpStrRet is of type STRRET_WSTR, its memory is freed with * CoTaskMemFree() and its type set to STRRET_CSTRA. * Failure: E_FAIL, if any parameters are invalid. */ HRESULT WINAPI StrRetToBufA (LPSTRRET src, const ITEMIDLIST *pidl, LPSTR dest, UINT len) { /* NOTE: * This routine is identical to that in dlls/shell32/shellstring.c. * It was duplicated because not every version of Shlwapi.dll exports * StrRetToBufA. If you change one routine, change them both. */ TRACE("dest=%p len=0x%x strret=%p pidl=%p\n", dest, len, src, pidl); if (!src) { WARN("Invalid lpStrRet would crash under Win32!\n"); if (dest) *dest = '\0'; return E_FAIL; } if (!dest || !len) return E_FAIL; *dest = '\0'; switch (src->uType) { case STRRET_WSTR: WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, dest, len, NULL, NULL); CoTaskMemFree(src->u.pOleStr); break; case STRRET_CSTR: lstrcpynA(dest, src->u.cStr, len); break; case STRRET_OFFSET: lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len); break; default: FIXME("unknown type!\n"); return FALSE; } return S_OK; } /************************************************************************* * StrRetToBufW [SHLWAPI.@] * * See StrRetToBufA. */ HRESULT WINAPI StrRetToBufW (LPSTRRET src, const ITEMIDLIST *pidl, LPWSTR dest, UINT len) { TRACE("dest=%p len=0x%x strret=%p pidl=%p\n", dest, len, src, pidl); if (!src) { WARN("Invalid lpStrRet would crash under Win32!\n"); if (dest) *dest = '\0'; return E_FAIL; } if (!dest || !len) return E_FAIL; *dest = '\0'; switch (src->uType) { case STRRET_WSTR: lstrcpynW(dest, src->u.pOleStr, len); CoTaskMemFree(src->u.pOleStr); break; case STRRET_CSTR: if (!MultiByteToWideChar( CP_ACP, 0, src->u.cStr, -1, dest, len )) dest[len-1] = 0; break; case STRRET_OFFSET: if (pidl) { if (!MultiByteToWideChar( CP_ACP, 0, ((LPCSTR)&pidl->mkid)+src->u.uOffset, -1, dest, len )) dest[len-1] = 0; } break; default: FIXME("unknown type!\n"); return FALSE; } return S_OK; } /************************************************************************* * StrRetToStrA [SHLWAPI.@] * * Converts a STRRET to a normal string. * * PARAMS * lpStrRet [O] STRRET to convert * pidl [I] ITEMIDLIST for lpStrRet->uType == STRRET_OFFSET * ppszName [O] Destination for converted string * * RETURNS * Success: S_OK. ppszName contains the new string, allocated with CoTaskMemAlloc(). * Failure: E_FAIL, if any parameters are invalid. */ HRESULT WINAPI StrRetToStrA(LPSTRRET lpStrRet, const ITEMIDLIST *pidl, LPSTR *ppszName) { HRESULT hRet = E_FAIL; switch (lpStrRet->uType) { case STRRET_WSTR: hRet = _SHStrDupAW(lpStrRet->u.pOleStr, ppszName); CoTaskMemFree(lpStrRet->u.pOleStr); break; case STRRET_CSTR: hRet = _SHStrDupAA(lpStrRet->u.cStr, ppszName); break; case STRRET_OFFSET: hRet = _SHStrDupAA(((LPCSTR)&pidl->mkid) + lpStrRet->u.uOffset, ppszName); break; default: *ppszName = NULL; } return hRet; } /************************************************************************* * StrRetToStrW [SHLWAPI.@] * * See StrRetToStrA. */ HRESULT WINAPI StrRetToStrW(LPSTRRET lpStrRet, const ITEMIDLIST *pidl, LPWSTR *ppszName) { HRESULT hRet = E_FAIL; switch (lpStrRet->uType) { case STRRET_WSTR: hRet = SHStrDupW(lpStrRet->u.pOleStr, ppszName); CoTaskMemFree(lpStrRet->u.pOleStr); break; case STRRET_CSTR: hRet = SHStrDupA(lpStrRet->u.cStr, ppszName); break; case STRRET_OFFSET: hRet = SHStrDupA(((LPCSTR)&pidl->mkid) + lpStrRet->u.uOffset, ppszName); break; default: *ppszName = NULL; } return hRet; } /* Create an ASCII string copy using SysAllocString() */ static HRESULT _SHStrDupAToBSTR(LPCSTR src, BSTR *pBstrOut) { *pBstrOut = NULL; if (src) { INT len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0); WCHAR* szTemp = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); if (szTemp) { MultiByteToWideChar(CP_ACP, 0, src, -1, szTemp, len); *pBstrOut = SysAllocString(szTemp); HeapFree(GetProcessHeap(), 0, szTemp); if (*pBstrOut) return S_OK; } } return E_OUTOFMEMORY; } /************************************************************************* * StrRetToBSTR [SHLWAPI.@] * * Converts a STRRET to a BSTR. * * PARAMS * lpStrRet [O] STRRET to convert * pidl [I] ITEMIDLIST for lpStrRet->uType = STRRET_OFFSET * pBstrOut [O] Destination for converted BSTR * * RETURNS * Success: S_OK. pBstrOut contains the new string. * Failure: E_FAIL, if any parameters are invalid. */ HRESULT WINAPI StrRetToBSTR(STRRET *lpStrRet, LPCITEMIDLIST pidl, BSTR* pBstrOut) { HRESULT hRet = E_FAIL; switch (lpStrRet->uType) { case STRRET_WSTR: *pBstrOut = SysAllocString(lpStrRet->u.pOleStr); if (*pBstrOut) hRet = S_OK; CoTaskMemFree(lpStrRet->u.pOleStr); break; case STRRET_CSTR: hRet = _SHStrDupAToBSTR(lpStrRet->u.cStr, pBstrOut); break; case STRRET_OFFSET: hRet = _SHStrDupAToBSTR(((LPCSTR)&pidl->mkid) + lpStrRet->u.uOffset, pBstrOut); break; default: *pBstrOut = NULL; } return hRet; } /************************************************************************* * StrFormatKBSizeA [SHLWAPI.@] * * Create a formatted string containing a byte count in Kilobytes. * * PARAMS * llBytes [I] Byte size to format * lpszDest [I] Destination for formatted string * cchMax [I] Size of lpszDest * * RETURNS * lpszDest. */ LPSTR WINAPI StrFormatKBSizeA(LONGLONG llBytes, LPSTR lpszDest, UINT cchMax) { WCHAR wszBuf[256]; if (!StrFormatKBSizeW(llBytes, wszBuf, 256)) return NULL; if (!WideCharToMultiByte(CP_ACP, 0, wszBuf, -1, lpszDest, cchMax, NULL, NULL)) return NULL; return lpszDest; } /************************************************************************* * StrFormatKBSizeW [SHLWAPI.@] * * See StrFormatKBSizeA. */ LPWSTR WINAPI StrFormatKBSizeW(LONGLONG llBytes, LPWSTR lpszDest, UINT cchMax) { static const WCHAR kb[] = {' ','K','B',0}; LONGLONG llKB = (llBytes + 1023) >> 10; int len; TRACE("(0x%s,%p,%d)\n", wine_dbgstr_longlong(llBytes), lpszDest, cchMax); if (!FormatInt(llKB, lpszDest, cchMax)) return NULL; len = lstrlenW(lpszDest); if (cchMax - len < 4) return NULL; lstrcatW(lpszDest, kb); return lpszDest; } /************************************************************************* * StrNCatA [SHLWAPI.@] * * Concatenate two strings together. * * PARAMS * lpszStr [O] String to concatenate to * lpszCat [I] String to add to lpszCat * cchMax [I] Maximum number of characters to concatenate * * RETURNS * lpszStr. * * NOTES * cchMax determines the number of characters that are appended to lpszStr, * not the total length of the string. */ LPSTR WINAPI StrNCatA(LPSTR lpszStr, LPCSTR lpszCat, INT cchMax) { LPSTR lpszRet = lpszStr; TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszCat), cchMax); if (!lpszStr) { WARN("Invalid lpszStr would crash under Win32!\n"); return NULL; } StrCpyNA(lpszStr + strlen(lpszStr), lpszCat, cchMax); return lpszRet; } /************************************************************************* * StrNCatW [SHLWAPI.@] * * See StrNCatA. */ LPWSTR WINAPI StrNCatW(LPWSTR lpszStr, LPCWSTR lpszCat, INT cchMax) { LPWSTR lpszRet = lpszStr; TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszCat), cchMax); if (!lpszStr) { WARN("Invalid lpszStr would crash under Win32\n"); return NULL; } StrCpyNW(lpszStr + strlenW(lpszStr), lpszCat, cchMax); return lpszRet; } /************************************************************************* * StrTrimA [SHLWAPI.@] * * Remove characters from the start and end of a string. * * PARAMS * lpszStr [O] String to remove characters from * lpszTrim [I] Characters to remove from lpszStr * * RETURNS * TRUE If lpszStr was valid and modified * FALSE Otherwise */ BOOL WINAPI StrTrimA(LPSTR lpszStr, LPCSTR lpszTrim) { DWORD dwLen; LPSTR lpszRead = lpszStr; BOOL bRet = FALSE; TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszTrim)); if (lpszRead && *lpszRead) { while (*lpszRead && StrChrA(lpszTrim, *lpszRead)) lpszRead = CharNextA(lpszRead); /* Skip leading matches */ dwLen = strlen(lpszRead); if (lpszRead != lpszStr) { memmove(lpszStr, lpszRead, dwLen + 1); bRet = TRUE; } if (dwLen > 0) { lpszRead = lpszStr + dwLen; while (StrChrA(lpszTrim, lpszRead[-1])) lpszRead = CharPrevA(lpszStr, lpszRead); /* Skip trailing matches */ if (lpszRead != lpszStr + dwLen) { *lpszRead = '\0'; bRet = TRUE; } } } return bRet; } /************************************************************************* * StrTrimW [SHLWAPI.@] * * See StrTrimA. */ BOOL WINAPI StrTrimW(LPWSTR lpszStr, LPCWSTR lpszTrim) { DWORD dwLen; LPWSTR lpszRead = lpszStr; BOOL bRet = FALSE; TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszTrim)); if (lpszRead && *lpszRead) { while (*lpszRead && StrChrW(lpszTrim, *lpszRead)) lpszRead++; dwLen = strlenW(lpszRead); if (lpszRead != lpszStr) { memmove(lpszStr, lpszRead, (dwLen + 1) * sizeof(WCHAR)); bRet = TRUE; } if (dwLen > 0) { lpszRead = lpszStr + dwLen; while (StrChrW(lpszTrim, lpszRead[-1])) lpszRead--; /* Skip trailing matches */ if (lpszRead != lpszStr + dwLen) { *lpszRead = '\0'; bRet = TRUE; } } } return bRet; } /************************************************************************* * _SHStrDupAA [INTERNAL] * * Duplicates a ASCII string to ASCII. The destination buffer is allocated. */ static HRESULT _SHStrDupAA(LPCSTR src, LPSTR * dest) { HRESULT hr; int len = 0; if (src) { len = lstrlenA(src) + 1; *dest = CoTaskMemAlloc(len); } else { *dest = NULL; } if (*dest) { lstrcpynA(*dest,src, len); hr = S_OK; } else { hr = E_OUTOFMEMORY; } TRACE("%s->(%p)\n", debugstr_a(src), *dest); return hr; } /************************************************************************* * SHStrDupA [SHLWAPI.@] * * Return a Unicode copy of a string, in memory allocated by CoTaskMemAlloc(). * * PARAMS * lpszStr [I] String to copy * lppszDest [O] Destination for the new string copy * * RETURNS * Success: S_OK. lppszDest contains the new string in Unicode format. * Failure: E_OUTOFMEMORY, If any arguments are invalid or memory allocation * fails. */ HRESULT WINAPI SHStrDupA(LPCSTR lpszStr, LPWSTR * lppszDest) { HRESULT hRet; int len = 0; if (lpszStr) { len = MultiByteToWideChar(CP_ACP, 0, lpszStr, -1, NULL, 0) * sizeof(WCHAR); *lppszDest = CoTaskMemAlloc(len); } else *lppszDest = NULL; if (*lppszDest) { MultiByteToWideChar(CP_ACP, 0, lpszStr, -1, *lppszDest, len/sizeof(WCHAR)); hRet = S_OK; } else hRet = E_OUTOFMEMORY; TRACE("%s->(%p)\n", debugstr_a(lpszStr), *lppszDest); return hRet; } /************************************************************************* * _SHStrDupAW [INTERNAL] * * Duplicates a UNICODE to a ASCII string. The destination buffer is allocated. */ static HRESULT _SHStrDupAW(LPCWSTR src, LPSTR * dest) { HRESULT hr; int len = 0; if (src) { len = WideCharToMultiByte(CP_ACP, 0, src, -1, NULL, 0, NULL, NULL); *dest = CoTaskMemAlloc(len); } else { *dest = NULL; } if (*dest) { WideCharToMultiByte(CP_ACP, 0, src, -1, *dest, len, NULL, NULL); hr = S_OK; } else { hr = E_OUTOFMEMORY; } TRACE("%s->(%p)\n", debugstr_w(src), *dest); return hr; } /************************************************************************* * SHStrDupW [SHLWAPI.@] * * See SHStrDupA. */ HRESULT WINAPI SHStrDupW(LPCWSTR src, LPWSTR * dest) { HRESULT hr; int len = 0; if (src) { len = (lstrlenW(src) + 1) * sizeof(WCHAR); *dest = CoTaskMemAlloc(len); } else { *dest = NULL; } if (*dest) { memcpy(*dest, src, len); hr = S_OK; } else { hr = E_OUTOFMEMORY; } TRACE("%s->(%p)\n", debugstr_w(src), *dest); return hr; } /************************************************************************* * SHLWAPI_WriteReverseNum * * Internal helper for SHLWAPI_WriteTimeClass. */ static inline LPWSTR SHLWAPI_WriteReverseNum(LPWSTR lpszOut, DWORD dwNum) { *lpszOut-- = '\0'; /* Write a decimal number to a string, backwards */ do { DWORD dwNextDigit = dwNum % 10; *lpszOut-- = '0' + dwNextDigit; dwNum = (dwNum - dwNextDigit) / 10; } while (dwNum > 0); return lpszOut; } /************************************************************************* * SHLWAPI_FormatSignificant * * Internal helper for SHLWAPI_WriteTimeClass. */ static inline int SHLWAPI_FormatSignificant(LPWSTR lpszNum, int dwDigits) { /* Zero non significant digits, return remaining significant digits */ while (*lpszNum) { lpszNum++; if (--dwDigits == 0) { while (*lpszNum) *lpszNum++ = '0'; return 0; } } return dwDigits; } /************************************************************************* * SHLWAPI_WriteTimeClass * * Internal helper for StrFromTimeIntervalW. */ static int SHLWAPI_WriteTimeClass(LPWSTR lpszOut, DWORD dwValue, UINT uClassStringId, int iDigits) { WCHAR szBuff[64], *szOut = szBuff + 32; szOut = SHLWAPI_WriteReverseNum(szOut, dwValue); iDigits = SHLWAPI_FormatSignificant(szOut + 1, iDigits); *szOut = ' '; LoadStringW(shlwapi_hInstance, uClassStringId, szBuff + 32, 32); strcatW(lpszOut, szOut); return iDigits; } /************************************************************************* * StrFromTimeIntervalA [SHLWAPI.@] * * Format a millisecond time interval into a string * * PARAMS * lpszStr [O] Output buffer for formatted time interval * cchMax [I] Size of lpszStr * dwMS [I] Number of milliseconds * iDigits [I] Number of digits to print * * RETURNS * The length of the formatted string, or 0 if any parameter is invalid. * * NOTES * This implementation mimics the Win32 behaviour of always writing a leading * space before the time interval begins. * * iDigits is used to provide approximate times if accuracy is not important. * This number of digits will be written of the first non-zero time class * (hours/minutes/seconds). If this does not complete the time classification, * the remaining digits are changed to zeros (i.e. The time is _not_ rounded). * If there are digits remaining following the writing of a time class, the * next time class will be written. * * For example, given dwMS represents 138 hours,43 minutes and 15 seconds, the * following will result from the given values of iDigits: * *| iDigits 1 2 3 4 5 ... *| lpszStr "100 hr" "130 hr" "138 hr" "138 hr 40 min" "138 hr 43 min" ... */ INT WINAPI StrFromTimeIntervalA(LPSTR lpszStr, UINT cchMax, DWORD dwMS, int iDigits) { INT iRet = 0; TRACE("(%p,%d,%d,%d)\n", lpszStr, cchMax, dwMS, iDigits); if (lpszStr && cchMax) { WCHAR szBuff[128]; StrFromTimeIntervalW(szBuff, sizeof(szBuff)/sizeof(WCHAR), dwMS, iDigits); WideCharToMultiByte(CP_ACP,0,szBuff,-1,lpszStr,cchMax,0,0); } return iRet; } /************************************************************************* * StrFromTimeIntervalW [SHLWAPI.@] * * See StrFromTimeIntervalA. */ INT WINAPI StrFromTimeIntervalW(LPWSTR lpszStr, UINT cchMax, DWORD dwMS, int iDigits) { INT iRet = 0; TRACE("(%p,%d,%d,%d)\n", lpszStr, cchMax, dwMS, iDigits); if (lpszStr && cchMax) { WCHAR szCopy[128]; DWORD dwHours, dwMinutes; if (!iDigits || cchMax == 1) { *lpszStr = '\0'; return 0; } /* Calculate the time classes */ dwMS = (dwMS + 500) / 1000; dwHours = dwMS / 3600; dwMS -= dwHours * 3600; dwMinutes = dwMS / 60; dwMS -= dwMinutes * 60; szCopy[0] = '\0'; if (dwHours) iDigits = SHLWAPI_WriteTimeClass(szCopy, dwHours, IDS_TIME_INTERVAL_HOURS, iDigits); if (dwMinutes && iDigits) iDigits = SHLWAPI_WriteTimeClass(szCopy, dwMinutes, IDS_TIME_INTERVAL_MINUTES, iDigits); if (iDigits) /* Always write seconds if we have significant digits */ SHLWAPI_WriteTimeClass(szCopy, dwMS, IDS_TIME_INTERVAL_SECONDS, iDigits); lstrcpynW(lpszStr, szCopy, cchMax); iRet = strlenW(lpszStr); } return iRet; } /************************************************************************* * StrIsIntlEqualA [SHLWAPI.@] * * Compare two strings. * * PARAMS * bCase [I] Whether to compare case sensitively * lpszStr [I] First string to compare * lpszComp [I] Second string to compare * iLen [I] Length to compare * * RETURNS * TRUE If the strings are equal. * FALSE Otherwise. */ BOOL WINAPI StrIsIntlEqualA(BOOL bCase, LPCSTR lpszStr, LPCSTR lpszComp, int iLen) { DWORD dwFlags; TRACE("(%d,%s,%s,%d)\n", bCase, debugstr_a(lpszStr), debugstr_a(lpszComp), iLen); /* FIXME: This flag is undocumented and unknown by our CompareString. * We need a define for it. */ dwFlags = 0x10000000; if (!bCase) dwFlags |= NORM_IGNORECASE; return (CompareStringA(GetThreadLocale(), dwFlags, lpszStr, iLen, lpszComp, iLen) == CSTR_EQUAL); } /************************************************************************* * StrIsIntlEqualW [SHLWAPI.@] * * See StrIsIntlEqualA. */ BOOL WINAPI StrIsIntlEqualW(BOOL bCase, LPCWSTR lpszStr, LPCWSTR lpszComp, int iLen) { DWORD dwFlags; TRACE("(%d,%s,%s,%d)\n", bCase, debugstr_w(lpszStr),debugstr_w(lpszComp), iLen); /* FIXME: This flag is undocumented and unknown by our CompareString. * We need a define for it. */ dwFlags = 0x10000000; if (!bCase) dwFlags |= NORM_IGNORECASE; return (CompareStringW(GetThreadLocale(), dwFlags, lpszStr, iLen, lpszComp, iLen) == CSTR_EQUAL); } /************************************************************************* * @ [SHLWAPI.399] * * Copy a string to another string, up to a maximum number of characters. * * PARAMS * lpszDest [O] Destination string * lpszSrc [I] Source string * iLen [I] Maximum number of chars to copy * * RETURNS * Success: A pointer to the last character written to lpszDest. * Failure: lpszDest, if any arguments are invalid. */ LPSTR WINAPI StrCpyNXA(LPSTR lpszDest, LPCSTR lpszSrc, int iLen) { TRACE("(%p,%s,%i)\n", lpszDest, debugstr_a(lpszSrc), iLen); if (lpszDest && lpszSrc && iLen > 0) { while ((iLen-- > 1) && *lpszSrc) *lpszDest++ = *lpszSrc++; if (iLen >= 0) *lpszDest = '\0'; } return lpszDest; } /************************************************************************* * @ [SHLWAPI.400] * * Unicode version of StrCpyNXA. */ LPWSTR WINAPI StrCpyNXW(LPWSTR lpszDest, LPCWSTR lpszSrc, int iLen) { TRACE("(%p,%s,%i)\n", lpszDest, debugstr_w(lpszSrc), iLen); if (lpszDest && lpszSrc && iLen > 0) { while ((iLen-- > 1) && *lpszSrc) *lpszDest++ = *lpszSrc++; if (iLen >= 0) *lpszDest = '\0'; } return lpszDest; } /************************************************************************* * StrCmpLogicalW [SHLWAPI.@] * * Compare two strings, ignoring case and comparing digits as numbers. * * PARAMS * lpszStr [I] First string to compare * lpszComp [I] Second string to compare * iLen [I] Length to compare * * RETURNS * TRUE If the strings are equal. * FALSE Otherwise. */ INT WINAPI StrCmpLogicalW(LPCWSTR lpszStr, LPCWSTR lpszComp) { INT iDiff; TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszComp)); if (lpszStr && lpszComp) { while (*lpszStr) { if (!*lpszComp) return 1; else if (isdigitW(*lpszStr)) { int iStr, iComp; if (!isdigitW(*lpszComp)) return -1; /* Compare the numbers */ StrToIntExW(lpszStr, 0, &iStr); StrToIntExW(lpszComp, 0, &iComp); if (iStr < iComp) return -1; else if (iStr > iComp) return 1; /* Skip */ while (isdigitW(*lpszStr)) lpszStr++; while (isdigitW(*lpszComp)) lpszComp++; } else if (isdigitW(*lpszComp)) return 1; else { iDiff = ChrCmpIW(*lpszStr,*lpszComp); if (iDiff > 0) return 1; else if (iDiff < 0) return -1; lpszStr++; lpszComp++; } } if (*lpszComp) return -1; } return 0; } /* Structure for formatting byte strings */ typedef struct tagSHLWAPI_BYTEFORMATS { LONGLONG dLimit; double dDivisor; double dNormaliser; int nDecimals; WCHAR wPrefix; } SHLWAPI_BYTEFORMATS; /************************************************************************* * StrFormatByteSizeW [SHLWAPI.@] * * Create a string containing an abbreviated byte count of up to 2^63-1. * * PARAMS * llBytes [I] Byte size to format * lpszDest [I] Destination for formatted string * cchMax [I] Size of lpszDest * * RETURNS * lpszDest. * * NOTES * There is no StrFormatByteSize64W function, it is called StrFormatByteSizeW(). */ LPWSTR WINAPI StrFormatByteSizeW(LONGLONG llBytes, LPWSTR lpszDest, UINT cchMax) { #define KB ((ULONGLONG)1024) #define MB (KB*KB) #define GB (KB*KB*KB) #define TB (KB*KB*KB*KB) #define PB (KB*KB*KB*KB*KB) static const SHLWAPI_BYTEFORMATS bfFormats[] = { { 10*KB, 10.24, 100.0, 2, 'K' }, /* 10 KB */ { 100*KB, 102.4, 10.0, 1, 'K' }, /* 100 KB */ { 1000*KB, 1024.0, 1.0, 0, 'K' }, /* 1000 KB */ { 10*MB, 10485.76, 100.0, 2, 'M' }, /* 10 MB */ { 100*MB, 104857.6, 10.0, 1, 'M' }, /* 100 MB */ { 1000*MB, 1048576.0, 1.0, 0, 'M' }, /* 1000 MB */ { 10*GB, 10737418.24, 100.0, 2, 'G' }, /* 10 GB */ { 100*GB, 107374182.4, 10.0, 1, 'G' }, /* 100 GB */ { 1000*GB, 1073741824.0, 1.0, 0, 'G' }, /* 1000 GB */ { 10*TB, 10485.76, 100.0, 2, 'T' }, /* 10 TB */ { 100*TB, 104857.6, 10.0, 1, 'T' }, /* 100 TB */ { 1000*TB, 1048576.0, 1.0, 0, 'T' }, /* 1000 TB */ { 10*PB, 10737418.24, 100.00, 2, 'P' }, /* 10 PB */ { 100*PB, 107374182.4, 10.00, 1, 'P' }, /* 100 PB */ { 1000*PB, 1073741824.0, 1.00, 0, 'P' }, /* 1000 PB */ { 0, 10995116277.76, 100.00, 2, 'E' } /* EB's, catch all */ }; WCHAR wszAdd[] = {' ','?','B',0}; double dBytes; UINT i = 0; TRACE("(0x%s,%p,%d)\n", wine_dbgstr_longlong(llBytes), lpszDest, cchMax); if (!lpszDest || !cchMax) return lpszDest; if (llBytes < 1024) /* 1K */ { WCHAR wszBytesFormat[64]; LoadStringW(shlwapi_hInstance, IDS_BYTES_FORMAT, wszBytesFormat, 64); snprintfW(lpszDest, cchMax, wszBytesFormat, (int)llBytes); return lpszDest; } /* Note that if this loop completes without finding a match, i will be * pointing at the last entry, which is a catch all for > 1000 PB */ while (i < sizeof(bfFormats) / sizeof(SHLWAPI_BYTEFORMATS) - 1) { if (llBytes < bfFormats[i].dLimit) break; i++; } /* Above 1 TB we encounter problems with FP accuracy. So for amounts above * this number we integer shift down by 1 MB first. The table above has * the divisors scaled down from the '< 10 TB' entry onwards, to account * for this. We also add a small fudge factor to get the correct result for * counts that lie exactly on a 1024 byte boundary. */ if (i > 8) dBytes = (double)(llBytes >> 20) + 0.001; /* Scale down by 1 MB */ else dBytes = (double)llBytes + 0.00001; dBytes = floor(dBytes / bfFormats[i].dDivisor) / bfFormats[i].dNormaliser; if (!FormatDouble(dBytes, bfFormats[i].nDecimals, lpszDest, cchMax)) return NULL; wszAdd[1] = bfFormats[i].wPrefix; StrCatBuffW(lpszDest, wszAdd, cchMax); return lpszDest; } /************************************************************************* * StrFormatByteSize64A [SHLWAPI.@] * * See StrFormatByteSizeW. */ LPSTR WINAPI StrFormatByteSize64A(LONGLONG llBytes, LPSTR lpszDest, UINT cchMax) { WCHAR wszBuff[32]; StrFormatByteSizeW(llBytes, wszBuff, sizeof(wszBuff)/sizeof(WCHAR)); if (lpszDest) WideCharToMultiByte(CP_ACP, 0, wszBuff, -1, lpszDest, cchMax, 0, 0); return lpszDest; } /************************************************************************* * StrFormatByteSizeA [SHLWAPI.@] * * Create a string containing an abbreviated byte count of up to 2^31-1. * * PARAMS * dwBytes [I] Byte size to format * lpszDest [I] Destination for formatted string * cchMax [I] Size of lpszDest * * RETURNS * lpszDest. * * NOTES * The Ascii and Unicode versions of this function accept a different * integer type for dwBytes. See StrFormatByteSize64A(). */ LPSTR WINAPI StrFormatByteSizeA(DWORD dwBytes, LPSTR lpszDest, UINT cchMax) { TRACE("(%d,%p,%d)\n", dwBytes, lpszDest, cchMax); return StrFormatByteSize64A(dwBytes, lpszDest, cchMax); } /************************************************************************* * @ [SHLWAPI.162] * * Remove a hanging lead byte from the end of a string, if present. * * PARAMS * lpStr [I] String to check for a hanging lead byte * size [I] Length of lpStr * * RETURNS * Success: The new length of the string. Any hanging lead bytes are removed. * Failure: 0, if any parameters are invalid. */ DWORD WINAPI SHTruncateString(LPSTR lpStr, DWORD size) { if (lpStr && size) { LPSTR lastByte = lpStr + size - 1; while(lpStr < lastByte) lpStr += IsDBCSLeadByte(*lpStr) ? 2 : 1; if(lpStr == lastByte && IsDBCSLeadByte(*lpStr)) { *lpStr = '\0'; size--; } return size; } return 0; } /************************************************************************* * @ [SHLWAPI.203] * * Remove a single non-trailing ampersand ('&') from a string. * * PARAMS * lpszStr [I/O] String to remove ampersand from. * * RETURNS * The character after the first ampersand in lpszStr, or the first character * in lpszStr if there is no ampersand in the string. */ char WINAPI SHStripMneumonicA(LPCSTR lpszStr) { LPSTR lpszIter, lpszTmp; char ch; TRACE("(%s)\n", debugstr_a(lpszStr)); ch = *lpszStr; if ((lpszIter = StrChrA(lpszStr, '&'))) { lpszTmp = CharNextA(lpszIter); if (*lpszTmp) { if (*lpszTmp != '&') ch = *lpszTmp; memmove( lpszIter, lpszTmp, strlen(lpszTmp) + 1 ); } } return ch; } /************************************************************************* * @ [SHLWAPI.225] * * Unicode version of SHStripMneumonicA. */ WCHAR WINAPI SHStripMneumonicW(LPCWSTR lpszStr) { LPWSTR lpszIter, lpszTmp; WCHAR ch; TRACE("(%s)\n", debugstr_w(lpszStr)); ch = *lpszStr; if ((lpszIter = StrChrW(lpszStr, '&'))) { lpszTmp = lpszIter + 1; if (*lpszTmp) { if (*lpszTmp != '&') ch = *lpszTmp; memmove( lpszIter, lpszTmp, (strlenW(lpszTmp) + 1) * sizeof(WCHAR) ); } } return ch; } /************************************************************************* * @ [SHLWAPI.216] * * Convert an Ascii string to Unicode. * * PARAMS * dwCp [I] Code page for the conversion * lpSrcStr [I] Source Ascii string to convert * lpDstStr [O] Destination for converted Unicode string * iLen [I] Length of lpDstStr * * RETURNS * The return value of the MultiByteToWideChar() function called on lpSrcStr. */ DWORD WINAPI SHAnsiToUnicodeCP(DWORD dwCp, LPCSTR lpSrcStr, LPWSTR lpDstStr, int iLen) { DWORD dwRet; dwRet = MultiByteToWideChar(dwCp, 0, lpSrcStr, -1, lpDstStr, iLen); TRACE("%s->%s,ret=%d\n", debugstr_a(lpSrcStr), debugstr_w(lpDstStr), dwRet); return dwRet; } /************************************************************************* * @ [SHLWAPI.215] * * Convert an Ascii string to Unicode. * * PARAMS * lpSrcStr [I] Source Ascii string to convert * lpDstStr [O] Destination for converted Unicode string * iLen [I] Length of lpDstStr * * RETURNS * The return value of the MultiByteToWideChar() function called on lpSrcStr. * * NOTES * This function simply calls SHAnsiToUnicodeCP with code page CP_ACP. */ DWORD WINAPI SHAnsiToUnicode(LPCSTR lpSrcStr, LPWSTR lpDstStr, int iLen) { return SHAnsiToUnicodeCP(CP_ACP, lpSrcStr, lpDstStr, iLen); } /************************************************************************* * @ [SHLWAPI.218] * * Convert a Unicode string to Ascii. * * PARAMS * CodePage [I] Code page to use for the conversion * lpSrcStr [I] Source Unicode string to convert * lpDstStr [O] Destination for converted Ascii string * dstlen [I] Length of buffer at lpDstStr * * RETURNS * Success: The length in bytes of the result at lpDstStr (including the terminator) * Failure: When using CP_UTF8, CP_UTF7 or 0xc350 as codePage, 0 is returned and * the result is not nul-terminated. * When using a different codepage, the length in bytes of the truncated * result at lpDstStr (including the terminator) is returned and * lpDstStr is always nul-terminated. * */ DWORD WINAPI SHUnicodeToAnsiCP(UINT CodePage, LPCWSTR lpSrcStr, LPSTR lpDstStr, int dstlen) { static const WCHAR emptyW[] = { '\0' }; int len , reqLen; LPSTR mem; if (!lpDstStr || !dstlen) return 0; if (!lpSrcStr) lpSrcStr = emptyW; *lpDstStr = '\0'; len = strlenW(lpSrcStr) + 1; switch (CodePage) { case CP_WINUNICODE: CodePage = CP_UTF8; /* Fall through... */ case 0x0000C350: /* FIXME: CP_ #define */ case CP_UTF7: case CP_UTF8: { DWORD dwMode = 0; INT lenW = len - 1; INT needed = dstlen - 1; HRESULT hr; /* try the user supplied buffer first */ hr = ConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &lenW, lpDstStr, &needed); if (hr == S_OK) { lpDstStr[needed] = '\0'; return needed + 1; } /* user buffer too small. exclude termination and copy as much as possible */ lenW = len; hr = ConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &lenW, NULL, &needed); needed++; mem = HeapAlloc(GetProcessHeap(), 0, needed); if (!mem) return 0; hr = ConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &len, mem, &needed); if (hr == S_OK) { reqLen = SHTruncateString(mem, dstlen); if (reqLen > 0) memcpy(lpDstStr, mem, reqLen-1); } HeapFree(GetProcessHeap(), 0, mem); return 0; } default: break; } /* try the user supplied buffer first */ reqLen = WideCharToMultiByte(CodePage, 0, lpSrcStr, len, lpDstStr, dstlen, NULL, NULL); if (!reqLen && GetLastError() == ERROR_INSUFFICIENT_BUFFER) { reqLen = WideCharToMultiByte(CodePage, 0, lpSrcStr, len, NULL, 0, NULL, NULL); if (reqLen) { mem = HeapAlloc(GetProcessHeap(), 0, reqLen); if (mem) { WideCharToMultiByte(CodePage, 0, lpSrcStr, len, mem, reqLen, NULL, NULL); reqLen = SHTruncateString(mem, dstlen -1); reqLen++; lstrcpynA(lpDstStr, mem, reqLen); HeapFree(GetProcessHeap(), 0, mem); lpDstStr[reqLen-1] = '\0'; } } } return reqLen; } /************************************************************************* * @ [SHLWAPI.217] * * Convert a Unicode string to Ascii. * * PARAMS * lpSrcStr [I] Source Unicode string to convert * lpDstStr [O] Destination for converted Ascii string * iLen [O] Length of lpDstStr in characters * * RETURNS * See SHUnicodeToAnsiCP * NOTES * This function simply calls SHUnicodeToAnsiCP() with CodePage = CP_ACP. */ INT WINAPI SHUnicodeToAnsi(LPCWSTR lpSrcStr, LPSTR lpDstStr, INT iLen) { return SHUnicodeToAnsiCP(CP_ACP, lpSrcStr, lpDstStr, iLen); } /************************************************************************* * @ [SHLWAPI.345] * * Copy one string to another. * * PARAMS * lpszSrc [I] Source string to copy * lpszDst [O] Destination for copy * iLen [I] Length of lpszDst in characters * * RETURNS * The length of the copied string, including the terminating NUL. lpszDst * contains iLen characters of lpszSrc. */ DWORD WINAPI SHAnsiToAnsi(LPCSTR lpszSrc, LPSTR lpszDst, int iLen) { LPSTR lpszRet; TRACE("(%s,%p,0x%08x)\n", debugstr_a(lpszSrc), lpszDst, iLen); lpszRet = StrCpyNXA(lpszDst, lpszSrc, iLen); return lpszRet - lpszDst + 1; } /************************************************************************* * @ [SHLWAPI.346] * * Unicode version of SSHAnsiToAnsi. */ DWORD WINAPI SHUnicodeToUnicode(LPCWSTR lpszSrc, LPWSTR lpszDst, int iLen) { LPWSTR lpszRet; TRACE("(%s,%p,0x%08x)\n", debugstr_w(lpszSrc), lpszDst, iLen); lpszRet = StrCpyNXW(lpszDst, lpszSrc, iLen); return lpszRet - lpszDst + 1; } /************************************************************************* * @ [SHLWAPI.364] * * Determine if an Ascii string converts to Unicode and back identically. * * PARAMS * lpSrcStr [I] Source Unicode string to convert * lpDst [O] Destination for resulting Ascii string * iLen [I] Length of lpDst in characters * * RETURNS * TRUE, since Ascii strings always convert identically. */ BOOL WINAPI DoesStringRoundTripA(LPCSTR lpSrcStr, LPSTR lpDst, INT iLen) { lstrcpynA(lpDst, lpSrcStr, iLen); return TRUE; } /************************************************************************* * @ [SHLWAPI.365] * * Determine if a Unicode string converts to Ascii and back identically. * * PARAMS * lpSrcStr [I] Source Unicode string to convert * lpDst [O] Destination for resulting Ascii string * iLen [I] Length of lpDst in characters * * RETURNS * TRUE, if lpSrcStr converts to Ascii and back identically, * FALSE otherwise. */ BOOL WINAPI DoesStringRoundTripW(LPCWSTR lpSrcStr, LPSTR lpDst, INT iLen) { WCHAR szBuff[MAX_PATH]; SHUnicodeToAnsi(lpSrcStr, lpDst, iLen); SHAnsiToUnicode(lpDst, szBuff, MAX_PATH); return !strcmpW(lpSrcStr, szBuff); } /************************************************************************* * SHLoadIndirectString [SHLWAPI.@] * * If passed a string that begins with '@', extract the string from the * appropriate resource, otherwise do a straight copy. * */ HRESULT WINAPI SHLoadIndirectString(LPCWSTR src, LPWSTR dst, UINT dst_len, void **reserved) { WCHAR *dllname = NULL; HMODULE hmod = NULL; HRESULT hr = E_FAIL; TRACE("(%s %p %08x %p)\n", debugstr_w(src), dst, dst_len, reserved); if(src[0] == '@') { WCHAR *index_str; int index; dst[0] = 0; dllname = StrDupW(src + 1); index_str = strchrW(dllname, ','); if(!index_str) goto end; *index_str = 0; index_str++; index = atoiW(index_str); hmod = LoadLibraryW(dllname); if(!hmod) goto end; if(index < 0) { if(LoadStringW(hmod, -index, dst, dst_len)) hr = S_OK; } else FIXME("can't handle non-negative indices (%d)\n", index); } else { if(dst != src) lstrcpynW(dst, src, dst_len); hr = S_OK; } TRACE("returning %s\n", debugstr_w(dst)); end: if(hmod) FreeLibrary(hmod); LocalFree(dllname); return hr; } BOOL WINAPI IsCharSpaceA(CHAR c) { WORD CharType; return GetStringTypeA(GetSystemDefaultLCID(), CT_CTYPE1, &c, 1, &CharType) && (CharType & C1_SPACE); } /************************************************************************* * @ [SHLWAPI.29] * * Determine if a Unicode character is a space. * * PARAMS * wc [I] Character to check. * * RETURNS * TRUE, if wc is a space, * FALSE otherwise. */ BOOL WINAPI IsCharSpaceW(WCHAR wc) { WORD CharType; return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_SPACE); }