Update hash staff & engine sync

interfaces/interfaces.cpp

@@ -6,8 +6,8 @@
 
 /* This is totally reverse-engineered code and may be wrong */
 
-#include "interfaces/interfaces.h"
 #include "tier0/dbg.h"
+#include "interfaces/interfaces.h"
 
 IApplication *g_pApplication;
 ICvar *cvar, *g_pCVar;

public/entity2/entitykeyvalues.h

@@ -248,7 +248,7 @@ inline EntityKeyId_t CEntityKeyValues::GetEntityKeyId( const CEntityKeyValues::I
 	if ( it.index >= it.keys->GetMemberCount() )
 		return EntityKeyId_t();
 
-	return it.keys->GetMemberNameEx( it.index );
+	return it.keys->GetKV3MemberName( it.index );
 }
 
 inline const char* CEntityKeyValues::GetAttributeName( const CEntityKeyValues::Iterator_t &it ) const

public/tier0/dbg.h

@@ -243,6 +243,9 @@ PLATFORM_INTERFACE void Msg( const tchar* pMsg, ... );
 PLATFORM_INTERFACE void Warning( const tchar *pMsg, ... ) FMTFUNCTION( 1, 2 );
 PLATFORM_INTERFACE void Warning_SpewCallStack( int iMaxCallStackLength, const tchar *pMsg, ... ) FMTFUNCTION( 2, 3 );
 
+#define Plat_FatalError( ... ) do { Log_Error( LOG_GENERAL, ##__VA_ARGS__ ); Plat_ExitProcess( EXIT_FAILURE ); } while( 0 )
+#define Plat_FatalErrorFunc
+
 // This is gone in Source2. Provide helper to roughly mimic Source1 behavior
 void Error( const tchar* pMsg, ... ) FMTFUNCTION( 1, 2 );
 inline void Error( const tchar* pMsg, ... )
@@ -312,25 +315,6 @@ PLATFORM_INTERFACE void COM_TimestampedLog( char const *fmt, ... ) FMTFUNCTION(
 
 #endif /* _DEBUG */
 
-//-----------------------------------------------------------------------------
-// Macro to assist in asserting constant invariants during compilation
-
-#define COMPILE_TIME_ASSERT( pred )	static_assert( pred, "Compile time assert constraint is not true: " #pred )
-// ASSERT_INVARIANT used to be needed in order to allow COMPILE_TIME_ASSERTs at global
-// scope. However the new COMPILE_TIME_ASSERT macro supports that by default.
-#define ASSERT_INVARIANT( pred )	COMPILE_TIME_ASSERT( pred )
-
-#ifdef _DEBUG
-template<typename DEST_POINTER_TYPE, typename SOURCE_POINTER_TYPE>
-inline DEST_POINTER_TYPE assert_cast(SOURCE_POINTER_TYPE* pSource)
-{
-    Assert( static_cast<DEST_POINTER_TYPE>(pSource) == dynamic_cast<DEST_POINTER_TYPE>(pSource) );
-    return static_cast<DEST_POINTER_TYPE>(pSource);
-}
-#else
-#define assert_cast static_cast
-#endif
-
 //-----------------------------------------------------------------------------
 // Templates to assist in validating pointers:
 

public/tier0/platform.h

@@ -81,6 +81,17 @@ class CBufferString;
 // scope. However the new COMPILE_TIME_ASSERT macro supports that by default.
 #define ASSERT_INVARIANT( pred )	COMPILE_TIME_ASSERT( pred )
 
+#ifdef _DEBUG
+template<typename DEST_POINTER_TYPE, typename SOURCE_POINTER_TYPE>
+inline DEST_POINTER_TYPE assert_cast(SOURCE_POINTER_TYPE* pSource)
+{
+	Assert( static_cast<DEST_POINTER_TYPE>(pSource) == dynamic_cast<DEST_POINTER_TYPE>(pSource) );
+	return static_cast<DEST_POINTER_TYPE>(pSource);
+}
+#else
+#define assert_cast static_cast
+#endif
+
 // feature enables
 #define NEW_SOFTWARE_LIGHTING
 #if !defined( _X360 )
@@ -1117,8 +1128,6 @@ PLATFORM_INTERFACE void				Plat_ExitProcess( int nCode );
 
 PLATFORM_INTERFACE bool				Plat_ShouldCollectMiniDumpsForFatalErrors();
 
-PLATFORM_INTERFACE void				Plat_FatalErrorFunc( const tchar* pMsg, ... ) FMTFUNCTION( 1, 2 );
-
 // b/w compatibility
 #define Sys_FloatTime Plat_FloatTime
 

public/tier1/CommandBuffer.h

@@ -69,6 +69,10 @@ class CCommandBuffer
 	// Indicates how long to delay when encoutering a 'wait' command
 	void SetWaitDelayTime( int nTickDelay );
 
+	// Compartmentalizes cfg-like commands.
+	// nLength can be -1
+	DLL_CLASS_IMPORT void SplitCommands( const char *pText, int nLength, CUtlVector< CUtlString > &outString );
+
 	// Returns a handle to the next command to process
 	// (useful when inserting commands into the buffer during processing
 	// of commands to force immediate execution of those commands,

public/tier1/UtlStringMap.h

@@ -6,27 +6,31 @@
 
 #ifndef UTLSTRINGMAP_H
 #define UTLSTRINGMAP_H
+
 #ifdef _WIN32
 #pragma once
 #endif
 
 #include "utlsymbol.h"
 
+#define FOR_EACH_STRING_MAP( mapName, iter ) \
+	for ( auto iter = (mapName).First(); iter < (mapName).GetNumStrings() && iter != (mapName).InvalidIndex(); iter = (mapName).Next( iter ) )
+
 template <class T>
 class CUtlStringMap
 {
 public:
 	CUtlStringMap( bool caseInsensitive = true, int initsize = 32 ) : 
-	  m_SymbolTable( 0, 32, caseInsensitive ),
-		  m_Vector( initsize )
+		  m_Vector( initsize ),
+		  m_SymbolTable( 0, 32, caseInsensitive )
 	{
 	}
 
 	// Get data by the string itself:
 	T& operator[]( const char *pString )
 	{
 		CUtlSymbol symbol = m_SymbolTable.AddString( pString );
-		int index = ( int )( UtlSymId_t )symbol;
+		int index = ( int )symbol;
 		if( m_Vector.Count() <= index )
 		{
 			m_Vector.EnsureCount( index + 1 );
@@ -35,44 +39,119 @@ class CUtlStringMap
 	}
 
 	// Get data by the string's symbol table ID - only used to retrieve a pre-existing symbol, not create a new one!
-	T& operator[]( UtlSymId_t n )
+	T& operator[]( CUtlSymbol n )
 	{
 		Assert( n <= m_Vector.Count() );
 		return m_Vector[n];
 	}
 
-	const T& operator[]( UtlSymId_t n ) const
+	const T& operator[]( CUtlSymbol n ) const
 	{
 		Assert( n <= m_Vector.Count() );
 		return m_Vector[n];
 	}
 
+	unsigned int Count() const
+	{
+		// Assert( m_Vector.Count() == m_SymbolTable.GetNumStrings() );
+		return m_Vector.Count();
+	}
+
 	bool Defined( const char *pString ) const
 	{
 		return m_SymbolTable.Find( pString ).IsValid();
 	}
 
-	UtlSymId_t Find( const char *pString ) const
+	CUtlSymbol Find( const char *pString ) const
 	{
 		return m_SymbolTable.Find( pString );
 	}
 
-	UtlSymId_t AddString( const char *pString, bool* created = NULL )
+	CUtlSymbol AddString( const char *pString, bool* created = NULL )
 	{
 		CUtlSymbol symbol = m_SymbolTable.AddString( pString, created );
-		int index = ( int )( UtlSymId_t )symbol;
+		int index = ( int )symbol;
 		if( m_Vector.Count() <= index )
 		{
 			m_Vector.EnsureCount( index + 1 );
 		}
 		return symbol;
 	}
 
-	static UtlSymId_t InvalidIndex()
+	/// Add a string to the map and also insert an item at 
+	/// its location in the same operation. Returns the 
+	/// newly created index (or the one that was just 
+	/// overwritten, if pString already existed.)
+	CUtlSymbol Insert( const char *pString, const T &item )
+	{
+		CUtlSymbol symbol = m_SymbolTable.AddString( pString ); // implicit coercion
+		if ( m_Vector.Count() > symbol ) 
+		{
+			// this string is already in the dictionary.
+
+		}
+		else if ( m_Vector.Count() == symbol )
+		{
+			// this is the expected case when we've added one more to the tail.
+			m_Vector.AddToTail( item );
+		}
+		else // ( m_Vector.Count() < symbol )
+		{
+			// this is a strange shouldn't-happen case.
+			AssertMsg( false, "CUtlStringMap insert unexpected entries." );
+			m_Vector.EnsureCount( symbol + 1 );
+			m_Vector[symbol] = item;
+		}
+		return symbol;
+	}
+
+	bool FindAndRemove( const char *pString )
+	{
+		CUtlSymbol symbol = m_SymbolTable.Find( pString );
+
+		if ( !symbol.IsValid() )
+		{
+			return false;
+		}
+
+		Destruct( &m_Vector[ symbol ] );
+		m_Vector[ symbol ] = {};
+		m_SymbolTable.Remove( symbol );
+
+		return true;
+	}
+
+	/// iterate, not in any particular order.
+	CUtlSymbol First() const 
+	{
+		if ( Count() > 0 )
+		{
+			return 0;
+		}
+		else
+		{
+			return InvalidIndex();
+		}
+	}
+
+	static CUtlSymbol InvalidIndex()
+	{
+		return {};
+	}
+
+	// iterators (for uniformity with other map types)
+	inline CUtlSymbol Head() const
 	{
-		return UTL_INVAL_SYMBOL;
+		return m_SymbolTable.GetNumStrings() > 0 ? CUtlSymbol( 0 )  : InvalidIndex();
 	}
 
+	inline CUtlSymbol Next( const CUtlSymbol &i ) const
+	{
+		CUtlSymbol n = i+1;
+		return n < m_SymbolTable.GetNumStrings() ? n : InvalidIndex();
+	}
+
+
 	int GetNumStrings( void ) const
 	{
 		return m_SymbolTable.GetNumStrings();
@@ -109,4 +188,16 @@ class CUtlStringMap
 	CUtlSymbolTable m_SymbolTable;
 };
 
+
+template< class T >
+class CUtlStringMapAutoPurge : public CUtlStringMap < T >
+{
+public:
+	~CUtlStringMapAutoPurge( void )
+	{
+		this->PurgeAndDeleteElements();
+	}
+
+};
+
 #endif // UTLSTRINGMAP_H

public/tier1/bufferstring.h

@@ -83,7 +83,6 @@ class CBufferString
 		m_nAllocatedSize( (bAllowHeapAllocation * ALLOW_HEAP_ALLOCATION) | STACK_ALLOCATED_MARKER | (nAllocatedSize + sizeof( m_szString )) ),
 		m_pString( nullptr )
 	{
-		Assert( nAllocatedSize > 8 );
 	}
 
 public:
@@ -122,11 +121,11 @@ class CBufferString
 	bool IsAllocationEmpty() const { return AllocatedNum() == 0; }
 
 protected:
-	char *Base() { return IsStackAllocated() ? m_szString : (!IsAllocationEmpty() ? m_pString : nullptr); }
+	char *Base() { return IsStackAllocated() ? m_szString : m_pString; }
 	const char *Base() const { return const_cast<CBufferString *>( this )->Base(); }
 
 public:
-	const char *Get() const { auto base = Base(); return base ? base : StringFuncs<char>::EmptyString(); }
+	const char *Get() const { return IsStackAllocated() ? m_szString : (IsAllocationEmpty() ? StringFuncs<char>::EmptyString() : m_pString); }
 
 	void Clear()
 	{
@@ -269,8 +268,8 @@ class CBufferString
 	DLL_CLASS_IMPORT const char *StripExtension();
 	DLL_CLASS_IMPORT const char *StripTrailingSlash();
 
-	DLL_CLASS_IMPORT void ToLowerFast(int nStart);
-	DLL_CLASS_IMPORT void ToUpperFast(int nStart);
+	DLL_CLASS_IMPORT void ToLowerFast(int nStart = 0);
+	DLL_CLASS_IMPORT void ToUpperFast(int nStart = 0);
 
 	DLL_CLASS_IMPORT const char *Trim(const char *pTrimChars = "\t\r\n ");
 	DLL_CLASS_IMPORT const char *TrimHead(const char *pTrimChars = "\t\r\n ");
@@ -292,19 +291,14 @@ class CBufferString
 	};
 };
 
-template<size_t SIZE>
+template< uintp SIZE = 128 > // Most commonly used.
 class CBufferStringN : public CBufferString
 {
 public:
-	static const size_t DATA_SIZE = ALIGN_VALUE( SIZE - sizeof( char[8] ), 8 );
+	static const uintp DATA_SIZE = ALIGN_VALUE( SIZE - sizeof( char[8] ), 8 );
 
-	CBufferStringN( bool bAllowHeapAllocation = true ) : CBufferString( DATA_SIZE, bAllowHeapAllocation ), m_FixedData{} {}
-	CBufferStringN( const char *pString, bool bAllowHeapAllocation = true ) : CBufferStringN( bAllowHeapAllocation )
-	{
-		Insert( 0, pString );
-	}
-
-	~CBufferStringN() { PurgeN(); }
+	CBufferStringN( bool bAllowHeapAllocation = true ) : CBufferString( DATA_SIZE, bAllowHeapAllocation ) {}
+	CBufferStringN( const char *pString, int nLen = -1, bool bAllowHeapAllocation = true ) : CBufferStringN( bAllowHeapAllocation ) { Insert( 0, pString, nLen ); }
 
 	// Should be preferred over CBufferString::Purge as it preserves stack space correctly
 	void PurgeN() { Purge( DATA_SIZE ); }
@@ -314,7 +308,7 @@ class CBufferStringN : public CBufferString
 };
 
 // AMNOTE: CBufferStringN name is preferred to be used, altho CBufferStringGrowable is left as a small bcompat
-template <size_t SIZE>
+template< uintp SIZE >
 using CBufferStringGrowable = CBufferStringN<SIZE>;
 
 #endif /* BUFFERSTRING_H */