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