walkero
/
cppcheck
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Refactoring: Some global functions moved to Tokenizer class

This commit is contained in:
Reijo Tomperi 2008-11-20 20:54:52 +00:00
parent dd5abf2c05
commit 180e3b99e6
9 changed files with 153 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
CheckBufferOverrun.cpp
View File

@ -51,8 +51,8 @@ void CheckBufferOverrunClass::ReportError(const TOKEN *tok, const char errmsg[])
std::ostringstream ostr;
std::list<const TOKEN *>::const_iterator it;
for ( it = CallStack.begin(); it != CallStack.end(); it++ )
ostr << FileLine(*it, _tokenizer ) << " -> ";
ostr << FileLine(tok, _tokenizer) << ": " << errmsg;
ostr << _tokenizer->fileLine(*it ) << " -> ";
ostr << _tokenizer->fileLine(tok) << ": " << errmsg;
ReportErr(ostr.str());
}
//---------------------------------------------------------------------------
@ -401,7 +401,7 @@ void CheckBufferOverrunClass::CheckBufferOverrun_StructVariable()
if ( Match(tok, "class") )
{
std::string func_pattern(structname + std::string(" :: %var% ("));
const TOKEN *tok3 = findmatch(_tokenizer->tokens(), func_pattern.c_str());
const TOKEN *tok3 = Tokenizer::findmatch(_tokenizer->tokens(), func_pattern.c_str());
while ( tok3 )
{
for ( const TOKEN *tok4 = tok3; tok4; tok4 = tok4->next )
@ -416,7 +416,7 @@ void CheckBufferOverrunClass::CheckBufferOverrun_StructVariable()
break;
}
}
tok3 = findmatch(tok3->next, func_pattern.c_str());
tok3 = Tokenizer::findmatch(tok3->next, func_pattern.c_str());
}
}
@ -503,14 +503,14 @@ void CheckBufferOverrunClass::WarningDangerousFunctions()
if (Match(tok, "gets ("))
{
std::ostringstream ostr;
ostr << FileLine(tok, _tokenizer) << ": Found 'gets'. You should use 'fgets' instead";
ostr << _tokenizer->fileLine(tok) << ": Found 'gets'. You should use 'fgets' instead";
ReportErr(ostr.str());
}
else if (Match(tok, "scanf (") && strcmp(Tokenizer::getstr(tok,2),"\"%s\"") == 0)
{
std::ostringstream ostr;
ostr << FileLine(tok, _tokenizer) << ": Found 'scanf'. You should use 'fgets' instead";
ostr << _tokenizer->fileLine(tok) << ": Found 'scanf'. You should use 'fgets' instead";
ReportErr(ostr.str());
}
}

10
CheckClass.cpp
View File

@ -337,7 +337,7 @@ void CheckClass::CheckConstructors()
if ( varlist )
{
std::ostringstream ostr;
ostr << FileLine(tok1, _tokenizer);
ostr << _tokenizer->fileLine(tok1);
ostr << " The class '" << classname << "' has no constructor";
ReportErr(ostr.str());
}
@ -376,7 +376,7 @@ void CheckClass::CheckConstructors()
if (!var->init)
{
std::ostringstream ostr;
ostr << FileLine(constructor_token, _tokenizer);
ostr << _tokenizer->fileLine(constructor_token);
ostr << " Uninitialized member variable '" << classname << "::" << var->name << "'";
ReportErr(ostr.str());
}
@ -575,7 +575,7 @@ void CheckClass::CheckMemset()
if (Tokenizer::findtoken(_tokenizer->tokens(),pattern1))
{
std::ostringstream ostr;
ostr << FileLine(tok, _tokenizer) << ": Using '" << tok->str << "' on class.";
ostr << _tokenizer->fileLine(tok) << ": Using '" << tok->str << "' on class.";
ReportErr(ostr.str());
continue;
}
@ -591,7 +591,7 @@ void CheckClass::CheckMemset()
if (Match(tstruct, "std :: %type% %var% ;"))
{
std::ostringstream ostr;
ostr << FileLine(tok, _tokenizer) << ": Using '" << tok->str << "' on struct that contains a 'std::" << Tokenizer::getstr(tstruct,2) << "'";
ostr << _tokenizer->fileLine(tok) << ": Using '" << tok->str << "' on struct that contains a 'std::" << Tokenizer::getstr(tstruct,2) << "'";
ReportErr(ostr.str());
break;
}
@ -612,7 +612,7 @@ void CheckClass::CheckOperatorEq1()
if (const TOKEN *tok = Tokenizer::findtoken(_tokenizer->tokens(),pattern))
{
std::ostringstream ostr;
ostr << FileLine(tok, _tokenizer) << ": 'operator=' should return something";
ostr << _tokenizer->fileLine(tok) << ": 'operator=' should return something";
ReportErr(ostr.str());
}
}

4
CheckHeaders.cpp
View File

@ -56,7 +56,7 @@ void CheckHeaders::WarningHeaderWithImplementation()
if (Match(tok, ") {"))
{
std::ostringstream ostr;
ostr << FileLine(tok, _tokenizer) << ": Found implementation in header";
ostr << _tokenizer->fileLine(tok) << ": Found implementation in header";
ReportErr(ostr.str());
// Goto next file..
@ -242,7 +242,7 @@ void CheckHeaders::WarningIncludeHeader()
if (!Needed)
{
std::ostringstream ostr;
ostr << FileLine(includetok, _tokenizer) << ": The included header '" << includefile << "' is not needed";
ostr << _tokenizer->fileLine(includetok) << ": The included header '" << includefile << "' is not needed";
if (NeedDeclaration)
ostr << " (but a forward declaration is needed)";
ReportErr(ostr.str());

70
CheckMemoryLeak.cpp
View File

@ -64,7 +64,7 @@ bool CheckMemoryLeakClass::isclass( const std::string &typestr )
std::ostringstream pattern;
pattern << "struct " << typestr;
if ( findmatch( _tokenizer->tokens(), pattern.str().c_str() ) )
if ( Tokenizer::findmatch( _tokenizer->tokens(), pattern.str().c_str() ) )
return false;
return true;
@ -208,7 +208,7 @@ const char * CheckMemoryLeakClass::call_func( const TOKEN *tok, std::list<const
if ( Match(tok, "[,()] %var1% [,()]", varnames) )
{
const TOKEN *ftok = _tokenizer->GetFunctionTokenByName(funcname);
const char *parname = GetParameterName( ftok, par );
const char *parname = Tokenizer::getParameterName( ftok, par );
if ( ! parname )
return "use";
// Check if the function deallocates the variable..
@ -217,13 +217,13 @@ const char * CheckMemoryLeakClass::call_func( const TOKEN *tok, std::list<const
TOKEN *func = getcode( Tokenizer::gettok(ftok,1), callstack, parname, alloctype, dealloctype );
simplifycode( func );
const char *ret = 0;
if (findmatch(func, "goto"))
if (Tokenizer::findmatch(func, "goto"))
ret = 0; // TODO : "goto" isn't handled well
else if (findmatch(func, "use"))
else if (Tokenizer::findmatch(func, "use"))
ret = "use";
else if (findmatch(func, "dealloc"))
else if (Tokenizer::findmatch(func, "dealloc"))
ret = "dealloc";
deleteTokens(func);
Tokenizer::deleteTokens(func);
return ret;
}
}
@ -237,8 +237,8 @@ void CheckMemoryLeakClass::MismatchError( const TOKEN *Tok1, const std::list<con
{
std::ostringstream errmsg;
for ( std::list<const TOKEN *>::const_iterator tok = callstack.begin(); tok != callstack.end(); ++tok )
errmsg << FileLine(*tok, _tokenizer) << " -> ";
errmsg << FileLine(Tok1, _tokenizer) << ": Mismatching allocation and deallocation: " << varname;
errmsg << _tokenizer->fileLine(*tok) << " -> ";
errmsg << _tokenizer->fileLine(Tok1) << ": Mismatching allocation and deallocation: " << varname;
ReportErr( errmsg.str() );
}
//---------------------------------------------------------------------------
@ -246,7 +246,7 @@ void CheckMemoryLeakClass::MismatchError( const TOKEN *Tok1, const std::list<con
void CheckMemoryLeakClass::MemoryLeak( const TOKEN *tok, const char varname[] )
{
std::ostringstream errmsg;
errmsg << FileLine(tok, _tokenizer) << ": Memory leak: " << varname;
errmsg << _tokenizer->fileLine(tok) << ": Memory leak: " << varname;
ReportErr( errmsg.str() );
}
//---------------------------------------------------------------------------
@ -778,69 +778,69 @@ void CheckMemoryLeakClass::CheckMemoryLeak_CheckScope( const TOKEN *Tok1, const
TOKEN *tok = getcode( Tok1, callstack, varname, alloctype, dealloctype );
// If the variable is not allocated at all => no memory leak
if (findmatch(tok, "alloc") == 0)
if (Tokenizer::findmatch(tok, "alloc") == 0)
{
deleteTokens(tok);
Tokenizer::deleteTokens(tok);
return;
}
// TODO : handle "goto"
if (findmatch(tok, "goto"))
if (Tokenizer::findmatch(tok, "goto"))
{
deleteTokens(tok);
Tokenizer::deleteTokens(tok);
return;
}
simplifycode( tok );
if ( findmatch(tok, "loop alloc ;") )
if ( Tokenizer::findmatch(tok, "loop alloc ;") )
{
MemoryLeak(findmatch(tok, "loop alloc ;"), varname);
MemoryLeak(Tokenizer::findmatch(tok, "loop alloc ;"), varname);
}
else if ( findmatch(tok, "alloc ; if continue ;") )
else if ( Tokenizer::findmatch(tok, "alloc ; if continue ;") )
{
MemoryLeak(Tokenizer::gettok(findmatch(tok, "alloc ; if continue ;"), 3), varname);
MemoryLeak(Tokenizer::gettok(Tokenizer::findmatch(tok, "alloc ; if continue ;"), 3), varname);
}
else if ( findmatch(tok, "alloc ; if break ;") )
else if ( Tokenizer::findmatch(tok, "alloc ; if break ;") )
{
MemoryLeak(Tokenizer::gettok(findmatch(tok, "alloc ; if break ;"), 3), varname);
MemoryLeak(Tokenizer::gettok(Tokenizer::findmatch(tok, "alloc ; if break ;"), 3), varname);
}
else if ( findmatch(tok, "alloc ; if return ;") )
else if ( Tokenizer::findmatch(tok, "alloc ; if return ;") )
{
MemoryLeak(Tokenizer::gettok(findmatch(tok, "alloc ; if return ;"), 3), varname);
MemoryLeak(Tokenizer::gettok(Tokenizer::findmatch(tok, "alloc ; if return ;"), 3), varname);
}
else if ( _settings._showAll && findmatch(tok, "alloc ; ifv continue ;") )
else if ( _settings._showAll && Tokenizer::findmatch(tok, "alloc ; ifv continue ;") )
{
MemoryLeak(Tokenizer::gettok(findmatch(tok, "alloc ; ifv continue ;"), 3), varname);
MemoryLeak(Tokenizer::gettok(Tokenizer::findmatch(tok, "alloc ; ifv continue ;"), 3), varname);
}
else if ( _settings._showAll && findmatch(tok, "alloc ; ifv break ;") )
else if ( _settings._showAll && Tokenizer::findmatch(tok, "alloc ; ifv break ;") )
{
MemoryLeak(Tokenizer::gettok(findmatch(tok, "alloc ; ifv break ;"), 3), varname);
MemoryLeak(Tokenizer::gettok(Tokenizer::findmatch(tok, "alloc ; ifv break ;"), 3), varname);
}
else if ( _settings._showAll && findmatch(tok, "alloc ; ifv return ;") )
else if ( _settings._showAll && Tokenizer::findmatch(tok, "alloc ; ifv return ;") )
{
MemoryLeak(Tokenizer::gettok(findmatch(tok, "alloc ; ifv return ;"), 3), varname);
MemoryLeak(Tokenizer::gettok(Tokenizer::findmatch(tok, "alloc ; ifv return ;"), 3), varname);
}
else if ( findmatch(tok, "alloc ; return ;") )
else if ( Tokenizer::findmatch(tok, "alloc ; return ;") )
{
MemoryLeak(Tokenizer::gettok(findmatch(tok,"alloc ; return ;"),2), varname);
MemoryLeak(Tokenizer::gettok(Tokenizer::findmatch(tok,"alloc ; return ;"),2), varname);
}
else if ( findmatch(tok, "alloc ; alloc") )
else if ( Tokenizer::findmatch(tok, "alloc ; alloc") )
{
MemoryLeak(Tokenizer::gettok(findmatch(tok,"alloc ; alloc"),2), varname);
MemoryLeak(Tokenizer::gettok(Tokenizer::findmatch(tok,"alloc ; alloc"),2), varname);
}
else if ( ! findmatch(tok,"dealloc") &&
! findmatch(tok,"use") &&
! findmatch(tok,"return use ;") )
else if ( ! Tokenizer::findmatch(tok,"dealloc") &&
! Tokenizer::findmatch(tok,"use") &&
! Tokenizer::findmatch(tok,"return use ;") )
{
const TOKEN *last = tok;
while (last->next)
@ -848,7 +848,7 @@ void CheckMemoryLeakClass::CheckMemoryLeak_CheckScope( const TOKEN *Tok1, const
MemoryLeak(last, varname);
}
deleteTokens(tok);
Tokenizer::deleteTokens(tok);
}
//---------------------------------------------------------------------------

44
CheckOther.cpp
View File

@ -60,7 +60,7 @@ void CheckOther::WarningOldStylePointerCast()
continue;
std::ostringstream ostr;
ostr << FileLine(tok, _tokenizer) << ": C-style pointer casting";
ostr << _tokenizer->fileLine(tok) << ": C-style pointer casting";
ReportErr(ostr.str());
}
}
@ -84,7 +84,7 @@ void CheckOther::WarningIsDigit()
if (err)
{
std::ostringstream ostr;
ostr << FileLine(tok, _tokenizer) << ": The condition can be simplified; use 'isdigit'";
ostr << _tokenizer->fileLine(tok) << ": The condition can be simplified; use 'isdigit'";
ReportErr(ostr.str());
}
}
@ -113,7 +113,7 @@ void CheckOther::WarningIsAlpha()
if (err)
{
std::ostringstream ostr;
ostr << FileLine(tok, _tokenizer) << ": The condition can be simplified; use 'isupper'";
ostr << _tokenizer->fileLine(tok) << ": The condition can be simplified; use 'isupper'";
ReportErr(ostr.str());
continue;
}
@ -126,7 +126,7 @@ void CheckOther::WarningIsAlpha()
if (err)
{
std::ostringstream ostr;
ostr << FileLine(tok, _tokenizer) << ": The condition can be simplified; use 'islower'";
ostr << _tokenizer->fileLine(tok) << ": The condition can be simplified; use 'islower'";
ReportErr(ostr.str());
continue;
}
@ -143,7 +143,7 @@ void CheckOther::WarningIsAlpha()
if (err)
{
std::ostringstream ostr;
ostr << FileLine(tok, _tokenizer) << ": The condition can be simplified; use 'isalpha'";
ostr << _tokenizer->fileLine(tok) << ": The condition can be simplified; use 'isalpha'";
ReportErr(ostr.str());
}
}
@ -197,7 +197,7 @@ void CheckOther::WarningRedundantCode()
if (err)
{
std::ostringstream ostr;
ostr << FileLine(tok, _tokenizer) << ": Redundant condition. It is safe to deallocate a NULL pointer";
ostr << _tokenizer->fileLine(tok) << ": Redundant condition. It is safe to deallocate a NULL pointer";
ReportErr(ostr.str());
}
}
@ -239,7 +239,7 @@ void CheckOther::WarningIf()
strcmp(Tokenizer::getstr(tok2,2), "else") != 0)
{
std::ostringstream ostr;
ostr << FileLine(tok, _tokenizer) << ": Found \"if (condition);\"";
ostr << _tokenizer->fileLine(tok) << ": Found \"if (condition);\"";
ReportErr(ostr.str());
}
break;
@ -290,7 +290,7 @@ void CheckOther::WarningIf()
// we found the error. Report.
std::ostringstream ostr;
ostr << FileLine(Tokenizer::gettok(tok,4), _tokenizer) << ": The condition is always ";
ostr << _tokenizer->fileLine(Tokenizer::gettok(tok,4)) << ": The condition is always ";
for (int i = 0; i < 6; i++)
{
if (strcmp(cond, p[i]) == 0)
@ -335,7 +335,7 @@ void CheckOther::InvalidFunctionUsage()
if (!(radix==0 || (radix>=2 && radix<=36)))
{
std::ostringstream ostr;
ostr << FileLine(tok2, _tokenizer) << ": Invalid radix in call to strtol or strtoul. Must be 0 or 2-36";
ostr << _tokenizer->fileLine(tok2) << ": Invalid radix in call to strtol or strtoul. Must be 0 or 2-36";
ReportErr(ostr.str());
}
}
@ -361,7 +361,7 @@ void CheckOther::CheckIfAssignment()
Match(tok, "if ( %var% = %var% )") )
{
std::ostringstream ostr;
ostr << FileLine(tok, _tokenizer) << ": Possible bug. Should it be '==' instead of '='?";
ostr << _tokenizer->fileLine(tok) << ": Possible bug. Should it be '==' instead of '='?";
ReportErr(ostr.str());
}
}
@ -400,7 +400,7 @@ void CheckOther::CheckUnsignedDivision()
{
// One of the operands are signed, the other is unsigned..
std::ostringstream ostr;
ostr << FileLine(tok->next, _tokenizer) << ": Warning: Division with signed and unsigned operators";
ostr << _tokenizer->fileLine(tok->next) << ": Warning: Division with signed and unsigned operators";
ReportErr(ostr.str());
}
}
@ -412,7 +412,7 @@ void CheckOther::CheckUnsignedDivision()
if ( sign1 == 'u' )
{
std::ostringstream ostr;
ostr << FileLine(tok->next, _tokenizer) << ": Unsigned division. The result will be wrong.";
ostr << _tokenizer->fileLine(tok->next) << ": Unsigned division. The result will be wrong.";
ReportErr(ostr.str());
}
}
@ -424,7 +424,7 @@ void CheckOther::CheckUnsignedDivision()
if ( sign2 == 'u' )
{
std::ostringstream ostr;
ostr << FileLine(tok->next, _tokenizer) << ": Unsigned division. The result will be wrong.";
ostr << _tokenizer->fileLine(tok->next) << ": Unsigned division. The result will be wrong.";
ReportErr(ostr.str());
}
}
@ -584,7 +584,7 @@ void CheckOther::CheckVariableScope_LookupVar( const TOKEN *tok1, const char var
// Warning if "used" is true
std::ostringstream errmsg;
errmsg << FileLine(tok1, _tokenizer) << " The scope of the variable '" << varname << "' can be limited";
errmsg << _tokenizer->fileLine(tok1) << " The scope of the variable '" << varname << "' can be limited";
ReportErr( errmsg.str() );
}
//---------------------------------------------------------------------------
@ -601,7 +601,7 @@ void CheckOther::CheckConstantFunctionParameter()
if ( Match(tok,"[,(] const std :: %type% %var% [,)]") )
{
std::ostringstream errmsg;
errmsg << FileLine(tok, _tokenizer) << " " << Tokenizer::getstr(tok,5) << " is passed by value, it could be passed by reference/pointer instead";
errmsg << _tokenizer->fileLine(tok) << " " << Tokenizer::getstr(tok,5) << " is passed by value, it could be passed by reference/pointer instead";
ReportErr( errmsg.str() );
}
@ -613,14 +613,14 @@ void CheckOther::CheckConstantFunctionParameter()
if ( Tokenizer::findtoken(_tokenizer->tokens(), pattern) )
{
std::ostringstream errmsg;
errmsg << FileLine(tok, _tokenizer) << " " << Tokenizer::getstr(tok,3) << " is passed by value, it could be passed by reference/pointer instead";
errmsg << _tokenizer->fileLine(tok) << " " << Tokenizer::getstr(tok,3) << " is passed by value, it could be passed by reference/pointer instead";
ReportErr( errmsg.str() );
}
pattern[0] = "struct";
if ( Tokenizer::findtoken(_tokenizer->tokens(), pattern) )
{
std::ostringstream errmsg;
errmsg << FileLine(tok, _tokenizer) << " " << Tokenizer::getstr(tok,3) << " is passed by value, it could be passed by reference/pointer instead";
errmsg << _tokenizer->fileLine(tok) << " " << Tokenizer::getstr(tok,3) << " is passed by value, it could be passed by reference/pointer instead";
ReportErr( errmsg.str() );
}
}
@ -681,7 +681,7 @@ void CheckOther::CheckStructMemberUsage()
if ( ! used )
{
std::ostringstream errmsg;
errmsg << FileLine(tok, _tokenizer) << ": struct member '" << structname << "::" << varname << "' is never read";
errmsg << _tokenizer->fileLine(tok) << ": struct member '" << structname << "::" << varname << "' is never read";
ReportErr(errmsg.str());
}
}
@ -723,7 +723,7 @@ void CheckOther::CheckCharVariable()
if (!Match(tok2,".") && Match(tok2->next, "%var% [ %var1% ]", varname))
{
std::ostringstream errmsg;
errmsg << FileLine(tok2->next, _tokenizer) << ": Warning - using char variable as array index";
errmsg << _tokenizer->fileLine(tok2->next) << ": Warning - using char variable as array index";
ReportErr(errmsg.str());
break;
}
@ -731,7 +731,7 @@ void CheckOther::CheckCharVariable()
if ( Match(tok2, "%var% [&|] %var1%", varname) || Match(tok2, "%var1% [&|]", varname) )
{
std::ostringstream errmsg;
errmsg << FileLine(tok2, _tokenizer) << ": Warning - using char variable in bit operation";
errmsg << _tokenizer->fileLine(tok2) << ": Warning - using char variable in bit operation";
ReportErr(errmsg.str());
break;
}
@ -767,14 +767,14 @@ void CheckOther::CheckIncompleteStatement()
if ( !Match(tok,"#") && Match(tok->next,"; %str%") && !Match(Tokenizer::gettok(tok,3), ",") )
{
std::ostringstream errmsg;
errmsg << FileLine(tok->next, _tokenizer) << ": Redundant code: Found a statement that begins with string constant";
errmsg << _tokenizer->fileLine(tok->next) << ": Redundant code: Found a statement that begins with string constant";
ReportErr(errmsg.str());
}
if ( !Match(tok,"#") && Match(tok->next,"; %num%") && !Match(Tokenizer::gettok(tok,3), ",") )
{
std::ostringstream errmsg;
errmsg << FileLine(tok->next, _tokenizer) << ": Redundant code: Found a statement that begins with numeric constant";
errmsg << _tokenizer->fileLine(tok->next) << ": Redundant code: Found a statement that begins with numeric constant";
ReportErr(errmsg.str());
}
}

60
CommonCheck.cpp
View File

@ -36,14 +36,7 @@ bool OnlyReportUniqueErrors;
std::ostringstream errout;
//---------------------------------------------------------------------------
std::string FileLine( const TOKEN *tok, Tokenizer *_tokenizer )
{
std::ostringstream ostr;
ostr << "[" << _tokenizer->getFiles()->at(tok->FileIndex) << ":" << tok->linenr << "]";
return ostr.str();
}
//---------------------------------------------------------------------------
bool SameFileName( const char fname1[], const char fname2[] )
@ -89,30 +82,17 @@ bool IsNumber(const char str[])
}
//---------------------------------------------------------------------------
bool IsStandardType(const char str[])
{
if (!str)
return false;
bool Ret = false;
const char *type[] = {"bool","char","short","int","long","float","double",0};
for (int i = 0; type[i]; i++)
Ret |= (strcmp(str,type[i])==0);
return Ret;
bool IsStandardType(const char str[])
{
if (!str)
return false;
bool Ret = false;
const char *type[] = {"bool","char","short","int","long","float","double",0};
for (int i = 0; type[i]; i++)
Ret |= (strcmp(str,type[i])==0);
return Ret;
}
//---------------------------------------------------------------------------
const char *GetParameterName( const TOKEN *ftok, int par )
{
int _par = 1;
for ( ; ftok; ftok = ftok->next)
{
if ( Match(ftok, ",") )
++_par;
if ( par==_par && Match(ftok, "%var% [,)]") )
return ftok->str;
}
return NULL;
}
//--------------------------------------------------------------------------
bool Match(const TOKEN *tok, const char pattern[], const char *varname1[], const char *varname2[])
@ -207,28 +187,8 @@ bool Match(const TOKEN *tok, const char pattern[], const char *varname1[], const
// The end of the pattern has been reached and nothing wrong has been found
return true;
}
//---------------------------------------------------------------------------
const TOKEN *findmatch(const TOKEN *tok, const char pattern[], const char *varname1[], const char *varname2[])
{
for ( ; tok; tok = tok->next)
{
if ( Match(tok, pattern, varname1, varname2) )
return tok;
}
return 0;
}
//---------------------------------------------------------------------------
void deleteTokens(TOKEN *tok)
{
while (tok)
{
TOKEN *next = tok->next;
delete tok;
tok = next;
}
}
//---------------------------------------------------------------------------

8
CommonCheck.h
View File

@ -30,9 +30,6 @@
#include "tokenize.h"
std::string FileLine(const TOKEN *tok, Tokenizer *_tokenizer);
// Are two filenames the same? Case insensitive on windows
bool SameFileName( const char fname1[], const char fname2[] );
@ -48,13 +45,12 @@ bool IsNumber(const char str[]);
bool IsStandardType(const char str[]);
const char *GetParameterName( const TOKEN *ftok, int par );
bool Match(const TOKEN *tok, const char pattern[], const char *varname1[]=0, const char *varname2[]=0);
const TOKEN *findmatch(const TOKEN *tok, const char pattern[], const char *varname1[]=0, const char *varname2[]=0);
void deleteTokens(TOKEN *tok);
//---------------------------------------------------------------------------
#endif

87
tokenize.cpp
View File

@ -1093,28 +1093,7 @@ const char *Tokenizer::getstr(const TOKEN *tok, int index)
// Deallocate lists..
void Tokenizer::DeallocateTokens()
{
while (_tokens)
{
TOKEN *next = _tokens->next;
delete _tokens;
_tokens = next;
}
tokens_back = _tokens;
while (dsymlist)
{
struct DefineSymbol *next = dsymlist->next;
free(dsymlist->name);
free(dsymlist->value);
delete dsymlist;
dsymlist = next;
}
Files.clear();
}
//---------------------------------------------------------------------------
@ -1333,3 +1312,69 @@ void Tokenizer::settings( const Settings &settings )
{
_settings = settings;
}
// Deallocate lists..
void Tokenizer::DeallocateTokens()
{
deleteTokens( _tokens );
_tokens = 0;
tokens_back = 0;
while (dsymlist)
{
struct DefineSymbol *next = dsymlist->next;
free(dsymlist->name);
free(dsymlist->value);
delete dsymlist;
dsymlist = next;
}
Files.clear();
}
void Tokenizer::deleteTokens(TOKEN *tok)
{
while (tok)
{
TOKEN *next = tok->next;
delete tok;
tok = next;
}
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
const char *Tokenizer::getParameterName( const TOKEN *ftok, int par )
{
int _par = 1;
for ( ; ftok; ftok = ftok->next)
{
if ( Match(ftok, ",") )
++_par;
if ( par==_par && Match(ftok, "%var% [,)]") )
return ftok->str;
}
return NULL;
}
//---------------------------------------------------------------------------
const TOKEN *Tokenizer::findmatch(const TOKEN *tok, const char pattern[], const char *varname1[], const char *varname2[])
{
for ( ; tok; tok = tok->next)
{
if ( Match(tok, pattern, varname1, varname2) )
return tok;
}
return 0;
}
//---------------------------------------------------------------------------
std::string Tokenizer::fileLine( const TOKEN *tok )
{
std::ostringstream ostr;
ostr << "[" << Files.at(tok->FileIndex) << ":" << tok->linenr << "]";
return ostr.str();
}

5
tokenize.h
View File

@ -80,6 +80,11 @@ public:
static const TOKEN *findtoken(const TOKEN *tok1, const char *tokenstr[]);
static const TOKEN *gettok(const TOKEN *tok, int index);
static const char *getstr(const TOKEN *tok, int index);
static void deleteTokens(TOKEN *tok);
static const char *getParameterName( const TOKEN *ftok, int par );
static const TOKEN *findmatch(const TOKEN *tok, const char pattern[], const char *varname1[]=0, const char *varname2[]=0);
std::string fileLine( const TOKEN *tok );
// Return size.
int SizeOfType(const char type[]);