1 /**
2 * Windows API header module
3 *
4 * Translated from MinGW API for MS-Windows 3.10
5 *
6 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
7 * Source: $(DRUNTIMESRC src/core/sys/windows/_winbase.d)
8 */
9 module core.sys.windows.winbase;
version(Windows)10 version (Windows):
11
12 version (ANSI) {} else version = Unicode;
13 pragma(lib, "kernel32");
14
15 /**
16 Translation Notes:
17 The following macros are obsolete, and have no effect.
18
19 LockSegment(w), MakeProcInstance(p, i), UnlockResource(h), UnlockSegment(w)
20 FreeModule(m), FreeProcInstance(p), GetFreeSpace(w), DefineHandleTable(w)
21 SetSwapAreaSize(w), LimitEmsPages(n), Yield()
22
23 // These are not required for DMD.
24
25 //FIXME:
26 // #ifndef UNDER_CE
27 int WinMain(HINSTANCE, HINSTANCE, LPSTR, int);
28 #else
29 int WinMain(HINSTANCE, HINSTANCE, LPWSTR, int);
30 #endif
31 int wWinMain(HINSTANCE, HINSTANCE, LPWSTR, int);
32
33 */
34
35 import core.sys.windows.windef, core.sys.windows.winver;
36 private import core.sys.windows.basetyps, core.sys.windows.w32api, core.sys.windows.winnt;
37
38 // FIXME:
39 //alias void va_list;
40 import core.stdc.stdarg : va_list;
41
42
43 // COMMPROP structure, used by GetCommProperties()
44 // -----------------------------------------------
45
46 // Communications provider type
47 enum : DWORD {
48 PST_UNSPECIFIED,
49 PST_RS232,
50 PST_PARALLELPORT,
51 PST_RS422,
52 PST_RS423,
53 PST_RS449,
54 PST_MODEM, // = 6
55 PST_FAX = 0x0021,
56 PST_SCANNER = 0x0022,
57 PST_NETWORK_BRIDGE = 0x0100,
58 PST_LAT = 0x0101,
59 PST_TCPIP_TELNET = 0x0102,
60 PST_X25 = 0x0103
61 }
62
63 // Max baud rate
64 enum : DWORD {
65 BAUD_075 = 0x00000001,
66 BAUD_110 = 0x00000002,
67 BAUD_134_5 = 0x00000004,
68 BAUD_150 = 0x00000008,
69 BAUD_300 = 0x00000010,
70 BAUD_600 = 0x00000020,
71 BAUD_1200 = 0x00000040,
72 BAUD_1800 = 0x00000080,
73 BAUD_2400 = 0x00000100,
74 BAUD_4800 = 0x00000200,
75 BAUD_7200 = 0x00000400,
76 BAUD_9600 = 0x00000800,
77 BAUD_14400 = 0x00001000,
78 BAUD_19200 = 0x00002000,
79 BAUD_38400 = 0x00004000,
80 BAUD_56K = 0x00008000,
81 BAUD_128K = 0x00010000,
82 BAUD_115200 = 0x00020000,
83 BAUD_57600 = 0x00040000,
84 BAUD_USER = 0x10000000
85 }
86
87 // Comm capabilities
88 enum : DWORD {
89 PCF_DTRDSR = 0x0001,
90 PCF_RTSCTS = 0x0002,
91 PCF_RLSD = 0x0004,
92 PCF_PARITY_CHECK = 0x0008,
93 PCF_XONXOFF = 0x0010,
94 PCF_SETXCHAR = 0x0020,
95 PCF_TOTALTIMEOUTS = 0x0040,
96 PCF_INTTIMEOUTS = 0x0080,
97 PCF_SPECIALCHARS = 0x0100,
98 PCF_16BITMODE = 0x0200
99 }
100
101 enum : DWORD {
102 SP_PARITY = 1,
103 SP_BAUD = 2,
104 SP_DATABITS = 4,
105 SP_STOPBITS = 8,
106 SP_HANDSHAKING = 16,
107 SP_PARITY_CHECK = 32,
108 SP_RLSD = 64
109 }
110
111 enum : DWORD {
112 DATABITS_5 = 1,
113 DATABITS_6 = 2,
114 DATABITS_7 = 4,
115 DATABITS_8 = 8,
116 DATABITS_16 = 16,
117 DATABITS_16X = 32
118 }
119
120 enum : WORD {
121 STOPBITS_10 = 0x0001,
122 STOPBITS_15 = 0x0002,
123 STOPBITS_20 = 0x0004,
124 PARITY_NONE = 0x0100,
125 PARITY_ODD = 0x0200,
126 PARITY_EVEN = 0x0400,
127 PARITY_MARK = 0x0800,
128 PARITY_SPACE = 0x1000
129 }
130
131 // used by dwServiceMask
132 enum SP_SERIALCOMM = 1;
133
134 struct COMMPROP {
135 WORD wPacketLength;
136 WORD wPacketVersion;
137 DWORD dwServiceMask;
138 DWORD dwReserved1;
139 DWORD dwMaxTxQueue;
140 DWORD dwMaxRxQueue;
141 DWORD dwMaxBaud;
142 DWORD dwProvSubType;
143 DWORD dwProvCapabilities;
144 DWORD dwSettableParams;
145 DWORD dwSettableBaud;
146 WORD wSettableData;
147 WORD wSettableStopParity;
148 DWORD dwCurrentTxQueue;
149 DWORD dwCurrentRxQueue;
150 DWORD dwProvSpec1;
151 DWORD dwProvSpec2;
152 WCHAR _wcProvChar = 0;
153
154 WCHAR* wcProvChar() return { return &_wcProvChar; }
155 }
156 alias COMMPROP* LPCOMMPROP;
157
158 // ----------
159
160 // for DEBUG_EVENT
161 enum : DWORD {
162 EXCEPTION_DEBUG_EVENT = 1,
163 CREATE_THREAD_DEBUG_EVENT,
164 CREATE_PROCESS_DEBUG_EVENT,
165 EXIT_THREAD_DEBUG_EVENT,
166 EXIT_PROCESS_DEBUG_EVENT,
167 LOAD_DLL_DEBUG_EVENT,
168 UNLOAD_DLL_DEBUG_EVENT,
169 OUTPUT_DEBUG_STRING_EVENT,
170 RIP_EVENT
171 }
172
173 enum HFILE HFILE_ERROR = cast(HFILE) (-1);
174
175 // for SetFilePointer()
176 enum : DWORD {
177 FILE_BEGIN = 0,
178 FILE_CURRENT = 1,
179 FILE_END = 2
180 }
181 enum DWORD INVALID_SET_FILE_POINTER = -1;
182
183
184 // for OpenFile()
185 deprecated enum : UINT {
186 OF_READ = 0,
187 OF_WRITE = 0x0001,
188 OF_READWRITE = 0x0002,
189 OF_SHARE_COMPAT = 0,
190 OF_SHARE_EXCLUSIVE = 0x0010,
191 OF_SHARE_DENY_WRITE = 0x0020,
192 OF_SHARE_DENY_READ = 0x0030,
193 OF_SHARE_DENY_NONE = 0x0040,
194 OF_PARSE = 0x0100,
195 OF_DELETE = 0x0200,
196 OF_VERIFY = 0x0400,
197 OF_CANCEL = 0x0800,
198 OF_CREATE = 0x1000,
199 OF_PROMPT = 0x2000,
200 OF_EXIST = 0x4000,
201 OF_REOPEN = 0x8000
202 }
203
204 enum : DWORD {
205 NMPWAIT_NOWAIT = 1,
206 NMPWAIT_WAIT_FOREVER = -1,
207 NMPWAIT_USE_DEFAULT_WAIT = 0
208 }
209
210 // for ClearCommError()
211 enum DWORD
212 CE_RXOVER = 0x0001,
213 CE_OVERRUN = 0x0002,
214 CE_RXPARITY = 0x0004,
215 CE_FRAME = 0x0008,
216 CE_BREAK = 0x0010,
217 CE_TXFULL = 0x0100,
218 CE_PTO = 0x0200,
219 CE_IOE = 0x0400,
220 CE_DNS = 0x0800,
221 CE_OOP = 0x1000,
222 CE_MODE = 0x8000;
223
224 // for CopyProgressRoutine callback.
225 enum : DWORD {
226 PROGRESS_CONTINUE = 0,
227 PROGRESS_CANCEL = 1,
228 PROGRESS_STOP = 2,
229 PROGRESS_QUIET = 3
230 }
231
232 enum : DWORD {
233 CALLBACK_CHUNK_FINISHED = 0,
234 CALLBACK_STREAM_SWITCH = 1
235 }
236
237 // CopyFileEx()
238 enum : DWORD {
239 COPY_FILE_FAIL_IF_EXISTS = 1,
240 COPY_FILE_RESTARTABLE = 2
241 }
242
243 enum : DWORD {
244 FILE_MAP_COPY = 1,
245 FILE_MAP_WRITE = 2,
246 FILE_MAP_READ = 4,
247 FILE_MAP_ALL_ACCESS = 0x000F001F
248 }
249
250 enum : DWORD {
251 MUTEX_ALL_ACCESS = 0x001f0001,
252 MUTEX_MODIFY_STATE = 0x00000001,
253 SEMAPHORE_ALL_ACCESS = 0x001f0003,
254 SEMAPHORE_MODIFY_STATE = 0x00000002,
255 EVENT_ALL_ACCESS = 0x001f0003,
256 EVENT_MODIFY_STATE = 0x00000002
257 }
258
259 // CreateNamedPipe()
260 enum : DWORD {
261 PIPE_ACCESS_INBOUND = 1,
262 PIPE_ACCESS_OUTBOUND = 2,
263 PIPE_ACCESS_DUPLEX = 3
264 }
265
266 enum DWORD
267 PIPE_TYPE_BYTE = 0,
268 PIPE_TYPE_MESSAGE = 4,
269 PIPE_READMODE_BYTE = 0,
270 PIPE_READMODE_MESSAGE = 2,
271 PIPE_WAIT = 0,
272 PIPE_NOWAIT = 1;
273
274 // GetNamedPipeInfo()
275 enum DWORD
276 PIPE_CLIENT_END = 0,
277 PIPE_SERVER_END = 1;
278
279 enum DWORD PIPE_UNLIMITED_INSTANCES = 255;
280
281 // dwCreationFlags for CreateProcess() and CreateProcessAsUser()
282 enum : DWORD {
283 DEBUG_PROCESS = 0x00000001,
284 DEBUG_ONLY_THIS_PROCESS = 0x00000002,
285 CREATE_SUSPENDED = 0x00000004,
286 DETACHED_PROCESS = 0x00000008,
287 CREATE_NEW_CONSOLE = 0x00000010,
288 NORMAL_PRIORITY_CLASS = 0x00000020,
289 IDLE_PRIORITY_CLASS = 0x00000040,
290 HIGH_PRIORITY_CLASS = 0x00000080,
291 REALTIME_PRIORITY_CLASS = 0x00000100,
292 CREATE_NEW_PROCESS_GROUP = 0x00000200,
293 CREATE_UNICODE_ENVIRONMENT = 0x00000400,
294 CREATE_SEPARATE_WOW_VDM = 0x00000800,
295 CREATE_SHARED_WOW_VDM = 0x00001000,
296 CREATE_FORCEDOS = 0x00002000,
297 BELOW_NORMAL_PRIORITY_CLASS = 0x00004000,
298 ABOVE_NORMAL_PRIORITY_CLASS = 0x00008000,
299 CREATE_BREAKAWAY_FROM_JOB = 0x01000000,
300 CREATE_WITH_USERPROFILE = 0x02000000,
301 CREATE_DEFAULT_ERROR_MODE = 0x04000000,
302 CREATE_NO_WINDOW = 0x08000000,
303 PROFILE_USER = 0x10000000,
304 PROFILE_KERNEL = 0x20000000,
305 PROFILE_SERVER = 0x40000000
306 }
307
308 enum DWORD CONSOLE_TEXTMODE_BUFFER = 1;
309
310 // CreateFile()
311 enum : DWORD {
312 CREATE_NEW = 1,
313 CREATE_ALWAYS,
314 OPEN_EXISTING,
315 OPEN_ALWAYS,
316 TRUNCATE_EXISTING
317 }
318
319 // CreateFile()
320 enum DWORD
321 FILE_FLAG_WRITE_THROUGH = 0x80000000,
322 FILE_FLAG_OVERLAPPED = 0x40000000,
323 FILE_FLAG_NO_BUFFERING = 0x20000000,
324 FILE_FLAG_RANDOM_ACCESS = 0x10000000,
325 FILE_FLAG_SEQUENTIAL_SCAN = 0x08000000,
326 FILE_FLAG_DELETE_ON_CLOSE = 0x04000000,
327 FILE_FLAG_BACKUP_SEMANTICS = 0x02000000,
328 FILE_FLAG_POSIX_SEMANTICS = 0x01000000,
329 FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000,
330 FILE_FLAG_OPEN_NO_RECALL = 0x00100000;
331
332 static if (_WIN32_WINNT >= 0x500) {
333 enum DWORD FILE_FLAG_FIRST_PIPE_INSTANCE = 0x00080000;
334 }
335
336 // for CreateFile()
337 enum DWORD
338 SECURITY_ANONYMOUS = SECURITY_IMPERSONATION_LEVEL.SecurityAnonymous<<16,
339 SECURITY_IDENTIFICATION = SECURITY_IMPERSONATION_LEVEL.SecurityIdentification<<16,
340 SECURITY_IMPERSONATION = SECURITY_IMPERSONATION_LEVEL.SecurityImpersonation<<16,
341 SECURITY_DELEGATION = SECURITY_IMPERSONATION_LEVEL.SecurityDelegation<<16,
342 SECURITY_CONTEXT_TRACKING = 0x00040000,
343 SECURITY_EFFECTIVE_ONLY = 0x00080000,
344 SECURITY_SQOS_PRESENT = 0x00100000,
345 SECURITY_VALID_SQOS_FLAGS = 0x001F0000;
346
347
348 // Thread exit code
349 enum DWORD STILL_ACTIVE = 0x103;
350
351 /* ??? The only documentation of this seems to be about Windows CE and to
352 * state what _doesn't_ support it.
353 */
354 enum DWORD FIND_FIRST_EX_CASE_SENSITIVE = 1;
355
356 // GetBinaryType()
357 enum : DWORD {
358 SCS_32BIT_BINARY = 0,
359 SCS_DOS_BINARY,
360 SCS_WOW_BINARY,
361 SCS_PIF_BINARY,
362 SCS_POSIX_BINARY,
363 SCS_OS216_BINARY
364 }
365
366 enum size_t
367 MAX_COMPUTERNAME_LENGTH = 15,
368 HW_PROFILE_GUIDLEN = 39,
369 MAX_PROFILE_LEN = 80;
370
371 // HW_PROFILE_INFO
372 enum DWORD
373 DOCKINFO_UNDOCKED = 1,
374 DOCKINFO_DOCKED = 2,
375 DOCKINFO_USER_SUPPLIED = 4,
376 DOCKINFO_USER_UNDOCKED = DOCKINFO_USER_SUPPLIED | DOCKINFO_UNDOCKED,
377 DOCKINFO_USER_DOCKED = DOCKINFO_USER_SUPPLIED | DOCKINFO_DOCKED;
378
379 // DriveType(), RealDriveType()
380 enum : int {
381 DRIVE_UNKNOWN = 0,
382 DRIVE_NO_ROOT_DIR,
383 DRIVE_REMOVABLE,
384 DRIVE_FIXED,
385 DRIVE_REMOTE,
386 DRIVE_CDROM,
387 DRIVE_RAMDISK
388 }
389
390 // GetFileType()
391 enum : DWORD {
392 FILE_TYPE_UNKNOWN = 0,
393 FILE_TYPE_DISK,
394 FILE_TYPE_CHAR,
395 FILE_TYPE_PIPE,
396 FILE_TYPE_REMOTE = 0x8000
397 }
398
399 // Get/SetHandleInformation()
400 enum DWORD
401 HANDLE_FLAG_INHERIT = 0x01,
402 HANDLE_FLAG_PROTECT_FROM_CLOSE = 0x02;
403
404 enum : DWORD {
405 STD_INPUT_HANDLE = 0xFFFFFFF6,
406 STD_OUTPUT_HANDLE = 0xFFFFFFF5,
407 STD_ERROR_HANDLE = 0xFFFFFFF4
408 }
409
410 enum HANDLE INVALID_HANDLE_VALUE = cast(HANDLE) (-1);
411
412 enum : DWORD {
413 GET_TAPE_MEDIA_INFORMATION = 0,
414 GET_TAPE_DRIVE_INFORMATION = 1
415 }
416
417 enum : DWORD {
418 SET_TAPE_MEDIA_INFORMATION = 0,
419 SET_TAPE_DRIVE_INFORMATION = 1
420 }
421
422 // SetThreadPriority()/GetThreadPriority()
423 enum : int {
424 THREAD_PRIORITY_IDLE = -15,
425 THREAD_PRIORITY_LOWEST = -2,
426 THREAD_PRIORITY_BELOW_NORMAL = -1,
427 THREAD_PRIORITY_NORMAL = 0,
428 THREAD_PRIORITY_ABOVE_NORMAL = 1,
429 THREAD_PRIORITY_HIGHEST = 2,
430 THREAD_PRIORITY_TIME_CRITICAL = 15,
431 THREAD_PRIORITY_ERROR_RETURN = 2147483647
432 }
433
434 enum : DWORD {
435 TIME_ZONE_ID_UNKNOWN,
436 TIME_ZONE_ID_STANDARD,
437 TIME_ZONE_ID_DAYLIGHT,
438 TIME_ZONE_ID_INVALID = 0xFFFFFFFF
439 }
440
441 enum DWORD
442 FS_CASE_SENSITIVE = 1,
443 FS_CASE_IS_PRESERVED = 2,
444 FS_UNICODE_STORED_ON_DISK = 4,
445 FS_PERSISTENT_ACLS = 8,
446 FS_FILE_COMPRESSION = 16,
447 FS_VOL_IS_COMPRESSED = 32768;
448
449 // Flags for GlobalAlloc
450 enum UINT
451 GMEM_FIXED = 0,
452 GMEM_MOVEABLE = 0x0002,
453 GMEM_ZEROINIT = 0x0040,
454 GPTR = 0x0040,
455 GHND = 0x0042,
456 GMEM_MODIFY = 0x0080, // used only for GlobalRealloc
457 GMEM_VALID_FLAGS = 0x7F72;
458
459 /+ // Obselete flags (Win16 only)
460 GMEM_NOCOMPACT=16;
461 GMEM_NODISCARD=32;
462 GMEM_DISCARDABLE=256;
463 GMEM_NOT_BANKED=4096;
464 GMEM_LOWER=4096;
465 GMEM_SHARE=8192;
466 GMEM_DDESHARE=8192;
467
468 GMEM_LOCKCOUNT=255;
469
470 // for GlobalFlags()
471 GMEM_DISCARDED = 16384;
472 GMEM_INVALID_HANDLE = 32768;
473
474 GMEM_NOTIFY = 16384;
475 +/
476
477 enum UINT
478 LMEM_FIXED = 0,
479 LMEM_MOVEABLE = 0x0002,
480 LMEM_NONZEROLPTR = 0,
481 NONZEROLPTR = 0,
482 LMEM_NONZEROLHND = 0x0002,
483 NONZEROLHND = 0x0002,
484 LMEM_DISCARDABLE = 0x0F00,
485 LMEM_NOCOMPACT = 0x0010,
486 LMEM_NODISCARD = 0x0020,
487 LMEM_ZEROINIT = 0x0040,
488 LPTR = 0x0040,
489 LHND = 0x0042,
490 LMEM_MODIFY = 0x0080,
491 LMEM_LOCKCOUNT = 0x00FF,
492 LMEM_DISCARDED = 0x4000,
493 LMEM_INVALID_HANDLE = 0x8000;
494
495
496
497 // used in EXCEPTION_RECORD
498 enum : DWORD {
499 STATUS_WAIT_0 = 0,
500 STATUS_ABANDONED_WAIT_0 = 0x00000080,
501 STATUS_USER_APC = 0x000000C0,
502 STATUS_TIMEOUT = 0x00000102,
503 STATUS_PENDING = 0x00000103,
504
505 STATUS_SEGMENT_NOTIFICATION = 0x40000005,
506 STATUS_GUARD_PAGE_VIOLATION = 0x80000001,
507 STATUS_DATATYPE_MISALIGNMENT = 0x80000002,
508 STATUS_BREAKPOINT = 0x80000003,
509 STATUS_SINGLE_STEP = 0x80000004,
510
511 STATUS_ACCESS_VIOLATION = 0xC0000005,
512 STATUS_IN_PAGE_ERROR = 0xC0000006,
513 STATUS_INVALID_HANDLE = 0xC0000008,
514
515 STATUS_NO_MEMORY = 0xC0000017,
516 STATUS_ILLEGAL_INSTRUCTION = 0xC000001D,
517 STATUS_NONCONTINUABLE_EXCEPTION = 0xC0000025,
518 STATUS_INVALID_DISPOSITION = 0xC0000026,
519 STATUS_ARRAY_BOUNDS_EXCEEDED = 0xC000008C,
520 STATUS_FLOAT_DENORMAL_OPERAND = 0xC000008D,
521 STATUS_FLOAT_DIVIDE_BY_ZERO = 0xC000008E,
522 STATUS_FLOAT_INEXACT_RESULT = 0xC000008F,
523 STATUS_FLOAT_INVALID_OPERATION = 0xC0000090,
524 STATUS_FLOAT_OVERFLOW = 0xC0000091,
525 STATUS_FLOAT_STACK_CHECK = 0xC0000092,
526 STATUS_FLOAT_UNDERFLOW = 0xC0000093,
527 STATUS_INTEGER_DIVIDE_BY_ZERO = 0xC0000094,
528 STATUS_INTEGER_OVERFLOW = 0xC0000095,
529 STATUS_PRIVILEGED_INSTRUCTION = 0xC0000096,
530 STATUS_STACK_OVERFLOW = 0xC00000FD,
531 STATUS_CONTROL_C_EXIT = 0xC000013A,
532 STATUS_DLL_INIT_FAILED = 0xC0000142,
533 STATUS_DLL_INIT_FAILED_LOGOFF = 0xC000026B,
534
535 CONTROL_C_EXIT = STATUS_CONTROL_C_EXIT,
536
537 EXCEPTION_ACCESS_VIOLATION = STATUS_ACCESS_VIOLATION,
538 EXCEPTION_DATATYPE_MISALIGNMENT = STATUS_DATATYPE_MISALIGNMENT,
539 EXCEPTION_BREAKPOINT = STATUS_BREAKPOINT,
540 EXCEPTION_SINGLE_STEP = STATUS_SINGLE_STEP,
541 EXCEPTION_ARRAY_BOUNDS_EXCEEDED = STATUS_ARRAY_BOUNDS_EXCEEDED,
542 EXCEPTION_FLT_DENORMAL_OPERAND = STATUS_FLOAT_DENORMAL_OPERAND,
543 EXCEPTION_FLT_DIVIDE_BY_ZERO = STATUS_FLOAT_DIVIDE_BY_ZERO,
544 EXCEPTION_FLT_INEXACT_RESULT = STATUS_FLOAT_INEXACT_RESULT,
545 EXCEPTION_FLT_INVALID_OPERATION = STATUS_FLOAT_INVALID_OPERATION,
546 EXCEPTION_FLT_OVERFLOW = STATUS_FLOAT_OVERFLOW,
547 EXCEPTION_FLT_STACK_CHECK = STATUS_FLOAT_STACK_CHECK,
548 EXCEPTION_FLT_UNDERFLOW = STATUS_FLOAT_UNDERFLOW,
549 EXCEPTION_INT_DIVIDE_BY_ZERO = STATUS_INTEGER_DIVIDE_BY_ZERO,
550 EXCEPTION_INT_OVERFLOW = STATUS_INTEGER_OVERFLOW,
551 EXCEPTION_PRIV_INSTRUCTION = STATUS_PRIVILEGED_INSTRUCTION,
552 EXCEPTION_IN_PAGE_ERROR = STATUS_IN_PAGE_ERROR,
553 EXCEPTION_ILLEGAL_INSTRUCTION = STATUS_ILLEGAL_INSTRUCTION,
554 EXCEPTION_NONCONTINUABLE_EXCEPTION = STATUS_NONCONTINUABLE_EXCEPTION,
555 EXCEPTION_STACK_OVERFLOW = STATUS_STACK_OVERFLOW,
556 EXCEPTION_INVALID_DISPOSITION = STATUS_INVALID_DISPOSITION,
557 EXCEPTION_GUARD_PAGE = STATUS_GUARD_PAGE_VIOLATION,
558 EXCEPTION_INVALID_HANDLE = STATUS_INVALID_HANDLE
559 }
560
561 // for PROCESS_HEAP_ENTRY
562 enum WORD
563 PROCESS_HEAP_REGION = 1,
564 PROCESS_HEAP_UNCOMMITTED_RANGE = 2,
565 PROCESS_HEAP_ENTRY_BUSY = 4,
566 PROCESS_HEAP_ENTRY_MOVEABLE = 16,
567 PROCESS_HEAP_ENTRY_DDESHARE = 32;
568
569 // for LoadLibraryEx()
570 enum DWORD
571 DONT_RESOLVE_DLL_REFERENCES = 0x01, // not for WinME and earlier
572 LOAD_LIBRARY_AS_DATAFILE = 0x02,
573 LOAD_WITH_ALTERED_SEARCH_PATH = 0x08,
574 LOAD_IGNORE_CODE_AUTHZ_LEVEL = 0x10; // only for XP and later
575
576 // for LockFile()
577 enum DWORD
578 LOCKFILE_FAIL_IMMEDIATELY = 1,
579 LOCKFILE_EXCLUSIVE_LOCK = 2;
580
581 enum MAXIMUM_WAIT_OBJECTS = 64;
582 enum MAXIMUM_SUSPEND_COUNT = 0x7F;
583
584 enum WAIT_OBJECT_0 = 0;
585 enum WAIT_ABANDONED_0 = 128;
586
587 //const WAIT_TIMEOUT=258; // also in winerror.h
588
589 enum : DWORD {
590 WAIT_IO_COMPLETION = 0x000000C0,
591 WAIT_ABANDONED = 0x00000080,
592 WAIT_FAILED = 0xFFFFFFFF
593 }
594
595 // PurgeComm()
596 enum DWORD
597 PURGE_TXABORT = 1,
598 PURGE_RXABORT = 2,
599 PURGE_TXCLEAR = 4,
600 PURGE_RXCLEAR = 8;
601
602 // ReadEventLog()
603 enum DWORD
604 EVENTLOG_SEQUENTIAL_READ = 1,
605 EVENTLOG_SEEK_READ = 2,
606 EVENTLOG_FORWARDS_READ = 4,
607 EVENTLOG_BACKWARDS_READ = 8;
608
609 // ReportEvent()
610 enum : WORD {
611 EVENTLOG_SUCCESS = 0,
612 EVENTLOG_ERROR_TYPE = 1,
613 EVENTLOG_WARNING_TYPE = 2,
614 EVENTLOG_INFORMATION_TYPE = 4,
615 EVENTLOG_AUDIT_SUCCESS = 8,
616 EVENTLOG_AUDIT_FAILURE = 16
617 }
618
619 // FormatMessage()
620 enum DWORD
621 FORMAT_MESSAGE_ALLOCATE_BUFFER = 0x0100,
622 FORMAT_MESSAGE_IGNORE_INSERTS = 0x0200,
623 FORMAT_MESSAGE_FROM_STRING = 0x0400,
624 FORMAT_MESSAGE_FROM_HMODULE = 0x0800,
625 FORMAT_MESSAGE_FROM_SYSTEM = 0x1000,
626 FORMAT_MESSAGE_ARGUMENT_ARRAY = 0x2000;
627
628 enum DWORD FORMAT_MESSAGE_MAX_WIDTH_MASK = 255;
629
630 // also in ddk/ntapi.h
631 // To restore default error mode, call SetErrorMode(0)
632 enum {
633 SEM_FAILCRITICALERRORS = 0x0001,
634 SEM_NOGPFAULTERRORBOX = 0x0002,
635 SEM_NOALIGNMENTFAULTEXCEPT = 0x0004,
636 SEM_NOOPENFILEERRORBOX = 0x8000
637 }
638 // end ntapi.h
639
640 enum {
641 SLE_ERROR = 1,
642 SLE_MINORERROR,
643 SLE_WARNING
644 }
645
646 enum SHUTDOWN_NORETRY = 1;
647
648 // Return type for exception filters.
649 enum : LONG {
650 EXCEPTION_EXECUTE_HANDLER = 1,
651 EXCEPTION_CONTINUE_EXECUTION = -1,
652 EXCEPTION_CONTINUE_SEARCH = 0
653 }
654
655 enum : ATOM {
656 MAXINTATOM = 0xC000,
657 INVALID_ATOM = 0
658 }
659
660 enum IGNORE = 0;
661 enum INFINITE = 0xFFFFFFFF;
662
663 // EscapeCommFunction()
664 enum {
665 SETXOFF = 1,
666 SETXON,
667 SETRTS,
668 CLRRTS,
669 SETDTR,
670 CLRDTR, // = 6
671 SETBREAK = 8,
672 CLRBREAK = 9
673 }
674
675
676 // for SetCommMask()
677 enum DWORD
678 EV_RXCHAR = 0x0001,
679 EV_RXFLAG = 0x0002,
680 EV_TXEMPTY = 0x0004,
681 EV_CTS = 0x0008,
682 EV_DSR = 0x0010,
683 EV_RLSD = 0x0020,
684 EV_BREAK = 0x0040,
685 EV_ERR = 0x0080,
686 EV_RING = 0x0100,
687 EV_PERR = 0x0200,
688 EV_RX80FULL = 0x0400,
689 EV_EVENT1 = 0x0800,
690 EV_EVENT2 = 0x1000;
691
692 // GetCommModemStatus()
693 enum DWORD
694 MS_CTS_ON = 0x0010,
695 MS_DSR_ON = 0x0020,
696 MS_RING_ON = 0x0040,
697 MS_RLSD_ON = 0x0080;
698
699
700 // DCB
701 enum : BYTE {
702 NOPARITY = 0,
703 ODDPARITY,
704 EVENPARITY,
705 MARKPARITY,
706 SPACEPARITY
707 }
708 // DCB
709 enum : BYTE {
710 ONESTOPBIT = 0,
711 ONE5STOPBITS,
712 TWOSTOPBITS
713 }
714 // DCB
715 enum : DWORD {
716 CBR_110 = 110,
717 CBR_300 = 300,
718 CBR_600 = 600,
719 CBR_1200 = 1200,
720 CBR_2400 = 2400,
721 CBR_4800 = 4800,
722 CBR_9600 = 9600,
723 CBR_14400 = 14400,
724 CBR_19200 = 19200,
725 CBR_38400 = 38400,
726 CBR_56000 = 56000,
727 CBR_57600 = 57600,
728 CBR_115200 = 115200,
729 CBR_128000 = 128000,
730 CBR_256000 = 256000
731 }
732 // DCB, 2-bit bitfield
733 enum {
734 DTR_CONTROL_DISABLE = 0,
735 DTR_CONTROL_ENABLE,
736 DTR_CONTROL_HANDSHAKE
737 }
738
739 // DCB, 2-bit bitfield
740 enum {
741 RTS_CONTROL_DISABLE = 0,
742 RTS_CONTROL_ENABLE,
743 RTS_CONTROL_HANDSHAKE,
744 RTS_CONTROL_TOGGLE,
745 }
746
747 // WIN32_STREAM_ID
748 enum : DWORD {
749 BACKUP_INVALID = 0,
750 BACKUP_DATA,
751 BACKUP_EA_DATA,
752 BACKUP_SECURITY_DATA,
753 BACKUP_ALTERNATE_DATA,
754 BACKUP_LINK,
755 BACKUP_PROPERTY_DATA,
756 BACKUP_OBJECT_ID,
757 BACKUP_REPARSE_DATA,
758 BACKUP_SPARSE_BLOCK
759 }
760
761 // WIN32_STREAM_ID
762 enum : DWORD {
763 STREAM_NORMAL_ATTRIBUTE = 0,
764 STREAM_MODIFIED_WHEN_READ = 1,
765 STREAM_CONTAINS_SECURITY = 2,
766 STREAM_CONTAINS_PROPERTIES = 4
767 }
768
769 // STARTUPINFO
770 enum DWORD
771 STARTF_USESHOWWINDOW = 0x0001,
772 STARTF_USESIZE = 0x0002,
773 STARTF_USEPOSITION = 0x0004,
774 STARTF_USECOUNTCHARS = 0x0008,
775 STARTF_USEFILLATTRIBUTE = 0x0010,
776 STARTF_RUNFULLSCREEN = 0x0020,
777 STARTF_FORCEONFEEDBACK = 0x0040,
778 STARTF_FORCEOFFFEEDBACK = 0x0080,
779 STARTF_USESTDHANDLES = 0x0100,
780 STARTF_USEHOTKEY = 0x0200;
781
782 // ???
783 enum {
784 TC_NORMAL = 0,
785 TC_HARDERR = 1,
786 TC_GP_TRAP = 2,
787 TC_SIGNAL = 3
788 }
789
790 /+ These seem to be Windows CE-specific
791 enum {
792 AC_LINE_OFFLINE = 0,
793 AC_LINE_ONLINE = 1,
794 AC_LINE_BACKUP_POWER = 2,
795 AC_LINE_UNKNOWN = 255
796 }
797
798 enum {
799 BATTERY_FLAG_HIGH = 1,
800 BATTERY_FLAG_LOW = 2,
801 BATTERY_FLAG_CRITICAL = 4,
802 BATTERY_FLAG_CHARGING = 8,
803 BATTERY_FLAG_NO_BATTERY = 128,
804 BATTERY_FLAG_UNKNOWN = 255,
805 BATTERY_PERCENTAGE_UNKNOWN = 255,
806 BATTERY_LIFE_UNKNOWN = 0xFFFFFFFF
807 }
808 +/
809
810 // ???
811 enum HINSTANCE_ERROR = 32;
812
813 // returned from GetFileSize()
814 enum DWORD INVALID_FILE_SIZE = 0xFFFFFFFF;
815
816 enum DWORD TLS_OUT_OF_INDEXES = 0xFFFFFFFF;
817
818 // GetWriteWatch()
819 enum DWORD WRITE_WATCH_FLAG_RESET = 1;
820
821 // for LogonUser()
822 enum : DWORD {
823 LOGON32_LOGON_INTERACTIVE = 2,
824 LOGON32_LOGON_NETWORK = 3,
825 LOGON32_LOGON_BATCH = 4,
826 LOGON32_LOGON_SERVICE = 5,
827 LOGON32_LOGON_UNLOCK = 7
828 }
829
830 // for LogonUser()
831 enum : DWORD {
832 LOGON32_PROVIDER_DEFAULT,
833 LOGON32_PROVIDER_WINNT35,
834 LOGON32_PROVIDER_WINNT40,
835 LOGON32_PROVIDER_WINNT50
836 }
837
838 // for MoveFileEx()
839 enum DWORD
840 MOVEFILE_REPLACE_EXISTING = 1,
841 MOVEFILE_COPY_ALLOWED = 2,
842 MOVEFILE_DELAY_UNTIL_REBOOT = 4,
843 MOVEFILE_WRITE_THROUGH = 8;
844
845 // DefineDosDevice()
846 enum DWORD
847 DDD_RAW_TARGET_PATH = 1,
848 DDD_REMOVE_DEFINITION = 2,
849 DDD_EXACT_MATCH_ON_REMOVE = 4;
850
851 static if (_WIN32_WINNT >= 0x500) {
852 enum : DWORD {
853 LOGON32_LOGON_NETWORK_CLEARTEXT = 8,
854 LOGON32_LOGON_NEW_CREDENTIALS = 9
855 }
856
857 // ReplaceFile()
858 enum DWORD
859 REPLACEFILE_WRITE_THROUGH = 1,
860 REPLACEFILE_IGNORE_MERGE_ERRORS = 2;
861 }
862
863 static if (_WIN32_WINNT >= 0x501) {
864 enum DWORD
865 GET_MODULE_HANDLE_EX_FLAG_PIN = 1,
866 GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT = 2,
867 GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS = 4;
868
869 // for ACTCTX
870 enum DWORD
871 ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID = 0x01,
872 ACTCTX_FLAG_LANGID_VALID = 0x02,
873 ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID = 0x04,
874 ACTCTX_FLAG_RESOURCE_NAME_VALID = 0x08,
875 ACTCTX_FLAG_SET_PROCESS_DEFAULT = 0x10,
876 ACTCTX_FLAG_APPLICATION_NAME_VALID = 0x20,
877 ACTCTX_FLAG_HMODULE_VALID = 0x80;
878
879 // DeactivateActCtx()
880 enum DWORD DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION = 1;
881 // FindActCtxSectionString()
882 enum DWORD FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX = 1;
883 // QueryActCtxW()
884 enum DWORD
885 QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX = 0x04,
886 QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE = 0x08,
887 QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS = 0x10;
888
889 enum {
890 LOGON_WITH_PROFILE = 1,
891 LOGON_NETCREDENTIALS_ONLY
892 }
893 }
894
895 // ----
896
897 struct FILETIME {
898 DWORD dwLowDateTime;
899 DWORD dwHighDateTime;
900 }
901 alias FILETIME* PFILETIME, LPFILETIME;
902
903 struct BY_HANDLE_FILE_INFORMATION {
904 DWORD dwFileAttributes;
905 FILETIME ftCreationTime;
906 FILETIME ftLastAccessTime;
907 FILETIME ftLastWriteTime;
908 DWORD dwVolumeSerialNumber;
909 DWORD nFileSizeHigh;
910 DWORD nFileSizeLow;
911 DWORD nNumberOfLinks;
912 DWORD nFileIndexHigh;
913 DWORD nFileIndexLow;
914 }
915 alias BY_HANDLE_FILE_INFORMATION* LPBY_HANDLE_FILE_INFORMATION;
916
917 struct DCB {
918 DWORD DCBlength = DCB.sizeof;
919 DWORD BaudRate;
920 /+
921 DWORD fBinary:1; // Binary Mode (skip EOF check)
922 DWORD fParity:1; // Enable parity checking
923 DWORD fOutxCtsFlow:1; // CTS handshaking on output
924 DWORD fOutxDsrFlow:1; // DSR handshaking on output
925 DWORD fDtrControl:2; // DTR Flow control
926 DWORD fDsrSensitivity:1; // DSR Sensitivity
927 DWORD fTXContinueOnXoff:1; // Continue TX when Xoff sent
928 DWORD fOutX:1; // Enable output X-ON/X-OFF
929 DWORD fInX:1; // Enable input X-ON/X-OFF
930 DWORD fErrorChar:1; // Enable Err Replacement
931 DWORD fNull:1; // Enable Null stripping
932 DWORD fRtsControl:2; // Rts Flow control
933 DWORD fAbortOnError:1; // Abort all reads and writes on Error
934 DWORD fDummy2:17; // Reserved
935 +/
936 uint _bf;
937 bool fBinary(bool f) { _bf = (_bf & ~0x0001) | f; return f; }
938 bool fParity(bool f) { _bf = (_bf & ~0x0002) | (f<<1); return f; }
939 bool fOutxCtsFlow(bool f) { _bf = (_bf & ~0x0004) | (f<<2); return f; }
940 bool fOutxDsrFlow(bool f) { _bf = (_bf & ~0x0008) | (f<<3); return f; }
941 byte fDtrControl(byte x) { _bf = (_bf & ~0x0030) | (x<<4); return cast(byte)(x & 3); }
942 bool fDsrSensitivity(bool f) { _bf = (_bf & ~0x0040) | (f<<6); return f; }
943 bool fTXContinueOnXoff(bool f) { _bf = (_bf & ~0x0080) | (f<<7); return f; }
944 bool fOutX(bool f) { _bf = (_bf & ~0x0100) | (f<<8); return f; }
945 bool fInX(bool f) { _bf = (_bf & ~0x0200) | (f<<9); return f; }
946 bool fErrorChar(bool f) { _bf = (_bf & ~0x0400) | (f<<10); return f; }
947 bool fNull(bool f) { _bf = (_bf & ~0x0800) | (f<<11); return f; }
948 byte fRtsControl(byte x) { _bf = (_bf & ~0x3000) | (x<<12); return cast(byte)(x & 3); }
949 bool fAbortOnError(bool f) { _bf = (_bf & ~0x4000) | (f<<14); return f; }
950
951 bool fBinary() { return cast(bool) (_bf & 1); }
952 bool fParity() { return cast(bool) (_bf & 2); }
953 bool fOutxCtsFlow() { return cast(bool) (_bf & 4); }
954 bool fOutxDsrFlow() { return cast(bool) (_bf & 8); }
955 byte fDtrControl() { return cast(byte) ((_bf & (32+16))>>4); }
956 bool fDsrSensitivity() { return cast(bool) (_bf & 64); }
957 bool fTXContinueOnXoff() { return cast(bool) (_bf & 128); }
958 bool fOutX() { return cast(bool) (_bf & 256); }
959 bool fInX() { return cast(bool) (_bf & 512); }
960 bool fErrorChar() { return cast(bool) (_bf & 1024); }
961 bool fNull() { return cast(bool) (_bf & 2048); }
962 byte fRtsControl() { return cast(byte) ((_bf & (4096+8192))>>12); }
963 bool fAbortOnError() { return cast(bool) (_bf & 16384); }
964
965 WORD wReserved;
966 WORD XonLim;
967 WORD XoffLim;
968 BYTE ByteSize;
969 BYTE Parity;
970 BYTE StopBits;
971 char XonChar = 0;
972 char XoffChar = 0;
973 char ErrorChar = 0;
974 char EofChar = 0;
975 char EvtChar = 0;
976 WORD wReserved1;
977 }
978 alias DCB* LPDCB;
979
980 struct COMMCONFIG {
981 DWORD dwSize = COMMCONFIG.sizeof;
982 WORD wVersion;
983 WORD wReserved;
984 DCB dcb;
985 DWORD dwProviderSubType;
986 DWORD dwProviderOffset;
987 DWORD dwProviderSize;
988 WCHAR _wcProviderData = 0;
989
990 WCHAR* wcProviderData() return { return &_wcProviderData; }
991 }
992 alias COMMCONFIG* LPCOMMCONFIG;
993
994 struct COMMTIMEOUTS {
995 DWORD ReadIntervalTimeout;
996 DWORD ReadTotalTimeoutMultiplier;
997 DWORD ReadTotalTimeoutConstant;
998 DWORD WriteTotalTimeoutMultiplier;
999 DWORD WriteTotalTimeoutConstant;
1000 }
1001 alias COMMTIMEOUTS* LPCOMMTIMEOUTS;
1002
1003 struct COMSTAT {
1004 /+
1005 DWORD fCtsHold:1;
1006 DWORD fDsrHold:1;
1007 DWORD fRlsdHold:1;
1008 DWORD fXoffHold:1;
1009 DWORD fXoffSent:1;
1010 DWORD fEof:1;
1011 DWORD fTxim:1;
1012 DWORD fReserved:25;
1013 +/
1014 DWORD _bf;
1015 bool fCtsHold(bool f) { _bf = (_bf & ~1) | f; return f; }
1016 bool fDsrHold(bool f) { _bf = (_bf & ~2) | (f<<1); return f; }
1017 bool fRlsdHold(bool f) { _bf = (_bf & ~4) | (f<<2); return f; }
1018 bool fXoffHold(bool f) { _bf = (_bf & ~8) | (f<<3); return f; }
1019 bool fXoffSent(bool f) { _bf = (_bf & ~16) | (f<<4); return f; }
1020 bool fEof(bool f) { _bf = (_bf & ~32) | (f<<5); return f; }
1021 bool fTxim(bool f) { _bf = (_bf & ~64) | (f<<6); return f; }
1022
1023 bool fCtsHold() { return cast(bool) (_bf & 1); }
1024 bool fDsrHold() { return cast(bool) (_bf & 2); }
1025 bool fRlsdHold() { return cast(bool) (_bf & 4); }
1026 bool fXoffHold() { return cast(bool) (_bf & 8); }
1027 bool fXoffSent() { return cast(bool) (_bf & 16); }
1028 bool fEof() { return cast(bool) (_bf & 32); }
1029 bool fTxim() { return cast(bool) (_bf & 64); }
1030
1031 DWORD cbInQue;
1032 DWORD cbOutQue;
1033 }
1034 alias COMSTAT* LPCOMSTAT;
1035
1036 struct CREATE_PROCESS_DEBUG_INFO {
1037 HANDLE hFile;
1038 HANDLE hProcess;
1039 HANDLE hThread;
1040 LPVOID lpBaseOfImage;
1041 DWORD dwDebugInfoFileOffset;
1042 DWORD nDebugInfoSize;
1043 LPVOID lpThreadLocalBase;
1044 LPTHREAD_START_ROUTINE lpStartAddress;
1045 LPVOID lpImageName;
1046 WORD fUnicode;
1047 }
1048 alias CREATE_PROCESS_DEBUG_INFO* LPCREATE_PROCESS_DEBUG_INFO;
1049
1050 struct CREATE_THREAD_DEBUG_INFO {
1051 HANDLE hThread;
1052 LPVOID lpThreadLocalBase;
1053 LPTHREAD_START_ROUTINE lpStartAddress;
1054 }
1055 alias CREATE_THREAD_DEBUG_INFO* LPCREATE_THREAD_DEBUG_INFO;
1056
1057 struct EXCEPTION_DEBUG_INFO {
1058 EXCEPTION_RECORD ExceptionRecord;
1059 DWORD dwFirstChance;
1060 }
1061 alias EXCEPTION_DEBUG_INFO* LPEXCEPTION_DEBUG_INFO;
1062
1063 struct EXIT_THREAD_DEBUG_INFO {
1064 DWORD dwExitCode;
1065 }
1066 alias EXIT_THREAD_DEBUG_INFO* LPEXIT_THREAD_DEBUG_INFO;
1067
1068 struct EXIT_PROCESS_DEBUG_INFO {
1069 DWORD dwExitCode;
1070 }
1071 alias EXIT_PROCESS_DEBUG_INFO* LPEXIT_PROCESS_DEBUG_INFO;
1072
1073 struct LOAD_DLL_DEBUG_INFO {
1074 HANDLE hFile;
1075 LPVOID lpBaseOfDll;
1076 DWORD dwDebugInfoFileOffset;
1077 DWORD nDebugInfoSize;
1078 LPVOID lpImageName;
1079 WORD fUnicode;
1080 }
1081 alias LOAD_DLL_DEBUG_INFO* LPLOAD_DLL_DEBUG_INFO;
1082
1083 struct UNLOAD_DLL_DEBUG_INFO {
1084 LPVOID lpBaseOfDll;
1085 }
1086 alias UNLOAD_DLL_DEBUG_INFO* LPUNLOAD_DLL_DEBUG_INFO;
1087
1088 struct OUTPUT_DEBUG_STRING_INFO {
1089 LPSTR lpDebugStringData;
1090 WORD fUnicode;
1091 WORD nDebugStringLength;
1092 }
1093 alias OUTPUT_DEBUG_STRING_INFO* LPOUTPUT_DEBUG_STRING_INFO;
1094
1095 struct RIP_INFO {
1096 DWORD dwError;
1097 DWORD dwType;
1098 }
1099 alias RIP_INFO* LPRIP_INFO;
1100
1101 struct DEBUG_EVENT {
1102 DWORD dwDebugEventCode;
1103 DWORD dwProcessId;
1104 DWORD dwThreadId;
1105 union {
1106 EXCEPTION_DEBUG_INFO Exception;
1107 CREATE_THREAD_DEBUG_INFO CreateThread;
1108 CREATE_PROCESS_DEBUG_INFO CreateProcessInfo;
1109 EXIT_THREAD_DEBUG_INFO ExitThread;
1110 EXIT_PROCESS_DEBUG_INFO ExitProcess;
1111 LOAD_DLL_DEBUG_INFO LoadDll;
1112 UNLOAD_DLL_DEBUG_INFO UnloadDll;
1113 OUTPUT_DEBUG_STRING_INFO DebugString;
1114 RIP_INFO RipInfo;
1115 }
1116 }
1117 alias DEBUG_EVENT* LPDEBUG_EVENT;
1118
1119 struct OVERLAPPED {
1120 ULONG_PTR Internal;
1121 ULONG_PTR InternalHigh;
1122 union {
1123 struct {
1124 DWORD Offset;
1125 DWORD OffsetHigh;
1126 }
1127 PVOID Pointer;
1128 }
1129 HANDLE hEvent;
1130 }
1131 alias OVERLAPPED* POVERLAPPED, LPOVERLAPPED;
1132
1133 struct STARTUPINFOA {
1134 DWORD cb = STARTUPINFOA.sizeof;
1135 LPSTR lpReserved;
1136 LPSTR lpDesktop;
1137 LPSTR lpTitle;
1138 DWORD dwX;
1139 DWORD dwY;
1140 DWORD dwXSize;
1141 DWORD dwYSize;
1142 DWORD dwXCountChars;
1143 DWORD dwYCountChars;
1144 DWORD dwFillAttribute;
1145 DWORD dwFlags;
1146 WORD wShowWindow;
1147 WORD cbReserved2;
1148 PBYTE lpReserved2;
1149 HANDLE hStdInput;
1150 HANDLE hStdOutput;
1151 HANDLE hStdError;
1152 }
1153 alias STARTUPINFOA* LPSTARTUPINFOA;
1154
1155 struct STARTUPINFOW {
1156 DWORD cb = STARTUPINFOW.sizeof;
1157 LPWSTR lpReserved;
1158 LPWSTR lpDesktop;
1159 LPWSTR lpTitle;
1160 DWORD dwX;
1161 DWORD dwY;
1162 DWORD dwXSize;
1163 DWORD dwYSize;
1164 DWORD dwXCountChars;
1165 DWORD dwYCountChars;
1166 DWORD dwFillAttribute;
1167 DWORD dwFlags;
1168 WORD wShowWindow;
1169 WORD cbReserved2;
1170 PBYTE lpReserved2;
1171 HANDLE hStdInput;
1172 HANDLE hStdOutput;
1173 HANDLE hStdError;
1174 }
1175 alias STARTUPINFOW STARTUPINFO_W;
1176 alias STARTUPINFOW* LPSTARTUPINFOW, LPSTARTUPINFO_W;
1177
1178 struct PROCESS_INFORMATION {
1179 HANDLE hProcess;
1180 HANDLE hThread;
1181 DWORD dwProcessId;
1182 DWORD dwThreadId;
1183 }
1184 alias PROCESS_INFORMATION* PPROCESS_INFORMATION, LPPROCESS_INFORMATION;
1185
1186 /*
1187 struct CRITICAL_SECTION_DEBUG {
1188 WORD Type;
1189 WORD CreatorBackTraceIndex;
1190 CRITICAL_SECTION* CriticalSection;
1191 LIST_ENTRY ProcessLocksList;
1192 DWORD EntryCount;
1193 DWORD ContentionCount;
1194 DWORD[2] Spare;
1195 }
1196 alias CRITICAL_SECTION_DEBUG* PCRITICAL_SECTION_DEBUG;
1197
1198 struct CRITICAL_SECTION {
1199 PCRITICAL_SECTION_DEBUG DebugInfo;
1200 LONG LockCount;
1201 LONG RecursionCount;
1202 HANDLE OwningThread;
1203 HANDLE LockSemaphore;
1204 DWORD SpinCount;
1205 }
1206 alias CRITICAL_SECTION* PCRITICAL_SECTION, LPCRITICAL_SECTION;
1207 */
1208
1209 alias CRITICAL_SECTION_DEBUG = RTL_CRITICAL_SECTION_DEBUG;
1210 alias CRITICAL_SECTION_DEBUG* PCRITICAL_SECTION_DEBUG;
1211
1212 alias CRITICAL_SECTION = RTL_CRITICAL_SECTION;
1213 alias CRITICAL_SECTION* PCRITICAL_SECTION, LPCRITICAL_SECTION;
1214
1215 struct SYSTEMTIME {
1216 WORD wYear;
1217 WORD wMonth;
1218 WORD wDayOfWeek;
1219 WORD wDay;
1220 WORD wHour;
1221 WORD wMinute;
1222 WORD wSecond;
1223 WORD wMilliseconds;
1224 }
1225 alias SYSTEMTIME* LPSYSTEMTIME;
1226
1227 struct WIN32_FILE_ATTRIBUTE_DATA {
1228 DWORD dwFileAttributes;
1229 FILETIME ftCreationTime;
1230 FILETIME ftLastAccessTime;
1231 FILETIME ftLastWriteTime;
1232 DWORD nFileSizeHigh;
1233 DWORD nFileSizeLow;
1234 }
1235 alias WIN32_FILE_ATTRIBUTE_DATA* LPWIN32_FILE_ATTRIBUTE_DATA;
1236
1237 struct WIN32_FIND_DATAA {
1238 DWORD dwFileAttributes;
1239 FILETIME ftCreationTime;
1240 FILETIME ftLastAccessTime;
1241 FILETIME ftLastWriteTime;
1242 DWORD nFileSizeHigh;
1243 DWORD nFileSizeLow;
1244 // #ifdef _WIN32_WCE
1245 // DWORD dwOID;
1246 // #else
1247 DWORD dwReserved0;
1248 DWORD dwReserved1;
1249 // #endif
1250 CHAR[MAX_PATH] cFileName = 0;
1251 // #ifndef _WIN32_WCE
1252 CHAR[14] cAlternateFileName = 0;
1253 // #endif
1254 }
1255 alias WIN32_FIND_DATAA* PWIN32_FIND_DATAA, LPWIN32_FIND_DATAA;
1256
1257 struct WIN32_FIND_DATAW {
1258 DWORD dwFileAttributes;
1259 FILETIME ftCreationTime;
1260 FILETIME ftLastAccessTime;
1261 FILETIME ftLastWriteTime;
1262 DWORD nFileSizeHigh;
1263 DWORD nFileSizeLow;
1264 // #ifdef _WIN32_WCE
1265 // DWORD dwOID;
1266 // #else
1267 DWORD dwReserved0;
1268 DWORD dwReserved1;
1269 // #endif
1270 WCHAR[MAX_PATH] cFileName = 0;
1271 // #ifndef _WIN32_WCE
1272 WCHAR[14] cAlternateFileName = 0;
1273 // #endif
1274 }
1275 alias WIN32_FIND_DATAW* PWIN32_FIND_DATAW, LPWIN32_FIND_DATAW;
1276
1277 struct WIN32_STREAM_ID {
1278 DWORD dwStreamId;
1279 DWORD dwStreamAttributes;
1280 LARGE_INTEGER Size;
1281 DWORD dwStreamNameSize;
1282 WCHAR _cStreamName = 0;
1283
1284 WCHAR* cStreamName() return { return &_cStreamName; }
1285 }
1286 alias WIN32_STREAM_ID* LPWIN32_STREAM_ID;
1287
1288 enum FINDEX_INFO_LEVELS {
1289 FindExInfoStandard,
1290 FindExInfoMaxInfoLevel
1291 }
1292
1293 enum FINDEX_SEARCH_OPS {
1294 FindExSearchNameMatch,
1295 FindExSearchLimitToDirectories,
1296 FindExSearchLimitToDevices,
1297 FindExSearchMaxSearchOp
1298 }
1299
1300 enum ACL_INFORMATION_CLASS {
1301 AclRevisionInformation = 1,
1302 AclSizeInformation
1303 }
1304
1305 struct HW_PROFILE_INFOA {
1306 DWORD dwDockInfo;
1307 CHAR[HW_PROFILE_GUIDLEN] szHwProfileGuid = 0;
1308 CHAR[MAX_PROFILE_LEN] szHwProfileName = 0;
1309 }
1310 alias HW_PROFILE_INFOA* LPHW_PROFILE_INFOA;
1311
1312 struct HW_PROFILE_INFOW {
1313 DWORD dwDockInfo;
1314 WCHAR[HW_PROFILE_GUIDLEN] szHwProfileGuid = 0;
1315 WCHAR[MAX_PROFILE_LEN] szHwProfileName = 0;
1316 }
1317 alias HW_PROFILE_INFOW* LPHW_PROFILE_INFOW;
1318
1319 /* ??? MSDN documents this only for Windows CE/Mobile, but it's used by
1320 * GetFileAttributesEx, which is in desktop Windows.
1321 */
1322 enum GET_FILEEX_INFO_LEVELS {
1323 GetFileExInfoStandard,
1324 GetFileExMaxInfoLevel
1325 }
1326
1327 struct SYSTEM_INFO {
1328 union {
1329 DWORD dwOemId;
1330 struct {
1331 WORD wProcessorArchitecture;
1332 WORD wReserved;
1333 }
1334 }
1335 DWORD dwPageSize;
1336 PVOID lpMinimumApplicationAddress;
1337 PVOID lpMaximumApplicationAddress;
1338 DWORD_PTR dwActiveProcessorMask;
1339 DWORD dwNumberOfProcessors;
1340 DWORD dwProcessorType;
1341 DWORD dwAllocationGranularity;
1342 WORD wProcessorLevel;
1343 WORD wProcessorRevision;
1344 }
1345 alias SYSTEM_INFO* LPSYSTEM_INFO;
1346
1347 static if (_WIN32_WINNT >= 0x500) {
1348 struct SYSTEM_POWER_STATUS {
1349 BYTE ACLineStatus;
1350 BYTE BatteryFlag;
1351 BYTE BatteryLifePercent;
1352 BYTE Reserved1;
1353 DWORD BatteryLifeTime;
1354 DWORD BatteryFullLifeTime;
1355 }
1356 alias SYSTEM_POWER_STATUS* LPSYSTEM_POWER_STATUS;
1357 }
1358
1359 struct TIME_ZONE_INFORMATION {
1360 LONG Bias;
1361 WCHAR[32] StandardName = 0;
1362 SYSTEMTIME StandardDate;
1363 LONG StandardBias;
1364 WCHAR[32] DaylightName = 0;
1365 SYSTEMTIME DaylightDate;
1366 LONG DaylightBias;
1367 }
1368 alias TIME_ZONE_INFORMATION* LPTIME_ZONE_INFORMATION;
1369
1370 // Does not exist in Windows headers, only MSDN
1371 // documentation (for TIME_ZONE_INFORMATION).
1372 // Provided solely for compatibility with the old
1373 // core.sys.windows.windows
1374 struct REG_TZI_FORMAT {
1375 LONG Bias;
1376 LONG StandardBias;
1377 LONG DaylightBias;
1378 SYSTEMTIME StandardDate;
1379 SYSTEMTIME DaylightDate;
1380 }
1381
1382 // MSDN documents this, possibly erroneously, as Win2000+.
1383 struct MEMORYSTATUS {
1384 DWORD dwLength;
1385 DWORD dwMemoryLoad;
1386 SIZE_T dwTotalPhys;
1387 SIZE_T dwAvailPhys;
1388 SIZE_T dwTotalPageFile;
1389 SIZE_T dwAvailPageFile;
1390 SIZE_T dwTotalVirtual;
1391 SIZE_T dwAvailVirtual;
1392 }
1393 alias MEMORYSTATUS* LPMEMORYSTATUS;
1394
1395 static if (_WIN32_WINNT >= 0x500) {
1396 struct MEMORYSTATUSEX {
1397 DWORD dwLength;
1398 DWORD dwMemoryLoad;
1399 DWORDLONG ullTotalPhys;
1400 DWORDLONG ullAvailPhys;
1401 DWORDLONG ullTotalPageFile;
1402 DWORDLONG ullAvailPageFile;
1403 DWORDLONG ullTotalVirtual;
1404 DWORDLONG ullAvailVirtual;
1405 DWORDLONG ullAvailExtendedVirtual;
1406 }
1407 alias MEMORYSTATUSEX* LPMEMORYSTATUSEX;
1408 }
1409
1410 struct LDT_ENTRY {
1411 WORD LimitLow;
1412 WORD BaseLow;
1413 struct {
1414 BYTE BaseMid;
1415 BYTE Flags1;
1416 BYTE Flags2;
1417 BYTE BaseHi;
1418
1419 byte Type(byte f) { Flags1 = cast(BYTE) ((Flags1 & 0xE0) | f); return cast(byte)(f & 0x1F); }
1420 byte Dpl(byte f) { Flags1 = cast(BYTE) ((Flags1 & 0x9F) | (f<<5)); return cast(byte)(f & 3); }
1421 bool Pres(bool f) { Flags1 = cast(BYTE) ((Flags1 & 0x7F) | (f<<7)); return f; }
1422
1423 byte LimitHi(byte f) { Flags2 = cast(BYTE) ((Flags2 & 0xF0) | (f&0x0F)); return cast(byte)(f & 0x0F); }
1424 bool Sys(bool f) { Flags2 = cast(BYTE) ((Flags2 & 0xEF) | (f<<4)); return f; }
1425 // Next bit is reserved
1426 bool Default_Big(bool f) { Flags2 = cast(BYTE) ((Flags2 & 0xBF) | (f<<6)); return f; }
1427 bool Granularity(bool f) { Flags2 = cast(BYTE) ((Flags2 & 0x7F) | (f<<7)); return f; }
1428
1429 byte Type() { return cast(byte) (Flags1 & 0x1F); }
1430 byte Dpl() { return cast(byte) ((Flags1 & 0x60)>>5); }
1431 bool Pres() { return cast(bool) (Flags1 & 0x80); }
1432
1433 byte LimitHi() { return cast(byte) (Flags2 & 0x0F); }
1434 bool Sys() { return cast(bool) (Flags2 & 0x10); }
1435 bool Default_Big() { return cast(bool) (Flags2 & 0x40); }
1436 bool Granularity() { return cast(bool) (Flags2 & 0x80); }
1437 }
1438 /+
1439 union HighWord {
1440 struct Bytes {
1441 BYTE BaseMid;
1442 BYTE Flags1;
1443 BYTE Flags2;
1444 BYTE BaseHi;
1445 }
1446 struct Bits {
1447 DWORD BaseMid:8;
1448 DWORD Type:5;
1449 DWORD Dpl:2;
1450 DWORD Pres:1;
1451 DWORD LimitHi:4;
1452 DWORD Sys:1;
1453 DWORD Reserved_0:1;
1454 DWORD Default_Big:1;
1455 DWORD Granularity:1;
1456 DWORD BaseHi:8;
1457 }
1458 }
1459 +/
1460 }
1461 alias LDT_ENTRY* PLDT_ENTRY, LPLDT_ENTRY;
1462
1463 /* As with the other memory management functions and structures, MSDN's
1464 * Windows version info shall be taken with a cup of salt.
1465 */
1466 struct PROCESS_HEAP_ENTRY {
1467 PVOID lpData;
1468 DWORD cbData;
1469 BYTE cbOverhead;
1470 BYTE iRegionIndex;
1471 WORD wFlags;
1472 union {
1473 struct _Block {
1474 HANDLE hMem;
1475 DWORD[3] dwReserved;
1476 }
1477 _Block Block;
1478 struct _Region {
1479 DWORD dwCommittedSize;
1480 DWORD dwUnCommittedSize;
1481 LPVOID lpFirstBlock;
1482 LPVOID lpLastBlock;
1483 }
1484 _Region Region;
1485 }
1486 }
1487 alias PROCESS_HEAP_ENTRY* LPPROCESS_HEAP_ENTRY;
1488
1489 struct OFSTRUCT {
1490 BYTE cBytes = OFSTRUCT.sizeof;
1491 BYTE fFixedDisk;
1492 WORD nErrCode;
1493 WORD Reserved1;
1494 WORD Reserved2;
1495 CHAR[128] szPathName = 0; // const OFS_MAXPATHNAME = 128;
1496 }
1497 alias OFSTRUCT* LPOFSTRUCT, POFSTRUCT;
1498
1499 /* ??? MSDN documents this only for Windows CE, but it's used by
1500 * ImageGetCertificateData, which is in desktop Windows.
1501 */
1502 struct WIN_CERTIFICATE {
1503 DWORD dwLength;
1504 WORD wRevision;
1505 WORD wCertificateType;
1506 BYTE _bCertificate;
1507
1508 BYTE* bCertificate() return { return &_bCertificate; }
1509 }
1510 alias WIN_CERTIFICATE* LPWIN_CERTIFICATE;
1511
1512 static if (_WIN32_WINNT >= 0x500) {
1513 enum COMPUTER_NAME_FORMAT {
1514 ComputerNameNetBIOS,
1515 ComputerNameDnsHostname,
1516 ComputerNameDnsDomain,
1517 ComputerNameDnsFullyQualified,
1518 ComputerNamePhysicalNetBIOS,
1519 ComputerNamePhysicalDnsHostname,
1520 ComputerNamePhysicalDnsDomain,
1521 ComputerNamePhysicalDnsFullyQualified,
1522 ComputerNameMax
1523 }
1524 }
1525
1526 static if (_WIN32_WINNT >= 0x501) {
1527 struct ACTCTXA {
1528 ULONG cbSize = this.sizeof;
1529 DWORD dwFlags;
1530 LPCSTR lpSource;
1531 USHORT wProcessorArchitecture;
1532 LANGID wLangId;
1533 LPCSTR lpAssemblyDirectory;
1534 LPCSTR lpResourceName;
1535 LPCSTR lpApplicationName;
1536 HMODULE hModule;
1537 }
1538 alias ACTCTXA* PACTCTXA;
1539 alias const(ACTCTXA)* PCACTCTXA;
1540
1541 struct ACTCTXW {
1542 ULONG cbSize = this.sizeof;
1543 DWORD dwFlags;
1544 LPCWSTR lpSource;
1545 USHORT wProcessorArchitecture;
1546 LANGID wLangId;
1547 LPCWSTR lpAssemblyDirectory;
1548 LPCWSTR lpResourceName;
1549 LPCWSTR lpApplicationName;
1550 HMODULE hModule;
1551 }
1552 alias ACTCTXW* PACTCTXW;
1553 alias const(ACTCTXW)* PCACTCTXW;
1554
1555 struct ACTCTX_SECTION_KEYED_DATA {
1556 ULONG cbSize = this.sizeof;
1557 ULONG ulDataFormatVersion;
1558 PVOID lpData;
1559 ULONG ulLength;
1560 PVOID lpSectionGlobalData;
1561 ULONG ulSectionGlobalDataLength;
1562 PVOID lpSectionBase;
1563 ULONG ulSectionTotalLength;
1564 HANDLE hActCtx;
1565 HANDLE ulAssemblyRosterIndex;
1566 }
1567 alias ACTCTX_SECTION_KEYED_DATA* PACTCTX_SECTION_KEYED_DATA;
1568 alias const(ACTCTX_SECTION_KEYED_DATA)* PCACTCTX_SECTION_KEYED_DATA;
1569
1570 enum MEMORY_RESOURCE_NOTIFICATION_TYPE {
1571 LowMemoryResourceNotification,
1572 HighMemoryResourceNotification
1573 }
1574
1575 } // (_WIN32_WINNT >= 0x501)
1576
1577 static if (_WIN32_WINNT >= 0x410) {
1578 /* apparently used only by SetThreadExecutionState (Win2000+)
1579 * and DDK functions (version compatibility not established)
1580 */
1581 alias DWORD EXECUTION_STATE;
1582 }
1583
1584 // Callbacks
1585 extern (Windows) {
1586 alias DWORD function(LPVOID) LPTHREAD_START_ROUTINE;
1587 alias DWORD function(LARGE_INTEGER, LARGE_INTEGER, LARGE_INTEGER, LARGE_INTEGER,
1588 DWORD, DWORD, HANDLE, HANDLE, LPVOID) LPPROGRESS_ROUTINE;
1589 alias void function(PVOID) LPFIBER_START_ROUTINE;
1590
1591 alias BOOL function(HMODULE, LPCSTR, LPCSTR, WORD, LONG_PTR) ENUMRESLANGPROCA;
1592 alias BOOL function(HMODULE, LPCWSTR, LPCWSTR, WORD, LONG_PTR) ENUMRESLANGPROCW;
1593 alias BOOL function(HMODULE, LPCSTR, LPSTR, LONG_PTR) ENUMRESNAMEPROCA;
1594 alias BOOL function(HMODULE, LPCWSTR, LPWSTR, LONG_PTR) ENUMRESNAMEPROCW;
1595 alias BOOL function(HMODULE, LPSTR, LONG_PTR) ENUMRESTYPEPROCA;
1596 alias BOOL function(HMODULE, LPWSTR, LONG_PTR) ENUMRESTYPEPROCW;
1597 alias void function(DWORD, DWORD, LPOVERLAPPED) LPOVERLAPPED_COMPLETION_ROUTINE;
1598 alias LONG function(LPEXCEPTION_POINTERS) PTOP_LEVEL_EXCEPTION_FILTER;
1599 alias PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER;
1600
1601 alias void function(ULONG_PTR) PAPCFUNC;
1602 alias void function(PVOID, DWORD, DWORD) PTIMERAPCROUTINE;
1603
1604 static if (_WIN32_WINNT >= 0x500) {
1605 alias void function(PVOID, BOOLEAN) WAITORTIMERCALLBACK;
1606 }
1607 }
1608
1609 LPTSTR MAKEINTATOM()(ushort i) {
1610 return cast(LPTSTR) cast(size_t) i;
1611 }
1612
1613 extern (Windows) nothrow @nogc {
1614 // The following Win16 functions are obselete in Win32.
1615 int _hread(HFILE, LPVOID, int);
1616 int _hwrite(HFILE, LPCSTR, int);
1617 HFILE _lclose(HFILE);
1618 HFILE _lcreat(LPCSTR, int);
1619 LONG _llseek(HFILE, LONG, int);
1620 HFILE _lopen(LPCSTR, int);
1621 UINT _lread(HFILE, LPVOID, UINT);
1622 UINT _lwrite(HFILE, LPCSTR, UINT);
1623 SIZE_T GlobalCompact(DWORD);
1624 VOID GlobalFix(HGLOBAL);
1625
1626 // MSDN contradicts itself on GlobalFlags:
1627 // "This function is provided only for compatibility with 16-bit versions of Windows."
1628 // but also requires Windows 2000 or above
1629 UINT GlobalFlags(HGLOBAL);
1630 VOID GlobalUnfix(HGLOBAL);
1631 BOOL GlobalUnWire(HGLOBAL);
1632 PVOID GlobalWire(HGLOBAL);
1633 SIZE_T LocalCompact(UINT);
1634 UINT LocalFlags(HLOCAL);
1635 SIZE_T LocalShrink(HLOCAL, UINT);
1636
1637 /+
1638 //--------------------------------------
1639 // These functions are problematic
1640
1641 version (UseNtoSKernel) {}else {
1642 /* CAREFUL: These are exported from ntoskrnl.exe and declared in winddk.h
1643 as __fastcall functions, but are exported from kernel32.dll as __stdcall */
1644 static if (_WIN32_WINNT >= 0x501) {
1645 VOID InitializeSListHead(PSLIST_HEADER);
1646 }
1647 LONG InterlockedCompareExchange(LPLONG, LONG, LONG);
1648 // PVOID WINAPI InterlockedCompareExchangePointer(PVOID*, PVOID, PVOID);
1649 (PVOID)InterlockedCompareExchange((LPLONG)(d) (PVOID)InterlockedCompareExchange((LPLONG)(d), (LONG)(e), (LONG)(c))
1650 LONG InterlockedDecrement(LPLONG);
1651 LONG InterlockedExchange(LPLONG, LONG);
1652 // PVOID WINAPI InterlockedExchangePointer(PVOID*, PVOID);
1653 (PVOID)InterlockedExchange((LPLONG)((PVOID)InterlockedExchange((LPLONG)(t), (LONG)(v))
1654 LONG InterlockedExchangeAdd(LPLONG, LONG);
1655
1656 static if (_WIN32_WINNT >= 0x501) {
1657 PSLIST_ENTRY InterlockedFlushSList(PSLIST_HEADER);
1658 }
1659 LONG InterlockedIncrement(LPLONG);
1660 static if (_WIN32_WINNT >= 0x501) {
1661 PSLIST_ENTRY InterlockedPopEntrySList(PSLIST_HEADER);
1662 PSLIST_ENTRY InterlockedPushEntrySList(PSLIST_HEADER, PSLIST_ENTRY);
1663 }
1664 } // #endif // __USE_NTOSKRNL__
1665 //--------------------------------------
1666 +/
1667
1668 LONG InterlockedIncrement(LPLONG lpAddend);
1669 LONG InterlockedDecrement(LPLONG lpAddend);
1670 LONG InterlockedExchange(LPLONG Target, LONG Value);
1671 LONG InterlockedExchangeAdd(LPLONG Addend, LONG Value);
1672 LONG InterlockedCompareExchange(LONG *Destination, LONG Exchange, LONG Comperand);
1673
1674 ATOM AddAtomA(LPCSTR);
1675 ATOM AddAtomW(LPCWSTR);
1676 BOOL AreFileApisANSI();
1677 BOOL Beep(DWORD, DWORD);
1678 HANDLE BeginUpdateResourceA(LPCSTR, BOOL);
1679 HANDLE BeginUpdateResourceW(LPCWSTR, BOOL);
1680 BOOL BuildCommDCBA(LPCSTR, LPDCB);
1681 BOOL BuildCommDCBW(LPCWSTR, LPDCB);
1682 BOOL BuildCommDCBAndTimeoutsA(LPCSTR, LPDCB, LPCOMMTIMEOUTS);
1683 BOOL BuildCommDCBAndTimeoutsW(LPCWSTR, LPDCB, LPCOMMTIMEOUTS);
1684 BOOL CallNamedPipeA(LPCSTR, PVOID, DWORD, PVOID, DWORD, PDWORD, DWORD);
1685 BOOL CallNamedPipeW(LPCWSTR, PVOID, DWORD, PVOID, DWORD, PDWORD, DWORD);
1686 BOOL CancelDeviceWakeupRequest(HANDLE);
1687 BOOL CheckTokenMembership(HANDLE, PSID, PBOOL);
1688 BOOL ClearCommBreak(HANDLE);
1689 BOOL ClearCommError(HANDLE, PDWORD, LPCOMSTAT);
1690 BOOL CloseHandle(HANDLE) @trusted;
1691 BOOL CommConfigDialogA(LPCSTR, HWND, LPCOMMCONFIG);
1692 BOOL CommConfigDialogW(LPCWSTR, HWND, LPCOMMCONFIG);
1693 LONG CompareFileTime(const(FILETIME)*, const(FILETIME)*);
1694 BOOL ContinueDebugEvent(DWORD, DWORD, DWORD);
1695 BOOL CopyFileA(LPCSTR, LPCSTR, BOOL);
1696 BOOL CopyFileW(LPCWSTR, LPCWSTR, BOOL);
1697 BOOL CopyFileExA(LPCSTR, LPCSTR, LPPROGRESS_ROUTINE, LPVOID, LPBOOL, DWORD);
1698 BOOL CopyFileExW(LPCWSTR, LPCWSTR, LPPROGRESS_ROUTINE, LPVOID, LPBOOL, DWORD);
1699
1700 /+ FIXME
1701 alias memmove RtlMoveMemory;
1702 alias memcpy RtlCopyMemory;
1703
1704 void RtlFillMemory(PVOID dest, SIZE_T len, BYTE fill) {
1705 memset(dest, fill, len);
1706 }
1707
1708 void RtlZeroMemory(PVOID dest, SIZE_T len) {
1709 RtlFillMemory(dest, len, 0);
1710 }
1711
1712 alias RtlMoveMemory MoveMemory;
1713 alias RtlCopyMemory CopyMemory;
1714 alias RtlFillMemory FillMemory;
1715 alias RtlZeroMemory ZeroMemory;
1716 +/
1717 BOOL CreateDirectoryA(LPCSTR, LPSECURITY_ATTRIBUTES);
1718 BOOL CreateDirectoryW(LPCWSTR, LPSECURITY_ATTRIBUTES);
1719 BOOL CreateDirectoryExA(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES);
1720 BOOL CreateDirectoryExW(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES);
1721 HANDLE CreateEventA(LPSECURITY_ATTRIBUTES, BOOL, BOOL, LPCSTR);
1722 HANDLE CreateEventW(LPSECURITY_ATTRIBUTES, BOOL, BOOL, LPCWSTR);
1723 HANDLE CreateFileA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE);
1724 HANDLE CreateFileW(LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE);
1725 HANDLE CreateIoCompletionPort(HANDLE, HANDLE, ULONG_PTR, DWORD);
1726 HANDLE CreateMailslotA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
1727 HANDLE CreateMailslotW(LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
1728 HANDLE CreateMutexA(LPSECURITY_ATTRIBUTES, BOOL, LPCSTR);
1729 HANDLE CreateMutexW(LPSECURITY_ATTRIBUTES, BOOL, LPCWSTR);
1730 BOOL CreatePipe(PHANDLE, PHANDLE, LPSECURITY_ATTRIBUTES, DWORD);
1731 BOOL CreateProcessA(LPCSTR, LPSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCSTR, LPSTARTUPINFOA, LPPROCESS_INFORMATION);
1732 BOOL CreateProcessW(LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION);
1733 HANDLE CreateSemaphoreA(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCSTR) @trusted;
1734 HANDLE CreateSemaphoreW(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCWSTR) @trusted;
1735 HANDLE CreateThread(LPSECURITY_ATTRIBUTES, SIZE_T, LPTHREAD_START_ROUTINE, PVOID, DWORD, PDWORD);
1736 BOOL DebugActiveProcess(DWORD);
1737 void DebugBreak();
1738 ATOM DeleteAtom(ATOM);
1739 void DeleteCriticalSection(PCRITICAL_SECTION);
1740 BOOL DeleteFileA(LPCSTR);
1741 BOOL DeleteFileW(LPCWSTR);
1742 BOOL DisableThreadLibraryCalls(HMODULE);
1743 BOOL DosDateTimeToFileTime(WORD, WORD, LPFILETIME);
1744 BOOL DuplicateHandle(HANDLE, HANDLE, HANDLE, PHANDLE, DWORD, BOOL, DWORD);
1745 BOOL EndUpdateResourceA(HANDLE, BOOL);
1746 BOOL EndUpdateResourceW(HANDLE, BOOL);
1747 void EnterCriticalSection(LPCRITICAL_SECTION);
1748 void EnterCriticalSection(shared(CRITICAL_SECTION)*);
1749 BOOL EnumResourceLanguagesA(HMODULE, LPCSTR, LPCSTR, ENUMRESLANGPROC, LONG_PTR);
1750 BOOL EnumResourceLanguagesW(HMODULE, LPCWSTR, LPCWSTR, ENUMRESLANGPROC, LONG_PTR);
1751 BOOL EnumResourceNamesA(HMODULE, LPCSTR, ENUMRESNAMEPROC, LONG_PTR);
1752 BOOL EnumResourceNamesW(HMODULE, LPCWSTR, ENUMRESNAMEPROC, LONG_PTR);
1753 BOOL EnumResourceTypesA(HMODULE, ENUMRESTYPEPROC, LONG_PTR);
1754 BOOL EnumResourceTypesW(HMODULE, ENUMRESTYPEPROC, LONG_PTR);
1755 BOOL EscapeCommFunction(HANDLE, DWORD);
1756 void ExitProcess(UINT); // Never returns
1757 void ExitThread(DWORD); // Never returns
1758 DWORD ExpandEnvironmentStringsA(LPCSTR, LPSTR, DWORD);
1759 DWORD ExpandEnvironmentStringsW(LPCWSTR, LPWSTR, DWORD);
1760 void FatalAppExitA(UINT, LPCSTR);
1761 void FatalAppExitW(UINT, LPCWSTR);
1762 void FatalExit(int);
1763 BOOL FileTimeToDosDateTime(const(FILETIME)*, LPWORD, LPWORD);
1764 BOOL FileTimeToLocalFileTime(const(FILETIME)*, LPFILETIME);
1765 BOOL FileTimeToSystemTime(const(FILETIME)*, LPSYSTEMTIME);
1766 ATOM FindAtomA(LPCSTR);
1767 ATOM FindAtomW(LPCWSTR);
1768 BOOL FindClose(HANDLE);
1769 BOOL FindCloseChangeNotification(HANDLE);
1770 HANDLE FindFirstChangeNotificationA(LPCSTR, BOOL, DWORD);
1771 HANDLE FindFirstChangeNotificationW(LPCWSTR, BOOL, DWORD);
1772 HANDLE FindFirstFileA(LPCSTR, LPWIN32_FIND_DATAA);
1773 HANDLE FindFirstFileW(LPCWSTR, LPWIN32_FIND_DATAW);
1774 BOOL FindNextChangeNotification(HANDLE);
1775 BOOL FindNextFileA(HANDLE, LPWIN32_FIND_DATAA);
1776 BOOL FindNextFileW(HANDLE, LPWIN32_FIND_DATAW);
1777 HRSRC FindResourceA(HMODULE, LPCSTR, LPCSTR);
1778 HRSRC FindResourceW(HINSTANCE, LPCWSTR, LPCWSTR);
1779 HRSRC FindResourceExA(HINSTANCE, LPCSTR, LPCSTR, WORD);
1780 HRSRC FindResourceExW(HINSTANCE, LPCWSTR, LPCWSTR, WORD);
1781 BOOL FlushFileBuffers(HANDLE);
1782 BOOL FlushInstructionCache(HANDLE, PCVOID, SIZE_T);
1783 DWORD FormatMessageA(DWORD, PCVOID, DWORD, DWORD, LPSTR, DWORD, va_list*);
1784 DWORD FormatMessageW(DWORD, PCVOID, DWORD, DWORD, LPWSTR, DWORD, va_list*);
1785 BOOL FreeEnvironmentStringsA(LPSTR);
1786 BOOL FreeEnvironmentStringsW(LPWSTR);
1787 BOOL FreeLibrary(HMODULE);
1788 void FreeLibraryAndExitThread(HMODULE, DWORD); // never returns
1789 BOOL FreeResource(HGLOBAL);
1790 UINT GetAtomNameA(ATOM, LPSTR, int);
1791 UINT GetAtomNameW(ATOM, LPWSTR, int);
1792 LPSTR GetCommandLineA();
1793 LPWSTR GetCommandLineW();
1794 BOOL GetCommConfig(HANDLE, LPCOMMCONFIG, PDWORD);
1795 BOOL GetCommMask(HANDLE, PDWORD);
1796 BOOL GetCommModemStatus(HANDLE, PDWORD);
1797 BOOL GetCommProperties(HANDLE, LPCOMMPROP);
1798 BOOL GetCommState(HANDLE, LPDCB);
1799 BOOL GetCommTimeouts(HANDLE, LPCOMMTIMEOUTS);
1800 BOOL GetComputerNameA(LPSTR, PDWORD);
1801 BOOL GetComputerNameW(LPWSTR, PDWORD);
1802 DWORD GetCurrentDirectoryA(DWORD, LPSTR);
1803 DWORD GetCurrentDirectoryW(DWORD, LPWSTR);
1804 HANDLE GetCurrentProcess();
1805 DWORD GetCurrentProcessId();
1806 HANDLE GetCurrentThread();
1807 /* In MinGW:
1808 #ifdef _WIN32_WCE
1809 extern DWORD GetCurrentThreadId(void);
1810 #else
1811 WINBASEAPI DWORD WINAPI GetCurrentThreadId(void);
1812 #endif
1813 */
1814 DWORD GetCurrentThreadId();
1815
1816 alias GetTickCount GetCurrentTime;
1817
1818 BOOL GetDefaultCommConfigA(LPCSTR, LPCOMMCONFIG, PDWORD);
1819 BOOL GetDefaultCommConfigW(LPCWSTR, LPCOMMCONFIG, PDWORD);
1820 BOOL GetDiskFreeSpaceA(LPCSTR, PDWORD, PDWORD, PDWORD, PDWORD);
1821 BOOL GetDiskFreeSpaceW(LPCWSTR, PDWORD, PDWORD, PDWORD, PDWORD);
1822 BOOL GetDiskFreeSpaceExA(LPCSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER);
1823 BOOL GetDiskFreeSpaceExW(LPCWSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER);
1824 UINT GetDriveTypeA(LPCSTR);
1825 UINT GetDriveTypeW(LPCWSTR);
1826 LPSTR GetEnvironmentStringsA();
1827 LPWSTR GetEnvironmentStringsW();
1828 DWORD GetEnvironmentVariableA(LPCSTR, LPSTR, DWORD);
1829 DWORD GetEnvironmentVariableW(LPCWSTR, LPWSTR, DWORD);
1830 BOOL GetExitCodeProcess(HANDLE, PDWORD);
1831 BOOL GetExitCodeThread(HANDLE, PDWORD);
1832 DWORD GetFileAttributesA(LPCSTR);
1833 DWORD GetFileAttributesW(LPCWSTR);
1834 BOOL GetFileInformationByHandle(HANDLE, LPBY_HANDLE_FILE_INFORMATION);
1835 DWORD GetFileSize(HANDLE, PDWORD);
1836 BOOL GetFileTime(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME);
1837 DWORD GetFileType(HANDLE);
1838 DWORD GetFullPathNameA(LPCSTR, DWORD, LPSTR, LPSTR*);
1839 DWORD GetFullPathNameW(LPCWSTR, DWORD, LPWSTR, LPWSTR*);
1840 DWORD GetLastError() @trusted;
1841 void GetLocalTime(LPSYSTEMTIME);
1842 DWORD GetLogicalDrives();
1843 DWORD GetLogicalDriveStringsA(DWORD, LPSTR);
1844 DWORD GetLogicalDriveStringsW(DWORD, LPWSTR);
1845 BOOL GetMailslotInfo(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD);
1846 DWORD GetModuleFileNameA(HINSTANCE, LPSTR, DWORD);
1847 DWORD GetModuleFileNameW(HINSTANCE, LPWSTR, DWORD);
1848 HMODULE GetModuleHandleA(LPCSTR);
1849 HMODULE GetModuleHandleW(LPCWSTR);
1850 BOOL GetNamedPipeHandleStateA(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD, LPSTR, DWORD);
1851 BOOL GetNamedPipeHandleStateW(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD, LPWSTR, DWORD);
1852 BOOL GetNamedPipeInfo(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD);
1853 BOOL GetOverlappedResult(HANDLE, LPOVERLAPPED, PDWORD, BOOL);
1854 DWORD GetPriorityClass(HANDLE);
1855 UINT GetPrivateProfileIntA(LPCSTR, LPCSTR, INT, LPCSTR);
1856 UINT GetPrivateProfileIntW(LPCWSTR, LPCWSTR, INT, LPCWSTR);
1857 DWORD GetPrivateProfileSectionA(LPCSTR, LPSTR, DWORD, LPCSTR);
1858 DWORD GetPrivateProfileSectionW(LPCWSTR, LPWSTR, DWORD, LPCWSTR);
1859 DWORD GetPrivateProfileSectionNamesA(LPSTR, DWORD, LPCSTR);
1860 DWORD GetPrivateProfileSectionNamesW(LPWSTR, DWORD, LPCWSTR);
1861 DWORD GetPrivateProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPSTR, DWORD, LPCSTR);
1862 DWORD GetPrivateProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, DWORD, LPCWSTR);
1863 BOOL GetPrivateProfileStructA(LPCSTR, LPCSTR, LPVOID, UINT, LPCSTR);
1864 BOOL GetPrivateProfileStructW(LPCWSTR, LPCWSTR, LPVOID, UINT, LPCWSTR);
1865 FARPROC GetProcAddress(HMODULE, LPCSTR); // 1st param wrongly HINSTANCE in MinGW
1866 BOOL GetProcessAffinityMask(HANDLE, PDWORD_PTR, PDWORD_PTR);
1867 DWORD GetProcessVersion(DWORD);
1868 UINT GetProfileIntA(LPCSTR, LPCSTR, INT);
1869 UINT GetProfileIntW(LPCWSTR, LPCWSTR, INT);
1870 DWORD GetProfileSectionA(LPCSTR, LPSTR, DWORD);
1871 DWORD GetProfileSectionW(LPCWSTR, LPWSTR, DWORD);
1872 DWORD GetProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPSTR, DWORD);
1873 DWORD GetProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, DWORD);
1874 DWORD GetShortPathNameA(LPCSTR, LPSTR, DWORD);
1875 DWORD GetShortPathNameW(LPCWSTR, LPWSTR, DWORD);
1876 VOID GetStartupInfoA(LPSTARTUPINFOA);
1877 VOID GetStartupInfoW(LPSTARTUPINFOW);
1878 HANDLE GetStdHandle(DWORD);
1879 UINT GetSystemDirectoryA(LPSTR, UINT);
1880 UINT GetSystemDirectoryW(LPWSTR, UINT);
1881 VOID GetSystemInfo(LPSYSTEM_INFO);
1882 VOID GetSystemTime(LPSYSTEMTIME);
1883 BOOL GetSystemTimeAdjustment(PDWORD, PDWORD, PBOOL);
1884 void GetSystemTimeAsFileTime(LPFILETIME);
1885 UINT GetTempFileNameA(LPCSTR, LPCSTR, UINT, LPSTR);
1886 UINT GetTempFileNameW(LPCWSTR, LPCWSTR, UINT, LPWSTR);
1887 DWORD GetTempPathA(DWORD, LPSTR);
1888 DWORD GetTempPathW(DWORD, LPWSTR);
1889 BOOL GetThreadContext(HANDLE, LPCONTEXT);
1890 int GetThreadPriority(HANDLE);
1891 BOOL GetThreadSelectorEntry(HANDLE, DWORD, LPLDT_ENTRY);
1892 DWORD GetTickCount();
1893 DWORD GetTimeZoneInformation(LPTIME_ZONE_INFORMATION);
1894 BOOL GetUserNameA (LPSTR, PDWORD);
1895 BOOL GetUserNameW(LPWSTR, PDWORD);
1896 DWORD GetVersion();
1897 BOOL GetVersionExA(LPOSVERSIONINFOA);
1898 BOOL GetVersionExW(LPOSVERSIONINFOW);
1899 BOOL GetVolumeInformationA(LPCSTR, LPSTR, DWORD, PDWORD, PDWORD, PDWORD, LPSTR, DWORD);
1900 BOOL GetVolumeInformationW(LPCWSTR, LPWSTR, DWORD, PDWORD, PDWORD, PDWORD, LPWSTR, DWORD);
1901 UINT GetWindowsDirectoryA(LPSTR, UINT);
1902 UINT GetWindowsDirectoryW(LPWSTR, UINT);
1903 DWORD GetWindowThreadProcessId(HWND, PDWORD);
1904 ATOM GlobalAddAtomA(LPCSTR);
1905 ATOM GlobalAddAtomW(LPCWSTR);
1906 ATOM GlobalDeleteAtom(ATOM);
1907 ATOM GlobalFindAtomA(LPCSTR);
1908 ATOM GlobalFindAtomW(LPCWSTR);
1909 UINT GlobalGetAtomNameA(ATOM, LPSTR, int);
1910 UINT GlobalGetAtomNameW(ATOM, LPWSTR, int);
1911
1912 bool HasOverlappedIoCompleted(LPOVERLAPPED lpOverlapped) {
1913 return lpOverlapped.Internal != STATUS_PENDING;
1914 }
1915
1916 BOOL InitAtomTable(DWORD);
1917 VOID InitializeCriticalSection(LPCRITICAL_SECTION) @trusted;
1918 /* ??? The next two are allegedly obsolete and "supported only for
1919 * backward compatibility with the 16-bit Windows API". Yet the
1920 * replacements IsBadReadPtr and IsBadWritePtr are apparently Win2000+
1921 * only. Where's the mistake?
1922 */
1923 BOOL IsBadHugeReadPtr(PCVOID, UINT_PTR);
1924 BOOL IsBadHugeWritePtr(PVOID, UINT_PTR);
1925 BOOL IsBadReadPtr(PCVOID, UINT_PTR);
1926 BOOL IsBadStringPtrA(LPCSTR, UINT_PTR);
1927 BOOL IsBadStringPtrW(LPCWSTR, UINT_PTR);
1928 BOOL IsBadWritePtr(PVOID, UINT_PTR);
1929 void LeaveCriticalSection(LPCRITICAL_SECTION);
1930 void LeaveCriticalSection(shared(CRITICAL_SECTION)*);
1931 HINSTANCE LoadLibraryA(LPCSTR);
1932 HINSTANCE LoadLibraryW(LPCWSTR);
1933 HINSTANCE LoadLibraryExA(LPCSTR, HANDLE, DWORD);
1934 HINSTANCE LoadLibraryExW(LPCWSTR, HANDLE, DWORD);
1935 DWORD LoadModule(LPCSTR, PVOID);
1936 HGLOBAL LoadResource(HINSTANCE, HRSRC);
1937 BOOL LocalFileTimeToFileTime(const(FILETIME)*, LPFILETIME);
1938 BOOL LockFile(HANDLE, DWORD, DWORD, DWORD, DWORD);
1939 PVOID LockResource(HGLOBAL);
1940
1941 LPSTR lstrcatA(LPSTR, LPCSTR);
1942 LPWSTR lstrcatW(LPWSTR, LPCWSTR);
1943 int lstrcmpA(LPCSTR, LPCSTR);
1944 int lstrcmpiA(LPCSTR, LPCSTR);
1945 int lstrcmpiW(LPCWSTR, LPCWSTR);
1946 int lstrcmpW(LPCWSTR, LPCWSTR);
1947 LPSTR lstrcpyA(LPSTR, LPCSTR);
1948 LPSTR lstrcpynA(LPSTR, LPCSTR, int);
1949 LPWSTR lstrcpynW(LPWSTR, LPCWSTR, int);
1950 LPWSTR lstrcpyW(LPWSTR, LPCWSTR);
1951 int lstrlenA(LPCSTR);
1952 int lstrlenW(LPCWSTR);
1953
1954 BOOL MoveFileA(LPCSTR, LPCSTR);
1955 BOOL MoveFileW(LPCWSTR, LPCWSTR);
1956 int MulDiv(int, int, int);
1957 HANDLE OpenEventA(DWORD, BOOL, LPCSTR);
1958 HANDLE OpenEventW(DWORD, BOOL, LPCWSTR);
1959 deprecated HFILE OpenFile(LPCSTR, LPOFSTRUCT, UINT);
1960 HANDLE OpenMutexA(DWORD, BOOL, LPCSTR);
1961 HANDLE OpenMutexW(DWORD, BOOL, LPCWSTR);
1962 HANDLE OpenProcess(DWORD, BOOL, DWORD);
1963 HANDLE OpenSemaphoreA(DWORD, BOOL, LPCSTR);
1964 HANDLE OpenSemaphoreW(DWORD, BOOL, LPCWSTR);
1965 void OutputDebugStringA(LPCSTR);
1966 void OutputDebugStringW(LPCWSTR);
1967 BOOL PeekNamedPipe(HANDLE, PVOID, DWORD, PDWORD, PDWORD, PDWORD);
1968 BOOL PulseEvent(HANDLE);
1969 BOOL PurgeComm(HANDLE, DWORD);
1970 BOOL QueryPerformanceCounter(PLARGE_INTEGER);
1971 BOOL QueryPerformanceFrequency(PLARGE_INTEGER);
1972 DWORD QueueUserAPC(PAPCFUNC, HANDLE, ULONG_PTR);
1973 void RaiseException(DWORD, DWORD, DWORD, const(ULONG_PTR)*);
1974 BOOL ReadFile(HANDLE, PVOID, DWORD, PDWORD, LPOVERLAPPED);
1975 BOOL ReadFileEx(HANDLE, PVOID, DWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE);
1976 BOOL ReadProcessMemory(HANDLE, PCVOID, PVOID, SIZE_T, SIZE_T*);
1977 BOOL ReleaseMutex(HANDLE);
1978 BOOL ReleaseSemaphore(HANDLE, LONG, LPLONG);
1979 BOOL RemoveDirectoryA(LPCSTR);
1980 BOOL RemoveDirectoryW(LPCWSTR);
1981 /* In MinGW:
1982 #ifdef _WIN32_WCE
1983 extern BOOL ResetEvent(HANDLE);
1984 #else
1985 WINBASEAPI BOOL WINAPI ResetEvent(HANDLE);
1986 #endif
1987 */
1988 BOOL ResetEvent(HANDLE);
1989 DWORD ResumeThread(HANDLE);
1990 DWORD SearchPathA(LPCSTR, LPCSTR, LPCSTR, DWORD, LPSTR, LPSTR*);
1991 DWORD SearchPathW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPWSTR, LPWSTR*);
1992 BOOL SetCommBreak(HANDLE);
1993 BOOL SetCommConfig(HANDLE, LPCOMMCONFIG, DWORD);
1994 BOOL SetCommMask(HANDLE, DWORD);
1995 BOOL SetCommState(HANDLE, LPDCB);
1996 BOOL SetCommTimeouts(HANDLE, LPCOMMTIMEOUTS);
1997 BOOL SetComputerNameA(LPCSTR);
1998 BOOL SetComputerNameW(LPCWSTR);
1999 BOOL SetCurrentDirectoryA(LPCSTR);
2000 BOOL SetCurrentDirectoryW(LPCWSTR);
2001 BOOL SetDefaultCommConfigA(LPCSTR, LPCOMMCONFIG, DWORD);
2002 BOOL SetDefaultCommConfigW(LPCWSTR, LPCOMMCONFIG, DWORD);
2003 BOOL SetEndOfFile(HANDLE);
2004 BOOL SetEnvironmentVariableA(LPCSTR, LPCSTR);
2005 BOOL SetEnvironmentVariableW(LPCWSTR, LPCWSTR);
2006 UINT SetErrorMode(UINT);
2007 /* In MinGW:
2008 #ifdef _WIN32_WCE
2009 extern BOOL SetEvent(HANDLE);
2010 #else
2011 WINBASEAPI BOOL WINAPI SetEvent(HANDLE);
2012 #endif
2013 */
2014 BOOL SetEvent(HANDLE);
2015 VOID SetFileApisToANSI();
2016 VOID SetFileApisToOEM();
2017 BOOL SetFileAttributesA(LPCSTR, DWORD);
2018 BOOL SetFileAttributesW(LPCWSTR, DWORD);
2019 DWORD SetFilePointer(HANDLE, LONG, PLONG, DWORD);
2020 BOOL SetFileTime(HANDLE, const(FILETIME)*, const(FILETIME)*, const(FILETIME)*);
2021 deprecated UINT SetHandleCount(UINT);
2022 void SetLastError(DWORD);
2023 void SetLastErrorEx(DWORD, DWORD);
2024 BOOL SetLocalTime(const(SYSTEMTIME)*);
2025 BOOL SetMailslotInfo(HANDLE, DWORD);
2026 BOOL SetNamedPipeHandleState(HANDLE, PDWORD, PDWORD, PDWORD);
2027 BOOL SetPriorityClass(HANDLE, DWORD);
2028 BOOL SetStdHandle(DWORD, HANDLE);
2029 BOOL SetSystemTime(const(SYSTEMTIME)*);
2030 DWORD_PTR SetThreadAffinityMask(HANDLE, DWORD_PTR);
2031 BOOL SetThreadContext(HANDLE, const(CONTEXT)*);
2032 BOOL SetThreadPriority(HANDLE, int);
2033 BOOL SetTimeZoneInformation(const(TIME_ZONE_INFORMATION)*);
2034 LPTOP_LEVEL_EXCEPTION_FILTER SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER);
2035 BOOL SetupComm(HANDLE, DWORD, DWORD);
2036 BOOL SetVolumeLabelA(LPCSTR, LPCSTR);
2037 BOOL SetVolumeLabelW(LPCWSTR, LPCWSTR);
2038
2039 DWORD SizeofResource(HINSTANCE, HRSRC);
2040 void Sleep(DWORD);
2041 DWORD SleepEx(DWORD, BOOL);
2042 DWORD SuspendThread(HANDLE);
2043 BOOL SystemTimeToFileTime(const(SYSTEMTIME)*, LPFILETIME);
2044 BOOL TerminateProcess(HANDLE, UINT);
2045 BOOL TerminateThread(HANDLE, DWORD);
2046 DWORD TlsAlloc();
2047 BOOL TlsFree(DWORD);
2048 PVOID TlsGetValue(DWORD);
2049 BOOL TlsSetValue(DWORD, PVOID);
2050 BOOL TransactNamedPipe(HANDLE, PVOID, DWORD, PVOID, DWORD, PDWORD, LPOVERLAPPED);
2051 BOOL TransmitCommChar(HANDLE, char);
2052 LONG UnhandledExceptionFilter(LPEXCEPTION_POINTERS);
2053 BOOL UnlockFile(HANDLE, DWORD, DWORD, DWORD, DWORD);
2054 BOOL WaitCommEvent(HANDLE, PDWORD, LPOVERLAPPED);
2055 BOOL WaitForDebugEvent(LPDEBUG_EVENT, DWORD);
2056 DWORD WaitForMultipleObjects(DWORD, const(HANDLE)*, BOOL, DWORD);
2057 DWORD WaitForMultipleObjectsEx(DWORD, const(HANDLE)*, BOOL, DWORD, BOOL);
2058 DWORD WaitForSingleObject(HANDLE, DWORD);
2059 DWORD WaitForSingleObjectEx(HANDLE, DWORD, BOOL);
2060 BOOL WaitNamedPipeA(LPCSTR, DWORD);
2061 BOOL WaitNamedPipeW(LPCWSTR, DWORD);
2062 // undocumented on MSDN
2063 BOOL WinLoadTrustProvider(GUID*);
2064 BOOL WriteFile(HANDLE, PCVOID, DWORD, PDWORD, LPOVERLAPPED);
2065 BOOL WriteFileEx(HANDLE, PCVOID, DWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE);
2066 BOOL WritePrivateProfileSectionA(LPCSTR, LPCSTR, LPCSTR);
2067 BOOL WritePrivateProfileSectionW(LPCWSTR, LPCWSTR, LPCWSTR);
2068 BOOL WritePrivateProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPCSTR);
2069 BOOL WritePrivateProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR);
2070 BOOL WritePrivateProfileStructA(LPCSTR, LPCSTR, LPVOID, UINT, LPCSTR);
2071 BOOL WritePrivateProfileStructW(LPCWSTR, LPCWSTR, LPVOID, UINT, LPCWSTR);
2072 BOOL WriteProcessMemory(HANDLE, LPVOID, LPCVOID, SIZE_T, SIZE_T*);
2073 BOOL WriteProfileSectionA(LPCSTR, LPCSTR);
2074 BOOL WriteProfileSectionW(LPCWSTR, LPCWSTR);
2075 BOOL WriteProfileStringA(LPCSTR, LPCSTR, LPCSTR);
2076 BOOL WriteProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR);
2077
2078 /* Memory allocation functions.
2079 * MSDN documents these erroneously as Win2000+; thus it is uncertain what
2080 * version compatibility they really have.
2081 */
2082 HGLOBAL GlobalAlloc(UINT, SIZE_T);
2083 HGLOBAL GlobalDiscard(HGLOBAL);
2084 HGLOBAL GlobalFree(HGLOBAL);
2085 HGLOBAL GlobalHandle(PCVOID);
2086 LPVOID GlobalLock(HGLOBAL);
2087 VOID GlobalMemoryStatus(LPMEMORYSTATUS);
2088 HGLOBAL GlobalReAlloc(HGLOBAL, SIZE_T, UINT);
2089 SIZE_T GlobalSize(HGLOBAL);
2090 BOOL GlobalUnlock(HGLOBAL);
2091 PVOID HeapAlloc(HANDLE, DWORD, SIZE_T);
2092 SIZE_T HeapCompact(HANDLE, DWORD);
2093 HANDLE HeapCreate(DWORD, SIZE_T, SIZE_T);
2094 BOOL HeapDestroy(HANDLE);
2095 BOOL HeapFree(HANDLE, DWORD, PVOID);
2096 BOOL HeapLock(HANDLE);
2097 PVOID HeapReAlloc(HANDLE, DWORD, PVOID, SIZE_T);
2098 SIZE_T HeapSize(HANDLE, DWORD, PCVOID);
2099 BOOL HeapUnlock(HANDLE);
2100 BOOL HeapValidate(HANDLE, DWORD, PCVOID);
2101 BOOL HeapWalk(HANDLE, LPPROCESS_HEAP_ENTRY);
2102 HLOCAL LocalAlloc(UINT, SIZE_T);
2103 HLOCAL LocalDiscard(HLOCAL);
2104 HLOCAL LocalFree(HLOCAL);
2105 HLOCAL LocalHandle(LPCVOID);
2106 PVOID LocalLock(HLOCAL);
2107 HLOCAL LocalReAlloc(HLOCAL, SIZE_T, UINT);
2108 SIZE_T LocalSize(HLOCAL);
2109 BOOL LocalUnlock(HLOCAL);
2110 PVOID VirtualAlloc(PVOID, SIZE_T, DWORD, DWORD);
2111 PVOID VirtualAllocEx(HANDLE, PVOID, SIZE_T, DWORD, DWORD);
2112 BOOL VirtualFree(PVOID, SIZE_T, DWORD);
2113 BOOL VirtualFreeEx(HANDLE, PVOID, SIZE_T, DWORD);
2114 BOOL VirtualLock(PVOID, SIZE_T);
2115 BOOL VirtualProtect(PVOID, SIZE_T, DWORD, PDWORD);
2116 BOOL VirtualProtectEx(HANDLE, PVOID, SIZE_T, DWORD, PDWORD);
2117 SIZE_T VirtualQuery(LPCVOID, PMEMORY_BASIC_INFORMATION, SIZE_T);
2118 SIZE_T VirtualQueryEx(HANDLE, LPCVOID, PMEMORY_BASIC_INFORMATION, SIZE_T);
2119 BOOL VirtualUnlock(PVOID, SIZE_T);
2120 // not in MinGW 4.0 - ???
2121 static if (_WIN32_WINNT >= 0x600) {
2122 BOOL CancelIoEx(HANDLE, LPOVERLAPPED);
2123 }
2124
2125 BOOL CancelIo(HANDLE);
2126 BOOL CancelWaitableTimer(HANDLE);
2127 PVOID ConvertThreadToFiber(PVOID);
2128 LPVOID CreateFiber(SIZE_T, LPFIBER_START_ROUTINE, LPVOID);
2129 HANDLE CreateWaitableTimerA(LPSECURITY_ATTRIBUTES, BOOL, LPCSTR);
2130 HANDLE CreateWaitableTimerW(LPSECURITY_ATTRIBUTES, BOOL, LPCWSTR);
2131 void DeleteFiber(PVOID);
2132 BOOL GetFileAttributesExA(LPCSTR, GET_FILEEX_INFO_LEVELS, PVOID);
2133 BOOL GetFileAttributesExW(LPCWSTR, GET_FILEEX_INFO_LEVELS, PVOID);
2134 DWORD GetLongPathNameA(LPCSTR, LPSTR, DWORD);
2135 DWORD GetLongPathNameW(LPCWSTR, LPWSTR, DWORD);
2136 BOOL InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION, DWORD);
2137 BOOL IsDebuggerPresent();
2138 HANDLE OpenWaitableTimerA(DWORD, BOOL, LPCSTR);
2139 HANDLE OpenWaitableTimerW(DWORD, BOOL, LPCWSTR);
2140 DWORD QueryDosDeviceA(LPCSTR, LPSTR, DWORD);
2141 DWORD QueryDosDeviceW(LPCWSTR, LPWSTR, DWORD);
2142 BOOL SetWaitableTimer(HANDLE, const(LARGE_INTEGER)*, LONG, PTIMERAPCROUTINE, PVOID, BOOL);
2143 void SwitchToFiber(PVOID);
2144
2145 static if (_WIN32_WINNT >= 0x500) {
2146 HANDLE OpenThread(DWORD, BOOL, DWORD);
2147 }
2148
2149 BOOL AccessCheck(PSECURITY_DESCRIPTOR, HANDLE, DWORD, PGENERIC_MAPPING, PPRIVILEGE_SET, PDWORD, PDWORD, PBOOL);
2150 BOOL AccessCheckAndAuditAlarmA(LPCSTR, LPVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, BOOL, PDWORD, PBOOL, PBOOL);
2151 BOOL AccessCheckAndAuditAlarmW(LPCWSTR, LPVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, BOOL, PDWORD, PBOOL, PBOOL);
2152 BOOL AddAccessAllowedAce(PACL, DWORD, DWORD, PSID);
2153 BOOL AddAccessDeniedAce(PACL, DWORD, DWORD, PSID);
2154 BOOL AddAce(PACL, DWORD, DWORD, PVOID, DWORD);
2155 BOOL AddAuditAccessAce(PACL, DWORD, DWORD, PSID, BOOL, BOOL);
2156 BOOL AdjustTokenGroups(HANDLE, BOOL, PTOKEN_GROUPS, DWORD, PTOKEN_GROUPS, PDWORD);
2157 BOOL AdjustTokenPrivileges(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
2158 BOOL AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY, BYTE, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, PSID*);
2159 BOOL AllocateLocallyUniqueId(PLUID);
2160 BOOL AreAllAccessesGranted(DWORD, DWORD);
2161 BOOL AreAnyAccessesGranted(DWORD, DWORD);
2162 BOOL BackupEventLogA(HANDLE, LPCSTR);
2163 BOOL BackupEventLogW(HANDLE, LPCWSTR);
2164 BOOL BackupRead(HANDLE, LPBYTE, DWORD, LPDWORD, BOOL, BOOL, LPVOID*);
2165 BOOL BackupSeek(HANDLE, DWORD, DWORD, LPDWORD, LPDWORD, LPVOID*);
2166 BOOL BackupWrite(HANDLE, LPBYTE, DWORD, LPDWORD, BOOL, BOOL, LPVOID*);
2167 BOOL ClearEventLogA(HANDLE, LPCSTR);
2168 BOOL ClearEventLogW(HANDLE, LPCWSTR);
2169 BOOL CloseEventLog(HANDLE);
2170 BOOL ConnectNamedPipe(HANDLE, LPOVERLAPPED);
2171 BOOL CopySid(DWORD, PSID, PSID);
2172 HANDLE CreateNamedPipeA(LPCSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
2173 HANDLE CreateNamedPipeW(LPCWSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
2174 BOOL CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, BOOL, HANDLE, PGENERIC_MAPPING);
2175 BOOL CreateProcessAsUserA(HANDLE, LPCSTR, LPSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCSTR, LPSTARTUPINFOA, LPPROCESS_INFORMATION);
2176 BOOL CreateProcessAsUserW(HANDLE, LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION);
2177 HANDLE CreateRemoteThread(HANDLE, LPSECURITY_ATTRIBUTES, SIZE_T, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD);
2178 DWORD CreateTapePartition(HANDLE, DWORD, DWORD, DWORD);
2179 BOOL DefineDosDeviceA(DWORD, LPCSTR, LPCSTR);
2180 BOOL DefineDosDeviceW(DWORD, LPCWSTR, LPCWSTR);
2181 BOOL DeleteAce(PACL, DWORD);
2182 BOOL DeregisterEventSource(HANDLE);
2183 BOOL DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR*);
2184 BOOL DeviceIoControl(HANDLE, DWORD, PVOID, DWORD, PVOID, DWORD, PDWORD, POVERLAPPED);
2185 BOOL DisconnectNamedPipe(HANDLE);
2186 BOOL DuplicateToken(HANDLE, SECURITY_IMPERSONATION_LEVEL, PHANDLE);
2187 BOOL DuplicateTokenEx(HANDLE, DWORD, LPSECURITY_ATTRIBUTES, SECURITY_IMPERSONATION_LEVEL, TOKEN_TYPE, PHANDLE);
2188 BOOL EqualPrefixSid(PSID, PSID);
2189 BOOL EqualSid(PSID, PSID);
2190 DWORD EraseTape(HANDLE, DWORD, BOOL);
2191 HANDLE FindFirstFileExA(LPCSTR, FINDEX_INFO_LEVELS, PVOID, FINDEX_SEARCH_OPS, PVOID, DWORD);
2192 HANDLE FindFirstFileExW(LPCWSTR, FINDEX_INFO_LEVELS, PVOID, FINDEX_SEARCH_OPS, PVOID, DWORD);
2193 BOOL FindFirstFreeAce(PACL, PVOID*);
2194 PVOID FreeSid(PSID);
2195 BOOL GetAce(PACL, DWORD, LPVOID*);
2196 BOOL GetAclInformation(PACL, PVOID, DWORD, ACL_INFORMATION_CLASS);
2197 BOOL GetBinaryTypeA(LPCSTR, PDWORD);
2198 BOOL GetBinaryTypeW(LPCWSTR, PDWORD);
2199 DWORD GetCompressedFileSizeA(LPCSTR, PDWORD);
2200 DWORD GetCompressedFileSizeW(LPCWSTR, PDWORD);
2201 BOOL GetCurrentHwProfileA(LPHW_PROFILE_INFOA);
2202 BOOL GetCurrentHwProfileW(LPHW_PROFILE_INFOW);
2203 BOOL GetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD);
2204 BOOL GetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD);
2205 BOOL GetHandleInformation(HANDLE, PDWORD);
2206 BOOL GetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD);
2207 DWORD GetLengthSid(PSID);
2208 BOOL GetNumberOfEventLogRecords(HANDLE, PDWORD);
2209 BOOL GetOldestEventLogRecord(HANDLE, PDWORD);
2210 BOOL GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD);
2211 BOOL GetProcessPriorityBoost(HANDLE, PBOOL);
2212 BOOL GetProcessShutdownParameters(PDWORD, PDWORD);
2213 BOOL GetProcessTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
2214 HWINSTA GetProcessWindowStation();
2215 BOOL GetProcessWorkingSetSize(HANDLE, PSIZE_T, PSIZE_T);
2216 BOOL GetQueuedCompletionStatus(HANDLE, PDWORD, PULONG_PTR, LPOVERLAPPED*, DWORD);
2217 BOOL GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL, PDWORD);
2218 BOOL GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL);
2219 BOOL GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID*, LPBOOL);
2220 DWORD GetSecurityDescriptorLength(PSECURITY_DESCRIPTOR);
2221 BOOL GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID*, LPBOOL);
2222 BOOL GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL);
2223 PSID_IDENTIFIER_AUTHORITY GetSidIdentifierAuthority(PSID);
2224 DWORD GetSidLengthRequired(UCHAR);
2225 PDWORD GetSidSubAuthority(PSID, DWORD);
2226 PUCHAR GetSidSubAuthorityCount(PSID);
2227 DWORD GetTapeParameters(HANDLE, DWORD, PDWORD, PVOID);
2228 DWORD GetTapePosition(HANDLE, DWORD, PDWORD, PDWORD, PDWORD);
2229 DWORD GetTapeStatus(HANDLE);
2230 BOOL GetThreadPriorityBoost(HANDLE, PBOOL);
2231 BOOL GetThreadTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
2232 BOOL GetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, PVOID, DWORD, PDWORD);
2233 BOOL ImpersonateLoggedOnUser(HANDLE);
2234 BOOL ImpersonateNamedPipeClient(HANDLE);
2235 BOOL ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL);
2236 BOOL InitializeAcl(PACL, DWORD, DWORD);
2237 DWORD SetCriticalSectionSpinCount(LPCRITICAL_SECTION, DWORD);
2238 BOOL InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR, DWORD);
2239 BOOL InitializeSid(PSID, PSID_IDENTIFIER_AUTHORITY, BYTE);
2240 BOOL IsProcessorFeaturePresent(DWORD);
2241 BOOL IsTextUnicode(PCVOID, int, LPINT);
2242 BOOL IsValidAcl(PACL);
2243 BOOL IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR);
2244 BOOL IsValidSid(PSID);
2245 BOOL LockFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, LPOVERLAPPED);
2246 BOOL LogonUserA(LPSTR, LPSTR, LPSTR, DWORD, DWORD, PHANDLE);
2247 BOOL LogonUserW(LPWSTR, LPWSTR, LPWSTR, DWORD, DWORD, PHANDLE);
2248 BOOL LookupAccountNameA(LPCSTR, LPCSTR, PSID, PDWORD, LPSTR, PDWORD, PSID_NAME_USE);
2249 BOOL LookupAccountNameW(LPCWSTR, LPCWSTR, PSID, PDWORD, LPWSTR, PDWORD, PSID_NAME_USE);
2250 BOOL LookupAccountSidA(LPCSTR, PSID, LPSTR, PDWORD, LPSTR, PDWORD, PSID_NAME_USE);
2251 BOOL LookupAccountSidW(LPCWSTR, PSID, LPWSTR, PDWORD, LPWSTR, PDWORD, PSID_NAME_USE);
2252 BOOL LookupPrivilegeDisplayNameA(LPCSTR, LPCSTR, LPSTR, PDWORD, PDWORD);
2253 BOOL LookupPrivilegeDisplayNameW(LPCWSTR, LPCWSTR, LPWSTR, PDWORD, PDWORD);
2254 BOOL LookupPrivilegeNameA(LPCSTR, PLUID, LPSTR, PDWORD);
2255 BOOL LookupPrivilegeNameW(LPCWSTR, PLUID, LPWSTR, PDWORD);
2256 BOOL LookupPrivilegeValueA(LPCSTR, LPCSTR, PLUID);
2257 BOOL LookupPrivilegeValueW(LPCWSTR, LPCWSTR, PLUID);
2258 BOOL MakeAbsoluteSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PDWORD, PACL, PDWORD, PACL, PDWORD, PSID, PDWORD, PSID, PDWORD);
2259 BOOL MakeSelfRelativeSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PDWORD);
2260 VOID MapGenericMask(PDWORD, PGENERIC_MAPPING);
2261 BOOL MoveFileExA(LPCSTR, LPCSTR, DWORD);
2262 BOOL MoveFileExW(LPCWSTR, LPCWSTR, DWORD);
2263 BOOL NotifyChangeEventLog(HANDLE, HANDLE);
2264 BOOL ObjectCloseAuditAlarmA(LPCSTR, PVOID, BOOL);
2265 BOOL ObjectCloseAuditAlarmW(LPCWSTR, PVOID, BOOL);
2266 BOOL ObjectDeleteAuditAlarmA(LPCSTR, PVOID, BOOL);
2267 BOOL ObjectDeleteAuditAlarmW(LPCWSTR, PVOID, BOOL);
2268 BOOL ObjectOpenAuditAlarmA(LPCSTR, PVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, BOOL, BOOL, PBOOL);
2269 BOOL ObjectOpenAuditAlarmW(LPCWSTR, PVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, BOOL, BOOL, PBOOL);
2270 BOOL ObjectPrivilegeAuditAlarmA(LPCSTR, PVOID, HANDLE, DWORD, PPRIVILEGE_SET, BOOL);
2271 BOOL ObjectPrivilegeAuditAlarmW(LPCWSTR, PVOID, HANDLE, DWORD, PPRIVILEGE_SET, BOOL);
2272 HANDLE OpenBackupEventLogA(LPCSTR, LPCSTR);
2273 HANDLE OpenBackupEventLogW(LPCWSTR, LPCWSTR);
2274 HANDLE OpenEventLogA(LPCSTR, LPCSTR);
2275 HANDLE OpenEventLogW(LPCWSTR, LPCWSTR);
2276 BOOL OpenProcessToken(HANDLE, DWORD, PHANDLE);
2277 BOOL OpenThreadToken(HANDLE, DWORD, BOOL, PHANDLE);
2278 BOOL PostQueuedCompletionStatus(HANDLE, DWORD, ULONG_PTR, LPOVERLAPPED);
2279 DWORD PrepareTape(HANDLE, DWORD, BOOL);
2280 BOOL PrivilegeCheck(HANDLE, PPRIVILEGE_SET, PBOOL);
2281 BOOL PrivilegedServiceAuditAlarmA(LPCSTR, LPCSTR, HANDLE, PPRIVILEGE_SET, BOOL);
2282 BOOL PrivilegedServiceAuditAlarmW(LPCWSTR, LPCWSTR, HANDLE, PPRIVILEGE_SET, BOOL);
2283 BOOL ReadDirectoryChangesW(HANDLE, PVOID, DWORD, BOOL, DWORD, PDWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE);
2284 BOOL ReadEventLogA(HANDLE, DWORD, DWORD, PVOID, DWORD, DWORD*, DWORD*);
2285 BOOL ReadEventLogW(HANDLE, DWORD, DWORD, PVOID, DWORD, DWORD*, DWORD*);
2286 BOOL ReadFileScatter(HANDLE, FILE_SEGMENT_ELEMENT*, DWORD, LPDWORD, LPOVERLAPPED);
2287 HANDLE RegisterEventSourceA (LPCSTR, LPCSTR);
2288 HANDLE RegisterEventSourceW(LPCWSTR, LPCWSTR);
2289 BOOL ReportEventA(HANDLE, WORD, WORD, DWORD, PSID, WORD, DWORD, LPCSTR*, PVOID);
2290 BOOL ReportEventW(HANDLE, WORD, WORD, DWORD, PSID, WORD, DWORD, LPCWSTR*, PVOID);
2291 BOOL RevertToSelf();
2292 BOOL SetAclInformation(PACL, PVOID, DWORD, ACL_INFORMATION_CLASS);
2293 BOOL SetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
2294 BOOL SetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
2295 BOOL SetHandleInformation(HANDLE, DWORD, DWORD);
2296 BOOL SetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
2297 BOOL SetPrivateObjectSecurity(SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, PGENERIC_MAPPING, HANDLE);
2298 BOOL SetProcessAffinityMask(HANDLE, DWORD_PTR);
2299 BOOL SetProcessPriorityBoost(HANDLE, BOOL);
2300 BOOL SetProcessShutdownParameters(DWORD, DWORD);
2301 BOOL SetProcessWorkingSetSize(HANDLE, SIZE_T, SIZE_T);
2302 BOOL SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, BOOL, PACL, BOOL);
2303 BOOL SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID, BOOL);
2304 BOOL SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID, BOOL);
2305 BOOL SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, BOOL, PACL, BOOL);
2306 BOOL SetSystemTimeAdjustment(DWORD, BOOL);
2307 DWORD SetTapeParameters(HANDLE, DWORD, PVOID);
2308 DWORD SetTapePosition(HANDLE, DWORD, DWORD, DWORD, DWORD, BOOL);
2309 BOOL SetThreadPriorityBoost(HANDLE, BOOL);
2310 BOOL SetThreadToken(PHANDLE, HANDLE);
2311 BOOL SetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, PVOID, DWORD);
2312 DWORD SignalObjectAndWait(HANDLE, HANDLE, DWORD, BOOL);
2313 BOOL SwitchToThread();
2314 BOOL SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION, LPSYSTEMTIME, LPSYSTEMTIME);
2315 BOOL TzSpecificLocalTimeToSystemTime(LPTIME_ZONE_INFORMATION, LPSYSTEMTIME, LPSYSTEMTIME);
2316 BOOL TryEnterCriticalSection(LPCRITICAL_SECTION);
2317 BOOL TryEnterCriticalSection(shared(CRITICAL_SECTION)*);
2318 BOOL UnlockFileEx(HANDLE, DWORD, DWORD, DWORD, LPOVERLAPPED);
2319 BOOL UpdateResourceA(HANDLE, LPCSTR, LPCSTR, WORD, PVOID, DWORD);
2320 BOOL UpdateResourceW(HANDLE, LPCWSTR, LPCWSTR, WORD, PVOID, DWORD);
2321 BOOL WriteFileGather(HANDLE, FILE_SEGMENT_ELEMENT*, DWORD, LPDWORD, LPOVERLAPPED);
2322 DWORD WriteTapemark(HANDLE, DWORD, DWORD, BOOL);
2323
2324 static if (_WIN32_WINNT >= 0x500) {
2325 BOOL AddAccessAllowedAceEx(PACL, DWORD, DWORD, DWORD, PSID);
2326 BOOL AddAccessDeniedAceEx(PACL, DWORD, DWORD, DWORD, PSID);
2327 PVOID AddVectoredExceptionHandler(ULONG, PVECTORED_EXCEPTION_HANDLER);
2328 BOOL AllocateUserPhysicalPages(HANDLE, PULONG_PTR, PULONG_PTR);
2329 BOOL AssignProcessToJobObject(HANDLE, HANDLE);
2330 BOOL ChangeTimerQueueTimer(HANDLE,HANDLE,ULONG,ULONG);
2331 LPVOID CreateFiberEx(SIZE_T, SIZE_T, DWORD, LPFIBER_START_ROUTINE, LPVOID);
2332 HANDLE CreateFileMappingA(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCSTR);
2333 HANDLE CreateFileMappingW(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCWSTR);
2334 BOOL CreateHardLinkA(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES);
2335 BOOL CreateHardLinkW(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES);
2336 HANDLE CreateJobObjectA(LPSECURITY_ATTRIBUTES, LPCSTR);
2337 HANDLE CreateJobObjectW(LPSECURITY_ATTRIBUTES, LPCWSTR);
2338 BOOL CreateProcessWithLogonW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPCWSTR, LPWSTR, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION);
2339 HANDLE CreateTimerQueue();
2340 BOOL CreateTimerQueueTimer(PHANDLE, HANDLE, WAITORTIMERCALLBACK, PVOID, DWORD, DWORD, ULONG);
2341 BOOL DeleteTimerQueue(HANDLE);
2342 BOOL DeleteTimerQueueEx(HANDLE, HANDLE);
2343 BOOL DeleteTimerQueueTimer(HANDLE, HANDLE, HANDLE);
2344 BOOL DeleteVolumeMountPointA(LPCSTR);
2345 BOOL DeleteVolumeMountPointW(LPCWSTR);
2346 BOOL DnsHostnameToComputerNameA(LPCSTR, LPSTR, LPDWORD);
2347 BOOL DnsHostnameToComputerNameW(LPCWSTR, LPWSTR, LPDWORD);
2348 BOOL EncryptFileA(LPCSTR);
2349 BOOL EncryptFileW(LPCWSTR);
2350 BOOL FileEncryptionStatusA(LPCSTR, LPDWORD);
2351 BOOL FileEncryptionStatusW(LPCWSTR, LPDWORD);
2352 HANDLE FindFirstVolumeA(LPCSTR, DWORD);
2353 HANDLE FindFirstVolumeMountPointA(LPSTR, LPSTR, DWORD);
2354 HANDLE FindFirstVolumeMountPointW(LPWSTR, LPWSTR, DWORD);
2355 HANDLE FindFirstVolumeW(LPCWSTR, DWORD);
2356 BOOL FindNextVolumeA(HANDLE, LPCSTR, DWORD);
2357 BOOL FindNextVolumeW(HANDLE, LPWSTR, DWORD);
2358 BOOL FindNextVolumeMountPointA(HANDLE, LPSTR, DWORD);
2359 BOOL FindNextVolumeMountPointW(HANDLE, LPWSTR, DWORD);
2360 BOOL FindVolumeClose(HANDLE);
2361 BOOL FindVolumeMountPointClose(HANDLE);
2362 BOOL FlushViewOfFile(PCVOID, SIZE_T);
2363 BOOL FreeUserPhysicalPages(HANDLE, PULONG_PTR, PULONG_PTR);
2364 BOOL GetComputerNameExA(COMPUTER_NAME_FORMAT, LPSTR, LPDWORD);
2365 BOOL GetComputerNameExW(COMPUTER_NAME_FORMAT, LPWSTR, LPDWORD);
2366 BOOL GetFileSizeEx(HANDLE, PLARGE_INTEGER);
2367 BOOL GetModuleHandleExA(DWORD, LPCSTR, HMODULE*);
2368 BOOL GetModuleHandleExW(DWORD, LPCWSTR, HMODULE*);
2369 HANDLE GetProcessHeap();
2370 DWORD GetProcessHeaps(DWORD, PHANDLE);
2371 BOOL GetProcessIoCounters(HANDLE, PIO_COUNTERS);
2372 BOOL GetSystemPowerStatus(LPSYSTEM_POWER_STATUS);
2373 UINT GetSystemWindowsDirectoryA(LPSTR, UINT);
2374 UINT GetSystemWindowsDirectoryW(LPWSTR, UINT);
2375 BOOL GetVolumeNameForVolumeMountPointA(LPCSTR, LPSTR, DWORD);
2376 BOOL GetVolumeNameForVolumeMountPointW(LPCWSTR, LPWSTR, DWORD);
2377 BOOL GetVolumePathNameA(LPCSTR, LPSTR, DWORD);
2378 BOOL GetVolumePathNameW(LPCWSTR, LPWSTR, DWORD);
2379 BOOL GlobalMemoryStatusEx(LPMEMORYSTATUSEX);
2380 BOOL IsBadCodePtr(FARPROC);
2381 BOOL IsSystemResumeAutomatic();
2382 BOOL MapUserPhysicalPages(PVOID, ULONG_PTR, PULONG_PTR);
2383 BOOL MapUserPhysicalPagesScatter(PVOID*, ULONG_PTR, PULONG_PTR);
2384 PVOID MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, SIZE_T);
2385 PVOID MapViewOfFileEx(HANDLE, DWORD, DWORD, DWORD, SIZE_T, PVOID);
2386 HANDLE OpenFileMappingA(DWORD, BOOL, LPCSTR);
2387 HANDLE OpenFileMappingW(DWORD, BOOL, LPCWSTR);
2388 BOOL ProcessIdToSessionId(DWORD, DWORD*);
2389 BOOL QueryInformationJobObject(HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD, LPDWORD);
2390 ULONG RemoveVectoredExceptionHandler(PVOID);
2391 BOOL ReplaceFileA(LPCSTR, LPCSTR, LPCSTR, DWORD, LPVOID, LPVOID);
2392 BOOL ReplaceFileW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPVOID, LPVOID);
2393 BOOL SetComputerNameExA(COMPUTER_NAME_FORMAT, LPCSTR);
2394 BOOL SetComputerNameExW(COMPUTER_NAME_FORMAT, LPCWSTR);
2395 BOOL SetFilePointerEx(HANDLE, LARGE_INTEGER, PLARGE_INTEGER, DWORD);
2396 BOOL SetInformationJobObject(HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD);
2397 BOOL SetSecurityDescriptorControl(PSECURITY_DESCRIPTOR, SECURITY_DESCRIPTOR_CONTROL, SECURITY_DESCRIPTOR_CONTROL);
2398 BOOL SetSystemPowerState(BOOL, BOOL);
2399 EXECUTION_STATE SetThreadExecutionState(EXECUTION_STATE);
2400 DWORD SetThreadIdealProcessor(HANDLE, DWORD);
2401 BOOL SetVolumeMountPointA(LPCSTR, LPCSTR);
2402 BOOL SetVolumeMountPointW(LPCWSTR, LPCWSTR);
2403 BOOL TerminateJobObject(HANDLE, UINT);
2404 BOOL UnmapViewOfFile(PCVOID);
2405 BOOL UnregisterWait(HANDLE);
2406 BOOL UnregisterWaitEx(HANDLE, HANDLE);
2407 BOOL VerifyVersionInfoA(LPOSVERSIONINFOEXA, DWORD, DWORDLONG);
2408 BOOL VerifyVersionInfoW(LPOSVERSIONINFOEXW, DWORD, DWORDLONG);
2409 }
2410
2411 static if (_WIN32_WINNT >= 0x501) {
2412 BOOL ActivateActCtx(HANDLE, ULONG_PTR*);
2413 void AddRefActCtx(HANDLE);
2414 BOOL CheckNameLegalDOS8Dot3A(LPCSTR, LPSTR, DWORD, PBOOL, PBOOL);
2415 BOOL CheckNameLegalDOS8Dot3W(LPCWSTR, LPSTR, DWORD, PBOOL, PBOOL);
2416 BOOL CheckRemoteDebuggerPresent(HANDLE, PBOOL);
2417 BOOL ConvertFiberToThread();
2418 HANDLE CreateActCtxA(PCACTCTXA);
2419 HANDLE CreateActCtxW(PCACTCTXW);
2420 HANDLE CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE);
2421 BOOL DeactivateActCtx(DWORD, ULONG_PTR);
2422 BOOL DebugActiveProcessStop(DWORD);
2423 BOOL DebugBreakProcess(HANDLE);
2424 BOOL DebugSetProcessKillOnExit(BOOL);
2425 BOOL FindActCtxSectionGuid(DWORD, const(GUID)*, ULONG, const(GUID)*,
2426 PACTCTX_SECTION_KEYED_DATA);
2427 BOOL FindActCtxSectionStringA(DWORD, const(GUID)*, ULONG, LPCSTR,
2428 PACTCTX_SECTION_KEYED_DATA);
2429 BOOL FindActCtxSectionStringW(DWORD, const(GUID)*, ULONG, LPCWSTR,
2430 PACTCTX_SECTION_KEYED_DATA);
2431 BOOL GetCurrentActCtx(HANDLE*);
2432 VOID GetNativeSystemInfo(LPSYSTEM_INFO);
2433 BOOL GetProcessHandleCount(HANDLE, PDWORD);
2434 BOOL GetSystemRegistryQuota(PDWORD, PDWORD);
2435 BOOL GetSystemTimes(LPFILETIME, LPFILETIME, LPFILETIME);
2436 UINT GetSystemWow64DirectoryA(LPSTR, UINT);
2437 UINT GetSystemWow64DirectoryW(LPWSTR, UINT);
2438 BOOL GetThreadIOPendingFlag(HANDLE, PBOOL);
2439 BOOL GetVolumePathNamesForVolumeNameA(LPCSTR, LPSTR, DWORD, PDWORD);
2440 BOOL GetVolumePathNamesForVolumeNameW(LPCWSTR, LPWSTR, DWORD, PDWORD);
2441 UINT GetWriteWatch(DWORD, PVOID, SIZE_T, PVOID*, PULONG_PTR, PULONG);
2442 BOOL HeapQueryInformation(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T, PSIZE_T);
2443 BOOL HeapSetInformation(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T);
2444 BOOL IsProcessInJob(HANDLE, HANDLE, PBOOL);
2445 BOOL IsWow64Process(HANDLE, PBOOL);
2446 BOOL QueryActCtxW(DWORD, HANDLE, PVOID, ULONG, PVOID, SIZE_T, SIZE_T*);
2447 BOOL QueryMemoryResourceNotification(HANDLE, PBOOL);
2448 void ReleaseActCtx(HANDLE);
2449 UINT ResetWriteWatch(LPVOID, SIZE_T);
2450 BOOL SetFileShortNameA(HANDLE, LPCSTR);
2451 BOOL SetFileShortNameW(HANDLE, LPCWSTR);
2452 BOOL SetFileValidData(HANDLE, LONGLONG);
2453 BOOL ZombifyActCtx(HANDLE);
2454 }
2455
2456 static if (_WIN32_WINNT >= 0x502) {
2457 DWORD GetFirmwareEnvironmentVariableA(LPCSTR, LPCSTR, PVOID, DWORD);
2458 DWORD GetFirmwareEnvironmentVariableW(LPCWSTR, LPCWSTR, PVOID, DWORD);
2459 DWORD GetDllDirectoryA(DWORD, LPSTR);
2460 DWORD GetDllDirectoryW(DWORD, LPWSTR);
2461 DWORD GetThreadId(HANDLE);
2462 DWORD GetProcessId(HANDLE);
2463 HANDLE ReOpenFile(HANDLE, DWORD, DWORD, DWORD);
2464 BOOL SetDllDirectoryA(LPCSTR);
2465 BOOL SetDllDirectoryW(LPCWSTR);
2466 BOOL SetFirmwareEnvironmentVariableA(LPCSTR, LPCSTR, PVOID, DWORD);
2467 BOOL SetFirmwareEnvironmentVariableW(LPCWSTR, LPCWSTR, PVOID, DWORD);
2468 }
2469
2470 // ???
2471 static if (_WIN32_WINNT >= 0x510) {
2472 VOID RestoreLastError(DWORD);
2473 }
2474 }
2475
2476 // For compatibility with old core.sys.windows.windows:
2477 version (LittleEndian) nothrow @nogc
2478 {
2479 BOOL QueryPerformanceCounter(long* lpPerformanceCount) { return QueryPerformanceCounter(cast(PLARGE_INTEGER)lpPerformanceCount); }
2480 BOOL QueryPerformanceFrequency(long* lpFrequency) { return QueryPerformanceFrequency(cast(PLARGE_INTEGER)lpFrequency); }
2481 }
2482
2483 mixin DECLARE_AW!("STARTUPINFO");
2484 version (Unicode) {
2485 //alias STARTUPINFOW STARTUPINFO;
2486 alias WIN32_FIND_DATAW WIN32_FIND_DATA;
2487 alias ENUMRESLANGPROCW ENUMRESLANGPROC;
2488 alias ENUMRESNAMEPROCW ENUMRESNAMEPROC;
2489 alias ENUMRESTYPEPROCW ENUMRESTYPEPROC;
2490 alias AddAtomW AddAtom;
2491 alias BeginUpdateResourceW BeginUpdateResource;
2492 alias BuildCommDCBW BuildCommDCB;
2493 alias BuildCommDCBAndTimeoutsW BuildCommDCBAndTimeouts;
2494 alias CallNamedPipeW CallNamedPipe;
2495 alias CommConfigDialogW CommConfigDialog;
2496 alias CopyFileW CopyFile;
2497 alias CopyFileExW CopyFileEx;
2498 alias CreateDirectoryW CreateDirectory;
2499 alias CreateDirectoryExW CreateDirectoryEx;
2500 alias CreateEventW CreateEvent;
2501 alias CreateFileW CreateFile;
2502 alias CreateMailslotW CreateMailslot;
2503 alias CreateMutexW CreateMutex;
2504 alias CreateProcessW CreateProcess;
2505 alias CreateSemaphoreW CreateSemaphore;
2506 alias DeleteFileW DeleteFile;
2507 alias EndUpdateResourceW EndUpdateResource;
2508 alias EnumResourceLanguagesW EnumResourceLanguages;
2509 alias EnumResourceNamesW EnumResourceNames;
2510 alias EnumResourceTypesW EnumResourceTypes;
2511 alias ExpandEnvironmentStringsW ExpandEnvironmentStrings;
2512 alias FatalAppExitW FatalAppExit;
2513 alias FindAtomW FindAtom;
2514 alias FindFirstChangeNotificationW FindFirstChangeNotification;
2515 alias FindFirstFileW FindFirstFile;
2516 alias FindNextFileW FindNextFile;
2517 alias FindResourceW FindResource;
2518 alias FindResourceExW FindResourceEx;
2519 alias FormatMessageW FormatMessage;
2520 alias FreeEnvironmentStringsW FreeEnvironmentStrings;
2521 alias GetAtomNameW GetAtomName;
2522 alias GetCommandLineW GetCommandLine;
2523 alias GetComputerNameW GetComputerName;
2524 alias GetCurrentDirectoryW GetCurrentDirectory;
2525 alias GetDefaultCommConfigW GetDefaultCommConfig;
2526 alias GetDiskFreeSpaceW GetDiskFreeSpace;
2527 alias GetDiskFreeSpaceExW GetDiskFreeSpaceEx;
2528 alias GetDriveTypeW GetDriveType;
2529 alias GetEnvironmentStringsW GetEnvironmentStrings;
2530 alias GetEnvironmentVariableW GetEnvironmentVariable;
2531 alias GetFileAttributesW GetFileAttributes;
2532 alias GetFullPathNameW GetFullPathName;
2533 alias GetLogicalDriveStringsW GetLogicalDriveStrings;
2534 alias GetModuleFileNameW GetModuleFileName;
2535 alias GetModuleHandleW GetModuleHandle;
2536 alias GetNamedPipeHandleStateW GetNamedPipeHandleState;
2537 alias GetPrivateProfileIntW GetPrivateProfileInt;
2538 alias GetPrivateProfileSectionW GetPrivateProfileSection;
2539 alias GetPrivateProfileSectionNamesW GetPrivateProfileSectionNames;
2540 alias GetPrivateProfileStringW GetPrivateProfileString;
2541 alias GetPrivateProfileStructW GetPrivateProfileStruct;
2542 alias GetProfileIntW GetProfileInt;
2543 alias GetProfileSectionW GetProfileSection;
2544 alias GetProfileStringW GetProfileString;
2545 alias GetShortPathNameW GetShortPathName;
2546 alias GetStartupInfoW GetStartupInfo;
2547 alias GetSystemDirectoryW GetSystemDirectory;
2548 alias GetTempFileNameW GetTempFileName;
2549 alias GetTempPathW GetTempPath;
2550 alias GetUserNameW GetUserName;
2551 alias GetVersionExW GetVersionEx;
2552 alias GetVolumeInformationW GetVolumeInformation;
2553 alias GetWindowsDirectoryW GetWindowsDirectory;
2554 alias GlobalAddAtomW GlobalAddAtom;
2555 alias GlobalFindAtomW GlobalFindAtom;
2556 alias GlobalGetAtomNameW GlobalGetAtomName;
2557 alias IsBadStringPtrW IsBadStringPtr;
2558 alias LoadLibraryW LoadLibrary;
2559 alias LoadLibraryExW LoadLibraryEx;
2560 alias lstrcatW lstrcat;
2561 alias lstrcmpW lstrcmp;
2562 alias lstrcmpiW lstrcmpi;
2563 alias lstrcpyW lstrcpy;
2564 alias lstrcpynW lstrcpyn;
2565 alias lstrlenW lstrlen;
2566 alias MoveFileW MoveFile;
2567 alias OpenEventW OpenEvent;
2568 alias OpenMutexW OpenMutex;
2569 alias OpenSemaphoreW OpenSemaphore;
2570 alias OutputDebugStringW OutputDebugString;
2571 alias RemoveDirectoryW RemoveDirectory;
2572 alias SearchPathW SearchPath;
2573 alias SetComputerNameW SetComputerName;
2574 alias SetCurrentDirectoryW SetCurrentDirectory;
2575 alias SetDefaultCommConfigW SetDefaultCommConfig;
2576 alias SetEnvironmentVariableW SetEnvironmentVariable;
2577 alias SetFileAttributesW SetFileAttributes;
2578 alias SetVolumeLabelW SetVolumeLabel;
2579 alias WaitNamedPipeW WaitNamedPipe;
2580 alias WritePrivateProfileSectionW WritePrivateProfileSection;
2581 alias WritePrivateProfileStringW WritePrivateProfileString;
2582 alias WritePrivateProfileStructW WritePrivateProfileStruct;
2583 alias WriteProfileSectionW WriteProfileSection;
2584 alias WriteProfileStringW WriteProfileString;
2585 alias CreateWaitableTimerW CreateWaitableTimer;
2586 alias GetFileAttributesExW GetFileAttributesEx;
2587 alias GetLongPathNameW GetLongPathName;
2588 alias QueryDosDeviceW QueryDosDevice;
2589
2590 alias HW_PROFILE_INFOW HW_PROFILE_INFO;
2591 alias AccessCheckAndAuditAlarmW AccessCheckAndAuditAlarm;
2592 alias BackupEventLogW BackupEventLog;
2593 alias ClearEventLogW ClearEventLog;
2594 alias CreateNamedPipeW CreateNamedPipe;
2595 alias CreateProcessAsUserW CreateProcessAsUser;
2596 alias DefineDosDeviceW DefineDosDevice;
2597 alias FindFirstFileExW FindFirstFileEx;
2598 alias GetBinaryTypeW GetBinaryType;
2599 alias GetCompressedFileSizeW GetCompressedFileSize;
2600 alias GetFileSecurityW GetFileSecurity;
2601 alias LogonUserW LogonUser;
2602 alias LookupAccountNameW LookupAccountName;
2603 alias LookupAccountSidW LookupAccountSid;
2604 alias LookupPrivilegeDisplayNameW LookupPrivilegeDisplayName;
2605 alias LookupPrivilegeNameW LookupPrivilegeName;
2606 alias LookupPrivilegeValueW LookupPrivilegeValue;
2607 alias MoveFileExW MoveFileEx;
2608 alias ObjectCloseAuditAlarmW ObjectCloseAuditAlarm;
2609 alias ObjectDeleteAuditAlarmW ObjectDeleteAuditAlarm;
2610 alias ObjectOpenAuditAlarmW ObjectOpenAuditAlarm;
2611 alias ObjectPrivilegeAuditAlarmW ObjectPrivilegeAuditAlarm;
2612 alias OpenBackupEventLogW OpenBackupEventLog;
2613 alias OpenEventLogW OpenEventLog;
2614 alias PrivilegedServiceAuditAlarmW PrivilegedServiceAuditAlarm;
2615 alias ReadEventLogW ReadEventLog;
2616 alias RegisterEventSourceW RegisterEventSource;
2617 alias ReportEventW ReportEvent;
2618 alias SetFileSecurityW SetFileSecurity;
2619 alias UpdateResourceW UpdateResource;
2620
2621 static if (_WIN32_WINNT >= 0x500) {
2622 alias CreateFileMappingW CreateFileMapping;
2623 alias CreateHardLinkW CreateHardLink;
2624 alias CreateJobObjectW CreateJobObject;
2625 alias DeleteVolumeMountPointW DeleteVolumeMountPoint;
2626 alias DnsHostnameToComputerNameW DnsHostnameToComputerName;
2627 alias EncryptFileW EncryptFile;
2628 alias FileEncryptionStatusW FileEncryptionStatus;
2629 alias FindFirstVolumeW FindFirstVolume;
2630 alias FindFirstVolumeMountPointW FindFirstVolumeMountPoint;
2631 alias FindNextVolumeW FindNextVolume;
2632 alias FindNextVolumeMountPointW FindNextVolumeMountPoint;
2633 alias GetModuleHandleExW GetModuleHandleEx;
2634 alias GetSystemWindowsDirectoryW GetSystemWindowsDirectory;
2635 alias GetVolumeNameForVolumeMountPointW GetVolumeNameForVolumeMountPoint;
2636 alias GetVolumePathNameW GetVolumePathName;
2637 alias OpenFileMappingW OpenFileMapping;
2638 alias ReplaceFileW ReplaceFile;
2639 alias SetVolumeMountPointW SetVolumeMountPoint;
2640 alias VerifyVersionInfoW VerifyVersionInfo;
2641 }
2642
2643 static if (_WIN32_WINNT >= 0x501) {
2644 alias ACTCTXW ACTCTX;
2645 alias CheckNameLegalDOS8Dot3W CheckNameLegalDOS8Dot3;
2646 alias CreateActCtxW CreateActCtx;
2647 alias FindActCtxSectionStringW FindActCtxSectionString;
2648 alias GetSystemWow64DirectoryW GetSystemWow64Directory;
2649 alias GetVolumePathNamesForVolumeNameW GetVolumePathNamesForVolumeName;
2650 alias SetFileShortNameW SetFileShortName;
2651 }
2652
2653 static if (_WIN32_WINNT >= 0x502) {
2654 alias SetFirmwareEnvironmentVariableW SetFirmwareEnvironmentVariable;
2655 alias SetDllDirectoryW SetDllDirectory;
2656 alias GetDllDirectoryW GetDllDirectory;
2657 }
2658
2659 } else {
2660 //alias STARTUPINFOA STARTUPINFO;
2661 alias WIN32_FIND_DATAA WIN32_FIND_DATA;
2662 alias ENUMRESLANGPROCW ENUMRESLANGPROC;
2663 alias ENUMRESNAMEPROCW ENUMRESNAMEPROC;
2664 alias ENUMRESTYPEPROCW ENUMRESTYPEPROC;
2665 alias AddAtomA AddAtom;
2666 alias BeginUpdateResourceA BeginUpdateResource;
2667 alias BuildCommDCBA BuildCommDCB;
2668 alias BuildCommDCBAndTimeoutsA BuildCommDCBAndTimeouts;
2669 alias CallNamedPipeA CallNamedPipe;
2670 alias CommConfigDialogA CommConfigDialog;
2671 alias CopyFileA CopyFile;
2672 alias CopyFileExA CopyFileEx;
2673 alias CreateDirectoryA CreateDirectory;
2674 alias CreateDirectoryExA CreateDirectoryEx;
2675 alias CreateEventA CreateEvent;
2676 alias CreateFileA CreateFile;
2677 alias CreateMailslotA CreateMailslot;
2678 alias CreateMutexA CreateMutex;
2679 alias CreateProcessA CreateProcess;
2680 alias CreateSemaphoreA CreateSemaphore;
2681 alias DeleteFileA DeleteFile;
2682 alias EndUpdateResourceA EndUpdateResource;
2683 alias EnumResourceLanguagesA EnumResourceLanguages;
2684 alias EnumResourceNamesA EnumResourceNames;
2685 alias EnumResourceTypesA EnumResourceTypes;
2686 alias ExpandEnvironmentStringsA ExpandEnvironmentStrings;
2687 alias FatalAppExitA FatalAppExit;
2688 alias FindAtomA FindAtom;
2689 alias FindFirstChangeNotificationA FindFirstChangeNotification;
2690 alias FindFirstFileA FindFirstFile;
2691 alias FindNextFileA FindNextFile;
2692 alias FindResourceA FindResource;
2693 alias FindResourceExA FindResourceEx;
2694 alias FormatMessageA FormatMessage;
2695 alias FreeEnvironmentStringsA FreeEnvironmentStrings;
2696 alias GetAtomNameA GetAtomName;
2697 alias GetCommandLineA GetCommandLine;
2698 alias GetComputerNameA GetComputerName;
2699 alias GetCurrentDirectoryA GetCurrentDirectory;
2700 alias GetDefaultCommConfigA GetDefaultCommConfig;
2701 alias GetDiskFreeSpaceA GetDiskFreeSpace;
2702 alias GetDiskFreeSpaceExA GetDiskFreeSpaceEx;
2703 alias GetDriveTypeA GetDriveType;
2704 alias GetEnvironmentStringsA GetEnvironmentStrings;
2705 alias GetEnvironmentVariableA GetEnvironmentVariable;
2706 alias GetFileAttributesA GetFileAttributes;
2707 alias GetFullPathNameA GetFullPathName;
2708 alias GetLogicalDriveStringsA GetLogicalDriveStrings;
2709 alias GetNamedPipeHandleStateA GetNamedPipeHandleState;
2710 alias GetModuleHandleA GetModuleHandle;
2711 alias GetModuleFileNameA GetModuleFileName;
2712 alias GetPrivateProfileIntA GetPrivateProfileInt;
2713 alias GetPrivateProfileSectionA GetPrivateProfileSection;
2714 alias GetPrivateProfileSectionNamesA GetPrivateProfileSectionNames;
2715 alias GetPrivateProfileStringA GetPrivateProfileString;
2716 alias GetPrivateProfileStructA GetPrivateProfileStruct;
2717 alias GetProfileIntA GetProfileInt;
2718 alias GetProfileSectionA GetProfileSection;
2719 alias GetProfileStringA GetProfileString;
2720 alias GetShortPathNameA GetShortPathName;
2721 alias GetStartupInfoA GetStartupInfo;
2722 alias GetSystemDirectoryA GetSystemDirectory;
2723 alias GetTempFileNameA GetTempFileName;
2724 alias GetTempPathA GetTempPath;
2725 alias GetUserNameA GetUserName;
2726 alias GetVersionExA GetVersionEx;
2727 alias GetVolumeInformationA GetVolumeInformation;
2728 alias GetWindowsDirectoryA GetWindowsDirectory;
2729 alias GlobalAddAtomA GlobalAddAtom;
2730 alias GlobalFindAtomA GlobalFindAtom;
2731 alias GlobalGetAtomNameA GlobalGetAtomName;
2732 alias IsBadStringPtrA IsBadStringPtr;
2733 alias LoadLibraryA LoadLibrary;
2734 alias LoadLibraryExA LoadLibraryEx;
2735 alias lstrcatA lstrcat;
2736 alias lstrcmpA lstrcmp;
2737 alias lstrcmpiA lstrcmpi;
2738 alias lstrcpyA lstrcpy;
2739 alias lstrcpynA lstrcpyn;
2740 alias lstrlenA lstrlen;
2741 alias MoveFileA MoveFile;
2742 alias OpenEventA OpenEvent;
2743 alias OpenMutexA OpenMutex;
2744 alias OpenSemaphoreA OpenSemaphore;
2745 alias OutputDebugStringA OutputDebugString;
2746 alias RemoveDirectoryA RemoveDirectory;
2747 alias SearchPathA SearchPath;
2748 alias SetComputerNameA SetComputerName;
2749 alias SetCurrentDirectoryA SetCurrentDirectory;
2750 alias SetDefaultCommConfigA SetDefaultCommConfig;
2751 alias SetEnvironmentVariableA SetEnvironmentVariable;
2752 alias SetFileAttributesA SetFileAttributes;
2753 alias SetVolumeLabelA SetVolumeLabel;
2754 alias WaitNamedPipeA WaitNamedPipe;
2755 alias WritePrivateProfileSectionA WritePrivateProfileSection;
2756 alias WritePrivateProfileStringA WritePrivateProfileString;
2757 alias WritePrivateProfileStructA WritePrivateProfileStruct;
2758 alias WriteProfileSectionA WriteProfileSection;
2759 alias WriteProfileStringA WriteProfileString;
2760 alias CreateWaitableTimerA CreateWaitableTimer;
2761 alias GetFileAttributesExA GetFileAttributesEx;
2762 alias GetLongPathNameA GetLongPathName;
2763 alias QueryDosDeviceA QueryDosDevice;
2764
2765 alias HW_PROFILE_INFOA HW_PROFILE_INFO;
2766 alias AccessCheckAndAuditAlarmA AccessCheckAndAuditAlarm;
2767 alias BackupEventLogA BackupEventLog;
2768 alias ClearEventLogA ClearEventLog;
2769 alias CreateNamedPipeA CreateNamedPipe;
2770 alias CreateProcessAsUserA CreateProcessAsUser;
2771 alias DefineDosDeviceA DefineDosDevice;
2772 alias FindFirstFileExA FindFirstFileEx;
2773 alias GetBinaryTypeA GetBinaryType;
2774 alias GetCompressedFileSizeA GetCompressedFileSize;
2775 alias GetFileSecurityA GetFileSecurity;
2776 alias LogonUserA LogonUser;
2777 alias LookupAccountNameA LookupAccountName;
2778 alias LookupAccountSidA LookupAccountSid;
2779 alias LookupPrivilegeDisplayNameA LookupPrivilegeDisplayName;
2780 alias LookupPrivilegeNameA LookupPrivilegeName;
2781 alias LookupPrivilegeValueA LookupPrivilegeValue;
2782 alias MoveFileExA MoveFileEx;
2783 alias ObjectCloseAuditAlarmA ObjectCloseAuditAlarm;
2784 alias ObjectDeleteAuditAlarmA ObjectDeleteAuditAlarm;
2785 alias ObjectOpenAuditAlarmA ObjectOpenAuditAlarm;
2786 alias ObjectPrivilegeAuditAlarmA ObjectPrivilegeAuditAlarm;
2787 alias OpenBackupEventLogA OpenBackupEventLog;
2788 alias OpenEventLogA OpenEventLog;
2789 alias PrivilegedServiceAuditAlarmA PrivilegedServiceAuditAlarm;
2790 alias ReadEventLogA ReadEventLog;
2791 alias RegisterEventSourceA RegisterEventSource;
2792 alias ReportEventA ReportEvent;
2793 alias SetFileSecurityA SetFileSecurity;
2794 alias UpdateResourceA UpdateResource;
2795
2796 static if (_WIN32_WINNT >= 0x500) {
2797 alias CreateFileMappingA CreateFileMapping;
2798 alias CreateHardLinkA CreateHardLink;
2799 alias CreateJobObjectA CreateJobObject;
2800 alias DeleteVolumeMountPointA DeleteVolumeMountPoint;
2801 alias DnsHostnameToComputerNameA DnsHostnameToComputerName;
2802 alias EncryptFileA EncryptFile;
2803 alias FileEncryptionStatusA FileEncryptionStatus;
2804 alias FindFirstVolumeA FindFirstVolume;
2805 alias FindFirstVolumeMountPointA FindFirstVolumeMountPoint;
2806 alias FindNextVolumeA FindNextVolume;
2807 alias FindNextVolumeMountPointA FindNextVolumeMountPoint;
2808 alias GetModuleHandleExA GetModuleHandleEx;
2809 alias GetSystemWindowsDirectoryA GetSystemWindowsDirectory;
2810 alias GetVolumeNameForVolumeMountPointA GetVolumeNameForVolumeMountPoint;
2811 alias GetVolumePathNameA GetVolumePathName;
2812 alias OpenFileMappingA OpenFileMapping;
2813 alias ReplaceFileA ReplaceFile;
2814 alias SetVolumeMountPointA SetVolumeMountPoint;
2815 alias VerifyVersionInfoA VerifyVersionInfo;
2816 }
2817
2818 static if (_WIN32_WINNT >= 0x501) {
2819 alias ACTCTXA ACTCTX;
2820 alias CheckNameLegalDOS8Dot3A CheckNameLegalDOS8Dot3;
2821 alias CreateActCtxA CreateActCtx;
2822 alias FindActCtxSectionStringA FindActCtxSectionString;
2823 alias GetSystemWow64DirectoryA GetSystemWow64Directory;
2824 alias GetVolumePathNamesForVolumeNameA GetVolumePathNamesForVolumeName;
2825 alias SetFileShortNameA SetFileShortName;
2826 }
2827
2828 static if (_WIN32_WINNT >= 0x502) {
2829 alias GetDllDirectoryA GetDllDirectory;
2830 alias SetDllDirectoryA SetDllDirectory;
2831 alias SetFirmwareEnvironmentVariableA SetFirmwareEnvironmentVariable;
2832 }
2833 }
2834
2835 alias STARTUPINFO* LPSTARTUPINFO;
2836 alias WIN32_FIND_DATA* LPWIN32_FIND_DATA;
2837
2838 alias HW_PROFILE_INFO* LPHW_PROFILE_INFO;
2839
2840 static if (_WIN32_WINNT >= 0x501) {
2841 alias ACTCTX* PACTCTX, PCACTCTX;
2842 }
2843