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