#
# Default configuration options for tracewpp for users who are using TCHARs
# and have UNICODE defined. This is the same as defaultwpp.ini except that:
#
# - %s is for WCHAR* instead of CHAR*.
# - %S is for CHAR* instead of WCHAR*.
# - %Z is for UNICODE_STRING* instead of ANSI_STRING*.
#
# Refer to the defaultwpp.ini file for additional information about the syntax
# of WPP INI files.

################################
# Default WPP configuration
################################

# our basic arithmetic types

DEFINE_SIMPLE_TYPE( XINT64, signed __int64,  ItemLongLongX, "I64x", i, 8, win:HexInt64);
DEFINE_SIMPLE_TYPE( XXINT64,signed __int64,  ItemLongLongXX,"I64X", i, 8, win:HexInt64);
DEFINE_SIMPLE_TYPE( OINT64, signed __int64,  ItemLongLongO, "I64o", i, 8, win:HexInt64);

DEFINE_SIMPLE_TYPE( SBYTE,  signed char,     ItemChar,      "c",    c, 1, win:Int8);
DEFINE_SIMPLE_TYPE( SSHORT, signed short,    ItemShort,     "hd",   h, 2, win:Int16);
DEFINE_SIMPLE_TYPE( SINT,   signed int,      ItemLong,      "d",    d, 4, win:Int32);
DEFINE_SIMPLE_TYPE( SLONG,  signed long,     ItemLong,      "ld",   l, 4, win:Int32);
DEFINE_SIMPLE_TYPE( SINT64, signed __int64,  ItemLongLong,  "I64d", i, 8, win:Int64);

DEFINE_SIMPLE_TYPE( UBYTE,  unsigned char,   ItemChar,      "c",    C, 1, win:UInt8);
DEFINE_SIMPLE_TYPE( USHORT, unsigned short,  ItemShort,     "hu",   H, 2, win:UInt16);
DEFINE_SIMPLE_TYPE( UINT,   unsigned int,    ItemLong,      "u",    D, 4, win:UInt32);
DEFINE_SIMPLE_TYPE( ULONG,  unsigned long,   ItemLong,      "lu",   L, 4, win:UInt32);
DEFINE_SIMPLE_TYPE( UINT64, unsigned __int64,ItemULongLong, "I64u", I, 8, win:UInt64);

DEFINE_SIMPLE_TYPE( DOUBLE, double,          ItemDouble,    "s",    g, 8, win:Double);

DEFINE_FLAVOR( UCHAR, UBYTE, ItemUChar, "c", win:UInt8; outType=xs:string);
DEFINE_FLAVOR( SCHAR, SBYTE, ItemChar,  "c", win:Int8;  outType=xs:string);

# arch dependent types

DEFINE_SIMPLE_TYPE( SLONGPTR, LONG_PTR,      ItemPtr,       "Id",   p, 7, win:Pointer; adapter=WPP_ADAPTER_PVOID; outType=xs:long);
DEFINE_SIMPLE_TYPE( ULONGPTR, ULONG_PTR,     ItemPtr,       "Iu",   P, 7, win:Pointer; adapter=WPP_ADAPTER_PVOID; outType=xs:unsignedLong);
DEFINE_SIMPLE_TYPE( PTR,      const void*,   ItemPtr,       "p",    q, 6, win:Pointer);
DEFINE_SIMPLE_TYPE( HANDLE,   const void*,   ItemPtr,       "p",    q, 6, win:Pointer);

DEFINE_SIMPLE_TYPE_PTR(GUID, LPCGUID, ItemGuid, "s", _guid_, 4, win:GUID);

# Predefined constants.
# Typically used in the function's prefix or suffix.
DEFINE_SIMPLE_TYPE( COMPNAME,,, "__COMPNAME__",,);
DEFINE_SIMPLE_TYPE( FILE,,,     "__FILE__",,);
DEFINE_SIMPLE_TYPE( LINE,,,     "__LINE__",,);
DEFINE_SIMPLE_TYPE( SPACE,,,    " ",,);

# The following can be used in the prefix or suffix.
DEFINE_SIMPLE_TYPE( FUNC,,,      "%!FUNC!",,);
DEFINE_SIMPLE_TYPE( LEVEL,,,     "%!LEVEL!",,);
DEFINE_SIMPLE_TYPE( KEYWORDS,,,  "%!FLAGS!",,);
DEFINE_SIMPLE_TYPE( STDPREFIX,,, "%0",,); # Only works at start of prefix. Ignored for manifest-based WPP.
DEFINE_SIMPLE_TYPE( MOD,,,       "%1!s!",,);
DEFINE_SIMPLE_TYPE( TYP,,,       "%2!s!",,);
DEFINE_SIMPLE_TYPE( TID,,,       "%3!x!",,);
DEFINE_SIMPLE_TYPE( NOW,,,       "%4!s!",,);
DEFINE_SIMPLE_TYPE( SEQ,,,       "%7!u!",,);
DEFINE_SIMPLE_TYPE( PID,,,       "%8!x!",,);
DEFINE_SIMPLE_TYPE( CPU,,,       "%9!u!",,);

# Complex types

# Strings and SID require custom processing
DEFINE_CPLX_TYPE(ASTR,  WPP_LOGASTR,  LPCSTR,             ItemString,  "s", s,     1, win:AnsiString);
DEFINE_CPLX_TYPE(ARSTR, WPP_LOGASTR,  LPCSTR,             ItemRString, "s", s,     1, win:AnsiString);
DEFINE_CPLX_TYPE(ARWSTR,WPP_LOGWSTR,  LPCWSTR,            ItemRWString,"s", S,     2, win:UnicodeString);
DEFINE_CPLX_TYPE(WSTR,  WPP_LOGWSTR,  LPCWSTR,            ItemWString, "s", S,     2, win:UnicodeString);
DEFINE_CPLX_TYPE(CSTR,  WPP_LOGPCSTR, const CSTRING*,     ItemPString, "s", z,     1, win:CountedAnsiString;    adapter=WPP_ADAPTER_PCSTR);
DEFINE_CPLX_TYPE(USTR,  WPP_LOGPUSTR, PCUNICODE_STRING,   ItemPWString,"s", Z,     2, win:CountedUnicodeString; adapter=WPP_ADAPTER_PUSTR);
DEFINE_CPLX_TYPE(ANSTR, WPP_LOGPCSTR, const ANSI_STRING*, ItemPString, "s", aZ,    1, win:CountedAnsiString;    adapter=WPP_ADAPTER_PCSTR);
DEFINE_CPLX_TYPE(sid,   WPP_LOGPSID,  PSID,               ItemSid,     "s", _sid_, 0, win:SID;                  adapter=WPP_ADAPTER_PSID);

# Raw binary data. Usage: DoTraceMessage(FLAG, "%!BIN!", WppBinary(pointer, size));
DEFINE_CPLX_TYPE(BIN,      WPP_LOGCSTR, WPP_BINARY, ItemHexDump,  "s", _zb_,  1, win:CountedBinary; adapter=WPP_ADAPTER_BIN);

# C++ string types
DEFINE_CPLX_TYPE(str,   WPP_LOGCPPSTR, const std::string&,      ItemPString,  "s", _str_,  0, win:CountedAnsiString;    adapter=WPP_ADAPTER_CPPSTR);
DEFINE_CPLX_TYPE(wstr,  WPP_LOGCPPSTR, const std::wstring&,     ItemPWString, "s", _wstr_, 0, win:CountedUnicodeString; adapter=WPP_ADAPTER_CPPSTR);
DEFINE_CPLX_TYPE(sv,    WPP_LOGCPPVEC, const std::string_view&, ItemPString,  "s", _sv_,   0, win:CountedAnsiString;    adapter=WPP_ADAPTER_CPPVEC);
DEFINE_CPLX_TYPE(wsv,   WPP_LOGCPPVEC, const std::wstring_view&,ItemPWString, "s", _wsv_,  0, win:CountedUnicodeString; adapter=WPP_ADAPTER_CPPVEC);

# Define printf-compatible types

DEFINE_FLAVOR(e,  DOUBLE,,);
DEFINE_FLAVOR(E,  DOUBLE,,);
DEFINE_FLAVOR(f,  DOUBLE,,);
DEFINE_FLAVOR(g,  DOUBLE,,);
DEFINE_FLAVOR(G,  DOUBLE,,);

DEFINE_FLAVOR(c,  SCHAR,,);
DEFINE_FLAVOR(hc, SCHAR,,);
DEFINE_FLAVOR(lc, SSHORT,,);
DEFINE_FLAVOR(wc, SSHORT,,);
DEFINE_FLAVOR(C,  SSHORT,,);

DEFINE_FLAVOR(s,  WSTR,,); # %s is WIDE with TCHARUNIwpp.ini.
DEFINE_FLAVOR(hs, ASTR,,);
DEFINE_FLAVOR(S,  ASTR,,); # %S is ANSI with TCHARUNIwpp.ini.
DEFINE_FLAVOR(ws, WSTR,,);
DEFINE_FLAVOR(ls, WSTR,,);

DEFINE_FLAVOR(hi, SSHORT,,);
DEFINE_FLAVOR(hd, SSHORT,,);
DEFINE_FLAVOR(hu, USHORT,,"u");
DEFINE_FLAVOR(hx, USHORT,,"x", win:UInt16; outType=win:HexInt16);
DEFINE_FLAVOR(hX, USHORT,,"X", win:UInt16; outType=win:HexInt16);
DEFINE_FLAVOR(ho, USHORT,,"o", win:UInt16; outType=win:HexInt16);

DEFINE_FLAVOR(Id, ULONGPTR,,"Id");
DEFINE_FLAVOR(Iu, ULONGPTR,,"Iu");
DEFINE_FLAVOR(Ix, ULONGPTR,,"Ix", win:Pointer; adapter=WPP_ADAPTER_PVOID);
DEFINE_FLAVOR(IX, ULONGPTR,,"IX", win:Pointer; adapter=WPP_ADAPTER_PVOID);
DEFINE_FLAVOR(Io, ULONGPTR,,"Io", win:Pointer; adapter=WPP_ADAPTER_PVOID);

DEFINE_FLAVOR(i, SINT,,);
DEFINE_FLAVOR(d, SINT,,);
DEFINE_FLAVOR(u, UINT,,"u");
DEFINE_FLAVOR(x, UINT,,"x", win:HexInt32);
DEFINE_FLAVOR(X, UINT,,"X", win:HexInt32);
DEFINE_FLAVOR(o, UINT,,"o", win:HexInt32);

DEFINE_FLAVOR(cccc, SINT, ItemChar4, "s", win:AnsiString; length=4; adapter=WPP_ADAPTER_CCCC);

DEFINE_FLAVOR(li, SLONG,,);
DEFINE_FLAVOR(ld, SLONG,,);
DEFINE_FLAVOR(lu, ULONG,,"u");
DEFINE_FLAVOR(lx, ULONG,,"x", win:HexInt32);
DEFINE_FLAVOR(lX, ULONG,,"X", win:HexInt32);
DEFINE_FLAVOR(lo, ULONG,,"o", win:HexInt32);

DEFINE_FLAVOR(I64d, SINT64,,);
DEFINE_FLAVOR(I64u, UINT64,,);
DEFINE_FLAVOR(I64x, XINT64,,"I64x");
DEFINE_FLAVOR(I64X, XXINT64,,"I64X");
DEFINE_FLAVOR(I64o, OINT64,,"I64o");

DEFINE_FLAVOR(lld, SINT64,,);
DEFINE_FLAVOR(llu, UINT64,,);
DEFINE_FLAVOR(llx, XINT64,,"I64x");
DEFINE_FLAVOR(llX, XXINT64,,"I64X");
DEFINE_FLAVOR(llo, OINT64,,"I64o");

DEFINE_FLAVOR(p, PTR,,);

DEFINE_FLAVOR(Z,  USTR,,); # %Z is PCUNICODE_STRING with TCHARUNIwpp.ini.
DEFINE_FLAVOR(wZ, USTR,,);
DEFINE_FLAVOR(z,  CSTR,,);
DEFINE_FLAVOR(hZ, CSTR,,);

# default formats for those who don't care to provide their own strings

DEFINE_FLAVOR(XBYTE, SBYTE,, "02x", win:UInt8; outType=win:HexInt8);
DEFINE_FLAVOR(OBYTE, SBYTE,, "o", win:UInt8; outType=win:HexInt8);

DEFINE_FLAVOR(XSHORT, SSHORT,, "04hX", win:UInt16; outType=win:HexInt16);
DEFINE_FLAVOR(OSHORT, SSHORT,, "ho", win:UInt16; outType=win:HexInt16);

DEFINE_FLAVOR(XINT, SINT,, "08x", win:HexInt32);
DEFINE_FLAVOR(OINT, SINT,, "o", win:HexInt32);

DEFINE_FLAVOR(XLONG, SLONG,, "08lX", win:HexInt32);
DEFINE_FLAVOR(OLONG, SLONG,, "lo", win:HexInt32);

DEFINE_FLAVOR(XLONGPTR, SLONGPTR,,"Ix", win:Pointer; adapter=WPP_ADAPTER_PVOID);
DEFINE_FLAVOR(OLONGPTR, SLONGPTR,,"Io", win:Pointer; adapter=WPP_ADAPTER_PVOID);

# special formats

DEFINE_FLAVOR(IPADDR,      UINT,   ItemIPAddr,      "s", win:UInt32;   outType=win:IPv4);
DEFINE_FLAVOR(PORT,        USHORT, ItemPort,        "s", win:UInt16;   outType=win:Port);
DEFINE_FLAVOR(STATUS,      SINT,   ItemNTSTATUS,    "s", win:HexInt32; outType=win:NTSTATUS);
DEFINE_FLAVOR(WINERROR,    UINT,   ItemWINERROR,    "s", win:UInt32;   outType=win:Win32Error);
DEFINE_FLAVOR(HRESULT,     SINT,   ItemHRESULT,     "s", win:Int32;    outType=win:HResult);

# Note: The %!NDIS_STATUS! and %!NDIS_OID! types work for for TMF-based WPP but
# do not work well with manifest-based WPP. Manifest-based ETW decoders will
# treat %!NDIS_STATUS! and %!NDIS_OID! items as HexInt32 items.
DEFINE_FLAVOR(NDIS_STATUS, SINT,   ItemNDIS_STATUS, "s", win:HexInt32);
DEFINE_FLAVOR(NDIS_OID,    UINT,   ItemNDIS_OID,    "s", win:HexInt32);

DEFINE_FLAVOR(ipaddr,IPADDR,,);
DEFINE_FLAVOR(port,PORT,,);
DEFINE_FLAVOR(status,STATUS,,);
DEFINE_FLAVOR(hresult,HRESULT,,);
DEFINE_FLAVOR(winerr,WINERROR,,);
DEFINE_FLAVOR(guid,GUID,,);

# time related stuff

DEFINE_FLAVOR(TIMESTAMP, SINT64, ItemTimestamp, "s", win:FILETIME; adapter=WPP_ADAPTER_PFILETIME);
DEFINE_FLAVOR(TIME,      SINT64, ItemTimestamp, "s", win:FILETIME; adapter=WPP_ADAPTER_PFILETIME);
DEFINE_FLAVOR(DATE,      SINT64, ItemTimestamp, "s", win:FILETIME; adapter=WPP_ADAPTER_PFILETIME);
DEFINE_FLAVOR(WAITTIME,  SINT64, ItemTimestamp, "s", win:FILETIME; adapter=WPP_ADAPTER_PFILETIME);

DEFINE_FLAVOR(due,       SINT64, ItemWaitTime,  "s", win:FILETIME; adapter=WPP_ADAPTER_PFILETIME);
DEFINE_FLAVOR(delta,     SINT64, ItemTimeDelta, "s");
DEFINE_FLAVOR(datetime,  SINT64, ItemTimestamp, "s", win:FILETIME; adapter=WPP_ADAPTER_PFILETIME);

# enumeration types

DEFINE_FLAVOR(ItemListByte,  SBYTE,  ItemListByte,  "s", win:UInt8);
DEFINE_FLAVOR(ItemListShort, SSHORT, ItemListShort, "s", win:UInt16);
DEFINE_FLAVOR(ItemListLong,  SLONG,  ItemListLong,  "s", win:UInt32);

DEFINE_FLAVOR(ItemSetByte,   UBYTE,  ItemSetByte,   "s", win:UInt8;    outType=win:HexInt8);
DEFINE_FLAVOR(ItemSetShort,  USHORT, ItemSetShort,  "s", win:UInt16;   outType=win:HexInt16);
DEFINE_FLAVOR(ItemSetLong,   ULONG,  ItemSetLong,   "s", win:HexInt32);

# Note: The "ItemEnum" and "ItemFlagsEnum" types work for for TMF-based WPP but
# do not work well with manifest-based WPP. Manifest-based ETW decoders will
# treat types based on "ItemEnum" as UInt32 and will treat types based on
# "ItemFlagsEnum" as HexInt32. For better results, use ItemListLong,
# ItemSetLong, or a "begin_wpp enum" block for your enumeration.
DEFINE_FLAVOR(ItemEnum,      ULONG, ItemEnum,       "s");
DEFINE_FLAVOR(ItemFlagsEnum, ULONG, ItemFlagsEnum,  "s", win:HexInt32);

DEFINE_FLAVOR(CLSID, GUID, ItemCLSID,  "s");
DEFINE_FLAVOR(LIBID, GUID, ItemLIBID,  "s");
DEFINE_FLAVOR(IID,   GUID, ItemIID,    "s");

CUSTOM_TYPE(b1,  ItemSetByte(1,2,3,4,5,6,7,8) );
CUSTOM_TYPE(b2,  ItemSetShort(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16) );
CUSTOM_TYPE(b4,  ItemSetLong(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32) );

CUSTOM_TYPE(bool,    ItemListLong(false,true) );
CUSTOM_TYPE(bool16,  ItemListShort(false,true) );
CUSTOM_TYPE(bool8,   ItemListByte(false,true) );
CUSTOM_TYPE(BOOLEAN, ItemListByte(FALSE,TRUE) );

CUSTOM_TYPE(irql,    ItemListByte(Low,APC,DPC) );

CUSTOM_TYPE(pnpmn,   ItemListByte(IRP_MN_START_DEVICE,IRP_MN_QUERY_REMOVE_DEVICE,IRP_MN_REMOVE_DEVICE,IRP_MN_CANCEL_REMOVE_DEVICE,IRP_MN_STOP_DEVICE,IRP_MN_QUERY_STOP_DEVICE,IRP_MN_CANCEL_STOP_DEVICE,IRP_MN_QUERY_DEVICE_RELATIONS,IRP_MN_QUERY_INTERFACE,IRP_MN_QUERY_CAPABILITIES,IRP_MN_QUERY_RESOURCES,IRP_MN_QUERY_RESOURCE_REQUIREMENTS,IRP_MN_QUERY_DEVICE_TEXT,IRP_MN_FILTER_RESOURCE_REQUIREMENTS,IRP_MN_PNP_14,IRP_MN_READ_CONFIG,IRP_MN_WRITE_CONFIG,IRP_MN_EJECT,IRP_MN_SET_LOCK,IRP_MN_QUERY_ID,IRP_MN_QUERY_PNP_DEVICE_STATE,IRP_MN_QUERY_BUS_INFORMATION,IRP_MN_DEVICE_USAGE_NOTIFICATION,IRP_MN_SURPRISE_REMOVAL) );
CUSTOM_TYPE(sysctrl, ItemListByte(IRP_MN_QUERY_ALL_DATA,IRP_MN_QUERY_SINGLE_INSTANCE, IRP_MN_CHANGE_SINGLE_INSTANCE, IRP_MN_CHANGE_SINGLE_ITEM, IRP_MN_ENABLE_EVENTS, IRP_MN_DISABLE_EVENTS, IRP_MN_ENABLE_COLLECTION, IRP_MN_DISABLE_COLLECTION, IRP_MN_REGINFO, IRP_MN_EXECUTE_METHOD, IRP_MN_Reserved_0a, IRP_MN_REGINFO_EX) );
CUSTOM_TYPE(pnpmj,   ItemListByte(IRP_MJ_CREATE,IRP_MJ_CREATE_NAMED_PIPE,IRP_MJ_CLOSE,IRP_MJ_READ,IRP_MJ_WRITE,IRP_MJ_QUERY_INFORMATION,IRP_MJ_SET_INFORMATION,IRP_MJ_QUERY_EA,IRP_MJ_SET_EA,IRP_MJ_FLUSH_BUFFERS,IRP_MJ_QUERY_VOLUME_INFORMATION,IRP_MJ_SET_VOLUME_INFORMATION,IRP_MJ_DIRECTORY_CONTROL,IRP_MJ_FILE_SYSTEM_CONTROL,IRP_MJ_DEVICE_CONTROL,IRP_MJ_INTERNAL_DEVICE_CONTROL,IRP_MJ_SHUTDOWN,IRP_MJ_LOCK_CONTROL,IRP_MJ_CLEANUP,IRP_MJ_CREATE_MAILSLOT,IRP_MJ_QUERY_SECURITY,IRP_MJ_SET_SECURITY,IRP_MJ_POWER,IRP_MJ_SYSTEM_CONTROL,IRP_MJ_DEVICE_CHANGE,IRP_MJ_QUERY_QUOTA,IRP_MJ_SET_QUOTA,IRP_MJ_PNP) );

# Built-in levels (for use with manifests)

DEFINE_BUILTIN_LEVEL(win:LogAlways,        0, WINEVENT_LEVEL_LOG_ALWAYS);
DEFINE_BUILTIN_LEVEL(win:Critical,         1, WINEVENT_LEVEL_CRITICAL, TRACE_LEVEL_CRITICAL);
DEFINE_BUILTIN_LEVEL(win:Error,            2, WINEVENT_LEVEL_ERROR,    TRACE_LEVEL_ERROR);
DEFINE_BUILTIN_LEVEL(win:Warning,          3, WINEVENT_LEVEL_WARNING,  TRACE_LEVEL_WARNING);
DEFINE_BUILTIN_LEVEL(win:Informational,    4, WINEVENT_LEVEL_INFO,     TRACE_LEVEL_INFORMATION);
DEFINE_BUILTIN_LEVEL(win:Verbose,          5, WINEVENT_LEVEL_VERBOSE,  TRACE_LEVEL_VERBOSE);
DEFINE_BUILTIN_LEVEL(win:ReservedLevel6,   6, WINEVENT_LEVEL_RESERVED_6);
DEFINE_BUILTIN_LEVEL(win:ReservedLevel7,   7, WINEVENT_LEVEL_RESERVED_7);
DEFINE_BUILTIN_LEVEL(win:ReservedLevel8,   8, WINEVENT_LEVEL_RESERVED_8);
DEFINE_BUILTIN_LEVEL(win:ReservedLevel9,   9, WINEVENT_LEVEL_RESERVED_9);
DEFINE_BUILTIN_LEVEL(win:ReservedLevel10, 10, WINEVENT_LEVEL_RESERVED_10);
DEFINE_BUILTIN_LEVEL(win:ReservedLevel11, 11, WINEVENT_LEVEL_RESERVED_11);
DEFINE_BUILTIN_LEVEL(win:ReservedLevel12, 12, WINEVENT_LEVEL_RESERVED_12);
DEFINE_BUILTIN_LEVEL(win:ReservedLevel13, 13, WINEVENT_LEVEL_RESERVED_13);
DEFINE_BUILTIN_LEVEL(win:ReservedLevel14, 14, WINEVENT_LEVEL_RESERVED_14);
DEFINE_BUILTIN_LEVEL(win:ReservedLevel15, 15, WINEVENT_LEVEL_RESERVED_15);

# Built-in keywords (for use with manifests)

DEFINE_BUILTIN_KEYWORD(win:AnyKeyword,        0x0,                WINEVT_KEYWORD_ANY);
DEFINE_BUILTIN_KEYWORD(win:ResponseTime,      0x0001000000000000, WINEVENT_KEYWORD_RESPONSE_TIME);
DEFINE_BUILTIN_KEYWORD(win:WDIContext,        0x0002000000000000, WINEVENT_KEYWORD_WDI_CONTEXT);
DEFINE_BUILTIN_KEYWORD(win:WDIDiag,           0x0004000000000000, WINEVENT_KEYWORD_WDI_DIAG);
DEFINE_BUILTIN_KEYWORD(win:SQM,               0x0008000000000000, WINEVENT_KEYWORD_SQM);
DEFINE_BUILTIN_KEYWORD(win:AuditFailure,      0x0010000000000000, WINEVENT_KEYWORD_AUDIT_FAILURE);
DEFINE_BUILTIN_KEYWORD(win:AuditSuccess,      0x0020000000000000, WINEVENT_KEYWORD_AUDIT_SUCCESS);
DEFINE_BUILTIN_KEYWORD(win:CorrelationHint,   0x0040000000000000, WINEVENT_KEYWORD_CORRELATION_HINT);
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword56, 0x0100000000000000, WINEVENT_KEYWORD_RESERVED_56);
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword57, 0x0200000000000000, WINEVENT_KEYWORD_RESERVED_57);
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword58, 0x0400000000000000, WINEVENT_KEYWORD_RESERVED_58);
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword59, 0x0800000000000000, WINEVENT_KEYWORD_RESERVED_59);
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword60, 0x1000000000000000, WINEVENT_KEYWORDE_RESERVED_60);
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword61, 0x2000000000000000, WINEVENT_KEYWORD_RESERVED_61);
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword62, 0x4000000000000000, WINEVENT_KEYWORD_RESERVED_62);
DEFINE_BUILTIN_KEYWORD(win:ReservedKeyword63, 0x8000000000000000, WINEVENT_KEYWORD_RESERVED_63);

# default tracing macros
FUNC DoTraceMessage(LEVEL,MSG,...); # Uses WPP-provided ENABLED/LOGGER macros
FUNC DoDebugTrace(TRACELEVEL,MSG,...); # Requires used-defined ENABLED/LOGGER macros

# default prefix (use traceprt default)
USEPREFIX(*,"%!STDPREFIX!"); # traceprt will add standard prefix

# the source file that calls WPP_INIT_TRACING is given special treatment
WPP_FLAGS(-lookfor:WPP_INIT_TRACING);