Document, implement/fix and test 110+ Path functions.
Share the GET_FUNC macro, other places than ordinal.c need it.
diff --git a/dlls/shlwapi/ordinal.c b/dlls/shlwapi/ordinal.c
index 5680fae..133137c 100644
--- a/dlls/shlwapi/ordinal.c
+++ b/dlls/shlwapi/ordinal.c
@@ -114,13 +114,6 @@
{0, 0}
};
-/* Macro to get function pointer for a module*/
-#define GET_FUNC(module, name, fail) \
- if (!SHLWAPI_h##module) SHLWAPI_h##module = LoadLibraryA(#module ".dll"); \
- if (!SHLWAPI_h##module) return fail; \
- if (!pfnFunc) pfnFunc = (void*)GetProcAddress(SHLWAPI_h##module, name); \
- if (!pfnFunc) return fail
-
/*
NOTES: Most functions exported by ordinal seem to be superflous.
The reason for these functions to be there is to provide a wraper
@@ -199,7 +192,7 @@
INT len;
if (y->size != 0x18) return E_INVALIDARG;
- /* FIXME: leading white space generates error of 0x80041001 which
+ /* FIXME: leading white space generates error of 0x80041001 which
* is undefined
*/
if (*x <= L' ') return 0x80041001;
@@ -246,6 +239,73 @@
}
/*************************************************************************
+ * @ [SHLWAPI.3]
+ *
+ * Determine if a file exists locally and is of an executable type.
+ *
+ * PARAMS
+ * lpszFile [O] File to search for
+ * dwWhich [I] Type of executable to search for
+ *
+ * RETURNS
+ * TRUE If the file was found. lpszFile contains the file name.
+ * FALSE Otherwise.
+ *
+ * NOTES
+ * lpszPath is modified in place and must be at least MAX_PATH in length.
+ * If the function returns FALSE, the path is modified to its orginal state.
+ * If the given path contains an extension or dwWhich is 0, executable
+ * extensions are not checked.
+ *
+ * Ordinals 3-6 are a classic case of MS exposing limited functionality to
+ * users (here through PathFindOnPath) and keeping advanced functionality for
+ * their own developers exclusive use. Monopoly, anyone?
+ */
+BOOL WINAPI SHLWAPI_3(LPSTR lpszFile,DWORD dwWhich)
+{
+ return SHLWAPI_PathFindLocalExeA(lpszFile,dwWhich);
+}
+
+/*************************************************************************
+ * @ [SHLWAPI.4]
+ *
+ * Unicode version of SHLWAPI_3.
+ */
+BOOL WINAPI SHLWAPI_4(LPWSTR lpszFile,DWORD dwWhich)
+{
+ return SHLWAPI_PathFindLocalExeW(lpszFile,dwWhich);
+}
+
+/*************************************************************************
+ * @ [SHLWAPI.5]
+ *
+ * Search a range of paths for a specific type of executable.
+ *
+ * PARAMS
+ * lpszFile [O] File to search for
+ * lppszOtherDirs [I] Other directories to look in
+ * dwWhich [I] Type of executable to search for
+ *
+ * RETURNS
+ * Success: TRUE. The path to the executable is stored in sFile.
+ * Failure: FALSE. The path to the executable is unchanged.
+ */
+BOOL WINAPI SHLWAPI_5(LPSTR lpszFile,LPCSTR *lppszOtherDirs,DWORD dwWhich)
+{
+ return SHLWAPI_PathFindOnPathExA(lpszFile,lppszOtherDirs,dwWhich);
+}
+
+/*************************************************************************
+ * @ [SHLWAPI.6]
+ *
+ * Unicode version of SHLWAPI_5.
+ */
+BOOL WINAPI SHLWAPI_6(LPWSTR lpszFile,LPCWSTR *lppszOtherDirs,DWORD dwWhich)
+{
+ return SHLWAPI_PathFindOnPathExW(lpszFile,lppszOtherDirs,dwWhich);
+}
+
+/*************************************************************************
* SHLWAPI_DupSharedHandle
*
* Internal implemetation of SHLWAPI_11.
diff --git a/dlls/shlwapi/ordinal.h b/dlls/shlwapi/ordinal.h
index bf2e130..5ce6e7b 100644
--- a/dlls/shlwapi/ordinal.h
+++ b/dlls/shlwapi/ordinal.h
@@ -43,3 +43,17 @@
DWORD WINAPI SHLWAPI_2(LPCWSTR x, UNKNOWN_SHLWAPI_2 *y);
+/* Macro to get function pointer for a module*/
+#define GET_FUNC(module, name, fail) \
+ if (!SHLWAPI_h##module) SHLWAPI_h##module = LoadLibraryA(#module ".dll"); \
+ if (!SHLWAPI_h##module) return fail; \
+ if (!pfnFunc) pfnFunc = (void*)GetProcAddress(SHLWAPI_h##module, name); \
+ if (!pfnFunc) return fail
+
+extern HMODULE SHLWAPI_hshell32;
+
+/* Shared internal functions */
+BOOL WINAPI SHLWAPI_PathFindLocalExeA(LPSTR lpszPath, DWORD dwWhich);
+BOOL WINAPI SHLWAPI_PathFindLocalExeW(LPWSTR lpszPath, DWORD dwWhich);
+BOOL WINAPI SHLWAPI_PathFindOnPathExA(LPSTR lpszFile,LPCSTR *lppszOtherDirs,DWORD dwWhich);
+BOOL WINAPI SHLWAPI_PathFindOnPathExW(LPWSTR lpszFile,LPCWSTR *lppszOtherDirs,DWORD dwWhich);
diff --git a/dlls/shlwapi/path.c b/dlls/shlwapi/path.c
index 603fa86..bd870a4 100644
--- a/dlls/shlwapi/path.c
+++ b/dlls/shlwapi/path.c
@@ -2,6 +2,7 @@
* Path Functions
*
* Copyright 1999, 2000 Juergen Schmied
+ * Copyright 2001, 2002 Jon Griffiths
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -35,978 +36,1560 @@
WINE_DEFAULT_DEBUG_CHANNEL(shell);
-INT __cdecl _wtoi(LPWSTR string);
-
-#define isSlash(x) ((x)=='\\' || (x)=='/')
-/*
- ########## Combining and Constructing paths ##########
-*/
-
/*************************************************************************
- * PathAppendA [SHLWAPI.@]
- *
- * NOTES
- * concat path lpszPath2 onto lpszPath1
+ * PathAppendA [SHLWAPI.@]
*
- * FIXME
- * the resulting path is also canonicalized
+ * Append one path to another.
+ *
+ * PARAMS
+ * lpszPath [O] Initial part of path
+ * lpszAppend [I] Path to append
+ *
+ * RETURNS
+ * Success: TRUE. lpszPath contains the newly created path.
+ * Failure: FALSE, if either path is NULL, or PathCombineA fails.
+ *
+ * NOTES
+ * lpszAppend must contain at least one backslash ('\') if not NULL.
+ * Because PathCombineA is used to join the paths, the resulting
+ * path is also canonicalized.
*/
-BOOL WINAPI PathAppendA(
- LPSTR lpszPath1,
- LPCSTR lpszPath2)
+BOOL WINAPI PathAppendA (LPSTR lpszPath, LPCSTR lpszAppend)
{
- TRACE("%s %s\n",lpszPath1, lpszPath2);
- while (lpszPath2[0]=='\\') lpszPath2++;
- PathCombineA(lpszPath1,lpszPath1,lpszPath2);
- return TRUE;
+ TRACE("(%s,%s)\n",debugstr_a(lpszPath), debugstr_a(lpszAppend));
+
+ if (lpszPath && lpszAppend)
+ {
+ while (*lpszAppend == '\\')
+ lpszAppend++;
+ if (PathCombineA(lpszPath, lpszPath, lpszAppend))
+ return TRUE;
+ }
+ return FALSE;
}
/*************************************************************************
- * PathAppendW [SHLWAPI.@]
+ * PathAppendW [SHLWAPI.@]
+ *
+ * See PathAppendA.
*/
-BOOL WINAPI PathAppendW(
- LPWSTR lpszPath1,
- LPCWSTR lpszPath2)
+BOOL WINAPI PathAppendW(LPWSTR lpszPath, LPCWSTR lpszAppend)
{
- TRACE("%s %s\n",debugstr_w(lpszPath1), debugstr_w(lpszPath2));
- while (lpszPath2[0]=='\\') lpszPath2++;
- PathCombineW(lpszPath1,lpszPath1,lpszPath2);
- return TRUE;
+ TRACE("(%s,%s)\n",debugstr_w(lpszPath), debugstr_w(lpszAppend));
+
+ if (lpszPath && lpszAppend)
+ {
+ while (*lpszAppend == '\\')
+ lpszAppend++;
+ if (PathCombineW(lpszPath, lpszPath, lpszAppend))
+ return TRUE;
+ }
+ return FALSE;
}
/*************************************************************************
* PathCombineA [SHLWAPI.@]
- *
- * NOTES
- * if lpszFile='.' skip it
- * szDest can be equal to lpszFile. Thats why we use sTemp
*
- * FIXME
- * the resulting path is also canonicalized
+ * Combine two paths together.
+ *
+ * PARAMS
+ * lpszDest [O] Destination for combined path
+ * lpszDir [I] Directory path
+ * liszFile [I] File path
+ *
+ * RETURNS
+ * Success: The output path
+ * Failure: NULL, if inputs are invalid.
+ *
+ * NOTES
+ * lpszDest should be at least MAX_PATH in size, and may point to the same
+ * memory location as lpszDir. The combined path is canonicalised.
*/
-LPSTR WINAPI PathCombineA(
- LPSTR szDest,
- LPCSTR lpszDir,
- LPCSTR lpszFile)
+LPSTR WINAPI PathCombineA(LPSTR lpszDest, LPCSTR lpszDir, LPCSTR lpszFile)
{
- char sTemp[MAX_PATH];
- TRACE("%p %p->%s %p->%s\n",szDest, lpszDir, lpszDir, lpszFile, lpszFile);
-
-
- if (!lpszFile || !lpszFile[0] || (lpszFile[0]=='.' && !lpszFile[1]) )
- {
- strcpy(szDest,lpszDir);
- return szDest;
- }
+ TRACE("(%p,%s,%s)\n", lpszDest, debugstr_a(lpszDir), debugstr_a(lpszFile));
- /* if lpszFile is a complete path don't care about lpszDir */
- if (PathGetDriveNumberA(lpszFile) != -1)
- {
- strcpy(szDest,lpszFile);
- }
- else if (lpszFile[0] == '\\' )
- {
- strcpy(sTemp,lpszDir);
- PathStripToRootA(sTemp);
- strcat(sTemp,lpszFile);
- strcpy(szDest,sTemp);
- }
- else
- {
- strcpy(sTemp,lpszDir);
- PathAddBackslashA(sTemp);
- strcat(sTemp,lpszFile);
- strcpy(szDest,sTemp);
- }
- return szDest;
+ if (!lpszDest || (!lpszDir && !lpszFile))
+ return NULL; /* Invalid parameters */
+ else
+ {
+ WCHAR szDest[MAX_PATH];
+ WCHAR szDir[MAX_PATH];
+ WCHAR szFile[MAX_PATH];
+ if (lpszDir)
+ MultiByteToWideChar(0,0,lpszDir,-1,szDir,MAX_PATH);
+ if (lpszFile)
+ MultiByteToWideChar(0,0,lpszFile,-1,szFile,MAX_PATH);
+ PathCombineW(szDest, lpszDir ? szDir : NULL, lpszFile ? szFile : NULL);
+ WideCharToMultiByte(0,0,szDest,-1,lpszDest,MAX_PATH,0,0);
+ }
+ return lpszDest;
}
/*************************************************************************
* PathCombineW [SHLWAPI.@]
+ *
+ * See PathCombineA.
*/
-LPWSTR WINAPI PathCombineW(
- LPWSTR szDest,
- LPCWSTR lpszDir,
- LPCWSTR lpszFile)
+LPWSTR WINAPI PathCombineW(LPWSTR lpszDest, LPCWSTR lpszDir, LPCWSTR lpszFile)
{
- WCHAR sTemp[MAX_PATH];
- TRACE("%p %p->%s %p->%s\n",szDest, lpszDir, debugstr_w(lpszDir),
- lpszFile, debugstr_w(lpszFile));
-
-
- if (!lpszFile || !lpszFile[0] || (lpszFile[0]==(WCHAR)'.' && !lpszFile[1]) )
- {
- strcpyW(szDest,lpszDir);
- return szDest;
- }
+ WCHAR szTemp[MAX_PATH];
+ BOOL bUseBoth = FALSE, bStrip = FALSE;
- /* if lpszFile is a complete path don't care about lpszDir */
- if (PathGetDriveNumberW(lpszFile) != -1)
- {
- strcpyW(szDest,lpszFile);
- }
- else if (lpszFile[0] == (WCHAR)'\\' )
- {
- strcpyW(sTemp,lpszDir);
- PathStripToRootW(sTemp);
- strcatW(sTemp,lpszFile);
- strcpyW(szDest,sTemp);
- }
- else
- {
- strcpyW(sTemp,lpszDir);
- PathAddBackslashW(sTemp);
- strcatW(sTemp,lpszFile);
- strcpyW(szDest,sTemp);
- }
- return szDest;
+ TRACE("(%p,%s,%s)\n", lpszDest, debugstr_w(lpszDir), debugstr_w(lpszFile));
+
+ if (!lpszDest || (!lpszDir && !lpszFile))
+ return lpszDest; /* Invalid parameters */
+
+ if (!lpszFile || !*lpszFile)
+ {
+ /* Use dir only */
+ strncpyW(szTemp, lpszDir, MAX_PATH);
+ }
+ else if (!lpszDir || !*lpszDir || !PathIsRelativeW(lpszFile))
+ {
+ if (!lpszDir || !*lpszDir || *lpszFile != '\\' || PathIsUNCW(lpszFile))
+ {
+ /* Use file only */
+ strncpyW(szTemp, lpszFile, MAX_PATH);
+ }
+ else
+ {
+ bUseBoth = TRUE;
+ bStrip = TRUE;
+ }
+ }
+ else
+ bUseBoth = TRUE;
+
+ if (bUseBoth)
+ {
+ strncpyW(szTemp, lpszDir, MAX_PATH);
+ if (bStrip)
+ {
+ PathStripToRootW(szTemp);
+ lpszFile++; /* Skip '\' */
+ }
+ if (!PathAddBackslashW(szTemp))
+ return NULL;
+ if (strlenW(szTemp) + strlenW(lpszFile) >= MAX_PATH)
+ return NULL;
+ strcatW(szTemp, lpszFile);
+ }
+
+ PathCanonicalizeW(lpszDest, szTemp);
+ return lpszDest;
}
/*************************************************************************
* PathAddBackslashA [SHLWAPI.@]
*
- * NOTES
- * append \ if there is none
+ * Append a backslash ('\') to a path if one doesn't exist.
+ *
+ * PARAMS
+ * lpszPath [O] The path to append a backslash to.
+ *
+ * RETURNS
+ * Success: The position of the last backslash in the path.
+ * Failure: NULL, if lpszPath is NULL or the path is too large.
*/
LPSTR WINAPI PathAddBackslashA(LPSTR lpszPath)
{
- int len;
- TRACE("%p->%s\n",lpszPath,lpszPath);
+ int iLen;
- len = strlen(lpszPath);
- if (len && lpszPath[len-1]!='\\')
- {
- lpszPath[len] = '\\';
- lpszPath[len+1]= 0x00;
- return lpszPath+len+1;
- }
- return lpszPath+len;
+ TRACE("(%s)\n",debugstr_a(lpszPath));
+
+ if (!lpszPath || (iLen = strlen(lpszPath)) >= MAX_PATH)
+ return NULL;
+
+ if (iLen)
+ {
+ lpszPath += iLen;
+ if (lpszPath[-1] != '\\')
+ {
+ *lpszPath++ = '\\';
+ *lpszPath = '\0';
+ }
+ }
+ return lpszPath;
}
/*************************************************************************
- * PathAddBackslashW [SHLWAPI.@]
+ * PathAddBackslashW [SHLWAPI.@]
+ *
+ * See PathAddBackslashA.
*/
-LPWSTR WINAPI PathAddBackslashW(LPWSTR lpszPath)
+LPWSTR WINAPI PathAddBackslashW( LPWSTR lpszPath )
{
- int len;
- TRACE("%p->%s\n",lpszPath,debugstr_w(lpszPath));
+ int iLen;
- len = strlenW(lpszPath);
- if (len && lpszPath[len-1]!=(WCHAR)'\\')
- {
- lpszPath[len] = (WCHAR)'\\';
- lpszPath[len+1]= 0x00;
- return lpszPath+len+1;
- }
- return lpszPath+len;
+ 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;
}
/*************************************************************************
- * PathBuildRootA [SHLWAPI.@]
+ * PathBuildRootA [SHLWAPI.@]
+ *
+ * Create a root drive string (e.g. "A:\") from a drive number.
+ *
+ * PARAMS
+ * lpszPath [O] Destination for the drive string
+ *
+ * RETURNS
+ * lpszPath
+ *
+ * NOTES
+ * If lpszPath is NULL or drive is invalid, nothing is written to lpszPath.
*/
-LPSTR WINAPI PathBuildRootA(LPSTR lpszPath, int drive)
+LPSTR WINAPI PathBuildRootA(LPSTR lpszPath, int drive)
{
- TRACE("%p %i\n",lpszPath, drive);
+ TRACE("(%p,%d)\n", debugstr_a(lpszPath), drive);
- strcpy(lpszPath,"A:\\");
- lpszPath[0]+=drive;
- return lpszPath;
+ if (lpszPath && drive >= 0 && drive < 26)
+ {
+ lpszPath[0] = 'A' + drive;
+ lpszPath[1] = ':';
+ lpszPath[2] = '\\';
+ lpszPath[3] = '\0';
+ }
+ return lpszPath;
}
/*************************************************************************
- * PathBuildRootW [SHLWAPI.@]
+ * PathBuildRootW [SHLWAPI.@]
+ *
+ * See PathBuildRootA.
*/
-LPWSTR WINAPI PathBuildRootW(LPWSTR lpszPath, int drive)
+LPWSTR WINAPI PathBuildRootW(LPWSTR lpszPath, int drive)
{
- lpszPath[0] = 'A' + drive;
- lpszPath[1] = ':';
- lpszPath[2] = '\\';
- lpszPath[3] = 0;
- TRACE("%p %i\n",debugstr_w(lpszPath), drive);
- return lpszPath;
+ TRACE("(%p,%d)\n",debugstr_w(lpszPath), drive);
+
+ if (lpszPath && drive >= 0 && drive < 26)
+ {
+ lpszPath[0] = 'A' + drive;
+ lpszPath[1] = ':';
+ lpszPath[2] = '\\';
+ lpszPath[3] = '\0';
+ }
+ return lpszPath;
}
-/*
- Extracting Component Parts
-*/
-
/*************************************************************************
- * PathFindFileNameA [SHLWAPI.@]
+ * PathFindFileNameA [SHLWAPI.@]
+ *
+ * Locate the start of the file name in a path
+ *
+ * PARAMS
+ * lpszPath [I] Path to search
+ *
+ * RETURNS
+ * A pointer to the first character of the file name
*/
LPSTR WINAPI PathFindFileNameA(LPCSTR lpszPath)
{
- LPCSTR lastSlash = lpszPath;
+ LPCSTR lastSlash = lpszPath;
- TRACE("%s\n",lpszPath);
- while (*lpszPath)
- {
- if ( isSlash(lpszPath[0]) && lpszPath[1])
- lastSlash = lpszPath+1;
- lpszPath = CharNextA(lpszPath);
- }
- return (LPSTR)lastSlash;
+ 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;
}
/*************************************************************************
- * PathFindFileNameW [SHLWAPI.@]
+ * PathFindFileNameW [SHLWAPI.@]
+ *
+ * See PathFindFileNameA.
*/
LPWSTR WINAPI PathFindFileNameW(LPCWSTR lpszPath)
{
- LPCWSTR wslash;
- wslash = lpszPath;
+ LPCWSTR lastSlash = lpszPath;
- TRACE("%s\n",debugstr_w(wslash));
- while (lpszPath[0])
- {
- if (((lpszPath[0]=='\\') || (lpszPath[0]==':')) && lpszPath[1] && lpszPath[1]!='\\')
- wslash = lpszPath+1;
- lpszPath = CharNextW(lpszPath);
- }
- return (LPWSTR)wslash;
+ TRACE("(%s)\n",debugstr_w(lpszPath));
+
+ while (lpszPath && *lpszPath)
+ {
+ if ((*lpszPath == '\\' || *lpszPath == '/' || *lpszPath == ':') &&
+ lpszPath[1] && lpszPath[1] != '\\' && lpszPath[1] != '/')
+ lastSlash = lpszPath + 1;
+ lpszPath = CharNextW(lpszPath);
+ }
+ return (LPWSTR)lastSlash;
}
/*************************************************************************
- * PathFindExtensionA [SHLWAPI.@]
+ * PathFindExtensionA [SHLWAPI.@]
+ *
+ * Locate the start of the file extension in a path
+ *
+ * PARAMS
+ * lpszPath [I] The path to search
+ *
+ * RETURNS
+ * A pointer to the first character of the extension, the end of
+ * the string if the path has no extension, or NULL If lpszPath is NULL
+ */
+LPSTR WINAPI PathFindExtensionA( LPCSTR lpszPath )
+{
+ 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);
+}
+
+/*************************************************************************
+ * PathFindExtensionW [SHLWAPI.@]
+ *
+ * See PathFindExtensionA.
+ */
+LPWSTR WINAPI PathFindExtensionW( LPCWSTR lpszPath )
+{
+ LPCWSTR lastpoint = NULL;
+
+ TRACE("(%s)\n", debugstr_w(lpszPath));
+
+ if (lpszPath)
+ {
+ while (*lpszPath)
+ {
+ if (*lpszPath == '\\' || *lpszPath==' ')
+ lastpoint = NULL;
+ else if (*lpszPath == '.')
+ lastpoint = lpszPath;
+ lpszPath = CharNextW(lpszPath);
+ }
+ }
+ return (LPWSTR)(lastpoint ? lastpoint : lpszPath);
+}
+
+/*************************************************************************
+ * PathGetArgsA [SHLWAPI.@]
+ *
+ * Find the next argument in a string delimited by spaces.
+ *
+ * PARAMS
+ * lpszPath [I] The string to search for arguments in
+ *
+ * RETURNS
+ * The start of the next argument in lpszPath, or NULL if lpszPath is NULL
*
* NOTES
- * returns pointer to last . in last lpszPath component or at \0.
+ * Spaces in quoted strings are ignored as delimiters.
*/
-
-LPSTR WINAPI PathFindExtensionA(LPCSTR lpszPath)
+LPSTR WINAPI PathGetArgsA(LPCSTR lpszPath)
{
- LPCSTR lastpoint = NULL;
+ BOOL bSeenQuote = FALSE;
- TRACE("%p %s\n",lpszPath,lpszPath);
+ TRACE("(%s)\n",debugstr_a(lpszPath));
- while (*lpszPath)
- {
- if (*lpszPath=='\\'||*lpszPath==' ')
- lastpoint=NULL;
- if (*lpszPath=='.')
- lastpoint=lpszPath;
- lpszPath = CharNextA(lpszPath);
- }
- return (LPSTR)(lastpoint?lastpoint:lpszPath);
+ if (lpszPath)
+ {
+ while (*lpszPath)
+ {
+ if ((*lpszPath==' ') && !bSeenQuote)
+ return (LPSTR)lpszPath + 1;
+ if (*lpszPath == '"')
+ bSeenQuote = !bSeenQuote;
+ lpszPath = CharNextA(lpszPath);
+ }
+ }
+ return (LPSTR)lpszPath;
}
/*************************************************************************
- * PathFindExtensionW [SHLWAPI.@]
- */
-LPWSTR WINAPI PathFindExtensionW(LPCWSTR lpszPath)
-{
- LPCWSTR lastpoint = NULL;
-
- TRACE("(%p %s)\n",lpszPath,debugstr_w(lpszPath));
-
- while (*lpszPath)
- {
- if (*lpszPath==(WCHAR)'\\'||*lpszPath==(WCHAR)' ')
- lastpoint=NULL;
- if (*lpszPath==(WCHAR)'.')
- lastpoint=lpszPath;
- lpszPath = CharNextW(lpszPath);
- }
- return (LPWSTR)(lastpoint?lastpoint:lpszPath);
-}
-
-/*************************************************************************
- * PathGetArgsA [SHLWAPI.@]
+ * PathGetArgsW [SHLWAPI.@]
*
- * NOTES
- * look for next arg in string. handle "quoted" strings
- * returns pointer to argument *AFTER* the space. Or to the \0.
- *
- * FIXME
- * quoting by '\'
+ * See PathGetArgsA.
*/
-LPSTR WINAPI PathGetArgsA(LPCSTR lpszPath)
+LPWSTR WINAPI PathGetArgsW(LPCWSTR lpszPath)
{
- BOOL qflag = FALSE;
+ BOOL bSeenQuote = FALSE;
- TRACE("%s\n",lpszPath);
+ TRACE("(%s)\n",debugstr_w(lpszPath));
- while (*lpszPath)
- {
- if ((*lpszPath==' ') && !qflag)
- return (LPSTR)lpszPath+1;
- if (*lpszPath=='"')
- qflag=!qflag;
- lpszPath = CharNextA(lpszPath);
- }
- return (LPSTR)lpszPath;
-}
-
-/*************************************************************************
- * PathGetArgsW [SHLWAPI.@]
- */
-LPWSTR WINAPI PathGetArgsW(LPCWSTR lpszPath)
-{
- BOOL qflag = FALSE;
-
- TRACE("%s\n",debugstr_w(lpszPath));
-
- while (*lpszPath)
- {
- if ((*lpszPath==' ') && !qflag)
- return (LPWSTR)lpszPath+1;
- if (*lpszPath=='"')
- qflag=!qflag;
- lpszPath = CharNextW(lpszPath);
- }
- return (LPWSTR)lpszPath;
+ if (lpszPath)
+ {
+ while (*lpszPath)
+ {
+ if ((*lpszPath==' ') && !bSeenQuote)
+ return (LPWSTR)lpszPath + 1;
+ if (*lpszPath == '"')
+ bSeenQuote = !bSeenQuote;
+ lpszPath = CharNextW(lpszPath);
+ }
+ }
+ return (LPWSTR)lpszPath;
}
/*************************************************************************
* PathGetDriveNumberA [SHLWAPI.@]
+ *
+ * Return the drive number from a path
+ *
+ * PARAMS
+ * lpszPath [I] Path to get the drive number from
+ *
+ * RETURNS
+ * Success: The drive number corresponding to the drive in the path
+ * Failure: -1, if lpszPath contains no valid drive
*/
int WINAPI PathGetDriveNumberA(LPCSTR lpszPath)
{
- int chr = tolower(lpszPath[0]);
-
- TRACE ("%s\n",debugstr_a(lpszPath));
+ TRACE ("(%s)\n",debugstr_a(lpszPath));
- if (!lpszPath || lpszPath[1]!=':' || chr < 'a' || chr > 'z') return -1;
- return tolower(lpszPath[0]) - 'a' ;
+ if (lpszPath && !IsDBCSLeadByte(*lpszPath) && lpszPath[1] == ':' &&
+ tolower(*lpszPath) >= 'a' && tolower(*lpszPath) <= 'z')
+ return tolower(*lpszPath) - 'a';
+ return -1;
}
/*************************************************************************
* PathGetDriveNumberW [SHLWAPI.@]
+ *
+ * See PathGetDriveNumberA.
*/
int WINAPI PathGetDriveNumberW(LPCWSTR lpszPath)
{
- int chr = tolowerW(lpszPath[0]);
-
- TRACE ("%s\n",debugstr_w(lpszPath));
+ TRACE ("(%s)\n",debugstr_w(lpszPath));
- if (!lpszPath || lpszPath[1]!=':' || chr < 'a' || chr > 'z') return -1;
- return tolowerW(lpszPath[0]) - 'a' ;
+ if (lpszPath && lpszPath[1] == ':' &&
+ tolowerW(*lpszPath) >= 'a' && tolowerW(*lpszPath) <= 'z')
+ return tolowerW(*lpszPath) - 'a';
+ return -1;
}
/*************************************************************************
* PathRemoveFileSpecA [SHLWAPI.@]
- *
- * NOTES
- * truncates passed argument to a valid path
- * returns if the string was modified or not.
- * "\foo\xx\foo"-> "\foo\xx"
- * "\" -> "\"
- * "a:\foo" -> "a:\"
+ *
+ * Remove the file specification from a path.
+ *
+ * PARAMS
+ * lpszPath [O] Path to remove the file spec from
+ *
+ * RETURNS
+ * TRUE If the path was valid and modified
+ * FALSE Otherwise
*/
BOOL WINAPI PathRemoveFileSpecA(LPSTR lpszPath)
{
- LPSTR cutplace = lpszPath;
- BOOL ret = FALSE;
-
- TRACE("%s\n",lpszPath);
+ LPSTR lpszFileSpec = lpszPath;
+ BOOL bModified = FALSE;
- if(lpszPath)
- {
- while (*lpszPath == '\\') cutplace = ++lpszPath;
-
- while (*lpszPath)
- {
- if(lpszPath[0] == '\\') cutplace = lpszPath;
-
- if(lpszPath[0] == ':')
- {
- cutplace = lpszPath + 1;
- if (lpszPath[1] == '\\') cutplace++;
- lpszPath++;
- }
- lpszPath = CharNextA(lpszPath);
- if (!lpszPath) break;
- }
-
- ret = (*cutplace!='\0');
- *cutplace = '\0';
- }
- return ret;
+ 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;
}
/*************************************************************************
* PathRemoveFileSpecW [SHLWAPI.@]
+ *
+ * See PathRemoveFileSpecA.
*/
BOOL WINAPI PathRemoveFileSpecW(LPWSTR lpszPath)
{
- LPWSTR cutplace = lpszPath;
- BOOL ret = FALSE;
+ LPWSTR lpszFileSpec = lpszPath;
+ BOOL bModified = FALSE;
- TRACE("%s\n",debugstr_w(lpszPath));
+ TRACE("(%s)\n",debugstr_w(lpszPath));
- if(lpszPath)
- {
- while (*lpszPath == '\\') cutplace = ++lpszPath;
-
- while (*lpszPath)
- {
- if(lpszPath[0] == '\\') cutplace = lpszPath;
-
- if(lpszPath[0] == ':')
- {
- cutplace = lpszPath + 1;
- if (lpszPath[1] == '\\') cutplace++;
- lpszPath++;
- }
- lpszPath = CharNextW(lpszPath);
- if (!lpszPath) break;
- }
-
- ret = (*cutplace!='\0');
- *cutplace = '\0';
- }
- return ret;
+ 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 = CharNextW(lpszPath)))
+ break;
+ }
+
+ if (*lpszFileSpec)
+ {
+ *lpszFileSpec = '\0';
+ bModified = TRUE;
+ }
+ }
+ return bModified;
}
/*************************************************************************
* PathStripPathA [SHLWAPI.@]
- *
- * NOTES
- * removes the path from the beginning of a filename
+ *
+ * Remove the initial path from the beginning of a filename
+ *
+ * PARAMS
+ * lpszPath [O] Path to remove the initial path from
+ *
+ * RETURNS
+ * Nothing.
*/
void WINAPI PathStripPathA(LPSTR lpszPath)
{
- LPSTR lpszFileName = PathFindFileNameA(lpszPath);
+ TRACE("(%s)\n", debugstr_a(lpszPath));
- TRACE("%s\n", lpszPath);
-
- if(lpszFileName)
- RtlMoveMemory(lpszPath, lpszFileName, strlen(lpszFileName)+1);
+ if (lpszPath)
+ {
+ LPSTR lpszFileName = PathFindFileNameA(lpszPath);
+ if(lpszFileName)
+ RtlMoveMemory(lpszPath, lpszFileName, strlen(lpszFileName)+1);
+ }
}
/*************************************************************************
* PathStripPathW [SHLWAPI.@]
+ *
+ * See PathStripPathA.
*/
void WINAPI PathStripPathW(LPWSTR lpszPath)
{
- LPWSTR lpszFileName = PathFindFileNameW(lpszPath);
+ LPWSTR lpszFileName;
- TRACE("%s\n", debugstr_w(lpszPath));
- if(lpszFileName)
- RtlMoveMemory(lpszPath, lpszFileName, (strlenW(lpszFileName)+1)*sizeof(WCHAR));
+ TRACE("(%s)\n", debugstr_w(lpszPath));
+ lpszFileName = PathFindFileNameW(lpszPath);
+ if(lpszFileName)
+ RtlMoveMemory(lpszPath, lpszFileName, (strlenW(lpszFileName)+1)*sizeof(WCHAR));
}
/*************************************************************************
* PathStripToRootA [SHLWAPI.@]
+ *
+ * Reduce a path to its root.
+ *
+ * PARAMS
+ * lpszPath [O] the path to reduce
+ *
+ * RETURNS
+ * Success: TRUE if the stripped path is a root path
+ * Failure: FALSE if the path cannot be stripped or is NULL
*/
BOOL WINAPI PathStripToRootA(LPSTR lpszPath)
{
- TRACE("%s\n", lpszPath);
+ TRACE("(%s)\n", debugstr_a(lpszPath));
- if (!lpszPath) return FALSE;
- while(!PathIsRootA(lpszPath))
- if (!PathRemoveFileSpecA(lpszPath)) return FALSE;
- return TRUE;
+ if (!lpszPath)
+ return FALSE;
+ while(!PathIsRootA(lpszPath))
+ if (!PathRemoveFileSpecA(lpszPath))
+ return FALSE;
+ return TRUE;
}
/*************************************************************************
* PathStripToRootW [SHLWAPI.@]
+ *
+ * See PathStripToRootA.
*/
BOOL WINAPI PathStripToRootW(LPWSTR lpszPath)
{
- TRACE("%s\n", debugstr_w(lpszPath));
+ TRACE("(%s)\n", debugstr_w(lpszPath));
- if (!lpszPath) return FALSE;
- while(!PathIsRootW(lpszPath))
- if (!PathRemoveFileSpecW(lpszPath)) return FALSE;
- return TRUE;
+ if (!lpszPath)
+ return FALSE;
+ while(!PathIsRootW(lpszPath))
+ if (!PathRemoveFileSpecW(lpszPath))
+ return FALSE;
+ return TRUE;
}
/*************************************************************************
* PathRemoveArgsA [SHLWAPI.@]
*
+ * Strip space seperated arguments from a path.
+ *
+ * PARAMS
+ * lpszPath [I] Path to remove arguments from
+ *
+ * RETURNS
+ * Nothing.
*/
void WINAPI PathRemoveArgsA(LPSTR lpszPath)
{
- TRACE("%s\n",lpszPath);
-
- if(lpszPath)
- {
- LPSTR lpszArgs = PathGetArgsA(lpszPath);
- if (!*lpszArgs)
- {
- LPSTR lpszLastChar = CharPrevA(lpszPath, lpszArgs);
- if(*lpszLastChar==' ') *lpszLastChar = '\0';
- }
- }
+ 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';
+ }
+ }
}
/*************************************************************************
* PathRemoveArgsW [SHLWAPI.@]
+ *
+ * See PathRemoveArgsA.
*/
void WINAPI PathRemoveArgsW(LPWSTR lpszPath)
{
- TRACE("%s\n", debugstr_w(lpszPath));
+ TRACE("(%s)\n",debugstr_w(lpszPath));
- if(lpszPath)
- {
- LPWSTR lpszArgs = PathGetArgsW(lpszPath);
- if (!*lpszArgs)
- {
- LPWSTR lpszLastChar = CharPrevW(lpszPath, lpszArgs);
- if(*lpszLastChar==' ') *lpszLastChar = '\0';
- }
- }
+ if(lpszPath)
+ {
+ LPWSTR lpszArgs = PathGetArgsW(lpszPath);
+ if (*lpszArgs)
+ lpszArgs[-1] = '\0';
+ else
+ {
+ LPWSTR lpszLastChar = CharPrevW(lpszPath, lpszArgs);
+ if(*lpszLastChar == ' ')
+ *lpszLastChar = '\0';
+ }
+ }
}
/*************************************************************************
* PathRemoveExtensionA [SHLWAPI.@]
+ *
+ * Remove the file extension from a path
+ *
+ * PARAMS
+ * lpszPath [O] Path to remove the extension from
+ *
+ * RETURNS
+ * Nothing.
*/
void WINAPI PathRemoveExtensionA(LPSTR lpszPath)
{
- LPSTR lpszExtension = PathFindExtensionA(lpszPath);
+ TRACE("(%s)\n", debugstr_a(lpszPath));
- TRACE("%s\n", lpszPath);
-
- if (lpszExtension) *lpszExtension='\0';
+ if (lpszPath)
+ {
+ lpszPath = PathFindExtensionA(lpszPath);
+ *lpszPath = '\0';
+ }
}
/*************************************************************************
* PathRemoveExtensionW [SHLWAPI.@]
- */
+ *
+ * See PathRemoveExtensionA.
+*/
void WINAPI PathRemoveExtensionW(LPWSTR lpszPath)
{
- LPWSTR lpszExtension = PathFindExtensionW(lpszPath);
+ TRACE("(%s)\n", debugstr_w(lpszPath));
- TRACE("%s\n", debugstr_w(lpszPath));
-
- if (lpszExtension) *lpszExtension='\0';
+ if (lpszPath)
+ {
+ lpszPath = PathFindExtensionW(lpszPath);
+ *lpszPath = '\0';
+ }
}
/*************************************************************************
* PathRemoveBackslashA [SHLWAPI.@]
*
- * If the path ends in a backslash it is replaced by a NULL
- * and the address of the NULL is returned
- * Otherwise
- * the address of the last character is returned.
+ * Remove a trailing backslash from a path.
*
- * FIXME
- * "c:\": keep backslash
+ * PARAMS
+ * lpszPath [O] Path to remove backslash from
+ *
+ * RETURNS
+ * Success: A pointer to the end of the path
+ * Failure: NULL, if lpszPath is NULL
*/
LPSTR WINAPI PathRemoveBackslashA( LPSTR lpszPath )
{
- int len;
- LPSTR szTemp = NULL;
-
- if(lpszPath)
- {
- len = strlen(lpszPath);
- szTemp = CharPrevA(lpszPath, lpszPath+len);
- if (! PathIsRootA(lpszPath))
- {
- if (*szTemp == '\\') *szTemp = '\0';
- }
- }
- return szTemp;
+ 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;
}
/*************************************************************************
* PathRemoveBackslashW [SHLWAPI.@]
+ *
+ * See PathRemoveBackslashA.
*/
LPWSTR WINAPI PathRemoveBackslashW( LPWSTR lpszPath )
{
- int len;
- LPWSTR szTemp = NULL;
-
- if(lpszPath)
- {
- len = strlenW(lpszPath);
- szTemp = CharPrevW(lpszPath, lpszPath+len);
- if (! PathIsRootW(lpszPath))
- {
- if (*szTemp == '\\') *szTemp = '\0';
- }
- }
- return szTemp;
+ LPWSTR szTemp = NULL;
+
+ TRACE("(%s)\n", debugstr_w(lpszPath));
+
+ if(lpszPath)
+ {
+ szTemp = CharPrevW(lpszPath, lpszPath + strlenW(lpszPath));
+ if (!PathIsRootW(lpszPath) && *szTemp == '\\')
+ *szTemp = '\0';
+ }
+ return szTemp;
}
-
-/*
- Path Manipulations
-*/
-
/*************************************************************************
* PathRemoveBlanksA [SHLWAPI.@]
- *
- * NOTES
- * remove spaces from beginning and end of passed string
+ *
+ * Remove Spaces from the start and end of a path.
+ *
+ * PARAMS
+ * lpszPath [O] Path to strip blanks from
+ *
+ * RETURNS
+ * Nothing.
*/
-void WINAPI PathRemoveBlanksA(LPSTR str)
+VOID WINAPI PathRemoveBlanksA(LPSTR lpszPath)
{
- LPSTR x = str;
+ TRACE("(%s)\n", debugstr_a(lpszPath));
- TRACE("%s\n",str);
+ if(lpszPath && *lpszPath)
+ {
+ LPSTR start = lpszPath;
- if(str)
- {
- while (*x==' ') x = CharNextA(x);
- if (x!=str) strcpy(str,x);
- x=str+strlen(str)-1;
- while (*x==' ') x = CharPrevA(str, x);
- if (*x==' ') *x='\0';
- }
+ while (*lpszPath == ' ')
+ lpszPath = CharNextA(lpszPath);
+
+ while(*lpszPath)
+ *start++ = *lpszPath++;
+
+ if (start != lpszPath)
+ while (start[-1] == ' ')
+ start--;
+ *start = '\0';
+ }
}
/*************************************************************************
* PathRemoveBlanksW [SHLWAPI.@]
+ *
+ * See PathRemoveBlanksA.
*/
-void WINAPI PathRemoveBlanksW(LPWSTR str)
+VOID WINAPI PathRemoveBlanksW(LPWSTR lpszPath)
{
- LPWSTR x = str;
+ TRACE("(%s)\n", debugstr_w(lpszPath));
- TRACE("%s\n",debugstr_w(str));
+ if(lpszPath && *lpszPath)
+ {
+ LPWSTR start = lpszPath;
- if(str)
- {
- while (*x==' ') x = CharNextW(x);
- if (x!=str) strcpyW(str,x);
- x=str+strlenW(str)-1;
- while (*x==' ') x = CharPrevW(str, x);
- if (*x==' ') *x='\0';
- }
+ while (*lpszPath == ' ')
+ lpszPath++;
+
+ while(*lpszPath)
+ *start++ = *lpszPath++;
+
+ if (start != lpszPath)
+ while (start[-1] == ' ')
+ start--;
+ *start = '\0';
+ }
}
/*************************************************************************
* PathQuoteSpacesA [SHLWAPI.@]
- *
+ *
+ * Surround a path containg spaces in quotes.
+ *
+ * PARAMS
+ * lpszPath [O] Path to quote
+ *
+ * RETURNS
+ * Nothing.
+ *
+ * NOTES
+ * The path is not changed if it is invalid or has no spaces.
*/
-LPSTR WINAPI PathQuoteSpacesA(LPSTR lpszPath)
+VOID WINAPI PathQuoteSpacesA(LPSTR lpszPath)
{
- TRACE("%s\n",lpszPath);
+ TRACE("(%s)\n", debugstr_a(lpszPath));
- if(StrChrA(lpszPath,' '))
- {
- int len = strlen(lpszPath);
- RtlMoveMemory(lpszPath+1, lpszPath, len);
- *(lpszPath++) = '"';
- lpszPath += len;
- *(lpszPath++) = '"';
- *(lpszPath) = '\0';
- return --lpszPath;
- }
- return 0;
+ if(lpszPath && StrChrA(lpszPath,' '))
+ {
+ int iLen = strlen(lpszPath) + 1;
+
+ if (iLen + 2 < MAX_PATH)
+ {
+ memmove(lpszPath + 1, lpszPath, iLen);
+ lpszPath[0] = '"';
+ lpszPath[iLen] = '"';
+ lpszPath[iLen + 1] = '\0';
+ }
+ }
}
/*************************************************************************
* PathQuoteSpacesW [SHLWAPI.@]
+ *
+ * See PathQuoteSpacesA.
*/
-LPWSTR WINAPI PathQuoteSpacesW(LPWSTR lpszPath)
+VOID WINAPI PathQuoteSpacesW(LPWSTR lpszPath)
{
- TRACE("%s\n",debugstr_w(lpszPath));
+ TRACE("(%s)\n", debugstr_w(lpszPath));
- if(StrChrW(lpszPath,' '))
- {
- int len = strlenW(lpszPath);
- RtlMoveMemory(lpszPath+1, lpszPath, len*sizeof(WCHAR));
- *(lpszPath++) = '"';
- lpszPath += len;
- *(lpszPath++) = '"';
- *(lpszPath) = '\0';
- return --lpszPath;
- }
- return 0;
+ 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';
+ }
+ }
}
/*************************************************************************
* PathUnquoteSpacesA [SHLWAPI.@]
- *
+ *
+ * Remove quotes ("") from around a path, if present.
+ *
+ * PARAMS
+ * lpszPath [O] Path to strip quotes from
+ *
+ * RETURNS
+ * Nothing
+ *
* NOTES
- * unquote string (remove ")
+ * If the path contains a single quote only, an empty string will result.
+ * Otherwise quotes are only removed if they appear at the start and end
+ * of the path.
*/
-VOID WINAPI PathUnquoteSpacesA(LPSTR str)
+VOID WINAPI PathUnquoteSpacesA(LPSTR lpszPath)
{
- DWORD len = strlen(str);
+ TRACE("(%s)\n", debugstr_a(lpszPath));
- TRACE("%s\n",str);
+ if (lpszPath && *lpszPath == '"')
+ {
+ DWORD dwLen = strlen(lpszPath) - 1;
- if (*str!='"')
- return;
- if (str[len-1]!='"')
- return;
- str[len-1]='\0';
- strcpy(str,str+1);
- return;
+ if (lpszPath[dwLen] == '"')
+ {
+ lpszPath[dwLen] = '\0';
+ for (; *lpszPath; lpszPath++)
+ *lpszPath = lpszPath[1];
+ }
+ }
}
/*************************************************************************
* PathUnquoteSpacesW [SHLWAPI.@]
+ *
+ * See PathUnquoteSpacesA.
*/
-VOID WINAPI PathUnquoteSpacesW(LPWSTR str)
+VOID WINAPI PathUnquoteSpacesW(LPWSTR lpszPath)
{
- DWORD len = strlenW(str);
+ TRACE("(%s)\n", debugstr_w(lpszPath));
- TRACE("%s\n",debugstr_w(str));
+ if (lpszPath && *lpszPath == '"')
+ {
+ DWORD dwLen = strlenW(lpszPath) - 1;
- if (*str!='"')
- return;
- if (str[len-1]!='"')
- return;
- str[len-1]='\0';
- strcpyW(str,str+1);
- return;
+ if (lpszPath[dwLen] == '"')
+ {
+ lpszPath[dwLen] = '\0';
+ for (; *lpszPath; lpszPath++)
+ *lpszPath = lpszPath[1];
+ }
+ }
}
/*************************************************************************
- * PathParseIconLocationA [SHLWAPI.@]
+ * PathParseIconLocationA [SHLWAPI.@]
+ *
+ * Parse the location of an icon from a path.
+ *
+ * PARAMS
+ * lpszPath [O] The path to parse the icon location from.
+ *
+ * RETURNS
+ * Success: The number of the icon
+ * Failure: 0 if the path does not contain an icon location or is NULL
+ *
+ * NOTES
+ * The path has surrounding quotes and spaces removed regardless
+ * of whether the call succeeds or not.
*/
int WINAPI PathParseIconLocationA(LPSTR lpszPath)
{
- LPSTR lpstrComma = strchr(lpszPath, ',');
- int ret = 0;
-
- TRACE("%s\n", debugstr_a(lpszPath));
+ int iRet = 0;
+ LPSTR lpszComma;
- if (lpstrComma && lpstrComma[1])
- {
- lpstrComma[0]='\0';
- ret = atoi(&lpstrComma[1]);
- }
-
- PathUnquoteSpacesA(lpszPath);
- return ret;
+ TRACE("(%s)\n", debugstr_a(lpszPath));
+
+ if (lpszPath)
+ {
+ if ((lpszComma = strchr(lpszPath, ',')))
+ {
+ *lpszComma++ = '\0';
+ iRet = StrToIntA(lpszComma);
+ }
+ PathUnquoteSpacesA(lpszPath);
+ PathRemoveBlanksA(lpszPath);
+ }
+ return iRet;
}
/*************************************************************************
- * PathParseIconLocationW [SHLWAPI.@]
+ * PathParseIconLocationW [SHLWAPI.@]
+ *
+ * See PathParseIconLocationA.
*/
int WINAPI PathParseIconLocationW(LPWSTR lpszPath)
{
- LPWSTR lpstrComma = strchrW(lpszPath, ',');
- int ret = 0;
-
- TRACE("%s\n", debugstr_w(lpszPath));
+ int iRet = 0;
+ LPWSTR lpszComma;
- if (lpstrComma && lpstrComma[1])
- {
- lpstrComma[0]='\0';
- ret = _wtoi(&lpstrComma[1]);
- }
- PathUnquoteSpacesW(lpszPath);
- return ret;
+ TRACE("(%s)\n", debugstr_w(lpszPath));
+
+ if (lpszPath)
+ {
+ if ((lpszComma = StrChrW(lpszPath, ',')))
+ {
+ *lpszComma++ = '\0';
+ iRet = StrToIntW(lpszComma);
+ }
+ PathUnquoteSpacesW(lpszPath);
+ PathRemoveBlanksW(lpszPath);
+ }
+ return iRet;
}
-/*
- ########## cleaning and resolving paths ##########
+/*************************************************************************
+ * SHLWAPI_PathFindLocalExeA
+ *
+ * Internal implementation of SHLWAPI_3.
*/
+BOOL WINAPI SHLWAPI_PathFindLocalExeA (LPSTR lpszPath, DWORD dwWhich)
+{
+ BOOL bRet = FALSE;
+
+ TRACE("(%s,%ld)\n", debugstr_a(lpszPath), dwWhich);
+
+ if (lpszPath)
+ {
+ WCHAR szPath[MAX_PATH];
+ MultiByteToWideChar(0,0,lpszPath,-1,szPath,MAX_PATH);
+ bRet = SHLWAPI_PathFindLocalExeW(szPath, dwWhich);
+ if (bRet)
+ WideCharToMultiByte(0,0,szPath,-1,lpszPath,MAX_PATH,0,0);
+ }
+ return bRet;
+}
+
+/*************************************************************************
+ * SHLWAPI_PathFindLocalExeW
+ *
+ * Internal implementation of SHLWAPI_4.
+ */
+BOOL WINAPI SHLWAPI_PathFindLocalExeW (LPWSTR lpszPath, DWORD dwWhich)
+{
+ static const WCHAR pszExts[7][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,%ld)\n", debugstr_w(lpszPath), dwWhich);
+
+ if (!lpszPath || PathIsUNCServerW(lpszPath) || PathIsUNCServerShareW(lpszPath))
+ return FALSE;
+
+ if (dwWhich)
+ {
+ LPCWSTR szExt = PathFindExtensionW(lpszPath);
+ if (!*szExt || dwWhich & 0x40)
+ {
+ int iChoose = 0;
+ int iLen = lstrlenW(lpszPath);
+ if (iLen > (MAX_PATH - 5))
+ return FALSE;
+ while (dwWhich & 0x1 && iChoose < sizeof(pszExts))
+ {
+ lstrcpyW(lpszPath + iLen, pszExts[iChoose]);
+ if (PathFileExistsW(lpszPath))
+ return TRUE;
+ iChoose++;
+ dwWhich >>= 1;
+ }
+ *(lpszPath + iLen) = (WCHAR)'\0';
+ return FALSE;
+ }
+ }
+ return PathFileExistsW(lpszPath);
+}
+
+/*************************************************************************
+ * SHLWAPI_PathFindInOtherDirs
+ *
+ * Internal helper for SHLWAPI_PathFindOnPathExA/W.
+ */
+static BOOL WINAPI SHLWAPI_PathFindInOtherDirs(LPWSTR lpszFile, DWORD dwWhich)
+{
+ static WCHAR szSystem[] = { 'S','y','s','t','e','m','\0'};
+ static WCHAR szPath[] = { 'P','A','T','H','\0'};
+ DWORD dwLenPATH;
+ LPCWSTR lpszCurr;
+ WCHAR *lpszPATH;
+ WCHAR buff[MAX_PATH];
+
+ TRACE("(%s,%08lx)\n", debugstr_w(lpszFile), dwWhich);
+
+ /* Try system directories */
+ GetSystemDirectoryW(buff, MAX_PATH);
+ if (!PathAppendW(buff, lpszFile))
+ return FALSE;
+ if (SHLWAPI_PathFindLocalExeW(buff, dwWhich))
+ {
+ strcpyW(lpszFile, buff);
+ return TRUE;
+ }
+ GetWindowsDirectoryW(buff, MAX_PATH);
+ if (!PathAppendW(buff, szSystem ) || !PathAppendW(buff, lpszFile))
+ return FALSE;
+ if (SHLWAPI_PathFindLocalExeW(buff, dwWhich))
+ {
+ strcpyW(lpszFile, buff);
+ return TRUE;
+ }
+ GetWindowsDirectoryW(buff, MAX_PATH);
+ if (!PathAppendW(buff, lpszFile))
+ return FALSE;
+ if (SHLWAPI_PathFindLocalExeW(buff, dwWhich))
+ {
+ strcpyW(lpszFile, buff);
+ return TRUE;
+ }
+ /* Try dirs listed in %PATH% */
+ dwLenPATH = GetEnvironmentVariableW(szPath, buff, MAX_PATH);
+
+ if (!dwLenPATH || !(lpszPATH = malloc((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))
+ return FALSE;
+ if (SHLWAPI_PathFindLocalExeW(buff, dwWhich))
+ {
+ strcpyW(lpszFile, buff);
+ free(lpszPATH);
+ return TRUE;
+ }
+ }
+ free(lpszPATH);
+ return FALSE;
+}
+
+
+/*************************************************************************
+ * SHLWAPI_PathFindOnPathExA
+ *
+ * Internal implementation of SHLWAPI_5
+ */
+BOOL WINAPI SHLWAPI_PathFindOnPathExA(LPSTR lpszFile, LPCSTR *lppszOtherDirs, DWORD dwWhich)
+{
+ WCHAR szFile[MAX_PATH];
+ WCHAR buff[MAX_PATH];
+
+ TRACE("(%s,%p,%08lx)\n", debugstr_a(lpszFile), lppszOtherDirs, dwWhich);
+
+ if (!lpszFile || !PathIsFileSpecA(lpszFile))
+ return FALSE;
+
+ MultiByteToWideChar(0,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(0,0,*lpszOtherPath,-1,szOther,MAX_PATH);
+ PathCombineW(buff, szOther, szFile);
+ if (SHLWAPI_PathFindLocalExeW(buff, dwWhich))
+ {
+ WideCharToMultiByte(0,0,buff,-1,lpszFile,MAX_PATH,0,0);
+ return TRUE;
+ }
+ lpszOtherPath++;
+ }
+ }
+ /* Not found, try system and path dirs */
+ if (SHLWAPI_PathFindInOtherDirs(szFile, dwWhich))
+ {
+ WideCharToMultiByte(0,0,szFile,-1,lpszFile,MAX_PATH,0,0);
+ return TRUE;
+ }
+ return FALSE;
+}
+
+/*************************************************************************
+ * SHLWAPI_PathFindOnPathExW
+ *
+ * Internal implementation of SHLWAPI_6.
+ */
+BOOL WINAPI SHLWAPI_PathFindOnPathExW(LPWSTR lpszFile, LPCWSTR *lppszOtherDirs, DWORD dwWhich)
+{
+ WCHAR buff[MAX_PATH];
+
+ TRACE("(%s,%p,%08lx)\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 (SHLWAPI_PathFindLocalExeW(buff, dwWhich))
+ {
+ strcpyW(lpszFile, buff);
+ return TRUE;
+ }
+ lpszOtherPath++;
+ }
+ }
+ /* Not found, try system and path dirs */
+ return SHLWAPI_PathFindInOtherDirs(lpszFile, dwWhich);
+}
/*************************************************************************
* PathFindOnPathA [SHLWAPI.@]
+ *
+ * Search a range of paths for an executable.
+ *
+ * PARAMS
+ * lpszFile [O] File to search for
+ * lppszOtherDirs [I] Other directories to look in
+ *
+ * RETURNS
+ * Success: TRUE. The path to the executable is stored in lpszFile.
+ * Failure: FALSE. The path to the executable is unchanged.
*/
-BOOL WINAPI PathFindOnPathA(LPSTR sFile, LPCSTR *sOtherDirs)
+BOOL WINAPI PathFindOnPathA(LPSTR lpszFile, LPCSTR *lppszOtherDirs)
{
- FIXME("%s %p\n",sFile, sOtherDirs);
- return FALSE;
+ TRACE("(%s,%p)\n", debugstr_a(lpszFile), lppszOtherDirs);
+ return SHLWAPI_PathFindOnPathExA(lpszFile, lppszOtherDirs, 0);
+ }
+
+/*************************************************************************
+ * PathFindOnPathW [SHLWAPI.@]
+ *
+ * See PathFindOnPathA.
+ */
+BOOL WINAPI PathFindOnPathW (LPWSTR lpszFile, LPCWSTR *lppszOtherDirs)
+{
+ TRACE("(%s,%p)\n", debugstr_w(lpszFile), lppszOtherDirs);
+ return SHLWAPI_PathFindOnPathExW(lpszFile,lppszOtherDirs, 0);
}
/*************************************************************************
- * PathFindOnPathW [SHLWAPI.@]
+ * PathCompactPathExA [SHLWAPI.@]
+ *
+ * Compact a path.
+ *
+ * PARAMS
+ * lpszDest [O] Destination for compacted path
+ * lpszPath [I] Source path
+ * cchMax [I[ Size of lpszDest
+ * dwFlags [I] Compaction flags
+ *
+ * RETURNS
+ * FIXME
*/
-BOOL WINAPI PathFindOnPathW(LPWSTR sFile, LPCWSTR *sOtherDirs)
+BOOL WINAPI PathCompactPathExA(LPSTR lpszDest, LPCSTR lpszPath,
+ UINT cchMax, DWORD dwFlags)
{
- FIXME("%s %p\n",debugstr_w(sFile), sOtherDirs);
- return FALSE;
+ BOOL bRet = FALSE;
+
+ TRACE("(%p,%s,%d,0x%08lx)\n", lpszDest, debugstr_a(lpszPath), cchMax, dwFlags);
+
+ if (lpszPath && lpszDest)
+ {
+ WCHAR szPath[MAX_PATH];
+ WCHAR szDest[MAX_PATH];
+
+ MultiByteToWideChar(0,0,lpszPath,-1,szPath,MAX_PATH);
+ szDest[0] = '\0';
+ bRet = PathCompactPathExW(szDest, szPath, cchMax, dwFlags);
+ WideCharToMultiByte(0,0,szDest,-1,lpszDest,MAX_PATH,0,0);
+ }
+ return bRet;
}
/*************************************************************************
- * PathCompactPathExA [SHLWAPI.@]
+ * PathCompactPathExW [SHLWAPI.@]
+ *
+ * See PathCompactPathExA.
*/
-BOOL WINAPI PathCompactPathExA(
- LPSTR pszOut,
- LPCSTR pszSrc,
- UINT cchMax,
- DWORD dwFlags)
+BOOL WINAPI PathCompactPathExW(LPWSTR lpszDest, LPCWSTR lpszPath,
+ UINT cchMax, DWORD dwFlags)
{
- FIXME("%p %s 0x%08x 0x%08lx\n", pszOut, pszSrc, cchMax, dwFlags);
- return FALSE;
+ FIXME("(%p,%s,%d,0x%08lx)-stub\n", lpszDest, debugstr_w(lpszPath), cchMax, dwFlags);
+
+ if (!lpszPath)
+ return FALSE;
+
+ if (!lpszDest)
+ {
+ WARN("Invalid lpszDest would crash under Win32!\n");
+ return FALSE;
+ }
+
+ /* FIXME */
+
+ return FALSE;
}
/*************************************************************************
- * PathCompactPathExW [SHLWAPI.@]
- */
-BOOL WINAPI PathCompactPathExW(
- LPWSTR pszOut,
- LPCWSTR pszSrc,
- UINT cchMax,
- DWORD dwFlags)
-{
- FIXME("%p %s 0x%08x 0x%08lx\n", pszOut, debugstr_w(pszSrc), cchMax, dwFlags);
- return FALSE;
-}
-
-/*
- ########## Path Testing ##########
-*/
-
-/*************************************************************************
- * PathIsUNCA [SHLWAPI.@]
- *
- * NOTES
- * PathIsUNC(char*path);
- */
-BOOL WINAPI PathIsUNCA(LPCSTR lpszPath)
-{
- TRACE("%s\n",lpszPath);
-
- return (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'));
-}
-
-/*************************************************************************
- * PathIsUNCW [SHLWAPI.@]
- */
-BOOL WINAPI PathIsUNCW(LPCWSTR lpszPath)
-{
- TRACE("%s\n",debugstr_w(lpszPath));
-
- return (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'));
-}
-
-/*************************************************************************
- * PathIsRelativeA [SHLWAPI.@]
+ * PathIsRelativeA [SHLWAPI.@]
+ *
+ * Determine if a path is a relative path.
+ *
+ * PARAMS
+ * lpszPath [I] Path to check
+ *
+ * RETURNS
+ * TRUE: The path is relative, or is invalid.
+ * FALSE: The path is not relative.
*/
BOOL WINAPI PathIsRelativeA (LPCSTR lpszPath)
{
- TRACE("lpszPath=%s\n",lpszPath);
+ TRACE("(%s)\n",debugstr_a(lpszPath));
- return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
+ if (!lpszPath || !*lpszPath || IsDBCSLeadByte(*lpszPath))
+ return TRUE;
+ if (*lpszPath == '\\' || (*lpszPath && lpszPath[1] == ':'))
+ return FALSE;
+ return TRUE;
}
/*************************************************************************
* PathIsRelativeW [SHLWAPI.@]
+ *
+ * See PathIsRelativeA.
*/
BOOL WINAPI PathIsRelativeW (LPCWSTR lpszPath)
{
- TRACE("lpszPath=%s\n",debugstr_w(lpszPath));
+ TRACE("(%s)\n",debugstr_w(lpszPath));
- return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
+ if (!lpszPath || !*lpszPath)
+ return TRUE;
+ if (*lpszPath == '\\' || (*lpszPath && lpszPath[1] == ':'))
+ return FALSE;
+ return TRUE;
}
/*************************************************************************
* PathIsRootA [SHLWAPI.@]
*
- * notes
- * TRUE if the path points to a root directory
+ * Determine if a path is a root path.
+ *
+ * PARAMS
+ * lpszPath [I] Path to check
+ *
+ * RETURNS
+ * TRUE If lpszPath is valid and a root path
+ * FALSE Otherwise
*/
BOOL WINAPI PathIsRootA(LPCSTR lpszPath)
{
- TRACE("%s\n",lpszPath);
+ TRACE("(%s)\n", debugstr_a(lpszPath));
- /* X:\ */
- if (lpszPath[1]==':' && lpszPath[2]=='\\' && lpszPath[3]=='\0')
- return TRUE;
+ if (lpszPath && *lpszPath)
+ {
+ if (*lpszPath == '\\')
+ {
+ if (!lpszPath[1])
+ return TRUE; /* \ */
+ else if (lpszPath[1]=='\\')
+ {
+ BOOL bSeenSlash = FALSE;
+ lpszPath += 2;
- /* "\" */
- if (lpszPath[0]=='\\' && lpszPath[1]=='\0')
- return TRUE;
-
- /* UNC "\\<computer>\<share>" */
- if (lpszPath[0]=='\\' && lpszPath[1]=='\\')
- {
- int foundbackslash = 0;
- lpszPath += 2;
- while (*lpszPath)
- {
- if (*lpszPath=='\\') foundbackslash++;
- lpszPath = CharNextA(lpszPath);
- }
- if (foundbackslash <= 1)
- return TRUE;
- }
- return FALSE;
+ /* 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;
}
/*************************************************************************
* PathIsRootW [SHLWAPI.@]
+ *
+ * See PathIsRootA.
*/
-BOOL WINAPI PathIsRootW(LPCWSTR lpszPath)
+BOOL WINAPI PathIsRootW(LPCWSTR lpszPath)
{
- TRACE("%s\n",debugstr_w(lpszPath));
+ TRACE("(%s)\n", debugstr_w(lpszPath));
- /* X:\ */
- if (lpszPath[1]==':' && lpszPath[2]=='\\' && lpszPath[3]=='\0')
- return TRUE;
+ if (lpszPath && *lpszPath)
+ {
+ if (*lpszPath == '\\')
+ {
+ if (!lpszPath[1])
+ return TRUE; /* \ */
+ else if (lpszPath[1]=='\\')
+ {
+ BOOL bSeenSlash = FALSE;
+ lpszPath += 2;
- /* "\" */
- if (lpszPath[0]=='\\' && lpszPath[1]=='\0')
- return TRUE;
-
- /* UNC "\\<computer>\<share>" */
- if (lpszPath[0]=='\\' && lpszPath[1]=='\\')
- {
- int foundbackslash = 0;
- lpszPath += 2;
- while (*lpszPath)
- {
- if (*lpszPath=='\\') foundbackslash++;
- lpszPath = CharNextW(lpszPath);
- }
- if (foundbackslash <= 1)
- return TRUE;
- }
- return FALSE;
-
+ /* Check for UNC root path */
+ while (*lpszPath)
+ {
+ if (*lpszPath == '\\')
+ {
+ if (bSeenSlash)
+ return FALSE;
+ bSeenSlash = TRUE;
+ }
+ lpszPath = CharNextW(lpszPath);
+ }
+ return TRUE;
+ }
+ }
+ else if (lpszPath[1] == ':' && lpszPath[2] == '\\' && lpszPath[3] == '\0')
+ return TRUE; /* X:\ */
+ }
+ return FALSE;
}
/*************************************************************************
* PathIsDirectoryA [SHLWAPI.@]
+ *
+ * Determine if a path is a valid directory
+ *
+ * PARAMS
+ * lpszPath [I] Path to check.
+ *
+ * RETURNS
+ * FILE_ATTRIBUTE_DIRECTORY if lpszPath exists and can be read (See Notes)
+ * FALSE if lpszPath is invalid or not a directory.
+ *
+ * NOTES
+ * Although this function is prototyped as returning a BOOL, it returns
+ * FILE_ATTRIBUTE_DIRECTORY for success. This means that code such as:
+ *
+ * if (PathIsDirectoryA("c:\\windows\\") == TRUE)
+ * ...
+ *
+ * will always fail.
*/
BOOL WINAPI PathIsDirectoryA(LPCSTR lpszPath)
{
- DWORD dwAttr;
+ DWORD dwAttr;
- TRACE("%s\n", debugstr_a(lpszPath));
+ TRACE("(%s)\n", debugstr_a(lpszPath));
- dwAttr = GetFileAttributesA(lpszPath);
- return (dwAttr != -1) ? dwAttr & FILE_ATTRIBUTE_DIRECTORY : 0;
+ if (!lpszPath || PathIsUNCServerA(lpszPath))
+ return FALSE;
+
+ if (PathIsUNCServerShareA(lpszPath))
+ {
+ FIXME("UNC Server Share not yet supported - FAILING\n");
+ return FALSE;
+ }
+
+ if ((dwAttr = GetFileAttributesA(lpszPath)) == -1)
+ return FALSE;
+ return dwAttr & FILE_ATTRIBUTE_DIRECTORY;
}
/*************************************************************************
* PathIsDirectoryW [SHLWAPI.@]
+ *
+ * See PathIsDirectoryA.
*/
BOOL WINAPI PathIsDirectoryW(LPCWSTR lpszPath)
{
- DWORD dwAttr;
-
- TRACE("%s\n", debugstr_w(lpszPath));
+ DWORD dwAttr;
- dwAttr = GetFileAttributesW(lpszPath);
- return (dwAttr != -1) ? dwAttr & FILE_ATTRIBUTE_DIRECTORY : 0;
+ 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)) == -1)
+ return FALSE;
+ return dwAttr & FILE_ATTRIBUTE_DIRECTORY;
}
/*************************************************************************
* PathFileExistsA [SHLWAPI.@]
- *
- * NOTES
- * file_exists(char *fn);
+ *
+ * Determine if a file exists.
+ *
+ * PARAMS
+ * lpszPath [I] Path to check
+ *
+ * RETURNS
+ * TRUE If the file exists and is readable
+ * FALSE Otherwise
*/
-BOOL WINAPI PathFileExistsA(LPCSTR lpszPath)
+BOOL WINAPI PathFileExistsA(LPCSTR lpszPath)
{
- TRACE("%s\n",lpszPath);
- return (GetFileAttributesA(lpszPath)!=-1);
+ UINT iPrevErrMode;
+ DWORD dwAttr;
+
+ TRACE("(%s)\n",debugstr_a(lpszPath));
+
+ if (!lpszPath)
+ return FALSE;
+
+ iPrevErrMode = SetErrorMode(1);
+ dwAttr = GetFileAttributesA(lpszPath);
+ SetErrorMode(iPrevErrMode);
+ return dwAttr == -1 ? FALSE : TRUE;
}
/*************************************************************************
* PathFileExistsW [SHLWAPI.@]
+ *
+ * See PathFileExistsA
*/
-BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath)
+BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath)
{
- TRACE("%s\n",debugstr_w(lpszPath));
- return (GetFileAttributesW(lpszPath)!=-1);
+ UINT iPrevErrMode;
+ DWORD dwAttr;
+
+ TRACE("(%s)\n",debugstr_w(lpszPath));
+
+ if (!lpszPath)
+ return FALSE;
+
+ iPrevErrMode = SetErrorMode(1);
+ dwAttr = GetFileAttributesW(lpszPath);
+ SetErrorMode(iPrevErrMode);
+ return dwAttr == -1 ? FALSE : TRUE;
}
/*************************************************************************
* PathMatchSingleMaskA [internal]
- *
+ *
* NOTES
* internal (used by PathMatchSpec)
*/
static BOOL PathMatchSingleMaskA(LPCSTR name, LPCSTR mask)
{
- while (*name && *mask && *mask!=';')
+ while (*name && *mask && *mask!=';')
{
- if (*mask=='*')
+ if (*mask=='*')
{
- do
+ do
{
if (PathMatchSingleMaskA(name,mask+1)) return 1; /* try substrings */
} while (*name++);
@@ -1016,7 +1599,7 @@
name = CharNextA(name);
mask = CharNextA(mask);
}
- if (!*name)
+ if (!*name)
{
while (*mask=='*') mask++;
if (!*mask || *mask==';') return 1;
@@ -1033,7 +1616,7 @@
{
if (*mask=='*')
{
- do
+ do
{
if (PathMatchSingleMaskW(name,mask+1)) return 1; /* try substrings */
} while (*name++);
@@ -1050,23 +1633,36 @@
}
return 0;
}
+
/*************************************************************************
* PathMatchSpecA [SHLWAPI.@]
- *
+ *
+ * Determine if a path matches one or more search masks.
+ *
+ * PARAMS
+ * lpszPath [I] Path to check
+ * lpszMask [I} Search mask(s)
+ *
+ * RETURNS
+ * TRUE If lpszPath is valid and is matched
+ * FALSE Otherwise
+ *
* NOTES
- * used from COMDLG32
+ * Multiple search masks may be given if they are seperated by ";". The
+ * pattern "*.*" is treated specially in that it matches all paths (for
+ * backwards compatability with DOS).
*/
-BOOL WINAPI PathMatchSpecA(LPCSTR name, LPCSTR mask)
+BOOL WINAPI PathMatchSpecA(LPCSTR name, LPCSTR mask)
{
TRACE("%s %s\n",name,mask);
if (!lstrcmpA( mask, "*.*" )) return 1; /* we don't require a period */
- while (*mask)
+ while (*mask)
{
if (PathMatchSingleMaskA(name,mask)) return 1; /* helper function */
while (*mask && *mask!=';') mask = CharNextA(mask);
- if (*mask==';')
+ if (*mask==';')
{
mask++;
while (*mask==' ') mask++; /* masks may be separated by "; " */
@@ -1077,19 +1673,21 @@
/*************************************************************************
* PathMatchSpecW [SHLWAPI.@]
+ *
+ * See PathMatchSpecA.
*/
-BOOL WINAPI PathMatchSpecW(LPCWSTR name, LPCWSTR mask)
+BOOL WINAPI PathMatchSpecW(LPCWSTR name, LPCWSTR mask)
{
static const WCHAR stemp[] = { '*','.','*',0 };
TRACE("%s %s\n",debugstr_w(name),debugstr_w(mask));
if (!lstrcmpW( mask, stemp )) return 1; /* we don't require a period */
- while (*mask)
+ while (*mask)
{
if (PathMatchSingleMaskW(name,mask)) return 1; /* helper function */
while (*mask && *mask!=';') mask = CharNextW(mask);
- if (*mask==';')
+ if (*mask==';')
{
mask++;
while (*mask==' ') mask++; /* masks may be separated by "; " */
@@ -1101,72 +1699,64 @@
/*************************************************************************
* PathIsSameRootA [SHLWAPI.@]
*
- * FIXME
- * what to do with "\path" ??
+ * Determine if two paths share the same root.
+ *
+ * PARAMS
+ * lpszPath1 [I] Source path
+ * lpszPath2 [I] Path to compare with
+ *
+ * RETURNS
+ * TRUE If both paths are valid and share the same root.
+ * FALSE If either path is invalid or the paths do not share the same root.
*/
BOOL WINAPI PathIsSameRootA(LPCSTR lpszPath1, LPCSTR lpszPath2)
{
- TRACE("%s %s\n", lpszPath1, lpszPath2);
-
- if (PathIsRelativeA(lpszPath1) || PathIsRelativeA(lpszPath2)) return FALSE;
+ LPCSTR lpszStart;
+ DWORD dwLen;
- /* usual path */
- if ( toupper(lpszPath1[0])==toupper(lpszPath2[0]) &&
- lpszPath1[1]==':' && lpszPath2[1]==':' &&
- lpszPath1[2]=='\\' && lpszPath2[2]=='\\')
- return TRUE;
+ TRACE("(%s,%s)\n", debugstr_a(lpszPath1), debugstr_a(lpszPath2));
- /* UNC */
- if (lpszPath1[0]=='\\' && lpszPath2[0]=='\\' &&
- lpszPath1[1]=='\\' && lpszPath2[1]=='\\')
- {
- int pos=2, bsfound=0;
- while (lpszPath1[pos] && lpszPath2[pos] &&
- (lpszPath1[pos] == lpszPath2[pos]))
- {
- if (lpszPath1[pos]=='\\') bsfound++;
- if (bsfound == 2) return TRUE;
- pos++; /* FIXME: use CharNext*/
- }
- return (lpszPath1[pos] == lpszPath2[pos]);
- }
- return FALSE;
+ 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;
}
/*************************************************************************
* PathIsSameRootW [SHLWAPI.@]
+ *
+ * See PathIsSameRootA.
*/
BOOL WINAPI PathIsSameRootW(LPCWSTR lpszPath1, LPCWSTR lpszPath2)
{
- TRACE("%s %s\n", debugstr_w(lpszPath1), debugstr_w(lpszPath2));
-
- if (PathIsRelativeW(lpszPath1) || PathIsRelativeW(lpszPath2)) return FALSE;
+ LPCWSTR lpszStart;
+ DWORD dwLen;
- /* usual path */
- if ( toupperW(lpszPath1[0])==toupperW(lpszPath2[0]) &&
- lpszPath1[1]==':' && lpszPath2[1]==':' &&
- lpszPath1[2]=='\\' && lpszPath2[2]=='\\')
- return TRUE;
+ TRACE("(%s,%s)\n", debugstr_w(lpszPath1), debugstr_w(lpszPath2));
- /* UNC */
- if (lpszPath1[0]=='\\' && lpszPath2[0]=='\\' &&
- lpszPath1[1]=='\\' && lpszPath2[1]=='\\')
- {
- int pos=2, bsfound=0;
- while (lpszPath1[pos] && lpszPath2[pos] &&
- (lpszPath1[pos] == lpszPath2[pos]))
- {
- if (lpszPath1[pos]=='\\') bsfound++;
- if (bsfound == 2) return TRUE;
- pos++;/* FIXME: use CharNext*/
- }
- return (lpszPath1[pos] == lpszPath2[pos]);
- }
- return FALSE;
+ 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;
}
/*************************************************************************
- * PathIsURLA (SHLWAPI.@)
+ * PathIsURLA [SHLWAPI.@]
+ *
+ * Check if the given path is a URL.
+ *
+ * PARAMS
+ * lpszPath [I] Path to check.
+ *
+ * RETURNS
+ * TRUE if lpszPath is a URL.
+ * FALSE if lpszPath is NULL or not a URL.
*/
BOOL WINAPI PathIsURLA(LPCSTR lpstrPath)
{
@@ -1179,10 +1769,10 @@
base.size = 24;
res1 = SHLWAPI_1(lpstrPath, &base);
return (base.fcncde) ? TRUE : FALSE;
-}
+}
/*************************************************************************
- * PathIsURLW (SHLWAPI.@)
+ * PathIsURLW [SHLWAPI.@]
*/
BOOL WINAPI PathIsURLW(LPCWSTR lpstrPath)
{
@@ -1195,700 +1785,1875 @@
base.size = 24;
res1 = SHLWAPI_2(lpstrPath, &base);
return (base.fcncde) ? TRUE : FALSE;
-}
-
-
-/*************************************************************************
- * PathIsContentTypeA [SHLWAPI.@]
- */
-BOOL WINAPI PathIsContentTypeA(LPCSTR pszPath, LPCSTR pszContentType)
-{
- FIXME("%s %s\n", pszPath, pszContentType);
- return FALSE;
}
/*************************************************************************
- * PathIsContentTypeW [SHLWAPI.@]
+ * PathIsContentTypeA [SHLWAPI.@]
+ *
+ * Determine if a file is of a registered content type.
+ *
+ * PARAMS
+ * lpszPath [I] file to chack
+ *
+ * RETURNS
+ * TRUE If lpszPath is a registered content type
+ * FALSE Otherwise.
*/
-BOOL WINAPI PathIsContentTypeW(LPCWSTR pszPath, LPCWSTR pszContentType)
+BOOL WINAPI PathIsContentTypeA(LPCSTR lpszPath, LPCSTR lpszContentType)
{
- FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszContentType));
- return FALSE;
+ 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;
}
/*************************************************************************
- * PathIsFileSpecA [SHLWAPI.@]
+ * PathIsContentTypeW [SHLWAPI.@]
+ *
+ * See PathIsContentTypeA.
*/
-BOOL WINAPI PathIsFileSpecA(LPCSTR pszPath)
+BOOL WINAPI PathIsContentTypeW(LPCWSTR lpszPath, LPCWSTR lpszContentType)
{
- FIXME("%s\n", pszPath);
- return FALSE;
+ 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;
}
/*************************************************************************
- * PathIsFileSpecW [SHLWAPI.@]
+ * PathIsFileSpecA [SHLWAPI.@]
+ *
+ * Determine if a path is a file specification.
+ *
+ * PARAMS
+ * lpszPath [I] Path to chack
+ *
+ * RETURNS
+ * TRUE If lpszPath is a file spec (contains no directories).
+ * FALSE Otherwise.
*/
-BOOL WINAPI PathIsFileSpecW(LPCWSTR pszPath)
+BOOL WINAPI PathIsFileSpecA(LPCSTR lpszPath)
{
- FIXME("%s\n", debugstr_w(pszPath));
- return FALSE;
+ TRACE("(%s)\n", debugstr_a(lpszPath));
+
+ if (!lpszPath)
+ return FALSE;
+
+ while (*lpszPath)
+ {
+ if (*lpszPath == '\\' || *lpszPath == ':')
+ return FALSE;
+ lpszPath = CharNextA(lpszPath);
+ }
+ return TRUE;
}
/*************************************************************************
- * PathIsPrefixA [SHLWAPI.@]
+ * PathIsFileSpecW [SHLWAPI.@]
+ *
+ * See PathIsFileSpecA.
*/
-BOOL WINAPI PathIsPrefixA(LPCSTR pszPrefix, LPCSTR pszPath)
+BOOL WINAPI PathIsFileSpecW(LPCWSTR lpszPath)
{
- FIXME("%s %s\n", pszPrefix, pszPath);
- return FALSE;
+ TRACE("(%s)\n", debugstr_w(lpszPath));
+
+ if (!lpszPath)
+ return FALSE;
+
+ while (*lpszPath)
+ {
+ if (*lpszPath == '\\' || *lpszPath == ':')
+ return FALSE;
+ lpszPath = CharNextW(lpszPath);
+ }
+ return TRUE;
}
/*************************************************************************
- * PathIsPrefixW [SHLWAPI.@]
+ * PathIsPrefixA [SHLWAPI.@]
+ *
+ * Determine if a path is a prefix of another.
+ *
+ * PARAMS
+ * lpszPrefix [I] Prefix
+ * lpszPath [i] Path to check
+ *
+ * RETURNS
+ * TRUE If lpszPath has lpszPrefix as its prefix
+ * FALSE If either path is NULL or lpszPrefix is not a prefix
*/
-BOOL WINAPI PathIsPrefixW(LPCWSTR pszPrefix, LPCWSTR pszPath)
+BOOL WINAPI PathIsPrefixA (LPCSTR lpszPrefix, LPCSTR lpszPath)
{
- FIXME("%s %s\n", debugstr_w(pszPrefix), debugstr_w(pszPath));
- return FALSE;
+ TRACE("(%s,%s)\n", debugstr_a(lpszPrefix), debugstr_a(lpszPath));
+
+ if (lpszPrefix && lpszPath &&
+ PathCommonPrefixA(lpszPath, lpszPrefix, NULL) == strlen(lpszPrefix))
+ return TRUE;
+ return FALSE;
}
/*************************************************************************
- * PathIsSystemFolderA [SHLWAPI.@]
+ * PathIsPrefixW [SHLWAPI.@]
+ *
+ * See PathIsPrefixA.
*/
-BOOL WINAPI PathIsSystemFolderA(LPCSTR pszPath, DWORD dwAttrb)
+BOOL WINAPI PathIsPrefixW(LPCWSTR lpszPrefix, LPCWSTR lpszPath)
{
- FIXME("%s 0x%08lx\n", pszPath, dwAttrb);
- return FALSE;
+ TRACE("(%s,%s)\n", debugstr_w(lpszPrefix), debugstr_w(lpszPath));
+
+ if (lpszPrefix && lpszPath &&
+ PathCommonPrefixW(lpszPath, lpszPrefix, NULL) == strlenW(lpszPrefix))
+ return TRUE;
+ return FALSE;
}
/*************************************************************************
- * PathIsSystemFolderW [SHLWAPI.@]
+ * PathIsSystemFolderA [SHLWAPI.@]
+ *
+ * Determine if a path or file attributes are a system folder.
+ *
+ * PARAMS
+ * lpszPath [I] Path to check.
+ * dwAttrib [I] Attributes to check, if lpszPath is NULL.
+ *
+ * RETURNS
+ * TRUE If lpszPath or dwAttrib are a system folder.
+ * FALSE If GetFileAttributesA fails or neither parameter is a system folder.
*/
-BOOL WINAPI PathIsSystemFolderW(LPCWSTR pszPath, DWORD dwAttrb)
+BOOL WINAPI PathIsSystemFolderA(LPCSTR lpszPath, DWORD dwAttrib)
{
- FIXME("%s 0x%08lx\n", debugstr_w(pszPath), dwAttrb);
- return FALSE;
+ TRACE("(%s,0x%08lx)\n", debugstr_a(lpszPath), dwAttrib);
+
+ if (lpszPath && *lpszPath)
+ dwAttrib = GetFileAttributesA(lpszPath);
+
+ if (dwAttrib == -1 || !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY) ||
+ !(dwAttrib & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
+ return FALSE;
+ return TRUE;
}
/*************************************************************************
- * PathIsUNCServerA [SHLWAPI.@]
+ * PathIsSystemFolderW [SHLWAPI.@]
+ *
+ * See PathIsSystemFolderA.
*/
-BOOL WINAPI PathIsUNCServerA(
- LPCSTR lpszPath)
+BOOL WINAPI PathIsSystemFolderW(LPCWSTR lpszPath, DWORD dwAttrib)
{
- TRACE("%s\n", debugstr_a(lpszPath));
- if (lpszPath[0]=='\\' && lpszPath[1]=='\\')
- {
- int foundbackslash = 0;
- lpszPath += 2;
- while (*lpszPath)
- {
- if (*lpszPath=='\\') foundbackslash++;
- lpszPath = CharNextA(lpszPath);
- }
- if (foundbackslash == 0)
- return TRUE;
- }
- return FALSE;
+ TRACE("(%s,0x%08lx)\n", debugstr_w(lpszPath), dwAttrib);
+
+ if (lpszPath && *lpszPath)
+ dwAttrib = GetFileAttributesW(lpszPath);
+
+ if (dwAttrib == -1 || !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY) ||
+ !(dwAttrib & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
+ return FALSE;
+ return TRUE;
}
/*************************************************************************
- * PathIsUNCServerW [SHLWAPI.@]
+ * PathIsUNCA [SHLWAPI.@]
+ *
+ * Determine if a path is in UNC format.
+ *
+ * PARAMS
+ * lpszPath [I] Path to check
+ *
+ * RETURNS
+ * TRUE: The path is UNC.
+ * FALSE: The path is not UNC or is NULL.
*/
-BOOL WINAPI PathIsUNCServerW(
- LPCWSTR lpszPath)
+BOOL WINAPI PathIsUNCA(LPCSTR lpszPath)
{
- TRACE("%s\n", debugstr_w(lpszPath));
- if (lpszPath[0]=='\\' && lpszPath[1]=='\\')
- {
- int foundbackslash = 0;
- lpszPath += 2;
- while (*lpszPath)
- {
- if (*lpszPath=='\\') foundbackslash++;
- lpszPath = CharNextW(lpszPath);
- }
- if (foundbackslash == 0)
- return TRUE;
- }
- return FALSE;
+ TRACE("(%s)\n",debugstr_a(lpszPath));
+
+ if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'))
+ return TRUE;
+ return FALSE;
}
/*************************************************************************
- * PathIsUNCServerShareA [SHLWAPI.@]
+ * PathIsUNCW [SHLWAPI.@]
+ *
+ * See PathIsUNCA.
*/
-BOOL WINAPI PathIsUNCServerShareA(
- LPCSTR lpszPath)
+BOOL WINAPI PathIsUNCW(LPCWSTR lpszPath)
{
- TRACE("%s\n", debugstr_a(lpszPath));
- if (!lpszPath) return FALSE;
- if (lpszPath[0]=='\\' && lpszPath[1]=='\\')
- {
- int foundbackslash = 0;
- lpszPath += 2;
- while (*lpszPath)
- {
- if (*lpszPath=='\\') foundbackslash++;
- lpszPath = CharNextA(lpszPath);
- }
- if (foundbackslash == 1)
- return TRUE;
- }
- return FALSE;
+ TRACE("(%s)\n",debugstr_w(lpszPath));
+
+ if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'))
+ return TRUE;
+ return FALSE;
}
/*************************************************************************
- * PathIsUNCServerShareW [SHLWAPI.@]
+ * PathIsUNCServerA [SHLWAPI.@]
+ *
+ * Determine if a path is a UNC server name ("\\SHARENAME").
+ *
+ * PARAMS
+ * lpszPath [I] Path to check.
+ *
+ * RETURNS
+ * TRUE If lpszPath is a valid UNC server name.
+ * FALSE Otherwise.
+ *
+ * NOTES
+ * This routine is bug compatible with Win32: Server names with a
+ * trailing backslash (e.g. "\\FOO\"), return FALSE incorrectly.
+ * Fixing this bug may break other shlwapi functions!
*/
-BOOL WINAPI PathIsUNCServerShareW(
- LPCWSTR lpszPath)
+BOOL WINAPI PathIsUNCServerA(LPCSTR lpszPath)
{
- TRACE("%s\n", debugstr_w(lpszPath));
- if (!lpszPath) return FALSE;
- if (lpszPath[0]=='\\' && lpszPath[1]=='\\')
- {
- int foundbackslash = 0;
- lpszPath += 2;
- while (*lpszPath)
- {
- if (*lpszPath=='\\') foundbackslash++;
- lpszPath = CharNextW(lpszPath);
- }
- if (foundbackslash == 1)
- return TRUE;
- }
- return FALSE;
+ TRACE("(%s)\n", debugstr_a(lpszPath));
+
+ if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
+ {
+ while (*lpszPath)
+ {
+ if (*lpszPath == '\\')
+ return FALSE;
+ lpszPath = CharNextA(lpszPath);
+ }
+ return TRUE;
+ }
+ return FALSE;
+}
+
+/*************************************************************************
+ * PathIsUNCServerW [SHLWAPI.@]
+ *
+ * See PathIsUNCServerA.
+ */
+BOOL WINAPI PathIsUNCServerW(LPCWSTR lpszPath)
+{
+ TRACE("(%s)\n", debugstr_w(lpszPath));
+
+ if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
+ {
+ while (*lpszPath)
+ {
+ if (*lpszPath == '\\')
+ return FALSE;
+ lpszPath = CharNextW(lpszPath);
+ }
+ return TRUE;
+ }
+ return FALSE;
+}
+
+/*************************************************************************
+ * PathIsUNCServerShareA [SHLWAPI.@]
+ *
+ * Determine if a path is a UNC server share ("\\SHARENAME\SHARE").
+ *
+ * PARAMS
+ * lpszPath [I] Path to check.
+ *
+ * RETURNS
+ * TRUE If lpszPath is a valid UNC server share.
+ * FALSE Otherwise.
+ *
+ * NOTES
+ * This routine is bug compatible with Win32: Server shares with a
+ * trailing backslash (e.g. "\\FOO\BAR\"), return FALSE incorrectly.
+ * Fixing this bug may break other shlwapi functions!
+ */
+BOOL WINAPI PathIsUNCServerShareA(LPCSTR lpszPath)
+{
+ 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;
+}
+
+/*************************************************************************
+ * PathIsUNCServerShareW [SHLWAPI.@]
+ *
+ * See PathIsUNCServerShareA.
+ */
+BOOL WINAPI PathIsUNCServerShareW(LPCWSTR lpszPath)
+{
+ TRACE("(%s)\n", debugstr_w(lpszPath));
+
+ if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
+ {
+ BOOL bSeenSlash = FALSE;
+ while (*lpszPath)
+ {
+ if (*lpszPath == '\\')
+ {
+ if (bSeenSlash)
+ return FALSE;
+ bSeenSlash = TRUE;
+ }
+ lpszPath = CharNextW(lpszPath);
+ }
+ return bSeenSlash;
+ }
+ return FALSE;
}
/*************************************************************************
* PathCanonicalizeA [SHLWAPI.@]
*
- * FIXME
- * returnvalue, use CharNext
+ * Convert a path to its canonical form.
+ *
+ * PARAMS
+ * lpszBuf [O] Output path
+ * lpszPath [I] Path to cnonicalize
+ *
+ * RETURNS
+ * Success: TRUE. lpszBuf contains the output path
+ * Failure: FALSE, If input path is invalid. lpszBuf is undefined
*/
-
-BOOL WINAPI PathCanonicalizeA(LPSTR pszBuf, LPCSTR pszPath)
+BOOL WINAPI PathCanonicalizeA(LPSTR lpszBuf, LPCSTR lpszPath)
{
- int OffsetMin = 0, OffsetSrc = 0, OffsetDst = 0, LenSrc = strlen(pszPath);
- BOOL bModifyed = FALSE;
+ BOOL bRet = FALSE;
- TRACE("%p %s\n", pszBuf, pszPath);
-
- pszBuf[OffsetDst]='\0';
+ TRACE("(%p,%s)\n", lpszBuf, debugstr_a(lpszPath));
- /* keep the root of the path */
- if( LenSrc && (pszPath[OffsetSrc]=='\\'))
- {
- pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
- }
- else if ( (LenSrc >= 2) && (pszPath[OffsetSrc+1] == ':'))
- {
- pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
- pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
- if (LenSrc && (pszPath[OffsetSrc] == '\\'))
- {
- pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
- if (LenSrc == 1 && pszPath[OffsetSrc]=='.')
- {
- /* C:\. */
- OffsetSrc++; LenSrc--; bModifyed = TRUE;
- }
- else if (LenSrc == 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='.')
- {
- /* C:\.. */
- OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
- }
- }
- }
-
- /* ".\" at the beginning of the path */
- if (LenSrc >= 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='\\')
- {
- OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
- }
-
- while ( LenSrc )
- {
- if((LenSrc>=3) && (pszPath[OffsetSrc]=='\\') && (pszPath[OffsetSrc+1]=='.') && (pszPath[OffsetSrc+2]=='.'))
- {
- /* "\.." found, go one deeper */
- while((OffsetDst > OffsetMin) && (pszBuf[OffsetDst]!='\\')) OffsetDst--;
- OffsetSrc += 3; LenSrc -= 3; bModifyed = TRUE;
- if(OffsetDst == OffsetMin && pszPath[OffsetSrc]=='\\') OffsetSrc++;
- pszBuf[OffsetDst] = '\0'; /* important for \..\.. */
- }
- else if(LenSrc>=2 && pszPath[OffsetSrc]=='\\' && pszPath[OffsetSrc+1]=='.' )
- {
- /* "\." found, skip it */
- OffsetSrc += 2; LenSrc-=2; bModifyed = TRUE;
- }
- else
- {
- pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; LenSrc--;
- }
- }
- pszBuf[OffsetDst] = '\0';
- TRACE("-- %s %u\n", pszBuf, bModifyed);
- return bModifyed;
+ if (lpszBuf)
+ *lpszBuf = '\0';
+
+ if (!lpszBuf || !lpszPath)
+ SetLastError(ERROR_INVALID_PARAMETER);
+ else
+ {
+ WCHAR szPath[MAX_PATH];
+ WCHAR szBuff[MAX_PATH];
+ MultiByteToWideChar(0,0,lpszPath,-1,szPath,MAX_PATH);
+ bRet = PathCanonicalizeW(szBuff, szPath);
+ WideCharToMultiByte(0,0,szBuff,-1,lpszBuf,MAX_PATH,0,0);
+ }
+ return bRet;
}
/*************************************************************************
* PathCanonicalizeW [SHLWAPI.@]
*
- * FIXME
- * returnvalue, use CharNext
+ * See PathCanonicalizeA.
*/
-BOOL WINAPI PathCanonicalizeW(LPWSTR pszBuf, LPCWSTR pszPath)
+BOOL WINAPI PathCanonicalizeW(LPWSTR lpszBuf, LPCWSTR lpszPath)
{
- int OffsetMin = 0, OffsetSrc = 0, OffsetDst = 0, LenSrc = strlenW(pszPath);
- BOOL bModifyed = FALSE;
+ LPWSTR lpszDst = lpszBuf;
+ LPCWSTR lpszSrc = lpszPath;
- TRACE("%p %s\n", pszBuf, debugstr_w(pszPath));
-
- pszBuf[OffsetDst]='\0';
+ TRACE("(%p,%s)\n", lpszBuf, debugstr_w(lpszPath));
- /* keep the root of the path */
- if( LenSrc && (pszPath[OffsetSrc]=='\\'))
- {
- pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
- }
- else if ( (LenSrc >= 2) && (pszPath[OffsetSrc+1] == ':'))
- {
- pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
- pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
- if (LenSrc && (pszPath[OffsetSrc] == '\\'))
- {
- pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
- if (LenSrc == 1 && pszPath[OffsetSrc]=='.')
- {
- /* C:\. */
- OffsetSrc++; LenSrc--; bModifyed = TRUE;
- }
- else if (LenSrc == 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='.')
- {
- /* C:\.. */
- OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
- }
+ 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 inital \\
+ */
+ 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;
}
- }
-
- /* ".\" at the beginning of the path */
- if (LenSrc >= 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='\\')
- {
- OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
- }
-
- while ( LenSrc )
- {
- if((LenSrc>=3) && (pszPath[OffsetSrc]=='\\') && (pszPath[OffsetSrc+1]=='.') && (pszPath[OffsetSrc+2]=='.'))
- {
- /* "\.." found, go one deeper */
- while((OffsetDst > OffsetMin) && (pszBuf[OffsetDst]!='\\')) OffsetDst--;
- OffsetSrc += 3; LenSrc -= 3; bModifyed = TRUE;
- if(OffsetDst == OffsetMin && pszPath[OffsetSrc]=='\\') OffsetSrc++;
- pszBuf[OffsetDst] = '\0'; /* important for \..\.. */
- }
- else if(LenSrc>=2 && pszPath[OffsetSrc]=='\\' && pszPath[OffsetSrc+1]=='.' )
- {
- /* "\." found, skip it */
- OffsetSrc += 2; LenSrc-=2; bModifyed = TRUE;
- }
- else
- {
- pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; LenSrc--;
- }
- }
- pszBuf[OffsetDst] = '\0';
- TRACE("-- %s %u\n", debugstr_w(pszBuf), bModifyed);
- return bModifyed;
+ 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;
}
/*************************************************************************
* PathFindNextComponentA [SHLWAPI.@]
*
+ * Find the next component in a path.
+ *
+ * PARAMS
+ * lpszPath [I] Path to find next component in
+ *
+ * RETURNS
+ * Success: A pointer to the next component, or the end of the string
+ * Failure: NULL, If lpszPath is invalid
+ *
* NOTES
- * special cases:
- * "" null
- * aa "" (pointer to traling NULL)
- * aa\ "" (pointer to traling NULL)
- * aa\\ "" (pointer to traling NULL)
- * aa\\bb bb
- * aa\\\bb \bb
- * c:\aa\ "aa\"
- * \\aa aa
- * \\aa\b aa\b
-*/
-LPSTR WINAPI PathFindNextComponentA(LPCSTR pszPath)
+ * A 'component' is either a backslash character (\) or UNC marker (\\).
+ * Because of this, relative paths (e.g "c:foo") are regarded as having
+ * only one component.
+ */
+LPSTR WINAPI PathFindNextComponentA(LPCSTR lpszPath)
{
- LPSTR pos;
+ LPSTR lpszSlash;
- TRACE("%s\n", pszPath);
+ TRACE("(%s)\n", debugstr_a(lpszPath));
- if(!pszPath || !*pszPath) return NULL;
- if(!(pos = StrChrA(pszPath, '\\')))
- return (LPSTR) pszPath + strlen(pszPath);
- pos++;
- if(pos[0] == '\\') pos++;
- return pos;
+ if(!lpszPath || !*lpszPath)
+ return NULL;
+
+ if ((lpszSlash = StrChrA(lpszPath, '\\')))
+ {
+ if (lpszSlash[1] == '\\')
+ lpszSlash++;
+ return lpszSlash + 1;
+ }
+ return (LPSTR)lpszPath + strlen(lpszPath);
}
/*************************************************************************
* PathFindNextComponentW [SHLWAPI.@]
+ *
+ * See PathFindNextComponentA.
*/
-LPWSTR WINAPI PathFindNextComponentW(LPCWSTR pszPath)
+LPWSTR WINAPI PathFindNextComponentW(LPCWSTR lpszPath)
{
- LPWSTR pos;
+ LPWSTR lpszSlash;
- TRACE("%s\n", debugstr_w(pszPath));
-
- if(!pszPath || !*pszPath) return NULL;
- if (!(pos = StrChrW(pszPath, '\\')))
- return (LPWSTR) pszPath + strlenW(pszPath);
- pos++;
- if(pos[0] == '\\') pos++;
- return pos;
+ 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);
}
/*************************************************************************
* PathAddExtensionA [SHLWAPI.@]
*
+ * Add a file extension to a path
+ *
+ * PARAMS
+ * lpszPath [O] Path to add extension to
+ * lpszExtension [I} Extension to add to lpszPath
+ *
+ * RETURNS
+ * TRUE If the path was modified
+ * FALSE If lpszPath or lpszExtension are invalid, lpszPath has an
+ * extension allready, or the new path length is too big.
+ *
+ * FIXME
+ * What version of shlwapi.dll adds "exe" if pszExtension is NULL? Win2k
+ * does not do this, so the behaviour was removed.
+ */
+BOOL WINAPI PathAddExtensionA(LPSTR lpszPath, LPCSTR lpszExtension)
+{
+ DWORD 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 [SHLWAPI.@]
+ *
+ * See PathAddExtensionA.
+ */
+BOOL WINAPI PathAddExtensionW(LPWSTR lpszPath, LPCWSTR lpszExtension)
+{
+ DWORD 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;
+}
+
+/*************************************************************************
+ * PathMakePrettyA [SHLWAPI.@]
+ *
+ * Convert an uppercase DOS filename into lowercase.
+ *
+ * PARAMS
+ * lpszPath [O] Path to convert.
+ *
+ * RETURNS
+ * TRUE If the path was an uppercase DOS path and was converted
+ * FALSE Otherwise.
+ */
+BOOL WINAPI PathMakePrettyA(LPSTR lpszPath)
+{
+ LPSTR pszIter = lpszPath;
+
+ TRACE("(%s)\n", debugstr_a(lpszPath));
+
+ if (!pszIter || !*pszIter)
+ return FALSE;
+
+ while (*pszIter)
+ {
+ if (islower(*pszIter) || IsDBCSLeadByte(*pszIter))
+ return FALSE; /* Not DOS path */
+ pszIter++;
+ }
+ pszIter = lpszPath + 1;
+ while (*pszIter)
+ {
+ *pszIter = tolower(*pszIter);
+ pszIter++;
+ }
+ return TRUE;
+}
+
+/*************************************************************************
+ * PathMakePrettyW [SHLWAPI.@]
+ *
+ * See PathMakePrettyA
+ */
+BOOL WINAPI PathMakePrettyW(LPWSTR lpszPath)
+{
+ LPWSTR pszIter = lpszPath;
+
+ TRACE("(%s)\n", debugstr_w(lpszPath));
+
+ if (!pszIter || !*pszIter)
+ return FALSE;
+
+ while (*pszIter)
+ {
+ if (islowerW(*pszIter))
+ return FALSE; /* Not DOS path */
+ pszIter++;
+ }
+ pszIter = lpszPath + 1;
+ while (*pszIter)
+ {
+ *pszIter = tolowerW(*pszIter);
+ pszIter++;
+ }
+ return TRUE;
+}
+
+/*************************************************************************
+ * PathCommonPrefixA [SHLWAPI.@]
+ *
+ * Determine the length of the common prefix between two paths.
+ *
+ * PARAMS
+ * lpszFile1 [I] First path for comparason
+ * lpszFile2 [I] Second path for comparason
+ * achPath [O] Destination for common prefix string
+ *
+ * RETURNS
+ * The length of the common prefix. This is 0 if there is no common
+ * prefix between the paths or if any parameters are invalid. If the prefix
+ * is non-zero and achPath is not NULL, achPath is filled with the common
+ * part of the prefix and NUL terminated.
+ *
* NOTES
- * it adds never a dot
+ * A common prefix of 2 is always returned as 3. It is thus possible for
+ * the length returned to be invalid (i.e. Longer than one or both of the
+ * strings given as parameters). This Win32 behaviour has been implimented
+ * here, and cannot be changed (fixed?) without breaking other SHLWAPI calls.
+ * To work around this when using this function, always check that the byte
+ * at [common_prefix_len-1] is not a NUL. If it is, deduct 1 from the prefix.
*/
-
-BOOL WINAPI PathAddExtensionA(
- LPSTR pszPath,
- LPCSTR pszExtension)
+int WINAPI PathCommonPrefixA(LPCSTR lpszFile1, LPCSTR lpszFile2, LPSTR achPath)
{
- if (*pszPath)
- {
- if (*(PathFindExtensionA(pszPath))) return FALSE;
+ int iLen = 0;
+ LPCSTR lpszIter1 = lpszFile1;
+ LPCSTR lpszIter2 = lpszFile2;
- if (!pszExtension || *pszExtension=='\0')
- strcat(pszPath, "exe");
- else
- strcat(pszPath, pszExtension);
- }
+ TRACE("(%s,%s,%p)\n", debugstr_a(lpszFile1), debugstr_a(lpszFile2), achPath);
- return TRUE;
+ 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 compatable with Win32 */
+
+ if (iLen && achPath)
+ {
+ memcpy(achPath,lpszFile1,iLen);
+ achPath[iLen] = '\0';
+ }
+ return iLen;
}
/*************************************************************************
- * PathAddExtensionW [SHLWAPI.@]
+ * PathCommonPrefixW [SHLWAPI.@]
+ *
+ * See PathCommonPrefixA.
*/
-BOOL WINAPI PathAddExtensionW(
- LPWSTR pszPath,
- LPCWSTR pszExtension)
+int WINAPI PathCommonPrefixW(LPCWSTR lpszFile1, LPCWSTR lpszFile2, LPWSTR achPath)
{
- static const WCHAR ext[] = { 'e','x','e',0 };
+ int iLen = 0;
+ LPCWSTR lpszIter1 = lpszFile1;
+ LPCWSTR lpszIter2 = lpszFile2;
- if (*pszPath)
- {
- if (*(PathFindExtensionW(pszPath))) return FALSE;
+ TRACE("(%s,%s,%p)\n", debugstr_w(lpszFile1), debugstr_w(lpszFile2), achPath);
- if (!pszExtension || *pszExtension=='\0')
- strcatW(pszPath, ext);
- else
- strcatW(pszPath, pszExtension);
- }
- return TRUE;
+ 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 compatable with Win32 */
+
+ if (iLen && achPath)
+ {
+ memcpy(achPath,lpszFile1,iLen * sizeof(WCHAR));
+ achPath[iLen] = '\0';
+ }
+ return iLen;
}
/*************************************************************************
- * PathMakePrettyA [SHLWAPI.@]
+ * PathCompactPathA [SHLWAPI.@]
+ *
+ * Make a path fit into a given width when printed to a DC.
+ *
+ * PARAMS
+ * hDc [I] Destination DC
+ * lpszPath [O] Path to be printed to hDc
+ * dx [i] Desired width
+ *
+ * RETURNS
+ * TRUE If the path was modified.
+ * FALSE Otherwise.
*/
-BOOL WINAPI PathMakePrettyA(
- LPSTR lpPath)
+BOOL WINAPI PathCompactPathA(HDC hDC, LPSTR lpszPath, UINT dx)
{
- FIXME("%s\n", lpPath);
- return TRUE;
+ BOOL bRet = FALSE;
+
+ TRACE("(%08x,%s,%d)\n", hDC, debugstr_a(lpszPath), dx);
+
+ if (lpszPath)
+ {
+ WCHAR szPath[MAX_PATH];
+ MultiByteToWideChar(0,0,lpszPath,-1,szPath,MAX_PATH);
+ bRet = PathCompactPathW(hDC, szPath, dx);
+ WideCharToMultiByte(0,0,szPath,-1,lpszPath,MAX_PATH,0,0);
+ }
+ return bRet;
}
/*************************************************************************
- * PathMakePrettyW [SHLWAPI.@]
+ * PathCompactPathW [SHLWAPI.@]
+ *
+ * See PathCompactPathA.
*/
-BOOL WINAPI PathMakePrettyW(
- LPWSTR lpPath)
+BOOL WINAPI PathCompactPathW(HDC hDC, LPWSTR lpszPath, UINT dx)
{
- FIXME("%s\n", debugstr_w(lpPath));
- return TRUE;
+ static const WCHAR szEllipses[] = { '.', '.', '.', '\0' };
+ BOOL bRet = TRUE;
+ HDC hdc = 0;
+ WCHAR buff[MAX_PATH];
+ SIZE size;
+ DWORD dwLen;
+ TRACE("(%08x,%s,%d)\n", hDC, debugstr_w(lpszPath), dx);
+
+ if (!lpszPath)
+ return bRet;
+
+ if (!hDC)
+ hdc = hDC = GetDC(0);
+
+ /* Get the length of the whole path */
+ dwLen = strlenW(lpszPath);
+ GetTextExtentPointW(hDC, lpszPath, dwLen, &size);
+
+ if (size.cx > dx)
+ {
+ /* Path too big, must reduce it */
+ LPWSTR sFile;
+ DWORD dwEllipsesLen = 0, dwPathLen = 0;
+
+ sFile = PathFindFileNameW(lpszPath);
+ if (sFile != lpszPath)
+ sFile = CharPrevW(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
+ */
+ strncpyW(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 = CharPrevW(lpszPath, sPath);
+ if (!bEllipses)
+ {
+ bEllipses = TRUE;
+ sPath = CharPrevW(lpszPath, sPath);
+ sPath = CharPrevW(lpszPath, sPath);
+ }
+ } while (sPath > lpszPath);
+
+ if (sPath > lpszPath)
+ {
+ if (bEllipses)
+ {
+ strcpyW(sPath, szEllipses);
+ strcpyW(sPath+3, buff);
+ }
+ if (hdc)
+ ReleaseDC(0, hdc);
+ return TRUE;
+ }
+ strcpyW(lpszPath, szEllipses);
+ strcpyW(lpszPath+3, buff);
+ return FALSE;
+ }
+
+ /* 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;
+ strncpyW(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);
+ }
+ }
+
+ if (hdc)
+ ReleaseDC(0, hdc);
+
+ return bRet;
}
/*************************************************************************
- * PathCommonPrefixA [SHLWAPI.@]
- */
-int WINAPI PathCommonPrefixA(
- LPCSTR pszFile1,
- LPCSTR pszFile2,
- LPSTR achPath)
-{
- FIXME("%s %s %p\n", pszFile1, pszFile2, achPath);
- return 0;
-}
-
-/*************************************************************************
- * PathCommonPrefixW [SHLWAPI.@]
- */
-int WINAPI PathCommonPrefixW(
- LPCWSTR pszFile1,
- LPCWSTR pszFile2,
- LPWSTR achPath)
-{
- FIXME("%s %s %p\n", debugstr_w(pszFile1), debugstr_w(pszFile2),achPath );
- return 0;
-}
-
-/*************************************************************************
- * PathCompactPathA [SHLWAPI.@]
- */
-BOOL WINAPI PathCompactPathA(HDC hDC, LPSTR pszPath, UINT dx)
-{
- FIXME("0x%08x %s 0x%08x\n", hDC, pszPath, dx);
- return FALSE;
-}
-
-/*************************************************************************
- * PathCompactPathW [SHLWAPI.@]
- */
-BOOL WINAPI PathCompactPathW(HDC hDC, LPWSTR pszPath, UINT dx)
-{
- FIXME("0x%08x %s 0x%08x\n", hDC, debugstr_w(pszPath), dx);
- return FALSE;
-}
-
-/*************************************************************************
- * PathGetCharTypeA [SHLWAPI.@]
+ * PathGetCharTypeA [SHLWAPI.@]
+ *
+ * Categorise a character from a file path.
+ *
+ * PARAMS
+ * ch [I] Character to get the type of
+ *
+ * RETURNS
+ * A set of GCT_ bit flags (from shlwapi.h) indicating the character type.
*/
UINT WINAPI PathGetCharTypeA(UCHAR ch)
{
- UINT flags = 0;
-
- TRACE("%c\n", ch);
-
- /* We could use them in filenames, but this would confuse 'ls' */
- if (iscntrl(ch))
- return GCT_INVALID;
- if ((ch == '*') || (ch=='?'))
- return GCT_WILD;
- if ((ch == '\\') || (ch=='/'))
- return GCT_SEPARATOR;
- flags = 0;
- /* all normal characters, no lower case letters */
- if ((ch > ' ') && (ch < 0x7f) && !islower(ch))
- flags |= GCT_SHORTCHAR;
- /* All other characters are valid in long filenames, even umlauts */
- return flags | GCT_LFNCHAR;
+ return PathGetCharTypeW(ch);
}
/*************************************************************************
- * PathGetCharTypeW [SHLWAPI.@]
+ * PathGetCharTypeW [SHLWAPI.@]
+ *
+ * See PathGetCharTypeA.
*/
UINT WINAPI PathGetCharTypeW(WCHAR ch)
{
- FIXME("%c, using ascii version\n", ch);
- return PathGetCharTypeA(ch);
+ UINT flags = 0;
+
+ TRACE("(%d)\n", ch);
+
+ if (!ch || ch < ' ' || ch == '<' || ch == '>' ||
+ ch == '"' || ch == '|' || ch == 255)
+ flags = GCT_INVALID; /* Invalid */
+ else if (ch == '*' || ch=='?')
+ flags = GCT_WILD; /* Wildchars */
+ else if ((ch == '\\') || (ch=='/') || (ch == ':'))
+ return GCT_SEPARATOR; /* Path separators */
+ else
+ {
+ if (ch < 126)
+ {
+ if (!ch || isalnum(ch) || ch == '$' || ch == '&' || ch == '(' ||
+ ch == '.' || ch == '@' || ch == '^' ||
+ ch == '\'' || ch == 130 || ch == '`')
+ flags |= GCT_SHORTCHAR; /* All these are valid for DOS */
+ }
+ else
+ if (!(ch & 0x1))
+ flags |= GCT_SHORTCHAR; /* Bug compatable with win32 */
+ flags |= GCT_LFNCHAR; /* Valid for long file names */
+ }
+ return flags;
}
/*************************************************************************
- * PathMakeSystemFolderA [SHLWAPI.@]
+ * SHLWAPI_UseSystemForSystemFolders
+ *
+ * Internal helper for PathMakeSystemFolderW.
*/
-BOOL WINAPI PathMakeSystemFolderA(LPCSTR pszPath)
+static BOOL SHLWAPI_UseSystemForSystemFolders()
{
- FIXME("%s\n", pszPath);
- return FALSE;
+ 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;
}
/*************************************************************************
- * PathMakeSystemFolderW [SHLWAPI.@]
+ * PathMakeSystemFolderA [SHLWAPI.@]
+ *
+ * Set system folder attribute for a path.
+ *
+ * PARAMS
+ * lpszPath [I] The path to turn into a system folder
+ *
+ * RETURNS
+ * TRUE If the path was changed to/already was a system folder
+ * FALSE If the path is invalid or SetFileAttributesA fails
*/
-BOOL WINAPI PathMakeSystemFolderW(LPCWSTR pszPath)
+BOOL WINAPI PathMakeSystemFolderA(LPCSTR lpszPath)
{
- FIXME("%s\n", debugstr_w(pszPath));
- return FALSE;
+ BOOL bRet = FALSE;
+
+ TRACE("(%s)\n", debugstr_a(lpszPath));
+
+ if (lpszPath && *lpszPath)
+ {
+ WCHAR szPath[MAX_PATH];
+ MultiByteToWideChar(0,0,lpszPath,-1,szPath,MAX_PATH);
+ bRet = PathMakeSystemFolderW(szPath);
+ }
+ return bRet;
}
/*************************************************************************
- * PathRenameExtensionA [SHLWAPI.@]
+ * PathMakeSystemFolderW [SHLWAPI.@]
+ *
+ * See PathMakeSystemFolderA.
*/
-BOOL WINAPI PathRenameExtensionA(LPSTR pszPath, LPCSTR pszExt)
+BOOL WINAPI PathMakeSystemFolderW(LPCWSTR lpszPath)
{
- LPSTR pszExtension = PathFindExtensionA(pszPath);
+ DWORD dwDefaultAttr = FILE_ATTRIBUTE_READONLY, dwAttr;
+ WCHAR buff[MAX_PATH];
- if (!pszExtension) return FALSE;
- if (pszExtension-pszPath + strlen(pszExt) > MAX_PATH) return FALSE;
+ TRACE("(%s)\n", debugstr_w(lpszPath));
- strcpy(pszExtension, pszExt);
- TRACE("%s\n", pszPath);
- return TRUE;
+ if (!lpszPath || !*lpszPath)
+ return FALSE;
+
+ /* If the directory is already a system directory, dont 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)) == -1)
+ return FALSE;
+
+ /* Change file attributes to system attributes */
+ dwAttr &= ~(FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_READONLY);
+ return SetFileAttributesW(lpszPath, dwAttr | dwDefaultAttr);
}
/*************************************************************************
- * PathRenameExtensionW [SHLWAPI.@]
+ * PathRenameExtensionA [SHLWAPI.@]
+ *
+ * Swap the file extension in a path with another extension.
+ *
+ * PARAMS
+ * pszPath [O] Path to swap the extension in
+ * pszExt [I] The new extension
+ *
+ * RETURNS
+ * TRUE if pszPath was modified
+ * FALSE if pszPath or pszExt is NULL, or the new path is too long
*/
-BOOL WINAPI PathRenameExtensionW(LPWSTR pszPath, LPCWSTR pszExt)
+BOOL WINAPI PathRenameExtensionA(LPSTR lpszPath, LPCSTR lpszExt)
{
- LPWSTR pszExtension = PathFindExtensionW(pszPath);
+ LPSTR lpszExtension;
- if (!pszExtension) return FALSE;
- if (pszExtension-pszPath + strlenW(pszExt) > MAX_PATH) return FALSE;
+ TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszExt));
- strcpyW(pszExtension, pszExt);
- TRACE("%s\n", debugstr_w(pszPath));
- return TRUE;
+ lpszExtension = PathFindExtensionA(lpszPath);
+
+ if (!lpszExtension || (lpszExtension - lpszPath + strlen(lpszExt) >= MAX_PATH))
+ return FALSE;
+
+ strcpy(lpszExtension, lpszExt);
+ return TRUE;
}
/*************************************************************************
- * PathSearchAndQualifyA [SHLWAPI.@]
+ * PathRenameExtensionW [SHLWAPI.@]
+ *
+ * See PathRenameExtensionA.
*/
-BOOL WINAPI PathSearchAndQualifyA(
- LPCSTR pszPath,
- LPSTR pszBuf,
- UINT cchBuf)
+BOOL WINAPI PathRenameExtensionW(LPWSTR lpszPath, LPCWSTR lpszExt)
{
- FIXME("%s %s 0x%08x\n", pszPath, pszBuf, cchBuf);
- return FALSE;
+ 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;
}
/*************************************************************************
- * PathSearchAndQualifyW [SHLWAPI.@]
+ * PathSearchAndQualifyA [SHLWAPI.@]
+ *
+ * Unimplemented.
+ *
+ * PARAMS
+ * lpszPath [I]
+ * lpszBuf [O]
+ * cchBuf [I] Size of lpszBuf
+ *
+ * RETURNS
+ * Unknown.
*/
-BOOL WINAPI PathSearchAndQualifyW(
- LPCWSTR pszPath,
- LPWSTR pszBuf,
- UINT cchBuf)
+BOOL WINAPI PathSearchAndQualifyA(LPCSTR lpszPath, LPSTR lpszBuf, UINT cchBuf)
{
- FIXME("%s %s 0x%08x\n", debugstr_w(pszPath), debugstr_w(pszBuf), cchBuf);
- return FALSE;
+ FIXME("(%s,%p,0x%08x)-stub\n", debugstr_a(lpszPath), lpszBuf, cchBuf);
+ return FALSE;
}
/*************************************************************************
- * PathSkipRootA [SHLWAPI.@]
+ * PathSearchAndQualifyW [SHLWAPI.@]
+ *
+ * See PathSearchAndQualifyA
*/
-LPSTR WINAPI PathSkipRootA(LPCSTR pszPath)
+BOOL WINAPI PathSearchAndQualifyW(LPCWSTR lpszPath, LPWSTR lpszBuf, UINT cchBuf)
{
- FIXME("%s\n", pszPath);
- return (LPSTR)pszPath;
+ FIXME("(%s,%p,0x%08x)-stub\n", debugstr_w(lpszPath), lpszBuf, cchBuf);
+ return FALSE;
}
/*************************************************************************
- * PathSkipRootW [SHLWAPI.@]
+ * PathSkipRootA [SHLWAPI.@]
+ *
+ * Return the portion of a path following the drive letter or mount point.
+ *
+ * PARAMS
+ * lpszPath [I] The path to skip on
+ *
+ * RETURNS
+ * Success: A pointer to the next character after the root.
+ * Failure: NULL, if lpszPath is invalid, has no root or is a MB string.
*/
-LPWSTR WINAPI PathSkipRootW(LPCWSTR pszPath)
+LPSTR WINAPI PathSkipRootA(LPCSTR lpszPath)
{
- FIXME("%s\n", debugstr_w(pszPath));
- return (LPWSTR)pszPath;
+ 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;
}
/*************************************************************************
- * PathCreateFromUrlA [SHLWAPI.@]
+ * PathSkipRootW [SHLWAPI.@]
+ *
+ * See PathSkipRootA.
*/
-HRESULT WINAPI PathCreateFromUrlA(
- LPCSTR pszUrl,
- LPSTR pszPath,
- LPDWORD pcchPath,
- DWORD dwFlags)
+LPWSTR WINAPI PathSkipRootW(LPCWSTR lpszPath)
{
+ 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;
+}
+
+/*************************************************************************
+ * PathCreateFromUrlA [SHLWAPI.@]
+ *
+ * Create a path from a URL
+ *
+ * PARAMS
+ * lpszUrl [I] URL to convert into a path
+ * lpszPath [O] Output buffer for the resulting Path
+ * pcchPath [I] Length of lpszPath
+ * dwFlags [I] Flags controlling the conversion
+ *
+ * RETURNS
+ * Success: S_OK. lpszPath contains the URL in path format
+ * Failure: An HRESULT error code such as E_INVALIDARG.
+ */
+HRESULT WINAPI PathCreateFromUrlA(LPCSTR lpszUrl, LPSTR lpszPath,
+ LPDWORD pcchPath, DWORD dwFlags)
+{
+ FIXME("(%s,%p,%p,0x%08lx)-stub\n", debugstr_a(lpszUrl), lpszPath, pcchPath, dwFlags);
+
+ if (!lpszUrl || !lpszPath || !pcchPath || !*pcchPath)
+ return E_INVALIDARG;
+
/* extracts thing prior to : in pszURL and checks against:
* https
* shell
* local
* about - if match returns E_INVALIDARG
*/
- FIXME("%s %p %p 0x%08lx\n",
- pszUrl, pszPath, pcchPath, dwFlags);
- return E_INVALIDARG;
+
+ return S_OK;
}
/*************************************************************************
- * PathCreateFromUrlW [SHLWAPI.@]
+ * PathCreateFromUrlW [SHLWAPI.@]
+ *
+ * See PathCreateFromUrlA.
*/
-HRESULT WINAPI PathCreateFromUrlW(
- LPCWSTR pszUrl,
- LPWSTR pszPath,
- LPDWORD pcchPath,
- DWORD dwFlags)
+HRESULT WINAPI PathCreateFromUrlW(LPCWSTR lpszUrl, LPWSTR lpszPath,
+ LPDWORD pcchPath, DWORD dwFlags)
{
- /* extracts thing prior to : in pszURL and checks against:
- * https
- * shell
- * local
- * about - if match returns E_INVALIDARG
- */
- FIXME("%s %p %p 0x%08lx\n",
- debugstr_w(pszUrl), pszPath, pcchPath, dwFlags);
- return E_INVALIDARG;
+ FIXME("(%s,%p,%p,0x%08lx)-stub\n", debugstr_w(lpszUrl), lpszPath, pcchPath, dwFlags);
+
+ if (!lpszUrl || !lpszPath || !pcchPath || !*pcchPath)
+ return E_INVALIDARG;
+
+ return S_OK;
}
/*************************************************************************
- * PathRelativePathToA [SHLWAPI.@]
+ * PathRelativePathToA [SHLWAPI.@]
+ *
+ * Create a relative path from one path to another.
+ *
+ * PARAMS
+ * lpszPath [O] Destination for relative path
+ * lpszFrom [I] Source path
+ * dwAttrFrom [I] File attribute of source path
+ * lpszTo [I] Destination path
+ * dwAttrTo [I] File attributes of destination path
+ *
+ * RETURNS
+ * TRUE If a relative path can be formed. lpszPath contains the new path
+ * FALSE If the paths are not relavtive or any parameters are invalid
+ *
+ * NOTES
+ * lpszTo should be at least MAX_PATH in length.
+ * Calling this function with relative paths for lpszFrom or lpszTo may
+ * give erroneous results.
+ *
+ * The Win32 version of this function contains a bug where the lpszTo string
+ * may be referenced 1 byte beyond the end of the string. As a result random
+ * garbage may be written to the output path, depending on what lies beyond
+ * the last byte of the string. This bug occurs because of the behaviour of
+ * PathCommonPrefix (see notes for that function), and no workaround seems
+ * possible with Win32.
+ * This bug has been fixed here, so for example the relative path from "\\"
+ * to "\\" is correctly determined as "." in this implementation.
*/
-BOOL WINAPI PathRelativePathToA(
- LPSTR pszPath,
- LPCSTR pszFrom,
- DWORD dwAttrFrom,
- LPCSTR pszTo,
- DWORD dwAttrTo)
+BOOL WINAPI PathRelativePathToA(LPSTR lpszPath, LPCSTR lpszFrom, DWORD dwAttrFrom,
+ LPCSTR lpszTo, DWORD dwAttrTo)
{
- FIXME("%s %s 0x%08lx %s 0x%08lx\n",
- pszPath, pszFrom, dwAttrFrom, pszTo, dwAttrTo);
- return FALSE;
+ BOOL bRet = FALSE;
+
+ TRACE("(%p,%s,0x%08lx,%s,0x%08lx)\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(0,0,lpszFrom,-1,szFrom,MAX_PATH);
+ MultiByteToWideChar(0,0,lpszTo,-1,szTo,MAX_PATH);
+ bRet = PathRelativePathToW(szPath,szFrom,dwAttrFrom,szTo,dwAttrTo);
+ WideCharToMultiByte(0,0,szPath,-1,lpszPath,MAX_PATH,0,0);
+ }
+ return bRet;
}
/*************************************************************************
- * PathRelativePathToW [SHLWAPI.@]
+ * PathRelativePathToW [SHLWAPI.@]
+ *
+ * See PathRelativePathToA.
*/
-BOOL WINAPI PathRelativePathToW(
- LPWSTR pszPath,
- LPCWSTR pszFrom,
- DWORD dwAttrFrom,
- LPCWSTR pszTo,
- DWORD dwAttrTo)
+BOOL WINAPI PathRelativePathToW(LPWSTR lpszPath, LPCWSTR lpszFrom, DWORD dwAttrFrom,
+ LPCWSTR lpszTo, DWORD dwAttrTo)
{
- FIXME("%s %s 0x%08lx %s 0x%08lx\n",
- debugstr_w(pszPath), debugstr_w(pszFrom), dwAttrFrom, debugstr_w(pszTo), dwAttrTo);
- return FALSE;
+ static const WCHAR szPrevDirSlash[] = { '.', '.', '\\', '\0' };
+ static const WCHAR szPrevDir[] = { '.', '.', '\0' };
+ WCHAR szFrom[MAX_PATH];
+ WCHAR szTo[MAX_PATH];
+ DWORD dwLen;
+
+ TRACE("(%p,%s,0x%08lx,%s,0x%08lx)\n", lpszPath, debugstr_w(lpszFrom),
+ dwAttrFrom, debugstr_w(lpszTo), dwAttrTo);
+
+ if(!lpszPath || !lpszFrom || !lpszTo)
+ return FALSE;
+
+ *lpszPath = '\0';
+ strncpyW(szFrom, lpszFrom, MAX_PATH);
+ strncpyW(szTo, lpszTo, MAX_PATH);
+
+ if(!(dwAttrFrom & FILE_ATTRIBUTE_DIRECTORY))
+ PathRemoveFileSpecW(szFrom);
+ if(!(dwAttrFrom & 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;
}
/*************************************************************************
- * PathUnmakeSystemFolderA [SHLWAPI.@]
+ * PathUnmakeSystemFolderA [SHLWAPI.@]
+ *
+ * Remove the system folder attributes from a path.
+ *
+ * PARAMS
+ * lpszPath [I] The path to remove attributes from
+ *
+ * RETURNS
+ * Success: TRUE.
+ * Failure: FALSE, if lpszPath is NULL, empty, not a directory, or calling
+ * SetFileAttributesA fails.
*/
-BOOL WINAPI PathUnmakeSystemFolderA(LPCSTR pszPath)
+BOOL WINAPI PathUnmakeSystemFolderA(LPCSTR lpszPath)
{
- FIXME("%s\n", pszPath);
- return FALSE;
+ DWORD dwAttr;
+
+ TRACE("(%s)\n", debugstr_a(lpszPath));
+
+ if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesA(lpszPath)) == -1 ||
+ !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
+ return FALSE;
+
+ dwAttr &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
+ return SetFileAttributesA(lpszPath, dwAttr);
}
/*************************************************************************
- * PathUnmakeSystemFolderW [SHLWAPI.@]
+ * PathUnmakeSystemFolderW [SHLWAPI.@]
+ *
+ * See PathUnmakeSystemFolderA.
*/
-BOOL WINAPI PathUnmakeSystemFolderW(LPCWSTR pszPath)
+BOOL WINAPI PathUnmakeSystemFolderW(LPCWSTR lpszPath)
{
- FIXME("%s\n", debugstr_w(pszPath));
- return FALSE;
+ DWORD dwAttr;
+
+ TRACE("(%s)\n", debugstr_w(lpszPath));
+
+ if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesW(lpszPath)) == -1 ||
+ !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
+ return FALSE;
+
+ dwAttr &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
+ return SetFileAttributesW(lpszPath, dwAttr);
}
-/*
- ########## special ##########
-*/
/*************************************************************************
* PathSetDlgItemPathA [SHLWAPI.@]
*
+ * Set the text of a dialog item to a path, shrinking the path to fit
+ * if it is too big for the item.
+ *
+ * PARAMS
+ * hDlg [I] Dialog handle
+ * id [I] ID of item in the dialog
+ * lpszPath [I] Path to set as the items text
+ *
+ * RETURNS
+ * Nothing.
+ *
* NOTES
- * use PathCompactPath to make sure, the path fits into the control
+ * If lpszPath is NULL, a blank string ("") is set (i.e. The previous
+ * window text is erased).
*/
-BOOL WINAPI PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR pszPath)
-{ TRACE("%x %x %s\n",hDlg, id, pszPath);
- return SetDlgItemTextA(hDlg, id, pszPath);
+VOID WINAPI PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR lpszPath)
+{
+ WCHAR szPath[MAX_PATH];
+
+ TRACE("(%8x,%8x,%s)\n",hDlg, id, debugstr_a(lpszPath));
+
+ if (lpszPath)
+ MultiByteToWideChar(0,0,lpszPath,-1,szPath,MAX_PATH);
+ else
+ szPath[0] = '\0';
+ PathSetDlgItemPathW(hDlg, id, szPath);
}
/*************************************************************************
* PathSetDlgItemPathW [SHLWAPI.@]
+ *
+ * See PathSetDlgItemPathA.
*/
-BOOL WINAPI PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR pszPath)
-{ TRACE("%x %x %s\n",hDlg, id, debugstr_w(pszPath));
- return SetDlgItemTextW(hDlg, id, pszPath);
+VOID WINAPI PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR lpszPath)
+{
+ WCHAR path[MAX_PATH + 1];
+ HWND hwItem;
+ RECT rect;
+ HDC hdc;
+ HGDIOBJ hPrevObj;
+
+ TRACE("(%8x,%8x,%s)\n",hDlg, id, debugstr_w(lpszPath));
+
+ if (!(hwItem = GetDlgItem(hDlg, id)))
+ return;
+
+ if (lpszPath)
+ strncpyW(path, lpszPath, sizeof(path));
+ 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);
+}
+
+/*************************************************************************
+ * PathIsNetworkPathA [SHLWAPI.@]
+ *
+ * Determine if the given path is a network path.
+ *
+ * PARAMS
+ * lpszPath [I] Path to check
+ *
+ * RETURNS
+ * TRUE If path is a UNC share or mapped network drive
+ * FALSE If path is a local drive or cannot be determined
+ */
+BOOL WINAPI PathIsNetworkPathA(LPCSTR lpszPath)
+{
+ static BOOL (WINAPI *pfnFunc)(DWORD);
+ DWORD 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;
+ GET_FUNC(shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
+ return pfnFunc(dwDriveNum);
+}
+
+/*************************************************************************
+ * PathIsNetworkPathW [SHLWAPI.@]
+ *
+ * See PathIsNetworkPathA.
+ */
+BOOL WINAPI PathIsNetworkPathW(LPCWSTR lpszPath)
+{
+ static BOOL (WINAPI *pfnFunc)(DWORD);
+ DWORD 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;
+ GET_FUNC(shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
+ return pfnFunc(dwDriveNum);
+}
+
+/*************************************************************************
+ * PathIsLFNFileSpecA [SHLWAPI.@]
+ *
+ * Determine if the given path is a long file name
+ *
+ * PARAMS
+ * lpszPath [I] Path to check
+ *
+ * RETURNS
+ * TRUE If path is a long file name
+ * FALSE If path is a valid DOS 8.3 file name
+ */
+BOOL WINAPI PathIsLFNFileSpecA(LPCSTR lpszPath)
+{
+ 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 [SHLWAPI.@]
+ *
+ * See PathIsLFNFileSpecA.
+ */
+BOOL WINAPI PathIsLFNFileSpecW(LPCWSTR lpszPath)
+{
+ 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 */
+}
+
+/*************************************************************************
+ * PathIsDirectoryEmptyA [SHLWAPI.@]
+ *
+ * Determine if a given directory is empty.
+ *
+ * PARAMS
+ * lpszPath [I] Directory to check
+ *
+ * RETURNS
+ * TRUE If the directory exists and contains no files
+ * FALSE Otherwise
+ */
+BOOL WINAPI PathIsDirectoryEmptyA(LPCSTR lpszPath)
+{
+ BOOL bRet = FALSE;
+
+ TRACE("(%s)\n",debugstr_a(lpszPath));
+
+ if (lpszPath)
+ {
+ WCHAR szPath[MAX_PATH];
+ MultiByteToWideChar(0,0,lpszPath,-1,szPath,MAX_PATH);
+ bRet = PathIsDirectoryEmptyW(szPath);
+ }
+ return bRet;
+}
+
+/*************************************************************************
+ * PathIsDirectoryEmptyW [SHLWAPI.@]
+ *
+ * See PathIsDirectoryEmptyA.
+ */
+BOOL WINAPI PathIsDirectoryEmptyW(LPCWSTR lpszPath)
+{
+ static const WCHAR szAllFiles[] = { '*', '.', '*', '\0' };
+ WCHAR szSearch[MAX_PATH];
+ DWORD dwLen;
+ HANDLE hfind;
+ BOOL retVal = FALSE;
+ WIN32_FIND_DATAW find_data;
+
+ TRACE("(%s)\n",debugstr_w(lpszPath));
+
+ if (!lpszPath || !PathIsDirectoryW(lpszPath))
+ return FALSE;
+
+ strncpyW(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 &&
+ find_data.cFileName[0] == '.' &&
+ find_data.cFileName[1] == '.')
+ {
+ /* The only directory entry should be the parent */
+ if (!FindNextFileW(hfind, &find_data))
+ retVal = TRUE;
+ FindClose(hfind);
+ }
+ return retVal;
+}
+
+
+/*************************************************************************
+ * PathFindSuffixArrayA [SHLWAPI.@]
+ *
+ * Find a suffix string in an array of suffix strings
+ *
+ * PARAMS
+ * lpszSuffix [I] Suffix string to search for
+ * lppszArray [I] Array of suffix strings to search
+ * dwCount [I] Number of elements in lppszArray
+ *
+ * RETURNS
+ * Success The index of the position of lpszSuffix in lppszArray
+ * Failure 0, if any parameters are invalid or lpszSuffix is not found
+ *
+ * NOTES
+ * The search is case sensitive.
+ * The match is made against the end of the suffix string, so for example:
+ * lpszSuffix=fooBAR matches BAR, but lpszSuffix=fooBARfoo does not.
+ */
+int WINAPI PathFindSuffixArrayA(LPCSTR lpszSuffix, LPCSTR *lppszArray, int dwCount)
+{
+ DWORD 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)
+ {
+ DWORD dwCompareLen = strlen(*lppszArray);
+ if (dwCompareLen < dwLen)
+ {
+ if (!strcmp(lpszSuffix + dwLen - dwCompareLen, *lppszArray))
+ return dwRet; /* Found */
+ }
+ dwRet++;
+ lppszArray++;
+ }
+ }
+ return 0;
+}
+
+/*************************************************************************
+ * PathFindSuffixArrayW [SHLWAPI.@]
+ *
+ * See PathFindSuffixArrayA.
+ */
+int WINAPI PathFindSuffixArrayW(LPCWSTR lpszSuffix, LPCWSTR *lppszArray, int dwCount)
+{
+ DWORD 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)
+ {
+ DWORD dwCompareLen = strlenW(*lppszArray);
+ if (dwCompareLen < dwLen)
+ {
+ if (!strcmpW(lpszSuffix + dwLen - dwCompareLen, *lppszArray))
+ return dwRet; /* Found */
+ }
+ dwRet++;
+ lppszArray++;
+ }
+ }
+ return 0;
+}
+
+/*************************************************************************
+ * PathUndecorateA [SHLWAPI.@]
+ *
+ * Undecorate a file path
+ *
+ * PARAMS
+ * lpszPath [O] Path to undecorate
+ *
+ * RETURNS
+ * Nothing
+ *
+ * NOTES
+ * A decorations form is "path[n].ext" where n is an optional decimal number.
+ */
+VOID WINAPI PathUndecorateA(LPSTR lpszPath)
+{
+ TRACE("(%s)\n",debugstr_a(lpszPath));
+
+ if (lpszPath)
+ {
+ LPSTR lpszExt = PathFindExtensionA(lpszPath);
+ if (lpszExt > lpszPath && lpszExt[-1] == ']')
+ {
+ LPSTR lpszSkip = lpszExt - 2;
+ if (*lpszSkip == '[')
+ lpszSkip++; /* [] (no number) */
+ else
+ while (lpszSkip > lpszPath && isdigit(lpszSkip[-1]))
+ lpszSkip--;
+ if (lpszSkip > lpszPath && lpszSkip[-1] == '[' && lpszSkip[-2] != '\\')
+ {
+ /* remove the [n] */
+ lpszSkip--;
+ while (*lpszExt)
+ *lpszSkip++ = *lpszExt++;
+ *lpszSkip = '\0';
+ }
+ }
+ }
+}
+
+/*************************************************************************
+ * PathUndecorateW [SHLWAPI.@]
+ *
+ * See PathUndecorateA.
+ */
+VOID WINAPI PathUndecorateW(LPWSTR lpszPath)
+{
+ TRACE("(%s)\n",debugstr_w(lpszPath));
+
+ if (lpszPath)
+ {
+ LPWSTR lpszExt = PathFindExtensionW(lpszPath);
+ if (lpszExt > lpszPath && lpszExt[-1] == ']')
+ {
+ LPWSTR lpszSkip = lpszExt - 2;
+ if (*lpszSkip == '[')
+ lpszSkip++; /* [] (no number) */
+ else
+ while (lpszSkip > lpszPath && isdigitW(lpszSkip[-1]))
+ lpszSkip--;
+ if (lpszSkip > lpszPath && lpszSkip[-1] == '[' && lpszSkip[-2] != '\\')
+ {
+ /* remove the [n] */
+ lpszSkip--;
+ while (*lpszExt)
+ *lpszSkip++ = *lpszExt++;
+ *lpszSkip = '\0';
+ }
+ }
+ }
}
diff --git a/dlls/shlwapi/shlwapi.spec b/dlls/shlwapi/shlwapi.spec
index 10490d8..6bb6703 100644
--- a/dlls/shlwapi/shlwapi.spec
+++ b/dlls/shlwapi/shlwapi.spec
@@ -12,10 +12,10 @@
1 stdcall @(str ptr) SHLWAPI_1
2 stdcall @(wstr ptr) SHLWAPI_2
-3 stub @
-4 stub @
-5 stub @
-6 stub @
+3 stdcall @(str long) SHLWAPI_3
+4 stdcall @(wstr long) SHLWAPI_4
+5 stdcall @(str ptr long) SHLWAPI_5
+6 stdcall @(wstr ptr long) SHLWAPI_6
7 stdcall @(long long ptr) SHLWAPI_7
8 stdcall @(long long) SHLWAPI_8
9 stdcall @(ptr) SHLWAPI_9
@@ -702,17 +702,17 @@
@ stdcall SHRegGetPathW(long wstr wstr ptr long)SHRegGetPathW
@ stub MLLoadLibraryA
@ stub MLLoadLibraryW
-@ stub PathIsDirectoryEmptyA
-@ stub PathIsDirectoryEmptyW
-@ stub PathIsNetworkPathA
-@ stub PathIsNetworkPathW
-@ stub PathIsLFNFileSpecA
-@ stub PathIsLFNFileSpecW
-@ stub PathFindSuffixArrayA
-@ stub PathFindSuffixArrayW
+@ stdcall PathIsDirectoryEmptyA(str) PathIsDirectoryEmptyA
+@ stdcall PathIsDirectoryEmptyW(wstr) PathIsDirectoryEmptyW
+@ stdcall PathIsNetworkPathA(str) PathIsNetworkPathA
+@ stdcall PathIsNetworkPathW(wstr) PathIsNetworkPathW
+@ stdcall PathIsLFNFileSpecA(str) PathIsLFNFileSpecA
+@ stdcall PathIsLFNFileSpecW(wstr) PathIsLFNFileSpecW
+@ stdcall PathFindSuffixArrayA(str) PathFindSuffixArrayA
+@ stdcall PathFindSuffixArrayW(wstr) PathFindSuffixArrayW
@ stdcall _SHGetInstanceExplorer@4(ptr) _SHGetInstanceExplorer
-@ stub PathUndecorateA
-@ stub PathUndecorateW
+@ stdcall PathUndecorateA(str) PathUndecorateA
+@ stdcall PathUndecorateW(wstr) PathUndecorateW
@ stub PathUnExpandEnvStringsA
@ stub PathUnExpandEnvStringsW
@ stub SHCopyKeyA
diff --git a/include/shlwapi.h b/include/shlwapi.h
index 05855ee..6826404 100644
--- a/include/shlwapi.h
+++ b/include/shlwapi.h
@@ -310,8 +310,8 @@
int WINAPI PathParseIconLocationW(LPWSTR);
#define PathParseIconLocation WINELIB_NAME_AW(PathParseIconLocation)
-LPSTR WINAPI PathQuoteSpacesA(LPSTR);
-LPWSTR WINAPI PathQuoteSpacesW(LPWSTR);
+VOID WINAPI PathQuoteSpacesA(LPSTR);
+VOID WINAPI PathQuoteSpacesW(LPWSTR);
#define PathQuoteSpaces WINELIB_NAME_AW(PathQuoteSpaces)
BOOL WINAPI PathRelativePathToA(LPSTR,LPCSTR,DWORD,LPCSTR,DWORD);
@@ -346,8 +346,8 @@
BOOL WINAPI PathSearchAndQualifyW(LPCWSTR,LPWSTR,UINT);
#define PathSearchAndQualify WINELIB_NAME_AW(PathSearchAndQualify)
-BOOL WINAPI PathSetDlgItemPathA(HWND,int,LPCSTR);
-BOOL WINAPI PathSetDlgItemPathW(HWND,int,LPCWSTR);
+VOID WINAPI PathSetDlgItemPathA(HWND,int,LPCSTR);
+VOID WINAPI PathSetDlgItemPathW(HWND,int,LPCWSTR);
#define PathSetDlgItemPath WINELIB_NAME_AW(PathSetDlgItemPath)
LPSTR WINAPI PathSkipRootA(LPCSTR);
@@ -386,8 +386,8 @@
BOOL WINAPI PathIsLFNFileSpecW(LPCWSTR);
#define PathIsLFNFileSpec WINELIB_NAME_AW(PathIsLFNFileSpec)
-LPCSTR WINAPI PathFindSuffixArrayA(LPCSTR,LPCSTR *,int);
-LPCWSTR WINAPI PathFindSuffixArrayW(LPCWSTR,LPCWSTR *,int);
+int WINAPI PathFindSuffixArrayA(LPCSTR,LPCSTR *,int);
+int WINAPI PathFindSuffixArrayW(LPCWSTR,LPCWSTR *,int);
#define PathFindSuffixArray WINELIB_NAME_AW(PathFindSuffixArray)
VOID WINAPI PathUndecorateA(LPSTR);
