tf2/tf2_src/utils/depcheck/processmodule.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//
#include <assert.h>
#include <time.h>
#include "stdafx.h"
#include <stdio.h>
#include <windows.h>
#include "depcheck_util.h"
#include "codeprocessor.h"

/*
================
UTIL_FloatTime
================
*/
double UTIL_FloatTime (void)
{
// more precise, less portable
	clock_t current;
	static clock_t base;
	static bool first = true;

	current = clock();

	if ( first )
	{
		first = false;

		base = current;
	}
	
	return (double)(current - base)/(double)CLOCKS_PER_SEC;
}

void CCodeProcessor::AddHeader( int depth, const char *filename, const char *rootmodule )
{
//	if ( depth < 1 )
//		return;
	if ( depth != 1 )
		return;

	// Check header list
	for ( int i = 0; i < m_nHeaderCount; i++ )
	{
		if ( !stricmp( m_Headers[ i ].name, filename ) )
		{
			vprint( 0, "%s included twice in module %s\n", filename, rootmodule );
			return;
		}
	}
	
	// Add to list
	strcpy( m_Headers[ m_nHeaderCount++ ].name, filename );
}

void CCodeProcessor::CreateBackup( const char *filename, bool& wasreadonly )
{
	assert( strstr( filename, ".cpp" ) );

	// attrib it, change extension, save it
	if ( GetFileAttributes( filename ) & FILE_ATTRIBUTE_READONLY )
	{
		wasreadonly = true;

		SetFileAttributes( filename, FILE_ATTRIBUTE_NORMAL );
	}
	else
	{
		wasreadonly = false;
	}

	char backupname[ 256 ];
	strcpy( backupname, filename );
	strcpy( (char *)&backupname[ strlen( filename ) - 4 ], ".bak" );

	unlink( backupname );
	rename( filename, backupname );

}

void CCodeProcessor::RestoreBackup( const char *filename, bool makereadonly )
{
	assert( strstr( filename, ".cpp" ) );

	char backupname[ 256 ];
	strcpy( backupname, filename );
	strcpy( (char *)&backupname[ strlen( filename ) - 4 ], ".bak" );

	SetFileAttributes( filename, FILE_ATTRIBUTE_NORMAL );

	unlink( filename );
	rename( backupname, filename );

	if ( makereadonly )
	{
		SetFileAttributes( filename, FILE_ATTRIBUTE_READONLY );
	}

	unlink( backupname );
}

bool CCodeProcessor::TryBuild( const char *rootdir, const char *filename, unsigned char *buffer, int filelength )
{
//	vprintf( "trying build\n" );

	FILE *fp;
	fp = fopen( filename, "wb" );
	if ( !fp )
	{
		assert( 0 );
		return false;
	}

	fwrite( buffer, filelength, 1, fp );
	fclose( fp );

	// if build is successful, return true
	//
	//	return true;
	char commandline[ 512 ];
	char directory[ 512 ];

	sprintf( directory, rootdir );

	//	sprintf( commandline, "msdev engdll.dsw /MAKE \"quiver - Win32 GL Debug\" /OUT log.txt" );

	// Builds the default configuration
	sprintf( commandline, "\"C:\\Program Files\\Microsoft Visual Studio\\Common\\MSDev98\\Bin\\msdev.exe\" %s /MAKE \"%s\" /OUT log.txt", m_szDSP, m_szConfig );

	PROCESS_INFORMATION pi;
	memset( &pi, 0, sizeof( pi ) );

	STARTUPINFO si;
	memset( &si, 0, sizeof( si ) );
	si.cb = sizeof( si );

	if ( !CreateProcess( NULL, commandline, NULL, NULL, TRUE, 0, NULL, directory, &si, &pi ) )
	{
LPVOID lpMsgBuf;
FormatMessage( 
    FORMAT_MESSAGE_ALLOCATE_BUFFER | 
    FORMAT_MESSAGE_FROM_SYSTEM | 
    FORMAT_MESSAGE_IGNORE_INSERTS,
    NULL,
    GetLastError(),
    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
    (LPTSTR) &lpMsgBuf,
    0,
    NULL 
);
// Process any inserts in lpMsgBuf.
// ...
// Display the string.
MessageBox( NULL, (LPCTSTR)lpMsgBuf, "Error", MB_OK | MB_ICONINFORMATION );
// Free the buffer.
LocalFree( lpMsgBuf );
		return false;
	}

	// Wait until child process exits.
    WaitForSingleObject( pi.hProcess, INFINITE );

	bool retval = false;
	DWORD exitCode = -1;
	if ( GetExitCodeProcess( pi.hProcess, &exitCode ) )
	{
		if ( !exitCode )
		{
			retval = true;
		}
	}
	
    // Close process and thread handles. 
    CloseHandle( pi.hProcess );
    CloseHandle( pi.hThread );

	return retval;
}

void CCodeProcessor::ProcessModule( bool forcequiet, int depth, int& maxdepth, int& numheaders, int& skippedfiles, const char *baseroot, const char *root, const char *module )
{
	char filename[ 256 ];

	bool checkroot = false;

	if ( depth > maxdepth )
	{
		maxdepth = depth;
	}

	// Load the base module
	sprintf( filename, "%s\\%s", root, module );
	strlwr( filename );

	bool firstheader = true;
retry:

	// Check module list
	for ( int i = 0; i < m_nModuleCount; i++ )
	{
		if ( !stricmp( m_Modules[ i ].name, filename ) )
		{
			if ( forcequiet )
			{
				m_nHeadersProcessed++;
				numheaders++;

				if ( m_Modules[ i ].skipped )
				{
					skippedfiles++;
				}
			}

			AddHeader( depth, filename, m_szCurrentCPP );

			return;
		}
	}

	int filelength;
	char *buffer = (char *)COM_LoadFile( filename, &filelength );
	if ( !buffer )
	{
		if ( !checkroot )
		{
			checkroot = true;
			// Load the base module
			sprintf( filename, "%s\\%s", baseroot, module );
			goto retry;
		}
		m_Modules[ m_nModuleCount ].skipped = true;
		strcpy( m_Modules[ m_nModuleCount++ ].name, filename );
		
		skippedfiles++;
		return;
	}

	m_nBytesProcessed += filelength;

	m_Modules[ m_nModuleCount ].skipped = false;
	strcpy( m_Modules[ m_nModuleCount++ ].name, filename );

	bool readonly = false;
	bool madechanges = false;
	CreateBackup( filename, readonly );

	if ( !forcequiet )
	{
		strcpy( m_szCurrentCPP, filename );
		
		vprint( 0, "- %s\n", (char *)&filename[ m_nOffset ] );
	}

	// Parse tokens looking for #include directives or class starts
	char *current = buffer;
	char *startofline;

	current = CC_ParseToken( current );
	while ( current )
	{
		// No more tokens
		if ( strlen( com_token ) <= 0 )
			break;

		if ( !stricmp( com_token, "#include" ) )
		{
			startofline = current - strlen( "#include" );

			current = CC_ParseToken( current );

			if ( strlen( com_token ) > 0)
			{
				vprint( 1, "#include %s", com_token );
				m_nHeadersProcessed++;
				numheaders++;				

				AddHeader( depth, filename, m_szCurrentCPP );

				bool dobuild = true;
				if ( firstheader )
				{
					if ( !stricmp( com_token, "cbase.h" ) )
					{
						dobuild = false;
					}

					if ( !TryBuild( baseroot, filename, (unsigned char *)buffer, filelength ) )
					{
						// build is broken, stop
						assert( 0 );
					}
				}

				firstheader = false;

				if ( dobuild )
				{
					// Try removing the header and compiling
					char saveinfo[2];
					memcpy( saveinfo, startofline, 2 );
					startofline[ 0 ] = '/';
					startofline[ 1 ] = '/';

					if ( TryBuild( baseroot, filename, (unsigned char *)buffer, filelength ) )
					{
						vprint( 0, ", unnecessary\n" );
						madechanges = true;
					}
					else
					{
						// Restore line
						memcpy( startofline, saveinfo, 2 );
						vprint( 0, "\n" );
					}
				}
				else
				{
					vprint( 0, "\n" );
				}
			}
		}

		current = CC_ParseToken( current );
	}

	// Save out last set of changes
	{
		FILE *fp;
		fp = fopen( filename, "wb" );
		if ( fp )
		{
			fwrite( buffer, filelength, 1, fp );
			fclose( fp );
		}
	}

	COM_FreeFile( (unsigned char *)buffer );

	if ( !madechanges )
	{
		RestoreBackup( filename, readonly );
	}

	if ( !forcequiet && !GetQuiet() )
	{
		vprint( 0, " %s: headers (%i)", (char *)&filename[ m_nOffset ], numheaders );
		if ( maxdepth > 1 )
		{
			vprint( 0, ", depth %i", maxdepth );
		}
		vprint( 0, "\n" );
	}

	m_nLinesOfCode += linesprocessed;
	linesprocessed = 0;
}

void CCodeProcessor::ProcessModules( const char *root, const char *rootmodule )
{
	m_nFilesProcessed++;

	// Reset header list per module
	m_nHeaderCount = 0;
	m_nModuleCount = 0;

	int numheaders = 0;
	int maxdepth = 0;
	int skippedfiles = 0;

	bool canstart = false;

	if ( strstr( root, "tf2_hud" ) )
	{
		canstart = true;
	}
	if ( !canstart )
	{
		vprint( 0, "skipping %s\n", rootmodule );
		return;
	}
	ProcessModule( false, 0, maxdepth, numheaders, skippedfiles, root, root, rootmodule );
}

void CCodeProcessor::PrintResults( void )
{
	vprint( 0, "\nChecking for errors and totaling...\n\n" );

	vprint( 0, "parsed from %i files ( %i headers parsed )\n",
		m_nFilesProcessed,
		m_nHeadersProcessed );

	vprint( 0, "%.3f K lines of code processed\n",
		(double)m_nLinesOfCode / 1024.0 );
	
	double elapsed = ( m_flEnd - m_flStart );

	if ( elapsed > 0.0 )
	{
		vprint( 0, "%.2f K processed in %.3f seconds, throughput %.2f KB/sec\n\n",
			(double)m_nBytesProcessed / 1024.0, elapsed, (double)m_nBytesProcessed / ( 1024.0 * elapsed ) );
	}
}

CCodeProcessor::CCodeProcessor( void )
{
	m_nModuleCount					= 0;

	m_bQuiet						= false;
	m_bLogToFile					= false;

	m_nFilesProcessed				= 0;
	m_nHeadersProcessed				= 0;
	m_nOffset						= 0;
	m_nBytesProcessed				= 0;
	m_nLinesOfCode					= 0;
	m_flStart						= 0.0;
	m_flEnd							= 0.0;

	m_szCurrentCPP[ 0 ]				= 0;
}

CCodeProcessor::~CCodeProcessor( void )
{
}

char const *stristr( char const *src, char const *search )
{
	char buf1[ 512 ];
	char buf2[ 512 ];

	strcpy( buf1, src );
	_strlwr( buf1 );

	strcpy( buf2, search );
	_strlwr( buf2 );

	char *p =  strstr( buf1, buf2 );
	if ( p )
	{
		int len = p - buf1;
		return src + len;
	}
	return NULL;
}

void CCodeProcessor::ConstructModuleList_R( int level, const char *gamespecific, const char *root )
{
	char directory[ 256 ];
	char filename[ 256 ];
	WIN32_FIND_DATA wfd;
	HANDLE ff;

	sprintf( directory, "%s\\*.*", root );

	if ( ( ff = FindFirstFile( directory, &wfd ) ) == INVALID_HANDLE_VALUE )
		return;

	do
	{
		if ( wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
		{

			if ( wfd.cFileName[ 0 ] == '.' )
				continue;

			// Once we descend down a branch, don't keep looking for hl2/tf2 in name, just recurse through all children
			if ( level == 0 && !stristr( wfd.cFileName, gamespecific ) )
				continue;

			// Recurse down directory
			sprintf( filename, "%s\\%s", root, wfd.cFileName );
			ConstructModuleList_R( level+1, gamespecific, filename );
		}
		else
		{
			if ( strstr( wfd.cFileName, ".cpp" ) )
			{
				ProcessModules( root, wfd.cFileName );
			}
		}
	} while ( FindNextFile( ff, &wfd ) );
}

void CCodeProcessor::Process( const char *gamespecific, const char *root, const char *dsp, const char *config )
{
	strcpy( m_szDSP, dsp );
	strcpy( m_szConfig, config );

	m_nBytesProcessed	= 0;
	m_nFilesProcessed	= 0;
	m_nHeadersProcessed = 0;
	m_nLinesOfCode		= 0;

	linesprocessed		= 0;

	m_nOffset = strlen( root ) + 1;

	m_nModuleCount = 0;
	m_nHeaderCount = 0;
	m_flStart = UTIL_FloatTime();

	vprint( 0, "--- Processing %s\n\n", root );

	ConstructModuleList_R( 0, gamespecific, root );

	m_flEnd = UTIL_FloatTime();

	PrintResults();
}

void CCodeProcessor::SetQuiet( bool quiet )
{
	m_bQuiet = quiet;
}

bool CCodeProcessor::GetQuiet( void ) const
{
	return m_bQuiet;
}

void CCodeProcessor::SetLogFile( bool log )
{
	m_bLogToFile = log;
}

bool CCodeProcessor::GetLogFile( void ) const
{
	return m_bLogToFile;
}

static CCodeProcessor g_Processor;
ICodeProcessor *processor = ( ICodeProcessor * )&g_Processor;