/*

* Cppcheck - A tool for static C/C++ code analysis

* Copyright (C) 2007-2021 Cppcheck team.

*

* 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"

#include "check.h"

#include "checkunusedfunctions.h"

#include "clangimport.h"

#include "ctu.h"

#include "library.h"

#include "mathlib.h"

#include "path.h"

#include "platform.h"

#include "preprocessor.h" // Preprocessor

#include "suppressions.h"

#include "timer.h"

#include "tokenize.h" // Tokenizer

#include "tokenlist.h"

#include "version.h"

#include "exprengine.h"

#define PICOJSON_USE_INT64

#include <picojson.h>

#include <simplecpp.h>

#include <tinyxml2.h>

#include <algorithm>

#include <cstring>

#include <new>

#include <set>

#include <stdexcept>

#include <vector>

#include <memory>

#include <iostream> // <- TEMPORARY

#include <cstdio>

#ifdef HAVE_RULES

#define PCRE_STATIC

#include <pcre.h>

#endif

static const char Version[] = CPPCHECK_VERSION_STRING;

static const char ExtraVersion[] = "";

static TimerResults s_timerResults;

// CWE ids used

static const CWE CWE398(398U); // Indicator of Poor Code Quality

namespace {

struct AddonInfo {

std::string name;

std::string scriptFile;

std::string args;

std::string python;

static std::string getFullPath(const std::string &fileName, const std::string &exename) {

if (Path::fileExists(fileName))

return fileName;

const std::string exepath = Path::getPathFromFilename(exename);

if (Path::fileExists(exepath + fileName))

return exepath + fileName;

if (Path::fileExists(exepath + "addons/" + fileName))

return exepath + "addons/" + fileName;

#ifdef FILESDIR

if (Path::fileExists(FILESDIR + ("/" + fileName)))

return FILESDIR + ("/" + fileName);

if (Path::fileExists(FILESDIR + ("/addons/" + fileName)))

return FILESDIR + ("/addons/" + fileName);

#endif

return "";

}

std::string parseAddonInfo(const picojson::value &json, const std::string &fileName, const std::string &exename) {

const std::string& json_error = picojson::get_last_error();

if (!json_error.empty()) {

return "Loading " + fileName + " failed. " + json_error;

}

if (!json.is<picojson::object>())

return "Loading " + fileName + " failed. Bad json.";

picojson::object obj = json.get<picojson::object>();

if (obj.count("args")) {

if (!obj["args"].is<picojson::array>())

return "Loading " + fileName + " failed. args must be array.";

for (const picojson::value &v : obj["args"].get<picojson::array>())

args += " " + v.get<std::string>();

}

if (obj.count("python")) {

// Python was defined in the config file

if (obj["python"].is<picojson::array>()) {

return "Loading " + fileName +" failed. python must not be an array.";

}

python = obj["python"].get<std::string>();

} else {

python = "";

}

return getAddonInfo(obj["script"].get<std::string>(), exename);

}

std::string getAddonInfo(const std::string &fileName, const std::string &exename) {

if (fileName[0] == '{') {

std::istringstream in(fileName);

picojson::value json;

in >> json;

return parseAddonInfo(json, fileName, exename);

}

if (fileName.find(".") == std::string::npos)

return getAddonInfo(fileName + ".py", exename);

if (endsWith(fileName, ".py", 3)) {

scriptFile = getFullPath(fileName, exename);

if (scriptFile.empty())

return "Did not find addon " + fileName;

std::string::size_type pos1 = scriptFile.rfind("/");

if (pos1 == std::string::npos)

pos1 = 0;

else

pos1++;

std::string::size_type pos2 = scriptFile.rfind(".");

if (pos2 < pos1)

pos2 = std::string::npos;

name = scriptFile.substr(pos1, pos2 - pos1);

return "";

}

if (!endsWith(fileName, ".json", 5))

return "Failed to open addon " + fileName;

std::ifstream fin(fileName);

if (!fin.is_open())

return "Failed to open " + fileName;

picojson::value json;

fin >> json;

return parseAddonInfo(json, fileName, exename);

}

};

}

static std::string cmdFileName(std::string f)

{

f = Path::toNativeSeparators(f);

if (f.find(" ") != std::string::npos)

return "\"" + f + "\"";

return f;

}

static std::vector<std::string> split(const std::string &str, const std::string &sep=" ")

{

std::vector<std::string> ret;

for (std::string::size_type startPos = 0U; startPos < str.size();) {

startPos = str.find_first_not_of(sep, startPos);

if (startPos == std::string::npos)

break;

if (str[startPos] == '\"') {

const std::string::size_type endPos = str.find("\"", startPos + 1);

ret.push_back(str.substr(startPos + 1, endPos - startPos - 1));

startPos = (endPos < str.size()) ? (endPos + 1) : endPos;

continue;

}

const std::string::size_type endPos = str.find(sep, startPos + 1);

ret.push_back(str.substr(startPos, endPos - startPos));

startPos = endPos;

}

return ret;

}

static void createDumpFile(const Settings& settings,

const std::string& filename,

const std::vector<std::string>& files,

const simplecpp::Token* rawtokens,

std::ofstream& fdump,

std::string& dumpFile)

{

if (!settings.dump && settings.addons.empty())

return;

if (!settings.dumpFile.empty())

dumpFile = settings.dumpFile;

else if (!settings.dump && !settings.buildDir.empty())

dumpFile = AnalyzerInformation::getAnalyzerInfoFile(settings.buildDir, filename, "") + ".dump";

else

dumpFile = filename + ".dump";

fdump.open(dumpFile);

if (!fdump.is_open())

return;

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";

if (rawtokens) {

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 = rawtokens; tok; tok = tok->next) {

fdump << " <tok "

<< "fileIndex=\"" << tok->location.fileIndex << "\" "

<< "linenr=\"" << tok->location.line << "\" "

<< "column=\"" << tok->location.col << "\" "

<< "str=\"" << ErrorLogger::toxml(tok->str()) << "\""

<< "/>" << std::endl;

}

fdump << " </rawtokens>" << std::endl;

}

}

static std::string executeAddon(const AddonInfo &addonInfo,

const std::string &defaultPythonExe,

const std::string &dumpFile,

std::function<bool(std::string,std::vector<std::string>,std::string,std::string*)> executeCommand)

{

const std::string redirect = "2>&1";

std::string pythonExe;

if (!addonInfo.python.empty())

pythonExe = cmdFileName(addonInfo.python);

else if (!defaultPythonExe.empty())

pythonExe = cmdFileName(defaultPythonExe);

else {

#ifdef _WIN32

const char *py_exes[] = { "python3.exe", "python.exe" };

#else

const char *py_exes[] = { "python3", "python" };

#endif

for (const char* py_exe : py_exes) {

std::string out;

if (executeCommand(py_exe, split("--version"), redirect, &out) && out.compare(0, 7, "Python ") == 0 && std::isdigit(out[7])) {

pythonExe = py_exe;

break;

}

}

if (pythonExe.empty())

throw InternalError(nullptr, "Failed to auto detect python");

}

const std::string args = cmdFileName(addonInfo.scriptFile) + " --cli" + addonInfo.args + " " + cmdFileName(dumpFile);

std::string result;

if (!executeCommand(pythonExe, split(args), redirect, &result))

throw InternalError(nullptr, "Failed to execute addon (command: '" + pythonExe + " " + args + "')");

// Validate output..

std::istringstream istr(result);

std::string line;

while (std::getline(istr, line)) {

if (line.compare(0,9,"Checking ", 0, 9) != 0 && !line.empty() && line[0] != '{')

throw InternalError(nullptr, "Failed to execute '" + pythonExe + " " + args + "'. " + result);

}

// Valid results

return result;

}

static std::string getDefinesFlags(const std::string &semicolonSeparatedString)

{

std::string flags;

for (const std::string &d: split(semicolonSeparatedString, ";"))

flags += "-D" + d + " ";

return flags;

}

CppCheck::CppCheck(ErrorLogger &errorLogger,

bool useGlobalSuppressions,

std::function<bool(std::string,std::vector<std::string>,std::string,std::string*)> executeCommand)

: mErrorLogger(errorLogger)

, mExitCode(0)

, mSuppressInternalErrorFound(false)

, mUseGlobalSuppressions(useGlobalSuppressions)

, mTooManyConfigs(false)

, mSimplify(true)

, mExecuteCommand(executeCommand)

{

}

CppCheck::~CppCheck()

{

while (!mFileInfo.empty()) {

delete mFileInfo.back();

mFileInfo.pop_back();

}

s_timerResults.showResults(mSettings.showtime);

}

const char * CppCheck::version()

{

return Version;

}

const char * CppCheck::extraVersion()

{

return ExtraVersion;

}

static bool reportClangErrors(std::istream &is, std::function<void(const ErrorMessage&)> reportErr)

{

std::string line;

while (std::getline(is, line)) {

if (line.empty() || line[0] == ' ' || line[0] == '`' || line[0] == '-')

continue;

std::string::size_type pos3 = line.find(": error: ");

if (pos3 == std::string::npos)

pos3 = line.find(": fatal error:");

if (pos3 == std::string::npos)

continue;

// file:line:column: error: ....

const std::string::size_type pos2 = line.rfind(":", pos3 - 1);

const std::string::size_type pos1 = line.rfind(":", pos2 - 1);

if (pos1 >= pos2 || pos2 >= pos3)

continue;

const std::string filename = line.substr(0, pos1);

const std::string linenr = line.substr(pos1+1, pos2-pos1-1);

const std::string colnr = line.substr(pos2+1, pos3-pos2-1);

const std::string msg = line.substr(line.find(":", pos3+1) + 2);

std::list<ErrorMessage::FileLocation> locationList;

ErrorMessage::FileLocation loc;

loc.setfile(Path::toNativeSeparators(filename));

loc.line = std::atoi(linenr.c_str());

loc.column = std::atoi(colnr.c_str());

locationList.push_back(loc);

ErrorMessage errmsg(locationList,

loc.getfile(),

Severity::error,

msg,

"syntaxError",

Certainty::normal);

reportErr(errmsg);

return true;

}

return false;

}

unsigned int CppCheck::check(const std::string &path)

{

if (mSettings.clang) {

if (!mSettings.quiet)

mErrorLogger.reportOut(std::string("Checking ") + path + "...");

const std::string lang = Path::isCPP(path) ? "-x c++" : "-x c";

const std::string analyzerInfo = mSettings.buildDir.empty() ? std::string() : AnalyzerInformation::getAnalyzerInfoFile(mSettings.buildDir, path, "");

const std::string clangcmd = analyzerInfo + ".clang-cmd";

const std::string clangStderr = analyzerInfo + ".clang-stderr";

const std::string clangAst = analyzerInfo + ".clang-ast";

std::string exe = mSettings.clangExecutable;

#ifdef _WIN32

// append .exe if it is not a path

if (Path::fromNativeSeparators(mSettings.clangExecutable).find('/') == std::string::npos) {

exe += ".exe";

}

#endif

std::string flags(lang + " ");

if (Path::isCPP(path) && !mSettings.standards.stdValue.empty())

flags += "-std=" + mSettings.standards.stdValue + " ";

for (const std::string &i: mSettings.includePaths)

flags += "-I" + i + " ";

flags += getDefinesFlags(mSettings.userDefines);

const std::string args2 = "-fsyntax-only -Xclang -ast-dump -fno-color-diagnostics " + flags + path;

const std::string redirect2 = analyzerInfo.empty() ? std::string("2>&1") : ("2> " + clangStderr);

if (!mSettings.buildDir.empty()) {

std::ofstream fout(clangcmd);

fout << exe << " " << args2 << " " << redirect2 << std::endl;

} else if (mSettings.verbose && !mSettings.quiet) {

mErrorLogger.reportOut(exe + " " + args2);

}

std::string output2;

if (!mExecuteCommand(exe,split(args2),redirect2,&output2) || output2.find("TranslationUnitDecl") == std::string::npos) {

std::cerr << "Failed to execute '" << exe << " " << args2 << " " << redirect2 << "'" << std::endl;

return 0;

}

// Ensure there are not syntax errors...

if (!mSettings.buildDir.empty()) {

std::ifstream fin(clangStderr);

auto reportError = [this](const ErrorMessage& errorMessage) {

reportErr(errorMessage);

};

if (reportClangErrors(fin, reportError))

return 0;

} else {

std::istringstream istr(output2);

auto reportError = [this](const ErrorMessage& errorMessage) {

reportErr(errorMessage);

};

if (reportClangErrors(istr, reportError))

return 0;

}

if (!mSettings.buildDir.empty()) {

std::ofstream fout(clangAst);

fout << output2 << std::endl;

}

try {

std::istringstream ast(output2);

Tokenizer tokenizer(&mSettings, this);

tokenizer.list.appendFileIfNew(path);

clangimport::parseClangAstDump(&tokenizer, ast);

ValueFlow::setValues(&tokenizer.list, const_cast<SymbolDatabase *>(tokenizer.getSymbolDatabase()), this, &mSettings);

if (mSettings.debugnormal)

tokenizer.printDebugOutput(1);

checkNormalTokens(tokenizer);

// create dumpfile

std::ofstream fdump;

std::string dumpFile;

createDumpFile(mSettings, path, tokenizer.list.getFiles(), nullptr, fdump, dumpFile);

if (fdump.is_open()) {

fdump << "<dump cfg=\"\">" << std::endl;

fdump << " <standards>" << std::endl;

fdump << " <c version=\"" << mSettings.standards.getC() << "\"/>" << std::endl;

fdump << " <cpp version=\"" << mSettings.standards.getCPP() << "\"/>" << std::endl;

fdump << " </standards>" << std::endl;

tokenizer.dump(fdump);

fdump << "</dump>" << std::endl;

fdump << "</dumps>" << std::endl;

fdump.close();

}

// run addons

executeAddons(dumpFile);

} catch (const InternalError &e) {

internalError(path, e.errorMessage);

mExitCode = 1; // e.g. reflect a syntax error

} catch (const std::exception &e) {

internalError(path, e.what());

}

return mExitCode;

}

std::ifstream fin(path);

return checkFile(Path::simplifyPath(path), emptyString, fin);

}

unsigned int CppCheck::check(const std::string &path, const std::string &content)

{

std::istringstream iss(content);

return checkFile(Path::simplifyPath(path), emptyString, iss);

}

unsigned int CppCheck::check(const ImportProject::FileSettings &fs)

{

CppCheck temp(mErrorLogger, mUseGlobalSuppressions, mExecuteCommand);

temp.mSettings = mSettings;

if (!temp.mSettings.userDefines.empty())

temp.mSettings.userDefines += ';';

if (mSettings.clang)

temp.mSettings.userDefines += fs.defines;

else

temp.mSettings.userDefines += fs.cppcheckDefines();

temp.mSettings.includePaths = fs.includePaths;

temp.mSettings.userUndefs.insert(fs.undefs.cbegin(), fs.undefs.cend());

if (fs.standard.find("++") != std::string::npos)

temp.mSettings.standards.setCPP(fs.standard);

else if (!fs.standard.empty())

temp.mSettings.standards.setC(fs.standard);

if (fs.platformType != Settings::Unspecified)

temp.mSettings.platform(fs.platformType);

if (mSettings.clang) {

temp.mSettings.includePaths.insert(temp.mSettings.includePaths.end(), fs.systemIncludePaths.cbegin(), fs.systemIncludePaths.cend());

return temp.check(Path::simplifyPath(fs.filename));

}

std::ifstream fin(fs.filename);

unsigned int returnValue = temp.checkFile(Path::simplifyPath(fs.filename), fs.cfg, fin);

mSettings.nomsg.addSuppressions(temp.mSettings.nomsg.getSuppressions());

return returnValue;

}

unsigned int CppCheck::checkFile(const std::string& filename, const std::string &cfgname, std::istream& fileStream)

{

mExitCode = 0;

mSuppressInternalErrorFound = false;

// only show debug warnings for accepted C/C++ source files

if (!Path::acceptFile(filename))

mSettings.debugwarnings = false;

if (Settings::terminated())

return mExitCode;

if (!mSettings.quiet) {

std::string fixedpath = Path::simplifyPath(filename);

fixedpath = Path::toNativeSeparators(fixedpath);

mErrorLogger.reportOut(std::string("Checking ") + fixedpath + ' ' + cfgname + std::string("..."));

if (mSettings.verbose) {

mErrorLogger.reportOut("Defines:" + mSettings.userDefines);

std::string undefs;

for (const std::string& U : mSettings.userUndefs) {

if (!undefs.empty())

undefs += ';';

undefs += ' ' + U;

}

mErrorLogger.reportOut("Undefines:" + undefs);

std::string includePaths;

for (const std::string &I : mSettings.includePaths)

includePaths += " -I" + I;

mErrorLogger.reportOut("Includes:" + includePaths);

mErrorLogger.reportOut(std::string("Platform:") + mSettings.platformString());

}

}

if (plistFile.is_open()) {

plistFile << ErrorLogger::plistFooter();

plistFile.close();

}

CheckUnusedFunctions checkUnusedFunctions(nullptr, nullptr, nullptr);

try {

Preprocessor preprocessor(mSettings, 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 (const simplecpp::Output &output : outputList) {

bool err;

switch (output.type) {

case simplecpp::Output::ERROR:

case simplecpp::Output::INCLUDE_NESTED_TOO_DEEPLY:

case simplecpp::Output::SYNTAX_ERROR:

case simplecpp::Output::UNHANDLED_CHAR_ERROR:

case simplecpp::Output::EXPLICIT_INCLUDE_NOT_FOUND:

err = true;

break;

case simplecpp::Output::WARNING:

case simplecpp::Output::MISSING_HEADER:

case simplecpp::Output::PORTABILITY_BACKSLASH:

err = false;

break;

}

if (err) {

std::string file = Path::fromNativeSeparators(output.location.file());

if (mSettings.relativePaths)

file = Path::getRelativePath(file, mSettings.basePaths);

const ErrorMessage::FileLocation loc1(file, output.location.line, output.location.col);

std::list<ErrorMessage::FileLocation> callstack(1, loc1);

ErrorMessage errmsg(callstack,

"",

Severity::error,

output.msg,

"syntaxError",

Certainty::normal);

reportErr(errmsg);

return mExitCode;

}

}

if (!preprocessor.loadFiles(tokens1, files))

return mExitCode;

if (!mSettings.plistOutput.empty()) {

std::string filename2;

if (filename.find('/') != std::string::npos)

filename2 = filename.substr(filename.rfind('/') + 1);

else

filename2 = filename;

std::size_t fileNameHash = std::hash<std::string> {}(filename);

filename2 = mSettings.plistOutput + filename2.substr(0, filename2.find('.')) + "_" + std::to_string(fileNameHash) + ".plist";

plistFile.open(filename2);

plistFile << ErrorLogger::plistHeader(version(), files);

}

// write dump file xml prolog

std::ofstream fdump;

std::string dumpFile;

createDumpFile(mSettings, filename, files, tokens1.cfront(), fdump, dumpFile);

// Parse comments and then remove them

preprocessor.inlineSuppressions(tokens1);

if ((mSettings.dump || !mSettings.addons.empty()) && fdump.is_open()) {

mSettings.nomsg.dump(fdump);

}

tokens1.removeComments();

preprocessor.removeComments();

if (!mSettings.buildDir.empty()) {

// Get toolinfo

std::ostringstream toolinfo;

toolinfo << CPPCHECK_VERSION_STRING;

toolinfo << (mSettings.severity.isEnabled(Severity::warning) ? 'w' : ' ');

toolinfo << (mSettings.severity.isEnabled(Severity::style) ? 's' : ' ');

toolinfo << (mSettings.severity.isEnabled(Severity::performance) ? 'p' : ' ');

toolinfo << (mSettings.severity.isEnabled(Severity::portability) ? 'p' : ' ');

toolinfo << (mSettings.severity.isEnabled(Severity::information) ? 'i' : ' ');

toolinfo << mSettings.userDefines;

mSettings.nomsg.dump(toolinfo);

// Calculate checksum so it can be compared with old checksum / future checksums

const unsigned int checksum = preprocessor.calculateChecksum(tokens1, toolinfo.str());

std::list<ErrorMessage> errors;

if (!mAnalyzerInformation.analyzeFile(mSettings.buildDir, filename, cfgname, checksum, &errors)) {

while (!errors.empty()) {

reportErr(errors.front());

errors.pop_front();

}

return mExitCode; // known results => no need to reanalyze file

}

}

// Get directives

preprocessor.setDirectives(tokens1);

preprocessor.simplifyPragmaAsm(&tokens1);

preprocessor.setPlatformInfo(&tokens1);

// Get configurations..

if ((mSettings.checkAllConfigurations && mSettings.userDefines.empty()) || mSettings.force) {

Timer t("Preprocessor::getConfigs", mSettings.showtime, &s_timerResults);

configurations = preprocessor.getConfigs(tokens1);

} else {

configurations.insert(mSettings.userDefines);

}

if (mSettings.checkConfiguration) {

for (const std::string &config : configurations)

(void)preprocessor.getcode(tokens1, config, files, true);

return 0;

}

// Run define rules on raw code

for (const Settings::Rule &rule : mSettings.rules) {

if (rule.tokenlist != "define")

continue;

std::string code;

const std::list<Directive> &directives = preprocessor.getDirectives();

for (const Directive &dir : directives) {

if (dir.str.compare(0,8,"#define ") == 0)

code += "#line " + MathLib::toString(dir.linenr) + " \"" + dir.file + "\"\n" + dir.str + '\n';

}

Tokenizer tokenizer2(&mSettings, this);

std::istringstream istr2(code);

tokenizer2.list.createTokens(istr2);

executeRules("define", tokenizer2);

break;

}

if (!mSettings.force && configurations.size() > mSettings.maxConfigs) {

if (mSettings.severity.isEnabled(Severity::information)) {

tooManyConfigsError(Path::toNativeSeparators(filename),configurations.size());

} else {

mTooManyConfigs = true;

}

}

std::set<unsigned long long> checksums;

int checkCount = 0;

bool hasValidConfig = false;

std::list<std::string> configurationError;

for (const std::string &currCfg : configurations) {

// bail out if terminated

if (Settings::terminated())

break;

// Check only a few configurations (default 12), after that bail out, unless --force

// was used.

if (!mSettings.force && ++checkCount > mSettings.maxConfigs)

break;

if (!mSettings.userDefines.empty()) {

mCurrentConfig = mSettings.userDefines;

const std::vector<std::string> v1(split(mSettings.userDefines, ";"));

for (const std::string &cfg: split(currCfg, ";")) {

if (std::find(v1.begin(), v1.end(), cfg) == v1.end()) {

mCurrentConfig += ";" + cfg;

}

}

} else {

mCurrentConfig = currCfg;

}

if (mSettings.preprocessOnly) {

Timer t("Preprocessor::getcode", mSettings.showtime, &s_timerResults);

std::string codeWithoutCfg = preprocessor.getcode(tokens1, mCurrentConfig, 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(&mSettings, this);

tokenizer.setPreprocessor(&preprocessor);

if (mSettings.showtime != SHOWTIME_MODES::SHOWTIME_NONE)

tokenizer.setTimerResults(&s_timerResults);

try {

// Create tokens, skip rest of iteration if failed

{

Timer timer("Tokenizer::createTokens", mSettings.showtime, &s_timerResults);

simplecpp::TokenList tokensP = preprocessor.preprocess(tokens1, mCurrentConfig, files, true);

tokenizer.createTokens(std::move(tokensP));

}

hasValidConfig = true;

// If only errors are printed, print filename after the check

if (!mSettings.quiet && (!mCurrentConfig.empty() || checkCount > 1)) {

std::string fixedpath = Path::simplifyPath(filename);

fixedpath = Path::toNativeSeparators(fixedpath);

mErrorLogger.reportOut("Checking " + fixedpath + ": " + mCurrentConfig + "...");

}

if (!tokenizer.tokens())

continue;

// skip rest of iteration if just checking configuration

if (mSettings.checkConfiguration)

continue;

// Check raw tokens

checkRawTokens(tokenizer);

// Simplify tokens into normal form, skip rest of iteration if failed

Timer timer2("Tokenizer::simplifyTokens1", mSettings.showtime, &s_timerResults);

bool result = tokenizer.simplifyTokens1(mCurrentConfig);

timer2.stop();

if (!result)

continue;

// dump xml if --dump

if ((mSettings.dump || !mSettings.addons.empty()) && fdump.is_open()) {

fdump << "<dump cfg=\"" << ErrorLogger::toxml(mCurrentConfig) << "\">" << std::endl;

fdump << " <standards>" << std::endl;

fdump << " <c version=\"" << mSettings.standards.getC() << "\"/>" << std::endl;

fdump << " <cpp version=\"" << mSettings.standards.getCPP() << "\"/>" << std::endl;

fdump << " </standards>" << std::endl;

preprocessor.dump(fdump);

tokenizer.dump(fdump);

fdump << "</dump>" << std::endl;

}

// Skip if we already met the same simplified token list

if (mSettings.force || mSettings.maxConfigs > 1) {

const unsigned long long checksum = tokenizer.list.calculateChecksum();

if (checksums.find(checksum) != checksums.end()) {

if (mSettings.debugwarnings)

purgedConfigurationMessage(filename, mCurrentConfig);

continue;

}

checksums.insert(checksum);

}

// Check normal tokens

checkNormalTokens(tokenizer);

// Analyze info..

if (!mSettings.buildDir.empty())

checkUnusedFunctions.parseTokens(tokenizer, filename.c_str(), &mSettings);

// simplify more if required, skip rest of iteration if failed

if (mSimplify && hasRule("simple")) {

std::cout << "Handling of \"simple\" rules is deprecated and will be removed in Cppcheck 2.5." << std::endl;

// if further simplification fails then skip rest of iteration

Timer timer3("Tokenizer::simplifyTokenList2", mSettings.showtime, &s_timerResults);

result = tokenizer.simplifyTokenList2();

timer3.stop();

if (!result)

continue;

if (!Settings::terminated())

executeRules("simple", tokenizer);

}

} catch (const simplecpp::Output &o) {

// #error etc during preprocessing

configurationError.push_back((mCurrentConfig.empty() ? "\'\'" : mCurrentConfig) + " : [" + o.location.file() + ':' + MathLib::toString(o.location.line) + "] " + o.msg);

--checkCount; // don't count invalid configurations

continue;

} catch (const InternalError &e) {

std::list<ErrorMessage::FileLocation> locationList;

if (e.token) {

ErrorMessage::FileLocation loc(e.token, &tokenizer.list);

locationList.push_back(loc);

} else {

ErrorMessage::FileLocation loc(tokenizer.list.getSourceFilePath(), 0, 0);

ErrorMessage::FileLocation loc2(filename, 0, 0);

locationList.push_back(loc2);

locationList.push_back(loc);

}

ErrorMessage errmsg(locationList,

tokenizer.list.getSourceFilePath(),

Severity::error,

e.errorMessage,

e.id,

Certainty::normal);

if (errmsg.severity == Severity::error || mSettings.severity.isEnabled(errmsg.severity))

reportErr(errmsg);

}

}

if (!hasValidConfig && configurations.size() > 1 && mSettings.severity.isEnabled(Severity::information)) {

std::string msg;

msg = "This file is not analyzed. Cppcheck failed to extract a valid configuration. Use -v for more details.";

msg += "\nThis file is not analyzed. Cppcheck failed to extract a valid configuration. The tested configurations have these preprocessor errors:";

for (const std::string &s : configurationError)

msg += '\n' + s;

std::list<ErrorMessage::FileLocation> locationList;

ErrorMessage::FileLocation loc;

loc.setfile(Path::toNativeSeparators(filename));

locationList.push_back(loc);

ErrorMessage errmsg(locationList,

loc.getfile(),

Severity::information,

msg,

"noValidConfiguration",

Certainty::normal);

reportErr(errmsg);

}

// dumped all configs, close root </dumps> element now

if (fdump.is_open()) {

fdump << "</dumps>" << std::endl;

fdump.close();

}

executeAddons(dumpFile);

} 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);

mExitCode=1; // e.g. reflect a syntax error

}

mAnalyzerInformation.setFileInfo("CheckUnusedFunctions", checkUnusedFunctions.analyzerInfo());

mAnalyzerInformation.close();

// In jointSuppressionReport mode, unmatched suppressions are

// collected after all files are processed

if (!mSettings.jointSuppressionReport && (mSettings.severity.isEnabled(Severity::information) || mSettings.checkConfiguration)) {

reportUnmatchedSuppressions(mSettings.nomsg.getUnmatchedLocalSuppressions(filename, isUnusedFunctionCheckEnabled()));

}

mErrorList.clear();

return mExitCode;

}

void CppCheck::internalError(const std::string &filename, const std::string &msg)

{

const std::string fixedpath = Path::toNativeSeparators(filename);

const std::string fullmsg("Bailing out from checking " + fixedpath + " since there was an internal error: " + msg);

if (mSettings.severity.isEnabled(Severity::information)) {

const ErrorMessage::FileLocation loc1(filename, 0, 0);

std::list<ErrorMessage::FileLocation> callstack(1, loc1);

ErrorMessage errmsg(callstack,

emptyString,

Severity::information,

fullmsg,

"internalError",

Certainty::normal);

mErrorLogger.reportErr(errmsg);

} else {

// Report on stdout

mErrorLogger.reportOut(fullmsg);

}

}

//---------------------------------------------------------------------------

// CppCheck - A function that checks a raw token list

//---------------------------------------------------------------------------

void CppCheck::checkRawTokens(const Tokenizer &tokenizer)

{

// Execute rules for "raw" code

executeRules("raw", tokenizer);

}

//---------------------------------------------------------------------------

// CppCheck - A function that checks a normal token list

//---------------------------------------------------------------------------

void CppCheck::checkNormalTokens(const Tokenizer &tokenizer)

{

mSettings.library.bugHunting = mSettings.bugHunting;

if (mSettings.bugHunting)

ExprEngine::runChecks(this, &tokenizer, &mSettings);

else {

// call all "runChecks" in all registered Check classes

for (Check *check : Check::instances()) {

if (Settings::terminated())

return;

if (Tokenizer::isMaxTime())

return;

Timer timerRunChecks(check->name() + "::runChecks", mSettings.showtime, &s_timerResults);

check->runChecks(&tokenizer, &mSettings, this);

}

if (mSettings.clang)

// TODO: Use CTU for Clang analysis

return;

// Analyse the tokens..

CTU::FileInfo *fi1 = CTU::getFileInfo(&tokenizer);

if (fi1) {

mFileInfo.push_back(fi1);

mAnalyzerInformation.setFileInfo("ctu", fi1->toString());

}

for (const Check *check : Check::instances()) {

Check::FileInfo *fi = check->getFileInfo(&tokenizer, &mSettings);

if (fi != nullptr) {

mFileInfo.push_back(fi);

mAnalyzerInformation.setFileInfo(check->name(), fi->toString());

}

}

executeRules("normal", tokenizer);

}

}

//---------------------------------------------------------------------------

bool CppCheck::hasRule(const std::string &tokenlist) const

{

#ifdef HAVE_RULES

for (const Settings::Rule &rule : mSettings.rules) {

if (rule.tokenlist == tokenlist)

return true;

}

#else

(void)tokenlist;

#endif

return false;

}

#ifdef HAVE_RULES

static const char * pcreErrorCodeToString(const int pcreExecRet)

{