Changeset 8584 for trunk/src

Timestamp:

Jun 7, 2002, 10:02:20 AM (23 years ago)

Author:

sandervl

Message:

resynced with latest Wine

Location:

trunk/src/shlwapi

Files:

• COPYING.LIB (added)
• LICENSE.TXT (modified) (1 diff)
• dbgwrap.cpp (modified) (8 diffs)
• makefile (modified) (4 diffs)
• ordinal.c (modified) (57 diffs)
• ordinal.h (modified) (2 diffs)
• ordinal_odin.cpp (modified) (12 diffs)
• path.c (modified) (17 diffs)
• pathcpp.cpp (deleted)
• reg.c (modified) (34 diffs)
• regstream.c (modified) (11 diffs)
• shlwapi.def (modified) (14 diffs)
• shlwapi_main.c (modified) (5 diffs)
• shlwapidbg.def (modified) (10 diffs)
• string.c (modified) (12 diffs)
• string_odin.cpp (modified) (2 diffs)
• url.c (modified) (33 diffs)
• wsprintf.c (added)

trunk/src/shlwapi/LICENSE.TXT

@@ -1 @@
-$Id: LICENSE.TXT,v 1.2 2001-07-21 08:48:22 sandervl Exp $
-@c This is an additional Odin license agreement.
-@c It supercedes the main Odin license, but is only valid in 
-@c the source directory in which it is present.
+$Id: LICENSE.TXT,v 1.3 2002-06-07 08:02:16 sandervl Exp $
+This is an additional Odin license agreement.
+It supercedes the main Odin license, but is only valid in 
+the source directory in which it is present.
 
-@c This file is processed by GNU's TeXinfo
-@c If you modify it or move it to another location, make sure that
-@c TeXinfo works (type `make' in directory documentation).
-
-Copyright (c) 1993-2000 the Wine project authors (see the file AUTHORS
+Copyright (c) 1993-2002 the Wine project authors (see the file AUTHORS
 for a complete list)
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+Wine is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 2.1 of the License, or (at
+your option) any later version. 
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+A copy of the GNU Lesser General Public License is included in the
+Wine distribution in the file COPYING.LIB. If you did not receive this
+copy, write to the Free Software Foundation, Inc., 59 Temple Place,
+Suite 330, Boston, MA 02111-1307 USA.

trunk/src/shlwapi/dbgwrap.cpp

@@ -61 +61 @@
 NODEF_DEBUGWRAP12(SHLWAPI_153)
 NODEF_DEBUGWRAP12(SHLWAPI_154)
+NODEF_DEBUGWRAP8(SHLWAPI_155)
 NODEF_DEBUGWRAP8(SHLWAPI_156)
 NODEF_DEBUGWRAP8(SHLWAPI_158)
@@ -71 +72 @@
 NODEF_DEBUGWRAP8(SHLWAPI_172)
 NODEF_DEBUGWRAP8(SHLWAPI_174)
+NODEF_DEBUGWRAP8(SHLWAPI_175)
 NODEF_DEBUGWRAP16(SHLWAPI_176)
 NODEF_DEBUGWRAP12(SHLWAPI_181)
@@ -82 +84 @@
 NODEF_DEBUGWRAP24(SHLWAPI_206)
 NODEF_DEBUGWRAP20(SHLWAPI_208)
+NODEF_DEBUGWRAP4(SHLWAPI_209)
 NODEF_DEBUGWRAP12(SHLWAPI_210)
 NODEF_DEBUGWRAP8(SHLWAPI_211)
@@ -101 +104 @@
 NODEF_DEBUGWRAP24(SHLWAPI_278)
 NODEF_DEBUGWRAP12(SHLWAPI_289)
+NODEF_DEBUGWRAP20(SHLWAPI_294)
 NODEF_DEBUGWRAP20(SHLWAPI_313)
 NODEF_DEBUGWRAP16(SHLWAPI_318)
@@ -113 +117 @@
 NODEF_DEBUGWRAP20(SHLWAPI_337)
 NODEF_DEBUGWRAP12(SHLWAPI_346)
+NODEF_DEBUGWRAP8(SHLWAPI_350)
+NODEF_DEBUGWRAP16(SHLWAPI_351)
+NODEF_DEBUGWRAP16(SHLWAPI_352)
 NODEF_DEBUGWRAP12(SHLWAPI_356)
 NODEF_DEBUGWRAP20(SHLWAPI_357)
@@ -128 +135 @@
 NODEF_DEBUGWRAP4(SHLWAPI_403)
 NODEF_DEBUGWRAP4(SHLWAPI_413)
+NODEF_DEBUGWRAP4(SHLWAPI_418)
 NODEF_DEBUGWRAP4(SHLWAPI_431)
+NODEF_DEBUGWRAP8(SHLWAPI_436)
 NODEF_DEBUGWRAP4(SHLWAPI_437)
 
@@ -180 +189 @@
 DEBUGWRAP4(PathIsDirectoryA)
 DEBUGWRAP4(PathIsDirectoryW)
+DEBUGWRAP4(PathIsDirectoryEmptyA)
+DEBUGWRAP4(PathIsDirectoryEmptyW)
 DEBUGWRAP4(PathIsFileSpecA)
 DEBUGWRAP4(PathIsFileSpecW)
@@ -365 +376 @@
 
 
+DEBUGWRAP16(wvnsprintfA)
+DEBUGWRAP16(wvnsprintfW)
+DEBUGWRAP20(SHRegSetPathA)
+DEBUGWRAP20(SHRegSetPathW)
+NODEF_DEBUGWRAP4(SHGetThreadRef)
+NODEF_DEBUGWRAP4(SHSetThreadRef)
+NODEF_DEBUGWRAP4(SHRegDuplicateHKey)
+DEBUGWRAP4(PathUndecorateA)
+DEBUGWRAP4(PathUndecorateW)
+DEBUGWRAP4(PathIsLFNFileSpecA)
+DEBUGWRAP4(PathIsLFNFileSpecW)
+DEBUGWRAP4(PathIsNetworkPathA)
+DEBUGWRAP4(PathIsNetworkPathW)
+DEBUGWRAP12(PathFindSuffixArrayA)
+DEBUGWRAP12(PathFindSuffixArrayW)

trunk/src/shlwapi/makefile

@@ -1 @@
-# $Id: makefile,v 1.26 2002-02-13 16:15:07 sandervl Exp $
+# $Id: makefile,v 1.27 2002-06-07 08:02:17 sandervl Exp $
 
 #
@@ -31 +31 @@
 $(OBJDIR)\reg.obj \
 $(OBJDIR)\regstream.obj \
-$(OBJDIR)\pathcpp.obj \
 $(OBJDIR)\path.obj \
 $(OBJDIR)\string_odin.obj \
@@ -37 +36 @@
 $(OBJDIR)\ordinal.obj \
 $(OBJDIR)\ordinal_odin.obj \
+$(OBJDIR)\wsprintf.obj \
 !if "$(DEBUG)" == "1"
 $(OBJDIR)\dbgwrap.obj \
@@ -49 +49 @@
 LIBS = \
 $(ODIN32_LIB)/kernel32.lib \
+$(ODIN32_LIB)/advapi32.lib \
 $(ODIN32_LIB)/ntdll.lib \
 $(ODIN32_LIB)/user32.lib \

trunk/src/shlwapi/ordinal.c

@@ -5 +5 @@
  *           1998 Jürgen Schmied
  *           2001 Jon Griffiths
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
@@ -24 +38 @@
 #include "winreg.h"
 #include "winuser.h"
-#include "debugtools.h"
+#include "wine/debug.h"
 #include "ordinal.h"
 #include "shlwapi.h"
 
-DEFAULT_DEBUG_CHANNEL(shell);
+WINE_DEFAULT_DEBUG_CHANNEL(shell);
 
 extern HINSTANCE shlwapi_hInstance;
@@ -36 +50 @@
 extern HMODULE SHLWAPI_hmpr;
 extern HMODULE SHLWAPI_hmlang;
+extern HMODULE SHLWAPI_hversion;
+
+extern DWORD SHLWAPI_ThreadRef_index;
 
 typedef HANDLE HSHARED; /* Shared memory */
@@ -98 +115 @@
 };
 
-/* 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
+/* function pointers for GET_FUNC macro; these need to be global because of gcc bug */
+#ifdef __WIN32OS2__
+static LPITEMIDLIST (* WINAPI pSHBrowseForFolderW)(LPBROWSEINFOW);
+static HRESULT (* WINAPI pConvertINetUnicodeToMultiByte)(LPDWORD,DWORD,LPCWSTR,LPINT,LPSTR,LPINT);
+static BOOL    (* WINAPI pPlaySoundW)(LPCWSTR, HMODULE, DWORD);
+static DWORD   (* WINAPI pSHGetFileInfoW)(LPCWSTR,DWORD,SHFILEINFOW*,UINT,UINT);
+static UINT    (* WINAPI pDragQueryFileW)(HDROP, UINT, LPWSTR, UINT);
+static BOOL    (* WINAPI pSHGetPathFromIDListW)(LPCITEMIDLIST, LPWSTR);
+static BOOL    (* WINAPI pShellExecuteExW)(LPSHELLEXECUTEINFOW);
+static HICON   (* WINAPI pSHFileOperationW)(LPSHFILEOPSTRUCTW);
+static HICON   (* WINAPI pExtractIconExW)(LPCWSTR, INT,HICON *,HICON *, UINT);
+static BOOL    (* WINAPI pSHGetNewLinkInfoW)(LPCWSTR, LPCWSTR, LPCWSTR, BOOL*, UINT);
+static DWORD   (* WINAPI pSHDefExtractIconW)(LPVOID, LPVOID, LPVOID, LPVOID, LPVOID, LPVOID); /* FIXME: Correct args */
+static HICON   (* WINAPI pExtractIconW)(HINSTANCE, LPCWSTR, UINT);
+static BOOL    (* WINAPI pGetSaveFileNameW)(LPOPENFILENAMEW);
+static DWORD   (* WINAPI pWNetRestoreConnectionW)(LPVOID, LPVOID); /* FIXME: Correct args */
+static DWORD   (* WINAPI pWNetGetLastErrorW)(LPVOID, LPVOID, LPVOID, LPVOID, LPVOID); /* FIXME: Correct args */
+static BOOL    (* WINAPI pPageSetupDlgW)(LPPAGESETUPDLGW);
+static BOOL    (* WINAPI pPrintDlgW)(LPPRINTDLGW);
+static BOOL    (* WINAPI pGetOpenFileNameW)(LPOPENFILENAMEW);
+static HRESULT (* WINAPI pSHGetInstanceExplorer)(LPUNKNOWN *);
+static DWORD   (* WINAPI pGetFileVersionInfoSizeW)(LPCWSTR,LPDWORD);
+static BOOL    (* WINAPI pGetFileVersionInfoW)(LPCWSTR,DWORD,DWORD,LPVOID);
+static WORD    (* WINAPI pVerQueryValueW)(LPVOID,LPCWSTR,LPVOID*,UINT*);
+#else
+static LPITEMIDLIST (WINAPI *pSHBrowseForFolderW)(LPBROWSEINFOW);
+static HRESULT (WINAPI *pConvertINetUnicodeToMultiByte)(LPDWORD,DWORD,LPCWSTR,LPINT,LPSTR,LPINT);
+static BOOL    (WINAPI *pPlaySoundW)(LPCWSTR, HMODULE, DWORD);
+static DWORD   (WINAPI *pSHGetFileInfoW)(LPCWSTR,DWORD,SHFILEINFOW*,UINT,UINT);
+static UINT    (WINAPI *pDragQueryFileW)(HDROP, UINT, LPWSTR, UINT);
+static BOOL    (WINAPI *pSHGetPathFromIDListW)(LPCITEMIDLIST, LPWSTR);
+static BOOL    (WINAPI *pShellExecuteExW)(LPSHELLEXECUTEINFOW);
+static HICON   (WINAPI *pSHFileOperationW)(LPSHFILEOPSTRUCTW);
+static HICON   (WINAPI *pExtractIconExW)(LPCWSTR, INT,HICON *,HICON *, UINT);
+static BOOL    (WINAPI *pSHGetNewLinkInfoW)(LPCWSTR, LPCWSTR, LPCWSTR, BOOL*, UINT);
+static DWORD   (WINAPI *pSHDefExtractIconW)(LPVOID, LPVOID, LPVOID, LPVOID, LPVOID, LPVOID); /* FIXME: Correct args */
+static HICON   (WINAPI *pExtractIconW)(HINSTANCE, LPCWSTR, UINT);
+static BOOL    (WINAPI *pGetSaveFileNameW)(LPOPENFILENAMEW);
+static DWORD   (WINAPI *pWNetRestoreConnectionW)(LPVOID, LPVOID); /* FIXME: Correct args */
+static DWORD   (WINAPI *pWNetGetLastErrorW)(LPVOID, LPVOID, LPVOID, LPVOID, LPVOID); /* FIXME: Correct args */
+static BOOL    (WINAPI *pPageSetupDlgW)(LPPAGESETUPDLGW);
+static BOOL    (WINAPI *pPrintDlgW)(LPPRINTDLGW);
+static BOOL    (WINAPI *pGetOpenFileNameW)(LPOPENFILENAMEW);
+static HRESULT (WINAPI *pSHGetInstanceExplorer)(LPUNKNOWN *);
+static DWORD   (WINAPI *pGetFileVersionInfoSizeW)(LPCWSTR,LPDWORD);
+static BOOL    (WINAPI *pGetFileVersionInfoW)(LPCWSTR,DWORD,DWORD,LPVOID);
+static WORD    (WINAPI *pVerQueryValueW)(LPVOID,LPCWSTR,LPVOID*,UINT*);
+#endif
 
 /*
@@ -127 +186 @@
 
     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
      */
@@ -183 +242 @@
 
     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
      */
@@ -230 +289 @@
 
 /*************************************************************************
+ * @    [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
  *
@@ -304 +430 @@
  * SHLWAPI_11           - Helper function; Duplicate cross-process handles
    */
-HSHARED WINAPI SHLWAPI_7 (DWORD dwProcId, LPCVOID lpvData, DWORD dwSize)
+HSHARED WINAPI SHLWAPI_7 (DWORD dwProcId, DWORD dwSize, LPCVOID lpvData)
 {
   HANDLE hMap;
@@ -528 +654 @@
  * Function:
  *    Retrieves IE "AcceptLanguage" value from registry. ASCII mode.
- *  
+ *
  */
 HRESULT WINAPI SHLWAPI_14 (
@@ -540 +666 @@
 
         mystrlen = (*buflen > 6) ? *buflen : 6;
-        mystr = (CHAR*)HeapAlloc(GetProcessHeap(), 
+        mystr = (CHAR*)HeapAlloc(GetProcessHeap(),
                                  HEAP_ZERO_MEMORY, mystrlen);
-        RegOpenKeyA(HKEY_CURRENT_USER, 
-                    "Software\\Microsoft\\Internet Explorer\\International", 
+        RegOpenKeyA(HKEY_CURRENT_USER,
+                    "Software\\Microsoft\\Internet Explorer\\International",
                     &mykey);
-        if (RegQueryValueExA(mykey, "AcceptLanguage", 
+        if (RegQueryValueExA(mykey, "AcceptLanguage",
                               0, &mytype, mystr, &mystrlen)) {
             /* Did not find value */
@@ -564 +690 @@
             FIXME("missing code\n");
         }
-        if (mystrlen > *buflen) 
+        if (mystrlen > *buflen)
             lstrcpynA(langbuf, mystr, *buflen);
         else {
             lstrcpyA(langbuf, mystr);
             *buflen = lstrlenA(langbuf);
-        }        
+        }
         RegCloseKey(mykey);
         HeapFree(GetProcessHeap(), 0, mystr);
@@ -581 +707 @@
  * Function:
  *    Retrieves IE "AcceptLanguage" value from registry. UNICODE mode.
- *  
+ *
  */
 HRESULT WINAPI SHLWAPI_15 (
@@ -593 +719 @@
 
         mystrlen = (*buflen > 6) ? *buflen : 6;
-        mystr = (CHAR*)HeapAlloc(GetProcessHeap(), 
+        mystr = (CHAR*)HeapAlloc(GetProcessHeap(),
                                  HEAP_ZERO_MEMORY, mystrlen);
-        RegOpenKeyA(HKEY_CURRENT_USER, 
-                    "Software\\Microsoft\\Internet Explorer\\International", 
+        RegOpenKeyA(HKEY_CURRENT_USER,
+                    "Software\\Microsoft\\Internet Explorer\\International",
                     &mykey);
-        if (RegQueryValueExA(mykey, "AcceptLanguage", 
+        if (RegQueryValueExA(mykey, "AcceptLanguage",
                               0, &mytype, mystr, &mystrlen)) {
             /* Did not find value */
@@ -870 +996 @@
 BOOL WINAPI SHLWAPI_36(HMENU h1, UINT ui2, UINT h3, LPCWSTR p4)
 {
-    TRACE("(0x%08x, 0x%08x, 0x%08x, %s): stub\n", 
+    TRACE("(0x%08x, 0x%08x, 0x%08x, %s): stub\n",
           h1, ui2, h3, debugstr_w(p4));
     return AppendMenuW(h1, ui2, h3, p4);
-}
-
-/*************************************************************************
- *      @       [SHLWAPI.40]
- *
- * Get pointer to next Unicode character.
- */
-LPCWSTR WINAPI SHLWAPI_40(LPCWSTR str)
-{
-  return *str ? str + 1 : str;
 }
 
@@ -941 +1057 @@
 {
     return strncmpiW( str1, str2, len );
+}
+
+/*************************************************************************
+ *      @       [SHLWAPI.155]
+ *
+ *      Case sensitive string compare (ASCII). Does not SetLastError().
+ */
+DWORD WINAPI SHLWAPI_155 ( LPSTR str1, LPSTR str2)
+{
+    return strcmp(str1, str2);
 }
 
@@ -1073 +1199 @@
  *      @       [SHLWAPI.174]
  *
- * Seems to do call either IObjectWithSite::SetSite or 
+ * Seems to do call either IObjectWithSite::SetSite or
  *   IPersistMoniker::GetClassID.  But since we do not implement either
  *   of those classes in our headers, we will fake it out.
@@ -1079 +1205 @@
 DWORD WINAPI SHLWAPI_174(
         IUnknown *p1,     /* [in]   OLE object                          */
-        LPVOID *p2)       /* [out]  ptr to result of either GetClassID 
+        LPVOID *p2)       /* [out]  ptr to result of either GetClassID
                                     or SetSite call.                    */
 {
@@ -1089 +1215 @@
     ret = IUnknown_QueryInterface((IUnknown *)p1, (REFIID)id1, (LPVOID *)&p1);
     TRACE("first IU_QI ret=%08lx, p1=%p\n", ret, p1);
-    if (ret) { 
+    if (ret) {
 
         /* see if GetClassId interface exists for IPersistMoniker object */
@@ -1098 +1224 @@
         /* fake a GetClassId call */
         ret = IOleWindow_GetWindow((IOleWindow *)aa, (HWND*)p2);
-        TRACE("second IU_QI doing 0x0c ret=%08lx, *p2=%08lx\n", ret, 
+        TRACE("second IU_QI doing 0x0c ret=%08lx, *p2=%08lx\n", ret,
               *(LPDWORD)p2);
         IUnknown_Release((IUnknown *)aa);
@@ -1105 +1231 @@
         /* fake a SetSite call */
         ret = IOleWindow_GetWindow((IOleWindow *)p1, (HWND*)p2);
-        TRACE("first IU_QI doing 0x0c ret=%08lx, *p2=%08lx\n", ret, 
+        TRACE("first IU_QI doing 0x0c ret=%08lx, *p2=%08lx\n", ret,
               *(LPDWORD)p2);
         IUnknown_Release((IUnknown *)p1);
@@ -1112 +1238 @@
 }
 
+/*************************************************************************
+ *      @       [SHLWAPI.175]
+ *
+ *      NOTE:
+ *        Param1 can be an IShellFolder Object
+ */
+HRESULT WINAPI SHLWAPI_175 (LPVOID x, LPVOID y)
+{
+        FIXME("(%p %p) stub\n", x,y);
+        return E_FAIL;
+}
 /*************************************************************************
  *      @       [SHLWAPI.176]
@@ -1133 +1270 @@
     if (!unk) return E_FAIL;
     ret = IUnknown_QueryInterface(unk, &IID_IServiceProvider, &aa);
-    TRACE("did IU_QI retval=%08lx, aa=%p\n", ret, aa); 
+    TRACE("did IU_QI retval=%08lx, aa=%p\n", ret, aa);
     if (ret) return ret;
-    ret = IServiceProvider_QueryService((IServiceProvider *)aa, sid, riid, 
+    ret = IServiceProvider_QueryService((IServiceProvider *)aa, sid, riid,
                                         (void **)z);
-    TRACE("did ISP_QS retval=%08lx, *z=%p\n", ret, (LPVOID)*z); 
+    TRACE("did ISP_QS retval=%08lx, *z=%p\n", ret, (LPVOID)*z);
     IUnknown_Release((IUnknown*)aa);
     return ret;
@@ -1220 +1357 @@
 
 /*************************************************************************
+ *      @       [SHLWAPI.209]
+ *
+ * Some sort of memory management process - associated with _208
+ */
+DWORD WINAPI SHLWAPI_209 (
+        LPVOID   a)
+{
+    FIXME("(%p) stub\n",
+          a);
+    return 1;
+}
+
+/*************************************************************************
  *      @       [SHLWAPI.210]
  *
@@ -1261 +1411 @@
         len_a = lstrlenA(lpStrSrc);
         ret = MultiByteToWideChar(0, 0, lpStrSrc, len_a, lpwStrDest, len);
-        TRACE("%s %s %d, ret=%d\n", 
+        TRACE("%s %s %d, ret=%d\n",
               debugstr_a(lpStrSrc), debugstr_w(lpwStrDest), len, ret);
         return ret;
@@ -1274 +1424 @@
                        LPINT lpnMultiCharCount)
 {
-  static HRESULT (* WINAPI pfnFunc)(LPDWORD,DWORD,LPCWSTR,LPINT,LPSTR,LPINT);
   WCHAR emptyW[] = { '\0' };
   int len , reqLen;
@@ -1300 +1449 @@
       INT nWideCharCount = len - 1;
 
-      GET_FUNC(mlang, "ConvertINetUnicodeToMultiByte", 0);
-      if (!pfnFunc(&dwMode, CodePage, lpSrcStr, &nWideCharCount, lpDstStr,
-                   lpnMultiCharCount))
+      GET_FUNC(pConvertINetUnicodeToMultiByte, mlang, "ConvertINetUnicodeToMultiByte", 0);
+      if (!pConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &nWideCharCount, lpDstStr,
+                                          lpnMultiCharCount))
         return 0;
 
@@ -1313 +1462 @@
         *lpnMultiCharCount = 0;
 
-        if (pfnFunc(&dwMode, CodePage, lpSrcStr, &len, mem, lpnMultiCharCount))
+        if (pConvertINetUnicodeToMultiByte(&dwMode, CodePage, lpSrcStr, &len, mem, lpnMultiCharCount))
         {
           SHLWAPI_162 (mem, *lpnMultiCharCount);
@@ -1400 +1549 @@
             xmove = x;
             while (xmove->refid) {
-                TRACE("trying (indx %ld) %s\n", xmove->indx, 
+                TRACE("trying (indx %ld) %s\n", xmove->indx,
                       debugstr_guid(xmove->refid));
                 if (IsEqualIID(riid, xmove->refid)) {
@@ -1543 +1692 @@
 /*************************************************************************
  *      @       [SHLWAPI.266]
+ *
+ * native does at least approximately:
+ *     strcpyW(newstr, x);
+ *     strcatW(newstr, "\\Restrictions");
+ *     if (RegOpenKeyExA(80000001, newstr, 00000000,00000001,40520b78))
+ *        return 0;
+ *    *unknown*
  */
 DWORD WINAPI SHLWAPI_266 (
         LPVOID w,
-        LPVOID x,
+        LPVOID x,   /* [in] partial registry key */
         LPVOID y,
         LPVOID z)
 {
         FIXME("(%p %p %p %p)stub\n",w,x,y,z);
-        return 0xabba1248;
+        return /* 0xabba1248 */ 0;
 }
 
@@ -1558 +1714 @@
  */
 HRESULT WINAPI SHLWAPI_267 (
-        LPVOID w, /* [???] NOTE: same as 1th parameter of SHLWAPI_219 */
-        LPVOID x, /* [???] NOTE: same as 2nd parameter of SHLWAPI_219 */
-        LPVOID y,
-        LPVOID z)
+        LPVOID w,
+        LPVOID x,
+        LPVOID y, /* [???] NOTE: same as 3rd parameter of SHLWAPI_219 */
+        LPVOID z) /* [???] NOTE: same as 4th parameter of SHLWAPI_219 */
 {
         FIXME("(%p %p %p %p)stub\n",w,x,y,z);
+
+        /* native seems to do:
+         *  SHLWAPI_219 ((LPVOID)(((LPSTR)x)-4), ???, (REFIID) y, (LPVOID*) z);
+         */
+
         *((LPDWORD)z) = 0xabba1200;
-        return 0xabba1254;
+        return /* 0xabba1254 */ 0;
 }
 
@@ -1582 +1743 @@
  *      @       [SHLWAPI.276]
  *
+ * on first call process does following:  other calls just returns 2
+ *  instance = LoadLibraryA("SHELL32.DLL");
+ *  func = GetProcAddress(instance, "DllGetVersion");
+ *  ret = RegOpenKeyExA(80000002, "Software\\Microsoft\\Internet Explorer",00000000,0002001f, newkey);
+ *  ret = RegQueryValueExA(newkey, "IntegratedBrowser",00000000,00000000,4052588c,40525890);
+ *  RegCloseKey(newkey);
+ *  FreeLibrary(instance);
+ *  return 2;
  */
 DWORD WINAPI SHLWAPI_276 ()
 {
         FIXME("()stub\n");
-        return /* 0xabba1244 */ 0;
+        return /* 0xabba1244 */ 2;
 }
 
@@ -1637 +1806 @@
 BOOL WINAPI SHLWAPI_289(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound)
 {
-  static BOOL (* WINAPI pfnFunc)(LPCWSTR, HMODULE, DWORD) = NULL;
-
-  GET_FUNC(winmm, "PlaySoundW", FALSE);
-  return pfnFunc(pszSound, hmod, fdwSound);
+  GET_FUNC(pPlaySoundW, winmm, "PlaySoundW", FALSE);
+  return pPlaySoundW(pszSound, hmod, fdwSound);
 }
 
@@ -1675 +1842 @@
                          SHFILEINFOW *psfi, UINT sizeofpsfi, UINT flags)
 {
-  static DWORD (* WINAPI pfnFunc)(LPCWSTR,DWORD,SHFILEINFOW*,UINT,UINT) = NULL;
-
-  GET_FUNC(shell32, "SHGetFileInfoW", 0);
-  return pfnFunc(path, dwFileAttributes, psfi, sizeofpsfi, flags);
+  GET_FUNC(pSHGetFileInfoW, shell32, "SHGetFileInfoW", 0);
+  return pSHGetFileInfoW(path, dwFileAttributes, psfi, sizeofpsfi, flags);
 }
 
@@ -1688 +1853 @@
 UINT WINAPI SHLWAPI_318(HDROP hDrop, UINT lFile, LPWSTR lpszFile, UINT lLength)
 {
-  static UINT (* WINAPI pfnFunc)(HDROP, UINT, LPWSTR, UINT) = NULL;
-
-  GET_FUNC(shell32, "DragQueryFileW", 0);
-  return pfnFunc(hDrop, lFile, lpszFile, lLength);
+  GET_FUNC(pDragQueryFileW, shell32, "DragQueryFileW", 0);
+  return pDragQueryFileW(hDrop, lFile, lpszFile, lLength);
 }
 
@@ -1701 +1864 @@
 LPITEMIDLIST WINAPI SHLWAPI_333(LPBROWSEINFOW lpBi)
 {
-  static LPITEMIDLIST (* WINAPI pfnFunc)(LPBROWSEINFOW) = NULL;
-
-  GET_FUNC(shell32, "SHBrowseForFolderW", NULL);
-  return pfnFunc(lpBi);
+  GET_FUNC(pSHBrowseForFolderW, shell32, "SHBrowseForFolderW", NULL);
+  return pSHBrowseForFolderW(lpBi);
 }
 
@@ -1714 +1875 @@
 BOOL WINAPI SHLWAPI_334(LPCITEMIDLIST pidl,LPWSTR pszPath)
 {
-  static BOOL (* WINAPI pfnFunc)(LPCITEMIDLIST, LPWSTR) = NULL;
-
-  GET_FUNC(shell32, "SHGetPathFromIDListW", 0);
-  return pfnFunc(pidl, pszPath);
+  GET_FUNC(pSHGetPathFromIDListW, shell32, "SHGetPathFromIDListW", 0);
+  return pSHGetPathFromIDListW(pidl, pszPath);
 }
 
@@ -1727 +1886 @@
 BOOL WINAPI SHLWAPI_335(LPSHELLEXECUTEINFOW lpExecInfo)
 {
-  static BOOL (* WINAPI pfnFunc)(LPSHELLEXECUTEINFOW) = NULL;
-
-  GET_FUNC(shell32, "ShellExecuteExW", FALSE);
-  return pfnFunc(lpExecInfo);
+  GET_FUNC(pShellExecuteExW, shell32, "ShellExecuteExW", FALSE);
+  return pShellExecuteExW(lpExecInfo);
 }
 
@@ -1740 +1897 @@
 DWORD WINAPI SHLWAPI_336(LPSHFILEOPSTRUCTW lpFileOp)
 {
-  static HICON (* WINAPI pfnFunc)(LPSHFILEOPSTRUCTW) = NULL;
-
-  GET_FUNC(shell32, "SHFileOperationW", 0);
-  return pfnFunc(lpFileOp);
+  GET_FUNC(pSHFileOperationW, shell32, "SHFileOperationW", 0);
+  return pSHFileOperationW(lpFileOp);
 }
 
@@ -1754 +1909 @@
                          HICON *phiconSmall, UINT nIcons)
 {
-  static HICON (* WINAPI pfnFunc)(LPCWSTR, INT,HICON *,HICON *, UINT) = NULL;
-
-  GET_FUNC(shell32, "ExtractIconExW", (HICON)0);
-  return pfnFunc(lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
+  GET_FUNC(pExtractIconExW, shell32, "ExtractIconExW", (HICON)0);
+  return pExtractIconExW(lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 }
 
@@ -1764 +1917 @@
  *
  */
-DWORD WINAPI SHLWAPI_342 (
-        LPDWORD  w,   /* [out] location to put HKEY value???   */
-        HKEY     x,   /* [in]  appears to be HKEY_CURRENT_USER */
-        LPVOID y)
-{
-        FIXME("(%p 0x%08x %p)stub\n", w,x,y);
-        *w = (DWORD)x;
-        return /* 0xabba1249 */ 0;
+LONG WINAPI SHInterlockedCompareExchange( PLONG dest, LONG xchg, LONG compare)
+{
+        return InterlockedCompareExchange(dest, xchg, compare);
 }
 
@@ -1788 +1936 @@
 
 /*************************************************************************
- *      @       [SHLWAPI.356]
- */
-DWORD WINAPI SHLWAPI_356 (
-        LPVOID x,
-        LPVOID y,
-        LPVOID z)
-{
-        FIXME("(%p %p %p)stub\n", x,y,z);
-        return 0;
-}
+ *      @       [SHLWAPI.350]
+ *
+ * seems to be late bound call to GetFileVersionInfoSizeW
+ */
+DWORD WINAPI SHLWAPI_350 (
+        LPWSTR x,
+        LPVOID y)
+{
+        DWORD ret;
+
+        GET_FUNC(pGetFileVersionInfoSizeW, version, "GetFileVersionInfoSizeW", 0);
+        ret = pGetFileVersionInfoSizeW(x, y);
+        return 0x208 + ret;
+}
+
+/*************************************************************************
+ *      @       [SHLWAPI.351]
+ *
+ * seems to be late bound call to GetFileVersionInfoW
+ */
+BOOL  WINAPI SHLWAPI_351 (
+        LPWSTR w,   /* [in] path to dll */
+        DWORD  x,   /* [in] parm 2 to GetFileVersionInfoA */
+        DWORD  y,   /* [in] return value from .350 - assume length */
+        LPVOID z)   /* [in/out] buffer (+0x208 sent to GetFileVersionInfoA) */
+{
+    GET_FUNC(pGetFileVersionInfoW, version, "GetFileVersionInfoW", 0);
+#ifdef __WIN32OS2__
+    return pGetFileVersionInfoW(w, x, y-0x208, (LPSTR)z+0x208);
+#else
+    return pGetFileVersionInfoW(w, x, y-0x208, z+0x208);
+#endif
+}
+
+/*************************************************************************
+ *      @       [SHLWAPI.352]
+ *
+ * seems to be late bound call to VerQueryValueW
+ */
+WORD WINAPI SHLWAPI_352 (
+        LPVOID w,   /* [in] buffer from _351 */
+        LPWSTR x,   /* [in]   value to retrieve -
+                              converted and passed to VerQueryValueA as #2 */
+        LPVOID y,   /* [out]  ver buffer - passed to VerQueryValueA as #3 */
+        UINT*  z)   /* [in]   ver length - passed to VerQueryValueA as #4 */
+{
+    GET_FUNC(pVerQueryValueW, version, "VerQueryValueW", 0);
+#ifdef __WIN32OS2__
+    return pVerQueryValueW((LPSTR)w+0x208, x, y, z);
+#else
+    return pVerQueryValueW(w+0x208, x, y, z);
+#endif
+}
+
+/**************************************************************************
+ *      @       [SHLWAPI.356]
+ *
+ *      mbc - this function is undocumented, The parameters are correct and
+ *            the calls to InitializeSecurityDescriptor and
+ *            SetSecurityDescriptorDacl are correct, but apparently some
+ *            apps call this function with all zero parameters.
+ */
+
+DWORD WINAPI SHLWAPI_356(PACL pDacl, PSECURITY_DESCRIPTOR pSD, LPCSTR *str)
+{
+  if(str != 0){
+    *str = 0;
+  }
+
+  if(!pDacl){
+    return 0;
+  }
+
+  if (!InitializeSecurityDescriptor(pSD, 1)) return 0;
+  return SetSecurityDescriptorDacl(pSD, 1, pDacl, 0);
+}
+
 
 /*************************************************************************
@@ -1807 +2022 @@
                         BOOL *pfMustCopy, UINT uFlags)
 {
-  static BOOL (* WINAPI pfnFunc)(LPCWSTR, LPCWSTR, LPCWSTR, BOOL*, UINT) = NULL;
-
-  GET_FUNC(shell32, "SHGetNewLinkInfoW", FALSE);
-  return pfnFunc(pszLinkTo, pszDir, pszName, pfMustCopy, uFlags);
+  GET_FUNC(pSHGetNewLinkInfoW, shell32, "SHGetNewLinkInfoW", FALSE);
+  return pSHGetNewLinkInfoW(pszLinkTo, pszDir, pszName, pfMustCopy, uFlags);
 }
 
@@ -1821 +2034 @@
                          LPVOID arg5, LPVOID arg6)
 {
-  /* FIXME: Correct args */
-  static DWORD (* WINAPI pfnFunc)(LPVOID, LPVOID, LPVOID, LPVOID, LPVOID, LPVOID) = NULL;
-
-  GET_FUNC(shell32, "SHDefExtractIconW", 0);
-  return pfnFunc(arg1, arg2, arg3, arg4, arg5, arg6);
+  GET_FUNC(pSHDefExtractIconW, shell32, "SHDefExtractIconW", 0);
+  return pSHDefExtractIconW(arg1, arg2, arg3, arg4, arg5, arg6);
 }
 
@@ -1847 +2057 @@
                          UINT nIconIndex)
 {
-  static HICON (* WINAPI pfnFunc)(HINSTANCE, LPCWSTR, UINT) = NULL;
-
-  GET_FUNC(shell32, "ExtractIconW", (HICON)0);
-  return pfnFunc(hInstance, lpszExeFileName, nIconIndex);
+  GET_FUNC(pExtractIconW, shell32, "ExtractIconW", (HICON)0);
+  return pExtractIconW(hInstance, lpszExeFileName, nIconIndex);
 }
 
@@ -1868 +2076 @@
  *      @       [SHLWAPI.377]
  *
- * FIXME: Native appears to do DPA_Create and a DPA_InsertPtr for 
+ * FIXME: Native appears to do DPA_Create and a DPA_InsertPtr for
  *        each call here.
  * FIXME: Native shows calls to:
@@ -1931 +2139 @@
 BOOL WINAPI SHLWAPI_389(LPOPENFILENAMEW ofn)
 {
-  static BOOL (* WINAPI pfnFunc)(LPOPENFILENAMEW) = NULL;
-
-  GET_FUNC(comdlg32, "GetSaveFileNameW", FALSE);
-  return pfnFunc(ofn);
+  GET_FUNC(pGetSaveFileNameW, comdlg32, "GetSaveFileNameW", FALSE);
+  return pGetSaveFileNameW(ofn);
 }
 
@@ -1944 +2150 @@
 DWORD WINAPI SHLWAPI_390(LPVOID arg1, LPVOID arg2)
 {
-  /* FIXME: Correct args */
-  static DWORD (* WINAPI pfnFunc)(LPVOID, LPVOID) = NULL;
-
-  GET_FUNC(mpr, "WNetRestoreConnectionW", 0);
-  return pfnFunc(arg1, arg2);
+  GET_FUNC(pWNetRestoreConnectionW, mpr, "WNetRestoreConnectionW", 0);
+  return pWNetRestoreConnectionW(arg1, arg2);
 }
 
@@ -1959 +2162 @@
                          LPVOID arg5)
 {
-  /* FIXME: Correct args */
-  static DWORD (* WINAPI pfnFunc)(LPVOID, LPVOID, LPVOID, LPVOID, LPVOID) = NULL;
-
-  GET_FUNC(mpr, "WNetGetLastErrorW", 0);
-  return pfnFunc(arg1, arg2, arg3, arg4, arg5);
+  GET_FUNC(pWNetGetLastErrorW, mpr, "WNetGetLastErrorW", 0);
+  return pWNetGetLastErrorW(arg1, arg2, arg3, arg4, arg5);
 }
 
@@ -1973 +2173 @@
 BOOL WINAPI SHLWAPI_401(LPPAGESETUPDLGW pagedlg)
 {
-  static BOOL (* WINAPI pfnFunc)(LPPAGESETUPDLGW) = NULL;
-
-  GET_FUNC(comdlg32, "PageSetupDlgW", FALSE);
-  return pfnFunc(pagedlg);
+  GET_FUNC(pPageSetupDlgW, comdlg32, "PageSetupDlgW", FALSE);
+  return pPageSetupDlgW(pagedlg);
 }
 
@@ -1986 +2184 @@
 BOOL WINAPI SHLWAPI_402(LPPRINTDLGW printdlg)
 {
-  static BOOL (* WINAPI pfnFunc)(LPPRINTDLGW) = NULL;
-
-  GET_FUNC(comdlg32, "PrintDlgW", FALSE);
-  return pfnFunc(printdlg);
+  GET_FUNC(pPrintDlgW, comdlg32, "PrintDlgW", FALSE);
+  return pPrintDlgW(printdlg);
 }
 
@@ -1999 +2195 @@
 BOOL WINAPI SHLWAPI_403(LPOPENFILENAMEW ofn)
 {
-  static BOOL (* WINAPI pfnFunc)(LPOPENFILENAMEW) = NULL;
-
-  GET_FUNC(comdlg32, "GetOpenFileNameW", FALSE);
-  return pfnFunc(ofn);
+  GET_FUNC(pGetOpenFileNameW, comdlg32, "GetOpenFileNameW", FALSE);
+  return pGetOpenFileNameW(ofn);
 }
 
@@ -2069 +2263 @@
 
 /*************************************************************************
+ *      @       [SHLWAPI.418]
+ *
+ * Function seems to do FreeLibrary plus other things.
+ *
+ * FIXME native shows the following calls:
+ *   RtlEnterCriticalSection
+ *   LocalFree
+ *   GetProcAddress(Comctl32??, 150L)
+ *   DPA_DeletePtr
+ *   RtlLeaveCriticalSection
+ *  followed by the FreeLibrary.
+ *  The above code may be related to .377 above.
+ */
+BOOL  WINAPI SHLWAPI_418 (HMODULE x)
+{
+        FIXME("(0x%08lx) partial stub\n", (LONG)x);
+        return FreeLibrary(x);
+}
+
+/*************************************************************************
  *      @       [SHLWAPI.431]
  */
@@ -2077 +2291 @@
 }
 
+/*************************************************************************
+ *      @       [SHLWAPI.436]
+ *
+ *  This is really CLSIDFromString which is exported by ole32.dll,
+ *  however the native shlwapi.dll does *not* import ole32. Nor does
+ *  ole32.dll import this ordinal from shlwapi. Therefore we must conclude
+ *  that MS duplicated the code for CLSIDFromString.
+ *
+ *  This is a duplicate (with changes for UNICODE) of CLSIDFromString16
+ *  in dlls/ole32/compobj.c
+ */
+DWORD WINAPI SHLWAPI_436 (LPWSTR idstr, CLSID *id)
+{
+    LPWSTR s = idstr;
+    BYTE *p;
+    INT i;
+    WCHAR table[256];
+
+    if (!s) {
+        memset(s, 0, sizeof(CLSID));
+        return S_OK;
+    }
+    else {  /* validate the CLSID string */
+
+        if (strlenW(s) != 38)
+            return CO_E_CLASSSTRING;
+
+        if ((s[0]!=L'{') || (s[9]!=L'-') || (s[14]!=L'-') || (s[19]!=L'-') || (s[24]!=L'-') || (s[37]!=L'}'))
+            return CO_E_CLASSSTRING;
+
+        for (i=1; i<37; i++)
+            {
+                if ((i == 9)||(i == 14)||(i == 19)||(i == 24)) continue;
+                if (!(((s[i] >= L'0') && (s[i] <= L'9'))  ||
+                      ((s[i] >= L'a') && (s[i] <= L'f'))  ||
+                      ((s[i] >= L'A') && (s[i] <= L'F')))
+                    )
+                    return CO_E_CLASSSTRING;
+            }
+    }
+
+    TRACE("%s -> %p\n", debugstr_w(s), id);
+
+  /* quick lookup table */
+    memset(table, 0, 256*sizeof(WCHAR));
+
+    for (i = 0; i < 10; i++) {
+        table['0' + i] = i;
+    }
+    for (i = 0; i < 6; i++) {
+        table['A' + i] = i+10;
+        table['a' + i] = i+10;
+    }
+
+    /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
+
+    p = (BYTE *) id;
+
+    s++;        /* skip leading brace  */
+    for (i = 0; i < 4; i++) {
+        p[3 - i] = table[*s]<<4 | table[*(s+1)];
+        s += 2;
+    }
+    p += 4;
+    s++;        /* skip - */
+
+    for (i = 0; i < 2; i++) {
+        p[1-i] = table[*s]<<4 | table[*(s+1)];
+        s += 2;
+    }
+    p += 2;
+    s++;        /* skip - */
+
+    for (i = 0; i < 2; i++) {
+        p[1-i] = table[*s]<<4 | table[*(s+1)];
+        s += 2;
+    }
+    p += 2;
+    s++;        /* skip - */
+
+    /* these are just sequential bytes */
+    for (i = 0; i < 2; i++) {
+        *p++ = table[*s]<<4 | table[*(s+1)];
+        s += 2;
+    }
+    s++;        /* skip - */
+
+    for (i = 0; i < 6; i++) {
+        *p++ = table[*s]<<4 | table[*(s+1)];
+        s += 2;
+    }
+
+    return S_OK;
+}
 #ifndef __WIN32OS2__
 /*************************************************************************
@@ -2104 +2412 @@
  * Input HLS values are constrained to the range (0..240).
  */
-VOID WINAPI ColorRGBToHLS(COLORREF drRGB, LPWORD pwHue, 
+VOID WINAPI ColorRGBToHLS(COLORREF drRGB, LPWORD pwHue,
                           LPWORD wLuminance, LPWORD pwSaturation)
 {
@@ -2123 +2431 @@
  *      SHGetInverseCMAP (SHLWAPI.@)
  */
-DWORD WINAPI SHGetInverseCMAP (LPVOID x, DWORD why)
-{
-        FIXME("(%p, %#lx)stub\n", x, why);
+DWORD WINAPI SHGetInverseCMAP (LPDWORD* x, DWORD why)
+{
+    if (why == 4) {
+        FIXME(" - returning bogus address for SHGetInverseCMAP\n");
+        *x = (LPDWORD)0xabba1249;
         return 0;
-}
-
-#ifndef __WIN32OS2__
+    }
+    FIXME("(%p, %#lx)stub\n", x, why);
+    return 0;
+}
+
 /*************************************************************************
  *      SHIsLowMemoryMachine    [SHLWAPI.@]
@@ -2138 +2450 @@
         return 0;
 }
-#endif
+
 /*************************************************************************
  *      GetMenuPosFromID        [SHLWAPI.@]
@@ -2164 +2476 @@
 HRESULT WINAPI _SHGetInstanceExplorer (LPUNKNOWN *lpUnknown)
 {
-  static HRESULT (* WINAPI pfnFunc)(LPUNKNOWN *) = NULL;
-
-  GET_FUNC(shell32, "SHGetInstanceExplorer", E_FAIL);
-  return pfnFunc(lpUnknown);
-}
+  GET_FUNC(pSHGetInstanceExplorer, shell32, "SHGetInstanceExplorer", E_FAIL);
+  return pSHGetInstanceExplorer(lpUnknown);
+}
+
+/*************************************************************************
+ *      SHGetThreadRef  [SHLWAPI.@]
+ *
+ * Retrieves the per-thread object reference set by SHSetThreadRef
+ * "punk" - Address of a pointer to the IUnknown interface. Returns S_OK if
+ *          successful or E_NOINTERFACE otherwise.
+ */
+HRESULT WINAPI SHGetThreadRef (IUnknown ** ppunk)
+{
+    if (SHLWAPI_ThreadRef_index < 0) return E_NOINTERFACE;
+    *ppunk = (IUnknown *)TlsGetValue(SHLWAPI_ThreadRef_index);
+    return S_OK;
+}
+
+/*************************************************************************
+ *      SHSetThreadRef  [SHLWAPI.@]
+ *
+ * Stores a per-thread reference to a COM object
+ * "punk" - Pointer to the IUnknown interface of the object to
+ *          which you want to store a reference. Returns S_OK if successful
+ *          or an OLE error value.
+ */
+HRESULT WINAPI SHSetThreadRef (IUnknown * punk)
+{
+    if (SHLWAPI_ThreadRef_index < 0) return E_NOINTERFACE;
+    TlsSetValue(SHLWAPI_ThreadRef_index, (LPVOID) punk);
+    return S_OK;
+}

trunk/src/shlwapi/ordinal.h

@@ -4 +4 @@
  *
  * Determined by experimentation.
+ *
+ * Copyright 2001 Guy Albertelli
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
@@ -28 +44 @@
 DWORD WINAPI SHLWAPI_2(LPCWSTR x, UNKNOWN_SHLWAPI_2 *y);
 
+/* Macro to get function pointer for a module*/
+#ifdef __WIN32OS2__ 
+#define GET_FUNC(func, module, name, fail) \
+  do { \
+    if (!func) { \
+      if (!SHLWAPI_h##module && !(SHLWAPI_h##module = LoadLibraryA(#module ".dll"))) return fail; \
+      if (!(*(DWORD *)&func = (DWORD)GetProcAddress(SHLWAPI_h##module, name))) return fail; \
+    } \
+  } while (0)
+#else 
+#define GET_FUNC(func, module, name, fail) \
+  do { \
+    if (!func) { \
+      if (!SHLWAPI_h##module && !(SHLWAPI_h##module = LoadLibraryA(#module ".dll"))) return fail; \
+      if (!(func = (void*)GetProcAddress(SHLWAPI_h##module, name))) return fail; \
+    } \
+  } while (0)
+#endif 
+
+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);

trunk/src/shlwapi/ordinal_odin.cpp

@@ -1 @@
-/* $Id: ordinal_odin.cpp,v 1.5 2002-02-06 20:18:27 sandervl Exp $ */
+/* $Id: ordinal_odin.cpp,v 1.6 2002-06-07 08:02:17 sandervl Exp $ */
 
 /*
@@ -55 +55 @@
 #include "shellapi.h"
 #include "shlobj.h"
-#include "wine/undocshell.h"
 
 #include "shlwapi.h"
@@ -65 +64 @@
  *****************************************************************************/
 
-ODINDEBUGCHANNEL(SHLWAPI-ORDINAL)
-
-
-#if 0
-/*****************************************************************************
- * Prototypes                                                                *
- *****************************************************************************/
-
-HANDLE WIN32API SHLWAPI_11(HANDLE, DWORD, DWORD, DWORD, DWORD);
+
+
+
+
+
+/*****************************************************************************
+ * Name      : ???
+ * Purpose   : Looks like a strdup()
+ * Parameters: Unknown (wrong)
+ * Variables :
+ * Result    : Unknown
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
+ *****************************************************************************/
+
+DWORD WIN32API SHLWAPI_12(DWORD arg0, DWORD arg1)
+{
+  dprintf(("not implemented, explorer.exe will trap now"));
+
+  return 0;
+}
+
 
 
@@ -86 +100 @@
  * Status    : UNTESTED STUB
  *
- * Author    : Christoph Bratschi [Wed, 2000/03/29 19:47]
- *****************************************************************************/
-
-// return characters in protocol part
-static INT extractProtocolFromURL(LPSTR  pszURL,
-                                  LPSTR* ppszColon)
-{
-  int i = 0;  // number of characters scanned
-  LPSTR s = pszURL;
-
-  *ppszColon = NULL;
-
-  if (*pszURL == 0)
-    return 0;
-
-
-  // scan through the string for the 1st colon
-  while(*s)
-  {
-    // filter non-printable characters
-    if (*s < ' ')
-      return 0;
-    else
-      if (*s > 0x80)
-        return 0;     
-
-    // Note: actually, the original code has a table with
-    // "forbidden" characters, we don't reproduce this here yet.
-
-    if (*s == ':')
-    {
-       // yes, first colon found!
-       if ( (pszURL[0] == 'U' || pszURL[0] == 'u') &&
-            (pszURL[1] == 'R' || pszURL[1] == 'r') &&
-            (pszURL[2] == 'L' || pszURL[2] == 'l') )
-       {
-         // restart scan!
-         pszURL = s+1;
-         i = 0;
-       }
-       else
-       {
-         // OK, protocol extracted
-         *ppszColon = s;
-         return i;
-       }
-    }
-
-    // skip to next character
-    i++;
-    s++;
-  }  
+ * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
+ *****************************************************************************/
+
+DWORD WIN32API SHLWAPI_17(DWORD arg0, DWORD arg1)
+{
+  dprintf(("not implemented, explorer.exe will trap now"));
 
   return 0;
 }
 
-typedef struct tabProtocolTableEntry
-{
-  LPSTR  pszName; // Note: original is unicode
-  DWORD  ID;
-  DWORD  dwNameLength;
-  DWORD  dwCharacteristic;
-} PROTOCOLTABLEENTRY, *LPPROTOCOLTABLEENTRY;
-
-
-#define PROTOCOL_HTTP 2
-#define PROTOCOL_FILE 9
-
-static PROTOCOLTABLEENTRY tabProtocolTable[] =
-{
-  { "http",        PROTOCOL_HTTP,  4, 0x0a },
-  { "file",        PROTOCOL_FILE,  4, 0x08 },
-  { "ftp",         1,  3, 0x0a },
-  { "https",      11,  5, 0x0a },
-  { "news",        5,  4, 0x0a },
-  { "mailto",      0,  6, 0x01 }, 
-  { "gopher",      3,  6, 0x0a },
-  { "nntp",        6,  4, 0x0a },
-  { "telnet",      7,  6, 0x0a },
-  { "wais",        8,  4, 0x00 },
-  { "mk",         10,  2, 0x04 },
-  { "shell",      12,  5, 0x01 },
-  { "local",      14,  5, 0x00 },
-  { "javascript", 15, 10, 0x05 },
-  { "vbscript",   16,  8, 0x05 },
-  { "snews",      13,  5, 0x0a },
-  { "about",      17,  5, 0x05 },
-  { "res",        18,  3, 0x04 }
-};
-#define END_OF_PROTOCOLTABLE (tabProtocolTable + (sizeof(tabProtocolTable) / sizeof(PROTOCOLTABLEENTRY)) )
-
-
-
-static DWORD getProtocolTableEntry(LPSTR pszProtocol, DWORD dwNameLength)
-{
-  LPPROTOCOLTABLEENTRY lpEntry = tabProtocolTable;
-
-  for(;;)
-  {
-    if (lpEntry->dwNameLength == dwNameLength)
-      if (lstrncmpiA( lpEntry->pszName, pszProtocol, dwNameLength) == 0)
-      {
-        return lpEntry->ID; 
-      }
-
-    lpEntry++;
-
-    // if scanning beyond end of the table,
-    // abort and return null
-    if (lpEntry > END_OF_PROTOCOLTABLE)
-      return 0;
-  }
-}
-
-typedef struct tagProtocolHandlerA
-{
-  DWORD  dwSize;
-  DWORD  dwProtocolNameLength;
-  LPSTR  lpszProtocolName;
-  LPSTR  lpszURL;
-  DWORD  dwURLNameLength;
-  DWORD  ProtocolID;
-} PROTOCOLHANDLERA, *LPPROTOCOLHANDLERA;
-
-typedef struct tagProtocolHandlerW
-{
-  DWORD  dwSize;
-  DWORD  dwProtocolNameLength;
-  LPWSTR lpszProtocolName;
-  LPWSTR lpszURL;
-  DWORD  dwURLNameLength;
-  DWORD  ProtocolID;
-} PROTOCOLHANDLERW, *LPPROTOCOLHANDLERW;
-
-
-ODINFUNCTION2(DWORD,   SHLWAPI_1,
-              LPSTR,   lpszURL,
-              LPPROTOCOLHANDLERA, lpHandler)
-{
-  dprintf(("not implemented"));
-
-  if (NULL == lpszURL)
-    return E_INVALIDARG;
-
-  if (NULL == lpHandler)
-    return E_INVALIDARG;
-
-  if (lpHandler->dwSize != sizeof( PROTOCOLHANDLERA) )
-    return E_INVALIDARG;
-
-  dprintf(("SHLWAPI-SHLWAPI1: URL=%s",
-    lpszURL));
-  
-  LPSTR lpszColon;
-  INT iProtocolLength = extractProtocolFromURL(lpszURL,
-                                               &lpszColon);
-  lpHandler->dwProtocolNameLength = iProtocolLength;
-  if (0 == iProtocolLength)
-    return 0x80041001; // unknown error constant
-
-  lpHandler->lpszProtocolName = lpszURL;
-
-  DWORD ID = getProtocolTableEntry(lpszURL,
-                                   iProtocolLength);
-  lpHandler->ProtocolID = ID;
-  lpHandler->lpszURL    = (LPSTR)(lpszURL + iProtocolLength + 1);
-  
-  if (ID == PROTOCOL_FILE)
-  {
-    // cut off leading slashes as required
-    if (lpHandler->lpszURL[0] == '/' &&
-        lpHandler->lpszURL[1] == '/')
-      lpHandler->lpszURL = lpHandler->lpszURL + 2;
-
-    if (lpHandler->lpszURL[0] == '/')
-      lpHandler->lpszURL = lpHandler->lpszURL + 1;
-  }
-
-  lpHandler->dwURLNameLength = lstrlenA(lpHandler->lpszURL);
-
-  return NO_ERROR;
-}
-#endif
-
-
-
-/*****************************************************************************
- * Name      : SHLWAPI_3
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    : STUB UNTESTED
- *
- * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
- *****************************************************************************/
-
-ODINFUNCTION2(BOOL,  SHLWAPI_3,
-              LPSTR, lpPath,
-              LPSTR, lpFile)
-{
-  dprintf(("not properly implemented"));
-
-  return TRUE;
-
-#if 0
-  if (lpPath == NULL)                return FALSE;
-  if (PathIsUNCServerA(lpPath))      return FALSE;
-  if (PathIsUNCServerShareA(lpPath)) return FALSE;
-
-  if (lpFile == NULL)
-    return PathFileExistsA(lpPath);
-  else
-  {
-    // PathFindExtensionA
-    // lstrlenA
-    // lstrcpyA
-    // PathFileExistsA
-    return FALSE;
-  }
-
-  return FALSE;
-#endif
-}
-
-
-/*****************************************************************************
- * Name      : SHLWAPI_4
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    : STUB UNTESTED
- *
- * Author    : Patrick Haller [Sun, 2000/06/10 04:02]
- *****************************************************************************/
-
-ODINFUNCTION2(BOOL,   SHLWAPI_4,
-              LPWSTR, lpPath,
-              LPWSTR, lpFile)
-{
-  dprintf(("not properly implemented"));
-
-  return TRUE;
-
-#if 0
-  if (lpPath == NULL)                return FALSE;
-  if (PathIsUNCServerW(lpPath))      return FALSE;
-  if (PathIsUNCServerShareW(lpPath)) return FALSE;
-
-  if (lpFile == NULL)
-    return PathFileExtensionW(lpPath);
-  else
-  {
-    // PathFindExtensionW
-    // lstrlenW
-    // lstrcpyW
-    // PathFileExistsW
-    return FALSE;
-  }
-
-  return FALSE;
-#endif
-}
+
 
 
 /*****************************************************************************
  * Name      : ???
- * Purpose   : extended version of PathFindOnPathA
+ * Purpose   : Unknown (used by explorer.exe)
  * Parameters: Unknown (wrong)
  * Variables :
@@ -366 +125 @@
  *****************************************************************************/
 
-ODINFUNCTION3(DWORD, SHLWAPI_5,
-              LPSTR, lpFile,
-              LPSTR, lpDirectories,
-              DWORD, dwUnknown)
-
-{
-  dprintf(("not implemented"));
-
-  return 0;
-}
-
-
-/*****************************************************************************
- * Name      : ???
- * Purpose   : extended version of PathFindOnPathA
- * Parameters: Unknown (wrong)
- * Variables :
- * Result    : Unknown
- * Remark    :
- * Status    : UNTESTED STUB
- *
- * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
- *****************************************************************************/
-
-ODINFUNCTION3(DWORD, SHLWAPI_6,
-              DWORD, arg0,
-              DWORD, arg1,
-              DWORD, arg2)
-
-{
-  dprintf(("not implemented"));
-
-  return 0;
-}
-
-
-
-
-
-/*****************************************************************************
- * Name      : ???
- * Purpose   : Looks like a strdup()
- * Parameters: Unknown (wrong)
- * Variables :
- * Result    : Unknown
- * Remark    :
- * Status    : UNTESTED STUB
- *
- * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
- *****************************************************************************/
-
-ODINFUNCTION2(DWORD,SHLWAPI_12,
-              DWORD,arg0,
-              DWORD,arg1)
-{
-  dprintf(("not implemented, explorer.exe will trap now"));
-
-  return 0;
-}
-
-
-
-
-/*****************************************************************************
- * Name      : ???
- * Purpose   : Unknown (used by explorer.exe)
- * Parameters: Unknown (wrong)
- * Variables :
- * Result    : Unknown
- * Remark    :
- * Status    : UNTESTED STUB
- *
- * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
- *****************************************************************************/
-
-ODINFUNCTION2(DWORD,SHLWAPI_17,
-              DWORD, arg0,
-              DWORD, arg1)
-{
-  dprintf(("not implemented, explorer.exe will trap now"));
-
-  return 0;
-}
-
-
-
-
-/*****************************************************************************
- * Name      : ???
- * Purpose   : Unknown (used by explorer.exe)
- * Parameters: Unknown (wrong)
- * Variables :
- * Result    : Unknown
- * Remark    :
- * Status    : UNTESTED STUB
- *
- * Author    : Patrick Haller [Sun, 2000/06/09 04:47]
- *****************************************************************************/
-
-ODINFUNCTION2(DWORD,SHLWAPI_20,
-              DWORD, arg0,
-              DWORD, arg1)
+DWORD WIN32API SHLWAPI_20(DWORD arg0, DWORD arg1)
 {
   dprintf(("not implemented, explorer.exe will trap now"));
@@ -493 +151 @@
  *****************************************************************************/
 
-ODINFUNCTION2(DWORD,  SHLWAPI_160,
-              DWORD,  arg0,
-              DWORD,  arg1)
+DWORD WIN32API SHLWAPI_160(DWORD arg0, DWORD arg1)
 {
   dprintf(("not implemented.\n"));
@@ -517 +173 @@
  *****************************************************************************/
 
-ODINFUNCTION6(DWORD,   SHLWAPI_185,
-              DWORD, arg0,
-              LPSTR, lpStr1,
-              LPSTR, lpStr2,
-              DWORD, arg3,
-              DWORD, dwDefault,
-              LPSTR, lpstrValueName)
+DWORD WIN32API SHLWAPI_185(DWORD arg0, LPSTR lpStr1, LPSTR lpStr2,
+                           DWORD arg3, DWORD dwDefault, LPSTR lpstrValueName)
 {
   BOOL  fDontShow;
@@ -587 +238 @@
  *****************************************************************************/
 
-ODINFUNCTION6(DWORD,  SHLWAPI_191,
-              HWND,   hwndParent,
-              DWORD,  arg1,
-              DWORD,  arg2,
-              DWORD,  arg3,
-              DWORD,  dwDefault,
-              LPWSTR, lpstrDialog)
+DWORD WIN32API SHLWAPI_191(HWND hwndParent, DWORD arg1, DWORD arg2,
+                           DWORD arg3, DWORD dwDefault, LPWSTR lpstrDialog)
 {
   BOOL rc = SHRegGetBoolUSValueW((LPCWSTR)L"Software\\Microsoft\\Windows\\CurrentVersion"
@@ -644 +290 @@
  *****************************************************************************/
 
-ODINFUNCTION3(BOOL,         SHLWAPI_197,
-              HDC,          hdc,
-              CONST RECT*,  lprc,
-              COLORREF,     crColor)
+BOOL WIN32API SHLWAPI_197(HDC hdc, CONST RECT*lprc, COLORREF crColor)
 {
   COLORREF crOld;
@@ -680 +323 @@
  *****************************************************************************/
 
-ODINFUNCTION5(DWORD, SHLWAPI_243,
-              DWORD, arg0,
-              DWORD, arg1,
-              DWORD, arg2,
-              DWORD, arg3,
-              DWORD, arg4)
+DWORD WIN32API SHLWAPI_243(DWORD arg0, DWORD arg1, DWORD arg2, DWORD arg3,
+                           DWORD arg4)
 {
   dprintf(("not implementes.\n"));
@@ -708 +347 @@
 #define REG_OPTIONS_DATACENTER  "DataCenter"
 
-ODINFUNCTION1(DWORD,  SHLWAPI_437,
-              DWORD,  nFunction)
+DWORD WIN32API SHLWAPI_437(DWORD  nFunction)
 {
   static BOOL           flagProductOptionsInitialized = FALSE;
@@ -868 +506 @@
 
 
-/*****************************************************************************
- * Name      : SHIsLowMemoryMachine
- * Purpose   :
- * Parameters: BOOL fRetest - TRUE if testing shall be repeated
- *                          - FALSE if cached result is to be used
- * Variables :
- * Result    : 0 - machine is not memory-constrained
- *             1 - machine is memory-constrained
- * Remark    : SHLWAPI.584
- * Status    : COMPLETELY IMPLEMENTED ? UNTESTED
- *
- * Author    : Patrick Haller [Mon, 2000/06/11 02:02]
- *****************************************************************************/
-
-ODINFUNCTION1(int,     SHIsLowMemoryMachine,
-              BOOL,    fRetest)
-{
-         MEMORYSTATUS memBuffer;
-  static int          flagIsLowMemoryMachine = -1;
-         ULONG        ulMem;
-
-  // use cached result?
-  if ( (fRetest == TRUE) ||
-       (flagIsLowMemoryMachine == -1) )
-  {
-    // determine and store result
-    GlobalMemoryStatus(&memBuffer);
-    if (VERSION_OsIsUnicode())
-      ulMem = 0x1000000; // unicode operation mode
-    else
-      ulMem = 0x0800000; // ascii operation mode
-
-    // enough memory?
-    if (memBuffer.dwTotalPhys <= ulMem)
-      flagIsLowMemoryMachine = 1;
-    else
-      flagIsLowMemoryMachine = 0;
-  }
-
-  return flagIsLowMemoryMachine;
-}
-

trunk/src/shlwapi/path.c

@@ -1 +1 @@
 /*
  * 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
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
@@ -15 +32 @@
 #define NO_SHLWAPI_STREAM
 #include "shlwapi.h"
-#include "debugtools.h"
+#include "wine/debug.h"
 #include "ordinal.h"
 
-DEFAULT_DEBUG_CHANNEL(shell);
-
-INT __cdecl _wtoi(LPWSTR string);
-
-#define isSlash(x) ((x)=='\\' || (x)=='/')
-/*
-        ########## Combining and Constructing paths ##########
+WINE_DEFAULT_DEBUG_CHANNEL(shell);
+
+/* function pointers for GET_FUNC macro; these need to be global because of gcc bug */
+#ifdef __WIN32OS2__
+static BOOL (* WINAPI pIsNetDrive)(DWORD);
+#else
+static BOOL (WINAPI *pIsNetDrive)(DWORD);
+#endif
+
+/*************************************************************************
+ * PathAppendA    [SHLWAPI.@]
+ *
+ * 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 lpszPath, LPCSTR lpszAppend)
+{
+  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.@]
+ *
+ * See PathAppendA.
+ */
+BOOL WINAPI PathAppendW(LPWSTR lpszPath, LPCWSTR lpszAppend)
+{
+  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.@]
+ *
+ * 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 lpszDest, LPCSTR lpszDir, LPCSTR lpszFile)
+{
+  TRACE("(%p,%s,%s)\n", lpszDest, debugstr_a(lpszDir), debugstr_a(lpszFile));
+
+  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 lpszDest, LPCWSTR lpszDir, LPCWSTR lpszFile)
+{
+  WCHAR szTemp[MAX_PATH];
+  BOOL bUseBoth = FALSE, bStrip = FALSE;
+
+  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.@]
+ *
+ * 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 iLen;
+
+  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.@]
+ *
+ * See PathAddBackslashA.
+ */
+LPWSTR WINAPI PathAddBackslashW( LPWSTR lpszPath )
+{
+  int iLen;
+
+  TRACE("(%s)\n",debugstr_w(lpszPath));
+
+  if (!lpszPath || (iLen = strlenW(lpszPath)) >= MAX_PATH)
+    return NULL;
+
+  if (iLen)
+  {
+    lpszPath += iLen;
+    if (lpszPath[-1] != '\\')
+    {
+      *lpszPath++ = '\\';
+      *lpszPath = '\0';
+    }
+  }
+  return lpszPath;
+}
+
+/*************************************************************************
+ * 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)
+{
+  TRACE("(%p,%d)\n", debugstr_a(lpszPath), drive);
+
+  if (lpszPath && drive >= 0 && drive < 26)
+  {
+    lpszPath[0] = 'A' + drive;
+    lpszPath[1] = ':';
+    lpszPath[2] = '\\';
+    lpszPath[3] = '\0';
+  }
+  return lpszPath;
+}
+
+/*************************************************************************
+ * PathBuildRootW    [SHLWAPI.@]
+ *
+ * See PathBuildRootA.
+ */
+LPWSTR WINAPI PathBuildRootW(LPWSTR lpszPath, int drive)
+{
+  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;
+}
+
+/*************************************************************************
+ * 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;
+
+  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.@]
+ *
+ * See PathFindFileNameA.
+ */
+LPWSTR WINAPI PathFindFileNameW(LPCWSTR lpszPath)
+{
+  LPCWSTR lastSlash = lpszPath;
+
+  TRACE("(%s)\n",debugstr_w(lpszPath));
+
+  while (lpszPath && *lpszPath)
+  {
+    if ((*lpszPath == '\\' || *lpszPath == '/' || *lpszPath == ':') &&
+        lpszPath[1] && lpszPath[1] != '\\' && lpszPath[1] != '/')
+      lastSlash = lpszPath + 1;
+    lpszPath = CharNextW(lpszPath);
+  }
+  return (LPWSTR)lastSlash;
+}
+
+/*************************************************************************
+ * 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
+ *  Spaces in quoted strings are ignored as delimiters.
+ */
+LPSTR WINAPI PathGetArgsA(LPCSTR lpszPath)
+{
+  BOOL bSeenQuote = FALSE;
+
+  TRACE("(%s)\n",debugstr_a(lpszPath));
+
+  if (lpszPath)
+  {
+    while (*lpszPath)
+    {
+      if ((*lpszPath==' ') && !bSeenQuote)
+        return (LPSTR)lpszPath + 1;
+      if (*lpszPath == '"')
+        bSeenQuote = !bSeenQuote;
+      lpszPath = CharNextA(lpszPath);
+    }
+  }
+  return (LPSTR)lpszPath;
+}
+
+/*************************************************************************
+ * PathGetArgsW    [SHLWAPI.@]
+ *
+ * See PathGetArgsA.
+ */
+LPWSTR WINAPI PathGetArgsW(LPCWSTR lpszPath)
+{
+  BOOL bSeenQuote = FALSE;
+
+  TRACE("(%s)\n",debugstr_w(lpszPath));
+
+  if (lpszPath)
+  {
+    while (*lpszPath)
+    {
+      if ((*lpszPath==' ') && !bSeenQuote)
+        return (LPWSTR)lpszPath + 1;
+      if (*lpszPath == '"')
+        bSeenQuote = !bSeenQuote;
+      lpszPath = 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)
+{
+  TRACE ("(%s)\n",debugstr_a(lpszPath));
+
+  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)
+{
+  TRACE ("(%s)\n",debugstr_w(lpszPath));
+
+  if (lpszPath && lpszPath[1] == ':' &&
+      tolowerW(*lpszPath) >= 'a' && tolowerW(*lpszPath) <= 'z')
+    return tolowerW(*lpszPath) - 'a';
+  return -1;
+}
+
+/*************************************************************************
+ * PathRemoveFileSpecA  [SHLWAPI.@]
+ *
+ * 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 lpszFileSpec = lpszPath;
+  BOOL bModified = FALSE;
+
+  TRACE("(%s)\n",debugstr_a(lpszPath));
+
+  if(lpszPath)
+  {
+    /* Skip directory or UNC path */
+    if (*lpszPath == '\\')
+      lpszFileSpec = ++lpszPath;
+    if (*lpszPath == '\\')
+      lpszFileSpec = ++lpszPath;
+
+    while (*lpszPath)
+    {
+      if(*lpszPath == '\\')
+        lpszFileSpec = lpszPath; /* Skip dir */
+      else if(*lpszPath == ':')
+      {
+        lpszFileSpec = ++lpszPath; /* Skip drive */
+        if (*lpszPath == '\\')
+          lpszFileSpec++;
+      }
+      if (!(lpszPath = CharNextA(lpszPath)))
+        break;
+    }
+
+    if (*lpszFileSpec)
+    {
+      *lpszFileSpec = '\0';
+      bModified = TRUE;
+    }
+  }
+  return bModified;
+}
+
+/*************************************************************************
+ * PathRemoveFileSpecW  [SHLWAPI.@]
+ *
+ * See PathRemoveFileSpecA.
+ */
+BOOL WINAPI PathRemoveFileSpecW(LPWSTR lpszPath)
+{
+  LPWSTR lpszFileSpec = lpszPath;
+  BOOL bModified = FALSE;
+
+  TRACE("(%s)\n",debugstr_w(lpszPath));
+
+  if(lpszPath)
+  {
+    /* Skip directory or UNC path */
+    if (*lpszPath == '\\')
+      lpszFileSpec = ++lpszPath;
+    if (*lpszPath == '\\')
+      lpszFileSpec = ++lpszPath;
+
+    while (*lpszPath)
+    {
+      if(*lpszPath == '\\')
+        lpszFileSpec = lpszPath; /* Skip dir */
+      else if(*lpszPath == ':')
+      {
+        lpszFileSpec = ++lpszPath; /* Skip drive */
+        if (*lpszPath == '\\')
+          lpszFileSpec++;
+      }
+      if (!(lpszPath = CharNextW(lpszPath)))
+        break;
+    }
+
+    if (*lpszFileSpec)
+    {
+      *lpszFileSpec = '\0';
+      bModified = TRUE;
+    }
+  }
+  return bModified;
+}
+
+/*************************************************************************
+ * PathStripPathA       [SHLWAPI.@]
+ *
+ * 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)
+{
+  TRACE("(%s)\n", debugstr_a(lpszPath));
+
+  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;
+
+  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", debugstr_a(lpszPath));
+
+  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));
+
+  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",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));
+
+  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)
+{
+  TRACE("(%s)\n", debugstr_a(lpszPath));
+
+  if (lpszPath)
+  {
+    lpszPath = PathFindExtensionA(lpszPath);
+    *lpszPath = '\0';
+  }
+}
+
+/*************************************************************************
+ * PathRemoveExtensionW         [SHLWAPI.@]
+ *
+ * See PathRemoveExtensionA.
 */
-
-/*************************************************************************
- * PathAppendA          [SHLWAPI.@]
- * 
+void WINAPI PathRemoveExtensionW(LPWSTR lpszPath)
+{
+  TRACE("(%s)\n", debugstr_w(lpszPath));
+
+  if (lpszPath)
+  {
+    lpszPath = PathFindExtensionW(lpszPath);
+    *lpszPath = '\0';
+  }
+}
+
+/*************************************************************************
+ * PathRemoveBackslashA [SHLWAPI.@]
+ *
+ * Remove a trailing backslash from a path.
+ *
+ * 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 )
+{
+  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 )
+{
+  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;
+}
+
+/*************************************************************************
+ * PathRemoveBlanksA [SHLWAPI.@]
+ *
+ * Remove Spaces from the start and end of a path.
+ *
+ * PARAMS
+ *  lpszPath [O] Path to strip blanks from
+ *
+ * RETURNS
+ *  Nothing.
+ */
+VOID WINAPI PathRemoveBlanksA(LPSTR lpszPath)
+{
+  TRACE("(%s)\n", debugstr_a(lpszPath));
+
+  if(lpszPath && *lpszPath)
+  {
+    LPSTR start = lpszPath;
+
+    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 lpszPath)
+{
+  TRACE("(%s)\n", debugstr_w(lpszPath));
+
+  if(lpszPath && *lpszPath)
+  {
+    LPWSTR start = lpszPath;
+
+    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
- *  concat path lpszPath2 onto lpszPath1
- *
- * FIXME
- *  the resulting path is also canonicalized
- */
-BOOL WINAPI PathAppendA(
-        LPSTR lpszPath1,
-        LPCSTR lpszPath2) 
-{
-        TRACE("%s %s\n",lpszPath1, lpszPath2);
-        while (lpszPath2[0]=='\\') lpszPath2++;
-        PathCombineA(lpszPath1,lpszPath1,lpszPath2);
-        return TRUE;
-}
-
-/*************************************************************************
- * PathAppendW          [SHLWAPI.@]
- */
-BOOL WINAPI PathAppendW(
-        LPWSTR lpszPath1,
-        LPCWSTR lpszPath2) 
-{
-        TRACE("%s %s\n",debugstr_w(lpszPath1), debugstr_w(lpszPath2));
-        while (lpszPath2[0]=='\\') lpszPath2++;
-        PathCombineW(lpszPath1,lpszPath1,lpszPath2);
-        return TRUE;
-}
-
-/*************************************************************************
- * PathCombineA         [SHLWAPI.@]
- * 
+ *  The path is not changed if it is invalid or has no spaces.
+ */
+VOID WINAPI PathQuoteSpacesA(LPSTR lpszPath)
+{
+  TRACE("(%s)\n", debugstr_a(lpszPath));
+
+  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.
+ */
+VOID WINAPI PathQuoteSpacesW(LPWSTR lpszPath)
+{
+  TRACE("(%s)\n", debugstr_w(lpszPath));
+
+  if(lpszPath && StrChrW(lpszPath,' '))
+  {
+    int iLen = strlenW(lpszPath) + 1;
+
+    if (iLen + 2 < MAX_PATH)
+    {
+      memmove(lpszPath + 1, lpszPath, iLen * sizeof(WCHAR));
+      lpszPath[0] = '"';
+      lpszPath[iLen] = '"';
+      lpszPath[iLen + 1] = '\0';
+    }
+  }
+}
+
+/*************************************************************************
+ * PathUnquoteSpacesA [SHLWAPI.@]
+ *
+ * Remove quotes ("") from around a path, if present.
+ *
+ * PARAMS
+ *  lpszPath [O] Path to strip quotes from
+ *
+ * RETURNS
+ *  Nothing
+ *
  * NOTES
- *  if lpszFile='.' skip it
- *  szDest can be equal to lpszFile. Thats why we use sTemp
- *
- * FIXME
- *  the resulting path is also canonicalized
- */
-LPSTR WINAPI PathCombineA(
-        LPSTR szDest,
-        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;
-        }
-
-        /*  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;
-}
-
-/*************************************************************************
- * PathCombineW          [SHLWAPI.@]
- */
-LPWSTR WINAPI PathCombineW(
-        LPWSTR szDest,
-        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;
-        }
-
-        /*  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;
-}
-
-/*************************************************************************
- * PathAddBackslashA    [SHLWAPI.@]
+ *  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 lpszPath)
+{
+  TRACE("(%s)\n", debugstr_a(lpszPath));
+
+  if (lpszPath && *lpszPath == '"')
+  {
+    DWORD dwLen = strlen(lpszPath) - 1;
+
+    if (lpszPath[dwLen] == '"')
+    {
+      lpszPath[dwLen] = '\0';
+      for (; *lpszPath; lpszPath++)
+        *lpszPath = lpszPath[1];
+    }
+  }
+}
+
+/*************************************************************************
+ * PathUnquoteSpacesW [SHLWAPI.@]
+ *
+ * See PathUnquoteSpacesA.
+ */
+VOID WINAPI PathUnquoteSpacesW(LPWSTR lpszPath)
+{
+  TRACE("(%s)\n", debugstr_w(lpszPath));
+
+  if (lpszPath && *lpszPath == '"')
+  {
+    DWORD dwLen = strlenW(lpszPath) - 1;
+
+    if (lpszPath[dwLen] == '"')
+    {
+      lpszPath[dwLen] = '\0';
+      for (; *lpszPath; lpszPath++)
+        *lpszPath = lpszPath[1];
+    }
+  }
+}
+
+/*************************************************************************
+ * 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
- *     append \ if there is none
- */
-LPSTR WINAPI PathAddBackslashA(LPSTR lpszPath)
-{
-        int len;
-        TRACE("%p->%s\n",lpszPath,lpszPath);
-
-        len = strlen(lpszPath);
-        if (len && lpszPath[len-1]!='\\') 
-        {
-          lpszPath[len]  = '\\';
-          lpszPath[len+1]= 0x00;
-          return lpszPath+len+1;
-        }
-        return lpszPath+len;
-}
-
-/*************************************************************************
- * PathAddBackslashW    [SHLWAPI.@]
- */
-LPWSTR WINAPI PathAddBackslashW(LPWSTR lpszPath)
-{
-        int len;
-        TRACE("%p->%s\n",lpszPath,debugstr_w(lpszPath));
-
-        len = strlenW(lpszPath);
-        if (len && lpszPath[len-1]!=(WCHAR)'\\') 
-        {
-          lpszPath[len]  = (WCHAR)'\\';
-          lpszPath[len+1]= 0x00;
-          return lpszPath+len+1;
-        }
-        return lpszPath+len;
-}
-
-/*************************************************************************
- * PathBuildRootA               [SHLWAPI.@]
- */
-LPSTR WINAPI PathBuildRootA(LPSTR lpszPath, int drive) 
-{
-        TRACE("%p %i\n",lpszPath, drive);
-
-        strcpy(lpszPath,"A:\\");
-        lpszPath[0]+=drive;
-        return lpszPath;
-}
-
-/*************************************************************************
- * PathBuildRootW               [SHLWAPI.@]
- */
-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;
-}
-
-/*
-        Extracting Component Parts
-*/
-
-/*************************************************************************
- * PathFindFileNameA    [SHLWAPI.@]
- */
-LPSTR WINAPI PathFindFileNameA(LPCSTR 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;
-
-}
-
-/*************************************************************************
- * PathFindFileNameW    [SHLWAPI.@]
- */
-LPWSTR WINAPI PathFindFileNameW(LPCWSTR lpszPath)
-{
-        LPCWSTR wslash;
-        wslash = 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;  
-}
-
-/*************************************************************************
- * PathFindExtensionA   [SHLWAPI.@]
+ *  The path has surrounding quotes and spaces removed regardless
+ *  of whether the call succeeds or not.
+ */
+int WINAPI PathParseIconLocationA(LPSTR lpszPath)
+{
+  int iRet = 0;
+  LPSTR lpszComma;
+
+  TRACE("(%s)\n", debugstr_a(lpszPath));
+
+  if (lpszPath)
+  {
+    if ((lpszComma = strchr(lpszPath, ',')))
+    {
+      *lpszComma++ = '\0';
+      iRet = StrToIntA(lpszComma);
+    }
+    PathUnquoteSpacesA(lpszPath);
+    PathRemoveBlanksA(lpszPath);
+  }
+  return iRet;
+}
+
+/*************************************************************************
+ * PathParseIconLocationW  [SHLWAPI.@]
+ *
+ * See PathParseIconLocationA.
+ */
+int WINAPI PathParseIconLocationW(LPWSTR lpszPath)
+{
+  int iRet = 0;
+  LPWSTR lpszComma;
+
+  TRACE("(%s)\n", debugstr_w(lpszPath));
+
+  if (lpszPath)
+  {
+    if ((lpszComma = StrChrW(lpszPath, ',')))
+    {
+      *lpszComma++ = '\0';
+      iRet = StrToIntW(lpszComma);
+    }
+    PathUnquoteSpacesW(lpszPath);
+    PathRemoveBlanksW(lpszPath);
+  }
+  return iRet;
+}
+
+/*************************************************************************
+ * 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 lpszFile, LPCSTR *lppszOtherDirs)
+{
+  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);
+}
+
+/*************************************************************************
+ * 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 PathCompactPathExA(LPSTR lpszDest, LPCSTR lpszPath,
+                               UINT cchMax, DWORD dwFlags)
+{
+  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;
+}
+
+/*************************************************************************
+ * PathCompactPathExW   [SHLWAPI.@]
+ *
+ * See PathCompactPathExA.
+ */
+BOOL WINAPI PathCompactPathExW(LPWSTR lpszDest, LPCWSTR lpszPath,
+                               UINT cchMax, DWORD dwFlags)
+{
+  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;
+}
+
+/*************************************************************************
+ * 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("(%s)\n",debugstr_a(lpszPath));
+
+  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("(%s)\n",debugstr_w(lpszPath));
+
+  if (!lpszPath || !*lpszPath)
+    return TRUE;
+  if (*lpszPath == '\\' || (*lpszPath && lpszPath[1] == ':'))
+    return FALSE;
+  return TRUE;
+}
+
+/*************************************************************************
+ * PathIsRootA          [SHLWAPI.@]
+ *
+ * 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", debugstr_a(lpszPath));
+
+  if (lpszPath && *lpszPath)
+  {
+    if (*lpszPath == '\\')
+    {
+      if (!lpszPath[1])
+        return TRUE; /* \ */
+      else if (lpszPath[1]=='\\')
+      {
+        BOOL bSeenSlash = FALSE;
+        lpszPath += 2;
+
+        /* Check for UNC root path */
+        while (*lpszPath)
+        {
+          if (*lpszPath == '\\')
+          {
+            if (bSeenSlash)
+              return FALSE;
+            bSeenSlash = TRUE;
+          }
+          lpszPath = CharNextA(lpszPath);
+        }
+        return TRUE;
+      }
+    }
+    else if (lpszPath[1] == ':' && lpszPath[2] == '\\' && lpszPath[3] == '\0')
+      return TRUE; /* X:\ */
+  }
+  return FALSE;
+}
+
+/*************************************************************************
+ * PathIsRootW          [SHLWAPI.@]
+ *
+ * See PathIsRootA.
+ */
+BOOL WINAPI PathIsRootW(LPCWSTR lpszPath)
+{
+  TRACE("(%s)\n", debugstr_w(lpszPath));
+
+  if (lpszPath && *lpszPath)
+  {
+    if (*lpszPath == '\\')
+    {
+      if (!lpszPath[1])
+        return TRUE; /* \ */
+      else if (lpszPath[1]=='\\')
+      {
+        BOOL bSeenSlash = FALSE;
+        lpszPath += 2;
+
+        /* Check for UNC root path */
+        while (*lpszPath)
+        {
+          if (*lpszPath == '\\')
+          {
+            if (bSeenSlash)
+              return FALSE;
+            bSeenSlash = TRUE;
+          }
+          lpszPath = 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
- *     returns pointer to last . in last lpszPath component or at \0.
- */
-
-LPSTR WINAPI PathFindExtensionA(LPCSTR lpszPath) 
-{
-        LPCSTR   lastpoint = NULL;
-
-        TRACE("%p %s\n",lpszPath,lpszPath);
-
-        while (*lpszPath) 
-        {
-          if (*lpszPath=='\\'||*lpszPath==' ')
-            lastpoint=NULL;
-          if (*lpszPath=='.')
-            lastpoint=lpszPath;
-          lpszPath = CharNextA(lpszPath);
-        }
-        return (LPSTR)(lastpoint?lastpoint: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.@]
- *
- * NOTES
- *     look for next arg in string. handle "quoted" strings
- *     returns pointer to argument *AFTER* the space. Or to the \0.
- *
- * FIXME
- *     quoting by '\'
- */
-LPSTR WINAPI PathGetArgsA(LPCSTR lpszPath) 
-{
-        BOOL    qflag = FALSE;
-
-        TRACE("%s\n",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;
-}
-
-/*************************************************************************
- * PathGetDriveNumberA  [SHLWAPI.@]
- */
-int WINAPI PathGetDriveNumberA(LPCSTR lpszPath)
-{
-        int chr = tolower(lpszPath[0]);
-        
-        TRACE ("%s\n",debugstr_a(lpszPath));
-
-        if (!lpszPath || lpszPath[1]!=':' || chr < 'a' || chr > 'z') return -1;
-        return tolower(lpszPath[0]) - 'a' ;
-}
-
-/*************************************************************************
- * PathGetDriveNumberW  [SHLWAPI.@]
- */
-int WINAPI PathGetDriveNumberW(LPCWSTR lpszPath)
-{
-        int chr = tolowerW(lpszPath[0]);
-        
-        TRACE ("%s\n",debugstr_w(lpszPath));
-
-        if (!lpszPath || lpszPath[1]!=':' || chr < 'a' || chr > 'z') return -1;
-        return tolowerW(lpszPath[0]) - 'a' ;
-}
-
-/*************************************************************************
- * 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:\"
- */
-BOOL WINAPI PathRemoveFileSpecA(LPSTR lpszPath)
-{
-        LPSTR cutplace = lpszPath;
-        BOOL ret = FALSE;
-        
-        TRACE("%s\n",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 = CharNextA(lpszPath);
-            if (!lpszPath) break;
-          }
-          
-          ret = (*cutplace!='\0');
-          *cutplace = '\0';
-        }
-        return ret;
-}
-
-/*************************************************************************
- * PathRemoveFileSpecW  [SHLWAPI.@]
- */
-BOOL WINAPI PathRemoveFileSpecW(LPWSTR lpszPath)
-{
-        LPWSTR cutplace = lpszPath;
-        BOOL ret = FALSE;
-
-        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;
-}
-
-/*************************************************************************
- * PathStripPathA       [SHLWAPI.@]
- * 
- * NOTES
- *  removes the path from the beginning of a filename
- */
-void WINAPI PathStripPathA(LPSTR lpszPath)
-{
-        LPSTR lpszFileName = PathFindFileNameA(lpszPath);
-
-        TRACE("%s\n", lpszPath);
-
-        if(lpszFileName)
-          RtlMoveMemory(lpszPath, lpszFileName, strlen(lpszFileName)+1); 
-}
-
-/*************************************************************************
- * PathStripPathW       [SHLWAPI.@]
- */
-void WINAPI PathStripPathW(LPWSTR lpszPath)
-{
-        LPWSTR lpszFileName = PathFindFileNameW(lpszPath);
-
-        TRACE("%s\n", debugstr_w(lpszPath));
-        if(lpszFileName)
-          RtlMoveMemory(lpszPath, lpszFileName, (strlenW(lpszFileName)+1)*sizeof(WCHAR)); 
-}
-
-/*************************************************************************
- * PathStripToRootA     [SHLWAPI.@]
- */
-BOOL WINAPI PathStripToRootA(LPSTR lpszPath)
-{
-        TRACE("%s\n", lpszPath);
-
-        if (!lpszPath) return FALSE;
-        while(!PathIsRootA(lpszPath))
-          if (!PathRemoveFileSpecA(lpszPath)) return FALSE;
-        return TRUE;
-}
-
-/*************************************************************************
- * PathStripToRootW     [SHLWAPI.@]
- */
-BOOL WINAPI PathStripToRootW(LPWSTR lpszPath)
-{
-        TRACE("%s\n", debugstr_w(lpszPath));
-
-        if (!lpszPath) return FALSE;
-        while(!PathIsRootW(lpszPath))
-          if (!PathRemoveFileSpecW(lpszPath)) return FALSE;
-        return TRUE;
-}
-
-/*************************************************************************
- * PathRemoveArgsA      [SHLWAPI.@]
- *
- */
-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';
-          }
-        }
-}
-
-/*************************************************************************
- * PathRemoveArgsW      [SHLWAPI.@]
- */
-void WINAPI PathRemoveArgsW(LPWSTR lpszPath)
-{
-        TRACE("%s\n", debugstr_w(lpszPath));
-
-        if(lpszPath)
-        {
-          LPWSTR lpszArgs = PathGetArgsW(lpszPath);
-          if (!*lpszArgs)
-          {
-            LPWSTR lpszLastChar = CharPrevW(lpszPath, lpszArgs);
-            if(*lpszLastChar==' ') *lpszLastChar = '\0';
-          }
-        }
-}
-
-/*************************************************************************
- * PathRemoveExtensionA         [SHLWAPI.@]
- */
-void WINAPI PathRemoveExtensionA(LPSTR lpszPath)
-{
-        LPSTR lpszExtension = PathFindExtensionA(lpszPath);
-
-        TRACE("%s\n", lpszPath);
-
-        if (lpszExtension) *lpszExtension='\0';
-}
-
-/*************************************************************************
- * PathRemoveExtensionW         [SHLWAPI.@]
- */
-void WINAPI PathRemoveExtensionW(LPWSTR lpszPath)
-{
-        LPWSTR lpszExtension = PathFindExtensionW(lpszPath);
-
-        TRACE("%s\n", debugstr_w(lpszPath));
-
-        if (lpszExtension) *lpszExtension='\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.
- *
- * FIXME
- *  "c:\": keep backslash
- */
-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;
-}
-
-/*************************************************************************
- * PathRemoveBackslashW [SHLWAPI.@]
- */
-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;
-}
-
-
-/*
-        Path Manipulations
-*/
-
-/*************************************************************************
- * PathRemoveBlanksA [SHLWAPI.@]
- * 
- * NOTES
- *     remove spaces from beginning and end of passed string
- */
-void WINAPI PathRemoveBlanksA(LPSTR str)
-{
-        LPSTR x = str;
-
-        TRACE("%s\n",str);
-
-        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';
-        }
-}
-
-/*************************************************************************
- * PathRemoveBlanksW [SHLWAPI.@]
- */
-void WINAPI PathRemoveBlanksW(LPWSTR str)
-{
-        LPWSTR x = str;
-
-        TRACE("%s\n",debugstr_w(str));
-
-        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';
-        }
-}
-
-/*************************************************************************
- * PathQuoteSpacesA [SHLWAPI.@]
- * 
- */
-LPSTR WINAPI PathQuoteSpacesA(LPSTR lpszPath)
-{
-        TRACE("%s\n",lpszPath);
-
-        if(StrChrA(lpszPath,' '))
-        {
-          int len = strlen(lpszPath);
-          RtlMoveMemory(lpszPath+1, lpszPath, len);
-          *(lpszPath++) = '"';
-          lpszPath += len;
-          *(lpszPath++) = '"';
-          *(lpszPath) = '\0';
-          return --lpszPath;
-        }
-        return 0;
-}
-
-/*************************************************************************
- * PathQuoteSpacesW [SHLWAPI.@]
- */
-LPWSTR WINAPI PathQuoteSpacesW(LPWSTR 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;
-}
-
-/*************************************************************************
- * PathUnquoteSpacesA [SHLWAPI.@]
- * 
- * NOTES
- *     unquote string (remove ")
- */
-VOID WINAPI PathUnquoteSpacesA(LPSTR str) 
-{
-        DWORD len = strlen(str);
-
-        TRACE("%s\n",str);
-
-        if (*str!='"')
-          return;
-        if (str[len-1]!='"')
-          return;
-        str[len-1]='\0';
-        strcpy(str,str+1);
-        return;
-}
-
-/*************************************************************************
- * PathUnquoteSpacesW [SHLWAPI.@]
- */
-VOID WINAPI PathUnquoteSpacesW(LPWSTR str) 
-{
-        DWORD len = strlenW(str);
-
-        TRACE("%s\n",debugstr_w(str));
-
-        if (*str!='"')
-          return;
-        if (str[len-1]!='"')
-          return;
-        str[len-1]='\0';
-        strcpyW(str,str+1);
-        return;
-}
-
-/*************************************************************************
- * PathParseIconLocationA       [SHLWAPI.@]
- */
-int WINAPI PathParseIconLocationA(LPSTR lpszPath)
-{
-        LPSTR lpstrComma = strchr(lpszPath, ',');
-        int ret = 0;
-        
-        TRACE("%s\n", debugstr_a(lpszPath));
-
-        if (lpstrComma && lpstrComma[1])
-        {
-          lpstrComma[0]='\0';
-          ret = atoi(&lpstrComma[1]);
-        }
-        
-        PathUnquoteSpacesA(lpszPath);
-        return ret;
-}
-
-/*************************************************************************
- * PathParseIconLocationW       [SHLWAPI.@]
- */
-int WINAPI PathParseIconLocationW(LPWSTR lpszPath)
-{
-        LPWSTR lpstrComma = strchrW(lpszPath, ',');
-        int ret = 0;
-        
-        TRACE("%s\n", debugstr_w(lpszPath));
-
-        if (lpstrComma && lpstrComma[1])
-        {
-          lpstrComma[0]='\0';
-          ret = _wtoi(&lpstrComma[1]);
-        }
-        PathUnquoteSpacesW(lpszPath);
-        return ret;
-}
-
-/*
-        ########## cleaning and resolving paths ##########
- */
-
-/*************************************************************************
- * PathFindOnPathA      [SHLWAPI.@]
- */
-BOOL WINAPI PathFindOnPathA(LPSTR sFile, LPCSTR *sOtherDirs)
-{
-        FIXME("%s %p\n",sFile, sOtherDirs);
-        return FALSE;
-}
-
-/*************************************************************************
- * PathFindOnPathW      [SHLWAPI.@]
- */
-BOOL WINAPI PathFindOnPathW(LPWSTR sFile, LPCWSTR *sOtherDirs)
-{
-        FIXME("%s %p\n",debugstr_w(sFile), sOtherDirs);
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathCompactPathExA   [SHLWAPI.@]
- */
-BOOL WINAPI PathCompactPathExA(
-        LPSTR pszOut,
-        LPCSTR pszSrc,
-        UINT cchMax,
-        DWORD dwFlags)
-{
-        FIXME("%p %s 0x%08x 0x%08lx\n", pszOut, pszSrc, cchMax, dwFlags);
-        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.@]
- */
-BOOL WINAPI PathIsRelativeA (LPCSTR lpszPath)
-{
-        TRACE("lpszPath=%s\n",lpszPath);
-
-        return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
-}
-
-/*************************************************************************
- *  PathIsRelativeW     [SHLWAPI.@]
- */
-BOOL WINAPI PathIsRelativeW (LPCWSTR lpszPath)
-{
-        TRACE("lpszPath=%s\n",debugstr_w(lpszPath));
-
-        return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
-}
-
-/*************************************************************************
- * PathIsRootA          [SHLWAPI.@]
- *
- * notes
- *  TRUE if the path points to a root directory
- */
-BOOL WINAPI PathIsRootA(LPCSTR lpszPath)
-{
-        TRACE("%s\n",lpszPath);
-
-        /* X:\ */
-        if (lpszPath[1]==':' && lpszPath[2]=='\\' && lpszPath[3]=='\0')
-          return TRUE;
-
-        /* "\" */
-        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;
-}
-
-/*************************************************************************
- * PathIsRootW          [SHLWAPI.@]
- */
-BOOL WINAPI PathIsRootW(LPCWSTR lpszPath) 
-{
-        TRACE("%s\n",debugstr_w(lpszPath));
-
-        /* X:\ */
-        if (lpszPath[1]==':' && lpszPath[2]=='\\' && lpszPath[3]=='\0')
-          return TRUE;
-
-        /* "\" */
-        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;
-
-}
-
-/*************************************************************************
- * PathIsDirectoryA     [SHLWAPI.@]
+ *  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;
-
-        TRACE("%s\n", debugstr_a(lpszPath));
-
-        dwAttr = GetFileAttributesA(lpszPath);
-        return  (dwAttr != -1) ? dwAttr & FILE_ATTRIBUTE_DIRECTORY : 0;
+  DWORD dwAttr;
+
+  TRACE("(%s)\n", debugstr_a(lpszPath));
+
+  if (!lpszPath || PathIsUNCServerA(lpszPath))
+    return FALSE;
+
+ if (PathIsUNCServerShareA(lpszPath))
+ {
+   FIXME("UNC Server Share not yet supported - FAILING\n");
+   return FALSE;
+ }
+
+  if ((dwAttr = GetFileAttributesA(lpszPath)) == -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));
-
-        dwAttr = GetFileAttributesW(lpszPath);
-        return  (dwAttr != -1) ? dwAttr & FILE_ATTRIBUTE_DIRECTORY : 0;
+  DWORD dwAttr;
+
+  TRACE("(%s)\n", debugstr_w(lpszPath));
+
+  if (!lpszPath || PathIsUNCServerW(lpszPath))
+    return FALSE;
+
+ if (PathIsUNCServerShareW(lpszPath))
+ {
+   FIXME("UNC Server Share not yet supported - FAILING\n");
+   return FALSE;
+ }
+
+  if ((dwAttr = GetFileAttributesW(lpszPath)) == -1)
+    return FALSE;
+  return dwAttr & FILE_ATTRIBUTE_DIRECTORY;
 }
 
 /*************************************************************************
  * PathFileExistsA      [SHLWAPI.@]
- * 
- * NOTES
- *     file_exists(char *fn);
- */
-BOOL WINAPI PathFileExistsA(LPCSTR lpszPath) 
-{
-        TRACE("%s\n",lpszPath);
-        return  (GetFileAttributesA(lpszPath)!=-1);
+ *
+ * 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)
+{
+  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.@]
- */
-BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath) 
-{
-        TRACE("%s\n",debugstr_w(lpszPath));
-        return  (GetFileAttributesW(lpszPath)!=-1);
+ *
+ * See PathFileExistsA
+ */
+BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath)
+{
+  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)
@@ -987 +1593 @@
 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 */
@@ -1001 +1607 @@
           mask = CharNextA(mask);
         }
-        if (!*name) 
+        if (!*name)
         {
           while (*mask=='*') mask++;
@@ -1014 +1620 @@
 static BOOL PathMatchSingleMaskW(LPCWSTR name, LPCWSTR mask)
 {
-        while (*name && *mask && *mask!=';') 
+        while (*name && *mask && *mask!=';')
         {
-          if (*mask=='*') 
+          if (*mask=='*')
           {
-            do 
+            do
             {
               if (PathMatchSingleMaskW(name,mask+1)) return 1;  /* try substrings */
@@ -1028 +1634 @@
           mask = CharNextW(mask);
         }
-        if (!*name) 
+        if (!*name)
         {
           while (*mask=='*') mask++;
@@ -1035 +1641 @@
         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
- */
-BOOL WINAPI PathMatchSpecA(LPCSTR name, LPCSTR mask) 
+ *  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)
 {
         TRACE("%s %s\n",name,mask);
@@ -1047 +1666 @@
         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++;
@@ -1062 +1681 @@
 /*************************************************************************
  * PathMatchSpecW       [SHLWAPI.@]
- */
-BOOL WINAPI PathMatchSpecW(LPCWSTR name, LPCWSTR mask) 
+ *
+ * See PathMatchSpecA.
+ */
+BOOL WINAPI PathMatchSpecW(LPCWSTR name, LPCWSTR mask)
 {
     static const WCHAR stemp[] = { '*','.','*',0 };
@@ -1070 +1691 @@
         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++;
@@ -1086 +1707 @@
  * 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;
-
-        /* usual path */
-        if ( toupper(lpszPath1[0])==toupper(lpszPath2[0]) &&
-             lpszPath1[1]==':' && lpszPath2[1]==':' &&
-             lpszPath1[2]=='\\' && lpszPath2[2]=='\\')
-          return TRUE;
-
-        /* 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;
+  LPCSTR lpszStart;
+  DWORD dwLen;
+
+  TRACE("(%s,%s)\n", debugstr_a(lpszPath1), debugstr_a(lpszPath2));
+
+  if (!lpszPath1 || !lpszPath2 || !(lpszStart = PathSkipRootA(lpszPath1)))
+    return FALSE;
+
+  dwLen = PathCommonPrefixA(lpszPath1, lpszPath2, NULL) + 1;
+  if (lpszStart - lpszPath1 > dwLen)
+    return FALSE; /* Paths not common up to length of the root */
+  return TRUE;
 }
 
 /*************************************************************************
  * 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;
-
-        /* usual path */
-        if ( toupperW(lpszPath1[0])==toupperW(lpszPath2[0]) &&
-             lpszPath1[1]==':' && lpszPath2[1]==':' &&
-             lpszPath1[2]=='\\' && lpszPath2[2]=='\\')
-          return TRUE;
-
-        /* 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;
-}
-
-/*************************************************************************
- * PathIsURLA (SHLWAPI.@)
+  LPCWSTR lpszStart;
+  DWORD dwLen;
+
+  TRACE("(%s,%s)\n", debugstr_w(lpszPath1), debugstr_w(lpszPath2));
+
+  if (!lpszPath1 || !lpszPath2 || !(lpszStart = PathSkipRootW(lpszPath1)))
+    return FALSE;
+
+  dwLen = PathCommonPrefixW(lpszPath1, lpszPath2, NULL) + 1;
+  if (lpszStart - lpszPath1 > dwLen)
+    return FALSE; /* Paths not common up to length of the root */
+  return TRUE;
+}
+
+/*************************************************************************
+ * 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)
@@ -1163 +1776 @@
     base.size = 24;
     res1 = SHLWAPI_1(lpstrPath, &base);
-
-#ifdef __WIN32OS2__  
-    // PH 2002-02-26 Fixes crash on Flask->About
-    // ShellExecute("..\doc\readme.html")
-    if (S_OK != res1)
-      return FALSE;
-#endif
-  
     return (base.fcncde) ? TRUE : FALSE;
-}  
-
-/*************************************************************************
- * PathIsURLW (SHLWAPI.@)
+}
+
+/*************************************************************************
+ * PathIsURLW   [SHLWAPI.@]
  */
 BOOL WINAPI PathIsURLW(LPCWSTR lpstrPath)
@@ -1187 +1792 @@
     base.size = 24;
     res1 = SHLWAPI_2(lpstrPath, &base);
-  
-#ifdef __WIN32OS2__  
-    // PH 2002-02-26 Fixes crash on Flask->About
-    // ShellExecute("..\doc\readme.html")
-    if (S_OK != res1)
+    return (base.fcncde) ? TRUE : FALSE;
+}
+
+/*************************************************************************
+ * 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 PathIsContentTypeA(LPCSTR lpszPath, LPCSTR lpszContentType)
+{
+  LPCSTR szExt;
+  DWORD dwDummy;
+  char szBuff[MAX_PATH];
+
+  TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszContentType));
+
+  if (lpszPath && (szExt = PathFindExtensionA(lpszPath)) && *szExt &&
+      !SHGetValueA(HKEY_CLASSES_ROOT, szExt, "Content Type",
+                   REG_NONE, szBuff, &dwDummy) &&
+      !strcasecmp(lpszContentType, szBuff))
+  {
+    return TRUE;
+  }
+  return FALSE;
+}
+
+/*************************************************************************
+ * PathIsContentTypeW   [SHLWAPI.@]
+ *
+ * See PathIsContentTypeA.
+ */
+BOOL WINAPI PathIsContentTypeW(LPCWSTR lpszPath, LPCWSTR lpszContentType)
+{
+  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;
+}
+
+/*************************************************************************
+ * 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 PathIsFileSpecA(LPCSTR lpszPath)
+{
+  TRACE("(%s)\n", debugstr_a(lpszPath));
+
+  if (!lpszPath)
+    return FALSE;
+
+  while (*lpszPath)
+  {
+    if (*lpszPath == '\\' || *lpszPath == ':')
       return FALSE;
-#endif
-  
-    return (base.fcncde) ? TRUE : FALSE;
-}  
-
-
-/*************************************************************************
- *      PathIsContentTypeA   [SHLWAPI.@]
- */
-BOOL WINAPI PathIsContentTypeA(LPCSTR pszPath, LPCSTR pszContentType)
-{
-        FIXME("%s %s\n", pszPath, pszContentType);
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathIsContentTypeW   [SHLWAPI.@]
- */
-BOOL WINAPI PathIsContentTypeW(LPCWSTR pszPath, LPCWSTR pszContentType)
-{
-        FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszContentType));
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathIsFileSpecA   [SHLWAPI.@]
- */
-BOOL WINAPI PathIsFileSpecA(LPCSTR pszPath)
-{
-        FIXME("%s\n", pszPath);
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathIsFileSpecW   [SHLWAPI.@]
- */
-BOOL WINAPI PathIsFileSpecW(LPCWSTR pszPath)
-{
-        FIXME("%s\n", debugstr_w(pszPath));
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathIsPrefixA   [SHLWAPI.@]
- */
-BOOL WINAPI PathIsPrefixA(LPCSTR pszPrefix, LPCSTR pszPath)
-{
-        FIXME("%s %s\n", pszPrefix, pszPath);
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathIsPrefixW   [SHLWAPI.@]
- */
-BOOL WINAPI PathIsPrefixW(LPCWSTR pszPrefix, LPCWSTR pszPath)
-{
-        FIXME("%s %s\n", debugstr_w(pszPrefix), debugstr_w(pszPath));
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathIsSystemFolderA   [SHLWAPI.@]
- */
-BOOL WINAPI PathIsSystemFolderA(LPCSTR pszPath, DWORD dwAttrb)
-{
-        FIXME("%s 0x%08lx\n", pszPath, dwAttrb);
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathIsSystemFolderW   [SHLWAPI.@]
- */
-BOOL WINAPI PathIsSystemFolderW(LPCWSTR pszPath, DWORD dwAttrb)
-{
-        FIXME("%s 0x%08lx\n", debugstr_w(pszPath), dwAttrb);
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathIsUNCServerA   [SHLWAPI.@]
- */
-BOOL WINAPI PathIsUNCServerA(
-        LPCSTR lpszPath)
-{
-        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;
-}
-
-/*************************************************************************
- *      PathIsUNCServerW   [SHLWAPI.@]
- */
-BOOL WINAPI PathIsUNCServerW(
-        LPCWSTR 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;
-}
-
-/*************************************************************************
- *      PathIsUNCServerShareA   [SHLWAPI.@]
- */
-BOOL WINAPI PathIsUNCServerShareA(
-        LPCSTR lpszPath)
-{
-        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 == 1)
-            return TRUE;
-        }
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathIsUNCServerShareW   [SHLWAPI.@]
- */
-BOOL WINAPI PathIsUNCServerShareW(
-        LPCWSTR 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 == 1)
-            return TRUE;
-        }
-        return FALSE;
+    lpszPath = CharNextA(lpszPath);
+  }
+  return TRUE;
+}
+
+/*************************************************************************
+ * PathIsFileSpecW   [SHLWAPI.@]
+ *
+ * See PathIsFileSpecA.
+ */
+BOOL WINAPI PathIsFileSpecW(LPCWSTR lpszPath)
+{
+  TRACE("(%s)\n", debugstr_w(lpszPath));
+
+  if (!lpszPath)
+    return FALSE;
+
+  while (*lpszPath)
+  {
+    if (*lpszPath == '\\' || *lpszPath == ':')
+      return FALSE;
+    lpszPath = CharNextW(lpszPath);
+  }
+  return TRUE;
+}
+
+/*************************************************************************
+ * 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 PathIsPrefixA (LPCSTR lpszPrefix, LPCSTR lpszPath)
+{
+  TRACE("(%s,%s)\n", debugstr_a(lpszPrefix), debugstr_a(lpszPath));
+
+  if (lpszPrefix && lpszPath &&
+      PathCommonPrefixA(lpszPath, lpszPrefix, NULL) == strlen(lpszPrefix))
+    return TRUE;
+  return FALSE;
+}
+
+/*************************************************************************
+ *  PathIsPrefixW   [SHLWAPI.@]
+ *
+ *  See PathIsPrefixA.
+ */
+BOOL WINAPI PathIsPrefixW(LPCWSTR lpszPrefix, LPCWSTR lpszPath)
+{
+  TRACE("(%s,%s)\n", debugstr_w(lpszPrefix), debugstr_w(lpszPath));
+
+  if (lpszPrefix && lpszPath &&
+      PathCommonPrefixW(lpszPath, lpszPrefix, NULL) == strlenW(lpszPrefix))
+    return TRUE;
+  return FALSE;
+}
+
+/*************************************************************************
+ * 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 PathIsSystemFolderA(LPCSTR lpszPath, DWORD dwAttrib)
+{
+  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;
+}
+
+/*************************************************************************
+ * PathIsSystemFolderW   [SHLWAPI.@]
+ *
+ * See PathIsSystemFolderA.
+ */
+BOOL WINAPI PathIsSystemFolderW(LPCWSTR lpszPath, DWORD dwAttrib)
+{
+  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;
+}
+
+/*************************************************************************
+ * 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 PathIsUNCA(LPCSTR lpszPath)
+{
+  TRACE("(%s)\n",debugstr_a(lpszPath));
+
+  if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'))
+    return TRUE;
+  return FALSE;
+}
+
+/*************************************************************************
+ * PathIsUNCW           [SHLWAPI.@]
+ *
+ * See PathIsUNCA.
+ */
+BOOL WINAPI PathIsUNCW(LPCWSTR lpszPath)
+{
+  TRACE("(%s)\n",debugstr_w(lpszPath));
+
+  if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'))
+    return TRUE;
+  return FALSE;
+}
+
+/*************************************************************************
+ * 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 PathIsUNCServerA(LPCSTR lpszPath)
+{
+  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;
 }
 
@@ -1362 +2140 @@
  * PathCanonicalizeA   [SHLWAPI.@]
  *
- *  FIXME
- *   returnvalue, use CharNext
- */
- 
-BOOL WINAPI PathCanonicalizeA(LPSTR pszBuf, LPCSTR pszPath)
-{
-        int OffsetMin = 0, OffsetSrc = 0, OffsetDst = 0, LenSrc = strlen(pszPath);
-        BOOL bModifyed = FALSE;
-
-        TRACE("%p %s\n", pszBuf, pszPath);
-        
-        pszBuf[OffsetDst]='\0';
-
-        /* 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;
-            } 
+ * 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 lpszBuf, LPCSTR lpszPath)
+{
+  BOOL bRet = FALSE;
+
+  TRACE("(%p,%s)\n", lpszBuf, debugstr_a(lpszPath));
+
+  if (lpszBuf)
+    *lpszBuf = '\0';
+
+  if (!lpszBuf || !lpszPath)
+    SetLastError(ERROR_INVALID_PARAMETER);
+  else
+  {
+    WCHAR szPath[MAX_PATH];
+    WCHAR szBuff[MAX_PATH];
+    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.@]
+ *
+ * See PathCanonicalizeA.
+ */
+BOOL WINAPI PathCanonicalizeW(LPWSTR lpszBuf, LPCWSTR lpszPath)
+{
+  LPWSTR lpszDst = lpszBuf;
+  LPCWSTR lpszSrc = lpszPath;
+
+  TRACE("(%p,%s)\n", lpszBuf, debugstr_w(lpszPath));
+
+  if (lpszBuf)
+    *lpszDst = '\0';
+
+  if (!lpszBuf || !lpszPath)
+  {
+    SetLastError(ERROR_INVALID_PARAMETER);
+    return FALSE;
+  }
+
+  if (!*lpszPath)
+  {
+    *lpszBuf++ = '\\';
+    *lpszBuf = '\0';
+    return TRUE;
+  }
+
+  /* Copy path root */
+  if (*lpszSrc == '\\')
+  {
+    *lpszDst++ = *lpszSrc++;
+  }
+  else if (*lpszSrc && lpszSrc[1] == ':')
+  {
+    /* X:\ */
+    *lpszDst++ = *lpszSrc++;
+    *lpszDst++ = *lpszSrc++;
+    if (*lpszSrc == '\\')
+      *lpszDst++ = *lpszSrc++;
+  }
+
+  /* Canonicalize the rest of the path */
+  while (*lpszSrc)
+  {
+    if (*lpszSrc == '.')
+    {
+      if (lpszSrc[1] == '\\' && (lpszSrc == lpszPath || lpszSrc[-1] == '\\' || lpszSrc[-1] == ':'))
+      {
+        lpszSrc += 2; /* Skip .\ */
+      }
+      else if (lpszSrc[1] == '.' && (lpszDst == lpszBuf || lpszDst[-1] == '\\'))
+      {
+        /* \.. backs up a directory, over the root if it has no \ following X:.
+         * .. is ignored if it would remove a UNC server name or 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", pszBuf, bModifyed);
-        return bModifyed;
-}
-
-
-/*************************************************************************
- * PathCanonicalizeW   [SHLWAPI.@]
- *
- *  FIXME
- *   returnvalue, use CharNext
- */
-BOOL WINAPI PathCanonicalizeW(LPWSTR pszBuf, LPCWSTR pszPath)
-{
-        int OffsetMin = 0, OffsetSrc = 0, OffsetDst = 0, LenSrc = strlenW(pszPath);
-        BOOL bModifyed = FALSE;
-
-        TRACE("%p %s\n", pszBuf, debugstr_w(pszPath));
-        
-        pszBuf[OffsetDst]='\0';
-
-        /* 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;
-            } 
+          while (lpszDst > lpszBuf && *lpszDst != '\\')
+            lpszDst--;
+          if (lpszDst == lpszBuf)
+          {
+            *lpszDst++ = '\\';
+            lpszSrc++;
           }
-        }
-        
-        /* ".\" 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;
+        }
+        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;
 }
 
@@ -1506 +2274 @@
  * 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)
-{
-        LPSTR pos;
-
-        TRACE("%s\n", pszPath);
-
-        if(!pszPath || !*pszPath) return NULL;
-        if(!(pos = StrChrA(pszPath, '\\')))
-          return (LPSTR) pszPath + strlen(pszPath);
-        pos++;
-        if(pos[0] == '\\') pos++;
-        return pos;
+ *  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 lpszSlash;
+
+  TRACE("(%s)\n", debugstr_a(lpszPath));
+
+  if(!lpszPath || !*lpszPath)
+    return NULL;
+
+  if ((lpszSlash = StrChrA(lpszPath, '\\')))
+  {
+    if (lpszSlash[1] == '\\')
+      lpszSlash++;
+    return lpszSlash + 1;
+  }
+  return (LPSTR)lpszPath + strlen(lpszPath);
 }
 
 /*************************************************************************
  * PathFindNextComponentW   [SHLWAPI.@]
- */
-LPWSTR WINAPI PathFindNextComponentW(LPCWSTR pszPath)
-{
-        LPWSTR pos;
-
-        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;
+ *
+ * See PathFindNextComponentA.
+ */
+LPWSTR WINAPI PathFindNextComponentW(LPCWSTR lpszPath)
+{
+  LPWSTR lpszSlash;
+
+  TRACE("(%s)\n", debugstr_w(lpszPath));
+
+  if(!lpszPath || !*lpszPath)
+    return NULL;
+
+  if ((lpszSlash = StrChrW(lpszPath, '\\')))
+  {
+    if (lpszSlash[1] == '\\')
+      lpszSlash++;
+    return lpszSlash + 1;
+  }
+  return (LPWSTR)lpszPath + strlenW(lpszPath);
 }
 
@@ -1552 +2332 @@
  * 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
- */
- 
-BOOL WINAPI PathAddExtensionA(
-        LPSTR  pszPath,
-        LPCSTR pszExtension)
-{
-        if (*pszPath)
-        {
-          if (*(PathFindExtensionA(pszPath))) return FALSE;
-
-          if (!pszExtension || *pszExtension=='\0')
-            strcat(pszPath, "exe");
-          else
-            strcat(pszPath, pszExtension);
-        }
-
-        return TRUE;
-}
-
-/*************************************************************************
- *      PathAddExtensionW   [SHLWAPI.@]
- */
-BOOL WINAPI PathAddExtensionW(
-        LPWSTR  pszPath,
-        LPCWSTR pszExtension)
-{
-        static const WCHAR ext[] = { 'e','x','e',0 };
-
-        if (*pszPath)
-        {
-          if (*(PathFindExtensionW(pszPath))) return FALSE;
-
-          if (!pszExtension || *pszExtension=='\0')
-            strcatW(pszPath, ext);
-          else
-            strcatW(pszPath, pszExtension);
-        }
-        return TRUE;
-
-}
-
-/*************************************************************************
- *      PathMakePrettyA   [SHLWAPI.@]
- */
-BOOL WINAPI PathMakePrettyA(
-        LPSTR lpPath)
-{
-        FIXME("%s\n", lpPath);
-        return TRUE;
-}
-
-/*************************************************************************
- *      PathMakePrettyW   [SHLWAPI.@]
- */
-BOOL WINAPI PathMakePrettyW(
-        LPWSTR lpPath)
-{
-        FIXME("%s\n", debugstr_w(lpPath));
-        return TRUE;
-
-}
-
-/*************************************************************************
- *      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.@]
+ *  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.
+ */
+int WINAPI PathCommonPrefixA(LPCSTR lpszFile1, LPCSTR lpszFile2, LPSTR achPath)
+{
+  int iLen = 0;
+  LPCSTR lpszIter1 = lpszFile1;
+  LPCSTR lpszIter2 = lpszFile2;
+
+  TRACE("(%s,%s,%p)\n", debugstr_a(lpszFile1), debugstr_a(lpszFile2), achPath);
+
+  if (achPath)
+    *achPath = '\0';
+
+  if (!lpszFile1 || !lpszFile2)
+    return 0;
+
+  /* Handle roots first */
+  if (PathIsUNCA(lpszFile1))
+  {
+    if (!PathIsUNCA(lpszFile2))
+      return 0;
+    lpszIter1 += 2;
+    lpszIter2 += 2;
+  }
+  else if (PathIsUNCA(lpszFile2))
+      return 0; /* Know already lpszFile1 is not UNC */
+
+  do
+  {
+    /* Update len */
+    if ((!*lpszIter1 || *lpszIter1 == '\\') &&
+        (!*lpszIter2 || *lpszIter2 == '\\'))
+      iLen = lpszIter1 - lpszFile1; /* Common to this point */
+
+    if (!*lpszIter1 || (tolower(*lpszIter1) != tolower(*lpszIter2)))
+      break; /* Strings differ at this point */
+
+    lpszIter1++;
+    lpszIter2++;
+  } while (1);
+
+  if (iLen == 2)
+    iLen++; /* Feature/Bug compatable with Win32 */
+
+  if (iLen && achPath)
+  {
+    memcpy(achPath,lpszFile1,iLen);
+    achPath[iLen] = '\0';
+  }
+  return iLen;
+}
+
+/*************************************************************************
+ * PathCommonPrefixW   [SHLWAPI.@]
+ *
+ * See PathCommonPrefixA.
+ */
+int WINAPI PathCommonPrefixW(LPCWSTR lpszFile1, LPCWSTR lpszFile2, LPWSTR achPath)
+{
+  int iLen = 0;
+  LPCWSTR lpszIter1 = lpszFile1;
+  LPCWSTR lpszIter2 = lpszFile2;
+
+  TRACE("(%s,%s,%p)\n", debugstr_w(lpszFile1), debugstr_w(lpszFile2), achPath);
+
+  if (achPath)
+    *achPath = '\0';
+
+  if (!lpszFile1 || !lpszFile2)
+    return 0;
+
+  /* Handle roots first */
+  if (PathIsUNCW(lpszFile1))
+  {
+    if (!PathIsUNCW(lpszFile2))
+      return 0;
+    lpszIter1 += 2;
+    lpszIter2 += 2;
+  }
+  else if (PathIsUNCW(lpszFile2))
+      return 0; /* Know already lpszFile1 is not UNC */
+
+  do
+  {
+    /* Update len */
+    if ((!*lpszIter1 || *lpszIter1 == '\\') &&
+        (!*lpszIter2 || *lpszIter2 == '\\'))
+      iLen = lpszIter1 - lpszFile1; /* Common to this point */
+
+    if (!*lpszIter1 || (tolowerW(*lpszIter1) != tolowerW(*lpszIter2)))
+      break; /* Strings differ at this point */
+
+    lpszIter1++;
+    lpszIter2++;
+  } while (1);
+
+  if (iLen == 2)
+    iLen++; /* Feature/Bug compatable with Win32 */
+
+  if (iLen && achPath)
+  {
+    memcpy(achPath,lpszFile1,iLen * sizeof(WCHAR));
+    achPath[iLen] = '\0';
+  }
+  return iLen;
+}
+
+/*************************************************************************
+ * 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 PathCompactPathA(HDC hDC, LPSTR lpszPath, UINT dx)
+{
+  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;
+}
+
+/*************************************************************************
+ * PathCompactPathW   [SHLWAPI.@]
+ *
+ * See PathCompactPathA.
+ */
+BOOL WINAPI PathCompactPathW(HDC hDC, LPWSTR lpszPath, UINT dx)
+{
+  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;
+}
+
+/*************************************************************************
+ * 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;
-}
-
-/*************************************************************************
- *      PathGetCharTypeW   [SHLWAPI.@]
+  return PathGetCharTypeW(ch);
+}
+
+/*************************************************************************
+ * PathGetCharTypeW   [SHLWAPI.@]
+ *
+ * See PathGetCharTypeA.
  */
 UINT WINAPI PathGetCharTypeW(WCHAR ch)
 {
-        FIXME("%c, using ascii version\n", ch);
-        return PathGetCharTypeA(ch);
-}
-
-/*************************************************************************
- *      PathMakeSystemFolderA   [SHLWAPI.@]
- */
-BOOL WINAPI PathMakeSystemFolderA(LPCSTR pszPath)
-{
-        FIXME("%s\n", pszPath);
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathMakeSystemFolderW   [SHLWAPI.@]
- */
-BOOL WINAPI PathMakeSystemFolderW(LPCWSTR pszPath)
-{
-        FIXME("%s\n", debugstr_w(pszPath));
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathRenameExtensionA   [SHLWAPI.@]
- */
-BOOL WINAPI PathRenameExtensionA(LPSTR pszPath, LPCSTR pszExt)
-{
-        LPSTR pszExtension = PathFindExtensionA(pszPath);
-
-        if (!pszExtension) return FALSE;
-        if (pszExtension-pszPath + strlen(pszExt) > MAX_PATH) return FALSE;
-
-        strcpy(pszExtension, pszExt);
-        TRACE("%s\n", pszPath);
-        return TRUE;
-}
-
-/*************************************************************************
- *      PathRenameExtensionW   [SHLWAPI.@]
- */
-BOOL WINAPI PathRenameExtensionW(LPWSTR pszPath, LPCWSTR pszExt)
-{
-        LPWSTR pszExtension = PathFindExtensionW(pszPath);
-
-        if (!pszExtension) return FALSE;
-        if (pszExtension-pszPath + strlenW(pszExt) > MAX_PATH) return FALSE;
-
-        strcpyW(pszExtension, pszExt);
-        TRACE("%s\n", debugstr_w(pszPath));
-        return TRUE;
-}
-
-/*************************************************************************
- *      PathSearchAndQualifyA   [SHLWAPI.@]
- */
-BOOL WINAPI PathSearchAndQualifyA(
-        LPCSTR pszPath,
-        LPSTR pszBuf,
-        UINT cchBuf)
-{
-        FIXME("%s %s 0x%08x\n", pszPath, pszBuf, cchBuf);
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathSearchAndQualifyW   [SHLWAPI.@]
- */
-BOOL WINAPI PathSearchAndQualifyW(
-        LPCWSTR pszPath,
-        LPWSTR pszBuf,
-        UINT cchBuf)
-{
-        FIXME("%s %s 0x%08x\n", debugstr_w(pszPath), debugstr_w(pszBuf), cchBuf);
-        return FALSE;
-}
-
-#ifndef __WIN32OS2__
-/*************************************************************************
- *      PathSkipRootA   [SHLWAPI.@]
- */
-LPSTR WINAPI PathSkipRootA(LPCSTR pszPath)
-{
-        FIXME("%s\n", pszPath);
-        return (LPSTR)pszPath;
-}
-
-/*************************************************************************
- *      PathSkipRootW   [SHLWAPI.@]
- */
-LPWSTR WINAPI PathSkipRootW(LPCWSTR pszPath)
-{
-        FIXME("%s\n", debugstr_w(pszPath));
-        return (LPWSTR)pszPath;
-}
-#endif
-
-/*************************************************************************
- *      PathCreateFromUrlA   [SHLWAPI.@]
- */
-HRESULT WINAPI PathCreateFromUrlA(
-        LPCSTR pszUrl,
-        LPSTR pszPath,
-        LPDWORD pcchPath,
-        DWORD dwFlags)
-{
+  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;
+}
+
+/*************************************************************************
+ * SHLWAPI_UseSystemForSystemFolders
+ *
+ * Internal helper for PathMakeSystemFolderW.
+ */
+static BOOL SHLWAPI_UseSystemForSystemFolders()
+{
+  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;
+}
+
+/*************************************************************************
+ * 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 PathMakeSystemFolderA(LPCSTR lpszPath)
+{
+  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;
+}
+
+/*************************************************************************
+ * PathMakeSystemFolderW   [SHLWAPI.@]
+ *
+ * See PathMakeSystemFolderA.
+ */
+BOOL WINAPI PathMakeSystemFolderW(LPCWSTR lpszPath)
+{
+  DWORD dwDefaultAttr = FILE_ATTRIBUTE_READONLY, dwAttr;
+  WCHAR buff[MAX_PATH];
+
+  TRACE("(%s)\n", debugstr_w(lpszPath));
+
+  if (!lpszPath || !*lpszPath)
+    return FALSE;
+
+  /* If the directory is already a system directory, 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);
+}
+
+/*************************************************************************
+ * 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 PathRenameExtensionA(LPSTR lpszPath, LPCSTR lpszExt)
+{
+  LPSTR lpszExtension;
+
+  TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszExt));
+
+  lpszExtension = PathFindExtensionA(lpszPath);
+
+  if (!lpszExtension || (lpszExtension - lpszPath + strlen(lpszExt) >= MAX_PATH))
+    return FALSE;
+
+  strcpy(lpszExtension, lpszExt);
+  return TRUE;
+}
+
+/*************************************************************************
+ * PathRenameExtensionW   [SHLWAPI.@]
+ *
+ * See PathRenameExtensionA.
+ */
+BOOL WINAPI PathRenameExtensionW(LPWSTR lpszPath, LPCWSTR lpszExt)
+{
+  LPWSTR lpszExtension;
+
+  TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszExt));
+
+  lpszExtension = PathFindExtensionW(lpszPath);
+
+  if (!lpszExtension || (lpszExtension - lpszPath + strlenW(lpszExt) >= MAX_PATH))
+    return FALSE;
+
+  strcpyW(lpszExtension, lpszExt);
+  return TRUE;
+}
+
+/*************************************************************************
+ * PathSearchAndQualifyA   [SHLWAPI.@]
+ *
+ * Unimplemented.
+ *
+ * PARAMS
+ *  lpszPath [I]
+ *  lpszBuf  [O]
+ *  cchBuf   [I] Size of lpszBuf
+ *
+ * RETURNS
+ *  Unknown.
+ */
+BOOL WINAPI PathSearchAndQualifyA(LPCSTR lpszPath, LPSTR lpszBuf, UINT cchBuf)
+{
+  FIXME("(%s,%p,0x%08x)-stub\n", debugstr_a(lpszPath), lpszBuf, cchBuf);
+  return FALSE;
+}
+
+/*************************************************************************
+ * PathSearchAndQualifyW   [SHLWAPI.@]
+ *
+ * See PathSearchAndQualifyA
+ */
+BOOL WINAPI PathSearchAndQualifyW(LPCWSTR lpszPath, LPWSTR lpszBuf, UINT cchBuf)
+{
+  FIXME("(%s,%p,0x%08x)-stub\n", debugstr_w(lpszPath), lpszBuf, cchBuf);
+  return FALSE;
+}
+
+/*************************************************************************
+ * 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.
+ */
+LPSTR WINAPI PathSkipRootA(LPCSTR lpszPath)
+{
+  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;
+}
+
+/*************************************************************************
+ * PathSkipRootW   [SHLWAPI.@]
+ *
+ * See PathSkipRootA.
+ */
+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
@@ -1798 +3052 @@
      *   about  - if match returns E_INVALIDARG
      */
-        FIXME("%s %p %p 0x%08lx\n",
-          pszUrl, pszPath, pcchPath, dwFlags);
-        return E_INVALIDARG;
-}
-
-/*************************************************************************
- *      PathCreateFromUrlW   [SHLWAPI.@]
- */
-HRESULT WINAPI PathCreateFromUrlW(
-        LPCWSTR pszUrl,
-        LPWSTR pszPath,
-        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;
-}
-
-/*************************************************************************
- *      PathRelativePathToA   [SHLWAPI.@]
- */
-BOOL WINAPI PathRelativePathToA(
-        LPSTR pszPath,
-        LPCSTR pszFrom,
-        DWORD dwAttrFrom,
-        LPCSTR pszTo,
-        DWORD dwAttrTo)
-{
-        FIXME("%s %s 0x%08lx %s 0x%08lx\n",
-          pszPath, pszFrom, dwAttrFrom, pszTo, dwAttrTo);
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathRelativePathToW   [SHLWAPI.@]
- */
-BOOL WINAPI PathRelativePathToW(
-        LPWSTR pszPath,
-        LPCWSTR pszFrom,
-        DWORD dwAttrFrom,
-        LPCWSTR pszTo,
-        DWORD dwAttrTo)
-{
-        FIXME("%s %s 0x%08lx %s 0x%08lx\n",
-          debugstr_w(pszPath), debugstr_w(pszFrom), dwAttrFrom, debugstr_w(pszTo), dwAttrTo);
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathUnmakeSystemFolderA   [SHLWAPI.@]
- */
-BOOL WINAPI PathUnmakeSystemFolderA(LPCSTR pszPath)
-{
-        FIXME("%s\n", pszPath);
-        return FALSE;
-}
-
-/*************************************************************************
- *      PathUnmakeSystemFolderW   [SHLWAPI.@]
- */
-BOOL WINAPI PathUnmakeSystemFolderW(LPCWSTR pszPath)
-{
-        FIXME("%s\n", debugstr_w(pszPath));
-        return FALSE;
-}
-
-/*
-        ########## special ##########
-*/
+
+  return S_OK;
+}
+
+/*************************************************************************
+ * PathCreateFromUrlW   [SHLWAPI.@]
+ *
+ * See PathCreateFromUrlA.
+ */
+HRESULT WINAPI PathCreateFromUrlW(LPCWSTR lpszUrl, LPWSTR lpszPath,
+                                  LPDWORD pcchPath, DWORD dwFlags)
+{
+  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.@]
+ *
+ * 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 lpszPath, LPCSTR lpszFrom, DWORD dwAttrFrom,
+                                LPCSTR lpszTo, DWORD dwAttrTo)
+{
+  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.@]
+ *
+ * See PathRelativePathToA.
+ */
+BOOL WINAPI PathRelativePathToW(LPWSTR lpszPath, LPCWSTR lpszFrom, DWORD dwAttrFrom,
+                                LPCWSTR lpszTo, DWORD dwAttrTo)
+{
+  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.@]
+ *
+ * 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 lpszPath)
+{
+  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.@]
+ *
+ * See PathUnmakeSystemFolderA.
+ */
+BOOL WINAPI PathUnmakeSystemFolderW(LPCWSTR lpszPath)
+{
+  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);
+}
+
 
 /*************************************************************************
  * 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
- */
-BOOL WINAPI PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR pszPath) 
-{       TRACE("%x %x %s\n",hDlg, id, pszPath);
-        return SetDlgItemTextA(hDlg, id, pszPath);
+ *  If lpszPath is NULL, a blank string ("") is set (i.e. The previous
+ *  window text is erased).
+ */
+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.@]
- */
-BOOL WINAPI PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR pszPath) 
-{       TRACE("%x %x %s\n",hDlg, id, debugstr_w(pszPath));
-        return SetDlgItemTextW(hDlg, id, pszPath);
-}
+ *
+ * See PathSetDlgItemPathA.
+ */
+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)
+{
+  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(pIsNetDrive, shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
+  return pIsNetDrive(dwDriveNum);
+}
+
+/*************************************************************************
+ * PathIsNetworkPathW [SHLWAPI.@]
+ *
+ * See PathIsNetworkPathA.
+ */
+BOOL WINAPI PathIsNetworkPathW(LPCWSTR lpszPath)
+{
+  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(pIsNetDrive, shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
+  return pIsNetDrive(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';
+      }
+    }
+  }
+}

trunk/src/shlwapi/reg.c

@@ -1 +1 @@
 /*
  * SHLWAPI registry functions
+ *
+ * Copyright 1998 Juergen Schmied
+ * Copyright 2001 Guy Albertelli
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
@@ -11 +28 @@
 #include "winnls.h"
 #include "winreg.h"
-#include "debugtools.h"
+#include "wine/debug.h"
 #define NO_SHLWAPI_STREAM
 #include "shlwapi.h"
 #include "wine/unicode.h"
 
-DEFAULT_DEBUG_CHANNEL(shell);
-
-#ifdef __WIN32OS2__
-typedef DWORD (* WINAPI RegQueryFn)(HKEY,LPCVOID,LPDWORD,LPDWORD,LPBYTE,LPDWORD);
-#else
-typedef DWORD (WINAPI *RegQueryFn)(HKEY,LPCVOID,LPDWORD,LPDWORD,LPBYTE,LPDWORD);
-#endif
+WINE_DEFAULT_DEBUG_CHANNEL(shell);
 
 static const char *lpszContentTypeA = "Content Type";
@@ -82 +93 @@
     LPInternal_HUSKEY ihky;
 
-    TRACE("(%s, 0x%lx, 0x%lx, %p, %s)\n", debugstr_a(Path), 
-          (LONG)AccessType, (LONG)hRelativeUSKey, phNewUSKey, 
+    TRACE("(%s, 0x%lx, 0x%lx, %p, %s)\n", debugstr_a(Path),
+          (LONG)AccessType, (LONG)hRelativeUSKey, phNewUSKey,
           (fIgnoreHKCU) ? "Ignoring HKCU" : "Process HKCU then HKLM");
 
     /* now create the internal version of HUSKEY */
-    ihky = (LPInternal_HUSKEY)HeapAlloc(GetProcessHeap(), 0 , 
+    ihky = (LPInternal_HUSKEY)HeapAlloc(GetProcessHeap(), 0 ,
                                         sizeof(Internal_HUSKEY));
     MultiByteToWideChar(0, 0, Path, -1, ihky->key_string,
@@ -104 +115 @@
     ihky->HKLMkey = 0;
     if (!fIgnoreHKCU) {
-        ret1 = RegOpenKeyExA(openHKCUkey, Path, 
+        ret1 = RegOpenKeyExA(openHKCUkey, Path,
                              0, AccessType, &ihky->HKCUkey);
         /* if successful, then save real starting point */
@@ -110 +121 @@
             ihky->HKCUkey = 0;
     }
-    ret2 = RegOpenKeyExA(openHKLMkey, Path, 
+    ret2 = RegOpenKeyExA(openHKLMkey, Path,
                          0, AccessType, &ihky->HKLMkey);
     if (ret2 != ERROR_SUCCESS)
@@ -149 +160 @@
     LPInternal_HUSKEY ihky;
 
-    TRACE("(%s, 0x%lx, 0x%lx, %p, %s)\n", debugstr_w(Path), 
-          (LONG)AccessType, (LONG)hRelativeUSKey, phNewUSKey, 
+    TRACE("(%s, 0x%lx, 0x%lx, %p, %s)\n", debugstr_w(Path),
+          (LONG)AccessType, (LONG)hRelativeUSKey, phNewUSKey,
           (fIgnoreHKCU) ? "Ignoring HKCU" : "Process HKCU then HKLM");
 
     /* now create the internal version of HUSKEY */
-    ihky = (LPInternal_HUSKEY)HeapAlloc(GetProcessHeap(), 0 , 
+    ihky = (LPInternal_HUSKEY)HeapAlloc(GetProcessHeap(), 0 ,
                                         sizeof(Internal_HUSKEY));
     lstrcpynW(ihky->key_string, Path, sizeof(ihky->key_string));
@@ -170 +181 @@
     ihky->HKLMkey = 0;
     if (!fIgnoreHKCU) {
-        ret1 = RegOpenKeyExW(openHKCUkey, Path, 
+        ret1 = RegOpenKeyExW(openHKCUkey, Path,
                             0, AccessType, &ihky->HKCUkey);
         /* if successful, then save real starting point */
@@ -176 +187 @@
             ihky->HKCUkey = 0;
     }
-    ret2 = RegOpenKeyExW(openHKLMkey, Path, 
+    ret2 = RegOpenKeyExW(openHKLMkey, Path,
                         0, AccessType, &ihky->HKLMkey);
     if (ret2 != ERROR_SUCCESS)
@@ -401 +412 @@
 
         datalen = sizeof(data)-1;
-        if (!(retvalue = SHRegGetUSValueA( pszSubKey, pszValue, &type, 
+        if (!(retvalue = SHRegGetUSValueA( pszSubKey, pszValue, &type,
                                            data, &datalen,
                                            fIgnoreHKCU, 0, 0))) {
@@ -460 +471 @@
 
         datalen = (sizeof(data)-1) * sizeof(WCHAR);
-        if (!(retvalue = SHRegGetUSValueW( pszSubKey, pszValue, &type, 
+        if (!(retvalue = SHRegGetUSValueW( pszSubKey, pszValue, &type,
                                            data, &datalen,
                                            fIgnoreHKCU, 0, 0))) {
@@ -522 +533 @@
                                    pcValues, pcchMaxValueNameLen, 0, 0, 0);
             if ((ret == ERROR_SUCCESS) ||
-                (enumRegFlags == SHREGENUM_HKCU)) 
+                (enumRegFlags == SHREGENUM_HKCU))
                 return ret;
         }
         if (((enumRegFlags == SHREGENUM_HKLM) ||
-             (enumRegFlags == SHREGENUM_DEFAULT)) && 
+             (enumRegFlags == SHREGENUM_DEFAULT)) &&
             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
             return RegQueryInfoKeyA(dokey, 0, 0, 0,
@@ -555 +566 @@
         /* if user wants HKCU, and it exists, then try it */
         if (((enumRegFlags == SHREGENUM_HKCU) ||
-             (enumRegFlags == SHREGENUM_DEFAULT)) && 
+             (enumRegFlags == SHREGENUM_DEFAULT)) &&
             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
             ret = RegQueryInfoKeyW(dokey, 0, 0, 0,
@@ -561 +572 @@
                                    pcValues, pcchMaxValueNameLen, 0, 0, 0);
             if ((ret == ERROR_SUCCESS) ||
-                (enumRegFlags == SHREGENUM_HKCU)) 
+                (enumRegFlags == SHREGENUM_HKCU))
                 return ret;
         }
         if (((enumRegFlags == SHREGENUM_HKLM) ||
-             (enumRegFlags == SHREGENUM_DEFAULT)) && 
+             (enumRegFlags == SHREGENUM_DEFAULT)) &&
             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
             return RegQueryInfoKeyW(dokey, 0, 0, 0,
@@ -591 +602 @@
 
         if (((enumRegFlags == SHREGENUM_HKCU) ||
-             (enumRegFlags == SHREGENUM_DEFAULT)) && 
+             (enumRegFlags == SHREGENUM_DEFAULT)) &&
             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
-            return RegEnumKeyExA(dokey, dwIndex, pszName, pcchValueNameLen, 
+            return RegEnumKeyExA(dokey, dwIndex, pszName, pcchValueNameLen,
                                 0, 0, 0, 0);
         }
 
         if (((enumRegFlags == SHREGENUM_HKLM) ||
-             (enumRegFlags == SHREGENUM_DEFAULT)) && 
+             (enumRegFlags == SHREGENUM_DEFAULT)) &&
             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
             return RegEnumKeyExA(dokey, dwIndex, pszName, pcchValueNameLen,
@@ -624 +635 @@
 
         if (((enumRegFlags == SHREGENUM_HKCU) ||
-             (enumRegFlags == SHREGENUM_DEFAULT)) && 
+             (enumRegFlags == SHREGENUM_DEFAULT)) &&
             (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
             return RegEnumKeyExW(dokey, dwIndex, pszName, pcchValueNameLen,
@@ -646 +657 @@
                                 LPVOID pvData, DWORD cbData, DWORD dwFlags)
 {
-    FIXME("(0x%lx,%s,%ld,%p,%ld,%ld): stub\n",
+    HKEY dokey;
+
+    TRACE("(0x%lx,%s,%ld,%p,%ld,%ld)\n",
           (LONG)hUSKey, debugstr_a(pszValue), dwType, pvData, cbData, dwFlags);
+
+    if ((dwFlags & SHREGSET_FORCE_HKCU) &&
+            (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
+        RegSetValueExA(dokey, pszValue, 0, dwType, pvData, cbData);
+    }
+
+    if ((dwFlags & SHREGSET_FORCE_HKLM) &&
+            (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
+        RegSetValueExA(dokey, pszValue, 0, dwType, pvData, cbData);
+    }
+
+    if (dwFlags & (SHREGSET_FORCE_HKCU | SHREGSET_FORCE_HKLM))
+        return ERROR_SUCCESS;
+
+    FIXME("SHREGSET_HKCU or SHREGSET_HKLM not supported\n");
     return ERROR_SUCCESS;
 }
@@ -657 +685 @@
                                 LPVOID pvData, DWORD cbData, DWORD dwFlags)
 {
-    FIXME("(0x%lx,%s,%ld,%p,%ld,%ld): stub\n",
+    HKEY dokey;
+
+    TRACE("(0x%lx,%s,%ld,%p,%ld,%ld)\n",
           (LONG)hUSKey, debugstr_w(pszValue), dwType, pvData, cbData, dwFlags);
+
+    if ((dwFlags & SHREGSET_FORCE_HKCU) &&
+            (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKCU))) {
+        RegSetValueExW(dokey, pszValue, 0, dwType, pvData, cbData);
+    }
+
+    if ((dwFlags & SHREGSET_FORCE_HKLM) &&
+            (dokey = REG_GetHKEYFromHUSKEY(hUSKey,REG_HKLM))) {
+        RegSetValueExW(dokey, pszValue, 0, dwType, pvData, cbData);
+    }
+
+    if (dwFlags & (SHREGSET_FORCE_HKCU | SHREGSET_FORCE_HKLM))
+        return ERROR_SUCCESS;
+
+    FIXME("SHREGSET_HKCU or SHREGSET_HKLM not supported\n");
     return ERROR_SUCCESS;
 }
@@ -681 +726 @@
                            LPSTR lpszPath, DWORD dwFlags)
 {
-  HKEY hSubKey;
-  DWORD dwType = REG_SZ, dwSize = MAX_PATH, dwRet = ERROR_SUCCESS;
+  DWORD dwSize = MAX_PATH;
 
   TRACE("(hkey=0x%08x,%s,%s,%p,%ld)\n", hKey, debugstr_a(lpszSubKey),
         debugstr_a(lpszValue), lpszPath, dwFlags);
 
-  if (lpszSubKey && *lpszSubKey)
-    dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
-  else
-    hSubKey = hKey;
-
-  if (!dwRet)
-    dwRet = SHQueryValueExA(hSubKey, lpszValue, NULL, &dwType, lpszPath, &dwSize);
-
-  if (hSubKey != hKey)
-    RegCloseKey(hSubKey);
-
-  return dwRet;
+  return SHGetValueA(hKey, lpszSubKey, lpszValue, 0, lpszPath, &dwSize);
 }
 
@@ -709 +742 @@
                            LPWSTR lpszPath, DWORD dwFlags)
 {
-  HKEY hSubKey;
-  DWORD dwType = REG_SZ, dwSize = MAX_PATH, dwRet = ERROR_SUCCESS;
+  DWORD dwSize = MAX_PATH;
 
   TRACE("(hkey=0x%08x,%s,%s,%p,%ld)\n", hKey, debugstr_w(lpszSubKey),
         debugstr_w(lpszValue), lpszPath, dwFlags);
 
-  if (lpszSubKey && *lpszSubKey)
-    dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
-  else
-    hSubKey = hKey;
-
-  if (!dwRet)
-    dwRet = SHQueryValueExW(hSubKey, lpszValue, NULL, &dwType, lpszPath, &dwSize);
-
-  if (hSubKey != hKey)
-    RegCloseKey(hSubKey);
-
-  return dwRet;
+  return SHGetValueW(hKey, lpszSubKey, lpszValue, 0, lpszPath, &dwSize);
 }
 
@@ -751 +772 @@
   char szBuff[MAX_PATH];
 
-  FIXME("(hkey=0x%08x,%s,%s,%p,%ld) - semi-stub",hKey, debugstr_a(lpszSubKey),
+  FIXME("(hkey=0x%08x,%s,%s,%p,%ld) - semi-stub\n",hKey, debugstr_a(lpszSubKey),
         debugstr_a(lpszValue), lpszPath, dwFlags);
 
@@ -772 +793 @@
   WCHAR szBuff[MAX_PATH];
 
-  FIXME("(hkey=0x%08x,%s,%s,%p,%ld) - semi-stub",hKey, debugstr_w(lpszSubKey),
+  FIXME("(hkey=0x%08x,%s,%s,%p,%ld) - semi-stub\n",hKey, debugstr_w(lpszSubKey),
         debugstr_w(lpszValue), lpszPath, dwFlags);
 
@@ -798 +819 @@
  * RETURNS
  *   Success: ERROR_SUCCESS. Output parameters contain the details read.
- *   Failure: An error code from RegOpenKeyExA or RegQueryValueExA.
+ *   Failure: An error code from RegOpenKeyExA or SHQueryValueExA.
  */
 DWORD WINAPI SHGetValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue,
                          LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
 {
-  DWORD dwRet;
-  HKEY hSubKey;
+  DWORD dwRet = 0;
+  HKEY hSubKey = 0;
 
   TRACE("(hkey=0x%08x,%s,%s,%p,%p,%p)\n", hKey, debugstr_a(lpszSubKey),
         debugstr_a(lpszValue), pwType, pvData, pcbData);
 
-  dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_QUERY_VALUE, &hSubKey);
-  if (!dwRet)
+  /*   lpszSubKey can be 0. In this case the value is taken from the
+   *   current key.
+   */
+  if(lpszSubKey)
+    dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_QUERY_VALUE, &hSubKey);
+
+  if (! dwRet)
   {
-    dwRet = RegQueryValueExA(hSubKey, lpszValue, 0, pwType, pvData, pcbData);
-    RegCloseKey(hSubKey);
+    /* SHQueryValueEx expands Environment strings */
+    dwRet = SHQueryValueExA(hSubKey ? hSubKey : hKey, lpszValue, 0, pwType, pvData, pcbData);
+    if (hSubKey) RegCloseKey(hSubKey);
   }
   return dwRet;
@@ -826 +853 @@
                          LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
 {
-  DWORD dwRet;
-  HKEY hSubKey;
+  DWORD dwRet = 0;
+  HKEY hSubKey = 0;
 
   TRACE("(hkey=0x%08x,%s,%s,%p,%p,%p)\n", hKey, debugstr_w(lpszSubKey),
         debugstr_w(lpszValue), pwType, pvData, pcbData);
 
-  dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_QUERY_VALUE, &hSubKey);
-  if (!dwRet)
+  if(lpszSubKey)
+    dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_QUERY_VALUE, &hSubKey);
+
+  if (! dwRet)
   {
-    dwRet = RegQueryValueExW(hSubKey, lpszValue, 0, pwType, pvData, pcbData);
-    RegCloseKey(hSubKey);
+    dwRet = SHQueryValueExW(hSubKey ? hSubKey : hKey, lpszValue, 0, pwType, pvData, pcbData);
+    if (hSubKey) RegCloseKey(hSubKey);
   }
   return dwRet;
@@ -944 +973 @@
 }
 
-/*************************************************************************
- * SHQueryValueExAW
- *
- * Internal implementation of SHQueryValueExA/SHQueryValueExW.
- */
-static DWORD WINAPI SHQueryValueExAW(RegQueryFn pfn,
-                                     HKEY hKey, LPCVOID lpszValue,
-                                     LPDWORD lpReserved, LPDWORD pwType,
-                                     LPBYTE pvData, LPDWORD pcbData)
-{
+/*
   DWORD dwRet, dwType, dwDataLen;
 
-  if (pcbData)
-    dwDataLen = *pcbData;
-
-  dwRet = pfn(hKey, lpszValue, lpReserved, &dwType, pvData, &dwDataLen);
+  FIXME("(hkey=0x%08x,%s,%p,%p,%p,%p=%ld)\n", hKey, debugstr_a(lpszValue),
+        lpReserved, pwType, pvData, pcbData, pcbData ? *pcbData : 0);
+
+  if (pcbData) dwDataLen = *pcbData;
+
+  dwRet = RegQueryValueExA(hKey, lpszValue, lpReserved, &dwType, pvData, &dwDataLen);
   if (!dwRet)
   {
     if (dwType == REG_EXPAND_SZ)
     {
-      /* Expand type REG_EXPAND_SZ into REG_SZ */
       LPSTR szExpand;
       LPBYTE pData = pvData;
@@ -970 +991 @@
       if (!pData)
       {
-        /* Create a buffer to hold the data, to get the size */
-        if (!pcbData ||
-            !(pData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *pcbData)))
+        if (!pcbData || !(pData = (LPBYTE) LocalAlloc(GMEM_ZEROINIT, *pcbData)))
           return ERROR_OUTOFMEMORY;
-        /* Read the data in to the buffer */
-        if ((dwRet = pfn(hKey, lpszValue, lpReserved, &dwType,
-                         pData, &dwDataLen)))
+
+        if ((dwRet = RegQueryValueExA (hKey, lpszValue, lpReserved, &dwType, pData, &dwDataLen)))
           return dwRet;
       }
@@ -982 +1000 @@
       if (!pcbData && pData != pvData)
       {
-        /* Note: In this case the caller will crash under Win32 */
-        WARN("Invalid pcbData would crash under Win32!");
+        WARN("Invalid pcbData would crash under Win32!\n");
         return ERROR_OUTOFMEMORY;
       }
 
-      szExpand = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *pcbData);
+      szExpand = (LPBYTE) LocalAlloc(GMEM_ZEROINIT, *pcbData);
       if (!szExpand)
       {
-        if (pData != pvData)
-          HeapFree(GetProcessHeap(), 0, pData);
+        if ( pData != pvData ) LocalFree((HLOCAL)pData);
         return ERROR_OUTOFMEMORY;
       }
-      if ((ExpandEnvironmentStringsA(pvData, szExpand, *pcbData) <= 0))
+      if ((ExpandEnvironmentStringsA(pvData, szExpand, *pcbData) > 0))
       {
         dwDataLen = strlen(szExpand) + 1;
@@ -1001 +1017 @@
       else
       {
-        if (pData != pvData)
-          HeapFree(GetProcessHeap(), 0, pData);
-        HeapFree(GetProcessHeap(), 0, szExpand);
+        if ( pData != pvData ) LocalFree((HLOCAL)pData);
+        LocalFree((HLOCAL)szExpand);
         return GetLastError();
       }
-      if (pData != pvData)
-        HeapFree(GetProcessHeap(), 0, pData);
-      HeapFree(GetProcessHeap(), 0, szExpand);
+      if (pData != pvData) LocalFree((HLOCAL)pData);
+      LocalFree((HLOCAL)szExpand);
       dwType = REG_SZ;
     }
     if (dwType == REG_SZ && pvData && pcbData && dwDataLen >= *pcbData)
     {
-      /* String type too long: truncate it */
-      pvData[*pcbData] = '\0';
+      ((LPBYTE) pvData)[*pcbData] = '\0';
     }
   }
-  /* Update the type and data size if the caller wanted them */
-  if (pwType)
-    *pwType = dwType;
-  if (pcbData)
-    *pcbData  = dwDataLen;
+  if ( pwType ) *pwType = dwType;
+  if ( pcbData ) *pcbData = dwDataLen;
   return dwRet;
-}
+*/
 
 /*************************************************************************
@@ -1032 +1042 @@
  * PARAMS
  *   hKey       [I] Handle to registry key
- *   lpszValue  [I] Name of value to delete
+ *   lpszValue  [I] Name of value to query
  *   lpReserved [O] Reserved for future use; must be NULL
  *   pwType     [O] Optional pointer updated with the values type
@@ -1053 +1063 @@
  *   the buffer given to store it.
  */
-DWORD WINAPI SHQueryValueExA(HKEY hKey, LPCSTR lpszValue,
-                             LPDWORD lpReserved, LPDWORD pwType,
-                             LPVOID pvData, LPDWORD pcbData)
-{
+DWORD WINAPI SHQueryValueExA( HKEY hKey, LPCSTR lpszValue,
+                              LPDWORD lpReserved, LPDWORD pwType,
+                              LPVOID pvData, LPDWORD pcbData)
+{
+  DWORD dwRet, dwType, dwUnExpDataLen = 0, dwExpDataLen;
+
   TRACE("(hkey=0x%08x,%s,%p,%p,%p,%p=%ld)\n", hKey, debugstr_a(lpszValue),
         lpReserved, pwType, pvData, pcbData, pcbData ? *pcbData : 0);
 
-  return SHQueryValueExAW((RegQueryFn)RegQueryValueExA, hKey, lpszValue,
-                          lpReserved, pwType, pvData, pcbData);
-}
+  if (pcbData) dwUnExpDataLen = *pcbData;
+
+  dwRet = RegQueryValueExA(hKey, lpszValue, lpReserved, &dwType, pvData, &dwUnExpDataLen);
+
+  if (pcbData && (dwType == REG_EXPAND_SZ))
+  {
+    DWORD nBytesToAlloc;
+
+    /* Expand type REG_EXPAND_SZ into REG_SZ */
+    LPSTR szData;
+
+    /* If the caller didn't supply a buffer or the buffer is to small we have
+     * to allocate our own
+     */
+    if ((!pvData) || (dwRet == ERROR_MORE_DATA) )
+    {
+      char cNull = '\0';
+      nBytesToAlloc = (!pvData || (dwRet == ERROR_MORE_DATA)) ? dwUnExpDataLen : *pcbData;
+
+      szData = (LPSTR) LocalAlloc(GMEM_ZEROINIT, nBytesToAlloc);
+      RegQueryValueExA (hKey, lpszValue, lpReserved, NULL, (LPBYTE)szData, &nBytesToAlloc);
+      dwExpDataLen = ExpandEnvironmentStringsA(szData, &cNull, 1);
+      dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
+      LocalFree((HLOCAL) szData);
+    }
+    else
+    {
+      nBytesToAlloc = lstrlenA(pvData) * sizeof (CHAR);
+      szData = (LPSTR) LocalAlloc(GMEM_ZEROINIT, nBytesToAlloc + 1);
+      lstrcpyA(szData, pvData);
+      dwExpDataLen = ExpandEnvironmentStringsA(szData, pvData, *pcbData / sizeof(CHAR));
+      if (dwExpDataLen > *pcbData) dwRet = ERROR_MORE_DATA;
+      dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
+      LocalFree((HLOCAL) szData);
+    }
+  }
+
+  /* Update the type and data size if the caller wanted them */
+  if ( dwType == REG_EXPAND_SZ ) dwType = REG_SZ;
+  if ( pwType ) *pwType = dwType;
+  if ( pcbData ) *pcbData = dwUnExpDataLen;
+  return dwRet;
+}
+
 
 /*************************************************************************
@@ -1073 +1126 @@
                              LPVOID pvData, LPDWORD pcbData)
 {
+  DWORD dwRet, dwType, dwUnExpDataLen = 0, dwExpDataLen;
+
   TRACE("(hkey=0x%08x,%s,%p,%p,%p,%p=%ld)\n", hKey, debugstr_w(lpszValue),
         lpReserved, pwType, pvData, pcbData, pcbData ? *pcbData : 0);
 
-  return SHQueryValueExAW((RegQueryFn)RegQueryValueExW, hKey, lpszValue,
-                          lpReserved, pwType, pvData, pcbData);
+  if (pcbData) dwUnExpDataLen = *pcbData;
+
+  dwRet = RegQueryValueExW(hKey, lpszValue, lpReserved, &dwType, pvData, &dwUnExpDataLen);
+
+  if (pcbData && (dwType == REG_EXPAND_SZ))
+  {
+    DWORD nBytesToAlloc;
+
+    /* Expand type REG_EXPAND_SZ into REG_SZ */
+    LPWSTR szData;
+
+    /* If the caller didn't supply a buffer or the buffer is to small we have
+     * to allocate our own
+     */
+    if ((!pvData) || (dwRet == ERROR_MORE_DATA) )
+    {
+      WCHAR cNull = '\0';
+      nBytesToAlloc = (!pvData || (dwRet == ERROR_MORE_DATA)) ? dwUnExpDataLen : *pcbData;
+
+      szData = (LPWSTR) LocalAlloc(GMEM_ZEROINIT, nBytesToAlloc);
+      RegQueryValueExW (hKey, lpszValue, lpReserved, NULL, (LPBYTE)szData, &nBytesToAlloc);
+      dwExpDataLen = ExpandEnvironmentStringsW(szData, &cNull, 1);
+      dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
+      LocalFree((HLOCAL) szData);
+    }
+    else
+    {
+      nBytesToAlloc = lstrlenW(pvData) * sizeof(WCHAR);
+      szData = (LPWSTR) LocalAlloc(GMEM_ZEROINIT, nBytesToAlloc + 1);
+      lstrcpyW(szData, pvData);
+      dwExpDataLen = ExpandEnvironmentStringsW(szData, pvData, *pcbData/sizeof(WCHAR) );
+      if (dwExpDataLen > *pcbData) dwRet = ERROR_MORE_DATA;
+      dwUnExpDataLen = max(nBytesToAlloc, dwExpDataLen);
+      LocalFree((HLOCAL) szData);
+    }
+  }
+
+  /* Update the type and data size if the caller wanted them */
+  if ( dwType == REG_EXPAND_SZ ) dwType = REG_SZ;
+  if ( pwType ) *pwType = dwType;
+  if ( pcbData ) *pcbData = dwUnExpDataLen;
+  return dwRet;
 }
 
@@ -1276 +1371 @@
   DWORD dwKeyCount = 0, dwValueCount = 0, dwRet;
 
-  TRACE("(hkey=0x%08x,%s)", hKey, debugstr_a(lpszSubKey));
+  TRACE("(hkey=0x%08x,%s)\n", hKey, debugstr_a(lpszSubKey));
 
   dwRet = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
@@ -1305 +1400 @@
   DWORD dwKeyCount = 0, dwValueCount = 0, dwRet;
 
-  TRACE("(hkey=0x%08x,%s)", hKey, debugstr_w(lpszSubKey));
+  TRACE("(hkey=0x%08x,%s)\n", hKey, debugstr_w(lpszSubKey));
 
   dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
@@ -1502 +1597 @@
   if (!lpszValue)
   {
-    WARN("Invalid lpszValue would crash under Win32!");
+    WARN("Invalid lpszValue would crash under Win32!\n");
     return FALSE;
   }
@@ -1522 +1617 @@
   if (!lpszValue)
   {
-    WARN("Invalid lpszValue would crash under Win32!");
+    WARN("Invalid lpszValue would crash under Win32!\n");
     return FALSE;
   }

trunk/src/shlwapi/regstream.c

@@ -1 +1 @@
 /*
  *      SHRegOpenStream
+ *
+ * Copyright 1999 Juergen Schmied
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
-#ifdef __WIN32OS2__
-#define SHLWAPI_STREAM
-#endif
+
 #include <string.h>
 
@@ -12 +26 @@
 #include "shlobj.h"
 
-#include "debugtools.h"
-
-DEFAULT_DEBUG_CHANNEL(shell);
-
-typedef struct 
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(shell);
+
+typedef struct
 {       ICOM_VFIELD(IStream);
         DWORD           ref;
@@ -34 +48 @@
         ISHRegStream*   rstr;
         DWORD           dwType;
-        
+
         rstr = (ISHRegStream*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ISHRegStream));
 
@@ -43 +57 @@
         {
           if (!(RegQueryValueExA(rstr->hKey, pszValue,0,0,0,&(rstr->dwLength))))
-          { 
+          {
             /* read the binary data into the buffer */
             if((rstr->pbBuffer = HeapAlloc(GetProcessHeap(),0,rstr->dwLength)))
@@ -71 +85 @@
         ISHRegStream*   rstr;
         DWORD           dwType;
-        
+
         rstr = (ISHRegStream*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ISHRegStream));
 
@@ -80 +94 @@
         {
           if (!(RegQueryValueExW(rstr->hKey, pszValue,0,0,0,&(rstr->dwLength))))
-          { 
+          {
             /* read the binary data into the buffer */
             if((rstr->pbBuffer = HeapAlloc(GetProcessHeap(),0,rstr->dwLength)))
@@ -113 +127 @@
 
         if(IsEqualIID(riid, &IID_IUnknown))     /*IUnknown*/
-        { *ppvObj = This; 
+        { *ppvObj = This;
         }
         else if(IsEqualIID(riid, &IID_IStream)) /*IStream*/
         { *ppvObj = This;
-        }   
+        }
 
         if(*ppvObj)
-        { 
-          IStream_AddRef((IStream*)*ppvObj);      
+        {
+          IStream_AddRef((IStream*)*ppvObj);
           TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
           return S_OK;
@@ -150 +164 @@
         TRACE("(%p)->()\n",This);
 
-        if (!--(This->ref)) 
+        if (!--(This->ref))
         { TRACE(" destroying SHReg IStream (%p)\n",This);
 
@@ -170 +184 @@
 
         DWORD dwBytesToRead, dwBytesLeft;
-        
+
         TRACE("(%p)->(%p,0x%08lx,%p)\n",This, pv, cb, pcbRead);
-        
+
         if ( !pv )
           return STG_E_INVALIDPOINTER;
-          
+
         dwBytesLeft = This->dwLength - This->dwPos;
 
         if ( 0 >= dwBytesLeft )                                         /* end of buffer */
           return S_FALSE;
-        
+
         dwBytesToRead = ( cb > dwBytesLeft) ? dwBytesLeft : cb;
 
         memmove ( pv, (This->pbBuffer) + (This->dwPos), dwBytesToRead);
-        
+
         This->dwPos += dwBytesToRead;                                   /* adjust pointer */
 
@@ -273 +287 @@
 }
 
-static struct ICOM_VTABLE(IStream) rstvt = 
-{       
+static struct ICOM_VTABLE(IStream) rstvt =
+{
         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
         IStream_fnQueryInterface,
@@ -290 +304 @@
         IStream_fnStat,
         IStream_fnClone
-        
+
 };
 

trunk/src/shlwapi/shlwapi.def

@@ -1 @@
-; $Id: shlwapi.def,v 1.29 2002-02-13 16:15:07 sandervl Exp $
+; $Id: shlwapi.def,v 1.30 2002-06-07 08:02:19 sandervl Exp $
 
 ; updated export ordinals to NT4 SP6 version of SHLWAPI.DLL
@@ -34 +34 @@
                              _SHLWAPI_8@8                         @8  NONAME
                              _SHLWAPI_9@4                         @9  NONAME
-                             _SHLWAPI_10@8                        @10 NONAME
-
+                             
+                             _SHLWAPI_10@8                        @10 NONAME                             
                              _SHLWAPI_11@20                       @11 NONAME
                              _SHLWAPI_12@8                        @12 NONAME
@@ -45 +45 @@
                              _SHLWAPI_18@8                        @18 NONAME
                              _SHLWAPI_19@4                        @19 NONAME
-
+                             
                              _SHLWAPI_20@8                        @20 NONAME
                              _SHLWAPI_21@8                        @21 NONAME
@@ -77 +77 @@
                              _CreateAcceleratorTableW@8           @47 NONAME
                              _CreateDCW@16                        @48 NONAME
-                             _CreateDialogParamW@20               @49 NONAME ; @@@PH imcomplete
+                             _CreateDialogParamA@20               @49 NONAME
 
                              _CreateDirectoryW@8                  @50 NONAME
@@ -194 +194 @@
                              _SHLWAPI_153@12                      @153 NONAME
                              _SHLWAPI_154@12                      @154 NONAME
-;;;;_SHLWAPI_155@??                      @155 NONAME
+                             _SHLWAPI_155@8                       @155 NONAME
                              _SHLWAPI_156@8                       @156 NONAME
                              _SHLWAPI_158@8                       @158 NONAME
@@ -209 +209 @@
                              _SHLWAPI_172@8                       @172 NONAME
                              _SHLWAPI_174@8                       @174 NONAME
+                             _SHLWAPI_175@8                       @175 NONAME
                              _SHLWAPI_176@16                      @176 NONAME
 
@@ -224 +225 @@
                              _SHLWAPI_206@24                      @206 NONAME
                              _SHLWAPI_208@20                      @208 NONAME
-
+                             _SHLWAPI_209@4                       @209 NONAME
+                             
                              _SHLWAPI_210@12                      @210 NONAME
                              _SHLWAPI_211@8                       @211 NONAME
@@ -241 +243 @@
 
                              _SHLWAPI_240@16                      @240 NONAME
-;;PH                             _SHLWAPI_241@0                       @241 NONAME
-                             _PathRemoveArgsA@4                   @241 NONAME
+                             _SHLWAPI_241@0                       @241 NONAME
                              _SHLWAPI_243@20                      @243 NONAME
 
-;   AssocCreate            = _AssocCreate@20                      @253 ;by name
-;   AssocQueryKeyA         = _AssocQueryKeyA@20                   @254 ;by name
-;   AssocQueryKeyW         = _AssocQueryKeyW@20                   @255 ;by name
+;    AssocCreate            = _AssocCreate@20                      @253 ;by name
+;    AssocQueryKeyA         = _AssocQueryKeyA@20                   @254 ;by name
+;    AssocQueryKeyW         = _AssocQueryKeyW@20                   @255 ;by name
 
                              _SHLWAPI_266@16                      @266 NONAME
@@ -257 +258 @@
 
                              _SHLWAPI_289@12                      @289 NONAME
-;;                             _SHLWAPI_284@20                      @294 NONAME
+                             _SHLWAPI_294@20                      @294 NONAME
                              _WritePrivateProfileStringW@16       @298 NONAME
 
@@ -270 +271 @@
                              _IsBadStringPtrW@8                   @308 NONAME
                              _LoadLibraryW@4                      @309 NONAME
+                             
                              _GetTimeFormatW@24                   @310 NONAME
                              _GetDateFormatW@24                   @311 NONAME
@@ -294 +296 @@
                              _SetFileAttributesW@8                @338 NONAME
                              _GetNumberFormatW@24                 @339 NONAME
+                             
                              _MessageBoxW@16                      @340 NONAME
                              _FindNextFileW@8                     @341 NONAME
-  _SHLWAPI_342@12 = _InterlockedCompareExchange@12                @342 NONAME
+                             _SHInterlockedCompareExchange@12     @342 NONAME
                              _SHLWAPI_346@12                      @346 NONAME
                              _RegDeleteValueW@8                   @347 NONAME
 
+                             _SHLWAPI_350@8                       @350 NONAME
+                             _SHLWAPI_351@16                      @351 NONAME
+                             _SHLWAPI_352@16                      @352 NONAME
                              _SHLWAPI_356@12                      @356 NONAME
                              _SHLWAPI_357@20                      @357 NONAME
@@ -342 +348 @@
 
                              _SHLWAPI_413@4                       @413 NONAME
-
+                             _SHLWAPI_418@4                       @418 NONAME
+                             
                              _TrackPopupMenuEx@24                 @428 NONAME
 
@@ -349 +356 @@
                              _SendMessageTimeoutW@28              @434 NONAME
 
+                             _SHLWAPI_436@8                       @436 NONAME
                              _SHLWAPI_437@4                       @437 NONAME
 
@@ -356 +364 @@
     ColorRGBToHLS          = _ColorRGBToHLS@16                    @445
 
-    DllGetVersion          = _SHLWAPI_DllGetVersion@4             @446
-    GetMenuPosFromID       = _GetMenuPosFromID@8                  @447
-    HashData               = _HashData@16                         @448
-  ; IntlStrEqWorkerA       = _StrIsIntlEqualA@16                  @449
-  ; IntlStrEqWorkerW       = _StrIsIntlEqualw@16                  @450
-    PathAddBackslashA      = _PathAddBackslashA@4                 @451
-    PathAddBackslashW      = _PathAddBackslashW@4                 @452
-    PathAddExtensionA      = _PathAddExtensionA@8                 @453
-    PathAddExtensionW      = _PathAddExtensionW@8                 @454
-    PathAppendA            = _PathAppendA@8                       @455
-    PathAppendW            = _PathAppendW@8                       @456
-    PathBuildRootA         = _PathBuildRootA@8                    @457
-    PathBuildRootW         = _PathBuildRootW@8                    @458
-    PathCanonicalizeA      = _PathCanonicalizeA@8                 @459
-    PathCanonicalizeW      = _PathCanonicalizeW@8                 @460
-    PathCombineA           = _PathCombineA@12                     @461
-    PathCombineW           = _PathCombineW@12                     @462
-    PathCommonPrefixA      = _PathCommonPrefixA@12                @463
-    PathCommonPrefixW      = _PathCommonPrefixW@12                @464
-    PathCompactPathA       = _PathCompactPathA@12                 @465
-    PathCompactPathExA     = _PathCompactPathExA@16               @466
-    PathCompactPathExW     = _PathCompactPathExW@16               @467
-    PathCompactPathW       = _PathCompactPathW@12                 @468
-    PathCreateFromUrlA     = _PathCreateFromUrlA@16               @469
-    PathCreateFromUrlW     = _PathCreateFromUrlW@16               @470
-    PathFileExistsA        = _PathFileExistsA@4                   @471
-    PathFileExistsW        = _PathFileExistsW@4                   @472
-    PathFindExtensionA     = _PathFindExtensionA@4                @473
-    PathFindExtensionW     = _PathFindExtensionW@4                @474
-    PathFindFileNameA      = _PathFindFileNameA@4                 @475
-    PathFindFileNameW      = _PathFindFileNameW@4                 @476
-    PathFindNextComponentA = _PathFindNextComponentA@4            @477
-    PathFindNextComponentW = _PathFindNextComponentW@4            @478
-    PathFindOnPathA        = _PathFindOnPathA@8                   @479
-    PathFindOnPathW        = _PathFindOnPathW@8                   @480
-;   PathFindSuffixArrayA   = _PathFindSuffixArrayA@12             @481
-;   PathFindSuffixArrayW   = _PathFindSuffixArrayW@12             @482
-    PathGetArgsA           = _PathGetArgsA@4                      @483
-    PathGetArgsW           = _PathGetArgsW@4                      @484
-    PathGetCharTypeA       = _PathGetCharTypeA@4                  @485
-    PathGetCharTypeW       = _PathGetCharTypeW@4                  @486
-    PathGetDriveNumberA    = _PathGetDriveNumberA@4               @487
-    PathGetDriveNumberW    = _PathGetDriveNumberW@4               @488
-    PathIsContentTypeA     = _PathIsContentTypeA@8                @489
-    PathIsContentTypeW     = _PathIsContentTypeW@8                @490
-    PathIsDirectoryA       = _PathIsDirectoryA@4                  @491
-;   PathIsDirectoryEmptyA  = _PathIsDirectoryEmptyA@4             @492
-;   PathIsDirectoryEmptyW  = _PathIsDirectoryEmptyW@4             @493
-    PathIsDirectoryW       = _PathIsDirectoryW@4                  @494
-    PathIsFileSpecA        = _PathIsFileSpecA@4                   @495
-    PathIsFileSpecW        = _PathIsFileSpecW@4                   @496
-;   PathIsLFNFileSpecA     = _PathIsLFNFileSpecA@4                @497
-;   PathIsLFNFileSpecW     = _PathIsLFNFileSpecW@4                @498
-;   PathIsNetworkPathA     = _PathIsNetworkPathA@4                @499
-;   PathIsNetworkPathW     = _PathIsNetworkPathW@4                @500
-    PathIsPrefixA          = _PathIsPrefixA@8                     @501
-    PathIsPrefixW          = _PathIsPrefixW@8                     @502
-    PathIsRelativeA        = _PathIsRelativeA@4                   @503
-    PathIsRelativeW        = _PathIsRelativeW@4                   @504
-    PathIsRootA            = _PathIsRootA@4                       @505
-    PathIsRootW            = _PathIsRootW@4                       @506
-    PathIsSameRootA        = _PathIsSameRootA@8                   @507
-    PathIsSameRootW        = _PathIsSameRootW@8                   @508
-    PathIsSystemFolderA    = _PathIsSystemFolderA@8               @509
-    PathIsSystemFolderW    = _PathIsSystemFolderW@8               @510
-    PathIsUNCA             = _PathIsUNCA@4                        @511
-    PathIsUNCServerA       = _PathIsUNCServerA@4                  @512
-    PathIsUNCServerShareA  = _PathIsUNCServerShareA@4             @513
-    PathIsUNCServerShareW  = _PathIsUNCServerShareW@4             @514
-    PathIsUNCServerW       = _PathIsUNCServerW@4                  @515
-    PathIsUNCW             = _PathIsUNCW@4                        @516
-    PathIsURLA             = _PathIsURLA@4                        @517
-    PathIsURLW             = _PathIsURLW@4                        @518
-    PathMakePrettyA        = _PathMakePrettyA@4                   @519
-    PathMakePrettyW        = _PathMakePrettyW@4                   @520
-    PathMakeSystemFolderA  = _PathMakeSystemFolderA@4             @521
-    PathMakeSystemFolderW  = _PathMakeSystemFolderW@4             @522
-    PathMatchSpecA         = _PathMatchSpecA@8                    @523
-    PathMatchSpecW         = _PathMatchSpecW@8                    @524
-    PathParseIconLocationA = _PathParseIconLocationA@4            @525
-    PathParseIconLocationW = _PathParseIconLocationW@4            @526
-    PathQuoteSpacesA       = _PathQuoteSpacesA@4                  @527
-    PathQuoteSpacesW       = _PathQuoteSpacesW@4                  @528
-    PathRelativePathToA    = _PathRelativePathToA@20              @529
-    PathRelativePathToW    = _PathRelativePathToW@20              @530
-    PathRemoveArgsA        = _PathRemoveArgsA@4                   @531
-    PathRemoveArgsW        = _PathRemoveArgsW@4                   @532
-    PathRemoveBackslashA   = _PathRemoveBackslashA@4              @533
-    PathRemoveBackslashW   = _PathRemoveBackslashW@4              @534
-    PathRemoveBlanksA      = _PathRemoveBlanksA@4                 @535
-    PathRemoveBlanksW      = _PathRemoveBlanksW@4                 @536
-    PathRemoveExtensionA   = _PathRemoveExtensionA@4              @537
-    PathRemoveExtensionW   = _PathRemoveExtensionW@4              @538
-    PathRemoveFileSpecA    = _PathRemoveFileSpecA@4               @539
-    PathRemoveFileSpecW    = _PathRemoveFileSpecW@4               @540
-    PathRenameExtensionA   = _PathRenameExtensionA@8              @541
-    PathRenameExtensionW   = _PathRenameExtensionW@8              @542
-    PathSearchAndQualifyA  = _PathSearchAndQualifyA@12            @543
-    PathSearchAndQualifyW  = _PathSearchAndQualifyW@12            @544
-    PathSetDlgItemPathA    = _PathSetDlgItemPathA@12              @545
-    PathSetDlgItemPathW    = _PathSetDlgItemPathW@12              @546
-    PathSkipRootA          = _PathSkipRootA@4                     @547
-    PathSkipRootW          = _PathSkipRootW@4                     @548
-    PathStripPathA         = _PathStripPathA@4                    @549
-    PathStripPathW         = _PathStripPathW@4                    @550
-    PathStripToRootA       = _PathStripToRootA@4                  @551
-    PathStripToRootW       = _PathStripToRootW@4                  @552
-;   PathUndecorateA        = _PathUndecorateA@4                   @553
-;   PathUndecorateW        = _PathUndecorateW@4                   @554
-    PathUnmakeSystemFolderA= _PathUnmakeSystemFolderA@4           @555
-    PathUnmakeSystemFolderW= _PathUnmakeSystemFolderW@4           @556
-    PathUnquoteSpacesA     = _PathUnquoteSpacesA@4                @557
-    PathUnquoteSpacesW     = _PathUnquoteSpacesW@4                @558
-
-;   SHAutoComplete         = _SHAutoComplete@8                    @559
-  ; SHCopyKeyA             = _SHCopyKeyA@?                        @560
-  ; SHCopyKeyW             = _SHCopyKeyW@?                        @561
-    SHCreateShellPalette   = _SHCreateShellPalette@4              @562
-  ; SHCreateStreamOnFileA  = _SHCreateStreamOnFileA@?             @563
-  ; SHCreateStreamOnFileW  = _SHCreateStreamOnFileW@?             @564
-  ; SHCreateStreamWrapper  = _SHCreateStreamWrapper@?             @565
-
-    SHDeleteEmptyKeyA      = _SHDeleteEmptyKeyA@8                 @567
-    SHDeleteEmptyKeyW      = _SHDeleteEmptyKeyW@8                 @568
-    SHDeleteKeyA           = _SHDeleteKeyA@8                      @569
-    SHDeleteKeyW           = _SHDeleteKeyW@8                      @570
-    SHDeleteOrphanKeyA     = _SHDeleteOrphanKeyA@8                @571
-    SHDeleteOrphanKeyW     = _SHDeleteOrphanKeyW@8                @572
-    SHDeleteValueA         = _SHDeleteValueA@12                   @573
-    SHDeleteValueW         = _SHDeleteValueW@12                   @574
-    SHEnumKeyExA           = _SHEnumKeyExA@16                     @575
-    SHEnumKeyExW           = _SHEnumKeyExW@16                     @576
-    SHEnumValueA           = _SHEnumValueA@28                     @577
-    SHEnumValueW           = _SHEnumValueW@28                     @578
-    _SHGetInstanceExplorer = __SHGetInstanceExplorer@4            @579
-    SHGetInverseCMAP       = _SHGetInverseCMAP@8                  @580
-;   SHGetThreadRef         = _SHGetThreadRef@?                    @581
-    SHGetValueA            = _SHGetValueA@24                      @582
-    SHGetValueW            = _SHGetValueW@24                      @583
-    SHIsLowMemoryMachine   = _SHIsLowMemoryMachine@4              @584
-    SHOpenRegStream2A      = _SHOpenRegStreamA@16                 @585
-    SHOpenRegStream2W      = _SHOpenRegStreamW@16                 @586
-    SHOpenRegStreamA       = _SHOpenRegStreamA@16                 @587
-    SHOpenRegStreamW       = _SHOpenRegStreamW@16                 @588
-    SHQueryInfoKeyA        = _SHQueryInfoKeyA@20                  @589
-    SHQueryInfoKeyW        = _SHQueryInfoKeyW@20                  @590
-    SHQueryValueExA        = _SHQueryValueExA@24                  @591
-    SHQueryValueExW        = _SHQueryValueExW@24                  @592
-    SHRegCloseUSKey        = _SHRegCloseUSKey@4                   @593
-    SHRegCreateUSKeyA      = _SHRegCreateUSKeyA@20                @594
-    SHRegCreateUSKeyW      = _SHRegCreateUSKeyW@20                @595
-    SHRegDeleteEmptyUSKeyA = _SHRegDeleteEmptyUSKeyA@12           @596
-    SHRegDeleteEmptyUSKeyW = _SHRegDeleteEmptyUSKeyW@12           @597
-    SHRegDeleteUSKeyA      = _SHRegDeleteUSKeyA@12                @598
-    SHRegDeleteUSKeyW      = _SHRegDeleteUSKeyW@12                @599
-  ; SHRegDuplicateHKey     = _SHRegDuplicateHKey@?                @600
-    SHRegEnumUSKeyA        = _SHRegEnumUSKeyA@20                  @601
-    SHRegEnumUSKeyW        = _SHRegEnumUSKeyW@20                  @602
-    SHRegEnumUSValueA      = _SHRegEnumUSValueA@32                @603
-    SHRegEnumUSValueW      = _SHRegEnumUSValueW@32                @604
-    SHRegGetBoolUSValueA   = _SHRegGetBoolUSValueA@16             @605
-    SHRegGetBoolUSValueW   = _SHRegGetBoolUSValueW@16             @606
-    SHRegGetUSValueA       = _SHRegGetUSValueA@32                 @607
-    SHRegGetUSValueW       = _SHRegGetUSValueW@32                 @608
-    SHRegOpenUSKeyA        = _SHRegOpenUSKeyA@20                  @609
-    SHRegOpenUSKeyW        = _SHRegOpenUSKeyW@20                  @610
-;    SHRegQueryInfoKeyA     = _SHRegQueryInfoKeyA@24               @611
-;    SHRegQueryInfoKeyW     = _SHRegQueryInfoKeyW@24               @612
-    SHRegQueryUSValueA     = _SHRegQueryUSValueA@32               @613
-    SHRegQueryUSValueW     = _SHRegQueryUSValueW@32               @614
-    SHRegSetUSValueA       = _SHRegSetUSValueA@24                 @615
-    SHRegSetUSValueW       = _SHRegSetUSValueW@24                 @616
-    SHRegWriteUSValueA     = _SHRegWriteUSValueA@24               @617
-    SHRegWriteUSValueW     = _SHRegWriteUSValueW@24               @618
-;   SHSetSetThreadRef      = _SHSetThreadRef@?                    @619
-    SHSetValueA            = _SHSetValueA@24                      @620
-    SHSetValueW            = _SHSetValueW@24                      @621
-;   SHSkipJunction         = _SHSkipJunction@8                    @622
-;   SHStrDupA              = _SHStrDupA@?                         @623
-;   SHStrDupW              = _SHStrDUpW@?                         @624
-    StrCSpnA               = _StrCSpnA@8                          @625
-  ; StrCSpnIA              = _StrCSpnIA@?                         @626
-  ; StrCSpnIW              = _StrCSpnIW@?                         @627
-    StrCSpnW               = _StrCSpnW@8                          @628
-    StrCatBuffA            = _StrCatBuffA@12                      @629
-    StrCatBuffW            = _StrCatBuffW@12                      @630
+    DllGetVersion          = _SHLWAPI_DllGetVersion@4             @1046
+    GetMenuPosFromID       = _GetMenuPosFromID@8                  @1047
+    HashData               = _HashData@16                         @1048
+  ; IntlStrEqWorkerA       = _StrIsIntlEqualA@16                  @1049
+  ; IntlStrEqWorkerW       = _StrIsIntlEqualw@16                  @1050
+    PathAddBackslashA      = _PathAddBackslashA@4                 @1051
+    PathAddBackslashW      = _PathAddBackslashW@4                 @1052
+    PathAddExtensionA      = _PathAddExtensionA@8                 @1053
+    PathAddExtensionW      = _PathAddExtensionW@8                 @1054
+    PathAppendA            = _PathAppendA@8                       @1055
+    PathAppendW            = _PathAppendW@8                       @1056
+    PathBuildRootA         = _PathBuildRootA@8                    @1057
+    PathBuildRootW         = _PathBuildRootW@8                    @1058
+    PathCanonicalizeA      = _PathCanonicalizeA@8                 @1059
+    PathCanonicalizeW      = _PathCanonicalizeW@8                 @1060
+    PathCombineA           = _PathCombineA@12                     @1061
+    PathCombineW           = _PathCombineW@12                     @1062
+    PathCommonPrefixA      = _PathCommonPrefixA@12                @1063
+    PathCommonPrefixW      = _PathCommonPrefixW@12                @1064
+    PathCompactPathA       = _PathCompactPathA@12                 @1065
+    PathCompactPathExA     = _PathCompactPathExA@16               @1066
+    PathCompactPathExW     = _PathCompactPathExW@16               @1067
+    PathCompactPathW       = _PathCompactPathW@12                 @1068
+    PathCreateFromUrlA     = _PathCreateFromUrlA@16               @1069
+    PathCreateFromUrlW     = _PathCreateFromUrlW@16               @1070
+    PathFileExistsA        = _PathFileExistsA@4                   @1071
+    PathFileExistsW        = _PathFileExistsW@4                   @1072
+    PathFindExtensionA     = _PathFindExtensionA@4                @1073
+    PathFindExtensionW     = _PathFindExtensionW@4                @1074
+    PathFindFileNameA      = _PathFindFileNameA@4                 @1075
+    PathFindFileNameW      = _PathFindFileNameW@4                 @1076
+    PathFindNextComponentA = _PathFindNextComponentA@4            @1077
+    PathFindNextComponentW = _PathFindNextComponentW@4            @1078
+    PathFindOnPathA        = _PathFindOnPathA@8                   @1079
+    PathFindOnPathW        = _PathFindOnPathW@8                   @1080
+    PathFindSuffixArrayA   = _PathFindSuffixArrayA@12             @1081
+    PathFindSuffixArrayW   = _PathFindSuffixArrayW@12             @1082
+    PathGetArgsA           = _PathGetArgsA@4                      @1083
+    PathGetArgsW           = _PathGetArgsW@4                      @1084
+    PathGetCharTypeA       = _PathGetCharTypeA@4                  @1085
+    PathGetCharTypeW       = _PathGetCharTypeW@4                  @1086
+    PathGetDriveNumberA    = _PathGetDriveNumberA@4               @1087
+    PathGetDriveNumberW    = _PathGetDriveNumberW@4               @1088
+    PathIsContentTypeA     = _PathIsContentTypeA@8                @1089
+    PathIsContentTypeW     = _PathIsContentTypeW@8                @1090
+    PathIsDirectoryA       = _PathIsDirectoryA@4                  @1091
+    PathIsDirectoryEmptyA  = _PathIsDirectoryEmptyA@4             @1092
+    PathIsDirectoryEmptyW  = _PathIsDirectoryEmptyW@4             @1093
+    PathIsDirectoryW       = _PathIsDirectoryW@4                  @1094
+    PathIsFileSpecA        = _PathIsFileSpecA@4                   @1095
+    PathIsFileSpecW        = _PathIsFileSpecW@4                   @1096
+    PathIsLFNFileSpecA     = _PathIsLFNFileSpecA@4                @1097
+    PathIsLFNFileSpecW     = _PathIsLFNFileSpecW@4                @1098
+    PathIsNetworkPathA     = _PathIsNetworkPathA@4                @1099
+    PathIsNetworkPathW     = _PathIsNetworkPathW@4                @1100
+    PathIsPrefixA          = _PathIsPrefixA@8                     @1101
+    PathIsPrefixW          = _PathIsPrefixW@8                     @1102
+    PathIsRelativeA        = _PathIsRelativeA@4                   @1103
+    PathIsRelativeW        = _PathIsRelativeW@4                   @1104
+    PathIsRootA            = _PathIsRootA@4                       @1105
+    PathIsRootW            = _PathIsRootW@4                       @1106
+    PathIsSameRootA        = _PathIsSameRootA@8                   @1107
+    PathIsSameRootW        = _PathIsSameRootW@8                   @1108
+    PathIsSystemFolderA    = _PathIsSystemFolderA@8               @1109
+    PathIsSystemFolderW    = _PathIsSystemFolderW@8               @1110
+    PathIsUNCA             = _PathIsUNCA@4                        @1111
+    PathIsUNCServerA       = _PathIsUNCServerA@4                  @1112
+    PathIsUNCServerShareA  = _PathIsUNCServerShareA@4             @1113
+    PathIsUNCServerShareW  = _PathIsUNCServerShareW@4             @1114
+    PathIsUNCServerW       = _PathIsUNCServerW@4                  @1115
+    PathIsUNCW             = _PathIsUNCW@4                        @1116
+    PathIsURLA             = _PathIsURLA@4                        @1117
+    PathIsURLW             = _PathIsURLW@4                        @1118
+    PathMakePrettyA        = _PathMakePrettyA@4                   @1119
+    PathMakePrettyW        = _PathMakePrettyW@4                   @1120
+    PathMakeSystemFolderA  = _PathMakeSystemFolderA@4             @1121
+    PathMakeSystemFolderW  = _PathMakeSystemFolderW@4             @1122
+    PathMatchSpecA         = _PathMatchSpecA@8                    @1123
+    PathMatchSpecW         = _PathMatchSpecW@8                    @1124
+    PathParseIconLocationA = _PathParseIconLocationA@4            @1125
+    PathParseIconLocationW = _PathParseIconLocationW@4            @1126
+    PathQuoteSpacesA       = _PathQuoteSpacesA@4                  @1127
+    PathQuoteSpacesW       = _PathQuoteSpacesW@4                  @1128
+    PathRelativePathToA    = _PathRelativePathToA@20              @1129
+    PathRelativePathToW    = _PathRelativePathToW@20              @1130
+    PathRemoveArgsA        = _PathRemoveArgsA@4                   @1131
+    PathRemoveArgsW        = _PathRemoveArgsW@4                   @1132
+    PathRemoveBackslashA   = _PathRemoveBackslashA@4              @1133
+    PathRemoveBackslashW   = _PathRemoveBackslashW@4              @1134
+    PathRemoveBlanksA      = _PathRemoveBlanksA@4                 @1135
+    PathRemoveBlanksW      = _PathRemoveBlanksW@4                 @1136
+    PathRemoveExtensionA   = _PathRemoveExtensionA@4              @1137
+    PathRemoveExtensionW   = _PathRemoveExtensionW@4              @1138
+    PathRemoveFileSpecA    = _PathRemoveFileSpecA@4               @1139
+    PathRemoveFileSpecW    = _PathRemoveFileSpecW@4               @1140
+    PathRenameExtensionA   = _PathRenameExtensionA@8              @1141
+    PathRenameExtensionW   = _PathRenameExtensionW@8              @1142
+    PathSearchAndQualifyA  = _PathSearchAndQualifyA@12            @1143
+    PathSearchAndQualifyW  = _PathSearchAndQualifyW@12            @1144
+    PathSetDlgItemPathA    = _PathSetDlgItemPathA@12              @1145
+    PathSetDlgItemPathW    = _PathSetDlgItemPathW@12              @1146
+    PathSkipRootA          = _PathSkipRootA@4                     @1147
+    PathSkipRootW          = _PathSkipRootW@4                     @1148
+    PathStripPathA         = _PathStripPathA@4                    @1149
+    PathStripPathW         = _PathStripPathW@4                    @1150
+    PathStripToRootA       = _PathStripToRootA@4                  @1151
+    PathStripToRootW       = _PathStripToRootW@4                  @1152
+    PathUndecorateA        = _PathUndecorateA@4                   @1153
+    PathUndecorateW        = _PathUndecorateW@4                   @1154
+    PathUnmakeSystemFolderA= _PathUnmakeSystemFolderA@4           @1155
+    PathUnmakeSystemFolderW= _PathUnmakeSystemFolderW@4           @1156
+    PathUnquoteSpacesA     = _PathUnquoteSpacesA@4                @1157
+    PathUnquoteSpacesW     = _PathUnquoteSpacesW@4                @1158
+
+;   SHAutoComplete         = _SHAutoComplete@8                    @1159
+  ; SHCopyKeyA             = _SHCopyKeyA@?                        @1160
+  ; SHCopyKeyW             = _SHCopyKeyW@?                        @1161
+    SHCreateShellPalette   = _SHCreateShellPalette@4              @1162
+  ; SHCreateStreamOnFileA  = _SHCreateStreamOnFileA@?             @1163
+  ; SHCreateStreamOnFileW  = _SHCreateStreamOnFileW@?             @1164
+  ; SHCreateStreamWrapper  = _SHCreateStreamWrapper@?             @1165
+
+    SHDeleteEmptyKeyA      = _SHDeleteEmptyKeyA@8                 @1167
+    SHDeleteEmptyKeyW      = _SHDeleteEmptyKeyW@8                 @1168
+    SHDeleteKeyA           = _SHDeleteKeyA@8                      @1169
+    SHDeleteKeyW           = _SHDeleteKeyW@8                      @1170
+    SHDeleteOrphanKeyA     = _SHDeleteOrphanKeyA@8                @1171
+    SHDeleteOrphanKeyW     = _SHDeleteOrphanKeyW@8                @1172
+    SHDeleteValueA         = _SHDeleteValueA@12                   @1173
+    SHDeleteValueW         = _SHDeleteValueW@12                   @1174
+    SHEnumKeyExA           = _SHEnumKeyExA@16                     @1175
+    SHEnumKeyExW           = _SHEnumKeyExW@16                     @1176
+    SHEnumValueA           = _SHEnumValueA@28                     @1177
+    SHEnumValueW           = _SHEnumValueW@28                     @1178
+    _SHGetInstanceExplorer = __SHGetInstanceExplorer@4            @1179
+    SHGetInverseCMAP       = _SHGetInverseCMAP@8                  @1180
+    SHGetThreadRef         = _SHGetThreadRef@4                    @1181
+    SHGetValueA            = _SHGetValueA@24                      @1182
+    SHGetValueW            = _SHGetValueW@24                      @1183
+    SHIsLowMemoryMachine   = _SHIsLowMemoryMachine@4              @1184
+    SHOpenRegStream2A      = _SHOpenRegStreamA@16                 @1185
+    SHOpenRegStream2W      = _SHOpenRegStreamW@16                 @1186
+    SHOpenRegStreamA       = _SHOpenRegStreamA@16                 @1187
+    SHOpenRegStreamW       = _SHOpenRegStreamW@16                 @1188
+    SHQueryInfoKeyA        = _SHQueryInfoKeyA@20                  @1189
+    SHQueryInfoKeyW        = _SHQueryInfoKeyW@20                  @1190
+    SHQueryValueExA        = _SHQueryValueExA@24                  @1191
+    SHQueryValueExW        = _SHQueryValueExW@24                  @1192
+    SHRegCloseUSKey        = _SHRegCloseUSKey@4                   @1193
+    SHRegCreateUSKeyA      = _SHRegCreateUSKeyA@20                @1194
+    SHRegCreateUSKeyW      = _SHRegCreateUSKeyW@20                @1195
+    SHRegDeleteEmptyUSKeyA = _SHRegDeleteEmptyUSKeyA@12           @1196
+    SHRegDeleteEmptyUSKeyW = _SHRegDeleteEmptyUSKeyW@12           @1197
+    SHRegDeleteUSKeyA      = _SHRegDeleteUSKeyA@12                @1198
+    SHRegDeleteUSKeyW      = _SHRegDeleteUSKeyW@12                @1199
+    SHRegDuplicateHKey     = _SHRegDuplicateHKey@4                @1200
+    SHRegEnumUSKeyA        = _SHRegEnumUSKeyA@20                  @1201
+    SHRegEnumUSKeyW        = _SHRegEnumUSKeyW@20                  @1202
+    SHRegEnumUSValueA      = _SHRegEnumUSValueA@32                @1203
+    SHRegEnumUSValueW      = _SHRegEnumUSValueW@32                @1204
+    SHRegGetBoolUSValueA   = _SHRegGetBoolUSValueA@16             @1205
+    SHRegGetBoolUSValueW   = _SHRegGetBoolUSValueW@16             @1206
+    SHRegGetUSValueA       = _SHRegGetUSValueA@32                 @1207
+    SHRegGetUSValueW       = _SHRegGetUSValueW@32                 @1208
+    SHRegOpenUSKeyA        = _SHRegOpenUSKeyA@20                  @1209
+    SHRegOpenUSKeyW        = _SHRegOpenUSKeyW@20                  @1210
+;    SHRegQueryInfoKeyA     = _SHRegQueryInfoKeyA@24               @1211
+;    SHRegQueryInfoKeyW     = _SHRegQueryInfoKeyW@24               @1212
+    SHRegQueryUSValueA     = _SHRegQueryUSValueA@32               @1213
+    SHRegQueryUSValueW     = _SHRegQueryUSValueW@32               @1214
+    SHRegSetUSValueA       = _SHRegSetUSValueA@24                 @1215
+    SHRegSetUSValueW       = _SHRegSetUSValueW@24                 @1216
+    SHRegWriteUSValueA     = _SHRegWriteUSValueA@24               @1217
+    SHRegWriteUSValueW     = _SHRegWriteUSValueW@24               @1218
+    SHSetSetThreadRef      = _SHSetThreadRef@4                    @1219
+    SHSetValueA            = _SHSetValueA@24                      @1220
+    SHSetValueW            = _SHSetValueW@24                      @1221
+;   SHSkipJunction         = _SHSkipJunction@8                    @1222
+;   SHStrDupA              = _SHStrDupA@?                         @1223
+;   SHStrDupW              = _SHStrDUpW@?                         @1224
+    StrCSpnA               = _StrCSpnA@8                          @1225
+  ; StrCSpnIA              = _StrCSpnIA@?                         @1226
+  ; StrCSpnIW              = _StrCSpnIW@?                         @1227
+    StrCSpnW               = _StrCSpnW@8                          @1228
+    StrCatBuffA            = _StrCatBuffA@12                      @1229
+    StrCatBuffW            = _StrCatBuffW@12                      @1230
 ;    StrCatA                = _StrCatA@8                                 ; not exported ?
-    StrCatW                = _StrCatW@8                           @631
-    StrChrA                = _StrChrA@8                           @632
-    StrChrIA               = _StrChrIA@8                          @633
-    StrChrIW               = _StrChrIW@8                          @634
-    StrChrW                = _StrChrW@8                           @635
-    StrCmpIW               = _lstrcmpiW@8                         @636
-    StrCmpNA               = _StrCmpNA@12                         @637
-    StrCmpNIA              = _StrCmpNIA@12                        @638
-    StrCmpNIW              = _StrCmpNIW@12                        @639
-    StrCmpNW               = _StrCmpNW@12                         @640
-    StrCmpW                = _lstrcmpW@8                          @641
-    StrCpyNW               = _lstrcpynW@12                        @642
+    StrCatW                = _StrCatW@8                           @1231
+    StrChrA                = _StrChrA@8                           @1232
+    StrChrIA               = _StrChrIA@8                          @1233
+    StrChrIW               = _StrChrIW@8                          @1234
+    StrChrW                = _StrChrW@8                           @1235
+    StrCmpIW               = _lstrcmpiW@8                         @1236
+    StrCmpNA               = _StrCmpNA@12                         @1237
+    StrCmpNIA              = _StrCmpNIA@12                        @1238
+    StrCmpNIW              = _StrCmpNIW@12                        @1239
+    StrCmpNW               = _StrCmpNW@12                         @1240
+    StrCmpW                = _lstrcmpW@8                          @1241
+    StrCpyNW               = _lstrcpynW@12                        @1242
 ;;;    StrCpyA                = _StrCpyA@8                                 ; not exported ?
-    StrCpyW                = _StrCpyW@8                           @643
-    StrDupA                = _StrDupA@4                           @644
-    StrDupW                = _StrDupW@4                           @645
-;   StrFormatByteSize64A   = _StrFormatByteSize64A@16             @646
-    StrFormatByteSizeA     = _StrFormatByteSizeA@12               @647
-    StrFormatByteSizeW     = _StrFormatByteSizeW@12               @648
-;   StrFormatKBSizeA       = _StrFormatKBSizeA@16                 @649
-;   StrFormatKBSizeW       = _StrFormatKBSizeW@16                 @650
-    StrFromTimeIntervalA   = _StrFromTimeIntervalA@16             @651
-    StrFromTimeIntervalW   = _StrFromTimeIntervalW@16             @652
-  ; IntlStrEqWorkerA       = _StrIsIntlEqualA@16                  @653
-  ; StrIsIntlEqualW        = _StrIsIntlEqualW@?                   @654
-    StrNCatA               = _StrNCatA@12                         @655
-    StrNCatW               = _StrNCatW@12                         @656
-    StrPBrkA               = _StrPBrkA@8                          @657
-    StrPBrkW               = _StrPBrkW@8                          @658
-    StrRChrA               = _StrRChrA@12                         @659
-    StrRChrIA              = _StrRChrIA@12                        @660
-    StrRChrIW              = _StrRChrIW@12                        @661
-    StrRChrW               = _StrRChrW@12                         @662
-    StrRStrIA              = _StrRStrIA@12                        @663
-    StrRStrIW              = _StrRStrIW@12                        @664
-    StrRetToBufA           = _StrRetToBufA@16                     @665
-    StrRetToBufW           = _StrRetToBufW@16                     @666
-;   StrRetToStrA           = _StrRetToStrA@12                     @667
-;   StrRetToStrW           = _StrRetToStrW@12                     @668
-    StrSpnA                = _StrSpnA@8                           @669
-    StrSpnW                = _StrSpnW@8                           @670
-    StrStrA                = _StrStrA@8                           @671
-    StrStrIA               = _StrStrIA@8                          @672
-    StrStrIW               = _StrStrIW@8                          @673
-    StrStrW                = _StrStrW@8                           @674
-    StrToIntA              = _StrToIntA@4                         @675
-    StrToIntExA            = _StrToIntExA@12                      @676
-    StrToIntExW            = _StrToIntExW@12                      @677
-    StrToIntW              = _StrToIntW@4                         @678
-    StrTrimA               = _StrTrimA@8                          @679
-  ; StrTrimW               = _StrTrimW@?                          @680
-    UrlApplySchemeA        = _UrlApplySchemeA@16                  @681
-    UrlApplySchemeW        = _UrlApplySchemeW@16                  @682
-    UrlCanonicalizeA       = _UrlCanonicalizeA@16                 @683
-    UrlCanonicalizeW       = _UrlCanonicalizeW@16                 @684
-    UrlCombineA            = _UrlCombineA@20                      @685
-    UrlCombineW            = _UrlCombineW@20                      @686
-    UrlCompareA            = _UrlCompareA@12                      @687
-    UrlCompareW            = _UrlCompareW@12                      @688
-    UrlCreateFromPathA     = _UrlCreateFromPathA@16               @689
-    UrlCreateFromPathW     = _UrlCreateFromPathW@16               @690
-    UrlEscapeA             = _UrlEscapeA@16                       @691
-    UrlEscapeW             = _UrlEscapeW@16                       @692
-    UrlGetLocationA        = _UrlGetLocationA@4                   @693
-    UrlGetLocationW        = _UrlGetLocationW@4                   @694
-    UrlGetPartA            = _UrlGetPartA@20                      @695
-    UrlGetPartW            = _UrlGetPartW@20                      @696
-    UrlHashA               = _UrlHashA@12                         @697
-    UrlHashW               = _UrlHashW@12                         @698
-    UrlIsA                 = _UrlIsA@8                            @699
-    UrlIsNoHistoryA        = _UrlIsNoHistoryA@4                   @700
-    UrlIsNoHistoryW        = _UrlIsNoHistoryW@4                   @701
-    UrlIsOpaqueA           = _UrlIsOpaqueA@4                      @702
-    UrlIsOpaqueW           = _UrlIsOpaqueW@4                      @703
-    UrlIsW                 = _UrlIsW@8                            @704
-    UrlUnescapeA           = _UrlUnescapeA@16                     @705
-    UrlUnescapeW           = _UrlUnescapeW@16                     @706
-    wnsprintfA             = _wnsprintfA                          @707
-    wnsprintfW             = _wnsprintfW                          @708
-;    wvnsprintfA            = _wvnsprintfA@16                      @709
-;    wvnsprintfW            = _wvnsprintfW@16                      @710
-
-    SHRegGetPathA          = _SHRegGetPathA@20                    @802
-    SHRegGetPathW          = _SHRegGetPathW@20                    @803
-    SHRegDeleteUSValueA    = _SHRegDeleteUSValueA@12
-    SHRegDeleteUSValueW    = _SHRegDeleteUSValueW@12
+    StrCpyW                = _StrCpyW@8                           @1243
+    StrDupA                = _StrDupA@4                           @1244
+    StrDupW                = _StrDupW@4                           @1245
+;   StrFormatByteSize64A   = _StrFormatByteSize64A@16             @1246
+    StrFormatByteSizeA     = _StrFormatByteSizeA@12               @1247
+    StrFormatByteSizeW     = _StrFormatByteSizeW@12               @1248
+;   StrFormatKBSizeA       = _StrFormatKBSizeA@16                 @1249
+;   StrFormatKBSizeW       = _StrFormatKBSizeW@16                 @1250
+    StrFromTimeIntervalA   = _StrFromTimeIntervalA@16             @1251
+    StrFromTimeIntervalW   = _StrFromTimeIntervalW@16             @1252
+  ; IntlStrEqWorkerA       = _StrIsIntlEqualA@16                  @1253
+  ; StrIsIntlEqualW        = _StrIsIntlEqualW@?                   @1254
+    StrNCatA               = _StrNCatA@12                         @1255
+    StrNCatW               = _StrNCatW@12                         @1256
+    StrPBrkA               = _StrPBrkA@8                          @1257
+    StrPBrkW               = _StrPBrkW@8                          @1258
+    StrRChrA               = _StrRChrA@12                         @1259
+    StrRChrIA              = _StrRChrIA@12                        @1260
+    StrRChrIW              = _StrRChrIW@12                        @1261
+    StrRChrW               = _StrRChrW@12                         @1262
+    StrRStrIA              = _StrRStrIA@12                        @1263
+    StrRStrIW              = _StrRStrIW@12                        @1264
+    StrRetToBufA           = _StrRetToBufA@16                     @1265
+    StrRetToBufW           = _StrRetToBufW@16                     @1266
+;   StrRetToStrA           = _StrRetToStrA@12                     @1267
+;   StrRetToStrW           = _StrRetToStrW@12                     @1268
+    StrSpnA                = _StrSpnA@8                           @1269
+    StrSpnW                = _StrSpnW@8                           @1270
+    StrStrA                = _StrStrA@8                           @1271
+    StrStrIA               = _StrStrIA@8                          @1272
+    StrStrIW               = _StrStrIW@8                          @1273
+    StrStrW                = _StrStrW@8                           @1274
+    StrToIntA              = _StrToIntA@4                         @1275
+    StrToIntExA            = _StrToIntExA@12                      @1276
+    StrToIntExW            = _StrToIntExW@12                      @1277
+    StrToIntW              = _StrToIntW@4                         @1278
+    StrTrimA               = _StrTrimA@8                          @1279
+  ; StrTrimW               = _StrTrimW@?                          @1280
+  
+    UrlApplySchemeA        = _UrlApplySchemeA@16                  @1281
+    UrlApplySchemeW        = _UrlApplySchemeW@16                  @1282
+    UrlCanonicalizeA       = _UrlCanonicalizeA@16                 @1283
+    UrlCanonicalizeW       = _UrlCanonicalizeW@16                 @1284
+    UrlCombineA            = _UrlCombineA@20                      @1285
+    UrlCombineW            = _UrlCombineW@20                      @1286
+    UrlCompareA            = _UrlCompareA@12                      @1287
+    UrlCompareW            = _UrlCompareW@12                      @1288
+    UrlCreateFromPathA     = _UrlCreateFromPathA@16               @1289
+    UrlCreateFromPathW     = _UrlCreateFromPathW@16               @1290
+    UrlEscapeA             = _UrlEscapeA@16                       @1291
+    UrlEscapeW             = _UrlEscapeW@16                       @1292
+    UrlGetLocationA        = _UrlGetLocationA@4                   @1293
+    UrlGetLocationW        = _UrlGetLocationW@4                   @1294
+    UrlGetPartA            = _UrlGetPartA@20                      @1295
+    UrlGetPartW            = _UrlGetPartW@20                      @1296
+    UrlHashA               = _UrlHashA@12                         @1297
+    UrlHashW               = _UrlHashW@12                         @1298
+    UrlIsA                 = _UrlIsA@8                            @1299
+    UrlIsNoHistoryA        = _UrlIsNoHistoryA@4                   @1300
+    UrlIsNoHistoryW        = _UrlIsNoHistoryW@4                   @1301
+    UrlIsOpaqueA           = _UrlIsOpaqueA@4                      @1302
+    UrlIsOpaqueW           = _UrlIsOpaqueW@4                      @1303
+    UrlIsW                 = _UrlIsW@8                            @1304
+    UrlUnescapeA           = _UrlUnescapeA@16                     @1305
+    UrlUnescapeW           = _UrlUnescapeW@16                     @1306
+    wnsprintfA             = _wnsprintfA                          @1307
+    wnsprintfW             = _wnsprintfW                          @1308
+    wvnsprintfA            = _wvnsprintfA@16                      @1309
+    wvnsprintfW            = _wvnsprintfW@16                      @1310
+
+;; exported in later versions
+    SHRegGetPathA          = _SHRegGetPathA@20                    @1402
+    SHRegGetPathW          = _SHRegGetPathW@20                    @1403
+    SHRegDeleteUSValueA    = _SHRegDeleteUSValueA@12              @1404
+    SHRegDeleteUSValueW    = _SHRegDeleteUSValueW@12              @1405    
+    SHRegSetPathA          = _SHRegSetPathA@20                    @1406
+    SHRegSetPathW          = _SHRegSetPathW@20                    @1407
+

trunk/src/shlwapi/shlwapi_main.c

@@ -4 +4 @@
  *  Copyright 1998 Marcus Meissner
  *  Copyright 1998 Juergen Schmied (jsch)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
@@ -9 +23 @@
 #include "winerror.h"
 #include "winreg.h"
-#include "debugtools.h"
+#include "wine/debug.h"
 #define NO_SHLWAPI_STREAM
-#ifndef __WIN32OS2__
 #include "shlwapi.h"
-#endif
 
-DEFAULT_DEBUG_CHANNEL(shell);
+WINE_DEFAULT_DEBUG_CHANNEL(shell);
 
-HINSTANCE shlwapi_hInstance = 0; 
+HINSTANCE shlwapi_hInstance = 0;
 HMODULE SHLWAPI_hshell32 = 0;
 HMODULE SHLWAPI_hwinmm = 0;
@@ -23 +35 @@
 HMODULE SHLWAPI_hmpr = 0;
 HMODULE SHLWAPI_hmlang = 0;
+HMODULE SHLWAPI_hversion = 0;
+
+DWORD SHLWAPI_ThreadRef_index = -1;
 
 /*************************************************************************
@@ -37 +52 @@
           case DLL_PROCESS_ATTACH:
             shlwapi_hInstance = hinstDLL;
+            SHLWAPI_ThreadRef_index = TlsAlloc();
             break;
           case DLL_PROCESS_DETACH:
@@ -44 +60 @@
             if (SHLWAPI_hmpr)      FreeLibrary(SHLWAPI_hmpr);
             if (SHLWAPI_hmlang)    FreeLibrary(SHLWAPI_hmlang);
+            if (SHLWAPI_hversion)  FreeLibrary(SHLWAPI_hversion);
+            if (SHLWAPI_ThreadRef_index >= 0) TlsFree(SHLWAPI_ThreadRef_index);
             break;
         }

trunk/src/shlwapi/shlwapidbg.def

@@ -1 @@
-; $Id: shlwapidbg.def,v 1.1 2002-02-13 16:15:08 sandervl Exp $
+; $Id: shlwapidbg.def,v 1.2 2002-06-07 08:02:19 sandervl Exp $
 
 ; updated export ordinals to NT4 SP6 version of SHLWAPI.DLL
@@ -77 +77 @@
                              _CreateAcceleratorTableW@8           @47 NONAME
                              _CreateDCW@16                        @48 NONAME
-                             _CreateDialogParamW@20               @49 NONAME ; @@@PH imcomplete
+                             _CreateDialogParamA@20               @49 NONAME
 
                              _CreateDirectoryW@8                  @50 NONAME
@@ -194 +194 @@
                              _DbgSHLWAPI_153@12                      @153 NONAME
                              _DbgSHLWAPI_154@12                      @154 NONAME
-;;;;_DbgSHLWAPI_155@??                      @155 NONAME
+                             _DbgSHLWAPI_155@8                       @155 NONAME
                              _DbgSHLWAPI_156@8                       @156 NONAME
                              _DbgSHLWAPI_158@8                       @158 NONAME
@@ -209 +209 @@
                              _DbgSHLWAPI_172@8                       @172 NONAME
                              _DbgSHLWAPI_174@8                       @174 NONAME
+                             _DbgSHLWAPI_175@8                       @175 NONAME
                              _DbgSHLWAPI_176@16                      @176 NONAME
 
@@ -224 +225 @@
                              _DbgSHLWAPI_206@24                      @206 NONAME
                              _DbgSHLWAPI_208@20                      @208 NONAME
+                             _DbgSHLWAPI_209@4                       @209 NONAME
 
                              _DbgSHLWAPI_210@12                      @210 NONAME
@@ -257 +259 @@
 
                              _DbgSHLWAPI_289@12                      @289 NONAME
-;;                             _DbgSHLWAPI_284@20                      @294 NONAME
+                             _DbgSHLWAPI_294@20                      @294 NONAME
                              _WritePrivateProfileStringW@16       @298 NONAME
 
@@ -296 +298 @@
                              _MessageBoxW@16                      @340 NONAME
                              _FindNextFileW@8                     @341 NONAME
-  _SHLWAPI_342@12 = _InterlockedCompareExchange@12                @342 NONAME
+                             _SHInterlockedCompareExchange@12     @342 NONAME
                              _DbgSHLWAPI_346@12                      @346 NONAME
                              _RegDeleteValueW@8                   @347 NONAME
 
+                             _DbgSHLWAPI_350@8                       @350 NONAME
+                             _DbgSHLWAPI_351@16                      @351 NONAME
+                             _DbgSHLWAPI_352@16                      @352 NONAME
                              _DbgSHLWAPI_356@12                      @356 NONAME
                              _DbgSHLWAPI_357@20                      @357 NONAME
@@ -342 +347 @@
 
                              _DbgSHLWAPI_413@4                       @413 NONAME
+                             _DbgSHLWAPI_418@4                       @418 NONAME
 
                              _TrackPopupMenuEx@24                 @428 NONAME
@@ -349 +355 @@
                              _SendMessageTimeoutW@28              @434 NONAME
 
+                             _DbgSHLWAPI_436@8                       @436 NONAME
                              _DbgSHLWAPI_437@4                       @437 NONAME
 
@@ -356 +363 @@
     ColorRGBToHLS          = _DbgColorRGBToHLS@16                    @445
 
-    DllGetVersion          = _DbgSHLWAPI_DllGetVersion@4             @446
-    GetMenuPosFromID       = _DbgGetMenuPosFromID@8                  @447
-    HashData               = _DbgHashData@16                         @448
-  ; IntlStrEqWorkerA       = _DbgStrIsIntlEqualA@16                  @449
-  ; IntlStrEqWorkerW       = _DbgStrIsIntlEqualw@16                  @450
-    PathAddBackslashA      = _DbgPathAddBackslashA@4                 @451
-    PathAddBackslashW      = _DbgPathAddBackslashW@4                 @452
-    PathAddExtensionA      = _DbgPathAddExtensionA@8                 @453
-    PathAddExtensionW      = _DbgPathAddExtensionW@8                 @454
-    PathAppendA            = _DbgPathAppendA@8                       @455
-    PathAppendW            = _DbgPathAppendW@8                       @456
-    PathBuildRootA         = _DbgPathBuildRootA@8                    @457
-    PathBuildRootW         = _DbgPathBuildRootW@8                    @458
-    PathCanonicalizeA      = _DbgPathCanonicalizeA@8                 @459
-    PathCanonicalizeW      = _DbgPathCanonicalizeW@8                 @460
-    PathCombineA           = _DbgPathCombineA@12                     @461
-    PathCombineW           = _DbgPathCombineW@12                     @462
-    PathCommonPrefixA      = _DbgPathCommonPrefixA@12                @463
-    PathCommonPrefixW      = _DbgPathCommonPrefixW@12                @464
-    PathCompactPathA       = _DbgPathCompactPathA@12                 @465
-    PathCompactPathExA     = _DbgPathCompactPathExA@16               @466
-    PathCompactPathExW     = _DbgPathCompactPathExW@16               @467
-    PathCompactPathW       = _DbgPathCompactPathW@12                 @468
-    PathCreateFromUrlA     = _DbgPathCreateFromUrlA@16               @469
-    PathCreateFromUrlW     = _DbgPathCreateFromUrlW@16               @470
-    PathFileExistsA        = _DbgPathFileExistsA@4                   @471
-    PathFileExistsW        = _DbgPathFileExistsW@4                   @472
-    PathFindExtensionA     = _DbgPathFindExtensionA@4                @473
-    PathFindExtensionW     = _DbgPathFindExtensionW@4                @474
-    PathFindFileNameA      = _DbgPathFindFileNameA@4                 @475
-    PathFindFileNameW      = _DbgPathFindFileNameW@4                 @476
-    PathFindNextComponentA = _DbgPathFindNextComponentA@4            @477
-    PathFindNextComponentW = _DbgPathFindNextComponentW@4            @478
-    PathFindOnPathA        = _DbgPathFindOnPathA@8                   @479
-    PathFindOnPathW        = _DbgPathFindOnPathW@8                   @480
-;   PathFindSuffixArrayA   = _DbgPathFindSuffixArrayA@12             @481
-;   PathFindSuffixArrayW   = _DbgPathFindSuffixArrayW@12             @482
-    PathGetArgsA           = _DbgPathGetArgsA@4                      @483
-    PathGetArgsW           = _DbgPathGetArgsW@4                      @484
-    PathGetCharTypeA       = _DbgPathGetCharTypeA@4                  @485
-    PathGetCharTypeW       = _DbgPathGetCharTypeW@4                  @486
-    PathGetDriveNumberA    = _DbgPathGetDriveNumberA@4               @487
-    PathGetDriveNumberW    = _DbgPathGetDriveNumberW@4               @488
-    PathIsContentTypeA     = _DbgPathIsContentTypeA@8                @489
-    PathIsContentTypeW     = _DbgPathIsContentTypeW@8                @490
-    PathIsDirectoryA       = _DbgPathIsDirectoryA@4                  @491
-;   PathIsDirectoryEmptyA  = _DbgPathIsDirectoryEmptyA@4             @492
-;   PathIsDirectoryEmptyW  = _DbgPathIsDirectoryEmptyW@4             @493
-    PathIsDirectoryW       = _DbgPathIsDirectoryW@4                  @494
-    PathIsFileSpecA        = _DbgPathIsFileSpecA@4                   @495
-    PathIsFileSpecW        = _DbgPathIsFileSpecW@4                   @496
-;   PathIsLFNFileSpecA     = _DbgPathIsLFNFileSpecA@4                @497
-;   PathIsLFNFileSpecW     = _DbgPathIsLFNFileSpecW@4                @498
-;   PathIsNetworkPathA     = _DbgPathIsNetworkPathA@4                @499
-;   PathIsNetworkPathW     = _DbgPathIsNetworkPathW@4                @500
-    PathIsPrefixA          = _DbgPathIsPrefixA@8                     @501
-    PathIsPrefixW          = _DbgPathIsPrefixW@8                     @502
-    PathIsRelativeA        = _DbgPathIsRelativeA@4                   @503
-    PathIsRelativeW        = _DbgPathIsRelativeW@4                   @504
-    PathIsRootA            = _DbgPathIsRootA@4                       @505
-    PathIsRootW            = _DbgPathIsRootW@4                       @506
-    PathIsSameRootA        = _DbgPathIsSameRootA@8                   @507
-    PathIsSameRootW        = _DbgPathIsSameRootW@8                   @508
-    PathIsSystemFolderA    = _DbgPathIsSystemFolderA@8               @509
-    PathIsSystemFolderW    = _DbgPathIsSystemFolderW@8               @510
-    PathIsUNCA             = _DbgPathIsUNCA@4                        @511
-    PathIsUNCServerA       = _DbgPathIsUNCServerA@4                  @512
-    PathIsUNCServerShareA  = _DbgPathIsUNCServerShareA@4             @513
-    PathIsUNCServerShareW  = _DbgPathIsUNCServerShareW@4             @514
-    PathIsUNCServerW       = _DbgPathIsUNCServerW@4                  @515
-    PathIsUNCW             = _DbgPathIsUNCW@4                        @516
-    PathIsURLA             = _DbgPathIsURLA@4                        @517
-    PathIsURLW             = _DbgPathIsURLW@4                        @518
-    PathMakePrettyA        = _DbgPathMakePrettyA@4                   @519
-    PathMakePrettyW        = _DbgPathMakePrettyW@4                   @520
-    PathMakeSystemFolderA  = _DbgPathMakeSystemFolderA@4             @521
-    PathMakeSystemFolderW  = _DbgPathMakeSystemFolderW@4             @522
-    PathMatchSpecA         = _DbgPathMatchSpecA@8                    @523
-    PathMatchSpecW         = _DbgPathMatchSpecW@8                    @524
-    PathParseIconLocationA = _DbgPathParseIconLocationA@4            @525
-    PathParseIconLocationW = _DbgPathParseIconLocationW@4            @526
-    PathQuoteSpacesA       = _DbgPathQuoteSpacesA@4                  @527
-    PathQuoteSpacesW       = _DbgPathQuoteSpacesW@4                  @528
-    PathRelativePathToA    = _DbgPathRelativePathToA@20              @529
-    PathRelativePathToW    = _DbgPathRelativePathToW@20              @530
-    PathRemoveArgsA        = _DbgPathRemoveArgsA@4                   @531
-    PathRemoveArgsW        = _DbgPathRemoveArgsW@4                   @532
-    PathRemoveBackslashA   = _DbgPathRemoveBackslashA@4              @533
-    PathRemoveBackslashW   = _DbgPathRemoveBackslashW@4              @534
-    PathRemoveBlanksA      = _DbgPathRemoveBlanksA@4                 @535
-    PathRemoveBlanksW      = _DbgPathRemoveBlanksW@4                 @536
-    PathRemoveExtensionA   = _DbgPathRemoveExtensionA@4              @537
-    PathRemoveExtensionW   = _DbgPathRemoveExtensionW@4              @538
-    PathRemoveFileSpecA    = _DbgPathRemoveFileSpecA@4               @539
-    PathRemoveFileSpecW    = _DbgPathRemoveFileSpecW@4               @540
-    PathRenameExtensionA   = _DbgPathRenameExtensionA@8              @541
-    PathRenameExtensionW   = _DbgPathRenameExtensionW@8              @542
-    PathSearchAndQualifyA  = _DbgPathSearchAndQualifyA@12            @543
-    PathSearchAndQualifyW  = _DbgPathSearchAndQualifyW@12            @544
-    PathSetDlgItemPathA    = _DbgPathSetDlgItemPathA@12              @545
-    PathSetDlgItemPathW    = _DbgPathSetDlgItemPathW@12              @546
-    PathSkipRootA          = _DbgPathSkipRootA@4                     @547
-    PathSkipRootW          = _DbgPathSkipRootW@4                     @548
-    PathStripPathA         = _DbgPathStripPathA@4                    @549
-    PathStripPathW         = _DbgPathStripPathW@4                    @550
-    PathStripToRootA       = _DbgPathStripToRootA@4                  @551
-    PathStripToRootW       = _DbgPathStripToRootW@4                  @552
-;   PathUndecorateA        = _DbgPathUndecorateA@4                   @553
-;   PathUndecorateW        = _DbgPathUndecorateW@4                   @554
-    PathUnmakeSystemFolderA= _DbgPathUnmakeSystemFolderA@4           @555
-    PathUnmakeSystemFolderW= _DbgPathUnmakeSystemFolderW@4           @556
-    PathUnquoteSpacesA     = _DbgPathUnquoteSpacesA@4                @557
-    PathUnquoteSpacesW     = _DbgPathUnquoteSpacesW@4                @558
-
-;   SHAutoComplete         = _DbgSHAutoComplete@8                    @559
-  ; SHCopyKeyA             = _DbgSHCopyKeyA@?                        @560
-  ; SHCopyKeyW             = _DbgSHCopyKeyW@?                        @561
-    SHCreateShellPalette   = _DbgSHCreateShellPalette@4              @562
-  ; SHCreateStreamOnFileA  = _DbgSHCreateStreamOnFileA@?             @563
-  ; SHCreateStreamOnFileW  = _DbgSHCreateStreamOnFileW@?             @564
-  ; SHCreateStreamWrapper  = _DbgSHCreateStreamWrapper@?             @565
-
-    SHDeleteEmptyKeyA      = _DbgSHDeleteEmptyKeyA@8                 @567
-    SHDeleteEmptyKeyW      = _DbgSHDeleteEmptyKeyW@8                 @568
-    SHDeleteKeyA           = _DbgSHDeleteKeyA@8                      @569
-    SHDeleteKeyW           = _DbgSHDeleteKeyW@8                      @570
-    SHDeleteOrphanKeyA     = _DbgSHDeleteOrphanKeyA@8                @571
-    SHDeleteOrphanKeyW     = _DbgSHDeleteOrphanKeyW@8                @572
-    SHDeleteValueA         = _DbgSHDeleteValueA@12                   @573
-    SHDeleteValueW         = _DbgSHDeleteValueW@12                   @574
-    SHEnumKeyExA           = _DbgSHEnumKeyExA@16                     @575
-    SHEnumKeyExW           = _DbgSHEnumKeyExW@16                     @576
-    SHEnumValueA           = _DbgSHEnumValueA@28                     @577
-    SHEnumValueW           = _DbgSHEnumValueW@28                     @578
-    _SHGetInstanceExplorer = _Dbg_SHGetInstanceExplorer@4            @579
-    SHGetInverseCMAP       = _DbgSHGetInverseCMAP@8                  @580
-;   SHGetThreadRef         = _DbgSHGetThreadRef@?                    @581
-    SHGetValueA            = _DbgSHGetValueA@24                      @582
-    SHGetValueW            = _DbgSHGetValueW@24                      @583
-    SHIsLowMemoryMachine   = _DbgSHIsLowMemoryMachine@4              @584
-    SHOpenRegStream2A      = _DbgSHOpenRegStreamA@16                 @585
-    SHOpenRegStream2W      = _DbgSHOpenRegStreamW@16                 @586
-    SHOpenRegStreamA       = _DbgSHOpenRegStreamA@16                 @587
-    SHOpenRegStreamW       = _DbgSHOpenRegStreamW@16                 @588
-    SHQueryInfoKeyA        = _DbgSHQueryInfoKeyA@20                  @589
-    SHQueryInfoKeyW        = _DbgSHQueryInfoKeyW@20                  @590
-    SHQueryValueExA        = _DbgSHQueryValueExA@24                  @591
-    SHQueryValueExW        = _DbgSHQueryValueExW@24                  @592
-    SHRegCloseUSKey        = _DbgSHRegCloseUSKey@4                   @593
-    SHRegCreateUSKeyA      = _DbgSHRegCreateUSKeyA@20                @594
-    SHRegCreateUSKeyW      = _DbgSHRegCreateUSKeyW@20                @595
-    SHRegDeleteEmptyUSKeyA = _DbgSHRegDeleteEmptyUSKeyA@12           @596
-    SHRegDeleteEmptyUSKeyW = _DbgSHRegDeleteEmptyUSKeyW@12           @597
-    SHRegDeleteUSKeyA      = _DbgSHRegDeleteUSKeyA@12                @598
-    SHRegDeleteUSKeyW      = _DbgSHRegDeleteUSKeyW@12                @599
-  ; SHRegDuplicateHKey     = _DbgSHRegDuplicateHKey@?                @600
-    SHRegEnumUSKeyA        = _DbgSHRegEnumUSKeyA@20                  @601
-    SHRegEnumUSKeyW        = _DbgSHRegEnumUSKeyW@20                  @602
-    SHRegEnumUSValueA      = _DbgSHRegEnumUSValueA@32                @603
-    SHRegEnumUSValueW      = _DbgSHRegEnumUSValueW@32                @604
-    SHRegGetBoolUSValueA   = _DbgSHRegGetBoolUSValueA@16             @605
-    SHRegGetBoolUSValueW   = _DbgSHRegGetBoolUSValueW@16             @606
-    SHRegGetUSValueA       = _DbgSHRegGetUSValueA@32                 @607
-    SHRegGetUSValueW       = _DbgSHRegGetUSValueW@32                 @608
-    SHRegOpenUSKeyA        = _DbgSHRegOpenUSKeyA@20                  @609
-    SHRegOpenUSKeyW        = _DbgSHRegOpenUSKeyW@20                  @610
-;    SHRegQueryInfoKeyA     = _DbgSHRegQueryInfoKeyA@24               @611
-;    SHRegQueryInfoKeyW     = _DbgSHRegQueryInfoKeyW@24               @612
-    SHRegQueryUSValueA     = _DbgSHRegQueryUSValueA@32               @613
-    SHRegQueryUSValueW     = _DbgSHRegQueryUSValueW@32               @614
-    SHRegSetUSValueA       = _DbgSHRegSetUSValueA@24                 @615
-    SHRegSetUSValueW       = _DbgSHRegSetUSValueW@24                 @616
-    SHRegWriteUSValueA     = _DbgSHRegWriteUSValueA@24               @617
-    SHRegWriteUSValueW     = _DbgSHRegWriteUSValueW@24               @618
-;   SHSetSetThreadRef      = _DbgSHSetThreadRef@?                    @619
-    SHSetValueA            = _DbgSHSetValueA@24                      @620
-    SHSetValueW            = _DbgSHSetValueW@24                      @621
-;   SHSkipJunction         = _DbgSHSkipJunction@8                    @622
-;   SHStrDupA              = _DbgSHStrDupA@?                         @623
-;   SHStrDupW              = _DbgSHStrDUpW@?                         @624
-    StrCSpnA               = _DbgStrCSpnA@8                          @625
-  ; StrCSpnIA              = _DbgStrCSpnIA@?                         @626
-  ; StrCSpnIW              = _DbgStrCSpnIW@?                         @627
-    StrCSpnW               = _DbgStrCSpnW@8                          @628
-    StrCatBuffA            = _DbgStrCatBuffA@12                      @629
-    StrCatBuffW            = _DbgStrCatBuffW@12                      @630
+    DllGetVersion          = _DbgSHLWAPI_DllGetVersion@4             @1046
+    GetMenuPosFromID       = _DbgGetMenuPosFromID@8                  @1047
+    HashData               = _DbgHashData@16                         @1048
+  ; IntlStrEqWorkerA       = _DbgStrIsIntlEqualA@16                  @1049
+  ; IntlStrEqWorkerW       = _DbgStrIsIntlEqualw@16                  @1050
+    PathAddBackslashA      = _DbgPathAddBackslashA@4                 @1051
+    PathAddBackslashW      = _DbgPathAddBackslashW@4                 @1052
+    PathAddExtensionA      = _DbgPathAddExtensionA@8                 @1053
+    PathAddExtensionW      = _DbgPathAddExtensionW@8                 @1054
+    PathAppendA            = _DbgPathAppendA@8                       @1055
+    PathAppendW            = _DbgPathAppendW@8                       @1056
+    PathBuildRootA         = _DbgPathBuildRootA@8                    @1057
+    PathBuildRootW         = _DbgPathBuildRootW@8                    @1058
+    PathCanonicalizeA      = _DbgPathCanonicalizeA@8                 @1059
+    PathCanonicalizeW      = _DbgPathCanonicalizeW@8                 @1060
+    PathCombineA           = _DbgPathCombineA@12                     @1061
+    PathCombineW           = _DbgPathCombineW@12                     @1062
+    PathCommonPrefixA      = _DbgPathCommonPrefixA@12                @1063
+    PathCommonPrefixW      = _DbgPathCommonPrefixW@12                @1064
+    PathCompactPathA       = _DbgPathCompactPathA@12                 @1065
+    PathCompactPathExA     = _DbgPathCompactPathExA@16               @1066
+    PathCompactPathExW     = _DbgPathCompactPathExW@16               @1067
+    PathCompactPathW       = _DbgPathCompactPathW@12                 @1068
+    PathCreateFromUrlA     = _DbgPathCreateFromUrlA@16               @1069
+    PathCreateFromUrlW     = _DbgPathCreateFromUrlW@16               @1070
+    PathFileExistsA        = _DbgPathFileExistsA@4                   @1071
+    PathFileExistsW        = _DbgPathFileExistsW@4                   @1072
+    PathFindExtensionA     = _DbgPathFindExtensionA@4                @1073
+    PathFindExtensionW     = _DbgPathFindExtensionW@4                @1074
+    PathFindFileNameA      = _DbgPathFindFileNameA@4                 @1075
+    PathFindFileNameW      = _DbgPathFindFileNameW@4                 @1076
+    PathFindNextComponentA = _DbgPathFindNextComponentA@4            @1077
+    PathFindNextComponentW = _DbgPathFindNextComponentW@4            @1078
+    PathFindOnPathA        = _DbgPathFindOnPathA@8                   @1079
+    PathFindOnPathW        = _DbgPathFindOnPathW@8                   @1080
+    PathFindSuffixArrayA   = _DbgPathFindSuffixArrayA@12             @1081
+    PathFindSuffixArrayW   = _DbgPathFindSuffixArrayW@12             @1082
+    PathGetArgsA           = _DbgPathGetArgsA@4                      @1083
+    PathGetArgsW           = _DbgPathGetArgsW@4                      @1084
+    PathGetCharTypeA       = _DbgPathGetCharTypeA@4                  @1085
+    PathGetCharTypeW       = _DbgPathGetCharTypeW@4                  @1086
+    PathGetDriveNumberA    = _DbgPathGetDriveNumberA@4               @1087
+    PathGetDriveNumberW    = _DbgPathGetDriveNumberW@4               @1088
+    PathIsContentTypeA     = _DbgPathIsContentTypeA@8                @1089
+    PathIsContentTypeW     = _DbgPathIsContentTypeW@8                @1090
+    PathIsDirectoryA       = _DbgPathIsDirectoryA@4                  @1091
+    PathIsDirectoryEmptyA  = _DbgPathIsDirectoryEmptyA@4             @1092
+    PathIsDirectoryEmptyW  = _DbgPathIsDirectoryEmptyW@4             @1093
+    PathIsDirectoryW       = _DbgPathIsDirectoryW@4                  @1094
+    PathIsFileSpecA        = _DbgPathIsFileSpecA@4                   @1095
+    PathIsFileSpecW        = _DbgPathIsFileSpecW@4                   @1096
+    PathIsLFNFileSpecA     = _DbgPathIsLFNFileSpecA@4                @1097
+    PathIsLFNFileSpecW     = _DbgPathIsLFNFileSpecW@4                @1098
+    PathIsNetworkPathA     = _DbgPathIsNetworkPathA@4                @1099
+    PathIsNetworkPathW     = _DbgPathIsNetworkPathW@4                @1100
+    PathIsPrefixA          = _DbgPathIsPrefixA@8                     @1101
+    PathIsPrefixW          = _DbgPathIsPrefixW@8                     @1102
+    PathIsRelativeA        = _DbgPathIsRelativeA@4                   @1103
+    PathIsRelativeW        = _DbgPathIsRelativeW@4                   @1104
+    PathIsRootA            = _DbgPathIsRootA@4                       @1105
+    PathIsRootW            = _DbgPathIsRootW@4                       @1106
+    PathIsSameRootA        = _DbgPathIsSameRootA@8                   @1107
+    PathIsSameRootW        = _DbgPathIsSameRootW@8                   @1108
+    PathIsSystemFolderA    = _DbgPathIsSystemFolderA@8               @1109
+    PathIsSystemFolderW    = _DbgPathIsSystemFolderW@8               @1110
+    PathIsUNCA             = _DbgPathIsUNCA@4                        @1111
+    PathIsUNCServerA       = _DbgPathIsUNCServerA@4                  @1112
+    PathIsUNCServerShareA  = _DbgPathIsUNCServerShareA@4             @1113
+    PathIsUNCServerShareW  = _DbgPathIsUNCServerShareW@4             @1114
+    PathIsUNCServerW       = _DbgPathIsUNCServerW@4                  @1115
+    PathIsUNCW             = _DbgPathIsUNCW@4                        @1116
+    PathIsURLA             = _DbgPathIsURLA@4                        @1117
+    PathIsURLW             = _DbgPathIsURLW@4                        @1118
+    PathMakePrettyA        = _DbgPathMakePrettyA@4                   @1119
+    PathMakePrettyW        = _DbgPathMakePrettyW@4                   @1120
+    PathMakeSystemFolderA  = _DbgPathMakeSystemFolderA@4             @1121
+    PathMakeSystemFolderW  = _DbgPathMakeSystemFolderW@4             @1122
+    PathMatchSpecA         = _DbgPathMatchSpecA@8                    @1123
+    PathMatchSpecW         = _DbgPathMatchSpecW@8                    @1124
+    PathParseIconLocationA = _DbgPathParseIconLocationA@4            @1125
+    PathParseIconLocationW = _DbgPathParseIconLocationW@4            @1126
+    PathQuoteSpacesA       = _DbgPathQuoteSpacesA@4                  @1127
+    PathQuoteSpacesW       = _DbgPathQuoteSpacesW@4                  @1128
+    PathRelativePathToA    = _DbgPathRelativePathToA@20              @1129
+    PathRelativePathToW    = _DbgPathRelativePathToW@20              @1130
+    PathRemoveArgsA        = _DbgPathRemoveArgsA@4                   @1131
+    PathRemoveArgsW        = _DbgPathRemoveArgsW@4                   @1132
+    PathRemoveBackslashA   = _DbgPathRemoveBackslashA@4              @1133
+    PathRemoveBackslashW   = _DbgPathRemoveBackslashW@4              @1134
+    PathRemoveBlanksA      = _DbgPathRemoveBlanksA@4                 @1135
+    PathRemoveBlanksW      = _DbgPathRemoveBlanksW@4                 @1136
+    PathRemoveExtensionA   = _DbgPathRemoveExtensionA@4              @1137
+    PathRemoveExtensionW   = _DbgPathRemoveExtensionW@4              @1138
+    PathRemoveFileSpecA    = _DbgPathRemoveFileSpecA@4               @1139
+    PathRemoveFileSpecW    = _DbgPathRemoveFileSpecW@4               @1140
+    PathRenameExtensionA   = _DbgPathRenameExtensionA@8              @1141
+    PathRenameExtensionW   = _DbgPathRenameExtensionW@8              @1142
+    PathSearchAndQualifyA  = _DbgPathSearchAndQualifyA@12            @1143
+    PathSearchAndQualifyW  = _DbgPathSearchAndQualifyW@12            @1144
+    PathSetDlgItemPathA    = _DbgPathSetDlgItemPathA@12              @1145
+    PathSetDlgItemPathW    = _DbgPathSetDlgItemPathW@12              @1146
+    PathSkipRootA          = _DbgPathSkipRootA@4                     @1147
+    PathSkipRootW          = _DbgPathSkipRootW@4                     @1148
+    PathStripPathA         = _DbgPathStripPathA@4                    @1149
+    PathStripPathW         = _DbgPathStripPathW@4                    @1150
+    PathStripToRootA       = _DbgPathStripToRootA@4                  @1151
+    PathStripToRootW       = _DbgPathStripToRootW@4                  @1152
+    PathUndecorateA        = _DbgPathUndecorateA@4                   @1153
+    PathUndecorateW        = _DbgPathUndecorateW@4                   @1154
+    PathUnmakeSystemFolderA= _DbgPathUnmakeSystemFolderA@4           @1155
+    PathUnmakeSystemFolderW= _DbgPathUnmakeSystemFolderW@4           @1156
+    PathUnquoteSpacesA     = _DbgPathUnquoteSpacesA@4                @1157
+    PathUnquoteSpacesW     = _DbgPathUnquoteSpacesW@4                @1158
+
+;   SHAutoComplete         = _DbgSHAutoComplete@8                    @1159
+  ; SHCopyKeyA             = _DbgSHCopyKeyA@?                        @1160
+  ; SHCopyKeyW             = _DbgSHCopyKeyW@?                        @1161
+    SHCreateShellPalette   = _DbgSHCreateShellPalette@4              @1162
+  ; SHCreateStreamOnFileA  = _DbgSHCreateStreamOnFileA@?             @1163
+  ; SHCreateStreamOnFileW  = _DbgSHCreateStreamOnFileW@?             @1164
+  ; SHCreateStreamWrapper  = _DbgSHCreateStreamWrapper@?             @1165
+
+    SHDeleteEmptyKeyA      = _DbgSHDeleteEmptyKeyA@8                 @1167
+    SHDeleteEmptyKeyW      = _DbgSHDeleteEmptyKeyW@8                 @1168
+    SHDeleteKeyA           = _DbgSHDeleteKeyA@8                      @1169
+    SHDeleteKeyW           = _DbgSHDeleteKeyW@8                      @1170
+    SHDeleteOrphanKeyA     = _DbgSHDeleteOrphanKeyA@8                @1171
+    SHDeleteOrphanKeyW     = _DbgSHDeleteOrphanKeyW@8                @1172
+    SHDeleteValueA         = _DbgSHDeleteValueA@12                   @1173
+    SHDeleteValueW         = _DbgSHDeleteValueW@12                   @1174
+    SHEnumKeyExA           = _DbgSHEnumKeyExA@16                     @1175
+    SHEnumKeyExW           = _DbgSHEnumKeyExW@16                     @1176
+    SHEnumValueA           = _DbgSHEnumValueA@28                     @1177
+    SHEnumValueW           = _DbgSHEnumValueW@28                     @1178
+    _SHGetInstanceExplorer = _Dbg_SHGetInstanceExplorer@4            @1179
+    SHGetInverseCMAP       = _DbgSHGetInverseCMAP@8                  @1180
+    SHGetThreadRef         = _DbgSHGetThreadRef@4                    @1181
+    SHGetValueA            = _DbgSHGetValueA@24                      @1182
+    SHGetValueW            = _DbgSHGetValueW@24                      @1183
+    SHIsLowMemoryMachine   = _DbgSHIsLowMemoryMachine@4              @1184
+    SHOpenRegStream2A      = _DbgSHOpenRegStreamA@16                 @1185
+    SHOpenRegStream2W      = _DbgSHOpenRegStreamW@16                 @1186
+    SHOpenRegStreamA       = _DbgSHOpenRegStreamA@16                 @1187
+    SHOpenRegStreamW       = _DbgSHOpenRegStreamW@16                 @1188
+    SHQueryInfoKeyA        = _DbgSHQueryInfoKeyA@20                  @1189
+    SHQueryInfoKeyW        = _DbgSHQueryInfoKeyW@20                  @1190
+    SHQueryValueExA        = _DbgSHQueryValueExA@24                  @1191
+    SHQueryValueExW        = _DbgSHQueryValueExW@24                  @1192
+    SHRegCloseUSKey        = _DbgSHRegCloseUSKey@4                   @1193
+    SHRegCreateUSKeyA      = _DbgSHRegCreateUSKeyA@20                @1194
+    SHRegCreateUSKeyW      = _DbgSHRegCreateUSKeyW@20                @1195
+    SHRegDeleteEmptyUSKeyA = _DbgSHRegDeleteEmptyUSKeyA@12           @1196
+    SHRegDeleteEmptyUSKeyW = _DbgSHRegDeleteEmptyUSKeyW@12           @1197
+    SHRegDeleteUSKeyA      = _DbgSHRegDeleteUSKeyA@12                @1198
+    SHRegDeleteUSKeyW      = _DbgSHRegDeleteUSKeyW@12                @1199
+    SHRegDuplicateHKey     = _DbgSHRegDuplicateHKey@4                @1200
+    SHRegEnumUSKeyA        = _DbgSHRegEnumUSKeyA@20                  @1201
+    SHRegEnumUSKeyW        = _DbgSHRegEnumUSKeyW@20                  @1202
+    SHRegEnumUSValueA      = _DbgSHRegEnumUSValueA@32                @1203
+    SHRegEnumUSValueW      = _DbgSHRegEnumUSValueW@32                @1204
+    SHRegGetBoolUSValueA   = _DbgSHRegGetBoolUSValueA@16             @1205
+    SHRegGetBoolUSValueW   = _DbgSHRegGetBoolUSValueW@16             @1206
+    SHRegGetUSValueA       = _DbgSHRegGetUSValueA@32                 @1207
+    SHRegGetUSValueW       = _DbgSHRegGetUSValueW@32                 @1208
+    SHRegOpenUSKeyA        = _DbgSHRegOpenUSKeyA@20                  @1209
+    SHRegOpenUSKeyW        = _DbgSHRegOpenUSKeyW@20                  @1210
+;    SHRegQueryInfoKeyA     = _DbgSHRegQueryInfoKeyA@24               @1211
+;    SHRegQueryInfoKeyW     = _DbgSHRegQueryInfoKeyW@24               @1212
+    SHRegQueryUSValueA     = _DbgSHRegQueryUSValueA@32               @1213
+    SHRegQueryUSValueW     = _DbgSHRegQueryUSValueW@32               @1214
+    SHRegSetUSValueA       = _DbgSHRegSetUSValueA@24                 @1215
+    SHRegSetUSValueW       = _DbgSHRegSetUSValueW@24                 @1216
+    SHRegWriteUSValueA     = _DbgSHRegWriteUSValueA@24               @1217
+    SHRegWriteUSValueW     = _DbgSHRegWriteUSValueW@24               @1218
+    SHSetSetThreadRef      = _DbgSHSetThreadRef@4                    @1219
+    SHSetValueA            = _DbgSHSetValueA@24                      @1220
+    SHSetValueW            = _DbgSHSetValueW@24                      @1221
+;   SHSkipJunction         = _DbgSHSkipJunction@8                    @1222
+;   SHStrDupA              = _DbgSHStrDupA@?                         @1223
+;   SHStrDupW              = _DbgSHStrDUpW@?                         @1224
+    StrCSpnA               = _DbgStrCSpnA@8                          @1225
+  ; StrCSpnIA              = _DbgStrCSpnIA@?                         @1226
+  ; StrCSpnIW              = _DbgStrCSpnIW@?                         @1227
+    StrCSpnW               = _DbgStrCSpnW@8                          @1228
+    StrCatBuffA            = _DbgStrCatBuffA@12                      @1229
+    StrCatBuffW            = _DbgStrCatBuffW@12                      @1230
 ;    StrCatA                = _DbgStrCatA@8                                 ; not exported ?
-    StrCatW                = _DbgStrCatW@8                           @631
-    StrChrA                = _DbgStrChrA@8                           @632
-    StrChrIA               = _DbgStrChrIA@8                          @633
-    StrChrIW               = _DbgStrChrIW@8                          @634
-    StrChrW                = _DbgStrChrW@8                           @635
-    StrCmpIW               = _lstrcmpiW@8                         @636
-    StrCmpNA               = _DbgStrCmpNA@12                         @637
-    StrCmpNIA              = _DbgStrCmpNIA@12                        @638
-    StrCmpNIW              = _DbgStrCmpNIW@12                        @639
-    StrCmpNW               = _DbgStrCmpNW@12                         @640
-    StrCmpW                = _lstrcmpW@8                          @641
-    StrCpyNW               = _lstrcpynW@12                        @642
+    StrCatW                = _DbgStrCatW@8                           @1231
+    StrChrA                = _DbgStrChrA@8                           @1232
+    StrChrIA               = _DbgStrChrIA@8                          @1233
+    StrChrIW               = _DbgStrChrIW@8                          @1234
+    StrChrW                = _DbgStrChrW@8                           @1235
+    StrCmpIW               = _lstrcmpiW@8                         @1236
+    StrCmpNA               = _DbgStrCmpNA@12                         @1237
+    StrCmpNIA              = _DbgStrCmpNIA@12                        @1238
+    StrCmpNIW              = _DbgStrCmpNIW@12                        @1239
+    StrCmpNW               = _DbgStrCmpNW@12                         @1240
+    StrCmpW                = _lstrcmpW@8                          @1241
+    StrCpyNW               = _lstrcpynW@12                        @1242
 ;;;    StrCpyA                = _DbgStrCpyA@8                                 ; not exported ?
-    StrCpyW                = _DbgStrCpyW@8                           @643
-    StrDupA                = _DbgStrDupA@4                           @644
-    StrDupW                = _DbgStrDupW@4                           @645
-;   StrFormatByteSize64A   = _DbgStrFormatByteSize64A@16             @646
-    StrFormatByteSizeA     = _DbgStrFormatByteSizeA@12               @647
-    StrFormatByteSizeW     = _DbgStrFormatByteSizeW@12               @648
-;   StrFormatKBSizeA       = _DbgStrFormatKBSizeA@16                 @649
-;   StrFormatKBSizeW       = _DbgStrFormatKBSizeW@16                 @650
-    StrFromTimeIntervalA   = _DbgStrFromTimeIntervalA@16             @651
-    StrFromTimeIntervalW   = _DbgStrFromTimeIntervalW@16             @652
-  ; IntlStrEqWorkerA       = _DbgStrIsIntlEqualA@16                  @653
-  ; StrIsIntlEqualW        = _DbgStrIsIntlEqualW@?                   @654
-    StrNCatA               = _DbgStrNCatA@12                         @655
-    StrNCatW               = _DbgStrNCatW@12                         @656
-    StrPBrkA               = _DbgStrPBrkA@8                          @657
-    StrPBrkW               = _DbgStrPBrkW@8                          @658
-    StrRChrA               = _DbgStrRChrA@12                         @659
-    StrRChrIA              = _DbgStrRChrIA@12                        @660
-    StrRChrIW              = _DbgStrRChrIW@12                        @661
-    StrRChrW               = _DbgStrRChrW@12                         @662
-    StrRStrIA              = _DbgStrRStrIA@12                        @663
-    StrRStrIW              = _DbgStrRStrIW@12                        @664
-    StrRetToBufA           = _DbgStrRetToBufA@16                     @665
-    StrRetToBufW           = _DbgStrRetToBufW@16                     @666
-;   StrRetToStrA           = _DbgStrRetToStrA@12                     @667
-;   StrRetToStrW           = _DbgStrRetToStrW@12                     @668
-    StrSpnA                = _DbgStrSpnA@8                           @669
-    StrSpnW                = _DbgStrSpnW@8                           @670
-    StrStrA                = _DbgStrStrA@8                           @671
-    StrStrIA               = _DbgStrStrIA@8                          @672
-    StrStrIW               = _DbgStrStrIW@8                          @673
-    StrStrW                = _DbgStrStrW@8                           @674
-    StrToIntA              = _DbgStrToIntA@4                         @675
-    StrToIntExA            = _DbgStrToIntExA@12                      @676
-    StrToIntExW            = _DbgStrToIntExW@12                      @677
-    StrToIntW              = _DbgStrToIntW@4                         @678
-    StrTrimA               = _DbgStrTrimA@8                          @679
-  ; StrTrimW               = _DbgStrTrimW@?                          @680
-    UrlApplySchemeA        = _DbgUrlApplySchemeA@16                  @681
-    UrlApplySchemeW        = _DbgUrlApplySchemeW@16                  @682
-    UrlCanonicalizeA       = _DbgUrlCanonicalizeA@16                 @683
-    UrlCanonicalizeW       = _DbgUrlCanonicalizeW@16                 @684
-    UrlCombineA            = _DbgUrlCombineA@20                      @685
-    UrlCombineW            = _DbgUrlCombineW@20                      @686
-    UrlCompareA            = _DbgUrlCompareA@12                      @687
-    UrlCompareW            = _DbgUrlCompareW@12                      @688
-    UrlCreateFromPathA     = _DbgUrlCreateFromPathA@16               @689
-    UrlCreateFromPathW     = _DbgUrlCreateFromPathW@16               @690
-    UrlEscapeA             = _DbgUrlEscapeA@16                       @691
-    UrlEscapeW             = _DbgUrlEscapeW@16                       @692
-    UrlGetLocationA        = _DbgUrlGetLocationA@4                   @693
-    UrlGetLocationW        = _DbgUrlGetLocationW@4                   @694
-    UrlGetPartA            = _DbgUrlGetPartA@20                      @695
-    UrlGetPartW            = _DbgUrlGetPartW@20                      @696
-    UrlHashA               = _DbgUrlHashA@12                         @697
-    UrlHashW               = _DbgUrlHashW@12                         @698
-    UrlIsA                 = _DbgUrlIsA@8                            @699
-    UrlIsNoHistoryA        = _DbgUrlIsNoHistoryA@4                   @700
-    UrlIsNoHistoryW        = _DbgUrlIsNoHistoryW@4                   @701
-    UrlIsOpaqueA           = _DbgUrlIsOpaqueA@4                      @702
-    UrlIsOpaqueW           = _DbgUrlIsOpaqueW@4                      @703
-    UrlIsW                 = _DbgUrlIsW@8                            @704
-    UrlUnescapeA           = _DbgUrlUnescapeA@16                     @705
-    UrlUnescapeW           = _DbgUrlUnescapeW@16                     @706
-    wnsprintfA             = _wnsprintfA                          @707
-    wnsprintfW             = _wnsprintfW                          @708
-;    wvnsprintfA            = _DbgwvnsprintfA@16                      @709
-;    wvnsprintfW            = _DbgwvnsprintfW@16                      @710
-
-    SHRegGetPathA          = _DbgSHRegGetPathA@20                    @802
-    SHRegGetPathW          = _DbgSHRegGetPathW@20                    @803
-    SHRegDeleteUSValueA    = _DbgSHRegDeleteUSValueA@12
-    SHRegDeleteUSValueW    = _DbgSHRegDeleteUSValueW@12
+    StrCpyW                = _DbgStrCpyW@8                           @1243
+    StrDupA                = _DbgStrDupA@4                           @1244
+    StrDupW                = _DbgStrDupW@4                           @1245
+;   StrFormatByteSize64A   = _DbgStrFormatByteSize64A@16             @1246
+    StrFormatByteSizeA     = _DbgStrFormatByteSizeA@12               @1247
+    StrFormatByteSizeW     = _DbgStrFormatByteSizeW@12               @1248
+;   StrFormatKBSizeA       = _DbgStrFormatKBSizeA@16                 @1249
+;   StrFormatKBSizeW       = _DbgStrFormatKBSizeW@16                 @1250
+    StrFromTimeIntervalA   = _DbgStrFromTimeIntervalA@16             @1251
+    StrFromTimeIntervalW   = _DbgStrFromTimeIntervalW@16             @1252
+  ; IntlStrEqWorkerA       = _DbgStrIsIntlEqualA@16                  @1253
+  ; StrIsIntlEqualW        = _DbgStrIsIntlEqualW@?                   @1254
+    StrNCatA               = _DbgStrNCatA@12                         @1255
+    StrNCatW               = _DbgStrNCatW@12                         @1256
+    StrPBrkA               = _DbgStrPBrkA@8                          @1257
+    StrPBrkW               = _DbgStrPBrkW@8                          @1258
+    StrRChrA               = _DbgStrRChrA@12                         @1259
+    StrRChrIA              = _DbgStrRChrIA@12                        @1260
+    StrRChrIW              = _DbgStrRChrIW@12                        @1261
+    StrRChrW               = _DbgStrRChrW@12                         @1262
+    StrRStrIA              = _DbgStrRStrIA@12                        @1263
+    StrRStrIW              = _DbgStrRStrIW@12                        @1264
+    StrRetToBufA           = _DbgStrRetToBufA@16                     @1265
+    StrRetToBufW           = _DbgStrRetToBufW@16                     @1266
+;   StrRetToStrA           = _DbgStrRetToStrA@12                     @1267
+;   StrRetToStrW           = _DbgStrRetToStrW@12                     @1268
+    StrSpnA                = _DbgStrSpnA@8                           @1269
+    StrSpnW                = _DbgStrSpnW@8                           @1270
+    StrStrA                = _DbgStrStrA@8                           @1271
+    StrStrIA               = _DbgStrStrIA@8                          @1272
+    StrStrIW               = _DbgStrStrIW@8                          @1273
+    StrStrW                = _DbgStrStrW@8                           @1274
+    StrToIntA              = _DbgStrToIntA@4                         @1275
+    StrToIntExA            = _DbgStrToIntExA@12                      @1276
+    StrToIntExW            = _DbgStrToIntExW@12                      @1277
+    StrToIntW              = _DbgStrToIntW@4                         @1278
+    StrTrimA               = _DbgStrTrimA@8                          @1279
+  ; StrTrimW               = _DbgStrTrimW@?                          @1280
+    UrlApplySchemeA        = _DbgUrlApplySchemeA@16                  @1281
+    UrlApplySchemeW        = _DbgUrlApplySchemeW@16                  @1282
+    UrlCanonicalizeA       = _DbgUrlCanonicalizeA@16                 @1283
+    UrlCanonicalizeW       = _DbgUrlCanonicalizeW@16                 @1284
+    UrlCombineA            = _DbgUrlCombineA@20                      @1285
+    UrlCombineW            = _DbgUrlCombineW@20                      @1286
+    UrlCompareA            = _DbgUrlCompareA@12                      @1287
+    UrlCompareW            = _DbgUrlCompareW@12                      @1288
+    UrlCreateFromPathA     = _DbgUrlCreateFromPathA@16               @1289
+    UrlCreateFromPathW     = _DbgUrlCreateFromPathW@16               @1290
+    UrlEscapeA             = _DbgUrlEscapeA@16                       @1291
+    UrlEscapeW             = _DbgUrlEscapeW@16                       @1292
+    UrlGetLocationA        = _DbgUrlGetLocationA@4                   @1293
+    UrlGetLocationW        = _DbgUrlGetLocationW@4                   @1294
+    UrlGetPartA            = _DbgUrlGetPartA@20                      @1295
+    UrlGetPartW            = _DbgUrlGetPartW@20                      @1296
+    UrlHashA               = _DbgUrlHashA@12                         @1297
+    UrlHashW               = _DbgUrlHashW@12                         @1298
+    UrlIsA                 = _DbgUrlIsA@8                            @1299
+    UrlIsNoHistoryA        = _DbgUrlIsNoHistoryA@4                   @1300
+    UrlIsNoHistoryW        = _DbgUrlIsNoHistoryW@4                   @1301
+    UrlIsOpaqueA           = _DbgUrlIsOpaqueA@4                      @1302
+    UrlIsOpaqueW           = _DbgUrlIsOpaqueW@4                      @1303
+    UrlIsW                 = _DbgUrlIsW@8                            @1304
+    UrlUnescapeA           = _DbgUrlUnescapeA@16                     @1305
+    UrlUnescapeW           = _DbgUrlUnescapeW@16                     @1306
+    wnsprintfA             = _wnsprintfA                             @1307
+    wnsprintfW             = _wnsprintfW                             @1308
+    wvnsprintfA            = _DbgwvnsprintfA@16                      @1309
+    wvnsprintfW            = _DbgwvnsprintfW@16                      @1310
+
+;; exported in later versions
+    SHRegGetPathA          = _DbgSHRegGetPathA@20                    @1402
+    SHRegGetPathW          = _DbgSHRegGetPathW@20                    @1403
+    SHRegDeleteUSValueA    = _DbgSHRegDeleteUSValueA@12              @1404
+    SHRegDeleteUSValueW    = _DbgSHRegDeleteUSValueW@12              @1405
+    SHRegSetPathA          = _DbgSHRegSetPathA@20                    @1406
+    SHRegSetPathW          = _DbgSHRegSetPathW@20                    @1407
+    

trunk/src/shlwapi/string.c

@@ +1 @@
+/*
+ * Shlwapi string functions
+ *
+ * Copyright 1998 Juergen Schmied
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 #include <ctype.h>
-#include <stdlib.h> 
+#include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -10 +30 @@
 #include "winuser.h"
 #include "winreg.h"
-#ifdef __WIN32OS2__
-#include "shlobj.h"
-#define NO_SHLWAPI_STREAM
-#include "shlwapi.h"
-#else
 #define NO_SHLWAPI_STREAM
 #include "shlwapi.h"
 #include "shlobj.h"
-#endif
 #include "wine/unicode.h"
-#include "debugtools.h"
-
-DEFAULT_DEBUG_CHANNEL(shell);
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(shell);
 
 /*************************************************************************
@@ -255 +269 @@
         int len = strlen(lpSrc);
         LPSTR lpDest = (LPSTR) LocalAlloc(LMEM_FIXED, len+1);
-        
+
         TRACE("%s\n", lpSrc);
 
@@ -269 +283 @@
         int len = strlenW(lpSrc);
         LPWSTR lpDest = (LPWSTR) LocalAlloc(LMEM_FIXED, sizeof(WCHAR) * (len+1));
-        
+
         TRACE("%s\n", debugstr_w(lpSrc));
 
@@ -295 +309 @@
             }
           }
-        }      
+        }
         TRACE("-- %u\n", pos);
-        return pos;     
+        return pos;
 }
 
@@ -319 +333 @@
             }
           }
-        }      
+        }
         TRACE("-- %u\n", pos);
-        return pos;     
+        return pos;
 }
 
@@ -342 +356 @@
         if (dbcs && lpStart[1] != HIBYTE(wMatch)) continue;
         lpGotIt = lpStart;
-    }    
+    }
     return (LPSTR)lpGotIt;
 }
@@ -390 +404 @@
             if (toupper(*lpStart) == toupper(wMatch)) lpGotIt = lpStart;
         }
-    }    
+    }
     return (LPSTR)lpGotIt;
 }
@@ -452 +466 @@
 /*************************************************************************
  * StrRetToBufA                                 [SHLWAPI.@]
- * 
+ *
  * converts a STRRET to a normal string
  *
@@ -497 +511 @@
 /*************************************************************************
  * StrRetToBufW                                 [SHLWAPI.@]
- * 
+ *
  * converts a STRRET to a normal string
  *
@@ -564 +578 @@
         }
         lstrcpynA (pszBuf, buf, cchBuf);
-        return pszBuf;  
+        return pszBuf;
 }
 
@@ -621 +635 @@
     return trimmed;
 }
-
-/*************************************************************************
- *      wnsprintfA      [SHLWAPI.@]
- */
-int WINAPIV wnsprintfA(LPSTR lpOut, int cchLimitIn, LPCSTR lpFmt, ...)
-{
-    va_list valist;
-    INT res;
-
-    va_start( valist, lpFmt );
-    res = wvsnprintfA( lpOut, cchLimitIn, lpFmt, valist );
-    va_end( valist );
-    return res;
-}
-
-/*************************************************************************
- *      wnsprintfW      [SHLWAPI.@]
- */
-int WINAPIV wnsprintfW(LPWSTR lpOut, int cchLimitIn, LPCWSTR lpFmt, ...)
-{
-    va_list valist;
-    INT res;
-
-    va_start( valist, lpFmt );
-    res = wvsnprintfW( lpOut, cchLimitIn, lpFmt, valist );
-    va_end( valist );
-    return res;
-}

trunk/src/shlwapi/string_odin.cpp

@@ -1 @@
- /* $Id: string_odin.cpp,v 1.7 2002-02-08 10:23:35 sandervl Exp $ */
+ /* $Id: string_odin.cpp,v 1.8 2002-06-07 08:02:20 sandervl Exp $ */
 
 /*
@@ -58 +58 @@
 #include "shellapi.h"
 #include "shlobj.h"
-#include "wine/undocshell.h"
 
 #include "shlwapi_odin.h"

trunk/src/shlwapi/url.c

@@ -3 +3 @@
  *
  * Copyright 2000 Huw D M Davies for CodeWeavers.
- */
-#ifdef __WIN32OS2__
-#include <ctype.h>
-#include <stdarg.h>
-#include <winuser.h>
-#endif
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
 
 #include <string.h>
@@ -21 +30 @@
 #define NO_SHLWAPI_STREAM
 #include "shlwapi.h"
-#include "debugtools.h"
+#include "wine/debug.h"
 #include "ordinal.h"
 
-
-DEFAULT_DEBUG_CHANNEL(shell);
+WINE_DEFAULT_DEBUG_CHANNEL(shell);
 
 typedef struct {
@@ -191 +199 @@
           pcchCanonicalized, dwFlags);
 
-    base = (LPWSTR) HeapAlloc(GetProcessHeap(), 0, 
+    base = (LPWSTR) HeapAlloc(GetProcessHeap(), 0,
                               (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
     canonical = base + INTERNET_MAX_URL_LENGTH;
@@ -210 +218 @@
         return E_POINTER;
     }
-    WideCharToMultiByte(0, 0, canonical, len+1, pszCanonicalized, 
+    WideCharToMultiByte(0, 0, canonical, len+1, pszCanonicalized,
                         *pcchCanonicalized, 0, 0);
     *pcchCanonicalized = len2;
@@ -221 +229 @@
  *
  *
- * MSDN is wrong (at 10/30/01 - go figure). This should support the 
+ * MSDN is wrong (at 10/30/01 - go figure). This should support the
  * following flags:                                      GLA
  *    URL_DONT_ESCAPE_EXTRA_INFO    0x02000000
@@ -231 +239 @@
  *    URL_ESCAPE_SEGMENT_ONLY       0x00002000
  */
-HRESULT WINAPI UrlCanonicalizeW(LPCWSTR pszUrl, LPWSTR pszCanonicalized, 
+HRESULT WINAPI UrlCanonicalizeW(LPCWSTR pszUrl, LPWSTR pszCanonicalized,
                                 LPDWORD pcchCanonicalized, DWORD dwFlags)
 {
@@ -357 +365 @@
         UrlUnescapeW(lpszUrlCpy, NULL, NULL, URL_UNESCAPE_INPLACE);
 
-    if((EscapeFlags = dwFlags & (URL_ESCAPE_UNSAFE | 
+    if((EscapeFlags = dwFlags & (URL_ESCAPE_UNSAFE |
                                  URL_ESCAPE_SPACES_ONLY |
                                  URL_ESCAPE_PERCENT |
@@ -377 +385 @@
 
     HeapFree(GetProcessHeap(), 0, lpszUrlCpy);
-  
+
     if (hr == S_OK)
         TRACE("result %s\n", debugstr_w(pszCanonicalized));
@@ -400 +408 @@
           *pcchCombined,dwFlags);
 
-    base = (LPWSTR) HeapAlloc(GetProcessHeap(), 0, 
+    base = (LPWSTR) HeapAlloc(GetProcessHeap(), 0,
                               (3*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
     relative = base + INTERNET_MAX_URL_LENGTH;
@@ -501 +509 @@
          *    .sizep2   length of location (above) and rest less the last
          *              leaf (if any)
-         *    sizeloc   length of location (above) up to but not including 
+         *    sizeloc   length of location (above) up to but not including
          *              the last '/'
          */
@@ -541 +549 @@
 
         /* handle cases where pszRelative has scheme */
-        if ((base.sizep1 == relative.sizep1) && 
+        if ((base.sizep1 == relative.sizep1) &&
             (strncmpW(base.ap1, relative.ap1, base.sizep1) == 0)) {
 
@@ -583 +591 @@
             ret = E_POINTER;
             break;
-        } 
+        }
         strcatW(preliminary, mrelative);
         break;
@@ -596 +604 @@
             ret = E_POINTER;
             break;
-        } 
+        }
         strcpyW(preliminary, mrelative);
         if (!(dwFlags & URL_PLUGGABLE_PROTOCOL) &&
@@ -612 +620 @@
             ret = E_POINTER;
             break;
-        } 
+        }
         strncpyW(preliminary, base.ap1, base.sizep1 + 1);
         work = preliminary + base.sizep1 + 1;
@@ -631 +639 @@
             ret = E_POINTER;
             break;
-        } 
+        }
         strncpyW(preliminary, base.ap1, base.sizep1+1+sizeloc);
         work = preliminary + base.sizep1 + 1 + sizeloc;
@@ -640 +648 @@
 
     case 5:  /*
-              * Return the pszBase without its document (if any) and 
+              * Return the pszBase without its document (if any) and
               * append pszRelative after its scheme.
               */
@@ -648 +656 @@
             ret = E_POINTER;
             break;
-        } 
+        }
         strncpyW(preliminary, base.ap1, base.sizep1+1+base.sizep2);
         work = preliminary + base.sizep1+1+base.sizep2 - 1;
@@ -663 +671 @@
     if (ret == S_OK) {
         /*
-         * Now that the combining is done, process the escape options if 
+         * Now that the combining is done, process the escape options if
          * necessary, otherwise just copy the string.
          */
@@ -780 +788 @@
     *pcchEscaped = needed;
     return ret;
-}       
+}
 
 /*************************************************************************
@@ -877 +885 @@
  *
  * Converts escape sequences back to ordinary characters.
- * 
+ *
  * If URL_ESCAPE_INPLACE is set in dwFlags then pszUnescaped and
  * pcchUnescaped are ignored and the converted string is returned in
@@ -942 +950 @@
 
     if (ret == S_OK) {
-        TRACE("result %s\n", (dwFlags & URL_UNESCAPE_INPLACE) ? 
+        TRACE("result %s\n", (dwFlags & URL_UNESCAPE_INPLACE) ?
               debugstr_a(pszUrl) : debugstr_a(pszUnescaped));
     }
@@ -1006 +1014 @@
 
     if (ret == S_OK) {
-        TRACE("result %s\n", (dwFlags & URL_UNESCAPE_INPLACE) ? 
+        TRACE("result %s\n", (dwFlags & URL_UNESCAPE_INPLACE) ?
               debugstr_w(pszUrl) : debugstr_w(pszUnescaped));
     }
@@ -1017 +1025 @@
  *
  * Bugs/Features:
- *  MSDN (as of 2001-11-01) says that: 
- *         "The location is the segment of the URL starting with a ? 
- *          or # character." 
+ *  MSDN (as of 2001-11-01) says that:
+ *         "The location is the segment of the URL starting with a ?
+ *          or # character."
  *     Neither V4 nor V5 of shlwapi.dll implement the '?' and always return
  *     a NULL.
  *  MSDN further states that:
- *         "If a file URL has a query string, ther returned string 
+ *         "If a file URL has a query string, ther returned string
  *          the query string."
- *     In all test cases if the scheme starts with "fi" then a NULL is 
+ *     In all test cases if the scheme starts with "fi" then a NULL is
  *     returned. V5 gives the following results:
  *       NULL     file://aa/b/cd#hohoh
@@ -1179 +1187 @@
           debugstr_a(pszIn), *pcchOut, dwFlags);
 
-    in = (LPWSTR) HeapAlloc(GetProcessHeap(), 0, 
+    in = (LPWSTR) HeapAlloc(GetProcessHeap(), 0,
                               (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
     out = in + INTERNET_MAX_URL_LENGTH;
@@ -1293 +1301 @@
 
     if (dwFlags & URL_APPLY_GUESSFILE) {
-        FIXME("(%s %p %p(%ld) 0x%08lx): stub URL_APPLY_GUESSFILE not implemented\n", 
+        FIXME("(%s %p %p(%ld) 0x%08lx): stub URL_APPLY_GUESSFILE not implemented\n",
               debugstr_w(pszIn), pszOut, pcchOut, *pcchOut, dwFlags);
         strcpyW(pszOut, pszIn);
@@ -1306 +1314 @@
         /* no scheme in input, need to see if we need to guess */
         if (dwFlags & URL_APPLY_GUESSSCHEME) {
-            if ((ret = URL_GuessScheme(pszIn, pszOut, pcchOut)) != -1) 
+            if ((ret = URL_GuessScheme(pszIn, pszOut, pcchOut)) != -1)
                 return ret;
         }
@@ -1325 +1333 @@
     }
 
-    /* If we are here, then either invalid scheme, 
+    /* If we are here, then either invalid scheme,
      * or no scheme and can't/failed guess.
      */
@@ -1495 +1503 @@
                 (*size)++;
             } else if (*start == L'%') {
-                if (isxdigitW(*(start+1)) && 
+                if (isxdigitW(*(start+1)) &&
                     isxdigitW(*(start+2))) {
                     start += 3;
@@ -1553 +1561 @@
     if ((*work != L'/') || (*(work+1) != L'/')) goto __ERROR;
 #else
-    if (!*work || (*work != L':')) goto ERROR1;
+    if (!*work || (*work != L':')) goto ERROR;
     work++;
     if ((*work != L'/') || (*(work+1) != L'/')) goto ERROR;
@@ -1583 +1591 @@
     } else goto __ERROR;
 #else
-    } else goto ERROR1;
+    } else goto ERROR;
 #endif
     /* now start parsing hostname or hostnumber */
@@ -1620 +1628 @@
  *      UrlGetPartA     [SHLWAPI.@]
  */
-HRESULT WINAPI UrlGetPartA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcchOut, 
+HRESULT WINAPI UrlGetPartA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcchOut,
                            DWORD dwPart, DWORD dwFlags)
 {
@@ -1626 +1634 @@
     DWORD ret, len, len2;
 
-    in = (LPWSTR) HeapAlloc(GetProcessHeap(), 0, 
+    in = (LPWSTR) HeapAlloc(GetProcessHeap(), 0,
                               (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
     out = in + INTERNET_MAX_URL_LENGTH;
@@ -1655 +1663 @@
  *      UrlGetPartW     [SHLWAPI.@]
  */
-HRESULT WINAPI UrlGetPartW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut, 
+HRESULT WINAPI UrlGetPartW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut,
                            DWORD dwPart, DWORD dwFlags)
 {