2010-01-16 08:47:46 +01:00
/*
* Cppcheck - A tool for static C / C + + code analysis
2011-01-09 20:33:36 +01:00
* Copyright ( C ) 2007 - 2011 Daniel Marjamäki and Cppcheck team .
2010-01-16 08:47:46 +01:00
*
* This program is free software : you can redistribute it and / or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation , either version 3 of the License , or
* ( at your option ) any later version .
*
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
* You should have received a copy of the GNU General Public License
* along with this program . If not , see < http : //www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
# include "checkclass.h"
# include "tokenize.h"
# include "token.h"
# include "errorlogger.h"
2010-11-13 07:31:56 +01:00
# include "symboldatabase.h"
2010-01-16 08:47:46 +01:00
# include <locale>
# include <cstring>
# include <string>
# include <sstream>
# include <algorithm>
//---------------------------------------------------------------------------
// Register CheckClass..
namespace
{
CheckClass instance ;
}
2010-07-26 16:46:37 +02:00
//---------------------------------------------------------------------------
CheckClass : : CheckClass ( const Tokenizer * tokenizer , const Settings * settings , ErrorLogger * errorLogger )
2011-02-02 10:29:10 +01:00
: Check ( myName ( ) , tokenizer , settings , errorLogger ) ,
2010-12-07 07:08:49 +01:00
symbolDatabase ( NULL )
2010-07-26 16:46:37 +02:00
{
2010-08-07 12:41:11 +02:00
}
2010-11-13 07:31:56 +01:00
void CheckClass : : createSymbolDatabase ( )
2010-07-14 19:00:52 +02:00
{
2010-11-13 07:31:56 +01:00
// Multiple calls => bail out
if ( symbolDatabase )
return ;
2010-07-14 19:00:52 +02:00
2010-12-07 07:08:49 +01:00
symbolDatabase = _tokenizer - > getSymbolDatabase ( ) ;
2010-07-14 19:00:52 +02:00
}
2010-01-16 08:47:46 +01:00
2010-07-26 16:46:37 +02:00
//---------------------------------------------------------------------------
// ClassCheck: Check that all class constructors are ok.
//---------------------------------------------------------------------------
2010-07-15 10:16:16 +02:00
2010-01-16 08:47:46 +01:00
void CheckClass : : constructors ( )
{
2010-04-21 08:38:25 +02:00
if ( ! _settings - > _checkCodingStyle )
return ;
2010-08-07 12:41:11 +02:00
createSymbolDatabase ( ) ;
2011-03-11 01:43:29 +01:00
std : : list < Scope > : : const_iterator scope ;
2010-07-26 16:46:37 +02:00
2011-03-11 01:43:29 +01:00
for ( scope = symbolDatabase - > scopeList . begin ( ) ; scope ! = symbolDatabase - > scopeList . end ( ) ; + + scope )
2010-01-16 08:47:46 +01:00
{
2010-11-20 07:26:50 +01:00
// only check classes and structures
2011-01-17 18:29:19 +01:00
if ( ! scope - > isClassOrStruct ( ) )
2010-08-09 17:50:26 +02:00
continue ;
2010-07-26 16:46:37 +02:00
// There are no constructors.
2011-01-17 18:29:19 +01:00
if ( scope - > numConstructors = = 0 )
2010-07-15 10:16:16 +02:00
{
2010-07-26 16:46:37 +02:00
// If there is a private variable, there should be a constructor..
2011-01-17 18:29:19 +01:00
std : : list < Variable > : : const_iterator var ;
for ( var = scope - > varlist . begin ( ) ; var ! = scope - > varlist . end ( ) ; + + var )
2010-07-14 19:00:52 +02:00
{
2011-01-18 07:32:06 +01:00
if ( var - > isPrivate ( ) & & ! var - > isClass ( ) & & ! var - > isStatic ( ) )
2010-07-15 10:16:16 +02:00
{
2011-01-17 18:29:19 +01:00
noConstructorError ( scope - > classDef , scope - > className , scope - > classDef - > str ( ) = = " struct " ) ;
2010-07-26 16:46:37 +02:00
break ;
2010-01-16 08:47:46 +01:00
}
}
2010-07-26 16:46:37 +02:00
}
2010-01-16 08:47:46 +01:00
2011-01-17 18:29:19 +01:00
std : : list < Function > : : const_iterator func ;
std : : vector < Usage > usage ( scope - > varlist . size ( ) ) ;
2010-01-16 08:47:46 +01:00
2011-01-17 18:29:19 +01:00
for ( func = scope - > functionList . begin ( ) ; func ! = scope - > functionList . end ( ) ; + + func )
2010-07-26 16:46:37 +02:00
{
2011-01-17 18:29:19 +01:00
if ( ! func - > hasBody | | ! ( func - > type = = Function : : eConstructor | |
func - > type = = Function : : eCopyConstructor | |
func - > type = = Function : : eOperatorEqual ) )
2010-07-26 16:46:37 +02:00
continue ;
// Mark all variables not used
2011-01-16 16:37:11 +01:00
clearAllVar ( usage ) ;
2010-07-14 19:00:52 +02:00
2010-07-26 16:46:37 +02:00
std : : list < std : : string > callstack ;
2011-03-11 01:43:29 +01:00
initializeVarList ( * func , callstack , & ( * scope ) , usage ) ;
2010-07-14 19:00:52 +02:00
2010-07-26 16:46:37 +02:00
// Check if any variables are uninitialized
2011-01-17 18:29:19 +01:00
std : : list < Variable > : : const_iterator var ;
2011-01-16 16:37:11 +01:00
unsigned int count = 0 ;
2011-01-17 18:29:19 +01:00
for ( var = scope - > varlist . begin ( ) ; var ! = scope - > varlist . end ( ) ; + + var , + + count )
2010-07-14 19:00:52 +02:00
{
2011-01-18 07:32:06 +01:00
if ( usage [ count ] . assign | | usage [ count ] . init | | var - > isStatic ( ) )
2010-07-26 16:46:37 +02:00
continue ;
2010-07-15 10:16:16 +02:00
2011-01-18 07:32:06 +01:00
if ( var - > isConst ( ) & & var - > nameToken ( ) - > previous ( ) - > str ( ) ! = " * " )
2010-11-16 07:30:55 +01:00
continue ;
2010-12-02 07:35:01 +01:00
// Check if this is a class constructor
2011-01-18 07:32:06 +01:00
if ( var - > isClass ( ) & & func - > type = = Function : : eConstructor )
2010-12-02 07:35:01 +01:00
{
// Unknown type so assume it is initialized
2011-01-18 07:32:06 +01:00
if ( ! var - > type ( ) )
2010-12-02 07:35:01 +01:00
continue ;
// Known type that doesn't need initialization or
// known type that has member variables of an unknown type
2011-01-18 07:32:06 +01:00
else if ( var - > type ( ) - > needInitialization ! = Scope : : True )
2010-12-02 07:35:01 +01:00
continue ;
}
2011-01-18 07:34:11 +01:00
// Check if type can't be copied
2011-01-18 11:07:33 +01:00
if ( var - > type ( ) & & canNotCopy ( var - > type ( ) ) )
2011-01-18 07:34:11 +01:00
continue ;
2010-07-26 16:46:37 +02:00
// It's non-static and it's not initialized => error
2011-01-17 18:29:19 +01:00
if ( func - > type = = Function : : eOperatorEqual )
2010-01-16 08:47:46 +01:00
{
2011-01-27 18:44:20 +01:00
const Token * operStart = func - > token - > tokAt ( 1 ) ;
2010-07-26 16:46:37 +02:00
bool classNameUsed = false ;
for ( const Token * operTok = operStart ; operTok ! = operStart - > link ( ) ; operTok = operTok - > next ( ) )
2010-01-16 08:47:46 +01:00
{
2011-01-17 18:29:19 +01:00
if ( operTok - > str ( ) = = scope - > className )
2010-07-14 19:00:52 +02:00
{
2010-07-26 16:46:37 +02:00
classNameUsed = true ;
break ;
2010-07-14 19:00:52 +02:00
}
2010-07-15 10:16:16 +02:00
}
2010-01-16 08:47:46 +01:00
2010-07-26 16:46:37 +02:00
if ( classNameUsed )
2011-01-18 07:32:06 +01:00
operatorEqVarError ( func - > token , scope - > className , var - > name ( ) ) ;
2010-07-26 16:46:37 +02:00
}
2011-01-17 07:21:59 +01:00
else if ( func - > access ! = Private )
2011-01-18 07:32:06 +01:00
uninitVarError ( func - > token , scope - > className , var - > name ( ) ) ;
2010-07-15 10:16:16 +02:00
}
2010-07-14 19:00:52 +02:00
}
2010-01-16 08:47:46 +01:00
}
}
2011-01-18 07:34:11 +01:00
bool CheckClass : : canNotCopy ( const Scope * scope ) const
{
std : : list < Function > : : const_iterator func ;
bool privateAssign = false ;
bool privateCopy = false ;
for ( func = scope - > functionList . begin ( ) ; func ! = scope - > functionList . end ( ) ; + + func )
{
if ( func - > type = = Function : : eCopyConstructor & & func - > access = = Private )
privateCopy = true ;
else if ( func - > type = = Function : : eOperatorEqual & & func - > access = = Private )
privateAssign = true ;
}
return privateAssign & & privateCopy ;
}
2011-01-17 18:29:19 +01:00
void CheckClass : : assignVar ( const std : : string & varname , const Scope * scope , std : : vector < Usage > & usage )
2011-01-16 16:37:11 +01:00
{
2011-01-17 18:29:19 +01:00
std : : list < Variable > : : const_iterator var ;
2011-01-16 16:37:11 +01:00
unsigned int count = 0 ;
2011-01-17 18:29:19 +01:00
for ( var = scope - > varlist . begin ( ) ; var ! = scope - > varlist . end ( ) ; + + var , + + count )
2011-01-16 16:37:11 +01:00
{
2011-01-18 07:32:06 +01:00
if ( var - > name ( ) = = varname )
2011-01-16 16:37:11 +01:00
{
usage [ count ] . assign = true ;
return ;
}
}
}
2011-01-17 18:29:19 +01:00
void CheckClass : : initVar ( const std : : string & varname , const Scope * scope , std : : vector < Usage > & usage )
2011-01-16 16:37:11 +01:00
{
2011-01-17 18:29:19 +01:00
std : : list < Variable > : : const_iterator var ;
2011-01-16 16:37:11 +01:00
unsigned int count = 0 ;
2011-01-17 18:29:19 +01:00
for ( var = scope - > varlist . begin ( ) ; var ! = scope - > varlist . end ( ) ; + + var , + + count )
2011-01-16 16:37:11 +01:00
{
2011-01-18 07:32:06 +01:00
if ( var - > name ( ) = = varname )
2011-01-16 16:37:11 +01:00
{
usage [ count ] . init = true ;
return ;
}
}
}
void CheckClass : : assignAllVar ( std : : vector < Usage > & usage )
{
for ( size_t i = 0 ; i < usage . size ( ) ; + + i )
usage [ i ] . assign = true ;
}
void CheckClass : : clearAllVar ( std : : vector < Usage > & usage )
{
for ( size_t i = 0 ; i < usage . size ( ) ; + + i )
{
usage [ i ] . assign = false ;
usage [ i ] . init = false ;
}
}
2011-01-17 18:29:19 +01:00
bool CheckClass : : isBaseClassFunc ( const Token * tok , const Scope * scope )
2011-01-16 16:37:11 +01:00
{
// Iterate through each base class...
2011-01-17 18:29:19 +01:00
for ( size_t i = 0 ; i < scope - > derivedFrom . size ( ) ; + + i )
2011-01-16 16:37:11 +01:00
{
2011-01-21 07:42:41 +01:00
const Scope * derivedFrom = scope - > derivedFrom [ i ] . scope ;
2011-01-16 16:37:11 +01:00
// Check if base class exists in database
if ( derivedFrom )
{
2011-01-17 18:29:19 +01:00
std : : list < Function > : : const_iterator func ;
2011-01-16 16:37:11 +01:00
for ( func = derivedFrom - > functionList . begin ( ) ; func ! = derivedFrom - > functionList . end ( ) ; + + func )
{
if ( func - > tokenDef - > str ( ) = = tok - > str ( ) )
return true ;
}
}
// Base class not found so assume it is in it.
else
return true ;
}
return false ;
}
2011-01-17 18:29:19 +01:00
void CheckClass : : initializeVarList ( const Function & func , std : : list < std : : string > & callstack , const Scope * scope , std : : vector < Usage > & usage )
2011-01-16 16:37:11 +01:00
{
bool Assign = false ;
unsigned int indentlevel = 0 ;
const Token * ftok = func . token ;
for ( ; ftok ; ftok = ftok - > next ( ) )
{
if ( ! ftok - > next ( ) )
break ;
// Class constructor.. initializing variables like this
// clKalle::clKalle() : var(value) { }
if ( indentlevel = = 0 )
{
if ( Assign & & Token : : Match ( ftok , " %var% ( " ) )
{
2011-01-17 18:29:19 +01:00
initVar ( ftok - > str ( ) , scope , usage ) ;
2011-01-16 16:37:11 +01:00
// assignment in the initializer..
// : var(value = x)
if ( Token : : Match ( ftok - > tokAt ( 2 ) , " %var% = " ) )
2011-01-17 18:29:19 +01:00
assignVar ( ftok - > strAt ( 2 ) , scope , usage ) ;
2011-01-16 16:37:11 +01:00
}
Assign | = ( ftok - > str ( ) = = " : " ) ;
}
if ( ftok - > str ( ) = = " { " )
{
+ + indentlevel ;
Assign = false ;
}
else if ( ftok - > str ( ) = = " } " )
{
if ( indentlevel < = 1 )
break ;
- - indentlevel ;
}
if ( indentlevel < 1 )
continue ;
// Variable getting value from stream?
if ( Token : : Match ( ftok , " >> %var% " ) )
{
2011-01-17 18:29:19 +01:00
assignVar ( ftok - > strAt ( 1 ) , scope , usage ) ;
2011-01-16 16:37:11 +01:00
}
// Before a new statement there is "[{};)=]"
if ( ! Token : : Match ( ftok , " [{};()=] " ) )
continue ;
if ( Token : : simpleMatch ( ftok , " ( ! " ) )
ftok = ftok - > next ( ) ;
// Using the operator= function to initialize all variables..
2011-02-02 16:41:43 +01:00
if ( Token : : simpleMatch ( ftok - > next ( ) , " * this = " ) )
2011-01-16 16:37:11 +01:00
{
assignAllVar ( usage ) ;
break ;
}
// Calling member variable function?
if ( Token : : Match ( ftok - > next ( ) , " %var% . %var% ( " ) )
{
2011-01-17 18:29:19 +01:00
std : : list < Variable > : : const_iterator var ;
for ( var = scope - > varlist . begin ( ) ; var ! = scope - > varlist . end ( ) ; + + var )
2011-01-16 16:37:11 +01:00
{
2011-01-18 07:32:06 +01:00
if ( var - > varId ( ) = = ftok - > next ( ) - > varId ( ) )
2011-01-16 16:37:11 +01:00
{
/** @todo false negative: we assume function changes variable state */
2011-01-17 18:29:19 +01:00
assignVar ( ftok - > next ( ) - > str ( ) , scope , usage ) ;
2011-01-16 16:37:11 +01:00
continue ;
}
}
ftok = ftok - > tokAt ( 2 ) ;
}
if ( ! Token : : Match ( ftok - > next ( ) , " %var% " ) & &
! Token : : Match ( ftok - > next ( ) , " this . %var% " ) & &
! Token : : Match ( ftok - > next ( ) , " * %var% = " ) & &
! Token : : Match ( ftok - > next ( ) , " ( * this ) . %var% " ) )
continue ;
// Goto the first token in this statement..
ftok = ftok - > next ( ) ;
// Skip "( * this )"
if ( Token : : simpleMatch ( ftok , " ( * this ) . " ) )
{
ftok = ftok - > tokAt ( 5 ) ;
}
// Skip "this->"
if ( Token : : simpleMatch ( ftok , " this . " ) )
ftok = ftok - > tokAt ( 2 ) ;
// Skip "classname :: "
if ( Token : : Match ( ftok , " %var% :: " ) )
ftok = ftok - > tokAt ( 2 ) ;
// Clearing all variables..
if ( Token : : simpleMatch ( ftok , " memset ( this , " ) )
{
assignAllVar ( usage ) ;
return ;
}
// Clearing array..
else if ( Token : : Match ( ftok , " memset ( %var% , " ) )
{
2011-01-17 18:29:19 +01:00
assignVar ( ftok - > strAt ( 2 ) , scope , usage ) ;
2011-01-16 16:37:11 +01:00
ftok = ftok - > next ( ) - > link ( ) ;
continue ;
}
// Calling member function?
2011-01-27 18:44:20 +01:00
else if ( Token : : simpleMatch ( ftok , " operator= ( " ) & &
2011-01-16 16:37:11 +01:00
ftok - > previous ( ) - > str ( ) ! = " :: " )
{
// check if member function exists
2011-01-17 18:29:19 +01:00
std : : list < Function > : : const_iterator it ;
for ( it = scope - > functionList . begin ( ) ; it ! = scope - > functionList . end ( ) ; + + it )
2011-01-16 16:37:11 +01:00
{
2011-01-27 18:44:20 +01:00
if ( ftok - > str ( ) = = it - > tokenDef - > str ( ) & & it - > type ! = Function : : eConstructor )
2011-01-16 16:37:11 +01:00
break ;
}
// member function found
2011-01-17 18:29:19 +01:00
if ( it ! = scope - > functionList . end ( ) )
2011-01-16 16:37:11 +01:00
{
// member function has implementation
if ( it - > hasBody )
{
// initialize variable use list using member function
callstack . push_back ( ftok - > str ( ) ) ;
2011-01-17 18:29:19 +01:00
initializeVarList ( * it , callstack , scope , usage ) ;
2011-01-16 16:37:11 +01:00
callstack . pop_back ( ) ;
}
// there is a called member function, but it has no implementation, so we assume it initializes everything
else
{
assignAllVar ( usage ) ;
}
}
// using default operator =, assume everything initialized
else
{
assignAllVar ( usage ) ;
}
}
else if ( Token : : Match ( ftok , " %var% ( " ) & & ftok - > str ( ) ! = " if " )
{
// Passing "this" => assume that everything is initialized
for ( const Token * tok2 = ftok - > next ( ) - > link ( ) ; tok2 & & tok2 ! = ftok ; tok2 = tok2 - > previous ( ) )
{
if ( tok2 - > str ( ) = = " this " )
{
assignAllVar ( usage ) ;
return ;
}
}
// recursive call / calling overloaded function
// assume that all variables are initialized
if ( std : : find ( callstack . begin ( ) , callstack . end ( ) , ftok - > str ( ) ) ! = callstack . end ( ) )
{
assignAllVar ( usage ) ;
return ;
}
// check if member function
2011-01-17 18:29:19 +01:00
std : : list < Function > : : const_iterator it ;
for ( it = scope - > functionList . begin ( ) ; it ! = scope - > functionList . end ( ) ; + + it )
2011-01-16 16:37:11 +01:00
{
2011-01-17 18:29:19 +01:00
if ( ftok - > str ( ) = = it - > tokenDef - > str ( ) & & it - > type ! = Function : : eConstructor )
2011-01-16 16:37:11 +01:00
break ;
}
// member function found
2011-01-17 18:29:19 +01:00
if ( it ! = scope - > functionList . end ( ) )
2011-01-16 16:37:11 +01:00
{
// member function has implementation
if ( it - > hasBody )
{
// initialize variable use list using member function
callstack . push_back ( ftok - > str ( ) ) ;
2011-01-17 18:29:19 +01:00
initializeVarList ( * it , callstack , scope , usage ) ;
2011-01-16 16:37:11 +01:00
callstack . pop_back ( ) ;
}
// there is a called member function, but it has no implementation, so we assume it initializes everything
else
{
assignAllVar ( usage ) ;
}
}
// not member function
else
{
// could be a base class virtual function, so we assume it initializes everything
2011-01-17 18:29:19 +01:00
if ( func . type ! = Function : : eConstructor & & isBaseClassFunc ( ftok , scope ) )
2011-01-16 16:37:11 +01:00
{
/** @todo False Negative: we should look at the base class functions to see if they
* call any derived class virtual functions that change the derived class state
*/
assignAllVar ( usage ) ;
}
// has friends, so we assume it initializes everything
2011-01-17 18:29:19 +01:00
if ( ! scope - > friendList . empty ( ) )
2011-01-16 16:37:11 +01:00
assignAllVar ( usage ) ;
// the function is external and it's neither friend nor inherited virtual function.
// assume all variables that are passed to it are initialized..
else
{
unsigned int indentlevel2 = 0 ;
for ( const Token * tok = ftok - > tokAt ( 2 ) ; tok ; tok = tok - > next ( ) )
{
if ( tok - > str ( ) = = " ( " )
+ + indentlevel2 ;
else if ( tok - > str ( ) = = " ) " )
{
if ( indentlevel2 = = 0 )
break ;
- - indentlevel2 ;
}
if ( tok - > isName ( ) )
{
2011-01-17 18:29:19 +01:00
assignVar ( tok - > str ( ) , scope , usage ) ;
2011-01-16 16:37:11 +01:00
}
}
}
}
}
// Assignment of member variable?
else if ( Token : : Match ( ftok , " %var% = " ) )
{
2011-01-17 18:29:19 +01:00
assignVar ( ftok - > str ( ) , scope , usage ) ;
2011-01-16 16:37:11 +01:00
}
// Assignment of array item of member variable?
else if ( Token : : Match ( ftok , " %var% [ %any% ] = " ) )
{
2011-01-17 18:29:19 +01:00
assignVar ( ftok - > str ( ) , scope , usage ) ;
2011-01-16 16:37:11 +01:00
}
// Assignment of member of array item of member variable?
else if ( Token : : Match ( ftok , " %var% [ %any% ] . %var% = " ) | |
Token : : Match ( ftok , " %var% [ %any% ] . %var% . %var% = " ) )
{
2011-01-17 18:29:19 +01:00
assignVar ( ftok - > str ( ) , scope , usage ) ;
2011-01-16 16:37:11 +01:00
}
// Assignment of array item of member variable?
else if ( Token : : Match ( ftok , " %var% [ %any% ] [ %any% ] = " ) )
{
2011-01-17 18:29:19 +01:00
assignVar ( ftok - > str ( ) , scope , usage ) ;
2011-01-16 16:37:11 +01:00
}
// Assignment of array item of member variable?
else if ( Token : : Match ( ftok , " * %var% = " ) )
{
2011-01-17 18:29:19 +01:00
assignVar ( ftok - > next ( ) - > str ( ) , scope , usage ) ;
2011-01-16 16:37:11 +01:00
}
// Assignment of struct member of member variable?
else if ( Token : : Match ( ftok , " %var% . %any% = " ) )
{
2011-01-17 18:29:19 +01:00
assignVar ( ftok - > str ( ) , scope , usage ) ;
2011-01-16 16:37:11 +01:00
}
// The functions 'clear' and 'Clear' are supposed to initialize variable.
if ( Token : : Match ( ftok , " %var% . clear|Clear ( " ) )
{
2011-01-17 18:29:19 +01:00
assignVar ( ftok - > str ( ) , scope , usage ) ;
2011-01-16 16:37:11 +01:00
}
}
}
2010-11-14 06:50:33 +01:00
void CheckClass : : noConstructorError ( const Token * tok , const std : : string & classname , bool isStruct )
{
// For performance reasons the constructor might be intentionally missing. Therefore this is not a "warning"
2010-11-27 09:17:03 +01:00
reportError ( tok , Severity : : style , " noConstructor " ,
" The " + std : : string ( isStruct ? " struct " : " class " ) + " ' " + classname +
" ' does not have a constructor. \n "
2010-12-01 16:55:22 +01:00
" The " + std : : string ( isStruct ? " struct " : " class " ) + " ' " + classname +
" 'does not have a constructor but it has attributes. "
2010-11-27 09:17:03 +01:00
" The attributes are not initialized which may cause bugs or undefined behavior. " ) ;
2010-11-14 06:50:33 +01:00
}
void CheckClass : : uninitVarError ( const Token * tok , const std : : string & classname , const std : : string & varname )
{
2011-01-03 19:03:42 +01:00
reportError ( tok , Severity : : warning , " uninitVar " , " Member variable ' " + classname + " :: " + varname + " ' is not initialised in the constructor. " ) ;
2010-11-14 06:50:33 +01:00
}
void CheckClass : : operatorEqVarError ( const Token * tok , const std : : string & classname , const std : : string & varname )
{
reportError ( tok , Severity : : warning , " operatorEqVarError " , " Member variable ' " + classname + " :: " + varname + " ' is not assigned a value in ' " + classname + " ::operator= " + " ' " ) ;
}
2010-01-16 08:47:46 +01:00
//---------------------------------------------------------------------------
// ClassCheck: Unused private functions
//---------------------------------------------------------------------------
void CheckClass : : privateFunctions ( )
{
2010-04-21 08:38:25 +02:00
if ( ! _settings - > _checkCodingStyle )
return ;
2010-09-30 21:22:49 +02:00
// don't check code that contains templates. Templates that are
// "unused" are removed from the code. #2067
if ( _tokenizer - > codeWithTemplates ( ) )
return ;
2010-09-07 18:37:43 +02:00
// dont check borland classes with properties..
if ( Token : : findmatch ( _tokenizer - > tokens ( ) , " ; __property ; " ) )
return ;
2010-09-02 07:40:20 +02:00
createSymbolDatabase ( ) ;
2011-03-11 01:43:29 +01:00
std : : list < Scope > : : const_iterator scope ;
2010-06-13 07:17:50 +02:00
2011-03-11 01:43:29 +01:00
for ( scope = symbolDatabase - > scopeList . begin ( ) ; scope ! = symbolDatabase - > scopeList . end ( ) ; + + scope )
2010-01-16 08:47:46 +01:00
{
2010-11-20 07:26:50 +01:00
// only check classes and structures
2011-01-17 18:29:19 +01:00
if ( ! scope - > isClassOrStruct ( ) )
2010-09-02 07:40:20 +02:00
continue ;
2010-12-15 18:45:53 +01:00
// don’ t check derived classes
2011-01-17 18:29:19 +01:00
if ( ! scope - > derivedFrom . empty ( ) )
2010-09-02 07:40:20 +02:00
continue ;
2011-01-22 17:35:54 +01:00
// skip checking if there are friends
if ( ! scope - > friendList . empty ( ) )
continue ;
2010-09-02 07:40:20 +02:00
// Locate some class
2011-01-17 18:29:19 +01:00
const Token * tok1 = scope - > classDef ;
2010-09-02 07:40:20 +02:00
2010-09-02 19:22:54 +02:00
// check that the whole class implementation is seen
bool whole = true ;
2011-01-17 18:29:19 +01:00
std : : list < Function > : : const_iterator func ;
for ( func = scope - > functionList . begin ( ) ; func ! = scope - > functionList . end ( ) ; + + func )
2010-09-02 19:22:54 +02:00
{
if ( ! func - > hasBody )
{
// empty private copy constructors and assignment operators are OK
2011-02-11 14:00:41 +01:00
if ( ( func - > type = = Function : : eCopyConstructor | |
func - > type = = Function : : eOperatorEqual ) & &
func - > access = = Private )
2010-09-02 19:22:54 +02:00
continue ;
whole = false ;
break ;
}
}
if ( ! whole )
2010-01-16 08:47:46 +01:00
continue ;
const std : : string & classname = tok1 - > next ( ) - > str ( ) ;
std : : list < const Token * > FuncList ;
2010-09-02 07:40:20 +02:00
/** @todo embedded class have access to private functions */
2011-01-17 18:29:19 +01:00
if ( ! scope - > getNestedNonFunctions ( ) )
2010-01-16 08:47:46 +01:00
{
2011-01-17 18:29:19 +01:00
for ( func = scope - > functionList . begin ( ) ; func ! = scope - > functionList . end ( ) ; + + func )
2010-01-16 08:47:46 +01:00
{
2010-09-02 07:40:20 +02:00
// Get private functions..
2011-02-11 14:00:41 +01:00
if ( func - > type = = Function : : eFunction & & func - > access = = Private )
2010-09-02 19:22:54 +02:00
FuncList . push_back ( func - > tokenDef ) ;
2010-01-16 08:47:46 +01:00
}
}
// Check that all private functions are used..
2011-02-11 14:00:41 +01:00
for ( func = scope - > functionList . begin ( ) ; func ! = scope - > functionList . end ( ) ; + + func )
2010-01-16 08:47:46 +01:00
{
2011-02-20 14:36:06 +01:00
const Token * ftok = func - > start ;
2011-02-22 12:47:28 +01:00
if ( ftok )
2010-01-16 08:47:46 +01:00
{
2011-02-22 12:47:28 +01:00
const Token * etok = ftok - > link ( ) ;
for ( ; ftok ! = etok ; ftok = ftok - > next ( ) )
2010-01-16 08:47:46 +01:00
{
2011-02-22 12:47:28 +01:00
if ( Token : : Match ( ftok , " %var% ( " ) )
2010-01-16 08:47:46 +01:00
{
2011-02-22 12:47:28 +01:00
// Remove function from FuncList
std : : list < const Token * > : : iterator it = FuncList . begin ( ) ;
while ( it ! = FuncList . end ( ) )
{
if ( ftok - > str ( ) = = ( * it ) - > str ( ) )
FuncList . erase ( it + + ) ;
else
+ + it ;
}
2010-01-16 08:47:46 +01:00
}
}
}
}
2011-02-11 14:00:41 +01:00
while ( ! FuncList . empty ( ) )
2010-01-16 08:47:46 +01:00
{
// Final check; check if the function pointer is used somewhere..
const std : : string _pattern ( " return|(|)|,|= " + FuncList . front ( ) - > str ( ) ) ;
2010-08-15 07:44:08 +02:00
// or if the function address is used somewhere...
// eg. sigc::mem_fun(this, &className::classFunction)
const std : : string _pattern2 ( " & " + classname + " :: " + FuncList . front ( ) - > str ( ) ) ;
2011-01-19 01:58:44 +01:00
const std : : string methodAsArgument ( " (|, " + classname + " :: " + FuncList . front ( ) - > str ( ) + " ,|) " ) ;
2010-08-15 07:44:08 +02:00
if ( ! Token : : findmatch ( _tokenizer - > tokens ( ) , _pattern . c_str ( ) ) & &
2011-01-19 01:58:44 +01:00
! Token : : findmatch ( _tokenizer - > tokens ( ) , _pattern2 . c_str ( ) ) & &
! Token : : findmatch ( _tokenizer - > tokens ( ) , methodAsArgument . c_str ( ) )
)
2010-01-16 08:47:46 +01:00
{
unusedPrivateFunctionError ( FuncList . front ( ) , classname , FuncList . front ( ) - > str ( ) ) ;
}
FuncList . pop_front ( ) ;
}
}
}
2010-11-14 06:50:33 +01:00
void CheckClass : : unusedPrivateFunctionError ( const Token * tok , const std : : string & classname , const std : : string & funcname )
{
reportError ( tok , Severity : : style , " unusedPrivateFunction " , " Unused private function ' " + classname + " :: " + funcname + " ' " ) ;
}
2010-01-16 08:47:46 +01:00
//---------------------------------------------------------------------------
// ClassCheck: Check that memset is not used on classes
//---------------------------------------------------------------------------
2011-03-13 04:41:21 +01:00
void CheckClass : : checkMemsetType ( const Scope * start , const Token * tok , const Token * typeTok )
2011-03-09 09:29:30 +01:00
{
// Warn if type is a class or struct that contains any std::* variables
2011-03-13 04:41:21 +01:00
const Scope * scope = symbolDatabase - > findVariableType ( start , typeTok ) ;
if ( ! scope )
2011-03-09 09:29:30 +01:00
return ;
2011-03-13 04:41:21 +01:00
const Token * tstruct = scope - > classDef ;
2011-03-10 08:19:31 +01:00
const std : : string & typeName = tstruct - > str ( ) ;
2011-03-09 09:29:30 +01:00
if ( tstruct - > tokAt ( 2 ) - > str ( ) = = " : " )
{
tstruct = tstruct - > tokAt ( 3 ) ;
for ( ; tstruct ; tstruct = tstruct - > next ( ) )
{
while ( Token : : Match ( tstruct , " public|private|protected|virtual " ) )
{
tstruct = tstruct - > next ( ) ;
}
// recursively check all parent classes
2011-03-13 04:41:21 +01:00
checkMemsetType ( start , tok , tstruct ) ;
2011-03-09 09:29:30 +01:00
tstruct = tstruct - > next ( ) ;
if ( tstruct - > str ( ) ! = " , " )
break ;
}
}
for ( ; tstruct ; tstruct = tstruct - > next ( ) )
{
if ( tstruct - > str ( ) = = " } " )
break ;
// struct with function? skip function body..
if ( Token : : simpleMatch ( tstruct , " ) { " ) )
{
tstruct = tstruct - > next ( ) - > link ( ) ;
if ( ! tstruct )
break ;
}
// before a statement there must be either:
// * private:|protected:|public:
// * { } ;
if ( Token : : Match ( tstruct , " [;{}] " ) | |
tstruct - > str ( ) . find ( " : " ) ! = std : : string : : npos )
{
if ( Token : : Match ( tstruct - > next ( ) , " std :: %type% %var% ; " ) )
2011-03-10 08:19:31 +01:00
memsetError ( tok , tok - > str ( ) , " 'std:: " + tstruct - > strAt ( 3 ) + " ' " , typeName ) ;
2011-03-09 09:29:30 +01:00
else if ( Token : : Match ( tstruct - > next ( ) , " std :: %type% < " ) )
{
// backup the type
const std : : string typestr ( tstruct - > strAt ( 3 ) ) ;
// check if it's a pointer variable..
unsigned int level = 0 ;
while ( 0 ! = ( tstruct = tstruct - > next ( ) ) )
{
if ( tstruct - > str ( ) = = " < " )
+ + level ;
else if ( tstruct - > str ( ) = = " > " )
{
if ( level < = 1 )
break ;
- - level ;
}
else if ( tstruct - > str ( ) = = " ( " )
tstruct = tstruct - > link ( ) ;
}
if ( ! tstruct )
break ;
// found error => report
if ( Token : : Match ( tstruct , " > %var% ; " ) )
2011-03-10 08:19:31 +01:00
memsetError ( tok , tok - > str ( ) , " 'std:: " + typestr + " ' " , typeName ) ;
2011-03-09 09:29:30 +01:00
}
2011-03-09 10:10:39 +01:00
else if ( Token : : simpleMatch ( tstruct - > next ( ) , " virtual " ) )
2011-03-10 08:19:31 +01:00
memsetError ( tok , tok - > str ( ) , " virtual method " , typeName ) ;
2011-03-09 09:29:30 +01:00
}
}
}
2010-01-16 08:47:46 +01:00
void CheckClass : : noMemset ( )
{
2011-02-26 22:00:05 +01:00
createSymbolDatabase ( ) ;
2011-03-13 04:41:21 +01:00
std : : list < Scope > : : const_iterator scope ;
for ( scope = symbolDatabase - > scopeList . begin ( ) ; scope ! = symbolDatabase - > scopeList . end ( ) ; + + scope )
2010-01-16 08:47:46 +01:00
{
2011-03-13 04:41:21 +01:00
std : : list < Function > : : const_iterator func ;
2010-01-16 08:47:46 +01:00
2011-03-13 04:41:21 +01:00
for ( func = scope - > functionList . begin ( ) ; func ! = scope - > functionList . end ( ) ; + + func )
2011-02-24 18:38:45 +01:00
{
2011-03-13 04:41:21 +01:00
// only check functions with bodies
if ( ! func - > hasBody )
continue ;
2010-01-16 08:47:46 +01:00
2011-03-13 04:41:21 +01:00
// Locate all 'memset' tokens..
const Token * end = func - > start - > link ( ) ;
for ( const Token * tok = func - > start ; tok & & tok ! = end ; tok = tok - > next ( ) )
{
if ( ! Token : : Match ( tok , " memset|memcpy|memmove " ) )
continue ;
const Token * typeTok = 0 ;
if ( Token : : Match ( tok , " memset ( %var% , %num% , sizeof ( %type% ) ) " ) )
typeTok = tok - > tokAt ( 8 ) ;
else if ( Token : : Match ( tok , " memset ( & %var% , %num% , sizeof ( %type% ) ) " ) )
typeTok = tok - > tokAt ( 9 ) ;
else if ( Token : : Match ( tok , " memset ( & %var% , %num% , sizeof ( %type% :: %type% ) ) " ) )
typeTok = tok - > tokAt ( 11 ) ;
else if ( Token : : Match ( tok , " memset ( %var% , %num% , sizeof ( struct %type% ) ) " ) )
typeTok = tok - > tokAt ( 9 ) ;
else if ( Token : : Match ( tok , " memset ( & %var% , %num% , sizeof ( struct %type% ) ) " ) )
typeTok = tok - > tokAt ( 10 ) ;
else if ( Token : : Match ( tok , " %type% ( %var% , %var% , sizeof ( %type% ) ) " ) )
typeTok = tok - > tokAt ( 8 ) ;
else if ( Token : : Match ( tok , " memset ( & %var% , %num% , sizeof ( %var% ) ) " ) )
{
unsigned int varid = tok - > tokAt ( 3 ) - > varId ( ) ;
const Variable * var = symbolDatabase - > getVariableFromVarId ( varid ) ;
if ( var & & ( var - > typeStartToken ( ) = = var - > typeEndToken ( ) | |
Token : : Match ( var - > typeStartToken ( ) , " %type% :: %type% " ) ) )
typeTok = var - > typeEndToken ( ) ;
}
// No type defined => The tokens didn't match
if ( ! typeTok )
continue ;
2010-01-16 08:47:46 +01:00
2011-03-13 04:41:21 +01:00
checkMemsetType ( & ( * scope ) , tok , typeTok ) ;
}
}
2010-01-16 08:47:46 +01:00
}
}
2011-03-10 08:19:31 +01:00
void CheckClass : : memsetError ( const Token * tok , const std : : string & memfunc , const std : : string & classname , const std : : string & type )
2010-11-14 06:50:33 +01:00
{
2011-03-10 08:19:31 +01:00
reportError ( tok , Severity : : error , " memsetClass " , " Using ' " + memfunc + " ' on " + type + " that contains a " + classname ) ;
2010-11-14 06:50:33 +01:00
}
2010-01-16 08:47:46 +01:00
//---------------------------------------------------------------------------
2010-09-11 08:23:30 +02:00
// ClassCheck: "void operator=(" and "const type & operator=("
2010-01-16 08:47:46 +01:00
//---------------------------------------------------------------------------
void CheckClass : : operatorEq ( )
{
2010-04-21 08:38:25 +02:00
if ( ! _settings - > _checkCodingStyle )
return ;
2010-08-07 12:41:11 +02:00
createSymbolDatabase ( ) ;
2011-03-11 01:43:29 +01:00
std : : list < Scope > : : const_iterator scope ;
2010-01-16 08:47:46 +01:00
2011-03-11 01:43:29 +01:00
for ( scope = symbolDatabase - > scopeList . begin ( ) ; scope ! = symbolDatabase - > scopeList . end ( ) ; + + scope )
2010-01-16 08:47:46 +01:00
{
2011-03-11 01:43:29 +01:00
std : : list < Function > : : const_iterator func ;
2010-07-26 16:46:37 +02:00
2011-03-11 01:43:29 +01:00
for ( func = scope - > functionList . begin ( ) ; func ! = scope - > functionList . end ( ) ; + + func )
2010-01-16 08:47:46 +01:00
{
2011-03-11 01:43:29 +01:00
if ( func - > type = = Function : : eOperatorEqual & & func - > access ! = Private )
2010-01-16 08:47:46 +01:00
{
2011-03-11 01:43:29 +01:00
if ( func - > token - > strAt ( - 1 ) = = " void " )
operatorEqReturnError ( func - > token - > tokAt ( - 1 ) ) ;
2010-01-16 08:47:46 +01:00
}
}
}
}
2010-11-14 06:50:33 +01:00
void CheckClass : : operatorEqReturnError ( const Token * tok )
{
reportError ( tok , Severity : : style , " operatorEq " , " 'operator=' should return something " ) ;
}
2010-01-16 08:47:46 +01:00
//---------------------------------------------------------------------------
// ClassCheck: "C& operator=(const C&) { ... return *this; }"
// operator= should return a reference to *this
//---------------------------------------------------------------------------
2011-01-17 18:29:19 +01:00
void CheckClass : : checkReturnPtrThis ( const Scope * scope , const Function * func , const Token * tok , const Token * last )
2010-09-11 08:23:30 +02:00
{
bool foundReturn = false ;
for ( ; tok & & tok ! = last ; tok = tok - > next ( ) )
{
// check for return of reference to this
if ( tok - > str ( ) = = " return " )
{
foundReturn = true ;
2011-01-17 18:29:19 +01:00
std : : string cast ( " ( " + scope - > className + " & ) " ) ;
2010-09-11 08:23:30 +02:00
if ( Token : : Match ( tok - > next ( ) , cast . c_str ( ) ) )
tok = tok - > tokAt ( 4 ) ;
// check if a function is called
if ( Token : : Match ( tok - > tokAt ( 1 ) , " %any% ( " ) & &
tok - > tokAt ( 2 ) - > link ( ) - > next ( ) - > str ( ) = = " ; " )
{
2011-01-17 18:29:19 +01:00
std : : list < Function > : : const_iterator it ;
2010-09-11 08:23:30 +02:00
// check if it is a member function
2011-01-17 18:29:19 +01:00
for ( it = scope - > functionList . begin ( ) ; it ! = scope - > functionList . end ( ) ; + + it )
2010-09-11 08:23:30 +02:00
{
2011-01-21 19:54:41 +01:00
// check for a regular function with the same name and a body
2011-01-17 18:29:19 +01:00
if ( it - > type = = Function : : eFunction & & it - > hasBody & &
2010-09-11 08:23:30 +02:00
it - > token - > str ( ) = = tok - > next ( ) - > str ( ) )
{
// check for the proper return type
if ( it - > tokenDef - > previous ( ) - > str ( ) = = " & " & &
2011-01-17 18:29:19 +01:00
it - > tokenDef - > strAt ( - 2 ) = = scope - > className )
2010-09-11 08:23:30 +02:00
{
// make sure it's not a const function
if ( it - > arg - > link ( ) - > next ( ) - > str ( ) ! = " const " )
2011-01-21 19:54:41 +01:00
{
/** @todo make sure argument types match */
// make sure it's not the same function
if ( & * it ! = func )
checkReturnPtrThis ( scope , & * it , it - > arg - > link ( ) - > next ( ) , it - > arg - > link ( ) - > next ( ) - > link ( ) ) ;
// just bail for now
else
return ;
}
2010-09-11 08:23:30 +02:00
}
}
}
}
2011-02-20 02:09:07 +01:00
// check if *this is returned
2010-09-11 08:23:30 +02:00
else if ( ! ( Token : : Match ( tok - > tokAt ( 1 ) , " (| * this ; | = " ) ||
Token : : Match ( tok - > tokAt ( 1 ) , " (| * this += " ) | |
2011-02-20 02:02:16 +01:00
Token : : simpleMatch ( tok - > tokAt ( 1 ) , " operator= ( " ) | |
2011-03-15 08:19:30 +01:00
Token : : simpleMatch ( tok - > tokAt ( 1 ) , " this . operator= ( " ) | |
2011-02-20 02:02:16 +01:00
( Token : : Match ( tok - > tokAt ( 1 ) , " %type% :: operator= ( " ) & &
tok - > next ( ) - > str ( ) = = scope - > className ) ) )
2010-09-11 08:23:30 +02:00
operatorEqRetRefThisError ( func - > token ) ;
}
}
if ( ! foundReturn )
operatorEqRetRefThisError ( func - > token ) ;
}
2010-01-16 08:47:46 +01:00
void CheckClass : : operatorEqRetRefThis ( )
{
2010-04-21 08:38:25 +02:00
if ( ! _settings - > _checkCodingStyle )
return ;
2010-08-07 12:41:11 +02:00
createSymbolDatabase ( ) ;
2011-03-11 01:43:29 +01:00
std : : list < Scope > : : const_iterator scope ;
2010-01-16 08:47:46 +01:00
2011-03-11 01:43:29 +01:00
for ( scope = symbolDatabase - > scopeList . begin ( ) ; scope ! = symbolDatabase - > scopeList . end ( ) ; + + scope )
2010-01-16 08:47:46 +01:00
{
2010-11-20 07:26:50 +01:00
// only check classes and structures
2011-01-17 18:29:19 +01:00
if ( scope - > isClassOrStruct ( ) )
2010-01-16 08:47:46 +01:00
{
2011-01-17 18:29:19 +01:00
std : : list < Function > : : const_iterator func ;
2010-11-02 18:28:55 +01:00
2011-01-17 18:29:19 +01:00
for ( func = scope - > functionList . begin ( ) ; func ! = scope - > functionList . end ( ) ; + + func )
2010-01-16 08:47:46 +01:00
{
2011-01-17 18:29:19 +01:00
if ( func - > type = = Function : : eOperatorEqual & & func - > hasBody )
2010-01-16 08:47:46 +01:00
{
2010-11-02 18:28:55 +01:00
// make sure return signature is correct
2011-01-27 18:44:20 +01:00
if ( Token : : Match ( func - > tokenDef - > tokAt ( - 3 ) , " ;|}|{|public:|protected:|private: %type% & " ) & &
func - > tokenDef - > strAt ( - 2 ) = = scope - > className )
2010-11-02 18:28:55 +01:00
{
// find the ')'
const Token * tok = func - > token - > next ( ) - > link ( ) ;
2010-01-16 08:47:46 +01:00
2011-03-11 01:43:29 +01:00
checkReturnPtrThis ( & ( * scope ) , & ( * func ) , tok - > tokAt ( 2 ) , tok - > next ( ) - > link ( ) ) ;
2010-11-02 18:28:55 +01:00
}
2010-01-16 08:47:46 +01:00
}
}
}
}
}
2010-07-26 16:46:37 +02:00
2010-11-14 06:50:33 +01:00
void CheckClass : : operatorEqRetRefThisError ( const Token * tok )
{
reportError ( tok , Severity : : style , " operatorEqRetRefThis " , " 'operator=' should return reference to self " ) ;
}
2010-01-16 08:47:46 +01:00
//---------------------------------------------------------------------------
// ClassCheck: "C& operator=(const C& rhs) { if (this == &rhs) ... }"
// operator= should check for assignment to self
//
// For simple classes, an assignment to self check is only a potential optimization.
//
// For classes that allocate dynamic memory, assignment to self can be a real error
// if it is deallocated and allocated again without being checked for.
//
// This check is not valid for classes with multiple inheritance because a
// class can have multiple addresses so there is no trivial way to check for
// assignment to self.
//---------------------------------------------------------------------------
2010-11-14 06:50:33 +01:00
void CheckClass : : operatorEqToSelf ( )
{
if ( ! _settings - > _checkCodingStyle )
return ;
createSymbolDatabase ( ) ;
2011-03-11 01:43:29 +01:00
std : : list < Scope > : : const_iterator scope ;
2010-11-14 06:50:33 +01:00
2011-03-11 01:43:29 +01:00
for ( scope = symbolDatabase - > scopeList . begin ( ) ; scope ! = symbolDatabase - > scopeList . end ( ) ; + + scope )
2010-11-14 06:50:33 +01:00
{
2011-03-11 01:43:29 +01:00
std : : list < Function > : : const_iterator func ;
2010-11-14 06:50:33 +01:00
// skip classes with multiple inheritance
2011-01-17 18:29:19 +01:00
if ( scope - > derivedFrom . size ( ) > 1 )
2010-11-14 06:50:33 +01:00
continue ;
2011-03-11 01:43:29 +01:00
for ( func = scope - > functionList . begin ( ) ; func ! = scope - > functionList . end ( ) ; + + func )
2010-11-14 06:50:33 +01:00
{
2011-03-11 01:43:29 +01:00
if ( func - > type = = Function : : eOperatorEqual & & func - > hasBody )
2010-11-14 06:50:33 +01:00
{
// make sure return signature is correct
2011-03-11 01:43:29 +01:00
if ( Token : : Match ( func - > tokenDef - > tokAt ( - 3 ) , " ;|}|{|public:|protected:|private: %type% & " ) & &
func - > tokenDef - > strAt ( - 2 ) = = scope - > className )
2010-11-14 06:50:33 +01:00
{
// check for proper function parameter signature
2011-03-11 01:43:29 +01:00
if ( ( Token : : Match ( func - > tokenDef - > next ( ) , " ( const %var% & ) " ) | |
Token : : Match ( func - > tokenDef - > next ( ) , " ( const %var% & %var% ) " ) ) & &
func - > tokenDef - > strAt ( 3 ) = = scope - > className )
2010-11-14 06:50:33 +01:00
{
// find the parameter name
2011-03-11 01:43:29 +01:00
const Token * rhs = func - > token ;
2010-11-14 06:50:33 +01:00
while ( rhs - > str ( ) ! = " & " )
rhs = rhs - > next ( ) ;
rhs = rhs - > next ( ) ;
// find the ')'
2011-03-11 01:43:29 +01:00
const Token * tok = func - > token - > next ( ) - > link ( ) ;
2010-11-14 06:50:33 +01:00
const Token * tok1 = tok ;
if ( tok1 & & tok1 - > tokAt ( 1 ) & & tok1 - > tokAt ( 1 ) - > str ( ) = = " { " & & tok1 - > tokAt ( 1 ) - > link ( ) )
{
const Token * first = tok1 - > tokAt ( 1 ) ;
const Token * last = first - > link ( ) ;
if ( ! hasAssignSelf ( first , last , rhs ) )
{
if ( hasDeallocation ( first , last ) )
operatorEqToSelfError ( tok ) ;
}
}
}
}
}
}
}
}
bool CheckClass : : hasDeallocation ( const Token * first , const Token * last )
2010-01-16 08:47:46 +01:00
{
// This function is called when no simple check was found for assignment
// to self. We are currently looking for a specific sequence of:
// deallocate member ; ... member = allocate
// This check is far from ideal because it can cause false negatives.
// Unfortunately, this is necessary to prevent false positives.
// This check needs to do careful analysis someday to get this
// correct with a high degree of certainty.
2010-08-28 11:23:23 +02:00
for ( const Token * tok = first ; tok & & ( tok ! = last ) ; tok = tok - > next ( ) )
2010-01-16 08:47:46 +01:00
{
// check for deallocating memory
2010-04-02 07:30:58 +02:00
if ( Token : : Match ( tok , " {|;|, free ( %var% " ) )
2010-01-16 08:47:46 +01:00
{
2010-08-28 11:23:23 +02:00
const Token * var = tok - > tokAt ( 3 ) ;
2010-01-16 08:47:46 +01:00
// we should probably check that var is a pointer in this class
2010-08-28 11:23:23 +02:00
const Token * tok1 = tok - > tokAt ( 4 ) ;
2010-01-16 08:47:46 +01:00
2010-04-02 07:30:58 +02:00
while ( tok1 & & ( tok1 ! = last ) )
2010-01-16 08:47:46 +01:00
{
2010-04-02 07:30:58 +02:00
if ( Token : : Match ( tok1 , " %var% = " ) )
2010-01-16 08:47:46 +01:00
{
2010-04-02 07:30:58 +02:00
if ( tok1 - > str ( ) = = var - > str ( ) )
2010-01-16 08:47:46 +01:00
return true ;
}
tok1 = tok1 - > next ( ) ;
}
}
2010-04-02 07:30:58 +02:00
else if ( Token : : Match ( tok , " {|;|, delete [ ] %var% " ) )
2010-01-16 08:47:46 +01:00
{
2010-08-28 11:23:23 +02:00
const Token * var = tok - > tokAt ( 4 ) ;
2010-01-16 08:47:46 +01:00
// we should probably check that var is a pointer in this class
2010-08-28 11:23:23 +02:00
const Token * tok1 = tok - > tokAt ( 5 ) ;
2010-01-16 08:47:46 +01:00
2010-04-02 07:30:58 +02:00
while ( tok1 & & ( tok1 ! = last ) )
2010-01-16 08:47:46 +01:00
{
2010-04-02 07:30:58 +02:00
if ( Token : : Match ( tok1 , " %var% = new %type% [ " ) )
2010-01-16 08:47:46 +01:00
{
2010-04-02 07:30:58 +02:00
if ( tok1 - > str ( ) = = var - > str ( ) )
2010-01-16 08:47:46 +01:00
return true ;
}
tok1 = tok1 - > next ( ) ;
}
}
2010-04-02 07:30:58 +02:00
else if ( Token : : Match ( tok , " {|;|, delete %var% " ) )
2010-01-16 08:47:46 +01:00
{
2010-08-28 11:23:23 +02:00
const Token * var = tok - > tokAt ( 2 ) ;
2010-01-16 08:47:46 +01:00
// we should probably check that var is a pointer in this class
2010-08-28 11:23:23 +02:00
const Token * tok1 = tok - > tokAt ( 3 ) ;
2010-01-16 08:47:46 +01:00
2010-04-02 07:30:58 +02:00
while ( tok1 & & ( tok1 ! = last ) )
2010-01-16 08:47:46 +01:00
{
2010-04-02 07:30:58 +02:00
if ( Token : : Match ( tok1 , " %var% = new " ) )
2010-01-16 08:47:46 +01:00
{
2010-04-02 07:30:58 +02:00
if ( tok1 - > str ( ) = = var - > str ( ) )
2010-01-16 08:47:46 +01:00
return true ;
}
tok1 = tok1 - > next ( ) ;
}
}
}
return false ;
}
2010-11-14 06:50:33 +01:00
bool CheckClass : : hasAssignSelf ( const Token * first , const Token * last , const Token * rhs )
2010-01-16 08:47:46 +01:00
{
2010-08-28 11:23:23 +02:00
for ( const Token * tok = first ; tok & & tok ! = last ; tok = tok - > next ( ) )
2010-01-16 08:47:46 +01:00
{
2011-02-02 17:12:46 +01:00
if ( Token : : simpleMatch ( tok , " if ( " ) )
2010-01-16 08:47:46 +01:00
{
2010-08-28 11:23:23 +02:00
const Token * tok1 = tok - > tokAt ( 2 ) ;
const Token * tok2 = tok - > tokAt ( 1 ) - > link ( ) ;
2010-01-16 08:47:46 +01:00
2010-04-02 07:30:58 +02:00
if ( tok1 & & tok2 )
2010-01-16 08:47:46 +01:00
{
2010-04-02 07:30:58 +02:00
for ( ; tok1 & & tok1 ! = tok2 ; tok1 = tok1 - > next ( ) )
2010-01-16 08:47:46 +01:00
{
2010-04-02 07:30:58 +02:00
if ( Token : : Match ( tok1 , " this ==|!= & %var% " ) )
2010-01-16 08:47:46 +01:00
{
2010-04-02 07:30:58 +02:00
if ( tok1 - > tokAt ( 3 ) - > str ( ) = = rhs - > str ( ) )
2010-01-16 08:47:46 +01:00
return true ;
}
2010-04-02 07:30:58 +02:00
else if ( Token : : Match ( tok1 , " & %var% ==|!= this " ) )
2010-01-16 08:47:46 +01:00
{
2010-04-02 07:30:58 +02:00
if ( tok1 - > tokAt ( 1 ) - > str ( ) = = rhs - > str ( ) )
2010-01-16 08:47:46 +01:00
return true ;
}
}
}
}
}
return false ;
}
2010-11-14 06:50:33 +01:00
void CheckClass : : operatorEqToSelfError ( const Token * tok )
2010-01-16 08:47:46 +01:00
{
2010-11-14 06:50:33 +01:00
reportError ( tok , Severity : : warning , " operatorEqToSelf " , " 'operator=' should check for assignment to self " ) ;
2010-01-16 08:47:46 +01:00
}
//---------------------------------------------------------------------------
// A destructor in a base class should be virtual
//---------------------------------------------------------------------------
void CheckClass : : virtualDestructor ( )
{
2010-05-29 11:19:28 +02:00
// This error should only be given if:
// * base class doesn't have virtual destructor
// * derived class has non-empty destructor
// * base class is deleted
if ( ! _settings - > inconclusive )
return ;
2010-08-13 18:34:02 +02:00
createSymbolDatabase ( ) ;
2011-03-11 01:43:29 +01:00
std : : list < Scope > : : const_iterator scope ;
2010-01-16 08:47:46 +01:00
2011-03-11 01:43:29 +01:00
for ( scope = symbolDatabase - > scopeList . begin ( ) ; scope ! = symbolDatabase - > scopeList . end ( ) ; + + scope )
2010-01-16 08:47:46 +01:00
{
2010-08-13 18:34:02 +02:00
// Skip base classes and namespaces
2011-01-17 18:29:19 +01:00
if ( scope - > derivedFrom . empty ( ) )
2010-08-13 18:34:02 +02:00
continue ;
2010-01-16 08:47:46 +01:00
2010-08-13 18:34:02 +02:00
// Find the destructor
2011-01-17 18:29:19 +01:00
const Function * destructor = scope - > getDestructor ( ) ;
2010-08-13 18:34:02 +02:00
// Check for destructor with implementation
if ( ! destructor | | ! destructor - > hasBody )
continue ;
// Empty destructor
2010-09-10 07:02:49 +02:00
if ( destructor - > token - > tokAt ( 3 ) - > link ( ) = = destructor - > token - > tokAt ( 4 ) )
2010-08-13 18:34:02 +02:00
continue ;
2010-01-16 08:47:46 +01:00
2011-01-17 18:29:19 +01:00
const Token * derived = scope - > classDef ;
2010-01-16 08:47:46 +01:00
const Token * derivedClass = derived - > tokAt ( 1 ) ;
// Iterate through each base class...
2011-01-17 18:29:19 +01:00
for ( unsigned int j = 0 ; j < scope - > derivedFrom . size ( ) ; + + j )
2010-01-16 08:47:46 +01:00
{
2010-08-13 18:34:02 +02:00
// Check if base class is public and exists in database
2011-01-21 07:42:41 +01:00
if ( scope - > derivedFrom [ j ] . access ! = Private & & scope - > derivedFrom [ j ] . scope )
2010-01-16 08:47:46 +01:00
{
2011-01-21 07:42:41 +01:00
const Scope * derivedFrom = scope - > derivedFrom [ j ] . scope ;
2010-01-16 08:47:46 +01:00
2010-08-13 23:57:53 +02:00
// Name of base class..
2011-01-21 07:42:41 +01:00
const std : : string baseName = derivedFrom - > className ;
2010-01-16 08:47:46 +01:00
2010-08-13 23:57:53 +02:00
// Find the destructor declaration for the base class.
2011-01-21 07:42:41 +01:00
const Function * base_destructor = derivedFrom - > getDestructor ( ) ;
2010-08-13 23:57:53 +02:00
const Token * base = 0 ;
if ( base_destructor )
base = base_destructor - > token ;
2010-01-16 08:47:46 +01:00
2010-08-13 23:57:53 +02:00
// Check that there is a destructor..
if ( ! base_destructor )
{
2011-01-21 07:42:41 +01:00
if ( derivedFrom - > derivedFrom . empty ( ) )
virtualDestructorError ( derivedFrom - > classDef , baseName , derivedClass - > str ( ) ) ;
2010-08-13 23:57:53 +02:00
}
else if ( ! base_destructor - > isVirtual )
{
// TODO: This is just a temporary fix, better solution is needed.
// Skip situations where base class has base classes of its own, because
// some of the base classes might have virtual destructor.
// Proper solution is to check all of the base classes. If base class is not
// found or if one of the base classes has virtual destructor, error should not
// be printed. See TODO test case "virtualDestructorInherited"
2011-01-21 07:42:41 +01:00
if ( derivedFrom - > derivedFrom . empty ( ) )
2010-08-13 23:57:53 +02:00
{
// Make sure that the destructor is public (protected or private
// would not compile if inheritance is used in a way that would
// cause the bug we are trying to find here.)
2011-01-17 07:21:59 +01:00
if ( base_destructor - > access = = Public )
2010-08-13 23:57:53 +02:00
virtualDestructorError ( base , baseName , derivedClass - > str ( ) ) ;
}
}
}
2010-01-16 08:47:46 +01:00
}
}
}
2010-11-14 06:50:33 +01:00
void CheckClass : : virtualDestructorError ( const Token * tok , const std : : string & Base , const std : : string & Derived )
2010-01-16 08:47:46 +01:00
{
2010-11-14 06:50:33 +01:00
reportError ( tok , Severity : : error , " virtualDestructor " , " Class " + Base + " which is inherited by class " + Derived + " does not have a virtual destructor " ) ;
2010-01-16 08:47:46 +01:00
}
2010-11-14 06:50:33 +01:00
//---------------------------------------------------------------------------
// warn for "this-x". The indented code may be "this->x"
//---------------------------------------------------------------------------
2010-01-16 08:47:46 +01:00
void CheckClass : : thisSubtraction ( )
{
2010-05-01 21:43:47 +02:00
if ( ! _settings - > _checkCodingStyle )
2010-04-21 08:38:25 +02:00
return ;
2010-01-16 08:47:46 +01:00
const Token * tok = _tokenizer - > tokens ( ) ;
2010-04-02 07:30:58 +02:00
for ( ; ; )
2010-01-16 08:47:46 +01:00
{
tok = Token : : findmatch ( tok , " this - %var% " ) ;
2010-04-02 07:30:58 +02:00
if ( ! tok )
2010-01-16 08:47:46 +01:00
break ;
2010-04-02 07:30:58 +02:00
if ( ! Token : : simpleMatch ( tok - > previous ( ) , " * " ) )
2010-01-16 08:47:46 +01:00
thisSubtractionError ( tok ) ;
tok = tok - > next ( ) ;
}
}
2010-11-14 06:50:33 +01:00
void CheckClass : : thisSubtractionError ( const Token * tok )
{
reportError ( tok , Severity : : warning , " thisSubtraction " , " Suspicious pointer subtraction " ) ;
}
//---------------------------------------------------------------------------
// can member function be const?
2010-03-05 17:06:25 +01:00
//---------------------------------------------------------------------------
2010-01-16 08:47:46 +01:00
2010-01-23 09:19:22 +01:00
void CheckClass : : checkConst ( )
{
2011-01-05 21:20:21 +01:00
if ( ! _settings - > isEnabled ( " information " ) | | _settings - > ifcfg )
2010-01-23 09:38:35 +01:00
return ;
2010-10-20 22:15:35 +02:00
// Don't check C# and JAVA classes
2010-10-28 18:51:55 +02:00
if ( _tokenizer - > isJavaOrCSharp ( ) )
2010-10-20 22:15:35 +02:00
{
return ;
}
2010-08-07 12:41:11 +02:00
createSymbolDatabase ( ) ;
2011-03-11 01:43:29 +01:00
std : : list < Scope > : : const_iterator scope ;
2010-01-23 09:19:22 +01:00
2011-03-11 01:43:29 +01:00
for ( scope = symbolDatabase - > scopeList . begin ( ) ; scope ! = symbolDatabase - > scopeList . end ( ) ; + + scope )
2010-07-26 16:46:37 +02:00
{
2010-11-20 07:26:50 +01:00
// only check classes and structures
2011-01-17 18:29:19 +01:00
if ( ! scope - > isClassOrStruct ( ) )
2010-11-20 07:26:50 +01:00
continue ;
2011-01-17 18:29:19 +01:00
std : : list < Function > : : const_iterator func ;
2010-03-05 17:06:25 +01:00
2011-01-17 18:29:19 +01:00
for ( func = scope - > functionList . begin ( ) ; func ! = scope - > functionList . end ( ) ; + + func )
2010-07-26 16:46:37 +02:00
{
// does the function have a body?
2011-01-17 18:29:19 +01:00
if ( func - > type = = Function : : eFunction & & func - > hasBody & & ! func - > isFriend & & ! func - > isStatic & & ! func - > isConst & & ! func - > isVirtual )
2010-03-12 18:30:20 +01:00
{
2010-07-26 16:46:37 +02:00
// get last token of return type
2010-11-02 18:28:55 +01:00
const Token * previous = func - > tokenDef - > isName ( ) ? func - > token - > previous ( ) : func - > token - > tokAt ( - 2 ) ;
2010-11-20 07:26:50 +01:00
while ( previous & & previous - > str ( ) = = " :: " )
2010-07-26 16:46:37 +02:00
previous = previous - > tokAt ( - 2 ) ;
2010-03-12 18:30:20 +01:00
2010-07-26 16:46:37 +02:00
// does the function return a pointer or reference?
if ( Token : : Match ( previous , " *|& " ) )
{
2010-11-02 18:28:55 +01:00
const Token * temp = func - > token - > previous ( ) ;
2010-01-23 09:19:22 +01:00
2010-07-26 16:46:37 +02:00
while ( ! Token : : Match ( temp - > previous ( ) , " ;|}|{|public:|protected:|private: " ) )
temp = temp - > previous ( ) ;
2010-01-24 13:45:56 +01:00
2010-07-26 16:46:37 +02:00
if ( temp - > str ( ) ! = " const " )
2010-03-19 17:40:23 +01:00
continue ;
}
2010-07-26 16:46:37 +02:00
else if ( Token : : Match ( previous - > previous ( ) , " *|& > " ) )
2010-04-09 19:15:39 +02:00
{
2010-11-02 18:28:55 +01:00
const Token * temp = func - > token - > previous ( ) ;
2010-07-26 16:46:37 +02:00
while ( ! Token : : Match ( temp - > previous ( ) , " ;|}|{|public:|protected:|private: " ) )
2010-04-09 19:15:39 +02:00
{
2010-07-26 16:46:37 +02:00
temp = temp - > previous ( ) ;
if ( temp - > str ( ) = = " const " )
2010-04-09 19:15:39 +02:00
break ;
}
2010-07-26 16:46:37 +02:00
if ( temp - > str ( ) ! = " const " )
2010-04-09 19:15:39 +02:00
continue ;
}
2010-07-26 16:46:37 +02:00
else
2010-01-23 09:19:22 +01:00
{
2010-07-26 16:46:37 +02:00
// don't warn for unknown types..
// LPVOID, HDC, etc
if ( previous - > isName ( ) )
2010-03-05 17:06:25 +01:00
{
2010-07-26 16:46:37 +02:00
bool allupper = true ;
const std : : string s ( previous - > str ( ) ) ;
for ( std : : string : : size_type pos = 0 ; pos < s . size ( ) ; + + pos )
2010-07-18 10:18:41 +02:00
{
2010-08-06 21:02:43 +02:00
const char ch = s [ pos ] ;
2010-07-26 16:46:37 +02:00
if ( ! ( ch = = ' _ ' | | ( ch > = ' A ' & & ch < = ' Z ' ) ) )
2010-01-23 09:19:22 +01:00
{
2010-07-26 16:46:37 +02:00
allupper = false ;
break ;
2010-01-23 20:59:20 +01:00
}
2010-03-05 17:06:25 +01:00
}
2010-07-26 16:46:37 +02:00
2010-09-06 19:04:14 +02:00
if ( allupper & & previous - > str ( ) . size ( ) > 2 )
2010-07-26 16:46:37 +02:00
continue ;
2010-03-05 17:06:25 +01:00
}
}
2010-01-23 20:59:20 +01:00
2011-01-01 17:54:37 +01:00
const Token * paramEnd = func - > arg - > link ( ) ;
2010-03-05 17:06:25 +01:00
2010-07-26 16:46:37 +02:00
// check if base class function is virtual
2011-01-17 18:29:19 +01:00
if ( ! scope - > derivedFrom . empty ( ) )
2010-03-05 17:06:25 +01:00
{
2011-03-11 01:43:29 +01:00
if ( isVirtualFunc ( & ( * scope ) , func - > tokenDef ) )
2010-07-26 16:46:37 +02:00
continue ;
2010-01-23 09:19:22 +01:00
}
2010-03-05 17:06:25 +01:00
2010-07-26 16:46:37 +02:00
// if nothing non-const was found. write error..
2011-03-11 01:43:29 +01:00
if ( checkConstFunc ( & ( * scope ) , paramEnd ) )
2010-03-28 11:46:42 +02:00
{
2011-01-17 18:29:19 +01:00
std : : string classname = scope - > className ;
const Scope * nest = scope - > nestedIn ;
while ( nest & & nest - > type ! = Scope : : eGlobal )
2010-03-28 11:46:42 +02:00
{
2010-07-26 16:46:37 +02:00
classname = std : : string ( nest - > className + " :: " + classname ) ;
2010-08-28 11:23:23 +02:00
nest = nest - > nestedIn ;
2010-03-28 11:46:42 +02:00
}
2010-04-18 15:40:31 +02:00
2010-09-01 06:32:46 +02:00
// get function name
2010-11-02 18:28:55 +01:00
std : : string functionName ( ( func - > tokenDef - > isName ( ) ? " " : " operator " ) + func - > tokenDef - > str ( ) ) ;
2010-09-01 06:32:46 +02:00
2010-11-02 18:28:55 +01:00
if ( func - > tokenDef - > str ( ) = = " ( " )
2010-09-01 06:32:46 +02:00
functionName + = " ) " ;
2010-11-02 18:28:55 +01:00
else if ( func - > tokenDef - > str ( ) = = " [ " )
2010-09-01 06:32:46 +02:00
functionName + = " ] " ;
2010-11-02 18:28:55 +01:00
if ( func - > isInline )
checkConstError ( func - > token , classname , functionName ) ;
2010-07-26 16:46:37 +02:00
else // not inline
2010-11-02 18:28:55 +01:00
checkConstError2 ( func - > token , func - > tokenDef , classname , functionName ) ;
2010-04-18 15:40:31 +02:00
}
2010-03-28 11:46:42 +02:00
}
}
}
}
2011-01-17 18:29:19 +01:00
bool CheckClass : : isMemberVar ( const Scope * scope , const Token * tok )
2011-01-16 11:18:12 +01:00
{
const Token * tok1 = tok ;
2011-02-21 02:01:54 +01:00
while ( tok - > previous ( ) & & ! Token : : Match ( tok - > previous ( ) , " }|{|;(||public:|protected:|private:|return|:|? " ) )
2011-01-16 11:18:12 +01:00
{
2011-02-02 17:12:46 +01:00
if ( Token : : simpleMatch ( tok - > previous ( ) , " * this " ) )
2011-01-16 11:18:12 +01:00
return true ;
tok = tok - > previous ( ) ;
}
if ( tok - > str ( ) = = " this " )
return true ;
if ( Token : : Match ( tok , " ( * %var% ) [ " ) | | ( Token : : Match ( tok , " ( * %var% ) << " ) & & tok1 - > next ( ) - > str ( ) = = " << " ) )
tok = tok - > tokAt ( 2 ) ;
// ignore class namespace
2011-01-17 18:29:19 +01:00
if ( tok - > str ( ) = = scope - > className & & tok - > next ( ) - > str ( ) = = " :: " )
2011-01-16 11:18:12 +01:00
tok = tok - > tokAt ( 2 ) ;
2011-01-17 18:29:19 +01:00
std : : list < Variable > : : const_iterator var ;
for ( var = scope - > varlist . begin ( ) ; var ! = scope - > varlist . end ( ) ; + + var )
2011-01-16 11:18:12 +01:00
{
2011-01-18 07:32:06 +01:00
if ( var - > name ( ) = = tok - > str ( ) )
2011-01-16 11:18:12 +01:00
{
2011-01-18 07:32:06 +01:00
return ! var - > isMutable ( ) ;
2011-01-16 11:18:12 +01:00
}
}
// not found in this class
2011-01-17 18:29:19 +01:00
if ( ! scope - > derivedFrom . empty ( ) )
2011-01-16 11:18:12 +01:00
{
// check each base class
2011-01-17 18:29:19 +01:00
for ( unsigned int i = 0 ; i < scope - > derivedFrom . size ( ) ; + + i )
2011-01-16 11:18:12 +01:00
{
// find the base class
2011-01-21 07:42:41 +01:00
const Scope * derivedFrom = scope - > derivedFrom [ i ] . scope ;
2011-01-16 11:18:12 +01:00
// find the function in the base class
2011-01-21 07:42:41 +01:00
if ( derivedFrom )
2011-01-16 11:18:12 +01:00
{
2011-01-21 07:42:41 +01:00
if ( isMemberVar ( derivedFrom , tok ) )
2011-01-16 11:18:12 +01:00
return true ;
}
}
}
return false ;
}
2011-01-17 18:29:19 +01:00
bool CheckClass : : isConstMemberFunc ( const Scope * scope , const Token * tok )
2011-01-16 11:18:12 +01:00
{
2011-01-17 18:29:19 +01:00
std : : list < Function > : : const_iterator func ;
2011-01-16 11:18:12 +01:00
2011-01-17 18:29:19 +01:00
for ( func = scope - > functionList . begin ( ) ; func ! = scope - > functionList . end ( ) ; + + func )
2011-01-16 11:18:12 +01:00
{
if ( func - > tokenDef - > str ( ) = = tok - > str ( ) & & func - > isConst )
return true ;
}
// not found in this class
2011-01-17 18:29:19 +01:00
if ( ! scope - > derivedFrom . empty ( ) )
2011-01-16 11:18:12 +01:00
{
// check each base class
2011-01-17 18:29:19 +01:00
for ( unsigned int i = 0 ; i < scope - > derivedFrom . size ( ) ; + + i )
2011-01-16 11:18:12 +01:00
{
// find the base class
2011-01-21 07:42:41 +01:00
const Scope * derivedFrom = scope - > derivedFrom [ i ] . scope ;
2011-01-16 11:18:12 +01:00
// find the function in the base class
2011-01-21 07:42:41 +01:00
if ( derivedFrom )
2011-01-16 11:18:12 +01:00
{
2011-01-21 07:42:41 +01:00
if ( isConstMemberFunc ( derivedFrom , tok ) )
2011-01-16 11:18:12 +01:00
return true ;
}
}
}
return false ;
}
2011-01-17 18:29:19 +01:00
bool CheckClass : : checkConstFunc ( const Scope * scope , const Token * tok )
2011-01-16 11:18:12 +01:00
{
// if the function doesn't have any assignment nor function call,
// it can be a const function..
unsigned int indentlevel = 0 ;
bool isconst = true ;
for ( const Token * tok1 = tok ; tok1 ; tok1 = tok1 - > next ( ) )
{
if ( tok1 - > str ( ) = = " { " )
+ + indentlevel ;
else if ( tok1 - > str ( ) = = " } " )
{
if ( indentlevel < = 1 )
break ;
- - indentlevel ;
}
// assignment.. = += |= ..
else if ( tok1 - > str ( ) = = " = " | |
( tok1 - > str ( ) . find ( " = " ) = = 1 & &
tok1 - > str ( ) . find_first_of ( " <!> " ) = = std : : string : : npos ) )
{
2011-01-17 18:29:19 +01:00
if ( tok1 - > previous ( ) - > varId ( ) = = 0 & & ! scope - > derivedFrom . empty ( ) )
2011-01-16 11:18:12 +01:00
{
isconst = false ;
break ;
}
2011-01-17 18:29:19 +01:00
else if ( isMemberVar ( scope , tok1 - > previous ( ) ) )
2011-01-16 11:18:12 +01:00
{
isconst = false ;
break ;
}
else if ( tok1 - > previous ( ) - > str ( ) = = " ] " )
{
// TODO: I assume that the assigned variable is a member variable
// don't assume it
isconst = false ;
break ;
}
else if ( tok1 - > next ( ) - > str ( ) = = " this " )
{
isconst = false ;
break ;
}
// FIXME: I assume that a member union/struct variable is assigned.
else if ( Token : : Match ( tok1 - > tokAt ( - 2 ) , " . %var% " ) )
{
isconst = false ;
break ;
}
}
// streaming: <<
2011-01-17 18:29:19 +01:00
else if ( tok1 - > str ( ) = = " << " & & isMemberVar ( scope , tok1 - > previous ( ) ) )
2011-01-16 11:18:12 +01:00
{
isconst = false ;
break ;
}
2011-02-21 02:01:54 +01:00
else if ( Token : : simpleMatch ( tok1 - > previous ( ) , " ) << " ) & &
isMemberVar ( scope , tok1 - > tokAt ( - 2 ) ) )
{
isconst = false ;
break ;
}
2011-01-16 11:18:12 +01:00
// increment/decrement (member variable?)..
else if ( Token : : Match ( tok1 , " ++|-- " ) )
{
2011-03-20 18:29:52 +01:00
if ( Token : : Match ( tok1 - > previous ( ) , " %var% " ) & &
tok1 - > previous ( ) - > str ( ) ! = " return " )
{
if ( isMemberVar ( scope , tok1 - > previous ( ) ) )
isconst = false ;
}
else if ( Token : : Match ( tok1 - > next ( ) , " %var% " ) )
{
if ( isMemberVar ( scope , tok1 - > next ( ) ) )
isconst = false ;
}
2011-01-16 11:18:12 +01:00
break ;
}
// function call..
else if ( Token : : Match ( tok1 , " %var% ( " ) & &
! ( Token : : Match ( tok1 , " return|c_str|if|string " ) | | tok1 - > isStandardType ( ) ) )
{
2011-01-17 18:29:19 +01:00
if ( ! isConstMemberFunc ( scope , tok1 ) )
2011-01-16 11:18:12 +01:00
{
isconst = false ;
break ;
}
}
else if ( Token : : Match ( tok1 , " %var% < %any% > ( " ) )
{
isconst = false ;
break ;
}
// delete..
else if ( tok1 - > str ( ) = = " delete " )
{
isconst = false ;
break ;
}
}
return isconst ;
}
//---------------------------------------------------------------------------
// check if this function is defined virtual in the base classes
2011-01-17 18:29:19 +01:00
bool CheckClass : : isVirtualFunc ( const Scope * scope , const Token * functionToken ) const
2011-01-16 11:18:12 +01:00
{
// check each base class
2011-01-17 18:29:19 +01:00
for ( unsigned int i = 0 ; i < scope - > derivedFrom . size ( ) ; + + i )
2011-01-16 11:18:12 +01:00
{
// check if base class exists in database
2011-01-21 07:42:41 +01:00
if ( scope - > derivedFrom [ i ] . scope )
2011-01-16 11:18:12 +01:00
{
2011-01-21 07:42:41 +01:00
const Scope * derivedFrom = scope - > derivedFrom [ i ] . scope ;
2011-01-16 11:18:12 +01:00
2011-01-17 18:29:19 +01:00
std : : list < Function > : : const_iterator func ;
2011-01-16 11:18:12 +01:00
// check if function defined in base class
for ( func = derivedFrom - > functionList . begin ( ) ; func ! = derivedFrom - > functionList . end ( ) ; + + func )
{
if ( func - > isVirtual )
{
const Token * tok = func - > tokenDef ;
if ( tok - > str ( ) = = functionToken - > str ( ) )
{
const Token * temp1 = tok - > previous ( ) ;
const Token * temp2 = functionToken - > previous ( ) ;
bool returnMatch = true ;
// check for matching return parameters
while ( temp1 - > str ( ) ! = " virtual " )
{
if ( temp1 - > str ( ) ! = temp2 - > str ( ) )
{
returnMatch = false ;
break ;
}
temp1 = temp1 - > previous ( ) ;
temp2 = temp2 - > previous ( ) ;
}
// check for matching function parameters
2011-01-17 18:29:19 +01:00
if ( returnMatch & & symbolDatabase - > argsMatch ( scope , tok - > tokAt ( 2 ) , functionToken - > tokAt ( 2 ) , std : : string ( " " ) , 0 ) )
2011-01-16 11:18:12 +01:00
{
return true ;
}
}
}
}
if ( ! derivedFrom - > derivedFrom . empty ( ) )
{
if ( isVirtualFunc ( derivedFrom , functionToken ) )
return true ;
}
}
else
{
// unable to find base class so assume it has a virtual function
return true ;
}
}
return false ;
}
2010-01-23 09:19:22 +01:00
void CheckClass : : checkConstError ( const Token * tok , const std : : string & classname , const std : : string & funcname )
{
2010-12-26 22:34:00 +01:00
reportError ( tok , Severity : : information , " functionConst " ,
" Technically the member function ' " + classname + " :: " + funcname + " ' can be const. \n "
" The member function ' " + classname + " :: " + funcname + " ' can be made a const "
" function. Making this function const function should not cause compiler errors. "
" Even though the function can be made const function technically it may not make "
" sense conceptually. Think about your design and task of the function first - is "
" it a function that must not change object internal state? " ) ;
2010-01-23 09:19:22 +01:00
}
2010-03-10 07:47:01 +01:00
void CheckClass : : checkConstError2 ( const Token * tok1 , const Token * tok2 , const std : : string & classname , const std : : string & funcname )
{
std : : list < const Token * > toks ;
toks . push_back ( tok1 ) ;
toks . push_back ( tok2 ) ;
2010-12-26 22:34:00 +01:00
reportError ( toks , Severity : : information , " functionConst " ,
" Technically the member function ' " + classname + " :: " + funcname + " ' can be const. \n "
" The member function ' " + classname + " :: " + funcname + " ' can be made a const "
" function. Making this function const function should not cause compiler errors. "
" Even though the function can be made const function technically it may not make "
" sense conceptually. Think about your design and task of the function first - is "
" it a function that must not change object internal state? " ) ;
2010-03-10 07:47:01 +01:00
}