Headers diff for kernel32.dll between 6.0.6002.18005-Windows 6.0 and 6.1.7601.23418-Windows 7.0 versions



 winbase.h (6.0.6002.18005-Windows 6.0)   winbase.h (6.1.7601.23418-Windows 7.0) 
skipping to change at line 164 skipping to change at line 164
#define COPY_FILE_RESTARTABLE 0x00000002 #define COPY_FILE_RESTARTABLE 0x00000002
#define COPY_FILE_OPEN_SOURCE_FOR_WRITE 0x00000004 #define COPY_FILE_OPEN_SOURCE_FOR_WRITE 0x00000004
#define COPY_FILE_ALLOW_DECRYPTED_DESTINATION 0x00000008 #define COPY_FILE_ALLOW_DECRYPTED_DESTINATION 0x00000008
// //
// Gap for private copyfile flags // Gap for private copyfile flags
// //
#if (_WIN32_WINNT >= 0x0600) #if (_WIN32_WINNT >= 0x0600)
#define COPY_FILE_COPY_SYMLINK 0x00000800 #define COPY_FILE_COPY_SYMLINK 0x00000800
#define COPY_FILE_NO_BUFFERING 0x00001000
#endif #endif
#endif /* _WIN32_WINNT >= 0x0400 */ #endif /* _WIN32_WINNT >= 0x0400 */
#if (_WIN32_WINNT >= 0x0500) #if (_WIN32_WINNT >= 0x0500)
// //
// Define ReplaceFile option flags // Define ReplaceFile option flags
// //
#define REPLACEFILE_WRITE_THROUGH 0x00000001 #define REPLACEFILE_WRITE_THROUGH 0x00000001
#define REPLACEFILE_IGNORE_MERGE_ERRORS 0x00000002 #define REPLACEFILE_IGNORE_MERGE_ERRORS 0x00000002
#if (_WIN32_WINNT >= 0x0600)
#define REPLACEFILE_IGNORE_ACL_ERRORS 0x00000004
#endif
#endif // #if (_WIN32_WINNT >= 0x0500) #endif // #if (_WIN32_WINNT >= 0x0500)
// //
// Define the NamedPipe definitions // Define the NamedPipe definitions
// //
// //
// Define the dwOpenMode values for CreateNamedPipe // Define the dwOpenMode values for CreateNamedPipe
// //
skipping to change at line 242 skipping to change at line 247
// File structures // File structures
// //
typedef struct _OVERLAPPED { typedef struct _OVERLAPPED {
ULONG_PTR Internal; ULONG_PTR Internal;
ULONG_PTR InternalHigh; ULONG_PTR InternalHigh;
union { union {
struct { struct {
DWORD Offset; DWORD Offset;
DWORD OffsetHigh; DWORD OffsetHigh;
}; } DUMMYSTRUCTNAME;
PVOID Pointer; PVOID Pointer;
}; } DUMMYUNIONNAME;
HANDLE hEvent; HANDLE hEvent;
} OVERLAPPED, *LPOVERLAPPED; } OVERLAPPED, *LPOVERLAPPED;
typedef struct _OVERLAPPED_ENTRY { typedef struct _OVERLAPPED_ENTRY {
ULONG_PTR lpCompletionKey; ULONG_PTR lpCompletionKey;
LPOVERLAPPED lpOverlapped; LPOVERLAPPED lpOverlapped;
ULONG_PTR Internal; ULONG_PTR Internal;
DWORD dwNumberOfBytesTransferred; DWORD dwNumberOfBytesTransferred;
} OVERLAPPED_ENTRY, *LPOVERLAPPED_ENTRY; } OVERLAPPED_ENTRY, *LPOVERLAPPED_ENTRY;
skipping to change at line 344 skipping to change at line 348
#define INIT_ONCE_ASYNC RTL_RUN_ONCE_ASYNC #define INIT_ONCE_ASYNC RTL_RUN_ONCE_ASYNC
#define INIT_ONCE_INIT_FAILED RTL_RUN_ONCE_INIT_FAILED #define INIT_ONCE_INIT_FAILED RTL_RUN_ONCE_INIT_FAILED
// //
// The context stored in the run once structure must leave the following number // The context stored in the run once structure must leave the following number
// of low order bits unused. // of low order bits unused.
// //
#define INIT_ONCE_CTX_RESERVED_BITS RTL_RUN_ONCE_CTX_RESERVED_BITS #define INIT_ONCE_CTX_RESERVED_BITS RTL_RUN_ONCE_CTX_RESERVED_BITS
//
// FailFast Exception Flags
//
#define FAIL_FAST_GENERATE_EXCEPTION_ADDRESS 0x1
#define FAIL_FAST_NO_HARD_ERROR_DLG 0x2
typedef typedef
BOOL BOOL
(WINAPI *PINIT_ONCE_FN) ( (WINAPI *PINIT_ONCE_FN) (
__inout PINIT_ONCE InitOnce, __inout PINIT_ONCE InitOnce,
__inout_opt PVOID Parameter, __inout_opt PVOID Parameter,
__deref_opt_out_opt PVOID *Context __deref_opt_out_opt PVOID *Context
); );
WINBASEAPI WINBASEAPI
VOID VOID
skipping to change at line 433 skipping to change at line 444
__inout PSRWLOCK SRWLock __inout PSRWLOCK SRWLock
); );
WINBASEAPI WINBASEAPI
VOID VOID
WINAPI WINAPI
AcquireSRWLockShared ( AcquireSRWLockShared (
__inout PSRWLOCK SRWLock __inout PSRWLOCK SRWLock
); );
WINBASEAPI
BOOLEAN
WINAPI
TryAcquireSRWLockExclusive (
__inout PSRWLOCK SRWLock
);
WINBASEAPI
BOOLEAN
WINAPI
TryAcquireSRWLockShared (
__inout PSRWLOCK SRWLock
);
// //
// Define condition variable // Define condition variable
// //
typedef RTL_CONDITION_VARIABLE CONDITION_VARIABLE, *PCONDITION_VARIABLE; typedef RTL_CONDITION_VARIABLE CONDITION_VARIABLE, *PCONDITION_VARIABLE;
WINBASEAPI WINBASEAPI
VOID VOID
WINAPI WINAPI
InitializeConditionVariable ( InitializeConditionVariable (
skipping to change at line 744 skipping to change at line 769
DWORD dwProviderSize; /* size of the provider-specific data field */ DWORD dwProviderSize; /* size of the provider-specific data field */
WCHAR wcProviderData[1]; /* provider-specific data */ WCHAR wcProviderData[1]; /* provider-specific data */
} COMMCONFIG,*LPCOMMCONFIG; } COMMCONFIG,*LPCOMMCONFIG;
typedef struct _SYSTEM_INFO { typedef struct _SYSTEM_INFO {
union { union {
DWORD dwOemId; // Obsolete field...do not use DWORD dwOemId; // Obsolete field...do not use
struct { struct {
WORD wProcessorArchitecture; WORD wProcessorArchitecture;
WORD wReserved; WORD wReserved;
}; } DUMMYSTRUCTNAME;
}; } DUMMYUNIONNAME;
DWORD dwPageSize; DWORD dwPageSize;
LPVOID lpMinimumApplicationAddress; LPVOID lpMinimumApplicationAddress;
LPVOID lpMaximumApplicationAddress; LPVOID lpMaximumApplicationAddress;
DWORD_PTR dwActiveProcessorMask; DWORD_PTR dwActiveProcessorMask;
DWORD dwNumberOfProcessors; DWORD dwNumberOfProcessors;
DWORD dwProcessorType; DWORD dwProcessorType;
DWORD dwAllocationGranularity; DWORD dwAllocationGranularity;
WORD wProcessorLevel; WORD wProcessorLevel;
WORD wProcessorRevision; WORD wProcessorRevision;
} SYSTEM_INFO, *LPSYSTEM_INFO; } SYSTEM_INFO, *LPSYSTEM_INFO;
skipping to change at line 831 skipping to change at line 856
/* Flags returned by LocalFlags (in addition to LMEM_DISCARDABLE) */ /* Flags returned by LocalFlags (in addition to LMEM_DISCARDABLE) */
#define LMEM_DISCARDED 0x4000 #define LMEM_DISCARDED 0x4000
#define LMEM_LOCKCOUNT 0x00FF #define LMEM_LOCKCOUNT 0x00FF
// //
// NUMA values // NUMA values
// //
#define NUMA_NO_PREFERRED_NODE ((DWORD) -1) #define NUMA_NO_PREFERRED_NODE ((DWORD) -1)
// //
// dwCreationFlag values // Process dwCreationFlag values
// //
#define DEBUG_PROCESS 0x00000001 #define DEBUG_PROCESS 0x00000001
#define DEBUG_ONLY_THIS_PROCESS 0x00000002 #define DEBUG_ONLY_THIS_PROCESS 0x00000002
#define CREATE_SUSPENDED 0x00000004 #define CREATE_SUSPENDED 0x00000004
#define DETACHED_PROCESS 0x00000008 #define DETACHED_PROCESS 0x00000008
#define CREATE_NEW_CONSOLE 0x00000010 #define CREATE_NEW_CONSOLE 0x00000010
#define NORMAL_PRIORITY_CLASS 0x00000020 #define NORMAL_PRIORITY_CLASS 0x00000020
#define IDLE_PRIORITY_CLASS 0x00000040 #define IDLE_PRIORITY_CLASS 0x00000040
#define HIGH_PRIORITY_CLASS 0x00000080 #define HIGH_PRIORITY_CLASS 0x00000080
#define REALTIME_PRIORITY_CLASS 0x00000100
#define REALTIME_PRIORITY_CLASS 0x00000100
#define CREATE_NEW_PROCESS_GROUP 0x00000200 #define CREATE_NEW_PROCESS_GROUP 0x00000200
#define CREATE_UNICODE_ENVIRONMENT 0x00000400 #define CREATE_UNICODE_ENVIRONMENT 0x00000400
#define CREATE_SEPARATE_WOW_VDM 0x00000800 #define CREATE_SEPARATE_WOW_VDM 0x00000800
#define CREATE_SHARED_WOW_VDM 0x00001000 #define CREATE_SHARED_WOW_VDM 0x00001000
#define CREATE_FORCEDOS 0x00002000 #define CREATE_FORCEDOS 0x00002000
#define BELOW_NORMAL_PRIORITY_CLASS 0x00004000 #define BELOW_NORMAL_PRIORITY_CLASS 0x00004000
#define ABOVE_NORMAL_PRIORITY_CLASS 0x00008000 #define ABOVE_NORMAL_PRIORITY_CLASS 0x00008000
#define STACK_SIZE_PARAM_IS_A_RESERVATION 0x00010000 #define INHERIT_PARENT_AFFINITY 0x00010000
#define INHERIT_CALLER_PRIORITY 0x00020000 #define INHERIT_CALLER_PRIORITY 0x00020000 // Deprecated
#define CREATE_PROTECTED_PROCESS 0x00040000 #define CREATE_PROTECTED_PROCESS 0x00040000
#define EXTENDED_STARTUPINFO_PRESENT 0x00080000 #define EXTENDED_STARTUPINFO_PRESENT 0x00080000
#define PROCESS_MODE_BACKGROUND_BEGIN 0x00100000 #define PROCESS_MODE_BACKGROUND_BEGIN 0x00100000
#define PROCESS_MODE_BACKGROUND_END 0x00200000 #define PROCESS_MODE_BACKGROUND_END 0x00200000
#define CREATE_BREAKAWAY_FROM_JOB 0x01000000 #define CREATE_BREAKAWAY_FROM_JOB 0x01000000
#define CREATE_PRESERVE_CODE_AUTHZ_LEVEL 0x02000000 #define CREATE_PRESERVE_CODE_AUTHZ_LEVEL 0x02000000
#define CREATE_DEFAULT_ERROR_MODE 0x04000000 #define CREATE_DEFAULT_ERROR_MODE 0x04000000
#define CREATE_NO_WINDOW 0x08000000 #define CREATE_NO_WINDOW 0x08000000
#define PROFILE_USER 0x10000000 #define PROFILE_USER 0x10000000
#define PROFILE_KERNEL 0x20000000 #define PROFILE_KERNEL 0x20000000
#define PROFILE_SERVER 0x40000000 #define PROFILE_SERVER 0x40000000
#define CREATE_IGNORE_SYSTEM_DEFAULT 0x80000000 #define CREATE_IGNORE_SYSTEM_DEFAULT 0x80000000
//
// Thread dwCreationFlag values
//
//#define CREATE_SUSPENDED 0x00000004
#define STACK_SIZE_PARAM_IS_A_RESERVATION 0x00010000 // Threads only
//
// Priority flags
//
#define THREAD_PRIORITY_LOWEST THREAD_BASE_PRIORITY_MIN #define THREAD_PRIORITY_LOWEST THREAD_BASE_PRIORITY_MIN
#define THREAD_PRIORITY_BELOW_NORMAL (THREAD_PRIORITY_LOWEST+1) #define THREAD_PRIORITY_BELOW_NORMAL (THREAD_PRIORITY_LOWEST+1)
#define THREAD_PRIORITY_NORMAL 0 #define THREAD_PRIORITY_NORMAL 0
#define THREAD_PRIORITY_HIGHEST THREAD_BASE_PRIORITY_MAX #define THREAD_PRIORITY_HIGHEST THREAD_BASE_PRIORITY_MAX
#define THREAD_PRIORITY_ABOVE_NORMAL (THREAD_PRIORITY_HIGHEST-1) #define THREAD_PRIORITY_ABOVE_NORMAL (THREAD_PRIORITY_HIGHEST-1)
#define THREAD_PRIORITY_ERROR_RETURN (MAXLONG) #define THREAD_PRIORITY_ERROR_RETURN (MAXLONG)
#define THREAD_PRIORITY_TIME_CRITICAL THREAD_BASE_PRIORITY_LOWRT #define THREAD_PRIORITY_TIME_CRITICAL THREAD_BASE_PRIORITY_LOWRT
#define THREAD_PRIORITY_IDLE THREAD_BASE_PRIORITY_IDLE #define THREAD_PRIORITY_IDLE THREAD_BASE_PRIORITY_IDLE
skipping to change at line 2548 skipping to change at line 2576
__clrcall __clrcall
#else #else
WINAPI WINAPI
#endif #endif
#else #else
CALLBACK CALLBACK
#endif #endif
WinMain ( WinMain (
__in HINSTANCE hInstance, __in HINSTANCE hInstance,
__in_opt HINSTANCE hPrevInstance, __in_opt HINSTANCE hPrevInstance,
__in_opt LPSTR lpCmdLine, __in LPSTR lpCmdLine,
__in int nShowCmd __in int nShowCmd
); );
int int
#if defined(_M_CEE_PURE) #if defined(_M_CEE_PURE)
__clrcall __clrcall
#else #else
WINAPI WINAPI
#endif #endif
wWinMain( wWinMain(
__in HINSTANCE hInstance, __in HINSTANCE hInstance,
__in_opt HINSTANCE hPrevInstance, __in_opt HINSTANCE hPrevInstance,
__in_opt LPWSTR lpCmdLine, __in LPWSTR lpCmdLine,
__in int nShowCmd __in int nShowCmd
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
FreeLibrary ( FreeLibrary (
__in HMODULE hLibModule __in HMODULE hLibModule
); );
skipping to change at line 2730 skipping to change at line 2758
} MEMORYSTATUSEX, *LPMEMORYSTATUSEX; } MEMORYSTATUSEX, *LPMEMORYSTATUSEX;
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GlobalMemoryStatusEx( GlobalMemoryStatusEx(
__out LPMEMORYSTATUSEX lpBuffer __out LPMEMORYSTATUSEX lpBuffer
); );
WINBASEAPI WINBASEAPI
__out_bcount_opt( "(uFlags&LMEM_FIXED) ? uBytes : 0" ) __out_bcount_opt( (uFlags&LMEM_FIXED) ? uBytes : 0 )
HLOCAL HLOCAL
WINAPI WINAPI
LocalAlloc( LocalAlloc(
__in UINT uFlags, __in UINT uFlags,
__in SIZE_T uBytes __in SIZE_T uBytes
); );
WINBASEAPI WINBASEAPI
__out_opt __out_opt
HLOCAL HLOCAL
skipping to change at line 2851 skipping to change at line 2879
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
QueryIdleProcessorCycleTime ( QueryIdleProcessorCycleTime (
__inout PULONG BufferLength, __inout PULONG BufferLength,
__out_bcount_opt(*BufferLength) PULONG64 ProcessorIdleCycleTime __out_bcount_opt(*BufferLength) PULONG64 ProcessorIdleCycleTime
); );
#endif #endif
#if (_WIN32_WINNT >= 0x0601)
WINBASEAPI
BOOL
WINAPI
QueryIdleProcessorCycleTimeEx (
__in USHORT Group,
__inout PULONG BufferLength,
__out_bcount_opt(*BufferLength) PULONG64 ProcessorIdleCycleTime
);
WINBASEAPI
BOOL
WINAPI
QueryUnbiasedInterruptTime (
__out PULONGLONG UnbiasedTime
);
WINBASEAPI
BOOL
WINAPI
GetProcessorSystemCycleTime (
__in USHORT Group,
__out_bcount_part_opt(*ReturnedLength, *ReturnedLength) PSYSTEM_PROCESSOR_CY
CLE_TIME_INFORMATION Buffer,
__inout PDWORD ReturnedLength
);
#endif // (_WIN32_WINNT >= 0x0601)
WINBASEAPI WINBASEAPI
__bcount_opt(dwSize) __bcount_opt(dwSize)
LPVOID LPVOID
WINAPI WINAPI
VirtualAlloc( VirtualAlloc(
__in_opt LPVOID lpAddress, __in_opt LPVOID lpAddress,
__in SIZE_T dwSize, __in SIZE_T dwSize,
__in DWORD flAllocationType, __in DWORD flAllocationType,
__in DWORD flProtect __in DWORD flProtect
); );
__drv_when(((dwFreeType&(MEM_RELEASE|MEM_DECOMMIT)))==(MEM_RELEASE|MEM_DECOMMIT)
,
__drv_reportError("Passing both MEM_RELEASE and MEM_DECOMMIT to VirtualFree
is not allowed. This results in the failure of this call"))
__drv_when(dwFreeType==0,
__drv_reportError("Passing zero as the dwFreeType parameter to VirtualFree i
s not allowed. This results in the failure of this call"))
__drv_when(((dwFreeType&MEM_RELEASE))!=0 && dwSize!=0,
__drv_reportError("Passing MEM_RELEASE and a non-zero dwSize parameter to Vi
rtualFree is not allowed. This results in the failure of this call"))
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
VirtualFree( VirtualFree(
__in LPVOID lpAddress, __in LPVOID lpAddress,
__in SIZE_T dwSize, __in SIZE_T dwSize,
__in DWORD dwFreeType __in DWORD dwFreeType
); );
WINBASEAPI WINBASEAPI
skipping to change at line 2968 skipping to change at line 3033
GetSystemFirmwareTable( GetSystemFirmwareTable(
__in DWORD FirmwareTableProviderSignature, __in DWORD FirmwareTableProviderSignature,
__in DWORD FirmwareTableID, __in DWORD FirmwareTableID,
__out_bcount_part_opt(BufferSize, return) PVOID pFirmwareTableBuffer, __out_bcount_part_opt(BufferSize, return) PVOID pFirmwareTableBuffer,
__in DWORD BufferSize __in DWORD BufferSize
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetPhysicallyInstalledSystemMemory(
__out PULONGLONG TotalMemoryInKilobytes
);
__drv_when(((dwFreeType&(MEM_RELEASE|MEM_DECOMMIT)))==(MEM_RELEASE|MEM_DECOMMIT)
,
__drv_reportError("Passing both MEM_RELEASE and MEM_DECOMMIT to VirtualFree
is not allowed. This results in the failure of this call"))
__drv_when(dwFreeType==0,
__drv_reportError("Passing zero as the dwFreeType parameter to VirtualFree i
s not allowed. This results in the failure of this call"))
__drv_when(((dwFreeType&MEM_RELEASE))!=0 && dwSize!=0,
__drv_reportError("Passing MEM_RELEASE and a non-zero dwSize parameter to Vi
rtualFree is not allowed. This results in the failure of this call"))
__drv_when(((dwFreeType&MEM_DECOMMIT))!=0,
__drv_reportError("Calling VirtualFreeEx without the MEM_RELEASE flag frees
memory but not address descriptors (VADs); results in address space leaks"))
WINBASEAPI
BOOL
WINAPI
VirtualFreeEx( VirtualFreeEx(
__in HANDLE hProcess, __in HANDLE hProcess,
__in LPVOID lpAddress, __in LPVOID lpAddress,
__in SIZE_T dwSize, __in SIZE_T dwSize,
__in DWORD dwFreeType __in DWORD dwFreeType
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
skipping to change at line 3040 skipping to change at line 3123
__deref LPVOID lpMem, __deref LPVOID lpMem,
__in SIZE_T dwBytes __in SIZE_T dwBytes
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
HeapFree( HeapFree(
__inout HANDLE hHeap, __inout HANDLE hHeap,
__in DWORD dwFlags, __in DWORD dwFlags,
__deref LPVOID lpMem __drv_freesMem(Mem) __post __notvalid __deref LPVOID lpMem
); );
WINBASEAPI WINBASEAPI
SIZE_T SIZE_T
WINAPI WINAPI
HeapSize( HeapSize(
__in HANDLE hHeap, __in HANDLE hHeap,
__in DWORD dwFlags, __in DWORD dwFlags,
__in LPCVOID lpMem __in LPCVOID lpMem
); );
skipping to change at line 3100 skipping to change at line 3183
struct { struct {
HANDLE hMem; HANDLE hMem;
DWORD dwReserved[ 3 ]; DWORD dwReserved[ 3 ];
} Block; } Block;
struct { struct {
DWORD dwCommittedSize; DWORD dwCommittedSize;
DWORD dwUnCommittedSize; DWORD dwUnCommittedSize;
LPVOID lpFirstBlock; LPVOID lpFirstBlock;
LPVOID lpLastBlock; LPVOID lpLastBlock;
} Region; } Region;
}; } DUMMYUNIONNAME;
} PROCESS_HEAP_ENTRY, *LPPROCESS_HEAP_ENTRY, *PPROCESS_HEAP_ENTRY; } PROCESS_HEAP_ENTRY, *LPPROCESS_HEAP_ENTRY, *PPROCESS_HEAP_ENTRY;
#define PROCESS_HEAP_REGION 0x0001 #define PROCESS_HEAP_REGION 0x0001
#define PROCESS_HEAP_UNCOMMITTED_RANGE 0x0002 #define PROCESS_HEAP_UNCOMMITTED_RANGE 0x0002
#define PROCESS_HEAP_ENTRY_BUSY 0x0004 #define PROCESS_HEAP_ENTRY_BUSY 0x0004
#define PROCESS_HEAP_ENTRY_MOVEABLE 0x0010 #define PROCESS_HEAP_ENTRY_MOVEABLE 0x0010
#define PROCESS_HEAP_ENTRY_DDESHARE 0x0020 #define PROCESS_HEAP_ENTRY_DDESHARE 0x0020
WINBASEAPI WINBASEAPI
BOOL BOOL
skipping to change at line 3193 skipping to change at line 3276
#define GetBinaryType GetBinaryTypeW #define GetBinaryType GetBinaryTypeW
#else #else
#define GetBinaryType GetBinaryTypeA #define GetBinaryType GetBinaryTypeA
#endif // !UNICODE #endif // !UNICODE
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
GetShortPathNameA( GetShortPathNameA(
__in LPCSTR lpszLongPath, __in LPCSTR lpszLongPath,
__out_ecount_part(cchBuffer, return + 1) LPSTR lpszShortPath, __out_ecount_part_opt(cchBuffer, return + 1) LPSTR lpszShortPath,
__in DWORD cchBuffer __in DWORD cchBuffer
); );
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
GetShortPathNameW( GetShortPathNameW(
__in LPCWSTR lpszLongPath, __in LPCWSTR lpszLongPath,
__out_ecount_part(cchBuffer, return + 1) LPWSTR lpszShortPath, __out_ecount_part_opt(cchBuffer, return + 1) LPWSTR lpszShortPath,
__in DWORD cchBuffer __in DWORD cchBuffer
); );
#ifdef UNICODE #ifdef UNICODE
#define GetShortPathName GetShortPathNameW #define GetShortPathName GetShortPathNameW
#else #else
#define GetShortPathName GetShortPathNameA #define GetShortPathName GetShortPathNameA
#endif // !UNICODE #endif // !UNICODE
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
GetLongPathNameA( GetLongPathNameA(
__in LPCSTR lpszShortPath, __in LPCSTR lpszShortPath,
__out_ecount_part(cchBuffer, return + 1) LPSTR lpszLongPath, __out_ecount_part_opt(cchBuffer, return + 1) LPSTR lpszLongPath,
__in DWORD cchBuffer __in DWORD cchBuffer
); );
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
GetLongPathNameW( GetLongPathNameW(
__in LPCWSTR lpszShortPath, __in LPCWSTR lpszShortPath,
__out_ecount_part(cchBuffer, return + 1) LPWSTR lpszLongPath, __out_ecount_part_opt(cchBuffer, return + 1) LPWSTR lpszLongPath,
__in DWORD cchBuffer __in DWORD cchBuffer
); );
#ifdef UNICODE #ifdef UNICODE
#define GetLongPathName GetLongPathNameW #define GetLongPathName GetLongPathNameW
#else #else
#define GetLongPathName GetLongPathNameA #define GetLongPathName GetLongPathNameA
#endif // !UNICODE #endif // !UNICODE
#if _WIN32_WINNT >= 0x0600 #if _WIN32_WINNT >= 0x0600
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
GetLongPathNameTransactedA( GetLongPathNameTransactedA(
__in LPCSTR lpszShortPath, __in LPCSTR lpszShortPath,
__out_ecount_part(cchBuffer, return + 1) LPSTR lpszLongPath, __out_ecount_part_opt(cchBuffer, return + 1) LPSTR lpszLongPath,
__in DWORD cchBuffer, __in DWORD cchBuffer,
__in HANDLE hTransaction __in HANDLE hTransaction
); );
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
GetLongPathNameTransactedW( GetLongPathNameTransactedW(
__in LPCWSTR lpszShortPath, __in LPCWSTR lpszShortPath,
__out_ecount_part(cchBuffer, return + 1) LPWSTR lpszLongPath, __out_ecount_part_opt(cchBuffer, return + 1) LPWSTR lpszLongPath,
__in DWORD cchBuffer, __in DWORD cchBuffer,
__in HANDLE hTransaction __in HANDLE hTransaction
); );
#ifdef UNICODE #ifdef UNICODE
#define GetLongPathNameTransacted GetLongPathNameTransactedW #define GetLongPathNameTransacted GetLongPathNameTransactedW
#else #else
#define GetLongPathNameTransacted GetLongPathNameTransactedA #define GetLongPathNameTransacted GetLongPathNameTransactedA
#endif // !UNICODE #endif // !UNICODE
#endif // _WIN32_WINNT >= 0x0600 #endif // _WIN32_WINNT >= 0x0600
skipping to change at line 3277 skipping to change at line 3360
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
SetProcessAffinityMask( SetProcessAffinityMask(
__in HANDLE hProcess, __in HANDLE hProcess,
__in DWORD_PTR dwProcessAffinityMask __in DWORD_PTR dwProcessAffinityMask
); );
#if _WIN32_WINNT >= 0x0601
BOOL
WINAPI
GetProcessGroupAffinity(
__in HANDLE hProcess,
__inout PUSHORT GroupCount,
__out_ecount(*GroupCount) PUSHORT GroupArray
);
#endif // _WIN32_WINNT >= 0x0601
#if _WIN32_WINNT >= 0x0501 #if _WIN32_WINNT >= 0x0501
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetProcessHandleCount( GetProcessHandleCount(
__in HANDLE hProcess, __in HANDLE hProcess,
__out PDWORD pdwHandleCount __out PDWORD pdwHandleCount
); );
skipping to change at line 3346 skipping to change at line 3441
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
SetProcessWorkingSetSizeEx( SetProcessWorkingSetSizeEx(
__in HANDLE hProcess, __in HANDLE hProcess,
__in SIZE_T dwMinimumWorkingSetSize, __in SIZE_T dwMinimumWorkingSetSize,
__in SIZE_T dwMaximumWorkingSetSize, __in SIZE_T dwMaximumWorkingSetSize,
__in DWORD Flags __in DWORD Flags
); );
#if (_WIN32_WINNT >= 0x0600)
#define PROCESS_AFFINITY_ENABLE_AUTO_UPDATE 0x00000001UL
WINBASEAPI
BOOL
WINAPI
SetProcessAffinityUpdateMode(
__in HANDLE hProcess,
__in DWORD dwFlags
);
WINBASEAPI
BOOL
WINAPI
QueryProcessAffinityUpdateMode(
__in HANDLE hProcess,
__out_opt LPDWORD lpdwFlags
);
#endif // _WIN32_WINNT >= 0x0600
WINBASEAPI WINBASEAPI
HANDLE HANDLE
WINAPI WINAPI
OpenProcess( OpenProcess(
__in DWORD dwDesiredAccess, __in DWORD dwDesiredAccess,
__in BOOL bInheritHandle, __in BOOL bInheritHandle,
__in DWORD dwProcessId __in DWORD dwProcessId
); );
WINBASEAPI WINBASEAPI
skipping to change at line 3471 skipping to change at line 3588
WINBASEAPI WINBASEAPI
VOID VOID
WINAPI WINAPI
RaiseException( RaiseException(
__in DWORD dwExceptionCode, __in DWORD dwExceptionCode,
__in DWORD dwExceptionFlags, __in DWORD dwExceptionFlags,
__in DWORD nNumberOfArguments, __in DWORD nNumberOfArguments,
__in_ecount_opt(nNumberOfArguments) CONST ULONG_PTR *lpArguments __in_ecount_opt(nNumberOfArguments) CONST ULONG_PTR *lpArguments
); );
WINBASEAPI
VOID
WINAPI
RaiseFailFastException(
__in_opt PEXCEPTION_RECORD pExceptionRecord,
__in PCONTEXT pContextRecord,
__in DWORD dwFlags
);
__callback __callback
WINBASEAPI WINBASEAPI
LONG LONG
WINAPI WINAPI
UnhandledExceptionFilter( UnhandledExceptionFilter(
__in struct _EXCEPTION_POINTERS *ExceptionInfo __in struct _EXCEPTION_POINTERS *ExceptionInfo
); );
typedef LONG (WINAPI *PTOP_LEVEL_EXCEPTION_FILTER)( typedef LONG (WINAPI *PTOP_LEVEL_EXCEPTION_FILTER)(
__in struct _EXCEPTION_POINTERS *ExceptionInfo __in struct _EXCEPTION_POINTERS *ExceptionInfo
); );
typedef PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER; typedef PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER;
WINBASEAPI WINBASEAPI
LPTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER
WINAPI WINAPI
SetUnhandledExceptionFilter( SetUnhandledExceptionFilter(
__in LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter __in_opt LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter
); );
#if(_WIN32_WINNT >= 0x0400) #if(_WIN32_WINNT >= 0x0400)
// //
// Fiber creation flags // Fiber creation flags
// //
#define FIBER_FLAG_FLOAT_SWITCH 0x1 // context switch floating point #define FIBER_FLAG_FLOAT_SWITCH 0x1 // context switch floating point
skipping to change at line 3581 skipping to change at line 3707
__in LPVOID lpFiber __in LPVOID lpFiber
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
SwitchToThread( SwitchToThread(
VOID VOID
); );
//
// UMS begin
//
#if (_WIN32_WINNT >= 0x0601) && !defined(MIDL_PASS)
#define UMS_VERSION RTL_UMS_VERSION
typedef void *PUMS_CONTEXT;
typedef void *PUMS_COMPLETION_LIST;
typedef enum _RTL_UMS_THREAD_INFO_CLASS UMS_THREAD_INFO_CLASS, *PUMS_THREAD_INFO
_CLASS;
typedef enum _RTL_UMS_SCHEDULER_REASON UMS_SCHEDULER_REASON;
typedef PRTL_UMS_SCHEDULER_ENTRY_POINT PUMS_SCHEDULER_ENTRY_POINT;
typedef struct _UMS_SCHEDULER_STARTUP_INFO {
//
// UMS Version the application was built to. Should be set to UMS_VERSION
//
ULONG UmsVersion;
//
// Completion List to associate the new User Scheduler to.
//
PUMS_COMPLETION_LIST CompletionList;
//
// A pointer to the application-defined function that represents the startin
g
// address of the Sheduler.
//
PUMS_SCHEDULER_ENTRY_POINT SchedulerProc;
//
// pointer to a variable to be passed to the scheduler uppon first activatio
n.
//
PVOID SchedulerParam;
} UMS_SCHEDULER_STARTUP_INFO, *PUMS_SCHEDULER_STARTUP_INFO;
__checkReturn
WINBASEAPI
BOOL
WINAPI
CreateUmsCompletionList(
__deref_out PUMS_COMPLETION_LIST* UmsCompletionList
);
WINBASEAPI
BOOL
WINAPI
DequeueUmsCompletionListItems(
__in PUMS_COMPLETION_LIST UmsCompletionList,
__in DWORD WaitTimeOut,
__out PUMS_CONTEXT* UmsThreadList
);
WINBASEAPI
BOOL
WINAPI
GetUmsCompletionListEvent(
__in PUMS_COMPLETION_LIST UmsCompletionList,
__inout PHANDLE UmsCompletionEvent
);
WINBASEAPI
BOOL
WINAPI
ExecuteUmsThread(
__inout PUMS_CONTEXT UmsThread
);
WINBASEAPI
BOOL
WINAPI
UmsThreadYield(
__in PVOID SchedulerParam
);
WINBASEAPI
BOOL
WINAPI
DeleteUmsCompletionList(
__in PUMS_COMPLETION_LIST UmsCompletionList
);
WINBASEAPI
PUMS_CONTEXT
WINAPI
GetCurrentUmsThread(
VOID
);
WINBASEAPI
PUMS_CONTEXT
WINAPI
GetNextUmsListItem(
__inout PUMS_CONTEXT UmsContext
);
WINBASEAPI
BOOL
WINAPI
QueryUmsThreadInformation(
__in PUMS_CONTEXT UmsThread,
__in UMS_THREAD_INFO_CLASS UmsThreadInfoClass,
__out_bcount_part(UmsThreadInformationLength, *ReturnLength) PVOID UmsThread
Information,
__in ULONG UmsThreadInformationLength,
__out_opt PULONG ReturnLength
);
WINBASEAPI
BOOL
WINAPI
SetUmsThreadInformation(
__in PUMS_CONTEXT UmsThread,
__in UMS_THREAD_INFO_CLASS UmsThreadInfoClass,
__in PVOID UmsThreadInformation,
__in ULONG UmsThreadInformationLength
);
WINBASEAPI
BOOL
WINAPI
DeleteUmsThreadContext(
__in PUMS_CONTEXT UmsThread
);
WINBASEAPI
BOOL
WINAPI
CreateUmsThreadContext(
__deref_out PUMS_CONTEXT *lpUmsThread
);
WINBASEAPI
BOOL
WINAPI
EnterUmsSchedulingMode(
__in PUMS_SCHEDULER_STARTUP_INFO SchedulerStartupInfo
);
#endif // (_WIN32_WINNT >= 0x0601) && !defined(MIDL_PASS)
//
// UMS end
//
#endif /* _WIN32_WINNT >= 0x0400 */ #endif /* _WIN32_WINNT >= 0x0400 */
typedef struct _PROC_THREAD_ATTRIBUTE_LIST *PPROC_THREAD_ATTRIBUTE_LIST, *LPPROC
_THREAD_ATTRIBUTE_LIST;
WINBASEAPI WINBASEAPI
__out_opt __out_opt
HANDLE HANDLE
WINAPI WINAPI
CreateThread( CreateThread(
__in_opt LPSECURITY_ATTRIBUTES lpThreadAttributes, __in_opt LPSECURITY_ATTRIBUTES lpThreadAttributes,
__in SIZE_T dwStackSize, __in SIZE_T dwStackSize,
__in LPTHREAD_START_ROUTINE lpStartAddress, __in LPTHREAD_START_ROUTINE lpStartAddress,
__in_opt LPVOID lpParameter, __in_opt __deref __drv_aliasesMem LPVOID lpParameter,
__in DWORD dwCreationFlags, __in DWORD dwCreationFlags,
__out_opt LPDWORD lpThreadId __out_opt LPDWORD lpThreadId
); );
WINBASEAPI WINBASEAPI
__out_opt __out_opt
HANDLE HANDLE
WINAPI WINAPI
CreateRemoteThread( CreateRemoteThread(
__in HANDLE hProcess, __in HANDLE hProcess,
__in_opt LPSECURITY_ATTRIBUTES lpThreadAttributes, __in_opt LPSECURITY_ATTRIBUTES lpThreadAttributes,
__in SIZE_T dwStackSize, __in SIZE_T dwStackSize,
__in LPTHREAD_START_ROUTINE lpStartAddress, __in LPTHREAD_START_ROUTINE lpStartAddress,
__in_opt LPVOID lpParameter, __in_opt LPVOID lpParameter,
__in DWORD dwCreationFlags, __in DWORD dwCreationFlags,
__out_opt LPDWORD lpThreadId __out_opt LPDWORD lpThreadId
); );
WINBASEAPI WINBASEAPI
__out_opt
HANDLE
WINAPI
CreateRemoteThreadEx(
__in HANDLE hProcess,
__in_opt LPSECURITY_ATTRIBUTES lpThreadAttributes,
__in SIZE_T dwStackSize,
__in LPTHREAD_START_ROUTINE lpStartAddress,
__in_opt LPVOID lpParameter,
__in DWORD dwCreationFlags,
__in_opt LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,
__out_opt LPDWORD lpThreadId
);
WINBASEAPI
__out __out
HANDLE HANDLE
WINAPI WINAPI
GetCurrentThread( GetCurrentThread(
VOID VOID
); );
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
skipping to change at line 3664 skipping to change at line 3958
__in HANDLE Process __in HANDLE Process
); );
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
GetCurrentProcessorNumber( GetCurrentProcessorNumber(
VOID VOID
); );
#if (_WIN32_WINNT >= 0x0601)
WINBASEAPI
VOID
WINAPI
GetCurrentProcessorNumberEx(
__out PPROCESSOR_NUMBER ProcNumber
);
#endif
#if (_WIN32_WINNT >= 0x0601)
WINBASEAPI
BOOL
WINAPI
GetThreadGroupAffinity(
__in HANDLE hThread,
__out PGROUP_AFFINITY GroupAffinity
);
#endif // _WIN32_WINNT >= 0x0601
WINBASEAPI WINBASEAPI
DWORD_PTR DWORD_PTR
WINAPI WINAPI
SetThreadAffinityMask( SetThreadAffinityMask(
__in HANDLE hThread, __in HANDLE hThread,
__in DWORD_PTR dwThreadAffinityMask __in DWORD_PTR dwThreadAffinityMask
); );
#if (_WIN32_WINNT >= 0x0601)
WINBASEAPI
BOOL
WINAPI
SetThreadGroupAffinity(
__in HANDLE hThread,
__in CONST GROUP_AFFINITY *GroupAffinity,
__out_opt PGROUP_AFFINITY PreviousGroupAffinity
);
WINBASEAPI
BOOL
WINAPI
SetThreadIdealProcessorEx (
__in HANDLE hThread,
__in PPROCESSOR_NUMBER lpIdealProcessor,
__out_opt PPROCESSOR_NUMBER lpPreviousIdealProcessor
);
WINBASEAPI
BOOL
WINAPI
GetThreadIdealProcessorEx (
__in HANDLE hThread,
__out PPROCESSOR_NUMBER lpIdealProcessor
);
#endif // _WIN32_WINNT >= 0x0601
#if(_WIN32_WINNT >= 0x0400) #if(_WIN32_WINNT >= 0x0400)
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
SetThreadIdealProcessor( SetThreadIdealProcessor(
__in HANDLE hThread, __in HANDLE hThread,
__in DWORD dwIdealProcessor __in DWORD dwIdealProcessor
); );
#endif /* _WIN32_WINNT >= 0x0400 */ #endif /* _WIN32_WINNT >= 0x0400 */
#if (_WIN32_WINNT >= 0x0600)
#define PROCESS_DEP_ENABLE 0x00000001
#define PROCESS_DEP_DISABLE_ATL_THUNK_EMULATION 0x00000002
WINBASEAPI
BOOL
WINAPI
SetProcessDEPPolicy(
__in DWORD dwFlags
);
WINBASEAPI
BOOL
WINAPI
GetProcessDEPPolicy(
__in HANDLE hProcess,
__out LPDWORD lpFlags,
__out PBOOL lpPermanent
);
#endif // _WIN32_WINNT >= 0x0600
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
SetProcessPriorityBoost( SetProcessPriorityBoost(
__in HANDLE hProcess, __in HANDLE hProcess,
__in BOOL bDisablePriorityBoost __in BOOL bDisablePriorityBoost
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
skipping to change at line 3793 skipping to change at line 4158
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
TerminateThread( TerminateThread(
__in HANDLE hThread, __in HANDLE hThread,
__in DWORD dwExitCode __in DWORD dwExitCode
); );
WINBASEAPI WINBASEAPI
__success(return != 0)
BOOL BOOL
WINAPI WINAPI
GetExitCodeThread( GetExitCodeThread(
__in HANDLE hThread, __in HANDLE hThread,
__out LPDWORD lpExitCode __out LPDWORD lpExitCode
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
skipping to change at line 3816 skipping to change at line 4182
__out LPLDT_ENTRY lpSelectorEntry __out LPLDT_ENTRY lpSelectorEntry
); );
WINBASEAPI WINBASEAPI
EXECUTION_STATE EXECUTION_STATE
WINAPI WINAPI
SetThreadExecutionState( SetThreadExecutionState(
__in EXECUTION_STATE esFlags __in EXECUTION_STATE esFlags
); );
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN7)
typedef struct _REASON_CONTEXT {
ULONG Version;
DWORD Flags;
union {
struct {
HMODULE LocalizedReasonModule;
ULONG LocalizedReasonId;
ULONG ReasonStringCount;
LPWSTR *ReasonStrings;
} Detailed;
LPWSTR SimpleReasonString;
} Reason;
} REASON_CONTEXT, *PREASON_CONTEXT;
//
// Power Request APIs
//
typedef REASON_CONTEXT POWER_REQUEST_CONTEXT, *PPOWER_REQUEST_CONTEXT, *LPPOWER_
REQUEST_CONTEXT;
WINBASEAPI
HANDLE
WINAPI
PowerCreateRequest (
__in PREASON_CONTEXT Context
);
WINBASEAPI
BOOL
WINAPI
PowerSetRequest (
__in HANDLE PowerRequest,
__in POWER_REQUEST_TYPE RequestType
);
WINBASEAPI
BOOL
WINAPI
PowerClearRequest (
__in HANDLE PowerRequest,
__in POWER_REQUEST_TYPE RequestType
);
#endif // (_WIN32_WINNT >= _WIN32_WINNT_WIN7)
#ifdef _M_CEE_PURE #ifdef _M_CEE_PURE
#define GetLastError System::Runtime::InteropServices::Marshal::GetLastWin32Erro r #define GetLastError System::Runtime::InteropServices::Marshal::GetLastWin32Erro r
#else #else
WINBASEAPI WINBASEAPI
__checkReturn __checkReturn
DWORD DWORD
WINAPI WINAPI
GetLastError( GetLastError(
VOID VOID
); );
skipping to change at line 3970 skipping to change at line 4385
VOID VOID
); );
WINBASEAPI WINBASEAPI
UINT UINT
WINAPI WINAPI
SetErrorMode( SetErrorMode(
__in UINT uMode __in UINT uMode
); );
//
// Thread error mode support
//
WINBASEAPI
DWORD
WINAPI
GetThreadErrorMode(
VOID
);
WINBASEAPI
BOOL
WINAPI
SetThreadErrorMode(
__in DWORD dwNewMode,
__in_opt LPDWORD lpOldMode
);
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
ReadProcessMemory( ReadProcessMemory(
__in HANDLE hProcess, __in HANDLE hProcess,
__in LPCVOID lpBaseAddress, __in LPCVOID lpBaseAddress,
__out_bcount_part(nSize, *lpNumberOfBytesRead) LPVOID lpBuffer, __out_bcount_part(nSize, *lpNumberOfBytesRead) LPVOID lpBuffer,
__in SIZE_T nSize, __in SIZE_T nSize,
__out_opt SIZE_T * lpNumberOfBytesRead __out_opt SIZE_T * lpNumberOfBytesRead
); );
skipping to change at line 4017 skipping to change at line 4451
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
Wow64GetThreadContext( Wow64GetThreadContext(
__in HANDLE hThread, __in HANDLE hThread,
__inout PWOW64_CONTEXT lpContext __inout PWOW64_CONTEXT lpContext
); );
#if(_WIN32_WINNT >= 0x0601)
WINBASEAPI
BOOL
WINAPI
Wow64GetThreadSelectorEntry(
__in HANDLE hThread,
__in DWORD dwSelector,
__out PWOW64_LDT_ENTRY lpSelectorEntry
);
#endif /* _WIN32_WINNT >= 0x0601 */
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
Wow64SetThreadContext( Wow64SetThreadContext(
__in HANDLE hThread, __in HANDLE hThread,
__in CONST WOW64_CONTEXT *lpContext __in CONST WOW64_CONTEXT *lpContext
); );
#endif #endif
skipping to change at line 4050 skipping to change at line 4497
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
ResumeThread( ResumeThread(
__in HANDLE hThread __in HANDLE hThread
); );
#if(_WIN32_WINNT >= 0x0400) || (_WIN32_WINDOWS > 0x0400) #if(_WIN32_WINNT >= 0x0400) || (_WIN32_WINDOWS > 0x0400)
typedef
VOID
(APIENTRY *PAPCFUNC)(
__in ULONG_PTR dwParam
);
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
QueueUserAPC( QueueUserAPC(
__in PAPCFUNC pfnAPC, __in PAPCFUNC pfnAPC,
__in HANDLE hThread, __in HANDLE hThread,
__in ULONG_PTR dwData __in ULONG_PTR dwData
); );
#endif /* _WIN32_WINNT >= 0x0400 || _WIN32_WINDOWS > 0x0400 */ #endif /* _WIN32_WINNT >= 0x0400 || _WIN32_WINDOWS > 0x0400 */
skipping to change at line 4140 skipping to change at line 4581
__in BOOL KillOnExit __in BOOL KillOnExit
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
DebugBreakProcess ( DebugBreakProcess (
__in HANDLE Process __in HANDLE Process
); );
#if (_WIN32_WINNT < _WIN32_WINNT_LONGHORN)
__drv_inTry
#endif
WINBASEAPI WINBASEAPI
VOID VOID
WINAPI WINAPI
InitializeCriticalSection( InitializeCriticalSection(
__out LPCRITICAL_SECTION lpCriticalSection __out LPCRITICAL_SECTION lpCriticalSection
); );
WINBASEAPI WINBASEAPI
VOID VOID
WINAPI WINAPI
skipping to change at line 4649 skipping to change at line 5093
#define HINSTANCE_ERROR 32 #define HINSTANCE_ERROR 32
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
LoadModule( LoadModule(
__in LPCSTR lpModuleName, __in LPCSTR lpModuleName,
__in LPVOID lpParameterBlock __in LPVOID lpParameterBlock
); );
__drv_preferredFunction("CreateProcess","Deprecated. See MSDN for details")
WINBASEAPI WINBASEAPI
UINT UINT
WINAPI WINAPI
WinExec( WinExec(
__in LPCSTR lpCmdLine, __in LPCSTR lpCmdLine,
__in UINT uCmdShow __in UINT uCmdShow
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
skipping to change at line 4957 skipping to change at line 5402
__in CONST SYSTEMTIME *lpSystemTime __in CONST SYSTEMTIME *lpSystemTime
); );
WINBASEAPI WINBASEAPI
VOID VOID
WINAPI WINAPI
GetSystemInfo( GetSystemInfo(
__out LPSYSTEM_INFO lpSystemInfo __out LPSYSTEM_INFO lpSystemInfo
); );
typedef enum _DEP_SYSTEM_POLICY_TYPE {
DEPPolicyAlwaysOff = 0,
DEPPolicyAlwaysOn,
DEPPolicyOptIn,
DEPPolicyOptOut,
DEPTotalPolicyCount
} DEP_SYSTEM_POLICY_TYPE;
WINBASEAPI
DEP_SYSTEM_POLICY_TYPE
WINAPI
GetSystemDEPPolicy(
VOID
);
#if _WIN32_WINNT >= 0x0502 #if _WIN32_WINNT >= 0x0502
#define FILE_CACHE_FLAGS_DEFINED
#define FILE_CACHE_MAX_HARD_ENABLE 0x00000001
#define FILE_CACHE_MAX_HARD_DISABLE 0x00000002
#define FILE_CACHE_MIN_HARD_ENABLE 0x00000004
#define FILE_CACHE_MIN_HARD_DISABLE 0x00000008
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
SetSystemFileCacheSize ( SetSystemFileCacheSize (
__in SIZE_T MinimumFileCacheSize, __in SIZE_T MinimumFileCacheSize,
__in SIZE_T MaximumFileCacheSize, __in SIZE_T MaximumFileCacheSize,
__in DWORD Flags __in DWORD Flags
); );
WINBASEAPI WINBASEAPI
skipping to change at line 5055 skipping to change at line 5522
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
TzSpecificLocalTimeToSystemTime( TzSpecificLocalTimeToSystemTime(
__in_opt CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation, __in_opt CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation,
__in CONST SYSTEMTIME *lpLocalTime, __in CONST SYSTEMTIME *lpLocalTime,
__out LPSYSTEMTIME lpUniversalTime __out LPSYSTEMTIME lpUniversalTime
); );
BOOL
WINAPI
GetTimeZoneInformationForYear(
__in USHORT wYear,
__in_opt PDYNAMIC_TIME_ZONE_INFORMATION pdtzi,
__out LPTIME_ZONE_INFORMATION ptzi
);
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
GetTimeZoneInformation( GetTimeZoneInformation(
__out LPTIME_ZONE_INFORMATION lpTimeZoneInformation __out LPTIME_ZONE_INFORMATION lpTimeZoneInformation
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
skipping to change at line 5145 skipping to change at line 5620
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
DosDateTimeToFileTime( DosDateTimeToFileTime(
__in WORD wFatDate, __in WORD wFatDate,
__in WORD wFatTime, __in WORD wFatTime,
__out LPFILETIME lpFileTime __out LPFILETIME lpFileTime
); );
__drv_preferredFunction("GetTickCount64", "GetTickCount overflows roughly every 49 days. Code that does not take that into account can loop indefinitely. GetT ickCount64 operates on 64 bit values and does not have that problem")
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
GetTickCount( GetTickCount(
VOID VOID
); );
#if (_WIN32_WINNT >= 0x0600)
WINBASEAPI WINBASEAPI
ULONGLONG ULONGLONG
WINAPI WINAPI
GetTickCount64( GetTickCount64(
VOID VOID
); );
#endif
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
SetSystemTimeAdjustment( SetSystemTimeAdjustment(
__in DWORD dwTimeAdjustment, __in DWORD dwTimeAdjustment,
__in BOOL bTimeAdjustmentDisabled __in BOOL bTimeAdjustmentDisabled
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
skipping to change at line 5622 skipping to change at line 6102
#if defined(DEPRECATE_SUPPORTED) #if defined(DEPRECATE_SUPPORTED)
#pragma warning(push) #pragma warning(push)
#pragma warning(disable:4995) #pragma warning(disable:4995)
#endif #endif
WINBASEAPI WINBASEAPI
__out __out
LPSTR LPSTR
WINAPI WINAPI
lstrcpyA( lstrcpyA(
__out LPSTR lpString1, __out_z LPSTR lpString1, // deprecated: annotation is as good as it gets
__in LPCSTR lpString2 __in LPCSTR lpString2
); );
WINBASEAPI WINBASEAPI
__out __out
LPWSTR LPWSTR
WINAPI WINAPI
lstrcpyW( lstrcpyW(
__out LPWSTR lpString1, __out_z LPWSTR lpString1, // deprecated: annotation is as good as it gets
__in LPCWSTR lpString2 __in LPCWSTR lpString2
); );
#ifdef UNICODE #ifdef UNICODE
#define lstrcpy lstrcpyW #define lstrcpy lstrcpyW
#else #else
#define lstrcpy lstrcpyA #define lstrcpy lstrcpyA
#endif // !UNICODE #endif // !UNICODE
WINBASEAPI WINBASEAPI
__out __out
skipping to change at line 6015 skipping to change at line 6495
#define STARTF_USECOUNTCHARS 0x00000008 #define STARTF_USECOUNTCHARS 0x00000008
#define STARTF_USEFILLATTRIBUTE 0x00000010 #define STARTF_USEFILLATTRIBUTE 0x00000010
#define STARTF_RUNFULLSCREEN 0x00000020 // ignored for non-x86 platforms #define STARTF_RUNFULLSCREEN 0x00000020 // ignored for non-x86 platforms
#define STARTF_FORCEONFEEDBACK 0x00000040 #define STARTF_FORCEONFEEDBACK 0x00000040
#define STARTF_FORCEOFFFEEDBACK 0x00000080 #define STARTF_FORCEOFFFEEDBACK 0x00000080
#define STARTF_USESTDHANDLES 0x00000100 #define STARTF_USESTDHANDLES 0x00000100
#if(WINVER >= 0x0400) #if(WINVER >= 0x0400)
#define STARTF_USEHOTKEY 0x00000200 #define STARTF_USEHOTKEY 0x00000200
#define STARTF_TITLEISLINKNAME 0x00000800
#define STARTF_TITLEISAPPID 0x00001000
#define STARTF_PREVENTPINNING 0x00002000
#endif /* WINVER >= 0x0400 */ #endif /* WINVER >= 0x0400 */
typedef struct _STARTUPINFOA { typedef struct _STARTUPINFOA {
DWORD cb; DWORD cb;
LPSTR lpReserved; LPSTR lpReserved;
LPSTR lpDesktop; LPSTR lpDesktop;
LPSTR lpTitle; LPSTR lpTitle;
DWORD dwX; DWORD dwX;
DWORD dwY; DWORD dwY;
DWORD dwXSize; DWORD dwXSize;
skipping to change at line 6065 skipping to change at line 6548
HANDLE hStdError; HANDLE hStdError;
} STARTUPINFOW, *LPSTARTUPINFOW; } STARTUPINFOW, *LPSTARTUPINFOW;
#ifdef UNICODE #ifdef UNICODE
typedef STARTUPINFOW STARTUPINFO; typedef STARTUPINFOW STARTUPINFO;
typedef LPSTARTUPINFOW LPSTARTUPINFO; typedef LPSTARTUPINFOW LPSTARTUPINFO;
#else #else
typedef STARTUPINFOA STARTUPINFO; typedef STARTUPINFOA STARTUPINFO;
typedef LPSTARTUPINFOA LPSTARTUPINFO; typedef LPSTARTUPINFOA LPSTARTUPINFO;
#endif // UNICODE #endif // UNICODE
#if (_WIN32_WINNT >= 0x0600)
typedef struct _STARTUPINFOEXA { typedef struct _STARTUPINFOEXA {
STARTUPINFOA StartupInfo; STARTUPINFOA StartupInfo;
struct _PROC_THREAD_ATTRIBUTE_LIST *lpAttributeList; LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList;
} STARTUPINFOEXA, *LPSTARTUPINFOEXA; } STARTUPINFOEXA, *LPSTARTUPINFOEXA;
typedef struct _STARTUPINFOEXW { typedef struct _STARTUPINFOEXW {
STARTUPINFOW StartupInfo; STARTUPINFOW StartupInfo;
struct _PROC_THREAD_ATTRIBUTE_LIST *lpAttributeList; LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList;
} STARTUPINFOEXW, *LPSTARTUPINFOEXW; } STARTUPINFOEXW, *LPSTARTUPINFOEXW;
#ifdef UNICODE #ifdef UNICODE
typedef STARTUPINFOEXW STARTUPINFOEX; typedef STARTUPINFOEXW STARTUPINFOEX;
typedef LPSTARTUPINFOEXW LPSTARTUPINFOEX; typedef LPSTARTUPINFOEXW LPSTARTUPINFOEX;
#else #else
typedef STARTUPINFOEXA STARTUPINFOEX; typedef STARTUPINFOEXA STARTUPINFOEX;
typedef LPSTARTUPINFOEXA LPSTARTUPINFOEX; typedef LPSTARTUPINFOEXA LPSTARTUPINFOEX;
#endif // UNICODE #endif // UNICODE
#endif // (_WIN32_WINNT >= 0x0600)
#define SHUTDOWN_NORETRY 0x00000001 #define SHUTDOWN_NORETRY 0x00000001
typedef struct _WIN32_FIND_DATAA { typedef struct _WIN32_FIND_DATAA {
DWORD dwFileAttributes; DWORD dwFileAttributes;
FILETIME ftCreationTime; FILETIME ftCreationTime;
FILETIME ftLastAccessTime; FILETIME ftLastAccessTime;
FILETIME ftLastWriteTime; FILETIME ftLastWriteTime;
DWORD nFileSizeHigh; DWORD nFileSizeHigh;
DWORD nFileSizeLow; DWORD nFileSizeLow;
DWORD dwReserved0; DWORD dwReserved0;
skipping to change at line 6345 skipping to change at line 6832
__in DWORD dwDesiredAccess, __in DWORD dwDesiredAccess,
__in BOOL bInheritHandle, __in BOOL bInheritHandle,
__in LPCWSTR lpTimerName __in LPCWSTR lpTimerName
); );
#ifdef UNICODE #ifdef UNICODE
#define OpenWaitableTimer OpenWaitableTimerW #define OpenWaitableTimer OpenWaitableTimerW
#else #else
#define OpenWaitableTimer OpenWaitableTimerA #define OpenWaitableTimer OpenWaitableTimerA
#endif // !UNICODE #endif // !UNICODE
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN7)
BOOL
WINAPI
SetWaitableTimerEx(
__in HANDLE hTimer,
__in const LARGE_INTEGER *lpDueTime,
__in LONG lPeriod,
__in_opt PTIMERAPCROUTINE pfnCompletionRoutine,
__in_opt LPVOID lpArgToCompletionRoutine,
__in_opt PREASON_CONTEXT WakeContext,
__in ULONG TolerableDelay
);
#endif // (_WIN32_WINNT >= _WIN32_WINNT_WIN7)
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
SetWaitableTimer( SetWaitableTimer(
__in HANDLE hTimer, __in HANDLE hTimer,
__in const LARGE_INTEGER *lpDueTime, __in const LARGE_INTEGER *lpDueTime,
__in LONG lPeriod, __in LONG lPeriod,
__in_opt PTIMERAPCROUTINE pfnCompletionRoutine, __in_opt PTIMERAPCROUTINE pfnCompletionRoutine,
__in_opt LPVOID lpArgToCompletionRoutine, __in_opt LPVOID lpArgToCompletionRoutine,
__in BOOL fResume __in BOOL fResume
skipping to change at line 6670 skipping to change at line 7173
#else #else
#define LoadLibraryEx LoadLibraryExA #define LoadLibraryEx LoadLibraryExA
#endif // !UNICODE #endif // !UNICODE
#define DONT_RESOLVE_DLL_REFERENCES 0x00000001 #define DONT_RESOLVE_DLL_REFERENCES 0x00000001
#define LOAD_LIBRARY_AS_DATAFILE 0x00000002 #define LOAD_LIBRARY_AS_DATAFILE 0x00000002
#define LOAD_WITH_ALTERED_SEARCH_PATH 0x00000008 #define LOAD_WITH_ALTERED_SEARCH_PATH 0x00000008
#define LOAD_IGNORE_CODE_AUTHZ_LEVEL 0x00000010 #define LOAD_IGNORE_CODE_AUTHZ_LEVEL 0x00000010
#define LOAD_LIBRARY_AS_IMAGE_RESOURCE 0x00000020 #define LOAD_LIBRARY_AS_IMAGE_RESOURCE 0x00000020
#define LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE 0x00000040 #define LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE 0x00000040
#define LOAD_LIBRARY_REQUIRE_SIGNED_TARGET 0x00000080
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
GetModuleFileNameA( GetModuleFileNameA(
__in_opt HMODULE hModule, __in_opt HMODULE hModule,
__out_ecount_part(nSize, return + 1) LPCH lpFilename, __out_ecount_part(nSize, return + 1) LPSTR lpFilename,
__in DWORD nSize __in DWORD nSize
); );
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
GetModuleFileNameW( GetModuleFileNameW(
__in_opt HMODULE hModule, __in_opt HMODULE hModule,
__out_ecount_part(nSize, return + 1) LPWCH lpFilename, __out_ecount_part(nSize, return + 1) LPWSTR lpFilename,
__in DWORD nSize __in DWORD nSize
); );
#ifdef UNICODE #ifdef UNICODE
#define GetModuleFileName GetModuleFileNameW #define GetModuleFileName GetModuleFileNameW
#else #else
#define GetModuleFileName GetModuleFileNameA #define GetModuleFileName GetModuleFileNameA
#endif // !UNICODE #endif // !UNICODE
WINBASEAPI WINBASEAPI
__out_opt __out_opt
skipping to change at line 6819 skipping to change at line 7323
__inout PDWORD lpdwSize __inout PDWORD lpdwSize
); );
#ifdef UNICODE #ifdef UNICODE
#define QueryFullProcessImageName QueryFullProcessImageNameW #define QueryFullProcessImageName QueryFullProcessImageNameW
#else #else
#define QueryFullProcessImageName QueryFullProcessImageNameA #define QueryFullProcessImageName QueryFullProcessImageNameA
#endif // !UNICODE #endif // !UNICODE
#endif #endif
#if (_WIN32_WINNT >= 0x0600)
// //
// Extended process and thread attribute support // Extended process and thread attribute support
// //
#define PROC_THREAD_ATTRIBUTE_NUMBER 0x0000FFFF #define PROC_THREAD_ATTRIBUTE_NUMBER 0x0000FFFF
#define PROC_THREAD_ATTRIBUTE_THREAD 0x00010000 // Attribute may be used wit h thread creation #define PROC_THREAD_ATTRIBUTE_THREAD 0x00010000 // Attribute may be used wit h thread creation
#define PROC_THREAD_ATTRIBUTE_INPUT 0x00020000 // Attribute is input only #define PROC_THREAD_ATTRIBUTE_INPUT 0x00020000 // Attribute is input only
#define PROC_THREAD_ATTRIBUTE_ADDITIVE 0x00040000 // Attribute may be "accumul ated," e.g. bitmasks, counters, etc. #define PROC_THREAD_ATTRIBUTE_ADDITIVE 0x00040000 // Attribute may be "accumul ated," e.g. bitmasks, counters, etc.
typedef enum _PROC_THREAD_ATTRIBUTE_NUM { typedef enum _PROC_THREAD_ATTRIBUTE_NUM {
ProcThreadAttributeParentProcess = 0, ProcThreadAttributeParentProcess = 0,
ProcThreadAttributeExtendedFlags, ProcThreadAttributeExtendedFlags,
ProcThreadAttributeHandleList, ProcThreadAttributeHandleList,
ProcThreadAttributeGroupAffinity,
ProcThreadAttributePreferredNode,
ProcThreadAttributeIdealProcessor,
ProcThreadAttributeUmsThread,
ProcThreadAttributeMitigationPolicy,
ProcThreadAttributeMax ProcThreadAttributeMax
} PROC_THREAD_ATTRIBUTE_NUM; } PROC_THREAD_ATTRIBUTE_NUM;
#define ProcThreadAttributeValue(Number, Thread, Input, Additive) \ #define ProcThreadAttributeValue(Number, Thread, Input, Additive) \
(((Number) & PROC_THREAD_ATTRIBUTE_NUMBER) | \ (((Number) & PROC_THREAD_ATTRIBUTE_NUMBER) | \
((Thread != FALSE) ? PROC_THREAD_ATTRIBUTE_THREAD : 0) | \ ((Thread != FALSE) ? PROC_THREAD_ATTRIBUTE_THREAD : 0) | \
((Input != FALSE) ? PROC_THREAD_ATTRIBUTE_INPUT : 0) | \ ((Input != FALSE) ? PROC_THREAD_ATTRIBUTE_INPUT : 0) | \
((Additive != FALSE) ? PROC_THREAD_ATTRIBUTE_ADDITIVE : 0)) ((Additive != FALSE) ? PROC_THREAD_ATTRIBUTE_ADDITIVE : 0))
#define PROC_THREAD_ATTRIBUTE_PARENT_PROCESS \ #define PROC_THREAD_ATTRIBUTE_PARENT_PROCESS \
ProcThreadAttributeValue (ProcThreadAttributeParentProcess, FALSE, TRUE, FAL SE) ProcThreadAttributeValue (ProcThreadAttributeParentProcess, FALSE, TRUE, FAL SE)
#define PROC_THREAD_ATTRIBUTE_EXTENDED_FLAGS \ #define PROC_THREAD_ATTRIBUTE_EXTENDED_FLAGS \
ProcThreadAttributeValue (ProcThreadAttributeExtendedFlags, FALSE, TRUE, TRU E) ProcThreadAttributeValue (ProcThreadAttributeExtendedFlags, FALSE, TRUE, TRU E)
#define PROC_THREAD_ATTRIBUTE_HANDLE_LIST \ #define PROC_THREAD_ATTRIBUTE_HANDLE_LIST \
ProcThreadAttributeValue (ProcThreadAttributeHandleList, FALSE, TRUE, FALSE) ProcThreadAttributeValue (ProcThreadAttributeHandleList, FALSE, TRUE, FALSE)
#define PROC_THREAD_ATTRIBUTE_GROUP_AFFINITY \
ProcThreadAttributeValue (ProcThreadAttributeGroupAffinity, TRUE, TRUE, FALS
E)
#define PROC_THREAD_ATTRIBUTE_PREFERRED_NODE \
ProcThreadAttributeValue (ProcThreadAttributePreferredNode, FALSE, TRUE, FAL
SE)
#define PROC_THREAD_ATTRIBUTE_IDEAL_PROCESSOR \
ProcThreadAttributeValue (ProcThreadAttributeIdealProcessor, TRUE, TRUE, FAL
SE)
#define PROC_THREAD_ATTRIBUTE_UMS_THREAD \
ProcThreadAttributeValue (ProcThreadAttributeUmsThread, TRUE, TRUE, FALSE)
#define PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY \
ProcThreadAttributeValue (ProcThreadAttributeMitigationPolicy, FALSE, TRUE,
FALSE)
typedef struct _PROC_THREAD_ATTRIBUTE_LIST *PPROC_THREAD_ATTRIBUTE_LIST, *LPPROC #define PROCESS_CREATION_MITIGATION_POLICY_DEP_ENABLE 0x01
_THREAD_ATTRIBUTE_LIST; #define PROCESS_CREATION_MITIGATION_POLICY_DEP_ATL_THUNK_ENABLE 0x02
#define PROCESS_CREATION_MITIGATION_POLICY_SEHOP_ENABLE 0x04
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
InitializeProcThreadAttributeList( InitializeProcThreadAttributeList(
__out_xcount_opt(*lpSize) LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList, __out_xcount_opt(*lpSize) LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,
__in DWORD dwAttributeCount, __in DWORD dwAttributeCount,
__in __reserved DWORD dwFlags, __reserved DWORD dwFlags,
__inout PSIZE_T lpSize __inout PSIZE_T lpSize
); );
WINBASEAPI WINBASEAPI
VOID VOID
WINAPI WINAPI
DeleteProcThreadAttributeList( DeleteProcThreadAttributeList(
__inout LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList __inout LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList
); );
skipping to change at line 6882 skipping to change at line 7405
UpdateProcThreadAttribute( UpdateProcThreadAttribute(
__inout LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList, __inout LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,
__in DWORD dwFlags, __in DWORD dwFlags,
__in DWORD_PTR Attribute, __in DWORD_PTR Attribute,
__in_bcount_opt(cbSize) PVOID lpValue, __in_bcount_opt(cbSize) PVOID lpValue,
__in SIZE_T cbSize, __in SIZE_T cbSize,
__out_bcount_opt(cbSize) PVOID lpPreviousValue, __out_bcount_opt(cbSize) PVOID lpPreviousValue,
__in_opt PSIZE_T lpReturnSize __in_opt PSIZE_T lpReturnSize
); );
#endif // (_WIN32_WINNT >= 0x0600)
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
CreateProcessA( CreateProcessA(
__in_opt LPCSTR lpApplicationName, __in_opt LPCSTR lpApplicationName,
__inout_opt LPSTR lpCommandLine, __inout_opt LPSTR lpCommandLine,
__in_opt LPSECURITY_ATTRIBUTES lpProcessAttributes, __in_opt LPSECURITY_ATTRIBUTES lpProcessAttributes,
__in_opt LPSECURITY_ATTRIBUTES lpThreadAttributes, __in_opt LPSECURITY_ATTRIBUTES lpThreadAttributes,
__in BOOL bInheritHandles, __in BOOL bInheritHandles,
__in DWORD dwCreationFlags, __in DWORD dwCreationFlags,
skipping to change at line 7025 skipping to change at line 7550
__in_opt LPCWSTR lpName, __in_opt LPCWSTR lpName,
__out_ecount_part_opt(nSize, return + 1) LPWSTR lpBuffer, __out_ecount_part_opt(nSize, return + 1) LPWSTR lpBuffer,
__in DWORD nSize __in DWORD nSize
); );
#ifdef UNICODE #ifdef UNICODE
#define GetEnvironmentVariable GetEnvironmentVariableW #define GetEnvironmentVariable GetEnvironmentVariableW
#else #else
#define GetEnvironmentVariable GetEnvironmentVariableA #define GetEnvironmentVariable GetEnvironmentVariableA
#endif // !UNICODE #endif // !UNICODE
#if defined(_M_CEE)
#undef GetEnvironmentVariable
__inline
DWORD
GetEnvironmentVariable(
__in_opt LPCTSTR lpName,
__out_ecount_part_opt(nSize, return + 1) LPTSTR lpBuffer,
__in DWORD nSize
)
{
#ifdef UNICODE
return GetEnvironmentVariableW(
#else
return GetEnvironmentVariableA(
#endif
lpName,
lpBuffer,
nSize
);
}
#endif /* _M_CEE */
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
SetEnvironmentVariableA( SetEnvironmentVariableA(
__in LPCSTR lpName, __in LPCSTR lpName,
__in_opt LPCSTR lpValue __in_opt LPCSTR lpValue
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
skipping to change at line 7334 skipping to change at line 7881
); );
#ifdef UNICODE #ifdef UNICODE
#define EnumResourceLanguages EnumResourceLanguagesW #define EnumResourceLanguages EnumResourceLanguagesW
#else #else
#define EnumResourceLanguages EnumResourceLanguagesA #define EnumResourceLanguages EnumResourceLanguagesA
#endif // !UNICODE #endif // !UNICODE
#define RESOURCE_ENUM_LN (0x0001) #define RESOURCE_ENUM_LN (0x0001)
#define RESOURCE_ENUM_MUI (0x0002) #define RESOURCE_ENUM_MUI (0x0002)
#define RESOURCE_ENUM_MUI_SYSTEM (0x0004) #define RESOURCE_ENUM_MUI_SYSTEM (0x0004)
#define RESOURCE_UPDATE_LN (0x0010) #define RESOURCE_ENUM_VALIDATE (0x0008)
#define RESOURCE_UPDATE_MUI (0x0020) #define RESOURCE_ENUM_MODULE_EXACT (0x0010)
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
EnumResourceTypesExA( EnumResourceTypesExA(
__in_opt HMODULE hModule, __in_opt HMODULE hModule,
__in ENUMRESTYPEPROCA lpEnumFunc, __in ENUMRESTYPEPROCA lpEnumFunc,
__in LONG_PTR lParam, __in LONG_PTR lParam,
DWORD dwFlags, DWORD dwFlags,
LANGID LangId LANGID LangId
skipping to change at line 7741 skipping to change at line 8288
__in LPCWSTR lpKeyName, __in LPCWSTR lpKeyName,
__in INT nDefault, __in INT nDefault,
__in_opt LPCWSTR lpFileName __in_opt LPCWSTR lpFileName
); );
#ifdef UNICODE #ifdef UNICODE
#define GetPrivateProfileInt GetPrivateProfileIntW #define GetPrivateProfileInt GetPrivateProfileIntW
#else #else
#define GetPrivateProfileInt GetPrivateProfileIntA #define GetPrivateProfileInt GetPrivateProfileIntA
#endif // !UNICODE #endif // !UNICODE
#if defined(_M_CEE)
#undef GetPrivateProfileInt
__inline
UINT
GetPrivateProfileInt(
LPCTSTR lpAppName,
LPCTSTR lpKeyName,
INT nDefault,
LPCTSTR lpFileName
)
{
#ifdef UNICODE
return GetPrivateProfileIntW(
#else
return GetPrivateProfileIntA(
#endif
lpAppName,
lpKeyName,
nDefault,
lpFileName
);
}
#endif /* _M_CEE */
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
GetPrivateProfileStringA( GetPrivateProfileStringA(
__in_opt LPCSTR lpAppName, __in_opt LPCSTR lpAppName,
__in_opt LPCSTR lpKeyName, __in_opt LPCSTR lpKeyName,
__in_opt LPCSTR lpDefault, __in_opt LPCSTR lpDefault,
__out_ecount_part_opt(nSize, return + 1) LPSTR lpReturnedString, __out_ecount_part_opt(nSize, return + 1) LPSTR lpReturnedString,
__in DWORD nSize, __in DWORD nSize,
__in_opt LPCSTR lpFileName __in_opt LPCSTR lpFileName
skipping to change at line 7769 skipping to change at line 8340
__out_ecount_part_opt(nSize, return + 1) LPWSTR lpReturnedString, __out_ecount_part_opt(nSize, return + 1) LPWSTR lpReturnedString,
__in DWORD nSize, __in DWORD nSize,
__in_opt LPCWSTR lpFileName __in_opt LPCWSTR lpFileName
); );
#ifdef UNICODE #ifdef UNICODE
#define GetPrivateProfileString GetPrivateProfileStringW #define GetPrivateProfileString GetPrivateProfileStringW
#else #else
#define GetPrivateProfileString GetPrivateProfileStringA #define GetPrivateProfileString GetPrivateProfileStringA
#endif // !UNICODE #endif // !UNICODE
#if defined(_M_CEE)
#undef GetPrivateProfileString
__inline
DWORD
GetPrivateProfileString(
LPCTSTR lpAppName,
LPCTSTR lpKeyName,
LPCTSTR lpDefault,
LPTSTR lpReturnedString,
DWORD nSize,
LPCTSTR lpFileName
)
{
#ifdef UNICODE
return GetPrivateProfileStringW(
#else
return GetPrivateProfileStringA(
#endif
lpAppName,
lpKeyName,
lpDefault,
lpReturnedString,
nSize,
lpFileName
);
}
#endif /* _M_CEE */
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
WritePrivateProfileStringA( WritePrivateProfileStringA(
__in_opt LPCSTR lpAppName, __in_opt LPCSTR lpAppName,
__in_opt LPCSTR lpKeyName, __in_opt LPCSTR lpKeyName,
__in_opt LPCSTR lpString, __in_opt LPCSTR lpString,
__in_opt LPCSTR lpFileName __in_opt LPCSTR lpFileName
); );
WINBASEAPI WINBASEAPI
skipping to change at line 7817 skipping to change at line 8416
__out_ecount_part_opt(nSize, return + 1) LPWSTR lpReturnedString, __out_ecount_part_opt(nSize, return + 1) LPWSTR lpReturnedString,
__in DWORD nSize, __in DWORD nSize,
__in_opt LPCWSTR lpFileName __in_opt LPCWSTR lpFileName
); );
#ifdef UNICODE #ifdef UNICODE
#define GetPrivateProfileSection GetPrivateProfileSectionW #define GetPrivateProfileSection GetPrivateProfileSectionW
#else #else
#define GetPrivateProfileSection GetPrivateProfileSectionA #define GetPrivateProfileSection GetPrivateProfileSectionA
#endif // !UNICODE #endif // !UNICODE
#if defined(_M_CEE)
#undef GetPrivateProfileSection
__inline
DWORD
GetPrivateProfileSection(
LPCTSTR lpAppName,
LPTSTR lpReturnedString,
DWORD nSize,
LPCTSTR lpFileName
)
{
#ifdef UNICODE
return GetPrivateProfileSectionW(
#else
return GetPrivateProfileSectionA(
#endif
lpAppName,
lpReturnedString,
nSize,
lpFileName
);
}
#endif /* _M_CEE */
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
WritePrivateProfileSectionA( WritePrivateProfileSectionA(
__in LPCSTR lpAppName, __in_opt LPCSTR lpAppName,
__in LPCSTR lpString, __in_opt LPCSTR lpString,
__in_opt LPCSTR lpFileName __in_opt LPCSTR lpFileName
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
WritePrivateProfileSectionW( WritePrivateProfileSectionW(
__in LPCWSTR lpAppName, __in_opt LPCWSTR lpAppName,
__in LPCWSTR lpString, __in_opt LPCWSTR lpString,
__in_opt LPCWSTR lpFileName __in_opt LPCWSTR lpFileName
); );
#ifdef UNICODE #ifdef UNICODE
#define WritePrivateProfileSection WritePrivateProfileSectionW #define WritePrivateProfileSection WritePrivateProfileSectionW
#else #else
#define WritePrivateProfileSection WritePrivateProfileSectionA #define WritePrivateProfileSection WritePrivateProfileSectionA
#endif // !UNICODE #endif // !UNICODE
WINBASEAPI WINBASEAPI
DWORD DWORD
skipping to change at line 7861 skipping to change at line 8484
__out_ecount_part_opt(nSize, return + 1) LPWSTR lpszReturnBuffer, __out_ecount_part_opt(nSize, return + 1) LPWSTR lpszReturnBuffer,
__in DWORD nSize, __in DWORD nSize,
__in_opt LPCWSTR lpFileName __in_opt LPCWSTR lpFileName
); );
#ifdef UNICODE #ifdef UNICODE
#define GetPrivateProfileSectionNames GetPrivateProfileSectionNamesW #define GetPrivateProfileSectionNames GetPrivateProfileSectionNamesW
#else #else
#define GetPrivateProfileSectionNames GetPrivateProfileSectionNamesA #define GetPrivateProfileSectionNames GetPrivateProfileSectionNamesA
#endif // !UNICODE #endif // !UNICODE
#if defined(_M_CEE)
#undef GetPrivateProfileSectionNames
__inline
DWORD
GetPrivateProfileSectionNames(
LPTSTR lpszReturnBuffer,
DWORD nSize,
LPCTSTR lpFileName
)
{
#ifdef UNICODE
return GetPrivateProfileSectionNamesW(
#else
return GetPrivateProfileSectionNamesA(
#endif
lpszReturnBuffer,
nSize,
lpFileName
);
}
#endif /* _M_CEE */
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetPrivateProfileStructA( GetPrivateProfileStructA(
__in LPCSTR lpszSection, __in LPCSTR lpszSection,
__in LPCSTR lpszKey, __in LPCSTR lpszKey,
__out_bcount_opt(uSizeStruct) LPVOID lpStruct, __out_bcount_opt(uSizeStruct) LPVOID lpStruct,
__in UINT uSizeStruct, __in UINT uSizeStruct,
__in_opt LPCSTR szFile __in_opt LPCSTR szFile
); );
skipping to change at line 7887 skipping to change at line 8532
__out_bcount_opt(uSizeStruct) LPVOID lpStruct, __out_bcount_opt(uSizeStruct) LPVOID lpStruct,
__in UINT uSizeStruct, __in UINT uSizeStruct,
__in_opt LPCWSTR szFile __in_opt LPCWSTR szFile
); );
#ifdef UNICODE #ifdef UNICODE
#define GetPrivateProfileStruct GetPrivateProfileStructW #define GetPrivateProfileStruct GetPrivateProfileStructW
#else #else
#define GetPrivateProfileStruct GetPrivateProfileStructA #define GetPrivateProfileStruct GetPrivateProfileStructA
#endif // !UNICODE #endif // !UNICODE
#if defined(_M_CEE)
#undef GetPrivateProfileStruct
__inline
BOOL
GetPrivateProfileStruct(
LPCTSTR lpszSection,
LPCTSTR lpszKey,
LPVOID lpStruct,
UINT uSizeStruct,
LPCTSTR szFile
)
{
#ifdef UNICODE
return GetPrivateProfileStructW(
#else
return GetPrivateProfileStructA(
#endif
lpszSection,
lpszKey,
lpStruct,
uSizeStruct,
szFile
);
}
#endif /* _M_CEE */
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
WritePrivateProfileStructA( WritePrivateProfileStructA(
__in LPCSTR lpszSection, __in LPCSTR lpszSection,
__in LPCSTR lpszKey, __in LPCSTR lpszKey,
__in_bcount_opt(uSizeStruct) LPVOID lpStruct, __in_bcount_opt(uSizeStruct) LPVOID lpStruct,
__in UINT uSizeStruct, __in UINT uSizeStruct,
__in_opt LPCSTR szFile __in_opt LPCSTR szFile
); );
skipping to change at line 8190 skipping to change at line 8861
GetCurrentDirectoryW( GetCurrentDirectoryW(
__in DWORD nBufferLength, __in DWORD nBufferLength,
__out_ecount_part_opt(nBufferLength, return + 1) LPWSTR lpBuffer __out_ecount_part_opt(nBufferLength, return + 1) LPWSTR lpBuffer
); );
#ifdef UNICODE #ifdef UNICODE
#define GetCurrentDirectory GetCurrentDirectoryW #define GetCurrentDirectory GetCurrentDirectoryW
#else #else
#define GetCurrentDirectory GetCurrentDirectoryA #define GetCurrentDirectory GetCurrentDirectoryA
#endif // !UNICODE #endif // !UNICODE
#if defined(_M_CEE)
#undef GetCurrentDirectory
__inline
DWORD
GetCurrentDirectory(
DWORD nBufferLength,
LPTSTR lpBuffer
)
{
#ifdef UNICODE
return GetCurrentDirectoryW(
#else
return GetCurrentDirectoryA(
#endif
nBufferLength,
lpBuffer
);
}
#endif /* _M_CEE */
#if _WIN32_WINNT >= 0x0502 #if _WIN32_WINNT >= 0x0502
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
SetDllDirectoryA( SetDllDirectoryA(
__in_opt LPCSTR lpPathName __in_opt LPCSTR lpPathName
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
skipping to change at line 8232 skipping to change at line 8923
__out_ecount_part_opt(nBufferLength, return + 1) LPWSTR lpBuffer __out_ecount_part_opt(nBufferLength, return + 1) LPWSTR lpBuffer
); );
#ifdef UNICODE #ifdef UNICODE
#define GetDllDirectory GetDllDirectoryW #define GetDllDirectory GetDllDirectoryW
#else #else
#define GetDllDirectory GetDllDirectoryA #define GetDllDirectory GetDllDirectoryA
#endif // !UNICODE #endif // !UNICODE
#endif // _WIN32_WINNT >= 0x0502 #endif // _WIN32_WINNT >= 0x0502
#define BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE 0x1
#define BASE_SEARCH_PATH_DISABLE_SAFE_SEARCHMODE 0x10000
#define BASE_SEARCH_PATH_PERMANENT 0x8000
#define BASE_SEARCH_PATH_INVALID_FLAGS ~0x18001
WINBASEAPI
BOOL
WINAPI
SetSearchPathMode (
__in DWORD Flags
);
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetDiskFreeSpaceA( GetDiskFreeSpaceA(
__in_opt LPCSTR lpRootPathName, __in_opt LPCSTR lpRootPathName,
__out_opt LPDWORD lpSectorsPerCluster, __out_opt LPDWORD lpSectorsPerCluster,
__out_opt LPDWORD lpBytesPerSector, __out_opt LPDWORD lpBytesPerSector,
__out_opt LPDWORD lpNumberOfFreeClusters, __out_opt LPDWORD lpNumberOfFreeClusters,
__out_opt LPDWORD lpTotalNumberOfClusters __out_opt LPDWORD lpTotalNumberOfClusters
); );
skipping to change at line 8350 skipping to change at line 9053
#else #else
#define CreateDirectoryEx CreateDirectoryExA #define CreateDirectoryEx CreateDirectoryExA
#endif // !UNICODE #endif // !UNICODE
#if _WIN32_WINNT >= 0x0600 #if _WIN32_WINNT >= 0x0600
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
CreateDirectoryTransactedA( CreateDirectoryTransactedA(
__in LPCSTR lpTemplateDirectory, __in_opt LPCSTR lpTemplateDirectory,
__in LPCSTR lpNewDirectory, __in LPCSTR lpNewDirectory,
__in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes, __in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes,
__in HANDLE hTransaction __in HANDLE hTransaction
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
CreateDirectoryTransactedW( CreateDirectoryTransactedW(
__in LPCWSTR lpTemplateDirectory, __in_opt LPCWSTR lpTemplateDirectory,
__in LPCWSTR lpNewDirectory, __in LPCWSTR lpNewDirectory,
__in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes, __in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes,
__in HANDLE hTransaction __in HANDLE hTransaction
); );
#ifdef UNICODE #ifdef UNICODE
#define CreateDirectoryTransacted CreateDirectoryTransactedW #define CreateDirectoryTransacted CreateDirectoryTransactedW
#else #else
#define CreateDirectoryTransacted CreateDirectoryTransactedA #define CreateDirectoryTransacted CreateDirectoryTransactedA
#endif // !UNICODE #endif // !UNICODE
skipping to change at line 8866 skipping to change at line 9569
#define CheckNameLegalDOS8Dot3 CheckNameLegalDOS8Dot3W #define CheckNameLegalDOS8Dot3 CheckNameLegalDOS8Dot3W
#else #else
#define CheckNameLegalDOS8Dot3 CheckNameLegalDOS8Dot3A #define CheckNameLegalDOS8Dot3 CheckNameLegalDOS8Dot3A
#endif // !UNICODE #endif // !UNICODE
#endif // (_WIN32_WINNT >= 0x0501) #endif // (_WIN32_WINNT >= 0x0501)
#if(_WIN32_WINNT >= 0x0400) #if(_WIN32_WINNT >= 0x0400)
typedef enum _FINDEX_INFO_LEVELS { typedef enum _FINDEX_INFO_LEVELS {
FindExInfoStandard, FindExInfoStandard,
FindExInfoBasic,
FindExInfoMaxInfoLevel FindExInfoMaxInfoLevel
} FINDEX_INFO_LEVELS; } FINDEX_INFO_LEVELS;
typedef enum _FINDEX_SEARCH_OPS { typedef enum _FINDEX_SEARCH_OPS {
FindExSearchNameMatch, FindExSearchNameMatch,
FindExSearchLimitToDirectories, FindExSearchLimitToDirectories,
FindExSearchLimitToDevices, FindExSearchLimitToDevices,
FindExSearchMaxSearchOp FindExSearchMaxSearchOp
} FINDEX_SEARCH_OPS; } FINDEX_SEARCH_OPS;
#define FIND_FIRST_EX_CASE_SENSITIVE 0x00000001 #define FIND_FIRST_EX_CASE_SENSITIVE 0x00000001
#define FIND_FIRST_EX_LARGE_FETCH 0x00000002
WINBASEAPI WINBASEAPI
__out __out
HANDLE HANDLE
WINAPI WINAPI
FindFirstFileExA( FindFirstFileExA(
__in LPCSTR lpFileName, __in LPCSTR lpFileName,
__in FINDEX_INFO_LEVELS fInfoLevelId, __in FINDEX_INFO_LEVELS fInfoLevelId,
__out LPVOID lpFindFileData, __out LPVOID lpFindFileData,
__in FINDEX_SEARCH_OPS fSearchOp, __in FINDEX_SEARCH_OPS fSearchOp,
skipping to change at line 9268 skipping to change at line 9973
#define MOVEFILE_REPLACE_EXISTING 0x00000001 #define MOVEFILE_REPLACE_EXISTING 0x00000001
#define MOVEFILE_COPY_ALLOWED 0x00000002 #define MOVEFILE_COPY_ALLOWED 0x00000002
#define MOVEFILE_DELAY_UNTIL_REBOOT 0x00000004 #define MOVEFILE_DELAY_UNTIL_REBOOT 0x00000004
#define MOVEFILE_WRITE_THROUGH 0x00000008 #define MOVEFILE_WRITE_THROUGH 0x00000008
#if (_WIN32_WINNT >= 0x0500) #if (_WIN32_WINNT >= 0x0500)
#define MOVEFILE_CREATE_HARDLINK 0x00000010 #define MOVEFILE_CREATE_HARDLINK 0x00000010
#define MOVEFILE_FAIL_IF_NOT_TRACKABLE 0x00000020 #define MOVEFILE_FAIL_IF_NOT_TRACKABLE 0x00000020
#endif // (_WIN32_WINNT >= 0x0500) #endif // (_WIN32_WINNT >= 0x0500)
#if (_WIN32_WINNT >= 0x0500) #if (_WIN32_WINNT >= 0x0500)
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
ReplaceFileA( ReplaceFileA(
__in LPCSTR lpReplacedFileName, __in LPCSTR lpReplacedFileName,
__in LPCSTR lpReplacementFileName, __in LPCSTR lpReplacementFileName,
__in_opt LPCSTR lpBackupFileName, __in_opt LPCSTR lpBackupFileName,
__in DWORD dwReplaceFlags, __in DWORD dwReplaceFlags,
__reserved LPVOID lpExclude, __reserved LPVOID lpExclude,
__reserved LPVOID lpReserved __reserved LPVOID lpReserved
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
ReplaceFileW( ReplaceFileW(
__in LPCWSTR lpReplacedFileName, __in LPCWSTR lpReplacedFileName,
__in LPCWSTR lpReplacementFileName, __in LPCWSTR lpReplacementFileName,
__in_opt LPCWSTR lpBackupFileName, __in_opt LPCWSTR lpBackupFileName,
__in DWORD dwReplaceFlags, __in DWORD dwReplaceFlags,
__reserved LPVOID lpExclude, __reserved LPVOID lpExclude,
__reserved LPVOID lpReserved __reserved LPVOID lpReserved
); );
#ifdef UNICODE #ifdef UNICODE
#define ReplaceFile ReplaceFileW #define ReplaceFile ReplaceFileW
#else #else
#define ReplaceFile ReplaceFileA #define ReplaceFile ReplaceFileA
#endif // !UNICODE #endif // !UNICODE
#endif // (_WIN32_WINNT >= 0x0500) #endif // (_WIN32_WINNT >= 0x0500)
#if (_WIN32_WINNT >= 0x0500) #if (_WIN32_WINNT >= 0x0500)
skipping to change at line 9377 skipping to change at line 10083
} STREAM_INFO_LEVELS; } STREAM_INFO_LEVELS;
typedef struct _WIN32_FIND_STREAM_DATA { typedef struct _WIN32_FIND_STREAM_DATA {
LARGE_INTEGER StreamSize; LARGE_INTEGER StreamSize;
WCHAR cStreamName[ MAX_PATH + 36 ]; WCHAR cStreamName[ MAX_PATH + 36 ];
} WIN32_FIND_STREAM_DATA, *PWIN32_FIND_STREAM_DATA; } WIN32_FIND_STREAM_DATA, *PWIN32_FIND_STREAM_DATA;
WINBASEAPI
__out __out
HANDLE HANDLE
WINAPI WINAPI
FindFirstStreamW( FindFirstStreamW(
__in LPCWSTR lpFileName, __in LPCWSTR lpFileName,
__in STREAM_INFO_LEVELS InfoLevel, __in STREAM_INFO_LEVELS InfoLevel,
__out LPVOID lpFindStreamData, __out LPVOID lpFindStreamData,
__reserved DWORD dwFlags __reserved DWORD dwFlags
); );
#if _WIN32_WINNT >= 0x0600
WINBASEAPI
HANDLE
WINAPI
FindFirstStreamTransactedW (
__in LPCWSTR lpFileName,
__in STREAM_INFO_LEVELS InfoLevel,
__out LPVOID lpFindStreamData,
__reserved DWORD dwFlags,
__in HANDLE hTransaction
);
#endif // _WIN32_WINNT >= 0x600
WINBASEAPI
BOOL BOOL
APIENTRY APIENTRY
FindNextStreamW( FindNextStreamW(
__in HANDLE hFindStream, __in HANDLE hFindStream,
__out LPVOID lpFindStreamData __out LPVOID lpFindStreamData
); );
#endif // (_WIN32_WINNT >= 0x0501) #endif // (_WIN32_WINNT >= 0x0501)
#if _WIN32_WINNT >= 0x0600 #if _WIN32_WINNT >= 0x0600
WINBASEAPI
HANDLE HANDLE
WINAPI WINAPI
FindFirstFileNameW ( FindFirstFileNameW (
__in LPCWSTR lpFileName, __in LPCWSTR lpFileName,
__in DWORD dwFlags, __in DWORD dwFlags,
__inout LPDWORD StringLength, __inout LPDWORD StringLength,
__inout_ecount(*StringLength) PWCHAR LinkName __inout_ecount(*StringLength) PWCHAR LinkName
); );
WINBASEAPI
BOOL BOOL
APIENTRY APIENTRY
FindNextFileNameW ( FindNextFileNameW (
__in HANDLE hFindStream, __in HANDLE hFindStream,
__inout LPDWORD StringLength, __inout LPDWORD StringLength,
__inout_ecount(*StringLength) PWCHAR LinkName __inout_ecount(*StringLength) PWCHAR LinkName
); );
WINBASEAPI
HANDLE HANDLE
WINAPI WINAPI
FindFirstFileNameTransactedW ( FindFirstFileNameTransactedW (
__in LPCWSTR lpFileName, __in LPCWSTR lpFileName,
__in DWORD dwFlags, __in DWORD dwFlags,
__inout LPDWORD StringLength, __inout LPDWORD StringLength,
__inout_ecount(*StringLength) PWCHAR LinkName, __inout_ecount(*StringLength) PWCHAR LinkName,
__in_opt HANDLE hTransaction __in_opt HANDLE hTransaction
); );
skipping to change at line 10496 skipping to change at line 11220
WINADVAPI WINADVAPI
BOOL BOOL
WINAPI WINAPI
IsWellKnownSid ( IsWellKnownSid (
__in PSID pSid, __in PSID pSid,
__in WELL_KNOWN_SID_TYPE WellKnownSidType __in WELL_KNOWN_SID_TYPE WellKnownSidType
); );
WINADVAPI WINADVAPI
BOOL __success(return != FALSE) BOOL
WINAPI WINAPI
CreateWellKnownSid( CreateWellKnownSid(
__in WELL_KNOWN_SID_TYPE WellKnownSidType, __in WELL_KNOWN_SID_TYPE WellKnownSidType,
__in_opt PSID DomainSid, __in_opt PSID DomainSid,
__out_bcount_part_opt(*cbSid, *cbSid) PSID pSid, __out_bcount_part_opt(*cbSid, *cbSid) PSID pSid,
__inout DWORD *cbSid __inout DWORD *cbSid
); );
WINADVAPI WINADVAPI
BOOL __success(return != FALSE) BOOL
WINAPI WINAPI
EqualDomainSid( EqualDomainSid(
__in PSID pSid1, __in PSID pSid1,
__in PSID pSid2, __in PSID pSid2,
__out BOOL *pfEqual __out BOOL *pfEqual
); );
WINADVAPI WINADVAPI
BOOL __success(return != FALSE) BOOL
WINAPI WINAPI
GetWindowsAccountDomainSid( GetWindowsAccountDomainSid(
__in PSID pSid, __in PSID pSid,
__out_bcount_part_opt(*cbDomainSid, *cbDomainSid) PSID pDomainSid, __out_bcount_part_opt(*cbDomainSid, *cbDomainSid) PSID pDomainSid,
__inout DWORD* cbDomainSid __inout DWORD* cbDomainSid
); );
#endif //(_WIN32_WINNT >= 0x0501) #endif //(_WIN32_WINNT >= 0x0501)
WINADVAPI WINADVAPI
skipping to change at line 10753 skipping to change at line 11477
WINAPI WINAPI
AddMandatoryAce ( AddMandatoryAce (
__inout PACL pAcl, __inout PACL pAcl,
__in DWORD dwAceRevision, __in DWORD dwAceRevision,
__in DWORD AceFlags, __in DWORD AceFlags,
__in DWORD MandatoryPolicy, __in DWORD MandatoryPolicy,
__in PSID pLabelSid __in PSID pLabelSid
); );
#endif /* _WIN32_WINNT >= 0x0600 */ #endif /* _WIN32_WINNT >= 0x0600 */
#if(_WIN32_WINNT >= 0x0601)
WINADVAPI
BOOL
WINAPI
AddConditionalAce (
__inout PACL pAcl,
__in DWORD dwAceRevision,
__in DWORD AceFlags,
__in UCHAR AceType,
__in DWORD AccessMask,
__in PSID pSid,
__in PWCHAR ConditionStr,
__out DWORD *ReturnLength
);
#endif /* _WIN32_WINNT >= 0x0601 */
WINADVAPI WINADVAPI
BOOL BOOL
WINAPI WINAPI
AddAccessDeniedAce ( AddAccessDeniedAce (
__inout PACL pAcl, __inout PACL pAcl,
__in DWORD dwAceRevision, __in DWORD dwAceRevision,
__in DWORD AccessMask, __in DWORD AccessMask,
__in PSID pSid __in PSID pSid
); );
skipping to change at line 11076 skipping to change at line 11816
__in SECURITY_INFORMATION SecurityInformation, __in SECURITY_INFORMATION SecurityInformation,
__in PSECURITY_DESCRIPTOR ModificationDescriptor, __in PSECURITY_DESCRIPTOR ModificationDescriptor,
__deref_inout PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor, __deref_inout PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor,
__in ULONG AutoInheritFlags, __in ULONG AutoInheritFlags,
__in PGENERIC_MAPPING GenericMapping, __in PGENERIC_MAPPING GenericMapping,
__in_opt HANDLE Token __in_opt HANDLE Token
); );
#endif /* _WIN32_WINNT >= 0x0500 */ #endif /* _WIN32_WINNT >= 0x0500 */
WINADVAPI WINADVAPI
BOOL __success(return != FALSE) BOOL
WINAPI WINAPI
GetPrivateObjectSecurity ( GetPrivateObjectSecurity (
__in PSECURITY_DESCRIPTOR ObjectDescriptor, __in PSECURITY_DESCRIPTOR ObjectDescriptor,
__in SECURITY_INFORMATION SecurityInformation, __in SECURITY_INFORMATION SecurityInformation,
__out_bcount_part_opt(DescriptorLength, *ReturnLength) PSECURITY_DESCRIPTOR ResultantDescriptor, __out_bcount_part_opt(DescriptorLength, *ReturnLength) PSECURITY_DESCRIPTOR ResultantDescriptor,
__in DWORD DescriptorLength, __in DWORD DescriptorLength,
__out PDWORD ReturnLength __out PDWORD ReturnLength
); );
WINADVAPI WINADVAPI
BOOL BOOL
WINAPI WINAPI
DestroyPrivateObjectSecurity ( DestroyPrivateObjectSecurity (
__deref PSECURITY_DESCRIPTOR * ObjectDescriptor __deref PSECURITY_DESCRIPTOR * ObjectDescriptor
); );
WINADVAPI WINADVAPI
BOOL __success(return != FALSE) BOOL
WINAPI WINAPI
MakeSelfRelativeSD ( MakeSelfRelativeSD (
__in PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, __in PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
__out_bcount_part_opt(*lpdwBufferLength, *lpdwBufferLength) PSECURITY_DESCRI PTOR pSelfRelativeSecurityDescriptor, __out_bcount_part_opt(*lpdwBufferLength, *lpdwBufferLength) PSECURITY_DESCRI PTOR pSelfRelativeSecurityDescriptor,
__inout LPDWORD lpdwBufferLength __inout LPDWORD lpdwBufferLength
); );
WINADVAPI WINADVAPI
BOOL __success(return != FALSE) BOOL
WINAPI WINAPI
MakeAbsoluteSD ( MakeAbsoluteSD (
__in PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, __in PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
__out_bcount_part_opt(*lpdwAbsoluteSecurityDescriptorSize, *lpdwAbsoluteSecu rityDescriptorSize) PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, __out_bcount_part_opt(*lpdwAbsoluteSecurityDescriptorSize, *lpdwAbsoluteSecu rityDescriptorSize) PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
__inout LPDWORD lpdwAbsoluteSecurityDescriptorSize, __inout LPDWORD lpdwAbsoluteSecurityDescriptorSize,
__out_bcount_part_opt(*lpdwDaclSize, *lpdwDaclSize) PACL pDacl, __out_bcount_part_opt(*lpdwDaclSize, *lpdwDaclSize) PACL pDacl,
__inout LPDWORD lpdwDaclSize, __inout LPDWORD lpdwDaclSize,
__out_bcount_part_opt(*lpdwSaclSize, *lpdwSaclSize) PACL pSacl, __out_bcount_part_opt(*lpdwSaclSize, *lpdwSaclSize) PACL pSacl,
__inout LPDWORD lpdwSaclSize, __inout LPDWORD lpdwSaclSize,
__out_bcount_part_opt(*lpdwOwnerSize, *lpdwOwnerSize) PSID pOwner, __out_bcount_part_opt(*lpdwOwnerSize, *lpdwOwnerSize) PSID pOwner,
__inout LPDWORD lpdwOwnerSize, __inout LPDWORD lpdwOwnerSize,
__out_bcount_part_opt(*lpdwPrimaryGroupSize, *lpdwPrimaryGroupSize) PSID pPr imaryGroup, __out_bcount_part_opt(*lpdwPrimaryGroupSize, *lpdwPrimaryGroupSize) PSID pPr imaryGroup,
__inout LPDWORD lpdwPrimaryGroupSize __inout LPDWORD lpdwPrimaryGroupSize
); );
WINADVAPI WINADVAPI
BOOL __success(return != FALSE) BOOL
WINAPI WINAPI
MakeAbsoluteSD2 ( MakeAbsoluteSD2 (
__inout_bcount_part(*lpdwBufferSize, *lpdwBufferSize) PSECURITY_DESCRIPTOR p SelfRelativeSecurityDescriptor, __inout_bcount_part(*lpdwBufferSize, *lpdwBufferSize) PSECURITY_DESCRIPTOR p SelfRelativeSecurityDescriptor,
__inout LPDWORD lpdwBufferSize __inout LPDWORD lpdwBufferSize
); );
WINADVAPI WINADVAPI
VOID VOID
WINAPI WINAPI
QuerySecurityAccessMask( QuerySecurityAccessMask(
skipping to change at line 11376 skipping to change at line 12116
__in_opt LPCWSTR lpsz, __in_opt LPCWSTR lpsz,
__in UINT_PTR ucchMax __in UINT_PTR ucchMax
); );
#ifdef UNICODE #ifdef UNICODE
#define IsBadStringPtr IsBadStringPtrW #define IsBadStringPtr IsBadStringPtrW
#else #else
#define IsBadStringPtr IsBadStringPtrA #define IsBadStringPtr IsBadStringPtrA
#endif // !UNICODE #endif // !UNICODE
WINADVAPI WINADVAPI
BOOL __success(return != FALSE) BOOL
WINAPI WINAPI
LookupAccountSidA( LookupAccountSidA(
__in_opt LPCSTR lpSystemName, __in_opt LPCSTR lpSystemName,
__in PSID Sid, __in PSID Sid,
__out_ecount_part_opt(*cchName, *cchName + 1) LPSTR Name, __out_ecount_part_opt(*cchName, *cchName + 1) LPSTR Name,
__inout LPDWORD cchName, __inout LPDWORD cchName,
__out_ecount_part_opt(*cchReferencedDomainName, *cchReferencedDomainName + 1 ) LPSTR ReferencedDomainName, __out_ecount_part_opt(*cchReferencedDomainName, *cchReferencedDomainName + 1 ) LPSTR ReferencedDomainName,
__inout LPDWORD cchReferencedDomainName, __inout LPDWORD cchReferencedDomainName,
__out PSID_NAME_USE peUse __out PSID_NAME_USE peUse
); );
WINADVAPI WINADVAPI
BOOL __success(return != FALSE) BOOL
WINAPI WINAPI
LookupAccountSidW( LookupAccountSidW(
__in_opt LPCWSTR lpSystemName, __in_opt LPCWSTR lpSystemName,
__in PSID Sid, __in PSID Sid,
__out_ecount_part_opt(*cchName, *cchName + 1) LPWSTR Name, __out_ecount_part_opt(*cchName, *cchName + 1) LPWSTR Name,
__inout LPDWORD cchName, __inout LPDWORD cchName,
__out_ecount_part_opt(*cchReferencedDomainName, *cchReferencedDomainName + 1 ) LPWSTR ReferencedDomainName, __out_ecount_part_opt(*cchReferencedDomainName, *cchReferencedDomainName + 1 ) LPWSTR ReferencedDomainName,
__inout LPDWORD cchReferencedDomainName, __inout LPDWORD cchReferencedDomainName,
__out PSID_NAME_USE peUse __out PSID_NAME_USE peUse
); );
#ifdef UNICODE #ifdef UNICODE
#define LookupAccountSid LookupAccountSidW #define LookupAccountSid LookupAccountSidW
#else #else
#define LookupAccountSid LookupAccountSidA #define LookupAccountSid LookupAccountSidA
#endif // !UNICODE #endif // !UNICODE
WINADVAPI WINADVAPI
BOOL __success(return != FALSE) BOOL
WINAPI
LookupAccountSidLocalA(
__in PSID Sid,
__out_ecount_part_opt(*cchName, *cchName + 1) LPSTR Name,
__inout LPDWORD cchName,
__out_ecount_part_opt(*cchReferencedDomainName, *cchReferencedDomainName + 1
) LPSTR ReferencedDomainName,
__inout LPDWORD cchReferencedDomainName,
__out PSID_NAME_USE peUse
);
WINADVAPI
__success(return != FALSE) BOOL
WINAPI
LookupAccountSidLocalW(
__in PSID Sid,
__out_ecount_part_opt(*cchName, *cchName + 1) LPWSTR Name,
__inout LPDWORD cchName,
__out_ecount_part_opt(*cchReferencedDomainName, *cchReferencedDomainName + 1
) LPWSTR ReferencedDomainName,
__inout LPDWORD cchReferencedDomainName,
__out PSID_NAME_USE peUse
);
#ifdef UNICODE
#define LookupAccountSidLocal LookupAccountSidLocalW
#else
#define LookupAccountSidLocal LookupAccountSidLocalA
#endif // !UNICODE
WINADVAPI
__success(return != FALSE) BOOL
WINAPI WINAPI
LookupAccountNameA( LookupAccountNameA(
__in_opt LPCSTR lpSystemName, __in_opt LPCSTR lpSystemName,
__in LPCSTR lpAccountName, __in LPCSTR lpAccountName,
__out_bcount_part_opt(*cbSid, *cbSid) PSID Sid, __out_bcount_part_opt(*cbSid, *cbSid) PSID Sid,
__inout LPDWORD cbSid, __inout LPDWORD cbSid,
__out_ecount_part_opt(*cchReferencedDomainName, *cchReferencedDomainName + 1 ) LPSTR ReferencedDomainName, __out_ecount_part_opt(*cchReferencedDomainName, *cchReferencedDomainName + 1 ) LPSTR ReferencedDomainName,
__inout LPDWORD cchReferencedDomainName, __inout LPDWORD cchReferencedDomainName,
__out PSID_NAME_USE peUse __out PSID_NAME_USE peUse
); );
WINADVAPI WINADVAPI
BOOL __success(return != FALSE) BOOL
WINAPI WINAPI
LookupAccountNameW( LookupAccountNameW(
__in_opt LPCWSTR lpSystemName, __in_opt LPCWSTR lpSystemName,
__in LPCWSTR lpAccountName, __in LPCWSTR lpAccountName,
__out_bcount_part_opt(*cbSid, *cbSid) PSID Sid, __out_bcount_part_opt(*cbSid, *cbSid) PSID Sid,
__inout LPDWORD cbSid, __inout LPDWORD cbSid,
__out_ecount_part_opt(*cchReferencedDomainName, *cchReferencedDomainName + 1 ) LPWSTR ReferencedDomainName, __out_ecount_part_opt(*cchReferencedDomainName, *cchReferencedDomainName + 1 ) LPWSTR ReferencedDomainName,
__inout LPDWORD cchReferencedDomainName, __inout LPDWORD cchReferencedDomainName,
__out PSID_NAME_USE peUse __out PSID_NAME_USE peUse
); );
#ifdef UNICODE #ifdef UNICODE
#define LookupAccountName LookupAccountNameW #define LookupAccountName LookupAccountNameW
#else #else
#define LookupAccountName LookupAccountNameA #define LookupAccountName LookupAccountNameA
#endif // !UNICODE #endif // !UNICODE
WINADVAPI WINADVAPI
__success(return != FALSE) BOOL
WINAPI
LookupAccountNameLocalA(
__in LPCSTR lpAccountName,
__out_bcount_part_opt(*cbSid, *cbSid) PSID Sid,
__inout LPDWORD cbSid,
__out_ecount_part_opt(*cchReferencedDomainName, *cchReferencedDomainName + 1
) LPSTR ReferencedDomainName,
__inout LPDWORD cchReferencedDomainName,
__out PSID_NAME_USE peUse
);
WINADVAPI
__success(return != FALSE) BOOL
WINAPI
LookupAccountNameLocalW(
__in LPCWSTR lpAccountName,
__out_bcount_part_opt(*cbSid, *cbSid) PSID Sid,
__inout LPDWORD cbSid,
__out_ecount_part_opt(*cchReferencedDomainName, *cchReferencedDomainName + 1
) LPWSTR ReferencedDomainName,
__inout LPDWORD cchReferencedDomainName,
__out PSID_NAME_USE peUse
);
#ifdef UNICODE
#define LookupAccountNameLocal LookupAccountNameLocalW
#else
#define LookupAccountNameLocal LookupAccountNameLocalA
#endif // !UNICODE
WINADVAPI
BOOL BOOL
WINAPI WINAPI
LookupPrivilegeValueA( LookupPrivilegeValueA(
__in_opt LPCSTR lpSystemName, __in_opt LPCSTR lpSystemName,
__in LPCSTR lpName, __in LPCSTR lpName,
__out PLUID lpLuid __out PLUID lpLuid
); );
WINADVAPI WINADVAPI
BOOL BOOL
WINAPI WINAPI
skipping to change at line 11458 skipping to change at line 12254
__in LPCWSTR lpName, __in LPCWSTR lpName,
__out PLUID lpLuid __out PLUID lpLuid
); );
#ifdef UNICODE #ifdef UNICODE
#define LookupPrivilegeValue LookupPrivilegeValueW #define LookupPrivilegeValue LookupPrivilegeValueW
#else #else
#define LookupPrivilegeValue LookupPrivilegeValueA #define LookupPrivilegeValue LookupPrivilegeValueA
#endif // !UNICODE #endif // !UNICODE
WINADVAPI WINADVAPI
BOOL __success(return != FALSE) BOOL
WINAPI WINAPI
LookupPrivilegeNameA( LookupPrivilegeNameA(
__in_opt LPCSTR lpSystemName, __in_opt LPCSTR lpSystemName,
__in PLUID lpLuid, __in PLUID lpLuid,
__out_ecount_part_opt(*cchName, *cchName + 1) LPSTR lpName, __out_ecount_part_opt(*cchName, *cchName + 1) LPSTR lpName,
__inout LPDWORD cchName __inout LPDWORD cchName
); );
WINADVAPI WINADVAPI
BOOL __success(return != FALSE) BOOL
WINAPI WINAPI
LookupPrivilegeNameW( LookupPrivilegeNameW(
__in_opt LPCWSTR lpSystemName, __in_opt LPCWSTR lpSystemName,
__in PLUID lpLuid, __in PLUID lpLuid,
__out_ecount_part_opt(*cchName, *cchName + 1) LPWSTR lpName, __out_ecount_part_opt(*cchName, *cchName + 1) LPWSTR lpName,
__inout LPDWORD cchName __inout LPDWORD cchName
); );
#ifdef UNICODE #ifdef UNICODE
#define LookupPrivilegeName LookupPrivilegeNameW #define LookupPrivilegeName LookupPrivilegeNameW
#else #else
#define LookupPrivilegeName LookupPrivilegeNameA #define LookupPrivilegeName LookupPrivilegeNameA
#endif // !UNICODE #endif // !UNICODE
WINADVAPI WINADVAPI
BOOL __success(return != FALSE) BOOL
WINAPI WINAPI
LookupPrivilegeDisplayNameA( LookupPrivilegeDisplayNameA(
__in_opt LPCSTR lpSystemName, __in_opt LPCSTR lpSystemName,
__in LPCSTR lpName, __in LPCSTR lpName,
__out_ecount_part_opt(*cchDisplayName, *cchDisplayName + 1) LPSTR lpDisplayN ame, __out_ecount_part_opt(*cchDisplayName, *cchDisplayName + 1) LPSTR lpDisplayN ame,
__inout LPDWORD cchDisplayName, __inout LPDWORD cchDisplayName,
__out LPDWORD lpLanguageId __out LPDWORD lpLanguageId
); );
WINADVAPI WINADVAPI
BOOL __success(return != FALSE) BOOL
WINAPI WINAPI
LookupPrivilegeDisplayNameW( LookupPrivilegeDisplayNameW(
__in_opt LPCWSTR lpSystemName, __in_opt LPCWSTR lpSystemName,
__in LPCWSTR lpName, __in LPCWSTR lpName,
__out_ecount_part_opt(*cchDisplayName, *cchDisplayName + 1) LPWSTR lpDisplay Name, __out_ecount_part_opt(*cchDisplayName, *cchDisplayName + 1) LPWSTR lpDisplay Name,
__inout LPDWORD cchDisplayName, __inout LPDWORD cchDisplayName,
__out LPDWORD lpLanguageId __out LPDWORD lpLanguageId
); );
#ifdef UNICODE #ifdef UNICODE
#define LookupPrivilegeDisplayName LookupPrivilegeDisplayNameW #define LookupPrivilegeDisplayName LookupPrivilegeDisplayNameW
skipping to change at line 11633 skipping to change at line 12429
#define MAX_COMPUTERNAME_LENGTH 15 #define MAX_COMPUTERNAME_LENGTH 15
#else #else
#define MAX_COMPUTERNAME_LENGTH 31 #define MAX_COMPUTERNAME_LENGTH 31
#endif #endif
WINBASEAPI WINBASEAPI
__success(return != 0) __success(return != 0)
BOOL BOOL
WINAPI WINAPI
GetComputerNameA ( GetComputerNameA (
__out_ecount_part_opt(*nSize, *nSize + 1) __out_has_type_adt_props(SAL_Valid CompNameT) LPSTR lpBuffer, __out_ecount_part_opt(*nSize, *nSize + 1) LPSTR lpBuffer,
__inout LPDWORD nSize __inout LPDWORD nSize
); );
WINBASEAPI WINBASEAPI
__success(return != 0) __success(return != 0)
BOOL BOOL
WINAPI WINAPI
GetComputerNameW ( GetComputerNameW (
__out_ecount_part_opt(*nSize, *nSize + 1) __out_has_type_adt_props(SAL_Valid CompNameT) LPWSTR lpBuffer, __out_ecount_part_opt(*nSize, *nSize + 1) LPWSTR lpBuffer,
__inout LPDWORD nSize __inout LPDWORD nSize
); );
#ifdef UNICODE #ifdef UNICODE
#define GetComputerName GetComputerNameW #define GetComputerName GetComputerNameW
#else #else
#define GetComputerName GetComputerNameA #define GetComputerName GetComputerNameA
#endif // !UNICODE #endif // !UNICODE
WINBASEAPI WINBASEAPI
BOOL BOOL
skipping to change at line 11732 skipping to change at line 12528
#else #else
#define SetComputerNameEx SetComputerNameExA #define SetComputerNameEx SetComputerNameExA
#endif // !UNICODE #endif // !UNICODE
WINBASEAPI WINBASEAPI
__success(return == TRUE) __success(return == TRUE)
BOOL BOOL
WINAPI WINAPI
DnsHostnameToComputerNameA ( DnsHostnameToComputerNameA (
__in LPCSTR Hostname, __in LPCSTR Hostname,
__out_ecount_part_opt(*nSize, *nSize + 1) __out_has_type_adt_props(SAL_Valid CompNameT) LPSTR ComputerName, __out_ecount_part_opt(*nSize, *nSize + 1) LPSTR ComputerName,
__inout LPDWORD nSize __inout LPDWORD nSize
); );
WINBASEAPI WINBASEAPI
__success(return == TRUE) __success(return == TRUE)
BOOL BOOL
WINAPI WINAPI
DnsHostnameToComputerNameW ( DnsHostnameToComputerNameW (
__in LPCWSTR Hostname, __in LPCWSTR Hostname,
__out_ecount_part_opt(*nSize, *nSize + 1) __out_has_type_adt_props(SAL_Valid CompNameT) LPWSTR ComputerName, __out_ecount_part_opt(*nSize, *nSize + 1) LPWSTR ComputerName,
__inout LPDWORD nSize __inout LPDWORD nSize
); );
#ifdef UNICODE #ifdef UNICODE
#define DnsHostnameToComputerName DnsHostnameToComputerNameW #define DnsHostnameToComputerName DnsHostnameToComputerNameW
#else #else
#define DnsHostnameToComputerName DnsHostnameToComputerNameA #define DnsHostnameToComputerName DnsHostnameToComputerNameA
#endif // !UNICODE #endif // !UNICODE
#endif // _WIN32_WINNT #endif // _WIN32_WINNT
skipping to change at line 11794 skipping to change at line 12590
#endif // (_WIN32_WINNT >= 0x0500) #endif // (_WIN32_WINNT >= 0x0500)
#define LOGON32_PROVIDER_DEFAULT 0 #define LOGON32_PROVIDER_DEFAULT 0
#define LOGON32_PROVIDER_WINNT35 1 #define LOGON32_PROVIDER_WINNT35 1
#if(_WIN32_WINNT >= 0x0400) #if(_WIN32_WINNT >= 0x0400)
#define LOGON32_PROVIDER_WINNT40 2 #define LOGON32_PROVIDER_WINNT40 2
#endif /* _WIN32_WINNT >= 0x0400 */ #endif /* _WIN32_WINNT >= 0x0400 */
#if(_WIN32_WINNT >= 0x0500) #if(_WIN32_WINNT >= 0x0500)
#define LOGON32_PROVIDER_WINNT50 3 #define LOGON32_PROVIDER_WINNT50 3
#endif // (_WIN32_WINNT >= 0x0500) #endif // (_WIN32_WINNT >= 0x0500)
#if(_WIN32_WINNT >= 0x0600)
#define LOGON32_PROVIDER_VIRTUAL 4
#endif // (_WIN32_WINNT >= 0x0600)
WINADVAPI WINADVAPI
BOOL BOOL
WINAPI WINAPI
LogonUserA ( LogonUserA (
__in LPCSTR lpszUsername, __in LPCSTR lpszUsername,
__in_opt LPCSTR lpszDomain, __in_opt LPCSTR lpszDomain,
__in LPCSTR lpszPassword, __in LPCSTR lpszPassword,
__in DWORD dwLogonType, __in DWORD dwLogonType,
__in DWORD dwLogonProvider, __in DWORD dwLogonProvider,
skipping to change at line 11918 skipping to change at line 12717
#if(_WIN32_WINNT >= 0x0500) #if(_WIN32_WINNT >= 0x0500)
// //
// LogonFlags // LogonFlags
// //
#define LOGON_WITH_PROFILE 0x00000001 #define LOGON_WITH_PROFILE 0x00000001
#define LOGON_NETCREDENTIALS_ONLY 0x00000002 #define LOGON_NETCREDENTIALS_ONLY 0x00000002
#define LOGON_ZERO_PASSWORD_BUFFER 0x80000000 #define LOGON_ZERO_PASSWORD_BUFFER 0x80000000
WINADVAPI WINADVAPI
BOOL __checkReturn BOOL
WINAPI WINAPI
CreateProcessWithLogonW( CreateProcessWithLogonW(
__in LPCWSTR lpUsername, __in LPCWSTR lpUsername,
__in_opt LPCWSTR lpDomain, __in_opt LPCWSTR lpDomain,
__in LPCWSTR lpPassword, __in LPCWSTR lpPassword,
__in DWORD dwLogonFlags, __in DWORD dwLogonFlags,
__in_opt LPCWSTR lpApplicationName, __in_opt LPCWSTR lpApplicationName,
__inout_opt LPWSTR lpCommandLine, __inout_opt LPWSTR lpCommandLine,
__in DWORD dwCreationFlags, __in DWORD dwCreationFlags,
__in_opt LPVOID lpEnvironment, __in_opt LPVOID lpEnvironment,
__in_opt LPCWSTR lpCurrentDirectory, __in_opt LPCWSTR lpCurrentDirectory,
__in LPSTARTUPINFOW lpStartupInfo, __in LPSTARTUPINFOW lpStartupInfo,
__out LPPROCESS_INFORMATION lpProcessInformation __out LPPROCESS_INFORMATION lpProcessInformation
); );
WINADVAPI WINADVAPI
BOOL __checkReturn BOOL
WINAPI WINAPI
CreateProcessWithTokenW( CreateProcessWithTokenW(
__in HANDLE hToken, __in HANDLE hToken,
__in DWORD dwLogonFlags, __in DWORD dwLogonFlags,
__in_opt LPCWSTR lpApplicationName, __in_opt LPCWSTR lpApplicationName,
__inout_opt LPWSTR lpCommandLine, __inout_opt LPWSTR lpCommandLine,
__in DWORD dwCreationFlags, __in DWORD dwCreationFlags,
__in_opt LPVOID lpEnvironment, __in_opt LPVOID lpEnvironment,
__in_opt LPCWSTR lpCurrentDirectory, __in_opt LPCWSTR lpCurrentDirectory,
__in LPSTARTUPINFOW lpStartupInfo, __in LPSTARTUPINFOW lpStartupInfo,
skipping to change at line 12190 skipping to change at line 12989
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
SetThreadpoolThreadMinimum( SetThreadpoolThreadMinimum(
__inout PTP_POOL ptpp, __inout PTP_POOL ptpp,
__in DWORD cthrdMic __in DWORD cthrdMic
); );
WINBASEAPI WINBASEAPI
BOOL
WINAPI
SetThreadpoolStackInformation(
__inout PTP_POOL ptpp,
__in PTP_POOL_STACK_INFORMATION ptpsi
);
WINBASEAPI
BOOL
WINAPI
QueryThreadpoolStackInformation(
__in PTP_POOL ptpp,
__out PTP_POOL_STACK_INFORMATION ptpsi
);
WINBASEAPI
VOID VOID
WINAPI WINAPI
CloseThreadpool( CloseThreadpool(
__inout PTP_POOL ptpp __inout PTP_POOL ptpp
); );
WINBASEAPI WINBASEAPI
__checkReturn __checkReturn
__out __out
PTP_CLEANUP_GROUP PTP_CLEANUP_GROUP
skipping to change at line 12272 skipping to change at line 13087
FORCEINLINE FORCEINLINE
VOID VOID
SetThreadpoolCallbackLibrary( SetThreadpoolCallbackLibrary(
__inout PTP_CALLBACK_ENVIRON pcbe, __inout PTP_CALLBACK_ENVIRON pcbe,
__in PVOID mod __in PVOID mod
) )
{ {
TpSetCallbackRaceWithDll(pcbe, mod); TpSetCallbackRaceWithDll(pcbe, mod);
} }
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN7)
FORCEINLINE
VOID
SetThreadpoolCallbackPriority(
__inout PTP_CALLBACK_ENVIRON pcbe,
__in TP_CALLBACK_PRIORITY Priority
)
{
TpSetCallbackPriority(pcbe, Priority);
}
#endif
FORCEINLINE
VOID
SetThreadpoolCallbackPersistent(
__inout PTP_CALLBACK_ENVIRON pcbe
)
{
TpSetCallbackPersistent(pcbe);
}
FORCEINLINE FORCEINLINE
VOID VOID
DestroyThreadpoolEnvironment( DestroyThreadpoolEnvironment(
__inout PTP_CALLBACK_ENVIRON pcbe __inout PTP_CALLBACK_ENVIRON pcbe
) )
{ {
TpDestroyCallbackEnviron(pcbe); TpDestroyCallbackEnviron(pcbe);
} }
#endif // !defined(MIDL_PASS) #endif // !defined(MIDL_PASS)
skipping to change at line 12564 skipping to change at line 13402
WINAPI WINAPI
ClosePrivateNamespace( ClosePrivateNamespace(
__in HANDLE Handle, __in HANDLE Handle,
__in ULONG Flags __in ULONG Flags
); );
// //
// Boundary descriptors support // Boundary descriptors support
// //
WINBASEAPI
__out_opt __out_opt
HANDLE HANDLE
APIENTRY APIENTRY
CreateBoundaryDescriptorA( CreateBoundaryDescriptorA(
__in LPCSTR Name, __in LPCSTR Name,
__in ULONG Flags __in ULONG Flags
); );
WINBASEAPI
__out_opt __out_opt
HANDLE HANDLE
APIENTRY APIENTRY
CreateBoundaryDescriptorW( CreateBoundaryDescriptorW(
__in LPCWSTR Name, __in LPCWSTR Name,
__in ULONG Flags __in ULONG Flags
); );
#ifdef UNICODE #ifdef UNICODE
#define CreateBoundaryDescriptor CreateBoundaryDescriptorW #define CreateBoundaryDescriptor CreateBoundaryDescriptorW
#else #else
skipping to change at line 12593 skipping to change at line 13433
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
AddSIDToBoundaryDescriptor( AddSIDToBoundaryDescriptor(
__inout HANDLE * BoundaryDescriptor, __inout HANDLE * BoundaryDescriptor,
__in PSID RequiredSid __in PSID RequiredSid
); );
WINBASEAPI WINBASEAPI
BOOL
WINAPI
AddIntegrityLabelToBoundaryDescriptor(
__inout HANDLE * BoundaryDescriptor,
__in PSID IntegrityLabel
);
WINBASEAPI
VOID VOID
WINAPI WINAPI
DeleteBoundaryDescriptor( DeleteBoundaryDescriptor(
__in HANDLE BoundaryDescriptor __in HANDLE BoundaryDescriptor
); );
#endif // _WIN32_WINNT >= 0x0600 #endif // _WIN32_WINNT >= 0x0600
#endif // _WIN32_WINNT >= 0x0500 #endif // _WIN32_WINNT >= 0x0500
skipping to change at line 12770 skipping to change at line 13618
typedef struct _SYSTEM_POWER_STATUS { typedef struct _SYSTEM_POWER_STATUS {
BYTE ACLineStatus; BYTE ACLineStatus;
BYTE BatteryFlag; BYTE BatteryFlag;
BYTE BatteryLifePercent; BYTE BatteryLifePercent;
BYTE Reserved1; BYTE Reserved1;
DWORD BatteryLifeTime; DWORD BatteryLifeTime;
DWORD BatteryFullLifeTime; DWORD BatteryFullLifeTime;
} SYSTEM_POWER_STATUS, *LPSYSTEM_POWER_STATUS; } SYSTEM_POWER_STATUS, *LPSYSTEM_POWER_STATUS;
WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetSystemPowerStatus( GetSystemPowerStatus(
__out LPSYSTEM_POWER_STATUS lpSystemPowerStatus __out LPSYSTEM_POWER_STATUS lpSystemPowerStatus
); );
WINBASEAPI
BOOL BOOL
WINAPI WINAPI
SetSystemPowerState( SetSystemPowerState(
__in BOOL fSuspend, __in BOOL fSuspend,
__in BOOL fForce __in BOOL fForce
); );
#endif /* WINVER >= 0x0400 */ #endif /* WINVER >= 0x0400 */
#if (_WIN32_WINNT >= 0x0500) #if (_WIN32_WINNT >= 0x0500)
skipping to change at line 13166 skipping to change at line 14016
__in LPCWSTR lpszFileName, __in LPCWSTR lpszFileName,
__out_ecount(cchBufferLength) LPWSTR lpszVolumePathName, __out_ecount(cchBufferLength) LPWSTR lpszVolumePathName,
__in DWORD cchBufferLength __in DWORD cchBufferLength
); );
#ifdef UNICODE #ifdef UNICODE
#define GetVolumePathName GetVolumePathNameW #define GetVolumePathName GetVolumePathNameW
#else #else
#define GetVolumePathName GetVolumePathNameA #define GetVolumePathName GetVolumePathNameA
#endif // !UNICODE #endif // !UNICODE
#endif
#if(_WIN32_WINNT >= 0x0501)
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetVolumePathNamesForVolumeNameA( GetVolumePathNamesForVolumeNameA(
__in LPCSTR lpszVolumeName, __in LPCSTR lpszVolumeName,
__out_ecount_part_opt(cchBufferLength, *lpcchReturnLength) __nullnulltermina ted LPCH lpszVolumePathNames, __out_ecount_part_opt(cchBufferLength, *lpcchReturnLength) __nullnulltermina ted LPCH lpszVolumePathNames,
__in DWORD cchBufferLength, __in DWORD cchBufferLength,
__out PDWORD lpcchReturnLength __out PDWORD lpcchReturnLength
); );
WINBASEAPI WINBASEAPI
skipping to change at line 13190 skipping to change at line 14044
__out_ecount_part_opt(cchBufferLength, *lpcchReturnLength) __nullnulltermina ted LPWCH lpszVolumePathNames, __out_ecount_part_opt(cchBufferLength, *lpcchReturnLength) __nullnulltermina ted LPWCH lpszVolumePathNames,
__in DWORD cchBufferLength, __in DWORD cchBufferLength,
__out PDWORD lpcchReturnLength __out PDWORD lpcchReturnLength
); );
#ifdef UNICODE #ifdef UNICODE
#define GetVolumePathNamesForVolumeName GetVolumePathNamesForVolumeNameW #define GetVolumePathNamesForVolumeName GetVolumePathNamesForVolumeNameW
#else #else
#define GetVolumePathNamesForVolumeName GetVolumePathNamesForVolumeNameA #define GetVolumePathNamesForVolumeName GetVolumePathNamesForVolumeNameA
#endif // !UNICODE #endif // !UNICODE
#endif #endif // (_WIN32_WINNT >= 0x0501)
#if (_WIN32_WINNT >= 0x0500) || (_WIN32_FUSION >= 0x0100) || ISOLATION_AWARE_ENA BLED #if (_WIN32_WINNT >= 0x0500) || (_WIN32_FUSION >= 0x0100) || ISOLATION_AWARE_ENA BLED
#define ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID (0x00000001) #define ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID (0x00000001)
#define ACTCTX_FLAG_LANGID_VALID (0x00000002) #define ACTCTX_FLAG_LANGID_VALID (0x00000002)
#define ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID (0x00000004) #define ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID (0x00000004)
#define ACTCTX_FLAG_RESOURCE_NAME_VALID (0x00000008) #define ACTCTX_FLAG_RESOURCE_NAME_VALID (0x00000008)
#define ACTCTX_FLAG_SET_PROCESS_DEFAULT (0x00000010) #define ACTCTX_FLAG_SET_PROCESS_DEFAULT (0x00000010)
#define ACTCTX_FLAG_APPLICATION_NAME_VALID (0x00000020) #define ACTCTX_FLAG_APPLICATION_NAME_VALID (0x00000020)
#define ACTCTX_FLAG_SOURCE_IS_ASSEMBLYREF (0x00000040) #define ACTCTX_FLAG_SOURCE_IS_ASSEMBLYREF (0x00000040)
skipping to change at line 13491 skipping to change at line 14345
__in HANDLE hProcess, __in HANDLE hProcess,
__out PBOOL Wow64Process __out PBOOL Wow64Process
); );
#endif // (_WIN32_WINNT >= 0x0501) #endif // (_WIN32_WINNT >= 0x0501)
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetLogicalProcessorInformation( GetLogicalProcessorInformation(
__out_bcount_part(*ReturnedLength, *ReturnedLength) PSYSTEM_LOGICAL_PROCESSO __out_bcount_part_opt(*ReturnedLength, *ReturnedLength) PSYSTEM_LOGICAL_PROC
R_INFORMATION Buffer, ESSOR_INFORMATION Buffer,
__inout PDWORD ReturnedLength
);
#if _WIN32_WINNT >= 0x0601
WINBASEAPI
BOOL
WINAPI
GetLogicalProcessorInformationEx(
__in LOGICAL_PROCESSOR_RELATIONSHIP RelationshipType,
__out_bcount_part_opt(*ReturnedLength, *ReturnedLength) PSYSTEM_LOGICAL_PROC
ESSOR_INFORMATION_EX Buffer,
__inout PDWORD ReturnedLength __inout PDWORD ReturnedLength
); );
WINBASEAPI
WORD
WINAPI
GetActiveProcessorGroupCount(
VOID
);
WINBASEAPI
WORD
WINAPI
GetMaximumProcessorGroupCount(
VOID
);
WINBASEAPI
DWORD
WINAPI
GetActiveProcessorCount(
__in WORD GroupNumber
);
WINBASEAPI
DWORD
WINAPI
GetMaximumProcessorCount(
__in WORD GroupNumber
);
#endif // (_WIN32_WINNT >=0x0601)
// //
// NUMA Information routines. // NUMA Information routines.
// //
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetNumaHighestNodeNumber( GetNumaHighestNodeNumber(
__out PULONG HighestNodeNumber __out PULONG HighestNodeNumber
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetNumaProcessorNode( GetNumaProcessorNode(
__in UCHAR Processor, __in UCHAR Processor,
__out PUCHAR NodeNumber __out PUCHAR NodeNumber
); );
#if _WIN32_WINNT >= 0x0601
WINBASEAPI
BOOL
WINAPI
GetNumaNodeNumberFromHandle(
__in HANDLE hFile,
__out PUSHORT NodeNumber
);
#endif // (_WIN32_WINNT >=0x0601)
#if _WIN32_WINNT >= 0x0601
WINBASEAPI
BOOL
WINAPI
GetNumaProcessorNodeEx(
__in PPROCESSOR_NUMBER Processor,
__out PUSHORT NodeNumber
);
#endif // (_WIN32_WINNT >=0x0601)
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetNumaNodeProcessorMask( GetNumaNodeProcessorMask(
__in UCHAR Node, __in UCHAR Node,
__out PULONGLONG ProcessorMask __out PULONGLONG ProcessorMask
); );
#if _WIN32_WINNT >= 0x0601
WINBASEAPI
BOOL
WINAPI
GetNumaNodeProcessorMaskEx(
__in USHORT Node,
__out PGROUP_AFFINITY ProcessorMask
);
#endif // (_WIN32_WINNT >=0x0601)
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetNumaAvailableMemoryNode( GetNumaAvailableMemoryNode(
__in UCHAR Node, __in UCHAR Node,
__out PULONGLONG AvailableBytes __out PULONGLONG AvailableBytes
); );
#if _WIN32_WINNT >= 0x0601
WINBASEAPI
BOOL
WINAPI
GetNumaAvailableMemoryNodeEx(
__in USHORT Node,
__out PULONGLONG AvailableBytes
);
#endif // (_WIN32_WINNT >=0x0601)
#if (_WIN32_WINNT >= 0x0600) #if (_WIN32_WINNT >= 0x0600)
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetNumaProximityNode( GetNumaProximityNode(
__in ULONG ProximityId, __in ULONG ProximityId,
__out PUCHAR NodeNumber __out PUCHAR NodeNumber
); );
#endif #endif
#if _WIN32_WINNT >= 0x0601
WINBASEAPI
BOOL
WINAPI
GetNumaProximityNodeEx(
__in ULONG ProximityId,
__out PUSHORT NodeNumber
);
#endif // (_WIN32_WINNT >=0x0601)
// //
// Application restart and data recovery callback // Application restart and data recovery callback
// //
typedef DWORD (WINAPI *APPLICATION_RECOVERY_CALLBACK)(PVOID pvParameter); typedef DWORD (WINAPI *APPLICATION_RECOVERY_CALLBACK)(PVOID pvParameter);
// //
// Max length of commandline in characters (including the NULL character that ca n be registered for restart) // Max length of commandline in characters (including the NULL character that ca n be registered for restart)
// //
#define RESTART_MAX_CMD_LINE 2048 #define RESTART_MAX_CMD_LINE 1024
// //
// Do not restart the process for termination due to application crashes // Do not restart the process for termination due to application crashes
// //
#define RESTART_NO_CRASH 1 #define RESTART_NO_CRASH 1
// //
// Do not restart the process for termination due to application hangs // Do not restart the process for termination due to application hangs
// //
#define RESTART_NO_HANG 2 #define RESTART_NO_HANG 2
// //
// Do not restart the process for termination due to patch installations // Do not restart the process for termination due to patch installations
// //
#define RESTART_NO_PATCH 4 #define RESTART_NO_PATCH 4
// //
// Do not restart the process when the system is rebooted because the // Do not restart the process when the system is rebooted due to patch installat ions
// //
#define RESTART_NO_REBOOT 8 #define RESTART_NO_REBOOT 8
WINBASEAPI WINBASEAPI
HRESULT HRESULT
WINAPI WINAPI
RegisterApplicationRecoveryCallback( RegisterApplicationRecoveryCallback(
__in APPLICATION_RECOVERY_CALLBACK pRecoveyCallback, __in APPLICATION_RECOVERY_CALLBACK pRecoveyCallback,
__in_opt PVOID pvParameter, __in_opt PVOID pvParameter,
__in DWORD dwPingInterval, __in DWORD dwPingInterval,
__in DWORD dwFlags __in DWORD dwFlags
); );
WINBASEAPI WINBASEAPI
HRESULT HRESULT
WINAPI WINAPI
UnregisterApplicationRecoveryCallback(); UnregisterApplicationRecoveryCallback(void);
WINBASEAPI WINBASEAPI
HRESULT HRESULT
WINAPI WINAPI
RegisterApplicationRestart( RegisterApplicationRestart(
__in_opt PCWSTR pwzCommandline, __in_opt PCWSTR pwzCommandline,
__in DWORD dwFlags __in DWORD dwFlags
); );
WINBASEAPI WINBASEAPI
HRESULT HRESULT
WINAPI WINAPI
UnregisterApplicationRestart(); UnregisterApplicationRestart(void);
#define RECOVERY_DEFAULT_PING_INTERVAL 5000 #define RECOVERY_DEFAULT_PING_INTERVAL 5000
#define RECOVERY_MAX_PING_INTERVAL (5 * 60 * 1000) #define RECOVERY_MAX_PING_INTERVAL (5 * 60 * 1000)
WINBASEAPI WINBASEAPI
HRESULT HRESULT
WINAPI WINAPI
GetApplicationRecoveryCallback( GetApplicationRecoveryCallback(
__in HANDLE hProcess, __in HANDLE hProcess,
__out APPLICATION_RECOVERY_CALLBACK* pRecoveryCallback, __out APPLICATION_RECOVERY_CALLBACK* pRecoveryCallback,
skipping to change at line 13653 skipping to change at line 14608
FileRenameInfo, FileRenameInfo,
FileDispositionInfo, FileDispositionInfo,
FileAllocationInfo, FileAllocationInfo,
FileEndOfFileInfo, FileEndOfFileInfo,
FileStreamInfo, FileStreamInfo,
FileCompressionInfo, FileCompressionInfo,
FileAttributeTagInfo, FileAttributeTagInfo,
FileIdBothDirectoryInfo, FileIdBothDirectoryInfo,
FileIdBothDirectoryRestartInfo, FileIdBothDirectoryRestartInfo,
FileIoPriorityHintInfo, FileIoPriorityHintInfo,
FileRemoteProtocolInfo,
MaximumFileInfoByHandleClass MaximumFileInfoByHandleClass
} FILE_INFO_BY_HANDLE_CLASS, *PFILE_INFO_BY_HANDLE_CLASS; } FILE_INFO_BY_HANDLE_CLASS, *PFILE_INFO_BY_HANDLE_CLASS;
typedef struct _FILE_BASIC_INFO { typedef struct _FILE_BASIC_INFO {
LARGE_INTEGER CreationTime; LARGE_INTEGER CreationTime;
LARGE_INTEGER LastAccessTime; LARGE_INTEGER LastAccessTime;
LARGE_INTEGER LastWriteTime; LARGE_INTEGER LastWriteTime;
LARGE_INTEGER ChangeTime; LARGE_INTEGER ChangeTime;
DWORD FileAttributes; DWORD FileAttributes;
} FILE_BASIC_INFO, *PFILE_BASIC_INFO; } FILE_BASIC_INFO, *PFILE_BASIC_INFO;
skipping to change at line 13747 skipping to change at line 14703
IoPriorityHintVeryLow = 0, IoPriorityHintVeryLow = 0,
IoPriorityHintLow, IoPriorityHintLow,
IoPriorityHintNormal, IoPriorityHintNormal,
MaximumIoPriorityHintType MaximumIoPriorityHintType
} PRIORITY_HINT; } PRIORITY_HINT;
typedef struct _FILE_IO_PRIORITY_HINT_INFO { typedef struct _FILE_IO_PRIORITY_HINT_INFO {
PRIORITY_HINT PriorityHint; PRIORITY_HINT PriorityHint;
} FILE_IO_PRIORITY_HINT_INFO, *PFILE_IO_PRIORITY_HINT_INFO; } FILE_IO_PRIORITY_HINT_INFO, *PFILE_IO_PRIORITY_HINT_INFO;
// Structure and constants must match those in ntioapi_x.w
#define REMOTE_PROTOCOL_INFO_FLAG_LOOPBACK 0x00000001
#define REMOTE_PROTOCOL_INFO_FLAG_OFFLINE 0x00000002
typedef struct _FILE_REMOTE_PROTOCOL_INFO
{
// Structure Version
USHORT StructureVersion; // 1
USHORT StructureSize; // sizeof(FILE_REMOTE_PROTOCOL_INFO)
DWORD Protocol; // Protocol (WNNC_NET_*) defined in wnnc.h or n
tifs.h.
// Protocol Version & Type
USHORT ProtocolMajorVersion;
USHORT ProtocolMinorVersion;
USHORT ProtocolRevision;
USHORT Reserved;
// Protocol-Generic Information
DWORD Flags;
struct {
DWORD Reserved[8];
} GenericReserved;
// Protocol specific information
struct {
DWORD Reserved[16];
} ProtocolSpecificReserved;
} FILE_REMOTE_PROTOCOL_INFO, *PFILE_REMOTE_PROTOCOL_INFO;
WINBASEAPI
BOOL BOOL
WINAPI WINAPI
SetFileInformationByHandle( SetFileInformationByHandle(
__in HANDLE hFile, __in HANDLE hFile,
__in FILE_INFO_BY_HANDLE_CLASS FileInformationClass, __in FILE_INFO_BY_HANDLE_CLASS FileInformationClass,
__in_bcount(dwBufferSize) LPVOID lpFileInformation, __in_bcount(dwBufferSize) LPVOID lpFileInformation,
__in DWORD dwBufferSize __in DWORD dwBufferSize
); );
WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetFileInformationByHandleEx( GetFileInformationByHandleEx(
__in HANDLE hFile, __in HANDLE hFile,
__in FILE_INFO_BY_HANDLE_CLASS FileInformationClass, __in FILE_INFO_BY_HANDLE_CLASS FileInformationClass,
__out_bcount(dwBufferSize) LPVOID lpFileInformation, __out_bcount(dwBufferSize) LPVOID lpFileInformation,
__in DWORD dwBufferSize __in DWORD dwBufferSize
); );
typedef enum _FILE_ID_TYPE { typedef enum _FILE_ID_TYPE {
skipping to change at line 13777 skipping to change at line 14770
ObjectIdType, ObjectIdType,
MaximumFileIdType MaximumFileIdType
} FILE_ID_TYPE, *PFILE_ID_TYPE; } FILE_ID_TYPE, *PFILE_ID_TYPE;
typedef struct FILE_ID_DESCRIPTOR { typedef struct FILE_ID_DESCRIPTOR {
DWORD dwSize; // Size of the struct DWORD dwSize; // Size of the struct
FILE_ID_TYPE Type; // Describes the type of identifier passed in. FILE_ID_TYPE Type; // Describes the type of identifier passed in.
union { union {
LARGE_INTEGER FileId; LARGE_INTEGER FileId;
GUID ObjectId; GUID ObjectId;
}; } DUMMYUNIONNAME;
} FILE_ID_DESCRIPTOR, *LPFILE_ID_DESCRIPTOR; } FILE_ID_DESCRIPTOR, *LPFILE_ID_DESCRIPTOR;
WINBASEAPI
__out __out
HANDLE HANDLE
WINAPI WINAPI
OpenFileById ( OpenFileById (
__in HANDLE hVolumeHint, __in HANDLE hVolumeHint,
__in LPFILE_ID_DESCRIPTOR lpFileId, __in LPFILE_ID_DESCRIPTOR lpFileId,
__in DWORD dwDesiredAccess, __in DWORD dwDesiredAccess,
__in DWORD dwShareMode, __in DWORD dwShareMode,
__in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes, __in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes,
__in DWORD dwFlagsAndAttributes __in DWORD dwFlagsAndAttributes
skipping to change at line 13803 skipping to change at line 14797
#if (_WIN32_WINNT >= 0x0600) #if (_WIN32_WINNT >= 0x0600)
// //
// Flags to be passed into CREATE_SYMBOLIC_LINK // Flags to be passed into CREATE_SYMBOLIC_LINK
// //
#define SYMBOLIC_LINK_FLAG_DIRECTORY (0x1) #define SYMBOLIC_LINK_FLAG_DIRECTORY (0x1)
#define VALID_SYMBOLIC_LINK_FLAGS SYMBOLIC_LINK_FLAG_DIRECTORY // & whatever ot her flags we think of! #define VALID_SYMBOLIC_LINK_FLAGS SYMBOLIC_LINK_FLAG_DIRECTORY // & whatever ot her flags we think of!
WINBASEAPI
BOOLEAN BOOLEAN
APIENTRY APIENTRY
CreateSymbolicLinkA ( CreateSymbolicLinkA (
__in LPCSTR lpSymlinkFileName, __in LPCSTR lpSymlinkFileName,
__in LPCSTR lpTargetFileName, __in LPCSTR lpTargetFileName,
__in DWORD dwFlags __in DWORD dwFlags
); );
WINBASEAPI
BOOLEAN BOOLEAN
APIENTRY APIENTRY
CreateSymbolicLinkW ( CreateSymbolicLinkW (
__in LPCWSTR lpSymlinkFileName, __in LPCWSTR lpSymlinkFileName,
__in LPCWSTR lpTargetFileName, __in LPCWSTR lpTargetFileName,
__in DWORD dwFlags __in DWORD dwFlags
); );
#ifdef UNICODE #ifdef UNICODE
#define CreateSymbolicLink CreateSymbolicLinkW #define CreateSymbolicLink CreateSymbolicLinkW
#else #else
#define CreateSymbolicLink CreateSymbolicLinkA #define CreateSymbolicLink CreateSymbolicLinkA
#endif // !UNICODE #endif // !UNICODE
WINBASEAPI
BOOLEAN BOOLEAN
APIENTRY APIENTRY
CreateSymbolicLinkTransactedA ( CreateSymbolicLinkTransactedA (
__in LPCSTR lpSymlinkFileName, __in LPCSTR lpSymlinkFileName,
__in LPCSTR lpTargetFileName, __in LPCSTR lpTargetFileName,
__in DWORD dwFlags, __in DWORD dwFlags,
__in HANDLE hTransaction __in HANDLE hTransaction
); );
WINBASEAPI
BOOLEAN BOOLEAN
APIENTRY APIENTRY
CreateSymbolicLinkTransactedW ( CreateSymbolicLinkTransactedW (
__in LPCWSTR lpSymlinkFileName, __in LPCWSTR lpSymlinkFileName,
__in LPCWSTR lpTargetFileName, __in LPCWSTR lpTargetFileName,
__in DWORD dwFlags, __in DWORD dwFlags,
__in HANDLE hTransaction __in HANDLE hTransaction
); );
#ifdef UNICODE #ifdef UNICODE
#define CreateSymbolicLinkTransacted CreateSymbolicLinkTransactedW #define CreateSymbolicLinkTransacted CreateSymbolicLinkTransactedW
#else #else
#define CreateSymbolicLinkTransacted CreateSymbolicLinkTransactedA #define CreateSymbolicLinkTransacted CreateSymbolicLinkTransactedA
#endif // !UNICODE #endif // !UNICODE
WINBASEAPI
DWORD DWORD
WINAPI WINAPI
GetFinalPathNameByHandleA ( GetFinalPathNameByHandleA (
__in HANDLE hFile, __in HANDLE hFile,
__out_ecount(cchFilePath) LPSTR lpszFilePath, __out_ecount(cchFilePath) LPSTR lpszFilePath,
__in DWORD cchFilePath, __in DWORD cchFilePath,
__in DWORD dwFlags __in DWORD dwFlags
); );
WINBASEAPI
DWORD DWORD
WINAPI WINAPI
GetFinalPathNameByHandleW ( GetFinalPathNameByHandleW (
__in HANDLE hFile, __in HANDLE hFile,
__out_ecount(cchFilePath) LPWSTR lpszFilePath, __out_ecount(cchFilePath) LPWSTR lpszFilePath,
__in DWORD cchFilePath, __in DWORD cchFilePath,
__in DWORD dwFlags __in DWORD dwFlags
); );
#ifdef UNICODE #ifdef UNICODE
#define GetFinalPathNameByHandle GetFinalPathNameByHandleW #define GetFinalPathNameByHandle GetFinalPathNameByHandleW
skipping to change at line 13886 skipping to change at line 14886
__in_opt HANDLE hActCtx, __in_opt HANDLE hActCtx,
__in_opt PCWSTR settingsNameSpace, __in_opt PCWSTR settingsNameSpace,
__in PCWSTR settingName, __in PCWSTR settingName,
__out_bcount_part_opt(dwBuffer, *pdwWrittenOrRequired) PWSTR pvBuffer, __out_bcount_part_opt(dwBuffer, *pdwWrittenOrRequired) PWSTR pvBuffer,
__in SIZE_T dwBuffer, __in SIZE_T dwBuffer,
__out_opt SIZE_T *pdwWrittenOrRequired __out_opt SIZE_T *pdwWrittenOrRequired
); );
#endif #endif
#if (_WIN32_WINNT >= 0x0600)
WINBASEAPI
BOOL
WINAPI
ReplacePartitionUnit (
__in PWSTR TargetPartition,
__in PWSTR SparePartition,
__in ULONG Flags
);
#endif
#if (_WIN32_WINNT >= 0x0600)
WINBASEAPI
BOOL
WINAPI
AddSecureMemoryCacheCallback(
__in __callback PSECURE_MEMORY_CACHE_CALLBACK pfnCallBack
);
WINBASEAPI
BOOL
WINAPI
RemoveSecureMemoryCacheCallback(
__in __callback PSECURE_MEMORY_CACHE_CALLBACK pfnCallBack
);
#endif
#if (_WIN32_WINNT >= 0x0601)
__checkReturn
WINBASEAPI
BOOL
WINAPI
CopyExtendedContext(
__out PCONTEXT_EX Destination,
__in DWORD ContextFlags,
__in PCONTEXT_EX Source
);
__checkReturn
WINBASEAPI
BOOL
WINAPI
InitializeExtendedContext(
__out PVOID Context,
__in DWORD ContextFlags,
__out PCONTEXT_EX* ContextEx
);
WINBASEAPI
DWORD64
WINAPI
GetEnabledExtendedFeatures(
__in DWORD64 FeatureMask
);
WINBASEAPI
BOOL
WINAPI
GetExtendedContextLength(
__in DWORD ContextFlags,
__out PDWORD ContextLength
);
WINBASEAPI
DWORD64
WINAPI
GetExtendedFeaturesMask(
__in PCONTEXT_EX ContextEx
);
WINBASEAPI
PVOID
WINAPI
LocateExtendedFeature(
__in PCONTEXT_EX ContextEx,
__in DWORD FeatureId,
__out_opt PDWORD Length
);
WINBASEAPI
PCONTEXT
WINAPI
LocateLegacyContext(
__in PCONTEXT_EX ContextEx,
__out_opt PDWORD Length
);
WINBASEAPI
VOID
WINAPI
SetExtendedFeaturesMask(
__out PCONTEXT_EX ContextEx,
__in DWORD64 FeatureMask
);
WINBASEAPI
DWORD
APIENTRY
EnableThreadProfiling(
__in HANDLE ThreadHandle,
__in DWORD Flags,
__in DWORD64 HardwareCounters,
__out HANDLE *PerformanceDataHandle
);
WINBASEAPI
DWORD
APIENTRY
DisableThreadProfiling(
__in HANDLE PerformanceDataHandle
);
WINBASEAPI
DWORD
APIENTRY
QueryThreadProfiling(
__in HANDLE ThreadHandle,
__out PBOOLEAN Enabled
);
WINBASEAPI
DWORD
APIENTRY
ReadThreadProfilingData(
__in HANDLE PerformanceDataHandle,
__in DWORD Flags,
__out PPERFORMANCE_DATA PerformanceData
);
#endif
#if !defined(RC_INVOKED) /* RC complains about long symbols in #ifs */ #if !defined(RC_INVOKED) /* RC complains about long symbols in #ifs */
#if defined(ISOLATION_AWARE_ENABLED) && (ISOLATION_AWARE_ENABLED != 0) #if defined(ISOLATION_AWARE_ENABLED) && (ISOLATION_AWARE_ENABLED != 0)
#include "winbase.inl" #include "winbase.inl"
#endif /* ISOLATION_AWARE_ENABLED */ #endif /* ISOLATION_AWARE_ENABLED */
#endif /* RC */ #endif /* RC */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif // _WINBASE_ #endif // _WINBASE_
#if !defined(RC_INVOKED)
#if !defined(NOWINBASEINTERLOCK)
#if !defined(_NTOS_)
/*++
Copyright (c) Microsoft Corporation. All rights reserved.
Module Name:
winbase_interlockedcplusplus.h
Abstract:
C++ function overloads in place of "manual name mangling".
This file is meant to be #included by winbase.h or any other file declaring
the signed interlocked functions.
Author:
Jay Krell (JayKrell) April 2002
--*/
#if !defined(RC_INVOKED) /* { */
#if !defined(MICROSOFT_WINDOWS_WINBASE_INTERLOCKED_CPLUSPLUS_H_INCLUDED) /* { */
#define MICROSOFT_WINDOWS_WINBASE_INTERLOCKED_CPLUSPLUS_H_INCLUDED
#if _MSC_VER > 1000
#pragma once
#endif
#if !defined(MIDL_PASS) /* { */
/*
To turn off/hide the contents of this file:
#define MICROSOFT_WINDOWS_WINBASE_H_DEFINE_INTERLOCKED_CPLUSPLUS_OVERLOADS 0
*/
#if !defined(MICROSOFT_WINDOWS_WINBASE_H_DEFINE_INTERLOCKED_CPLUSPLUS_OVERLOADS)
#define MICROSOFT_WINDOWS_WINBASE_H_DEFINE_INTERLOCKED_CPLUSPLUS_OVERLOADS (_WIN
32_WINNT >= 0x0502 || !defined(_WINBASE_))
#endif
#if MICROSOFT_WINDOWS_WINBASE_H_DEFINE_INTERLOCKED_CPLUSPLUS_OVERLOADS /* { */
#if defined(__cplusplus) /* { */
extern "C++" {
FORCEINLINE
unsigned
InterlockedIncrement(
__inout __drv_interlocked unsigned volatile *Addend
)
{
return (unsigned) InterlockedIncrement((volatile long*) Addend);
}
FORCEINLINE
unsigned long
InterlockedIncrement(
__inout __drv_interlocked unsigned long volatile *Addend
)
{
return (unsigned long) InterlockedIncrement((volatile long*) Addend);
}
#if defined(_WIN64) || ((_WIN32_WINNT >= 0x0502) && defined(_WINBASE_))
FORCEINLINE
unsigned __int64
InterlockedIncrement(
__inout __drv_interlocked unsigned __int64 volatile *Addend
)
{
return (unsigned __int64) InterlockedIncrement64((volatile __int64*) Addend)
;
}
#endif
FORCEINLINE
unsigned
InterlockedDecrement(
__inout __drv_interlocked unsigned volatile *Addend
)
{
return (unsigned long) InterlockedDecrement((volatile long*) Addend);
}
FORCEINLINE
unsigned long
InterlockedDecrement(
__inout __drv_interlocked unsigned long volatile *Addend
)
{
return (unsigned long) InterlockedDecrement((volatile long*) Addend);
}
#if defined(_WIN64) || ((_WIN32_WINNT >= 0x0502) && defined(_WINBASE_))
FORCEINLINE
unsigned __int64
InterlockedDecrement(
__inout __drv_interlocked unsigned __int64 volatile *Addend
)
{
return (unsigned __int64) InterlockedDecrement64((volatile __int64*) Addend)
;
}
#endif
FORCEINLINE
unsigned
InterlockedExchange(
__inout __drv_interlocked unsigned volatile *Target,
__in unsigned Value
)
{
return (unsigned) InterlockedExchange((volatile long*) Target, (long) Value)
;
}
FORCEINLINE
unsigned long
InterlockedExchange(
__inout __drv_interlocked unsigned long volatile *Target,
__in unsigned long Value
)
{
return (unsigned long) InterlockedExchange((volatile long*) Target, (long) V
alue);
}
#if defined(_WIN64) || ((_WIN32_WINNT >= 0x0502) && defined(_WINBASE_))
FORCEINLINE
unsigned __int64
InterlockedExchange(
__inout __drv_interlocked unsigned __int64 volatile *Target,
__in unsigned __int64 Value
)
{
return (unsigned __int64) InterlockedExchange64((volatile __int64*) Target,
(__int64) Value);
}
#endif
FORCEINLINE
unsigned
InterlockedExchangeAdd(
__inout __drv_interlocked unsigned volatile *Addend,
__in unsigned Value
)
{
return (unsigned) InterlockedExchangeAdd((volatile long*) Addend, (long) Val
ue);
}
FORCEINLINE
unsigned
InterlockedExchangeSubtract(
__inout __drv_interlocked unsigned volatile *Addend,
__in unsigned Value
)
{
return (unsigned) InterlockedExchangeAdd((volatile long*) Addend, - (long)
Value);
}
FORCEINLINE
unsigned long
InterlockedExchangeAdd(
__inout __drv_interlocked unsigned long volatile *Addend,
__in unsigned long Value
)
{
return (unsigned long) InterlockedExchangeAdd((volatile long*) Addend, (long
) Value);
}
FORCEINLINE
unsigned long
InterlockedExchangeSubtract(
__inout __drv_interlocked unsigned long volatile *Addend,
__in unsigned long Value
)
{
return (unsigned long) InterlockedExchangeAdd((volatile long*) Addend, - (l
ong) Value);
}
#if defined(_WIN64) || ((_WIN32_WINNT >= 0x0502) && defined(_WINBASE_))
FORCEINLINE
unsigned __int64
InterlockedExchangeAdd(
__inout __drv_interlocked unsigned __int64 volatile *Addend,
__in unsigned __int64 Value
)
{
return (unsigned __int64) InterlockedExchangeAdd64((volatile __int64*) Adden
d, (__int64) Value);
}
FORCEINLINE
unsigned __int64
InterlockedExchangeSubtract(
__inout __drv_interlocked unsigned __int64 volatile *Addend,
__in unsigned __int64 Value
)
{
return (unsigned __int64) InterlockedExchangeAdd64((volatile __int64*) Adden
d, - (__int64) Value);
}
#endif
FORCEINLINE
unsigned
InterlockedCompareExchange(
__inout __drv_interlocked unsigned volatile *Destination,
__in unsigned Exchange,
__in unsigned Comperand
)
{
return (unsigned) InterlockedCompareExchange((volatile long*) Destination, (
long) Exchange, (long) Comperand);
}
FORCEINLINE
unsigned long
InterlockedCompareExchange(
__inout __drv_interlocked unsigned long volatile *Destination,
__in unsigned long Exchange,
__in unsigned long Comperand
)
{
return (unsigned long) InterlockedCompareExchange((volatile long*) Destinati
on, (long) Exchange, (long) Comperand);
}
#if defined(_WIN64) || ((_WIN32_WINNT >= 0x0502) && defined(_WINBASE_))
FORCEINLINE
unsigned __int64
InterlockedCompareExchange(
__inout __drv_interlocked unsigned __int64 volatile *Destination,
__in unsigned __int64 Exchange,
__in unsigned __int64 Comperand
)
{
return (unsigned __int64) InterlockedCompareExchange64((volatile __int64*) D
estination, (__int64) Exchange, (__int64) Comperand);
}
FORCEINLINE
unsigned __int64
InterlockedAnd(
__inout __drv_interlocked unsigned __int64 volatile *Destination,
__in unsigned __int64 Value
)
{
return (unsigned __int64) InterlockedAnd64((volatile __int64*) Destination,
(__int64) Value);
}
FORCEINLINE
unsigned __int64
InterlockedOr(
__inout __drv_interlocked unsigned __int64 volatile *Destination,
__in unsigned __int64 Value
)
{
return (unsigned __int64) InterlockedOr64((volatile __int64*) Destination, (
__int64) Value);
}
FORCEINLINE
unsigned __int64
InterlockedXor(
__inout __drv_interlocked unsigned __int64 volatile *Destination,
__in unsigned __int64 Value
)
{
return (unsigned __int64) InterlockedXor64((volatile __int64*) Destination,
(__int64) Value);
}
#endif
} /* extern "C++" */
#endif /* } __cplusplus */
#endif /* } MICROSOFT_WINBASE_H_DEFINE_INTERLOCKED_CPLUSPLUS_OVERLOADS */
#undef MICROSOFT_WINBASE_H_DEFINE_INTERLOCKED_CPLUSPLUS_OVERLOADS
#define MICROSOFT_WINBASE_H_DEFINE_INTERLOCKED_CPLUSPLUS_OVERLOADS 0
#endif /* } MIDL_PASS */
#endif /* } MICROSOFT_WINDOWS_WINBASE_INTERLOCKED_CPLUSPLUS_H_INCLUDED */
#endif /* } RC_INVOKED */
#endif /* _NTOS_ */
#endif /* NOWINBASEINTERLOCK */
#endif /* RC_INVOKED */
 End of changes. 156 change blocks. 
91 lines changed or deleted 1252 lines changed or added


 wincon.h (6.0.6002.18005-Windows 6.0)   wincon.h (6.1.7601.23418-Windows 7.0) 
skipping to change at line 245 skipping to change at line 246
#define CONSOLE_MOUSE_DOWN 0x0008 // mouse is down #define CONSOLE_MOUSE_DOWN 0x0008 // mouse is down
#endif /* _WIN32_WINNT >= 0x0500 */ #endif /* _WIN32_WINNT >= 0x0500 */
// //
// typedef for ctrl-c handler routines // typedef for ctrl-c handler routines
// //
typedef typedef
BOOL BOOL
(WINAPI *PHANDLER_ROUTINE)( (WINAPI *PHANDLER_ROUTINE)(
DWORD CtrlType __in DWORD CtrlType
); );
#define CTRL_C_EVENT 0 #define CTRL_C_EVENT 0
#define CTRL_BREAK_EVENT 1 #define CTRL_BREAK_EVENT 1
#define CTRL_CLOSE_EVENT 2 #define CTRL_CLOSE_EVENT 2
// 3 is reserved! // 3 is reserved!
// 4 is reserved! // 4 is reserved!
#define CTRL_LOGOFF_EVENT 5 #define CTRL_LOGOFF_EVENT 5
#define CTRL_SHUTDOWN_EVENT 6 #define CTRL_SHUTDOWN_EVENT 6
skipping to change at line 484 skipping to change at line 485
__in DWORD nLength, __in DWORD nLength,
__in COORD dwWriteCoord, __in COORD dwWriteCoord,
__out LPDWORD lpNumberOfAttrsWritten __out LPDWORD lpNumberOfAttrsWritten
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
FillConsoleOutputCharacterA( FillConsoleOutputCharacterA(
__in HANDLE hConsoleOutput, __in HANDLE hConsoleOutput,
__in_ecount(nLength) CHAR cCharacter, __in CHAR cCharacter,
__in DWORD nLength, __in DWORD nLength,
__in COORD dwWriteCoord, __in COORD dwWriteCoord,
__out LPDWORD lpNumberOfCharsWritten __out LPDWORD lpNumberOfCharsWritten
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
FillConsoleOutputCharacterW( FillConsoleOutputCharacterW(
__in HANDLE hConsoleOutput, __in HANDLE hConsoleOutput,
__in_ecount(nLength) WCHAR cCharacter, __in WCHAR cCharacter,
__in DWORD nLength, __in DWORD nLength,
__in COORD dwWriteCoord, __in COORD dwWriteCoord,
__out LPDWORD lpNumberOfCharsWritten __out LPDWORD lpNumberOfCharsWritten
); );
#ifdef UNICODE #ifdef UNICODE
#define FillConsoleOutputCharacter FillConsoleOutputCharacterW #define FillConsoleOutputCharacter FillConsoleOutputCharacterW
#else #else
#define FillConsoleOutputCharacter FillConsoleOutputCharacterA #define FillConsoleOutputCharacter FillConsoleOutputCharacterA
#endif // !UNICODE #endif // !UNICODE
skipping to change at line 738 skipping to change at line 739
WINAPI WINAPI
SetConsoleCtrlHandler( SetConsoleCtrlHandler(
__in_opt PHANDLER_ROUTINE HandlerRoutine, __in_opt PHANDLER_ROUTINE HandlerRoutine,
__in BOOL Add); __in BOOL Add);
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GenerateConsoleCtrlEvent( GenerateConsoleCtrlEvent(
__in DWORD dwCtrlEvent, __in DWORD dwCtrlEvent,
__in DWORD dwProcessGroupId __in DWORD dwProcessGroupId);
);
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
AllocConsole( VOID ); AllocConsole(
VOID);
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
FreeConsole( VOID ); FreeConsole(
VOID);
#if(_WIN32_WINNT >= 0x0500) #if(_WIN32_WINNT >= 0x0500)
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
AttachConsole( AttachConsole(
__in DWORD dwProcessId __in DWORD dwProcessId);
);
#define ATTACH_PARENT_PROCESS ((DWORD)-1) #define ATTACH_PARENT_PROCESS ((DWORD)-1)
#endif /* _WIN32_WINNT >= 0x0500 */ #endif /* _WIN32_WINNT >= 0x0500 */
WINBASEAPI WINBASEAPI
DWORD DWORD
WINAPI WINAPI
GetConsoleTitleA( GetConsoleTitleA(
__out_ecount(nSize) LPSTR lpConsoleTitle, __out_ecount(nSize) LPSTR lpConsoleTitle,
__in DWORD nSize __in DWORD nSize
); );
WINBASEAPI WINBASEAPI
skipping to change at line 821 skipping to change at line 823
SetConsoleTitleW( SetConsoleTitleW(
__in LPCWSTR lpConsoleTitle __in LPCWSTR lpConsoleTitle
); );
#ifdef UNICODE #ifdef UNICODE
#define SetConsoleTitle SetConsoleTitleW #define SetConsoleTitle SetConsoleTitleW
#else #else
#define SetConsoleTitle SetConsoleTitleA #define SetConsoleTitle SetConsoleTitleA
#endif // !UNICODE #endif // !UNICODE
typedef struct _CONSOLE_READCONSOLE_CONTROL { typedef struct _CONSOLE_READCONSOLE_CONTROL {
IN ULONG nLength; // sizeof( CONSOLE_READCONSOLE_CONTROL ) ULONG nLength;
IN ULONG nInitialChars; ULONG nInitialChars;
IN ULONG dwCtrlWakeupMask; ULONG dwCtrlWakeupMask;
OUT ULONG dwControlKeyState; ULONG dwControlKeyState;
} CONSOLE_READCONSOLE_CONTROL, *PCONSOLE_READCONSOLE_CONTROL; } CONSOLE_READCONSOLE_CONTROL, *PCONSOLE_READCONSOLE_CONTROL;
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
ReadConsoleA( ReadConsoleA(
__in HANDLE hConsoleInput, __in HANDLE hConsoleInput,
__out_ecount_part(nNumberOfCharsToRead, *lpNumberOfCharsRead) __out_ecount_part(nNumberOfCharsToRead, *lpNumberOfCharsRead)
LPVOID lpBuffer, LPVOID lpBuffer,
__in DWORD nNumberOfCharsToRead, __in DWORD nNumberOfCharsToRead,
skipping to change at line 862 skipping to change at line 864
#define ReadConsole ReadConsoleA #define ReadConsole ReadConsoleA
#endif // !UNICODE #endif // !UNICODE
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
WriteConsoleA( WriteConsoleA(
__in HANDLE hConsoleOutput, __in HANDLE hConsoleOutput,
__in_ecount(nNumberOfCharsToWrite) CONST VOID *lpBuffer, __in_ecount(nNumberOfCharsToWrite) CONST VOID *lpBuffer,
__in DWORD nNumberOfCharsToWrite, __in DWORD nNumberOfCharsToWrite,
__out LPDWORD lpNumberOfCharsWritten, __out_opt LPDWORD lpNumberOfCharsWritten,
__reserved LPVOID lpReserved __reserved LPVOID lpReserved);
);
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
WriteConsoleW( WriteConsoleW(
__in HANDLE hConsoleOutput, __in HANDLE hConsoleOutput,
__in_ecount(nNumberOfCharsToWrite) CONST VOID *lpBuffer, __in_ecount(nNumberOfCharsToWrite) CONST VOID *lpBuffer,
__in DWORD nNumberOfCharsToWrite, __in DWORD nNumberOfCharsToWrite,
__out LPDWORD lpNumberOfCharsWritten, __out_opt LPDWORD lpNumberOfCharsWritten,
__reserved LPVOID lpReserved __reserved LPVOID lpReserved);
);
#ifdef UNICODE #ifdef UNICODE
#define WriteConsole WriteConsoleW #define WriteConsole WriteConsoleW
#else #else
#define WriteConsole WriteConsoleA #define WriteConsole WriteConsoleA
#endif // !UNICODE #endif // !UNICODE
#define CONSOLE_TEXTMODE_BUFFER 1 #define CONSOLE_TEXTMODE_BUFFER 1
__allocator __allocator
WINBASEAPI WINBASEAPI
skipping to change at line 898 skipping to change at line 898
__in DWORD dwDesiredAccess, __in DWORD dwDesiredAccess,
__in DWORD dwShareMode, __in DWORD dwShareMode,
__in_opt CONST SECURITY_ATTRIBUTES *lpSecurityAttributes, __in_opt CONST SECURITY_ATTRIBUTES *lpSecurityAttributes,
__in DWORD dwFlags, __in DWORD dwFlags,
__reserved LPVOID lpScreenBufferData __reserved LPVOID lpScreenBufferData
); );
WINBASEAPI WINBASEAPI
UINT UINT
WINAPI WINAPI
GetConsoleCP( VOID ); GetConsoleCP(
VOID);
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
SetConsoleCP( SetConsoleCP(
__in UINT wCodePageID __in UINT wCodePageID
); );
WINBASEAPI WINBASEAPI
UINT UINT
WINAPI WINAPI
GetConsoleOutputCP( VOID ); GetConsoleOutputCP(
VOID);
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
SetConsoleOutputCP( SetConsoleOutputCP(
__in UINT wCodePageID __in UINT wCodePageID
); );
#if(_WIN32_WINNT >= 0x0500) #if(_WIN32_WINNT >= 0x0500)
 End of changes. 13 change blocks. 
21 lines changed or deleted 22 lines changed or added


 winnls.h (6.0.6002.18005-Windows 6.0)   winnls.h (6.1.7601.23418-Windows 7.0) 
skipping to change at line 193 skipping to change at line 193
#define MAP_FOLDDIGITS 0x00000080 // all digits to ASCII 0-9 #define MAP_FOLDDIGITS 0x00000080 // all digits to ASCII 0-9
#if(WINVER >= 0x0500) #if(WINVER >= 0x0500)
#define MAP_EXPAND_LIGATURES 0x00002000 // expand all ligatures #define MAP_EXPAND_LIGATURES 0x00002000 // expand all ligatures
#endif /* WINVER >= 0x0500 */ #endif /* WINVER >= 0x0500 */
// //
// Locale Dependent Mapping Flags. // Locale Dependent Mapping Flags.
// //
#define LCMAP_LOWERCASE 0x00000100 // lower case letters #define LCMAP_LOWERCASE 0x00000100 // lower case letters
#define LCMAP_UPPERCASE 0x00000200 // upper case letters #define LCMAP_UPPERCASE 0x00000200 // UPPER CASE LETTERS
#if (WINVER >= _WIN32_WINNT_WIN7)
#define LCMAP_TITLECASE 0x00000300 // Title Case Letters
#endif // (WINVER >= _WIN32_WINNT_WIN7)
#define LCMAP_SORTKEY 0x00000400 // WC sort key (normalize) #define LCMAP_SORTKEY 0x00000400 // WC sort key (normalize)
#define LCMAP_BYTEREV 0x00000800 // byte reversal #define LCMAP_BYTEREV 0x00000800 // byte reversal
#define LCMAP_HIRAGANA 0x00100000 // map katakana to hiragana #define LCMAP_HIRAGANA 0x00100000 // map katakana to hiragana
#define LCMAP_KATAKANA 0x00200000 // map hiragana to katakana #define LCMAP_KATAKANA 0x00200000 // map hiragana to katakana
#define LCMAP_HALFWIDTH 0x00400000 // map double byte to single byte #define LCMAP_HALFWIDTH 0x00400000 // map double byte to single byte
#define LCMAP_FULLWIDTH 0x00800000 // map single byte to double byte #define LCMAP_FULLWIDTH 0x00800000 // map single byte to double byte
#define LCMAP_LINGUISTIC_CASING 0x01000000 // use linguistic rules for casing #define LCMAP_LINGUISTIC_CASING 0x01000000 // use linguistic rules for casing
skipping to change at line 228 skipping to change at line 232
#define LGRPID_INSTALLED 0x00000001 // installed language group ids #define LGRPID_INSTALLED 0x00000001 // installed language group ids
#define LGRPID_SUPPORTED 0x00000002 // supported language group ids #define LGRPID_SUPPORTED 0x00000002 // supported language group ids
// //
// Locale Enumeration Flags. // Locale Enumeration Flags.
// //
#define LCID_INSTALLED 0x00000001 // installed locale ids #define LCID_INSTALLED 0x00000001 // installed locale ids
#define LCID_SUPPORTED 0x00000002 // supported locale ids #define LCID_SUPPORTED 0x00000002 // supported locale ids
#define LCID_ALTERNATE_SORTS 0x00000004 // alternate sort locale ids #define LCID_ALTERNATE_SORTS 0x00000004 // alternate sort locale ids
#if (WINVER >= 0x0600) #if (WINVER >= _WIN32_WINNT_VISTA)
// //
// Named based enumeration flags. // Named based enumeration flags.
// //
#define LOCALE_ALL 0 // enumerate all named b #define LOCALE_ALL 0 // enumerate all named
ased locales based locales
#define LOCALE_WINDOWS 0x00000001 // shipped locales and/o #define LOCALE_WINDOWS 0x00000001 // shipped locales and
r replacements for them /or replacements for them
#define LOCALE_SUPPLEMENTAL 0x00000002 // supplemental locales #define LOCALE_SUPPLEMENTAL 0x00000002 // supplemental locale
only s only
#define LOCALE_ALTERNATE_SORTS 0x00000004 // alternate sort locale #define LOCALE_ALTERNATE_SORTS 0x00000004 // alternate sort loca
s les
#define LOCALE_REPLACEMENT 0x00000008 // replacement locales o #define LOCALE_REPLACEMENT 0x00000008 // locales that replac
nly (supplemental - custom) e shipped locales (callback flag only)
#endif // (WINVER >= 0x0600) #endif // (WINVER >= _WIN32_WINNT_VISTA)
#if (WINVER >= _WIN32_WINNT_WIN7)
#define LOCALE_NEUTRALDATA 0x00000010 // Locales that are "n
eutral" (language only, region data is default)
#define LOCALE_SPECIFICDATA 0x00000020 // Locales that contai
n language and region data
#endif // (WINVER >= _WIN32_WINNT_WIN7)
// //
// Code Page Enumeration Flags. // Code Page Enumeration Flags.
// //
#define CP_INSTALLED 0x00000001 // installed code page ids #define CP_INSTALLED 0x00000001 // installed code page ids
#define CP_SUPPORTED 0x00000002 // supported code page ids #define CP_SUPPORTED 0x00000002 // supported code page ids
// //
// Sorting Flags. // Sorting Flags.
// //
skipping to change at line 277 skipping to change at line 285
// coat // coat
// comb // comb
// coop // coop
// cork // cork
// we're <------- apostrophe (punctuation) // we're <------- apostrophe (punctuation)
// went // went
// were // were
// //
#define SORT_STRINGSORT 0x00001000 // use string sort method #define SORT_STRINGSORT 0x00001000 // use string sort method
// Sort digits as numbers (ie: 2 comes before 10)
#if (WINVER >= _WIN32_WINNT_WIN7)
#define SORT_DIGITSASNUMBERS 0x00000008 // use digits as numbers sort meth
od
#endif // (WINVER >= _WIN32_WINNT_WIN7)
// //
// Compare String Return Values. // Compare String Return Values.
// //
#define CSTR_LESS_THAN 1 // string 1 less than string 2 #define CSTR_LESS_THAN 1 // string 1 less than string 2
#define CSTR_EQUAL 2 // string 1 equal to string 2 #define CSTR_EQUAL 2 // string 1 equal to string 2
#define CSTR_GREATER_THAN 3 // string 1 greater than string 2 #define CSTR_GREATER_THAN 3 // string 1 greater than string 2
// //
// Code Page Default Values. // Code Page Default Values.
// //
skipping to change at line 440 skipping to change at line 453
// number instead of a string. This flag is only valid for the LCTypes // number instead of a string. This flag is only valid for the LCTypes
// beginning with LOCALE_I. // beginning with LOCALE_I.
// //
#define LOCALE_NOUSEROVERRIDE 0x80000000 // do not use user overrides #define LOCALE_NOUSEROVERRIDE 0x80000000 // do not use user overrides
#define LOCALE_USE_CP_ACP 0x40000000 // use the system ACP #define LOCALE_USE_CP_ACP 0x40000000 // use the system ACP
#if(WINVER >= 0x0400) #if(WINVER >= 0x0400)
#define LOCALE_RETURN_NUMBER 0x20000000 // return number instead of s tring #define LOCALE_RETURN_NUMBER 0x20000000 // return number instead of s tring
#endif /* WINVER >= 0x0400 */ #endif /* WINVER >= 0x0400 */
#if (WINVER >= _WIN32_WINNT_WIN7)
#define LOCALE_RETURN_GENITIVE_NAMES 0x10000000 //Flag to return the Genitive
forms of month names
#define LOCALE_ALLOW_NEUTRAL_NAMES 0x08000000 //Flag to allow returning neu
tral names/lcids for name conversion
#endif //(WINVER >= _WIN32_WINNT_WIN7)
// //
// The following LCTypes are mutually exclusive in that they may NOT // The following LCTypes are mutually exclusive in that they may NOT
// be used in combination with each other. // be used in combination with each other.
// //
#define LOCALE_ILANGUAGE 0x00000001 // language id
#define LOCALE_SLANGUAGE 0x00000002 // localized name of language
#define LOCALE_SENGLANGUAGE 0x00001001 // English name of language
#define LOCALE_SABBREVLANGNAME 0x00000003 // abbreviated language name
#define LOCALE_SNATIVELANGNAME 0x00000004 // native name of language
#define LOCALE_ICOUNTRY 0x00000005 // country code //
#define LOCALE_SCOUNTRY 0x00000006 // localized name of country // These are the various forms of the name of the locale:
#define LOCALE_SENGCOUNTRY 0x00001002 // English name of country //
#define LOCALE_SABBREVCTRYNAME 0x00000007 // abbreviated country name #define LOCALE_SLOCALIZEDDISPLAYNAME 0x00000002 // localized name of locale,
#define LOCALE_SNATIVECTRYNAME 0x00000008 // native name of country eg "German (Germany)" in UI language
#define LOCALE_IGEOID 0x0000005B // geographical location id #if (WINVER >= _WIN32_WINNT_WIN7)
#define LOCALE_SENGLISHDISPLAYNAME 0x00000072 // Display name (language + c
ountry usually) in English, eg "German (Germany)"
#define LOCALE_SNATIVEDISPLAYNAME 0x00000073 // Display name in native loc
ale language, eg "Deutsch (Deutschland)
#endif //(WINVER >= _WIN32_WINNT_WIN7)
#define LOCALE_IDEFAULTLANGUAGE 0x00000009 // default language id #if (WINVER >= _WIN32_WINNT_VISTA)
#define LOCALE_IDEFAULTCOUNTRY 0x0000000A // default country code #define LOCALE_SLOCALIZEDLANGUAGENAME 0x0000006f // Language Display Name for
#define LOCALE_IDEFAULTCODEPAGE 0x0000000B // default oem code page a language, eg "German" in UI language
#define LOCALE_IDEFAULTANSICODEPAGE 0x00001004 // default ansi code page #endif //(WINVER >= _WIN32_WINNT_VISTA)
#define LOCALE_IDEFAULTMACCODEPAGE 0x00001011 // default mac code page #define LOCALE_SENGLISHLANGUAGENAME 0x00001001 // English name of language,
eg "German"
#define LOCALE_SNATIVELANGUAGENAME 0x00000004 // native name of language, e
g "Deutsch"
#define LOCALE_SLIST 0x0000000C // list item separator #define LOCALE_SLOCALIZEDCOUNTRYNAME 0x00000006 // localized name of country,
#define LOCALE_IMEASURE 0x0000000D // 0 = metric, 1 = US eg "Germany" in UI language
#define LOCALE_SENGLISHCOUNTRYNAME 0x00001002 // English name of country, e
g "Germany"
#define LOCALE_SNATIVECOUNTRYNAME 0x00000008 // native name of country, eg
"Deutschland"
#define LOCALE_SDECIMAL 0x0000000E // decimal separator //
#define LOCALE_STHOUSAND 0x0000000F // thousand separator // Legacy labels for the locale name values
#define LOCALE_SGROUPING 0x00000010 // digit grouping //
#define LOCALE_IDIGITS 0x00000011 // number of fractional digit #define LOCALE_SLANGUAGE 0x00000002 // localized name of locale,
s eg "German (Germany)" in UI language
#define LOCALE_ILZERO 0x00000012 // leading zeros for decimal #if (WINVER >= _WIN32_WINNT_VISTA)
#define LOCALE_INEGNUMBER 0x00001010 // negative number mode #define LOCALE_SLANGDISPLAYNAME 0x0000006f // Language Display Name for
#define LOCALE_SNATIVEDIGITS 0x00000013 // native digits for 0-9 a language, eg "German" in UI language
#endif //(WINVER >= _WIN32_WINNT_VISTA)
#define LOCALE_SENGLANGUAGE 0x00001001 // English name of language,
eg "German"
#define LOCALE_SNATIVELANGNAME 0x00000004 // native name of language, e
g "Deutsch"
#define LOCALE_SCOUNTRY 0x00000006 // localized name of country,
eg "Germany" in UI language
#define LOCALE_SENGCOUNTRY 0x00001002 // English name of country, e
g "Germany"
#define LOCALE_SNATIVECTRYNAME 0x00000008 // native name of country, eg
"Deutschland"
#define LOCALE_SCURRENCY 0x00000014 // local monetary symbol // Additional LCTypes
#define LOCALE_SINTLSYMBOL 0x00000015 // intl monetary symbol #define LOCALE_ILANGUAGE 0x00000001 // language id, LOCALE_SNAME
#define LOCALE_SMONDECIMALSEP 0x00000016 // monetary decimal separator preferred
#define LOCALE_SMONTHOUSANDSEP 0x00000017 // monetary thousand separato
r #define LOCALE_SABBREVLANGNAME 0x00000003 // arbitrary abbreviated lang
#define LOCALE_SMONGROUPING 0x00000018 // monetary grouping uage name, LOCALE_SISO639LANGNAME preferred
#define LOCALE_ICURRDIGITS 0x00000019 // # local monetary digits
#define LOCALE_IINTLCURRDIGITS 0x0000001A // # intl monetary digits #define LOCALE_ICOUNTRY 0x00000005 // country code, eg 1, LOCALE
#define LOCALE_ICURRENCY 0x0000001B // positive currency mode _SISO3166CTRYNAME may be more useful.
#define LOCALE_INEGCURR 0x0000001C // negative currency mode #define LOCALE_SABBREVCTRYNAME 0x00000007 // arbitrary abbreviated coun
try name, LOCALE_SISO3166CTRYNAME preferred
#define LOCALE_IGEOID 0x0000005B // geographical location id,
eg "244"
#define LOCALE_IDEFAULTLANGUAGE 0x00000009 // default language id, depre
cated
#define LOCALE_IDEFAULTCOUNTRY 0x0000000A // default country code, depr
ecated
#define LOCALE_IDEFAULTCODEPAGE 0x0000000B // default oem code page (use
of Unicode is recommended instead)
#define LOCALE_IDEFAULTANSICODEPAGE 0x00001004 // default ansi code page (us
e of Unicode is recommended instead)
#define LOCALE_IDEFAULTMACCODEPAGE 0x00001011 // default mac code page (use
of Unicode is recommended instead)
#define LOCALE_SLIST 0x0000000C // list item separator, eg ",
" for "1,2,3,4"
#define LOCALE_IMEASURE 0x0000000D // 0 = metric, 1 = US measure
ment system
#define LOCALE_SDECIMAL 0x0000000E // decimal separator, eg "."
for 1,234.00
#define LOCALE_STHOUSAND 0x0000000F // thousand separator, eg ","
for 1,234.00
#define LOCALE_SGROUPING 0x00000010 // digit grouping, eg "3;0" f
or 1,000,000
#define LOCALE_IDIGITS 0x00000011 // number of fractional digit
s eg 2 for 1.00
#define LOCALE_ILZERO 0x00000012 // leading zeros for decimal,
0 for .97, 1 for 0.97
#define LOCALE_INEGNUMBER 0x00001010 // negative number mode, 0-4,
see documentation
#define LOCALE_SNATIVEDIGITS 0x00000013 // native digits for 0-9, eg
"0123456789"
#define LOCALE_SCURRENCY 0x00000014 // local monetary symbol, eg
"$"
#define LOCALE_SINTLSYMBOL 0x00000015 // intl monetary symbol, eg "
USD"
#define LOCALE_SMONDECIMALSEP 0x00000016 // monetary decimal separator
, eg "." for $1,234.00
#define LOCALE_SMONTHOUSANDSEP 0x00000017 // monetary thousand separato
r, eg "," for $1,234.00
#define LOCALE_SMONGROUPING 0x00000018 // monetary grouping, eg "3;0
" for $1,000,000.00
#define LOCALE_ICURRDIGITS 0x00000019 // # local monetary digits, e
g 2 for $1.00
#define LOCALE_IINTLCURRDIGITS 0x0000001A // # intl monetary digits, eg
2 for $1.00
#define LOCALE_ICURRENCY 0x0000001B // positive currency mode, 0-
3, see documenation
#define LOCALE_INEGCURR 0x0000001C // negative currency mode, 0-
15, see documentation
#define LOCALE_SDATE 0x0000001D // date separator (derived fr om LOCALE_SSHORTDATE, use that instead) #define LOCALE_SDATE 0x0000001D // date separator (derived fr om LOCALE_SSHORTDATE, use that instead)
#define LOCALE_STIME 0x0000001E // time separator (derived fr om LOCALE_STIMEFORMAT, use that instead) #define LOCALE_STIME 0x0000001E // time separator (derived fr om LOCALE_STIMEFORMAT, use that instead)
#define LOCALE_SSHORTDATE 0x0000001F // short date format string #define LOCALE_SSHORTDATE 0x0000001F // short date format string,
#define LOCALE_SLONGDATE 0x00000020 // long date format string eg "MM/dd/yyyy"
#define LOCALE_STIMEFORMAT 0x00001003 // time format string #define LOCALE_SLONGDATE 0x00000020 // long date format string, e
g "dddd, MMMM dd, yyyy"
#define LOCALE_STIMEFORMAT 0x00001003 // time format string, eg "HH
:mm:ss"
#define LOCALE_IDATE 0x00000021 // short date format ordering (derived from LOCALE_SSHORTDATE, use that instead) #define LOCALE_IDATE 0x00000021 // short date format ordering (derived from LOCALE_SSHORTDATE, use that instead)
#define LOCALE_ILDATE 0x00000022 // long date format ordering (derived from LOCALE_SLONGDATE, use that instead) #define LOCALE_ILDATE 0x00000022 // long date format ordering (derived from LOCALE_SLONGDATE, use that instead)
#define LOCALE_ITIME 0x00000023 // time format specifier (der ived from LOCALE_STIMEFORMAT, use that instead) #define LOCALE_ITIME 0x00000023 // time format specifier (der ived from LOCALE_STIMEFORMAT, use that instead)
#define LOCALE_ITIMEMARKPOSN 0x00001005 // time marker position (deri ved from LOCALE_STIMEFORMAT, use that instead) #define LOCALE_ITIMEMARKPOSN 0x00001005 // time marker position (deri ved from LOCALE_STIMEFORMAT, use that instead)
#define LOCALE_ICENTURY 0x00000024 // century format specifier ( short date, LOCALE_SSHORTDATE is preferred) #define LOCALE_ICENTURY 0x00000024 // century format specifier ( short date, LOCALE_SSHORTDATE is preferred)
#define LOCALE_ITLZERO 0x00000025 // leading zeros in time fiel d (derived from LOCALE_STIMEFORMAT, use that instead) #define LOCALE_ITLZERO 0x00000025 // leading zeros in time fiel d (derived from LOCALE_STIMEFORMAT, use that instead)
#define LOCALE_IDAYLZERO 0x00000026 // leading zeros in day field (short date, LOCALE_SSHORTDATE is preferred) #define LOCALE_IDAYLZERO 0x00000026 // leading zeros in day field (short date, LOCALE_SSHORTDATE is preferred)
#define LOCALE_IMONLZERO 0x00000027 // leading zeros in month fie ld (short date, LOCALE_SSHORTDATE is preferred) #define LOCALE_IMONLZERO 0x00000027 // leading zeros in month fie ld (short date, LOCALE_SSHORTDATE is preferred)
#define LOCALE_S1159 0x00000028 // AM designator #define LOCALE_S1159 0x00000028 // AM designator, eg "AM"
#define LOCALE_S2359 0x00000029 // PM designator #define LOCALE_S2359 0x00000029 // PM designator, eg "PM"
#define LOCALE_ICALENDARTYPE 0x00001009 // type of calendar specifier #define LOCALE_ICALENDARTYPE 0x00001009 // type of calendar specifier
#define LOCALE_IOPTIONALCALENDAR 0x0000100B // additional calendar types , eg CAL_GREGORIAN
specifier #define LOCALE_IOPTIONALCALENDAR 0x0000100B // additional calendar types
#define LOCALE_IFIRSTDAYOFWEEK 0x0000100C // first day of week specifie specifier, eg CAL_GREGORIAN_US
r #define LOCALE_IFIRSTDAYOFWEEK 0x0000100C // first day of week specifie
#define LOCALE_IFIRSTWEEKOFYEAR 0x0000100D // first week of year specifi r, 0-6, 0=Monday, 6=Sunday
er #define LOCALE_IFIRSTWEEKOFYEAR 0x0000100D // first week of year specifi
er, 0-2, see documentation
#define LOCALE_SDAYNAME1 0x0000002A // long name for Monday #define LOCALE_SDAYNAME1 0x0000002A // long name for Monday
#define LOCALE_SDAYNAME2 0x0000002B // long name for Tuesday #define LOCALE_SDAYNAME2 0x0000002B // long name for Tuesday
#define LOCALE_SDAYNAME3 0x0000002C // long name for Wednesday #define LOCALE_SDAYNAME3 0x0000002C // long name for Wednesday
#define LOCALE_SDAYNAME4 0x0000002D // long name for Thursday #define LOCALE_SDAYNAME4 0x0000002D // long name for Thursday
#define LOCALE_SDAYNAME5 0x0000002E // long name for Friday #define LOCALE_SDAYNAME5 0x0000002E // long name for Friday
#define LOCALE_SDAYNAME6 0x0000002F // long name for Saturday #define LOCALE_SDAYNAME6 0x0000002F // long name for Saturday
#define LOCALE_SDAYNAME7 0x00000030 // long name for Sunday #define LOCALE_SDAYNAME7 0x00000030 // long name for Sunday
#define LOCALE_SABBREVDAYNAME1 0x00000031 // abbreviated name for Monda y #define LOCALE_SABBREVDAYNAME1 0x00000031 // abbreviated name for Monda y
#define LOCALE_SABBREVDAYNAME2 0x00000032 // abbreviated name for Tuesd ay #define LOCALE_SABBREVDAYNAME2 0x00000032 // abbreviated name for Tuesd ay
skipping to change at line 546 skipping to change at line 593
#define LOCALE_SABBREVMONTHNAME5 0x00000048 // abbreviated name for May #define LOCALE_SABBREVMONTHNAME5 0x00000048 // abbreviated name for May
#define LOCALE_SABBREVMONTHNAME6 0x00000049 // abbreviated name for June #define LOCALE_SABBREVMONTHNAME6 0x00000049 // abbreviated name for June
#define LOCALE_SABBREVMONTHNAME7 0x0000004A // abbreviated name for July #define LOCALE_SABBREVMONTHNAME7 0x0000004A // abbreviated name for July
#define LOCALE_SABBREVMONTHNAME8 0x0000004B // abbreviated name for Augus t #define LOCALE_SABBREVMONTHNAME8 0x0000004B // abbreviated name for Augus t
#define LOCALE_SABBREVMONTHNAME9 0x0000004C // abbreviated name for Septe mber #define LOCALE_SABBREVMONTHNAME9 0x0000004C // abbreviated name for Septe mber
#define LOCALE_SABBREVMONTHNAME10 0x0000004D // abbreviated name for Octob er #define LOCALE_SABBREVMONTHNAME10 0x0000004D // abbreviated name for Octob er
#define LOCALE_SABBREVMONTHNAME11 0x0000004E // abbreviated name for Novem ber #define LOCALE_SABBREVMONTHNAME11 0x0000004E // abbreviated name for Novem ber
#define LOCALE_SABBREVMONTHNAME12 0x0000004F // abbreviated name for Decem ber #define LOCALE_SABBREVMONTHNAME12 0x0000004F // abbreviated name for Decem ber
#define LOCALE_SABBREVMONTHNAME13 0x0000100F // abbreviated name for 13th month (if exists) #define LOCALE_SABBREVMONTHNAME13 0x0000100F // abbreviated name for 13th month (if exists)
#define LOCALE_SPOSITIVESIGN 0x00000050 // positive sign #define LOCALE_SPOSITIVESIGN 0x00000050 // positive sign, eg ""
#define LOCALE_SNEGATIVESIGN 0x00000051 // negative sign #define LOCALE_SNEGATIVESIGN 0x00000051 // negative sign, eg "-"
#define LOCALE_IPOSSIGNPOSN 0x00000052 // positive sign position (de rived from INEGCURR) #define LOCALE_IPOSSIGNPOSN 0x00000052 // positive sign position (de rived from INEGCURR)
#define LOCALE_INEGSIGNPOSN 0x00000053 // negative sign position (de rived from INEGCURR) #define LOCALE_INEGSIGNPOSN 0x00000053 // negative sign position (de rived from INEGCURR)
#define LOCALE_IPOSSYMPRECEDES 0x00000054 // mon sym precedes pos amt ( derived from ICURRENCY) #define LOCALE_IPOSSYMPRECEDES 0x00000054 // mon sym precedes pos amt ( derived from ICURRENCY)
#define LOCALE_IPOSSEPBYSPACE 0x00000055 // mon sym sep by space from pos amt (derived from ICURRENCY) #define LOCALE_IPOSSEPBYSPACE 0x00000055 // mon sym sep by space from pos amt (derived from ICURRENCY)
#define LOCALE_INEGSYMPRECEDES 0x00000056 // mon sym precedes neg amt ( derived from INEGCURR) #define LOCALE_INEGSYMPRECEDES 0x00000056 // mon sym precedes neg amt ( derived from INEGCURR)
#define LOCALE_INEGSEPBYSPACE 0x00000057 // mon sym sep by space from neg amt (derived from INEGCURR) #define LOCALE_INEGSEPBYSPACE 0x00000057 // mon sym sep by space from neg amt (derived from INEGCURR)
#if(WINVER >= 0x0400) #if(WINVER >= 0x0400)
#define LOCALE_FONTSIGNATURE 0x00000058 // font signature #define LOCALE_FONTSIGNATURE 0x00000058 // font signature
#define LOCALE_SISO639LANGNAME 0x00000059 // ISO abbreviated language n #define LOCALE_SISO639LANGNAME 0x00000059 // ISO abbreviated language n
ame ame, eg "en"
#define LOCALE_SISO3166CTRYNAME 0x0000005A // ISO abbreviated country na #define LOCALE_SISO3166CTRYNAME 0x0000005A // ISO abbreviated country na
me me, eg "US"
#endif /* WINVER >= 0x0400 */ #endif /* WINVER >= 0x0400 */
#if(WINVER >= 0x0500) #if(WINVER >= 0x0500)
#define LOCALE_IDEFAULTEBCDICCODEPAGE 0x00001012 // default ebcdic code page #define LOCALE_IDEFAULTEBCDICCODEPAGE 0x00001012 // default ebcdic code page ( use of Unicode is recommended instead)
#define LOCALE_IPAPERSIZE 0x0000100A // 1 = letter, 5 = legal, 8 = a3, 9 = a4 #define LOCALE_IPAPERSIZE 0x0000100A // 1 = letter, 5 = legal, 8 = a3, 9 = a4
#define LOCALE_SENGCURRNAME 0x00001007 // english name of currency #define LOCALE_SENGCURRNAME 0x00001007 // english name of currency,
#define LOCALE_SNATIVECURRNAME 0x00001008 // native name of currency eg "Euro"
#define LOCALE_SYEARMONTH 0x00001006 // year month format string #define LOCALE_SNATIVECURRNAME 0x00001008 // native name of currency, e
#define LOCALE_SSORTNAME 0x00001013 // sort name g "euro"
#define LOCALE_SYEARMONTH 0x00001006 // year month format string,
eg "MM/yyyy"
#define LOCALE_SSORTNAME 0x00001013 // sort name, usually "", eg
"Dictionary" in UI Language
#define LOCALE_IDIGITSUBSTITUTION 0x00001014 // 0 = context, 1 = none, 2 = national #define LOCALE_IDIGITSUBSTITUTION 0x00001014 // 0 = context, 1 = none, 2 = national
#endif /* WINVER >= 0x0500 */ #endif /* WINVER >= 0x0500 */
#if (WINVER >= 0x0600) #if (WINVER >= 0x0600)
#define LOCALE_SNAME 0x0000005c // locale name (ie: en-us) #define LOCALE_SNAME 0x0000005c // locale name (ie: en-us)
#define LOCALE_SDURATION 0x0000005d // time duration format #define LOCALE_SDURATION 0x0000005d // time duration format, eg "
#define LOCALE_SKEYBOARDSTOINSTALL 0x0000005e hh:mm:ss"
#define LOCALE_SKEYBOARDSTOINSTALL 0x0000005e // Used internally, see GetKe
yboardLayoutName() function
#define LOCALE_SSHORTESTDAYNAME1 0x00000060 // Shortest day name for Mond ay #define LOCALE_SSHORTESTDAYNAME1 0x00000060 // Shortest day name for Mond ay
#define LOCALE_SSHORTESTDAYNAME2 0x00000061 // Shortest day name for Tues day #define LOCALE_SSHORTESTDAYNAME2 0x00000061 // Shortest day name for Tues day
#define LOCALE_SSHORTESTDAYNAME3 0x00000062 // Shortest day name for Wedn esday #define LOCALE_SSHORTESTDAYNAME3 0x00000062 // Shortest day name for Wedn esday
#define LOCALE_SSHORTESTDAYNAME4 0x00000063 // Shortest day name for Thur sday #define LOCALE_SSHORTESTDAYNAME4 0x00000063 // Shortest day name for Thur sday
#define LOCALE_SSHORTESTDAYNAME5 0x00000064 // Shortest day name for Frid ay #define LOCALE_SSHORTESTDAYNAME5 0x00000064 // Shortest day name for Frid ay
#define LOCALE_SSHORTESTDAYNAME6 0x00000065 // Shortest day name for Satu rday #define LOCALE_SSHORTESTDAYNAME6 0x00000065 // Shortest day name for Satu rday
#define LOCALE_SSHORTESTDAYNAME7 0x00000066 // Shortest day name for Sund ay #define LOCALE_SSHORTESTDAYNAME7 0x00000066 // Shortest day name for Sund ay
#define LOCALE_SISO639LANGNAME2 0x00000067 // 3 character ISO abbreviate #define LOCALE_SISO639LANGNAME2 0x00000067 // 3 character ISO abbreviate
d language name d language name, eg "eng"
#define LOCALE_SISO3166CTRYNAME2 0x00000068 // 3 character ISO country na #define LOCALE_SISO3166CTRYNAME2 0x00000068 // 3 character ISO country na
me me, eg "USA"
#define LOCALE_SNAN 0x00000069 // Not a Number #define LOCALE_SNAN 0x00000069 // Not a Number, eg "NaN"
#define LOCALE_SPOSINFINITY 0x0000006a // + Infinity #define LOCALE_SPOSINFINITY 0x0000006a // + Infinity, eg "infinity"
#define LOCALE_SNEGINFINITY 0x0000006b // - Infinity #define LOCALE_SNEGINFINITY 0x0000006b // - Infinity, eg "-infinity"
#define LOCALE_SSCRIPTS 0x0000006c // Typical scripts in the loc #define LOCALE_SSCRIPTS 0x0000006c // Typical scripts in the loc
ale ale: ; delimited script codes, eg "Latn;"
#define LOCALE_SPARENT 0x0000006d // Fallback name for resource #define LOCALE_SPARENT 0x0000006d // Fallback name for resource
s s, eg "en" for "en-US"
#define LOCALE_SCONSOLEFALLBACKNAME 0x0000006e // Fallback name for within t #define LOCALE_SCONSOLEFALLBACKNAME 0x0000006e // Fallback name for within t
he console he console for Unicode Only locales, eg "en" for bn-IN
#define LOCALE_SLANGDISPLAYNAME 0x0000006f // Lanugage Display Name for
a language
#endif //(WINVER >= 0x0600) #endif //(WINVER >= 0x0600)
#if (WINVER >= _WIN32_WINNT_WIN7)
#define LOCALE_IREADINGLAYOUT 0x00000070 // Returns one of the followi
ng 4 reading layout values:
// 0 - Left to right (eg en-U
S)
// 1 - Right to left (eg arab
ic locales)
// 2 - Vertical top to bottom
with columns to the left and also left to right (ja-JP locales)
// 3 - Vertical top to bottom
with columns proceeding to the right
#define LOCALE_INEUTRAL 0x00000071 // Returns 0 for specific cul
tures, 1 for neutral cultures.
#define LOCALE_INEGATIVEPERCENT 0x00000074 // Returns 0-11 for the negat
ive percent format
#define LOCALE_IPOSITIVEPERCENT 0x00000075 // Returns 0-3 for the positi
ve percent formatIPOSITIVEPERCENT
#define LOCALE_SPERCENT 0x00000076 // Returns the percent symbol
#define LOCALE_SPERMILLE 0x00000077 // Returns the permille (U+20
30) symbol
#define LOCALE_SMONTHDAY 0x00000078 // Returns the preferred mont
h/day format
#define LOCALE_SSHORTTIME 0x00000079 // Returns the preferred shor
t time format (ie: no seconds, just h:mm)
#define LOCALE_SOPENTYPELANGUAGETAG 0x0000007a // Open type language tag, eg
: "latn" or "dflt"
#define LOCALE_SSORTLOCALE 0x0000007b // Name of locale to use for
sorting/collation/casing behavior.
#endif //(WINVER >= _WIN32_WINNT_WIN7)
// //
// Time Flags for GetTimeFormat. // Time Flags for GetTimeFormat.
// //
#define TIME_NOMINUTESORSECONDS 0x00000001 // do not use minutes or seconds #define TIME_NOMINUTESORSECONDS 0x00000001 // do not use minutes or seconds
#define TIME_NOSECONDS 0x00000002 // do not use seconds #define TIME_NOSECONDS 0x00000002 // do not use seconds
#define TIME_NOTIMEMARKER 0x00000004 // do not use time marker #define TIME_NOTIMEMARKER 0x00000004 // do not use time marker
#define TIME_FORCE24HOURFORMAT 0x00000008 // always use 24 hour format #define TIME_FORCE24HOURFORMAT 0x00000008 // always use 24 hour format
// //
// Date Flags for GetDateFormat. // Date Flags for GetDateFormat.
skipping to change at line 615 skipping to change at line 678
#define DATE_SHORTDATE 0x00000001 // use short date picture #define DATE_SHORTDATE 0x00000001 // use short date picture
#define DATE_LONGDATE 0x00000002 // use long date picture #define DATE_LONGDATE 0x00000002 // use long date picture
#define DATE_USE_ALT_CALENDAR 0x00000004 // use alternate calendar (if any) #define DATE_USE_ALT_CALENDAR 0x00000004 // use alternate calendar (if any)
#if(WINVER >= 0x0500) #if(WINVER >= 0x0500)
#define DATE_YEARMONTH 0x00000008 // use year month picture #define DATE_YEARMONTH 0x00000008 // use year month picture
#define DATE_LTRREADING 0x00000010 // add marks for left to right rea ding order layout #define DATE_LTRREADING 0x00000010 // add marks for left to right rea ding order layout
#define DATE_RTLREADING 0x00000020 // add marks for right to left rea ding order layout #define DATE_RTLREADING 0x00000020 // add marks for right to left rea ding order layout
#endif /* WINVER >= 0x0500 */ #endif /* WINVER >= 0x0500 */
#if (WINVER >= _WIN32_WINNT_WIN7)
#define DATE_AUTOLAYOUT 0x00000040 // add appropriate marks for lef
t-to-right or right-to-left reading order layout
#endif //(WINVER >= _WIN32_WINNT_WIN7)
// //
// Calendar Types. // Calendar Types.
// //
// These types are used for the EnumCalendarInfo and GetCalendarInfo // These types are used for the EnumCalendarInfo and GetCalendarInfo
// NLS API routines. // NLS API routines.
// Some of these types are also used for the SetCalendarInfo NLS API // Some of these types are also used for the SetCalendarInfo NLS API
// routine. // routine.
// //
// //
skipping to change at line 637 skipping to change at line 704
// CAL_NOUSEROVERRIDE // CAL_NOUSEROVERRIDE
// //
// CAL_USE_CP_ACP is used in the A (Ansi) apis that need to do string // CAL_USE_CP_ACP is used in the A (Ansi) apis that need to do string
// translation. // translation.
// //
// CAL_RETURN_NUMBER will return the result from GetCalendarInfo as a // CAL_RETURN_NUMBER will return the result from GetCalendarInfo as a
// number instead of a string. This flag is only valid for the CalTypes // number instead of a string. This flag is only valid for the CalTypes
// beginning with CAL_I. // beginning with CAL_I.
// //
#if(WINVER >= 0x0500) #if(WINVER >= 0x0500)
#define CAL_NOUSEROVERRIDE LOCALE_NOUSEROVERRIDE // do not use user over #define CAL_NOUSEROVERRIDE LOCALE_NOUSEROVERRIDE // do not use us
rides er overrides
#define CAL_USE_CP_ACP LOCALE_USE_CP_ACP // use the system ACP #define CAL_USE_CP_ACP LOCALE_USE_CP_ACP // use the syste
#define CAL_RETURN_NUMBER LOCALE_RETURN_NUMBER // return number instea m ACP
d of string #define CAL_RETURN_NUMBER LOCALE_RETURN_NUMBER // return number
instead of string
#endif /* WINVER >= 0x0500 */ #endif /* WINVER >= 0x0500 */
#if (WINVER >= _WIN32_WINNT_WIN7)
#define CAL_RETURN_GENITIVE_NAMES LOCALE_RETURN_GENITIVE_NAMES // return geniti
ve forms of month names
#endif // winver >= windows 7
// //
// The following CalTypes are mutually exclusive in that they may NOT // The following CalTypes are mutually exclusive in that they may NOT
// be used in combination with each other. // be used in combination with each other.
// //
#define CAL_ICALINTVALUE 0x00000001 // calendar type #define CAL_ICALINTVALUE 0x00000001 // calendar type
#define CAL_SCALNAME 0x00000002 // native name of calendar #define CAL_SCALNAME 0x00000002 // native name of calendar
#define CAL_IYEAROFFSETRANGE 0x00000003 // starting years of eras #define CAL_IYEAROFFSETRANGE 0x00000003 // starting years of eras
#define CAL_SERASTRING 0x00000004 // era name for IYearOffsetRanges #define CAL_SERASTRING 0x00000004 // era name for IYearOffsetRanges, eg A.D.
#define CAL_SSHORTDATE 0x00000005 // short date format string #define CAL_SSHORTDATE 0x00000005 // short date format string
#define CAL_SLONGDATE 0x00000006 // long date format string #define CAL_SLONGDATE 0x00000006 // long date format string
#define CAL_SDAYNAME1 0x00000007 // native name for Monday #define CAL_SDAYNAME1 0x00000007 // native name for Monday
#define CAL_SDAYNAME2 0x00000008 // native name for Tuesday #define CAL_SDAYNAME2 0x00000008 // native name for Tuesday
#define CAL_SDAYNAME3 0x00000009 // native name for Wednesday #define CAL_SDAYNAME3 0x00000009 // native name for Wednesday
#define CAL_SDAYNAME4 0x0000000a // native name for Thursday #define CAL_SDAYNAME4 0x0000000a // native name for Thursday
#define CAL_SDAYNAME5 0x0000000b // native name for Friday #define CAL_SDAYNAME5 0x0000000b // native name for Friday
#define CAL_SDAYNAME6 0x0000000c // native name for Saturday #define CAL_SDAYNAME6 0x0000000c // native name for Saturday
#define CAL_SDAYNAME7 0x0000000d // native name for Sunday #define CAL_SDAYNAME7 0x0000000d // native name for Sunday
#define CAL_SABBREVDAYNAME1 0x0000000e // abbreviated name for Monday #define CAL_SABBREVDAYNAME1 0x0000000e // abbreviated name for Mon
#define CAL_SABBREVDAYNAME2 0x0000000f // abbreviated name for Tuesday #define CAL_SABBREVDAYNAME2 0x0000000f // abbreviated name for Tue
#define CAL_SABBREVDAYNAME3 0x00000010 // abbreviated name for Wednesday #define CAL_SABBREVDAYNAME3 0x00000010 // abbreviated name for Wed
#define CAL_SABBREVDAYNAME4 0x00000011 // abbreviated name for Thursday #define CAL_SABBREVDAYNAME4 0x00000011 // abbreviated name for Thu
#define CAL_SABBREVDAYNAME5 0x00000012 // abbreviated name for Friday #define CAL_SABBREVDAYNAME5 0x00000012 // abbreviated name for Fri
#define CAL_SABBREVDAYNAME6 0x00000013 // abbreviated name for Saturday #define CAL_SABBREVDAYNAME6 0x00000013 // abbreviated name for Sat
#define CAL_SABBREVDAYNAME7 0x00000014 // abbreviated name for Sunday #define CAL_SABBREVDAYNAME7 0x00000014 // abbreviated name for Sun
// Note that in the hebrew calendar the leap month name is always returned as th
e 7th month
#define CAL_SMONTHNAME1 0x00000015 // native name for January #define CAL_SMONTHNAME1 0x00000015 // native name for January
#define CAL_SMONTHNAME2 0x00000016 // native name for February #define CAL_SMONTHNAME2 0x00000016 // native name for February
#define CAL_SMONTHNAME3 0x00000017 // native name for March #define CAL_SMONTHNAME3 0x00000017 // native name for March
#define CAL_SMONTHNAME4 0x00000018 // native name for April #define CAL_SMONTHNAME4 0x00000018 // native name for April
#define CAL_SMONTHNAME5 0x00000019 // native name for May #define CAL_SMONTHNAME5 0x00000019 // native name for May
#define CAL_SMONTHNAME6 0x0000001a // native name for June #define CAL_SMONTHNAME6 0x0000001a // native name for June
#define CAL_SMONTHNAME7 0x0000001b // native name for July #define CAL_SMONTHNAME7 0x0000001b // native name for July
#define CAL_SMONTHNAME8 0x0000001c // native name for August #define CAL_SMONTHNAME8 0x0000001c // native name for August
#define CAL_SMONTHNAME9 0x0000001d // native name for September #define CAL_SMONTHNAME9 0x0000001d // native name for September
#define CAL_SMONTHNAME10 0x0000001e // native name for October #define CAL_SMONTHNAME10 0x0000001e // native name for October
#define CAL_SMONTHNAME11 0x0000001f // native name for November #define CAL_SMONTHNAME11 0x0000001f // native name for November
#define CAL_SMONTHNAME12 0x00000020 // native name for December #define CAL_SMONTHNAME12 0x00000020 // native name for December
#define CAL_SMONTHNAME13 0x00000021 // native name for 13th month (if any) #define CAL_SMONTHNAME13 0x00000021 // native name for 13th month (if any)
#define CAL_SABBREVMONTHNAME1 0x00000022 // abbreviated name for January #define CAL_SABBREVMONTHNAME1 0x00000022 // abbreviated name for Jan
#define CAL_SABBREVMONTHNAME2 0x00000023 // abbreviated name for February #define CAL_SABBREVMONTHNAME2 0x00000023 // abbreviated name for Feb
#define CAL_SABBREVMONTHNAME3 0x00000024 // abbreviated name for March #define CAL_SABBREVMONTHNAME3 0x00000024 // abbreviated name for Mar
#define CAL_SABBREVMONTHNAME4 0x00000025 // abbreviated name for April #define CAL_SABBREVMONTHNAME4 0x00000025 // abbreviated name for Apr
#define CAL_SABBREVMONTHNAME5 0x00000026 // abbreviated name for May #define CAL_SABBREVMONTHNAME5 0x00000026 // abbreviated name for May
#define CAL_SABBREVMONTHNAME6 0x00000027 // abbreviated name for June #define CAL_SABBREVMONTHNAME6 0x00000027 // abbreviated name for Jun
#define CAL_SABBREVMONTHNAME7 0x00000028 // abbreviated name for July #define CAL_SABBREVMONTHNAME7 0x00000028 // abbreviated name for July
#define CAL_SABBREVMONTHNAME8 0x00000029 // abbreviated name for August #define CAL_SABBREVMONTHNAME8 0x00000029 // abbreviated name for Aug
#define CAL_SABBREVMONTHNAME9 0x0000002a // abbreviated name for September #define CAL_SABBREVMONTHNAME9 0x0000002a // abbreviated name for Sep
#define CAL_SABBREVMONTHNAME10 0x0000002b // abbreviated name for October #define CAL_SABBREVMONTHNAME10 0x0000002b // abbreviated name for Oct
#define CAL_SABBREVMONTHNAME11 0x0000002c // abbreviated name for November #define CAL_SABBREVMONTHNAME11 0x0000002c // abbreviated name for Nov
#define CAL_SABBREVMONTHNAME12 0x0000002d // abbreviated name for December #define CAL_SABBREVMONTHNAME12 0x0000002d // abbreviated name for Dec
#define CAL_SABBREVMONTHNAME13 0x0000002e // abbreviated name for 13th month (if any) #define CAL_SABBREVMONTHNAME13 0x0000002e // abbreviated name for 13th month (if any)
#if(WINVER >= 0x0500) #if(WINVER >= 0x0500)
#define CAL_SYEARMONTH 0x0000002f // year month format string #define CAL_SYEARMONTH 0x0000002f // year month format string
#define CAL_ITWODIGITYEARMAX 0x00000030 // two digit year max #define CAL_ITWODIGITYEARMAX 0x00000030 // two digit year max
#endif /* WINVER >= 0x0500 */ #endif /* WINVER >= 0x0500 */
#if (WINVER >= 0x0600) #if (WINVER >= 0x0600)
#define CAL_SSHORTESTDAYNAME1 0x00000031 // Shortest day name for Monday #define CAL_SSHORTESTDAYNAME1 0x00000031 // Shortest day name for Mo
#define CAL_SSHORTESTDAYNAME2 0x00000032 // Shortest day name for Tuesday #define CAL_SSHORTESTDAYNAME2 0x00000032 // Shortest day name for Tu
#define CAL_SSHORTESTDAYNAME3 0x00000033 // Shortest day name for Wednesday #define CAL_SSHORTESTDAYNAME3 0x00000033 // Shortest day name for We
#define CAL_SSHORTESTDAYNAME4 0x00000034 // Shortest day name for Thursday #define CAL_SSHORTESTDAYNAME4 0x00000034 // Shortest day name for Th
#define CAL_SSHORTESTDAYNAME5 0x00000035 // Shortest day name for Friday #define CAL_SSHORTESTDAYNAME5 0x00000035 // Shortest day name for Fr
#define CAL_SSHORTESTDAYNAME6 0x00000036 // Shortest day name for Saturday #define CAL_SSHORTESTDAYNAME6 0x00000036 // Shortest day name for Sa
#define CAL_SSHORTESTDAYNAME7 0x00000037 // Shortest day name for Sunday #define CAL_SSHORTESTDAYNAME7 0x00000037 // Shortest day name for Su
#endif //(WINVER >= 0x0600) #endif //(WINVER >= 0x0600)
#if (WINVER >= _WIN32_WINNT_WIN7)
#define CAL_SMONTHDAY 0x00000038 // Month/day format
#define CAL_SABBREVERASTRING 0x00000039 // Abbreviated era string (eg: AD)
#endif // winver >= windows 7
// //
// Calendar Enumeration Value. // Calendar Enumeration Value.
// //
#define ENUM_ALL_CALENDARS 0xffffffff // enumerate all calendars #define ENUM_ALL_CALENDARS 0xffffffff // enumerate all calendars
// //
// Calendar ID Values. // Calendar ID Values.
// //
#define CAL_GREGORIAN 1 // Gregorian (localized) calendar #define CAL_GREGORIAN 1 // Gregorian (localized) calendar
#define CAL_GREGORIAN_US 2 // Gregorian (U.S.) calendar #define CAL_GREGORIAN_US 2 // Gregorian (U.S.) calendar
skipping to change at line 760 skipping to change at line 837
#define LGRPID_ARMENIAN 0x0011 // Armenian #define LGRPID_ARMENIAN 0x0011 // Armenian
#if (WINVER >= 0x0600) #if (WINVER >= 0x0600)
// //
// MUI function flag values // MUI function flag values
// //
#define MUI_LANGUAGE_ID 0x4 // Use traditional language ID convention #define MUI_LANGUAGE_ID 0x4 // Use traditional language ID convention
#define MUI_LANGUAGE_NAME 0x8 // Use ISO language (cultur e) name convention #define MUI_LANGUAGE_NAME 0x8 // Use ISO language (cultur e) name convention
#define MUI_MERGE_SYSTEM_FALLBACK 0x10 // GetThreadPreferredUILang uages merges in parent and base languages #define MUI_MERGE_SYSTEM_FALLBACK 0x10 // GetThreadPreferredUILang uages merges in parent and base languages
#define MUI_MERGE_USER_FALLBACK 0x20 // GetThreadPreferredUILang uages merges in user preferred languages #define MUI_MERGE_USER_FALLBACK 0x20 // GetThreadPreferredUILang uages merges in user preferred languages
#define MUI_UI_FALLBACK MUI_MERGE_SYSTEM_FALLBACK | MUI_MERG E_USER_FALLBACK
#define MUI_THREAD_LANGUAGES 0x40 // GetThreadPreferredUILang uages merges in user preferred languages #define MUI_THREAD_LANGUAGES 0x40 // GetThreadPreferredUILang uages merges in user preferred languages
#define MUI_CONSOLE_FILTER 0x100 // SetThreadPreferredUILang uages takes on console specific behavior #define MUI_CONSOLE_FILTER 0x100 // SetThreadPreferredUILang uages takes on console specific behavior
#define MUI_COMPLEX_SCRIPT_FILTER 0x200 // SetThreadPreferredUILang uages takes on complex script specific behavior #define MUI_COMPLEX_SCRIPT_FILTER 0x200 // SetThreadPreferredUILang uages takes on complex script specific behavior
#define MUI_RESET_FILTERS 0x001 // Reset MUI_CONSOLE_FILTER and MUI_COMPLEX_SCRIPT_FILTER #define MUI_RESET_FILTERS 0x001 // Reset MUI_CONSOLE_FILTER and MUI_COMPLEX_SCRIPT_FILTER
#define MUI_USER_PREFERRED_UI_LANGUAGES 0x10 // GetFileMUIPath returns t he MUI files for the languages in the fallback list #define MUI_USER_PREFERRED_UI_LANGUAGES 0x10 // GetFileMUIPath returns t he MUI files for the languages in the fallback list
#define MUI_USE_INSTALLED_LANGUAGES 0x20 // GetFileMUIPath returns a ll the MUI files installed in the machine #define MUI_USE_INSTALLED_LANGUAGES 0x20 // GetFileMUIPath returns a ll the MUI files installed in the machine
#define MUI_USE_SEARCH_ALL_LANGUAGES 0x40 // GetFileMUIPath returns a ll the MUI files irrespective of whether language is installed #define MUI_USE_SEARCH_ALL_LANGUAGES 0x40 // GetFileMUIPath returns a ll the MUI files irrespective of whether language is installed
#define MUI_LANG_NEUTRAL_PE_FILE 0x100 // GetFileMUIPath returns t arget file with .mui extension #define MUI_LANG_NEUTRAL_PE_FILE 0x100 // GetFileMUIPath returns t arget file with .mui extension
#define MUI_NON_LANG_NEUTRAL_FILE 0x200 // GetFileMUIPath returns t arget file with same name as source #define MUI_NON_LANG_NEUTRAL_FILE 0x200 // GetFileMUIPath returns t arget file with same name as source
#define MUI_MACHINE_LANGUAGE_SETTINGS 0x400 #define MUI_MACHINE_LANGUAGE_SETTINGS 0x400
#define MUI_BYPASS_SESSION_BEHAVIOR 0x80 //EnumUILanguages,GetFileMUI Info: includes latest changes in installed languages
#define MUI_FILETYPE_NOT_LANGUAGE_NEUTRAL 0x001 // GetFileMUIInfo found a no n-split resource file #define MUI_FILETYPE_NOT_LANGUAGE_NEUTRAL 0x001 // GetFileMUIInfo found a no n-split resource file
#define MUI_FILETYPE_LANGUAGE_NEUTRAL_MAIN 0x002 // GetFileMUIInfo found a LN main module resource file #define MUI_FILETYPE_LANGUAGE_NEUTRAL_MAIN 0x002 // GetFileMUIInfo found a LN main module resource file
#define MUI_FILETYPE_LANGUAGE_NEUTRAL_MUI 0x004 // GetFileMUIInfo found a LN MUI module resource file #define MUI_FILETYPE_LANGUAGE_NEUTRAL_MUI 0x004 // GetFileMUIInfo found a LN MUI module resource file
#define MUI_QUERY_TYPE 0x001 // GetFileMUIInfo will look for the type of the resource file #define MUI_QUERY_TYPE 0x001 // GetFileMUIInfo will look for the type of the resource file
#define MUI_QUERY_CHECKSUM 0x002 // GetFileMUIInfo will look for the checksum of the resource file #define MUI_QUERY_CHECKSUM 0x002 // GetFileMUIInfo will look for the checksum of the resource file
#define MUI_QUERY_LANGUAGE_NAME 0x004 // GetFileMUIInfo will look for the culture of the resource file #define MUI_QUERY_LANGUAGE_NAME 0x004 // GetFileMUIInfo will look for the culture of the resource file
#define MUI_QUERY_RESOURCE_TYPES 0x008 // GetFileMUIInfo will look for the resource types of the resource file #define MUI_QUERY_RESOURCE_TYPES 0x008 // GetFileMUIInfo will look for the resource types of the resource file
#define MUI_FILEINFO_VERSION 0x001 // Version of FILEMUIINFO st ructure used with GetFileMUIInfo #define MUI_FILEINFO_VERSION 0x001 // Version of FILEMUIINFO st ructure used with GetFileMUIInfo
#define MUI_SXS_FALLBACK 0x00010000 // SXS
#define MUI_FULL_LANGUAGE 0x01 #define MUI_FULL_LANGUAGE 0x01
#define MUI_PARTIAL_LANGUAGE 0x02 #define MUI_PARTIAL_LANGUAGE 0x02
#define MUI_LIP_LANGUAGE 0x04 #define MUI_LIP_LANGUAGE 0x04
#define MUI_LANGUAGE_INSTALLED 0x20 #define MUI_LANGUAGE_INSTALLED 0x20
#define MUI_LANGUAGE_LICENSED 0x40 #define MUI_LANGUAGE_LICENSED 0x40
#define MUI_PUBLIC_LANGUAGE_TYPE_FLAGS_MASK 0x67
// //
// MUI_CALLBACK_FLAG defines are duplicated in rtlmui.h // MUI_CALLBACK_FLAG defines are duplicated in rtlmui.h
// //
#define MUI_CALLBACK_ALL_FLAGS MUI_CALLBACK_FLAG_UPGRADED _INSTALLATION // OR all other flags when defined. #define MUI_CALLBACK_ALL_FLAGS MUI_CALLBACK_FLAG_UPGRADED _INSTALLATION // OR all other flags when defined.
// //
// MUI_CALLBACK_ flags are duplicated in rtlmui.h // MUI_CALLBACK_ flags are duplicated in rtlmui.h
// //
skipping to change at line 942 skipping to change at line 1016
// //
// NLS version structure. // NLS version structure.
// //
typedef struct _nlsversioninfo{ typedef struct _nlsversioninfo{
DWORD dwNLSVersionInfoSize; // 12 bytes DWORD dwNLSVersionInfoSize; // 12 bytes
DWORD dwNLSVersion; DWORD dwNLSVersion;
DWORD dwDefinedVersion; DWORD dwDefinedVersion;
} NLSVERSIONINFO, *LPNLSVERSIONINFO; } NLSVERSIONINFO, *LPNLSVERSIONINFO;
// This is to be deprecated, please use the NLSVERSIONINFO
// structure above in the future. The difference is that
// the effective ID is more robust.
typedef struct _nlsversioninfoex{ typedef struct _nlsversioninfoex{
DWORD dwNLSVersionInfoSize; // sizeof(NLSVERSIONINFOEX) == 32 bytes DWORD dwNLSVersionInfoSize; // sizeof(NLSVERSIONINFOEX) == 32 bytes
DWORD dwNLSVersion; DWORD dwNLSVersion;
DWORD dwDefinedVersion; DWORD dwDefinedVersion;
DWORD dwEffectiveId; DWORD dwEffectiveId; // Use NLSVERSIONINFO instead
GUID guidCustomVersion; GUID guidCustomVersion;
} NLSVERSIONINFOEX, *LPNLSVERSIONINFOEX; } NLSVERSIONINFOEX, *LPNLSVERSIONINFOEX;
// //
// GEO defines // GEO defines
// //
typedef LONG GEOID; typedef LONG GEOID;
typedef DWORD GEOTYPE; typedef DWORD GEOTYPE;
typedef DWORD GEOCLASS; typedef DWORD GEOCLASS;
skipping to change at line 1263 skipping to change at line 1340
__in int cchWideChar, __in int cchWideChar,
__out_bcount_opt(cbMultiByte) __transfer(lpWideCharStr) LPSTR lpMultiByteS tr, __out_bcount_opt(cbMultiByte) __transfer(lpWideCharStr) LPSTR lpMultiByteS tr,
__in int cbMultiByte, __in int cbMultiByte,
__in_opt LPCSTR lpDefaultChar, __in_opt LPCSTR lpDefaultChar,
__out_opt LPBOOL lpUsedDefaultChar); __out_opt LPBOOL lpUsedDefaultChar);
// //
// Locale Dependent APIs. // Locale Dependent APIs.
// //
// For Windows Vista and above CompareStringEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
CompareStringA( CompareStringA(
__in LCID Locale, __in LCID Locale,
__in DWORD dwCmpFlags, __in DWORD dwCmpFlags,
__in_ecount(cchCount1) LPCSTR lpString1, __in_ecount(cchCount1) PCNZCH lpString1,
__in int cchCount1, __in int cchCount1,
__in_ecount(cchCount2) LPCSTR lpString2, __in_ecount(cchCount2) PCNZCH lpString2,
__in int cchCount2); __in int cchCount2);
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
CompareStringW( CompareStringW(
__in LCID Locale, __in LCID Locale,
__in DWORD dwCmpFlags, __in DWORD dwCmpFlags,
__in_ecount(cchCount1) LPCWSTR lpString1, __in_ecount(cchCount1) PCNZWCH lpString1,
__in int cchCount1, __in int cchCount1,
__in_ecount(cchCount2) LPCWSTR lpString2, __in_ecount(cchCount2) PCNZWCH lpString2,
__in int cchCount2); __in int cchCount2);
#ifdef UNICODE #ifdef UNICODE
#define CompareString CompareStringW #define CompareString CompareStringW
#else #else
#define CompareString CompareStringA #define CompareString CompareStringA
#endif // !UNICODE #endif // !UNICODE
#if defined(_M_CEE) #if defined(_M_CEE)
#undef CompareString #undef CompareString
__inline __inline
int int
skipping to change at line 1319 skipping to change at line 1399
lpString1, lpString1,
cchCount1, cchCount1,
lpString2, lpString2,
cchCount2 cchCount2
); );
} }
#endif /* _M_CEE */ #endif /* _M_CEE */
#if (WINVER >= 0x0600) #if (WINVER >= 0x0600)
// For Windows Vista and above FindNLSStringEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
FindNLSString( FindNLSString(
__in LCID Locale, __in LCID Locale,
__in DWORD dwFindNLSStringFlags, __in DWORD dwFindNLSStringFlags,
__in_ecount(cchSource) LPCWSTR lpStringSource, __in_ecount(cchSource) LPCWSTR lpStringSource,
__in int cchSource, __in int cchSource,
__in_ecount(cchValue) LPCWSTR lpStringValue, __in_ecount(cchValue) LPCWSTR lpStringValue,
__in int cchValue, __in int cchValue,
__out_opt LPINT pcchFound); __out_opt LPINT pcchFound);
#endif //(WINVER >= 0x0600) #endif //(WINVER >= 0x0600)
#if (WINVER >= _WIN32_WINNT_WIN7)
WINBASEAPI
int
WINAPI
FindStringOrdinal(
__in DWORD dwFindStringOrdinalFlags,
__in_ecount(cchSource) LPCWSTR lpStringSource,
__in int cchSource,
__in_ecount(cchValue) LPCWSTR lpStringValue,
__in int cchValue,
__in BOOL bIgnoreCase);
#endif //(WINVER >= _WIN32_WINNT_WIN7)
// For Windows Vista and above LCMapStringEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
LCMapStringA( LCMapStringA(
__in LCID Locale, __in LCID Locale,
__in DWORD dwMapFlags, __in DWORD dwMapFlags,
__in_ecount(cchSrc) LPCSTR lpSrcStr, __in_ecount(cchSrc) LPCSTR lpSrcStr,
__in int cchSrc, __in int cchSrc,
__out_xcount_opt(cchDest) LPSTR lpDestStr, __out_xcount_opt(cchDest) LPSTR lpDestStr,
__in int cchDest); __in int cchDest);
// For Windows Vista and above LCMapStringEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
LCMapStringW( LCMapStringW(
__in LCID Locale, __in LCID Locale,
__in DWORD dwMapFlags, __in DWORD dwMapFlags,
__in_ecount(cchSrc) LPCWSTR lpSrcStr, __in_ecount(cchSrc) LPCWSTR lpSrcStr,
__in int cchSrc, __in int cchSrc,
__out_xcount_opt(cchDest) LPWSTR lpDestStr, __out_xcount_opt(cchDest) LPWSTR lpDestStr,
__in int cchDest); __in int cchDest);
#ifdef UNICODE #ifdef UNICODE
#define LCMapString LCMapStringW #define LCMapString LCMapStringW
#else #else
#define LCMapString LCMapStringA #define LCMapString LCMapStringA
#endif // !UNICODE #endif // !UNICODE
// For Windows Vista and above GetLocaleInfoEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
GetLocaleInfoA( GetLocaleInfoA(
__in LCID Locale, __in LCID Locale,
__in LCTYPE LCType, __in LCTYPE LCType,
__out_ecount_opt(cchData) LPSTR lpLCData, __out_ecount_opt(cchData) LPSTR lpLCData,
__in int cchData); __in int cchData);
// For Windows Vista and above GetLocaleInfoEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
GetLocaleInfoW( GetLocaleInfoW(
__in LCID Locale, __in LCID Locale,
__in LCTYPE LCType, __in LCTYPE LCType,
__out_ecount_opt(cchData) LPWSTR lpLCData, __out_ecount_opt(cchData) LPWSTR lpLCData,
__in int cchData); __in int cchData);
#ifdef UNICODE #ifdef UNICODE
#define GetLocaleInfo GetLocaleInfoW #define GetLocaleInfo GetLocaleInfoW
skipping to change at line 1402 skipping to change at line 1502
__in LCID Locale, __in LCID Locale,
__in LCTYPE LCType, __in LCTYPE LCType,
__in LPCWSTR lpLCData); __in LPCWSTR lpLCData);
#ifdef UNICODE #ifdef UNICODE
#define SetLocaleInfo SetLocaleInfoW #define SetLocaleInfo SetLocaleInfoW
#else #else
#define SetLocaleInfo SetLocaleInfoA #define SetLocaleInfo SetLocaleInfoA
#endif // !UNICODE #endif // !UNICODE
#if (WINVER >= 0x040A) #if (WINVER >= 0x040A)
// For Windows Vista and above GetCalendarInfoEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
GetCalendarInfoA( GetCalendarInfoA(
__in LCID Locale, __in LCID Locale,
__in CALID Calendar, __in CALID Calendar,
__in CALTYPE CalType, __in CALTYPE CalType,
__out_ecount_opt(cchData) LPSTR lpCalData, __out_ecount_opt(cchData) LPSTR lpCalData,
__in int cchData, __in int cchData,
__out_opt LPDWORD lpValue); __out_opt LPDWORD lpValue);
// For Windows Vista and above GetCalendarInfoEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
GetCalendarInfoW( GetCalendarInfoW(
__in LCID Locale, __in LCID Locale,
__in CALID Calendar, __in CALID Calendar,
__in CALTYPE CalType, __in CALTYPE CalType,
__out_ecount_opt(cchData) LPWSTR lpCalData, __out_ecount_opt(cchData) LPWSTR lpCalData,
__in int cchData, __in int cchData,
__out_opt LPDWORD lpValue); __out_opt LPDWORD lpValue);
skipping to change at line 1470 skipping to change at line 1572
WINBASEAPI WINBASEAPI
LCID LCID
WINAPI WINAPI
LocaleNameToLCID( LocaleNameToLCID(
__in LPCWSTR lpName, __in LPCWSTR lpName,
__in DWORD dwFlags); __in DWORD dwFlags);
#endif // (WINVER >= 0x0600) #endif // (WINVER >= 0x0600)
// For Windows Vista and above GetTimeFormatEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
GetTimeFormatA( GetTimeFormatA(
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags, __in DWORD dwFlags,
__in_opt CONST SYSTEMTIME *lpTime, __in_opt CONST SYSTEMTIME *lpTime,
__in_opt LPCSTR lpFormat, __in_opt LPCSTR lpFormat,
__out_ecount_opt(cchTime) LPSTR lpTimeStr, __out_ecount_opt(cchTime) LPSTR lpTimeStr,
__in int cchTime); __in int cchTime);
// For Windows Vista and above GetTimeFormatEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
GetTimeFormatW( GetTimeFormatW(
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags, __in DWORD dwFlags,
__in_opt CONST SYSTEMTIME *lpTime, __in_opt CONST SYSTEMTIME *lpTime,
__in_opt LPCWSTR lpFormat, __in_opt LPCWSTR lpFormat,
__out_ecount_opt(cchTime) LPWSTR lpTimeStr, __out_ecount_opt(cchTime) LPWSTR lpTimeStr,
__in int cchTime); __in int cchTime);
#ifdef UNICODE #ifdef UNICODE
#define GetTimeFormat GetTimeFormatW #define GetTimeFormat GetTimeFormatW
#else #else
#define GetTimeFormat GetTimeFormatA #define GetTimeFormat GetTimeFormatA
#endif // !UNICODE #endif // !UNICODE
// For Windows Vista and above GetDurationFormatEx is preferred
#if (WINVER >= 0x0600) #if (WINVER >= 0x0600)
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
GetDurationFormat( GetDurationFormat(
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags, __in DWORD dwFlags,
__in_opt CONST SYSTEMTIME *lpDuration, __in_opt CONST SYSTEMTIME *lpDuration,
__in ULONGLONG ullDuration, __in ULONGLONG ullDuration,
__in_opt LPCWSTR lpFormat, __in_opt LPCWSTR lpFormat,
__out_ecount_opt(cchDuration) LPWSTR lpDurationStr, __out_ecount_opt(cchDuration) LPWSTR lpDurationStr,
__in int cchDuration); __in int cchDuration);
#endif //(WINVER >= 0x0600) #endif //(WINVER >= 0x0600)
// For Windows Vista and above GetDateFormatEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
GetDateFormatA( GetDateFormatA(
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags, __in DWORD dwFlags,
__in_opt CONST SYSTEMTIME *lpDate, __in_opt CONST SYSTEMTIME *lpDate,
__in_opt LPCSTR lpFormat, __in_opt LPCSTR lpFormat,
__out_ecount_opt(cchDate) LPSTR lpDateStr, __out_ecount_opt(cchDate) LPSTR lpDateStr,
__in int cchDate); __in int cchDate);
// For Windows Vista and above GetDateFormatEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
GetDateFormatW( GetDateFormatW(
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags, __in DWORD dwFlags,
__in_opt CONST SYSTEMTIME *lpDate, __in_opt CONST SYSTEMTIME *lpDate,
__in_opt LPCWSTR lpFormat, __in_opt LPCWSTR lpFormat,
__out_ecount_opt(cchDate) LPWSTR lpDateStr, __out_ecount_opt(cchDate) LPWSTR lpDateStr,
__in int cchDate); __in int cchDate);
#ifdef UNICODE #ifdef UNICODE
#define GetDateFormat GetDateFormatW #define GetDateFormat GetDateFormatW
#else #else
#define GetDateFormat GetDateFormatA #define GetDateFormat GetDateFormatA
#endif // !UNICODE #endif // !UNICODE
// For Windows Vista and above GetNumberFormatEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
GetNumberFormatA( GetNumberFormatA(
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags, __in DWORD dwFlags,
__in LPCSTR lpValue, __in LPCSTR lpValue,
__in_opt CONST NUMBERFMTA *lpFormat, __in_opt CONST NUMBERFMTA *lpFormat,
__out_ecount_opt(cchNumber) LPSTR lpNumberStr, __out_ecount_opt(cchNumber) LPSTR lpNumberStr,
__in int cchNumber); __in int cchNumber);
// For Windows Vista and above GetNumberFormatEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
GetNumberFormatW( GetNumberFormatW(
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags, __in DWORD dwFlags,
__in LPCWSTR lpValue, __in LPCWSTR lpValue,
__in_opt CONST NUMBERFMTW *lpFormat, __in_opt CONST NUMBERFMTW *lpFormat,
__out_ecount_opt(cchNumber) LPWSTR lpNumberStr, __out_ecount_opt(cchNumber) LPWSTR lpNumberStr,
__in int cchNumber); __in int cchNumber);
#ifdef UNICODE #ifdef UNICODE
#define GetNumberFormat GetNumberFormatW #define GetNumberFormat GetNumberFormatW
#else #else
#define GetNumberFormat GetNumberFormatA #define GetNumberFormat GetNumberFormatA
#endif // !UNICODE #endif // !UNICODE
// For Windows Vista and above GetCurrencyFormatEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
GetCurrencyFormatA( GetCurrencyFormatA(
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags, __in DWORD dwFlags,
__in LPCSTR lpValue, __in LPCSTR lpValue,
__in_opt CONST CURRENCYFMTA *lpFormat, __in_opt CONST CURRENCYFMTA *lpFormat,
__out_ecount_opt(cchCurrency) LPSTR lpCurrencyStr, __out_ecount_opt(cchCurrency) LPSTR lpCurrencyStr,
__in int cchCurrency); __in int cchCurrency);
// For Windows Vista and above GetCurrencyFormatEx is preferred
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
GetCurrencyFormatW( GetCurrencyFormatW(
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags, __in DWORD dwFlags,
__in LPCWSTR lpValue, __in LPCWSTR lpValue,
__in_opt CONST CURRENCYFMTW *lpFormat, __in_opt CONST CURRENCYFMTW *lpFormat,
__out_ecount_opt(cchCurrency) LPWSTR lpCurrencyStr, __out_ecount_opt(cchCurrency) LPWSTR lpCurrencyStr,
__in int cchCurrency); __in int cchCurrency);
#ifdef UNICODE #ifdef UNICODE
#define GetCurrencyFormat GetCurrencyFormatW #define GetCurrencyFormat GetCurrencyFormatW
#else #else
#define GetCurrencyFormat GetCurrencyFormatA #define GetCurrencyFormat GetCurrencyFormatA
#endif // !UNICODE #endif // !UNICODE
// For Windows Vista and above EnumCalendarInfoExEx is preferred
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
EnumCalendarInfoA( EnumCalendarInfoA(
__in CALINFO_ENUMPROCA lpCalInfoEnumProc, __in CALINFO_ENUMPROCA lpCalInfoEnumProc,
__in LCID Locale, __in LCID Locale,
__in CALID Calendar, __in CALID Calendar,
__in CALTYPE CalType); __in CALTYPE CalType);
// For Windows Vista and above EnumCalendarInfoExEx is preferred
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
EnumCalendarInfoW( EnumCalendarInfoW(
__in CALINFO_ENUMPROCW lpCalInfoEnumProc, __in CALINFO_ENUMPROCW lpCalInfoEnumProc,
__in LCID Locale, __in LCID Locale,
__in CALID Calendar, __in CALID Calendar,
__in CALTYPE CalType); __in CALTYPE CalType);
#ifdef UNICODE #ifdef UNICODE
#define EnumCalendarInfo EnumCalendarInfoW #define EnumCalendarInfo EnumCalendarInfoW
#else #else
#define EnumCalendarInfo EnumCalendarInfoA #define EnumCalendarInfo EnumCalendarInfoA
#endif // !UNICODE #endif // !UNICODE
#if(WINVER >= 0x0500) #if(WINVER >= 0x0500)
// For Windows Vista and above EnumCalendarInfoExEx is preferred
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
EnumCalendarInfoExA( EnumCalendarInfoExA(
__in CALINFO_ENUMPROCEXA lpCalInfoEnumProcEx, __in CALINFO_ENUMPROCEXA lpCalInfoEnumProcEx,
__in LCID Locale, __in LCID Locale,
__in CALID Calendar, __in CALID Calendar,
__in CALTYPE CalType); __in CALTYPE CalType);
// For Windows Vista and above EnumCalendarInfoExEx is preferred
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
EnumCalendarInfoExW( EnumCalendarInfoExW(
__in CALINFO_ENUMPROCEXW lpCalInfoEnumProcEx, __in CALINFO_ENUMPROCEXW lpCalInfoEnumProcEx,
__in LCID Locale, __in LCID Locale,
__in CALID Calendar, __in CALID Calendar,
__in CALTYPE CalType); __in CALTYPE CalType);
#ifdef UNICODE #ifdef UNICODE
#define EnumCalendarInfoEx EnumCalendarInfoExW #define EnumCalendarInfoEx EnumCalendarInfoExW
#else #else
#define EnumCalendarInfoEx EnumCalendarInfoExA #define EnumCalendarInfoEx EnumCalendarInfoExA
#endif // !UNICODE #endif // !UNICODE
#endif /* WINVER >= 0x0500 */ #endif /* WINVER >= 0x0500 */
// For Windows Vista and above EnumTimeFormatsEx is preferred
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
EnumTimeFormatsA( EnumTimeFormatsA(
__in TIMEFMT_ENUMPROCA lpTimeFmtEnumProc, __in TIMEFMT_ENUMPROCA lpTimeFmtEnumProc,
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags); __in DWORD dwFlags);
// For Windows Vista and above EnumTimeFormatsEx is preferred
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
EnumTimeFormatsW( EnumTimeFormatsW(
__in TIMEFMT_ENUMPROCW lpTimeFmtEnumProc, __in TIMEFMT_ENUMPROCW lpTimeFmtEnumProc,
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags); __in DWORD dwFlags);
#ifdef UNICODE #ifdef UNICODE
#define EnumTimeFormats EnumTimeFormatsW #define EnumTimeFormats EnumTimeFormatsW
#else #else
#define EnumTimeFormats EnumTimeFormatsA #define EnumTimeFormats EnumTimeFormatsA
#endif // !UNICODE #endif // !UNICODE
// For Windows Vista and above EnumDateFormatsExEx is preferred
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
EnumDateFormatsA( EnumDateFormatsA(
__in DATEFMT_ENUMPROCA lpDateFmtEnumProc, __in DATEFMT_ENUMPROCA lpDateFmtEnumProc,
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags); __in DWORD dwFlags);
// For Windows Vista and above EnumDateFormatsExEx is preferred
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
EnumDateFormatsW( EnumDateFormatsW(
__in DATEFMT_ENUMPROCW lpDateFmtEnumProc, __in DATEFMT_ENUMPROCW lpDateFmtEnumProc,
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags); __in DWORD dwFlags);
#ifdef UNICODE #ifdef UNICODE
#define EnumDateFormats EnumDateFormatsW #define EnumDateFormats EnumDateFormatsW
#else #else
#define EnumDateFormats EnumDateFormatsA #define EnumDateFormats EnumDateFormatsA
#endif // !UNICODE #endif // !UNICODE
#if(WINVER >= 0x0500) #if(WINVER >= 0x0500)
// For Windows Vista and above EnumDateFormatsExEx is preferred
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
EnumDateFormatsExA( EnumDateFormatsExA(
__in DATEFMT_ENUMPROCEXA lpDateFmtEnumProcEx, __in DATEFMT_ENUMPROCEXA lpDateFmtEnumProcEx,
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags); __in DWORD dwFlags);
// For Windows Vista and above EnumDateFormatsExEx is preferred
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
EnumDateFormatsExW( EnumDateFormatsExW(
__in DATEFMT_ENUMPROCEXW lpDateFmtEnumProcEx, __in DATEFMT_ENUMPROCEXW lpDateFmtEnumProcEx,
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags); __in DWORD dwFlags);
#ifdef UNICODE #ifdef UNICODE
#define EnumDateFormatsEx EnumDateFormatsExW #define EnumDateFormatsEx EnumDateFormatsExW
#else #else
skipping to change at line 1705 skipping to change at line 1826
#if(WINVER >= 0x0500) #if(WINVER >= 0x0500)
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
IsValidLanguageGroup( IsValidLanguageGroup(
__in LGRPID LanguageGroup, __in LGRPID LanguageGroup,
__in DWORD dwFlags); __in DWORD dwFlags);
#endif /* WINVER >= 0x0500 */ #endif /* WINVER >= 0x0500 */
// For Windows Vista and above GetNLSVersionEx is preferred
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetNLSVersion( GetNLSVersion(
__in NLS_FUNCTION Function, __in NLS_FUNCTION Function,
__in LCID Locale, __in LCID Locale,
__inout LPNLSVERSIONINFO lpVersionInformation); __inout LPNLSVERSIONINFO lpVersionInformation);
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
IsNLSDefinedString( IsNLSDefinedString(
__in NLS_FUNCTION Function, __in NLS_FUNCTION Function,
__in DWORD dwFlags, __in DWORD dwFlags,
__in LPNLSVERSIONINFO lpVersionInformation, __in LPNLSVERSIONINFO lpVersionInformation,
__in_ecount(cchStr) LPCWSTR lpString, __in_ecount(cchStr) LPCWSTR lpString,
__in INT cchStr); __in INT cchStr);
// For Windows Vista and above IsValidLocaleName is preferred
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
IsValidLocale( IsValidLocale(
__in LCID Locale, __in LCID Locale,
__in DWORD dwFlags); __in DWORD dwFlags);
WINBASEAPI WINBASEAPI
int int
WINAPI WINAPI
skipping to change at line 1839 skipping to change at line 1962
#if (WINVER >= 0x0600) #if (WINVER >= 0x0600)
WINBASEAPI WINBASEAPI
LANGID LANGID
WINAPI WINAPI
GetThreadUILanguage(void); GetThreadUILanguage(void);
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetProcessPreferredUILanguages(
__in DWORD dwFlags,
__out PULONG pulNumLanguages,
__out_ecount_opt(*pcchLanguagesBuffer) PZZWSTR pwszLanguagesBuffer,
__inout PULONG pcchLanguagesBuffer
);
WINBASEAPI
BOOL
WINAPI
SetProcessPreferredUILanguages(
__in DWORD dwFlags,
__in_opt PCZZWSTR pwszLanguagesBuffer,
__out_opt PULONG pulNumLanguages
);
WINBASEAPI
BOOL
WINAPI
GetUserPreferredUILanguages ( GetUserPreferredUILanguages (
__in DWORD dwFlags, __in DWORD dwFlags,
__out PULONG pulNumLanguages, __out PULONG pulNumLanguages,
__out_ecount_opt(*pcchLanguagesBuffer) PWSTR pwszLanguagesBuffer, __out_ecount_opt(*pcchLanguagesBuffer) PZZWSTR pwszLanguagesBuffer,
__in PULONG pcchLanguagesBuffer __inout PULONG pcchLanguagesBuffer
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetSystemPreferredUILanguages ( GetSystemPreferredUILanguages (
__in DWORD dwFlags, __in DWORD dwFlags,
__out PULONG pulNumLanguages, __out PULONG pulNumLanguages,
__out_ecount_opt(*pcchLanguagesBuffer) PWSTR pwszLanguagesBuffer, __out_ecount_opt(*pcchLanguagesBuffer) PZZWSTR pwszLanguagesBuffer,
__in PULONG pcchLanguagesBuffer __inout PULONG pcchLanguagesBuffer
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetThreadPreferredUILanguages( GetThreadPreferredUILanguages(
__in DWORD dwFlags, __in DWORD dwFlags,
__out PULONG pulNumLanguages, __out PULONG pulNumLanguages,
__out_ecount_opt(*pcchLanguagesBuffer) PWSTR pwszLanguagesBuffer, __out_ecount_opt(*pcchLanguagesBuffer) PZZWSTR pwszLanguagesBuffer,
__inout PULONG pcchLanguagesBuffer __inout PULONG pcchLanguagesBuffer
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
SetThreadPreferredUILanguages( SetThreadPreferredUILanguages(
__in DWORD dwFlags, __in DWORD dwFlags,
__in_opt PCWSTR pwszLanguagesBuffer, __in_opt PCZZWSTR pwszLanguagesBuffer,
__out_opt PULONG pulNumLanguages __out_opt PULONG pulNumLanguages
); );
WINBASEAPI WINBASEAPI
__success(return==1) __success(return==1)
BOOL BOOL
WINAPI WINAPI
GetFileMUIInfo( GetFileMUIInfo(
DWORD dwFlags, DWORD dwFlags,
__in PCWSTR pcwszFilePath, __in PCWSTR pcwszFilePath,
skipping to change at line 1903 skipping to change at line 2045
__out_ecount_opt (*pcchFileMUIPath) PWSTR pwszFileMUIPath, __out_ecount_opt (*pcchFileMUIPath) PWSTR pwszFileMUIPath,
__inout PULONG pcchFileMUIPath, __inout PULONG pcchFileMUIPath,
__inout PULONGLONG pululEnumerator __inout PULONGLONG pululEnumerator
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
GetUILanguageInfo( GetUILanguageInfo(
__in DWORD dwFlags, __in DWORD dwFlags,
__in PCWSTR pwmszLanguage, __in PCZZWSTR pwmszLanguage,
__out_ecount_opt(*pcchFallbackLanguages) PWSTR pwszFallbackLanguages, __out_ecount_opt(*pcchFallbackLanguages) PZZWSTR pwszFallbackLanguages,
__inout_opt PDWORD pcchFallbackLanguages, __inout_opt PDWORD pcchFallbackLanguages,
__out PDWORD pAttributes __out PDWORD pAttributes
); );
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI WINAPI
NotifyUILanguageChange( NotifyUILanguageChange(
__in DWORD dwFlags, __in DWORD dwFlags,
__in_opt PCWSTR pcwstrNewLanguage, __in_opt PCWSTR pcwstrNewLanguage,
skipping to change at line 2128 skipping to change at line 2270
BOOL BOOL
WINAPI IsNormalizedString( __in NORM_FORM NormForm, WINAPI IsNormalizedString( __in NORM_FORM NormForm,
__in_ecount(cwLength) LPCWSTR lpString, __in_ecount(cwLength) LPCWSTR lpString,
__in int cwLength ); __in int cwLength );
// //
// IDN (International Domain Name) Functions // IDN (International Domain Name) Functions
// //
WINNORMALIZEAPI WINNORMALIZEAPI
int int
WINAPI IdnToAscii(__in DWORD dwFlags, WINAPI IdnToAscii(__in DWORD dwFlags,
__in_ecount(cchUnicodeChar) LPCWSTR lpUnicodeCharStr, __in_ecount(cchUnicodeChar) LPCWSTR lpUnicodeCharStr,
__in int cchUnicodeChar, __in int cchUnicodeChar,
__out_ecount(cchASCIIChar) LPWSTR lpASCIICharStr, __out_ecount_opt(cchASCIIChar) LPWSTR lpASCIICharStr,
__in int cchASCIIChar); __in int cchASCIIChar);
WINNORMALIZEAPI WINNORMALIZEAPI
int int
WINAPI IdnToNameprepUnicode(__in DWORD dwFlags, WINAPI IdnToNameprepUnicode(__in DWORD dwFlags,
__in_ecount(cchUnicodeChar) LPCWSTR lpUnicodeCha __in_ecount(cchUnicodeChar) LPCWSTR lpUnicode
rStr, CharStr,
__in int cchUnicodeCh __in int cchUnicod
ar, eChar,
__out_ecount(cchNameprepChar) LPWSTR lpNameprepCh __out_ecount_opt(cchNameprepChar) LPWSTR lpNamepr
arStr, epCharStr,
__in int cchNameprepC __in int cchNamepr
har); epChar);
WINNORMALIZEAPI WINNORMALIZEAPI
int int
WINAPI IdnToUnicode(__in DWORD dwFlags, WINAPI IdnToUnicode(__in DWORD dwFlags,
__in_ecount(cchASCIIChar) LPCWSTR lpASCIICharStr, __in_ecount(cchASCIIChar) LPCWSTR lpASCIICharStr,
__in int cchASCIIChar, __in int cchASCIIChar,
__out_ecount(cchUnicodeChar) LPWSTR lpUnicodeCharStr, __out_ecount_opt(cchUnicodeChar) LPWSTR lpUnicodeCharStr,
__in int cchUnicodeChar); __in int cchUnicodeChar);
WINBASEAPI WINBASEAPI
BOOL BOOL
WINAPI VerifyScripts( WINAPI VerifyScripts(
__in DWORD dwFlags, // optional behavior flags __in DWORD dwFlags, // optional behavior flags
__in LPCWSTR lpLocaleScripts, // Locale list of scripts string __in LPCWSTR lpLocaleScripts, // Locale list of scripts string
__in int cchLocaleScripts, // size of locale script list string __in int cchLocaleScripts, // size of locale script list string
__in LPCWSTR lpTestScripts, // test scripts string __in LPCWSTR lpTestScripts, // test scripts string
__in int cchTestScripts); // size of test list string __in int cchTestScripts); // size of test list string
skipping to change at line 2405 skipping to change at line 2547
WINAPI WINAPI
EnumSystemLocalesEx( EnumSystemLocalesEx(
__in LOCALE_ENUMPROCEX lpLocaleEnumProcEx, __in LOCALE_ENUMPROCEX lpLocaleEnumProcEx,
__in DWORD dwFlags, __in DWORD dwFlags,
__in LPARAM lParam, __in LPARAM lParam,
__in_opt LPVOID lpReserved __in_opt LPVOID lpReserved
); );
#endif //(WINVER >= 0x0600) #endif //(WINVER >= 0x0600)
#if (WINVER >= _WIN32_WINNT_WIN7)
WINBASEAPI
int
WINAPI
ResolveLocaleName(
__in_opt LPCWSTR lpNameToResolve,
__out_ecount_opt(cchLocaleName) LPWSTR lpLocaleName,
__in int cchLocaleName
);
#endif // (WINVER >= _WIN32_WINNT_WIN7)
#endif // NONLS #endif // NONLS
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif // _WINNLS_ #endif // _WINNLS_
 End of changes. 82 change blocks. 
155 lines changed or deleted 381 lines changed or added

This html diff was produced by rfcdiff 1.41.