2010-01-16 08:47:46 +01:00
/*
* Cppcheck - A tool for static C / C + + code analysis
2022-02-05 11:45:17 +01:00
* Copyright ( C ) 2007 - 2022 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"
2018-04-22 07:40:11 +02:00
# include "astutils.h"
2017-05-27 04:33:47 +02:00
# include "library.h"
# include "settings.h"
# include "standards.h"
2010-11-13 07:31:56 +01:00
# include "symboldatabase.h"
2021-02-09 21:35:08 +01:00
# include "errorlogger.h"
2020-05-23 07:16:49 +02:00
# include "errortypes.h"
2022-01-27 19:03:20 +01:00
# include "mathlib.h"
2017-05-27 04:33:47 +02:00
# include "token.h"
# include "tokenize.h"
2022-01-27 19:03:20 +01:00
# include "tokenlist.h"
2015-11-29 10:49:10 +01:00
# include "utils.h"
2010-01-16 08:47:46 +01:00
# include <algorithm>
2022-01-27 19:03:20 +01:00
# include <cctype>
2017-05-27 04:33:47 +02:00
# include <cstdlib>
2022-01-27 19:03:20 +01:00
# include <cstring>
# include <memory>
2017-05-27 04:33:47 +02:00
# include <utility>
2022-01-27 19:03:20 +01:00
# include <unordered_map>
# include <tinyxml2.h>
namespace CTU {
class FileInfo ;
}
2010-01-16 08:47:46 +01:00
//---------------------------------------------------------------------------
// Register CheckClass..
2011-10-13 20:53:06 +02:00
namespace {
CheckClass instance ;
2016-01-25 20:01:48 +01:00
}
2013-03-30 15:09:22 +01:00
2016-08-24 12:43:45 +02:00
static const CWE CWE398 ( 398U ) ; // Indicator of Poor Code Quality
static const CWE CWE404 ( 404U ) ; // Improper Resource Shutdown or Release
static const CWE CWE665 ( 665U ) ; // Improper Initialization
static const CWE CWE758 ( 758U ) ; // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
static const CWE CWE762 ( 762U ) ; // Mismatched Memory Management Routines
2016-01-25 20:01:48 +01:00
2021-02-09 21:35:08 +01:00
static const CWE CWE_ONE_DEFINITION_RULE ( 758U ) ;
2016-05-16 09:36:26 +02:00
static const char * getFunctionTypeName ( Function : : Type type )
2016-01-25 20:01:48 +01:00
{
switch ( type ) {
case Function : : eConstructor :
return " constructor " ;
case Function : : eCopyConstructor :
return " copy constructor " ;
case Function : : eMoveConstructor :
return " move constructor " ;
case Function : : eDestructor :
return " destructor " ;
case Function : : eFunction :
return " function " ;
case Function : : eOperatorEqual :
return " operator= " ;
2019-07-11 08:25:25 +02:00
case Function : : eLambda :
return " lambda " ;
2013-03-30 15:09:22 +01:00
}
2016-01-25 20:01:48 +01:00
return " " ;
}
2013-03-30 15:09:22 +01:00
2022-02-27 19:15:19 +01:00
static bool isVariableCopyNeeded ( const Variable & var , Function : : Type type )
2018-06-27 14:02:57 +02:00
{
2022-02-27 19:15:19 +01:00
bool isOpEqual = false ;
switch ( type ) {
case Function : : eOperatorEqual :
isOpEqual = true ;
2022-03-13 20:07:58 +01:00
break ;
2022-02-27 19:15:19 +01:00
case Function : : eCopyConstructor :
case Function : : eMoveConstructor :
break ;
default :
return true ;
}
return ( ! var . hasDefault ( ) | | isOpEqual ) & & // default init does not matter for operator=
( var . isPointer ( ) | |
( var . type ( ) & & var . type ( ) - > needInitialization = = Type : : NeedInitialization : : True ) | |
( var . valueType ( ) & & var . valueType ( ) - > type > = ValueType : : Type : : CHAR ) ) ;
2018-06-27 14:02:57 +02:00
}
2021-06-13 18:56:04 +02:00
static bool isVcl ( const Settings * settings )
{
for ( const std : : string & library : settings - > libraries ) {
if ( library = = " vcl " )
return true ;
}
return false ;
}
static bool isVclTypeInit ( const Type * type )
{
if ( ! type )
return false ;
for ( const Type : : BaseInfo & baseInfo : type - > derivedFrom ) {
if ( ! baseInfo . type )
return true ;
if ( isVclTypeInit ( baseInfo . type ) )
return true ;
}
return false ;
}
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 ) ,
2021-08-07 20:51:18 +02:00
mSymbolDatabase ( tokenizer ? tokenizer - > getSymbolDatabase ( ) : nullptr )
{ }
2010-08-07 12:41:11 +02: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 ( )
{
2021-02-24 22:00:06 +01:00
const bool printStyle = mSettings - > severity . isEnabled ( Severity : : style ) ;
const bool printWarnings = mSettings - > severity . isEnabled ( Severity : : warning ) ;
2015-04-10 14:18:52 +02:00
if ( ! printStyle & & ! printWarnings )
2010-04-21 08:38:25 +02:00
return ;
2021-02-24 22:00:06 +01:00
const bool printInconclusive = mSettings - > certainty . isEnabled ( Certainty : : inconclusive ) ;
2018-06-17 18:43:54 +02:00
for ( const Scope * scope : mSymbolDatabase - > classAndStructScopes ) {
2021-06-13 18:56:04 +02:00
if ( isVcl ( mSettings ) & & isVclTypeInit ( scope - > definedType ) )
continue ;
2019-06-20 14:00:44 +02:00
const bool unusedTemplate = Token : : simpleMatch ( scope - > classDef - > previous ( ) , " > " ) ;
2010-08-09 17:50:26 +02:00
2016-05-25 19:05:16 +02:00
bool usedInUnion = false ;
2018-06-17 18:43:54 +02:00
for ( const Scope & unionScope : mSymbolDatabase - > scopeList ) {
2018-04-24 11:04:47 +02:00
if ( unionScope . type ! = Scope : : eUnion )
2016-05-25 19:05:16 +02:00
continue ;
2018-04-24 11:04:47 +02:00
for ( const Variable & var : unionScope . varlist ) {
if ( var . type ( ) & & var . type ( ) - > classScope = = scope ) {
2016-05-25 19:05:16 +02:00
usedInUnion = true ;
break ;
}
}
}
2010-07-26 16:46:37 +02:00
// There are no constructors.
2016-05-25 19:05:16 +02:00
if ( scope - > numConstructors = = 0 & & printStyle & & ! usedInUnion ) {
2010-07-26 16:46:37 +02:00
// If there is a private variable, there should be a constructor..
2022-03-07 08:39:19 +01:00
int needInit = 0 , haveInit = 0 ;
std : : vector < const Variable * > uninitVars ;
2018-04-24 11:04:47 +02:00
for ( const Variable & var : scope - > varlist ) {
2022-03-07 08:39:19 +01:00
if ( var . isPrivate ( ) & & ! var . isStatic ( ) & &
2019-08-02 21:14:29 +02:00
( ! var . isClass ( ) | | ( var . type ( ) & & var . type ( ) - > needInitialization = = Type : : NeedInitialization : : True ) ) ) {
2022-03-07 08:39:19 +01:00
+ + needInit ;
2022-03-23 07:35:41 +01:00
if ( ! var . isInit ( ) & & ! var . hasDefault ( ) & & var . nameToken ( ) - > scope ( ) = = scope ) // don't warn for anonymous union members
2022-03-07 08:39:19 +01:00
uninitVars . emplace_back ( & var ) ;
else
+ + haveInit ;
2010-01-16 08:47:46 +01:00
}
}
2022-03-07 08:39:19 +01:00
if ( needInit > haveInit ) {
if ( haveInit = = 0 )
noConstructorError ( scope - > classDef , scope - > className , scope - > classDef - > str ( ) = = " struct " ) ;
else
for ( const Variable * uv : uninitVars )
2022-03-13 17:33:31 +01:00
uninitVarError ( uv - > typeStartToken ( ) , uv - > scope ( ) - > className , uv - > name ( ) ) ;
2022-03-07 08:39:19 +01:00
}
2010-07-26 16:46:37 +02:00
}
2010-01-16 08:47:46 +01:00
2015-04-10 14:18:52 +02:00
if ( ! printWarnings )
2013-03-03 11:41:59 +01:00
continue ;
2011-11-22 19:26:00 +01:00
// #3196 => bailout if there are nested unions
// TODO: handle union variables better
{
bool bailout = false ;
2018-04-24 11:04:47 +02:00
for ( const Scope * const nestedScope : scope - > nestedList ) {
2011-11-22 19:26:00 +01:00
if ( nestedScope - > type = = Scope : : eUnion ) {
bailout = true ;
break ;
}
}
if ( bailout )
continue ;
}
2021-02-03 19:13:49 +01:00
std : : vector < Usage > usageList = createUsageList ( scope ) ;
2010-01-16 08:47:46 +01:00
2018-06-27 09:14:03 +02:00
for ( const Function & func : scope - > functionList ) {
2019-10-09 08:17:47 +02:00
if ( ! func . hasBody ( ) | | ! ( func . isConstructor ( ) | | func . type = = Function : : eOperatorEqual ) )
2010-07-26 16:46:37 +02:00
continue ;
2019-06-19 22:27:50 +02:00
// Bail: If initializer list is not recognized as a variable or type then skip since parsing is incomplete
2019-06-20 14:00:44 +02:00
if ( unusedTemplate & & func . type = = Function : : eConstructor ) {
2019-06-19 22:27:50 +02:00
const Token * initList = func . constructorMemberInitialization ( ) ;
if ( Token : : Match ( initList , " : %name% ( " ) & & initList - > next ( ) - > tokType ( ) = = Token : : eName )
break ;
}
2010-07-26 16:46:37 +02:00
// Mark all variables not used
2021-02-01 17:13:58 +01:00
clearAllVar ( usageList ) ;
2010-07-14 19:00:52 +02:00
2013-01-01 09:53:40 +01:00
std : : list < const Function * > callstack ;
2021-02-01 17:13:58 +01:00
initializeVarList ( func , callstack , scope , usageList ) ;
2010-07-14 19:00:52 +02:00
2010-07-26 16:46:37 +02:00
// Check if any variables are uninitialized
2021-02-01 17:13:58 +01:00
for ( Usage & usage : usageList ) {
const Variable & var = * usage . var ;
2018-06-27 09:14:03 +02:00
2013-02-18 06:33:53 +01:00
// check for C++11 initializer
2022-02-27 19:15:19 +01:00
if ( var . hasDefault ( ) & & func . type ! = Function : : eOperatorEqual & & func . type ! = Function : : eCopyConstructor ) { // variable still needs to be copied
2021-02-01 17:13:58 +01:00
usage . init = true ;
2014-07-08 10:28:57 +02:00
continue ;
}
2013-02-18 06:33:53 +01:00
2021-02-01 17:13:58 +01:00
if ( usage . assign | | usage . init | | var . isStatic ( ) )
2010-07-26 16:46:37 +02:00
continue ;
2010-07-15 10:16:16 +02:00
2021-01-31 12:14:10 +01:00
if ( var . valueType ( ) & & var . valueType ( ) - > pointer = = 0 & & var . type ( ) & & var . type ( ) - > needInitialization = = Type : : NeedInitialization : : False & & var . type ( ) - > derivedFrom . empty ( ) )
2018-06-27 14:02:57 +02:00
continue ;
2018-06-27 09:14:03 +02:00
if ( var . isConst ( ) & & func . isOperator ( ) ) // We can't set const members in assignment operator
2010-11-16 07:30:55 +01:00
continue ;
2010-12-02 07:35:01 +01:00
// Check if this is a class constructor
2018-06-27 09:14:03 +02:00
if ( ! var . isPointer ( ) & & ! var . isPointerArray ( ) & & var . isClass ( ) & & func . type = = Function : : eConstructor ) {
2010-12-02 07:35:01 +01:00
// Unknown type so assume it is initialized
2018-06-27 09:14:03 +02: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
2019-08-02 21:14:29 +02:00
else if ( var . type ( ) - > needInitialization ! = Type : : NeedInitialization : : 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
2018-06-27 09:14:03 +02:00
if ( ! var . isPointer ( ) & & ! var . isPointerArray ( ) & & var . typeScope ( ) ) {
if ( func . type = = Function : : eMoveConstructor ) {
if ( canNotMove ( var . typeScope ( ) ) )
2013-04-10 21:57:22 +02:00
continue ;
} else {
2018-06-27 09:14:03 +02:00
if ( canNotCopy ( var . typeScope ( ) ) )
2013-04-10 21:57:22 +02:00
continue ;
}
}
2011-01-18 07:34:11 +01:00
2022-02-02 20:44:10 +01:00
// Is there missing member copy in copy/move constructor or assignment operator?
bool missingCopy = false ;
2012-09-20 16:47:01 +02:00
// Don't warn about unknown types in copy constructors since we
// don't know if they can be copied or not..
2022-02-27 19:15:19 +01:00
if ( ! isVariableCopyNeeded ( var , func . type ) ) {
2022-02-02 20:44:10 +01:00
if ( ! printInconclusive )
continue ;
2018-06-27 14:02:57 +02:00
2022-02-02 20:44:10 +01:00
missingCopy = true ;
}
2012-09-20 16:47:01 +02:00
2010-07-26 16:46:37 +02:00
// It's non-static and it's not initialized => error
2018-06-27 09:14:03 +02:00
if ( func . type = = Function : : eOperatorEqual ) {
const Token * operStart = func . arg ;
2010-07-26 16:46:37 +02:00
bool classNameUsed = false ;
2011-10-13 20:53:06 +02:00
for ( const Token * operTok = operStart ; operTok ! = operStart - > link ( ) ; operTok = operTok - > next ( ) ) {
if ( operTok - > str ( ) = = scope - > className ) {
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
2022-03-03 09:41:26 +01:00
if ( classNameUsed & & mSettings - > library . getTypeCheck ( " operatorEqVarError " , var . getTypeName ( ) ) ! = Library : : TypeCheck : : suppress )
2022-02-02 20:44:10 +01:00
operatorEqVarError ( func . token , scope - > className , var . name ( ) , missingCopy ) ;
2019-07-23 14:29:02 +02:00
} else if ( func . access ! = AccessControl : : Private | | mSettings - > standards . cpp > = Standards : : CPP11 ) {
2019-11-01 16:39:53 +01:00
// If constructor is not in scope then we maybe using a constructor from a different template specialization
2019-05-17 20:24:41 +02:00
if ( ! precedes ( scope - > bodyStart , func . tokenDef ) )
continue ;
2018-06-27 09:14:03 +02:00
const Scope * varType = var . typeScope ( ) ;
2013-03-09 09:20:48 +01:00
if ( ! varType | | varType - > type ! = Scope : : eUnion ) {
2021-02-01 18:58:51 +01:00
const bool derived = scope ! = var . scope ( ) ;
2018-06-27 09:14:03 +02:00
if ( func . type = = Function : : eConstructor & &
func . nestedIn & & ( func . nestedIn - > numConstructors - func . nestedIn - > numCopyOrMoveConstructors ) > 1 & &
func . argCount ( ) = = 0 & & func . functionScope & &
func . arg & & func . arg - > link ( ) - > next ( ) = = func . functionScope - > bodyStart & &
func . functionScope - > bodyStart - > link ( ) = = func . functionScope - > bodyStart - > next ( ) ) {
2013-03-09 09:20:48 +01:00
// don't warn about user defined default constructor when there are other constructors
2015-04-10 14:18:52 +02:00
if ( printInconclusive )
2022-03-13 17:33:31 +01:00
uninitVarError ( func . token , func . access = = AccessControl : : Private , func . type , var . scope ( ) - > className , var . name ( ) , derived , true ) ;
2022-02-02 20:44:10 +01:00
} else if ( missingCopy )
2022-03-13 17:33:31 +01:00
missingMemberCopyError ( func . token , func . type , var . scope ( ) - > className , var . name ( ) ) ;
2022-02-02 20:44:10 +01:00
else
2022-03-13 17:33:31 +01:00
uninitVarError ( func . token , func . access = = AccessControl : : Private , func . type , var . scope ( ) - > className , var . name ( ) , derived , false ) ;
2013-03-09 09:20:48 +01:00
}
2012-01-08 12:17:55 +01:00
}
2010-07-15 10:16:16 +02:00
}
2010-07-14 19:00:52 +02:00
}
2010-01-16 08:47:46 +01:00
}
}
2015-03-07 20:07:54 +01:00
void CheckClass : : checkExplicitConstructors ( )
{
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > severity . isEnabled ( Severity : : style ) )
2015-03-07 20:07:54 +01:00
return ;
2018-06-17 18:43:54 +02:00
for ( const Scope * scope : mSymbolDatabase - > classAndStructScopes ) {
2015-03-07 20:07:54 +01:00
// Do not perform check, if the class/struct has not any constructors
if ( scope - > numConstructors = = 0 )
continue ;
// Is class abstract? Maybe this test is over-simplification, but it will suffice for simple cases,
// and it will avoid false positives.
bool isAbstractClass = false ;
2018-04-24 11:04:47 +02:00
for ( const Function & func : scope - > functionList ) {
if ( func . isPure ( ) ) {
2015-03-07 20:07:54 +01:00
isAbstractClass = true ;
break ;
}
}
2015-11-13 12:48:26 +01:00
// Abstract classes can't be instantiated. But if there is C++11
// "misuse" by derived classes then these constructors must be explicit.
2021-04-12 18:29:13 +02:00
if ( isAbstractClass & & mSettings - > standards . cpp > = Standards : : CPP11 )
2015-11-09 08:36:47 +01:00
continue ;
2018-04-24 11:04:47 +02:00
for ( const Function & func : scope - > functionList ) {
2015-03-07 20:07:54 +01:00
// We are looking for constructors, which are meeting following criteria:
2015-03-11 20:26:53 +01:00
// 1) Constructor is declared with a single parameter
2015-03-07 20:07:54 +01:00
// 2) Constructor is not declared as explicit
// 3) It is not a copy/move constructor of non-abstract class
// 4) Constructor is not marked as delete (programmer can mark the default constructor as deleted, which is ok)
2019-07-23 14:29:02 +02:00
if ( ! func . isConstructor ( ) | | func . isDelete ( ) | | ( ! func . hasBody ( ) & & func . access = = AccessControl : : Private ) )
2015-03-07 20:07:54 +01:00
continue ;
2018-04-24 11:04:47 +02:00
if ( ! func . isExplicit ( ) & &
2019-04-23 10:46:22 +02:00
func . minArgCount ( ) = = 1 & &
2018-04-24 11:04:47 +02:00
func . type ! = Function : : eCopyConstructor & &
func . type ! = Function : : eMoveConstructor ) {
noExplicitConstructorError ( func . tokenDef , scope - > className , scope - > type = = Scope : : eStruct ) ;
2015-03-07 20:07:54 +01:00
}
}
2015-11-14 19:59:22 +01:00
}
2015-03-07 20:07:54 +01:00
}
2021-04-09 07:41:59 +02:00
static bool hasNonCopyableBase ( const Scope * scope , bool * unknown )
2018-05-01 08:33:23 +02:00
{
// check if there is base class that is not copyable
for ( const Type : : BaseInfo & baseInfo : scope - > definedType - > derivedFrom ) {
2018-05-06 09:52:04 +02:00
if ( ! baseInfo . type | | ! baseInfo . type - > classScope ) {
2021-04-09 07:41:59 +02:00
* unknown = true ;
2018-05-01 08:33:23 +02:00
continue ;
}
2021-04-09 07:41:59 +02:00
if ( hasNonCopyableBase ( baseInfo . type - > classScope , unknown ) )
2018-06-06 16:02:25 +02:00
return true ;
2018-05-01 08:33:23 +02:00
for ( const Function & func : baseInfo . type - > classScope - > functionList ) {
if ( func . type ! = Function : : eCopyConstructor )
continue ;
2021-04-09 07:41:59 +02:00
if ( func . access = = AccessControl : : Private | | func . isDelete ( ) ) {
* unknown = false ;
2018-05-01 08:33:23 +02:00
return true ;
2021-04-09 07:41:59 +02:00
}
2018-05-01 08:33:23 +02:00
}
}
return false ;
}
2012-09-17 17:59:35 +02:00
void CheckClass : : copyconstructors ( )
{
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > severity . isEnabled ( Severity : : warning ) )
2012-09-17 17:59:35 +02:00
return ;
2018-06-17 18:43:54 +02:00
for ( const Scope * scope : mSymbolDatabase - > classAndStructScopes ) {
2019-07-16 09:03:45 +02:00
std : : map < int , const Token * > allocatedVars ;
2012-09-17 17:59:35 +02:00
2018-04-27 23:04:48 +02:00
for ( const Function & func : scope - > functionList ) {
if ( func . type ! = Function : : eConstructor | | ! func . functionScope )
continue ;
const Token * tok = func . token - > linkAt ( 1 ) ;
for ( const Token * const end = func . functionScope - > bodyStart ; tok ! = end ; tok = tok - > next ( ) ) {
2018-04-27 23:20:04 +02:00
if ( Token : : Match ( tok , " %var% ( new " ) | |
2019-07-05 12:44:52 +02:00
( Token : : Match ( tok , " %var% ( %name% ( " ) & & mSettings - > library . getAllocFuncInfo ( tok - > tokAt ( 2 ) ) ) ) {
2018-04-27 23:04:48 +02:00
const Variable * var = tok - > variable ( ) ;
if ( var & & var - > isPointer ( ) & & var - > scope ( ) = = scope )
allocatedVars [ tok - > varId ( ) ] = tok ;
2013-03-14 17:27:42 +01:00
}
2018-04-27 23:04:48 +02:00
}
for ( const Token * const end = func . functionScope - > bodyEnd ; tok ! = end ; tok = tok - > next ( ) ) {
2018-04-27 23:20:04 +02:00
if ( Token : : Match ( tok , " %var% = new " ) | |
2019-07-05 12:44:52 +02:00
( Token : : Match ( tok , " %var% = %name% ( " ) & & mSettings - > library . getAllocFuncInfo ( tok - > tokAt ( 2 ) ) ) ) {
2018-04-27 23:04:48 +02:00
const Variable * var = tok - > variable ( ) ;
if ( var & & var - > isPointer ( ) & & var - > scope ( ) = = scope & & ! var - > isStatic ( ) )
allocatedVars [ tok - > varId ( ) ] = tok ;
2012-09-17 17:59:35 +02:00
}
}
}
2018-04-30 23:13:08 +02:00
if ( ! allocatedVars . empty ( ) ) {
2018-05-04 14:58:38 +02:00
const Function * funcCopyCtor = nullptr ;
const Function * funcOperatorEq = nullptr ;
const Function * funcDestructor = nullptr ;
2018-04-30 23:13:08 +02:00
for ( const Function & func : scope - > functionList ) {
if ( func . type = = Function : : eCopyConstructor )
2018-05-04 14:58:38 +02:00
funcCopyCtor = & func ;
2018-04-30 23:13:08 +02:00
else if ( func . type = = Function : : eOperatorEqual )
2018-05-04 14:58:38 +02:00
funcOperatorEq = & func ;
2018-04-30 23:13:08 +02:00
else if ( func . type = = Function : : eDestructor )
2018-05-04 14:58:38 +02:00
funcDestructor = & func ;
2018-04-30 23:13:08 +02:00
}
2018-05-04 14:58:38 +02:00
if ( ! funcCopyCtor | | funcCopyCtor - > isDefault ( ) ) {
2018-05-01 08:33:23 +02:00
bool unknown = false ;
2021-04-09 07:41:59 +02:00
if ( ! hasNonCopyableBase ( scope , & unknown ) & & ! unknown )
2018-05-04 15:39:23 +02:00
noCopyConstructorError ( scope , funcCopyCtor , allocatedVars . begin ( ) - > second , unknown ) ;
2018-05-01 08:33:23 +02:00
}
2018-05-05 07:46:58 +02:00
if ( ! funcOperatorEq | | funcOperatorEq - > isDefault ( ) ) {
bool unknown = false ;
2021-04-09 07:41:59 +02:00
if ( ! hasNonCopyableBase ( scope , & unknown ) & & ! unknown )
2018-05-05 07:46:58 +02:00
noOperatorEqError ( scope , funcOperatorEq , allocatedVars . begin ( ) - > second , unknown ) ;
}
2018-05-04 14:58:38 +02:00
if ( ! funcDestructor | | funcDestructor - > isDefault ( ) ) {
2018-05-01 15:31:13 +02:00
const Token * mustDealloc = nullptr ;
2019-07-16 09:03:45 +02:00
for ( std : : map < int , const Token * > : : const_iterator it = allocatedVars . begin ( ) ; it ! = allocatedVars . end ( ) ; + + it ) {
2018-05-01 15:31:13 +02:00
if ( ! Token : : Match ( it - > second , " %var% [(=] new %type% " ) ) {
mustDealloc = it - > second ;
break ;
}
if ( it - > second - > valueType ( ) & & it - > second - > valueType ( ) - > isIntegral ( ) ) {
mustDealloc = it - > second ;
break ;
}
const Variable * var = it - > second - > variable ( ) ;
2019-12-31 16:32:45 +01:00
if ( var & & var - > typeScope ( ) & & var - > typeScope ( ) - > functionList . empty ( ) & & var - > type ( ) - > derivedFrom . empty ( ) ) {
2018-05-01 15:31:13 +02:00
mustDealloc = it - > second ;
2019-12-31 16:32:45 +01:00
break ;
}
2018-05-01 15:31:13 +02:00
}
if ( mustDealloc )
2018-05-04 15:39:23 +02:00
noDestructorError ( scope , funcDestructor , mustDealloc ) ;
2018-05-01 09:26:03 +02:00
}
2018-04-30 23:13:08 +02:00
}
2012-09-17 17:59:35 +02:00
std : : set < const Token * > copiedVars ;
2017-07-28 15:20:43 +02:00
const Token * copyCtor = nullptr ;
2018-04-27 22:18:26 +02:00
for ( const Function & func : scope - > functionList ) {
if ( func . type ! = Function : : eCopyConstructor )
continue ;
copyCtor = func . tokenDef ;
if ( ! func . functionScope ) {
allocatedVars . clear ( ) ;
break ;
}
const Token * tok = func . tokenDef - > linkAt ( 1 ) - > next ( ) ;
if ( tok - > str ( ) = = " : " ) {
tok = tok - > next ( ) ;
while ( Token : : Match ( tok , " %name% ( " ) ) {
if ( allocatedVars . find ( tok - > varId ( ) ) ! = allocatedVars . end ( ) ) {
if ( tok - > varId ( ) & & Token : : Match ( tok - > tokAt ( 2 ) , " %name% . %name% ) " ) )
2012-09-17 17:59:35 +02:00
copiedVars . insert ( tok ) ;
2018-04-27 22:18:26 +02:00
else if ( ! Token : : Match ( tok - > tokAt ( 2 ) , " %any% ) " ) )
allocatedVars . erase ( tok - > varId ( ) ) ; // Assume memory is allocated
2012-09-17 17:59:35 +02:00
}
2018-04-27 22:18:26 +02:00
tok = tok - > linkAt ( 1 ) - > tokAt ( 2 ) ;
}
}
2018-04-27 22:36:30 +02:00
for ( tok = func . functionScope - > bodyStart ; tok ! = func . functionScope - > bodyEnd ; tok = tok - > next ( ) ) {
2018-04-27 22:18:26 +02:00
if ( Token : : Match ( tok , " %var% = new|malloc|g_malloc|g_try_malloc|realloc|g_realloc|g_try_realloc " ) ) {
allocatedVars . erase ( tok - > varId ( ) ) ;
} else if ( Token : : Match ( tok , " %var% = %name% . %name% ; " ) & & allocatedVars . find ( tok - > varId ( ) ) ! = allocatedVars . end ( ) ) {
copiedVars . insert ( tok ) ;
}
2012-09-17 17:59:35 +02:00
}
2018-04-27 22:18:26 +02:00
break ;
2012-09-17 17:59:35 +02:00
}
2018-04-30 23:13:08 +02:00
if ( copyCtor & & ! copiedVars . empty ( ) ) {
2018-07-13 23:32:49 +02:00
for ( const Token * cv : copiedVars )
copyConstructorShallowCopyError ( cv , cv - > str ( ) ) ;
2012-09-17 17:59:35 +02:00
// throw error if count mismatch
2012-09-17 18:10:11 +02:00
/* FIXME: This doesn't work. See #4154
2021-08-07 20:51:18 +02:00
for ( std : : map < int , const Token * > : : const_iterator i = allocatedVars . begin ( ) ; i ! = allocatedVars . end ( ) ; + + i ) {
2012-09-17 17:59:35 +02:00
copyConstructorMallocError ( copyCtor , i - > second , i - > second - > str ( ) ) ;
2021-08-07 20:51:18 +02:00
}
*/
2012-09-17 17:59:35 +02:00
}
}
}
2012-09-17 18:10:11 +02:00
/* This doesn't work. See #4154
2021-08-07 20:51:18 +02:00
void CheckClass : : copyConstructorMallocError ( const Token * cctor , const Token * alloc , const std : : string & varname )
{
2012-09-17 17:59:35 +02:00
std : : list < const Token * > callstack ;
callstack . push_back ( cctor ) ;
callstack . push_back ( alloc ) ;
reportError ( callstack , Severity : : warning , " copyCtorNoAllocation " , " Copy constructor does not allocate memory for member ' " + varname + " ' although memory has been allocated in other constructors. " ) ;
2021-08-07 20:51:18 +02:00
}
*/
2012-09-17 17:59:35 +02:00
void CheckClass : : copyConstructorShallowCopyError ( const Token * tok , const std : : string & varname )
{
2019-03-06 19:00:58 +01:00
reportError ( tok , Severity : : warning , " copyCtorPointerCopying " ,
2021-02-24 22:00:06 +01:00
" $symbol: " + varname + " \n Value of pointer '$symbol', which points to allocated memory, is copied in copy constructor instead of allocating new memory. " , CWE398 , Certainty : : normal ) ;
2012-09-17 17:59:35 +02:00
}
2018-05-04 15:39:23 +02:00
static std : : string noMemberErrorMessage ( const Scope * scope , const char function [ ] , bool isdefault )
2012-09-17 17:59:35 +02:00
{
2018-04-30 23:13:08 +02:00
const std : : string & classname = scope ? scope - > className : " class " ;
2018-05-04 15:39:23 +02:00
const std : : string type = ( scope & & scope - > type = = Scope : : eStruct ) ? " Struct " : " Class " ;
2018-05-29 13:24:48 +02:00
const bool isDestructor = ( function [ 0 ] = = ' d ' ) ;
2018-05-04 15:39:23 +02:00
std : : string errmsg = " $symbol: " + classname + ' \n ' ;
if ( isdefault ) {
errmsg + = type + " '$symbol' has dynamic memory/resource allocation(s). The " + function + " is explicitly defaulted but the default " + function + " does not work well. " ;
if ( isDestructor )
errmsg + = " It is recommended to define the " + std : : string ( function ) + ' . ' ;
else
errmsg + = " It is recommended to define or delete the " + std : : string ( function ) + ' . ' ;
} else {
errmsg + = type + " '$symbol' does not have a " + function + " which is recommended since it has dynamic memory/resource allocation(s). " ;
}
return errmsg ;
2018-04-30 23:13:08 +02:00
}
2018-05-04 15:39:23 +02:00
void CheckClass : : noCopyConstructorError ( const Scope * scope , bool isdefault , const Token * alloc , bool inconclusive )
2018-04-30 23:13:08 +02:00
{
2021-02-24 22:00:06 +01:00
reportError ( alloc , Severity : : warning , " noCopyConstructor " , noMemberErrorMessage ( scope , " copy constructor " , isdefault ) , CWE398 , inconclusive ? Certainty : : inconclusive : Certainty : : normal ) ;
2018-04-30 23:13:08 +02:00
}
2018-05-05 07:46:58 +02:00
void CheckClass : : noOperatorEqError ( const Scope * scope , bool isdefault , const Token * alloc , bool inconclusive )
2018-04-30 23:13:08 +02:00
{
2021-02-24 22:00:06 +01:00
reportError ( alloc , Severity : : warning , " noOperatorEq " , noMemberErrorMessage ( scope , " operator= " , isdefault ) , CWE398 , inconclusive ? Certainty : : inconclusive : Certainty : : normal ) ;
2018-05-04 15:39:23 +02:00
}
2018-05-01 15:31:13 +02:00
2018-05-04 15:39:23 +02:00
void CheckClass : : noDestructorError ( const Scope * scope , bool isdefault , const Token * alloc )
{
2021-02-24 22:00:06 +01:00
reportError ( alloc , Severity : : warning , " noDestructor " , noMemberErrorMessage ( scope , " destructor " , isdefault ) , CWE398 , Certainty : : normal ) ;
2012-09-17 17:59:35 +02:00
}
2012-08-02 18:50:48 +02:00
bool CheckClass : : canNotCopy ( const Scope * scope )
2011-01-18 07:34:11 +01:00
{
2012-09-22 08:16:16 +02:00
bool constructor = false ;
bool publicAssign = false ;
bool publicCopy = false ;
2011-01-18 07:34:11 +01:00
2018-07-13 23:32:49 +02:00
for ( const Function & func : scope - > functionList ) {
if ( func . isConstructor ( ) )
2012-09-22 08:16:16 +02:00
constructor = true ;
2019-07-23 14:29:02 +02:00
if ( func . access ! = AccessControl : : Public )
2017-09-04 23:04:48 +02:00
continue ;
2018-07-13 23:32:49 +02:00
if ( func . type = = Function : : eCopyConstructor ) {
2012-09-22 08:16:16 +02:00
publicCopy = true ;
2017-09-04 23:04:48 +02:00
break ;
2018-07-13 23:32:49 +02:00
} else if ( func . type = = Function : : eOperatorEqual ) {
2012-09-22 08:16:16 +02:00
publicAssign = true ;
2017-09-04 23:04:48 +02:00
break ;
}
2011-01-18 07:34:11 +01:00
}
2012-09-29 12:19:30 +02:00
return constructor & & ! ( publicAssign | | publicCopy ) ;
2011-01-18 07:34:11 +01:00
}
2013-04-10 21:57:22 +02:00
bool CheckClass : : canNotMove ( const Scope * scope )
{
bool constructor = false ;
bool publicAssign = false ;
bool publicCopy = false ;
bool publicMove = false ;
2018-07-13 23:32:49 +02:00
for ( const Function & func : scope - > functionList ) {
if ( func . isConstructor ( ) )
2013-04-10 21:57:22 +02:00
constructor = true ;
2019-07-23 14:29:02 +02:00
if ( func . access ! = AccessControl : : Public )
2017-09-04 22:58:14 +02:00
continue ;
2018-07-13 23:32:49 +02:00
if ( func . type = = Function : : eCopyConstructor ) {
2013-04-10 21:57:22 +02:00
publicCopy = true ;
2017-09-04 23:00:02 +02:00
break ;
2018-07-13 23:32:49 +02:00
} else if ( func . type = = Function : : eMoveConstructor ) {
2013-04-10 21:57:22 +02:00
publicMove = true ;
2017-09-04 23:00:02 +02:00
break ;
2018-07-13 23:32:49 +02:00
} else if ( func . type = = Function : : eOperatorEqual ) {
2013-04-10 21:57:22 +02:00
publicAssign = true ;
2017-09-04 23:00:02 +02:00
break ;
}
2013-04-10 21:57:22 +02:00
}
return constructor & & ! ( publicAssign | | publicCopy | | publicMove ) ;
}
2021-02-03 19:25:28 +01:00
static void getAllVariableMembers ( const Scope * scope , std : : vector < const Variable * > & varList )
2011-01-16 16:37:11 +01:00
{
2021-02-01 18:58:51 +01:00
for ( const Variable & var : scope - > varlist )
2021-02-03 19:13:49 +01:00
varList . push_back ( & var ) ;
2021-02-01 18:58:51 +01:00
if ( scope - > definedType ) {
for ( const Type : : BaseInfo & baseInfo : scope - > definedType - > derivedFrom ) {
2021-02-03 19:25:28 +01:00
if ( scope - > definedType = = baseInfo . type )
continue ;
2021-02-01 18:58:51 +01:00
const Scope * baseClass = baseInfo . type ? baseInfo . type - > classScope : nullptr ;
if ( baseClass & & baseClass - > isClassOrStruct ( ) & & baseClass - > numConstructors = = 0 )
2021-02-03 19:25:28 +01:00
getAllVariableMembers ( baseClass , varList ) ;
2021-02-01 18:58:51 +01:00
}
}
}
2011-01-16 16:37:11 +01:00
2021-02-03 19:13:49 +01:00
std : : vector < CheckClass : : Usage > CheckClass : : createUsageList ( const Scope * scope )
{
std : : vector < Usage > ret ;
std : : vector < const Variable * > varlist ;
2021-02-03 19:25:28 +01:00
getAllVariableMembers ( scope , varlist ) ;
2021-04-18 21:51:47 +02:00
ret . reserve ( varlist . size ( ) ) ;
2021-02-03 19:13:49 +01:00
for ( const Variable * var : varlist )
ret . emplace_back ( var ) ;
return ret ;
}
2021-02-01 18:58:51 +01:00
void CheckClass : : assignVar ( std : : vector < Usage > & usageList , nonneg int varid )
{
for ( Usage & usage : usageList ) {
if ( usage . var - > declarationId ( ) = = varid ) {
usage . assign = true ;
2011-01-16 16:37:11 +01:00
return ;
}
}
}
2021-02-01 17:13:58 +01:00
void CheckClass : : initVar ( std : : vector < Usage > & usageList , nonneg int varid )
2011-01-16 16:37:11 +01:00
{
2021-02-01 17:13:58 +01:00
for ( Usage & usage : usageList ) {
if ( usage . var - > declarationId ( ) = = varid ) {
usage . init = true ;
2011-01-16 16:37:11 +01:00
return ;
}
}
}
2021-02-01 19:31:30 +01:00
void CheckClass : : assignAllVar ( std : : vector < Usage > & usageList )
2011-01-16 16:37:11 +01:00
{
2021-02-01 19:31:30 +01:00
for ( Usage & i : usageList )
2019-09-19 20:29:33 +02:00
i . assign = true ;
2011-01-16 16:37:11 +01:00
}
2021-02-01 19:31:30 +01:00
void CheckClass : : clearAllVar ( std : : vector < Usage > & usageList )
2011-01-16 16:37:11 +01:00
{
2021-02-01 19:31:30 +01:00
for ( Usage & i : usageList ) {
2019-09-19 20:29:33 +02:00
i . assign = false ;
i . init = false ;
2011-01-16 16:37:11 +01:00
}
}
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...
2019-09-19 20:29:33 +02:00
for ( const Type : : BaseInfo & i : scope - > definedType - > derivedFrom ) {
const Type * derivedFrom = i . type ;
2011-01-16 16:37:11 +01:00
// Check if base class exists in database
2013-03-05 15:28:40 +01:00
if ( derivedFrom & & derivedFrom - > classScope ) {
2014-07-23 16:51:23 +02:00
const std : : list < Function > & functionList = derivedFrom - > classScope - > functionList ;
2011-01-16 16:37:11 +01:00
2018-07-14 07:55:18 +02:00
for ( const Function & func : functionList ) {
if ( func . tokenDef - > str ( ) = = tok - > str ( ) )
2011-01-16 16:37:11 +01:00
return true ;
}
2022-03-02 07:46:23 +01:00
if ( isBaseClassFunc ( tok , derivedFrom - > classScope ) )
return true ;
2011-01-16 16:37:11 +01:00
}
// Base class not found so assume it is in it.
else
return true ;
}
return false ;
}
2013-01-01 09:53:40 +01:00
void CheckClass : : initializeVarList ( const Function & func , std : : list < const Function * > & callstack , const Scope * scope , std : : vector < Usage > & usage )
2011-01-16 16:37:11 +01:00
{
2014-04-21 21:44:17 +02:00
if ( ! func . functionScope )
2017-08-09 20:00:26 +02:00
throw InternalError ( nullptr , " Internal Error: Invalid syntax " ) ; // #5702
2013-04-10 21:57:22 +02:00
bool initList = func . isConstructor ( ) ;
2012-07-10 14:47:51 +02:00
const Token * ftok = func . arg - > link ( ) - > next ( ) ;
int level = 0 ;
2018-04-27 22:36:30 +02:00
for ( ; ftok & & ftok ! = func . functionScope - > bodyEnd ; ftok = ftok - > next ( ) ) {
2011-01-16 16:37:11 +01:00
// Class constructor.. initializing variables like this
// clKalle::clKalle() : var(value) { }
2012-04-05 09:43:40 +02:00
if ( initList ) {
2015-04-06 19:47:21 +02:00
if ( level = = 0 & & Token : : Match ( ftok , " %name% {|( " ) & & Token : : Match ( ftok - > linkAt ( 1 ) , " }|) ,|{ " ) ) {
2013-03-02 07:24:51 +01:00
if ( ftok - > str ( ) ! = func . name ( ) ) {
2021-02-01 17:13:58 +01:00
initVar ( usage , ftok - > varId ( ) ) ;
2013-03-02 07:24:51 +01:00
} else { // c++11 delegate constructor
2014-11-13 06:29:51 +01:00
const Function * member = ftok - > function ( ) ;
2019-01-10 20:13:37 +01:00
// member function not found => assume it initializes all members
if ( ! member ) {
assignAllVar ( usage ) ;
return ;
}
2013-01-01 09:53:40 +01:00
2019-01-10 20:13:37 +01:00
// recursive call
// assume that all variables are initialized
if ( std : : find ( callstack . begin ( ) , callstack . end ( ) , member ) ! = callstack . end ( ) ) {
/** @todo false negative: just bail */
assignAllVar ( usage ) ;
return ;
}
2013-01-01 09:53:40 +01:00
2019-01-10 20:13:37 +01:00
// member function has implementation
if ( member - > hasBody ( ) ) {
// initialize variable use list using member function
callstack . push_back ( member ) ;
initializeVarList ( * member , callstack , scope , usage ) ;
callstack . pop_back ( ) ;
}
// there is a called member function, but it has no implementation, so we assume it initializes everything
else {
assignAllVar ( usage ) ;
2013-01-01 09:53:40 +01:00
}
}
2015-01-31 10:50:39 +01:00
} else if ( level ! = 0 & & Token : : Match ( ftok , " %name% = " ) ) // assignment in the initializer: var(value = x)
2021-02-01 18:58:51 +01:00
assignVar ( usage , ftok - > varId ( ) ) ;
2012-07-10 14:47:51 +02:00
2015-04-06 19:47:21 +02:00
// Level handling
if ( ftok - > link ( ) & & Token : : Match ( ftok , " (|< " ) )
2012-07-10 14:47:51 +02:00
level + + ;
else if ( ftok - > str ( ) = = " { " ) {
2015-04-06 19:47:21 +02:00
if ( level ! = 0 | |
( Token : : Match ( ftok - > previous ( ) , " %name%|> " ) & & Token : : Match ( ftok - > link ( ) , " } ,|{ " ) ) )
level + + ;
2012-07-10 14:47:51 +02:00
else
2015-04-06 19:47:21 +02:00
initList = false ;
} else if ( ftok - > link ( ) & & Token : : Match ( ftok , " )|>|} " ) )
level - - ;
2011-01-16 16:37:11 +01:00
}
2012-04-05 09:43:40 +02:00
if ( initList )
2011-01-16 16:37:11 +01:00
continue ;
// Variable getting value from stream?
2018-04-22 14:00:03 +02:00
if ( Token : : Match ( ftok , " >>|& %name% " ) & & isLikelyStreamRead ( true , ftok ) ) {
2021-02-01 18:58:51 +01:00
assignVar ( usage , ftok - > next ( ) - > varId ( ) ) ;
2011-01-16 16:37:11 +01:00
}
2017-05-28 16:00:06 +02:00
// If assignment comes after an && or || this is really inconclusive because of short circuiting
if ( Token : : Match ( ftok , " %oror%|&& " ) )
2011-01-16 16:37:11 +01:00
continue ;
if ( Token : : simpleMatch ( ftok , " ( ! " ) )
ftok = ftok - > next ( ) ;
// Using the operator= function to initialize all variables..
2012-05-22 11:27:21 +02:00
if ( Token : : Match ( ftok - > next ( ) , " return| (| * this )| = " ) ) {
2011-01-16 16:37:11 +01:00
assignAllVar ( usage ) ;
break ;
}
2012-09-22 08:50:36 +02:00
// Using swap to assign all variables..
2015-01-31 10:50:39 +01:00
if ( func . type = = Function : : eOperatorEqual & & Token : : Match ( ftok , " [;{}] %name% ( " ) & & Token : : Match ( ftok - > linkAt ( 2 ) , " ) . %name% ( *| this ) ; " ) ) {
2012-09-22 08:50:36 +02:00
assignAllVar ( usage ) ;
break ;
}
2011-01-16 16:37:11 +01:00
// Calling member variable function?
2022-03-16 20:35:55 +01:00
if ( Token : : Match ( ftok - > next ( ) , " %var% . %name% ( " ) & & ! ( ftok - > next ( ) - > valueType ( ) & & ftok - > next ( ) - > valueType ( ) - > pointer ) ) {
2018-07-13 23:32:49 +02:00
for ( const Variable & var : scope - > varlist ) {
if ( var . declarationId ( ) = = ftok - > next ( ) - > varId ( ) ) {
2011-01-16 16:37:11 +01:00
/** @todo false negative: we assume function changes variable state */
2021-02-01 18:58:51 +01:00
assignVar ( usage , ftok - > next ( ) - > varId ( ) ) ;
2012-03-11 14:29:00 +01:00
break ;
2011-01-16 16:37:11 +01:00
}
}
ftok = ftok - > tokAt ( 2 ) ;
}
2015-01-31 10:50:39 +01:00
if ( ! Token : : Match ( ftok - > next ( ) , " ::| %name% " ) & &
! Token : : Match ( ftok - > next ( ) , " *| this . %name% " ) & &
! Token : : Match ( ftok - > next ( ) , " * %name% = " ) & &
! Token : : Match ( ftok - > next ( ) , " ( * this ) . %name% " ) )
2011-01-16 16:37:11 +01:00
continue ;
// Goto the first token in this statement..
ftok = ftok - > next ( ) ;
2011-08-26 05:27:10 +02:00
// skip "return"
if ( ftok - > str ( ) = = " return " )
ftok = ftok - > next ( ) ;
2011-01-16 16:37:11 +01:00
// Skip "( * this )"
2011-10-13 20:53:06 +02:00
if ( Token : : simpleMatch ( ftok , " ( * this ) . " ) ) {
2011-01-16 16:37:11 +01:00
ftok = ftok - > tokAt ( 5 ) ;
}
// Skip "this->"
if ( Token : : simpleMatch ( ftok , " this . " ) )
ftok = ftok - > tokAt ( 2 ) ;
// Skip "classname :: "
2015-01-31 10:50:39 +01:00
if ( Token : : Match ( ftok , " :: %name% " ) )
2014-01-01 18:34:39 +01:00
ftok = ftok - > next ( ) ;
2015-01-31 10:50:39 +01:00
while ( Token : : Match ( ftok , " %name% :: " ) )
2011-01-16 16:37:11 +01:00
ftok = ftok - > tokAt ( 2 ) ;
// Clearing all variables..
2011-10-13 20:53:06 +02:00
if ( Token : : Match ( ftok , " ::| memset ( this , " ) ) {
2011-01-16 16:37:11 +01:00
assignAllVar ( usage ) ;
return ;
}
2016-10-01 13:46:58 +02:00
// Ticket #7068
else if ( Token : : Match ( ftok , " ::| memset ( &| this . %name% " ) ) {
if ( ftok - > str ( ) = = " :: " )
ftok = ftok - > next ( ) ;
int offsetToMember = 4 ;
2016-10-16 22:21:33 +02:00
if ( ftok - > strAt ( 2 ) = = " & " )
2016-10-01 13:46:58 +02:00
+ + offsetToMember ;
2021-02-01 18:58:51 +01:00
assignVar ( usage , ftok - > tokAt ( offsetToMember ) - > varId ( ) ) ;
2016-10-01 13:46:58 +02:00
ftok = ftok - > linkAt ( 1 ) ;
continue ;
}
2011-01-16 16:37:11 +01:00
// Clearing array..
2015-01-31 10:50:39 +01:00
else if ( Token : : Match ( ftok , " ::| memset ( %name% , " ) ) {
2012-03-11 14:29:00 +01:00
if ( ftok - > str ( ) = = " :: " )
ftok = ftok - > next ( ) ;
2021-02-01 18:58:51 +01:00
assignVar ( usage , ftok - > tokAt ( 2 ) - > varId ( ) ) ;
2012-03-11 14:29:00 +01:00
ftok = ftok - > linkAt ( 1 ) ;
2011-01-16 16:37:11 +01:00
continue ;
}
// Calling member function?
2022-02-16 21:30:19 +01:00
else if ( Token : : simpleMatch ( ftok , " operator= ( " ) ) {
if ( ftok - > function ( ) ) {
2013-02-27 06:59:04 +01:00
const Function * member = ftok - > function ( ) ;
2013-01-01 09:53:40 +01:00
// recursive call
// assume that all variables are initialized
if ( std : : find ( callstack . begin ( ) , callstack . end ( ) , member ) ! = callstack . end ( ) ) {
/** @todo false negative: just bail */
assignAllVar ( usage ) ;
return ;
}
2011-01-16 16:37:11 +01:00
// member function has implementation
2015-01-08 05:45:31 +01:00
if ( member - > hasBody ( ) ) {
2011-09-15 01:58:11 +02:00
// initialize variable use list using member function
2013-01-01 09:53:40 +01:00
callstack . push_back ( member ) ;
initializeVarList ( * member , callstack , scope , usage ) ;
2011-09-15 01:58:11 +02:00
callstack . pop_back ( ) ;
2011-01-16 16:37:11 +01:00
}
// there is a called member function, but it has no implementation, so we assume it initializes everything
2011-10-13 20:53:06 +02:00
else {
2011-01-16 16:37:11 +01:00
assignAllVar ( usage ) ;
}
}
// using default operator =, assume everything initialized
2011-10-13 20:53:06 +02:00
else {
2011-01-16 16:37:11 +01:00
assignAllVar ( usage ) ;
}
2018-11-06 06:44:08 +01:00
} else if ( Token : : Match ( ftok , " ::| %name% ( " ) & & ! Token : : Match ( ftok , " if|while|for " ) ) {
2011-11-30 21:28:16 +01:00
if ( ftok - > str ( ) = = " :: " )
ftok = ftok - > next ( ) ;
2011-01-16 16:37:11 +01:00
// Passing "this" => assume that everything is initialized
2011-10-13 20:53:06 +02:00
for ( const Token * tok2 = ftok - > next ( ) - > link ( ) ; tok2 & & tok2 ! = ftok ; tok2 = tok2 - > previous ( ) ) {
if ( tok2 - > str ( ) = = " this " ) {
2011-01-16 16:37:11 +01:00
assignAllVar ( usage ) ;
return ;
}
}
// check if member function
2013-02-27 06:59:04 +01:00
if ( ftok - > function ( ) & & ftok - > function ( ) - > nestedIn = = scope & &
2013-04-10 21:57:22 +02:00
! ftok - > function ( ) - > isConstructor ( ) ) {
2013-02-27 06:59:04 +01:00
const Function * member = ftok - > function ( ) ;
2011-01-16 16:37:11 +01:00
2013-01-01 09:53:40 +01:00
// recursive call
// assume that all variables are initialized
if ( std : : find ( callstack . begin ( ) , callstack . end ( ) , member ) ! = callstack . end ( ) ) {
assignAllVar ( usage ) ;
return ;
}
2011-01-16 16:37:11 +01:00
// member function has implementation
2015-01-08 05:45:31 +01:00
if ( member - > hasBody ( ) ) {
2011-09-15 01:58:11 +02:00
// initialize variable use list using member function
2013-01-01 09:53:40 +01:00
callstack . push_back ( member ) ;
initializeVarList ( * member , callstack , scope , usage ) ;
2011-09-15 01:58:11 +02:00
callstack . pop_back ( ) ;
2012-09-23 18:29:05 +02:00
// Assume that variables that are passed to it are initialized..
for ( const Token * tok2 = ftok ; tok2 ; tok2 = tok2 - > next ( ) ) {
if ( Token : : Match ( tok2 , " [;{}] " ) )
break ;
2015-01-31 10:50:39 +01:00
if ( Token : : Match ( tok2 , " [(,] &| %name% [,)] " ) ) {
2012-09-23 18:29:05 +02:00
tok2 = tok2 - > next ( ) ;
if ( tok2 - > str ( ) = = " & " )
tok2 = tok2 - > next ( ) ;
2021-02-01 18:58:51 +01:00
assignVar ( usage , tok2 - > varId ( ) ) ;
2012-09-23 18:29:05 +02:00
}
}
2011-01-16 16:37:11 +01:00
}
// there is a called member function, but it has no implementation, so we assume it initializes everything
2011-10-13 20:53:06 +02:00
else {
2011-01-16 16:37:11 +01:00
assignAllVar ( usage ) ;
}
}
// not member function
2011-10-13 20:53:06 +02:00
else {
2011-01-16 16:37:11 +01:00
// could be a base class virtual function, so we assume it initializes everything
2013-04-10 21:57:22 +02:00
if ( ! func . isConstructor ( ) & & 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
2013-03-05 15:28:40 +01:00
if ( ! scope - > definedType - > 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..
2011-10-13 20:53:06 +02:00
else {
2012-01-15 12:31:49 +01:00
for ( const Token * tok = ftok - > tokAt ( 2 ) ; tok & & tok ! = ftok - > next ( ) - > link ( ) ; tok = tok - > next ( ) ) {
2011-10-13 20:53:06 +02:00
if ( tok - > isName ( ) ) {
2021-02-01 18:58:51 +01:00
assignVar ( usage , tok - > varId ( ) ) ;
2011-01-16 16:37:11 +01:00
}
}
}
}
}
// Assignment of member variable?
2015-01-31 10:50:39 +01:00
else if ( Token : : Match ( ftok , " %name% = " ) ) {
2021-02-01 18:58:51 +01:00
assignVar ( usage , ftok - > varId ( ) ) ;
2015-11-09 21:02:06 +01:00
bool bailout = ftok - > variable ( ) & & ftok - > variable ( ) - > isReference ( ) ;
const Token * tok2 = ftok - > tokAt ( 2 ) ;
if ( tok2 - > str ( ) = = " & " ) {
tok2 = tok2 - > next ( ) ;
bailout = true ;
}
if ( tok2 - > variable ( ) & & ( bailout | | tok2 - > variable ( ) - > isArray ( ) ) & & tok2 - > strAt ( 1 ) ! = " [ " )
2021-02-01 18:58:51 +01:00
assignVar ( usage , tok2 - > varId ( ) ) ;
2011-01-16 16:37:11 +01:00
}
// Assignment of array item of member variable?
2015-01-31 10:50:39 +01:00
else if ( Token : : Match ( ftok , " %name% [|. " ) ) {
2011-11-22 18:45:25 +01:00
const Token * tok2 = ftok ;
while ( tok2 ) {
2013-03-01 12:42:04 +01:00
if ( tok2 - > strAt ( 1 ) = = " [ " )
2011-11-22 18:45:25 +01:00
tok2 = tok2 - > next ( ) - > link ( ) ;
2015-01-31 10:50:39 +01:00
else if ( Token : : Match ( tok2 - > next ( ) , " . %name% " ) )
2011-11-22 18:45:25 +01:00
tok2 = tok2 - > tokAt ( 2 ) ;
else
break ;
}
2011-12-08 21:28:34 +01:00
if ( tok2 & & tok2 - > strAt ( 1 ) = = " = " )
2021-02-01 18:58:51 +01:00
assignVar ( usage , ftok - > varId ( ) ) ;
2011-01-16 16:37:11 +01:00
}
// Assignment of array item of member variable?
2015-01-31 10:50:39 +01:00
else if ( Token : : Match ( ftok , " * %name% = " ) ) {
2021-02-01 18:58:51 +01:00
assignVar ( usage , ftok - > next ( ) - > varId ( ) ) ;
2015-01-31 10:50:39 +01:00
} else if ( Token : : Match ( ftok , " * this . %name% = " ) ) {
2021-02-01 18:58:51 +01:00
assignVar ( usage , ftok - > tokAt ( 3 ) - > varId ( ) ) ;
2011-01-16 16:37:11 +01:00
}
// The functions 'clear' and 'Clear' are supposed to initialize variable.
2015-01-31 10:50:39 +01:00
if ( Token : : Match ( ftok , " %name% . clear|Clear ( " ) ) {
2021-02-01 18:58:51 +01:00
assignVar ( usage , ftok - > varId ( ) ) ;
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 " ,
2018-04-09 06:43:48 +02:00
" $symbol: " + classname + " \n " +
2022-02-01 17:24:26 +01:00
" The " + std : : string ( isStruct ? " struct " : " class " ) + " '$symbol' does not declare a constructor although it has private member variables which likely require initialization. \n "
" The " + std : : string ( isStruct ? " struct " : " class " ) + " '$symbol' does not declare a constructor "
2018-04-09 06:43:48 +02:00
" although it has private member variables. Member variables of builtin types are left "
2021-02-24 22:00:06 +01:00
" uninitialized when the class is instantiated. That may cause bugs or undefined behavior. " , CWE398 , Certainty : : normal ) ;
2010-11-14 06:50:33 +01:00
}
2015-03-07 20:07:54 +01:00
void CheckClass : : noExplicitConstructorError ( const Token * tok , const std : : string & classname , bool isStruct )
{
2018-04-09 06:43:48 +02:00
const std : : string message ( std : : string ( isStruct ? " Struct " : " Class " ) + " '$symbol' has a constructor with 1 argument that is not explicit. " ) ;
2015-03-10 19:35:12 +01:00
const std : : string verbose ( message + " Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided. " ) ;
2021-02-24 22:00:06 +01:00
reportError ( tok , Severity : : style , " noExplicitConstructor " , " $symbol: " + classname + ' \n ' + message + ' \n ' + verbose , CWE398 , Certainty : : normal ) ;
2015-03-07 20:07:54 +01:00
}
2022-03-13 17:33:31 +01:00
void CheckClass : : uninitVarError ( const Token * tok , bool isprivate , Function : : Type functionType , const std : : string & classname , const std : : string & varname , bool derived , bool inconclusive )
2010-11-14 06:50:33 +01:00
{
2022-03-13 17:33:31 +01:00
std : : string ctor ;
if ( functionType = = Function : : eCopyConstructor )
ctor = " copy " ;
else if ( functionType = = Function : : eMoveConstructor )
ctor = " move " ;
std : : string message ( " Member variable '$symbol' is not initialized in the " + ctor + " constructor. " ) ;
2021-02-01 18:58:51 +01:00
if ( derived )
message + = " Maybe it should be initialized directly in the class " + classname + " ? " ;
std : : string id = std : : string ( " uninit " ) + ( derived ? " Derived " : " " ) + " MemberVar " + ( isprivate ? " Private " : " " ) ;
2021-02-24 22:00:06 +01:00
reportError ( tok , Severity : : warning , id , " $symbol: " + classname + " :: " + varname + " \n " + message , CWE398 , inconclusive ? Certainty : : inconclusive : Certainty : : normal ) ;
2010-11-14 06:50:33 +01:00
}
2022-03-13 17:33:31 +01:00
void CheckClass : : uninitVarError ( const Token * tok , const std : : string & classname , const std : : string & varname )
2022-02-02 20:44:10 +01:00
{
2022-03-13 17:33:31 +01:00
const std : : string message ( " Member variable '$symbol' is not initialized. " ) ; // report missing in-class initializer
const std : : string id = std : : string ( " uninitMemberVarPrivate " ) ;
reportError ( tok , Severity : : warning , id , " $symbol: " + classname + " :: " + varname + " \n " + message , CWE398 , Certainty : : normal ) ;
}
void CheckClass : : missingMemberCopyError ( const Token * tok , Function : : Type functionType , const std : : string & classname , const std : : string & varname )
{
const std : : string ctor ( functionType = = Function : : Type : : eCopyConstructor ? " copy " : " move " ) ;
const std : : string action ( functionType = = Function : : Type : : eCopyConstructor ? " copied? " : " moved? " ) ;
2022-02-02 20:44:10 +01:00
const std : : string message =
" $symbol: " + classname + " :: " + varname + " \n " +
2022-03-13 17:33:31 +01:00
" Member variable '$symbol' is not assigned in the " + ctor + " constructor. Should it be " + action ;
2022-02-02 20:44:10 +01:00
const char id [ ] = " missingMemberCopy " ;
reportError ( tok , Severity : : warning , id , message , CWE398 , Certainty : : inconclusive ) ;
}
2012-09-20 19:16:26 +02:00
void CheckClass : : operatorEqVarError ( const Token * tok , const std : : string & classname , const std : : string & varname , bool inconclusive )
2010-11-14 06:50:33 +01:00
{
2021-02-24 22:00:06 +01:00
reportError ( tok , Severity : : warning , " operatorEqVarError " , " $symbol: " + classname + " :: " + varname + " \n Member variable '$symbol' is not assigned a value in ' " + classname + " ::operator='. " , CWE398 , inconclusive ? Certainty : : inconclusive : Certainty : : normal ) ;
2010-11-14 06:50:33 +01:00
}
2012-05-18 16:54:58 +02:00
//---------------------------------------------------------------------------
// ClassCheck: Use initialization list instead of assignment
//---------------------------------------------------------------------------
void CheckClass : : initializationListUsage ( )
{
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > severity . isEnabled ( Severity : : performance ) )
2012-05-18 16:54:58 +02:00
return ;
2018-06-17 18:43:54 +02:00
for ( const Scope * scope : mSymbolDatabase - > functionScopes ) {
2012-05-18 16:54:58 +02:00
// Check every constructor
2020-09-09 18:04:21 +02:00
if ( ! scope - > function | | ! scope - > function - > isConstructor ( ) )
2012-05-18 16:54:58 +02:00
continue ;
2020-09-09 18:04:21 +02:00
// Do not warn when a delegate constructor is called
if ( const Token * initList = scope - > function - > constructorMemberInitialization ( ) ) {
if ( Token : : Match ( initList , " : %name% {|( " ) & & initList - > strAt ( 1 ) = = scope - > className )
continue ;
}
2013-03-05 18:42:42 +01:00
const Scope * owner = scope - > functionOf ;
2018-04-27 22:36:30 +02:00
for ( const Token * tok = scope - > bodyStart ; tok ! = scope - > bodyEnd ; tok = tok - > next ( ) ) {
2015-01-31 10:50:39 +01:00
if ( Token : : Match ( tok , " %name% ( " ) ) // Assignments might depend on this function call or if/for/while/switch statement from now on.
2012-05-18 16:54:58 +02:00
break ;
2012-05-22 10:35:56 +02:00
if ( Token : : Match ( tok , " try|do { " ) )
break ;
2019-09-01 09:53:45 +02:00
if ( ! Token : : Match ( tok , " %var% = " ) | | tok - > strAt ( - 1 ) = = " * " | | tok - > strAt ( - 1 ) = = " . " )
2019-01-07 21:26:58 +01:00
continue ;
2015-08-14 12:50:45 +02:00
2019-01-07 21:26:58 +01:00
const Variable * var = tok - > variable ( ) ;
if ( ! var | | var - > scope ( ) ! = owner | | var - > isStatic ( ) )
continue ;
2020-11-27 16:49:25 +01:00
if ( var - > isPointer ( ) | | var - > isReference ( ) | | var - > isEnumType ( ) )
continue ;
if ( ! WRONG_DATA ( ! var - > valueType ( ) , tok ) & & var - > valueType ( ) - > type > ValueType : : Type : : ITERATOR )
2019-01-07 21:26:58 +01:00
continue ;
2019-02-05 19:53:10 +01:00
// bailout: multi line lambda in rhs => do not warn
if ( findLambdaEndToken ( tok - > tokAt ( 2 ) ) & & tok - > tokAt ( 2 ) - > findExpressionStartEndTokens ( ) . second - > linenr ( ) > tok - > tokAt ( 2 ) - > linenr ( ) )
continue ;
2019-01-07 21:26:58 +01:00
// Access local var member in rhs => do not warn
bool localmember = false ;
visitAstNodes ( tok - > next ( ) - > astOperand2 ( ) ,
2021-08-07 20:51:18 +02:00
[ & ] ( const Token * rhs ) {
2019-01-07 21:26:58 +01:00
if ( rhs - > str ( ) = = " . " & & rhs - > astOperand1 ( ) & & rhs - > astOperand1 ( ) - > variable ( ) & & rhs - > astOperand1 ( ) - > variable ( ) - > isLocal ( ) )
localmember = true ;
return ChildrenToVisit : : op1_and_op2 ;
} ) ;
if ( localmember )
continue ;
2015-08-14 12:50:45 +02:00
2019-01-07 21:26:58 +01:00
bool allowed = true ;
visitAstNodes ( tok - > next ( ) - > astOperand2 ( ) ,
2021-08-07 20:51:18 +02:00
[ & ] ( const Token * tok2 ) {
2019-01-07 21:26:58 +01:00
const Variable * var2 = tok2 - > variable ( ) ;
if ( var2 ) {
if ( var2 - > scope ( ) = = owner & & tok2 - > strAt ( - 1 ) ! = " . " ) { // Is there a dependency between two member variables?
allowed = false ;
return ChildrenToVisit : : done ;
} else if ( var2 - > isArray ( ) & & var2 - > isLocal ( ) ) { // Can't initialize with a local array
allowed = false ;
return ChildrenToVisit : : done ;
}
} else if ( tok2 - > str ( ) = = " this " ) { // 'this' instance is not completely constructed in initialization list
allowed = false ;
return ChildrenToVisit : : done ;
} else if ( Token : : Match ( tok2 , " %name% ( " ) & & tok2 - > strAt ( - 1 ) ! = " . " & & isMemberFunc ( owner , tok2 ) ) { // Member function called?
allowed = false ;
return ChildrenToVisit : : done ;
2012-05-18 16:54:58 +02:00
}
2019-01-07 21:26:58 +01:00
return ChildrenToVisit : : op1_and_op2 ;
} ) ;
if ( ! allowed )
continue ;
suggestInitializationList ( tok , tok - > str ( ) ) ;
2012-05-18 16:54:58 +02:00
}
}
}
2012-05-19 21:51:39 +02:00
void CheckClass : : suggestInitializationList ( const Token * tok , const std : : string & varname )
2012-05-18 16:54:58 +02:00
{
2018-04-09 06:43:48 +02:00
reportError ( tok , Severity : : performance , " useInitializationList " , " $symbol: " + varname + " \n Variable '$symbol' is assigned in constructor body. Consider performing initialization in initialization list. \n "
2012-07-31 21:28:42 +02:00
" When an object of a class is created, the constructors of all member variables are called consecutively "
2012-05-18 16:54:58 +02:00
" in the order the variables are declared, even if you don't explicitly write them to the initialization list. You "
2021-02-24 22:00:06 +01:00
" could avoid assigning '$symbol' a value by passing the value to the constructor in the initialization list. " , CWE398 , Certainty : : normal ) ;
2012-05-18 16:54:58 +02:00
}
2010-01-16 08:47:46 +01:00
//---------------------------------------------------------------------------
// ClassCheck: Unused private functions
//---------------------------------------------------------------------------
2016-05-16 09:36:26 +02:00
static bool checkFunctionUsage ( const Function * privfunc , const Scope * scope )
2012-02-24 20:45:56 +01:00
{
if ( ! scope )
2013-02-16 10:51:08 +01:00
return true ; // Assume it is used, if scope is not seen
2012-02-24 20:45:56 +01:00
for ( std : : list < Function > : : const_iterator func = scope - > functionList . begin ( ) ; func ! = scope - > functionList . end ( ) ; + + func ) {
2012-05-22 21:58:46 +02:00
if ( func - > functionScope ) {
2015-01-31 10:50:39 +01:00
if ( Token : : Match ( func - > tokenDef , " %name% ( " ) ) {
2013-08-26 16:41:23 +02:00
for ( const Token * ftok = func - > tokenDef - > tokAt ( 2 ) ; ftok & & ftok - > str ( ) ! = " ) " ; ftok = ftok - > next ( ) ) {
2016-05-16 09:36:26 +02:00
if ( Token : : Match ( ftok , " = %name% [(,)] " ) & & ftok - > strAt ( 1 ) = = privfunc - > name ( ) )
2013-08-26 16:41:23 +02:00
return true ;
if ( ftok - > str ( ) = = " ( " )
ftok = ftok - > link ( ) ;
}
}
2018-04-27 22:36:30 +02:00
for ( const Token * ftok = func - > functionScope - > classDef - > linkAt ( 1 ) ; ftok ! = func - > functionScope - > bodyEnd ; ftok = ftok - > next ( ) ) {
2016-05-16 09:36:26 +02:00
if ( ftok - > function ( ) = = privfunc )
return true ;
2016-05-16 10:55:22 +02:00
if ( ftok - > varId ( ) = = 0U & & ftok - > str ( ) = = privfunc - > name ( ) ) // TODO: This condition should be redundant
2012-02-24 20:45:56 +01:00
return true ;
}
2013-02-16 10:51:08 +01:00
} else if ( ( func - > type ! = Function : : eCopyConstructor & &
func - > type ! = Function : : eOperatorEqual ) | |
2019-07-23 14:29:02 +02:00
func - > access ! = AccessControl : : Private ) // Assume it is used, if a function implementation isn't seen, but empty private copy constructors and assignment operators are OK
2013-02-16 10:51:08 +01:00
return true ;
}
2017-10-15 02:53:41 +02:00
const std : : map < std : : string , Type * > : : const_iterator end = scope - > definedTypesMap . end ( ) ;
2021-08-07 20:51:18 +02:00
for ( std : : map < std : : string , Type * > : : const_iterator iter = scope - > definedTypesMap . begin ( ) ; iter ! = end ; + + iter ) {
2017-10-15 02:53:41 +02:00
const Type * type = ( * iter ) . second ;
2016-05-16 20:52:50 +02:00
if ( type - > enclosingScope = = scope & & checkFunctionUsage ( privfunc , type - > classScope ) )
return true ;
2012-02-24 20:45:56 +01:00
}
2018-07-14 07:55:18 +02:00
for ( const Variable & var : scope - > varlist ) {
if ( var . isStatic ( ) ) {
2022-03-14 19:15:48 +01:00
const Token * tok = Token : : findmatch ( scope - > bodyStart , " %varid% =|(|{ " , var . declarationId ( ) ) ;
2014-08-26 11:29:26 +02:00
if ( tok )
tok = tok - > tokAt ( 2 ) ;
while ( tok & & tok - > str ( ) ! = " ; " ) {
2016-05-16 09:36:26 +02:00
if ( tok - > function ( ) = = privfunc )
2014-08-26 11:29:26 +02:00
return true ;
tok = tok - > next ( ) ;
}
}
}
2012-02-24 20:45:56 +01:00
return false ; // Unused in this scope
}
2010-01-16 08:47:46 +01:00
void CheckClass : : privateFunctions ( )
{
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > severity . isEnabled ( Severity : : style ) )
2010-04-21 08:38:25 +02:00
return ;
2018-06-17 18:43:54 +02:00
for ( const Scope * scope : mSymbolDatabase - > classAndStructScopes ) {
2010-09-02 07:40:20 +02:00
2013-11-09 16:07:28 +01:00
// do not check borland classes with properties..
2018-04-27 22:36:30 +02:00
if ( Token : : findsimplematch ( scope - > bodyStart , " ; __property ; " , scope - > bodyEnd ) )
2011-12-14 21:11:40 +01:00
continue ;
2010-09-02 07:40:20 +02:00
2014-08-06 13:35:04 +02:00
std : : list < const Function * > privateFuncs ;
2018-07-13 23:43:03 +02:00
for ( const Function & func : scope - > functionList ) {
2013-02-16 10:51:08 +01:00
// Get private functions..
2019-07-23 14:29:02 +02:00
if ( func . type = = Function : : eFunction & & func . access = = AccessControl : : Private & & ! func . isOperator ( ) ) // TODO: There are smarter ways to check private operator usage
2018-07-13 23:43:03 +02:00
privateFuncs . push_back ( & func ) ;
2010-01-16 08:47:46 +01:00
}
2013-01-16 15:37:07 +01:00
// Bailout for overridden virtual functions of base classes
2013-03-05 15:28:40 +01:00
if ( ! scope - > definedType - > derivedFrom . empty ( ) ) {
2012-03-24 10:50:19 +01:00
// Check virtual functions
2014-08-06 13:35:04 +02:00
for ( std : : list < const Function * > : : iterator it = privateFuncs . begin ( ) ; it ! = privateFuncs . end ( ) ; ) {
2012-10-10 20:42:07 +02:00
if ( ( * it ) - > isImplicitlyVirtual ( true ) ) // Give true as default value to be returned if we don't see all base classes
2014-08-06 13:35:04 +02:00
privateFuncs . erase ( it + + ) ;
2012-03-24 10:50:19 +01:00
else
2012-10-10 20:42:07 +02:00
+ + it ;
2012-03-24 10:50:19 +01:00
}
}
2011-02-22 12:47:28 +01:00
2014-08-06 13:35:04 +02:00
while ( ! privateFuncs . empty ( ) ) {
2012-02-24 20:45:56 +01:00
// Check that all private functions are used
2016-05-16 09:36:26 +02:00
bool used = checkFunctionUsage ( privateFuncs . front ( ) , scope ) ; // Usage in this class
2012-02-24 20:45:56 +01:00
// Check in friend classes
2018-05-14 12:18:59 +02:00
const std : : vector < Type : : FriendInfo > & friendList = scope - > definedType - > friendList ;
2019-07-16 09:03:45 +02:00
for ( int i = 0 ; i < friendList . size ( ) & & ! used ; i + + ) {
2018-05-14 12:18:59 +02:00
if ( friendList [ i ] . type )
used = checkFunctionUsage ( privateFuncs . front ( ) , friendList [ i ] . type - > classScope ) ;
2013-03-05 15:28:40 +01:00
else
used = true ; // Assume, it is used if we do not see friend class
2013-08-26 16:41:23 +02:00
}
2012-02-24 20:45:56 +01:00
2013-02-16 10:51:08 +01:00
if ( ! used )
2016-05-16 09:36:26 +02:00
unusedPrivateFunctionError ( privateFuncs . front ( ) - > tokenDef , scope - > className , privateFuncs . front ( ) - > name ( ) ) ;
2010-01-16 08:47:46 +01:00
2014-08-06 13:35:04 +02:00
privateFuncs . pop_front ( ) ;
2010-01-16 08:47:46 +01:00
}
}
}
2010-11-14 06:50:33 +01:00
void CheckClass : : unusedPrivateFunctionError ( const Token * tok , const std : : string & classname , const std : : string & funcname )
{
2021-02-24 22:00:06 +01:00
reportError ( tok , Severity : : style , " unusedPrivateFunction " , " $symbol: " + classname + " :: " + funcname + " \n Unused private function: '$symbol' " , CWE398 , Certainty : : normal ) ;
2010-11-14 06:50:33 +01:00
}
2010-01-16 08:47:46 +01:00
//---------------------------------------------------------------------------
// ClassCheck: Check that memset is not used on classes
//---------------------------------------------------------------------------
2013-02-27 06:59:04 +01:00
static const Scope * findFunctionOf ( const Scope * scope )
2013-02-16 20:02:43 +01:00
{
while ( scope ) {
if ( scope - > type = = Scope : : eFunction )
return scope - > functionOf ;
scope = scope - > nestedIn ;
}
2017-08-09 20:00:26 +02:00
return nullptr ;
2013-02-16 20:02:43 +01:00
}
2013-11-18 16:56:00 +01:00
void CheckClass : : checkMemset ( )
2010-01-16 08:47:46 +01:00
{
2021-02-24 22:00:06 +01:00
const bool printWarnings = mSettings - > severity . isEnabled ( Severity : : warning ) ;
2018-06-17 18:43:54 +02:00
for ( const Scope * scope : mSymbolDatabase - > functionScopes ) {
2018-04-27 22:36:30 +02:00
for ( const Token * tok = scope - > bodyStart ; tok & & tok ! = scope - > bodyEnd ; tok = tok - > next ( ) ) {
2015-12-24 14:40:48 +01:00
if ( Token : : Match ( tok , " memset|memcpy|memmove ( " ) ) {
2013-03-01 15:07:20 +01:00
const Token * arg1 = tok - > tokAt ( 2 ) ;
2014-07-23 16:51:23 +02:00
const Token * arg3 = arg1 - > nextArgument ( ) ;
2014-06-09 11:35:30 +02:00
if ( arg3 )
arg3 = arg3 - > nextArgument ( ) ;
2013-05-17 14:10:53 +02:00
if ( ! arg3 )
// weird, shouldn't happen: memset etc should have
// 3 arguments.
continue ;
2013-03-01 15:07:20 +01:00
2014-02-16 11:47:52 +01:00
const Token * typeTok = nullptr ;
const Scope * type = nullptr ;
2013-03-01 15:07:20 +01:00
if ( Token : : Match ( arg3 , " sizeof ( %type% ) ) " ) )
typeTok = arg3 - > tokAt ( 2 ) ;
else if ( Token : : Match ( arg3 , " sizeof ( %type% :: %type% ) ) " ) )
typeTok = arg3 - > tokAt ( 4 ) ;
else if ( Token : : Match ( arg3 , " sizeof ( struct %type% ) ) " ) )
typeTok = arg3 - > tokAt ( 3 ) ;
else if ( Token : : simpleMatch ( arg3 , " sizeof ( * this ) ) " ) || Token::simpleMatch(arg1, " this , " )) {
type = findFunctionOf ( arg3 - > scope ( ) ) ;
2013-03-04 11:47:29 +01:00
} else if ( Token : : Match ( arg1 , " &|*|%var% " ) ) {
2015-12-05 18:22:01 +01:00
int numIndirToVariableType = 0 ; // Offset to the actual type in terms of dereference/addressof
2013-03-04 11:47:29 +01:00
for ( ; ; arg1 = arg1 - > next ( ) ) {
if ( arg1 - > str ( ) = = " & " )
2015-08-23 19:57:58 +02:00
+ + numIndirToVariableType ;
2013-03-04 11:47:29 +01:00
else if ( arg1 - > str ( ) = = " * " )
2015-08-23 19:57:58 +02:00
- - numIndirToVariableType ;
2013-03-04 11:47:29 +01:00
else
break ;
}
2015-12-05 18:22:01 +01:00
const Variable * const var = arg1 - > variable ( ) ;
2013-03-04 11:47:29 +01:00
if ( var & & arg1 - > strAt ( 1 ) = = " , " ) {
2015-08-23 19:57:58 +02:00
if ( var - > isArrayOrPointer ( ) ) {
const Token * endTok = var - > typeEndToken ( ) ;
2017-02-06 15:37:12 +01:00
while ( Token : : simpleMatch ( endTok , " * " ) ) {
2015-08-27 23:35:22 +02:00
+ + numIndirToVariableType ;
2015-08-23 19:57:58 +02:00
endTok = endTok - > previous ( ) ;
}
2013-08-31 03:03:16 +02:00
}
2013-03-04 11:47:29 +01:00
if ( var - > isArray ( ) )
2015-12-05 18:22:01 +01:00
numIndirToVariableType + = int ( var - > dimensions ( ) . size ( ) ) ;
2013-03-04 11:47:29 +01:00
2015-08-23 19:57:58 +02:00
if ( numIndirToVariableType = = 1 )
2013-03-05 13:33:38 +01:00
type = var - > typeScope ( ) ;
2013-03-04 11:47:29 +01:00
}
2013-03-01 15:07:20 +01:00
}
2011-03-13 04:41:21 +01:00
2013-03-01 15:07:20 +01:00
// No type defined => The tokens didn't match
if ( ! typeTok & & ! type )
continue ;
2012-10-10 20:42:07 +02:00
2013-03-01 15:07:20 +01:00
if ( typeTok & & typeTok - > str ( ) = = " ( " )
typeTok = typeTok - > next ( ) ;
2010-01-16 08:47:46 +01:00
2015-08-14 20:46:13 +02:00
if ( ! type & & typeTok - > type ( ) )
type = typeTok - > type ( ) - > classScope ;
2012-04-05 09:43:40 +02:00
2014-03-30 17:38:07 +02:00
if ( type ) {
2018-04-04 21:51:31 +02:00
const std : : set < const Scope * > parsedTypes ;
2015-01-17 16:28:39 +01:00
checkMemsetType ( scope , tok , type , false , parsedTypes ) ;
2014-03-30 17:38:07 +02:00
}
2013-03-05 13:33:38 +01:00
} else if ( tok - > variable ( ) & & tok - > variable ( ) - > typeScope ( ) & & Token : : Match ( tok , " %var% = calloc|malloc|realloc|g_malloc|g_try_malloc|g_realloc|g_try_realloc ( " ) ) {
2018-04-04 21:51:31 +02:00
const std : : set < const Scope * > parsedTypes ;
2015-01-17 16:28:39 +01:00
checkMemsetType ( scope , tok - > tokAt ( 2 ) , tok - > variable ( ) - > typeScope ( ) , true , parsedTypes ) ;
2011-03-23 02:24:28 +01:00
2017-09-04 22:33:14 +02:00
if ( printWarnings & & tok - > variable ( ) - > typeScope ( ) - > numConstructors > 0 )
2013-03-05 13:33:38 +01:00
mallocOnClassWarning ( tok , tok - > strAt ( 2 ) , tok - > variable ( ) - > typeScope ( ) - > classDef ) ;
2013-03-01 15:07:20 +01:00
}
2011-03-13 04:41:21 +01:00
}
2010-01-16 08:47:46 +01:00
}
}
2015-12-25 14:19:27 +01:00
void CheckClass : : checkMemsetType ( const Scope * start , const Token * tok , const Scope * type , bool allocation , std : : set < const Scope * > parsedTypes )
2011-03-26 03:21:40 +01:00
{
2014-03-30 17:38:07 +02:00
// If type has been checked there is no need to check it again
2015-12-25 14:19:27 +01:00
if ( parsedTypes . find ( type ) ! = parsedTypes . end ( ) )
2014-03-30 17:38:07 +02:00
return ;
2015-12-25 14:19:27 +01:00
parsedTypes . insert ( type ) ;
2014-03-30 17:38:07 +02:00
2021-02-24 22:00:06 +01:00
const bool printPortability = mSettings - > severity . isEnabled ( Severity : : portability ) ;
2015-12-05 18:22:01 +01:00
2011-03-26 03:21:40 +01:00
// recursively check all parent classes
2019-09-19 20:29:33 +02:00
for ( const Type : : BaseInfo & i : type - > definedType - > derivedFrom ) {
const Type * derivedFrom = i . type ;
2014-07-23 16:51:23 +02:00
if ( derivedFrom & & derivedFrom - > classScope )
checkMemsetType ( start , tok , derivedFrom - > classScope , allocation , parsedTypes ) ;
2011-03-26 03:21:40 +01:00
}
// Warn if type is a class that contains any virtual functions
2018-07-14 07:55:18 +02:00
for ( const Function & func : type - > functionList ) {
2019-07-04 12:32:32 +02:00
if ( func . hasVirtualSpecifier ( ) ) {
2013-03-01 15:07:20 +01:00
if ( allocation )
2019-01-14 19:54:34 +01:00
mallocOnClassError ( tok , tok - > str ( ) , type - > classDef , " virtual function " ) ;
2013-03-01 15:07:20 +01:00
else
2019-01-14 19:54:34 +01:00
memsetError ( tok , tok - > str ( ) , " virtual function " , type - > classDef - > str ( ) ) ;
2013-03-02 07:30:55 +01:00
}
2011-03-26 03:21:40 +01:00
}
// Warn if type is a class or struct that contains any std::* variables
2018-07-14 07:55:18 +02:00
for ( const Variable & var : type - > varlist ) {
if ( var . isReference ( ) & & ! var . isStatic ( ) ) {
2014-03-15 18:22:29 +01:00
memsetErrorReference ( tok , tok - > str ( ) , type - > classDef - > str ( ) ) ;
continue ;
}
2016-05-04 13:38:36 +02:00
// don't warn if variable static or const, pointer or array of pointers
2018-07-14 07:55:18 +02:00
if ( ! var . isStatic ( ) & & ! var . isConst ( ) & & ! var . isPointer ( ) & & ( ! var . isArray ( ) | | var . typeEndToken ( ) - > str ( ) ! = " * " ) ) {
const Token * tok1 = var . typeStartToken ( ) ;
const Scope * typeScope = var . typeScope ( ) ;
2011-03-26 03:21:40 +01:00
2019-04-01 19:32:00 +02:00
std : : string typeName ;
if ( Token : : Match ( tok1 , " %type% :: " ) ) {
const Token * typeTok = tok1 ;
while ( Token : : Match ( typeTok , " %type% :: " ) ) {
typeName + = typeTok - > str ( ) + " :: " ;
typeTok = typeTok - > tokAt ( 2 ) ;
}
typeName + = typeTok - > str ( ) ;
}
2012-08-20 17:27:43 +02:00
// check for std:: type
2019-04-01 19:32:00 +02:00
if ( var . isStlType ( ) & & typeName ! = " std::array " & & ! mSettings - > library . podtype ( typeName ) ) {
2013-03-01 15:07:20 +01:00
if ( allocation )
2019-04-01 19:32:00 +02:00
mallocOnClassError ( tok , tok - > str ( ) , type - > classDef , " ' " + typeName + " ' " ) ;
2013-03-01 15:07:20 +01:00
else
2019-04-01 19:32:00 +02:00
memsetError ( tok , tok - > str ( ) , " ' " + typeName + " ' " , type - > classDef - > str ( ) ) ;
}
2011-03-26 03:21:40 +01:00
2012-08-20 17:27:43 +02:00
// check for known type
2014-03-02 15:56:42 +01:00
else if ( typeScope & & typeScope ! = type )
2014-03-30 17:38:07 +02:00
checkMemsetType ( start , tok , typeScope , allocation , parsedTypes ) ;
2014-08-08 08:08:21 +02:00
// check for float
2018-07-14 07:55:18 +02:00
else if ( printPortability & & var . isFloatingType ( ) & & tok - > str ( ) = = " memset " )
2014-08-20 15:12:53 +02:00
memsetErrorFloat ( tok , type - > classDef - > str ( ) ) ;
2011-03-26 03:21:40 +01:00
}
}
}
2013-03-01 15:07:20 +01:00
void CheckClass : : mallocOnClassWarning ( const Token * tok , const std : : string & memfunc , const Token * classTok )
{
2018-04-09 09:54:39 +02:00
std : : list < const Token * > toks = { tok , classTok } ;
2013-03-01 15:07:20 +01:00
reportError ( toks , Severity : : warning , " mallocOnClassWarning " ,
2018-04-09 06:43:48 +02:00
" $symbol: " + memfunc + " \n "
" Memory for class instance allocated with $symbol(), but class provides constructors. \n "
" Memory for class instance allocated with $symbol(), but class provides constructors. This is unsafe, "
2021-02-24 22:00:06 +01:00
" since no constructor is called and class members remain uninitialized. Consider using 'new' instead. " , CWE762 , Certainty : : normal ) ;
2013-03-01 15:07:20 +01:00
}
void CheckClass : : mallocOnClassError ( const Token * tok , const std : : string & memfunc , const Token * classTok , const std : : string & classname )
{
2018-04-09 09:54:39 +02:00
std : : list < const Token * > toks = { tok , classTok } ;
2013-03-01 15:07:20 +01:00
reportError ( toks , Severity : : error , " mallocOnClassError " ,
2018-04-09 06:43:48 +02:00
" $symbol: " + memfunc + " \n "
" $symbol: " + classname + " \n "
2013-03-01 15:07:20 +01:00
" Memory for class instance allocated with " + memfunc + " (), but class contains a " + classname + " . \n "
" Memory for class instance allocated with " + memfunc + " (), but class a " + classname + " . This is unsafe, "
2021-02-24 22:00:06 +01:00
" since no constructor is called and class members remain uninitialized. Consider using 'new' instead. " , CWE665 , Certainty : : normal ) ;
2013-03-01 15:07:20 +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
{
2014-03-17 13:23:23 +01:00
reportError ( tok , Severity : : error , " memsetClass " ,
2018-04-09 06:43:48 +02:00
" $symbol: " + memfunc + " \n "
" $symbol: " + classname + " \n "
2014-03-17 13:23:23 +01:00
" Using ' " + memfunc + " ' on " + type + " that contains a " + classname + " . \n "
" Using ' " + memfunc + " ' on " + type + " that contains a " + classname + " is unsafe, because constructor, destructor "
" and copy operator calls are omitted. These are necessary for this non-POD type to ensure that a valid object "
2021-02-24 22:00:06 +01:00
" is created. " , CWE762 , Certainty : : normal ) ;
2010-11-14 06:50:33 +01:00
}
2010-01-16 08:47:46 +01:00
2014-03-15 18:22:29 +01:00
void CheckClass : : memsetErrorReference ( const Token * tok , const std : : string & memfunc , const std : : string & type )
{
2018-04-09 06:43:48 +02:00
reportError ( tok , Severity : : error , " memsetClassReference " ,
" $symbol: " + memfunc + " \n "
2021-02-24 22:00:06 +01:00
" Using ' " + memfunc + " ' on " + type + " that contains a reference. " , CWE665 , Certainty : : normal ) ;
2014-08-08 08:08:21 +02:00
}
2014-08-20 15:12:53 +02:00
void CheckClass : : memsetErrorFloat ( const Token * tok , const std : : string & type )
2014-08-08 08:08:21 +02:00
{
2014-08-20 15:12:53 +02:00
reportError ( tok , Severity : : portability , " memsetClassFloat " , " Using memset() on " + type + " which contains a floating point number. \n "
2015-02-22 15:41:02 +01:00
" Using memset() on " + type + " which contains a floating point number. "
" This is not portable because memset() sets each byte of a block of memory to a specific value and "
" the actual representation of a floating-point value is implementation defined. "
2021-02-24 22:00:06 +01:00
" Note: In case of an IEEE754-1985 compatible implementation setting all bits to zero results in the value 0.0. " , CWE758 , Certainty : : normal ) ;
2014-03-15 18:22:29 +01:00
}
2010-01-16 08:47:46 +01:00
//---------------------------------------------------------------------------
// ClassCheck: "C& operator=(const C&) { ... return *this; }"
// operator= should return a reference to *this
//---------------------------------------------------------------------------
2011-03-26 03:21:40 +01:00
void CheckClass : : operatorEqRetRefThis ( )
{
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > severity . isEnabled ( Severity : : style ) )
2011-03-26 03:21:40 +01:00
return ;
2018-06-17 18:43:54 +02:00
for ( const Scope * scope : mSymbolDatabase - > classAndStructScopes ) {
2018-04-05 15:48:23 +02:00
for ( std : : list < Function > : : const_iterator func = scope - > functionList . begin ( ) ; func ! = scope - > functionList . end ( ) ; + + func ) {
2015-01-08 05:45:31 +01:00
if ( func - > type = = Function : : eOperatorEqual & & func - > hasBody ( ) ) {
2012-10-10 20:42:07 +02:00
// make sure return signature is correct
2018-11-05 06:55:30 +01:00
if ( func - > retType = = func - > nestedIn - > definedType & & func - > tokenDef - > strAt ( - 1 ) = = " & " ) {
2018-04-27 22:36:30 +02:00
checkReturnPtrThis ( scope , & ( * func ) , func - > functionScope - > bodyStart , func - > functionScope - > bodyEnd ) ;
2011-03-26 03:21:40 +01:00
}
}
}
}
}
2014-07-24 14:54:20 +02:00
void CheckClass : : checkReturnPtrThis ( const Scope * scope , const Function * func , const Token * tok , const Token * last )
{
std : : set < const Function * > analyzedFunctions ;
checkReturnPtrThis ( scope , func , tok , last , analyzedFunctions ) ;
}
void CheckClass : : checkReturnPtrThis ( const Scope * scope , const Function * func , const Token * tok , const Token * last , std : : set < const Function * > & analyzedFunctions )
2010-09-11 08:23:30 +02:00
{
bool foundReturn = false ;
2015-01-24 11:18:33 +01:00
const Token * const startTok = tok ;
2011-10-13 20:53:06 +02:00
for ( ; tok & & tok ! = last ; tok = tok - > next ( ) ) {
2010-09-11 08:23:30 +02:00
// check for return of reference to this
2017-07-26 22:03:55 +02:00
if ( tok - > str ( ) ! = " return " )
continue ;
foundReturn = true ;
2019-05-20 21:30:20 +02:00
const Token * retExpr = tok - > astOperand1 ( ) ;
if ( retExpr & & retExpr - > str ( ) = = " = " )
retExpr = retExpr - > astOperand1 ( ) ;
if ( retExpr & & retExpr - > isUnaryOp ( " * " ) & & Token : : simpleMatch ( retExpr - > astOperand1 ( ) , " this " ) )
continue ;
2017-07-26 22:03:55 +02:00
std : : string cast ( " ( " + scope - > className + " & ) " ) ;
2020-05-26 20:13:56 +02:00
if ( Token : : simpleMatch ( tok - > next ( ) , cast . c_str ( ) , cast . size ( ) ) )
2017-07-26 22:03:55 +02:00
tok = tok - > tokAt ( 4 ) ;
// check if a function is called
if ( tok - > strAt ( 2 ) = = " ( " & &
tok - > linkAt ( 2 ) - > next ( ) - > str ( ) = = " ; " ) {
// check if it is a member function
2018-04-05 15:48:23 +02:00
for ( std : : list < Function > : : const_iterator it = scope - > functionList . begin ( ) ; it ! = scope - > functionList . end ( ) ; + + it ) {
2017-07-26 22:03:55 +02:00
// check for a regular function with the same name and a body
if ( it - > type = = Function : : eFunction & & it - > hasBody ( ) & &
it - > token - > str ( ) = = tok - > next ( ) - > str ( ) ) {
// check for the proper return type
if ( it - > tokenDef - > previous ( ) - > str ( ) = = " & " & &
it - > tokenDef - > strAt ( - 2 ) = = scope - > className ) {
// make sure it's not a const function
if ( ! it - > isConst ( ) ) {
/** @todo make sure argument types match */
// avoid endless recursions
if ( analyzedFunctions . find ( & * it ) = = analyzedFunctions . end ( ) ) {
analyzedFunctions . insert ( & * it ) ;
checkReturnPtrThis ( scope , & * it , it - > arg - > link ( ) - > next ( ) , it - > arg - > link ( ) - > next ( ) - > link ( ) ,
analyzedFunctions ) ;
2011-01-21 19:54:41 +01:00
}
2017-07-26 22:03:55 +02:00
// just bail for now
else
return ;
2010-09-11 08:23:30 +02:00
}
}
}
}
}
2017-07-26 22:03:55 +02:00
// check if *this is returned
2019-05-20 21:30:20 +02:00
else if ( ! ( Token : : simpleMatch ( tok - > next ( ) , " operator= ( " ) | |
2017-07-26 22:03:55 +02:00
Token : : simpleMatch ( tok - > next ( ) , " this . operator= ( " ) | |
( Token : : Match ( tok - > next ( ) , " %type% :: operator= ( " ) & &
tok - > next ( ) - > str ( ) = = scope - > className ) ) )
operatorEqRetRefThisError ( func - > token ) ;
2010-09-11 08:23:30 +02:00
}
2015-01-24 11:18:33 +01:00
if ( foundReturn ) {
return ;
}
if ( startTok - > next ( ) = = last ) {
2020-05-26 20:13:56 +02:00
const std : : string tmp ( " ( const " + scope - > className + " & " ) ;
if ( Token : : simpleMatch ( func - > argDef , tmp . c_str ( ) , tmp . size ( ) ) ) {
2015-01-24 11:18:33 +01:00
// Typical wrong way to suppress default assignment operator by declaring it and leaving empty
2019-07-23 14:29:02 +02:00
operatorEqMissingReturnStatementError ( func - > token , func - > access = = AccessControl : : Public ) ;
2015-01-24 11:18:33 +01:00
} else {
operatorEqMissingReturnStatementError ( func - > token , true ) ;
}
return ;
}
2018-06-16 16:10:28 +02:00
if ( mSettings - > library . isScopeNoReturn ( last , nullptr ) ) {
2015-01-24 11:18:33 +01:00
// Typical wrong way to prohibit default assignment operator
// by always throwing an exception or calling a noreturn function
operatorEqShouldBeLeftUnimplementedError ( func - > token ) ;
return ;
}
2019-07-23 14:29:02 +02:00
operatorEqMissingReturnStatementError ( func - > token , func - > access = = AccessControl : : Public ) ;
2010-09-11 08:23:30 +02:00
}
2010-11-14 06:50:33 +01:00
void CheckClass : : operatorEqRetRefThisError ( const Token * tok )
{
2021-02-24 22:00:06 +01:00
reportError ( tok , Severity : : style , " operatorEqRetRefThis " , " 'operator=' should return reference to 'this' instance. " , CWE398 , Certainty : : normal ) ;
2010-11-14 06:50:33 +01:00
}
2010-01-16 08:47:46 +01:00
2015-01-24 11:18:33 +01:00
void CheckClass : : operatorEqShouldBeLeftUnimplementedError ( const Token * tok )
{
2021-02-24 22:00:06 +01:00
reportError ( tok , Severity : : style , " operatorEqShouldBeLeftUnimplemented " , " 'operator=' should either return reference to 'this' instance or be declared private and left unimplemented. " , CWE398 , Certainty : : normal ) ;
2015-01-24 11:18:33 +01:00
}
void CheckClass : : operatorEqMissingReturnStatementError ( const Token * tok , bool error )
{
if ( error ) {
2021-02-24 22:00:06 +01:00
reportError ( tok , Severity : : error , " operatorEqMissingReturnStatement " , " No 'return' statement in non-void function causes undefined behavior. " , CWE398 , Certainty : : normal ) ;
2015-01-24 11:18:33 +01:00
} else {
operatorEqRetRefThisError ( tok ) ;
}
}
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 ( )
{
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > severity . isEnabled ( Severity : : warning ) )
2010-11-14 06:50:33 +01:00
return ;
2018-06-17 18:43:54 +02:00
for ( const Scope * scope : mSymbolDatabase - > classAndStructScopes ) {
2010-11-14 06:50:33 +01:00
// skip classes with multiple inheritance
2013-03-05 15:28:40 +01:00
if ( scope - > definedType - > derivedFrom . size ( ) > 1 )
2010-11-14 06:50:33 +01:00
continue ;
2018-07-13 23:43:03 +02:00
for ( const Function & func : scope - > functionList ) {
if ( func . type = = Function : : eOperatorEqual & & func . hasBody ( ) ) {
2012-04-25 20:25:51 +02:00
// make sure that the operator takes an object of the same type as *this, otherwise we can't detect self-assignment checks
2018-07-13 23:43:03 +02:00
if ( func . argumentList . empty ( ) )
2012-04-25 20:25:51 +02:00
continue ;
2018-07-13 23:43:03 +02:00
const Token * typeTok = func . argumentList . front ( ) . typeEndToken ( ) ;
2012-04-25 20:25:51 +02:00
while ( typeTok - > str ( ) = = " const " | | typeTok - > str ( ) = = " & " | | typeTok - > str ( ) = = " * " )
typeTok = typeTok - > previous ( ) ;
if ( typeTok - > str ( ) ! = scope - > className )
continue ;
2010-11-14 06:50:33 +01:00
// make sure return signature is correct
2018-07-13 23:43:03 +02:00
if ( Token : : Match ( func . retDef , " %type% & " ) & & func . retDef - > str ( ) = = scope - > className ) {
2011-04-01 01:53:35 +02:00
// find the parameter name
2018-07-13 23:43:03 +02:00
const Token * rhs = func . argumentList . begin ( ) - > nameToken ( ) ;
2021-02-02 15:00:46 +01:00
const Token * out_ifStatementScopeStart = nullptr ;
if ( ! hasAssignSelf ( & func , rhs , & out_ifStatementScopeStart ) ) {
2018-07-13 23:43:03 +02:00
if ( hasAllocation ( & func , scope ) )
operatorEqToSelfError ( func . token ) ;
2021-02-02 15:01:28 +01:00
} else if ( out_ifStatementScopeStart ! = nullptr ) {
if ( hasAllocationInIfScope ( & func , scope , out_ifStatementScopeStart ) )
operatorEqToSelfError ( func . token ) ;
2021-02-02 15:00:46 +01:00
}
2010-11-14 06:50:33 +01:00
}
}
}
}
}
2021-02-02 15:00:46 +01:00
bool CheckClass : : hasAllocationInIfScope ( const Function * func , const Scope * scope , const Token * ifStatementScopeStart ) const
{
2021-02-02 15:01:28 +01:00
const Token * end ;
if ( ifStatementScopeStart - > str ( ) = = " { " )
end = ifStatementScopeStart - > link ( ) ;
else
end = func - > functionScope - > bodyEnd ;
return hasAllocation ( func , scope , ifStatementScopeStart , end ) ;
2021-02-02 15:00:46 +01:00
}
2014-03-15 18:22:29 +01:00
bool CheckClass : : hasAllocation ( const Function * func , const Scope * scope ) const
2010-01-16 08:47:46 +01:00
{
2021-02-02 15:01:28 +01:00
return hasAllocation ( func , scope , func - > functionScope - > bodyStart , func - > functionScope - > bodyEnd ) ;
2021-02-02 15:00:46 +01:00
}
bool CheckClass : : hasAllocation ( const Function * func , const Scope * scope , const Token * start , const Token * end ) const
{
2021-02-02 15:01:28 +01:00
if ( ! end )
end = func - > functionScope - > bodyEnd ;
2021-02-02 15:00:46 +01:00
for ( const Token * tok = start ; tok & & ( tok ! = end ) ; tok = tok - > next ( ) ) {
2012-04-05 09:43:40 +02:00
if ( Token : : Match ( tok , " %var% = malloc|realloc|calloc|new " ) & & isMemberVar ( scope , tok ) )
return true ;
2010-01-16 08:47:46 +01:00
2012-04-05 09:43:40 +02:00
// check for deallocating memory
2016-08-05 14:05:37 +02:00
const Token * var ;
2012-04-05 09:43:40 +02:00
if ( Token : : Match ( tok , " free ( %var% " ) )
var = tok - > tokAt ( 2 ) ;
else if ( Token : : Match ( tok , " delete [ ] %var% " ) )
var = tok - > tokAt ( 3 ) ;
else if ( Token : : Match ( tok , " delete %var% " ) )
var = tok - > next ( ) ;
2016-08-05 14:05:37 +02:00
else
continue ;
2013-01-16 15:37:07 +01:00
// Check for assignment to the deleted pointer (only if its a member of the class)
2016-08-05 14:05:37 +02:00
if ( isMemberVar ( scope , var ) ) {
2021-02-02 15:00:46 +01:00
for ( const Token * tok1 = var - > next ( ) ; tok1 & & ( tok1 ! = end ) ; tok1 = tok1 - > next ( ) ) {
2015-01-31 12:31:34 +01:00
if ( Token : : Match ( tok1 , " %varid% = " , var - > varId ( ) ) )
return true ;
2010-01-16 08:47:46 +01:00
}
}
}
return false ;
}
2021-02-02 15:00:46 +01:00
static bool isTrueKeyword ( const Token * tok )
{
2021-02-02 15:01:28 +01:00
return tok - > hasKnownIntValue ( ) & & tok - > getKnownIntValue ( ) = = 1 ;
2021-02-02 15:00:46 +01:00
}
static bool isFalseKeyword ( const Token * tok )
{
2021-02-02 15:01:28 +01:00
return tok - > hasKnownIntValue ( ) & & tok - > getKnownIntValue ( ) = = 0 ;
2021-02-02 15:00:46 +01:00
}
/*
* Checks if self - assignment test is inverse
* For example ' if ( this = = & rhs ) '
*/
CheckClass : : Bool CheckClass : : isInverted ( const Token * tok , const Token * rhs )
{
2021-02-02 15:01:28 +01:00
bool res = true ;
for ( const Token * itr = tok ; itr & & itr - > str ( ) ! = " ( " ; itr = itr - > astParent ( ) ) {
if ( Token : : simpleMatch ( itr , " != " ) & & ( isTrueKeyword ( itr - > astOperand1 ( ) ) | | isTrueKeyword ( itr - > astOperand2 ( ) ) ) ) {
res = ! res ;
} else if ( Token : : simpleMatch ( itr , " != " ) & & ( ( Token : : simpleMatch ( itr - > astOperand1 ( ) , " this " ) & & Token : : simpleMatch ( itr - > astOperand2 ( ) , " & " ) & & Token : : simpleMatch ( itr - > astOperand2 ( ) - > next ( ) , rhs - > str ( ) . c_str ( ) , rhs - > str ( ) . size ( ) ) )
2021-08-07 20:51:18 +02:00
| | ( Token : : simpleMatch ( itr - > astOperand2 ( ) , " this " ) & & Token : : simpleMatch ( itr - > astOperand1 ( ) , " & " ) & & Token : : simpleMatch ( itr - > astOperand1 ( ) - > next ( ) , rhs - > str ( ) . c_str ( ) , rhs - > str ( ) . size ( ) ) ) ) ) {
2021-02-02 15:01:28 +01:00
res = ! res ;
} else if ( Token : : simpleMatch ( itr , " != " ) & & ( isFalseKeyword ( itr - > astOperand1 ( ) ) | | isFalseKeyword ( itr - > astOperand2 ( ) ) ) ) {
//Do nothing
} else if ( Token : : simpleMatch ( itr , " ! " ) ) {
res = ! res ;
} else if ( Token : : simpleMatch ( itr , " == " ) & & ( isFalseKeyword ( itr - > astOperand1 ( ) ) | | isFalseKeyword ( itr - > astOperand2 ( ) ) ) ) {
res = ! res ;
} else if ( Token : : simpleMatch ( itr , " == " ) & & ( isTrueKeyword ( itr - > astOperand1 ( ) ) | | isTrueKeyword ( itr - > astOperand2 ( ) ) ) ) {
//Do nothing
} else if ( Token : : simpleMatch ( itr , " == " ) & & ( ( Token : : simpleMatch ( itr - > astOperand1 ( ) , " this " ) & & Token : : simpleMatch ( itr - > astOperand2 ( ) , " & " ) & & Token : : simpleMatch ( itr - > astOperand2 ( ) - > next ( ) , rhs - > str ( ) . c_str ( ) , rhs - > str ( ) . size ( ) ) )
2021-08-07 20:51:18 +02:00
| | ( Token : : simpleMatch ( itr - > astOperand2 ( ) , " this " ) & & Token : : simpleMatch ( itr - > astOperand1 ( ) , " & " ) & & Token : : simpleMatch ( itr - > astOperand1 ( ) - > next ( ) , rhs - > str ( ) . c_str ( ) , rhs - > str ( ) . size ( ) ) ) ) ) {
2021-02-02 15:01:28 +01:00
//Do nothing
} else {
return Bool : : BAILOUT ;
}
}
if ( res )
return Bool : : TRUE ;
return Bool : : FALSE ;
2021-02-02 15:00:46 +01:00
}
const Token * CheckClass : : getIfStmtBodyStart ( const Token * tok , const Token * rhs )
{
2021-02-02 15:01:28 +01:00
const Token * top = tok - > astTop ( ) ;
if ( Token : : simpleMatch ( top - > link ( ) , " ) { " ) ) {
switch ( isInverted ( tok - > astParent ( ) , rhs ) ) {
case Bool : : BAILOUT :
return nullptr ;
case Bool : : TRUE :
return top - > link ( ) - > next ( ) ;
case Bool : : FALSE :
return top - > link ( ) - > next ( ) - > link ( ) ;
}
}
return nullptr ;
2021-02-02 15:00:46 +01:00
}
bool CheckClass : : hasAssignSelf ( const Function * func , const Token * rhs , const Token * * out_ifStatementScopeStart )
2010-01-16 08:47:46 +01:00
{
2015-07-20 19:04:34 +02:00
if ( ! rhs )
return false ;
2018-04-27 22:36:30 +02:00
const Token * last = func - > functionScope - > bodyEnd ;
for ( const Token * tok = func - > functionScope - > bodyStart ; tok & & tok ! = last ; tok = tok - > next ( ) ) {
2017-07-28 23:49:11 +02:00
if ( ! Token : : simpleMatch ( tok , " if ( " ) )
continue ;
2018-11-23 20:33:31 +01:00
bool ret = false ;
visitAstNodes ( tok - > next ( ) - > astOperand2 ( ) ,
2021-08-07 20:51:18 +02:00
[ & ] ( const Token * tok2 ) {
2017-07-28 23:49:11 +02:00
if ( ! Token : : Match ( tok2 , " ==|!= " ) )
2018-11-23 20:33:31 +01:00
return ChildrenToVisit : : op1_and_op2 ;
2017-07-28 23:49:11 +02:00
if ( Token : : simpleMatch ( tok2 - > astOperand1 ( ) , " this " ) )
tok2 = tok2 - > astOperand2 ( ) ;
else if ( Token : : simpleMatch ( tok2 - > astOperand2 ( ) , " this " ) )
tok2 = tok2 - > astOperand1 ( ) ;
else
2018-11-23 20:33:31 +01:00
return ChildrenToVisit : : op1_and_op2 ;
2018-07-13 23:17:24 +02:00
if ( tok2 & & tok2 - > isUnaryOp ( " & " ) & & tok2 - > astOperand1 ( ) - > str ( ) = = rhs - > str ( ) )
2018-11-23 20:33:31 +01:00
ret = true ;
2021-02-02 15:00:46 +01:00
if ( ret ) {
2021-02-02 15:01:28 +01:00
* out_ifStatementScopeStart = getIfStmtBodyStart ( tok2 , rhs ) ;
2021-02-02 15:00:46 +01:00
}
2018-11-23 20:33:31 +01:00
return ret ? ChildrenToVisit : : done : ChildrenToVisit : : op1_and_op2 ;
} ) ;
if ( ret )
return ret ;
2010-01-16 08:47:46 +01:00
}
return false ;
}
2010-11-14 06:50:33 +01:00
void CheckClass : : operatorEqToSelfError ( const Token * tok )
2010-01-16 08:47:46 +01:00
{
2012-07-09 11:11:05 +02:00
reportError ( tok , Severity : : warning , " operatorEqToSelf " ,
" 'operator=' should check for assignment to self to avoid problems with dynamic memory. \n "
" 'operator=' should check for assignment to self to ensure that each block of dynamically "
2021-02-24 22:00:06 +01:00
" allocated memory is owned and managed by only one instance of the class. " , CWE398 , Certainty : : normal ) ;
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
2019-09-27 09:55:39 +02:00
// * derived class has non-empty destructor (only c++03, in c++11 it's UB see paragraph 3 in [expr.delete])
2010-05-29 11:19:28 +02:00
// * base class is deleted
2014-06-14 12:55:20 +02:00
// unless inconclusive in which case:
2020-04-27 09:22:42 +02:00
// * A class with any virtual functions should have a destructor that is either public and virtual or protected
2021-02-24 22:00:06 +01:00
const bool printInconclusive = mSettings - > certainty . isEnabled ( Certainty : : inconclusive ) ;
2014-06-14 12:55:20 +02:00
2016-01-11 11:04:52 +01:00
std : : list < const Function * > inconclusiveErrors ;
2010-05-29 11:19:28 +02:00
2018-06-17 18:43:54 +02:00
for ( const Scope * scope : mSymbolDatabase - > classAndStructScopes ) {
2010-01-16 08:47:46 +01:00
2014-06-14 12:55:20 +02:00
// Skip base classes (unless inconclusive)
if ( scope - > definedType - > derivedFrom . empty ( ) ) {
2015-04-10 14:18:52 +02:00
if ( printInconclusive ) {
2014-06-14 12:55:20 +02:00
const Function * destructor = scope - > getDestructor ( ) ;
2020-09-04 18:56:12 +02:00
if ( destructor & & ! destructor - > hasVirtualSpecifier ( ) & & destructor - > access = = AccessControl : : Public ) {
for ( const Function & func : scope - > functionList ) {
if ( func . hasVirtualSpecifier ( ) ) {
inconclusiveErrors . push_back ( destructor ) ;
break ;
2014-06-14 12:55:20 +02:00
}
}
}
}
2010-08-13 18:34:02 +02:00
continue ;
2014-06-14 12:55:20 +02:00
}
2010-01-16 08:47:46 +01:00
2019-09-27 09:55:39 +02:00
// Check if destructor is empty and non-empty ..
if ( mSettings - > standards . cpp < = Standards : : CPP03 ) {
// Find the destructor
const Function * destructor = scope - > getDestructor ( ) ;
2010-08-13 18:34:02 +02:00
2019-09-27 09:55:39 +02:00
// Check for destructor with implementation
if ( ! destructor | | ! destructor - > hasBody ( ) )
continue ;
2010-08-13 18:34:02 +02:00
2019-09-27 09:55:39 +02:00
// Empty destructor
if ( destructor - > token - > linkAt ( 3 ) = = destructor - > token - > tokAt ( 4 ) )
continue ;
}
2010-01-16 08:47:46 +01:00
2011-01-17 18:29:19 +01:00
const Token * derived = scope - > classDef ;
2011-11-20 15:09:57 +01:00
const Token * derivedClass = derived - > next ( ) ;
2010-01-16 08:47:46 +01:00
// Iterate through each base class...
2019-09-19 20:29:33 +02:00
for ( const Type : : BaseInfo & j : scope - > definedType - > derivedFrom ) {
2010-08-13 18:34:02 +02:00
// Check if base class is public and exists in database
2019-09-19 20:29:33 +02:00
if ( j . access ! = AccessControl : : Private & & j . type ) {
const Type * derivedFrom = j . type ;
2013-03-05 15:28:40 +01:00
const Scope * derivedFromScope = derivedFrom - > classScope ;
if ( ! derivedFromScope )
continue ;
2010-01-16 08:47:46 +01:00
2011-04-20 18:03:16 +02:00
// Check for this pattern:
// 1. Base class pointer is given the address of derived class instance
// 2. Base class pointer is deleted
//
// If this pattern is not seen then bailout the checking of these base/derived classes
{
// pointer variables of type 'Base *'
2019-07-16 09:03:45 +02:00
std : : set < int > baseClassPointers ;
2011-04-20 18:03:16 +02:00
2018-06-17 18:43:54 +02:00
for ( const Variable * var : mSymbolDatabase - > variableList ( ) ) {
2013-03-05 15:28:40 +01:00
if ( var & & var - > isPointer ( ) & & var - > type ( ) = = derivedFrom )
2016-01-11 11:04:52 +01:00
baseClassPointers . insert ( var - > declarationId ( ) ) ;
2013-03-05 15:28:40 +01:00
}
2011-04-20 18:03:16 +02:00
// pointer variables of type 'Base *' that should not be deleted
2019-07-16 09:03:45 +02:00
std : : set < int > dontDelete ;
2011-04-20 18:03:16 +02:00
// No deletion of derived class instance through base class pointer found => the code is ok
bool ok = true ;
2011-04-21 01:07:28 +02:00
2018-06-16 16:10:28 +02:00
for ( const Token * tok = mTokenizer - > tokens ( ) ; tok ; tok = tok - > next ( ) ) {
2013-03-05 15:28:40 +01:00
if ( Token : : Match ( tok , " [;{}] %var% = " ) & &
2016-01-11 11:04:52 +01:00
baseClassPointers . find ( tok - > next ( ) - > varId ( ) ) ! = baseClassPointers . end ( ) ) {
2011-04-20 18:03:16 +02:00
// new derived class..
2020-05-26 20:13:56 +02:00
const std : : string tmp ( " new " + derivedClass - > str ( ) ) ;
if ( Token : : simpleMatch ( tok - > tokAt ( 3 ) , tmp . c_str ( ) , tmp . size ( ) ) ) {
2011-04-20 18:03:16 +02:00
dontDelete . insert ( tok - > next ( ) - > varId ( ) ) ;
}
}
// Delete base class pointer that might point at derived class
2011-12-17 11:39:20 +01:00
else if ( Token : : Match ( tok , " delete %var% ; " ) & &
dontDelete . find ( tok - > next ( ) - > varId ( ) ) ! = dontDelete . end ( ) ) {
2011-04-20 18:03:16 +02:00
ok = false ;
break ;
}
}
// No base class pointer that points at a derived class is deleted
if ( ok )
continue ;
}
2010-08-13 23:57:53 +02:00
// Find the destructor declaration for the base class.
2016-01-11 11:04:52 +01:00
const Function * baseDestructor = derivedFromScope - > getDestructor ( ) ;
2010-01-16 08:47:46 +01:00
2010-08-13 23:57:53 +02:00
// Check that there is a destructor..
2016-01-11 11:04:52 +01:00
if ( ! baseDestructor ) {
2014-06-14 12:55:20 +02:00
if ( derivedFrom - > derivedFrom . empty ( ) ) {
virtualDestructorError ( derivedFrom - > classDef , derivedFrom - > name ( ) , derivedClass - > str ( ) , false ) ;
}
2019-07-04 12:32:32 +02:00
} else if ( ! baseDestructor - > hasVirtualSpecifier ( ) ) {
2010-08-13 23:57:53 +02:00
// 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-10-13 20:53:06 +02: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.)
2019-07-23 14:29:02 +02:00
if ( baseDestructor - > access = = AccessControl : : Public ) {
2016-01-11 11:04:52 +01:00
virtualDestructorError ( baseDestructor - > token , derivedFrom - > name ( ) , derivedClass - > str ( ) , false ) ;
// check for duplicate error and remove it if found
2018-04-04 21:51:31 +02:00
const std : : list < const Function * > : : iterator found = find ( inconclusiveErrors . begin ( ) , inconclusiveErrors . end ( ) , baseDestructor ) ;
2016-01-11 11:04:52 +01:00
if ( found ! = inconclusiveErrors . end ( ) )
inconclusiveErrors . erase ( found ) ;
2014-06-14 12:55:20 +02:00
}
2010-08-13 23:57:53 +02:00
}
}
}
2010-01-16 08:47:46 +01:00
}
}
2014-06-14 12:55:20 +02:00
2018-07-13 23:45:34 +02:00
for ( const Function * func : inconclusiveErrors )
virtualDestructorError ( func - > tokenDef , func - > name ( ) , emptyString , true ) ;
2010-01-16 08:47:46 +01:00
}
2014-06-14 12:55:20 +02:00
void CheckClass : : virtualDestructorError ( const Token * tok , const std : : string & Base , const std : : string & Derived , bool inconclusive )
2010-01-16 08:47:46 +01:00
{
2016-11-22 23:59:39 +01:00
if ( inconclusive ) {
2021-02-24 22:00:06 +01:00
if ( mSettings - > severity . isEnabled ( Severity : : warning ) )
reportError ( tok , Severity : : warning , " virtualDestructor " , " $symbol: " + Base + " \n Class '$symbol' which has virtual members does not have a virtual destructor. " , CWE404 , Certainty : : inconclusive ) ;
2016-11-22 23:59:39 +01:00
} else {
2018-04-09 06:43:48 +02:00
reportError ( tok , Severity : : error , " virtualDestructor " ,
" $symbol: " + Base + " \n "
" $symbol: " + Derived + " \n "
" Class ' " + Base + " ' which is inherited by class ' " + Derived + " ' does not have a virtual destructor. \n "
2014-06-14 12:55:20 +02:00
" Class ' " + Base + " ' which is inherited by class ' " + Derived + " ' does not have a virtual destructor. "
" If you destroy instances of the derived class by deleting a pointer that points to the base class, only "
" the destructor of the base class is executed. Thus, dynamic memory that is managed by the derived class "
2021-02-24 22:00:06 +01:00
" could leak. This can be avoided by adding a virtual destructor to the base class. " , CWE404 , Certainty : : normal ) ;
2016-11-22 23:59:39 +01:00
}
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 ( )
{
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > severity . isEnabled ( Severity : : warning ) )
2010-04-21 08:38:25 +02:00
return ;
2018-06-16 16:10:28 +02:00
const Token * tok = mTokenizer - > tokens ( ) ;
2011-10-13 20:53:06 +02:00
for ( ; ; ) {
2015-01-31 10:50:39 +01:00
tok = Token : : findmatch ( tok , " this - %name% " ) ;
2010-04-02 07:30:58 +02:00
if ( ! tok )
2010-01-16 08:47:46 +01:00
break ;
2012-03-11 14:29:00 +01:00
if ( tok - > strAt ( - 1 ) ! = " * " )
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 )
{
2021-02-24 22:00:06 +01:00
reportError ( tok , Severity : : warning , " thisSubtraction " , " Suspicious pointer subtraction. Did you intend to write '->'? " , CWE398 , Certainty : : normal ) ;
2010-11-14 06:50:33 +01:00
}
//---------------------------------------------------------------------------
// 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 ( )
{
2012-09-17 17:59:35 +02:00
// This is an inconclusive check. False positives: #3322.
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > certainty . isEnabled ( Certainty : : inconclusive ) )
2011-11-20 16:54:06 +01:00
return ;
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > severity . isEnabled ( Severity : : style ) )
2010-01-23 09:38:35 +01:00
return ;
2018-06-17 18:43:54 +02:00
for ( const Scope * scope : mSymbolDatabase - > classAndStructScopes ) {
2018-10-03 12:54:59 +02:00
for ( const Function & func : scope - > functionList ) {
2010-07-26 16:46:37 +02:00
// does the function have a body?
2018-10-03 12:54:59 +02:00
if ( func . type ! = Function : : eFunction | | ! func . hasBody ( ) )
2016-09-04 16:06:54 +02:00
continue ;
2019-01-14 19:54:34 +01:00
// don't warn for friend/static/virtual functions
2019-07-04 12:32:32 +02:00
if ( func . isFriend ( ) | | func . isStatic ( ) | | func . hasVirtualSpecifier ( ) )
2016-09-04 15:38:56 +02:00
continue ;
2010-01-23 20:59:20 +01:00
2020-07-24 19:58:36 +02:00
// don't warn when returning non-const pointer/reference
2020-07-24 19:40:04 +02:00
{
bool isPointerOrReference = false ;
for ( const Token * typeToken = func . retDef ; typeToken ; typeToken = typeToken - > next ( ) ) {
if ( Token : : Match ( typeToken , " (|{|; " ) )
break ;
2020-07-24 19:58:36 +02:00
if ( ! isPointerOrReference & & typeToken - > str ( ) = = " const " )
2020-07-24 19:40:04 +02:00
break ;
if ( Token : : Match ( typeToken , " *|& " ) ) {
isPointerOrReference = true ;
2016-09-04 15:38:56 +02:00
break ;
}
2010-01-23 09:19:22 +01:00
}
2020-07-24 19:40:04 +02:00
if ( isPointerOrReference )
2016-09-04 15:38:56 +02:00
continue ;
2020-07-24 19:40:04 +02:00
}
if ( func . isOperator ( ) ) { // Operator without return type: conversion operator
2018-10-03 12:54:59 +02:00
const std : : string & opName = func . tokenDef - > str ( ) ;
2017-04-01 18:14:18 +02:00
if ( opName . compare ( 8 , 5 , " const " ) ! = 0 & & ( endsWith ( opName , ' & ' ) | | endsWith ( opName , ' * ' ) ) )
2016-09-04 15:38:56 +02:00
continue ;
2019-04-24 13:06:58 +02:00
} else if ( mSettings - > library . isSmartPointer ( func . retDef ) ) {
// Don't warn if a std::shared_ptr etc is returned
2018-08-07 18:06:14 +02:00
continue ;
2016-09-04 15:38:56 +02:00
} else {
// don't warn for unknown types..
// LPVOID, HDC, etc
2020-07-24 19:40:04 +02:00
if ( func . retDef - > str ( ) . size ( ) > 2 & & ! func . retDef - > type ( ) & & func . retDef - > isUpperCaseName ( ) )
2016-09-04 15:38:56 +02:00
continue ;
}
2010-04-18 15:40:31 +02:00
2016-09-04 15:38:56 +02:00
// check if base class function is virtual
2018-10-03 12:54:59 +02:00
if ( ! scope - > definedType - > derivedFrom . empty ( ) & & func . isImplicitlyVirtual ( true ) )
2016-09-04 16:06:54 +02:00
continue ;
2010-09-01 06:32:46 +02:00
2016-09-04 15:38:56 +02:00
bool memberAccessed = false ;
// if nothing non-const was found. write error..
2018-10-03 12:54:59 +02:00
if ( ! checkConstFunc ( scope , & func , memberAccessed ) )
2016-09-04 16:06:54 +02:00
continue ;
2016-09-04 15:38:56 +02:00
2018-10-03 12:54:59 +02:00
if ( func . isConst ( ) & & ( memberAccessed | | func . isOperator ( ) ) )
2016-09-04 16:06:54 +02:00
continue ;
2016-09-04 15:38:56 +02:00
2016-09-04 16:06:54 +02:00
std : : string classname = scope - > className ;
const Scope * nest = scope - > nestedIn ;
while ( nest & & nest - > type ! = Scope : : eGlobal ) {
classname = std : : string ( nest - > className + " :: " + classname ) ;
nest = nest - > nestedIn ;
2016-09-04 16:02:59 +02:00
}
2016-09-04 16:06:54 +02:00
// get function name
2018-10-03 12:54:59 +02:00
std : : string functionName = ( func . tokenDef - > isName ( ) ? " " : " operator " ) + func . tokenDef - > str ( ) ;
2016-09-04 16:06:54 +02:00
2018-10-03 12:54:59 +02:00
if ( func . tokenDef - > str ( ) = = " ( " )
2016-09-04 16:06:54 +02:00
functionName + = " ) " ;
2018-10-03 12:54:59 +02:00
else if ( func . tokenDef - > str ( ) = = " [ " )
2016-09-04 16:06:54 +02:00
functionName + = " ] " ;
2018-10-03 12:54:59 +02:00
if ( func . isInline ( ) )
checkConstError ( func . token , classname , functionName , ! memberAccessed & & ! func . isOperator ( ) ) ;
2016-09-04 16:06:54 +02:00
else // not inline
2018-10-03 12:54:59 +02:00
checkConstError2 ( func . token , func . tokenDef , classname , functionName , ! memberAccessed & & ! func . isOperator ( ) ) ;
2010-03-28 11:46:42 +02:00
}
}
}
2014-03-15 18:22:29 +01:00
bool CheckClass : : isMemberVar ( const Scope * scope , const Token * tok ) const
2011-01-16 11:18:12 +01:00
{
2011-03-27 19:59:12 +02:00
bool again = false ;
2011-01-16 11:18:12 +01:00
2011-03-27 19:59:12 +02:00
// try to find the member variable
2011-10-13 20:53:06 +02:00
do {
2011-03-27 19:59:12 +02:00
again = false ;
2011-01-16 11:18:12 +01:00
2011-10-13 20:53:06 +02:00
if ( tok - > str ( ) = = " this " ) {
2011-03-27 19:59:12 +02:00
return true ;
2011-10-27 10:41:34 +02:00
} else if ( Token : : simpleMatch ( tok - > tokAt ( - 3 ) , " ( * this ) " ) ) {
2011-08-28 15:21:00 +02:00
return true ;
2022-02-28 18:28:23 +01:00
} else if ( Token : : Match ( tok - > tokAt ( - 3 ) , " %name% ) . %name% " ) ) {
tok = tok - > tokAt ( - 3 ) ;
again = true ;
2015-01-31 10:50:39 +01:00
} else if ( Token : : Match ( tok - > tokAt ( - 2 ) , " %name% . %name% " ) ) {
2011-03-27 19:59:12 +02:00
tok = tok - > tokAt ( - 2 ) ;
again = true ;
2015-01-31 10:50:39 +01:00
} else if ( Token : : Match ( tok - > tokAt ( - 2 ) , " ] . %name% " ) ) {
2011-11-20 14:22:39 +01:00
tok = tok - > linkAt ( - 2 ) - > previous ( ) ;
2011-03-27 19:59:12 +02:00
again = true ;
2011-10-13 20:53:06 +02:00
} else if ( tok - > str ( ) = = " ] " ) {
2011-03-27 19:59:12 +02:00
tok = tok - > link ( ) - > previous ( ) ;
again = true ;
}
2011-10-13 20:53:06 +02:00
} while ( again ) ;
2011-01-16 11:18:12 +01:00
2022-02-20 18:17:47 +01:00
for ( const Variable & var : scope - > varlist ) {
2018-07-13 23:51:22 +02:00
if ( var . name ( ) = = tok - > str ( ) ) {
2022-03-16 15:29:34 +01:00
if ( Token : : Match ( tok , " %name% :: " ) )
continue ;
2022-02-20 18:17:47 +01:00
const Token * fqTok = tok ;
while ( Token : : Match ( fqTok - > tokAt ( - 2 ) , " %name% :: " ) )
fqTok = fqTok - > tokAt ( - 2 ) ;
if ( fqTok - > strAt ( - 1 ) = = " :: " )
fqTok = fqTok - > previous ( ) ;
bool isMember = tok = = fqTok ;
std : : string scopeStr ;
const Scope * curScope = scope ;
while ( ! isMember & & curScope & & curScope - > type ! = Scope : : ScopeType : : eGlobal ) {
scopeStr . insert ( 0 , curScope - > className + " :: " ) ;
isMember = Token : : Match ( fqTok , scopeStr . c_str ( ) ) ;
curScope = curScope - > nestedIn ;
}
if ( isMember ) {
if ( tok - > varId ( ) = = 0 )
mSymbolDatabase - > debugMessage ( tok , " varid0 " , " CheckClass::isMemberVar found used member variable \' " + tok - > str ( ) + " \' with varid 0 " ) ;
2011-03-27 20:27:14 +02:00
2022-02-20 18:17:47 +01:00
return ! var . isStatic ( ) ;
}
2011-01-16 11:18:12 +01:00
}
}
// not found in this class
2015-07-01 07:50:13 +02:00
if ( ! scope - > definedType - > derivedFrom . empty ( ) ) {
2011-01-16 11:18:12 +01:00
// check each base class
2019-09-19 20:29:33 +02:00
for ( const Type : : BaseInfo & i : scope - > definedType - > derivedFrom ) {
2011-01-16 11:18:12 +01:00
// find the base class
2019-09-19 20:29:33 +02:00
const Type * derivedFrom = i . type ;
2011-01-16 11:18:12 +01:00
// find the function in the base class
2021-01-18 19:01:04 +01:00
if ( derivedFrom & & derivedFrom - > classScope & & derivedFrom - > classScope ! = scope ) {
2013-03-05 15:28:40 +01:00
if ( isMemberVar ( derivedFrom - > classScope , tok ) )
2011-01-16 11:18:12 +01:00
return true ;
}
}
}
return false ;
}
2014-03-15 18:22:29 +01:00
bool CheckClass : : isMemberFunc ( const Scope * scope , const Token * tok ) const
2012-05-16 20:57:12 +02:00
{
2017-04-01 10:18:53 +02:00
if ( ! tok - > function ( ) ) {
2018-07-13 23:51:22 +02:00
for ( const Function & func : scope - > functionList ) {
if ( func . name ( ) = = tok - > str ( ) ) {
2017-04-01 10:18:53 +02:00
const Token * tok2 = tok - > tokAt ( 2 ) ;
2019-07-16 09:03:45 +02:00
int argsPassed = tok2 - > str ( ) = = " ) " ? 0 : 1 ;
2017-04-01 10:18:53 +02:00
for ( ; ; ) {
tok2 = tok2 - > nextArgument ( ) ;
if ( tok2 )
argsPassed + + ;
else
break ;
}
2020-10-31 10:02:15 +01:00
if ( argsPassed = = func . argCount ( ) | |
( func . isVariadic ( ) & & argsPassed > = ( func . argCount ( ) - 1 ) ) | |
( argsPassed < func . argCount ( ) & & argsPassed > = func . minArgCount ( ) ) )
2017-04-01 10:18:53 +02:00
return true ;
}
}
} else if ( tok - > function ( ) - > nestedIn = = scope )
2015-01-08 05:45:31 +01:00
return ! tok - > function ( ) - > isStatic ( ) ;
2012-05-16 20:57:12 +02:00
// not found in this class
2013-03-05 15:28:40 +01:00
if ( ! scope - > definedType - > derivedFrom . empty ( ) ) {
2012-05-16 20:57:12 +02:00
// check each base class
2019-09-19 20:29:33 +02:00
for ( const Type : : BaseInfo & i : scope - > definedType - > derivedFrom ) {
2012-05-16 20:57:12 +02:00
// find the base class
2019-09-19 20:29:33 +02:00
const Type * derivedFrom = i . type ;
2012-05-16 20:57:12 +02:00
// find the function in the base class
2021-01-18 19:01:04 +01:00
if ( derivedFrom & & derivedFrom - > classScope & & derivedFrom - > classScope ! = scope ) {
2013-03-05 15:28:40 +01:00
if ( isMemberFunc ( derivedFrom - > classScope , tok ) )
2012-05-16 20:57:12 +02:00
return true ;
}
}
}
return false ;
}
2014-03-15 18:22:29 +01:00
bool CheckClass : : isConstMemberFunc ( const Scope * scope , const Token * tok ) const
2011-01-16 11:18:12 +01:00
{
2017-04-01 10:18:53 +02:00
if ( ! tok - > function ( ) )
return false ;
else if ( tok - > function ( ) - > nestedIn = = scope )
2015-01-08 05:45:31 +01:00
return tok - > function ( ) - > isConst ( ) ;
2011-08-23 02:34:00 +02:00
2011-01-16 11:18:12 +01:00
// not found in this class
2013-03-05 15:28:40 +01:00
if ( ! scope - > definedType - > derivedFrom . empty ( ) ) {
2011-01-16 11:18:12 +01:00
// check each base class
2019-09-19 20:29:33 +02:00
for ( const Type : : BaseInfo & i : scope - > definedType - > derivedFrom ) {
2011-01-16 11:18:12 +01:00
// find the base class
2019-09-19 20:29:33 +02:00
const Type * derivedFrom = i . type ;
2011-01-16 11:18:12 +01:00
// find the function in the base class
2015-07-01 07:50:13 +02:00
if ( derivedFrom & & derivedFrom - > classScope ) {
2013-03-05 15:28:40 +01:00
if ( isConstMemberFunc ( derivedFrom - > classScope , tok ) )
2011-01-16 11:18:12 +01:00
return true ;
}
}
}
return false ;
}
2022-02-11 19:40:11 +01:00
const std : : set < std : : string > CheckClass : : stl_containers_not_const = { " map " , " unordered_map " } ;
2015-06-13 16:22:43 +02:00
2014-05-10 11:49:14 +02:00
bool CheckClass : : checkConstFunc ( const Scope * scope , const Function * func , bool & memberAccessed ) const
2011-01-16 11:18:12 +01:00
{
2020-12-04 20:29:10 +01:00
if ( mTokenizer - > hasIfdef ( func - > functionScope - > bodyStart , func - > functionScope - > bodyEnd ) )
return false ;
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..
2018-04-27 22:36:30 +02:00
for ( const Token * tok1 = func - > functionScope - > bodyStart ; tok1 & & tok1 ! = func - > functionScope - > bodyEnd ; tok1 = tok1 - > next ( ) ) {
2012-08-01 19:24:38 +02:00
if ( tok1 - > isName ( ) & & isMemberVar ( scope , tok1 ) ) {
memberAccessed = true ;
2013-02-02 16:30:17 +01:00
const Variable * v = tok1 - > variable ( ) ;
2012-08-01 19:24:38 +02:00
if ( v & & v - > isMutable ( ) )
continue ;
2011-01-16 11:18:12 +01:00
2012-08-01 19:24:38 +02:00
if ( tok1 - > str ( ) = = " this " & & tok1 - > previous ( ) - > isAssignmentOp ( ) )
2015-12-05 18:22:01 +01:00
return false ;
2011-09-17 00:07:25 +02:00
2020-06-29 13:09:01 +02:00
// non const pointer cast
if ( tok1 - > valueType ( ) & & tok1 - > valueType ( ) - > pointer > 0 & & tok1 - > astParent ( ) & & tok1 - > astParent ( ) - > isCast ( ) & & ! Token : : simpleMatch ( tok1 - > astParent ( ) , " ( const " ) )
return false ;
2014-11-02 13:38:03 +01:00
2015-08-28 14:19:24 +02:00
const Token * lhs = tok1 - > previous ( ) ;
2022-01-18 20:21:25 +01:00
if ( lhs - > str ( ) = = " ( " & & tok1 - > astParent ( ) & & tok1 - > astParent ( ) - > astParent ( ) )
lhs = tok1 - > astParent ( ) - > astParent ( ) ;
2014-11-02 13:38:03 +01:00
if ( lhs - > str ( ) = = " & " ) {
lhs = lhs - > previous ( ) ;
2018-11-09 06:30:41 +01:00
if ( lhs - > isAssignmentOp ( ) & & lhs - > previous ( ) - > variable ( ) ) {
2014-11-02 13:38:03 +01:00
if ( lhs - > previous ( ) - > variable ( ) - > typeStartToken ( ) - > strAt ( - 1 ) ! = " const " & & lhs - > previous ( ) - > variable ( ) - > isPointer ( ) )
return false ;
}
2020-04-10 14:01:15 +02:00
} else if ( lhs - > str ( ) = = " : " & & lhs - > astParent ( ) & & lhs - > astParent ( ) - > str ( ) = = " ( " ) { // range-based for-loop (C++11)
2015-10-26 18:47:44 +01:00
// TODO: We could additionally check what is done with the elements to avoid false negatives. Here we just rely on "const" keyword being used.
if ( lhs - > astParent ( ) - > strAt ( 1 ) ! = " const " )
return false ;
2014-11-02 13:38:03 +01:00
} else {
2018-11-09 06:30:41 +01:00
if ( lhs - > isAssignmentOp ( ) ) {
2015-12-24 15:08:49 +01:00
const Variable * lhsVar = lhs - > previous ( ) - > variable ( ) ;
if ( lhsVar & & ! lhsVar - > isConst ( ) & & lhsVar - > isReference ( ) & & lhs = = lhsVar - > nameToken ( ) - > next ( ) )
2014-11-02 13:38:03 +01:00
return false ;
2015-12-24 15:08:49 +01:00
}
2014-11-02 13:38:03 +01:00
}
2015-06-13 16:22:43 +02:00
const Token * jumpBackToken = nullptr ;
2013-02-02 16:30:17 +01:00
const Token * lastVarTok = tok1 ;
const Token * end = tok1 ;
2012-08-01 19:24:38 +02:00
for ( ; ; ) {
2015-01-31 10:50:39 +01:00
if ( Token : : Match ( end - > next ( ) , " . %name% " ) ) {
2012-08-01 19:24:38 +02:00
end = end - > tokAt ( 2 ) ;
if ( end - > varId ( ) )
2013-02-02 16:30:17 +01:00
lastVarTok = end ;
2012-08-01 19:24:38 +02:00
} else if ( end - > strAt ( 1 ) = = " [ " ) {
if ( end - > varId ( ) ) {
2013-02-02 16:30:17 +01:00
const Variable * var = end - > variable ( ) ;
2015-06-13 16:22:43 +02:00
if ( var & & var - > isStlType ( stl_containers_not_const ) )
2014-01-30 05:26:48 +01:00
return false ;
2022-01-21 20:40:10 +01:00
const Token * assignTok = end - > next ( ) - > astParent ( ) ;
2022-01-24 21:50:01 +01:00
if ( var & & assignTok & & assignTok - > isAssignmentOp ( ) & & assignTok - > astOperand1 ( ) & & assignTok - > astOperand1 ( ) - > variable ( ) ) {
2022-01-21 20:40:10 +01:00
const Variable * assignVar = assignTok - > astOperand1 ( ) - > variable ( ) ;
if ( assignVar - > isPointer ( ) & & ! assignVar - > isConst ( ) & & var - > typeScope ( ) ) {
const auto & funcMap = var - > typeScope ( ) - > functionMap ;
// if there is no operator that is const and returns a non-const pointer, func cannot be const
if ( std : : none_of ( funcMap . begin ( ) , funcMap . end ( ) , [ ] ( const std : : pair < std : : string , const Function * > & fm ) {
return fm . second - > isConst ( ) & & fm . first = = " operator[] " & & ! Function : : returnsConst ( fm . second ) ;
} ) )
return false ;
}
}
2012-08-01 19:24:38 +02:00
}
2013-02-16 11:20:18 +01:00
if ( ! jumpBackToken )
jumpBackToken = end - > next ( ) ; // Check inside the [] brackets
2012-08-01 19:24:38 +02:00
end = end - > linkAt ( 1 ) ;
} else if ( end - > strAt ( 1 ) = = " ) " )
end = end - > next ( ) ;
else
break ;
2011-03-20 18:29:52 +01:00
}
2011-03-26 03:37:32 +01:00
2012-08-01 19:24:38 +02:00
if ( end - > strAt ( 1 ) = = " ( " ) {
2013-02-02 16:30:17 +01:00
const Variable * var = lastVarTok - > variable ( ) ;
2012-08-01 19:24:38 +02:00
if ( ! var )
2014-01-30 05:26:48 +01:00
return false ;
2022-02-11 21:23:23 +01:00
if ( ( var - > isStlType ( ) // assume all std::*::size() and std::*::empty() are const
& & ( Token : : Match ( end , " size|empty|cend|crend|cbegin|crbegin|max_size|length|count|capacity|get_allocator|c_str|str ( ) " ) | | Token : : Match ( end , " rfind|copy " ) ) ) | |
( lastVarTok - > valueType ( ) & & lastVarTok - > valueType ( ) - > container & &
( ( lastVarTok - > valueType ( ) - > container - > getYield ( end - > str ( ) ) = = Library : : Container : : Yield : : START_ITERATOR ) | |
( lastVarTok - > valueType ( ) - > container - > getYield ( end - > str ( ) ) = = Library : : Container : : Yield : : END_ITERATOR ) )
& & ( tok1 - > previous ( ) - > isComparisonOp ( ) | |
( tok1 - > previous ( ) - > isAssignmentOp ( ) & & tok1 - > tokAt ( - 2 ) - > variable ( ) & & Token : : Match ( tok1 - > tokAt ( - 2 ) - > variable ( ) - > typeEndToken ( ) , " const_iterator|const_reverse_iterator " ) ) ) ) )
2012-08-01 19:24:38 +02:00
;
2013-03-05 13:33:38 +01:00
else if ( ! var - > typeScope ( ) | | ! isConstMemberFunc ( var - > typeScope ( ) , end ) )
2015-12-05 18:22:01 +01:00
return false ;
2011-03-20 18:29:52 +01:00
}
2011-01-16 11:18:12 +01:00
2012-08-01 19:24:38 +02:00
// Assignment
2018-11-09 06:30:41 +01:00
else if ( end - > next ( ) - > isAssignmentOp ( ) )
2015-12-05 18:22:01 +01:00
return false ;
2011-06-04 04:00:27 +02:00
2012-08-01 19:24:38 +02:00
// Streaming
else if ( end - > strAt ( 1 ) = = " << " & & tok1 - > strAt ( - 1 ) ! = " << " )
2015-12-05 18:22:01 +01:00
return false ;
2018-04-22 07:45:36 +02:00
else if ( isLikelyStreamRead ( true , tok1 - > previous ( ) ) )
2015-12-05 18:22:01 +01:00
return false ;
2012-08-01 19:24:38 +02:00
// ++/--
2015-08-14 20:46:13 +02:00
else if ( end - > next ( ) - > tokType ( ) = = Token : : eIncDecOp | | tok1 - > previous ( ) - > tokType ( ) = = Token : : eIncDecOp )
2015-12-05 18:22:01 +01:00
return false ;
2012-08-01 19:24:38 +02:00
const Token * start = tok1 ;
while ( tok1 - > strAt ( - 1 ) = = " ) " )
tok1 = tok1 - > linkAt ( - 1 ) ;
if ( start - > strAt ( - 1 ) = = " delete " )
2015-12-05 18:22:01 +01:00
return false ;
2012-08-01 19:24:38 +02:00
2013-02-16 11:20:18 +01:00
tok1 = jumpBackToken ? jumpBackToken : end ; // Jump back to first [ to check inside, or jump to end of expression
2022-01-17 20:33:32 +01:00
if ( tok1 = = end & & Token : : Match ( end - > previous ( ) , " . %name% ( !!) " ) )
tok1 = tok1 - > previous ( ) ; // check function call
2012-08-01 19:24:38 +02:00
}
// streaming: <<
else if ( Token : : simpleMatch ( tok1 - > previous ( ) , " ) << " ) & &
isMemberVar ( scope , tok1 - > tokAt ( - 2 ) ) ) {
2013-02-02 16:30:17 +01:00
const Variable * var = tok1 - > tokAt ( - 2 ) - > variable ( ) ;
2012-08-01 19:24:38 +02:00
if ( ! var | | ! var - > isMutable ( ) )
2015-12-05 18:22:01 +01:00
return false ;
2011-06-04 04:00:27 +02:00
}
2018-10-03 13:00:11 +02:00
// streaming: >> *this
else if ( Token : : simpleMatch ( tok1 , " >> * this " ) & & isLikelyStreamRead ( true , tok1 ) ) {
return false ;
}
2012-08-01 19:24:38 +02:00
2022-01-18 20:49:35 +01:00
// function/constructor call, return init list
else if ( ( Token : : Match ( tok1 , " %name% (|{ " ) | | Token : : simpleMatch ( tok1 - > astParent ( ) , " return { " )) && !tok1->isStandardType() &&
2012-04-18 18:51:38 +02:00
! Token : : Match ( tok1 , " return|if|string|switch|while|catch|for " ) ) {
2012-08-01 19:24:38 +02:00
if ( isMemberFunc ( scope , tok1 ) & & tok1 - > strAt ( - 1 ) ! = " . " ) {
if ( ! isConstMemberFunc ( scope , tok1 ) )
2015-12-05 18:22:01 +01:00
return false ;
2012-08-01 19:24:38 +02:00
memberAccessed = true ;
2011-12-15 20:18:52 +01:00
}
// Member variable given as parameter
2016-09-04 16:36:04 +02:00
const Token * lpar = tok1 - > next ( ) ;
if ( Token : : simpleMatch ( lpar , " ( ) ( " ) )
lpar = lpar - > tokAt ( 2 ) ;
for ( const Token * tok2 = lpar - > next ( ) ; tok2 & & tok2 ! = tok1 - > next ( ) - > link ( ) ; tok2 = tok2 - > next ( ) ) {
2011-12-15 20:18:52 +01:00
if ( tok2 - > str ( ) = = " ( " )
tok2 = tok2 - > link ( ) ;
2022-01-18 20:49:35 +01:00
else if ( ( tok2 - > isName ( ) & & isMemberVar ( scope , tok2 ) ) | | ( tok2 - > isUnaryOp ( " & " ) & & ( tok2 = tok2 - > astOperand1 ( ) ) ) ) {
2013-02-02 16:30:17 +01:00
const Variable * var = tok2 - > variable ( ) ;
2012-08-01 19:24:38 +02:00
if ( ! var | | ! var - > isMutable ( ) )
2015-12-05 18:22:01 +01:00
return false ; // TODO: Only bailout if function takes argument as non-const reference
2012-08-01 19:24:38 +02:00
}
2011-01-16 11:18:12 +01:00
}
2012-07-11 17:45:16 +02:00
} else if ( Token : : simpleMatch ( tok1 , " > ( " ) & & ( ! tok1 - > link ( ) | | ! Token : : Match ( tok1 - > link ( ) - > previous ( ) , " static_cast|const_cast|dynamic_cast|reinterpret_cast " ) ) ) {
2015-12-05 18:22:01 +01:00
return false ;
2011-01-16 11:18:12 +01:00
}
}
2015-12-05 18:22:01 +01:00
return true ;
2011-01-16 11:18:12 +01:00
}
2012-08-01 19:24:38 +02:00
void CheckClass : : checkConstError ( const Token * tok , const std : : string & classname , const std : : string & funcname , bool suggestStatic )
2010-01-23 09:19:22 +01:00
{
2017-08-09 20:00:26 +02:00
checkConstError2 ( tok , nullptr , classname , funcname , suggestStatic ) ;
2010-01-23 09:19:22 +01:00
}
2012-08-01 19:24:38 +02:00
void CheckClass : : checkConstError2 ( const Token * tok1 , const Token * tok2 , const std : : string & classname , const std : : string & funcname , bool suggestStatic )
2010-03-10 07:47:01 +01:00
{
std : : list < const Token * > toks ;
toks . push_back ( tok1 ) ;
2012-07-09 11:11:05 +02:00
if ( tok2 )
toks . push_back ( tok2 ) ;
2012-08-01 19:24:38 +02:00
if ( ! suggestStatic )
reportError ( toks , Severity : : style , " functionConst " ,
2018-04-09 06:43:48 +02:00
" $symbol: " + classname + " :: " + funcname + " \n "
" Technically the member function '$symbol' can be const. \n "
" The member function '$symbol' can be made a const "
2012-08-01 19:24:38 +02:00
" function. Making this function 'const' 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 the task of the function first - is "
2021-02-24 22:00:06 +01:00
" it a function that must not change object internal state? " , CWE398 , Certainty : : inconclusive ) ;
2012-08-01 19:24:38 +02:00
else
reportError ( toks , Severity : : performance , " functionStatic " ,
2018-04-09 06:43:48 +02:00
" $symbol: " + classname + " :: " + funcname + " \n "
2018-12-03 18:30:46 +01:00
" Technically the member function '$symbol' can be static (but you may consider moving to unnamed namespace). \n "
2018-04-09 06:43:48 +02:00
" The member function '$symbol' can be made a static "
2012-08-01 19:24:38 +02:00
" function. Making a function static can bring a performance benefit since no 'this' instance is "
" passed to the function. This change should not cause compiler errors but it does not "
" necessarily make sense conceptually. Think about your design and the task of the function first - "
2018-12-03 18:30:46 +01:00
" is it a function that must not access members of class instances? And maybe it is more appropriate "
2021-02-24 22:00:06 +01:00
" to move this function to a unnamed namespace. " , CWE398 , Certainty : : inconclusive ) ;
2010-03-10 07:47:01 +01:00
}
2011-09-28 03:07:37 +02:00
//---------------------------------------------------------------------------
// ClassCheck: Check that initializer list is in declared order.
//---------------------------------------------------------------------------
2015-09-08 15:11:17 +02:00
namespace { // avoid one-definition-rule violation
struct VarInfo {
VarInfo ( const Variable * _var , const Token * _tok )
2021-08-07 20:51:18 +02:00
: var ( _var ) , tok ( _tok ) { }
2015-09-08 15:11:17 +02:00
const Variable * var ;
const Token * tok ;
} ;
}
2011-09-28 03:07:37 +02:00
2012-05-18 16:54:58 +02:00
void CheckClass : : initializerListOrder ( )
2011-09-28 03:07:37 +02:00
{
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > severity . isEnabled ( Severity : : style ) )
2011-09-28 03:07:37 +02:00
return ;
// This check is not inconclusive. However it only determines if the initialization
// order is incorrect. It does not determine if being out of order causes
// a real error. Out of order is not necessarily an error but you can never
// have an error if the list is in order so this enforces defensive programming.
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > certainty . isEnabled ( Certainty : : inconclusive ) )
2011-09-28 03:07:37 +02:00
return ;
2018-06-17 18:43:54 +02:00
for ( const Scope * scope : mSymbolDatabase - > classAndStructScopes ) {
2011-09-28 03:07:37 +02:00
// iterate through all member functions looking for constructors
2018-04-05 15:48:23 +02:00
for ( std : : list < Function > : : const_iterator func = scope - > functionList . begin ( ) ; func ! = scope - > functionList . end ( ) ; + + func ) {
2017-09-04 21:49:05 +02:00
if ( func - > isConstructor ( ) & & func - > hasBody ( ) ) {
2011-09-28 03:07:37 +02:00
// check for initializer list
const Token * tok = func - > arg - > link ( ) - > next ( ) ;
2011-10-13 20:53:06 +02:00
if ( tok - > str ( ) = = " : " ) {
2011-09-28 03:07:37 +02:00
std : : vector < VarInfo > vars ;
tok = tok - > next ( ) ;
// find all variable initializations in list
2018-04-27 22:36:30 +02:00
while ( tok & & tok ! = func - > functionScope - > bodyStart ) {
2015-01-31 10:50:39 +01:00
if ( Token : : Match ( tok , " %name% (|{ " ) ) {
2015-03-23 09:58:56 +01:00
const Variable * var = scope - > getVariable ( tok - > str ( ) ) ;
2011-09-28 03:07:37 +02:00
if ( var )
2018-04-11 09:44:35 +02:00
vars . emplace_back ( var , tok ) ;
2011-09-28 03:07:37 +02:00
2015-01-31 10:50:39 +01:00
if ( Token : : Match ( tok - > tokAt ( 2 ) , " %name% = " ) ) {
2015-03-23 09:58:56 +01:00
var = scope - > getVariable ( tok - > strAt ( 2 ) ) ;
2011-09-28 03:07:37 +02:00
if ( var )
2018-04-11 09:44:35 +02:00
vars . emplace_back ( var , tok - > tokAt ( 2 ) ) ;
2011-09-28 03:07:37 +02:00
}
2012-03-24 10:50:19 +01:00
tok = tok - > next ( ) - > link ( ) - > next ( ) ;
} else
tok = tok - > next ( ) ;
2011-09-28 03:07:37 +02:00
}
// need at least 2 members to have out of order initialization
2019-07-16 09:03:45 +02:00
for ( int j = 1 ; j < vars . size ( ) ; j + + ) {
2012-03-24 10:50:19 +01:00
// check for out of order initialization
2012-10-10 20:42:07 +02:00
if ( vars [ j ] . var - > index ( ) < vars [ j - 1 ] . var - > index ( ) )
2015-03-23 09:58:56 +01:00
initializerListError ( vars [ j ] . tok , vars [ j ] . var - > nameToken ( ) , scope - > className , vars [ j ] . var - > name ( ) ) ;
2011-09-28 03:07:37 +02:00
}
}
}
}
}
}
void CheckClass : : initializerListError ( const Token * tok1 , const Token * tok2 , const std : : string & classname , const std : : string & varname )
{
2018-04-09 09:54:39 +02:00
std : : list < const Token * > toks = { tok1 , tok2 } ;
2012-05-06 19:37:41 +02:00
reportError ( toks , Severity : : style , " initializerList " ,
2018-04-09 06:43:48 +02:00
" $symbol: " + classname + " :: " + varname + " \n "
" Member variable '$symbol' is in the wrong place in the initializer list. \n "
" Member variable '$symbol' is in the wrong place in the initializer list. "
2012-07-09 11:11:05 +02:00
" Members are initialized in the order they are declared, not in the "
2012-05-06 19:37:41 +02:00
" order they are in the initializer list. Keeping the initializer list "
" in the same order that the members were declared prevents order dependent "
2021-02-24 22:00:06 +01:00
" initialization errors. " , CWE398 , Certainty : : inconclusive ) ;
2011-09-28 03:07:37 +02:00
}
2013-03-30 15:09:22 +01:00
2014-08-05 11:48:53 +02:00
//---------------------------------------------------------------------------
// Check for self initialization in initialization list
//---------------------------------------------------------------------------
void CheckClass : : checkSelfInitialization ( )
{
2018-06-17 18:43:54 +02:00
for ( const Scope * scope : mSymbolDatabase - > functionScopes ) {
2014-08-05 11:48:53 +02:00
const Function * function = scope - > function ;
if ( ! function | | ! function - > isConstructor ( ) )
continue ;
const Token * tok = function - > arg - > link ( ) - > next ( ) ;
if ( tok - > str ( ) ! = " : " )
continue ;
2018-04-27 22:36:30 +02:00
for ( ; tok ! = scope - > bodyStart ; tok = tok - > next ( ) ) {
2015-01-31 10:50:39 +01:00
if ( Token : : Match ( tok , " [:,] %var% (|{ %var% )|} " ) & & tok - > next ( ) - > varId ( ) = = tok - > tokAt ( 3 ) - > varId ( ) ) {
2014-08-05 11:48:53 +02:00
selfInitializationError ( tok , tok - > strAt ( 1 ) ) ;
}
}
}
}
2014-08-06 13:35:39 +02:00
void CheckClass : : selfInitializationError ( const Token * tok , const std : : string & varname )
2014-08-05 11:48:53 +02:00
{
2021-02-24 22:00:06 +01:00
reportError ( tok , Severity : : error , " selfInitialization " , " $symbol: " + varname + " \n Member variable '$symbol' is initialized by itself. " , CWE665 , Certainty : : normal ) ;
2014-08-05 11:48:53 +02:00
}
//---------------------------------------------------------------------------
2018-04-02 15:31:47 +02:00
// Check for virtual function calls in constructor/destructor
2014-08-05 11:48:53 +02:00
//---------------------------------------------------------------------------
2018-04-02 15:31:47 +02:00
void CheckClass : : checkVirtualFunctionCallInConstructor ( )
2013-03-30 15:09:22 +01:00
{
2021-08-07 20:51:18 +02:00
if ( ! mSettings - > severity . isEnabled ( Severity : : warning ) )
2015-04-06 13:34:44 +02:00
return ;
2021-08-07 20:51:18 +02:00
std : : map < const Function * , std : : list < const Token * > > virtualFunctionCallsMap ;
2018-06-17 18:43:54 +02:00
for ( const Scope * scope : mSymbolDatabase - > functionScopes ) {
2015-06-13 16:22:43 +02:00
if ( scope - > function = = nullptr | | ! scope - > function - > hasBody ( ) | |
2013-04-10 21:57:22 +02:00
! ( scope - > function - > isConstructor ( ) | |
scope - > function - > isDestructor ( ) ) )
2013-03-30 15:09:22 +01:00
continue ;
2018-04-02 15:31:47 +02:00
const std : : list < const Token * > & virtualFunctionCalls = getVirtualFunctionCalls ( * scope - > function , virtualFunctionCallsMap ) ;
2018-07-13 23:51:22 +02:00
for ( const Token * callToken : virtualFunctionCalls ) {
2018-04-09 09:54:39 +02:00
std : : list < const Token * > callstack ( 1 , callToken ) ;
2018-04-02 15:31:47 +02:00
getFirstVirtualFunctionCallStack ( virtualFunctionCallsMap , callToken , callstack ) ;
if ( callstack . empty ( ) )
continue ;
2021-07-11 11:03:09 +02:00
if ( ! ( callstack . back ( ) - > function ( ) - > hasVirtualSpecifier ( ) | | callstack . back ( ) - > function ( ) - > hasOverrideSpecifier ( ) ) )
continue ;
2018-04-02 15:31:47 +02:00
if ( callstack . back ( ) - > function ( ) - > isPure ( ) )
pureVirtualFunctionCallInConstructorError ( scope - > function , callstack , callstack . back ( ) - > str ( ) ) ;
2021-11-11 07:53:30 +01:00
else if ( ! callstack . back ( ) - > function ( ) - > hasFinalSpecifier ( ) )
2018-04-02 15:31:47 +02:00
virtualFunctionCallInConstructorError ( scope - > function , callstack , callstack . back ( ) - > str ( ) ) ;
2013-03-30 15:09:22 +01:00
}
}
}
2018-04-02 15:31:47 +02:00
const std : : list < const Token * > & CheckClass : : getVirtualFunctionCalls ( const Function & function ,
2021-08-07 20:51:18 +02:00
std : : map < const Function * , std : : list < const Token * > > & virtualFunctionCallsMap )
2018-04-02 15:31:47 +02:00
{
2021-08-07 20:51:18 +02:00
const std : : map < const Function * , std : : list < const Token * > > : : const_iterator found = virtualFunctionCallsMap . find ( & function ) ;
2018-04-02 15:31:47 +02:00
if ( found ! = virtualFunctionCallsMap . end ( ) )
return found - > second ;
2013-03-30 15:09:22 +01:00
2018-04-02 15:31:47 +02:00
virtualFunctionCallsMap [ & function ] = std : : list < const Token * > ( ) ;
std : : list < const Token * > & virtualFunctionCalls = virtualFunctionCallsMap . find ( & function ) - > second ;
2013-10-20 14:09:10 +02:00
2022-04-05 23:18:08 +02:00
if ( ! function . hasBody ( ) | | ! function . functionScope )
2018-04-02 15:31:47 +02:00
return virtualFunctionCalls ;
2013-03-30 15:09:22 +01:00
2018-04-27 22:36:30 +02:00
for ( const Token * tok = function . arg - > link ( ) ; tok ! = function . functionScope - > bodyEnd ; tok = tok - > next ( ) ) {
2018-04-02 15:31:47 +02:00
if ( function . type ! = Function : : eConstructor & &
function . type ! = Function : : eCopyConstructor & &
function . type ! = Function : : eMoveConstructor & &
function . type ! = Function : : eDestructor ) {
if ( ( Token : : simpleMatch ( tok , " ) { " ) & & tok - > link ( ) & & Token : : Match ( tok - > link ( ) - > previous ( ) , " if|switch " ) ) | |
Token : : simpleMatch ( tok , " else { " ) ) {
// Assume pure virtual function call is prevented by "if|else|switch" condition
tok = tok - > linkAt ( 1 ) ;
continue ;
2013-03-30 15:09:22 +01:00
}
}
2018-04-02 15:31:47 +02:00
if ( tok - > scope ( ) - > type = = Scope : : eLambda )
2018-04-27 22:36:30 +02:00
tok = tok - > scope ( ) - > bodyEnd - > next ( ) ;
2018-04-02 15:31:47 +02:00
const Function * callFunction = tok - > function ( ) ;
if ( ! callFunction | |
function . nestedIn ! = callFunction - > nestedIn | |
2022-03-19 20:00:06 +01:00
Token : : simpleMatch ( tok - > previous ( ) , " . " ) | |
! ( tok - > astParent ( ) & & ( tok - > astParent ( ) - > str ( ) = = " ( " | | ( tok - > astParent ( ) - > str ( ) = = " :: " & & Token : : simpleMatch ( tok - > astParent ( ) - > astParent ( ) , " ( " ) ) ) ) )
2018-04-02 15:31:47 +02:00
continue ;
if ( tok - > previous ( ) & &
tok - > previous ( ) - > str ( ) = = " ( " ) {
const Token * prev = tok - > previous ( ) ;
if ( prev - > previous ( ) & &
2018-06-16 16:10:28 +02:00
( mSettings - > library . ignorefunction ( tok - > str ( ) )
| | mSettings - > library . ignorefunction ( prev - > previous ( ) - > str ( ) ) ) )
2018-04-02 15:31:47 +02:00
continue ;
}
2019-07-04 12:32:32 +02:00
if ( callFunction - > isImplicitlyVirtual ( ) ) {
2018-04-03 14:02:59 +02:00
if ( ! callFunction - > isPure ( ) & & Token : : simpleMatch ( tok - > previous ( ) , " :: " ) )
continue ;
2018-04-02 15:31:47 +02:00
virtualFunctionCalls . push_back ( tok ) ;
continue ;
}
const std : : list < const Token * > & virtualFunctionCallsOfTok = getVirtualFunctionCalls ( * callFunction , virtualFunctionCallsMap ) ;
if ( ! virtualFunctionCallsOfTok . empty ( ) )
virtualFunctionCalls . push_back ( tok ) ;
2013-03-30 15:09:22 +01:00
}
2018-04-02 15:31:47 +02:00
return virtualFunctionCalls ;
2013-03-30 15:09:22 +01:00
}
2018-04-02 15:31:47 +02:00
void CheckClass : : getFirstVirtualFunctionCallStack (
2021-08-07 20:51:18 +02:00
std : : map < const Function * , std : : list < const Token * > > & virtualFunctionCallsMap ,
2018-04-02 15:31:47 +02:00
const Token * callToken ,
2018-06-10 22:04:22 +02:00
std : : list < const Token * > & pureFuncStack )
2013-03-30 15:09:22 +01:00
{
2018-04-02 15:31:47 +02:00
const Function * callFunction = callToken - > function ( ) ;
2019-07-04 12:32:32 +02:00
if ( callFunction - > isImplicitlyVirtual ( ) & & ( ! callFunction - > isPure ( ) | | ! callFunction - > hasBody ( ) ) ) {
2018-06-10 22:04:22 +02:00
pureFuncStack . push_back ( callFunction - > tokenDef ) ;
2013-03-30 15:09:22 +01:00
return ;
}
2021-08-07 20:51:18 +02:00
std : : map < const Function * , std : : list < const Token * > > : : const_iterator found = virtualFunctionCallsMap . find ( callFunction ) ;
2018-04-02 15:31:47 +02:00
if ( found = = virtualFunctionCallsMap . end ( ) | | found - > second . empty ( ) ) {
2018-06-10 22:04:22 +02:00
pureFuncStack . clear ( ) ;
2013-03-30 15:09:22 +01:00
return ;
}
2018-04-02 15:31:47 +02:00
const Token * firstCall = * found - > second . begin ( ) ;
2018-06-10 22:04:22 +02:00
pureFuncStack . push_back ( firstCall ) ;
getFirstVirtualFunctionCallStack ( virtualFunctionCallsMap , firstCall , pureFuncStack ) ;
2013-03-30 15:09:22 +01:00
}
2018-04-02 15:31:47 +02:00
void CheckClass : : virtualFunctionCallInConstructorError (
const Function * scopeFunction ,
const std : : list < const Token * > & tokStack ,
const std : : string & funcname )
{
const char * scopeFunctionTypeName = scopeFunction ? getFunctionTypeName ( scopeFunction - > type ) : " constructor " ;
ErrorPath errorPath ;
2018-04-04 12:52:58 +02:00
int lineNumber = 1 ;
2018-07-13 23:51:22 +02:00
for ( const Token * tok : tokStack )
errorPath . emplace_back ( tok , " Calling " + tok - > str ( ) ) ;
2018-04-04 12:52:58 +02:00
if ( ! errorPath . empty ( ) ) {
lineNumber = errorPath . front ( ) . first - > linenr ( ) ;
2019-01-14 19:54:34 +01:00
errorPath . back ( ) . second = funcname + " is a virtual function " ;
2018-04-04 12:52:58 +02:00
}
std : : string constructorName ;
if ( scopeFunction ) {
const Token * endToken = scopeFunction - > argDef - > link ( ) - > next ( ) ;
if ( scopeFunction - > type = = Function : : Type : : eDestructor )
constructorName = " ~ " ;
for ( const Token * tok = scopeFunction - > tokenDef ; tok ! = endToken ; tok = tok - > next ( ) ) {
if ( ! constructorName . empty ( ) & & Token : : Match ( tok - > previous ( ) , " %name%|%num% %name%|%num% " ) )
constructorName + = ' ' ;
constructorName + = tok - > str ( ) ;
if ( tok - > str ( ) = = " ) " )
break ;
}
}
2018-04-02 15:31:47 +02:00
2020-02-14 17:10:12 +01:00
reportError ( errorPath , Severity : : style , " virtualCallInConstructor " ,
2021-02-24 22:00:06 +01:00
" Virtual function ' " + funcname + " ' is called from " + scopeFunctionTypeName + " ' " + constructorName + " ' at line " + MathLib : : toString ( lineNumber ) + " . Dynamic binding is not used. " , CWE ( 0U ) , Certainty : : normal ) ;
2018-04-02 15:31:47 +02:00
}
void CheckClass : : pureVirtualFunctionCallInConstructorError (
const Function * scopeFunction ,
2013-03-30 15:09:22 +01:00
const std : : list < const Token * > & tokStack ,
const std : : string & purefuncname )
{
2018-04-02 15:31:47 +02:00
const char * scopeFunctionTypeName = scopeFunction ? getFunctionTypeName ( scopeFunction - > type ) : " constructor " ;
ErrorPath errorPath ;
2018-07-13 23:51:22 +02:00
for ( const Token * tok : tokStack )
errorPath . emplace_back ( tok , " Calling " + tok - > str ( ) ) ;
2018-04-02 15:31:47 +02:00
if ( ! errorPath . empty ( ) )
2019-01-14 19:54:34 +01:00
errorPath . back ( ) . second = purefuncname + " is a pure virtual function without body " ;
2018-04-02 15:31:47 +02:00
2019-01-13 08:42:48 +01:00
reportError ( errorPath , Severity : : warning , " pureVirtualCall " ,
2018-04-09 06:43:48 +02:00
" $symbol: " + purefuncname + " \n "
" Call of pure virtual function '$symbol' in " + scopeFunctionTypeName + " . \n "
2021-02-24 22:00:06 +01:00
" Call of pure virtual function '$symbol' in " + scopeFunctionTypeName + " . The call will fail during runtime. " , CWE ( 0U ) , Certainty : : normal ) ;
2013-03-30 15:09:22 +01:00
}
2014-08-05 11:48:53 +02:00
//---------------------------------------------------------------------------
// Check for members hiding inherited members with the same name
//---------------------------------------------------------------------------
void CheckClass : : checkDuplInheritedMembers ( )
{
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > severity . isEnabled ( Severity : : warning ) )
2014-08-05 11:48:53 +02:00
return ;
// Iterate over all classes
2018-07-14 07:49:04 +02:00
for ( const Type & classIt : mSymbolDatabase - > typeList ) {
2014-08-05 11:48:53 +02:00
// Iterate over the parent classes
2020-12-21 07:14:52 +01:00
checkDuplInheritedMembersRecursive ( & classIt , & classIt ) ;
}
}
void CheckClass : : checkDuplInheritedMembersRecursive ( const Type * typeCurrent , const Type * typeBase )
{
for ( const Type : : BaseInfo & parentClassIt : typeBase - > derivedFrom ) {
// Check if there is info about the 'Base' class
if ( ! parentClassIt . type | | ! parentClassIt . type - > classScope )
continue ;
2021-02-05 11:05:07 +01:00
// Don't crash on recursive templates
if ( parentClassIt . type = = typeBase )
continue ;
2020-12-21 07:14:52 +01:00
// Check if they have a member variable in common
for ( const Variable & classVarIt : typeCurrent - > classScope - > varlist ) {
for ( const Variable & parentClassVarIt : parentClassIt . type - > classScope - > varlist ) {
if ( classVarIt . name ( ) = = parentClassVarIt . name ( ) & & ! parentClassVarIt . isPrivate ( ) ) { // Check if the class and its parent have a common variable
duplInheritedMembersError ( classVarIt . nameToken ( ) , parentClassVarIt . nameToken ( ) ,
2020-12-22 08:09:26 +01:00
typeCurrent - > name ( ) , parentClassIt . type - > name ( ) , classVarIt . name ( ) ,
typeCurrent - > classScope - > type = = Scope : : eStruct ,
parentClassIt . type - > classScope - > type = = Scope : : eStruct ) ;
2014-08-05 11:48:53 +02:00
}
}
}
2021-01-18 19:01:04 +01:00
if ( typeCurrent ! = parentClassIt . type )
checkDuplInheritedMembersRecursive ( typeCurrent , parentClassIt . type ) ;
2014-08-05 11:48:53 +02:00
}
}
void CheckClass : : duplInheritedMembersError ( const Token * tok1 , const Token * tok2 ,
2021-08-07 20:51:18 +02:00
const std : : string & derivedName , const std : : string & baseName ,
const std : : string & variableName , bool derivedIsStruct , bool baseIsStruct )
2014-08-05 11:48:53 +02:00
{
2018-08-19 14:13:58 +02:00
ErrorPath errorPath ;
errorPath . emplace_back ( tok2 , " Parent variable ' " + baseName + " :: " + variableName + " ' " ) ;
errorPath . emplace_back ( tok1 , " Derived variable ' " + derivedName + " :: " + variableName + " ' " ) ;
2014-08-05 11:48:53 +02:00
2018-08-19 14:13:58 +02:00
const std : : string symbols = " $symbol: " + derivedName + " \n $symbol: " + variableName + " \n $symbol: " + baseName ;
2018-04-09 06:43:48 +02:00
2018-08-19 14:13:58 +02:00
const std : : string message = " The " + std : : string ( derivedIsStruct ? " struct " : " class " ) + " ' " + derivedName +
" ' defines member variable with name ' " + variableName + " ' also defined in its parent " +
std : : string ( baseIsStruct ? " struct " : " class " ) + " ' " + baseName + " '. " ;
2021-02-24 22:00:06 +01:00
reportError ( errorPath , Severity : : warning , " duplInheritedMember " , symbols + ' \n ' + message , CWE398 , Certainty : : normal ) ;
2014-08-05 11:48:53 +02:00
}
2017-03-24 12:00:20 +01:00
2018-04-24 22:42:25 +02:00
//---------------------------------------------------------------------------
// Check that copy constructor and operator defined together
//---------------------------------------------------------------------------
2019-07-17 10:39:06 +02:00
enum class CtorType {
2018-04-24 22:42:25 +02:00
NO ,
WITHOUT_BODY ,
WITH_BODY
} ;
2017-03-24 12:00:20 +01:00
2018-04-24 22:42:25 +02:00
void CheckClass : : checkCopyCtorAndEqOperator ( )
2017-03-24 12:00:20 +01:00
{
2018-09-08 09:14:02 +02:00
// This is disabled because of #8388
// The message must be clarified. How is the behaviour different?
return ;
2021-01-09 20:32:38 +01:00
// cppcheck-suppress unreachableCode - remove when code is enabled again
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > severity . isEnabled ( Severity : : warning ) )
2017-03-24 12:00:20 +01:00
return ;
2018-06-17 18:43:54 +02:00
for ( const Scope * scope : mSymbolDatabase - > classAndStructScopes ) {
2017-03-24 12:00:20 +01:00
2017-08-14 17:06:23 +02:00
bool hasNonStaticVars = false ;
2018-04-24 22:42:25 +02:00
for ( std : : list < Variable > : : const_iterator var = scope - > varlist . begin ( ) ; var ! = scope - > varlist . end ( ) ; + + var ) {
if ( ! var - > isStatic ( ) ) {
2017-08-14 17:06:23 +02:00
hasNonStaticVars = true ;
break ;
}
2017-08-02 01:52:41 +02:00
}
2017-08-14 17:06:23 +02:00
if ( ! hasNonStaticVars )
2017-03-24 12:00:20 +01:00
continue ;
2018-04-24 22:42:25 +02:00
CtorType copyCtors = CtorType : : NO ;
2017-12-23 10:35:14 +01:00
bool moveCtor = false ;
2018-04-24 22:42:25 +02:00
CtorType assignmentOperators = CtorType : : NO ;
2017-03-24 12:00:20 +01:00
2018-04-30 22:10:54 +02:00
for ( const Function & func : scope - > functionList ) {
if ( copyCtors = = CtorType : : NO & & func . type = = Function : : eCopyConstructor ) {
copyCtors = func . hasBody ( ) ? CtorType : : WITH_BODY : CtorType : : WITHOUT_BODY ;
2017-03-24 12:00:20 +01:00
}
2018-04-30 22:10:54 +02:00
if ( assignmentOperators = = CtorType : : NO & & func . type = = Function : : eOperatorEqual ) {
const Variable * variable = func . getArgumentVar ( 0 ) ;
2017-03-24 12:00:20 +01:00
if ( variable & & variable - > type ( ) & & variable - > type ( ) - > classScope = = scope ) {
2018-04-30 22:10:54 +02:00
assignmentOperators = func . hasBody ( ) ? CtorType : : WITH_BODY : CtorType : : WITHOUT_BODY ;
2017-03-24 12:00:20 +01:00
}
}
2018-04-30 22:10:54 +02:00
if ( func . type = = Function : : eMoveConstructor ) {
2017-12-23 10:35:14 +01:00
moveCtor = true ;
break ;
}
2017-03-24 12:00:20 +01:00
}
2017-12-23 10:35:14 +01:00
if ( moveCtor )
continue ;
2018-04-24 16:07:58 +02:00
// No method defined
2018-04-24 22:42:25 +02:00
if ( copyCtors ! = CtorType : : WITH_BODY & & assignmentOperators ! = CtorType : : WITH_BODY )
2018-04-24 16:07:58 +02:00
continue ;
2018-04-24 22:42:25 +02:00
// both methods are defined
if ( copyCtors ! = CtorType : : NO & & assignmentOperators ! = CtorType : : NO )
2018-04-24 16:07:58 +02:00
continue ;
2018-04-24 22:42:25 +02:00
copyCtorAndEqOperatorError ( scope - > classDef , scope - > className , scope - > type = = Scope : : eStruct , copyCtors = = CtorType : : WITH_BODY ) ;
2017-03-24 12:00:20 +01:00
}
}
2018-04-24 22:42:25 +02:00
void CheckClass : : copyCtorAndEqOperatorError ( const Token * tok , const std : : string & classname , bool isStruct , bool hasCopyCtor )
2017-03-24 12:00:20 +01:00
{
2018-04-24 22:42:25 +02:00
const std : : string message = " $symbol: " + classname + " \n "
" The " + std : : string ( isStruct ? " struct " : " class " ) + " '$symbol' has ' " +
getFunctionTypeName ( hasCopyCtor ? Function : : eCopyConstructor : Function : : eOperatorEqual ) +
" ' but lack of ' " + getFunctionTypeName ( hasCopyCtor ? Function : : eOperatorEqual : Function : : eCopyConstructor ) +
" '. " ;
reportError ( tok , Severity : : warning , " copyCtorAndEqOperator " , message ) ;
2017-03-24 12:00:20 +01:00
}
2017-10-20 02:02:51 +02:00
2018-04-27 11:12:09 +02:00
void CheckClass : : checkOverride ( )
{
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > severity . isEnabled ( Severity : : style ) )
2018-04-27 11:12:09 +02:00
return ;
2018-06-16 16:10:28 +02:00
if ( mSettings - > standards . cpp < Standards : : CPP11 )
2018-04-27 11:12:09 +02:00
return ;
2018-06-17 18:43:54 +02:00
for ( const Scope * classScope : mSymbolDatabase - > classAndStructScopes ) {
2018-04-27 11:12:09 +02:00
if ( ! classScope - > definedType | | classScope - > definedType - > derivedFrom . empty ( ) )
continue ;
for ( const Function & func : classScope - > functionList ) {
2018-04-27 14:57:43 +02:00
if ( func . hasOverrideSpecifier ( ) | | func . hasFinalSpecifier ( ) )
2018-04-27 11:12:09 +02:00
continue ;
2019-01-14 18:36:21 +01:00
const Function * baseFunc = func . getOverriddenFunction ( ) ;
2018-05-15 10:48:34 +02:00
if ( baseFunc )
2018-04-27 11:12:09 +02:00
overrideError ( baseFunc , & func ) ;
}
}
}
void CheckClass : : overrideError ( const Function * funcInBase , const Function * funcInDerived )
{
2019-08-01 10:43:45 +02:00
const std : : string functionName = funcInDerived ? ( ( funcInDerived - > isDestructor ( ) ? " ~ " : " " ) + funcInDerived - > name ( ) ) : " " ;
const std : : string funcType = ( funcInDerived & & funcInDerived - > isDestructor ( ) ) ? " destructor " : " function " ;
2018-04-27 11:12:09 +02:00
ErrorPath errorPath ;
if ( funcInBase & & funcInDerived ) {
2019-08-01 10:43:45 +02:00
errorPath . push_back ( ErrorPathItem ( funcInBase - > tokenDef , " Virtual " + funcType + " in base class " ) ) ;
errorPath . push_back ( ErrorPathItem ( funcInDerived - > tokenDef , char ( std : : toupper ( funcType [ 0 ] ) ) + funcType . substr ( 1 ) + " in derived class " ) ) ;
2018-04-27 11:12:09 +02:00
}
reportError ( errorPath , Severity : : style , " missingOverride " ,
" $symbol: " + functionName + " \n "
2019-08-01 10:43:45 +02:00
" The " + funcType + " '$symbol' overrides a " + funcType + " in a base class but is not marked with a 'override' specifier. " ,
2018-04-27 11:12:09 +02:00
CWE ( 0U ) /* Unknown CWE! */ ,
2021-02-24 22:00:06 +01:00
Certainty : : normal ) ;
2020-01-01 16:09:43 +01:00
}
2020-02-13 10:59:00 +01:00
void CheckClass : : checkThisUseAfterFree ( )
{
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > severity . isEnabled ( Severity : : warning ) )
2020-02-13 10:59:00 +01:00
return ;
for ( const Scope * classScope : mSymbolDatabase - > classAndStructScopes ) {
for ( const Variable & var : classScope - > varlist ) {
// Find possible "self pointer".. pointer/smartpointer member variable of "self" type.
if ( var . valueType ( ) & & var . valueType ( ) - > smartPointerType ! = classScope - > definedType & & var . valueType ( ) - > typeScope ! = classScope ) {
const ValueType valueType = ValueType : : parseDecl ( var . typeStartToken ( ) , mSettings ) ;
if ( valueType . smartPointerType ! = classScope - > definedType )
continue ;
}
// If variable is not static, check that "this" is assigned
if ( ! var . isStatic ( ) ) {
bool hasAssign = false ;
for ( const Function & func : classScope - > functionList ) {
if ( func . type ! = Function : : Type : : eFunction | | ! func . hasBody ( ) )
continue ;
for ( const Token * tok = func . functionScope - > bodyStart ; tok ! = func . functionScope - > bodyEnd ; tok = tok - > next ( ) ) {
if ( Token : : Match ( tok , " %varid% = this|shared_from_this " , var . declarationId ( ) ) ) {
hasAssign = true ;
break ;
}
}
if ( hasAssign )
break ;
}
if ( ! hasAssign )
continue ;
}
// Check usage of self pointer..
for ( const Function & func : classScope - > functionList ) {
if ( func . type ! = Function : : Type : : eFunction | | ! func . hasBody ( ) )
continue ;
const Token * freeToken = nullptr ;
std : : set < const Function * > callstack ;
checkThisUseAfterFreeRecursive ( classScope , & func , & var , callstack , & freeToken ) ;
}
}
}
}
bool CheckClass : : checkThisUseAfterFreeRecursive ( const Scope * classScope , const Function * func , const Variable * selfPointer , std : : set < const Function * > callstack , const Token * * freeToken )
{
if ( ! func | | ! func - > functionScope )
return false ;
// avoid recursion
if ( callstack . count ( func ) )
return false ;
callstack . insert ( func ) ;
const Token * const bodyStart = func - > functionScope - > bodyStart ;
const Token * const bodyEnd = func - > functionScope - > bodyEnd ;
for ( const Token * tok = bodyStart ; tok ! = bodyEnd ; tok = tok - > next ( ) ) {
const bool isDestroyed = * freeToken ! = nullptr & & ! func - > isStatic ( ) ;
if ( Token : : Match ( tok , " delete %var% ; " ) & & selfPointer = = tok - > next ( ) - > variable ( ) ) {
* freeToken = tok ;
tok = tok - > tokAt ( 2 ) ;
} else if ( Token : : Match ( tok , " %var% . reset ( ) " ) & & selfPointer = = tok - > variable ( ) )
* freeToken = tok ;
else if ( Token : : Match ( tok - > previous ( ) , " !!. %name% ( " ) & & tok - > function ( ) & & tok - > function ( ) - > nestedIn = = classScope ) {
if ( isDestroyed ) {
thisUseAfterFree ( selfPointer - > nameToken ( ) , * freeToken , tok ) ;
return true ;
}
if ( checkThisUseAfterFreeRecursive ( classScope , tok - > function ( ) , selfPointer , callstack , freeToken ) )
return true ;
} else if ( isDestroyed & & Token : : Match ( tok - > previous ( ) , " !!. %name% " ) & & tok - > variable ( ) & & tok - > variable ( ) - > scope ( ) = = classScope & & ! tok - > variable ( ) - > isStatic ( ) & & ! tok - > variable ( ) - > isArgument ( ) ) {
thisUseAfterFree ( selfPointer - > nameToken ( ) , * freeToken , tok ) ;
return true ;
2020-04-17 20:20:45 +02:00
} else if ( * freeToken & & Token : : Match ( tok , " return|throw " ) ) {
2020-02-13 10:59:00 +01:00
// TODO
return tok - > str ( ) = = " throw " ;
2020-04-17 20:20:45 +02:00
} else if ( tok - > str ( ) = = " { " && tok->scope()->type == Scope::ScopeType::eLambda) {
tok = tok - > link ( ) ;
}
2020-02-13 10:59:00 +01:00
}
return false ;
}
void CheckClass : : thisUseAfterFree ( const Token * self , const Token * free , const Token * use )
{
std : : string selfPointer = self ? self - > str ( ) : " ptr " ;
const ErrorPath errorPath = { ErrorPathItem ( self , " Assuming ' " + selfPointer + " ' is used as 'this' " ) , ErrorPathItem ( free , " Delete ' " + selfPointer + " ', invalidating 'this' " ) , ErrorPathItem ( use , " Call method when 'this' is invalid " ) } ;
const std : : string usestr = use ? use - > str ( ) : " x " ;
const std : : string usemsg = use & & use - > function ( ) ? ( " Calling method ' " + usestr + " ()' " ) : ( " Using member ' " + usestr + " ' " ) ;
reportError ( errorPath , Severity : : warning , " thisUseAfterFree " ,
" $symbol: " + selfPointer + " \n " +
usemsg + " when 'this' might be invalid " ,
2021-02-24 22:00:06 +01:00
CWE ( 0 ) , Certainty : : normal ) ;
2020-02-13 10:59:00 +01:00
}
2019-08-13 20:58:31 +02:00
void CheckClass : : checkUnsafeClassRefMember ( )
2019-08-13 20:40:48 +02:00
{
2021-02-24 22:00:06 +01:00
if ( ! mSettings - > safeChecks . classes | | ! mSettings - > severity . isEnabled ( Severity : : warning ) )
2019-08-13 20:40:48 +02:00
return ;
for ( const Scope * classScope : mSymbolDatabase - > classAndStructScopes ) {
for ( const Function & func : classScope - > functionList ) {
if ( ! func . hasBody ( ) | | ! func . isConstructor ( ) )
continue ;
const Token * initList = func . constructorMemberInitialization ( ) ;
while ( Token : : Match ( initList , " [:,] %name% ( " ) ) {
if ( Token : : Match ( initList - > tokAt ( 2 ) , " ( %var% ) " ) ) {
const Variable * const memberVar = initList - > next ( ) - > variable ( ) ;
const Variable * const argVar = initList - > tokAt ( 3 ) - > variable ( ) ;
if ( memberVar & & argVar & & memberVar - > isConst ( ) & & memberVar - > isReference ( ) & & argVar - > isArgument ( ) & & argVar - > isConst ( ) & & argVar - > isReference ( ) )
2019-08-13 20:58:31 +02:00
unsafeClassRefMemberError ( initList - > next ( ) , classScope - > className + " :: " + memberVar - > name ( ) ) ;
2019-08-13 20:40:48 +02:00
}
initList = initList - > linkAt ( 2 ) - > next ( ) ;
}
}
}
}
2019-08-13 20:58:31 +02:00
void CheckClass : : unsafeClassRefMemberError ( const Token * tok , const std : : string & varname )
2019-08-13 20:40:48 +02:00
{
2019-08-13 20:58:31 +02:00
reportError ( tok , Severity : : warning , " unsafeClassRefMember " ,
2019-08-13 20:40:48 +02:00
" $symbol: " + varname + " \n "
" Unsafe class: The const reference member '$symbol' is initialized by a const reference constructor argument. You need to be careful about lifetime issues. \n "
2019-08-13 20:58:31 +02:00
" Unsafe class checking: The const reference member '$symbol' is initialized by a const reference constructor argument. You need to be careful about lifetime issues. If you pass a local variable or temporary value in this constructor argument, be extra careful. If the argument is always some global object that is never destroyed then this is safe usage. However it would be defensive to make the member '$symbol' a non-reference variable or a smart pointer. " ,
2021-02-24 22:00:06 +01:00
CWE ( 0 ) , Certainty : : normal ) ;
2019-08-13 20:40:48 +02:00
}
2021-02-09 21:35:08 +01:00
Check : : FileInfo * CheckClass : : getFileInfo ( const Tokenizer * tokenizer , const Settings * settings ) const
{
if ( ! tokenizer - > isCPP ( ) )
return nullptr ;
( void ) settings ;
// One definition rule
std : : vector < MyFileInfo : : NameLoc > classDefinitions ;
for ( const Scope * classScope : tokenizer - > getSymbolDatabase ( ) - > classAndStructScopes ) {
2021-03-20 18:53:17 +01:00
if ( classScope - > isAnonymous ( ) )
continue ;
2021-02-09 21:35:08 +01:00
// the full definition must be compared
2021-02-09 21:47:56 +01:00
bool fullDefinition = std : : all_of ( classScope - > functionList . begin ( ) ,
classScope - > functionList . end ( ) ,
2021-08-07 20:51:18 +02:00
[ ] ( const Function & f ) {
2021-02-10 11:42:00 +01:00
return f . hasBody ( ) ;
} ) ;
2021-02-09 21:35:08 +01:00
if ( ! fullDefinition )
continue ;
std : : string name ;
const Scope * scope = classScope ;
while ( scope - > isClassOrStruct ( ) & & ! classScope - > className . empty ( ) ) {
2021-04-04 21:29:45 +02:00
if ( Token : : Match ( scope - > classDef , " struct|class %name% :: %name% " ) ) {
// TODO handle such classnames
name . clear ( ) ;
break ;
}
2021-02-09 21:35:08 +01:00
name = scope - > className + " :: " + name ;
scope = scope - > nestedIn ;
}
2021-03-19 09:19:48 +01:00
if ( name . empty ( ) )
continue ;
2021-02-09 21:35:08 +01:00
name . erase ( name . size ( ) - 2 ) ;
if ( scope - > type ! = Scope : : ScopeType : : eGlobal )
continue ;
MyFileInfo : : NameLoc nameLoc ;
nameLoc . className = name ;
nameLoc . fileName = tokenizer - > list . file ( classScope - > classDef ) ;
nameLoc . lineNumber = classScope - > classDef - > linenr ( ) ;
nameLoc . column = classScope - > classDef - > column ( ) ;
// Calculate hash from the full class/struct definition
std : : string def ;
for ( const Token * tok = classScope - > classDef ; tok ! = classScope - > bodyEnd ; tok = tok - > next ( ) )
def + = tok - > str ( ) ;
for ( const Function & f : classScope - > functionList ) {
2021-03-19 09:19:48 +01:00
if ( f . functionScope & & f . functionScope - > nestedIn ! = classScope ) {
2021-02-09 21:35:08 +01:00
for ( const Token * tok = f . functionScope - > bodyStart ; tok ! = f . functionScope - > bodyEnd ; tok = tok - > next ( ) )
def + = tok - > str ( ) ;
}
}
nameLoc . hash = std : : hash < std : : string > { } ( def ) ;
classDefinitions . push_back ( nameLoc ) ;
}
if ( classDefinitions . empty ( ) )
return nullptr ;
MyFileInfo * fileInfo = new MyFileInfo ;
fileInfo - > classDefinitions . swap ( classDefinitions ) ;
return fileInfo ;
}
std : : string CheckClass : : MyFileInfo : : toString ( ) const
{
std : : string ret ;
for ( const MyFileInfo : : NameLoc & nameLoc : classDefinitions ) {
2021-08-04 21:39:13 +02:00
ret + = " <class name= \" " + ErrorLogger : : toxml ( nameLoc . className ) +
2021-02-09 21:35:08 +01:00
" \" file= \" " + ErrorLogger : : toxml ( nameLoc . fileName ) +
" \" line= \" " + std : : to_string ( nameLoc . lineNumber ) +
" \" col= \" " + std : : to_string ( nameLoc . column ) +
" \" hash= \" " + std : : to_string ( nameLoc . hash ) +
" \" /> \n " ;
}
return ret ;
}
Check : : FileInfo * CheckClass : : loadFileInfoFromXml ( const tinyxml2 : : XMLElement * xmlElement ) const
{
MyFileInfo * fileInfo = new MyFileInfo ;
for ( const tinyxml2 : : XMLElement * e = xmlElement - > FirstChildElement ( ) ; e ; e = e - > NextSiblingElement ( ) ) {
if ( std : : strcmp ( e - > Name ( ) , " class " ) ! = 0 )
continue ;
const char * name = e - > Attribute ( " name " ) ;
const char * file = e - > Attribute ( " file " ) ;
const char * line = e - > Attribute ( " line " ) ;
const char * col = e - > Attribute ( " col " ) ;
const char * hash = e - > Attribute ( " hash " ) ;
if ( name & & file & & line & & col & & hash ) {
MyFileInfo : : NameLoc nameLoc ;
nameLoc . className = name ;
nameLoc . fileName = file ;
nameLoc . lineNumber = std : : atoi ( line ) ;
nameLoc . column = std : : atoi ( col ) ;
nameLoc . hash = MathLib : : toULongNumber ( hash ) ;
fileInfo - > classDefinitions . push_back ( nameLoc ) ;
}
}
if ( fileInfo - > classDefinitions . empty ( ) ) {
delete fileInfo ;
fileInfo = nullptr ;
}
return fileInfo ;
}
bool CheckClass : : analyseWholeProgram ( const CTU : : FileInfo * ctu , const std : : list < Check : : FileInfo * > & fileInfo , const Settings & settings , ErrorLogger & errorLogger )
{
bool foundErrors = false ;
( void ) ctu ; // This argument is unused
( void ) settings ; // This argument is unused
std : : unordered_map < std : : string , MyFileInfo : : NameLoc > all ;
for ( Check : : FileInfo * fi1 : fileInfo ) {
const MyFileInfo * fi = dynamic_cast < MyFileInfo * > ( fi1 ) ;
if ( ! fi )
continue ;
for ( const MyFileInfo : : NameLoc & nameLoc : fi - > classDefinitions ) {
auto it = all . find ( nameLoc . className ) ;
if ( it = = all . end ( ) ) {
all [ nameLoc . className ] = nameLoc ;
continue ;
}
if ( it - > second . hash = = nameLoc . hash )
continue ;
2021-02-10 11:44:05 +01:00
// Same location, sometimes the hash is different wrongly (possibly because of different token simplifications).
if ( it - > second . isSameLocation ( nameLoc ) )
continue ;
2021-02-09 21:35:08 +01:00
std : : list < ErrorMessage : : FileLocation > locationList ;
locationList . emplace_back ( nameLoc . fileName , nameLoc . lineNumber , nameLoc . column ) ;
locationList . emplace_back ( it - > second . fileName , it - > second . lineNumber , it - > second . column ) ;
const ErrorMessage errmsg ( locationList ,
emptyString ,
Severity : : error ,
" $symbol: " + nameLoc . className +
" \n The one definition rule is violated, different classes/structs have the same name '$symbol' " ,
" ctuOneDefinitionRuleViolation " ,
CWE_ONE_DEFINITION_RULE ,
2021-02-24 22:00:06 +01:00
Certainty : : normal ) ;
2021-02-09 21:35:08 +01:00
errorLogger . reportErr ( errmsg ) ;
foundErrors = true ;
}
}
return foundErrors ;
}