Obsolete tier1.lib/.a & optimize murmurhash2 inlining

This commit is contained in:
GAMMACASE committed 2026-07-17 17:54:07 +03:00
1 parent ce74fb70f5
commit b6f05e3742
15 files changed
+431 -1667

No files matched your search

Binary file not shown.
Binary file not shown.
-55
View File
@@ -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)
+1 -1
View File
@@ -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 );
}
+1 -3
View File
@@ -17,8 +17,6 @@
#include <memory>
#define CODEGEN_HASH_TOKEN (0x3501A674)
class CNetMessage;
class CNetworkSerializerCodeGenDatabase;
class CCheckTransmitInfo;
@@ -226,7 +224,7 @@ struct SerializerFieldLookup_t
};
template<> struct DefaultEqualFunctor<SerializerFieldLookup_t> { bool operator()( SerializerFieldLookup_t a, SerializerFieldLookup_t b ) const { return a.m_FieldName == b.m_FieldName; } };
template<> struct DefaultHashFunctor<SerializerFieldLookup_t> { unsigned int operator()( SerializerFieldLookup_t a ) const { return MurmurHash2LowerCase( a.m_FieldName.String(), CODEGEN_HASH_TOKEN ); } };
template<> struct DefaultHashFunctor<SerializerFieldLookup_t> { unsigned int operator()( SerializerFieldLookup_t a ) const { return HashStringCaseless( a.m_FieldName.String() ); } };
class CNetworkSerializerClassInfo
{
+408 -36
View File
@@ -12,23 +12,215 @@
#pragma once
#endif
#include <cctype>
#include <type_traits>
#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 <typename T>
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<int>(const int &key )
template <> inline uint32 HashItem<int>(const int &key )
{
return HashInt( key );
}
template <> inline unsigned HashItem<unsigned>(const unsigned &key )
template <> inline uint32 HashItem<uint32>(const uint32 &key )
{
return HashInt( (int)key );
}
template<> inline unsigned HashItem<const char *>(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 <bool CASELESS = false, size_t N>
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<uint32>(static_cast<uint8>(GenericHash::detail::to_lower( key[offset + 0] ))) |
(static_cast<uint32>(static_cast<uint8>(GenericHash::detail::to_lower( key[offset + 1] ))) << 8) |
(static_cast<uint32>(static_cast<uint8>(GenericHash::detail::to_lower( key[offset + 2] ))) << 16) |
(static_cast<uint32>(static_cast<uint8>(GenericHash::detail::to_lower( key[offset + 3] ))) << 24);
}
else
{
k = static_cast<uint32>(static_cast<uint8>(key[offset + 0])) |
(static_cast<uint32>(static_cast<uint8>(key[offset + 1])) << 8) |
(static_cast<uint32>(static_cast<uint8>(key[offset + 2])) << 16) |
(static_cast<uint32>(static_cast<uint8>(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<uint32>(static_cast<uint8>(GenericHash::detail::to_lower( key[offset + 2] ))) << 16;
if constexpr(((N - 1) % 4) >= 2) h ^= static_cast<uint32>(static_cast<uint8>(GenericHash::detail::to_lower( key[offset + 1] ))) << 8;
if constexpr(((N - 1) % 4) >= 1)
{
h ^= static_cast<uint32>(static_cast<uint8>(GenericHash::detail::to_lower( key[offset + 0] )));
h *= m;
}
}
else
{
if constexpr(((N - 1) % 4) >= 3) h ^= static_cast<uint32>(static_cast<uint8>(key[offset + 2])) << 16;
if constexpr(((N - 1) % 4) >= 2) h ^= static_cast<uint32>(static_cast<uint8>(key[offset + 1])) << 8;
if constexpr(((N - 1) % 4) >= 1)
{
h ^= static_cast<uint32>(static_cast<uint8>(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 <bool CASELESS = false>
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<uint32>(static_cast<uint8>(GenericHash::detail::to_lower( data[0] ))) |
(static_cast<uint32>(static_cast<uint8>(GenericHash::detail::to_lower( data[1] ))) << 8) |
(static_cast<uint32>(static_cast<uint8>(GenericHash::detail::to_lower( data[2] ))) << 16) |
(static_cast<uint32>(static_cast<uint8>(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<uint32>(static_cast<uint8>(GenericHash::detail::to_lower( data[2] ))) << 16;
case 2: h ^= static_cast<uint32>(static_cast<uint8>(GenericHash::detail::to_lower( data[1] ))) << 8;
case 1: h ^= static_cast<uint32>(static_cast<uint8>(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 <size_t N>
inline uint32 MurmurHash2LowerCase( char const (&key)[N], uint32 seed )
{
return MurmurHash2<true>( key, seed );
}
inline uint32 MurmurHash2LowerCase( char const *key, int len, uint32 seed )
{
return MurmurHash2<true>( 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 <typename T, std::enable_if_t<std::is_same_v<T, const char *>, 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 char *const &pszKey )
{
return HashString( pszKey );
}
template<> inline unsigned HashItem<char *>(char * const &pszKey )
template<> inline uint32 HashItem<char *>( 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 */
+10 -4
View File
@@ -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 <size_t N>
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 <typename T, std::enable_if_t<std::is_same_v<T, const char *>, 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;
}
+11 -9
View File
@@ -16,6 +16,8 @@
#include <limits.h>
#include "tier1/generichash.h"
#include <type_traits>
#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 <size_t N>
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 <typename T, std::enable_if_t<std::is_same_v<T, const char *>, 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
-1
View File
@@ -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"
-361
View File
@@ -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 <stdlib.h>
#include "tier0/basetypes.h"
#include "tier0/platform.h"
#include "tier1/utlstring.h"
#include "generichash.h"
#include <ctype.h>
//-----------------------------------------------------------------------------
//
// 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 );
}
-568
View File
@@ -1,568 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="8.00"
Name="tier1"
ProjectGUID="{E1DA8DB8-FB4C-4B14-91A6-98BCED6B9720}"
RootNamespace="tier1"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="4"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
CommandLine=""
ExcludedFromBuild="false"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
UseUnicodeResponseFiles="false"
Optimization="0"
AdditionalIncludeDirectories="..\public;..\public\tier0;..\public\tier1"
PreprocessorDefinitions="WIN32;_WIN32;_DEBUG;DEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;TIER1_STATIC_LIB"
StringPooling="true"
MinimalRebuild="true"
ExceptionHandling="0"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
BufferSecurityCheck="false"
FloatingPointModel="2"
TreatWChar_tAsBuiltInType="true"
ForceConformanceInForLoopScope="true"
RuntimeTypeInfo="true"
OpenMP="false"
UsePrecompiledHeader="0"
ExpandAttributedSource="false"
AssemblerOutput="0"
AssemblerListingLocation="$(IntDir)/"
ObjectFile="$(IntDir)/"
ProgramDataBaseFileName="$(IntDir)/"
GenerateXMLDocumentationFiles="false"
BrowseInformation="0"
BrowseInformationFile="$(IntDir)/"
WarningLevel="4"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="4"
CompileAs="2"
ErrorReporting="1"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
CommandLine=""
ExcludedFromBuild="false"
/>
<Tool
Name="VCLibrarianTool"
UseUnicodeResponseFiles="false"
AdditionalDependencies="Rpcrt4.lib"
OutputFile="..\lib\public\tier1.lib"
SuppressStartupBanner="true"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
SuppressStartupBanner="true"
/>
<Tool
Name="VCBscMakeTool"
SuppressStartupBanner="true"
OutputFile="$(OutDir)/tier1.bsc"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
ExcludedFromBuild="false"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="4"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
CommandLine=""
ExcludedFromBuild="false"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
UseUnicodeResponseFiles="false"
Optimization="2"
InlineFunctionExpansion="2"
EnableIntrinsicFunctions="true"
FavorSizeOrSpeed="1"
AdditionalIncludeDirectories="..\public;..\public\tier0;..\public\tier1"
PreprocessorDefinitions="WIN32;_WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;TIER1_STATIC_LIB"
StringPooling="true"
ExceptionHandling="0"
RuntimeLibrary="0"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
FloatingPointModel="2"
TreatWChar_tAsBuiltInType="true"
ForceConformanceInForLoopScope="true"
RuntimeTypeInfo="true"
OpenMP="false"
UsePrecompiledHeader="0"
ExpandAttributedSource="false"
AssemblerOutput="0"
AssemblerListingLocation="$(IntDir)/"
ObjectFile="$(IntDir)/"
ProgramDataBaseFileName="$(IntDir)/"
GenerateXMLDocumentationFiles="false"
BrowseInformation="0"
BrowseInformationFile="$(IntDir)/"
WarningLevel="4"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="1"
CompileAs="2"
ErrorReporting="1"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
CommandLine=""
ExcludedFromBuild="false"
/>
<Tool
Name="VCLibrarianTool"
UseUnicodeResponseFiles="false"
AdditionalDependencies="Rpcrt4.lib"
OutputFile="..\lib\public\tier1.lib"
SuppressStartupBanner="true"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
SuppressStartupBanner="true"
/>
<Tool
Name="VCBscMakeTool"
SuppressStartupBanner="true"
OutputFile="$(OutDir)/tier1.bsc"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
ExcludedFromBuild="false"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
>
<File
RelativePath=".\bitbuf.cpp"
>
</File>
<File
RelativePath=".\cbyteswap.cpp"
>
</File>
<File
RelativePath=".\characterset.cpp"
>
</File>
<File
RelativePath=".\checksum_crc.cpp"
>
</File>
<File
RelativePath=".\checksum_md5.cpp"
>
</File>
<File
RelativePath=".\commandbuffer.cpp"
>
</File>
<File
RelativePath=".\convar.cpp"
>
</File>
<File
RelativePath=".\datamanager.cpp"
>
</File>
<File
RelativePath=".\diff.cpp"
>
</File>
<File
RelativePath=".\generichash.cpp"
>
</File>
<File
RelativePath=".\interface.cpp"
>
</File>
<File
RelativePath=".\KeyValues.cpp"
>
</File>
<File
RelativePath=".\mempool.cpp"
>
</File>
<File
RelativePath=".\memstack.cpp"
>
</File>
<File
RelativePath=".\NetAdr.cpp"
>
</File>
<File
RelativePath=".\newbitbuf.cpp"
>
</File>
<File
RelativePath=".\processor_detect.cpp"
>
<FileConfiguration
Name="Debug|Win32"
>
<Tool
Name="VCCLCompilerTool"
ExceptionHandling="1"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCLCompilerTool"
ExceptionHandling="1"
/>
</FileConfiguration>
</File>
<File
RelativePath=".\rangecheckedvar.cpp"
>
</File>
<File
RelativePath=".\stringpool.cpp"
>
</File>
<File
RelativePath=".\strtools.cpp"
>
</File>
<File
RelativePath=".\tier1.cpp"
>
</File>
<File
RelativePath=".\tokenreader.cpp"
>
</File>
<File
RelativePath=".\uniqueid.cpp"
>
</File>
<File
RelativePath=".\utlbuffer.cpp"
>
</File>
<File
RelativePath=".\utlbufferutil.cpp"
>
</File>
<File
RelativePath=".\utlstring.cpp"
>
</File>
<File
RelativePath=".\utlsymbol.cpp"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl"
>
<File
RelativePath="..\public\tier1\bitbuf.h"
>
</File>
<File
RelativePath="..\public\tier1\cbyteswap.h"
>
</File>
<File
RelativePath="..\public\tier1\callqueue.h"
>
</File>
<File
RelativePath="..\public\tier1\characterset.h"
>
</File>
<File
RelativePath="..\public\tier1\checksum_crc.h"
>
</File>
<File
RelativePath="..\public\tier1\checksum_md5.h"
>
</File>
<File
RelativePath="..\public\tier1\CommandBuffer.h"
>
</File>
<File
RelativePath="..\public\tier1\convar.h"
>
</File>
<File
RelativePath="..\public\tier1\datamanager.h"
>
</File>
<File
RelativePath="..\public\datamap.h"
>
</File>
<File
RelativePath="..\public\tier1\delegates.h"
>
</File>
<File
RelativePath="..\public\tier1\diff.h"
>
</File>
<File
RelativePath="..\public\tier1\fmtstr.h"
>
</File>
<File
RelativePath="..\public\tier1\functors.h"
>
</File>
<File
RelativePath="..\public\tier1\generichash.h"
>
</File>
<File
RelativePath="..\public\tier1\iconvar.h"
>
</File>
<File
RelativePath="..\public\tier1\interface.h"
>
</File>
<File
RelativePath="..\public\tier1\KeyValues.h"
>
</File>
<File
RelativePath="..\public\tier1\lzmaDecoder.h"
>
</File>
<File
RelativePath="..\public\tier1\lzss.h"
>
</File>
<File
RelativePath="..\public\tier1\mempool.h"
>
</File>
<File
RelativePath="..\public\tier1\memstack.h"
>
</File>
<File
RelativePath="..\public\tier1\netadr.h"
>
</File>
<File
RelativePath="..\public\tier1\processor_detect.h"
>
</File>
<File
RelativePath="..\public\tier1\rangecheckedvar.h"
>
</File>
<File
RelativePath="..\public\tier1\refcount.h"
>
</File>
<File
RelativePath="..\public\tier1\smartptr.h"
>
</File>
<File
RelativePath="..\public\tier1\stringpool.h"
>
</File>
<File
RelativePath="..\public\tier1\strtools.h"
>
</File>
<File
RelativePath="..\public\tier1\tier1.h"
>
</File>
<File
RelativePath="..\public\tier1\tokenreader.h"
>
</File>
<File
RelativePath="..\public\tier1\uniqueid.h"
>
</File>
<File
RelativePath="..\public\tier1\utlbidirectionalset.h"
>
</File>
<File
RelativePath="..\public\tier1\utlblockmemory.h"
>
</File>
<File
RelativePath="..\public\tier1\utlbuffer.h"
>
</File>
<File
RelativePath="..\public\tier1\utlbufferutil.h"
>
</File>
<File
RelativePath="..\public\tier1\utldict.h"
>
</File>
<File
RelativePath="..\public\tier1\utlenvelope.h"
>
</File>
<File
RelativePath="..\public\tier1\utlfixedmemory.h"
>
</File>
<File
RelativePath="..\public\tier1\utlhandletable.h"
>
</File>
<File
RelativePath="..\public\tier1\utlhash.h"
>
</File>
<File
RelativePath="..\public\tier1\utllinkedlist.h"
>
</File>
<File
RelativePath="..\public\tier1\utlmap.h"
>
</File>
<File
RelativePath="..\public\tier1\utlmemory.h"
>
</File>
<File
RelativePath="..\public\tier1\utlmultilist.h"
>
</File>
<File
RelativePath="..\public\tier1\utlpriorityqueue.h"
>
</File>
<File
RelativePath="..\public\tier1\utlqueue.h"
>
</File>
<File
RelativePath="..\public\tier1\utlrbtree.h"
>
</File>
<File
RelativePath="..\public\tier1\UtlSortVector.h"
>
</File>
<File
RelativePath="..\public\tier1\utlstack.h"
>
</File>
<File
RelativePath="..\public\tier1\utlstring.h"
>
</File>
<File
RelativePath="..\public\tier1\UtlStringMap.h"
>
</File>
<File
RelativePath="..\public\tier1\utlsymbol.h"
>
</File>
<File
RelativePath="..\public\tier1\utlvector.h"
>
</File>
<File
RelativePath="..\common\xbox\xboxstubs.h"
>
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>
-29
View File
@@ -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 <tier1/tier1.h>
#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();
}
-28
View File
@@ -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
-384
View File
@@ -1,384 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectName>tier1</ProjectName>
<ProjectGuid>{E1DA8DB8-FB4C-4B14-91A6-98BCED6B9720}</ProjectGuid>
<RootNamespace>tier1</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v120_xp</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v143</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v120_xp</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>v143</PlatformToolset>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup>
<_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">..\lib\public\</OutDir>
<PreBuildEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</PreBuildEventUseInBuild>
<PreBuildEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</PreBuildEventUseInBuild>
<PreLinkEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</PreLinkEventUseInBuild>
<PreLinkEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</PreLinkEventUseInBuild>
<PostBuildEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</PostBuildEventUseInBuild>
<PostBuildEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</PostBuildEventUseInBuild>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">..\lib\public\</OutDir>
<PreBuildEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</PreBuildEventUseInBuild>
<PreBuildEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</PreBuildEventUseInBuild>
<PreLinkEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</PreLinkEventUseInBuild>
<PreLinkEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</PreLinkEventUseInBuild>
<PostBuildEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</PostBuildEventUseInBuild>
<PostBuildEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</PostBuildEventUseInBuild>
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<OutDir>..\lib\public\win64\</OutDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<OutDir>..\lib\public\win64\</OutDir>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<PreBuildEvent>
<Command>
</Command>
</PreBuildEvent>
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\public;..\public\tier0;..\public\tier1;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_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)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<MinimalRebuild>true</MinimalRebuild>
<ExceptionHandling>
</ExceptionHandling>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<BufferSecurityCheck>false</BufferSecurityCheck>
<FloatingPointModel>Fast</FloatingPointModel>
<TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
<ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope>
<RuntimeTypeInfo>true</RuntimeTypeInfo>
<OpenMPSupport>false</OpenMPSupport>
<PrecompiledHeader>
</PrecompiledHeader>
<ExpandAttributedSource>false</ExpandAttributedSource>
<AssemblerOutput>
</AssemblerOutput>
<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>
<ObjectFileName>$(IntDir)</ObjectFileName>
<ProgramDataBaseFileName>$(IntDir)</ProgramDataBaseFileName>
<GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
<BrowseInformation>
</BrowseInformation>
<BrowseInformationFile>$(IntDir)</BrowseInformationFile>
<CompileAs>CompileAsCpp</CompileAs>
<ErrorReporting>Prompt</ErrorReporting>
<WarningLevel>Level3</WarningLevel>
</ClCompile>
<PreLinkEvent>
<Command>
</Command>
</PreLinkEvent>
<Lib>
<UseUnicodeResponseFiles>false</UseUnicodeResponseFiles>
<AdditionalDependencies>Rpcrt4.lib;%(AdditionalDependencies)</AdditionalDependencies>
<SuppressStartupBanner>true</SuppressStartupBanner>
</Lib>
<Xdcmake>
<SuppressStartupBanner>true</SuppressStartupBanner>
</Xdcmake>
<Bscmake>
<SuppressStartupBanner>true</SuppressStartupBanner>
<OutputFile>$(OutDir)tier1.bsc</OutputFile>
</Bscmake>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<PreBuildEvent>
<Command>
</Command>
</PreBuildEvent>
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\public;..\public\tier0;..\public\tier1;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_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)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<ExceptionHandling>
</ExceptionHandling>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<BufferSecurityCheck>false</BufferSecurityCheck>
<FloatingPointModel>Fast</FloatingPointModel>
<TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
<ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope>
<RuntimeTypeInfo>true</RuntimeTypeInfo>
<OpenMPSupport>false</OpenMPSupport>
<PrecompiledHeader>
</PrecompiledHeader>
<ExpandAttributedSource>false</ExpandAttributedSource>
<AssemblerOutput>
</AssemblerOutput>
<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>
<ObjectFileName>$(IntDir)</ObjectFileName>
<ProgramDataBaseFileName>$(IntDir)</ProgramDataBaseFileName>
<GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
<BrowseInformation>
</BrowseInformation>
<BrowseInformationFile>$(IntDir)</BrowseInformationFile>
<CompileAs>CompileAsCpp</CompileAs>
<ErrorReporting>Prompt</ErrorReporting>
<WarningLevel>Level3</WarningLevel>
</ClCompile>
<PreLinkEvent>
<Command>
</Command>
</PreLinkEvent>
<Lib>
<UseUnicodeResponseFiles>false</UseUnicodeResponseFiles>
<AdditionalDependencies>Rpcrt4.lib;%(AdditionalDependencies)</AdditionalDependencies>
<SuppressStartupBanner>true</SuppressStartupBanner>
</Lib>
<Xdcmake>
<SuppressStartupBanner>true</SuppressStartupBanner>
</Xdcmake>
<Bscmake>
<SuppressStartupBanner>true</SuppressStartupBanner>
<OutputFile>$(OutDir)tier1.bsc</OutputFile>
</Bscmake>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<PreBuildEvent>
<Command>
</Command>
</PreBuildEvent>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<IntrinsicFunctions>true</IntrinsicFunctions>
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
<AdditionalIncludeDirectories>..\public;..\public\tier0;..\public\tier1;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_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)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<ExceptionHandling>
</ExceptionHandling>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<BufferSecurityCheck>false</BufferSecurityCheck>
<FunctionLevelLinking>true</FunctionLevelLinking>
<FloatingPointModel>Fast</FloatingPointModel>
<TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
<ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope>
<RuntimeTypeInfo>true</RuntimeTypeInfo>
<OpenMPSupport>false</OpenMPSupport>
<PrecompiledHeader>
</PrecompiledHeader>
<ExpandAttributedSource>false</ExpandAttributedSource>
<AssemblerOutput>
</AssemblerOutput>
<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>
<ObjectFileName>$(IntDir)</ObjectFileName>
<ProgramDataBaseFileName>$(IntDir)</ProgramDataBaseFileName>
<GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
<BrowseInformation>
</BrowseInformation>
<BrowseInformationFile>$(IntDir)</BrowseInformationFile>
<CompileAs>CompileAsCpp</CompileAs>
<ErrorReporting>Prompt</ErrorReporting>
<WarningLevel>Level3</WarningLevel>
<UndefinePreprocessorDefinitions>
</UndefinePreprocessorDefinitions>
<AdditionalOptions>/Zo %(AdditionalOptions)</AdditionalOptions>
</ClCompile>
<PreLinkEvent>
<Command>
</Command>
</PreLinkEvent>
<Lib>
<UseUnicodeResponseFiles>false</UseUnicodeResponseFiles>
<AdditionalDependencies>Rpcrt4.lib;%(AdditionalDependencies)</AdditionalDependencies>
<SuppressStartupBanner>true</SuppressStartupBanner>
</Lib>
<Xdcmake>
<SuppressStartupBanner>true</SuppressStartupBanner>
</Xdcmake>
<Bscmake>
<SuppressStartupBanner>true</SuppressStartupBanner>
<OutputFile>$(OutDir)tier1.bsc</OutputFile>
</Bscmake>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<PreBuildEvent>
<Command>
</Command>
</PreBuildEvent>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<IntrinsicFunctions>true</IntrinsicFunctions>
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
<AdditionalIncludeDirectories>..\public;..\public\tier0;..\public\tier1;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_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)</PreprocessorDefinitions>
<StringPooling>true</StringPooling>
<ExceptionHandling>
</ExceptionHandling>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<BufferSecurityCheck>false</BufferSecurityCheck>
<FunctionLevelLinking>true</FunctionLevelLinking>
<FloatingPointModel>Fast</FloatingPointModel>
<TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
<ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope>
<RuntimeTypeInfo>true</RuntimeTypeInfo>
<OpenMPSupport>false</OpenMPSupport>
<PrecompiledHeader>
</PrecompiledHeader>
<ExpandAttributedSource>false</ExpandAttributedSource>
<AssemblerOutput>
</AssemblerOutput>
<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>
<ObjectFileName>$(IntDir)</ObjectFileName>
<ProgramDataBaseFileName>$(IntDir)</ProgramDataBaseFileName>
<GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
<BrowseInformation>
</BrowseInformation>
<BrowseInformationFile>$(IntDir)</BrowseInformationFile>
<CompileAs>CompileAsCpp</CompileAs>
<ErrorReporting>Prompt</ErrorReporting>
<WarningLevel>Level3</WarningLevel>
<UndefinePreprocessorDefinitions>
</UndefinePreprocessorDefinitions>
<AdditionalOptions>/Zo %(AdditionalOptions)</AdditionalOptions>
</ClCompile>
<PreLinkEvent>
<Command>
</Command>
</PreLinkEvent>
<Lib>
<UseUnicodeResponseFiles>false</UseUnicodeResponseFiles>
<AdditionalDependencies>Rpcrt4.lib;%(AdditionalDependencies)</AdditionalDependencies>
<SuppressStartupBanner>true</SuppressStartupBanner>
</Lib>
<Xdcmake>
<SuppressStartupBanner>true</SuppressStartupBanner>
</Xdcmake>
<Bscmake>
<SuppressStartupBanner>true</SuppressStartupBanner>
<OutputFile>$(OutDir)tier1.bsc</OutputFile>
</Bscmake>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="bitbuf.cpp" />
<ClCompile Include="generichash.cpp" />
<ClCompile Include="rangecheckedvar.cpp" />
<ClCompile Include="tier1.cpp" />
<ClCompile Include="utlbufferutil.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\public\tier1\bitbuf.h" />
<ClInclude Include="..\public\tier1\cbyteswap.h" />
<ClInclude Include="..\public\tier1\callqueue.h" />
<ClInclude Include="..\public\tier1\characterset.h" />
<ClInclude Include="..\public\tier1\checksum_crc.h" />
<ClInclude Include="..\public\tier1\checksum_md5.h" />
<ClInclude Include="..\public\tier1\CommandBuffer.h" />
<ClInclude Include="..\public\tier1\convar.h" />
<ClInclude Include="..\public\tier1\datamanager.h" />
<ClInclude Include="..\public\datamap.h" />
<ClInclude Include="..\public\tier1\delegates.h" />
<ClInclude Include="..\public\tier1\diff.h" />
<ClInclude Include="..\public\tier1\fmtstr.h" />
<ClInclude Include="..\public\tier1\functors.h" />
<ClInclude Include="..\public\tier1\generichash.h" />
<ClInclude Include="..\public\tier1\iconvar.h" />
<ClInclude Include="..\public\tier1\KeyValues.h" />
<ClInclude Include="..\public\tier1\lzmaDecoder.h" />
<ClInclude Include="..\public\tier1\lzss.h" />
<ClInclude Include="..\public\tier1\mempool.h" />
<ClInclude Include="..\public\tier1\memstack.h" />
<ClInclude Include="..\public\tier1\netadr.h" />
<ClInclude Include="..\public\tier1\processor_detect.h" />
<ClInclude Include="..\public\tier1\rangecheckedvar.h" />
<ClInclude Include="..\public\tier1\refcount.h" />
<ClInclude Include="..\public\tier1\smartptr.h" />
<ClInclude Include="..\public\tier1\stringpool.h" />
<ClInclude Include="..\public\tier1\strtools.h" />
<ClInclude Include="..\public\tier1\tier1.h" />
<ClInclude Include="..\public\tier1\uniqueid.h" />
<ClInclude Include="..\public\tier1\utlbidirectionalset.h" />
<ClInclude Include="..\public\tier1\utlblockmemory.h" />
<ClInclude Include="..\public\tier1\utlbuffer.h" />
<ClInclude Include="..\public\tier1\utlbufferutil.h" />
<ClInclude Include="..\public\tier1\utldict.h" />
<ClInclude Include="..\public\tier1\utlenvelope.h" />
<ClInclude Include="..\public\tier1\utlfixedmemory.h" />
<ClInclude Include="..\public\tier1\utlhandletable.h" />
<ClInclude Include="..\public\tier1\utlhash.h" />
<ClInclude Include="..\public\tier1\utllinkedlist.h" />
<ClInclude Include="..\public\tier1\utlmap.h" />
<ClInclude Include="..\public\tier1\utlvectormemory.h" />
<ClInclude Include="..\public\tier1\utlmultilist.h" />
<ClInclude Include="..\public\tier1\utlpriorityqueue.h" />
<ClInclude Include="..\public\tier1\utlqueue.h" />
<ClInclude Include="..\public\tier1\utlrbtree.h" />
<ClInclude Include="..\public\tier1\UtlSortVector.h" />
<ClInclude Include="..\public\tier1\utlstack.h" />
<ClInclude Include="..\public\tier1\UtlStringMap.h" />
<ClInclude Include="..\public\tier1\utlsymbol.h" />
<ClInclude Include="..\public\tier1\utlvector.h" />
<ClInclude Include="..\common\xbox\xboxstubs.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
-188
View File
@@ -1,188 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Source Files">
<UniqueIdentifier>{aba1d919-d95c-4c3f-a495-be0375bab184}</UniqueIdentifier>
<Extensions>cpp;c;cxx;rc;def;r;odl;idl;hpj;bat</Extensions>
</Filter>
<Filter Include="Header Files">
<UniqueIdentifier>{0295d938-2af6-4393-9785-4b7b122313c9}</UniqueIdentifier>
<Extensions>h;hpp;hxx;hm;inl</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="bitbuf.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="generichash.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="rangecheckedvar.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tier1.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="utlbufferutil.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\public\tier1\bitbuf.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\cbyteswap.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\callqueue.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\characterset.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\checksum_crc.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\checksum_md5.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\CommandBuffer.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\convar.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\datamanager.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\datamap.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\delegates.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\diff.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\fmtstr.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\functors.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\generichash.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\iconvar.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\KeyValues.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\lzmaDecoder.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\lzss.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\mempool.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\memstack.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\netadr.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\processor_detect.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\rangecheckedvar.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\refcount.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\smartptr.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\stringpool.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\strtools.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\tier1.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\uniqueid.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlbidirectionalset.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlblockmemory.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlbuffer.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlbufferutil.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utldict.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlenvelope.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlfixedmemory.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlhandletable.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlhash.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utllinkedlist.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlmap.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlvectormemory.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlmultilist.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlpriorityqueue.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlqueue.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlrbtree.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\UtlSortVector.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlstack.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\UtlStringMap.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlsymbol.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\public\tier1\utlvector.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\common\xbox\xboxstubs.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
</Project>