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

typedef struct tagSHLWAPI_BYTEFORMATS SHLWAPI_BYTEFORMATS

Function Documentation

_SHStrDupAA()

static HRESULT _SHStrDupAA ( LPCSTR  src, LPSTR *  dest  )

static

Definition at line 1917 of file string.c.

{
    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;
}

Referenced by StrRetToStrA().

_SHStrDupAToBSTR()

static HRESULT _SHStrDupAToBSTR ( LPCSTR  src, BSTR *  pBstrOut  )

static

Definition at line 1658 of file string.c.

{
    *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;
}

Referenced by StrRetToBSTR().

_SHStrDupAW()

static HRESULT _SHStrDupAW ( LPCWSTR  src, LPSTR *  dest  )

static

Definition at line 1984 of file string.c.

{
    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;
}

Referenced by StrRetToStrA().

ChrCmpIA()

BOOL WINAPI ChrCmpIA	(	WORD	ch1,
		WORD	ch2
	)

Definition at line 205 of file string.c.

{
  TRACE("(%d,%d)\n", ch1, ch2);
 
  return SHLWAPI_ChrCmpHelperA(ch1, ch2, NORM_IGNORECASE);
}

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

ChrCmpIW()

BOOL WINAPI ChrCmpIW	(	WCHAR	ch1,
		WCHAR	ch2
	)

Definition at line 217 of file string.c.

{
  return CompareStringW(GetThreadLocale(), NORM_IGNORECASE, &ch1, 1, &ch2, 1) - CSTR_EQUAL;
}

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

DoesStringRoundTripA()

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

Definition at line 2848 of file string.c.

{
  lstrcpynA(lpDst, lpSrcStr, iLen);
  return TRUE;
}

DoesStringRoundTripW()

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

Definition at line 2868 of file string.c.

{
    WCHAR szBuff[MAX_PATH];
 
    SHUnicodeToAnsi(lpSrcStr, lpDst, iLen);
    SHAnsiToUnicode(lpDst, szBuff, MAX_PATH);
    return !strcmpW(lpSrcStr, szBuff);
}

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.

{
  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;
}

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.

{
  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);
}

Referenced by StrFormatByteSizeW().

FormatInt()

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

static

Definition at line 96 of file string.c.

{
  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);
}

Referenced by StrFormatKBSizeW().

IsCharSpaceA()

BOOL WINAPI IsCharSpaceA

(

CHAR

c

)

Definition at line 2946 of file string.c.

{
    WORD CharType;
    return GetStringTypeA(GetSystemDefaultLCID(), CT_CTYPE1, &c, 1, &CharType) && (CharType & C1_SPACE);
}

IsCharSpaceW()

BOOL WINAPI IsCharSpaceW

(

WCHAR

wc

)

Definition at line 2964 of file string.c.

{
    WORD CharType;
 
    return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_SPACE);
}

SHAnsiToAnsi()

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

Definition at line 2810 of file string.c.

{
    LPSTR lpszRet;
 
    TRACE("(%s,%p,0x%08x)\n", debugstr_a(lpszSrc), lpszDst, iLen);
 
    lpszRet = StrCpyNXA(lpszDst, lpszSrc, iLen);
    return lpszRet - lpszDst + 1;
}

SHAnsiToUnicode()

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

Definition at line 2667 of file string.c.

{
  return SHAnsiToUnicodeCP(CP_ACP, lpSrcStr, lpDstStr, iLen);
}

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

SHAnsiToUnicodeCP()

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

Definition at line 2642 of file string.c.

{
  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;
}

Referenced by SHAnsiToUnicode().

SHLoadIndirectString()

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

Definition at line 2884 of file string.c.

{
    WCHAR *dllname = NULL;
    HMODULE hmod = NULL;
    HRESULT hr = E_FAIL;
#ifdef __REACTOS__
    WCHAR szExpanded[512];
#endif
 
    TRACE("(%s %p %08x %p)\n", debugstr_w(src), dst, dst_len, reserved);
 
    if(src[0] == '@')
    {
        WCHAR *index_str;
        int index;
 
#ifdef __REACTOS__
        if (wcschr(src, '%') != NULL)
        {
            ExpandEnvironmentStringsW(src, szExpanded, ARRAY_SIZE(szExpanded));
            src = szExpanded;
        }
#endif
        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);
  
#ifdef __REACTOS__
        hmod = LoadLibraryExW(dllname, NULL, LOAD_LIBRARY_AS_DATAFILE);
#else
        hmod = LoadLibraryW(dllname);
#endif
        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;
}

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.

{
  return SHLWAPI_ChrCmpHelperA(ch1, ch2, 0);
}

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.

{
  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;
}

Referenced by ChrCmpIA(), and SHLWAPI_ChrCmpA().

SHLWAPI_FormatSignificant()

static int SHLWAPI_FormatSignificant ( LPWSTR  lpszNum, int  dwDigits  )

inlinestatic

Definition at line 2060 of file string.c.

{
  /* Zero non significant digits, return remaining significant digits */
  while (*lpszNum)
  {
    lpszNum++;
    if (--dwDigits == 0)
    {
      while (*lpszNum)
        *lpszNum++ = '0';
      return 0;
    }
  }
  return dwDigits;
}

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 1295 of file string.c.

{
  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;
}

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 1122 of file string.c.

{
  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;
}

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.

{
  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;
}

Referenced by StrStrA(), and StrStrIA().

SHLWAPI_WriteReverseNum()

static LPWSTR SHLWAPI_WriteReverseNum ( LPWSTR  lpszOut, DWORD  dwNum  )

inlinestatic

Definition at line 2040 of file string.c.

{
  *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;
}

Referenced by SHLWAPI_WriteTimeClass().

SHLWAPI_WriteTimeClass()

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

static

Definition at line 2081 of file string.c.

{
  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;
}

Referenced by StrFromTimeIntervalW().

SHStrDupA()

HRESULT WINAPI SHStrDupA	(	LPCSTR	lpszStr,
		LPWSTR *	lppszDest
	)

Definition at line 1954 of file string.c.

{
  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;
}

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

SHStrDupW()

HRESULT WINAPI SHStrDupW	(	LPCWSTR	src,
		LPWSTR *	dest
	)

Definition at line 2012 of file string.c.

{
    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;
}

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

SHStripMneumonicA()

char WINAPI SHStripMneumonicA

(

LPCSTR

lpszStr

)

Definition at line 2575 of file string.c.

{
  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;
}

SHStripMneumonicW()

WCHAR WINAPI SHStripMneumonicW

(

LPCWSTR

lpszStr

)

Definition at line 2604 of file string.c.

{
  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;
}

SHTruncateString()

DWORD WINAPI SHTruncateString	(	LPSTR	lpStr,
		DWORD	size
	)

Definition at line 2544 of file string.c.

{
  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;
}

Referenced by SHUnicodeToAnsiCP().

SHUnicodeToAnsi()

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

Definition at line 2791 of file string.c.

{
    return SHUnicodeToAnsiCP(CP_ACP, lpSrcStr, lpDstStr, iLen);
}

Referenced by CheckEscapesA(), DoesStringRoundTripW(), CDefaultContextMenu::GetCommandString(), GetCommandStringA(), CDefView::InvokeContextMenuCommand(), MakeShellURLFromPathA(), CAutoComplete::OnNotify(), PathQualifyA(), PathResolveA(), SHBrowseForFolderA(), SHELL_IsVerb(), and SHInvokeCommandOnContextMenuInternal().

SHUnicodeToAnsiCP()

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

Definition at line 2692 of file string.c.

{
  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;
}

Referenced by SHUnicodeToAnsi().

SHUnicodeToUnicode()

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

Definition at line 2825 of file string.c.

{
    LPWSTR lpszRet;
 
    TRACE("(%s,%p,0x%08x)\n", debugstr_w(lpszSrc), lpszDst, iLen);
 
    lpszRet = StrCpyNXW(lpszDst, lpszSrc, iLen);
    return lpszRet - lpszDst + 1;
}

StrCatBuffA()

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

Definition at line 1419 of file string.c.

{
  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()

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

Definition at line 1444 of file string.c.

{
  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;
}

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.

{
  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;
}

StrCatW()

LPWSTR WINAPI StrCatW	(	LPWSTR	lpszStr,
		LPCWSTR	lpszSrc
	)

Definition at line 452 of file string.c.

{
  TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszSrc));
 
  if (lpszStr && lpszSrc)
    strcatW(lpszStr, lpszSrc);
  return lpszStr;
}

Referenced by CRegistryFolder::FormatValueData().

StrChrA()

LPSTR WINAPI StrChrA	(	LPCSTR	lpszStr,
		WORD	ch
	)

Definition at line 236 of file string.c.

{
  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;
}

StrChrIA()

LPSTR WINAPI StrChrIA	(	LPCSTR	lpszStr,
		WORD	ch
	)

Definition at line 282 of file string.c.

{
  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()

LPWSTR WINAPI StrChrIW	(	LPCWSTR	lpszStr,
		WCHAR	ch
	)

Definition at line 303 of file string.c.

{
  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()

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

Definition at line 324 of file string.c.

{
  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;
}

StrChrW()

LPWSTR WINAPI StrChrW	(	LPCWSTR	lpszStr,
		WCHAR	ch
	)

Definition at line 257 of file string.c.

{
  LPWSTR lpszRet = NULL;
 
  TRACE("(%s,%i)\n", debugstr_w(lpszStr), ch);
 
  if (lpszStr)
    lpszRet = strchrW(lpszStr, ch);
  return lpszRet;
}

StrCmpIW()

int WINAPI StrCmpIW	(	LPCWSTR	lpszStr,
		LPCWSTR	lpszComp
	)

Definition at line 353 of file string.c.

{
  TRACE("(%s,%s)\n", debugstr_w(lpszStr),debugstr_w(lpszComp));
  return CompareStringW(GetThreadLocale(), NORM_IGNORECASE, lpszStr, -1, lpszComp, -1) - CSTR_EQUAL;
}

Referenced by CMruBase::_IsEqual(), AssocFindByBuiltinExtension(), AssocFindByType(), Control_DoLaunch(), CAppDB::EnumerateRegistry(), HandleUninstallCommand(), CAutoComplete::Init(), MatchCmdOption(), SHExplorerParseCmdLine(), and test_assoc_one().

StrCmpLogicalW()

INT WINAPI StrCmpLogicalW	(	LPCWSTR	lpszStr,
		LPCWSTR	lpszComp
	)

Definition at line 2304 of file string.c.

{
  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;
}

Referenced by CompareFunc(), and SortListView().

StrCmpNA()

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

Definition at line 373 of file string.c.

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

StrCmpNIA()

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

Definition at line 404 of file string.c.

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

StrCmpNIW()

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

Definition at line 415 of file string.c.

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

StrCmpNW()

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

Definition at line 384 of file string.c.

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

StrCmpW()

int WINAPI StrCmpW	(	LPCWSTR	lpszStr,
		LPCWSTR	lpszComp
	)

Definition at line 434 of file string.c.

{
  TRACE("(%s,%s)\n", debugstr_w(lpszStr), debugstr_w(lpszComp));
  return CompareStringW(GetThreadLocale(), 0, lpszStr, -1, lpszComp, -1) - CSTR_EQUAL;
}

Referenced by CViewStatePropertyBag::_CanAccessUpgradeBag(), CMruBase::_IsEqual(), CFindFolder::CompareIDs(), Dde_OnExecute(), CViewStatePropertyBag::IsSameBag(), CDesktopUpgradePropertyBag::Read(), test_PathCombineW(), and test_StrCpyW().

StrCpyNW()

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

Definition at line 536 of file string.c.

{
  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;
}

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

StrCpyNXA()

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

Definition at line 2257 of file string.c.

{
  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;
}

Referenced by SHAnsiToAnsi().

StrCpyNXW()

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

Definition at line 2276 of file string.c.

{
  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;
}

Referenced by SHUnicodeToUnicode().

StrCpyW()

LPWSTR WINAPI StrCpyW	(	LPWSTR	lpszStr,
		LPCWSTR	lpszSrc
	)

Definition at line 514 of file string.c.

{
  TRACE("(%p,%s)\n", lpszStr, debugstr_w(lpszSrc));
 
  if (lpszStr && lpszSrc)
    strcpyW(lpszStr, lpszSrc);
  return lpszStr;
}

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

StrCSpnA()

int WINAPI StrCSpnA	(	LPCSTR	lpszStr,
		LPCSTR	lpszMatch
	)

Definition at line 1189 of file string.c.

{
  TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
 
  return SHLWAPI_StrSpnHelperA(lpszStr, lpszMatch, StrChrA, TRUE);
}

StrCSpnIA()

int WINAPI StrCSpnIA	(	LPCSTR	lpszStr,
		LPCSTR	lpszMatch
	)

Definition at line 1221 of file string.c.

{
  TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
 
  return SHLWAPI_StrSpnHelperA(lpszStr, lpszMatch, StrChrIA, TRUE);
}

StrCSpnIW()

int WINAPI StrCSpnIW	(	LPCWSTR	lpszStr,
		LPCWSTR	lpszMatch
	)

Definition at line 1233 of file string.c.

{
  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;
}

StrCSpnW()

int WINAPI StrCSpnW	(	LPCWSTR	lpszStr,
		LPCWSTR	lpszMatch
	)

Definition at line 1201 of file string.c.

{
    if (!lpszStr || !lpszMatch) return 0;
    return strcspnW( lpszStr, lpszMatch );
}

StrDupA()

LPSTR WINAPI StrDupA

(

LPCSTR

lpszStr

)

Definition at line 1064 of file string.c.

{
  int iLen;
  LPSTR lpszRet;
 
  TRACE("(%s)\n",debugstr_a(lpszStr));
 
#ifdef __REACTOS__
  if (!lpszStr)
    return NULL;
#endif
  iLen = lpszStr ? strlen(lpszStr) + 1 : 1;
  lpszRet = LocalAlloc(LMEM_FIXED, iLen);
 
  if (lpszRet)
  {
    if (lpszStr)
      memcpy(lpszRet, lpszStr, iLen);
    else
      *lpszRet = '\0';
  }
  return lpszRet;
}

Referenced by TEST_StrDupA(), and test_StrDupA().

StrDupW()

LPWSTR WINAPI StrDupW

(

LPCWSTR

lpszStr

)

Definition at line 1093 of file string.c.

{
  int iLen;
  LPWSTR lpszRet;
 
  TRACE("(%s)\n",debugstr_w(lpszStr));
 
#ifdef __REACTOS__
  if (!lpszStr)
    return NULL;
#endif
  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;
}

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(), set_file_name(), SHELL_execute(), SHLoadIndirectString(), SHParseDisplayName(), TEST_StrDupW(), and test_StrXXX_overflows().

StrFormatByteSize64A()

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

Definition at line 2496 of file string.c.

{
  WCHAR wszBuff[32];
 
  StrFormatByteSizeW(llBytes, wszBuff, sizeof(wszBuff)/sizeof(WCHAR));
 
  if (lpszDest)
    WideCharToMultiByte(CP_ACP, 0, wszBuff, -1, lpszDest, cchMax, 0, 0);
  return lpszDest;
}

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

StrFormatByteSizeA()

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

Definition at line 2524 of file string.c.

{
  TRACE("(%d,%p,%d)\n", dwBytes, lpszDest, cchMax);
 
  return StrFormatByteSize64A(dwBytes, lpszDest, cchMax);
}

StrFormatByteSizeW()

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

Definition at line 2388 of file string.c.

{
#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[] =
  {
#ifdef __REACTOS__
    { 10*KB, 10.24, 100.0, 2, IDS_KB_FORMAT }, /* 10 KB */
    { 100*KB, 102.4, 10.0, 1, IDS_KB_FORMAT }, /* 100 KB */
    { 1000*KB, 1024.0, 1.0, 0, IDS_KB_FORMAT }, /* 1000 KB */
    { 10*MB, 10485.76, 100.0, 2, IDS_MB_FORMAT }, /* 10 MB */
    { 100*MB, 104857.6, 10.0, 1, IDS_MB_FORMAT }, /* 100 MB */
    { 1000*MB, 1048576.0, 1.0, 0, IDS_MB_FORMAT }, /* 1000 MB */
    { 10*GB, 10737418.24, 100.0, 2, IDS_GB_FORMAT }, /* 10 GB */
    { 100*GB, 107374182.4, 10.0, 1, IDS_GB_FORMAT }, /* 100 GB */
    { 1000*GB, 1073741824.0, 1.0, 0, IDS_GB_FORMAT }, /* 1000 GB */
    { 10*TB, 10485.76, 100.0, 2, IDS_TB_FORMAT }, /* 10 TB */
    { 100*TB, 104857.6, 10.0, 1, IDS_TB_FORMAT }, /* 100 TB */
    { 1000*TB, 1048576.0, 1.0, 0, IDS_TB_FORMAT }, /* 1000 TB */
    { 10*PB, 10737418.24, 100.00, 2, IDS_PB_FORMAT }, /* 10 PB */
    { 100*PB, 107374182.4, 10.00, 1, IDS_PB_FORMAT }, /* 100 PB */
    { 1000*PB, 1073741824.0, 1.00, 0, IDS_PB_FORMAT }, /* 1000 PB */
    { 0, 10995116277.76, 100.00, 2, IDS_EB_FORMAT } /* EB's, catch all */
#else
    { 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 */
#endif
  };
#ifdef __REACTOS__
  WCHAR szBuff[40], wszFormat[40];
#else
  WCHAR wszAdd[] = {' ','?','B',0};
#endif
  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;
 
#ifdef __REACTOS__
  if (!FormatDouble(dBytes, bfFormats[i].nDecimals, szBuff, ARRAYSIZE(szBuff)))
    return NULL;
  LoadStringW(shlwapi_hInstance, bfFormats[i].nFormatID, wszFormat, ARRAYSIZE(wszFormat));
  snprintfW(lpszDest, cchMax, wszFormat, szBuff);
#else
  if (!FormatDouble(dBytes, bfFormats[i].nDecimals, lpszDest, cchMax))
    return NULL;
  wszAdd[1] = bfFormats[i].wPrefix;
  StrCatBuffW(lpszDest, wszAdd, cchMax);
#endif
  return lpszDest;
}

Referenced by AddUserProfile(), CAvailableApplicationInfo::CAvailableApplicationInfo(), dialog_vcl_add_drives(), FormatFileSizeWithBytes(), CZipFolder::GetDetailsOf(), CDrvDefExt::InitGeneralPage(), InitializeFormatDriveDlg(), InitializeRecycleBinDlg(), InsertDefaultClusterSizeForFs(), 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 1735 of file string.c.

{
  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;
}

Referenced by CFontExt::GetDetailsOf().

StrFormatKBSizeW()

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

Definition at line 1751 of file string.c.

{
  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;
}

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

StrFromTimeIntervalA()

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

Definition at line 2125 of file string.c.

{
  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;
}

Referenced by test_StrFromTimeIntervalA().

StrFromTimeIntervalW()

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

Definition at line 2147 of file string.c.

{
  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;
}

Referenced by dialog_proc(), and StrFromTimeIntervalA().

StrIsIntlEqualA()

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

Definition at line 2204 of file string.c.

{
  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()

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

Definition at line 2226 of file string.c.

{
  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);
}

StrNCatA()

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

Definition at line 1786 of file string.c.

{
  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()

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

Definition at line 1807 of file string.c.

{
  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;
}

StrPBrkA()

LPSTR WINAPI StrPBrkA	(	LPCSTR	lpszStr,
		LPCSTR	lpszMatch
	)

Definition at line 1263 of file string.c.

{
  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()

LPWSTR WINAPI StrPBrkW	(	LPCWSTR	lpszStr,
		LPCWSTR	lpszMatch
	)

Definition at line 1284 of file string.c.

{
    if (!lpszStr || !lpszMatch) return NULL;
    return strpbrkW( lpszStr, lpszMatch );
}

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

StrRChrA()

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

Definition at line 1335 of file string.c.

{
  TRACE("(%s,%s,%x)\n", debugstr_a(lpszStr), debugstr_a(lpszEnd), ch);
 
  return SHLWAPI_StrRChrHelperA(lpszStr, lpszEnd, ch, SHLWAPI_ChrCmpA);
}

StrRChrIA()

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

Definition at line 1376 of file string.c.

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

StrRChrIW()

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

Definition at line 1388 of file string.c.

{
    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;
}

StrRChrW()

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

Definition at line 1347 of file string.c.

{
    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;
}

StrRetToBSTR()

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

Definition at line 1694 of file string.c.

{
  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;
}

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 1481 of file string.c.

{
    /* 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 E_NOTIMPL;
    }
    return S_OK;
}

StrRetToBufW()

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

Definition at line 1530 of file string.c.

{
    TRACE("dest=%p len=0x%x strret=%p pidl=%p\n", dest, len, src, pidl);
 
    if (!dest || !len)
        return E_FAIL;
 
    if (!src)
    {
        WARN("Invalid lpStrRet would crash under Win32!\n");
        if (dest)
            *dest = '\0';
        return E_FAIL;
    }
 
    *dest = '\0';
 
    switch (src->uType) {
    case STRRET_WSTR: {
        size_t dst_len;
        if (!src->u.pOleStr)
            return E_FAIL;
        dst_len = strlenW(src->u.pOleStr);
        memcpy(dest, src->u.pOleStr, min(dst_len, len-1) * sizeof(WCHAR));
        dest[min(dst_len, len-1)] = 0;
        CoTaskMemFree(src->u.pOleStr);
        if (len <= dst_len)
        {
            dest[0] = 0;
            return E_NOT_SUFFICIENT_BUFFER;
        }
        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 E_NOTIMPL;
    }
 
    return S_OK;
}

Referenced by CFSDropTarget::_CopyItems(), CAddressEditBox::AddComboBoxItem(), COMDLG32_GetDisplayNameOf(), COMDLG32_UpdateCurrentDir(), CMyDocsDropHandler::Drop(), CDeskLinkDropHandler::Drop(), FindExpectedFile(), GetCommandString(), GetDisplayName(), CCommonFolder< TSelf, TItemId, TExtractIcon >::GetDisplayNameOf(), GetFullName(), IEGetNameAndFlagsEx(), ok_displayname_(), SHELL32_CompareDetails(), Shell_DisplayNameOf(), SHGetPathCchFromIDListW(), SHGetRealIDL(), 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 1600 of file string.c.

{
  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()

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

Definition at line 1631 of file string.c.

{
  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;
}

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

StrRStrIA()

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

Definition at line 627 of file string.c.

{
  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()

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

Definition at line 667 of file string.c.

{
  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;
}

StrSpnA()

int WINAPI StrSpnA	(	LPCSTR	lpszStr,
		LPCSTR	lpszMatch
	)

Definition at line 1157 of file string.c.

{
  TRACE("(%s,%s)\n",debugstr_a(lpszStr), debugstr_a(lpszMatch));
 
  return SHLWAPI_StrSpnHelperA(lpszStr, lpszMatch, StrChrA, FALSE);
}

StrSpnW()

int WINAPI StrSpnW	(	LPCWSTR	lpszStr,
		LPCWSTR	lpszMatch
	)

Definition at line 1169 of file string.c.

{
    if (!lpszStr || !lpszMatch) return 0;
    return strspnW( lpszStr, lpszMatch );
}

StrStrA()

LPSTR WINAPI StrStrA	(	LPCSTR	lpszStr,
		LPCSTR	lpszSearch
	)

Definition at line 594 of file string.c.

{
  TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
 
  return SHLWAPI_StrStrHelperA(lpszStr, lpszSearch, StrCmpNA);
}

StrStrIA()

LPSTR WINAPI StrStrIA	(	LPCSTR	lpszStr,
		LPCSTR	lpszSearch
	)

Definition at line 708 of file string.c.

{
  TRACE("(%s,%s)\n", debugstr_a(lpszStr), debugstr_a(lpszSearch));
 
  return SHLWAPI_StrStrHelperA(lpszStr, lpszSearch, StrCmpNIA);
}

StrStrIW()

LPWSTR WINAPI StrStrIW	(	LPCWSTR	lpszStr,
		LPCWSTR	lpszSearch
	)

Definition at line 720 of file string.c.

{
  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;
}

StrStrNIW()

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

Definition at line 790 of file string.c.

{
    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;
}

StrStrNW()

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

Definition at line 755 of file string.c.

{
    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;
}

StrStrW()

LPWSTR WINAPI StrStrW	(	LPCWSTR	lpszStr,
		LPCWSTR	lpszSearch
	)

Definition at line 606 of file string.c.

{
    TRACE("(%s, %s)\n", debugstr_w(lpszStr), debugstr_w(lpszSearch));
 
    if (!lpszStr || !lpszSearch || !*lpszSearch) return NULL;
    return strstrW( lpszStr, lpszSearch );
}

StrToInt64ExA()

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

Definition at line 903 of file string.c.

{
  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;
}

Referenced by StrToIntExA().

StrToInt64ExW()

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

Definition at line 987 of file string.c.

{
  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;
}

Referenced by set_content_length(), and StrToIntExW().

StrToIntA()

int WINAPI StrToIntA

(

LPCSTR

lpszStr

)

Definition at line 826 of file string.c.

{
  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;
}

StrToIntExA()

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

Definition at line 886 of file string.c.

{
  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;
}

Referenced by StrToIntA(), and test_StrToIntExA().

StrToIntExW()

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

Definition at line 970 of file string.c.

{
  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;
}

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.

{
  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;
}

StrTrimA()

BOOL WINAPI StrTrimA	(	LPSTR	lpszStr,
		LPCSTR	lpszTrim
	)

Definition at line 1836 of file string.c.

{
  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()

BOOL WINAPI StrTrimW	(	LPWSTR	lpszStr,
		LPCWSTR	lpszTrim
	)

Definition at line 1877 of file string.c.

{
  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;
}

Referenced by BrFolder_OnOK(), 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().