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 lpszPath)
VOID WINAPI	PathRemoveBlanksW (LPWSTR lpszPath)
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 lpszPath)
VOID WINAPI	PathUndecorateW (LPWSTR lpszPath)
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 47 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 4308 of file path.c.

PATH_CHAR_CLASS_ASTERIX

#define PATH_CHAR_CLASS_ASTERIX   0x00000002

Definition at line 4297 of file path.c.

PATH_CHAR_CLASS_BACKSLASH

#define PATH_CHAR_CLASS_BACKSLASH   0x00000008

Definition at line 4299 of file path.c.

PATH_CHAR_CLASS_COLON

#define PATH_CHAR_CLASS_COLON   0x00000010

Definition at line 4300 of file path.c.

PATH_CHAR_CLASS_COMMA

#define PATH_CHAR_CLASS_COMMA   0x00000040

Definition at line 4302 of file path.c.

PATH_CHAR_CLASS_DOT

#define PATH_CHAR_CLASS_DOT   0x00000004

Definition at line 4298 of file path.c.

PATH_CHAR_CLASS_DOUBLEQUOTE

#define PATH_CHAR_CLASS_DOUBLEQUOTE   0x00000200

Definition at line 4305 of file path.c.

PATH_CHAR_CLASS_INVALID

#define PATH_CHAR_CLASS_INVALID   0x00000000

Definition at line 4307 of file path.c.

PATH_CHAR_CLASS_LETTER

#define PATH_CHAR_CLASS_LETTER   0x00000001

Definition at line 4296 of file path.c.

PATH_CHAR_CLASS_OTHER_VALID

#define PATH_CHAR_CLASS_OTHER_VALID   0x00000100

Definition at line 4304 of file path.c.

PATH_CHAR_CLASS_SEMICOLON

#define PATH_CHAR_CLASS_SEMICOLON   0x00000020

Definition at line 4301 of file path.c.

PATH_CHAR_CLASS_SPACE

#define PATH_CHAR_CLASS_SPACE   0x00000080

Definition at line 4303 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 60 of file path.c.

Function Documentation

heap_strdupAtoW()

static WCHAR* heap_strdupAtoW ( LPCSTR  str )

inlinestatic

Definition at line 68 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 4154 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 258 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;
}

Referenced by ATL::CPathT< StringType >::PathAddBackslashX(), and test_PathAddBackslash().

PathAddBackslashW()

LPWSTR WINAPI PathAddBackslashW

(

LPWSTR

lpszPath

)

Definition at line 289 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;
}

Referenced by CDesktopFolder::_GetSFFromPidl(), _SHGetUserShellFolderPath(), _SHRegisterFolders(), _SHRegisterUserShellFolders(), ACTION_AppSearchComponents(), ACTION_AppSearchDr(), ACTION_RecurseSearchDirectory(), ACTION_SearchDirectory(), app_search_file(), COMDLG32_GetCanonicalPath(), CControlPanelEnum::CreateCPanelEnumList(), DoGetBaseName(), FILEDLG95_InitControls(), FILEDLG95_ValidatePathAction(), find_published_source(), get_drive_type(), CFSFolder::GetDisplayNameOf(), CFileSysEnum::Initialize(), ITERATE_RemoveFiles(), MMSYS_InstallDevice(), msi_dialog_directorylist_up(), msi_load_media_info(), OpenColorProfileW(), CFSFolder::ParseDisplayName(), ATL::CPathT< StringType >::PathAddBackslashX(), PathCombineW(), PathIsDirectoryEmptyW(), ready_media(), RenderHDROP(), set_installer_properties(), SHCreateDirectoryExW(), ShellExecCmdLine(), ShellLink_UpdatePath(), SHGetFolderPathAndSubDirW(), SHGetNewLinkInfoW(), ShowCreateShortcutWizard(), source_matches_volume(), START_TEST(), test_PathSearchAndQualify(), and wWinMain().

PathAddExtensionA()

BOOL WINAPI PathAddExtensionA	(	LPSTR	lpszPath,
		LPCSTR	lpszExtension
	)

Definition at line 2594 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;
}

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

PathAddExtensionW()

BOOL WINAPI PathAddExtensionW	(	LPWSTR	lpszPath,
		LPCWSTR	lpszExtension
	)

Definition at line 2617 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;
}

Referenced by ATL::CPathT< StringType >::PathAddExtensionX(), SHELL_TryAppPathW(), and WriteMinidump().

PathAppendA()

BOOL WINAPI PathAppendA	(	LPSTR	lpszPath,
		LPCSTR	lpszAppend
	)

Definition at line 101 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;
}

Referenced by PathAppendAW(), ATL::CPathT< StringType >::PathAppendX(), SHAddToRecentDocs(), test_PathAppendA(), test_SdbGetPermLayerKeys(), test_SetPermLayer(), test_Sign_Media(), and write_resource_file().

PathAppendW()

BOOL WINAPI PathAppendW	(	LPWSTR	lpszPath,
		LPCWSTR	lpszAppend
	)

Definition at line 121 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;
}

Referenced by _SHExpandEnvironmentStrings(), _SHGetDefaultValue(), ACTION_RecurseSearchDirectory(), add_favs_to_menu(), addFileHelper(), CCommonFolder< CRegistryFolder, RegPidlEntry, CRegistryFolderExtractIcon >::BindToObject(), CSendToMenu::CreateSendToFiles(), DllRegisterServer(), DoAddFilesFromItem(), DoDeleteSpecW(), DoInit(), CFontExt::DoInstallFontFile(), DoTestEntry(), CDeskLinkDropHandler::Drop(), FinishDlgProc(), CSendToMenu::FolderHasAnyItems(), CFSFolder::GetCustomViewInfo(), CCommonFolder< CRegistryFolder, RegPidlEntry, CRegistryFolderExtractIcon >::GetDisplayNameOf(), getIconLocationForDrive(), getIconLocationForFolder(), CFileDefExt::InitFolderCustomizePage(), OnCreate(), CFileDefExt::OnFolderCustApply(), PathAppendAW(), ATL::CPathT< StringType >::PathAppendX(), SHAddToRecentDocs(), SHGetFolderPathAndSubDirW(), SHLWAPI_PathFindInOtherDirs(), START_TEST(), and testRegStoreSavedCerts().

PathBuildRootA()

LPSTR WINAPI PathBuildRootA	(	LPSTR	lpszPath,
		int	drive
	)

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

PathCanonicalizeA()

BOOL WINAPI PathCanonicalizeA	(	LPSTR	lpszBuf,
		LPCSTR	lpszPath
	)

Definition at line 2392 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;
}

Referenced by ATL::CPathT< StringType >::PathCanonicalizeX(), and test_PathCanonicalizeA().

PathCanonicalizeW()

BOOL WINAPI PathCanonicalizeW	(	LPWSTR	lpszBuf,
		LPCWSTR	lpszPath
	)

Definition at line 2425 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;
}

Referenced by COMDLG32_GetCanonicalPath(), PathCanonicalizeA(), ATL::CPathT< StringType >::PathCanonicalizeX(), and PathCombineW().

PathCombineA()

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

Definition at line 154 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;
}

Referenced by create_file(), delete_file(), expect_files(), CZipExtract::Extract(), PathAppendA(), ATL::CPathT< StringType >::PathCombineX(), test_items(), test_PathCombineA(), test_SdbGetPermLayerKeys(), test_Sign_Media(), and wrapSdbSetPermLayerKeys2().

PathCombineW()

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

Definition at line 189 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;
}

Referenced by CFSFolder::_CreateShellExtInstance(), CFSDropTarget::_DoDrop(), CFSFolder::BindToObject(), BuildPathsList(), compat_catpath(), copy_dir_to_dir(), copy_file(), copy_to_dir(), move_dir_to_dir(), move_to_dir(), parse_file_list(), PathAppendW(), PathCombineA(), ATL::CPathT< StringType >::PathCombineX(), PathFindOnPathExA(), PathFindOnPathExW(), PathYetAnotherMakeUniqueName(), pBuildFileList(), RecursiveFind(), SetChmPath(), CFSFolder::SetNameOf(), SHELL_DeleteDirectoryW(), SHGetFileInfoW(), test_items(), and test_PathCombineW().

PathCommonPrefixA()

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

Definition at line 2730 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 2785 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 ATL::CPathT< StringType >::PathCommonPrefixX(), PathIsPrefixW(), PathIsSameRootW(), and PathRelativePathToW().

PathCompactPathA()

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

Definition at line 2849 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 1414 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 1439 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 2870 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 3285 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 3476 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 3334 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 DocObjectService_FireBeforeNavigate2(), InternetCrackUrlW(), on_before_navigate2(), parse_path_from_url(), PathCreateFromUrlA(), PathCreateFromUrlAlloc(), and SHELL_execute().

PathFileExistsA()

BOOL WINAPI PathFileExistsA

(

LPCSTR

lpszPath

)

Definition at line 1734 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 PathFileExistsAW(), and ATL::CPathT< StringType >::PathFileExistsX().

PathFileExistsAndAttributesA()

BOOL WINAPI PathFileExistsAndAttributesA	(	LPCSTR	lpszPath,
		DWORD *	dwAttr
	)

Definition at line 1785 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 1811 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);
}

PathFileExistsDefExtA()

BOOL WINAPI PathFileExistsDefExtA	(	LPSTR	lpszPath,
		DWORD	dwWhich
	)

Definition at line 1174 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 1112 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);
    if (!*szExt || dwWhich & 0x40)
    {
      size_t iChoose = 0;
      int iLen = lstrlenW(lpszPath);
      if (iLen > (MAX_PATH - 5))
        return FALSE;
      while ( (dwWhich & 0x1) && pszExts[iChoose][0] )
      {
        lstrcpyW(lpszPath + iLen, pszExts[iChoose]);
        if (PathFileExistsW(lpszPath))
          return TRUE;
        iChoose++;
        dwWhich >>= 1;
      }
      *(lpszPath + iLen) = (WCHAR)'\0';
      return FALSE;
    }
  }
  return PathFileExistsW(lpszPath);
}

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

PathFileExistsW()

BOOL WINAPI PathFileExistsW

(

LPCWSTR

lpszPath

)

Definition at line 1756 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(), copy_dir_to_dir(), copy_file(), copy_file_to_file(), copy_files(), copy_to_dir(), create_dest_dirs(), DoGetZipName(), DoTestEntry(), FILEDLG95_InitControls(), FILEDLG95_OnOpen(), HACKISH_PathResolve(), CFileDefExt::InitOpensWithField(), LoadOSList(), move_files(), on_default_action(), CShellLink::OnNotify(), PathFileExistsAW(), PathFileExistsDefExtW(), ATL::CPathT< StringType >::PathFileExistsX(), PathYetAnotherMakeUniqueName(), SHAddToRecentDocs(), ShellExecCmdLine(), SHExplorerParseCmdLine(), SHGetFolderPathAndSubDirW(), SHGetWebFolderFilePathW(), ShowCreateShortcutWizard(), START_TEST(), and try_find_new_name().

PathFindExtensionA()

LPSTR WINAPI PathFindExtensionA

(

LPCSTR

lpszPath

)

Definition at line 417 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 _ILGetExtension(), 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 442 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 CFSDropTarget::_DoDrop(), add_favs_to_menu(), COpenWithList::AddAppToMRUList(), CFSFolder::CompareIDs(), CRecycleBin::CompareIDs(), CreateShortcut(), CFontExt::Drop(), FD31_UpdateResult(), FILEDLG95_OnOpen(), FinishDlgProc(), FM_InitMenuPopup(), get_first_ext_from_spec(), CRecycleBin::GetDetailsOf(), CLayerUIPropPage::InitFile(), CFileDefExt::InitFileType(), COpenWithMenu::Initialize(), CFileDefExt::InitOpensWithField(), COpenWithMenu::InvokeCommand(), LoadPropSheetHandlers(), COpenWithList::LoadRecommended(), on_default_action(), CShellLink::OnNotify(), CDefView::OnNotify(), OpenKeyFromFileType(), PathAddExtensionW(), PathFileExistsDefExtW(), ATL::CPathT< StringType >::PathFindExtensionX(), PathGetExtensionW(), PathIsContentTypeW(), PathRemoveExtensionW(), PathRenameExtensionW(), PathUndecorateW(), PathYetAnotherMakeUniqueName(), process_extensions(), BtrfsContextMenu::reflink_copy(), COpenWithList::SetDefaultHandler(), CFSFolder::SetNameOf(), SH_GetTargetTypeByPath(), SHAddToRecentDocs(), SHELL_FS_HideExtension(), ShellExecute_GetClassKey(), SHGetFileInfoW(), ShowCreateShortcutWizard(), try_find_new_name(), and URLDownloadToCacheFileW().

PathFindFileNameA()

LPSTR WINAPI PathFindFileNameA

(

LPCSTR

lpszPath

)

Definition at line 368 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 _CZipAskPassword(), _CZipAskReplace(), FD31_UpdateResult(), FILEDLG95_OnOpen(), GetFileDialog95(), ATL::CPathT< StringType >::PathFindFileNameX(), and PathStripPathA().

PathFindFileNameW()

LPWSTR WINAPI PathFindFileNameW

(

LPCWSTR

lpszPath

)

Definition at line 389 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 CFSDropTarget::_DoDrop(), _ILCreate(), COpenWithList::Add(), CRecycleBin::CompareIDs(), copy_file(), copy_file_to_file(), create_target_directory(), CSendToMenu::CreateSendToFiles(), CDeskLinkDropHandler::Drop(), FD31_UpdateResult(), FILEDLG95_OnOpen(), CFileDefExt::GeneralPageProc(), get_volume_path_parent(), GetFileDialog95(), CShellLink::GetPath(), COpenWithDialog::Init(), CFileDefExt::InitFilePath(), CFileDefExt::InitGeneralPage(), CFileDefExt::InitOpensWithField(), COpenWithList::LoadFromProgIdKey(), LoadPropSheetHandlers(), msi_dialog_directorylist_up(), CShellLink::OnInitDialog(), PathCompactPathExW(), PathCompactPathW(), ATL::CPathT< StringType >::PathFindFileNameX(), PathStripPathW(), BtrfsContextMenu::reflink_copy(), SH_ShowPropertiesDialog(), SHAddToRecentDocs(), SHChangeNotify(), SHGetFileInfoW(), ShowCreateShortcutWizard(), and WelcomeDlgProc().

PathFindNextComponentA()

LPSTR WINAPI PathFindNextComponentA

(

LPCSTR

lpszPath

)

Definition at line 2535 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 2558 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 FILEDLG95_ValidatePathAction(), and PathRelativePathToW().

PathFindOnPathA()

BOOL WINAPI PathFindOnPathA	(	LPSTR	lpszFile,
		LPCSTR *	lppszOtherDirs
	)

Definition at line 1371 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 1286 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 1330 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().

PathFindOnPathW()

BOOL WINAPI PathFindOnPathW	(	LPWSTR	lpszFile,
		LPCWSTR *	lppszOtherDirs
	)

Definition at line 1382 of file path.c.

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

Referenced by DoEntry(), and HACKISH_PathResolve().

PathFindSuffixArrayA()

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

Definition at line 3972 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 4003 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 476 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 501 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 CShellLink::OnNotify(), PathRemoveArgsW(), and SHExplorerParseCmdLine().

PathGetCharTypeA()

UINT WINAPI PathGetCharTypeA

(

UCHAR

ch

)

Definition at line 3005 of file path.c.

{
  return PathGetCharTypeW(ch);
}

Referenced by PathCleanupSpec().

PathGetCharTypeW()

UINT WINAPI PathGetCharTypeW

(

WCHAR

ch

)

Definition at line 3015 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 533 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 548 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(), CDrivesFolder::ParseDisplayName(), CDesktopFolder::ParseDisplayName(), ATL::CPathT< StringType >::PathGetDriveNumberX(), PathIsNetworkPathW(), and test_PathGetDriveNumber().

PathIsContentTypeA()

BOOL WINAPI PathIsContentTypeA	(	LPCSTR	lpszPath,
		LPCSTR	lpszContentType
	)

Definition at line 2037 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 2060 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 1677 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 3890 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 3910 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 1702 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 copy_file(), create_target_directory(), DoAddFilesFromItem(), DoTestEntry(), CFontExt::Drop(), FILEDLG95_InitControls(), CFSFolder::GetCustomViewInfo(), getIconLocationForDrive(), getIconLocationForFolder(), CFileDefExt::Initialize(), LoadPropSheetHandlers(), PathIsDirectoryEmptyW(), ATL::CPathT< StringType >::PathIsDirectoryX(), SHAddToRecentDocs(), SHELL_execute(), SHExplorerParseCmdLine(), ShowCreateShortcutWizard(), and wWinMain().

PathIsFileSpecA()

BOOL WINAPI PathIsFileSpecA

(

LPCSTR

lpszPath

)

Definition at line 2091 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 2112 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(), and ATL::CPathT< StringType >::PathIsFileSpecX().

PathIsLFNFileSpecA()

BOOL WINAPI PathIsLFNFileSpecA

(

LPCSTR

lpszPath

)

Definition at line 3801 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 3842 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 3742 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 3768 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 2141 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 2156 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 1542 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 1558 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 COMDLG32_GetCanonicalPath(), CFontCache::Filename(), CFSFolder::GetCustomViewInfo(), getIconLocationForDrive(), getIconLocationForFolder(), msi_apply_transforms(), msi_dialog_verify_path(), MSI_OpenProductW(), OpenColorProfileW(), parse_file_list(), PathCombineW(), ATL::CPathT< StringType >::PathIsRelativeX(), SHCreateDirectoryExW(), ShellExecCmdLine(), SHGetFileInfoW(), and TestGetModuleFileNameW().

PathIsRootA()

BOOL WINAPI PathIsRootA

(

LPCSTR

lpszPath

)

Definition at line 1581 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(), and PathStripToRootA().

PathIsRootW()

BOOL WINAPI PathIsRootW

(

LPCWSTR

lpszPath

)

Definition at line 1621 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 PathIsRootAW(), ATL::CPathT< StringType >::PathIsRootX(), PathRemoveBackslashW(), PathStripToRootW(), and SH_ShowPropertiesDialog().

PathIsSameRootA()

BOOL WINAPI PathIsSameRootA	(	LPCSTR	lpszPath1,
		LPCSTR	lpszPath2
	)

Definition at line 1982 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 2003 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 2179 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 2197 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;
}

PathIsUNCA()

BOOL WINAPI PathIsUNCA

(

LPCSTR

lpszPath

)

Definition at line 2222 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 (WINVER >= _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 2280 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 2330 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 2357 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 2302 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 2245 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 (WINVER >= _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 CDesktopFolder::ParseDisplayName(), PathAppendW(), PathCombineW(), PathCommonPrefixW(), and ATL::CPathT< StringType >::PathIsUNCX().

PathIsValidCharA()

BOOL WINAPI PathIsValidCharA	(	char	c,
		DWORD	class
	)

Definition at line 4383 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 4396 of file path.c.

{
    if (c > 0x7e)
        return class & PATH_CHAR_CLASS_OTHER_VALID;

    return class & SHELL_charclass[c];
}

PathMakePrettyA()

BOOL WINAPI PathMakePrettyA

(

LPSTR

lpszPath

)

Definition at line 2647 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 2679 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 3079 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 3099 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().

PathMatchSingleMaskA()

static BOOL PathMatchSingleMaskA ( LPCSTR  name, LPCSTR  mask  )

static

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

PathMatchSingleMaskW()

static BOOL PathMatchSingleMaskW ( LPCWSTR  name, LPCWSTR  mask  )

static

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

PathMatchSpecA()

BOOL WINAPI PathMatchSpecA	(	LPCSTR	lpszPath,
		LPCSTR	lpszMask
	)

Definition at line 1914 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 1943 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 1062 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 1087 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 DoFileTypeIconLocation(), getIconLocationForDrive(), getIconLocationForFolder(), and CFileDefExt::InitFolderCustomizePage().

PathQuoteSpacesA()

VOID WINAPI PathQuoteSpacesA

(

LPSTR

lpszPath

)

Definition at line 950 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 973 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 3525 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 3551 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 751 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 774 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 CShellLink::OnNotify(), and ATL::CPathT< StringType >::PathRemoveArgsX().

PathRemoveBackslashA()

LPSTR WINAPI PathRemoveBackslashA

(

LPSTR

lpszPath

)

Definition at line 842 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 862 of file path.c.

{