/*

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

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

#include "check.h"

#include "checks.h"

#include "checkunusedfunctions.h"

#include "clangimport.h"

#include "color.h"

#include "ctu.h"

#include "errorlogger.h"

#include "errortypes.h"

#include "filesettings.h"

#include "library.h"

#include "path.h"

#include "platform.h"

#include "preprocessor.h"

#include "settings.h"

#include "standards.h"

#include "suppressions.h"

#include "symboldatabase.h"

#include "timer.h"

#include "token.h"

#include "tokenize.h"

#include "tokenlist.h"

#include "utils.h"

#include "valueflow.h"

#include "version.h"

#ifdef HAVE_RULES

#include "regex.h"

#include "rule.h"

#endif

#include <algorithm>

#include <cassert>

#include <cstdio>

#include <cstdint>

#include <cstring>

#include <cctype>

#include <cstdlib>

#include <ctime>

#include <exception> // IWYU pragma: keep

#include <fstream>

#include <iostream>

#include <iterator>

#include <map>

#include <new>

#include <set>

#include <sstream>

#include <stdexcept>

#include <string>

#include <unordered_set>

#include <utility>

#include <vector>

#include "json.h"

#include <simplecpp.h>

namespace tinyxml2 { class XMLElement; }

static constexpr char Version[] = CPPCHECK_VERSION_STRING;

static constexpr char ExtraVersion[] = "";

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

// CWE ids used

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

class CppCheck::CppCheckLogger : public ErrorLogger

{

public:

CppCheckLogger(ErrorLogger& errorLogger, const Settings& settings, Suppressions& suppressions, bool useGlobalSuppressions)

: mErrorLogger(errorLogger)

, mSettings(settings)

, mSuppressions(suppressions)

, mUseGlobalSuppressions(useGlobalSuppressions)

{}

~CppCheckLogger() override

{

closePlist();

}

void addRemarkComments(const std::vector<RemarkComment> &remarkComments)

{

mRemarkComments.insert(mRemarkComments.end(), remarkComments.begin(), remarkComments.end());

}

void setLocationMacros(const Token* startTok, const std::vector<std::string>& files)

{

mLocationMacros.clear();

for (const Token* tok = startTok; tok; tok = tok->next()) {

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

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

}

}

void resetExitCode()

{

mExitCode = 0;

}

void clear()

{

mErrorList.clear();

}

void openPlist(const std::string& filename)

{

mPlistFile.open(filename);

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

}

void setPlistFilenames(std::vector<std::string> files)

{

if (mPlistFile.is_open()) {

mPlistFilenames = std::move(files);

}

}

void closePlist()

{

if (mPlistFile.is_open()) {

mPlistFile << ErrorLogger::plistFooter(mPlistFilenames);

mPlistFile.close();

mPlistFilenames.clear();

}

}

unsigned int exitcode() const

{

return mExitCode;

}

void setAnalyzerInfo(AnalyzerInformation* info)

{

mAnalyzerInformation = info;

}

private:

/**

* @brief Errors and warnings are directed here.

*

* @param msg Errors messages are normally in format

* "[filepath:line number] Message", e.g.

* "[main.cpp:4] Uninitialized member variable"

*/

// TODO: part of this logic is duplicated in Executor::hasToLog()

void reportErr(const ErrorMessage &msg) override

{

if (msg.severity == Severity::internal) {

mErrorLogger.reportErr(msg);

return;

}

if (!mSettings.library.reportErrors(msg.file0))

return;

std::set<std::string> macroNames;

if (!msg.callStack.empty()) {

const std::string &file = msg.callStack.back().getfile(false);

int lineNumber = msg.callStack.back().line;

const auto it = mLocationMacros.find(Location(file, lineNumber));

if (it != mLocationMacros.cend())

macroNames = it->second;

}

// TODO: only convert if necessary

const auto errorMessage = SuppressionList::ErrorMessage::fromErrorMessage(msg, macroNames);

bool suppressed = false;

if (mSuppressions.nomsg.isSuppressed(errorMessage, mUseGlobalSuppressions)) {

// Safety: Report critical errors to ErrorLogger

if (mSettings.safety && ErrorLogger::isCriticalErrorId(msg.id)) {

mExitCode = 1;

if (mSuppressions.nomsg.isSuppressedExplicitly(errorMessage, mUseGlobalSuppressions)) {

// Report with internal severity to signal that there is this critical error but

// it is suppressed

ErrorMessage temp(msg);

temp.severity = Severity::internal;

mErrorLogger.reportErr(temp);

} else {

// Report critical error that is not explicitly suppressed

mErrorLogger.reportErr(msg);

}

}

suppressed = true;

}

// TODO: there should be no need for the verbose and default messages here

std::string errmsg = msg.toString(mSettings.verbose, mSettings.templateFormat, mSettings.templateLocation);

if (errmsg.empty())

return;

// Alert only about unique errors.

// This makes sure the errors of a single check() call are unique.

// TODO: get rid of this? This is forwarded to another ErrorLogger which is also doing this

if (!mSettings.emitDuplicates && !mErrorList.emplace(std::move(errmsg)).second)

return;

if (mAnalyzerInformation)

mAnalyzerInformation->reportErr(msg);

if (suppressed)

return;

if (!mSuppressions.nofail.isSuppressed(errorMessage) && !mSuppressions.nomsg.isSuppressed(errorMessage)) {

mExitCode = 1;

}

std::string remark;

if (!msg.callStack.empty()) {

for (const auto& r: mRemarkComments) {

if (r.file != msg.callStack.back().getfile(false))

continue;

if (r.lineNumber != msg.callStack.back().line)

continue;

remark = r.str;

break;

}

}

if (!remark.empty()) {

ErrorMessage msg2(msg);

msg2.remark = std::move(remark);

mErrorLogger.reportErr(msg2);

} else {

mErrorLogger.reportErr(msg);

}

// check if plistOutput should be populated and the current output file is open and the error is not suppressed

if (!mSettings.plistOutput.empty() && mPlistFile.is_open() && !mSuppressions.nomsg.isSuppressed(errorMessage)) {

// add error to plist output file

mPlistFile << ErrorLogger::plistData(msg);

}

}

/**

* @brief Information about progress is directed here.

*

* @param outmsg Message to show, e.g. "Checking main.cpp..."

*/

void reportOut(const std::string &outmsg, Color c = Color::Reset) override

{

mErrorLogger.reportOut(outmsg, c);

}

void reportMetric(const std::string &metric) override

{

mErrorLogger.reportMetric(metric);

}

void reportProgress(const std::string &filename, const char stage[], const std::size_t value) override

{

mErrorLogger.reportProgress(filename, stage, value);

}

ErrorLogger &mErrorLogger;

const Settings& mSettings;

Suppressions& mSuppressions;

bool mUseGlobalSuppressions;

// TODO: store hashes instead of the full messages

std::unordered_set<std::string> mErrorList;

std::vector<RemarkComment> mRemarkComments;

using Location = std::pair<std::string, int>;

std::map<Location, std::set<std::string>> mLocationMacros; // What macros are used on a location?

std::ofstream mPlistFile;

std::vector<std::string> mPlistFilenames;

unsigned int mExitCode{};

AnalyzerInformation* mAnalyzerInformation{};

};

// 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(std::move(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 std::string getDumpFileName(const Settings& settings, const FileWithDetails& file)

{

std::string extension = ".dump";

if (file.fsFileId() > 0)

extension = "." + std::to_string(file.fsFileId()) + extension;

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

extension = "." + std::to_string(settings.pid) + extension;

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

return AnalyzerInformation::getAnalyzerInfoFile(settings.buildDir, file.spath(), "", file.fsFileId()) + extension;

return file.spath() + 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 FileWithDetails& file,

std::ofstream& fdump,

std::string& dumpFile)

{

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

return;

dumpFile = getDumpFileName(settings, file);

fdump.open(dumpFile);

if (!fdump.is_open())

return;

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

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

}

std::string language;

assert(file.lang() != Standards::Language::None);

switch (file.lang()) {

case Standards::Language::C:

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

break;

case Standards::Language::CPP:

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

break;

case Standards::Language::None:

break;

}

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

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

fdump << " <platform"

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

<< " char_bit=\"" << static_cast<unsigned>(settings.platform.char_bit) << '\"'

<< " short_bit=\"" << static_cast<unsigned>(settings.platform.short_bit) << '\"'

<< " int_bit=\"" << static_cast<unsigned>(settings.platform.int_bit) << '\"'

<< " long_bit=\"" << static_cast<unsigned>(settings.platform.long_bit) << '\"'

<< " long_long_bit=\"" << static_cast<unsigned>(settings.platform.long_long_bit) << '\"'

<< " float_bit=\"" << static_cast<unsigned>(settings.platform.float_bit) << '\"'

<< " double_bit=\"" << static_cast<unsigned>(settings.platform.double_bit) << '\"'

<< " long_double_bit=\"" << static_cast<unsigned>(settings.platform.long_double_bit) << '\"'

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

<< " wchar_t_bit=\"" << (settings.platform.sizeof_wchar_t * settings.platform.char_bit) << '\"'

<< " size_t_bit=\"" << (settings.platform.sizeof_size_t * 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 2>&1";

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

// TODO: get more detailed error?

continue;

}

#endif

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

return py_exe;

}

}

return "";

}

/**

* @throws InternalError thrown when execution fails

*/

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)

{

if (!executeCommand)

throw InternalError(nullptr, "Failed to execute addon - no command callback provided");

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 - TODO: do not cache globally

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), "2>&1", 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, std::move(message), std::move(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(const Settings& settings,

Suppressions& supprs,

ErrorLogger &errorLogger,

TimerResults *timerResults,

bool useGlobalSuppressions,

ExecuteCmdFn executeCommand)

: mSettings(settings)

, mSuppressions(supprs)

, mLogger(new CppCheckLogger(errorLogger, mSettings, mSuppressions, useGlobalSuppressions))

, mErrorLogger(*mLogger)

, mErrorLoggerDirect(errorLogger)

, mTimerResults(timerResults)

, mUseGlobalSuppressions(useGlobalSuppressions)

, mExecuteCommand(std::move(executeCommand))

{}

CppCheck::~CppCheck()

{

mLogger->setAnalyzerInfo(nullptr);

while (!mFileInfo.empty()) {

delete mFileInfo.back();

mFileInfo.pop_back();

}

}

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;

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::string locFile = Path::toNativeSeparators(std::move(filename));

const int line_i = strToInt<int>(linenr);

const int column = strToInt<unsigned int>(colnr);

ErrorMessage::FileLocation loc(locFile, line_i, column);

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

std::move(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;

}

std::string CppCheck::getLibraryDumpData() const {

std::string out;

for (const std::string &s : mSettings.libraries) {

out += " <library lib=\"" + s + "\"/>\n";

}

return out;

}

/**

* @brief Get the clang command line flags using the Settings

* @param lang language guessed from filename

* @return Clang command line flags

*/

static std::string getClangFlags(const Settings& setting, Standards::Language lang) {

std::string flags;

assert(lang != Standards::Language::None);

switch (lang) {

case Standards::Language::C:

flags = "-x c ";

if (!setting.standards.stdValueC.empty())

flags += "-std=" + setting.standards.stdValueC + " ";

break;

case Standards::Language::CPP:

flags += "-x c++ ";

if (!setting.standards.stdValueCPP.empty())

flags += "-std=" + setting.standards.stdValueCPP + " ";

break;

case Standards::Language::None:

break;

}

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

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

flags += getDefinesFlags(setting.userDefines);

for (const std::string &i: setting.userIncludes)

flags += "--include " + cmdFileName(i) + " ";

return flags;

}

// TODO: clear error list before returning

unsigned int CppCheck::checkClang(const FileWithDetails &file)

{

// TODO: clear exitcode

if (mSettings.checks.isEnabled(Checks::unusedFunction) && !mUnusedFunctionsCheck)

mUnusedFunctionsCheck.reset(new CheckUnusedFunctions());

if (!mSettings.quiet)

mErrorLogger.reportOut(std::string("Checking ") + file.spath() + " ...", Color::FgGreen);

// TODO: get language from FileWithDetails object

std::string clangStderr;

if (!mSettings.buildDir.empty())

clangStderr = AnalyzerInformation::getAnalyzerInfoFile(mSettings.buildDir, file.spath(), "", file.fsFileId()) + ".clang-stderr";

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

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

getClangFlags(mSettings, file.lang()) +

file.spath();

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

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

mErrorLogger.reportOut(exe + " " + args2, Color::Reset);

}

if (!mExecuteCommand) {

std::cerr << "Failed to execute '" << exe << " " << args2 << " " << redirect2 << "' - (no command callback provided)" << std::endl;

return 0; // TODO: report as failure?

}

std::string output2;

const int exitcode = mExecuteCommand(exe,split(args2),redirect2,output2);

if (mSettings.debugClangOutput) {

std::cout << output2 << std::endl;

}

// TODO: this might also fail if compiler errors are encountered - we should report them properly

if (exitcode != EXIT_SUCCESS) {

// TODO: report as proper error

std::cerr << "Failed to execute '" << exe << " " << args2 << " " << redirect2 << "' - (exitcode: " << exitcode << " / output: " << output2 << ")" << std::endl;

return 0; // TODO: report as failure?

}

if (output2.find("TranslationUnitDecl") == std::string::npos) {

// TODO: report as proper error

std::cerr << "Failed to execute '" << exe << " " << args2 << " " << redirect2 << "' - (no TranslationUnitDecl in output)" << std::endl;

return 0; // TODO: report as failure?

}

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

mErrorLogger.reportErr(errorMessage);

};

// Ensure there are not syntax errors...

std::vector<ErrorMessage> compilerWarnings;

if (!clangStderr.empty()) {

std::ifstream fin(clangStderr);

if (reportClangErrors(fin, reportError, compilerWarnings))

return 0; // TODO: report as failure?

} else {

std::istringstream istr(output2);

if (reportClangErrors(istr, reportError, compilerWarnings))

return 0; // TODO: report as failure?

}

try {

TokenList tokenlist{mSettings, file.lang()};

tokenlist.appendFileIfNew(file.spath());

Tokenizer tokenizer(std::move(tokenlist), mErrorLogger);

std::istringstream ast(output2);

clangimport::parseClangAstDump(tokenizer, ast);

ValueFlow::setValues(tokenizer.list,

const_cast<SymbolDatabase&>(*tokenizer.getSymbolDatabase()),

mErrorLogger,

mSettings,

mTimerResults);

tokenizer.printDebugOutput(std::cout);

checkNormalTokens(tokenizer, nullptr, ""); // TODO: provide analyzer information

// create dumpfile

std::ofstream fdump;

std::string dumpFile;

createDumpFile(mSettings, file, fdump, dumpFile);

if (fdump.is_open()) {

fdump << getLibraryDumpData();

// TODO: use tinyxml2 to create XML

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

for (const ErrorMessage& errmsg: compilerWarnings)

fdump << " <clang-warning file=\"" << ErrorLogger::toxml(errmsg.callStack.front().getfile()) << "\" line=\"" << errmsg.callStack.front().line << "\" column=\"" << errmsg.callStack.front().column << "\" message=\"" << ErrorLogger::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, file);

} catch (const InternalError &e) {

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

mErrorLogger.reportErr(errmsg);

} catch (const TerminateException &) {

// Analysis is terminated

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

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

}

return mLogger->exitcode();

}

unsigned int CppCheck::check(const FileWithDetails &file)

{

// TODO: handle differently?

// dummy call to make sure wildcards are being flagged as checked in case isSuppressed() is never called

{

// the empty ID is intentional for now - although it should not be allowed

ErrorMessage msg({}, file.spath(), Severity::information, "", "", Certainty::normal);

(void)mSuppressions.nomsg.isSuppressed(SuppressionList::ErrorMessage::fromErrorMessage(msg, {}), true);

}

unsigned int returnValue;

if (mSettings.clang)

returnValue = checkClang(file);

else

returnValue = checkFile(file, "");

// TODO: call analyseClangTidy()

return returnValue;

}

unsigned int CppCheck::checkBuffer(const FileWithDetails &file, const char* data, std::size_t size)

{

return checkBuffer(file, "", data, size);

}

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

{

// TODO: move to constructor when CppCheck no longer owns the settings

if (mSettings.checks.isEnabled(Checks::unusedFunction) && !mUnusedFunctionsCheck)

mUnusedFunctionsCheck.reset(new CheckUnusedFunctions());

Settings tempSettings = mSettings; // this is a copy

if (!tempSettings.userDefines.empty())

tempSettings.userDefines += ';';

if (mSettings.clang)

tempSettings.userDefines += fs.defines;

else

tempSettings.userDefines += fs.cppcheckDefines();

tempSettings.includePaths = fs.includePaths;

tempSettings.userIncludes.insert(tempSettings.userIncludes.end(), fs.forcedIncludes.cbegin(), fs.forcedIncludes.cend());

tempSettings.userUndefs.insert(fs.undefs.cbegin(), fs.undefs.cend());

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

tempSettings.standards.setCPP(fs.standard);

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

tempSettings.standards.setC(fs.standard);

if (fs.platformType != Platform::Type::Unspecified)

tempSettings.platform.set(fs.platformType);

if (mSettings.clang) {

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

// need to pass the externally provided ErrorLogger instead of our internal wrapper

CppCheck temp(tempSettings, mSuppressions, mErrorLoggerDirect, mTimerResults, mUseGlobalSuppressions, mExecuteCommand);

// TODO: propagate back mFileInfo

const unsigned int returnValue = temp.check(fs.file);

if (mUnusedFunctionsCheck)

mUnusedFunctionsCheck->updateFunctionData(*temp.mUnusedFunctionsCheck);

return returnValue;

}

// need to pass the externally provided ErrorLogger instead of our internal wrapper

CppCheck temp(tempSettings, mSuppressions, mErrorLoggerDirect, mTimerResults, mUseGlobalSuppressions, mExecuteCommand);

const unsigned int returnValue = temp.checkFile(fs.file, fs.cfg);

if (mUnusedFunctionsCheck)

mUnusedFunctionsCheck->updateFunctionData(*temp.mUnusedFunctionsCheck);

while (!temp.mFileInfo.empty()) {

mFileInfo.push_back(temp.mFileInfo.back());

temp.mFileInfo.pop_back();

}

// TODO: propagate back more data?

if (mSettings.clangTidy)

analyseClangTidy(fs); // TODO: returnValue

return returnValue;

}

std::size_t CppCheck::calculateHash(const Preprocessor& preprocessor, const std::string& filePath) const

{

std::ostringstream toolinfo;

toolinfo << (mSettings.cppcheckCfgProductName.empty() ? CPPCHECK_VERSION_STRING : mSettings.cppcheckCfgProductName);

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;

toolinfo << (mSettings.checkConfiguration ? 'c' : ' '); // --check-config

toolinfo << (mSettings.force ? 'f' : ' ');

toolinfo << mSettings.maxConfigsOption;

toolinfo << std::to_string(static_cast<std::uint8_t>(mSettings.checkLevel));

for (const auto &a : mSettings.addonInfos) {

toolinfo << a.name;

toolinfo << a.args;

}

toolinfo << mSettings.premiumArgs;

// TODO: do we need to add more options?

mSuppressions.nomsg.dump(toolinfo, filePath);

return preprocessor.calculateHash(toolinfo.str());

}

unsigned int CppCheck::checkBuffer(const FileWithDetails &file, const std::string &cfgname, const char* data, std::size_t size)

{

const auto f = [&file, data, size](std::vector<std::string>& files, simplecpp::OutputList* outputList) {

return simplecpp::TokenList{{data, size}, files, file.spath(), outputList};

};

return checkInternal(file, cfgname, f);

}

unsigned int CppCheck::checkFile(const FileWithDetails& file, const std::string &cfgname)

{

const auto f = [&file](std::vector<std::string>& files, simplecpp::OutputList* outputList) {

return simplecpp::TokenList{file.spath(), files, outputList};

};

return checkInternal(file, cfgname, f);

}

void CppCheck::checkPlistOutput(const FileWithDetails& file)

{

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

const bool slashFound = file.spath().find('/') != std::string::npos;

std::string filename = slashFound ? file.spath().substr(file.spath().rfind('/') + 1) : file.spath();

// removes suffix from filename when it exists

const std::string noSuffixFilename = filename.substr(0, filename.find('.'));

// the hash is added to handle when files in different folders have the same name

const std::size_t fileNameHash = std::hash<std::string> {}(file.spath());

filename = mSettings.plistOutput + noSuffixFilename + "_" + std::to_string(fileNameHash) + ".plist";

mLogger->openPlist(filename);

}

}

unsigned int CppCheck::checkInternal(const FileWithDetails& file, const std::string &cfgname, const CreateTokenListFn& createTokenList)

{

// TODO: move to constructor when CppCheck no longer owns the settings

if (mSettings.checks.isEnabled(Checks::unusedFunction) && !mUnusedFunctionsCheck)

mUnusedFunctionsCheck.reset(new CheckUnusedFunctions());

const int maxConfigs = mSettings.getMaxConfigs();

mLogger->resetExitCode();

if (Settings::terminated())

return mLogger->exitcode();

std::unique_ptr<OneShotTimer> checkTimeTimer;

if (mSettings.showtime == Settings::ShowTime::FILE || mSettings.showtime == Settings::ShowTime::FILE_TOTAL || mSettings.showtime == Settings::ShowTime::TOP5_FILE)

checkTimeTimer.reset(new OneShotTimer("Check time: " + file.spath()));

if (!mSettings.quiet) {

std::string fixedpath = Path::toNativeSeparators(file.spath());

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

if (mSettings.verbose) {

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

std::string undefs;

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

if (!undefs.empty())

undefs += ';';

undefs += ' ' + U;

}

mErrorLogger.reportOut("Undefines:" + undefs, Color::Reset);

std::string includePaths;

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

includePaths += " -I" + I;

mErrorLogger.reportOut("Includes:" + includePaths, Color::Reset);

mErrorLogger.reportOut(std::string("Platform:") + mSettings.platform.toString(), Color::Reset);

}

}

mLogger->closePlist();

std::unique_ptr<AnalyzerInformation> analyzerInformation;

try {

if (mSettings.library.markupFile(file.spath())) {

// TODO: if an exception occurs in this block it will continue in an unexpected code path

if (!mSettings.buildDir.empty())

{

analyzerInformation.reset(new AnalyzerInformation);

mLogger->setAnalyzerInfo(analyzerInformation.get());

}

if (mUnusedFunctionsCheck && (mSettings.useSingleJob() || analyzerInformation)) {

std::size_t hash = 0;

// markup files are special and do not adhere to the enforced language

TokenList tokenlist{mSettings, Standards::Language::C};

std::vector<std::string> files;

simplecpp::TokenList tokens = createTokenList(files, nullptr);

if (analyzerInformation) {

const Preprocessor preprocessor(tokens, mSettings, mErrorLogger, file.lang());

hash = calculateHash(preprocessor);

}

tokenlist.createTokens(std::move(tokens));

// this is not a real source file - we just want to tokenize it. treat it as C anyways as the language needs to be determined.

Tokenizer tokenizer(std::move(tokenlist), mErrorLogger);

mUnusedFunctionsCheck->parseTokens(tokenizer, mSettings.library);

if (analyzerInformation) {

mLogger->setAnalyzerInfo(nullptr);

std::list<ErrorMessage> errors;

analyzerInformation->analyzeFile(mSettings.buildDir, file.spath(), cfgname, file.fsFileId(), hash, errors, mSettings.debugainfo);

analyzerInformation->setFileInfo("CheckUnusedFunctions", mUnusedFunctionsCheck->analyzerInfo(tokenizer));

analyzerInformation->close();

}

}