Author: akhaldi Date: Tue Aug 13 15:12:04 2013 New Revision: 59722
URL: http://svn.reactos.org/svn/reactos?rev=59722&view=rev Log: [PSDK] * Annotate shlwapi.h.
Modified: trunk/reactos/include/psdk/shlwapi.h
Modified: trunk/reactos/include/psdk/shlwapi.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/include/psdk/shlwapi.h?rev=... ============================================================================== --- trunk/reactos/include/psdk/shlwapi.h [iso-8859-1] (original) +++ trunk/reactos/include/psdk/shlwapi.h [iso-8859-1] Tue Aug 13 15:12:04 2013 @@ -35,55 +35,205 @@
/* Registry functions */
-DWORD WINAPI SHDeleteEmptyKeyA(HKEY,LPCSTR); -DWORD WINAPI SHDeleteEmptyKeyW(HKEY,LPCWSTR); +DWORD WINAPI SHDeleteEmptyKeyA(_In_ HKEY, _In_opt_ LPCSTR); +DWORD WINAPI SHDeleteEmptyKeyW(_In_ HKEY, _In_opt_ LPCWSTR); #define SHDeleteEmptyKey WINELIB_NAME_AW(SHDeleteEmptyKey)
-DWORD WINAPI SHDeleteKeyA(HKEY,LPCSTR); -DWORD WINAPI SHDeleteKeyW(HKEY,LPCWSTR); +DWORD WINAPI SHDeleteKeyA(_In_ HKEY, _In_opt_ LPCSTR); +DWORD WINAPI SHDeleteKeyW(_In_ HKEY, _In_opt_ LPCWSTR); #define SHDeleteKey WINELIB_NAME_AW(SHDeleteKey)
-DWORD WINAPI SHDeleteValueA(HKEY,LPCSTR,LPCSTR); -DWORD WINAPI SHDeleteValueW(HKEY,LPCWSTR,LPCWSTR); +DWORD WINAPI SHDeleteValueA(_In_ HKEY, _In_opt_ LPCSTR, _In_ LPCSTR); +DWORD WINAPI SHDeleteValueW(_In_ HKEY, _In_opt_ LPCWSTR, _In_ 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); +DWORD +WINAPI +SHGetValueA( + _In_ HKEY, + _In_opt_ LPCSTR, + _In_opt_ LPCSTR, + _Out_opt_ LPDWORD, + _Out_writes_bytes_opt_(*pcbData) LPVOID, + _Inout_opt_ LPDWORD pcbData); + +DWORD +WINAPI +SHGetValueW( + _In_ HKEY, + _In_opt_ LPCWSTR, + _In_opt_ LPCWSTR, + _Out_opt_ LPDWORD, + _Out_writes_bytes_opt_(*pcbData) LPVOID, + _Inout_opt_ LPDWORD pcbData); + #define SHGetValue WINELIB_NAME_AW(SHGetValue)
-DWORD WINAPI SHSetValueA(HKEY,LPCSTR,LPCSTR,DWORD,LPCVOID,DWORD); -DWORD WINAPI SHSetValueW(HKEY,LPCWSTR,LPCWSTR,DWORD,LPCVOID,DWORD); +DWORD +WINAPI +SHSetValueA( + _In_ HKEY, + _In_opt_ LPCSTR, + _In_opt_ LPCSTR, + _In_ DWORD, + _In_reads_bytes_opt_(cbData) LPCVOID, + _In_ DWORD cbData); + +DWORD +WINAPI +SHSetValueW( + _In_ HKEY, + _In_opt_ LPCWSTR, + _In_opt_ LPCWSTR, + _In_ DWORD, + _In_reads_bytes_opt_(cbData) LPCVOID, + _In_ DWORD cbData); + #define SHSetValue WINELIB_NAME_AW(SHSetValue)
-DWORD WINAPI SHQueryValueExA(HKEY,LPCSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD); -DWORD WINAPI SHQueryValueExW(HKEY,LPCWSTR,LPDWORD,LPDWORD,LPVOID,LPDWORD); +DWORD +WINAPI +SHQueryValueExA( + _In_ HKEY, + _In_opt_ LPCSTR, + _Reserved_ LPDWORD, + _Out_opt_ LPDWORD, + _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, + _Inout_opt_ LPDWORD pcbData); + +DWORD +WINAPI +SHQueryValueExW( + _In_ HKEY, + _In_opt_ LPCWSTR, + _Reserved_ LPDWORD, + _Out_opt_ LPDWORD, + _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, + _Inout_opt_ LPDWORD pcbData); + #define SHQueryValueEx WINELIB_NAME_AW(SHQueryValueEx)
-LONG WINAPI SHEnumKeyExA(HKEY,DWORD,LPSTR,LPDWORD); -LONG WINAPI SHEnumKeyExW(HKEY,DWORD,LPWSTR,LPDWORD); +LONG +WINAPI +SHEnumKeyExA( + _In_ HKEY, + _In_ DWORD, + _Out_writes_(*pcchName) LPSTR, + _Inout_ LPDWORD pcchName); + +LONG +WINAPI +SHEnumKeyExW( + _In_ HKEY, + _In_ DWORD, + _Out_writes_(*pcchName) LPWSTR, + _Inout_ LPDWORD pcchName); + #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); +LONG +WINAPI +SHEnumValueA( + _In_ HKEY, + _In_ DWORD, + _Out_writes_opt_(*pcchValueName) LPSTR, + _Inout_opt_ LPDWORD pcchValueName, + _Out_opt_ LPDWORD, + _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, + _Inout_opt_ LPDWORD pcbData); + +LONG +WINAPI +SHEnumValueW( + _In_ HKEY, + _In_ DWORD, + _Out_writes_opt_(*pcchValueName) LPWSTR, + _Inout_opt_ LPDWORD pcchValueName, + _Out_opt_ LPDWORD, + _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, + _Inout_opt_ LPDWORD pcbData); + #define SHEnumValue WINELIB_NAME_AW(SHEnumValue)
-LONG WINAPI SHQueryInfoKeyA(HKEY,LPDWORD,LPDWORD,LPDWORD,LPDWORD); -LONG WINAPI SHQueryInfoKeyW(HKEY,LPDWORD,LPDWORD,LPDWORD,LPDWORD); +LONG +WINAPI +SHQueryInfoKeyA( + _In_ HKEY, + _Out_opt_ LPDWORD, + _Out_opt_ LPDWORD, + _Out_opt_ LPDWORD, + _Out_opt_ LPDWORD); + +LONG +WINAPI +SHQueryInfoKeyW( + _In_ HKEY, + _Out_opt_ LPDWORD, + _Out_opt_ LPDWORD, + _Out_opt_ LPDWORD, + _Out_opt_ LPDWORD); + #define SHQueryInfoKey WINELIB_NAME_AW(SHQueryInfoKey)
-DWORD WINAPI SHRegGetPathA(HKEY,LPCSTR,LPCSTR,LPSTR,DWORD); -DWORD WINAPI SHRegGetPathW(HKEY,LPCWSTR,LPCWSTR,LPWSTR,DWORD); +DWORD +WINAPI +SHRegGetPathA( + _In_ HKEY, + _In_opt_ LPCSTR, + _In_opt_ LPCSTR, + _Out_writes_(MAX_PATH) LPSTR, + _In_ DWORD); + +DWORD +WINAPI +SHRegGetPathW( + _In_ HKEY, + _In_opt_ LPCWSTR, + _In_opt_ LPCWSTR, + _Out_writes_(MAX_PATH) LPWSTR, + _In_ DWORD); + #define SHRegGetPath WINELIB_NAME_AW(SHRegGetPath)
-DWORD WINAPI SHRegSetPathA(HKEY,LPCSTR,LPCSTR,LPCSTR,DWORD); -DWORD WINAPI SHRegSetPathW(HKEY,LPCWSTR,LPCWSTR,LPCWSTR,DWORD); +DWORD +WINAPI +SHRegSetPathA( + _In_ HKEY, + _In_opt_ LPCSTR, + _In_opt_ LPCSTR, + _In_ LPCSTR, + _In_ DWORD); + +DWORD +WINAPI +SHRegSetPathW( + _In_ HKEY, + _In_opt_ LPCWSTR, + _In_opt_ LPCWSTR, + _In_ LPCWSTR, + _In_ DWORD); + #define SHRegSetPath WINELIB_NAME_AW(SHRegSetPath)
-DWORD WINAPI SHCopyKeyA(HKEY,LPCSTR,HKEY,DWORD); -DWORD WINAPI SHCopyKeyW(HKEY,LPCWSTR,HKEY,DWORD); +DWORD +WINAPI +SHCopyKeyA( + _In_ HKEY, + _In_opt_ LPCSTR, + _In_ HKEY, + _Reserved_ DWORD); + +DWORD +WINAPI +SHCopyKeyW( + _In_ HKEY, + _In_opt_ LPCWSTR, + _In_ HKEY, + _Reserved_ DWORD); + #define SHCopyKey WINELIB_NAME_AW(SHCopyKey)
-HKEY WINAPI SHRegDuplicateHKey(HKEY); +HKEY WINAPI SHRegDuplicateHKey(_In_ HKEY);
/* SHRegGetValue flags */ typedef INT SRRF; @@ -109,8 +259,28 @@ #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); +LSTATUS +WINAPI +SHRegGetValueA( + _In_ HKEY, + _In_opt_ LPCSTR, + _In_opt_ LPCSTR, + _In_ SRRF, + _Out_opt_ LPDWORD, + _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, + _Inout_opt_ LPDWORD pcbData); + +LSTATUS +WINAPI +SHRegGetValueW( + _In_ HKEY, + _In_opt_ LPCWSTR, + _In_opt_ LPCWSTR, + _In_ SRRF, + _Out_opt_ LPDWORD, + _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, + _Inout_opt_ LPDWORD pcbData); + #define SHRegGetValue WINELIB_NAME_AW(SHRegGetValue)
/* Undocumented registry functions */ @@ -147,65 +317,263 @@ typedef HANDLE HUSKEY; typedef HUSKEY *PHUSKEY;
-LONG WINAPI SHRegCreateUSKeyA(LPCSTR,REGSAM,HUSKEY,PHUSKEY,DWORD); -LONG WINAPI SHRegCreateUSKeyW(LPCWSTR,REGSAM,HUSKEY,PHUSKEY,DWORD); +LONG +WINAPI +SHRegCreateUSKeyA( + _In_ LPCSTR, + _In_ REGSAM, + _In_opt_ HUSKEY, + _Out_ PHUSKEY, + _In_ DWORD); + +LONG +WINAPI +SHRegCreateUSKeyW( + _In_ LPCWSTR, + _In_ REGSAM, + _In_opt_ HUSKEY, + _Out_ PHUSKEY, + _In_ DWORD); + #define SHRegCreateUSKey WINELIB_NAME_AW(SHRegCreateUSKey)
-LONG WINAPI SHRegOpenUSKeyA(LPCSTR,REGSAM,HUSKEY,PHUSKEY,BOOL); -LONG WINAPI SHRegOpenUSKeyW(LPCWSTR,REGSAM,HUSKEY,PHUSKEY,BOOL); +LONG +WINAPI +SHRegOpenUSKeyA( + _In_ LPCSTR, + _In_ REGSAM, + _In_opt_ HUSKEY, + _Out_ PHUSKEY, + _In_ BOOL); + +LONG +WINAPI +SHRegOpenUSKeyW( + _In_ LPCWSTR, + _In_ REGSAM, + _In_opt_ HUSKEY, + _Out_ PHUSKEY, + _In_ BOOL); + #define SHRegOpenUSKey WINELIB_NAME_AW(SHRegOpenUSKey)
-LONG WINAPI SHRegQueryUSValueA(HUSKEY,LPCSTR,LPDWORD,LPVOID,LPDWORD, - BOOL,LPVOID,DWORD); -LONG WINAPI SHRegQueryUSValueW(HUSKEY,LPCWSTR,LPDWORD,LPVOID,LPDWORD, - BOOL,LPVOID,DWORD); +LONG +WINAPI +SHRegQueryUSValueA( + _In_ HUSKEY, + _In_opt_ LPCSTR, + _Inout_opt_ LPDWORD, + _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, + _Inout_opt_ LPDWORD pcbData, + _In_ BOOL, + _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID, + _In_opt_ DWORD dwDefaultDataSize); + +LONG +WINAPI +SHRegQueryUSValueW( + _In_ HUSKEY, + _In_opt_ LPCWSTR, + _Inout_opt_ LPDWORD, + _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, + _Inout_opt_ LPDWORD pcbData, + _In_ BOOL, + _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID, + _In_opt_ DWORD dwDefaultDataSize); + #define SHRegQueryUSValue WINELIB_NAME_AW(SHRegQueryUSValue)
-LONG WINAPI SHRegWriteUSValueA(HUSKEY,LPCSTR,DWORD,LPVOID,DWORD,DWORD); -LONG WINAPI SHRegWriteUSValueW(HUSKEY,LPCWSTR,DWORD,LPVOID,DWORD,DWORD); +LONG +WINAPI +SHRegWriteUSValueA( + _In_ HUSKEY, + _In_ LPCSTR, + _In_ DWORD, + _In_reads_bytes_(cbData) LPVOID, + _In_ DWORD cbData, + _In_ DWORD); + +LONG +WINAPI +SHRegWriteUSValueW( + _In_ HUSKEY, + _In_ LPCWSTR, + _In_ DWORD, + _In_reads_bytes_(cbData) LPVOID, + _In_ DWORD cbData, + _In_ DWORD); + #define SHRegWriteUSValue WINELIB_NAME_AW(SHRegWriteUSValue)
-LONG WINAPI SHRegDeleteUSValueA(HUSKEY,LPCSTR,SHREGDEL_FLAGS); -LONG WINAPI SHRegDeleteUSValueW(HUSKEY,LPCWSTR,SHREGDEL_FLAGS); +LONG +WINAPI +SHRegDeleteUSValueA( + _In_ HUSKEY, + _In_ LPCSTR, + _In_ SHREGDEL_FLAGS); + +LONG +WINAPI +SHRegDeleteUSValueW( + _In_ HUSKEY, + _In_ LPCWSTR, + _In_ SHREGDEL_FLAGS); + #define SHRegDeleteUSValue WINELIB_NAME_AW(SHRegDeleteUSValue)
-LONG WINAPI SHRegDeleteEmptyUSKeyA(HUSKEY,LPCSTR,SHREGDEL_FLAGS); -LONG WINAPI SHRegDeleteEmptyUSKeyW(HUSKEY,LPCWSTR,SHREGDEL_FLAGS); +LONG +WINAPI +SHRegDeleteEmptyUSKeyA( + _In_ HUSKEY, + _In_ LPCSTR, + _In_ SHREGDEL_FLAGS); + +LONG +WINAPI +SHRegDeleteEmptyUSKeyW( + _In_ HUSKEY, + _In_ LPCWSTR, + _In_ 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); +LONG +WINAPI +SHRegEnumUSKeyA( + _In_ HUSKEY, + _In_ DWORD, + _Out_writes_to_(*pcchName, *pcchName) LPSTR, + _Inout_ LPDWORD pcchName, + _In_ SHREGENUM_FLAGS); + +LONG +WINAPI +SHRegEnumUSKeyW( + _In_ HUSKEY, + _In_ DWORD, + _Out_writes_to_(*pcchName, *pcchName) LPWSTR, + _Inout_ LPDWORD pcchName, + _In_ SHREGENUM_FLAGS); + #define SHRegEnumUSKey WINELIB_NAME_AW(SHRegEnumUSKey)
-LONG WINAPI SHRegEnumUSValueA(HUSKEY,DWORD,LPSTR,LPDWORD,LPDWORD, - LPVOID,LPDWORD,SHREGENUM_FLAGS); -LONG WINAPI SHRegEnumUSValueW(HUSKEY,DWORD,LPWSTR,LPDWORD,LPDWORD, - LPVOID,LPDWORD,SHREGENUM_FLAGS); +LONG +WINAPI +SHRegEnumUSValueA( + _In_ HUSKEY, + _In_ DWORD, + _Out_writes_to_(*pcchValueName, *pcchValueName) LPSTR, + _Inout_ LPDWORD pcchValueName, + _Out_opt_ LPDWORD, + _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, + _Inout_opt_ LPDWORD pcbData, + _In_ SHREGENUM_FLAGS); + +LONG +WINAPI +SHRegEnumUSValueW( + _In_ HUSKEY, + _In_ DWORD, + _Out_writes_to_(*pcchValueName, *pcchValueName) LPWSTR, + _Inout_ LPDWORD pcchValueName, + _Out_opt_ LPDWORD, + _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, + _Inout_opt_ LPDWORD pcbData, + _In_ SHREGENUM_FLAGS); + #define SHRegEnumUSValue WINELIB_NAME_AW(SHRegEnumUSValue)
-LONG WINAPI SHRegQueryInfoUSKeyA(HUSKEY,LPDWORD,LPDWORD,LPDWORD, - LPDWORD,SHREGENUM_FLAGS); -LONG WINAPI SHRegQueryInfoUSKeyW(HUSKEY,LPDWORD,LPDWORD,LPDWORD, - LPDWORD,SHREGENUM_FLAGS); +LONG +WINAPI +SHRegQueryInfoUSKeyA( + _In_ HUSKEY, + _Out_opt_ LPDWORD, + _Out_opt_ LPDWORD, + _Out_opt_ LPDWORD, + _Out_opt_ LPDWORD, + _In_ SHREGENUM_FLAGS); + +LONG +WINAPI +SHRegQueryInfoUSKeyW( + _In_ HUSKEY, + _Out_opt_ LPDWORD, + _Out_opt_ LPDWORD, + _Out_opt_ LPDWORD, + _Out_opt_ LPDWORD, + _In_ SHREGENUM_FLAGS); + #define SHRegQueryInfoUSKey WINELIB_NAME_AW(SHRegQueryInfoUSKey)
-LONG WINAPI SHRegCloseUSKey(HUSKEY); - -LONG WINAPI SHRegGetUSValueA(LPCSTR,LPCSTR,LPDWORD,LPVOID,LPDWORD, - BOOL,LPVOID,DWORD); -LONG WINAPI SHRegGetUSValueW(LPCWSTR,LPCWSTR,LPDWORD,LPVOID,LPDWORD, - BOOL,LPVOID,DWORD); +LONG WINAPI SHRegCloseUSKey(_In_ HUSKEY); + +LONG +WINAPI +SHRegGetUSValueA( + _In_ LPCSTR, + _In_opt_ LPCSTR, + _Inout_opt_ LPDWORD, + _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, + _Inout_opt_ LPDWORD pcbData, + _In_ BOOL, + _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID, + _In_ DWORD dwDefaultDataSize); + +LONG +WINAPI +SHRegGetUSValueW( + _In_ LPCWSTR, + _In_opt_ LPCWSTR, + _Inout_opt_ LPDWORD, + _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID, + _Inout_opt_ LPDWORD pcbData, + _In_ BOOL, + _In_reads_bytes_opt_(dwDefaultDataSize) LPVOID, + _In_ DWORD dwDefaultDataSize); + #define SHRegGetUSValue WINELIB_NAME_AW(SHRegGetUSValue)
-LONG WINAPI SHRegSetUSValueA(LPCSTR,LPCSTR,DWORD,LPVOID,DWORD,DWORD); -LONG WINAPI SHRegSetUSValueW(LPCWSTR,LPCWSTR,DWORD,LPVOID,DWORD,DWORD); +LONG +WINAPI +SHRegSetUSValueA( + _In_ LPCSTR, + _In_ LPCSTR, + _In_ DWORD, + _In_reads_bytes_opt_(cbData) LPVOID, + _In_opt_ DWORD cbData, + _In_opt_ DWORD); + +LONG +WINAPI +SHRegSetUSValueW( + _In_ LPCWSTR, + _In_ LPCWSTR, + _In_ DWORD, + _In_reads_bytes_opt_(cbData) LPVOID, + _In_opt_ DWORD cbData, + _In_opt_ DWORD); + #define SHRegSetUSValue WINELIB_NAME_AW(SHRegSetUSValue)
-BOOL WINAPI SHRegGetBoolUSValueA(LPCSTR,LPCSTR,BOOL,BOOL); -BOOL WINAPI SHRegGetBoolUSValueW(LPCWSTR,LPCWSTR,BOOL,BOOL); +BOOL +WINAPI +SHRegGetBoolUSValueA( + _In_ LPCSTR, + _In_opt_ LPCSTR, + _In_ BOOL, + _In_ BOOL); + +BOOL +WINAPI +SHRegGetBoolUSValueW( + _In_ LPCWSTR, + _In_opt_ LPCWSTR, + _In_ BOOL, + _In_ BOOL); + #define SHRegGetBoolUSValue WINELIB_NAME_AW(SHRegGetBoolUSValue)
-int WINAPI SHRegGetIntW(HKEY,LPCWSTR,int); +int WINAPI SHRegGetIntW(_In_ HKEY, _In_opt_ LPCWSTR, _In_ int);
/* IQueryAssociation and helpers */ enum @@ -282,11 +650,11 @@ STDMETHOD_(ULONG,AddRef)(THIS) PURE; STDMETHOD_(ULONG,Release)(THIS) PURE; /*** IQueryAssociations methods ***/ - STDMETHOD(Init)(THIS_ ASSOCF flags, LPCWSTR pszAssoc, HKEY hkProgid, HWND hwnd) PURE; - STDMETHOD(GetString)(THIS_ ASSOCF flags, ASSOCSTR str, LPCWSTR pszExtra, LPWSTR pszOut, DWORD * pcchOut) PURE; - STDMETHOD(GetKey)(THIS_ ASSOCF flags, ASSOCKEY key, LPCWSTR pszExtra, HKEY * phkeyOut) PURE; - STDMETHOD(GetData)(THIS_ ASSOCF flags, ASSOCDATA data, LPCWSTR pszExtra, LPVOID pvOut, DWORD * pcbOut) PURE; - STDMETHOD(GetEnum)(THIS_ ASSOCF flags, ASSOCENUM assocenum, LPCWSTR pszExtra, REFIID riid, LPVOID * ppvOut) PURE; + STDMETHOD(Init)(THIS_ _In_ ASSOCF flags, _In_opt_ LPCWSTR pszAssoc, _In_opt_ HKEY hkProgid, _In_opt_ HWND hwnd) PURE; + STDMETHOD(GetString)(THIS_ _In_ ASSOCF flags, _In_ ASSOCSTR str, _In_opt_ LPCWSTR pszExtra, _Out_writes_opt_(*pcchOut) LPWSTR pszOut, _Inout_ DWORD *pcchOut) PURE; + STDMETHOD(GetKey)(THIS_ _In_ ASSOCF flags, _In_ ASSOCKEY key, _In_opt_ LPCWSTR pszExtra, _Out_ HKEY *phkeyOut) PURE; + STDMETHOD(GetData)(THIS_ _In_ ASSOCF flags, _In_ ASSOCDATA data, _In_opt_ LPCWSTR pszExtra, _Out_writes_bytes_opt_(*pcbOut) LPVOID pvOut, _Inout_opt_ DWORD *pcbOut) PURE; + STDMETHOD(GetEnum)(THIS_ _In_ ASSOCF flags, _In_ ASSOCENUM assocenum, _In_opt_ LPCWSTR pszExtra, _In_ REFIID riid, _Outptr_ LPVOID *ppvOut) PURE; }; #undef INTERFACE
@@ -301,30 +669,100 @@ #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*); - -HRESULT WINAPI AssocQueryStringA(ASSOCF,ASSOCSTR,LPCSTR,LPCSTR,LPSTR,LPDWORD); -HRESULT WINAPI AssocQueryStringW(ASSOCF,ASSOCSTR,LPCWSTR,LPCWSTR,LPWSTR,LPDWORD); +HRESULT WINAPI AssocCreate(_In_ CLSID, _In_ REFIID, _Outptr_ LPVOID*); + +HRESULT +WINAPI +AssocQueryStringA( + _In_ ASSOCF, + _In_ ASSOCSTR, + _In_ LPCSTR, + _In_opt_ LPCSTR, + _Out_writes_opt_(*pcchOut) LPSTR, + _Inout_ LPDWORD pcchOut); + +HRESULT +WINAPI +AssocQueryStringW( + _In_ ASSOCF, + _In_ ASSOCSTR, + _In_ LPCWSTR, + _In_opt_ LPCWSTR, + _Out_writes_opt_(*pcchOut) LPWSTR, + _Inout_ LPDWORD pcchOut); + #define AssocQueryString WINELIB_NAME_AW(AssocQueryString)
-HRESULT WINAPI AssocQueryStringByKeyA(ASSOCF,ASSOCSTR,HKEY,LPCSTR,LPSTR,LPDWORD); -HRESULT WINAPI AssocQueryStringByKeyW(ASSOCF,ASSOCSTR,HKEY,LPCWSTR,LPWSTR,LPDWORD); +HRESULT +WINAPI +AssocQueryStringByKeyA( + _In_ ASSOCF, + _In_ ASSOCSTR, + _In_ HKEY, + _In_opt_ LPCSTR, + _Out_writes_opt_(*pcchOut) LPSTR, + _Inout_ LPDWORD pcchOut); + +HRESULT +WINAPI +AssocQueryStringByKeyW( + _In_ ASSOCF, + _In_ ASSOCSTR, + _In_ HKEY, + _In_opt_ LPCWSTR, + _Out_writes_opt_(*pcchOut) LPWSTR, + _Inout_ LPDWORD pcchOut); + #define AssocQueryStringByKey WINELIB_NAME_AW(AssocQueryStringByKey)
-HRESULT WINAPI AssocQueryKeyA(ASSOCF,ASSOCKEY,LPCSTR,LPCSTR,PHKEY); -HRESULT WINAPI AssocQueryKeyW(ASSOCF,ASSOCKEY,LPCWSTR,LPCWSTR,PHKEY); +HRESULT +WINAPI +AssocQueryKeyA( + _In_ ASSOCF, + _In_ ASSOCKEY, + _In_ LPCSTR, + _In_opt_ LPCSTR, + _Out_ PHKEY); + +HRESULT +WINAPI +AssocQueryKeyW( + _In_ ASSOCF, + _In_ ASSOCKEY, + _In_ LPCWSTR, + _In_opt_ LPCWSTR, + _Out_ PHKEY); + #define AssocQueryKey WINELIB_NAME_AW(AssocQueryKey)
-BOOL WINAPI AssocIsDangerous(LPCWSTR); +BOOL WINAPI AssocIsDangerous(_In_ 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); +void WINAPI IUnknown_Set(_Inout_ IUnknown **ppunk, _In_opt_ IUnknown *punk); +void WINAPI IUnknown_AtomicRelease(_Inout_opt_ IUnknown **punk); +HRESULT WINAPI IUnknown_GetWindow(_In_ IUnknown *punk, _Out_ HWND *phwnd); + +HRESULT +WINAPI +IUnknown_SetSite( + _In_ IUnknown *punk, + _In_opt_ IUnknown *punkSite); + +HRESULT +WINAPI +IUnknown_GetSite( + _In_ IUnknown *punk, + _In_ REFIID riid, + _Outptr_ void **ppv); + +HRESULT +WINAPI +IUnknown_QueryService( + _In_opt_ IUnknown *punk, + _In_ REFGUID guidService, + _In_ REFIID riid, + _Outptr_ void **ppvOut);
/* Path functions */ #ifndef NO_SHLWAPI_PATH @@ -336,230 +774,366 @@ #define GCT_WILD 0x4 #define GCT_SEPARATOR 0x8
-LPSTR WINAPI PathAddBackslashA(LPSTR); -LPWSTR WINAPI PathAddBackslashW(LPWSTR); +LPSTR WINAPI PathAddBackslashA(_Inout_updates_(MAX_PATH) LPSTR); +LPWSTR WINAPI PathAddBackslashW(_Inout_updates_(MAX_PATH) LPWSTR); #define PathAddBackslash WINELIB_NAME_AW(PathAddBackslash)
-BOOL WINAPI PathAddExtensionA(LPSTR,LPCSTR); -BOOL WINAPI PathAddExtensionW(LPWSTR,LPCWSTR); +BOOL +WINAPI +PathAddExtensionA( + _Inout_updates_(MAX_PATH) LPSTR, + _In_opt_ LPCSTR); + +BOOL +WINAPI +PathAddExtensionW( + _Inout_updates_(MAX_PATH) LPWSTR, + _In_opt_ LPCWSTR); + #define PathAddExtension WINELIB_NAME_AW(PathAddExtension)
-BOOL WINAPI PathAppendA(LPSTR,LPCSTR); -BOOL WINAPI PathAppendW(LPWSTR,LPCWSTR); +BOOL WINAPI PathAppendA(_Inout_updates_(MAX_PATH) LPSTR, _In_ LPCSTR); +BOOL WINAPI PathAppendW(_Inout_updates_(MAX_PATH) LPWSTR, _In_ LPCWSTR); #define PathAppend WINELIB_NAME_AW(PathAppend)
-LPSTR WINAPI PathBuildRootA(LPSTR,int); -LPWSTR WINAPI PathBuildRootW(LPWSTR,int); +LPSTR WINAPI PathBuildRootA(_Out_writes_(4) LPSTR, int); +LPWSTR WINAPI PathBuildRootW(_Out_writes_(4) LPWSTR, int); #define PathBuildRoot WINELIB_NAME_AW(PathBuiltRoot)
-BOOL WINAPI PathCanonicalizeA(LPSTR,LPCSTR); -BOOL WINAPI PathCanonicalizeW(LPWSTR,LPCWSTR); +BOOL WINAPI PathCanonicalizeA(_Out_writes_(MAX_PATH) LPSTR, _In_ LPCSTR); +BOOL WINAPI PathCanonicalizeW(_Out_writes_(MAX_PATH) LPWSTR, _In_ LPCWSTR); #define PathCanonicalize WINELIB_NAME_AW(PathCanonicalize)
-LPSTR WINAPI PathCombineA(LPSTR,LPCSTR,LPCSTR); -LPWSTR WINAPI PathCombineW(LPWSTR,LPCWSTR,LPCWSTR); +LPSTR +WINAPI +PathCombineA( + _Out_writes_(MAX_PATH) LPSTR, + _In_opt_ LPCSTR, + _In_opt_ LPCSTR); + +LPWSTR +WINAPI +PathCombineW( + _Out_writes_(MAX_PATH) LPWSTR, + _In_opt_ LPCWSTR, + _In_opt_ LPCWSTR); + #define PathCombine WINELIB_NAME_AW(PathCombine)
-BOOL WINAPI PathCompactPathA(HDC,LPSTR,UINT); -BOOL WINAPI PathCompactPathW(HDC,LPWSTR,UINT); +BOOL +WINAPI +PathCompactPathA( + _In_opt_ HDC, + _Inout_updates_(MAX_PATH) LPSTR, + _In_ UINT); + +BOOL +WINAPI +PathCompactPathW( + _In_opt_ HDC, + _Inout_updates_(MAX_PATH) LPWSTR, + _In_ UINT); + #define PathCompactPath WINELIB_NAME_AW(PathCompactPath)
-BOOL WINAPI PathCompactPathExA(LPSTR,LPCSTR,UINT,DWORD); -BOOL WINAPI PathCompactPathExW(LPWSTR,LPCWSTR,UINT,DWORD); +BOOL +WINAPI +PathCompactPathExA( + _Out_writes_(cchMax) LPSTR, + _In_ LPCSTR, + _In_ UINT cchMax, + _In_ DWORD); + +BOOL +WINAPI +PathCompactPathExW( + _Out_writes_(cchMax) LPWSTR, + _In_ LPCWSTR, + _In_ UINT cchMax, + _In_ DWORD); + #define PathCompactPathEx WINELIB_NAME_AW(PathCompactPathEx)
-int WINAPI PathCommonPrefixA(LPCSTR,LPCSTR,LPSTR); -int WINAPI PathCommonPrefixW(LPCWSTR,LPCWSTR,LPWSTR); +int +WINAPI +PathCommonPrefixA( + _In_ LPCSTR, + _In_ LPCSTR, + _Out_writes_opt_(MAX_PATH) LPSTR); + +int +WINAPI +PathCommonPrefixW( + _In_ LPCWSTR, + _In_ LPCWSTR, + _Out_writes_opt_(MAX_PATH) LPWSTR); + #define PathCommonPrefix WINELIB_NAME_AW(PathCommonPrefix)
-HRESULT WINAPI PathCreateFromUrlA(LPCSTR,LPSTR,LPDWORD,DWORD); -HRESULT WINAPI PathCreateFromUrlW(LPCWSTR,LPWSTR,LPDWORD,DWORD); +HRESULT +WINAPI +PathCreateFromUrlA( + _In_ LPCSTR, + _Out_writes_to_(*pcchPath, *pcchPath) LPSTR, + _Inout_ LPDWORD pcchPath, + DWORD); + +HRESULT +WINAPI +PathCreateFromUrlW( + _In_ LPCWSTR, + _Out_writes_to_(*pcchPath, *pcchPath) LPWSTR, + _Inout_ LPDWORD pcchPath, + DWORD); + #define PathCreateFromUrl WINELIB_NAME_AW(PathCreateFromUrl)
-HRESULT WINAPI PathCreateFromUrlAlloc(LPCWSTR,LPWSTR*,DWORD); - -BOOL WINAPI PathFileExistsA(LPCSTR); -BOOL WINAPI PathFileExistsW(LPCWSTR); +HRESULT WINAPI PathCreateFromUrlAlloc(_In_ LPCWSTR, _Outptr_ LPWSTR*, DWORD); + +BOOL WINAPI PathFileExistsA(_In_ LPCSTR); +BOOL WINAPI PathFileExistsW(_In_ LPCWSTR); #define PathFileExists WINELIB_NAME_AW(PathFileExists)
BOOL WINAPI PathFileExistsAndAttributesA(LPCSTR,DWORD*); BOOL WINAPI PathFileExistsAndAttributesW(LPCWSTR,DWORD*); #define PathFileExistsAndAttributes WINELIB_NAME_AW(PathFileExistsAndAttributes)
-LPSTR WINAPI PathFindExtensionA(LPCSTR); -LPWSTR WINAPI PathFindExtensionW(LPCWSTR); +LPSTR WINAPI PathFindExtensionA(_In_ LPCSTR); +LPWSTR WINAPI PathFindExtensionW(_In_ LPCWSTR); #define PathFindExtension WINELIB_NAME_AW(PathFindExtension)
-LPSTR WINAPI PathFindFileNameA(LPCSTR); -LPWSTR WINAPI PathFindFileNameW(LPCWSTR); +LPSTR WINAPI PathFindFileNameA(_In_ LPCSTR); +LPWSTR WINAPI PathFindFileNameW(_In_ LPCWSTR); #define PathFindFileName WINELIB_NAME_AW(PathFindFileName)
-LPSTR WINAPI PathFindNextComponentA(LPCSTR); -LPWSTR WINAPI PathFindNextComponentW(LPCWSTR); +LPSTR WINAPI PathFindNextComponentA(_In_ LPCSTR); +LPWSTR WINAPI PathFindNextComponentW(_In_ LPCWSTR); #define PathFindNextComponent WINELIB_NAME_AW(PathFindNextComponent)
-BOOL WINAPI PathFindOnPathA(LPSTR,LPCSTR*); -BOOL WINAPI PathFindOnPathW(LPWSTR,LPCWSTR*); +BOOL WINAPI PathFindOnPathA(_Inout_updates_(MAX_PATH) LPSTR, _In_opt_ LPCSTR*); +BOOL WINAPI PathFindOnPathW(_Inout_updates_(MAX_PATH) LPWSTR, _In_opt_ LPCWSTR*); #define PathFindOnPath WINELIB_NAME_AW(PathFindOnPath)
-LPSTR WINAPI PathGetArgsA(LPCSTR); -LPWSTR WINAPI PathGetArgsW(LPCWSTR); +LPSTR WINAPI PathGetArgsA(_In_ LPCSTR); +LPWSTR WINAPI PathGetArgsW(_In_ LPCWSTR); #define PathGetArgs WINELIB_NAME_AW(PathGetArgs)
-UINT WINAPI PathGetCharTypeA(UCHAR); -UINT WINAPI PathGetCharTypeW(WCHAR); +UINT WINAPI PathGetCharTypeA(_In_ UCHAR); +UINT WINAPI PathGetCharTypeW(_In_ WCHAR); #define PathGetCharType WINELIB_NAME_AW(PathGetCharType)
-int WINAPI PathGetDriveNumberA(LPCSTR); -int WINAPI PathGetDriveNumberW(LPCWSTR); +int WINAPI PathGetDriveNumberA(_In_ LPCSTR); +int WINAPI PathGetDriveNumberW(_In_ LPCWSTR); #define PathGetDriveNumber WINELIB_NAME_AW(PathGetDriveNumber)
-BOOL WINAPI PathIsDirectoryA(LPCSTR); -BOOL WINAPI PathIsDirectoryW(LPCWSTR); +BOOL WINAPI PathIsDirectoryA(_In_ LPCSTR); +BOOL WINAPI PathIsDirectoryW(_In_ LPCWSTR); #define PathIsDirectory WINELIB_NAME_AW(PathIsDirectory)
-BOOL WINAPI PathIsDirectoryEmptyA(LPCSTR); -BOOL WINAPI PathIsDirectoryEmptyW(LPCWSTR); +BOOL WINAPI PathIsDirectoryEmptyA(_In_ LPCSTR); +BOOL WINAPI PathIsDirectoryEmptyW(_In_ LPCWSTR); #define PathIsDirectoryEmpty WINELIB_NAME_AW(PathIsDirectoryEmpty)
-BOOL WINAPI PathIsFileSpecA(LPCSTR); -BOOL WINAPI PathIsFileSpecW(LPCWSTR); +BOOL WINAPI PathIsFileSpecA(_In_ LPCSTR); +BOOL WINAPI PathIsFileSpecW(_In_ LPCWSTR); #define PathIsFileSpec WINELIB_NAME_AW(PathIsFileSpec);
-BOOL WINAPI PathIsPrefixA(LPCSTR,LPCSTR); -BOOL WINAPI PathIsPrefixW(LPCWSTR,LPCWSTR); +BOOL WINAPI PathIsPrefixA(_In_ LPCSTR, _In_ LPCSTR); +BOOL WINAPI PathIsPrefixW(_In_ LPCWSTR, _In_ LPCWSTR); #define PathIsPrefix WINELIB_NAME_AW(PathIsPrefix)
-BOOL WINAPI PathIsRelativeA(LPCSTR); -BOOL WINAPI PathIsRelativeW(LPCWSTR); +BOOL WINAPI PathIsRelativeA(_In_ LPCSTR); +BOOL WINAPI PathIsRelativeW(_In_ LPCWSTR); #define PathIsRelative WINELIB_NAME_AW(PathIsRelative)
-BOOL WINAPI PathIsRootA(LPCSTR); -BOOL WINAPI PathIsRootW(LPCWSTR); +BOOL WINAPI PathIsRootA(_In_ LPCSTR); +BOOL WINAPI PathIsRootW(_In_ LPCWSTR); #define PathIsRoot WINELIB_NAME_AW(PathIsRoot)
-BOOL WINAPI PathIsSameRootA(LPCSTR,LPCSTR); -BOOL WINAPI PathIsSameRootW(LPCWSTR,LPCWSTR); +BOOL WINAPI PathIsSameRootA(_In_ LPCSTR, _In_ LPCSTR); +BOOL WINAPI PathIsSameRootW(_In_ LPCWSTR, _In_ LPCWSTR); #define PathIsSameRoot WINELIB_NAME_AW(PathIsSameRoot)
-BOOL WINAPI PathIsUNCA(LPCSTR); -BOOL WINAPI PathIsUNCW(LPCWSTR); +BOOL WINAPI PathIsUNCA(_In_ LPCSTR); +BOOL WINAPI PathIsUNCW(_In_ LPCWSTR); #define PathIsUNC WINELIB_NAME_AW(PathIsUNC)
-BOOL WINAPI PathIsUNCServerA(LPCSTR); -BOOL WINAPI PathIsUNCServerW(LPCWSTR); +BOOL WINAPI PathIsUNCServerA(_In_ LPCSTR); +BOOL WINAPI PathIsUNCServerW(_In_ LPCWSTR); #define PathIsUNCServer WINELIB_NAME_AW(PathIsUNCServer)
-BOOL WINAPI PathIsUNCServerShareA(LPCSTR); -BOOL WINAPI PathIsUNCServerShareW(LPCWSTR); +BOOL WINAPI PathIsUNCServerShareA(_In_ LPCSTR); +BOOL WINAPI PathIsUNCServerShareW(_In_ LPCWSTR); #define PathIsUNCServerShare WINELIB_NAME_AW(PathIsUNCServerShare)
-BOOL WINAPI PathIsContentTypeA(LPCSTR,LPCSTR); -BOOL WINAPI PathIsContentTypeW(LPCWSTR,LPCWSTR); +BOOL WINAPI PathIsContentTypeA(_In_ LPCSTR, _In_ LPCSTR); +BOOL WINAPI PathIsContentTypeW(_In_ LPCWSTR, _In_ LPCWSTR); #define PathIsContentType WINELIB_NAME_AW(PathIsContentType)
-BOOL WINAPI PathIsURLA(LPCSTR); -BOOL WINAPI PathIsURLW(LPCWSTR); +BOOL WINAPI PathIsURLA(_In_ LPCSTR); +BOOL WINAPI PathIsURLW(_In_ LPCWSTR); #define PathIsURL WINELIB_NAME_AW(PathIsURL)
-BOOL WINAPI PathMakePrettyA(LPSTR); -BOOL WINAPI PathMakePrettyW(LPWSTR); +BOOL WINAPI PathMakePrettyA(_Inout_ LPSTR); +BOOL WINAPI PathMakePrettyW(_Inout_ LPWSTR); #define PathMakePretty WINELIB_NAME_AW(PathMakePretty)
-BOOL WINAPI PathMatchSpecA(LPCSTR,LPCSTR); -BOOL WINAPI PathMatchSpecW(LPCWSTR,LPCWSTR); +BOOL WINAPI PathMatchSpecA(_In_ LPCSTR, _In_ LPCSTR); +BOOL WINAPI PathMatchSpecW(_In_ LPCWSTR, _In_ LPCWSTR); #define PathMatchSpec WINELIB_NAME_AW(PathMatchSpec)
-int WINAPI PathParseIconLocationA(LPSTR); -int WINAPI PathParseIconLocationW(LPWSTR); +int WINAPI PathParseIconLocationA(_Inout_ LPSTR); +int WINAPI PathParseIconLocationW(_Inout_ LPWSTR); #define PathParseIconLocation WINELIB_NAME_AW(PathParseIconLocation)
-VOID WINAPI PathQuoteSpacesA(LPSTR); -VOID WINAPI PathQuoteSpacesW(LPWSTR); +VOID WINAPI PathQuoteSpacesA(_Inout_updates_(MAX_PATH) LPSTR); +VOID WINAPI PathQuoteSpacesW(_Inout_updates_(MAX_PATH) LPWSTR); #define PathQuoteSpaces WINELIB_NAME_AW(PathQuoteSpaces)
-BOOL WINAPI PathRelativePathToA(LPSTR,LPCSTR,DWORD,LPCSTR,DWORD); -BOOL WINAPI PathRelativePathToW(LPWSTR,LPCWSTR,DWORD,LPCWSTR,DWORD); +BOOL +WINAPI +PathRelativePathToA( + _Out_writes_(MAX_PATH) LPSTR, + _In_ LPCSTR, + _In_ DWORD, + _In_ LPCSTR, + _In_ DWORD); + +BOOL +WINAPI +PathRelativePathToW( + _Out_writes_(MAX_PATH) LPWSTR, + _In_ LPCWSTR, + _In_ DWORD, + _In_ LPCWSTR, + _In_ DWORD); + #define PathRelativePathTo WINELIB_NAME_AW(PathRelativePathTo)
-VOID WINAPI PathRemoveArgsA(LPSTR); -VOID WINAPI PathRemoveArgsW(LPWSTR); +VOID WINAPI PathRemoveArgsA(_Inout_ LPSTR); +VOID WINAPI PathRemoveArgsW(_Inout_ LPWSTR); #define PathRemoveArgs WINELIB_NAME_AW(PathRemoveArgs)
-LPSTR WINAPI PathRemoveBackslashA(LPSTR); -LPWSTR WINAPI PathRemoveBackslashW(LPWSTR); +LPSTR WINAPI PathRemoveBackslashA(_Inout_ LPSTR); +LPWSTR WINAPI PathRemoveBackslashW(_Inout_ LPWSTR); #define PathRemoveBackslash WINELIB_NAME_AW(PathRemoveBackslash)
-VOID WINAPI PathRemoveBlanksA(LPSTR); -VOID WINAPI PathRemoveBlanksW(LPWSTR); +VOID WINAPI PathRemoveBlanksA(_Inout_ LPSTR); +VOID WINAPI PathRemoveBlanksW(_Inout_ LPWSTR); #define PathRemoveBlanks WINELIB_NAME_AW(PathRemoveBlanks)
-VOID WINAPI PathRemoveExtensionA(LPSTR); -VOID WINAPI PathRemoveExtensionW(LPWSTR); +VOID WINAPI PathRemoveExtensionA(_Inout_ LPSTR); +VOID WINAPI PathRemoveExtensionW(_Inout_ LPWSTR); #define PathRemoveExtension WINELIB_NAME_AW(PathRemoveExtension)
-BOOL WINAPI PathRemoveFileSpecA(LPSTR); -BOOL WINAPI PathRemoveFileSpecW(LPWSTR); +BOOL WINAPI PathRemoveFileSpecA(_Inout_ LPSTR); +BOOL WINAPI PathRemoveFileSpecW(_Inout_ LPWSTR); #define PathRemoveFileSpec WINELIB_NAME_AW(PathRemoveFileSpec)
-BOOL WINAPI PathRenameExtensionA(LPSTR,LPCSTR); -BOOL WINAPI PathRenameExtensionW(LPWSTR,LPCWSTR); +BOOL +WINAPI +PathRenameExtensionA( + _Inout_updates_(MAX_PATH) LPSTR, + _In_ LPCSTR); + +BOOL +WINAPI +PathRenameExtensionW( + _Inout_updates_(MAX_PATH) LPWSTR, + _In_ LPCWSTR); + #define PathRenameExtension WINELIB_NAME_AW(PathRenameExtension)
-BOOL WINAPI PathSearchAndQualifyA(LPCSTR,LPSTR,UINT); -BOOL WINAPI PathSearchAndQualifyW(LPCWSTR,LPWSTR,UINT); +BOOL +WINAPI +PathSearchAndQualifyA( + _In_ LPCSTR, + _Out_writes_(cchBuf) LPSTR, + _In_ UINT cchBuf); + +BOOL +WINAPI +PathSearchAndQualifyW( + _In_ LPCWSTR, + _Out_writes_(cchBuf) LPWSTR, + _In_ UINT cchBuf); + #define PathSearchAndQualify WINELIB_NAME_AW(PathSearchAndQualify)
-VOID WINAPI PathSetDlgItemPathA(HWND,int,LPCSTR); -VOID WINAPI PathSetDlgItemPathW(HWND,int,LPCWSTR); +VOID WINAPI PathSetDlgItemPathA(_In_ HWND, int, LPCSTR); +VOID WINAPI PathSetDlgItemPathW(_In_ HWND, int, LPCWSTR); #define PathSetDlgItemPath WINELIB_NAME_AW(PathSetDlgItemPath)
-LPSTR WINAPI PathSkipRootA(LPCSTR); -LPWSTR WINAPI PathSkipRootW(LPCWSTR); +LPSTR WINAPI PathSkipRootA(_In_ LPCSTR); +LPWSTR WINAPI PathSkipRootW(_In_ LPCWSTR); #define PathSkipRoot WINELIB_NAME_AW(PathSkipRoot)
-VOID WINAPI PathStripPathA(LPSTR); -VOID WINAPI PathStripPathW(LPWSTR); +VOID WINAPI PathStripPathA(_Inout_ LPSTR); +VOID WINAPI PathStripPathW(_Inout_ LPWSTR); #define PathStripPath WINELIB_NAME_AW(PathStripPath)
-BOOL WINAPI PathStripToRootA(LPSTR); -BOOL WINAPI PathStripToRootW(LPWSTR); +BOOL WINAPI PathStripToRootA(_Inout_ LPSTR); +BOOL WINAPI PathStripToRootW(_Inout_ LPWSTR); #define PathStripToRoot WINELIB_NAME_AW(PathStripToRoot)
-VOID WINAPI PathUnquoteSpacesA(LPSTR); -VOID WINAPI PathUnquoteSpacesW(LPWSTR); +VOID WINAPI PathUnquoteSpacesA(_Inout_ LPSTR); +VOID WINAPI PathUnquoteSpacesW(_Inout_ LPWSTR); #define PathUnquoteSpaces WINELIB_NAME_AW(PathUnquoteSpaces)
-BOOL WINAPI PathMakeSystemFolderA(LPCSTR); -BOOL WINAPI PathMakeSystemFolderW(LPCWSTR); +BOOL WINAPI PathMakeSystemFolderA(_In_ LPCSTR); +BOOL WINAPI PathMakeSystemFolderW(_In_ LPCWSTR); #define PathMakeSystemFolder WINELIB_NAME_AW(PathMakeSystemFolder)
-BOOL WINAPI PathUnmakeSystemFolderA(LPCSTR); -BOOL WINAPI PathUnmakeSystemFolderW(LPCWSTR); +BOOL WINAPI PathUnmakeSystemFolderA(_In_ LPCSTR); +BOOL WINAPI PathUnmakeSystemFolderW(_In_ LPCWSTR); #define PathUnmakeSystemFolder WINELIB_NAME_AW(PathUnmakeSystemFolder)
-BOOL WINAPI PathIsSystemFolderA(LPCSTR,DWORD); -BOOL WINAPI PathIsSystemFolderW(LPCWSTR,DWORD); +BOOL WINAPI PathIsSystemFolderA(_In_opt_ LPCSTR, _In_ DWORD); +BOOL WINAPI PathIsSystemFolderW(_In_opt_ LPCWSTR, _In_ DWORD); #define PathIsSystemFolder WINELIB_NAME_AW(PathIsSystemFolder)
-BOOL WINAPI PathIsNetworkPathA(LPCSTR); -BOOL WINAPI PathIsNetworkPathW(LPCWSTR); +BOOL WINAPI PathIsNetworkPathA(_In_ LPCSTR); +BOOL WINAPI PathIsNetworkPathW(_In_ LPCWSTR); #define PathIsNetworkPath WINELIB_NAME_AW(PathIsNetworkPath)
-BOOL WINAPI PathIsLFNFileSpecA(LPCSTR); -BOOL WINAPI PathIsLFNFileSpecW(LPCWSTR); +BOOL WINAPI PathIsLFNFileSpecA(_In_ LPCSTR); +BOOL WINAPI PathIsLFNFileSpecW(_In_ LPCWSTR); #define PathIsLFNFileSpec WINELIB_NAME_AW(PathIsLFNFileSpec)
-LPCSTR WINAPI PathFindSuffixArrayA(LPCSTR,LPCSTR *,int); -LPCWSTR WINAPI PathFindSuffixArrayW(LPCWSTR,LPCWSTR *,int); +LPCSTR +WINAPI +PathFindSuffixArrayA( + _In_ LPCSTR, + _In_reads_(iArraySize) LPCSTR *, + int iArraySize); + +LPCWSTR +WINAPI +PathFindSuffixArrayW( + _In_ LPCWSTR, + _In_reads_(iArraySize) LPCWSTR *, + int iArraySize); + #define PathFindSuffixArray WINELIB_NAME_AW(PathFindSuffixArray)
-VOID WINAPI PathUndecorateA(LPSTR); -VOID WINAPI PathUndecorateW(LPWSTR); +VOID WINAPI PathUndecorateA(_Inout_ LPSTR); +VOID WINAPI PathUndecorateW(_Inout_ LPWSTR); #define PathUndecorate WINELIB_NAME_AW(PathUndecorate)
-BOOL WINAPI PathUnExpandEnvStringsA(LPCSTR,LPSTR,UINT); -BOOL WINAPI PathUnExpandEnvStringsW(LPCWSTR,LPWSTR,UINT); +BOOL +WINAPI +PathUnExpandEnvStringsA( + _In_ LPCSTR, + _Out_writes_(cchBuf) LPSTR, + _In_ UINT cchBuf); + +BOOL +WINAPI +PathUnExpandEnvStringsW( + _In_ LPCWSTR, + _Out_writes_(cchBuf) LPWSTR, + _In_ UINT cchBuf); + #define PathUnExpandEnvStrings WINELIB_NAME_AW(PathUnExpandEnvStrings)
/* Url functions */ @@ -650,24 +1224,82 @@ #define URL_ESCAPE_SEGMENT_ONLY 0x00002000 #define URL_ESCAPE_PERCENT 0x00001000
-HRESULT WINAPI UrlApplySchemeA(LPCSTR,LPSTR,LPDWORD,DWORD); -HRESULT WINAPI UrlApplySchemeW(LPCWSTR,LPWSTR,LPDWORD,DWORD); +HRESULT +WINAPI +UrlApplySchemeA( + _In_ LPCSTR, + _Out_writes_(*pcchOut) LPSTR, + _Inout_ LPDWORD pcchOut, + DWORD); + +HRESULT +WINAPI +UrlApplySchemeW( + _In_ LPCWSTR, + _Out_writes_(*pcchOut) LPWSTR, + _Inout_ LPDWORD pcchOut, + DWORD); + #define UrlApplyScheme WINELIB_NAME_AW(UrlApplyScheme)
-HRESULT WINAPI UrlCanonicalizeA(LPCSTR,LPSTR,LPDWORD,DWORD); -HRESULT WINAPI UrlCanonicalizeW(LPCWSTR,LPWSTR,LPDWORD,DWORD); +HRESULT +WINAPI +UrlCanonicalizeA( + _In_ LPCSTR, + _Out_writes_to_(*pcchCanonicalized, *pcchCanonicalized) LPSTR, + _Inout_ LPDWORD pcchCanonicalized, + DWORD); + +HRESULT +WINAPI +UrlCanonicalizeW( + _In_ LPCWSTR, + _Out_writes_to_(*pcchCanonicalized, *pcchCanonicalized) LPWSTR, + _Inout_ LPDWORD pcchCanonicalized, + DWORD); + #define UrlCanonicalize WINELIB_NAME_AW(UrlCanonicalize)
-HRESULT WINAPI UrlCombineA(LPCSTR,LPCSTR,LPSTR,LPDWORD,DWORD); -HRESULT WINAPI UrlCombineW(LPCWSTR,LPCWSTR,LPWSTR,LPDWORD,DWORD); +HRESULT +WINAPI +UrlCombineA( + _In_ LPCSTR, + _In_ LPCSTR, + _Out_writes_to_opt_(*pcchCombined, *pcchCombined) LPSTR, + _Inout_ LPDWORD pcchCombined, + DWORD); + +HRESULT +WINAPI +UrlCombineW( + _In_ LPCWSTR, + _In_ LPCWSTR, + _Out_writes_to_opt_(*pcchCombined, *pcchCombined) LPWSTR, + _Inout_ LPDWORD pcchCombined, + DWORD); + #define UrlCombine WINELIB_NAME_AW(UrlCombine)
-INT WINAPI UrlCompareA(LPCSTR,LPCSTR,BOOL); -INT WINAPI UrlCompareW(LPCWSTR,LPCWSTR,BOOL); +INT WINAPI UrlCompareA(_In_ LPCSTR, _In_ LPCSTR, BOOL); +INT WINAPI UrlCompareW(_In_ LPCWSTR, _In_ LPCWSTR, BOOL); #define UrlCompare WINELIB_NAME_AW(UrlCompare)
-HRESULT WINAPI UrlEscapeA(LPCSTR,LPSTR,LPDWORD,DWORD); -HRESULT WINAPI UrlEscapeW(LPCWSTR,LPWSTR,LPDWORD,DWORD); +HRESULT +WINAPI +UrlEscapeA( + _In_ LPCSTR, + _Out_writes_to_(*pcchEscaped, *pcchEscaped) LPSTR, + _Inout_ LPDWORD pcchEscaped, + DWORD); + +HRESULT +WINAPI +UrlEscapeW( + _In_ LPCWSTR, + _Out_writes_to_(*pcchEscaped, *pcchEscaped) LPWSTR, + _Inout_ LPDWORD pcchEscaped, + DWORD); + #define UrlEscape WINELIB_NAME_AW(UrlEscape)
#define UrlEscapeSpacesA(x,y,z) UrlCanonicalizeA(x, y, z, \ @@ -676,38 +1308,86 @@ URL_DONT_ESCAPE_EXTRA_INFO|URL_ESCAPE_SPACES_ONLY) #define UrlEscapeSpaces WINELIB_NAME_AW(UrlEscapeSpaces)
-LPCSTR WINAPI UrlGetLocationA(LPCSTR); -LPCWSTR WINAPI UrlGetLocationW(LPCWSTR); +LPCSTR WINAPI UrlGetLocationA(_In_ LPCSTR); +LPCWSTR WINAPI UrlGetLocationW(_In_ LPCWSTR); #define UrlGetLocation WINELIB_NAME_AW(UrlGetLocation)
-HRESULT WINAPI UrlGetPartA(LPCSTR,LPSTR,LPDWORD,DWORD,DWORD); -HRESULT WINAPI UrlGetPartW(LPCWSTR,LPWSTR,LPDWORD,DWORD,DWORD); +HRESULT +WINAPI +UrlGetPartA( + _In_ LPCSTR, + _Out_writes_(*pcchOut) LPSTR, + _Inout_ LPDWORD pcchOut, + DWORD, + DWORD); + +HRESULT +WINAPI +UrlGetPartW( + _In_ LPCWSTR, + _Out_writes_(*pcchOut) LPWSTR, + _Inout_ LPDWORD pcchOut, + DWORD, + DWORD); + #define UrlGetPart WINELIB_NAME_AW(UrlGetPart)
-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); +HRESULT +WINAPI +HashData( + _In_reads_bytes_(cbData) const unsigned char *, + DWORD cbData, + _Out_writes_bytes_(cbHash) unsigned char *lpDest, + DWORD cbHash); + +HRESULT +WINAPI +UrlHashA( + _In_ LPCSTR, + _Out_writes_bytes_(cbHash) unsigned char *, + DWORD cbHash); + +HRESULT +WINAPI +UrlHashW( + _In_ LPCWSTR, + _Out_writes_bytes_(cbHash) unsigned char *, + DWORD cbHash); + #define UrlHash WINELIB_NAME_AW(UrlHash)
-BOOL WINAPI UrlIsA(LPCSTR,URLIS); -BOOL WINAPI UrlIsW(LPCWSTR,URLIS); +BOOL WINAPI UrlIsA(_In_ LPCSTR, URLIS); +BOOL WINAPI UrlIsW(_In_ LPCWSTR, URLIS); #define UrlIs WINELIB_NAME_AW(UrlIs)
-BOOL WINAPI UrlIsNoHistoryA(LPCSTR); -BOOL WINAPI UrlIsNoHistoryW(LPCWSTR); +BOOL WINAPI UrlIsNoHistoryA(_In_ LPCSTR); +BOOL WINAPI UrlIsNoHistoryW(_In_ LPCWSTR); #define UrlIsNoHistory WINELIB_NAME_AW(UrlIsNoHistory)
-BOOL WINAPI UrlIsOpaqueA(LPCSTR); -BOOL WINAPI UrlIsOpaqueW(LPCWSTR); +BOOL WINAPI UrlIsOpaqueA(_In_ LPCSTR); +BOOL WINAPI UrlIsOpaqueW(_In_ 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); +HRESULT +WINAPI +UrlUnescapeA( + _Inout_ LPSTR, + _Out_writes_to_opt_(*pcchUnescaped, *pcchUnescaped) LPSTR, + _Inout_opt_ LPDWORD pcchUnescaped, + DWORD); + +HRESULT +WINAPI +UrlUnescapeW( + _Inout_ LPWSTR, + _Out_writes_to_opt_(*pcchUnescaped, *pcchUnescaped) LPWSTR, + _Inout_opt_ LPDWORD pcchUnescaped, + DWORD); + #define UrlUnescape WINELIB_NAME_AW(UrlUnescape)
#define UrlUnescapeInPlaceA(x,y) UrlUnescapeA(x, NULL, NULL, \ @@ -716,8 +1396,22 @@ y | URL_UNESCAPE_INPLACE) #define UrlUnescapeInPlace WINELIB_NAME_AW(UrlUnescapeInPlace)
-HRESULT WINAPI UrlCreateFromPathA(LPCSTR,LPSTR,LPDWORD,DWORD); -HRESULT WINAPI UrlCreateFromPathW(LPCWSTR,LPWSTR,LPDWORD,DWORD); +HRESULT +WINAPI +UrlCreateFromPathA( + _In_ LPCSTR, + _Out_writes_to_(*pcchUrl, *pcchUrl) LPSTR, + _Inout_ LPDWORD pcchUrl, + DWORD); + +HRESULT +WINAPI +UrlCreateFromPathW( + _In_ LPCWSTR, + _Out_writes_to_(*pcchUrl, *pcchUrl) LPWSTR, + _Inout_ LPDWORD pcchUrl, + DWORD); + #define UrlCreateFromPath WINELIB_NAME_AW(UrlCreateFromPath)
typedef struct tagPARSEDURLA { @@ -738,8 +1432,8 @@ UINT nScheme; } PARSEDURLW, *PPARSEDURLW;
-HRESULT WINAPI ParseURLA(LPCSTR pszUrl, PARSEDURLA *ppu); -HRESULT WINAPI ParseURLW(LPCWSTR pszUrl, PARSEDURLW *ppu); +HRESULT WINAPI ParseURLA(_In_ LPCSTR pszUrl, _Inout_ PARSEDURLA *ppu); +HRESULT WINAPI ParseURLW(_In_ LPCWSTR pszUrl, _Inout_ PARSEDURLW *ppu); #define ParseURL WINELIB_NAME_AW(ParseUrl)
#endif /* NO_SHLWAPI_PATH */ @@ -756,74 +1450,110 @@ BOOL WINAPI ChrCmpIW (WCHAR,WCHAR); #define ChrCmpI WINELIB_NAME_AW(ChrCmpI)
-INT WINAPI StrCSpnA(LPCSTR,LPCSTR); -INT WINAPI StrCSpnW(LPCWSTR,LPCWSTR); +INT WINAPI StrCSpnA(_In_ LPCSTR, _In_ LPCSTR); +INT WINAPI StrCSpnW(_In_ LPCWSTR, _In_ LPCWSTR); #define StrCSpn WINELIB_NAME_AW(StrCSpn)
-INT WINAPI StrCSpnIA(LPCSTR,LPCSTR); -INT WINAPI StrCSpnIW(LPCWSTR,LPCWSTR); +INT WINAPI StrCSpnIA(_In_ LPCSTR, _In_ LPCSTR); +INT WINAPI StrCSpnIW(_In_ LPCWSTR, _In_ LPCWSTR); #define StrCSpnI WINELIB_NAME_AW(StrCSpnI)
#define StrCatA lstrcatA -LPWSTR WINAPI StrCatW(LPWSTR,LPCWSTR); +LPWSTR WINAPI StrCatW(_Inout_ LPWSTR, _In_ LPCWSTR); #define StrCat WINELIB_NAME_AW(StrCat)
-LPSTR WINAPI StrCatBuffA(LPSTR,LPCSTR,INT); -LPWSTR WINAPI StrCatBuffW(LPWSTR,LPCWSTR,INT); +LPSTR +WINAPI +StrCatBuffA( + _Inout_updates_(cchDestBuffSize) LPSTR, + _In_ LPCSTR, + INT cchDestBuffSize); + +LPWSTR +WINAPI +StrCatBuffW( + _Inout_updates_(cchDestBuffSize) LPWSTR, + _In_ LPCWSTR, + INT cchDestBuffSize); + #define StrCatBuff WINELIB_NAME_AW(StrCatBuff)
-DWORD WINAPI StrCatChainW(LPWSTR,DWORD,DWORD,LPCWSTR); - -LPSTR WINAPI StrChrA(LPCSTR,WORD); -LPWSTR WINAPI StrChrW(LPCWSTR,WCHAR); +DWORD +WINAPI +StrCatChainW( + _Out_writes_(cchDst) LPWSTR, + DWORD cchDst, + DWORD, + _In_ LPCWSTR); + +LPSTR WINAPI StrChrA(_In_ LPCSTR, WORD); +LPWSTR WINAPI StrChrW(_In_ LPCWSTR, WCHAR); #define StrChr WINELIB_NAME_AW(StrChr)
-LPSTR WINAPI StrChrIA(LPCSTR,WORD); -LPWSTR WINAPI StrChrIW(LPCWSTR,WCHAR); +LPSTR WINAPI StrChrIA(_In_ LPCSTR, WORD); +LPWSTR WINAPI StrChrIW(_In_ LPCWSTR, WCHAR); #define StrChrI WINELIB_NAME_AW(StrChrI)
#define StrCmpA lstrcmpA -int WINAPI StrCmpW(LPCWSTR,LPCWSTR); +int WINAPI StrCmpW(_In_ LPCWSTR, _In_ LPCWSTR); #define StrCmp WINELIB_NAME_AW(StrCmp)
#define StrCmpIA lstrcmpiA -int WINAPI StrCmpIW(LPCWSTR,LPCWSTR); +int WINAPI StrCmpIW(_In_ LPCWSTR, _In_ LPCWSTR); #define StrCmpI WINELIB_NAME_AW(StrCmpI)
#define StrCpyA lstrcpyA -LPWSTR WINAPI StrCpyW(LPWSTR,LPCWSTR); +LPWSTR WINAPI StrCpyW(_Out_ LPWSTR, _In_ LPCWSTR); #define StrCpy WINELIB_NAME_AW(StrCpy)
#define StrCpyNA lstrcpynA -LPWSTR WINAPI StrCpyNW(LPWSTR,LPCWSTR,int); +LPWSTR WINAPI StrCpyNW(_Out_writes_(cchMax) LPWSTR, _In_ LPCWSTR, int cchMax); #define StrCpyN WINELIB_NAME_AW(StrCpyN) #define StrNCpy WINELIB_NAME_AW(StrCpyN)
-INT WINAPI StrCmpLogicalW(LPCWSTR,LPCWSTR); - -INT WINAPI StrCmpNA(LPCSTR,LPCSTR,INT); -INT WINAPI StrCmpNW(LPCWSTR,LPCWSTR,INT); +INT WINAPI StrCmpLogicalW(_In_ LPCWSTR, _In_ LPCWSTR); + +INT WINAPI StrCmpNA(_In_ LPCSTR, _In_ LPCSTR, INT); +INT WINAPI StrCmpNW(_In_ LPCWSTR, _In_ 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); +INT WINAPI StrCmpNIA(_In_ LPCSTR, _In_ LPCSTR, INT); +INT WINAPI StrCmpNIW(_In_ LPCWSTR, _In_ LPCWSTR, INT); #define StrCmpNI WINELIB_NAME_AW(StrCmpNI) #define StrNCmpI WINELIB_NAME_AW(StrCmpNI)
-LPSTR WINAPI StrDupA(LPCSTR); -LPWSTR WINAPI StrDupW(LPCWSTR); +LPSTR WINAPI StrDupA(_In_ LPCSTR); +LPWSTR WINAPI StrDupW(_In_ LPCWSTR); #define StrDup WINELIB_NAME_AW(StrDup)
-HRESULT WINAPI SHStrDupA(LPCSTR,WCHAR**); -HRESULT WINAPI SHStrDupW(LPCWSTR,WCHAR**); +HRESULT WINAPI SHStrDupA(_In_ LPCSTR, _Outptr_ WCHAR**); +HRESULT WINAPI SHStrDupW(_In_ LPCWSTR, _Outptr_ WCHAR**); #define SHStrDup WINELIB_NAME_AW(SHStrDup)
-LPSTR WINAPI StrFormatByteSizeA (DWORD,LPSTR,UINT); +LPSTR +WINAPI +StrFormatByteSizeA( + DWORD, + _Out_writes_(cchBuf) LPSTR, + UINT cchBuf);
/* A/W Pairing is broken for this function */ -LPSTR WINAPI StrFormatByteSize64A (LONGLONG,LPSTR,UINT); -LPWSTR WINAPI StrFormatByteSizeW (LONGLONG,LPWSTR,UINT); + +LPSTR +WINAPI +StrFormatByteSize64A( + LONGLONG, + _Out_writes_(cchBuf) LPSTR, + UINT cchBuf); + +LPWSTR +WINAPI +StrFormatByteSizeW( + LONGLONG, + _Out_writes_(cchBuf) LPWSTR, + UINT cchBuf); + #ifndef WINE_NO_UNICODE_MACROS #ifdef UNICODE #define StrFormatByteSize StrFormatByteSizeW @@ -832,16 +1562,42 @@ #endif #endif
-LPSTR WINAPI StrFormatKBSizeA(LONGLONG,LPSTR,UINT); -LPWSTR WINAPI StrFormatKBSizeW(LONGLONG,LPWSTR,UINT); +LPSTR +WINAPI +StrFormatKBSizeA( + LONGLONG, + _Out_writes_(cchBuf) LPSTR, + UINT cchBuf); + +LPWSTR +WINAPI +StrFormatKBSizeW( + LONGLONG, + _Out_writes_(cchBuf) LPWSTR, + UINT cchBuf); + #define StrFormatKBSize WINELIB_NAME_AW(StrFormatKBSize)
-int WINAPI StrFromTimeIntervalA(LPSTR,UINT,DWORD,int); -int WINAPI StrFromTimeIntervalW(LPWSTR,UINT,DWORD,int); +int +WINAPI +StrFromTimeIntervalA( + _Out_writes_(cchMax) LPSTR, + UINT cchMax, + DWORD, + int); + +int +WINAPI +StrFromTimeIntervalW( + _Out_writes_(cchMax) LPWSTR, + UINT cchMax, + DWORD, + int); + #define StrFromTimeInterval WINELIB_NAME_AW(StrFromTimeInterval)
-BOOL WINAPI StrIsIntlEqualA(BOOL,LPCSTR,LPCSTR,int); -BOOL WINAPI StrIsIntlEqualW(BOOL,LPCWSTR,LPCWSTR,int); +BOOL WINAPI StrIsIntlEqualA(BOOL, _In_ LPCSTR, _In_ LPCSTR, int); +BOOL WINAPI StrIsIntlEqualW(BOOL, _In_ LPCWSTR, _In_ LPCWSTR, int); #define StrIsIntlEqual WINELIB_NAME_AW(StrIsIntlEqual)
#define StrIntlEqNA(a,b,c) StrIsIntlEqualA(TRUE,a,b,c) @@ -850,71 +1606,119 @@ #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); +LPSTR WINAPI StrNCatA(_Inout_updates_(cchMax) LPSTR, LPCSTR, int cchMax); +LPWSTR WINAPI StrNCatW(_Inout_updates_(cchMax) LPWSTR, LPCWSTR, int cchMax); #define StrNCat WINELIB_NAME_AW(StrNCat) #define StrCatN WINELIB_NAME_AW(StrNCat)
-LPSTR WINAPI StrPBrkA(LPCSTR,LPCSTR); -LPWSTR WINAPI StrPBrkW(LPCWSTR,LPCWSTR); +LPSTR WINAPI StrPBrkA(_In_ LPCSTR, _In_ LPCSTR); +LPWSTR WINAPI StrPBrkW(_In_ LPCWSTR, _In_ LPCWSTR); #define StrPBrk WINELIB_NAME_AW(StrPBrk)
-LPSTR WINAPI StrRChrA(LPCSTR,LPCSTR,WORD); -LPWSTR WINAPI StrRChrW(LPCWSTR,LPCWSTR,WORD); +LPSTR WINAPI StrRChrA(_In_ LPCSTR, _In_opt_ LPCSTR, WORD); +LPWSTR WINAPI StrRChrW(_In_ LPCWSTR, _In_opt_ LPCWSTR, WCHAR); #define StrRChr WINELIB_NAME_AW(StrRChr)
-LPSTR WINAPI StrRChrIA(LPCSTR,LPCSTR,WORD); -LPWSTR WINAPI StrRChrIW(LPCWSTR,LPCWSTR,WORD); +LPSTR WINAPI StrRChrIA(_In_ LPCSTR, _In_opt_ LPCSTR, WORD); +LPWSTR WINAPI StrRChrIW(_In_ LPCWSTR, _In_opt_ LPCWSTR, WCHAR); #define StrRChrI WINELIB_NAME_AW(StrRChrI)
-LPSTR WINAPI StrRStrIA(LPCSTR,LPCSTR,LPCSTR); -LPWSTR WINAPI StrRStrIW(LPCWSTR,LPCWSTR,LPCWSTR); +LPSTR WINAPI StrRStrIA(_In_ LPCSTR, _In_opt_ LPCSTR, _In_ LPCSTR); +LPWSTR WINAPI StrRStrIW(_In_ LPCWSTR, _In_opt_ LPCWSTR, _In_ LPCWSTR); #define StrRStrI WINELIB_NAME_AW(StrRStrI)
-int WINAPI StrSpnA(LPCSTR,LPCSTR); -int WINAPI StrSpnW(LPCWSTR,LPCWSTR); +int WINAPI StrSpnA(_In_ LPCSTR, _In_ LPCSTR); +int WINAPI StrSpnW(_In_ LPCWSTR, _In_ LPCWSTR); #define StrSpn WINELIB_NAME_AW(StrSpn)
-LPSTR WINAPI StrStrA(LPCSTR,LPCSTR); -LPWSTR WINAPI StrStrW(LPCWSTR,LPCWSTR); +LPSTR WINAPI StrStrA(_In_ LPCSTR, _In_ LPCSTR); +LPWSTR WINAPI StrStrW(_In_ LPCWSTR, _In_ LPCWSTR); #define StrStr WINELIB_NAME_AW(StrStr)
-LPSTR WINAPI StrStrIA(LPCSTR,LPCSTR); -LPWSTR WINAPI StrStrIW(LPCWSTR,LPCWSTR); +LPSTR WINAPI StrStrIA(_In_ LPCSTR, _In_ LPCSTR); +LPWSTR WINAPI StrStrIW(_In_ LPCWSTR, _In_ LPCWSTR); #define StrStrI WINELIB_NAME_AW(StrStrI)
-LPWSTR WINAPI StrStrNW(LPCWSTR,LPCWSTR,UINT); -LPWSTR WINAPI StrStrNIW(LPCWSTR,LPCWSTR,UINT); - -int WINAPI StrToIntA(LPCSTR); -int WINAPI StrToIntW(LPCWSTR); +LPWSTR WINAPI StrStrNW(_In_ LPCWSTR, _In_ LPCWSTR, UINT); +LPWSTR WINAPI StrStrNIW(_In_ LPCWSTR, _In_ LPCWSTR, UINT); + +int WINAPI StrToIntA(_In_ LPCSTR); +int WINAPI StrToIntW(_In_ 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*); +BOOL WINAPI StrToIntExA(_In_ LPCSTR, DWORD, _Out_ int*); +BOOL WINAPI StrToIntExW(_In_ LPCWSTR, DWORD, _Out_ int*); #define StrToIntEx WINELIB_NAME_AW(StrToIntEx)
-BOOL WINAPI StrToInt64ExA(LPCSTR,DWORD,LONGLONG*); -BOOL WINAPI StrToInt64ExW(LPCWSTR,DWORD,LONGLONG*); +BOOL WINAPI StrToInt64ExA(_In_ LPCSTR, DWORD, _Out_ LONGLONG*); +BOOL WINAPI StrToInt64ExW(_In_ LPCWSTR, DWORD, _Out_ LONGLONG*); #define StrToIntEx64 WINELIB_NAME_AW(StrToIntEx64)
-BOOL WINAPI StrTrimA(LPSTR,LPCSTR); -BOOL WINAPI StrTrimW(LPWSTR,LPCWSTR); +BOOL WINAPI StrTrimA(_Inout_ LPSTR, _In_ LPCSTR); +BOOL WINAPI StrTrimW(_Inout_ LPWSTR, _In_ 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); +INT +WINAPI +wvnsprintfA( + _Out_writes_(cchDest) LPSTR, + _In_ INT cchDest, + _In_ _Printf_format_string_ LPCSTR, + _In_ __ms_va_list); + +INT +WINAPI +wvnsprintfW( + _Out_writes_(cchDest) LPWSTR, + _In_ INT cchDest, + _In_ _Printf_format_string_ LPCWSTR, + _In_ __ms_va_list); + #define wvnsprintf WINELIB_NAME_AW(wvnsprintf)
-INT WINAPIV wnsprintfA(LPSTR,INT,LPCSTR, ...); -INT WINAPIV wnsprintfW(LPWSTR,INT,LPCWSTR, ...); +INT +WINAPIV +wnsprintfA( + _Out_writes_(cchDest) LPSTR, + _In_ INT cchDest, + _In_ _Printf_format_string_ LPCSTR, + ...); + +INT +WINAPIV +wnsprintfW( + _Out_writes_(cchDest) LPWSTR, + _In_ INT cchDest, + _In_ _Printf_format_string_ LPCWSTR, + ...); + #define wnsprintf WINELIB_NAME_AW(wnsprintf)
-HRESULT WINAPI SHLoadIndirectString(LPCWSTR,LPWSTR,UINT,PVOID*); - -BOOL WINAPI IntlStrEqWorkerA(BOOL,LPCSTR,LPCSTR,int); -BOOL WINAPI IntlStrEqWorkerW(BOOL,LPCWSTR,LPCWSTR,int); +HRESULT +WINAPI +SHLoadIndirectString( + _In_ LPCWSTR, + _Out_writes_(cchOutBuf) LPWSTR, + _In_ UINT cchOutBuf, + _Reserved_ PVOID*); + +BOOL +WINAPI +IntlStrEqWorkerA( + BOOL, + _In_reads_(nChar) LPCSTR, + _In_reads_(nChar) LPCSTR, + int nChar); + +BOOL +WINAPI +IntlStrEqWorkerW( + BOOL, + _In_reads_(nChar) LPCWSTR, + _In_reads_(nChar) LPCWSTR, + int nChar); + #define IntlStrEqWorker WINELIB_NAME_AW(IntlStrEqWorker)
#define IntlStrEqNA(s1,s2,n) IntlStrEqWorkerA(TRUE,s1,s2,n) @@ -925,15 +1729,46 @@ #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*); +HRESULT +WINAPI +StrRetToStrA( + _Inout_ STRRET*, + _In_opt_ LPCITEMIDLIST, + _Outptr_ LPSTR*); + +HRESULT +WINAPI +StrRetToStrW( + _Inout_ STRRET*, + _In_opt_ LPCITEMIDLIST, + _Outptr_ LPWSTR*); + #define StrRetToStr WINELIB_NAME_AW(StrRetToStr)
-HRESULT WINAPI StrRetToBufA(STRRET*,LPCITEMIDLIST,LPSTR,UINT); -HRESULT WINAPI StrRetToBufW(STRRET*,LPCITEMIDLIST,LPWSTR,UINT); +HRESULT +WINAPI +StrRetToBufA( + _Inout_ STRRET*, + _In_opt_ LPCITEMIDLIST, + _Out_writes_(cchBuf) LPSTR, + UINT cchBuf); + +HRESULT +WINAPI +StrRetToBufW( + _Inout_ STRRET*, + _In_opt_ LPCITEMIDLIST, + _Out_writes_(cchBuf) LPWSTR, + UINT cchBuf); + #define StrRetToBuf WINELIB_NAME_AW(StrRetToBuf)
-HRESULT WINAPI StrRetToBSTR(STRRET*,LPCITEMIDLIST,BSTR*); +HRESULT +WINAPI +StrRetToBSTR( + _Inout_ STRRET*, + _In_opt_ LPCITEMIDLIST, + _Outptr_ BSTR*);
BOOL WINAPI IsCharSpaceA(CHAR); BOOL WINAPI IsCharSpaceW(WCHAR); @@ -945,13 +1780,13 @@ /* GDI functions */ #ifndef NO_SHLWAPI_GDI
-HPALETTE WINAPI SHCreateShellPalette(HDC); +HPALETTE WINAPI SHCreateShellPalette(_In_opt_ HDC);
COLORREF WINAPI ColorHLSToRGB(WORD,WORD,WORD);
COLORREF WINAPI ColorAdjustLuma(COLORREF,int,BOOL);
-VOID WINAPI ColorRGBToHLS(COLORREF,LPWORD,LPWORD,LPWORD); +VOID WINAPI ColorRGBToHLS(COLORREF, _Out_ LPWORD, _Out_ LPWORD, _Out_ LPWORD);
#endif /* NO_SHLWAPI_GDI */
@@ -961,19 +1796,67 @@ /* Stream functions */ #ifndef NO_SHLWAPI_STREAM
-struct IStream * WINAPI SHOpenRegStreamA(HKEY,LPCSTR,LPCSTR,DWORD); -struct IStream * WINAPI SHOpenRegStreamW(HKEY,LPCWSTR,LPCWSTR,DWORD); +struct IStream * +WINAPI +SHOpenRegStreamA( + _In_ HKEY, + _In_opt_ LPCSTR, + _In_opt_ LPCSTR, + _In_ DWORD); + +struct IStream * +WINAPI +SHOpenRegStreamW( + _In_ HKEY, + _In_opt_ LPCWSTR, + _In_opt_ LPCWSTR, + _In_ 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); +struct IStream * +WINAPI +SHOpenRegStream2A( + _In_ HKEY, + _In_opt_ LPCSTR, + _In_opt_ LPCSTR, + _In_ DWORD); + +struct IStream * +WINAPI +SHOpenRegStream2W( + _In_ HKEY, + _In_opt_ LPCWSTR, + _In_opt_ LPCWSTR, + _In_ DWORD); + #define SHOpenRegStream2 WINELIB_NAME_AW(SHOpenRegStream2)
-HRESULT WINAPI SHCreateStreamOnFileA(LPCSTR,DWORD,struct IStream**); -HRESULT WINAPI SHCreateStreamOnFileW(LPCWSTR,DWORD,struct IStream**); +HRESULT +WINAPI +SHCreateStreamOnFileA( + _In_ LPCSTR, + _In_ DWORD, + _Outptr_ struct IStream**); + +HRESULT +WINAPI +SHCreateStreamOnFileW( + _In_ LPCWSTR, + _In_ DWORD, + _Outptr_ struct IStream**); + #define SHCreateStreamOnFile WINELIB_NAME_AW(SHCreateStreamOnFile)
-HRESULT WINAPI SHCreateStreamOnFileEx(LPCWSTR,DWORD,DWORD,BOOL,struct IStream*,struct IStream**); +HRESULT +WINAPI +SHCreateStreamOnFileEx( + _In_ LPCWSTR, + _In_ DWORD, + _In_ DWORD, + _In_ BOOL, + _In_opt_ struct IStream*, + _Outptr_ struct IStream**);
HRESULT WINAPI SHCreateStreamWrapper(LPBYTE,DWORD,DWORD,struct IStream**);
@@ -993,12 +1876,12 @@ #define SHACF_AUTOAPPEND_FORCE_ON 0x40000000 #define SHACF_AUTOAPPEND_FORCE_OFF 0x80000000
-HRESULT WINAPI SHAutoComplete(HWND,DWORD); +HRESULT WINAPI SHAutoComplete(_In_ HWND, DWORD);
/* Threads */ -HRESULT WINAPI SHCreateThreadRef(LONG*, IUnknown**); -HRESULT WINAPI SHGetThreadRef(IUnknown**); -HRESULT WINAPI SHSetThreadRef(IUnknown*); +HRESULT WINAPI SHCreateThreadRef(_Inout_ LONG*, _Outptr_ IUnknown**); +HRESULT WINAPI SHGetThreadRef(_Outptr_ IUnknown**); +HRESULT WINAPI SHSetThreadRef(_In_opt_ IUnknown*); HRESULT WINAPI SHReleaseThreadRef(void);
/* SHCreateThread flags */ @@ -1010,9 +1893,15 @@ #define CTF_REF_COUNTED 0x20 /* Thread is ref counted */ #define CTF_WAIT_ALLOWCOM 0x40 /* Allow marshalling */
-BOOL WINAPI SHCreateThread(LPTHREAD_START_ROUTINE,void*,DWORD,LPTHREAD_START_ROUTINE); - -BOOL WINAPI SHSkipJunction(struct IBindCtx*,const CLSID*); +BOOL +WINAPI +SHCreateThread( + _In_ LPTHREAD_START_ROUTINE, + _In_opt_ void*, + _In_ DWORD, + _In_opt_ LPTHREAD_START_ROUTINE); + +BOOL WINAPI SHSkipJunction(_In_opt_ struct IBindCtx*, _In_ const CLSID*);
/* Version Information */
@@ -1048,7 +1937,7 @@ #define MAKEDLLVERULL(mjr, mnr, bld, qfe) (((ULONGLONG)(mjr)<< 48)| \ ((ULONGLONG)(mnr)<< 32) | ((ULONGLONG)(bld)<< 16) | (ULONGLONG)(qfe))
-HRESULT WINAPI DllInstall(BOOL,LPCWSTR) DECLSPEC_HIDDEN; +HRESULT WINAPI DllInstall(BOOL, _In_opt_ LPCWSTR) DECLSPEC_HIDDEN;
#if (_WIN32_IE >= 0x0600) @@ -1065,7 +1954,15 @@ #define SHGVSPB_USERDEFAULTS (SHGVSPB_PERUSER | SHGVSPB_ALLFOLDERS) #define SHGVSPB_GLOBALDEAFAULTS (SHGVSPB_ALLUSERS | SHGVSPB_ALLFOLDERS)
-HRESULT WINAPI SHGetViewStatePropertyBag(LPCITEMIDLIST pidl, LPWSTR bag_name, DWORD flags, REFIID riid, void **ppv); +HRESULT +WINAPI +SHGetViewStatePropertyBag( + _In_opt_ LPCITEMIDLIST pidl, + _In_opt_ LPWSTR bag_name, + DWORD flags, + _In_ REFIID riid, + _Outptr_ void **ppv); + #endif /* (_WIN32_IE >= 0x0600) */
@@ -1133,7 +2030,13 @@ int dwOffset; } QITAB, *LPQITAB;
-HRESULT WINAPI QISearch(void* base, const QITAB *pqit, REFIID riid, void **ppv); +HRESULT +WINAPI +QISearch( + _Inout_ void* base, + _In_ const QITAB *pqit, + _In_ REFIID riid, + _Outptr_ void **ppv);
#include <poppack.h>
-
akhaldi＠svn.reactos.org