Update CUtlSymbolTable and tier1 project file (#190)

* Update CUtlSymbolTable and tier1 project file

* Fix unintended change

* change nullptr to NULL

* Remove utlsymbol

* Fix CUtlStringMap using the wrong variable

* Add default null value to the new argument

* Remove unneeded parameter in CUtlStringMap operator[]

* fix makefile line ending

linux_sdk/Makefile.tier1

@@ -50,7 +50,6 @@ LIB_OBJS= \
 	$(LIB_OBJ_DIR)/undiff.o \
 	$(LIB_OBJ_DIR)/uniqueid.o \
 	$(LIB_OBJ_DIR)/utlbufferutil.o \
-	$(LIB_OBJ_DIR)/utlsymbol.o \
 
 all: dirs $(NAME).$(SHLIBEXT)
 

public/tier1/UtlStringMap.h

@@ -1,4 +1,4 @@
-//===== Copyright <EFBFBD> 1996-2005, Valve Corporation, All rights reserved. ======//
+//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======//
 //
 // Purpose: 
 //
@@ -55,9 +55,9 @@ public:
 		return m_SymbolTable.Find( pString );
 	}
 
-	UtlSymId_t AddString( const char *pString )
+	UtlSymId_t AddString( const char *pString, bool* created = NULL )
 	{
-		CUtlSymbol symbol = m_SymbolTable.AddString( pString );
+		CUtlSymbol symbol = m_SymbolTable.AddString( pString, created );
 		int index = ( int )( UtlSymId_t )symbol;
 		if( m_Vector.Count() <= index )
 		{

public/tier1/utlsymbol.h

@@ -1,4 +1,4 @@
-//===== Copyright <EFBFBD> 1996-2005, Valve Corporation, All rights reserved. ======//
+//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======//
 //
 // Purpose: Defines a symbol table
 //
@@ -102,7 +102,7 @@ public:
 	~CUtlSymbolTable();
 	
 	// Finds and/or creates a symbol based on the string
-	CUtlSymbol AddString( const char* pString );
+	CUtlSymbol AddString( const char* pString, bool* created = NULL );
 
 	// Finds the symbol for pString
 	CUtlSymbol Find( const char* pString ) const;
@@ -174,7 +174,7 @@ protected:
 
 	// stores the string data
 	CUtlVector<StringPool_t*> m_StringPools;
-
+	uint8 unknown[56];
 private:
 	int FindPoolWithSpace( int len ) const;
 	const char* StringFromIndex( const CStringPoolIndex &index ) const;
@@ -193,10 +193,10 @@ public:
 	{
 	}
 
-	CUtlSymbol AddString( const char* pString )
+	CUtlSymbol AddString( const char* pString, bool* created = NULL )
 	{
 		m_lock.LockForWrite();
-		CUtlSymbol result = CUtlSymbolTable::AddString( pString );
+		CUtlSymbol result = CUtlSymbolTable::AddString( pString, created );
 		m_lock.UnlockWrite();
 		return result;
 	}

public/tier1/utlsymbollarge.h

@@ -142,8 +142,8 @@ public:
 	~CUtlSymbolTableLargeBase() { }
 
 	// Finds and/or creates a symbol based on the string
-	CUtlSymbolLarge AddString( const char* pString );
+	CUtlSymbolLarge AddString( const char* pString, bool* created = NULL );
-	CUtlSymbolLarge AddString( const char* pString, int nLength );
+	CUtlSymbolLarge AddString( const char* pString, int nLength, bool* created = NULL );
 
 	// Finds the symbol for pString
 	CUtlSymbolLarge Find( const char* pString ) const;
@@ -326,7 +326,7 @@ inline CUtlSymbolLarge CUtlSymbolTableLargeBase< CASEINSENSITIVE, PAGE_SIZE, MUT
 }
 
 template < bool CASEINSENSITIVE, size_t PAGE_SIZE, class MUTEX_TYPE >
-inline CUtlSymbolLarge CUtlSymbolTableLargeBase< CASEINSENSITIVE, PAGE_SIZE, MUTEX_TYPE >::AddString( const char* pString, int nLength )
+inline CUtlSymbolLarge CUtlSymbolTableLargeBase< CASEINSENSITIVE, PAGE_SIZE, MUTEX_TYPE >::AddString( const char* pString, int nLength, bool* created )
 {	
 	CUtlSymbolLarge sym;
 
@@ -348,9 +348,9 @@ inline CUtlSymbolLarge CUtlSymbolTableLargeBase< CASEINSENSITIVE, PAGE_SIZE, MUT
 }
 
 template < bool CASEINSENSITIVE, size_t PAGE_SIZE, class MUTEX_TYPE >
-inline CUtlSymbolLarge CUtlSymbolTableLargeBase< CASEINSENSITIVE, PAGE_SIZE, MUTEX_TYPE >::AddString( const char* pString )
+inline CUtlSymbolLarge CUtlSymbolTableLargeBase< CASEINSENSITIVE, PAGE_SIZE, MUTEX_TYPE >::AddString( const char* pString, bool* created )
 {	
-	return AddString( pString, pString ? strlen( pString ) : 0 );
+	return AddString( pString, pString ? strlen( pString ) : 0, created );
 }
 
 template < bool CASEINSENSITIVE, size_t PAGE_SIZE, class MUTEX_TYPE >

tier1/tier1.vcxproj.filters

@@ -68,9 +68,6 @@
     <ClCompile Include="utlbufferutil.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="utlsymbol.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\public\tier1\bitbuf.h">

tier1/utlsymbol.cpp

@@ -1,397 +0,0 @@
-//========= Copyright <20> 1996-2005, Valve Corporation, All rights reserved. ============//
-//
-// Purpose: Defines a symbol table
-//
-// $Header: $
-// $NoKeywords: $
-//=============================================================================//
-
-#ifdef _MSC_VER
-#pragma warning (disable:4514)
-#endif
-
-#include "utlsymbol.h"
-#include "KeyValues.h"
-#include "tier0/threadtools.h"
-#include "tier0/memdbgon.h"
-#include "stringpool.h"
-
-// 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 ( !pTable->m_bInsensitive )
-		return strcmp( str1, str2 ) < 0;
-	else
-		return strcmpi( 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();
-}
-
-
-//-----------------------------------------------------------------------------
-// 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
-	strlwr( 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_StringPool.FindStringHandle( basepath );
-	handle.file = m_StringPool.FindStringHandle( filename );
-	if ( handle.path && 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
-	strlwr( 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;
-
-	m_lock.LockForRead();
-	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 )
-	{
-		return false;
-	}
-
-	m_lock.LockForRead();
-	const char *path = m_StringPool.HandleToString(internal->path);
-	const char *fn = m_StringPool.HandleToString(internal->file);
-	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_StringPool.FreeAll();
-}
-
-void CUtlFilenameSymbolTable::SpewStrings()
-{
-	m_lock.LockForRead();
-	m_StringPool.SpewStrings();
-	m_lock.UnlockRead();
-
-}