cppcheck/lib/executionpath.cpp

492 lines
16 KiB
C++
Raw Normal View History

2009-12-14 20:30:31 +01:00
/*
* Cppcheck - A tool for static C/C++ code analysis
2014-02-15 07:45:39 +01:00
* Copyright (C) 2007-2014 Daniel Marjamäki and Cppcheck team.
2009-12-14 20:30:31 +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 "executionpath.h"
#include "token.h"
#include "symboldatabase.h"
2009-12-14 20:30:31 +01:00
#include <memory>
2010-04-25 11:55:57 +02:00
#include <set>
2010-04-25 12:10:50 +02:00
#include <iterator>
#include <iostream>
2009-12-14 20:30:31 +01:00
2009-12-25 19:45:21 +01:00
// default : bail out if the condition is has variable handling
2009-12-25 20:50:23 +01:00
bool ExecutionPath::parseCondition(const Token &tok, std::list<ExecutionPath *> & checks)
2009-12-25 19:45:21 +01:00
{
unsigned int parlevel = 0;
2011-10-13 20:53:06 +02:00
for (const Token *tok2 = &tok; tok2; tok2 = tok2->next()) {
if (tok2->str() == "(")
2009-12-25 19:45:21 +01:00
++parlevel;
2011-10-13 20:53:06 +02:00
else if (tok2->str() == ")") {
if (parlevel == 0)
2009-12-25 19:45:21 +01:00
break;
--parlevel;
2011-10-13 20:53:06 +02:00
} else if (Token::Match(tok2, "[;{}]"))
2009-12-25 19:45:21 +01:00
break;
2011-10-13 20:53:06 +02:00
if (tok2->varId() != 0) {
2010-04-25 11:55:57 +02:00
bailOutVar(checks, tok2->varId());
2009-12-25 19:45:21 +01:00
}
}
2011-10-13 20:53:06 +02:00
for (std::list<ExecutionPath *>::iterator it = checks.begin(); it != checks.end();) {
if ((*it)->varId > 0 && (*it)->numberOfIf >= 1) {
delete *it;
checks.erase(it++);
2011-10-13 20:53:06 +02:00
} else {
++it;
}
}
2009-12-25 19:45:21 +01:00
return false;
}
void ExecutionPath::print() const
{
std::cout << " varId=" << varId
<< " numberOfIf=" << numberOfIf
<< "\n";
}
// I use this function when debugging ExecutionPaths with GDB
/*
static void printchecks(const std::list<ExecutionPath *> &checks)
{
for (std::list<ExecutionPath *>::const_iterator it = checks.begin(); it != checks.end(); ++it)
(*it)->print();
}
*/
/**
* @brief Parse If/Switch body recursively.
* @param tok First token in body.
* @param checks The current checks
* @param newchecks new checks
* @param countif The countif set - count number of if for each execution path
*/
static void parseIfSwitchBody(const Token * const tok,
const std::list<ExecutionPath *> &checks,
std::list<ExecutionPath *> &newchecks,
std::set<unsigned int> &countif)
{
std::set<unsigned int> countif2;
std::list<ExecutionPath *> c;
2011-10-13 20:53:06 +02:00
if (!checks.empty()) {
std::list<ExecutionPath *>::const_iterator it;
2011-10-13 20:53:06 +02:00
for (it = checks.begin(); it != checks.end(); ++it) {
if ((*it)->numberOfIf == 0)
c.push_back((*it)->copy());
if ((*it)->varId != 0)
countif2.insert((*it)->varId);
}
}
ExecutionPath::checkScope(tok, c);
2011-10-13 20:53:06 +02:00
while (!c.empty()) {
if (c.back()->varId == 0) {
2011-05-19 19:31:51 +02:00
delete c.back();
c.pop_back();
continue;
}
bool duplicate = false;
std::list<ExecutionPath *>::const_iterator it;
2011-10-13 20:53:06 +02:00
for (it = checks.begin(); it != checks.end(); ++it) {
if (*(*it) == *c.back() && (*it)->numberOfIf == c.back()->numberOfIf) {
duplicate = true;
countif2.erase((*it)->varId);
break;
}
}
if (!duplicate)
newchecks.push_back(c.back());
2011-05-19 19:31:51 +02:00
else
delete c.back();
c.pop_back();
}
// Add countif2 ids to countif.. countif.
countif.insert(countif2.begin(), countif2.end());
}
void ExecutionPath::checkScope(const Token *tok, std::list<ExecutionPath *> &checks)
2009-12-14 20:30:31 +01:00
{
if (!tok || tok->str() == "}" || checks.empty())
return;
2010-01-08 21:54:24 +01:00
2009-12-14 20:30:31 +01:00
const std::auto_ptr<ExecutionPath> check(checks.front()->copy());
2011-10-13 20:53:06 +02:00
for (; tok; tok = tok->next()) {
2010-09-17 19:31:45 +02:00
// might be a noreturn function..
if (Token::simpleMatch(tok->tokAt(-2), ") ; }") &&
Token::Match(tok->linkAt(-2)->tokAt(-2), "[;{}] %var% (") &&
tok->linkAt(-2)->previous()->varId() == 0) {
2010-09-17 19:31:45 +02:00
ExecutionPath::bailOut(checks);
return;
}
if (Token::simpleMatch(tok, "union {")) {
tok = tok->next()->link();
continue;
}
if (tok->str() == "}")
return;
2009-12-14 20:30:31 +01:00
2011-10-13 20:53:06 +02:00
if (tok->str() == "break") {
ExecutionPath::bailOut(checks);
return;
}
2011-10-13 20:53:06 +02:00
if (Token::simpleMatch(tok, "while (")) {
// parse condition
2011-10-13 20:53:06 +02:00
if (checks.size() > 10 || check->parseCondition(*tok->tokAt(2), checks)) {
ExecutionPath::bailOut(checks);
return;
}
// skip "while (fgets()!=NULL)"
2011-10-13 20:53:06 +02:00
if (Token::simpleMatch(tok, "while ( fgets (")) {
const Token *tok2 = tok->linkAt(3);
2011-10-13 20:53:06 +02:00
if (Token::simpleMatch(tok2, ") ) {")) {
tok = tok2->linkAt(2);
if (!tok)
break;
continue;
}
}
}
// goto/setjmp/longjmp => bailout
else if (Token::Match(tok, "goto|setjmp|longjmp")) {
ExecutionPath::bailOut(checks);
return;
}
// ?: => bailout
2011-10-13 20:53:06 +02:00
if (tok->str() == "?") {
for (const Token *tok2 = tok; tok2 && tok2->str() != ";"; tok2 = tok2->next()) {
if (tok2->varId() > 0)
ExecutionPath::bailOutVar(checks, tok2->varId());
}
}
// for/while/switch/do .. bail out
else if (Token::Match(tok, "for|while|switch|do")) {
// goto {
const Token *tok2 = tok->next();
if (tok2 && tok2->str() == "(")
tok2 = tok2->link();
if (tok2 && tok2->str() == ")")
tok2 = tok2->next();
if (!tok2 || tok2->str() != "{") {
ExecutionPath::bailOut(checks);
return;
}
if (tok->str() == "switch") {
// parse condition
if (checks.size() > 10 || check->parseCondition(*tok->next(), checks)) {
ExecutionPath::bailOut(checks);
return;
}
// what variable ids should the if be counted for?
std::set<unsigned int> countif;
std::list<ExecutionPath *> newchecks;
for (const Token* tok3 = tok2->next(); tok3; tok3 = tok3->next()) {
if (tok3->str() == "{")
tok3 = tok3->link();
else if (tok3->str() == "}")
break;
else if (tok3->str() == "case" &&
!Token::Match(tok3, "case %num% : ; case")) {
parseIfSwitchBody(tok3, checks, newchecks, countif);
}
}
// Add newchecks to checks..
std::copy(newchecks.begin(), newchecks.end(), std::back_inserter(checks));
// Increase numberOfIf
std::list<ExecutionPath *>::iterator it;
2011-10-13 20:53:06 +02:00
for (it = checks.begin(); it != checks.end(); ++it) {
if (countif.find((*it)->varId) != countif.end())
(*it)->numberOfIf++;
}
}
// no switch
else {
2011-10-13 20:53:06 +02:00
for (const Token *tok3 = tok; tok3 && tok3 != tok2; tok3 = tok3->next()) {
if (tok3->varId())
ExecutionPath::bailOutVar(checks, tok3->varId());
}
// it is not certain that a for/while will be executed:
2011-10-13 20:53:06 +02:00
for (std::list<ExecutionPath *>::iterator it = checks.begin(); it != checks.end();) {
if ((*it)->numberOfIf > 0) {
delete *it;
checks.erase(it++);
} else
++it;
}
// #2231 - loop body only contains a conditional initialization..
2011-10-13 20:53:06 +02:00
if (Token::simpleMatch(tok2->next(), "if (")) {
// Start { for the if block
const Token *tok3 = tok2->linkAt(2);
2011-10-13 20:53:06 +02:00
if (Token::simpleMatch(tok3,") {")) {
tok3 = tok3->next();
// End } for the if block
const Token *tok4 = tok3->link();
if (Token::Match(tok3, "{ %var% =") &&
Token::simpleMatch(tok4, "} }") &&
2011-10-13 20:53:06 +02:00
Token::simpleMatch(tok4->tokAt(-2), "break ;")) {
// Is there a assignment and then a break?
const Token *t = Token::findsimplematch(tok3, ";");
2011-10-13 20:53:06 +02:00
if (t && t->tokAt(3) == tok4) {
for (std::list<ExecutionPath *>::iterator it = checks.begin(); it != checks.end(); ++it) {
if ((*it)->varId == tok3->next()->varId()) {
(*it)->numberOfIf++;
break;
}
}
tok = tok2->link();
continue;
}
}
}
}
// parse loop bodies
check->parseLoopBody(tok2->next(), checks);
}
// skip { .. }
tok2 = tok2->link();
// if "do { .. } while ( .." , goto end of while..
if (Token::simpleMatch(tok, "do {") && Token::simpleMatch(tok2, "} while ("))
tok2 = tok2->linkAt(2);
// bail out all variables if the scope contains a "return"
// bail out all variables used in this for/while/switch/do
2011-10-13 20:53:06 +02:00
for (; tok && tok != tok2; tok = tok->next()) {
if (tok->str() == "return")
ExecutionPath::bailOut(checks);
if (tok->varId())
ExecutionPath::bailOutVar(checks, tok->varId());
}
continue;
2009-12-14 20:30:31 +01:00
}
// bailout used variables in '; FOREACH ( .. ) { .. }'
2011-10-13 20:53:06 +02:00
else if (tok->str() != "if" && Token::Match(tok->previous(), "[;{}] %var% (")) {
// goto {
const Token *tok2 = tok->next()->link()->next();
if (tok2 && tok2->str() == "{") {
// goto "}"
tok2 = tok2->link();
// bail out all variables used in "{ .. }"
for (; tok && tok != tok2; tok = tok->next()) {
if (tok->varId())
ExecutionPath::bailOutVar(checks, tok->varId());
}
if (!tok)
break;
}
}
// .. ) { ... } => bail out
if (tok->str() == ")" && tok->next() && tok->next()->str() == "{") {
ExecutionPath::bailOut(checks);
return;
}
if ((tok->str() == "abort" || tok->str() == "exit") &&
tok->next() && tok->next()->str() == "(") {
ExecutionPath::bailOut(checks);
return;
}
2009-12-21 18:17:35 +01:00
// don't parse into "struct type { .."
2011-10-13 20:53:06 +02:00
if (Token::Match(tok, "struct|union|class %type% {|:")) {
while (tok && tok->str() != "{" && tok->str() != ";")
tok = tok->next();
tok = tok ? tok->link() : 0;
2011-10-13 20:53:06 +02:00
if (!tok) {
ExecutionPath::bailOut(checks);
return;
}
}
2009-12-21 18:17:35 +01:00
2011-10-13 20:53:06 +02:00
if (Token::simpleMatch(tok, "= {")) {
// GCC struct initialization.. bail out
2011-10-13 20:53:06 +02:00
if (Token::Match(tok->tokAt(2), ". %var% =")) {
ExecutionPath::bailOut(checks);
return;
}
const Token * const end = tok->next()->link();
while (tok && tok != end) {
if (Token::Match(tok, "[{,] & %var% [,}]"))
ExecutionPath::bailOutVar(checks, tok->tokAt(2)->varId());
tok = tok->next();
}
2011-10-13 20:53:06 +02:00
if (!tok) {
2009-12-14 20:30:31 +01:00
ExecutionPath::bailOut(checks);
return;
2009-12-14 20:30:31 +01:00
}
continue;
}
// ; { ... }
if (tok && Token::Match(tok->previous(), "[;{}:] {")) {
ExecutionPath::checkScope(tok->next(), checks);
tok = tok->link();
continue;
}
if (tok && tok->str() == "if" && tok->next() && tok->next()->str() == "(") {
2010-04-25 11:55:57 +02:00
// what variable ids should the numberOfIf be counted for?
std::set<unsigned int> countif;
2009-12-14 20:30:31 +01:00
std::list<ExecutionPath *> newchecks;
while (tok->str() == "if" && tok->next() && tok->next()->str() == "(") {
2009-12-14 20:30:31 +01:00
// goto "("
tok = tok->next();
2009-12-25 19:45:21 +01:00
// parse condition
2011-10-13 20:53:06 +02:00
if (checks.size() > 10 || check->parseCondition(*tok->next(), checks)) {
ExecutionPath::bailOut(checks);
ExecutionPath::bailOut(newchecks);
return;
2009-12-14 20:30:31 +01:00
}
2009-12-25 19:45:21 +01:00
// goto ")"
tok = tok->link();
2009-12-25 19:45:21 +01:00
2009-12-14 20:30:31 +01:00
// goto "{"
tok = tok->next();
2009-12-14 20:30:31 +01:00
if (!tok || tok->str() != "{") {
ExecutionPath::bailOut(checks);
ExecutionPath::bailOut(newchecks);
return;
}
2009-12-14 20:30:31 +01:00
// Recursively check into the if ..
parseIfSwitchBody(tok->next(), checks, newchecks, countif);
2009-12-14 20:30:31 +01:00
// goto "}"
tok = tok->link();
// there is no else => break out
if (!tok->next() || tok->next()->str() != "else")
2009-12-14 20:30:31 +01:00
break;
// parse next "if"..
tok = tok->tokAt(2);
if (!tok) {
ExecutionPath::bailOut(newchecks);
return;
}
2014-08-18 12:30:52 +02:00
if (tok->str() == "if")
continue;
2009-12-14 20:30:31 +01:00
// there is no "if"..
ExecutionPath::checkScope(tok->next(), checks);
2009-12-14 20:30:31 +01:00
tok = tok->link();
2011-10-13 20:53:06 +02:00
if (!tok) {
ExecutionPath::bailOut(newchecks);
return;
}
2009-12-14 20:30:31 +01:00
}
2010-04-25 11:55:57 +02:00
// Add newchecks to checks..
std::copy(newchecks.begin(), newchecks.end(), std::back_inserter(checks));
// Increase numberOfIf
2009-12-14 20:30:31 +01:00
std::list<ExecutionPath *>::iterator it;
2011-10-13 20:53:06 +02:00
for (it = checks.begin(); it != checks.end(); ++it) {
2010-04-25 11:55:57 +02:00
if (countif.find((*it)->varId) != countif.end())
(*it)->numberOfIf++;
}
// Delete checks that have numberOfIf >= 2
2011-10-13 20:53:06 +02:00
for (it = checks.begin(); it != checks.end();) {
if ((*it)->varId > 0 && (*it)->numberOfIf >= 2) {
delete *it;
checks.erase(it++);
2011-10-13 20:53:06 +02:00
} else {
++it;
}
}
2009-12-14 20:30:31 +01:00
}
2014-09-04 18:08:56 +02:00
if (tok) {
tok = check->parse(*tok, checks);
if (checks.empty())
return;
2009-12-14 20:30:31 +01:00
}
2012-01-31 15:49:34 +01:00
if (!tok)
break;
// return/throw ends all execution paths
if (tok->str() == "return" ||
tok->str() == "throw" ||
tok->str() == "continue" ||
2011-10-13 20:53:06 +02:00
tok->str() == "break") {
2009-12-14 20:30:31 +01:00
ExecutionPath::bailOut(checks);
}
}
}
void checkExecutionPaths(const SymbolDatabase *symbolDatabase, ExecutionPath *c)
{
for (std::list<Scope>::const_iterator i = symbolDatabase->scopeList.begin(); i != symbolDatabase->scopeList.end(); ++i) {
if (i->type != Scope::eFunction || !i->classStart)
continue;
// Check function
std::list<ExecutionPath *> checks;
checks.push_back(c->copy());
ExecutionPath::checkScope(i->classStart, checks);
c->end(checks, i->classEnd);
// Cleanup
while (!checks.empty()) {
delete checks.back();
checks.pop_back();
}
}
}