[ros-diffs] [akhaldi] 58388: [PSDK] * Annotate winreg.h.

Author: akhaldi
Date: Fri Mar  1 18:18:36 2013
New Revision: 58388

URL: http://svn.reactos.org/svn/reactos?rev=58388&view=rev
Log:
[PSDK]
* Annotate winreg.h.

Modified:
    trunk/reactos/include/psdk/winreg.h

Modified: trunk/reactos/include/psdk/winreg.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/include/psdk/winreg.h?rev=…
==============================================================================
--- trunk/reactos/include/psdk/winreg.h [iso-8859-1] (original)
+++ trunk/reactos/include/psdk/winreg.h [iso-8859-1] Fri Mar  1 18:18:36 2013
@@ -62,7 +62,7 @@
 
 #ifndef RC_INVOKED
 typedef ACCESS_MASK REGSAM;
-typedef LONG LSTATUS;
+typedef _Return_type_success_(return==ERROR_SUCCESS) LONG LSTATUS;
 typedef struct value_entA {
 	LPSTR ve_valuename;
 	DWORD ve_valuelen;
@@ -75,103 +75,367 @@
 	DWORD ve_valueptr;
 	DWORD ve_type;
 } VALENTW,*PVALENTW;
-BOOL WINAPI AbortSystemShutdownA(LPCSTR);
-BOOL WINAPI AbortSystemShutdownW(LPCWSTR);
-#if (_WIN32_WINNT >= 0x0600)
-DWORD WINAPI InitiateShutdownA(LPSTR, LPSTR, DWORD, DWORD, DWORD);
-DWORD WINAPI InitiateShutdownW(LPWSTR, LPWSTR, DWORD, DWORD, DWORD);
-#endif
-BOOL WINAPI InitiateSystemShutdownA(LPSTR,LPSTR,DWORD,BOOL,BOOL);
-BOOL WINAPI InitiateSystemShutdownW(LPWSTR,LPWSTR,DWORD,BOOL,BOOL);
-BOOL WINAPI InitiateSystemShutdownExA(LPSTR,LPSTR,DWORD,BOOL,BOOL,DWORD);
-BOOL WINAPI InitiateSystemShutdownExW(LPWSTR,LPWSTR,DWORD,BOOL,BOOL,DWORD);
-LONG WINAPI RegCloseKey(HKEY);
-LONG WINAPI RegConnectRegistryA(LPCSTR,HKEY,PHKEY);
-LONG WINAPI RegConnectRegistryW(LPCWSTR,HKEY,PHKEY);
-#if (_WIN32_WINNT >= 0x0600)
-LONG WINAPI RegCopyTreeA(HKEY,LPCSTR,HKEY);
-LONG WINAPI RegCopyTreeW(HKEY,LPCWSTR,HKEY);
-#endif
-LONG WINAPI RegCreateKeyA(HKEY,LPCSTR,PHKEY);
-LONG WINAPI
RegCreateKeyExA(HKEY,LPCSTR,DWORD,LPSTR,DWORD,REGSAM,LPSECURITY_ATTRIBUTES,PHKEY,PDWORD);
-LONG WINAPI
RegCreateKeyExW(HKEY,LPCWSTR,DWORD,LPWSTR,DWORD,REGSAM,LPSECURITY_ATTRIBUTES,PHKEY,PDWORD);
-LONG WINAPI RegCreateKeyW(HKEY,LPCWSTR,PHKEY);
-LONG WINAPI RegDeleteKeyA(HKEY,LPCSTR);
-LONG WINAPI RegDeleteKeyExA (HKEY,LPCSTR,REGSAM,DWORD);
-LONG WINAPI RegDeleteKeyExW (HKEY,LPCWSTR,REGSAM,DWORD);
-#if (_WIN32_WINNT >= 0x0600)
-LONG WINAPI RegDeleteKeyValueA(HKEY,LPCSTR,LPCSTR);
-LONG WINAPI RegDeleteKeyValueW(HKEY,LPCWSTR,LPCWSTR);
-#endif
-LONG WINAPI RegDeleteKeyW(HKEY,LPCWSTR);
-#if (_WIN32_WINNT >= 0x0600)
-LONG WINAPI RegDeleteTreeA(HKEY,LPCSTR);
-LONG WINAPI RegDeleteTreeW(HKEY,LPCWSTR);
-#endif
-LONG WINAPI RegDeleteValueA(HKEY,LPCSTR);
-LONG WINAPI RegDeleteValueW(HKEY,LPCWSTR);
+
+BOOL WINAPI AbortSystemShutdownA(_In_opt_ LPCSTR);
+BOOL WINAPI AbortSystemShutdownW(_In_opt_ LPCWSTR);
+
+#if (_WIN32_WINNT >= 0x0600)
+DWORD WINAPI InitiateShutdownA(_In_opt_ LPSTR, _In_opt_ LPSTR, _In_ DWORD, _In_ DWORD,
_In_ DWORD);
+DWORD WINAPI InitiateShutdownW(_In_opt_ LPWSTR, _In_opt_ LPWSTR, _In_ DWORD, _In_ DWORD,
_In_ DWORD);
+#endif
+
+BOOL WINAPI InitiateSystemShutdownA(_In_opt_ LPSTR, _In_opt_ LPSTR, _In_ DWORD, _In_
BOOL, _In_ BOOL);
+BOOL WINAPI InitiateSystemShutdownW(_In_opt_ LPWSTR, _In_opt_ LPWSTR, _In_ DWORD, _In_
BOOL, _In_ BOOL);
+BOOL WINAPI InitiateSystemShutdownExA(_In_opt_ LPSTR, _In_opt_ LPSTR, _In_ DWORD, _In_
BOOL, _In_ BOOL, _In_ DWORD);
+BOOL WINAPI InitiateSystemShutdownExW(_In_opt_ LPWSTR, _In_opt_ LPWSTR, _In_ DWORD, _In_
BOOL, _In_ BOOL, _In_ DWORD);
+LSTATUS WINAPI RegCloseKey(_In_ HKEY);
+LSTATUS WINAPI RegConnectRegistryA(_In_opt_ LPCSTR, _In_ HKEY, _Out_ PHKEY);
+LSTATUS WINAPI RegConnectRegistryW(_In_opt_ LPCWSTR,_In_ HKEY, _Out_ PHKEY);
+
+#if (_WIN32_WINNT >= 0x0600)
+LSTATUS WINAPI RegCopyTreeA(_In_ HKEY, _In_opt_ LPCSTR, _In_ HKEY);
+LSTATUS WINAPI RegCopyTreeW(_In_ HKEY, _In_opt_ LPCWSTR, _In_ HKEY);
+#endif
+
+LSTATUS WINAPI RegCreateKeyA(_In_ HKEY, _In_opt_ LPCSTR, _Out_ PHKEY);
+LSTATUS WINAPI RegCreateKeyW(_In_ HKEY, _In_opt_ LPCWSTR, _Out_ PHKEY);
+LSTATUS WINAPI RegCreateKeyExA(_In_ HKEY, _In_ LPCSTR, _Reserved_ DWORD, _In_opt_ LPSTR,
_In_ DWORD, _In_ REGSAM, _In_opt_ LPSECURITY_ATTRIBUTES, _Out_ PHKEY, _Out_opt_ PDWORD);
+LSTATUS WINAPI RegCreateKeyExW(_In_ HKEY, _In_ LPCWSTR, _Reserved_ DWORD, _In_opt_
LPWSTR, _In_ DWORD, _In_ REGSAM, _In_opt_ LPSECURITY_ATTRIBUTES, _Out_ PHKEY, _Out_opt_
PDWORD);
+LSTATUS WINAPI RegDeleteKeyA(_In_ HKEY, _In_ LPCSTR);
+LSTATUS WINAPI RegDeleteKeyW(_In_ HKEY, _In_ LPCWSTR);
+LSTATUS WINAPI RegDeleteKeyExA(_In_ HKEY, _In_ LPCSTR, _In_ REGSAM, _Reserved_ DWORD);
+LSTATUS WINAPI RegDeleteKeyExW(_In_ HKEY, _In_ LPCWSTR, _In_ REGSAM, _Reserved_ DWORD);
+
+#if (_WIN32_WINNT >= 0x0600)
+LSTATUS WINAPI RegDeleteKeyValueA(_In_ HKEY, _In_opt_ LPCSTR, _In_opt_ LPCSTR);
+LSTATUS WINAPI RegDeleteKeyValueW(_In_ HKEY, _In_opt_ LPCWSTR, _In_opt_ LPCWSTR);
+LSTATUS WINAPI RegDeleteTreeA(_In_ HKEY, _In_opt_ LPCSTR);
+LSTATUS WINAPI RegDeleteTreeW(_In_ HKEY, _In_opt_ LPCWSTR);
+#endif
+
+LSTATUS WINAPI RegDeleteValueA(_In_ HKEY, _In_opt_ LPCSTR);
+LSTATUS WINAPI RegDeleteValueW(_In_ HKEY, _In_opt_ LPCWSTR);
+
 #if (_WIN32_WINNT >= 0x0500)
 LONG WINAPI RegDisablePredefinedCache(VOID);
-LONG WINAPI RegSaveKeyExA(HKEY,LPCSTR,LPSECURITY_ATTRIBUTES,DWORD);
-LONG WINAPI RegSaveKeyExW(HKEY,LPCWSTR,LPSECURITY_ATTRIBUTES,DWORD);
-#endif
+LSTATUS WINAPI RegSaveKeyExA(_In_ HKEY, _In_ LPCSTR, _In_opt_ LPSECURITY_ATTRIBUTES, _In_
DWORD);
+LSTATUS WINAPI RegSaveKeyExW(_In_ HKEY, _In_ LPCWSTR, _In_opt_ LPSECURITY_ATTRIBUTES,
_In_ DWORD);
+#endif
+
 #if (_WIN32_WINNT >= 0x0600)
 LONG WINAPI RegDisablePredefinedCacheEx(VOID);
-LONG WINAPI RegDisableReflectionKey(HKEY);
-LONG WINAPI RegEnableReflectionKey(HKEY);
-#endif
-LONG WINAPI RegEnumKeyA(HKEY,DWORD,LPSTR,DWORD);
-LONG WINAPI RegEnumKeyW(HKEY,DWORD,LPWSTR,DWORD);
-LONG WINAPI RegEnumKeyExA(HKEY,DWORD,LPSTR,PDWORD,PDWORD,LPSTR,PDWORD,PFILETIME);
-LONG WINAPI RegEnumKeyExW(HKEY,DWORD,LPWSTR,PDWORD,PDWORD,LPWSTR,PDWORD,PFILETIME);
-LONG WINAPI RegEnumValueA(HKEY,DWORD,LPSTR,PDWORD,PDWORD,PDWORD,LPBYTE,PDWORD);
-LONG WINAPI RegEnumValueW(HKEY,DWORD,LPWSTR,PDWORD,PDWORD,PDWORD,LPBYTE,PDWORD);
-#if (_WIN32_WINNT >= 0x0600)
-LONG WINAPI RegGetValueA(HKEY,LPCSTR,LPCSTR,DWORD,LPDWORD,PVOID,LPDWORD);
-LONG WINAPI RegGetValueW(HKEY,LPCWSTR,LPCWSTR,DWORD,LPDWORD,PVOID,LPDWORD);
-#endif
-LONG WINAPI RegFlushKey(HKEY);
-LONG WINAPI RegGetKeySecurity(HKEY,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,PDWORD);
-LONG WINAPI RegLoadKeyA(HKEY,LPCSTR,LPCSTR);
-LONG WINAPI RegLoadKeyW(HKEY,LPCWSTR,LPCWSTR);
-#if (_WIN32_WINNT >= 0x0600)
-LONG WINAPI RegLoadMUIStringA(HKEY,LPCSTR,LPSTR,DWORD,LPDWORD,DWORD,LPCSTR);
-LONG WINAPI RegLoadMUIStringW(HKEY,LPCWSTR,LPWSTR,DWORD,LPDWORD,DWORD,LPCWSTR);
-#endif
-LONG WINAPI RegNotifyChangeKeyValue(HKEY,BOOL,DWORD,HANDLE,BOOL);
-LONG WINAPI RegOpenCurrentUser(REGSAM,PHKEY);
-LONG WINAPI RegOpenKeyA(HKEY,LPCSTR,PHKEY);
-LONG WINAPI RegOpenKeyExA(HKEY,LPCSTR,DWORD,REGSAM,PHKEY);
-LONG WINAPI RegOpenKeyExW(HKEY,LPCWSTR,DWORD,REGSAM,PHKEY);
-LONG WINAPI RegOpenKeyW(HKEY,LPCWSTR,PHKEY);
-LONG WINAPI
RegQueryInfoKeyA(HKEY,LPSTR,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PFILETIME);
-LONG WINAPI
RegQueryInfoKeyW(HKEY,LPWSTR,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PDWORD,PFILETIME);
-LONG WINAPI RegQueryMultipleValuesA(HKEY,PVALENTA,DWORD,LPSTR,LPDWORD);
-LONG WINAPI RegQueryMultipleValuesW(HKEY,PVALENTW,DWORD,LPWSTR,LPDWORD);
-#if (_WIN32_WINNT >= 0x0600)
-LONG WINAPI RegQueryReflectionKey(HKEY,BOOL*);
-#endif
-LONG WINAPI RegQueryValueA(HKEY,LPCSTR,LPSTR,PLONG);
-LONG WINAPI RegQueryValueExA(HKEY,LPCSTR,LPDWORD,LPDWORD,LPBYTE,LPDWORD);
-LONG WINAPI RegQueryValueExW(HKEY,LPCWSTR,LPDWORD,LPDWORD,LPBYTE,LPDWORD);
-LONG WINAPI RegQueryValueW(HKEY,LPCWSTR,LPWSTR,PLONG);
-LONG WINAPI RegReplaceKeyA(HKEY,LPCSTR,LPCSTR,LPCSTR);
-LONG WINAPI RegReplaceKeyW(HKEY,LPCWSTR,LPCWSTR,LPCWSTR);
-LONG WINAPI RegRestoreKeyA(HKEY,LPCSTR,DWORD);
-LONG WINAPI RegRestoreKeyW(HKEY,LPCWSTR,DWORD);
-LONG WINAPI RegSaveKeyA(HKEY,LPCSTR,LPSECURITY_ATTRIBUTES);
-LONG WINAPI RegSaveKeyW(HKEY,LPCWSTR,LPSECURITY_ATTRIBUTES);
-LONG WINAPI RegSetKeySecurity(HKEY,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
-#if (_WIN32_WINNT >= 0x0600)
-LONG WINAPI RegSetKeyValueA(HKEY,LPCSTR,LPCSTR,DWORD,LPCVOID,DWORD);
-LONG WINAPI RegSetKeyValueW(HKEY,LPCWSTR,LPCWSTR,DWORD,LPCVOID,DWORD);
-#endif
-LONG WINAPI RegSetValueA(HKEY,LPCSTR,DWORD,LPCSTR,DWORD);
-LONG WINAPI RegSetValueExA(HKEY,LPCSTR,DWORD,DWORD,const BYTE*,DWORD);
-LONG WINAPI RegSetValueExW(HKEY,LPCWSTR,DWORD,DWORD,const BYTE*,DWORD);
-LONG WINAPI RegSetValueW(HKEY,LPCWSTR,DWORD,LPCWSTR,DWORD);
-LONG WINAPI RegUnLoadKeyA(HKEY,LPCSTR);
-LONG WINAPI RegUnLoadKeyW(HKEY,LPCWSTR);
+LONG WINAPI RegDisableReflectionKey(_In_ HKEY);
+LONG WINAPI RegEnableReflectionKey(_In_ HKEY);
+#endif
+
+LSTATUS
+WINAPI
+RegEnumKeyA(
+  _In_ HKEY hKey,
+  _In_ DWORD dwIndex,
+  _Out_writes_opt_(cchName) LPSTR lpName,
+  _In_ DWORD cchName);
+
+LSTATUS
+WINAPI
+RegEnumKeyW(
+  _In_ HKEY hKey,
+  _In_ DWORD dwIndex,
+  _Out_writes_opt_(cchName) LPWSTR lpName,
+  _In_ DWORD cchName);
+
+LSTATUS
+WINAPI
+RegEnumKeyExA(
+  _In_ HKEY hKey,
+  _In_ DWORD dwIndex,
+  _Out_writes_to_opt_(*lpcchName, *lpcchName + 1) LPSTR lpName,
+  _Inout_ LPDWORD lpcchName,
+  _Reserved_ LPDWORD lpReserved,
+  _Out_writes_to_opt_(*lpcchClass,*lpcchClass + 1) LPSTR lpClass,
+  _Inout_opt_ LPDWORD lpcchClass,
+  _Out_opt_ PFILETIME lpftLastWriteTime);
+
+LSTATUS
+WINAPI
+RegEnumKeyExW(
+  _In_ HKEY hKey,
+  _In_ DWORD dwIndex,
+  _Out_writes_to_opt_(*lpcchName, *lpcchName + 1) LPWSTR lpName,
+  _Inout_ LPDWORD lpcchName,
+  _Reserved_ LPDWORD lpReserved,
+  _Out_writes_to_opt_(*lpcchClass,*lpcchClass + 1) LPWSTR lpClass,
+  _Inout_opt_ LPDWORD lpcchClass,
+  _Out_opt_ PFILETIME lpftLastWriteTime);
+
+LSTATUS
+WINAPI
+RegEnumValueA(
+  _In_ HKEY hKey,
+  _In_ DWORD dwIndex,
+  _Out_writes_to_opt_(*lpcchValueName, *lpcchValueName + 1) LPSTR lpValueName,
+  _Inout_ LPDWORD lpcchValueName,
+  _Reserved_ LPDWORD lpReserved,
+  _Out_opt_ LPDWORD lpType,
+  _Out_writes_bytes_to_opt_(*lpcbData, *lpcbData) __out_data_source(REGISTRY) LPBYTE
lpData,
+  _Inout_opt_ LPDWORD lpcbData);
+
+LSTATUS
+WINAPI
+RegEnumValueW(
+  _In_ HKEY hKey,
+  _In_ DWORD dwIndex,
+  _Out_writes_to_opt_(*lpcchValueName, *lpcchValueName + 1) LPWSTR lpValueName,
+  _Inout_ LPDWORD lpcchValueName,
+  _Reserved_ LPDWORD lpReserved,
+  _Out_opt_ LPDWORD lpType,
+  _Out_writes_bytes_to_opt_(*lpcbData, *lpcbData) __out_data_source(REGISTRY) LPBYTE
lpData,
+  _Inout_opt_ LPDWORD lpcbData);
+
+#if (_WIN32_WINNT >= 0x0600)
+
+LSTATUS
+WINAPI
+RegGetValueA(
+  _In_ HKEY hkey,
+  _In_opt_ LPCSTR lpSubKey,
+  _In_opt_ LPCSTR lpValue,
+  _In_ DWORD dwFlags,
+  _Out_opt_ LPDWORD pdwType,
+  _When_((dwFlags & 0x7F) == RRF_RT_REG_SZ || (dwFlags & 0x7F) ==
RRF_RT_REG_EXPAND_SZ ||
+    (dwFlags & 0x7F) == (RRF_RT_REG_SZ | RRF_RT_REG_EXPAND_SZ) || *pdwType == REG_SZ
||
+    *pdwType == REG_EXPAND_SZ, _Post_z_)
+    _When_((dwFlags & 0x7F) == RRF_RT_REG_MULTI_SZ || *pdwType == REG_MULTI_SZ,
_Post_ _NullNull_terminated_)
+      _Out_writes_bytes_to_opt_(*pcbData,*pcbData) PVOID pvData,
+  _Inout_opt_ LPDWORD pcbData);
+
+LSTATUS
+WINAPI
+RegGetValueW(
+  _In_ HKEY hkey,
+  _In_opt_ LPCWSTR lpSubKey,
+  _In_opt_ LPCWSTR lpValue,
+  _In_ DWORD dwFlags,
+  _Out_opt_ LPDWORD pdwType,
+  _When_((dwFlags & 0x7F) == RRF_RT_REG_SZ || (dwFlags & 0x7F) ==
RRF_RT_REG_EXPAND_SZ ||
+    (dwFlags & 0x7F) == (RRF_RT_REG_SZ | RRF_RT_REG_EXPAND_SZ) || *pdwType == REG_SZ
||
+    *pdwType == REG_EXPAND_SZ, _Post_z_)
+    _When_((dwFlags & 0x7F) == RRF_RT_REG_MULTI_SZ || *pdwType == REG_MULTI_SZ,
_Post_ _NullNull_terminated_)
+      _Out_writes_bytes_to_opt_(*pcbData,*pcbData) PVOID pvData,
+  _Inout_opt_ LPDWORD pcbData);
+
+#endif
+
+LSTATUS WINAPI RegFlushKey(_In_ HKEY);
+
+LSTATUS
+WINAPI
+RegGetKeySecurity(
+  _In_ HKEY hKey,
+  _In_ SECURITY_INFORMATION SecurityInformation,
+  _Out_writes_bytes_opt_(*lpcbSecurityDescriptor) PSECURITY_DESCRIPTOR
pSecurityDescriptor,
+  _Inout_ LPDWORD lpcbSecurityDescriptor);
+
+LSTATUS WINAPI RegLoadKeyA(_In_ HKEY, _In_opt_ LPCSTR, _In_ LPCSTR);
+LSTATUS WINAPI RegLoadKeyW(_In_ HKEY, _In_opt_ LPCWSTR, _In_ LPCWSTR);
+
+#if (_WIN32_WINNT >= 0x0600)
+
+LSTATUS
+WINAPI
+RegLoadMUIStringA(
+  _In_ HKEY hKey,
+  _In_opt_ LPCSTR pszValue,
+  _Out_writes_bytes_opt_(cbOutBuf) LPSTR pszOutBuf,
+  _In_ DWORD cbOutBuf,
+  _Out_opt_ LPDWORD pcbData,
+  _In_ DWORD Flags,
+  _In_opt_ LPCSTR pszDirectory);
+
+LSTATUS
+WINAPI
+RegLoadMUIStringW(
+  _In_ HKEY hKey,
+  _In_opt_ LPCWSTR pszValue,
+  _Out_writes_bytes_opt_(cbOutBuf) LPWSTR pszOutBuf,
+  _In_ DWORD cbOutBuf,
+  _Out_opt_ LPDWORD pcbData,
+  _In_ DWORD Flags,
+  _In_opt_ LPCWSTR pszDirectory);
+
+#endif
+
+LSTATUS WINAPI RegNotifyChangeKeyValue(_In_ HKEY, _In_ BOOL, _In_ DWORD, _In_opt_ HANDLE,
_In_ BOOL);
+LSTATUS WINAPI RegOpenCurrentUser(_In_ REGSAM, _Out_ PHKEY);
+LSTATUS WINAPI RegOpenKeyA(_In_ HKEY, _In_opt_ LPCSTR, _Out_ PHKEY);
+LSTATUS WINAPI RegOpenKeyW(_In_ HKEY, _In_opt_ LPCWSTR, _Out_ PHKEY);
+LSTATUS WINAPI RegOpenKeyExA(_In_ HKEY, _In_opt_ LPCSTR, _In_opt_ DWORD, _In_ REGSAM,
_Out_ PHKEY);
+LSTATUS WINAPI RegOpenKeyExW(_In_ HKEY, _In_opt_ LPCWSTR, _In_opt_ DWORD, _In_ REGSAM,
_Out_ PHKEY);
+
+LSTATUS
+WINAPI
+RegQueryInfoKeyA(
+  _In_ HKEY hKey,
+  _Out_writes_to_opt_(*lpcchClass, *lpcchClass + 1) LPSTR lpClass,
+  _Inout_opt_ LPDWORD lpcchClass,
+  _Reserved_ LPDWORD lpReserved,
+  _Out_opt_ LPDWORD lpcSubKeys,
+  _Out_opt_ LPDWORD lpcbMaxSubKeyLen,
+  _Out_opt_ LPDWORD lpcbMaxClassLen,
+  _Out_opt_ LPDWORD lpcValues,
+  _Out_opt_ LPDWORD lpcbMaxValueNameLen,
+  _Out_opt_ LPDWORD lpcbMaxValueLen,
+  _Out_opt_ LPDWORD lpcbSecurityDescriptor,
+  _Out_opt_ PFILETIME lpftLastWriteTime);
+
+LSTATUS
+WINAPI
+RegQueryInfoKeyW(
+  _In_ HKEY hKey,
+  _Out_writes_to_opt_(*lpcchClass, *lpcchClass + 1) LPWSTR lpClass,
+  _Inout_opt_ LPDWORD lpcchClass,
+  _Reserved_ LPDWORD lpReserved,
+  _Out_opt_ LPDWORD lpcSubKeys,
+  _Out_opt_ LPDWORD lpcbMaxSubKeyLen,
+  _Out_opt_ LPDWORD lpcbMaxClassLen,
+  _Out_opt_ LPDWORD lpcValues,
+  _Out_opt_ LPDWORD lpcbMaxValueNameLen,
+  _Out_opt_ LPDWORD lpcbMaxValueLen,
+  _Out_opt_ LPDWORD lpcbSecurityDescriptor,
+  _Out_opt_ PFILETIME lpftLastWriteTime);
+
+LSTATUS
+WINAPI
+RegQueryMultipleValuesA(
+  _In_ HKEY hKey,
+  _Out_writes_(num_vals) PVALENTA val_list,
+  _In_ DWORD num_vals,
+  _Out_writes_bytes_to_opt_(*ldwTotsize, *ldwTotsize) __out_data_source(REGISTRY) LPSTR
lpValueBuf,
+  _Inout_opt_ LPDWORD ldwTotsize);
+
+LSTATUS
+WINAPI
+RegQueryMultipleValuesW(
+  _In_ HKEY hKey,
+  _Out_writes_(num_vals) PVALENTW val_list,
+  _In_ DWORD num_vals,
+  _Out_writes_bytes_to_opt_(*ldwTotsize, *ldwTotsize) __out_data_source(REGISTRY) LPWSTR
lpValueBuf,
+  _Inout_opt_ LPDWORD ldwTotsize);
+
+#if (_WIN32_WINNT >= 0x0600)
+LONG WINAPI RegQueryReflectionKey(_In_ HKEY, _Out_ BOOL*);
+#endif
+
+LSTATUS
+WINAPI
+RegQueryValueA(
+  _In_ HKEY hKey,
+  _In_opt_ LPCSTR lpSubKey,
+  _Out_writes_bytes_to_opt_(*lpcbData, *lpcbData) __out_data_source(REGISTRY) LPSTR
lpData,
+  _Inout_opt_ PLONG lpcbData);
+
+LSTATUS
+WINAPI
+RegQueryValueW(
+  _In_ HKEY hKey,
+  _In_opt_ LPCWSTR lpSubKey,
+  _Out_writes_bytes_to_opt_(*lpcbData, *lpcbData) __out_data_source(REGISTRY) LPWSTR
lpData,
+  _Inout_opt_ PLONG lpcbData);
+
+LSTATUS
+WINAPI
+RegQueryValueExA(
+  _In_ HKEY hKey,
+  _In_opt_ LPCSTR lpValueName,
+  _Reserved_ LPDWORD lpReserved,
+  _Out_opt_ LPDWORD lpType,
+  _Out_writes_bytes_to_opt_(*lpcbData, *lpcbData) __out_data_source(REGISTRY) LPBYTE
lpData,
+  _When_(lpData == NULL, _Out_opt_)
+    _When_(lpData != NULL, _Inout_opt_) LPDWORD lpcbData);
+
+LSTATUS
+WINAPI
+RegQueryValueExW(
+  _In_ HKEY hKey,
+  _In_opt_ LPCWSTR lpValueName,
+  _Reserved_ LPDWORD lpReserved,
+  _Out_opt_ LPDWORD lpType,
+  _Out_writes_bytes_to_opt_(*lpcbData, *lpcbData) __out_data_source(REGISTRY) LPBYTE
lpData,
+  _When_(lpData == NULL, _Out_opt_)
+    _When_(lpData != NULL, _Inout_opt_) LPDWORD lpcbData);
+
+LSTATUS WINAPI RegReplaceKeyA(_In_ HKEY, _In_opt_ LPCSTR, _In_ LPCSTR, _In_ LPCSTR);
+LSTATUS WINAPI RegReplaceKeyW(_In_ HKEY, _In_opt_ LPCWSTR, _In_ LPCWSTR, _In_ LPCWSTR);
+LSTATUS WINAPI RegRestoreKeyA(_In_ HKEY, _In_ LPCSTR, _In_ DWORD);
+LSTATUS WINAPI RegRestoreKeyW(_In_ HKEY, _In_ LPCWSTR, _In_ DWORD);
+LSTATUS WINAPI RegSaveKeyA(_In_ HKEY, _In_ LPCSTR, _In_opt_ LPSECURITY_ATTRIBUTES);
+LSTATUS WINAPI RegSaveKeyW(_In_ HKEY, _In_ LPCWSTR, _In_opt_ LPSECURITY_ATTRIBUTES);
+LSTATUS WINAPI RegSetKeySecurity(_In_ HKEY, _In_ SECURITY_INFORMATION, _In_
PSECURITY_DESCRIPTOR);
+
+#if (_WIN32_WINNT >= 0x0600)
+
+LSTATUS
+WINAPI
+RegSetKeyValueA(
+  _In_ HKEY hKey,
+  _In_opt_ LPCSTR lpSubKey,
+  _In_opt_ LPCSTR lpValueName,
+  _In_ DWORD dwType,
+  _In_reads_bytes_opt_(cbData) LPCVOID lpData,
+  _In_ DWORD cbData);
+
+LSTATUS
+WINAPI
+RegSetKeyValueW(
+  _In_ HKEY hKey,
+  _In_opt_ LPCWSTR lpSubKey,
+  _In_opt_ LPCWSTR lpValueName,
+  _In_ DWORD dwType,
+  _In_reads_bytes_opt_(cbData) LPCVOID lpData,
+  _In_ DWORD cbData);
+
+#endif
+
+LSTATUS
+WINAPI
+RegSetValueA(
+  _In_ HKEY hKey,
+  _In_opt_ LPCSTR lpSubKey,
+  _In_ DWORD dwType,
+  _In_reads_bytes_opt_(cbData) LPCSTR lpData,
+  _In_ DWORD cbData);
+
+LSTATUS
+WINAPI
+RegSetValueW(
+  _In_ HKEY hKey,
+  _In_opt_ LPCWSTR lpSubKey,
+  _In_ DWORD dwType,
+  _In_reads_bytes_opt_(cbData) LPCWSTR lpData,
+  _In_ DWORD cbData);
+
+LSTATUS
+WINAPI
+RegSetValueExA(
+  _In_ HKEY hKey,
+  _In_opt_ LPCSTR lpValueName,
+  _Reserved_ DWORD Reserved,
+  _In_ DWORD dwType,
+  _In_reads_bytes_opt_(cbData) const BYTE *lpData,
+  _In_ DWORD cbData);
+
+LSTATUS
+WINAPI
+RegSetValueExW(
+  _In_ HKEY hKey,
+  _In_opt_ LPCWSTR lpValueName,
+  _Reserved_ DWORD Reserved,
+  _In_ DWORD dwType,
+  _In_reads_bytes_opt_(cbData) const BYTE *lpData,
+  _In_ DWORD cbData);
+
+LSTATUS WINAPI RegUnLoadKeyA(_In_ HKEY, _In_opt_ LPCSTR);
+LSTATUS WINAPI RegUnLoadKeyW(_In_ HKEY, _In_opt_ LPCWSTR);
 
 #ifdef UNICODE
 typedef VALENTW VALENT,*PVALENT;