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