tf2/tf2_src/utils/classcheck/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 "classcheck_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;
}

CClass *CCodeProcessor::FindClass( const char *name ) const
{
	CClass *cl = m_pClassList;
	while ( cl )
	{
		if ( !stricmp( cl->m_szName, name ) )
			return cl;

		cl = cl->m_pNext;
	}
	return NULL;
}

void ClearMissingTypes();

void CCodeProcessor::Clear( void )
{
	ClearMissingTypes();

	CClass *cl = m_pClassList, *next;
	while ( cl )
	{
		next = cl->m_pNext;
		delete cl;
		cl = next;
	}
	m_pClassList = NULL;
}



int CCodeProcessor::Count( void ) const
{
	int c = 0;
	CClass *cl = m_pClassList;
	while ( cl )
	{
		c++;
		cl = cl->m_pNext;
	}
	return c;
}

int FnClassSortCompare( const void *elem1, const void *elem2 )
{
	CClass *c1 = *(CClass **)elem1;
	CClass *c2 = *(CClass **)elem2;

	return ( stricmp( c1->m_szName, c2->m_szName ) );
}

void CCodeProcessor::SortClassList( void )
{
	int n = Count();
	if ( n <= 1 )
		return;

	CClass **ppList = new CClass *[ n ];
	if ( ppList )
	{
		CClass *cl;
		int i;
		for ( i = 0, cl = m_pClassList; i < n; i++, cl = cl->m_pNext )
		{
			ppList[ i ] = cl;
		}

		qsort( ppList, n, sizeof( CClass * ), FnClassSortCompare );

		for ( i = 0; i < n - 1; i++ )
		{
			ppList[ i ]->m_pNext = ppList[ i + 1 ];
		}
		ppList[ i ]->m_pNext = NULL;
		m_pClassList = ppList[ 0 ];
	}
	delete[] ppList;
}

void CCodeProcessor::ResolveBaseClasses( const char *baseentityclass )
{
	SortClassList();

	CClass *cl = m_pClassList;
	while ( cl )
	{
		if ( cl->m_szBaseClass[0] )
		{
			cl->m_pBaseClass = FindClass( cl->m_szBaseClass );
			if ( !cl->m_pBaseClass )
			{
				//vprint( 0, "couldn't find base class %s for %s\n", cl->m_szBaseClass, cl->m_szName );
			}
		}
		
		cl = cl->m_pNext;
	}

	cl = m_pClassList;
	while ( cl )
	{
		cl->CheckChildOfBaseEntity( baseentityclass );
		cl = cl->m_pNext;
	}
}

void CCodeProcessor::PrintMissingTDFields( void ) const
{
	int classcount;
	int fieldcount;
	int c;

	CClass *cl;

	if ( GetPrintTDs() )
	{
		classcount = 0;
		fieldcount = 0;
		cl = m_pClassList;
		while ( cl )
		{
			if ( cl->m_bDerivedFromCBaseEntity || cl->m_bHasSaveRestoreData )
			{
				if ( cl->CheckForMissingTypeDescriptionFields( c ) )
				{
					classcount++;
					fieldcount += c;
				}
			}
			cl = cl->m_pNext;
		}

		if ( fieldcount )
		{
			vprint( 0, "\nSummary:  %i fields missing from %i classes\n", fieldcount, classcount );
		}
		else
		{
			if ( !classcount )
			{
				vprint( 0, "\nSummary:  no saverestore info present\n");
			}
			else
			{
				vprint( 0, "\nSummary:  no errors for %i classes\n", classcount );
			}
		}

		vprint( 0, "\n" );
	}

	if ( GetPrintPredTDs() )
	{
		//Now check prediction stuff
		classcount = 0;
		fieldcount = 0;
		cl = m_pClassList;
		while ( cl )
		{
			if ( cl->m_bDerivedFromCBaseEntity || cl->m_bHasPredictionData )
			{
				if ( cl->CheckForMissingPredictionFields( c, false ) )
				{
					classcount++;
					fieldcount += c;
				}
			}
			cl = cl->m_pNext;
		}

		if ( fieldcount )
		{
			vprint( 0, "\nSummary:  %i prediction fields missing from %i classes\n", fieldcount, classcount );
		}
		else
		{
			if ( !classcount )
			{
				vprint( 0, "\nSummary:  no prediction info present\n");
			}
			else
			{
				vprint( 0, "\nSummary:  no errors for %i predictable classes\n", classcount );
			}
		}

		vprint( 0, "\n" );
	}

	if ( GetPrintCreateMissingTDs() )
	{
		//Now check prediction stuff
		classcount = 0;
		fieldcount = 0;
		cl = m_pClassList;
		while ( cl )
		{
			if ( cl->m_bDerivedFromCBaseEntity || cl->m_bHasSaveRestoreData )
			{
				if ( cl->CheckForMissingTypeDescriptionFields( c, true ) )
				{
					classcount++;
					fieldcount += c;
				}
			}
			cl = cl->m_pNext;
		}

		if ( fieldcount )
		{
			vprint( 0, "\nSummary:  %i saverestore fields missing from %i classes\n", fieldcount, classcount );
		}
		else
		{
			if ( !classcount )
			{
				vprint( 0, "\nSummary:  no saverestore info present\n");
			}
			else
			{
				vprint( 0, "\nSummary:  no errors for %i classes\n", classcount );
			}
		}

		vprint( 0, "\n" );
	}

	if ( GetPrintCreateMissingPredTDs() )
	{
		//Now check prediction stuff
		classcount = 0;
		fieldcount = 0;
		cl = m_pClassList;
		while ( cl )
		{
			if ( cl->m_bDerivedFromCBaseEntity || cl->m_bHasPredictionData )
			{
				if ( cl->CheckForMissingPredictionFields( c, true ) )
				{
					classcount++;
					fieldcount += c;
				}
			}
			cl = cl->m_pNext;
		}

		if ( fieldcount )
		{
			vprint( 0, "\nSummary:  %i prediction fields missing from %i classes\n", fieldcount, classcount );
		}
		else
		{
			if ( !classcount )
			{
				vprint( 0, "\nSummary:  no prediction info present\n");
			}
			else
			{
				vprint( 0, "\nSummary:  no errors for %i predictable classes\n", classcount );
			}
		}

		vprint( 0, "\n" );
	}

	// Now check for things that are in the prediction TD but not marked correctly as being part of the sendtable
	{
		//Now check prediction stuff
		classcount = 0;
		fieldcount = 0;
		cl = m_pClassList;
		while ( cl )
		{
			if ( cl->m_bDerivedFromCBaseEntity || cl->m_bHasPredictionData )
			{
				if ( cl->CheckForPredictionFieldsInRecvTableNotMarkedAsSuchCorrectly( c ) )
				{
					classcount++;
					fieldcount += c;
				}
			}
			cl = cl->m_pNext;
		}

		vprint( 0, "\n" );
	}

	// Print stuff derived from CBaseEntity that doesn't have save/restore data
	vprint( 0, "\nMissing DATADESC tables:\n\n" );
	cl = m_pClassList;
	while ( cl )
	{
		if ( cl->m_bDerivedFromCBaseEntity && !cl->m_bHasSaveRestoreData && cl->m_nVarCount )
		{
			vprint( 0, "\t%s\n", cl->m_szName );
		}
		cl = cl->m_pNext;
	}
	vprint( 0, "\n" );
}

void CCodeProcessor::ReportHungarianNotationErrors()
{
	if ( !GetCheckHungarian() )
		return;

	vprint( 0, "\tChecking for hungarian notation issues\n" );

	CClass *cl = m_pClassList;
	int classcount = 0;
	int warningcount = 0;
	while ( cl )
	{
		int c = 0;
		
		cl->CheckForHungarianErrors( c );
		
		classcount++;
		warningcount += c;

		cl = cl->m_pNext;
	}

	vprint( 0, "\tFound %i notation errors across %i classes\n", classcount, warningcount );
}

void CCodeProcessor::PrintClassList( void ) const
{
	if ( GetPrintHierarchy() )
	{
		vprint( 0, "\nClass Summary\n\n" );
	}

	CClass *cl = m_pClassList;
	
	while ( cl )
	{
		if ( cl->m_bDerivedFromCBaseEntity )
		{
			bool missing = false;
			char missingwarning[ 128 ];

			missingwarning[0]=0;
			if ( cl->m_szTypedefBaseClass[0] )
			{
				if ( stricmp( cl->m_szBaseClass, cl->m_szTypedefBaseClass ) )
				{
					vprint( 0, "class %s has incorrect typedef %s BaseClass\n", cl->m_szName, cl->m_szTypedefBaseClass );
				}
			}
			else if ( cl->m_szBaseClass[ 0 ] )
			{
				missing = true;
				sprintf( missingwarning, ", missing typedef %s BaseClass", cl->m_szBaseClass );
			}

			if ( GetPrintHierarchy() || missing )
			{
				vprint( 0, "class %s%s\n", cl->m_szName, missing ? missingwarning : "" );
			}

			int level = 1;
			CClass *base = cl->m_pBaseClass;
			while ( base )
			{
				if ( GetPrintHierarchy() )
				{
					vprint( level++, "public %s\n", base->m_szName );
				}
				base = base->m_pBaseClass;
			}

			int i; 

			if ( GetPrintHierarchy() && GetPrintMembers() )
			{

				if ( cl->m_nMemberCount )
				{
					vprint( 1, "\nMember functions:\n\n" );
				}

				for ( i = 0; i < cl->m_nMemberCount; i++ )
				{
					CClassMemberFunction *member = cl->m_Members[ i ];

					if ( member->m_szType[0] )
					{
						vprint( 1, "%s %s();\n", member->m_szType, member->m_szName );
					}
					else
					{
						char *p = member->m_szName;
						if ( *p == '~' )
							p++;

						if ( stricmp( p, cl->m_szName ) )
						{
							vprint( 0, "class %s has member function %s with no return type!!!\n",
								cl->m_szName, member->m_szName );
						}
						vprint( 1, "%s();\n", member->m_szName );
					}
				}

				if ( cl->m_nVarCount )
				{
					vprint( 1, "\nMember Variables\n\n" );
				}

				
				for ( i = 0; i < cl->m_nVarCount; i++ )
				{
					CClassVariable *var = cl->m_Variables[ i ];

					if ( var->m_bIsArray )
					{
						if ( var->m_szArraySize[0]==0 )
						{
							vprint( 1, "%s %s[];\n", var->m_szType, var->m_szName );
						}
						else
						{
							vprint( 1, "%s %s[ %s ];\n", var->m_szType, var->m_szName, var->m_szArraySize );
						}
					}
					else
					{
						vprint( 1, "%s %s;\n", var->m_szType, var->m_szName );
					}
				}

				if ( cl->m_nTDCount )
				{
					vprint( 1, "\nSave/Restore TYPEDESCRIPTION\n\n" );
				}

				for ( i = 0; i < cl->m_nTDCount; i++ )
				{
					CTypeDescriptionField *td = cl->m_TDFields[ i ];
					if ( td->m_bCommentedOut )
					{
						vprint( 1, "// " );
					}
					else
					{
						vprint( 1, "" );
					}

					vprint( 0, "%s( %s, %s, %s, ... )\n", td->m_szDefineType, cl->m_szName, td->m_szVariableName, td->m_szType );
				}

				if ( !cl->m_bHasSaveRestoreData )
				{
				//	vprint( 1, "\nSave/Restore TYPEDESCRIPTION not specified for class\n\n" );
				}

				if ( cl->m_nPredTDCount )
				{
					vprint( 1, "\nPrediction TYPEDESCRIPTION\n\n" );
				}

				for ( i = 0; i < cl->m_nPredTDCount; i++ )
				{
					CTypeDescriptionField *td = cl->m_PredTDFields[ i ];
					if ( td->m_bCommentedOut )
					{
						vprint( 1, "// " );
					}
					else
					{
						vprint( 1, "" );
					}

					vprint( 0, "%s( %s, %s, %s, ... )\n", td->m_szDefineType, cl->m_szName, td->m_szVariableName, td->m_szType );
				}

				if ( !cl->m_bHasPredictionData )
				{
				//	vprint( 1, "\nPrediction TYPEDESCRIPTION not specified for class\n\n" );
				}
			}
		
			if ( GetPrintHierarchy() )
			{
				vprint( 0, "\n" );
			}
		}

		cl = cl->m_pNext;
	}
}

CClass *CCodeProcessor::AddClass( const char *classname )
{
	CClass *cl = FindClass( classname );
	if ( !cl )
	{
		cl = new CClass( classname );

		m_nClassesParsed++;

		cl->m_pNext = m_pClassList;
		m_pClassList = cl;
	}
	return cl;
}



char *CCodeProcessor::ParseTypeDescription( char *current, bool fIsMacroized )
{
	// Next token is classname then :: then variablename then braces then = then {
	char classname[ 256 ];
	char variablename[ 256 ];

	if ( !fIsMacroized )
	{
		current = CC_ParseToken( current );
		if ( strlen( com_token ) <= 0 )
			return current;

		strcpy( classname, com_token );
		if ( classname[0]=='*' )
			return current;

		current = CC_ParseToken( current );
		if (stricmp( com_token, ":" ) )
		{
			return current;
		}

		current = CC_ParseToken( current );
		Assert( !stricmp( com_token, ":" ) );

		current = CC_ParseToken( current );
		if ( strlen( com_token ) <= 0 )
			return current;

		strcpy( variablename, com_token );
	}
	else
	{
		current = CC_ParseToken( current );
		if (stricmp( com_token, "(" ) )
		{
			return current;
		}

		current = CC_ParseToken( current );
		if ( strlen( com_token ) <= 0 )
			return current;

		strcpy( classname, com_token );
		if ( classname[0]=='*' )
			return current;

		current = CC_ParseToken( current );
		if (stricmp( com_token, ")" ) )
		{
			return current;
		}

		// It's macro-ized
		strcpy( variablename, "m_DataDesc" );
	}
	if ( !fIsMacroized )
	{
		char ch;
		current = CC_RawParseChar( current, "{", &ch );
		Assert( ch == '{' );
		if ( strlen( com_token ) <= 0 )
			return current;
	}

	com_ignoreinlinecomment = true;
	bool insidecomment = false;

	// Now parse typedescription line by line
	while ( 1 )
	{
		current = CC_ParseToken( current );
		if ( strlen( com_token ) <= 0 )
			break;

		// Go to next line
		if ( !stricmp( com_token, "," ) )
			continue;

		// end
		if ( !fIsMacroized )
		{
			if ( !stricmp( com_token, "}" ) )
				break;
		}
		else
		{
			if ( !stricmp( com_token, "END_DATADESC" ) ||
				 !stricmp( com_token, "END_BYTESWAP_DATADESC" ) )
				break;
		}

		// skip #ifdef's inside of typedescs
		if ( com_token[0]=='#' )
		{
			current = CC_ParseUntilEndOfLine( current );
			continue;
		}

		if ( !stricmp( com_token, "/" ) )
		{
			current = CC_ParseToken( current );
			if ( !stricmp( com_token, "/" ) )
			{
				// There are two styles supported. One is to have the member definition present but commented out:
				//		DEFINE_FIELD( m_member, FIELD_INTEGER ),
				// the other is to have a comment where the first token of the comment is a member name:
				//		m_member
				current = CC_ParseToken( current );
				if ( !strnicmp( com_token, "DEFINE_", 7 ) )
				{
					CC_UngetToken();
					insidecomment = true;
				}
				else
				{
					char commentedvarname[ 256 ];
					strcpy( commentedvarname, com_token );

					CClass *cl = FindClass( classname );
					if ( cl )
					{
						if ( !cl->FindTD( commentedvarname ) )
						{
							cl->AddTD( commentedvarname, "", "", true );
						}
						// Mark that it has a data table
						cl->m_bHasSaveRestoreData = true;
					}
					current = CC_ParseUntilEndOfLine( current );
				}
				continue;
			}
		}

		com_ignoreinlinecomment = false;

		// Parse a typedescription line
		char definetype[ 256 ];
		strcpy( definetype, com_token );

		current = CC_ParseToken( current );
		if ( stricmp( com_token, "(" ) )
			break;

		char varname[ 256 ];
		current = CC_ParseToken( current );

		strcpy( varname, com_token );

		
		char vartype[ 256 ];

		vartype[0]=0;

		if ( !stricmp( definetype, "DEFINE_FUNCTION" ) ||
			!stricmp( definetype, "DEFINE_THINKFUNC" ) ||
			!stricmp( definetype, "DEFINE_ENTITYFUNC" ) ||
			!stricmp( definetype, "DEFINE_USEFUNC" ) ||
			!stricmp( definetype, "DEFINE_OUTPUT" ) ||
			!stricmp( definetype, "DEFINE_INPUTFUNC" ) )
		{
			strcpy( vartype, "funcptr" );
		}
		else if ( !stricmp(definetype, "DEFINE_FIELD") || 
			!stricmp(definetype, "DEFINE_INDEX") ||
			!stricmp(definetype, "DEFINE_KEYFIELD") || 
			!stricmp(definetype, "DEFINE_KEYFIELD_NOT_SAVED") || 
			!stricmp(definetype, "DEFINE_UTLVECTOR") || 
			!stricmp(definetype, "DEFINE_GLOBAL_FIELD") || 
			!stricmp(definetype, "DEFINE_GLOBAL_KEYFIELD") || 
			!stricmp(definetype, "DEFINE_CUSTOM_FIELD") ||
			!stricmp(definetype, "DEFINE_INPUT") ||
			!stricmp(definetype, "DEFINE_AUTO_ARRAY") ||
			!stricmp(definetype, "DEFINE_AUTO_ARRAY_KEYFIELD") ||
			!stricmp(definetype, "DEFINE_AUTO_ARRAY2D") ||
			!stricmp(definetype, "DEFINE_ARRAY") )
		{
			// skip comma
			current = CC_ParseToken( current );
			if (!strcmp( com_token, "[" ))
			{
				// Read array...
				current = CC_ParseToken( current );
				strcat( varname, "[" );
				strcat( varname, com_token );
				current = CC_ParseToken( current );

				// eat everything until the next "]"
				while (strcmp( com_token, "]") != 0)
				{
					strcat( varname, com_token );
					current = CC_ParseToken( current );
				}

				if ( strcmp( com_token, "]" ))
				{
					current = current;
				}

 				strcat( varname, "]" );

				// skip comma
				current = CC_ParseToken( current );
			}

			current = CC_ParseToken( current );

			strcpy( vartype, com_token );
		}

		// Jump to end of definition
		int nParenCount = 1;
		do
		{
			current = CC_ParseToken( current );
			if ( strlen( com_token ) <= 0 )
				break;

			if ( !stricmp( com_token, "(" ) )
			{
				++nParenCount; 
			}
			else if ( !stricmp( com_token, ")" ) )
			{
				if ( --nParenCount == 0 )
				{
					break;
				}
			}

		} while ( 1 );

//		vprint( 2, "%s%s::%s %s %s %s\n",
//			insidecomment ? "// " : "",
//			classname, variablename,
//			definetype, varname, vartype );

		CClass *cl = FindClass( classname );
		if ( cl )
		{
			if ( strcmp( vartype, "funcptr" ) && cl->FindTD( varname ) )
			{
				vprint( 0, "class %s::%s already has typedescription entry for field %s\n", classname, variablename, varname );
			}
			else
			{
				cl->AddTD( varname, vartype, definetype, insidecomment );
			}
			// Mark that it has a data table
			cl->m_bHasSaveRestoreData = true;
		}
		insidecomment = false;
		com_ignoreinlinecomment = true;
	}

	com_ignoreinlinecomment = false;

	return current;
}

char *CCodeProcessor::ParseReceiveTable( char *current )
{
	// Next token is open paren, then classname close paren, then {
	char classname[ 256 ];

	current = CC_ParseToken( current );
	if (stricmp( com_token, "(" ) )
	{
		return current;
	}

	current = CC_ParseToken( current );
	if ( strlen( com_token ) <= 0 )
		return current;

	strcpy( classname, com_token );
	if ( classname[0]=='*' )
		return current;
	if ( !strcmp( classname, "className" ) )
		return current;
	if ( !strcmp( classname, "clientClassName" ) )
		return current;

	CClass *cl = FindClass( classname );
	if ( cl )
	{
		cl->m_bHasRecvTableData = true;
	}

	CClass *leafClass = cl;

	// parse until end of line
	current = CC_ParseUntilEndOfLine( current );

	// Now parse recvtable entries line by line
	while ( 1 )
	{
		cl = leafClass;

		current = CC_ParseToken( current );
		if ( strlen( com_token ) <= 0 )
			break;

		// Go to next line
		if ( !stricmp( com_token, "," ) )
			continue;

		// end
		if ( !stricmp( com_token, "END_RECV_TABLE" ) )
			break;

		// skip #ifdef's inside of recv tables
		if ( com_token[0]=='#' )
		{
			current = CC_ParseUntilEndOfLine( current );
			continue;
		}

		// Parse recproxy line
		char recvproptype[ 256 ];
		strcpy( recvproptype, com_token );

		if ( strnicmp( recvproptype, "RecvProp", strlen( "RecvProp" ) ) )
		{
			current = CC_ParseUntilEndOfLine( current );
			continue;
		}

		if ( !strcmp( recvproptype, "RecvPropArray" ) )
		{
			current = CC_ParseToken( current );
			if ( stricmp( com_token, "(" ) )
				break;

			current = CC_ParseToken( current );
			if ( strnicmp( recvproptype, "RecvProp", strlen( "RecvProp" ) ) )
			{
				current = CC_ParseUntilEndOfLine( current );
				continue;
			}
		}

		current = CC_ParseToken( current );
		if ( stricmp( com_token, "(" ) )
			break;

		// Read macro or fieldname
		current = CC_ParseToken( current );

		char varname[ 256 ];

		if ( !strnicmp( com_token, "RECVINFO", strlen( "RECVINFO" ) ) )
		{
			current = CC_ParseToken( current );
			if ( stricmp( com_token, "(" ) )
				break;
			current = CC_ParseToken( current );
		}
		else
		{
			current = CC_ParseUntilEndOfLine( current );
			continue;
		}

		strcpy( varname, com_token );

		current = CC_ParseUntilEndOfLine( current );

		if ( cl )
		{
			// Look up the var
			CClassVariable *classVar = cl->FindVar( varname, true );
			if ( classVar )
			{
				classVar->m_bInRecvTable = true;
			}
			else
			{
				char cropped[ 256 ];
				char root[ 256 ];
				strcpy( cropped, varname );

				while ( 1 )
				{
					// See if varname is an embedded var
					char *spot = strstr( cropped, "." );
					if ( spot )
					{
						strcpy( root, cropped );
						root[ spot - cropped ] = 0;
						strcpy( cropped, spot + 1 );

						classVar = cl->FindVar( root, true );	
					}
					else
					{
						classVar = cl->FindVar( cropped, true );
						break;
					}

					if ( classVar )
						break;
				}

				if ( !classVar )
				{
					vprint( 0, "class %s::%s missing, but referenced by RecvTable!!!\n", classname, varname );
				}
				else
				{
					classVar->m_bInRecvTable = true;
				}
			}
		}
		else
		{
			vprint( 0, "class %s::%s found in RecvTable, but no such class is known!!!\n", classname, varname );
		}
	}

	return current;
}

char *CCodeProcessor::ParsePredictionTypeDescription( char *current )
{
	// Next token is open paren, then classname close paren, then {
	char classname[ 256 ];
	char variablename[ 256 ];

	current = CC_ParseToken( current );
	if (stricmp( com_token, "(" ) )
	{
		return current;
	}

	current = CC_ParseToken( current );
	if ( strlen( com_token ) <= 0 )
		return current;

	strcpy( classname, com_token );
	if ( classname[0]=='*' )
		return current;

	CClass *cl = FindClass( classname );
	if ( cl )
	{
		cl->m_bHasPredictionData = true;
	}

	current = CC_ParseToken( current );
	if (stricmp( com_token, ")" ) )
	{
		return current;
	}

	// It's macro-ized
	strcpy( variablename, "m_PredDesc" );

	com_ignoreinlinecomment = true;
	bool insidecomment = false;

	// Now parse typedescription line by line
	while ( 1 )
	{
		current = CC_ParseToken( current );
		if ( strlen( com_token ) <= 0 )
			break;

		// Go to next line
		if ( !stricmp( com_token, "," ) )
			continue;

		// end
		if ( !stricmp( com_token, "END_PREDICTION_DATA" ) )
			break;

		// skip #ifdef's inside of typedescs
		if ( com_token[0]=='#' )
		{
			current = CC_ParseUntilEndOfLine( current );
			continue;
		}

		if ( !stricmp( com_token, "/" ) )
		{
			current = CC_ParseToken( current );
			if ( !stricmp( com_token, "/" ) )
			{
				current = CC_ParseToken( current );
				if ( !strnicmp( com_token, "DEFINE_", 7 ) )
				{
					CC_UngetToken();
					insidecomment = true;
				}
				else
				{
					current = CC_ParseUntilEndOfLine( current );
				}
				continue;
			}
		}

		com_ignoreinlinecomment = false;

		// Parse a typedescription line
		char definetype[ 256 ];
		strcpy( definetype, com_token );

		current = CC_ParseToken( current );
		if ( stricmp( com_token, "(" ) )
			break;

		char varname[ 256 ];
		current = CC_ParseToken( current );

		strcpy( varname, com_token );

		
		char vartype[ 256 ];

		vartype[0]=0;

		if ( stricmp( definetype, "DEFINE_FUNCTION" ) )
		{
			// skip comma
			current = CC_ParseToken( current );

			current = CC_ParseToken( current );

			strcpy( vartype, com_token );
		}
		else
		{
			strcpy( vartype, "funcptr" );
		}

		bool inrecvtable = false;
		// Jump to end of definition
		int nParenCount = 1;
		do
		{
			current = CC_ParseToken( current );
			if ( strlen( com_token ) <= 0 )
				break;

			if ( !stricmp( com_token, "(" ) )
			{
				++nParenCount; 
			}
			else if ( !stricmp( com_token, ")" ) )
			{
				if ( --nParenCount == 0 )
				{
					break;
				}
			}

			if ( !stricmp( com_token, "FTYPEDESC_INSENDTABLE" ) )
			{
				inrecvtable = true;
			}

		} while ( 1 );

		/*
		vprint( 2, "%s%s::%s %s %s %s\n",
			insidecomment ? "// " : "",
			classname, variablename,
			definetype, varname, vartype );
		*/

		if ( cl )
		{
			if ( cl->FindPredTD( varname ) )
			{
				vprint( 0, "class %s::%s already has prediction typedescription entry for field %s\n", classname, variablename, varname );
			}
			else
			{
				cl->AddPredTD( varname, vartype, definetype, insidecomment, inrecvtable );
			}
		}
		insidecomment = false;
		com_ignoreinlinecomment = true;
	}

	com_ignoreinlinecomment = false;

	return current;
}

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

	// Check header list
	int idx = m_Headers.Find( filename );
	if ( idx != m_Headers.InvalidIndex() )
	{
		vprint( 0, "%s included twice in module %s\n", filename, rootmodule );
		return;
	}

	CODE_MODULE module;
	module.skipped = false;

	m_Headers.Insert( filename, module );
}

bool CCodeProcessor::CheckShouldSkip( bool forcequiet, int depth, char const *filename, int& numheaders, int& skippedfiles)
{
	int idx = m_Modules.Find( filename );
	if ( idx == m_Modules.InvalidIndex() )
		return false;

	CODE_MODULE *module = &m_Modules[ idx ];

	if ( forcequiet )
	{
		m_nHeadersProcessed++;
		numheaders++;

		if ( module->skipped )
		{
			skippedfiles++;
		}
	}

	AddHeader( depth, filename, m_szCurrentCPP );
	return true;
}

bool CCodeProcessor::LoadFile( char **buffer, char *filename, char const *module, bool forcequiet, 
	int depth, int& filelength, int& numheaders, int& skippedfiles,
	char const *srcroot, char const *root, char const *baseroot )
{
	for ( int i = 0; i < m_IncludePath.Count(); ++i )
	{
		// Load the base module
		sprintf( filename, "%s\\%s", m_IncludePath[i], module );
		strlwr( filename );

		if ( CheckShouldSkip( forcequiet, depth, filename, numheaders, skippedfiles ) )
		{
			return false;
		}

		*buffer = (char *)COM_LoadFile( filename, &filelength );
		if ( *buffer )
			return true;
	}

	return false;
}

static bool SkipFile( char const *module )
{
	if ( !stricmp( module, "predictable_entity.h" ) )
		return true;
	if ( !stricmp( module, "baseentity_shared.h" ) )
		return true;
	if ( !stricmp( module, "baseplayer_shared.h" ) )
		return true;
	if ( !stricmp( module, "tf_tacticalmap.cpp" ) )
		return true;
	if ( !stricmp( module, "techtree.cpp" ) )
		return true;
	if ( !stricmp( module, "techtree_parse.cpp" ) )
		return true;

	return false;
}

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

	if ( depth > maxdepth )
	{
		maxdepth = depth;
	}
	int filelength;
	char *buffer = NULL;
		
	// Always skip these particular modules/headers
	if ( SkipFile( module ) )
	{
		CODE_MODULE module;
		module.skipped = true;

		m_Modules.Insert( filename, module );

		skippedfiles++;
		return;
	}

	if ( !LoadFile( &buffer, filename, module, forcequiet, depth, filelength, numheaders, skippedfiles,
		srcroot, root, baseroot ) )
	{
		CODE_MODULE module;
		module.skipped = true;
		m_Modules.Insert( filename, module );
		skippedfiles++;
		return;
	}

	Assert( buffer );

	m_nBytesProcessed += filelength;

	CODE_MODULE m;
	m.skipped = false;
	m_Modules.Insert( filename, m );

	if ( !forcequiet )
	{
		strcpy( m_szCurrentCPP, filename );
	}

	AddHeader( depth, filename, m_szCurrentCPP );

	bool onclient = !strnicmp( m_szBaseEntityClass, "C_", 2 ) ? true : false;

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

	current = CC_ParseToken( current );
	while ( 1 )
	{
		// No more tokens
		if ( !current )
			break;

		if ( !stricmp( com_token, "#include" ) )
		{
			current = CC_ParseToken( current );
			if ( strlen( com_token ) > 0 &&
				com_token[ 0 ] != '<' )
			{
				//vprint( "#include %s\n", com_token );
				m_nHeadersProcessed++;
				numheaders++;
				ProcessModule( true, depth + 1, maxdepth, numheaders, skippedfiles, srcroot, baseroot, root, com_token );
			}
		}
		else if ( !stricmp( com_token, "class" ) ||
			 !stricmp( com_token, "struct" ) )
		{
			current = CC_ParseToken( current );
			if ( strlen( com_token ) > 0 )
			{
				//vprint( depth, "class %s\n", com_token );

				CClass *cl = AddClass( com_token );

				// Now see if there's a base class
				current = CC_ParseToken( current );
				if ( !stricmp( com_token, ":" ) )
				{
					// Parse out public and then classname an
					current = CC_ParseToken( current );
					if ( !stricmp( com_token, "public" ) )
					{
						current = CC_ParseToken( current );
						if ( strlen( com_token ) > 0 )
						{
							cl->SetBaseClass( com_token );

							do
							{
								current = CC_ParseToken( current );
							} while ( strlen( com_token ) && stricmp( com_token, "{" ) );

							if ( !stricmp( com_token, "{" ) )
							{
								current = cl->ParseClassDeclaration( current );
							}
						}
					}
				}
				else if ( !stricmp( com_token, "{" ) )
				{
					current = cl->ParseClassDeclaration( current );
				}
			}
		}
		else if ( !strnicmp( com_token, "PREDICTABLE_CLASS", strlen( "PREDICTABLE_CLASS" ) ) )
		{
			char prefix[ 32 ];
			prefix[ 0 ] = 0;
			int type = 0;
			int bases = 1;
			int usebase = 0;

			if ( !stricmp( com_token, "PREDICTABLE_CLASS_ALIASED" ) )
			{
				type = 2;
				bases = 2;
				if ( onclient )
				{
					strcpy( prefix, "C_" );
				}
				else
				{
					strcpy( prefix, "C" );
					usebase = 1;
				}
			}
			else if ( !stricmp( com_token, "PREDICTABLE_CLASS_SHARED" ) )
			{
				type = 1;
				bases = 1;
			}
			else if ( !stricmp( com_token, "PREDICTABLE_CLASS" ) )
			{
				type = 0;
				bases = 1;
				if ( onclient )
				{
					strcpy( prefix, "C_" );
				}
				else
				{
					strcpy( prefix, "C" );
				}
			}
			else if ( !stricmp( com_token, "PREDICTABLE_CLASS_ALIASED_PREFIXED" ) )
			{
				// Nothing
			}
			else
			{
				vprint( 0, "PREDICTABLE_CLASS of unknown type!!! %s\n", com_token );
			}

			// parse the (
			current = CC_ParseToken( current );
			if ( !strcmp( com_token, "(" ) )
			{
				// Now the classname
				current = CC_ParseToken( current );
				if ( strlen( com_token ) > 0 )
				{
					//vprint( depth, "class %s\n", com_token );

					CClass *cl = AddClass( com_token );

					// Now see if there's a base class
					current = CC_ParseToken( current );
					if ( !stricmp( com_token, "," ) )
					{
						// Parse out public and then classname an
						current = CC_ParseToken( current );
						if ( strlen( com_token ) > 0 )
						{
							char basename[ 256 ];
							sprintf( basename, "%s%s", prefix, com_token );

							bool valid = true;

							if ( bases == 2 )
							{
								valid = false;

								current = CC_ParseToken( current );
								if ( !stricmp( com_token, "," ) )
								{
									current = CC_ParseToken( current );
									if ( strlen( com_token ) > 0 )
									{
										valid = true;
										if ( usebase == 1 )
										{
											sprintf( basename, "%s%s", prefix, com_token );
										}
									}
								}
							}

							if ( valid )
							{
								cl->SetBaseClass( basename );
								strcpy( cl->m_szTypedefBaseClass, basename );
							}
							
							do
							{
								current = CC_ParseToken( current );
							} while ( strlen( com_token ) && stricmp( com_token, ")" ) );

							if ( !stricmp( com_token, ")" ) )
							{
								current = cl->ParseClassDeclaration( current );
							}
						}
					}
					else if ( !stricmp( com_token, ")" ) )
					{
						current = cl->ParseClassDeclaration( current );
					}
				}
			}
		}
		else if ( !strcmp( com_token, "TYPEDESCRIPTION" ) || 
			    !strcmp( com_token, "typedescription_t" ) )
		{
			current = ParseTypeDescription( current, false );
		}
		else if ( !strcmp( com_token, "BEGIN_DATADESC" ) ||
				  !strcmp( com_token, "BEGIN_DATADESC_NO_BASE" ) ||
				  !strcmp( com_token, "BEGIN_SIMPLE_DATADESC" ) ||
				  !strcmp( com_token, "BEGIN_BYTESWAP_DATADESC" ) )
		{
			current = ParseTypeDescription( current, true );
		}
		else if ( !strcmp( com_token, "BEGIN_PREDICTION_DATA" ) ||
			!strcmp( com_token, "BEGIN_EMBEDDED_PREDDESC" ) )
		{
			current = ParsePredictionTypeDescription( current );
		}
		else if (	!strcmp( com_token, "BEGIN_RECV_TABLE" ) ||
					!strcmp( com_token, "BEGIN_RECV_TABLE_NOBASE" ) ||
					!strcmp( com_token, "IMPLEMENT_CLIENTCLASS_DT" ) ||
					!strcmp( com_token, "IMPLEMENT_CLIENTCLASS_DT_NOBASE" ) )
		{
			current = ParseReceiveTable( current );
		}
		else if ( !strcmp( com_token, "IMPLEMENT_PREDICTABLE_NODATA" ) )
		{
			current = CC_ParseToken( current );
			if ( !strcmp( com_token, "(" ) )
			{
				current = CC_ParseToken( current );

				CClass *cl = FindClass( com_token );
				if ( cl )
				{
					if ( cl->m_bHasPredictionData )
					{
						if ( !forcequiet )
						{
							vprint( 0, "Class %s declared predictable and implemented with IMPLEMENT_PREDICTABLE_NODATA in typedescription\n",
								cl->m_szName );
						}

						cl->m_bHasPredictionData = false;
					}
				}

				current = CC_ParseToken( current );
			}
		}

		current = CC_ParseToken( current );
	}

	COM_FreeFile( (unsigned char *)buffer );

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

	m_nLinesOfCode += linesprocessed;
	linesprocessed = 0;
}

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

	// Reset header list per module
	m_Headers.RemoveAll();

	int numheaders = 0;
	int maxdepth = 0;
	int skippedfiles = 0;
	ProcessModule( false, 0, maxdepth, numheaders, skippedfiles, srcroot, root, root, rootmodule );
}

void ReportMissingTypes();

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

	ResolveBaseClasses( baseentityclass );
	PrintClassList();
	PrintMissingTDFields();
	ReportMissingTypes();
	ReportHungarianNotationErrors();

	vprint( 0, "%i total classes parsed from %i files ( %i headers parsed )\n",
		m_nClassesParsed,
		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 ) );
	}

	Clear();
}

CCodeProcessor::CCodeProcessor( void )
{
	m_pClassList					= NULL;
	
	m_Modules.RemoveAll();

	m_bQuiet						= false;
	m_bPrintHierarchy				= false;
	m_bPrintMembers					= true;
	m_bPrintTypedescriptionErrors	= true;
	m_bPrintPredictionDescErrors	= true;
	m_bCreateMissingTDs				= false;
	m_bLogToFile					= false;
	m_bCheckHungarian				= false;

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

	m_szCurrentCPP[ 0 ]				= 0;
	m_szBaseEntityClass[ 0 ]		= 0;
}

CCodeProcessor::~CCodeProcessor( void )
{
}

void CCodeProcessor::ConstructModuleList_R( int level, const char *baseentityclass, 
	const char *gamespecific, const char *root, const char *srcroot )
{
	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 && !strstr( wfd.cFileName, gamespecific ) )
				continue;

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

void CCodeProcessor::CleanupIncludePath()
{
	for ( int i = m_IncludePath.Count(); --i >= 0; )
	{
		delete [] m_IncludePath[i];
	}
	m_IncludePath.RemoveAll();
}

void CCodeProcessor::AddIncludePath( const char *pPath )
{
	int i = m_IncludePath.AddToTail();
	int nLen = strlen(pPath) + 1;
	m_IncludePath[i] = new char[nLen];
	memcpy( m_IncludePath[i], pPath, nLen );
}

void CCodeProcessor::SetupIncludePath( const char *sourcetreebase, const char *subdir, const char *gamespecific )
{
	CleanupIncludePath();

	char path[MAX_PATH];
	sprintf( path, "%s\\%s", sourcetreebase, subdir );
	strlwr( path );
	AddIncludePath( path );

	char modsubdir[128];
	if ( !stricmp(subdir, "dlls") )
	{
		sprintf(modsubdir,"%s\\%s_dll", subdir, gamespecific );
	}
	else if ( !stricmp(subdir, "cl_dll") )
	{
		sprintf(modsubdir,"%s\\%s_hud", subdir, gamespecific );
	}
	else
	{
		sprintf(modsubdir,"%s\\%s", subdir, gamespecific );
	}

	sprintf( path, "%s\\%s", sourcetreebase, modsubdir );
	strlwr( path );
	AddIncludePath( path );

	// Game shared
	sprintf( path, "%s\\game_shared", sourcetreebase );
	strlwr( path );
	AddIncludePath( path );

	sprintf( path, "%s\\game_shared\\%s", sourcetreebase, gamespecific );
	strlwr( path );
	AddIncludePath( path );

	sprintf( path, "%s\\public", sourcetreebase );
	strlwr( path );
	AddIncludePath( path );
}


void CCodeProcessor::Process( const char *baseentityclass, const char *gamespecific, const char *sourcetreebase, const char *subdir )
{
	SetupIncludePath( sourcetreebase, subdir, gamespecific );

	strcpy( m_szBaseEntityClass, baseentityclass );

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

	linesprocessed		= 0;

	m_Modules.RemoveAll();
	m_Headers.RemoveAll();

	m_flStart = UTIL_FloatTime();

	char rootdirectory[ 256 ];
	sprintf( rootdirectory, "%s\\%s", sourcetreebase, subdir );

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

	m_nOffset = strlen( rootdirectory ) + 1;

	ConstructModuleList_R( 0, baseentityclass, gamespecific, rootdirectory, sourcetreebase );

	sprintf( rootdirectory, "%s\\%s", sourcetreebase, "game_shared" );

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

	m_nOffset = strlen( rootdirectory ) + 1;
	
	ConstructModuleList_R( 0, baseentityclass, gamespecific, rootdirectory, sourcetreebase );

	m_flEnd = UTIL_FloatTime();

	PrintResults( baseentityclass );
}

void CCodeProcessor::Process( const char *baseentityclass, const char *gamespecific, 
	const char *sourcetreebase, const char *subdir, const char *pFileName )
{
	SetupIncludePath( sourcetreebase, subdir, gamespecific );

	strcpy( m_szBaseEntityClass, baseentityclass );

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

	linesprocessed		= 0;

	m_Modules.RemoveAll();
	m_Headers.RemoveAll();

	m_flStart = UTIL_FloatTime();

	char rootdirectory[ 256 ];
	sprintf( rootdirectory, "%s\\%s", sourcetreebase, subdir );

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

	m_nOffset = strlen( rootdirectory ) + 1;

	ProcessModules( sourcetreebase, rootdirectory, pFileName );

	m_flEnd = UTIL_FloatTime();

	PrintResults( baseentityclass );
}

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

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

void CCodeProcessor::SetPrintHierarchy( bool print )
{
	m_bPrintHierarchy = print;
}

bool CCodeProcessor::GetPrintHierarchy( void ) const
{
	return m_bPrintHierarchy;
}

void CCodeProcessor::SetPrintMembers( bool print )
{
	m_bPrintMembers = print;
}

bool CCodeProcessor::GetPrintMembers( void ) const
{
	return m_bPrintMembers;
}

void CCodeProcessor::SetPrintTDs( bool print )
{
	m_bPrintTypedescriptionErrors = print;
}

bool CCodeProcessor::GetPrintTDs( void ) const
{
	return m_bPrintTypedescriptionErrors;
}

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

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

void CCodeProcessor::SetPrintPredTDs( bool print )
{
	m_bPrintPredictionDescErrors = print;
}

bool CCodeProcessor::GetPrintPredTDs( void ) const
{
	return m_bPrintPredictionDescErrors;
}

void CCodeProcessor::SetPrintCreateMissingTDs( bool print )
{
	m_bCreateMissingTDs = print;
}

bool CCodeProcessor::GetPrintCreateMissingTDs( void ) const
{
	return m_bCreateMissingTDs;
}

void CCodeProcessor::SetPrintCreateMissingPredTDs( bool print )
{
	m_bCreateMissingPredTDs = print;
}

bool CCodeProcessor::GetPrintCreateMissingPredTDs( void ) const
{
	return m_bCreateMissingPredTDs;
}

void CCodeProcessor::SetCheckHungarian( bool check )
{
	m_bCheckHungarian = check;
}

bool CCodeProcessor::GetCheckHungarian() const
{
	return m_bCheckHungarian;
}

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