tf2/tf2_src/public/kevvaluescompiler.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================
#include "keyvaluescompiler.h"
#include "filesystem.h"
#include "tier1/KeyValues.h"

extern IFileSystem *g_pFullFileSystem;

bool CRunTimeKeyValuesStringTable::ReadStringTable( int numStrings, CUtlBuffer& buf )
{
	Assert( m_Strings.Count() == 0 );

	CUtlVector< int > offsets;
	offsets.EnsureCapacity( numStrings );

	offsets.CopyArray( (int *)( buf.PeekGet() ), numStrings );

	// Skip over data
	buf.SeekGet( CUtlBuffer::SEEK_HEAD, buf.TellGet() + numStrings * sizeof( int ) );

	int stringSize = buf.GetInt();
	
	// Read in the string table
	m_Strings.EnsureCapacity( numStrings );
	int i;
	for ( i = 0 ; i < numStrings; ++i )
	{
		m_Strings.AddToTail( (const char *)buf.PeekGet( offsets[ i ] ) );
	}

	buf.SeekGet( CUtlBuffer::SEEK_HEAD, buf.TellGet() + stringSize );

	return true;
}

void CCompiledKeyValuesWriter::BuildKVData_R( KeyValues *kv, int parent )
{
	// Add self
	KVInfo_t info;
	info.key = m_StringTable.AddString( kv->GetName() );
	info.value = m_StringTable.AddString( kv->GetString() );

	info.SetSubTree( kv->GetFirstSubKey() != NULL ? true : false );
	info.SetParent( parent );

	int newParent = m_Data.AddToTail( info );

	// Then add children
	for ( KeyValues *sub = kv->GetFirstSubKey(); sub; sub = sub->GetNextKey() )
	{
		BuildKVData_R( sub, newParent );
	}

	// Then add peers
	if ( parent == -1 )
	{
		if ( kv->GetNextKey() )
		{
			BuildKVData_R( kv->GetNextKey(), parent );
		}
	}
}

void CCompiledKeyValuesWriter::Describe( const KVFile_t& file )
{
	Msg( "file( %s )\n", m_StringTable.String( file.filename ) );

	int c = file.numElements;
	for ( int i = 0; i < c; ++i )
	{
		KVInfo_t &info = m_Data[ file.firstElement + i ];
		if ( info.IsSubTree() )
		{
			Msg( "%d:  %s -> subtree at parent %i\n",
				file.firstElement + i,
				m_StringTable.String( info.key ),
				info.GetParent() );
		}
		else
		{
			Msg( "%d:  %s -> %s at parent %i\n",
				file.firstElement + i,
				m_StringTable.String( info.key ),
				m_StringTable.String( info.value ),
				info.GetParent() );
		}
	}
}

void CCompiledKeyValuesWriter::AppendKeyValuesFile( char const *filename )
{
	KVFile_t kvf;
	kvf.filename = m_StringTable.AddString( filename );
	kvf.firstElement = m_Data.Count();

	KeyValues *kv = new KeyValues( filename );
	if ( kv->LoadFromFile( g_pFullFileSystem, filename ) )
	{
		// Add to dictionary
		// do a depth first traversal of the keyvalues
		BuildKVData_R( kv, -1 );
	}
	kv->deleteThis();

	kvf.numElements = m_Data.Count() - kvf.firstElement;

//	Describe( kvf );

	m_Files.AddToTail( kvf );
}

void CCompiledKeyValuesWriter::WriteData( CUtlBuffer& buf )
{
	int c = m_Data.Count();
	buf.PutInt( c );
	for ( int i = 0; i < c; ++i )
	{
		KVInfo_t &info = m_Data[ i ];
		buf.PutShort( info.key );
		buf.PutShort( info.value );
		buf.PutShort( info.GetParent() );
		buf.PutChar( info.IsSubTree() ? 1 : 0 );
	}
}

void CCompiledKeyValuesWriter::WriteFiles( CUtlBuffer &buf )
{
	int c = m_Files.Count();
	buf.PutInt( c );
	for ( int i = 0; i < c; ++i )
	{
		KVFile_t &file = m_Files[ i ];
		buf.PutShort( file.filename );
		buf.PutShort( file.firstElement );
		buf.PutShort( file.numElements );
	}
}

void CCompiledKeyValuesWriter::WriteStringTable( CUtlBuffer& buf )
{
	int i;
	CUtlVector< int >	offsets;

	CUtlBuffer stringBuffer;

	offsets.AddToTail( stringBuffer.TellPut() );

	stringBuffer.PutString( "" );
	// save all the rest
	int c = m_StringTable.GetNumStrings();
	for ( i = 1; i < c; i++)
	{
		offsets.AddToTail( stringBuffer.TellPut() );
		stringBuffer.PutString( m_StringTable.String( i ) );
	}

	buf.Put( offsets.Base(), offsets.Count() * sizeof( int ) );

	buf.PutInt( stringBuffer.TellPut() );
	buf.Put( stringBuffer.Base(), stringBuffer.TellPut() );
}

void CCompiledKeyValuesWriter::WriteFile( char const *outfile )
{
	CUtlBuffer buf;

	// Write the data file out
	KVHeader_t header;
	header.fileid		= COMPILED_KEYVALUES_ID;
	header.version		= COMPILED_KEYVALUES_VERSION;
	header.numStrings	= m_StringTable.GetNumStrings();

	buf.Put( &header, sizeof( header ) );

	WriteStringTable( buf );
	WriteData( buf );
	WriteFiles( buf );

	g_pFullFileSystem->WriteFile( outfile, NULL, buf );
}

CCompiledKeyValuesReader::CCompiledKeyValuesReader()
	: m_Dict( 0, 0, FileInfo_t::Less )
{
}

int CCompiledKeyValuesReader::First() const
{
	return m_Dict.FirstInorder();
}

int CCompiledKeyValuesReader::Next( int i ) const
{
	return m_Dict.NextInorder( i );
}

int CCompiledKeyValuesReader::InvalidIndex() const
{
	return m_Dict.InvalidIndex();
}

void CCompiledKeyValuesReader::GetFileName( int index, char *buf, size_t bufsize )
{
	Assert( buf );
	buf[ 0 ] = 0;
	FileNameHandle_t& handle = m_Dict[ index ].hFile;
	g_pFullFileSystem->String( handle, buf, bufsize );
}

bool CCompiledKeyValuesReader::LoadFile( char const *filename )
{
	int i;
	m_LoadBuffer.Purge();

	g_pFullFileSystem->ReadFile( filename, NULL, m_LoadBuffer );

	KVHeader_t header;
	m_LoadBuffer.Get( &header, sizeof( header ) );

	if ( header.fileid != COMPILED_KEYVALUES_ID )
	{
		return false;
	}

	if ( header.version != COMPILED_KEYVALUES_VERSION )
	{
		return false;
	}

	if ( !m_StringTable.ReadStringTable( header.numStrings, m_LoadBuffer ) )
	{
		return false;
	}

	// Now parse the data
	int dataCount = m_LoadBuffer.GetInt();
	m_Data.EnsureCapacity( dataCount );
	for ( i = 0; i < dataCount; ++i )
	{
		KVInfo_t info;
		info.key = m_LoadBuffer.GetShort();
		info.value = m_LoadBuffer.GetShort();
		info.SetParent( m_LoadBuffer.GetShort() );
		info.SetSubTree( m_LoadBuffer.GetChar() == 1 ? true : false );
		m_Data.AddToTail( info );
	}

	int fileCount = m_LoadBuffer.GetInt();
	for ( i = 0; i < fileCount; ++i )
	{
		FileInfo_t kvf;
		short fileNameString	= m_LoadBuffer.GetShort();

		kvf.hFile		= g_pFullFileSystem->FindOrAddFileName( m_StringTable.Lookup( fileNameString ) );
		kvf.nFirstIndex = m_LoadBuffer.GetShort();
		kvf.nCount		= m_LoadBuffer.GetShort();

		m_Dict.Insert( kvf );
	}

	return true;
}

struct CreateHelper_t
{
	int			index;
	KeyValues	*kv;
	KeyValues	*tail;

	static bool Less( const CreateHelper_t& lhs, const CreateHelper_t& rhs )
	{
		return lhs.index < rhs.index;
	}
};

KeyValues *CCompiledKeyValuesReader::CreateFromData( const FileInfo_t& info )
{
	KeyValues *head = new KeyValues( "" );
	if ( CreateInPlaceFromData( *head, info ) )
	{
		return head;
	}
	else
	{
		head->deleteThis();
		return NULL;
	}
}

bool CCompiledKeyValuesReader::CreateInPlaceFromData( KeyValues& head, const FileInfo_t& info )
{
	int first = info.nFirstIndex;
	int num = info.nCount;

	KeyValues *root = NULL;
	KeyValues *tail = NULL;

	CUtlRBTree< CreateHelper_t, int >	helper( 0, 0, CreateHelper_t::Less );

	for ( int i = 0; i < num; ++i )
	{
		int offset = first + i;
		KVInfo_t& info = m_Data[ offset ];

		if ( info.GetParent() != -1 )
		{
			CreateHelper_t search;
			search.index = info.GetParent();
			int idx = helper.Find( search );
			if ( idx == helper.InvalidIndex() )
			{
				return NULL;
			}

			KeyValues *parent = helper[ idx ].kv;
			Assert( parent );

			KeyValues *sub = new KeyValues( m_StringTable.Lookup( info.key ) );

			if ( !info.IsSubTree() )
			{
				sub->SetStringValue(m_StringTable.Lookup( info.value ) );
			}

			if ( !parent->GetFirstSubKey() )
			{
				parent->AddSubKey( sub );
			}
			else
			{
				KeyValues *last = helper[ idx ].tail;
				last->SetNextKey( sub );
			}

			helper[ idx ].tail = sub;

			CreateHelper_t insert;
			insert.index = offset;
			insert.kv = sub;
			insert.tail = NULL;
			helper.Insert( insert );
		}
		else
		{
			if ( !root )
			{
				root = &head;
				root->SetName( m_StringTable.Lookup( info.key ) );
				tail = root;

				CreateHelper_t insert;
				insert.index = offset;
				insert.kv = root;
				insert.tail = NULL;
				helper.Insert( insert );
			}
			else
			{
				CreateHelper_t insert;
				insert.index = offset;
				insert.kv = new KeyValues( m_StringTable.Lookup( info.key ) );
				insert.tail = NULL;
				helper.Insert( insert );

				tail->SetNextKey( insert.kv );
				tail = insert.kv;
			}
		}
	}
	return true;
}


bool CCompiledKeyValuesReader::InstanceInPlace( KeyValues& head, char const *kvfilename )
{
	char sz[ 512 ];
	Q_strncpy( sz, kvfilename, sizeof( sz ) );
	Q_FixSlashes( sz );

	FileInfo_t search;
	search.hFile = g_pFullFileSystem->FindOrAddFileName( sz );

	int idx = m_Dict.Find( search );
	if ( idx == m_Dict.InvalidIndex() )
	{
		return false;
	}

	const FileInfo_t& info = m_Dict[ idx ];

	return CreateInPlaceFromData( head, info );
}

KeyValues *CCompiledKeyValuesReader::Instance( char const *kvfilename )
{
	char sz[ 512 ];
	Q_strncpy( sz, kvfilename, sizeof( sz ) );
	Q_FixSlashes( sz );

	FileInfo_t search;
	search.hFile = g_pFullFileSystem->FindOrAddFileName( sz );

	int idx = m_Dict.Find( search );
	if ( idx == m_Dict.InvalidIndex() )
	{
		return NULL;
	}

	const FileInfo_t& info = m_Dict[ idx ];

	return CreateFromData( info );
}

bool CCompiledKeyValuesReader::LookupKeyValuesRootKeyName( char const *kvfilename, char *outbuf, size_t bufsize )
{
	char sz[ 512 ];
	Q_strncpy( sz, kvfilename, sizeof( sz ) );
	Q_FixSlashes( sz );

	FileInfo_t search;
	search.hFile = g_pFullFileSystem->FindOrAddFileName( sz );

	int idx = m_Dict.Find( search );
	if ( idx == m_Dict.InvalidIndex() )
	{
		return false;
	}

	const FileInfo_t& info = m_Dict[ idx ];

	Q_strncpy( outbuf, m_StringTable.Lookup( m_Data[ info.nFirstIndex ].key ), bufsize );
	return true;
}