/*
===========================================================================

Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  

Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "precompiled.h"
#pragma hdrstop

idStrPool		idDict::globalKeys;
idStrPool		idDict::globalValues;

/*
================
idDict::operator=

  clear existing key/value pairs and copy all key/value pairs from other
================
*/
idDict &idDict::operator=( const idDict &other ) {
	int i;

	// check for assignment to self
	if ( this == &other ) {
		return *this;
	}

	Clear();

	args = other.args;
	argHash = other.argHash;

	for ( i = 0; i < args.Num(); i++ ) {
		args[i].key = globalKeys.CopyString( args[i].key );
		args[i].value = globalValues.CopyString( args[i].value );
	}

	return *this;
}

/*
================
idDict::Copy

  copy all key value pairs without removing existing key/value pairs not present in the other dict
================
*/
void idDict::Copy( const idDict &other ) {
	int i, n, *found;
	idKeyValue kv;

	// check for assignment to self
	if ( this == &other ) {
		return;
	}

	n = other.args.Num();

	if ( args.Num() ) {
		found = (int *) _alloca16( other.args.Num() * sizeof( int ) );
        for ( i = 0; i < n; i++ ) {
			found[i] = FindKeyIndex( other.args[i].GetKey() );
		}
	} else {
		found = NULL;
	}

	for ( i = 0; i < n; i++ ) {
		if ( found && found[i] != -1 ) {
			// first set the new value and then free the old value to allow proper self copying
			const idPoolStr *oldValue = args[found[i]].value;
			args[found[i]].value = globalValues.CopyString( other.args[i].value );
			globalValues.FreeString( oldValue );
		} else {
			kv.key = globalKeys.CopyString( other.args[i].key );
			kv.value = globalValues.CopyString( other.args[i].value );
			argHash.Add( argHash.GenerateKey( kv.GetKey(), false ), args.Append( kv ) );
		}
	}
}

/*
================
idDict::TransferKeyValues

  clear existing key/value pairs and transfer key/value pairs from other
================
*/
void idDict::TransferKeyValues( idDict &other ) {
	int i, n;

	if ( this == &other ) {
		return;
	}

	if ( other.args.Num() && other.args[0].key->GetPool() != &globalKeys ) {
		common->FatalError( "idDict::TransferKeyValues: can't transfer values across a DLL boundary" );
		return;
	}

	Clear();

	n = other.args.Num();
	args.SetNum( n );
	for ( i = 0; i < n; i++ ) {
		args[i].key = other.args[i].key;
		args[i].value = other.args[i].value;
	}
	argHash = other.argHash;

	other.args.Clear();
	other.argHash.Free();
}

/*
================
idDict::Parse
================
*/
bool idDict::Parse( idParser &parser ) {
	idToken	token;
	idToken	token2;
	bool	errors;

	errors = false;

	parser.ExpectTokenString( "{" );
	parser.ReadToken( &token );
	while( ( token.type != TT_PUNCTUATION ) || ( token != "}" ) ) {
		if ( token.type != TT_STRING ) {
			parser.Error( "Expected quoted string, but found '%s'", token.c_str() );
		}

		if ( !parser.ReadToken( &token2 ) ) {
			parser.Error( "Unexpected end of file" );
		}

		if ( FindKey( token ) ) {
			parser.Warning( "'%s' already defined", token.c_str() );
			errors = true;
		}
		Set( token, token2 );

		if ( !parser.ReadToken( &token ) ) {
			parser.Error( "Unexpected end of file" );
		}
	}

	return !errors;
}

/*
================
idDict::SetDefaults
================
*/
void idDict::SetDefaults( const idDict *dict ) {
	int i, n;
	const idKeyValue *kv, *def;
	idKeyValue newkv;

	n = dict->args.Num();
	for( i = 0; i < n; i++ ) {
		def = &dict->args[i];
		kv = FindKey( def->GetKey() );
		if ( !kv ) {
			newkv.key = globalKeys.CopyString( def->key );
			newkv.value = globalValues.CopyString( def->value );
			argHash.Add( argHash.GenerateKey( newkv.GetKey(), false ), args.Append( newkv ) );
		}
	}
}

/*
================
idDict::Clear
================
*/
void idDict::Clear() {
	int i;

	for( i = 0; i < args.Num(); i++ ) {
		globalKeys.FreeString( args[i].key );
		globalValues.FreeString( args[i].value );
	}

	args.Clear();
	argHash.Free();
}

/*
================
idDict::Print
================
*/
void idDict::Print() const {
	int i;
	int n;

	n = args.Num();
	for( i = 0; i < n; i++ ) {
		idLib::common->Printf( "%s = %s\n", args[i].GetKey().c_str(), args[i].GetValue().c_str() );
	}
}

int KeyCompare( const idKeyValue *a, const idKeyValue *b ) {
	return idStr::Cmp( a->GetKey(), b->GetKey() );
}

/*
================
idDict::Checksum
================
*/
int	idDict::Checksum() const {
	unsigned long ret;
	int i, n;

	idList<idKeyValue> sorted = args;
	sorted.SortWithTemplate( idSort_KeyValue() );
	n = sorted.Num();
	CRC32_InitChecksum( ret );
	for( i = 0; i < n; i++ ) {
		CRC32_UpdateChecksum( ret, sorted[i].GetKey().c_str(), sorted[i].GetKey().Length() );
		CRC32_UpdateChecksum( ret, sorted[i].GetValue().c_str(), sorted[i].GetValue().Length() );
	}
	CRC32_FinishChecksum( ret );
	return ret;
}

/*
================
idDict::Allocated
================
*/
size_t idDict::Allocated() const {
	int		i;
	size_t	size;

	size = args.Allocated() + argHash.Allocated();
	for( i = 0; i < args.Num(); i++ ) {
		size += args[i].Size();
	}

	return size;
}

/*
================
idDict::Set
================
*/
void idDict::Set( const char *key, const char *value ) {
	int i;
	idKeyValue kv;

	if ( key == NULL || key[0] == '\0' ) {
		return;
	}

	i = FindKeyIndex( key );
	if ( i != -1 ) {
		// first set the new value and then free the old value to allow proper self copying
		const idPoolStr *oldValue = args[i].value;
		args[i].value = globalValues.AllocString( value );
		globalValues.FreeString( oldValue );
	} else {
		kv.key = globalKeys.AllocString( key );
		kv.value = globalValues.AllocString( value );
		argHash.Add( argHash.GenerateKey( kv.GetKey(), false ), args.Append( kv ) );
	}
}

/*
================
idDict::GetFloat
================
*/
bool idDict::GetFloat( const char *key, const char *defaultString, float &out ) const {
	const char	*s;
	bool		found;

	found = GetString( key, defaultString, &s );
	out = atof( s );
	return found;
}

/*
================
idDict::GetInt
================
*/
bool idDict::GetInt( const char *key, const char *defaultString, int &out ) const {
	const char	*s;
	bool		found;

	found = GetString( key, defaultString, &s );
	out = atoi( s );
	return found;
}

/*
================
idDict::GetBool
================
*/
bool idDict::GetBool( const char *key, const char *defaultString, bool &out ) const {
	const char	*s;
	bool		found;

	found = GetString( key, defaultString, &s );
	out = ( atoi( s ) != 0 );
	return found;
}

/*
================
idDict::GetFloat
================
*/
bool idDict::GetFloat( const char *key, const float defaultFloat, float &out ) const {
	const idKeyValue *kv = FindKey( key );
	if ( kv ) {
		out = atof( kv->GetValue() );
		return true;
	} else {
		out = defaultFloat;
		return false;
	}
}

/*
================
idDict::GetInt
================
*/
bool idDict::GetInt( const char *key, const int defaultInt, int &out ) const {
	const idKeyValue *kv = FindKey( key );
	if ( kv ) {
		out = atoi( kv->GetValue() );
		return true;
	} else {
		out = defaultInt;
		return false;
	}
}

/*
================
idDict::GetBool
================
*/
bool idDict::GetBool( const char *key, const bool defaultBool, bool &out ) const {
	const idKeyValue *kv = FindKey( key );
	if ( kv ) {
		out = ( atoi( kv->GetValue() ) != 0 );
		return true;
	} else {
		out = defaultBool;
		return false;
	}
}

/*
================
idDict::GetAngles
================
*/
bool idDict::GetAngles( const char *key, const char *defaultString, idAngles &out ) const {
	bool		found;
	const char	*s;
	
	if ( !defaultString ) {
		defaultString = "0 0 0";
	}

	found = GetString( key, defaultString, &s );
	out.Zero();	
	sscanf( s, "%f %f %f", &out.pitch, &out.yaw, &out.roll );
	return found;
}

/*
================
idDict::GetVector
================
*/
bool idDict::GetVector( const char *key, const char *defaultString, idVec3 &out ) const {
	bool		found;
	const char	*s;
	
	if ( !defaultString ) {
		defaultString = "0 0 0";
	}

	found = GetString( key, defaultString, &s );
	out.Zero();
	sscanf( s, "%f %f %f", &out.x, &out.y, &out.z );
	return found;
}

/*
================
idDict::GetVec2
================
*/
bool idDict::GetVec2( const char *key, const char *defaultString, idVec2 &out ) const {
	bool		found;
	const char	*s;
	
	if ( !defaultString ) {
		defaultString = "0 0";
	}

	found = GetString( key, defaultString, &s );
	out.Zero();
	sscanf( s, "%f %f", &out.x, &out.y );
	return found;
}

/*
================
idDict::GetVec4
================
*/
bool idDict::GetVec4( const char *key, const char *defaultString, idVec4 &out ) const {
	bool		found;
	const char	*s;
	
	if ( !defaultString ) {
		defaultString = "0 0 0 0";
	}

	found = GetString( key, defaultString, &s );
	out.Zero();
	sscanf( s, "%f %f %f %f", &out.x, &out.y, &out.z, &out.w );
	return found;
}

/*
================
idDict::GetMatrix
================
*/
bool idDict::GetMatrix( const char *key, const char *defaultString, idMat3 &out ) const {
	const char	*s;
	bool		found;
		
	if ( !defaultString ) {
		defaultString = "1 0 0 0 1 0 0 0 1";
	}

	found = GetString( key, defaultString, &s );
	out.Identity();		// sccanf has a bug in it on Mac OS 9.  Sigh.
	sscanf( s, "%f %f %f %f %f %f %f %f %f", &out[0].x, &out[0].y, &out[0].z, &out[1].x, &out[1].y, &out[1].z, &out[2].x, &out[2].y, &out[2].z );
	return found;
}

/*
================
WriteString
================
*/
static void WriteString( const char *s, idFile *f ) {
	int	len = strlen( s );
	if ( len >= MAX_STRING_CHARS-1 ) {
		idLib::common->Error( "idDict::WriteToFileHandle: bad string" );
	}
	f->Write( s, strlen(s) + 1 );
}

/*
================
idDict::FindKey
================
*/
const idKeyValue *idDict::FindKey( const char *key ) const {
	int i, hash;

	if ( key == NULL || key[0] == '\0' ) {
		idLib::common->DWarning( "idDict::FindKey: empty key" );
		return NULL;
	}

	hash = argHash.GenerateKey( key, false );
	for ( i = argHash.First( hash ); i != -1; i = argHash.Next( i ) ) {
		if ( args[i].GetKey().Icmp( key ) == 0 ) {
			return &args[i];
		}
	}

	return NULL;
}

/*
================
idDict::FindKeyIndex
================
*/
int idDict::FindKeyIndex( const char *key ) const {

	if ( key == NULL || key[0] == '\0' ) {
		idLib::common->DWarning( "idDict::FindKeyIndex: empty key" );
		return 0;
	}

	int hash = argHash.GenerateKey( key, false );
	for ( int i = argHash.First( hash ); i != -1; i = argHash.Next( i ) ) {
		if ( args[i].GetKey().Icmp( key ) == 0 ) {
			return i;
		}
	}

	return -1;
}

/*
================
idDict::Delete
================
*/
void idDict::Delete( const char *key ) {
	int hash, i;

	hash = argHash.GenerateKey( key, false );
	for ( i = argHash.First( hash ); i != -1; i = argHash.Next( i ) ) {
		if ( args[i].GetKey().Icmp( key ) == 0 ) {
			globalKeys.FreeString( args[i].key );
			globalValues.FreeString( args[i].value );
			args.RemoveIndex( i );
			argHash.RemoveIndex( hash, i );
			break;
		}
	}

#if 0
	// make sure all keys can still be found in the hash index
	for ( i = 0; i < args.Num(); i++ ) {
		assert( FindKey( args[i].GetKey() ) != NULL );
	}
#endif
}

/*
================
idDict::MatchPrefix
================
*/
const idKeyValue *idDict::MatchPrefix( const char *prefix, const idKeyValue *lastMatch ) const {
	int	i;
	int len;
	int start;

	assert( prefix );
	len = strlen( prefix );

	start = -1;
	if ( lastMatch ) {
		start = args.FindIndex( *lastMatch );
		assert( start >= 0 );
		if ( start < 1 ) {
			start = 0;
		}
	}

	for( i = start + 1; i < args.Num(); i++ ) {
		if ( !args[i].GetKey().Icmpn( prefix, len ) ) {
			return &args[i];
		}
	}
	return NULL;
}

/*
================
idDict::RandomPrefix
================
*/
const char *idDict::RandomPrefix( const char *prefix, idRandom &random ) const {
	int count;
	const int MAX_RANDOM_KEYS = 2048;
	const char *list[MAX_RANDOM_KEYS];
	const idKeyValue *kv;

	list[0] = "";
	for ( count = 0, kv = MatchPrefix( prefix ); kv != NULL && count < MAX_RANDOM_KEYS; kv = MatchPrefix( prefix, kv ) ) {
		list[count++] = kv->GetValue().c_str();
	}
	return list[random.RandomInt( count )];
}

/*
================
idDict::WriteToFileHandle
================
*/
void idDict::WriteToFileHandle( idFile *f ) const {
	int c = LittleLong( args.Num() );
	f->Write( &c, sizeof( c ) );
	for ( int i = 0; i < args.Num(); i++ ) {	// don't loop on the swapped count use the original
		WriteString( args[i].GetKey().c_str(), f );
		WriteString( args[i].GetValue().c_str(), f );
	}
}

/*
================
ReadString
================
*/
static idStr ReadString( idFile *f ) {
	char	str[MAX_STRING_CHARS];
	int		len;

	for ( len = 0; len < MAX_STRING_CHARS; len++ ) {
		f->Read( (void *)&str[len], 1 );
		if ( str[len] == 0 ) {
			break;
		}
	}
	if ( len == MAX_STRING_CHARS ) {
		idLib::common->Error( "idDict::ReadFromFileHandle: bad string" );
	}

	return idStr( str );
}

/*
================
idDict::ReadFromFileHandle
================
*/
void idDict::ReadFromFileHandle( idFile *f ) {
	int c;
	idStr key, val;

	Clear();

	f->Read( &c, sizeof( c ) );
	c = LittleLong( c );
	for ( int i = 0; i < c; i++ ) {
		key = ReadString( f );
		val = ReadString( f );
		Set( key, val );
	}
}

/*
========================
idDict::Serialize
========================
*/
void idDict::Serialize( idSerializer & ser ) {
	if ( ser.IsReading() ) {
		Clear();
	}

	int num = args.Num();
	ser.SerializePacked( num );
	for ( int i = 0; i < num; i++ ) {
		idStr key;
		idStr val; 

		if ( ser.IsWriting() ) {
			key = args[i].GetKey();
			val = args[i].GetValue();
		}

		ser.SerializeString( key );
		ser.SerializeString( val );

		if ( ser.IsReading() ) {
			Set( key.c_str(), val.c_str() );
		}
	}
}

/*
================
idDict::WriteToIniFile
================
*/
void idDict::WriteToIniFile( idFile * f ) const {
	// make a copy so we don't affect the checksum of the original dict
	idList< idKeyValue > sortedArgs( args );
	sortedArgs.SortWithTemplate( idSort_KeyValue() );

	idList< idStr > prefixList;
	idTempArray< int > prefixIndex( sortedArgs.Num() );	// for each keyValue in the args, this is an index into which prefix it uses.
														// 0 means no prefix, otherwise, it's an index + (-1) into prefixList
														// we do this so we can print all the non-prefix based pairs first
	idStr prevPrefix = "";
	idStr skipFirstLine = "";

	// Scan for all the prefixes
	for ( int i = 0; i < sortedArgs.Num(); i++ ) {
		const idKeyValue * kv = &sortedArgs[i];
		int slashPosition = kv->GetKey().Last( '/' );
		if ( slashPosition != idStr::INVALID_POSITION ) {
			idStr prefix = kv->GetKey().Mid( 0, slashPosition );
			if ( prefix != prevPrefix ) {
				prevPrefix = prefix;
				prefixList.Append( prefix );
			}
			prefixIndex[i] = prefixList.Num();
		} else {
			prefixIndex[i] = 0;

			// output all the prefix-less first
			idStr str = va( "%s=%s\n", kv->GetKey().c_str(), idStr::CStyleQuote( kv->GetValue() ) );
			f->Write( (void *)str.c_str(), str.Length() );

			skipFirstLine = "\n";
		}
	}

	int prevPrefixIndex = 0;
	int prefixLength = 0;

	// output all the rest without their prefix
	for ( int i = 0; i < sortedArgs.Num(); i++ ) {
		if ( prefixIndex[i] == 0 ) {
			continue;
		}

		if ( prefixIndex[i] != prevPrefixIndex ) {
			prevPrefixIndex = prefixIndex[i];
			prefixLength = prefixList[prevPrefixIndex - 1].Length() + 1; // to skip past the '/' too

			// output prefix
			idStr str = va( "%s[%s]\n", skipFirstLine.c_str(), prefixList[prevPrefixIndex - 1].c_str() );
			f->Write( (void *)str.c_str(), str.Length() );
		}

		const idKeyValue * kv = &sortedArgs[i];
		idStr str = va( "%s=%s\n", kv->GetKey().c_str() + prefixLength, idStr::CStyleQuote( kv->GetValue() ) );
		f->Write( (void *)str.c_str(), str.Length() );
	}
}

/*
================
idDict::ReadFromIniFile
================
*/
bool idDict::ReadFromIniFile( idFile * f ) {
	int length = f->Length();
	idTempArray< char > buffer( length );
	if ( (int)f->Read( buffer.Ptr(), length ) != length ) {
		return false;
	}
	buffer[length-1] = NULL;	// Since the .ini files are not null terminated, make sure we mark where the end of the .ini file is in our read buffer

	idLexer parser( LEXFL_NOFATALERRORS | LEXFL_ALLOWPATHNAMES /*| LEXFL_ONLYSTRINGS */);
	idStr name = f->GetName();
	name.Append( " dictionary INI reader" );
	if ( !parser.LoadMemory( ( const char* )buffer.Ptr(), length, name.c_str() ) ) {
		return false;
	}

	idToken	token;
	idToken	token2;
	idStr prefix = "";
	idStr valueStr;
	bool success = true;

	Clear();

	const punctuation_t ini_punctuations[] = {
		{ "[", P_SQBRACKETOPEN },
		{ "]", P_SQBRACKETCLOSE },
		{ "=", P_ASSIGN },
		{ NULL, 0 }
	};
	parser.SetPunctuations( ini_punctuations );

	while ( success && !parser.EndOfFile() ) {
		if ( parser.PeekTokenType( TT_PUNCTUATION, P_SQBRACKETOPEN, &token ) ) {
			success = success && parser.ExpectTokenType( TT_PUNCTUATION, P_SQBRACKETOPEN, &token );
			success = success && parser.ReadToken( &token );
			prefix = token.c_str();
			prefix.Append( '/' );
			success = success && parser.ExpectTokenType( TT_PUNCTUATION, P_SQBRACKETCLOSE, &token );
		}
		
		if ( !parser.PeekTokenType( TT_NAME, 0, &token ) ) {
			// end of file most likely
			break;
		}

		success = success && parser.ExpectTokenType( TT_NAME, 0, &token );
		success = success && parser.ExpectTokenType( TT_PUNCTUATION, P_ASSIGN, &token2 );
		success = success && ( parser.ParseRestOfLine( valueStr ) != NULL );

		valueStr = idStr::CStyleUnQuote( valueStr );

		idStr key = va( "%s%s", prefix.c_str(), token.c_str() );
		if ( FindKey( key.c_str() ) ) {
			parser.Warning( "'%s' already defined", key.c_str() );
		}

		Set( key.c_str(), valueStr.c_str() );
	}

	return success;
}

CONSOLE_COMMAND( TestDictIniFile, "Tests the writing/reading of various items in a dict to/from an ini file", 0 ) {
	// Write to the file
	idFile * file = fileSystem->OpenFileWrite( "idDict_ini_test.ini" );
	if ( file == NULL ) {
		idLib::Printf( "[^1FAILED^0] Couldn't open file for writing.\n" );
		return;
	}

	idDict vars;
	vars.SetInt( "section1/section3/a", -1 );
	vars.SetInt( "section1/section3/b", 0 );
	vars.SetInt( "section1/section3/c", 3 );
	vars.SetFloat( "section2/d", 4.0f );
	vars.SetFloat( "section2/e", -5.0f );
	vars.SetBool( "section2/f", true );
	vars.SetBool( "section1/g", false );
	vars.Set( "section1/h", "test1" );
	vars.Set( "i", "1234" );
	vars.SetInt( "j", 9 );
	vars.WriteToIniFile( file );
	delete file;

	// Read from the file
	file = fileSystem->OpenFileRead( "idDict_ini_test.ini" );
	if ( file == NULL ) {
		idLib::Printf( "[^1FAILED^0] Couldn't open file for reading.\n" );
	}

	idDict readVars;
	readVars.ReadFromIniFile( file );
	delete file;

	if ( vars.Checksum() != readVars.Checksum() ) {
		idLib::Printf( "[^1FAILED^0] Dictionaries do not match.\n" );
	} else {
		idLib::Printf( "[^2PASSED^0] Dictionaries match.\n" );
	}

	// Output results
	for ( int i = 0; i < readVars.GetNumKeyVals(); i++ ) {
		const idKeyValue * kv = readVars.GetKeyVal( i );
		idLib::Printf( "%s=%s\n", kv->GetKey().c_str(), kv->GetValue().c_str() );
	}
}

/*
================
idDict::Init
================
*/
void idDict::Init() {
	globalKeys.SetCaseSensitive( false );
	globalValues.SetCaseSensitive( true );
}

/*
================
idDict::Shutdown
================
*/
void idDict::Shutdown() {
	globalKeys.Clear();
	globalValues.Clear();
}

/*
================
idDict::ShowMemoryUsage_f
================
*/
void idDict::ShowMemoryUsage_f( const idCmdArgs &args ) {
	idLib::common->Printf( "%5d KB in %d keys\n", globalKeys.Size() >> 10, globalKeys.Num() );
	idLib::common->Printf( "%5d KB in %d values\n", globalValues.Size() >> 10, globalValues.Num() );
}

/*
================
idDict::ListKeys_f
================
*/
void idDict::ListKeys_f( const idCmdArgs &args ) {
	idLib::Printf( "Not implemented due to sort impl issues.\n" );
	//int i;
	//idList<const idPoolStr *> keyStrings;

	//for ( i = 0; i < globalKeys.Num(); i++ ) {
	//	keyStrings.Append( globalKeys[i] );
	//}
	//keyStrings.SortWithTemplate( idSort_PoolStrPtr() );
	//for ( i = 0; i < keyStrings.Num(); i++ ) {
	//	idLib::common->Printf( "%s\n", keyStrings[i]->c_str() );
	//}
	//idLib::common->Printf( "%5d keys\n", keyStrings.Num() );
}

/*
================
idDict::ListValues_f
================
*/
void idDict::ListValues_f( const idCmdArgs &args ) {
	idLib::Printf( "Not implemented due to sort impl issues.\n" );
	//int i;
	//idList<const idPoolStr *> valueStrings;

	//for ( i = 0; i < globalValues.Num(); i++ ) {
	//	valueStrings.Append( globalValues[i] );
	//}
	//valueStrings.SortWithTemplate( idSort_PoolStrPtr() );
	//for ( i = 0; i < valueStrings.Num(); i++ ) {
	//	idLib::common->Printf( "%s\n", valueStrings[i]->c_str() );
	//}
	//idLib::common->Printf( "%5d values\n", valueStrings.Num() );
}