diff --git a/uppdev/RichEditTest/main.cpp b/uppdev/RichEditTest/main.cpp index 1b0bfc66c..b79ff873f 100644 --- a/uppdev/RichEditTest/main.cpp +++ b/uppdev/RichEditTest/main.cpp @@ -66,9 +66,9 @@ GUI_APP_MAIN // e.SetQTF(LoadFile("U:\\xxx\\PainterBug.qtf")); // e.ClipZoom(4, 1); // Ctrl::ShowRepaint(50); - RichEdit::PosInfo f; - LoadFromFile(f, ConfigFile("pos")); - e.SetPosInfo(f); +// RichEdit::PosInfo f; +// LoadFromFile(f, ConfigFile("pos")); +// e.SetPosInfo(f); // e.Pick(ParseQTF(AsQTF(CreateImageObject(CtrlImg::exclamation)) + " hahahaha")); MyApp w; // w.ToolWindow(); @@ -82,18 +82,41 @@ GUI_APP_MAIN #else w.Add(e.SizePos()); #endif + + { + static const char styles[] = + "[ $$0,0#00000000000000000000000000000000:Default]" + ; + + DLOG("==================="); + DDUMP(e.GetLength()); + + WString text = e.Get().GetPlainText(); + DDUMP(text.GetLength()); + e.Select(0, e.GetLength()); + e.Cut(); + DDUMP(e.GetLength()); + e.PasteText(ParseQTF(String().Cat() << "[%CS-CZ " << styles << "[s0; \1" << text.ToString() << "\1")); + DDUMP(e.GetLength()); + e.Select(0, e.GetLength()); + RichEdit h; + e.ApplyFormatInfo(h.GetFormatInfo()); + DDUMP(e.GetLength()); + e.Select(0, 0); + } + w.Run(); /* String strQTF = e.GetQTF(CHARSET_ISO8859_1); e.SetQTF(strQTF); w.Run(); */ - String x = e.GetQTF(); +/* String x = e.GetQTF(); SaveFile(FileName(), x); f = e.GetPosInfo(); StoreToFile(f, ConfigFile("pos")); - - SaveFile(GetHomeDirFile("test.rtf"), EncodeRTF(e.Get())); +*/ +// SaveFile(GetHomeDirFile("test.rtf"), EncodeRTF(e.Get())); LOG("Exit"); } diff --git a/uppdev/TestCppParser/CppParser.cpp b/uppdev/TestCppParser/CppParser.cpp index 8ae4325c6..4c5411e44 100644 --- a/uppdev/TestCppParser/CppParser.cpp +++ b/uppdev/TestCppParser/CppParser.cpp @@ -23,7 +23,7 @@ void Test(const char *path) Parser p; // p.Do(in, base, 0, 0, GetFileTitle(path), callback(AddError), Vector(), Vector(), Index()); - p.Do(in, base, 0, 0, GetFileTitle(path), callback(AddError), + p.Do(in, base, 0, FILE_C, GetFileTitle(path), callback(AddError), Vector(), Vector(), hh); if(errs.GetCount()) @@ -49,7 +49,7 @@ void Test(const char *path) p.dobody = true; in.Seek(0); - p.Do(in, base, 0, 0, GetFileTitle(path), callback(AddError), + p.Do(in, base, 0, FILE_C, GetFileTitle(path), callback(AddError), Vector(), Vector(), hh); out << " {\n"; diff --git a/uppdev/TestCppParser/test1.in b/uppdev/TestCppParser/test1.in index 779daa5f0..aaf461cf1 100644 --- a/uppdev/TestCppParser/test1.in +++ b/uppdev/TestCppParser/test1.in @@ -1,79 +1,7 @@ -class TreeNodeInfo : Moveable { - enum { SMALLCHARS = 40 }; +void Foo::Foo() { - int8 kind; - byte len; - word impressions; - dword sortaccel; -public: - struct Extended { - String name; - String aname; - String urlname; - String aurlname; - String title; - String atitle; - String altname; - String aaltname; - String nodeid; - int doubled_id; - int parent_id; - int master_id; - int impressions; - - bool master, noprotection, nosamecustomer, nooccupancyhigh, noncommercial, erotica; +void Foo::Bar(); - Extended(); - }; - union { - Extended *extended; - char text[SMALLCHARS]; - }; -private: - enum { EMPTY = -100 }; - - Extended& Ext(); - void Free(); - void Init(); - void Copy(const TreeNodeInfo& src); - - friend struct TreeInfo; - -public: -// int GetId() const { return id; } - String GetName() const { return kind ? String(text, len) : extended->name; } - String GetUrlName() const { return kind ? GetName() : extended->urlname; } - String GetNameA() const { return kind ? GetName() : extended->aname; } - - String GetUrlNameA() const { return kind ? String() : extended->aurlname; } - String GetAltName() const { return kind ? String() : extended->altname; } - String GetAltNameA() const { return kind ? String() : extended->aaltname; } - String GetTitle() const { return kind ? String() : extended->title; } - String GetTitleA() const { return kind ? String() : extended->atitle; } - - int GetDoubledId() const { return kind ? (int)Null : extended->doubled_id; } - int GetParentId() const { return kind == EMPTY ? Null : kind ? kind : extended->parent_id; } - int GetMasterId() const { return kind == EMPTY ? Null : kind ? kind : extended->master_id; } - - int GetImpressions() const { return kind ? impressions : extended->impressions; } - - String GetNodeId() const { return kind ? String() : extended->nodeid; } - bool IsMaster() const { return kind ? false : extended->master; } - bool NoProtection() const { return kind ? false : extended->noprotection; } - bool NoSameCustomer() const { return kind ? false : extended->nosamecustomer; } - bool NoOccupancyHigh() const { return kind ? false : extended->nooccupancyhigh; } - bool NonCommercial() const { return kind ? false : extended->noncommercial; } - bool Erotica() const { return kind ? false : extended->erotica; } - - bool IsExtended() const { return kind == 0; } - - int Less(dword sortaccel, const char *aname, int alen, const char *name, int len) const; - int Less(const TreeNodeInfo& b) const; - - void Serialize(Stream& s); - - TreeNodeInfo& operator=(const TreeNodeInfo& src); - TreeNodeInfo(const TreeNodeInfo& src); - TreeNodeInfo(); - ~TreeNodeInfo(); -}; +void Foo::Bar2() { +label: + int x = 10; \ No newline at end of file diff --git a/uppdev/TestCppParser/test2.in b/uppdev/TestCppParser/test2.in index b119cebfa..5033373cc 100644 --- a/uppdev/TestCppParser/test2.in +++ b/uppdev/TestCppParser/test2.in @@ -1,29 +1,4 @@ -typedef struct { - int x; - struct Foo { - int a; - } y; - struct { - int bar; - }; - struct { - int foo; - } quack; -} name; - -namespace std { - struct string {}; -}; - -// void Foo(string a); - -using namespace std; - -struct Bar { - struct string {}; - - std::string Foo(string a); -}; - -void Foo(string a); +extern "C++" // templates cannot be declared to have 'C' linkage +template +char (*RtlpNumberOf( T (&)[N] ))[N]; diff --git a/uppdev/TestCppParser/test3.in b/uppdev/TestCppParser/test3.in index 00f2c11fc..3e60d57d9 100644 --- a/uppdev/TestCppParser/test3.in +++ b/uppdev/TestCppParser/test3.in @@ -1,2 +1,5197 @@ -template -void Fn(); +extern "C++" // templates cannot be declared to have 'C' linkage +template +char (*RtlpNumberOf( T (&)[N] ))[N]; + +#define _WINNT_ + + + + + + + + +extern "C" { + + + +#define ANYSIZE_ARRAY 1 + +// +// For compilers that don't support nameless unions/structs +// + + +#define DUMMYUNIONNAME u +#define DUMMYUNIONNAME2 u2 +#define DUMMYUNIONNAME3 u3 +#define DUMMYUNIONNAME4 u4 +#define DUMMYUNIONNAME5 u5 +#define DUMMYUNIONNAME6 u6 +#define DUMMYUNIONNAME7 u7 +#define DUMMYUNIONNAME8 u8 +#define DUMMYUNIONNAME9 u9 + +#define DUMMYUNIONNAME +#define DUMMYUNIONNAME2 +#define DUMMYUNIONNAME3 +#define DUMMYUNIONNAME4 +#define DUMMYUNIONNAME5 +#define DUMMYUNIONNAME6 +#define DUMMYUNIONNAME7 +#define DUMMYUNIONNAME8 +#define DUMMYUNIONNAME9 + + + + + +#define DUMMYSTRUCTNAME s +#define DUMMYSTRUCTNAME2 s2 +#define DUMMYSTRUCTNAME3 s3 +#define DUMMYSTRUCTNAME4 s4 +#define DUMMYSTRUCTNAME5 s5 + +#define DUMMYSTRUCTNAME +#define DUMMYSTRUCTNAME2 +#define DUMMYSTRUCTNAME3 +#define DUMMYSTRUCTNAME4 +#define DUMMYSTRUCTNAME5 + + + + + + + + + + + +#define RESTRICTED_POINTER __restrict + +#define RESTRICTED_POINTER + + + +#define ALIGNMENT_MACHINE +#define UNALIGNED __unaligned + +#define UNALIGNED64 __unaligned + +#define UNALIGNED64 + + +#undef ALIGNMENT_MACHINE +#define UNALIGNED +#define UNALIGNED64 + + + + +#define MAX_NATURAL_ALIGNMENT sizeof(ULONGLONG) +#define MEMORY_ALLOCATION_ALIGNMENT 16 + +#define MAX_NATURAL_ALIGNMENT sizeof(DWORD) +#define MEMORY_ALLOCATION_ALIGNMENT 8 + + +// +// TYPE_ALIGNMENT will return the alignment requirements of a given type for +// the current platform. +// + + + +#define TYPE_ALIGNMENT( t ) __alignof(t) + + +#define TYPE_ALIGNMENT( t ) FIELD_OFFSET( struct { char x; t test; }, test ) + + + + + + +#define PROBE_ALIGNMENT( _s ) TYPE_ALIGNMENT( DWORD ) + +#define PROBE_ALIGNMENT( _s ) (TYPE_ALIGNMENT( _s ) > TYPE_ALIGNMENT( DWORD ) ? TYPE_ALIGNMENT( _s ) : TYPE_ALIGNMENT( DWORD )) + + + + + +#define PROBE_ALIGNMENT32( _s ) TYPE_ALIGNMENT( DWORD ) + + + +#define PROBE_ALIGNMENT( _s ) TYPE_ALIGNMENT( DWORD ) + + + +// +// C_ASSERT() can be used to perform many compile-time assertions: +// type sizes, field offsets, etc. +// +// An assertion failure results in error C2118: negative subscript. +// + + +#define C_ASSERT(e) typedef char __C_ASSERT__[(e)?1:-1] + +#define C_ASSERT(e) + + + + + + +#define DECLSPEC_IMPORT __declspec(dllimport) + +#define DECLSPEC_IMPORT + + + + +#define DECLSPEC_NORETURN __declspec(noreturn) + +#define DECLSPEC_NORETURN + + + + + +#define DECLSPEC_NOTHROW __declspec(nothrow) + +#define DECLSPEC_NOTHROW + + + + + +#define DECLSPEC_ALIGN(x) __declspec(align(x)) + +#define DECLSPEC_ALIGN(x) + + + + + +#define SYSTEM_CACHE_ALIGNMENT_SIZE 64 + +#define SYSTEM_CACHE_ALIGNMENT_SIZE 128 + + + + +#define DECLSPEC_CACHEALIGN DECLSPEC_ALIGN(SYSTEM_CACHE_ALIGNMENT_SIZE) + + + + +#define DECLSPEC_UUID(x) __declspec(uuid(x)) + +#define DECLSPEC_UUID(x) + + + + + +#define DECLSPEC_NOVTABLE __declspec(novtable) + +#define DECLSPEC_NOVTABLE + + + + + +#define DECLSPEC_SELECTANY __declspec(selectany) + +#define DECLSPEC_SELECTANY + + + + + +#define NOP_FUNCTION __noop + +#define NOP_FUNCTION (void)0 + + + + + +#define DECLSPEC_ADDRSAFE __declspec(address_safe) + +#define DECLSPEC_ADDRSAFE + + + + + +#define DECLSPEC_NOINLINE __declspec(noinline) + +#define DECLSPEC_NOINLINE + + + + + +#define FORCEINLINE __forceinline + +#define FORCEINLINE __inline + + + + + +#define DECLSPEC_DEPRECATED __declspec(deprecated) +#define DEPRECATE_SUPPORTED + +#define DECLSPEC_DEPRECATED +#undef DEPRECATE_SUPPORTED + + + + + +#define DECLSPEC_DEPRECATED_DDK DECLSPEC_DEPRECATED + +#define PRAGMA_DEPRECATED_DDK 1 + + +#define DECLSPEC_DEPRECATED_DDK +#define PRAGMA_DEPRECATED_DDK 1 + + +#define DECLSPEC_DEPRECATED_DDK +#define PRAGMA_DEPRECATED_DDK 0 + + +// +// Void +// + +typedef void *PVOID; +typedef void * PVOID64; + + + +#define NTAPI __stdcall + +#define _cdecl +#define __cdecl +#define NTAPI + + + +#define NTAPI_INLINE NTAPI + +#define NTAPI_INLINE + + +// +// Define API decoration for direct importing system DLL references. +// + + +#define NTSYSAPI DECLSPEC_IMPORT +#define NTSYSCALLAPI DECLSPEC_IMPORT + +#define NTSYSAPI + +#define NTSYSCALLAPI + +#define NTSYSCALLAPI DECLSPEC_ADDRSAFE + + + + + +// +// Basics +// + + +#define VOID void +typedef char CHAR; +typedef short SHORT; +typedef long LONG; + +typedef int INT; + + + +// +// UNICODE (Wide Character) types +// + + +typedef wchar_t WCHAR; // wc, 16-bit UNICODE character + + + + + +typedef WCHAR *PWCHAR, *LPWCH, *PWCH; +typedef const WCHAR *LPCWCH, *PCWCH; + +typedef WCHAR *NWPSTR, *LPWSTR, *PWSTR; +typedef PWSTR *PZPWSTR; +typedef const PWSTR *PCZPWSTR; +typedef WCHAR *LPUWSTR, *PUWSTR; +typedef const WCHAR *LPCWSTR, *PCWSTR; +typedef PCWSTR *PZPCWSTR; +typedef const WCHAR *LPCUWSTR, *PCUWSTR; + +typedef WCHAR *PZZWSTR; +typedef const WCHAR *PCZZWSTR; +typedef WCHAR *PUZZWSTR; +typedef const WCHAR *PCUZZWSTR; + +typedef [OnParameterOrReturnOnly] WCHAR *PNZWCH; +typedef [OnParameterOrReturnOnly] const WCHAR *PCNZWCH; +typedef [OnParameterOrReturnOnly] WCHAR *PUNZWCH; +typedef [OnParameterOrReturnOnly] const WCHAR *PCUNZWCH; + + + +typedef const WCHAR *LPCWCHAR, *PCWCHAR; +typedef const WCHAR *LPCUWCHAR, *PCUWCHAR; + +// +// UCS (Universal Character Set) types +// + +typedef unsigned long UCSCHAR; + +// +// Even pre-Unicode agreement, UCS values are always in the +// range U+00000000 to U+7FFFFFFF, so we'll pick an obvious +// value. + +#define UCSCHAR_INVALID_CHARACTER (0xffffffff) + +#define MIN_UCSCHAR (0) + +// +// We'll assume here that the ISO-10646 / Unicode agreement +// not to assign code points after U+0010FFFF holds so that +// we do not have to have separate "UCSCHAR" and "UNICODECHAR" +// types. +// + +#define MAX_UCSCHAR (0x0010FFFF) + +typedef UCSCHAR *PUCSCHAR; +typedef const UCSCHAR *PCUCSCHAR; + +typedef UCSCHAR *PUCSSTR; +typedef UCSCHAR *PUUCSSTR; + +typedef const UCSCHAR *PCUCSSTR; +typedef const UCSCHAR *PCUUCSSTR; + +typedef UCSCHAR *PUUCSCHAR; +typedef const UCSCHAR *PCUUCSCHAR; + + + + +// +// ANSI (Multi-byte Character) types +// +typedef CHAR *PCHAR, *LPCH, *PCH; +typedef const CHAR *LPCCH, *PCCH; + +typedef CHAR *NPSTR, *LPSTR, *PSTR; +typedef PSTR *PZPSTR; +typedef const PSTR *PCZPSTR; +typedef const CHAR *LPCSTR, *PCSTR; +typedef PCSTR *PZPCSTR; + +typedef CHAR *PZZSTR; +typedef const CHAR *PCZZSTR; + +typedef [OnParameterOrReturnOnly] CHAR *PNZCH; +typedef [OnParameterOrReturnOnly] const CHAR *PCNZCH; + +// +// Neutral ANSI/UNICODE types and macros +// + + + +typedef WCHAR TCHAR, *PTCHAR; +typedef WCHAR TBYTE , *PTBYTE ; +#define _TCHAR_DEFINED + + +typedef LPWCH LPTCH, PTCH; +typedef LPCWCH LPCTCH, PCTCH; +typedef LPWSTR PTSTR, LPTSTR; +typedef LPCWSTR PCTSTR, LPCTSTR; +typedef LPUWSTR PUTSTR, LPUTSTR; +typedef LPCUWSTR PCUTSTR, LPCUTSTR; +typedef LPWSTR LP; +typedef PZZWSTR PZZTSTR; +typedef PCZZWSTR PCZZTSTR; +typedef PUZZWSTR PUZZTSTR; +typedef PCUZZWSTR PCUZZTSTR; +typedef PNZWCH PNZTCH; +typedef PCNZWCH PCNZTCH; +typedef PUNZWCH PUNZTCH; +typedef PCUNZWCH PCUNZTCH; +#define __TEXT(quote) L##quote // r_winnt + + + + + + +#define _TCHAR_DEFINED + + + + + + + + + + +#define __TEXT(quote) quote // r_winnt + + +#define TEXT(quote) __TEXT(quote) // r_winnt + + +typedef SHORT *PSHORT; +typedef LONG *PLONG; + +#define ALL_PROCESSOR_GROUPS 0xffff + +// +// Structure to represent a system wide processor number. It contains a +// group number and relative processor number within the group. +// + +typedef struct _PROCESSOR_NUMBER { + WORD Group; + BYTE Number; + BYTE Reserved; +} PROCESSOR_NUMBER, *PPROCESSOR_NUMBER; + +// +// Structure to represent a group-specific affinity, such as that of a +// thread. Specifies the group number and the affinity within that group. +// + +typedef struct _GROUP_AFFINITY { + KAFFINITY Mask; + WORD Group; + WORD Reserved[3]; +} GROUP_AFFINITY, *PGROUP_AFFINITY; + +// +// Handle to an Object +// + + +typedef void *HANDLE; + +#define DECLARE_HANDLE(name) struct name##__; typedef struct name##__ *name + +#define DECLARE_HANDLE(name) struct name##__{int unused;}; typedef struct name##__ *name + + + +#define DECLARE_HANDLE(name) typedef HANDLE name + +typedef HANDLE *PHANDLE; + +// +// Flag (bit) fields +// + +typedef BYTE FCHAR; +typedef WORD FSHORT; +typedef DWORD FLONG; + +// Component Object Model defines, and macros + + +#define _HRESULT_DEFINED + +typedef LONG HRESULT; + + + + + + + #define EXTERN_C extern "C" + + #define EXTERN_C extern + + + + +// Win32 doesn't support __export + + +#define STDMETHODCALLTYPE __cdecl + +#define STDMETHODCALLTYPE __stdcall + +#define STDMETHODVCALLTYPE __cdecl + +#define STDAPICALLTYPE __stdcall +#define STDAPIVCALLTYPE __cdecl + + + +#define STDMETHODCALLTYPE __export __stdcall +#define STDMETHODVCALLTYPE __export __cdecl + +#define STDAPICALLTYPE __export __stdcall +#define STDAPIVCALLTYPE __export __cdecl + + + + +#define STDAPI EXTERN_C HRESULT STDAPICALLTYPE +#define STDAPI_(type) EXTERN_C type STDAPICALLTYPE + +#define STDMETHODIMP HRESULT STDMETHODCALLTYPE +#define STDMETHODIMP_(type) type STDMETHODCALLTYPE + +#define STDOVERRIDEMETHODIMP __override STDMETHODIMP +#define STDOVERRIDEMETHODIMP_(type) __override STDMETHODIMP_(type) + +#define IFACEMETHODIMP __override STDMETHODIMP +#define IFACEMETHODIMP_(type) __override STDMETHODIMP_(type) + +// The 'V' versions allow Variable Argument lists. + +#define STDAPIV EXTERN_C HRESULT STDAPIVCALLTYPE +#define STDAPIV_(type) EXTERN_C type STDAPIVCALLTYPE + +#define STDMETHODIMPV HRESULT STDMETHODVCALLTYPE +#define STDMETHODIMPV_(type) type STDMETHODVCALLTYPE + +#define STDOVERRIDEMETHODIMPV __override STDMETHODIMPV +#define STDOVERRIDEMETHODIMPV_(type) __override STDMETHODIMPV_(type) + +#define IFACEMETHODIMPV __override STDMETHODIMPV +#define IFACEMETHODIMPV_(type) __override STDMETHODIMPV_(type) + +typedef char CCHAR; +typedef DWORD LCID; +typedef PDWORD PLCID; +typedef WORD LANGID; +#define APPLICATION_ERROR_MASK 0x20000000 +#define ERROR_SEVERITY_SUCCESS 0x00000000 +#define ERROR_SEVERITY_INFORMATIONAL 0x40000000 +#define ERROR_SEVERITY_WARNING 0x80000000 +#define ERROR_SEVERITY_ERROR 0xC0000000 + +// +// _M_IX86 included so that EM CONTEXT structure compiles with +// x86 programs. *** TBD should this be for all architectures? +// + +// +// 16 byte aligned type for 128 bit floats +// + +// +// For we define a 128 bit structure and use __declspec(align(16)) pragma to +// align to 128 bits. +// + + + + +typedef struct _FLOAT128 { + __int64 LowPart; + __int64 HighPart; +} FLOAT128; + +typedef FLOAT128 *PFLOAT128; + + +// +// __int64 is only supported by 2.0 and later midl. +// __midl is set by the 2.0 midl and not by 1.0 midl. +// + +#define _ULONGLONG_ + +typedef __int64 LONGLONG; +typedef unsigned __int64 ULONGLONG; + +#define MAXLONGLONG (0x7fffffffffffffff) + + + + + + + + +#define MAXLONGLONG (0x7fffffffffffffff) + + + + + + + + + +typedef LONGLONG *PLONGLONG; +typedef ULONGLONG *PULONGLONG; + +// Update Sequence Number + +typedef LONGLONG USN; + + +typedef struct _LARGE_INTEGER { + + + + + + + + + + + + LONGLONG QuadPart; +} LARGE_INTEGER; + +typedef LARGE_INTEGER *PLARGE_INTEGER; + + +typedef struct _ULARGE_INTEGER { + + + + + + + + + + + + ULONGLONG QuadPart; +} ULARGE_INTEGER; + +typedef ULARGE_INTEGER *PULARGE_INTEGER; + +// end_ntminiport end_ntndis end_ntminitape + + +// +// Locally Unique Identifier +// + +typedef struct _LUID { + DWORD LowPart; + LONG HighPart; +} LUID, *PLUID; + +#define _DWORDLONG_ +typedef ULONGLONG DWORDLONG; +typedef DWORDLONG *PDWORDLONG; + + +// +// Define operations to logically shift an int64 by 0..31 bits and to multiply +// 32-bits by 32-bits to form a 64-bit product. +// + + + + + +// +// Midl does not understand inline assembler. Therefore, the Rtl functions +// are used for shifts by 0..31 and multiplies of 32-bits times 32-bits to +// form a 64-bit product. +// +// +// IA64 and AMD64 have native 64-bit operations that are just as fast as their +// 32-bit counter parts. Therefore, the int64 data type is used directly to form +// shifts of 0..31 and multiplies of 32-bits times 32-bits to form a 64-bit +// product. +// + +#define Int32x32To64(a, b) (((__int64)((long)(a))) * ((__int64)((long)(b)))) +#define UInt32x32To64(a, b) (((unsigned __int64)((unsigned int)(a))) * ((unsigned __int64)((unsigned int)(b)))) + +#define Int64ShllMod32(a, b) (((unsigned __int64)(a)) << (b)) +#define Int64ShraMod32(a, b) (((__int64)(a)) >> (b)) +#define Int64ShrlMod32(a, b) (((unsigned __int64)(a)) >> (b)) + + + + + + + + + + + +#define Int32x32To64(a, b) ((__int64)(((__int64)((long)(a))) * ((long)(b)))) +#define UInt32x32To64(a, b) ((unsigned __int64)(((unsigned __int64)((unsigned int)(a))) * ((unsigned int)(b)))) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +// +// Define rotate intrinsics. +// + + +extern "C" { + + + + +#define RotateLeft8 _rotl8 +#define RotateLeft16 _rotl16 +#define RotateRight8 _rotr8 +#define RotateRight16 _rotr16 + +unsigned char + +_rotl8 ( + [OnParameterOnly] unsigned char Value, + [OnParameterOnly] unsigned char Shift + ); + +unsigned short + +_rotl16 ( + [OnParameterOnly] unsigned short Value, + [OnParameterOnly] unsigned char Shift + ); + +unsigned char + +_rotr8 ( + [OnParameterOnly] unsigned char Value, + [OnParameterOnly] unsigned char Shift + ); + +unsigned short + +_rotr16 ( + [OnParameterOnly] unsigned short Value, + [OnParameterOnly] unsigned char Shift + ); + + + + + + + + + + +#define RotateLeft32 _rotl +#define RotateLeft64 _rotl64 +#define RotateRight32 _rotr +#define RotateRight64 _rotr64 + + [method: OnFunctionOnly] +unsigned int + +_rotl ( + [OnParameterOnly] unsigned int Value, + [OnParameterOnly] int Shift + ); + + [method: OnFunctionOnly] +unsigned __int64 + +_rotl64 ( + [OnParameterOnly] unsigned __int64 Value, + [OnParameterOnly] int Shift + ); + + [method: OnFunctionOnly] +unsigned int + +_rotr ( + [OnParameterOnly] unsigned int Value, + [OnParameterOnly] int Shift + ); + + [method: OnFunctionOnly] +unsigned __int64 + +_rotr64 ( + [OnParameterOnly] unsigned __int64 Value, + [OnParameterOnly] int Shift + ); + + + + + + + + + +} + + +#define ANSI_NULL ((CHAR)0) +#define UNICODE_NULL ((WCHAR)0) +#define UNICODE_STRING_MAX_BYTES ((WORD ) 65534) +#define UNICODE_STRING_MAX_CHARS (32767) +typedef BYTE BOOLEAN; +typedef BOOLEAN *PBOOLEAN; +// +// Doubly linked list structure. Can be used as either a list head, or +// as link words. +// + +typedef struct _LIST_ENTRY { + struct _LIST_ENTRY *Flink; + struct _LIST_ENTRY *Blink; +} LIST_ENTRY, *PLIST_ENTRY, * PRLIST_ENTRY; + +// +// Singly linked list structure. Can be used as either a list head, or +// as link words. +// + +typedef struct _SINGLE_LIST_ENTRY { + struct _SINGLE_LIST_ENTRY *Next; +} SINGLE_LIST_ENTRY, *PSINGLE_LIST_ENTRY; + + +// +// These are needed for portable debugger support. +// + +typedef struct LIST_ENTRY32 { + DWORD Flink; + DWORD Blink; +} LIST_ENTRY32; +typedef LIST_ENTRY32 *PLIST_ENTRY32; + +typedef struct LIST_ENTRY64 { + ULONGLONG Flink; + ULONGLONG Blink; +} LIST_ENTRY64; +typedef LIST_ENTRY64 *PLIST_ENTRY64; + + + + + +#define __OBJECTID_DEFINED + +typedef struct _OBJECTID { // size is 20 + GUID Lineage; + DWORD Uniquifier; +} OBJECTID; + + +#define MINCHAR 0x80 +#define MAXCHAR 0x7f +#define MINSHORT 0x8000 +#define MAXSHORT 0x7fff +#define MINLONG 0x80000000 +#define MAXLONG 0x7fffffff +#define MAXBYTE 0xff +#define MAXWORD 0xffff +#define MAXDWORD 0xffffffff +// +// Calculate the byte offset of a field in a structure of type type. +// + +#define FIELD_OFFSET(type, field) ((LONG)(LONG_PTR)&(((type *)0)->field)) + +// +// Calculate the size of a field in a structure of type type, without +// knowing or stating the type of the field. +// +#define RTL_FIELD_SIZE(type, field) (sizeof(((type *)0)->field)) + +// +// Calculate the size of a structure of type type up through and +// including a field. +// +#define RTL_SIZEOF_THROUGH_FIELD(type, field) (FIELD_OFFSET(type, field) + RTL_FIELD_SIZE(type, field)) + + +// +// RTL_CONTAINS_FIELD usage: +// +// if (RTL_CONTAINS_FIELD(pBlock, pBlock->cbSize, dwMumble)) { // safe to use pBlock->dwMumble +// +#define RTL_CONTAINS_FIELD(Struct, Size, Field) ( (((PCHAR)(&(Struct)->Field)) + sizeof((Struct)->Field)) <= (((PCHAR)(Struct))+(Size)) ) + + +// +// Return the number of elements in a statically sized array. +// DWORD Buffer[100]; +// RTL_NUMBER_OF(Buffer) == 100 +// This is also popularly known as: NUMBER_OF, ARRSIZE, _countof, NELEM, etc. +// +#define RTL_NUMBER_OF_V1(A) (sizeof(A)/sizeof((A)[0])) + + + + + + + +// +// RtlpNumberOf is a function that takes a reference to an array of N Ts. +// +// typedef T array_of_T[N]; +// typedef array_of_T &reference_to_array_of_T; +// +// RtlpNumberOf returns a pointer to an array of N chars. +// We could return a reference instead of a pointer but older compilers do not accept that. +// +// typedef char array_of_char[N]; +// typedef array_of_char *pointer_to_array_of_char; +// +// sizeof(array_of_char) == N +// sizeof(*pointer_to_array_of_char) == N +// +// pointer_to_array_of_char RtlpNumberOf(reference_to_array_of_T); +// +// We never even call RtlpNumberOf, we just take the size of dereferencing its return type. +// We do not even implement RtlpNumberOf, we just decare it. +// +// Attempts to pass pointers instead of arrays to this macro result in compile time errors. +// That is the point. +// +extern "C++" // templates cannot be declared to have 'C' linkage +template +char (*RtlpNumberOf( T (&)[N] ))[N]; + +#define RTL_NUMBER_OF_V2(A) (sizeof(*RtlpNumberOf(A))) + +// +// This does not work with: +// +// void Foo() +// { +// struct { int x; } y[2]; +// RTL_NUMBER_OF_V2(y); // illegal use of anonymous local type in template instantiation +// } +// +// You must instead do: +// +// struct Foo1 { int x; }; +// +// void Foo() +// { +// Foo1 y[2]; +// RTL_NUMBER_OF_V2(y); // ok +// } +// +// OR +// +// void Foo() +// { +// struct { int x; } y[2]; +// RTL_NUMBER_OF_V1(y); // ok +// } +// +// OR +// +// void Foo() +// { +// struct { int x; } y[2]; +// _ARRAYSIZE(y); // ok +// } +// + + +#define RTL_NUMBER_OF_V2(A) RTL_NUMBER_OF_V1(A) + + + +#define RTL_NUMBER_OF(A) RTL_NUMBER_OF_V2(A) + +#define RTL_NUMBER_OF(A) RTL_NUMBER_OF_V1(A) + + +// +// ARRAYSIZE is more readable version of RTL_NUMBER_OF_V2, and uses +// it regardless of ENABLE_RTL_NUMBER_OF_V2 +// +// _ARRAYSIZE is a version useful for anonymous types +// +#define ARRAYSIZE(A) RTL_NUMBER_OF_V2(A) +#define _ARRAYSIZE(A) RTL_NUMBER_OF_V1(A) + +// +// An expression that yields the type of a field in a struct. +// +#define RTL_FIELD_TYPE(type, field) (((type*)0)->field) + +// RTL_ to avoid collisions in the global namespace. +// +// Given typedef struct _FOO { BYTE Bar[123]; } FOO; +// RTL_NUMBER_OF_FIELD(FOO, Bar) == 123 +// +#define RTL_NUMBER_OF_FIELD(type, field) (RTL_NUMBER_OF(RTL_FIELD_TYPE(type, field))) + +// +// eg: +// typedef struct FOO { +// DWORD Integer; +// PVOID Pointer; +// } FOO; +// +// RTL_PADDING_BETWEEN_FIELDS(FOO, Integer, Pointer) == 0 for Win32, 4 for Win64 +// +#define RTL_PADDING_BETWEEN_FIELDS(T, F1, F2) ((FIELD_OFFSET(T, F2) > FIELD_OFFSET(T, F1)) ? (FIELD_OFFSET(T, F2) - FIELD_OFFSET(T, F1) - RTL_FIELD_SIZE(T, F1)) : (FIELD_OFFSET(T, F1) - FIELD_OFFSET(T, F2) - RTL_FIELD_SIZE(T, F2))) + + + + +// RTL_ to avoid collisions in the global namespace. + +#define RTL_CONST_CAST(type) const_cast + +#define RTL_CONST_CAST(type) (type) + + + +// like sizeof +// usually this would be * CHAR_BIT, but we don't necessarily have #include +#define RTL_BITS_OF(sizeOfArg) (sizeof(sizeOfArg) * 8) + +#define RTL_BITS_OF_FIELD(type, field) (RTL_BITS_OF(RTL_FIELD_TYPE(type, field))) + +// +// Calculate the address of the base of the structure given its type, and an +// address of a field within the structure. +// + +#define CONTAINING_RECORD(address, type, field) ((type *)( (PCHAR)(address) - (ULONG_PTR)(&((type *)0)->field))) + + + +// end_ntminiport end_ntndis + +// +// Exception handler routine definition. +// + + + +typedef + + +EXCEPTION_DISPOSITION + +EXCEPTION_ROUTINE ( + [OnParameterOnly] struct _EXCEPTION_RECORD *ExceptionRecord, + [OnParameterOnly] PVOID EstablisherFrame, + [OnParameterOnly] struct _CONTEXT *ContextRecord, + [OnParameterOnly] PVOID DispatcherContext + ); + +typedef EXCEPTION_ROUTINE *PEXCEPTION_ROUTINE; + + +#define VER_SERVER_NT 0x80000000 +#define VER_WORKSTATION_NT 0x40000000 +#define VER_SUITE_SMALLBUSINESS 0x00000001 +#define VER_SUITE_ENTERPRISE 0x00000002 +#define VER_SUITE_BACKOFFICE 0x00000004 +#define VER_SUITE_COMMUNICATIONS 0x00000008 +#define VER_SUITE_TERMINAL 0x00000010 +#define VER_SUITE_SMALLBUSINESS_RESTRICTED 0x00000020 +#define VER_SUITE_EMBEDDEDNT 0x00000040 +#define VER_SUITE_DATACENTER 0x00000080 +#define VER_SUITE_SINGLEUSERTS 0x00000100 +#define VER_SUITE_PERSONAL 0x00000200 +#define VER_SUITE_BLADE 0x00000400 +#define VER_SUITE_EMBEDDED_RESTRICTED 0x00000800 +#define VER_SUITE_SECURITY_APPLIANCE 0x00001000 +#define VER_SUITE_STORAGE_SERVER 0x00002000 +#define VER_SUITE_COMPUTE_SERVER 0x00004000 +#define VER_SUITE_WH_SERVER 0x00008000 + + +// +// Product types +// This list grows with each OS release. +// +// There is no ordering of values to ensure callers +// do an equality test i.e. greater-than and less-than +// comparisons are not useful. +// +// NOTE: Values in this list should never be deleted. +// When a product-type 'X' gets dropped from a +// OS release onwards, the value of 'X' continues +// to be used in the mapping table of GetProductInfo. +// + +#define PRODUCT_UNDEFINED 0x00000000 + +#define PRODUCT_ULTIMATE 0x00000001 +#define PRODUCT_HOME_BASIC 0x00000002 +#define PRODUCT_HOME_PREMIUM 0x00000003 +#define PRODUCT_ENTERPRISE 0x00000004 +#define PRODUCT_HOME_BASIC_N 0x00000005 +#define PRODUCT_BUSINESS 0x00000006 +#define PRODUCT_STANDARD_SERVER 0x00000007 +#define PRODUCT_DATACENTER_SERVER 0x00000008 +#define PRODUCT_SMALLBUSINESS_SERVER 0x00000009 +#define PRODUCT_ENTERPRISE_SERVER 0x0000000A +#define PRODUCT_STARTER 0x0000000B +#define PRODUCT_DATACENTER_SERVER_CORE 0x0000000C +#define PRODUCT_STANDARD_SERVER_CORE 0x0000000D +#define PRODUCT_ENTERPRISE_SERVER_CORE 0x0000000E +#define PRODUCT_ENTERPRISE_SERVER_IA64 0x0000000F +#define PRODUCT_BUSINESS_N 0x00000010 +#define PRODUCT_WEB_SERVER 0x00000011 +#define PRODUCT_CLUSTER_SERVER 0x00000012 +#define PRODUCT_HOME_SERVER 0x00000013 +#define PRODUCT_STORAGE_EXPRESS_SERVER 0x00000014 +#define PRODUCT_STORAGE_STANDARD_SERVER 0x00000015 +#define PRODUCT_STORAGE_WORKGROUP_SERVER 0x00000016 +#define PRODUCT_STORAGE_ENTERPRISE_SERVER 0x00000017 +#define PRODUCT_SERVER_FOR_SMALLBUSINESS 0x00000018 +#define PRODUCT_SMALLBUSINESS_SERVER_PREMIUM 0x00000019 +#define PRODUCT_HOME_PREMIUM_N 0x0000001A +#define PRODUCT_ENTERPRISE_N 0x0000001B +#define PRODUCT_ULTIMATE_N 0x0000001C +#define PRODUCT_WEB_SERVER_CORE 0x0000001D +#define PRODUCT_MEDIUMBUSINESS_SERVER_MANAGEMENT 0x0000001E +#define PRODUCT_MEDIUMBUSINESS_SERVER_SECURITY 0x0000001F +#define PRODUCT_MEDIUMBUSINESS_SERVER_MESSAGING 0x00000020 +#define PRODUCT_SERVER_FOUNDATION 0x00000021 +#define PRODUCT_HOME_PREMIUM_SERVER 0x00000022 +#define PRODUCT_SERVER_FOR_SMALLBUSINESS_V 0x00000023 +#define PRODUCT_STANDARD_SERVER_V 0x00000024 +#define PRODUCT_DATACENTER_SERVER_V 0x00000025 +#define PRODUCT_ENTERPRISE_SERVER_V 0x00000026 +#define PRODUCT_DATACENTER_SERVER_CORE_V 0x00000027 +#define PRODUCT_STANDARD_SERVER_CORE_V 0x00000028 +#define PRODUCT_ENTERPRISE_SERVER_CORE_V 0x00000029 +#define PRODUCT_HYPERV 0x0000002A +#define PRODUCT_STORAGE_EXPRESS_SERVER_CORE 0x0000002B +#define PRODUCT_STORAGE_STANDARD_SERVER_CORE 0x0000002C +#define PRODUCT_STORAGE_WORKGROUP_SERVER_CORE 0x0000002D +#define PRODUCT_STORAGE_ENTERPRISE_SERVER_CORE 0x0000002E +#define PRODUCT_STARTER_N 0x0000002F +#define PRODUCT_PROFESSIONAL 0x00000030 +#define PRODUCT_PROFESSIONAL_N 0x00000031 +#define PRODUCT_SB_SOLUTION_SERVER 0x00000032 +#define PRODUCT_SERVER_FOR_SB_SOLUTIONS 0x00000033 +#define PRODUCT_STANDARD_SERVER_SOLUTIONS 0x00000034 +#define PRODUCT_STANDARD_SERVER_SOLUTIONS_CORE 0x00000035 +#define PRODUCT_SB_SOLUTION_SERVER_EM 0x00000036 +#define PRODUCT_SERVER_FOR_SB_SOLUTIONS_EM 0x00000037 +#define PRODUCT_SOLUTION_EMBEDDEDSERVER 0x00000038 +#define PRODUCT_SOLUTION_EMBEDDEDSERVER_CORE 0x00000039 +#define PRODUCT_SMALLBUSINESS_SERVER_PREMIUM_CORE 0x0000003F +#define PRODUCT_ESSENTIALBUSINESS_SERVER_MGMT 0x0000003B +#define PRODUCT_ESSENTIALBUSINESS_SERVER_ADDL 0x0000003C +#define PRODUCT_ESSENTIALBUSINESS_SERVER_MGMTSVC 0x0000003D +#define PRODUCT_ESSENTIALBUSINESS_SERVER_ADDLSVC 0x0000003E +#define PRODUCT_CLUSTER_SERVER_V 0x00000040 +#define PRODUCT_EMBEDDED 0x00000041 +#define PRODUCT_STARTER_E 0x00000042 +#define PRODUCT_HOME_BASIC_E 0x00000043 +#define PRODUCT_HOME_PREMIUM_E 0x00000044 +#define PRODUCT_PROFESSIONAL_E 0x00000045 +#define PRODUCT_ENTERPRISE_E 0x00000046 +#define PRODUCT_ULTIMATE_E 0x00000047 + +#define PRODUCT_UNLICENSED 0xABCDABCD + + + +// +// Language IDs. +// +// Note that the named locale APIs (eg GetLocaleInfoEx) are preferred. +// +// Not all locales have unique Language IDs +// +// The following two combinations of primary language ID and +// sublanguage ID have special semantics: +// +// Primary Language ID Sublanguage ID Result +// ------------------- --------------- ------------------------ +// LANG_NEUTRAL SUBLANG_NEUTRAL Language neutral +// LANG_NEUTRAL SUBLANG_DEFAULT User default language +// LANG_NEUTRAL SUBLANG_SYS_DEFAULT System default language +// LANG_INVARIANT SUBLANG_NEUTRAL Invariant locale +// +// It is recommended that applications test for locale names instead of +// Language IDs / LCIDs. + +// +// Primary language IDs. +// +// WARNING: These aren't always unique. Bosnian, Serbian & Croation for example. +// +// It is recommended that applications test for locale names or actual LCIDs. +// +// Note that the LANG, SUBLANG construction is not always consistent. +// The named locale APIs (eg GetLocaleInfoEx) are recommended. +// +#define LANG_NEUTRAL 0x00 +#define LANG_INVARIANT 0x7f + +#define LANG_AFRIKAANS 0x36 +#define LANG_ALBANIAN 0x1c +#define LANG_ALSATIAN 0x84 +#define LANG_AMHARIC 0x5e +#define LANG_ARABIC 0x01 +#define LANG_ARMENIAN 0x2b +#define LANG_ASSAMESE 0x4d +#define LANG_AZERI 0x2c +#define LANG_BASHKIR 0x6d +#define LANG_BASQUE 0x2d +#define LANG_BELARUSIAN 0x23 +#define LANG_BENGALI 0x45 +#define LANG_BRETON 0x7e +#define LANG_BOSNIAN 0x1a // Use with SUBLANG_BOSNIAN_* Sublanguage IDs +#define LANG_BOSNIAN_NEUTRAL 0x781a // Use with the ConvertDefaultLocale function +#define LANG_BULGARIAN 0x02 +#define LANG_CATALAN 0x03 +#define LANG_CHINESE 0x04 // Use with SUBLANG_CHINESE_* Sublanguage IDs +#define LANG_CHINESE_SIMPLIFIED 0x04 // Use with the ConvertDefaultLocale function +#define LANG_CHINESE_TRADITIONAL 0x7c04 // Use with the ConvertDefaultLocale function +#define LANG_CORSICAN 0x83 +#define LANG_CROATIAN 0x1a +#define LANG_CZECH 0x05 +#define LANG_DANISH 0x06 +#define LANG_DARI 0x8c +#define LANG_DIVEHI 0x65 +#define LANG_DUTCH 0x13 +#define LANG_ENGLISH 0x09 +#define LANG_ESTONIAN 0x25 +#define LANG_FAEROESE 0x38 +#define LANG_FARSI 0x29 // Deprecated: use LANG_PERSIAN instead +#define LANG_FILIPINO 0x64 +#define LANG_FINNISH 0x0b +#define LANG_FRENCH 0x0c +#define LANG_FRISIAN 0x62 +#define LANG_GALICIAN 0x56 +#define LANG_GEORGIAN 0x37 +#define LANG_GERMAN 0x07 +#define LANG_GREEK 0x08 +#define LANG_GREENLANDIC 0x6f +#define LANG_GUJARATI 0x47 +#define LANG_HAUSA 0x68 +#define LANG_HEBREW 0x0d +#define LANG_HINDI 0x39 +#define LANG_HUNGARIAN 0x0e +#define LANG_ICELANDIC 0x0f +#define LANG_IGBO 0x70 +#define LANG_INDONESIAN 0x21 +#define LANG_INUKTITUT 0x5d +#define LANG_IRISH 0x3c // Use with the SUBLANG_IRISH_IRELAND Sublanguage ID +#define LANG_ITALIAN 0x10 +#define LANG_JAPANESE 0x11 +#define LANG_KANNADA 0x4b +#define LANG_KASHMIRI 0x60 +#define LANG_KAZAK 0x3f +#define LANG_KHMER 0x53 +#define LANG_KICHE 0x86 +#define LANG_KINYARWANDA 0x87 +#define LANG_KONKANI 0x57 +#define LANG_KOREAN 0x12 +#define LANG_KYRGYZ 0x40 +#define LANG_LAO 0x54 +#define LANG_LATVIAN 0x26 +#define LANG_LITHUANIAN 0x27 +#define LANG_LOWER_SORBIAN 0x2e +#define LANG_LUXEMBOURGISH 0x6e +#define LANG_MACEDONIAN 0x2f // the Former Yugoslav Republic of Macedonia +#define LANG_MALAY 0x3e +#define LANG_MALAYALAM 0x4c +#define LANG_MALTESE 0x3a +#define LANG_MANIPURI 0x58 +#define LANG_MAORI 0x81 +#define LANG_MAPUDUNGUN 0x7a +#define LANG_MARATHI 0x4e +#define LANG_MOHAWK 0x7c +#define LANG_MONGOLIAN 0x50 +#define LANG_NEPALI 0x61 +#define LANG_NORWEGIAN 0x14 +#define LANG_OCCITAN 0x82 +#define LANG_ORIYA 0x48 +#define LANG_PASHTO 0x63 +#define LANG_PERSIAN 0x29 +#define LANG_POLISH 0x15 +#define LANG_PORTUGUESE 0x16 +#define LANG_PUNJABI 0x46 +#define LANG_QUECHUA 0x6b +#define LANG_ROMANIAN 0x18 +#define LANG_ROMANSH 0x17 +#define LANG_RUSSIAN 0x19 +#define LANG_SAMI 0x3b +#define LANG_SANSKRIT 0x4f +#define LANG_SCOTTISH_GAELIC 0x91 +#define LANG_SERBIAN 0x1a // Use with the SUBLANG_SERBIAN_* Sublanguage IDs +#define LANG_SERBIAN_NEUTRAL 0x7c1a // Use with the ConvertDefaultLocale function +#define LANG_SINDHI 0x59 +#define LANG_SINHALESE 0x5b +#define LANG_SLOVAK 0x1b +#define LANG_SLOVENIAN 0x24 +#define LANG_SOTHO 0x6c +#define LANG_SPANISH 0x0a +#define LANG_SWAHILI 0x41 +#define LANG_SWEDISH 0x1d +#define LANG_SYRIAC 0x5a +#define LANG_TAJIK 0x28 +#define LANG_TAMAZIGHT 0x5f +#define LANG_TAMIL 0x49 +#define LANG_TATAR 0x44 +#define LANG_TELUGU 0x4a +#define LANG_THAI 0x1e +#define LANG_TIBETAN 0x51 +#define LANG_TIGRIGNA 0x73 +#define LANG_TSWANA 0x32 +#define LANG_TURKISH 0x1f +#define LANG_TURKMEN 0x42 +#define LANG_UIGHUR 0x80 +#define LANG_UKRAINIAN 0x22 +#define LANG_UPPER_SORBIAN 0x2e +#define LANG_URDU 0x20 +#define LANG_UZBEK 0x43 +#define LANG_VIETNAMESE 0x2a +#define LANG_WELSH 0x52 +#define LANG_WOLOF 0x88 +#define LANG_XHOSA 0x34 +#define LANG_YAKUT 0x85 +#define LANG_YI 0x78 +#define LANG_YORUBA 0x6a +#define LANG_ZULU 0x35 + +// +// Sublanguage IDs. +// +// The name immediately following SUBLANG_ dictates which primary +// language ID that sublanguage ID can be combined with to form a +// valid language ID. +// +// Note that the LANG, SUBLANG construction is not always consistent. +// The named locale APIs (eg GetLocaleInfoEx) are recommended. +// + +#define SUBLANG_NEUTRAL 0x00 // language neutral +#define SUBLANG_DEFAULT 0x01 // user default +#define SUBLANG_SYS_DEFAULT 0x02 // system default +#define SUBLANG_CUSTOM_DEFAULT 0x03 // default custom language/locale +#define SUBLANG_CUSTOM_UNSPECIFIED 0x04 // custom language/locale +#define SUBLANG_UI_CUSTOM_DEFAULT 0x05 // Default custom MUI language/locale + + +#define SUBLANG_AFRIKAANS_SOUTH_AFRICA 0x01 // Afrikaans (South Africa) 0x0436 af-ZA +#define SUBLANG_ALBANIAN_ALBANIA 0x01 // Albanian (Albania) 0x041c sq-AL +#define SUBLANG_ALSATIAN_FRANCE 0x01 // Alsatian (France) 0x0484 +#define SUBLANG_AMHARIC_ETHIOPIA 0x01 // Amharic (Ethiopia) 0x045e +#define SUBLANG_ARABIC_SAUDI_ARABIA 0x01 // Arabic (Saudi Arabia) +#define SUBLANG_ARABIC_IRAQ 0x02 // Arabic (Iraq) +#define SUBLANG_ARABIC_EGYPT 0x03 // Arabic (Egypt) +#define SUBLANG_ARABIC_LIBYA 0x04 // Arabic (Libya) +#define SUBLANG_ARABIC_ALGERIA 0x05 // Arabic (Algeria) +#define SUBLANG_ARABIC_MOROCCO 0x06 // Arabic (Morocco) +#define SUBLANG_ARABIC_TUNISIA 0x07 // Arabic (Tunisia) +#define SUBLANG_ARABIC_OMAN 0x08 // Arabic (Oman) +#define SUBLANG_ARABIC_YEMEN 0x09 // Arabic (Yemen) +#define SUBLANG_ARABIC_SYRIA 0x0a // Arabic (Syria) +#define SUBLANG_ARABIC_JORDAN 0x0b // Arabic (Jordan) +#define SUBLANG_ARABIC_LEBANON 0x0c // Arabic (Lebanon) +#define SUBLANG_ARABIC_KUWAIT 0x0d // Arabic (Kuwait) +#define SUBLANG_ARABIC_UAE 0x0e // Arabic (U.A.E) +#define SUBLANG_ARABIC_BAHRAIN 0x0f // Arabic (Bahrain) +#define SUBLANG_ARABIC_QATAR 0x10 // Arabic (Qatar) +#define SUBLANG_ARMENIAN_ARMENIA 0x01 // Armenian (Armenia) 0x042b hy-AM +#define SUBLANG_ASSAMESE_INDIA 0x01 // Assamese (India) 0x044d +#define SUBLANG_AZERI_LATIN 0x01 // Azeri (Latin) +#define SUBLANG_AZERI_CYRILLIC 0x02 // Azeri (Cyrillic) +#define SUBLANG_BASHKIR_RUSSIA 0x01 // Bashkir (Russia) 0x046d ba-RU +#define SUBLANG_BASQUE_BASQUE 0x01 // Basque (Basque) 0x042d eu-ES +#define SUBLANG_BELARUSIAN_BELARUS 0x01 // Belarusian (Belarus) 0x0423 be-BY +#define SUBLANG_BENGALI_INDIA 0x01 // Bengali (India) +#define SUBLANG_BENGALI_BANGLADESH 0x02 // Bengali (Bangladesh) +#define SUBLANG_BOSNIAN_BOSNIA_HERZEGOVINA_LATIN 0x05 // Bosnian (Bosnia and Herzegovina - Latin) 0x141a bs-BA-Latn +#define SUBLANG_BOSNIAN_BOSNIA_HERZEGOVINA_CYRILLIC 0x08 // Bosnian (Bosnia and Herzegovina - Cyrillic) 0x201a bs-BA-Cyrl +#define SUBLANG_BRETON_FRANCE 0x01 // Breton (France) 0x047e +#define SUBLANG_BULGARIAN_BULGARIA 0x01 // Bulgarian (Bulgaria) 0x0402 +#define SUBLANG_CATALAN_CATALAN 0x01 // Catalan (Catalan) 0x0403 +#define SUBLANG_CHINESE_TRADITIONAL 0x01 // Chinese (Taiwan) 0x0404 zh-TW +#define SUBLANG_CHINESE_SIMPLIFIED 0x02 // Chinese (PR China) 0x0804 zh-CN +#define SUBLANG_CHINESE_HONGKONG 0x03 // Chinese (Hong Kong S.A.R., P.R.C.) 0x0c04 zh-HK +#define SUBLANG_CHINESE_SINGAPORE 0x04 // Chinese (Singapore) 0x1004 zh-SG +#define SUBLANG_CHINESE_MACAU 0x05 // Chinese (Macau S.A.R.) 0x1404 zh-MO +#define SUBLANG_CORSICAN_FRANCE 0x01 // Corsican (France) 0x0483 +#define SUBLANG_CZECH_CZECH_REPUBLIC 0x01 // Czech (Czech Republic) 0x0405 +#define SUBLANG_CROATIAN_CROATIA 0x01 // Croatian (Croatia) +#define SUBLANG_CROATIAN_BOSNIA_HERZEGOVINA_LATIN 0x04 // Croatian (Bosnia and Herzegovina - Latin) 0x101a hr-BA +#define SUBLANG_DANISH_DENMARK 0x01 // Danish (Denmark) 0x0406 +#define SUBLANG_DARI_AFGHANISTAN 0x01 // Dari (Afghanistan) +#define SUBLANG_DIVEHI_MALDIVES 0x01 // Divehi (Maldives) 0x0465 div-MV +#define SUBLANG_DUTCH 0x01 // Dutch +#define SUBLANG_DUTCH_BELGIAN 0x02 // Dutch (Belgian) +#define SUBLANG_ENGLISH_US 0x01 // English (USA) +#define SUBLANG_ENGLISH_UK 0x02 // English (UK) +#define SUBLANG_ENGLISH_AUS 0x03 // English (Australian) +#define SUBLANG_ENGLISH_CAN 0x04 // English (Canadian) +#define SUBLANG_ENGLISH_NZ 0x05 // English (New Zealand) +#define SUBLANG_ENGLISH_EIRE 0x06 // English (Irish) +#define SUBLANG_ENGLISH_SOUTH_AFRICA 0x07 // English (South Africa) +#define SUBLANG_ENGLISH_JAMAICA 0x08 // English (Jamaica) +#define SUBLANG_ENGLISH_CARIBBEAN 0x09 // English (Caribbean) +#define SUBLANG_ENGLISH_BELIZE 0x0a // English (Belize) +#define SUBLANG_ENGLISH_TRINIDAD 0x0b // English (Trinidad) +#define SUBLANG_ENGLISH_ZIMBABWE 0x0c // English (Zimbabwe) +#define SUBLANG_ENGLISH_PHILIPPINES 0x0d // English (Philippines) +#define SUBLANG_ENGLISH_INDIA 0x10 // English (India) +#define SUBLANG_ENGLISH_MALAYSIA 0x11 // English (Malaysia) +#define SUBLANG_ENGLISH_SINGAPORE 0x12 // English (Singapore) +#define SUBLANG_ESTONIAN_ESTONIA 0x01 // Estonian (Estonia) 0x0425 et-EE +#define SUBLANG_FAEROESE_FAROE_ISLANDS 0x01 // Faroese (Faroe Islands) 0x0438 fo-FO +#define SUBLANG_FILIPINO_PHILIPPINES 0x01 // Filipino (Philippines) 0x0464 fil-PH +#define SUBLANG_FINNISH_FINLAND 0x01 // Finnish (Finland) 0x040b +#define SUBLANG_FRENCH 0x01 // French +#define SUBLANG_FRENCH_BELGIAN 0x02 // French (Belgian) +#define SUBLANG_FRENCH_CANADIAN 0x03 // French (Canadian) +#define SUBLANG_FRENCH_SWISS 0x04 // French (Swiss) +#define SUBLANG_FRENCH_LUXEMBOURG 0x05 // French (Luxembourg) +#define SUBLANG_FRENCH_MONACO 0x06 // French (Monaco) +#define SUBLANG_FRISIAN_NETHERLANDS 0x01 // Frisian (Netherlands) 0x0462 fy-NL +#define SUBLANG_GALICIAN_GALICIAN 0x01 // Galician (Galician) 0x0456 gl-ES +#define SUBLANG_GEORGIAN_GEORGIA 0x01 // Georgian (Georgia) 0x0437 ka-GE +#define SUBLANG_GERMAN 0x01 // German +#define SUBLANG_GERMAN_SWISS 0x02 // German (Swiss) +#define SUBLANG_GERMAN_AUSTRIAN 0x03 // German (Austrian) +#define SUBLANG_GERMAN_LUXEMBOURG 0x04 // German (Luxembourg) +#define SUBLANG_GERMAN_LIECHTENSTEIN 0x05 // German (Liechtenstein) +#define SUBLANG_GREEK_GREECE 0x01 // Greek (Greece) +#define SUBLANG_GREENLANDIC_GREENLAND 0x01 // Greenlandic (Greenland) 0x046f kl-GL +#define SUBLANG_GUJARATI_INDIA 0x01 // Gujarati (India (Gujarati Script)) 0x0447 gu-IN +#define SUBLANG_HAUSA_NIGERIA_LATIN 0x01 // Hausa (Latin, Nigeria) 0x0468 ha-NG-Latn +#define SUBLANG_HEBREW_ISRAEL 0x01 // Hebrew (Israel) 0x040d +#define SUBLANG_HINDI_INDIA 0x01 // Hindi (India) 0x0439 hi-IN +#define SUBLANG_HUNGARIAN_HUNGARY 0x01 // Hungarian (Hungary) 0x040e +#define SUBLANG_ICELANDIC_ICELAND 0x01 // Icelandic (Iceland) 0x040f +#define SUBLANG_IGBO_NIGERIA 0x01 // Igbo (Nigeria) 0x0470 ig-NG +#define SUBLANG_INDONESIAN_INDONESIA 0x01 // Indonesian (Indonesia) 0x0421 id-ID +#define SUBLANG_INUKTITUT_CANADA 0x01 // Inuktitut (Syllabics) (Canada) 0x045d iu-CA-Cans +#define SUBLANG_INUKTITUT_CANADA_LATIN 0x02 // Inuktitut (Canada - Latin) +#define SUBLANG_IRISH_IRELAND 0x02 // Irish (Ireland) +#define SUBLANG_ITALIAN 0x01 // Italian +#define SUBLANG_ITALIAN_SWISS 0x02 // Italian (Swiss) +#define SUBLANG_JAPANESE_JAPAN 0x01 // Japanese (Japan) 0x0411 +#define SUBLANG_KANNADA_INDIA 0x01 // Kannada (India (Kannada Script)) 0x044b kn-IN +#define SUBLANG_KASHMIRI_SASIA 0x02 // Kashmiri (South Asia) +#define SUBLANG_KASHMIRI_INDIA 0x02 // For app compatibility only +#define SUBLANG_KAZAK_KAZAKHSTAN 0x01 // Kazakh (Kazakhstan) 0x043f kk-KZ +#define SUBLANG_KHMER_CAMBODIA 0x01 // Khmer (Cambodia) 0x0453 kh-KH +#define SUBLANG_KICHE_GUATEMALA 0x01 // K'iche (Guatemala) +#define SUBLANG_KINYARWANDA_RWANDA 0x01 // Kinyarwanda (Rwanda) 0x0487 rw-RW +#define SUBLANG_KONKANI_INDIA 0x01 // Konkani (India) 0x0457 kok-IN +#define SUBLANG_KOREAN 0x01 // Korean (Extended Wansung) +#define SUBLANG_KYRGYZ_KYRGYZSTAN 0x01 // Kyrgyz (Kyrgyzstan) 0x0440 ky-KG +#define SUBLANG_LAO_LAO 0x01 // Lao (Lao PDR) 0x0454 lo-LA +#define SUBLANG_LATVIAN_LATVIA 0x01 // Latvian (Latvia) 0x0426 lv-LV +#define SUBLANG_LITHUANIAN 0x01 // Lithuanian +#define SUBLANG_LOWER_SORBIAN_GERMANY 0x02 // Lower Sorbian (Germany) 0x082e wee-DE +#define SUBLANG_LUXEMBOURGISH_LUXEMBOURG 0x01 // Luxembourgish (Luxembourg) 0x046e lb-LU +#define SUBLANG_MACEDONIAN_MACEDONIA 0x01 // Macedonian (Macedonia (FYROM)) 0x042f mk-MK +#define SUBLANG_MALAY_MALAYSIA 0x01 // Malay (Malaysia) +#define SUBLANG_MALAY_BRUNEI_DARUSSALAM 0x02 // Malay (Brunei Darussalam) +#define SUBLANG_MALAYALAM_INDIA 0x01 // Malayalam (India (Malayalam Script) ) 0x044c ml-IN +#define SUBLANG_MALTESE_MALTA 0x01 // Maltese (Malta) 0x043a mt-MT +#define SUBLANG_MAORI_NEW_ZEALAND 0x01 // Maori (New Zealand) 0x0481 mi-NZ +#define SUBLANG_MAPUDUNGUN_CHILE 0x01 // Mapudungun (Chile) 0x047a arn-CL +#define SUBLANG_MARATHI_INDIA 0x01 // Marathi (India) 0x044e mr-IN +#define SUBLANG_MOHAWK_MOHAWK 0x01 // Mohawk (Mohawk) 0x047c moh-CA +#define SUBLANG_MONGOLIAN_CYRILLIC_MONGOLIA 0x01 // Mongolian (Cyrillic, Mongolia) +#define SUBLANG_MONGOLIAN_PRC 0x02 // Mongolian (PRC) +#define SUBLANG_NEPALI_INDIA 0x02 // Nepali (India) +#define SUBLANG_NEPALI_NEPAL 0x01 // Nepali (Nepal) 0x0461 ne-NP +#define SUBLANG_NORWEGIAN_BOKMAL 0x01 // Norwegian (Bokmal) +#define SUBLANG_NORWEGIAN_NYNORSK 0x02 // Norwegian (Nynorsk) +#define SUBLANG_OCCITAN_FRANCE 0x01 // Occitan (France) 0x0482 oc-FR +#define SUBLANG_ORIYA_INDIA 0x01 // Oriya (India (Oriya Script)) 0x0448 or-IN +#define SUBLANG_PASHTO_AFGHANISTAN 0x01 // Pashto (Afghanistan) +#define SUBLANG_PERSIAN_IRAN 0x01 // Persian (Iran) 0x0429 fa-IR +#define SUBLANG_POLISH_POLAND 0x01 // Polish (Poland) 0x0415 +#define SUBLANG_PORTUGUESE 0x02 // Portuguese +#define SUBLANG_PORTUGUESE_BRAZILIAN 0x01 // Portuguese (Brazilian) +#define SUBLANG_PUNJABI_INDIA 0x01 // Punjabi (India (Gurmukhi Script)) 0x0446 pa-IN +#define SUBLANG_QUECHUA_BOLIVIA 0x01 // Quechua (Bolivia) +#define SUBLANG_QUECHUA_ECUADOR 0x02 // Quechua (Ecuador) +#define SUBLANG_QUECHUA_PERU 0x03 // Quechua (Peru) +#define SUBLANG_ROMANIAN_ROMANIA 0x01 // Romanian (Romania) 0x0418 +#define SUBLANG_ROMANSH_SWITZERLAND 0x01 // Romansh (Switzerland) 0x0417 rm-CH +#define SUBLANG_RUSSIAN_RUSSIA 0x01 // Russian (Russia) 0x0419 +#define SUBLANG_SAMI_NORTHERN_NORWAY 0x01 // Northern Sami (Norway) +#define SUBLANG_SAMI_NORTHERN_SWEDEN 0x02 // Northern Sami (Sweden) +#define SUBLANG_SAMI_NORTHERN_FINLAND 0x03 // Northern Sami (Finland) +#define SUBLANG_SAMI_LULE_NORWAY 0x04 // Lule Sami (Norway) +#define SUBLANG_SAMI_LULE_SWEDEN 0x05 // Lule Sami (Sweden) +#define SUBLANG_SAMI_SOUTHERN_NORWAY 0x06 // Southern Sami (Norway) +#define SUBLANG_SAMI_SOUTHERN_SWEDEN 0x07 // Southern Sami (Sweden) +#define SUBLANG_SAMI_SKOLT_FINLAND 0x08 // Skolt Sami (Finland) +#define SUBLANG_SAMI_INARI_FINLAND 0x09 // Inari Sami (Finland) +#define SUBLANG_SANSKRIT_INDIA 0x01 // Sanskrit (India) 0x044f sa-IN +#define SUBLANG_SCOTTISH_GAELIC 0x01 // Scottish Gaelic (United Kingdom) 0x0491 gd-GB +#define SUBLANG_SERBIAN_BOSNIA_HERZEGOVINA_LATIN 0x06 // Serbian (Bosnia and Herzegovina - Latin) +#define SUBLANG_SERBIAN_BOSNIA_HERZEGOVINA_CYRILLIC 0x07 // Serbian (Bosnia and Herzegovina - Cyrillic) +#define SUBLANG_SERBIAN_MONTENEGRO_LATIN 0x0b // Serbian (Montenegro - Latn) +#define SUBLANG_SERBIAN_MONTENEGRO_CYRILLIC 0x0c // Serbian (Montenegro - Cyrillic) +#define SUBLANG_SERBIAN_SERBIA_LATIN 0x09 // Serbian (Serbia - Latin) +#define SUBLANG_SERBIAN_SERBIA_CYRILLIC 0x0a // Serbian (Serbia - Cyrillic) +#define SUBLANG_SERBIAN_CROATIA 0x01 // Croatian (Croatia) 0x041a hr-HR +#define SUBLANG_SERBIAN_LATIN 0x02 // Serbian (Latin) +#define SUBLANG_SERBIAN_CYRILLIC 0x03 // Serbian (Cyrillic) +#define SUBLANG_SINDHI_INDIA 0x01 // Sindhi (India) reserved 0x0459 +#define SUBLANG_SINDHI_PAKISTAN 0x02 // Sindhi (Pakistan) reserved 0x0859 +#define SUBLANG_SINDHI_AFGHANISTAN 0x02 // For app compatibility only +#define SUBLANG_SINHALESE_SRI_LANKA 0x01 // Sinhalese (Sri Lanka) +#define SUBLANG_SOTHO_NORTHERN_SOUTH_AFRICA 0x01 // Northern Sotho (South Africa) +#define SUBLANG_SLOVAK_SLOVAKIA 0x01 // Slovak (Slovakia) 0x041b sk-SK +#define SUBLANG_SLOVENIAN_SLOVENIA 0x01 // Slovenian (Slovenia) 0x0424 sl-SI +#define SUBLANG_SPANISH 0x01 // Spanish (Castilian) +#define SUBLANG_SPANISH_MEXICAN 0x02 // Spanish (Mexican) +#define SUBLANG_SPANISH_MODERN 0x03 // Spanish (Modern) +#define SUBLANG_SPANISH_GUATEMALA 0x04 // Spanish (Guatemala) +#define SUBLANG_SPANISH_COSTA_RICA 0x05 // Spanish (Costa Rica) +#define SUBLANG_SPANISH_PANAMA 0x06 // Spanish (Panama) +#define SUBLANG_SPANISH_DOMINICAN_REPUBLIC 0x07 // Spanish (Dominican Republic) +#define SUBLANG_SPANISH_VENEZUELA 0x08 // Spanish (Venezuela) +#define SUBLANG_SPANISH_COLOMBIA 0x09 // Spanish (Colombia) +#define SUBLANG_SPANISH_PERU 0x0a // Spanish (Peru) +#define SUBLANG_SPANISH_ARGENTINA 0x0b // Spanish (Argentina) +#define SUBLANG_SPANISH_ECUADOR 0x0c // Spanish (Ecuador) +#define SUBLANG_SPANISH_CHILE 0x0d // Spanish (Chile) +#define SUBLANG_SPANISH_URUGUAY 0x0e // Spanish (Uruguay) +#define SUBLANG_SPANISH_PARAGUAY 0x0f // Spanish (Paraguay) +#define SUBLANG_SPANISH_BOLIVIA 0x10 // Spanish (Bolivia) +#define SUBLANG_SPANISH_EL_SALVADOR 0x11 // Spanish (El Salvador) +#define SUBLANG_SPANISH_HONDURAS 0x12 // Spanish (Honduras) +#define SUBLANG_SPANISH_NICARAGUA 0x13 // Spanish (Nicaragua) +#define SUBLANG_SPANISH_PUERTO_RICO 0x14 // Spanish (Puerto Rico) +#define SUBLANG_SPANISH_US 0x15 // Spanish (United States) +#define SUBLANG_SWAHILI_KENYA 0x01 // Swahili (Kenya) 0x0441 sw-KE +#define SUBLANG_SWEDISH 0x01 // Swedish +#define SUBLANG_SWEDISH_FINLAND 0x02 // Swedish (Finland) +#define SUBLANG_SYRIAC_SYRIA 0x01 // Syriac (Syria) 0x045a syr-SY +#define SUBLANG_TAJIK_TAJIKISTAN 0x01 // Tajik (Tajikistan) 0x0428 tg-TJ-Cyrl +#define SUBLANG_TAMAZIGHT_ALGERIA_LATIN 0x02 // Tamazight (Latin, Algeria) 0x085f tmz-DZ-Latn +#define SUBLANG_TAMIL_INDIA 0x01 // Tamil (India) +#define SUBLANG_TATAR_RUSSIA 0x01 // Tatar (Russia) 0x0444 tt-RU +#define SUBLANG_TELUGU_INDIA 0x01 // Telugu (India (Telugu Script)) 0x044a te-IN +#define SUBLANG_THAI_THAILAND 0x01 // Thai (Thailand) 0x041e th-TH +#define SUBLANG_TIBETAN_PRC 0x01 // Tibetan (PRC) +#define SUBLANG_TIGRIGNA_ERITREA 0x02 // Tigrigna (Eritrea) +#define SUBLANG_TSWANA_SOUTH_AFRICA 0x01 // Setswana / Tswana (South Africa) 0x0432 tn-ZA +#define SUBLANG_TURKISH_TURKEY 0x01 // Turkish (Turkey) 0x041f tr-TR +#define SUBLANG_TURKMEN_TURKMENISTAN 0x01 // Turkmen (Turkmenistan) 0x0442 tk-TM +#define SUBLANG_UIGHUR_PRC 0x01 // Uighur (PRC) 0x0480 ug-CN +#define SUBLANG_UKRAINIAN_UKRAINE 0x01 // Ukrainian (Ukraine) 0x0422 uk-UA +#define SUBLANG_UPPER_SORBIAN_GERMANY 0x01 // Upper Sorbian (Germany) 0x042e wen-DE +#define SUBLANG_URDU_PAKISTAN 0x01 // Urdu (Pakistan) +#define SUBLANG_URDU_INDIA 0x02 // Urdu (India) +#define SUBLANG_UZBEK_LATIN 0x01 // Uzbek (Latin) +#define SUBLANG_UZBEK_CYRILLIC 0x02 // Uzbek (Cyrillic) +#define SUBLANG_VIETNAMESE_VIETNAM 0x01 // Vietnamese (Vietnam) 0x042a vi-VN +#define SUBLANG_WELSH_UNITED_KINGDOM 0x01 // Welsh (United Kingdom) 0x0452 cy-GB +#define SUBLANG_WOLOF_SENEGAL 0x01 // Wolof (Senegal) +#define SUBLANG_XHOSA_SOUTH_AFRICA 0x01 // isiXhosa / Xhosa (South Africa) 0x0434 xh-ZA +#define SUBLANG_YAKUT_RUSSIA 0x01 // Yakut (Russia) 0x0485 sah-RU +#define SUBLANG_YI_PRC 0x01 // Yi (PRC)) 0x0478 +#define SUBLANG_YORUBA_NIGERIA 0x01 // Yoruba (Nigeria) 046a yo-NG +#define SUBLANG_ZULU_SOUTH_AFRICA 0x01 // isiZulu / Zulu (South Africa) 0x0435 zu-ZA + + + + +// +// Sorting IDs. +// +// Note that the named locale APIs (eg CompareStringExEx) are recommended. +// + +#define SORT_DEFAULT 0x0 // sorting default + +#define SORT_INVARIANT_MATH 0x1 // Invariant (Mathematical Symbols) + +#define SORT_JAPANESE_XJIS 0x0 // Japanese XJIS order +#define SORT_JAPANESE_UNICODE 0x1 // Japanese Unicode order (no longer supported) +#define SORT_JAPANESE_RADICALSTROKE 0x4 // Japanese radical/stroke order + +#define SORT_CHINESE_BIG5 0x0 // Chinese BIG5 order +#define SORT_CHINESE_PRCP 0x0 // PRC Chinese Phonetic order +#define SORT_CHINESE_UNICODE 0x1 // Chinese Unicode order (no longer supported) +#define SORT_CHINESE_PRC 0x2 // PRC Chinese Stroke Count order +#define SORT_CHINESE_BOPOMOFO 0x3 // Traditional Chinese Bopomofo order +#define SORT_CHINESE_RADICALSTROKE 0x4 // Traditional Chinese radical/stroke order. + +#define SORT_KOREAN_KSC 0x0 // Korean KSC order +#define SORT_KOREAN_UNICODE 0x1 // Korean Unicode order (no longer supported) + +#define SORT_GERMAN_PHONE_BOOK 0x1 // German Phone Book order + +#define SORT_HUNGARIAN_DEFAULT 0x0 // Hungarian Default order +#define SORT_HUNGARIAN_TECHNICAL 0x1 // Hungarian Technical order + +#define SORT_GEORGIAN_TRADITIONAL 0x0 // Georgian Traditional order +#define SORT_GEORGIAN_MODERN 0x1 // Georgian Modern order + +// end_r_winnt + +// +// A language ID is a 16 bit value which is the combination of a +// primary language ID and a secondary language ID. The bits are +// allocated as follows: +// +// +-----------------------+-------------------------+ +// | Sublanguage ID | Primary Language ID | +// +-----------------------+-------------------------+ +// 15 10 9 0 bit +// +// WARNING: This pattern isn't always follows, Serbina, Bosnian & Croation +// for example. +// +// It is recommended that applications test for locale names or actual LCIDs. +// +// Language ID creation/extraction macros: +// +// MAKELANGID - construct language id from a primary language id and +// a sublanguage id. +// PRIMARYLANGID - extract primary language id from a language id. +// SUBLANGID - extract sublanguage id from a language id. +// +// Note that the LANG, SUBLANG construction is not always consistent. +// The named locale APIs (eg GetLocaleInfoEx) are recommended. +// +// Language IDs do not exist for all locales +// +#define MAKELANGID(p, s) ((((WORD )(s)) << 10) | (WORD )(p)) +#define PRIMARYLANGID(lgid) ((WORD )(lgid) & 0x3ff) +#define SUBLANGID(lgid) ((WORD )(lgid) >> 10) + + +// +// A locale ID is a 32 bit value which is the combination of a +// language ID, a sort ID, and a reserved area. The bits are +// allocated as follows: +// +// +-------------+---------+-------------------------+ +// | Reserved | Sort ID | Language ID | +// +-------------+---------+-------------------------+ +// 31 20 19 16 15 0 bit +// +// WARNING: This pattern isn't always followed (es-ES_tradnl vs es-ES for example) +// +// It is recommended that applications test for locale names or actual LCIDs. +// +// Locale ID creation/extraction macros: +// +// MAKELCID - construct the locale id from a language id and a sort id. +// MAKESORTLCID - construct the locale id from a language id, sort id, and sort version. +// LANGIDFROMLCID - extract the language id from a locale id. +// SORTIDFROMLCID - extract the sort id from a locale id. +// SORTVERSIONFROMLCID - extract the sort version from a locale id. +// +// Note that the LANG, SUBLANG construction is not always consistent. +// The named locale APIs (eg GetLocaleInfoEx) are recommended. +// +// LCIDs do not exist for all locales. +// +#define NLS_VALID_LOCALE_MASK 0x000fffff + +#define MAKELCID(lgid, srtid) ((DWORD)((((DWORD)((WORD )(srtid))) << 16) | ((DWORD)((WORD )(lgid))))) + +#define MAKESORTLCID(lgid, srtid, ver) ((DWORD)((MAKELCID(lgid, srtid)) | (((DWORD)((WORD )(ver))) << 20))) + + +#define LANGIDFROMLCID(lcid) ((WORD )(lcid)) +#define SORTIDFROMLCID(lcid) ((WORD )((((DWORD)(lcid)) >> 16) & 0xf)) +#define SORTVERSIONFROMLCID(lcid) ((WORD )((((DWORD)(lcid)) >> 20) & 0xf)) + +// 8 characters for language +// 8 characters for region +// 64 characters for suffix (script) +// 2 characters for '-' separators +// 2 characters for prefix like "i-" or "x-" +// 1 null termination +#define LOCALE_NAME_MAX_LENGTH 85 + +// +// Default System and User IDs for language and locale. +// Locale names such as LOCALE_NAME_SYSTEM_DEFAULT, LOCALE_NAME_USER_DEFAULT, +// and LOCALE_NAME_INVARIANT are preferred. +// + +#define LANG_SYSTEM_DEFAULT (MAKELANGID(LANG_NEUTRAL, SUBLANG_SYS_DEFAULT)) +#define LANG_USER_DEFAULT (MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT)) + +#define LOCALE_SYSTEM_DEFAULT (MAKELCID(LANG_SYSTEM_DEFAULT, SORT_DEFAULT)) +#define LOCALE_USER_DEFAULT (MAKELCID(LANG_USER_DEFAULT, SORT_DEFAULT)) + +// +// Other special IDs for language and locale. +// +#define LOCALE_CUSTOM_DEFAULT (MAKELCID(MAKELANGID(LANG_NEUTRAL, SUBLANG_CUSTOM_DEFAULT), SORT_DEFAULT)) + + +#define LOCALE_CUSTOM_UNSPECIFIED (MAKELCID(MAKELANGID(LANG_NEUTRAL, SUBLANG_CUSTOM_UNSPECIFIED), SORT_DEFAULT)) + + +#define LOCALE_CUSTOM_UI_DEFAULT (MAKELCID(MAKELANGID(LANG_NEUTRAL, SUBLANG_UI_CUSTOM_DEFAULT), SORT_DEFAULT)) + + +#define LOCALE_NEUTRAL (MAKELCID(MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), SORT_DEFAULT)) + + +#define LOCALE_INVARIANT (MAKELCID(MAKELANGID(LANG_INVARIANT, SUBLANG_NEUTRAL), SORT_DEFAULT)) + + +// begin_ntminiport begin_ntndis begin_ntminitape + +// +// Macros used to eliminate compiler warning generated when formal +// parameters or local variables are not declared. +// +// Use DBG_UNREFERENCED_PARAMETER() when a parameter is not yet +// referenced but will be once the module is completely developed. +// +// Use DBG_UNREFERENCED_LOCAL_VARIABLE() when a local variable is not yet +// referenced but will be once the module is completely developed. +// +// Use UNREFERENCED_PARAMETER() if a parameter will never be referenced. +// +// DBG_UNREFERENCED_PARAMETER and DBG_UNREFERENCED_LOCAL_VARIABLE will +// eventually be made into a null macro to help determine whether there +// is unfinished work. +// + + +#define UNREFERENCED_PARAMETER(P) (P) +#define DBG_UNREFERENCED_PARAMETER(P) (P) +#define DBG_UNREFERENCED_LOCAL_VARIABLE(V) (V) + + + + + + + +#define UNREFERENCED_PARAMETER(P) { (P) = (P); } + + + + + +#define DBG_UNREFERENCED_PARAMETER(P) { (P) = (P); } + + + + + +#define DBG_UNREFERENCED_LOCAL_VARIABLE(V) { (V) = (V); } + + + + + + + + +// +// Macro used to eliminate compiler warning 4715 within a switch statement +// when all possible cases have already been accounted for. +// +// switch (a & 3) { +// case 0: return 1; +// case 1: return Foo(); +// case 2: return Bar(); +// case 3: return 1; +// DEFAULT_UNREACHABLE; +// + + +#define DEFAULT_UNREACHABLE default: __assume(0) + + + + + + + +#define DEFAULT_UNREACHABLE + + + + + +// Define operator overloads to enable bit operations on enum values that are +// used to define flags. Use DEFINE_ENUM_FLAG_OPERATORS(YOUR_TYPE) to enable these +// operators on YOUR_TYPE. + +// Moved here from objbase.w. + +#define DEFINE_ENUM_FLAG_OPERATORS(ENUMTYPE) extern "C++" { inline ENUMTYPE operator | (ENUMTYPE a, ENUMTYPE b) { return ENUMTYPE(((int)a) | ((int)b)); } inline ENUMTYPE &operator |= (ENUMTYPE &a, ENUMTYPE b) { return (ENUMTYPE &)(((int &)a) |= ((int)b)); } inline ENUMTYPE operator & (ENUMTYPE a, ENUMTYPE b) { return ENUMTYPE(((int)a) & ((int)b)); } inline ENUMTYPE &operator &= (ENUMTYPE &a, ENUMTYPE b) { return (ENUMTYPE &)(((int &)a) &= ((int)b)); } inline ENUMTYPE operator ~ (ENUMTYPE a) { return ENUMTYPE(~((int)a)); } inline ENUMTYPE operator ^ (ENUMTYPE a, ENUMTYPE b) { return ENUMTYPE(((int)a) ^ ((int)b)); } inline ENUMTYPE &operator ^= (ENUMTYPE &a, ENUMTYPE b) { return (ENUMTYPE &)(((int &)a) ^= ((int)b)); } } + + + + + + + + + + +#define DEFINE_ENUM_FLAG_OPERATORS(ENUMTYPE) // NOP, C allows these operators. + + +// Compile-time macros for initializing flag values in const data. +// +// When using DEFINE_ENUM_FLAG_OPERATORS for enum values you should use the macros below +// when you need to initialize global const data. Without these macros the inline operators +// from DEFINE_ENUM_FLAG_OPERATORS force a runtime initialization rather than a +// compile time initialization. This applies even if you have declared the data as const. +#define COMPILETIME_OR_2FLAGS(a,b) ((UINT)(a)|(UINT)(b)) +#define COMPILETIME_OR_3FLAGS(a,b,c) ((UINT)(a)|(UINT)(b)|(UINT)(c)) +#define COMPILETIME_OR_4FLAGS(a,b,c,d) ((UINT)(a)|(UINT)(b)|(UINT)(c)|(UINT)(d)) +#define COMPILETIME_OR_5FLAGS(a,b,c,d,e) ((UINT)(a)|(UINT)(b)|(UINT)(c)|(UINT)(d)|(UINT)(e)) + + + +#define STATUS_WAIT_0 ((DWORD )0x00000000L) +#define STATUS_ABANDONED_WAIT_0 ((DWORD )0x00000080L) +#define STATUS_USER_APC ((DWORD )0x000000C0L) +#define STATUS_TIMEOUT ((DWORD )0x00000102L) +#define STATUS_PENDING ((DWORD )0x00000103L) +#define DBG_EXCEPTION_HANDLED ((DWORD )0x00010001L) +#define DBG_CONTINUE ((DWORD )0x00010002L) +#define STATUS_SEGMENT_NOTIFICATION ((DWORD )0x40000005L) +#define DBG_TERMINATE_THREAD ((DWORD )0x40010003L) +#define DBG_TERMINATE_PROCESS ((DWORD )0x40010004L) +#define DBG_CONTROL_C ((DWORD )0x40010005L) +#define DBG_PRINTEXCEPTION_C ((DWORD )0x40010006L) +#define DBG_RIPEXCEPTION ((DWORD )0x40010007L) +#define DBG_CONTROL_BREAK ((DWORD )0x40010008L) +#define DBG_COMMAND_EXCEPTION ((DWORD )0x40010009L) +#define STATUS_GUARD_PAGE_VIOLATION ((DWORD )0x80000001L) +#define STATUS_DATATYPE_MISALIGNMENT ((DWORD )0x80000002L) +#define STATUS_BREAKPOINT ((DWORD )0x80000003L) +#define STATUS_SINGLE_STEP ((DWORD )0x80000004L) +#define STATUS_LONGJUMP ((DWORD )0x80000026L) +#define STATUS_UNWIND_CONSOLIDATE ((DWORD )0x80000029L) +#define DBG_EXCEPTION_NOT_HANDLED ((DWORD )0x80010001L) +#define STATUS_ACCESS_VIOLATION ((DWORD )0xC0000005L) +#define STATUS_IN_PAGE_ERROR ((DWORD )0xC0000006L) +#define STATUS_INVALID_HANDLE ((DWORD )0xC0000008L) +#define STATUS_INVALID_PARAMETER ((DWORD )0xC000000DL) +#define STATUS_NO_MEMORY ((DWORD )0xC0000017L) +#define STATUS_ILLEGAL_INSTRUCTION ((DWORD )0xC000001DL) +#define STATUS_NONCONTINUABLE_EXCEPTION ((DWORD )0xC0000025L) +#define STATUS_INVALID_DISPOSITION ((DWORD )0xC0000026L) +#define STATUS_ARRAY_BOUNDS_EXCEEDED ((DWORD )0xC000008CL) +#define STATUS_FLOAT_DENORMAL_OPERAND ((DWORD )0xC000008DL) +#define STATUS_FLOAT_DIVIDE_BY_ZERO ((DWORD )0xC000008EL) +#define STATUS_FLOAT_INEXACT_RESULT ((DWORD )0xC000008FL) +#define STATUS_FLOAT_INVALID_OPERATION ((DWORD )0xC0000090L) +#define STATUS_FLOAT_OVERFLOW ((DWORD )0xC0000091L) +#define STATUS_FLOAT_STACK_CHECK ((DWORD )0xC0000092L) +#define STATUS_FLOAT_UNDERFLOW ((DWORD )0xC0000093L) +#define STATUS_INTEGER_DIVIDE_BY_ZERO ((DWORD )0xC0000094L) +#define STATUS_INTEGER_OVERFLOW ((DWORD )0xC0000095L) +#define STATUS_PRIVILEGED_INSTRUCTION ((DWORD )0xC0000096L) +#define STATUS_STACK_OVERFLOW ((DWORD )0xC00000FDL) +#define STATUS_DLL_NOT_FOUND ((DWORD )0xC0000135L) +#define STATUS_ORDINAL_NOT_FOUND ((DWORD )0xC0000138L) +#define STATUS_ENTRYPOINT_NOT_FOUND ((DWORD )0xC0000139L) +#define STATUS_CONTROL_C_EXIT ((DWORD )0xC000013AL) +#define STATUS_DLL_INIT_FAILED ((DWORD )0xC0000142L) +#define STATUS_FLOAT_MULTIPLE_FAULTS ((DWORD )0xC00002B4L) +#define STATUS_FLOAT_MULTIPLE_TRAPS ((DWORD )0xC00002B5L) +#define STATUS_REG_NAT_CONSUMPTION ((DWORD )0xC00002C9L) +#define STATUS_STACK_BUFFER_OVERRUN ((DWORD )0xC0000409L) +#define STATUS_INVALID_CRUNTIME_PARAMETER ((DWORD )0xC0000417L) +#define STATUS_ASSERTION_FAILURE ((DWORD )0xC0000420L) + +#define STATUS_SXS_EARLY_DEACTIVATION ((DWORD )0xC015000FL) +#define STATUS_SXS_INVALID_DEACTIVATION ((DWORD )0xC0150010L) + + + +#define MAXIMUM_WAIT_OBJECTS 64 // Maximum number of wait objects + +#define MAXIMUM_SUSPEND_COUNT MAXCHAR // Maximum times thread can be suspended + +typedef ULONG_PTR KSPIN_LOCK; +typedef KSPIN_LOCK *PKSPIN_LOCK; + + +// +// Define 128-bit 16-byte aligned xmm register type. +// + +typedef struct _M128A { + ULONGLONG Low; + LONGLONG High; +} M128A, *PM128A; + +// +// Format of data for (F)XSAVE/(F)XRSTOR instruction +// + +typedef struct _XSAVE_FORMAT { + WORD ControlWord; + WORD StatusWord; + BYTE TagWord; + BYTE Reserved1; + WORD ErrorOpcode; + DWORD ErrorOffset; + WORD ErrorSelector; + WORD Reserved2; + DWORD DataOffset; + WORD DataSelector; + WORD Reserved3; + DWORD MxCsr; + DWORD MxCsr_Mask; + M128A FloatRegisters[8]; + + + + M128A XmmRegisters[16]; + BYTE Reserved4[96]; + + + + + + + + + + + + + + + + + +} XSAVE_FORMAT, *PXSAVE_FORMAT; + +typedef struct _XSAVE_AREA_HEADER { + DWORD64 Mask; + DWORD64 Reserved[7]; +} XSAVE_AREA_HEADER, *PXSAVE_AREA_HEADER; + +typedef struct _XSAVE_AREA { + XSAVE_FORMAT LegacyState; + XSAVE_AREA_HEADER Header; +} XSAVE_AREA, *PXSAVE_AREA; + +typedef struct _XSTATE_CONTEXT { + DWORD64 Mask; + DWORD Length; + DWORD Reserved1; + [OnFieldOnly] PXSAVE_AREA Area; + + + DWORD Reserved2; + + + PVOID Buffer; + + + DWORD Reserved3; + + +} XSTATE_CONTEXT, *PXSTATE_CONTEXT; + + +#define XSAVE_ALIGN 64 +#define MINIMAL_XSTATE_AREA_LENGTH sizeof(XSAVE_AREA) + + +// +// This structure specifies an offset (from the beginning of CONTEXT_EX +// structure) and size of a single chunk of an extended context structure. +// +// N.B. Offset may be negative. +// + +typedef struct _CONTEXT_CHUNK { + LONG Offset; + DWORD Length; +} CONTEXT_CHUNK, *PCONTEXT_CHUNK; + +// +// CONTEXT_EX structure is an extension to CONTEXT structure. It defines +// a context record as a set of disjoint variable-sized buffers (chunks) +// each containing a portion of processor state. Currently there are only +// two buffers (chunks) are defined: +// +// - Legacy, that stores traditional CONTEXT structure; +// - XState, that stores XSAVE save area buffer starting from +// XSAVE_AREA_HEADER, i.e. without the first 512 bytes. +// +// There a few assumptions exists that simplify conversion of PCONTEXT +// pointer to PCONTEXT_EX pointer. +// +// 1. APIs that work with PCONTEXT pointers assume that CONTEXT_EX is +// stored right after the CONTEXT structure. It is also assumed that +// CONTEXT_EX is present if and only if corresponding CONTEXT_XXX +// flags are set in CONTEXT.ContextFlags. +// +// 2. CONTEXT_EX.Legacy is always present if CONTEXT_EX structure is +// present. All other chunks are optional. +// +// 3. CONTEXT.ContextFlags unambigiously define which chunks are +// present. I.e. if CONTEXT_XSTATE is set CONTEXT_EX.XState is valid. +// + +typedef struct _CONTEXT_EX { + + // + // The total length of the structure starting from the chunk with + // the smallest offset. N.B. that the offset may be negative. + // + + CONTEXT_CHUNK All; + + // + // Wrapper for the traditional CONTEXT structure. N.B. the size of + // the chunk may be less than sizeof(CONTEXT) is some cases (when + // CONTEXT_EXTENDED_REGISTERS is not set on x86 for instance). + // + + CONTEXT_CHUNK Legacy; + + // + // CONTEXT_XSTATE: Extended processor state chunk. The state is + // stored in the same format XSAVE operation strores it with + // exception of the first 512 bytes, i.e. staring from + // XSAVE_AREA_HEADER. The lower two bits corresponding FP and + // SSE state must be zero. + // + + CONTEXT_CHUNK XState; + +} CONTEXT_EX, *PCONTEXT_EX; + +#define CONTEXT_EX_LENGTH ALIGN_UP_BY(sizeof(CONTEXT_EX), STACK_ALIGN) + +// +// These macros make context chunks manupulations easier. +// + +#define RTL_CONTEXT_EX_OFFSET(ContextEx, Chunk) ((ContextEx)->Chunk.Offset) + + +#define RTL_CONTEXT_EX_LENGTH(ContextEx, Chunk) ((ContextEx)->Chunk.Length) + + +#define RTL_CONTEXT_EX_CHUNK(Base, Layout, Chunk) ((PVOID)((PCHAR)(Base) + RTL_CONTEXT_EX_OFFSET(Layout, Chunk))) + + +#define RTL_CONTEXT_OFFSET(Context, Chunk) RTL_CONTEXT_EX_OFFSET((PCONTEXT_EX)(Context + 1), Chunk) + + +#define RTL_CONTEXT_LENGTH(Context, Chunk) RTL_CONTEXT_EX_LENGTH((PCONTEXT_EX)(Context + 1), Chunk) + + +#define RTL_CONTEXT_CHUNK(Context, Chunk) RTL_CONTEXT_EX_CHUNK((PCONTEXT_EX)(Context + 1), (PCONTEXT_EX)(Context + 1), Chunk) + + + + + + + +// +// XSAVE/XRSTOR save area should be aligned on 64 byte boundary +// + +; +; + +// XSAVE_AREA structure must be sized uniformly on all architectures +; + + + + + + + + + +// +// Define bit test intrinsics. +// + + +extern "C" { + + +#define BitTest _bittest +#define BitTestAndComplement _bittestandcomplement +#define BitTestAndSet _bittestandset +#define BitTestAndReset _bittestandreset +#define InterlockedBitTestAndSet _interlockedbittestandset +#define InterlockedBitTestAndReset _interlockedbittestandreset + +#define BitTest64 _bittest64 +#define BitTestAndComplement64 _bittestandcomplement64 +#define BitTestAndSet64 _bittestandset64 +#define BitTestAndReset64 _bittestandreset64 +#define InterlockedBitTestAndSet64 _interlockedbittestandset64 +#define InterlockedBitTestAndReset64 _interlockedbittestandreset64 + + [method: OnFunctionOnly] +BOOLEAN +_bittest ( + [OnParameterOnly] LONG const *Base, + [OnParameterOnly] LONG Offset + ); + +BOOLEAN +_bittestandcomplement ( + [OnParameterOnly] LONG *Base, + [OnParameterOnly] LONG Offset + ); + +BOOLEAN +_bittestandset ( + [OnParameterOnly] LONG *Base, + [OnParameterOnly] LONG Offset + ); + +BOOLEAN +_bittestandreset ( + [OnParameterOnly] LONG *Base, + [OnParameterOnly] LONG Offset + ); + +BOOLEAN +_interlockedbittestandset ( + [OnParameterOnly] LONG volatile *Base, + [OnParameterOnly] LONG Offset + ); + +BOOLEAN +_interlockedbittestandreset ( + [OnParameterOnly] LONG volatile *Base, + [OnParameterOnly] LONG Offset + ); + +BOOLEAN +_bittest64 ( + [OnParameterOnly] LONG64 const *Base, + [OnParameterOnly] LONG64 Offset + ); + +BOOLEAN +_bittestandcomplement64 ( + [OnParameterOnly] LONG64 *Base, + [OnParameterOnly] LONG64 Offset + ); + +BOOLEAN +_bittestandset64 ( + [OnParameterOnly] LONG64 *Base, + [OnParameterOnly] LONG64 Offset + ); + +BOOLEAN +_bittestandreset64 ( + [OnParameterOnly] LONG64 *Base, + [OnParameterOnly] LONG64 Offset + ); + +BOOLEAN +_interlockedbittestandset64 ( + [OnParameterOnly] LONG64 volatile *Base, + [OnParameterOnly] LONG64 Offset + ); + +BOOLEAN +_interlockedbittestandreset64 ( + [OnParameterOnly] LONG64 volatile *Base, + [OnParameterOnly] LONG64 Offset + ); + + + + + + + + + + + + + + + +// +// Define bit scan intrinsics. +// + +#define BitScanForward _BitScanForward +#define BitScanReverse _BitScanReverse +#define BitScanForward64 _BitScanForward64 +#define BitScanReverse64 _BitScanReverse64 + + +BOOLEAN +_BitScanForward ( + [OnParameterOnly] DWORD *Index, + [OnParameterOnly] DWORD Mask + ); + + +BOOLEAN +_BitScanReverse ( + [OnParameterOnly] DWORD *Index, + [OnParameterOnly] DWORD Mask + ); + + +BOOLEAN +_BitScanForward64 ( + [OnParameterOnly] DWORD *Index, + [OnParameterOnly] DWORD64 Mask + ); + + +BOOLEAN +_BitScanReverse64 ( + [OnParameterOnly] DWORD *Index, + [OnParameterOnly] DWORD64 Mask + ); + + + + + + +// +// Interlocked intrinsic functions. +// + +#define InterlockedIncrement16 _InterlockedIncrement16 +#define InterlockedDecrement16 _InterlockedDecrement16 +#define InterlockedCompareExchange16 _InterlockedCompareExchange16 + +#define InterlockedAnd _InterlockedAnd +#define InterlockedAndAcquire _InterlockedAnd +#define InterlockedAndRelease _InterlockedAnd +#define InterlockedOr _InterlockedOr +#define InterlockedOrAcquire _InterlockedOr +#define InterlockedOrRelease _InterlockedOr +#define InterlockedXor _InterlockedXor +#define InterlockedIncrement _InterlockedIncrement +#define InterlockedIncrementAcquire InterlockedIncrement +#define InterlockedIncrementRelease InterlockedIncrement +#define InterlockedDecrement _InterlockedDecrement +#define InterlockedDecrementAcquire InterlockedDecrement +#define InterlockedDecrementRelease InterlockedDecrement +#define InterlockedAdd _InterlockedAdd +#define InterlockedExchange _InterlockedExchange +#define InterlockedExchangeAdd _InterlockedExchangeAdd +#define InterlockedCompareExchange _InterlockedCompareExchange +#define InterlockedCompareExchangeAcquire InterlockedCompareExchange +#define InterlockedCompareExchangeRelease InterlockedCompareExchange + +#define InterlockedAnd64 _InterlockedAnd64 +#define InterlockedAnd64Acquire _InterlockedAnd64 +#define InterlockedAnd64Release _InterlockedAnd64 +#define InterlockedAndAffinity InterlockedAnd64 +#define InterlockedOr64 _InterlockedOr64 +#define InterlockedOr64Acquire _InterlockedOr64 +#define InterlockedOr64Release _InterlockedOr64 +#define InterlockedOrAffinity InterlockedOr64 +#define InterlockedXor64 _InterlockedXor64 +#define InterlockedIncrement64 _InterlockedIncrement64 +#define InterlockedDecrement64 _InterlockedDecrement64 +#define InterlockedAdd64 _InterlockedAdd64 +#define InterlockedExchange64 _InterlockedExchange64 +#define InterlockedExchangeAcquire64 InterlockedExchange64 +#define InterlockedExchangeAdd64 _InterlockedExchangeAdd64 +#define InterlockedCompareExchange64 _InterlockedCompareExchange64 +#define InterlockedCompareExchangeAcquire64 InterlockedCompareExchange64 +#define InterlockedCompareExchangeRelease64 InterlockedCompareExchange64 + +#define InterlockedExchangePointer _InterlockedExchangePointer +#define InterlockedCompareExchangePointer _InterlockedCompareExchangePointer +#define InterlockedCompareExchangePointerAcquire _InterlockedCompareExchangePointer +#define InterlockedCompareExchangePointerRelease _InterlockedCompareExchangePointer + +#define InterlockedExchangeAddSizeT(a, b) InterlockedExchangeAdd64((LONG64 *)a, b) +#define InterlockedIncrementSizeT(a) InterlockedIncrement64((LONG64 *)a) +#define InterlockedDecrementSizeT(a) InterlockedDecrement64((LONG64 *)a) + +SHORT + _InterlockedIncrement16 ( + [OnParameterOnly] SHORT volatile *Addend + ); + +SHORT + _InterlockedDecrement16 ( + [OnParameterOnly] SHORT volatile *Addend + ); + +SHORT + _InterlockedCompareExchange16 ( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT ExChange, + [OnParameterOnly] SHORT Comperand + ); + +LONG + _InterlockedAnd ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG Value + ); + +LONG + _InterlockedOr ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG Value + ); + +LONG + _InterlockedXor ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG Value + ); + +LONG64 + _InterlockedAnd64 ( + [OnParameterOnly] LONG64 volatile *Destination, + [OnParameterOnly] LONG64 Value + ); + +LONG64 + _InterlockedOr64 ( + [OnParameterOnly] LONG64 volatile *Destination, + [OnParameterOnly] LONG64 Value + ); + +LONG64 + _InterlockedXor64 ( + [OnParameterOnly] LONG64 volatile *Destination, + [OnParameterOnly] LONG64 Value + ); + +LONG + _InterlockedIncrement( + [OnParameterOnly] LONG volatile *Addend + ); + +LONG + _InterlockedDecrement( + [OnParameterOnly] LONG volatile *Addend + ); + +LONG + _InterlockedExchange( + [OnParameterOnly] LONG volatile *Target, + [OnParameterOnly] LONG Value + ); + +LONG + _InterlockedExchangeAdd( + [OnParameterOnly] LONG volatile *Addend, + [OnParameterOnly] LONG Value + ); + + + + +LONG + _InterlockedAdd( + [OnParameterOnly] LONG volatile *Addend, + [OnParameterOnly] LONG Value + ) + +{ + return _InterlockedExchangeAdd(Addend, Value) + Value; +} + + + +LONG + _InterlockedCompareExchange ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG ExChange, + [OnParameterOnly] LONG Comperand + ); + +LONG64 + _InterlockedIncrement64( + [OnParameterOnly] LONG64 volatile *Addend + ); + +LONG64 + _InterlockedDecrement64( + [OnParameterOnly] LONG64 volatile *Addend + ); + +LONG64 + _InterlockedExchange64( + [OnParameterOnly] LONG64 volatile *Target, + [OnParameterOnly] LONG64 Value + ); + +LONG64 + _InterlockedExchangeAdd64( + [OnParameterOnly] LONG64 volatile *Addend, + [OnParameterOnly] LONG64 Value + ); + + + + +LONG64 + _InterlockedAdd64( + [OnParameterOnly] LONG64 volatile *Addend, + [OnParameterOnly] LONG64 Value + ) + +{ + return _InterlockedExchangeAdd64(Addend, Value) + Value; +} + + + +LONG64 + _InterlockedCompareExchange64 ( + [OnParameterOnly] LONG64 volatile *Destination, + [OnParameterOnly] LONG64 ExChange, + [OnParameterOnly] LONG64 Comperand + ); + +PVOID + _InterlockedCompareExchangePointer ( + [OnParameterOnly] PVOID volatile *Destination, + [OnParameterOnly] PVOID Exchange, + [OnParameterOnly] PVOID Comperand + ); + +PVOID + _InterlockedExchangePointer( + [OnParameterOnly] PVOID volatile *Target, + [OnParameterOnly] PVOID Value + ); + + + + + + + + + + + + + + + + + + + + + + + + + +#define InterlockedAnd8 _InterlockedAnd8 +#define InterlockedOr8 _InterlockedOr8 +#define InterlockedXor8 _InterlockedXor8 +#define InterlockedAnd16 _InterlockedAnd16 +#define InterlockedOr16 _InterlockedOr16 +#define InterlockedXor16 _InterlockedXor16 + +char + _InterlockedAnd8 ( + [OnParameterOnly] char volatile *Destination, + [OnParameterOnly] char Value + ); + +char + _InterlockedOr8 ( + [OnParameterOnly] char volatile *Destination, + [OnParameterOnly] char Value + ); + +char + _InterlockedXor8 ( + [OnParameterOnly] char volatile *Destination, + [OnParameterOnly] char Value + ); + +SHORT + _InterlockedAnd16( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT Value + ); + +SHORT + _InterlockedOr16( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT Value + ); + +SHORT + _InterlockedXor16( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT Value + ); + + + + + + + + + + +// +// Define function to flush a cache line. +// + +#define CacheLineFlush(Address) _mm_clflush(Address) + + void +_mm_clflush ( + [OnParameterOnly] void const *Address + ); + + + + void +_ReadWriteBarrier ( + void + ); + + + +// +// Define memory fence intrinsics +// + +#define FastFence __faststorefence +#define LoadFence _mm_lfence +#define MemoryFence _mm_mfence +#define StoreFence _mm_sfence + + void +__faststorefence ( + void + ); + + void +_mm_lfence ( + void + ); + + void +_mm_mfence ( + void + ); + + void +_mm_sfence ( + void + ); + + void +_mm_pause ( + void + ); + + void +_mm_prefetch ( + [OnParameterOnly] CHAR const *a, + [OnParameterOnly] int sel + ); + + void +_m_prefetchw ( + [OnParameterOnly] volatile const void *Source + ); + +// +// Define constants for use with _mm_prefetch. +// + +#define _MM_HINT_T0 1 +#define _MM_HINT_T1 2 +#define _MM_HINT_T2 3 +#define _MM_HINT_NTA 0 + + + + + + + + + +#define YieldProcessor _mm_pause +#define MemoryBarrier __faststorefence +#define PreFetchCacheLine(l, a) _mm_prefetch((CHAR CONST *) a, l) +#define PrefetchForWrite(p) _m_prefetchw(p) +#define ReadForWriteAccess(p) (_m_prefetchw(p), *(p)) + +// +// PreFetchCacheLine level defines. +// + +#define PF_TEMPORAL_LEVEL_1 _MM_HINT_T0 +#define PF_TEMPORAL_LEVEL_2 _MM_HINT_T1 +#define PF_TEMPORAL_LEVEL_3 _MM_HINT_T2 +#define PF_NON_TEMPORAL_LEVEL_ALL _MM_HINT_NTA + +// +// Define get/set MXCSR intrinsics. +// + +#define ReadMxCsr _mm_getcsr +#define WriteMxCsr _mm_setcsr + +unsigned int +_mm_getcsr ( + void + ); + + void +_mm_setcsr ( + [OnParameterOnly] unsigned int MxCsr + ); + + + + +// +// Assert exception. +// + + void +__int2c ( + void + ); + + + + + __inline + void +DbgRaiseAssertionFailure ( + void + ) + +{ + __int2c(); +} + +// +// Define function to get the caller's EFLAGs value. +// + +#define GetCallersEflags() __getcallerseflags() + +unsigned __int32 +__getcallerseflags ( + void + ); + + + +// +// Define function to get segment limit. +// + +#define GetSegmentLimit __segmentlimit + +DWORD +__segmentlimit ( + [OnParameterOnly] DWORD Selector + ); + + + +// +// Define function to read the value of a performance counter. +// + +#define ReadPMC __readpmc + +DWORD64 +__readpmc ( + [OnParameterOnly] DWORD Counter + ); + + + +// +// Define function to read the value of the time stamp counter +// + +#define ReadTimeStampCounter() __rdtsc() + +DWORD64 +__rdtsc ( + void + ); + + + +// +// Define functions to move strings as bytes, words, dwords, and qwords. +// + + void +__movsb ( + [OnParameterOnly] PBYTE Destination, + [OnParameterOnly] BYTE const *Source, + [OnParameterOnly] SIZE_T Count + ); + + void +__movsw ( + [OnParameterOnly] PWORD Destination, + [OnParameterOnly] WORD const *Source, + [OnParameterOnly] SIZE_T Count + ); + + void +__movsd ( + [OnParameterOnly] PDWORD Destination, + [OnParameterOnly] DWORD const *Source, + [OnParameterOnly] SIZE_T Count + ); + + void +__movsq ( + [OnParameterOnly] PDWORD64 Destination, + [OnParameterOnly] DWORD64 const *Source, + [OnParameterOnly] SIZE_T Count + ); + + + + + + +// +// Define functions to store strings as bytes, words, dwords, and qwords. +// + + void +__stosb ( + [OnParameterOnly] PBYTE Destination, + [OnParameterOnly] BYTE Value, + [OnParameterOnly] SIZE_T Count + ); + + void +__stosw ( + [OnParameterOnly] PWORD Destination, + [OnParameterOnly] WORD Value, + [OnParameterOnly] SIZE_T Count + ); + + void +__stosd ( + [OnParameterOnly] PDWORD Destination, + [OnParameterOnly] DWORD Value, + [OnParameterOnly] SIZE_T Count + ); + + void +__stosq ( + [OnParameterOnly] PDWORD64 Destination, + [OnParameterOnly] DWORD64 Value, + [OnParameterOnly] SIZE_T Count + ); + + + + + + +// +// Define functions to capture the high 64-bits of a 128-bit multiply. +// + +#define MultiplyHigh __mulh +#define UnsignedMultiplyHigh __umulh + +LONGLONG + __mulh ( + [OnParameterOnly] LONG64 Multiplier, + [OnParameterOnly] LONG64 Multiplicand + ); + +ULONGLONG + __umulh ( + [OnParameterOnly] DWORD64 Multiplier, + [OnParameterOnly] DWORD64 Multiplicand + ); + + + + +// +// Define functions to perform 128-bit shifts +// + +#define ShiftLeft128 __shiftleft128 +#define ShiftRight128 __shiftright128 + +DWORD64 + __shiftleft128 ( + [OnParameterOnly] DWORD64 LowPart, + [OnParameterOnly] DWORD64 HighPart, + [OnParameterOnly] BYTE Shift + ); + +DWORD64 + __shiftright128 ( + [OnParameterOnly] DWORD64 LowPart, + [OnParameterOnly] DWORD64 HighPart, + [OnParameterOnly] BYTE Shift + ); + + + + +// +// Define functions to perform 128-bit multiplies. +// + +#define Multiply128 _mul128 + +LONG64 + _mul128 ( + [OnParameterOnly] LONG64 Multiplier, + [OnParameterOnly] LONG64 Multiplicand, + [OnParameterOnly] LONG64 *HighProduct + ); + + + + + +#define UnsignedMultiply128 _umul128 + +DWORD64 + _umul128 ( + [OnParameterOnly] DWORD64 Multiplier, + [OnParameterOnly] DWORD64 Multiplicand, + [OnParameterOnly] DWORD64 *HighProduct + ); + + + + + + +LONG64 +MultiplyExtract128 ( + [OnParameterOnly] LONG64 Multiplier, + [OnParameterOnly] LONG64 Multiplicand, + [OnParameterOnly] BYTE Shift + ) + +{ + + LONG64 extractedProduct; + LONG64 highProduct; + LONG64 lowProduct; + BOOLEAN negate; + DWORD64 uhighProduct; + DWORD64 ulowProduct; + + lowProduct = _mul128(Multiplier, Multiplicand, &highProduct); + negate = 0; + uhighProduct = (DWORD64)highProduct; + ulowProduct = (DWORD64)lowProduct; + if (highProduct < 0) { + negate = 1; + uhighProduct = (DWORD64)(-highProduct); + ulowProduct = (DWORD64)(-lowProduct); + if (ulowProduct != 0) { + uhighProduct -= 1; + } + } + + extractedProduct = (LONG64) __shiftright128(ulowProduct, uhighProduct, Shift); + if (negate != 0) { + extractedProduct = -extractedProduct; + } + + return extractedProduct; +} + + +DWORD64 +UnsignedMultiplyExtract128 ( + [OnParameterOnly] DWORD64 Multiplier, + [OnParameterOnly] DWORD64 Multiplicand, + [OnParameterOnly] BYTE Shift + ) + +{ + + DWORD64 extractedProduct; + DWORD64 highProduct; + DWORD64 lowProduct; + + lowProduct = _umul128(Multiplier, Multiplicand, &highProduct); + extractedProduct = __shiftright128(lowProduct, highProduct, Shift); + return extractedProduct; +} + +// +// Define functions to read and write the uer TEB and the system PCR/PRCB. +// + +BYTE +__readgsbyte ( + [OnParameterOnly] DWORD Offset + ); + +WORD +__readgsword ( + [OnParameterOnly] DWORD Offset + ); + +DWORD +__readgsdword ( + [OnParameterOnly] DWORD Offset + ); + +DWORD64 +__readgsqword ( + [OnParameterOnly] DWORD Offset + ); + + void +__writegsbyte ( + [OnParameterOnly] DWORD Offset, + [OnParameterOnly] BYTE Data + ); + + void +__writegsword ( + [OnParameterOnly] DWORD Offset, + [OnParameterOnly] WORD Data + ); + + void +__writegsdword ( + [OnParameterOnly] DWORD Offset, + [OnParameterOnly] DWORD Data + ); + + void +__writegsqword ( + [OnParameterOnly] DWORD Offset, + [OnParameterOnly] DWORD64 Data + ); + + + + + + + + + + + + + void +__incgsbyte ( + [OnParameterOnly] DWORD Offset + ); + + void +__addgsbyte ( + [OnParameterOnly] DWORD Offset, + [OnParameterOnly] BYTE Value + ); + + void +__incgsword ( + [OnParameterOnly] DWORD Offset + ); + + void +__addgsword ( + [OnParameterOnly] DWORD Offset, + [OnParameterOnly] WORD Value + ); + + void +__incgsdword ( + [OnParameterOnly] DWORD Offset + ); + + void +__addgsdword ( + [OnParameterOnly] DWORD Offset, + [OnParameterOnly] DWORD Value + ); + + void +__incgsqword ( + [OnParameterOnly] DWORD Offset + ); + + void +__addgsqword ( + [OnParameterOnly] DWORD Offset, + [OnParameterOnly] DWORD64 Value + ); + + + + + + + + + + + + + + + +} + + + + +// +// The following values specify the type of access in the first parameter +// of the exception record whan the exception code specifies an access +// violation. +// + +#define EXCEPTION_READ_FAULT 0 // exception caused by a read +#define EXCEPTION_WRITE_FAULT 1 // exception caused by a write +#define EXCEPTION_EXECUTE_FAULT 8 // exception caused by an instruction fetch + +// begin_wx86 +// +// The following flags control the contents of the CONTEXT structure. +// + + + +#define CONTEXT_AMD64 0x100000 + +// end_wx86 + +#define CONTEXT_CONTROL (CONTEXT_AMD64 | 0x1L) +#define CONTEXT_INTEGER (CONTEXT_AMD64 | 0x2L) +#define CONTEXT_SEGMENTS (CONTEXT_AMD64 | 0x4L) +#define CONTEXT_FLOATING_POINT (CONTEXT_AMD64 | 0x8L) +#define CONTEXT_DEBUG_REGISTERS (CONTEXT_AMD64 | 0x10L) + +#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT) + +#define CONTEXT_ALL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS | CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS) + +#define CONTEXT_XSTATE (CONTEXT_AMD64 | 0x20L) + +#define CONTEXT_EXCEPTION_ACTIVE 0x8000000 +#define CONTEXT_SERVICE_ACTIVE 0x10000000 +#define CONTEXT_EXCEPTION_REQUEST 0x40000000 +#define CONTEXT_EXCEPTION_REPORTING 0x80000000 + +// begin_wx86 + + + +// +// Define initial MxCsr and FpCsr control. +// + +#define INITIAL_MXCSR 0x1f80 // initial MXCSR value +#define INITIAL_FPCSR 0x027f // initial FPCSR value + +// end_ntddk +// begin_wdm begin_ntosp + +typedef XSAVE_FORMAT XMM_SAVE_AREA32, *PXMM_SAVE_AREA32; + +// end_wdm end_ntosp +// begin_ntddk + +// +// Context Frame +// +// This frame has a several purposes: 1) it is used as an argument to +// NtContinue, 2) it is used to constuct a call frame for APC delivery, +// and 3) it is used in the user level thread creation routines. +// +// +// The flags field within this record controls the contents of a CONTEXT +// record. +// +// If the context record is used as an input parameter, then for each +// portion of the context record controlled by a flag whose value is +// set, it is assumed that that portion of the context record contains +// valid context. If the context record is being used to modify a threads +// context, then only that portion of the threads context is modified. +// +// If the context record is used as an output parameter to capture the +// context of a thread, then only those portions of the thread's context +// corresponding to set flags will be returned. +// +// CONTEXT_CONTROL specifies SegSs, Rsp, SegCs, Rip, and EFlags. +// +// CONTEXT_INTEGER specifies Rax, Rcx, Rdx, Rbx, Rbp, Rsi, Rdi, and R8-R15. +// +// CONTEXT_SEGMENTS specifies SegDs, SegEs, SegFs, and SegGs. +// +// CONTEXT_FLOATING_POINT specifies Xmm0-Xmm15. +// +// CONTEXT_DEBUG_REGISTERS specifies Dr0-Dr3 and Dr6-Dr7. +// + +typedef struct _CONTEXT { + + // + // Register parameter home addresses. + // + // N.B. These fields are for convience - they could be used to extend the + // context record in the future. + // + + DWORD64 P1Home; + DWORD64 P2Home; + DWORD64 P3Home; + DWORD64 P4Home; + DWORD64 P5Home; + DWORD64 P6Home; + + // + // Control flags. + // + + DWORD ContextFlags; + DWORD MxCsr; + + // + // Segment Registers and processor flags. + // + + WORD SegCs; + WORD SegDs; + WORD SegEs; + WORD SegFs; + WORD SegGs; + WORD SegSs; + DWORD EFlags; + + // + // Debug registers + // + + DWORD64 Dr0; + DWORD64 Dr1; + DWORD64 Dr2; + DWORD64 Dr3; + DWORD64 Dr6; + DWORD64 Dr7; + + // + // Integer registers. + // + + DWORD64 Rax; + DWORD64 Rcx; + DWORD64 Rdx; + DWORD64 Rbx; + DWORD64 Rsp; + DWORD64 Rbp; + DWORD64 Rsi; + DWORD64 Rdi; + DWORD64 R8; + DWORD64 R9; + DWORD64 R10; + DWORD64 R11; + DWORD64 R12; + DWORD64 R13; + DWORD64 R14; + DWORD64 R15; + + // + // Program counter. + // + + DWORD64 Rip; + + // + // Floating point state. + // + + union { + XMM_SAVE_AREA32 FltSave; + struct { + M128A Header[2]; + M128A Legacy[8]; + M128A Xmm0; + M128A Xmm1; + M128A Xmm2; + M128A Xmm3; + M128A Xmm4; + M128A Xmm5; + M128A Xmm6; + M128A Xmm7; + M128A Xmm8; + M128A Xmm9; + M128A Xmm10; + M128A Xmm11; + M128A Xmm12; + M128A Xmm13; + M128A Xmm14; + M128A Xmm15; + } ; + } ; + + // + // Vector registers. + // + + M128A VectorRegister[26]; + DWORD64 VectorControl; + + // + // Special debug control registers. + // + + DWORD64 DebugControl; + DWORD64 LastBranchToRip; + DWORD64 LastBranchFromRip; + DWORD64 LastExceptionToRip; + DWORD64 LastExceptionFromRip; +} CONTEXT, *PCONTEXT; + +// +// Define function table entry - a function table entry is generated for +// each frame function. +// + +#define RUNTIME_FUNCTION_INDIRECT 0x1 + +typedef struct _RUNTIME_FUNCTION { + DWORD BeginAddress; + DWORD EndAddress; + DWORD UnwindData; +} RUNTIME_FUNCTION, *PRUNTIME_FUNCTION; + +// +// Define unwind history table structure. +// + +#define UNWIND_HISTORY_TABLE_SIZE 12 + +typedef struct _UNWIND_HISTORY_TABLE_ENTRY { + DWORD64 ImageBase; + PRUNTIME_FUNCTION FunctionEntry; +} UNWIND_HISTORY_TABLE_ENTRY, *PUNWIND_HISTORY_TABLE_ENTRY; + +typedef struct _UNWIND_HISTORY_TABLE { + DWORD Count; + BYTE LocalHint; + BYTE GlobalHint; + BYTE Search; + BYTE Once; + DWORD64 LowAddress; + DWORD64 HighAddress; + UNWIND_HISTORY_TABLE_ENTRY Entry[ 12]; +} UNWIND_HISTORY_TABLE, *PUNWIND_HISTORY_TABLE; + +// +// Define dynamic function table entry. +// + +typedef + +PRUNTIME_FUNCTION +GET_RUNTIME_FUNCTION_CALLBACK ( + [OnParameterOnly] DWORD64 ControlPc, + [OnParameterOnly] PVOID Context + ); +typedef GET_RUNTIME_FUNCTION_CALLBACK *PGET_RUNTIME_FUNCTION_CALLBACK; + +typedef + +DWORD +OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK ( + [OnParameterOnly] HANDLE Process, + [OnParameterOnly] PVOID TableAddress, + [OnParameterOnly] PDWORD Entries, + [OnParameterOnly] PRUNTIME_FUNCTION* Functions + ); +typedef OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK *POUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK; + +#define OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK_EXPORT_NAME "OutOfProcessFunctionTableCallback" + + +// +// Define runtime exception handling prototypes. +// + + + void + +RtlRestoreContext ( + [OnParameterOnly] PCONTEXT ContextRecord, + [OnParameterOnly] struct _EXCEPTION_RECORD *ExceptionRecord + ); + + + +BOOLEAN + +RtlAddFunctionTable ( + [OnParameterOnly] PRUNTIME_FUNCTION FunctionTable, + [OnParameterOnly] DWORD EntryCount, + [OnParameterOnly] DWORD64 BaseAddress + ); + + +PRUNTIME_FUNCTION + +RtlLookupFunctionEntry ( + [OnParameterOnly] DWORD64 ControlPc, + [OnParameterOnly] PDWORD64 ImageBase, + [OnParameterOnly] PUNWIND_HISTORY_TABLE HistoryTable + ); + +// +// Nonvolatile context pointer record. +// + +typedef struct _KNONVOLATILE_CONTEXT_POINTERS { + union { + PM128A FloatingContext[16]; + struct { + PM128A Xmm0; + PM128A Xmm1; + PM128A Xmm2; + PM128A Xmm3; + PM128A Xmm4; + PM128A Xmm5; + PM128A Xmm6; + PM128A Xmm7; + PM128A Xmm8; + PM128A Xmm9; + PM128A Xmm10; + PM128A Xmm11; + PM128A Xmm12; + PM128A Xmm13; + PM128A Xmm14; + PM128A Xmm15; + } ; + } ; + + union { + PDWORD64 IntegerContext[16]; + struct { + PDWORD64 Rax; + PDWORD64 Rcx; + PDWORD64 Rdx; + PDWORD64 Rbx; + PDWORD64 Rsp; + PDWORD64 Rbp; + PDWORD64 Rsi; + PDWORD64 Rdi; + PDWORD64 R8; + PDWORD64 R9; + PDWORD64 R10; + PDWORD64 R11; + PDWORD64 R12; + PDWORD64 R13; + PDWORD64 R14; + PDWORD64 R15; + } ; + } ; + +} KNONVOLATILE_CONTEXT_POINTERS, *PKNONVOLATILE_CONTEXT_POINTERS; + + +PEXCEPTION_ROUTINE + +RtlVirtualUnwind ( + [OnParameterOnly] DWORD HandlerType, + [OnParameterOnly] DWORD64 ImageBase, + [OnParameterOnly] DWORD64 ControlPc, + [OnParameterOnly] PRUNTIME_FUNCTION FunctionEntry, + [OnParameterOnly] PCONTEXT ContextRecord, + [OnParameterOnly] PVOID *HandlerData, + [OnParameterOnly] PDWORD64 EstablisherFrame, + [OnParameterOnly] PKNONVOLATILE_CONTEXT_POINTERS ContextPointers + ); + + +BOOLEAN + +RtlInstallFunctionTableCallback ( + [OnParameterOnly] DWORD64 TableIdentifier, + [OnParameterOnly] DWORD64 BaseAddress, + [OnParameterOnly] DWORD Length, + [OnParameterOnly] PGET_RUNTIME_FUNCTION_CALLBACK Callback, + [OnParameterOnly] PVOID Context, + [OnParameterOnly] PCWSTR OutOfProcessCallbackDll + ); + + +BOOLEAN + +RtlDeleteFunctionTable ( + [OnParameterOnly] PRUNTIME_FUNCTION FunctionTable + ); + + + + + + +// +// Disable these two pragmas that evaluate to "sti" "cli" on x86 so that driver +// writers to not leave them inadvertantly in their code. +// + + + + + + + + + // build with /Od don't get weird errors ! + + + + + + + + + + + + + + +// end_ntddk end_nthal + + + +extern "C" { + + + + + + + +// +// Define bit test intrinsics. +// + +#define BitTest _bittest +#define BitTestAndComplement _bittestandcomplement +#define BitTestAndSet _bittestandset +#define BitTestAndReset _bittestandreset +#define InterlockedBitTestAndSet _interlockedbittestandset +#define InterlockedBitTestAndReset _interlockedbittestandreset + + [method: OnFunctionOnly] +BOOLEAN +_bittest ( + [OnParameterOnly] LONG const *Base, + [OnParameterOnly] LONG Offset + ); + +BOOLEAN +_bittestandcomplement ( + [OnParameterOnly] LONG *Base, + [OnParameterOnly] LONG Offset + ); + +BOOLEAN +_bittestandset ( + [OnParameterOnly] LONG *Base, + [OnParameterOnly] LONG Offset + ); + +BOOLEAN +_bittestandreset ( + [OnParameterOnly] LONG *Base, + [OnParameterOnly] LONG Offset + ); + +BOOLEAN +_interlockedbittestandset ( + [OnParameterOnly] LONG volatile *Base, + [OnParameterOnly] LONG Offset + ); + +BOOLEAN +_interlockedbittestandreset ( + [OnParameterOnly] LONG volatile *Base, + [OnParameterOnly] LONG Offset + ); + + + + + + + + +// +// Define bit scan intrinsics. +// + +#define BitScanForward _BitScanForward +#define BitScanReverse _BitScanReverse + + +BOOLEAN +_BitScanForward ( + [OnParameterOnly] DWORD *Index, + [OnParameterOnly] DWORD Mask + ); + + +BOOLEAN +_BitScanReverse ( + [OnParameterOnly] DWORD *Index, + [OnParameterOnly] DWORD Mask + ); + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +// +// [pfx_parse] - guard against PREfix intrinsic error +// + + +#define InterlockedAnd16 _InterlockedAnd16 +#define InterlockedCompareExchange16 _InterlockedCompareExchange16 +#define InterlockedOr16 _InterlockedOr16 + +SHORT +_InterlockedAnd16 ( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT Value + ); + +SHORT +_InterlockedCompareExchange16 ( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT ExChange, + [OnParameterOnly] SHORT Comperand + ); + +SHORT +_InterlockedOr16 ( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT Value + ); + + + + + + + + + + + + __inline +BOOLEAN +InterlockedBitTestAndComplement ( + [OnParameterOnly] LONG volatile *Base, + [OnParameterOnly] LONG Bit + ) +{ + __asm { + mov eax, Bit + mov ecx, Base + lock btc [ecx], eax + setc al + }; +} + + + +// +// [pfx_parse] +// guard against __readfsbyte parsing error +// + + +// +// Define FS referencing intrinsics +// + +BYTE +__readfsbyte ( + [OnParameterOnly] DWORD Offset + ); + +WORD +__readfsword ( + [OnParameterOnly] DWORD Offset + ); + +DWORD +__readfsdword ( + [OnParameterOnly] DWORD Offset + ); + + void +__writefsbyte ( + [OnParameterOnly] DWORD Offset, + [OnParameterOnly] BYTE Data + ); + + void +__writefsword ( + [OnParameterOnly] DWORD Offset, + [OnParameterOnly] WORD Data + ); + + void +__writefsdword ( + [OnParameterOnly] DWORD Offset, + [OnParameterOnly] DWORD Data + ); + + + + + + + + + + + + + + + void +__incfsbyte ( + [OnParameterOnly] DWORD Offset + ); + + void +__addfsbyte ( + [OnParameterOnly] DWORD Offset, + [OnParameterOnly] BYTE Value + ); + + void +__incfsword ( + [OnParameterOnly] DWORD Offset + ); + + void +__addfsword ( + [OnParameterOnly] DWORD Offset, + [OnParameterOnly] WORD Value + ); + + void +__incfsdword ( + [OnParameterOnly] DWORD Offset + ); + + void +__addfsdword ( + [OnParameterOnly] DWORD Offset, + [OnParameterOnly] DWORD Value + ); + + + + + + + + + + + + + + + void +_mm_pause ( + void + ); + + + +#define YieldProcessor _mm_pause + + + + +#define YieldProcessor() __asm { rep nop } + + + + + +} + + + + + + + + + + + __inline + void + __faststorefence ( + void + ) +{ + LONG Barrier; + __asm { + xchg Barrier, eax + } +} + + + +// +// Prefetch is not supported on all x86 procssors. +// + +#define PreFetchCacheLine(l, a) +#define PrefetchForWrite(p) +#define ReadForWriteAccess(p) (*(p)) + +// +// PreFetchCacheLine level defines. +// + +#define PF_TEMPORAL_LEVEL_1 +#define PF_NON_TEMPORAL_LEVEL_ALL + +// +// Define function to read the value of a performance counter. +// + + + +#define ReadPMC __readpmc + +DWORD64 +__readpmc ( + [OnParameterOnly] DWORD Counter + ); + + + + + + + + + + + + + + + + + + + + +// +// Define function to read the value of the time stamp counter +// + + + +#define ReadTimeStampCounter() __rdtsc() + +DWORD64 +__rdtsc ( + void + ); + + + + + + + + + + + + + + + + + +// end_ntddk +// begin_wdm + + + + + + void +__int2c ( + void + ); + + + + + __inline + void +DbgRaiseAssertionFailure ( + void + ) + +{ + __int2c(); +} + + + + + + + + + + + + + + + + + + + + + + +// end_wdm + + + +__inline PVOID GetFiberData( void ) { return *(PVOID *) (ULONG_PTR) __readfsdword (0x10);} +__inline PVOID GetCurrentFiber( void ) { return (PVOID) (ULONG_PTR) __readfsdword (0x10);} + + + + + + + + + + + + + + + + + + + + +// begin_ntddk + +// end_ntddk + +// +// The following values specify the type of failing access when the status is +// STATUS_ACCESS_VIOLATION and the first parameter in the execpetion record. +// + +#define EXCEPTION_READ_FAULT 0 // Access violation was caused by a read +#define EXCEPTION_WRITE_FAULT 1 // Access violation was caused by a write +#define EXCEPTION_EXECUTE_FAULT 8 // Access violation was caused by an instruction fetch + +// begin_wx86 +// begin_ntddk + +// +// Define the size of the 80387 save area, which is in the context frame. +// + +#define SIZE_OF_80387_REGISTERS 80 + +// +// The following flags control the contents of the CONTEXT structure. +// + + + +#define CONTEXT_i386 0x00010000 // this assumes that i386 and +#define CONTEXT_i486 0x00010000 // i486 have identical context records + +// end_wx86 + +#define CONTEXT_CONTROL (CONTEXT_i386 | 0x00000001L) // SS:SP, CS:IP, FLAGS, BP +#define CONTEXT_INTEGER (CONTEXT_i386 | 0x00000002L) // AX, BX, CX, DX, SI, DI +#define CONTEXT_SEGMENTS (CONTEXT_i386 | 0x00000004L) // DS, ES, FS, GS +#define CONTEXT_FLOATING_POINT (CONTEXT_i386 | 0x00000008L) // 387 state +#define CONTEXT_DEBUG_REGISTERS (CONTEXT_i386 | 0x00000010L) // DB 0-3,6,7 +#define CONTEXT_EXTENDED_REGISTERS (CONTEXT_i386 | 0x00000020L) // cpu specific extensions + +#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS) + + +#define CONTEXT_ALL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS | CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS | CONTEXT_EXTENDED_REGISTERS) + + + +#define CONTEXT_XSTATE (CONTEXT_i386 | 0x00000040L) + +// begin_wx86 + + + +typedef struct _FLOATING_SAVE_AREA { + DWORD ControlWord; + DWORD StatusWord; + DWORD TagWord; + DWORD ErrorOffset; + DWORD ErrorSelector; + DWORD DataOffset; + DWORD DataSelector; + BYTE RegisterArea[ 80]; + DWORD Cr0NpxState; +} FLOATING_SAVE_AREA; + +typedef FLOATING_SAVE_AREA *PFLOATING_SAVE_AREA; + + +// end_ntddk +// begin_wdm begin_ntosp + +#define MAXIMUM_SUPPORTED_EXTENSION 512 + + + +; + + + +// end_wdm end_ntosp +// begin_ntddk + + + +// +// Context Frame +// +// This frame has a several purposes: 1) it is used as an argument to +// NtContinue, 2) is is used to constuct a call frame for APC delivery, +// and 3) it is used in the user level thread creation routines. +// +// The layout of the record conforms to a standard call frame. +// + +typedef struct _CONTEXT { + + // + // The flags values within this flag control the contents of + // a CONTEXT record. + // + // If the context record is used as an input parameter, then + // for each portion of the context record controlled by a flag + // whose value is set, it is assumed that that portion of the + // context record contains valid context. If the context record + // is being used to modify a threads context, then only that + // portion of the threads context will be modified. + // + // If the context record is used as an IN OUT parameter to capture + // the context of a thread, then only those portions of the thread's + // context corresponding to set flags will be returned. + // + // The context record is never used as an OUT only parameter. + // + + DWORD ContextFlags; + + // + // This section is specified/returned if CONTEXT_DEBUG_REGISTERS is + // set in ContextFlags. Note that CONTEXT_DEBUG_REGISTERS is NOT + // included in CONTEXT_FULL. + // + + DWORD Dr0; + DWORD Dr1; + DWORD Dr2; + DWORD Dr3; + DWORD Dr6; + DWORD Dr7; + + // + // This section is specified/returned if the + // ContextFlags word contians the flag CONTEXT_FLOATING_POINT. + // + + FLOATING_SAVE_AREA FloatSave; + + // + // This section is specified/returned if the + // ContextFlags word contians the flag CONTEXT_SEGMENTS. + // + + DWORD SegGs; + DWORD SegFs; + DWORD SegEs; + DWORD SegDs; + + // + // This section is specified/returned if the + // ContextFlags word contians the flag CONTEXT_INTEGER. + // + + DWORD Edi; + DWORD Esi; + DWORD Ebx; + DWORD Edx; + DWORD Ecx; + DWORD Eax; + + // + // This section is specified/returned if the + // ContextFlags word contians the flag CONTEXT_CONTROL. + // + + DWORD Ebp; + DWORD Eip; + DWORD SegCs; // MUST BE SANITIZED + DWORD EFlags; // MUST BE SANITIZED + DWORD Esp; + DWORD SegSs; + + // + // This section is specified/returned if the ContextFlags word + // contains the flag CONTEXT_EXTENDED_REGISTERS. + // The format and contexts are processor specific + // + + BYTE ExtendedRegisters[ 512]; + +} CONTEXT; + +typedef CONTEXT *PCONTEXT; + + + +// begin_ntminiport + + + + +#define _LDT_ENTRY_DEFINED + +typedef struct _LDT_ENTRY { + WORD LimitLow; + WORD BaseLow; + union { + struct { + BYTE BaseMid; + BYTE Flags1; // Declare as bytes to avoid alignment + BYTE Flags2; // Problems. + BYTE BaseHi; + } Bytes; + struct { + DWORD BaseMid : 8; + DWORD Type : 5; + DWORD Dpl : 2; + DWORD Pres : 1; + DWORD LimitHi : 4; + DWORD Sys : 1; + DWORD Reserved_0 : 1; + DWORD Default_Big : 1; + DWORD Granularity : 1; + DWORD BaseHi : 8; + } Bits; + } HighWord; +} LDT_ENTRY, *PLDT_ENTRY; + + + + + + + +extern "C" { + + +// +// Define bit test intrinsics. +// + +#define BitTest _bittest +#define BitTestAndComplement _bittestandcomplement +#define BitTestAndSet _bittestandset +#define BitTestAndReset _bittestandreset + +#define BitTest64 _bittest64 +#define BitTestAndComplement64 _bittestandcomplement64 +#define BitTestAndSet64 _bittestandset64 +#define BitTestAndReset64 _bittestandreset64 + + [method: OnFunctionOnly] +BOOLEAN +_bittest ( + [OnParameterOnly] LONG const *Base, + [OnParameterOnly] LONG Offset + ); + +BOOLEAN +_bittestandcomplement ( + [OnParameterOnly] LONG *Base, + [OnParameterOnly] LONG Offset + ); + +BOOLEAN +_bittestandset ( + [OnParameterOnly] LONG *Base, + [OnParameterOnly] LONG Offset + ); + +BOOLEAN +_bittestandreset ( + [OnParameterOnly] LONG *Base, + [OnParameterOnly] LONG Offset + ); + + [method: OnFunctionOnly] +BOOLEAN +_bittest64 ( + [OnParameterOnly] LONG64 const *Base, + [OnParameterOnly] LONG64 Offset + ); + +BOOLEAN +_bittestandcomplement64 ( + [OnParameterOnly] LONG64 *Base, + [OnParameterOnly] LONG64 Offset + ); + +BOOLEAN +_bittestandset64 ( + [OnParameterOnly] LONG64 *Base, + [OnParameterOnly] LONG64 Offset + ); + +BOOLEAN +_bittestandreset64 ( + [OnParameterOnly] LONG64 *Base, + [OnParameterOnly] LONG64 Offset + ); + + + + + + + + + + + +// +// Define bit scan intrinsics. +// + +#define BitScanForward _BitScanForward +#define BitScanReverse _BitScanReverse +#define BitScanForward64 _BitScanForward64 +#define BitScanReverse64 _BitScanReverse64 + + +BOOLEAN +_BitScanForward ( + [OnParameterOnly] DWORD *Index, + [OnParameterOnly] DWORD Mask + ); + + +BOOLEAN +_BitScanReverse ( + [OnParameterOnly] DWORD *Index, + [OnParameterOnly] DWORD Mask + ); + + +BOOLEAN +_BitScanForward64 ( + [OnParameterOnly] DWORD *Index, + [OnParameterOnly] DWORD64 Mask + ); + + +BOOLEAN +_BitScanReverse64 ( + [OnParameterOnly] DWORD *Index, + [OnParameterOnly] DWORD64 Mask + ); + + + + + + +#define InterlockedCompareExchange16 _InterlockedCompareExchange16 + +SHORT +_InterlockedCompareExchange16 ( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT ExChange, + [OnParameterOnly] SHORT Comperand + ); + + + + +} + + +#define InterlockedAdd _InterlockedAdd +#define InterlockedAddAcquire _InterlockedAdd_acq +#define InterlockedAddRelease _InterlockedAdd_rel + +#define InterlockedIncrement _InterlockedIncrement +#define InterlockedIncrementAcquire _InterlockedIncrement_acq +#define InterlockedIncrementRelease _InterlockedIncrement_rel + +#define InterlockedDecrement _InterlockedDecrement +#define InterlockedDecrementAcquire _InterlockedDecrement_acq +#define InterlockedDecrementRelease _InterlockedDecrement_rel + +#define InterlockedExchange _InterlockedExchange +#define InterlockedExchangeAcquire _InterlockedExchange_acq + +#define InterlockedExchangeAdd _InterlockedExchangeAdd +#define InterlockedExchangeAddAcquire _InterlockedExchangeAdd_acq +#define InterlockedExchangeAddRelease _InterlockedExchangeAdd_rel + +#define InterlockedAdd64 _InterlockedAdd64 +#define InterlockedAddAcquire64 _InterlockedAdd64_acq +#define InterlockedAddRelease64 _InterlockedAdd64_rel + +#define InterlockedIncrement64 _InterlockedIncrement64 +#define InterlockedIncrementAcquire64 _InterlockedIncrement64_acq +#define InterlockedIncrementRelease64 _InterlockedIncrement64_rel + +#define InterlockedDecrement64 _InterlockedDecrement64 +#define InterlockedDecrementAcquire64 _InterlockedDecrement64_acq +#define InterlockedDecrementRelease64 _InterlockedDecrement64_rel + +#define InterlockedExchange64 _InterlockedExchange64 +#define InterlockedExchangeAcquire64 _InterlockedExchange64_acq + +#define InterlockedExchangeAdd64 _InterlockedExchangeAdd64 +#define InterlockedExchangeAddAcquire64 _InterlockedExchangeAdd64_acq +#define InterlockedExchangeAddRelease64 _InterlockedExchangeAdd64_rel + +#define InterlockedCompareExchange64 _InterlockedCompareExchange64 +#define InterlockedCompareExchangeAcquire64 _InterlockedCompareExchange64_acq +#define InterlockedCompareExchangeRelease64 _InterlockedCompareExchange64_rel + +#define InterlockedCompare64Exchange128 _InterlockedCompare64Exchange128 +#define InterlockedCompare64ExchangeAcquire128 _InterlockedCompare64Exchange128_acq +#define InterlockedCompare64ExchangeRelease128 _InterlockedCompare64Exchange128_rel + +#define InterlockedCompareExchange _InterlockedCompareExchange +#define InterlockedCompareExchangeAcquire _InterlockedCompareExchange_acq +#define InterlockedCompareExchangeRelease _InterlockedCompareExchange_rel + +#define InterlockedExchangePointer _InterlockedExchangePointer +#define InterlockedExchangePointerAcquire _InterlockedExchangePointer_acq + +#define InterlockedCompareExchangePointer _InterlockedCompareExchangePointer +#define InterlockedCompareExchangePointerRelease _InterlockedCompareExchangePointer_rel +#define InterlockedCompareExchangePointerAcquire _InterlockedCompareExchangePointer_acq + + +#define InterlockedExchangeAddSizeT(a, b) InterlockedExchangeAdd64((LONG64 *)a, b) +#define InterlockedIncrementSizeT(a) InterlockedIncrement64((LONG64 *)a) +#define InterlockedDecrementSizeT(a) InterlockedDecrement64((LONG64 *)a) + +#define InterlockedOr _InterlockedOr +#define InterlockedOrAcquire _InterlockedOr_acq +#define InterlockedOrRelease _InterlockedOr_rel +#define InterlockedOr8 _InterlockedOr8 +#define InterlockedOr8Acquire _InterlockedOr8_acq +#define InterlockedOr8Release _InterlockedOr8_rel +#define InterlockedOr16 _InterlockedOr16 +#define InterlockedOr16Acquire _InterlockedOr16_acq +#define InterlockedOr16Release _InterlockedOr16_rel +#define InterlockedOr64 _InterlockedOr64 +#define InterlockedOr64Acquire _InterlockedOr64_acq +#define InterlockedOr64Release _InterlockedOr64_rel +#define InterlockedXor _InterlockedXor +#define InterlockedXorAcquire _InterlockedXor_acq +#define InterlockedXorRelease _InterlockedXor_rel +#define InterlockedXor8 _InterlockedXor8 +#define InterlockedXor8Acquire _InterlockedXor8_acq +#define InterlockedXor8Release _InterlockedXor8_rel +#define InterlockedXor16 _InterlockedXor16 +#define InterlockedXor16Acquire _InterlockedXor16_acq +#define InterlockedXor16Release _InterlockedXor16_rel +#define InterlockedXor64 _InterlockedXor64 +#define InterlockedXor64Acquire _InterlockedXor64_acq +#define InterlockedXor64Release _InterlockedXor64_rel +#define InterlockedAnd _InterlockedAnd +#define InterlockedAndAcquire _InterlockedAnd_acq +#define InterlockedAndRelease _InterlockedAnd_rel +#define InterlockedAnd8 _InterlockedAnd8 +#define InterlockedAnd8Acquire _InterlockedAnd8_acq +#define InterlockedAnd8Release _InterlockedAnd8_rel +#define InterlockedAnd16 _InterlockedAnd16 +#define InterlockedAnd16Acquire _InterlockedAnd16_acq +#define InterlockedAnd16Release _InterlockedAnd16_rel +#define InterlockedAnd64 _InterlockedAnd64 +#define InterlockedAnd64Acquire _InterlockedAnd64_acq +#define InterlockedAnd64Release _InterlockedAnd64_rel + + +extern "C" { + + +LONG + + _InterlockedAdd ( + [OnParameterOnly] LONG volatile *Addend, + [OnParameterOnly] LONG Value + ); + +LONG + + _InterlockedAdd_acq ( + [OnParameterOnly] LONG volatile *Addend, + [OnParameterOnly] LONG Value + ); + +LONG + + _InterlockedAdd_rel ( + [OnParameterOnly] LONG volatile *Addend, + [OnParameterOnly] LONG Value + ); + +LONGLONG + + _InterlockedAdd64 ( + [OnParameterOnly] LONGLONG volatile *Addend, + [OnParameterOnly] LONGLONG Value + ); + +LONGLONG + + _InterlockedAdd64_acq ( + [OnParameterOnly] LONGLONG volatile *Addend, + [OnParameterOnly] LONGLONG Value + ); + + +LONGLONG + + _InterlockedAdd64_rel ( + [OnParameterOnly] LONGLONG volatile *Addend, + [OnParameterOnly] LONGLONG Value + ); + +LONG + + _InterlockedIncrement( + [OnParameterOnly] LONG volatile *Addend + ); + +LONG + + _InterlockedDecrement( + [OnParameterOnly] LONG volatile *Addend + ); + +LONG + + _InterlockedIncrement_acq( + [OnParameterOnly] LONG volatile *Addend + ); + +LONG + + _InterlockedDecrement_acq( + [OnParameterOnly] LONG volatile *Addend + ); + +LONG + + _InterlockedIncrement_rel( + [OnParameterOnly] LONG volatile *Addend + ); + +LONG + + _InterlockedDecrement_rel( + [OnParameterOnly] LONG volatile *Addend + ); + +LONG + + _InterlockedExchange( + [OnParameterOnly] LONG volatile *Target, + [OnParameterOnly] LONG Value + ); + +LONG + + _InterlockedExchange_acq( + [OnParameterOnly] LONG volatile *Target, + [OnParameterOnly] LONG Value + ); + +LONG + + _InterlockedExchangeAdd( + [OnParameterOnly] LONG volatile *Addend, + [OnParameterOnly] LONG Value + ); + +LONG + + _InterlockedExchangeAdd_acq( + [OnParameterOnly] LONG volatile *Addend, + [OnParameterOnly] LONG Value + ); + +LONG + + _InterlockedExchangeAdd_rel( + [OnParameterOnly] LONG volatile *Addend, + [OnParameterOnly] LONG Value + ); + +LONG + + _InterlockedCompareExchange ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG ExChange, + [OnParameterOnly] LONG Comperand + ); + + +LONG + + _InterlockedCompareExchange_rel ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG ExChange, + [OnParameterOnly] LONG Comperand + ); + + +LONG + + _InterlockedCompareExchange_acq ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG ExChange, + [OnParameterOnly] LONG Comperand + ); + + +LONGLONG + + _InterlockedIncrement64( + [OnParameterOnly] LONGLONG volatile *Addend + ); + +LONGLONG + + _InterlockedIncrement64_acq( + [OnParameterOnly] LONGLONG volatile *Addend + ); + +LONGLONG + + _InterlockedIncrement64_rel( + [OnParameterOnly] LONGLONG volatile *Addend + ); + +LONGLONG + + _InterlockedDecrement64( + [OnParameterOnly] LONGLONG volatile *Addend + ); + +LONGLONG + + _InterlockedDecrement64_acq( + [OnParameterOnly] LONGLONG volatile *Addend + ); + +LONGLONG + + _InterlockedDecrement64_rel( + [OnParameterOnly] LONGLONG volatile *Addend + ); + +LONGLONG + + _InterlockedExchange64( + [OnParameterOnly] LONGLONG volatile *Target, + [OnParameterOnly] LONGLONG Value + ); + +LONGLONG + + _InterlockedExchange64_acq( + [OnParameterOnly] LONGLONG volatile *Target, + [OnParameterOnly] LONGLONG Value + ); + +LONGLONG + + _InterlockedExchangeAdd64( + [OnParameterOnly] LONGLONG volatile *Addend, + [OnParameterOnly] LONGLONG Value + ); + +LONGLONG + + _InterlockedExchangeAdd64_acq( + [OnParameterOnly] LONGLONG volatile *Addend, + [OnParameterOnly] LONGLONG Value + ); + +LONGLONG + + _InterlockedExchangeAdd64_rel( + [OnParameterOnly] LONGLONG volatile *Addend, + [OnParameterOnly] LONGLONG Value + ); + +LONGLONG + + _InterlockedCompareExchange64 ( + [OnParameterOnly] LONGLONG volatile *Destination, + [OnParameterOnly] LONGLONG ExChange, + [OnParameterOnly] LONGLONG Comperand + ); + +LONGLONG + + _InterlockedCompareExchange64_acq ( + [OnParameterOnly] LONGLONG volatile *Destination, + [OnParameterOnly] LONGLONG ExChange, + [OnParameterOnly] LONGLONG Comperand + ); + +LONGLONG + + _InterlockedCompareExchange64_rel ( + [OnParameterOnly] LONGLONG volatile *Destination, + [OnParameterOnly] LONGLONG ExChange, + [OnParameterOnly] LONGLONG Comperand + ); + +LONG64 + + _InterlockedCompare64Exchange128( + [OnParameterOnly] LONG64 volatile *Destination, + [OnParameterOnly] LONG64 ExchangeHigh, + [OnParameterOnly] LONG64 ExchangeLow, + [OnParameterOnly] LONG64 Comperand + ); + +LONG64 + + _InterlockedCompare64Exchange128_acq( + [OnParameterOnly] LONG64 volatile *Destination, + [OnParameterOnly] LONG64 ExchangeHigh, + [OnParameterOnly] LONG64 ExchangeLow, + [OnParameterOnly] LONG64 Comperand + ); + +LONG64 + + _InterlockedCompare64Exchange128_rel( + [OnParameterOnly] LONG64 volatile *Destination, + [OnParameterOnly] LONG64 ExchangeHigh, + [OnParameterOnly] LONG64 ExchangeLow, + [OnParameterOnly] LONG64 Comperand + ); + +PVOID + + _InterlockedCompareExchangePointer ( + [OnParameterOnly] PVOID volatile *Destination, + [OnParameterOnly] PVOID Exchange, + [OnParameterOnly] PVOID Comperand + ); + +PVOID + + _InterlockedCompareExchangePointer_acq ( + [OnParameterOnly] PVOID volatile *Destination, + [OnParameterOnly] PVOID Exchange, + [OnParameterOnly] PVOID Comperand + ); + +PVOID + + _InterlockedCompareExchangePointer_rel ( + [OnParameterOnly] PVOID volatile *Destination, + [OnParameterOnly] PVOID Exchange, + [OnParameterOnly] PVOID Comperand + ); + +PVOID + + _InterlockedExchangePointer( + [OnParameterOnly] PVOID volatile *Target, + [OnParameterOnly] PVOID Value + ); + +PVOID + + _InterlockedExchangePointer_acq( + [OnParameterOnly] PVOID volatile *Target, + [OnParameterOnly] PVOID Value + ); + +LONG + + _InterlockedOr ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG Value + ); + +LONG + + _InterlockedOr_acq ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG Value + ); + +LONG + + _InterlockedOr_rel ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG Value + ); + +CHAR + + _InterlockedOr8 ( + [OnParameterOnly] CHAR volatile *Destination, + [OnParameterOnly] CHAR Value + ); + +CHAR + + _InterlockedOr8_acq ( + [OnParameterOnly] CHAR volatile *Destination, + [OnParameterOnly] CHAR Value + ); + +CHAR + + _InterlockedOr8_rel ( + [OnParameterOnly] CHAR volatile *Destination, + [OnParameterOnly] CHAR Value + ); + +SHORT + + _InterlockedOr16( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT Value + ); + +SHORT + + _InterlockedOr16_acq ( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT Value + ); + +SHORT + + _InterlockedOr16_rel ( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT Value + ); + +LONGLONG + + _InterlockedOr64 ( + [OnParameterOnly] LONGLONG volatile *Destination, + [OnParameterOnly] LONGLONG Value + ); + +LONGLONG + + _InterlockedOr64_acq ( + [OnParameterOnly] LONGLONG volatile *Destination, + [OnParameterOnly] LONGLONG Value + ); + +LONGLONG + + _InterlockedOr64_rel ( + [OnParameterOnly] LONGLONG volatile *Destination, + [OnParameterOnly] LONGLONG Value + ); + +LONG + + _InterlockedXor ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG Value + ); + +LONG + + _InterlockedXor_acq ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG Value + ); + +LONG + + _InterlockedXor_rel ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG Value + ); + +CHAR + + _InterlockedXor8 ( + [OnParameterOnly] CHAR volatile *Destination, + [OnParameterOnly] CHAR Value + ); + +CHAR + + _InterlockedXor8_acq ( + [OnParameterOnly] CHAR volatile *Destination, + [OnParameterOnly] CHAR Value + ); + +CHAR + + _InterlockedXor8_rel ( + [OnParameterOnly] CHAR volatile *Destination, + [OnParameterOnly] CHAR Value + ); + +SHORT + + _InterlockedXor16( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT Value + ); + +SHORT + + _InterlockedXor16_acq ( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT Value + ); + +SHORT + + _InterlockedXor16_rel ( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT Value + ); + +LONGLONG + + _InterlockedXor64 ( + [OnParameterOnly] LONGLONG volatile *Destination, + [OnParameterOnly] LONGLONG Value + ); + +LONGLONG + + _InterlockedXor64_acq ( + [OnParameterOnly] LONGLONG volatile *Destination, + [OnParameterOnly] LONGLONG Value + ); + +LONGLONG + + _InterlockedXor64_rel ( + [OnParameterOnly] LONGLONG volatile *Destination, + [OnParameterOnly] LONGLONG Value + ); + +LONG + + _InterlockedAnd ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG Value + ); + +LONG + + _InterlockedAnd_acq ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG Value + ); + +LONG + + _InterlockedAnd_rel ( + [OnParameterOnly] LONG volatile *Destination, + [OnParameterOnly] LONG Value + ); + +CHAR + + _InterlockedAnd8 ( + [OnParameterOnly] CHAR volatile *Destination, + [OnParameterOnly] CHAR Value + ); + +CHAR + + _InterlockedAnd8_acq ( + [OnParameterOnly] CHAR volatile *Destination, + [OnParameterOnly] CHAR Value + ); + +CHAR + + _InterlockedAnd8_rel ( + [OnParameterOnly] CHAR volatile *Destination, + [OnParameterOnly] CHAR Value + ); + +SHORT + + _InterlockedAnd16( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT Value + ); + +SHORT + + _InterlockedAnd16_acq ( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT Value + ); + +SHORT + + _InterlockedAnd16_rel ( + [OnParameterOnly] SHORT volatile *Destination, + [OnParameterOnly] SHORT Value + ); + +LONGLONG + + _InterlockedAnd64 ( + [OnParameterOnly] LONGLONG volatile *Destination, + [OnParameterOnly] LONGLONG Value + ); + +LONGLONG + + _InterlockedAnd64_acq ( + [OnParameterOnly] LONGLONG volatile *Destination, + [OnParameterOnly] LONGLONG Value + ); + +LONGLONG + + _InterlockedAnd64_rel ( + [OnParameterOnly] LONGLONG volatile *Destination, + [OnParameterOnly] LONGLONG Value + ); + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +#define InterlockedAnd64 InterlockedAnd64_Inline + +LONGLONG + __inline +InterlockedAnd64_Inline ( + [OnParameterOnly] LONGLONG volatile *Destination, + [OnParameterOnly] LONGLONG Value + ) +{ + LONGLONG Old; + + do { + Old = *Destination; + } while ( _InterlockedCompareExchange64(Destination, + Old & Value, + Old) != Old); + + return Old; +} +