1 /**
2 * Windows API header module
3 *
4 * Translated from MinGW Windows headers
5 *
6 * Authors: Stewart Gordon
7 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
8 * Source: $(DRUNTIMESRC core/sys/windows/_winreg.d)
9 */
10 module core.sys.windows.winreg;
version(Windows)11 version (Windows):
12 @system:
13
14 version (ANSI) {} else version = Unicode;
15 pragma(lib, "advapi32");
16
17 import core.sys.windows.w32api, core.sys.windows.winbase, core.sys.windows.windef;
18
19 enum : HKEY { // for some reason, DMD errors if I don't give all the values explicitly
20 HKEY_CLASSES_ROOT = cast(HKEY) 0x80000000,
21 HKEY_CURRENT_USER = cast(HKEY) 0x80000001,
22 HKEY_LOCAL_MACHINE = cast(HKEY) 0x80000002,
23 HKEY_USERS = cast(HKEY) 0x80000003,
24 HKEY_PERFORMANCE_DATA = cast(HKEY) 0x80000004,
25 HKEY_CURRENT_CONFIG = cast(HKEY) 0x80000005,
26 HKEY_DYN_DATA = cast(HKEY) 0x80000006,
27 HKEY_PERFORMANCE_TEXT = cast(HKEY) 0x80000050,
28 HKEY_PERFORMANCE_NLSTEXT = cast(HKEY) 0x80000060,
29 }
30
31 //enum : DWORD {
32 // REG_OPTION_NON_VOLATILE,
33 // REG_OPTION_VOLATILE
34 //}
35
36 enum : DWORD {
37 REG_CREATED_NEW_KEY = 1,
38 REG_OPENED_EXISTING_KEY
39 }
40
41 enum : DWORD {
42 REG_NONE = 0,
43 REG_SZ,
44 REG_EXPAND_SZ,
45 REG_BINARY,
46 REG_DWORD_LITTLE_ENDIAN,
47 REG_DWORD = REG_DWORD_LITTLE_ENDIAN,
48 REG_DWORD_BIG_ENDIAN,
49 REG_LINK,
50 REG_MULTI_SZ,
51 REG_RESOURCE_LIST,
52 REG_FULL_RESOURCE_DESCRIPTOR,
53 REG_RESOURCE_REQUIREMENTS_LIST,
54 REG_QWORD_LITTLE_ENDIAN,
55 REG_QWORD = REG_QWORD_LITTLE_ENDIAN
56 }
57
58 enum DWORD
59 REG_NOTIFY_CHANGE_NAME = 1,
60 REG_NOTIFY_CHANGE_ATTRIBUTES = 2,
61 REG_NOTIFY_CHANGE_LAST_SET = 4,
62 REG_NOTIFY_CHANGE_SECURITY = 8;
63
64 alias ACCESS_MASK REGSAM;
65
66 struct VALENTA {
67 LPSTR ve_valuename;
68 DWORD ve_valuelen;
69 DWORD_PTR ve_valueptr;
70 DWORD ve_type;
71 }
72 alias VALENTA* PVALENTA;
73
74 struct VALENTW {
75 LPWSTR ve_valuename;
76 DWORD ve_valuelen;
77 DWORD_PTR ve_valueptr;
78 DWORD ve_type;
79 }
80 alias VALENTW* PVALENTW;
81
82 // RRF - Registry Routine Flags (for RegGetValue)
83 static if (_WIN32_WINNT >= 0x600) {
84 enum : DWORD {
85 RRF_RT_REG_NONE = 0x00000001,
86 RRF_RT_REG_SZ = 0x00000002,
87 RRF_RT_REG_EXPAND_SZ = 0x00000004,
88 RRF_RT_REG_BINARY = 0x00000008,
89 RRF_RT_REG_DWORD = 0x00000010,
90 RRF_RT_REG_MULTI_SZ = 0x00000020,
91 RRF_RT_REG_QWORD = 0x00000040,
92 RRF_RT_DWORD = RRF_RT_REG_BINARY | RRF_RT_REG_DWORD,
93 RRF_RT_QWORD = RRF_RT_REG_BINARY | RRF_RT_REG_QWORD,
94 RRF_RT_ANY = 0x0000FFFF,
95 RRF_NOEXPAND = 0x10000000,
96 RRF_ZEROONFAILURE = 0x20000000
97 }
98 }
99
100 extern (Windows) nothrow @nogc {
101 LONG RegCloseKey(const scope HKEY);
102 LONG RegConnectRegistryA(LPCSTR, HKEY, PHKEY);
103 LONG RegConnectRegistryW(LPCWSTR, HKEY, PHKEY);
104 LONG RegCreateKeyExA(const scope HKEY, LPCSTR, DWORD, LPSTR, DWORD, REGSAM,
105 LPSECURITY_ATTRIBUTES, PHKEY, PDWORD);
106 LONG RegCreateKeyExW(const scope HKEY, LPCWSTR, DWORD, LPWSTR, DWORD, REGSAM,
107 LPSECURITY_ATTRIBUTES, PHKEY, PDWORD);
108 LONG RegDeleteKeyA(const scope HKEY, LPCSTR);
109 LONG RegDeleteKeyW(const scope HKEY, LPCWSTR);
110 LONG RegDeleteValueA(const scope HKEY, LPCSTR);
111 LONG RegDeleteValueW(const scope HKEY, LPCWSTR);
112 LONG RegEnumKeyExA(const scope HKEY, DWORD, LPSTR, PDWORD, PDWORD, LPSTR, PDWORD,
113 PFILETIME);
114 LONG RegEnumKeyExW(const scope HKEY, DWORD, LPWSTR, PDWORD, PDWORD, LPWSTR, PDWORD,
115 PFILETIME);
116 LONG RegEnumValueA(const scope HKEY, DWORD, LPSTR, PDWORD, PDWORD, PDWORD, LPBYTE,
117 PDWORD);
118 LONG RegEnumValueW(const scope HKEY, DWORD, LPWSTR, PDWORD, PDWORD, PDWORD, LPBYTE,
119 PDWORD);
120 LONG RegFlushKey(const scope HKEY);
121 LONG RegLoadKeyA(const scope HKEY, LPCSTR, LPCSTR);
122 LONG RegLoadKeyW(const scope HKEY, LPCWSTR, LPCWSTR);
123 LONG RegOpenKeyExA(const scope HKEY, LPCSTR, DWORD, REGSAM, PHKEY);
124 LONG RegOpenKeyExW(const scope HKEY, LPCWSTR, DWORD, REGSAM, PHKEY);
125 LONG RegQueryInfoKeyA(const scope HKEY, LPSTR, PDWORD, PDWORD, PDWORD, PDWORD,
126 PDWORD, PDWORD, PDWORD, PDWORD, PDWORD, PFILETIME);
127 LONG RegQueryInfoKeyW(const scope HKEY, LPWSTR, PDWORD, PDWORD, PDWORD, PDWORD,
128 PDWORD, PDWORD, PDWORD, PDWORD, PDWORD, PFILETIME);
129 LONG RegQueryMultipleValuesA(const scope HKEY, PVALENTA, DWORD, LPSTR, LPDWORD);
130 LONG RegQueryMultipleValuesW(const scope HKEY, PVALENTW, DWORD, LPWSTR, LPDWORD);
131 LONG RegQueryValueExA(const scope HKEY, LPCSTR, LPDWORD, LPDWORD, /*LPBYTE*/LPVOID, LPDWORD);
132 LONG RegQueryValueExW(const scope HKEY, LPCWSTR, LPDWORD, LPDWORD, /*LPBYTE*/LPVOID, LPDWORD);
133 LONG RegReplaceKeyA(const scope HKEY, LPCSTR, LPCSTR, LPCSTR);
134 LONG RegReplaceKeyW(const scope HKEY, LPCWSTR, LPCWSTR, LPCWSTR);
135 LONG RegSaveKeyA(const scope HKEY, LPCSTR, LPSECURITY_ATTRIBUTES);
136 LONG RegSaveKeyW(const scope HKEY, LPCWSTR, LPSECURITY_ATTRIBUTES);
137 LONG RegSetKeySecurity(const scope HKEY, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
138 LONG RegSetValueExA(const scope HKEY, LPCSTR, DWORD, DWORD, const(BYTE)*, DWORD);
139 LONG RegSetValueExW(const scope HKEY, LPCWSTR, DWORD, DWORD, const(BYTE)*, DWORD);
140 LONG RegUnLoadKeyA(const scope HKEY, LPCSTR);
141 LONG RegUnLoadKeyW(const scope HKEY, LPCWSTR);
142 LONG RegNotifyChangeKeyValue(const scope HKEY, BOOL, DWORD, HANDLE, BOOL);
143
144 BOOL AbortSystemShutdownA(LPCSTR);
145 BOOL AbortSystemShutdownW(LPCWSTR);
146 BOOL InitiateSystemShutdownA(LPSTR, LPSTR, DWORD, BOOL, BOOL);
147 BOOL InitiateSystemShutdownW(LPWSTR, LPWSTR, DWORD, BOOL, BOOL);
148 LONG RegGetKeySecurity(const scope HKEY, SECURITY_INFORMATION,
149 PSECURITY_DESCRIPTOR, PDWORD);
150 LONG RegRestoreKeyA(const scope HKEY, LPCSTR, DWORD);
151 LONG RegRestoreKeyW(const scope HKEY, LPCWSTR, DWORD);
152 LONG RegSetKeySecurity(const scope HKEY, SECURITY_INFORMATION,
153 PSECURITY_DESCRIPTOR);
154
155 static if (_WIN32_WINNT >= 0x500) {
156 LONG RegDisablePredefinedCache();
157 LONG RegOpenCurrentUser(REGSAM, PHKEY);
158 LONG RegOpenUserClassesRoot(HANDLE, DWORD, REGSAM, PHKEY);
159 }
160
161 static if (_WIN32_WINNT >= 0x501) {
162 LONG RegSaveKeyExA(const scope HKEY, LPCSTR, LPSECURITY_ATTRIBUTES, DWORD);
163 LONG RegSaveKeyExW(const scope HKEY, LPCWSTR, LPSECURITY_ATTRIBUTES, DWORD);
164 }
165
166 static if (_WIN32_WINNT >= 0x600) {
167 LONG RegGetValueA(const scope HKEY hkey, LPCSTR lpSubKey, LPCSTR lpValue,
168 DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData);
169 LONG RegGetValueW(const scope HKEY hkey, LPCWSTR lpSubKey, LPCWSTR lpValue,
170 DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData);
171 }
172
173 //deprecated {
174 LONG RegCreateKeyA(const scope HKEY, LPCSTR, PHKEY);
175 LONG RegCreateKeyW(const scope HKEY, LPCWSTR, PHKEY);
176 LONG RegEnumKeyA(const scope HKEY, DWORD, LPSTR, DWORD);
177 LONG RegEnumKeyW(const scope HKEY, DWORD, LPWSTR, DWORD);
178 LONG RegOpenKeyA(const scope HKEY, LPCSTR, PHKEY);
179 LONG RegOpenKeyW(const scope HKEY, LPCWSTR, PHKEY);
180 LONG RegQueryValueA(const scope HKEY, LPCSTR, LPSTR, PLONG);
181 LONG RegQueryValueW(const scope HKEY, LPCWSTR, LPWSTR, PLONG);
182 LONG RegSetValueA(const scope HKEY, LPCSTR, DWORD, LPCSTR, DWORD);
183 LONG RegSetValueW(const scope HKEY, LPCWSTR, DWORD, LPCWSTR, DWORD);
184 //}
185 }
186
187 version (Unicode) {
188 alias VALENTW VALENT;
189 alias RegConnectRegistryW RegConnectRegistry;
190 alias RegCreateKeyExW RegCreateKeyEx;
191 alias RegDeleteKeyW RegDeleteKey;
192 alias RegDeleteValueW RegDeleteValue;
193 alias RegEnumKeyExW RegEnumKeyEx;
194 alias RegEnumValueW RegEnumValue;
195 alias RegLoadKeyW RegLoadKey;
196 alias RegOpenKeyExW RegOpenKeyEx;
197 alias RegQueryInfoKeyW RegQueryInfoKey;
198 alias RegQueryMultipleValuesW RegQueryMultipleValues;
199 alias RegQueryValueExW RegQueryValueEx;
200 alias RegReplaceKeyW RegReplaceKey;
201 alias RegSaveKeyW RegSaveKey;
202 alias RegSetValueExW RegSetValueEx;
203 alias RegUnLoadKeyW RegUnLoadKey;
204
205 alias AbortSystemShutdownW AbortSystemShutdown;
206 alias InitiateSystemShutdownW InitiateSystemShutdown;
207 alias RegRestoreKeyW RegRestoreKey;
208 static if (_WIN32_WINNT >= 0x501) {
209 alias RegSaveKeyExA RegSaveKeyEx;
210 }
211 static if (_WIN32_WINNT >= 0x600) {
212 alias RegGetValueW RegGetValue;
213 }
214 //deprecated {
215 alias RegCreateKeyW RegCreateKey;
216 alias RegEnumKeyW RegEnumKey;
217 alias RegOpenKeyW RegOpenKey;
218 alias RegQueryValueW RegQueryValue;
219 alias RegSetValueW RegSetValue;
220 //}
221 } else {
222 alias VALENTA VALENT;
223 alias RegConnectRegistryA RegConnectRegistry;
224 alias RegCreateKeyExA RegCreateKeyEx;
225 alias RegDeleteKeyA RegDeleteKey;
226 alias RegDeleteValueA RegDeleteValue;
227 alias RegEnumKeyExA RegEnumKeyEx;
228 alias RegEnumValueA RegEnumValue;
229 alias RegLoadKeyA RegLoadKey;
230 alias RegOpenKeyExA RegOpenKeyEx;
231 alias RegQueryInfoKeyA RegQueryInfoKey;
232 alias RegQueryMultipleValuesA RegQueryMultipleValues;
233 alias RegQueryValueExA RegQueryValueEx;
234 alias RegReplaceKeyA RegReplaceKey;
235 alias RegSaveKeyA RegSaveKey;
236 alias RegSetValueExA RegSetValueEx;
237 alias RegUnLoadKeyA RegUnLoadKey;
238 alias AbortSystemShutdownA AbortSystemShutdown;
239 alias InitiateSystemShutdownA InitiateSystemShutdown;
240 alias RegRestoreKeyW RegRestoreKey;
241 static if (_WIN32_WINNT >= 0x501) {
242 alias RegSaveKeyExA RegSaveKeyEx;
243 }
244 static if (_WIN32_WINNT >= 0x600) {
245 alias RegGetValueA RegGetValue;
246 }
247 //deprecated {
248 alias RegCreateKeyA RegCreateKey;
249 alias RegEnumKeyA RegEnumKey;
250 alias RegOpenKeyA RegOpenKey;
251 alias RegQueryValueA RegQueryValue;
252 alias RegSetValueA RegSetValue;
253 //}
254 }
255
256 alias VALENT* PVALENT;
257