From 180e3b99e65caa5542496df6158f35e31e3271ff Mon Sep 17 00:00:00 2001 From: Reijo Tomperi Date: Thu, 20 Nov 2008 20:54:52 +0000 Subject: [PATCH] Refactoring: Some global functions moved to Tokenizer class --- CheckBufferOverrun.cpp | 12 +++--- CheckClass.cpp | 10 ++--- CheckHeaders.cpp | 4 +- CheckMemoryLeak.cpp | 70 ++++++++++++++++----------------- CheckOther.cpp | 44 ++++++++++----------- CommonCheck.cpp | 60 +++++------------------------ CommonCheck.h | 8 +--- tokenize.cpp | 87 ++++++++++++++++++++++++++++++++---------- tokenize.h | 5 +++ 9 files changed, 153 insertions(+), 147 deletions(-) diff --git a/CheckBufferOverrun.cpp b/CheckBufferOverrun.cpp index ebd8b0f02..ef8a7fc07 100644 --- a/CheckBufferOverrun.cpp +++ b/CheckBufferOverrun.cpp @@ -51,8 +51,8 @@ void CheckBufferOverrunClass::ReportError(const TOKEN *tok, const char errmsg[]) std::ostringstream ostr; std::list::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()); } } diff --git a/CheckClass.cpp b/CheckClass.cpp index 55cdf1e31..dd998a18d 100644 --- a/CheckClass.cpp +++ b/CheckClass.cpp @@ -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()); } } diff --git a/CheckHeaders.cpp b/CheckHeaders.cpp index a8d9eff6e..b38a9d36b 100644 --- a/CheckHeaders.cpp +++ b/CheckHeaders.cpp @@ -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()); diff --git a/CheckMemoryLeak.cpp b/CheckMemoryLeak.cpp index f6bda1d7d..a969aee05 100644 --- a/CheckMemoryLeak.cpp +++ b/CheckMemoryLeak.cpp @@ -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::listGetFunctionTokenByName(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_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::listfileLine(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); } //--------------------------------------------------------------------------- diff --git a/CheckOther.cpp b/CheckOther.cpp index 5bae59368..a34c35be9 100644 --- a/CheckOther.cpp +++ b/CheckOther.cpp @@ -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()); } } diff --git a/CommonCheck.cpp b/CommonCheck.cpp index da5232a14..f2763e6e8 100644 --- a/CommonCheck.cpp +++ b/CommonCheck.cpp @@ -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; - } -} //--------------------------------------------------------------------------- + diff --git a/CommonCheck.h b/CommonCheck.h index 86f1d76fd..bebbe17ac 100644 --- a/CommonCheck.h +++ b/CommonCheck.h @@ -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 diff --git a/tokenize.cpp b/tokenize.cpp index 11fdbda43..ab1e0924d 100644 --- a/tokenize.cpp +++ b/tokenize.cpp @@ -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(); +} diff --git a/tokenize.h b/tokenize.h index 81b29ac53..1ecc86ce8 100644 --- a/tokenize.h +++ b/tokenize.h @@ -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[]);