/************************************************************************
* *
* winbase.h -- This module defines the 32-Bit Windows Base APIs *
* *
* Copyright 1990 - 1998 Microsoft Corp. All rights reserved. *
* *
************************************************************************/
#ifndef _WINBASE_
#define _WINBASE_
#ifdef _MAC
#include <macwin32.h>
#endif //_MAC
//
// Define API decoration for direct importing of DLL references.
//
#if !defined(_ADVAPI32_)
#define WINADVAPI DECLSPEC_IMPORT
#else
#define WINADVAPI
#endif
#if !defined(_KERNEL32_)
#define WINBASEAPI DECLSPEC_IMPORT
#else
#define WINBASEAPI
#endif
#if !defined(_ZAWPROXY_)
#define ZAWPROXYAPI DECLSPEC_IMPORT
#else
#define ZAWPROXYAPI
#endif
#ifdef __cplusplus
extern "C" {
#endif
/*
* Compatibility macros
*/
#define DefineHandleTable(w) ((w),TRUE)
#define LimitEmsPages(dw)
#define SetSwapAreaSize(w) (w)
#define LockSegment(w) GlobalFix((HANDLE)(w))
#define UnlockSegment(w) GlobalUnfix((HANDLE)(w))
#define GetCurrentTime() GetTickCount()
#define Yield()
#define INVALID_HANDLE_VALUE (HANDLE)-1
#define INVALID_FILE_SIZE (DWORD)0xFFFFFFFF
#define FILE_BEGIN 0
#define FILE_CURRENT 1
#define FILE_END 2
#define TIME_ZONE_ID_INVALID (DWORD)0xFFFFFFFF
#define WAIT_FAILED (DWORD)0xFFFFFFFF
#define WAIT_OBJECT_0 ((STATUS_WAIT_0 ) + 0 )
#define WAIT_ABANDONED ((STATUS_ABANDONED_WAIT_0 ) + 0 )
#define WAIT_ABANDONED_0 ((STATUS_ABANDONED_WAIT_0 ) + 0 )
#define WAIT_TIMEOUT STATUS_TIMEOUT
#define WAIT_IO_COMPLETION STATUS_USER_APC
#define STILL_ACTIVE STATUS_PENDING
#define EXCEPTION_ACCESS_VIOLATION STATUS_ACCESS_VIOLATION
#define EXCEPTION_DATATYPE_MISALIGNMENT STATUS_DATATYPE_MISALIGNMENT
#define EXCEPTION_BREAKPOINT STATUS_BREAKPOINT
#define EXCEPTION_SINGLE_STEP STATUS_SINGLE_STEP
#define EXCEPTION_ARRAY_BOUNDS_EXCEEDED STATUS_ARRAY_BOUNDS_EXCEEDED
#define EXCEPTION_FLT_DENORMAL_OPERAND STATUS_FLOAT_DENORMAL_OPERAND
#define EXCEPTION_FLT_DIVIDE_BY_ZERO STATUS_FLOAT_DIVIDE_BY_ZERO
#define EXCEPTION_FLT_INEXACT_RESULT STATUS_FLOAT_INEXACT_RESULT
#define EXCEPTION_FLT_INVALID_OPERATION STATUS_FLOAT_INVALID_OPERATION
#define EXCEPTION_FLT_OVERFLOW STATUS_FLOAT_OVERFLOW
#define EXCEPTION_FLT_STACK_CHECK STATUS_FLOAT_STACK_CHECK
#define EXCEPTION_FLT_UNDERFLOW STATUS_FLOAT_UNDERFLOW
#define EXCEPTION_INT_DIVIDE_BY_ZERO STATUS_INTEGER_DIVIDE_BY_ZERO
#define EXCEPTION_INT_OVERFLOW STATUS_INTEGER_OVERFLOW
#define EXCEPTION_PRIV_INSTRUCTION STATUS_PRIVILEGED_INSTRUCTION
#define EXCEPTION_IN_PAGE_ERROR STATUS_IN_PAGE_ERROR
#define EXCEPTION_ILLEGAL_INSTRUCTION STATUS_ILLEGAL_INSTRUCTION
#define EXCEPTION_NONCONTINUABLE_EXCEPTION STATUS_NONCONTINUABLE_EXCEPTION
#define EXCEPTION_STACK_OVERFLOW STATUS_STACK_OVERFLOW
#define EXCEPTION_INVALID_DISPOSITION STATUS_INVALID_DISPOSITION
#define EXCEPTION_GUARD_PAGE STATUS_GUARD_PAGE_VIOLATION
#define EXCEPTION_INVALID_HANDLE STATUS_INVALID_HANDLE
#define CONTROL_C_EXIT STATUS_CONTROL_C_EXIT
#define MoveMemory RtlMoveMemory
#define CopyMemory RtlCopyMemory
#define FillMemory RtlFillMemory
#define ZeroMemory RtlZeroMemory
#if (_WIN32_WINNT >= 0x0500)
#if defined(_M_ALPHA)
#define MoveMemoryVlm RtlMoveMemory
#define CopyMemoryVlm RtlCopyMemory
#define FillMemoryVlm RtlFillMemory
#define ZeroMemoryVlm RtlZeroMemory
#endif
#endif
//
// File creation flags must start at the high end since they
// are combined with the attributes
//
#define FILE_FLAG_WRITE_THROUGH 0x80000000
#define FILE_FLAG_OVERLAPPED 0x40000000
#define FILE_FLAG_NO_BUFFERING 0x20000000
#define FILE_FLAG_RANDOM_ACCESS 0x10000000
#define FILE_FLAG_SEQUENTIAL_SCAN 0x08000000
#define FILE_FLAG_DELETE_ON_CLOSE 0x04000000
#define FILE_FLAG_BACKUP_SEMANTICS 0x02000000
#define FILE_FLAG_POSIX_SEMANTICS 0x01000000
#define FILE_FLAG_OPEN_REPARSE_POINT 0x00200000
#define FILE_FLAG_OPEN_NO_RECALL 0x00100000
#define CREATE_NEW 1
#define CREATE_ALWAYS 2
#define OPEN_EXISTING 3
#define OPEN_ALWAYS 4
#define TRUNCATE_EXISTING 5
#if(_WIN32_WINNT >= 0x0400)
//
// Define possible return codes from the CopyFileEx callback routine
//
#define PROGRESS_CONTINUE 0
#define PROGRESS_CANCEL 1
#define PROGRESS_STOP 2
#define PROGRESS_QUIET 3
//
// Define CopyFileEx callback routine state change values
//
#define CALLBACK_CHUNK_FINISHED 0x00000000
#define CALLBACK_STREAM_SWITCH 0x00000001
//
// Define CopyFileEx option flags
//
#define COPY_FILE_FAIL_IF_EXISTS 0x00000001
#define COPY_FILE_RESTARTABLE 0x00000002
#define COPY_FILE_OPEN_SOURCE_FOR_WRITE 0x00000004
#endif /* _WIN32_WINNT >= 0x0400 */
//
// Define the NamedPipe definitions
//
//
// Define the dwOpenMode values for CreateNamedPipe
//
#define PIPE_ACCESS_INBOUND 0x00000001
#define PIPE_ACCESS_OUTBOUND 0x00000002
#define PIPE_ACCESS_DUPLEX 0x00000003
//
// Define the Named Pipe End flags for GetNamedPipeInfo
//
#define PIPE_CLIENT_END 0x00000000
#define PIPE_SERVER_END 0x00000001
//
// Define the dwPipeMode values for CreateNamedPipe
//
#define PIPE_WAIT 0x00000000
#define PIPE_NOWAIT 0x00000001
#define PIPE_READMODE_BYTE 0x00000000
#define PIPE_READMODE_MESSAGE 0x00000002
#define PIPE_TYPE_BYTE 0x00000000
#define PIPE_TYPE_MESSAGE 0x00000004
//
// Define the well known values for CreateNamedPipe nMaxInstances
//
#define PIPE_UNLIMITED_INSTANCES 255
//
// Define the Security Quality of Service bits to be passed
// into CreateFile
//
#define SECURITY_ANONYMOUS ( SecurityAnonymous << 16 )
#define SECURITY_IDENTIFICATION ( SecurityIdentification << 16 )
#define SECURITY_IMPERSONATION ( SecurityImpersonation << 16 )
#define SECURITY_DELEGATION ( SecurityDelegation << 16 )
#define SECURITY_CONTEXT_TRACKING 0x00040000
#define SECURITY_EFFECTIVE_ONLY 0x00080000
#define SECURITY_SQOS_PRESENT 0x00100000
#define SECURITY_VALID_SQOS_FLAGS 0x001F0000
//
// File structures
//
typedef struct _OVERLAPPED {
DWORD Internal;
DWORD InternalHigh;
DWORD Offset;
DWORD OffsetHigh;
HANDLE hEvent;
} OVERLAPPED, *LPOVERLAPPED;
typedef struct _SECURITY_ATTRIBUTES {
DWORD nLength;
LPVOID lpSecurityDescriptor;
BOOL bInheritHandle;
} SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
typedef struct _PROCESS_INFORMATION {
HANDLE hProcess;
HANDLE hThread;
DWORD dwProcessId;
DWORD dwThreadId;
} PROCESS_INFORMATION, *PPROCESS_INFORMATION, *LPPROCESS_INFORMATION;
//
// File System time stamps are represented with the following structure:
//
typedef struct _FILETIME {
DWORD dwLowDateTime;
DWORD dwHighDateTime;
} FILETIME, *PFILETIME, *LPFILETIME;
//
// System time is represented with the following structure:
//
typedef struct _SYSTEMTIME {
WORD wYear;
WORD wMonth;
WORD wDayOfWeek;
WORD wDay;
WORD wHour;
WORD wMinute;
WORD wSecond;
WORD wMilliseconds;
} SYSTEMTIME, *PSYSTEMTIME, *LPSYSTEMTIME;
typedef DWORD (WINAPI *PTHREAD_START_ROUTINE)(
LPVOID lpThreadParameter
);
typedef PTHREAD_START_ROUTINE LPTHREAD_START_ROUTINE;
#if(_WIN32_WINNT >= 0x0400)
typedef VOID (WINAPI *PFIBER_START_ROUTINE)(
LPVOID lpFiberParameter
);
typedef PFIBER_START_ROUTINE LPFIBER_START_ROUTINE;
#endif /* _WIN32_WINNT >= 0x0400 */
typedef RTL_CRITICAL_SECTION CRITICAL_SECTION;
typedef PRTL_CRITICAL_SECTION PCRITICAL_SECTION;
typedef PRTL_CRITICAL_SECTION LPCRITICAL_SECTION;
typedef RTL_CRITICAL_SECTION_DEBUG CRITICAL_SECTION_DEBUG;
typedef PRTL_CRITICAL_SECTION_DEBUG PCRITICAL_SECTION_DEBUG;
typedef PRTL_CRITICAL_SECTION_DEBUG LPCRITICAL_SECTION_DEBUG;
#ifdef _X86_
typedef PLDT_ENTRY LPLDT_ENTRY;
#else
typedef LPVOID LPLDT_ENTRY;
#endif
#define MUTEX_MODIFY_STATE MUTANT_QUERY_STATE
#define MUTEX_ALL_ACCESS MUTANT_ALL_ACCESS
//
// Serial provider type.
//
#define SP_SERIALCOMM ((DWORD)0x00000001)
//
// Provider SubTypes
//
#define PST_UNSPECIFIED ((DWORD)0x00000000)
#define PST_RS232 ((DWORD)0x00000001)
#define PST_PARALLELPORT ((DWORD)0x00000002)
#define PST_RS422 ((DWORD)0x00000003)
#define PST_RS423 ((DWORD)0x00000004)
#define PST_RS449 ((DWORD)0x00000005)
#define PST_MODEM ((DWORD)0x00000006)
#define PST_FAX ((DWORD)0x00000021)
#define PST_SCANNER ((DWORD)0x00000022)
#define PST_NETWORK_BRIDGE ((DWORD)0x00000100)
#define PST_LAT ((DWORD)0x00000101)
#define PST_TCPIP_TELNET ((DWORD)0x00000102)
#define PST_X25 ((DWORD)0x00000103)
//
// Provider capabilities flags.
//
#define PCF_DTRDSR ((DWORD)0x0001)
#define PCF_RTSCTS ((DWORD)0x0002)
#define PCF_RLSD ((DWORD)0x0004)
#define PCF_PARITY_CHECK ((DWORD)0x0008)
#define PCF_XONXOFF ((DWORD)0x0010)
#define PCF_SETXCHAR ((DWORD)0x0020)
#define PCF_TOTALTIMEOUTS ((DWORD)0x0040)
#define PCF_INTTIMEOUTS ((DWORD)0x0080)
#define PCF_SPECIALCHARS ((DWORD)0x0100)
#define PCF_16BITMODE ((DWORD)0x0200)
//
// Comm provider settable parameters.
//
#define SP_PARITY ((DWORD)0x0001)
#define SP_BAUD ((DWORD)0x0002)
#define SP_DATABITS ((DWORD)0x0004)
#define SP_STOPBITS ((DWORD)0x0008)
#define SP_HANDSHAKING ((DWORD)0x0010)
#define SP_PARITY_CHECK ((DWORD)0x0020)
#define SP_RLSD ((DWORD)0x0040)
//
// Settable baud rates in the provider.
//
#define BAUD_075 ((DWORD)0x00000001)
#define BAUD_110 ((DWORD)0x00000002)
#define BAUD_134_5 ((DWORD)0x00000004)
#define BAUD_150 ((DWORD)0x00000008)
#define BAUD_300 ((DWORD)0x00000010)
#define BAUD_600 ((DWORD)0x00000020)
#define BAUD_1200 ((DWORD)0x00000040)
#define BAUD_1800 ((DWORD)0x00000080)
#define BAUD_2400 ((DWORD)0x00000100)
#define BAUD_4800 ((DWORD)0x00000200)
#define BAUD_7200 ((DWORD)0x00000400)
#define BAUD_9600 ((DWORD)0x00000800)
#define BAUD_14400 ((DWORD)0x00001000)
#define BAUD_19200 ((DWORD)0x00002000)
#define BAUD_38400 ((DWORD)0x00004000)
#define BAUD_56K ((DWORD)0x00008000)
#define BAUD_128K ((DWORD)0x00010000)
#define BAUD_115200 ((DWORD)0x00020000)
#define BAUD_57600 ((DWORD)0x00040000)
#define BAUD_USER ((DWORD)0x10000000)
//
// Settable Data Bits
//
#define DATABITS_5 ((WORD)0x0001)
#define DATABITS_6 ((WORD)0x0002)
#define DATABITS_7 ((WORD)0x0004)
#define DATABITS_8 ((WORD)0x0008)
#define DATABITS_16 ((WORD)0x0010)
#define DATABITS_16X ((WORD)0x0020)
//
// Settable Stop and Parity bits.
//
#define STOPBITS_10 ((WORD)0x0001)
#define STOPBITS_15 ((WORD)0x0002)
#define STOPBITS_20 ((WORD)0x0004)
#define PARITY_NONE ((WORD)0x0100)
#define PARITY_ODD ((WORD)0x0200)
#define PARITY_EVEN ((WORD)0x0400)
#define PARITY_MARK ((WORD)0x0800)
#define PARITY_SPACE ((WORD)0x1000)
typedef 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[1];
} COMMPROP,*LPCOMMPROP;
//
// Set dwProvSpec1 to COMMPROP_INITIALIZED to indicate that wPacketLength
// is valid before a call to GetCommProperties().
//
#define COMMPROP_INITIALIZED ((DWORD)0xE73CF52E)
typedef 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 cbInQue;
DWORD cbOutQue;
} COMSTAT, *LPCOMSTAT;
//
// DTR Control Flow Values.
//
#define DTR_CONTROL_DISABLE 0x00
#define DTR_CONTROL_ENABLE 0x01
#define DTR_CONTROL_HANDSHAKE 0x02
//
// RTS Control Flow Values
//
#define RTS_CONTROL_DISABLE 0x00
#define RTS_CONTROL_ENABLE 0x01
#define RTS_CONTROL_HANDSHAKE 0x02
#define RTS_CONTROL_TOGGLE 0x03
typedef struct _DCB {
DWORD DCBlength; /* sizeof(DCB) */
DWORD BaudRate; /* Baudrate at which running */
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 */
WORD wReserved; /* Not currently used */
WORD XonLim; /* Transmit X-ON threshold */
WORD XoffLim; /* Transmit X-OFF threshold */
BYTE ByteSize; /* Number of bits/byte, 4-8 */
BYTE Parity; /* 0-4=None,Odd,Even,Mark,Space */
BYTE StopBits; /* 0,1,2 = 1, 1.5, 2 */
char XonChar; /* Tx and Rx X-ON character */
char XoffChar; /* Tx and Rx X-OFF character */
char ErrorChar; /* Error replacement char */
char EofChar; /* End of Input character */
char EvtChar; /* Received Event character */
WORD wReserved1; /* Fill for now. */
} DCB, *LPDCB;
typedef struct _COMMTIMEOUTS {
DWORD ReadIntervalTimeout; /* Maximum time between read chars. */
DWORD ReadTotalTimeoutMultiplier; /* Multiplier of characters. */
DWORD ReadTotalTimeoutConstant; /* Constant in milliseconds. */
DWORD WriteTotalTimeoutMultiplier; /* Multiplier of characters. */
DWORD WriteTotalTimeoutConstant; /* Constant in milliseconds. */
} COMMTIMEOUTS,*LPCOMMTIMEOUTS;
typedef struct _COMMCONFIG {
DWORD dwSize; /* Size of the entire struct */
WORD wVersion; /* version of the structure */
WORD wReserved; /* alignment */
DCB dcb; /* device control block */
DWORD dwProviderSubType; /* ordinal value for identifying
provider-defined data structure format*/
DWORD dwProviderOffset; /* Specifies the offset of provider specific
data field in bytes from the start */
DWORD dwProviderSize; /* size of the provider-specific data field */
WCHAR wcProviderData[1]; /* provider-specific data */
} COMMCONFIG,*LPCOMMCONFIG;
typedef struct _SYSTEM_INFO {
union {
DWORD dwOemId; // Obsolete field...do not use
struct {
WORD wProcessorArchitecture;
WORD wReserved;
};
};
DWORD dwPageSize;
LPVOID lpMinimumApplicationAddress;
LPVOID lpMaximumApplicationAddress;
DWORD dwActiveProcessorMask;
DWORD dwNumberOfProcessors;
DWORD dwProcessorType;
DWORD dwAllocationGranularity;
WORD wProcessorLevel;
WORD wProcessorRevision;
} SYSTEM_INFO, *LPSYSTEM_INFO;
//
//
#define FreeModule(hLibModule) FreeLibrary((hLibModule))
#define MakeProcInstance(lpProc,hInstance) (lpProc)
#define FreeProcInstance(lpProc) (lpProc)
/* Global Memory Flags */
#define GMEM_FIXED 0x0000
#define GMEM_MOVEABLE 0x0002
#define GMEM_NOCOMPACT 0x0010
#define GMEM_NODISCARD 0x0020
#define GMEM_ZEROINIT 0x0040
#define GMEM_MODIFY 0x0080
#define GMEM_DISCARDABLE 0x0100
#define GMEM_NOT_BANKED 0x1000
#define GMEM_SHARE 0x2000
#define GMEM_DDESHARE 0x2000
#define GMEM_NOTIFY 0x4000
#define GMEM_LOWER GMEM_NOT_BANKED
#define GMEM_VALID_FLAGS 0x7F72
#define GMEM_INVALID_HANDLE 0x8000
#define GHND (GMEM_MOVEABLE | GMEM_ZEROINIT)
#define GPTR (GMEM_FIXED | GMEM_ZEROINIT)
#define GlobalLRUNewest( h ) (HANDLE)(h)
#define GlobalLRUOldest( h ) (HANDLE)(h)
#define GlobalDiscard( h ) GlobalReAlloc( (h), 0, GMEM_MOVEABLE )
/* Flags returned by GlobalFlags (in addition to GMEM_DISCARDABLE) */
#define GMEM_DISCARDED 0x4000
#define GMEM_LOCKCOUNT 0x00FF
typedef struct _MEMORYSTATUS {
DWORD dwLength;
DWORD dwMemoryLoad;
DWORD dwTotalPhys;
DWORD dwAvailPhys;
DWORD dwTotalPageFile;
DWORD dwAvailPageFile;
DWORD dwTotalVirtual;
DWORD dwAvailVirtual;
} MEMORYSTATUS, *LPMEMORYSTATUS;
/* Local Memory Flags */
#define LMEM_FIXED 0x0000
#define LMEM_MOVEABLE 0x0002
#define LMEM_NOCOMPACT 0x0010
#define LMEM_NODISCARD 0x0020
#define LMEM_ZEROINIT 0x0040
#define LMEM_MODIFY 0x0080
#define LMEM_DISCARDABLE 0x0F00
#define LMEM_VALID_FLAGS 0x0F72
#define LMEM_INVALID_HANDLE 0x8000
#define LHND (LMEM_MOVEABLE | LMEM_ZEROINIT)
#define LPTR (LMEM_FIXED | LMEM_ZEROINIT)
#define NONZEROLHND (LMEM_MOVEABLE)
#define NONZEROLPTR (LMEM_FIXED)
#define LocalDiscard( h ) LocalReAlloc( (h), 0, LMEM_MOVEABLE )
/* Flags returned by LocalFlags (in addition to LMEM_DISCARDABLE) */
#define LMEM_DISCARDED 0x4000
#define LMEM_LOCKCOUNT 0x00FF
//
// dwCreationFlag values
//
#define DEBUG_PROCESS 0x00000001
#define DEBUG_ONLY_THIS_PROCESS 0x00000002
#define CREATE_SUSPENDED 0x00000004
#define DETACHED_PROCESS 0x00000008
#define CREATE_NEW_CONSOLE 0x00000010
#define NORMAL_PRIORITY_CLASS 0x00000020
#define IDLE_PRIORITY_CLASS 0x00000040
#define HIGH_PRIORITY_CLASS 0x00000080
#define REALTIME_PRIORITY_CLASS 0x00000100
#define CREATE_NEW_PROCESS_GROUP 0x00000200
#define CREATE_UNICODE_ENVIRONMENT 0x00000400
#define CREATE_SEPARATE_WOW_VDM 0x00000800
#define CREATE_SHARED_WOW_VDM 0x00001000
#define CREATE_FORCEDOS 0x00002000
#define CREATE_DEFAULT_ERROR_MODE 0x04000000
#define CREATE_NO_WINDOW 0x08000000
#define PROFILE_USER 0x10000000
#define PROFILE_KERNEL 0x20000000
#define PROFILE_SERVER 0x40000000
#define THREAD_PRIORITY_LOWEST THREAD_BASE_PRIORITY_MIN
#define THREAD_PRIORITY_BELOW_NORMAL (THREAD_PRIORITY_LOWEST+1)
#define THREAD_PRIORITY_NORMAL 0
#define THREAD_PRIORITY_HIGHEST THREAD_BASE_PRIORITY_MAX
#define THREAD_PRIORITY_ABOVE_NORMAL (THREAD_PRIORITY_HIGHEST-1)
#define THREAD_PRIORITY_ERROR_RETURN (MAXLONG)
#define THREAD_PRIORITY_TIME_CRITICAL THREAD_BASE_PRIORITY_LOWRT
#define THREAD_PRIORITY_IDLE THREAD_BASE_PRIORITY_IDLE
//
// Debug APIs
//
#define EXCEPTION_DEBUG_EVENT 1
#define CREATE_THREAD_DEBUG_EVENT 2
#define CREATE_PROCESS_DEBUG_EVENT 3
#define EXIT_THREAD_DEBUG_EVENT 4
#define EXIT_PROCESS_DEBUG_EVENT 5
#define LOAD_DLL_DEBUG_EVENT 6
#define UNLOAD_DLL_DEBUG_EVENT 7
#define OUTPUT_DEBUG_STRING_EVENT 8
#define RIP_EVENT 9
typedef struct _EXCEPTION_DEBUG_INFO {
EXCEPTION_RECORD ExceptionRecord;
DWORD dwFirstChance;
} EXCEPTION_DEBUG_INFO, *LPEXCEPTION_DEBUG_INFO;
typedef struct _CREATE_THREAD_DEBUG_INFO {
HANDLE hThread;
LPVOID lpThreadLocalBase;
LPTHREAD_START_ROUTINE lpStartAddress;
} CREATE_THREAD_DEBUG_INFO, *LPCREATE_THREAD_DEBUG_INFO;
typedef 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;
} CREATE_PROCESS_DEBUG_INFO, *LPCREATE_PROCESS_DEBUG_INFO;
typedef struct _EXIT_THREAD_DEBUG_INFO {
DWORD dwExitCode;
} EXIT_THREAD_DEBUG_INFO, *LPEXIT_THREAD_DEBUG_INFO;
typedef struct _EXIT_PROCESS_DEBUG_INFO {
DWORD dwExitCode;
} EXIT_PROCESS_DEBUG_INFO, *LPEXIT_PROCESS_DEBUG_INFO;
typedef struct _LOAD_DLL_DEBUG_INFO {
HANDLE hFile;
LPVOID lpBaseOfDll;
DWORD dwDebugInfoFileOffset;
DWORD nDebugInfoSize;
LPVOID lpImageName;
WORD fUnicode;
} LOAD_DLL_DEBUG_INFO, *LPLOAD_DLL_DEBUG_INFO;
typedef struct _UNLOAD_DLL_DEBUG_INFO {
LPVOID lpBaseOfDll;
} UNLOAD_DLL_DEBUG_INFO, *LPUNLOAD_DLL_DEBUG_INFO;
typedef struct _OUTPUT_DEBUG_STRING_INFO {
LPSTR lpDebugStringData;
WORD fUnicode;
WORD nDebugStringLength;
} OUTPUT_DEBUG_STRING_INFO, *LPOUTPUT_DEBUG_STRING_INFO;
typedef struct _RIP_INFO {
DWORD dwError;
DWORD dwType;
} RIP_INFO, *LPRIP_INFO;
typedef 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;
} u;
} DEBUG_EVENT, *LPDEBUG_EVENT;
#if !defined(MIDL_PASS)
typedef PCONTEXT LPCONTEXT;
typedef PEXCEPTION_RECORD LPEXCEPTION_RECORD;
typedef PEXCEPTION_POINTERS LPEXCEPTION_POINTERS;
#endif
#define DRIVE_UNKNOWN 0
#define DRIVE_NO_ROOT_DIR 1
#define DRIVE_REMOVABLE 2
#define DRIVE_FIXED 3
#define DRIVE_REMOTE 4
#define DRIVE_CDROM 5
#define DRIVE_RAMDISK 6
#ifndef _MAC
#define GetFreeSpace(w) (0x100000L)
#else
WINBASEAPI DWORD WINAPI GetFreeSpace(UINT);
#endif
#define FILE_TYPE_UNKNOWN 0x0000
#define FILE_TYPE_DISK 0x0001
#define FILE_TYPE_CHAR 0x0002
#define FILE_TYPE_PIPE 0x0003
#define FILE_TYPE_REMOTE 0x8000
#define STD_INPUT_HANDLE (DWORD)-10
#define STD_OUTPUT_HANDLE (DWORD)-11
#define STD_ERROR_HANDLE (DWORD)-12
#define NOPARITY 0
#define ODDPARITY 1
#define EVENPARITY 2
#define MARKPARITY 3
#define SPACEPARITY 4
#define ONESTOPBIT 0
#define ONE5STOPBITS 1
#define TWOSTOPBITS 2
#define IGNORE 0 // Ignore signal
#define INFINITE 0xFFFFFFFF // Infinite timeout
//
// Baud rates at which the communication device operates
//
#define CBR_110 110
#define CBR_300 300
#define CBR_600 600
#define CBR_1200 1200
#define CBR_2400 2400
#define CBR_4800 4800
#define CBR_9600 9600
#define CBR_14400 14400
#define CBR_19200 19200
#define CBR_38400 38400
#define CBR_56000 56000
#define CBR_57600 57600
#define CBR_115200 115200
#define CBR_128000 128000
#define CBR_256000 256000
//
// Error Flags
//
#define CE_RXOVER 0x0001 // Receive Queue overflow
#define CE_OVERRUN 0x0002 // Receive Overrun Error
#define CE_RXPARITY 0x0004 // Receive Parity Error
#define CE_FRAME 0x0008 // Receive Framing error
#define CE_BREAK 0x0010 // Break Detected
#define CE_TXFULL 0x0100 // TX Queue is full
#define CE_PTO 0x0200 // LPTx Timeout
#define CE_IOE 0x0400 // LPTx I/O Error
#define CE_DNS 0x0800 // LPTx Device not selected
#define CE_OOP 0x1000 // LPTx Out-Of-Paper
#define CE_MODE 0x8000 // Requested mode unsupported
#define IE_BADID (-1) // Invalid or unsupported id
#define IE_OPEN (-2) // Device Already Open
#define IE_NOPEN (-3) // Device Not Open
#define IE_MEMORY (-4) // Unable to allocate queues
#define IE_DEFAULT (-5) // Error in default parameters
#define IE_HARDWARE (-10) // Hardware Not Present
#define IE_BYTESIZE (-11) // Illegal Byte Size
#define IE_BAUDRATE (-12) // Unsupported BaudRate
//
// Events
//
#define EV_RXCHAR 0x0001 // Any Character received
#define EV_RXFLAG 0x0002 // Received certain character
#define EV_TXEMPTY 0x0004 // Transmitt Queue Empty
#define EV_CTS 0x0008 // CTS changed state
#define EV_DSR 0x0010 // DSR changed state
#define EV_RLSD 0x0020 // RLSD changed state
#define EV_BREAK 0x0040 // BREAK received
#define EV_ERR 0x0080 // Line status error occurred
#define EV_RING 0x0100 // Ring signal detected
#define EV_PERR 0x0200 // Printer error occured
#define EV_RX80FULL 0x0400 // Receive buffer is 80 percent full
#define EV_EVENT1 0x0800 // Provider specific event 1
#define EV_EVENT2 0x1000 // Provider specific event 2
//
// Escape Functions
//
#define SETXOFF 1 // Simulate XOFF received
#define SETXON 2 // Simulate XON received
#define SETRTS 3 // Set RTS high
#define CLRRTS 4 // Set RTS low
#define SETDTR 5 // Set DTR high
#define CLRDTR 6 // Set DTR low
#define RESETDEV 7 // Reset device if possible
#define SETBREAK 8 // Set the device break line.
#define CLRBREAK 9 // Clear the device break line.
//
// PURGE function flags.
//
#define PURGE_TXABORT 0x0001 // Kill the pending/current writes to the comm port.
#define PURGE_RXABORT 0x0002 // Kill the pending/current reads to the comm port.
#define PURGE_TXCLEAR 0x0004 // Kill the transmit queue if there.
#define PURGE_RXCLEAR 0x0008 // Kill the typeahead buffer if there.
#define LPTx 0x80 // Set if ID is for LPT device
//
// Modem Status Flags
//
#define MS_CTS_ON ((DWORD)0x0010)
#define MS_DSR_ON ((DWORD)0x0020)
#define MS_RING_ON ((DWORD)0x0040)
#define MS_RLSD_ON ((DWORD)0x0080)
//
// WaitSoundState() Constants
//
#define S_QUEUEEMPTY 0
#define S_THRESHOLD 1
#define S_ALLTHRESHOLD 2
//
// Accent Modes
//
#define S_NORMAL 0
#define S_LEGATO 1
#define S_STACCATO 2
//
// SetSoundNoise() Sources
//
#define S_PERIOD512 0 // Freq = N/512 high pitch, less coarse hiss
#define S_PERIOD1024 1 // Freq = N/1024
#define S_PERIOD2048 2 // Freq = N/2048 low pitch, more coarse hiss
#define S_PERIODVOICE 3 // Source is frequency from voice channel (3)
#define S_WHITE512 4 // Freq = N/512 high pitch, less coarse hiss
#define S_WHITE1024 5 // Freq = N/1024
#define S_WHITE2048 6 // Freq = N/2048 low pitch, more coarse hiss
#define S_WHITEVOICE 7 // Source is frequency from voice channel (3)
#define S_SERDVNA (-1) // Device not available
#define S_SEROFM (-2) // Out of memory
#define S_SERMACT (-3) // Music active
#define S_SERQFUL (-4) // Queue full
#define S_SERBDNT (-5) // Invalid note
#define S_SERDLN (-6) // Invalid note length
#define S_SERDCC (-7) // Invalid note count
#define S_SERDTP (-8) // Invalid tempo
#define S_SERDVL (-9) // Invalid volume
#define S_SERDMD (-10) // Invalid mode
#define S_SERDSH (-11) // Invalid shape
#define S_SERDPT (-12) // Invalid pitch
#define S_SERDFQ (-13) // Invalid frequency
#define S_SERDDR (-14) // Invalid duration
#define S_SERDSR (-15) // Invalid source
#define S_SERDST (-16) // Invalid state
#define NMPWAIT_WAIT_FOREVER 0xffffffff
#define NMPWAIT_NOWAIT 0x00000001
#define NMPWAIT_USE_DEFAULT_WAIT 0x00000000
#define FS_CASE_IS_PRESERVED FILE_CASE_PRESERVED_NAMES
#define FS_CASE_SENSITIVE FILE_CASE_SENSITIVE_SEARCH
#define FS_UNICODE_STORED_ON_DISK FILE_UNICODE_ON_DISK
#define FS_PERSISTENT_ACLS FILE_PERSISTENT_ACLS
#define FS_VOL_IS_COMPRESSED FILE_VOLUME_IS_COMPRESSED
#define FS_FILE_COMPRESSION FILE_FILE_COMPRESSION
#define FILE_MAP_COPY SECTION_QUERY
#define FILE_MAP_WRITE SECTION_MAP_WRITE
#define FILE_MAP_READ SECTION_MAP_READ
#define FILE_MAP_ALL_ACCESS SECTION_ALL_ACCESS
#define OF_READ 0x00000000
#define OF_WRITE 0x00000001
#define OF_READWRITE 0x00000002
#define OF_SHARE_COMPAT 0x00000000
#define OF_SHARE_EXCLUSIVE 0x00000010
#define OF_SHARE_DENY_WRITE 0x00000020
#define OF_SHARE_DENY_READ 0x00000030
#define OF_SHARE_DENY_NONE 0x00000040
#define OF_PARSE 0x00000100
#define OF_DELETE 0x00000200
#define OF_VERIFY 0x00000400
#define OF_CANCEL 0x00000800
#define OF_CREATE 0x00001000
#define OF_PROMPT 0x00002000
#define OF_EXIST 0x00004000
#define OF_REOPEN 0x00008000
#define OFS_MAXPATHNAME 128
typedef struct _OFSTRUCT {
BYTE cBytes;
BYTE fFixedDisk;
WORD nErrCode;
WORD Reserved1;
WORD Reserved2;
CHAR szPathName[OFS_MAXPATHNAME];
} OFSTRUCT, *LPOFSTRUCT, *POFSTRUCT;
//
// The MS-MIPS and Alpha compilers support intrinsic functions for interlocked
// increment, decrement, and exchange.
//
#if (defined(_M_MRX000) || defined(_M_ALPHA) || (defined(_M_PPC) && (_MSC_VER >= 1000))) && !defined(RC_INVOKED)
#define InterlockedIncrement _InterlockedIncrement
#define InterlockedDecrement _InterlockedDecrement
#define InterlockedExchange _InterlockedExchange
#define InterlockedExchangeAdd _InterlockedExchangeAdd
#define InterlockedCompareExchange _InterlockedCompareExchange
LONG
WINAPI
InterlockedIncrement(
LPLONG lpAddend
);
LONG
WINAPI
InterlockedDecrement(
LPLONG lpAddend
);
LONG
WINAPI
InterlockedExchange(
LPLONG Target,
LONG Value
);
PVOID
WINAPI
InterlockedCompareExchange (
PVOID *Destination,
PVOID Exchange,
PVOID Comperand
);
LONG
WINAPI
InterlockedExchangeAdd(
LPLONG Addend,
LONG Value
);
#pragma intrinsic(_InterlockedIncrement)
#pragma intrinsic(_InterlockedDecrement)
#pragma intrinsic(_InterlockedExchange)
#pragma intrinsic(_InterlockedCompareExchange)
#pragma intrinsic(_InterlockedExchangeAdd)
#else
#ifndef _NTOS_
WINBASEAPI
LONG
WINAPI
InterlockedIncrement(
LPLONG lpAddend
);
WINBASEAPI
LONG
WINAPI
InterlockedDecrement(
LPLONG lpAddend
);
WINBASEAPI
LONG
WINAPI
InterlockedExchange(
LPLONG Target,
LONG Value
);
WINBASEAPI
LONG
WINAPI
InterlockedExchangeAdd(
LPLONG Addend,
LONG Value
);
WINBASEAPI
PVOID
WINAPI
InterlockedCompareExchange (
PVOID *Destination,
PVOID Exchange,
PVOID Comperand
);
#endif /* NT_INCLUDED */
#endif
WINBASEAPI
BOOL
WINAPI
FreeResource(
HGLOBAL hResData
);
WINBASEAPI
LPVOID
WINAPI
LockResource(
HGLOBAL hResData
);
#define UnlockResource(hResData) ((hResData), 0)
#define MAXINTATOM 0xC000
#define MAKEINTATOM(i) (LPTSTR)((DWORD)((WORD)(i)))
#define INVALID_ATOM ((ATOM)0)
#ifndef _MAC
int
WINAPI
#else
int
CALLBACK
#endif
WinMain(
HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nShowCmd
);
WINBASEAPI
BOOL
WINAPI
FreeLibrary(
HMODULE hLibModule
);
WINBASEAPI
VOID
WINAPI
FreeLibraryAndExitThread(
HMODULE hLibModule,
DWORD dwExitCode
);
WINBASEAPI
BOOL
WINAPI
DisableThreadLibraryCalls(
HMODULE hLibModule
);
WINBASEAPI
FARPROC
WINAPI
GetProcAddress(
HMODULE hModule,
LPCSTR lpProcName
);
WINBASEAPI
DWORD
WINAPI
GetVersion( VOID );
WINBASEAPI
HGLOBAL
WINAPI
GlobalAlloc(
UINT uFlags,
DWORD dwBytes
);
WINBASEAPI
HGLOBAL
WINAPI
GlobalReAlloc(
HGLOBAL hMem,
DWORD dwBytes,
UINT uFlags
);
WINBASEAPI
DWORD
WINAPI
GlobalSize(
HGLOBAL hMem
);
WINBASEAPI
UINT
WINAPI
GlobalFlags(
HGLOBAL hMem
);
WINBASEAPI
LPVOID
WINAPI
GlobalLock(
HGLOBAL hMem
);
//!!!MWH My version win31 = DWORD WINAPI GlobalHandle(UINT)
WINBASEAPI
HGLOBAL
WINAPI
GlobalHandle(
LPCVOID pMem
);
WINBASEAPI
BOOL
WINAPI
GlobalUnlock(
HGLOBAL hMem
);
WINBASEAPI
HGLOBAL
WINAPI
GlobalFree(
HGLOBAL hMem
);
WINBASEAPI
UINT
WINAPI
GlobalCompact(
DWORD dwMinFree
);
WINBASEAPI
VOID
WINAPI
GlobalFix(
HGLOBAL hMem
);
WINBASEAPI
VOID
WINAPI
GlobalUnfix(
HGLOBAL hMem
);
WINBASEAPI
LPVOID
WINAPI
GlobalWire(
HGLOBAL hMem
);
WINBASEAPI
BOOL
WINAPI
GlobalUnWire(
HGLOBAL hMem
);
WINBASEAPI
VOID
WINAPI
GlobalMemoryStatus(
LPMEMORYSTATUS lpBuffer
);
WINBASEAPI
HLOCAL
WINAPI
LocalAlloc(
UINT uFlags,
UINT uBytes
);
WINBASEAPI
HLOCAL
WINAPI
LocalReAlloc(
HLOCAL hMem,
UINT uBytes,
UINT uFlags
);
WINBASEAPI
LPVOID
WINAPI
LocalLock(
HLOCAL hMem
);
WINBASEAPI
HLOCAL
WINAPI
LocalHandle(
LPCVOID pMem
);
WINBASEAPI
BOOL
WINAPI
LocalUnlock(
HLOCAL hMem
);
WINBASEAPI
UINT
WINAPI
LocalSize(
HLOCAL hMem
);
WINBASEAPI
UINT
WINAPI
LocalFlags(
HLOCAL hMem
);
WINBASEAPI
HLOCAL
WINAPI
LocalFree(
HLOCAL hMem
);
WINBASEAPI
UINT
WINAPI
LocalShrink(
HLOCAL hMem,
UINT cbNewSize
);
WINBASEAPI
UINT
WINAPI
LocalCompact(
UINT uMinFree
);
WINBASEAPI
BOOL
WINAPI
FlushInstructionCache(
HANDLE hProcess,
LPCVOID lpBaseAddress,
DWORD dwSize
);
WINBASEAPI
LPVOID
WINAPI
VirtualAlloc(
LPVOID lpAddress,
DWORD dwSize,
DWORD flAllocationType,
DWORD flProtect
);
WINBASEAPI
BOOL
WINAPI
VirtualFree(
LPVOID lpAddress,
DWORD dwSize,
DWORD dwFreeType
);
WINBASEAPI
BOOL
WINAPI
VirtualProtect(
LPVOID lpAddress,
DWORD dwSize,
DWORD flNewProtect,
PDWORD lpflOldProtect
);
WINBASEAPI
DWORD
WINAPI
VirtualQuery(
LPCVOID lpAddress,
PMEMORY_BASIC_INFORMATION lpBuffer,
DWORD dwLength
);
WINBASEAPI
LPVOID
WINAPI
VirtualAllocEx(
HANDLE hProcess,
LPVOID lpAddress,
DWORD dwSize,
DWORD flAllocationType,
DWORD flProtect
);
WINBASEAPI
BOOL
WINAPI
VirtualFreeEx(
HANDLE hProcess,
LPVOID lpAddress,
DWORD dwSize,
DWORD dwFreeType
);
WINBASEAPI
BOOL
WINAPI
VirtualProtectEx(
HANDLE hProcess,
LPVOID lpAddress,
DWORD dwSize,
DWORD flNewProtect,
PDWORD lpflOldProtect
);
WINBASEAPI
DWORD
WINAPI
VirtualQueryEx(
HANDLE hProcess,
LPCVOID lpAddress,
PMEMORY_BASIC_INFORMATION lpBuffer,
DWORD dwLength
);
WINBASEAPI
HANDLE
WINAPI
HeapCreate(
DWORD flOptions,
DWORD dwInitialSize,
DWORD dwMaximumSize
);
WINBASEAPI
BOOL
WINAPI
HeapDestroy(
HANDLE hHeap
);
WINBASEAPI
LPVOID
WINAPI
HeapAlloc(
HANDLE hHeap,
DWORD dwFlags,
DWORD dwBytes
);
WINBASEAPI
LPVOID
WINAPI
HeapReAlloc(
HANDLE hHeap,
DWORD dwFlags,
LPVOID lpMem,
DWORD dwBytes
);
WINBASEAPI
BOOL
WINAPI
HeapFree(
HANDLE hHeap,
DWORD dwFlags,
LPVOID lpMem
);
WINBASEAPI
DWORD
WINAPI
HeapSize(
HANDLE hHeap,
DWORD dwFlags,
LPCVOID lpMem
);
WINBASEAPI
BOOL
WINAPI
HeapValidate(
HANDLE hHeap,
DWORD dwFlags,
LPCVOID lpMem
);
WINBASEAPI
UINT
WINAPI
HeapCompact(
HANDLE hHeap,
DWORD dwFlags
);
WINBASEAPI
HANDLE
WINAPI
GetProcessHeap( VOID );
WINBASEAPI
DWORD
WINAPI
GetProcessHeaps(
DWORD NumberOfHeaps,
PHANDLE ProcessHeaps
);
typedef struct _PROCESS_HEAP_ENTRY {
PVOID lpData;
DWORD cbData;
BYTE cbOverhead;
BYTE iRegionIndex;
WORD wFlags;
union {
struct {
HANDLE hMem;
DWORD dwReserved[ 3 ];
} Block;
struct {
DWORD dwCommittedSize;
DWORD dwUnCommittedSize;
LPVOID lpFirstBlock;
LPVOID lpLastBlock;
} Region;
};
} PROCESS_HEAP_ENTRY, *LPPROCESS_HEAP_ENTRY, *PPROCESS_HEAP_ENTRY;
#define PROCESS_HEAP_REGION 0x0001
#define PROCESS_HEAP_UNCOMMITTED_RANGE 0x0002
#define PROCESS_HEAP_ENTRY_BUSY 0x0004
#define PROCESS_HEAP_ENTRY_MOVEABLE 0x0010
#define PROCESS_HEAP_ENTRY_DDESHARE 0x0020
WINBASEAPI
BOOL
WINAPI
HeapLock(
HANDLE hHeap
);
WINBASEAPI
BOOL
WINAPI
HeapUnlock(
HANDLE hHeap
);
WINBASEAPI
BOOL
WINAPI
HeapWalk(
HANDLE hHeap,
LPPROCESS_HEAP_ENTRY lpEntry
);
// GetBinaryType return values.
#define SCS_32BIT_BINARY 0
#define SCS_DOS_BINARY 1
#define SCS_WOW_BINARY 2
#define SCS_PIF_BINARY 3
#define SCS_POSIX_BINARY 4
#define SCS_OS216_BINARY 5
WINBASEAPI
BOOL
WINAPI
GetBinaryTypeA(
LPCSTR lpApplicationName,
LPDWORD lpBinaryType
);
WINBASEAPI
BOOL
WINAPI
GetBinaryTypeW(
LPCWSTR lpApplicationName,
LPDWORD lpBinaryType
);
#ifdef UNICODE
#define GetBinaryType GetBinaryTypeW
#else
#define GetBinaryType GetBinaryTypeA
#endif // !UNICODE
WINBASEAPI
DWORD
WINAPI
GetShortPathNameA(
LPCSTR lpszLongPath,
LPSTR lpszShortPath,
DWORD cchBuffer
);
WINBASEAPI
DWORD
WINAPI
GetShortPathNameW(
LPCWSTR lpszLongPath,
LPWSTR lpszShortPath,
DWORD cchBuffer
);
#ifdef UNICODE
#define GetShortPathName GetShortPathNameW
#else
#define GetShortPathName GetShortPathNameA
#endif // !UNICODE
WINBASEAPI
DWORD
WINAPI
GetLongPathNameA(
LPCSTR lpszShortPath,
LPSTR lpszLongPath,
DWORD cchBuffer
);
WINBASEAPI
DWORD
WINAPI
GetLongPathNameW(
LPCWSTR lpszShortPath,
LPWSTR lpszLongPath,
DWORD cchBuffer
);
#ifdef UNICODE
#define GetLongPathName GetLongPathNameW
#else
#define GetLongPathName GetLongPathNameA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
GetProcessAffinityMask(
HANDLE hProcess,
LPDWORD lpProcessAffinityMask,
LPDWORD lpSystemAffinityMask
);
WINBASEAPI
BOOL
WINAPI
SetProcessAffinityMask(
HANDLE hProcess,
DWORD dwProcessAffinityMask
);
WINBASEAPI
BOOL
WINAPI
GetProcessTimes(
HANDLE hProcess,
LPFILETIME lpCreationTime,
LPFILETIME lpExitTime,
LPFILETIME lpKernelTime,
LPFILETIME lpUserTime
);
WINBASEAPI
BOOL
WINAPI
GetProcessWorkingSetSize(
HANDLE hProcess,
LPDWORD lpMinimumWorkingSetSize,
LPDWORD lpMaximumWorkingSetSize
);
WINBASEAPI
BOOL
WINAPI
SetProcessWorkingSetSize(
HANDLE hProcess,
DWORD dwMinimumWorkingSetSize,
DWORD dwMaximumWorkingSetSize
);
WINBASEAPI
HANDLE
WINAPI
OpenProcess(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
DWORD dwProcessId
);
WINBASEAPI
HANDLE
WINAPI
GetCurrentProcess(
VOID
);
WINBASEAPI
DWORD
WINAPI
GetCurrentProcessId(
VOID
);
WINBASEAPI
VOID
WINAPI
ExitProcess(
UINT uExitCode
);
WINBASEAPI
BOOL
WINAPI
TerminateProcess(
HANDLE hProcess,
UINT uExitCode
);
WINBASEAPI
BOOL
WINAPI
GetExitCodeProcess(
HANDLE hProcess,
LPDWORD lpExitCode
);
WINBASEAPI
VOID
WINAPI
FatalExit(
int ExitCode
);
WINBASEAPI
LPSTR
WINAPI
GetEnvironmentStrings(
VOID
);
WINBASEAPI
LPWSTR
WINAPI
GetEnvironmentStringsW(
VOID
);
#ifdef UNICODE
#define GetEnvironmentStrings GetEnvironmentStringsW
#else
#define GetEnvironmentStringsA GetEnvironmentStrings
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
FreeEnvironmentStringsA(
LPSTR
);
WINBASEAPI
BOOL
WINAPI
FreeEnvironmentStringsW(
LPWSTR
);
#ifdef UNICODE
#define FreeEnvironmentStrings FreeEnvironmentStringsW
#else
#define FreeEnvironmentStrings FreeEnvironmentStringsA
#endif // !UNICODE
WINBASEAPI
VOID
WINAPI
RaiseException(
DWORD dwExceptionCode,
DWORD dwExceptionFlags,
DWORD nNumberOfArguments,
CONST DWORD *lpArguments
);
WINBASEAPI
LONG
WINAPI
UnhandledExceptionFilter(
struct _EXCEPTION_POINTERS *ExceptionInfo
);
typedef LONG (WINAPI *PTOP_LEVEL_EXCEPTION_FILTER)(
struct _EXCEPTION_POINTERS *ExceptionInfo
);
typedef PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER;
WINBASEAPI
LPTOP_LEVEL_EXCEPTION_FILTER
WINAPI
SetUnhandledExceptionFilter(
LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter
);
#if(_WIN32_WINNT >= 0x0400)
WINBASEAPI
LPVOID
WINAPI
CreateFiber(
DWORD dwStackSize,
LPFIBER_START_ROUTINE lpStartAddress,
LPVOID lpParameter
);
WINBASEAPI
VOID
WINAPI
DeleteFiber(
LPVOID lpFiber
);
WINBASEAPI
LPVOID
WINAPI
ConvertThreadToFiber(
LPVOID lpParameter
);
WINBASEAPI
VOID
WINAPI
SwitchToFiber(
LPVOID lpFiber
);
WINBASEAPI
BOOL
WINAPI
SwitchToThread(
VOID
);
#endif /* _WIN32_WINNT >= 0x0400 */
WINBASEAPI
HANDLE
WINAPI
CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
DWORD dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);
WINBASEAPI
HANDLE
WINAPI
CreateRemoteThread(
HANDLE hProcess,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
DWORD dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);
WINBASEAPI
HANDLE
WINAPI
GetCurrentThread(
VOID
);
WINBASEAPI
DWORD
WINAPI
GetCurrentThreadId(
VOID
);
WINBASEAPI
DWORD
WINAPI
SetThreadAffinityMask(
HANDLE hThread,
DWORD dwThreadAffinityMask
);
#if(_WIN32_WINNT >= 0x0400)
WINBASEAPI
DWORD
WINAPI
SetThreadIdealProcessor(
HANDLE hThread,
DWORD dwIdealProcessor
);
#endif /* _WIN32_WINNT >= 0x0400 */
WINBASEAPI
BOOL
WINAPI
SetProcessPriorityBoost(
HANDLE hProcess,
BOOL bDisablePriorityBoost
);
WINBASEAPI
BOOL
WINAPI
GetProcessPriorityBoost(
HANDLE hProcess,
PBOOL pDisablePriorityBoost
);
WINBASEAPI
BOOL
WINAPI
RequestWakeupLatency(
LATENCY_TIME latency
);
WINBASEAPI
BOOL
WINAPI
SetThreadPriority(
HANDLE hThread,
int nPriority
);
WINBASEAPI
BOOL
WINAPI
SetThreadPriorityBoost(
HANDLE hThread,
BOOL bDisablePriorityBoost
);
WINBASEAPI
BOOL
WINAPI
GetThreadPriorityBoost(
HANDLE hThread,
PBOOL pDisablePriorityBoost
);
WINBASEAPI
int
WINAPI
GetThreadPriority(
HANDLE hThread
);
WINBASEAPI
BOOL
WINAPI
GetThreadTimes(
HANDLE hThread,
LPFILETIME lpCreationTime,
LPFILETIME lpExitTime,
LPFILETIME lpKernelTime,
LPFILETIME lpUserTime
);
WINBASEAPI
VOID
WINAPI
ExitThread(
DWORD dwExitCode
);
WINBASEAPI
BOOL
WINAPI
TerminateThread(
HANDLE hThread,
DWORD dwExitCode
);
WINBASEAPI
BOOL
WINAPI
GetExitCodeThread(
HANDLE hThread,
LPDWORD lpExitCode
);
WINBASEAPI
BOOL
WINAPI
GetThreadSelectorEntry(
HANDLE hThread,
DWORD dwSelector,
LPLDT_ENTRY lpSelectorEntry
);
WINBASEAPI
EXECUTION_STATE
WINAPI
SetThreadExecutionState(
EXECUTION_STATE esFlags
);
WINBASEAPI
DWORD
WINAPI
GetLastError(
VOID
);
WINBASEAPI
VOID
WINAPI
SetLastError(
DWORD dwErrCode
);
#define HasOverlappedIoCompleted(lpOverlapped) ((lpOverlapped)->Internal != STATUS_PENDING)
WINBASEAPI
BOOL
WINAPI
GetOverlappedResult(
HANDLE hFile,
LPOVERLAPPED lpOverlapped,
LPDWORD lpNumberOfBytesTransferred,
BOOL bWait
);
WINBASEAPI
HANDLE
WINAPI
CreateIoCompletionPort(
HANDLE FileHandle,
HANDLE ExistingCompletionPort,
DWORD CompletionKey,
DWORD NumberOfConcurrentThreads
);
WINBASEAPI
BOOL
WINAPI
GetQueuedCompletionStatus(
HANDLE CompletionPort,
LPDWORD lpNumberOfBytesTransferred,
LPDWORD lpCompletionKey,
LPOVERLAPPED *lpOverlapped,
DWORD dwMilliseconds
);
WINBASEAPI
BOOL
WINAPI
PostQueuedCompletionStatus(
HANDLE CompletionPort,
DWORD dwNumberOfBytesTransferred,
DWORD dwCompletionKey,
LPOVERLAPPED lpOverlapped
);
#define SEM_FAILCRITICALERRORS 0x0001
#define SEM_NOGPFAULTERRORBOX 0x0002
#define SEM_NOALIGNMENTFAULTEXCEPT 0x0004
#define SEM_NOOPENFILEERRORBOX 0x8000
WINBASEAPI
UINT
WINAPI
SetErrorMode(
UINT uMode
);
WINBASEAPI
BOOL
WINAPI
ReadProcessMemory(
HANDLE hProcess,
LPCVOID lpBaseAddress,
LPVOID lpBuffer,
DWORD nSize,
LPDWORD lpNumberOfBytesRead
);
WINBASEAPI
BOOL
WINAPI
WriteProcessMemory(
HANDLE hProcess,
LPVOID lpBaseAddress,
LPVOID lpBuffer,
DWORD nSize,
LPDWORD lpNumberOfBytesWritten
);
#if !defined(MIDL_PASS)
WINBASEAPI
BOOL
WINAPI
GetThreadContext(
HANDLE hThread,
LPCONTEXT lpContext
);
WINBASEAPI
BOOL
WINAPI
SetThreadContext(
HANDLE hThread,
CONST CONTEXT *lpContext
);
#endif
WINBASEAPI
DWORD
WINAPI
SuspendThread(
HANDLE hThread
);
WINBASEAPI
DWORD
WINAPI
ResumeThread(
HANDLE hThread
);
#if(_WIN32_WINNT >= 0x0400)
typedef
VOID
(APIENTRY *PAPCFUNC)(
DWORD dwParam
);
WINBASEAPI
DWORD
WINAPI
QueueUserAPC(
PAPCFUNC pfnAPC,
HANDLE hThread,
DWORD dwData
);
#endif /* _WIN32_WINNT >= 0x0400 */
#if (_WIN32_WINNT >= 0x0400) || (_WIN32_WINDOWS > 0x0400)
WINBASEAPI
BOOL
WINAPI
IsDebuggerPresent(
VOID
);
#endif
WINBASEAPI
VOID
WINAPI
DebugBreak(
VOID
);
WINBASEAPI
BOOL
WINAPI
WaitForDebugEvent(
LPDEBUG_EVENT lpDebugEvent,
DWORD dwMilliseconds
);
WINBASEAPI
BOOL
WINAPI
ContinueDebugEvent(
DWORD dwProcessId,
DWORD dwThreadId,
DWORD dwContinueStatus
);
WINBASEAPI
BOOL
WINAPI
DebugActiveProcess(
DWORD dwProcessId
);
WINBASEAPI
VOID
WINAPI
InitializeCriticalSection(
LPCRITICAL_SECTION lpCriticalSection
);
WINBASEAPI
VOID
WINAPI
EnterCriticalSection(
LPCRITICAL_SECTION lpCriticalSection
);
WINBASEAPI
VOID
WINAPI
LeaveCriticalSection(
LPCRITICAL_SECTION lpCriticalSection
);
#if (_WIN32_WINNT >= 0x0500)
WINBASEAPI
BOOL
WINAPI
InitializeCriticalSectionAndSpinCount(
LPCRITICAL_SECTION lpCriticalSection,
DWORD dwSpinCount
);
WINBASEAPI
DWORD
WINAPI
SetCriticalSectionSpinCount(
LPCRITICAL_SECTION lpCriticalSection,
DWORD dwSpinCount
);
#endif
#if(_WIN32_WINNT >= 0x0400)
WINBASEAPI
BOOL
WINAPI
TryEnterCriticalSection(
LPCRITICAL_SECTION lpCriticalSection
);
#endif /* _WIN32_WINNT >= 0x0400 */
WINBASEAPI
VOID
WINAPI
DeleteCriticalSection(
LPCRITICAL_SECTION lpCriticalSection
);
WINBASEAPI
BOOL
WINAPI
SetEvent(
HANDLE hEvent
);
WINBASEAPI
BOOL
WINAPI
ResetEvent(
HANDLE hEvent
);
WINBASEAPI
BOOL
WINAPI
PulseEvent(
HANDLE hEvent
);
WINBASEAPI
BOOL
WINAPI
ReleaseSemaphore(
HANDLE hSemaphore,
LONG lReleaseCount,
LPLONG lpPreviousCount
);
WINBASEAPI
BOOL
WINAPI
ReleaseMutex(
HANDLE hMutex
);
WINBASEAPI
DWORD
WINAPI
WaitForSingleObject(
HANDLE hHandle,
DWORD dwMilliseconds
);
WINBASEAPI
DWORD
WINAPI
WaitForMultipleObjects(
DWORD nCount,
CONST HANDLE *lpHandles,
BOOL bWaitAll,
DWORD dwMilliseconds
);
WINBASEAPI
VOID
WINAPI
Sleep(
DWORD dwMilliseconds
);
WINBASEAPI
HGLOBAL
WINAPI
LoadResource(
HMODULE hModule,
HRSRC hResInfo
);
WINBASEAPI
DWORD
WINAPI
SizeofResource(
HMODULE hModule,
HRSRC hResInfo
);
WINBASEAPI
ATOM
WINAPI
GlobalDeleteAtom(
ATOM nAtom
);
WINBASEAPI
BOOL
WINAPI
InitAtomTable(
DWORD nSize
);
WINBASEAPI
ATOM
WINAPI
DeleteAtom(
ATOM nAtom
);
WINBASEAPI
UINT
WINAPI
SetHandleCount(
UINT uNumber
);
WINBASEAPI
DWORD
WINAPI
GetLogicalDrives(
VOID
);
WINBASEAPI
BOOL
WINAPI
LockFile(
HANDLE hFile,
DWORD dwFileOffsetLow,
DWORD dwFileOffsetHigh,
DWORD nNumberOfBytesToLockLow,
DWORD nNumberOfBytesToLockHigh
);
WINBASEAPI
BOOL
WINAPI
UnlockFile(
HANDLE hFile,
DWORD dwFileOffsetLow,
DWORD dwFileOffsetHigh,
DWORD nNumberOfBytesToUnlockLow,
DWORD nNumberOfBytesToUnlockHigh
);
WINBASEAPI
BOOL
WINAPI
LockFileEx(
HANDLE hFile,
DWORD dwFlags,
DWORD dwReserved,
DWORD nNumberOfBytesToLockLow,
DWORD nNumberOfBytesToLockHigh,
LPOVERLAPPED lpOverlapped
);
#define LOCKFILE_FAIL_IMMEDIATELY 0x00000001
#define LOCKFILE_EXCLUSIVE_LOCK 0x00000002
WINBASEAPI
BOOL
WINAPI
UnlockFileEx(
HANDLE hFile,
DWORD dwReserved,
DWORD nNumberOfBytesToUnlockLow,
DWORD nNumberOfBytesToUnlockHigh,
LPOVERLAPPED lpOverlapped
);
typedef 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;
} BY_HANDLE_FILE_INFORMATION, *PBY_HANDLE_FILE_INFORMATION, *LPBY_HANDLE_FILE_INFORMATION;
WINBASEAPI
BOOL
WINAPI
GetFileInformationByHandle(
HANDLE hFile,
LPBY_HANDLE_FILE_INFORMATION lpFileInformation
);
WINBASEAPI
DWORD
WINAPI
GetFileType(
HANDLE hFile
);
WINBASEAPI
DWORD
WINAPI
GetFileSize(
HANDLE hFile,
LPDWORD lpFileSizeHigh
);
WINBASEAPI
HANDLE
WINAPI
GetStdHandle(
DWORD nStdHandle
);
WINBASEAPI
BOOL
WINAPI
SetStdHandle(
DWORD nStdHandle,
HANDLE hHandle
);
WINBASEAPI
BOOL
WINAPI
WriteFile(
HANDLE hFile,
LPCVOID lpBuffer,
DWORD nNumberOfBytesToWrite,
LPDWORD lpNumberOfBytesWritten,
LPOVERLAPPED lpOverlapped
);
WINBASEAPI
BOOL
WINAPI
ReadFile(
HANDLE hFile,
LPVOID lpBuffer,
DWORD nNumberOfBytesToRead,
LPDWORD lpNumberOfBytesRead,
LPOVERLAPPED lpOverlapped
);
WINBASEAPI
BOOL
WINAPI
FlushFileBuffers(
HANDLE hFile
);
WINBASEAPI
BOOL
WINAPI
DeviceIoControl(
HANDLE hDevice,
DWORD dwIoControlCode,
LPVOID lpInBuffer,
DWORD nInBufferSize,
LPVOID lpOutBuffer,
DWORD nOutBufferSize,
LPDWORD lpBytesReturned,
LPOVERLAPPED lpOverlapped
);
WINBASEAPI
BOOL
WINAPI
GetDevicePowerState(
HANDLE hFile
);
WINBASEAPI
BOOL
WINAPI
SetEndOfFile(
HANDLE hFile
);
WINBASEAPI
DWORD
WINAPI
SetFilePointer(
HANDLE hFile,
LONG lDistanceToMove,
PLONG lpDistanceToMoveHigh,
DWORD dwMoveMethod
);
WINBASEAPI
BOOL
WINAPI
FindClose(
HANDLE hFindFile
);
WINBASEAPI
BOOL
WINAPI
GetFileTime(
HANDLE hFile,
LPFILETIME lpCreationTime,
LPFILETIME lpLastAccessTime,
LPFILETIME lpLastWriteTime
);
WINBASEAPI
BOOL
WINAPI
SetFileTime(
HANDLE hFile,
CONST FILETIME *lpCreationTime,
CONST FILETIME *lpLastAccessTime,
CONST FILETIME *lpLastWriteTime
);
WINBASEAPI
BOOL
WINAPI
CloseHandle(
HANDLE hObject
);
WINBASEAPI
BOOL
WINAPI
DuplicateHandle(
HANDLE hSourceProcessHandle,
HANDLE hSourceHandle,
HANDLE hTargetProcessHandle,
LPHANDLE lpTargetHandle,
DWORD dwDesiredAccess,
BOOL bInheritHandle,
DWORD dwOptions
);
WINBASEAPI
BOOL
WINAPI
GetHandleInformation(
HANDLE hObject,
LPDWORD lpdwFlags
);
WINBASEAPI
BOOL
WINAPI
SetHandleInformation(
HANDLE hObject,
DWORD dwMask,
DWORD dwFlags
);
#define HANDLE_FLAG_INHERIT 0x00000001
#define HANDLE_FLAG_PROTECT_FROM_CLOSE 0x00000002
#define HINSTANCE_ERROR 32
WINBASEAPI
DWORD
WINAPI
LoadModule(
LPCSTR lpModuleName,
LPVOID lpParameterBlock
);
WINBASEAPI
UINT
WINAPI
WinExec(
LPCSTR lpCmdLine,
UINT uCmdShow
);
WINBASEAPI
BOOL
WINAPI
ClearCommBreak(
HANDLE hFile
);
WINBASEAPI
BOOL
WINAPI
ClearCommError(
HANDLE hFile,
LPDWORD lpErrors,
LPCOMSTAT lpStat
);
WINBASEAPI
BOOL
WINAPI
SetupComm(
HANDLE hFile,
DWORD dwInQueue,
DWORD dwOutQueue
);
WINBASEAPI
BOOL
WINAPI
EscapeCommFunction(
HANDLE hFile,
DWORD dwFunc
);
WINBASEAPI
BOOL
WINAPI
GetCommConfig(
HANDLE hCommDev,
LPCOMMCONFIG lpCC,
LPDWORD lpdwSize
);
WINBASEAPI
BOOL
WINAPI
GetCommMask(
HANDLE hFile,
LPDWORD lpEvtMask
);
WINBASEAPI
BOOL
WINAPI
GetCommProperties(
HANDLE hFile,
LPCOMMPROP lpCommProp
);
WINBASEAPI
BOOL
WINAPI
GetCommModemStatus(
HANDLE hFile,
LPDWORD lpModemStat
);
WINBASEAPI
BOOL
WINAPI
GetCommState(
HANDLE hFile,
LPDCB lpDCB
);
WINBASEAPI
BOOL
WINAPI
GetCommTimeouts(
HANDLE hFile,
LPCOMMTIMEOUTS lpCommTimeouts
);
WINBASEAPI
BOOL
WINAPI
PurgeComm(
HANDLE hFile,
DWORD dwFlags
);
WINBASEAPI
BOOL
WINAPI
SetCommBreak(
HANDLE hFile
);
WINBASEAPI
BOOL
WINAPI
SetCommConfig(
HANDLE hCommDev,
LPCOMMCONFIG lpCC,
DWORD dwSize
);
WINBASEAPI
BOOL
WINAPI
SetCommMask(
HANDLE hFile,
DWORD dwEvtMask
);
WINBASEAPI
BOOL
WINAPI
SetCommState(
HANDLE hFile,
LPDCB lpDCB
);
WINBASEAPI
BOOL
WINAPI
SetCommTimeouts(
HANDLE hFile,
LPCOMMTIMEOUTS lpCommTimeouts
);
WINBASEAPI
BOOL
WINAPI
TransmitCommChar(
HANDLE hFile,
char cChar
);
WINBASEAPI
BOOL
WINAPI
WaitCommEvent(
HANDLE hFile,
LPDWORD lpEvtMask,
LPOVERLAPPED lpOverlapped
);
WINBASEAPI
DWORD
WINAPI
SetTapePosition(
HANDLE hDevice,
DWORD dwPositionMethod,
DWORD dwPartition,
DWORD dwOffsetLow,
DWORD dwOffsetHigh,
BOOL bImmediate
);
WINBASEAPI
DWORD
WINAPI
GetTapePosition(
HANDLE hDevice,
DWORD dwPositionType,
LPDWORD lpdwPartition,
LPDWORD lpdwOffsetLow,
LPDWORD lpdwOffsetHigh
);
WINBASEAPI
DWORD
WINAPI
PrepareTape(
HANDLE hDevice,
DWORD dwOperation,
BOOL bImmediate
);
WINBASEAPI
DWORD
WINAPI
EraseTape(
HANDLE hDevice,
DWORD dwEraseType,
BOOL bImmediate
);
WINBASEAPI
DWORD
WINAPI
CreateTapePartition(
HANDLE hDevice,
DWORD dwPartitionMethod,
DWORD dwCount,
DWORD dwSize
);
WINBASEAPI
DWORD
WINAPI
WriteTapemark(
HANDLE hDevice,
DWORD dwTapemarkType,
DWORD dwTapemarkCount,
BOOL bImmediate
);
WINBASEAPI
DWORD
WINAPI
GetTapeStatus(
HANDLE hDevice
);
WINBASEAPI
DWORD
WINAPI
GetTapeParameters(
HANDLE hDevice,
DWORD dwOperation,
LPDWORD lpdwSize,
LPVOID lpTapeInformation
);
#define GET_TAPE_MEDIA_INFORMATION 0
#define GET_TAPE_DRIVE_INFORMATION 1
WINBASEAPI
DWORD
WINAPI
SetTapeParameters(
HANDLE hDevice,
DWORD dwOperation,
LPVOID lpTapeInformation
);
#define SET_TAPE_MEDIA_INFORMATION 0
#define SET_TAPE_DRIVE_INFORMATION 1
WINBASEAPI
BOOL
WINAPI
Beep(
DWORD dwFreq,
DWORD dwDuration
);
WINBASEAPI
int
WINAPI
MulDiv(
int nNumber,
int nNumerator,
int nDenominator
);
WINBASEAPI
VOID
WINAPI
GetSystemTime(
LPSYSTEMTIME lpSystemTime
);
WINBASEAPI
VOID
WINAPI
GetSystemTimeAsFileTime(
LPFILETIME lpSystemTimeAsFileTime
);
WINBASEAPI
BOOL
WINAPI
SetSystemTime(
CONST SYSTEMTIME *lpSystemTime
);
WINBASEAPI
VOID
WINAPI
GetLocalTime(
LPSYSTEMTIME lpSystemTime
);
WINBASEAPI
BOOL
WINAPI
SetLocalTime(
CONST SYSTEMTIME *lpSystemTime
);
WINBASEAPI
VOID
WINAPI
GetSystemInfo(
LPSYSTEM_INFO lpSystemInfo
);
WINBASEAPI
BOOL
WINAPI
IsProcessorFeaturePresent(
DWORD ProcessorFeature
);
typedef struct _TIME_ZONE_INFORMATION {
LONG Bias;
WCHAR StandardName[ 32 ];
SYSTEMTIME StandardDate;
LONG StandardBias;
WCHAR DaylightName[ 32 ];
SYSTEMTIME DaylightDate;
LONG DaylightBias;
} TIME_ZONE_INFORMATION, *PTIME_ZONE_INFORMATION, *LPTIME_ZONE_INFORMATION;
WINBASEAPI
BOOL
WINAPI
SystemTimeToTzSpecificLocalTime(
LPTIME_ZONE_INFORMATION lpTimeZoneInformation,
LPSYSTEMTIME lpUniversalTime,
LPSYSTEMTIME lpLocalTime
);
WINBASEAPI
DWORD
WINAPI
GetTimeZoneInformation(
LPTIME_ZONE_INFORMATION lpTimeZoneInformation
);
WINBASEAPI
BOOL
WINAPI
SetTimeZoneInformation(
CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation
);
//
// Routines to convert back and forth between system time and file time
//
WINBASEAPI
BOOL
WINAPI
SystemTimeToFileTime(
CONST SYSTEMTIME *lpSystemTime,
LPFILETIME lpFileTime
);
WINBASEAPI
BOOL
WINAPI
FileTimeToLocalFileTime(
CONST FILETIME *lpFileTime,
LPFILETIME lpLocalFileTime
);
WINBASEAPI
BOOL
WINAPI
LocalFileTimeToFileTime(
CONST FILETIME *lpLocalFileTime,
LPFILETIME lpFileTime
);
WINBASEAPI
BOOL
WINAPI
FileTimeToSystemTime(
CONST FILETIME *lpFileTime,
LPSYSTEMTIME lpSystemTime
);
WINBASEAPI
LONG
WINAPI
CompareFileTime(
CONST FILETIME *lpFileTime1,
CONST FILETIME *lpFileTime2
);
WINBASEAPI
BOOL
WINAPI
FileTimeToDosDateTime(
CONST FILETIME *lpFileTime,
LPWORD lpFatDate,
LPWORD lpFatTime
);
WINBASEAPI
BOOL
WINAPI
DosDateTimeToFileTime(
WORD wFatDate,
WORD wFatTime,
LPFILETIME lpFileTime
);
WINBASEAPI
DWORD
WINAPI
GetTickCount(
VOID
);
WINBASEAPI
BOOL
WINAPI
SetSystemTimeAdjustment(
DWORD dwTimeAdjustment,
BOOL bTimeAdjustmentDisabled
);
WINBASEAPI
BOOL
WINAPI
GetSystemTimeAdjustment(
PDWORD lpTimeAdjustment,
PDWORD lpTimeIncrement,
PBOOL lpTimeAdjustmentDisabled
);
#if !defined(MIDL_PASS)
WINBASEAPI
DWORD
WINAPI
FormatMessageA(
DWORD dwFlags,
LPCVOID lpSource,
DWORD dwMessageId,
DWORD dwLanguageId,
LPSTR lpBuffer,
DWORD nSize,
va_list *Arguments
);
WINBASEAPI
DWORD
WINAPI
FormatMessageW(
DWORD dwFlags,
LPCVOID lpSource,
DWORD dwMessageId,
DWORD dwLanguageId,
LPWSTR lpBuffer,
DWORD nSize,
va_list *Arguments
);
#ifdef UNICODE
#define FormatMessage FormatMessageW
#else
#define FormatMessage FormatMessageA
#endif // !UNICODE
#endif
#define FORMAT_MESSAGE_ALLOCATE_BUFFER 0x00000100
#define FORMAT_MESSAGE_IGNORE_INSERTS 0x00000200
#define FORMAT_MESSAGE_FROM_STRING 0x00000400
#define FORMAT_MESSAGE_FROM_HMODULE 0x00000800
#define FORMAT_MESSAGE_FROM_SYSTEM 0x00001000
#define FORMAT_MESSAGE_ARGUMENT_ARRAY 0x00002000
#define FORMAT_MESSAGE_MAX_WIDTH_MASK 0x000000FF
WINBASEAPI
BOOL
WINAPI
CreatePipe(
PHANDLE hReadPipe,
PHANDLE hWritePipe,
LPSECURITY_ATTRIBUTES lpPipeAttributes,
DWORD nSize
);
WINBASEAPI
BOOL
WINAPI
ConnectNamedPipe(
HANDLE hNamedPipe,
LPOVERLAPPED lpOverlapped
);
WINBASEAPI
BOOL
WINAPI
DisconnectNamedPipe(
HANDLE hNamedPipe
);
WINBASEAPI
BOOL
WINAPI
SetNamedPipeHandleState(
HANDLE hNamedPipe,
LPDWORD lpMode,
LPDWORD lpMaxCollectionCount,
LPDWORD lpCollectDataTimeout
);
WINBASEAPI
BOOL
WINAPI
GetNamedPipeInfo(
HANDLE hNamedPipe,
LPDWORD lpFlags,
LPDWORD lpOutBufferSize,
LPDWORD lpInBufferSize,
LPDWORD lpMaxInstances
);
WINBASEAPI
BOOL
WINAPI
PeekNamedPipe(
HANDLE hNamedPipe,
LPVOID lpBuffer,
DWORD nBufferSize,
LPDWORD lpBytesRead,
LPDWORD lpTotalBytesAvail,
LPDWORD lpBytesLeftThisMessage
);
WINBASEAPI
BOOL
WINAPI
TransactNamedPipe(
HANDLE hNamedPipe,
LPVOID lpInBuffer,
DWORD nInBufferSize,
LPVOID lpOutBuffer,
DWORD nOutBufferSize,
LPDWORD lpBytesRead,
LPOVERLAPPED lpOverlapped
);
WINBASEAPI
HANDLE
WINAPI
CreateMailslotA(
LPCSTR lpName,
DWORD nMaxMessageSize,
DWORD lReadTimeout,
LPSECURITY_ATTRIBUTES lpSecurityAttributes
);
WINBASEAPI
HANDLE
WINAPI
CreateMailslotW(
LPCWSTR lpName,
DWORD nMaxMessageSize,
DWORD lReadTimeout,
LPSECURITY_ATTRIBUTES lpSecurityAttributes
);
#ifdef UNICODE
#define CreateMailslot CreateMailslotW
#else
#define CreateMailslot CreateMailslotA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
GetMailslotInfo(
HANDLE hMailslot,
LPDWORD lpMaxMessageSize,
LPDWORD lpNextSize,
LPDWORD lpMessageCount,
LPDWORD lpReadTimeout
);
WINBASEAPI
BOOL
WINAPI
SetMailslotInfo(
HANDLE hMailslot,
DWORD lReadTimeout
);
WINBASEAPI
LPVOID
WINAPI
MapViewOfFile(
HANDLE hFileMappingObject,
DWORD dwDesiredAccess,
DWORD dwFileOffsetHigh,
DWORD dwFileOffsetLow,
DWORD dwNumberOfBytesToMap
);
WINBASEAPI
PVOID64
WINAPI
MapViewOfFileVlm(
HANDLE hFileMappingObject,
DWORD dwDesiredAccess,
DWORDLONG ulOffset,
DWORDLONG ulNumberOfBytesToMap,
PVOID64 lpBaseAddress
);
WINBASEAPI
BOOL
WINAPI
FlushViewOfFile(
LPCVOID lpBaseAddress,
DWORD dwNumberOfBytesToFlush
);
WINBASEAPI
BOOL
WINAPI
UnmapViewOfFile(
LPCVOID lpBaseAddress
);
WINBASEAPI
BOOL
WINAPI
UnmapViewOfFileVlm(
PVOID64 lpBaseAddress
);
//
// File Encryption API
//
WINADVAPI
BOOL
WINAPI
EncryptFileA(
LPCSTR lpFileName
);
WINADVAPI
BOOL
WINAPI
EncryptFileW(
LPCWSTR lpFileName
);
#ifdef UNICODE
#define EncryptFile EncryptFileW
#else
#define EncryptFile EncryptFileA
#endif // !UNICODE
WINADVAPI
BOOL
WINAPI
DecryptFileA(
LPCSTR lpFileName,
DWORD dwReserved
);
WINADVAPI
BOOL
WINAPI
DecryptFileW(
LPCWSTR lpFileName,
DWORD dwReserved
);
#ifdef UNICODE
#define DecryptFile DecryptFileW
#else
#define DecryptFile DecryptFileA
#endif // !UNICODE
//
// Currently defined recovery flags
//
#define EFS_USE_RECOVERY_KEYS (0x1)
typedef
DWORD
(*PFE_EXPORT_FUNC)(
PBYTE pbData,
PVOID pvCallbackContext,
ULONG ulLength
);
typedef
DWORD
(*PFE_IMPORT_FUNC)(
PBYTE pbData,
PVOID pvCallbackContext,
PULONG ulLength
);
//
// OpenRaw flag values
//
#define CREATE_FOR_IMPORT (1)
#define CREATE_FOR_DIR (2)
WINADVAPI
DWORD
WINAPI
OpenRawA(
LPCSTR lpFileName,
ULONG ulFlags,
PVOID * pvContext
);
WINADVAPI
DWORD
WINAPI
OpenRawW(
LPCWSTR lpFileName,
ULONG ulFlags,
PVOID * pvContext
);
#ifdef UNICODE
#define OpenRaw OpenRawW
#else
#define OpenRaw OpenRawA
#endif // !UNICODE
WINADVAPI
DWORD
WINAPI
ReadRaw(
PFE_EXPORT_FUNC pfExportCallback,
PVOID pvCallbackContext,
PVOID pvContext
);
WINADVAPI
DWORD
WINAPI
WriteRaw(
PFE_IMPORT_FUNC pfImportCallback,
PVOID pvCallbackContext,
PVOID pvContext
);
WINADVAPI
VOID
WINAPI
CloseRaw(
PVOID pvContext
);
typedef struct _RECOVERY_AGENT_INFORMATIONA {
DWORD NextEntryOffset;
DWORD AgentNameLength;
CHAR AgentInformation[1];
} RECOVERY_AGENT_INFORMATIONA, *LPRECOVERY_AGENT_INFORMATIONA;
typedef struct _RECOVERY_AGENT_INFORMATIONW {
DWORD NextEntryOffset;
DWORD AgentNameLength;
WCHAR AgentInformation[1];
} RECOVERY_AGENT_INFORMATIONW, *LPRECOVERY_AGENT_INFORMATIONW;
#ifdef UNICODE
typedef RECOVERY_AGENT_INFORMATIONW RECOVERY_AGENT_INFORMATION;
typedef LPRECOVERY_AGENT_INFORMATIONW LPRECOVERY_AGENT_INFORMATION;
#else
typedef RECOVERY_AGENT_INFORMATIONA RECOVERY_AGENT_INFORMATION;
typedef LPRECOVERY_AGENT_INFORMATIONA LPRECOVERY_AGENT_INFORMATION;
#endif // UNICODE
WINADVAPI
DWORD
WINAPI
QueryRecoveryAgentsA(
IN LPCSTR lpFileName,
OUT PDWORD AgentCount,
OUT LPRECOVERY_AGENT_INFORMATIONA * RecoveryAgentInformation
);
WINADVAPI
DWORD
WINAPI
QueryRecoveryAgentsW(
IN LPCWSTR lpFileName,
OUT PDWORD AgentCount,
OUT LPRECOVERY_AGENT_INFORMATIONW * RecoveryAgentInformation
);
#ifdef UNICODE
#define QueryRecoveryAgents QueryRecoveryAgentsW
#else
#define QueryRecoveryAgents QueryRecoveryAgentsA
#endif // !UNICODE
//
// _l Compat Functions
//
WINBASEAPI
int
WINAPI
lstrcmpA(
LPCSTR lpString1,
LPCSTR lpString2
);
WINBASEAPI
int
WINAPI
lstrcmpW(
LPCWSTR lpString1,
LPCWSTR lpString2
);
#ifdef UNICODE
#define lstrcmp lstrcmpW
#else
#define lstrcmp lstrcmpA
#endif // !UNICODE
WINBASEAPI
int
WINAPI
lstrcmpiA(
LPCSTR lpString1,
LPCSTR lpString2
);
WINBASEAPI
int
WINAPI
lstrcmpiW(
LPCWSTR lpString1,
LPCWSTR lpString2
);
#ifdef UNICODE
#define lstrcmpi lstrcmpiW
#else
#define lstrcmpi lstrcmpiA
#endif // !UNICODE
WINBASEAPI
LPSTR
WINAPI
lstrcpynA(
LPSTR lpString1,
LPCSTR lpString2,
int iMaxLength
);
WINBASEAPI
LPWSTR
WINAPI
lstrcpynW(
LPWSTR lpString1,
LPCWSTR lpString2,
int iMaxLength
);
#ifdef UNICODE
#define lstrcpyn lstrcpynW
#else
#define lstrcpyn lstrcpynA
#endif // !UNICODE
WINBASEAPI
LPSTR
WINAPI
lstrcpyA(
LPSTR lpString1,
LPCSTR lpString2
);
WINBASEAPI
LPWSTR
WINAPI
lstrcpyW(
LPWSTR lpString1,
LPCWSTR lpString2
);
#ifdef UNICODE
#define lstrcpy lstrcpyW
#else
#define lstrcpy lstrcpyA
#endif // !UNICODE
WINBASEAPI
LPSTR
WINAPI
lstrcatA(
LPSTR lpString1,
LPCSTR lpString2
);
WINBASEAPI
LPWSTR
WINAPI
lstrcatW(
LPWSTR lpString1,
LPCWSTR lpString2
);
#ifdef UNICODE
#define lstrcat lstrcatW
#else
#define lstrcat lstrcatA
#endif // !UNICODE
WINBASEAPI
int
WINAPI
lstrlenA(
LPCSTR lpString
);
WINBASEAPI
int
WINAPI
lstrlenW(
LPCWSTR lpString
);
#ifdef UNICODE
#define lstrlen lstrlenW
#else
#define lstrlen lstrlenA
#endif // !UNICODE
WINBASEAPI
HFILE
WINAPI
OpenFile(
LPCSTR lpFileName,
LPOFSTRUCT lpReOpenBuff,
UINT uStyle
);
WINBASEAPI
HFILE
WINAPI
_lopen(
LPCSTR lpPathName,
int iReadWrite
);
WINBASEAPI
HFILE
WINAPI
_lcreat(
LPCSTR lpPathName,
int iAttribute
);
WINBASEAPI
UINT
WINAPI
_lread(
HFILE hFile,
LPVOID lpBuffer,
UINT uBytes
);
WINBASEAPI
UINT
WINAPI
_lwrite(
HFILE hFile,
LPCSTR lpBuffer,
UINT uBytes
);
WINBASEAPI
long
WINAPI
_hread(
HFILE hFile,
LPVOID lpBuffer,
long lBytes
);
WINBASEAPI
long
WINAPI
_hwrite(
HFILE hFile,
LPCSTR lpBuffer,
long lBytes
);
WINBASEAPI
HFILE
WINAPI
_lclose(
HFILE hFile
);
WINBASEAPI
LONG
WINAPI
_llseek(
HFILE hFile,
LONG lOffset,
int iOrigin
);
WINADVAPI
BOOL
WINAPI
IsTextUnicode(
CONST LPVOID lpBuffer,
int cb,
LPINT lpi
);
WINBASEAPI
DWORD
WINAPI
TlsAlloc(
VOID
);
#define TLS_OUT_OF_INDEXES (DWORD)0xFFFFFFFF
WINBASEAPI
LPVOID
WINAPI
TlsGetValue(
DWORD dwTlsIndex
);
WINBASEAPI
BOOL
WINAPI
TlsSetValue(
DWORD dwTlsIndex,
LPVOID lpTlsValue
);
WINBASEAPI
BOOL
WINAPI
TlsFree(
DWORD dwTlsIndex
);
typedef
VOID
(WINAPI *LPOVERLAPPED_COMPLETION_ROUTINE)(
DWORD dwErrorCode,
DWORD dwNumberOfBytesTransfered,
LPOVERLAPPED lpOverlapped
);
WINBASEAPI
DWORD
WINAPI
SleepEx(
DWORD dwMilliseconds,
BOOL bAlertable
);
WINBASEAPI
DWORD
WINAPI
WaitForSingleObjectEx(
HANDLE hHandle,
DWORD dwMilliseconds,
BOOL bAlertable
);
WINBASEAPI
DWORD
WINAPI
WaitForMultipleObjectsEx(
DWORD nCount,
CONST HANDLE *lpHandles,
BOOL bWaitAll,
DWORD dwMilliseconds,
BOOL bAlertable
);
#if(_WIN32_WINNT >= 0x0400)
WINBASEAPI
DWORD
WINAPI
SignalObjectAndWait(
HANDLE hObjectToSignal,
HANDLE hObjectToWaitOn,
DWORD dwMilliseconds,
BOOL bAlertable
);
#endif /* _WIN32_WINNT >= 0x0400 */
WINBASEAPI
BOOL
WINAPI
ReadFileEx(
HANDLE hFile,
LPVOID lpBuffer,
DWORD nNumberOfBytesToRead,
LPOVERLAPPED lpOverlapped,
LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
);
WINBASEAPI
BOOL
WINAPI
WriteFileEx(
HANDLE hFile,
LPCVOID lpBuffer,
DWORD nNumberOfBytesToWrite,
LPOVERLAPPED lpOverlapped,
LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
);
WINBASEAPI
BOOL
WINAPI
BackupRead(
HANDLE hFile,
LPBYTE lpBuffer,
DWORD nNumberOfBytesToRead,
LPDWORD lpNumberOfBytesRead,
BOOL bAbort,
BOOL bProcessSecurity,
LPVOID *lpContext
);
WINBASEAPI
BOOL
WINAPI
BackupSeek(
HANDLE hFile,
DWORD dwLowBytesToSeek,
DWORD dwHighBytesToSeek,
LPDWORD lpdwLowByteSeeked,
LPDWORD lpdwHighByteSeeked,
LPVOID *lpContext
);
WINBASEAPI
BOOL
WINAPI
BackupWrite(
HANDLE hFile,
LPBYTE lpBuffer,
DWORD nNumberOfBytesToWrite,
LPDWORD lpNumberOfBytesWritten,
BOOL bAbort,
BOOL bProcessSecurity,
LPVOID *lpContext
);
//
// Stream id structure
//
typedef struct _WIN32_STREAM_ID {
DWORD dwStreamId ;
DWORD dwStreamAttributes ;
LARGE_INTEGER Size ;
DWORD dwStreamNameSize ;
WCHAR cStreamName[ ANYSIZE_ARRAY ] ;
} WIN32_STREAM_ID, *LPWIN32_STREAM_ID ;
//
// Stream Ids
//
#define BACKUP_INVALID 0x00000000
#define BACKUP_DATA 0x00000001
#define BACKUP_EA_DATA 0x00000002
#define BACKUP_SECURITY_DATA 0x00000003
#define BACKUP_ALTERNATE_DATA 0x00000004
#define BACKUP_LINK 0x00000005
#define BACKUP_PROPERTY_DATA 0x00000006
#define BACKUP_OBJECT_ID 0x00000007
#define BACKUP_REPARSE_DATA 0x00000008
#define BACKUP_SPARSE_BLOCK 0x00000009
//
// Stream Attributes
//
#define STREAM_NORMAL_ATTRIBUTE 0x00000000
#define STREAM_MODIFIED_WHEN_READ 0x00000001
#define STREAM_CONTAINS_SECURITY 0x00000002
#define STREAM_CONTAINS_PROPERTIES 0x00000004
#define STREAM_SPARSE_ATTRIBUTE 0x00000008
WINBASEAPI
BOOL
WINAPI
ReadFileScatter(
HANDLE hFile,
FILE_SEGMENT_ELEMENT aSegmentArray[],
DWORD nNumberOfBytesToRead,
LPDWORD lpReserved,
LPOVERLAPPED lpOverlapped
);
WINBASEAPI
BOOL
WINAPI
WriteFileGather(
HANDLE hFile,
FILE_SEGMENT_ELEMENT aSegmentArray[],
DWORD nNumberOfBytesToWrite,
LPDWORD lpReserved,
LPOVERLAPPED lpOverlapped
);
//
// Dual Mode API below this line. Dual Mode Structures also included.
//
#define STARTF_USESHOWWINDOW 0x00000001
#define STARTF_USESIZE 0x00000002
#define STARTF_USEPOSITION 0x00000004
#define STARTF_USECOUNTCHARS 0x00000008
#define STARTF_USEFILLATTRIBUTE 0x00000010
#define STARTF_RUNFULLSCREEN 0x00000020 // ignored for non-x86 platforms
#define STARTF_FORCEONFEEDBACK 0x00000040
#define STARTF_FORCEOFFFEEDBACK 0x00000080
#define STARTF_USESTDHANDLES 0x00000100
#if(WINVER >= 0x0400)
#define STARTF_USEHOTKEY 0x00000200
#endif /* WINVER >= 0x0400 */
typedef struct _STARTUPINFOA {
DWORD cb;
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;
LPBYTE lpReserved2;
HANDLE hStdInput;
HANDLE hStdOutput;
HANDLE hStdError;
} STARTUPINFOA, *LPSTARTUPINFOA;
typedef struct _STARTUPINFOW {
DWORD cb;
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;
LPBYTE lpReserved2;
HANDLE hStdInput;
HANDLE hStdOutput;
HANDLE hStdError;
} STARTUPINFOW, *LPSTARTUPINFOW;
#ifdef UNICODE
typedef STARTUPINFOW STARTUPINFO;
typedef LPSTARTUPINFOW LPSTARTUPINFO;
#else
typedef STARTUPINFOA STARTUPINFO;
typedef LPSTARTUPINFOA LPSTARTUPINFO;
#endif // UNICODE
#define SHUTDOWN_NORETRY 0x00000001
typedef struct _WIN32_FIND_DATAA {
DWORD dwFileAttributes;
FILETIME ftCreationTime;
FILETIME ftLastAccessTime;
FILETIME ftLastWriteTime;
DWORD nFileSizeHigh;
DWORD nFileSizeLow;
DWORD dwReserved0;
DWORD dwReserved1;
CHAR cFileName[ MAX_PATH ];
CHAR cAlternateFileName[ 14 ];
#ifdef _MAC
DWORD dwFileType;
DWORD dwCreatorType;
WORD wFinderFlags;
#endif
} WIN32_FIND_DATAA, *PWIN32_FIND_DATAA, *LPWIN32_FIND_DATAA;
typedef struct _WIN32_FIND_DATAW {
DWORD dwFileAttributes;
FILETIME ftCreationTime;
FILETIME ftLastAccessTime;
FILETIME ftLastWriteTime;
DWORD nFileSizeHigh;
DWORD nFileSizeLow;
DWORD dwReserved0;
DWORD dwReserved1;
WCHAR cFileName[ MAX_PATH ];
WCHAR cAlternateFileName[ 14 ];
#ifdef _MAC
DWORD dwFileType;
DWORD dwCreatorType;
WORD wFinderFlags;
#endif
} WIN32_FIND_DATAW, *PWIN32_FIND_DATAW, *LPWIN32_FIND_DATAW;
#ifdef UNICODE
typedef WIN32_FIND_DATAW WIN32_FIND_DATA;
typedef PWIN32_FIND_DATAW PWIN32_FIND_DATA;
typedef LPWIN32_FIND_DATAW LPWIN32_FIND_DATA;
#else
typedef WIN32_FIND_DATAA WIN32_FIND_DATA;
typedef PWIN32_FIND_DATAA PWIN32_FIND_DATA;
typedef LPWIN32_FIND_DATAA LPWIN32_FIND_DATA;
#endif // UNICODE
typedef struct _WIN32_FILE_ATTRIBUTE_DATA {
DWORD dwFileAttributes;
FILETIME ftCreationTime;
FILETIME ftLastAccessTime;
FILETIME ftLastWriteTime;
DWORD nFileSizeHigh;
DWORD nFileSizeLow;
} WIN32_FILE_ATTRIBUTE_DATA, *LPWIN32_FILE_ATTRIBUTE_DATA;
WINBASEAPI
HANDLE
WINAPI
CreateMutexA(
LPSECURITY_ATTRIBUTES lpMutexAttributes,
BOOL bInitialOwner,
LPCSTR lpName
);
WINBASEAPI
HANDLE
WINAPI
CreateMutexW(
LPSECURITY_ATTRIBUTES lpMutexAttributes,
BOOL bInitialOwner,
LPCWSTR lpName
);
#ifdef UNICODE
#define CreateMutex CreateMutexW
#else
#define CreateMutex CreateMutexA
#endif // !UNICODE
WINBASEAPI
HANDLE
WINAPI
OpenMutexA(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
LPCSTR lpName
);
WINBASEAPI
HANDLE
WINAPI
OpenMutexW(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
LPCWSTR lpName
);
#ifdef UNICODE
#define OpenMutex OpenMutexW
#else
#define OpenMutex OpenMutexA
#endif // !UNICODE
WINBASEAPI
HANDLE
WINAPI
CreateEventA(
LPSECURITY_ATTRIBUTES lpEventAttributes,
BOOL bManualReset,
BOOL bInitialState,
LPCSTR lpName
);
WINBASEAPI
HANDLE
WINAPI
CreateEventW(
LPSECURITY_ATTRIBUTES lpEventAttributes,
BOOL bManualReset,
BOOL bInitialState,
LPCWSTR lpName
);
#ifdef UNICODE
#define CreateEvent CreateEventW
#else
#define CreateEvent CreateEventA
#endif // !UNICODE
WINBASEAPI
HANDLE
WINAPI
OpenEventA(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
LPCSTR lpName
);
WINBASEAPI
HANDLE
WINAPI
OpenEventW(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
LPCWSTR lpName
);
#ifdef UNICODE
#define OpenEvent OpenEventW
#else
#define OpenEvent OpenEventA
#endif // !UNICODE
WINBASEAPI
HANDLE
WINAPI
CreateSemaphoreA(
LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
LONG lInitialCount,
LONG lMaximumCount,
LPCSTR lpName
);
WINBASEAPI
HANDLE
WINAPI
CreateSemaphoreW(
LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
LONG lInitialCount,
LONG lMaximumCount,
LPCWSTR lpName
);
#ifdef UNICODE
#define CreateSemaphore CreateSemaphoreW
#else
#define CreateSemaphore CreateSemaphoreA
#endif // !UNICODE
WINBASEAPI
HANDLE
WINAPI
OpenSemaphoreA(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
LPCSTR lpName
);
WINBASEAPI
HANDLE
WINAPI
OpenSemaphoreW(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
LPCWSTR lpName
);
#ifdef UNICODE
#define OpenSemaphore OpenSemaphoreW
#else
#define OpenSemaphore OpenSemaphoreA
#endif // !UNICODE
#if (_WIN32_WINNT >= 0x0400) || (_WIN32_WINDOWS > 0x0400)
typedef
VOID
(APIENTRY *PTIMERAPCROUTINE)(
LPVOID lpArgToCompletionRoutine,
DWORD dwTimerLowValue,
DWORD dwTimerHighValue
);
WINBASEAPI
HANDLE
WINAPI
CreateWaitableTimerA(
LPSECURITY_ATTRIBUTES lpTimerAttributes,
BOOL bManualReset,
LPCSTR lpTimerName
);
WINBASEAPI
HANDLE
WINAPI
CreateWaitableTimerW(
LPSECURITY_ATTRIBUTES lpTimerAttributes,
BOOL bManualReset,
LPCWSTR lpTimerName
);
#ifdef UNICODE
#define CreateWaitableTimer CreateWaitableTimerW
#else
#define CreateWaitableTimer CreateWaitableTimerA
#endif // !UNICODE
WINBASEAPI
HANDLE
WINAPI
OpenWaitableTimerA(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
LPCSTR lpTimerName
);
WINBASEAPI
HANDLE
WINAPI
OpenWaitableTimerW(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
LPCWSTR lpTimerName
);
#ifdef UNICODE
#define OpenWaitableTimer OpenWaitableTimerW
#else
#define OpenWaitableTimer OpenWaitableTimerA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
SetWaitableTimer(
HANDLE hTimer,
const LARGE_INTEGER *lpDueTime,
LONG lPeriod,
PTIMERAPCROUTINE pfnCompletionRoutine,
LPVOID lpArgToCompletionRoutine,
BOOL fResume
);
WINBASEAPI
BOOL
WINAPI
CancelWaitableTimer(
HANDLE hTimer
);
#endif /* (_WIN32_WINNT >= 0x0400) || (_WIN32_WINDOWS > 0x0400) */
WINBASEAPI
HANDLE
WINAPI
CreateFileMappingA(
HANDLE hFile,
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
DWORD flProtect,
DWORD dwMaximumSizeHigh,
DWORD dwMaximumSizeLow,
LPCSTR lpName
);
WINBASEAPI
HANDLE
WINAPI
CreateFileMappingW(
HANDLE hFile,
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
DWORD flProtect,
DWORD dwMaximumSizeHigh,
DWORD dwMaximumSizeLow,
LPCWSTR lpName
);
#ifdef UNICODE
#define CreateFileMapping CreateFileMappingW
#else
#define CreateFileMapping CreateFileMappingA
#endif // !UNICODE
WINBASEAPI
HANDLE
WINAPI
OpenFileMappingA(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
LPCSTR lpName
);
WINBASEAPI
HANDLE
WINAPI
OpenFileMappingW(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
LPCWSTR lpName
);
#ifdef UNICODE
#define OpenFileMapping OpenFileMappingW
#else
#define OpenFileMapping OpenFileMappingA
#endif // !UNICODE
WINBASEAPI
DWORD
WINAPI
GetLogicalDriveStringsA(
DWORD nBufferLength,
LPSTR lpBuffer
);
WINBASEAPI
DWORD
WINAPI
GetLogicalDriveStringsW(
DWORD nBufferLength,
LPWSTR lpBuffer
);
#ifdef UNICODE
#define GetLogicalDriveStrings GetLogicalDriveStringsW
#else
#define GetLogicalDriveStrings GetLogicalDriveStringsA
#endif // !UNICODE
WINBASEAPI
HMODULE
WINAPI
LoadLibraryA(
LPCSTR lpLibFileName
);
WINBASEAPI
HMODULE
WINAPI
LoadLibraryW(
LPCWSTR lpLibFileName
);
#ifdef UNICODE
#define LoadLibrary LoadLibraryW
#else
#define LoadLibrary LoadLibraryA
#endif // !UNICODE
WINBASEAPI
HMODULE
WINAPI
LoadLibraryExA(
LPCSTR lpLibFileName,
HANDLE hFile,
DWORD dwFlags
);
WINBASEAPI
HMODULE
WINAPI
LoadLibraryExW(
LPCWSTR lpLibFileName,
HANDLE hFile,
DWORD dwFlags
);
#ifdef UNICODE
#define LoadLibraryEx LoadLibraryExW
#else
#define LoadLibraryEx LoadLibraryExA
#endif // !UNICODE
#define DONT_RESOLVE_DLL_REFERENCES 0x00000001
#define LOAD_LIBRARY_AS_DATAFILE 0x00000002
#define LOAD_WITH_ALTERED_SEARCH_PATH 0x00000008
WINBASEAPI
DWORD
WINAPI
GetModuleFileNameA(
HMODULE hModule,
LPSTR lpFilename,
DWORD nSize
);
WINBASEAPI
DWORD
WINAPI
GetModuleFileNameW(
HMODULE hModule,
LPWSTR lpFilename,
DWORD nSize
);
#ifdef UNICODE
#define GetModuleFileName GetModuleFileNameW
#else
#define GetModuleFileName GetModuleFileNameA
#endif // !UNICODE
WINBASEAPI
HMODULE
WINAPI
GetModuleHandleA(
LPCSTR lpModuleName
);
WINBASEAPI
HMODULE
WINAPI
GetModuleHandleW(
LPCWSTR lpModuleName
);
#ifdef UNICODE
#define GetModuleHandle GetModuleHandleW
#else
#define GetModuleHandle GetModuleHandleA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
CreateProcessA(
LPCSTR lpApplicationName,
LPSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCSTR lpCurrentDirectory,
LPSTARTUPINFOA lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
);
WINBASEAPI
BOOL
WINAPI
CreateProcessW(
LPCWSTR lpApplicationName,
LPWSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCWSTR lpCurrentDirectory,
LPSTARTUPINFOW lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
);
#ifdef UNICODE
#define CreateProcess CreateProcessW
#else
#define CreateProcess CreateProcessA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
SetProcessShutdownParameters(
DWORD dwLevel,
DWORD dwFlags
);
WINBASEAPI
BOOL
WINAPI
GetProcessShutdownParameters(
LPDWORD lpdwLevel,
LPDWORD lpdwFlags
);
WINBASEAPI
DWORD
WINAPI
GetProcessVersion(
DWORD ProcessId
);
WINBASEAPI
VOID
WINAPI
FatalAppExitA(
UINT uAction,
LPCSTR lpMessageText
);
WINBASEAPI
VOID
WINAPI
FatalAppExitW(
UINT uAction,
LPCWSTR lpMessageText
);
#ifdef UNICODE
#define FatalAppExit FatalAppExitW
#else
#define FatalAppExit FatalAppExitA
#endif // !UNICODE
WINBASEAPI
VOID
WINAPI
GetStartupInfoA(
LPSTARTUPINFOA lpStartupInfo
);
WINBASEAPI
VOID
WINAPI
GetStartupInfoW(
LPSTARTUPINFOW lpStartupInfo
);
#ifdef UNICODE
#define GetStartupInfo GetStartupInfoW
#else
#define GetStartupInfo GetStartupInfoA
#endif // !UNICODE
WINBASEAPI
LPSTR
WINAPI
GetCommandLineA(
VOID
);
WINBASEAPI
LPWSTR
WINAPI
GetCommandLineW(
VOID
);
#ifdef UNICODE
#define GetCommandLine GetCommandLineW
#else
#define GetCommandLine GetCommandLineA
#endif // !UNICODE
WINBASEAPI
DWORD
WINAPI
GetEnvironmentVariableA(
LPCSTR lpName,
LPSTR lpBuffer,
DWORD nSize
);
WINBASEAPI
DWORD
WINAPI
GetEnvironmentVariableW(
LPCWSTR lpName,
LPWSTR lpBuffer,
DWORD nSize
);
#ifdef UNICODE
#define GetEnvironmentVariable GetEnvironmentVariableW
#else
#define GetEnvironmentVariable GetEnvironmentVariableA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
SetEnvironmentVariableA(
LPCSTR lpName,
LPCSTR lpValue
);
WINBASEAPI
BOOL
WINAPI
SetEnvironmentVariableW(
LPCWSTR lpName,
LPCWSTR lpValue
);
#ifdef UNICODE
#define SetEnvironmentVariable SetEnvironmentVariableW
#else
#define SetEnvironmentVariable SetEnvironmentVariableA
#endif // !UNICODE
WINBASEAPI
DWORD
WINAPI
ExpandEnvironmentStringsA(
LPCSTR lpSrc,
LPSTR lpDst,
DWORD nSize
);
WINBASEAPI
DWORD
WINAPI
ExpandEnvironmentStringsW(
LPCWSTR lpSrc,
LPWSTR lpDst,
DWORD nSize
);
#ifdef UNICODE
#define ExpandEnvironmentStrings ExpandEnvironmentStringsW
#else
#define ExpandEnvironmentStrings ExpandEnvironmentStringsA
#endif // !UNICODE
WINBASEAPI
VOID
WINAPI
OutputDebugStringA(
LPCSTR lpOutputString
);
WINBASEAPI
VOID
WINAPI
OutputDebugStringW(
LPCWSTR lpOutputString
);
#ifdef UNICODE
#define OutputDebugString OutputDebugStringW
#else
#define OutputDebugString OutputDebugStringA
#endif // !UNICODE
WINBASEAPI
HRSRC
WINAPI
FindResourceA(
HMODULE hModule,
LPCSTR lpName,
LPCSTR lpType
);
WINBASEAPI
HRSRC
WINAPI
FindResourceW(
HMODULE hModule,
LPCWSTR lpName,
LPCWSTR lpType
);
#ifdef UNICODE
#define FindResource FindResourceW
#else
#define FindResource FindResourceA
#endif // !UNICODE
WINBASEAPI
HRSRC
WINAPI
FindResourceExA(
HMODULE hModule,
LPCSTR lpType,
LPCSTR lpName,
WORD wLanguage
);
WINBASEAPI
HRSRC
WINAPI
FindResourceExW(
HMODULE hModule,
LPCWSTR lpType,
LPCWSTR lpName,
WORD wLanguage
);
#ifdef UNICODE
#define FindResourceEx FindResourceExW
#else
#define FindResourceEx FindResourceExA
#endif // !UNICODE
#ifdef STRICT
typedef BOOL (CALLBACK* ENUMRESTYPEPROC)(HMODULE hModule, LPTSTR lpType,
LONG lParam);
typedef BOOL (CALLBACK* ENUMRESNAMEPROC)(HMODULE hModule, LPCTSTR lpType,
LPTSTR lpName, LONG lParam);
typedef BOOL (CALLBACK* ENUMRESLANGPROC)(HMODULE hModule, LPCTSTR lpType,
LPCTSTR lpName, WORD wLanguage, LONG lParam);
#else
typedef FARPROC ENUMRESTYPEPROC;
typedef FARPROC ENUMRESNAMEPROC;
typedef FARPROC ENUMRESLANGPROC;
#endif
WINBASEAPI
BOOL
WINAPI
EnumResourceTypesA(
HMODULE hModule,
ENUMRESTYPEPROC lpEnumFunc,
LONG lParam
);
WINBASEAPI
BOOL
WINAPI
EnumResourceTypesW(
HMODULE hModule,
ENUMRESTYPEPROC lpEnumFunc,
LONG lParam
);
#ifdef UNICODE
#define EnumResourceTypes EnumResourceTypesW
#else
#define EnumResourceTypes EnumResourceTypesA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
EnumResourceNamesA(
HMODULE hModule,
LPCSTR lpType,
ENUMRESNAMEPROC lpEnumFunc,
LONG lParam
);
WINBASEAPI
BOOL
WINAPI
EnumResourceNamesW(
HMODULE hModule,
LPCWSTR lpType,
ENUMRESNAMEPROC lpEnumFunc,
LONG lParam
);
#ifdef UNICODE
#define EnumResourceNames EnumResourceNamesW
#else
#define EnumResourceNames EnumResourceNamesA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
EnumResourceLanguagesA(
HMODULE hModule,
LPCSTR lpType,
LPCSTR lpName,
ENUMRESLANGPROC lpEnumFunc,
LONG lParam
);
WINBASEAPI
BOOL
WINAPI
EnumResourceLanguagesW(
HMODULE hModule,
LPCWSTR lpType,
LPCWSTR lpName,
ENUMRESLANGPROC lpEnumFunc,
LONG lParam
);
#ifdef UNICODE
#define EnumResourceLanguages EnumResourceLanguagesW
#else
#define EnumResourceLanguages EnumResourceLanguagesA
#endif // !UNICODE
WINBASEAPI
HANDLE
WINAPI
BeginUpdateResourceA(
LPCSTR pFileName,
BOOL bDeleteExistingResources
);
WINBASEAPI
HANDLE
WINAPI
BeginUpdateResourceW(
LPCWSTR pFileName,
BOOL bDeleteExistingResources
);
#ifdef UNICODE
#define BeginUpdateResource BeginUpdateResourceW
#else
#define BeginUpdateResource BeginUpdateResourceA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
UpdateResourceA(
HANDLE hUpdate,
LPCSTR lpType,
LPCSTR lpName,
WORD wLanguage,
LPVOID lpData,
DWORD cbData
);
WINBASEAPI
BOOL
WINAPI
UpdateResourceW(
HANDLE hUpdate,
LPCWSTR lpType,
LPCWSTR lpName,
WORD wLanguage,
LPVOID lpData,
DWORD cbData
);
#ifdef UNICODE
#define UpdateResource UpdateResourceW
#else
#define UpdateResource UpdateResourceA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
EndUpdateResourceA(
HANDLE hUpdate,
BOOL fDiscard
);
WINBASEAPI
BOOL
WINAPI
EndUpdateResourceW(
HANDLE hUpdate,
BOOL fDiscard
);
#ifdef UNICODE
#define EndUpdateResource EndUpdateResourceW
#else
#define EndUpdateResource EndUpdateResourceA
#endif // !UNICODE
WINBASEAPI
ATOM
WINAPI
GlobalAddAtomA(
LPCSTR lpString
);
WINBASEAPI
ATOM
WINAPI
GlobalAddAtomW(
LPCWSTR lpString
);
#ifdef UNICODE
#define GlobalAddAtom GlobalAddAtomW
#else
#define GlobalAddAtom GlobalAddAtomA
#endif // !UNICODE
WINBASEAPI
ATOM
WINAPI
GlobalFindAtomA(
LPCSTR lpString
);
WINBASEAPI
ATOM
WINAPI
GlobalFindAtomW(
LPCWSTR lpString
);
#ifdef UNICODE
#define GlobalFindAtom GlobalFindAtomW
#else
#define GlobalFindAtom GlobalFindAtomA
#endif // !UNICODE
WINBASEAPI
UINT
WINAPI
GlobalGetAtomNameA(
ATOM nAtom,
LPSTR lpBuffer,
int nSize
);
WINBASEAPI
UINT
WINAPI
GlobalGetAtomNameW(
ATOM nAtom,
LPWSTR lpBuffer,
int nSize
);
#ifdef UNICODE
#define GlobalGetAtomName GlobalGetAtomNameW
#else
#define GlobalGetAtomName GlobalGetAtomNameA
#endif // !UNICODE
WINBASEAPI
ATOM
WINAPI
AddAtomA(
LPCSTR lpString
);
WINBASEAPI
ATOM
WINAPI
AddAtomW(
LPCWSTR lpString
);
#ifdef UNICODE
#define AddAtom AddAtomW
#else
#define AddAtom AddAtomA
#endif // !UNICODE
WINBASEAPI
ATOM
WINAPI
FindAtomA(
LPCSTR lpString
);
WINBASEAPI
ATOM
WINAPI
FindAtomW(
LPCWSTR lpString
);
#ifdef UNICODE
#define FindAtom FindAtomW
#else
#define FindAtom FindAtomA
#endif // !UNICODE
WINBASEAPI
UINT
WINAPI
GetAtomNameA(
ATOM nAtom,
LPSTR lpBuffer,
int nSize
);
WINBASEAPI
UINT
WINAPI
GetAtomNameW(
ATOM nAtom,
LPWSTR lpBuffer,
int nSize
);
#ifdef UNICODE
#define GetAtomName GetAtomNameW
#else
#define GetAtomName GetAtomNameA
#endif // !UNICODE
WINBASEAPI
UINT
WINAPI
GetProfileIntA(
LPCSTR lpAppName,
LPCSTR lpKeyName,
INT nDefault
);
WINBASEAPI
UINT
WINAPI
GetProfileIntW(
LPCWSTR lpAppName,
LPCWSTR lpKeyName,
INT nDefault
);
#ifdef UNICODE
#define GetProfileInt GetProfileIntW
#else
#define GetProfileInt GetProfileIntA
#endif // !UNICODE
WINBASEAPI
DWORD
WINAPI
GetProfileStringA(
LPCSTR lpAppName,
LPCSTR lpKeyName,
LPCSTR lpDefault,
LPSTR lpReturnedString,
DWORD nSize
);
WINBASEAPI
DWORD
WINAPI
GetProfileStringW(
LPCWSTR lpAppName,
LPCWSTR lpKeyName,
LPCWSTR lpDefault,
LPWSTR lpReturnedString,
DWORD nSize
);
#ifdef UNICODE
#define GetProfileString GetProfileStringW
#else
#define GetProfileString GetProfileStringA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
WriteProfileStringA(
LPCSTR lpAppName,
LPCSTR lpKeyName,
LPCSTR lpString
);
WINBASEAPI
BOOL
WINAPI
WriteProfileStringW(
LPCWSTR lpAppName,
LPCWSTR lpKeyName,
LPCWSTR lpString
);
#ifdef UNICODE
#define WriteProfileString WriteProfileStringW
#else
#define WriteProfileString WriteProfileStringA
#endif // !UNICODE
WINBASEAPI
DWORD
WINAPI
GetProfileSectionA(
LPCSTR lpAppName,
LPSTR lpReturnedString,
DWORD nSize
);
WINBASEAPI
DWORD
WINAPI
GetProfileSectionW(
LPCWSTR lpAppName,
LPWSTR lpReturnedString,
DWORD nSize
);
#ifdef UNICODE
#define GetProfileSection GetProfileSectionW
#else
#define GetProfileSection GetProfileSectionA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
WriteProfileSectionA(
LPCSTR lpAppName,
LPCSTR lpString
);
WINBASEAPI
BOOL
WINAPI
WriteProfileSectionW(
LPCWSTR lpAppName,
LPCWSTR lpString
);
#ifdef UNICODE
#define WriteProfileSection WriteProfileSectionW
#else
#define WriteProfileSection WriteProfileSectionA
#endif // !UNICODE
WINBASEAPI
UINT
WINAPI
GetPrivateProfileIntA(
LPCSTR lpAppName,
LPCSTR lpKeyName,
INT nDefault,
LPCSTR lpFileName
);
WINBASEAPI
UINT
WINAPI
GetPrivateProfileIntW(
LPCWSTR lpAppName,
LPCWSTR lpKeyName,
INT nDefault,
LPCWSTR lpFileName
);
#ifdef UNICODE
#define GetPrivateProfileInt GetPrivateProfileIntW
#else
#define GetPrivateProfileInt GetPrivateProfileIntA
#endif // !UNICODE
WINBASEAPI
DWORD
WINAPI
GetPrivateProfileStringA(
LPCSTR lpAppName,
LPCSTR lpKeyName,
LPCSTR lpDefault,
LPSTR lpReturnedString,
DWORD nSize,
LPCSTR lpFileName
);
WINBASEAPI
DWORD
WINAPI
GetPrivateProfileStringW(
LPCWSTR lpAppName,
LPCWSTR lpKeyName,
LPCWSTR lpDefault,
LPWSTR lpReturnedString,
DWORD nSize,
LPCWSTR lpFileName
);
#ifdef UNICODE
#define GetPrivateProfileString GetPrivateProfileStringW
#else
#define GetPrivateProfileString GetPrivateProfileStringA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
WritePrivateProfileStringA(
LPCSTR lpAppName,
LPCSTR lpKeyName,
LPCSTR lpString,
LPCSTR lpFileName
);
WINBASEAPI
BOOL
WINAPI
WritePrivateProfileStringW(
LPCWSTR lpAppName,
LPCWSTR lpKeyName,
LPCWSTR lpString,
LPCWSTR lpFileName
);
#ifdef UNICODE
#define WritePrivateProfileString WritePrivateProfileStringW
#else
#define WritePrivateProfileString WritePrivateProfileStringA
#endif // !UNICODE
WINBASEAPI
DWORD
WINAPI
GetPrivateProfileSectionA(
LPCSTR lpAppName,
LPSTR lpReturnedString,
DWORD nSize,
LPCSTR lpFileName
);
WINBASEAPI
DWORD
WINAPI
GetPrivateProfileSectionW(
LPCWSTR lpAppName,
LPWSTR lpReturnedString,
DWORD nSize,
LPCWSTR lpFileName
);
#ifdef UNICODE
#define GetPrivateProfileSection GetPrivateProfileSectionW
#else
#define GetPrivateProfileSection GetPrivateProfileSectionA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
WritePrivateProfileSectionA(
LPCSTR lpAppName,
LPCSTR lpString,
LPCSTR lpFileName
);
WINBASEAPI
BOOL
WINAPI
WritePrivateProfileSectionW(
LPCWSTR lpAppName,
LPCWSTR lpString,
LPCWSTR lpFileName
);
#ifdef UNICODE
#define WritePrivateProfileSection WritePrivateProfileSectionW
#else
#define WritePrivateProfileSection WritePrivateProfileSectionA
#endif // !UNICODE
WINBASEAPI
DWORD
WINAPI
GetPrivateProfileSectionNamesA(
LPSTR lpszReturnBuffer,
DWORD nSize,
LPCSTR lpFileName
);
WINBASEAPI
DWORD
WINAPI
GetPrivateProfileSectionNamesW(
LPWSTR lpszReturnBuffer,
DWORD nSize,
LPCWSTR lpFileName
);
#ifdef UNICODE
#define GetPrivateProfileSectionNames GetPrivateProfileSectionNamesW
#else
#define GetPrivateProfileSectionNames GetPrivateProfileSectionNamesA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
GetPrivateProfileStructA(
LPCSTR lpszSection,
LPCSTR lpszKey,
LPVOID lpStruct,
UINT uSizeStruct,
LPCSTR szFile
);
WINBASEAPI
BOOL
WINAPI
GetPrivateProfileStructW(
LPCWSTR lpszSection,
LPCWSTR lpszKey,
LPVOID lpStruct,
UINT uSizeStruct,
LPCWSTR szFile
);
#ifdef UNICODE
#define GetPrivateProfileStruct GetPrivateProfileStructW
#else
#define GetPrivateProfileStruct GetPrivateProfileStructA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
WritePrivateProfileStructA(
LPCSTR lpszSection,
LPCSTR lpszKey,
LPVOID lpStruct,
UINT uSizeStruct,
LPCSTR szFile
);
WINBASEAPI
BOOL
WINAPI
WritePrivateProfileStructW(
LPCWSTR lpszSection,
LPCWSTR lpszKey,
LPVOID lpStruct,
UINT uSizeStruct,
LPCWSTR szFile
);
#ifdef UNICODE
#define WritePrivateProfileStruct WritePrivateProfileStructW
#else
#define WritePrivateProfileStruct WritePrivateProfileStructA
#endif // !UNICODE
WINBASEAPI
UINT
WINAPI
GetDriveTypeA(
LPCSTR lpRootPathName
);
WINBASEAPI
UINT
WINAPI
GetDriveTypeW(
LPCWSTR lpRootPathName
);
#ifdef UNICODE
#define GetDriveType GetDriveTypeW
#else
#define GetDriveType GetDriveTypeA
#endif // !UNICODE
WINBASEAPI
UINT
WINAPI
GetSystemDirectoryA(
LPSTR lpBuffer,
UINT uSize
);
WINBASEAPI
UINT
WINAPI
GetSystemDirectoryW(
LPWSTR lpBuffer,
UINT uSize
);
#ifdef UNICODE
#define GetSystemDirectory GetSystemDirectoryW
#else
#define GetSystemDirectory GetSystemDirectoryA
#endif // !UNICODE
WINBASEAPI
DWORD
WINAPI
GetTempPathA(
DWORD nBufferLength,
LPSTR lpBuffer
);
WINBASEAPI
DWORD
WINAPI
GetTempPathW(
DWORD nBufferLength,
LPWSTR lpBuffer
);
#ifdef UNICODE
#define GetTempPath GetTempPathW
#else
#define GetTempPath GetTempPathA
#endif // !UNICODE
WINBASEAPI
UINT
WINAPI
GetTempFileNameA(
LPCSTR lpPathName,
LPCSTR lpPrefixString,
UINT uUnique,
LPSTR lpTempFileName
);
WINBASEAPI
UINT
WINAPI
GetTempFileNameW(
LPCWSTR lpPathName,
LPCWSTR lpPrefixString,
UINT uUnique,
LPWSTR lpTempFileName
);
#ifdef UNICODE
#define GetTempFileName GetTempFileNameW
#else
#define GetTempFileName GetTempFileNameA
#endif // !UNICODE
WINBASEAPI
UINT
WINAPI
GetWindowsDirectoryA(
LPSTR lpBuffer,
UINT uSize
);
WINBASEAPI
UINT
WINAPI
GetWindowsDirectoryW(
LPWSTR lpBuffer,
UINT uSize
);
#ifdef UNICODE
#define GetWindowsDirectory GetWindowsDirectoryW
#else
#define GetWindowsDirectory GetWindowsDirectoryA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
SetCurrentDirectoryA(
LPCSTR lpPathName
);
WINBASEAPI
BOOL
WINAPI
SetCurrentDirectoryW(
LPCWSTR lpPathName
);
#ifdef UNICODE
#define SetCurrentDirectory SetCurrentDirectoryW
#else
#define SetCurrentDirectory SetCurrentDirectoryA
#endif // !UNICODE
WINBASEAPI
DWORD
WINAPI
GetCurrentDirectoryA(
DWORD nBufferLength,
LPSTR lpBuffer
);
WINBASEAPI
DWORD
WINAPI
GetCurrentDirectoryW(
DWORD nBufferLength,
LPWSTR lpBuffer
);
#ifdef UNICODE
#define GetCurrentDirectory GetCurrentDirectoryW
#else
#define GetCurrentDirectory GetCurrentDirectoryA
#endif // !UNICODE
WINBASEAPI
BOOL
WINAPI
GetDiskFreeSpaceA(
LPCSTR lpRootPathName,
LPDWORD lpSectorsPerCluster,
LPDWORD lpBytesPerSector,
LPDWORD lpNumberOfFreeClusters,
LPDWORD lpTotalNumberOfClusters
);
WINBASEAPI
BOOL
WINAPI
GetDiskFreeSpaceW(
LPCWSTR lpRootPathName,
LPDWORD lpSectorsPerCluster,
LPDWORD lpBytesPerSector,
LPDWORD lpNumberOfFreeClusters,
LPDWORD lpTota