include: Use proper dllimports for shlwapi functions.

dlls/kernelbase/Makefile.in

-EXTRADEFS = -DWINBASEAPI= -DWINADVAPI= -DWINUSERAPI=
+EXTRADEFS = -DWINBASEAPI= -DWINADVAPI= -DWINUSERAPI= -DWINSHLWAPI=
 MODULE    = kernelbase.dll
 IMPORTLIB = kernelbase
 IMPORTS   = uuid ntdll winecrt0

dlls/shcore/main.c

@@ -29,6 +29,7 @@
 #include "ocidl.h"
 #include "featurestagingapi.h"
 #include "shellscalingapi.h"
+#define WINSHLWAPI
 #include "shlwapi.h"
 
 #include "wine/debug.h"

dlls/shell32/shell32.spec

@@ -225,10 +225,10 @@
  511 stdcall SHRegQueryValueExW (long wstr ptr ptr ptr ptr)
  512 stdcall SHRegDeleteKeyW (long wstr)
 
- 520 stdcall -noname SHAllocShared(ptr long long)
- 521 stdcall -noname SHLockShared(long long)
- 522 stdcall -noname SHUnlockShared(ptr)
- 523 stdcall -noname SHFreeShared(long long)
+ 520 stdcall -noname -import SHAllocShared(ptr long long)
+ 521 stdcall -noname -import SHLockShared(long long)
+ 522 stdcall -noname -import SHUnlockShared(ptr)
+ 523 stdcall -noname -import SHFreeShared(long long)
  524 stdcall -ordinal RealDriveType(long long)
  525 stub RealDriveTypeFlags
  526 stdcall SHFlushSFCache()

dlls/shell32/shellord.c

@@ -84,24 +84,6 @@ extern INT    WINAPI FindMRUData(HANDLE hList, LPCVOID lpData, DWORD cbData, LPI
 extern INT    WINAPI EnumMRUListA(HANDLE hList, INT nItemPos, LPVOID lpBuffer, DWORD nBufferSize);
 
 
-/* Get a function pointer from a DLL handle */
-#define GET_FUNC(func, module, name, fail) \
-  do { \
-    if (!func) { \
-      if (!SHELL32_h##module && !(SHELL32_h##module = LoadLibraryA(#module ".dll"))) return fail; \
-      func = (void*)GetProcAddress(SHELL32_h##module, name); \
-      if (!func) return fail; \
-    } \
-  } while (0)
-
-/* Function pointers for GET_FUNC macro */
-static HMODULE SHELL32_hshlwapi=NULL;
-static HANDLE (WINAPI *pSHAllocShared)(LPCVOID,DWORD,DWORD);
-static LPVOID (WINAPI *pSHLockShared)(HANDLE,DWORD);
-static BOOL   (WINAPI *pSHUnlockShared)(LPVOID);
-static BOOL   (WINAPI *pSHFreeShared)(HANDLE,DWORD);
-
-
 /*************************************************************************
  * ParseFieldA					[internal]
  *
@@ -1324,50 +1306,6 @@ BOOL WINAPI IsUserAnAdmin(VOID)
 }
 
 /*************************************************************************
- * SHAllocShared				[SHELL32.520]
- *
- * See shlwapi.SHAllocShared
- */
-HANDLE WINAPI SHAllocShared(const void *lpvData, DWORD dwSize, DWORD dwProcId)
-{
-    GET_FUNC(pSHAllocShared, shlwapi, (char*)7, NULL);
-    return pSHAllocShared(lpvData, dwSize, dwProcId);
-}
-
-/*************************************************************************
- * SHLockShared					[SHELL32.521]
- *
- * See shlwapi.SHLockShared
- */
-LPVOID WINAPI SHLockShared(HANDLE hShared, DWORD dwProcId)
-{
-    GET_FUNC(pSHLockShared, shlwapi, (char*)8, NULL);
-    return pSHLockShared(hShared, dwProcId);
-}
-
-/*************************************************************************
- * SHUnlockShared				[SHELL32.522]
- *
- * See shlwapi.SHUnlockShared
- */
-BOOL WINAPI SHUnlockShared(LPVOID lpView)
-{
-    GET_FUNC(pSHUnlockShared, shlwapi, (char*)9, FALSE);
-    return pSHUnlockShared(lpView);
-}
-
-/*************************************************************************
- * SHFreeShared					[SHELL32.523]
- *
- * See shlwapi.SHFreeShared
- */
-BOOL WINAPI SHFreeShared(HANDLE hShared, DWORD dwProcId)
-{
-    GET_FUNC(pSHFreeShared, shlwapi, (char*)10, FALSE);
-    return pSHFreeShared(hShared, dwProcId);
-}
-
-/*************************************************************************
  * SetAppStartingCursor				[SHELL32.99]
  */
 HRESULT WINAPI SetAppStartingCursor(HWND u, DWORD v)

dlls/shlwapi/Makefile.in

+EXTRADEFS = -D_SHLWAPI_
 MODULE    = shlwapi.dll
 IMPORTLIB = shlwapi
 IMPORTS   = uuid shcore user32 gdi32 advapi32 kernelbase

include/shlwapi.h

@@ -31,10 +31,18 @@ extern "C" {
 
 #include <pshpack8.h>
 
+#ifndef WINSHLWAPI
+#ifndef _SHLWAPI_
+#define WINSHLWAPI DECLSPEC_IMPORT
+#else
+#define WINSHLWAPI
+#endif
+#endif
+
 #ifndef NO_SHLWAPI_HTTP
 
-HRESULT WINAPI GetAcceptLanguagesA(char *buffer, DWORD *buff_len);
-HRESULT WINAPI GetAcceptLanguagesW(WCHAR *buffer, DWORD *buff_len);
+WINSHLWAPI HRESULT WINAPI GetAcceptLanguagesA(char *buffer, DWORD *buff_len);
+WINSHLWAPI HRESULT WINAPI GetAcceptLanguagesW(WCHAR *buffer, DWORD *buff_len);
 #define GetAcceptLanguages WINELIB_NAME_AW(GetAcceptLanguages)
 
 #endif /* NO_SHLWAPI_HTTP */
@@ -43,55 +51,55 @@ HRESULT WINAPI GetAcceptLanguagesW(WCHAR *buffer, DWORD *buff_len);
 
 /* Registry functions */
 
-DWORD WINAPI SHDeleteEmptyKeyA(HKEY,LPCSTR);
-DWORD WINAPI SHDeleteEmptyKeyW(HKEY,LPCWSTR);
+WINSHLWAPI DWORD WINAPI SHDeleteEmptyKeyA(HKEY,LPCSTR);
+WINSHLWAPI DWORD WINAPI SHDeleteEmptyKeyW(HKEY,LPCWSTR);
 #define SHDeleteEmptyKey WINELIB_NAME_AW(SHDeleteEmptyKey)
 
-DWORD WINAPI SHDeleteKeyA(HKEY,LPCSTR);
-DWORD WINAPI SHDeleteKeyW(HKEY,LPCWSTR);
+WINSHLWAPI DWORD WINAPI SHDeleteKeyA(HKEY,LPCSTR);
+WINSHLWAPI DWORD WINAPI SHDeleteKeyW(HKEY,LPCWSTR);
 #define SHDeleteKey WINELIB_NAME_AW(SHDeleteKey)
 
-DWORD WINAPI SHDeleteValueA(HKEY,LPCSTR,LPCSTR);
-DWORD WINAPI SHDeleteValueW(HKEY,LPCWSTR,LPCWSTR);
+WINSHLWAPI DWORD WINAPI SHDeleteValueA(HKEY,LPCSTR,LPCSTR);
+WINSHLWAPI DWORD WINAPI SHDeleteValueW(HKEY,LPCWSTR,LPCWSTR);
 #define SHDeleteValue WINELIB_NAME_AW(SHDeleteValue)
 
-DWORD WINAPI SHGetValueA(HKEY,LPCSTR,LPCSTR,LPDWORD,LPVOID,LPDWORD);
-DWORD WINAPI SHGetValueW(HKEY,LPCWSTR,LPCWSTR,LPDWORD,LPVOID,LPDWORD);
+WINSHLWAPI DWORD WINAPI SHGetValueA(HKEY,LPCSTR,LPCSTR,LPDWORD,LPVOID,LPDWORD);
+WINSHLWAPI DWORD WINAPI SHGetValueW(HKEY,LPCWSTR,LPCWSTR,LPDWORD,LPVOID,LPDWORD);
 #define SHGetValue WINELIB_NAME_AW(SHGetValue)
 
-DWORD WINAPI SHSetValueA(HKEY,LPCSTR,LPCSTR,DWORD,LPCVOID,DWORD);
-DWORD WINAPI SHSetValueW(HKEY,LPCWSTR,LPCWSTR,DWORD,LPCVOID,DWORD);
+WINSHLWAPI DWORD WINAPI SHSetValueA(HKEY,LPCSTR,LPCSTR,DWORD,LPCVOID,DWORD);
+WINSHLWAPI DWORD WINAPI SHSetValueW(HKEY,LPCWSTR,LPCWSTR,DWORD,LPCVOID,DWORD);
 #define SHSetValue WINELIB_NAME_AW(SHSetValue)
 
-DWORD WINAPI SHQueryValueExA(HKEY,LPCSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD);
-DWORD WINAPI SHQueryValueExW(HKEY,LPCWSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD);
+WINSHLWAPI DWORD WINAPI SHQueryValueExA(HKEY,LPCSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD);
+WINSHLWAPI DWORD WINAPI SHQueryValueExW(HKEY,LPCWSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD);
 #define SHQueryValueEx WINELIB_NAME_AW(SHQueryValueEx)
 
-LONG WINAPI SHEnumKeyExA(HKEY,DWORD,LPSTR,LPDWORD);
-LONG WINAPI SHEnumKeyExW(HKEY,DWORD,LPWSTR,LPDWORD);
+WINSHLWAPI LONG WINAPI SHEnumKeyExA(HKEY,DWORD,LPSTR,LPDWORD);
+WINSHLWAPI LONG WINAPI SHEnumKeyExW(HKEY,DWORD,LPWSTR,LPDWORD);
 #define SHEnumKeyEx WINELIB_NAME_AW(SHEnumKeyEx)
 
-LONG WINAPI SHEnumValueA(HKEY,DWORD,LPSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD);
-LONG WINAPI SHEnumValueW(HKEY,DWORD,LPWSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD);
+WINSHLWAPI LONG WINAPI SHEnumValueA(HKEY,DWORD,LPSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD);
+WINSHLWAPI LONG WINAPI SHEnumValueW(HKEY,DWORD,LPWSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD);
 #define SHEnumValue WINELIB_NAME_AW(SHEnumValue)
 
-LONG WINAPI SHQueryInfoKeyA(HKEY,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
-LONG WINAPI SHQueryInfoKeyW(HKEY,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
+WINSHLWAPI LONG WINAPI SHQueryInfoKeyA(HKEY,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
+WINSHLWAPI LONG WINAPI SHQueryInfoKeyW(HKEY,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
 #define SHQueryInfoKey WINELIB_NAME_AW(SHQueryInfoKey)
 
-DWORD WINAPI SHRegGetPathA(HKEY,LPCSTR,LPCSTR,LPSTR,DWORD);
-DWORD WINAPI SHRegGetPathW(HKEY,LPCWSTR,LPCWSTR,LPWSTR,DWORD);
+WINSHLWAPI DWORD WINAPI SHRegGetPathA(HKEY,LPCSTR,LPCSTR,LPSTR,DWORD);
+WINSHLWAPI DWORD WINAPI SHRegGetPathW(HKEY,LPCWSTR,LPCWSTR,LPWSTR,DWORD);
 #define SHRegGetPath WINELIB_NAME_AW(SHRegGetPath)
 
-DWORD WINAPI SHRegSetPathA(HKEY,LPCSTR,LPCSTR,LPCSTR,DWORD);
-DWORD WINAPI SHRegSetPathW(HKEY,LPCWSTR,LPCWSTR,LPCWSTR,DWORD);
+WINSHLWAPI DWORD WINAPI SHRegSetPathA(HKEY,LPCSTR,LPCSTR,LPCSTR,DWORD);
+WINSHLWAPI DWORD WINAPI SHRegSetPathW(HKEY,LPCWSTR,LPCWSTR,LPCWSTR,DWORD);
 #define SHRegSetPath WINELIB_NAME_AW(SHRegSetPath)
 
-DWORD WINAPI SHCopyKeyA(HKEY,LPCSTR,HKEY,DWORD);
-DWORD WINAPI SHCopyKeyW(HKEY,LPCWSTR,HKEY,DWORD);
+WINSHLWAPI DWORD WINAPI SHCopyKeyA(HKEY,LPCSTR,HKEY,DWORD);
+WINSHLWAPI DWORD WINAPI SHCopyKeyW(HKEY,LPCWSTR,HKEY,DWORD);
 #define SHCopyKey WINELIB_NAME_AW(SHCopyKey)
 
-HKEY WINAPI  SHRegDuplicateHKey(HKEY);
+WINSHLWAPI HKEY WINAPI  SHRegDuplicateHKey(HKEY);
 
 /* SHRegGetValue flags */
 typedef INT SRRF;
@@ -117,14 +125,14 @@ typedef INT SRRF;
 #define SRRF_ZEROONFAILURE 0x20000000
 #define SRRF_NOVIRT 0x40000000
 
-LSTATUS WINAPI SHRegGetValueA(HKEY,LPCSTR,LPCSTR,SRRF,LPDWORD,LPVOID,LPDWORD);
-LSTATUS WINAPI SHRegGetValueW(HKEY,LPCWSTR,LPCWSTR,SRRF,LPDWORD,LPVOID,LPDWORD);
+WINSHLWAPI LSTATUS WINAPI SHRegGetValueA(HKEY,LPCSTR,LPCSTR,SRRF,LPDWORD,LPVOID,LPDWORD);
+WINSHLWAPI LSTATUS WINAPI SHRegGetValueW(HKEY,LPCWSTR,LPCWSTR,SRRF,LPDWORD,LPVOID,LPDWORD);
 #define SHRegGetValue WINELIB_NAME_AW(SHRegGetValue)
 
 /* Undocumented registry functions */
 
-DWORD WINAPI SHDeleteOrphanKeyA(HKEY,LPCSTR);
-DWORD WINAPI SHDeleteOrphanKeyW(HKEY,LPCWSTR);
+WINSHLWAPI DWORD WINAPI SHDeleteOrphanKeyA(HKEY,LPCSTR);
+WINSHLWAPI DWORD WINAPI SHDeleteOrphanKeyW(HKEY,LPCWSTR);
 #define SHDeleteOrphanKey WINELIB_NAME_AW(SHDeleteOrphanKey)
 
 
@@ -155,65 +163,65 @@ typedef enum
 typedef HANDLE HUSKEY;
 typedef HUSKEY *PHUSKEY;
 
-LONG WINAPI SHRegCreateUSKeyA(LPCSTR,REGSAM,HUSKEY,PHUSKEY,DWORD);
-LONG WINAPI SHRegCreateUSKeyW(LPCWSTR,REGSAM,HUSKEY,PHUSKEY,DWORD);
+WINSHLWAPI LONG WINAPI SHRegCreateUSKeyA(LPCSTR,REGSAM,HUSKEY,PHUSKEY,DWORD);
+WINSHLWAPI LONG WINAPI SHRegCreateUSKeyW(LPCWSTR,REGSAM,HUSKEY,PHUSKEY,DWORD);
 #define SHRegCreateUSKey WINELIB_NAME_AW(SHRegCreateUSKey)
 
-LONG WINAPI SHRegOpenUSKeyA(LPCSTR,REGSAM,HUSKEY,PHUSKEY,BOOL);
-LONG WINAPI SHRegOpenUSKeyW(LPCWSTR,REGSAM,HUSKEY,PHUSKEY,BOOL);
+WINSHLWAPI LONG WINAPI SHRegOpenUSKeyA(LPCSTR,REGSAM,HUSKEY,PHUSKEY,BOOL);
+WINSHLWAPI LONG WINAPI SHRegOpenUSKeyW(LPCWSTR,REGSAM,HUSKEY,PHUSKEY,BOOL);
 #define SHRegOpenUSKey WINELIB_NAME_AW(SHRegOpenUSKey)
 
-LONG WINAPI SHRegQueryUSValueA(HUSKEY,LPCSTR,LPDWORD,LPVOID,LPDWORD,
+WINSHLWAPI LONG WINAPI SHRegQueryUSValueA(HUSKEY,LPCSTR,LPDWORD,LPVOID,LPDWORD,
                                BOOL,LPVOID,DWORD);
-LONG WINAPI SHRegQueryUSValueW(HUSKEY,LPCWSTR,LPDWORD,LPVOID,LPDWORD,
+WINSHLWAPI LONG WINAPI SHRegQueryUSValueW(HUSKEY,LPCWSTR,LPDWORD,LPVOID,LPDWORD,
                                BOOL,LPVOID,DWORD);
 #define SHRegQueryUSValue WINELIB_NAME_AW(SHRegQueryUSValue)
 
-LONG WINAPI SHRegWriteUSValueA(HUSKEY,LPCSTR,DWORD,LPVOID,DWORD,DWORD);
-LONG WINAPI SHRegWriteUSValueW(HUSKEY,LPCWSTR,DWORD,LPVOID,DWORD,DWORD);
+WINSHLWAPI LONG WINAPI SHRegWriteUSValueA(HUSKEY,LPCSTR,DWORD,LPVOID,DWORD,DWORD);
+WINSHLWAPI LONG WINAPI SHRegWriteUSValueW(HUSKEY,LPCWSTR,DWORD,LPVOID,DWORD,DWORD);
 #define SHRegWriteUSValue WINELIB_NAME_AW(SHRegWriteUSValue)
 
-LONG WINAPI SHRegDeleteUSValueA(HUSKEY,LPCSTR,SHREGDEL_FLAGS);
-LONG WINAPI SHRegDeleteUSValueW(HUSKEY,LPCWSTR,SHREGDEL_FLAGS);
+WINSHLWAPI LONG WINAPI SHRegDeleteUSValueA(HUSKEY,LPCSTR,SHREGDEL_FLAGS);
+WINSHLWAPI LONG WINAPI SHRegDeleteUSValueW(HUSKEY,LPCWSTR,SHREGDEL_FLAGS);
 #define SHRegDeleteUSValue WINELIB_NAME_AW(SHRegDeleteUSValue)
 
-LONG WINAPI SHRegDeleteEmptyUSKeyA(HUSKEY,LPCSTR,SHREGDEL_FLAGS);
-LONG WINAPI SHRegDeleteEmptyUSKeyW(HUSKEY,LPCWSTR,SHREGDEL_FLAGS);
+WINSHLWAPI LONG WINAPI SHRegDeleteEmptyUSKeyA(HUSKEY,LPCSTR,SHREGDEL_FLAGS);
+WINSHLWAPI LONG WINAPI SHRegDeleteEmptyUSKeyW(HUSKEY,LPCWSTR,SHREGDEL_FLAGS);
 #define SHRegDeleteEmptyUSKey WINELIB_NAME_AW(SHRegDeleteEmptyUSKey)
 
-LONG WINAPI SHRegEnumUSKeyA(HUSKEY,DWORD,LPSTR,LPDWORD,SHREGENUM_FLAGS);
-LONG WINAPI SHRegEnumUSKeyW(HUSKEY,DWORD,LPWSTR,LPDWORD,SHREGENUM_FLAGS);
+WINSHLWAPI LONG WINAPI SHRegEnumUSKeyA(HUSKEY,DWORD,LPSTR,LPDWORD,SHREGENUM_FLAGS);
+WINSHLWAPI LONG WINAPI SHRegEnumUSKeyW(HUSKEY,DWORD,LPWSTR,LPDWORD,SHREGENUM_FLAGS);
 #define SHRegEnumUSKey WINELIB_NAME_AW(SHRegEnumUSKey)
 
-LONG WINAPI SHRegEnumUSValueA(HUSKEY,DWORD,LPSTR,LPDWORD,LPDWORD,
+WINSHLWAPI LONG WINAPI SHRegEnumUSValueA(HUSKEY,DWORD,LPSTR,LPDWORD,LPDWORD,
                               LPVOID,LPDWORD,SHREGENUM_FLAGS);
-LONG WINAPI SHRegEnumUSValueW(HUSKEY,DWORD,LPWSTR,LPDWORD,LPDWORD,
+WINSHLWAPI LONG WINAPI SHRegEnumUSValueW(HUSKEY,DWORD,LPWSTR,LPDWORD,LPDWORD,
                               LPVOID,LPDWORD,SHREGENUM_FLAGS);
 #define SHRegEnumUSValue WINELIB_NAME_AW(SHRegEnumUSValue)
 
-LONG WINAPI SHRegQueryInfoUSKeyA(HUSKEY,LPDWORD,LPDWORD,LPDWORD,
+WINSHLWAPI LONG WINAPI SHRegQueryInfoUSKeyA(HUSKEY,LPDWORD,LPDWORD,LPDWORD,
                                  LPDWORD,SHREGENUM_FLAGS);
-LONG WINAPI SHRegQueryInfoUSKeyW(HUSKEY,LPDWORD,LPDWORD,LPDWORD,
+WINSHLWAPI LONG WINAPI SHRegQueryInfoUSKeyW(HUSKEY,LPDWORD,LPDWORD,LPDWORD,
                                  LPDWORD,SHREGENUM_FLAGS);
 #define SHRegQueryInfoUSKey WINELIB_NAME_AW(SHRegQueryInfoUSKey)
 
-LONG WINAPI SHRegCloseUSKey(HUSKEY);
+WINSHLWAPI LONG WINAPI SHRegCloseUSKey(HUSKEY);
 
-LONG WINAPI SHRegGetUSValueA(LPCSTR,LPCSTR,LPDWORD,LPVOID,LPDWORD,
+WINSHLWAPI LONG WINAPI SHRegGetUSValueA(LPCSTR,LPCSTR,LPDWORD,LPVOID,LPDWORD,
                              BOOL,LPVOID,DWORD);
-LONG WINAPI SHRegGetUSValueW(LPCWSTR,LPCWSTR,LPDWORD,LPVOID,LPDWORD,
+WINSHLWAPI LONG WINAPI SHRegGetUSValueW(LPCWSTR,LPCWSTR,LPDWORD,LPVOID,LPDWORD,
                              BOOL,LPVOID,DWORD);
 #define SHRegGetUSValue WINELIB_NAME_AW(SHRegGetUSValue)
 
-LONG WINAPI SHRegSetUSValueA(LPCSTR,LPCSTR,DWORD,LPVOID,DWORD,DWORD);
-LONG WINAPI SHRegSetUSValueW(LPCWSTR,LPCWSTR,DWORD,LPVOID,DWORD,DWORD);
+WINSHLWAPI LONG WINAPI SHRegSetUSValueA(LPCSTR,LPCSTR,DWORD,LPVOID,DWORD,DWORD);
+WINSHLWAPI LONG WINAPI SHRegSetUSValueW(LPCWSTR,LPCWSTR,DWORD,LPVOID,DWORD,DWORD);
 #define SHRegSetUSValue WINELIB_NAME_AW(SHRegSetUSValue)
 
-BOOL WINAPI SHRegGetBoolUSValueA(LPCSTR,LPCSTR,BOOL,BOOL);
-BOOL WINAPI SHRegGetBoolUSValueW(LPCWSTR,LPCWSTR,BOOL,BOOL);
+WINSHLWAPI BOOL WINAPI SHRegGetBoolUSValueA(LPCSTR,LPCSTR,BOOL,BOOL);
+WINSHLWAPI BOOL WINAPI SHRegGetBoolUSValueW(LPCWSTR,LPCWSTR,BOOL,BOOL);
 #define SHRegGetBoolUSValue WINELIB_NAME_AW(SHRegGetBoolUSValue)
 
-int WINAPI SHRegGetIntW(HKEY,LPCWSTR,int);
+WINSHLWAPI int WINAPI SHRegGetIntW(HKEY,LPCWSTR,int);
 
 /* IQueryAssociation and helpers */
 enum
@@ -313,30 +321,30 @@ DECLARE_INTERFACE_(IQueryAssociations,IUnknown)
 #define IQueryAssociations_GetEnum(p,a,b,c,d,e)    (p)->lpVtbl->GetEnum(p,a,b,c,d,e)
 #endif
 
-HRESULT WINAPI AssocCreate(CLSID,REFIID,LPVOID*);
+WINSHLWAPI HRESULT WINAPI AssocCreate(CLSID,REFIID,LPVOID*);
 
-HRESULT WINAPI AssocQueryStringA(ASSOCF,ASSOCSTR,LPCSTR,LPCSTR,LPSTR,LPDWORD);
-HRESULT WINAPI AssocQueryStringW(ASSOCF,ASSOCSTR,LPCWSTR,LPCWSTR,LPWSTR,LPDWORD);
+WINSHLWAPI HRESULT WINAPI AssocQueryStringA(ASSOCF,ASSOCSTR,LPCSTR,LPCSTR,LPSTR,LPDWORD);
+WINSHLWAPI HRESULT WINAPI AssocQueryStringW(ASSOCF,ASSOCSTR,LPCWSTR,LPCWSTR,LPWSTR,LPDWORD);
 #define AssocQueryString WINELIB_NAME_AW(AssocQueryString)
 
-HRESULT WINAPI AssocQueryStringByKeyA(ASSOCF,ASSOCSTR,HKEY,LPCSTR,LPSTR,LPDWORD);
-HRESULT WINAPI AssocQueryStringByKeyW(ASSOCF,ASSOCSTR,HKEY,LPCWSTR,LPWSTR,LPDWORD);
+WINSHLWAPI HRESULT WINAPI AssocQueryStringByKeyA(ASSOCF,ASSOCSTR,HKEY,LPCSTR,LPSTR,LPDWORD);
+WINSHLWAPI HRESULT WINAPI AssocQueryStringByKeyW(ASSOCF,ASSOCSTR,HKEY,LPCWSTR,LPWSTR,LPDWORD);
 #define AssocQueryStringByKey WINELIB_NAME_AW(AssocQueryStringByKey)
 
-HRESULT WINAPI AssocQueryKeyA(ASSOCF,ASSOCKEY,LPCSTR,LPCSTR,PHKEY);
-HRESULT WINAPI AssocQueryKeyW(ASSOCF,ASSOCKEY,LPCWSTR,LPCWSTR,PHKEY);
+WINSHLWAPI HRESULT WINAPI AssocQueryKeyA(ASSOCF,ASSOCKEY,LPCSTR,LPCSTR,PHKEY);
+WINSHLWAPI HRESULT WINAPI AssocQueryKeyW(ASSOCF,ASSOCKEY,LPCWSTR,LPCWSTR,PHKEY);
 #define AssocQueryKey WINELIB_NAME_AW(AssocQueryKey)
 
-BOOL WINAPI AssocIsDangerous(LPCWSTR);
+WINSHLWAPI BOOL WINAPI AssocIsDangerous(LPCWSTR);
 
 #endif /* NO_SHLWAPI_REG */
 
-void WINAPI IUnknown_Set(IUnknown **ppunk, IUnknown *punk);
-void WINAPI IUnknown_AtomicRelease(IUnknown **punk);
-HRESULT WINAPI IUnknown_GetWindow(IUnknown *punk, HWND *phwnd);
-HRESULT WINAPI IUnknown_SetSite(IUnknown *punk, IUnknown *punkSite);
-HRESULT WINAPI IUnknown_GetSite(IUnknown *punk, REFIID riid, void **ppv);
-HRESULT WINAPI IUnknown_QueryService(IUnknown *punk, REFGUID guidService, REFIID riid, void **ppvOut);
+WINSHLWAPI void WINAPI IUnknown_Set(IUnknown **ppunk, IUnknown *punk);
+WINSHLWAPI void WINAPI IUnknown_AtomicRelease(IUnknown **punk);
+WINSHLWAPI HRESULT WINAPI IUnknown_GetWindow(IUnknown *punk, HWND *phwnd);
+WINSHLWAPI HRESULT WINAPI IUnknown_SetSite(IUnknown *punk, IUnknown *punkSite);
+WINSHLWAPI HRESULT WINAPI IUnknown_GetSite(IUnknown *punk, REFIID riid, void **ppv);
+WINSHLWAPI HRESULT WINAPI IUnknown_QueryService(IUnknown *punk, REFGUID guidService, REFIID riid, void **ppvOut);
 
 /* Path functions */
 #ifndef NO_SHLWAPI_PATH
@@ -348,238 +356,238 @@ HRESULT WINAPI IUnknown_QueryService(IUnknown *punk, REFGUID guidService, REFIID
 #define GCT_WILD        0x4
 #define GCT_SEPARATOR   0x8
 
-LPSTR  WINAPI PathAddBackslashA(LPSTR);
-LPWSTR WINAPI PathAddBackslashW(LPWSTR);
+WINSHLWAPI LPSTR  WINAPI PathAddBackslashA(LPSTR);
+WINSHLWAPI LPWSTR WINAPI PathAddBackslashW(LPWSTR);
 #define PathAddBackslash WINELIB_NAME_AW(PathAddBackslash)
 
-BOOL WINAPI PathAddExtensionA(LPSTR,LPCSTR);
-BOOL WINAPI PathAddExtensionW(LPWSTR,LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathAddExtensionA(LPSTR,LPCSTR);
+WINSHLWAPI BOOL WINAPI PathAddExtensionW(LPWSTR,LPCWSTR);
 #define PathAddExtension WINELIB_NAME_AW(PathAddExtension)
 
-BOOL WINAPI PathAppendA(LPSTR,LPCSTR);
-BOOL WINAPI PathAppendW(LPWSTR,LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathAppendA(LPSTR,LPCSTR);
+WINSHLWAPI BOOL WINAPI PathAppendW(LPWSTR,LPCWSTR);
 #define PathAppend WINELIB_NAME_AW(PathAppend)
 
-LPSTR  WINAPI PathBuildRootA(LPSTR,int);
-LPWSTR WINAPI PathBuildRootW(LPWSTR,int);
+WINSHLWAPI LPSTR  WINAPI PathBuildRootA(LPSTR,int);
+WINSHLWAPI LPWSTR WINAPI PathBuildRootW(LPWSTR,int);
 #define PathBuildRoot WINELIB_NAME_AW(PathBuiltRoot)
 
-BOOL WINAPI PathCanonicalizeA(LPSTR,LPCSTR);
-BOOL WINAPI PathCanonicalizeW(LPWSTR,LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathCanonicalizeA(LPSTR,LPCSTR);
+WINSHLWAPI BOOL WINAPI PathCanonicalizeW(LPWSTR,LPCWSTR);
 #define PathCanonicalize WINELIB_NAME_AW(PathCanonicalize)
 
-LPSTR  WINAPI PathCombineA(LPSTR,LPCSTR,LPCSTR);
-LPWSTR WINAPI PathCombineW(LPWSTR,LPCWSTR,LPCWSTR);
+WINSHLWAPI LPSTR  WINAPI PathCombineA(LPSTR,LPCSTR,LPCSTR);
+WINSHLWAPI LPWSTR WINAPI PathCombineW(LPWSTR,LPCWSTR,LPCWSTR);
 #define PathCombine WINELIB_NAME_AW(PathCombine)
 
-BOOL WINAPI PathCompactPathA(HDC,LPSTR,UINT);
-BOOL WINAPI PathCompactPathW(HDC,LPWSTR,UINT);
+WINSHLWAPI BOOL WINAPI PathCompactPathA(HDC,LPSTR,UINT);
+WINSHLWAPI BOOL WINAPI PathCompactPathW(HDC,LPWSTR,UINT);
 #define PathCompactPath WINELIB_NAME_AW(PathCompactPath)
 
-BOOL WINAPI PathCompactPathExA(LPSTR,LPCSTR,UINT,DWORD);
-BOOL WINAPI PathCompactPathExW(LPWSTR,LPCWSTR,UINT,DWORD);
+WINSHLWAPI BOOL WINAPI PathCompactPathExA(LPSTR,LPCSTR,UINT,DWORD);
+WINSHLWAPI BOOL WINAPI PathCompactPathExW(LPWSTR,LPCWSTR,UINT,DWORD);
 #define PathCompactPathEx WINELIB_NAME_AW(PathCompactPathEx)
 
-int WINAPI PathCommonPrefixA(LPCSTR,LPCSTR,LPSTR);
-int WINAPI PathCommonPrefixW(LPCWSTR,LPCWSTR,LPWSTR);
+WINSHLWAPI int WINAPI PathCommonPrefixA(LPCSTR,LPCSTR,LPSTR);
+WINSHLWAPI int WINAPI PathCommonPrefixW(LPCWSTR,LPCWSTR,LPWSTR);
 #define PathCommonPrefix WINELIB_NAME_AW(PathCommonPrefix)
 
-HRESULT WINAPI PathCreateFromUrlA(LPCSTR,LPSTR,LPDWORD,DWORD);
-HRESULT WINAPI PathCreateFromUrlW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI PathCreateFromUrlA(LPCSTR,LPSTR,LPDWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI PathCreateFromUrlW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
 #define PathCreateFromUrl WINELIB_NAME_AW(PathCreateFromUrl)
 
-HRESULT WINAPI PathCreateFromUrlAlloc(LPCWSTR,LPWSTR*,DWORD);
+WINSHLWAPI HRESULT WINAPI PathCreateFromUrlAlloc(LPCWSTR,LPWSTR*,DWORD);
 
-BOOL WINAPI PathFileExistsA(LPCSTR);
-BOOL WINAPI PathFileExistsW(LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathFileExistsA(LPCSTR);
+WINSHLWAPI BOOL WINAPI PathFileExistsW(LPCWSTR);
 #define PathFileExists WINELIB_NAME_AW(PathFileExists)
 
-BOOL WINAPI PathFileExistsAndAttributesA(LPCSTR,DWORD*);
-BOOL WINAPI PathFileExistsAndAttributesW(LPCWSTR,DWORD*);
+WINSHLWAPI BOOL WINAPI PathFileExistsAndAttributesA(LPCSTR,DWORD*);
+WINSHLWAPI BOOL WINAPI PathFileExistsAndAttributesW(LPCWSTR,DWORD*);
 #define PathFileExistsAndAttributes WINELIB_NAME_AW(PathFileExistsAndAttributes)
 
-LPSTR  WINAPI PathFindExtensionA(LPCSTR);
-LPWSTR WINAPI PathFindExtensionW(LPCWSTR);
+WINSHLWAPI LPSTR  WINAPI PathFindExtensionA(LPCSTR);
+WINSHLWAPI LPWSTR WINAPI PathFindExtensionW(LPCWSTR);
 #define PathFindExtension WINELIB_NAME_AW(PathFindExtension)
 
-LPSTR  WINAPI PathFindFileNameA(LPCSTR);
-LPWSTR WINAPI PathFindFileNameW(LPCWSTR);
+WINSHLWAPI LPSTR  WINAPI PathFindFileNameA(LPCSTR);
+WINSHLWAPI LPWSTR WINAPI PathFindFileNameW(LPCWSTR);
 #define PathFindFileName WINELIB_NAME_AW(PathFindFileName)
 
-LPSTR  WINAPI PathFindNextComponentA(LPCSTR);
-LPWSTR WINAPI PathFindNextComponentW(LPCWSTR);
+WINSHLWAPI LPSTR  WINAPI PathFindNextComponentA(LPCSTR);
+WINSHLWAPI LPWSTR WINAPI PathFindNextComponentW(LPCWSTR);
 #define PathFindNextComponent WINELIB_NAME_AW(PathFindNextComponent)
 
-BOOL WINAPI PathFindOnPathA(LPSTR,LPCSTR*);
-BOOL WINAPI PathFindOnPathW(LPWSTR,LPCWSTR*);
+WINSHLWAPI BOOL WINAPI PathFindOnPathA(LPSTR,LPCSTR*);
+WINSHLWAPI BOOL WINAPI PathFindOnPathW(LPWSTR,LPCWSTR*);
 #define PathFindOnPath WINELIB_NAME_AW(PathFindOnPath)
 
-LPSTR  WINAPI PathGetArgsA(LPCSTR);
-LPWSTR WINAPI PathGetArgsW(LPCWSTR);
+WINSHLWAPI LPSTR  WINAPI PathGetArgsA(LPCSTR);
+WINSHLWAPI LPWSTR WINAPI PathGetArgsW(LPCWSTR);
 #define PathGetArgs WINELIB_NAME_AW(PathGetArgs)
 
-UINT WINAPI PathGetCharTypeA(UCHAR);
-UINT WINAPI PathGetCharTypeW(WCHAR);
+WINSHLWAPI UINT WINAPI PathGetCharTypeA(UCHAR);
+WINSHLWAPI UINT WINAPI PathGetCharTypeW(WCHAR);
 #define PathGetCharType WINELIB_NAME_AW(PathGetCharType)
 
-int WINAPI PathGetDriveNumberA(LPCSTR);
-int WINAPI PathGetDriveNumberW(LPCWSTR);
+WINSHLWAPI int WINAPI PathGetDriveNumberA(LPCSTR);
+WINSHLWAPI int WINAPI PathGetDriveNumberW(LPCWSTR);
 #define PathGetDriveNumber WINELIB_NAME_AW(PathGetDriveNumber)
 
-BOOL WINAPI PathIsDirectoryA(LPCSTR);
-BOOL WINAPI PathIsDirectoryW(LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathIsDirectoryA(LPCSTR);
+WINSHLWAPI BOOL WINAPI PathIsDirectoryW(LPCWSTR);
 #define PathIsDirectory WINELIB_NAME_AW(PathIsDirectory)
 
-BOOL WINAPI PathIsDirectoryEmptyA(LPCSTR);
-BOOL WINAPI PathIsDirectoryEmptyW(LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathIsDirectoryEmptyA(LPCSTR);
+WINSHLWAPI BOOL WINAPI PathIsDirectoryEmptyW(LPCWSTR);
 #define PathIsDirectoryEmpty WINELIB_NAME_AW(PathIsDirectoryEmpty)
 
-BOOL WINAPI PathIsFileSpecA(LPCSTR);
-BOOL WINAPI PathIsFileSpecW(LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathIsFileSpecA(LPCSTR);
+WINSHLWAPI BOOL WINAPI PathIsFileSpecW(LPCWSTR);
 #define PathIsFileSpec WINELIB_NAME_AW(PathIsFileSpec)
 
-BOOL WINAPI PathIsPrefixA(LPCSTR,LPCSTR);
-BOOL WINAPI PathIsPrefixW(LPCWSTR,LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathIsPrefixA(LPCSTR,LPCSTR);
+WINSHLWAPI BOOL WINAPI PathIsPrefixW(LPCWSTR,LPCWSTR);
 #define PathIsPrefix WINELIB_NAME_AW(PathIsPrefix)
 
-BOOL WINAPI PathIsRelativeA(LPCSTR);
-BOOL WINAPI PathIsRelativeW(LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathIsRelativeA(LPCSTR);
+WINSHLWAPI BOOL WINAPI PathIsRelativeW(LPCWSTR);
 #define PathIsRelative WINELIB_NAME_AW(PathIsRelative)
 
-BOOL WINAPI PathIsRootA(LPCSTR);
-BOOL WINAPI PathIsRootW(LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathIsRootA(LPCSTR);
+WINSHLWAPI BOOL WINAPI PathIsRootW(LPCWSTR);
 #define PathIsRoot WINELIB_NAME_AW(PathIsRoot)
 
-BOOL WINAPI PathIsSameRootA(LPCSTR,LPCSTR);
-BOOL WINAPI PathIsSameRootW(LPCWSTR,LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathIsSameRootA(LPCSTR,LPCSTR);
+WINSHLWAPI BOOL WINAPI PathIsSameRootW(LPCWSTR,LPCWSTR);
 #define PathIsSameRoot WINELIB_NAME_AW(PathIsSameRoot)
 
-BOOL WINAPI PathIsUNCA(LPCSTR);
-BOOL WINAPI PathIsUNCW(LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathIsUNCA(LPCSTR);
+WINSHLWAPI BOOL WINAPI PathIsUNCW(LPCWSTR);
 #define PathIsUNC WINELIB_NAME_AW(PathIsUNC)
 
-BOOL WINAPI PathIsUNCServerA(LPCSTR);
-BOOL WINAPI PathIsUNCServerW(LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathIsUNCServerA(LPCSTR);
+WINSHLWAPI BOOL WINAPI PathIsUNCServerW(LPCWSTR);
 #define PathIsUNCServer WINELIB_NAME_AW(PathIsUNCServer)
 
-BOOL WINAPI PathIsUNCServerShareA(LPCSTR);
-BOOL WINAPI PathIsUNCServerShareW(LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathIsUNCServerShareA(LPCSTR);
+WINSHLWAPI BOOL WINAPI PathIsUNCServerShareW(LPCWSTR);
 #define PathIsUNCServerShare WINELIB_NAME_AW(PathIsUNCServerShare)
 
-BOOL WINAPI PathIsContentTypeA(LPCSTR,LPCSTR);
-BOOL WINAPI PathIsContentTypeW(LPCWSTR,LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathIsContentTypeA(LPCSTR,LPCSTR);
+WINSHLWAPI BOOL WINAPI PathIsContentTypeW(LPCWSTR,LPCWSTR);
 #define PathIsContentType WINELIB_NAME_AW(PathIsContentType)
 
-BOOL WINAPI PathIsURLA(LPCSTR);
-BOOL WINAPI PathIsURLW(LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathIsURLA(LPCSTR);
+WINSHLWAPI BOOL WINAPI PathIsURLW(LPCWSTR);
 #define PathIsURL WINELIB_NAME_AW(PathIsURL)
 
-BOOL WINAPI PathMakePrettyA(LPSTR);
-BOOL WINAPI PathMakePrettyW(LPWSTR);
+WINSHLWAPI BOOL WINAPI PathMakePrettyA(LPSTR);
+WINSHLWAPI BOOL WINAPI PathMakePrettyW(LPWSTR);
 #define PathMakePretty WINELIB_NAME_AW(PathMakePretty)
 
-BOOL WINAPI PathMatchSpecA(LPCSTR,LPCSTR);
-BOOL WINAPI PathMatchSpecW(LPCWSTR,LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathMatchSpecA(LPCSTR,LPCSTR);
+WINSHLWAPI BOOL WINAPI PathMatchSpecW(LPCWSTR,LPCWSTR);
 #define PathMatchSpec WINELIB_NAME_AW(PathMatchSpec)
 
 #define PMSF_NORMAL             0x00000000
 #define PMSF_MULTIPLE           0x00000001
 #define PMSF_DONT_STRIP_SPACES  0x00010000
 
-HRESULT WINAPI PathMatchSpecExA(LPCSTR,LPCSTR,DWORD);
-HRESULT WINAPI PathMatchSpecExW(LPCWSTR,LPCWSTR,DWORD);
+WINSHLWAPI HRESULT WINAPI PathMatchSpecExA(LPCSTR,LPCSTR,DWORD);
+WINSHLWAPI HRESULT WINAPI PathMatchSpecExW(LPCWSTR,LPCWSTR,DWORD);
 #define PathMatchSpecEx WINELIB_NAME_AW(PathMatchSpecEx)
 
-int WINAPI PathParseIconLocationA(LPSTR);
-int WINAPI PathParseIconLocationW(LPWSTR);
+WINSHLWAPI int WINAPI PathParseIconLocationA(LPSTR);
+WINSHLWAPI int WINAPI PathParseIconLocationW(LPWSTR);
 #define PathParseIconLocation WINELIB_NAME_AW(PathParseIconLocation)
 
-VOID WINAPI PathQuoteSpacesA(LPSTR);
-VOID WINAPI PathQuoteSpacesW(LPWSTR);
+WINSHLWAPI VOID WINAPI PathQuoteSpacesA(LPSTR);
+WINSHLWAPI VOID WINAPI PathQuoteSpacesW(LPWSTR);
 #define PathQuoteSpaces WINELIB_NAME_AW(PathQuoteSpaces)
 
-BOOL WINAPI PathRelativePathToA(LPSTR,LPCSTR,DWORD,LPCSTR,DWORD);
-BOOL WINAPI PathRelativePathToW(LPWSTR,LPCWSTR,DWORD,LPCWSTR,DWORD);
+WINSHLWAPI BOOL WINAPI PathRelativePathToA(LPSTR,LPCSTR,DWORD,LPCSTR,DWORD);
+WINSHLWAPI BOOL WINAPI PathRelativePathToW(LPWSTR,LPCWSTR,DWORD,LPCWSTR,DWORD);
 #define PathRelativePathTo WINELIB_NAME_AW(PathRelativePathTo)
 
-VOID WINAPI PathRemoveArgsA(LPSTR);
-VOID WINAPI PathRemoveArgsW(LPWSTR);
+WINSHLWAPI VOID WINAPI PathRemoveArgsA(LPSTR);
+WINSHLWAPI VOID WINAPI PathRemoveArgsW(LPWSTR);
 #define PathRemoveArgs WINELIB_NAME_AW(PathRemoveArgs)
 
-LPSTR  WINAPI PathRemoveBackslashA(LPSTR);
-LPWSTR WINAPI PathRemoveBackslashW(LPWSTR);
+WINSHLWAPI LPSTR  WINAPI PathRemoveBackslashA(LPSTR);
+WINSHLWAPI LPWSTR WINAPI PathRemoveBackslashW(LPWSTR);
 #define PathRemoveBackslash WINELIB_NAME_AW(PathRemoveBackslash)
 
-VOID WINAPI PathRemoveBlanksA(LPSTR);
-VOID WINAPI PathRemoveBlanksW(LPWSTR);
+WINSHLWAPI VOID WINAPI PathRemoveBlanksA(LPSTR);
+WINSHLWAPI VOID WINAPI PathRemoveBlanksW(LPWSTR);
 #define PathRemoveBlanks WINELIB_NAME_AW(PathRemoveBlanks)
 
-VOID WINAPI PathRemoveExtensionA(LPSTR);
-VOID WINAPI PathRemoveExtensionW(LPWSTR);
+WINSHLWAPI VOID WINAPI PathRemoveExtensionA(LPSTR);
+WINSHLWAPI VOID WINAPI PathRemoveExtensionW(LPWSTR);
 #define PathRemoveExtension WINELIB_NAME_AW(PathRemoveExtension)
 
-BOOL WINAPI PathRemoveFileSpecA(LPSTR);
-BOOL WINAPI PathRemoveFileSpecW(LPWSTR);
+WINSHLWAPI BOOL WINAPI PathRemoveFileSpecA(LPSTR);
+WINSHLWAPI BOOL WINAPI PathRemoveFileSpecW(LPWSTR);
 #define PathRemoveFileSpec WINELIB_NAME_AW(PathRemoveFileSpec)
 
-BOOL WINAPI PathRenameExtensionA(LPSTR,LPCSTR);
-BOOL WINAPI PathRenameExtensionW(LPWSTR,LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathRenameExtensionA(LPSTR,LPCSTR);
+WINSHLWAPI BOOL WINAPI PathRenameExtensionW(LPWSTR,LPCWSTR);
 #define PathRenameExtension WINELIB_NAME_AW(PathRenameExtension)
 
-BOOL WINAPI PathSearchAndQualifyA(LPCSTR,LPSTR,UINT);
-BOOL WINAPI PathSearchAndQualifyW(LPCWSTR,LPWSTR,UINT);
+WINSHLWAPI BOOL WINAPI PathSearchAndQualifyA(LPCSTR,LPSTR,UINT);
+WINSHLWAPI BOOL WINAPI PathSearchAndQualifyW(LPCWSTR,LPWSTR,UINT);
 #define PathSearchAndQualify WINELIB_NAME_AW(PathSearchAndQualify)
 
-VOID WINAPI PathSetDlgItemPathA(HWND,int,LPCSTR);
-VOID WINAPI PathSetDlgItemPathW(HWND,int,LPCWSTR);
+WINSHLWAPI VOID WINAPI PathSetDlgItemPathA(HWND,int,LPCSTR);
+WINSHLWAPI VOID WINAPI PathSetDlgItemPathW(HWND,int,LPCWSTR);
 #define PathSetDlgItemPath WINELIB_NAME_AW(PathSetDlgItemPath)
 
-LPSTR  WINAPI PathSkipRootA(LPCSTR);
-LPWSTR WINAPI PathSkipRootW(LPCWSTR);
+WINSHLWAPI LPSTR  WINAPI PathSkipRootA(LPCSTR);
+WINSHLWAPI LPWSTR WINAPI PathSkipRootW(LPCWSTR);
 #define PathSkipRoot WINELIB_NAME_AW(PathSkipRoot)
 
-VOID WINAPI PathStripPathA(LPSTR);
-VOID WINAPI PathStripPathW(LPWSTR);
+WINSHLWAPI VOID WINAPI PathStripPathA(LPSTR);
+WINSHLWAPI VOID WINAPI PathStripPathW(LPWSTR);
 #define PathStripPath WINELIB_NAME_AW(PathStripPath)
 
-BOOL WINAPI PathStripToRootA(LPSTR);
-BOOL WINAPI PathStripToRootW(LPWSTR);
+WINSHLWAPI BOOL WINAPI PathStripToRootA(LPSTR);
+WINSHLWAPI BOOL WINAPI PathStripToRootW(LPWSTR);
 #define PathStripToRoot WINELIB_NAME_AW(PathStripToRoot)
 
-VOID WINAPI PathUnquoteSpacesA(LPSTR);
-VOID WINAPI PathUnquoteSpacesW(LPWSTR);
+WINSHLWAPI VOID WINAPI PathUnquoteSpacesA(LPSTR);
+WINSHLWAPI VOID WINAPI PathUnquoteSpacesW(LPWSTR);
 #define PathUnquoteSpaces WINELIB_NAME_AW(PathUnquoteSpaces)
 
-BOOL WINAPI PathMakeSystemFolderA(LPCSTR);
-BOOL WINAPI PathMakeSystemFolderW(LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathMakeSystemFolderA(LPCSTR);
+WINSHLWAPI BOOL WINAPI PathMakeSystemFolderW(LPCWSTR);
 #define PathMakeSystemFolder WINELIB_NAME_AW(PathMakeSystemFolder)
 
-BOOL WINAPI PathUnmakeSystemFolderA(LPCSTR);
-BOOL WINAPI PathUnmakeSystemFolderW(LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathUnmakeSystemFolderA(LPCSTR);
+WINSHLWAPI BOOL WINAPI PathUnmakeSystemFolderW(LPCWSTR);
 #define PathUnmakeSystemFolder WINELIB_NAME_AW(PathUnmakeSystemFolder)
 
-BOOL WINAPI PathIsSystemFolderA(LPCSTR,DWORD);
-BOOL WINAPI PathIsSystemFolderW(LPCWSTR,DWORD);
+WINSHLWAPI BOOL WINAPI PathIsSystemFolderA(LPCSTR,DWORD);
+WINSHLWAPI BOOL WINAPI PathIsSystemFolderW(LPCWSTR,DWORD);
 #define PathIsSystemFolder WINELIB_NAME_AW(PathIsSystemFolder)
 
-BOOL WINAPI PathIsNetworkPathA(LPCSTR);
-BOOL WINAPI PathIsNetworkPathW(LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathIsNetworkPathA(LPCSTR);
+WINSHLWAPI BOOL WINAPI PathIsNetworkPathW(LPCWSTR);
 #define PathIsNetworkPath WINELIB_NAME_AW(PathIsNetworkPath)
 
-BOOL WINAPI PathIsLFNFileSpecA(LPCSTR);
-BOOL WINAPI PathIsLFNFileSpecW(LPCWSTR);
+WINSHLWAPI BOOL WINAPI PathIsLFNFileSpecA(LPCSTR);
+WINSHLWAPI BOOL WINAPI PathIsLFNFileSpecW(LPCWSTR);
 #define PathIsLFNFileSpec WINELIB_NAME_AW(PathIsLFNFileSpec)
 
-LPCSTR WINAPI PathFindSuffixArrayA(LPCSTR,LPCSTR *,int);
-LPCWSTR WINAPI PathFindSuffixArrayW(LPCWSTR,LPCWSTR *,int);
+WINSHLWAPI LPCSTR WINAPI PathFindSuffixArrayA(LPCSTR,LPCSTR *,int);
+WINSHLWAPI LPCWSTR WINAPI PathFindSuffixArrayW(LPCWSTR,LPCWSTR *,int);
 #define PathFindSuffixArray WINELIB_NAME_AW(PathFindSuffixArray)
 
-VOID WINAPI PathUndecorateA(LPSTR);
-VOID WINAPI PathUndecorateW(LPWSTR);
+WINSHLWAPI VOID WINAPI PathUndecorateA(LPSTR);
+WINSHLWAPI VOID WINAPI PathUndecorateW(LPWSTR);
 #define PathUndecorate WINELIB_NAME_AW(PathUndecorate)
 
-BOOL WINAPI PathUnExpandEnvStringsA(LPCSTR,LPSTR,UINT);
-BOOL WINAPI PathUnExpandEnvStringsW(LPCWSTR,LPWSTR,UINT);
+WINSHLWAPI BOOL WINAPI PathUnExpandEnvStringsA(LPCSTR,LPSTR,UINT);
+WINSHLWAPI BOOL WINAPI PathUnExpandEnvStringsW(LPCWSTR,LPWSTR,UINT);
 #define PathUnExpandEnvStrings WINELIB_NAME_AW(PathUnExpandEnvStrings)
 
 /* Url functions */
@@ -677,24 +685,24 @@ typedef enum {
 #define URL_UNESCAPE_AS_UTF8            URL_ESCAPE_AS_UTF8
 #define URL_UNESCAPE_URI_COMPONENT      URL_UNESCAPE_AS_UTF8
 
-HRESULT WINAPI UrlApplySchemeA(LPCSTR,LPSTR,LPDWORD,DWORD);
-HRESULT WINAPI UrlApplySchemeW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlApplySchemeA(LPCSTR,LPSTR,LPDWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlApplySchemeW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
 #define UrlApplyScheme WINELIB_NAME_AW(UrlApplyScheme)
 
-HRESULT WINAPI UrlCanonicalizeA(LPCSTR,LPSTR,LPDWORD,DWORD);
-HRESULT WINAPI UrlCanonicalizeW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlCanonicalizeA(LPCSTR,LPSTR,LPDWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlCanonicalizeW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
 #define UrlCanonicalize WINELIB_NAME_AW(UrlCanonicalize)
 
-HRESULT WINAPI UrlCombineA(LPCSTR,LPCSTR,LPSTR,LPDWORD,DWORD);
-HRESULT WINAPI UrlCombineW(LPCWSTR,LPCWSTR,LPWSTR,LPDWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlCombineA(LPCSTR,LPCSTR,LPSTR,LPDWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlCombineW(LPCWSTR,LPCWSTR,LPWSTR,LPDWORD,DWORD);
 #define UrlCombine WINELIB_NAME_AW(UrlCombine)
 
-INT WINAPI UrlCompareA(LPCSTR,LPCSTR,BOOL);
-INT WINAPI UrlCompareW(LPCWSTR,LPCWSTR,BOOL);
+WINSHLWAPI INT WINAPI UrlCompareA(LPCSTR,LPCSTR,BOOL);
+WINSHLWAPI INT WINAPI UrlCompareW(LPCWSTR,LPCWSTR,BOOL);
 #define UrlCompare WINELIB_NAME_AW(UrlCompare)
 
-HRESULT WINAPI UrlEscapeA(LPCSTR,LPSTR,LPDWORD,DWORD);
-HRESULT WINAPI UrlEscapeW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlEscapeA(LPCSTR,LPSTR,LPDWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlEscapeW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
 #define UrlEscape WINELIB_NAME_AW(UrlEscape)
 
 #define UrlEscapeSpacesA(x,y,z) UrlCanonicalizeA(x, y, z, \
@@ -703,38 +711,38 @@ HRESULT WINAPI UrlEscapeW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
                          URL_DONT_ESCAPE_EXTRA_INFO|URL_ESCAPE_SPACES_ONLY)
 #define UrlEscapeSpaces WINELIB_NAME_AW(UrlEscapeSpaces)
 
-LPCSTR  WINAPI UrlGetLocationA(LPCSTR);
-LPCWSTR WINAPI UrlGetLocationW(LPCWSTR);
+WINSHLWAPI LPCSTR  WINAPI UrlGetLocationA(LPCSTR);
+WINSHLWAPI LPCWSTR WINAPI UrlGetLocationW(LPCWSTR);
 #define UrlGetLocation WINELIB_NAME_AW(UrlGetLocation)
 
-HRESULT WINAPI UrlGetPartA(LPCSTR,LPSTR,LPDWORD,DWORD,DWORD);
-HRESULT WINAPI UrlGetPartW(LPCWSTR,LPWSTR,LPDWORD,DWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlGetPartA(LPCSTR,LPSTR,LPDWORD,DWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlGetPartW(LPCWSTR,LPWSTR,LPDWORD,DWORD,DWORD);
 #define UrlGetPart WINELIB_NAME_AW(UrlGetPart)
 
-HRESULT WINAPI HashData(const unsigned char *,DWORD,unsigned char *lpDest,DWORD);
+WINSHLWAPI HRESULT WINAPI HashData(const unsigned char *,DWORD,unsigned char *lpDest,DWORD);
 
-HRESULT WINAPI UrlHashA(LPCSTR,unsigned char *,DWORD);
-HRESULT WINAPI UrlHashW(LPCWSTR,unsigned char *,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlHashA(LPCSTR,unsigned char *,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlHashW(LPCWSTR,unsigned char *,DWORD);
 #define UrlHash WINELIB_NAME_AW(UrlHash)
 
-BOOL    WINAPI UrlIsA(LPCSTR,URLIS);
-BOOL    WINAPI UrlIsW(LPCWSTR,URLIS);
+WINSHLWAPI BOOL    WINAPI UrlIsA(LPCSTR,URLIS);
+WINSHLWAPI BOOL    WINAPI UrlIsW(LPCWSTR,URLIS);
 #define UrlIs WINELIB_NAME_AW(UrlIs)
 
-BOOL    WINAPI UrlIsNoHistoryA(LPCSTR);
-BOOL    WINAPI UrlIsNoHistoryW(LPCWSTR);
+WINSHLWAPI BOOL    WINAPI UrlIsNoHistoryA(LPCSTR);
+WINSHLWAPI BOOL    WINAPI UrlIsNoHistoryW(LPCWSTR);
 #define UrlIsNoHistory WINELIB_NAME_AW(UrlIsNoHistory)
 
-BOOL    WINAPI UrlIsOpaqueA(LPCSTR);
-BOOL    WINAPI UrlIsOpaqueW(LPCWSTR);
+WINSHLWAPI BOOL    WINAPI UrlIsOpaqueA(LPCSTR);
+WINSHLWAPI BOOL    WINAPI UrlIsOpaqueW(LPCWSTR);
 #define UrlIsOpaque WINELIB_NAME_AW(UrlIsOpaque)
 
 #define UrlIsFileUrlA(x) UrlIsA(x, URLIS_FILEURL)
 #define UrlIsFileUrlW(x) UrlIsW(x, URLIS_FILEURL)
 #define UrlIsFileUrl WINELIB_NAME_AW(UrlIsFileUrl)
 
-HRESULT WINAPI UrlUnescapeA(LPSTR,LPSTR,LPDWORD,DWORD);
-HRESULT WINAPI UrlUnescapeW(LPWSTR,LPWSTR,LPDWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlUnescapeA(LPSTR,LPSTR,LPDWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlUnescapeW(LPWSTR,LPWSTR,LPDWORD,DWORD);
 #define UrlUnescape WINELIB_NAME_AW(UrlUnescape)
 
 #define UrlUnescapeInPlaceA(x,y) UrlUnescapeA(x, NULL, NULL, \
@@ -743,8 +751,8 @@ HRESULT WINAPI UrlUnescapeW(LPWSTR,LPWSTR,LPDWORD,DWORD);
                                               y | URL_UNESCAPE_INPLACE)
 #define UrlUnescapeInPlace WINELIB_NAME_AW(UrlUnescapeInPlace)
 
-HRESULT WINAPI UrlCreateFromPathA(LPCSTR,LPSTR,LPDWORD,DWORD);
-HRESULT WINAPI UrlCreateFromPathW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlCreateFromPathA(LPCSTR,LPSTR,LPDWORD,DWORD);
+WINSHLWAPI HRESULT WINAPI UrlCreateFromPathW(LPCWSTR,LPWSTR,LPDWORD,DWORD);
 #define UrlCreateFromPath WINELIB_NAME_AW(UrlCreateFromPath)
 
 typedef struct tagPARSEDURLA {
@@ -765,8 +773,8 @@ typedef struct tagPARSEDURLW {
     UINT nScheme;
 } PARSEDURLW, *PPARSEDURLW;
 
-HRESULT WINAPI ParseURLA(LPCSTR pszUrl, PARSEDURLA *ppu);
-HRESULT WINAPI ParseURLW(LPCWSTR pszUrl, PARSEDURLW *ppu);
+WINSHLWAPI HRESULT WINAPI ParseURLA(LPCSTR pszUrl, PARSEDURLA *ppu);
+WINSHLWAPI HRESULT WINAPI ParseURLW(LPCWSTR pszUrl, PARSEDURLW *ppu);
 #define ParseURL WINELIB_NAME_AW(ParseUrl)
 
 #endif /* NO_SHLWAPI_PATH */
@@ -779,78 +787,78 @@ HRESULT WINAPI ParseURLW(LPCWSTR pszUrl, PARSEDURLW *ppu);
 #define STIF_DEFAULT     __MSABI_LONG(0x0)
 #define STIF_SUPPORT_HEX __MSABI_LONG(0x1)
 
-BOOL WINAPI ChrCmpIA (WORD,WORD);
-BOOL WINAPI ChrCmpIW (WCHAR,WCHAR);
+WINSHLWAPI BOOL WINAPI ChrCmpIA (WORD,WORD);
+WINSHLWAPI BOOL WINAPI ChrCmpIW (WCHAR,WCHAR);
 #define ChrCmpI WINELIB_NAME_AW(ChrCmpI)
 
-INT WINAPI StrCSpnA(LPCSTR,LPCSTR);
-INT WINAPI StrCSpnW(LPCWSTR,LPCWSTR);
+WINSHLWAPI INT WINAPI StrCSpnA(LPCSTR,LPCSTR);
+WINSHLWAPI INT WINAPI StrCSpnW(LPCWSTR,LPCWSTR);
 #define StrCSpn WINELIB_NAME_AW(StrCSpn)
 
-INT WINAPI StrCSpnIA(LPCSTR,LPCSTR);
-INT WINAPI StrCSpnIW(LPCWSTR,LPCWSTR);
+WINSHLWAPI INT WINAPI StrCSpnIA(LPCSTR,LPCSTR);
+WINSHLWAPI INT WINAPI StrCSpnIW(LPCWSTR,LPCWSTR);
 #define StrCSpnI WINELIB_NAME_AW(StrCSpnI)
 
 #define StrCatA lstrcatA
-LPWSTR WINAPI StrCatW(LPWSTR,LPCWSTR);
+WINSHLWAPI LPWSTR WINAPI StrCatW(LPWSTR,LPCWSTR);
 #define StrCat WINELIB_NAME_AW(StrCat)
 
-LPSTR WINAPI StrCatBuffA(LPSTR,LPCSTR,INT);
-LPWSTR WINAPI StrCatBuffW(LPWSTR,LPCWSTR,INT);
+WINSHLWAPI LPSTR WINAPI StrCatBuffA(LPSTR,LPCSTR,INT);
+WINSHLWAPI LPWSTR WINAPI StrCatBuffW(LPWSTR,LPCWSTR,INT);
 #define StrCatBuff WINELIB_NAME_AW(StrCatBuff)
 
-DWORD WINAPI StrCatChainW(LPWSTR,DWORD,DWORD,LPCWSTR);
+WINSHLWAPI DWORD WINAPI StrCatChainW(LPWSTR,DWORD,DWORD,LPCWSTR);
 
-LPSTR WINAPI StrChrA(LPCSTR,WORD);
-LPWSTR WINAPI StrChrW(LPCWSTR,WCHAR);
+WINSHLWAPI LPSTR WINAPI StrChrA(LPCSTR,WORD);
+WINSHLWAPI LPWSTR WINAPI StrChrW(LPCWSTR,WCHAR);
 #define StrChr WINELIB_NAME_AW(StrChr)
 
-LPSTR WINAPI StrChrIA(LPCSTR,WORD);
-LPWSTR WINAPI StrChrIW(LPCWSTR,WCHAR);
+WINSHLWAPI LPSTR WINAPI StrChrIA(LPCSTR,WORD);
+WINSHLWAPI LPWSTR WINAPI StrChrIW(LPCWSTR,WCHAR);
 #define StrChrI WINELIB_NAME_AW(StrChrI)
 
 #define StrCmpA lstrcmpA
-int WINAPI StrCmpW(LPCWSTR,LPCWSTR);
+WINSHLWAPI int WINAPI StrCmpW(LPCWSTR,LPCWSTR);
 #define StrCmp WINELIB_NAME_AW(StrCmp)
 
 #define StrCmpIA lstrcmpiA
-int WINAPI StrCmpIW(LPCWSTR,LPCWSTR);
+WINSHLWAPI int WINAPI StrCmpIW(LPCWSTR,LPCWSTR);
 #define StrCmpI WINELIB_NAME_AW(StrCmpI)
 
 #define StrCpyA lstrcpyA
-LPWSTR WINAPI StrCpyW(LPWSTR,LPCWSTR);
+WINSHLWAPI LPWSTR WINAPI StrCpyW(LPWSTR,LPCWSTR);
 #define StrCpy WINELIB_NAME_AW(StrCpy)
 
 #define StrCpyNA lstrcpynA
-LPWSTR WINAPI StrCpyNW(LPWSTR,LPCWSTR,int);
+WINSHLWAPI LPWSTR WINAPI StrCpyNW(LPWSTR,LPCWSTR,int);
 #define StrCpyN WINELIB_NAME_AW(StrCpyN)
 #define StrNCpy WINELIB_NAME_AW(StrCpyN)
 
-INT WINAPI StrCmpLogicalW(LPCWSTR,LPCWSTR);
+WINSHLWAPI INT WINAPI StrCmpLogicalW(LPCWSTR,LPCWSTR);
 
-INT WINAPI StrCmpNA(LPCSTR,LPCSTR,INT);
-INT WINAPI StrCmpNW(LPCWSTR,LPCWSTR,INT);
+WINSHLWAPI INT WINAPI StrCmpNA(LPCSTR,LPCSTR,INT);
+WINSHLWAPI INT WINAPI StrCmpNW(LPCWSTR,LPCWSTR,INT);
 #define StrCmpN WINELIB_NAME_AW(StrCmpN)
 #define StrNCmp WINELIB_NAME_AW(StrCmpN)
 
-INT WINAPI StrCmpNIA(LPCSTR,LPCSTR,INT);
-INT WINAPI StrCmpNIW(LPCWSTR,LPCWSTR,INT);
+WINSHLWAPI INT WINAPI StrCmpNIA(LPCSTR,LPCSTR,INT);
+WINSHLWAPI INT WINAPI StrCmpNIW(LPCWSTR,LPCWSTR,INT);
 #define StrCmpNI WINELIB_NAME_AW(StrCmpNI)
 #define StrNCmpI WINELIB_NAME_AW(StrCmpNI)
 
-char * WINAPI StrDupA(const char *) __WINE_DEALLOC(LocalFree) __WINE_MALLOC;
-WCHAR * WINAPI StrDupW(const WCHAR *) __WINE_DEALLOC(LocalFree) __WINE_MALLOC;
+WINSHLWAPI char * WINAPI StrDupA(const char *) __WINE_DEALLOC(LocalFree) __WINE_MALLOC;
+WINSHLWAPI WCHAR * WINAPI StrDupW(const WCHAR *) __WINE_DEALLOC(LocalFree) __WINE_MALLOC;
 #define StrDup WINELIB_NAME_AW(StrDup)
 
-HRESULT WINAPI SHStrDupA(LPCSTR,WCHAR**);
-HRESULT WINAPI SHStrDupW(LPCWSTR,WCHAR**);
+WINSHLWAPI HRESULT WINAPI SHStrDupA(LPCSTR,WCHAR**);
+WINSHLWAPI HRESULT WINAPI SHStrDupW(LPCWSTR,WCHAR**);
 #define SHStrDup WINELIB_NAME_AW(SHStrDup)
 
-LPSTR WINAPI StrFormatByteSizeA (DWORD,LPSTR,UINT);
+WINSHLWAPI LPSTR WINAPI StrFormatByteSizeA (DWORD,LPSTR,UINT);
 
 /* A/W Pairing is broken for this function */
-LPSTR WINAPI StrFormatByteSize64A (LONGLONG,LPSTR,UINT);
-LPWSTR WINAPI StrFormatByteSizeW (LONGLONG,LPWSTR,UINT);
+WINSHLWAPI LPSTR WINAPI StrFormatByteSize64A (LONGLONG,LPSTR,UINT);
+WINSHLWAPI LPWSTR WINAPI StrFormatByteSizeW (LONGLONG,LPWSTR,UINT);
 #ifndef WINE_NO_UNICODE_MACROS
 #ifdef UNICODE
 #define StrFormatByteSize StrFormatByteSizeW
@@ -859,16 +867,16 @@ LPWSTR WINAPI StrFormatByteSizeW (LONGLONG,LPWSTR,UINT);
 #endif
 #endif
 
-LPSTR WINAPI StrFormatKBSizeA(LONGLONG,LPSTR,UINT);
-LPWSTR WINAPI StrFormatKBSizeW(LONGLONG,LPWSTR,UINT);
+WINSHLWAPI LPSTR WINAPI StrFormatKBSizeA(LONGLONG,LPSTR,UINT);
+WINSHLWAPI LPWSTR WINAPI StrFormatKBSizeW(LONGLONG,LPWSTR,UINT);
 #define StrFormatKBSize WINELIB_NAME_AW(StrFormatKBSize)
 
-int WINAPI StrFromTimeIntervalA(LPSTR,UINT,DWORD,int);
-int WINAPI StrFromTimeIntervalW(LPWSTR,UINT,DWORD,int);
+WINSHLWAPI int WINAPI StrFromTimeIntervalA(LPSTR,UINT,DWORD,int);
+WINSHLWAPI int WINAPI StrFromTimeIntervalW(LPWSTR,UINT,DWORD,int);
 #define StrFromTimeInterval WINELIB_NAME_AW(StrFromTimeInterval)
 
-BOOL WINAPI StrIsIntlEqualA(BOOL,LPCSTR,LPCSTR,int);
-BOOL WINAPI StrIsIntlEqualW(BOOL,LPCWSTR,LPCWSTR,int);
+WINSHLWAPI BOOL WINAPI StrIsIntlEqualA(BOOL,LPCSTR,LPCSTR,int);
+WINSHLWAPI BOOL WINAPI StrIsIntlEqualW(BOOL,LPCWSTR,LPCWSTR,int);
 #define StrIsIntlEqual WINELIB_NAME_AW(StrIsIntlEqual)
 
 #define StrIntlEqNA(a,b,c) StrIsIntlEqualA(TRUE,a,b,c)
@@ -877,71 +885,71 @@ BOOL WINAPI StrIsIntlEqualW(BOOL,LPCWSTR,LPCWSTR,int);
 #define StrIntlEqNIA(a,b,c) StrIsIntlEqualA(FALSE,a,b,c)
 #define StrIntlEqNIW(a,b,c) StrIsIntlEqualW(FALSE,a,b,c)
 
-LPSTR  WINAPI StrNCatA(LPSTR,LPCSTR,int);
-LPWSTR WINAPI StrNCatW(LPWSTR,LPCWSTR,int);
+WINSHLWAPI LPSTR  WINAPI StrNCatA(LPSTR,LPCSTR,int);
+WINSHLWAPI LPWSTR WINAPI StrNCatW(LPWSTR,LPCWSTR,int);
 #define StrNCat WINELIB_NAME_AW(StrNCat)
 #define StrCatN WINELIB_NAME_AW(StrNCat)
 
-LPSTR  WINAPI StrPBrkA(LPCSTR,LPCSTR);
-LPWSTR WINAPI StrPBrkW(LPCWSTR,LPCWSTR);
+WINSHLWAPI LPSTR  WINAPI StrPBrkA(LPCSTR,LPCSTR);
+WINSHLWAPI LPWSTR WINAPI StrPBrkW(LPCWSTR,LPCWSTR);
 #define StrPBrk WINELIB_NAME_AW(StrPBrk)
 
-LPSTR  WINAPI StrRChrA(LPCSTR,LPCSTR,WORD);
-LPWSTR WINAPI StrRChrW(LPCWSTR,LPCWSTR,WORD);
+WINSHLWAPI LPSTR  WINAPI StrRChrA(LPCSTR,LPCSTR,WORD);
+WINSHLWAPI LPWSTR WINAPI StrRChrW(LPCWSTR,LPCWSTR,WORD);
 #define StrRChr WINELIB_NAME_AW(StrRChr)
 
-LPSTR  WINAPI StrRChrIA(LPCSTR,LPCSTR,WORD);
-LPWSTR WINAPI StrRChrIW(LPCWSTR,LPCWSTR,WORD);
+WINSHLWAPI LPSTR  WINAPI StrRChrIA(LPCSTR,LPCSTR,WORD);
+WINSHLWAPI LPWSTR WINAPI StrRChrIW(LPCWSTR,LPCWSTR,WORD);
 #define StrRChrI WINELIB_NAME_AW(StrRChrI)
 
-LPSTR  WINAPI StrRStrIA(LPCSTR,LPCSTR,LPCSTR);
-LPWSTR WINAPI StrRStrIW(LPCWSTR,LPCWSTR,LPCWSTR);
+WINSHLWAPI LPSTR  WINAPI StrRStrIA(LPCSTR,LPCSTR,LPCSTR);
+WINSHLWAPI LPWSTR WINAPI StrRStrIW(LPCWSTR,LPCWSTR,LPCWSTR);
 #define StrRStrI WINELIB_NAME_AW(StrRStrI)
 
-int WINAPI StrSpnA(LPCSTR,LPCSTR);
-int WINAPI StrSpnW(LPCWSTR,LPCWSTR);
+WINSHLWAPI int WINAPI StrSpnA(LPCSTR,LPCSTR);
+WINSHLWAPI int WINAPI StrSpnW(LPCWSTR,LPCWSTR);
 #define StrSpn WINELIB_NAME_AW(StrSpn)
 
-LPSTR  WINAPI StrStrA(LPCSTR,LPCSTR);
-LPWSTR WINAPI StrStrW(LPCWSTR,LPCWSTR);
+WINSHLWAPI LPSTR  WINAPI StrStrA(LPCSTR,LPCSTR);
+WINSHLWAPI LPWSTR WINAPI StrStrW(LPCWSTR,LPCWSTR);
 #define StrStr WINELIB_NAME_AW(StrStr)
 
-LPSTR  WINAPI StrStrIA(LPCSTR,LPCSTR);
-LPWSTR WINAPI StrStrIW(LPCWSTR,LPCWSTR);
+WINSHLWAPI LPSTR  WINAPI StrStrIA(LPCSTR,LPCSTR);
+WINSHLWAPI LPWSTR WINAPI StrStrIW(LPCWSTR,LPCWSTR);
 #define StrStrI WINELIB_NAME_AW(StrStrI)
 
-LPWSTR WINAPI StrStrNW(LPCWSTR,LPCWSTR,UINT);
-LPWSTR WINAPI StrStrNIW(LPCWSTR,LPCWSTR,UINT);
+WINSHLWAPI LPWSTR WINAPI StrStrNW(LPCWSTR,LPCWSTR,UINT);
+WINSHLWAPI LPWSTR WINAPI StrStrNIW(LPCWSTR,LPCWSTR,UINT);
 
-int WINAPI StrToIntA(LPCSTR);
-int WINAPI StrToIntW(LPCWSTR);
+WINSHLWAPI int WINAPI StrToIntA(LPCSTR);
+WINSHLWAPI int WINAPI StrToIntW(LPCWSTR);
 #define StrToInt WINELIB_NAME_AW(StrToInt)
 #define StrToLong WINELIB_NAME_AW(StrToInt)
 
-BOOL WINAPI StrToIntExA(LPCSTR,DWORD,int*);
-BOOL WINAPI StrToIntExW(LPCWSTR,DWORD,int*);
+WINSHLWAPI BOOL WINAPI StrToIntExA(LPCSTR,DWORD,int*);
+WINSHLWAPI BOOL WINAPI StrToIntExW(LPCWSTR,DWORD,int*);
 #define StrToIntEx WINELIB_NAME_AW(StrToIntEx)
 
-BOOL WINAPI StrToInt64ExA(LPCSTR,DWORD,LONGLONG*);
-BOOL WINAPI StrToInt64ExW(LPCWSTR,DWORD,LONGLONG*);
+WINSHLWAPI BOOL WINAPI StrToInt64ExA(LPCSTR,DWORD,LONGLONG*);
+WINSHLWAPI BOOL WINAPI StrToInt64ExW(LPCWSTR,DWORD,LONGLONG*);
 #define StrToIntEx64 WINELIB_NAME_AW(StrToIntEx64)
 
-BOOL WINAPI StrTrimA(LPSTR,LPCSTR);
-BOOL WINAPI StrTrimW(LPWSTR,LPCWSTR);
+WINSHLWAPI BOOL WINAPI StrTrimA(LPSTR,LPCSTR);
+WINSHLWAPI BOOL WINAPI StrTrimW(LPWSTR,LPCWSTR);
 #define StrTrim WINELIB_NAME_AW(StrTrim)
 
-INT WINAPI wvnsprintfA(LPSTR,INT,LPCSTR,__ms_va_list);
-INT WINAPI wvnsprintfW(LPWSTR,INT,LPCWSTR,__ms_va_list);
+WINSHLWAPI INT WINAPI wvnsprintfA(LPSTR,INT,LPCSTR,__ms_va_list);
+WINSHLWAPI INT WINAPI wvnsprintfW(LPWSTR,INT,LPCWSTR,__ms_va_list);
 #define wvnsprintf WINELIB_NAME_AW(wvnsprintf)
 
-INT WINAPIV wnsprintfA(LPSTR,INT,LPCSTR, ...);
-INT WINAPIV wnsprintfW(LPWSTR,INT,LPCWSTR, ...);
+WINSHLWAPI INT WINAPIV wnsprintfA(LPSTR,INT,LPCSTR, ...);
+WINSHLWAPI INT WINAPIV wnsprintfW(LPWSTR,INT,LPCWSTR, ...);
 #define wnsprintf WINELIB_NAME_AW(wnsprintf)
 
-HRESULT WINAPI SHLoadIndirectString(LPCWSTR,LPWSTR,UINT,PVOID*);
+WINSHLWAPI HRESULT WINAPI SHLoadIndirectString(LPCWSTR,LPWSTR,UINT,PVOID*);
 
-BOOL WINAPI IntlStrEqWorkerA(BOOL,LPCSTR,LPCSTR,int);
-BOOL WINAPI IntlStrEqWorkerW(BOOL,LPCWSTR,LPCWSTR,int);
+WINSHLWAPI BOOL WINAPI IntlStrEqWorkerA(BOOL,LPCSTR,LPCSTR,int);
+WINSHLWAPI BOOL WINAPI IntlStrEqWorkerW(BOOL,LPCWSTR,LPCWSTR,int);
 #define IntlStrEqWorker WINELIB_NAME_AW(IntlStrEqWorker)
 
 #define IntlStrEqNA(s1,s2,n) IntlStrEqWorkerA(TRUE,s1,s2,n)
@@ -952,18 +960,18 @@ BOOL WINAPI IntlStrEqWorkerW(BOOL,LPCWSTR,LPCWSTR,int);
 #define IntlStrEqNIW(s1,s2,n) IntlStrEqWorkerW(FALSE,s1,s2,n)
 #define IntlStrEqNI WINELIB_NAME_AW(IntlStrEqNI)
 
-HRESULT WINAPI StrRetToStrA(STRRET*,LPCITEMIDLIST,LPSTR*);
-HRESULT WINAPI StrRetToStrW(STRRET*,LPCITEMIDLIST,LPWSTR*);
+WINSHLWAPI HRESULT WINAPI StrRetToStrA(STRRET*,LPCITEMIDLIST,LPSTR*);
+WINSHLWAPI HRESULT WINAPI StrRetToStrW(STRRET*,LPCITEMIDLIST,LPWSTR*);
 #define StrRetToStr WINELIB_NAME_AW(StrRetToStr)
 
-HRESULT WINAPI StrRetToBufA(STRRET*,LPCITEMIDLIST,LPSTR,UINT);
-HRESULT WINAPI StrRetToBufW(STRRET*,LPCITEMIDLIST,LPWSTR,UINT);
+WINSHLWAPI HRESULT WINAPI StrRetToBufA(STRRET*,LPCITEMIDLIST,LPSTR,UINT);
+WINSHLWAPI HRESULT WINAPI StrRetToBufW(STRRET*,LPCITEMIDLIST,LPWSTR,UINT);
 #define StrRetToBuf WINELIB_NAME_AW(StrRetToBuf)
 
-HRESULT WINAPI StrRetToBSTR(STRRET*,LPCITEMIDLIST,BSTR*);
+WINSHLWAPI HRESULT WINAPI StrRetToBSTR(STRRET*,LPCITEMIDLIST,BSTR*);
 
-BOOL WINAPI IsCharSpaceA(CHAR);
-BOOL WINAPI IsCharSpaceW(WCHAR);
+WINSHLWAPI BOOL WINAPI IsCharSpaceA(CHAR);
+WINSHLWAPI BOOL WINAPI IsCharSpaceW(WCHAR);
 #define IsCharSpace WINELIB_NAME_AW(IsCharSpace)
 
 #endif /* NO_SHLWAPI_STRFCNS */
@@ -972,42 +980,42 @@ BOOL WINAPI IsCharSpaceW(WCHAR);
 /* GDI functions */
 #ifndef NO_SHLWAPI_GDI
 
-HPALETTE WINAPI SHCreateShellPalette(HDC);
+WINSHLWAPI HPALETTE WINAPI SHCreateShellPalette(HDC);
 
-COLORREF WINAPI ColorHLSToRGB(WORD,WORD,WORD);
+WINSHLWAPI COLORREF WINAPI ColorHLSToRGB(WORD,WORD,WORD);
 
-COLORREF WINAPI ColorAdjustLuma(COLORREF,int,BOOL);
+WINSHLWAPI COLORREF WINAPI ColorAdjustLuma(COLORREF,int,BOOL);
 
-VOID WINAPI ColorRGBToHLS(COLORREF,LPWORD,LPWORD,LPWORD);
+WINSHLWAPI VOID WINAPI ColorRGBToHLS(COLORREF,LPWORD,LPWORD,LPWORD);
 
 #endif /* NO_SHLWAPI_GDI */
 
 /* Security functions */
-BOOL WINAPI IsInternetESCEnabled(void);
+WINSHLWAPI BOOL WINAPI IsInternetESCEnabled(void);
 
 /* Stream functions */
 #ifndef NO_SHLWAPI_STREAM
 
-struct IStream * WINAPI SHOpenRegStreamA(HKEY,LPCSTR,LPCSTR,DWORD);
-struct IStream * WINAPI SHOpenRegStreamW(HKEY,LPCWSTR,LPCWSTR,DWORD);
+WINSHLWAPI struct IStream * WINAPI SHOpenRegStreamA(HKEY,LPCSTR,LPCSTR,DWORD);
+WINSHLWAPI struct IStream * WINAPI SHOpenRegStreamW(HKEY,LPCWSTR,LPCWSTR,DWORD);
 #define SHOpenRegStream WINELIB_NAME_AW(SHOpenRegStream2) /* Uses version 2 */
 
-struct IStream * WINAPI SHOpenRegStream2A(HKEY,LPCSTR,LPCSTR,DWORD);
-struct IStream * WINAPI SHOpenRegStream2W(HKEY,LPCWSTR,LPCWSTR,DWORD);
+WINSHLWAPI struct IStream * WINAPI SHOpenRegStream2A(HKEY,LPCSTR,LPCSTR,DWORD);
+WINSHLWAPI struct IStream * WINAPI SHOpenRegStream2W(HKEY,LPCWSTR,LPCWSTR,DWORD);
 #define SHOpenRegStream2 WINELIB_NAME_AW(SHOpenRegStream2)
 
-HRESULT WINAPI SHCreateStreamOnFileA(LPCSTR,DWORD,struct IStream**);
-HRESULT WINAPI SHCreateStreamOnFileW(LPCWSTR,DWORD,struct IStream**);
+WINSHLWAPI HRESULT WINAPI SHCreateStreamOnFileA(LPCSTR,DWORD,struct IStream**);
+WINSHLWAPI HRESULT WINAPI SHCreateStreamOnFileW(LPCWSTR,DWORD,struct IStream**);
 #define SHCreateStreamOnFile WINELIB_NAME_AW(SHCreateStreamOnFile)
 
-struct IStream * WINAPI SHCreateMemStream(const BYTE*,UINT);
-HRESULT WINAPI SHCreateStreamOnFileEx(LPCWSTR,DWORD,DWORD,BOOL,struct IStream*,struct IStream**);
-HRESULT WINAPI SHCreateStreamWrapper(LPBYTE,DWORD,DWORD,struct IStream**);
+WINSHLWAPI struct IStream * WINAPI SHCreateMemStream(const BYTE*,UINT);
+WINSHLWAPI HRESULT WINAPI SHCreateStreamOnFileEx(LPCWSTR,DWORD,DWORD,BOOL,struct IStream*,struct IStream**);
+WINSHLWAPI HRESULT WINAPI SHCreateStreamWrapper(LPBYTE,DWORD,DWORD,struct IStream**);
 
 #endif /* NO_SHLWAPI_STREAM */
 
-HRESULT WINAPI IStream_Reset(IStream*);
-HRESULT WINAPI IStream_Size(IStream*,ULARGE_INTEGER*);
+WINSHLWAPI HRESULT WINAPI IStream_Reset(IStream*);
+WINSHLWAPI HRESULT WINAPI IStream_Size(IStream*,ULARGE_INTEGER*);
 
 /* SHAutoComplete flags */
 #define SHACF_DEFAULT               0x00000000
@@ -1023,13 +1031,13 @@ HRESULT WINAPI IStream_Size(IStream*,ULARGE_INTEGER*);
 #define SHACF_AUTOAPPEND_FORCE_ON   0x40000000
 #define SHACF_AUTOAPPEND_FORCE_OFF  0x80000000
 
-HRESULT WINAPI SHAutoComplete(HWND,DWORD);
+WINSHLWAPI HRESULT WINAPI SHAutoComplete(HWND,DWORD);
 
 /* Threads */
-HRESULT WINAPI SHCreateThreadRef(LONG*, IUnknown**);
-HRESULT WINAPI SHGetThreadRef(IUnknown**);
-HRESULT WINAPI SHSetThreadRef(IUnknown*);
-HRESULT WINAPI SHReleaseThreadRef(void);
+WINSHLWAPI HRESULT WINAPI SHCreateThreadRef(LONG*, IUnknown**);
+WINSHLWAPI HRESULT WINAPI SHGetThreadRef(IUnknown**);
+WINSHLWAPI HRESULT WINAPI SHSetThreadRef(IUnknown*);
+WINSHLWAPI HRESULT WINAPI SHReleaseThreadRef(void);
 
 /* SHCreateThread flags */
 enum
@@ -1051,9 +1059,9 @@ enum
     CTF_NOADDREFLIB       = 0x00002000,
 };
 
-BOOL WINAPI SHCreateThread(LPTHREAD_START_ROUTINE,void*,DWORD,LPTHREAD_START_ROUTINE);
+WINSHLWAPI BOOL WINAPI SHCreateThread(LPTHREAD_START_ROUTINE,void*,DWORD,LPTHREAD_START_ROUTINE);
 
-BOOL WINAPI SHSkipJunction(struct IBindCtx*,const CLSID*);
+WINSHLWAPI BOOL WINAPI SHSkipJunction(struct IBindCtx*,const CLSID*);
 
 /* Version Information */
 
@@ -1132,7 +1140,7 @@ HRESULT WINAPI DllInstall(BOOL,LPCWSTR) DECLSPEC_HIDDEN;
 #define OS_MEDIACENTER            0x23
 #define OS_APPLIANCE              0x24
 
-BOOL WINAPI IsOS(DWORD);
+WINSHLWAPI BOOL WINAPI IsOS(DWORD);
 
 /* SHSetTimerQueueTimer definitions */
 #define TPS_EXECUTEIO    0x00000001
@@ -1149,8 +1157,8 @@ BOOL WINAPI IsOS(DWORD);
 #define FDTF_RTLDATE            0x00000200
 #define FDTF_NOAUTOREADINGORDER 0x00000400
 
-int WINAPI SHFormatDateTimeA(const FILETIME UNALIGNED *filetime, DWORD *flags, LPSTR buffer, UINT size);
-int WINAPI SHFormatDateTimeW(const FILETIME UNALIGNED *filetime, DWORD *flags, LPWSTR buffer, UINT size);
+WINSHLWAPI int WINAPI SHFormatDateTimeA(const FILETIME UNALIGNED *filetime, DWORD *flags, LPSTR buffer, UINT size);
+WINSHLWAPI int WINAPI SHFormatDateTimeW(const FILETIME UNALIGNED *filetime, DWORD *flags, LPWSTR buffer, UINT size);
 
 typedef struct
 {
@@ -1158,14 +1166,14 @@ typedef struct
     DWORD dwOffset;
 } QITAB, *LPQITAB;
 
-HRESULT WINAPI QISearch(void* base, const QITAB *pqit, REFIID riid, void **ppv);
+WINSHLWAPI HRESULT WINAPI QISearch(void* base, const QITAB *pqit, REFIID riid, void **ppv);
 
 #define PLATFORM_UNKNOWN     0
 #define PLATFORM_IE3         1
 #define PLATFORM_BROWSERONLY 1
 #define PLATFORM_INTEGRATED  2
 
-UINT WINAPI WhichPlatform(void);
+WINSHLWAPI UINT WINAPI WhichPlatform(void);
 
 #define SHGVSPB_PERUSER          0x00000001
 #define SHGVSPB_ALLUSERS         0x00000002
@@ -1179,18 +1187,18 @@ UINT WINAPI WhichPlatform(void);
 #define SHGVSPB_USERDEFAULTS     (SHGVSPB_PERUSER | SHGVSPB_ALLFOLDERS)
 #define SHGVSPB_GLOBALDEFAULTS   (SHGVSPB_ALLUSERS | SHGVSPB_ALLFOLDERS)
 
-HRESULT WINAPI SHGetViewStatePropertyBag(PCIDLIST_ABSOLUTE pidl, PCWSTR bagname, DWORD flags, REFIID riid, void **ppv);
+WINSHLWAPI HRESULT WINAPI SHGetViewStatePropertyBag(PCIDLIST_ABSOLUTE pidl, PCWSTR bagname, DWORD flags, REFIID riid, void **ppv);
 
 #define ILMM_IE4 0
 
-BOOL WINAPI SHIsLowMemoryMachine(DWORD type);
+WINSHLWAPI BOOL WINAPI SHIsLowMemoryMachine(DWORD type);
 
 #include <poppack.h>
 
-HANDLE WINAPI SHAllocShared(const void *data, DWORD size, DWORD pid);
-BOOL WINAPI SHFreeShared(HANDLE handle, DWORD pid);
-void * WINAPI SHLockShared(HANDLE handle, DWORD pid);
-BOOL WINAPI SHUnlockShared(void *data);
+WINSHLWAPI HANDLE WINAPI SHAllocShared(const void *data, DWORD size, DWORD pid);
+WINSHLWAPI BOOL WINAPI SHFreeShared(HANDLE handle, DWORD pid);
+WINSHLWAPI void * WINAPI SHLockShared(HANDLE handle, DWORD pid);
+WINSHLWAPI BOOL WINAPI SHUnlockShared(void *data);
 
 #ifdef __cplusplus
 } /* extern "C" */