string.c File Reference

#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	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 *)
DWORD WINAPI	SHTruncateString (LPSTR lpStr, DWORD size)
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)
LPWSTR WINAPI	StrCatW (LPWSTR lpszStr, LPCWSTR lpszSrc)
LPWSTR WINAPI	StrCpyW (LPWSTR lpszStr, LPCWSTR lpszSrc)
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)
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)
LPWSTR WINAPI	StrFormatByteSizeW (LONGLONG llBytes, LPWSTR lpszDest, UINT cchMax)
HRESULT WINAPI	StrFormatByteSizeEx (LONGLONG llBytes, SFBS_FLAGS flags, LPWSTR lpszDest, UINT cchMax)
LPSTR WINAPI	StrFormatByteSize64A (LONGLONG llBytes, LPSTR lpszDest, UINT cchMax)
LPSTR WINAPI	StrFormatByteSizeA (DWORD dwBytes, LPSTR lpszDest, UINT cchMax)
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)
BOOL WINAPI	DoesStringRoundTripA (LPCSTR lpSrcStr, LPSTR lpDst, INT iLen)
BOOL WINAPI	DoesStringRoundTripW (LPCWSTR lpSrcStr, LPSTR lpDst, INT iLen)

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

NO_SHLWAPI_STREAM

#define NO_SHLWAPI_STREAM

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

{
    *pBstrOut = NULL;
 
    if (src)
    {
        INT len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
        WCHAR *szTemp = malloc(len * sizeof(WCHAR));
 
        if (szTemp)
        {
            MultiByteToWideChar(CP_ACP, 0, src, -1, szTemp, len);
            *pBstrOut = SysAllocString(szTemp);
            free(szTemp);
 
            if (*pBstrOut)
                return S_OK;
        }
    }
    return E_OUTOFMEMORY;
}

Referenced by StrRetToBSTR().

_SHStrDupAW()

static HRESULT _SHStrDupAW ( LPCWSTR  src, LPSTR *  dest  )

static

Definition at line 619 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().

DoesStringRoundTripA()

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

Definition at line 1278 of file string.c.

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

DoesStringRoundTripW()

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

Definition at line 1298 of file string.c.

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

FillNumberFmt()

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

static

Definition at line 51 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, ARRAY_SIZE(grouping));
  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 124 of file string.c.

{
  static const WCHAR flfmt[] = {'%','f',0};
  WCHAR buf[64];
  NUMBERFMTW fmt;
  WCHAR decimal[8], thousand[8];
  
  swprintf(buf, 64, flfmt, value);
 
  FillNumberFmt(&fmt, decimal, ARRAY_SIZE(decimal), thousand, ARRAY_SIZE(thousand));
  fmt.NumDigits = decimals;
  return GetNumberFormatW(LOCALE_USER_DEFAULT, 0, buf, &fmt, pszBuf, cchBuf);
}

Referenced by StrFormatByteSizeEx().

FormatInt()

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

static

Definition at line 92 of file string.c.

{
  NUMBERFMTW fmt;
  WCHAR decimal[8], thousand[8];
  WCHAR buf[24];
  WCHAR *c;
  BOOL neg = (qdwValue < 0);
 
  FillNumberFmt(&fmt, decimal, ARRAY_SIZE(decimal), thousand, ARRAY_SIZE(thousand));
 
  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().

SHAnsiToUnicode()

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

Definition at line 1136 of file string.c.

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

Referenced by DoesStringRoundTripW().

SHAnsiToUnicodeCP()

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

Definition at line 1111 of file string.c.

{
  DWORD dwRet;
 
  dwRet = MultiByteToWideChar(dwCp, 0, lpSrcStr, -1, lpDstStr, iLen);
  TRACE("%s->%s,ret=%ld\n", debugstr_a(lpSrcStr), debugstr_w(lpDstStr), dwRet);
  return dwRet;
}

Referenced by SHAnsiToUnicode().

SHLWAPI_FormatSignificant()

static int SHLWAPI_FormatSignificant ( LPWSTR  lpszNum, int  dwDigits  )

inlinestatic

Definition at line 695 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_WriteReverseNum()

static LPWSTR SHLWAPI_WriteReverseNum ( LPWSTR  lpszOut, DWORD  dwNum  )

inlinestatic

Definition at line 675 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 716 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);
  lstrcatW(lpszOut, szOut);
  return iDigits;
}

Referenced by StrFromTimeIntervalW().

SHStrDupA()

HRESULT WINAPI SHStrDupA	(	LPCSTR	lpszStr,
		LPWSTR *	lppszDest
	)

Definition at line 589 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().

SHStrDupW()

HRESULT WINAPI SHStrDupW	(	LPCWSTR	src,
		LPWSTR *	dest
	)

Definition at line 647 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 StrRetToStrW().

SHStripMneumonicA()

char WINAPI SHStripMneumonicA

(

LPCSTR

lpszStr

)

Definition at line 1044 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 1073 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, (lstrlenW(lpszTmp) + 1) * sizeof(WCHAR) );
    }
  }
 
  return ch;
}

SHTruncateString()

DWORD WINAPI SHTruncateString	(	LPSTR	lpStr,
		DWORD	size
	)

SHUnicodeToAnsi()

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

Definition at line 1260 of file string.c.

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

Referenced by DoesStringRoundTripW().

SHUnicodeToAnsiCP()

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

Definition at line 1161 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 = lstrlenW(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 = malloc(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);
      }
      free(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 = malloc(reqLen);
      if (mem)
      {
        WideCharToMultiByte(CodePage, 0, lpSrcStr, len, mem, reqLen, NULL, NULL);
 
        reqLen = SHTruncateString(mem, dstlen -1);
        reqLen++;
 
        lstrcpynA(lpDstStr, mem, reqLen);
        free(mem);
        lpDstStr[reqLen-1] = '\0';
      }
    }
  }
  return reqLen;
}

Referenced by SHUnicodeToAnsi().

StrCatW()

LPWSTR WINAPI StrCatW	(	LPWSTR	lpszStr,
		LPCWSTR	lpszSrc
	)

Definition at line 151 of file string.c.

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

Referenced by CRegistryFolder::FormatValueData().

StrCpyW()

LPWSTR WINAPI StrCpyW	(	LPWSTR	lpszStr,
		LPCWSTR	lpszSrc
	)

Definition at line 173 of file string.c.

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

Referenced by _ShowContextMenu(), and test_StrCpyW().

StrFormatByteSize64A()

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

Definition at line 997 of file string.c.

{
  WCHAR wszBuff[32];
 
  StrFormatByteSizeW(llBytes, wszBuff, ARRAY_SIZE(wszBuff));
 
  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 1025 of file string.c.

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

Referenced by CCabFolder::GetItemDetails().

StrFormatByteSizeEx()

HRESULT WINAPI StrFormatByteSizeEx	(	LONGLONG	llBytes,
		SFBS_FLAGS	flags,
		LPWSTR	lpszDest,
		UINT	cchMax
	)

Definition at line 877 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,%d,%p,%d)\n", wine_dbgstr_longlong(llBytes), flags, lpszDest, cchMax);
 
  if (!cchMax)
    return E_INVALIDARG;
 
  if (llBytes < 1024)  /* 1K */
  {
    WCHAR wszBytesFormat[64];
    LoadStringW(shlwapi_hInstance, IDS_BYTES_FORMAT, wszBytesFormat, 64);
    swprintf(lpszDest, cchMax, wszBytesFormat, (int)llBytes);
    return S_OK;
  }
 
  /* 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 < ARRAY_SIZE(bfFormats) - 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;
 
  switch(flags)
  {
  case SFBS_FLAGS_ROUND_TO_NEAREST_DISPLAYED_DIGIT:
      dBytes = round(dBytes / bfFormats[i].dDivisor) / bfFormats[i].dNormaliser;
      break;
  case SFBS_FLAGS_TRUNCATE_UNDISPLAYED_DECIMAL_DIGITS:
      dBytes = floor(dBytes / bfFormats[i].dDivisor) / bfFormats[i].dNormaliser;
      break;
  default:
      return E_INVALIDARG;
  }
 
#ifdef __REACTOS__
  if (!FormatDouble(dBytes, bfFormats[i].nDecimals, szBuff, ARRAYSIZE(szBuff)))
    return E_FAIL;
  LoadStringW(shlwapi_hInstance, bfFormats[i].nFormatID, wszFormat, ARRAYSIZE(wszFormat));
  snprintfW(lpszDest, cchMax, wszFormat, szBuff);
#else
  if (!FormatDouble(dBytes, bfFormats[i].nDecimals, lpszDest, cchMax))
    return E_FAIL;
 
  wszAdd[1] = bfFormats[i].wPrefix;
  StrCatBuffW(lpszDest, wszAdd, cchMax);
#endif
  return S_OK;
}

Referenced by StrFormatByteSizeW().

StrFormatByteSizeW()

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

Definition at line 854 of file string.c.

{
  HRESULT hr;
 
  TRACE("(0x%s,%p,%d)\n", wine_dbgstr_longlong(llBytes), lpszDest, cchMax);
 
  if (!lpszDest || !cchMax)
    return lpszDest;
 
  hr = StrFormatByteSizeEx(llBytes, SFBS_FLAGS_TRUNCATE_UNDISPLAYED_DECIMAL_DIGITS,
                           lpszDest, cchMax);
 
  if (FAILED(hr))
    return NULL;
 
  return lpszDest;
}

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

StrFormatKBSizeA()

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

Definition at line 459 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 475 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(), CFSFolder::FormatSize(), and StrFormatKBSizeA().

StrFromTimeIntervalA()

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

Definition at line 760 of file string.c.

{
  INT iRet = 0;
 
  TRACE("(%p,%d,%ld,%d)\n", lpszStr, cchMax, dwMS, iDigits);
 
  if (lpszStr && cchMax)
  {
    WCHAR szBuff[128];
    StrFromTimeIntervalW(szBuff, ARRAY_SIZE(szBuff), 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 782 of file string.c.

{
  INT iRet = 0;
 
  TRACE("(%p,%d,%ld,%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 = lstrlenW(lpszStr);
  }
  return iRet;
}

Referenced by dialog_proc(), and StrFromTimeIntervalA().

StrNCatA()

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

Definition at line 510 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 531 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 + lstrlenW(lpszStr), lpszCat, cchMax);
  return lpszRet;
}

StrRetToBSTR()

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

Definition at line 418 of file string.c.

{
  HRESULT hRet = E_FAIL;
 
  switch (lpStrRet->uType)
  {
  case STRRET_WSTR:
    *pBstrOut = SysAllocString(lpStrRet->pOleStr);
    if (*pBstrOut)
      hRet = S_OK;
    CoTaskMemFree(lpStrRet->pOleStr);
    break;
 
  case STRRET_CSTR:
    hRet = _SHStrDupAToBSTR(lpStrRet->cStr, pBstrOut);
    break;
 
  case STRRET_OFFSET:
    hRet = _SHStrDupAToBSTR(((LPCSTR)&pidl->mkid) + lpStrRet->uOffset, pBstrOut);
    break;
 
  default:
    *pBstrOut = NULL;
  }
 
  return hRet;
}

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

StrRetToBufA()

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

Definition at line 199 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->pOleStr, -1, dest, len, NULL, NULL);
        CoTaskMemFree(src->pOleStr);
        break;
 
      case STRRET_CSTR:
            lstrcpynA(dest, src->cStr, len);
        break;
 
      case STRRET_OFFSET:
            lstrcpynA(dest, ((LPCSTR)&pidl->mkid)+src->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 248 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->pOleStr)
            return E_FAIL;
        dst_len = lstrlenW(src->pOleStr);
        memcpy(dest, src->pOleStr, min(dst_len, len-1) * sizeof(WCHAR));
        dest[min(dst_len, len-1)] = 0;
        CoTaskMemFree(src->pOleStr);
        if (len <= dst_len)
        {
            dest[0] = 0;
            return E_NOT_SUFFICIENT_BUFFER;
        }
        break;
    }
 
    case STRRET_CSTR:
        if (!MultiByteToWideChar( CP_ACP, 0, src->cStr, -1, dest, len ))
            dest[len-1] = 0;
        break;
 
    case STRRET_OFFSET:
        if (pidl)
    {
            if (!MultiByteToWideChar( CP_ACP, 0, ((LPCSTR)&pidl->mkid)+src->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(), CISFBand::AddToolbarButtons(), COMDLG32_GetDisplayNameOf(), COMDLG32_UpdateCurrentDir(), DisplayNameOfW(), CMyDocsDropHandler::Drop(), CDeskLinkDropHandler::Drop(), FindExpectedFile(), GetCommandString(), GetDisplayName(), GetDisplayNameOf(), CCommonFolder< TSelf, TItemId, TExtractIcon >::GetDisplayNameOf(), GetFullName(), IEGetNameAndFlagsEx(), ok_displayname_(), SHELL32_CompareDetails(), 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 318 of file string.c.

{
  HRESULT hRet = E_FAIL;
 
  switch (lpStrRet->uType)
  {
  case STRRET_WSTR:
    hRet = _SHStrDupAW(lpStrRet->pOleStr, ppszName);
    CoTaskMemFree(lpStrRet->pOleStr);
    break;
 
  case STRRET_CSTR:
    hRet = _SHStrDupAA(lpStrRet->cStr, ppszName);
    break;
 
  case STRRET_OFFSET:
    hRet = _SHStrDupAA(((LPCSTR)&pidl->mkid) + lpStrRet->uOffset, ppszName);
    break;
 
  default:
    *ppszName = NULL;
  }
 
  return hRet;
}

StrRetToStrW()

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

Definition at line 349 of file string.c.

{
  HRESULT hRet = E_FAIL;
 
  switch (lpStrRet->uType)
  {
  case STRRET_WSTR:
#ifdef __REACTOS__
    hRet = lpStrRet->pOleStr ? S_OK : E_FAIL;
    *ppszName = lpStrRet->pOleStr;
    lpStrRet->pOleStr = NULL; /* Windows does this, presumably in case someone calls SHFree */
#else
    hRet = SHStrDupW(lpStrRet->pOleStr, ppszName);
    CoTaskMemFree(lpStrRet->pOleStr);
#endif
    break;
 
  case STRRET_CSTR:
    hRet = SHStrDupA(lpStrRet->cStr, ppszName);
    break;
 
  case STRRET_OFFSET:
    hRet = SHStrDupA(((LPCSTR)&pidl->mkid) + lpStrRet->uOffset, ppszName);
    break;
 
  default:
    *ppszName = NULL;
  }
 
  return hRet;
}

Referenced by CEnumMergedFolder::Begin(), GetDetailsOf(), GetDisplayname(), CACListISF::GetDisplayName(), CSendToMenu::LoadAllItems(), CShellBrowser::OnAddToFavorites(), SHELL32_GetFSItemAttributes(), SHELL_DisplayNameOf(), SHGetNameFromIDList(), and TEST_StrRet().

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 StrFormatByteSizeEx().