| /** |
| * Windows API header module |
| * |
| * Translated from MinGW API for MS-Windows 3.10 |
| * |
| * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) |
| * Source: $(DRUNTIMESRC src/core/sys/windows/_winbase.d) |
| */ |
| module core.sys.windows.winbase; |
| version (Windows): |
| @system: |
| |
| version (ANSI) {} else version = Unicode; |
| pragma(lib, "kernel32"); |
| |
| /** |
| Translation Notes: |
| The following macros are obsolete, and have no effect. |
| |
| LockSegment(w), MakeProcInstance(p, i), UnlockResource(h), UnlockSegment(w) |
| FreeModule(m), FreeProcInstance(p), GetFreeSpace(w), DefineHandleTable(w) |
| SetSwapAreaSize(w), LimitEmsPages(n), Yield() |
| |
| // These are not required for DMD. |
| |
| //FIXME: |
| // #ifndef UNDER_CE |
| int WinMain(HINSTANCE, HINSTANCE, LPSTR, int); |
| #else |
| int WinMain(HINSTANCE, HINSTANCE, LPWSTR, int); |
| #endif |
| int wWinMain(HINSTANCE, HINSTANCE, LPWSTR, int); |
| |
| */ |
| |
| import core.sys.windows.windef, core.sys.windows.winver; |
| import core.sys.windows.basetyps, core.sys.windows.w32api, core.sys.windows.winnt; |
| |
| // FIXME: |
| //alias void va_list; |
| import core.stdc.stdarg : va_list; |
| |
| |
| // COMMPROP structure, used by GetCommProperties() |
| // ----------------------------------------------- |
| |
| // Communications provider type |
| enum : DWORD { |
| PST_UNSPECIFIED, |
| PST_RS232, |
| PST_PARALLELPORT, |
| PST_RS422, |
| PST_RS423, |
| PST_RS449, |
| PST_MODEM, // = 6 |
| PST_FAX = 0x0021, |
| PST_SCANNER = 0x0022, |
| PST_NETWORK_BRIDGE = 0x0100, |
| PST_LAT = 0x0101, |
| PST_TCPIP_TELNET = 0x0102, |
| PST_X25 = 0x0103 |
| } |
| |
| // Max baud rate |
| enum : DWORD { |
| BAUD_075 = 0x00000001, |
| BAUD_110 = 0x00000002, |
| BAUD_134_5 = 0x00000004, |
| BAUD_150 = 0x00000008, |
| BAUD_300 = 0x00000010, |
| BAUD_600 = 0x00000020, |
| BAUD_1200 = 0x00000040, |
| BAUD_1800 = 0x00000080, |
| BAUD_2400 = 0x00000100, |
| BAUD_4800 = 0x00000200, |
| BAUD_7200 = 0x00000400, |
| BAUD_9600 = 0x00000800, |
| BAUD_14400 = 0x00001000, |
| BAUD_19200 = 0x00002000, |
| BAUD_38400 = 0x00004000, |
| BAUD_56K = 0x00008000, |
| BAUD_128K = 0x00010000, |
| BAUD_115200 = 0x00020000, |
| BAUD_57600 = 0x00040000, |
| BAUD_USER = 0x10000000 |
| } |
| |
| // Comm capabilities |
| enum : DWORD { |
| PCF_DTRDSR = 0x0001, |
| PCF_RTSCTS = 0x0002, |
| PCF_RLSD = 0x0004, |
| PCF_PARITY_CHECK = 0x0008, |
| PCF_XONXOFF = 0x0010, |
| PCF_SETXCHAR = 0x0020, |
| PCF_TOTALTIMEOUTS = 0x0040, |
| PCF_INTTIMEOUTS = 0x0080, |
| PCF_SPECIALCHARS = 0x0100, |
| PCF_16BITMODE = 0x0200 |
| } |
| |
| enum : DWORD { |
| SP_PARITY = 1, |
| SP_BAUD = 2, |
| SP_DATABITS = 4, |
| SP_STOPBITS = 8, |
| SP_HANDSHAKING = 16, |
| SP_PARITY_CHECK = 32, |
| SP_RLSD = 64 |
| } |
| |
| enum : DWORD { |
| DATABITS_5 = 1, |
| DATABITS_6 = 2, |
| DATABITS_7 = 4, |
| DATABITS_8 = 8, |
| DATABITS_16 = 16, |
| DATABITS_16X = 32 |
| } |
| |
| enum : WORD { |
| STOPBITS_10 = 0x0001, |
| STOPBITS_15 = 0x0002, |
| STOPBITS_20 = 0x0004, |
| PARITY_NONE = 0x0100, |
| PARITY_ODD = 0x0200, |
| PARITY_EVEN = 0x0400, |
| PARITY_MARK = 0x0800, |
| PARITY_SPACE = 0x1000 |
| } |
| |
| // used by dwServiceMask |
| enum SP_SERIALCOMM = 1; |
| |
| struct COMMPROP { |
| WORD wPacketLength; |
| WORD wPacketVersion; |
| DWORD dwServiceMask; |
| DWORD dwReserved1; |
| DWORD dwMaxTxQueue; |
| DWORD dwMaxRxQueue; |
| DWORD dwMaxBaud; |
| DWORD dwProvSubType; |
| DWORD dwProvCapabilities; |
| DWORD dwSettableParams; |
| DWORD dwSettableBaud; |
| WORD wSettableData; |
| WORD wSettableStopParity; |
| DWORD dwCurrentTxQueue; |
| DWORD dwCurrentRxQueue; |
| DWORD dwProvSpec1; |
| DWORD dwProvSpec2; |
| WCHAR _wcProvChar = 0; |
| |
| WCHAR* wcProvChar() return { return &_wcProvChar; } |
| } |
| alias COMMPROP* LPCOMMPROP; |
| |
| // ---------- |
| |
| // for DEBUG_EVENT |
| enum : DWORD { |
| EXCEPTION_DEBUG_EVENT = 1, |
| CREATE_THREAD_DEBUG_EVENT, |
| CREATE_PROCESS_DEBUG_EVENT, |
| EXIT_THREAD_DEBUG_EVENT, |
| EXIT_PROCESS_DEBUG_EVENT, |
| LOAD_DLL_DEBUG_EVENT, |
| UNLOAD_DLL_DEBUG_EVENT, |
| OUTPUT_DEBUG_STRING_EVENT, |
| RIP_EVENT |
| } |
| |
| enum HFILE HFILE_ERROR = cast(HFILE) (-1); |
| |
| // for SetFilePointer() |
| enum : DWORD { |
| FILE_BEGIN = 0, |
| FILE_CURRENT = 1, |
| FILE_END = 2 |
| } |
| enum DWORD INVALID_SET_FILE_POINTER = -1; |
| |
| |
| // for OpenFile() |
| deprecated enum : UINT { |
| OF_READ = 0, |
| OF_WRITE = 0x0001, |
| OF_READWRITE = 0x0002, |
| OF_SHARE_COMPAT = 0, |
| OF_SHARE_EXCLUSIVE = 0x0010, |
| OF_SHARE_DENY_WRITE = 0x0020, |
| OF_SHARE_DENY_READ = 0x0030, |
| OF_SHARE_DENY_NONE = 0x0040, |
| OF_PARSE = 0x0100, |
| OF_DELETE = 0x0200, |
| OF_VERIFY = 0x0400, |
| OF_CANCEL = 0x0800, |
| OF_CREATE = 0x1000, |
| OF_PROMPT = 0x2000, |
| OF_EXIST = 0x4000, |
| OF_REOPEN = 0x8000 |
| } |
| |
| enum : DWORD { |
| NMPWAIT_NOWAIT = 1, |
| NMPWAIT_WAIT_FOREVER = -1, |
| NMPWAIT_USE_DEFAULT_WAIT = 0 |
| } |
| |
| // for ClearCommError() |
| enum DWORD |
| CE_RXOVER = 0x0001, |
| CE_OVERRUN = 0x0002, |
| CE_RXPARITY = 0x0004, |
| CE_FRAME = 0x0008, |
| CE_BREAK = 0x0010, |
| CE_TXFULL = 0x0100, |
| CE_PTO = 0x0200, |
| CE_IOE = 0x0400, |
| CE_DNS = 0x0800, |
| CE_OOP = 0x1000, |
| CE_MODE = 0x8000; |
| |
| // for CopyProgressRoutine callback. |
| enum : DWORD { |
| PROGRESS_CONTINUE = 0, |
| PROGRESS_CANCEL = 1, |
| PROGRESS_STOP = 2, |
| PROGRESS_QUIET = 3 |
| } |
| |
| enum : DWORD { |
| CALLBACK_CHUNK_FINISHED = 0, |
| CALLBACK_STREAM_SWITCH = 1 |
| } |
| |
| // CopyFileEx() |
| enum : DWORD { |
| COPY_FILE_FAIL_IF_EXISTS = 1, |
| COPY_FILE_RESTARTABLE = 2 |
| } |
| |
| enum : DWORD { |
| FILE_MAP_COPY = 1, |
| FILE_MAP_WRITE = 2, |
| FILE_MAP_READ = 4, |
| FILE_MAP_ALL_ACCESS = 0x000F001F |
| } |
| |
| enum : DWORD { |
| MUTEX_ALL_ACCESS = 0x001f0001, |
| MUTEX_MODIFY_STATE = 0x00000001, |
| SEMAPHORE_ALL_ACCESS = 0x001f0003, |
| SEMAPHORE_MODIFY_STATE = 0x00000002, |
| EVENT_ALL_ACCESS = 0x001f0003, |
| EVENT_MODIFY_STATE = 0x00000002 |
| } |
| |
| // CreateNamedPipe() |
| enum : DWORD { |
| PIPE_ACCESS_INBOUND = 1, |
| PIPE_ACCESS_OUTBOUND = 2, |
| PIPE_ACCESS_DUPLEX = 3 |
| } |
| |
| enum DWORD |
| PIPE_TYPE_BYTE = 0, |
| PIPE_TYPE_MESSAGE = 4, |
| PIPE_READMODE_BYTE = 0, |
| PIPE_READMODE_MESSAGE = 2, |
| PIPE_WAIT = 0, |
| PIPE_NOWAIT = 1; |
| |
| // GetNamedPipeInfo() |
| enum DWORD |
| PIPE_CLIENT_END = 0, |
| PIPE_SERVER_END = 1; |
| |
| enum DWORD PIPE_UNLIMITED_INSTANCES = 255; |
| |
| // dwCreationFlags for CreateProcess() and CreateProcessAsUser() |
| enum : DWORD { |
| DEBUG_PROCESS = 0x00000001, |
| DEBUG_ONLY_THIS_PROCESS = 0x00000002, |
| CREATE_SUSPENDED = 0x00000004, |
| DETACHED_PROCESS = 0x00000008, |
| CREATE_NEW_CONSOLE = 0x00000010, |
| NORMAL_PRIORITY_CLASS = 0x00000020, |
| IDLE_PRIORITY_CLASS = 0x00000040, |
| HIGH_PRIORITY_CLASS = 0x00000080, |
| REALTIME_PRIORITY_CLASS = 0x00000100, |
| CREATE_NEW_PROCESS_GROUP = 0x00000200, |
| CREATE_UNICODE_ENVIRONMENT = 0x00000400, |
| CREATE_SEPARATE_WOW_VDM = 0x00000800, |
| CREATE_SHARED_WOW_VDM = 0x00001000, |
| CREATE_FORCEDOS = 0x00002000, |
| BELOW_NORMAL_PRIORITY_CLASS = 0x00004000, |
| ABOVE_NORMAL_PRIORITY_CLASS = 0x00008000, |
| CREATE_BREAKAWAY_FROM_JOB = 0x01000000, |
| CREATE_WITH_USERPROFILE = 0x02000000, |
| CREATE_DEFAULT_ERROR_MODE = 0x04000000, |
| CREATE_NO_WINDOW = 0x08000000, |
| PROFILE_USER = 0x10000000, |
| PROFILE_KERNEL = 0x20000000, |
| PROFILE_SERVER = 0x40000000 |
| } |
| |
| enum DWORD CONSOLE_TEXTMODE_BUFFER = 1; |
| |
| // CreateFile() |
| enum : DWORD { |
| CREATE_NEW = 1, |
| CREATE_ALWAYS, |
| OPEN_EXISTING, |
| OPEN_ALWAYS, |
| TRUNCATE_EXISTING |
| } |
| |
| // CreateFile() |
| enum DWORD |
| FILE_FLAG_WRITE_THROUGH = 0x80000000, |
| FILE_FLAG_OVERLAPPED = 0x40000000, |
| FILE_FLAG_NO_BUFFERING = 0x20000000, |
| FILE_FLAG_RANDOM_ACCESS = 0x10000000, |
| FILE_FLAG_SEQUENTIAL_SCAN = 0x08000000, |
| FILE_FLAG_DELETE_ON_CLOSE = 0x04000000, |
| FILE_FLAG_BACKUP_SEMANTICS = 0x02000000, |
| FILE_FLAG_POSIX_SEMANTICS = 0x01000000, |
| FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000, |
| FILE_FLAG_OPEN_NO_RECALL = 0x00100000; |
| |
| static if (_WIN32_WINNT >= 0x500) { |
| enum DWORD FILE_FLAG_FIRST_PIPE_INSTANCE = 0x00080000; |
| } |
| |
| // for CreateFile() |
| enum DWORD |
| SECURITY_ANONYMOUS = SECURITY_IMPERSONATION_LEVEL.SecurityAnonymous<<16, |
| SECURITY_IDENTIFICATION = SECURITY_IMPERSONATION_LEVEL.SecurityIdentification<<16, |
| SECURITY_IMPERSONATION = SECURITY_IMPERSONATION_LEVEL.SecurityImpersonation<<16, |
| SECURITY_DELEGATION = SECURITY_IMPERSONATION_LEVEL.SecurityDelegation<<16, |
| SECURITY_CONTEXT_TRACKING = 0x00040000, |
| SECURITY_EFFECTIVE_ONLY = 0x00080000, |
| SECURITY_SQOS_PRESENT = 0x00100000, |
| SECURITY_VALID_SQOS_FLAGS = 0x001F0000; |
| |
| |
| // Thread exit code |
| enum DWORD STILL_ACTIVE = 0x103; |
| |
| /* ??? The only documentation of this seems to be about Windows CE and to |
| * state what _doesn't_ support it. |
| */ |
| enum DWORD FIND_FIRST_EX_CASE_SENSITIVE = 1; |
| |
| // GetBinaryType() |
| enum : DWORD { |
| SCS_32BIT_BINARY = 0, |
| SCS_DOS_BINARY, |
| SCS_WOW_BINARY, |
| SCS_PIF_BINARY, |
| SCS_POSIX_BINARY, |
| SCS_OS216_BINARY |
| } |
| |
| enum size_t |
| MAX_COMPUTERNAME_LENGTH = 15, |
| HW_PROFILE_GUIDLEN = 39, |
| MAX_PROFILE_LEN = 80; |
| |
| // HW_PROFILE_INFO |
| enum DWORD |
| DOCKINFO_UNDOCKED = 1, |
| DOCKINFO_DOCKED = 2, |
| DOCKINFO_USER_SUPPLIED = 4, |
| DOCKINFO_USER_UNDOCKED = DOCKINFO_USER_SUPPLIED | DOCKINFO_UNDOCKED, |
| DOCKINFO_USER_DOCKED = DOCKINFO_USER_SUPPLIED | DOCKINFO_DOCKED; |
| |
| // DriveType(), RealDriveType() |
| enum : int { |
| DRIVE_UNKNOWN = 0, |
| DRIVE_NO_ROOT_DIR, |
| DRIVE_REMOVABLE, |
| DRIVE_FIXED, |
| DRIVE_REMOTE, |
| DRIVE_CDROM, |
| DRIVE_RAMDISK |
| } |
| |
| // GetFileType() |
| enum : DWORD { |
| FILE_TYPE_UNKNOWN = 0, |
| FILE_TYPE_DISK, |
| FILE_TYPE_CHAR, |
| FILE_TYPE_PIPE, |
| FILE_TYPE_REMOTE = 0x8000 |
| } |
| |
| // Get/SetHandleInformation() |
| enum DWORD |
| HANDLE_FLAG_INHERIT = 0x01, |
| HANDLE_FLAG_PROTECT_FROM_CLOSE = 0x02; |
| |
| enum : DWORD { |
| STD_INPUT_HANDLE = 0xFFFFFFF6, |
| STD_OUTPUT_HANDLE = 0xFFFFFFF5, |
| STD_ERROR_HANDLE = 0xFFFFFFF4 |
| } |
| |
| enum HANDLE INVALID_HANDLE_VALUE = cast(HANDLE) (-1); |
| |
| enum : DWORD { |
| GET_TAPE_MEDIA_INFORMATION = 0, |
| GET_TAPE_DRIVE_INFORMATION = 1 |
| } |
| |
| enum : DWORD { |
| SET_TAPE_MEDIA_INFORMATION = 0, |
| SET_TAPE_DRIVE_INFORMATION = 1 |
| } |
| |
| // SetThreadPriority()/GetThreadPriority() |
| enum : int { |
| THREAD_PRIORITY_IDLE = -15, |
| THREAD_PRIORITY_LOWEST = -2, |
| THREAD_PRIORITY_BELOW_NORMAL = -1, |
| THREAD_PRIORITY_NORMAL = 0, |
| THREAD_PRIORITY_ABOVE_NORMAL = 1, |
| THREAD_PRIORITY_HIGHEST = 2, |
| THREAD_PRIORITY_TIME_CRITICAL = 15, |
| THREAD_PRIORITY_ERROR_RETURN = 2147483647 |
| } |
| |
| enum : DWORD { |
| TIME_ZONE_ID_UNKNOWN, |
| TIME_ZONE_ID_STANDARD, |
| TIME_ZONE_ID_DAYLIGHT, |
| TIME_ZONE_ID_INVALID = 0xFFFFFFFF |
| } |
| |
| enum DWORD |
| FS_CASE_SENSITIVE = 1, |
| FS_CASE_IS_PRESERVED = 2, |
| FS_UNICODE_STORED_ON_DISK = 4, |
| FS_PERSISTENT_ACLS = 8, |
| FS_FILE_COMPRESSION = 16, |
| FS_VOL_IS_COMPRESSED = 32768; |
| |
| // Flags for GlobalAlloc |
| enum UINT |
| GMEM_FIXED = 0, |
| GMEM_MOVEABLE = 0x0002, |
| GMEM_ZEROINIT = 0x0040, |
| GPTR = 0x0040, |
| GHND = 0x0042, |
| GMEM_MODIFY = 0x0080, // used only for GlobalRealloc |
| GMEM_VALID_FLAGS = 0x7F72; |
| |
| /+ // Obselete flags (Win16 only) |
| GMEM_NOCOMPACT=16; |
| GMEM_NODISCARD=32; |
| GMEM_DISCARDABLE=256; |
| GMEM_NOT_BANKED=4096; |
| GMEM_LOWER=4096; |
| GMEM_SHARE=8192; |
| GMEM_DDESHARE=8192; |
| |
| GMEM_LOCKCOUNT=255; |
| |
| // for GlobalFlags() |
| GMEM_DISCARDED = 16384; |
| GMEM_INVALID_HANDLE = 32768; |
| |
| GMEM_NOTIFY = 16384; |
| +/ |
| |
| enum UINT |
| LMEM_FIXED = 0, |
| LMEM_MOVEABLE = 0x0002, |
| LMEM_NONZEROLPTR = 0, |
| NONZEROLPTR = 0, |
| LMEM_NONZEROLHND = 0x0002, |
| NONZEROLHND = 0x0002, |
| LMEM_DISCARDABLE = 0x0F00, |
| LMEM_NOCOMPACT = 0x0010, |
| LMEM_NODISCARD = 0x0020, |
| LMEM_ZEROINIT = 0x0040, |
| LPTR = 0x0040, |
| LHND = 0x0042, |
| LMEM_MODIFY = 0x0080, |
| LMEM_LOCKCOUNT = 0x00FF, |
| LMEM_DISCARDED = 0x4000, |
| LMEM_INVALID_HANDLE = 0x8000; |
| |
| |
| |
| // used in EXCEPTION_RECORD |
| enum : DWORD { |
| STATUS_WAIT_0 = 0, |
| STATUS_ABANDONED_WAIT_0 = 0x00000080, |
| STATUS_USER_APC = 0x000000C0, |
| STATUS_TIMEOUT = 0x00000102, |
| STATUS_PENDING = 0x00000103, |
| |
| STATUS_SEGMENT_NOTIFICATION = 0x40000005, |
| STATUS_GUARD_PAGE_VIOLATION = 0x80000001, |
| STATUS_DATATYPE_MISALIGNMENT = 0x80000002, |
| STATUS_BREAKPOINT = 0x80000003, |
| STATUS_SINGLE_STEP = 0x80000004, |
| |
| STATUS_ACCESS_VIOLATION = 0xC0000005, |
| STATUS_IN_PAGE_ERROR = 0xC0000006, |
| STATUS_INVALID_HANDLE = 0xC0000008, |
| |
| STATUS_NO_MEMORY = 0xC0000017, |
| STATUS_ILLEGAL_INSTRUCTION = 0xC000001D, |
| STATUS_NONCONTINUABLE_EXCEPTION = 0xC0000025, |
| STATUS_INVALID_DISPOSITION = 0xC0000026, |
| STATUS_ARRAY_BOUNDS_EXCEEDED = 0xC000008C, |
| STATUS_FLOAT_DENORMAL_OPERAND = 0xC000008D, |
| STATUS_FLOAT_DIVIDE_BY_ZERO = 0xC000008E, |
| STATUS_FLOAT_INEXACT_RESULT = 0xC000008F, |
| STATUS_FLOAT_INVALID_OPERATION = 0xC0000090, |
| STATUS_FLOAT_OVERFLOW = 0xC0000091, |
| STATUS_FLOAT_STACK_CHECK = 0xC0000092, |
| STATUS_FLOAT_UNDERFLOW = 0xC0000093, |
| STATUS_INTEGER_DIVIDE_BY_ZERO = 0xC0000094, |
| STATUS_INTEGER_OVERFLOW = 0xC0000095, |
| STATUS_PRIVILEGED_INSTRUCTION = 0xC0000096, |
| STATUS_STACK_OVERFLOW = 0xC00000FD, |
| STATUS_CONTROL_C_EXIT = 0xC000013A, |
| STATUS_DLL_INIT_FAILED = 0xC0000142, |
| STATUS_DLL_INIT_FAILED_LOGOFF = 0xC000026B, |
| |
| CONTROL_C_EXIT = STATUS_CONTROL_C_EXIT, |
| |
| EXCEPTION_ACCESS_VIOLATION = STATUS_ACCESS_VIOLATION, |
| EXCEPTION_DATATYPE_MISALIGNMENT = STATUS_DATATYPE_MISALIGNMENT, |
| EXCEPTION_BREAKPOINT = STATUS_BREAKPOINT, |
| EXCEPTION_SINGLE_STEP = STATUS_SINGLE_STEP, |
| EXCEPTION_ARRAY_BOUNDS_EXCEEDED = STATUS_ARRAY_BOUNDS_EXCEEDED, |
| EXCEPTION_FLT_DENORMAL_OPERAND = STATUS_FLOAT_DENORMAL_OPERAND, |
| EXCEPTION_FLT_DIVIDE_BY_ZERO = STATUS_FLOAT_DIVIDE_BY_ZERO, |
| EXCEPTION_FLT_INEXACT_RESULT = STATUS_FLOAT_INEXACT_RESULT, |
| EXCEPTION_FLT_INVALID_OPERATION = STATUS_FLOAT_INVALID_OPERATION, |
| EXCEPTION_FLT_OVERFLOW = STATUS_FLOAT_OVERFLOW, |
| EXCEPTION_FLT_STACK_CHECK = STATUS_FLOAT_STACK_CHECK, |
| EXCEPTION_FLT_UNDERFLOW = STATUS_FLOAT_UNDERFLOW, |
| EXCEPTION_INT_DIVIDE_BY_ZERO = STATUS_INTEGER_DIVIDE_BY_ZERO, |
| EXCEPTION_INT_OVERFLOW = STATUS_INTEGER_OVERFLOW, |
| EXCEPTION_PRIV_INSTRUCTION = STATUS_PRIVILEGED_INSTRUCTION, |
| EXCEPTION_IN_PAGE_ERROR = STATUS_IN_PAGE_ERROR, |
| EXCEPTION_ILLEGAL_INSTRUCTION = STATUS_ILLEGAL_INSTRUCTION, |
| EXCEPTION_NONCONTINUABLE_EXCEPTION = STATUS_NONCONTINUABLE_EXCEPTION, |
| EXCEPTION_STACK_OVERFLOW = STATUS_STACK_OVERFLOW, |
| EXCEPTION_INVALID_DISPOSITION = STATUS_INVALID_DISPOSITION, |
| EXCEPTION_GUARD_PAGE = STATUS_GUARD_PAGE_VIOLATION, |
| EXCEPTION_INVALID_HANDLE = STATUS_INVALID_HANDLE |
| } |
| |
| // for PROCESS_HEAP_ENTRY |
| enum WORD |
| PROCESS_HEAP_REGION = 1, |
| PROCESS_HEAP_UNCOMMITTED_RANGE = 2, |
| PROCESS_HEAP_ENTRY_BUSY = 4, |
| PROCESS_HEAP_ENTRY_MOVEABLE = 16, |
| PROCESS_HEAP_ENTRY_DDESHARE = 32; |
| |
| // for LoadLibraryEx() |
| enum DWORD |
| DONT_RESOLVE_DLL_REFERENCES = 0x01, // not for WinME and earlier |
| LOAD_LIBRARY_AS_DATAFILE = 0x02, |
| LOAD_WITH_ALTERED_SEARCH_PATH = 0x08, |
| LOAD_IGNORE_CODE_AUTHZ_LEVEL = 0x10; // only for XP and later |
| |
| // for LockFile() |
| enum DWORD |
| LOCKFILE_FAIL_IMMEDIATELY = 1, |
| LOCKFILE_EXCLUSIVE_LOCK = 2; |
| |
| enum MAXIMUM_WAIT_OBJECTS = 64; |
| enum MAXIMUM_SUSPEND_COUNT = 0x7F; |
| |
| enum WAIT_OBJECT_0 = 0; |
| enum WAIT_ABANDONED_0 = 128; |
| |
| //const WAIT_TIMEOUT=258; // also in winerror.h |
| |
| enum : DWORD { |
| WAIT_IO_COMPLETION = 0x000000C0, |
| WAIT_ABANDONED = 0x00000080, |
| WAIT_FAILED = 0xFFFFFFFF |
| } |
| |
| // PurgeComm() |
| enum DWORD |
| PURGE_TXABORT = 1, |
| PURGE_RXABORT = 2, |
| PURGE_TXCLEAR = 4, |
| PURGE_RXCLEAR = 8; |
| |
| // ReadEventLog() |
| enum DWORD |
| EVENTLOG_SEQUENTIAL_READ = 1, |
| EVENTLOG_SEEK_READ = 2, |
| EVENTLOG_FORWARDS_READ = 4, |
| EVENTLOG_BACKWARDS_READ = 8; |
| |
| // ReportEvent() |
| enum : WORD { |
| EVENTLOG_SUCCESS = 0, |
| EVENTLOG_ERROR_TYPE = 1, |
| EVENTLOG_WARNING_TYPE = 2, |
| EVENTLOG_INFORMATION_TYPE = 4, |
| EVENTLOG_AUDIT_SUCCESS = 8, |
| EVENTLOG_AUDIT_FAILURE = 16 |
| } |
| |
| // FormatMessage() |
| enum DWORD |
| FORMAT_MESSAGE_ALLOCATE_BUFFER = 0x0100, |
| FORMAT_MESSAGE_IGNORE_INSERTS = 0x0200, |
| FORMAT_MESSAGE_FROM_STRING = 0x0400, |
| FORMAT_MESSAGE_FROM_HMODULE = 0x0800, |
| FORMAT_MESSAGE_FROM_SYSTEM = 0x1000, |
| FORMAT_MESSAGE_ARGUMENT_ARRAY = 0x2000; |
| |
| enum DWORD FORMAT_MESSAGE_MAX_WIDTH_MASK = 255; |
| |
| // also in ddk/ntapi.h |
| // To restore default error mode, call SetErrorMode(0) |
| enum { |
| SEM_FAILCRITICALERRORS = 0x0001, |
| SEM_NOGPFAULTERRORBOX = 0x0002, |
| SEM_NOALIGNMENTFAULTEXCEPT = 0x0004, |
| SEM_NOOPENFILEERRORBOX = 0x8000 |
| } |
| // end ntapi.h |
| |
| enum { |
| SLE_ERROR = 1, |
| SLE_MINORERROR, |
| SLE_WARNING |
| } |
| |
| enum SHUTDOWN_NORETRY = 1; |
| |
| // Return type for exception filters. |
| enum : LONG { |
| EXCEPTION_EXECUTE_HANDLER = 1, |
| EXCEPTION_CONTINUE_EXECUTION = -1, |
| EXCEPTION_CONTINUE_SEARCH = 0 |
| } |
| |
| enum : ATOM { |
| MAXINTATOM = 0xC000, |
| INVALID_ATOM = 0 |
| } |
| |
| enum IGNORE = 0; |
| enum INFINITE = 0xFFFFFFFF; |
| |
| // EscapeCommFunction() |
| enum { |
| SETXOFF = 1, |
| SETXON, |
| SETRTS, |
| CLRRTS, |
| SETDTR, |
| CLRDTR, // = 6 |
| SETBREAK = 8, |
| CLRBREAK = 9 |
| } |
| |
| |
| // for SetCommMask() |
| enum DWORD |
| EV_RXCHAR = 0x0001, |
| EV_RXFLAG = 0x0002, |
| EV_TXEMPTY = 0x0004, |
| EV_CTS = 0x0008, |
| EV_DSR = 0x0010, |
| EV_RLSD = 0x0020, |
| EV_BREAK = 0x0040, |
| EV_ERR = 0x0080, |
| EV_RING = 0x0100, |
| EV_PERR = 0x0200, |
| EV_RX80FULL = 0x0400, |
| EV_EVENT1 = 0x0800, |
| EV_EVENT2 = 0x1000; |
| |
| // GetCommModemStatus() |
| enum DWORD |
| MS_CTS_ON = 0x0010, |
| MS_DSR_ON = 0x0020, |
| MS_RING_ON = 0x0040, |
| MS_RLSD_ON = 0x0080; |
| |
| |
| // DCB |
| enum : BYTE { |
| NOPARITY = 0, |
| ODDPARITY, |
| EVENPARITY, |
| MARKPARITY, |
| SPACEPARITY |
| } |
| // DCB |
| enum : BYTE { |
| ONESTOPBIT = 0, |
| ONE5STOPBITS, |
| TWOSTOPBITS |
| } |
| // DCB |
| enum : DWORD { |
| CBR_110 = 110, |
| CBR_300 = 300, |
| CBR_600 = 600, |
| CBR_1200 = 1200, |
| CBR_2400 = 2400, |
| CBR_4800 = 4800, |
| CBR_9600 = 9600, |
| CBR_14400 = 14400, |
| CBR_19200 = 19200, |
| CBR_38400 = 38400, |
| CBR_56000 = 56000, |
| CBR_57600 = 57600, |
| CBR_115200 = 115200, |
| CBR_128000 = 128000, |
| CBR_256000 = 256000 |
| } |
| // DCB, 2-bit bitfield |
| enum { |
| DTR_CONTROL_DISABLE = 0, |
| DTR_CONTROL_ENABLE, |
| DTR_CONTROL_HANDSHAKE |
| } |
| |
| // DCB, 2-bit bitfield |
| enum { |
| RTS_CONTROL_DISABLE = 0, |
| RTS_CONTROL_ENABLE, |
| RTS_CONTROL_HANDSHAKE, |
| RTS_CONTROL_TOGGLE, |
| } |
| |
| // WIN32_STREAM_ID |
| enum : DWORD { |
| BACKUP_INVALID = 0, |
| BACKUP_DATA, |
| BACKUP_EA_DATA, |
| BACKUP_SECURITY_DATA, |
| BACKUP_ALTERNATE_DATA, |
| BACKUP_LINK, |
| BACKUP_PROPERTY_DATA, |
| BACKUP_OBJECT_ID, |
| BACKUP_REPARSE_DATA, |
| BACKUP_SPARSE_BLOCK |
| } |
| |
| // WIN32_STREAM_ID |
| enum : DWORD { |
| STREAM_NORMAL_ATTRIBUTE = 0, |
| STREAM_MODIFIED_WHEN_READ = 1, |
| STREAM_CONTAINS_SECURITY = 2, |
| STREAM_CONTAINS_PROPERTIES = 4 |
| } |
| |
| // STARTUPINFO |
| enum DWORD |
| STARTF_USESHOWWINDOW = 0x0001, |
| STARTF_USESIZE = 0x0002, |
| STARTF_USEPOSITION = 0x0004, |
| STARTF_USECOUNTCHARS = 0x0008, |
| STARTF_USEFILLATTRIBUTE = 0x0010, |
| STARTF_RUNFULLSCREEN = 0x0020, |
| STARTF_FORCEONFEEDBACK = 0x0040, |
| STARTF_FORCEOFFFEEDBACK = 0x0080, |
| STARTF_USESTDHANDLES = 0x0100, |
| STARTF_USEHOTKEY = 0x0200; |
| |
| // ??? |
| enum { |
| TC_NORMAL = 0, |
| TC_HARDERR = 1, |
| TC_GP_TRAP = 2, |
| TC_SIGNAL = 3 |
| } |
| |
| /+ These seem to be Windows CE-specific |
| enum { |
| AC_LINE_OFFLINE = 0, |
| AC_LINE_ONLINE = 1, |
| AC_LINE_BACKUP_POWER = 2, |
| AC_LINE_UNKNOWN = 255 |
| } |
| |
| enum { |
| BATTERY_FLAG_HIGH = 1, |
| BATTERY_FLAG_LOW = 2, |
| BATTERY_FLAG_CRITICAL = 4, |
| BATTERY_FLAG_CHARGING = 8, |
| BATTERY_FLAG_NO_BATTERY = 128, |
| BATTERY_FLAG_UNKNOWN = 255, |
| BATTERY_PERCENTAGE_UNKNOWN = 255, |
| BATTERY_LIFE_UNKNOWN = 0xFFFFFFFF |
| } |
| +/ |
| |
| // ??? |
| enum HINSTANCE_ERROR = 32; |
| |
| // returned from GetFileSize() |
| enum DWORD INVALID_FILE_SIZE = 0xFFFFFFFF; |
| |
| enum DWORD TLS_OUT_OF_INDEXES = 0xFFFFFFFF; |
| |
| // GetWriteWatch() |
| enum DWORD WRITE_WATCH_FLAG_RESET = 1; |
| |
| // for LogonUser() |
| enum : DWORD { |
| LOGON32_LOGON_INTERACTIVE = 2, |
| LOGON32_LOGON_NETWORK = 3, |
| LOGON32_LOGON_BATCH = 4, |
| LOGON32_LOGON_SERVICE = 5, |
| LOGON32_LOGON_UNLOCK = 7 |
| } |
| |
| // for LogonUser() |
| enum : DWORD { |
| LOGON32_PROVIDER_DEFAULT, |
| LOGON32_PROVIDER_WINNT35, |
| LOGON32_PROVIDER_WINNT40, |
| LOGON32_PROVIDER_WINNT50 |
| } |
| |
| // for MoveFileEx() |
| enum DWORD |
| MOVEFILE_REPLACE_EXISTING = 1, |
| MOVEFILE_COPY_ALLOWED = 2, |
| MOVEFILE_DELAY_UNTIL_REBOOT = 4, |
| MOVEFILE_WRITE_THROUGH = 8; |
| |
| // DefineDosDevice() |
| enum DWORD |
| DDD_RAW_TARGET_PATH = 1, |
| DDD_REMOVE_DEFINITION = 2, |
| DDD_EXACT_MATCH_ON_REMOVE = 4; |
| |
| static if (_WIN32_WINNT >= 0x500) { |
| enum : DWORD { |
| LOGON32_LOGON_NETWORK_CLEARTEXT = 8, |
| LOGON32_LOGON_NEW_CREDENTIALS = 9 |
| } |
| |
| // ReplaceFile() |
| enum DWORD |
| REPLACEFILE_WRITE_THROUGH = 1, |
| REPLACEFILE_IGNORE_MERGE_ERRORS = 2; |
| } |
| |
| static if (_WIN32_WINNT >= 0x501) { |
| enum DWORD |
| GET_MODULE_HANDLE_EX_FLAG_PIN = 1, |
| GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT = 2, |
| GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS = 4; |
| |
| // for ACTCTX |
| enum DWORD |
| ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID = 0x01, |
| ACTCTX_FLAG_LANGID_VALID = 0x02, |
| ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID = 0x04, |
| ACTCTX_FLAG_RESOURCE_NAME_VALID = 0x08, |
| ACTCTX_FLAG_SET_PROCESS_DEFAULT = 0x10, |
| ACTCTX_FLAG_APPLICATION_NAME_VALID = 0x20, |
| ACTCTX_FLAG_HMODULE_VALID = 0x80; |
| |
| // DeactivateActCtx() |
| enum DWORD DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION = 1; |
| // FindActCtxSectionString() |
| enum DWORD FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX = 1; |
| // QueryActCtxW() |
| enum DWORD |
| QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX = 0x04, |
| QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE = 0x08, |
| QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS = 0x10; |
| |
| enum { |
| LOGON_WITH_PROFILE = 1, |
| LOGON_NETCREDENTIALS_ONLY |
| } |
| } |
| |
| // ---- |
| |
| struct FILETIME { |
| DWORD dwLowDateTime; |
| DWORD dwHighDateTime; |
| } |
| alias FILETIME* PFILETIME, LPFILETIME; |
| |
| struct BY_HANDLE_FILE_INFORMATION { |
| DWORD dwFileAttributes; |
| FILETIME ftCreationTime; |
| FILETIME ftLastAccessTime; |
| FILETIME ftLastWriteTime; |
| DWORD dwVolumeSerialNumber; |
| DWORD nFileSizeHigh; |
| DWORD nFileSizeLow; |
| DWORD nNumberOfLinks; |
| DWORD nFileIndexHigh; |
| DWORD nFileIndexLow; |
| } |
| alias BY_HANDLE_FILE_INFORMATION* LPBY_HANDLE_FILE_INFORMATION; |
| |
| struct DCB { |
| DWORD DCBlength = DCB.sizeof; |
| DWORD BaudRate; |
| /+ |
| DWORD fBinary:1; // Binary Mode (skip EOF check) |
| DWORD fParity:1; // Enable parity checking |
| DWORD fOutxCtsFlow:1; // CTS handshaking on output |
| DWORD fOutxDsrFlow:1; // DSR handshaking on output |
| DWORD fDtrControl:2; // DTR Flow control |
| DWORD fDsrSensitivity:1; // DSR Sensitivity |
| DWORD fTXContinueOnXoff:1; // Continue TX when Xoff sent |
| DWORD fOutX:1; // Enable output X-ON/X-OFF |
| DWORD fInX:1; // Enable input X-ON/X-OFF |
| DWORD fErrorChar:1; // Enable Err Replacement |
| DWORD fNull:1; // Enable Null stripping |
| DWORD fRtsControl:2; // Rts Flow control |
| DWORD fAbortOnError:1; // Abort all reads and writes on Error |
| DWORD fDummy2:17; // Reserved |
| +/ |
| uint _bf; |
| bool fBinary(bool f) { _bf = (_bf & ~0x0001) | f; return f; } |
| bool fParity(bool f) { _bf = (_bf & ~0x0002) | (f<<1); return f; } |
| bool fOutxCtsFlow(bool f) { _bf = (_bf & ~0x0004) | (f<<2); return f; } |
| bool fOutxDsrFlow(bool f) { _bf = (_bf & ~0x0008) | (f<<3); return f; } |
| byte fDtrControl(byte x) { _bf = (_bf & ~0x0030) | (x<<4); return cast(byte)(x & 3); } |
| bool fDsrSensitivity(bool f) { _bf = (_bf & ~0x0040) | (f<<6); return f; } |
| bool fTXContinueOnXoff(bool f) { _bf = (_bf & ~0x0080) | (f<<7); return f; } |
| bool fOutX(bool f) { _bf = (_bf & ~0x0100) | (f<<8); return f; } |
| bool fInX(bool f) { _bf = (_bf & ~0x0200) | (f<<9); return f; } |
| bool fErrorChar(bool f) { _bf = (_bf & ~0x0400) | (f<<10); return f; } |
| bool fNull(bool f) { _bf = (_bf & ~0x0800) | (f<<11); return f; } |
| byte fRtsControl(byte x) { _bf = (_bf & ~0x3000) | (x<<12); return cast(byte)(x & 3); } |
| bool fAbortOnError(bool f) { _bf = (_bf & ~0x4000) | (f<<14); return f; } |
| |
| bool fBinary() { return cast(bool) (_bf & 1); } |
| bool fParity() { return cast(bool) (_bf & 2); } |
| bool fOutxCtsFlow() { return cast(bool) (_bf & 4); } |
| bool fOutxDsrFlow() { return cast(bool) (_bf & 8); } |
| byte fDtrControl() { return cast(byte) ((_bf & (32+16))>>4); } |
| bool fDsrSensitivity() { return cast(bool) (_bf & 64); } |
| bool fTXContinueOnXoff() { return cast(bool) (_bf & 128); } |
| bool fOutX() { return cast(bool) (_bf & 256); } |
| bool fInX() { return cast(bool) (_bf & 512); } |
| bool fErrorChar() { return cast(bool) (_bf & 1024); } |
| bool fNull() { return cast(bool) (_bf & 2048); } |
| byte fRtsControl() { return cast(byte) ((_bf & (4096+8192))>>12); } |
| bool fAbortOnError() { return cast(bool) (_bf & 16384); } |
| |
| WORD wReserved; |
| WORD XonLim; |
| WORD XoffLim; |
| BYTE ByteSize; |
| BYTE Parity; |
| BYTE StopBits; |
| char XonChar = 0; |
| char XoffChar = 0; |
| char ErrorChar = 0; |
| char EofChar = 0; |
| char EvtChar = 0; |
| WORD wReserved1; |
| } |
| alias DCB* LPDCB; |
| |
| struct COMMCONFIG { |
| DWORD dwSize = COMMCONFIG.sizeof; |
| WORD wVersion; |
| WORD wReserved; |
| DCB dcb; |
| DWORD dwProviderSubType; |
| DWORD dwProviderOffset; |
| DWORD dwProviderSize; |
| WCHAR _wcProviderData = 0; |
| |
| WCHAR* wcProviderData() return { return &_wcProviderData; } |
| } |
| alias COMMCONFIG* LPCOMMCONFIG; |
| |
| struct COMMTIMEOUTS { |
| DWORD ReadIntervalTimeout; |
| DWORD ReadTotalTimeoutMultiplier; |
| DWORD ReadTotalTimeoutConstant; |
| DWORD WriteTotalTimeoutMultiplier; |
| DWORD WriteTotalTimeoutConstant; |
| } |
| alias COMMTIMEOUTS* LPCOMMTIMEOUTS; |
| |
| struct COMSTAT { |
| /+ |
| DWORD fCtsHold:1; |
| DWORD fDsrHold:1; |
| DWORD fRlsdHold:1; |
| DWORD fXoffHold:1; |
| DWORD fXoffSent:1; |
| DWORD fEof:1; |
| DWORD fTxim:1; |
| DWORD fReserved:25; |
| +/ |
| DWORD _bf; |
| bool fCtsHold(bool f) { _bf = (_bf & ~1) | f; return f; } |
| bool fDsrHold(bool f) { _bf = (_bf & ~2) | (f<<1); return f; } |
| bool fRlsdHold(bool f) { _bf = (_bf & ~4) | (f<<2); return f; } |
| bool fXoffHold(bool f) { _bf = (_bf & ~8) | (f<<3); return f; } |
| bool fXoffSent(bool f) { _bf = (_bf & ~16) | (f<<4); return f; } |
| bool fEof(bool f) { _bf = (_bf & ~32) | (f<<5); return f; } |
| bool fTxim(bool f) { _bf = (_bf & ~64) | (f<<6); return f; } |
| |
| bool fCtsHold() { return cast(bool) (_bf & 1); } |
| bool fDsrHold() { return cast(bool) (_bf & 2); } |
| bool fRlsdHold() { return cast(bool) (_bf & 4); } |
| bool fXoffHold() { return cast(bool) (_bf & 8); } |
| bool fXoffSent() { return cast(bool) (_bf & 16); } |
| bool fEof() { return cast(bool) (_bf & 32); } |
| bool fTxim() { return cast(bool) (_bf & 64); } |
| |
| DWORD cbInQue; |
| DWORD cbOutQue; |
| } |
| alias COMSTAT* LPCOMSTAT; |
| |
| struct CREATE_PROCESS_DEBUG_INFO { |
| HANDLE hFile; |
| HANDLE hProcess; |
| HANDLE hThread; |
| LPVOID lpBaseOfImage; |
| DWORD dwDebugInfoFileOffset; |
| DWORD nDebugInfoSize; |
| LPVOID lpThreadLocalBase; |
| LPTHREAD_START_ROUTINE lpStartAddress; |
| LPVOID lpImageName; |
| WORD fUnicode; |
| } |
| alias CREATE_PROCESS_DEBUG_INFO* LPCREATE_PROCESS_DEBUG_INFO; |
| |
| struct CREATE_THREAD_DEBUG_INFO { |
| HANDLE hThread; |
| LPVOID lpThreadLocalBase; |
| LPTHREAD_START_ROUTINE lpStartAddress; |
| } |
| alias CREATE_THREAD_DEBUG_INFO* LPCREATE_THREAD_DEBUG_INFO; |
| |
| struct EXCEPTION_DEBUG_INFO { |
| EXCEPTION_RECORD ExceptionRecord; |
| DWORD dwFirstChance; |
| } |
| alias EXCEPTION_DEBUG_INFO* LPEXCEPTION_DEBUG_INFO; |
| |
| struct EXIT_THREAD_DEBUG_INFO { |
| DWORD dwExitCode; |
| } |
| alias EXIT_THREAD_DEBUG_INFO* LPEXIT_THREAD_DEBUG_INFO; |
| |
| struct EXIT_PROCESS_DEBUG_INFO { |
| DWORD dwExitCode; |
| } |
| alias EXIT_PROCESS_DEBUG_INFO* LPEXIT_PROCESS_DEBUG_INFO; |
| |
| struct LOAD_DLL_DEBUG_INFO { |
| HANDLE hFile; |
| LPVOID lpBaseOfDll; |
| DWORD dwDebugInfoFileOffset; |
| DWORD nDebugInfoSize; |
| LPVOID lpImageName; |
| WORD fUnicode; |
| } |
| alias LOAD_DLL_DEBUG_INFO* LPLOAD_DLL_DEBUG_INFO; |
| |
| struct UNLOAD_DLL_DEBUG_INFO { |
| LPVOID lpBaseOfDll; |
| } |
| alias UNLOAD_DLL_DEBUG_INFO* LPUNLOAD_DLL_DEBUG_INFO; |
| |
| struct OUTPUT_DEBUG_STRING_INFO { |
| LPSTR lpDebugStringData; |
| WORD fUnicode; |
| WORD nDebugStringLength; |
| } |
| alias OUTPUT_DEBUG_STRING_INFO* LPOUTPUT_DEBUG_STRING_INFO; |
| |
| struct RIP_INFO { |
| DWORD dwError; |
| DWORD dwType; |
| } |
| alias RIP_INFO* LPRIP_INFO; |
| |
| struct DEBUG_EVENT { |
| DWORD dwDebugEventCode; |
| DWORD dwProcessId; |
| DWORD dwThreadId; |
| union { |
| EXCEPTION_DEBUG_INFO Exception; |
| CREATE_THREAD_DEBUG_INFO CreateThread; |
| CREATE_PROCESS_DEBUG_INFO CreateProcessInfo; |
| EXIT_THREAD_DEBUG_INFO ExitThread; |
| EXIT_PROCESS_DEBUG_INFO ExitProcess; |
| LOAD_DLL_DEBUG_INFO LoadDll; |
| UNLOAD_DLL_DEBUG_INFO UnloadDll; |
| OUTPUT_DEBUG_STRING_INFO DebugString; |
| RIP_INFO RipInfo; |
| } |
| } |
| alias DEBUG_EVENT* LPDEBUG_EVENT; |
| |
| struct OVERLAPPED { |
| ULONG_PTR Internal; |
| ULONG_PTR InternalHigh; |
| union { |
| struct { |
| DWORD Offset; |
| DWORD OffsetHigh; |
| } |
| PVOID Pointer; |
| } |
| HANDLE hEvent; |
| } |
| alias OVERLAPPED* POVERLAPPED, LPOVERLAPPED; |
| |
| struct STARTUPINFOA { |
| DWORD cb = STARTUPINFOA.sizeof; |
| LPSTR lpReserved; |
| LPSTR lpDesktop; |
| LPSTR lpTitle; |
| DWORD dwX; |
| DWORD dwY; |
| DWORD dwXSize; |
| DWORD dwYSize; |
| DWORD dwXCountChars; |
| DWORD dwYCountChars; |
| DWORD dwFillAttribute; |
| DWORD dwFlags; |
| WORD wShowWindow; |
| WORD cbReserved2; |
| PBYTE lpReserved2; |
| HANDLE hStdInput; |
| HANDLE hStdOutput; |
| HANDLE hStdError; |
| } |
| alias STARTUPINFOA* LPSTARTUPINFOA; |
| |
| struct STARTUPINFOW { |
| DWORD cb = STARTUPINFOW.sizeof; |
| LPWSTR lpReserved; |
| LPWSTR lpDesktop; |
| LPWSTR lpTitle; |
| DWORD dwX; |
| DWORD dwY; |
| DWORD dwXSize; |
| DWORD dwYSize; |
| DWORD dwXCountChars; |
| DWORD dwYCountChars; |
| DWORD dwFillAttribute; |
| DWORD dwFlags; |
| WORD wShowWindow; |
| WORD cbReserved2; |
| PBYTE lpReserved2; |
| HANDLE hStdInput; |
| HANDLE hStdOutput; |
| HANDLE hStdError; |
| } |
| alias STARTUPINFOW STARTUPINFO_W; |
| alias STARTUPINFOW* LPSTARTUPINFOW, LPSTARTUPINFO_W; |
| |
| struct PROCESS_INFORMATION { |
| HANDLE hProcess; |
| HANDLE hThread; |
| DWORD dwProcessId; |
| DWORD dwThreadId; |
| } |
| alias PROCESS_INFORMATION* PPROCESS_INFORMATION, LPPROCESS_INFORMATION; |
| |
| /* |
| struct CRITICAL_SECTION_DEBUG { |
| WORD Type; |
| WORD CreatorBackTraceIndex; |
| CRITICAL_SECTION* CriticalSection; |
| LIST_ENTRY ProcessLocksList; |
| DWORD EntryCount; |
| DWORD ContentionCount; |
| DWORD[2] Spare; |
| } |
| alias CRITICAL_SECTION_DEBUG* PCRITICAL_SECTION_DEBUG; |
| |
| struct CRITICAL_SECTION { |
| PCRITICAL_SECTION_DEBUG DebugInfo; |
| LONG LockCount; |
| LONG RecursionCount; |
| HANDLE OwningThread; |
| HANDLE LockSemaphore; |
| DWORD SpinCount; |
| } |
| alias CRITICAL_SECTION* PCRITICAL_SECTION, LPCRITICAL_SECTION; |
| */ |
| |
| alias CRITICAL_SECTION_DEBUG = RTL_CRITICAL_SECTION_DEBUG; |
| alias CRITICAL_SECTION_DEBUG* PCRITICAL_SECTION_DEBUG; |
| |
| alias CRITICAL_SECTION = RTL_CRITICAL_SECTION; |
| alias CRITICAL_SECTION* PCRITICAL_SECTION, LPCRITICAL_SECTION; |
| |
| struct SYSTEMTIME { |
| WORD wYear; |
| WORD wMonth; |
| WORD wDayOfWeek; |
| WORD wDay; |
| WORD wHour; |
| WORD wMinute; |
| WORD wSecond; |
| WORD wMilliseconds; |
| } |
| alias SYSTEMTIME* LPSYSTEMTIME; |
| |
| struct WIN32_FILE_ATTRIBUTE_DATA { |
| DWORD dwFileAttributes; |
| FILETIME ftCreationTime; |
| FILETIME ftLastAccessTime; |
| FILETIME ftLastWriteTime; |
| DWORD nFileSizeHigh; |
| DWORD nFileSizeLow; |
| } |
| alias WIN32_FILE_ATTRIBUTE_DATA* LPWIN32_FILE_ATTRIBUTE_DATA; |
| |
| struct WIN32_FIND_DATAA { |
| DWORD dwFileAttributes; |
| FILETIME ftCreationTime; |
| FILETIME ftLastAccessTime; |
| FILETIME ftLastWriteTime; |
| DWORD nFileSizeHigh; |
| DWORD nFileSizeLow; |
| // #ifdef _WIN32_WCE |
| // DWORD dwOID; |
| // #else |
| DWORD dwReserved0; |
| DWORD dwReserved1; |
| // #endif |
| CHAR[MAX_PATH] cFileName = 0; |
| // #ifndef _WIN32_WCE |
| CHAR[14] cAlternateFileName = 0; |
| // #endif |
| } |
| alias WIN32_FIND_DATAA* PWIN32_FIND_DATAA, LPWIN32_FIND_DATAA; |
| |
| struct WIN32_FIND_DATAW { |
| DWORD dwFileAttributes; |
| FILETIME ftCreationTime; |
| FILETIME ftLastAccessTime; |
| FILETIME ftLastWriteTime; |
| DWORD nFileSizeHigh; |
| DWORD nFileSizeLow; |
| // #ifdef _WIN32_WCE |
| // DWORD dwOID; |
| // #else |
| DWORD dwReserved0; |
| DWORD dwReserved1; |
| // #endif |
| WCHAR[MAX_PATH] cFileName = 0; |
| // #ifndef _WIN32_WCE |
| WCHAR[14] cAlternateFileName = 0; |
| // #endif |
| } |
| alias WIN32_FIND_DATAW* PWIN32_FIND_DATAW, LPWIN32_FIND_DATAW; |
| |
| struct WIN32_STREAM_ID { |
| DWORD dwStreamId; |
| DWORD dwStreamAttributes; |
| LARGE_INTEGER Size; |
| DWORD dwStreamNameSize; |
| WCHAR _cStreamName = 0; |
| |
| WCHAR* cStreamName() return { return &_cStreamName; } |
| } |
| alias WIN32_STREAM_ID* LPWIN32_STREAM_ID; |
| |
| static if (_WIN32_WINNT >= 0x601) { |
| enum FINDEX_INFO_LEVELS { |
| FindExInfoStandard, |
| FindExInfoBasic, |
| FindExInfoMaxInfoLevel, |
| } |
| } else { |
| enum FINDEX_INFO_LEVELS { |
| FindExInfoStandard, |
| FindExInfoMaxInfoLevel, |
| } |
| } |
| |
| enum FINDEX_SEARCH_OPS { |
| FindExSearchNameMatch, |
| FindExSearchLimitToDirectories, |
| FindExSearchLimitToDevices, |
| FindExSearchMaxSearchOp |
| } |
| |
| enum ACL_INFORMATION_CLASS { |
| AclRevisionInformation = 1, |
| AclSizeInformation |
| } |
| |
| struct HW_PROFILE_INFOA { |
| DWORD dwDockInfo; |
| CHAR[HW_PROFILE_GUIDLEN] szHwProfileGuid = 0; |
| CHAR[MAX_PROFILE_LEN] szHwProfileName = 0; |
| } |
| alias HW_PROFILE_INFOA* LPHW_PROFILE_INFOA; |
| |
| struct HW_PROFILE_INFOW { |
| DWORD dwDockInfo; |
| WCHAR[HW_PROFILE_GUIDLEN] szHwProfileGuid = 0; |
| WCHAR[MAX_PROFILE_LEN] szHwProfileName = 0; |
| } |
| alias HW_PROFILE_INFOW* LPHW_PROFILE_INFOW; |
| |
| /* ??? MSDN documents this only for Windows CE/Mobile, but it's used by |
| * GetFileAttributesEx, which is in desktop Windows. |
| */ |
| enum GET_FILEEX_INFO_LEVELS { |
| GetFileExInfoStandard, |
| GetFileExMaxInfoLevel |
| } |
| |
| struct SYSTEM_INFO { |
| union { |
| DWORD dwOemId; |
| struct { |
| WORD wProcessorArchitecture; |
| WORD wReserved; |
| } |
| } |
| DWORD dwPageSize; |
| PVOID lpMinimumApplicationAddress; |
| PVOID lpMaximumApplicationAddress; |
| DWORD_PTR dwActiveProcessorMask; |
| DWORD dwNumberOfProcessors; |
| DWORD dwProcessorType; |
| DWORD dwAllocationGranularity; |
| WORD wProcessorLevel; |
| WORD wProcessorRevision; |
| } |
| alias SYSTEM_INFO* LPSYSTEM_INFO; |
| |
| static if (_WIN32_WINNT >= 0x500) { |
| struct SYSTEM_POWER_STATUS { |
| BYTE ACLineStatus; |
| BYTE BatteryFlag; |
| BYTE BatteryLifePercent; |
| BYTE Reserved1; |
| DWORD BatteryLifeTime; |
| DWORD BatteryFullLifeTime; |
| } |
| alias SYSTEM_POWER_STATUS* LPSYSTEM_POWER_STATUS; |
| } |
| |
| struct TIME_ZONE_INFORMATION { |
| LONG Bias; |
| WCHAR[32] StandardName = 0; |
| SYSTEMTIME StandardDate; |
| LONG StandardBias; |
| WCHAR[32] DaylightName = 0; |
| SYSTEMTIME DaylightDate; |
| LONG DaylightBias; |
| } |
| alias TIME_ZONE_INFORMATION* LPTIME_ZONE_INFORMATION; |
| |
| // Does not exist in Windows headers, only MSDN |
| // documentation (for TIME_ZONE_INFORMATION). |
| // Provided solely for compatibility with the old |
| // core.sys.windows.windows |
| struct REG_TZI_FORMAT { |
| LONG Bias; |
| LONG StandardBias; |
| LONG DaylightBias; |
| SYSTEMTIME StandardDate; |
| SYSTEMTIME DaylightDate; |
| } |
| |
| // MSDN documents this, possibly erroneously, as Win2000+. |
| struct MEMORYSTATUS { |
| DWORD dwLength; |
| DWORD dwMemoryLoad; |
| SIZE_T dwTotalPhys; |
| SIZE_T dwAvailPhys; |
| SIZE_T dwTotalPageFile; |
| SIZE_T dwAvailPageFile; |
| SIZE_T dwTotalVirtual; |
| SIZE_T dwAvailVirtual; |
| } |
| alias MEMORYSTATUS* LPMEMORYSTATUS; |
| |
| static if (_WIN32_WINNT >= 0x500) { |
| struct MEMORYSTATUSEX { |
| DWORD dwLength; |
| DWORD dwMemoryLoad; |
| DWORDLONG ullTotalPhys; |
| DWORDLONG ullAvailPhys; |
| DWORDLONG ullTotalPageFile; |
| DWORDLONG ullAvailPageFile; |
| DWORDLONG ullTotalVirtual; |
| DWORDLONG ullAvailVirtual; |
| DWORDLONG ullAvailExtendedVirtual; |
| } |
| alias MEMORYSTATUSEX* LPMEMORYSTATUSEX; |
| } |
| |
| struct LDT_ENTRY { |
| WORD LimitLow; |
| WORD BaseLow; |
| struct { |
| BYTE BaseMid; |
| BYTE Flags1; |
| BYTE Flags2; |
| BYTE BaseHi; |
| |
| byte Type(byte f) { Flags1 = cast(BYTE) ((Flags1 & 0xE0) | f); return cast(byte)(f & 0x1F); } |
| byte Dpl(byte f) { Flags1 = cast(BYTE) ((Flags1 & 0x9F) | (f<<5)); return cast(byte)(f & 3); } |
| bool Pres(bool f) { Flags1 = cast(BYTE) ((Flags1 & 0x7F) | (f<<7)); return f; } |
| |
| byte LimitHi(byte f) { Flags2 = cast(BYTE) ((Flags2 & 0xF0) | (f&0x0F)); return cast(byte)(f & 0x0F); } |
| bool Sys(bool f) { Flags2 = cast(BYTE) ((Flags2 & 0xEF) | (f<<4)); return f; } |
| // Next bit is reserved |
| bool Default_Big(bool f) { Flags2 = cast(BYTE) ((Flags2 & 0xBF) | (f<<6)); return f; } |
| bool Granularity(bool f) { Flags2 = cast(BYTE) ((Flags2 & 0x7F) | (f<<7)); return f; } |
| |
| byte Type() { return cast(byte) (Flags1 & 0x1F); } |
| byte Dpl() { return cast(byte) ((Flags1 & 0x60)>>5); } |
| bool Pres() { return cast(bool) (Flags1 & 0x80); } |
| |
| byte LimitHi() { return cast(byte) (Flags2 & 0x0F); } |
| bool Sys() { return cast(bool) (Flags2 & 0x10); } |
| bool Default_Big() { return cast(bool) (Flags2 & 0x40); } |
| bool Granularity() { return cast(bool) (Flags2 & 0x80); } |
| } |
| /+ |
| union HighWord { |
| struct Bytes { |
| BYTE BaseMid; |
| BYTE Flags1; |
| BYTE Flags2; |
| BYTE BaseHi; |
| } |
| struct Bits { |
| DWORD BaseMid:8; |
| DWORD Type:5; |
| DWORD Dpl:2; |
| DWORD Pres:1; |
| DWORD LimitHi:4; |
| DWORD Sys:1; |
| DWORD Reserved_0:1; |
| DWORD Default_Big:1; |
| DWORD Granularity:1; |
| DWORD BaseHi:8; |
| } |
| } |
| +/ |
| } |
| alias LDT_ENTRY* PLDT_ENTRY, LPLDT_ENTRY; |
| |
| /* As with the other memory management functions and structures, MSDN's |
| * Windows version info shall be taken with a cup of salt. |
| */ |
| struct PROCESS_HEAP_ENTRY { |
| PVOID lpData; |
| DWORD cbData; |
| BYTE cbOverhead; |
| BYTE iRegionIndex; |
| WORD wFlags; |
| union { |
| struct _Block { |
| HANDLE hMem; |
| DWORD[3] dwReserved; |
| } |
| _Block Block; |
| struct _Region { |
| DWORD dwCommittedSize; |
| DWORD dwUnCommittedSize; |
| LPVOID lpFirstBlock; |
| LPVOID lpLastBlock; |
| } |
| _Region Region; |
| } |
| } |
| alias PROCESS_HEAP_ENTRY* LPPROCESS_HEAP_ENTRY; |
| |
| struct OFSTRUCT { |
| BYTE cBytes = OFSTRUCT.sizeof; |
| BYTE fFixedDisk; |
| WORD nErrCode; |
| WORD Reserved1; |
| WORD Reserved2; |
| CHAR[128] szPathName = 0; // const OFS_MAXPATHNAME = 128; |
| } |
| alias OFSTRUCT* LPOFSTRUCT, POFSTRUCT; |
| |
| /* ??? MSDN documents this only for Windows CE, but it's used by |
| * ImageGetCertificateData, which is in desktop Windows. |
| */ |
| struct WIN_CERTIFICATE { |
| DWORD dwLength; |
| WORD wRevision; |
| WORD wCertificateType; |
| BYTE _bCertificate; |
| |
| BYTE* bCertificate() return { return &_bCertificate; } |
| } |
| alias WIN_CERTIFICATE* LPWIN_CERTIFICATE; |
| |
| static if (_WIN32_WINNT >= 0x500) { |
| enum COMPUTER_NAME_FORMAT { |
| ComputerNameNetBIOS, |
| ComputerNameDnsHostname, |
| ComputerNameDnsDomain, |
| ComputerNameDnsFullyQualified, |
| ComputerNamePhysicalNetBIOS, |
| ComputerNamePhysicalDnsHostname, |
| ComputerNamePhysicalDnsDomain, |
| ComputerNamePhysicalDnsFullyQualified, |
| ComputerNameMax |
| } |
| } |
| |
| static if (_WIN32_WINNT >= 0x501) { |
| struct ACTCTXA { |
| ULONG cbSize = this.sizeof; |
| DWORD dwFlags; |
| LPCSTR lpSource; |
| USHORT wProcessorArchitecture; |
| LANGID wLangId; |
| LPCSTR lpAssemblyDirectory; |
| LPCSTR lpResourceName; |
| LPCSTR lpApplicationName; |
| HMODULE hModule; |
| } |
| alias ACTCTXA* PACTCTXA; |
| alias const(ACTCTXA)* PCACTCTXA; |
| |
| struct ACTCTXW { |
| ULONG cbSize = this.sizeof; |
| DWORD dwFlags; |
| LPCWSTR lpSource; |
| USHORT wProcessorArchitecture; |
| LANGID wLangId; |
| LPCWSTR lpAssemblyDirectory; |
| LPCWSTR lpResourceName; |
| LPCWSTR lpApplicationName; |
| HMODULE hModule; |
| } |
| alias ACTCTXW* PACTCTXW; |
| alias const(ACTCTXW)* PCACTCTXW; |
| |
| struct ACTCTX_SECTION_KEYED_DATA { |
| ULONG cbSize = this.sizeof; |
| ULONG ulDataFormatVersion; |
| PVOID lpData; |
| ULONG ulLength; |
| PVOID lpSectionGlobalData; |
| ULONG ulSectionGlobalDataLength; |
| PVOID lpSectionBase; |
| ULONG ulSectionTotalLength; |
| HANDLE hActCtx; |
| HANDLE ulAssemblyRosterIndex; |
| } |
| alias ACTCTX_SECTION_KEYED_DATA* PACTCTX_SECTION_KEYED_DATA; |
| alias const(ACTCTX_SECTION_KEYED_DATA)* PCACTCTX_SECTION_KEYED_DATA; |
| |
| enum MEMORY_RESOURCE_NOTIFICATION_TYPE { |
| LowMemoryResourceNotification, |
| HighMemoryResourceNotification |
| } |
| |
| } // (_WIN32_WINNT >= 0x501) |
| |
| static if (_WIN32_WINNT >= 0x410) { |
| /* apparently used only by SetThreadExecutionState (Win2000+) |
| * and DDK functions (version compatibility not established) |
| */ |
| alias DWORD EXECUTION_STATE; |
| } |
| |
| // CreateSymbolicLink |
| static if (_WIN32_WINNT >= 0x600) { |
| enum { |
| SYMBOLIC_LINK_FLAG_DIRECTORY = 0x1, |
| SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE = 0x2 |
| } |
| } |
| |
| // Callbacks |
| extern (Windows) { |
| alias DWORD function(LPVOID) LPTHREAD_START_ROUTINE; |
| alias DWORD function(LARGE_INTEGER, LARGE_INTEGER, LARGE_INTEGER, LARGE_INTEGER, |
| DWORD, DWORD, HANDLE, HANDLE, LPVOID) LPPROGRESS_ROUTINE; |
| alias void function(PVOID) LPFIBER_START_ROUTINE; |
| |
| alias BOOL function(HMODULE, LPCSTR, LPCSTR, WORD, LONG_PTR) ENUMRESLANGPROCA; |
| alias BOOL function(HMODULE, LPCWSTR, LPCWSTR, WORD, LONG_PTR) ENUMRESLANGPROCW; |
| alias BOOL function(HMODULE, LPCSTR, LPSTR, LONG_PTR) ENUMRESNAMEPROCA; |
| alias BOOL function(HMODULE, LPCWSTR, LPWSTR, LONG_PTR) ENUMRESNAMEPROCW; |
| alias BOOL function(HMODULE, LPSTR, LONG_PTR) ENUMRESTYPEPROCA; |
| alias BOOL function(HMODULE, LPWSTR, LONG_PTR) ENUMRESTYPEPROCW; |
| alias void function(DWORD, DWORD, LPOVERLAPPED) LPOVERLAPPED_COMPLETION_ROUTINE; |
| alias LONG function(LPEXCEPTION_POINTERS) PTOP_LEVEL_EXCEPTION_FILTER; |
| alias PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER; |
| |
| alias void function(ULONG_PTR) PAPCFUNC; |
| alias void function(PVOID, DWORD, DWORD) PTIMERAPCROUTINE; |
| |
| static if (_WIN32_WINNT >= 0x500) { |
| alias void function(PVOID, BOOLEAN) WAITORTIMERCALLBACK; |
| } |
| } |
| |
| LPTSTR MAKEINTATOM()(ushort i) { |
| return cast(LPTSTR) cast(size_t) i; |
| } |
| |
| extern (Windows) nothrow @nogc { |
| // The following Win16 functions are obselete in Win32. |
| int _hread(HFILE, LPVOID, int); |
| int _hwrite(HFILE, LPCSTR, int); |
| HFILE _lclose(HFILE); |
| HFILE _lcreat(LPCSTR, int); |
| LONG _llseek(HFILE, LONG, int); |
| HFILE _lopen(LPCSTR, int); |
| UINT _lread(HFILE, LPVOID, UINT); |
| UINT _lwrite(HFILE, LPCSTR, UINT); |
| SIZE_T GlobalCompact(DWORD); |
| VOID GlobalFix(HGLOBAL); |
| |
| // MSDN contradicts itself on GlobalFlags: |
| // "This function is provided only for compatibility with 16-bit versions of Windows." |
| // but also requires Windows 2000 or above |
| UINT GlobalFlags(HGLOBAL); |
| VOID GlobalUnfix(HGLOBAL); |
| BOOL GlobalUnWire(HGLOBAL); |
| PVOID GlobalWire(HGLOBAL); |
| SIZE_T LocalCompact(UINT); |
| UINT LocalFlags(HLOCAL); |
| SIZE_T LocalShrink(HLOCAL, UINT); |
| |
| /+ |
| //-------------------------------------- |
| // These functions are problematic |
| |
| version (UseNtoSKernel) {}else { |
| /* CAREFUL: These are exported from ntoskrnl.exe and declared in winddk.h |
| as __fastcall functions, but are exported from kernel32.dll as __stdcall */ |
| static if (_WIN32_WINNT >= 0x501) { |
| VOID InitializeSListHead(PSLIST_HEADER); |
| } |
| LONG InterlockedCompareExchange(LPLONG, LONG, LONG); |
| // PVOID WINAPI InterlockedCompareExchangePointer(PVOID*, PVOID, PVOID); |
| (PVOID)InterlockedCompareExchange((LPLONG)(d) (PVOID)InterlockedCompareExchange((LPLONG)(d), (LONG)(e), (LONG)(c)) |
| LONG InterlockedDecrement(LPLONG); |
| LONG InterlockedExchange(LPLONG, LONG); |
| // PVOID WINAPI InterlockedExchangePointer(PVOID*, PVOID); |
| (PVOID)InterlockedExchange((LPLONG)((PVOID)InterlockedExchange((LPLONG)(t), (LONG)(v)) |
| LONG InterlockedExchangeAdd(LPLONG, LONG); |
| |
| static if (_WIN32_WINNT >= 0x501) { |
| PSLIST_ENTRY InterlockedFlushSList(PSLIST_HEADER); |
| } |
| LONG InterlockedIncrement(LPLONG); |
| static if (_WIN32_WINNT >= 0x501) { |
| PSLIST_ENTRY InterlockedPopEntrySList(PSLIST_HEADER); |
| PSLIST_ENTRY InterlockedPushEntrySList(PSLIST_HEADER, PSLIST_ENTRY); |
| } |
| } // #endif // __USE_NTOSKRNL__ |
| //-------------------------------------- |
| +/ |
| |
| LONG InterlockedIncrement(LPLONG lpAddend); |
| LONG InterlockedDecrement(LPLONG lpAddend); |
| LONG InterlockedExchange(LPLONG Target, LONG Value); |
| LONG InterlockedExchangeAdd(LPLONG Addend, LONG Value); |
| LONG InterlockedCompareExchange(LONG *Destination, LONG Exchange, LONG Comperand); |
| |
| ATOM AddAtomA(LPCSTR); |
| ATOM AddAtomW(LPCWSTR); |
| BOOL AreFileApisANSI(); |
| BOOL Beep(DWORD, DWORD); |
| HANDLE BeginUpdateResourceA(LPCSTR, BOOL); |
| HANDLE BeginUpdateResourceW(LPCWSTR, BOOL); |
| BOOL BuildCommDCBA(LPCSTR, LPDCB); |
| BOOL BuildCommDCBW(LPCWSTR, LPDCB); |
| BOOL BuildCommDCBAndTimeoutsA(LPCSTR, LPDCB, LPCOMMTIMEOUTS); |
| BOOL BuildCommDCBAndTimeoutsW(LPCWSTR, LPDCB, LPCOMMTIMEOUTS); |
| BOOL CallNamedPipeA(LPCSTR, PVOID, DWORD, PVOID, DWORD, PDWORD, DWORD); |
| BOOL CallNamedPipeW(LPCWSTR, PVOID, DWORD, PVOID, DWORD, PDWORD, DWORD); |
| BOOL CancelDeviceWakeupRequest(HANDLE); |
| BOOL CheckTokenMembership(HANDLE, PSID, PBOOL); |
| BOOL ClearCommBreak(HANDLE); |
| BOOL ClearCommError(HANDLE, PDWORD, LPCOMSTAT); |
| BOOL CloseHandle(HANDLE) @trusted; |
| BOOL CommConfigDialogA(LPCSTR, HWND, LPCOMMCONFIG); |
| BOOL CommConfigDialogW(LPCWSTR, HWND, LPCOMMCONFIG); |
| LONG CompareFileTime(const(FILETIME)*, const(FILETIME)*); |
| BOOL ContinueDebugEvent(DWORD, DWORD, DWORD); |
| BOOL CopyFileA(LPCSTR, LPCSTR, BOOL); |
| BOOL CopyFileW(LPCWSTR, LPCWSTR, BOOL); |
| BOOL CopyFileExA(LPCSTR, LPCSTR, LPPROGRESS_ROUTINE, LPVOID, LPBOOL, DWORD); |
| BOOL CopyFileExW(LPCWSTR, LPCWSTR, LPPROGRESS_ROUTINE, LPVOID, LPBOOL, DWORD); |
| |
| /+ FIXME |
| alias memmove RtlMoveMemory; |
| alias memcpy RtlCopyMemory; |
| |
| void RtlFillMemory(PVOID dest, SIZE_T len, BYTE fill) { |
| memset(dest, fill, len); |
| } |
| |
| void RtlZeroMemory(PVOID dest, SIZE_T len) { |
| RtlFillMemory(dest, len, 0); |
| } |
| |
| alias RtlMoveMemory MoveMemory; |
| alias RtlCopyMemory CopyMemory; |
| alias RtlFillMemory FillMemory; |
| alias RtlZeroMemory ZeroMemory; |
| +/ |
| BOOL CreateDirectoryA(LPCSTR, LPSECURITY_ATTRIBUTES); |
| BOOL CreateDirectoryW(LPCWSTR, LPSECURITY_ATTRIBUTES); |
| BOOL CreateDirectoryExA(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES); |
| BOOL CreateDirectoryExW(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES); |
| HANDLE CreateEventA(LPSECURITY_ATTRIBUTES, BOOL, BOOL, LPCSTR); |
| HANDLE CreateEventW(LPSECURITY_ATTRIBUTES, BOOL, BOOL, LPCWSTR); |
| HANDLE CreateFileA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE); |
| HANDLE CreateFileW(LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE); |
| HANDLE CreateIoCompletionPort(HANDLE, HANDLE, ULONG_PTR, DWORD); |
| HANDLE CreateMailslotA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES); |
| HANDLE CreateMailslotW(LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES); |
| HANDLE CreateMutexA(LPSECURITY_ATTRIBUTES, BOOL, LPCSTR); |
| HANDLE CreateMutexW(LPSECURITY_ATTRIBUTES, BOOL, LPCWSTR); |
| BOOL CreatePipe(PHANDLE, PHANDLE, LPSECURITY_ATTRIBUTES, DWORD); |
| BOOL CreateProcessA(LPCSTR, LPSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCSTR, LPSTARTUPINFOA, LPPROCESS_INFORMATION); |
| BOOL CreateProcessW(LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION); |
| HANDLE CreateSemaphoreA(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCSTR) @trusted; |
| HANDLE CreateSemaphoreW(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCWSTR) @trusted; |
| HANDLE CreateThread(LPSECURITY_ATTRIBUTES, SIZE_T, LPTHREAD_START_ROUTINE, PVOID, DWORD, PDWORD); |
| BOOL DebugActiveProcess(DWORD); |
| void DebugBreak(); |
| ATOM DeleteAtom(ATOM); |
| void DeleteCriticalSection(PCRITICAL_SECTION); |
| BOOL DeleteFileA(LPCSTR); |
| BOOL DeleteFileW(LPCWSTR); |
| BOOL DisableThreadLibraryCalls(HMODULE); |
| BOOL DosDateTimeToFileTime(WORD, WORD, LPFILETIME); |
| BOOL DuplicateHandle(HANDLE, HANDLE, HANDLE, PHANDLE, DWORD, BOOL, DWORD); |
| BOOL EndUpdateResourceA(HANDLE, BOOL); |
| BOOL EndUpdateResourceW(HANDLE, BOOL); |
| void EnterCriticalSection(LPCRITICAL_SECTION); |
| void EnterCriticalSection(shared(CRITICAL_SECTION)*); |
| BOOL EnumResourceLanguagesA(HMODULE, LPCSTR, LPCSTR, ENUMRESLANGPROC, LONG_PTR); |
| BOOL EnumResourceLanguagesW(HMODULE, LPCWSTR, LPCWSTR, ENUMRESLANGPROC, LONG_PTR); |
| BOOL EnumResourceNamesA(HMODULE, LPCSTR, ENUMRESNAMEPROC, LONG_PTR); |
| BOOL EnumResourceNamesW(HMODULE, LPCWSTR, ENUMRESNAMEPROC, LONG_PTR); |
| BOOL EnumResourceTypesA(HMODULE, ENUMRESTYPEPROC, LONG_PTR); |
| BOOL EnumResourceTypesW(HMODULE, ENUMRESTYPEPROC, LONG_PTR); |
| BOOL EscapeCommFunction(HANDLE, DWORD); |
| void ExitProcess(UINT); // Never returns |
| void ExitThread(DWORD); // Never returns |
| DWORD ExpandEnvironmentStringsA(LPCSTR, LPSTR, DWORD); |
| DWORD ExpandEnvironmentStringsW(LPCWSTR, LPWSTR, DWORD); |
| void FatalAppExitA(UINT, LPCSTR); |
| void FatalAppExitW(UINT, LPCWSTR); |
| void FatalExit(int); |
| BOOL FileTimeToDosDateTime(const(FILETIME)*, LPWORD, LPWORD); |
| BOOL FileTimeToLocalFileTime(const(FILETIME)*, LPFILETIME); |
| BOOL FileTimeToSystemTime(const(FILETIME)*, LPSYSTEMTIME); |
| ATOM FindAtomA(LPCSTR); |
| ATOM FindAtomW(LPCWSTR); |
| BOOL FindClose(HANDLE); |
| BOOL FindCloseChangeNotification(HANDLE); |
| HANDLE FindFirstChangeNotificationA(LPCSTR, BOOL, DWORD); |
| HANDLE FindFirstChangeNotificationW(LPCWSTR, BOOL, DWORD); |
| HANDLE FindFirstFileA(LPCSTR, LPWIN32_FIND_DATAA); |
| HANDLE FindFirstFileW(LPCWSTR, LPWIN32_FIND_DATAW); |
| BOOL FindNextChangeNotification(HANDLE); |
| BOOL FindNextFileA(HANDLE, LPWIN32_FIND_DATAA); |
| BOOL FindNextFileW(HANDLE, LPWIN32_FIND_DATAW); |
| HRSRC FindResourceA(HMODULE, LPCSTR, LPCSTR); |
| HRSRC FindResourceW(HINSTANCE, LPCWSTR, LPCWSTR); |
| HRSRC FindResourceExA(HINSTANCE, LPCSTR, LPCSTR, WORD); |
| HRSRC FindResourceExW(HINSTANCE, LPCWSTR, LPCWSTR, WORD); |
| BOOL FlushFileBuffers(HANDLE); |
| BOOL FlushInstructionCache(HANDLE, PCVOID, SIZE_T); |
| DWORD FormatMessageA(DWORD, PCVOID, DWORD, DWORD, LPSTR, DWORD, va_list*); |
| DWORD FormatMessageW(DWORD, PCVOID, DWORD, DWORD, LPWSTR, DWORD, va_list*); |
| BOOL FreeEnvironmentStringsA(LPSTR); |
| BOOL FreeEnvironmentStringsW(LPWSTR); |
| BOOL FreeLibrary(HMODULE); |
| void FreeLibraryAndExitThread(HMODULE, DWORD); // never returns |
| BOOL FreeResource(HGLOBAL); |
| UINT GetAtomNameA(ATOM, LPSTR, int); |
| UINT GetAtomNameW(ATOM, LPWSTR, int); |
| LPSTR GetCommandLineA(); |
| LPWSTR GetCommandLineW(); |
| BOOL GetCommConfig(HANDLE, LPCOMMCONFIG, PDWORD); |
| BOOL GetCommMask(HANDLE, PDWORD); |
| BOOL GetCommModemStatus(HANDLE, PDWORD); |
| BOOL GetCommProperties(HANDLE, LPCOMMPROP); |
| BOOL GetCommState(HANDLE, LPDCB); |
| BOOL GetCommTimeouts(HANDLE, LPCOMMTIMEOUTS); |
| BOOL GetComputerNameA(LPSTR, PDWORD); |
| BOOL GetComputerNameW(LPWSTR, PDWORD); |
| DWORD GetCurrentDirectoryA(DWORD, LPSTR); |
| DWORD GetCurrentDirectoryW(DWORD, LPWSTR); |
| HANDLE GetCurrentProcess(); |
| DWORD GetCurrentProcessId(); |
| HANDLE GetCurrentThread(); |
| /* In MinGW: |
| #ifdef _WIN32_WCE |
| extern DWORD GetCurrentThreadId(void); |
| #else |
| WINBASEAPI DWORD WINAPI GetCurrentThreadId(void); |
| #endif |
| */ |
| DWORD GetCurrentThreadId(); |
| |
| alias GetTickCount GetCurrentTime; |
| |
| BOOL GetDefaultCommConfigA(LPCSTR, LPCOMMCONFIG, PDWORD); |
| BOOL GetDefaultCommConfigW(LPCWSTR, LPCOMMCONFIG, PDWORD); |
| BOOL GetDiskFreeSpaceA(LPCSTR, PDWORD, PDWORD, PDWORD, PDWORD); |
| BOOL GetDiskFreeSpaceW(LPCWSTR, PDWORD, PDWORD, PDWORD, PDWORD); |
| BOOL GetDiskFreeSpaceExA(LPCSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER); |
| BOOL GetDiskFreeSpaceExW(LPCWSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER); |
| UINT GetDriveTypeA(LPCSTR); |
| UINT GetDriveTypeW(LPCWSTR); |
| LPSTR GetEnvironmentStringsA(); |
| LPWSTR GetEnvironmentStringsW(); |
| DWORD GetEnvironmentVariableA(LPCSTR, LPSTR, DWORD); |
| DWORD GetEnvironmentVariableW(LPCWSTR, LPWSTR, DWORD); |
| BOOL GetExitCodeProcess(HANDLE, PDWORD); |
| BOOL GetExitCodeThread(HANDLE, PDWORD); |
| DWORD GetFileAttributesA(LPCSTR); |
| DWORD GetFileAttributesW(LPCWSTR); |
| BOOL GetFileInformationByHandle(HANDLE, LPBY_HANDLE_FILE_INFORMATION); |
| DWORD GetFileSize(HANDLE, PDWORD); |
| BOOL GetFileTime(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME); |
| DWORD GetFileType(HANDLE); |
| DWORD GetFullPathNameA(LPCSTR, DWORD, LPSTR, LPSTR*); |
| DWORD GetFullPathNameW(LPCWSTR, DWORD, LPWSTR, LPWSTR*); |
| DWORD GetLastError() @trusted; |
| void GetLocalTime(LPSYSTEMTIME); |
| DWORD GetLogicalDrives(); |
| DWORD GetLogicalDriveStringsA(DWORD, LPSTR); |
| DWORD GetLogicalDriveStringsW(DWORD, LPWSTR); |
| BOOL GetMailslotInfo(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD); |
| DWORD GetModuleFileNameA(HINSTANCE, LPSTR, DWORD); |
| DWORD GetModuleFileNameW(HINSTANCE, LPWSTR, DWORD); |
| HMODULE GetModuleHandleA(LPCSTR); |
| HMODULE GetModuleHandleW(LPCWSTR); |
| BOOL GetNamedPipeHandleStateA(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD, LPSTR, DWORD); |
| BOOL GetNamedPipeHandleStateW(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD, LPWSTR, DWORD); |
| BOOL GetNamedPipeInfo(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD); |
| BOOL GetOverlappedResult(HANDLE, LPOVERLAPPED, PDWORD, BOOL); |
| DWORD GetPriorityClass(HANDLE); |
| UINT GetPrivateProfileIntA(LPCSTR, LPCSTR, INT, LPCSTR); |
| UINT GetPrivateProfileIntW(LPCWSTR, LPCWSTR, INT, LPCWSTR); |
| DWORD GetPrivateProfileSectionA(LPCSTR, LPSTR, DWORD, LPCSTR); |
| DWORD GetPrivateProfileSectionW(LPCWSTR, LPWSTR, DWORD, LPCWSTR); |
| DWORD GetPrivateProfileSectionNamesA(LPSTR, DWORD, LPCSTR); |
| DWORD GetPrivateProfileSectionNamesW(LPWSTR, DWORD, LPCWSTR); |
| DWORD GetPrivateProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPSTR, DWORD, LPCSTR); |
| DWORD GetPrivateProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, DWORD, LPCWSTR); |
| BOOL GetPrivateProfileStructA(LPCSTR, LPCSTR, LPVOID, UINT, LPCSTR); |
| BOOL GetPrivateProfileStructW(LPCWSTR, LPCWSTR, LPVOID, UINT, LPCWSTR); |
| FARPROC GetProcAddress(HMODULE, LPCSTR); // 1st param wrongly HINSTANCE in MinGW |
| BOOL GetProcessAffinityMask(HANDLE, PDWORD_PTR, PDWORD_PTR); |
| DWORD GetProcessVersion(DWORD); |
| UINT GetProfileIntA(LPCSTR, LPCSTR, INT); |
| UINT GetProfileIntW(LPCWSTR, LPCWSTR, INT); |
| DWORD GetProfileSectionA(LPCSTR, LPSTR, DWORD); |
| DWORD GetProfileSectionW(LPCWSTR, LPWSTR, DWORD); |
| DWORD GetProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPSTR, DWORD); |
| DWORD GetProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, DWORD); |
| DWORD GetShortPathNameA(LPCSTR, LPSTR, DWORD); |
| DWORD GetShortPathNameW(LPCWSTR, LPWSTR, DWORD); |
| VOID GetStartupInfoA(LPSTARTUPINFOA); |
| VOID GetStartupInfoW(LPSTARTUPINFOW); |
| HANDLE GetStdHandle(DWORD); |
| UINT GetSystemDirectoryA(LPSTR, UINT); |
| UINT GetSystemDirectoryW(LPWSTR, UINT); |
| VOID GetSystemInfo(LPSYSTEM_INFO); |
| VOID GetSystemTime(LPSYSTEMTIME); |
| BOOL GetSystemTimeAdjustment(PDWORD, PDWORD, PBOOL); |
| void GetSystemTimeAsFileTime(LPFILETIME); |
| UINT GetTempFileNameA(LPCSTR, LPCSTR, UINT, LPSTR); |
| UINT GetTempFileNameW(LPCWSTR, LPCWSTR, UINT, LPWSTR); |
| DWORD GetTempPathA(DWORD, LPSTR); |
| DWORD GetTempPathW(DWORD, LPWSTR); |
| BOOL GetThreadContext(HANDLE, LPCONTEXT); |
| int GetThreadPriority(HANDLE); |
| BOOL GetThreadSelectorEntry(HANDLE, DWORD, LPLDT_ENTRY); |
| DWORD GetTickCount(); |
| DWORD GetTimeZoneInformation(LPTIME_ZONE_INFORMATION); |
| BOOL GetUserNameA (LPSTR, PDWORD); |
| BOOL GetUserNameW(LPWSTR, PDWORD); |
| DWORD GetVersion(); |
| BOOL GetVersionExA(LPOSVERSIONINFOA); |
| BOOL GetVersionExW(LPOSVERSIONINFOW); |
| BOOL GetVolumeInformationA(LPCSTR, LPSTR, DWORD, PDWORD, PDWORD, PDWORD, LPSTR, DWORD); |
| BOOL GetVolumeInformationW(LPCWSTR, LPWSTR, DWORD, PDWORD, PDWORD, PDWORD, LPWSTR, DWORD); |
| UINT GetWindowsDirectoryA(LPSTR, UINT); |
| UINT GetWindowsDirectoryW(LPWSTR, UINT); |
| DWORD GetWindowThreadProcessId(HWND, PDWORD); |
| ATOM GlobalAddAtomA(LPCSTR); |
| ATOM GlobalAddAtomW(LPCWSTR); |
| ATOM GlobalDeleteAtom(ATOM); |
| ATOM GlobalFindAtomA(LPCSTR); |
| ATOM GlobalFindAtomW(LPCWSTR); |
| UINT GlobalGetAtomNameA(ATOM, LPSTR, int); |
| UINT GlobalGetAtomNameW(ATOM, LPWSTR, int); |
| |
| bool HasOverlappedIoCompleted(LPOVERLAPPED lpOverlapped) { |
| return lpOverlapped.Internal != STATUS_PENDING; |
| } |
| |
| BOOL InitAtomTable(DWORD); |
| VOID InitializeCriticalSection(LPCRITICAL_SECTION) @trusted; |
| /* ??? The next two are allegedly obsolete and "supported only for |
| * backward compatibility with the 16-bit Windows API". Yet the |
| * replacements IsBadReadPtr and IsBadWritePtr are apparently Win2000+ |
| * only. Where's the mistake? |
| */ |
| BOOL IsBadHugeReadPtr(PCVOID, UINT_PTR); |
| BOOL IsBadHugeWritePtr(PVOID, UINT_PTR); |
| BOOL IsBadReadPtr(PCVOID, UINT_PTR); |
| BOOL IsBadStringPtrA(LPCSTR, UINT_PTR); |
| BOOL IsBadStringPtrW(LPCWSTR, UINT_PTR); |
| BOOL IsBadWritePtr(PVOID, UINT_PTR); |
| void LeaveCriticalSection(LPCRITICAL_SECTION); |
| void LeaveCriticalSection(shared(CRITICAL_SECTION)*); |
| HINSTANCE LoadLibraryA(LPCSTR); |
| HINSTANCE LoadLibraryW(LPCWSTR); |
| HINSTANCE LoadLibraryExA(LPCSTR, HANDLE, DWORD); |
| HINSTANCE LoadLibraryExW(LPCWSTR, HANDLE, DWORD); |
| DWORD LoadModule(LPCSTR, PVOID); |
| HGLOBAL LoadResource(HINSTANCE, HRSRC); |
| BOOL LocalFileTimeToFileTime(const(FILETIME)*, LPFILETIME); |
| BOOL LockFile(HANDLE, DWORD, DWORD, DWORD, DWORD); |
| PVOID LockResource(HGLOBAL); |
| |
| LPSTR lstrcatA(LPSTR, LPCSTR); |
| LPWSTR lstrcatW(LPWSTR, LPCWSTR); |
| int lstrcmpA(LPCSTR, LPCSTR); |
| int lstrcmpiA(LPCSTR, LPCSTR); |
| int lstrcmpiW(LPCWSTR, LPCWSTR); |
| int lstrcmpW(LPCWSTR, LPCWSTR); |
| LPSTR lstrcpyA(LPSTR, LPCSTR); |
| LPSTR lstrcpynA(LPSTR, LPCSTR, int); |
| LPWSTR lstrcpynW(LPWSTR, LPCWSTR, int); |
| LPWSTR lstrcpyW(LPWSTR, LPCWSTR); |
| int lstrlenA(LPCSTR); |
| int lstrlenW(LPCWSTR); |
| |
| BOOL MoveFileA(LPCSTR, LPCSTR); |
| BOOL MoveFileW(LPCWSTR, LPCWSTR); |
| int MulDiv(int, int, int); |
| HANDLE OpenEventA(DWORD, BOOL, LPCSTR); |
| HANDLE OpenEventW(DWORD, BOOL, LPCWSTR); |
| deprecated HFILE OpenFile(LPCSTR, LPOFSTRUCT, UINT); |
| HANDLE OpenMutexA(DWORD, BOOL, LPCSTR); |
| HANDLE OpenMutexW(DWORD, BOOL, LPCWSTR); |
| HANDLE OpenProcess(DWORD, BOOL, DWORD); |
| HANDLE OpenSemaphoreA(DWORD, BOOL, LPCSTR); |
| HANDLE OpenSemaphoreW(DWORD, BOOL, LPCWSTR); |
| void OutputDebugStringA(LPCSTR); |
| void OutputDebugStringW(LPCWSTR); |
| BOOL PeekNamedPipe(HANDLE, PVOID, DWORD, PDWORD, PDWORD, PDWORD); |
| BOOL PulseEvent(HANDLE); |
| BOOL PurgeComm(HANDLE, DWORD); |
| BOOL QueryPerformanceCounter(PLARGE_INTEGER); |
| BOOL QueryPerformanceFrequency(PLARGE_INTEGER); |
| DWORD QueueUserAPC(PAPCFUNC, HANDLE, ULONG_PTR); |
| void RaiseException(DWORD, DWORD, DWORD, const(ULONG_PTR)*); |
| BOOL ReadFile(HANDLE, PVOID, DWORD, PDWORD, LPOVERLAPPED); |
| BOOL ReadFileEx(HANDLE, PVOID, DWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE); |
| BOOL ReadProcessMemory(HANDLE, PCVOID, PVOID, SIZE_T, SIZE_T*); |
| BOOL ReleaseMutex(HANDLE); |
| BOOL ReleaseSemaphore(HANDLE, LONG, LPLONG); |
| BOOL RemoveDirectoryA(LPCSTR); |
| BOOL RemoveDirectoryW(LPCWSTR); |
| /* In MinGW: |
| #ifdef _WIN32_WCE |
| extern BOOL ResetEvent(HANDLE); |
| #else |
| WINBASEAPI BOOL WINAPI ResetEvent(HANDLE); |
| #endif |
| */ |
| BOOL ResetEvent(HANDLE); |
| DWORD ResumeThread(HANDLE); |
| DWORD SearchPathA(LPCSTR, LPCSTR, LPCSTR, DWORD, LPSTR, LPSTR*); |
| DWORD SearchPathW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPWSTR, LPWSTR*); |
| BOOL SetCommBreak(HANDLE); |
| BOOL SetCommConfig(HANDLE, LPCOMMCONFIG, DWORD); |
| BOOL SetCommMask(HANDLE, DWORD); |
| BOOL SetCommState(HANDLE, LPDCB); |
| BOOL SetCommTimeouts(HANDLE, LPCOMMTIMEOUTS); |
| BOOL SetComputerNameA(LPCSTR); |
| BOOL SetComputerNameW(LPCWSTR); |
| BOOL SetCurrentDirectoryA(LPCSTR); |
| BOOL SetCurrentDirectoryW(LPCWSTR); |
| BOOL SetDefaultCommConfigA(LPCSTR, LPCOMMCONFIG, DWORD); |
| BOOL SetDefaultCommConfigW(LPCWSTR, LPCOMMCONFIG, DWORD); |
| BOOL SetEndOfFile(HANDLE); |
| BOOL SetEnvironmentVariableA(LPCSTR, LPCSTR); |
| BOOL SetEnvironmentVariableW(LPCWSTR, LPCWSTR); |
| UINT SetErrorMode(UINT); |
| /* In MinGW: |
| #ifdef _WIN32_WCE |
| extern BOOL SetEvent(HANDLE); |
| #else |
| WINBASEAPI BOOL WINAPI SetEvent(HANDLE); |
| #endif |
| */ |
| BOOL SetEvent(HANDLE); |
| VOID SetFileApisToANSI(); |
| VOID SetFileApisToOEM(); |
| BOOL SetFileAttributesA(LPCSTR, DWORD); |
| BOOL SetFileAttributesW(LPCWSTR, DWORD); |
| DWORD SetFilePointer(HANDLE, LONG, PLONG, DWORD); |
| BOOL SetFileTime(HANDLE, const(FILETIME)*, const(FILETIME)*, const(FILETIME)*); |
| deprecated UINT SetHandleCount(UINT); |
| void SetLastError(DWORD); |
| void SetLastErrorEx(DWORD, DWORD); |
| BOOL SetLocalTime(const(SYSTEMTIME)*); |
| BOOL SetMailslotInfo(HANDLE, DWORD); |
| BOOL SetNamedPipeHandleState(HANDLE, PDWORD, PDWORD, PDWORD); |
| BOOL SetPriorityClass(HANDLE, DWORD); |
| BOOL SetStdHandle(DWORD, HANDLE); |
| BOOL SetSystemTime(const(SYSTEMTIME)*); |
| DWORD_PTR SetThreadAffinityMask(HANDLE, DWORD_PTR); |
| BOOL SetThreadContext(HANDLE, const(CONTEXT)*); |
| BOOL SetThreadPriority(HANDLE, int); |
| BOOL SetTimeZoneInformation(const(TIME_ZONE_INFORMATION)*); |
| LPTOP_LEVEL_EXCEPTION_FILTER SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER); |
| BOOL SetupComm(HANDLE, DWORD, DWORD); |
| BOOL SetVolumeLabelA(LPCSTR, LPCSTR); |
| BOOL SetVolumeLabelW(LPCWSTR, LPCWSTR); |
| |
| DWORD SizeofResource(HINSTANCE, HRSRC); |
| void Sleep(DWORD); |
| DWORD SleepEx(DWORD, BOOL); |
| DWORD SuspendThread(HANDLE); |
| BOOL SystemTimeToFileTime(const(SYSTEMTIME)*, LPFILETIME); |
| BOOL TerminateProcess(HANDLE, UINT); |
| BOOL TerminateThread(HANDLE, DWORD); |
| DWORD TlsAlloc(); |
| BOOL TlsFree(DWORD); |
| PVOID TlsGetValue(DWORD); |
| BOOL TlsSetValue(DWORD, PVOID); |
| BOOL TransactNamedPipe(HANDLE, PVOID, DWORD, PVOID, DWORD, PDWORD, LPOVERLAPPED); |
| BOOL TransmitCommChar(HANDLE, char); |
| LONG UnhandledExceptionFilter(LPEXCEPTION_POINTERS); |
| BOOL UnlockFile(HANDLE, DWORD, DWORD, DWORD, DWORD); |
| BOOL WaitCommEvent(HANDLE, PDWORD, LPOVERLAPPED); |
| BOOL WaitForDebugEvent(LPDEBUG_EVENT, DWORD); |
| DWORD WaitForMultipleObjects(DWORD, const(HANDLE)*, BOOL, DWORD); |
| DWORD WaitForMultipleObjectsEx(DWORD, const(HANDLE)*, BOOL, DWORD, BOOL); |
| DWORD WaitForSingleObject(HANDLE, DWORD); |
| DWORD WaitForSingleObjectEx(HANDLE, DWORD, BOOL); |
| BOOL WaitNamedPipeA(LPCSTR, DWORD); |
| BOOL WaitNamedPipeW(LPCWSTR, DWORD); |
| // undocumented on MSDN |
| BOOL WinLoadTrustProvider(GUID*); |
| BOOL WriteFile(HANDLE, PCVOID, DWORD, PDWORD, LPOVERLAPPED); |
| BOOL WriteFileEx(HANDLE, PCVOID, DWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE); |
| BOOL WritePrivateProfileSectionA(LPCSTR, LPCSTR, LPCSTR); |
| BOOL WritePrivateProfileSectionW(LPCWSTR, LPCWSTR, LPCWSTR); |
| BOOL WritePrivateProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPCSTR); |
| BOOL WritePrivateProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR); |
| BOOL WritePrivateProfileStructA(LPCSTR, LPCSTR, LPVOID, UINT, LPCSTR); |
| BOOL WritePrivateProfileStructW(LPCWSTR, LPCWSTR, LPVOID, UINT, LPCWSTR); |
| BOOL WriteProcessMemory(HANDLE, LPVOID, LPCVOID, SIZE_T, SIZE_T*); |
| BOOL WriteProfileSectionA(LPCSTR, LPCSTR); |
| BOOL WriteProfileSectionW(LPCWSTR, LPCWSTR); |
| BOOL WriteProfileStringA(LPCSTR, LPCSTR, LPCSTR); |
| BOOL WriteProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR); |
| |
| /* Memory allocation functions. |
| * MSDN documents these erroneously as Win2000+; thus it is uncertain what |
| * version compatibility they really have. |
| */ |
| HGLOBAL GlobalAlloc(UINT, SIZE_T); |
| HGLOBAL GlobalDiscard(HGLOBAL); |
| HGLOBAL GlobalFree(HGLOBAL); |
| HGLOBAL GlobalHandle(PCVOID); |
| LPVOID GlobalLock(HGLOBAL); |
| VOID GlobalMemoryStatus(LPMEMORYSTATUS); |
| HGLOBAL GlobalReAlloc(HGLOBAL, SIZE_T, UINT); |
| SIZE_T GlobalSize(HGLOBAL); |
| BOOL GlobalUnlock(HGLOBAL); |
| PVOID HeapAlloc(HANDLE, DWORD, SIZE_T); |
| SIZE_T HeapCompact(HANDLE, DWORD); |
| HANDLE HeapCreate(DWORD, SIZE_T, SIZE_T); |
| BOOL HeapDestroy(HANDLE); |
| BOOL HeapFree(HANDLE, DWORD, PVOID); |
| BOOL HeapLock(HANDLE); |
| PVOID HeapReAlloc(HANDLE, DWORD, PVOID, SIZE_T); |
| SIZE_T HeapSize(HANDLE, DWORD, PCVOID); |
| BOOL HeapUnlock(HANDLE); |
| BOOL HeapValidate(HANDLE, DWORD, PCVOID); |
| BOOL HeapWalk(HANDLE, LPPROCESS_HEAP_ENTRY); |
| HLOCAL LocalAlloc(UINT, SIZE_T); |
| HLOCAL LocalDiscard(HLOCAL); |
| HLOCAL LocalFree(HLOCAL); |
| HLOCAL LocalHandle(LPCVOID); |
| PVOID LocalLock(HLOCAL); |
| HLOCAL LocalReAlloc(HLOCAL, SIZE_T, UINT); |
| SIZE_T LocalSize(HLOCAL); |
| BOOL LocalUnlock(HLOCAL); |
| PVOID VirtualAlloc(PVOID, SIZE_T, DWORD, DWORD); |
| PVOID VirtualAllocEx(HANDLE, PVOID, SIZE_T, DWORD, DWORD); |
| BOOL VirtualFree(PVOID, SIZE_T, DWORD); |
| BOOL VirtualFreeEx(HANDLE, PVOID, SIZE_T, DWORD); |
| BOOL VirtualLock(PVOID, SIZE_T); |
| BOOL VirtualProtect(PVOID, SIZE_T, DWORD, PDWORD); |
| BOOL VirtualProtectEx(HANDLE, PVOID, SIZE_T, DWORD, PDWORD); |
| SIZE_T VirtualQuery(LPCVOID, PMEMORY_BASIC_INFORMATION, SIZE_T); |
| SIZE_T VirtualQueryEx(HANDLE, LPCVOID, PMEMORY_BASIC_INFORMATION, SIZE_T); |
| BOOL VirtualUnlock(PVOID, SIZE_T); |
| // not in MinGW 4.0 - ??? |
| static if (_WIN32_WINNT >= 0x600) { |
| BOOL CancelIoEx(HANDLE, LPOVERLAPPED); |
| } |
| |
| BOOL CancelIo(HANDLE); |
| BOOL CancelWaitableTimer(HANDLE); |
| PVOID ConvertThreadToFiber(PVOID); |
| LPVOID CreateFiber(SIZE_T, LPFIBER_START_ROUTINE, LPVOID); |
| HANDLE CreateWaitableTimerA(LPSECURITY_ATTRIBUTES, BOOL, LPCSTR); |
| HANDLE CreateWaitableTimerW(LPSECURITY_ATTRIBUTES, BOOL, LPCWSTR); |
| void DeleteFiber(PVOID); |
| BOOL GetFileAttributesExA(LPCSTR, GET_FILEEX_INFO_LEVELS, PVOID); |
| BOOL GetFileAttributesExW(LPCWSTR, GET_FILEEX_INFO_LEVELS, PVOID); |
| DWORD GetLongPathNameA(LPCSTR, LPSTR, DWORD); |
| DWORD GetLongPathNameW(LPCWSTR, LPWSTR, DWORD); |
| BOOL InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION, DWORD); |
| BOOL IsDebuggerPresent(); |
| HANDLE OpenWaitableTimerA(DWORD, BOOL, LPCSTR); |
| HANDLE OpenWaitableTimerW(DWORD, BOOL, LPCWSTR); |
| DWORD QueryDosDeviceA(LPCSTR, LPSTR, DWORD); |
| DWORD QueryDosDeviceW(LPCWSTR, LPWSTR, DWORD); |
| BOOL SetWaitableTimer(HANDLE, const(LARGE_INTEGER)*, LONG, PTIMERAPCROUTINE, PVOID, BOOL); |
| void SwitchToFiber(PVOID); |
| |
| static if (_WIN32_WINNT >= 0x500) { |
| HANDLE OpenThread(DWORD, BOOL, DWORD); |
| } |
| |
| BOOL AccessCheck(PSECURITY_DESCRIPTOR, HANDLE, DWORD, PGENERIC_MAPPING, PPRIVILEGE_SET, PDWORD, PDWORD, PBOOL); |
| BOOL AccessCheckAndAuditAlarmA(LPCSTR, LPVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, BOOL, PDWORD, PBOOL, PBOOL); |
| BOOL AccessCheckAndAuditAlarmW(LPCWSTR, LPVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, BOOL, PDWORD, PBOOL, PBOOL); |
| BOOL AddAccessAllowedAce(PACL, DWORD, DWORD, PSID); |
| BOOL AddAccessDeniedAce(PACL, DWORD, DWORD, PSID); |
| BOOL AddAce(PACL, DWORD, DWORD, PVOID, DWORD); |
| BOOL AddAuditAccessAce(PACL, DWORD, DWORD, PSID, BOOL, BOOL); |
| BOOL AdjustTokenGroups(HANDLE, BOOL, PTOKEN_GROUPS, DWORD, PTOKEN_GROUPS, PDWORD); |
| BOOL AdjustTokenPrivileges(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD); |
| BOOL AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY, BYTE, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, PSID*); |
| BOOL AllocateLocallyUniqueId(PLUID); |
| BOOL AreAllAccessesGranted(DWORD, DWORD); |
| BOOL AreAnyAccessesGranted(DWORD, DWORD); |
| BOOL BackupEventLogA(HANDLE, LPCSTR); |
| BOOL BackupEventLogW(HANDLE, LPCWSTR); |
| BOOL BackupRead(HANDLE, LPBYTE, DWORD, LPDWORD, BOOL, BOOL, LPVOID*); |
| BOOL BackupSeek(HANDLE, DWORD, DWORD, LPDWORD, LPDWORD, LPVOID*); |
| BOOL BackupWrite(HANDLE, LPBYTE, DWORD, LPDWORD, BOOL, BOOL, LPVOID*); |
| BOOL ClearEventLogA(HANDLE, LPCSTR); |
| BOOL ClearEventLogW(HANDLE, LPCWSTR); |
| BOOL CloseEventLog(HANDLE); |
| BOOL ConnectNamedPipe(HANDLE, LPOVERLAPPED); |
| BOOL CopySid(DWORD, PSID, PSID); |
| HANDLE CreateNamedPipeA(LPCSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES); |
| HANDLE CreateNamedPipeW(LPCWSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES); |
| BOOL CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, BOOL, HANDLE, PGENERIC_MAPPING); |
| BOOL CreateProcessAsUserA(HANDLE, LPCSTR, LPSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCSTR, LPSTARTUPINFOA, LPPROCESS_INFORMATION); |
| BOOL CreateProcessAsUserW(HANDLE, LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION); |
| HANDLE CreateRemoteThread(HANDLE, LPSECURITY_ATTRIBUTES, SIZE_T, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD); |
| DWORD CreateTapePartition(HANDLE, DWORD, DWORD, DWORD); |
| BOOL DefineDosDeviceA(DWORD, LPCSTR, LPCSTR); |
| BOOL DefineDosDeviceW(DWORD, LPCWSTR, LPCWSTR); |
| BOOL DeleteAce(PACL, DWORD); |
| BOOL DeregisterEventSource(HANDLE); |
| BOOL DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR*); |
| BOOL DeviceIoControl(HANDLE, DWORD, PVOID, DWORD, PVOID, DWORD, PDWORD, POVERLAPPED); |
| BOOL DisconnectNamedPipe(HANDLE); |
| BOOL DuplicateToken(HANDLE, SECURITY_IMPERSONATION_LEVEL, PHANDLE); |
| BOOL DuplicateTokenEx(HANDLE, DWORD, LPSECURITY_ATTRIBUTES, SECURITY_IMPERSONATION_LEVEL, TOKEN_TYPE, PHANDLE); |
| BOOL EqualPrefixSid(PSID, PSID); |
| BOOL EqualSid(PSID, PSID); |
| DWORD EraseTape(HANDLE, DWORD, BOOL); |
| HANDLE FindFirstFileExA(LPCSTR, FINDEX_INFO_LEVELS, PVOID, FINDEX_SEARCH_OPS, PVOID, DWORD); |
| HANDLE FindFirstFileExW(LPCWSTR, FINDEX_INFO_LEVELS, PVOID, FINDEX_SEARCH_OPS, PVOID, DWORD); |
| BOOL FindFirstFreeAce(PACL, PVOID*); |
| PVOID FreeSid(PSID); |
| BOOL GetAce(PACL, DWORD, LPVOID*); |
| BOOL GetAclInformation(PACL, PVOID, DWORD, ACL_INFORMATION_CLASS); |
| BOOL GetBinaryTypeA(LPCSTR, PDWORD); |
| BOOL GetBinaryTypeW(LPCWSTR, PDWORD); |
| DWORD GetCompressedFileSizeA(LPCSTR, PDWORD); |
| DWORD GetCompressedFileSizeW(LPCWSTR, PDWORD); |
| BOOL GetCurrentHwProfileA(LPHW_PROFILE_INFOA); |
| BOOL GetCurrentHwProfileW(LPHW_PROFILE_INFOW); |
| BOOL GetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD); |
| BOOL GetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD); |
| BOOL GetHandleInformation(HANDLE, PDWORD); |
| BOOL GetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD); |
| DWORD GetLengthSid(PSID); |
| BOOL GetNumberOfEventLogRecords(HANDLE, PDWORD); |
| BOOL GetOldestEventLogRecord(HANDLE, PDWORD); |
| BOOL GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD); |
| BOOL GetProcessPriorityBoost(HANDLE, PBOOL); |
| BOOL GetProcessShutdownParameters(PDWORD, PDWORD); |
| BOOL GetProcessTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME); |
| HWINSTA GetProcessWindowStation(); |
| BOOL GetProcessWorkingSetSize(HANDLE, PSIZE_T, PSIZE_T); |
| BOOL GetQueuedCompletionStatus(HANDLE, PDWORD, PULONG_PTR, LPOVERLAPPED*, DWORD); |
| BOOL GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL, PDWORD); |
| BOOL GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL); |
| BOOL GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID*, LPBOOL); |
| DWORD GetSecurityDescriptorLength(PSECURITY_DESCRIPTOR); |
| BOOL GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID*, LPBOOL); |
| BOOL GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL); |
| PSID_IDENTIFIER_AUTHORITY GetSidIdentifierAuthority(PSID); |
| DWORD GetSidLengthRequired(UCHAR); |
| PDWORD GetSidSubAuthority(PSID, DWORD); |
| PUCHAR GetSidSubAuthorityCount(PSID); |
| DWORD GetTapeParameters(HANDLE, DWORD, PDWORD, PVOID); |
| DWORD GetTapePosition(HANDLE, DWORD, PDWORD, PDWORD, PDWORD); |
| DWORD GetTapeStatus(HANDLE); |
| BOOL GetThreadPriorityBoost(HANDLE, PBOOL); |
| BOOL GetThreadTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME); |
| BOOL GetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, PVOID, DWORD, PDWORD); |
| BOOL ImpersonateLoggedOnUser(HANDLE); |
| BOOL ImpersonateNamedPipeClient(HANDLE); |
| BOOL ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL); |
| BOOL InitializeAcl(PACL, DWORD, DWORD); |
| DWORD SetCriticalSectionSpinCount(LPCRITICAL_SECTION, DWORD); |
| BOOL InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR, DWORD); |
| BOOL InitializeSid(PSID, PSID_IDENTIFIER_AUTHORITY, BYTE); |
| BOOL IsProcessorFeaturePresent(DWORD); |
| BOOL IsTextUnicode(PCVOID, int, LPINT); |
| BOOL IsValidAcl(PACL); |
| BOOL IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR); |
| BOOL IsValidSid(PSID); |
| BOOL CreateWellKnownSid(WELL_KNOWN_SID_TYPE, PSID, PSID, PDWORD); |
| BOOL LockFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, LPOVERLAPPED); |
| BOOL LogonUserA(LPSTR, LPSTR, LPSTR, DWORD, DWORD, PHANDLE); |
| BOOL LogonUserW(LPWSTR, LPWSTR, LPWSTR, DWORD, DWORD, PHANDLE); |
| BOOL LookupAccountNameA(LPCSTR, LPCSTR, PSID, PDWORD, LPSTR, PDWORD, PSID_NAME_USE); |
| BOOL LookupAccountNameW(LPCWSTR, LPCWSTR, PSID, PDWORD, LPWSTR, PDWORD, PSID_NAME_USE); |
| BOOL LookupAccountSidA(LPCSTR, PSID, LPSTR, PDWORD, LPSTR, PDWORD, PSID_NAME_USE); |
| BOOL LookupAccountSidW(LPCWSTR, PSID, LPWSTR, PDWORD, LPWSTR, PDWORD, PSID_NAME_USE); |
| BOOL LookupPrivilegeDisplayNameA(LPCSTR, LPCSTR, LPSTR, PDWORD, PDWORD); |
| BOOL LookupPrivilegeDisplayNameW(LPCWSTR, LPCWSTR, LPWSTR, PDWORD, PDWORD); |
| BOOL LookupPrivilegeNameA(LPCSTR, PLUID, LPSTR, PDWORD); |
| BOOL LookupPrivilegeNameW(LPCWSTR, PLUID, LPWSTR, PDWORD); |
| BOOL LookupPrivilegeValueA(LPCSTR, LPCSTR, PLUID); |
| BOOL LookupPrivilegeValueW(LPCWSTR, LPCWSTR, PLUID); |
| BOOL MakeAbsoluteSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PDWORD, PACL, PDWORD, PACL, PDWORD, PSID, PDWORD, PSID, PDWORD); |
| BOOL MakeSelfRelativeSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PDWORD); |
| VOID MapGenericMask(PDWORD, PGENERIC_MAPPING); |
| BOOL MoveFileExA(LPCSTR, LPCSTR, DWORD); |
| BOOL MoveFileExW(LPCWSTR, LPCWSTR, DWORD); |
| BOOL NotifyChangeEventLog(HANDLE, HANDLE); |
| BOOL ObjectCloseAuditAlarmA(LPCSTR, PVOID, BOOL); |
| BOOL ObjectCloseAuditAlarmW(LPCWSTR, PVOID, BOOL); |
| BOOL ObjectDeleteAuditAlarmA(LPCSTR, PVOID, BOOL); |
| BOOL ObjectDeleteAuditAlarmW(LPCWSTR, PVOID, BOOL); |
| BOOL ObjectOpenAuditAlarmA(LPCSTR, PVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, BOOL, BOOL, PBOOL); |
| BOOL ObjectOpenAuditAlarmW(LPCWSTR, PVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, BOOL, BOOL, PBOOL); |
| BOOL ObjectPrivilegeAuditAlarmA(LPCSTR, PVOID, HANDLE, DWORD, PPRIVILEGE_SET, BOOL); |
| BOOL ObjectPrivilegeAuditAlarmW(LPCWSTR, PVOID, HANDLE, DWORD, PPRIVILEGE_SET, BOOL); |
| HANDLE OpenBackupEventLogA(LPCSTR, LPCSTR); |
| HANDLE OpenBackupEventLogW(LPCWSTR, LPCWSTR); |
| HANDLE OpenEventLogA(LPCSTR, LPCSTR); |
| HANDLE OpenEventLogW(LPCWSTR, LPCWSTR); |
| BOOL OpenProcessToken(HANDLE, DWORD, PHANDLE); |
| BOOL OpenThreadToken(HANDLE, DWORD, BOOL, PHANDLE); |
| BOOL PostQueuedCompletionStatus(HANDLE, DWORD, ULONG_PTR, LPOVERLAPPED); |
| DWORD PrepareTape(HANDLE, DWORD, BOOL); |
| BOOL PrivilegeCheck(HANDLE, PPRIVILEGE_SET, PBOOL); |
| BOOL PrivilegedServiceAuditAlarmA(LPCSTR, LPCSTR, HANDLE, PPRIVILEGE_SET, BOOL); |
| BOOL PrivilegedServiceAuditAlarmW(LPCWSTR, LPCWSTR, HANDLE, PPRIVILEGE_SET, BOOL); |
| BOOL ReadDirectoryChangesW(HANDLE, PVOID, DWORD, BOOL, DWORD, PDWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE); |
| BOOL ReadEventLogA(HANDLE, DWORD, DWORD, PVOID, DWORD, DWORD*, DWORD*); |
| BOOL ReadEventLogW(HANDLE, DWORD, DWORD, PVOID, DWORD, DWORD*, DWORD*); |
| BOOL ReadFileScatter(HANDLE, FILE_SEGMENT_ELEMENT*, DWORD, LPDWORD, LPOVERLAPPED); |
| HANDLE RegisterEventSourceA (LPCSTR, LPCSTR); |
| HANDLE RegisterEventSourceW(LPCWSTR, LPCWSTR); |
| BOOL ReportEventA(HANDLE, WORD, WORD, DWORD, PSID, WORD, DWORD, LPCSTR*, PVOID); |
| BOOL ReportEventW(HANDLE, WORD, WORD, DWORD, PSID, WORD, DWORD, LPCWSTR*, PVOID); |
| BOOL RevertToSelf(); |
| BOOL SetAclInformation(PACL, PVOID, DWORD, ACL_INFORMATION_CLASS); |
| BOOL SetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR); |
| BOOL SetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR); |
| BOOL SetHandleInformation(HANDLE, DWORD, DWORD); |
| BOOL SetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR); |
| BOOL SetPrivateObjectSecurity(SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, PGENERIC_MAPPING, HANDLE); |
| BOOL SetProcessAffinityMask(HANDLE, DWORD_PTR); |
| BOOL SetProcessPriorityBoost(HANDLE, BOOL); |
| BOOL SetProcessShutdownParameters(DWORD, DWORD); |
| BOOL SetProcessWorkingSetSize(HANDLE, SIZE_T, SIZE_T); |
| BOOL SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, BOOL, PACL, BOOL); |
| BOOL SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID, BOOL); |
| BOOL SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID, BOOL); |
| BOOL SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, BOOL, PACL, BOOL); |
| BOOL SetSystemTimeAdjustment(DWORD, BOOL); |
| DWORD SetTapeParameters(HANDLE, DWORD, PVOID); |
| DWORD SetTapePosition(HANDLE, DWORD, DWORD, DWORD, DWORD, BOOL); |
| BOOL SetThreadPriorityBoost(HANDLE, BOOL); |
| BOOL SetThreadToken(PHANDLE, HANDLE); |
| BOOL SetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, PVOID, DWORD); |
| DWORD SignalObjectAndWait(HANDLE, HANDLE, DWORD, BOOL); |
| BOOL SwitchToThread(); |
| BOOL SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION, LPSYSTEMTIME, LPSYSTEMTIME); |
| BOOL TzSpecificLocalTimeToSystemTime(LPTIME_ZONE_INFORMATION, LPSYSTEMTIME, LPSYSTEMTIME); |
| BOOL TryEnterCriticalSection(LPCRITICAL_SECTION); |
| BOOL TryEnterCriticalSection(shared(CRITICAL_SECTION)*); |
| BOOL UnlockFileEx(HANDLE, DWORD, DWORD, DWORD, LPOVERLAPPED); |
| BOOL UpdateResourceA(HANDLE, LPCSTR, LPCSTR, WORD, PVOID, DWORD); |
| BOOL UpdateResourceW(HANDLE, LPCWSTR, LPCWSTR, WORD, PVOID, DWORD); |
| BOOL WriteFileGather(HANDLE, FILE_SEGMENT_ELEMENT*, DWORD, LPDWORD, LPOVERLAPPED); |
| DWORD WriteTapemark(HANDLE, DWORD, DWORD, BOOL); |
| |
| static if (_WIN32_WINNT >= 0x500) { |
| BOOL AddAccessAllowedAceEx(PACL, DWORD, DWORD, DWORD, PSID); |
| BOOL AddAccessDeniedAceEx(PACL, DWORD, DWORD, DWORD, PSID); |
| PVOID AddVectoredExceptionHandler(ULONG, PVECTORED_EXCEPTION_HANDLER); |
| BOOL AllocateUserPhysicalPages(HANDLE, PULONG_PTR, PULONG_PTR); |
| BOOL AssignProcessToJobObject(HANDLE, HANDLE); |
| BOOL ChangeTimerQueueTimer(HANDLE,HANDLE,ULONG,ULONG); |
| LPVOID CreateFiberEx(SIZE_T, SIZE_T, DWORD, LPFIBER_START_ROUTINE, LPVOID); |
| HANDLE CreateFileMappingA(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCSTR); |
| HANDLE CreateFileMappingW(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCWSTR); |
| BOOL CreateHardLinkA(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES); |
| BOOL CreateHardLinkW(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES); |
| HANDLE CreateJobObjectA(LPSECURITY_ATTRIBUTES, LPCSTR); |
| HANDLE CreateJobObjectW(LPSECURITY_ATTRIBUTES, LPCWSTR); |
| BOOL CreateProcessWithLogonW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPCWSTR, LPWSTR, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION); |
| HANDLE CreateTimerQueue(); |
| BOOL CreateTimerQueueTimer(PHANDLE, HANDLE, WAITORTIMERCALLBACK, PVOID, DWORD, DWORD, ULONG); |
| BOOL DeleteTimerQueue(HANDLE); |
| BOOL DeleteTimerQueueEx(HANDLE, HANDLE); |
| BOOL DeleteTimerQueueTimer(HANDLE, HANDLE, HANDLE); |
| BOOL DeleteVolumeMountPointA(LPCSTR); |
| BOOL DeleteVolumeMountPointW(LPCWSTR); |
| BOOL DnsHostnameToComputerNameA(LPCSTR, LPSTR, LPDWORD); |
| BOOL DnsHostnameToComputerNameW(LPCWSTR, LPWSTR, LPDWORD); |
| BOOL EncryptFileA(LPCSTR); |
| BOOL EncryptFileW(LPCWSTR); |
| BOOL FileEncryptionStatusA(LPCSTR, LPDWORD); |
| BOOL FileEncryptionStatusW(LPCWSTR, LPDWORD); |
| HANDLE FindFirstVolumeA(LPCSTR, DWORD); |
| HANDLE FindFirstVolumeMountPointA(LPSTR, LPSTR, DWORD); |
| HANDLE FindFirstVolumeMountPointW(LPWSTR, LPWSTR, DWORD); |
| HANDLE FindFirstVolumeW(LPCWSTR, DWORD); |
| BOOL FindNextVolumeA(HANDLE, LPCSTR, DWORD); |
| BOOL FindNextVolumeW(HANDLE, LPWSTR, DWORD); |
| BOOL FindNextVolumeMountPointA(HANDLE, LPSTR, DWORD); |
| BOOL FindNextVolumeMountPointW(HANDLE, LPWSTR, DWORD); |
| BOOL FindVolumeClose(HANDLE); |
| BOOL FindVolumeMountPointClose(HANDLE); |
| BOOL FlushViewOfFile(PCVOID, SIZE_T); |
| BOOL FreeUserPhysicalPages(HANDLE, PULONG_PTR, PULONG_PTR); |
| BOOL GetComputerNameExA(COMPUTER_NAME_FORMAT, LPSTR, LPDWORD); |
| BOOL GetComputerNameExW(COMPUTER_NAME_FORMAT, LPWSTR, LPDWORD); |
| BOOL GetFileSizeEx(HANDLE, PLARGE_INTEGER); |
| BOOL GetModuleHandleExA(DWORD, LPCSTR, HMODULE*); |
| BOOL GetModuleHandleExW(DWORD, LPCWSTR, HMODULE*); |
| HANDLE GetProcessHeap(); |
| DWORD GetProcessHeaps(DWORD, PHANDLE); |
| BOOL GetProcessIoCounters(HANDLE, PIO_COUNTERS); |
| BOOL GetSystemPowerStatus(LPSYSTEM_POWER_STATUS); |
| UINT GetSystemWindowsDirectoryA(LPSTR, UINT); |
| UINT GetSystemWindowsDirectoryW(LPWSTR, UINT); |
| BOOL GetVolumeNameForVolumeMountPointA(LPCSTR, LPSTR, DWORD); |
| BOOL GetVolumeNameForVolumeMountPointW(LPCWSTR, LPWSTR, DWORD); |
| BOOL GetVolumePathNameA(LPCSTR, LPSTR, DWORD); |
| BOOL GetVolumePathNameW(LPCWSTR, LPWSTR, DWORD); |
| BOOL GlobalMemoryStatusEx(LPMEMORYSTATUSEX); |
| BOOL IsBadCodePtr(FARPROC); |
| BOOL IsSystemResumeAutomatic(); |
| BOOL MapUserPhysicalPages(PVOID, ULONG_PTR, PULONG_PTR); |
| BOOL MapUserPhysicalPagesScatter(PVOID*, ULONG_PTR, PULONG_PTR); |
| PVOID MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, SIZE_T); |
| PVOID MapViewOfFileEx(HANDLE, DWORD, DWORD, DWORD, SIZE_T, PVOID); |
| HANDLE OpenFileMappingA(DWORD, BOOL, LPCSTR); |
| HANDLE OpenFileMappingW(DWORD, BOOL, LPCWSTR); |
| BOOL ProcessIdToSessionId(DWORD, DWORD*); |
| BOOL QueryInformationJobObject(HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD, LPDWORD); |
| ULONG RemoveVectoredExceptionHandler(PVOID); |
| BOOL ReplaceFileA(LPCSTR, LPCSTR, LPCSTR, DWORD, LPVOID, LPVOID); |
| BOOL ReplaceFileW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPVOID, LPVOID); |
| BOOL SetComputerNameExA(COMPUTER_NAME_FORMAT, LPCSTR); |
| BOOL SetComputerNameExW(COMPUTER_NAME_FORMAT, LPCWSTR); |
| BOOL SetFilePointerEx(HANDLE, LARGE_INTEGER, PLARGE_INTEGER, DWORD); |
| BOOL SetInformationJobObject(HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD); |
| BOOL SetSecurityDescriptorControl(PSECURITY_DESCRIPTOR, SECURITY_DESCRIPTOR_CONTROL, SECURITY_DESCRIPTOR_CONTROL); |
| BOOL SetSystemPowerState(BOOL, BOOL); |
| EXECUTION_STATE SetThreadExecutionState(EXECUTION_STATE); |
| DWORD SetThreadIdealProcessor(HANDLE, DWORD); |
| BOOL SetVolumeMountPointA(LPCSTR, LPCSTR); |
| BOOL SetVolumeMountPointW(LPCWSTR, LPCWSTR); |
| BOOL TerminateJobObject(HANDLE, UINT); |
| BOOL UnmapViewOfFile(PCVOID); |
| BOOL UnregisterWait(HANDLE); |
| BOOL UnregisterWaitEx(HANDLE, HANDLE); |
| BOOL VerifyVersionInfoA(LPOSVERSIONINFOEXA, DWORD, DWORDLONG); |
| BOOL VerifyVersionInfoW(LPOSVERSIONINFOEXW, DWORD, DWORDLONG); |
| } |
| |
| static if (_WIN32_WINNT >= 0x501) { |
| BOOL ActivateActCtx(HANDLE, ULONG_PTR*); |
| void AddRefActCtx(HANDLE); |
| BOOL CheckNameLegalDOS8Dot3A(LPCSTR, LPSTR, DWORD, PBOOL, PBOOL); |
| BOOL CheckNameLegalDOS8Dot3W(LPCWSTR, LPSTR, DWORD, PBOOL, PBOOL); |
| BOOL CheckRemoteDebuggerPresent(HANDLE, PBOOL); |
| BOOL ConvertFiberToThread(); |
| HANDLE CreateActCtxA(PCACTCTXA); |
| HANDLE CreateActCtxW(PCACTCTXW); |
| HANDLE CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE); |
| BOOL DeactivateActCtx(DWORD, ULONG_PTR); |
| BOOL DebugActiveProcessStop(DWORD); |
| BOOL DebugBreakProcess(HANDLE); |
| BOOL DebugSetProcessKillOnExit(BOOL); |
| BOOL FindActCtxSectionGuid(DWORD, const(GUID)*, ULONG, const(GUID)*, |
| PACTCTX_SECTION_KEYED_DATA); |
| BOOL FindActCtxSectionStringA(DWORD, const(GUID)*, ULONG, LPCSTR, |
| PACTCTX_SECTION_KEYED_DATA); |
| BOOL FindActCtxSectionStringW(DWORD, const(GUID)*, ULONG, LPCWSTR, |
| PACTCTX_SECTION_KEYED_DATA); |
| BOOL GetCurrentActCtx(HANDLE*); |
| VOID GetNativeSystemInfo(LPSYSTEM_INFO); |
| BOOL GetProcessHandleCount(HANDLE, PDWORD); |
| BOOL GetSystemRegistryQuota(PDWORD, PDWORD); |
| BOOL GetSystemTimes(LPFILETIME, LPFILETIME, LPFILETIME); |
| UINT GetSystemWow64DirectoryA(LPSTR, UINT); |
| UINT GetSystemWow64DirectoryW(LPWSTR, UINT); |
| BOOL GetThreadIOPendingFlag(HANDLE, PBOOL); |
| BOOL GetVolumePathNamesForVolumeNameA(LPCSTR, LPSTR, DWORD, PDWORD); |
| BOOL GetVolumePathNamesForVolumeNameW(LPCWSTR, LPWSTR, DWORD, PDWORD); |
| UINT GetWriteWatch(DWORD, PVOID, SIZE_T, PVOID*, PULONG_PTR, PULONG); |
| BOOL HeapQueryInformation(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T, PSIZE_T); |
| BOOL HeapSetInformation(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T); |
| BOOL IsProcessInJob(HANDLE, HANDLE, PBOOL); |
| BOOL IsWow64Process(HANDLE, PBOOL); |
| BOOL QueryActCtxW(DWORD, HANDLE, PVOID, ULONG, PVOID, SIZE_T, SIZE_T*); |
| BOOL QueryMemoryResourceNotification(HANDLE, PBOOL); |
| void ReleaseActCtx(HANDLE); |
| UINT ResetWriteWatch(LPVOID, SIZE_T); |
| BOOL SetFileShortNameA(HANDLE, LPCSTR); |
| BOOL SetFileShortNameW(HANDLE, LPCWSTR); |
| BOOL SetFileValidData(HANDLE, LONGLONG); |
| BOOL ZombifyActCtx(HANDLE); |
| } |
| |
| static if (_WIN32_WINNT >= 0x502) { |
| DWORD GetFirmwareEnvironmentVariableA(LPCSTR, LPCSTR, PVOID, DWORD); |
| DWORD GetFirmwareEnvironmentVariableW(LPCWSTR, LPCWSTR, PVOID, DWORD); |
| DWORD GetDllDirectoryA(DWORD, LPSTR); |
| DWORD GetDllDirectoryW(DWORD, LPWSTR); |
| DWORD GetThreadId(HANDLE); |
| DWORD GetProcessId(HANDLE); |
| HANDLE ReOpenFile(HANDLE, DWORD, DWORD, DWORD); |
| BOOL SetDllDirectoryA(LPCSTR); |
| BOOL SetDllDirectoryW(LPCWSTR); |
| BOOL SetFirmwareEnvironmentVariableA(LPCSTR, LPCSTR, PVOID, DWORD); |
| BOOL SetFirmwareEnvironmentVariableW(LPCWSTR, LPCWSTR, PVOID, DWORD); |
| } |
| |
| // ??? |
| static if (_WIN32_WINNT >= 0x510) { |
| VOID RestoreLastError(DWORD); |
| } |
| |
| static if (_WIN32_WINNT >= 0x600) { |
| BOOL CreateSymbolicLinkA(LPCSTR, LPCSTR, DWORD); |
| BOOL CreateSymbolicLinkW(LPCWSTR, LPCWSTR, DWORD); |
| } |
| } |
| |
| // For compatibility with old core.sys.windows.windows: |
| version (LittleEndian) nothrow @nogc |
| { |
| BOOL QueryPerformanceCounter(long* lpPerformanceCount) { return QueryPerformanceCounter(cast(PLARGE_INTEGER)lpPerformanceCount); } |
| BOOL QueryPerformanceFrequency(long* lpFrequency) { return QueryPerformanceFrequency(cast(PLARGE_INTEGER)lpFrequency); } |
| } |
| |
| mixin DECLARE_AW!("STARTUPINFO"); |
| version (Unicode) { |
| //alias STARTUPINFOW STARTUPINFO; |
| alias WIN32_FIND_DATAW WIN32_FIND_DATA; |
| alias ENUMRESLANGPROCW ENUMRESLANGPROC; |
| alias ENUMRESNAMEPROCW ENUMRESNAMEPROC; |
| alias ENUMRESTYPEPROCW ENUMRESTYPEPROC; |
| alias AddAtomW AddAtom; |
| alias BeginUpdateResourceW BeginUpdateResource; |
| alias BuildCommDCBW BuildCommDCB; |
| alias BuildCommDCBAndTimeoutsW BuildCommDCBAndTimeouts; |
| alias CallNamedPipeW CallNamedPipe; |
| alias CommConfigDialogW CommConfigDialog; |
| alias CopyFileW CopyFile; |
| alias CopyFileExW CopyFileEx; |
| alias CreateDirectoryW CreateDirectory; |
| alias CreateDirectoryExW CreateDirectoryEx; |
| alias CreateEventW CreateEvent; |
| alias CreateFileW CreateFile; |
| alias CreateMailslotW CreateMailslot; |
| alias CreateMutexW CreateMutex; |
| alias CreateProcessW CreateProcess; |
| alias CreateSemaphoreW CreateSemaphore; |
| alias DeleteFileW DeleteFile; |
| alias EndUpdateResourceW EndUpdateResource; |
| alias EnumResourceLanguagesW EnumResourceLanguages; |
| alias EnumResourceNamesW EnumResourceNames; |
| alias EnumResourceTypesW EnumResourceTypes; |
| alias ExpandEnvironmentStringsW ExpandEnvironmentStrings; |
| alias FatalAppExitW FatalAppExit; |
| alias FindAtomW FindAtom; |
| alias FindFirstChangeNotificationW FindFirstChangeNotification; |
| alias FindFirstFileW FindFirstFile; |
| alias FindNextFileW FindNextFile; |
| alias FindResourceW FindResource; |
| alias FindResourceExW FindResourceEx; |
| alias FormatMessageW FormatMessage; |
| alias FreeEnvironmentStringsW FreeEnvironmentStrings; |
| alias GetAtomNameW GetAtomName; |
| alias GetCommandLineW GetCommandLine; |
| alias GetComputerNameW GetComputerName; |
| alias GetCurrentDirectoryW GetCurrentDirectory; |
| alias GetDefaultCommConfigW GetDefaultCommConfig; |
| alias GetDiskFreeSpaceW GetDiskFreeSpace; |
| alias GetDiskFreeSpaceExW GetDiskFreeSpaceEx; |
| alias GetDriveTypeW GetDriveType; |
| alias GetEnvironmentStringsW GetEnvironmentStrings; |
| alias GetEnvironmentVariableW GetEnvironmentVariable; |
| alias GetFileAttributesW GetFileAttributes; |
| alias GetFullPathNameW GetFullPathName; |
| alias GetLogicalDriveStringsW GetLogicalDriveStrings; |
| alias GetModuleFileNameW GetModuleFileName; |
| alias GetModuleHandleW GetModuleHandle; |
| alias GetNamedPipeHandleStateW GetNamedPipeHandleState; |
| alias GetPrivateProfileIntW GetPrivateProfileInt; |
| alias GetPrivateProfileSectionW GetPrivateProfileSection; |
| alias GetPrivateProfileSectionNamesW GetPrivateProfileSectionNames; |
| alias GetPrivateProfileStringW GetPrivateProfileString; |
| alias GetPrivateProfileStructW GetPrivateProfileStruct; |
| alias GetProfileIntW GetProfileInt; |
| alias GetProfileSectionW GetProfileSection; |
| alias GetProfileStringW GetProfileString; |
| alias GetShortPathNameW GetShortPathName; |
| alias GetStartupInfoW GetStartupInfo; |
| alias GetSystemDirectoryW GetSystemDirectory; |
| alias GetTempFileNameW GetTempFileName; |
| alias GetTempPathW GetTempPath; |
| alias GetUserNameW GetUserName; |
| alias GetVersionExW GetVersionEx; |
| alias GetVolumeInformationW GetVolumeInformation; |
| alias GetWindowsDirectoryW GetWindowsDirectory; |
| alias GlobalAddAtomW GlobalAddAtom; |
| alias GlobalFindAtomW GlobalFindAtom; |
| alias GlobalGetAtomNameW GlobalGetAtomName; |
| alias IsBadStringPtrW IsBadStringPtr; |
| alias LoadLibraryW LoadLibrary; |
| alias LoadLibraryExW LoadLibraryEx; |
| alias lstrcatW lstrcat; |
| alias lstrcmpW lstrcmp; |
| alias lstrcmpiW lstrcmpi; |
| alias lstrcpyW lstrcpy; |
| alias lstrcpynW lstrcpyn; |
| alias lstrlenW lstrlen; |
| alias MoveFileW MoveFile; |
| alias OpenEventW OpenEvent; |
| alias OpenMutexW OpenMutex; |
| alias OpenSemaphoreW OpenSemaphore; |
| alias OutputDebugStringW OutputDebugString; |
| alias RemoveDirectoryW RemoveDirectory; |
| alias SearchPathW SearchPath; |
| alias SetComputerNameW SetComputerName; |
| alias SetCurrentDirectoryW SetCurrentDirectory; |
| alias SetDefaultCommConfigW SetDefaultCommConfig; |
| alias SetEnvironmentVariableW SetEnvironmentVariable; |
| alias SetFileAttributesW SetFileAttributes; |
| alias SetVolumeLabelW SetVolumeLabel; |
| alias WaitNamedPipeW WaitNamedPipe; |
| alias WritePrivateProfileSectionW WritePrivateProfileSection; |
| alias WritePrivateProfileStringW WritePrivateProfileString; |
| alias WritePrivateProfileStructW WritePrivateProfileStruct; |
| alias WriteProfileSectionW WriteProfileSection; |
| alias WriteProfileStringW WriteProfileString; |
| alias CreateWaitableTimerW CreateWaitableTimer; |
| alias GetFileAttributesExW GetFileAttributesEx; |
| alias GetLongPathNameW GetLongPathName; |
| alias QueryDosDeviceW QueryDosDevice; |
| |
| alias HW_PROFILE_INFOW HW_PROFILE_INFO; |
| alias AccessCheckAndAuditAlarmW AccessCheckAndAuditAlarm; |
| alias BackupEventLogW BackupEventLog; |
| alias ClearEventLogW ClearEventLog; |
| alias CreateNamedPipeW CreateNamedPipe; |
| alias CreateProcessAsUserW CreateProcessAsUser; |
| alias DefineDosDeviceW DefineDosDevice; |
| alias FindFirstFileExW FindFirstFileEx; |
| alias GetBinaryTypeW GetBinaryType; |
| alias GetCompressedFileSizeW GetCompressedFileSize; |
| alias GetFileSecurityW GetFileSecurity; |
| alias LogonUserW LogonUser; |
| alias LookupAccountNameW LookupAccountName; |
| alias LookupAccountSidW LookupAccountSid; |
| alias LookupPrivilegeDisplayNameW LookupPrivilegeDisplayName; |
| alias LookupPrivilegeNameW LookupPrivilegeName; |
| alias LookupPrivilegeValueW LookupPrivilegeValue; |
| alias MoveFileExW MoveFileEx; |
| alias ObjectCloseAuditAlarmW ObjectCloseAuditAlarm; |
| alias ObjectDeleteAuditAlarmW ObjectDeleteAuditAlarm; |
| alias ObjectOpenAuditAlarmW ObjectOpenAuditAlarm; |
| alias ObjectPrivilegeAuditAlarmW ObjectPrivilegeAuditAlarm; |
| alias OpenBackupEventLogW OpenBackupEventLog; |
| alias OpenEventLogW OpenEventLog; |
| alias PrivilegedServiceAuditAlarmW PrivilegedServiceAuditAlarm; |
| alias ReadEventLogW ReadEventLog; |
| alias RegisterEventSourceW RegisterEventSource; |
| alias ReportEventW ReportEvent; |
| alias SetFileSecurityW SetFileSecurity; |
| alias UpdateResourceW UpdateResource; |
| |
| static if (_WIN32_WINNT >= 0x500) { |
| alias CreateFileMappingW CreateFileMapping; |
| alias CreateHardLinkW CreateHardLink; |
| alias CreateJobObjectW CreateJobObject; |
| alias DeleteVolumeMountPointW DeleteVolumeMountPoint; |
| alias DnsHostnameToComputerNameW DnsHostnameToComputerName; |
| alias EncryptFileW EncryptFile; |
| alias FileEncryptionStatusW FileEncryptionStatus; |
| alias FindFirstVolumeW FindFirstVolume; |
| alias FindFirstVolumeMountPointW FindFirstVolumeMountPoint; |
| alias FindNextVolumeW FindNextVolume; |
| alias FindNextVolumeMountPointW FindNextVolumeMountPoint; |
| alias GetModuleHandleExW GetModuleHandleEx; |
| alias GetSystemWindowsDirectoryW GetSystemWindowsDirectory; |
| alias GetVolumeNameForVolumeMountPointW GetVolumeNameForVolumeMountPoint; |
| alias GetVolumePathNameW GetVolumePathName; |
| alias OpenFileMappingW OpenFileMapping; |
| alias ReplaceFileW ReplaceFile; |
| alias SetVolumeMountPointW SetVolumeMountPoint; |
| alias VerifyVersionInfoW VerifyVersionInfo; |
| } |
| |
| static if (_WIN32_WINNT >= 0x501) { |
| alias ACTCTXW ACTCTX; |
| alias CheckNameLegalDOS8Dot3W CheckNameLegalDOS8Dot3; |
| alias CreateActCtxW CreateActCtx; |
| alias FindActCtxSectionStringW FindActCtxSectionString; |
| alias GetSystemWow64DirectoryW GetSystemWow64Directory; |
| alias GetVolumePathNamesForVolumeNameW GetVolumePathNamesForVolumeName; |
| alias SetFileShortNameW SetFileShortName; |
| } |
| |
| static if (_WIN32_WINNT >= 0x502) { |
| alias SetFirmwareEnvironmentVariableW SetFirmwareEnvironmentVariable; |
| alias SetDllDirectoryW SetDllDirectory; |
| alias GetDllDirectoryW GetDllDirectory; |
| } |
| |
| static if (_WIN32_WINNT >= 0x600) { |
| alias CreateSymbolicLinkW CreateSymbolicLink; |
| } |
| |
| } else { |
| //alias STARTUPINFOA STARTUPINFO; |
| alias WIN32_FIND_DATAA WIN32_FIND_DATA; |
| alias ENUMRESLANGPROCW ENUMRESLANGPROC; |
| alias ENUMRESNAMEPROCW ENUMRESNAMEPROC; |
| alias ENUMRESTYPEPROCW ENUMRESTYPEPROC; |
| alias AddAtomA AddAtom; |
| alias BeginUpdateResourceA BeginUpdateResource; |
| alias BuildCommDCBA BuildCommDCB; |
| alias BuildCommDCBAndTimeoutsA BuildCommDCBAndTimeouts; |
| alias CallNamedPipeA CallNamedPipe; |
| alias CommConfigDialogA CommConfigDialog; |
| alias CopyFileA CopyFile; |
| alias CopyFileExA CopyFileEx; |
| alias CreateDirectoryA CreateDirectory; |
| alias CreateDirectoryExA CreateDirectoryEx; |
| alias CreateEventA CreateEvent; |
| alias CreateFileA CreateFile; |
| alias CreateMailslotA CreateMailslot; |
| alias CreateMutexA CreateMutex; |
| alias CreateProcessA CreateProcess; |
| alias CreateSemaphoreA CreateSemaphore; |
| alias DeleteFileA DeleteFile; |
| alias EndUpdateResourceA EndUpdateResource; |
| alias EnumResourceLanguagesA EnumResourceLanguages; |
| alias EnumResourceNamesA EnumResourceNames; |
| alias EnumResourceTypesA EnumResourceTypes; |
| alias ExpandEnvironmentStringsA ExpandEnvironmentStrings; |
| alias FatalAppExitA FatalAppExit; |
| alias FindAtomA FindAtom; |
| alias FindFirstChangeNotificationA FindFirstChangeNotification; |
| alias FindFirstFileA FindFirstFile; |
| alias FindNextFileA FindNextFile; |
| alias FindResourceA FindResource; |
| alias FindResourceExA FindResourceEx; |
| alias FormatMessageA FormatMessage; |
| alias FreeEnvironmentStringsA FreeEnvironmentStrings; |
| alias GetAtomNameA GetAtomName; |
| alias GetCommandLineA GetCommandLine; |
| alias GetComputerNameA GetComputerName; |
| alias GetCurrentDirectoryA GetCurrentDirectory; |
| alias GetDefaultCommConfigA GetDefaultCommConfig; |
| alias GetDiskFreeSpaceA GetDiskFreeSpace; |
| alias GetDiskFreeSpaceExA GetDiskFreeSpaceEx; |
| alias GetDriveTypeA GetDriveType; |
| alias GetEnvironmentStringsA GetEnvironmentStrings; |
| alias GetEnvironmentVariableA GetEnvironmentVariable; |
| alias GetFileAttributesA GetFileAttributes; |
| alias GetFullPathNameA GetFullPathName; |
| alias GetLogicalDriveStringsA GetLogicalDriveStrings; |
| alias GetNamedPipeHandleStateA GetNamedPipeHandleState; |
| alias GetModuleHandleA GetModuleHandle; |
| alias GetModuleFileNameA GetModuleFileName; |
| alias GetPrivateProfileIntA GetPrivateProfileInt; |
| alias GetPrivateProfileSectionA GetPrivateProfileSection; |
| alias GetPrivateProfileSectionNamesA GetPrivateProfileSectionNames; |
| alias GetPrivateProfileStringA GetPrivateProfileString; |
| alias GetPrivateProfileStructA GetPrivateProfileStruct; |
| alias GetProfileIntA GetProfileInt; |
| alias GetProfileSectionA GetProfileSection; |
| alias GetProfileStringA GetProfileString; |
| alias GetShortPathNameA GetShortPathName; |
| alias GetStartupInfoA GetStartupInfo; |
| alias GetSystemDirectoryA GetSystemDirectory; |
| alias GetTempFileNameA GetTempFileName; |
| alias GetTempPathA GetTempPath; |
| alias GetUserNameA GetUserName; |
| alias GetVersionExA GetVersionEx; |
| alias GetVolumeInformationA GetVolumeInformation; |
| alias GetWindowsDirectoryA GetWindowsDirectory; |
| alias GlobalAddAtomA GlobalAddAtom; |
| alias GlobalFindAtomA GlobalFindAtom; |
| alias GlobalGetAtomNameA GlobalGetAtomName; |
| alias IsBadStringPtrA IsBadStringPtr; |
| alias LoadLibraryA LoadLibrary; |
| alias LoadLibraryExA LoadLibraryEx; |
| alias lstrcatA lstrcat; |
| alias lstrcmpA lstrcmp; |
| alias lstrcmpiA lstrcmpi; |
| alias lstrcpyA lstrcpy; |
| alias lstrcpynA lstrcpyn; |
| alias lstrlenA lstrlen; |
| alias MoveFileA MoveFile; |
| alias OpenEventA OpenEvent; |
| alias OpenMutexA OpenMutex; |
| alias OpenSemaphoreA OpenSemaphore; |
| alias OutputDebugStringA OutputDebugString; |
| alias RemoveDirectoryA RemoveDirectory; |
| alias SearchPathA SearchPath; |
| alias SetComputerNameA SetComputerName; |
| alias SetCurrentDirectoryA SetCurrentDirectory; |
| alias SetDefaultCommConfigA SetDefaultCommConfig; |
| alias SetEnvironmentVariableA SetEnvironmentVariable; |
| alias SetFileAttributesA SetFileAttributes; |
| alias SetVolumeLabelA SetVolumeLabel; |
| alias WaitNamedPipeA WaitNamedPipe; |
| alias WritePrivateProfileSectionA WritePrivateProfileSection; |
| alias WritePrivateProfileStringA WritePrivateProfileString; |
| alias WritePrivateProfileStructA WritePrivateProfileStruct; |
| alias WriteProfileSectionA WriteProfileSection; |
| alias WriteProfileStringA WriteProfileString; |
| alias CreateWaitableTimerA CreateWaitableTimer; |
| alias GetFileAttributesExA GetFileAttributesEx; |
| alias GetLongPathNameA GetLongPathName; |
| alias QueryDosDeviceA QueryDosDevice; |
| |
| alias HW_PROFILE_INFOA HW_PROFILE_INFO; |
| alias AccessCheckAndAuditAlarmA AccessCheckAndAuditAlarm; |
| alias BackupEventLogA BackupEventLog; |
| alias ClearEventLogA ClearEventLog; |
| alias CreateNamedPipeA CreateNamedPipe; |
| alias CreateProcessAsUserA CreateProcessAsUser; |
| alias DefineDosDeviceA DefineDosDevice; |
| alias FindFirstFileExA FindFirstFileEx; |
| alias GetBinaryTypeA GetBinaryType; |
| alias GetCompressedFileSizeA GetCompressedFileSize; |
| alias GetFileSecurityA GetFileSecurity; |
| alias LogonUserA LogonUser; |
| alias LookupAccountNameA LookupAccountName; |
| alias LookupAccountSidA LookupAccountSid; |
| alias LookupPrivilegeDisplayNameA LookupPrivilegeDisplayName; |
| alias LookupPrivilegeNameA LookupPrivilegeName; |
| alias LookupPrivilegeValueA LookupPrivilegeValue; |
| alias MoveFileExA MoveFileEx; |
| alias ObjectCloseAuditAlarmA ObjectCloseAuditAlarm; |
| alias ObjectDeleteAuditAlarmA ObjectDeleteAuditAlarm; |
| alias ObjectOpenAuditAlarmA ObjectOpenAuditAlarm; |
| alias ObjectPrivilegeAuditAlarmA ObjectPrivilegeAuditAlarm; |
| alias OpenBackupEventLogA OpenBackupEventLog; |
| alias OpenEventLogA OpenEventLog; |
| alias PrivilegedServiceAuditAlarmA PrivilegedServiceAuditAlarm; |
| alias ReadEventLogA ReadEventLog; |
| alias RegisterEventSourceA RegisterEventSource; |
| alias ReportEventA ReportEvent; |
| alias SetFileSecurityA SetFileSecurity; |
| alias UpdateResourceA UpdateResource; |
| |
| static if (_WIN32_WINNT >= 0x500) { |
| alias CreateFileMappingA CreateFileMapping; |
| alias CreateHardLinkA CreateHardLink; |
| alias CreateJobObjectA CreateJobObject; |
| alias DeleteVolumeMountPointA DeleteVolumeMountPoint; |
| alias DnsHostnameToComputerNameA DnsHostnameToComputerName; |
| alias EncryptFileA EncryptFile; |
| alias FileEncryptionStatusA FileEncryptionStatus; |
| alias FindFirstVolumeA FindFirstVolume; |
| alias FindFirstVolumeMountPointA FindFirstVolumeMountPoint; |
| alias FindNextVolumeA FindNextVolume; |
| alias FindNextVolumeMountPointA FindNextVolumeMountPoint; |
| alias GetModuleHandleExA GetModuleHandleEx; |
| alias GetSystemWindowsDirectoryA GetSystemWindowsDirectory; |
| alias GetVolumeNameForVolumeMountPointA GetVolumeNameForVolumeMountPoint; |
| alias GetVolumePathNameA GetVolumePathName; |
| alias OpenFileMappingA OpenFileMapping; |
| alias ReplaceFileA ReplaceFile; |
| alias SetVolumeMountPointA SetVolumeMountPoint; |
| alias VerifyVersionInfoA VerifyVersionInfo; |
| } |
| |
| static if (_WIN32_WINNT >= 0x501) { |
| alias ACTCTXA ACTCTX; |
| alias CheckNameLegalDOS8Dot3A CheckNameLegalDOS8Dot3; |
| alias CreateActCtxA CreateActCtx; |
| alias FindActCtxSectionStringA FindActCtxSectionString; |
| alias GetSystemWow64DirectoryA GetSystemWow64Directory; |
| alias GetVolumePathNamesForVolumeNameA GetVolumePathNamesForVolumeName; |
| alias SetFileShortNameA SetFileShortName; |
| } |
| |
| static if (_WIN32_WINNT >= 0x502) { |
| alias GetDllDirectoryA GetDllDirectory; |
| alias SetDllDirectoryA SetDllDirectory; |
| alias SetFirmwareEnvironmentVariableA SetFirmwareEnvironmentVariable; |
| } |
| |
| static if (_WIN32_WINNT >= 0x600) { |
| alias CreateSymbolicLinkA CreateSymbolicLink; |
| } |
| } |
| |
| alias STARTUPINFO* LPSTARTUPINFO; |
| alias WIN32_FIND_DATA* LPWIN32_FIND_DATA; |
| |
| alias |
