diff --git a/lib/linux64/tier1.a b/lib/linux64/tier1.a deleted file mode 100644 index 3db87723..00000000 Binary files a/lib/linux64/tier1.a and /dev/null differ diff --git a/lib/public/win64/tier1.lib b/lib/public/win64/tier1.lib deleted file mode 100644 index 0b7d9548..00000000 Binary files a/lib/public/win64/tier1.lib and /dev/null differ diff --git a/linux_sdk/Makefile.tier1 b/linux_sdk/Makefile.tier1 deleted file mode 100644 index 39e503f9..00000000 --- a/linux_sdk/Makefile.tier1 +++ /dev/null @@ -1,55 +0,0 @@ -# -# Tier1 Static Library Makefile -# - -override NAME = tier1 - -LIB_SRC_DIR = $(SRC_DIR)/$(NAME) -PUBLIC_SRC_DIR = $(SRC_DIR)/public -TIER0_PUBLIC_SRC_DIR = $(SRC_DIR)/public/tier0 -TIER1_PUBLIC_SRC_DIR = $(SRC_DIR)/public/tier1 - -LIB_OBJ_DIR=$(BUILD_OBJ_DIR)/$(NAME) - -# Extension of linux static library -override SHLIBEXT = a - -INCLUDEDIRS = -I$(PUBLIC_SRC_DIR) -I$(TIER0_PUBLIC_SRC_DIR) -I$(TIER1_PUBLIC_SRC_DIR) -D_LIB -DTIER1_STATIC_LIB - -DO_CC = $(CPLUS) $(INCLUDEDIRS) -DARCH=$(ARCH) - -ifeq "$(DEBUG)" "true" - DO_CC += $(DBG_DEFINES) $(DBG_CFLAGS) -else - DO_CC += -DNDEBUG $(CFLAGS) -endif - -DO_CC += -o $@ -c $< - -##################################################################### - -LIB_OBJS= \ - $(LIB_OBJ_DIR)/bitbuf.o \ - $(LIB_OBJ_DIR)/generichash.o \ - $(LIB_OBJ_DIR)/rangecheckedvar.o \ - $(LIB_OBJ_DIR)/tier1.o \ - $(LIB_OBJ_DIR)/utlbufferutil.o \ - -all: dirs $(NAME).$(SHLIBEXT) - -dirs: - -mkdir -p $(BUILD_OBJ_DIR) - -mkdir -p $(LIB_OBJ_DIR) - -$(NAME).$(SHLIBEXT): $(LIB_OBJS) - $(AR) $(LIB_DIR)/$@ $(LIB_OBJS) - -$(LIB_OBJ_DIR)/%.o: $(LIB_SRC_DIR)/%.cpp - $(DO_CC) - -install: - cp -f $(NAME).$(SHLIBEXT) $(LIB_DIR)/$(NAME).$(SHLIBEXT) - -clean: - -rm -rf $(LIB_OBJ_DIR) - diff --git a/public/gametrace.h b/public/gametrace.h index 2070c249..d50bb3c7 100644 --- a/public/gametrace.h +++ b/public/gametrace.h @@ -265,7 +265,7 @@ public: m_sSurfaceProperty = m_tempSurfaceProp; m_sBoneName = m_tempBoneName; - m_nBoneNameHash = MakeStringToken( m_tempBoneName ); + m_nBoneNameHash = CUtlStringToken( m_tempBoneName ); m_cRenderColor.SetColor( 0, 0, 0, 0 ); } diff --git a/public/networksystem/inetworkserializer.h b/public/networksystem/inetworkserializer.h index b883055e..33c8caf0 100644 --- a/public/networksystem/inetworkserializer.h +++ b/public/networksystem/inetworkserializer.h @@ -17,8 +17,6 @@ #include -#define CODEGEN_HASH_TOKEN (0x3501A674) - class CNetMessage; class CNetworkSerializerCodeGenDatabase; class CCheckTransmitInfo; @@ -226,7 +224,7 @@ struct SerializerFieldLookup_t }; template<> struct DefaultEqualFunctor { bool operator()( SerializerFieldLookup_t a, SerializerFieldLookup_t b ) const { return a.m_FieldName == b.m_FieldName; } }; -template<> struct DefaultHashFunctor { unsigned int operator()( SerializerFieldLookup_t a ) const { return MurmurHash2LowerCase( a.m_FieldName.String(), CODEGEN_HASH_TOKEN ); } }; +template<> struct DefaultHashFunctor { unsigned int operator()( SerializerFieldLookup_t a ) const { return HashStringCaseless( a.m_FieldName.String() ); } }; class CNetworkSerializerClassInfo { diff --git a/public/tier1/generichash.h b/public/tier1/generichash.h index f04e12c3..83a4c4d6 100644 --- a/public/tier1/generichash.h +++ b/public/tier1/generichash.h @@ -12,23 +12,215 @@ #pragma once #endif +#include +#include + #include "platform.h" //----------------------------------------------------------------------------- -unsigned FASTCALL HashString( const char *pszKey ); -unsigned FASTCALL HashStringCaseless( const char *pszKey ); -unsigned FASTCALL HashStringFastCaselessConventional( const char *pszKey ); -unsigned FASTCALL Hash4( const void *pKey ); -unsigned FASTCALL Hash8( const void *pKey ); -unsigned FASTCALL Hash12( const void *pKey ); -unsigned FASTCALL Hash16( const void *pKey ); -unsigned FASTCALL HashBlock( const void *pKey, unsigned size ); +// AMNOTE: To not pollute global namespace, these are hidden under namespace +namespace GenericHash +{ + namespace detail + { + // Branchless constexpr ascii tolower method. + // Checks if value is in range of A-Z + // if so adds 32 to the base char symbol + constexpr char to_lower( char c ) + { + return c + (((c >= 'A') & (c <= 'Z')) << 5); + } -unsigned FASTCALL HashInt( const int key ); + static constexpr uint32 kRandVals[256] = + { + 238, 164, 191, 168, 115, 16, 142, 11, 213, 214, 57, 151, 248, 252, 26, 198, + 13, 105, 102, 25, 43, 42, 227, 107, 210, 251, 86, 66, 83, 193, 126, 108, + 131, 3, 64, 186, 192, 81, 37, 158, 39, 244, 14, 254, 75, 30, 2, 88, + 172, 176, 255, 69, 0, 45, 116, 139, 23, 65, 183, 148, 33, 46, 203, 20, + 143, 205, 60, 197, 118, 9, 171, 51, 233, 135, 220, 49, 71, 184, 82, 109, + 36, 161, 169, 150, 63, 96, 173, 125, 113, 67, 224, 78, 232, 215, 35, 219, + 79, 181, 41, 229, 149, 153, 111, 217, 21, 72, 120, 163, 133, 40, 122, 140, + 208, 231, 211, 200, 160, 182, 104, 110, 178, 237, 15, 101, 27, 50, 24, 189, + 177, 130, 187, 92, 253, 136, 100, 212, 19, 174, 70, 22, 170, 206, 162, 74, + 247, 5, 47, 32, 179, 117, 132, 195, 124, 123, 245, 128, 236, 223, 12, 84, + 54, 218, 146, 228, 157, 94, 106, 31, 17, 29, 194, 34, 56, 134, 239, 246, + 241, 216, 127, 98, 7, 204, 154, 152, 209, 188, 48, 61, 87, 97, 225, 85, + 90, 167, 155, 112, 145, 114, 141, 93, 250, 4, 201, 156, 38, 89, 226, 196, + 1, 235, 44, 180, 159, 121, 119, 166, 190, 144, 10, 91, 76, 230, 221, 80, + 207, 55, 58, 53, 175, 8, 6, 52, 68, 242, 18, 222, 103, 249, 147, 129, + 138, 243, 28, 185, 62, 59, 240, 202, 234, 99, 77, 73, 199, 137, 95, 165, + }; + }; +}; + +inline uint32 HashStringFastCaselessConventional( const char *pszKey ) +{ + uint32 hash = 0xAAAAAAAA; // Alternating 1's and 0's to maximize the effect of the later multiply and add + + for(; *pszKey; pszKey++) + { + hash = ((hash << 5) + hash) + (uint8)tolower( *pszKey ); + } + + return hash; +} + +inline uint32 HashStringConventional( const char *pszKey ) +{ + uint32 hash = 0xAAAAAAAA; // Alternating 1's and 0's to maximize the effect of the later multiply and add + + for(; *pszKey; pszKey++) + { + hash = ((hash << 5) + hash) + (uint8)*pszKey; + } + + return hash; +} + +inline uint32 HashInt( const int n ) +{ + uint32 even = 0, odd = 0; + even = GenericHash::detail::kRandVals[n & 0xff]; + odd = GenericHash::detail::kRandVals[((n >> 8) & 0xff)]; + + even = GenericHash::detail::kRandVals[odd ^ (n >> 24)]; + odd = GenericHash::detail::kRandVals[even ^ ((n >> 16) & 0xff)]; + even = GenericHash::detail::kRandVals[odd ^ ((n >> 8) & 0xff)]; + odd = GenericHash::detail::kRandVals[even ^ (n & 0xff)]; + + return (even << 8) | odd; +} + +inline uint32 Hash4( const void *pKey ) +{ + const uint32 *p = (const uint32 *)pKey; + uint32 even = 0, odd = 0, n = 0; + + n = *p; + even = GenericHash::detail::kRandVals[n & 0xff]; + odd = GenericHash::detail::kRandVals[((n >> 8) & 0xff)]; + + even = GenericHash::detail::kRandVals[odd ^ (n >> 24)]; + odd = GenericHash::detail::kRandVals[even ^ ((n >> 16) & 0xff)]; + even = GenericHash::detail::kRandVals[odd ^ ((n >> 8) & 0xff)]; + odd = GenericHash::detail::kRandVals[even ^ (n & 0xff)]; + + return (even << 8) | odd; +} + +inline uint32 Hash8( const void *pKey ) +{ + const uint32 *p = (const uint32 *)pKey; + uint32 even = 0, odd = 0, n = 0; + + n = *p; + even = GenericHash::detail::kRandVals[n & 0xff]; + odd = GenericHash::detail::kRandVals[((n >> 8) & 0xff)]; + + even = GenericHash::detail::kRandVals[odd ^ (n >> 24)]; + odd = GenericHash::detail::kRandVals[even ^ ((n >> 16) & 0xff)]; + even = GenericHash::detail::kRandVals[odd ^ ((n >> 8) & 0xff)]; + odd = GenericHash::detail::kRandVals[even ^ (n & 0xff)]; + + n = *(p + 1); + even = GenericHash::detail::kRandVals[odd ^ (n >> 24)]; + odd = GenericHash::detail::kRandVals[even ^ ((n >> 16) & 0xff)]; + even = GenericHash::detail::kRandVals[odd ^ ((n >> 8) & 0xff)]; + odd = GenericHash::detail::kRandVals[even ^ (n & 0xff)]; + + return (even << 8) | odd; +} + +inline uint32 Hash12( const void *pKey ) +{ + const uint32 *p = (const uint32 *)pKey; + uint32 even = 0, odd = 0, n = 0; + + n = *p; + even = GenericHash::detail::kRandVals[n & 0xff]; + odd = GenericHash::detail::kRandVals[((n >> 8) & 0xff)]; + + even = GenericHash::detail::kRandVals[odd ^ (n >> 24)]; + odd = GenericHash::detail::kRandVals[even ^ ((n >> 16) & 0xff)]; + even = GenericHash::detail::kRandVals[odd ^ ((n >> 8) & 0xff)]; + odd = GenericHash::detail::kRandVals[even ^ (n & 0xff)]; + + n = *(p + 1); + even = GenericHash::detail::kRandVals[odd ^ (n >> 24)]; + odd = GenericHash::detail::kRandVals[even ^ ((n >> 16) & 0xff)]; + even = GenericHash::detail::kRandVals[odd ^ ((n >> 8) & 0xff)]; + odd = GenericHash::detail::kRandVals[even ^ (n & 0xff)]; + + n = *(p + 2); + even = GenericHash::detail::kRandVals[odd ^ (n >> 24)]; + odd = GenericHash::detail::kRandVals[even ^ ((n >> 16) & 0xff)]; + even = GenericHash::detail::kRandVals[odd ^ ((n >> 8) & 0xff)]; + odd = GenericHash::detail::kRandVals[even ^ (n & 0xff)]; + + return (even << 8) | odd; +} + +inline uint32 Hash16( const void *pKey ) +{ + const uint32 *p = (const uint32 *)pKey; + uint32 even = 0, odd = 0, n = 0; + + n = *p; + even = GenericHash::detail::kRandVals[n & 0xff]; + odd = GenericHash::detail::kRandVals[((n >> 8) & 0xff)]; + + even = GenericHash::detail::kRandVals[odd ^ (n >> 24)]; + odd = GenericHash::detail::kRandVals[even ^ ((n >> 16) & 0xff)]; + even = GenericHash::detail::kRandVals[odd ^ ((n >> 8) & 0xff)]; + odd = GenericHash::detail::kRandVals[even ^ (n & 0xff)]; + + n = *(p + 1); + even = GenericHash::detail::kRandVals[odd ^ (n >> 24)]; + odd = GenericHash::detail::kRandVals[even ^ ((n >> 16) & 0xff)]; + even = GenericHash::detail::kRandVals[odd ^ ((n >> 8) & 0xff)]; + odd = GenericHash::detail::kRandVals[even ^ (n & 0xff)]; + + n = *(p + 2); + even = GenericHash::detail::kRandVals[odd ^ (n >> 24)]; + odd = GenericHash::detail::kRandVals[even ^ ((n >> 16) & 0xff)]; + even = GenericHash::detail::kRandVals[odd ^ ((n >> 8) & 0xff)]; + odd = GenericHash::detail::kRandVals[even ^ (n & 0xff)]; + + n = *(p + 3); + even = GenericHash::detail::kRandVals[odd ^ (n >> 24)]; + odd = GenericHash::detail::kRandVals[even ^ ((n >> 16) & 0xff)]; + even = GenericHash::detail::kRandVals[odd ^ ((n >> 8) & 0xff)]; + odd = GenericHash::detail::kRandVals[even ^ (n & 0xff)]; + + return (even << 8) | odd; +} + +inline uint32 HashBlock( const void *pKey, uint32 size ) +{ + const uint8 *k = (const uint8 *)pKey; + uint32 even = 0, odd = 0, n = 0; + + while(size) + { + --size; + n = *k++; + even = GenericHash::detail::kRandVals[odd ^ n]; + if(size) + { + --size; + n = *k++; + odd = GenericHash::detail::kRandVals[even ^ n]; + } + else + break; + } + + return (even << 8) | odd; +} // hash a uint32 into a uint32 -FORCEINLINE uint32 HashIntAlternate( uint32 n) +inline uint32 HashIntAlternate( uint32 n) { n = ( n + 0x7ed55d16 ) + ( n << 12 ); n = ( n ^ 0xc761c23c ) ^ ( n >> 19 ); @@ -39,10 +231,10 @@ FORCEINLINE uint32 HashIntAlternate( uint32 n) return n; } -inline unsigned HashIntConventional( const int n ) // faster but less effective +inline uint32 HashIntConventional( const int n ) // faster but less effective { // first byte - unsigned hash = 0xAAAAAAAA + (n & 0xFF); + uint32 hash = 0xAAAAAAAA + (n & 0xFF); // second byte hash = ( hash << 5 ) + hash + ( (n >> 8) & 0xFF ); // third byte @@ -56,7 +248,7 @@ inline unsigned HashIntConventional( const int n ) // faster but less effective line on a PowerPC, and therefore took hundreds of clocks to execute! byte *p = (byte *)&n; - unsigned hash = 0xAAAAAAAA + *p++; + uint32 hash = 0xAAAAAAAA + *p++; hash = ( ( hash << 5 ) + hash ) + *p++; hash = ( ( hash << 5 ) + hash ) + *p++; return ( ( hash << 5 ) + hash ) + *p; @@ -66,7 +258,7 @@ inline unsigned HashIntConventional( const int n ) // faster but less effective //----------------------------------------------------------------------------- template -inline unsigned HashItem( const T &item ) +inline uint32 HashItem( const T &item ) { // TODO: Confirm comiler optimizes out unused paths if ( sizeof(item) == 4 ) @@ -81,42 +273,222 @@ inline unsigned HashItem( const T &item ) return HashBlock( &item, sizeof(item) ); } -template <> inline unsigned HashItem(const int &key ) +template <> inline uint32 HashItem(const int &key ) { return HashInt( key ); } -template <> inline unsigned HashItem(const unsigned &key ) +template <> inline uint32 HashItem(const uint32 &key ) { return HashInt( (int)key ); } -template<> inline unsigned HashItem(const char * const &pszKey ) +//----------------------------------------------------------------------------- + + +//----------------------------------------------------------------------------- +// MurmurHash variants +//----------------------------------------------------------------------------- + +// AMNOTE: Special case for const string arrays to make compiler happy about const folding the hash value +// during compilation, in turn this results in a hash compiled in instead of byte code to compute the hash. +// Very picky about its internal code so edit with care and little of changes could break constant folding. +// In complex cases might still result in a bytecode being emitted instead of direct hash. +template +inline uint32 MurmurHash2( const char (&key)[N], uint32 seed ) +{ + // 'm' and 'r' are mixing constants generated offline. + // They're not really 'magic', they just happen to work well. + + const uint32 m = 0x5bd1e995; + const int r = 24; + + // Initialize the hash to a 'random' value + + uint32 len = N - 1; + uint32 h = seed ^ len; + + // Mix 4 bytes at a time into the hash + // AMNOTE: ptr casting is not allowed during const folding, so can't use that here + uint32 offset = 0; + + while(len >= 4) + { + uint32 k = 0; + if constexpr(CASELESS) + { + // AMNOTE: Double casting is required to prevent sign extension bugs that could propagate + // since initial buffer is a signed char, while in original code it casted buffer to unsigned char first + k = static_cast(static_cast(GenericHash::detail::to_lower( key[offset + 0] ))) | + (static_cast(static_cast(GenericHash::detail::to_lower( key[offset + 1] ))) << 8) | + (static_cast(static_cast(GenericHash::detail::to_lower( key[offset + 2] ))) << 16) | + (static_cast(static_cast(GenericHash::detail::to_lower( key[offset + 3] ))) << 24); + } + else + { + k = static_cast(static_cast(key[offset + 0])) | + (static_cast(static_cast(key[offset + 1])) << 8) | + (static_cast(static_cast(key[offset + 2])) << 16) | + (static_cast(static_cast(key[offset + 3])) << 24); + } + + k *= m; + k ^= k >> r; + k *= m; + + h *= m; + h ^= k; + + len -= 4; + offset += 4; + } + + // AMNOTE: switch case breaks const folding during inlining, so can't use it here + if constexpr(CASELESS) + { + if constexpr(((N - 1) % 4) >= 3) h ^= static_cast(static_cast(GenericHash::detail::to_lower( key[offset + 2] ))) << 16; + if constexpr(((N - 1) % 4) >= 2) h ^= static_cast(static_cast(GenericHash::detail::to_lower( key[offset + 1] ))) << 8; + if constexpr(((N - 1) % 4) >= 1) + { + h ^= static_cast(static_cast(GenericHash::detail::to_lower( key[offset + 0] ))); + h *= m; + } + } + else + { + if constexpr(((N - 1) % 4) >= 3) h ^= static_cast(static_cast(key[offset + 2])) << 16; + if constexpr(((N - 1) % 4) >= 2) h ^= static_cast(static_cast(key[offset + 1])) << 8; + if constexpr(((N - 1) % 4) >= 1) + { + h ^= static_cast(static_cast(key[offset])); + h *= m; + } + } + + // Do a few final mixes of the hash to ensure the last few + // bytes are well-incorporated.2 + + h ^= h >> 13; + h *= m; + h ^= h >> 15; + + return h; +} + +// AMNOTE: MurmurHash2 variant for any arbitrary type buffer, +// also supports hashing caseless version of strings, +// and is mostly relevant for runtime strings if so. +// Prefer the const string array variant if possible due to constant folding optimizations. +template +inline uint32 MurmurHash2( const void *key, int len, uint32 seed ) +{ + // 'm' and 'r' are mixing constants generated offline. + // They're not really 'magic', they just happen to work well. + + const uint32 m = 0x5bd1e995; + const int r = 24; + + // Initialize the hash to a 'random' value + + uint32 h = seed ^ len; + + // Mix 4 bytes at a time into the hash + + const unsigned char *data = (const unsigned char *)key; + + while(len >= 4) + { + uint32 k = 0; + if constexpr (CASELESS) + { + k = static_cast(static_cast(GenericHash::detail::to_lower( data[0] ))) | + (static_cast(static_cast(GenericHash::detail::to_lower( data[1] ))) << 8) | + (static_cast(static_cast(GenericHash::detail::to_lower( data[2] ))) << 16) | + (static_cast(static_cast(GenericHash::detail::to_lower( data[3] ))) << 24); + } + else + { + k = LittleDWord( *(uint32 *)data ); + } + + k *= m; + k ^= k >> r; + k *= m; + + h *= m; + h ^= k; + + data += 4; + len -= 4; + } + + // Handle the last few bytes of the input array + + if constexpr (CASELESS) + { + switch(len) + { + case 3: h ^= static_cast(static_cast(GenericHash::detail::to_lower( data[2] ))) << 16; + case 2: h ^= static_cast(static_cast(GenericHash::detail::to_lower( data[1] ))) << 8; + case 1: h ^= static_cast(static_cast(GenericHash::detail::to_lower( data[0] ))); + h *= m; + }; + } + else + { + switch(len) + { + case 3: h ^= data[2] << 16; + case 2: h ^= data[1] << 8; + case 1: h ^= data[0]; + h *= m; + }; + } + + // Do a few final mixes of the hash to ensure the last few + // bytes are well-incorporated. + + h ^= h >> 13; + h *= m; + h ^= h >> 15; + + return h; +} + +template +inline uint32 MurmurHash2LowerCase( char const (&key)[N], uint32 seed ) +{ + return MurmurHash2( key, seed ); +} + +inline uint32 MurmurHash2LowerCase( char const *key, int len, uint32 seed ) +{ + return MurmurHash2( key, len, seed ); +} + +// AMNOTE: Template is required to enforce compiler to pick the correct overload when inlining +// as otherwise non templated overload would always win the pick thus no const folding would happen +template , int> = 0> +inline uint32 MurmurHash2LowerCase( T key, uint32 seed ) { return MurmurHash2LowerCase( key, strlen( key ), seed ); } + +inline uint32 HashString( const char *pszKey ) +{ + return MurmurHash2( pszKey, strlen( pszKey ), 0x3501A674 ); +} + +inline uint32 HashStringCaseless( const char *pszKey ) +{ + return MurmurHash2LowerCase( pszKey, 0x3501A674 ); +} + +template<> inline uint32 HashItem( const char *const &pszKey ) { return HashString( pszKey ); } -template<> inline unsigned HashItem(char * const &pszKey ) +template<> inline uint32 HashItem( char *const &pszKey ) { return HashString( pszKey ); } -//----------------------------------------------------------------------------- - - -//----------------------------------------------------------------------------- -// Murmur hash -//----------------------------------------------------------------------------- -uint32 MurmurHash2( const void *key, int len, uint32 seed ); - -// return murmurhash2 of a downcased string -uint32 MurmurHash2LowerCase( char const *pString, uint32 nSeed ); -uint32 MurmurHash2LowerCase( char const *pString, int nLength, uint32 nSeed ); - -PLATFORM_INTERFACE uint32 MurmurHash3_32( void const *key, size_t len, uint32 seed, bool bCaselessStringVariant = false ); - -// MurmurHash2, 64-bit version -uint64 MurmurHash64( const void *key, int len, uint32 seed ); - - #endif /* !GENERICHASH_H */ diff --git a/public/tier1/keyvalues3.h b/public/tier1/keyvalues3.h index 9d0efa2c..b061fa8c 100644 --- a/public/tier1/keyvalues3.h +++ b/public/tier1/keyvalues3.h @@ -347,12 +347,18 @@ struct KV3BinaryBlob_t class CKV3MemberName { public: - inline CKV3MemberName(const char* pszString, UtlSymLargeId_t symid = UTL_INVAL_SYMBOL_LARGE ): m_nHashCode(), m_SymId( symid ), m_pszString("") - { - if (!pszString || !pszString[0]) + template + inline CKV3MemberName( const char (&pszString)[N], UtlSymLargeId_t symid = UTL_INVAL_SYMBOL_LARGE ) : m_nHashCode( pszString ), m_SymId( symid ), m_pszString( pszString ) {} + + // AMNOTE: Template is required to enforce compiler to pick the correct overload when inlining + // as otherwise non templated overload would always win the pick thus no const folding would happen + template , int> = 0> + inline CKV3MemberName( T pszString, UtlSymLargeId_t symid = UTL_INVAL_SYMBOL_LARGE ) : m_nHashCode( 0 ), m_SymId( symid ), m_pszString( "" ) + { + if(!pszString || !pszString[0]) return; - m_nHashCode = MakeStringToken( pszString ); + m_nHashCode = CUtlStringToken( pszString ); m_pszString = pszString; } diff --git a/public/tier1/utlstringtoken.h b/public/tier1/utlstringtoken.h index 49b87a81..94b56d9d 100644 --- a/public/tier1/utlstringtoken.h +++ b/public/tier1/utlstringtoken.h @@ -16,6 +16,8 @@ #include #include "tier1/generichash.h" +#include + #define STRINGTOKEN_MURMURHASH_SEED 0x31415926 class CUtlString; @@ -30,13 +32,18 @@ class CUtlStringToken { public: FORCEINLINE CUtlStringToken( uint32 nHashCode = 0 ) : m_nHashCode( nHashCode ) {} - FORCEINLINE CUtlStringToken( const char *str ) : m_nHashCode( 0 ) + + template + FORCEINLINE CUtlStringToken( const char (&str)[N] ) : m_nHashCode( MurmurHash2LowerCase( str, STRINGTOKEN_MURMURHASH_SEED ) ) { } + + // AMNOTE: Template is required to enforce compiler to pick the correct overload when inlining + // as otherwise non templated overload would always win the pick thus no const folding would happen + template , int> = 0> + FORCEINLINE CUtlStringToken( T str ) : m_nHashCode( 0 ) { if(str && *str) - { m_nHashCode = MurmurHash2LowerCase( str, STRINGTOKEN_MURMURHASH_SEED ); - } - } + }; FORCEINLINE bool operator==( CUtlStringToken const &other ) const { return ( other.m_nHashCode == m_nHashCode ); } FORCEINLINE bool operator!=( CUtlStringToken const &other ) const { return !operator==( other ); } @@ -53,9 +60,4 @@ private: uint32 m_nHashCode; }; -FORCEINLINE CUtlStringToken MakeStringToken( const char *str ) -{ - return CUtlStringToken( str ); -} - #endif // UTLSTRINGTOKEN_H diff --git a/tier1/convar.cpp b/tier1/convar.cpp index b884854d..9dc22ed4 100644 --- a/tier1/convar.cpp +++ b/tier1/convar.cpp @@ -16,7 +16,6 @@ #include "tier1/characterset.h" #include "tier1/utlvector.h" #include "tier1/utlbuffer.h" -#include "tier1/tier1.h" #include "icvar.h" #include "tier0/dbg.h" #include "Color.h" diff --git a/tier1/generichash.cpp b/tier1/generichash.cpp deleted file mode 100644 index 06c4fdce..00000000 --- a/tier1/generichash.cpp +++ /dev/null @@ -1,361 +0,0 @@ -//======= Copyright © 2005, , Valve Corporation, All rights reserved. ========= -// -// Purpose: Variant Pearson Hash general purpose hashing algorithm described -// by Cargill in C++ Report 1994. Generates a 16-bit result. -// -//============================================================================= - -#include -#include "tier0/basetypes.h" -#include "tier0/platform.h" -#include "tier1/utlstring.h" -#include "generichash.h" -#include - -//----------------------------------------------------------------------------- -// -// Table of randomly shuffled values from 0-255 generated by: -// -//----------------------------------------------------------------------------- -/* -void MakeRandomValues() -{ - int i, j, r; - unsigned t; - srand( 0xdeadbeef ); - - for ( i = 0; i < 256; i++ ) - { - g_nRandomValues[i] = (unsigned )i; - } - - for (j = 0; j < 8; j++) - { - for (i = 0; i < 256; i++) - { - r = rand() & 0xff; - t = g_nRandomValues[i]; - g_nRandomValues[i] = g_nRandomValues[r]; - g_nRandomValues[r] = t; - } - } - - printf("static unsigned g_nRandomValues[256] =\n{\n"); - - for (i = 0; i < 256; i += 16) - { - printf("\t"); - for (j = 0; j < 16; j++) - printf(" %3d,", g_nRandomValues[i+j]); - printf("\n"); - } - printf("};\n"); -} -*/ - -static unsigned g_nRandomValues[256] = -{ - 238, 164, 191, 168, 115, 16, 142, 11, 213, 214, 57, 151, 248, 252, 26, 198, - 13, 105, 102, 25, 43, 42, 227, 107, 210, 251, 86, 66, 83, 193, 126, 108, - 131, 3, 64, 186, 192, 81, 37, 158, 39, 244, 14, 254, 75, 30, 2, 88, - 172, 176, 255, 69, 0, 45, 116, 139, 23, 65, 183, 148, 33, 46, 203, 20, - 143, 205, 60, 197, 118, 9, 171, 51, 233, 135, 220, 49, 71, 184, 82, 109, - 36, 161, 169, 150, 63, 96, 173, 125, 113, 67, 224, 78, 232, 215, 35, 219, - 79, 181, 41, 229, 149, 153, 111, 217, 21, 72, 120, 163, 133, 40, 122, 140, - 208, 231, 211, 200, 160, 182, 104, 110, 178, 237, 15, 101, 27, 50, 24, 189, - 177, 130, 187, 92, 253, 136, 100, 212, 19, 174, 70, 22, 170, 206, 162, 74, - 247, 5, 47, 32, 179, 117, 132, 195, 124, 123, 245, 128, 236, 223, 12, 84, - 54, 218, 146, 228, 157, 94, 106, 31, 17, 29, 194, 34, 56, 134, 239, 246, - 241, 216, 127, 98, 7, 204, 154, 152, 209, 188, 48, 61, 87, 97, 225, 85, - 90, 167, 155, 112, 145, 114, 141, 93, 250, 4, 201, 156, 38, 89, 226, 196, - 1, 235, 44, 180, 159, 121, 119, 166, 190, 144, 10, 91, 76, 230, 221, 80, - 207, 55, 58, 53, 175, 8, 6, 52, 68, 242, 18, 222, 103, 249, 147, 129, - 138, 243, 28, 185, 62, 59, 240, 202, 234, 99, 77, 73, 199, 137, 95, 165, -}; - -//----------------------------------------------------------------------------- -// String -//----------------------------------------------------------------------------- -unsigned FASTCALL HashString( const char *pszKey ) -{ - return MurmurHash2( pszKey, strlen( pszKey ), 0x3501A674 ); -} - - -//----------------------------------------------------------------------------- -// Case-insensitive string -//----------------------------------------------------------------------------- -unsigned FASTCALL HashStringCaseless( const char *pszKey ) -{ - return MurmurHash2LowerCase( pszKey, 0x3501A674 ); -} - -//----------------------------------------------------------------------------- -// 32 bit conventional case-insensitive string -//----------------------------------------------------------------------------- -unsigned FASTCALL HashStringFastCaselessConventional( const char *pszKey ) -{ - unsigned hash = 0xAAAAAAAA; // Alternating 1's and 0's to maximize the effect of the later multiply and add - - for( ; *pszKey ; pszKey++ ) - { - hash = ( ( hash << 5 ) + hash ) + (uint8)tolower(*pszKey); - } - - return hash; -} - -//----------------------------------------------------------------------------- -// 32 bit conventional case-sensitive string -//----------------------------------------------------------------------------- -unsigned FASTCALL HashStringConventional( const char *pszKey ) -{ - unsigned hash = 0xAAAAAAAA; // Alternating 1's and 0's to maximize the effect of the later multiply and add - - for(; *pszKey; pszKey++) - { - hash = ((hash << 5) + hash) + (uint8)*pszKey; - } - - return hash; -} - -//----------------------------------------------------------------------------- -// int hash -//----------------------------------------------------------------------------- -unsigned FASTCALL HashInt( const int n ) -{ - unsigned even, odd; - even = g_nRandomValues[n & 0xff]; - odd = g_nRandomValues[((n >> 8) & 0xff)]; - - even = g_nRandomValues[odd ^ (n >> 24)]; - odd = g_nRandomValues[even ^ ((n >> 16) & 0xff)]; - even = g_nRandomValues[odd ^ ((n >> 8) & 0xff)]; - odd = g_nRandomValues[even ^ (n & 0xff)]; - - return (even << 8) | odd; -} - -//----------------------------------------------------------------------------- -// 4-byte hash -//----------------------------------------------------------------------------- -unsigned FASTCALL Hash4( const void *pKey ) -{ - const uint32 * p = (const uint32 *) pKey; - unsigned even, - odd, - n; - n = *p; - even = g_nRandomValues[n & 0xff]; - odd = g_nRandomValues[((n >> 8) & 0xff)]; - - even = g_nRandomValues[odd ^ (n >> 24)]; - odd = g_nRandomValues[even ^ ((n >> 16) & 0xff)]; - even = g_nRandomValues[odd ^ ((n >> 8) & 0xff)]; - odd = g_nRandomValues[even ^ (n & 0xff)]; - - return (even << 8) | odd; -} - - -//----------------------------------------------------------------------------- -// 8-byte hash -//----------------------------------------------------------------------------- -unsigned FASTCALL Hash8( const void *pKey ) -{ - const uint32 * p = (const uint32 *) pKey; - unsigned even, - odd, - n; - n = *p; - even = g_nRandomValues[n & 0xff]; - odd = g_nRandomValues[((n >> 8) & 0xff)]; - - even = g_nRandomValues[odd ^ (n >> 24)]; - odd = g_nRandomValues[even ^ ((n >> 16) & 0xff)]; - even = g_nRandomValues[odd ^ ((n >> 8) & 0xff)]; - odd = g_nRandomValues[even ^ (n & 0xff)]; - - n = *(p+1); - even = g_nRandomValues[odd ^ (n >> 24)]; - odd = g_nRandomValues[even ^ ((n >> 16) & 0xff)]; - even = g_nRandomValues[odd ^ ((n >> 8) & 0xff)]; - odd = g_nRandomValues[even ^ (n & 0xff)]; - - return (even << 8) | odd; -} - - -//----------------------------------------------------------------------------- -// 12-byte hash -//----------------------------------------------------------------------------- -unsigned FASTCALL Hash12( const void *pKey ) -{ - const uint32 * p = (const uint32 *) pKey; - unsigned even, - odd, - n; - n = *p; - even = g_nRandomValues[n & 0xff]; - odd = g_nRandomValues[((n >> 8) & 0xff)]; - - even = g_nRandomValues[odd ^ (n >> 24)]; - odd = g_nRandomValues[even ^ ((n >> 16) & 0xff)]; - even = g_nRandomValues[odd ^ ((n >> 8) & 0xff)]; - odd = g_nRandomValues[even ^ (n & 0xff)]; - - n = *(p+1); - even = g_nRandomValues[odd ^ (n >> 24)]; - odd = g_nRandomValues[even ^ ((n >> 16) & 0xff)]; - even = g_nRandomValues[odd ^ ((n >> 8) & 0xff)]; - odd = g_nRandomValues[even ^ (n & 0xff)]; - - n = *(p+2); - even = g_nRandomValues[odd ^ (n >> 24)]; - odd = g_nRandomValues[even ^ ((n >> 16) & 0xff)]; - even = g_nRandomValues[odd ^ ((n >> 8) & 0xff)]; - odd = g_nRandomValues[even ^ (n & 0xff)]; - - return (even << 8) | odd; -} - - -//----------------------------------------------------------------------------- -// 16-byte hash -//----------------------------------------------------------------------------- -unsigned FASTCALL Hash16( const void *pKey ) -{ - const uint32 * p = (const uint32 *) pKey; - unsigned even, - odd, - n; - n = *p; - even = g_nRandomValues[n & 0xff]; - odd = g_nRandomValues[((n >> 8) & 0xff)]; - - even = g_nRandomValues[odd ^ (n >> 24)]; - odd = g_nRandomValues[even ^ ((n >> 16) & 0xff)]; - even = g_nRandomValues[odd ^ ((n >> 8) & 0xff)]; - odd = g_nRandomValues[even ^ (n & 0xff)]; - - n = *(p+1); - even = g_nRandomValues[odd ^ (n >> 24)]; - odd = g_nRandomValues[even ^ ((n >> 16) & 0xff)]; - even = g_nRandomValues[odd ^ ((n >> 8) & 0xff)]; - odd = g_nRandomValues[even ^ (n & 0xff)]; - - n = *(p+2); - even = g_nRandomValues[odd ^ (n >> 24)]; - odd = g_nRandomValues[even ^ ((n >> 16) & 0xff)]; - even = g_nRandomValues[odd ^ ((n >> 8) & 0xff)]; - odd = g_nRandomValues[even ^ (n & 0xff)]; - - n = *(p+3); - even = g_nRandomValues[odd ^ (n >> 24)]; - odd = g_nRandomValues[even ^ ((n >> 16) & 0xff)]; - even = g_nRandomValues[odd ^ ((n >> 8) & 0xff)]; - odd = g_nRandomValues[even ^ (n & 0xff)]; - - return (even << 8) | odd; -} - - -//----------------------------------------------------------------------------- -// Arbitrary fixed length hash -//----------------------------------------------------------------------------- -unsigned FASTCALL HashBlock( const void *pKey, unsigned size ) -{ - const uint8 * k = (const uint8 *) pKey; - unsigned even = 0, - odd = 0, - n; - - while (size) - { - --size; - n = *k++; - even = g_nRandomValues[odd ^ n]; - if (size) - { - --size; - n = *k++; - odd = g_nRandomValues[even ^ n]; - } - else - break; - } - - return (even << 8) | odd; -} - -//----------------------------------------------------------------------------- -// MurmurHash variants -//----------------------------------------------------------------------------- -uint32 MurmurHash2( const void *key, int len, uint32 seed ) -{ - // 'm' and 'r' are mixing constants generated offline. - // They're not really 'magic', they just happen to work well. - - const uint32 m = 0x5bd1e995; - const int r = 24; - - // Initialize the hash to a 'random' value - - uint32 h = seed ^ len; - - // Mix 4 bytes at a time into the hash - - const unsigned char *data = (const unsigned char *)key; - - while(len >= 4) - { - uint32 k = LittleDWord( *(uint32 *)data ); - - k *= m; - k ^= k >> r; - k *= m; - - h *= m; - h ^= k; - - data += 4; - len -= 4; - } - - // Handle the last few bytes of the input array - - switch(len) - { - case 3: h ^= data[2] << 16; - case 2: h ^= data[1] << 8; - case 1: h ^= data[0]; - h *= m; - }; - - // Do a few final mixes of the hash to ensure the last few - // bytes are well-incorporated. - - h ^= h >> 13; - h *= m; - h ^= h >> 15; - - return h; -} - -// return murmurhash2 of a downcased string -uint32 MurmurHash2LowerCase( char const *pString, uint32 nSeed ) -{ - CUtlString buf( pString ); - buf.ToLowerFast(); - - return MurmurHash2( buf.Get(), buf.Length(), nSeed ); -} - -uint32 MurmurHash2LowerCase( char const *pString, int nLength, uint32 nSeed ) -{ - CUtlString buf( pString ); - buf.ToLowerFast(); - - return MurmurHash2( buf.Get(), nLength, nSeed ); -} diff --git a/tier1/tier1-2005.vcproj b/tier1/tier1-2005.vcproj deleted file mode 100644 index a1c9d413..00000000 --- a/tier1/tier1-2005.vcproj +++ /dev/null @@ -1,568 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/tier1/tier1.cpp b/tier1/tier1.cpp deleted file mode 100644 index 0b2c21d2..00000000 --- a/tier1/tier1.cpp +++ /dev/null @@ -1,29 +0,0 @@ -//===== Copyright © 2005-2005, Valve Corporation, All rights reserved. ======// -// -// Purpose: A higher level link library for general use in the game and tools. -// -//===========================================================================// - -#include -#include "tier0/dbg.h" -#include "interfaces/interfaces.h" - -// for utlsortvector.h -#ifndef _WIN32 - void *g_pUtlSortVectorQSortContext = NULL; -#endif - - -//----------------------------------------------------------------------------- -// Call this to connect to all tier 1 libraries. -// It's up to the caller to check the globals it cares about to see if ones are missing -//----------------------------------------------------------------------------- -void ConnectTier1Libraries( CreateInterfaceFn *pFactoryList, int nFactoryCount ) -{ - ConnectInterfaces( pFactoryList, nFactoryCount); -} - -void DisconnectTier1Libraries() -{ - DisconnectInterfaces(); -} diff --git a/tier1/tier1.sln b/tier1/tier1.sln deleted file mode 100644 index bcc127ca..00000000 --- a/tier1/tier1.sln +++ /dev/null @@ -1,28 +0,0 @@ - -Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio 2013 -VisualStudioVersion = 12.0.31101.0 -MinimumVisualStudioVersion = 10.0.40219.1 -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tier1", "tier1.vcxproj", "{E1DA8DB8-FB4C-4B14-91A6-98BCED6B9720}" -EndProject -Global - GlobalSection(SolutionConfigurationPlatforms) = preSolution - Debug|Win32 = Debug|Win32 - Debug|x64 = Debug|x64 - Release|Win32 = Release|Win32 - Release|x64 = Release|x64 - EndGlobalSection - GlobalSection(ProjectConfigurationPlatforms) = postSolution - {E1DA8DB8-FB4C-4B14-91A6-98BCED6B9720}.Debug|Win32.ActiveCfg = Debug|Win32 - {E1DA8DB8-FB4C-4B14-91A6-98BCED6B9720}.Debug|Win32.Build.0 = Debug|Win32 - {E1DA8DB8-FB4C-4B14-91A6-98BCED6B9720}.Debug|x64.ActiveCfg = Debug|x64 - {E1DA8DB8-FB4C-4B14-91A6-98BCED6B9720}.Debug|x64.Build.0 = Debug|x64 - {E1DA8DB8-FB4C-4B14-91A6-98BCED6B9720}.Release|Win32.ActiveCfg = Release|Win32 - {E1DA8DB8-FB4C-4B14-91A6-98BCED6B9720}.Release|Win32.Build.0 = Release|Win32 - {E1DA8DB8-FB4C-4B14-91A6-98BCED6B9720}.Release|x64.ActiveCfg = Release|x64 - {E1DA8DB8-FB4C-4B14-91A6-98BCED6B9720}.Release|x64.Build.0 = Release|x64 - EndGlobalSection - GlobalSection(SolutionProperties) = preSolution - HideSolutionNode = FALSE - EndGlobalSection -EndGlobal diff --git a/tier1/tier1.vcxproj b/tier1/tier1.vcxproj deleted file mode 100644 index 0b3786f6..00000000 --- a/tier1/tier1.vcxproj +++ /dev/null @@ -1,384 +0,0 @@ - - - - - Debug - Win32 - - - Debug - x64 - - - Release - Win32 - - - Release - x64 - - - - tier1 - {E1DA8DB8-FB4C-4B14-91A6-98BCED6B9720} - tier1 - 10.0 - - - - StaticLibrary - v120_xp - - - StaticLibrary - v143 - - - StaticLibrary - v120_xp - - - StaticLibrary - v143 - - - - - - - - - - - - - - - - - - - <_ProjectFileVersion>10.0.40219.1 - ..\lib\public\ - true - true - true - true - true - true - ..\lib\public\ - true - true - true - true - true - true - AllRules.ruleset - AllRules.ruleset - - - - - AllRules.ruleset - AllRules.ruleset - - - - - - - ..\lib\public\win64\ - - - ..\lib\public\win64\ - - - - - - - - Disabled - ..\public;..\public\tier0;..\public\tier1;%(AdditionalIncludeDirectories) - _HAS_ITERATOR_DEBUGGING=0;_ALLOW_RUNTIME_LIBRARY_MISMATCH;_ALLOW_ITERATOR_DEBUG_LEVEL_MISMATCH;_ALLOW_MSC_VER_MISMATCH;WIN32;_WIN32;COMPILER_MSVC;COMPILER_MSVC32;_DEBUG;DEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;TIER1_STATIC_LIB;%(PreprocessorDefinitions) - true - true - - - EnableFastChecks - MultiThreadedDebug - false - Fast - true - true - true - false - - - false - - - $(IntDir) - $(IntDir) - $(IntDir) - false - - - $(IntDir) - CompileAsCpp - Prompt - Level3 - - - - - - - false - Rpcrt4.lib;%(AdditionalDependencies) - true - - - true - - - true - $(OutDir)tier1.bsc - - - - - - - - - Disabled - ..\public;..\public\tier0;..\public\tier1;%(AdditionalIncludeDirectories) - _HAS_ITERATOR_DEBUGGING=0;_ALLOW_RUNTIME_LIBRARY_MISMATCH;_ALLOW_ITERATOR_DEBUG_LEVEL_MISMATCH;_ALLOW_MSC_VER_MISMATCH;WIN32;_WIN32;COMPILER_MSVC;COMPILER_MSVC64;_DEBUG;DEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;TIER1_STATIC_LIB;%(PreprocessorDefinitions) - true - - - EnableFastChecks - MultiThreadedDebug - false - Fast - true - true - true - false - - - false - - - $(IntDir) - $(IntDir) - $(IntDir) - false - - - $(IntDir) - CompileAsCpp - Prompt - Level3 - - - - - - - false - Rpcrt4.lib;%(AdditionalDependencies) - true - - - true - - - true - $(OutDir)tier1.bsc - - - - - - - - - MaxSpeed - AnySuitable - true - Speed - ..\public;..\public\tier0;..\public\tier1;%(AdditionalIncludeDirectories) - _HAS_ITERATOR_DEBUGGING=0;_ALLOW_RUNTIME_LIBRARY_MISMATCH;_ALLOW_ITERATOR_DEBUG_LEVEL_MISMATCH;_ALLOW_MSC_VER_MISMATCH;WIN32;_WIN32;COMPILER_MSVC;COMPILER_MSVC32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;TIER1_STATIC_LIB;%(PreprocessorDefinitions) - true - - - MultiThreaded - false - true - Fast - true - true - true - false - - - false - - - $(IntDir) - $(IntDir) - $(IntDir) - false - - - $(IntDir) - CompileAsCpp - Prompt - Level3 - - - /Zo %(AdditionalOptions) - - - - - - - false - Rpcrt4.lib;%(AdditionalDependencies) - true - - - true - - - true - $(OutDir)tier1.bsc - - - - - - - - - MaxSpeed - AnySuitable - true - Speed - ..\public;..\public\tier0;..\public\tier1;%(AdditionalIncludeDirectories) - _HAS_ITERATOR_DEBUGGING=0;_ALLOW_RUNTIME_LIBRARY_MISMATCH;_ALLOW_ITERATOR_DEBUG_LEVEL_MISMATCH;_ALLOW_MSC_VER_MISMATCH;WIN;_WIN32;COMPILER_MSVC;COMPILER_MSVC64;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;TIER1_STATIC_LIB;X64BITS;%(PreprocessorDefinitions) - true - - - MultiThreaded - false - true - Fast - true - true - true - false - - - false - - - $(IntDir) - $(IntDir) - $(IntDir) - false - - - $(IntDir) - CompileAsCpp - Prompt - Level3 - - - /Zo %(AdditionalOptions) - - - - - - - false - Rpcrt4.lib;%(AdditionalDependencies) - true - - - true - - - true - $(OutDir)tier1.bsc - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/tier1/tier1.vcxproj.filters b/tier1/tier1.vcxproj.filters deleted file mode 100644 index 3ad01eb8..00000000 --- a/tier1/tier1.vcxproj.filters +++ /dev/null @@ -1,188 +0,0 @@ - - - - - {aba1d919-d95c-4c3f-a495-be0375bab184} - cpp;c;cxx;rc;def;r;odl;idl;hpj;bat - - - {0295d938-2af6-4393-9785-4b7b122313c9} - h;hpp;hxx;hm;inl - - - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - \ No newline at end of file