: mErrorLogger(errorLogger)

, mSettings(settings)

, mSuppressions(suppressions)

, mUseGlobalSuppressions(useGlobalSuppressions)

{

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

}

{

mPlistFile.open(filename);

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

{

if (mPlistFile.is_open()) {

mPlistFile << ErrorLogger::plistFooter();

mPlistFile.close();

}

{

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

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

}

}

return;

}

// 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 (!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);

}

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;

{

f = Path::toNativeSeparators(std::move(f));

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

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

return f;

{

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;

{

std::string extension = ".dump";

if (fileIndex > 0)

extension = "." + std::to_string(fileIndex) + 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, filename, "", fileIndex) + extension;

return filename + extension;

const FileWithDetails& file,

int fileIndex,

std::ofstream& fdump,

std::string& dumpFile)

{

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

return;

dumpFile = getDumpFileName(settings, file.spath(), fileIndex);

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

{

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

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;

{

std::string flags;

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

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

return flags;

Suppressions& supprs,

ErrorLogger &errorLogger,

bool useGlobalSuppressions,

ExecuteCmdFn executeCommand)

: mSettings(settings)

, mSuppressions(supprs)

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

, mErrorLogger(*mLogger)

, mErrorLoggerDirect(errorLogger)

, mUseGlobalSuppressions(useGlobalSuppressions)

, mExecuteCommand(std::move(executeCommand))

{

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

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

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

}

return out;

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 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(), "", fileIndex) + ".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,

&s_timerResults);

tokenizer.printDebugOutput(std::cout);

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

// create dumpfile

std::ofstream fdump;

std::string dumpFile;

createDumpFile(mSettings, file, fileIndex, 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();

{

// 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, 0);

else

returnValue = checkFile(file, "", 0);

// TODO: call analyseClangTidy()

return returnValue;

{

// 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.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, 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, mUseGlobalSuppressions, mExecuteCommand);

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

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::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 << 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(tokens, toolinfo.str());

{

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, fileIndex, f);

{

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

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

};

return checkInternal(file, cfgname, fileIndex, f);

{

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

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

mUnusedFunctionsCheck.reset(new CheckUnusedFunctions());

mLogger->resetExitCode();

if (Settings::terminated())

return mLogger->exitcode();

const Timer fileTotalTimer(mSettings.showtime == SHOWTIME_MODES::SHOWTIME_FILE_TOTAL, 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(mSettings, mErrorLogger, file.lang());

hash = calculateHash(preprocessor, tokens);

}

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

if (analyzerInformation) {

mLogger->setAnalyzerInfo(nullptr);

std::list<ErrorMessage> errors;

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

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

analyzerInformation->close();

}

}

return EXIT_SUCCESS;

}

simplecpp::OutputList outputList;

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

simplecpp::TokenList tokens1 = createTokenList(files, &outputList);

// 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 locfile = Path::fromNativeSeparators(output.location.file());

if (mSettings.relativePaths)

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

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

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

"", // TODO: is this correct?

Severity::error,

output.msg,

"syntaxError",

Certainty::normal);

mErrorLogger.reportErr(errmsg);

return mLogger->exitcode();

}

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

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

return mLogger->exitcode();

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

std::string filename2;

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

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

else

filename2 = file.spath();

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

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

mLogger->openPlist(filename2, files);