void CppCheck::checkFile(const std::string &code, const char FileName[])
{
if (_settings.terminated() || _settings.checkConfiguration)
return;
Tokenizer _tokenizer(&_settings, this);
if (_settings._showtime != SHOWTIME_NONE)
_tokenizer.setTimerResults(&S_timerResults);
try {
bool result;
// Tokenize the file
std::istringstream istr(code);
Timer timer("Tokenizer::tokenize", _settings._showtime, &S_timerResults);
result = _tokenizer.tokenize(istr, FileName, cfg);
timer.Stop();
if (!result) {
// File had syntax errors, abort
return;
}
// Update the _dependencies..
if (_tokenizer.list.getFiles().size() >= 2)
_dependencies.insert(_tokenizer.list.getFiles().begin()+1, _tokenizer.list.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;
Timer timerRunChecks((*it)->name() + "::runChecks", _settings._showtime, &S_timerResults);
(*it)->runChecks(&_tokenizer, &_settings, this);
}
if (_settings.isEnabled("unusedFunction") && _settings._jobs == 1)
_checkUnusedFunctions.parseTokens(_tokenizer);
if (!_simplify)
return;
Timer timer3("Tokenizer::simplifyTokenList", _settings._showtime, &S_timerResults);
result = _tokenizer.simplifyTokenList();
timer3.Stop();
if (!result)
return;
// 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;
Timer timerSimpleChecks((*it)->name() + "::runSimplifiedChecks", _settings._showtime, &S_timerResults);
(*it)->runSimplifiedChecks(&_tokenizer, &_settings, this);
}
#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);
reportErr(errmsg);
}
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.getSourceFilePath());
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.list.getFiles().at(tok->fileIndex()));
loc.line = tok->linenr();
break;
}
}
const std::list<ErrorLogger::ErrorMessage::FileLocation> callStack(1, loc);
// 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);
// Report error
reportErr(errmsg);
}
pcre_free(re);
}
}
#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.list.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);
}
}
unsigned int CppCheck::processFile(const std::string& filename, const std::string &cfgname, std::istream& fileStream)
{
exitcode = 0;
// only show debug warnings for accepted C/C++ source files
if (!Path::acceptFile(filename))
_settings.debugwarnings = false;
if (_settings.terminated())
return exitcode;
if (!_settings.quiet) {
std::string fixedpath = Path::simplifyPath(filename);
fixedpath = Path::toNativeSeparators(fixedpath);
_errorLogger.reportOut(std::string("Checking ") + fixedpath + ' ' + cfgname + std::string("..."));
if (_settings.verbose) {
_errorLogger.reportOut("Defines: " + _settings.userDefines);
std::string includePaths;
for (std::list<std::string>::const_iterator I = _settings.includePaths.begin(); I != _settings.includePaths.end(); ++I)
includePaths += " -I" + *I;
_errorLogger.reportOut("Includes:" + includePaths);
_errorLogger.reportOut(std::string("Platform:") + _settings.platformString());
}
}
if (plistFile.is_open()) {
plistFile << ErrorLogger::plistFooter();
plistFile.close();
}
CheckUnusedFunctions checkUnusedFunctions(nullptr, nullptr, nullptr);
bool internalErrorFound(false);
try {
Preprocessor preprocessor(_settings, this);
std::set<std::string> configurations;
simplecpp::OutputList outputList;
std::vector<std::string> files;
simplecpp::TokenList tokens1(fileStream, files, filename, &outputList);
// If there is a syntax error, report it and stop
for (simplecpp::OutputList::const_iterator it = outputList.begin(); it != outputList.end(); ++it) {
bool err;
switch (it->type) {
case simplecpp::Output::ERROR:
case simplecpp::Output::INCLUDE_NESTED_TOO_DEEPLY:
case simplecpp::Output::SYNTAX_ERROR:
case simplecpp::Output::UNHANDLED_CHAR_ERROR:
err = true;
break;
case simplecpp::Output::WARNING:
case simplecpp::Output::MISSING_HEADER:
case simplecpp::Output::PORTABILITY_BACKSLASH:
err = false;
break;
};
if (err) {
const ErrorLogger::ErrorMessage::FileLocation loc1(it->location.file(), it->location.line);
std::list<ErrorLogger::ErrorMessage::FileLocation> callstack;
callstack.push_back(loc1);
ErrorLogger::ErrorMessage errmsg(callstack,
"",
Severity::error,
it->msg,
"syntaxError",
false);
_errorLogger.reportErr(errmsg);
return 1;
}
}
preprocessor.loadFiles(tokens1, files);
if (!_settings.plistOutput.empty()) {
std::string filename2;
if (filename.find('/') != std::string::npos)
filename2 = filename.substr(filename.rfind('/') + 1);
else
filename2 = filename;
filename2 = _settings.plistOutput + filename2.substr(0, filename2.find('.')) + ".plist";
plistFile.open(filename2);
plistFile << ErrorLogger::plistHeader(version(), files);
}
// write dump file xml prolog
std::ofstream fdump;
if (_settings.dump) {
const std::string dumpfile(_settings.dumpFile.empty() ? (filename + ".dump") : _settings.dumpFile);
fdump.open(dumpfile.c_str());
if (fdump.is_open()) {
fdump << "<?xml version=\"1.0\"?>" << std::endl;
fdump << "<dumps>" << std::endl;
fdump << " <platform"
<< " name=\"" << _settings.platformString() << '\"'
<< " char_bit=\"" << _settings.char_bit << '\"'
<< " short_bit=\"" << _settings.short_bit << '\"'
<< " int_bit=\"" << _settings.int_bit << '\"'
<< " long_bit=\"" << _settings.long_bit << '\"'
<< " long_long_bit=\"" << _settings.long_long_bit << '\"'
<< " pointer_bit=\"" << (_settings.sizeof_pointer * _settings.char_bit) << '\"'
<< "/>\n";
fdump << " <rawtokens>" << std::endl;
for (unsigned int i = 0; i < files.size(); ++i)
fdump << " <file index=\"" << i << "\" name=\"" << ErrorLogger::toxml(files[i]) << "\"/>" << std::endl;
for (const simplecpp::Token *tok = tokens1.cfront(); tok; tok = tok->next) {
fdump << " <tok "
<< "fileIndex=\"" << tok->location.fileIndex << "\" "
<< "linenr=\"" << tok->location.line << "\" "
<< "str=\"" << ErrorLogger::toxml(tok->str) << "\""
<< "/>" << std::endl;
}
fdump << " </rawtokens>" << std::endl;
}
}
// Parse comments and then remove them
preprocessor.inlineSuppressions(tokens1);
tokens1.removeComments();
preprocessor.removeComments();
if (!_settings.buildDir.empty()) {
// Get toolinfo
std::string toolinfo;
toolinfo += CPPCHECK_VERSION_STRING;
toolinfo += _settings.isEnabled(Settings::WARNING) ? 'w' : ' ';
toolinfo += _settings.isEnabled(Settings::STYLE) ? 's' : ' ';
toolinfo += _settings.isEnabled(Settings::PERFORMANCE) ? 'p' : ' ';
toolinfo += _settings.isEnabled(Settings::PORTABILITY) ? 'p' : ' ';
toolinfo += _settings.isEnabled(Settings::INFORMATION) ? 'i' : ' ';
toolinfo += _settings.userDefines;
// Calculate checksum so it can be compared with old checksum / future checksums
const unsigned int checksum = preprocessor.calculateChecksum(tokens1, toolinfo);
std::list<ErrorLogger::ErrorMessage> errors;
if (!analyzerInformation.analyzeFile(_settings.buildDir, filename, cfgname, checksum, &errors)) {
while (!errors.empty()) {
reportErr(errors.front());
errors.pop_front();
}
return exitcode; // known results => no need to reanalyze file
}
}
// Get directives
preprocessor.setDirectives(tokens1);
preprocessor.simplifyPragmaAsm(&tokens1);
preprocessor.setPlatformInfo(&tokens1);
// Get configurations..
if (_settings.userDefines.empty() || _settings.force) {
Timer t("Preprocessor::getConfigs", _settings.showtime, &S_timerResults);
configurations = preprocessor.getConfigs(tokens1);
} else {
configurations.insert(_settings.userDefines);
}
if (_settings.checkConfiguration) {
for (std::set<std::string>::const_iterator it = configurations.begin(); it != configurations.end(); ++it)
(void)preprocessor.getcode(tokens1, *it, files, true);
return 0;
}
// Run define rules on raw code
for (std::list<Settings::Rule>::const_iterator it = _settings.rules.begin(); it != _settings.rules.end(); ++it) {
if (it->tokenlist != "define")
continue;
std::string code;
const std::list<Directive> &directives = preprocessor.getDirectives();
for (std::list<Directive>::const_iterator dir = directives.begin(); dir != directives.end(); ++dir) {
if (dir->str.compare(0,8,"#define ") == 0)
code += "#line " + MathLib::toString(dir->linenr) + " \"" + dir->file + "\"\n" + dir->str + '\n';
}
Tokenizer tokenizer2(&_settings, this);
std::istringstream istr2(code);
tokenizer2.list.createTokens(istr2);
executeRules("define", tokenizer2);
break;
}
if (!_settings.force && configurations.size() > _settings.maxConfigs) {
if (_settings.isEnabled(Settings::INFORMATION)) {
tooManyConfigsError(Path::toNativeSeparators(filename),configurations.size());
} else {
tooManyConfigs = true;
}
}
std::set<unsigned long long> checksums;
unsigned int checkCount = 0;
for (std::set<std::string>::const_iterator it = configurations.begin(); it != configurations.end(); ++it) {
// bail out if terminated
if (_settings.terminated())
break;
// Check only a few configurations (default 12), after that bail out, unless --force
// was used.
if (!_settings.force && ++checkCount > _settings.maxConfigs)
break;
cfg = *it;
// If only errors are printed, print filename after the check
if (!_settings.quiet && (!cfg.empty() || it != configurations.begin())) {
std::string fixedpath = Path::simplifyPath(filename);
fixedpath = Path::toNativeSeparators(fixedpath);
_errorLogger.reportOut("Checking " + fixedpath + ": " + cfg + "...");
}
if (!_settings.userDefines.empty()) {
if (!cfg.empty())
cfg = ";" + cfg;
cfg = _settings.userDefines + cfg;
}
if (_settings.preprocessOnly) {
Timer t("Preprocessor::getcode", _settings.showtime, &S_timerResults);
std::string codeWithoutCfg = preprocessor.getcode(tokens1, cfg, files, true);
t.Stop();
if (codeWithoutCfg.compare(0,5,"#file") == 0)
codeWithoutCfg.insert(0U, "//");
std::string::size_type pos = 0;
while ((pos = codeWithoutCfg.find("\n#file",pos)) != std::string::npos)
codeWithoutCfg.insert(pos+1U, "//");
pos = 0;
while ((pos = codeWithoutCfg.find("\n#endfile",pos)) != std::string::npos)
codeWithoutCfg.insert(pos+1U, "//");
pos = 0;
while ((pos = codeWithoutCfg.find(Preprocessor::macroChar,pos)) != std::string::npos)
codeWithoutCfg[pos] = ' ';
reportOut(codeWithoutCfg);
continue;
}
Tokenizer _tokenizer(&_settings, this);
if (_settings.showtime != SHOWTIME_NONE)
_tokenizer.setTimerResults(&S_timerResults);
try {
bool result;
// Create tokens, skip rest of iteration if failed
Timer timer("Tokenizer::createTokens", _settings.showtime, &S_timerResults);
const simplecpp::TokenList &tokensP = preprocessor.preprocess(tokens1, cfg, files);
_tokenizer.createTokens(&tokensP);
timer.Stop();
if (tokensP.empty())
continue;
// skip rest of iteration if just checking configuration
if (_settings.checkConfiguration)
continue;
// Check raw tokens
checkRawTokens(_tokenizer);
// Simplify tokens into normal form, skip rest of iteration if failed
Timer timer2("Tokenizer::simplifyTokens1", _settings.showtime, &S_timerResults);
result = _tokenizer.simplifyTokens1(cfg);
timer2.Stop();
if (!result)
continue;
// dump xml if --dump
if (_settings.dump && fdump.is_open()) {
fdump << "<dump cfg=\"" << ErrorLogger::toxml(cfg) << "\">" << std::endl;
preprocessor.dump(fdump);
_tokenizer.dump(fdump);
fdump << "</dump>" << std::endl;
}
// Skip if we already met the same simplified token list
if (_settings.force || _settings.maxConfigs > 1) {
const unsigned long long checksum = _tokenizer.list.calculateChecksum();
if (checksums.find(checksum) != checksums.end()) {
if (_settings.isEnabled(Settings::INFORMATION) && (_settings.debug || _settings.verbose))
purgedConfigurationMessage(filename, cfg);
continue;
}
checksums.insert(checksum);
}
// Check normal tokens
checkNormalTokens(_tokenizer);
// Analyze info..
if (!_settings.buildDir.empty())
checkUnusedFunctions.parseTokens(_tokenizer, filename.c_str(), &_settings, false);
// simplify more if required, skip rest of iteration if failed
if (_simplify) {
// if further simplification fails then skip rest of iteration
Timer timer3("Tokenizer::simplifyTokenList2", _settings.showtime, &S_timerResults);
result = _tokenizer.simplifyTokenList2();
timer3.Stop();
if (!result)
continue;
// Check simplified tokens
checkSimplifiedTokens(_tokenizer);
}
} catch (const InternalError &e) {
internalErrorFound=true;
std::list<ErrorLogger::ErrorMessage::FileLocation> locationList;
ErrorLogger::ErrorMessage::FileLocation loc;
if (e.token) {
loc.line = e.token->linenr();
const std::string fixedpath = Path::toNativeSeparators(_tokenizer.list.file(e.token));
loc.setfile(fixedpath);
} else {
ErrorLogger::ErrorMessage::FileLocation loc2;
loc2.setfile(Path::toNativeSeparators(filename));
locationList.push_back(loc2);
loc.setfile(_tokenizer.list.getSourceFilePath());
}
locationList.push_back(loc);
ErrorLogger::ErrorMessage errmsg(locationList,
_tokenizer.list.getSourceFilePath(),
Severity::error,
e.errorMessage,
e.id,
false);
reportErr(errmsg);
}
}
// dumped all configs, close root </dumps> element now
if (_settings.dump && fdump.is_open())
fdump << "</dumps>" << std::endl;
} catch (const std::runtime_error &e) {
internalError(filename, e.what());
} catch (const std::bad_alloc &e) {
internalError(filename, e.what());
} catch (const InternalError &e) {
internalError(filename, e.errorMessage);
exitcode=1; // e.g. reflect a syntax error
}
analyzerInformation.setFileInfo("CheckUnusedFunctions", checkUnusedFunctions.analyzerInfo());
analyzerInformation.close();
// In jointSuppressionReport mode, unmatched suppressions are
// collected after all files are processed
if (!_settings.jointSuppressionReport && (_settings.isEnabled(Settings::INFORMATION) || _settings.checkConfiguration)) {
reportUnmatchedSuppressions(_settings.nomsg.getUnmatchedLocalSuppressions(filename, isUnusedFunctionCheckEnabled()));
}
_errorList.clear();
if (internalErrorFound && (exitcode==0)) {
exitcode=1;
}
return exitcode;
}
void CppCheck::executeRules(const std::string &tokenlist, const Tokenizer &tokenizer)
{
(void)tokenlist;
(void)tokenizer;
#ifdef HAVE_RULES
// Are there rules to execute?
bool isrule = false;
for (std::list<Settings::Rule>::const_iterator it = _settings.rules.begin(); it != _settings.rules.end(); ++it) {
if (it->tokenlist == tokenlist)
isrule = true;
}
// There is no rule to execute
if (isrule == false)
return;
// Write all tokens in a string that can be parsed by pcre
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 == Severity::none || rule.tokenlist != tokenlist)
continue;
const char *error = nullptr;
int erroffset = 0;
pcre *re = pcre_compile(rule.pattern.c_str(),0,&error,&erroffset,nullptr);
if (!re) {
if (error) {
ErrorLogger::ErrorMessage errmsg(std::list<ErrorLogger::ErrorMessage::FileLocation>(),
emptyString,
Severity::error,
error,
"pcre_compile",
false);
reportErr(errmsg);
}
continue;
}
int pos = 0;
int ovector[30]= {0};
while (pos < (int)str.size() && 0 <= pcre_exec(re, nullptr, str.c_str(), (int)str.size(), pos, 0, ovector, 30)) {
const unsigned int pos1 = (unsigned int)ovector[0];
const 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.list.getSourceFilePath());
loc.line = 0;
std::size_t len = 0;
for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
len = len + 1U + tok->str().size();
if (len > pos1) {
loc.setfile(tokenizer.list.getFiles().at(tok->fileIndex()));
loc.line = tok->linenr();
break;
}
}
const std::list<ErrorLogger::ErrorMessage::FileLocation> callStack(1, loc);
// 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, tokenizer.list.getSourceFilePath(), rule.severity, summary, rule.id, false);
// Report error
reportErr(errmsg);
}
pcre_free(re);
}
#endif
}
unsigned int CppCheck::processFile(const std::string& filename)
{
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?
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;
if (_settings._errorsOnly == false) {
std::string fixedpath = Path::simplifyPath(filename.c_str());
fixedpath = Path::toNativeSeparators(fixedpath);
_errorLogger.reportOut(std::string("Checking ") + fixedpath + std::string("..."));
}
try {
Preprocessor preprocessor(&_settings, this);
std::list<std::string> configurations;
std::string filedata = "";
if (!_fileContent.empty()) {
// File content was given as a string
std::istringstream iss(_fileContent);
preprocessor.preprocess(iss, filedata, configurations, filename, _settings._includePaths);
} 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);
}
if (_settings.checkConfiguration) {
return 0;
}
if (!_settings.userDefines.empty()) {
configurations.clear();
configurations.push_back(_settings.userDefines);
}
int checkCount = 0;
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);
if (!_settings.nomsg.isSuppressedLocal(errmsg._id, fixedpath, location.line)) {
reportErr(errmsg);
}
break;
}
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
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();
if (_settings.debugFalsePositive) {
if (findError(codeWithoutCfg + appendCode, filename.c_str())) {
return exitcode;
}
} else {
checkFile(codeWithoutCfg + appendCode, filename.c_str());
}
++checkCount;
}
} 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));
_errorList.clear();
return exitcode;
}
unsigned int CppCheck::processFile(const std::string& filename, std::istream& fileStream)
{
exitcode = 0;
// only show debug warnings for accepted C/C++ source files
if (!Path::acceptFile(filename))
_settings.debugwarnings = false;
if (_settings.terminated())
return exitcode;
if (_settings.quiet == false) {
std::string fixedpath = Path::simplifyPath(filename);
fixedpath = Path::toNativeSeparators(fixedpath);
_errorLogger.reportOut(std::string("Checking ") + fixedpath + std::string("..."));
}
bool internalErrorFound(false);
try {
Preprocessor preprocessor(_settings, this);
std::list<std::string> configurations;
std::string filedata;
{
Timer t("Preprocessor::preprocess", _settings.showtime, &S_timerResults);
preprocessor.preprocess(fileStream, filedata, configurations, filename, _settings.includePaths);
}
if (_settings.checkConfiguration) {
return 0;
}
// Run define rules on raw code
for (std::list<Settings::Rule>::const_iterator it = _settings.rules.begin(); it != _settings.rules.end(); ++it) {
if (it->tokenlist == "define") {
Tokenizer tokenizer2(&_settings, this);
std::istringstream istr2(filedata);
tokenizer2.list.createTokens(istr2, filename);
for (const Token *tok = tokenizer2.list.front(); tok; tok = tok->next()) {
if (tok->str() == "#define") {
std::string code = std::string(tok->linenr()-1U, '\n');
for (const Token *tok2 = tok; tok2 && tok2->linenr() == tok->linenr(); tok2 = tok2->next())
code += " " + tok2->str();
Tokenizer tokenizer3(&_settings, this);
std::istringstream istr3(code);
tokenizer3.list.createTokens(istr3, tokenizer2.list.file(tok));
executeRules("define", tokenizer3);
}
}
break;
}
}
if (!_settings.userDefines.empty() && _settings.maxConfigs==1U) {
configurations.clear();
configurations.push_back(_settings.userDefines);
}
if (!_settings.force && configurations.size() > _settings.maxConfigs) {
if (_settings.isEnabled("information")) {
tooManyConfigsError(Path::toNativeSeparators(filename),configurations.size());
} else {
tooManyConfigs = true;
}
}
// write dump file xml prolog
std::ofstream fdump;
if (_settings.dump) {
const std::string dumpfile(filename + ".dump");
fdump.open(dumpfile.c_str());
if (fdump.is_open()) {
fdump << "<?xml version=\"1.0\"?>" << std::endl;
fdump << "<dumps>" << std::endl;
}
}
std::set<unsigned long long> checksums;
unsigned int checkCount = 0;
for (std::list<std::string>::const_iterator it = configurations.begin(); it != configurations.end(); ++it) {
// bail out if terminated
if (_settings.terminated())
break;
// Check only a few configurations (default 12), after that bail out, unless --force
// was used.
if (!_settings.force && ++checkCount > _settings.maxConfigs)
break;
cfg = *it;
// If only errors are printed, print filename after the check
if (_settings.quiet == false && it != configurations.begin()) {
std::string fixedpath = Path::simplifyPath(filename);
fixedpath = Path::toNativeSeparators(fixedpath);
_errorLogger.reportOut("Checking " + fixedpath + ": " + cfg + "...");
}
if (!_settings.userDefines.empty()) {
if (!cfg.empty())
cfg = ";" + cfg;
cfg = _settings.userDefines + cfg;
}
Timer t("Preprocessor::getcode", _settings.showtime, &S_timerResults);
std::string codeWithoutCfg = preprocessor.getcode(filedata, cfg, filename);
t.Stop();
codeWithoutCfg += _settings.append();
if (_settings.preprocessOnly) {
if (codeWithoutCfg.compare(0,5,"#file") == 0)
codeWithoutCfg.insert(0U, "//");
std::string::size_type pos = 0;
while ((pos = codeWithoutCfg.find("\n#file",pos)) != std::string::npos)
codeWithoutCfg.insert(pos+1U, "//");
pos = 0;
while ((pos = codeWithoutCfg.find("\n#endfile",pos)) != std::string::npos)
codeWithoutCfg.insert(pos+1U, "//");
pos = 0;
while ((pos = codeWithoutCfg.find(Preprocessor::macroChar,pos)) != std::string::npos)
codeWithoutCfg[pos] = ' ';
reportOut(codeWithoutCfg);
continue;
}
Tokenizer _tokenizer(&_settings, this);
if (_settings.showtime != SHOWTIME_NONE)
_tokenizer.setTimerResults(&S_timerResults);
try {
// Create tokens, skip rest of iteration if failed
std::istringstream istr(codeWithoutCfg);
Timer timer("Tokenizer::createTokens", _settings.showtime, &S_timerResults);
bool result = _tokenizer.createTokens(istr, filename);
timer.Stop();
if (!result)
continue;
// skip rest of iteration if just checking configuration
if (_settings.checkConfiguration)
continue;
// Check raw tokens
checkRawTokens(_tokenizer);
// Simplify tokens into normal form, skip rest of iteration if failed
Timer timer2("Tokenizer::simplifyTokens1", _settings.showtime, &S_timerResults);
result = _tokenizer.simplifyTokens1(cfg);
timer2.Stop();
if (!result)
continue;
// dump xml if --dump
if (_settings.dump && fdump.is_open()) {
fdump << "<dump cfg=\"" << cfg << "\">" << std::endl;
preprocessor.dump(fdump);
_tokenizer.dump(fdump);
fdump << "</dump>" << std::endl;
}
// Skip if we already met the same simplified token list
if (_settings.force || _settings.maxConfigs > 1) {
const unsigned long long checksum = _tokenizer.list.calculateChecksum();
if (checksums.find(checksum) != checksums.end())
continue;
checksums.insert(checksum);
}
// Check normal tokens
checkNormalTokens(_tokenizer);
// simplify more if required, skip rest of iteration if failed
if (_simplify) {
// if further simplification fails then skip rest of iteration
Timer timer3("Tokenizer::simplifyTokenList2", _settings.showtime, &S_timerResults);
result = _tokenizer.simplifyTokenList2();
timer3.Stop();
if (!result)
continue;
// Check simplified tokens
checkSimplifiedTokens(_tokenizer);
}
} catch (const InternalError &e) {
if (_settings.isEnabled("information") && (_settings.debug || _settings.verbose))
purgedConfigurationMessage(filename, cfg);
internalErrorFound=true;
std::list<ErrorLogger::ErrorMessage::FileLocation> locationList;
ErrorLogger::ErrorMessage::FileLocation loc;
if (e.token) {
loc.line = e.token->linenr();
const std::string fixedpath = Path::toNativeSeparators(_tokenizer.list.file(e.token));
loc.setfile(fixedpath);
} else {
ErrorLogger::ErrorMessage::FileLocation loc2;
loc2.setfile(Path::toNativeSeparators(filename.c_str()));
locationList.push_back(loc2);
loc.setfile(_tokenizer.list.getSourceFilePath());
}
locationList.push_back(loc);
const ErrorLogger::ErrorMessage errmsg(locationList,
Severity::error,
e.errorMessage,
e.id,
false);
reportErr(errmsg);
}
}
// dumped all configs, close root </dumps> element now
if (_settings.dump && fdump.is_open())
fdump << "</dumps>" << std::endl;
} catch (const std::runtime_error &e) {
internalError(filename, e.what());
} catch (const std::bad_alloc &e) {
internalError(filename, e.what());
} catch (const InternalError &e) {
internalError(filename, e.errorMessage);
exitcode=1; // e.g. reflect a syntax error
}
// In jointSuppressionReport mode, unmatched suppressions are
// collected after all files are processed
if (!_settings.jointSuppressionReport && (_settings.isEnabled("information") || _settings.checkConfiguration)) {
reportUnmatchedSuppressions(_settings.nomsg.getUnmatchedLocalSuppressions(filename, unusedFunctionCheckIsEnabled()));
}
_errorList.clear();
if (internalErrorFound && (exitcode==0)) {
exitcode=1;
}
return exitcode;
}
/*
* That is a method which gets called from check_wrapper
* */
int CppCheckExecutor::check_internal(CppCheck& cppcheck, int /*argc*/, const char* const argv[])
{
Settings& settings = cppcheck.settings();
_settings = &settings;
bool std = tryLoadLibrary(settings.library, argv[0], "std.cfg");
bool posix = true;
if (settings.standards.posix)
posix = tryLoadLibrary(settings.library, argv[0], "posix.cfg");
bool windows = true;
if (settings.isWindowsPlatform())
windows = tryLoadLibrary(settings.library, argv[0], "windows.cfg");
if (!std || !posix || !windows) {
const std::list<ErrorLogger::ErrorMessage::FileLocation> callstack;
const std::string msg("Failed to load " + std::string(!std ? "std.cfg" : !posix ? "posix.cfg" : "windows.cfg") + ". Your Cppcheck installation is broken, please re-install.");
#ifdef CFGDIR
const std::string details("The Cppcheck binary was compiled with CFGDIR set to \"" +
std::string(CFGDIR) + "\" and will therefore search for "
"std.cfg in that path.");
#else
const std::string cfgfolder(Path::fromNativeSeparators(Path::getPathFromFilename(argv[0])) + "cfg");
const std::string details("The Cppcheck binary was compiled without CFGDIR set. Either the "
"std.cfg should be available in " + cfgfolder + " or the CFGDIR "
"should be configured.");
#endif
ErrorLogger::ErrorMessage errmsg(callstack, Severity::information, msg+" "+details, "failedToLoadCfg", false);
reportErr(errmsg);
return EXIT_FAILURE;
}
if (settings.reportProgress)
time1 = std::time(0);
if (settings._xml) {
reportErr(ErrorLogger::ErrorMessage::getXMLHeader(settings._xml_version));
}
unsigned int returnValue = 0;
if (settings._jobs == 1) {
// Single process
settings.jointSuppressionReport = true;
std::size_t totalfilesize = 0;
for (std::map<std::string, std::size_t>::const_iterator i = _files.begin(); i != _files.end(); ++i) {
totalfilesize += i->second;
}
std::size_t processedsize = 0;
unsigned int c = 0;
for (std::map<std::string, std::size_t>::const_iterator i = _files.begin(); i != _files.end(); ++i) {
if (!_settings->library.markupFile(i->first)
|| !_settings->library.processMarkupAfterCode(i->first)) {
returnValue += cppcheck.check(i->first);
processedsize += i->second;
if (!settings._errorsOnly)
reportStatus(c + 1, _files.size(), processedsize, totalfilesize);
c++;
}
}
// second loop to parse all markup files which may not work until all
// c/cpp files have been parsed and checked
for (std::map<std::string, std::size_t>::const_iterator i = _files.begin(); i != _files.end(); ++i) {
if (_settings->library.markupFile(i->first) && _settings->library.processMarkupAfterCode(i->first)) {
returnValue += cppcheck.check(i->first);
processedsize += i->second;
if (!settings._errorsOnly)
reportStatus(c + 1, _files.size(), processedsize, totalfilesize);
c++;
}
}
cppcheck.analyseWholeProgram();
} else if (!ThreadExecutor::isEnabled()) {
std::cout << "No thread support yet implemented for this platform." << std::endl;
} else {
// Multiple processes
ThreadExecutor executor(_files, settings, *this);
returnValue = executor.check();
}
if (settings.isEnabled("information") || settings.checkConfiguration) {
const bool enableUnusedFunctionCheck = cppcheck.unusedFunctionCheckIsEnabled();
if (settings.jointSuppressionReport) {
for (std::map<std::string, std::size_t>::const_iterator i = _files.begin(); i != _files.end(); ++i) {
reportUnmatchedSuppressions(settings.nomsg.getUnmatchedLocalSuppressions(i->first, enableUnusedFunctionCheck));
}
}
reportUnmatchedSuppressions(settings.nomsg.getUnmatchedGlobalSuppressions(enableUnusedFunctionCheck));
}
if (!settings.checkConfiguration) {
cppcheck.tooManyConfigsError("",0U);
if (settings.isEnabled("missingInclude") && (Preprocessor::missingIncludeFlag || Preprocessor::missingSystemIncludeFlag)) {
const std::list<ErrorLogger::ErrorMessage::FileLocation> callStack;
ErrorLogger::ErrorMessage msg(callStack,
Severity::information,
"Cppcheck cannot find all the include files (use --check-config for details)\n"
"Cppcheck cannot find all the include files. Cppcheck can check the code without the "
"include files found. But the results will probably be more accurate if all the include "
"files are found. Please check your project's include directories and add all of them "
"as include directories for Cppcheck. To see what files Cppcheck cannot find use "
"--check-config.",
Preprocessor::missingIncludeFlag ? "missingInclude" : "missingIncludeSystem",
false);
reportInfo(msg);
}
}
if (settings._xml) {
reportErr(ErrorLogger::ErrorMessage::getXMLFooter(settings._xml_version));
}
_settings = 0;
if (returnValue)
return settings._exitCode;
else
return 0;
}
void CppCheckExecutor::reportInfo(const ErrorLogger::ErrorMessage &msg)
{
reportErr(msg);
}
void CppCheck::executeRules(const std::string &tokenlist, const Tokenizer &tokenizer)
{
(void)tokenlist;
(void)tokenizer;
#ifdef HAVE_RULES
// Are there rules to execute?
bool isrule = false;
for (std::list<Settings::Rule>::const_iterator it = mSettings.rules.begin(); it != mSettings.rules.end(); ++it) {
if (it->tokenlist == tokenlist)
isrule = true;
}
// There is no rule to execute
if (isrule == false)
return;
// Write all tokens in a string that can be parsed by pcre
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 = mSettings.rules.begin(); it != mSettings.rules.end(); ++it) {
const Settings::Rule &rule = *it;
if (rule.pattern.empty() || rule.id.empty() || rule.severity == Severity::none || rule.tokenlist != tokenlist)
continue;
const char *pcreCompileErrorStr = nullptr;
int erroffset = 0;
pcre * const re = pcre_compile(rule.pattern.c_str(),0,&pcreCompileErrorStr,&erroffset,nullptr);
if (!re) {
if (pcreCompileErrorStr) {
const std::string msg = "pcre_compile failed: " + std::string(pcreCompileErrorStr);
const ErrorLogger::ErrorMessage errmsg(std::list<ErrorLogger::ErrorMessage::FileLocation>(),
emptyString,
Severity::error,
msg,
"pcre_compile",
false);
reportErr(errmsg);
}
continue;
}
// Optimize the regex, but only if PCRE_CONFIG_JIT is available
#ifdef PCRE_CONFIG_JIT
const char *pcreStudyErrorStr = nullptr;
pcre_extra * const pcreExtra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &pcreStudyErrorStr);
// pcre_study() returns NULL for both errors and when it can not optimize the regex.
// The last argument is how one checks for errors.
// It is NULL if everything works, and points to an error string otherwise.
if (pcreStudyErrorStr) {
const std::string msg = "pcre_study failed: " + std::string(pcreStudyErrorStr);
const ErrorLogger::ErrorMessage errmsg(std::list<ErrorLogger::ErrorMessage::FileLocation>(),
emptyString,
Severity::error,
msg,
"pcre_study",
false);
reportErr(errmsg);
// pcre_compile() worked, but pcre_study() returned an error. Free the resources allocated by pcre_compile().
pcre_free(re);
continue;
}
#else
const pcre_extra * const pcreExtra = nullptr;
#endif
int pos = 0;
int ovector[30]= {0};
while (pos < (int)str.size()) {
const int pcreExecRet = pcre_exec(re, pcreExtra, str.c_str(), (int)str.size(), pos, 0, ovector, 30);
if (pcreExecRet < 0) {
const std::string errorMessage = pcreErrorCodeToString(pcreExecRet);
if (!errorMessage.empty()) {
const ErrorLogger::ErrorMessage errmsg(std::list<ErrorLogger::ErrorMessage::FileLocation>(),
emptyString,
Severity::error,
std::string("pcre_exec failed: ") + errorMessage,
"pcre_exec",
false);
reportErr(errmsg);
}
break;
}
const unsigned int pos1 = (unsigned int)ovector[0];
const 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.list.getSourceFilePath());
loc.line = 0;
std::size_t len = 0;
for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
len = len + 1U + tok->str().size();
if (len > pos1) {
loc.setfile(tokenizer.list.getFiles().at(tok->fileIndex()));
loc.line = tok->linenr();
break;
}
}
const std::list<ErrorLogger::ErrorMessage::FileLocation> callStack(1, loc);
// 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, tokenizer.list.getSourceFilePath(), rule.severity, summary, rule.id, false);
// Report error
reportErr(errmsg);
}
pcre_free(re);
#ifdef PCRE_CONFIG_JIT
// Free up the EXTRA PCRE value (may be NULL at this point)
if (pcreExtra) {
pcre_free_study(pcreExtra);
}
#endif
}
#endif
}
int main(void)
{
/* Declare Variables, a pain in C */
int (* cmp) (const void*, const void*);
char* input, * input2, ** linebuf, * line, curChar;
char readbuf[2];
size_t lineNum, lineSize, bufferSize, i, fileSize;
int isEOF, isSpace;
ssize_t ret;
struct stat buf;
/* Initialize variables */
bufferSize = 0, lineNum = 0, lineSize = 0, isEOF = 0;
/* Set frobcmp pointer */
cmp = &cmpWrapper;
/* File Information */
ret = fstat(STDIN_FILENO, &buf);
checkIOErr(ret);
fileSize = buf.st_size + 1;
/* Setup Initial Buffer */
input = (char*) malloc(sizeof(char) * fileSize);
checkMemErr(input);
line = input;
/* *
* Read from Input
*/
while ( ! isEOF)
{
ret = read(STDIN_FILENO, readbuf, 1);
checkIOErr(ret);
curChar = readbuf[0];
isSpace = curChar == SPACE;
isEOF = ! ret;
if ( ! lineSize && isSpace)
continue;
/* Resize buffer */
if (bufferSize == fileSize)
{
fileSize *= 2;
input2 = (char*) realloc(input, sizeof(char) * fileSize);
checkMemErr(input2);
input = input2;
}
/* Store the current character */
if ( ! isEOF)
{
input[bufferSize++] = curChar;
lineSize++;
if ( ! isSpace)
continue;
}
else
{
if ( ! bufferSize)
{
free(input);
return 0; /* An Empty file or a file with only spaces */
}
/* Append a space if there is none */
if (input[bufferSize-1] != SPACE)
input[bufferSize++] = SPACE;
if ( ! lineSize)
break;
}
/* New Line */
lineNum++;
lineSize = 0;
}
linebuf = (char**) malloc(sizeof(char*) * lineNum);
checkMemErr(linebuf);
if (lineNum != initLinebuf(linebuf, input, bufferSize))
reportErr("Wrong Line Number.");
/* Sort the input */
qsort(linebuf, lineNum, sizeof(char*), cmp);
/* Output results */
for (i = 0; i < lineNum; i++)
strWrite(linebuf[i]);
/* Free input array */
free(linebuf);
free(input);
fprintf(stderr, "Comparisons: %ld\n", numOfComp);
return 0;
}
/* Check if malloc / realloc allocates memory successfully */
inline
void checkMemErr(void* ptr)
{
if (ptr == NULL) reportErr("Memory Allocation");
}
/* Check IO Error */
inline
void checkIOErr(ssize_t ret)
{
if (ret < 0) reportErr("IO");
}
int CppCheckExecutor::check(int argc, const char* const argv[])
{
Preprocessor::missingIncludeFlag = false;
CppCheck cppCheck(*this, true);
if (!parseFromArgs(&cppCheck, argc, argv)) {
return EXIT_FAILURE;
}
if (cppCheck.settings().reportProgress)
time1 = std::time(0);
_settings = cppCheck.settings();
if (_settings._xml) {
reportErr(ErrorLogger::ErrorMessage::getXMLHeader(_settings._xml_version));
}
unsigned int returnValue = 0;
if (_settings._jobs == 1) {
// Single process
long totalfilesize = 0;
for (std::map<std::string, long>::const_iterator i = _filesizes.begin(); i != _filesizes.end(); ++i) {
totalfilesize += i->second;
}
long processedsize = 0;
for (unsigned int c = 0; c < _filenames.size(); c++) {
returnValue += cppCheck.check(_filenames[c]);
if (_filesizes.find(_filenames[c]) != _filesizes.end()) {
processedsize += _filesizes[_filenames[c]];
}
if (!_settings._errorsOnly)
reportStatus(c + 1, _filenames.size(), processedsize, totalfilesize);
}
cppCheck.checkFunctionUsage();
} else if (!ThreadExecutor::isEnabled()) {
std::cout << "No thread support yet implemented for this platform." << std::endl;
} else {
// Multiple processes
Settings &settings = cppCheck.settings();
ThreadExecutor executor(_filenames, _filesizes, settings, *this);
returnValue = executor.check();
}
if (!cppCheck.settings().checkConfiguration) {
if (!_settings._errorsOnly)
reportUnmatchedSuppressions(cppCheck.settings().nomsg.getUnmatchedGlobalSuppressions());
if (Preprocessor::missingIncludeFlag) {
const std::list<ErrorLogger::ErrorMessage::FileLocation> callStack;
ErrorLogger::ErrorMessage msg(callStack,
Severity::information,
"Cppcheck cannot find all the include files (use --check-config for details)\n"
"Cppcheck cannot find all the include files. Cpppcheck can check the code without the "
"include files found. But the results will probably be more accurate if all the include "
"files are found. Please check your project's include directories and add all of them "
"as include directories for Cppcheck. To see what files Cppcheck cannot find use "
"--check-config.",
"missingInclude",
false);
reportErr(msg);
}
}
if (_settings._xml) {
reportErr(ErrorLogger::ErrorMessage::getXMLFooter(_settings._xml_version));
}
if (returnValue)
return _settings._exitCode;
else
return 0;
}
