gecko-dev/tools/dreftool/main.cpp
1999-08-04 19:44:15 +00:00

629 lines
18 KiB
C++

#include <iostream.h>
#include <fstream.h>
#include "nsString.h"
#include "IDirectory.h"
#include "CScanner.h"
#include "CCPPTokenizer.h"
#include "tokens.h"
#include "CToken.h"
#include <direct.h>
//*******************************************************************************
// Global variables...
//*******************************************************************************
bool gVerbose=false;
bool gShowIncludeErrors=false;
bool gEmitHTML=false;
char gRootDir[1024];
class IPattern {
public:
virtual CToken* scan(CCPPTokenizer& aTokenizer,int anIndex,ostream& anOutput)=0;
};
class CPattern {
public:
CPattern(const nsCString& aFilename) : mNames(0), mFilename(aFilename), mSafeNames(0) {
mIndex=0;
mLineNumber=1;
mErrCount=0;
}
CToken* matchID(nsDeque& aDeque,nsCString& aName){
int theMax=aDeque.GetSize();
for(int theIndex=0;theIndex<theMax;theIndex++){
CToken* theToken=(CToken*)aDeque.ObjectAt(theIndex);
if(theToken){
nsCString& theName=theToken->getStringValue();
if(theName==aName) {
return theToken;
}
}
}
return 0;
}
/***************************************************************************
This gets called when we know we've seen an if statement (at anIndex).
Look into the parm list (...) for an ID. If you find one, then you know
it's a conditioned identifier which can be safely ignored during other
error tests.
***************************************************************************/
CToken* findSafeIDInIfStatement(CCPPTokenizer& aTokenizer,nsDeque& aNameDeque) {
CToken* result=0;
enum eState {eSkipLparen,eFindID};
eState theState=eSkipLparen;
CToken* theToken=0;
while(theToken=aTokenizer.getTokenAt(++mIndex)) {
int theType=theToken->getTokenType();
nsCString& theString=theToken->getStringValue();
PRUnichar theChar=theString[0];
switch(theState) {
case eSkipLparen:
//first scan for the lparen...
switch(theType) {
case eToken_comment:
case eToken_whitespace:
case eToken_newline:
mLineNumber+=theString.CountChar('\n'); break;
case eToken_operator:
switch(theChar) {
case '(': theState=eFindID; break;
case ')': return 0; break;
default:
break;
} //switch
break;
default:
break;
} //switch
break;
//now scan for the identifier...
case eFindID:
switch(theType) {
case eToken_comment:
case eToken_whitespace:
case eToken_newline:
mLineNumber+=theString.CountChar('\n'); break;
case eToken_identifier:
if(matchID(mNames,theString)) {
return theToken;
}
break;
case eToken_operator:
switch(theChar) {
case ')':
case ';':
case '{':
case '(':
return result;
break;
default:
break;
} //switch
break;
default:
break;
} //switch
break;
default:
switch(theType) {
case eToken_comment:
case eToken_whitespace:
case eToken_newline:
mLineNumber+=theString.CountChar('\n');
break;
default:
break;
}//switch
break;
} //switch
}
return result;
}
/***************************************************************************
We're looking for the pattern foo-> without the preceeding (conditional) if():
Assume that the given id (aName) exists in the tokenizer at anIndex.
if(foo)
foo->
***************************************************************************/
CToken* findPtrDecl(CCPPTokenizer& aTokenizer,int anIndex,PRUnichar& anOpChar,bool allocRequired) {
enum eState {eFindNew,eFindType,eFindPunct,eFindStar};
CToken* theToken=0;
CToken* theID=0;
eState theState=eFindStar;
while(theToken=aTokenizer.getTokenAt(++anIndex)){
if(theToken) {
nsCString& theString=theToken->getStringValue();
int theType=theToken->getTokenType();
anOpChar=theString[0];
switch(theType){
case eToken_semicolon:
case eToken_operator:
switch(theState) {
case eFindStar:
if('*'==anOpChar)
theState=eFindType;
else return 0;
break;
case eFindPunct:
switch(anOpChar) {
case '=':
if(!allocRequired)
return theID;
else theState=eFindNew;
break;
case ';':
return (allocRequired) ? 0 : theID;
break;
default:
break;
}
break;
default:
return 0;
}
break;
case eToken_identifier:
switch(theState){
case eFindType:
theID=theToken;
theState=eFindPunct;
break;
case eFindNew:
if(theString.Equals("new") || theString.Equals("PR_Malloc"))
return theID;
else return 0;
break;
default:
return 0;
}
break;
default:
break;
}
}//if
}//while
return 0;
}
/***************************************************************************
We're looking for the pattern *foo.
***************************************************************************/
bool hasSimpleDeref(nsCString& aName,CCPPTokenizer& aTokenizer,int anIndex) {
bool result=false;
int theMin=anIndex-3;
for(int theIndex=anIndex-1;theIndex>theMin;theIndex--){
CToken* theToken=aTokenizer.getTokenAt(theIndex);
if(theToken) {
nsCString& theString=theToken->getStringValue();
int theType=theToken->getTokenType();
PRUnichar theChar=theString[0];
if(eToken_operator==theType) {
if('*'==theChar){
result=true;
}
}
}
}
if(result) {
int theMax=anIndex+3;
for(int theIndex=anIndex;theIndex<theMax;theIndex++){
CToken* theToken=aTokenizer.getTokenAt(theIndex);
if(theToken) {
nsCString& theString=theToken->getStringValue();
int theType=theToken->getTokenType();
PRUnichar theChar=theString[0];
if(eToken_operator==theType) {
if((','==theChar) || (')'==theChar)){
result=false;
}
}
}
}
}
return result;
}
/***************************************************************************
We're looking for the pattern foo-> without the preceeding (conditional) if():
Assume that the given id (aName) exists in the tokenizer at anIndex.
if(foo)
foo->
***************************************************************************/
bool hasUnconditionedDeref(nsCString& aName,CCPPTokenizer& aTokenizer,int anIndex) {
bool result=false;
enum eState {eFailure,eFindIf,eFindDeref};
CToken* theToken=0;
eState theState=eFindDeref;
int theIndex=anIndex+1;
while(eFailure!=theState){
CToken* theToken=aTokenizer.getTokenAt(theIndex);
if(theToken) {
nsCString& theString=theToken->getStringValue();
int theType=theToken->getTokenType();
PRUnichar theChar=theString[0];
switch(theState){
case eFindDeref:
switch(theType) {
case eToken_whitespace:
case eToken_comment:
case eToken_newline:
theIndex++;
break;
default:
if(0==theString.Compare("->",true,2)) {
theIndex=anIndex-1; //now start looking backwards...
theState=eFindIf;
}
else theState=eFailure;
}//switch
break;
case eFindIf:
switch(theType) {
case eToken_whitespace:
case eToken_comment:
case eToken_newline:
theIndex--;
break;
case eToken_semicolon:
return true;
break;
case eToken_operator:
switch(theChar){
case '{':
case '+':
case '-':
case '=':
case '*':
case '%':
return true;
default:
break;
}
theIndex-=1;
break;
case eToken_identifier:
if(0==theString.Compare("if",true,2)){
return false;
}
else if(0==theString.Compare(aName)){
return false;
}
else if(0==theString.Compare("while",true,5)){
return false;
}
return true;
default:
theIndex--;
} //switch
break;
}//switch
}//if
else theState=eFailure;
}//while
return result;
}
void skipSemi(CCPPTokenizer& aTokenizer) {
CToken* theToken=0;
while(theToken=aTokenizer.getTokenAt(++mIndex)){
int theType=theToken->getTokenType();
nsCString& theString=theToken->getStringValue();
PRUnichar theChar=theString[0];
switch(theType){
case eToken_semicolon:
return;
case eToken_operator:
if(('}'==theChar) || (';'==theChar))
return;
break;
case eToken_newline:
case eToken_comment:
case eToken_whitespace:
mLineNumber+=theString.CountChar('\n');
default:
break;
} //switch
}//while
}
void OutputMozillaFilename(ostream& anOutput) {
PRInt32 pos=mFilename.Find("mozilla");
const char* buf=mFilename.GetBuffer();
if(-1<pos) {
buf+=pos+8;
if(gEmitHTML) {
anOutput << "<br><a href=\"" ;
anOutput << "http://lxr.mozilla.org/mozilla/source/";
anOutput << buf << "#" << mLineNumber;
cout << "\">";
}
cout << buf << ":" << mLineNumber;
if(gEmitHTML) {
cout << "</a>";
}
}
else {
anOutput << buf;
}
}
/***************************************************************************
This method iterates the tokens (in tokenizer) looking for statements.
The statements are then decoded to find pointer variables. If they get a
new call, then they're recorded in mNames. If they're in an IF(), then
they're recording in mSafeNames. We also look for simple dereferences.
When we find one, we look it up in mSafeNames. If it's not there, we have
a potential deref error.
***************************************************************************/
void scan(CCPPTokenizer& aTokenizer,ostream& anOutput){
int theMax=aTokenizer.getCount();
int theIDCount=mNames.GetSize();
int theSafeIDCount=mSafeNames.GetSize();
CToken* theMatch=0;
while(mIndex<theMax){
CToken* theToken=aTokenizer.getTokenAt(mIndex);
int theType=theToken->getTokenType();
nsCString& theString=theToken->getStringValue();
int theNLCount=theString.CountChar('\n');
switch(theType){
case eToken_operator:
{
PRUnichar theChar=theString[0];
switch(theChar){
case '{':
mIndex++;
scan(aTokenizer,anOutput);
break;
case '}':
//before returning, let's remove the new identifiers...
while(mNames.GetSize()>theIDCount){
CToken* theToken2=(CToken*)mNames.Pop();
}
while(mSafeNames.GetSize()>theSafeIDCount){
CToken* theToken2=(CToken*)mSafeNames.Pop();
}
return;
default:
break;
}
}
break;
case eToken_comment:
case eToken_newline:
case eToken_whitespace:
mLineNumber+=theString.CountChar('\n');
break;
//If it's an ID, then we're looking for 3 patterns:
// 1. ID* ID...;
// 2. *ID=ID;
// 3. ID->XXX;
case eToken_identifier:
{
PRUnichar theOpChar=0;
if(theToken=findPtrDecl(aTokenizer,mIndex,theOpChar,true)) {
//we found ID* ID; (or) ID* ID=...;
mNames.Push(theToken);
mIndex+=2;
skipSemi(aTokenizer);
}
else if(0==theString.Compare("if",true,2)) {
CToken* theSafeID=findSafeIDInIfStatement(aTokenizer,mNames);
if(theSafeID) {
mSafeNames.Push(theSafeID);
theSafeIDCount++;
}
}
else {
CToken* theMatch=matchID(mNames,theString);
if(theMatch){
if((hasUnconditionedDeref(theString,aTokenizer,mIndex)) ||
(hasSimpleDeref(theString,aTokenizer,mIndex))){
CToken* theSafeID=matchID(mSafeNames,theString);
if(theSafeID) {
nsCString& s1=theSafeID->getStringValue();
if(s1.Equals(theString))
break;
}
//dump the name out in LXR format
OutputMozillaFilename(anOutput);
nsCAutoString theCStr(theString);
anOutput << " Deref-error: \"" << (const char*)theCStr << "\"" << endl;
mErrCount++;
}
}
}
}
break;
default:
break;
}
mIndex++;
}
}
nsDeque mNames;
nsDeque mSafeNames;
int mIndex;
int mLineNumber;
int mErrCount;
nsCString mFilename;
};
void ScanFile(nsCString& aFilename,ostream& anOutput,int& aLineCount,int& anErrCount) {
nsCAutoString theCStr(aFilename);
fstream input((const char*)theCStr,ios::in);
CScanner theScanner(input);
CCPPTokenizer theTokenizer;
theTokenizer.tokenize(theScanner);
CPattern thePattern(aFilename);
thePattern.scan(theTokenizer,anOutput);
aLineCount+=thePattern.mLineNumber;
anErrCount+=thePattern.mErrCount;
}
void IterateFiles(IDirectory& aDirectory,ostream& anOutput,int& aFilecount,int& aLineCount,int& anErrCount) {
nsCAutoString thePath("");
aDirectory.getPath(thePath);
int theCount=aDirectory.getSize();
int theIndex=0;
for(theIndex=0;theIndex<theCount;theIndex++){
IDirEntry* theEntry=aDirectory.getEntryAt(theIndex);
nsCString& theName=theEntry->getName();
if(!dynamic_cast<IDirectory*>(theEntry)){
nsCAutoString theCopy;
theName.Right(theCopy,4);
if(0==theCopy.Compare(".cpp",true,3)) {
nsCAutoString path(thePath);
path.Append('/');
path.Append(theName);
aFilecount++;
ScanFile(path,anOutput,aLineCount,anErrCount);
}
} else {
//we've got a directory on our hands...
//let's go walk it...
nsCAutoString path(thePath);
path.Append("/");
path.Append(theName);
if(!theName.EqualsIgnoreCase("cvs")) {
IDirectory* theDirectory=IDirectory::openDirectory(path.GetBuffer(),"*.*");
if(theDirectory) {
IterateFiles(*theDirectory,anOutput,aFilecount,aLineCount,anErrCount);
IDirectory::closeDirectory(theDirectory);
}
}
}
}
}
void ConsumeArguments(int argc, char* argv[]) {
if(argc<2) {
cout << "Usage: dreftool -h -d sourcepath" << endl;
cout << "-D path to root of source tree" << endl;
cout << "-H emit as HTML" << endl;
exit(1);
}
for(int index=1;index<argc;index++){
switch(argv[index][0]) {
case '-':
case '/':
switch(toupper(argv[index][1])){
case 'D': //to specify starting directory
if(('-'!=argv[index+1][0]) && ('/'!=argv[index+1][0])) {
strcpy(gRootDir,argv[index+1]);
index++;
}
break;
case 'H': //user chose to show redundant include errors
gEmitHTML=true;
break;
default:
break;
}
break;
default:
break;
}
}
}
int main(int argc, char* argv[]){
getcwd(gRootDir,sizeof(gRootDir)-1);
ConsumeArguments(argc,argv);
int fileCount=0;
int lineCount=0;
int errCount=0;
#if 0
nsCAutoString temp("test3.cpp");
ScanFile(temp,cout,lineCount,errCount);
fileCount++;
#endif
#if 1
if(gEmitHTML) {
cout << "<html><body>" << endl;
}
cout << "Scanning " << gRootDir << "..." << endl;
IDirectory* theDirectory=IDirectory::openDirectory(gRootDir,"*.*");
if(theDirectory)
IterateFiles(*theDirectory,cout,fileCount,lineCount,errCount);
#endif
if(gEmitHTML) {
cout << "<PRE>" <<endl;
}
cout << endl << endl << "Summary: " << endl;
cout << "===============================" << endl;
cout<< "Files: " << fileCount << endl;
cout<< "Lines: " << lineCount<< endl;
cout<< "Errors: " << errCount<< endl;
if(gEmitHTML) {
cout << "</PRE>" <<endl;
cout << "</body></html>" << endl;
}
return 0;
}