diff options
Diffstat (limited to 'utils/unusedcontent/unusedcontent.cpp')
| -rw-r--r-- | utils/unusedcontent/unusedcontent.cpp | 1767 |
1 files changed, 1767 insertions, 0 deletions
diff --git a/utils/unusedcontent/unusedcontent.cpp b/utils/unusedcontent/unusedcontent.cpp new file mode 100644 index 0000000..98725b4 --- /dev/null +++ b/utils/unusedcontent/unusedcontent.cpp @@ -0,0 +1,1767 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: unusedcontent.cpp : Defines the entry point for the console application. +// +//=============================================================================// +#include "cbase.h" +#include <stdio.h> +#include <windows.h> +#include <io.h> +#include <sys/stat.h> +#include "tier0/dbg.h" +#pragma warning( disable : 4018 ) + +#include "utlrbtree.h" +#include "utlvector.h" +#include "utldict.h" +#include "filesystem.h" +#include "FileSystem_Tools.h" +#include "FileSystem_Helpers.h" +#include "KeyValues.h" +#include "cmdlib.h" +#include "scriplib.h" +#include "tier0/icommandline.h" +#include "tier1/fmtstr.h" + +bool uselogfile = false; +bool spewdeletions = false; +bool showreferencedfiles = false; +bool immediatedelete = false; +bool printwhitelist = false; +bool showmapfileusage = false; + +static char modname[MAX_PATH]; +static char g_szReslistDir[ MAX_PATH ] = "reslists/"; + +namespace UnusedContent +{ + +class CCleanupUtlSymbolTable; + +//----------------------------------------------------------------------------- +// forward declarations +//----------------------------------------------------------------------------- + +class CUtlSymbolTable; + + +//----------------------------------------------------------------------------- +// This is a symbol, which is a easier way of dealing with strings. +//----------------------------------------------------------------------------- + +typedef unsigned int UtlSymId_t; + +#define UC_UTL_INVAL_SYMBOL ((UnusedContent::UtlSymId_t)~0) + +class CUtlSymbol +{ +public: + // constructor, destructor + CUtlSymbol() : m_Id(UTL_INVAL_SYMBOL) {} + CUtlSymbol( UtlSymId_t id ) : m_Id(id) {} + CUtlSymbol( char const* pStr ); + CUtlSymbol( CUtlSymbol const& sym ) : m_Id(sym.m_Id) {} + + // operator= + CUtlSymbol& operator=( CUtlSymbol const& src ) { m_Id = src.m_Id; return *this; } + + // operator== + bool operator==( CUtlSymbol const& src ) const { return m_Id == src.m_Id; } + bool operator==( char const* pStr ) const; + + // Is valid? + bool IsValid() const { return m_Id != UTL_INVAL_SYMBOL; } + + // Gets at the symbol + operator UtlSymId_t const() const { return m_Id; } + + // Gets the string associated with the symbol + char const* String( ) const; + + // Modules can choose to disable the static symbol table so to prevent accidental use of them. + static void DisableStaticSymbolTable(); + +protected: + UtlSymId_t m_Id; + + // Initializes the symbol table + static void Initialize(); + + // returns the current symbol table + static CUtlSymbolTable* CurrTable(); + + // The standard global symbol table + static CUtlSymbolTable* s_pSymbolTable; + + static bool s_bAllowStaticSymbolTable; + + friend class UnusedContent::CCleanupUtlSymbolTable; +}; + + +//----------------------------------------------------------------------------- +// CUtlSymbolTable: +// description: +// This class defines a symbol table, which allows us to perform mappings +// of strings to symbols and back. The symbol class itself contains +// a static version of this class for creating global strings, but this +// class can also be instanced to create local symbol tables. +//----------------------------------------------------------------------------- + +class CUtlSymbolTable +{ +public: + // constructor, destructor + CUtlSymbolTable( int growSize = 0, int initSize = 32, bool caseInsensitive = false ); + ~CUtlSymbolTable(); + + // Finds and/or creates a symbol based on the string + CUtlSymbol AddString( char const* pString ); + + // Finds the symbol for pString + CUtlSymbol Find( char const* pString ); + + // Look up the string associated with a particular symbol + char const* String( CUtlSymbol id ) const; + + // Remove all symbols in the table. + void RemoveAll(); + + int GetNumStrings( void ) const + { + return m_Lookup.Count(); + } + +protected: + class CStringPoolIndex + { + public: + inline CStringPoolIndex() + { + } + + inline CStringPoolIndex( unsigned int iPool, unsigned int iOffset ) + { + m_iPool = iPool; + m_iOffset = iOffset; + } + + inline bool operator==( const CStringPoolIndex &other ) const + { + return m_iPool == other.m_iPool && m_iOffset == other.m_iOffset; + } + + unsigned int m_iPool; // Index into m_StringPools. + unsigned int m_iOffset; // Index into the string pool. + }; + + // Stores the symbol lookup + CUtlRBTree<CStringPoolIndex, unsigned int> m_Lookup; + + typedef struct + { + int m_TotalLen; // How large is + int m_SpaceUsed; + char m_Data[1]; + } StringPool_t; + + // stores the string data + CUtlVector<StringPool_t*> m_StringPools; + + + +private: + + int FindPoolWithSpace( int len ) const; + + const char* StringFromIndex( const CStringPoolIndex &index ) const; + + // Less function, for sorting strings + static bool SymLess( CStringPoolIndex const& i1, CStringPoolIndex const& i2 ); + // case insensitive less function + static bool SymLessi( CStringPoolIndex const& i1, CStringPoolIndex const& i2 ); +}; + +//=========== (C) Copyright 1999 Valve, L.L.C. All rights reserved. =========== +// +// The copyright to the contents herein is the property of Valve, L.L.C. +// The contents may be used and/or copied only with the written permission of +// Valve, L.L.C., or in accordance with the terms and conditions stipulated in +// the agreement/contract under which the contents have been supplied. +// +// Purpose: Defines a symbol table +// +// $Header: $ +// $NoKeywords: $ +//============================================================================= + +#pragma warning (disable:4514) + +#define INVALID_STRING_INDEX CStringPoolIndex( 0xFFFF, 0xFFFF ) + +#define MIN_STRING_POOL_SIZE 2048 + +//----------------------------------------------------------------------------- +// globals +//----------------------------------------------------------------------------- + +CUtlSymbolTable* 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 CUtlSymbolTable; + 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; + +CUtlSymbolTable* CUtlSymbol::CurrTable() +{ + Initialize(); + return s_pSymbolTable; +} + + +//----------------------------------------------------------------------------- +// string->symbol->string +//----------------------------------------------------------------------------- + +CUtlSymbol::CUtlSymbol( char const* pStr ) +{ + m_Id = CurrTable()->AddString( pStr ); +} + +char const* CUtlSymbol::String( ) const +{ + return CurrTable()->String(m_Id); +} + +void CUtlSymbol::DisableStaticSymbolTable() +{ + s_bAllowStaticSymbolTable = false; +} + +//----------------------------------------------------------------------------- +// checks if the symbol matches a string +//----------------------------------------------------------------------------- + +bool CUtlSymbol::operator==( char const* pStr ) const +{ + if (m_Id == UTL_INVAL_SYMBOL) + return false; + return strcmp( String(), pStr ) == 0; +} + + + +//----------------------------------------------------------------------------- +// symbol table stuff +//----------------------------------------------------------------------------- + +struct LessCtx_t +{ + char const* m_pUserString; + CUtlSymbolTable* m_pTable; + + LessCtx_t( ) : m_pUserString(0), m_pTable(0) {} +}; + +static LessCtx_t g_LessCtx; + + +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::SymLess( CStringPoolIndex const& i1, CStringPoolIndex const& i2 ) +{ + char const* str1 = (i1 == INVALID_STRING_INDEX) ? g_LessCtx.m_pUserString : + g_LessCtx.m_pTable->StringFromIndex( i1 ); + char const* str2 = (i2 == INVALID_STRING_INDEX) ? g_LessCtx.m_pUserString : + g_LessCtx.m_pTable->StringFromIndex( i2 ); + + return strcmp( str1, str2 ) < 0; +} + + +bool CUtlSymbolTable::SymLessi( CStringPoolIndex const& i1, CStringPoolIndex const& i2 ) +{ + char const* str1 = (i1 == INVALID_STRING_INDEX) ? g_LessCtx.m_pUserString : + g_LessCtx.m_pTable->StringFromIndex( i1 ); + char const* str2 = (i2 == INVALID_STRING_INDEX) ? g_LessCtx.m_pUserString : + g_LessCtx.m_pTable->StringFromIndex( i2 ); + + return strcmpi( str1, str2 ) < 0; +} + +//----------------------------------------------------------------------------- +// constructor, destructor +//----------------------------------------------------------------------------- + +CUtlSymbolTable::CUtlSymbolTable( int growSize, int initSize, bool caseInsensitive ) : + m_Lookup( growSize, initSize, caseInsensitive ? SymLessi : SymLess ), m_StringPools( 8 ) +{ +} + +CUtlSymbolTable::~CUtlSymbolTable() +{ +} + + +CUtlSymbol CUtlSymbolTable::Find( char const* pString ) +{ + if (!pString) + return CUtlSymbol(); + + // Store a special context used to help with insertion + g_LessCtx.m_pUserString = pString; + g_LessCtx.m_pTable = this; + + // 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 ); + 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( char const* 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 int 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 +//----------------------------------------------------------------------------- + +char const* 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.RemoveAll(); + + for ( int i=0; i < m_StringPools.Count(); i++ ) + free( m_StringPools[i] ); + + m_StringPools.RemoveAll(); +} + +} // Namespace UnusedContent + +struct AnalysisData +{ + UnusedContent::CUtlSymbolTable symbols; +}; + +char *directories_to_check[] = +{ + "", + "bin", + "maps", + "materials", + "models", + "scenes", + "scripts", + "sound", + "hl2", +}; + +char *directories_to_ignore[] = // don't include these dirs in the others list +{ + "reslists", + "reslists_temp", + "logs", + "media", + "downloads", + "save", + "screenshots", + "testscripts", + "logos" +}; + + +enum +{ + REFERENCED_NO = 0, + REFERENCED_WHITELIST, + REFERENCED_GAME +}; + +struct FileEntry +{ + FileEntry() + { + sym = UC_UTL_INVAL_SYMBOL; + size = 0; + referenced = REFERENCED_NO; + } + + UnusedContent::CUtlSymbol sym; + unsigned int size; + int referenced; +}; + +struct ReferencedFile +{ + ReferencedFile() + { + sym = UC_UTL_INVAL_SYMBOL; + } + + ReferencedFile( const ReferencedFile& src ) + { + sym = src.sym; + maplist.RemoveAll(); + int c = src.maplist.Count(); + for ( int i = 0; i < c; ++i ) + { + maplist.AddToTail( src.maplist[ i ] ); + } + } + + ReferencedFile & operator =( const ReferencedFile& src ) + { + if ( this == &src ) + return *this; + + sym = src.sym; + maplist.RemoveAll(); + int c = src.maplist.Count(); + for ( int i = 0; i < c; ++i ) + { + maplist.AddToTail( src.maplist[ i ] ); + } + return *this; + } + + UnusedContent::CUtlSymbol sym; + CUtlVector< UnusedContent::CUtlSymbol > maplist; +}; + + +static AnalysisData g_Analysis; + +IFileSystem *filesystem = NULL; +static CUniformRandomStream g_Random; +IUniformRandomStream *random = &g_Random; + +static bool spewed = false; + +SpewRetval_t SpewFunc( SpewType_t type, char const *pMsg ) +{ + spewed = true; + + printf( "%s", pMsg ); + OutputDebugString( pMsg ); + + if ( type == SPEW_ERROR ) + { + printf( "\n" ); + OutputDebugString( "\n" ); + exit(-1); + } + + return SPEW_CONTINUE; +} + +char *va( const char *fmt, ... ) +{ + static char string[ 8192 ]; + va_list va; + va_start( va, fmt ); + vsprintf( string, fmt, va ); + va_end( va ); + return string; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : depth - +// *fmt - +// ... - +//----------------------------------------------------------------------------- +void vprint( int depth, const char *fmt, ... ) +{ + char string[ 8192 ]; + va_list va; + va_start( va, fmt ); + vsprintf( string, fmt, va ); + va_end( va ); + + FILE *fp = NULL; + + if ( uselogfile ) + { + fp = fopen( "log.txt", "ab" ); + } + + while ( depth-- > 0 ) + { + printf( " " ); + OutputDebugString( " " ); + if ( fp ) + { + fprintf( fp, " " ); + } + } + + ::printf( "%s", string ); + OutputDebugString( string ); + + if ( fp ) + { + char *p = string; + while ( *p ) + { + if ( *p == '\n' ) + { + fputc( '\r', fp ); + } + fputc( *p, fp ); + p++; + } + fclose( fp ); + } +} + +void logprint( char const *logfile, const char *fmt, ... ) +{ + char string[ 8192 ]; + va_list va; + va_start( va, fmt ); + vsprintf( string, fmt, va ); + va_end( va ); + + FILE *fp = NULL; + + UnusedContent::CUtlSymbol sym = g_Analysis.symbols.Find( logfile ); + static CUtlRBTree< UnusedContent::CUtlSymbol, int > previousfiles( 0, 0, DefLessFunc( UnusedContent::CUtlSymbol ) ); + if ( previousfiles.Find( sym ) == previousfiles.InvalidIndex() ) + { + previousfiles.Insert( sym ); + fp = fopen( logfile, "wb" ); + } + else + { + fp = fopen( logfile, "ab" ); + } + + if ( fp ) + { + char *p = string; + while ( *p ) + { + if ( *p == '\n' ) + { + fputc( '\r', fp ); + } + fputc( *p, fp ); + p++; + } + fclose( fp ); + } +} + +void Con_Printf( const char *fmt, ... ) +{ + va_list args; + static char output[1024]; + + va_start( args, fmt ); + vprintf( fmt, args ); + vsprintf( output, fmt, args ); + + vprint( 0, output ); +} + +bool ShouldCheckDir( char const *dirname ); +bool ShouldIgnoreDir( const char *dirname ); + +void BuildFileList_R( int depth, CUtlVector< FileEntry >& files, CUtlVector< FileEntry > * otherfiles, char const *dir, char const *wild, int skipchars ) +{ + WIN32_FIND_DATA wfd; + + char directory[ 256 ]; + char filename[ 256 ]; + HANDLE ff; + + bool canrecurse = true; + if ( !Q_stricmp( wild, "..." ) ) + { + canrecurse = true; + sprintf( directory, "%s%s%s", dir[0] == '\\' ? dir + 1 : dir, dir[0] != 0 ? "\\" : "", "*.*" ); + } + else + { + sprintf( directory, "%s%s%s", dir, dir[0] != 0 ? "\\" : "", wild ); + } + int dirlen = Q_strlen( dir ); + + if ( ( ff = FindFirstFile( directory, &wfd ) ) == INVALID_HANDLE_VALUE ) + return; + + do + { + if ( wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) + { + bool useOtherFiles = false; + + if ( wfd.cFileName[ 0 ] == '.' ) + continue; + + if ( depth == 0 && !ShouldCheckDir( wfd.cFileName ) && otherfiles ) + { + if ( !ShouldIgnoreDir( wfd.cFileName ) ) + { + useOtherFiles = true; + } + } + + if ( !canrecurse ) + continue; + + // Recurse down directory + if ( dir[0] ) + { + sprintf( filename, "%s\\%s", dir, wfd.cFileName ); + } + else + { + sprintf( filename, "%s", wfd.cFileName ); + } + BuildFileList_R( depth + 1, useOtherFiles ? *otherfiles: files, NULL, filename, wild, skipchars ); + } + else + { + if (!stricmp(wfd.cFileName, "vssver.scc")) + continue; + + char filename[ MAX_PATH ]; + if ( dirlen <= skipchars ) + { + Q_snprintf( filename, sizeof( filename ), "%s", wfd.cFileName ); + } + else + { + Q_snprintf( filename, sizeof( filename ), "%s\\%s", &dir[ skipchars ], wfd.cFileName ); + } + _strlwr( filename ); + + Q_FixSlashes( filename ); + + UnusedContent::CUtlSymbol sym = g_Analysis.symbols.AddString( filename ); + + FileEntry entry; + entry.sym = sym; + int size = g_pFileSystem->Size( filename ); + entry.size = size >= 0 ? (unsigned int)size : 0; + + files.AddToTail( entry ); + + if ( !( files.Count() % 3000 ) ) + { + vprint( 0, "...found %i files\n", files.Count() ); + } + } + } while ( FindNextFile( ff, &wfd ) ); +} + +void BuildFileList( int depth, CUtlVector< FileEntry >& files, CUtlVector< FileEntry > * otherfiles, char const *rootdir, int skipchars ) +{ + files.RemoveAll(); + Assert( otherfiles ); + otherfiles->RemoveAll(); + BuildFileList_R( depth, files, otherfiles, rootdir, "...", skipchars ); +} + +void BuildFileListWildcard( int depth, CUtlVector< FileEntry >& files, char const *rootdir, char const *wildcard, int skipchars ) +{ + files.RemoveAll(); + BuildFileList_R( depth, files, NULL, rootdir, wildcard, skipchars ); +} + + +static CUtlVector< UnusedContent::CUtlSymbol > g_DirList; +static CUtlVector< UnusedContent::CUtlSymbol > g_IgnoreDir; + +bool ShouldCheckDir( char const *dirname ) +{ + int c = g_DirList.Count(); + for ( int i = 0; i < c; ++i ) + { + char const *check = g_Analysis.symbols.String( g_DirList[ i ] ); + + if ( !Q_stricmp( dirname, check ) ) + return true; + } + + vprint( 1, "Skipping dir %s\n", dirname ); + return false; +} + +bool ShouldIgnoreDir( const char *dirname ) +{ + int c = g_IgnoreDir.Count(); + for ( int i = 0; i < c; ++i ) + { + char const *check = g_Analysis.symbols.String( g_IgnoreDir[ i ] ); + + if ( Q_stristr( dirname, "reslists" ) ) + { + vprint( 1, "Ignoring dir %s\n", dirname ); + return true; + } + + if ( !Q_stricmp( dirname, check ) ) + { + vprint( 1, "Ignoring dir %s\n", dirname ); + return true; + } + } + + return false; +} + +void AddCheckdir( char const *dirname ) +{ + UnusedContent::CUtlSymbol sym = g_Analysis.symbols.AddString( dirname ); + g_DirList.AddToTail( sym ); + + vprint( 1, "AddCheckdir[ \"%s\" ]\n", dirname ); +} + +void AddIgnoredir( const char *dirname ) +{ + UnusedContent::CUtlSymbol sym = g_Analysis.symbols.AddString( dirname ); + g_IgnoreDir.AddToTail( sym ); + + vprint( 1, "AddIgnoredir[ \"%s\" ]\n", dirname ); +} + + +#define UNUSEDCONTENT_CFG "unusedcontent.cfg" + +void BuildCheckdirList() +{ + vprint( 0, "Checking for dirlist\n" ); + // Search for unusedcontent.cfg file + if ( g_pFileSystem->FileExists( UNUSEDCONTENT_CFG, "GAME") ) + { + KeyValues *kv = new KeyValues( UNUSEDCONTENT_CFG ); + if ( kv ) + { + if ( kv->LoadFromFile( g_pFileSystem, UNUSEDCONTENT_CFG, "GAME" ) ) + { + for ( KeyValues *sub = kv->GetFirstSubKey(); sub; sub = sub->GetNextKey() ) + { + if ( !Q_stricmp( sub->GetName(), "dir" ) ) + { + AddCheckdir( sub->GetString() ); + } + else if ( !Q_stricmp( sub->GetName(), "ignore" ) ) + { + AddIgnoredir( sub->GetString() ); + } + else + { + vprint( 1, "Unknown subkey '%s' in %s\n", sub->GetName(), UNUSEDCONTENT_CFG ); + } + } + } + + kv->deleteThis(); + } + } + else + { + int c = ARRAYSIZE( directories_to_check ); + int i; + for ( i = 0; i < c; ++i ) + { + AddCheckdir( directories_to_check[ i ] ); + } + + // add the list of dirs to ignore from the others lists + c = ARRAYSIZE( directories_to_ignore ); + for ( i = 0; i < c; ++i ) + { + AddIgnoredir( directories_to_ignore[ i ] ); + } + } +} + +static CUtlRBTree< UnusedContent::CUtlSymbol, int > g_WhiteList( 0, 0, DefLessFunc( UnusedContent::CUtlSymbol ) ); + +#define WHITELIST_FILE "whitelist.cfg" + +static int wl_added = 0; +static int wl_removed = 0; + +void AddToWhiteList( char const *path ) +{ + vprint( 2, "+\t'%s'\n", path ); + + char dir[ 512 ]; + Q_strncpy( dir, path, sizeof( dir ) ); + + // Get the base filename from the path + _strlwr( dir ); + Q_FixSlashes( dir ); + + CUtlVector< FileEntry > files; + + char *lastslash = strrchr( dir, '\\' ); + if ( lastslash == 0 ) + { + BuildFileListWildcard( 1, files, "", dir, 0 ); + } + else + { + char *wild = lastslash + 1; + *lastslash = 0; + + BuildFileListWildcard( 1, files, dir, wild, 0 ); + } + + int c = files.Count(); + for ( int i = 0; i < c; ++i ) + { + UnusedContent::CUtlSymbol sym = files[ i ].sym; + if ( g_WhiteList.Find( sym ) == g_WhiteList.InvalidIndex() ) + { + g_WhiteList.Insert( sym ); + ++wl_added; + } + } +} + +void RemoveFromWhiteList( char const *path ) +{ + vprint( 2, "-\t'%s'\n", path ); + + char dir[ 512 ]; + Q_strncpy( dir, path, sizeof( dir ) ); + + // Get the base filename from the path + _strlwr( dir ); + Q_FixSlashes( dir ); + + CUtlVector< FileEntry > files; + + char *lastslash = strrchr( dir, '\\' ); + if ( lastslash == 0 ) + { + BuildFileListWildcard( 1, files, "", dir, 0 ); + } + else + { + char *wild = lastslash + 1; + *lastslash = 0; + + BuildFileListWildcard( 1, files, dir, wild, 0 ); + } + + int c = files.Count(); + for ( int i = 0; i < c; ++i ) + { + UnusedContent::CUtlSymbol sym = files[ i ].sym; + int idx = g_WhiteList.Find( sym ); + if ( idx != g_WhiteList.InvalidIndex() ) + { + g_WhiteList.RemoveAt( idx ); + ++wl_removed; + } + } +} + +void BuildWhiteList() +{ + // Search for unusedcontent.cfg file + if ( !g_pFileSystem->FileExists( WHITELIST_FILE ) ) + { + vprint( 1, "Running with no whitelist.cfg file!!!\n" ); + return; + } + + vprint( 1, "\nBuilding whitelist\n" ); + + KeyValues *kv = new KeyValues( WHITELIST_FILE ); + if ( kv ) + { + if ( kv->LoadFromFile( g_pFileSystem, WHITELIST_FILE, NULL ) ) + { + for ( KeyValues *sub = kv->GetFirstSubKey(); sub; sub = sub->GetNextKey() ) + { + if ( !Q_stricmp( sub->GetName(), "add" ) ) + { + AddToWhiteList( sub->GetString() ); + } + else if ( !Q_stricmp( sub->GetName(), "remove" ) ) + { + RemoveFromWhiteList( sub->GetString() ); + } + else + { + vprint( 1, "Unknown subkey '%s' in %s\n", sub->GetName(), WHITELIST_FILE ); + } + } + } + + kv->deleteThis(); + } + + if ( verbose || printwhitelist ) + { + vprint( 1, "Whitelist:\n\n" ); + + + for ( int i = g_WhiteList.FirstInorder(); + i != g_WhiteList.InvalidIndex(); + i = g_WhiteList.NextInorder( i ) ) + { + UnusedContent::CUtlSymbol& sym = g_WhiteList[ i ]; + + char const *resolved = g_Analysis.symbols.String( sym ); + vprint( 2, " %s\n", resolved ); + } + } + + // dump the whitelist file list anyway + { + filesystem->RemoveFile( "whitelist_files.txt", "GAME" ); + for ( int i = g_WhiteList.FirstInorder(); + i != g_WhiteList.InvalidIndex(); + i = g_WhiteList.NextInorder( i ) ) + { + UnusedContent::CUtlSymbol& sym = g_WhiteList[ i ]; + char const *resolved = g_Analysis.symbols.String( sym ); + logprint( "whitelist_files.txt", "\"%s\"\n", resolved ); + } + } + + + vprint( 1, "Whitelist resolves to %d files (added %i/removed %i)\n\n", g_WhiteList.Count(), wl_added, wl_removed ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void printusage( void ) +{ + vprint( 0, "usage: unusedcontent maplistfile\n\ + \t Note that you must have generated the reslistsfile output via the engine first!!!\n\ + \t-d = spew command prompt deletion instructions to deletions.bat\n\ + \t-v = verbose output\n\ + \t-l = log to file log.txt\n\ + \t-r = print out all referenced files\n\ + \t-m = generate referenced.csv with map counts\n\ + \t-w = print out whitelist\n\ + \t-i = delete unused files immediately\n\ + \t-f <reslistdir> : specify reslists folder, 'reslists' assumed by default\n\ + \t\tmaps/\n\ + \t\tmaterials/\n\ + \t\tmodels/\n\ + \t\tsounds/\n\ + \ne.g.: unusedcontent -r maplist.txt\n" ); + + // Exit app + exit( 1 ); +} + +void ParseFilesFromResList( UnusedContent::CUtlSymbol & resfilesymbol, CUtlRBTree< ReferencedFile, int >& files, char const *resfile ) +{ + int addedStrings = 0; + int resourcesConsidered = 0; + + int offset = Q_strlen( gamedir ); + + char basedir[MAX_PATH]; + Q_strncpy( basedir, gamedir, sizeof( basedir ) ); + if ( !Q_StripLastDir( basedir, sizeof( basedir ) ) ) + Error( "Can't get basedir from %s.", gamedir ); + + FileHandle_t resfilehandle; + resfilehandle = g_pFileSystem->Open( resfile, "rb" ); + if ( FILESYSTEM_INVALID_HANDLE != resfilehandle ) + { + // Read in the entire file + int length = g_pFileSystem->Size(resfilehandle); + if ( length > 0 ) + { + char *pStart = (char *)new char[ length + 1 ]; + if ( pStart && ( length == g_pFileSystem->Read(pStart, length, resfilehandle) ) ) + { + pStart[ length ] = 0; + + char *pFileList = pStart; + + char token[512]; + + while ( 1 ) + { + pFileList = ParseFile( pFileList, token, NULL ); + if ( !pFileList ) + break; + + if ( strlen( token ) > 0 ) + { + char szFileName[ 256 ]; + Q_snprintf( szFileName, sizeof( szFileName ), "%s%s", basedir, token ); + _strlwr( szFileName ); + Q_FixSlashes( szFileName ); + while ( szFileName[ strlen( szFileName ) - 1 ] == '\n' || + szFileName[ strlen( szFileName ) - 1 ] == '\r' ) + { + szFileName[ strlen( szFileName ) - 1 ] = 0; + } + + if ( Q_strnicmp( szFileName, gamedir, offset ) ) + continue; + + char *pFile = szFileName + offset; + ++resourcesConsidered; + + ReferencedFile rf; + rf.sym = g_Analysis.symbols.AddString( pFile ); + + int idx = files.Find( rf ); + if ( idx == files.InvalidIndex() ) + { + ++addedStrings; + rf.maplist.AddToTail( resfilesymbol ); + files.Insert( rf ); + } + else + { + // + ReferencedFile & slot = files[ idx ]; + if ( slot.maplist.Find( resfilesymbol ) == slot.maplist.InvalidIndex() ) + { + slot.maplist.AddToTail( resfilesymbol ); + } + + } + } + } + + } + delete[] pStart; + } + + g_pFileSystem->Close(resfilehandle); + } + + int filesFound = addedStrings; + + vprint( 1, "Found %i new resources (%i total) in %s\n", filesFound, resourcesConsidered, resfile ); +} + +bool BuildReferencedFileList( CUtlVector< UnusedContent::CUtlSymbol >& resfiles, CUtlRBTree< ReferencedFile, int >& files, const char *resfile ) +{ + + // Load the reslist file + FileHandle_t resfilehandle; + resfilehandle = g_pFileSystem->Open( resfile, "rb" ); + if ( FILESYSTEM_INVALID_HANDLE != resfilehandle ) + { + // Read in and parse mapcycle.txt + int length = g_pFileSystem->Size(resfilehandle); + if ( length > 0 ) + { + char *pStart = (char *)new char[ length + 1 ]; + if ( pStart && ( length == g_pFileSystem->Read(pStart, length, resfilehandle) ) + ) + { + pStart[ length ] = 0; + + char *pFileList = pStart; + + while ( 1 ) + { + char szResList[ 256 ]; + + pFileList = COM_Parse( pFileList ); + if ( strlen( com_token ) <= 0 ) + break; + + Q_snprintf(szResList, sizeof( szResList ), "%s%s.lst", g_szReslistDir, com_token ); + _strlwr( szResList ); + Q_FixSlashes( szResList ); + + if ( !g_pFileSystem->FileExists( szResList ) ) + { + vprint( 0, "Couldn't find %s\n", szResList ); + continue; + } + + UnusedContent::CUtlSymbol sym = g_Analysis.symbols.AddString( szResList ); + resfiles.AddToTail( sym ); + + } + } + delete[] pStart; + } + + g_pFileSystem->Close(resfilehandle); + } + else + { + Error( "Unable to open reslist file %s\n", resfile ); + exit( -1 ); + } + + if ( g_pFileSystem->FileExists( CFmtStr( "%sall.lst", g_szReslistDir ) ) ) + { + UnusedContent::CUtlSymbol sym = g_Analysis.symbols.AddString( CFmtStr( "%sall.lst", g_szReslistDir ) ); + resfiles.AddToTail( sym ); + } + + if ( g_pFileSystem->FileExists( CFmtStr( "%sengine.lst", g_szReslistDir ) ) ) + { + UnusedContent::CUtlSymbol sym = g_Analysis.symbols.AddString( CFmtStr( "%sengine.lst", g_szReslistDir ) ); + resfiles.AddToTail( sym ); + } + + // Do we have any resfiles? + if ( resfiles.Count() <= 0 ) + { + vprint( 0, "%s didn't have any actual .lst files in the reslists folder, have you run the engine with %s\n", resfile, + "-makereslists -usereslistfile maplist.txt" ); + return false; + } + + vprint( 0, "Parsed %i reslist files\n", resfiles.Count() ); + + // Now load in each res file + int c = resfiles.Count(); + for ( int i = 0; i < c; ++i ) + { + UnusedContent::CUtlSymbol& filename = resfiles[ i ]; + char fn[ 256 ]; + Q_strncpy( fn, g_Analysis.symbols.String( filename ), sizeof( fn ) ); + + ParseFilesFromResList( filename, files, fn ); + } + + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CheckLogFile( void ) +{ + if ( uselogfile ) + { + _unlink( "log.txt" ); + vprint( 0, " Outputting to log.txt\n" ); + } +} + +void PrintHeader() +{ + vprint( 0, "Valve Software - unusedcontent.exe (%s)\n", __DATE__ ); + vprint( 0, "--- Compares reslists with actual game content tree to show unreferenced content and stats ---\n" ); +} + +static bool ReferencedFileLessFunc( const ReferencedFile &lhs, const ReferencedFile &rhs ) +{ + char const *s1 = g_Analysis.symbols.String( lhs.sym ); + char const *s2 = g_Analysis.symbols.String( rhs.sym ); + + return Q_stricmp( s1, s2 ) < 0; +} + +static bool FileEntryLessFunc( const FileEntry &lhs, const FileEntry &rhs ) +{ + char const *s1 = g_Analysis.symbols.String( lhs.sym ); + char const *s2 = g_Analysis.symbols.String( rhs.sym ); + + return Q_stricmp( s1, s2 ) < 0; +} + +static bool RefFileLessFunc( const ReferencedFile &lhs, const ReferencedFile &rhs ) +{ + char const *s1 = g_Analysis.symbols.String( lhs.sym ); + char const *s2 = g_Analysis.symbols.String( rhs.sym ); + + return Q_stricmp( s1, s2 ) < 0; +} + +struct DirEntry +{ + DirEntry() + { + total = 0; + unreferenced = 0; + whitelist = 0; + } + + double total; + double unreferenced; + double whitelist; +}; + +void Correlate( CUtlRBTree< ReferencedFile, int >& referencedfiles, CUtlVector< FileEntry >& contentfiles, const char *modname ) +{ + int i; + int c = contentfiles.Count(); + + double totalDiskSize = 0; + double totalReferencedDiskSize = 0; + double totalWhiteListDiskSize = 0; + + for ( i = 0; i < c; ++i ) + { + totalDiskSize += contentfiles [ i ].size; + } + + vprint( 0, "Content tree size on disk %s\n", Q_pretifymem( totalDiskSize, 3 ) ); + + // Analysis is to walk tree and see which files on disk are referenced in the .lst files + // Need a fast lookup from file symbol to referenced list + CUtlRBTree< ReferencedFile, int > tree( 0, 0, ReferencedFileLessFunc ); + c = referencedfiles.Count(); + for ( i = 0 ; i < c; ++i ) + { + tree.Insert( referencedfiles[ i ] ); + } + + // Now walk the on disk file and see check off resources which are in referenced + c = contentfiles.Count(); + int invalidindex = tree.InvalidIndex(); + unsigned int refcounted = 0; + unsigned int whitelisted = 0; + + filesystem->RemoveFile( CFmtStr( "%swhitelist.lst", g_szReslistDir ), "GAME" ); + + for ( i = 0; i < c; ++i ) + { + FileEntry & entry = contentfiles[ i ]; + + ReferencedFile foo; + foo.sym = entry.sym; + + bool gameref = tree.Find( foo ) != invalidindex; + char const *fn = g_Analysis.symbols.String( entry.sym ); + + bool whitelist = g_WhiteList.Find( entry.sym ) != g_WhiteList.InvalidIndex(); + + if ( gameref || whitelist ) + { + entry.referenced = gameref ? REFERENCED_GAME : REFERENCED_WHITELIST; + totalReferencedDiskSize += entry.size; + if ( entry.referenced == REFERENCED_WHITELIST ) + { + logprint( CFmtStr( "%swhitelist.lst", g_szReslistDir ), "\"%s\\%s\"\n", modname, fn ); + + totalWhiteListDiskSize += entry.size; + ++whitelisted; + } + ++refcounted; + } + } + + vprint( 0, "Found %i referenced (%i whitelist) files in tree, %s\n", refcounted, whitelisted, Q_pretifymem( totalReferencedDiskSize, 2 ) ); + vprint( 0, "%s appear unused\n", Q_pretifymem( totalDiskSize - totalReferencedDiskSize, 2 ) ); + + // Now sort and dump the unreferenced ones.. + vprint( 0, "Sorting unreferenced files list...\n" ); + + CUtlRBTree< FileEntry, int > unreftree( 0, 0, FileEntryLessFunc ); + for ( i = 0; i < c; ++i ) + { + FileEntry & entry = contentfiles[ i ]; + if ( entry.referenced != REFERENCED_NO ) + continue; + + unreftree.Insert( entry ); + } + + // Now walk the unref tree in order + i = unreftree.FirstInorder(); + invalidindex = unreftree.InvalidIndex(); + int index = 0; + while ( i != invalidindex ) + { + FileEntry & entry = unreftree[ i ]; + + if ( showreferencedfiles ) + { + vprint( 1, "%6i %12s: %s\n", ++index, Q_pretifymem( entry.size, 2 ), g_Analysis.symbols.String( entry.sym ) ); + } + + i = unreftree.NextInorder( i ); + } + + if ( showmapfileusage ) + { + vprint( 0, "Writing referenced.csv...\n" ); + + // Now walk the list of referenced files and print out how many and which maps reference them + i = tree.FirstInorder(); + invalidindex = tree.InvalidIndex(); + index = 0; + while ( i != invalidindex ) + { + ReferencedFile & entry = tree[ i ]; + + char ext[ 32 ]; + Q_ExtractFileExtension( g_Analysis.symbols.String( entry.sym ), ext, sizeof( ext ) ); + + logprint( "referenced.csv", "\"%s\",\"%s\",%d", g_Analysis.symbols.String( entry.sym ), ext, entry.maplist.Count() ); + + int mapcount = entry.maplist.Count(); + for ( int j = 0 ; j < mapcount; ++j ) + { + char basemap[ 128 ]; + Q_FileBase( g_Analysis.symbols.String( entry.maplist[ j ] ), basemap, sizeof( basemap ) ); + logprint( "referenced.csv", ",\"%s\"", basemap ); + } + + logprint( "referenced.csv", "\n" ); + + i = tree.NextInorder( i ); + } + } + + + vprint( 0, "\nBuilding directory summary list...\n" ); + + // Now build summaries by root branch off of gamedir (e.g., for sound, materials, models, etc.) + CUtlDict< DirEntry, int > directories; + invalidindex = directories.InvalidIndex(); + for ( i = 0; i < c; ++i ) + { + FileEntry & entry = contentfiles[ i ]; + + // Get the dir name + char const *dirname = g_Analysis.symbols.String( entry.sym ); + + const char *backslash = strstr( dirname, "\\" ); + + char dir[ 256 ]; + if ( !backslash ) + { + dir[0] = 0; + } + else + { + Q_strncpy( dir, dirname, backslash - dirname + 1); + } + + + int idx = directories.Find( dir ); + if ( idx == invalidindex ) + { + DirEntry foo; + idx = directories.Insert( dir, foo ); + } + + DirEntry & de = directories[ idx ]; + de.total += entry.size; + if ( entry.referenced == REFERENCED_NO ) + { + de.unreferenced += entry.size; + } + if ( entry.referenced == REFERENCED_WHITELIST ) + { + de.whitelist += entry.size; + } + } + + if ( spewdeletions ) + { + // Spew deletion commands to console + if ( immediatedelete ) + { + vprint( 0, "\n\nDeleting files...\n" ); + } + else + { + vprint( 0, "\n\nGenerating deletions.bat\n" ); + } + + i = unreftree.FirstInorder(); + invalidindex = unreftree.InvalidIndex(); + float deletionSize = 0.0f; + int deletionCount = 0; + + while ( i != invalidindex ) + { + FileEntry & entry = unreftree[ i ]; + i = unreftree.NextInorder( i ); + + // Don't delete stuff that's in the white list + if ( g_WhiteList.Find( entry.sym ) != g_WhiteList.InvalidIndex() ) + { + if ( verbose ) + { + vprint( 0, "whitelist blocked deletion of %s\n", g_Analysis.symbols.String( entry.sym ) ); + } + continue; + } + + ++deletionCount; + deletionSize += entry.size; + + if ( immediatedelete ) + { + if ( _chmod( g_Analysis.symbols.String( entry.sym ), _S_IWRITE ) == -1 ) + { + vprint( 0, "Could not find file %s\n", g_Analysis.symbols.String( entry.sym ) ); + } + if ( _unlink( g_Analysis.symbols.String( entry.sym ) ) == -1 ) + { + vprint( 0, "Could not delete file %s\n", g_Analysis.symbols.String( entry.sym ) ); + } + + if ( deletionCount % 1000 == 0 ) + { + vprint( 0, "...deleted %i files\n", deletionCount ); + } + } + else + { + logprint( "deletions.bat", "del \"%s\" /f\n", g_Analysis.symbols.String( entry.sym ) ); + } + } + + vprint( 0, "\nFile deletion (%d files, %s)\n\n", deletionCount, Q_pretifymem(deletionSize, 2) ); + } + + double grand_total = 0; + double grand_total_unref = 0; + double grand_total_white = 0; + + char totalstring[ 20 ]; + char unrefstring[ 20 ]; + char refstring[ 20 ]; + char whiteliststring[ 20 ]; + + vprint( 0, "---------------------------------------- Summary ----------------------------------------\n" ); + + vprint( 0, "% 15s % 15s % 15s % 15s %12s\n", + "Referenced", + "WhiteListed", + "Unreferenced", + "Total", + "Directory" ); + + // Now walk the dictionary in order + i = directories.First(); + while ( i != invalidindex ) + { + DirEntry & de = directories[ i ]; + + double remainder = de.total - de.unreferenced; + + float percent_unref = 0.0f; + float percent_white = 0.0f; + if ( de.total > 0 ) + { + percent_unref = 100.0f * (float)de.unreferenced / (float)de.total; + percent_white = 100.0f * (float)de.whitelist / (float)de.total; + } + + Q_strncpy( totalstring, Q_pretifymem( de.total, 2 ), sizeof( totalstring ) ); + Q_strncpy( unrefstring, Q_pretifymem( de.unreferenced, 2 ), sizeof( unrefstring ) ); + Q_strncpy( refstring, Q_pretifymem( remainder, 2 ), sizeof( refstring ) ); + Q_strncpy( whiteliststring, Q_pretifymem( de.whitelist, 2 ), sizeof( whiteliststring ) ); + + vprint( 0, "%15s (%8.3f%%) %15s (%8.3f%%) %15s (%8.3f%%) %15s => dir: %s\n", + refstring, 100.0f - percent_unref, whiteliststring, percent_white, unrefstring, percent_unref, totalstring, directories.GetElementName( i ) ); + + grand_total += de.total; + grand_total_unref += de.unreferenced; + grand_total_white += de.whitelist; + + i = directories.Next( i ); + } + + Q_strncpy( totalstring, Q_pretifymem( grand_total, 2 ), sizeof( totalstring ) ); + Q_strncpy( unrefstring, Q_pretifymem( grand_total_unref, 2 ), sizeof( unrefstring ) ); + Q_strncpy( refstring, Q_pretifymem( grand_total - grand_total_unref, 2 ), sizeof( refstring ) ); + Q_strncpy( whiteliststring, Q_pretifymem( grand_total_white, 2 ), sizeof( whiteliststring ) ); + + double percent_unref = 100.0 * grand_total_unref / grand_total; + double percent_white = 100.0 * grand_total_white / grand_total; + + vprint( 0, "-----------------------------------------------------------------------------------------\n" ); + vprint( 0, "%15s (%8.3f%%) %15s (%8.3f%%) %15s (%8.3f%%) %15s\n", + refstring, 100.0f - percent_unref, whiteliststring, percent_white, unrefstring, percent_unref, totalstring ); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : argc - +// argv[] - +// Output : int +//----------------------------------------------------------------------------- +int main( int argc, char* argv[] ) +{ + SpewOutputFunc( SpewFunc ); + SpewActivate( "unusedcontent", 2 ); + + CommandLine()->CreateCmdLine( argc, argv ); + + int i=1; + for ( i ; i<argc ; i++) + { + if ( argv[ i ][ 0 ] == '-' ) + { + switch( argv[ i ][ 1 ] ) + { + case 'l': + uselogfile = true; + break; + case 'v': + verbose = true; + break; + case 'r': + showreferencedfiles = true; + break; + case 'd': + spewdeletions = true; + break; + case 'i': + immediatedelete = true; + break; + case 'w': + printwhitelist = true; + break; + case 'm': + showmapfileusage = true; + break; + case 'g': + // Just skip -game + Assert( !Q_stricmp( argv[ i ], "-game" ) ); + ++i; + break; + case 'f': + // grab reslists folder + { + ++i; + Q_strncpy( g_szReslistDir, argv[ i ], sizeof( g_szReslistDir ) ); + Q_strlower( g_szReslistDir ); + Q_FixSlashes( g_szReslistDir ); + Q_AppendSlash( g_szReslistDir, sizeof( g_szReslistDir ) ); + + } + break; + default: + printusage(); + break; + } + } + } + + if ( argc < 3 || ( i != argc ) ) + { + PrintHeader(); + printusage(); + return 0; + } + + CheckLogFile(); + + PrintHeader(); + + vprint( 0, " Using reslist dir '%s'\n", g_szReslistDir ); + + vprint( 0, " Looking for extraneous content...\n" ); + + char resfile[ 256 ]; + strcpy( resfile, argv[ i - 1 ] ); + + vprint( 0, " Comparing results of resfile (%s) with files under current directory...\n", resfile ); + + char workingdir[ 256 ]; + workingdir[0] = 0; + Q_getwd( workingdir, sizeof( workingdir ) ); + + // If they didn't specify -game on the command line, use VPROJECT. + CmdLib_InitFileSystem( workingdir ); + + filesystem = (IFileSystem *)(CmdLib_GetFileSystemFactory()( FILESYSTEM_INTERFACE_VERSION, NULL )); + if ( !filesystem ) + { + AssertMsg( 0, "Failed to create/get IFileSystem" ); + return 1; + } + + g_pFullFileSystem->RemoveAllSearchPaths(); + g_pFullFileSystem->AddSearchPath(gamedir, "GAME"); + + Q_strlower( gamedir ); + Q_FixSlashes( gamedir ); + + // + //ProcessMaterialsDirectory( vmtdir ); + + // find out the mod dir name + Q_strncpy( modname, gamedir, sizeof(modname) ); + modname[ strlen(modname) - 1] = 0; + + if ( strrchr( modname, '\\' ) ) + { + Q_strncpy( modname, strrchr( modname, '\\' ) + 1, sizeof(modname) ); + } + else + { + Q_strncpy( modname, "", sizeof(modname) ); + } + vprint( 1, "Mod Name:%s\n", modname); + + + BuildCheckdirList(); + BuildWhiteList(); + + vprint( 0, "Building aggregate file list from resfile output\n" ); + CUtlRBTree< ReferencedFile, int > referencedfiles( 0, 0, RefFileLessFunc ); + CUtlVector< UnusedContent::CUtlSymbol > resfiles; + + BuildReferencedFileList( resfiles, referencedfiles, resfile ); + + vprint( 0, "found %i files\n\n", referencedfiles.Count() ); + + vprint( 0, "Building list of all game content files\n" ); + CUtlVector< FileEntry > contentfiles; + CUtlVector< FileEntry > otherfiles; + BuildFileList( 0, contentfiles, &otherfiles, "", 0 ); + vprint( 0, "found %i files in content tree\n\n", contentfiles.Count() ); + + Correlate( referencedfiles, contentfiles, modname ); + + // now output the files not referenced in the whitelist or general reslists + filesystem->RemoveFile( CFmtStr( "%sunreferenced_files.lst", g_szReslistDir ), "GAME" ); + int c = otherfiles.Count(); + for ( i = 0; i < c; ++i ) + { + FileEntry & entry = otherfiles[ i ]; + char const *name = g_Analysis.symbols.String( entry.sym ); + + logprint( CFmtStr( "%sunreferenced_files.lst", g_szReslistDir ), "\"%s\\%s\"\n", modname, name ); + } + + // also include the files from deletions.bat, as we don't actually run that now + c = contentfiles.Count(); + for ( i = 0; i < c; ++i ) + { + FileEntry & entry = contentfiles[ i ]; + if ( entry.referenced != REFERENCED_NO ) + continue; + + char const *fn = g_Analysis.symbols.String( entry.sym ); + logprint( CFmtStr( "%sunreferenced_files.lst", g_szReslistDir ), "\"%s\\%s\"\n", modname, fn ); + } + + FileSystem_Term(); + + return 0; +}
\ No newline at end of file |