path.c File Reference

#include "config.h"
#include "wine/port.h"
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include "wine/unicode.h"
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winreg.h"
#include "winternl.h"
#include "shlwapi.h"
#include "wine/debug.h"

Include dependency graph for path.c:

Go to the source code of this file.

Classes
struct	envvars_map

Macros
#define	NO_SHLWAPI_STREAM
#define	GET_FUNC(func, module, name, fail)
#define	szWebLen   (sizeof(szWeb)/sizeof(WCHAR))
#define	szWebMuiLen   ((sizeof(szWebMui)+1)/sizeof(WCHAR))
#define	PATH_CHAR_CLASS_LETTER   0x00000001
#define	PATH_CHAR_CLASS_ASTERIX   0x00000002
#define	PATH_CHAR_CLASS_DOT   0x00000004
#define	PATH_CHAR_CLASS_BACKSLASH   0x00000008
#define	PATH_CHAR_CLASS_COLON   0x00000010
#define	PATH_CHAR_CLASS_SEMICOLON   0x00000020
#define	PATH_CHAR_CLASS_COMMA   0x00000040
#define	PATH_CHAR_CLASS_SPACE   0x00000080
#define	PATH_CHAR_CLASS_OTHER_VALID   0x00000100
#define	PATH_CHAR_CLASS_DOUBLEQUOTE   0x00000200
#define	PATH_CHAR_CLASS_INVALID   0x00000000
#define	PATH_CHAR_CLASS_ANY   0xffffffff

Typedefs
typedef BOOL(WINAPI *	fnpIsNetDrive) (int)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)
HRESULT WINAPI	SHGetWebFolderFilePathW (LPCWSTR, LPWSTR, DWORD)
static WCHAR *	heap_strdupAtoW (LPCSTR str)
BOOL WINAPI	PathAppendA (LPSTR lpszPath, LPCSTR lpszAppend)
BOOL WINAPI	PathAppendW (LPWSTR lpszPath, LPCWSTR lpszAppend)
LPSTR WINAPI	PathCombineA (LPSTR lpszDest, LPCSTR lpszDir, LPCSTR lpszFile)
LPWSTR WINAPI	PathCombineW (LPWSTR lpszDest, LPCWSTR lpszDir, LPCWSTR lpszFile)
LPSTR WINAPI	PathAddBackslashA (LPSTR lpszPath)
LPWSTR WINAPI	PathAddBackslashW (LPWSTR lpszPath)
LPSTR WINAPI	PathBuildRootA (LPSTR lpszPath, int drive)
LPWSTR WINAPI	PathBuildRootW (LPWSTR lpszPath, int drive)
LPSTR WINAPI	PathFindFileNameA (LPCSTR lpszPath)
LPWSTR WINAPI	PathFindFileNameW (LPCWSTR lpszPath)
LPSTR WINAPI	PathFindExtensionA (LPCSTR lpszPath)
LPWSTR WINAPI	PathFindExtensionW (LPCWSTR lpszPath)
LPSTR WINAPI	PathGetArgsA (LPCSTR lpszPath)
LPWSTR WINAPI	PathGetArgsW (LPCWSTR lpszPath)
int WINAPI	PathGetDriveNumberA (LPCSTR lpszPath)
int WINAPI	PathGetDriveNumberW (const WCHAR *path)
BOOL WINAPI	PathRemoveFileSpecA (LPSTR lpszPath)
BOOL WINAPI	PathRemoveFileSpecW (LPWSTR lpszPath)
void WINAPI	PathStripPathA (LPSTR lpszPath)
void WINAPI	PathStripPathW (LPWSTR lpszPath)
BOOL WINAPI	PathStripToRootA (LPSTR lpszPath)
BOOL WINAPI	PathStripToRootW (LPWSTR lpszPath)
void WINAPI	PathRemoveArgsA (LPSTR lpszPath)
void WINAPI	PathRemoveArgsW (LPWSTR lpszPath)
void WINAPI	PathRemoveExtensionA (LPSTR lpszPath)
void WINAPI	PathRemoveExtensionW (LPWSTR lpszPath)
LPSTR WINAPI	PathRemoveBackslashA (LPSTR lpszPath)
LPWSTR WINAPI	PathRemoveBackslashW (LPWSTR lpszPath)
void WINAPI	PathRemoveBlanksA (LPSTR pszPath)
void WINAPI	PathRemoveBlanksW (LPWSTR pszPath)
VOID WINAPI	PathQuoteSpacesA (LPSTR lpszPath)
VOID WINAPI	PathQuoteSpacesW (LPWSTR lpszPath)
VOID WINAPI	PathUnquoteSpacesA (LPSTR lpszPath)
VOID WINAPI	PathUnquoteSpacesW (LPWSTR lpszPath)
int WINAPI	PathParseIconLocationA (LPSTR lpszPath)
int WINAPI	PathParseIconLocationW (LPWSTR lpszPath)
BOOL WINAPI	PathFileExistsDefExtW (LPWSTR lpszPath, DWORD dwWhich)
BOOL WINAPI	PathFileExistsDefExtA (LPSTR lpszPath, DWORD dwWhich)
static BOOL	SHLWAPI_PathFindInOtherDirs (LPWSTR lpszFile, DWORD dwWhich)
BOOL WINAPI	PathFindOnPathExA (LPSTR lpszFile, LPCSTR *lppszOtherDirs, DWORD dwWhich)
BOOL WINAPI	PathFindOnPathExW (LPWSTR lpszFile, LPCWSTR *lppszOtherDirs, DWORD dwWhich)
BOOL WINAPI	PathFindOnPathA (LPSTR lpszFile, LPCSTR *lppszOtherDirs)
BOOL WINAPI	PathFindOnPathW (LPWSTR lpszFile, LPCWSTR *lppszOtherDirs)
BOOL WINAPI	PathCompactPathExA (LPSTR lpszDest, LPCSTR lpszPath, UINT cchMax, DWORD dwFlags)
BOOL WINAPI	PathCompactPathExW (LPWSTR lpszDest, LPCWSTR lpszPath, UINT cchMax, DWORD dwFlags)
BOOL WINAPI	PathIsRelativeA (LPCSTR lpszPath)
BOOL WINAPI	PathIsRelativeW (LPCWSTR lpszPath)
BOOL WINAPI	PathIsRootA (LPCSTR lpszPath)
BOOL WINAPI	PathIsRootW (LPCWSTR lpszPath)
BOOL WINAPI	PathIsDirectoryA (LPCSTR lpszPath)
BOOL WINAPI	PathIsDirectoryW (LPCWSTR lpszPath)
BOOL WINAPI	PathFileExistsA (LPCSTR lpszPath)
BOOL WINAPI	PathFileExistsW (LPCWSTR lpszPath)
BOOL WINAPI	PathFileExistsAndAttributesA (LPCSTR lpszPath, DWORD *dwAttr)
BOOL WINAPI	PathFileExistsAndAttributesW (LPCWSTR lpszPath, DWORD *dwAttr)
static BOOL	PathMatchSingleMaskA (LPCSTR name, LPCSTR mask)
static BOOL	PathMatchSingleMaskW (LPCWSTR name, LPCWSTR mask)
BOOL WINAPI	PathMatchSpecA (LPCSTR lpszPath, LPCSTR lpszMask)
BOOL WINAPI	PathMatchSpecW (LPCWSTR lpszPath, LPCWSTR lpszMask)
BOOL WINAPI	PathIsSameRootA (LPCSTR lpszPath1, LPCSTR lpszPath2)
BOOL WINAPI	PathIsSameRootW (LPCWSTR lpszPath1, LPCWSTR lpszPath2)
BOOL WINAPI	PathIsContentTypeA (LPCSTR lpszPath, LPCSTR lpszContentType)
BOOL WINAPI	PathIsContentTypeW (LPCWSTR lpszPath, LPCWSTR lpszContentType)
BOOL WINAPI	PathIsFileSpecA (LPCSTR lpszPath)
BOOL WINAPI	PathIsFileSpecW (LPCWSTR lpszPath)
BOOL WINAPI	PathIsPrefixA (LPCSTR lpszPrefix, LPCSTR lpszPath)
BOOL WINAPI	PathIsPrefixW (LPCWSTR lpszPrefix, LPCWSTR lpszPath)
BOOL WINAPI	PathIsSystemFolderA (LPCSTR lpszPath, DWORD dwAttrib)
BOOL WINAPI	PathIsSystemFolderW (LPCWSTR lpszPath, DWORD dwAttrib)
BOOL WINAPI	PathIsUNCA (LPCSTR lpszPath)
BOOL WINAPI	PathIsUNCW (LPCWSTR lpszPath)
BOOL WINAPI	PathIsUNCServerA (LPCSTR lpszPath)
BOOL WINAPI	PathIsUNCServerW (LPCWSTR lpszPath)
BOOL WINAPI	PathIsUNCServerShareA (LPCSTR lpszPath)
BOOL WINAPI	PathIsUNCServerShareW (LPCWSTR lpszPath)
BOOL WINAPI	PathCanonicalizeA (LPSTR lpszBuf, LPCSTR lpszPath)
BOOL WINAPI	PathCanonicalizeW (LPWSTR lpszBuf, LPCWSTR lpszPath)
LPSTR WINAPI	PathFindNextComponentA (LPCSTR lpszPath)
LPWSTR WINAPI	PathFindNextComponentW (LPCWSTR lpszPath)
BOOL WINAPI	PathAddExtensionA (LPSTR lpszPath, LPCSTR lpszExtension)
BOOL WINAPI	PathAddExtensionW (LPWSTR lpszPath, LPCWSTR lpszExtension)
BOOL WINAPI	PathMakePrettyA (LPSTR lpszPath)
BOOL WINAPI	PathMakePrettyW (LPWSTR lpszPath)
int WINAPI	PathCommonPrefixA (LPCSTR lpszFile1, LPCSTR lpszFile2, LPSTR achPath)
int WINAPI	PathCommonPrefixW (LPCWSTR lpszFile1, LPCWSTR lpszFile2, LPWSTR achPath)
BOOL WINAPI	PathCompactPathA (HDC hDC, LPSTR lpszPath, UINT dx)
BOOL WINAPI	PathCompactPathW (HDC hDC, LPWSTR lpszPath, UINT dx)
UINT WINAPI	PathGetCharTypeA (UCHAR ch)
UINT WINAPI	PathGetCharTypeW (WCHAR ch)
static BOOL	SHLWAPI_UseSystemForSystemFolders (void)
BOOL WINAPI	PathMakeSystemFolderA (LPCSTR lpszPath)
BOOL WINAPI	PathMakeSystemFolderW (LPCWSTR lpszPath)
BOOL WINAPI	PathRenameExtensionA (LPSTR lpszPath, LPCSTR lpszExt)
BOOL WINAPI	PathRenameExtensionW (LPWSTR lpszPath, LPCWSTR lpszExt)
BOOL WINAPI	PathSearchAndQualifyA (LPCSTR lpszPath, LPSTR lpszBuf, UINT cchBuf)
BOOL WINAPI	PathSearchAndQualifyW (LPCWSTR lpszPath, LPWSTR lpszBuf, UINT cchBuf)
LPSTR WINAPI	PathSkipRootA (LPCSTR lpszPath)
LPWSTR WINAPI	PathSkipRootW (LPCWSTR lpszPath)
HRESULT WINAPI	PathCreateFromUrlA (LPCSTR pszUrl, LPSTR pszPath, LPDWORD pcchPath, DWORD dwReserved)
HRESULT WINAPI	PathCreateFromUrlW (LPCWSTR pszUrl, LPWSTR pszPath, LPDWORD pcchPath, DWORD dwReserved)
HRESULT WINAPI	PathCreateFromUrlAlloc (LPCWSTR pszUrl, LPWSTR *pszPath, DWORD dwReserved)
BOOL WINAPI	PathRelativePathToA (LPSTR lpszPath, LPCSTR lpszFrom, DWORD dwAttrFrom, LPCSTR lpszTo, DWORD dwAttrTo)
BOOL WINAPI	PathRelativePathToW (LPWSTR lpszPath, LPCWSTR lpszFrom, DWORD dwAttrFrom, LPCWSTR lpszTo, DWORD dwAttrTo)
BOOL WINAPI	PathUnmakeSystemFolderA (LPCSTR lpszPath)
BOOL WINAPI	PathUnmakeSystemFolderW (LPCWSTR lpszPath)
VOID WINAPI	PathSetDlgItemPathA (HWND hDlg, int id, LPCSTR lpszPath)
VOID WINAPI	PathSetDlgItemPathW (HWND hDlg, int id, LPCWSTR lpszPath)
BOOL WINAPI	PathIsNetworkPathA (LPCSTR lpszPath)
BOOL WINAPI	PathIsNetworkPathW (LPCWSTR lpszPath)
BOOL WINAPI	PathIsLFNFileSpecA (LPCSTR lpszPath)
BOOL WINAPI	PathIsLFNFileSpecW (LPCWSTR lpszPath)
BOOL WINAPI	PathIsDirectoryEmptyA (LPCSTR lpszPath)
BOOL WINAPI	PathIsDirectoryEmptyW (LPCWSTR lpszPath)
LPCSTR WINAPI	PathFindSuffixArrayA (LPCSTR lpszSuffix, LPCSTR *lppszArray, int dwCount)
LPCWSTR WINAPI	PathFindSuffixArrayW (LPCWSTR lpszSuffix, LPCWSTR *lppszArray, int dwCount)
void WINAPI	PathUndecorateA (LPSTR pszPath)
void WINAPI	PathUndecorateW (LPWSTR pszPath)
BOOL WINAPI	PathUnExpandEnvStringsA (LPCSTR path, LPSTR buffer, UINT buf_len)
static void	init_envvars_map (struct envvars_map *map)
BOOL WINAPI	PathUnExpandEnvStringsW (LPCWSTR path, LPWSTR buffer, UINT buf_len)
HRESULT WINAPI	SHGetWebFolderFilePathA (LPCSTR lpszFile, LPSTR lpszPath, DWORD dwPathLen)
BOOL WINAPI	PathIsValidCharA (char c, DWORD class)
BOOL WINAPI	PathIsValidCharW (WCHAR c, DWORD class)

Variables
static HMODULE	SHLWAPI_hshell32
static fnpIsNetDrive	pIsNetDrive
static const WCHAR	allusersprofileW [] = {'%','A','L','L','U','S','E','R','S','P','R','O','F','I','L','E','%',0}
static const WCHAR	appdataW [] = {'%','A','P','P','D','A','T','A','%',0}
static const WCHAR	programfilesW [] = {'%','P','r','o','g','r','a','m','F','i','l','e','s','%',0}
static const WCHAR	systemrootW [] = {'%','S','y','s','t','e','m','R','o','o','t','%',0}
static const WCHAR	systemdriveW [] = {'%','S','y','s','t','e','m','D','r','i','v','e','%',0}
static const WCHAR	userprofileW [] = {'%','U','S','E','R','P','R','O','F','I','L','E','%',0}
static const DWORD	SHELL_charclass []

Macro Definition Documentation

GET_FUNC

#define GET_FUNC	(		func,
			module,
			name,
			fail
	)

Value:

  do { \
    if (!func) { \
      if (!SHLWAPI_h##module && !(SHLWAPI_h##module = LoadLibraryA(#module ".dll"))) return fail; \
      func = (fn##func)GetProcAddress(SHLWAPI_h##module, name); \
      if (!func) return fail; \
    } \
  } while (0)

Definition at line 52 of file path.c.

NO_SHLWAPI_STREAM

#define NO_SHLWAPI_STREAM

Definition at line 36 of file path.c.

PATH_CHAR_CLASS_ANY

#define PATH_CHAR_CLASS_ANY   0xffffffff

Definition at line 4320 of file path.c.

PATH_CHAR_CLASS_ASTERIX

#define PATH_CHAR_CLASS_ASTERIX   0x00000002

Definition at line 4309 of file path.c.

PATH_CHAR_CLASS_BACKSLASH

#define PATH_CHAR_CLASS_BACKSLASH   0x00000008

Definition at line 4311 of file path.c.

PATH_CHAR_CLASS_COLON

#define PATH_CHAR_CLASS_COLON   0x00000010

Definition at line 4312 of file path.c.

PATH_CHAR_CLASS_COMMA

#define PATH_CHAR_CLASS_COMMA   0x00000040

Definition at line 4314 of file path.c.

PATH_CHAR_CLASS_DOT

#define PATH_CHAR_CLASS_DOT   0x00000004

Definition at line 4310 of file path.c.

PATH_CHAR_CLASS_DOUBLEQUOTE

#define PATH_CHAR_CLASS_DOUBLEQUOTE   0x00000200

Definition at line 4317 of file path.c.

PATH_CHAR_CLASS_INVALID

#define PATH_CHAR_CLASS_INVALID   0x00000000

Definition at line 4319 of file path.c.

PATH_CHAR_CLASS_LETTER

#define PATH_CHAR_CLASS_LETTER   0x00000001

Definition at line 4308 of file path.c.

PATH_CHAR_CLASS_OTHER_VALID

#define PATH_CHAR_CLASS_OTHER_VALID   0x00000100

Definition at line 4316 of file path.c.

PATH_CHAR_CLASS_SEMICOLON

#define PATH_CHAR_CLASS_SEMICOLON   0x00000020

Definition at line 4313 of file path.c.

PATH_CHAR_CLASS_SPACE

#define PATH_CHAR_CLASS_SPACE   0x00000080

Definition at line 4315 of file path.c.

szWebLen

#define szWebLen   (sizeof(szWeb)/sizeof(WCHAR))

szWebMuiLen

#define szWebMuiLen   ((sizeof(szWebMui)+1)/sizeof(WCHAR))

Typedef Documentation

fnpIsNetDrive

typedef BOOL(WINAPI * fnpIsNetDrive) (int)

Definition at line 65 of file path.c.

Function Documentation

heap_strdupAtoW()

static WCHAR * heap_strdupAtoW ( LPCSTR  str )

inlinestatic

Definition at line 73 of file path.c.

{
    WCHAR *ret = NULL;
 
    if (str)
    {
        DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
        ret = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
        if (ret)
            MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
    }
 
    return ret;
}

Referenced by PathUnExpandEnvStringsA().

init_envvars_map()

static void init_envvars_map ( struct envvars_map *  map )

static

Definition at line 4165 of file path.c.

{
    while (map->var)
    {
        map->len = ExpandEnvironmentStringsW(map->var, map->path, sizeof(map->path)/sizeof(WCHAR));
        /* exclude null from length */
        if (map->len) map->len--;
        map++;
    }
}

Referenced by PathUnExpandEnvStringsW().

PathAddBackslashA()

LPSTR WINAPI PathAddBackslashA

(

LPSTR

lpszPath

)

Definition at line 263 of file path.c.

{
  size_t iLen;
  LPSTR prev = lpszPath;
 
  TRACE("(%s)\n",debugstr_a(lpszPath));
 
  if (!lpszPath || (iLen = strlen(lpszPath)) >= MAX_PATH)
    return NULL;
 
  if (iLen)
  {
    do {
      lpszPath = CharNextA(prev);
      if (*lpszPath)
        prev = lpszPath;
    } while (*lpszPath);
    if (*prev != '\\')
    {
      *lpszPath++ = '\\';
      *lpszPath = '\0';
    }
  }
  return lpszPath;
}

PathAddBackslashW()

LPWSTR WINAPI PathAddBackslashW

(

LPWSTR

lpszPath

)

Definition at line 294 of file path.c.

{
  size_t iLen;
 
  TRACE("(%s)\n",debugstr_w(lpszPath));
 
  if (!lpszPath || (iLen = strlenW(lpszPath)) >= MAX_PATH)
    return NULL;
 
  if (iLen)
  {
    lpszPath += iLen;
    if (lpszPath[-1] != '\\')
    {
      *lpszPath++ = '\\';
      *lpszPath = '\0';
    }
  }
  return lpszPath;
}

PathAddExtensionA()

BOOL WINAPI PathAddExtensionA	(	LPSTR	lpszPath,
		LPCSTR	lpszExtension
	)

Definition at line 2621 of file path.c.

{
  size_t dwLen;
 
  TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszExtension));
 
  if (!lpszPath || !lpszExtension || *(PathFindExtensionA(lpszPath)))
    return FALSE;
 
  dwLen = strlen(lpszPath);
 
  if (dwLen + strlen(lpszExtension) >= MAX_PATH)
    return FALSE;
 
  strcpy(lpszPath + dwLen, lpszExtension);
  return TRUE;
}

PathAddExtensionW()

BOOL WINAPI PathAddExtensionW	(	LPWSTR	lpszPath,
		LPCWSTR	lpszExtension
	)

Definition at line 2644 of file path.c.

{
  size_t dwLen;
 
  TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszExtension));
 
  if (!lpszPath || !lpszExtension || *(PathFindExtensionW(lpszPath)))
    return FALSE;
 
  dwLen = strlenW(lpszPath);
 
  if (dwLen + strlenW(lpszExtension) >= MAX_PATH)
    return FALSE;
 
  strcpyW(lpszPath + dwLen, lpszExtension);
  return TRUE;
}

PathAppendA()

BOOL WINAPI PathAppendA	(	LPSTR	lpszPath,
		LPCSTR	lpszAppend
	)

Definition at line 106 of file path.c.

{
  TRACE("(%s,%s)\n",debugstr_a(lpszPath), debugstr_a(lpszAppend));
 
  if (lpszPath && lpszAppend)
  {
    if (!PathIsUNCA(lpszAppend))
      while (*lpszAppend == '\\')
        lpszAppend++;
    if (PathCombineA(lpszPath, lpszPath, lpszAppend))
      return TRUE;
  }
  return FALSE;
}

PathAppendW()

BOOL WINAPI PathAppendW	(	LPWSTR	lpszPath,
		LPCWSTR	lpszAppend
	)

Definition at line 126 of file path.c.

{
  TRACE("(%s,%s)\n",debugstr_w(lpszPath), debugstr_w(lpszAppend));
 
  if (lpszPath && lpszAppend)
  {
    if (!PathIsUNCW(lpszAppend))
      while (*lpszAppend == '\\')
        lpszAppend++;
    if (PathCombineW(lpszPath, lpszPath, lpszAppend))
      return TRUE;
  }
  return FALSE;
}

PathBuildRootA()

LPSTR WINAPI PathBuildRootA	(	LPSTR	lpszPath,
		int	drive
	)

Definition at line 329 of file path.c.

{
  TRACE("(%p,%d)\n", lpszPath, drive);
 
  if (lpszPath && drive >= 0 && drive < 26)
  {
    lpszPath[0] = 'A' + drive;
    lpszPath[1] = ':';
    lpszPath[2] = '\\';
    lpszPath[3] = '\0';
  }
  return lpszPath;
}

Referenced by ATL::CPathT< StringType >::PathBuildRootX(), and test_PathBuildRootA().

PathBuildRootW()

LPWSTR WINAPI PathBuildRootW	(	LPWSTR	lpszPath,
		int	drive
	)

Definition at line 348 of file path.c.

{
  TRACE("(%p,%d)\n", lpszPath, drive);
 
  if (lpszPath && drive >= 0 && drive < 26)
  {
    lpszPath[0] = 'A' + drive;
    lpszPath[1] = ':';
    lpszPath[2] = '\\';
    lpszPath[3] = '\0';
  }
  return lpszPath;
}

Referenced by IsLFNDriveW(), CDesktopBrowser::OnDeviceChange(), CDrivesFolder::ParseDisplayName(), ATL::CPathT< StringType >::PathBuildRootX(), and PathQualifyExW().

PathCanonicalizeA()

BOOL WINAPI PathCanonicalizeA	(	LPSTR	lpszBuf,
		LPCSTR	lpszPath
	)

Definition at line 2419 of file path.c.

{
  BOOL bRet = FALSE;
 
  TRACE("(%p,%s)\n", lpszBuf, debugstr_a(lpszPath));
 
  if (lpszBuf)
    *lpszBuf = '\0';
 
  if (!lpszBuf || !lpszPath)
    SetLastError(ERROR_INVALID_PARAMETER);
  else
  {
    WCHAR szPath[MAX_PATH];
    WCHAR szBuff[MAX_PATH];
    int ret = MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
 
    if (!ret) {
    WARN("Failed to convert string to widechar (too long?), LE %d.\n", GetLastError());
    return FALSE;
    }
    bRet = PathCanonicalizeW(szBuff, szPath);
    WideCharToMultiByte(CP_ACP,0,szBuff,-1,lpszBuf,MAX_PATH,0,0);
  }
  return bRet;
}

PathCanonicalizeW()

BOOL WINAPI PathCanonicalizeW	(	LPWSTR	lpszBuf,
		LPCWSTR	lpszPath
	)

Definition at line 2452 of file path.c.

{
  LPWSTR lpszDst = lpszBuf;
  LPCWSTR lpszSrc = lpszPath;
 
  TRACE("(%p,%s)\n", lpszBuf, debugstr_w(lpszPath));
 
  if (lpszBuf)
    *lpszDst = '\0';
 
  if (!lpszBuf || !lpszPath)
  {
    SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
  }
 
  if (!*lpszPath)
  {
    *lpszBuf++ = '\\';
    *lpszBuf = '\0';
    return TRUE;
  }
 
  /* Copy path root */
  if (*lpszSrc == '\\')
  {
    *lpszDst++ = *lpszSrc++;
  }
  else if (*lpszSrc && lpszSrc[1] == ':')
  {
    /* X:\ */
    *lpszDst++ = *lpszSrc++;
    *lpszDst++ = *lpszSrc++;
    if (*lpszSrc == '\\')
      *lpszDst++ = *lpszSrc++;
  }
 
  /* Canonicalize the rest of the path */
  while (*lpszSrc)
  {
    if (*lpszSrc == '.')
    {
      if (lpszSrc[1] == '\\' && (lpszSrc == lpszPath || lpszSrc[-1] == '\\' || lpszSrc[-1] == ':'))
      {
        lpszSrc += 2; /* Skip .\ */
      }
      else if (lpszSrc[1] == '.' && (lpszDst == lpszBuf || lpszDst[-1] == '\\'))
      {
        /* \.. backs up a directory, over the root if it has no \ following X:.
         * .. is ignored if it would remove a UNC server name or initial \\
         */
        if (lpszDst != lpszBuf)
        {
          *lpszDst = '\0'; /* Allow PathIsUNCServerShareA test on lpszBuf */
          if (lpszDst > lpszBuf+1 && lpszDst[-1] == '\\' &&
             (lpszDst[-2] != '\\' || lpszDst > lpszBuf+2))
          {
            if (lpszDst[-2] == ':' && (lpszDst > lpszBuf+3 || lpszDst[-3] == ':'))
            {
              lpszDst -= 2;
              while (lpszDst > lpszBuf && *lpszDst != '\\')
                lpszDst--;
              if (*lpszDst == '\\')
                lpszDst++; /* Reset to last '\' */
              else
                lpszDst = lpszBuf; /* Start path again from new root */
            }
            else if (lpszDst[-2] != ':' && !PathIsUNCServerShareW(lpszBuf))
              lpszDst -= 2;
          }
          while (lpszDst > lpszBuf && *lpszDst != '\\')
            lpszDst--;
          if (lpszDst == lpszBuf)
          {
            *lpszDst++ = '\\';
            lpszSrc++;
          }
        }
        lpszSrc += 2; /* Skip .. in src path */
      }
      else
        *lpszDst++ = *lpszSrc++;
    }
    else
      *lpszDst++ = *lpszSrc++;
  }
  /* Append \ to naked drive specs */
  if (lpszDst - lpszBuf == 2 && lpszDst[-1] == ':')
    *lpszDst++ = '\\';
  *lpszDst++ = '\0';
  return TRUE;
}

PathCombineA()

LPSTR WINAPI PathCombineA	(	LPSTR	lpszDest,
		LPCSTR	lpszDir,
		LPCSTR	lpszFile
	)

Definition at line 159 of file path.c.

{
  WCHAR szDest[MAX_PATH];
  WCHAR szDir[MAX_PATH];
  WCHAR szFile[MAX_PATH];
  TRACE("(%p,%s,%s)\n", lpszDest, debugstr_a(lpszDir), debugstr_a(lpszFile));
 
  /* Invalid parameters */
  if (!lpszDest)
    return NULL;
  if (!lpszDir && !lpszFile)
    goto fail;
 
  if (lpszDir)
    if (!MultiByteToWideChar(CP_ACP,0,lpszDir,-1,szDir,MAX_PATH))
      goto fail;
 
  if (lpszFile)
    if (!MultiByteToWideChar(CP_ACP,0,lpszFile,-1,szFile,MAX_PATH))
      goto fail;
 
  if (PathCombineW(szDest, lpszDir ? szDir : NULL, lpszFile ? szFile : NULL))
    if (WideCharToMultiByte(CP_ACP,0,szDest,-1,lpszDest,MAX_PATH,0,0))
      return lpszDest;
 
fail:
  lpszDest[0] = 0;
  return NULL;
}

PathCombineW()

LPWSTR WINAPI PathCombineW	(	LPWSTR	lpszDest,
		LPCWSTR	lpszDir,
		LPCWSTR	lpszFile
	)

Definition at line 194 of file path.c.

{
  WCHAR szTemp[MAX_PATH];
  BOOL bUseBoth = FALSE, bStrip = FALSE;
 
  TRACE("(%p,%s,%s)\n", lpszDest, debugstr_w(lpszDir), debugstr_w(lpszFile));
 
  /* Invalid parameters */
  if (!lpszDest)
    return NULL;
  if (!lpszDir && !lpszFile)
  {
    lpszDest[0] = 0;
    return NULL;
  }
 
  if ((!lpszFile || !*lpszFile) && lpszDir)
  {
    /* Use dir only */
    lstrcpynW(szTemp, lpszDir, MAX_PATH);
  }
  else if (!lpszDir || !*lpszDir || !PathIsRelativeW(lpszFile))
  {
    if (!lpszDir || !*lpszDir || *lpszFile != '\\' || PathIsUNCW(lpszFile))
    {
      /* Use file only */
      lstrcpynW(szTemp, lpszFile, MAX_PATH);
    }
    else
    {
      bUseBoth = TRUE;
      bStrip = TRUE;
    }
  }
  else
    bUseBoth = TRUE;
 
  if (bUseBoth)
  {
    lstrcpynW(szTemp, lpszDir, MAX_PATH);
    if (bStrip)
    {
      PathStripToRootW(szTemp);
      lpszFile++; /* Skip '\' */
    }
    if (!PathAddBackslashW(szTemp) || strlenW(szTemp) + strlenW(lpszFile) >= MAX_PATH)
    {
      lpszDest[0] = 0;
      return NULL;
    }
    strcatW(szTemp, lpszFile);
  }
 
  PathCanonicalizeW(lpszDest, szTemp);
  return lpszDest;
}

PathCommonPrefixA()

int WINAPI PathCommonPrefixA	(	LPCSTR	lpszFile1,
		LPCSTR	lpszFile2,
		LPSTR	achPath
	)

Definition at line 2757 of file path.c.

{
  size_t iLen = 0;
  LPCSTR lpszIter1 = lpszFile1;
  LPCSTR lpszIter2 = lpszFile2;
 
  TRACE("(%s,%s,%p)\n", debugstr_a(lpszFile1), debugstr_a(lpszFile2), achPath);
 
  if (achPath)
    *achPath = '\0';
 
  if (!lpszFile1 || !lpszFile2)
    return 0;
 
  /* Handle roots first */
  if (PathIsUNCA(lpszFile1))
  {
    if (!PathIsUNCA(lpszFile2))
      return 0;
    lpszIter1 += 2;
    lpszIter2 += 2;
  }
  else if (PathIsUNCA(lpszFile2))
      return 0; /* Know already lpszFile1 is not UNC */
 
  do
  {
    /* Update len */
    if ((!*lpszIter1 || *lpszIter1 == '\\') &&
        (!*lpszIter2 || *lpszIter2 == '\\'))
      iLen = lpszIter1 - lpszFile1; /* Common to this point */
 
    if (!*lpszIter1 || (tolower(*lpszIter1) != tolower(*lpszIter2)))
      break; /* Strings differ at this point */
 
    lpszIter1++;
    lpszIter2++;
  } while (1);
 
  if (iLen == 2)
    iLen++; /* Feature/Bug compatible with Win32 */
 
  if (iLen && achPath)
  {
    memcpy(achPath,lpszFile1,iLen);
    achPath[iLen] = '\0';
  }
  return iLen;
}

Referenced by ATL::CPathT< StringType >::PathCommonPrefixX(), PathIsPrefixA(), PathIsSameRootA(), and test_PathCommonPrefixA().

PathCommonPrefixW()

int WINAPI PathCommonPrefixW	(	LPCWSTR	lpszFile1,
		LPCWSTR	lpszFile2,
		LPWSTR	achPath
	)

Definition at line 2812 of file path.c.

{
  size_t iLen = 0;
  LPCWSTR lpszIter1 = lpszFile1;
  LPCWSTR lpszIter2 = lpszFile2;
 
  TRACE("(%s,%s,%p)\n", debugstr_w(lpszFile1), debugstr_w(lpszFile2), achPath);
 
  if (achPath)
    *achPath = '\0';
 
  if (!lpszFile1 || !lpszFile2)
    return 0;
 
  /* Handle roots first */
  if (PathIsUNCW(lpszFile1))
  {
    if (!PathIsUNCW(lpszFile2))
      return 0;
    lpszIter1 += 2;
    lpszIter2 += 2;
  }
  else if (PathIsUNCW(lpszFile2))
      return 0; /* Know already lpszFile1 is not UNC */
 
  do
  {
    /* Update len */
    if ((!*lpszIter1 || *lpszIter1 == '\\') &&
        (!*lpszIter2 || *lpszIter2 == '\\'))
      iLen = lpszIter1 - lpszFile1; /* Common to this point */
 
    if (!*lpszIter1 || (tolowerW(*lpszIter1) != tolowerW(*lpszIter2)))
      break; /* Strings differ at this point */
 
    lpszIter1++;
    lpszIter2++;
  } while (1);
 
  if (iLen == 2)
    iLen++; /* Feature/Bug compatible with Win32 */
 
  if (iLen && achPath)
  {
    memcpy(achPath,lpszFile1,iLen * sizeof(WCHAR));
    achPath[iLen] = '\0';
  }
  return iLen;
}

Referenced by DynamicPathCommonPrefixW(), ATL::CPathT< StringType >::PathCommonPrefixX(), PathIsPrefixW(), PathIsSameRootW(), and PathRelativePathToW().

PathCompactPathA()

BOOL WINAPI PathCompactPathA	(	HDC	hDC,
		LPSTR	lpszPath,
		UINT	dx
	)

Definition at line 2876 of file path.c.

{
  BOOL bRet = FALSE;
 
  TRACE("(%p,%s,%d)\n", hDC, debugstr_a(lpszPath), dx);
 
  if (lpszPath)
  {
    WCHAR szPath[MAX_PATH];
    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
    bRet = PathCompactPathW(hDC, szPath, dx);
    WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
  }
  return bRet;
}

Referenced by ATL::CPathT< StringType >::PathCompactPathX().

PathCompactPathExA()

BOOL WINAPI PathCompactPathExA	(	LPSTR	lpszDest,
		LPCSTR	lpszPath,
		UINT	cchMax,
		DWORD	dwFlags
	)

Definition at line 1441 of file path.c.

{
  BOOL bRet = FALSE;
 
  TRACE("(%p,%s,%d,0x%08x)\n", lpszDest, debugstr_a(lpszPath), cchMax, dwFlags);
 
  if (lpszPath && lpszDest)
  {
    WCHAR szPath[MAX_PATH];
    WCHAR szDest[MAX_PATH];
 
    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
    szDest[0] = '\0';
    bRet = PathCompactPathExW(szDest, szPath, cchMax, dwFlags);
    WideCharToMultiByte(CP_ACP,0,szDest,-1,lpszDest,MAX_PATH,0,0);
  }
  return bRet;
}

Referenced by ATL::CPathT< StringType >::PathCompactPathExX().

PathCompactPathExW()

BOOL WINAPI PathCompactPathExW	(	LPWSTR	lpszDest,
		LPCWSTR	lpszPath,
		UINT	cchMax,
		DWORD	dwFlags
	)

Definition at line 1466 of file path.c.

{
  static const WCHAR szEllipses[] = { '.', '.', '.', '\0' };
  LPCWSTR lpszFile;
  DWORD dwLen, dwFileLen = 0;
 
  TRACE("(%p,%s,%d,0x%08x)\n", lpszDest, debugstr_w(lpszPath), cchMax, dwFlags);
 
  if (!lpszPath)
    return FALSE;
 
  if (!lpszDest)
  {
    WARN("Invalid lpszDest would crash under Win32!\n");
    return FALSE;
  }
 
  *lpszDest = '\0';
 
  if (cchMax < 2)
    return TRUE;
 
  dwLen = strlenW(lpszPath) + 1;
 
  if (dwLen < cchMax)
  {
    /* Don't need to compact */
    memcpy(lpszDest, lpszPath, dwLen * sizeof(WCHAR));
    return TRUE;
  }
 
  /* Path must be compacted to fit into lpszDest */
  lpszFile = PathFindFileNameW(lpszPath);
  dwFileLen = lpszPath + dwLen - lpszFile;
 
  if (dwFileLen == dwLen)
  {
    /* No root in psth */
    if (cchMax <= 4)
    {
      while (--cchMax > 0) /* No room left for anything but ellipses */
        *lpszDest++ = '.';
      *lpszDest = '\0';
      return TRUE;
    }
    /* Compact the file name with ellipses at the end */
    cchMax -= 4;
    memcpy(lpszDest, lpszFile, cchMax * sizeof(WCHAR));
    strcpyW(lpszDest + cchMax, szEllipses);
    return TRUE;
  }
  /* We have a root in the path */
  lpszFile--; /* Start compacted filename with the path separator */
  dwFileLen++;
 
  if (dwFileLen + 3 > cchMax)
  {
    /* Compact the file name */
    if (cchMax <= 4)
    {
      while (--cchMax > 0) /* No room left for anything but ellipses */
        *lpszDest++ = '.';
      *lpszDest = '\0';
      return TRUE;
    }
    strcpyW(lpszDest, szEllipses);
    lpszDest += 3;
    cchMax -= 4;
    *lpszDest++ = *lpszFile++;
    if (cchMax <= 4)
    {
      while (--cchMax > 0) /* No room left for anything but ellipses */
        *lpszDest++ = '.';
      *lpszDest = '\0';
      return TRUE;
    }
    cchMax -= 4;
    memcpy(lpszDest, lpszFile, cchMax * sizeof(WCHAR));
    strcpyW(lpszDest + cchMax, szEllipses);
    return TRUE;
  }
 
  /* Only the root needs to be Compacted */
  dwLen = cchMax - dwFileLen - 3;
  memcpy(lpszDest, lpszPath, dwLen * sizeof(WCHAR));
  strcpyW(lpszDest + dwLen, szEllipses);
  strcpyW(lpszDest + dwLen + 3, lpszFile);
  return TRUE;
}

Referenced by PathCompactPathExA(), and ATL::CPathT< StringType >::PathCompactPathExX().

PathCompactPathW()

BOOL WINAPI PathCompactPathW	(	HDC	hDC,
		LPWSTR	lpszPath,
		UINT	dx
	)

Definition at line 2897 of file path.c.

{
  static const WCHAR szEllipses[] = { '.', '.', '.', '\0' };
  BOOL bRet = TRUE;
  HDC hdc = 0;
  WCHAR buff[MAX_PATH];
  SIZE size;
  DWORD dwLen;
 
  TRACE("(%p,%s,%d)\n", hDC, debugstr_w(lpszPath), dx);
 
  if (!lpszPath)
    return FALSE;
 
  if (!hDC)
    hdc = hDC = GetDC(0);
 
  /* Get the length of the whole path */
  dwLen = strlenW(lpszPath);
  GetTextExtentPointW(hDC, lpszPath, dwLen, &size);
 
  if ((UINT)size.cx > dx)
  {
    /* Path too big, must reduce it */
    LPWSTR sFile;
    DWORD dwEllipsesLen = 0, dwPathLen = 0;
 
    sFile = PathFindFileNameW(lpszPath);
    if (sFile != lpszPath) sFile--;
 
    /* Get the size of ellipses */
    GetTextExtentPointW(hDC, szEllipses, 3, &size);
    dwEllipsesLen = size.cx;
    /* Get the size of the file name */
    GetTextExtentPointW(hDC, sFile, strlenW(sFile), &size);
    dwPathLen = size.cx;
 
    if (sFile != lpszPath)
    {
      LPWSTR sPath = sFile;
      BOOL bEllipses = FALSE;
 
      /* The path includes a file name. Include as much of the path prior to
       * the file name as possible, allowing for the ellipses, e.g:
       * c:\some very long path\filename ==> c:\some v...\filename
       */
      lstrcpynW(buff, sFile, MAX_PATH);
 
      do
      {
        DWORD dwTotalLen = bEllipses? dwPathLen + dwEllipsesLen : dwPathLen;
 
        GetTextExtentPointW(hDC, lpszPath, sPath - lpszPath, &size);
        dwTotalLen += size.cx;
        if (dwTotalLen <= dx)
          break;
        sPath--;
        if (!bEllipses)
        {
          bEllipses = TRUE;
          sPath -= 2;
        }
      } while (sPath > lpszPath);
 
      if (sPath > lpszPath)
      {
        if (bEllipses)
        {
          strcpyW(sPath, szEllipses);
          strcpyW(sPath+3, buff);
        }
        bRet = TRUE;
        goto end;
      }
      strcpyW(lpszPath, szEllipses);
      strcpyW(lpszPath+3, buff);
      bRet = FALSE;
      goto end;
    }
 
    /* Trim the path by adding ellipses to the end, e.g:
     * A very long file name.txt ==> A very...
     */
    dwLen = strlenW(lpszPath);
 
    if (dwLen > MAX_PATH - 3)
      dwLen =  MAX_PATH - 3;
    lstrcpynW(buff, sFile, dwLen);
 
    do {
      dwLen--;
      GetTextExtentPointW(hDC, buff, dwLen, &size);
    } while (dwLen && size.cx + dwEllipsesLen > dx);
 
   if (!dwLen)
   {
     DWORD dwWritten = 0;
 
     dwEllipsesLen /= 3; /* Size of a single '.' */
 
     /* Write as much of the Ellipses string as possible */
     while (dwWritten + dwEllipsesLen < dx && dwLen < 3)
     {
       *lpszPath++ = '.';
       dwWritten += dwEllipsesLen;
       dwLen++;
     }
     *lpszPath = '\0';
     bRet = FALSE;
   }
   else
   {
     strcpyW(buff + dwLen, szEllipses);
     strcpyW(lpszPath, buff);
    }
  }
 
end:
  if (hdc)
    ReleaseDC(0, hdc);
 
  return bRet;
}

Referenced by CZipExtract::CCompleteSettingsPage::OnSetActive(), PathCompactPathA(), ATL::CPathT< StringType >::PathCompactPathX(), and PathSetDlgItemPathW().

PathCreateFromUrlA()

HRESULT WINAPI PathCreateFromUrlA	(	LPCSTR	pszUrl,
		LPSTR	pszPath,
		LPDWORD	pcchPath,
		DWORD	dwReserved
	)

Definition at line 3312 of file path.c.

{
    WCHAR bufW[MAX_PATH];
    WCHAR *pathW = bufW;
    UNICODE_STRING urlW;
    HRESULT ret;
    DWORD lenW = sizeof(bufW)/sizeof(WCHAR), lenA;
 
    if (!pszUrl || !pszPath || !pcchPath || !*pcchPath)
        return E_INVALIDARG;
 
    if(!RtlCreateUnicodeStringFromAsciiz(&urlW, pszUrl))
        return E_INVALIDARG;
    if((ret = PathCreateFromUrlW(urlW.Buffer, pathW, &lenW, dwReserved)) == E_POINTER) {
        pathW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
        ret = PathCreateFromUrlW(urlW.Buffer, pathW, &lenW, dwReserved);
    }
    if(ret == S_OK) {
        RtlUnicodeToMultiByteSize(&lenA, pathW, lenW * sizeof(WCHAR));
        if(*pcchPath > lenA) {
            RtlUnicodeToMultiByteN(pszPath, *pcchPath - 1, &lenA, pathW, lenW * sizeof(WCHAR));
            pszPath[lenA] = 0;
            *pcchPath = lenA;
        } else {
            *pcchPath = lenA + 1;
            ret = E_POINTER;
        }
    }
    if(pathW != bufW) HeapFree(GetProcessHeap(), 0, pathW);
    RtlFreeUnicodeString(&urlW);
    return ret;
}

Referenced by FileProtocolHandlerA().

PathCreateFromUrlAlloc()

HRESULT WINAPI PathCreateFromUrlAlloc	(	LPCWSTR	pszUrl,
		LPWSTR *	pszPath,
		DWORD	dwReserved
	)

Definition at line 3503 of file path.c.

{
    WCHAR pathW[MAX_PATH];
    DWORD size;
    HRESULT hr;
 
    size = MAX_PATH;
    hr = PathCreateFromUrlW(pszUrl, pathW, &size, dwReserved);
    if (SUCCEEDED(hr))
    {
        /* Yes, this is supposed to crash if pszPath is NULL */
        *pszPath = StrDupW(pathW);
    }
    return hr;
}

PathCreateFromUrlW()

HRESULT WINAPI PathCreateFromUrlW	(	LPCWSTR	pszUrl,
		LPWSTR	pszPath,
		LPDWORD	pcchPath,
		DWORD	dwReserved
	)

Definition at line 3361 of file path.c.

{
    static const WCHAR file_colon[] = { 'f','i','l','e',':',0 };
    static const WCHAR localhost[] = { 'l','o','c','a','l','h','o','s','t',0 };
    DWORD nslashes, unescape, len;
    const WCHAR *src;
    WCHAR *tpath, *dst;
    HRESULT ret;
 
    TRACE("(%s,%p,%p,0x%08x)\n", debugstr_w(pszUrl), pszPath, pcchPath, dwReserved);
 
    if (!pszUrl || !pszPath || !pcchPath || !*pcchPath)
        return E_INVALIDARG;
 
    if (lstrlenW(pszUrl) < 5)
        return E_INVALIDARG;
 
    if (CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, pszUrl, 5,
                       file_colon, 5) != CSTR_EQUAL)
        return E_INVALIDARG;
    pszUrl += 5;
    ret = S_OK;
 
    src = pszUrl;
    nslashes = 0;
    while (*src == '/' || *src == '\\') {
        nslashes++;
        src++;
    }
 
    /* We need a temporary buffer so we can compute what size to ask for.
     * We know that the final string won't be longer than the current pszUrl
     * plus at most two backslashes. All the other transformations make it
     * shorter.
     */
    len = 2 + lstrlenW(pszUrl) + 1;
    if (*pcchPath < len)
        tpath = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    else
        tpath = pszPath;
 
    len = 0;
    dst = tpath;
    unescape = 1;
    switch (nslashes)
    {
    case 0:
        /* 'file:' + escaped DOS path */
        break;
    case 1:
        /* 'file:/' + escaped DOS path */
        /* fall through */
    case 3:
        /* 'file:///' (implied localhost) + escaped DOS path */
        if (!isalphaW(*src) || (src[1] != ':' && src[1] != '|'))
            src -= 1;
        break;
    case 2:
        if (lstrlenW(src) >= 10 && CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE,
            src, 9, localhost, 9) == CSTR_EQUAL && (src[9] == '/' || src[9] == '\\'))
        {
            /* 'file://localhost/' + escaped DOS path */
            src += 10;
        }
        else if (isalphaW(*src) && (src[1] == ':' || src[1] == '|'))
        {
            /* 'file://' + unescaped DOS path */
            unescape = 0;
        }
        else
        {
            /*    'file://hostname:port/path' (where path is escaped)
             * or 'file:' + escaped UNC path (\\server\share\path)
             * The second form is clearly specific to Windows and it might
             * even be doing a network lookup to try to figure it out.
             */
            while (*src && *src != '/' && *src != '\\')
                src++;
            len = src - pszUrl;
            StrCpyNW(dst, pszUrl, len + 1);
            dst += len;
            if (*src && isalphaW(src[1]) && (src[2] == ':' || src[2] == '|'))
            {
                /* 'Forget' to add a trailing '/', just like Windows */
                src++;
            }
        }
        break;
    case 4:
        /* 'file://' + unescaped UNC path (\\server\share\path) */
        unescape = 0;
        if (isalphaW(*src) && (src[1] == ':' || src[1] == '|'))
            break;
        /* fall through */
    default:
        /* 'file:/...' + escaped UNC path (\\server\share\path) */
        src -= 2;
    }
 
    /* Copy the remainder of the path */
    len += lstrlenW(src);
    StrCpyW(dst, src);
 
     /* First do the Windows-specific path conversions */
    for (dst = tpath; *dst; dst++)
        if (*dst == '/') *dst = '\\';
    if (isalphaW(*tpath) && tpath[1] == '|')
        tpath[1] = ':'; /* c| -> c: */
 
    /* And only then unescape the path (i.e. escaped slashes are left as is) */
    if (unescape)
    {
        ret = UrlUnescapeW(tpath, NULL, &len, URL_UNESCAPE_INPLACE);
        if (ret == S_OK)
        {
            /* When working in-place UrlUnescapeW() does not set len */
            len = lstrlenW(tpath);
        }
    }
 
    if (*pcchPath < len + 1)
    {
        ret = E_POINTER;
        *pcchPath = len + 1;
    }
    else
    {
        *pcchPath = len;
        if (tpath != pszPath)
            StrCpyW(pszPath, tpath);
    }
    if (tpath != pszPath)
      HeapFree(GetProcessHeap(), 0, tpath);
 
    TRACE("Returning (%u) %s\n", *pcchPath, debugstr_w(pszPath));
    return ret;
}

Referenced by CDesktopFolder::_ParseDisplayNameByParent(), DocObjectService_FireBeforeNavigate2(), InternetCrackUrlW(), on_before_navigate2(), parse_path_from_url(), PathCreateFromUrlA(), PathCreateFromUrlAlloc(), CDownloadManager::PerformDownloadAndInstall(), and SHELL_execute().

PathFileExistsA()

BOOL WINAPI PathFileExistsA

(

LPCSTR

lpszPath

)

Definition at line 1761 of file path.c.

{
  UINT iPrevErrMode;
  DWORD dwAttr;
 
  TRACE("(%s)\n",debugstr_a(lpszPath));
 
  if (!lpszPath)
    return FALSE;
 
  /* Prevent a dialog box if path is on a disk that has been ejected. */
  iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
  dwAttr = GetFileAttributesA(lpszPath);
  SetErrorMode(iPrevErrMode);
  return dwAttr != INVALID_FILE_ATTRIBUTES;
}

Referenced by DoTestEntry(), PathFileExistsAW(), ATL::CPathT< StringType >::PathFileExistsX(), and START_TEST().

PathFileExistsAndAttributesA()

BOOL WINAPI PathFileExistsAndAttributesA	(	LPCSTR	lpszPath,
		DWORD *	dwAttr
	)

Definition at line 1812 of file path.c.

{
  UINT iPrevErrMode;
  DWORD dwVal = 0;
 
  TRACE("(%s %p)\n", debugstr_a(lpszPath), dwAttr);
 
  if (dwAttr)
    *dwAttr = INVALID_FILE_ATTRIBUTES;
 
  if (!lpszPath)
    return FALSE;
 
  iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
  dwVal = GetFileAttributesA(lpszPath);
  SetErrorMode(iPrevErrMode);
  if (dwAttr)
    *dwAttr = dwVal;
  return (dwVal != INVALID_FILE_ATTRIBUTES);
}

PathFileExistsAndAttributesW()

BOOL WINAPI PathFileExistsAndAttributesW	(	LPCWSTR	lpszPath,
		DWORD *	dwAttr
	)

Definition at line 1838 of file path.c.

{
  UINT iPrevErrMode;
  DWORD dwVal;
 
  TRACE("(%s %p)\n", debugstr_w(lpszPath), dwAttr);
 
  if (!lpszPath)
    return FALSE;
 
  iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
  dwVal = GetFileAttributesW(lpszPath);
  SetErrorMode(iPrevErrMode);
  if (dwAttr)
    *dwAttr = dwVal;
  return (dwVal != INVALID_FILE_ATTRIBUTES);
}

Referenced by GetTypeDescriptionByPath(), PathFileExistsDefExtAndAttributesW(), and PathResolveW().

PathFileExistsDefExtA()

BOOL WINAPI PathFileExistsDefExtA	(	LPSTR	lpszPath,
		DWORD	dwWhich
	)

Definition at line 1201 of file path.c.

{
  BOOL bRet = FALSE;
 
  TRACE("(%s,%d)\n", debugstr_a(lpszPath), dwWhich);
 
  if (lpszPath)
  {
    WCHAR szPath[MAX_PATH];
    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
    bRet = PathFileExistsDefExtW(szPath, dwWhich);
    if (bRet)
      WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
  }
  return bRet;
}

PathFileExistsDefExtW()

BOOL WINAPI PathFileExistsDefExtW	(	LPWSTR	lpszPath,
		DWORD	dwWhich
	)

Definition at line 1123 of file path.c.

{
  static const WCHAR pszExts[][5]  = { { '.', 'p', 'i', 'f', 0},
                                       { '.', 'c', 'o', 'm', 0},
                                       { '.', 'e', 'x', 'e', 0},
                                       { '.', 'b', 'a', 't', 0},
                                       { '.', 'l', 'n', 'k', 0},
                                       { '.', 'c', 'm', 'd', 0},
                                       { 0, 0, 0, 0, 0} };
 
  TRACE("(%s,%d)\n", debugstr_w(lpszPath), dwWhich);
 
  if (!lpszPath || PathIsUNCServerW(lpszPath) || PathIsUNCServerShareW(lpszPath))
    return FALSE;
 
  if (dwWhich)
  {
    LPCWSTR szExt = PathFindExtensionW(lpszPath);
#ifndef __REACTOS__
    if (!*szExt || dwWhich & 0x40)
#else
    if (!*szExt || dwWhich & WHICH_OPTIONAL)
#endif
    {
      size_t iChoose = 0;
      int iLen = lstrlenW(lpszPath);
      if (iLen > (MAX_PATH - 5))
        return FALSE;
#ifndef __REACTOS__
      while ( (dwWhich & 0x1) && pszExts[iChoose][0] )
#else
      while (pszExts[iChoose][0])
#endif
      {
#ifdef __REACTOS__
        if (dwWhich & 0x1)
        {
        if (GetFileAttributes(lpszPath) != FILE_ATTRIBUTE_DIRECTORY)
#endif
        lstrcpyW(lpszPath + iLen, pszExts[iChoose]);
        if (PathFileExistsW(lpszPath))
          return TRUE;
#ifdef __REACTOS__
        }
#endif
        iChoose++;
        dwWhich >>= 1;
      }
      *(lpszPath + iLen) = (WCHAR)'\0';
      return FALSE;
    }
  }
  return PathFileExistsW(lpszPath);
}

Referenced by PathFileExistsDefExtA(), PathFileExistsDefExtAndAttributesW(), PathFindOnPathExA(), PathFindOnPathExW(), PathSearchOnExtensionsW(), and SHLWAPI_PathFindInOtherDirs().

PathFileExistsW()

BOOL WINAPI PathFileExistsW

(

LPCWSTR

lpszPath

)

Definition at line 1783 of file path.c.

{
  UINT iPrevErrMode;
  DWORD dwAttr;
 
  TRACE("(%s)\n",debugstr_w(lpszPath));
 
  if (!lpszPath)
    return FALSE;
 
  iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
  dwAttr = GetFileAttributesW(lpszPath);
  SetErrorMode(iPrevErrMode);
  return dwAttr != INVALID_FILE_ATTRIBUTES;
}

Referenced by CFSDropTarget::_GetUniqueFileName(), BrowseCallbackProc(), CAvailableApplicationInfo::CAvailableApplicationInfo(), copy_dir_to_dir(), copy_file(), copy_file_to_file(), copy_files(), copy_to_dir(), create_dest_dirs(), DoGetZipName(), DoTestEntry(), CMyDocsDropHandler::Drop(), CDeskLinkDropHandler::Drop(), CACListISF::Expand(), FILEDLG95_InitControls(), FILEDLG95_OnOpen(), FILEDLG95_ValidatePathAction(), FindSubProgram(), CFileDefExt::InitOpensWithField(), LoadOSList(), move_file_to_file(), move_files(), move_to_dir(), on_default_action(), CShellLink::OnNotify(), OpenMailer(), PathFileExistsAW(), PathFileExistsDefExtW(), ATL::CPathT< StringType >::PathFileExistsX(), PathYetAnotherMakeUniqueName(), CDirectoryWatcher::ProcessNotification(), CShellLink::Save(), SHAddToRecentDocs(), SHCreatePropertyBagOnProfileSection(), SHELL32_GetFSItemAttributes(), ShellExecCmdLine(), SHExplorerParseCmdLine(), SHGetFolderPathAndSubDirW(), SHGetWebFolderFilePathW(), ShowCreateShortcutWizard(), SHPropertyBag_OnIniFile(), START_TEST(), TEST_Start(), try_find_new_name(), and WelcomeDlgProc().

PathFindExtensionA()

LPSTR WINAPI PathFindExtensionA

(

LPCSTR

lpszPath

)

Definition at line 422 of file path.c.

{
  LPCSTR lastpoint = NULL;
 
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (lpszPath)
  {
    while (*lpszPath)
    {
      if (*lpszPath == '\\' || *lpszPath==' ')
        lastpoint = NULL;
      else if (*lpszPath == '.')
        lastpoint = lpszPath;
      lpszPath = CharNextA(lpszPath);
    }
  }
  return (LPSTR)(lastpoint ? lastpoint : lpszPath);
}

Referenced by FD31_UpdateResult(), FILEDLG95_OnOpen(), PathAddExtensionA(), ATL::CPathT< StringType >::PathFindExtensionX(), PathGetExtensionA(), PathIsContentTypeA(), PathRemoveExtensionA(), PathRenameExtensionA(), PathUndecorateA(), and test_PathFindExtensionA().

PathFindExtensionW()

LPWSTR WINAPI PathFindExtensionW

(

LPCWSTR

lpszPath

)

Definition at line 447 of file path.c.

{
  LPCWSTR lastpoint = NULL;
 
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (lpszPath)
  {
    while (*lpszPath)
    {
      if (*lpszPath == '\\' || *lpszPath==' ')
        lastpoint = NULL;
      else if (*lpszPath == '.')
        lastpoint = lpszPath;
      lpszPath++;
    }
  }
  return (LPWSTR)(lastpoint ? lastpoint : lpszPath);
}

Referenced by CFileSysEnum::_AddFindResult(), CFSDropTarget::_DoDrop(), _ILGetExtension(), add_favs_to_menu(), COpenWithList::AddAppToMRUList(), CFSFolder::CompareIDs(), CreateShortcut(), RecycleBin5::DeleteFile(), DoShellContextMenu(), CDeskLinkDropHandler::Drop(), ExtensionFromPidl(), FD31_UpdateResult(), FileCompareWildTitle(), FILEDLG95_OnOpen(), FM_InitMenuPopup(), get_first_ext_from_spec(), GetAssocClass(), CMainWindow::GetSaveFileName(), GetTypeDescriptionByPath(), RecycleBin5File::Init(), CQueryAssociations::Init(), CLayerUIPropPage::InitFile(), CFileDefExt::InitFileType(), COpenWithMenu::Initialize(), CFileDefExt::InitOpensWithField(), InstallFontFiles(), COpenWithMenu::InvokeCommand(), COpenWithList::LoadRecommended(), OFNHookProc(), on_default_action(), CShellLink::OnNotify(), CDefView::OnNotify(), OpensWithExplorer(), PathAddExtensionW(), PathFileExistsDefExtAndAttributesW(), PathFileExistsDefExtW(), ATL::CPathT< StringType >::PathFindExtensionX(), PathGetExtensionW(), PathIsContentTypeW(), PathRemoveExtensionW(), PathRenameExtensionW(), PathSearchOnExtensionsW(), PathUndecorateW(), PathYetAnotherMakeUniqueName(), process_extensions(), BtrfsContextMenu::reflink_copy(), CImageDx::SaveDx(), CMainWindow::saveImage(), COpenWithList::SetDefaultHandler(), CFSFolder::SetNameOf(), SHAddToRecentDocs(), SHELL32_AssocGetFileDescription(), SHELL32_GetFSItemAttributes(), SHELL_FS_HideExtension(), ShellExecute_GetClassKey(), SHGetFileInfoW(), ShowCreateShortcutWizard(), test_properties(), try_find_new_name(), and URLDownloadToCacheFileW().

PathFindFileNameA()

LPSTR WINAPI PathFindFileNameA

(

LPCSTR

lpszPath

)

Definition at line 373 of file path.c.

{
  LPCSTR lastSlash = lpszPath;
 
  TRACE("(%s)\n",debugstr_a(lpszPath));
 
  while (lpszPath && *lpszPath)
  {
    if ((*lpszPath == '\\' || *lpszPath == '/' || *lpszPath == ':') &&
        lpszPath[1] && lpszPath[1] != '\\' && lpszPath[1] != '/')
      lastSlash = lpszPath + 1;
    lpszPath = CharNextA(lpszPath);
  }
  return (LPSTR)lastSlash;
}

Referenced by FD31_UpdateResult(), FILEDLG95_OnOpen(), GetFileDialog95(), ATL::CPathT< StringType >::PathFindFileNameX(), and PathStripPathA().

PathFindFileNameW()

LPWSTR WINAPI PathFindFileNameW

(

LPCWSTR

lpszPath

)

Definition at line 394 of file path.c.

{
  LPCWSTR lastSlash = lpszPath;
 
  TRACE("(%s)\n",debugstr_w(lpszPath));
 
  while (lpszPath && *lpszPath)
  {
    if ((*lpszPath == '\\' || *lpszPath == '/' || *lpszPath == ':') &&
        lpszPath[1] && lpszPath[1] != '\\' && lpszPath[1] != '/')
      lastSlash = lpszPath + 1;
    lpszPath++;
  }
  return (LPWSTR)lastSlash;
}

Referenced by _CZipAskPassword(), _CZipAskReplace(), CFSDropTarget::_DoDrop(), _ILCreate(), COpenWithList::Add(), CheckForError(), CFontExt::CompareIDs(), copy_file(), copy_file_to_file(), create_target_directory(), CreateItem(), CreateSendToMyDocuments(), dialog_directorylist_up(), CDeskLinkDropHandler::Drop(), FD31_UpdateResult(), FILEDLG95_OnOpen(), FinishDlgProc(), CFileDefExt::GeneralPageProc(), get_volume_path_parent(), CFontExt::GetDetailsOf(), CRecycleBin::GetDisplayNameOf(), GetFileDialog95(), GetItemOriginalFileName(), CShellLink::GetPath(), HandleDesktopIniOp(), COpenWithDialog::Init(), CFileDefExt::InitFilePath(), CFileDefExt::InitGeneralPage(), CFileDefExt::InitOpensWithField(), IsExplorerSystemShell(), IsTitleWild(), COpenWithList::LoadFromProgIdKey(), move_file_to_file(), OFNHookProc(), CShellLink::OnInitDialog(), OpenMailer(), OpensWithExplorer(), PathCompactPathExW(), PathCompactPathW(), ATL::CPathT< StringType >::PathFindFileNameX(), PathStripPathW(), Preview_UpdateTitle(), BtrfsContextMenu::reflink_copy(), SetFileInfo(), CFSFolder::SetNameOf(), SHAddToRecentDocs(), SHCreatePropertyBagOnProfileSection(), SHELL32_GetDllFromRundll32CommandLine(), SHELL_InRunDllProcess(), ShowCreateShortcutWizard(), START_TEST(), test_MultipleFiles(), and TEST_Start().

PathFindNextComponentA()

LPSTR WINAPI PathFindNextComponentA

(

LPCSTR

lpszPath

)

Definition at line 2562 of file path.c.

{
  LPSTR lpszSlash;
 
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if(!lpszPath || !*lpszPath)
    return NULL;
 
  if ((lpszSlash = StrChrA(lpszPath, '\\')))
  {
    if (lpszSlash[1] == '\\')
      lpszSlash++;
    return lpszSlash + 1;
  }
  return (LPSTR)lpszPath + strlen(lpszPath);
}

PathFindNextComponentW()

LPWSTR WINAPI PathFindNextComponentW

(

LPCWSTR

lpszPath

)

Definition at line 2585 of file path.c.

{
  LPWSTR lpszSlash;
 
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if(!lpszPath || !*lpszPath)
    return NULL;
 
  if ((lpszSlash = StrChrW(lpszPath, '\\')))
  {
    if (lpszSlash[1] == '\\')
      lpszSlash++;
    return lpszSlash + 1;
  }
  return (LPWSTR)lpszPath + strlenW(lpszPath);
}

Referenced by ChildWndProc(), FILEDLG95_ValidatePathAction(), PathRelativePathToW(), and Test_GetDisplayNameOf().

PathFindOnPathA()

BOOL WINAPI PathFindOnPathA	(	LPSTR	lpszFile,
		LPCSTR *	lppszOtherDirs
	)

Definition at line 1398 of file path.c.

{
  TRACE("(%s,%p)\n", debugstr_a(lpszFile), lppszOtherDirs);
  return PathFindOnPathExA(lpszFile, lppszOtherDirs, 0);
 }

PathFindOnPathExA()

BOOL WINAPI PathFindOnPathExA	(	LPSTR	lpszFile,
		LPCSTR *	lppszOtherDirs,
		DWORD	dwWhich
	)

Definition at line 1313 of file path.c.

{
  WCHAR szFile[MAX_PATH];
  WCHAR buff[MAX_PATH];
 
  TRACE("(%s,%p,%08x)\n", debugstr_a(lpszFile), lppszOtherDirs, dwWhich);
 
  if (!lpszFile || !PathIsFileSpecA(lpszFile))
    return FALSE;
 
  MultiByteToWideChar(CP_ACP,0,lpszFile,-1,szFile,MAX_PATH);
 
  /* Search provided directories first */
  if (lppszOtherDirs && *lppszOtherDirs)
  {
    WCHAR szOther[MAX_PATH];
    LPCSTR *lpszOtherPath = lppszOtherDirs;
 
    while (lpszOtherPath && *lpszOtherPath && (*lpszOtherPath)[0])
    {
      MultiByteToWideChar(CP_ACP,0,*lpszOtherPath,-1,szOther,MAX_PATH);
      PathCombineW(buff, szOther, szFile);
      if (PathFileExistsDefExtW(buff, dwWhich))
      {
        WideCharToMultiByte(CP_ACP,0,buff,-1,lpszFile,MAX_PATH,0,0);
        return TRUE;
      }
      lpszOtherPath++;
    }
  }
  /* Not found, try system and path dirs */
  if (SHLWAPI_PathFindInOtherDirs(szFile, dwWhich))
  {
    WideCharToMultiByte(CP_ACP,0,szFile,-1,lpszFile,MAX_PATH,0,0);
    return TRUE;
  }
  return FALSE;
}

Referenced by PathFindOnPathA().

PathFindOnPathExW()

BOOL WINAPI PathFindOnPathExW	(	LPWSTR	lpszFile,
		LPCWSTR *	lppszOtherDirs,
		DWORD	dwWhich
	)

Definition at line 1357 of file path.c.

{
  WCHAR buff[MAX_PATH];
 
  TRACE("(%s,%p,%08x)\n", debugstr_w(lpszFile), lppszOtherDirs, dwWhich);
 
  if (!lpszFile || !PathIsFileSpecW(lpszFile))
    return FALSE;
 
  /* Search provided directories first */
  if (lppszOtherDirs && *lppszOtherDirs)
  {
    LPCWSTR *lpszOtherPath = lppszOtherDirs;
    while (lpszOtherPath && *lpszOtherPath && (*lpszOtherPath)[0])
    {
      PathCombineW(buff, *lpszOtherPath, lpszFile);
      if (PathFileExistsDefExtW(buff, dwWhich))
      {
        strcpyW(lpszFile, buff);
        return TRUE;
      }
      lpszOtherPath++;
    }
  }
  /* Not found, try system and path dirs */
  return SHLWAPI_PathFindInOtherDirs(lpszFile, dwWhich);
}

Referenced by PathFindOnPathW(), PathSearchOnExtensionsW(), ShellExecCmdLine(), and WelcomeDlgProc().

PathFindOnPathW()

BOOL WINAPI PathFindOnPathW	(	LPWSTR	lpszFile,
		LPCWSTR *	lppszOtherDirs
	)

Definition at line 1409 of file path.c.

{
  TRACE("(%s,%p)\n", debugstr_w(lpszFile), lppszOtherDirs);
  return PathFindOnPathExW(lpszFile,lppszOtherDirs, 0);
}

Referenced by DoEntry(), PathResolveW(), and SHELL_FindExecutable().

PathFindSuffixArrayA()

LPCSTR WINAPI PathFindSuffixArrayA	(	LPCSTR	lpszSuffix,
		LPCSTR *	lppszArray,
		int	dwCount
	)

Definition at line 3999 of file path.c.

{
  size_t dwLen;
  int dwRet = 0;
 
  TRACE("(%s,%p,%d)\n",debugstr_a(lpszSuffix), lppszArray, dwCount);
 
  if (lpszSuffix && lppszArray && dwCount > 0)
  {
    dwLen = strlen(lpszSuffix);
 
    while (dwRet < dwCount)
    {
      size_t dwCompareLen = strlen(*lppszArray);
      if (dwCompareLen < dwLen)
      {
        if (!strcmp(lpszSuffix + dwLen - dwCompareLen, *lppszArray))
          return *lppszArray; /* Found */
      }
      dwRet++;
      lppszArray++;
    }
  }
  return NULL;
}

PathFindSuffixArrayW()

LPCWSTR WINAPI PathFindSuffixArrayW	(	LPCWSTR	lpszSuffix,
		LPCWSTR *	lppszArray,
		int	dwCount
	)

Definition at line 4030 of file path.c.

{
  size_t dwLen;
  int dwRet = 0;
 
  TRACE("(%s,%p,%d)\n",debugstr_w(lpszSuffix), lppszArray, dwCount);
 
  if (lpszSuffix && lppszArray && dwCount > 0)
  {
    dwLen = strlenW(lpszSuffix);
 
    while (dwRet < dwCount)
    {
      size_t dwCompareLen = strlenW(*lppszArray);
      if (dwCompareLen < dwLen)
      {
        if (!strcmpW(lpszSuffix + dwLen - dwCompareLen, *lppszArray))
          return *lppszArray; /* Found */
      }
      dwRet++;
      lppszArray++;
    }
  }
  return NULL;
}

PathGetArgsA()

LPSTR WINAPI PathGetArgsA

(

LPCSTR

lpszPath

)

Definition at line 481 of file path.c.

{
  BOOL bSeenQuote = FALSE;
 
  TRACE("(%s)\n",debugstr_a(lpszPath));
 
  if (lpszPath)
  {
    while (*lpszPath)
    {
      if ((*lpszPath==' ') && !bSeenQuote)
        return (LPSTR)lpszPath + 1;
      if (*lpszPath == '"')
        bSeenQuote = !bSeenQuote;
      lpszPath = CharNextA(lpszPath);
    }
  }
  return (LPSTR)lpszPath;
}

Referenced by PathRemoveArgsA().

PathGetArgsW()

LPWSTR WINAPI PathGetArgsW

(

LPCWSTR

lpszPath

)

Definition at line 506 of file path.c.

{
  BOOL bSeenQuote = FALSE;
 
  TRACE("(%s)\n",debugstr_w(lpszPath));
 
  if (lpszPath)
  {
    while (*lpszPath)
    {
      if ((*lpszPath==' ') && !bSeenQuote)
        return (LPWSTR)lpszPath + 1;
      if (*lpszPath == '"')
        bSeenQuote = !bSeenQuote;
      lpszPath++;
    }
  }
  return (LPWSTR)lpszPath;
}

Referenced by RunOnceExEntry::Exec(), CAddressEditBox::ExecuteCommandLine(), CDrvDefExt::GeneralPageProc(), LanguagesPageProc(), CShellLink::OnNotify(), PathRemoveArgsW(), SHELL_execute(), SHELL_translate_idlist(), ShellExec_RunDLL_Helper(), SHExplorerParseCmdLine(), and WelcomeDlgProc().

PathGetCharTypeA()

UINT WINAPI PathGetCharTypeA

(

UCHAR

ch

)

Definition at line 3032 of file path.c.

{
  return PathGetCharTypeW(ch);
}

Referenced by PathCleanupSpec().

PathGetCharTypeW()

UINT WINAPI PathGetCharTypeW

(

WCHAR

ch

)

Definition at line 3042 of file path.c.

{
  UINT flags = 0;
 
  TRACE("(%d)\n", ch);
 
  if (!ch || ch < ' ' || ch == '<' || ch == '>' ||
      ch == '"' || ch == '|' || ch == '/')
    flags = GCT_INVALID; /* Invalid */
  else if (ch == '*' || ch=='?')
    flags = GCT_WILD; /* Wildchars */
  else if ((ch == '\\') || (ch == ':'))
    return GCT_SEPARATOR; /* Path separators */
  else
  {
     if (ch < 126)
     {
         if (((ch & 0x1) && ch != ';') || !ch || isalnum(ch) || ch == '$' || ch == '&' || ch == '(' ||
            ch == '.' || ch == '@' || ch == '^' ||
            ch == '\'' || ch == 130 || ch == '`')
         flags |= GCT_SHORTCHAR; /* All these are valid for DOS */
     }
     else
       flags |= GCT_SHORTCHAR; /* Bug compatible with win32 */
     flags |= GCT_LFNCHAR; /* Valid for long file names */
  }
  return flags;
}

Referenced by PathCleanupSpec(), and PathGetCharTypeA().

PathGetDriveNumberA()

int WINAPI PathGetDriveNumberA

(

LPCSTR

lpszPath

)

Definition at line 538 of file path.c.

{
  TRACE ("(%s)\n",debugstr_a(lpszPath));
 
  if (lpszPath && !IsDBCSLeadByte(*lpszPath) && lpszPath[1] == ':' &&
      tolower(*lpszPath) >= 'a' && tolower(*lpszPath) <= 'z')
    return tolower(*lpszPath) - 'a';
  return -1;
}

Referenced by ATL::CPathT< StringType >::PathGetDriveNumberX(), PathIsNetworkPathA(), and test_PathGetDriveNumber().

PathGetDriveNumberW()

int WINAPI PathGetDriveNumberW

(

const WCHAR *

path

)

Definition at line 553 of file path.c.

{
    WCHAR drive;
 
    static const WCHAR nt_prefixW[] = {'\\','\\','?','\\'};
 
    TRACE("(%s)\n", debugstr_w(path));
 
    if (!path)
        return -1;
 
    if (!strncmpW(path, nt_prefixW, 4))
        path += 4;
 
    drive = tolowerW(path[0]);
    if (drive < 'a' || drive > 'z' || path[1] != ':')
        return -1;
 
    return drive - 'a';
}

Referenced by COMDLG32_GetCanonicalPath(), GetDefaultRecycleDriveNumber(), GetItemDriveNumber(), ATL::CPathT< StringType >::PathGetDriveNumberX(), PathIsAbsoluteW(), PathIsDriveRoot(), PathIsNetworkPathW(), PathIsOnDrive(), PathIsSameDrive(), PathQualifyExW(), SHChangeNotify(), SHELL_execute(), SHIsRemovableDrive(), and test_PathGetDriveNumber().

PathIsContentTypeA()

BOOL WINAPI PathIsContentTypeA	(	LPCSTR	lpszPath,
		LPCSTR	lpszContentType
	)

Definition at line 2064 of file path.c.

{
  LPCSTR szExt;
  DWORD dwDummy;
  char szBuff[MAX_PATH];
 
  TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszContentType));
 
  if (lpszPath && (szExt = PathFindExtensionA(lpszPath)) && *szExt &&
      !SHGetValueA(HKEY_CLASSES_ROOT, szExt, "Content Type",
                   REG_NONE, szBuff, &dwDummy) &&
      !strcasecmp(lpszContentType, szBuff))
  {
    return TRUE;
  }
  return FALSE;
}

PathIsContentTypeW()

BOOL WINAPI PathIsContentTypeW	(	LPCWSTR	lpszPath,
		LPCWSTR	lpszContentType
	)

Definition at line 2087 of file path.c.

{
  static const WCHAR szContentType[] = { 'C','o','n','t','e','n','t',' ','T','y','p','e','\0' };
  LPCWSTR szExt;
  DWORD dwDummy;
  WCHAR szBuff[MAX_PATH];
 
  TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszContentType));
 
  if (lpszPath && (szExt = PathFindExtensionW(lpszPath)) && *szExt &&
      !SHGetValueW(HKEY_CLASSES_ROOT, szExt, szContentType,
                   REG_NONE, szBuff, &dwDummy) &&
      !strcmpiW(lpszContentType, szBuff))
  {
    return TRUE;
  }
  return FALSE;
}

PathIsDirectoryA()

BOOL WINAPI PathIsDirectoryA

(

LPCSTR

lpszPath

)

Definition at line 1704 of file path.c.

{
  DWORD dwAttr;
 
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (!lpszPath || PathIsUNCServerA(lpszPath))
    return FALSE;
 
  if (PathIsUNCServerShareA(lpszPath))
  {
    FIXME("UNC Server Share not yet supported - FAILING\n");
    return FALSE;
  }
 
  if ((dwAttr = GetFileAttributesA(lpszPath)) == INVALID_FILE_ATTRIBUTES)
    return FALSE;
  return dwAttr & FILE_ATTRIBUTE_DIRECTORY;
}

Referenced by ATL::CPathT< StringType >::PathIsDirectoryX().

PathIsDirectoryEmptyA()

BOOL WINAPI PathIsDirectoryEmptyA

(

LPCSTR

lpszPath

)

Definition at line 3917 of file path.c.

{
  BOOL bRet = FALSE;
 
  TRACE("(%s)\n",debugstr_a(lpszPath));
 
  if (lpszPath)
  {
    WCHAR szPath[MAX_PATH];
    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
    bRet = PathIsDirectoryEmptyW(szPath);
  }
  return bRet;
}

PathIsDirectoryEmptyW()

BOOL WINAPI PathIsDirectoryEmptyW

(

LPCWSTR

lpszPath

)

Definition at line 3937 of file path.c.

{
  static const WCHAR szAllFiles[] = { '*', '.', '*', '\0' };
  WCHAR szSearch[MAX_PATH];
  DWORD dwLen;
  HANDLE hfind;
  BOOL retVal = TRUE;
  WIN32_FIND_DATAW find_data;
 
  TRACE("(%s)\n",debugstr_w(lpszPath));
 
  if (!lpszPath || !PathIsDirectoryW(lpszPath))
    return FALSE;
 
  lstrcpynW(szSearch, lpszPath, MAX_PATH);
  PathAddBackslashW(szSearch);
  dwLen = strlenW(szSearch);
  if (dwLen > MAX_PATH - 4)
    return FALSE;
 
  strcpyW(szSearch + dwLen, szAllFiles);
  hfind = FindFirstFileW(szSearch, &find_data);
  if (hfind == INVALID_HANDLE_VALUE)
    return FALSE;
 
  do
  {
    if (find_data.cFileName[0] == '.')
    {
      if (find_data.cFileName[1] == '\0') continue;
      if (find_data.cFileName[1] == '.' && find_data.cFileName[2] == '\0') continue;
    }
 
    retVal = FALSE;
    break;
  }
  while (FindNextFileW(hfind, &find_data));
 
  FindClose(hfind);
  return retVal;
}

Referenced by move_dir_to_dir(), and PathIsDirectoryEmptyA().

PathIsDirectoryW()

BOOL WINAPI PathIsDirectoryW

(

LPCWSTR

lpszPath

)

Definition at line 1729 of file path.c.

{
  DWORD dwAttr;
 
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (!lpszPath || PathIsUNCServerW(lpszPath))
    return FALSE;
 
  if (PathIsUNCServerShareW(lpszPath))
  {
    FIXME("UNC Server Share not yet supported - FAILING\n");
    return FALSE;
  }
 
  if ((dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES)
    return FALSE;
  return dwAttr & FILE_ATTRIBUTE_DIRECTORY;
}

Referenced by CDirectoryList::AddPathsFromDirectory(), BrFolder_OnOK(), copy_file(), create_target_directory(), CreateDirectoryWatcherFromRegEntry(), DetermineDialogBoxType(), CAppScrnshotPreview::DisplayImage(), DoAddFilesFromItem(), DoBuildFilesAndDirs(), DoTestEntry(), CDeskLinkDropHandler::Drop(), CAddressEditBox::ExecuteCommandLine(), FILEDLG95_InitControls(), CFSFolder::GetCustomViewInfo(), getIconLocationForDrive(), getIconLocationForFolder(), getLabelForDriveFromAutoRun(), CFileDefExt::Initialize(), InstallFontFiles(), PathIsDirectoryEmptyW(), ATL::CPathT< StringType >::PathIsDirectoryX(), CDirectoryWatcher::ProcessNotification(), SHAddToRecentDocs(), SHELL_execute(), SHExplorerParseCmdLine(), ShowCreateShortcutWizard(), WindowProc(), and wWinMain().

PathIsFileSpecA()

BOOL WINAPI PathIsFileSpecA

(

LPCSTR

lpszPath

)

Definition at line 2118 of file path.c.

{
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (!lpszPath)
    return FALSE;
 
  while (*lpszPath)
  {
    if (*lpszPath == '\\' || *lpszPath == ':')
      return FALSE;
    lpszPath = CharNextA(lpszPath);
  }
  return TRUE;
}

Referenced by PathFindOnPathExA(), and ATL::CPathT< StringType >::PathIsFileSpecX().

PathIsFileSpecW()

BOOL WINAPI PathIsFileSpecW

(

LPCWSTR

lpszPath

)

Definition at line 2139 of file path.c.

{
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (!lpszPath)
    return FALSE;
 
  while (*lpszPath)
  {
    if (*lpszPath == '\\' || *lpszPath == ':')
      return FALSE;
    lpszPath++;
  }
  return TRUE;
}

Referenced by Control_LoadApplet(), PathFindOnPathExW(), ATL::CPathT< StringType >::PathIsFileSpecX(), PathResolveW(), and CShellLink::SetTargetFromPIDLOrPath().

PathIsLFNFileSpecA()

BOOL WINAPI PathIsLFNFileSpecA

(

LPCSTR

lpszPath

)

Definition at line 3828 of file path.c.

{
  DWORD dwNameLen = 0, dwExtLen = 0;
 
  TRACE("(%s)\n",debugstr_a(lpszPath));
 
  if (!lpszPath)
    return FALSE;
 
  while (*lpszPath)
  {
    if (*lpszPath == ' ')
      return TRUE; /* DOS names cannot have spaces */
    if (*lpszPath == '.')
    {
      if (dwExtLen)
        return TRUE; /* DOS names have only one dot */
      dwExtLen = 1;
    }
    else if (dwExtLen)
    {
      dwExtLen++;
      if (dwExtLen > 4)
        return TRUE; /* DOS extensions are <= 3 chars*/
    }
    else
    {
      dwNameLen++;
      if (dwNameLen > 8)
        return TRUE; /* DOS names are <= 8 chars */
    }
    lpszPath += IsDBCSLeadByte(*lpszPath) ? 2 : 1;
  }
  return FALSE; /* Valid DOS path */
}

PathIsLFNFileSpecW()

BOOL WINAPI PathIsLFNFileSpecW

(

LPCWSTR

lpszPath

)

Definition at line 3869 of file path.c.

{
  DWORD dwNameLen = 0, dwExtLen = 0;
 
  TRACE("(%s)\n",debugstr_w(lpszPath));
 
  if (!lpszPath)
    return FALSE;
 
  while (*lpszPath)
  {
    if (*lpszPath == ' ')
      return TRUE; /* DOS names cannot have spaces */
    if (*lpszPath == '.')
    {
      if (dwExtLen)
        return TRUE; /* DOS names have only one dot */
      dwExtLen = 1;
    }
    else if (dwExtLen)
    {
      dwExtLen++;
      if (dwExtLen > 4)
        return TRUE; /* DOS extensions are <= 3 chars*/
    }
    else
    {
      dwNameLen++;
      if (dwNameLen > 8)
        return TRUE; /* DOS names are <= 8 chars */
    }
    lpszPath++;
  }
  return FALSE; /* Valid DOS path */
}

PathIsNetworkPathA()

BOOL WINAPI PathIsNetworkPathA

(

LPCSTR

lpszPath

)

Definition at line 3769 of file path.c.

{
  int dwDriveNum;
 
  TRACE("(%s)\n",debugstr_a(lpszPath));
 
  if (!lpszPath)
    return FALSE;
  if (*lpszPath == '\\' && lpszPath[1] == '\\')
    return TRUE;
  dwDriveNum = PathGetDriveNumberA(lpszPath);
  if (dwDriveNum == -1)
    return FALSE;
#ifdef __REACTOS__
  return IsNetDrive(dwDriveNum);
#else
  GET_FUNC(pIsNetDrive, shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
  return pIsNetDrive(dwDriveNum);
#endif
}

PathIsNetworkPathW()

BOOL WINAPI PathIsNetworkPathW

(

LPCWSTR

lpszPath

)

Definition at line 3795 of file path.c.

{
  int dwDriveNum;
 
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (!lpszPath)
    return FALSE;
  if (*lpszPath == '\\' && lpszPath[1] == '\\')
    return TRUE;
  dwDriveNum = PathGetDriveNumberW(lpszPath);
  if (dwDriveNum == -1)
    return FALSE;
#ifdef __REACTOS__
  return IsNetDrive(dwDriveNum);
#else
  GET_FUNC(pIsNetDrive, shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
  return pIsNetDrive(dwDriveNum);
#endif
}

PathIsPrefixA()

BOOL WINAPI PathIsPrefixA	(	LPCSTR	lpszPrefix,
		LPCSTR	lpszPath
	)

Definition at line 2168 of file path.c.

{
  TRACE("(%s,%s)\n", debugstr_a(lpszPrefix), debugstr_a(lpszPath));
 
  if (lpszPrefix && lpszPath &&
      PathCommonPrefixA(lpszPath, lpszPrefix, NULL) == (int)strlen(lpszPrefix))
    return TRUE;
  return FALSE;
}

Referenced by ATL::CPathT< StringType >::PathIsPrefixX().

PathIsPrefixW()

BOOL WINAPI PathIsPrefixW	(	LPCWSTR	lpszPrefix,
		LPCWSTR	lpszPath
	)

Definition at line 2183 of file path.c.

{
  TRACE("(%s,%s)\n", debugstr_w(lpszPrefix), debugstr_w(lpszPath));
 
  if (lpszPrefix && lpszPath &&
      PathCommonPrefixW(lpszPath, lpszPrefix, NULL) == (int)strlenW(lpszPrefix))
    return TRUE;
  return FALSE;
}

Referenced by ATL::CPathT< StringType >::PathIsPrefixX().

PathIsRelativeA()

BOOL WINAPI PathIsRelativeA

(

LPCSTR

lpszPath

)

Definition at line 1569 of file path.c.

{
  TRACE("(%s)\n",debugstr_a(lpszPath));
 
  if (!lpszPath || !*lpszPath || IsDBCSLeadByte(*lpszPath))
    return TRUE;
  if (*lpszPath == '\\' || (*lpszPath && lpszPath[1] == ':'))
    return FALSE;
  return TRUE;
}

Referenced by ATL::CPathT< StringType >::PathIsRelativeX(), and TestGetModuleFileNameA().

PathIsRelativeW()

BOOL WINAPI PathIsRelativeW

(

LPCWSTR

lpszPath

)

Definition at line 1585 of file path.c.

{
  TRACE("(%s)\n",debugstr_w(lpszPath));
 
  if (!lpszPath || !*lpszPath)
    return TRUE;
  if (*lpszPath == '\\' || (*lpszPath && lpszPath[1] == ':'))
    return FALSE;
  return TRUE;
}

Referenced by CDirectoryList::AddPath(), CDirectoryList::AddPathsFromDirectory(), BrFolder_OnOK(), COMDLG32_GetCanonicalPath(), CDirectoryList::ContainsPath(), CDirectoryList::DeletePath(), dialog_verify_path(), CACListISF::Expand(), CFontCache::Filename(), CFSFolder::GetCustomViewInfo(), getIconLocationForDrive(), getIconLocationForFolder(), msi_apply_transforms(), MSI_OpenProductW(), OpenColorProfileW(), parse_file_list(), PathCombineW(), ATL::CPathT< StringType >::PathIsRelativeX(), PathProcessCommandW(), CDirectoryWatcher::ProcessNotification(), CDirectoryList::RenamePath(), SHCreateDirectoryExW(), ShellExecCmdLine(), SHGetFileInfoW(), Test_GetDisplayNameOf(), TestGetModuleFileNameW(), and WelcomeDlgProc().

PathIsRootA()

BOOL WINAPI PathIsRootA

(

LPCSTR

lpszPath

)

Definition at line 1608 of file path.c.

{
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (lpszPath && *lpszPath)
  {
    if (*lpszPath == '\\')
    {
      if (!lpszPath[1])
        return TRUE; /* \ */
      else if (lpszPath[1]=='\\')
      {
        BOOL bSeenSlash = FALSE;
        lpszPath += 2;
 
        /* Check for UNC root path */
        while (*lpszPath)
        {
          if (*lpszPath == '\\')
          {
            if (bSeenSlash)
              return FALSE;
            bSeenSlash = TRUE;
          }
          lpszPath = CharNextA(lpszPath);
        }
        return TRUE;
      }
    }
    else if (lpszPath[1] == ':' && lpszPath[2] == '\\' && lpszPath[3] == '\0')
      return TRUE; /* X:\ */
  }
  return FALSE;
}

Referenced by PathIsRootAW(), ATL::CPathT< StringType >::PathIsRootX(), PathRemoveBackslashA(), PathStripToRootA(), and START_TEST().

PathIsRootW()

BOOL WINAPI PathIsRootW

(

LPCWSTR

lpszPath

)

Definition at line 1648 of file path.c.

{
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (lpszPath && *lpszPath)
  {
    if (*lpszPath == '\\')
    {
      if (!lpszPath[1])
        return TRUE; /* \ */
      else if (lpszPath[1]=='\\')
      {
        BOOL bSeenSlash = FALSE;
        lpszPath += 2;
 
        /* Check for UNC root path */
        while (*lpszPath)
        {
          if (*lpszPath == '\\')
          {
            if (bSeenSlash)
              return FALSE;
            bSeenSlash = TRUE;
          }
          lpszPath++;
        }
        return TRUE;
      }
    }
    else if (lpszPath[1] == ':' && lpszPath[2] == '\\' && lpszPath[3] == '\0')
      return TRUE; /* X:\ */
  }
  return FALSE;
}

Referenced by _ILCreate(), IsDriveFloppyW(), PathIsDriveRoot(), PathIsRootAW(), ATL::CPathT< StringType >::PathIsRootX(), PathRemoveBackslashW(), PathResolveW(), PathStripToRootW(), and SHGetFileInfoW().

PathIsSameRootA()

BOOL WINAPI PathIsSameRootA	(	LPCSTR	lpszPath1,
		LPCSTR	lpszPath2
	)

Definition at line 2009 of file path.c.

{
  LPCSTR lpszStart;
  int dwLen;
 
  TRACE("(%s,%s)\n", debugstr_a(lpszPath1), debugstr_a(lpszPath2));
 
  if (!lpszPath1 || !lpszPath2 || !(lpszStart = PathSkipRootA(lpszPath1)))
    return FALSE;
 
  dwLen = PathCommonPrefixA(lpszPath1, lpszPath2, NULL) + 1;
  if (lpszStart - lpszPath1 > dwLen)
    return FALSE; /* Paths not common up to length of the root */
  return TRUE;
}

Referenced by ATL::CPathT< StringType >::PathIsSameRootX().

PathIsSameRootW()

BOOL WINAPI PathIsSameRootW	(	LPCWSTR	lpszPath1,
		LPCWSTR	lpszPath2
	)

Definition at line 2030 of file path.c.

{
  LPCWSTR lpszStart;
  int dwLen;
 
  TRACE("(%s,%s)\n", debugstr_w(lpszPath1), debugstr_w(lpszPath2));
 
  if (!lpszPath1 || !lpszPath2 || !(lpszStart = PathSkipRootW(lpszPath1)))
    return FALSE;
 
  dwLen = PathCommonPrefixW(lpszPath1, lpszPath2, NULL) + 1;
  if (lpszStart - lpszPath1 > dwLen)
    return FALSE; /* Paths not common up to length of the root */
  return TRUE;
}

Referenced by ATL::CPathT< StringType >::PathIsSameRootX().

PathIsSystemFolderA()

BOOL WINAPI PathIsSystemFolderA	(	LPCSTR	lpszPath,
		DWORD	dwAttrib
	)

Definition at line 2206 of file path.c.

{
  TRACE("(%s,0x%08x)\n", debugstr_a(lpszPath), dwAttrib);
 
  if (lpszPath && *lpszPath)
    dwAttrib = GetFileAttributesA(lpszPath);
 
  if (dwAttrib == INVALID_FILE_ATTRIBUTES || !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY) ||
      !(dwAttrib & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
    return FALSE;
  return TRUE;
}

PathIsSystemFolderW()

BOOL WINAPI PathIsSystemFolderW	(	LPCWSTR	lpszPath,
		DWORD	dwAttrib
	)

Definition at line 2224 of file path.c.

{
  TRACE("(%s,0x%08x)\n", debugstr_w(lpszPath), dwAttrib);
 
  if (lpszPath && *lpszPath)
    dwAttrib = GetFileAttributesW(lpszPath);
 
  if (dwAttrib == INVALID_FILE_ATTRIBUTES || !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY) ||
      !(dwAttrib & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
    return FALSE;
  return TRUE;
}

Referenced by CViewStatePropertyBag::_IsSystemFolder().

PathIsUNCA()

BOOL WINAPI PathIsUNCA

(

LPCSTR

lpszPath

)

Definition at line 2249 of file path.c.

{
  TRACE("(%s)\n",debugstr_a(lpszPath));
 
/*
 * On Windows 2003, tests show that strings starting with "\\?" are
 * considered UNC, while on Windows Vista+ this is not the case anymore.
 */
// #ifdef __REACTOS__
#if (_WIN32_WINNT >= _WIN32_WINNT_VISTA)
  if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\') && (lpszPath[2]!='?'))
#else
  if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'))
#endif
    return TRUE;
  return FALSE;
}

Referenced by PathAppendA(), PathCommonPrefixA(), and ATL::CPathT< StringType >::PathIsUNCX().

PathIsUNCServerA()

BOOL WINAPI PathIsUNCServerA

(

LPCSTR

lpszPath

)

Definition at line 2307 of file path.c.

{
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
  {
    while (*lpszPath)
    {
      if (*lpszPath == '\\')
        return FALSE;
      lpszPath = CharNextA(lpszPath);
    }
    return TRUE;
  }
  return FALSE;
}

Referenced by PathIsDirectoryA(), and ATL::CPathT< StringType >::PathIsUNCServerX().

PathIsUNCServerShareA()

BOOL WINAPI PathIsUNCServerShareA

(

LPCSTR

lpszPath

)

Definition at line 2357 of file path.c.

{
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
  {
    BOOL bSeenSlash = FALSE;
    while (*lpszPath)
    {
      if (*lpszPath == '\\')
      {
        if (bSeenSlash)
          return FALSE;
        bSeenSlash = TRUE;
      }
      lpszPath = CharNextA(lpszPath);
    }
    return bSeenSlash;
  }
  return FALSE;
}

Referenced by PathIsDirectoryA(), and ATL::CPathT< StringType >::PathIsUNCServerShareX().

PathIsUNCServerShareW()

BOOL WINAPI PathIsUNCServerShareW

(

LPCWSTR

lpszPath

)

Definition at line 2384 of file path.c.

{
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
  {
    BOOL bSeenSlash = FALSE;
    while (*lpszPath)
    {
      if (*lpszPath == '\\')
      {
        if (bSeenSlash)
          return FALSE;
        bSeenSlash = TRUE;
      }
      lpszPath++;
    }
    return bSeenSlash;
  }
  return FALSE;
}

Referenced by PathCanonicalizeW(), PathFileExistsDefExtW(), PathIsDirectoryW(), and ATL::CPathT< StringType >::PathIsUNCServerShareX().

PathIsUNCServerW()

BOOL WINAPI PathIsUNCServerW

(

LPCWSTR

lpszPath

)

Definition at line 2329 of file path.c.

{
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (lpszPath && lpszPath[0] == '\\' && lpszPath[1] == '\\')
  {
      return !strchrW( lpszPath + 2, '\\' );
  }
  return FALSE;
}

Referenced by PathFileExistsDefExtW(), PathIsDirectoryW(), and ATL::CPathT< StringType >::PathIsUNCServerX().

PathIsUNCW()

BOOL WINAPI PathIsUNCW

(

LPCWSTR

lpszPath

)

Definition at line 2272 of file path.c.

{
  TRACE("(%s)\n",debugstr_w(lpszPath));
 
/*
 * On Windows 2003, tests show that strings starting with "\\?" are
 * considered UNC, while on Windows Vista+ this is not the case anymore.
 */
// #ifdef __REACTOS__
#if (_WIN32_WINNT >= _WIN32_WINNT_VISTA)
  if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\') && (lpszPath[2]!='?'))
#else
  if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'))
#endif
    return TRUE;
  return FALSE;
}

Referenced by _ILIsNetworkPlace(), CDesktopFolder::_ParseDisplayNameByParent(), IsLFNDriveW(), PathAppendW(), PathCombineW(), PathCommonPrefixW(), PathIsAbsoluteW(), PathIsOnUnc(), ATL::CPathT< StringType >::PathIsUNCX(), and PathQualifyExW().

PathIsValidCharA()

BOOL WINAPI PathIsValidCharA	(	char	c,
		DWORD	class
	)

Definition at line 4396 of file path.c.

{
    if ((unsigned)c > 0x7e)
        return class & PATH_CHAR_CLASS_OTHER_VALID;
 
    return class & SHELL_charclass[(unsigned)c];
}

PathIsValidCharW()

BOOL WINAPI PathIsValidCharW	(	WCHAR	c,
		DWORD	class
	)

Definition at line 4409 of file path.c.

{
    if (c > 0x7e)
        return class & PATH_CHAR_CLASS_OTHER_VALID;
 
    return class & SHELL_charclass[c];
}

Referenced by PathIsValidElement(), PathQualifyExW(), SHDOCVW_PathDeleteInvalidChars(), and UrlUnescapeAndMakeFileNameValid().

PathMakePrettyA()

BOOL WINAPI PathMakePrettyA

(

LPSTR

lpszPath

)

Definition at line 2674 of file path.c.

{
  LPSTR pszIter = lpszPath;
 
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (!pszIter)
    return FALSE;
 
  if (*pszIter)
  {
    do
    {
      if (islower(*pszIter) || IsDBCSLeadByte(*pszIter))
        return FALSE; /* Not DOS path */
      pszIter++;
    } while (*pszIter);
    pszIter = lpszPath + 1;
    while (*pszIter)
    {
      *pszIter = tolower(*pszIter);
      pszIter++;
    }
  }
  return TRUE;
}

Referenced by ATL::CPathT< StringType >::PathMakePrettyX(), and test_PathMakePretty().

PathMakePrettyW()

BOOL WINAPI PathMakePrettyW

(

LPWSTR

lpszPath

)

Definition at line 2706 of file path.c.

{
  LPWSTR pszIter = lpszPath;
 
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (!pszIter)
    return FALSE;
 
  if (*pszIter)
  {
    do
    {
      if (islowerW(*pszIter))
        return FALSE; /* Not DOS path */
      pszIter++;
    } while (*pszIter);
    pszIter = lpszPath + 1;
    while (*pszIter)
    {
      *pszIter = tolowerW(*pszIter);
      pszIter++;
    }
  }
  return TRUE;
}

Referenced by ATL::CPathT< StringType >::PathMakePrettyX().

PathMakeSystemFolderA()

BOOL WINAPI PathMakeSystemFolderA

(

LPCSTR

lpszPath

)

Definition at line 3106 of file path.c.

{
  BOOL bRet = FALSE;
 
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (lpszPath && *lpszPath)
  {
    WCHAR szPath[MAX_PATH];
    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
    bRet = PathMakeSystemFolderW(szPath);
  }
  return bRet;
}

PathMakeSystemFolderW()

BOOL WINAPI PathMakeSystemFolderW

(

LPCWSTR

lpszPath

)

Definition at line 3126 of file path.c.

{
  DWORD dwDefaultAttr = FILE_ATTRIBUTE_READONLY, dwAttr;
  WCHAR buff[MAX_PATH];
 
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (!lpszPath || !*lpszPath)
    return FALSE;
 
  /* If the directory is already a system directory, don't do anything */
  GetSystemDirectoryW(buff, MAX_PATH);
  if (!strcmpW(buff, lpszPath))
    return TRUE;
 
  GetWindowsDirectoryW(buff, MAX_PATH);
  if (!strcmpW(buff, lpszPath))
    return TRUE;
 
  /* "UseSystemForSystemFolders" Tells Win what attributes to use */
  if (SHLWAPI_UseSystemForSystemFolders())
    dwDefaultAttr = FILE_ATTRIBUTE_SYSTEM;
 
  if ((dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES)
    return FALSE;
 
  /* Change file attributes to system attributes */
  dwAttr &= ~(FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_READONLY);
  return SetFileAttributesW(lpszPath, dwAttr | dwDefaultAttr);
}

Referenced by PathMakeSystemFolderA(), and SHCreatePropertyBagOnProfileSection().

PathMatchSingleMaskA()

static BOOL PathMatchSingleMaskA ( LPCSTR  name, LPCSTR  mask  )

static

Definition at line 1859 of file path.c.

{
  while (*name && *mask && *mask!=';')
  {
    if (*mask == '*')
    {
      do
      {
        if (PathMatchSingleMaskA(name,mask+1))
          return TRUE;  /* try substrings */
      } while (*name++);
      return FALSE;
    }
 
    if (toupper(*mask) != toupper(*name) && *mask != '?')
      return FALSE;
 
    name = CharNextA(name);
    mask = CharNextA(mask);
  }
 
  if (!*name)
  {
    while (*mask == '*')
      mask++;
    if (!*mask || *mask == ';')
      return TRUE;
  }
  return FALSE;
}

Referenced by PathMatchSingleMaskA(), and PathMatchSpecA().

PathMatchSingleMaskW()

static BOOL PathMatchSingleMaskW ( LPCWSTR  name, LPCWSTR  mask  )

static

Definition at line 1893 of file path.c.

{
  while (*name && *mask && *mask != ';')
  {
    if (*mask == '*')
    {
      do
      {
        if (PathMatchSingleMaskW(name,mask+1))
          return TRUE;  /* try substrings */
      } while (*name++);
      return FALSE;
    }
 
    if (toupperW(*mask) != toupperW(*name) && *mask != '?')
      return FALSE;
 
    name++;
    mask++;
  }
  if (!*name)
  {
    while (*mask == '*')
      mask++;
    if (!*mask || *mask == ';')
      return TRUE;
  }
  return FALSE;
}

Referenced by PathMatchSingleMaskW(), and PathMatchSpecW().

PathMatchSpecA()

BOOL WINAPI PathMatchSpecA	(	LPCSTR	lpszPath,
		LPCSTR	lpszMask
	)

Definition at line 1941 of file path.c.

{
  TRACE("(%s,%s)\n", lpszPath, lpszMask);
 
  if (!lstrcmpA(lpszMask, "*.*"))
    return TRUE; /* Matches every path */
 
  while (*lpszMask)
  {
    while (*lpszMask == ' ')
      lpszMask++; /* Eat leading spaces */
 
    if (PathMatchSingleMaskA(lpszPath, lpszMask))
      return TRUE; /* Matches the current mask */
 
    while (*lpszMask && *lpszMask != ';')
      lpszMask = CharNextA(lpszMask); /* masks separated by ';' */
 
    if (*lpszMask == ';')
      lpszMask++;
  }
  return FALSE;
}

Referenced by ATL::CPathT< StringType >::PathMatchSpecX(), and test_PathMatchSpec().

PathMatchSpecW()

BOOL WINAPI PathMatchSpecW	(	LPCWSTR	lpszPath,
		LPCWSTR	lpszMask
	)

Definition at line 1970 of file path.c.

{
  static const WCHAR szStarDotStar[] = { '*', '.', '*', '\0' };
 
  TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszMask));
 
  if (!lstrcmpW(lpszMask, szStarDotStar))
    return TRUE; /* Matches every path */
 
  while (*lpszMask)
  {
    while (*lpszMask == ' ')
      lpszMask++; /* Eat leading spaces */
 
    if (PathMatchSingleMaskW(lpszPath, lpszMask))
      return TRUE; /* Matches the current path */
 
    while (*lpszMask && *lpszMask != ';')
      lpszMask++; /* masks separated by ';' */
 
    if (*lpszMask == ';')
      lpszMask++;
  }
  return FALSE;
}

Referenced by FileNameMatch(), FTP_ParseNextFile(), ICommDlgBrowser3_fnIncludeObject(), IShellBrowserImpl_ICommDlgBrowser_IncludeObject(), on_command_filetype(), and ATL::CPathT< StringType >::PathMatchSpecX().

PathParseIconLocationA()

int WINAPI PathParseIconLocationA

(

LPSTR

lpszPath

)

Definition at line 1073 of file path.c.

{
  int iRet = 0;
  LPSTR lpszComma;
 
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (lpszPath)
  {
    if ((lpszComma = strchr(lpszPath, ',')))
    {
      *lpszComma++ = '\0';
      iRet = StrToIntA(lpszComma);
    }
    PathUnquoteSpacesA(lpszPath);
    PathRemoveBlanksA(lpszPath);
  }
  return iRet;
}

PathParseIconLocationW()

int WINAPI PathParseIconLocationW

(

LPWSTR

lpszPath

)

Definition at line 1098 of file path.c.

{
  int iRet = 0;
  LPWSTR lpszComma;
 
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (lpszPath)
  {
    if ((lpszComma = StrChrW(lpszPath, ',')))
    {
      *lpszComma++ = '\0';
      iRet = StrToIntW(lpszComma);
    }
    PathUnquoteSpacesW(lpszPath);
    PathRemoveBlanksW(lpszPath);
  }
  return iRet;
}

Referenced by AsyncLoadIconProc(), GetFileTypeIconsEx(), getIconLocationForDrive(), getIconLocationForFolder(), and CFileDefExt::InitFolderCustomizePage().

PathQuoteSpacesA()

VOID WINAPI PathQuoteSpacesA

(

LPSTR

lpszPath

)

Definition at line 961 of file path.c.

{
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if(lpszPath && StrChrA(lpszPath,' '))
  {
    size_t iLen = strlen(lpszPath) + 1;
 
    if (iLen + 2 < MAX_PATH)
    {
      memmove(lpszPath + 1, lpszPath, iLen);
      lpszPath[0] = '"';
      lpszPath[iLen] = '"';
      lpszPath[iLen + 1] = '\0';
    }
  }
}

Referenced by ATL::CPathT< StringType >::PathQuoteSpacesX().

PathQuoteSpacesW()

VOID WINAPI PathQuoteSpacesW

(

LPWSTR

lpszPath

)

Definition at line 984 of file path.c.

{
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if(lpszPath && StrChrW(lpszPath,' '))
  {
    int iLen = strlenW(lpszPath) + 1;
 
    if (iLen + 2 < MAX_PATH)
    {
      memmove(lpszPath + 1, lpszPath, iLen * sizeof(WCHAR));
      lpszPath[0] = '"';
      lpszPath[iLen] = '"';
      lpszPath[iLen + 1] = '\0';
    }
  }
}

Referenced by ATL::CPathT< StringType >::PathQuoteSpacesX(), and RunFontViewer().

PathRelativePathToA()

BOOL WINAPI PathRelativePathToA	(	LPSTR	lpszPath,
		LPCSTR	lpszFrom,
		DWORD	dwAttrFrom,
		LPCSTR	lpszTo,
		DWORD	dwAttrTo
	)

Definition at line 3552 of file path.c.

{
  BOOL bRet = FALSE;
 
  TRACE("(%p,%s,0x%08x,%s,0x%08x)\n", lpszPath, debugstr_a(lpszFrom),
        dwAttrFrom, debugstr_a(lpszTo), dwAttrTo);
 
  if(lpszPath && lpszFrom && lpszTo)
  {
    WCHAR szPath[MAX_PATH];
    WCHAR szFrom[MAX_PATH];
    WCHAR szTo[MAX_PATH];
    MultiByteToWideChar(CP_ACP,0,lpszFrom,-1,szFrom,MAX_PATH);
    MultiByteToWideChar(CP_ACP,0,lpszTo,-1,szTo,MAX_PATH);
    bRet = PathRelativePathToW(szPath,szFrom,dwAttrFrom,szTo,dwAttrTo);
    WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
  }
  return bRet;
}

Referenced by ATL::CPathT< StringType >::PathRelativePathToX().

PathRelativePathToW()

BOOL WINAPI PathRelativePathToW	(	LPWSTR	lpszPath,
		LPCWSTR	lpszFrom,
		DWORD	dwAttrFrom,
		LPCWSTR	lpszTo,
		DWORD	dwAttrTo
	)

Definition at line 3578 of file path.c.

{
  static const WCHAR szPrevDirSlash[] = { '.', '.', '\\', '\0' };
  static const WCHAR szPrevDir[] = { '.', '.', '\0' };
  WCHAR szFrom[MAX_PATH];
  WCHAR szTo[MAX_PATH];
  DWORD dwLen;
 
  TRACE("(%p,%s,0x%08x,%s,0x%08x)\n", lpszPath, debugstr_w(lpszFrom),
        dwAttrFrom, debugstr_w(lpszTo), dwAttrTo);
 
  if(!lpszPath || !lpszFrom || !lpszTo)
    return FALSE;
 
  *lpszPath = '\0';
  lstrcpynW(szFrom, lpszFrom, MAX_PATH);
  lstrcpynW(szTo, lpszTo, MAX_PATH);
 
  if(!(dwAttrFrom & FILE_ATTRIBUTE_DIRECTORY))
    PathRemoveFileSpecW(szFrom);
  if(!(dwAttrTo & FILE_ATTRIBUTE_DIRECTORY))
    PathRemoveFileSpecW(szTo);
 
  /* Paths can only be relative if they have a common root */
  if(!(dwLen = PathCommonPrefixW(szFrom, szTo, 0)))
    return FALSE;
 
  /* Strip off lpszFrom components to the root, by adding "..\" */
  lpszFrom = szFrom + dwLen;
  if (!*lpszFrom)
  {
    lpszPath[0] = '.';
    lpszPath[1] = '\0';
  }
  if (*lpszFrom == '\\')
    lpszFrom++;
 
  while (*lpszFrom)
  {
    lpszFrom = PathFindNextComponentW(lpszFrom);
    strcatW(lpszPath, *lpszFrom ? szPrevDirSlash : szPrevDir);
  }
 
  /* From the root add the components of lpszTo */
  lpszTo += dwLen;
  /* We check lpszTo[-1] to avoid skipping end of string. See the notes for
   * this function.
   */
  if (*lpszTo && lpszTo[-1])
  {
    if (*lpszTo != '\\')
      lpszTo--;
    dwLen = strlenW(lpszPath);
    if (dwLen + strlenW(lpszTo) >= MAX_PATH)
    {
      *lpszPath = '\0';
      return FALSE;
    }
    strcpyW(lpszPath + dwLen, lpszTo);
  }
  return TRUE;
}

Referenced by PathRelativePathToA(), and ATL::CPathT< StringType >::PathRelativePathToX().

PathRemoveArgsA()

void WINAPI PathRemoveArgsA

(

LPSTR

lpszPath

)

Definition at line 756 of file path.c.

{
  TRACE("(%s)\n",debugstr_a(lpszPath));
 
  if(lpszPath)
  {
    LPSTR lpszArgs = PathGetArgsA(lpszPath);
    if (*lpszArgs)
      lpszArgs[-1] = '\0';
    else
    {
      LPSTR lpszLastChar = CharPrevA(lpszPath, lpszArgs);
      if(*lpszLastChar == ' ')
        *lpszLastChar = '\0';
    }
  }
}

Referenced by ATL::CPathT< StringType >::PathRemoveArgsX().

PathRemoveArgsW()

void WINAPI PathRemoveArgsW

(

LPWSTR

lpszPath

)

Definition at line 779 of file path.c.

{
  TRACE("(%s)\n",debugstr_w(lpszPath));
 
  if(lpszPath)
  {
    LPWSTR lpszArgs = PathGetArgsW(lpszPath);
    if (*lpszArgs || (lpszArgs > lpszPath && lpszArgs[-1] == ' '))
      lpszArgs[-1] = '\0';
  }
}

Referenced by RunOnceExEntry::Exec(), CAddressEditBox::ExecuteCommandLine(), CShellLink::OnNotify(), OpensWithExplorer(), ATL::CPathT< StringType >::PathRemoveArgsX(), SHELL_execute(), SHELL_translate_idlist(), and WelcomeDlgProc().

PathRemoveBackslashA()

LPSTR WINAPI PathRemoveBackslashA

(

LPSTR

lpszPath

)

Definition at line 847 of file path.c.

{
  LPSTR szTemp = NULL;
 
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if(lpszPath)
  {
    szTemp = CharPrevA(lpszPath, lpszPath + strlen(lpszPath));
    if (!PathIsRootA(lpszPath) && *szTemp == '\\')
      *szTemp = '\0';
  }
  return szTemp;
}

Referenced by ATL::CPathT< StringType >::PathRemoveBackslashX().

PathRemoveBackslashW()

LPWSTR WINAPI PathRemoveBackslashW

(

LPWSTR

lpszPath

)

Definition at line 867 of file path.c.

{
  LPWSTR szTemp = NULL;
 
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if(lpszPath)
  {
    szTemp = lpszPath + strlenW(lpszPath);
    if (szTemp > lpszPath) szTemp--;
    if (!PathIsRootW(lpszPath) && *szTemp == '\\')
      *szTemp = '\0';
  }
  return szTemp;
}

Referenced by dialog_update_directory_combo(), CFileDefExt::InitFilePath(), PathQualifyExW(), ATL::CPathT< StringType >::PathRemoveBackslashX(), and SHGetFolderPathAndSubDirW().

PathRemoveBlanksA()

void WINAPI PathRemoveBlanksA

(

LPSTR

pszPath

)

Definition at line 894 of file path.c.

{
    LPSTR start, first;
 
    TRACE("(%s)\n", debugstr_a(pszPath));
 
    if (!pszPath || !*pszPath)
        return;
 
    start = first = pszPath;
 
    while (*pszPath == ' ')
        pszPath = CharNextA(pszPath);
 
    while (*pszPath)
        *start++ = *pszPath++;
 
    if (start != first)
        while (start[-1] == ' ')
            start--;
 
    *start = '\0';
}

Referenced by PathParseIconLocationA(), ATL::CPathT< StringType >::PathRemoveBlanksX(), and test_PathRemoveBlanks().

PathRemoveBlanksW()

void WINAPI PathRemoveBlanksW

(

LPWSTR

pszPath

)

Definition at line 923 of file path.c.

{
    LPWSTR start, first;
 
    TRACE("(%s)\n", debugstr_w(pszPath));
 
    if (!pszPath || !*pszPath)
        return;
 
    start = first = pszPath;
 
    while (*pszPath == ' ')
        pszPath++;
 
    while (*pszPath)
        *start++ = *pszPath++;
 
    if (start != first)
        while (start[-1] == ' ')
            start--;
 
    *start = '\0';
}

Referenced by PathParseIconLocationW(), ATL::CPathT< StringType >::PathRemoveBlanksX(), RouteTheCallW(), SHELL_FindExecutable(), and test_PathRemoveBlanks().

PathRemoveExtensionA()

void WINAPI PathRemoveExtensionA

(

LPSTR

lpszPath

)

Definition at line 806 of file path.c.

{
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (lpszPath)
  {
    lpszPath = PathFindExtensionA(lpszPath);
    if (lpszPath && *lpszPath != '\0')
      *lpszPath = '\0';
  }
}

Referenced by ATL::CPathT< StringType >::PathRemoveExtensionX().

PathRemoveExtensionW()

void WINAPI PathRemoveExtensionW

(

LPWSTR

lpszPath

)

Definition at line 823 of file path.c.

{
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (lpszPath)
  {
    lpszPath = PathFindExtensionW(lpszPath);
    if (lpszPath && *lpszPath != '\0')
      *lpszPath = '\0';
  }
}

Referenced by CFSDropTarget::_DoDrop(), CZipExtract::CZipExtract(), DoGetZipName(), CDeskLinkDropHandler::Drop(), CAppDB::EnumerateFiles(), FileCompareWildTitle(), FinishDlgProc(), CQueryAssociations::GetString(), on_command_filetype(), PathIsDosDevice(), ATL::CPathT< StringType >::PathRemoveExtensionX(), PathYetAnotherMakeUniqueName(), CMainWindow::saveImage(), SHELL_FS_ProcessDisplayFilename(), START_TEST(), TestModuleRegistry(), and WriteMinidump().

PathRemoveFileSpecA()

BOOL WINAPI PathRemoveFileSpecA

(

LPSTR

lpszPath

)

Definition at line 586 of file path.c.

{
  LPSTR lpszFileSpec = lpszPath;
  BOOL bModified = FALSE;
 
  TRACE("(%s)\n",debugstr_a(lpszPath));
 
  if(lpszPath)
  {
    /* Skip directory or UNC path */
    if (*lpszPath == '\\')
      lpszFileSpec = ++lpszPath;
    if (*lpszPath == '\\')
      lpszFileSpec = ++lpszPath;
 
    while (*lpszPath)
    {
      if(*lpszPath == '\\')
        lpszFileSpec = lpszPath; /* Skip dir */
      else if(*lpszPath == ':')
      {
        lpszFileSpec = ++lpszPath; /* Skip drive */
        if (*lpszPath == '\\')
          lpszFileSpec++;
      }
      if (!(lpszPath = CharNextA(lpszPath)))
        break;
    }
 
    if (*lpszFileSpec)
    {
      *lpszFileSpec = '\0';
      bModified = TRUE;
    }
  }
  return bModified;
}

Referenced by PathRemoveFileSpecAW(), ATL::CPathT< StringType >::PathRemoveFileSpecX(), and PathStripToRootA().

PathRemoveFileSpecW()

BOOL WINAPI PathRemoveFileSpecW

(

LPWSTR

lpszPath

)

Definition at line 629 of file path.c.

{
  LPWSTR lpszFileSpec = lpszPath;
  BOOL bModified = FALSE;
 
  TRACE("(%s)\n",debugstr_w(lpszPath));
 
  if(lpszPath)
  {
    /* Skip directory or UNC path */
    if (*lpszPath == '\\')
      lpszFileSpec = ++lpszPath;
    if (*lpszPath == '\\')
      lpszFileSpec = ++lpszPath;
 
    while (*lpszPath)
    {
      if(*lpszPath == '\\')
        lpszFileSpec = lpszPath; /* Skip dir */
      else if(*lpszPath == ':')
      {
        lpszFileSpec = ++lpszPath; /* Skip drive */
        if (*lpszPath == '\\')
          lpszFileSpec++;
      }
      lpszPath++;
    }
 
    if (*lpszFileSpec)
    {
      *lpszFileSpec = '\0';
      bModified = TRUE;
    }
  }
  return bModified;
}

Referenced by CFSDropTarget::_CopyItems(), CDirectoryList::AddPathsFromDirectory(), DoBuildFilesAndDirs(), DoDeleteSpecW(), DoGetBaseName(), DoTestEntry(), CDeskLinkDropHandler::Drop(), CZipExtract::Extract(), FileCompareBothWild(), FileCompareOneSideWild(), FileCompareWildTitle(), FindSubProgram(), FinishDlgProc(), GetItemOriginalFolder(), HandleDesktopIniOp(), CShellLink::OnInitDialog(), PathQualifyExW(), PathRelativePathToW(), PathRemoveFileSpecAW(), ATL::CPathT< StringType >::PathRemoveFileSpecX(), PathStripToRootW(), pBuildFileList(), search_dr(), search_file(), SHCreatePropertyBagOnProfileSection(), and SHGetShellStyleHInstance().

PathRenameExtensionA()

BOOL WINAPI PathRenameExtensionA	(	LPSTR	lpszPath,
		LPCSTR	lpszExt
	)

Definition at line 3170 of file path.c.

{
  LPSTR lpszExtension;
 
  TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszExt));
 
  lpszExtension = PathFindExtensionA(lpszPath);
 
  if (!lpszExtension || (lpszExtension - lpszPath + strlen(lpszExt) >= MAX_PATH))
    return FALSE;
 
  strcpy(lpszExtension, lpszExt);
  return TRUE;
}

PathRenameExtensionW()

BOOL WINAPI PathRenameExtensionW	(	LPWSTR	lpszPath,
		LPCWSTR	lpszExt
	)

Definition at line 3190 of file path.c.

{
  LPWSTR lpszExtension;
 
  TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszExt));
 
  lpszExtension = PathFindExtensionW(lpszPath);
 
  if (!lpszExtension || (lpszExtension - lpszPath + strlenW(lpszExt) >= MAX_PATH))
    return FALSE;
 
  strcpyW(lpszExtension, lpszExt);
  return TRUE;
}

PathSearchAndQualifyA()

BOOL WINAPI PathSearchAndQualifyA	(	LPCSTR	lpszPath,
		LPSTR	lpszBuf,
		UINT	cchBuf
	)

Definition at line 3218 of file path.c.

{
    TRACE("(%s,%p,0x%08x)\n", debugstr_a(lpszPath), lpszBuf, cchBuf);
 
    if(SearchPathA(NULL, lpszPath, NULL, cchBuf, lpszBuf, NULL))
        return TRUE;
    return !!GetFullPathNameA(lpszPath, cchBuf, lpszBuf, NULL);
}

PathSearchAndQualifyW()

BOOL WINAPI PathSearchAndQualifyW	(	LPCWSTR	lpszPath,
		LPWSTR	lpszBuf,
		UINT	cchBuf
	)

Definition at line 3232 of file path.c.

{
    TRACE("(%s,%p,0x%08x)\n", debugstr_w(lpszPath), lpszBuf, cchBuf);
 
    if(SearchPathW(NULL, lpszPath, NULL, cchBuf, lpszBuf, NULL))
        return TRUE;
    return !!GetFullPathNameW(lpszPath, cchBuf, lpszBuf, NULL);
}

Referenced by create_uri(), and test_PathSearchAndQualify().

PathSetDlgItemPathA()

VOID WINAPI PathSetDlgItemPathA	(	HWND	hDlg,
		int	id,
		LPCSTR	lpszPath
	)

Definition at line 3707 of file path.c.

{
  WCHAR szPath[MAX_PATH];
 
  TRACE("(%p,%8x,%s)\n",hDlg, id, debugstr_a(lpszPath));
 
  if (lpszPath)
    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
  else
    szPath[0] = '\0';
  PathSetDlgItemPathW(hDlg, id, szPath);
}

PathSetDlgItemPathW()

VOID WINAPI PathSetDlgItemPathW	(	HWND	hDlg,
		int	id,
		LPCWSTR	lpszPath
	)

Definition at line 3725 of file path.c.

{
  WCHAR path[MAX_PATH + 1];
  HWND hwItem;
  RECT rect;
  HDC hdc;
  HGDIOBJ hPrevObj;
 
  TRACE("(%p,%8x,%s)\n",hDlg, id, debugstr_w(lpszPath));
 
  if (!(hwItem = GetDlgItem(hDlg, id)))
    return;
 
  if (lpszPath)
    lstrcpynW(path, lpszPath, sizeof(path) / sizeof(WCHAR));
  else
    path[0] = '\0';
 
  GetClientRect(hwItem, &rect);
  hdc = GetDC(hDlg);
  hPrevObj = SelectObject(hdc, (HGDIOBJ)SendMessageW(hwItem,WM_GETFONT,0,0));
 
  if (hPrevObj)
  {
    PathCompactPathW(hdc, path, rect.right);
    SelectObject(hdc, hPrevObj);
  }
 
  ReleaseDC(hDlg, hdc);
  SetWindowTextW(hwItem, path);
}

Referenced by PathSetDlgItemPathA().

PathSkipRootA()

LPSTR WINAPI PathSkipRootA

(

LPCSTR

lpszPath

)

Definition at line 3253 of file path.c.

{
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (!lpszPath || !*lpszPath)
    return NULL;
 
  if (*lpszPath == '\\' && lpszPath[1] == '\\')
  {
    /* Network share: skip share server and mount point */
    lpszPath += 2;
    if ((lpszPath = StrChrA(lpszPath, '\\')) &&
        (lpszPath = StrChrA(lpszPath + 1, '\\')))
      lpszPath++;
    return (LPSTR)lpszPath;
  }
 
  if (IsDBCSLeadByte(*lpszPath))
    return NULL;
 
  /* Check x:\ */
  if (lpszPath[0] && lpszPath[1] == ':' && lpszPath[2] == '\\')
    return (LPSTR)lpszPath + 3;
  return NULL;
}

Referenced by PathIsSameRootA(), and ATL::CPathT< StringType >::PathSkipRootX().

PathSkipRootW()

LPWSTR WINAPI PathSkipRootW

(

LPCWSTR

lpszPath

)

Definition at line 3284 of file path.c.

{
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (!lpszPath || !*lpszPath)
    return NULL;
 
  if (*lpszPath == '\\' && lpszPath[1] == '\\')
  {
    /* Network share: skip share server and mount point */
    lpszPath += 2;
    if ((lpszPath = StrChrW(lpszPath, '\\')) &&
        (lpszPath = StrChrW(lpszPath + 1, '\\')))
     lpszPath++;
    return (LPWSTR)lpszPath;
  }
 
  /* Check x:\ */
  if (lpszPath[0] && lpszPath[1] == ':' && lpszPath[2] == '\\')
    return (LPWSTR)lpszPath + 3;
  return NULL;
}

Referenced by PathIsSameRootW(), and ATL::CPathT< StringType >::PathSkipRootX().

PathStripPathA()

void WINAPI PathStripPathA

(

LPSTR

lpszPath

)

Definition at line 677 of file path.c.

{
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (lpszPath)
  {
    LPSTR lpszFileName = PathFindFileNameA(lpszPath);
    if(lpszFileName != lpszPath)
      RtlMoveMemory(lpszPath, lpszFileName, strlen(lpszFileName)+1);
  }
}

Referenced by ATL::CPathT< StringType >::PathStripPathX(), SHAddToRecentDocs(), and test_PathStripPathA().

PathStripPathW()

void WINAPI PathStripPathW

(

LPWSTR

lpszPath

)

Definition at line 694 of file path.c.

{
  LPWSTR lpszFileName;
 
  TRACE("(%s)\n", debugstr_w(lpszPath));
  lpszFileName = PathFindFileNameW(lpszPath);
  if(lpszFileName != lpszPath)
    RtlMoveMemory(lpszPath, lpszFileName, (strlenW(lpszFileName)+1)*sizeof(WCHAR));
}

Referenced by dialog_update_directory_combo(), CZipExtract::Extract(), CQueryAssociations::GetString(), ATL::CPathT< StringType >::PathStripPathX(), and TestModuleRegistry().

PathStripToRootA()

BOOL WINAPI PathStripToRootA

(

LPSTR

lpszPath

)

Definition at line 716 of file path.c.

{
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (!lpszPath)
    return FALSE;
  while(!PathIsRootA(lpszPath))
    if (!PathRemoveFileSpecA(lpszPath))
      return FALSE;
  return TRUE;
}

Referenced by ATL::CPathT< StringType >::PathStripToRootX().

PathStripToRootW()

BOOL WINAPI PathStripToRootW

(

LPWSTR

lpszPath

)

Definition at line 733 of file path.c.

{
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (!lpszPath)
    return FALSE;
  while(!PathIsRootW(lpszPath))
    if (!PathRemoveFileSpecW(lpszPath))
      return FALSE;
  return TRUE;
}

Referenced by get_drive_type(), IsLFNDriveW(), PathCombineW(), PathQualifyExW(), ATL::CPathT< StringType >::PathStripToRootX(), SHELL_execute(), SHExplorerParseCmdLine(), source_matches_volume(), START_TEST(), test_sei_lpIDList(), and TRASH_CanTrashFile().

PathUndecorateA()

void WINAPI PathUndecorateA

(

LPSTR

pszPath

)

Definition at line 4070 of file path.c.

{
  char *ext, *skip;
 
  TRACE("(%s)\n", debugstr_a(pszPath));
 
  if (!pszPath) return;
 
  ext = PathFindExtensionA(pszPath);
  if (ext == pszPath || ext[-1] != ']') return;
 
  skip = ext - 2;
  while (skip > pszPath && '0' <= *skip && *skip <= '9')
      skip--;
 
  if (skip > pszPath && *skip == '[' && skip[-1] != '\\')
      memmove(skip, ext, strlen(ext) + 1);
}

Referenced by test_PathUndecorate().

PathUndecorateW()

void WINAPI PathUndecorateW

(

LPWSTR

pszPath

)

Definition at line 4094 of file path.c.

{
  WCHAR *ext, *skip;
 
  TRACE("(%s)\n", debugstr_w(pszPath));
 
  if (!pszPath) return;
 
  ext = PathFindExtensionW(pszPath);
  if (ext == pszPath || ext[-1] != ']') return;
 
  skip = ext - 2;
  while (skip > pszPath && '0' <= *skip && *skip <= '9')
      skip--;
 
  if (skip > pszPath && *skip == '[' && skip[-1] != '\\')
      memmove(skip, ext, (wcslen(ext) + 1) * sizeof(WCHAR));
}

Referenced by test_PathUndecorate().

PathUnExpandEnvStringsA()

BOOL WINAPI PathUnExpandEnvStringsA	(	LPCSTR	path,
		LPSTR	buffer,
		UINT	buf_len
	)

Definition at line 4128 of file path.c.

{
    WCHAR bufferW[MAX_PATH], *pathW;
    DWORD len;
    BOOL ret;
 
    TRACE("(%s, %p, %d)\n", debugstr_a(path), buffer, buf_len);
 
    pathW = heap_strdupAtoW(path);
    if (!pathW) return FALSE;
 
    ret = PathUnExpandEnvStringsW(pathW, bufferW, MAX_PATH);
    HeapFree(GetProcessHeap(), 0, pathW);
    if (!ret) return FALSE;
 
    len = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
    if (buf_len < len + 1) return FALSE;
 
    WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, buf_len, NULL, NULL);
    return TRUE;
}

PathUnExpandEnvStringsW()

BOOL WINAPI PathUnExpandEnvStringsW	(	LPCWSTR	path,
		LPWSTR	buffer,
		UINT	buf_len
	)

Definition at line 4181 of file path.c.

{
    static struct envvars_map null_var = {NULL, 0, {0}, 0};
    struct envvars_map *match = &null_var, *cur;
    struct envvars_map envvars[] = {
        { allusersprofileW, sizeof(allusersprofileW)/sizeof(WCHAR) },
        { appdataW,         sizeof(appdataW)/sizeof(WCHAR)         },
        { programfilesW,    sizeof(programfilesW)/sizeof(WCHAR)    },
        { systemrootW,      sizeof(systemrootW)/sizeof(WCHAR)      },
        { systemdriveW,     sizeof(systemdriveW)/sizeof(WCHAR)     },
        { userprofileW,     sizeof(userprofileW)/sizeof(WCHAR)     },
        { NULL }
    };
    DWORD pathlen;
    UINT  needed;
 
    TRACE("(%s, %p, %d)\n", debugstr_w(path), buffer, buf_len);
 
    pathlen = strlenW(path);
    init_envvars_map(envvars);
    cur = envvars;
    while (cur->var)
    {
        /* path can't contain expanded value or value wasn't retrieved */
        if (cur->len == 0 || cur->len > pathlen || strncmpiW(cur->path, path, cur->len))
        {
            cur++;
            continue;
        }
 
        if (cur->len > match->len)
            match = cur;
        cur++;
    }
 
    /* 'varlen' includes NULL termination char */
    needed = match->varlen + pathlen - match->len;
    if (match->len == 0 || needed > buf_len) return FALSE;
 
    strcpyW(buffer, match->var);
    strcatW(buffer, &path[match->len]);
    TRACE("ret %s\n", debugstr_w(buffer));
 
    return TRUE;
}

Referenced by PathUnExpandEnvStringsA(), CShellLink::SetIconLocation(), and SHSetUnreadMailCountW().

PathUnmakeSystemFolderA()

BOOL WINAPI PathUnmakeSystemFolderA

(

LPCSTR

lpszPath

)

Definition at line 3655 of file path.c.

{
  DWORD dwAttr;
 
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesA(lpszPath)) == INVALID_FILE_ATTRIBUTES ||
      !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
    return FALSE;
 
  dwAttr &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
  return SetFileAttributesA(lpszPath, dwAttr);
}

PathUnmakeSystemFolderW()

BOOL WINAPI PathUnmakeSystemFolderW

(

LPCWSTR

lpszPath

)

Definition at line 3674 of file path.c.

{
  DWORD dwAttr;
 
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES ||
    !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
    return FALSE;
 
  dwAttr &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
  return SetFileAttributesW(lpszPath, dwAttr);
}

PathUnquoteSpacesA()

VOID WINAPI PathUnquoteSpacesA

(

LPSTR

lpszPath

)

Definition at line 1018 of file path.c.

{
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (lpszPath && *lpszPath == '"')
  {
    DWORD dwLen = strlen(lpszPath) - 1;
 
    if (lpszPath[dwLen] == '"')
    {
      lpszPath[dwLen] = '\0';
      for (; *lpszPath; lpszPath++)
        *lpszPath = lpszPath[1];
    }
  }
}

Referenced by HCR_RegGetIconA(), PathParseIconLocationA(), ATL::CPathT< StringType >::PathUnquoteSpacesX(), and test_PathUnquoteSpaces().

PathUnquoteSpacesW()

VOID WINAPI PathUnquoteSpacesW

(

LPWSTR

lpszPath

)

Definition at line 1040 of file path.c.

{
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (lpszPath && *lpszPath == '"')
  {
    DWORD dwLen = strlenW(lpszPath) - 1;
 
    if (lpszPath[dwLen] == '"')
    {
      lpszPath[dwLen] = '\0';
      for (; *lpszPath; lpszPath++)
        *lpszPath = lpszPath[1];
    }
  }
}

Referenced by CFSExtractIcon_CreateInstance(), CAddressEditBox::ExecuteCommandLine(), HCR_RegGetIconW(), CFileDefExt::InitOpensWithField(), LanguagesPageProc(), CShellLink::OnNotify(), PathParseIconLocationW(), PathResolveW(), ATL::CPathT< StringType >::PathUnquoteSpacesX(), Preview_OnCreate(), CShellLink::SetPath(), SHELL_execute(), SHELL_translate_idlist(), ShellExec_RunDLL_Helper(), and test_PathUnquoteSpaces().

SHGetWebFolderFilePathA()

HRESULT WINAPI SHGetWebFolderFilePathA	(	LPCSTR	lpszFile,
		LPSTR	lpszPath,
		DWORD	dwPathLen
	)

Definition at line 4241 of file path.c.

{
  WCHAR szFile[MAX_PATH], szPath[MAX_PATH];
  HRESULT hRet;
 
  TRACE("(%s,%p,%d)\n", lpszFile, lpszPath, dwPathLen);
 
  MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, szFile, MAX_PATH);
  szPath[0] = '\0';
  hRet = SHGetWebFolderFilePathW(szFile, szPath, dwPathLen);
  WideCharToMultiByte(CP_ACP, 0, szPath, -1, lpszPath, dwPathLen, 0, 0);
  return hRet;
}

SHGetWebFolderFilePathW()

HRESULT WINAPI SHGetWebFolderFilePathW	(	LPCWSTR	lpszFile,
		LPWSTR	lpszPath,
		DWORD	dwPathLen
	)

Definition at line 4260 of file path.c.

{
  static const WCHAR szWeb[] = {'\\','W','e','b','\\','\0'};
  static const WCHAR szWebMui[] = {'m','u','i','\\','%','0','4','x','\\','\0'};
#define szWebLen (sizeof(szWeb)/sizeof(WCHAR))
#define szWebMuiLen ((sizeof(szWebMui)+1)/sizeof(WCHAR))
  DWORD dwLen, dwFileLen;
  LANGID lidSystem, lidUser;
 
  TRACE("(%s,%p,%d)\n", debugstr_w(lpszFile), lpszPath, dwPathLen);
 
  /* Get base directory for web content */
  dwLen = GetSystemWindowsDirectoryW(lpszPath, dwPathLen);
  if (dwLen > 0 && lpszPath[dwLen-1] == '\\')
    dwLen--;
 
  dwFileLen = strlenW(lpszFile);
 
  if (dwLen + dwFileLen + szWebLen >= dwPathLen)
    return E_FAIL; /* lpszPath too short */
 
  strcpyW(lpszPath+dwLen, szWeb);
  dwLen += szWebLen;
  dwPathLen = dwPathLen - dwLen; /* Remaining space */
 
  lidSystem = GetSystemDefaultUILanguage();
  lidUser = GetUserDefaultUILanguage();
 
  if (lidSystem != lidUser)
  {
    if (dwFileLen + szWebMuiLen < dwPathLen)
    {
      /* Use localised content in the users UI language if present */
      wsprintfW(lpszPath + dwLen, szWebMui, lidUser);
      strcpyW(lpszPath + dwLen + szWebMuiLen, lpszFile);
      if (PathFileExistsW(lpszPath))
        return S_OK;
    }
  }
 
  /* Fall back to OS default installed content */
  strcpyW(lpszPath + dwLen, lpszFile);
  if (PathFileExistsW(lpszPath))
    return S_OK;
  return E_FAIL;
}

Referenced by SHGetWebFolderFilePathA().

SHLWAPI_PathFindInOtherDirs()

static BOOL SHLWAPI_PathFindInOtherDirs ( LPWSTR  lpszFile, DWORD  dwWhich  )

static

Definition at line 1223 of file path.c.

{
  static const WCHAR szSystem[] = { 'S','y','s','t','e','m','\0'};
  static const WCHAR szPath[] = { 'P','A','T','H','\0'};
  DWORD dwLenPATH;
  LPCWSTR lpszCurr;
  WCHAR *lpszPATH;
  WCHAR buff[MAX_PATH];
 
  TRACE("(%s,%08x)\n", debugstr_w(lpszFile), dwWhich);
 
  /* Try system directories */
  GetSystemDirectoryW(buff, MAX_PATH);
  if (!PathAppendW(buff, lpszFile))
     return FALSE;
  if (PathFileExistsDefExtW(buff, dwWhich))
  {
    strcpyW(lpszFile, buff);
    return TRUE;
  }
  GetWindowsDirectoryW(buff, MAX_PATH);
  if (!PathAppendW(buff, szSystem ) || !PathAppendW(buff, lpszFile))
    return FALSE;
  if (PathFileExistsDefExtW(buff, dwWhich))
  {
    strcpyW(lpszFile, buff);
    return TRUE;
  }
  GetWindowsDirectoryW(buff, MAX_PATH);
  if (!PathAppendW(buff, lpszFile))
    return FALSE;
  if (PathFileExistsDefExtW(buff, dwWhich))
  {
    strcpyW(lpszFile, buff);
    return TRUE;
  }
  /* Try dirs listed in %PATH% */
  dwLenPATH = GetEnvironmentVariableW(szPath, buff, MAX_PATH);
 
  if (!dwLenPATH || !(lpszPATH = HeapAlloc(GetProcessHeap(), 0, (dwLenPATH + 1) * sizeof (WCHAR))))
    return FALSE;
 
  GetEnvironmentVariableW(szPath, lpszPATH, dwLenPATH + 1);
  lpszCurr = lpszPATH;
  while (lpszCurr)
  {
    LPCWSTR lpszEnd = lpszCurr;
    LPWSTR pBuff = buff;
 
    while (*lpszEnd == ' ')
      lpszEnd++;
    while (*lpszEnd && *lpszEnd != ';')
      *pBuff++ = *lpszEnd++;
    *pBuff = '\0';
 
    if (*lpszEnd)
      lpszCurr = lpszEnd + 1;
    else
      lpszCurr = NULL; /* Last Path, terminate after this */
 
    if (!PathAppendW(buff, lpszFile))
    {
      HeapFree(GetProcessHeap(), 0, lpszPATH);
      return FALSE;
    }
    if (PathFileExistsDefExtW(buff, dwWhich))
    {
      strcpyW(lpszFile, buff);
      HeapFree(GetProcessHeap(), 0, lpszPATH);
      return TRUE;
    }
  }
  HeapFree(GetProcessHeap(), 0, lpszPATH);
  return FALSE;
}

Referenced by PathFindOnPathExA(), and PathFindOnPathExW().

SHLWAPI_UseSystemForSystemFolders()

static BOOL SHLWAPI_UseSystemForSystemFolders ( void  )

static

Definition at line 3076 of file path.c.

{
  static BOOL bCheckedReg = FALSE;
  static BOOL bUseSystemForSystemFolders = FALSE;
 
  if (!bCheckedReg)
  {
    bCheckedReg = TRUE;
 
    /* Key tells Win what file attributes to use on system folders */
    if (SHGetValueA(HKEY_LOCAL_MACHINE,
        "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
        "UseSystemForSystemFolders", 0, 0, 0))
      bUseSystemForSystemFolders = TRUE;
  }
  return bUseSystemForSystemFolders;
}

Referenced by PathMakeSystemFolderW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shell

)

Variable Documentation

allusersprofileW

const WCHAR allusersprofileW[] = {'%','A','L','L','U','S','E','R','S','P','R','O','F','I','L','E','%',0}

static

Definition at line 4150 of file path.c.

Referenced by PathUnExpandEnvStringsW().

appdataW

const WCHAR appdataW[] = {'%','A','P','P','D','A','T','A','%',0}

static

Definition at line 4151 of file path.c.

Referenced by PathUnExpandEnvStringsW().

pIsNetDrive

fnpIsNetDrive pIsNetDrive

static

Definition at line 66 of file path.c.

Referenced by PathIsNetworkPathA(), and PathIsNetworkPathW().

programfilesW

const WCHAR programfilesW[] = {'%','P','r','o','g','r','a','m','F','i','l','e','s','%',0}

static

Definition at line 4152 of file path.c.

Referenced by PathUnExpandEnvStringsW(), and test_StdRegProv().

SHELL_charclass

const DWORD SHELL_charclass[]

static

Definition at line 4323 of file path.c.

Referenced by PathIsValidCharA(), PathIsValidCharW(), test_PathIsValidCharA(), and test_PathIsValidCharW().

SHLWAPI_hshell32

HMODULE SHLWAPI_hshell32

static

Definition at line 62 of file path.c.

systemdriveW

const WCHAR systemdriveW[] = {'%','S','y','s','t','e','m','D','r','i','v','e','%',0}

static

Definition at line 4154 of file path.c.

Referenced by PathUnExpandEnvStringsW(), and test_Win32_OperatingSystem().

systemrootW

const WCHAR systemrootW[] = {'%','S','y','s','t','e','m','R','o','o','t','%',0}

static

Definition at line 4153 of file path.c.

Referenced by create_file_test(), and PathUnExpandEnvStringsW().

userprofileW

const WCHAR userprofileW[] = {'%','U','S','E','R','P','R','O','F','I','L','E','%',0}

static

Definition at line 4155 of file path.c.

Referenced by PathUnExpandEnvStringsW().