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