/*

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

* Copyright (C) 2007-2023 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 "addoninfo.h"

#include "check.h"

#include "checkunusedfunctions.h"

#include "clangimport.h"

#include "color.h"

#include "ctu.h"

#include "errortypes.h"

#include "filesettings.h"

#include "library.h"

#include "path.h"

#include "platform.h"

#include "preprocessor.h"

#include "standards.h"

#include "suppressions.h"

#include "timer.h"

#include "token.h"

#include "tokenize.h"

#include "tokenlist.h"

#include "utils.h"

#include "valueflow.h"

#include "version.h"

#include <algorithm>

#include <cassert>

#include <cstdio>

#include <cstdint>

#include <cstring>

#include <cctype>

#include <cstdlib>

#include <ctime>

#include <exception>

#include <fstream>

#include <iostream> // <- TEMPORARY

#include <new>

#include <set>

#include <sstream> // IWYU pragma: keep

#include <stdexcept>

#include <string>

#include <unordered_set>

#include <utility>

#include <vector>

#ifndef _WIN32

#include <unistd.h>

#else

#include <process.h>

#endif

#include "json.h"

#include <simplecpp.h>

#include <tinyxml2.h>

#ifdef HAVE_RULES

#ifdef _WIN32

#define PCRE_STATIC

#endif

#include <pcre.h>

#endif

class SymbolDatabase;

static constexpr char Version[] = CPPCHECK_VERSION_STRING;

static constexpr char ExtraVersion[] = "";

static constexpr char FILELIST[] = "cppcheck-addon-ctu-file-list";

static TimerResults s_timerResults;

// CWE ids used

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

// File deleter

namespace {

class FilesDeleter {

public:

FilesDeleter() = default;

~FilesDeleter() {

for (const std::string& fileName: mFilenames)

std::remove(fileName.c_str());

}

void addFile(const std::string& fileName) {

mFilenames.push_back(fileName);

}

private:

std::vector<std::string> mFilenames;

};

}

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 int getPid()

{

#ifndef _WIN32

return getpid();

#else

return _getpid();

#endif

}

static std::string getDumpFileName(const Settings& settings, const std::string& filename)

{

if (!settings.dumpFile.empty())

return settings.dumpFile;

std::string extension;

if (settings.dump)

extension = ".dump";

else

extension = "." + std::to_string(getPid()) + ".dump";

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

return AnalyzerInformation::getAnalyzerInfoFile(settings.buildDir, filename, emptyString) + extension;

return filename + extension;

}

static std::string getCtuInfoFileName(const std::string &dumpFile)

{

return dumpFile.substr(0, dumpFile.size()-4) + "ctu-info";

}

static void createDumpFile(const Settings& settings,

const std::string& filename,

std::ofstream& fdump,

std::string& dumpFile)

{

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

return;

dumpFile = getDumpFileName(settings, filename);

fdump.open(dumpFile);

if (!fdump.is_open())

return;

{

std::ofstream fout(getCtuInfoFileName(dumpFile));

}

std::string language;

switch (settings.enforcedLang) {

case Settings::Language::C:

language = " language=\"c\"";

break;

case Settings::Language::CPP:

language = " language=\"cpp\"";

break;

case Settings::Language::None:

if (Path::isCPP(filename))

language = " language=\"cpp\"";

else if (Path::isC(filename))

language = " language=\"c\"";

break;

}

fdump << "<?xml version=\"1.0\"?>\n";

fdump << "<dumps" << language << ">\n";

fdump << " <platform"

<< " name=\"" << settings.platform.toString() << '\"'

<< " char_bit=\"" << settings.platform.char_bit << '\"'

<< " short_bit=\"" << settings.platform.short_bit << '\"'

<< " int_bit=\"" << settings.platform.int_bit << '\"'

<< " long_bit=\"" << settings.platform.long_bit << '\"'

<< " long_long_bit=\"" << settings.platform.long_long_bit << '\"'

<< " pointer_bit=\"" << (settings.platform.sizeof_pointer * settings.platform.char_bit) << '\"'

<< "/>" << '\n';

}

static std::string detectPython(const CppCheck::ExecuteCmdFn &executeCommand)

{

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

#ifdef _MSC_VER

// FIXME: hack to avoid debug assertion with _popen() in executeCommand() for non-existing commands

const std::string cmd = std::string(py_exe) + " --version >NUL";

if (system(cmd.c_str()) != 0) {

// TODO: get more detailed error?

break;

}

#endif

if (executeCommand(py_exe, split("--version"), "2>&1", out) == EXIT_SUCCESS && startsWith(out, "Python ") && std::isdigit(out[7])) {

return py_exe;

}

}

return "";

}

static std::vector<picojson::value> executeAddon(const AddonInfo &addonInfo,

const std::string &defaultPythonExe,

const std::string &file,

const std::string &premiumArgs,

const CppCheck::ExecuteCmdFn &executeCommand)

{

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

std::string pythonExe;

if (!addonInfo.executable.empty())

pythonExe = addonInfo.executable;

else if (!addonInfo.python.empty())

pythonExe = cmdFileName(addonInfo.python);

else if (!defaultPythonExe.empty())

pythonExe = cmdFileName(defaultPythonExe);

else {

// store in static variable so we only look this up once

static const std::string detectedPythonExe = detectPython(executeCommand);

if (detectedPythonExe.empty())

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

pythonExe = detectedPythonExe;

}

std::string args;

if (addonInfo.executable.empty())

args = cmdFileName(addonInfo.runScript) + " " + cmdFileName(addonInfo.scriptFile);

args += std::string(args.empty() ? "" : " ") + "--cli" + addonInfo.args;

if (!premiumArgs.empty() && !addonInfo.executable.empty())

args += " " + premiumArgs;

const bool is_file_list = (file.find(FILELIST) != std::string::npos);

const std::string fileArg = (is_file_list ? " --file-list " : " ") + cmdFileName(file);

args += fileArg;

std::string result;

if (const int exitcode = executeCommand(pythonExe, split(args), redirect, result)) {

std::string message("Failed to execute addon '" + addonInfo.name + "' - exitcode is " + std::to_string(exitcode));

std::string details = pythonExe + " " + args;

if (result.size() > 2) {

details += "\nOutput:\n";

details += result;

const auto pos = details.find_last_not_of("\n\r");

if (pos != std::string::npos)

details.resize(pos + 1);

}

throw InternalError(nullptr, message, details);

}

std::vector<picojson::value> addonResult;

// Validate output..

std::istringstream istr(result);

std::string line;

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

// TODO: also bail out?

if (line.empty()) {

//std::cout << "addon '" << addonInfo.name << "' result contains empty line" << std::endl;

continue;

}

// TODO: get rid of this

if (startsWith(line,"Checking ")) {

//std::cout << "addon '" << addonInfo.name << "' result contains 'Checking ' line" << std::endl;

continue;

}

if (line[0] != '{') {

//std::cout << "addon '" << addonInfo.name << "' result is not a JSON" << std::endl;

result.erase(result.find_last_not_of('\n') + 1, std::string::npos); // Remove trailing newlines

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

}

//std::cout << "addon '" << addonInfo.name << "' result is " << line << std::endl;

// TODO: make these failures?

picojson::value res;

const std::string err = picojson::parse(res, line);

if (!err.empty()) {

//std::cout << "addon '" << addonInfo.name << "' result is not a valid JSON (" << err << ")" << std::endl;

continue;

}

if (!res.is<picojson::object>()) {

//std::cout << "addon '" << addonInfo.name << "' result is not a JSON object" << std::endl;

continue;

}

addonResult.emplace_back(std::move(res));

}

// Valid results

return addonResult;

}

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,

ExecuteCmdFn executeCommand)

: mErrorLogger(errorLogger)

, mUseGlobalSuppressions(useGlobalSuppressions)

, mExecuteCommand(std::move(executeCommand))

{}

CppCheck::~CppCheck()

{

while (!mFileInfo.empty()) {

delete mFileInfo.back();

mFileInfo.pop_back();

}

if (mPlistFile.is_open()) {

mPlistFile << ErrorLogger::plistFooter();

mPlistFile.close();

}

}

const char * CppCheck::version()

{

return Version;

}

const char * CppCheck::extraVersion()

{

return ExtraVersion;

}

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

{

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)

pos3 = line.find(": warning:");

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

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

ErrorMessage::FileLocation loc;

loc.setfile(locFile);

loc.line = strToInt<int>(linenr);

loc.column = strToInt<unsigned int>(colnr);

ErrorMessage errmsg({std::move(loc)},

locFile,

Severity::error,

msg,

"syntaxError",

Certainty::normal);

if (line.compare(pos3, 10, ": warning:") == 0) {

warnings.push_back(std::move(errmsg));

continue;

}

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 + "...", Color::FgGreen);

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, emptyString);

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) != EXIT_SUCCESS || output2.find("TranslationUnitDecl") == std::string::npos) {

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

return 0;

}

// Ensure there are not syntax errors...

std::vector<ErrorMessage> compilerWarnings;

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

std::ifstream fin(clangStderr);

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

reportErr(errorMessage);

};

if (reportClangErrors(fin, reportError, compilerWarnings))

return 0;

} else {

std::istringstream istr(output2);

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

reportErr(errorMessage);

};

if (reportClangErrors(istr, reportError, compilerWarnings))

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,

&s_timerResults);

if (mSettings.debugnormal)

tokenizer.printDebugOutput(1);

checkNormalTokens(tokenizer);

// create dumpfile

std::ofstream fdump;

std::string dumpFile;

createDumpFile(mSettings, path, fdump, dumpFile);

if (fdump.is_open()) {

fdump << "<dump cfg=\"\">\n";

for (const ErrorMessage& errmsg: compilerWarnings)

fdump << " <clang-warning file=\"" << toxml(errmsg.callStack.front().getfile()) << "\" line=\"" << errmsg.callStack.front().line << "\" column=\"" << errmsg.callStack.front().column << "\" message=\"" << toxml(errmsg.shortMessage()) << "\"/>\n";

fdump << " <standards>\n";

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

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

fdump << " </standards>\n";

tokenizer.dump(fdump);

fdump << "</dump>\n";

fdump << "</dumps>\n";

fdump.close();

}

// run addons

executeAddons(dumpFile, path);

} catch (const InternalError &e) {

const ErrorMessage errmsg = ErrorMessage::fromInternalError(e, nullptr, path, "Bailing out from analysis: Processing Clang AST dump failed");

reportErr(errmsg);

} catch (const TerminateException &) {

// Analysis is terminated

return mExitCode;

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

internalError(path, std::string("Processing Clang AST dump failed: ") + e.what());

}

return mExitCode;

}

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

}

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 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 != Platform::Type::Unspecified)

temp.mSettings.platform.set(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));

}

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

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

return returnValue;

}

static simplecpp::TokenList createTokenList(const std::string& filename, std::vector<std::string>& files, simplecpp::OutputList* outputList, std::istream* fileStream)

{

if (fileStream)

return {*fileStream, files, filename, outputList};

return {filename, files, outputList};

}

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

{

mExitCode = 0;

FilesDeleter filesDeleter;

if (Settings::terminated())

return mExitCode;

const Timer fileTotalTimer(mSettings.showtime == SHOWTIME_MODES::SHOWTIME_FILE_TOTAL, filename);

if (!mSettings.quiet) {

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

fixedpath = Path::toNativeSeparators(fixedpath);

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

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.platform.toString());

}

}

if (mPlistFile.is_open()) {

mPlistFile << ErrorLogger::plistFooter();

mPlistFile.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 = createTokenList(filename, files, &outputList, fileStream);

// If there is a syntax error, report it and stop

const auto output_it = std::find_if(outputList.cbegin(), outputList.cend(), [](const simplecpp::Output &output){

return Preprocessor::hasErrors(output);

});

if (output_it != outputList.cend()) {

const simplecpp::Output &output = *output_it;

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 (mSettings.library.markupFile(filename)) {

Tokenizer tokenizer(&mSettings, this, &preprocessor);

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

checkUnusedFunctions.getFileInfo(&tokenizer, &mSettings);

return EXIT_SUCCESS;

}

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;

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

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

mPlistFile.open(filename2);

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

}

std::string dumpProlog;

if (mSettings.dump || !mSettings.addons.empty()) {

dumpProlog += " <rawtokens>\n";

for (unsigned int i = 0; i < files.size(); ++i) {

dumpProlog += " <file index=\"";

dumpProlog += std::to_string(i);

dumpProlog += "\" name=\"";

dumpProlog += ErrorLogger::toxml(files[i]);

dumpProlog += "\"/>\n";

}

for (const simplecpp::Token *tok = tokens1.cfront(); tok; tok = tok->next) {

dumpProlog += " <tok ";

dumpProlog += "fileIndex=\"";

dumpProlog += std::to_string(tok->location.fileIndex);

dumpProlog += "\" ";

dumpProlog += "linenr=\"";

dumpProlog += std::to_string(tok->location.line);

dumpProlog += "\" ";

dumpProlog +="column=\"";

dumpProlog += std::to_string(tok->location.col);

dumpProlog += "\" ";

dumpProlog += "str=\"";

dumpProlog += ErrorLogger::toxml(tok->str());

dumpProlog += "\"";

dumpProlog += "/>\n";

}

dumpProlog += " </rawtokens>\n";

}

// Parse comments and then remove them

preprocessor.inlineSuppressions(tokens1, mSettings.nomsg);

if (mSettings.dump || !mSettings.addons.empty()) {

std::ostringstream oss;

mSettings.nomsg.dump(oss);

dumpProlog += oss.str();

}

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 hash so it can be compared with old hash / future hashes

const std::size_t hash = preprocessor.calculateHash(tokens1, toolinfo.str());

std::list<ErrorMessage> errors;

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

while (!errors.empty()) {

reportErr(errors.front());

errors.pop_front();

}

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

}

}

// write dump file xml prolog

std::ofstream fdump;

std::string dumpFile;

createDumpFile(mSettings, filename, fdump, dumpFile);

if (fdump.is_open()) {

fdump << dumpProlog;

if (!mSettings.dump)

filesDeleter.addFile(dumpFile);

}

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

}

#ifdef HAVE_RULES

// Run define rules on raw code

const auto rules_it = std::find_if(mSettings.rules.cbegin(), mSettings.rules.cend(), [](const Settings::Rule& rule) {

return rule.tokenlist == "define";

});

if (rules_it != mSettings.rules.cend()) {

std::string code;

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

for (const Directive &dir : directives) {

if (startsWith(dir.str,"#define ") || startsWith(dir.str,"#include "))

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

}

Tokenizer tokenizer2(&mSettings, this);

std::istringstream istr2(code);

tokenizer2.list.createTokens(istr2);

executeRules("define", tokenizer2);

}

#endif

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

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.cbegin(), v1.cend(), cfg) == v1.cend()) {

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 (startsWith(codeWithoutCfg,"#file"))

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, &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;

// locations macros

mLocationMacros.clear();

for (const Token* tok = tokenizer.tokens(); tok; tok = tok->next()) {

if (!tok->getMacroName().empty())

mLocationMacros[Location(files[tok->fileIndex()], tok->linenr())].emplace(tok->getMacroName());

}

// 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 + "...", Color::FgGreen);

}

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

if (!tokenizer.simplifyTokens1(mCurrentConfig))

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;

}

// Need to call this even if the hash will skip this configuration

mSettings.nomsg.markUnmatchedInlineSuppressionsAsChecked(tokenizer);

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

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

const std::size_t hash = tokenizer.list.calculateHash();

if (hashes.find(hash) != hashes.end()) {

if (mSettings.debugwarnings)

purgedConfigurationMessage(filename, mCurrentConfig);

continue;

}

hashes.insert(hash);

}

// Check normal tokens

checkNormalTokens(tokenizer);

// Analyze info..

if (!mSettings.buildDir.empty())

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

#ifdef HAVE_RULES

// handling of "simple" rules has been removed.

if (hasRule("simple"))

throw InternalError(nullptr, "Handling of \"simple\" rules has been removed in Cppcheck. Use --addon instead.");

#endif

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

// #error etc during preprocessing

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

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

if (!hasValidConfig && currCfg == *configurations.rbegin()) {

// If there is no valid configuration then report error..

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

if (mSettings.relativePaths)

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

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

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

ErrorMessage errmsg(callstack,

filename,

Severity::error,

o.msg,

"preprocessorErrorDirective",

Certainty::normal);

reportErr(errmsg);

}

continue;

} catch (const TerminateException &) {

// Analysis is terminated

return mExitCode;

} catch (const InternalError &e) {

ErrorMessage errmsg = ErrorMessage::fromInternalError(e, &tokenizer.list, filename);

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;

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

ErrorMessage::FileLocation loc;

loc.setfile(locFile);

ErrorMessage errmsg({std::move(loc)},

locFile,

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, Path::simplifyPath(filename));

} catch (const TerminateException &) {

// Analysis is terminated

return mExitCode;

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

internalError(filename, std::string("Checking file failed: ") + e.what());

} catch (const std::bad_alloc &) {

internalError(filename, "Checking file failed: out of memory");

} catch (const InternalError &e) {

const ErrorMessage errmsg = ErrorMessage::fromInternalError(e, nullptr, filename, "Bailing out from analysis: Checking file failed");

reportErr(errmsg);

}