Google Git Google Git
Sign in
gnu/gcc/6da0b1468bfc4fbf4e8029b9dd634c31cb8261d8/./libphobos/libdruntime/core/sys/windows/winbase.d
blob: 0a5a4c8a511f0d9194148fb1b20acab9f15ca16a [file]
/**
* 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 core/sys/windows/_winbase.d)
*/
module core.sys.windows.winbase;
version (Windows):
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;
import core.stdc.string : memset, memcpy, memmove;
// 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 LPCOMMPROP = COMMPROP*;
// ----------
// 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;
// for GetFinalPathNameByHandle()
enum DWORD
VOLUME_NAME_DOS = 0x0,
VOLUME_NAME_GUID = 0x1,
VOLUME_NAME_NT = 0x2,
VOLUME_NAME_NONE = 0x4,
FILE_NAME_NORMALIZED = 0x0,
FILE_NAME_OPENED = 0x8;
// 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
}
@trusted 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 PFILETIME = FILETIME*, LPFILETIME = FILETIME*;
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 LPBY_HANDLE_FILE_INFORMATION = BY_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 LPDCB = DCB*;
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 LPCOMMCONFIG = COMMCONFIG*;
struct COMMTIMEOUTS {
DWORD ReadIntervalTimeout;
DWORD ReadTotalTimeoutMultiplier;
DWORD ReadTotalTimeoutConstant;
DWORD WriteTotalTimeoutMultiplier;
DWORD WriteTotalTimeoutConstant;
}
alias LPCOMMTIMEOUTS = COMMTIMEOUTS*;
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 LPCOMSTAT = COMSTAT*;
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 LPCREATE_PROCESS_DEBUG_INFO = CREATE_PROCESS_DEBUG_INFO*;
struct CREATE_THREAD_DEBUG_INFO {
HANDLE hThread;
LPVOID lpThreadLocalBase;
LPTHREAD_START_ROUTINE lpStartAddress;
}
alias LPCREATE_THREAD_DEBUG_INFO = CREATE_THREAD_DEBUG_INFO*;
struct EXCEPTION_DEBUG_INFO {
EXCEPTION_RECORD ExceptionRecord;
DWORD dwFirstChance;
}
alias LPEXCEPTION_DEBUG_INFO = EXCEPTION_DEBUG_INFO*;
struct EXIT_THREAD_DEBUG_INFO {
DWORD dwExitCode;
}
alias LPEXIT_THREAD_DEBUG_INFO = EXIT_THREAD_DEBUG_INFO*;
struct EXIT_PROCESS_DEBUG_INFO {
DWORD dwExitCode;
}
alias LPEXIT_PROCESS_DEBUG_INFO = EXIT_PROCESS_DEBUG_INFO*;
struct LOAD_DLL_DEBUG_INFO {
HANDLE hFile;
LPVOID lpBaseOfDll;
DWORD dwDebugInfoFileOffset;
DWORD nDebugInfoSize;
LPVOID lpImageName;
WORD fUnicode;
}
alias LPLOAD_DLL_DEBUG_INFO = LOAD_DLL_DEBUG_INFO*;
struct UNLOAD_DLL_DEBUG_INFO {
LPVOID lpBaseOfDll;
}
alias LPUNLOAD_DLL_DEBUG_INFO = UNLOAD_DLL_DEBUG_INFO*;
struct OUTPUT_DEBUG_STRING_INFO {
LPSTR lpDebugStringData;
WORD fUnicode;
WORD nDebugStringLength;
}
alias LPOUTPUT_DEBUG_STRING_INFO = OUTPUT_DEBUG_STRING_INFO*;
struct RIP_INFO {
DWORD dwError;
DWORD dwType;
}
alias LPRIP_INFO = RIP_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 LPDEBUG_EVENT = DEBUG_EVENT*;
struct OVERLAPPED {
ULONG_PTR Internal;
ULONG_PTR InternalHigh;
union {
struct {
DWORD Offset;
DWORD OffsetHigh;
}
PVOID Pointer;
}
HANDLE hEvent;
}
alias POVERLAPPED = OVERLAPPED*, LPOVERLAPPED = OVERLAPPED*;
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 LPSTARTUPINFOA = STARTUPINFOA*;
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 STARTUPINFO_W = STARTUPINFOW;
alias LPSTARTUPINFOW = STARTUPINFOW*, LPSTARTUPINFO_W = STARTUPINFOW*;
struct PROCESS_INFORMATION {
HANDLE hProcess;
HANDLE hThread;
DWORD dwProcessId;
DWORD dwThreadId;
}
alias PPROCESS_INFORMATION = PROCESS_INFORMATION*, LPPROCESS_INFORMATION = PROCESS_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 PCRITICAL_SECTION_DEBUG = CRITICAL_SECTION_DEBUG*;
alias CRITICAL_SECTION = RTL_CRITICAL_SECTION;
alias PCRITICAL_SECTION = CRITICAL_SECTION*, LPCRITICAL_SECTION = CRITICAL_SECTION*;
struct SYSTEMTIME {
WORD wYear;
WORD wMonth;
WORD wDayOfWeek;
WORD wDay;
WORD wHour;
WORD wMinute;
WORD wSecond;
WORD wMilliseconds;
}
alias LPSYSTEMTIME = SYSTEMTIME*;
struct WIN32_FILE_ATTRIBUTE_DATA {
DWORD dwFileAttributes;
FILETIME ftCreationTime;
FILETIME ftLastAccessTime;
FILETIME ftLastWriteTime;
DWORD nFileSizeHigh;
DWORD nFileSizeLow;
}
alias LPWIN32_FILE_ATTRIBUTE_DATA = WIN32_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 PWIN32_FIND_DATAA = WIN32_FIND_DATAA*, LPWIN32_FIND_DATAA = WIN32_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 PWIN32_FIND_DATAW = WIN32_FIND_DATAW*, LPWIN32_FIND_DATAW = WIN32_FIND_DATAW*;
struct WIN32_STREAM_ID {
DWORD dwStreamId;
DWORD dwStreamAttributes;
LARGE_INTEGER Size;
DWORD dwStreamNameSize;
WCHAR _cStreamName = 0;
WCHAR* cStreamName() return { return &_cStreamName; }
}
alias LPWIN32_STREAM_ID = WIN32_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 LPHW_PROFILE_INFOA = HW_PROFILE_INFOA*;
struct HW_PROFILE_INFOW {
DWORD dwDockInfo;
WCHAR[HW_PROFILE_GUIDLEN] szHwProfileGuid = 0;
WCHAR[MAX_PROFILE_LEN] szHwProfileName = 0;
}
alias LPHW_PROFILE_INFOW = HW_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
}
import core.sys.windows.sdkddkver : NTDDI_VERSION, NTDDI_LONGHORN;
static if (NTDDI_VERSION >= NTDDI_LONGHORN)
{
enum FILE_INFO_BY_HANDLE_CLASS
{
FileBasicInfo,
FileStandardInfo,
FileNameInfo,
FileRenameInfo,
FileDispositionInfo,
FileAllocationInfo,
FileEndOfFileInfo,
FileStreamInfo,
FileCompressionInfo,
FileAttributeTagInfo,
FileIdBothDirectoryInfo,
FileIdBothDirectoryRestartInfo,
FileIoPriorityHintInfo,
FileRemoteProtocolInfo,
FileFullDirectoryInfo,
FileFullDirectoryRestartInfo,
// static if (NTDDI_VERSION >= NTDDI_WIN8)
// {
FileStorageInfo,
FileAlignmentInfo,
FileIdInfo,
FileIdExtdDirectoryInfo,
FileIdExtdDirectoryRestartInfo,
// }
// static if (NTDDI_VERSION >= NTDDI_WIN10_RS1)
// {
FileDispositionInfoEx,
FileRenameInfoEx,
// }
// static if (NTDDI_VERSION >= NTDDI_WIN10_19H1)
// {
FileCaseSensitiveInfo,
FileNormalizedNameInfo,
// }
MaximumFileInfoByHandleClass
}
alias PFILE_INFO_BY_HANDLE_CLASS = FILE_INFO_BY_HANDLE_CLASS*;
}
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 LPSYSTEM_INFO = SYSTEM_INFO*;
static if (_WIN32_WINNT >= 0x500) {
struct SYSTEM_POWER_STATUS {
BYTE ACLineStatus;
BYTE BatteryFlag;
BYTE BatteryLifePercent;
BYTE Reserved1;
DWORD BatteryLifeTime;
DWORD BatteryFullLifeTime;
}
alias LPSYSTEM_POWER_STATUS = SYSTEM_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 LPTIME_ZONE_INFORMATION = TIME_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 LPMEMORYSTATUS = MEMORYSTATUS*;
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 LPMEMORYSTATUSEX = MEMORYSTATUSEX*;
}
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 PLDT_ENTRY = LDT_ENTRY*, LPLDT_ENTRY = LDT_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 LPPROCESS_HEAP_ENTRY = PROCESS_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 LPOFSTRUCT = OFSTRUCT*, POFSTRUCT = OFSTRUCT*;
/* ??? 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 LPWIN_CERTIFICATE = WIN_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 PACTCTXA = ACTCTXA*;
alias PCACTCTXA = const(ACTCTXA)*;
struct ACTCTXW {
ULONG cbSize = this.sizeof;
DWORD dwFlags;
LPCWSTR lpSource;
USHORT wProcessorArchitecture;
LANGID wLangId;
LPCWSTR lpAssemblyDirectory;
LPCWSTR lpResourceName;
LPCWSTR lpApplicationName;
HMODULE hModule;
}
alias PACTCTXW = ACTCTXW*;
alias PCACTCTXW = const(ACTCTXW)*;
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 PACTCTX_SECTION_KEYED_DATA = ACTCTX_SECTION_KEYED_DATA*;
alias PCACTCTX_SECTION_KEYED_DATA = const(ACTCTX_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 EXECUTION_STATE = DWORD;
}
// CreateSymbolicLink, GetFileInformationByHandleEx
static if (_WIN32_WINNT >= 0x600) {
enum {
SYMBOLIC_LINK_FLAG_DIRECTORY = 0x1,
SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE = 0x2
}
struct FILE_BASIC_INFO
{
LARGE_INTEGER CreationTime;
LARGE_INTEGER LastAccessTime;
LARGE_INTEGER LastWriteTime;
LARGE_INTEGER ChangeTime;
DWORD FileAttributes;
}
alias PFILE_BASIC_INFO = FILE_BASIC_INFO*;
struct FILE_STANDARD_INFO
{
LARGE_INTEGER AllocationSize;
LARGE_INTEGER EndOfFile;
DWORD NumberOfLinks;
BOOLEAN DeletePending;
BOOLEAN Directory;
}
alias PFILE_STANDARD_INFO = FILE_STANDARD_INFO*;
}
// Callbacks
extern (Windows) {
alias LPTHREAD_START_ROUTINE = DWORD function(LPVOID);
alias LPPROGRESS_ROUTINE = DWORD function(LARGE_INTEGER, LARGE_INTEGER, LARGE_INTEGER, LARGE_INTEGER,
DWORD, DWORD, HANDLE, HANDLE, LPVOID);
alias LPFIBER_START_ROUTINE = void function(PVOID);
alias ENUMRESLANGPROCA = BOOL function(HMODULE, LPCSTR, LPCSTR, WORD, LONG_PTR);
alias ENUMRESLANGPROCW = BOOL function(HMODULE, LPCWSTR, LPCWSTR, WORD, LONG_PTR);
alias ENUMRESNAMEPROCA = BOOL function(HMODULE, LPCSTR, LPSTR, LONG_PTR);
alias ENUMRESNAMEPROCW = BOOL function(HMODULE, LPCWSTR, LPWSTR, LONG_PTR);
alias ENUMRESTYPEPROCA = BOOL function(HMODULE, LPSTR, LONG_PTR);
alias ENUMRESTYPEPROCW = BOOL function(HMODULE, LPWSTR, LONG_PTR);
alias LPOVERLAPPED_COMPLETION_ROUTINE = void function(DWORD, DWORD, LPOVERLAPPED);
alias PTOP_LEVEL_EXCEPTION_FILTER = LONG function(LPEXCEPTION_POINTERS);
alias LPTOP_LEVEL_EXCEPTION_FILTER = PTOP_LEVEL_EXCEPTION_FILTER;
alias PAPCFUNC = void function(ULONG_PTR);
alias PTIMERAPCROUTINE = void function(PVOID, DWORD, DWORD);
static if (_WIN32_WINNT >= 0x500) {
alias WAITORTIMERCALLBACK = void function(PVOID, BOOLEAN);
}
}
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);
alias RtlMoveMemory = memmove;
alias RtlCopyMemory = memcpy;
pragma(inline, true) void RtlFillMemory(PVOID Destination, SIZE_T Length, BYTE Fill) pure { memset(Destination, Fill, Length); }
pragma(inline, true) void RtlZeroMemory(PVOID Destination, SIZE_T Length) pure { memset(Destination, 0, Length); }
alias MoveMemory = RtlMoveMemory;
alias CopyMemory = RtlCopyMemory;
alias FillMemory = RtlFillMemory;
alias ZeroMemory = RtlZeroMemory;
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 GetCurrentTime = GetTickCount;
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 GetFinalPathNameByHandleA(HANDLE, LPSTR, DWORD, DWORD);
DWORD GetFinalPathNameByHandleW(HANDLE, LPWSTR, DWORD, DWORD);
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);
BOOL GetFileInformationByHandleEx(HANDLE, FILE_INFO_BY_HANDLE_CLASS, LPVOID, 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_DATA = WIN32_FIND_DATAW;
alias ENUMRESLANGPROC = ENUMRESLANGPROCW;
alias ENUMRESNAMEPROC = ENUMRESNAMEPROCW;
alias ENUMRESTYPEPROC = ENUMRESTYPEPROCW;
alias AddAtom = AddAtomW;
alias BeginUpdateResource = BeginUpdateResourceW;
alias BuildCommDCB = BuildCommDCBW;
alias BuildCommDCBAndTimeouts = BuildCommDCBAndTimeoutsW;
alias CallNamedPipe = CallNamedPipeW;
alias CommConfigDialog = CommConfigDialogW;
alias CopyFile = CopyFileW;
alias CopyFileEx = CopyFileExW;
alias CreateDirectory = CreateDirectoryW;
alias CreateDirectoryEx = CreateDirectoryExW;
alias CreateEvent = CreateEventW;
alias CreateFile = CreateFileW;
alias CreateMailslot = CreateMailslotW;
alias CreateMutex = CreateMutexW;
alias CreateProcess = CreateProcessW;
alias CreateSemaphore = CreateSemaphoreW;
alias DeleteFile = DeleteFileW;
alias EndUpdateResource = EndUpdateResourceW;
alias EnumResourceLanguages = EnumResourceLanguagesW;
alias EnumResourceNames = EnumResourceNamesW;
alias EnumResourceTypes = EnumResourceTypesW;
alias ExpandEnvironmentStrings = ExpandEnvironmentStringsW;
alias FatalAppExit = FatalAppExitW;
alias FindAtom = FindAtomW;
alias FindFirstChangeNotification = FindFirstChangeNotificationW;
alias FindFirstFile = FindFirstFileW;
alias FindNextFile = FindNextFileW;
alias FindResource = FindResourceW;
alias FindResourceEx = FindResourceExW;
alias FormatMessage = FormatMessageW;
alias FreeEnvironmentStrings = FreeEnvironmentStringsW;
alias GetAtomName = GetAtomNameW;
alias GetCommandLine = GetCommandLineW;
alias GetComputerName = GetComputerNameW;
alias GetCurrentDirectory = GetCurrentDirectoryW;
alias GetDefaultCommConfig = GetDefaultCommConfigW;
alias GetDiskFreeSpace = GetDiskFreeSpaceW;
alias GetDiskFreeSpaceEx = GetDiskFreeSpaceExW;
alias GetDriveType = GetDriveTypeW;
alias GetEnvironmentStrings = GetEnvironmentStringsW;
alias GetEnvironmentVariable = GetEnvironmentVariableW;
alias GetFileAttributes = GetFileAttributesW;
alias GetFullPathName = GetFullPathNameW;
alias GetLogicalDriveStrings = GetLogicalDriveStringsW;
alias GetModuleFileName = GetModuleFileNameW;
alias GetModuleHandle = GetModuleHandleW;
alias GetNamedPipeHandleState = GetNamedPipeHandleStateW;
alias GetPrivateProfileInt = GetPrivateProfileIntW;
alias GetPrivateProfileSection = GetPrivateProfileSectionW;
alias GetPrivateProfileSectionNames = GetPrivateProfileSectionNamesW;
alias GetPrivateProfileString = GetPrivateProfileStringW;
alias GetPrivateProfileStruct = GetPrivateProfileStructW;
alias GetProfileInt = GetProfileIntW;
alias GetProfileSection = GetProfileSectionW;
alias GetProfileString = GetProfileStringW;
alias GetShortPathName = GetShortPathNameW;
alias GetStartupInfo = GetStartupInfoW;
alias GetSystemDirectory = GetSystemDirectoryW;
alias GetTempFileName = GetTempFileNameW;
alias GetTempPath = GetTempPathW;
alias GetUserName = GetUserNameW;
alias GetVersionEx = GetVersionExW;
alias GetVolumeInformation = GetVolumeInformationW;
alias GetWindowsDirectory = GetWindowsDirectoryW;
alias GlobalAddAtom = GlobalAddAtomW;
alias GlobalFindAtom = GlobalFindAtomW;
alias GlobalGetAtomName = GlobalGetAtomNameW;
alias IsBadStringPtr = IsBadStringPtrW;
alias LoadLibrary = LoadLibraryW;
alias LoadLibraryEx = LoadLibraryExW;
alias lstrcat = lstrcatW;
alias lstrcmp = lstrcmpW;
alias lstrcmpi = lstrcmpiW;
alias lstrcpy = lstrcpyW;
alias lstrcpyn = lstrcpynW;
alias lstrlen = lstrlenW;
alias MoveFile = MoveFileW;
alias OpenEvent = OpenEventW;
alias OpenMutex = OpenMutexW;
alias OpenSemaphore = OpenSemaphoreW;
alias OutputDebugString = OutputDebugStringW;
alias RemoveDirectory = RemoveDirectoryW;
alias SearchPath = SearchPathW;
alias SetComputerName = SetComputerNameW;
alias SetCurrentDirectory = SetCurrentDirectoryW;
alias SetDefaultCommConfig = SetDefaultCommConfigW;
alias SetEnvironmentVariable = SetEnvironmentVariableW;
alias SetFileAttributes = SetFileAttributesW;
alias SetVolumeLabel = SetVolumeLabelW;
alias WaitNamedPipe = WaitNamedPipeW;
alias WritePrivateProfileSection = WritePrivateProfileSectionW;
alias WritePrivateProfileString = WritePrivateProfileStringW;
alias WritePrivateProfileStruct = WritePrivateProfileStructW;
alias WriteProfileSection = WriteProfileSectionW;
alias WriteProfileString = WriteProfileStringW;
alias CreateWaitableTimer = CreateWaitableTimerW;
alias GetFileAttributesEx = GetFileAttributesExW;
alias GetLongPathName = GetLongPathNameW;
alias QueryDosDevice = QueryDosDeviceW;
alias HW_PROFILE_INFO = HW_PROFILE_INFOW;
alias AccessCheckAndAuditAlarm = AccessCheckAndAuditAlarmW;
alias BackupEventLog = BackupEventLogW;
alias ClearEventLog = ClearEventLogW;
alias CreateNamedPipe = CreateNamedPipeW;
alias CreateProcessAsUser = CreateProcessAsUserW;
alias DefineDosDevice = DefineDosDeviceW;
alias FindFirstFileEx = FindFirstFileExW;
alias GetBinaryType = GetBinaryTypeW;
alias GetCompressedFileSize = GetCompressedFileSizeW;
alias GetFileSecurity = GetFileSecurityW;
alias LogonUser = LogonUserW;
alias LookupAccountName = LookupAccountNameW;
alias LookupAccountSid = LookupAccountSidW;
alias LookupPrivilegeDisplayName = LookupPrivilegeDisplayNameW;
alias LookupPrivilegeName = LookupPrivilegeNameW;
alias LookupPrivilegeValue = LookupPrivilegeValueW;
alias MoveFileEx = MoveFileExW;
alias ObjectCloseAuditAlarm = ObjectCloseAuditAlarmW;
alias ObjectDeleteAuditAlarm = ObjectDeleteAuditAlarmW;
alias ObjectOpenAuditAlarm = ObjectOpenAuditAlarmW;
alias ObjectPrivilegeAuditAlarm = ObjectPrivilegeAuditAlarmW;
alias OpenBackupEventLog = OpenBackupEventLogW;
alias OpenEventLog = OpenEventLogW;
alias PrivilegedServiceAuditAlarm = PrivilegedServiceAuditAlarmW;
alias ReadEventLog = ReadEventLogW;
alias RegisterEventSource = RegisterEventSourceW;
alias ReportEvent = ReportEventW;
alias SetFileSecurity = SetFileSecurityW;
alias UpdateResource = UpdateResourceW;
static if (_WIN32_WINNT >= 0x500) {
alias CreateFileMapping = CreateFileMappingW;
alias CreateHardLink = CreateHardLinkW;
alias CreateJobObject = CreateJobObjectW;
alias DeleteVolumeMountPoint = DeleteVolumeMountPointW;
alias DnsHostnameToComputerName = DnsHostnameToComputerNameW;
alias EncryptFile = EncryptFileW;
alias FileEncryptionStatus = FileEncryptionStatusW;
alias FindFirstVolume = FindFirstVolumeW;
alias FindFirstVolumeMountPoint = FindFirstVolumeMountPointW;
alias FindNextVolume = FindNextVolumeW;
alias FindNextVolumeMountPoint = FindNextVolumeMountPointW;
alias GetModuleHandleEx = GetModuleHandleExW;
alias GetSystemWindowsDirectory = GetSystemWindowsDirectoryW;
alias GetVolumeNameForVolumeMountPoint = GetVolumeNameForVolumeMountPointW;
alias GetVolumePathName = GetVolumePathNameW;
alias OpenFileMapping = OpenFileMappingW;
alias ReplaceFile = ReplaceFileW;
alias SetVolumeMountPoint = SetVolumeMountPointW;
alias VerifyVersionInfo = VerifyVersionInfoW;
}
static if (_WIN32_WINNT >= 0x501) {
alias ACTCTX = ACTCTXW;
alias CheckNameLegalDOS8Dot3 = CheckNameLegalDOS8Dot3W;
alias CreateActCtx = CreateActCtxW;
alias FindActCtxSectionString = FindActCtxSectionStringW;
alias GetSystemWow64Directory = GetSystemWow64DirectoryW;
alias GetVolumePathNamesForVolumeName = GetVolumePathNamesForVolumeNameW;
alias SetFileShortName = SetFileShortNameW;
}
static if (_WIN32_WINNT >= 0x502) {
alias SetFirmwareEnvironmentVariable = SetFirmwareEnvironmentVariableW;
alias SetDllDirectory = SetDllDirectoryW;
alias GetDllDirectory = GetDllDirectoryW;
}
static if (_WIN32_WINNT >= 0x600) {
alias CreateSymbolicLink = CreateSymbolicLinkW;
}
} else {
//alias STARTUPINFOA STARTUPINFO;
alias WIN32_FIND_DATA = WIN32_FIND_DATAA;
alias ENUMRESLANGPROC = ENUMRESLANGPROCW;
alias ENUMRESNAMEPROC = ENUMRESNAMEPROCW;
alias ENUMRESTYPEPROC = ENUMRESTYPEPROCW;
alias AddAtom = AddAtomA;
alias BeginUpdateResource = BeginUpdateResourceA;
alias BuildCommDCB = BuildCommDCBA;
alias BuildCommDCBAndTimeouts = BuildCommDCBAndTimeoutsA;
alias CallNamedPipe = CallNamedPipeA;
alias CommConfigDialog = CommConfigDialogA;
alias CopyFile = CopyFileA;
alias CopyFileEx = CopyFileExA;
alias CreateDirectory = CreateDirectoryA;
alias CreateDirectoryEx = CreateDirectoryExA;
alias CreateEvent = CreateEventA;
alias CreateFile = CreateFileA;
alias CreateMailslot = CreateMailslotA;
alias CreateMutex = CreateMutexA;
alias CreateProcess = CreateProcessA;
alias CreateSemaphore = CreateSemaphoreA;
alias DeleteFile = DeleteFileA;
alias EndUpdateResource = EndUpdateResourceA;
alias EnumResourceLanguages = EnumResourceLanguagesA;
alias EnumResourceNames = EnumResourceNamesA;
alias EnumResourceTypes = EnumResourceTypesA;
alias ExpandEnvironmentStrings = ExpandEnvironmentStringsA;
alias FatalAppExit = FatalAppExitA;
alias FindAtom = FindAtomA;
alias FindFirstChangeNotification = FindFirstChangeNotificationA;
alias FindFirstFile = FindFirstFileA;
alias FindNextFile = FindNextFileA;
alias FindResource = FindResourceA;
alias FindResourceEx = FindResourceExA;
alias FormatMessage = FormatMessageA;
alias FreeEnvironmentStrings = FreeEnvironmentStringsA;
alias GetAtomName = GetAtomNameA;
alias GetCommandLine = GetCommandLineA;
alias GetComputerName = GetComputerNameA;
alias GetCurrentDirectory = GetCurrentDirectoryA;
alias GetDefaultCommConfig = GetDefaultCommConfigA;
alias GetDiskFreeSpace = GetDiskFreeSpaceA;
alias GetDiskFreeSpaceEx = GetDiskFreeSpaceExA;
alias GetDriveType = GetDriveTypeA;
alias GetEnvironmentStrings = GetEnvironmentStringsA;
alias GetEnvironmentVariable = GetEnvironmentVariableA;
alias GetFileAttributes = GetFileAttributesA;
alias GetFullPathName = GetFullPathNameA;
alias GetLogicalDriveStrings = GetLogicalDriveStringsA;
alias GetNamedPipeHandleState = GetNamedPipeHandleStateA;
alias GetModuleHandle = GetModuleHandleA;
alias GetModuleFileName = GetModuleFileNameA;
alias GetPrivateProfileInt = GetPrivateProfileIntA;
alias GetPrivateProfileSection = GetPrivateProfileSectionA;
alias GetPrivateProfileSectionNames = GetPrivateProfileSectionNamesA;
alias GetPrivateProfileString = GetPrivateProfileStringA;
alias GetPrivateProfileStruct = GetPrivateProfileStructA;
alias GetProfileInt = GetProfileIntA;
alias GetProfileSection = GetProfileSectionA;
alias GetProfileString = GetProfileStringA;
alias GetShortPathName = GetShortPathNameA;
alias GetStartupInfo = GetStartupInfoA;
alias GetSystemDirectory = GetSystemDirectoryA;
alias GetTempFileName = GetTempFileNameA;
alias GetTempPath = GetTempPathA;
alias GetUserName = GetUserNameA;
alias GetVersionEx = GetVersionExA;
alias GetVolumeInformation = GetVolumeInformationA;
alias GetWindowsDirectory = GetWindowsDirectoryA;
alias GlobalAddAtom = GlobalAddAtomA;
alias GlobalFindAtom = GlobalFindAtomA;
alias GlobalGetAtomName = GlobalGetAtomNameA;
alias IsBadStringPtr = IsBadStringPtrA;
alias LoadLibrary = LoadLibraryA;
alias LoadLibraryEx = LoadLibraryExA;
alias lstrcat = lstrcatA;
alias lstrcmp = lstrcmpA;
alias lstrcmpi = lstrcmpiA;
alias lstrcpy = lstrcpyA;
alias lstrcpyn = lstrcpynA;
alias lstrlen = lstrlenA;
alias MoveFile = MoveFileA;
alias OpenEvent = OpenEventA;
alias OpenMutex = OpenMutexA;
alias OpenSemaphore = OpenSemaphoreA;
alias OutputDebugString = OutputDebugStringA;
alias RemoveDirectory = RemoveDirectoryA;
alias SearchPath = SearchPathA;
alias SetComputerName = SetComputerNameA;
alias SetCurrentDirectory = SetCurrentDirectoryA;
alias SetDefaultCommConfig = SetDefaultCommConfigA;
alias SetEnvironmentVariable = SetEnvironmentVariableA;
alias SetFileAttributes = SetFileAttributesA;
alias SetVolumeLabel = SetVolumeLabelA;
alias WaitNamedPipe = WaitNamedPipeA;
alias WritePrivateProfileSection = WritePrivateProfileSectionA;
alias WritePrivateProfileString = WritePrivateProfileStringA;
alias WritePrivateProfileStruct = WritePrivateProfileStructA;
alias WriteProfileSection = WriteProfileSectionA;
alias WriteProfileString = WriteProfileStringA;
alias CreateWaitableTimer = CreateWaitableTimerA;
alias GetFileAttributesEx = GetFileAttributesExA;
alias GetLongPathName = GetLongPathNameA;
alias QueryDosDevice = QueryDosDeviceA;
alias HW_PROFILE_INFO = HW_PROFILE_INFOA;
alias AccessCheckAndAuditAlarm = AccessCheckAndAuditAlarmA;
alias BackupEventLog = BackupEventLogA;
alias ClearEventLog = ClearEventLogA;
alias CreateNamedPipe = CreateNamedPipeA;
alias CreateProcessAsUser = CreateProcessAsUserA;
alias DefineDosDevice = DefineDosDeviceA;
alias FindFirstFileEx = FindFirstFileExA;
alias GetBinaryType = GetBinaryTypeA;
alias GetCompressedFileSize = GetCompressedFileSizeA;
alias GetFileSecurity = GetFileSecurityA;
alias LogonUser = LogonUserA;
alias LookupAccountName = LookupAccountNameA;
alias LookupAccountSid = LookupAccountSidA;
alias LookupPrivilegeDisplayName = LookupPrivilegeDisplayNameA;
alias LookupPrivilegeName = LookupPrivilegeNameA;
alias LookupPrivilegeValue = LookupPrivilegeValueA;
alias MoveFileEx = MoveFileExA;
alias ObjectCloseAuditAlarm = ObjectCloseAuditAlarmA;
alias ObjectDeleteAuditAlarm = ObjectDeleteAuditAlarmA;
alias ObjectOpenAuditAlarm = ObjectOpenAuditAlarmA;
alias ObjectPrivilegeAuditAlarm = ObjectPrivilegeAuditAlarmA;
alias OpenBackupEventLog = OpenBackupEventLogA;
alias OpenEventLog = OpenEventLogA;
alias PrivilegedServiceAuditAlarm = PrivilegedServiceAuditAlarmA;
alias ReadEventLog = ReadEventLogA;
alias RegisterEventSource = RegisterEventSourceA;
alias ReportEvent = ReportEventA;
alias SetFileSecurity = SetFileSecurityA;
alias UpdateResource = UpdateResourceA;
static if (_WIN32_WINNT >= 0x500) {
alias CreateFileMapping = CreateFileMappingA;
alias CreateHardLink = CreateHardLinkA;
alias CreateJobObject = CreateJobObjectA;
alias DeleteVolumeMountPoint = DeleteVolumeMountPointA;
alias DnsHostnameToComputerName = DnsHostnameToComputerNameA;
alias EncryptFile = EncryptFileA;
alias FileEncryptionStatus = FileEncryptionStatusA;
alias FindFirstVolume = FindFirstVolumeA;
alias FindFirstVolumeMountPoint = FindFirstVolumeMountPointA;
alias FindNextVolume = FindNextVolumeA;
alias FindNextVolumeMountPoint = FindNextVolumeMountPointA;
alias GetModuleHandleEx = GetModuleHandleExA;
alias GetSystemWindowsDirectory = GetSystemWindowsDirectoryA;
alias GetVolumeNameForVolumeMountPoint = GetVolumeNameForVolumeMountPointA;
alias GetVolumePathName = GetVolumePathNameA;
alias OpenFileMapping = OpenFileMappingA;
alias ReplaceFile = ReplaceFileA;
alias SetVolumeMountPoint = SetVolumeMountPointA;
alias VerifyVersionInfo = VerifyVersionInfoA;
}
static if (_WIN32_WINNT >= 0x501) {
alias ACTCTX = ACTCTXA;
alias CheckNameLegalDOS8Dot3 = CheckNameLegalDOS8Dot3A;
alias CreateActCtx = CreateActCtxA;
alias FindActCtxSectionString = FindActCtxSectionStringA;
alias GetSystemWow64Directory = GetSystemWow64DirectoryA;
alias GetVolumePathNamesForVolumeName = GetVolumePathNamesForVolumeNameA;
alias SetFileShortName = SetFileShortNameA;
}
static if (_WIN32_WINNT >= 0x502) {
alias GetDllDirectory = GetDllDirectoryA;
alias SetDllDirectory = SetDllDirectoryA;
alias SetFirmwareEnvironmentVariable = SetFirmwareEnvironmentVariableA;
}
static if (_WIN32_WINNT >= 0x600) {
alias CreateSymbolicLink = CreateSymbolicLinkA;
}
}
alias LPSTARTUPINFO = STARTUPINFO*;
alias LPWIN32_FIND_DATA = WIN32_FIND_DATA*;
alias LPHW_PROFILE_INFO = HW_PROFILE_INFO*;
static if (_WIN32_WINNT >= 0x501) {
alias PACTCTX = ACTCTX*, PCACTCTX = ACTCTX*;
}