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