cppcheck/lib/cppcheck.cpp

528 lines
18 KiB
C++
Raw Normal View History

2010-04-13 19:25:08 +02:00
/*
* Cppcheck - A tool for static C/C++ code analysis
2012-01-01 00:05:37 +01:00
* Copyright (C) 2007-2012 Daniel Marjamäki and Cppcheck team.
2010-04-13 19:25:08 +02: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 "cppcheck.h"
2011-12-08 17:42:26 +01:00
#include "preprocessor.h" // Preprocessor
#include "tokenize.h" // Tokenizer
2010-04-13 19:25:08 +02:00
#include "check.h"
#include "path.h"
2010-04-13 19:25:08 +02:00
#include <algorithm>
#include <fstream>
#include <sstream>
#include <stdexcept>
2010-08-31 22:18:07 +02:00
#include "timer.h"
2010-04-13 19:25:08 +02:00
#ifdef HAVE_RULES
2010-12-12 11:56:22 +01:00
#define PCRE_STATIC
#include <pcre.h>
2010-12-31 10:24:51 +01:00
#endif
2010-12-12 11:56:22 +01:00
2012-04-15 07:23:26 +02:00
static const char Version[] = "1.54";
static const char ExtraVersion[] = "";
2010-04-13 19:25:08 +02:00
static TimerResults S_timerResults;
CppCheck::CppCheck(ErrorLogger &errorLogger, bool useGlobalSuppressions)
2012-04-07 15:36:45 +02:00
: exitcode(0), _useGlobalSuppressions(useGlobalSuppressions), _errorLogger(errorLogger)
2010-04-13 19:25:08 +02:00
{
}
CppCheck::~CppCheck()
{
if (_settings._showtime != SHOWTIME_NONE)
S_timerResults.ShowResults();
2010-04-13 19:25:08 +02:00
}
const char * CppCheck::version()
2010-04-13 19:25:08 +02:00
{
return Version;
}
const char * CppCheck::extraVersion()
{
return ExtraVersion;
2010-04-13 19:25:08 +02:00
}
unsigned int CppCheck::check(const std::string &path)
2010-04-13 19:25:08 +02:00
{
return processFile(path);
2010-04-13 19:25:08 +02:00
}
unsigned int CppCheck::check(const std::string &path, const std::string &content)
2010-04-13 19:25:08 +02:00
{
_fileContent = content;
const unsigned int retval = processFile(path);
_fileContent.clear();
return retval;
2010-04-13 19:25:08 +02:00
}
void CppCheck::replaceAll(std::string& code, const std::string &from, const std::string &to)
{
size_t pos = 0;
2011-10-13 20:53:06 +02:00
while ((pos = code.find(from, pos)) != std::string::npos) {
code.replace(pos, from.length(), to);
pos += to.length();
}
}
bool CppCheck::findError(std::string code, const char FileName[])
{
// First make sure that error occurs with the original code
checkFile(code, FileName);
2011-10-13 20:53:06 +02:00
if (_errorList.empty()) {
// Error does not occur with this code
return false;
}
std::string previousCode = code;
std::string error = _errorList.front();
2011-10-13 20:53:06 +02:00
for (;;) {
// Try to remove included files from the source
size_t found=previousCode.rfind("\n#endfile");
2011-10-13 20:53:06 +02:00
if (found == std::string::npos) {
// No modifications can be done to the code
2011-10-13 20:53:06 +02:00
} else {
// Modify code and re-check it to see if error
// is still there.
code = previousCode.substr(found+9);
_errorList.clear();
checkFile(code, FileName);
}
2011-10-13 20:53:06 +02:00
if (_errorList.empty()) {
// Latest code didn't fail anymore. Fall back
// to previous code
code = previousCode;
2011-10-13 20:53:06 +02:00
} else {
error = _errorList.front();
}
// Add '\n' so that "\n#file" on first line would be found
code = "// " + error + "\n" + code;
replaceAll(code, "\n#file", "\n// #file");
replaceAll(code, "\n#endfile", "\n// #endfile");
// We have reduced the code as much as we can. Print out
// the code and quit.
_errorLogger.reportOut(code);
break;
}
return true;
}
unsigned int CppCheck::processFile(const std::string& filename)
2010-04-13 19:25:08 +02:00
{
exitcode = 0;
// only show debug warnings for C/C++ source files (don't fix
// debug warnings for java/c#/etc files)
if (!Path::acceptFile(filename))
_settings.debugwarnings = false;
// TODO: Should this be moved out to its own function so all the files can be
// analysed before any files are checked?
2011-10-13 20:53:06 +02:00
if (_settings.test_2_pass && _settings._jobs == 1) {
const std::string printname = Path::toNativeSeparators(filename);
reportOut("Analysing " + printname + "...");
std::ifstream f(filename.c_str());
analyseFile(f, filename);
}
if (_settings.terminated())
return exitcode;
2011-10-13 20:53:06 +02:00
if (_settings._errorsOnly == false) {
std::string fixedpath = Path::simplifyPath(filename.c_str());
fixedpath = Path::toNativeSeparators(fixedpath);
_errorLogger.reportOut(std::string("Checking ") + fixedpath + std::string("..."));
}
2010-04-13 19:25:08 +02:00
2011-10-13 20:53:06 +02:00
try {
Preprocessor preprocessor(&_settings, this);
std::list<std::string> configurations;
std::string filedata = "";
2010-04-13 19:25:08 +02:00
2011-10-13 20:53:06 +02:00
if (!_fileContent.empty()) {
// File content was given as a string
std::istringstream iss(_fileContent);
preprocessor.preprocess(iss, filedata, configurations, filename, _settings._includePaths);
2011-10-13 20:53:06 +02:00
} else {
// Only file name was given, read the content from file
std::ifstream fin(filename.c_str());
Timer t("Preprocessor::preprocess", _settings._showtime, &S_timerResults);
preprocessor.preprocess(fin, filedata, configurations, filename, _settings._includePaths);
}
2010-04-13 19:25:08 +02:00
2011-10-13 20:53:06 +02:00
if (_settings.checkConfiguration) {
return 0;
}
2011-10-13 20:53:06 +02:00
if (!_settings.userDefines.empty()) {
configurations.clear();
configurations.push_back(_settings.userDefines);
}
2010-04-13 19:25:08 +02:00
int checkCount = 0;
2011-10-13 20:53:06 +02:00
for (std::list<std::string>::const_iterator it = configurations.begin(); it != configurations.end(); ++it) {
// Check only a few configurations (default 12), after that bail out, unless --force
// was used.
if (!_settings._force && checkCount >= _settings._maxConfigs) {
const std::string fixedpath = Path::toNativeSeparators(filename);
ErrorLogger::ErrorMessage::FileLocation location;
location.setfile(fixedpath);
std::list<ErrorLogger::ErrorMessage::FileLocation> loclist;
loclist.push_back(location);
const std::string msg("Interrupted checking because of too many #ifdef configurations.\n"
"The checking of the file was interrupted because there were too many "
"#ifdef configurations. Checking of all #ifdef configurations can be forced "
"by --force command line option or from GUI preferences. However that may "
"increase the checking time.");
ErrorLogger::ErrorMessage errmsg(loclist,
Severity::information,
msg,
"toomanyconfigs",
false);
2011-10-13 20:53:06 +02:00
if (!_settings.nomsg.isSuppressedLocal(errmsg._id, fixedpath, location.line)) {
reportErr(errmsg);
}
break;
2010-04-13 19:25:08 +02:00
}
cfg = *it;
Timer t("Preprocessor::getcode", _settings._showtime, &S_timerResults);
const std::string codeWithoutCfg = preprocessor.getcode(filedata, *it, filename);
t.Stop();
// If only errors are printed, print filename after the check
2011-10-13 20:53:06 +02:00
if (_settings._errorsOnly == false && it != configurations.begin()) {
std::string fixedpath = Path::simplifyPath(filename.c_str());
fixedpath = Path::toNativeSeparators(fixedpath);
_errorLogger.reportOut(std::string("Checking ") + fixedpath + ": " + cfg + std::string("..."));
}
const std::string &appendCode = _settings.append();
2011-10-13 20:53:06 +02:00
if (_settings.debugFalsePositive) {
if (findError(codeWithoutCfg + appendCode, filename.c_str())) {
return exitcode;
}
2011-10-13 20:53:06 +02:00
} else {
checkFile(codeWithoutCfg + appendCode, filename.c_str());
}
++checkCount;
2010-04-13 19:25:08 +02:00
}
2011-10-13 20:53:06 +02:00
} catch (std::runtime_error &e) {
// Exception was thrown when checking this file..
const std::string fixedpath = Path::toNativeSeparators(filename);
_errorLogger.reportOut("Bailing out from checking " + fixedpath + ": " + e.what());
}
if (!_settings._errorsOnly)
reportUnmatchedSuppressions(_settings.nomsg.getUnmatchedLocalSuppressions(filename));
2010-04-13 19:25:08 +02:00
_errorList.clear();
return exitcode;
}
void CppCheck::checkFunctionUsage()
{
2010-04-13 19:25:08 +02:00
// This generates false positives - especially for libraries
2011-10-13 20:53:06 +02:00
if (_settings.isEnabled("unusedFunction") && _settings._jobs == 1) {
const bool verbose_orig = _settings._verbose;
_settings._verbose = false;
2010-04-13 19:25:08 +02:00
if (_settings._errorsOnly == false)
_errorLogger.reportOut("Checking usage of global functions..");
2010-07-08 13:01:53 +02:00
_checkUnusedFunctions.check(this);
2010-04-13 19:25:08 +02:00
_settings._verbose = verbose_orig;
}
2010-04-13 19:25:08 +02:00
}
void CppCheck::analyseFile(std::istream &fin, const std::string &filename)
{
// Preprocess file..
Preprocessor preprocessor(&_settings, this);
std::list<std::string> configurations;
std::string filedata = "";
preprocessor.preprocess(fin, filedata, configurations, filename, _settings._includePaths);
const std::string code = preprocessor.getcode(filedata, "", filename);
2011-10-13 20:53:06 +02:00
if (_settings.checkConfiguration) {
return;
}
// Tokenize..
Tokenizer tokenizer(&_settings, this);
std::istringstream istr(code);
tokenizer.tokenize(istr, filename.c_str(), "");
tokenizer.simplifyTokenList();
// Analyse the tokens..
std::set<std::string> data;
2011-10-13 20:53:06 +02:00
for (std::list<Check *>::const_iterator it = Check::instances().begin(); it != Check::instances().end(); ++it) {
(*it)->analyse(tokenizer.tokens(), data);
}
// Save analysis results..
// TODO: This loop should be protected by a mutex or something like that
// The saveAnalysisData must _not_ be called from many threads at the same time.
2011-10-13 20:53:06 +02:00
for (std::list<Check *>::const_iterator it = Check::instances().begin(); it != Check::instances().end(); ++it) {
(*it)->saveAnalysisData(data);
}
}
2010-04-13 19:25:08 +02:00
//---------------------------------------------------------------------------
// CppCheck - A function that checks a specified file
//---------------------------------------------------------------------------
void CppCheck::checkFile(const std::string &code, const char FileName[])
{
if (_settings.terminated() || _settings.checkConfiguration)
2010-04-13 19:25:08 +02:00
return;
Tokenizer _tokenizer(&_settings, this);
if (_settings._showtime != SHOWTIME_NONE)
_tokenizer.setTimerResults(&S_timerResults);
try {
bool result;
2010-04-13 19:25:08 +02:00
// Tokenize the file
std::istringstream istr(code);
2010-04-13 19:25:08 +02:00
Timer timer("Tokenizer::tokenize", _settings._showtime, &S_timerResults);
result = _tokenizer.tokenize(istr, FileName, cfg);
timer.Stop();
if (!result) {
// File had syntax errors, abort
return;
}
2010-04-13 19:25:08 +02:00
// Update the _dependencies..
if (_tokenizer.getFiles().size() >= 2)
_dependencies.insert(_tokenizer.getFiles().begin()+1, _tokenizer.getFiles().end());
// call all "runChecks" in all registered Check classes
for (std::list<Check *>::iterator it = Check::instances().begin(); it != Check::instances().end(); ++it) {
if (_settings.terminated())
return;
2010-04-13 19:25:08 +02:00
Timer timerRunChecks((*it)->name() + "::runChecks", _settings._showtime, &S_timerResults);
(*it)->runChecks(&_tokenizer, &_settings, this);
}
2010-04-13 19:25:08 +02:00
if (_settings.isEnabled("unusedFunction") && _settings._jobs == 1)
_checkUnusedFunctions.parseTokens(_tokenizer);
Timer timer3("Tokenizer::simplifyTokenList", _settings._showtime, &S_timerResults);
result = _tokenizer.simplifyTokenList();
timer3.Stop();
if (!result)
return;
2010-04-13 19:25:08 +02:00
// call all "runSimplifiedChecks" in all registered Check classes
for (std::list<Check *>::iterator it = Check::instances().begin(); it != Check::instances().end(); ++it) {
if (_settings.terminated())
return;
2010-04-13 19:25:08 +02:00
Timer timerSimpleChecks((*it)->name() + "::runSimplifiedChecks", _settings._showtime, &S_timerResults);
(*it)->runSimplifiedChecks(&_tokenizer, &_settings, this);
}
2010-12-12 11:56:22 +01:00
#ifdef HAVE_RULES
// Are there extra rules?
if (!_settings.rules.empty()) {
std::ostringstream ostr;
for (const Token *tok = _tokenizer.tokens(); tok; tok = tok->next())
ostr << " " << tok->str();
const std::string str(ostr.str());
for (std::list<Settings::Rule>::const_iterator it = _settings.rules.begin(); it != _settings.rules.end(); ++it) {
const Settings::Rule &rule = *it;
if (rule.pattern.empty() || rule.id.empty() || rule.severity.empty())
continue;
const char *error = 0;
int erroffset = 0;
pcre *re = pcre_compile(rule.pattern.c_str(),0,&error,&erroffset,NULL);
if (!re && error) {
ErrorLogger::ErrorMessage errmsg(std::list<ErrorLogger::ErrorMessage::FileLocation>(),
Severity::error,
error,
"pcre_compile",
false);
2010-12-12 11:56:22 +01:00
reportErr(errmsg);
2011-02-02 16:54:04 +01:00
}
if (!re)
continue;
int pos = 0;
int ovector[30];
while (0 <= pcre_exec(re, NULL, str.c_str(), (int)str.size(), pos, 0, ovector, 30)) {
unsigned int pos1 = (unsigned int)ovector[0];
unsigned int pos2 = (unsigned int)ovector[1];
// jump to the end of the match for the next pcre_exec
pos = (int)pos2;
// determine location..
ErrorLogger::ErrorMessage::FileLocation loc;
loc.setfile(_tokenizer.getFiles().front());
loc.line = 0;
unsigned int len = 0;
for (const Token *tok = _tokenizer.tokens(); tok; tok = tok->next()) {
len = len + 1 + tok->str().size();
if (len > pos1) {
loc.setfile(_tokenizer.getFiles().at(tok->fileIndex()));
loc.line = tok->linenr();
break;
}
}
2010-12-12 11:56:22 +01:00
const std::list<ErrorLogger::ErrorMessage::FileLocation> callStack(1, loc);
2010-12-12 11:56:22 +01:00
// Create error message
std::string summary;
if (rule.summary.empty())
summary = "found '" + str.substr(pos1, pos2 - pos1) + "'";
else
summary = rule.summary;
const ErrorLogger::ErrorMessage errmsg(callStack, Severity::fromString(rule.severity), summary, rule.id, false);
2010-12-12 11:56:22 +01:00
// Report error
reportErr(errmsg);
}
2011-02-02 16:54:04 +01:00
pcre_free(re);
}
2010-12-12 11:56:22 +01:00
}
2010-12-31 10:24:51 +01:00
#endif
} catch (const InternalError &e) {
std::list<ErrorLogger::ErrorMessage::FileLocation> locationList;
ErrorLogger::ErrorMessage::FileLocation loc2;
loc2.setfile(Path::toNativeSeparators(FileName));
locationList.push_back(loc2);
ErrorLogger::ErrorMessage::FileLocation loc;
if (e.token) {
loc.line = e.token->linenr();
const std::string fixedpath = Path::toNativeSeparators(_tokenizer.file(e.token));
loc.setfile(fixedpath);
} else {
loc.setfile(_tokenizer.getSourceFilePath());
}
locationList.push_back(loc);
const ErrorLogger::ErrorMessage errmsg(locationList,
Severity::error,
e.errorMessage,
"cppcheckError",
false);
_errorLogger.reportErr(errmsg);
}
2010-04-13 19:25:08 +02:00
}
Settings &CppCheck::settings()
2010-04-13 19:25:08 +02:00
{
return _settings;
}
//---------------------------------------------------------------------------
void CppCheck::reportErr(const ErrorLogger::ErrorMessage &msg)
{
std::string errmsg = msg.toString(_settings._verbose);
if (errmsg.empty())
return;
2010-04-13 19:25:08 +02:00
// Alert only about unique errors
if (std::find(_errorList.begin(), _errorList.end(), errmsg) != _errorList.end())
return;
2011-10-13 20:53:06 +02:00
if (_settings.debugFalsePositive) {
// Don't print out error
_errorList.push_back(errmsg);
return;
}
2010-04-13 19:25:08 +02:00
std::string file;
unsigned int line(0);
2011-10-13 20:53:06 +02:00
if (!msg._callStack.empty()) {
file = msg._callStack.back().getfile(false);
2010-04-13 19:25:08 +02:00
line = msg._callStack.back().line;
}
2011-10-13 20:53:06 +02:00
if (_useGlobalSuppressions) {
if (_settings.nomsg.isSuppressed(msg._id, file, line))
return;
2011-10-13 20:53:06 +02:00
} else {
if (_settings.nomsg.isSuppressedLocal(msg._id, file, line))
return;
}
2010-04-13 19:25:08 +02:00
if (!_settings.nofail.isSuppressed(msg._id, file, line))
exitcode = 1;
_errorList.push_back(errmsg);
2011-10-13 20:53:06 +02:00
if (_settings._verbose) {
errmsg += "\n Defines=\'" + cfg + "\'\n";
2010-04-13 19:25:08 +02:00
}
_errorLogger.reportErr(msg);
}
void CppCheck::reportOut(const std::string &outmsg)
{
_errorLogger.reportOut(outmsg);
}
void CppCheck::reportProgress(const std::string &filename, const char stage[], const unsigned int value)
2010-04-13 19:25:08 +02:00
{
_errorLogger.reportProgress(filename, stage, value);
2010-04-13 19:25:08 +02:00
}
void CppCheck::reportStatus(unsigned int /*fileindex*/, unsigned int /*filecount*/, size_t /*sizedone*/, size_t /*sizetotal*/)
{
}
2010-04-13 19:25:08 +02:00
void CppCheck::getErrorMessages()
{
// call all "getErrorMessages" in all registered Check classes
for (std::list<Check *>::iterator it = Check::instances().begin(); it != Check::instances().end(); ++it)
(*it)->getErrorMessages(this, &_settings);
2010-04-13 19:25:08 +02:00
Tokenizer tokenizer(&_settings, 0);
tokenizer.getErrorMessages(this, &_settings);
2010-04-13 19:25:08 +02:00
Preprocessor::getErrorMessages(this, &_settings);
2010-04-13 19:25:08 +02:00
}