555 lines
12 KiB
C++
555 lines
12 KiB
C++
//====== Copyright 1996-2004, 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 )
|
|
{
|
|
if ( nChars > 0 )
|
|
{
|
|
m_Storage.SetLength( nChars+1 );
|
|
m_Storage.Set( pValue, nChars );
|
|
m_Storage[nChars] = 0;
|
|
}
|
|
else
|
|
{
|
|
m_Storage.SetLength( 0 );
|
|
}
|
|
}
|
|
|
|
|
|
void CUtlString::Set( const char *pValue )
|
|
{
|
|
Assert( !m_Storage.IsReadOnly() );
|
|
int nLen = pValue ? V_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 ] );
|
|
}
|
|
}
|
|
|
|
|
|
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( V_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 ]
|
|
V_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.
|
|
V_snprintf( tmpBuf, sizeof( tmpBuf ), "%lg", rhs );
|
|
tmpBuf[ sizeof( tmpBuf ) - 1 ] = '\0';
|
|
|
|
return operator+=( tmpBuf );
|
|
}
|
|
|
|
bool CUtlString::MatchesPattern( const CUtlString &Pattern, int nFlags ) const
|
|
{
|
|
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 ) const
|
|
{
|
|
if ( nStart < 0 )
|
|
nStart = Length() - (-nStart % Length());
|
|
else if ( nStart >= Length() )
|
|
nStart = Length();
|
|
|
|
if ( nEnd == INT32_MAX )
|
|
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 ) const
|
|
{
|
|
return Slice( 0, nChars );
|
|
}
|
|
|
|
CUtlString CUtlString::Right( int32 nChars ) const
|
|
{
|
|
return Slice( -nChars );
|
|
}
|
|
|
|
CUtlString CUtlString::Replace( char cFrom, char cTo ) const
|
|
{
|
|
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 ) const
|
|
{
|
|
char szNew[MAX_PATH];
|
|
V_MakeAbsolutePath( szNew, sizeof( szNew ), this->String(), pStartingDir );
|
|
return CUtlString( szNew );
|
|
}
|
|
|
|
CUtlString CUtlString::UnqualifiedFilename() const
|
|
{
|
|
const char *pFilename = V_UnqualifiedFileName( this->String() );
|
|
return CUtlString( pFilename );
|
|
}
|
|
|
|
CUtlString CUtlString::DirName() const
|
|
{
|
|
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 );
|
|
}
|
|
|
|
|
|
CUtlString CUtlString::operator+( const char *pOther ) const
|
|
{
|
|
CUtlString s = *this;
|
|
s += pOther;
|
|
return s;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: concatenate the provided string to our current content
|
|
//-----------------------------------------------------------------------------
|
|
void CUtlString::Append( const char *pchAddition )
|
|
{
|
|
CUtlString s = *this;
|
|
s += pchAddition;
|
|
}
|