First version of the SOurce SDK 2013

mp/src/tier1/NetAdr.cpp

@@ -0,0 +1,326 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// NetAdr.cpp: implementation of the CNetAdr class.
+//
+//===========================================================================//
+#if defined( _WIN32 ) && !defined( _X360 )
+#include <windows.h>
+#endif
+
+#include "tier0/dbg.h"
+#include "netadr.h"
+#include "tier1/strtools.h"
+
+#if defined( _WIN32 ) && !defined( _X360 )
+#define WIN32_LEAN_AND_MEAN
+#include <winsock.h>
+typedef int socklen_t;
+#elif !defined( _X360 )
+#include <netinet/in.h> // ntohs()
+#include <netdb.h>		// gethostbyname()
+#include <sys/socket.h>	// getsockname()
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+bool netadr_t::CompareAdr (const netadr_t &a, bool onlyBase) const
+{
+	if ( a.type != type )
+		return false;
+
+	if ( type == NA_LOOPBACK )
+		return true;
+
+	if ( type == NA_BROADCAST )
+		return true;
+
+	if ( type == NA_IP )
+	{
+		if ( !onlyBase && (port != a.port) )
+			return false;
+
+		if ( a.ip[0] == ip[0] && a.ip[1] == ip[1] && a.ip[2] == ip[2] && a.ip[3] == ip[3] )
+			return true;
+	}
+
+	return false;
+}
+
+bool netadr_t::CompareClassBAdr (const netadr_t &a) const
+{
+	if ( a.type != type )
+		return false;
+
+	if ( type == NA_LOOPBACK )
+		return true;
+
+	if ( type == NA_IP )
+	{
+		if (a.ip[0] == ip[0] && a.ip[1] == ip[1] )
+			return true;
+	}
+
+	return false;
+}
+
+bool netadr_t::CompareClassCAdr (const netadr_t &a) const
+{
+	if ( a.type != type )
+		return false;
+
+	if ( type == NA_LOOPBACK )
+		return true;
+
+	if ( type == NA_IP )
+	{
+		if (a.ip[0] == ip[0] && a.ip[1] == ip[1] && a.ip[2] == ip[2] )
+			return true;
+	}
+
+	return false;
+}
+// reserved addresses are not routeable, so they can all be used in a LAN game
+bool netadr_t::IsReservedAdr () const
+{
+	if ( type == NA_LOOPBACK )
+		return true;
+
+	if ( type == NA_IP )
+	{
+		if ( (ip[0] == 10) ||									// 10.x.x.x is reserved
+			 (ip[0] == 127) ||									// 127.x.x.x 
+			 (ip[0] == 172 && ip[1] >= 16 && ip[1] <= 31) ||	// 172.16.x.x  - 172.31.x.x 
+			 (ip[0] == 192 && ip[1] >= 168) ) 					// 192.168.x.x
+			return true;
+	}
+	return false;
+}
+
+const char * netadr_t::ToString(bool baseOnly) const
+{
+	static	char	s[64];
+
+	Q_strncpy (s, "unknown", sizeof( s ) );
+
+	if (type == NA_LOOPBACK)
+	{
+		Q_strncpy (s, "loopback", sizeof( s ) );
+	}
+	else if (type == NA_BROADCAST)
+	{
+		Q_strncpy (s, "broadcast", sizeof( s ) );
+	}
+	else if (type == NA_IP)
+	{
+		if ( baseOnly)
+		{
+			Q_snprintf (s, sizeof( s ), "%i.%i.%i.%i", ip[0], ip[1], ip[2], ip[3]);
+		}
+		else
+		{
+			Q_snprintf (s, sizeof( s ), "%i.%i.%i.%i:%i", ip[0], ip[1], ip[2], ip[3], ntohs(port));
+		}
+	}
+
+	return s;
+}
+
+bool netadr_t::IsLocalhost() const
+{
+	// are we 127.0.0.1 ?
+	return (ip[0] == 127) && (ip[1] == 0) && (ip[2] == 0) && (ip[3] == 1);
+}
+
+bool netadr_t::IsLoopback() const
+{
+	// are we useding engine loopback buffers
+	return type == NA_LOOPBACK;
+}
+
+void netadr_t::Clear()
+{
+	ip[0] = ip[1] = ip[2] = ip[3] = 0;
+	port = 0;
+	type = NA_NULL;
+}
+
+void netadr_t::SetIP(uint8 b1, uint8 b2, uint8 b3, uint8 b4)
+{
+	ip[0] = b1;
+	ip[1] = b2;
+	ip[2] = b3;
+	ip[3] = b4;
+}
+
+void netadr_t::SetIP(uint unIP)
+{
+	*((uint*)ip) = BigLong( unIP );
+}
+
+void netadr_t::SetType(netadrtype_t newtype)
+{
+	type = newtype;
+}
+
+netadrtype_t netadr_t::GetType() const
+{
+	return type;
+}
+
+unsigned short netadr_t::GetPort() const
+{
+	return BigShort( port );
+}
+
+unsigned int netadr_t::GetIPNetworkByteOrder() const
+{
+	return *(unsigned int *)&ip;
+}
+
+unsigned int netadr_t::GetIPHostByteOrder() const
+{
+	return ntohl( GetIPNetworkByteOrder() );
+}
+
+
+void netadr_t::ToSockadr (struct sockaddr * s) const
+{
+	Q_memset ( s, 0, sizeof(struct sockaddr));
+
+	if (type == NA_BROADCAST)
+	{
+		((struct sockaddr_in*)s)->sin_family = AF_INET;
+		((struct sockaddr_in*)s)->sin_port = port;
+		((struct sockaddr_in*)s)->sin_addr.s_addr = INADDR_BROADCAST;
+	}
+	else if (type == NA_IP)
+	{
+		((struct sockaddr_in*)s)->sin_family = AF_INET;
+		((struct sockaddr_in*)s)->sin_addr.s_addr = *(int *)&ip;
+		((struct sockaddr_in*)s)->sin_port = port;
+	}
+	else if (type == NA_LOOPBACK )
+	{
+		((struct sockaddr_in*)s)->sin_family = AF_INET;
+		((struct sockaddr_in*)s)->sin_port = port;
+		((struct sockaddr_in*)s)->sin_addr.s_addr = INADDR_LOOPBACK ;
+	}
+}
+
+bool netadr_t::SetFromSockadr(const struct sockaddr * s)
+{
+	if (s->sa_family == AF_INET)
+	{
+		type = NA_IP;
+		*(int *)&ip = ((struct sockaddr_in *)s)->sin_addr.s_addr;
+		port = ((struct sockaddr_in *)s)->sin_port;
+		return true;
+	}
+	else
+	{
+		Clear();
+		return false;
+	}
+}
+
+bool netadr_t::IsValid() const
+{
+	return ( (port !=0 ) && (type != NA_NULL) &&
+			 ( ip[0] != 0 || ip[1] != 0 || ip[2] != 0 || ip[3] != 0 ) );
+}
+
+#ifdef _WIN32
+#undef SetPort	// get around stupid WINSPOOL.H macro
+#endif
+
+void netadr_t::SetPort(unsigned short newport)
+{
+	port = BigShort( newport );
+}
+
+void netadr_t::SetFromString( const char *pch, bool bUseDNS )
+{
+	Clear();
+	type = NA_IP;
+
+	Assert( pch );		// invalid to call this with NULL pointer; fix your code bug!
+	if ( !pch )			// but let's not crash
+		return;
+
+
+	if ( pch[0] >= '0' && pch[0] <= '9' && strchr( pch, '.' ) )
+	{
+		int n1 = 0, n2 = 0, n3 = 0, n4 = 0, n5 = 0;
+		int nRes = sscanf( pch, "%d.%d.%d.%d:%d", &n1, &n2, &n3, &n4, &n5 );
+		if ( nRes >= 4 )
+		{
+			SetIP( n1, n2, n3, n4 );
+		}
+
+		if ( nRes == 5 )
+		{
+			SetPort( ( uint16 ) n5 );
+		}
+	}
+	else if ( bUseDNS )
+	{
+// X360TBD:
+#if !defined( _X360 )
+		char szHostName[ 256 ];
+		Q_strncpy( szHostName, pch, sizeof(szHostName) );
+		char *pchColon = strchr( szHostName, ':' );
+		if ( pchColon )
+		{
+			*pchColon = 0;
+		}
+		
+		// DNS it
+		struct hostent *h = gethostbyname( szHostName );
+		if ( !h )
+			return;
+
+		SetIP( ntohl( *(int *)h->h_addr_list[0]  ) );
+
+		if ( pchColon )
+		{
+			SetPort( atoi( ++pchColon ) );
+		}
+#else
+		Assert( 0 );
+#endif
+	}
+}
+
+bool netadr_t::operator<(const netadr_t &netadr) const
+{
+	if ( *((uint *)netadr.ip) < *((uint *)ip) )
+		return true;
+	else if ( *((uint *)netadr.ip) > *((uint *)ip) )
+		return false;
+	return ( netadr.port < port );
+}
+
+
+void netadr_t::SetFromSocket( int hSocket )
+{	
+#if !defined(_X360)
+	Clear();
+	type = NA_IP;
+
+	struct sockaddr address;
+	int namelen = sizeof(address);
+	if ( getsockname( hSocket, (struct sockaddr *)&address, (socklen_t *)&namelen) == 0 )
+	{
+		SetFromSockadr( &address );
+	}
+#else
+	Assert(0);
+#endif
+}

mp/src/tier1/byteswap.cpp

@@ -0,0 +1,90 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Low level byte swapping routines.
+//
+// $NoKeywords: $
+//=============================================================================
+
+#include "byteswap.h"
+
+//-----------------------------------------------------------------------------
+// Copy a single field from the input buffer to the output buffer, swapping the bytes if necessary
+//-----------------------------------------------------------------------------
+void CByteswap::SwapFieldToTargetEndian( void* pOutputBuffer, void *pData, typedescription_t *pField )
+{
+	switch ( pField->fieldType )
+	{
+	case FIELD_CHARACTER:
+		SwapBufferToTargetEndian<char>( (char*)pOutputBuffer, (char*)pData, pField->fieldSize );
+		break;
+
+	case FIELD_BOOLEAN:
+		SwapBufferToTargetEndian<bool>( (bool*)pOutputBuffer, (bool*)pData, pField->fieldSize );
+		break;
+
+	case FIELD_SHORT:
+		SwapBufferToTargetEndian<short>( (short*)pOutputBuffer, (short*)pData, pField->fieldSize );
+		break;
+
+	case FIELD_FLOAT:
+		SwapBufferToTargetEndian<uint>( (uint*)pOutputBuffer, (uint*)pData, pField->fieldSize );
+		break;
+
+	case FIELD_INTEGER:
+		SwapBufferToTargetEndian<int>( (int*)pOutputBuffer, (int*)pData, pField->fieldSize );
+		break;
+
+	case FIELD_VECTOR:
+		SwapBufferToTargetEndian<uint>( (uint*)pOutputBuffer, (uint*)pData, pField->fieldSize * 3 );
+		break;
+
+	case FIELD_VECTOR2D:
+		SwapBufferToTargetEndian<uint>( (uint*)pOutputBuffer, (uint*)pData, pField->fieldSize * 2 );
+		break;
+
+	case FIELD_QUATERNION:
+		SwapBufferToTargetEndian<uint>( (uint*)pOutputBuffer, (uint*)pData, pField->fieldSize * 4 );
+		break;
+
+	case FIELD_EMBEDDED:
+		{
+			typedescription_t *pEmbed = pField->td->dataDesc;
+			for ( int i = 0; i < pField->fieldSize; ++i )
+			{
+				SwapFieldsToTargetEndian( (byte*)pOutputBuffer + pEmbed->fieldOffset[ TD_OFFSET_NORMAL ], 
+										(byte*)pData + pEmbed->fieldOffset[ TD_OFFSET_NORMAL ],  
+										pField->td );
+
+				pOutputBuffer = (byte*)pOutputBuffer + pField->fieldSizeInBytes;
+				pData = (byte*)pData + pField->fieldSizeInBytes;
+			}
+		}
+		break;
+		
+	default:
+		assert(0); 
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Write a block of fields. Works a bit like the saverestore code.  
+//-----------------------------------------------------------------------------
+void CByteswap::SwapFieldsToTargetEndian( void *pOutputBuffer, void *pBaseData, datamap_t *pDataMap )
+{	
+	// deal with base class first
+	if ( pDataMap->baseMap )
+	{
+		SwapFieldsToTargetEndian( pOutputBuffer, pBaseData, pDataMap->baseMap );
+	}
+
+	typedescription_t *pFields = pDataMap->dataDesc;
+	int fieldCount = pDataMap->dataNumFields;
+	for ( int i = 0; i < fieldCount; ++i )
+	{
+		typedescription_t *pField = &pFields[i];
+		SwapFieldToTargetEndian( (BYTE*)pOutputBuffer + pField->fieldOffset[ TD_OFFSET_NORMAL ],  
+								 (BYTE*)pBaseData + pField->fieldOffset[ TD_OFFSET_NORMAL ], 
+								  pField );
+	}
+}
+

mp/src/tier1/characterset.cpp

@@ -0,0 +1,41 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================
+
+#include <string.h>
+#include "characterset.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: builds a simple lookup table of a group of important characters
+// Input  : *pParseGroup - pointer to the buffer for the group
+//			*pGroupString - null terminated list of characters to flag
+//-----------------------------------------------------------------------------
+void CharacterSetBuild( characterset_t *pSetBuffer, const char *pszSetString )
+{
+	int i = 0;
+
+	// Test our pointers
+	if ( !pSetBuffer || !pszSetString )
+		return;
+
+	memset( pSetBuffer->set, 0, sizeof(pSetBuffer->set) );
+
+	while ( pszSetString[i] )
+	{
+		pSetBuffer->set[ pszSetString[i] ] = 1;
+		i++;
+	}
+
+}

mp/src/tier1/checksum_crc.cpp

@@ -0,0 +1,180 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Generic CRC functions
+//
+//=============================================================================//
+
+#include "basetypes.h"
+#include "commonmacros.h"
+#include "checksum_crc.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#define CRC32_INIT_VALUE 0xFFFFFFFFUL
+#define CRC32_XOR_VALUE  0xFFFFFFFFUL
+
+#define NUM_BYTES 256
+static const CRC32_t pulCRCTable[NUM_BYTES] =
+{
+    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
+    0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
+    0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+    0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
+    0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+    0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
+    0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
+    0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+    0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
+    0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
+    0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+    0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
+    0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
+    0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
+    0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+    0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+    0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
+    0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
+    0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+    0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
+    0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+    0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
+    0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
+    0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
+    0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+    0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
+    0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+    0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
+    0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
+    0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+    0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+    0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
+    0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
+    0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
+    0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
+    0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
+    0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
+    0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+    0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+    0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
+    0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
+    0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+    0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+    0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+    0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
+    0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
+    0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
+    0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
+    0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+};
+
+void CRC32_Init(CRC32_t *pulCRC)
+{
+	*pulCRC = CRC32_INIT_VALUE;
+}
+
+void CRC32_Final(CRC32_t *pulCRC)
+{
+	*pulCRC ^= CRC32_XOR_VALUE;
+}
+
+CRC32_t	CRC32_GetTableEntry( unsigned int slot )
+{
+	return pulCRCTable[(unsigned char)slot];
+}
+
+void CRC32_ProcessBuffer(CRC32_t *pulCRC, const void *pBuffer, int nBuffer)
+{
+	CRC32_t ulCrc = *pulCRC;
+	unsigned char *pb = (unsigned char *)pBuffer;
+    unsigned int nFront;
+    int nMain;
+
+JustAfew:
+
+    switch (nBuffer)
+    {
+    case 7:
+        ulCrc  = pulCRCTable[*pb++ ^ (unsigned char)ulCrc] ^ (ulCrc >> 8);
+
+    case 6:
+        ulCrc  = pulCRCTable[*pb++ ^ (unsigned char)ulCrc] ^ (ulCrc >> 8);
+
+    case 5:
+        ulCrc  = pulCRCTable[*pb++ ^ (unsigned char)ulCrc] ^ (ulCrc >> 8);
+
+    case 4:
+        ulCrc ^= LittleLong( *(CRC32_t *)pb );
+        ulCrc  = pulCRCTable[(unsigned char)ulCrc] ^ (ulCrc >> 8);
+        ulCrc  = pulCRCTable[(unsigned char)ulCrc] ^ (ulCrc >> 8);
+        ulCrc  = pulCRCTable[(unsigned char)ulCrc] ^ (ulCrc >> 8);
+        ulCrc  = pulCRCTable[(unsigned char)ulCrc] ^ (ulCrc >> 8);
+		*pulCRC = ulCrc;
+        return;
+
+    case 3:
+        ulCrc  = pulCRCTable[*pb++ ^ (unsigned char)ulCrc] ^ (ulCrc >> 8);
+
+    case 2:
+        ulCrc  = pulCRCTable[*pb++ ^ (unsigned char)ulCrc] ^ (ulCrc >> 8);
+
+    case 1:
+        ulCrc  = pulCRCTable[*pb++ ^ (unsigned char)ulCrc] ^ (ulCrc >> 8);
+
+    case 0:
+		*pulCRC = ulCrc;
+        return;
+    }
+
+    // We may need to do some alignment work up front, and at the end, so that
+    // the main loop is aligned and only has to worry about 8 byte at a time.
+    //
+    // The low-order two bits of pb and nBuffer in total control the
+    // upfront work.
+    //
+    nFront = ((unsigned int)pb) & 3;
+    nBuffer -= nFront;
+    switch (nFront)
+    {
+    case 3:
+        ulCrc  = pulCRCTable[*pb++ ^ (unsigned char)ulCrc] ^ (ulCrc >> 8);
+    case 2:
+        ulCrc  = pulCRCTable[*pb++ ^ (unsigned char)ulCrc] ^ (ulCrc >> 8);
+    case 1:
+        ulCrc  = pulCRCTable[*pb++ ^ (unsigned char)ulCrc] ^ (ulCrc >> 8);
+    }
+
+    nMain = nBuffer >> 3;
+    while (nMain--)
+    {
+        ulCrc ^= LittleLong( *(CRC32_t *)pb );
+        ulCrc  = pulCRCTable[(unsigned char)ulCrc] ^ (ulCrc >> 8);
+        ulCrc  = pulCRCTable[(unsigned char)ulCrc] ^ (ulCrc >> 8);
+        ulCrc  = pulCRCTable[(unsigned char)ulCrc] ^ (ulCrc >> 8);
+        ulCrc  = pulCRCTable[(unsigned char)ulCrc] ^ (ulCrc >> 8);
+        ulCrc ^= LittleLong( *(CRC32_t *)(pb + 4) );
+        ulCrc  = pulCRCTable[(unsigned char)ulCrc] ^ (ulCrc >> 8);
+        ulCrc  = pulCRCTable[(unsigned char)ulCrc] ^ (ulCrc >> 8);
+        ulCrc  = pulCRCTable[(unsigned char)ulCrc] ^ (ulCrc >> 8);
+        ulCrc  = pulCRCTable[(unsigned char)ulCrc] ^ (ulCrc >> 8);
+        pb += 8;
+    }
+
+    nBuffer &= 7;
+    goto JustAfew;
+}

mp/src/tier1/checksum_md5.cpp

@@ -0,0 +1,305 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//===========================================================================//
+
+#include "basetypes.h"
+#include "commonmacros.h"
+#include "checksum_md5.h"
+#include <string.h>
+#include <stdio.h>
+#include "tier1/strtools.h"
+#include "tier0/dbg.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+// The four core functions - F1 is optimized somewhat
+// #define F1(x, y, z) (x & y | ~x & z)
+#define F1(x, y, z) (z ^ (x & (y ^ z)))
+#define F2(x, y, z) F1(z, x, y)
+#define F3(x, y, z) (x ^ y ^ z)
+#define F4(x, y, z) (y ^ (x | ~z))
+
+// This is the central step in the MD5 algorithm.
+#define MD5STEP(f, w, x, y, z, data, s) \
+        ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+
+//-----------------------------------------------------------------------------
+// Purpose: The core of the MD5 algorithm, this alters an existing MD5 hash to
+//  reflect the addition of 16 longwords of new data.  MD5Update blocks
+//  the data and converts bytes into longwords for this routine.
+// Input  : buf[4] - 
+//			in[16] - 
+// Output : static void
+//-----------------------------------------------------------------------------
+static void MD5Transform(unsigned int buf[4], unsigned int const in[16])
+{
+    register unsigned int a, b, c, d;
+
+    a = buf[0];
+    b = buf[1];
+    c = buf[2];
+    d = buf[3];
+
+    MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
+    MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
+    MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
+    MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
+    MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
+    MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
+    MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
+    MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
+    MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
+    MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
+    MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
+    MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
+    MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
+    MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
+    MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
+    MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
+
+    MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
+    MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
+    MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
+    MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
+    MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
+    MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
+    MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
+    MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
+    MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
+    MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
+    MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
+    MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
+    MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
+    MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
+    MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
+    MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
+
+    MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
+    MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
+    MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
+    MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
+    MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
+    MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
+    MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
+    MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
+    MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
+    MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
+    MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
+    MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
+    MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
+    MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
+    MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
+    MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
+
+    MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
+    MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
+    MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
+    MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
+    MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
+    MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
+    MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
+    MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
+    MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
+    MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
+    MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
+    MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
+    MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
+    MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
+    MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
+    MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
+
+    buf[0] += a;
+    buf[1] += b;
+    buf[2] += c;
+    buf[3] += d;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious initialization constants.
+
+// Input  : *ctx - 
+//-----------------------------------------------------------------------------
+void MD5Init(MD5Context_t *ctx)
+{
+    ctx->buf[0] = 0x67452301;
+    ctx->buf[1] = 0xefcdab89;
+    ctx->buf[2] = 0x98badcfe;
+    ctx->buf[3] = 0x10325476;
+
+    ctx->bits[0] = 0;
+    ctx->bits[1] = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Update context to reflect the concatenation of another buffer full of bytes.
+// Input  : *ctx - 
+//			*buf - 
+//			len - 
+//-----------------------------------------------------------------------------
+void MD5Update(MD5Context_t *ctx, unsigned char const *buf, unsigned int len)
+{
+    unsigned int t;
+
+    /* Update bitcount */
+
+    t = ctx->bits[0];
+    if ((ctx->bits[0] = t + ((unsigned int) len << 3)) < t)
+        ctx->bits[1]++;         /* Carry from low to high */
+    ctx->bits[1] += len >> 29;
+
+    t = (t >> 3) & 0x3f;        /* Bytes already in shsInfo->data */
+
+    /* Handle any leading odd-sized chunks */
+
+    if (t)
+	{
+        unsigned char *p = (unsigned char *) ctx->in + t;
+
+        t = 64 - t;
+        if (len < t)
+		{
+            memcpy(p, buf, len);
+            return;
+        }
+        memcpy(p, buf, t);
+        //byteReverse(ctx->in, 16);
+        MD5Transform(ctx->buf, (unsigned int *) ctx->in);
+        buf += t;
+        len -= t;
+    }
+    /* Process data in 64-byte chunks */
+
+    while (len >= 64)
+	{
+        memcpy(ctx->in, buf, 64);
+        //byteReverse(ctx->in, 16);
+        MD5Transform(ctx->buf, (unsigned int *) ctx->in);
+        buf += 64;
+        len -= 64;
+    }
+
+    /* Handle any remaining bytes of data. */
+    memcpy(ctx->in, buf, len);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Final wrapup - pad to 64-byte boundary with the bit pattern 
+// 1 0* (64-bit count of bits processed, MSB-first)
+// Input  : digest[MD5_DIGEST_LENGTH] - 
+//			*ctx - 
+//-----------------------------------------------------------------------------
+void MD5Final(unsigned char digest[MD5_DIGEST_LENGTH], MD5Context_t *ctx)
+{
+    unsigned count;
+    unsigned char *p;
+
+    /* Compute number of bytes mod 64 */
+    count = (ctx->bits[0] >> 3) & 0x3F;
+
+    /* Set the first char of padding to 0x80.  This is safe since there is
+       always at least one byte free */
+    p = ctx->in + count;
+    *p++ = 0x80;
+
+    /* Bytes of padding needed to make 64 bytes */
+    count = 64 - 1 - count;
+
+    /* Pad out to 56 mod 64 */
+    if (count < 8)
+	{
+        /* Two lots of padding:  Pad the first block to 64 bytes */
+        memset(p, 0, count);
+        //byteReverse(ctx->in, 16);
+        MD5Transform(ctx->buf, (unsigned int *) ctx->in);
+
+        /* Now fill the next block with 56 bytes */
+        memset(ctx->in, 0, 56);
+    }
+	else
+	{
+        /* Pad block to 56 bytes */
+        memset(p, 0, count - 8);
+    }
+    //byteReverse(ctx->in, 14);
+
+    /* Append length in bits and transform */
+    ((unsigned int *) ctx->in)[14] = ctx->bits[0];
+    ((unsigned int *) ctx->in)[15] = ctx->bits[1];
+
+    MD5Transform(ctx->buf, (unsigned int *) ctx->in);
+    //byteReverse((unsigned char *) ctx->buf, 4);
+    memcpy(digest, ctx->buf, MD5_DIGEST_LENGTH);
+    memset(ctx, 0, sizeof(*ctx));        /* In case it's sensitive */
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *hash - 
+//			hashlen - 
+// Output : char
+//-----------------------------------------------------------------------------
+char *MD5_Print( unsigned char *hash, int hashlen )
+{
+	static char szReturn[64];
+
+	Assert( hashlen <= 32 );
+
+	Q_binarytohex( hash, hashlen, szReturn, sizeof( szReturn ) );
+	return szReturn;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: generate pseudo random number from a seed number
+// Input  : seed number
+// Output : pseudo random number
+//-----------------------------------------------------------------------------
+unsigned int MD5_PseudoRandom(unsigned int nSeed)
+{
+	MD5Context_t ctx;
+	unsigned char digest[MD5_DIGEST_LENGTH]; // The MD5 Hash
+
+	memset( &ctx, 0, sizeof( ctx ) );
+		
+	MD5Init(&ctx);
+	MD5Update(&ctx, (unsigned char*)&nSeed, sizeof(nSeed) );
+	MD5Final(digest, &ctx);
+
+	return *(unsigned int*)(digest+6);	// use 4 middle bytes for random value
+}
+
+//-----------------------------------------------------------------------------
+bool MD5_Compare( const MD5Value_t &data, const MD5Value_t &compare )
+{
+	return V_memcmp( data.bits, compare.bits, MD5_DIGEST_LENGTH ) == 0;
+}
+
+//-----------------------------------------------------------------------------
+void MD5Value_t::Zero()
+{
+	V_memset( bits, 0, sizeof( bits ) );
+}
+
+//-----------------------------------------------------------------------------
+bool MD5Value_t::IsZero() const
+{
+	for ( int i = 0 ; i < Q_ARRAYSIZE( bits ) ; ++i )
+	{
+		if ( bits[i] != 0 )
+			return false;
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+void MD5_ProcessSingleBuffer( const void *p, int len, MD5Value_t &md5Result )
+{
+	Assert( len >= 0 );
+	MD5Context_t ctx;
+	MD5Init( &ctx );
+	MD5Update( &ctx, (unsigned char const *)p, len );
+	MD5Final( md5Result.bits, &ctx );
+}

mp/src/tier1/checksum_sha1.cpp

@@ -0,0 +1,299 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Implementation of SHA-1
+//
+//=============================================================================
+
+/*
+	100% free public domain implementation of the SHA-1
+	algorithm by Dominik Reichl <dominik.reichl@t-online.de>
+
+
+	=== Test Vectors (from FIPS PUB 180-1) ===
+
+	SHA1("abc") =
+		A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
+
+	SHA1("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") =
+		84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
+
+	SHA1(A million repetitions of "a") =
+		34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
+*/
+
+#if !defined(_MINIMUM_BUILD_)
+#include "checksum_sha1.h"
+#else
+//
+//	This path is build in the CEG/DRM projects where we require that no CRT references are made !
+//
+#include <intrin.h>				// memcpy, memset etc... will be inlined.
+#include "tier1/checksum_sha1.h"
+#endif
+
+#define MAX_FILE_READ_BUFFER 8000
+
+// Rotate x bits to the left
+#ifndef ROL32
+#define ROL32(_val32, _nBits) (((_val32)<<(_nBits))|((_val32)>>(32-(_nBits))))
+#endif
+
+#ifdef SHA1_LITTLE_ENDIAN
+	#define SHABLK0(i) (m_block->l[i] = \
+		(ROL32(m_block->l[i],24) & 0xFF00FF00) | (ROL32(m_block->l[i],8) & 0x00FF00FF))
+#else
+	#define SHABLK0(i) (m_block->l[i])
+#endif
+
+#define SHABLK(i) (m_block->l[i&15] = ROL32(m_block->l[(i+13)&15] ^ m_block->l[(i+8)&15] \
+	^ m_block->l[(i+2)&15] ^ m_block->l[i&15],1))
+
+// SHA-1 rounds
+#define _R0(v,w,x,y,z,i) { z+=((w&(x^y))^y)+SHABLK0(i)+0x5A827999+ROL32(v,5); w=ROL32(w,30); }
+#define _R1(v,w,x,y,z,i) { z+=((w&(x^y))^y)+SHABLK(i)+0x5A827999+ROL32(v,5); w=ROL32(w,30); }
+#define _R2(v,w,x,y,z,i) { z+=(w^x^y)+SHABLK(i)+0x6ED9EBA1+ROL32(v,5); w=ROL32(w,30); }
+#define _R3(v,w,x,y,z,i) { z+=(((w|x)&y)|(w&x))+SHABLK(i)+0x8F1BBCDC+ROL32(v,5); w=ROL32(w,30); }
+#define _R4(v,w,x,y,z,i) { z+=(w^x^y)+SHABLK(i)+0xCA62C1D6+ROL32(v,5); w=ROL32(w,30); }
+
+#ifdef	_MINIMUM_BUILD_
+Minimum_CSHA1::Minimum_CSHA1()
+#else
+CSHA1::CSHA1()
+#endif
+{
+	m_block = (SHA1_WORKSPACE_BLOCK *)m_workspace;
+
+	Reset();
+}
+#ifdef	_MINIMUM_BUILD_
+Minimum_CSHA1::~Minimum_CSHA1()
+#else
+CSHA1::~CSHA1()
+#endif
+{
+	// Reset();
+}
+#ifdef	_MINIMUM_BUILD_
+void Minimum_CSHA1::Reset() 
+#else
+void CSHA1::Reset()
+#endif
+{
+	// SHA1 initialization constants
+	m_state[0] = 0x67452301;
+	m_state[1] = 0xEFCDAB89;
+	m_state[2] = 0x98BADCFE;
+	m_state[3] = 0x10325476;
+	m_state[4] = 0xC3D2E1F0;
+
+	m_count[0] = 0;
+	m_count[1] = 0;
+}
+
+#ifdef	_MINIMUM_BUILD_
+void Minimum_CSHA1::Transform(unsigned long state[5], unsigned char buffer[64])
+#else
+void CSHA1::Transform(unsigned long state[5], unsigned char buffer[64])
+#endif
+{
+	unsigned long a = 0, b = 0, c = 0, d = 0, e = 0;
+
+	memcpy(m_block, buffer, 64);
+
+	// Copy state[] to working vars
+	a = state[0];
+	b = state[1];
+	c = state[2];
+	d = state[3];
+	e = state[4];
+
+	// 4 rounds of 20 operations each. Loop unrolled.
+	_R0(a,b,c,d,e, 0); _R0(e,a,b,c,d, 1); _R0(d,e,a,b,c, 2); _R0(c,d,e,a,b, 3);
+	_R0(b,c,d,e,a, 4); _R0(a,b,c,d,e, 5); _R0(e,a,b,c,d, 6); _R0(d,e,a,b,c, 7);
+	_R0(c,d,e,a,b, 8); _R0(b,c,d,e,a, 9); _R0(a,b,c,d,e,10); _R0(e,a,b,c,d,11);
+	_R0(d,e,a,b,c,12); _R0(c,d,e,a,b,13); _R0(b,c,d,e,a,14); _R0(a,b,c,d,e,15);
+	_R1(e,a,b,c,d,16); _R1(d,e,a,b,c,17); _R1(c,d,e,a,b,18); _R1(b,c,d,e,a,19);
+	_R2(a,b,c,d,e,20); _R2(e,a,b,c,d,21); _R2(d,e,a,b,c,22); _R2(c,d,e,a,b,23);
+	_R2(b,c,d,e,a,24); _R2(a,b,c,d,e,25); _R2(e,a,b,c,d,26); _R2(d,e,a,b,c,27);
+	_R2(c,d,e,a,b,28); _R2(b,c,d,e,a,29); _R2(a,b,c,d,e,30); _R2(e,a,b,c,d,31);
+	_R2(d,e,a,b,c,32); _R2(c,d,e,a,b,33); _R2(b,c,d,e,a,34); _R2(a,b,c,d,e,35);
+	_R2(e,a,b,c,d,36); _R2(d,e,a,b,c,37); _R2(c,d,e,a,b,38); _R2(b,c,d,e,a,39);
+	_R3(a,b,c,d,e,40); _R3(e,a,b,c,d,41); _R3(d,e,a,b,c,42); _R3(c,d,e,a,b,43);
+	_R3(b,c,d,e,a,44); _R3(a,b,c,d,e,45); _R3(e,a,b,c,d,46); _R3(d,e,a,b,c,47);
+	_R3(c,d,e,a,b,48); _R3(b,c,d,e,a,49); _R3(a,b,c,d,e,50); _R3(e,a,b,c,d,51);
+	_R3(d,e,a,b,c,52); _R3(c,d,e,a,b,53); _R3(b,c,d,e,a,54); _R3(a,b,c,d,e,55);
+	_R3(e,a,b,c,d,56); _R3(d,e,a,b,c,57); _R3(c,d,e,a,b,58); _R3(b,c,d,e,a,59);
+	_R4(a,b,c,d,e,60); _R4(e,a,b,c,d,61); _R4(d,e,a,b,c,62); _R4(c,d,e,a,b,63);
+	_R4(b,c,d,e,a,64); _R4(a,b,c,d,e,65); _R4(e,a,b,c,d,66); _R4(d,e,a,b,c,67);
+	_R4(c,d,e,a,b,68); _R4(b,c,d,e,a,69); _R4(a,b,c,d,e,70); _R4(e,a,b,c,d,71);
+	_R4(d,e,a,b,c,72); _R4(c,d,e,a,b,73); _R4(b,c,d,e,a,74); _R4(a,b,c,d,e,75);
+	_R4(e,a,b,c,d,76); _R4(d,e,a,b,c,77); _R4(c,d,e,a,b,78); _R4(b,c,d,e,a,79);
+
+	// Add the working vars back into state[]
+	state[0] += a;
+	state[1] += b;
+	state[2] += c;
+	state[3] += d;
+	state[4] += e;
+
+	// Wipe variables
+	a = b = c = d = e = 0;
+}
+
+// Use this function to hash in binary data and strings
+#ifdef	_MINIMUM_BUILD_
+void Minimum_CSHA1::Update(unsigned char *data, unsigned int len)
+#else
+void CSHA1::Update(unsigned char *data, unsigned int len)
+#endif
+{
+	unsigned long i = 0, j;
+
+	j = (m_count[0] >> 3) & 63;
+
+	if((m_count[0] += len << 3) < (len << 3)) m_count[1]++;
+
+	m_count[1] += (len >> 29);
+
+	if((j + len) > 63)
+	{
+		memcpy(&m_buffer[j], data, (i = 64 - j));
+		Transform(m_state, m_buffer);
+
+		for (; i+63 < len; i += 64)
+			Transform(m_state, &data[i]);
+
+		j = 0;
+	}
+	else i = 0;
+
+	memcpy(&m_buffer[j], &data[i], len - i);
+}
+
+#if !defined(_MINIMUM_BUILD_)
+// Hash in file contents
+bool CSHA1::HashFile(char *szFileName)
+{
+	unsigned long ulFileSize = 0, ulRest = 0, ulBlocks = 0;
+	unsigned long i = 0;
+	unsigned char uData[MAX_FILE_READ_BUFFER];
+	FILE *fIn = NULL;
+
+	if(szFileName == NULL) return(false);
+
+	if((fIn = fopen(szFileName, "rb")) == NULL) return(false);
+
+	fseek(fIn, 0, SEEK_END);
+	ulFileSize = ftell(fIn);
+	fseek(fIn, 0, SEEK_SET);
+
+	ulRest = ulFileSize % MAX_FILE_READ_BUFFER;
+	ulBlocks = ulFileSize / MAX_FILE_READ_BUFFER;
+
+	for(i = 0; i < ulBlocks; i++)
+	{
+		fread(uData, 1, MAX_FILE_READ_BUFFER, fIn);
+		Update(uData, MAX_FILE_READ_BUFFER);
+	}
+
+	if(ulRest != 0)
+	{
+		fread(uData, 1, ulRest, fIn);
+		Update(uData, ulRest);
+	}
+
+	fclose(fIn);
+	fIn = NULL;
+
+	return(true);
+}
+#endif
+
+#ifdef	_MINIMUM_BUILD_
+void Minimum_CSHA1::Final()
+#else
+void CSHA1::Final()
+#endif
+{
+	unsigned long i = 0;
+	unsigned char finalcount[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+
+	for (i = 0; i < 8; i++)
+		finalcount[i] = (unsigned char)((m_count[(i >= 4 ? 0 : 1)]
+			>> ((3 - (i & 3)) * 8) ) & 255); // Endian independent
+
+	Update((unsigned char *)"\200", 1);
+
+	while ((m_count[0] & 504) != 448)
+		Update((unsigned char *)"\0", 1);
+
+	Update(finalcount, 8); // Cause a SHA1Transform()
+
+	for (i = 0; i < k_cubHash; i++)
+	{
+		m_digest[i] = (unsigned char)((m_state[i >> 2] >> ((3 - (i & 3)) * 8) ) & 255);
+	}
+
+	// Wipe variables for security reasons
+	i = 0;
+	memset(m_buffer, 0, sizeof(m_buffer) );
+	memset(m_state, 0, sizeof(m_state) );
+	memset(m_count, 0, sizeof(m_count) );
+	memset(finalcount, 0, sizeof( finalcount) );
+
+	Transform(m_state, m_buffer);
+}
+
+#if !defined(_MINIMUM_BUILD_)
+// Get the final hash as a pre-formatted string
+void CSHA1::ReportHash(char *szReport, unsigned char uReportType)
+{
+	unsigned char i = 0;
+	char szTemp[12];
+
+	if(szReport == NULL) return;
+
+	if(uReportType == REPORT_HEX)
+	{
+		sprintf(szTemp, "%02X", m_digest[0]);
+		strcat(szReport, szTemp);
+
+		for(i = 1; i < k_cubHash; i++)
+		{
+			sprintf(szTemp, " %02X", m_digest[i]);
+			strcat(szReport, szTemp);
+		}
+	}
+	else if(uReportType == REPORT_DIGIT)
+	{
+		sprintf(szTemp, "%u", m_digest[0]);
+		strcat(szReport, szTemp);
+
+		for(i = 1; i < k_cubHash; i++)
+		{
+			sprintf(szTemp, " %u", m_digest[i]);
+			strcat(szReport, szTemp);
+		}
+	}
+	else strcpy(szReport, "Error: Unknown report type!");
+}
+#endif // _MINIMUM_BUILD_
+
+// Get the raw message digest
+#ifdef	_MINIMUM_BUILD_
+void Minimum_CSHA1::GetHash(unsigned char *uDest)
+#else
+void CSHA1::GetHash(unsigned char *uDest)
+#endif
+{
+	memcpy(uDest, m_digest, k_cubHash);
+}
+
+#ifndef	_MINIMUM_BUILD_
+// utility hash comparison function
+bool HashLessFunc( SHADigest_t const &lhs, SHADigest_t const &rhs )
+{
+	int iRes = memcmp( &lhs, &rhs, sizeof( SHADigest_t ) );
+	return ( iRes < 0 );
+}
+#endif

mp/src/tier1/commandbuffer.cpp

@@ -0,0 +1,636 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//===========================================================================//
+
+#include "tier1/CommandBuffer.h"
+#include "tier1/utlbuffer.h"
+#include "tier1/strtools.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#define	MAX_ALIAS_NAME	32
+#define MAX_COMMAND_LENGTH 1024
+
+struct cmdalias_t
+{
+	cmdalias_t	*next;
+	char		name[ MAX_ALIAS_NAME ];
+	char		*value;
+};
+
+
+//-----------------------------------------------------------------------------
+// Constructor, destructor
+//-----------------------------------------------------------------------------
+CCommandBuffer::CCommandBuffer( ) : m_Commands( 32, 32 )
+{
+	m_hNextCommand = m_Commands.InvalidIndex();
+	m_nWaitDelayTicks = 1;
+	m_nCurrentTick = 0;
+	m_nLastTickToProcess = -1;
+	m_nArgSBufferSize = 0;
+	m_bIsProcessingCommands = false;
+	m_nMaxArgSBufferLength = ARGS_BUFFER_LENGTH;
+}
+
+CCommandBuffer::~CCommandBuffer()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Indicates how long to delay when encoutering a 'wait' command
+//-----------------------------------------------------------------------------
+void CCommandBuffer::SetWaitDelayTime( int nTickDelay )
+{
+	Assert( nTickDelay >= 0 );
+	m_nWaitDelayTicks = nTickDelay;
+}
+
+	
+//-----------------------------------------------------------------------------
+// Specifies a max limit of the args buffer. For unittesting. Size == 0 means use default
+//-----------------------------------------------------------------------------
+void CCommandBuffer::LimitArgumentBufferSize( int nSize )
+{
+	if ( nSize > ARGS_BUFFER_LENGTH )
+	{
+		nSize = ARGS_BUFFER_LENGTH;
+	}
+
+	m_nMaxArgSBufferLength = ( nSize == 0 ) ? ARGS_BUFFER_LENGTH : nSize;
+}
+
+	
+//-----------------------------------------------------------------------------
+// Parses argv0 out of the buffer
+//-----------------------------------------------------------------------------
+bool CCommandBuffer::ParseArgV0( CUtlBuffer &buf, char *pArgV0, int nMaxLen, const char **pArgS )
+{
+	pArgV0[0] = 0;
+	*pArgS = NULL;
+
+	if ( !buf.IsValid() )
+		return false;
+
+	int	nSize = buf.ParseToken( CCommand::DefaultBreakSet(), pArgV0, nMaxLen );
+	if ( ( nSize <= 0 ) || ( nMaxLen == nSize ) )
+		return false;
+
+	int nArgSLen = buf.TellMaxPut() - buf.TellGet();
+	*pArgS = (nArgSLen > 0) ? (const char*)buf.PeekGet() : NULL;
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Insert a command into the command queue
+//-----------------------------------------------------------------------------
+void CCommandBuffer::InsertCommandAtAppropriateTime( int hCommand )
+{
+	int i;
+	Command_t &command = m_Commands[hCommand];
+	for ( i = m_Commands.Head(); i != m_Commands.InvalidIndex(); i = m_Commands.Next(i) )
+	{
+		if ( m_Commands[i].m_nTick > command.m_nTick )
+			break;
+	}
+	m_Commands.LinkBefore( i, hCommand );
+}
+
+
+//-----------------------------------------------------------------------------
+// Insert a command into the command queue at the appropriate time
+//-----------------------------------------------------------------------------
+void CCommandBuffer::InsertImmediateCommand( int hCommand )
+{
+	m_Commands.LinkBefore( m_hNextCommand, hCommand );
+}
+
+
+//-----------------------------------------------------------------------------
+// Insert a command into the command queue
+//-----------------------------------------------------------------------------
+bool CCommandBuffer::InsertCommand( const char *pArgS, int nCommandSize, int nTick )
+{
+	if ( nCommandSize >= CCommand::MaxCommandLength() )
+	{
+		Warning( "WARNING: Command too long... ignoring!\n%s\n", pArgS );
+		return false;
+	}
+
+	// Add one for null termination
+	if ( m_nArgSBufferSize + nCommandSize + 1 > m_nMaxArgSBufferLength )
+	{
+		Compact();
+		if ( m_nArgSBufferSize + nCommandSize + 1 > m_nMaxArgSBufferLength )
+			return false;
+	}
+	
+	memcpy( &m_pArgSBuffer[m_nArgSBufferSize], pArgS, nCommandSize );
+	m_pArgSBuffer[m_nArgSBufferSize + nCommandSize] = 0;
+	++nCommandSize;
+
+	int hCommand = m_Commands.Alloc();
+	Command_t &command = m_Commands[hCommand];
+	command.m_nTick = nTick;
+	command.m_nFirstArgS = m_nArgSBufferSize;
+	command.m_nBufferSize = nCommandSize;
+
+	m_nArgSBufferSize += nCommandSize;
+
+	if ( !m_bIsProcessingCommands || ( nTick > m_nCurrentTick ) )
+	{
+		InsertCommandAtAppropriateTime( hCommand );
+	}
+	else
+	{
+		InsertImmediateCommand( hCommand );
+	}
+	return true;
+}
+
+		
+//-----------------------------------------------------------------------------
+// Returns the length of the next command
+//-----------------------------------------------------------------------------
+void CCommandBuffer::GetNextCommandLength( const char *pText, int nMaxLen, int *pCommandLength, int *pNextCommandOffset )
+{
+	int nCommandLength = 0;
+	int nNextCommandOffset;
+	bool bIsQuoted = false;
+	bool bIsCommented = false;
+	for ( nNextCommandOffset=0; nNextCommandOffset < nMaxLen; ++nNextCommandOffset, nCommandLength += bIsCommented ? 0 : 1 )
+	{
+		char c = pText[nNextCommandOffset];
+		if ( !bIsCommented )
+		{
+			if ( c == '"' )
+			{
+				bIsQuoted = !bIsQuoted;
+				continue;
+			}
+
+			// don't break if inside a C++ style comment
+			if ( !bIsQuoted && c == '/' )
+			{
+				bIsCommented = ( nNextCommandOffset < nMaxLen-1 ) && pText[nNextCommandOffset+1] == '/';
+				if ( bIsCommented )
+				{
+					++nNextCommandOffset;
+					continue;
+				}
+			}
+
+			// don't break if inside a quoted string
+			if ( !bIsQuoted && c == ';' )
+				break;	
+		}
+
+		// FIXME: This is legacy behavior; should we not break if a \n is inside a quoted string?
+		if ( c == '\n' )
+			break;
+	}
+
+	*pCommandLength = nCommandLength;
+	*pNextCommandOffset = nNextCommandOffset;
+}
+
+
+//-----------------------------------------------------------------------------
+// Add text to command buffer, return false if it couldn't owing to overflow
+//-----------------------------------------------------------------------------
+bool CCommandBuffer::AddText( const char *pText, int nTickDelay )
+{
+	Assert( nTickDelay >= 0 );
+
+	int	nLen = Q_strlen( pText );
+	int nTick = m_nCurrentTick + nTickDelay;
+
+	// Parse the text into distinct commands
+	const char *pCurrentCommand = pText;
+	int nOffsetToNextCommand;
+	for( ; nLen > 0; nLen -= nOffsetToNextCommand+1, pCurrentCommand += nOffsetToNextCommand+1 )
+	{
+		// find a \n or ; line break
+		int nCommandLength;
+		GetNextCommandLength( pCurrentCommand, nLen, &nCommandLength, &nOffsetToNextCommand );
+		if ( nCommandLength <= 0 )
+			continue;
+
+		const char *pArgS;
+		char *pArgV0 = (char*)_alloca( nCommandLength+1 );
+		CUtlBuffer bufParse( pCurrentCommand, nCommandLength, CUtlBuffer::TEXT_BUFFER | CUtlBuffer::READ_ONLY ); 
+		ParseArgV0( bufParse, pArgV0, nCommandLength+1, &pArgS );
+		if ( pArgV0[0] == 0 )
+			continue;
+
+		// Deal with the special 'wait' command
+		if ( !Q_stricmp( pArgV0, "wait" ) && IsWaitEnabled() )
+		{
+			int nDelay = pArgS ? atoi( pArgS ) : m_nWaitDelayTicks;
+			nTick += nDelay;
+			continue;
+		}
+
+		if ( !InsertCommand( pCurrentCommand, nCommandLength, nTick ) )
+			return false;
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Are we in the middle of processing commands?
+//-----------------------------------------------------------------------------
+bool CCommandBuffer::IsProcessingCommands()
+{
+	return m_bIsProcessingCommands;
+}
+	
+	
+//-----------------------------------------------------------------------------
+// Delays all queued commands to execute at a later time
+//-----------------------------------------------------------------------------
+void CCommandBuffer::DelayAllQueuedCommands( int nDelay )
+{
+	if ( nDelay <= 0 )
+		return;
+
+	for ( int i = m_Commands.Head(); i != m_Commands.InvalidIndex(); i = m_Commands.Next(i) )
+	{
+		m_Commands[i].m_nTick += nDelay;			
+	}
+}
+
+	
+//-----------------------------------------------------------------------------
+// Call this to begin iterating over all commands up to flCurrentTime
+//-----------------------------------------------------------------------------
+void CCommandBuffer::BeginProcessingCommands( int nDeltaTicks )
+{
+	if ( nDeltaTicks == 0 )
+		return;
+
+	Assert( !m_bIsProcessingCommands );
+	m_bIsProcessingCommands = true;
+	m_nLastTickToProcess = m_nCurrentTick + nDeltaTicks - 1;
+
+	// Necessary to insert commands while commands are being processed
+	m_hNextCommand = m_Commands.Head();
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns the next command
+//-----------------------------------------------------------------------------
+bool CCommandBuffer::DequeueNextCommand( )
+{
+	m_CurrentCommand.Reset();
+
+	Assert( m_bIsProcessingCommands );
+	if ( m_Commands.Count() == 0 )
+		return false;
+
+	int nHead = m_Commands.Head();
+	Command_t &command = m_Commands[ nHead ];
+	if ( command.m_nTick > m_nLastTickToProcess )
+		return false;
+
+	m_nCurrentTick = command.m_nTick;
+
+	// Copy the current command into a temp buffer
+	// NOTE: This is here to avoid the pointers returned by DequeueNextCommand
+	// to become invalid by calling AddText. Is there a way we can avoid the memcpy?
+	if ( command.m_nBufferSize > 0 )
+	{
+		m_CurrentCommand.Tokenize( &m_pArgSBuffer[command.m_nFirstArgS] );
+	}
+
+	m_Commands.Remove( nHead );
+
+	// Necessary to insert commands while commands are being processed
+	m_hNextCommand = m_Commands.Head();
+
+//	Msg("Dequeue : ");
+//	for ( int i = 0; i < nArgc; ++i )
+//	{
+//		Msg("%s ", m_pCurrentArgv[i] ); 
+//	}
+//	Msg("\n");
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns the next command
+//-----------------------------------------------------------------------------
+int CCommandBuffer::DequeueNextCommand( const char **& ppArgv )
+{
+	DequeueNextCommand();
+	ppArgv = ArgV();
+	return ArgC();
+}
+
+
+//-----------------------------------------------------------------------------
+// Compacts the command buffer
+//-----------------------------------------------------------------------------
+void CCommandBuffer::Compact()
+{
+	// Compress argvbuffer + argv
+	// NOTE: I'm using this choice instead of calling malloc + free
+	// per command to allocate arguments because I expect to post a
+	// bunch of commands but not have many delayed commands; 
+	// avoiding the allocation cost seems more important that the memcpy 
+	// cost here since I expect to not have much to copy.
+	m_nArgSBufferSize = 0;
+
+	char pTempBuffer[ ARGS_BUFFER_LENGTH ];
+	for ( int i = m_Commands.Head(); i != m_Commands.InvalidIndex(); i = m_Commands.Next(i) )
+	{
+		Command_t &command = m_Commands[ i ];
+
+		memcpy( &pTempBuffer[m_nArgSBufferSize], &m_pArgSBuffer[command.m_nFirstArgS], command.m_nBufferSize );
+		command.m_nFirstArgS = m_nArgSBufferSize;
+		m_nArgSBufferSize += command.m_nBufferSize;
+	}
+
+	// NOTE: We could also store 2 buffers in the command buffer and switch
+	// between the two to avoid the 2nd memcpy; but again I'm guessing the memory
+	// tradeoff isn't worth it
+	memcpy( m_pArgSBuffer, pTempBuffer, m_nArgSBufferSize );
+}
+
+
+//-----------------------------------------------------------------------------
+// Call this to finish iterating over all commands
+//-----------------------------------------------------------------------------
+void CCommandBuffer::EndProcessingCommands()
+{
+	Assert( m_bIsProcessingCommands );
+	m_bIsProcessingCommands = false;
+	m_nCurrentTick = m_nLastTickToProcess + 1;
+	m_hNextCommand = m_Commands.InvalidIndex();
+
+	// Extract commands that are before the end time
+	// NOTE: This is a bug for this to 
+	int i = m_Commands.Head();
+	if ( i == m_Commands.InvalidIndex() )
+	{
+		m_nArgSBufferSize = 0;
+		return;
+	}
+
+	while ( i != m_Commands.InvalidIndex() )
+	{
+		if ( m_Commands[i].m_nTick >= m_nCurrentTick )
+			break;
+
+		AssertMsgOnce( false, "CCommandBuffer::EndProcessingCommands() called before all appropriate commands were dequeued.\n" );
+		int nNext = i;
+		Msg( "Warning: Skipping command %s\n", &m_pArgSBuffer[ m_Commands[i].m_nFirstArgS ] );
+		m_Commands.Remove( i );
+		i = nNext;
+	}
+
+	Compact();
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns a handle to the next command to process
+//-----------------------------------------------------------------------------
+CommandHandle_t CCommandBuffer::GetNextCommandHandle()
+{
+	Assert( m_bIsProcessingCommands );
+	return m_Commands.Head();
+}
+
+
+#if 0
+/*
+===============
+Cmd_Alias_f
+
+Creates a new command that executes a command string (possibly ; seperated)
+===============
+*/
+void Cmd_Alias_f (void)
+{
+	cmdalias_t	*a;
+	char		cmd[MAX_COMMAND_LENGTH];
+	int			i, c;
+	char		*s;
+
+	if (Cmd_Argc() == 1)
+	{
+		Con_Printf ("Current alias commands:\n");
+		for (a = cmd_alias ; a ; a=a->next)
+			Con_Printf ("%s : %s\n", a->name, a->value);
+		return;
+	}
+
+	s = Cmd_Argv(1);
+	if (strlen(s) >= MAX_ALIAS_NAME)
+	{
+		Con_Printf ("Alias name is too long\n");
+		return;
+	}
+
+// copy the rest of the command line
+	cmd[0] = 0;		// start out with a null string
+	c = Cmd_Argc();
+	for (i=2 ; i< c ; i++)
+	{
+		Q_strncat(cmd, Cmd_Argv(i), sizeof( cmd ), COPY_ALL_CHARACTERS);
+		if (i != c)
+		{
+			Q_strncat (cmd, " ", sizeof( cmd ), COPY_ALL_CHARACTERS );
+		}
+	}
+	Q_strncat (cmd, "\n", sizeof( cmd ), COPY_ALL_CHARACTERS);
+
+	// if the alias already exists, reuse it
+	for (a = cmd_alias ; a ; a=a->next)
+	{
+		if (!strcmp(s, a->name))
+		{
+			if ( !strcmp( a->value, cmd ) )		// Re-alias the same thing
+				return;
+
+			delete[] a->value;
+			break;
+		}
+	}
+
+	if (!a)
+	{
+		a = (cmdalias_t *)new cmdalias_t;
+		a->next = cmd_alias;
+		cmd_alias = a;
+	}
+	Q_strncpy (a->name, s, sizeof( a->name ) );	
+
+	a->value = COM_StringCopy(cmd);
+}
+
+
+	
+/*
+=============================================================================
+
+					COMMAND EXECUTION
+
+=============================================================================
+*/
+
+#define	MAX_ARGS		80
+
+static	int			cmd_argc;
+static	char		*cmd_argv[MAX_ARGS];
+static	char		*cmd_null_string = "";
+static	const char	*cmd_args = NULL;
+
+cmd_source_t	cmd_source;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : void Cmd_Init
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void Cmd_Shutdown( void )
+{
+	// TODO, cleanup
+	while ( cmd_alias )
+	{
+		cmdalias_t *next = cmd_alias->next;
+		delete cmd_alias->value;	// created by StringCopy()
+		delete cmd_alias;
+		cmd_alias = next;
+	}
+}
+
+
+
+/*
+============
+Cmd_ExecuteString
+
+A complete command line has been parsed, so try to execute it
+FIXME: lookupnoadd the token to speed search?
+============
+*/
+const ConCommandBase *Cmd_ExecuteString (const char *text, cmd_source_t src)
+{	
+	cmdalias_t		*a;
+
+	cmd_source = src;
+	Cmd_TokenizeString (text);
+			
+// execute the command line
+	if (!Cmd_Argc())
+		return NULL;		// no tokens
+
+// check alias
+	for (a=cmd_alias ; a ; a=a->next)
+	{
+		if (!Q_strcasecmp (cmd_argv[0], a->name))
+		{
+			Cbuf_InsertText (a->value);
+			return NULL;
+		}
+	}
+	
+// check ConCommands
+	ConCommandBase const *pCommand = ConCommandBase::FindCommand( cmd_argv[ 0 ] );
+	if ( pCommand && pCommand->IsCommand() )
+	{
+		bool isServerCommand = ( pCommand->IsBitSet( FCVAR_GAMEDLL ) && 
+								// Typed at console
+								cmd_source == src_command &&
+								// Not HLDS
+								!sv.IsDedicated() );
+
+		// Hook to allow game .dll to figure out who type the message on a listen server
+		if ( serverGameClients )
+		{
+			// We're actually the server, so set it up locally
+			if ( sv.IsActive() )
+			{
+				g_pServerPluginHandler->SetCommandClient( -1 );
+						
+#ifndef SWDS
+				// Special processing for listen server player
+				if ( isServerCommand )
+				{
+					g_pServerPluginHandler->SetCommandClient( cl.m_nPlayerSlot );
+				}
+#endif
+			}
+			// We're not the server, but we've been a listen server (game .dll loaded)
+			//  forward this command tot he server instead of running it locally if we're still
+			//  connected
+			// Otherwise, things like "say" won't work unless you quit and restart
+			else if ( isServerCommand )
+			{
+				if ( cl.IsConnected() )
+				{
+					Cmd_ForwardToServer();
+					return NULL;
+				}
+				else
+				{
+					// It's a server command, but we're not connected to a server.  Don't try to execute it.
+					return NULL;
+				}
+			}
+		}
+
+		// Allow cheat commands in singleplayer, debug, or multiplayer with sv_cheats on
+#ifndef _DEBUG
+		if ( pCommand->IsBitSet( FCVAR_CHEAT ) )
+		{
+			if ( !Host_IsSinglePlayerGame() && sv_cheats.GetInt() == 0 )
+			{
+				Msg( "Can't use cheat command %s in multiplayer, unless the server has sv_cheats set to 1.\n", pCommand->GetName() );
+				return NULL;
+			}
+		}
+#endif
+
+		(( ConCommand * )pCommand )->Dispatch();
+		return pCommand;
+	}
+
+	// check cvars
+	if ( cv->IsCommand() )
+	{
+		return pCommand;
+	}
+
+	// forward the command line to the server, so the entity DLL can parse it
+	if ( cmd_source == src_command )
+	{
+		if ( cl.IsConnected() )
+		{
+			Cmd_ForwardToServer();
+			return NULL;
+		}
+	}
+	
+	Msg("Unknown command \"%s\"\n", Cmd_Argv(0));
+
+	return NULL;
+}
+#endif

mp/src/tier1/datamanager.cpp

@@ -0,0 +1,411 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#include "basetypes.h"
+#include "datamanager.h"
+
+DECLARE_POINTER_HANDLE( memhandle_t );
+
+#define AUTO_LOCK_DM() AUTO_LOCK_( CDataManagerBase, *this )
+
+CDataManagerBase::CDataManagerBase( unsigned int maxSize )
+{
+	m_targetMemorySize = maxSize;
+	m_memUsed = 0;
+	m_lruList = m_memoryLists.CreateList();
+	m_lockList = m_memoryLists.CreateList();
+	m_freeList = m_memoryLists.CreateList();
+	m_listsAreFreed = 0;
+}
+
+CDataManagerBase::~CDataManagerBase() 
+{
+	Assert( m_listsAreFreed );
+}
+
+void CDataManagerBase::NotifySizeChanged( memhandle_t handle, unsigned int oldSize, unsigned int newSize )
+{
+	Lock();
+	m_memUsed += (int)newSize - (int)oldSize;
+	Unlock();
+}
+
+void CDataManagerBase::SetTargetSize( unsigned int targetSize )
+{
+	m_targetMemorySize = targetSize;
+}
+
+unsigned int CDataManagerBase::FlushAllUnlocked()
+{
+	Lock();
+
+	int nFlush = m_memoryLists.Count( m_lruList );
+	void **pScratch = (void **)_alloca( nFlush * sizeof(void *) );
+	CUtlVector<void *> destroyList( pScratch, nFlush );
+
+	unsigned nBytesInitial = MemUsed_Inline();
+
+	int node = m_memoryLists.Head(m_lruList);
+	while ( node != m_memoryLists.InvalidIndex() )
+	{
+		int next = m_memoryLists.Next(node);
+		m_memoryLists.Unlink( m_lruList, node );
+		destroyList.AddToTail( GetForFreeByIndex( node ) );
+		node = next;
+	}
+
+	Unlock();
+
+	for ( int i = 0; i < nFlush; i++ )
+	{
+		DestroyResourceStorage( destroyList[i] );
+	}
+
+	return ( nBytesInitial - MemUsed_Inline() );
+}
+
+unsigned int CDataManagerBase::FlushToTargetSize()
+{
+	return EnsureCapacity(0);
+}
+
+// Frees everything!  The LRU AND the LOCKED items.  This is only used to forcibly free the resources,
+// not to make space.
+
+unsigned int CDataManagerBase::FlushAll()
+{
+	Lock();
+
+	int nFlush = m_memoryLists.Count( m_lruList ) + m_memoryLists.Count( m_lockList );
+	void **pScratch = (void **)_alloca( nFlush * sizeof(void *) );
+	CUtlVector<void *> destroyList( pScratch, nFlush );
+
+	unsigned result = MemUsed_Inline();
+	int node;
+	int nextNode;
+
+	node = m_memoryLists.Head(m_lruList);
+	while ( node != m_memoryLists.InvalidIndex() )
+	{
+		nextNode = m_memoryLists.Next(node);
+		m_memoryLists.Unlink( m_lruList, node );
+		destroyList.AddToTail( GetForFreeByIndex( node ) );
+		node = nextNode;
+	}
+
+	node = m_memoryLists.Head(m_lockList);
+	while ( node != m_memoryLists.InvalidIndex() )
+	{
+		nextNode = m_memoryLists.Next(node);
+		m_memoryLists.Unlink( m_lockList, node );
+		m_memoryLists[node].lockCount = 0;
+		destroyList.AddToTail( GetForFreeByIndex( node ) );
+		node = nextNode;
+	}
+
+	m_listsAreFreed = false;
+	Unlock();
+
+	for ( int i = 0; i < nFlush; i++ )
+	{
+		DestroyResourceStorage( destroyList[i] );
+	}
+
+	return result;
+}
+
+unsigned int CDataManagerBase::Purge( unsigned int nBytesToPurge )
+{
+	unsigned int nTargetSize = MemUsed_Inline() - nBytesToPurge;
+	// Check for underflow
+	if ( MemUsed_Inline() < nBytesToPurge )
+		nTargetSize = 0;
+	unsigned int nImpliedCapacity = MemTotal_Inline() - nTargetSize;
+	return EnsureCapacity( nImpliedCapacity );
+}
+
+
+void CDataManagerBase::DestroyResource( memhandle_t handle )
+{
+	Lock();
+	unsigned short index = FromHandle( handle );
+	if ( !m_memoryLists.IsValidIndex(index) )
+	{
+		Unlock();
+		return;
+	}
+	
+	Assert( m_memoryLists[index].lockCount == 0  );
+	if ( m_memoryLists[index].lockCount )
+		BreakLock( handle );
+	m_memoryLists.Unlink( m_lruList, index );
+	void *p = GetForFreeByIndex( index );
+	Unlock();
+
+	DestroyResourceStorage( p );
+}
+
+
+void *CDataManagerBase::LockResource( memhandle_t handle )
+{
+	AUTO_LOCK_DM();
+	unsigned short memoryIndex = FromHandle(handle);
+	if ( memoryIndex != m_memoryLists.InvalidIndex() )
+	{
+		if ( m_memoryLists[memoryIndex].lockCount == 0 )
+		{
+			m_memoryLists.Unlink( m_lruList, memoryIndex );
+			m_memoryLists.LinkToTail( m_lockList, memoryIndex );
+		}
+		Assert(m_memoryLists[memoryIndex].lockCount != (unsigned short)-1);
+		m_memoryLists[memoryIndex].lockCount++;
+		return m_memoryLists[memoryIndex].pStore;
+	}
+
+	return NULL;
+}
+
+int CDataManagerBase::UnlockResource( memhandle_t handle )
+{
+	AUTO_LOCK_DM();
+	unsigned short memoryIndex = FromHandle(handle);
+	if ( memoryIndex != m_memoryLists.InvalidIndex() )
+	{
+		Assert( m_memoryLists[memoryIndex].lockCount > 0 );
+		if ( m_memoryLists[memoryIndex].lockCount > 0 )
+		{
+			m_memoryLists[memoryIndex].lockCount--;
+			if ( m_memoryLists[memoryIndex].lockCount == 0 )
+			{
+				m_memoryLists.Unlink( m_lockList, memoryIndex );
+				m_memoryLists.LinkToTail( m_lruList, memoryIndex );
+			}
+		}
+		return m_memoryLists[memoryIndex].lockCount;
+	}
+
+	return 0;
+}
+
+void *CDataManagerBase::GetResource_NoLockNoLRUTouch( memhandle_t handle )
+{
+	AUTO_LOCK_DM();
+	unsigned short memoryIndex = FromHandle(handle);
+	if ( memoryIndex != m_memoryLists.InvalidIndex() )
+	{
+		return m_memoryLists[memoryIndex].pStore;
+	}
+	return NULL;
+}
+
+
+void *CDataManagerBase::GetResource_NoLock( memhandle_t handle )
+{
+	AUTO_LOCK_DM();
+	unsigned short memoryIndex = FromHandle(handle);
+	if ( memoryIndex != m_memoryLists.InvalidIndex() )
+	{
+		TouchByIndex( memoryIndex );
+		return m_memoryLists[memoryIndex].pStore;
+	}
+	return NULL;
+}
+
+void CDataManagerBase::TouchResource( memhandle_t handle )
+{
+	AUTO_LOCK_DM();
+	TouchByIndex( FromHandle(handle) );
+}
+
+void CDataManagerBase::MarkAsStale( memhandle_t handle )
+{
+	AUTO_LOCK_DM();
+	unsigned short memoryIndex = FromHandle(handle);
+	if ( memoryIndex != m_memoryLists.InvalidIndex() )
+	{
+		if ( m_memoryLists[memoryIndex].lockCount == 0 )
+		{
+			m_memoryLists.Unlink( m_lruList, memoryIndex );
+			m_memoryLists.LinkToHead( m_lruList, memoryIndex );
+		}
+	}
+}
+
+int CDataManagerBase::BreakLock( memhandle_t handle )
+{
+	AUTO_LOCK_DM();
+	unsigned short memoryIndex = FromHandle(handle);
+	if ( memoryIndex != m_memoryLists.InvalidIndex() && m_memoryLists[memoryIndex].lockCount )
+	{
+		int nBroken = m_memoryLists[memoryIndex].lockCount;
+		m_memoryLists[memoryIndex].lockCount = 0;
+		m_memoryLists.Unlink( m_lockList, memoryIndex );
+		m_memoryLists.LinkToTail( m_lruList, memoryIndex );
+
+		return nBroken;
+	}
+	return 0;
+}
+
+int CDataManagerBase::BreakAllLocks()
+{
+	AUTO_LOCK_DM();
+	int nBroken = 0;
+	int node;
+	int nextNode;
+
+	node = m_memoryLists.Head(m_lockList);
+	while ( node != m_memoryLists.InvalidIndex() )
+	{
+		nBroken++;
+		nextNode = m_memoryLists.Next(node);
+		m_memoryLists[node].lockCount = 0;
+		m_memoryLists.Unlink( m_lockList, node );
+		m_memoryLists.LinkToTail( m_lruList, node );
+		node = nextNode;
+	}
+
+	return nBroken;
+
+}
+
+unsigned short CDataManagerBase::CreateHandle( bool bCreateLocked )
+{
+	AUTO_LOCK_DM();
+	int memoryIndex = m_memoryLists.Head(m_freeList);
+	unsigned short list = ( bCreateLocked ) ? m_lockList : m_lruList;
+	if ( memoryIndex != m_memoryLists.InvalidIndex() )
+	{
+		m_memoryLists.Unlink( m_freeList, memoryIndex );
+		m_memoryLists.LinkToTail( list, memoryIndex );
+	}
+	else
+	{
+		memoryIndex = m_memoryLists.AddToTail( list );
+	}
+
+	if ( bCreateLocked )
+	{
+		m_memoryLists[memoryIndex].lockCount++;
+	}
+
+	return memoryIndex;
+}
+
+memhandle_t CDataManagerBase::StoreResourceInHandle( unsigned short memoryIndex, void *pStore, unsigned int realSize )
+{
+	AUTO_LOCK_DM();
+	resource_lru_element_t &mem = m_memoryLists[memoryIndex];
+	mem.pStore = pStore;
+	m_memUsed += realSize;
+	return ToHandle(memoryIndex);
+}
+
+void CDataManagerBase::TouchByIndex( unsigned short memoryIndex )
+{
+	if ( memoryIndex != m_memoryLists.InvalidIndex() )
+	{
+		if ( m_memoryLists[memoryIndex].lockCount == 0 )
+		{
+			m_memoryLists.Unlink( m_lruList, memoryIndex );
+			m_memoryLists.LinkToTail( m_lruList, memoryIndex );
+		}
+	}
+}
+
+memhandle_t CDataManagerBase::ToHandle( unsigned short index )
+{
+	unsigned int hiword = m_memoryLists.Element(index).serial;
+	hiword <<= 16;
+	index++;
+	return (memhandle_t)( hiword|index );
+}
+
+unsigned int CDataManagerBase::TargetSize() 
+{ 
+	return MemTotal_Inline(); 
+}
+
+unsigned int CDataManagerBase::AvailableSize()
+{ 
+	return MemAvailable_Inline(); 
+}
+
+
+unsigned int CDataManagerBase::UsedSize()
+{ 
+	return MemUsed_Inline(); 
+}
+
+// free resources until there is enough space to hold "size"
+unsigned int CDataManagerBase::EnsureCapacity( unsigned int size )
+{
+	unsigned nBytesInitial = MemUsed_Inline();
+	while ( MemUsed_Inline() > MemTotal_Inline() || MemAvailable_Inline() < size )
+	{
+		Lock();
+		int lruIndex = m_memoryLists.Head( m_lruList );
+		if ( lruIndex == m_memoryLists.InvalidIndex() )
+		{
+			Unlock();
+			break;
+		}
+		m_memoryLists.Unlink( m_lruList, lruIndex );
+		void *p = GetForFreeByIndex( lruIndex );
+		Unlock();
+		DestroyResourceStorage( p );
+	}
+	return ( nBytesInitial - MemUsed_Inline() );
+}
+
+// free this resource and move the handle to the free list
+void *CDataManagerBase::GetForFreeByIndex( unsigned short memoryIndex )
+{
+	void *p = NULL;
+	if ( memoryIndex != m_memoryLists.InvalidIndex() )
+	{
+		Assert( m_memoryLists[memoryIndex].lockCount == 0 );
+
+		resource_lru_element_t &mem = m_memoryLists[memoryIndex];
+		unsigned size = GetRealSize( mem.pStore );
+		if ( size > m_memUsed )
+		{
+			ExecuteOnce( Warning( "Data manager 'used' memory incorrect\n" ) );
+			size = m_memUsed;
+		}
+		m_memUsed -= size;
+		p = mem.pStore;
+		mem.pStore = NULL;
+		mem.serial++;
+		m_memoryLists.LinkToTail( m_freeList, memoryIndex );
+	}
+	return p;
+}
+
+// get a list of everything in the LRU
+void CDataManagerBase::GetLRUHandleList( CUtlVector< memhandle_t >& list )
+{
+	for ( int node = m_memoryLists.Tail(m_lruList);
+			node != m_memoryLists.InvalidIndex();
+			node = m_memoryLists.Previous(node) )
+	{
+		list.AddToTail( ToHandle( node ) );
+	}
+}
+
+// get a list of everything locked
+void CDataManagerBase::GetLockHandleList( CUtlVector< memhandle_t >& list )
+{
+	for ( int node = m_memoryLists.Head(m_lockList);
+			node != m_memoryLists.InvalidIndex();
+			node = m_memoryLists.Next(node) )
+	{
+		list.AddToTail( ToHandle( node ) );
+	}
+}
+

mp/src/tier1/diff.cpp

@@ -0,0 +1,547 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "tier0/platform.h"
+#include "tier0/dbg.h"
+#include "tier1/diff.h"
+#include "mathlib/mathlib.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+// format of diff output:
+// 0NN (N=1..127)  copy next N literaly
+//
+// 1NN (N=1..127) ofs (-128..127) copy next N bytes from original, changin offset by N bytes from
+// last copy end
+// 100 N ofs(-32768..32767) copy next N, with larger delta offset
+// 00 NNNN(1..65535) ofs(-32768..32767) big copy from old
+// 80 00 NN NN NN big raw copy
+//
+// available codes (could be used for additonal compression ops)
+// long offset form whose offset could have fit in short offset
+
+// note - this algorithm uses storage equal to 8* the old buffer size. 64k=.5mb
+
+
+#define MIN_MATCH_LEN 8
+#define ACCEPTABLE_MATCH_LEN 4096
+
+struct BlockPtr
+{
+  BlockPtr *Next;
+  uint8 const *dataptr;
+};
+
+template<class T,class V> static inline void AddToHead(T * & head, V * node)
+{
+   node->Next=head;
+   head=node;
+}  
+
+void Fail(char const *msg)
+{
+	Assert(0);
+}
+
+void ApplyDiffs(uint8 const *OldBlock, uint8 const *DiffList,
+                int OldSize, int DiffListSize, int &ResultListSize,uint8 *Output,uint32 OutSize)
+{
+  uint8 const *copy_src=OldBlock;
+  uint8 const *end_of_diff_list=DiffList+DiffListSize;
+  uint8 const *obuf=Output;
+  while(DiffList<end_of_diff_list)
+  {
+    //  printf("dptr=%x ",DiffList-d);
+    uint8 op=*(DiffList++);
+    if (op==0)
+    {
+      uint16 copy_sz=DiffList[0]+256*DiffList[1];
+      int copy_ofs=DiffList[2]+DiffList[3]*256;
+      if (copy_ofs>32767)
+        copy_ofs|=0xffff0000;
+    //    printf("long cp from %x to %x len=%d\n", copy_src+copy_ofs-OldBlock,Output-obuf,copy_sz);
+      
+      memcpy(Output,copy_src+copy_ofs,copy_sz);
+      Output+=copy_sz;
+      copy_src=copy_src+copy_ofs+copy_sz;
+      DiffList+=4;
+    }
+    else
+    {
+      if (op & 0x80)
+      {
+        int copy_sz=op & 0x7f;
+        int copy_ofs;
+        if (copy_sz==0)
+        {
+          copy_sz=DiffList[0];
+          if (copy_sz==0)
+          {
+            // big raw copy
+            copy_sz=DiffList[1]+256*DiffList[2]+65536*DiffList[3];
+            memcpy(Output,DiffList+4,copy_sz);
+    //          printf("big rawcopy to %x len=%d\n", Output-obuf,copy_sz);
+            
+            DiffList+=copy_sz+4;
+            Output+=copy_sz;
+          }
+          else
+          {
+            copy_ofs=DiffList[1]+(DiffList[2]*256);
+            if (copy_ofs>32767)
+              copy_ofs|=0xffff0000;
+    //          printf("long ofs cp from %x to %x len=%d\n", copy_src+copy_ofs-OldBlock,Output-obuf,copy_sz);
+            
+            memcpy(Output,copy_src+copy_ofs,copy_sz);
+            Output+=copy_sz;
+            copy_src=copy_src+copy_ofs+copy_sz;
+            DiffList+=3;
+          }
+        }
+        else
+        {
+          copy_ofs=DiffList[0];
+          if (copy_ofs>127)
+            copy_ofs|=0xffffff80;
+    //        printf("cp from %x to %x len=%d\n", copy_src+copy_ofs-OldBlock,Output-obuf,copy_sz);
+          
+          memcpy(Output,copy_src+copy_ofs,copy_sz);
+          Output+=copy_sz;
+          copy_src=copy_src+copy_ofs+copy_sz;
+          DiffList++;
+        }
+      }
+      else
+      {
+    //      printf("raw copy %d to %x\n",op & 127,Output-obuf);
+        memcpy(Output,DiffList,op & 127);
+        Output+=op & 127;
+        DiffList+=(op & 127);
+      }
+    }
+  }
+  ResultListSize=Output-obuf;
+  
+}
+
+static void CopyPending(int len, uint8 const *rawbytes,uint8 * &outbuf, uint8 const *limit)
+{
+//    printf("copy raw len=%d\n",len);
+  if (len<128)
+  {
+    if (limit-outbuf < len+1)
+      Fail("diff buffer overrun");
+    *(outbuf++)=len;
+    memcpy(outbuf,rawbytes,len);
+    outbuf+=len;
+  }
+  else
+  {
+    if (limit-outbuf < len+5)
+      Fail("diff buffer overrun");
+    *(outbuf++)=0x80;
+    *(outbuf++)=0x00;
+    *(outbuf++)=(len & 255);
+    *(outbuf++)=((len>>8) & 255);
+    *(outbuf++)=((len>>16) & 255);
+    memcpy(outbuf,rawbytes,len);
+    outbuf+=len;
+  }
+}
+
+static uint32 hasher(uint8 const *mdata)
+{
+  // attempt to scramble the bits of h1 and h2 together
+  uint32 ret=0;
+  for(int i=0;i<MIN_MATCH_LEN;i++)
+  {
+    ret=ret<<4;
+    ret+=(*mdata++);
+  }
+  return ret;
+}
+
+int FindDiffsForLargeFiles(uint8 const *NewBlock, uint8 const *OldBlock,
+                            int NewSize, int OldSize, int &DiffListSize,uint8 *Output,
+                            uint32 OutSize,
+                            int hashsize)
+{
+  
+  int ret=0;
+  if (OldSize!=NewSize)
+    ret=1;
+  // first, build the hash table
+  BlockPtr **HashedMatches=new BlockPtr* [hashsize];
+  memset(HashedMatches,0,sizeof(HashedMatches[0])*hashsize);
+  BlockPtr *Blocks=0;
+  if (OldSize)
+    Blocks=new BlockPtr[OldSize];
+  BlockPtr *FreeList=Blocks;
+  // now, build the hash table
+  uint8 const *walk=OldBlock;
+  if (OldBlock && OldSize)
+    while(walk<OldBlock+OldSize-MIN_MATCH_LEN)
+    {
+      uint32 hash1=hasher(walk);
+      hash1 &=(hashsize-1);
+      BlockPtr *newnode=FreeList;
+      FreeList++;
+      newnode->dataptr=walk;
+      AddToHead(HashedMatches[hash1],newnode);
+      walk++;
+    }
+  else
+    ret=1;
+  // now, we have the hash table which may be used to search. begin the output step
+  int pending_raw_len=0;
+  walk=NewBlock;
+  uint8 *outbuf=Output;
+  uint8 const *lastmatchend=OldBlock;
+  while(walk<NewBlock+NewSize)
+  {
+    int longest=0;
+    BlockPtr *longest_block=0;
+    if (walk<NewBlock+NewSize-MIN_MATCH_LEN)
+    {
+      // check for a match
+      uint32 hash1=hasher(walk);
+      hash1 &= (hashsize-1);
+      // now, find the longest match in the hash table. If we find one >MIN_MATCH_LEN, take it
+      for(BlockPtr *b=HashedMatches[hash1];b;b=b->Next)
+      {
+        // find the match length
+        int match_of=b->dataptr-lastmatchend;
+        if ((match_of>-32768) && (match_of<32767))
+        {
+          int max_mlength=min(65535,OldBlock+OldSize-b->dataptr);
+          max_mlength=min(max_mlength,NewBlock+NewSize-walk);
+          int i;
+		  for(i=0;i<max_mlength;i++)
+            if (walk[i]!=b->dataptr[i])
+              break;
+          if ((i>MIN_MATCH_LEN) && (i>longest))
+          {
+            longest=i;
+            longest_block=b;
+            if (longest>ACCEPTABLE_MATCH_LEN)
+              break;
+          }
+        }
+      }
+    }
+    // now, we have a match maybe
+    if (longest_block)
+    {      
+      if (pending_raw_len)                                  // must output
+      {
+        ret=1;
+        CopyPending(pending_raw_len,walk-pending_raw_len,outbuf,Output+OutSize);
+        pending_raw_len=0;
+      }
+      // now, output copy block
+      int match_of=longest_block->dataptr-lastmatchend;
+      int nremaining=OutSize-(outbuf-Output);
+      
+      if (match_of)
+        ret=1;
+//        printf("copy from %x to %x len=%d\n", match_of,outbuf-Output,longest);
+      if (longest>127)
+      {
+        // use really long encoding
+        if (nremaining<5)
+          Fail("diff buff needs increase");
+        *(outbuf++)=00;
+        *(outbuf++)=(longest & 255);
+        *(outbuf++)=((longest>>8) & 255);
+        *(outbuf++)=(match_of & 255);
+        *(outbuf++)=((match_of>>8) & 255);
+        
+      }
+      else
+      {
+        if ((match_of>=-128) && (match_of<128))
+        {
+          if (nremaining<2)
+            Fail("diff buff needs increase");
+          *(outbuf++)=128+longest;
+          *(outbuf++)=(match_of&255);
+        }
+        else
+        {
+          // use long encoding
+          if (nremaining<4)
+            Fail("diff buff needs increase");
+          *(outbuf++)=0x80;          
+          *(outbuf++)=longest;
+          *(outbuf++)=(match_of & 255);
+          *(outbuf++)=((match_of>>8) & 255);
+        }
+      }
+      lastmatchend=longest_block->dataptr+longest;
+      walk+=longest;
+    }
+    else
+    {
+      walk++;
+      pending_raw_len++;
+    }
+  }
+  // now, flush pending raw copy
+  if (pending_raw_len)                                  // must output
+  {
+    ret=1;
+    CopyPending(pending_raw_len,walk-pending_raw_len,outbuf,Output+OutSize);
+    pending_raw_len=0;
+  }
+  delete[] HashedMatches;
+  if (Blocks)
+    delete[] Blocks;
+  DiffListSize=outbuf-Output;
+  return ret;
+}
+
+
+int FindDiffs(uint8 const *NewBlock, uint8 const *OldBlock,
+               int NewSize, int OldSize, int &DiffListSize,uint8 *Output,uint32 OutSize)
+{
+  
+  int ret=0;
+  if (OldSize!=NewSize)
+    ret=1;
+  // first, build the hash table
+  BlockPtr *HashedMatches[65536];
+  memset(HashedMatches,0,sizeof(HashedMatches));
+  BlockPtr *Blocks=0;
+  if (OldSize)
+    Blocks=new BlockPtr[OldSize];
+  BlockPtr *FreeList=Blocks;
+  // now, build the hash table
+  uint8 const *walk=OldBlock;
+  if (OldBlock && OldSize)
+    while(walk<OldBlock+OldSize-MIN_MATCH_LEN)
+    {
+      uint16 hash1=*((uint16 const *) walk)+*((uint16 const *) walk+2);
+      BlockPtr *newnode=FreeList;
+      FreeList++;
+      newnode->dataptr=walk;
+      AddToHead(HashedMatches[hash1],newnode);
+      walk++;
+    }
+  else
+    ret=1;
+  // now, we have the hash table which may be used to search. begin the output step
+  int pending_raw_len=0;
+  walk=NewBlock;
+  uint8 *outbuf=Output;
+  uint8 const *lastmatchend=OldBlock;
+  while(walk<NewBlock+NewSize)
+  {
+    int longest=0;
+    BlockPtr *longest_block=0;
+    if (walk<NewBlock+NewSize-MIN_MATCH_LEN)
+    {
+      // check for a match
+      uint16 hash1=*((uint16 const *) walk)+*((uint16 const *) walk+2);
+      // now, find the longest match in the hash table. If we find one >MIN_MATCH_LEN, take it
+      for(BlockPtr *b=HashedMatches[hash1];b;b=b->Next)
+      {
+        // find the match length
+        int match_of=b->dataptr-lastmatchend;
+        if ((match_of>-32768) && (match_of<32767))
+        {
+          int max_mlength=min(65535,OldBlock+OldSize-b->dataptr);
+          max_mlength=min(max_mlength,NewBlock+NewSize-walk);
+          int i;
+		  for(i=0;i<max_mlength;i++)
+            if (walk[i]!=b->dataptr[i])
+              break;
+          if ((i>MIN_MATCH_LEN) && (i>longest))
+          {
+            longest=i;
+            longest_block=b;
+          }
+        }
+      }
+    }
+    // now, we have a match maybe
+    if (longest_block)
+    {
+      if (pending_raw_len)                                  // must output
+      {
+        ret=1;
+        CopyPending(pending_raw_len,walk-pending_raw_len,outbuf,Output+OutSize);
+        pending_raw_len=0;
+      }
+      // now, output copy block
+      int match_of=longest_block->dataptr-lastmatchend;
+      int nremaining=OutSize-(outbuf-Output);
+      if (match_of)
+        ret=1;
+      if (longest>127)
+      {
+        // use really long encoding
+        if (nremaining<5)
+          Fail("diff buff needs increase");
+        *(outbuf++)=00;
+        *(outbuf++)=(longest & 255);
+        *(outbuf++)=((longest>>8) & 255);
+        *(outbuf++)=(match_of & 255);
+        *(outbuf++)=((match_of>>8) & 255);
+      }
+      else
+      {
+        if ((match_of>=-128) && (match_of<128))
+        {
+          if (nremaining<2)
+            Fail("diff buff needs increase");
+          *(outbuf++)=128+longest;
+          *(outbuf++)=(match_of&255);
+        }
+        else
+        {
+          // use long encoding
+          if (nremaining<4)
+            Fail("diff buff needs increase");
+          *(outbuf++)=0x80;
+          *(outbuf++)=longest;
+          *(outbuf++)=(match_of & 255);
+          *(outbuf++)=((match_of>>8) & 255);
+        }
+      }
+      lastmatchend=longest_block->dataptr+longest;
+      walk+=longest;
+    }
+    else
+    {
+      walk++;
+      pending_raw_len++;
+    }
+  }
+  // now, flush pending raw copy
+  if (pending_raw_len)                                  // must output
+  {
+    ret=1;
+    CopyPending(pending_raw_len,walk-pending_raw_len,outbuf,Output+OutSize);
+    pending_raw_len=0;
+  }
+  if (Blocks)
+    delete[] Blocks;
+  DiffListSize=outbuf-Output;
+  return ret;
+}
+
+
+int FindDiffsLowMemory(uint8 const *NewBlock, uint8 const *OldBlock,
+                        int NewSize, int OldSize, int &DiffListSize,uint8 *Output,uint32 OutSize)
+{
+  
+  int ret=0;
+  if (OldSize!=NewSize)
+    ret=1;
+  uint8 const *old_data_hash[256];
+  memset(old_data_hash,0,sizeof(old_data_hash));
+  int pending_raw_len=0;
+  uint8 const *walk=NewBlock;
+  uint8 const *oldptr=OldBlock;
+  uint8 *outbuf=Output;
+  uint8 const *lastmatchend=OldBlock;
+  while(walk<NewBlock+NewSize)
+  {
+    while( (oldptr-OldBlock<walk-NewBlock+40) && (oldptr-OldBlock<OldSize-MIN_MATCH_LEN))
+    {
+      uint16 hash1=(oldptr[0]+oldptr[1]+oldptr[2]+oldptr[3]) & (NELEMS(old_data_hash)-1);
+      old_data_hash[hash1]=oldptr;
+      oldptr++;
+    }
+    int longest=0;
+    uint8 const *longest_block=0;
+    if (walk<NewBlock+NewSize-MIN_MATCH_LEN)
+    {
+      // check for a match
+      uint16 hash1=(walk[0]+walk[1]+walk[2]+walk[3]) & (NELEMS(old_data_hash)-1);
+      if (old_data_hash[hash1])
+      {
+        int max_bytes_to_compare=min(NewBlock+NewSize-walk,OldBlock+OldSize-old_data_hash[hash1]);
+        int nmatches;
+		for(nmatches=0;nmatches<max_bytes_to_compare;nmatches++)
+          if (walk[nmatches]!=old_data_hash[hash1][nmatches])
+            break;
+        if (nmatches>MIN_MATCH_LEN)
+        {
+          longest_block=old_data_hash[hash1];
+          longest=nmatches;
+        }
+      }
+    }
+    // now, we have a match maybe
+    if (longest_block)
+    {
+      if (pending_raw_len)                                  // must output
+      {
+        ret=1;
+        CopyPending(pending_raw_len,walk-pending_raw_len,outbuf,Output+OutSize);
+        pending_raw_len=0;
+      }
+      // now, output copy block
+      int match_of=longest_block-lastmatchend;
+      int nremaining=OutSize-(outbuf-Output);
+      if (match_of)
+        ret=1;
+      if (longest>127)
+      {
+        // use really long encoding
+        if (nremaining<5)
+          Fail("diff buff needs increase");
+        *(outbuf++)=00;
+        *(outbuf++)=(longest & 255);
+        *(outbuf++)=((longest>>8) & 255);
+        *(outbuf++)=(match_of & 255);
+        *(outbuf++)=((match_of>>8) & 255);
+      }
+      else
+      {
+        if ((match_of>=-128) && (match_of<128))
+        {
+          if (nremaining<2)
+            Fail("diff buff needs increase");
+          *(outbuf++)=128+longest;
+          *(outbuf++)=(match_of&255);
+        }
+        else
+        {
+          // use long encoding
+          if (nremaining<4)
+            Fail("diff buff needs increase");
+          *(outbuf++)=0x80;
+          *(outbuf++)=longest;
+          *(outbuf++)=(match_of & 255);
+          *(outbuf++)=((match_of>>8) & 255);
+        }
+      }
+      lastmatchend=longest_block+longest;
+      walk+=longest;
+    }
+    else
+    {
+      walk++;
+      pending_raw_len++;
+    }
+  }
+  // now, flush pending raw copy
+  if (pending_raw_len)                                  // must output
+  {
+    ret=1;
+    CopyPending(pending_raw_len,walk-pending_raw_len,outbuf,Output+OutSize);
+    pending_raw_len=0;
+  }
+  DiffListSize=outbuf-Output;
+  return ret;
+}
+
+

mp/src/tier1/fileio.cpp

@@ -0,0 +1,497 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: A collection of utility classes to simplify file I/O, and
+//			as much as possible contain portability problems. Here avoiding 
+//			including windows.h.
+//
+//=============================================================================
+
+#if defined(_WIN32)
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0502		// ReadDirectoryChangesW
+#endif
+
+#if defined(OSX)
+#include <CoreServices/CoreServices.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <sys/time.h>
+#endif
+
+#define ASYNC_FILEIO
+#if defined( LINUX )
+// Linux hasn't got a good AIO library that we have found yet, so lets punt for now
+#undef ASYNC_FILEIO
+#endif
+
+#if defined(_WIN32)
+//#include <direct.h>
+#include <io.h>
+// unset to force to use stdio implementation 
+#define WIN32_FILEIO
+
+#if defined(ASYNC_FILEIO) 
+#if defined(_WIN32) && !defined(WIN32_FILEIO)
+#error "trying to use async io without win32 filesystem API usage, that isn't doable"
+#endif
+#endif
+
+#else /* not defined (_WIN32) */
+#include <utime.h>
+#include <dirent.h>
+#include <unistd.h> // for unlink
+#include <limits.h> // defines PATH_MAX
+#include <alloca.h> // 'cause we like smashing the stack
+#if defined( _PS3 )
+#include <fcntl.h>
+#else
+#include <sys/fcntl.h>
+#include <sys/statvfs.h>
+#endif
+#include <sched.h>
+#define int64 int64_t
+
+#define _A_SUBDIR S_IFDIR
+
+// FUTURE map _A_HIDDEN via checking filename against .*
+#define _A_HIDDEN 0
+
+// FUTURE check 'read only' by checking mode against S_IRUSR
+#define _A_RDONLY 0
+
+// no files under posix are 'system' or 'archive'
+#define _A_SYSTEM 0
+#define _A_ARCH   0
+
+#endif 
+
+#include "tier1/fileio.h"
+#include "tier1/utlbuffer.h"
+#include "tier1/strtools.h"
+#include <errno.h>
+
+#if defined( WIN32_FILEIO )
+#include "winlite.h"
+#endif
+
+#if defined( ASYNC_FILEIO )
+#ifdef _WIN32
+#include "winlite.h"
+#elif defined(_PS3)
+// bugbug ps3 - see some aio files under libfs.. skipping for the moment
+#elif defined(POSIX)
+#include <aio.h>
+#else
+#error "aio please"
+#endif
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor from UTF8
+//-----------------------------------------------------------------------------
+CPathString::CPathString( const char *pchUTF8Path )
+{
+	// Need to first turn into an absolute path, so \\?\ pre-pended paths will be ok
+	m_pchUTF8Path = new char[ MAX_UNICODE_PATH_IN_UTF8 ];
+	m_pwchWideCharPathPrepended = NULL;
+
+	// First, convert to absolute path, which also does Q_FixSlashes for us.
+	Q_MakeAbsolutePath( m_pchUTF8Path, MAX_UNICODE_PATH * 4, pchUTF8Path );
+
+	// Second, fix any double slashes
+	V_FixDoubleSlashes( m_pchUTF8Path );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+CPathString::~CPathString()
+{
+	if ( m_pwchWideCharPathPrepended )
+	{
+		delete[] m_pwchWideCharPathPrepended;
+		m_pwchWideCharPathPrepended = NULL;
+	}
+
+	if ( m_pchUTF8Path )
+	{
+		delete[] m_pchUTF8Path;
+		m_pchUTF8Path = NULL;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Access UTF8 path
+//-----------------------------------------------------------------------------
+const char * CPathString::GetUTF8Path()
+{
+	return m_pchUTF8Path;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets wchar_t based path, with \\?\ pre-pended (allowing long paths 
+// on Win32, should only be used with unicode extended path aware filesystem calls)
+//-----------------------------------------------------------------------------
+const wchar_t *CPathString::GetWCharPathPrePended()
+{
+	PopulateWCharPath();
+	return m_pwchWideCharPathPrepended; 
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Builds wchar path string
+//-----------------------------------------------------------------------------
+void CPathString::PopulateWCharPath()
+{
+	if ( m_pwchWideCharPathPrepended )
+		return;
+
+	// Check if the UTF8 path starts with \\, which on Win32 means it's a UNC path, and then needs a different prefix
+	if ( m_pchUTF8Path[0] == '\\' && m_pchUTF8Path[1] == '\\' )
+	{
+		m_pwchWideCharPathPrepended = new wchar_t[MAX_UNICODE_PATH+8];
+		Q_memcpy( m_pwchWideCharPathPrepended, L"\\\\?\\UNC\\", 8*sizeof(wchar_t) );
+#ifdef DBGFLAG_ASSERT
+		int cchResult =
+#endif
+			Q_UTF8ToUnicode( m_pchUTF8Path+2, m_pwchWideCharPathPrepended+8, MAX_UNICODE_PATH*sizeof(wchar_t) );
+		Assert( cchResult );
+
+		// Be sure we NULL terminate within our allocated region incase Q_UTF8ToUnicode failed, though we're already in bad shape then.
+		m_pwchWideCharPathPrepended[MAX_UNICODE_PATH+7] = 0;
+	}
+	else
+	{
+		m_pwchWideCharPathPrepended = new wchar_t[MAX_UNICODE_PATH+4];
+		Q_memcpy( m_pwchWideCharPathPrepended, L"\\\\?\\", 4*sizeof(wchar_t) );
+#ifdef DBGFLAG_ASSERT
+		int cchResult =
+#endif
+			Q_UTF8ToUnicode( m_pchUTF8Path, m_pwchWideCharPathPrepended+4, MAX_UNICODE_PATH*sizeof(wchar_t) );
+		Assert( cchResult );
+
+		// Be sure we NULL terminate within our allocated region incase Q_UTF8ToUnicode failed, though we're already in bad shape then.
+		m_pwchWideCharPathPrepended[MAX_UNICODE_PATH+3] = 0;
+	}
+}
+
+#ifdef WIN32
+struct DirWatcherOverlapped : public OVERLAPPED
+{
+	CDirWatcher *m_pDirWatcher;
+};
+#endif
+
+#if !defined(_PS3) && !defined(_X360)
+// a buffer full of file names
+static const int k_cubDirWatchBufferSize = 8 * 1024;
+
+//-----------------------------------------------------------------------------
+// Purpose: directory watching
+//-----------------------------------------------------------------------------
+CDirWatcher::CDirWatcher()
+{
+	m_hFile = NULL;
+	m_pOverlapped = NULL;
+	m_pFileInfo = NULL;
+#ifdef OSX
+	m_WatcherStream = 0;
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: directory watching
+//-----------------------------------------------------------------------------
+CDirWatcher::~CDirWatcher()
+{
+#ifdef WIN32
+	if ( m_pOverlapped )
+	{
+		// mark the overlapped structure as gone
+		DirWatcherOverlapped *pDirWatcherOverlapped = (DirWatcherOverlapped *)m_pOverlapped;
+		pDirWatcherOverlapped->m_pDirWatcher = NULL;
+	}
+
+	if ( m_hFile )
+	{
+		// make sure we flush any pending I/O's on the handle
+		::CancelIo( m_hFile );
+		::SleepEx( 0, TRUE );
+		// close the handle
+		::CloseHandle( m_hFile );
+	}
+#elif defined(OSX)
+	if ( m_WatcherStream )
+	{
+		FSEventStreamStop( (FSEventStreamRef)m_WatcherStream );
+		FSEventStreamInvalidate( (FSEventStreamRef)m_WatcherStream );
+		FSEventStreamRelease( (FSEventStreamRef)m_WatcherStream );		
+		m_WatcherStream = 0;
+	}
+#endif
+	if ( m_pFileInfo )
+	{
+		free( m_pFileInfo );
+	}
+	if ( m_pOverlapped )
+	{
+		free( m_pOverlapped );
+	}
+}
+
+
+#ifdef WIN32
+//-----------------------------------------------------------------------------
+// Purpose: callback watch
+//			gets called on the same thread whenever a SleepEx() occurs
+//-----------------------------------------------------------------------------
+class CDirWatcherFriend
+{
+public:
+	static void WINAPI DirWatchCallback( DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered, OVERLAPPED *pOverlapped )
+	{
+		DirWatcherOverlapped *pDirWatcherOverlapped = (DirWatcherOverlapped *)pOverlapped;
+
+		// see if we've been cancelled
+		if ( !pDirWatcherOverlapped->m_pDirWatcher )
+			return;
+
+		// parse and pass back
+		if ( dwNumberOfBytesTransfered > sizeof(FILE_NOTIFY_INFORMATION) )
+		{
+			FILE_NOTIFY_INFORMATION *pFileNotifyInformation = (FILE_NOTIFY_INFORMATION *)pDirWatcherOverlapped->m_pDirWatcher->m_pFileInfo;
+			do 
+			{
+				// null terminate the string and turn it to UTF-8
+				int cNumWChars = pFileNotifyInformation->FileNameLength / sizeof(wchar_t);
+				wchar_t *pwchT = new wchar_t[cNumWChars + 1];
+				memcpy( pwchT, pFileNotifyInformation->FileName, pFileNotifyInformation->FileNameLength );
+				pwchT[cNumWChars] = 0;
+				CStrAutoEncode strAutoEncode( pwchT );
+
+				// add it to our list
+				pDirWatcherOverlapped->m_pDirWatcher->AddFileToChangeList( strAutoEncode.ToString() );
+				delete[] pwchT;
+				if ( pFileNotifyInformation->NextEntryOffset == 0 )
+					break;
+
+				// move to the next file
+				pFileNotifyInformation = (FILE_NOTIFY_INFORMATION *)(((byte*)pFileNotifyInformation) + pFileNotifyInformation->NextEntryOffset);
+			} while ( 1 );
+		}
+
+
+		// watch again
+		pDirWatcherOverlapped->m_pDirWatcher->PostDirWatch();
+	}
+};
+#elif defined(OSX)
+void CheckDirectoryForChanges( const char *path_buff, CDirWatcher *pDirWatch, bool bRecurse )
+{
+	DIR *dir = opendir(path_buff);
+	char fullpath[MAX_PATH];
+	struct dirent *dirent;
+	struct timespec ts = { 0, 0 };
+	bool bTimeSet = false;
+	
+	while ( (dirent = readdir(dir)) != NULL ) 
+	{
+		if (strcmp(dirent->d_name, ".") == 0 || strcmp(dirent->d_name, "..") == 0)
+			continue;
+		
+		snprintf( fullpath, PATH_MAX, "%s/%s", path_buff, dirent->d_name );
+		
+		struct stat    st;
+		if (lstat(fullpath, &st) != 0)
+			continue;
+		
+		if ( S_ISDIR(st.st_mode) && bRecurse )
+		{
+			CheckDirectoryForChanges( fullpath, pDirWatch, bRecurse );
+		}
+		else if ( st.st_mtimespec.tv_sec > pDirWatch->m_modTime.tv_sec ||
+				 ( st.st_mtimespec.tv_sec == pDirWatch->m_modTime.tv_sec && st.st_mtimespec.tv_nsec > pDirWatch->m_modTime.tv_nsec ) )
+		{
+			ts = st.st_mtimespec;
+			bTimeSet = true;
+			// the win32 size only sends up the dir relative to the watching dir, so replicate that here
+			pDirWatch->AddFileToChangeList( fullpath + pDirWatch->m_BaseDir.Length() + 1 );
+		}
+	}
+
+	if ( bTimeSet )
+		pDirWatch->m_modTime = ts;
+	closedir(dir);	
+}
+
+static void fsevents_callback( ConstFSEventStreamRef streamRef, void *clientCallBackInfo, size_t numEvents,void *eventPaths, 
+							  const FSEventStreamEventFlags eventMasks[], const FSEventStreamEventId eventIDs[] )
+{
+    char  path_buff[PATH_MAX];
+	for (int i=0; i < numEvents; i++) 
+	{
+		char **paths = (char **)eventPaths;
+		
+        strcpy(path_buff, paths[i]);
+        int len = strlen(path_buff);
+        if (path_buff[len-1] == '/') 
+		{
+            // chop off a trailing slash
+            path_buff[--len] = '\0';
+        }
+		
+		bool bRecurse = false;
+		
+        if (eventMasks[i] & kFSEventStreamEventFlagMustScanSubDirs
+			|| eventMasks[i] & kFSEventStreamEventFlagUserDropped
+			|| eventMasks[i] & kFSEventStreamEventFlagKernelDropped) 
+		{
+            bRecurse = true;
+        } 
+		
+		CDirWatcher *pDirWatch = (CDirWatcher *)clientCallBackInfo;
+		// make sure its in our subdir
+		if ( !V_strnicmp( path_buff, pDirWatch->m_BaseDir.String(), pDirWatch->m_BaseDir.Length() ) )
+			CheckDirectoryForChanges( path_buff, pDirWatch, bRecurse );
+    }
+}
+
+
+
+
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: only one directory can be watched at a time
+//-----------------------------------------------------------------------------
+void CDirWatcher::SetDirToWatch( const char *pchDir )
+{
+	if ( !pchDir || !*pchDir )
+		return;
+	
+	CPathString strPath( pchDir );
+#ifdef WIN32
+	// open the directory
+	m_hFile = ::CreateFileW( strPath.GetWCharPathPrePended(), FILE_LIST_DIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED | FILE_FLAG_BACKUP_SEMANTICS, NULL );
+
+	// create our buffers
+	m_pFileInfo = malloc( k_cubDirWatchBufferSize );
+	m_pOverlapped = malloc( sizeof( DirWatcherOverlapped ) );
+
+	// post a watch
+	PostDirWatch();
+#elif defined(OSX)
+	CFStringRef mypath = CFStringCreateWithCString( NULL, strPath.GetUTF8Path(), kCFStringEncodingMacRoman );
+	if ( !mypath )
+	{
+		Assert( !"Failed to CFStringCreateWithCString watcher path" );
+		return;
+	}
+	
+    CFArrayRef pathsToWatch = CFArrayCreate(NULL, (const void **)&mypath, 1, NULL);
+    FSEventStreamContext callbackInfo = {0, this, NULL, NULL, NULL};
+    CFAbsoluteTime latency = 1.0; // Latency in seconds
+
+    m_WatcherStream = (void *)FSEventStreamCreate(NULL,
+								 &fsevents_callback,
+								 &callbackInfo,
+								 pathsToWatch,
+								 kFSEventStreamEventIdSinceNow, 
+								 latency,
+								 kFSEventStreamCreateFlagNoDefer
+								 );
+	
+    FSEventStreamScheduleWithRunLoop( (FSEventStreamRef)m_WatcherStream, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
+	CFRelease(pathsToWatch );
+	CFRelease( mypath );
+	
+	FSEventStreamStart( (FSEventStreamRef)m_WatcherStream );
+
+	char szFullPath[MAX_PATH];
+	Q_MakeAbsolutePath( szFullPath, sizeof(szFullPath), pchDir );
+	m_BaseDir = szFullPath;
+	
+	struct timeval tv;
+	gettimeofday( &tv, NULL );
+	TIMEVAL_TO_TIMESPEC( &tv, &m_modTime );
+		
+#else
+	Assert( !"Impl me" );
+#endif
+}
+
+
+#ifdef WIN32
+//-----------------------------------------------------------------------------
+// Purpose: used by callback functions to push a file onto the list
+//-----------------------------------------------------------------------------
+void CDirWatcher::PostDirWatch()
+{
+	memset( m_pOverlapped, 0, sizeof(DirWatcherOverlapped) );
+	DirWatcherOverlapped *pDirWatcherOverlapped = (DirWatcherOverlapped *)m_pOverlapped;
+	pDirWatcherOverlapped->m_pDirWatcher = this;
+
+	DWORD dwBytes;
+	::ReadDirectoryChangesW( m_hFile, m_pFileInfo, k_cubDirWatchBufferSize, TRUE, FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_FILE_NAME, &dwBytes, (OVERLAPPED *)m_pOverlapped, &CDirWatcherFriend::DirWatchCallback );
+}
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Purpose: used by callback functions to push a file onto the list
+//-----------------------------------------------------------------------------
+void CDirWatcher::AddFileToChangeList( const char *pchFile )
+{
+	// make sure it isn't already in the list
+	FOR_EACH_LL( m_listChangedFiles, i )
+	{
+		if ( !Q_stricmp( m_listChangedFiles[i], pchFile ) )
+			return;
+	}
+
+	m_listChangedFiles.AddToTail( pchFile );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: retrieve any changes
+//-----------------------------------------------------------------------------
+bool CDirWatcher::GetChangedFile( CUtlString *psFile )
+{
+#ifdef WIN32
+	// this will trigger any pending directory reads
+	// this does get hit other places in the code; so the callback can happen at any time
+	::SleepEx( 0, TRUE );
+#endif
+
+	if ( !m_listChangedFiles.Count() )
+		return false;
+
+	*psFile = m_listChangedFiles[m_listChangedFiles.Head()];
+	m_listChangedFiles.Remove( m_listChangedFiles.Head() );
+	return true;
+}
+
+
+
+#ifdef DBGFLAG_VALIDATE
+void CDirWatcher::Validate( CValidator &validator, const char *pchName )
+{
+	VALIDATE_SCOPE();
+
+	validator.ClaimMemory( m_pOverlapped );
+	validator.ClaimMemory( m_pFileInfo );
+	ValidateObj( m_listChangedFiles );
+	FOR_EACH_LL( m_listChangedFiles, i )
+	{
+		ValidateObj( m_listChangedFiles[i] );
+	}
+}
+#endif
+
+#endif // _PS3 || _X360

mp/src/tier1/generichash.cpp

@@ -0,0 +1,437 @@
+//========= Copyright 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 "generichash.h"
+#include <ctype.h>
+#include "tier0/dbg.h"
+
+// NOTE: This has to be the last file included!
+#include "tier0/memdbgon.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 )
+{
+	const uint8 *k =   (const uint8 *)pszKey;
+	unsigned 	even = 0,
+				odd  = 0,
+				n;
+
+	while ((n = *k++) != 0)
+	{
+		even = g_nRandomValues[odd ^ n];
+		if ((n = *k++) != 0)
+			odd = g_nRandomValues[even ^ n];
+		else
+			break;
+	}
+
+	return (even << 8) | odd ;
+}
+
+
+//-----------------------------------------------------------------------------
+// Case-insensitive string 
+//-----------------------------------------------------------------------------
+unsigned FASTCALL HashStringCaseless( const char *pszKey )
+{
+	const uint8 *k = (const uint8 *) pszKey;
+	unsigned	even = 0,
+				odd  = 0,
+				n;
+
+	while ((n = toupper(*k++)) != 0)
+	{
+		even = g_nRandomValues[odd ^ n];
+		if ((n = toupper(*k++)) != 0)
+			odd = g_nRandomValues[even ^ n];
+		else
+			break;
+	}
+
+	return (even << 8) | odd;
+}
+
+//-----------------------------------------------------------------------------
+// 32 bit conventional case-insensitive string 
+//-----------------------------------------------------------------------------
+unsigned FASTCALL HashStringCaselessConventional( 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;
+}
+
+//-----------------------------------------------------------------------------
+// int hash
+//-----------------------------------------------------------------------------
+unsigned FASTCALL HashInt( const int n )
+{
+	register 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 )
+{
+	register const uint32 *	p = (const uint32 *) pKey;
+	register 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 )
+{
+	register const uint32 *	p = (const uint32 *) pKey;
+	register 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 )
+{
+	register const uint32 *	p = (const uint32 *) pKey;
+	register 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 )
+{
+	register const uint32 *	p = (const uint32 *) pKey;
+	register 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;
+}
+
+
+//-----------------------------------------------------------------------------
+// Murmur hash
+//-----------------------------------------------------------------------------
+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;
+}
+
+#define TOLOWERU( c ) ( ( uint32 ) ( ( ( c >= 'A' ) && ( c <= 'Z' ) )? c + 32 : c ) )
+uint32 MurmurHash2LowerCase( char const *pString, uint32 nSeed )
+{
+	int nLen = strlen( pString );
+	char *p = ( char * ) stackalloc( nLen + 1 );
+	for( int i = 0; i < nLen ; i++ )
+	{
+		p[i] = TOLOWERU( pString[i] );
+	}
+	return MurmurHash2( p, nLen, nSeed );
+}
+
+
+//-----------------------------------------------------------------------------
+// Murmur hash, 64 bit- endian neutral
+//-----------------------------------------------------------------------------
+uint64 MurmurHash64( 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 h1 = seed ^ len;
+	uint32 h2 = 0;
+
+	// Mix 4 bytes at a time into the hash
+
+	const uint32 * data = (const uint32 *)key;
+	while ( len >= 8 )
+	{
+		uint32 k1 = LittleDWord( *data++ );
+		k1 *= m; k1 ^= k1 >> r; k1 *= m;
+		h1 *= m; h1 ^= k1;
+		len -= 4;
+
+		uint32 k2 = LittleDWord( *data++ );
+		k2 *= m; k2 ^= k2 >> r; k2 *= m;
+		h2 *= m; h2 ^= k2;
+		len -= 4;
+	}
+
+	if(len >= 4)
+	{
+		uint32 k1 = LittleDWord( *data++ );
+		k1 *= m; k1 ^= k1 >> r; k1 *= m;
+		h1 *= m; h1 ^= k1;
+		len -= 4;
+	}
+
+	// Handle the last few bytes of the input array
+	switch(len)
+	{
+	case 3: h2 ^= ((uint8*)data)[2] << 16;
+	case 2: h2 ^= ((uint8*)data)[1] << 8;
+	case 1: h2 ^= ((uint8*)data)[0];
+			h2 *= m;
+	};
+
+	h1 ^= h2 >> 18; h1 *= m;
+	h2 ^= h1 >> 22; h2 *= m;
+	h1 ^= h2 >> 17; h1 *= m;
+	h2 ^= h1 >> 19; h2 *= m;
+
+	uint64 h = h1;
+
+	h = (h << 32) | h2;
+
+	return h;
+}
+

mp/src/tier1/ilocalize.cpp

@@ -0,0 +1,259 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#if defined( WIN32 ) && !defined( _X360 )
+	#include <windows.h>
+#elif defined( POSIX )
+	#include <iconv.h>
+#endif
+
+#include "tier1/ilocalize.h"
+#include "utlstring.h"
+
+#pragma warning( disable: 4018 ) // '<' : signed/unsigned mismatch
+
+//-----------------------------------------------------------------------------
+// Purpose: converts an english string to unicode
+//-----------------------------------------------------------------------------
+int ILocalize::ConvertANSIToUnicode(const char *ansi, wchar_t *unicode, int unicodeBufferSizeInBytes)
+{
+#ifdef POSIX
+	return Q_UTF8ToUnicode(ansi, unicode, unicodeBufferSizeInBytes);
+#else
+	int chars = MultiByteToWideChar(CP_UTF8, 0, ansi, -1, unicode, unicodeBufferSizeInBytes / sizeof(wchar_t));
+	unicode[(unicodeBufferSizeInBytes / sizeof(wchar_t)) - 1] = 0;
+	return chars;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: converts an unicode string to an english string
+//-----------------------------------------------------------------------------
+int ILocalize::ConvertUnicodeToANSI(const wchar_t *unicode, char *ansi, int ansiBufferSize)
+{
+#ifdef POSIX
+	return Q_UnicodeToUTF8(unicode, ansi, ansiBufferSize);
+#else
+	int result = WideCharToMultiByte(CP_UTF8, 0, unicode, -1, ansi, ansiBufferSize, NULL, NULL);
+	ansi[ansiBufferSize - 1] = 0;
+	return result;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: construct string helper
+//-----------------------------------------------------------------------------
+template < typename T >
+void ConstructStringVArgsInternal_Impl(T *unicodeOutput, int unicodeBufferSizeInBytes, const T *formatString, int numFormatParameters, va_list argList)
+{
+	static const int k_cMaxFormatStringArguments = 9; // We only look one character ahead and start at %s1
+	Assert( numFormatParameters <= k_cMaxFormatStringArguments );
+
+	// Safety check
+	if ( unicodeOutput == NULL || unicodeBufferSizeInBytes < 1 )
+	{
+		return;
+	}
+
+	if ( !formatString || numFormatParameters > k_cMaxFormatStringArguments )
+	{
+		unicodeOutput[0] = 0;
+		return;
+	}
+
+	int unicodeBufferSize = unicodeBufferSizeInBytes / sizeof(T);
+	const T *searchPos = formatString;
+	T *outputPos = unicodeOutput;
+
+	T *argParams[k_cMaxFormatStringArguments];
+	for ( int i = 0; i < numFormatParameters; i++ )
+	{
+		argParams[i] = va_arg( argList, T* );
+	}
+
+	//assumes we can't have %s10
+	//assume both are 0 terminated?
+	int formatLength = StringFuncs<T>::Length( formatString );
+
+	while ( searchPos[0] != '\0' && unicodeBufferSize > 1 )
+	{
+		if ( formatLength >= 3 && searchPos[0] == '%' && searchPos[1] == 's' )
+		{
+			//this is an escape sequence - %s1, %s2 etc, up to %s9
+
+			int argindex = ( searchPos[2] ) - '0' - 1; // 0 for %s1, 1 for %s2, etc.
+
+			if ( argindex < 0 || argindex > k_cMaxFormatStringArguments )
+			{
+				Warning( "Bad format string in CLocalizeStringTable::ConstructString\n" );
+				*outputPos = '\0';
+				return;
+			}
+
+			if ( argindex < numFormatParameters )
+			{
+				T const *param = argParams[argindex];
+
+				if ( param == NULL )
+					param = StringFuncs<T>::NullDebugString();
+
+				int paramSize = StringFuncs<T>::Length(param);
+				if (paramSize >= unicodeBufferSize)
+				{
+					paramSize = unicodeBufferSize - 1;
+				}
+
+				memcpy(outputPos, param, paramSize * sizeof(T));
+
+				unicodeBufferSize -= paramSize;
+				outputPos += paramSize;
+
+				searchPos += 3;
+				formatLength -= 3;
+			}
+			else
+			{
+				AssertMsg( argindex < numFormatParameters, "ConstructStringVArgsInternal_Impl() - Found a %s# escape sequence whose index was more than the number of args." );
+
+				//copy it over, char by char
+				*outputPos = *searchPos;
+
+				outputPos++;
+				unicodeBufferSize--;
+
+				searchPos++;
+				formatLength--;
+			}
+		}
+		else
+		{
+			//copy it over, char by char
+			*outputPos = *searchPos;
+
+			outputPos++;
+			unicodeBufferSize--;
+
+			searchPos++;
+			formatLength--;
+		}
+	}
+
+	// ensure null termination
+	Assert( outputPos - unicodeOutput < unicodeBufferSizeInBytes/sizeof(T) );
+	*outputPos = L'\0';
+}
+
+void ILocalize::ConstructStringVArgsInternal(char *unicodeOutput, int unicodeBufferSizeInBytes, const char *formatString, int numFormatParameters, va_list argList)
+{
+	ConstructStringVArgsInternal_Impl<char>( unicodeOutput, unicodeBufferSizeInBytes, formatString, numFormatParameters, argList );
+}
+
+void ILocalize::ConstructStringVArgsInternal(wchar_t *unicodeOutput, int unicodeBufferSizeInBytes, const wchar_t *formatString, int numFormatParameters, va_list argList)
+{
+	ConstructStringVArgsInternal_Impl<wchar_t>( unicodeOutput, unicodeBufferSizeInBytes, formatString, numFormatParameters, argList );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: construct string helper
+//-----------------------------------------------------------------------------
+template < typename T >
+const T *GetTypedKeyValuesString( KeyValues *pKeyValues, const char *pKeyName );
+
+template < >
+const char *GetTypedKeyValuesString<char>( KeyValues *pKeyValues, const char *pKeyName )
+{
+	return pKeyValues->GetString( pKeyName, "[unknown]" );
+}
+
+template < >
+const wchar_t *GetTypedKeyValuesString<wchar_t>( KeyValues *pKeyValues, const char *pKeyName )
+{
+	return pKeyValues->GetWString( pKeyName, L"[unknown]" );
+}
+
+template < typename T >
+void ConstructStringKeyValuesInternal_Impl( T *unicodeOutput, int unicodeBufferSizeInBytes, const T *formatString, KeyValues *localizationVariables )
+{
+	T *outputPos = unicodeOutput;
+
+	//assumes we can't have %s10
+	//assume both are 0 terminated?
+	int unicodeBufferSize = unicodeBufferSizeInBytes / sizeof(T);
+
+	while ( *formatString != '\0' && unicodeBufferSize > 1 )
+	{
+		bool shouldAdvance = true;
+
+		if ( *formatString == '%' )
+		{
+			// this is an escape sequence that specifies a variable name
+			if ( formatString[1] == 's' && formatString[2] >= '0' && formatString[2] <= '9' )
+			{
+				// old style escape sequence, ignore
+			}
+			else if ( formatString[1] == '%' )
+			{
+				// just a '%' char, just write the second one
+				formatString++;
+			}
+			else if ( localizationVariables )
+			{
+				// get out the variable name
+				const T *varStart = formatString + 1;
+				const T *varEnd = StringFuncs<T>::FindChar( varStart, '%' );
+
+				if ( varEnd && *varEnd == '%' )
+				{
+					shouldAdvance = false;
+
+					// assume variable names must be ascii, do a quick convert
+					char variableName[32];
+					char *vset = variableName;
+					for ( const T *pws = varStart; pws < varEnd && (vset < variableName + sizeof(variableName) - 1); ++pws, ++vset )
+					{
+						*vset = (char)*pws;
+					}
+					*vset = 0;
+
+					// look up the variable name
+					const T *value = GetTypedKeyValuesString<T>( localizationVariables, variableName );
+					
+					int paramSize = StringFuncs<T>::Length( value );
+					if (paramSize >= unicodeBufferSize)
+					{
+						paramSize = MAX( 0, unicodeBufferSize - 1 );
+					}
+
+					StringFuncs<T>::Copy( outputPos, value, paramSize );
+
+					unicodeBufferSize -= paramSize;
+					outputPos += paramSize;
+					formatString = varEnd + 1;
+				}
+			}
+		}
+
+		if (shouldAdvance)
+		{
+			//copy it over, char by char
+			*outputPos = *formatString;
+
+			outputPos++;
+			unicodeBufferSize--;
+
+			formatString++;
+		}		
+	}
+
+	// ensure null termination
+	*outputPos = '\0';
+}
+
+void ILocalize::ConstructStringKeyValuesInternal(char *unicodeOutput, int unicodeBufferSizeInBytes, const char *formatString, KeyValues *localizationVariables)
+{
+	ConstructStringKeyValuesInternal_Impl<char>( unicodeOutput, unicodeBufferSizeInBytes, formatString, localizationVariables );
+}
+
+void ILocalize::ConstructStringKeyValuesInternal(wchar_t *unicodeOutput, int unicodeBufferSizeInBytes, const wchar_t *formatString, KeyValues *localizationVariables)
+{
+	ConstructStringKeyValuesInternal_Impl<wchar_t>( unicodeOutput, unicodeBufferSizeInBytes, formatString, localizationVariables );
+}

mp/src/tier1/interface.cpp

@@ -0,0 +1,542 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//===========================================================================//
+#if defined( _WIN32 ) && !defined( _X360 )
+#include <windows.h>
+#endif
+
+#if !defined( DONT_PROTECT_FILEIO_FUNCTIONS )
+#define DONT_PROTECT_FILEIO_FUNCTIONS // for protected_things.h
+#endif
+
+#if defined( PROTECTED_THINGS_ENABLE )
+#undef PROTECTED_THINGS_ENABLE // from protected_things.h
+#endif
+
+#include <stdio.h>
+#include "interface.h"
+#include "basetypes.h"
+#include "tier0/dbg.h"
+#include <string.h>
+#include <stdlib.h>
+#include "tier1/strtools.h"
+#include "tier0/icommandline.h"
+#include "tier0/dbg.h"
+#include "tier0/threadtools.h"
+#ifdef _WIN32
+#include <direct.h> // getcwd
+#elif POSIX
+#include <dlfcn.h>
+#include <unistd.h>
+#define _getcwd getcwd
+#endif
+#if defined( _X360 )
+#include "xbox/xbox_win32stubs.h"
+#endif
+
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+// ------------------------------------------------------------------------------------ //
+// InterfaceReg.
+// ------------------------------------------------------------------------------------ //
+InterfaceReg *InterfaceReg::s_pInterfaceRegs = NULL;
+
+InterfaceReg::InterfaceReg( InstantiateInterfaceFn fn, const char *pName ) :
+	m_pName(pName)
+{
+	m_CreateFn = fn;
+	m_pNext = s_pInterfaceRegs;
+	s_pInterfaceRegs = this;
+}
+
+// ------------------------------------------------------------------------------------ //
+// CreateInterface.
+// This is the primary exported function by a dll, referenced by name via dynamic binding
+// that exposes an opqaue function pointer to the interface.
+//
+// We have the Internal variant so Sys_GetFactoryThis() returns the correct internal 
+// symbol under GCC/Linux/Mac as CreateInterface is DLL_EXPORT so its global so the loaders
+// on those OS's pick exactly 1 of the CreateInterface symbols to be the one that is process wide and 
+// all Sys_GetFactoryThis() calls find that one, which doesn't work. Using the internal walkthrough here
+// makes sure Sys_GetFactoryThis() has the dll specific symbol and GetProcAddress() returns the module specific
+// function for CreateInterface again getting the dll specific symbol we need.
+// ------------------------------------------------------------------------------------ //
+void* CreateInterfaceInternal( const char *pName, int *pReturnCode )
+{
+	InterfaceReg *pCur;
+	
+	for (pCur=InterfaceReg::s_pInterfaceRegs; pCur; pCur=pCur->m_pNext)
+	{
+		if (strcmp(pCur->m_pName, pName) == 0)
+		{
+			if (pReturnCode)
+			{
+				*pReturnCode = IFACE_OK;
+			}
+			return pCur->m_CreateFn();
+		}
+	}
+	
+	if (pReturnCode)
+	{
+		*pReturnCode = IFACE_FAILED;
+	}
+	return NULL;	
+}
+
+void* CreateInterface( const char *pName, int *pReturnCode )
+{
+    return CreateInterfaceInternal( pName, pReturnCode );
+}
+
+
+
+#ifdef POSIX
+// Linux doesn't have this function so this emulates its functionality
+void *GetModuleHandle(const char *name)
+{
+	void *handle;
+
+	if( name == NULL )
+	{
+		// hmm, how can this be handled under linux....
+		// is it even needed?
+		return NULL;
+	}
+
+    if( (handle=dlopen(name, RTLD_NOW))==NULL)
+    {
+            printf("DLOPEN Error:%s\n",dlerror());
+            // couldn't open this file
+            return NULL;
+    }
+
+	// read "man dlopen" for details
+	// in short dlopen() inc a ref count
+	// so dec the ref count by performing the close
+	dlclose(handle);
+	return handle;
+}
+#endif
+
+#if defined( _WIN32 ) && !defined( _X360 )
+#define WIN32_LEAN_AND_MEAN
+#include "windows.h"
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: returns a pointer to a function, given a module
+// Input  : pModuleName - module name
+//			*pName - proc name
+//-----------------------------------------------------------------------------
+static void *Sys_GetProcAddress( const char *pModuleName, const char *pName )
+{
+	HMODULE hModule = (HMODULE)GetModuleHandle( pModuleName );
+#ifdef WIN32
+	return (void *)GetProcAddress( hModule, pName );
+#else
+	return (void *)dlsym( (void *)hModule, pName );
+#endif
+}
+
+static void *Sys_GetProcAddress( HMODULE hModule, const char *pName )
+{
+#ifdef WIN32
+	return (void *)GetProcAddress( hModule, pName );
+#else
+	return (void *)dlsym( (void *)hModule, pName );
+#endif
+}
+
+bool Sys_IsDebuggerPresent()
+{
+	return Plat_IsInDebugSession();
+}
+
+struct ThreadedLoadLibaryContext_t
+{
+	const char *m_pLibraryName;
+	HMODULE m_hLibrary;
+};
+
+#ifdef _WIN32
+
+// wraps LoadLibraryEx() since 360 doesn't support that
+static HMODULE InternalLoadLibrary( const char *pName, Sys_Flags flags )
+{
+#if defined(_X360)
+	return LoadLibrary( pName );
+#else
+	if ( flags & SYS_NOLOAD )
+		return GetModuleHandle( pName );
+	else
+		return LoadLibraryEx( pName, NULL, LOAD_WITH_ALTERED_SEARCH_PATH );
+#endif
+}
+unsigned ThreadedLoadLibraryFunc( void *pParam )
+{
+	ThreadedLoadLibaryContext_t *pContext = (ThreadedLoadLibaryContext_t*)pParam;
+	pContext->m_hLibrary = InternalLoadLibrary( pContext->m_pLibraryName, SYS_NOFLAGS );
+	return 0;
+}
+
+#endif // _WIN32
+
+HMODULE Sys_LoadLibrary( const char *pLibraryName, Sys_Flags flags )
+{
+	char str[ 1024 ];
+	// Note: DLL_EXT_STRING can be "_srv.so" or "_360.dll". So be careful
+	//	when using the V_*Extension* routines...
+	const char *pDllStringExtension = V_GetFileExtension( DLL_EXT_STRING );
+	const char *pModuleExtension = pDllStringExtension ? ( pDllStringExtension - 1 ) : DLL_EXT_STRING;
+
+	Q_strncpy( str, pLibraryName, sizeof(str) );
+
+	if ( IsX360() )
+	{
+		// old, probably busted, behavior for xbox
+		if ( !Q_stristr( str, pModuleExtension ) )
+		{
+			V_SetExtension( str, pModuleExtension, sizeof(str) );
+		}
+	}
+	else
+	{
+		// always force the final extension to be .dll
+		V_SetExtension( str, pModuleExtension, sizeof(str) );
+	}
+
+	Q_FixSlashes( str );
+
+#ifdef _WIN32
+	ThreadedLoadLibraryFunc_t threadFunc = GetThreadedLoadLibraryFunc();
+	if ( !threadFunc )
+		return InternalLoadLibrary( str, flags );
+
+	// We shouldn't be passing noload while threaded.
+	Assert( !( flags & SYS_NOLOAD ) );
+
+	ThreadedLoadLibaryContext_t context;
+	context.m_pLibraryName = str;
+	context.m_hLibrary = 0;
+
+	ThreadHandle_t h = CreateSimpleThread( ThreadedLoadLibraryFunc, &context );
+
+#ifdef _X360
+	ThreadSetAffinity( h, XBOX_PROCESSOR_3 );
+#endif
+
+	unsigned int nTimeout = 0;
+	while( ThreadWaitForObject( h, true, nTimeout ) == TW_TIMEOUT )
+	{
+		nTimeout = threadFunc();
+	}
+
+	ReleaseThreadHandle( h );
+	return context.m_hLibrary;
+
+#elif POSIX
+	int dlopen_mode = RTLD_NOW;
+
+	if ( flags & SYS_NOLOAD )
+		dlopen_mode |= RTLD_NOLOAD;
+
+	HMODULE ret = ( HMODULE )dlopen( str, dlopen_mode );
+	if ( !ret && !( flags & SYS_NOLOAD ) )
+	{
+		const char *pError = dlerror();
+		if ( pError && ( strstr( pError, "No such file" ) == 0 ) && ( strstr( pError, "image not found" ) == 0 ) )
+		{
+			Msg( " failed to dlopen %s error=%s\n", str, pError );
+		}
+	}
+	
+	return ret;
+#endif
+}
+static bool s_bRunningWithDebugModules = false;
+
+//-----------------------------------------------------------------------------
+// Purpose: Loads a DLL/component from disk and returns a handle to it
+// Input  : *pModuleName - filename of the component
+// Output : opaque handle to the module (hides system dependency)
+//-----------------------------------------------------------------------------
+CSysModule *Sys_LoadModule( const char *pModuleName, Sys_Flags flags /* = SYS_NOFLAGS (0) */ )
+{
+	// If using the Steam filesystem, either the DLL must be a minimum footprint
+	// file in the depot (MFP) or a filesystem GetLocalCopy() call must be made
+	// prior to the call to this routine.
+	char szCwd[1024];
+	HMODULE hDLL = NULL;
+
+	if ( !Q_IsAbsolutePath( pModuleName ) )
+	{
+		// full path wasn't passed in, using the current working dir
+		_getcwd( szCwd, sizeof( szCwd ) );
+		if ( IsX360() )
+		{
+			int i = CommandLine()->FindParm( "-basedir" );
+			if ( i )
+			{
+				strcpy( szCwd, CommandLine()->GetParm( i+1 ) );
+			}
+		}
+		if (szCwd[strlen(szCwd) - 1] == '/' || szCwd[strlen(szCwd) - 1] == '\\' )
+		{
+			szCwd[strlen(szCwd) - 1] = 0;
+		}
+
+		char szAbsoluteModuleName[1024];
+		size_t cCwd = strlen( szCwd );
+		if ( strstr( pModuleName, "bin/") == pModuleName || ( szCwd[ cCwd - 1 ] == 'n'  && szCwd[ cCwd - 2 ] == 'i' && szCwd[ cCwd - 3 ] == 'b' )  )
+		{
+			// don't make bin/bin path
+			Q_snprintf( szAbsoluteModuleName, sizeof(szAbsoluteModuleName), "%s/%s", szCwd, pModuleName );			
+		}
+		else
+		{
+			Q_snprintf( szAbsoluteModuleName, sizeof(szAbsoluteModuleName), "%s/bin/%s", szCwd, pModuleName );
+		}
+		hDLL = Sys_LoadLibrary( szAbsoluteModuleName, flags );
+	}
+
+	if ( !hDLL )
+	{
+		// full path failed, let LoadLibrary() try to search the PATH now
+		hDLL = Sys_LoadLibrary( pModuleName, flags );
+#if defined( _DEBUG )
+		if ( !hDLL )
+		{
+// So you can see what the error is in the debugger...
+#if defined( _WIN32 ) && !defined( _X360 )
+			char *lpMsgBuf;
+			
+			FormatMessage( 
+				FORMAT_MESSAGE_ALLOCATE_BUFFER | 
+				FORMAT_MESSAGE_FROM_SYSTEM | 
+				FORMAT_MESSAGE_IGNORE_INSERTS,
+				NULL,
+				GetLastError(),
+				MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+				(LPTSTR) &lpMsgBuf,
+				0,
+				NULL 
+			);
+
+			LocalFree( (HLOCAL)lpMsgBuf );
+#elif defined( _X360 )
+			DWORD error = GetLastError();
+			Msg( "Error(%d) - Failed to load %s:\n", error, pModuleName );
+#else
+			Msg( "Failed to load %s: %s\n", pModuleName, dlerror() );
+#endif // _WIN32
+		}
+#endif // DEBUG
+	}
+
+#if !defined(LINUX)
+	// If running in the debugger, assume debug binaries are okay, otherwise they must run with -allowdebug
+	if ( Sys_GetProcAddress( hDLL, "BuiltDebug" ) )
+	{
+		if ( !IsX360() && hDLL && 
+			 !CommandLine()->FindParm( "-allowdebug" ) && 
+			 !Sys_IsDebuggerPresent() )
+		{
+			Error( "Module %s is a debug build\n", pModuleName );
+		}
+
+		DevWarning( "Module %s is a debug build\n", pModuleName );
+
+		if ( !s_bRunningWithDebugModules )
+		{
+			s_bRunningWithDebugModules = true;
+			
+#if 0 //def IS_WINDOWS_PC
+			char chMemoryName[ MAX_PATH ];
+			DebugKernelMemoryObjectName( chMemoryName );
+			
+			(void) CreateFileMapping( INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 1024, chMemoryName );
+			// Created a shared memory kernel object specific to process id
+			// Existence of this object indicates that we have debug modules loaded
+#endif
+		}
+	}
+#endif
+
+	return reinterpret_cast<CSysModule *>(hDLL);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Determine if any debug modules were loaded
+//-----------------------------------------------------------------------------
+bool Sys_RunningWithDebugModules()
+{
+	if ( !s_bRunningWithDebugModules )
+	{
+#if 0 //def IS_WINDOWS_PC
+		char chMemoryName[ MAX_PATH ];
+		DebugKernelMemoryObjectName( chMemoryName );
+
+		HANDLE hObject = OpenFileMapping( FILE_MAP_READ, FALSE, chMemoryName );
+		if ( hObject && hObject != INVALID_HANDLE_VALUE )
+		{
+			CloseHandle( hObject );
+			s_bRunningWithDebugModules = true;
+		}
+#endif
+	}
+	return s_bRunningWithDebugModules;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Unloads a DLL/component from
+// Input  : *pModuleName - filename of the component
+// Output : opaque handle to the module (hides system dependency)
+//-----------------------------------------------------------------------------
+void Sys_UnloadModule( CSysModule *pModule )
+{
+	if ( !pModule )
+		return;
+
+	HMODULE	hDLL = reinterpret_cast<HMODULE>(pModule);
+
+#ifdef _WIN32
+	FreeLibrary( hDLL );
+#elif defined(POSIX)
+	dlclose((void *)hDLL);
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: returns a pointer to a function, given a module
+// Input  : module - windows HMODULE from Sys_LoadModule() 
+//			*pName - proc name
+// Output : factory for this module
+//-----------------------------------------------------------------------------
+CreateInterfaceFn Sys_GetFactory( CSysModule *pModule )
+{
+	if ( !pModule )
+		return NULL;
+
+	HMODULE	hDLL = reinterpret_cast<HMODULE>(pModule);
+#ifdef _WIN32
+	return reinterpret_cast<CreateInterfaceFn>(GetProcAddress( hDLL, CREATEINTERFACE_PROCNAME ));
+#elif defined(POSIX)
+	// Linux gives this error:
+	//../public/interface.cpp: In function `IBaseInterface *(*Sys_GetFactory
+	//(CSysModule *)) (const char *, int *)':
+	//../public/interface.cpp:154: ISO C++ forbids casting between
+	//pointer-to-function and pointer-to-object
+	//
+	// so lets get around it :)
+	return (CreateInterfaceFn)(GetProcAddress( (void *)hDLL, CREATEINTERFACE_PROCNAME ));
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: returns the instance of this module
+// Output : interface_instance_t
+//-----------------------------------------------------------------------------
+CreateInterfaceFn Sys_GetFactoryThis( void )
+{
+	return &CreateInterfaceInternal;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: returns the instance of the named module
+// Input  : *pModuleName - name of the module
+// Output : interface_instance_t - instance of that module
+//-----------------------------------------------------------------------------
+CreateInterfaceFn Sys_GetFactory( const char *pModuleName )
+{
+#ifdef _WIN32
+	return static_cast<CreateInterfaceFn>( Sys_GetProcAddress( pModuleName, CREATEINTERFACE_PROCNAME ) );
+#elif defined(POSIX)
+	// see Sys_GetFactory( CSysModule *pModule ) for an explanation
+	return (CreateInterfaceFn)( Sys_GetProcAddress( pModuleName, CREATEINTERFACE_PROCNAME ) );
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: get the interface for the specified module and version
+// Input  : 
+// Output : 
+//-----------------------------------------------------------------------------
+bool Sys_LoadInterface(
+	const char *pModuleName,
+	const char *pInterfaceVersionName,
+	CSysModule **pOutModule,
+	void **pOutInterface )
+{
+	CSysModule *pMod = Sys_LoadModule( pModuleName );
+	if ( !pMod )
+		return false;
+
+	CreateInterfaceFn fn = Sys_GetFactory( pMod );
+	if ( !fn )
+	{
+		Sys_UnloadModule( pMod );
+		return false;
+	}
+
+	*pOutInterface = fn( pInterfaceVersionName, NULL );
+	if ( !( *pOutInterface ) )
+	{
+		Sys_UnloadModule( pMod );
+		return false;
+	}
+
+	if ( pOutModule )
+		*pOutModule = pMod;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Place this as a singleton at module scope (e.g.) and use it to get the factory from the specified module name.  
+// 
+// When the singleton goes out of scope (.dll unload if at module scope),
+//  then it'll call Sys_UnloadModule on the module so that the refcount is decremented 
+//  and the .dll actually can unload from memory.
+//-----------------------------------------------------------------------------
+CDllDemandLoader::CDllDemandLoader( char const *pchModuleName ) : 
+	m_pchModuleName( pchModuleName ), 
+	m_hModule( 0 ),
+	m_bLoadAttempted( false )
+{
+}
+
+CDllDemandLoader::~CDllDemandLoader()
+{
+	Unload();
+}
+
+CreateInterfaceFn CDllDemandLoader::GetFactory()
+{
+	if ( !m_hModule && !m_bLoadAttempted )
+	{
+		m_bLoadAttempted = true;
+		m_hModule = Sys_LoadModule( m_pchModuleName );
+	}
+
+	if ( !m_hModule )
+	{
+		return NULL;
+	}
+
+	return Sys_GetFactory( m_hModule );
+}
+
+void CDllDemandLoader::Unload()
+{
+	if ( m_hModule )
+	{
+		Sys_UnloadModule( m_hModule );
+		m_hModule = 0;
+	}
+}

mp/src/tier1/kvpacker.cpp

@@ -0,0 +1,274 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Contains a branch-neutral binary packer for KeyValues trees. 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#include <KeyValues.h>
+#include "kvpacker.h"
+
+#include "tier0/dbg.h"
+#include "utlbuffer.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include <tier0/memdbgon.h>
+
+#define KEYVALUES_TOKEN_SIZE	1024
+
+// writes KeyValue as binary data to buffer
+bool KVPacker::WriteAsBinary( KeyValues *pNode, CUtlBuffer &buffer )
+{
+	if ( buffer.IsText() ) // must be a binary buffer
+		return false;
+
+	if ( !buffer.IsValid() ) // must be valid, no overflows etc
+		return false;
+
+	// Write subkeys:
+
+	// loop through all our peers
+	for ( KeyValues *dat = pNode; dat != NULL; dat = dat->GetNextKey() )
+	{
+		// write type
+		switch ( dat->GetDataType() )
+		{
+		case KeyValues::TYPE_NONE:
+			{
+				buffer.PutUnsignedChar( PACKTYPE_NONE );
+				break;
+			}
+		case KeyValues::TYPE_STRING:
+			{
+				buffer.PutUnsignedChar( PACKTYPE_STRING );
+				break;
+			}
+		case KeyValues::TYPE_WSTRING:
+			{
+				buffer.PutUnsignedChar( PACKTYPE_WSTRING );
+				break;
+			}
+
+		case KeyValues::TYPE_INT:
+			{
+				buffer.PutUnsignedChar( PACKTYPE_INT );
+				break;
+			}
+
+		case KeyValues::TYPE_UINT64:
+			{
+				buffer.PutUnsignedChar( PACKTYPE_UINT64 );
+				break;
+			}
+
+		case KeyValues::TYPE_FLOAT:
+			{
+				buffer.PutUnsignedChar( PACKTYPE_FLOAT );
+				break;
+			}
+		case KeyValues::TYPE_COLOR:
+			{
+				buffer.PutUnsignedChar( PACKTYPE_COLOR );
+				break;
+			}
+		case KeyValues::TYPE_PTR:
+			{
+				buffer.PutUnsignedChar( PACKTYPE_PTR );
+				break;
+			}
+
+		default:
+			break;
+		}
+
+		// write name
+		buffer.PutString( dat->GetName() );
+
+		// write value
+		switch ( dat->GetDataType() )
+		{
+		case KeyValues::TYPE_NONE:
+			{
+				if( !WriteAsBinary( dat->GetFirstSubKey(), buffer ) )
+					return false;
+				break;
+			}
+		case KeyValues::TYPE_STRING:
+			{
+				if (dat->GetString() && *(dat->GetString()))
+				{
+					buffer.PutString( dat->GetString() );
+				}
+				else
+				{
+					buffer.PutString( "" );
+				}
+				break;
+			}
+		case KeyValues::TYPE_WSTRING:
+			{
+				int nLength = dat->GetWString() ? Q_wcslen( dat->GetWString() ) : 0;
+				buffer.PutShort( nLength );
+				for( int k = 0; k < nLength; ++ k )
+				{
+					buffer.PutShort( ( unsigned short ) dat->GetWString()[k] );
+				}
+				break;
+			}
+
+		case KeyValues::TYPE_INT:
+			{
+				buffer.PutInt( dat->GetInt() );				
+				break;
+			}
+
+		case KeyValues::TYPE_UINT64:
+			{
+				buffer.PutInt64( dat->GetUint64() );
+				break;
+			}
+
+		case KeyValues::TYPE_FLOAT:
+			{
+				buffer.PutFloat( dat->GetFloat() );
+				break;
+			}
+		case KeyValues::TYPE_COLOR:
+			{
+				Color color = dat->GetColor();
+				buffer.PutUnsignedChar( color[0] );
+				buffer.PutUnsignedChar( color[1] );
+				buffer.PutUnsignedChar( color[2] );
+				buffer.PutUnsignedChar( color[3] );
+				break;
+			}
+		case KeyValues::TYPE_PTR:
+			{
+				buffer.PutUnsignedInt( (int)dat->GetPtr() );
+				break;
+			}
+
+		default:
+			break;
+		}
+	}
+
+	// write tail, marks end of peers
+	buffer.PutUnsignedChar( PACKTYPE_NULLMARKER ); 
+
+	return buffer.IsValid();
+}
+
+// read KeyValues from binary buffer, returns true if parsing was successful
+bool KVPacker::ReadAsBinary( KeyValues *pNode, CUtlBuffer &buffer )
+{
+	if ( buffer.IsText() ) // must be a binary buffer
+		return false;
+
+	if ( !buffer.IsValid() ) // must be valid, no overflows etc
+		return false;
+
+	pNode->Clear();
+
+	char		token[KEYVALUES_TOKEN_SIZE];
+	KeyValues	*dat = pNode;
+	EPackType		ePackType = (EPackType)buffer.GetUnsignedChar();
+
+	// loop through all our peers
+	while ( true )
+	{
+		if ( ePackType == PACKTYPE_NULLMARKER )
+			break; // no more peers
+
+		buffer.GetString( token, KEYVALUES_TOKEN_SIZE-1 );
+		token[KEYVALUES_TOKEN_SIZE-1] = 0;
+
+		dat->SetName( token );
+
+		switch ( ePackType )
+		{
+		case PACKTYPE_NONE:
+			{
+				KeyValues *pNewNode = new KeyValues("");
+				dat->AddSubKey( pNewNode );
+				if( !ReadAsBinary( pNewNode, buffer ) )
+					return false;
+				break;
+			}
+		case PACKTYPE_STRING:
+			{
+				buffer.GetString( token, KEYVALUES_TOKEN_SIZE-1 );
+				token[KEYVALUES_TOKEN_SIZE-1] = 0;
+				dat->SetStringValue( token );
+				break;
+			}
+		case PACKTYPE_WSTRING:
+			{
+				int nLength = buffer.GetShort();
+				wchar_t *pTemp = (wchar_t *)stackalloc( sizeof(wchar_t) * ( 1 + nLength ) );
+
+				for( int k = 0; k < nLength; ++ k )
+				{
+					pTemp[k] = buffer.GetShort();
+				}
+				pTemp[ nLength ] = 0;
+
+				dat->SetWString( NULL, pTemp );
+				break;
+			}
+
+		case PACKTYPE_INT:
+			{
+				dat->SetInt( NULL, buffer.GetInt() );
+				break;
+			}
+
+		case PACKTYPE_UINT64:
+			{
+				dat->SetUint64( NULL, (uint64)buffer.GetInt64() );
+				break;
+			}
+
+		case PACKTYPE_FLOAT:
+			{
+				dat->SetFloat( NULL, buffer.GetFloat() );
+				break;
+			}
+		case PACKTYPE_COLOR:
+			{
+				Color color( 
+					buffer.GetUnsignedChar(),
+					buffer.GetUnsignedChar(),
+					buffer.GetUnsignedChar(),
+					buffer.GetUnsignedChar() );
+				dat->SetColor( NULL, color );
+				break;
+			}
+		case PACKTYPE_PTR:
+			{
+				dat->SetPtr( NULL, (void*)buffer.GetUnsignedInt() );
+				break;
+			}
+
+		default:
+			break;
+		}
+
+		if ( !buffer.IsValid() ) // error occured
+			return false;
+
+		ePackType = (EPackType)buffer.GetUnsignedChar();
+
+		if ( ePackType == PACKTYPE_NULLMARKER )
+			break;
+
+		// new peer follows
+		KeyValues *pNewPeer = new KeyValues("");
+		dat->SetNextKey( pNewPeer );
+		dat = pNewPeer;
+	}
+
+	return buffer.IsValid();
+}
+

mp/src/tier1/mempool.cpp

@@ -0,0 +1,312 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//===========================================================================//
+
+#include "mempool.h"
+#include <stdio.h>
+#include <malloc.h>
+#include <memory.h>
+#include "tier0/dbg.h"
+#include <ctype.h>
+#include "tier1/strtools.h"
+
+// Should be last include
+#include "tier0/memdbgon.h"
+ 
+MemoryPoolReportFunc_t CUtlMemoryPool::g_ReportFunc = 0;
+
+//-----------------------------------------------------------------------------
+// Error reporting...  (debug only)
+//-----------------------------------------------------------------------------
+
+void CUtlMemoryPool::SetErrorReportFunc( MemoryPoolReportFunc_t func )
+{
+	g_ReportFunc = func;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CUtlMemoryPool::CUtlMemoryPool( int blockSize, int numElements, int growMode, const char *pszAllocOwner, int nAlignment )
+{
+#ifdef _X360
+	if( numElements > 0 && growMode != GROW_NONE )
+	{
+		numElements = 1;
+	}
+#endif
+
+	m_nAlignment = ( nAlignment != 0 ) ? nAlignment : 1;
+	Assert( IsPowerOfTwo( m_nAlignment ) );
+	m_BlockSize = blockSize < sizeof(void*) ? sizeof(void*) : blockSize;
+	m_BlockSize = AlignValue( m_BlockSize, m_nAlignment );
+	m_BlocksPerBlob = numElements;
+	m_PeakAlloc = 0;
+	m_GrowMode = growMode;
+	if ( !pszAllocOwner )
+	{
+		pszAllocOwner = __FILE__;
+	}
+	m_pszAllocOwner = pszAllocOwner;
+	Init();
+	AddNewBlob();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Frees the memory contained in the mempool, and invalidates it for
+//			any further use.
+// Input  : *memPool - the mempool to shutdown
+//-----------------------------------------------------------------------------
+CUtlMemoryPool::~CUtlMemoryPool()
+{
+	if (m_BlocksAllocated > 0)
+	{
+		ReportLeaks();
+	}
+	Clear();
+}
+
+
+//-----------------------------------------------------------------------------
+// Resets the pool
+//-----------------------------------------------------------------------------
+void CUtlMemoryPool::Init()
+{
+	m_NumBlobs = 0;
+	m_BlocksAllocated = 0;
+	m_pHeadOfFreeList = 0;
+	m_BlobHead.m_pNext = m_BlobHead.m_pPrev = &m_BlobHead;
+}
+
+
+//-----------------------------------------------------------------------------
+// Frees everything
+//-----------------------------------------------------------------------------
+void CUtlMemoryPool::Clear()
+{
+	// Free everything..
+	CBlob *pNext;
+	for( CBlob *pCur = m_BlobHead.m_pNext; pCur != &m_BlobHead; pCur = pNext )
+	{
+		pNext = pCur->m_pNext;
+		free( pCur );
+	}
+	Init();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Reports memory leaks 
+//-----------------------------------------------------------------------------
+
+void CUtlMemoryPool::ReportLeaks()
+{
+	if (!g_ReportFunc)
+		return;
+
+	g_ReportFunc("Memory leak: mempool blocks left in memory: %d\n", m_BlocksAllocated);
+
+#ifdef _DEBUG
+	// walk and destroy the free list so it doesn't intefere in the scan
+	while (m_pHeadOfFreeList != NULL)
+	{
+		void *next = *((void**)m_pHeadOfFreeList);
+		memset(m_pHeadOfFreeList, 0, m_BlockSize);
+		m_pHeadOfFreeList = next;
+	}
+
+	g_ReportFunc("Dumping memory: \'");
+
+	for( CBlob *pCur=m_BlobHead.m_pNext; pCur != &m_BlobHead; pCur=pCur->m_pNext )
+	{
+		// scan the memory block and dump the leaks
+		char *scanPoint = (char *)pCur->m_Data;
+		char *scanEnd = pCur->m_Data + pCur->m_NumBytes;
+		bool needSpace = false;
+
+		while (scanPoint < scanEnd)
+		{
+			// search for and dump any strings
+			if ((unsigned)(*scanPoint + 1) <= 256 && isprint(*scanPoint))
+			{
+				g_ReportFunc("%c", *scanPoint);
+				needSpace = true;
+			}
+			else if (needSpace)
+			{
+				needSpace = false;
+				g_ReportFunc(" ");
+			}
+
+			scanPoint++;
+		}
+	}
+
+	g_ReportFunc("\'\n");
+#endif // _DEBUG
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CUtlMemoryPool::AddNewBlob()
+{
+	MEM_ALLOC_CREDIT_(m_pszAllocOwner);
+
+	int sizeMultiplier;
+
+	if( m_GrowMode == GROW_SLOW )
+	{
+		sizeMultiplier = 1;
+	}
+	else
+	{
+		if ( m_GrowMode == GROW_NONE )
+		{
+			// Can only have one allocation when we're in this mode
+			if( m_NumBlobs != 0 )
+			{
+				Assert( !"CUtlMemoryPool::AddNewBlob: mode == GROW_NONE" );
+				return;
+			}
+		}
+		
+		// GROW_FAST and GROW_NONE use this.
+		sizeMultiplier = m_NumBlobs + 1;
+	}
+
+	// maybe use something other than malloc?
+	int nElements = m_BlocksPerBlob * sizeMultiplier;
+	int blobSize = m_BlockSize * nElements;
+	CBlob *pBlob = (CBlob*)malloc( sizeof(CBlob) - 1 + blobSize + ( m_nAlignment - 1 ) );
+	Assert( pBlob );
+	
+	// Link it in at the end of the blob list.
+	pBlob->m_NumBytes = blobSize;
+	pBlob->m_pNext = &m_BlobHead;
+	pBlob->m_pPrev = pBlob->m_pNext->m_pPrev;
+	pBlob->m_pNext->m_pPrev = pBlob->m_pPrev->m_pNext = pBlob;
+
+	// setup the free list
+	m_pHeadOfFreeList = AlignValue( pBlob->m_Data, m_nAlignment );
+	Assert (m_pHeadOfFreeList);
+
+	void **newBlob = (void**)m_pHeadOfFreeList;
+	for (int j = 0; j < nElements-1; j++)
+	{
+		newBlob[0] = (char*)newBlob + m_BlockSize;
+		newBlob = (void**)newBlob[0];
+	}
+
+	// null terminate list
+	newBlob[0] = NULL;
+	m_NumBlobs++;
+}
+
+
+void* CUtlMemoryPool::Alloc()
+{
+	return Alloc( m_BlockSize );
+}
+
+
+void* CUtlMemoryPool::AllocZero()
+{
+	return AllocZero( m_BlockSize );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Allocs a single block of memory from the pool.  
+// Input  : amount - 
+//-----------------------------------------------------------------------------
+void *CUtlMemoryPool::Alloc( size_t amount )
+{
+	void *returnBlock;
+
+	if ( amount > (unsigned int)m_BlockSize )
+		return NULL;
+
+	if( !m_pHeadOfFreeList )
+	{
+		// returning NULL is fine in GROW_NONE
+		if( m_GrowMode == GROW_NONE )
+		{
+			//Assert( !"CUtlMemoryPool::Alloc: tried to make new blob with GROW_NONE" );
+			return NULL;
+		}
+
+		// overflow
+		AddNewBlob();
+
+		// still failure, error out
+		if( !m_pHeadOfFreeList )
+		{
+			Assert( !"CUtlMemoryPool::Alloc: ran out of memory" );
+			return NULL;
+		}
+	}
+	m_BlocksAllocated++;
+	m_PeakAlloc = max(m_PeakAlloc, m_BlocksAllocated);
+
+	returnBlock = m_pHeadOfFreeList;
+
+	// move the pointer the next block
+	m_pHeadOfFreeList = *((void**)m_pHeadOfFreeList);
+
+	return returnBlock;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Allocs a single block of memory from the pool, zeroes the memory before returning
+// Input  : amount - 
+//-----------------------------------------------------------------------------
+void *CUtlMemoryPool::AllocZero( size_t amount )
+{
+	void *mem = Alloc( amount );
+	if ( mem )
+	{
+		V_memset( mem, 0x00, amount );
+	}
+	return mem;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Frees a block of memory
+// Input  : *memBlock - the memory to free
+//-----------------------------------------------------------------------------
+void CUtlMemoryPool::Free( void *memBlock )
+{
+	if ( !memBlock )
+		return;  // trying to delete NULL pointer, ignore
+
+#ifdef _DEBUG
+	// check to see if the memory is from the allocated range
+	bool bOK = false;
+	for( CBlob *pCur=m_BlobHead.m_pNext; pCur != &m_BlobHead; pCur=pCur->m_pNext )
+	{
+		if (memBlock >= pCur->m_Data && (char*)memBlock < (pCur->m_Data + pCur->m_NumBytes))
+		{
+			bOK = true;
+		}
+	}
+	Assert (bOK);
+#endif // _DEBUG
+
+#ifdef _DEBUG	
+	// invalidate the memory
+	memset( memBlock, 0xDD, m_BlockSize );
+#endif
+
+	m_BlocksAllocated--;
+
+	// make the block point to the first item in the list
+	*((void**)memBlock) = m_pHeadOfFreeList;
+
+	// the list head is now the new block
+	m_pHeadOfFreeList = memBlock;
+}
+
+

mp/src/tier1/memstack.cpp

@@ -0,0 +1,297 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================//
+
+#if defined( _WIN32 ) && !defined( _X360 )
+#define WIN_32_LEAN_AND_MEAN
+#include <windows.h>
+#define VA_COMMIT_FLAGS MEM_COMMIT
+#define VA_RESERVE_FLAGS MEM_RESERVE
+#elif defined( _X360 )
+#define VA_COMMIT_FLAGS (MEM_COMMIT|MEM_NOZERO|MEM_LARGE_PAGES)
+#define VA_RESERVE_FLAGS (MEM_RESERVE|MEM_LARGE_PAGES)
+#endif
+
+#include "tier0/dbg.h"
+#include "memstack.h"
+#include "utlmap.h"
+#include "tier0/memdbgon.h"
+
+#ifdef _WIN32
+#pragma warning(disable:4073)
+#pragma init_seg(lib)
+#endif
+
+//-----------------------------------------------------------------------------
+
+MEMALLOC_DEFINE_EXTERNAL_TRACKING(CMemoryStack);
+
+//-----------------------------------------------------------------------------
+
+CMemoryStack::CMemoryStack()
+ : 	m_pBase( NULL ),
+	m_pNextAlloc( NULL ),
+	m_pAllocLimit( NULL ),
+	m_pCommitLimit( NULL ),
+	m_alignment( 16 ),
+#if defined(_WIN32)
+ 	m_commitSize( 0 ),
+	m_minCommit( 0 ),
+#endif
+ 	m_maxSize( 0 )
+{
+}
+	
+//-------------------------------------
+
+CMemoryStack::~CMemoryStack()
+{
+	if ( m_pBase )
+		Term();
+}
+
+//-------------------------------------
+
+bool CMemoryStack::Init( unsigned maxSize, unsigned commitSize, unsigned initialCommit, unsigned alignment )
+{
+	Assert( !m_pBase );
+
+#ifdef _X360
+	m_bPhysical = false;
+#endif
+
+	m_maxSize = maxSize;
+	m_alignment = AlignValue( alignment, 4 );
+
+	Assert( m_alignment == alignment );
+	Assert( m_maxSize > 0 );
+
+#if defined(_WIN32)
+	if ( commitSize != 0 )
+	{
+		m_commitSize = commitSize;
+	}
+
+	unsigned pageSize;
+
+#ifndef _X360
+	SYSTEM_INFO sysInfo;
+	GetSystemInfo( &sysInfo );
+	Assert( !( sysInfo.dwPageSize & (sysInfo.dwPageSize-1)) );
+	pageSize = sysInfo.dwPageSize;
+#else
+	pageSize = 64*1024;
+#endif
+
+	if ( m_commitSize == 0 )
+	{
+		m_commitSize = pageSize;
+	}
+	else
+	{
+		m_commitSize = AlignValue( m_commitSize, pageSize );
+	}
+
+	m_maxSize = AlignValue( m_maxSize, m_commitSize );
+	
+	Assert( m_maxSize % pageSize == 0 && m_commitSize % pageSize == 0 && m_commitSize <= m_maxSize );
+
+	m_pBase = (unsigned char *)VirtualAlloc( NULL, m_maxSize, VA_RESERVE_FLAGS, PAGE_NOACCESS );
+	Assert( m_pBase );
+	m_pCommitLimit = m_pNextAlloc = m_pBase;
+
+	if ( initialCommit )
+	{
+		initialCommit = AlignValue( initialCommit, m_commitSize );
+		Assert( initialCommit < m_maxSize );
+		if ( !VirtualAlloc( m_pCommitLimit, initialCommit, VA_COMMIT_FLAGS, PAGE_READWRITE ) )
+			return false;
+		m_minCommit = initialCommit;
+		m_pCommitLimit += initialCommit;
+		MemAlloc_RegisterExternalAllocation( CMemoryStack, GetBase(), GetSize() );
+	}
+
+#else
+	m_pBase = (byte *)MemAlloc_AllocAligned( m_maxSize, alignment ? alignment : 1 );
+	m_pNextAlloc = m_pBase;
+	m_pCommitLimit = m_pBase + m_maxSize;
+#endif
+
+	m_pAllocLimit = m_pBase + m_maxSize;
+
+	return ( m_pBase != NULL );
+}
+
+//-------------------------------------
+
+#ifdef _X360
+bool CMemoryStack::InitPhysical( unsigned size, unsigned alignment )
+{
+	m_bPhysical = true;
+
+	m_maxSize = m_commitSize = size;
+	m_alignment = AlignValue( alignment, 4 );
+
+	int flags = PAGE_READWRITE;
+	if ( size >= 16*1024*1024 )
+	{
+		flags |= MEM_16MB_PAGES;
+	}
+	else
+	{
+		flags |= MEM_LARGE_PAGES;
+	}
+	m_pBase = (unsigned char *)XPhysicalAlloc( m_maxSize, MAXULONG_PTR, 4096, flags );
+	Assert( m_pBase );
+	m_pNextAlloc = m_pBase;
+	m_pCommitLimit = m_pBase + m_maxSize;
+	m_pAllocLimit = m_pBase + m_maxSize;
+
+	MemAlloc_RegisterExternalAllocation( CMemoryStack, GetBase(), GetSize() );
+	return ( m_pBase != NULL );
+}
+#endif
+
+//-------------------------------------
+
+void CMemoryStack::Term()
+{
+	FreeAll();
+	if ( m_pBase )
+	{
+#if defined(_WIN32)
+		VirtualFree( m_pBase, 0, MEM_RELEASE );
+#else
+		MemAlloc_FreeAligned( m_pBase );
+#endif
+		m_pBase = NULL;
+	}
+}
+
+//-------------------------------------
+
+int CMemoryStack::GetSize()
+{ 
+#ifdef _WIN32
+	return m_pCommitLimit - m_pBase; 
+#else
+	return m_maxSize;
+#endif
+}
+
+
+//-------------------------------------
+
+bool CMemoryStack::CommitTo( byte *pNextAlloc ) RESTRICT
+{
+#ifdef _X360
+	if ( m_bPhysical )
+	{
+		return NULL;
+	}
+#endif
+#if defined(_WIN32)
+	unsigned char *	pNewCommitLimit = AlignValue( pNextAlloc, m_commitSize );
+	unsigned 		commitSize 		= pNewCommitLimit - m_pCommitLimit;
+	
+	if ( GetSize() )
+		MemAlloc_RegisterExternalDeallocation( CMemoryStack, GetBase(), GetSize() );
+
+	if( m_pCommitLimit + commitSize > m_pAllocLimit )
+	{
+		return false;
+	}
+
+	if ( !VirtualAlloc( m_pCommitLimit, commitSize, VA_COMMIT_FLAGS, PAGE_READWRITE ) )
+	{
+		Assert( 0 );
+		return false;
+	}
+	m_pCommitLimit = pNewCommitLimit;
+
+	if ( GetSize() )
+		MemAlloc_RegisterExternalAllocation( CMemoryStack, GetBase(), GetSize() );
+	return true;
+#else
+	Assert( 0 );
+	return false;
+#endif
+}
+
+//-------------------------------------
+
+void CMemoryStack::FreeToAllocPoint( MemoryStackMark_t mark, bool bDecommit )
+{
+	void *pAllocPoint = m_pBase + mark;
+	Assert( pAllocPoint >= m_pBase && pAllocPoint <= m_pNextAlloc );
+	
+	if ( pAllocPoint >= m_pBase && pAllocPoint < m_pNextAlloc )
+	{
+		if ( bDecommit )
+		{
+#if defined(_WIN32)
+			unsigned char *pDecommitPoint = AlignValue( (unsigned char *)pAllocPoint, m_commitSize );
+
+			if ( pDecommitPoint < m_pBase + m_minCommit )
+			{
+				pDecommitPoint = m_pBase + m_minCommit;
+			}
+
+			unsigned decommitSize = m_pCommitLimit - pDecommitPoint;
+
+			if ( decommitSize > 0 )
+			{
+				MemAlloc_RegisterExternalDeallocation( CMemoryStack, GetBase(), GetSize() );
+
+				VirtualFree( pDecommitPoint, decommitSize, MEM_DECOMMIT );
+				m_pCommitLimit = pDecommitPoint;
+
+				if ( mark > 0 )
+				{
+					MemAlloc_RegisterExternalAllocation( CMemoryStack, GetBase(), GetSize() );
+				}
+			}
+#endif
+		}
+		m_pNextAlloc = (unsigned char *)pAllocPoint;
+	}
+}
+
+//-------------------------------------
+
+void CMemoryStack::FreeAll( bool bDecommit )
+{
+	if ( m_pBase && m_pCommitLimit - m_pBase > 0 )
+	{
+		if ( bDecommit )
+		{
+#if defined(_WIN32)
+			MemAlloc_RegisterExternalDeallocation( CMemoryStack, GetBase(), GetSize() );
+
+			VirtualFree( m_pBase, m_pCommitLimit - m_pBase, MEM_DECOMMIT );
+			m_pCommitLimit = m_pBase;
+#endif
+		}
+		m_pNextAlloc = m_pBase;
+	}
+}
+
+//-------------------------------------
+
+void CMemoryStack::Access( void **ppRegion, unsigned *pBytes )
+{
+	*ppRegion = m_pBase;
+	*pBytes = ( m_pNextAlloc - m_pBase);
+}
+
+//-------------------------------------
+
+void CMemoryStack::PrintContents()
+{
+	Msg( "Total used memory:      %d\n", GetUsed() );
+	Msg( "Total committed memory: %d\n", GetSize() );
+}
+
+//-----------------------------------------------------------------------------

mp/src/tier1/newbitbuf.cpp

@@ -0,0 +1,717 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#include "bitbuf.h"
+#include "coordsize.h"
+#include "mathlib/vector.h"
+#include "mathlib/mathlib.h"
+#include "tier1/strtools.h"
+#include "bitvec.h"
+
+// FIXME: Can't use this until we get multithreaded allocations in tier0 working for tools
+// This is used by VVIS and fails to link
+// NOTE: This must be the last file included!!!
+//#include "tier0/memdbgon.h"
+
+#ifdef _X360
+// mandatory ... wary of above comment and isolating, tier0 is built as MT though
+#include "tier0/memdbgon.h"
+#endif
+
+#include "stdio.h"
+
+#if 0
+
+void CBitWrite::StartWriting( void *pData, int nBytes, int iStartBit, int nBits )
+{
+	// Make sure it's dword aligned and padded.
+	Assert( (nBytes % 4) == 0 );
+	Assert(((unsigned long)pData & 3) == 0);
+	Assert( iStartBit == 0 );
+	m_pData = (uint32 *) pData;
+	m_pDataOut = m_pData;
+	m_nDataBytes = nBytes;
+
+	if ( nBits == -1 )
+	{
+		m_nDataBits = nBytes << 3;
+	}
+	else
+	{
+		Assert( nBits <= nBytes*8 );
+		m_nDataBits = nBits;
+	}
+	m_bOverflow = false;
+	m_nOutBufWord = 0;
+	m_nOutBitsAvail = 32;
+	m_pBufferEnd = m_pDataOut + ( nBytes >> 2 );
+}
+
+const uint32 CBitBuffer::s_nMaskTable[33] = {
+	0,
+	( 1 << 1 ) - 1,
+	( 1 << 2 ) - 1,
+	( 1 << 3 ) - 1,
+	( 1 << 4 ) - 1,
+	( 1 << 5 ) - 1,
+	( 1 << 6 ) - 1,
+	( 1 << 7 ) - 1,
+	( 1 << 8 ) - 1,
+	( 1 << 9 ) - 1,
+	( 1 << 10 ) - 1,
+	( 1 << 11 ) - 1,
+	( 1 << 12 ) - 1,
+	( 1 << 13 ) - 1,
+	( 1 << 14 ) - 1,
+	( 1 << 15 ) - 1,
+	( 1 << 16 ) - 1,
+	( 1 << 17 ) - 1,
+	( 1 << 18 ) - 1,
+	( 1 << 19 ) - 1,
+   	( 1 << 20 ) - 1,
+	( 1 << 21 ) - 1,
+	( 1 << 22 ) - 1,
+	( 1 << 23 ) - 1,
+	( 1 << 24 ) - 1,
+	( 1 << 25 ) - 1,
+	( 1 << 26 ) - 1,
+   	( 1 << 27 ) - 1,
+	( 1 << 28 ) - 1,
+	( 1 << 29 ) - 1,
+	( 1 << 30 ) - 1,
+	0x7fffffff,
+	0xffffffff,
+};
+
+bool CBitWrite::WriteString( const char *pStr )
+{
+	if(pStr)
+	{
+		while( *pStr )
+		{
+			WriteChar( * ( pStr++ ) );
+		}
+	}
+	WriteChar( 0 );
+	return !IsOverflowed();
+}
+
+			 
+void CBitWrite::WriteLongLong(int64 val)
+{
+	uint *pLongs = (uint*)&val;
+
+	// Insert the two DWORDS according to network endian
+	const short endianIndex = 0x0100;
+	byte *idx = (byte*)&endianIndex;
+	WriteUBitLong(pLongs[*idx++], sizeof(long) << 3);
+	WriteUBitLong(pLongs[*idx], sizeof(long) << 3);
+}
+
+bool CBitWrite::WriteBits(const void *pInData, int nBits)
+{
+	unsigned char *pOut = (unsigned char*)pInData;
+	int nBitsLeft = nBits;
+
+	// Bounds checking..
+	if ( ( GetNumBitsWritten() + nBits) > m_nDataBits )
+	{
+		SetOverflowFlag();
+		CallErrorHandler( BITBUFERROR_BUFFER_OVERRUN, m_pDebugName );
+		return false;
+	}
+
+	// !! speed!! need fast paths
+	// write remaining bytes
+	while ( nBitsLeft >= 8 )
+	{
+		WriteUBitLong( *pOut, 8, false );
+		++pOut;
+		nBitsLeft -= 8;
+	}
+	
+	// write remaining bits
+	if ( nBitsLeft )
+	{
+		WriteUBitLong( *pOut, nBitsLeft, false );
+	}
+
+	return !IsOverflowed();
+}
+
+void CBitWrite::WriteBytes( const void *pBuf, int nBytes )
+{
+	WriteBits(pBuf, nBytes << 3);
+}
+
+void CBitWrite::WriteBitCoord (const float f)
+{
+	int		signbit = (f <= -COORD_RESOLUTION);
+	int		intval = (int)abs(f);
+	int		fractval = abs((int)(f*COORD_DENOMINATOR)) & (COORD_DENOMINATOR-1);
+
+
+	// Send the bit flags that indicate whether we have an integer part and/or a fraction part.
+	WriteOneBit( intval );
+	WriteOneBit( fractval );
+
+	if ( intval || fractval )
+	{
+		// Send the sign bit
+		WriteOneBit( signbit );
+
+		// Send the integer if we have one.
+		if ( intval )
+		{
+			// Adjust the integers from [1..MAX_COORD_VALUE] to [0..MAX_COORD_VALUE-1]
+			intval--;
+			WriteUBitLong( (unsigned int)intval, COORD_INTEGER_BITS );
+		}
+		
+		// Send the fraction if we have one
+		if ( fractval )
+		{
+			WriteUBitLong( (unsigned int)fractval, COORD_FRACTIONAL_BITS );
+		}
+	}
+}
+
+void CBitWrite::WriteBitCoordMP (const float f, bool bIntegral, bool bLowPrecision )
+{
+	int		signbit = (f <= -( bLowPrecision ? COORD_RESOLUTION_LOWPRECISION : COORD_RESOLUTION ));
+	int		intval = (int)abs(f);
+	int		fractval = bLowPrecision ? 
+		( abs((int)(f*COORD_DENOMINATOR_LOWPRECISION)) & (COORD_DENOMINATOR_LOWPRECISION-1) ) :
+		( abs((int)(f*COORD_DENOMINATOR)) & (COORD_DENOMINATOR-1) );
+
+	bool    bInBounds = intval < (1 << COORD_INTEGER_BITS_MP );
+
+	WriteOneBit( bInBounds );
+
+	if ( bIntegral )
+	{
+		// Send the sign bit
+		WriteOneBit( intval );
+		if ( intval )
+		{
+			WriteOneBit( signbit );
+			// Send the integer if we have one.
+			// Adjust the integers from [1..MAX_COORD_VALUE] to [0..MAX_COORD_VALUE-1]
+			intval--;
+			if ( bInBounds )
+			{
+				WriteUBitLong( (unsigned int)intval, COORD_INTEGER_BITS_MP );
+			}
+			else
+			{
+				WriteUBitLong( (unsigned int)intval, COORD_INTEGER_BITS );
+			}
+		}
+	}
+	else
+	{
+		// Send the bit flags that indicate whether we have an integer part and/or a fraction part.
+		WriteOneBit( intval );
+		// Send the sign bit
+		WriteOneBit( signbit );
+
+		// Send the integer if we have one.
+		if ( intval )
+		{
+			// Adjust the integers from [1..MAX_COORD_VALUE] to [0..MAX_COORD_VALUE-1]
+			intval--;
+			if ( bInBounds )
+			{
+				WriteUBitLong( (unsigned int)intval, COORD_INTEGER_BITS_MP );
+			}
+			else
+			{
+				WriteUBitLong( (unsigned int)intval, COORD_INTEGER_BITS );
+			}
+		}
+		WriteUBitLong( (unsigned int)fractval, bLowPrecision ? COORD_FRACTIONAL_BITS_MP_LOWPRECISION : COORD_FRACTIONAL_BITS );
+	}
+}
+
+void CBitWrite::SeekToBit( int nBit )
+{
+	TempFlush();
+	m_pDataOut = m_pData + ( nBit / 32 );
+	m_nOutBufWord = *( m_pDataOut );
+	m_nOutBitsAvail = 32 - ( nBit & 31 );
+}
+
+
+
+void CBitWrite::WriteBitVec3Coord( const Vector& fa )
+{
+	int		xflag, yflag, zflag;
+
+	xflag = (fa[0] >= COORD_RESOLUTION) || (fa[0] <= -COORD_RESOLUTION);
+	yflag = (fa[1] >= COORD_RESOLUTION) || (fa[1] <= -COORD_RESOLUTION);
+	zflag = (fa[2] >= COORD_RESOLUTION) || (fa[2] <= -COORD_RESOLUTION);
+
+	WriteOneBit( xflag );
+	WriteOneBit( yflag );
+	WriteOneBit( zflag );
+
+	if ( xflag )
+		WriteBitCoord( fa[0] );
+	if ( yflag )
+		WriteBitCoord( fa[1] );
+	if ( zflag )
+		WriteBitCoord( fa[2] );
+}
+
+void CBitWrite::WriteBitNormal( float f )
+{
+	int	signbit = (f <= -NORMAL_RESOLUTION);
+
+	// NOTE: Since +/-1 are valid values for a normal, I'm going to encode that as all ones
+	unsigned int fractval = abs( (int)(f*NORMAL_DENOMINATOR) );
+
+	// clamp..
+	if (fractval > NORMAL_DENOMINATOR)
+		fractval = NORMAL_DENOMINATOR;
+
+	// Send the sign bit
+	WriteOneBit( signbit );
+
+	// Send the fractional component
+	WriteUBitLong( fractval, NORMAL_FRACTIONAL_BITS );
+}
+
+void CBitWrite::WriteBitVec3Normal( const Vector& fa )
+{
+	int		xflag, yflag;
+
+	xflag = (fa[0] >= NORMAL_RESOLUTION) || (fa[0] <= -NORMAL_RESOLUTION);
+	yflag = (fa[1] >= NORMAL_RESOLUTION) || (fa[1] <= -NORMAL_RESOLUTION);
+
+	WriteOneBit( xflag );
+	WriteOneBit( yflag );
+
+	if ( xflag )
+		WriteBitNormal( fa[0] );
+	if ( yflag )
+		WriteBitNormal( fa[1] );
+	
+	// Write z sign bit
+	int	signbit = (fa[2] <= -NORMAL_RESOLUTION);
+	WriteOneBit( signbit );
+}
+
+void CBitWrite::WriteBitAngle( float fAngle, int numbits )
+{
+
+	unsigned int shift = GetBitForBitnum(numbits);
+	unsigned int mask = shift - 1;
+
+	int d = (int)( (fAngle / 360.0) * shift );
+	d &= mask;
+
+	WriteUBitLong((unsigned int)d, numbits);
+}
+
+bool CBitWrite::WriteBitsFromBuffer( bf_read *pIn, int nBits )
+{
+// This could be optimized a little by
+	while ( nBits > 32 )
+	{
+		WriteUBitLong( pIn->ReadUBitLong( 32 ), 32 );
+		nBits -= 32;
+	}
+
+	WriteUBitLong( pIn->ReadUBitLong( nBits ), nBits );
+	return !IsOverflowed() && !pIn->IsOverflowed();
+}
+
+void CBitWrite::WriteBitAngles( const QAngle& fa )
+{
+	// FIXME:
+	Vector tmp( fa.x, fa.y, fa.z );
+	WriteBitVec3Coord( tmp );
+}
+
+bool CBitRead::Seek( int nPosition )
+{
+	bool bSucc = true;
+	if ( nPosition < 0 || nPosition > m_nDataBits)
+	{
+		SetOverflowFlag();
+		bSucc = false;
+		nPosition = m_nDataBits;
+	}
+	int nHead = m_nDataBytes & 3;							// non-multiple-of-4 bytes at head of buffer. We put the "round off"
+															// at the head to make reading and detecting the end efficient.
+	
+	int nByteOfs = nPosition / 8;
+	if ( ( m_nDataBytes < 4 ) || ( nHead && ( nByteOfs < nHead ) ) )
+	{
+		// partial first dword
+		uint8 const *pPartial = ( uint8 const *) m_pData;
+		if ( m_pData )
+		{
+			m_nInBufWord = *( pPartial++ );
+			if ( nHead > 1 )
+				m_nInBufWord |= ( *pPartial++ )  << 8;
+			if ( nHead > 2 )
+				m_nInBufWord |= ( *pPartial++ ) << 16;
+		}
+		m_pDataIn = ( uint32 const * ) pPartial;
+		m_nInBufWord >>= ( nPosition & 31 );
+		m_nBitsAvail = ( nHead << 3 ) - ( nPosition & 31 );
+	}
+	else
+	{
+		int nAdjPosition = nPosition - ( nHead << 3 );
+		m_pDataIn = reinterpret_cast<uint32 const *> (
+			reinterpret_cast<uint8 const *>( m_pData ) + ( ( nAdjPosition / 32 ) << 2 ) + nHead );
+		if ( m_pData )
+		{
+			m_nBitsAvail = 32;
+			GrabNextDWord();
+		}
+		else
+		{
+			m_nInBufWord = 0;
+			m_nBitsAvail = 1;
+		}
+		m_nInBufWord >>= ( nAdjPosition & 31 );
+		m_nBitsAvail = min( m_nBitsAvail, 32 - ( nAdjPosition & 31 ) );	// in case grabnextdword overflowed
+	}
+	return bSucc;
+}
+
+
+void CBitRead::StartReading( const void *pData, int nBytes, int iStartBit, int nBits )
+{
+// Make sure it's dword aligned and padded.
+	Assert(((unsigned long)pData & 3) == 0);
+	m_pData = (uint32 *) pData;
+	m_pDataIn = m_pData;
+	m_nDataBytes = nBytes;
+
+	if ( nBits == -1 )
+	{
+		m_nDataBits = nBytes << 3;
+	}
+	else
+	{
+		Assert( nBits <= nBytes*8 );
+		m_nDataBits = nBits;
+	}
+	m_bOverflow = false;
+	m_pBufferEnd = reinterpret_cast<uint32 const *> ( reinterpret_cast< uint8 const *> (m_pData) + nBytes );
+	if ( m_pData )
+		Seek( iStartBit ); 
+	
+}
+
+bool CBitRead::ReadString( char *pStr, int maxLen, bool bLine, int *pOutNumChars )
+{
+	Assert( maxLen != 0 );
+
+	bool bTooSmall = false;
+	int iChar = 0;
+	while(1)
+	{
+		char val = ReadChar();
+		if ( val == 0 )
+			break;
+		else if ( bLine && val == '\n' )
+			break;
+
+		if ( iChar < (maxLen-1) )
+		{
+			pStr[iChar] = val;
+			++iChar;
+		}
+		else
+		{
+			bTooSmall = true;
+		}
+	}
+
+	// Make sure it's null-terminated.
+	Assert( iChar < maxLen );
+	pStr[iChar] = 0;
+
+	if ( pOutNumChars )
+		*pOutNumChars = iChar;
+
+	return !IsOverflowed() && !bTooSmall;
+}
+
+char* CBitRead::ReadAndAllocateString( bool *pOverflow )
+{
+	char str[2048];
+	
+	int nChars;
+	bool bOverflow = !ReadString( str, sizeof( str ), false, &nChars );
+	if ( pOverflow )
+		*pOverflow = bOverflow;
+
+	// Now copy into the output and return it;
+	char *pRet = new char[ nChars + 1 ];
+	for ( int i=0; i <= nChars; i++ )
+		pRet[i] = str[i];
+
+	return pRet;
+}
+
+int64 CBitRead::ReadLongLong( void )
+{
+	int64 retval;
+	uint *pLongs = (uint*)&retval;
+
+	// Read the two DWORDs according to network endian
+	const short endianIndex = 0x0100;
+	byte *idx = (byte*)&endianIndex;
+	pLongs[*idx++] = ReadUBitLong(sizeof(long) << 3);
+	pLongs[*idx] = ReadUBitLong(sizeof(long) << 3);
+	return retval;
+}
+
+void CBitRead::ReadBits(void *pOutData, int nBits)
+{
+	unsigned char *pOut = (unsigned char*)pOutData;
+	int nBitsLeft = nBits;
+
+	
+	// align output to dword boundary
+	while( ((unsigned long)pOut & 3) != 0 && nBitsLeft >= 8 )
+	{
+		*pOut = (unsigned char)ReadUBitLong(8);
+		++pOut;
+		nBitsLeft -= 8;
+	}
+
+	// X360TBD: Can't read dwords in ReadBits because they'll get swapped
+	if ( IsPC() )
+	{
+		// read dwords
+		while ( nBitsLeft >= 32 )
+		{
+			*((unsigned long*)pOut) = ReadUBitLong(32);
+			pOut += sizeof(unsigned long);
+			nBitsLeft -= 32;
+		}
+	}
+
+	// read remaining bytes
+	while ( nBitsLeft >= 8 )
+	{
+		*pOut = ReadUBitLong(8);
+		++pOut;
+		nBitsLeft -= 8;
+	}
+	
+	// read remaining bits
+	if ( nBitsLeft )
+	{
+		*pOut = ReadUBitLong(nBitsLeft);
+	}
+
+}
+
+bool CBitRead::ReadBytes(void *pOut, int nBytes)
+{
+	ReadBits(pOut, nBytes << 3);
+	return !IsOverflowed();
+}
+
+float CBitRead::ReadBitAngle( int numbits )
+{
+	float shift = (float)( GetBitForBitnum(numbits) );
+
+	int i = ReadUBitLong( numbits );
+	float fReturn = (float)i * (360.0 / shift);
+
+	return fReturn;
+}
+
+// Basic Coordinate Routines (these contain bit-field size AND fixed point scaling constants)
+float CBitRead::ReadBitCoord (void)
+{
+	int		intval=0,fractval=0,signbit=0;
+	float	value = 0.0;
+
+
+	// Read the required integer and fraction flags
+	intval = ReadOneBit();
+	fractval = ReadOneBit();
+
+	// If we got either parse them, otherwise it's a zero.
+	if ( intval || fractval )
+	{
+		// Read the sign bit
+		signbit = ReadOneBit();
+
+		// If there's an integer, read it in
+		if ( intval )
+		{
+			// Adjust the integers from [0..MAX_COORD_VALUE-1] to [1..MAX_COORD_VALUE]
+			intval = ReadUBitLong( COORD_INTEGER_BITS ) + 1;
+		}
+
+		// If there's a fraction, read it in
+		if ( fractval )
+		{
+			fractval = ReadUBitLong( COORD_FRACTIONAL_BITS );
+		}
+
+		// Calculate the correct floating point value
+		value = intval + ((float)fractval * COORD_RESOLUTION);
+
+		// Fixup the sign if negative.
+		if ( signbit )
+			value = -value;
+	}
+
+	return value;
+}
+
+float CBitRead::ReadBitCoordMP( bool bIntegral, bool bLowPrecision )
+{
+	int		intval=0,fractval=0,signbit=0;
+	float	value = 0.0;
+
+	bool bInBounds = ReadOneBit() ? true : false;
+
+	if ( bIntegral )
+	{
+		// Read the required integer and fraction flags
+		intval = ReadOneBit();
+		// If we got either parse them, otherwise it's a zero.
+		if ( intval )
+		{
+			// Read the sign bit
+			signbit = ReadOneBit();
+
+			// If there's an integer, read it in
+			// Adjust the integers from [0..MAX_COORD_VALUE-1] to [1..MAX_COORD_VALUE]
+			if ( bInBounds )
+			{
+				value = ReadUBitLong( COORD_INTEGER_BITS_MP ) + 1;
+			}
+			else
+			{
+				value = ReadUBitLong( COORD_INTEGER_BITS ) + 1;
+			}
+		}
+	}
+	else
+	{
+		// Read the required integer and fraction flags
+		intval = ReadOneBit();
+
+		// Read the sign bit
+		signbit = ReadOneBit();
+
+		// If we got either parse them, otherwise it's a zero.
+		if ( intval )
+		{
+			if ( bInBounds )
+			{
+				intval = ReadUBitLong( COORD_INTEGER_BITS_MP ) + 1;
+			}
+			else
+			{
+				intval = ReadUBitLong( COORD_INTEGER_BITS ) + 1;
+			}
+		}
+
+		// If there's a fraction, read it in
+		fractval = ReadUBitLong( bLowPrecision ? COORD_FRACTIONAL_BITS_MP_LOWPRECISION : COORD_FRACTIONAL_BITS );
+
+		// Calculate the correct floating point value
+		value = intval + ((float)fractval * ( bLowPrecision ? COORD_RESOLUTION_LOWPRECISION : COORD_RESOLUTION ) );
+	}
+
+	// Fixup the sign if negative.
+	if ( signbit )
+		value = -value;
+
+	return value;
+}
+
+void CBitRead::ReadBitVec3Coord( Vector& fa )
+{
+	int		xflag, yflag, zflag;
+
+	// This vector must be initialized! Otherwise, If any of the flags aren't set, 
+	// the corresponding component will not be read and will be stack garbage.
+	fa.Init( 0, 0, 0 );
+
+	xflag = ReadOneBit();
+	yflag = ReadOneBit(); 
+	zflag = ReadOneBit();
+
+	if ( xflag )
+		fa[0] = ReadBitCoord();
+	if ( yflag )
+		fa[1] = ReadBitCoord();
+	if ( zflag )
+		fa[2] = ReadBitCoord();
+}
+
+float CBitRead::ReadBitNormal (void)
+{
+	// Read the sign bit
+	int	signbit = ReadOneBit();
+
+	// Read the fractional part
+	unsigned int fractval = ReadUBitLong( NORMAL_FRACTIONAL_BITS );
+
+	// Calculate the correct floating point value
+	float value = (float)fractval * NORMAL_RESOLUTION;
+
+	// Fixup the sign if negative.
+	if ( signbit )
+		value = -value;
+
+	return value;
+}
+
+void CBitRead::ReadBitVec3Normal( Vector& fa )
+{
+	int xflag = ReadOneBit();
+	int yflag = ReadOneBit(); 
+
+	if (xflag)
+		fa[0] = ReadBitNormal();
+	else
+		fa[0] = 0.0f;
+
+	if (yflag)
+		fa[1] = ReadBitNormal();
+	else
+		fa[1] = 0.0f;
+
+	// The first two imply the third (but not its sign)
+	int znegative = ReadOneBit();
+
+	float fafafbfb = fa[0] * fa[0] + fa[1] * fa[1];
+	if (fafafbfb < 1.0f)
+		fa[2] = sqrt( 1.0f - fafafbfb );
+	else
+		fa[2] = 0.0f;
+
+	if (znegative)
+		fa[2] = -fa[2];
+}
+
+void CBitRead::ReadBitAngles( QAngle& fa )
+{
+	Vector tmp;
+	ReadBitVec3Coord( tmp );
+	fa.Init( tmp.x, tmp.y, tmp.z );
+}
+
+#endif

mp/src/tier1/pathmatch.cpp

@@ -0,0 +1,906 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Utility to interrogate and modify the data in the OSX IPC Server
+//
+// $NoKeywords: $
+//=============================================================================
+// README:README
+//
+// This file implements the --wrap for ld on linux that lets file i/o api's
+// behave as if it were running on a case insensitive file system.  Unfortunately,
+// this is needed by both steam2 and steam3.  It was decided to check the source
+// into both locations, otherwise someone would find the .o and have no idea
+// where to go for the source if it was in the 'other' tree.  Also, because this
+// needs to be linked into every elf binary, the .o is checked in for Steam3 so that it is
+// always available.  In Steam2 it sits with the PosixWin32.cpp implementation and gets
+// compiled along side of it through the make system.  If you are reading this in Steam3,
+// you will probably want to actually make your changes in steam2 and do a baseless merge
+// to the steam3 copy.
+//
+// HOWTO: Add a new function.  Add the function with _WRAP to the makefiles as noted below.
+// Add the implementation to pathmatch.cpp - probably mimicking the existing functions.
+// Build steam2 and copy to matching steam3/client.  Take the pathmatch.o from steam 2
+// and check it in to steam3 (in the location noted below).  Full rebuild (re-link really)
+// of steam3.  Test steam and check in.
+//
+// If you are looking at updating this file, please update the following as needed:
+//
+// STEAM2.../Projects/GazelleProto/Client/Engine/obj/RELEASE_NORMAL/libsteam_linux/Common/Misc/pathmatch.o
+//          This is where steam2 builds the pathmatch.o out to.
+//
+// STEAM2.../Projects/GazelleProto/Makefile.shlib.base - contains _WRAP references
+// STEAM2.../Projects/Common/Misc/pathmatch.cpp - Where the source is checked in, keep in sync with:
+// STEAM3.../src/common/pathmatch.cpp - should be identical to previous file, but discoverable in steam3.
+// STEAM3.../src/lib/linux32/release/pathmatch.o - steam3 checked in version
+// STEAM3.../src/devtools/makefile_base_posix.mak - look for the _WRAP references
+
+#ifdef LINUX
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <strings.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <errno.h>
+#include <signal.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/mount.h>
+#include <fcntl.h>
+#include <utime.h>
+#include <map>
+#include <string>
+#include <time.h>
+
+// Enable to do pathmatch caching. Beware: this code isn't threadsafe.
+// #define DO_PATHMATCH_CACHE
+
+#ifdef UTF8_PATHMATCH
+#define strcasecmp utf8casecmp
+#endif
+
+static bool s_bShowDiag;
+#define DEBUG_MSG( ... ) if ( s_bShowDiag ) fprintf( stderr, ##__VA_ARGS__ )
+#define DEBUG_BREAK() __asm__ __volatile__ ( "int $3" )
+#define _COMPILE_TIME_ASSERT(pred) switch(0){case 0:case pred:;}
+
+#define WRAP( fn, ret, ... ) \
+	ret __real_##fn(__VA_ARGS__); \
+	ret __wrap_##fn(__VA_ARGS__)
+
+#define CALL( fn ) __real_##fn
+
+// Needed by pathmatch code
+extern "C" int __real_access(const char *pathname, int mode);
+extern "C" DIR *__real_opendir(const char *name);
+
+
+// UTF-8 work from PhysicsFS: http://icculus.org/physfs/
+//  Even if it wasn't under the zlib license, Ryan wrote all this code originally.
+
+#define UNICODE_BOGUS_CHAR_VALUE 0xFFFFFFFF
+#define UNICODE_BOGUS_CHAR_CODEPOINT '?'
+
+inline __attribute__ ((always_inline)) static uint32_t utf8codepoint(const char **_str)
+{
+	const char *str = *_str;
+	uint32_t retval = 0;
+	uint32_t octet = (uint32_t) ((uint8_t) *str);
+	uint32_t octet2, octet3, octet4;
+
+	if (octet == 0)  // null terminator, end of string.
+		return 0;
+
+	else if (octet < 128)  // one octet char: 0 to 127
+	{
+		(*_str)++;  // skip to next possible start of codepoint.
+		return octet;
+	}
+
+	else if ((octet > 127) && (octet < 192))  // bad (starts with 10xxxxxx).
+	{
+		// Apparently each of these is supposed to be flagged as a bogus
+		//  char, instead of just resyncing to the next valid codepoint.
+		(*_str)++;  // skip to next possible start of codepoint.
+		return UNICODE_BOGUS_CHAR_VALUE;
+	}
+
+	else if (octet < 224)  // two octets
+	{
+		octet -= (128+64);
+		octet2 = (uint32_t) ((uint8_t) *(++str));
+		if ((octet2 & (128+64)) != 128)  // Format isn't 10xxxxxx?
+			return UNICODE_BOGUS_CHAR_VALUE;
+
+		*_str += 2;  // skip to next possible start of codepoint.
+		retval = ((octet << 6) | (octet2 - 128));
+		if ((retval >= 0x80) && (retval <= 0x7FF))
+			return retval;
+	}
+
+	else if (octet < 240)  // three octets
+	{
+		octet -= (128+64+32);
+		octet2 = (uint32_t) ((uint8_t) *(++str));
+		if ((octet2 & (128+64)) != 128)  // Format isn't 10xxxxxx?
+			return UNICODE_BOGUS_CHAR_VALUE;
+
+		octet3 = (uint32_t) ((uint8_t) *(++str));
+		if ((octet3 & (128+64)) != 128)  // Format isn't 10xxxxxx?
+			return UNICODE_BOGUS_CHAR_VALUE;
+
+		*_str += 3;  // skip to next possible start of codepoint.
+		retval = ( ((octet << 12)) | ((octet2-128) << 6) | ((octet3-128)) );
+
+		// There are seven "UTF-16 surrogates" that are illegal in UTF-8.
+		switch (retval)
+		{
+			case 0xD800:
+			case 0xDB7F:
+			case 0xDB80:
+			case 0xDBFF:
+			case 0xDC00:
+			case 0xDF80:
+			case 0xDFFF:
+				return UNICODE_BOGUS_CHAR_VALUE;
+		}
+
+		// 0xFFFE and 0xFFFF are illegal, too, so we check them at the edge.
+		if ((retval >= 0x800) && (retval <= 0xFFFD))
+			return retval;
+	}
+
+	else if (octet < 248)  // four octets
+	{
+		octet -= (128+64+32+16);
+		octet2 = (uint32_t) ((uint8_t) *(++str));
+		if ((octet2 & (128+64)) != 128)  // Format isn't 10xxxxxx?
+			return UNICODE_BOGUS_CHAR_VALUE;
+
+		octet3 = (uint32_t) ((uint8_t) *(++str));
+		if ((octet3 & (128+64)) != 128)  // Format isn't 10xxxxxx?
+			return UNICODE_BOGUS_CHAR_VALUE;
+
+		octet4 = (uint32_t) ((uint8_t) *(++str));
+		if ((octet4 & (128+64)) != 128)  // Format isn't 10xxxxxx?
+			return UNICODE_BOGUS_CHAR_VALUE;
+
+		*_str += 4;  // skip to next possible start of codepoint.
+		retval = ( ((octet << 18)) | ((octet2 - 128) << 12) |
+		           ((octet3 - 128) << 6) | ((octet4 - 128)) );
+		if ((retval >= 0x10000) && (retval <= 0x10FFFF))
+			return retval;
+	}
+
+	// Five and six octet sequences became illegal in rfc3629.
+	//  We throw the codepoint away, but parse them to make sure we move
+	//  ahead the right number of bytes and don't overflow the buffer.
+
+	else if (octet < 252)  // five octets
+	{
+		octet = (uint32_t) ((uint8_t) *(++str));
+		if ((octet & (128+64)) != 128)  // Format isn't 10xxxxxx?
+			return UNICODE_BOGUS_CHAR_VALUE;
+
+		octet = (uint32_t) ((uint8_t) *(++str));
+		if ((octet & (128+64)) != 128)  // Format isn't 10xxxxxx?
+			return UNICODE_BOGUS_CHAR_VALUE;
+
+		octet = (uint32_t) ((uint8_t) *(++str));
+		if ((octet & (128+64)) != 128)  // Format isn't 10xxxxxx?
+			return UNICODE_BOGUS_CHAR_VALUE;
+
+		octet = (uint32_t) ((uint8_t) *(++str));
+		if ((octet & (128+64)) != 128)  // Format isn't 10xxxxxx?
+			return UNICODE_BOGUS_CHAR_VALUE;
+
+		*_str += 5;  // skip to next possible start of codepoint.
+		return UNICODE_BOGUS_CHAR_VALUE;
+	}
+
+	else  // six octets
+	{
+		octet = (uint32_t) ((uint8_t) *(++str));
+		if ((octet & (128+64)) != 128)  // Format isn't 10xxxxxx?
+			return UNICODE_BOGUS_CHAR_VALUE;
+
+		octet = (uint32_t) ((uint8_t) *(++str));
+		if ((octet & (128+64)) != 128)  // Format isn't 10xxxxxx?
+			return UNICODE_BOGUS_CHAR_VALUE;
+
+		octet = (uint32_t) ((uint8_t) *(++str));
+		if ((octet & (128+64)) != 128)  // Format isn't 10xxxxxx?
+			return UNICODE_BOGUS_CHAR_VALUE;
+
+		octet = (uint32_t) ((uint8_t) *(++str));
+		if ((octet & (128+64)) != 128)  // Format isn't 10xxxxxx?
+			return UNICODE_BOGUS_CHAR_VALUE;
+
+		octet = (uint32_t) ((uint8_t) *(++str));
+		if ((octet & (128+64)) != 128)  // Format isn't 10xxxxxx?
+			return UNICODE_BOGUS_CHAR_VALUE;
+
+		*_str += 6;  // skip to next possible start of codepoint.
+		return UNICODE_BOGUS_CHAR_VALUE;
+	}
+
+	return UNICODE_BOGUS_CHAR_VALUE;
+}
+
+typedef struct CaseFoldMapping
+{
+	uint32_t from;
+	uint32_t to0;
+	uint32_t to1;
+	uint32_t to2;
+} CaseFoldMapping;
+
+typedef struct CaseFoldHashBucket
+{
+	const uint8_t count;
+	const CaseFoldMapping *list;
+} CaseFoldHashBucket;
+
+#include "pathmatch_casefolding.h"
+
+inline __attribute__ ((always_inline)) static void locate_case_fold_mapping(const uint32_t from, uint32_t *to)
+{
+	const uint8_t hashed = ((from ^ (from >> 8)) & 0xFF);
+	const CaseFoldHashBucket *bucket = &case_fold_hash[hashed];
+	const CaseFoldMapping *mapping = bucket->list;
+	uint32_t i;
+
+	for (i = 0; i < bucket->count; i++, mapping++)
+	{
+		if (mapping->from == from)
+		{
+			to[0] = mapping->to0;
+			to[1] = mapping->to1;
+			to[2] = mapping->to2;
+			return;
+		}
+	}
+
+	// Not found...there's no remapping for this codepoint.
+	to[0] = from;
+	to[1] = 0;
+	to[2] = 0;
+}
+
+inline __attribute__ ((always_inline)) static uint32_t *fold_utf8(const char *str)
+{
+	uint32_t *retval = new uint32_t[(strlen(str) * 3) + 1];
+	uint32_t *dst = retval;
+	while (*str)
+	{
+		const char ch = *str;
+		if (ch & 0x80)  // high bit set? UTF-8 sequence!
+		{
+			uint32_t fold[3];
+			locate_case_fold_mapping(utf8codepoint(&str), fold);
+			*(dst++) = fold[0];
+			if (fold[1])
+			{
+				*(dst++) = fold[1];
+				if (fold[2])
+					*(dst++) = fold[2];
+			}
+		}
+		else  // simple ASCII test.
+		{
+			*(dst++) = (uint32_t) (((ch >= 'A') && (ch <= 'Z')) ? ch + 32 : ch);
+			str++;
+		}
+	}
+	*dst = 0;
+	return retval;
+}
+
+inline __attribute__ ((always_inline)) static int utf8casecmp_loop(const uint32_t *folded1, const uint32_t *folded2)
+{
+	while (true)
+	{
+		const uint32_t ch1 = *(folded1++);
+		const uint32_t ch2 = *(folded2++);
+		if (ch1 < ch2)
+			return -1;
+		else if (ch1 > ch2)
+			return 1;
+		else if (ch1 == 0)
+			return 0;  // complete match.
+	}
+}
+
+static int utf8casecmp(const char *str1, const char *str2)
+{
+	uint32_t *folded1 = fold_utf8(str1);
+	uint32_t *folded2 = fold_utf8(str2);
+	const int retval = utf8casecmp_loop(folded1, folded2);
+	delete[] folded1;
+	delete[] folded2;
+	return retval;
+}
+
+// Simple object to help make sure a DIR* from opendir
+// gets closed when it goes out of scope.
+class CDirPtr
+{
+public:
+    CDirPtr() { m_pDir = NULL; }
+    CDirPtr( DIR *pDir ) : m_pDir(pDir) {}
+    ~CDirPtr() { Close(); }
+
+    void operator=(DIR *pDir) { Close(); m_pDir = pDir; }
+
+    operator DIR *() { return m_pDir; }
+    operator bool() { return m_pDir != NULL; }
+private:
+
+    void Close() { if ( m_pDir ) closedir( m_pDir ); }
+
+    DIR *m_pDir;
+};
+
+// Object used to temporarily slice a path into a smaller componentent
+// and then repair it when going out of scope. Typically used as an unnamed
+// temp object that is a parameter to a function.
+class CDirTrimmer
+{
+public:
+    CDirTrimmer( char * pPath, size_t nTrimIdx )
+    {
+        m_pPath = pPath;
+        m_idx = nTrimIdx;
+        m_c = m_pPath[nTrimIdx];
+        m_pPath[nTrimIdx] = '\0';
+    }
+    ~CDirTrimmer() { m_pPath[m_idx] = m_c; }
+
+    operator const char *() { return m_pPath; }
+
+private:
+    size_t m_idx;
+    char *m_pPath;
+    char m_c;
+};
+
+
+enum PathMod_t
+{
+	kPathUnchanged,
+	kPathLowered,
+	kPathChanged,
+	kPathFailed,
+};
+
+static bool Descend( char *pPath, size_t nStartIdx, bool bAllowBasenameMismatch, size_t nLevel = 0 )
+{
+	DEBUG_MSG( "(%zu) Descend: %s, (%s), %s\n", nLevel, pPath, pPath+nStartIdx, bAllowBasenameMismatch ? "true" : "false " );
+	// We assume up through nStartIdx is valid and matching
+	size_t nNextSlash = nStartIdx+1;
+
+	// path might be a dir
+	if ( pPath[nNextSlash] == '\0' )
+	{
+		return true;
+	}
+
+	bool bIsDir = false; // is the new component a directory for certain?
+	while ( pPath[nNextSlash] != '\0' && pPath[nNextSlash] != '/' )
+	{
+		nNextSlash++;
+	}
+
+	// Modify the pPath string
+	if ( pPath[nNextSlash] == '/' )
+		bIsDir = true;
+
+	// See if we have an immediate match
+	if ( __real_access( CDirTrimmer(pPath, nNextSlash), F_OK ) == 0 )
+	{
+		if ( !bIsDir )
+			return true;
+
+		bool bRet = Descend( pPath, nNextSlash, bAllowBasenameMismatch, nLevel+1 );
+		if ( bRet )
+			return true;
+	}
+
+	// Start enumerating dirents
+	CDirPtr spDir;
+	if ( nStartIdx )
+	{
+		// we have a path
+		spDir = __real_opendir( CDirTrimmer( pPath, nStartIdx ) );
+		nStartIdx++;
+	}
+	else
+	{
+		// we either start at root or cwd
+		const char *pRoot = ".";
+		if ( *pPath == '/' )
+		{
+		    pRoot = "/";
+		    nStartIdx++;
+		}
+		spDir = __real_opendir( pRoot );
+	}
+
+    errno = 0;
+    struct dirent *pEntry = spDir ? readdir( spDir ) : NULL;
+    char *pszComponent = pPath + nStartIdx;
+    size_t cbComponent = nNextSlash - nStartIdx;
+    while ( pEntry )
+    {
+        DEBUG_MSG( "\t(%zu) comparing %s with %s\n", nLevel, pEntry->d_name, (const char *)CDirTrimmer(pszComponent, cbComponent) );
+
+        // the candidate must match the target, but not be a case-identical match (we would
+        // have looked there in the short-circuit code above, so don't look again)
+        bool bMatches = ( strcasecmp( CDirTrimmer(pszComponent, cbComponent), pEntry->d_name ) == 0 &&
+                          strcmp( CDirTrimmer(pszComponent, cbComponent), pEntry->d_name ) != 0 );
+
+        if ( bMatches )
+        {
+            char *pSrc = pEntry->d_name;
+            char *pDst = &pPath[nStartIdx];
+            // found a match; copy it in.
+            while ( *pSrc && (*pSrc != '/') )
+            {
+                *pDst++ = *pSrc++;
+            }
+
+            if ( !bIsDir )
+                return true;
+
+            if ( Descend( pPath, nNextSlash, bAllowBasenameMismatch, nLevel+1 ) )
+                return true;
+
+            // If descend fails, try more directories
+        }
+        pEntry = readdir( spDir );
+    }
+
+    if ( bIsDir )
+    {
+        DEBUG_MSG( "(%zu) readdir failed to find '%s' in '%s'\n", nLevel, (const char *)CDirTrimmer(pszComponent, cbComponent), (const char *)CDirTrimmer( pPath, nStartIdx ) );
+    }
+
+	// Sometimes it's ok for the filename portion to not match
+	// since we might be opening for write.  Note that if
+	// the filename matches case insensitive, that will be
+	// preferred over preserving the input name
+	if ( !bIsDir && bAllowBasenameMismatch )
+		return true;
+
+	return false;
+}
+
+#ifdef DO_PATHMATCH_CACHE
+typedef std::map<std::string, std::pair<std::string, time_t> > resultCache_t;
+typedef std::map<std::string, std::pair<std::string, time_t> >::iterator resultCacheItr_t;
+static resultCache_t resultCache;
+static const int k_cMaxCacheLifetimeSeconds = 2;
+#endif // DO_PATHMATCH_CACHE
+
+PathMod_t pathmatch( const char *pszIn, char **ppszOut, bool bAllowBasenameMismatch, char *pszOutBuf, size_t OutBufLen )
+{
+	// Path matching can be very expensive, and the cost is unpredictable because it
+	// depends on how many files are in directories on a user's machine. Therefore
+	// it should be disabled whenever possible, and only enabled in environments (such
+	// as running with loose files such as out of Perforce) where it is needed.
+	static const char *s_pszPathMatchEnabled = getenv("ENABLE_PATHMATCH");
+	if ( !s_pszPathMatchEnabled )
+		return kPathUnchanged;
+
+	static const char *s_pszDbgPathMatch = getenv("DBG_PATHMATCH");
+
+	s_bShowDiag = ( s_pszDbgPathMatch != NULL );
+
+	*ppszOut = NULL;
+
+	if ( __real_access( pszIn, F_OK ) == 0 )
+		return kPathUnchanged;
+
+#ifdef DO_PATHMATCH_CACHE
+	resultCacheItr_t cachedResult = resultCache.find( pszIn );
+	if ( cachedResult != resultCache.end() )
+	{
+		unsigned int age = time( NULL ) - cachedResult->second.second;
+		const char *pszResult = cachedResult->second.first.c_str(); 
+		if ( pszResult[0] != '\0' || age <= k_cMaxCacheLifetimeSeconds )
+		{
+			if ( pszResult[0] != '\0' )
+			{
+				*ppszOut = strdup( pszResult );
+				DEBUG_MSG( "Cached '%s' -> '%s'\n", pszIn, *ppszOut );
+				return kPathChanged;
+			}
+			else
+			{
+				DEBUG_MSG( "Cached '%s' -> kPathFailed\n", pszIn );
+				return kPathFailed;
+			}
+		}
+		else if ( age <= k_cMaxCacheLifetimeSeconds )
+		{
+			DEBUG_MSG( "Rechecking '%s' - cache is %u seconds old\n", pszIn, age );			
+		}
+	}
+#endif // DO_PATHMATCH_CACHE
+
+	char *pPath;
+	if( strlen( pszIn ) >= OutBufLen )
+	{
+		pPath = strdup( pszIn );
+	}
+	else
+	{
+		strncpy( pszOutBuf, pszIn, OutBufLen );
+		pPath = pszOutBuf;
+	}
+
+	if ( pPath )
+	{
+		// I believe this code is broken. I'm guessing someone wanted to avoid lowercasing
+		//	the path before the steam directory - but it's actually skipping lowercasing
+		//	whenever steam is found anywhere - including the filename. For example, 
+		//	  /home/mikesart/valvesrc/console/l4d2/game/left4dead2_dlc1/particles/steam_fx.pcf
+		//	winds up only having the "steam_fx.pcf" portion lowercased.
+#ifdef NEVER
+		// optimization, if the path contained steam somewhere
+		// assume the path up through the component with 'steam' in
+		// is valid (because we almost certainly obtained it
+		// progamatically
+		char *p = strcasestr( pPath, "steam" );
+		if ( p )
+		{
+			while ( p > pPath )
+			{
+				if ( p[-1] == '/' )
+					break;
+				p--;
+			}
+
+			if ( ( p == pPath+1 ) && ( *pPath != '/' ) )
+				p = pPath;
+		}
+		else
+		{
+			p = pPath;
+		}
+#else
+		char *p = pPath;
+#endif
+
+		// Try the lower casing of the remaining path
+		char *pBasename = p;
+		while ( *p )
+		{
+			if ( *p == '/' )
+				pBasename = p+1;
+
+			*p = tolower(*p);
+			p++;
+		}
+		if ( __real_access( pPath, F_OK ) == 0 )
+		{
+			*ppszOut = pPath;
+			DEBUG_MSG( "Lowered '%s' -> '%s'\n", pszIn, pPath );
+			return kPathLowered;
+		}
+
+		// path didn't match lowered successfully, restore the basename
+		// if bAllowBasenameMismatch was true
+		if ( bAllowBasenameMismatch )
+		{
+			const char *pSrc = pszIn + (pBasename - pPath);
+			while ( *pBasename )
+			{
+				*pBasename++ = *pSrc++;
+			}
+		}
+
+		if ( s_pszDbgPathMatch && strcasestr( s_pszDbgPathMatch, pszIn ) )
+		{
+			DEBUG_MSG( "Breaking '%s' in '%s'\n", pszIn, s_pszDbgPathMatch );
+			DEBUG_BREAK();
+		}
+
+		bool bSuccess = Descend( pPath, 0, bAllowBasenameMismatch );
+		if ( bSuccess )
+		{
+			*ppszOut = pPath;
+			DEBUG_MSG( "Matched '%s' -> '%s'\n", pszIn, pPath );
+		}
+		else
+		{
+			DEBUG_MSG( "Unmatched %s\n", pszIn );
+		}
+
+#ifndef DO_PATHMATCH_CACHE
+		return bSuccess ? kPathChanged : kPathFailed;
+#else
+		time_t now = time(NULL);
+		if ( bSuccess )
+		{
+			resultCache[ pszIn ] = std::make_pair( *ppszOut, now ); 
+			return kPathChanged;
+		}
+		else
+		{
+			resultCache[ pszIn ] = std::make_pair( "", now ); 
+			return kPathFailed;			
+		}
+#endif
+	}
+	return kPathFailed;
+}
+
+// Wrapper object that manages the 'typical' usage cases of pathmatch()
+class CWrap
+{
+public:
+	CWrap( const char *pSuppliedPath, bool bAllowMismatchedBasename )
+		: m_pSuppliedPath( pSuppliedPath ), m_pBestMatch( NULL )
+	{
+	    m_eResult = pathmatch( m_pSuppliedPath, &m_pBestMatch, bAllowMismatchedBasename, m_BestMatchBuf, sizeof( m_BestMatchBuf ) );
+		if ( m_pBestMatch == NULL )
+		{
+			m_pBestMatch = const_cast<char*>( m_pSuppliedPath );
+		}
+	}
+
+	~CWrap()
+	{
+		if ( ( m_pBestMatch != m_pSuppliedPath ) && ( m_pBestMatch != m_BestMatchBuf ) )
+			free( m_pBestMatch );
+	}
+
+	const char *GetBest() const { return m_pBestMatch; }
+	const char *GetOriginal() const { return m_pSuppliedPath; }
+	PathMod_t GetMatchResult() const { return m_eResult; }
+
+	operator const char*() { return GetBest(); }
+
+private:
+	const char *m_pSuppliedPath;
+	char *m_pBestMatch;
+	char m_BestMatchBuf[ 512 ];
+	PathMod_t m_eResult;
+};
+
+#ifdef MAIN_TEST
+void usage()
+{
+    puts("pathmatch [options] <path>");
+    //puts("options:");
+    //puts("\t");
+
+    exit(-1);
+}
+
+void test( const char *pszFile, bool bAllowBasenameMismatch )
+{
+    char *pNewPath;
+	char NewPathBuf[ 512 ];
+    PathMod_t nStat = pathmatch( pszFile, &pNewPath, bAllowBasenameMismatch, NewPathBuf, sizeof( NewPathBuf ) );
+
+    printf("AllowMismatchedBasename: %s\n", bAllowBasenameMismatch ? "true" : "false" );
+    printf("Path Was: ");
+    switch ( nStat )
+    {
+    case kPathUnchanged:
+        puts("kPathUnchanged");
+        break;
+    case kPathLowered:
+        puts("kPathLowered");
+        break;
+    case kPathChanged:
+        puts("kPathChanged");
+        break;
+    case kPathFailed:
+        puts("kPathFailed");
+        break;
+    }
+
+    printf(" Path In: %s\n", pszFile );
+    printf("Path Out: %s\n",  nStat == kPathUnchanged ? pszFile : pNewPath );
+
+    if ( pNewPath )
+        free( pNewPath );
+}
+
+int
+main(int argc, char **argv)
+{
+    if ( argc <= 1 || argc > 2 )
+        usage();
+
+    test( argv[1], false );
+    test( argv[1], true );
+
+    return 0;
+}
+#endif
+
+extern "C" {
+
+	WRAP(freopen, FILE *, const char *path, const char *mode, FILE *stream)
+	{
+		// if mode does not have w, a, or +, it's open for read.
+		bool bAllowBasenameMismatch = strpbrk( mode, "wa+" ) != NULL;
+		CWrap mpath( path, bAllowBasenameMismatch );
+
+		return CALL(freopen)( mpath, mode, stream );
+	}
+
+	WRAP(fopen, FILE *, const char *path, const char *mode)
+	{
+		// if mode does not have w, a, or +, it's open for read.
+		bool bAllowBasenameMismatch = strpbrk( mode, "wa+" ) != NULL;
+		CWrap mpath( path, bAllowBasenameMismatch );
+
+		return CALL(fopen)( mpath, mode );
+	}
+
+
+	WRAP(fopen64, FILE *, const char *path, const char *mode)
+	{
+		// if mode does not have w, a, or +, it's open for read.
+		bool bAllowBasenameMismatch = strpbrk( mode, "wa+" ) != NULL;
+		CWrap mpath( path, bAllowBasenameMismatch );
+
+		return CALL(fopen64)( mpath, mode );
+	}
+
+	WRAP(open, int, const char *pathname, int flags, mode_t mode)
+	{
+		bool bAllowBasenameMismatch = ((flags & (O_WRONLY | O_RDWR)) != 0);
+		CWrap mpath( pathname, bAllowBasenameMismatch );
+		return CALL(open)( mpath, flags, mode );
+	}
+
+	WRAP(open64, int, const char *pathname, int flags, mode_t mode)
+	{
+		bool bAllowBasenameMismatch = ((flags & (O_WRONLY | O_RDWR)) != 0);
+		CWrap mpath( pathname, bAllowBasenameMismatch );
+		return CALL(open64)( mpath, flags, mode );
+	}
+
+	int __wrap_creat(const char *pathname, mode_t mode)
+	{
+		return __wrap_open( pathname, O_CREAT|O_WRONLY|O_TRUNC, mode );
+	}
+
+	int __wrap_access(const char *pathname, int mode)
+	{
+		return __real_access( CWrap( pathname, false ), mode );
+	}
+
+	WRAP(stat, int, const char *path, struct stat *buf)
+	{
+		return CALL(stat)( CWrap( path, false ), buf );
+	}
+
+	WRAP(lstat, int, const char *path, struct stat *buf)
+	{
+		return CALL(lstat)( CWrap( path, false ), buf );
+	}
+
+	WRAP(scandir, int, const char *dirp, struct dirent ***namelist,
+		 int (*filter)(const struct dirent *),
+		 int (*compar)(const struct dirent **, const struct dirent **))
+	{
+		return CALL(scandir)( CWrap( dirp, false ), namelist, filter, compar );
+	}
+
+	WRAP(opendir, DIR*, const char *name)
+	{
+		return CALL(opendir)( CWrap( name, false ) );
+	}
+
+    WRAP(__xstat, int, int __ver, __const char *__filename, struct stat *__stat_buf)
+    {
+        return CALL(__xstat)( __ver, CWrap( __filename, false), __stat_buf );
+    }
+
+    WRAP(__lxstat, int, int __ver, __const char *__filename, struct stat *__stat_buf)
+    {
+        return CALL(__lxstat)( __ver, CWrap( __filename, false), __stat_buf );
+    }
+
+    WRAP(__xstat64, int, int __ver, __const char *__filename, struct stat *__stat_buf)
+    {
+        return CALL(__xstat64)( __ver, CWrap( __filename, false), __stat_buf );
+    }
+
+    WRAP(__lxstat64, int, int __ver, __const char *__filename, struct stat *__stat_buf)
+    {
+        return CALL(__lxstat64)( __ver, CWrap( __filename, false), __stat_buf );
+    }
+
+	WRAP(chmod, int, const char *path, mode_t mode)
+	{
+        return CALL(chmod)( CWrap( path, false), mode );
+	}
+
+	WRAP(chown, int, const char *path, uid_t owner, gid_t group)
+	{
+        return CALL(chown)( CWrap( path, false), owner, group );
+	}
+
+	WRAP(lchown, int, const char *path, uid_t owner, gid_t group)
+	{
+        return CALL(lchown)( CWrap( path, false), owner, group );
+	}
+
+	WRAP(symlink, int, const char *oldpath, const char *newpath)
+	{
+        return CALL(symlink)( CWrap( oldpath, false), CWrap( newpath, true ) );
+	}
+
+	WRAP(link, int, const char *oldpath, const char *newpath)
+	{
+        return CALL(link)( CWrap( oldpath, false), CWrap( newpath, true ) );
+	}
+
+	WRAP(mknod, int, const char *pathname, mode_t mode, dev_t dev)
+	{
+        return CALL(mknod)( CWrap( pathname, true), mode, dev );
+	}
+
+	WRAP(mount, int, const char *source, const char *target,
+		 const char *filesystemtype, unsigned long mountflags,
+		 const void *data)
+	{
+		return CALL(mount)( CWrap( source, false ), CWrap( target, false ), filesystemtype, mountflags, data );
+	}
+
+	WRAP(unlink, int, const char *pathname)
+	{
+        return CALL(unlink)( CWrap( pathname, false ) );
+	}
+
+	WRAP(mkfifo, int, const char *pathname, mode_t mode)
+	{
+        return CALL(mkfifo)( CWrap( pathname, true ), mode );
+	}
+
+	WRAP(rename, int, const char *oldpath, const char *newpath)
+	{
+        return CALL(rename)( CWrap( oldpath, false), CWrap( newpath, true ) );
+	}
+
+	WRAP(utime, int, const char *filename, const struct utimbuf *times)
+	{
+        return CALL(utime)( CWrap( filename, false), times );
+	}
+
+	WRAP(utimes, int, const char *filename, const struct timeval times[2])
+	{
+        return CALL(utimes)( CWrap( filename, false), times );
+	}
+
+	WRAP(realpath, char *, const char *path, char *resolved_path)
+	{
+		return CALL(realpath)( CWrap( path, true ), resolved_path );
+	}
+
+	WRAP(mkdir, int, const char *pathname, mode_t mode)
+	{
+		return CALL(mkdir)( CWrap( pathname, true ), mode );
+	}
+
+	WRAP(rmdir, char *, const char *pathname)
+	{
+		return CALL(rmdir)( CWrap( pathname, false ) );
+	}
+
+};
+
+#endif

mp/src/tier1/processor_detect.cpp

@@ -0,0 +1,274 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: win32 dependant ASM code for CPU capability detection
+//
+// $Workfile:     $
+// $NoKeywords: $
+//=============================================================================//
+
+#if defined( _X360 ) || defined( WIN64 )
+
+bool CheckMMXTechnology(void) { return false; }
+bool CheckSSETechnology(void) { return false; }
+bool CheckSSE2Technology(void) { return false; }
+bool Check3DNowTechnology(void) { return false; }
+
+#elif defined( _WIN32 ) && !defined( _X360 )
+
+#pragma optimize( "", off )
+#pragma warning( disable: 4800 ) //'int' : forcing value to bool 'true' or 'false' (performance warning)
+
+// stuff from windows.h
+#ifndef EXCEPTION_EXECUTE_HANDLER
+#define EXCEPTION_EXECUTE_HANDLER       1
+#endif
+
+bool CheckMMXTechnology(void)
+{
+    int retval = true;
+    unsigned int RegEDX = 0;
+
+#ifdef CPUID
+	_asm pushad;
+#endif
+
+    __try
+	{
+        _asm
+		{
+#ifdef CPUID
+			xor edx, edx	// Clue the compiler that EDX is about to be used.
+#endif
+            mov eax, 1      // set up CPUID to return processor version and features
+                            //      0 = vendor string, 1 = version info, 2 = cache info
+            CPUID           // code bytes = 0fh,  0a2h
+            mov RegEDX, edx // features returned in edx
+		}
+    } 
+	__except(EXCEPTION_EXECUTE_HANDLER) 
+	{ 
+		retval = false; 
+	}
+
+	// If CPUID not supported, then certainly no MMX extensions.
+    if (retval)
+	{
+		if (RegEDX & 0x800000)          // bit 23 is set for MMX technology
+		{
+		   __try 
+		   { 
+				// try executing the MMX instruction "emms"
+			   _asm EMMS
+		   } 
+		   __except(EXCEPTION_EXECUTE_HANDLER) 
+		   { 
+			   retval = false; 
+		   }
+		}
+
+		else
+			retval = false;           // processor supports CPUID but does not support MMX technology
+
+		// if retval == 0 here, it means the processor has MMX technology but
+		// floating-point emulation is on; so MMX technology is unavailable
+	}
+
+#ifdef CPUID
+	_asm popad;
+#endif
+
+    return retval;
+}
+
+bool CheckSSETechnology(void)
+{
+    int retval = true;
+    unsigned int RegEDX = 0;
+
+#ifdef CPUID
+	_asm pushad;
+#endif
+
+	// Do we have support for the CPUID function?
+    __try
+	{
+        _asm
+		{
+#ifdef CPUID
+			xor edx, edx			// Clue the compiler that EDX is about to be used.
+#endif
+            mov eax, 1				// set up CPUID to return processor version and features
+									//      0 = vendor string, 1 = version info, 2 = cache info
+            CPUID					// code bytes = 0fh,  0a2h
+            mov RegEDX, edx			// features returned in edx
+		}
+    } 
+	__except(EXCEPTION_EXECUTE_HANDLER) 
+	{ 
+		retval = false; 
+	}
+
+	// If CPUID not supported, then certainly no SSE extensions.
+    if (retval)
+	{
+		// Do we have support for SSE in this processor?
+		if ( RegEDX & 0x2000000L )		// bit 25 is set for SSE technology
+		{
+			// Make sure that SSE is supported by executing an inline SSE instruction
+
+// BUGBUG, FIXME - Visual C Version 6.0 does not support SSE inline code YET (No macros from Intel either)
+// Fix this if VC7 supports inline SSE instructinons like "xorps" as shown below.
+#if 1
+			__try
+			{
+				_asm
+				{
+					// Attempt execution of a SSE instruction to make sure OS supports SSE FPU context switches
+					xorps xmm0, xmm0
+					// This will work on Win2k+ (Including masking SSE FPU exception to "normalized" values)
+					// This will work on Win98+ (But no "masking" of FPU exceptions provided)
+				}
+			} 
+			__except(EXCEPTION_EXECUTE_HANDLER) 
+#endif
+
+			{ 
+				retval = false; 
+			}
+		}
+		else
+			retval = false;
+	}
+#ifdef CPUID
+	_asm popad;
+#endif
+
+    return retval;
+}
+
+bool CheckSSE2Technology(void)
+{
+    int retval = true;
+    unsigned int RegEDX = 0;
+
+#ifdef CPUID
+	_asm pushad;
+#endif
+
+	// Do we have support for the CPUID function?
+    __try
+	{
+        _asm
+		{
+#ifdef CPUID
+			xor edx, edx			// Clue the compiler that EDX is about to be used.
+#endif
+            mov eax, 1				// set up CPUID to return processor version and features
+									//      0 = vendor string, 1 = version info, 2 = cache info
+            CPUID					// code bytes = 0fh,  0a2h
+            mov RegEDX, edx			// features returned in edx
+		}
+    } 
+	__except(EXCEPTION_EXECUTE_HANDLER) 
+	{ 
+		retval = false; 
+	}
+
+	// If CPUID not supported, then certainly no SSE extensions.
+    if (retval)
+	{
+		// Do we have support for SSE in this processor?
+		if ( RegEDX & 0x04000000 )		// bit 26 is set for SSE2 technology
+		{
+			// Make sure that SSE is supported by executing an inline SSE instruction
+
+			__try
+			{
+				_asm
+				{
+					// Attempt execution of a SSE2 instruction to make sure OS supports SSE FPU context switches
+					xorpd xmm0, xmm0
+				}
+			} 
+			__except(EXCEPTION_EXECUTE_HANDLER) 
+
+			{ 
+				retval = false; 
+			}
+		}
+		else
+			retval = false;
+	}
+#ifdef CPUID
+	_asm popad;
+#endif
+
+    return retval;
+}
+
+bool Check3DNowTechnology(void)
+{
+    int retval = true;
+    unsigned int RegEAX = 0;
+
+#ifdef CPUID
+	_asm pushad;
+#endif
+
+    // First see if we can execute CPUID at all
+	__try
+	{
+        _asm
+		{
+#ifdef CPUID
+//			xor edx, edx			// Clue the compiler that EDX is about to be used.
+#endif
+            mov eax, 0x80000000     // setup CPUID to return whether AMD >0x80000000 function are supported.
+									// 0x80000000 = Highest 0x80000000+ function, 0x80000001 = 3DNow support
+            CPUID					// code bytes = 0fh,  0a2h
+            mov RegEAX, eax			// result returned in eax
+		}
+    } 
+	__except(EXCEPTION_EXECUTE_HANDLER) 
+	{ 
+		retval = false; 
+	}
+
+	// If CPUID not supported, then there is definitely no 3DNow support
+    if (retval)
+	{
+		// Are there any "higher" AMD CPUID functions?
+		if (RegEAX > 0x80000000L )				
+		{
+		   __try 
+			{
+			_asm
+				{
+					mov			eax, 0x80000001		// setup to test for CPU features
+					CPUID							// code bytes = 0fh,  0a2h
+					shr			edx, 31				// If bit 31 is set, we have 3DNow support!
+					mov			retval, edx			// Save the return value for end of function
+				}
+			}
+			__except(EXCEPTION_EXECUTE_HANDLER) 
+			{ 
+				retval = false; 
+			}
+		}
+		else
+		{
+			// processor supports CPUID but does not support AMD CPUID functions
+			retval = false;					
+		}
+	}
+
+#ifdef CPUID
+	_asm popad;
+#endif
+
+    return retval;
+}
+
+#pragma optimize( "", on )
+
+#endif // _WIN32

mp/src/tier1/processor_detect_linux.cpp

@@ -0,0 +1,47 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: linux dependant ASM code for CPU capability detection
+//
+// $Workfile:     $
+// $NoKeywords: $
+//=============================================================================//
+
+#define cpuid(in,a,b,c,d)												\
+	asm("pushl %%ebx\n\t" "cpuid\n\t" "movl %%ebx,%%esi\n\t" "pop %%ebx": "=a" (a), "=S" (b), "=c" (c), "=d" (d) : "a" (in));
+
+bool CheckMMXTechnology(void)
+{
+    unsigned long eax,ebx,edx,unused;
+    cpuid(1,eax,ebx,unused,edx);
+
+    return edx & 0x800000;
+}
+
+bool CheckSSETechnology(void)
+{
+    unsigned long eax,ebx,edx,unused;
+    cpuid(1,eax,ebx,unused,edx);
+
+    return edx & 0x2000000L;
+}
+
+bool CheckSSE2Technology(void)
+{
+    unsigned long eax,ebx,edx,unused;
+    cpuid(1,eax,ebx,unused,edx);
+
+    return edx & 0x04000000;
+}
+
+bool Check3DNowTechnology(void)
+{
+    unsigned long eax, unused;
+    cpuid(0x80000000,eax,unused,unused,unused);
+
+    if ( eax > 0x80000000L )
+    {
+     	cpuid(0x80000001,unused,unused,unused,eax);
+		return ( eax & 1<<31 );
+    }
+    return false;
+}

mp/src/tier1/qsort_s.cpp

@@ -0,0 +1,112 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+/******************************************************************/
+
+/* qsort.c  --  Non-Recursive ANSI Quicksort function             */
+
+/*                                                                */
+
+/* Public domain by Raymond Gardner, Englewood CO  February 1991  */
+
+/*                                                                */
+
+/* Usage:                                                         */
+
+/*     qsort(base, nbr_elements, width_bytes, compare_function);  */
+
+/*        void *base;                                             */
+
+/*        size_t nbr_elements, width_bytes;                       */
+
+/*        int (*compare_function)(const void *, const void *);    */
+
+/*                                                                */
+
+/* Sorts an array starting at base, of length nbr_elements, each  */
+
+/* element of size width_bytes, ordered via compare_function,     */
+
+/* which is called as  (*compare_function)(ptr_to_element1,       */
+
+/* ptr_to_element2) and returns < 0 if element1 < element2,       */
+
+/* 0 if element1 = element2, > 0 if element1 > element2.          */
+
+/* Most refinements are due to R. Sedgewick. See "Implementing    */
+
+/* Quicksort Programs", Comm. ACM, Oct. 1978, and Corrigendum,    */
+
+/* Comm. ACM, June 1979.                                          */
+
+/******************************************************************/
+
+
+
+// modified to take (and use) a context object, ala Microsoft's qsort_s
+
+// "extension" to the stdlib
+
+
+
+#include <stddef.h>                     /* for size_t definition  */
+
+
+
+/*
+
+**  swap nbytes between a and b
+
+*/
+
+
+
+static void swap_bytes(char *a, char *b, size_t nbytes)
+
+{
+
+   char tmp;
+
+   do {
+
+      tmp = *a; *a++ = *b; *b++ = tmp;
+
+   } while ( --nbytes );
+
+}
+
+
+
+#define  SWAP(a, b)  (swap_bytes((char *)(a), (char *)(b), size))
+
+
+
+#define  COMP(ctx, a, b)  ((*comp)((void *)ctx, (void *)(a), (void *)(b)))
+
+
+
+#define  T           7    /* subfiles of T or fewer elements will */
+
+                          /* be sorted by a simple insertion sort */
+
+                          /* Note!  T must be at least 3          */
+
+
+
+extern "C" void qsort_s(void *basep, size_t nelems, size_t size,
+
+           int (*comp)(void *, const void *, const void *),
+
+	   void *ctx)
+
+{
+
+   char *stack[40], **sp;       /* stack and stack pointer        */
+
+   char *i, *j, *limit;         /* scan and limit pointers        */
+
+   size_t thresh;               /* size of T elements in bytes    */
+
+   char *base;                  /* base pointer as char *         */
+
+
+
+   base = (char *)basep;        /* set up char * base pointer     */

mp/src/tier1/rangecheckedvar.cpp

@@ -0,0 +1,41 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "rangecheckedvar.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+bool g_bDoRangeChecks = true;
+
+
+static int g_nDisables = 0;
+
+
+CDisableRangeChecks::CDisableRangeChecks()
+{
+	if ( !ThreadInMainThread() )
+		return;
+	g_nDisables++;
+	g_bDoRangeChecks = false;
+}
+
+
+CDisableRangeChecks::~CDisableRangeChecks()
+{
+	if ( !ThreadInMainThread() )
+		return;
+	Assert( g_nDisables > 0 );
+	--g_nDisables;
+	if ( g_nDisables == 0 )
+	{
+		g_bDoRangeChecks = true;
+	}
+}
+
+
+
+

mp/src/tier1/reliabletimer.cpp

@@ -0,0 +1,93 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "tier1/reliabletimer.h"
+
+int64 CReliableTimer::sm_nPerformanceFrequency = 0;
+bool CReliableTimer::sm_bUseQPC = false;
+
+#ifdef _WIN32
+#include "winlite.h"
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CReliableTimer::CReliableTimer()
+{
+	m_nPerformanceCounterStart = 0;
+	m_nPerformanceCounterEnd = 0;
+	m_nPerformanceCounterLimit = 0;
+
+#ifdef _WIN32
+	// calculate performance frequency the first time we use a timer
+	if ( 0 == sm_nPerformanceFrequency )
+	{
+		// Are we on a bad CPU?
+		sm_bUseQPC = false; // todo
+		const CPUInformation &cpu = *GetCPUInformation();
+		sm_bUseQPC = ( ( 0 == Q_stricmp( cpu.m_szProcessorID, "AuthenticAMD" ) )
+			&& ( cpu.m_nPhysicalProcessors > 1 )
+			&& !cpu.m_bSSE41 );
+
+		if ( sm_bUseQPC )
+		{
+			LARGE_INTEGER li;
+			QueryPerformanceFrequency( &li );
+			sm_nPerformanceFrequency = li.QuadPart;
+		}
+		else
+		{
+			sm_nPerformanceFrequency = g_ClockSpeed;
+		}
+	}
+#elif defined(_PS3)
+	// On PowerPC, the time base register increment frequency is implementation dependent, and doesn't have to be constant.
+	// On PS3, measured it to be just shy of 80Mhz on the PPU and doesn't seem to change
+	if ( sm_nPerformanceFrequency == 0 )
+		sm_nPerformanceFrequency = sys_time_get_timebase_frequency(); 
+#else
+	// calculate performance frequency the first time we use a timer
+	if ( 0 == sm_nPerformanceFrequency )
+	{
+		sm_nPerformanceFrequency = g_ClockSpeed;
+	}
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns current QueryPerformanceCounter value
+//-----------------------------------------------------------------------------
+int64 CReliableTimer::GetPerformanceCountNow()
+{
+	//VPROF_BUDGET( "CReliableTimer::GetPerformanceCountNow", VPROF_BUDGETGROUP_OTHER_UNACCOUNTED );
+#ifdef _WIN32
+	if ( sm_bUseQPC )
+	{
+		LARGE_INTEGER li = {0};
+		QueryPerformanceCounter( &li );
+		return li.QuadPart;
+	}
+	else
+	{
+		CCycleCount CycleCount;
+		CycleCount.Sample();
+		return CycleCount.GetLongCycles();
+	}
+#elif defined( _PS3 )
+	// use handy macro to grab tb
+	uint64 ulNow;
+	SYS_TIMEBASE_GET( ulNow );
+	return ulNow;
+#else
+	uint64 un64;
+	 __asm__ __volatile__ (
+                        "rdtsc\n\t"
+                        : "=A" (un64) );
+	return (int64)un64;
+#endif
+}

mp/src/tier1/snappy-internal.h

@@ -0,0 +1,150 @@
+// Copyright 2008 Google Inc. All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Internals shared between the Snappy implementation and its unittest.
+
+#ifndef UTIL_SNAPPY_SNAPPY_INTERNAL_H_
+#define UTIL_SNAPPY_SNAPPY_INTERNAL_H_
+
+#include "snappy-stubs-internal.h"
+
+namespace snappy {
+namespace internal {
+
+class WorkingMemory {
+ public:
+  WorkingMemory() : large_table_(NULL) { }
+  ~WorkingMemory() { delete[] large_table_; }
+
+  // Allocates and clears a hash table using memory in "*this",
+  // stores the number of buckets in "*table_size" and returns a pointer to
+  // the base of the hash table.
+  uint16* GetHashTable(size_t input_size, int* table_size);
+
+ private:
+  uint16 small_table_[1<<10];    // 2KB
+  uint16* large_table_;          // Allocated only when needed
+
+  SNAPPY_DISALLOW_COPY_AND_ASSIGN(WorkingMemory);
+};
+
+// Flat array compression that does not emit the "uncompressed length"
+// prefix. Compresses "input" string to the "*op" buffer.
+//
+// REQUIRES: "input_length <= kBlockSize"
+// REQUIRES: "op" points to an array of memory that is at least
+// "MaxCompressedLength(input_length)" in size.
+// REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero.
+// REQUIRES: "table_size" is a power of two
+//
+// Returns an "end" pointer into "op" buffer.
+// "end - op" is the compressed size of "input".
+char* CompressFragment(const char* input,
+                       size_t input_length,
+                       char* op,
+                       uint16* table,
+                       const int table_size);
+
+// Return the largest n such that
+//
+//   s1[0,n-1] == s2[0,n-1]
+//   and n <= (s2_limit - s2).
+//
+// Does not read *s2_limit or beyond.
+// Does not read *(s1 + (s2_limit - s2)) or beyond.
+// Requires that s2_limit >= s2.
+//
+// Separate implementation for x86_64, for speed.  Uses the fact that
+// x86_64 is little endian.
+#if defined(ARCH_K8)
+static inline int FindMatchLength(const char* s1,
+                                  const char* s2,
+                                  const char* s2_limit) {
+  DCHECK_GE(s2_limit, s2);
+  int matched = 0;
+
+  // Find out how long the match is. We loop over the data 64 bits at a
+  // time until we find a 64-bit block that doesn't match; then we find
+  // the first non-matching bit and use that to calculate the total
+  // length of the match.
+  while (PREDICT_TRUE(s2 <= s2_limit - 8)) {
+    if (PREDICT_FALSE(UNALIGNED_LOAD64(s2) == UNALIGNED_LOAD64(s1 + matched))) {
+      s2 += 8;
+      matched += 8;
+    } else {
+      // On current (mid-2008) Opteron models there is a 3% more
+      // efficient code sequence to find the first non-matching byte.
+      // However, what follows is ~10% better on Intel Core 2 and newer,
+      // and we expect AMD's bsf instruction to improve.
+      uint64 x = UNALIGNED_LOAD64(s2) ^ UNALIGNED_LOAD64(s1 + matched);
+      int matching_bits = Bits::FindLSBSetNonZero64(x);
+      matched += matching_bits >> 3;
+      return matched;
+    }
+  }
+  while (PREDICT_TRUE(s2 < s2_limit)) {
+    if (PREDICT_TRUE(s1[matched] == *s2)) {
+      ++s2;
+      ++matched;
+    } else {
+      return matched;
+    }
+  }
+  return matched;
+}
+#else
+static inline int FindMatchLength(const char* s1,
+                                  const char* s2,
+                                  const char* s2_limit) {
+  // Implementation based on the x86-64 version, above.
+  DCHECK_GE(s2_limit, s2);
+  int matched = 0;
+
+  while (s2 <= s2_limit - 4 &&
+         UNALIGNED_LOAD32(s2) == UNALIGNED_LOAD32(s1 + matched)) {
+    s2 += 4;
+    matched += 4;
+  }
+  if (LittleEndian::IsLittleEndian() && s2 <= s2_limit - 4) {
+    uint32 x = UNALIGNED_LOAD32(s2) ^ UNALIGNED_LOAD32(s1 + matched);
+    int matching_bits = Bits::FindLSBSetNonZero(x);
+    matched += matching_bits >> 3;
+  } else {
+    while ((s2 < s2_limit) && (s1[matched] == *s2)) {
+      ++s2;
+      ++matched;
+    }
+  }
+  return matched;
+}
+#endif
+
+}  // end namespace internal
+}  // end namespace snappy
+
+#endif  // UTIL_SNAPPY_SNAPPY_INTERNAL_H_

mp/src/tier1/snappy-sinksource.cpp

@@ -0,0 +1,72 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <string.h>
+
+#include "snappy-sinksource.h"
+
+namespace snappy {
+
+Source::~Source() { }
+
+Sink::~Sink() { }
+
+char* Sink::GetAppendBuffer(size_t, char* scratch) {
+  return scratch;
+}
+
+ByteArraySource::~ByteArraySource() { }
+
+size_t ByteArraySource::Available() const { return left_; }
+
+const char* ByteArraySource::Peek(size_t* len) {
+  *len = left_;
+  return ptr_;
+}
+
+void ByteArraySource::Skip(size_t n) {
+  left_ -= n;
+  ptr_ += n;
+}
+
+UncheckedByteArraySink::~UncheckedByteArraySink() { }
+
+void UncheckedByteArraySink::Append(const char* data, size_t n) {
+  // Do no copying if the caller filled in the result of GetAppendBuffer()
+  if (data != dest_) {
+    memcpy(dest_, data, n);
+  }
+  dest_ += n;
+}
+
+char* UncheckedByteArraySink::GetAppendBuffer(size_t, char*) {
+  return dest_;
+}
+
+
+}

mp/src/tier1/snappy-stubs-internal.cpp

@@ -0,0 +1,45 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <algorithm>
+#ifdef _WIN32
+#pragma warning(disable:4530) // warning C4530: C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc
+#endif //_WIN32
+#include <string>
+
+#include "snappy-stubs-internal.h"
+
+namespace snappy {
+
+void Varint::Append32(string* s, uint32 value) {
+  char buf[Varint::kMax32];
+  const char* p = Varint::Encode32(buf, value);
+  s->append(buf, p - buf);
+}
+
+}  // namespace snappy

mp/src/tier1/snappy-stubs-internal.h

@@ -0,0 +1,487 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Various stubs for the open-source version of Snappy.
+
+#ifndef UTIL_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_
+#define UTIL_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "tier0/platform.h"
+
+// don't use iostream, this make us fail to run under OS X 10.5
+//#include <iostream>
+#include <string>
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef HAVE_SYS_MMAN
+#include <sys/mman.h>
+#endif
+
+#if defined(__x86_64__)
+
+// Enable 64-bit optimized versions of some routines.
+#define ARCH_K8 1
+
+#endif
+
+// Needed by OS X, among others.
+#ifndef MAP_ANONYMOUS
+#define MAP_ANONYMOUS MAP_ANON
+#endif
+
+// Pull in std::min, std::ostream, and the likes. This is safe because this
+// header file is never used from any public header files.
+using namespace std;
+
+// We only define ARRAYSIZE if it isn't already defined, because this definition
+// is not very good.
+#ifndef ARRAYSIZE
+// The size of an array, if known at compile-time.
+// Will give unexpected results if used on a pointer.
+#define ARRAYSIZE(a) (sizeof(a) / sizeof(*(a)))
+#endif
+
+// Static prediction hints.
+#ifdef HAVE_BUILTIN_EXPECT
+#define PREDICT_FALSE(x) (__builtin_expect(x, 0))
+#define PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
+#else
+#define PREDICT_FALSE(x) x
+#define PREDICT_TRUE(x) x
+#endif
+
+// This is only used for recomputing the tag byte table used during
+// decompression; for simplicity we just remove it from the open-source
+// version (anyone who wants to regenerate it can just do the call
+// themselves within main()).
+#define DEFINE_bool(flag_name, default_value, description) \
+  bool FLAGS_ ## flag_name = default_value;
+#define DECLARE_bool(flag_name) \
+  extern bool FLAGS_ ## flag_name;
+#define REGISTER_MODULE_INITIALIZER(name, code)
+
+#define SNAPPY_DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName&);               \
+  void operator=(const TypeName&)
+
+namespace snappy {
+
+static const uint32 kuint32max = static_cast<uint32>(0xFFFFFFFF);
+static const int64 kint64max = static_cast<int64>(0x7FFFFFFFFFFFFFFFLL);
+
+// Logging.
+
+#define LOG(level) LogMessage()
+#define VLOG(level) true ? (void)0 : \
+    snappy::LogMessageVoidify() & snappy::LogMessage()
+
+class LogMessage {
+ public:
+  LogMessage() { }
+  ~LogMessage() {
+	  fprintf( stderr, "\n" );
+    //cerr << endl;
+  }
+
+  LogMessage& operator<<(const std::string& msg) {
+    //cerr << msg;
+	  fprintf( stderr, "%s", msg.c_str() );
+
+	  return *this;
+  }
+  LogMessage& operator<<(int x) {
+	  fprintf( stderr, "%d", x );
+    //cerr << x;
+    return *this;
+  }
+};
+
+// Asserts, both versions activated in debug mode only,
+// and ones that are always active.
+
+#define CRASH_UNLESS(condition) \
+    PREDICT_TRUE(condition) ? (void)0 : \
+    snappy::LogMessageVoidify() & snappy::LogMessageCrash()
+
+class LogMessageCrash : public LogMessage {
+ public:
+  LogMessageCrash() { }
+  ~LogMessageCrash() {
+	  fprintf( stderr, "\n" );
+//    cerr << endl;
+    abort();
+  }
+};
+
+// This class is used to explicitly ignore values in the conditional
+// logging macros.  This avoids compiler warnings like "value computed
+// is not used" and "statement has no effect".
+
+class LogMessageVoidify {
+ public:
+  LogMessageVoidify() { }
+  // This has to be an operator with a precedence lower than << but
+  // higher than ?:
+  void operator&(const LogMessage&) { }
+};
+
+#define CHECK(cond) CRASH_UNLESS(cond)
+#define CHECK_LE(a, b) CRASH_UNLESS((a) <= (b))
+#define CHECK_GE(a, b) CRASH_UNLESS((a) >= (b))
+#define CHECK_EQ(a, b) CRASH_UNLESS((a) == (b))
+#define CHECK_NE(a, b) CRASH_UNLESS((a) != (b))
+#define CHECK_LT(a, b) CRASH_UNLESS((a) < (b))
+#define CHECK_GT(a, b) CRASH_UNLESS((a) > (b))
+
+#ifdef NDEBUG
+
+#define DCHECK(cond) CRASH_UNLESS(true)
+#define DCHECK_LE(a, b) CRASH_UNLESS(true)
+#define DCHECK_GE(a, b) CRASH_UNLESS(true)
+#define DCHECK_EQ(a, b) CRASH_UNLESS(true)
+#define DCHECK_NE(a, b) CRASH_UNLESS(true)
+#define DCHECK_LT(a, b) CRASH_UNLESS(true)
+#define DCHECK_GT(a, b) CRASH_UNLESS(true)
+
+#else
+
+#define DCHECK(cond) CHECK(cond)
+#define DCHECK_LE(a, b) CHECK_LE(a, b)
+#define DCHECK_GE(a, b) CHECK_GE(a, b)
+#define DCHECK_EQ(a, b) CHECK_EQ(a, b)
+#define DCHECK_NE(a, b) CHECK_NE(a, b)
+#define DCHECK_LT(a, b) CHECK_LT(a, b)
+#define DCHECK_GT(a, b) CHECK_GT(a, b)
+
+#endif
+
+// Potentially unaligned loads and stores.
+
+#if defined(__i386__) || defined(__x86_64__) || defined(__powerpc__)
+
+#define UNALIGNED_LOAD16(_p) (*reinterpret_cast<const uint16 *>(_p))
+#define UNALIGNED_LOAD32(_p) (*reinterpret_cast<const uint32 *>(_p))
+#define UNALIGNED_LOAD64(_p) (*reinterpret_cast<const uint64 *>(_p))
+
+#define UNALIGNED_STORE16(_p, _val) (*reinterpret_cast<uint16 *>(_p) = (_val))
+#define UNALIGNED_STORE32(_p, _val) (*reinterpret_cast<uint32 *>(_p) = (_val))
+#define UNALIGNED_STORE64(_p, _val) (*reinterpret_cast<uint64 *>(_p) = (_val))
+
+#else
+
+// These functions are provided for architectures that don't support
+// unaligned loads and stores.
+
+inline uint16 UNALIGNED_LOAD16(const void *p) {
+  uint16 t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint32 UNALIGNED_LOAD32(const void *p) {
+  uint32 t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint64 UNALIGNED_LOAD64(const void *p) {
+  uint64 t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline void UNALIGNED_STORE16(void *p, uint16 v) {
+  memcpy(p, &v, sizeof v);
+}
+
+inline void UNALIGNED_STORE32(void *p, uint32 v) {
+  memcpy(p, &v, sizeof v);
+}
+
+inline void UNALIGNED_STORE64(void *p, uint64 v) {
+  memcpy(p, &v, sizeof v);
+}
+
+#endif
+
+// The following guarantees declaration of the byte swap functions.
+#ifdef WORDS_BIGENDIAN
+
+#ifdef _MSC_VER
+#include <stdlib.h>
+#define bswap_16(x) _byteswap_ushort(x)
+#define bswap_32(x) _byteswap_ulong(x)
+#define bswap_64(x) _byteswap_uint64(x)
+
+#elif defined(__APPLE__)
+// Mac OS X / Darwin features
+#include <libkern/OSByteOrder.h>
+#define bswap_16(x) OSSwapInt16(x)
+#define bswap_32(x) OSSwapInt32(x)
+#define bswap_64(x) OSSwapInt64(x)
+
+#else
+#include <byteswap.h>
+#endif
+
+#endif  // WORDS_BIGENDIAN
+
+// Convert to little-endian storage, opposite of network format.
+// Convert x from host to little endian: x = LittleEndian.FromHost(x);
+// convert x from little endian to host: x = LittleEndian.ToHost(x);
+//
+//  Store values into unaligned memory converting to little endian order:
+//    LittleEndian.Store16(p, x);
+//
+//  Load unaligned values stored in little endian converting to host order:
+//    x = LittleEndian.Load16(p);
+class LittleEndian {
+ public:
+  // Conversion functions.
+#ifdef WORDS_BIGENDIAN
+
+  static uint16 FromHost16(uint16 x) { return bswap_16(x); }
+  static uint16 ToHost16(uint16 x) { return bswap_16(x); }
+
+  static uint32 FromHost32(uint32 x) { return bswap_32(x); }
+  static uint32 ToHost32(uint32 x) { return bswap_32(x); }
+
+  static bool IsLittleEndian() { return false; }
+
+#else  // !defined(WORDS_BIGENDIAN)
+
+  static uint16 FromHost16(uint16 x) { return x; }
+  static uint16 ToHost16(uint16 x) { return x; }
+
+  static uint32 FromHost32(uint32 x) { return x; }
+  static uint32 ToHost32(uint32 x) { return x; }
+
+  static bool IsLittleEndian() { return true; }
+
+#endif  // !defined(WORDS_BIGENDIAN)
+
+  // Functions to do unaligned loads and stores in little-endian order.
+  static uint16 Load16(const void *p) {
+    return ToHost16(UNALIGNED_LOAD16(p));
+  }
+
+  static void Store16(void *p, uint16 v) {
+    UNALIGNED_STORE16(p, FromHost16(v));
+  }
+
+  static uint32 Load32(const void *p) {
+    return ToHost32(UNALIGNED_LOAD32(p));
+  }
+
+  static void Store32(void *p, uint32 v) {
+    UNALIGNED_STORE32(p, FromHost32(v));
+  }
+};
+
+// Some bit-manipulation functions.
+class Bits {
+ public:
+  // Return floor(log2(n)) for positive integer n.  Returns -1 iff n == 0.
+  static int Log2Floor(uint32 n);
+
+  // Return the first set least / most significant bit, 0-indexed.  Returns an
+  // undefined value if n == 0.  FindLSBSetNonZero() is similar to ffs() except
+  // that it's 0-indexed.
+  static int FindLSBSetNonZero(uint32 n);
+  static int FindLSBSetNonZero64(uint64 n);
+
+ private:
+  SNAPPY_DISALLOW_COPY_AND_ASSIGN(Bits);
+};
+
+#ifdef HAVE_BUILTIN_CTZ
+
+inline int Bits::Log2Floor(uint32 n) {
+  return n == 0 ? -1 : 31 ^ __builtin_clz(n);
+}
+
+inline int Bits::FindLSBSetNonZero(uint32 n) {
+  return __builtin_ctz(n);
+}
+
+inline int Bits::FindLSBSetNonZero64(uint64 n) {
+  return __builtin_ctzll(n);
+}
+
+#else  // Portable versions.
+
+inline int Bits::Log2Floor(uint32 n) {
+  if (n == 0)
+    return -1;
+  int log = 0;
+  uint32 value = n;
+  for (int i = 4; i >= 0; --i) {
+    int shift = (1 << i);
+    uint32 x = value >> shift;
+    if (x != 0) {
+      value = x;
+      log += shift;
+    }
+  }
+  assert(value == 1);
+  return log;
+}
+
+inline int Bits::FindLSBSetNonZero(uint32 n) {
+  int rc = 31;
+  for (int i = 4, shift = 1 << 4; i >= 0; --i) {
+    const uint32 x = n << shift;
+    if (x != 0) {
+      n = x;
+      rc -= shift;
+    }
+    shift >>= 1;
+  }
+  return rc;
+}
+
+// FindLSBSetNonZero64() is defined in terms of FindLSBSetNonZero().
+inline int Bits::FindLSBSetNonZero64(uint64 n) {
+  const uint32 bottombits = static_cast<uint32>(n);
+  if (bottombits == 0) {
+    // Bottom bits are zero, so scan in top bits
+    return 32 + FindLSBSetNonZero(static_cast<uint32>(n >> 32));
+  } else {
+    return FindLSBSetNonZero(bottombits);
+  }
+}
+
+#endif  // End portable versions.
+
+// Variable-length integer encoding.
+class Varint {
+ public:
+  // Maximum lengths of varint encoding of uint32.
+  static const int kMax32 = 5;
+
+  // Attempts to parse a varint32 from a prefix of the bytes in [ptr,limit-1].
+  // Never reads a character at or beyond limit.  If a valid/terminated varint32
+  // was found in the range, stores it in *OUTPUT and returns a pointer just
+  // past the last byte of the varint32. Else returns NULL.  On success,
+  // "result <= limit".
+  static const char* Parse32WithLimit(const char* ptr, const char* limit,
+                                      uint32* OUTPUT);
+
+  // REQUIRES   "ptr" points to a buffer of length sufficient to hold "v".
+  // EFFECTS    Encodes "v" into "ptr" and returns a pointer to the
+  //            byte just past the last encoded byte.
+  static char* Encode32(char* ptr, uint32 v);
+
+  // EFFECTS    Appends the varint representation of "value" to "*s".
+  static void Append32(string* s, uint32 value);
+};
+
+inline const char* Varint::Parse32WithLimit(const char* p,
+                                            const char* l,
+                                            uint32* OUTPUT) {
+  const unsigned char* ptr = reinterpret_cast<const unsigned char*>(p);
+  const unsigned char* limit = reinterpret_cast<const unsigned char*>(l);
+  uint32 b, result;
+  if (ptr >= limit) return NULL;
+  b = *(ptr++); result = b & 127;          if (b < 128) goto done;
+  if (ptr >= limit) return NULL;
+  b = *(ptr++); result |= (b & 127) <<  7; if (b < 128) goto done;
+  if (ptr >= limit) return NULL;
+  b = *(ptr++); result |= (b & 127) << 14; if (b < 128) goto done;
+  if (ptr >= limit) return NULL;
+  b = *(ptr++); result |= (b & 127) << 21; if (b < 128) goto done;
+  if (ptr >= limit) return NULL;
+  b = *(ptr++); result |= (b & 127) << 28; if (b < 16) goto done;
+  return NULL;       // Value is too long to be a varint32
+ done:
+  *OUTPUT = result;
+  return reinterpret_cast<const char*>(ptr);
+}
+
+inline char* Varint::Encode32(char* sptr, uint32 v) {
+  // Operate on characters as unsigneds
+  unsigned char* ptr = reinterpret_cast<unsigned char*>(sptr);
+  static const int B = 128;
+  if (v < (1<<7)) {
+    *(ptr++) = v;
+  } else if (v < (1<<14)) {
+    *(ptr++) = v | B;
+    *(ptr++) = v>>7;
+  } else if (v < (1<<21)) {
+    *(ptr++) = v | B;
+    *(ptr++) = (v>>7) | B;
+    *(ptr++) = v>>14;
+  } else if (v < (1<<28)) {
+    *(ptr++) = v | B;
+    *(ptr++) = (v>>7) | B;
+    *(ptr++) = (v>>14) | B;
+    *(ptr++) = v>>21;
+  } else {
+    *(ptr++) = v | B;
+    *(ptr++) = (v>>7) | B;
+    *(ptr++) = (v>>14) | B;
+    *(ptr++) = (v>>21) | B;
+    *(ptr++) = v>>28;
+  }
+  return reinterpret_cast<char*>(ptr);
+}
+
+// If you know the internal layout of the std::string in use, you can
+// replace this function with one that resizes the string without
+// filling the new space with zeros (if applicable) --
+// it will be non-portable but faster.
+inline void STLStringResizeUninitialized(string* s, size_t new_size) {
+  s->resize(new_size);
+}
+
+// Return a mutable char* pointing to a string's internal buffer,
+// which may not be null-terminated. Writing through this pointer will
+// modify the string.
+//
+// string_as_array(&str)[i] is valid for 0 <= i < str.size() until the
+// next call to a string method that invalidates iterators.
+//
+// As of 2006-04, there is no standard-blessed way of getting a
+// mutable reference to a string's internal buffer. However, issue 530
+// (http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-defects.html#530)
+// proposes this as the method. It will officially be part of the standard
+// for C++0x. This should already work on all current implementations.
+inline char* string_as_array(string* str) {
+  return str->empty() ? NULL : &*str->begin();
+}
+
+}  // namespace snappy
+
+#endif  // UTIL_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_

mp/src/tier1/sparsematrix.cpp

@@ -0,0 +1,141 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//===========================================================================//
+
+#include "tier1/sparsematrix.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+void CSparseMatrix::AdjustAllRowIndicesAfter( int nStartRow, int nDelta )
+{
+	// now, we need to offset the starting position of all subsequent rows by -1 to compensate for the removal of this element
+	for( int nOtherRow = nStartRow + 1 ; nOtherRow < Height(); nOtherRow++ )
+	{
+		m_rowDescriptors[nOtherRow].m_nDataIndex += nDelta;
+	}
+}
+
+void CSparseMatrix::SetDimensions( int nNumRows, int nNumCols )
+{
+	m_nNumRows = nNumRows;
+	m_nNumCols = nNumCols;
+	m_entries.SetCount( 0 );
+	m_rowDescriptors.SetCount( m_nNumRows );
+	// and set all rows to be empty
+	for( int i = 0; i < m_nNumRows; i++ )
+	{
+		m_rowDescriptors[i].m_nNonZeroCount = 0;
+		m_rowDescriptors[i].m_nDataIndex = 0;
+	}
+	m_nHighestRowAppendedTo = -1;
+
+}
+
+
+void CSparseMatrix::SetElement( int nRow, int nCol, float flValue ) 
+{
+	Assert( nCol < m_nNumCols );
+	int nCount = m_rowDescriptors[nRow].m_nNonZeroCount;
+	bool bValueIsZero = ( flValue == 0.0 );
+	int nFirstEntryIndex = m_rowDescriptors[nRow].m_nDataIndex;
+	if ( nCount )
+	{
+		NonZeroValueDescriptor_t *pValue = &( m_entries[nFirstEntryIndex] );
+		int i;
+		for( i = 0; i < nCount; i++ )
+		{
+			int nIdx = pValue->m_nColumnNumber;
+			if ( nIdx == nCol )								// we found it!
+			{
+				if ( !bValueIsZero )
+				{
+					// we want to overwrite the existing value
+					pValue->m_flValue = flValue;
+				}
+				else
+				{
+					// there is a non-zero element currently at this position. We need to remove it
+					// and we need to remove its storage.
+					m_rowDescriptors[nRow].m_nNonZeroCount--;
+					m_entries.Remove( nFirstEntryIndex + i );
+					// now, we need to offset the starting position of all subsequent rows by -1 to compensate for the removal of this element
+					AdjustAllRowIndicesAfter( nRow, -1 );
+				}
+				return;
+			}
+			if ( nIdx > nCol )
+			{
+				break;
+			}
+			pValue++;
+		}
+		// we did not find an entry for this cell. If we were writing zero, fine - we are
+		// done, otherwise insert
+		if (! bValueIsZero )
+		{
+			m_rowDescriptors[nRow].m_nNonZeroCount++;
+			NonZeroValueDescriptor_t newValue;
+			newValue.m_nColumnNumber = nCol;
+			newValue.m_flValue = flValue;
+			if ( i == nCount )								// need to append
+			{
+				m_entries.InsertAfter( nFirstEntryIndex + nCount - 1, newValue );
+			}
+			else
+			{
+				m_entries.InsertBefore( nFirstEntryIndex + i, newValue );
+			}
+			// now, we need to offset the starting position of all subsequent rows by -1 to compensate for the addition of this element
+			AdjustAllRowIndicesAfter( nRow, +1 );
+		}
+	}
+	else
+	{
+		// row is empty. We may need to insert
+		if ( ! bValueIsZero )
+		{
+			m_rowDescriptors[nRow].m_nNonZeroCount++;
+			NonZeroValueDescriptor_t newValue;
+			newValue.m_nColumnNumber = nCol;
+			newValue.m_flValue = flValue;
+			m_entries.InsertBefore( nFirstEntryIndex, newValue );
+			AdjustAllRowIndicesAfter( nRow, +1 );
+		}
+	}
+}
+
+void CSparseMatrix::FinishedAppending( void )
+{
+	// set all pointers to space for subsequent rows to the right value
+	for( int i = m_nHighestRowAppendedTo + 1 ; i < Height(); i++ )
+	{
+		m_rowDescriptors[i].m_nDataIndex = m_entries.Count();
+	}
+}
+
+void CSparseMatrix::AppendElement( int nRow, int nColumn, float flValue )
+{
+	if ( flValue != 0.0 )
+	{
+		if ( m_nHighestRowAppendedTo != nRow )
+		{
+			Assert( nRow > m_nHighestRowAppendedTo );
+			for( int i = m_nHighestRowAppendedTo + 1; i <= nRow; i++ )
+			{
+				m_rowDescriptors[i].m_nDataIndex = m_entries.Count();
+			}
+		}
+		m_nHighestRowAppendedTo = nRow;
+		m_rowDescriptors[nRow].m_nNonZeroCount++;
+		NonZeroValueDescriptor_t newDesc;
+		newDesc.m_nColumnNumber = nColumn;
+		newDesc.m_flValue = flValue;
+		m_entries.AddToTail( newDesc );
+	}
+}
+	
+	
+
+

mp/src/tier1/splitstring.cpp

@@ -0,0 +1,91 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//
+//
+//==================================================================================================
+
+#include "strtools.h"
+#include "utlvector.h"
+
+CSplitString::CSplitString(const char *pString, const char **pSeparators, int nSeparators)
+{
+	Construct(pString, pSeparators, nSeparators);
+};
+
+CSplitString::CSplitString( const char *pString, const char *pSeparator)
+{
+	Construct( pString, &pSeparator, 1 );
+}
+
+CSplitString::~CSplitString()
+{
+	if(m_szBuffer)
+		delete [] m_szBuffer;
+}
+
+void CSplitString::Construct( const char *pString, const char **pSeparators, int nSeparators )
+{
+	//////////////////////////////////////////////////////////////////////////
+	// make a duplicate of the original string. We'll use pieces of this duplicate to tokenize the string
+	// and create NULL-terminated tokens of the original string
+	//
+	int nOriginalStringLength = V_strlen(pString);
+	m_szBuffer = new char[nOriginalStringLength + 1];
+	memcpy(m_szBuffer, pString, nOriginalStringLength + 1);
+
+	this->Purge();
+	const char *pCurPos = pString;
+	while ( 1 )
+	{
+		int iFirstSeparator = -1;
+		const char *pFirstSeparator = 0;
+		for ( int i=0; i < nSeparators; i++ )
+		{
+			const char *pTest = V_stristr( pCurPos, pSeparators[i] );
+			if ( pTest && (!pFirstSeparator || pTest < pFirstSeparator) )
+			{
+				iFirstSeparator = i;
+				pFirstSeparator = pTest;
+			}
+		}
+
+		if ( pFirstSeparator )
+		{
+			// Split on this separator and continue on.
+			int separatorLen = strlen( pSeparators[iFirstSeparator] );
+			if ( pFirstSeparator > pCurPos )
+			{
+				//////////////////////////////////////////////////////////////////////////
+				/// Cut the token out of the duplicate string
+				char *pTokenInDuplicate = m_szBuffer + (pCurPos - pString);
+				int nTokenLength = pFirstSeparator-pCurPos;
+				Assert(nTokenLength > 0 && !memcmp(pTokenInDuplicate,pCurPos,nTokenLength));
+				pTokenInDuplicate[nTokenLength] = '\0';
+
+				this->AddToTail( pTokenInDuplicate /*AllocString( pCurPos, pFirstSeparator-pCurPos )*/ );
+			}
+
+			pCurPos = pFirstSeparator + separatorLen;
+		}
+		else
+		{
+			// Copy the rest of the string
+			if ( int nTokenLength = strlen( pCurPos ) )
+			{
+				//////////////////////////////////////////////////////////////////////////
+				// There's no need to cut this token, because there's no separator after it.
+				// just add its copy in the buffer to the tail
+				char *pTokenInDuplicate = m_szBuffer + (pCurPos - pString);
+				Assert(!memcmp(pTokenInDuplicate, pCurPos, nTokenLength));
+
+				this->AddToTail( pTokenInDuplicate/*AllocString( pCurPos, -1 )*/ );
+			}
+			return;
+		}
+	}
+}
+
+void CSplitString::PurgeAndDeleteElements()
+{
+	Purge();
+}

mp/src/tier1/stringpool.cpp

@@ -0,0 +1,334 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//===========================================================================//
+
+#include "convar.h"
+#include "tier0/dbg.h"
+#include "stringpool.h"
+#include "tier1/strtools.h"
+#include "generichash.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Comparison function for string sorted associative data structures
+//-----------------------------------------------------------------------------
+
+bool StrLess( const char * const &pszLeft, const char * const &pszRight )
+{
+	return ( Q_stricmp( pszLeft, pszRight) < 0 );
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+CStringPool::CStringPool()
+  : m_Strings( 32, 256, StrLess )
+{
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+CStringPool::~CStringPool()
+{
+	FreeAll();
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+unsigned int CStringPool::Count() const
+{
+	return m_Strings.Count();
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+const char * CStringPool::Find( const char *pszValue )
+{
+	unsigned short i = m_Strings.Find(pszValue);
+	if ( m_Strings.IsValidIndex(i) )
+		return m_Strings[i];
+
+	return NULL;
+}
+
+const char * CStringPool::Allocate( const char *pszValue )
+{
+	char	*pszNew;
+
+	unsigned short i 	= m_Strings.Find(pszValue);
+	bool		   bNew = (i == m_Strings.InvalidIndex());
+
+	if ( !bNew )
+		return m_Strings[i];
+
+	pszNew = strdup( pszValue );
+
+	if ( bNew )
+		m_Strings.Insert( pszNew );
+
+	return pszNew;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+void CStringPool::FreeAll()
+{
+	unsigned short i = m_Strings.FirstInorder();
+	while ( i != m_Strings.InvalidIndex() )
+	{
+		free( (void *)m_Strings[i] );
+		i = m_Strings.NextInorder(i);
+	}
+	m_Strings.RemoveAll();
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+
+CCountedStringPool::CCountedStringPool()
+{
+	MEM_ALLOC_CREDIT();
+	m_HashTable.EnsureCount(HASH_TABLE_SIZE);
+
+	for( int i = 0; i < m_HashTable.Count(); i++ )
+	{
+		m_HashTable[i] = INVALID_ELEMENT;		
+	}
+
+	m_FreeListStart = INVALID_ELEMENT;
+	m_Elements.AddToTail();
+	m_Elements[0].pString = NULL;
+	m_Elements[0].nReferenceCount = 0;
+	m_Elements[0].nNextElement = INVALID_ELEMENT;
+}
+
+CCountedStringPool::~CCountedStringPool()
+{
+	FreeAll();
+}
+
+void CCountedStringPool::FreeAll()
+{
+	int i;
+
+	// Reset the hash table:
+	for( i = 0; i < m_HashTable.Count(); i++ )
+	{
+		m_HashTable[i] = INVALID_ELEMENT;		
+	}
+
+	// Blow away the free list:
+	m_FreeListStart = INVALID_ELEMENT;
+
+	for( i = 0; i < m_Elements.Count(); i++ )
+	{
+		if( m_Elements[i].pString )
+		{
+			delete [] m_Elements[i].pString;
+			m_Elements[i].pString = NULL;
+			m_Elements[i].nReferenceCount = 0;
+			m_Elements[i].nNextElement = INVALID_ELEMENT;
+		}
+	}
+
+	// Remove all but the invalid element:
+	m_Elements.RemoveAll();
+	m_Elements.AddToTail();
+	m_Elements[0].pString = NULL;
+	m_Elements[0].nReferenceCount = 0;
+	m_Elements[0].nNextElement = INVALID_ELEMENT;
+}
+
+
+unsigned short CCountedStringPool::FindStringHandle( const char* pIntrinsic )
+{
+	if( pIntrinsic == NULL )
+		return INVALID_ELEMENT;
+
+	unsigned short nHashBucketIndex = (HashStringCaseless(pIntrinsic ) %HASH_TABLE_SIZE);
+	unsigned short nCurrentBucket = m_HashTable[ nHashBucketIndex ];
+
+	// Does the bucket already exist?
+	if( nCurrentBucket != INVALID_ELEMENT  )
+	{
+		for( ; nCurrentBucket != INVALID_ELEMENT  ; nCurrentBucket = m_Elements[nCurrentBucket].nNextElement )
+		{
+			if( !Q_stricmp( pIntrinsic, m_Elements[nCurrentBucket].pString ) )
+			{
+				return nCurrentBucket;
+			}
+		}
+	}
+	
+	return 0;
+
+}
+
+char* CCountedStringPool::FindString( const char* pIntrinsic )
+{
+	if( pIntrinsic == NULL )
+		return NULL;
+
+	// Yes, this will be NULL on failure.
+	return m_Elements[FindStringHandle(pIntrinsic)].pString;
+}
+
+unsigned short CCountedStringPool::ReferenceStringHandle( const char* pIntrinsic )
+{
+	if( pIntrinsic == NULL )
+		return INVALID_ELEMENT;
+
+	unsigned short nHashBucketIndex = (HashStringCaseless( pIntrinsic ) % HASH_TABLE_SIZE);
+	unsigned short nCurrentBucket =  m_HashTable[ nHashBucketIndex ];
+
+	// Does the bucket already exist?
+	if( nCurrentBucket != INVALID_ELEMENT )
+	{
+		for( ; nCurrentBucket != INVALID_ELEMENT ; nCurrentBucket = m_Elements[nCurrentBucket].nNextElement )
+		{
+			if( !Q_stricmp( pIntrinsic, m_Elements[nCurrentBucket].pString ) )
+			{
+				// Anyone who hits 65k references is permanant
+				if( m_Elements[nCurrentBucket].nReferenceCount < MAX_REFERENCE )
+				{
+					m_Elements[nCurrentBucket].nReferenceCount ++ ;
+				}
+				return nCurrentBucket;
+			}
+		}
+	}
+
+	if( m_FreeListStart != INVALID_ELEMENT )
+	{
+		nCurrentBucket = m_FreeListStart;
+		m_FreeListStart = m_Elements[nCurrentBucket].nNextElement;
+	}
+	else
+	{
+		nCurrentBucket = m_Elements.AddToTail();
+	}
+
+	m_Elements[nCurrentBucket].nReferenceCount = 1;
+
+	// Insert at the beginning of the bucket:
+	m_Elements[nCurrentBucket].nNextElement = m_HashTable[ nHashBucketIndex ];
+	m_HashTable[ nHashBucketIndex ] = nCurrentBucket;
+
+	m_Elements[nCurrentBucket].pString = new char[Q_strlen( pIntrinsic ) + 1];
+	Q_strcpy( m_Elements[nCurrentBucket].pString, pIntrinsic );
+	
+    return nCurrentBucket;
+}
+
+
+char* CCountedStringPool::ReferenceString( const char* pIntrinsic )
+{
+	if(!pIntrinsic)
+		return NULL;
+
+	return m_Elements[ReferenceStringHandle( pIntrinsic)].pString; 
+}
+
+void CCountedStringPool::DereferenceString( const char* pIntrinsic )
+{
+	// If we get a NULL pointer, just return
+	if (!pIntrinsic)
+		return;
+
+	unsigned short nHashBucketIndex = (HashStringCaseless( pIntrinsic ) % m_HashTable.Count());
+	unsigned short nCurrentBucket =  m_HashTable[ nHashBucketIndex ];
+
+	// If there isn't anything in the bucket, just return.
+	if ( nCurrentBucket == INVALID_ELEMENT )
+		return;
+
+	for( unsigned short previous = INVALID_ELEMENT; nCurrentBucket != INVALID_ELEMENT ; nCurrentBucket = m_Elements[nCurrentBucket].nNextElement )
+	{
+		if( !Q_stricmp( pIntrinsic, m_Elements[nCurrentBucket].pString ) )
+		{
+			// Anyone who hits 65k references is permanant
+			if( m_Elements[nCurrentBucket].nReferenceCount < MAX_REFERENCE )
+			{
+				m_Elements[nCurrentBucket].nReferenceCount --;
+			}
+
+			if( m_Elements[nCurrentBucket].nReferenceCount == 0 )
+			{
+				if( previous == INVALID_ELEMENT )
+				{
+					m_HashTable[nHashBucketIndex] = m_Elements[nCurrentBucket].nNextElement;
+				}
+				else
+				{
+					m_Elements[previous].nNextElement = m_Elements[nCurrentBucket].nNextElement;
+				}
+
+				delete [] m_Elements[nCurrentBucket].pString;
+				m_Elements[nCurrentBucket].pString = NULL;
+				m_Elements[nCurrentBucket].nReferenceCount = 0;
+
+				m_Elements[nCurrentBucket].nNextElement = m_FreeListStart;
+				m_FreeListStart = nCurrentBucket;
+				break;
+
+			}
+		}
+
+		previous = nCurrentBucket;
+	}
+}
+
+char* CCountedStringPool::HandleToString( unsigned short handle )
+{
+	return m_Elements[handle].pString;
+}
+
+void CCountedStringPool::SpewStrings()
+{
+	int i;
+	for ( i = 0; i < m_Elements.Count(); i++ )
+	{
+		char* string = m_Elements[i].pString;
+
+		Msg("String %d: ref:%d %s", i, m_Elements[i].nReferenceCount, string == NULL? "EMPTY - ok for slot zero only!" : string);
+	}
+
+	Msg("\n%d total counted strings.", m_Elements.Count());
+}
+
+#ifdef _DEBUG
+CON_COMMAND( test_stringpool, "Tests the class CStringPool" )
+{
+	CStringPool pool;
+
+	Assert(pool.Count() == 0);
+
+	pool.Allocate("test");
+	Assert(pool.Count() == 1);
+
+	pool.Allocate("test");
+	Assert(pool.Count() == 1);
+
+	pool.Allocate("test2");
+	Assert(pool.Count() == 2);
+
+	Assert( pool.Find("test2") != NULL );
+	Assert( pool.Find("TEST") != NULL );
+	Assert( pool.Find("Test2") != NULL );
+	Assert( pool.Find("test") != NULL );
+
+	pool.FreeAll();
+	Assert(pool.Count() == 0);
+
+	Msg("Pass.");
+}
+#endif

mp/src/tier1/tier1-2010.vcxproj

@@ -0,0 +1,287 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.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="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectName>tier1</ProjectName>
+    <ProjectGuid>{EC1C516D-E1D9-BC0A-F79D-E91E954ED8EC}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <TargetName>tier1</TargetName>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <TargetName>tier1</TargetName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </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)'=='Release|Win32'" 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.30319.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">..\lib\public\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\Debug\win32\</IntDir>
+    <ExecutablePath Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">..\devtools\vstools;$(ExecutablePath);$(Path)</ExecutablePath>
+    <PreBuildEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</PreBuildEventUseInBuild>
+    <PreLinkEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</PreLinkEventUseInBuild>
+    <PostBuildEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</PostBuildEventUseInBuild>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">..\lib\public\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\Release\win32\</IntDir>
+    <ExecutablePath Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">..\devtools\vstools;$(ExecutablePath);$(Path)</ExecutablePath>
+    <PreBuildEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</PreBuildEventUseInBuild>
+    <PreLinkEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</PreLinkEventUseInBuild>
+    <PostBuildEventUseInBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</PostBuildEventUseInBuild>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <PreBuildEvent>
+    </PreBuildEvent>
+    <ClCompile>
+      <AdditionalOptions> /MP</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>..\common;..\public;..\public\tier0;..\public\tier1</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>_HAS_ITERATOR_DEBUGGING=0;WIN32;_WIN32;_DEBUG;DEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;COMPILER_MSVC32;LIBNAME=tier1;RAD_TELEMETRY_DISABLED;BINK_VIDEO;AVI_VIDEO;WMV_VIDEO;TIER1_STATIC_LIB;VPCGAMECAPS=VALVE;PROJECTDIR=D:\dev\games\rel\hl2\src\tier1;_DLL_EXT=.dll;VPCGAME=valve</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <ExceptionHandling>false</ExceptionHandling>
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <BufferSecurityCheck>true</BufferSecurityCheck>
+      <EnableEnhancedInstructionSet>StreamingSIMDExtensions</EnableEnhancedInstructionSet>
+      <FloatingPointModel>Fast</FloatingPointModel>
+      <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
+      <ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope>
+      <RuntimeTypeInfo>true</RuntimeTypeInfo>
+      <OpenMPSupport>false</OpenMPSupport>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <ExpandAttributedSource>false</ExpandAttributedSource>
+      <AssemblerOutput>NoListing</AssemblerOutput>
+      <AssemblerListingLocation>$(IntDir)/</AssemblerListingLocation>
+      <ObjectFileName>$(IntDir)/</ObjectFileName>
+      <ProgramDataBaseFileName>$(IntDir)/</ProgramDataBaseFileName>
+      <GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
+      <BrowseInformation>false</BrowseInformation>
+      <WarningLevel>Level4</WarningLevel>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+      <CompileAs>CompileAsCpp</CompileAs>
+      <BrowseInformationFile>$(IntDir)/</BrowseInformationFile>
+      <ErrorReporting>Prompt</ErrorReporting>
+    </ClCompile>
+    <PreLinkEvent>
+    </PreLinkEvent>
+    <Lib>
+      <UseUnicodeResponseFiles>false</UseUnicodeResponseFiles>
+      <AdditionalDependencies>;Rpcrt4.lib</AdditionalDependencies>
+      <OutputFile>..\lib\public\tier1.lib</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <LinkLibraryDependencies>false</LinkLibraryDependencies>
+      <AdditionalOptions> /ignore:4221</AdditionalOptions>
+    </Lib>
+    <Xdcmake>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+    </Xdcmake>
+    <Bscmake>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <OutputFile>$(OutDir)/tier1.bsc</OutputFile>
+    </Bscmake>
+    <PostBuildEvent>
+    </PostBuildEvent>
+    <CustomBuildStep>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <PreBuildEvent>
+    </PreBuildEvent>
+    <ClCompile>
+      <AdditionalOptions> /MP /d2Zi+</AdditionalOptions>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <AdditionalIncludeDirectories>..\common;..\public;..\public\tier0;..\public\tier1</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;COMPILER_MSVC32;LIBNAME=tier1;RAD_TELEMETRY_DISABLED;BINK_VIDEO;AVI_VIDEO;WMV_VIDEO;TIER1_STATIC_LIB;VPCGAMECAPS=VALVE;PROJECTDIR=D:\dev\games\rel\hl2\src\tier1;_DLL_EXT=.dll;VPCGAME=valve</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <ExceptionHandling>false</ExceptionHandling>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <EnableEnhancedInstructionSet>StreamingSIMDExtensions</EnableEnhancedInstructionSet>
+      <FloatingPointModel>Fast</FloatingPointModel>
+      <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
+      <ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope>
+      <RuntimeTypeInfo>true</RuntimeTypeInfo>
+      <OpenMPSupport>false</OpenMPSupport>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <ExpandAttributedSource>false</ExpandAttributedSource>
+      <AssemblerOutput>NoListing</AssemblerOutput>
+      <AssemblerListingLocation>$(IntDir)/</AssemblerListingLocation>
+      <ObjectFileName>$(IntDir)/</ObjectFileName>
+      <ProgramDataBaseFileName>$(IntDir)/</ProgramDataBaseFileName>
+      <GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
+      <BrowseInformation>false</BrowseInformation>
+      <WarningLevel>Level4</WarningLevel>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <CompileAs>CompileAsCpp</CompileAs>
+      <BrowseInformationFile>$(IntDir)/</BrowseInformationFile>
+      <ErrorReporting>Prompt</ErrorReporting>
+    </ClCompile>
+    <PreLinkEvent>
+    </PreLinkEvent>
+    <Lib>
+      <UseUnicodeResponseFiles>false</UseUnicodeResponseFiles>
+      <AdditionalDependencies>;Rpcrt4.lib</AdditionalDependencies>
+      <OutputFile>..\lib\public\tier1.lib</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <LinkLibraryDependencies>false</LinkLibraryDependencies>
+      <AdditionalOptions> /ignore:4221</AdditionalOptions>
+    </Lib>
+    <Xdcmake>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+    </Xdcmake>
+    <Bscmake>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <OutputFile>$(OutDir)/tier1.bsc</OutputFile>
+    </Bscmake>
+    <PostBuildEvent>
+    </PostBuildEvent>
+    <CustomBuildStep>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\public\tier1\bitbuf.h" />
+    <ClInclude Include="..\public\tier1\byteswap.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\checksum_sha1.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\ilocalize.h" />
+    <ClInclude Include="..\public\tier1\interface.h" />
+    <ClInclude Include="..\public\tier1\KeyValues.h" />
+    <ClInclude Include="..\public\tier1\kvpacker.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\snappy-sinksource.h" />
+    <ClInclude Include="..\public\tier1\snappy.h" />
+    <ClInclude Include="..\public\tier1\stringpool.h" />
+    <ClInclude Include="..\public\tier1\strtools.h" />
+    <ClInclude Include="..\public\tier1\tier1.h" />
+    <ClInclude Include="..\public\tier1\tokenreader.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\utlcommon.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\utlhashtable.h" />
+    <ClInclude Include="..\public\tier1\utllinkedlist.h" />
+    <ClInclude Include="..\public\tier1\utlmap.h" />
+    <ClInclude Include="..\public\tier1\utlmemory.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\utlstring.h" />
+    <ClInclude Include="..\public\tier1\UtlStringMap.h" />
+    <ClInclude Include="..\public\tier1\utlsymbol.h" />
+    <ClInclude Include="..\public\tier1\utlsymbollarge.h" />
+    <ClInclude Include="..\public\tier1\utlvector.h" />
+    <ClInclude Include="..\common\xbox\xboxstubs.h" />
+    <ClInclude Include="snappy-internal.h" />
+    <ClInclude Include="snappy-stubs-internal.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="bitbuf.cpp" />
+    <ClCompile Include="byteswap.cpp" />
+    <ClCompile Include="characterset.cpp" />
+    <ClCompile Include="checksum_crc.cpp" />
+    <ClCompile Include="checksum_md5.cpp" />
+    <ClCompile Include="checksum_sha1.cpp" />
+    <ClCompile Include="commandbuffer.cpp" />
+    <ClCompile Include="convar.cpp" />
+    <ClCompile Include="datamanager.cpp" />
+    <ClCompile Include="diff.cpp" />
+    <ClCompile Include="generichash.cpp" />
+    <ClCompile Include="ilocalize.cpp" />
+    <ClCompile Include="interface.cpp" />
+    <ClCompile Include="KeyValues.cpp" />
+    <ClCompile Include="kvpacker.cpp" />
+    <ClCompile Include="mempool.cpp" />
+    <ClCompile Include="memstack.cpp" />
+    <ClCompile Include="NetAdr.cpp" />
+    <ClCompile Include="newbitbuf.cpp" />
+    <ClCompile Include="processor_detect.cpp">
+      <ExceptionHandling Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Sync</ExceptionHandling>
+      <ExceptionHandling Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Sync</ExceptionHandling>
+    </ClCompile>
+    <ClCompile Include="rangecheckedvar.cpp" />
+    <ClCompile Include="reliabletimer.cpp" />
+    <ClCompile Include="snappy-sinksource.cpp" />
+    <ClCompile Include="snappy-stubs-internal.cpp" />
+    <ClCompile Include="snappy.cpp" />
+    <ClCompile Include="sparsematrix.cpp" />
+    <ClCompile Include="splitstring.cpp" />
+    <ClCompile Include="stringpool.cpp" />
+    <ClCompile Include="strtools.cpp" />
+    <ClCompile Include="tier1.cpp" />
+    <ClCompile Include="tokenreader.cpp" />
+    <ClCompile Include="uniqueid.cpp" />
+    <ClCompile Include="utlbuffer.cpp" />
+    <ClCompile Include="utlbufferutil.cpp" />
+    <ClCompile Include="utlstring.cpp" />
+    <ClCompile Include="utlsymbol.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+  </ItemGroup>
+  <ItemGroup>
+  </ItemGroup>
+  <ItemGroup>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

mp/src/tier1/tier1-2010.vcxproj.filters

@@ -0,0 +1,329 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{1680C80B-FF1E-EA4D-9817-CC12254F2E40}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Internal Header Files">
+      <UniqueIdentifier>{82D97A15-B2F0-1D81-D6D4-97637C1216E9}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{BA03E055-4FA2-FCE3-8A1C-D348547D379C}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\public\tier1\bitbuf.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\public\tier1\byteswap.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\checksum_sha1.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\ilocalize.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\public\tier1\interface.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\public\tier1\KeyValues.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\public\tier1\kvpacker.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\snappy-sinksource.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\public\tier1\snappy.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\tokenreader.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\utlcommon.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\utlhashtable.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\utlmemory.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\utlstring.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\utlsymbollarge.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>
+    <ClInclude Include="snappy-internal.h">
+      <Filter>Header Files\Internal Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="snappy-stubs-internal.h">
+      <Filter>Header Files\Internal Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="bitbuf.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="byteswap.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="characterset.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checksum_crc.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checksum_md5.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checksum_sha1.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="commandbuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="convar.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="datamanager.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="diff.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="generichash.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="ilocalize.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="interface.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="KeyValues.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="kvpacker.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="mempool.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="memstack.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="NetAdr.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="newbitbuf.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="processor_detect.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="rangecheckedvar.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="reliabletimer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="snappy-sinksource.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="snappy-stubs-internal.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="snappy.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="sparsematrix.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="splitstring.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="stringpool.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="strtools.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="tier1.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="tokenreader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="uniqueid.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="utlbuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="utlbufferutil.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="utlstring.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="utlsymbol.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+  </ItemGroup>
+  <ItemGroup>
+  </ItemGroup>
+  <ItemGroup>
+  </ItemGroup>
+</Project>

mp/src/tier1/tier1.cpp

@@ -0,0 +1,63 @@
+//========= Copyright 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 "vstdlib/iprocessutils.h"
+#include "icvar.h"
+
+
+//-----------------------------------------------------------------------------
+// These tier1 libraries must be set by any users of this library.
+// They can be set by calling ConnectTier1Libraries or InitDefaultFileSystem.
+// It is hoped that setting this, and using this library will be the common mechanism for
+// allowing link libraries to access tier1 library interfaces
+//-----------------------------------------------------------------------------
+ICvar *cvar = 0;
+ICvar *g_pCVar = 0;
+IProcessUtils *g_pProcessUtils = 0;
+static bool s_bConnected = false;
+
+// 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 )
+{
+	// Don't connect twice..
+	if ( s_bConnected )
+		return;
+
+	s_bConnected = true;
+
+	for ( int i = 0; i < nFactoryCount; ++i )
+	{
+		if ( !g_pCVar )
+		{
+			cvar = g_pCVar = ( ICvar * )pFactoryList[i]( CVAR_INTERFACE_VERSION, NULL );
+		}
+		if ( !g_pProcessUtils )
+		{
+			g_pProcessUtils = ( IProcessUtils * )pFactoryList[i]( PROCESS_UTILS_INTERFACE_VERSION, NULL );
+		}
+	}
+}
+
+void DisconnectTier1Libraries()
+{
+	if ( !s_bConnected )
+		return;
+
+	g_pCVar = cvar = 0;
+	g_pProcessUtils = NULL;
+	s_bConnected = false;
+}

mp/src/tier1/tier1_linux32.mak

@@ -0,0 +1,408 @@
+NAME=tier1
+SRCROOT=..
+TARGET_PLATFORM=linux32
+TARGET_PLATFORM_EXT=
+USE_VALVE_BINDIR=0
+PWD := $(shell pwd)
+# If no configuration is specified, "release" will be used.
+ifeq "$(CFG)" ""
+	CFG = release
+endif
+
+GCC_ExtraCompilerFlags= -U_FORTIFY_SOURCE
+GCC_ExtraLinkerFlags = 
+SymbolVisibility = hidden
+OptimizerLevel = -gdwarf-2 -g $(OptimizerLevel_CompilerSpecific)
+SystemLibraries = 
+DLL_EXT = .so
+SYM_EXT = .dbg
+FORCEINCLUDES= 
+ifeq "$(CFG)" "debug"
+DEFINES += -DDEBUG -D_DEBUG -DPOSIX -DGNUC -DLINUX -D_LINUX -DLIBNAME=tier1 -DRAD_TELEMETRY_DISABLED -DBINK_VIDEO -DGL_GLEXT_PROTOTYPES -DDX_TO_GL_ABSTRACTION -DUSE_SDL -DTIER1_STATIC_LIB -D_EXTERNAL_DLL_EXT=.so -DVPCGAMECAPS=VALVE -DPROJECTDIR=/home/VALVE/joe/p4clients/linuxsdk/hl2/src/tier1 -D_DLL_EXT=.so -DVPCGAME=valve -D_LINUX=1 -D_POSIX=1 -DLINUX=1 -DPOSIX=1 
+else
+DEFINES += -DNDEBUG -DPOSIX -DGNUC -DLINUX -D_LINUX -DLIBNAME=tier1 -DRAD_TELEMETRY_DISABLED -DBINK_VIDEO -DGL_GLEXT_PROTOTYPES -DDX_TO_GL_ABSTRACTION -DUSE_SDL -DTIER1_STATIC_LIB -D_EXTERNAL_DLL_EXT=.so -DVPCGAMECAPS=VALVE -DPROJECTDIR=/home/VALVE/joe/p4clients/linuxsdk/hl2/src/tier1 -D_DLL_EXT=.so -DVPCGAME=valve -D_LINUX=1 -D_POSIX=1 -DLINUX=1 -DPOSIX=1 
+endif
+INCLUDEDIRS += ../common ../public ../public/tier0 ../public/tier1 ../thirdparty/SDL2 
+CONFTYPE = lib
+OUTPUTFILE=../lib/public/linux32/tier1.a
+THIS_MAKEFILE = $(PWD)/tier1_linux32.mak
+MAKEFILE_BASE = $(SRCROOT)/devtools/makefile_base_posix.mak
+
+
+POSTBUILDCOMMAND = true
+
+
+
+CPPFILES= \
+    bitbuf.cpp \
+    byteswap.cpp \
+    characterset.cpp \
+    checksum_crc.cpp \
+    checksum_md5.cpp \
+    checksum_sha1.cpp \
+    commandbuffer.cpp \
+    convar.cpp \
+    datamanager.cpp \
+    diff.cpp \
+    generichash.cpp \
+    ilocalize.cpp \
+    interface.cpp \
+    KeyValues.cpp \
+    kvpacker.cpp \
+    mempool.cpp \
+    memstack.cpp \
+    NetAdr.cpp \
+    newbitbuf.cpp \
+    pathmatch.cpp \
+    processor_detect_linux.cpp \
+    qsort_s.cpp \
+    rangecheckedvar.cpp \
+    reliabletimer.cpp \
+    snappy-sinksource.cpp \
+    snappy-stubs-internal.cpp \
+    snappy.cpp \
+    sparsematrix.cpp \
+    splitstring.cpp \
+    stringpool.cpp \
+    strtools.cpp \
+    tier1.cpp \
+    tokenreader.cpp \
+    uniqueid.cpp \
+    utlbuffer.cpp \
+    utlbufferutil.cpp \
+    utlstring.cpp \
+    utlsymbol.cpp \
+
+
+LIBFILES = \
+
+
+LIBFILENAMES = \
+
+
+# Include the base makefile now.
+include $(SRCROOT)/devtools/makefile_base_posix.mak
+
+
+
+OTHER_DEPENDENCIES = \
+
+
+$(OBJ_DIR)/_other_deps.P : $(OTHER_DEPENDENCIES)
+	$(GEN_OTHER_DEPS)
+
+-include $(OBJ_DIR)/_other_deps.P
+
+
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/bitbuf.P
+endif
+
+$(OBJ_DIR)/bitbuf.o : $(PWD)/bitbuf.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/byteswap.P
+endif
+
+$(OBJ_DIR)/byteswap.o : $(PWD)/byteswap.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/characterset.P
+endif
+
+$(OBJ_DIR)/characterset.o : $(PWD)/characterset.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/checksum_crc.P
+endif
+
+$(OBJ_DIR)/checksum_crc.o : $(PWD)/checksum_crc.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/checksum_md5.P
+endif
+
+$(OBJ_DIR)/checksum_md5.o : $(PWD)/checksum_md5.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/checksum_sha1.P
+endif
+
+$(OBJ_DIR)/checksum_sha1.o : $(PWD)/checksum_sha1.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/commandbuffer.P
+endif
+
+$(OBJ_DIR)/commandbuffer.o : $(PWD)/commandbuffer.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/convar.P
+endif
+
+$(OBJ_DIR)/convar.o : $(PWD)/convar.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/datamanager.P
+endif
+
+$(OBJ_DIR)/datamanager.o : $(PWD)/datamanager.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/diff.P
+endif
+
+$(OBJ_DIR)/diff.o : $(PWD)/diff.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/generichash.P
+endif
+
+$(OBJ_DIR)/generichash.o : $(PWD)/generichash.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/ilocalize.P
+endif
+
+$(OBJ_DIR)/ilocalize.o : $(PWD)/ilocalize.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/interface.P
+endif
+
+$(OBJ_DIR)/interface.o : $(PWD)/interface.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/KeyValues.P
+endif
+
+$(OBJ_DIR)/KeyValues.o : $(PWD)/KeyValues.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/kvpacker.P
+endif
+
+$(OBJ_DIR)/kvpacker.o : $(PWD)/kvpacker.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/mempool.P
+endif
+
+$(OBJ_DIR)/mempool.o : $(PWD)/mempool.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/memstack.P
+endif
+
+$(OBJ_DIR)/memstack.o : $(PWD)/memstack.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/NetAdr.P
+endif
+
+$(OBJ_DIR)/NetAdr.o : $(PWD)/NetAdr.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/newbitbuf.P
+endif
+
+$(OBJ_DIR)/newbitbuf.o : $(PWD)/newbitbuf.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/pathmatch.P
+endif
+
+$(OBJ_DIR)/pathmatch.o : $(PWD)/pathmatch.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/processor_detect_linux.P
+endif
+
+$(OBJ_DIR)/processor_detect_linux.o : $(PWD)/processor_detect_linux.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/qsort_s.P
+endif
+
+$(OBJ_DIR)/qsort_s.o : $(PWD)/qsort_s.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/rangecheckedvar.P
+endif
+
+$(OBJ_DIR)/rangecheckedvar.o : $(PWD)/rangecheckedvar.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/reliabletimer.P
+endif
+
+$(OBJ_DIR)/reliabletimer.o : $(PWD)/reliabletimer.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/snappy-sinksource.P
+endif
+
+$(OBJ_DIR)/snappy-sinksource.o : $(PWD)/snappy-sinksource.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/snappy-stubs-internal.P
+endif
+
+$(OBJ_DIR)/snappy-stubs-internal.o : $(PWD)/snappy-stubs-internal.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/snappy.P
+endif
+
+$(OBJ_DIR)/snappy.o : $(PWD)/snappy.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/sparsematrix.P
+endif
+
+$(OBJ_DIR)/sparsematrix.o : $(PWD)/sparsematrix.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/splitstring.P
+endif
+
+$(OBJ_DIR)/splitstring.o : $(PWD)/splitstring.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/stringpool.P
+endif
+
+$(OBJ_DIR)/stringpool.o : $(PWD)/stringpool.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/strtools.P
+endif
+
+$(OBJ_DIR)/strtools.o : $(PWD)/strtools.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/tier1.P
+endif
+
+$(OBJ_DIR)/tier1.o : $(PWD)/tier1.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/tokenreader.P
+endif
+
+$(OBJ_DIR)/tokenreader.o : $(PWD)/tokenreader.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/uniqueid.P
+endif
+
+$(OBJ_DIR)/uniqueid.o : $(PWD)/uniqueid.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/utlbuffer.P
+endif
+
+$(OBJ_DIR)/utlbuffer.o : $(PWD)/utlbuffer.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/utlbufferutil.P
+endif
+
+$(OBJ_DIR)/utlbufferutil.o : $(PWD)/utlbufferutil.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/utlstring.P
+endif
+
+$(OBJ_DIR)/utlstring.o : $(PWD)/utlstring.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/utlsymbol.P
+endif
+
+$(OBJ_DIR)/utlsymbol.o : $(PWD)/utlsymbol.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+# Uncomment this, and set FILENAME to file you want built without optimizations enabled.
+# $(OBJ_DIR)/FILENAME.o : CFLAGS := $(subst -O2,-O0,$(CFLAGS))
+
+# Uncomment this to disable optimizations for the entire project.
+# $(OBJ_DIR)/%.o : CFLAGS := $(subst -O2,-O0,$(CFLAGS))
+
+

mp/src/tier1/tier1_osx32.mak

@@ -0,0 +1,390 @@
+NAME=tier1
+SRCROOT=..
+TARGET_PLATFORM=osx32
+TARGET_PLATFORM_EXT=
+USE_VALVE_BINDIR=0
+PWD := $(shell pwd)
+# If no configuration is specified, "release" will be used.
+ifeq "$(CFG)" ""
+	CFG = release
+endif
+
+GCC_ExtraCompilerFlags=
+GCC_ExtraLinkerFlags = 
+SymbolVisibility = hidden
+OptimizerLevel = -gdwarf-2 -g $(OptimizerLevel_CompilerSpecific)
+SystemLibraries = 
+DLL_EXT = .dylib
+SYM_EXT = .dSYM
+FORCEINCLUDES= 
+ifeq "$(CFG)" "debug"
+DEFINES += -DDEBUG -D_DEBUG -DGNUC -DPOSIX -D_OSX -DOSX -D_DARWIN_UNLIMITED_SELECT -DFD_SETSIZE=10240 -DQUICKTIME_VIDEO -DFORCE_QUICKTIME -DGL_GLEXT_PROTOTYPES -DDX_TO_GL_ABSTRACTION -DTIER1_STATIC_LIB -DVPCGAMECAPS=VALVE -DPROJECTDIR=/Users/joe/p4/ValveGames/rel/hl2/src/tier1 -D_DLL_EXT=.dylib -DVPCGAME=valve -D_POSIX=1 
+else
+DEFINES += -DNDEBUG -DGNUC -DPOSIX -D_OSX -DOSX -D_DARWIN_UNLIMITED_SELECT -DFD_SETSIZE=10240 -DQUICKTIME_VIDEO -DFORCE_QUICKTIME -DGL_GLEXT_PROTOTYPES -DDX_TO_GL_ABSTRACTION -DTIER1_STATIC_LIB -DVPCGAMECAPS=VALVE -DPROJECTDIR=/Users/joe/p4/ValveGames/rel/hl2/src/tier1 -D_DLL_EXT=.dylib -DVPCGAME=valve -D_POSIX=1 
+endif
+INCLUDEDIRS += ../common ../public ../public/tier0 ../public/tier1 
+CONFTYPE = lib
+OUTPUTFILE=../lib/osx32/tier1.a
+THIS_MAKEFILE = $(PWD)/tier1_osx32.mak
+MAKEFILE_BASE = $(SRCROOT)/devtools/makefile_base_posix.mak
+
+
+POSTBUILDCOMMAND = true
+
+
+
+CPPFILES= \
+    bitbuf.cpp \
+    byteswap.cpp \
+    characterset.cpp \
+    checksum_crc.cpp \
+    checksum_md5.cpp \
+    checksum_sha1.cpp \
+    commandbuffer.cpp \
+    convar.cpp \
+    datamanager.cpp \
+    diff.cpp \
+    generichash.cpp \
+    ilocalize.cpp \
+    interface.cpp \
+    KeyValues.cpp \
+    kvpacker.cpp \
+    mempool.cpp \
+    memstack.cpp \
+    NetAdr.cpp \
+    newbitbuf.cpp \
+    processor_detect_linux.cpp \
+    rangecheckedvar.cpp \
+    reliabletimer.cpp \
+    snappy-sinksource.cpp \
+    snappy-stubs-internal.cpp \
+    snappy.cpp \
+    sparsematrix.cpp \
+    splitstring.cpp \
+    stringpool.cpp \
+    strtools.cpp \
+    tier1.cpp \
+    tokenreader.cpp \
+    uniqueid.cpp \
+    utlbuffer.cpp \
+    utlbufferutil.cpp \
+    utlstring.cpp \
+    utlsymbol.cpp \
+
+
+LIBFILES = \
+
+
+LIBFILENAMES = \
+
+
+# Include the base makefile now.
+include $(SRCROOT)/devtools/makefile_base_posix.mak
+
+
+
+OTHER_DEPENDENCIES = \
+
+
+$(OBJ_DIR)/_other_deps.P : $(OTHER_DEPENDENCIES)
+	$(GEN_OTHER_DEPS)
+
+-include $(OBJ_DIR)/_other_deps.P
+
+
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/bitbuf.P
+endif
+
+$(OBJ_DIR)/bitbuf.o : $(PWD)/bitbuf.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/byteswap.P
+endif
+
+$(OBJ_DIR)/byteswap.o : $(PWD)/byteswap.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/characterset.P
+endif
+
+$(OBJ_DIR)/characterset.o : $(PWD)/characterset.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/checksum_crc.P
+endif
+
+$(OBJ_DIR)/checksum_crc.o : $(PWD)/checksum_crc.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/checksum_md5.P
+endif
+
+$(OBJ_DIR)/checksum_md5.o : $(PWD)/checksum_md5.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/checksum_sha1.P
+endif
+
+$(OBJ_DIR)/checksum_sha1.o : $(PWD)/checksum_sha1.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/commandbuffer.P
+endif
+
+$(OBJ_DIR)/commandbuffer.o : $(PWD)/commandbuffer.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/convar.P
+endif
+
+$(OBJ_DIR)/convar.o : $(PWD)/convar.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/datamanager.P
+endif
+
+$(OBJ_DIR)/datamanager.o : $(PWD)/datamanager.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/diff.P
+endif
+
+$(OBJ_DIR)/diff.o : $(PWD)/diff.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/generichash.P
+endif
+
+$(OBJ_DIR)/generichash.o : $(PWD)/generichash.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/ilocalize.P
+endif
+
+$(OBJ_DIR)/ilocalize.o : $(PWD)/ilocalize.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/interface.P
+endif
+
+$(OBJ_DIR)/interface.o : $(PWD)/interface.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/KeyValues.P
+endif
+
+$(OBJ_DIR)/KeyValues.o : $(PWD)/KeyValues.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/kvpacker.P
+endif
+
+$(OBJ_DIR)/kvpacker.o : $(PWD)/kvpacker.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/mempool.P
+endif
+
+$(OBJ_DIR)/mempool.o : $(PWD)/mempool.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/memstack.P
+endif
+
+$(OBJ_DIR)/memstack.o : $(PWD)/memstack.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/NetAdr.P
+endif
+
+$(OBJ_DIR)/NetAdr.o : $(PWD)/NetAdr.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/newbitbuf.P
+endif
+
+$(OBJ_DIR)/newbitbuf.o : $(PWD)/newbitbuf.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/processor_detect_linux.P
+endif
+
+$(OBJ_DIR)/processor_detect_linux.o : $(PWD)/processor_detect_linux.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/rangecheckedvar.P
+endif
+
+$(OBJ_DIR)/rangecheckedvar.o : $(PWD)/rangecheckedvar.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/reliabletimer.P
+endif
+
+$(OBJ_DIR)/reliabletimer.o : $(PWD)/reliabletimer.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/snappy-sinksource.P
+endif
+
+$(OBJ_DIR)/snappy-sinksource.o : $(PWD)/snappy-sinksource.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/snappy-stubs-internal.P
+endif
+
+$(OBJ_DIR)/snappy-stubs-internal.o : $(PWD)/snappy-stubs-internal.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/snappy.P
+endif
+
+$(OBJ_DIR)/snappy.o : $(PWD)/snappy.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/sparsematrix.P
+endif
+
+$(OBJ_DIR)/sparsematrix.o : $(PWD)/sparsematrix.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/splitstring.P
+endif
+
+$(OBJ_DIR)/splitstring.o : $(PWD)/splitstring.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/stringpool.P
+endif
+
+$(OBJ_DIR)/stringpool.o : $(PWD)/stringpool.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/strtools.P
+endif
+
+$(OBJ_DIR)/strtools.o : $(PWD)/strtools.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/tier1.P
+endif
+
+$(OBJ_DIR)/tier1.o : $(PWD)/tier1.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/tokenreader.P
+endif
+
+$(OBJ_DIR)/tokenreader.o : $(PWD)/tokenreader.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/uniqueid.P
+endif
+
+$(OBJ_DIR)/uniqueid.o : $(PWD)/uniqueid.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/utlbuffer.P
+endif
+
+$(OBJ_DIR)/utlbuffer.o : $(PWD)/utlbuffer.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/utlbufferutil.P
+endif
+
+$(OBJ_DIR)/utlbufferutil.o : $(PWD)/utlbufferutil.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/utlstring.P
+endif
+
+$(OBJ_DIR)/utlstring.o : $(PWD)/utlstring.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+ifneq (clean, $(findstring clean, $(MAKECMDGOALS)))
+-include $(OBJ_DIR)/utlsymbol.P
+endif
+
+$(OBJ_DIR)/utlsymbol.o : $(PWD)/utlsymbol.cpp $(THIS_MAKEFILE) $(MAKEFILE_BASE)
+	$(PRE_COMPILE_FILE)
+	$(COMPILE_FILE) $(POST_COMPILE_FILE)
+
+# Uncomment this, and set FILENAME to file you want built without optimizations enabled.
+# $(OBJ_DIR)/FILENAME.o : CFLAGS := $(subst -O2,-O0,$(CFLAGS))
+
+# Uncomment this to disable optimizations for the entire project.
+# $(OBJ_DIR)/%.o : CFLAGS := $(subst -O2,-O0,$(CFLAGS))
+
+

mp/src/tier1/tokenreader.cpp

@@ -0,0 +1,480 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//===========================================================================//
+
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+#include "tokenreader.h"
+#include "tier0/platform.h"
+#include "tier1/strtools.h"
+#include "tier0/dbg.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+TokenReader::TokenReader(void)
+{
+	m_szFilename[0] = '\0';
+	m_nLine = 1;
+	m_nErrorCount = 0;
+	m_bStuffed = false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pszFilename - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool TokenReader::Open(const char *pszFilename)
+{
+	open(pszFilename, std::ios::in | std::ios::binary );
+	Q_strncpy(m_szFilename, pszFilename, sizeof( m_szFilename ) );
+	m_nLine = 1;
+	m_nErrorCount = 0;
+	m_bStuffed = false;
+	return(is_open() != 0);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void TokenReader::Close()
+{
+	close();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *error - 
+// Output : const char
+//-----------------------------------------------------------------------------
+const char *TokenReader::Error(char *error, ...)
+{
+	static char szErrorBuf[256];
+	Q_snprintf(szErrorBuf, sizeof( szErrorBuf ), "File %s, line %d: ", m_szFilename, m_nLine);
+	Q_strncat(szErrorBuf, error, sizeof( szErrorBuf ), COPY_ALL_CHARACTERS );
+	m_nErrorCount++;
+	return(szErrorBuf);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pszStore - 
+//			nSize - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+trtoken_t TokenReader::GetString(char *pszStore, int nSize)
+{
+	if (nSize <= 0)
+	{
+		return TOKENERROR;
+	}
+
+	char szBuf[1024];
+
+	//
+	// Until we reach the end of this string or run out of room in
+	// the destination buffer...
+	//
+	while (true)
+	{
+		//
+		// Fetch the next batch of text from the file.
+		//
+		get(szBuf, sizeof(szBuf), '\"');
+		if (eof())
+		{
+			return TOKENEOF;
+		}
+
+		if (fail())
+		{
+			// Just means nothing was read (empty string probably "")
+			clear();
+		}
+
+		//
+		// Transfer the text to the destination buffer.
+		//
+		char *pszSrc = szBuf;
+		while ((*pszSrc != '\0') && (nSize > 1))
+		{
+			if (*pszSrc == 0x0d)
+			{
+				//
+				// Newline encountered before closing quote -- unterminated string.
+				//
+				*pszStore = '\0';
+				return TOKENSTRINGTOOLONG;
+			}
+			else if (*pszSrc != '\\')
+			{
+				*pszStore = *pszSrc;
+				pszSrc++;
+			}
+			else
+			{
+				//
+				// Backslash sequence - replace with the appropriate character.
+				//
+				pszSrc++;
+
+				if (*pszSrc == 'n')
+				{
+					*pszStore = '\n';
+				}
+
+				pszSrc++;
+			}
+
+			pszStore++;
+			nSize--;
+		}
+
+		if (*pszSrc != '\0')
+		{
+			//
+			// Ran out of room in the destination buffer. Skip to the close-quote,
+			// terminate the string, and exit.
+			//
+			ignore(1024, '\"');
+			*pszStore = '\0';
+			return TOKENSTRINGTOOLONG; 
+		}
+
+		//
+		// Check for closing quote.
+		//
+		if (peek() == '\"')
+		{
+			//
+			// Eat the close quote and any whitespace.
+			//
+			get();
+
+			bool bCombineStrings = SkipWhiteSpace();
+
+			//
+			// Combine consecutive quoted strings if the combine strings character was
+			// encountered between the two strings.
+			//
+			if (bCombineStrings && (peek() == '\"'))
+			{
+				//
+				// Eat the open quote and keep parsing this string.
+				//
+				get();
+			}
+			else
+			{
+				//
+				// Done with this string, terminate the string and exit.
+				//
+				*pszStore = '\0';
+				return STRING;
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the next token, allocating enough memory to store the token
+//			plus a terminating NULL.
+// Input  : pszStore - Pointer to a string that will be allocated.
+// Output : Returns the type of token that was read, or TOKENERROR.
+//-----------------------------------------------------------------------------
+trtoken_t TokenReader::NextTokenDynamic(char **ppszStore)
+{
+	char szTempBuffer[8192];
+	trtoken_t eType = NextToken(szTempBuffer, sizeof(szTempBuffer));
+
+	int len = Q_strlen(szTempBuffer) + 1;
+	*ppszStore = new char [len];
+	Assert( *ppszStore );
+	Q_strncpy(*ppszStore, szTempBuffer, len );
+
+	return(eType);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the next token.
+// Input  : pszStore - Pointer to a string that will receive the token.
+// Output : Returns the type of token that was read, or TOKENERROR.
+//-----------------------------------------------------------------------------
+trtoken_t TokenReader::NextToken(char *pszStore, int nSize)
+{
+	char *pStart = pszStore;
+
+	if (!is_open())
+	{
+		return TOKENEOF;
+	}
+
+	//
+	// If they stuffed a token, return that token.
+	//
+	if (m_bStuffed)
+	{
+		m_bStuffed = false;
+		Q_strncpy( pszStore, m_szStuffed, nSize );
+		return m_eStuffed;
+	}
+	
+	SkipWhiteSpace();
+
+	if (eof())
+	{
+		return TOKENEOF;
+	}
+
+	if (fail())
+	{
+		return TOKENEOF;
+	}
+
+	char ch = get();
+
+	//
+	// Look for all the valid operators.
+	//
+	switch (ch)
+	{
+		case '@':
+		case ',':
+		case '!':
+		case '+':
+		case '&':
+		case '*':
+		case '$':
+		case '.':
+		case '=':
+		case ':':
+		case '[':
+		case ']':
+		case '(':
+		case ')':
+		case '{':
+		case '}':
+		case '\\':
+		{
+			pszStore[0] = ch;
+			pszStore[1] = 0;
+			return OPERATOR;
+		}
+	}
+
+	//
+	// Look for the start of a quoted string.
+	//
+	if (ch == '\"')
+	{
+		return GetString(pszStore, nSize);
+	}
+
+	//
+	// Integers consist of numbers with an optional leading minus sign.
+	//
+	if (isdigit(ch) || (ch == '-'))
+	{
+		do
+		{
+			if ( (pszStore - pStart + 1) < nSize )
+			{
+				*pszStore = ch;
+				pszStore++;
+			}
+
+			ch = get();
+			if (ch == '-')
+			{
+				return TOKENERROR;
+			}
+		} while (isdigit(ch));
+		
+		//
+		// No identifier characters are allowed contiguous with numbers.
+		//
+		if (isalpha(ch) || (ch == '_'))
+		{
+			return TOKENERROR;
+		}
+
+		//
+		// Put back the non-numeric character for the next call.
+		//
+		putback(ch);
+		*pszStore = '\0';
+		return INTEGER;
+	}
+ 
+	//
+	// Identifiers consist of a consecutive string of alphanumeric
+	// characters and underscores.
+	//
+	while ( isalpha(ch) || isdigit(ch) || (ch == '_') )
+	{
+		if ( (pszStore - pStart + 1) < nSize )
+		{
+			*pszStore = ch;
+			pszStore++;
+		}
+
+		ch = get();
+	}
+
+	//
+	// Put back the non-identifier character for the next call.
+	//
+	putback(ch);
+	*pszStore = '\0';
+	return IDENT;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : ttype - 
+//			*pszToken - 
+//-----------------------------------------------------------------------------
+void TokenReader::IgnoreTill(trtoken_t ttype, const char *pszToken)
+{
+	trtoken_t _ttype;
+	char szBuf[1024];
+
+	while(1)
+	{
+		_ttype = NextToken(szBuf, sizeof(szBuf));
+		if(_ttype == TOKENEOF)
+			return;
+		if(_ttype == ttype)
+		{
+			if(IsToken(pszToken, szBuf))
+			{
+				Stuff(ttype, pszToken);
+				return;
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : ttype - 
+//			pszToken - 
+//-----------------------------------------------------------------------------
+void TokenReader::Stuff(trtoken_t eType, const char *pszToken)
+{
+	m_eStuffed = eType;
+	Q_strncpy(m_szStuffed, pszToken, sizeof( m_szStuffed ) );
+	m_bStuffed = true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : ttype - 
+//			pszToken - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool TokenReader::Expecting(trtoken_t ttype, const char *pszToken)
+{
+	char szBuf[1024];
+	if (NextToken(szBuf, sizeof(szBuf)) != ttype || !IsToken(pszToken, szBuf))
+	{
+		return false;
+	}
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pszStore - 
+// Output : 
+//-----------------------------------------------------------------------------
+trtoken_t TokenReader::PeekTokenType(char *pszStore, int maxlen )
+{
+	if (!m_bStuffed)
+	{
+		m_eStuffed = NextToken(m_szStuffed, sizeof(m_szStuffed));
+		m_bStuffed = true;
+	}
+	
+	if (pszStore)
+	{
+		Q_strncpy(pszStore, m_szStuffed, maxlen );
+	}
+
+	return(m_eStuffed);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets the next non-whitespace character from the file.
+// Input  : ch - Receives the character.
+// Output : Returns true if the whitespace contained the combine strings
+//			character '\', which is used to merge consecutive quoted strings.
+//-----------------------------------------------------------------------------
+bool TokenReader::SkipWhiteSpace(void)
+{
+	bool bCombineStrings = false;
+
+	while (true)
+	{
+		char ch = get();
+
+		if ((ch == ' ') || (ch == '\t') || (ch == '\r') || (ch == 0))
+		{
+			continue;
+		}
+
+		if (ch == '+')
+		{
+			bCombineStrings = true;
+			continue;
+		}
+
+		if (ch == '\n')
+		{
+			m_nLine++;
+			continue;
+		}
+
+		if (eof())
+		{
+			return(bCombineStrings);
+		}
+
+		//
+		// Check for the start of a comment.
+		//
+		if (ch == '/')
+		{
+			if (peek() == '/')
+			{
+				ignore(1024, '\n');
+				m_nLine++;
+			}
+		}
+		else
+		{
+			//
+			// It is a worthy character. Put it back.
+			//
+			putback(ch);
+			return(bCombineStrings);
+		}
+	}
+}
+

mp/src/tier1/undiff.cpp

@@ -0,0 +1,94 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// UnDiff - Apply difference block
+//
+//=============================================================================//
+
+#include "tier0/platform.h"
+#include "tier0/dbg.h"
+#include "tier1/diff.h"
+#include "mathlib/mathlib.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+void ApplyDiffs(uint8 const *OldBlock, uint8 const *DiffList,
+                int OldSize, int DiffListSize, int &ResultListSize,uint8 *Output,uint32 OutSize)
+{
+  uint8 const *copy_src=OldBlock;
+  uint8 const *end_of_diff_list=DiffList+DiffListSize;
+  uint8 const *obuf=Output;
+  while(DiffList<end_of_diff_list)
+  {
+    //  printf("dptr=%x ",DiffList-d);
+    uint8 op=*(DiffList++);
+    if (op==0)
+    {
+      uint16 copy_sz=DiffList[0]+256*DiffList[1];
+      int copy_ofs=DiffList[2]+DiffList[3]*256;
+      if (copy_ofs>32767)
+        copy_ofs|=0xffff0000;
+    //    printf("long cp from %x to %x len=%d\n", copy_src+copy_ofs-OldBlock,Output-obuf,copy_sz);
+      
+      memcpy(Output,copy_src+copy_ofs,copy_sz);
+      Output+=copy_sz;
+      copy_src=copy_src+copy_ofs+copy_sz;
+      DiffList+=4;
+    }
+    else
+    {
+      if (op & 0x80)
+      {
+        int copy_sz=op & 0x7f;
+        int copy_ofs;
+        if (copy_sz==0)
+        {
+          copy_sz=DiffList[0];
+          if (copy_sz==0)
+          {
+            // big raw copy
+            copy_sz=DiffList[1]+256*DiffList[2]+65536*DiffList[3];
+            memcpy(Output,DiffList+4,copy_sz);
+    //          printf("big rawcopy to %x len=%d\n", Output-obuf,copy_sz);
+            
+            DiffList+=copy_sz+4;
+            Output+=copy_sz;
+          }
+          else
+          {
+            copy_ofs=DiffList[1]+(DiffList[2]*256);
+            if (copy_ofs>32767)
+              copy_ofs|=0xffff0000;
+    //          printf("long ofs cp from %x to %x len=%d\n", copy_src+copy_ofs-OldBlock,Output-obuf,copy_sz);
+            
+            memcpy(Output,copy_src+copy_ofs,copy_sz);
+            Output+=copy_sz;
+            copy_src=copy_src+copy_ofs+copy_sz;
+            DiffList+=3;
+          }
+        }
+        else
+        {
+          copy_ofs=DiffList[0];
+          if (copy_ofs>127)
+            copy_ofs|=0xffffff80;
+    //        printf("cp from %x to %x len=%d\n", copy_src+copy_ofs-OldBlock,Output-obuf,copy_sz);
+          
+          memcpy(Output,copy_src+copy_ofs,copy_sz);
+          Output+=copy_sz;
+          copy_src=copy_src+copy_ofs+copy_sz;
+          DiffList++;
+        }
+      }
+      else
+      {
+    //      printf("raw copy %d to %x\n",op & 127,Output-obuf);
+        memcpy(Output,DiffList,op & 127);
+        Output+=op & 127;
+        DiffList+=(op & 127);
+      }
+    }
+  }
+  ResultListSize=Output-obuf;
+  
+}

mp/src/tier1/uniqueid.cpp

@@ -0,0 +1,177 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+// Unique ID generation
+//=============================================================================//
+
+#include "tier0/platform.h"
+
+#ifdef IS_WINDOWS_PC
+#include <windows.h> // UUIDCreate
+#else
+#include "checksum_crc.h"
+#endif
+#include "tier1/uniqueid.h"
+#include "tier1/utlbuffer.h"
+
+//-----------------------------------------------------------------------------
+// Creates a new unique id
+//-----------------------------------------------------------------------------
+void CreateUniqueId( UniqueId_t *pDest )
+{
+#ifdef IS_WINDOWS_PC
+	Assert( sizeof( UUID ) == sizeof( *pDest ) );
+	UuidCreate( (UUID *)pDest );
+#else
+	// X360/linux TBD: Need a real UUID Implementation
+	Q_memset( pDest, 0, sizeof( UniqueId_t ) );
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Creates a new unique id from a string representation of one
+//-----------------------------------------------------------------------------
+bool UniqueIdFromString( UniqueId_t *pDest, const char *pBuf, int nMaxLen )
+{
+	if ( nMaxLen == 0 )
+	{
+		nMaxLen = Q_strlen( pBuf );
+	}
+
+	char *pTemp = (char*)stackalloc( nMaxLen + 1 );
+	V_strncpy( pTemp, pBuf, nMaxLen + 1 );
+	--nMaxLen;
+	while( (nMaxLen >= 0) && isspace( pTemp[nMaxLen] ) )
+	{
+		--nMaxLen;
+	}
+	pTemp[ nMaxLen + 1 ] = 0;
+
+	while( *pTemp && isspace( *pTemp ) )
+	{
+		++pTemp;
+	}
+
+#ifdef IS_WINDOWS_PC
+	Assert( sizeof( UUID ) == sizeof( *pDest ) );
+
+	if ( RPC_S_OK != UuidFromString( (unsigned char *)pTemp, (UUID *)pDest ) )
+	{
+		InvalidateUniqueId( pDest );
+		return false;
+	}
+#else
+	// X360TBD: Need a real UUID Implementation
+	// For now, use crc to generate a unique ID from the UUID string.
+	Q_memset( pDest, 0, sizeof( UniqueId_t ) );
+	if ( nMaxLen > 0 )
+	{
+		CRC32_t crc;
+		CRC32_Init( &crc );
+		CRC32_ProcessBuffer( &crc, pBuf, nMaxLen );
+		CRC32_Final( &crc );
+		Q_memcpy( pDest, &crc, sizeof( CRC32_t ) );
+	}
+#endif
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Sets an object ID to be an invalid state
+//-----------------------------------------------------------------------------
+void InvalidateUniqueId( UniqueId_t *pDest )
+{
+	Assert( pDest );
+	memset( pDest, 0, sizeof( UniqueId_t ) );
+}
+
+bool IsUniqueIdValid( const UniqueId_t &id )
+{
+	UniqueId_t invalidId;
+	memset( &invalidId, 0, sizeof( UniqueId_t ) );
+	return !IsUniqueIdEqual( invalidId, id );
+}
+
+bool IsUniqueIdEqual( const UniqueId_t &id1, const UniqueId_t &id2 )
+{
+	return memcmp( &id1, &id2, sizeof( UniqueId_t ) ) == 0; 
+}
+
+void UniqueIdToString( const UniqueId_t &id, char *pBuf, int nMaxLen )
+{
+	pBuf[ 0 ] = 0;
+
+// X360TBD: Need a real UUID Implementation
+#ifdef IS_WINDOWS_PC
+	UUID *self = ( UUID * )&id;
+
+	unsigned char *outstring = NULL;
+
+	UuidToString( self, &outstring );
+	if ( outstring && *outstring )
+	{
+		Q_strncpy( pBuf, (const char *)outstring, nMaxLen );
+		RpcStringFree( &outstring );
+	}
+#endif
+}
+
+void CopyUniqueId( const UniqueId_t &src, UniqueId_t *pDest )
+{
+	memcpy( pDest, &src, sizeof( UniqueId_t ) );
+}
+
+bool Serialize( CUtlBuffer &buf, const UniqueId_t &src )
+{
+// X360TBD: Need a real UUID Implementation
+#ifdef IS_WINDOWS_PC
+	if ( buf.IsText() )
+	{
+		UUID *pId = ( UUID * )&src;
+
+		unsigned char *outstring = NULL;
+
+		UuidToString( pId, &outstring );
+		if ( outstring && *outstring )
+		{
+			buf.PutString( (const char *)outstring );
+			RpcStringFree( &outstring );
+		}
+		else
+		{
+			buf.PutChar( '\0' );
+		}
+	}
+	else
+	{
+		buf.Put( &src, sizeof(UniqueId_t) );
+	}
+	return buf.IsValid();
+#else
+	return false;
+#endif
+}
+
+bool Unserialize( CUtlBuffer &buf, UniqueId_t &dest )
+{
+	if ( buf.IsText() )
+	{
+		int nTextLen = buf.PeekStringLength();
+		char *pBuf = (char*)stackalloc( nTextLen );
+		buf.GetString( pBuf, nTextLen );
+		UniqueIdFromString( &dest, pBuf, nTextLen );
+	}
+	else
+	{
+		buf.Get( &dest, sizeof(UniqueId_t) );
+	}
+	return buf.IsValid();
+}
+
+
+

mp/src/tier1/utlbufferutil.cpp

@@ -0,0 +1,559 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// $Header: $
+// $NoKeywords: $
+//
+// Serialization buffer
+//===========================================================================//
+
+#pragma warning (disable : 4514)
+
+#include "tier1/utlbufferutil.h"
+#include "tier1/utlbuffer.h"
+#include "mathlib/vector.h"
+#include "mathlib/vector2d.h"
+#include "mathlib/vector4d.h"
+#include "mathlib/vmatrix.h"
+#include "Color.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <limits.h>
+#include "tier1/utlstring.h"
+#include "tier1/strtools.h"
+#include "tier1/characterset.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+			    
+
+//-----------------------------------------------------------------------------
+// For serialization, set the delimiter rules
+//-----------------------------------------------------------------------------
+CUtlCharConversion *s_pConv = NULL;
+const char *s_pUtlBufferUtilArrayDelim = NULL;
+void SetSerializationDelimiter( CUtlCharConversion *pConv )
+{
+	s_pConv = pConv;
+}
+
+void SetSerializationArrayDelimiter( const char *pDelimiter )
+{
+	s_pUtlBufferUtilArrayDelim = pDelimiter;
+}
+
+
+//-----------------------------------------------------------------------------
+// Serialize a floating point number in text mode in a readably friendly fashion
+//-----------------------------------------------------------------------------
+static void SerializeFloat( CUtlBuffer &buf, float f )
+{
+	Assert( buf.IsText() );
+
+	// FIXME: Print this in a way that we never lose precision
+	char pTemp[256];
+	int nLen = Q_snprintf( pTemp, sizeof(pTemp), "%.10f", f );
+	while ( nLen > 0 && pTemp[nLen-1] == '0' )
+	{
+		--nLen;
+		pTemp[nLen] = 0;
+	}
+	if ( nLen > 0 && pTemp[nLen-1] == '.' )
+	{
+		--nLen;
+		pTemp[nLen] = 0;
+	}
+	buf.PutString( pTemp );
+}
+
+static void SerializeFloats( CUtlBuffer &buf, int nCount, const float *pFloats )
+{
+	for ( int i = 0; i < nCount; ++i )
+	{
+		SerializeFloat( buf, pFloats[i] );
+		if ( i != nCount-1 )
+		{
+			buf.PutChar( ' ' );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Serialization methods for basic types
+//-----------------------------------------------------------------------------
+bool Serialize( CUtlBuffer &buf, const bool &src )
+{
+	if ( buf.IsText() )
+	{
+		buf.Printf( "%d", src );
+	}
+	else
+	{
+		buf.PutChar( src );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, bool &dest )
+{
+	if ( buf.IsText() )
+	{
+		int nValue = 0;
+		int nRetVal = buf.Scanf( "%d", &nValue );
+		dest = ( nValue != 0 );
+		return (nRetVal == 1) && buf.IsValid();
+	}
+
+	dest = ( buf.GetChar( ) != 0 );
+	return buf.IsValid();
+}
+
+
+bool Serialize( CUtlBuffer &buf, const int &src )
+{
+	if ( buf.IsText() )
+	{
+		buf.Printf( "%d", src );
+	}
+	else
+	{
+		buf.PutInt( src );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, int &dest )
+{
+	if ( buf.IsText() )
+	{
+		int nRetVal = buf.Scanf( "%d", &dest );
+		return (nRetVal == 1) && buf.IsValid();
+	}
+
+	dest = buf.GetInt( );
+	return buf.IsValid();
+}
+
+bool Serialize( CUtlBuffer &buf, const float &src )
+{
+	if ( buf.IsText() )
+	{
+		SerializeFloat( buf, src );
+	}
+	else
+	{
+		buf.PutFloat( src );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, float &dest )
+{
+	if ( buf.IsText() )
+	{
+		// FIXME: Print this in a way that we never lose precision
+		int nRetVal = buf.Scanf( "%f", &dest );
+		return (nRetVal == 1) && buf.IsValid();
+	}
+
+	dest = buf.GetFloat( );
+	return buf.IsValid();
+}
+
+
+//-----------------------------------------------------------------------------
+// Attribute types related to vector math
+//-----------------------------------------------------------------------------
+bool Serialize( CUtlBuffer &buf, const Vector2D &src )
+{
+	if ( buf.IsText() )
+	{
+		SerializeFloats( buf, 2, src.Base() );
+	}
+	else
+	{
+		buf.PutFloat( src.x );
+		buf.PutFloat( src.y );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, Vector2D &dest )
+{
+	if ( buf.IsText() )
+	{
+		// FIXME: Print this in a way that we never lose precision
+		int nRetVal = buf.Scanf( "%f %f", &dest.x, &dest.y );
+		return (nRetVal == 2) && buf.IsValid();
+	}
+
+	dest.x = buf.GetFloat( );
+	dest.y = buf.GetFloat( );
+	return buf.IsValid();
+}
+
+bool Serialize( CUtlBuffer &buf, const Vector &src )
+{
+	if ( buf.IsText() )
+	{
+		SerializeFloats( buf, 3, src.Base() );
+	}
+	else
+	{
+		buf.PutFloat( src.x );
+		buf.PutFloat( src.y );
+		buf.PutFloat( src.z );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, Vector &dest )
+{
+	if ( buf.IsText() )
+	{
+		// FIXME: Print this in a way that we never lose precision
+		int nRetVal = buf.Scanf( "%f %f %f", &dest.x, &dest.y, &dest.z );
+		return (nRetVal == 3) && buf.IsValid();
+	}
+
+	dest.x = buf.GetFloat( );
+	dest.y = buf.GetFloat( );
+	dest.z = buf.GetFloat( );
+	return buf.IsValid();
+}
+
+bool Serialize( CUtlBuffer &buf, const Vector4D &src )
+{
+	if ( buf.IsText() )
+	{
+		SerializeFloats( buf, 4, src.Base() );
+	}
+	else
+	{
+		buf.PutFloat( src.x );
+		buf.PutFloat( src.y );
+		buf.PutFloat( src.z );
+		buf.PutFloat( src.w );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, Vector4D &dest )
+{
+	if ( buf.IsText() )
+	{
+		// FIXME: Print this in a way that we never lose precision
+		int nRetVal = buf.Scanf( "%f %f %f %f", &dest.x, &dest.y, &dest.z, &dest.w );
+		return (nRetVal == 4) && buf.IsValid();
+	}
+
+	dest.x = buf.GetFloat( );
+	dest.y = buf.GetFloat( );
+	dest.z = buf.GetFloat( );
+	dest.w = buf.GetFloat( );
+	return buf.IsValid();
+}
+
+bool Serialize( CUtlBuffer &buf, const QAngle &src )
+{
+	if ( buf.IsText() )
+	{
+		SerializeFloats( buf, 3, src.Base() );
+	}
+	else
+	{
+		buf.PutFloat( src.x );
+		buf.PutFloat( src.y );
+		buf.PutFloat( src.z );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, QAngle &dest )
+{
+	if ( buf.IsText() )
+	{
+		// FIXME: Print this in a way that we never lose precision
+		int nRetVal = buf.Scanf( "%f %f %f", &dest.x, &dest.y, &dest.z );
+		return (nRetVal == 3) && buf.IsValid();
+	}
+
+	dest.x = buf.GetFloat( );
+	dest.y = buf.GetFloat( );
+	dest.z = buf.GetFloat( );
+	return buf.IsValid();
+}
+
+bool Serialize( CUtlBuffer &buf, const Quaternion &src )
+{
+	if ( buf.IsText() )
+	{
+		SerializeFloats( buf, 4, &src.x );
+	}
+	else
+	{
+		buf.PutFloat( src.x );
+		buf.PutFloat( src.y );
+		buf.PutFloat( src.z );
+		buf.PutFloat( src.w );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, Quaternion &dest )
+{
+	if ( buf.IsText() )
+	{
+		// FIXME: Print this in a way that we never lose precision
+		int nRetVal = buf.Scanf( "%f %f %f %f", &dest.x, &dest.y, &dest.z, &dest.w );
+		return (nRetVal == 4) && buf.IsValid();
+	}
+
+	dest.x = buf.GetFloat( );
+	dest.y = buf.GetFloat( );
+	dest.z = buf.GetFloat( );
+	dest.w = buf.GetFloat( );
+	return buf.IsValid();
+}
+
+bool Serialize( CUtlBuffer &buf, const VMatrix &src )
+{
+	if ( buf.IsText() )
+	{
+		buf.Printf( "\n" );
+		SerializeFloats( buf, 4, src[0] );
+		buf.Printf( "\n" );
+		SerializeFloats( buf, 4, src[1] );
+		buf.Printf( "\n" );
+		SerializeFloats( buf, 4, src[2] );
+		buf.Printf( "\n" );
+		SerializeFloats( buf, 4, src[3] );
+		buf.Printf( "\n" );
+	}
+	else
+	{
+		buf.Put( &src, sizeof(VMatrix) );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, VMatrix &dest )
+{
+	if ( !buf.IsValid() )
+		return false;
+
+	if ( buf.IsText() )
+	{
+		int nRetVal = buf.Scanf( "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f",
+			&dest[ 0 ][ 0 ], &dest[ 0 ][ 1 ], &dest[ 0 ][ 2 ], &dest[ 0 ][ 3 ],
+			&dest[ 1 ][ 0 ], &dest[ 1 ][ 1 ], &dest[ 1 ][ 2 ], &dest[ 1 ][ 3 ],
+			&dest[ 2 ][ 0 ], &dest[ 2 ][ 1 ], &dest[ 2 ][ 2 ], &dest[ 2 ][ 3 ],
+			&dest[ 3 ][ 0 ], &dest[ 3 ][ 1 ], &dest[ 3 ][ 2 ], &dest[ 3 ][ 3 ] );
+		return (nRetVal == 16);
+	}
+
+	buf.Get( &dest, sizeof(VMatrix) );
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Color attribute
+//-----------------------------------------------------------------------------
+bool Serialize( CUtlBuffer &buf, const Color &src )
+{
+	if ( buf.IsText() )
+	{
+		buf.Printf( "%d %d %d %d", src[0], src[1], src[2], src[3] );
+	}
+	else
+	{
+		buf.PutUnsignedChar( src[0] );
+		buf.PutUnsignedChar( src[1] );
+		buf.PutUnsignedChar( src[2] );
+		buf.PutUnsignedChar( src[3] );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, Color &dest )
+{
+	if ( buf.IsText() )
+	{
+		int r = 0, g = 0, b = 0, a = 255;
+		int nRetVal = buf.Scanf( "%d %d %d %d", &r, &g, &b, &a );
+		dest.SetColor( r, g, b, a );
+		return (nRetVal == 4) && buf.IsValid();
+	}
+
+	dest[0] = buf.GetUnsignedChar( );
+	dest[1] = buf.GetUnsignedChar( );
+	dest[2] = buf.GetUnsignedChar( );
+	dest[3] = buf.GetUnsignedChar( );
+	return buf.IsValid();
+}
+
+/*
+//-----------------------------------------------------------------------------
+// Object ID attribute
+//-----------------------------------------------------------------------------
+bool Serialize( CUtlBuffer &buf, const DmObjectId_t &src )
+{
+	return g_pDataModel->Serialize( buf, src );
+}
+
+bool Unserialize( CUtlBuffer &buf, DmObjectId_t &dest )
+{
+	return g_pDataModel->Unserialize( buf, &dest );
+}
+*/
+
+//-----------------------------------------------------------------------------
+// Binary buffer attribute
+//-----------------------------------------------------------------------------
+bool Serialize( CUtlBuffer &buf, const CUtlBinaryBlock &src )
+{
+	int nLength = src.Length();
+	if ( !buf.IsText() )
+	{
+		buf.PutInt( nLength );
+		if ( nLength != 0 )
+		{
+			buf.Put( src.Get(), nLength );
+		}
+		return buf.IsValid();
+	}
+
+	// Writes out uuencoded binaries
+	for ( int i = 0; i < nLength; ++i )
+	{
+		if ( (i % 40) == 0 )
+		{
+			buf.PutChar( '\n' );
+		}
+
+		char b1 = src[i] & 0xF;
+		char b2 = src[i] >> 4;
+
+		char c1 = ( b1 <= 9 ) ? b1 + '0' : b1 - 10 + 'A';
+		char c2 = ( b2 <= 9 ) ? b2 + '0' : b2 - 10 + 'A';
+
+		buf.PutChar( c2 );
+		buf.PutChar( c1 );
+	}
+
+	buf.PutChar( '\n' );
+	return buf.IsValid();
+}
+
+static int CountBinaryBytes( CUtlBuffer &buf, int *pEndGet )
+{
+	// This counts the number of bytes in the uuencoded text
+	int nStartGet = buf.TellGet();
+	buf.EatWhiteSpace();
+	*pEndGet = buf.TellGet();
+	int nByteCount = 0;
+	while ( buf.IsValid() )
+	{
+		char c1 = buf.GetChar();
+		char c2 = buf.GetChar();
+
+		bool bIsNum1 = ( c1 >= '0' ) && ( c1 <= '9' );
+		bool bIsNum2 = ( c2 >= '0' ) && ( c2 <= '9' );
+
+		bool bIsAlpha1 = (( c1 >= 'A' ) && ( c1 <= 'F' )) || (( c1 >= 'a' ) && ( c1 <= 'f' ));
+		bool bIsAlpha2 = (( c2 >= 'A' ) && ( c2 <= 'F' )) || (( c2 >= 'a' ) && ( c2 <= 'f' ));
+
+		if ( !(bIsNum1 || bIsAlpha1) || !(bIsNum2 || bIsAlpha2) )
+			break;
+
+		buf.EatWhiteSpace();
+		*pEndGet = buf.TellGet();
+		++nByteCount;
+	}
+	buf.SeekGet( CUtlBuffer::SEEK_HEAD, nStartGet );
+	return nByteCount;
+}
+
+inline static unsigned char HexCharToInt( int c1 )
+{
+	if (( c1 >= '0' ) && ( c1 <= '9' ))
+		return c1 - '0';
+
+	if (( c1 >= 'A' ) && ( c1 <= 'F' ))
+		return 10 + c1 - 'A';
+
+	if (( c1 >= 'a' ) && ( c1 <= 'f' ))
+		return 10 + c1 - 'a';
+
+	return 0xFF;
+}
+
+bool Unserialize( CUtlBuffer &buf, CUtlBinaryBlock &dest )
+{
+	if ( !buf.IsText() )
+	{
+		int nLen = buf.GetInt( );
+		dest.SetLength( nLen );
+		if ( dest.Length() != 0 )
+		{
+			buf.Get( dest.Get(), dest.Length() );
+		}
+
+		if ( nLen != dest.Length() )
+		{
+			buf.SeekGet( CUtlBuffer::SEEK_CURRENT, nLen - dest.Length() );
+			return false;
+		}
+
+		return buf.IsValid();
+	}
+
+	int nEndGet;
+	int nByteCount = CountBinaryBytes( buf, &nEndGet );
+	if ( nByteCount < 0 )
+		return false;
+
+	buf.EatWhiteSpace();
+	int nDest = 0;
+	dest.SetLength( nByteCount );
+	while( buf.TellGet() < nEndGet )
+	{
+		char c1 = buf.GetChar();
+		char c2 = buf.GetChar();
+
+		unsigned char b1 = HexCharToInt( c1 );
+		unsigned char b2 = HexCharToInt( c2 );
+		if ( b1 == 0xFF || b2 == 0xFF )
+			return false;
+
+		dest[ nDest++ ] = b2 | ( b1 << 4 );
+		buf.EatWhiteSpace();
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// String attribute
+//-----------------------------------------------------------------------------
+bool Serialize( CUtlBuffer &buf, const CUtlString &src )
+{
+	buf.PutDelimitedString( s_pConv, src.Get() );
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, CUtlString &dest )
+{
+	int nLen = buf.PeekDelimitedStringLength( s_pConv );
+	dest.SetLength( nLen - 1 );	// -1 because the length returned includes space for \0
+	buf.GetDelimitedString( s_pConv, dest.Get(), nLen );
+	return buf.IsValid();
+}
+
+
+
+

mp/src/tier1/utlstring.cpp

@@ -0,0 +1,548 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "tier1/utlstring.h"
+#include "tier1/strtools.h"
+#include <ctype.h>
+
+// NOTE: This has to be the last file included!
+#include "tier0/memdbgon.h"
+
+
+//-----------------------------------------------------------------------------
+// Base class, containing simple memory management
+//-----------------------------------------------------------------------------
+CUtlBinaryBlock::CUtlBinaryBlock( int growSize, int initSize ) 
+{
+	MEM_ALLOC_CREDIT();
+	m_Memory.Init( growSize, initSize );
+
+	m_nActualLength = 0;
+}
+
+CUtlBinaryBlock::CUtlBinaryBlock( void* pMemory, int nSizeInBytes, int nInitialLength ) : m_Memory( (unsigned char*)pMemory, nSizeInBytes )
+{
+	m_nActualLength = nInitialLength;
+}
+
+CUtlBinaryBlock::CUtlBinaryBlock( const void* pMemory, int nSizeInBytes ) : m_Memory( (const unsigned char*)pMemory, nSizeInBytes )
+{
+	m_nActualLength = nSizeInBytes;
+}
+
+CUtlBinaryBlock::CUtlBinaryBlock( const CUtlBinaryBlock& src )
+{
+	Set( src.Get(), src.Length() );
+}
+
+void CUtlBinaryBlock::Get( void *pValue, int nLen ) const
+{
+	Assert( nLen > 0 );
+	if ( m_nActualLength < nLen )
+	{
+		nLen = m_nActualLength;
+	}
+
+	if ( nLen > 0 )
+	{
+		memcpy( pValue, m_Memory.Base(), nLen );
+	}
+}
+
+void CUtlBinaryBlock::SetLength( int nLength )
+{
+	MEM_ALLOC_CREDIT();
+	Assert( !m_Memory.IsReadOnly() );
+
+	m_nActualLength = nLength;
+	if ( nLength > m_Memory.NumAllocated() )
+	{
+		int nOverFlow = nLength - m_Memory.NumAllocated();
+		m_Memory.Grow( nOverFlow );
+
+		// If the reallocation failed, clamp length
+		if ( nLength > m_Memory.NumAllocated() )
+		{
+			m_nActualLength = m_Memory.NumAllocated();
+		}
+	}
+
+#ifdef _DEBUG
+	if ( m_Memory.NumAllocated() > m_nActualLength )
+	{
+		memset( ( ( char * )m_Memory.Base() ) + m_nActualLength, 0xEB, m_Memory.NumAllocated() - m_nActualLength );
+	}
+#endif
+}
+
+
+void CUtlBinaryBlock::Set( const void *pValue, int nLen )
+{
+	Assert( !m_Memory.IsReadOnly() );
+
+	if ( !pValue )
+	{
+		nLen = 0;
+	}
+
+	SetLength( nLen );
+
+	if ( m_nActualLength )
+	{
+		if ( ( ( const char * )m_Memory.Base() ) >= ( ( const char * )pValue ) + nLen ||
+			 ( ( const char * )m_Memory.Base() ) + m_nActualLength <= ( ( const char * )pValue ) )
+		{
+			memcpy( m_Memory.Base(), pValue, m_nActualLength );
+		}
+		else
+		{
+			memmove( m_Memory.Base(), pValue, m_nActualLength );
+		}
+	}
+}
+
+
+CUtlBinaryBlock &CUtlBinaryBlock::operator=( const CUtlBinaryBlock &src )
+{
+	Assert( !m_Memory.IsReadOnly() );
+	Set( src.Get(), src.Length() );
+	return *this;
+}
+
+
+bool CUtlBinaryBlock::operator==( const CUtlBinaryBlock &src ) const
+{
+	if ( src.Length() != Length() )
+		return false;
+
+	return !memcmp( src.Get(), Get(), Length() );
+}
+
+
+//-----------------------------------------------------------------------------
+// Simple string class. 
+//-----------------------------------------------------------------------------
+CUtlString::CUtlString()
+{
+}
+
+CUtlString::CUtlString( const char *pString )
+{
+	Set( pString );
+}
+
+CUtlString::CUtlString( const CUtlString& string )
+{
+	Set( string.Get() );
+}
+
+// Attaches the string to external memory. Useful for avoiding a copy
+CUtlString::CUtlString( void* pMemory, int nSizeInBytes, int nInitialLength ) : m_Storage( pMemory, nSizeInBytes, nInitialLength )
+{
+}
+
+CUtlString::CUtlString( const void* pMemory, int nSizeInBytes ) : m_Storage( pMemory, nSizeInBytes )
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Set directly and don't look for a null terminator in pValue.
+//-----------------------------------------------------------------------------
+void CUtlString::SetDirect( const char *pValue, int nChars )
+{
+	Assert( !m_Storage.IsReadOnly() );
+	m_Storage.Set( pValue, nChars + 1 );
+
+	// Make sure to null terminate the copied string
+	*(((char *)m_Storage.Get()) + nChars) = NULL;
+}
+
+
+void CUtlString::Set( const char *pValue )
+{
+	Assert( !m_Storage.IsReadOnly() );
+	int nLen = pValue ? Q_strlen(pValue) + 1 : 0;
+	m_Storage.Set( pValue, nLen );
+}
+
+
+// Returns strlen
+int CUtlString::Length() const
+{
+	return m_Storage.Length() ? m_Storage.Length() - 1 : 0;
+}
+
+// Sets the length (used to serialize into the buffer )
+void CUtlString::SetLength( int nLen )
+{
+	Assert( !m_Storage.IsReadOnly() );
+
+	// Add 1 to account for the NULL
+	m_Storage.SetLength( nLen > 0 ? nLen + 1 : 0 );
+}
+
+const char *CUtlString::Get( ) const
+{
+	if ( m_Storage.Length() == 0 )
+	{
+		return "";
+	}
+
+	return reinterpret_cast< const char* >( m_Storage.Get() );
+}
+
+// Converts to c-strings
+CUtlString::operator const char*() const
+{
+	return Get();
+}
+
+char *CUtlString::Get()
+{
+	Assert( !m_Storage.IsReadOnly() );
+
+	if ( m_Storage.Length() == 0 )
+	{
+		// In general, we optimise away small mallocs for empty strings
+		// but if you ask for the non-const bytes, they must be writable
+		// so we can't return "" here, like we do for the const version - jd
+		m_Storage.SetLength( 1 );
+		m_Storage[ 0 ] = '\0';
+	}
+
+	return reinterpret_cast< char* >( m_Storage.Get() );
+}
+
+void CUtlString::Purge()
+{
+	m_Storage.Purge();
+}
+
+
+void CUtlString::ToLower()
+{
+	for( int nLength = Length() - 1; nLength >= 0; nLength-- )
+	{
+		m_Storage[ nLength ] = tolower( m_Storage[ nLength ] );
+	}
+}
+
+
+void CUtlString::ToUpper()
+{
+	for( int nLength = Length() - 1; nLength >= 0; nLength-- )
+	{
+		m_Storage[ nLength ] = toupper( m_Storage[ nLength ] );
+	}
+}
+
+
+CUtlString &CUtlString::operator=( const CUtlString &src )
+{
+	Assert( !m_Storage.IsReadOnly() );
+	m_Storage = src.m_Storage;
+	return *this;
+}
+
+CUtlString &CUtlString::operator=( const char *src )
+{
+	Assert( !m_Storage.IsReadOnly() );
+	Set( src );
+	return *this;
+}
+
+bool CUtlString::operator==( const CUtlString &src ) const
+{
+	return m_Storage == src.m_Storage;
+}
+
+bool CUtlString::operator==( const char *src ) const
+{
+	return ( strcmp( Get(), src ) == 0 );
+}
+
+CUtlString &CUtlString::operator+=( const CUtlString &rhs )
+{
+	Assert( !m_Storage.IsReadOnly() );
+
+	const int lhsLength( Length() );
+	const int rhsLength( rhs.Length() );
+	const int requestedLength( lhsLength + rhsLength );
+
+	SetLength( requestedLength );
+	const int allocatedLength( Length() );
+	const int copyLength( allocatedLength - lhsLength < rhsLength ? allocatedLength - lhsLength : rhsLength );
+	memcpy( Get() + lhsLength, rhs.Get(), copyLength );
+	m_Storage[ allocatedLength ] = '\0';
+
+	return *this;
+}
+
+CUtlString &CUtlString::operator+=( const char *rhs )
+{
+	Assert( !m_Storage.IsReadOnly() );
+
+	const int lhsLength( Length() );
+	const int rhsLength( Q_strlen( rhs ) );
+	const int requestedLength( lhsLength + rhsLength );
+
+	SetLength( requestedLength );
+	const int allocatedLength( Length() );
+	const int copyLength( allocatedLength - lhsLength < rhsLength ? allocatedLength - lhsLength : rhsLength );
+	memcpy( Get() + lhsLength, rhs, copyLength );
+	m_Storage[ allocatedLength ] = '\0';
+
+	return *this;
+}
+
+CUtlString &CUtlString::operator+=( char c )
+{
+	Assert( !m_Storage.IsReadOnly() );
+
+	int nLength = Length();
+	SetLength( nLength + 1 );
+	m_Storage[ nLength ] = c;
+	m_Storage[ nLength+1 ] = '\0';
+	return *this;
+}
+
+CUtlString &CUtlString::operator+=( int rhs )
+{
+	Assert( !m_Storage.IsReadOnly() );
+	Assert( sizeof( rhs ) == 4 );
+
+	char tmpBuf[ 12 ];	// Sufficient for a signed 32 bit integer [ -2147483648 to +2147483647 ]
+	Q_snprintf( tmpBuf, sizeof( tmpBuf ), "%d", rhs );
+	tmpBuf[ sizeof( tmpBuf ) - 1 ] = '\0';
+
+	return operator+=( tmpBuf );
+}
+
+CUtlString &CUtlString::operator+=( double rhs )
+{
+	Assert( !m_Storage.IsReadOnly() );
+
+	char tmpBuf[ 256 ];	// How big can doubles be???  Dunno.
+	Q_snprintf( tmpBuf, sizeof( tmpBuf ), "%lg", rhs );
+	tmpBuf[ sizeof( tmpBuf ) - 1 ] = '\0';
+
+	return operator+=( tmpBuf );
+}
+
+bool CUtlString::MatchesPattern( const CUtlString &Pattern, int nFlags )
+{
+	const char *pszSource = String();
+	const char *pszPattern = Pattern.String();
+	bool	bExact = true;
+
+	while( 1 )
+	{
+		if ( ( *pszPattern ) == 0 )
+		{
+			return ( (*pszSource ) == 0 );
+		}
+
+		if ( ( *pszPattern ) == '*' )
+		{
+			pszPattern++;
+
+			if ( ( *pszPattern ) == 0 )
+			{
+				return true;
+			}
+
+			bExact = false;
+			continue;
+		}
+
+		int nLength = 0;
+
+		while( ( *pszPattern ) != '*' && ( *pszPattern ) != 0 )
+		{
+			nLength++;
+			pszPattern++;
+		}
+
+		while( 1 )
+		{
+			const char *pszStartPattern = pszPattern - nLength;
+			const char *pszSearch = pszSource;
+
+			for( int i = 0; i < nLength; i++, pszSearch++, pszStartPattern++ )
+			{
+				if ( ( *pszSearch ) == 0 )
+				{
+					return false;
+				}
+
+				if ( ( *pszSearch ) != ( *pszStartPattern ) )
+				{
+					break;
+				}
+			}
+
+			if ( pszSearch - pszSource == nLength )
+			{
+				break;
+			}
+
+			if ( bExact == true )
+			{
+				return false;
+			}
+
+			if ( ( nFlags & PATTERN_DIRECTORY ) != 0 )
+			{
+				if ( ( *pszPattern ) != '/' && ( *pszSource ) == '/' )
+				{
+					return false;
+				}
+			}
+
+			pszSource++;
+		}
+
+		pszSource += nLength;
+	}
+}
+
+
+int CUtlString::Format( const char *pFormat, ... )
+{
+	Assert( !m_Storage.IsReadOnly() );
+
+	char tmpBuf[ 4096 ];	//< Nice big 4k buffer, as much memory as my first computer had, a Radio Shack Color Computer
+
+	va_list marker;
+
+	va_start( marker, pFormat );
+#ifdef _WIN32
+	int len = _vsnprintf( tmpBuf, sizeof( tmpBuf ) - 1, pFormat, marker );
+#elif POSIX
+	int len = vsnprintf( tmpBuf, sizeof( tmpBuf ) - 1, pFormat, marker );
+#else
+#error "define vsnprintf type."
+#endif
+	va_end( marker );
+
+	// Len > maxLen represents an overflow on POSIX, < 0 is an overflow on windows
+	if( len < 0 || len >= sizeof( tmpBuf ) - 1 )
+	{
+		len = sizeof( tmpBuf ) - 1;
+		tmpBuf[sizeof( tmpBuf ) - 1] = 0;
+	}
+
+	Set( tmpBuf );
+
+	return len;
+}
+
+//-----------------------------------------------------------------------------
+// Strips the trailing slash
+//-----------------------------------------------------------------------------
+void CUtlString::StripTrailingSlash()
+{
+	if ( IsEmpty() )
+		return;
+
+	int nLastChar = Length() - 1;
+	char c = m_Storage[ nLastChar ];
+	if ( c == '\\' || c == '/' )
+	{
+		m_Storage[ nLastChar ] = 0;
+		m_Storage.SetLength( m_Storage.Length() - 1 );
+	}
+}
+
+CUtlString CUtlString::Slice( int32 nStart, int32 nEnd )
+{
+	if ( nStart < 0 )
+		nStart = Length() - (-nStart % Length());
+	else if ( nStart >= Length() )
+		nStart = Length();
+
+	if ( nEnd == 0x7FFFFFFF )
+		nEnd = Length();
+	else if ( nEnd < 0 )
+		nEnd = Length() - (-nEnd % Length());
+	else if ( nEnd >= Length() )
+		nEnd = Length();
+	
+	if ( nStart >= nEnd )
+		return CUtlString( "" );
+
+	const char *pIn = String();
+
+	CUtlString ret;
+	ret.m_Storage.SetLength( nEnd - nStart + 1 );
+	char *pOut = (char*)ret.m_Storage.Get();
+
+	memcpy( ret.m_Storage.Get(), &pIn[nStart], nEnd - nStart );
+	pOut[nEnd - nStart] = 0;
+
+	return ret;
+}
+
+// Grab a substring starting from the left or the right side.
+CUtlString CUtlString::Left( int32 nChars )
+{
+	return Slice( 0, nChars );
+}
+
+CUtlString CUtlString::Right( int32 nChars )
+{
+	return Slice( -nChars );
+}
+
+CUtlString CUtlString::Replace( char cFrom, char cTo )
+{
+	CUtlString ret = *this;
+	int len = ret.Length();
+	for ( int i=0; i < len; i++ )
+	{
+		if ( ret.m_Storage[i] == cFrom )
+			ret.m_Storage[i] = cTo;
+	}
+
+	return ret;
+}
+
+CUtlString CUtlString::AbsPath( const char *pStartingDir )
+{
+	char szNew[MAX_PATH];
+	V_MakeAbsolutePath( szNew, sizeof( szNew ), this->String(), pStartingDir );
+	return CUtlString( szNew );
+}
+
+CUtlString CUtlString::UnqualifiedFilename()
+{
+	const char *pFilename = V_UnqualifiedFileName( this->String() );
+	return CUtlString( pFilename );
+}
+
+CUtlString CUtlString::DirName()
+{
+	CUtlString ret( this->String() );
+	V_StripLastDir( (char*)ret.m_Storage.Get(), ret.m_Storage.Length() );
+	V_StripTrailingSlash( (char*)ret.m_Storage.Get() );
+	return ret;
+}
+
+CUtlString CUtlString::PathJoin( const char *pStr1, const char *pStr2 )
+{
+	char szPath[MAX_PATH];
+	V_ComposeFileName( pStr1, pStr2, szPath, sizeof( szPath ) );
+	return CUtlString( szPath );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: concatenate the provided string to our current content
+//-----------------------------------------------------------------------------
+void CUtlString::Append( const char *pchAddition )
+{
+	*this += pchAddition;
+}

mp/src/tier1/utlsymbol.cpp

@@ -0,0 +1,436 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Defines a symbol table
+//
+// $Header: $
+// $NoKeywords: $
+//=============================================================================//
+
+#pragma warning (disable:4514)
+
+#include "utlsymbol.h"
+#include "KeyValues.h"
+#include "tier0/threadtools.h"
+#include "tier0/memdbgon.h"
+#include "stringpool.h"
+#include "utlhashtable.h"
+#include "utlstring.h"
+
+// Ensure that everybody has the right compiler version installed. The version
+// number can be obtained by looking at the compiler output when you type 'cl'
+// and removing the last two digits and the periods: 16.00.40219.01 becomes 160040219
+#ifdef _MSC_FULL_VER
+	#if _MSC_FULL_VER > 160000000
+		// VS 2010
+		#if _MSC_FULL_VER < 160040219
+			#error You must install VS 2010 SP1
+		#endif
+	#else
+		// VS 2005
+		#if _MSC_FULL_VER < 140050727
+			#error You must install VS 2005 SP1
+		#endif
+	#endif
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#define INVALID_STRING_INDEX CStringPoolIndex( 0xFFFF, 0xFFFF )
+
+#define MIN_STRING_POOL_SIZE	2048
+
+//-----------------------------------------------------------------------------
+// globals
+//-----------------------------------------------------------------------------
+
+CUtlSymbolTableMT* CUtlSymbol::s_pSymbolTable = 0; 
+bool CUtlSymbol::s_bAllowStaticSymbolTable = true;
+
+
+//-----------------------------------------------------------------------------
+// symbol methods
+//-----------------------------------------------------------------------------
+
+void CUtlSymbol::Initialize()
+{
+	// If this assert fails, then the module that this call is in has chosen to disallow
+	// use of the static symbol table. Usually, it's to prevent confusion because it's easy
+	// to accidentally use the global symbol table when you really want to use a specific one.
+	Assert( s_bAllowStaticSymbolTable );
+
+	// necessary to allow us to create global symbols
+	static bool symbolsInitialized = false;
+	if (!symbolsInitialized)
+	{
+		s_pSymbolTable = new CUtlSymbolTableMT;
+		symbolsInitialized = true;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Singleton to delete table on exit from module
+//-----------------------------------------------------------------------------
+class CCleanupUtlSymbolTable
+{
+public:
+	~CCleanupUtlSymbolTable()
+	{
+		delete CUtlSymbol::s_pSymbolTable;
+		CUtlSymbol::s_pSymbolTable = NULL;
+	}
+};
+
+static CCleanupUtlSymbolTable g_CleanupSymbolTable;
+
+CUtlSymbolTableMT* CUtlSymbol::CurrTable()
+{
+	Initialize();
+	return s_pSymbolTable; 
+}
+
+
+//-----------------------------------------------------------------------------
+// string->symbol->string
+//-----------------------------------------------------------------------------
+
+CUtlSymbol::CUtlSymbol( const char* pStr )
+{
+	m_Id = CurrTable()->AddString( pStr );
+}
+
+const char* CUtlSymbol::String( ) const
+{
+	return CurrTable()->String(m_Id);
+}
+
+void CUtlSymbol::DisableStaticSymbolTable()
+{
+	s_bAllowStaticSymbolTable = false;
+}
+
+//-----------------------------------------------------------------------------
+// checks if the symbol matches a string
+//-----------------------------------------------------------------------------
+
+bool CUtlSymbol::operator==( const char* pStr ) const
+{
+	if (m_Id == UTL_INVAL_SYMBOL) 
+		return false;
+	return strcmp( String(), pStr ) == 0;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// symbol table stuff
+//-----------------------------------------------------------------------------
+
+inline const char* CUtlSymbolTable::StringFromIndex( const CStringPoolIndex &index ) const
+{
+	Assert( index.m_iPool < m_StringPools.Count() );
+	Assert( index.m_iOffset < m_StringPools[index.m_iPool]->m_TotalLen );
+
+	return &m_StringPools[index.m_iPool]->m_Data[index.m_iOffset];
+}
+
+
+bool CUtlSymbolTable::CLess::operator()( const CStringPoolIndex &i1, const CStringPoolIndex &i2 ) const
+{
+	// Need to do pointer math because CUtlSymbolTable is used in CUtlVectors, and hence
+	// can be arbitrarily moved in memory on a realloc. Yes, this is portable. In reality,
+	// right now at least, because m_LessFunc is the first member of CUtlRBTree, and m_Lookup
+	// is the first member of CUtlSymbolTabke, this == pTable
+	CUtlSymbolTable *pTable = (CUtlSymbolTable *)( (byte *)this - offsetof(CUtlSymbolTable::CTree, m_LessFunc) ) - offsetof(CUtlSymbolTable, m_Lookup );
+	const char* str1 = (i1 == INVALID_STRING_INDEX) ? pTable->m_pUserSearchString :
+													  pTable->StringFromIndex( i1 );
+	const char* str2 = (i2 == INVALID_STRING_INDEX) ? pTable->m_pUserSearchString :
+													  pTable->StringFromIndex( i2 );
+
+	if ( !str1 && str2 )
+		return false;
+	if ( !str2 && str1 )
+		return true;
+	if ( !str1 && !str2 )
+		return false;
+	if ( !pTable->m_bInsensitive )
+		return V_strcmp( str1, str2 ) < 0;
+	else
+		return V_stricmp( str1, str2 ) < 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// constructor, destructor
+//-----------------------------------------------------------------------------
+CUtlSymbolTable::CUtlSymbolTable( int growSize, int initSize, bool caseInsensitive ) : 
+	m_Lookup( growSize, initSize ), m_bInsensitive( caseInsensitive ), m_StringPools( 8 )
+{
+}
+
+CUtlSymbolTable::~CUtlSymbolTable()
+{
+	// Release the stringpool string data
+	RemoveAll();
+}
+
+
+CUtlSymbol CUtlSymbolTable::Find( const char* pString ) const
+{	
+	if (!pString)
+		return CUtlSymbol();
+	
+	// Store a special context used to help with insertion
+	m_pUserSearchString = pString;
+	
+	// Passing this special invalid symbol makes the comparison function
+	// use the string passed in the context
+	UtlSymId_t idx = m_Lookup.Find( INVALID_STRING_INDEX );
+
+#ifdef _DEBUG
+	m_pUserSearchString = NULL;
+#endif
+
+	return CUtlSymbol( idx );
+}
+
+
+int CUtlSymbolTable::FindPoolWithSpace( int len )	const
+{
+	for ( int i=0; i < m_StringPools.Count(); i++ )
+	{
+		StringPool_t *pPool = m_StringPools[i];
+
+		if ( (pPool->m_TotalLen - pPool->m_SpaceUsed) >= len )
+		{
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Finds and/or creates a symbol based on the string
+//-----------------------------------------------------------------------------
+
+CUtlSymbol CUtlSymbolTable::AddString( const char* pString )
+{
+	if (!pString) 
+		return CUtlSymbol( UTL_INVAL_SYMBOL );
+
+	CUtlSymbol id = Find( pString );
+	
+	if (id.IsValid())
+		return id;
+
+	int len = strlen(pString) + 1;
+
+	// Find a pool with space for this string, or allocate a new one.
+	int iPool = FindPoolWithSpace( len );
+	if ( iPool == -1 )
+	{
+		// Add a new pool.
+		int newPoolSize = max( len, MIN_STRING_POOL_SIZE );
+		StringPool_t *pPool = (StringPool_t*)malloc( sizeof( StringPool_t ) + newPoolSize - 1 );
+		pPool->m_TotalLen = newPoolSize;
+		pPool->m_SpaceUsed = 0;
+		iPool = m_StringPools.AddToTail( pPool );
+	}
+
+	// Copy the string in.
+	StringPool_t *pPool = m_StringPools[iPool];
+	Assert( pPool->m_SpaceUsed < 0xFFFF );	// This should never happen, because if we had a string > 64k, it
+											// would have been given its entire own pool.
+	
+	unsigned short iStringOffset = pPool->m_SpaceUsed;
+
+	memcpy( &pPool->m_Data[pPool->m_SpaceUsed], pString, len );
+	pPool->m_SpaceUsed += len;
+
+	// didn't find, insert the string into the vector.
+	CStringPoolIndex index;
+	index.m_iPool = iPool;
+	index.m_iOffset = iStringOffset;
+
+	UtlSymId_t idx = m_Lookup.Insert( index );
+	return CUtlSymbol( idx );
+}
+
+
+//-----------------------------------------------------------------------------
+// Look up the string associated with a particular symbol
+//-----------------------------------------------------------------------------
+
+const char* CUtlSymbolTable::String( CUtlSymbol id ) const
+{
+	if (!id.IsValid()) 
+		return "";
+	
+	Assert( m_Lookup.IsValidIndex((UtlSymId_t)id) );
+	return StringFromIndex( m_Lookup[id] );
+}
+
+
+//-----------------------------------------------------------------------------
+// Remove all symbols in the table.
+//-----------------------------------------------------------------------------
+
+void CUtlSymbolTable::RemoveAll()
+{
+	m_Lookup.Purge();
+	
+	for ( int i=0; i < m_StringPools.Count(); i++ )
+		free( m_StringPools[i] );
+
+	m_StringPools.RemoveAll();
+}
+
+
+
+class CUtlFilenameSymbolTable::HashTable : public CUtlStableHashtable<CUtlConstString>
+{
+};
+
+CUtlFilenameSymbolTable::CUtlFilenameSymbolTable()
+{
+	m_Strings = new HashTable;
+}
+
+CUtlFilenameSymbolTable::~CUtlFilenameSymbolTable()
+{
+	delete m_Strings;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pFileName - 
+// Output : FileNameHandle_t
+//-----------------------------------------------------------------------------
+FileNameHandle_t CUtlFilenameSymbolTable::FindOrAddFileName( const char *pFileName )
+{
+	if ( !pFileName )
+	{
+		return NULL;
+	}
+
+	// find first
+	FileNameHandle_t hFileName = FindFileName( pFileName );
+	if ( hFileName )
+	{
+		return hFileName;
+	}
+
+	// Fix slashes+dotslashes and make lower case first..
+	char fn[ MAX_PATH ];
+	Q_strncpy( fn, pFileName, sizeof( fn ) );
+	Q_RemoveDotSlashes( fn );
+#ifdef _WIN32
+	Q_strlower( fn );
+#endif
+
+	// Split the filename into constituent parts
+	char basepath[ MAX_PATH ];
+	Q_ExtractFilePath( fn, basepath, sizeof( basepath ) );
+	char filename[ MAX_PATH ];
+	Q_strncpy( filename, fn + Q_strlen( basepath ), sizeof( filename ) );
+
+	// not found, lock and look again
+	FileNameHandleInternal_t handle;
+	m_lock.LockForWrite();
+	handle.path = m_Strings->Insert( basepath ) + 1;
+	handle.file = m_Strings->Insert( filename ) + 1;
+	//handle.path = m_StringPool.FindStringHandle( basepath );
+	//handle.file = m_StringPool.FindStringHandle( filename );
+	//if ( handle.path != m_Strings.InvalidHandle() && handle.file )
+	//{
+		// found
+	//	m_lock.UnlockWrite();
+	//	return *( FileNameHandle_t * )( &handle );
+	//}
+
+	// safely add it
+	//handle.path = m_StringPool.ReferenceStringHandle( basepath );
+	//handle.file = m_StringPool.ReferenceStringHandle( filename );
+	m_lock.UnlockWrite();
+
+	return *( FileNameHandle_t * )( &handle );
+}
+
+FileNameHandle_t CUtlFilenameSymbolTable::FindFileName( const char *pFileName )
+{
+	if ( !pFileName )
+	{
+		return NULL;
+	}
+
+	// Fix slashes+dotslashes and make lower case first..
+	char fn[ MAX_PATH ];
+	Q_strncpy( fn, pFileName, sizeof( fn ) );
+	Q_RemoveDotSlashes( fn );
+#ifdef _WIN32
+	Q_strlower( fn );
+#endif
+
+	// Split the filename into constituent parts
+	char basepath[ MAX_PATH ];
+	Q_ExtractFilePath( fn, basepath, sizeof( basepath ) );
+	char filename[ MAX_PATH ];
+	Q_strncpy( filename, fn + Q_strlen( basepath ), sizeof( filename ) );
+
+	FileNameHandleInternal_t handle;
+
+	Assert( (uint16)(m_Strings->InvalidHandle() + 1) == 0 );
+
+	m_lock.LockForRead();
+	handle.path = m_Strings->Find(basepath) + 1;
+	handle.file = m_Strings->Find(filename) + 1;
+	//handle.path = m_StringPool.FindStringHandle(basepath);
+	//handle.file = m_StringPool.FindStringHandle(filename);
+	m_lock.UnlockRead();
+
+	if ( handle.path == 0 || handle.file == 0 )
+		return NULL;
+
+	return *( FileNameHandle_t * )( &handle );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : handle - 
+// Output : const char
+//-----------------------------------------------------------------------------
+bool CUtlFilenameSymbolTable::String( const FileNameHandle_t& handle, char *buf, int buflen )
+{
+	buf[ 0 ] = 0;
+
+	FileNameHandleInternal_t *internal = ( FileNameHandleInternal_t * )&handle;
+	if ( !internal || !internal->file || !internal->path )
+	{
+		return false;
+	}
+
+	m_lock.LockForRead();
+	//const char *path = m_StringPool.HandleToString(internal->path);
+	//const char *fn = m_StringPool.HandleToString(internal->file);
+	const char *path = (*m_Strings)[ internal->path - 1 ].Get();
+	const char *fn = (*m_Strings)[ internal->file - 1].Get();
+	m_lock.UnlockRead();
+
+	if ( !path || !fn )
+	{
+		return false;
+	}
+
+	Q_strncpy( buf, path, buflen );
+	Q_strncat( buf, fn, buflen, COPY_ALL_CHARACTERS );
+
+	return true;
+}
+
+void CUtlFilenameSymbolTable::RemoveAll()
+{
+	m_Strings->Purge();
+}