ReactOS 0.4.15-dev-7788-g1ad9096
string.c File Reference
#include "config.h"
#include "wine/port.h"
#include <math.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#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"
Include dependency graph for string.c:

Go to the source code of this file.

Classes

struct  tagSHLWAPI_BYTEFORMATS
 

Macros

#define NONAMELESSUNION
 
#define NO_SHLWAPI_REG
 
#define NO_SHLWAPI_STREAM
 
#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)
 

Typedefs

typedef struct tagSHLWAPI_BYTEFORMATS SHLWAPI_BYTEFORMATS
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (shell)
 
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)
 
static int FormatInt (LONGLONG qdwValue, LPWSTR pszBuf, int cchBuf)
 
static int FormatDouble (double value, int decimals, LPWSTR pszBuf, int cchBuf)
 
static BOOL SHLWAPI_ChrCmpHelperA (WORD ch1, WORD ch2, DWORD dwFlags)
 
static BOOL WINAPI SHLWAPI_ChrCmpA (WORD ch1, WORD ch2)
 
BOOL WINAPI ChrCmpIA (WORD ch1, WORD ch2)
 
BOOL WINAPI ChrCmpIW (WCHAR ch1, WCHAR ch2)
 
LPSTR WINAPI StrChrA (LPCSTR lpszStr, WORD ch)
 
LPWSTR WINAPI StrChrW (LPCWSTR lpszStr, WCHAR ch)
 
LPSTR WINAPI StrChrIA (LPCSTR lpszStr, WORD ch)
 
LPWSTR WINAPI StrChrIW (LPCWSTR lpszStr, WCHAR ch)
 
LPWSTR WINAPI StrChrNW (LPCWSTR lpszStr, WCHAR ch, UINT cchMax)
 
int WINAPI StrCmpIW (LPCWSTR lpszStr, LPCWSTR lpszComp)
 
INT WINAPI StrCmpNA (LPCSTR lpszStr, LPCSTR lpszComp, INT iLen)
 
INT WINAPI StrCmpNW (LPCWSTR lpszStr, LPCWSTR lpszComp, INT iLen)
 
int WINAPI StrCmpNIA (LPCSTR lpszStr, LPCSTR lpszComp, int iLen)
 
INT WINAPI StrCmpNIW (LPCWSTR lpszStr, LPCWSTR lpszComp, int iLen)
 
int WINAPI StrCmpW (LPCWSTR lpszStr, LPCWSTR lpszComp)
 
LPWSTR WINAPI StrCatW (LPWSTR lpszStr, LPCWSTR lpszSrc)
 
DWORD WINAPI StrCatChainW (LPWSTR lpszStr, DWORD cchMax, DWORD ichAt, LPCWSTR lpszCat)
 
LPWSTR WINAPI StrCpyW (LPWSTR lpszStr, LPCWSTR lpszSrc)
 
LPWSTR WINAPI StrCpyNW (LPWSTR dst, LPCWSTR src, int count)
 
static LPSTR SHLWAPI_StrStrHelperA (LPCSTR lpszStr, LPCSTR lpszSearch, INT(WINAPI *pStrCmpFn)(LPCSTR, LPCSTR, INT))
 
LPSTR WINAPI StrStrA (LPCSTR lpszStr, LPCSTR lpszSearch)
 
LPWSTR WINAPI StrStrW (LPCWSTR lpszStr, LPCWSTR lpszSearch)
 
LPSTR WINAPI StrRStrIA (LPCSTR lpszStr, LPCSTR lpszEnd, LPCSTR lpszSearch)
 
LPWSTR WINAPI StrRStrIW (LPCWSTR lpszStr, LPCWSTR lpszEnd, LPCWSTR lpszSearch)
 
LPSTR WINAPI StrStrIA (LPCSTR lpszStr, LPCSTR lpszSearch)
 
LPWSTR WINAPI StrStrIW (LPCWSTR lpszStr, LPCWSTR lpszSearch)
 
LPWSTR WINAPI StrStrNW (LPCWSTR lpFirst, LPCWSTR lpSrch, UINT cchMax)
 
LPWSTR WINAPI StrStrNIW (LPCWSTR lpFirst, LPCWSTR lpSrch, UINT cchMax)
 
int WINAPI StrToIntA (LPCSTR lpszStr)
 
int WINAPI StrToIntW (LPCWSTR lpszStr)
 
BOOL WINAPI StrToIntExA (LPCSTR lpszStr, DWORD dwFlags, LPINT lpiRet)
 
BOOL WINAPI StrToInt64ExA (LPCSTR lpszStr, DWORD dwFlags, LONGLONG *lpiRet)
 
BOOL WINAPI StrToIntExW (LPCWSTR lpszStr, DWORD dwFlags, LPINT lpiRet)
 
BOOL WINAPI StrToInt64ExW (LPCWSTR lpszStr, DWORD dwFlags, LONGLONG *lpiRet)
 
LPSTR WINAPI StrDupA (LPCSTR lpszStr)
 
LPWSTR WINAPI StrDupW (LPCWSTR lpszStr)
 
static int SHLWAPI_StrSpnHelperA (LPCSTR lpszStr, LPCSTR lpszMatch, LPSTR(WINAPI *pStrChrFn)(LPCSTR, WORD), BOOL bInvert)
 
int WINAPI StrSpnA (LPCSTR lpszStr, LPCSTR lpszMatch)
 
int WINAPI StrSpnW (LPCWSTR lpszStr, LPCWSTR lpszMatch)
 
int WINAPI StrCSpnA (LPCSTR lpszStr, LPCSTR lpszMatch)
 
int WINAPI StrCSpnW (LPCWSTR lpszStr, LPCWSTR lpszMatch)
 
int WINAPI StrCSpnIA (LPCSTR lpszStr, LPCSTR lpszMatch)
 
int WINAPI StrCSpnIW (LPCWSTR lpszStr, LPCWSTR lpszMatch)
 
LPSTR WINAPI StrPBrkA (LPCSTR lpszStr, LPCSTR lpszMatch)
 
LPWSTR WINAPI StrPBrkW (LPCWSTR lpszStr, LPCWSTR lpszMatch)
 
static LPSTR SHLWAPI_StrRChrHelperA (LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch, BOOL(WINAPI *pChrCmpFn)(WORD, WORD))
 
LPSTR WINAPI StrRChrA (LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch)
 
LPWSTR WINAPI StrRChrW (LPCWSTR str, LPCWSTR end, WORD ch)
 
LPSTR WINAPI StrRChrIA (LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch)
 
LPWSTR WINAPI StrRChrIW (LPCWSTR str, LPCWSTR end, WORD ch)
 
LPSTR WINAPI StrCatBuffA (LPSTR lpszStr, LPCSTR lpszCat, INT cchMax)
 
LPWSTR WINAPI StrCatBuffW (LPWSTR lpszStr, LPCWSTR lpszCat, INT cchMax)
 
HRESULT WINAPI StrRetToBufA (LPSTRRET src, const ITEMIDLIST *pidl, LPSTR dest, UINT len)
 
HRESULT WINAPI StrRetToBufW (LPSTRRET src, const ITEMIDLIST *pidl, LPWSTR dest, UINT len)
 
HRESULT WINAPI StrRetToStrA (LPSTRRET lpStrRet, const ITEMIDLIST *pidl, LPSTR *ppszName)
 
HRESULT WINAPI StrRetToStrW (LPSTRRET lpStrRet, const ITEMIDLIST *pidl, LPWSTR *ppszName)
 
static HRESULT _SHStrDupAToBSTR (LPCSTR src, BSTR *pBstrOut)
 
HRESULT WINAPI StrRetToBSTR (STRRET *lpStrRet, LPCITEMIDLIST pidl, BSTR *pBstrOut)
 
LPSTR WINAPI StrFormatKBSizeA (LONGLONG llBytes, LPSTR lpszDest, UINT cchMax)
 
LPWSTR WINAPI StrFormatKBSizeW (LONGLONG llBytes, LPWSTR lpszDest, UINT cchMax)
 
LPSTR WINAPI StrNCatA (LPSTR lpszStr, LPCSTR lpszCat, INT cchMax)
 
LPWSTR WINAPI StrNCatW (LPWSTR lpszStr, LPCWSTR lpszCat, INT cchMax)
 
BOOL WINAPI StrTrimA (LPSTR lpszStr, LPCSTR lpszTrim)
 
BOOL WINAPI StrTrimW (LPWSTR lpszStr, LPCWSTR lpszTrim)
 
HRESULT WINAPI SHStrDupA (LPCSTR lpszStr, LPWSTR *lppszDest)
 
HRESULT WINAPI SHStrDupW (LPCWSTR src, LPWSTR *dest)
 
static LPWSTR SHLWAPI_WriteReverseNum (LPWSTR lpszOut, DWORD dwNum)
 
static int SHLWAPI_FormatSignificant (LPWSTR lpszNum, int dwDigits)
 
static int SHLWAPI_WriteTimeClass (LPWSTR lpszOut, DWORD dwValue, UINT uClassStringId, int iDigits)
 
INT WINAPI StrFromTimeIntervalA (LPSTR lpszStr, UINT cchMax, DWORD dwMS, int iDigits)
 
INT WINAPI StrFromTimeIntervalW (LPWSTR lpszStr, UINT cchMax, DWORD dwMS, int iDigits)
 
BOOL WINAPI StrIsIntlEqualA (BOOL bCase, LPCSTR lpszStr, LPCSTR lpszComp, int iLen)
 
BOOL WINAPI StrIsIntlEqualW (BOOL bCase, LPCWSTR lpszStr, LPCWSTR lpszComp, int iLen)
 
LPSTR WINAPI StrCpyNXA (LPSTR lpszDest, LPCSTR lpszSrc, int iLen)
 
LPWSTR WINAPI StrCpyNXW (LPWSTR lpszDest, LPCWSTR lpszSrc, int iLen)
 
INT WINAPI StrCmpLogicalW (LPCWSTR lpszStr, LPCWSTR lpszComp)
 
LPWSTR WINAPI StrFormatByteSizeW (LONGLONG llBytes, LPWSTR lpszDest, UINT cchMax)
 
LPSTR WINAPI StrFormatByteSize64A (LONGLONG llBytes, LPSTR lpszDest, UINT cchMax)
 
LPSTR WINAPI StrFormatByteSizeA (DWORD dwBytes, LPSTR lpszDest, UINT cchMax)
 
DWORD WINAPI SHTruncateString (LPSTR lpStr, DWORD size)
 
char WINAPI SHStripMneumonicA (LPCSTR lpszStr)
 
WCHAR WINAPI SHStripMneumonicW (LPCWSTR lpszStr)
 
DWORD WINAPI SHAnsiToUnicodeCP (DWORD dwCp, LPCSTR lpSrcStr, LPWSTR lpDstStr, int iLen)
 
DWORD WINAPI SHAnsiToUnicode (LPCSTR lpSrcStr, LPWSTR lpDstStr, int iLen)
 
DWORD WINAPI SHUnicodeToAnsiCP (UINT CodePage, LPCWSTR lpSrcStr, LPSTR lpDstStr, int dstlen)
 
INT WINAPI SHUnicodeToAnsi (LPCWSTR lpSrcStr, LPSTR lpDstStr, INT iLen)
 
DWORD WINAPI SHAnsiToAnsi (LPCSTR lpszSrc, LPSTR lpszDst, int iLen)
 
DWORD WINAPI SHUnicodeToUnicode (LPCWSTR lpszSrc, LPWSTR lpszDst, int iLen)
 
BOOL WINAPI DoesStringRoundTripA (LPCSTR lpSrcStr, LPSTR lpDst, INT iLen)
 
BOOL WINAPI DoesStringRoundTripW (LPCWSTR lpSrcStr, LPSTR lpDst, INT iLen)
 
HRESULT WINAPI SHLoadIndirectString (LPCWSTR src, LPWSTR dst, UINT dst_len, void **reserved)
 
BOOL WINAPI IsCharSpaceA (CHAR c)
 
BOOL WINAPI IsCharSpaceW (WCHAR wc)
 

Variables

HINSTANCE shlwapi_hInstance
 

Macro Definition Documentation

◆ GB

#define GB   (KB*KB*KB)

◆ KB

#define KB   ((ULONGLONG)1024)

◆ MB

#define MB   (KB*KB)

◆ NO_SHLWAPI_REG

#define NO_SHLWAPI_REG

Definition at line 34 of file string.c.

◆ NO_SHLWAPI_STREAM

#define NO_SHLWAPI_STREAM

Definition at line 35 of file string.c.

◆ NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 30 of file string.c.

◆ PB

#define PB   (KB*KB*KB*KB*KB)

◆ TB

#define TB   (KB*KB*KB*KB)

Typedef Documentation

◆ SHLWAPI_BYTEFORMATS

Function Documentation

◆ _SHStrDupAA()

static HRESULT _SHStrDupAA ( LPCSTR  src,
LPSTR dest 
)
static

Definition at line 1909 of file string.c.

1910{
1911 HRESULT hr;
1912 int len = 0;
1913
1914 if (src) {
1915 len = lstrlenA(src) + 1;
1917 } else {
1918 *dest = NULL;
1919 }
1920
1921 if (*dest) {
1922 lstrcpynA(*dest,src, len);
1923 hr = S_OK;
1924 } else {
1925 hr = E_OUTOFMEMORY;
1926 }
1927
1928 TRACE("%s->(%p)\n", debugstr_a(src), *dest);
1929 return hr;
1930}
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define NULL
Definition: types.h:112
#define lstrcpynA
Definition: compat.h:751
GLenum src
Definition: glext.h:6340
GLenum GLsizei len
Definition: glext.h:6722
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:426
#define S_OK
Definition: intsafe.h:52
#define debugstr_a
Definition: kernel32.h:31
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
static char * dest
Definition: rtl.c:135
HRESULT hr
Definition: shlfolder.c:183
#define TRACE(s)
Definition: solgame.cpp:4

Referenced by StrRetToStrA().

◆ _SHStrDupAToBSTR()

static HRESULT _SHStrDupAToBSTR ( LPCSTR  src,
BSTR pBstrOut 
)
static

Definition at line 1650 of file string.c.

1651{
1652 *pBstrOut = NULL;
1653
1654 if (src)
1655 {
1656 INT len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
1657 WCHAR* szTemp = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1658
1659 if (szTemp)
1660 {
1661 MultiByteToWideChar(CP_ACP, 0, src, -1, szTemp, len);
1662 *pBstrOut = SysAllocString(szTemp);
1663 HeapFree(GetProcessHeap(), 0, szTemp);
1664
1665 if (*pBstrOut)
1666 return S_OK;
1667 }
1668 }
1669 return E_OUTOFMEMORY;
1670}
#define GetProcessHeap()
Definition: compat.h:736
#define CP_ACP
Definition: compat.h:109
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
#define MultiByteToWideChar
Definition: compat.h:110
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238
int32_t INT
Definition: typedefs.h:58
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by StrRetToBSTR().

◆ _SHStrDupAW()

static HRESULT _SHStrDupAW ( LPCWSTR  src,
LPSTR dest 
)
static

Definition at line 1976 of file string.c.

1977{
1978 HRESULT hr;
1979 int len = 0;
1980
1981 if (src) {
1982 len = WideCharToMultiByte(CP_ACP, 0, src, -1, NULL, 0, NULL, NULL);
1984 } else {
1985 *dest = NULL;
1986 }
1987
1988 if (*dest) {
1990 hr = S_OK;
1991 } else {
1992 hr = E_OUTOFMEMORY;
1993 }
1994
1995 TRACE("%s->(%p)\n", debugstr_w(src), *dest);
1996 return hr;
1997}
#define WideCharToMultiByte
Definition: compat.h:111
#define debugstr_w
Definition: kernel32.h:32

Referenced by StrRetToStrA().

◆ ChrCmpIA()

BOOL WINAPI ChrCmpIA ( WORD  ch1,
WORD  ch2 
)

Definition at line 205 of file string.c.

206{
207 TRACE("(%d,%d)\n", ch1, ch2);
208
209 return SHLWAPI_ChrCmpHelperA(ch1, ch2, NORM_IGNORECASE);
210}
static BOOL SHLWAPI_ChrCmpHelperA(WORD ch1, WORD ch2, DWORD dwFlags)
Definition: string.c:157
#define NORM_IGNORECASE
Definition: winnls.h:176

Referenced by StrChrIA(), StrRChrIA(), and StrRStrIA().

◆ ChrCmpIW()

BOOL WINAPI ChrCmpIW ( WCHAR  ch1,
WCHAR  ch2 
)

Definition at line 217 of file string.c.

218{
219 return CompareStringW(GetThreadLocale(), NORM_IGNORECASE, &ch1, 1, &ch2, 1) - CSTR_EQUAL;
220}
LCID WINAPI GetThreadLocale(void)
Definition: lang.c:1459
INT WINAPI CompareStringW(LCID lcid, DWORD flags, LPCWSTR str1, INT len1, LPCWSTR str2, INT len2)
Definition: lang.c:2671
#define CSTR_EQUAL
Definition: winnls.h:456

Referenced by CAutoComplete::DoAutoAppend(), StrCmpLogicalW(), StrRChrIW(), StrRStrIW(), and URL_GuessScheme().

◆ DoesStringRoundTripA()

BOOL WINAPI DoesStringRoundTripA ( LPCSTR  lpSrcStr,
LPSTR  lpDst,
INT  iLen 
)

Definition at line 2840 of file string.c.

2841{
2842 lstrcpynA(lpDst, lpSrcStr, iLen);
2843 return TRUE;
2844}
#define TRUE
Definition: types.h:120

◆ DoesStringRoundTripW()

BOOL WINAPI DoesStringRoundTripW ( LPCWSTR  lpSrcStr,
LPSTR  lpDst,
INT  iLen 
)

Definition at line 2860 of file string.c.

2861{
2862 WCHAR szBuff[MAX_PATH];
2863
2864 SHUnicodeToAnsi(lpSrcStr, lpDst, iLen);
2865 SHAnsiToUnicode(lpDst, szBuff, MAX_PATH);
2866 return !strcmpW(lpSrcStr, szBuff);
2867}
#define MAX_PATH
Definition: compat.h:34
DWORD WINAPI SHAnsiToUnicode(LPCSTR lpSrcStr, LPWSTR lpDstStr, int iLen)
Definition: string.c:2659
INT WINAPI SHUnicodeToAnsi(LPCWSTR lpSrcStr, LPSTR lpDstStr, INT iLen)
Definition: string.c:2783
#define strcmpW(s1, s2)
Definition: unicode.h:38

◆ FillNumberFmt()

static void FillNumberFmt ( NUMBERFMTW fmt,
LPWSTR  decimal_buffer,
int  decimal_bufwlen,
LPWSTR  thousand_buffer,
int  thousand_bufwlen 
)
static

Definition at line 55 of file string.c.

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}
const GLubyte * c
Definition: glext.h:8905
#define c
Definition: ke_i.h:80
INT WINAPI GetLocaleInfoW(LCID lcid, LCTYPE lctype, LPWSTR buffer, INT len)
Definition: lang.c:1108
#define LOCALE_USER_DEFAULT
Definition: dsound.c:943
#define LOCALE_SGROUPING
Definition: winnls.h:44
#define LOCALE_SDECIMAL
Definition: winnls.h:42
#define LOCALE_STHOUSAND
Definition: winnls.h:43
#define LOCALE_INEGNUMBER
Definition: winnls.h:47
#define LOCALE_ILZERO
Definition: winnls.h:46
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by FormatDouble(), and FormatInt().

◆ FormatDouble()

static int FormatDouble ( double  value,
int  decimals,
LPWSTR  pszBuf,
int  cchBuf 
)
static

Definition at line 129 of file string.c.

130{
131 static const WCHAR flfmt[] = {'%','f',0};
132 WCHAR buf[64];
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}
static void FillNumberFmt(NUMBERFMTW *fmt, LPWSTR decimal_buffer, int decimal_bufwlen, LPWSTR thousand_buffer, int thousand_bufwlen)
Definition: string.c:55
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
INT WINAPI GetNumberFormatW(LCID lcid, DWORD dwFlags, LPCWSTR lpszValue, const NUMBERFMTW *lpFormat, LPWSTR lpNumberStr, int cchOut)
Definition: lcformat.c:1212
#define snprintfW
Definition: unicode.h:60
Definition: pdh_main.c:94

Referenced by StrFormatByteSizeW().

◆ FormatInt()

static int FormatInt ( LONGLONG  qdwValue,
LPWSTR  pszBuf,
int  cchBuf 
)
static

Definition at line 96 of file string.c.

97{
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}
unsigned int BOOL
Definition: ntddk_ex.h:94

Referenced by StrFormatKBSizeW().

◆ IsCharSpaceA()

BOOL WINAPI IsCharSpaceA ( CHAR  c)

Definition at line 2938 of file string.c.

2939{
2940 WORD CharType;
2941 return GetStringTypeA(GetSystemDefaultLCID(), CT_CTYPE1, &c, 1, &CharType) && (CharType & C1_SPACE);
2942}
unsigned short WORD
Definition: ntddk_ex.h:93
#define C1_SPACE
Definition: unicode.h:34
BOOL WINAPI GetStringTypeA(LCID locale, DWORD type, LPCSTR src, INT count, LPWORD chartype)
Definition: lang.c:1823
LCID WINAPI GetSystemDefaultLCID(void)
Definition: lang.c:797
#define CT_CTYPE1
Definition: winnls.h:237

◆ IsCharSpaceW()

BOOL WINAPI IsCharSpaceW ( WCHAR  wc)

Definition at line 2956 of file string.c.

2957{
2958 WORD CharType;
2959
2960 return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_SPACE);
2961}
BOOL WINAPI GetStringTypeW(DWORD type, LPCWSTR src, INT count, LPWORD chartype)
Definition: lang.c:1709

◆ SHAnsiToAnsi()

DWORD WINAPI SHAnsiToAnsi ( LPCSTR  lpszSrc,
LPSTR  lpszDst,
int  iLen 
)

Definition at line 2802 of file string.c.

2803{
2804 LPSTR lpszRet;
2805
2806 TRACE("(%s,%p,0x%08x)\n", debugstr_a(lpszSrc), lpszDst, iLen);
2807
2808 lpszRet = StrCpyNXA(lpszDst, lpszSrc, iLen);
2809 return lpszRet - lpszDst + 1;
2810}
LPSTR WINAPI StrCpyNXA(LPSTR lpszDest, LPCSTR lpszSrc, int iLen)
Definition: string.c:2249
char * LPSTR
Definition: xmlstorage.h:182

◆ SHAnsiToUnicode()

DWORD WINAPI SHAnsiToUnicode ( LPCSTR  lpSrcStr,
LPWSTR  lpDstStr,
int  iLen 
)

Definition at line 2659 of file string.c.

2660{
2661 return SHAnsiToUnicodeCP(CP_ACP, lpSrcStr, lpDstStr, iLen);
2662}
DWORD WINAPI SHAnsiToUnicodeCP(DWORD dwCp, LPCSTR lpSrcStr, LPWSTR lpDstStr, int iLen)
Definition: string.c:2634

Referenced by CheckEscapesA(), DoesStringRoundTripW(), CDefaultContextMenu::GetCommandString(), IsLFNDriveA(), MakeShellURLFromPathA(), CDefaultContextMenu::MapVerbToCmdId(), PathIsTemporaryA(), PathQualifyA(), PathResolveA(), and SHChangeNotify().

◆ SHAnsiToUnicodeCP()

DWORD WINAPI SHAnsiToUnicodeCP ( DWORD  dwCp,
LPCSTR  lpSrcStr,
LPWSTR  lpDstStr,
int  iLen 
)

Definition at line 2634 of file string.c.

2635{
2636 DWORD dwRet;
2637
2638 dwRet = MultiByteToWideChar(dwCp, 0, lpSrcStr, -1, lpDstStr, iLen);
2639 TRACE("%s->%s,ret=%d\n", debugstr_a(lpSrcStr), debugstr_w(lpDstStr), dwRet);
2640 return dwRet;
2641}
unsigned long DWORD
Definition: ntddk_ex.h:95

Referenced by SHAnsiToUnicode().

◆ SHLoadIndirectString()

HRESULT WINAPI SHLoadIndirectString ( LPCWSTR  src,
LPWSTR  dst,
UINT  dst_len,
void **  reserved 
)

Definition at line 2876 of file string.c.

2877{
2878 WCHAR *dllname = NULL;
2879 HMODULE hmod = NULL;
2880 HRESULT hr = E_FAIL;
2881#ifdef __REACTOS__
2882 WCHAR szExpanded[512];
2883#endif
2884
2885 TRACE("(%s %p %08x %p)\n", debugstr_w(src), dst, dst_len, reserved);
2886
2887 if(src[0] == '@')
2888 {
2889 WCHAR *index_str;
2890 int index;
2891
2892#ifdef __REACTOS__
2893 if (wcschr(src, '%') != NULL)
2894 {
2895 ExpandEnvironmentStringsW(src, szExpanded, ARRAY_SIZE(szExpanded));
2896 src = szExpanded;
2897 }
2898#endif
2899 dst[0] = 0;
2900 dllname = StrDupW(src + 1);
2901 index_str = strchrW(dllname, ',');
2902
2903 if(!index_str) goto end;
2904
2905 *index_str = 0;
2906 index_str++;
2907 index = atoiW(index_str);
2908
2909#ifdef __REACTOS__
2911#else
2912 hmod = LoadLibraryW(dllname);
2913#endif
2914 if(!hmod) goto end;
2915
2916 if(index < 0)
2917 {
2918 if(LoadStringW(hmod, -index, dst, dst_len))
2919 hr = S_OK;
2920 }
2921 else
2922 FIXME("can't handle non-negative indices (%d)\n", index);
2923 }
2924 else
2925 {
2926 if(dst != src)
2927 lstrcpynW(dst, src, dst_len);
2928 hr = S_OK;
2929 }
2930
2931 TRACE("returning %s\n", debugstr_w(dst));
2932end:
2933 if(hmod) FreeLibrary(hmod);
2934 LocalFree(dllname);
2935 return hr;
2936}
#define index(s, c)
Definition: various.h:29
#define ARRAY_SIZE(A)
Definition: main.h:33
#define FIXME(fmt,...)
Definition: debug.h:111
#define E_FAIL
Definition: ddrawi.h:102
#define wcschr
Definition: compat.h:17
#define FreeLibrary(x)
Definition: compat.h:748
#define LoadLibraryW(x)
Definition: compat.h:747
#define lstrcpynW
Definition: compat.h:738
DWORD WINAPI ExpandEnvironmentStringsW(IN LPCWSTR lpSrc, IN LPWSTR lpDst, IN DWORD nSize)
Definition: environ.c:519
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryExW(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
Definition: loader.c:288
LPWSTR WINAPI StrDupW(LPCWSTR lpszStr)
Definition: string.c:1089
r reserved
Definition: btrfs.c:3006
GLuint GLuint end
Definition: gl.h:1545
GLuint index
Definition: glext.h:6031
GLenum GLenum dst
Definition: glext.h:6340
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
static PEXPLICIT_ACCESSW *static HMODULE hmod
Definition: security.c:143
#define atoiW(s)
Definition: unicode.h:54
#define strchrW(s, c)
Definition: unicode.h:34
#define LOAD_LIBRARY_AS_DATAFILE
Definition: winbase.h:342
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)

Referenced by AllSysInfo(), execute_test(), and SHLoadRegUIStringW().

◆ SHLWAPI_ChrCmpA()

static BOOL WINAPI SHLWAPI_ChrCmpA ( WORD  ch1,
WORD  ch2 
)
static

Definition at line 187 of file string.c.

188{
189 return SHLWAPI_ChrCmpHelperA(ch1, ch2, 0);
190}

Referenced by StrChrA(), and StrRChrA().

◆ SHLWAPI_ChrCmpHelperA()

static BOOL SHLWAPI_ChrCmpHelperA ( WORD  ch1,
WORD  ch2,
DWORD  dwFlags 
)
static

Definition at line 157 of file string.c.

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) - CSTR_EQUAL;
180}
BOOL WINAPI IsDBCSLeadByte(BYTE TestByte)
Definition: nls.c:2359
#define LOBYTE(W)
Definition: jmemdos.c:487
#define HIBYTE(W)
Definition: jmemdos.c:486
INT WINAPI CompareStringA(LCID lcid, DWORD flags, LPCSTR str1, INT len1, LPCSTR str2, INT len2)
Definition: lang.c:2695
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176

Referenced by ChrCmpIA(), and SHLWAPI_ChrCmpA().

◆ SHLWAPI_FormatSignificant()

static int SHLWAPI_FormatSignificant ( LPWSTR  lpszNum,
int  dwDigits 
)
inlinestatic

Definition at line 2052 of file string.c.

2053{
2054 /* Zero non significant digits, return remaining significant digits */
2055 while (*lpszNum)
2056 {
2057 lpszNum++;
2058 if (--dwDigits == 0)
2059 {
2060 while (*lpszNum)
2061 *lpszNum++ = '0';
2062 return 0;
2063 }
2064 }
2065 return dwDigits;
2066}

Referenced by SHLWAPI_WriteTimeClass().

◆ SHLWAPI_StrRChrHelperA()

static LPSTR SHLWAPI_StrRChrHelperA ( LPCSTR  lpszStr,
LPCSTR  lpszEnd,
WORD  ch,
BOOL(WINAPI *pChrCmpFn)(WORD, WORD  
)
static

Definition at line 1287 of file string.c.

1290{
1291 LPCSTR lpszRet = NULL;
1292
1293 if (lpszStr)
1294 {
1295 WORD ch2;
1296
1297 if (!lpszEnd)
1298 lpszEnd = lpszStr + lstrlenA(lpszStr);
1299
1300 while (*lpszStr && lpszStr <= lpszEnd)
1301 {
1302 ch2 = IsDBCSLeadByte(*lpszStr)? *lpszStr << 8 | lpszStr[1] : *lpszStr;
1303
1304 if (!pChrCmpFn(ch, ch2))
1305 lpszRet = lpszStr;
1306 lpszStr = CharNextA(lpszStr);
1307 }
1308 }
1309 return (LPSTR)lpszRet;
1310}
LPSTR WINAPI CharNextA(_In_ LPCSTR)
const char * LPCSTR
Definition: xmlstorage.h:183

Referenced by StrRChrA(), and StrRChrIA().

◆ SHLWAPI_StrSpnHelperA()

static int SHLWAPI_StrSpnHelperA ( LPCSTR  lpszStr,
LPCSTR  lpszMatch,
LPSTR(WINAPI *pStrChrFn)(LPCSTR, WORD ,
BOOL  bInvert 
)
static

Definition at line 1114 of file string.c.

1117{
1118 LPCSTR lpszRead = lpszStr;
1119 if (lpszStr && *lpszStr && lpszMatch)
1120 {
1121 while (*lpszRead)
1122 {
1123 LPCSTR lpszTest = pStrChrFn(lpszMatch, *lpszRead);
1124
1125 if (!bInvert && !lpszTest)
1126 break;
1127 if (bInvert && lpszTest)
1128 break;
1129 lpszRead = CharNextA(lpszRead);
1130 };
1131 }
1132 return lpszRead - lpszStr;
1133}
static BOOL bInvert
Definition: win.c:51

Referenced by StrCSpnA(), StrCSpnIA(), and StrSpnA().

◆ SHLWAPI_StrStrHelperA()

static LPSTR SHLWAPI_StrStrHelperA ( LPCSTR  lpszStr,
LPCSTR  lpszSearch,
INT(WINAPI *pStrCmpFn)(LPCSTR, LPCSTR, INT  
)
static

Definition at line 561 of file string.c.

563{
564 size_t iLen;
565 LPCSTR end;
566
567 if (!lpszStr || !lpszSearch || !*lpszSearch)
568 return NULL;
569
570 iLen = strlen(lpszSearch);
571 end = lpszStr + strlen(lpszStr);
572
573 while (lpszStr + iLen <= end)
574 {
575 if (!pStrCmpFn(lpszStr, lpszSearch, iLen))
576 return (LPSTR)lpszStr;
577 lpszStr = CharNextA(lpszStr);
578 }
579 return NULL;
580}
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269

Referenced by StrStrA(), and StrStrIA().

◆ SHLWAPI_WriteReverseNum()

static LPWSTR SHLWAPI_WriteReverseNum ( LPWSTR  lpszOut,
DWORD  dwNum 
)
inlinestatic

Definition at line 2032 of file string.c.

2033{
2034 *lpszOut-- = '\0';
2035
2036 /* Write a decimal number to a string, backwards */
2037 do
2038 {
2039 DWORD dwNextDigit = dwNum % 10;
2040 *lpszOut-- = '0' + dwNextDigit;
2041 dwNum = (dwNum - dwNextDigit) / 10;
2042 } while (dwNum > 0);
2043
2044 return lpszOut;
2045}

Referenced by SHLWAPI_WriteTimeClass().

◆ SHLWAPI_WriteTimeClass()

static int SHLWAPI_WriteTimeClass ( LPWSTR  lpszOut,
DWORD  dwValue,
UINT  uClassStringId,
int  iDigits 
)
static

Definition at line 2073 of file string.c.

2075{
2076 WCHAR szBuff[64], *szOut = szBuff + 32;
2077
2078 szOut = SHLWAPI_WriteReverseNum(szOut, dwValue);
2079 iDigits = SHLWAPI_FormatSignificant(szOut + 1, iDigits);
2080 *szOut = ' ';
2081 LoadStringW(shlwapi_hInstance, uClassStringId, szBuff + 32, 32);
2082 strcatW(lpszOut, szOut);
2083 return iDigits;
2084}
static int SHLWAPI_FormatSignificant(LPWSTR lpszNum, int dwDigits)
Definition: string.c:2052
static LPWSTR SHLWAPI_WriteReverseNum(LPWSTR lpszOut, DWORD dwNum)
Definition: string.c:2032
HINSTANCE shlwapi_hInstance
Definition: shlwapi_main.c:33
#define strcatW(d, s)
Definition: unicode.h:30

Referenced by StrFromTimeIntervalW().

◆ SHStrDupA()

HRESULT WINAPI SHStrDupA ( LPCSTR  lpszStr,
LPWSTR lppszDest 
)

Definition at line 1946 of file string.c.

1947{
1948 HRESULT hRet;
1949 int len = 0;
1950
1951 if (lpszStr)
1952 {
1953 len = MultiByteToWideChar(CP_ACP, 0, lpszStr, -1, NULL, 0) * sizeof(WCHAR);
1954 *lppszDest = CoTaskMemAlloc(len);
1955 }
1956 else
1957 *lppszDest = NULL;
1958
1959 if (*lppszDest)
1960 {
1961 MultiByteToWideChar(CP_ACP, 0, lpszStr, -1, *lppszDest, len/sizeof(WCHAR));
1962 hRet = S_OK;
1963 }
1964 else
1965 hRet = E_OUTOFMEMORY;
1966
1967 TRACE("%s->(%p)\n", debugstr_a(lpszStr), *lppszDest);
1968 return hRet;
1969}

Referenced by StrRetToStrW(), test_assoc_one(), and TestFilenameA().

◆ SHStrDupW()

HRESULT WINAPI SHStrDupW ( LPCWSTR  src,
LPWSTR dest 
)

Definition at line 2004 of file string.c.

2005{
2006 HRESULT hr;
2007 int len = 0;
2008
2009 if (src) {
2010 len = (lstrlenW(src) + 1) * sizeof(WCHAR);
2012 } else {
2013 *dest = NULL;
2014 }
2015
2016 if (*dest) {
2017 memcpy(*dest, src, len);
2018 hr = S_OK;
2019 } else {
2020 hr = E_OUTOFMEMORY;
2021 }
2022
2023 TRACE("%s->(%p)\n", debugstr_w(src), *dest);
2024 return hr;
2025}
#define lstrlenW
Definition: compat.h:750
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878

Referenced by AssocGetPerceivedType(), DoSanitizeClipboard(), CAutoComplete::GetDropDownStatus(), CACListISF::GetPaths(), CShellFolder::GetValidCharacters(), CDesktopFolder::GetValidCharacters(), CFSFolder::GetValidCharacters(), CMyDocsFolder::GetValidCharacters(), CMergedFolder::GetValidCharacters(), CEnumString::Next(), START_TEST(), and StrRetToStrW().

◆ SHStripMneumonicA()

char WINAPI SHStripMneumonicA ( LPCSTR  lpszStr)

Definition at line 2567 of file string.c.

2568{
2569 LPSTR lpszIter, lpszTmp;
2570 char ch;
2571
2572 TRACE("(%s)\n", debugstr_a(lpszStr));
2573
2574 ch = *lpszStr;
2575
2576 if ((lpszIter = StrChrA(lpszStr, '&')))
2577 {
2578 lpszTmp = CharNextA(lpszIter);
2579 if (*lpszTmp)
2580 {
2581 if (*lpszTmp != '&')
2582 ch = *lpszTmp;
2583
2584 memmove( lpszIter, lpszTmp, strlen(lpszTmp) + 1 );
2585 }
2586 }
2587
2588 return ch;
2589}
LPSTR WINAPI StrChrA(LPCSTR lpszStr, WORD ch)
Definition: string.c:270
#define memmove(s1, s2, n)
Definition: mkisofs.h:881

◆ SHStripMneumonicW()

WCHAR WINAPI SHStripMneumonicW ( LPCWSTR  lpszStr)

Definition at line 2596 of file string.c.

2597{
2598 LPWSTR lpszIter, lpszTmp;
2599 WCHAR ch;
2600
2601 TRACE("(%s)\n", debugstr_w(lpszStr));
2602
2603 ch = *lpszStr;
2604
2605 if ((lpszIter = StrChrW(lpszStr, '&')))
2606 {
2607 lpszTmp = lpszIter + 1;
2608 if (*lpszTmp)
2609 {
2610 if (*lpszTmp != '&')
2611 ch = *lpszTmp;
2612
2613 memmove( lpszIter, lpszTmp, (strlenW(lpszTmp) + 1) * sizeof(WCHAR) );
2614 }
2615 }
2616
2617 return ch;
2618}
LPWSTR WINAPI StrChrW(LPCWSTR lpszStr, WCHAR ch)
Definition: string.c:257
#define strlenW(s)
Definition: unicode.h:28

◆ SHTruncateString()

DWORD WINAPI SHTruncateString ( LPSTR  lpStr,
DWORD  size 
)

Definition at line 2536 of file string.c.

2537{
2538 if (lpStr && size)
2539 {
2540 LPSTR lastByte = lpStr + size - 1;
2541
2542 while(lpStr < lastByte)
2543 lpStr += IsDBCSLeadByte(*lpStr) ? 2 : 1;
2544
2545 if(lpStr == lastByte && IsDBCSLeadByte(*lpStr))
2546 {
2547 *lpStr = '\0';
2548 size--;
2549 }
2550 return size;
2551 }
2552 return 0;
2553}
GLsizeiptr size
Definition: glext.h:5919

Referenced by SHUnicodeToAnsiCP().

◆ SHUnicodeToAnsi()

INT WINAPI SHUnicodeToAnsi ( LPCWSTR  lpSrcStr,
LPSTR  lpDstStr,
INT  iLen 
)

Definition at line 2783 of file string.c.

2784{
2785 return SHUnicodeToAnsiCP(CP_ACP, lpSrcStr, lpDstStr, iLen);
2786}
DWORD WINAPI SHUnicodeToAnsiCP(UINT CodePage, LPCWSTR lpSrcStr, LPSTR lpDstStr, int dstlen)
Definition: string.c:2684

Referenced by CheckEscapesA(), DoesStringRoundTripW(), CDefaultContextMenu::GetCommandString(), MakeShellURLFromPathA(), CAutoComplete::OnNotify(), PathQualifyA(), and PathResolveA().

◆ SHUnicodeToAnsiCP()

DWORD WINAPI SHUnicodeToAnsiCP ( UINT  CodePage,
LPCWSTR  lpSrcStr,
LPSTR  lpDstStr,
int  dstlen 
)

Definition at line 2684 of file string.c.

2685{
2686 static const WCHAR emptyW[] = { '\0' };
2687 int len , reqLen;
2688 LPSTR mem;
2689
2690 if (!lpDstStr || !dstlen)
2691 return 0;
2692
2693 if (!lpSrcStr)
2694 lpSrcStr = emptyW;
2695
2696 *lpDstStr = '\0';
2697
2698 len = strlenW(lpSrcStr) + 1;
2699
2700 switch (CodePage)
2701 {
2702 case CP_WINUNICODE:
2703 CodePage = CP_UTF8; /* Fall through... */
2704 case 0x0000C350: /* FIXME: CP_ #define */
2705 case CP_UTF7:
2706 case CP_UTF8:
2707 {
2708 DWORD dwMode = 0;
2709 INT lenW = len - 1;
2710 INT needed = dstlen - 1;
2711 HRESULT hr;
2712
2713 /* try the user supplied buffer first */
2714 hr = ConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &lenW, lpDstStr, &needed);
2715 if (hr == S_OK)
2716 {
2717 lpDstStr[needed] = '\0';
2718 return needed + 1;
2719 }
2720
2721 /* user buffer too small. exclude termination and copy as much as possible */
2722 lenW = len;
2723 hr = ConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &lenW, NULL, &needed);
2724 needed++;
2725 mem = HeapAlloc(GetProcessHeap(), 0, needed);
2726 if (!mem)
2727 return 0;
2728
2729 hr = ConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &len, mem, &needed);
2730 if (hr == S_OK)
2731 {
2732 reqLen = SHTruncateString(mem, dstlen);
2733 if (reqLen > 0) memcpy(lpDstStr, mem, reqLen-1);
2734 }
2736 return 0;
2737 }
2738 default:
2739 break;
2740 }
2741
2742 /* try the user supplied buffer first */
2743 reqLen = WideCharToMultiByte(CodePage, 0, lpSrcStr, len, lpDstStr, dstlen, NULL, NULL);
2744
2745 if (!reqLen && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
2746 {
2747 reqLen = WideCharToMultiByte(CodePage, 0, lpSrcStr, len, NULL, 0, NULL, NULL);
2748 if (reqLen)
2749 {
2750 mem = HeapAlloc(GetProcessHeap(), 0, reqLen);
2751 if (mem)
2752 {
2753 WideCharToMultiByte(CodePage, 0, lpSrcStr, len, mem, reqLen, NULL, NULL);
2754
2755 reqLen = SHTruncateString(mem, dstlen -1);
2756 reqLen++;
2757
2758 lstrcpynA(lpDstStr, mem, reqLen);
2760 lpDstStr[reqLen-1] = '\0';
2761 }
2762 }
2763 }
2764 return reqLen;
2765}
#define CP_WINUNICODE
Definition: ddeml.h:33
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
DWORD WINAPI SHTruncateString(LPSTR lpStr, DWORD size)
Definition: string.c:2536
static const WCHAR emptyW[]
Definition: navigate.c:40
static DWORD dstlen
Definition: directory.c:51
#define CP_UTF8
Definition: nls.h:20
Definition: mem.c:156
static CONVERTINETUNICODETOMULTIBYTE ConvertINetUnicodeToMultiByte
Definition: win_iconv.c:706
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define CP_UTF7
Definition: winnls.h:235

Referenced by SHUnicodeToAnsi().

◆ SHUnicodeToUnicode()

DWORD WINAPI SHUnicodeToUnicode ( LPCWSTR  lpszSrc,
LPWSTR  lpszDst,
int  iLen 
)

Definition at line 2817 of file string.c.

2818{
2819 LPWSTR lpszRet;
2820
2821 TRACE("(%s,%p,0x%08x)\n", debugstr_w(lpszSrc), lpszDst, iLen);
2822
2823 lpszRet = StrCpyNXW(lpszDst, lpszSrc, iLen);
2824 return lpszRet - lpszDst + 1;
2825}
LPWSTR WINAPI StrCpyNXW(LPWSTR lpszDest, LPCWSTR lpszSrc, int iLen)
Definition: string.c:2268

◆ StrCatBuffA()

LPSTR WINAPI StrCatBuffA ( LPSTR  lpszStr,
LPCSTR  lpszCat,
INT  cchMax 
)

Definition at line 1411 of file string.c.

1412{
1413 INT iLen;
1414
1415 TRACE("(%p,%s,%d)\n", lpszStr, debugstr_a(lpszCat), cchMax);
1416
1417 if (!lpszStr)
1418 {
1419 WARN("Invalid lpszStr would crash under Win32!\n");
1420 return NULL;
1421 }
1422
1423 iLen = strlen(lpszStr);
1424 cchMax -= iLen;
1425
1426 if (cchMax > 0)
1427 StrCpyNA(lpszStr + iLen, lpszCat, cchMax);
1428 return lpszStr;
1429}
UINT cchMax
#define WARN(fmt,...)
Definition: debug.h:112
#define StrCpyNA
Definition: shlwapi.h:1514

◆ StrCatBuffW()

LPWSTR WINAPI StrCatBuffW ( LPWSTR  lpszStr,
LPCWSTR  lpszCat,
INT  cchMax 
)

Definition at line 1436 of file string.c.

1437{
1438 INT iLen;
1439
1440 TRACE("(%p,%s,%d)\n", lpszStr, debugstr_w(lpszCat), cchMax);
1441
1442 if (!lpszStr)
1443 {
1444 WARN("Invalid lpszStr would crash under Win32!\n");
1445 return NULL;
1446 }
1447
1448 iLen = strlenW(lpszStr);
1449 cchMax -= iLen;
1450
1451 if (cchMax > 0)
1452 StrCpyNW(lpszStr + iLen, lpszCat, cchMax);
1453 return lpszStr;
1454}
LPWSTR WINAPI StrCpyNW(LPWSTR dst, LPCWSTR src, int count)
Definition: string.c:536

Referenced by SHAboutInfoW(), SHAddToRecentDocs(), and StrFormatByteSizeW().

◆ StrCatChainW()

DWORD WINAPI StrCatChainW ( LPWSTR  lpszStr,
DWORD  cchMax,
DWORD  ichAt,
LPCWSTR  lpszCat 
)

Definition at line 475 of file string.c.

476{
477 TRACE("(%s,%u,%d,%s)\n", debugstr_w(lpszStr), cchMax, ichAt, debugstr_w(lpszCat));
478
479 if (ichAt == -1)
480 ichAt = strlenW(lpszStr);
481
482 if (!cchMax)
483 return ichAt;
484
485 if (ichAt == cchMax)
486 ichAt--;
487
488 if (lpszCat && ichAt < cchMax)
489 {
490 lpszStr += ichAt;
491 while (ichAt < cchMax - 1 && *lpszCat)
492 {
493 *lpszStr++ = *lpszCat++;
494 ichAt++;
495 }
496 *lpszStr = 0;
497 }
498
499 return ichAt;
500}

◆ StrCatW()

LPWSTR WINAPI StrCatW ( LPWSTR  lpszStr,
LPCWSTR  lpszSrc 
)

Definition at line 452 of file string.c.

453{
454 TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSrc));
455
456 if (lpszStr && lpszSrc)
457 strcatW(lpszStr, lpszSrc);
458 return lpszStr;
459}

Referenced by CRegistryFolder::FormatValueData().

◆ StrChrA()

LPSTR WINAPI StrChrA ( LPCSTR  lpszStr,
WORD  ch 
)

Definition at line 236 of file string.c.

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}
static BOOL WINAPI SHLWAPI_ChrCmpA(WORD ch1, WORD ch2)
Definition: string.c:187

◆ StrChrIA()

LPSTR WINAPI StrChrIA ( LPCSTR  lpszStr,
WORD  ch 
)

Definition at line 282 of file string.c.

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}
BOOL WINAPI ChrCmpIA(WORD ch1, WORD ch2)
Definition: string.c:205

◆ StrChrIW()

LPWSTR WINAPI StrChrIW ( LPCWSTR  lpszStr,
WCHAR  ch 
)

Definition at line 303 of file string.c.

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}
#define toupperW(n)
Definition: unicode.h:45

◆ StrChrNW()

LPWSTR WINAPI StrChrNW ( LPCWSTR  lpszStr,
WCHAR  ch,
UINT  cchMax 
)

Definition at line 324 of file string.c.

325{
326 TRACE("(%s(%i),%i)\n", debugstr_wn(lpszStr,cchMax), cchMax, ch);
327
328 if (lpszStr)
329 {
330 while (*lpszStr && cchMax-- > 0)
331 {
332 if (*lpszStr == ch)
333 return (LPWSTR)lpszStr;
334 lpszStr++;
335 }
336 }
337 return NULL;
338}
#define debugstr_wn
Definition: kernel32.h:33

◆ StrChrW()

LPWSTR WINAPI StrChrW ( LPCWSTR  lpszStr,
WCHAR  ch 
)

Definition at line 257 of file string.c.

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}

◆ StrCmpIW()

int WINAPI StrCmpIW ( LPCWSTR  lpszStr,
LPCWSTR  lpszComp 
)

◆ StrCmpLogicalW()

INT WINAPI StrCmpLogicalW ( LPCWSTR  lpszStr,
LPCWSTR  lpszComp 
)

Definition at line 2296 of file string.c.

2297{
2298 INT iDiff;
2299
2300 TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszComp));
2301
2302 if (lpszStr && lpszComp)
2303 {
2304 while (*lpszStr)
2305 {
2306 if (!*lpszComp)
2307 return 1;
2308 else if (isdigitW(*lpszStr))
2309 {
2310 int iStr, iComp;
2311
2312 if (!isdigitW(*lpszComp))
2313 return -1;
2314
2315 /* Compare the numbers */
2316 StrToIntExW(lpszStr, 0, &iStr);
2317 StrToIntExW(lpszComp, 0, &iComp);
2318
2319 if (iStr < iComp)
2320 return -1;
2321 else if (iStr > iComp)
2322 return 1;
2323
2324 /* Skip */
2325 while (isdigitW(*lpszStr))
2326 lpszStr++;
2327 while (isdigitW(*lpszComp))
2328 lpszComp++;
2329 }
2330 else if (isdigitW(*lpszComp))
2331 return 1;
2332 else
2333 {
2334 iDiff = ChrCmpIW(*lpszStr,*lpszComp);
2335 if (iDiff > 0)
2336 return 1;
2337 else if (iDiff < 0)
2338 return -1;
2339
2340 lpszStr++;
2341 lpszComp++;
2342 }
2343 }
2344 if (*lpszComp)
2345 return -1;
2346 }
2347 return 0;
2348}
BOOL WINAPI ChrCmpIW(WCHAR ch1, WCHAR ch2)
Definition: string.c:217
BOOL WINAPI StrToIntExW(LPCWSTR lpszStr, DWORD dwFlags, LPINT lpiRet)
Definition: string.c:970
#define isdigitW(n)
Definition: unicode.h:50

Referenced by CompareFunc(), CExplorerBand::CompareTreeItems(), and SortListView().

◆ StrCmpNA()

INT WINAPI StrCmpNA ( LPCSTR  lpszStr,
LPCSTR  lpszComp,
INT  iLen 
)

Definition at line 373 of file string.c.

374{
375 TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszComp), iLen);
376 return CompareStringA(GetThreadLocale(), 0, lpszStr, iLen, lpszComp, iLen) - CSTR_EQUAL;
377}

◆ StrCmpNIA()

int WINAPI StrCmpNIA ( LPCSTR  lpszStr,
LPCSTR  lpszComp,
int  iLen 
)

Definition at line 404 of file string.c.

405{
406 TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszComp), iLen);
407 return CompareStringA(GetThreadLocale(), NORM_IGNORECASE, lpszStr, iLen, lpszComp, iLen) - CSTR_EQUAL;
408}

◆ StrCmpNIW()

INT WINAPI StrCmpNIW ( LPCWSTR  lpszStr,
LPCWSTR  lpszComp,
int  iLen 
)

Definition at line 415 of file string.c.

416{
417 TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszComp), iLen);
418 return CompareStringW(GetThreadLocale(), NORM_IGNORECASE, lpszStr, iLen, lpszComp, iLen) - CSTR_EQUAL;
419}

◆ StrCmpNW()

INT WINAPI StrCmpNW ( LPCWSTR  lpszStr,
LPCWSTR  lpszComp,
INT  iLen 
)

Definition at line 384 of file string.c.

385{
386 TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszComp), iLen);
387 return CompareStringW(GetThreadLocale(), 0, lpszStr, iLen, lpszComp, iLen) - CSTR_EQUAL;
388}

◆ StrCmpW()

int WINAPI StrCmpW ( LPCWSTR  lpszStr,
LPCWSTR  lpszComp 
)

◆ StrCpyNW()

LPWSTR WINAPI StrCpyNW ( LPWSTR  dst,
LPCWSTR  src,
int  count 
)

Definition at line 536 of file string.c.

537{
538 LPWSTR d = dst;
539 LPCWSTR s = src;
540
541 TRACE("(%p,%s,%i)\n", dst, debugstr_w(src), count);
542
543 if (s)
544 {
545 while ((count > 1) && *s)
546 {
547 count--;
548 *d++ = *s++;
549 }
550 }
551 if (count) *d = 0;
552
553 return dst;
554}
GLdouble s
Definition: gl.h:2039
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define d
Definition: ke_i.h:81
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185

Referenced by CIniPropertyBag::_GetSectionAndName(), CZipExtract::Extract(), PathCreateFromUrlW(), SHCreatePropertyBagOnProfileSection(), SHGlobalCounterCreateNamedW(), SHPathPrepareForWriteW(), StrCatBuffW(), StrNCatW(), and test_StrXXX_overflows().

◆ StrCpyNXA()

LPSTR WINAPI StrCpyNXA ( LPSTR  lpszDest,
LPCSTR  lpszSrc,
int  iLen 
)

Definition at line 2249 of file string.c.

2250{
2251 TRACE("(%p,%s,%i)\n", lpszDest, debugstr_a(lpszSrc), iLen);
2252
2253 if (lpszDest && lpszSrc && iLen > 0)
2254 {
2255 while ((iLen-- > 1) && *lpszSrc)
2256 *lpszDest++ = *lpszSrc++;
2257 if (iLen >= 0)
2258 *lpszDest = '\0';
2259 }
2260 return lpszDest;
2261}
WCHAR lpszDest[260]

Referenced by SHAnsiToAnsi().

◆ StrCpyNXW()

LPWSTR WINAPI StrCpyNXW ( LPWSTR  lpszDest,
LPCWSTR  lpszSrc,
int  iLen 
)

Definition at line 2268 of file string.c.

2269{
2270 TRACE("(%p,%s,%i)\n", lpszDest, debugstr_w(lpszSrc), iLen);
2271
2272 if (lpszDest && lpszSrc && iLen > 0)
2273 {
2274 while ((iLen-- > 1) && *lpszSrc)
2275 *lpszDest++ = *lpszSrc++;
2276 if (iLen >= 0)
2277 *lpszDest = '\0';
2278 }
2279 return lpszDest;
2280}

Referenced by SHUnicodeToUnicode().

◆ StrCpyW()

LPWSTR WINAPI StrCpyW ( LPWSTR  lpszStr,
LPCWSTR  lpszSrc 
)

Definition at line 514 of file string.c.

515{
516 TRACE("(%p,%s)\n", lpszStr, debugstr_w(lpszSrc));
517
518 if (lpszStr && lpszSrc)
519 strcpyW(lpszStr, lpszSrc);
520 return lpszStr;
521}
#define strcpyW(d, s)
Definition: unicode.h:29

Referenced by _ShowContextMenu(), PathCreateFromUrlW(), and test_StrCpyW().

◆ StrCSpnA()

int WINAPI StrCSpnA ( LPCSTR  lpszStr,
LPCSTR  lpszMatch 
)

Definition at line 1181 of file string.c.

1182{
1183 TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
1184
1185 return SHLWAPI_StrSpnHelperA(lpszStr, lpszMatch, StrChrA, TRUE);
1186}
static int SHLWAPI_StrSpnHelperA(LPCSTR lpszStr, LPCSTR lpszMatch, LPSTR(WINAPI *pStrChrFn)(LPCSTR, WORD), BOOL bInvert)
Definition: string.c:1114

◆ StrCSpnIA()

int WINAPI StrCSpnIA ( LPCSTR  lpszStr,
LPCSTR  lpszMatch 
)

Definition at line 1213 of file string.c.

1214{
1215 TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
1216
1217 return SHLWAPI_StrSpnHelperA(lpszStr, lpszMatch, StrChrIA, TRUE);
1218}
LPSTR WINAPI StrChrIA(LPCSTR lpszStr, WORD ch)
Definition: string.c:614

◆ StrCSpnIW()

int WINAPI StrCSpnIW ( LPCWSTR  lpszStr,
LPCWSTR  lpszMatch 
)

Definition at line 1225 of file string.c.

1226{
1227 LPCWSTR lpszRead = lpszStr;
1228
1229 TRACE("(%s,%s)\n",debugstr_w(lpszStr), debugstr_w(lpszMatch));
1230
1231 if (lpszStr && *lpszStr && lpszMatch)
1232 {
1233 while (*lpszRead)
1234 {
1235 if (StrChrIW(lpszMatch, *lpszRead)) break;
1236 lpszRead++;
1237 }
1238 }
1239 return lpszRead - lpszStr;
1240}
LPWSTR WINAPI StrChrIW(LPCWSTR lpszStr, WCHAR ch)
Definition: string.c:635

◆ StrCSpnW()

int WINAPI StrCSpnW ( LPCWSTR  lpszStr,
LPCWSTR  lpszMatch 
)

Definition at line 1193 of file string.c.

1194{
1195 if (!lpszStr || !lpszMatch) return 0;
1196 return strcspnW( lpszStr, lpszMatch );
1197}
#define strcspnW(d, s)
Definition: unicode.h:31

◆ StrDupA()

LPSTR WINAPI StrDupA ( LPCSTR  lpszStr)

Definition at line 1064 of file string.c.

1065{
1066 int iLen;
1067 LPSTR lpszRet;
1068
1069 TRACE("(%s)\n",debugstr_a(lpszStr));
1070
1071 iLen = lpszStr ? strlen(lpszStr) + 1 : 1;
1072 lpszRet = LocalAlloc(LMEM_FIXED, iLen);
1073
1074 if (lpszRet)
1075 {
1076 if (lpszStr)
1077 memcpy(lpszRet, lpszStr, iLen);
1078 else
1079 *lpszRet = '\0';
1080 }
1081 return lpszRet;
1082}
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1390
#define LMEM_FIXED
Definition: winbase.h:368

Referenced by test_StrDupA().

◆ StrDupW()

LPWSTR WINAPI StrDupW ( LPCWSTR  lpszStr)

Definition at line 1089 of file string.c.

1090{
1091 int iLen;
1092 LPWSTR lpszRet;
1093
1094 TRACE("(%s)\n",debugstr_w(lpszStr));
1095
1096 iLen = (lpszStr ? strlenW(lpszStr) + 1 : 1) * sizeof(WCHAR);
1097 lpszRet = LocalAlloc(LMEM_FIXED, iLen);
1098
1099 if (lpszRet)
1100 {
1101 if (lpszStr)
1102 memcpy(lpszRet, lpszStr, iLen);
1103 else
1104 *lpszRet = '\0';
1105 }
1106 return lpszRet;
1107}

Referenced by FileDialog_constructor(), CRecycleBin::GetDisplayNameOf(), IFileDialog2_fnSetCancelButtonLabel(), IFileDialog2_fnSetDefaultExtension(), IFileDialog2_fnSetFileNameLabel(), IFileDialog2_fnSetFileTypes(), IFileDialog2_fnSetOkButtonLabel(), IFileDialog2_fnSetTitle(), CViewStatePropertyBag::Init(), CIniPropertyBag::Init(), IStream_Create(), IStream_fnStat(), PathCreateFromUrlAlloc(), RecursiveFind(), CFindFolder::SearchThreadProc(), set_file_name(), SHExplorerParseCmdLine(), SHLoadIndirectString(), and test_StrXXX_overflows().

◆ StrFormatByteSize64A()

LPSTR WINAPI StrFormatByteSize64A ( LONGLONG  llBytes,
LPSTR  lpszDest,
UINT  cchMax 
)

Definition at line 2488 of file string.c.

2489{
2490 WCHAR wszBuff[32];
2491
2492 StrFormatByteSizeW(llBytes, wszBuff, sizeof(wszBuff)/sizeof(WCHAR));
2493
2494 if (lpszDest)
2495 WideCharToMultiByte(CP_ACP, 0, wszBuff, -1, lpszDest, cchMax, 0, 0);
2496 return lpszDest;
2497}
LPWSTR WINAPI StrFormatByteSizeW(LONGLONG llBytes, LPWSTR lpszDest, UINT cchMax)
Definition: string.c:2380

Referenced by CDrivesFolder::GetDetailsOf(), and StrFormatByteSizeA().

◆ StrFormatByteSizeA()

LPSTR WINAPI StrFormatByteSizeA ( DWORD  dwBytes,
LPSTR  lpszDest,
UINT  cchMax 
)

Definition at line 2516 of file string.c.

2517{
2518 TRACE("(%d,%p,%d)\n", dwBytes, lpszDest, cchMax);
2519
2520 return StrFormatByteSize64A(dwBytes, lpszDest, cchMax);
2521}
LPSTR WINAPI StrFormatByteSize64A(LONGLONG llBytes, LPSTR lpszDest, UINT cchMax)
Definition: string.c:2488

◆ StrFormatByteSizeW()

LPWSTR WINAPI StrFormatByteSizeW ( LONGLONG  llBytes,
LPWSTR  lpszDest,
UINT  cchMax 
)

Definition at line 2380 of file string.c.

2381{
2382#define KB ((ULONGLONG)1024)
2383#define MB (KB*KB)
2384#define GB (KB*KB*KB)
2385#define TB (KB*KB*KB*KB)
2386#define PB (KB*KB*KB*KB*KB)
2387
2388 static const SHLWAPI_BYTEFORMATS bfFormats[] =
2389 {
2390#ifdef __REACTOS__
2391 { 10*KB, 10.24, 100.0, 2, IDS_KB_FORMAT }, /* 10 KB */
2392 { 100*KB, 102.4, 10.0, 1, IDS_KB_FORMAT }, /* 100 KB */
2393 { 1000*KB, 1024.0, 1.0, 0, IDS_KB_FORMAT }, /* 1000 KB */
2394 { 10*MB, 10485.76, 100.0, 2, IDS_MB_FORMAT }, /* 10 MB */
2395 { 100*MB, 104857.6, 10.0, 1, IDS_MB_FORMAT }, /* 100 MB */
2396 { 1000*MB, 1048576.0, 1.0, 0, IDS_MB_FORMAT }, /* 1000 MB */
2397 { 10*GB, 10737418.24, 100.0, 2, IDS_GB_FORMAT }, /* 10 GB */
2398 { 100*GB, 107374182.4, 10.0, 1, IDS_GB_FORMAT }, /* 100 GB */
2399 { 1000*GB, 1073741824.0, 1.0, 0, IDS_GB_FORMAT }, /* 1000 GB */
2400 { 10*TB, 10485.76, 100.0, 2, IDS_TB_FORMAT }, /* 10 TB */
2401 { 100*TB, 104857.6, 10.0, 1, IDS_TB_FORMAT }, /* 100 TB */
2402 { 1000*TB, 1048576.0, 1.0, 0, IDS_TB_FORMAT }, /* 1000 TB */
2403 { 10*PB, 10737418.24, 100.00, 2, IDS_PB_FORMAT }, /* 10 PB */
2404 { 100*PB, 107374182.4, 10.00, 1, IDS_PB_FORMAT }, /* 100 PB */
2405 { 1000*PB, 1073741824.0, 1.00, 0, IDS_PB_FORMAT }, /* 1000 PB */
2406 { 0, 10995116277.76, 100.00, 2, IDS_EB_FORMAT } /* EB's, catch all */
2407#else
2408 { 10*KB, 10.24, 100.0, 2, 'K' }, /* 10 KB */
2409 { 100*KB, 102.4, 10.0, 1, 'K' }, /* 100 KB */
2410 { 1000*KB, 1024.0, 1.0, 0, 'K' }, /* 1000 KB */
2411 { 10*MB, 10485.76, 100.0, 2, 'M' }, /* 10 MB */
2412 { 100*MB, 104857.6, 10.0, 1, 'M' }, /* 100 MB */
2413 { 1000*MB, 1048576.0, 1.0, 0, 'M' }, /* 1000 MB */
2414 { 10*GB, 10737418.24, 100.0, 2, 'G' }, /* 10 GB */
2415 { 100*GB, 107374182.4, 10.0, 1, 'G' }, /* 100 GB */
2416 { 1000*GB, 1073741824.0, 1.0, 0, 'G' }, /* 1000 GB */
2417 { 10*TB, 10485.76, 100.0, 2, 'T' }, /* 10 TB */
2418 { 100*TB, 104857.6, 10.0, 1, 'T' }, /* 100 TB */
2419 { 1000*TB, 1048576.0, 1.0, 0, 'T' }, /* 1000 TB */
2420 { 10*PB, 10737418.24, 100.00, 2, 'P' }, /* 10 PB */
2421 { 100*PB, 107374182.4, 10.00, 1, 'P' }, /* 100 PB */
2422 { 1000*PB, 1073741824.0, 1.00, 0, 'P' }, /* 1000 PB */
2423 { 0, 10995116277.76, 100.00, 2, 'E' } /* EB's, catch all */
2424#endif
2425 };
2426#ifdef __REACTOS__
2427 WCHAR szBuff[40], wszFormat[40];
2428#else
2429 WCHAR wszAdd[] = {' ','?','B',0};
2430#endif
2431 double dBytes;
2432 UINT i = 0;
2433
2434 TRACE("(0x%s,%p,%d)\n", wine_dbgstr_longlong(llBytes), lpszDest, cchMax);
2435
2436 if (!lpszDest || !cchMax)
2437 return lpszDest;
2438
2439 if (llBytes < 1024) /* 1K */
2440 {
2441 WCHAR wszBytesFormat[64];
2442 LoadStringW(shlwapi_hInstance, IDS_BYTES_FORMAT, wszBytesFormat, 64);
2443 snprintfW(lpszDest, cchMax, wszBytesFormat, (int)llBytes);
2444 return lpszDest;
2445 }
2446
2447 /* Note that if this loop completes without finding a match, i will be
2448 * pointing at the last entry, which is a catch all for > 1000 PB
2449 */
2450 while (i < sizeof(bfFormats) / sizeof(SHLWAPI_BYTEFORMATS) - 1)
2451 {
2452 if (llBytes < bfFormats[i].dLimit)
2453 break;
2454 i++;
2455 }
2456 /* Above 1 TB we encounter problems with FP accuracy. So for amounts above
2457 * this number we integer shift down by 1 MB first. The table above has
2458 * the divisors scaled down from the '< 10 TB' entry onwards, to account
2459 * for this. We also add a small fudge factor to get the correct result for
2460 * counts that lie exactly on a 1024 byte boundary.
2461 */
2462 if (i > 8)
2463 dBytes = (double)(llBytes >> 20) + 0.001; /* Scale down by 1 MB */
2464 else
2465 dBytes = (double)llBytes + 0.00001;
2466
2467 dBytes = floor(dBytes / bfFormats[i].dDivisor) / bfFormats[i].dNormaliser;
2468
2469#ifdef __REACTOS__
2470 if (!FormatDouble(dBytes, bfFormats[i].nDecimals, szBuff, ARRAYSIZE(szBuff)))
2471 return NULL;
2472 LoadStringW(shlwapi_hInstance, bfFormats[i].nFormatID, wszFormat, ARRAYSIZE(wszFormat));
2473 snprintfW(lpszDest, cchMax, wszFormat, szBuff);
2474#else
2475 if (!FormatDouble(dBytes, bfFormats[i].nDecimals, lpszDest, cchMax))
2476 return NULL;
2477 wszAdd[1] = bfFormats[i].wPrefix;
2478 StrCatBuffW(lpszDest, wszAdd, cchMax);
2479#endif
2480 return lpszDest;
2481}
#define IDS_BYTES_FORMAT
Definition: resource.h:120
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
#define KB
#define PB
LPWSTR WINAPI StrCatBuffW(LPWSTR lpszStr, LPCWSTR lpszCat, INT cchMax)
Definition: string.c:1436
#define TB
#define GB
#define MB
static int FormatDouble(double value, int decimals, LPWSTR pszBuf, int cchBuf)
Definition: string.c:129
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
_Check_return_ _CRTIMP double __cdecl floor(_In_ double x)
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:80
unsigned int UINT
Definition: ndis.h:50

Referenced by AddUserProfile(), CAvailableApplicationInfo::CAvailableApplicationInfo(), FormatFileSizeWithBytes(), CZipFolder::GetDetailsOf(), CDrvDefExt::InitGeneralPage(), InitializeFormatDriveDlg(), InitializeRecycleBinDlg(), InsertDefaultClusterSizeForFs(), msi_dialog_vcl_add_drives(), PerformancePageRefreshThread(), PrintDiskData(), PrintPartitionData(), CDownloaderProgress::SetProgress(), SH_FormatFileSizeWithBytes(), ShortSizeFormatW(), StrFormatByteSize64A(), UpdateLanStatusUiDlg(), and CDefView::UpdateStatusbar().

◆ StrFormatKBSizeA()

LPSTR WINAPI StrFormatKBSizeA ( LONGLONG  llBytes,
LPSTR  lpszDest,
UINT  cchMax 
)

Definition at line 1727 of file string.c.

1728{
1729 WCHAR wszBuf[256];
1730
1731 if (!StrFormatKBSizeW(llBytes, wszBuf, 256))
1732 return NULL;
1733 if (!WideCharToMultiByte(CP_ACP, 0, wszBuf, -1, lpszDest, cchMax, NULL, NULL))
1734 return NULL;
1735 return lpszDest;
1736}
LPWSTR WINAPI StrFormatKBSizeW(LONGLONG llBytes, LPWSTR lpszDest, UINT cchMax)
Definition: string.c:1743

Referenced by _ILGetFileSize(), and CFontExt::GetDetailsOf().

◆ StrFormatKBSizeW()

LPWSTR WINAPI StrFormatKBSizeW ( LONGLONG  llBytes,
LPWSTR  lpszDest,
UINT  cchMax 
)

Definition at line 1743 of file string.c.

1744{
1745 static const WCHAR kb[] = {' ','K','B',0};
1746 LONGLONG llKB = (llBytes + 1023) >> 10;
1747 int len;
1748
1749 TRACE("(0x%s,%p,%d)\n", wine_dbgstr_longlong(llBytes), lpszDest, cchMax);
1750
1751 if (!FormatInt(llKB, lpszDest, cchMax))
1752 return NULL;
1753
1755 if (cchMax - len < 4)
1756 return NULL;
1757 lstrcatW(lpszDest, kb);
1758 return lpszDest;
1759}
static int FormatInt(LONGLONG qdwValue, LPWSTR pszBuf, int cchBuf)
Definition: string.c:96
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
int64_t LONGLONG
Definition: typedefs.h:68

Referenced by CRecycleBin::GetDetailsOf(), and StrFormatKBSizeA().

◆ StrFromTimeIntervalA()

INT WINAPI StrFromTimeIntervalA ( LPSTR  lpszStr,
UINT  cchMax,
DWORD  dwMS,
int  iDigits 
)

Definition at line 2117 of file string.c.

2119{
2120 INT iRet = 0;
2121
2122 TRACE("(%p,%d,%d,%d)\n", lpszStr, cchMax, dwMS, iDigits);
2123
2124 if (lpszStr && cchMax)
2125 {
2126 WCHAR szBuff[128];
2127 StrFromTimeIntervalW(szBuff, sizeof(szBuff)/sizeof(WCHAR), dwMS, iDigits);
2128 WideCharToMultiByte(CP_ACP,0,szBuff,-1,lpszStr,cchMax,0,0);
2129 }
2130 return iRet;
2131}
INT WINAPI StrFromTimeIntervalW(LPWSTR lpszStr, UINT cchMax, DWORD dwMS, int iDigits)
Definition: string.c:2139

Referenced by test_StrFromTimeIntervalA().

◆ StrFromTimeIntervalW()

INT WINAPI StrFromTimeIntervalW ( LPWSTR  lpszStr,
UINT  cchMax,
DWORD  dwMS,
int  iDigits 
)

Definition at line 2139 of file string.c.

2141{
2142 INT iRet = 0;
2143
2144 TRACE("(%p,%d,%d,%d)\n", lpszStr, cchMax, dwMS, iDigits);
2145
2146 if (lpszStr && cchMax)
2147 {
2148 WCHAR szCopy[128];
2149 DWORD dwHours, dwMinutes;
2150
2151 if (!iDigits || cchMax == 1)
2152 {
2153 *lpszStr = '\0';
2154 return 0;
2155 }
2156
2157 /* Calculate the time classes */
2158 dwMS = (dwMS + 500) / 1000;
2159 dwHours = dwMS / 3600;
2160 dwMS -= dwHours * 3600;
2161 dwMinutes = dwMS / 60;
2162 dwMS -= dwMinutes * 60;
2163
2164 szCopy[0] = '\0';
2165
2166 if (dwHours)
2167 iDigits = SHLWAPI_WriteTimeClass(szCopy, dwHours, IDS_TIME_INTERVAL_HOURS, iDigits);
2168
2169 if (dwMinutes && iDigits)
2170 iDigits = SHLWAPI_WriteTimeClass(szCopy, dwMinutes, IDS_TIME_INTERVAL_MINUTES, iDigits);
2171
2172 if (iDigits) /* Always write seconds if we have significant digits */
2173 SHLWAPI_WriteTimeClass(szCopy, dwMS, IDS_TIME_INTERVAL_SECONDS, iDigits);
2174
2175 lstrcpynW(lpszStr, szCopy, cchMax);
2176 iRet = strlenW(lpszStr);
2177 }
2178 return iRet;
2179}
#define IDS_TIME_INTERVAL_MINUTES
Definition: resource.h:28
#define IDS_TIME_INTERVAL_HOURS
Definition: resource.h:27
#define IDS_TIME_INTERVAL_SECONDS
Definition: resource.h:29
static int SHLWAPI_WriteTimeClass(LPWSTR lpszOut, DWORD dwValue, UINT uClassStringId, int iDigits)
Definition: string.c:2073

Referenced by dialog_proc(), and StrFromTimeIntervalA().

◆ StrIsIntlEqualA()

BOOL WINAPI StrIsIntlEqualA ( BOOL  bCase,
LPCSTR  lpszStr,
LPCSTR  lpszComp,
int  iLen 
)

Definition at line 2196 of file string.c.

2198{
2199 DWORD dwFlags;
2200
2201 TRACE("(%d,%s,%s,%d)\n", bCase,
2202 debugstr_a(lpszStr), debugstr_a(lpszComp), iLen);
2203
2204 /* FIXME: This flag is undocumented and unknown by our CompareString.
2205 * We need a define for it.
2206 */
2207 dwFlags = 0x10000000;
2208 if (!bCase) dwFlags |= NORM_IGNORECASE;
2209
2210 return (CompareStringA(GetThreadLocale(), dwFlags, lpszStr, iLen, lpszComp, iLen) == CSTR_EQUAL);
2211}

◆ StrIsIntlEqualW()

BOOL WINAPI StrIsIntlEqualW ( BOOL  bCase,
LPCWSTR  lpszStr,
LPCWSTR  lpszComp,
int  iLen 
)

Definition at line 2218 of file string.c.

2220{
2221 DWORD dwFlags;
2222
2223 TRACE("(%d,%s,%s,%d)\n", bCase,
2224 debugstr_w(lpszStr),debugstr_w(lpszComp), iLen);
2225
2226 /* FIXME: This flag is undocumented and unknown by our CompareString.
2227 * We need a define for it.
2228 */
2229 dwFlags = 0x10000000;
2230 if (!bCase) dwFlags |= NORM_IGNORECASE;
2231
2232 return (CompareStringW(GetThreadLocale(), dwFlags, lpszStr, iLen, lpszComp, iLen) == CSTR_EQUAL);
2233}

◆ StrNCatA()

LPSTR WINAPI StrNCatA ( LPSTR  lpszStr,
LPCSTR  lpszCat,
INT  cchMax 
)

Definition at line 1778 of file string.c.

1779{
1780 LPSTR lpszRet = lpszStr;
1781
1782 TRACE("(%s,%s,%i)\n", debugstr_a(lpszStr), debugstr_a(lpszCat), cchMax);
1783
1784 if (!lpszStr)
1785 {
1786 WARN("Invalid lpszStr would crash under Win32!\n");
1787 return NULL;
1788 }
1789
1790 StrCpyNA(lpszStr + strlen(lpszStr), lpszCat, cchMax);
1791 return lpszRet;
1792}

◆ StrNCatW()

LPWSTR WINAPI StrNCatW ( LPWSTR  lpszStr,
LPCWSTR  lpszCat,
INT  cchMax 
)

Definition at line 1799 of file string.c.

1800{
1801 LPWSTR lpszRet = lpszStr;
1802
1803 TRACE("(%s,%s,%i)\n", debugstr_w(lpszStr), debugstr_w(lpszCat), cchMax);
1804
1805 if (!lpszStr)
1806 {
1807 WARN("Invalid lpszStr would crash under Win32\n");
1808 return NULL;
1809 }
1810
1811 StrCpyNW(lpszStr + strlenW(lpszStr), lpszCat, cchMax);
1812 return lpszRet;
1813}

◆ StrPBrkA()

LPSTR WINAPI StrPBrkA ( LPCSTR  lpszStr,
LPCSTR  lpszMatch 
)

Definition at line 1255 of file string.c.

1256{
1257 TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
1258
1259 if (lpszStr && lpszMatch && *lpszMatch)
1260 {
1261 while (*lpszStr)
1262 {
1263 if (StrChrA(lpszMatch, *lpszStr))
1264 return (LPSTR)lpszStr;
1265 lpszStr = CharNextA(lpszStr);
1266 }
1267 }
1268 return NULL;
1269}

◆ StrPBrkW()

LPWSTR WINAPI StrPBrkW ( LPCWSTR  lpszStr,
LPCWSTR  lpszMatch 
)

Definition at line 1276 of file string.c.

1277{
1278 if (!lpszStr || !lpszMatch) return NULL;
1279 return strpbrkW( lpszStr, lpszMatch );
1280}
#define strpbrkW(str, accept)
Definition: unicode.h:43

Referenced by CheckEscapesW(), parse_file_list(), and SHFindAttrW().

◆ StrRChrA()

LPSTR WINAPI StrRChrA ( LPCSTR  lpszStr,
LPCSTR  lpszEnd,
WORD  ch 
)

Definition at line 1327 of file string.c.

1328{
1329 TRACE("(%s,%s,%x)\n", debugstr_a(lpszStr), debugstr_a(lpszEnd), ch);
1330
1331 return SHLWAPI_StrRChrHelperA(lpszStr, lpszEnd, ch, SHLWAPI_ChrCmpA);
1332}
static LPSTR SHLWAPI_StrRChrHelperA(LPCSTR lpszStr, LPCSTR lpszEnd, WORD ch, BOOL(WINAPI *pChrCmpFn)(WORD, WORD))
Definition: string.c:1287

◆ StrRChrIA()

LPSTR WINAPI StrRChrIA ( LPCSTR  lpszStr,
LPCSTR  lpszEnd,
WORD  ch 
)

Definition at line 1368 of file string.c.

1369{
1370 TRACE("(%s,%s,%x)\n", debugstr_a(lpszStr), debugstr_a(lpszEnd), ch);
1371
1372 return SHLWAPI_StrRChrHelperA(lpszStr, lpszEnd, ch, ChrCmpIA);
1373}

◆ StrRChrIW()

LPWSTR WINAPI StrRChrIW ( LPCWSTR  str,
LPCWSTR  end,
WORD  ch 
)

Definition at line 1380 of file string.c.

1381{
1382 WCHAR *ret = NULL;
1383
1384 if (!str) return NULL;
1385 if (!end) end = str + strlenW(str);
1386 while (str < end)
1387 {
1388 if (!ChrCmpIW(*str, ch)) ret = (WCHAR *)str;
1389 str++;
1390 }
1391 return ret;
1392}
const WCHAR * str
int ret

◆ StrRChrW()

LPWSTR WINAPI StrRChrW ( LPCWSTR  str,
LPCWSTR  end,
WORD  ch 
)

Definition at line 1339 of file string.c.

1340{
1341 WCHAR *ret = NULL;
1342
1343 if (!str) return NULL;
1344 if (!end) end = str + strlenW(str);
1345 while (str < end)
1346 {
1347 if (*str == ch) ret = (WCHAR *)str;
1348 str++;
1349 }
1350 return ret;
1351}

◆ StrRetToBSTR()

HRESULT WINAPI StrRetToBSTR ( STRRET lpStrRet,
LPCITEMIDLIST  pidl,
BSTR pBstrOut 
)

Definition at line 1686 of file string.c.

1687{
1688 HRESULT hRet = E_FAIL;
1689
1690 switch (lpStrRet->uType)
1691 {
1692 case STRRET_WSTR:
1693 *pBstrOut = SysAllocString(lpStrRet->u.pOleStr);
1694 if (*pBstrOut)
1695 hRet = S_OK;
1696 CoTaskMemFree(lpStrRet->u.pOleStr);
1697 break;
1698
1699 case STRRET_CSTR:
1700 hRet = _SHStrDupAToBSTR(lpStrRet->u.cStr, pBstrOut);
1701 break;
1702
1703 case STRRET_OFFSET:
1704 hRet = _SHStrDupAToBSTR(((LPCSTR)&pidl->mkid) + lpStrRet->u.uOffset, pBstrOut);
1705 break;
1706
1707 default:
1708 *pBstrOut = NULL;
1709 }
1710
1711 return hRet;
1712}
static HRESULT _SHStrDupAToBSTR(LPCSTR src, BSTR *pBstrOut)
Definition: string.c:1650
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
@ STRRET_CSTR
Definition: shtypes.idl:87
@ STRRET_OFFSET
Definition: shtypes.idl:86
@ STRRET_WSTR
Definition: shtypes.idl:85
char cStr[MAX_PATH]
Definition: shtypes.idl:98
UINT uType
Definition: shtypes.idl:93
LPWSTR pOleStr
Definition: shtypes.idl:96
UINT uOffset
Definition: shtypes.idl:97

Referenced by CFolderItem::get_Name(), and CFolderItem::get_Path().

◆ StrRetToBufA()

HRESULT WINAPI StrRetToBufA ( LPSTRRET  src,
const ITEMIDLIST pidl,
LPSTR  dest,
UINT  len 
)

Definition at line 1473 of file string.c.

1474{
1475 /* NOTE:
1476 * This routine is identical to that in dlls/shell32/shellstring.c.
1477 * It was duplicated because not every version of Shlwapi.dll exports
1478 * StrRetToBufA. If you change one routine, change them both.
1479 */
1480 TRACE("dest=%p len=0x%x strret=%p pidl=%p\n", dest, len, src, pidl);
1481
1482 if (!src)
1483 {
1484 WARN("Invalid lpStrRet would crash under Win32!\n");
1485 if (dest)
1486 *dest = '\0';
1487 return E_FAIL;
1488 }
1489
1490 if (!dest || !len)
1491 return E_FAIL;
1492
1493 *dest = '\0';
1494
1495 switch (src->uType)
1496 {
1497 case STRRET_WSTR:
1498 WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, dest, len, NULL, NULL);
1499 CoTaskMemFree(src->u.pOleStr);
1500 break;
1501
1502 case STRRET_CSTR:
1503 lstrcpynA(dest, src->u.cStr, len);
1504 break;
1505
1506 case STRRET_OFFSET:
1507 lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
1508 break;
1509
1510 default:
1511 FIXME("unknown type!\n");
1512 return E_NOTIMPL;
1513 }
1514 return S_OK;
1515}
#define E_NOTIMPL
Definition: ddrawi.h:99
SHITEMID mkid
Definition: shtypes.idl:34

◆ StrRetToBufW()

HRESULT WINAPI StrRetToBufW ( LPSTRRET  src,
const ITEMIDLIST pidl,
LPWSTR  dest,
UINT  len 
)

Definition at line 1522 of file string.c.

1523{
1524 TRACE("dest=%p len=0x%x strret=%p pidl=%p\n", dest, len, src, pidl);
1525
1526 if (!dest || !len)
1527 return E_FAIL;
1528
1529 if (!src)
1530 {
1531 WARN("Invalid lpStrRet would crash under Win32!\n");
1532 if (dest)
1533 *dest = '\0';
1534 return E_FAIL;
1535 }
1536
1537 *dest = '\0';
1538
1539 switch (src->uType) {
1540 case STRRET_WSTR: {
1541 size_t dst_len;
1542 if (!src->u.pOleStr)
1543 return E_FAIL;
1544 dst_len = strlenW(src->u.pOleStr);
1545 memcpy(dest, src->u.pOleStr, min(dst_len, len-1) * sizeof(WCHAR));
1546 dest[min(dst_len, len-1)] = 0;
1547 CoTaskMemFree(src->u.pOleStr);
1548 if (len <= dst_len)
1549 {
1550 dest[0] = 0;
1552 }
1553 break;
1554 }
1555
1556 case STRRET_CSTR:
1557 if (!MultiByteToWideChar( CP_ACP, 0, src->u.cStr, -1, dest, len ))
1558 dest[len-1] = 0;
1559 break;
1560
1561 case STRRET_OFFSET:
1562 if (pidl)
1563 {
1564 if (!MultiByteToWideChar( CP_ACP, 0, ((LPCSTR)&pidl->mkid)+src->u.uOffset, -1,
1565 dest, len ))
1566 dest[len-1] = 0;
1567 }
1568 break;
1569
1570 default:
1571 FIXME("unknown type!\n");
1572 return E_NOTIMPL;
1573 }
1574
1575 return S_OK;
1576}
#define min(a, b)
Definition: monoChain.cc:55
#define E_NOT_SUFFICIENT_BUFFER
Definition: winerror.h:2345

Referenced by CFSDropTarget::_CopyItems(), CFSDropTarget::_DoDrop(), CAddressEditBox::AddComboBoxItem(), COMDLG32_GetDisplayNameOf(), COMDLG32_UpdateCurrentDir(), CMyDocsDropHandler::Drop(), CDeskLinkDropHandler::Drop(), FindExpectedFile(), GetDisplayName(), CCommonFolder< TSelf, TItemId, TExtractIcon >::GetDisplayNameOf(), GetFullName(), IEGetNameAndFlagsEx(), CExplorerBand::InsertItem(), ok_displayname_(), SHELL32_CompareDetails(), SHGetPathCchFromIDListW(), SHIsRemovableDrive(), SHOpenFolderAndSelectItems(), test_desktop_displaynameof(), test_FolderShortcut(), test_GetDisplayName(), test_LocalizedNames(), test_SHGetNameFromIDList(), and test_SHGetPathFromIDList().

◆ StrRetToStrA()

HRESULT WINAPI StrRetToStrA ( LPSTRRET  lpStrRet,
const ITEMIDLIST pidl,
LPSTR ppszName 
)

Definition at line 1592 of file string.c.

1593{
1594 HRESULT hRet = E_FAIL;
1595
1596 switch (lpStrRet->uType)
1597 {
1598 case STRRET_WSTR:
1599 hRet = _SHStrDupAW(lpStrRet->u.pOleStr, ppszName);
1600 CoTaskMemFree(lpStrRet->u.pOleStr);
1601 break;
1602
1603 case STRRET_CSTR:
1604 hRet = _SHStrDupAA(lpStrRet->u.cStr, ppszName);
1605 break;
1606
1607 case STRRET_OFFSET:
1608 hRet = _SHStrDupAA(((LPCSTR)&pidl->mkid) + lpStrRet->u.uOffset, ppszName);
1609 break;
1610
1611 default:
1612 *ppszName = NULL;
1613 }
1614
1615 return hRet;
1616}
static HRESULT _SHStrDupAA(LPCSTR, LPSTR *)
Definition: string.c:1909
static HRESULT _SHStrDupAW(LPCWSTR, LPSTR *)
Definition: string.c:1976
SIGDN PWSTR * ppszName
Definition: shobjidl.idl:595

◆ StrRetToStrW()

HRESULT WINAPI StrRetToStrW ( LPSTRRET  lpStrRet,
const ITEMIDLIST pidl,
LPWSTR ppszName 
)

Definition at line 1623 of file string.c.

1624{
1625 HRESULT hRet = E_FAIL;
1626
1627 switch (lpStrRet->uType)
1628 {
1629 case STRRET_WSTR:
1630 hRet = SHStrDupW(lpStrRet->u.pOleStr, ppszName);
1631 CoTaskMemFree(lpStrRet->u.pOleStr);
1632 break;
1633
1634 case STRRET_CSTR:
1635 hRet = SHStrDupA(lpStrRet->u.cStr, ppszName);
1636 break;
1637
1638 case STRRET_OFFSET:
1639 hRet = SHStrDupA(((LPCSTR)&pidl->mkid) + lpStrRet->u.uOffset, ppszName);
1640 break;
1641
1642 default:
1643 *ppszName = NULL;
1644 }
1645
1646 return hRet;
1647}
HRESULT WINAPI SHStrDupW(LPCWSTR src, LPWSTR *dest)
Definition: string.c:2004
HRESULT WINAPI SHStrDupA(LPCSTR lpszStr, LPWSTR *lppszDest)
Definition: string.c:1946

Referenced by CEnumMergedFolder::Begin(), GetDisplayname(), CACListISF::GetDisplayName(), CSendToMenu::LoadAllItems(), and SHGetNameFromIDList().

◆ StrRStrIA()

LPSTR WINAPI StrRStrIA ( LPCSTR  lpszStr,
LPCSTR  lpszEnd,
LPCSTR  lpszSearch 
)

Definition at line 627 of file string.c.

628{
629 LPSTR lpszRet = NULL;
630 WORD ch1, ch2;
631 INT iLen;
632
633 TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
634
635 if (!lpszStr || !lpszSearch || !*lpszSearch)
636 return NULL;
637
638 if (IsDBCSLeadByte(*lpszSearch))
639 ch1 = *lpszSearch << 8 | (UCHAR)lpszSearch[1];
640 else
641 ch1 = *lpszSearch;
642 iLen = lstrlenA(lpszSearch);
643
644 if (!lpszEnd)
645 lpszEnd = lpszStr + lstrlenA(lpszStr);
646 else /* reproduce the broken behaviour on Windows */
647 lpszEnd += min(iLen - 1, lstrlenA(lpszEnd));
648
649 while (lpszStr + iLen <= lpszEnd && *lpszStr)
650 {
651 ch2 = IsDBCSLeadByte(*lpszStr)? *lpszStr << 8 | (UCHAR)lpszStr[1] : *lpszStr;
652 if (!ChrCmpIA(ch1, ch2))
653 {
654 if (!StrCmpNIA(lpszStr, lpszSearch, iLen))
655 lpszRet = (LPSTR)lpszStr;
656 }
657 lpszStr = CharNextA(lpszStr);
658 }
659 return lpszRet;
660}
INT WINAPI StrCmpNIA(LPCSTR lpszStr, LPCSTR lpszComp, INT iLen)
Definition: string.c:300
unsigned char UCHAR
Definition: xmlstorage.h:181

◆ StrRStrIW()

LPWSTR WINAPI StrRStrIW ( LPCWSTR  lpszStr,
LPCWSTR  lpszEnd,
LPCWSTR  lpszSearch 
)

Definition at line 667 of file string.c.

668{
669 LPWSTR lpszRet = NULL;
670 INT iLen;
671
672 TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch));
673
674 if (!lpszStr || !lpszSearch || !*lpszSearch)
675 return NULL;
676
677 iLen = strlenW(lpszSearch);
678
679 if (!lpszEnd)
680 lpszEnd = lpszStr + strlenW(lpszStr);
681 else /* reproduce the broken behaviour on Windows */
682 lpszEnd += min(iLen - 1, lstrlenW(lpszEnd));
683
684 while (lpszStr + iLen <= lpszEnd && *lpszStr)
685 {
686 if (!ChrCmpIW(*lpszSearch, *lpszStr))
687 {
688 if (!StrCmpNIW(lpszStr, lpszSearch, iLen))
689 lpszRet = (LPWSTR)lpszStr;
690 }
691 lpszStr++;
692 }
693 return lpszRet;
694}
INT WINAPI StrCmpNIW(LPCWSTR lpszStr, LPCWSTR lpszComp, INT iLen)
Definition: string.c:311

◆ StrSpnA()

int WINAPI StrSpnA ( LPCSTR  lpszStr,
LPCSTR  lpszMatch 
)

Definition at line 1149 of file string.c.

1150{
1151 TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
1152
1153 return SHLWAPI_StrSpnHelperA(lpszStr, lpszMatch, StrChrA, FALSE);
1154}
#define FALSE
Definition: types.h:117

◆ StrSpnW()

int WINAPI StrSpnW ( LPCWSTR  lpszStr,
LPCWSTR  lpszMatch 
)

Definition at line 1161 of file string.c.

1162{
1163 if (!lpszStr || !lpszMatch) return 0;
1164 return strspnW( lpszStr, lpszMatch );
1165}
#define strspnW(str, accept)
Definition: unicode.h:42

◆ StrStrA()

LPSTR WINAPI StrStrA ( LPCSTR  lpszStr,
LPCSTR  lpszSearch 
)

Definition at line 594 of file string.c.

595{
596 TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
597
598 return SHLWAPI_StrStrHelperA(lpszStr, lpszSearch, StrCmpNA);
599}
INT WINAPI StrCmpNA(LPCSTR lpszStr, LPCSTR lpszComp, INT iLen)
Definition: string.c:493
static LPSTR SHLWAPI_StrStrHelperA(LPCSTR lpszStr, LPCSTR lpszSearch, INT(WINAPI *pStrCmpFn)(LPCSTR, LPCSTR, INT))
Definition: string.c:561

◆ StrStrIA()

LPSTR WINAPI StrStrIA ( LPCSTR  lpszStr,
LPCSTR  lpszSearch 
)

Definition at line 708 of file string.c.

709{
710 TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
711
712 return SHLWAPI_StrStrHelperA(lpszStr, lpszSearch, StrCmpNIA);
713}

◆ StrStrIW()

LPWSTR WINAPI StrStrIW ( LPCWSTR  lpszStr,
LPCWSTR  lpszSearch 
)

Definition at line 720 of file string.c.

721{
722 int iLen;
723 LPCWSTR end;
724
725 TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch));
726
727 if (!lpszStr || !lpszSearch || !*lpszSearch)
728 return NULL;
729
730 iLen = strlenW(lpszSearch);
731 end = lpszStr + strlenW(lpszStr);
732
733 while (lpszStr + iLen <= end)
734 {
735 if (!StrCmpNIW(lpszStr, lpszSearch, iLen))
736 return (LPWSTR)lpszStr;
737 lpszStr++;
738 }
739 return NULL;
740}

◆ StrStrNIW()

LPWSTR WINAPI StrStrNIW ( LPCWSTR  lpFirst,
LPCWSTR  lpSrch,
UINT  cchMax 
)

Definition at line 790 of file string.c.

791{
792 UINT i;
793 int len;
794
795 TRACE("(%s, %s, %u)\n", debugstr_w(lpFirst), debugstr_w(lpSrch), cchMax);
796
797 if (!lpFirst || !lpSrch || !*lpSrch || !cchMax)
798 return NULL;
799
800 len = strlenW(lpSrch);
801
802 for (i = cchMax; *lpFirst && (i > 0); i--, lpFirst++)
803 {
804 if (!strncmpiW(lpFirst, lpSrch, len))
805 return (LPWSTR)lpFirst;
806 }
807
808 return NULL;
809}
#define strncmpiW(s1, s2, n)
Definition: unicode.h:40

◆ StrStrNW()

LPWSTR WINAPI StrStrNW ( LPCWSTR  lpFirst,
LPCWSTR  lpSrch,
UINT  cchMax 
)

Definition at line 755 of file string.c.

756{
757 UINT i;
758 int len;
759
760 TRACE("(%s, %s, %u)\n", debugstr_w(lpFirst), debugstr_w(lpSrch), cchMax);
761
762 if (!lpFirst || !lpSrch || !*lpSrch || !cchMax)
763 return NULL;
764
765 len = strlenW(lpSrch);
766
767 for (i = cchMax; *lpFirst && (i > 0); i--, lpFirst++)
768 {
769 if (!strncmpW(lpFirst, lpSrch, len))
770 return (LPWSTR)lpFirst;
771 }
772
773 return NULL;
774}
#define strncmpW(s1, s2, n)
Definition: unicode.h:36

◆ StrStrW()

LPWSTR WINAPI StrStrW ( LPCWSTR  lpszStr,
LPCWSTR  lpszSearch 
)

Definition at line 606 of file string.c.

607{
608 TRACE("(%s, %s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch));
609
610 if (!lpszStr || !lpszSearch || !*lpszSearch) return NULL;
611 return strstrW( lpszStr, lpszSearch );
612}
#define strstrW(d, s)
Definition: unicode.h:32

◆ StrToInt64ExA()

BOOL WINAPI StrToInt64ExA ( LPCSTR  lpszStr,
DWORD  dwFlags,
LONGLONG lpiRet 
)

Definition at line 903 of file string.c.

904{
905 BOOL bNegative = FALSE;
906 LONGLONG iRet = 0;
907
908 TRACE("(%s,%08X,%p)\n", debugstr_a(lpszStr), dwFlags, lpiRet);
909
910 if (!lpszStr || !lpiRet)
911 {
912 WARN("Invalid parameter would crash under Win32!\n");
913 return FALSE;
914 }
915 if (dwFlags > STIF_SUPPORT_HEX) WARN("Unknown flags %08x\n", dwFlags);
916
917 /* Skip leading space, '+', '-' */
918 while (isspace(*lpszStr))
919 lpszStr = CharNextA(lpszStr);
920
921 if (*lpszStr == '-')
922 {
923 bNegative = TRUE;
924 lpszStr++;
925 }
926 else if (*lpszStr == '+')
927 lpszStr++;
928
930 *lpszStr == '0' && tolower(lpszStr[1]) == 'x')
931 {
932 /* Read hex number */
933 lpszStr += 2;
934
935 if (!isxdigit(*lpszStr))
936 return FALSE;
937
938 while (isxdigit(*lpszStr))
939 {
940 iRet = iRet * 16;
941 if (isdigit(*lpszStr))
942 iRet += (*lpszStr - '0');
943 else
944 iRet += 10 + (tolower(*lpszStr) - 'a');
945 lpszStr++;
946 }
947 *lpiRet = iRet;
948 return TRUE;
949 }
950
951 /* Read decimal number */
952 if (!isdigit(*lpszStr))
953 return FALSE;
954
955 while (isdigit(*lpszStr))
956 {
957 iRet = iRet * 10;
958 iRet += (*lpszStr - '0');
959 lpszStr++;
960 }
961 *lpiRet = bNegative ? -iRet : iRet;
962 return TRUE;
963}
#define isspace(c)
Definition: acclib.h:69
#define isdigit(c)
Definition: acclib.h:68
#define isxdigit(c)
Definition: acclib.h:70
int tolower(int c)
Definition: utclib.c:902
#define STIF_SUPPORT_HEX
Definition: shlwapi.h:1452

Referenced by StrToIntExA().

◆ StrToInt64ExW()

BOOL WINAPI StrToInt64ExW ( LPCWSTR  lpszStr,
DWORD  dwFlags,
LONGLONG lpiRet 
)

Definition at line 987 of file string.c.

988{
989 BOOL bNegative = FALSE;
990 LONGLONG iRet = 0;
991
992 TRACE("(%s,%08X,%p)\n", debugstr_w(lpszStr), dwFlags, lpiRet);
993
994 if (!lpszStr || !lpiRet)
995 {
996 WARN("Invalid parameter would crash under Win32!\n");
997 return FALSE;
998 }
999 if (dwFlags > STIF_SUPPORT_HEX) WARN("Unknown flags %08x\n", dwFlags);
1000
1001 /* Skip leading space, '+', '-' */
1002 while (isspaceW(*lpszStr)) lpszStr++;
1003
1004 if (*lpszStr == '-')
1005 {
1006 bNegative = TRUE;
1007 lpszStr++;
1008 }
1009 else if (*lpszStr == '+')
1010 lpszStr++;
1011
1012 if (dwFlags & STIF_SUPPORT_HEX &&
1013 *lpszStr == '0' && tolowerW(lpszStr[1]) == 'x')
1014 {
1015 /* Read hex number */
1016 lpszStr += 2;
1017
1018 if (!isxdigitW(*lpszStr))
1019 return FALSE;
1020
1021 while (isxdigitW(*lpszStr))
1022 {
1023 iRet = iRet * 16;
1024 if (isdigitW(*lpszStr))
1025 iRet += (*lpszStr - '0');
1026 else
1027 iRet += 10 + (tolowerW(*lpszStr) - 'a');
1028 lpszStr++;
1029 }
1030 *lpiRet = iRet;
1031 return TRUE;
1032 }
1033
1034 /* Read decimal number */
1035 if (!isdigitW(*lpszStr))
1036 return FALSE;
1037
1038 while (isdigitW(*lpszStr))
1039 {
1040 iRet = iRet * 10;
1041 iRet += (*lpszStr - '0');
1042 lpszStr++;
1043 }
1044 *lpiRet = bNegative ? -iRet : iRet;
1045 return TRUE;
1046}
#define tolowerW(n)
Definition: unicode.h:44
#define isxdigitW(n)
Definition: unicode.h:51
#define isspaceW(n)
Definition: unicode.h:52

Referenced by set_content_length(), and StrToIntExW().

◆ StrToIntA()

int WINAPI StrToIntA ( LPCSTR  lpszStr)

Definition at line 826 of file string.c.

827{
828 int iRet = 0;
829
830 TRACE("(%s)\n", debugstr_a(lpszStr));
831
832 if (!lpszStr)
833 {
834 WARN("Invalid lpszStr would crash under Win32!\n");
835 return 0;
836 }
837
838 if (*lpszStr == '-' || isdigit(*lpszStr))
839 StrToIntExA(lpszStr, 0, &iRet);
840 return iRet;
841}
BOOL WINAPI StrToIntExA(LPCSTR lpszStr, DWORD dwFlags, LPINT lpiRet)
Definition: string.c:886

◆ StrToIntExA()

BOOL WINAPI StrToIntExA ( LPCSTR  lpszStr,
DWORD  dwFlags,
LPINT  lpiRet 
)

Definition at line 886 of file string.c.

887{
888 LONGLONG li;
889 BOOL bRes;
890
891 TRACE("(%s,%08X,%p)\n", debugstr_a(lpszStr), dwFlags, lpiRet);
892
893 bRes = StrToInt64ExA(lpszStr, dwFlags, &li);
894 if (bRes) *lpiRet = li;
895 return bRes;
896}
BOOL WINAPI StrToInt64ExA(LPCSTR lpszStr, DWORD dwFlags, LONGLONG *lpiRet)
Definition: string.c:903
LARGE_INTEGER li
Definition: fxtimerapi.cpp:235

Referenced by StrToIntA(), and test_StrToIntExA().

◆ StrToIntExW()

BOOL WINAPI StrToIntExW ( LPCWSTR  lpszStr,
DWORD  dwFlags,
LPINT  lpiRet 
)

Definition at line 970 of file string.c.

971{
972 LONGLONG li;
973 BOOL bRes;
974
975 TRACE("(%s,%08X,%p)\n", debugstr_w(lpszStr), dwFlags, lpiRet);
976
977 bRes = StrToInt64ExW(lpszStr, dwFlags, &li);
978 if (bRes) *lpiRet = li;
979 return bRes;
980}
BOOL WINAPI StrToInt64ExW(LPCWSTR lpszStr, DWORD dwFlags, LONGLONG *lpiRet)
Definition: string.c:987

Referenced by CompareVersion(), CAvailableApplicationInfo::RetrieveLanguages(), StrCmpLogicalW(), StrToIntW(), test_StrToIntExW(), and UrlUnescapeW().

◆ StrToIntW()

int WINAPI StrToIntW ( LPCWSTR  lpszStr)

Definition at line 848 of file string.c.

849{
850 int iRet = 0;
851
852 TRACE("(%s)\n", debugstr_w(lpszStr));
853
854 if (!lpszStr)
855 {
856 WARN("Invalid lpszStr would crash under Win32!\n");
857 return 0;
858 }
859
860 if (*lpszStr == '-' || isdigitW(*lpszStr))
861 StrToIntExW(lpszStr, 0, &iRet);
862 return iRet;
863}

◆ StrTrimA()

BOOL WINAPI StrTrimA ( LPSTR  lpszStr,
LPCSTR  lpszTrim 
)

Definition at line 1828 of file string.c.

1829{
1830 DWORD dwLen;
1831 LPSTR lpszRead = lpszStr;
1832 BOOL bRet = FALSE;
1833
1834 TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszTrim));
1835
1836 if (lpszRead && *lpszRead)
1837 {
1838 while (*lpszRead && StrChrA(lpszTrim, *lpszRead))
1839 lpszRead = CharNextA(lpszRead); /* Skip leading matches */
1840
1841 dwLen = strlen(lpszRead);
1842
1843 if (lpszRead != lpszStr)
1844 {
1845 memmove(lpszStr, lpszRead, dwLen + 1);
1846 bRet = TRUE;
1847 }
1848 if (dwLen > 0)
1849 {
1850 lpszRead = lpszStr + dwLen;
1851 while (StrChrA(lpszTrim, lpszRead[-1]))
1852 lpszRead = CharPrevA(lpszStr, lpszRead); /* Skip trailing matches */
1853
1854 if (lpszRead != lpszStr + dwLen)
1855 {
1856 *lpszRead = '\0';
1857 bRet = TRUE;
1858 }
1859 }
1860 }
1861 return bRet;
1862}
LPSTR WINAPI CharPrevA(_In_ LPCSTR, _In_ LPCSTR)

◆ StrTrimW()

BOOL WINAPI StrTrimW ( LPWSTR  lpszStr,
LPCWSTR  lpszTrim 
)

Definition at line 1869 of file string.c.

1870{
1871 DWORD dwLen;
1872 LPWSTR lpszRead = lpszStr;
1873 BOOL bRet = FALSE;
1874
1875 TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszTrim));
1876
1877 if (lpszRead && *lpszRead)
1878 {
1879 while (*lpszRead && StrChrW(lpszTrim, *lpszRead)) lpszRead++;
1880
1881 dwLen = strlenW(lpszRead);
1882
1883 if (lpszRead != lpszStr)
1884 {
1885 memmove(lpszStr, lpszRead, (dwLen + 1) * sizeof(WCHAR));
1886 bRet = TRUE;
1887 }
1888 if (dwLen > 0)
1889 {
1890 lpszRead = lpszStr + dwLen;
1891 while (StrChrW(lpszTrim, lpszRead[-1]))
1892 lpszRead--; /* Skip trailing matches */
1893
1894 if (lpszRead != lpszStr + dwLen)
1895 {
1896 *lpszRead = '\0';
1897 bRet = TRUE;
1898 }
1899 }
1900 }
1901 return bRet;
1902}

Referenced by BrsFolder_OnCommand(), EditActionDlg_OnOK(), EditTypeDlg_OnOK(), EditTypeDlg_OnRemove(), FinishDlgProc(), CFSFolder::GetCustomViewInfo(), NewActionDlg_OnOK(), NewExtDlg_OnOK(), CShellLink::OnNotify(), RunDlgProc(), ShellExecCmdLine(), WelcomeDlgProc(), and WindowProc().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( shell  )

Variable Documentation

◆ shlwapi_hInstance

HINSTANCE shlwapi_hInstance
extern

Definition at line 33 of file shlwapi_main.c.

Referenced by DllMain(), SHLWAPI_WriteTimeClass(), and StrFormatByteSizeW().