{

const QString dataDir = settings->value("DATADIR", QString()).toString();

const QString appPath = QFileInfo(QCoreApplication::applicationFilePath()).canonicalPath();

return dataDir.isEmpty() ? appPath : dataDir;

mSettings(settings),

mApplications(new ApplicationList(this)),

mTranslation(th),

mScratchPad(nullptr),

mProjectFile(nullptr),

mPlatformActions(new QActionGroup(this)),

mCStandardActions(new QActionGroup(this)),

mCppStandardActions(new QActionGroup(this)),

mSelectLanguageActions(new QActionGroup(this)),

mExiting(false),

mIsLogfileLoaded(false)

{

mUI.setupUi(this);

mThread = new ThreadHandler(this);

mThread->setDataDir(getDataDir(settings));

mUI.mResults->initialize(mSettings, mApplications, mThread);

// Filter timer to delay filtering results slightly while typing

mFilterTimer = new QTimer(this);

mFilterTimer->setInterval(500);

mFilterTimer->setSingleShot(true);

connect(mFilterTimer, &QTimer::timeout, this, &MainWindow::filterResults);

// "Filter" toolbar

mLineEditFilter = new QLineEdit(mUI.mToolBarFilter);

mLineEditFilter->setPlaceholderText(tr("Quick Filter:"));

mLineEditFilter->setClearButtonEnabled(true);

mUI.mToolBarFilter->addWidget(mLineEditFilter);

connect(mLineEditFilter, SIGNAL(textChanged(const QString&)), mFilterTimer, SLOT(start()));

connect(mLineEditFilter, &QLineEdit::returnPressed, this, &MainWindow::filterResults);

connect(mUI.mActionPrint, SIGNAL(triggered()), mUI.mResults, SLOT(print()));

connect(mUI.mActionPrintPreview, SIGNAL(triggered()), mUI.mResults, SLOT(printPreview()));

connect(mUI.mActionQuit, &QAction::triggered, this, &MainWindow::close);

connect(mUI.mActionAnalyzeFiles, &QAction::triggered, this, &MainWindow::analyzeFiles);

connect(mUI.mActionAnalyzeDirectory, &QAction::triggered, this, &MainWindow::analyzeDirectory);

connect(mUI.mActionSettings, &QAction::triggered, this, &MainWindow::programSettings);

connect(mUI.mActionClearResults, &QAction::triggered, this, &MainWindow::clearResults);

connect(mUI.mActionOpenXML, &QAction::triggered, this, &MainWindow::openResults);

connect(mUI.mActionShowStyle, &QAction::toggled, this, &MainWindow::showStyle);

connect(mUI.mActionShowErrors, &QAction::toggled, this, &MainWindow::showErrors);

connect(mUI.mActionShowWarnings, &QAction::toggled, this, &MainWindow::showWarnings);

connect(mUI.mActionShowPortability, &QAction::toggled, this, &MainWindow::showPortability);

connect(mUI.mActionShowPerformance, &QAction::toggled, this, &MainWindow::showPerformance);

connect(mUI.mActionShowInformation, &QAction::toggled, this, &MainWindow::showInformation);

connect(mUI.mActionShowCppcheck, &QAction::toggled, mUI.mResults, &ResultsView::showCppcheckResults);

connect(mUI.mActionShowClang, &QAction::toggled, mUI.mResults, &ResultsView::showClangResults);

connect(mUI.mActionCheckAll, &QAction::triggered, this, &MainWindow::checkAll);

connect(mUI.mActionUncheckAll, &QAction::triggered, this, &MainWindow::uncheckAll);

connect(mUI.mActionCollapseAll, &QAction::triggered, mUI.mResults, &ResultsView::collapseAllResults);

connect(mUI.mActionExpandAll, &QAction::triggered, mUI.mResults, &ResultsView::expandAllResults);

connect(mUI.mActionShowHidden, &QAction::triggered, mUI.mResults, &ResultsView::showHiddenResults);

connect(mUI.mActionViewStats, &QAction::triggered, this, &MainWindow::showStatistics);

connect(mUI.mActionLibraryEditor, &QAction::triggered, this, &MainWindow::showLibraryEditor);

connect(mUI.mActionReanalyzeModified, &QAction::triggered, this, &MainWindow::reAnalyzeModified);

connect(mUI.mActionReanalyzeAll, &QAction::triggered, this, &MainWindow::reAnalyzeAll);

connect(mUI.mActionCheckLibrary, &QAction::triggered, this, &MainWindow::checkLibrary);

connect(mUI.mActionCheckConfiguration, &QAction::triggered, this, &MainWindow::checkConfiguration);

connect(mUI.mActionStop, &QAction::triggered, this, &MainWindow::stopAnalysis);

connect(mUI.mActionSave, &QAction::triggered, this, &MainWindow::save);

// About menu

connect(mUI.mActionAbout, &QAction::triggered, this, &MainWindow::about);

connect(mUI.mActionLicense, &QAction::triggered, this, &MainWindow::showLicense);

// View > Toolbar menu

connect(mUI.mActionToolBarMain, SIGNAL(toggled(bool)), this, SLOT(toggleMainToolBar()));

connect(mUI.mActionToolBarView, SIGNAL(toggled(bool)), this, SLOT(toggleViewToolBar()));

connect(mUI.mActionToolBarFilter, SIGNAL(toggled(bool)), this, SLOT(toggleFilterToolBar()));

connect(mUI.mActionAuthors, &QAction::triggered, this, &MainWindow::showAuthors);

connect(mThread, &ThreadHandler::done, this, &MainWindow::analysisDone);

connect(mThread, &ThreadHandler::log, mUI.mResults, &ResultsView::log);

connect(mThread, &ThreadHandler::debugError, mUI.mResults, &ResultsView::debugError);

connect(mUI.mResults, &ResultsView::gotResults, this, &MainWindow::resultsAdded);

connect(mUI.mResults, &ResultsView::resultsHidden, mUI.mActionShowHidden, &QAction::setEnabled);

connect(mUI.mResults, &ResultsView::checkSelected, this, &MainWindow::performSelectedFilesCheck);

connect(mUI.mResults, &ResultsView::tagged, this, &MainWindow::tagged);

connect(mUI.mResults, &ResultsView::suppressIds, this, &MainWindow::suppressIds);

connect(mUI.mMenuView, &QMenu::aboutToShow, this, &MainWindow::aboutToShowViewMenu);

// File menu

connect(mUI.mActionNewProjectFile, &QAction::triggered, this, &MainWindow::newProjectFile);

connect(mUI.mActionOpenProjectFile, &QAction::triggered, this, &MainWindow::openProjectFile);

connect(mUI.mActionShowScratchpad, &QAction::triggered, this, &MainWindow::showScratchpad);

connect(mUI.mActionCloseProjectFile, &QAction::triggered, this, &MainWindow::closeProjectFile);

connect(mUI.mActionEditProjectFile, &QAction::triggered, this, &MainWindow::editProjectFile);

connect(mUI.mActionHelpContents, &QAction::triggered, this, &MainWindow::openHelpContents);

loadSettings();

mThread->initialize(mUI.mResults);

if (mProjectFile)

formatAndSetTitle(tr("Project:") + ' ' + mProjectFile->getFilename());

else

formatAndSetTitle();

enableCheckButtons(true);

mUI.mActionPrint->setShortcut(QKeySequence::Print);

enableResultsButtons();

enableProjectOpenActions(true);

enableProjectActions(false);

// Must setup MRU menu before CLI param handling as it can load a

// project file and update MRU menu.

for (int i = 0; i < MaxRecentProjects; ++i) {

mRecentProjectActs[i] = new QAction(this);

mRecentProjectActs[i]->setVisible(false);

connect(mRecentProjectActs[i], SIGNAL(triggered()),

this, SLOT(openRecentProject()));

}

mRecentProjectActs[MaxRecentProjects] = nullptr; // The separator

mUI.mActionProjectMRU->setVisible(false);

updateMRUMenuItems();

QStringList args = QCoreApplication::arguments();

//Remove the application itself

args.removeFirst();

if (!args.isEmpty()) {

handleCLIParams(args);

}

mUI.mActionCloseProjectFile->setEnabled(mProjectFile != nullptr);

mUI.mActionEditProjectFile->setEnabled(mProjectFile != nullptr);

for (int i = 0; i < mPlatforms.getCount(); i++) {

Platform platform = mPlatforms.mPlatforms[i];

QAction *action = new QAction(this);

platform.mActMainWindow = action;

mPlatforms.mPlatforms[i] = platform;

action->setText(platform.mTitle);

action->setData(platform.mType);

action->setCheckable(true);

action->setActionGroup(mPlatformActions);

mUI.mMenuAnalyze->insertAction(mUI.mActionPlatforms, action);

connect(action, SIGNAL(triggered()), this, SLOT(selectPlatform()));

}

mUI.mActionC89->setActionGroup(mCStandardActions);

mUI.mActionC99->setActionGroup(mCStandardActions);

mUI.mActionC11->setActionGroup(mCStandardActions);

mUI.mActionCpp03->setActionGroup(mCppStandardActions);

mUI.mActionCpp11->setActionGroup(mCppStandardActions);

mUI.mActionCpp14->setActionGroup(mCppStandardActions);

mUI.mActionCpp17->setActionGroup(mCppStandardActions);

mUI.mActionCpp20->setActionGroup(mCppStandardActions);

mUI.mActionEnforceC->setActionGroup(mSelectLanguageActions);

mUI.mActionEnforceCpp->setActionGroup(mSelectLanguageActions);

mUI.mActionAutoDetectLanguage->setActionGroup(mSelectLanguageActions);

// For Windows platforms default to Win32 checked platform.

// For other platforms default to unspecified/default which means the

// platform Cppcheck GUI was compiled on.

#if defined(_WIN32)

const Settings::PlatformType defaultPlatform = Settings::Win32W;

#else

const Settings::PlatformType defaultPlatform = Settings::Unspecified;

#endif

Platform &platform = mPlatforms.get((Settings::PlatformType)mSettings->value(SETTINGS_CHECKED_PLATFORM, defaultPlatform).toInt());

platform.mActMainWindow->setChecked(true);

{

int index;

if (params.contains("-p")) {

index = params.indexOf("-p");

if ((index + 1) < params.length())

loadProjectFile(params[index + 1]);

} else if (params.contains("-l")) {

QString logFile;

index = params.indexOf("-l");

if ((index + 1) < params.length())

logFile = params[index + 1];

if (params.contains("-d")) {

QString checkedDir;

index = params.indexOf("-d");

if ((index + 1) < params.length())

checkedDir = params[index + 1];

loadResults(logFile, checkedDir);

} else {

loadResults(logFile);

}

} else if ((index = params.indexOf(QRegExp(".*\\.cppcheck$", Qt::CaseInsensitive), 0)) >= 0 && index < params.length() && QFile(params[index]).exists()) {

loadProjectFile(params[index]);

} else if ((index = params.indexOf(QRegExp(".*\\.xml$", Qt::CaseInsensitive), 0)) >= 0 && index < params.length() && QFile(params[index]).exists()) {

loadResults(params[index],QDir::currentPath());

} else

doAnalyzeFiles(params);

{

// Window/dialog sizes

if (mSettings->value(SETTINGS_WINDOW_MAXIMIZED, false).toBool()) {

showMaximized();

} else {

resize(mSettings->value(SETTINGS_WINDOW_WIDTH, 800).toInt(),

mSettings->value(SETTINGS_WINDOW_HEIGHT, 600).toInt());

}

ShowTypes *types = mUI.mResults->getShowTypes();

mUI.mActionShowStyle->setChecked(types->isShown(ShowTypes::ShowStyle));

mUI.mActionShowErrors->setChecked(types->isShown(ShowTypes::ShowErrors));

mUI.mActionShowWarnings->setChecked(types->isShown(ShowTypes::ShowWarnings));

mUI.mActionShowPortability->setChecked(types->isShown(ShowTypes::ShowPortability));

mUI.mActionShowPerformance->setChecked(types->isShown(ShowTypes::ShowPerformance));

mUI.mActionShowInformation->setChecked(types->isShown(ShowTypes::ShowInformation));

mUI.mActionShowCppcheck->setChecked(true);

mUI.mActionShowClang->setChecked(true);

Standards standards;

standards.setC(mSettings->value(SETTINGS_STD_C, QString()).toString().toStdString());

mUI.mActionC89->setChecked(standards.c == Standards::C89);

mUI.mActionC99->setChecked(standards.c == Standards::C99);

mUI.mActionC11->setChecked(standards.c == Standards::C11);

standards.setCPP(mSettings->value(SETTINGS_STD_CPP, QString()).toString().toStdString());

mUI.mActionCpp03->setChecked(standards.cpp == Standards::CPP03);

mUI.mActionCpp11->setChecked(standards.cpp == Standards::CPP11);

mUI.mActionCpp14->setChecked(standards.cpp == Standards::CPP14);

mUI.mActionCpp17->setChecked(standards.cpp == Standards::CPP17);

mUI.mActionCpp20->setChecked(standards.cpp == Standards::CPP20);

// Main window settings

const bool showMainToolbar = mSettings->value(SETTINGS_TOOLBARS_MAIN_SHOW, true).toBool();

mUI.mActionToolBarMain->setChecked(showMainToolbar);

mUI.mToolBarMain->setVisible(showMainToolbar);

const bool showViewToolbar = mSettings->value(SETTINGS_TOOLBARS_VIEW_SHOW, true).toBool();

mUI.mActionToolBarView->setChecked(showViewToolbar);

mUI.mToolBarView->setVisible(showViewToolbar);

const bool showFilterToolbar = mSettings->value(SETTINGS_TOOLBARS_FILTER_SHOW, true).toBool();

mUI.mActionToolBarFilter->setChecked(showFilterToolbar);

mUI.mToolBarFilter->setVisible(showFilterToolbar);

Settings::Language enforcedLanguage = (Settings::Language)mSettings->value(SETTINGS_ENFORCED_LANGUAGE, 0).toInt();

if (enforcedLanguage == Settings::CPP)

mUI.mActionEnforceCpp->setChecked(true);

else if (enforcedLanguage == Settings::C)

mUI.mActionEnforceC->setChecked(true);

else

mUI.mActionAutoDetectLanguage->setChecked(true);

bool succeeded = mApplications->loadSettings();

if (!succeeded) {

const QString msg = tr("There was a problem with loading the editor application settings.\n\n"

"This is probably because the settings were changed between the Cppcheck versions. "

"Please check (and fix) the editor application settings, otherwise the editor "

"program might not start correctly.");

QMessageBox msgBox(QMessageBox::Warning,

tr("Cppcheck"),

msg,

QMessageBox::Ok,

this);

msgBox.exec();

}

const QString projectFile = mSettings->value(SETTINGS_OPEN_PROJECT, QString()).toString();

if (!projectFile.isEmpty() && QCoreApplication::arguments().size()==1) {

QFileInfo inf(projectFile);

if (inf.exists() && inf.isReadable()) {

setPath(SETTINGS_LAST_PROJECT_PATH, projectFile);

mProjectFile = new ProjectFile(this);

mProjectFile->read(projectFile);

loadLastResults();

QDir::setCurrent(inf.absolutePath());

}

}

{

// Window/dialog sizes

mSettings->setValue(SETTINGS_WINDOW_WIDTH, size().width());

mSettings->setValue(SETTINGS_WINDOW_HEIGHT, size().height());

mSettings->setValue(SETTINGS_WINDOW_MAXIMIZED, isMaximized());

// Show * states

mSettings->setValue(SETTINGS_SHOW_STYLE, mUI.mActionShowStyle->isChecked());

mSettings->setValue(SETTINGS_SHOW_ERRORS, mUI.mActionShowErrors->isChecked());

mSettings->setValue(SETTINGS_SHOW_WARNINGS, mUI.mActionShowWarnings->isChecked());

mSettings->setValue(SETTINGS_SHOW_PORTABILITY, mUI.mActionShowPortability->isChecked());

mSettings->setValue(SETTINGS_SHOW_PERFORMANCE, mUI.mActionShowPerformance->isChecked());

mSettings->setValue(SETTINGS_SHOW_INFORMATION, mUI.mActionShowInformation->isChecked());

if (mUI.mActionC89->isChecked())

mSettings->setValue(SETTINGS_STD_C, "C89");

if (mUI.mActionC99->isChecked())

mSettings->setValue(SETTINGS_STD_C, "C99");

if (mUI.mActionC11->isChecked())

mSettings->setValue(SETTINGS_STD_C, "C11");

if (mUI.mActionCpp03->isChecked())

mSettings->setValue(SETTINGS_STD_CPP, "C++03");

if (mUI.mActionCpp11->isChecked())

mSettings->setValue(SETTINGS_STD_CPP, "C++11");

if (mUI.mActionCpp14->isChecked())

mSettings->setValue(SETTINGS_STD_CPP, "C++14");

if (mUI.mActionCpp17->isChecked())

mSettings->setValue(SETTINGS_STD_CPP, "C++17");

if (mUI.mActionCpp20->isChecked())

mSettings->setValue(SETTINGS_STD_CPP, "C++20");

// Main window settings

mSettings->setValue(SETTINGS_TOOLBARS_MAIN_SHOW, mUI.mToolBarMain->isVisible());

mSettings->setValue(SETTINGS_TOOLBARS_VIEW_SHOW, mUI.mToolBarView->isVisible());

mSettings->setValue(SETTINGS_TOOLBARS_FILTER_SHOW, mUI.mToolBarFilter->isVisible());

if (mUI.mActionEnforceCpp->isChecked())

mSettings->setValue(SETTINGS_ENFORCED_LANGUAGE, Settings::CPP);

else if (mUI.mActionEnforceC->isChecked())

mSettings->setValue(SETTINGS_ENFORCED_LANGUAGE, Settings::C);

else

mSettings->setValue(SETTINGS_ENFORCED_LANGUAGE, Settings::None);

mApplications->saveSettings();

mSettings->setValue(SETTINGS_LANGUAGE, mTranslation->getCurrentLanguage());

mSettings->setValue(SETTINGS_OPEN_PROJECT, mProjectFile ? mProjectFile->getFilename() : QString());

mUI.mResults->saveSettings(mSettings);

{

clearResults();

mIsLogfileLoaded = false;

if (mProjectFile) {

std::vector<std::string> v;

foreach (const QString &i, mProjectFile->getExcludedPaths()) {

v.push_back(i.toStdString());

}

p.ignorePaths(v);

if (!mProjectFile->getAnalyzeAllVsConfigs()) {

Settings::PlatformType platform = (Settings::PlatformType) mSettings->value(SETTINGS_CHECKED_PLATFORM, 0).toInt();

p.selectOneVsConfig(platform);

}

} else {

enableProjectActions(false);

}

mUI.mResults->clear(true);

mThread->clearFiles();

mUI.mResults->checkingStarted(p.fileSettings.size());

QDir inf(mCurrentDirectory);

const QString checkPath = inf.canonicalPath();

setPath(SETTINGS_LAST_CHECK_PATH, checkPath);

checkLockDownUI(); // lock UI while checking

mUI.mResults->setCheckDirectory(checkPath);

Settings checkSettings = getCppcheckSettings();

checkSettings.force = false;

checkSettings.checkLibrary = checkLibrary;

checkSettings.checkConfiguration = checkConfiguration;

if (mProjectFile)

qDebug() << "Checking project file" << mProjectFile->getFilename();

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

std::list<std::string> sourcefiles;

AnalyzerInformation::writeFilesTxt(checkSettings.buildDir, sourcefiles, p.fileSettings);

}

//mThread->SetanalyzeProject(true);

if (mProjectFile) {

mThread->setAddonsAndTools(mProjectFile->getAddonsAndTools(), mSettings->value(SETTINGS_MISRA_FILE).toString());

QString clangHeaders = mSettings->value(SETTINGS_VS_INCLUDE_PATHS).toString();

mThread->setClangIncludePaths(clangHeaders.split(";"));

mThread->setSuppressions(mProjectFile->getSuppressions());

}

mThread->setProject(p);

mThread->check(checkSettings);

{

if (files.isEmpty()) {

return;

}

clearResults();

mIsLogfileLoaded = false;

FileList pathList;

pathList.addPathList(files);

if (mProjectFile) {

pathList.addExcludeList(mProjectFile->getExcludedPaths());

} else {

enableProjectActions(false);

}

QStringList fileNames = pathList.getFileList();

mUI.mResults->clear(true);

mThread->clearFiles();

if (fileNames.isEmpty()) {

QMessageBox msg(QMessageBox::Warning,

tr("Cppcheck"),

tr("No suitable files found to analyze!"),

QMessageBox::Ok,

this);

msg.exec();

return;

}

mUI.mResults->checkingStarted(fileNames.count());

mThread->setFiles(fileNames);

if (mProjectFile && !checkConfiguration)

mThread->setAddonsAndTools(mProjectFile->getAddonsAndTools(), mSettings->value(SETTINGS_MISRA_FILE).toString());

mThread->setSuppressions(mProjectFile ? mProjectFile->getSuppressions() : QList<Suppressions::Suppression>());

QDir inf(mCurrentDirectory);

const QString checkPath = inf.canonicalPath();

setPath(SETTINGS_LAST_CHECK_PATH, checkPath);

checkLockDownUI(); // lock UI while checking

mUI.mResults->setCheckDirectory(checkPath);

Settings checkSettings = getCppcheckSettings();

checkSettings.checkLibrary = checkLibrary;

checkSettings.checkConfiguration = checkConfiguration;

if (mProjectFile)

qDebug() << "Checking project file" << mProjectFile->getFilename();

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

std::list<std::string> sourcefiles;

foreach (QString s, fileNames)

sourcefiles.push_back(s.toStdString());

AnalyzerInformation::writeFilesTxt(checkSettings.buildDir, sourcefiles, checkSettings.project.fileSettings);

}

mThread->setCheckFiles(true);

mThread->check(checkSettings);

{

// Initialize dummy ThreadResult as ErrorLogger

ThreadResult result;

result.setFiles(QStringList(filename));

connect(&result, SIGNAL(progress(int, const QString&)),

mUI.mResults, SLOT(progress(int, const QString&)));

connect(&result, SIGNAL(error(const ErrorItem &)),

mUI.mResults, SLOT(error(const ErrorItem &)));

connect(&result, SIGNAL(log(const QString &)),

mUI.mResults, SLOT(log(const QString &)));

connect(&result, SIGNAL(debugError(const ErrorItem &)),

mUI.mResults, SLOT(debugError(const ErrorItem &)));

// Create CppCheck instance

CppCheck cppcheck(result, true);

cppcheck.settings() = getCppcheckSettings();

// Check

checkLockDownUI();

clearResults();

mUI.mResults->checkingStarted(1);

cppcheck.check(filename.toStdString(), code.toStdString());

analysisDone();

// Expand results

if (mUI.mResults->hasVisibleResults())

mUI.mResults->expandAllResults();

{

if (mProjectFile) {

QMessageBox msgBox(this);

msgBox.setWindowTitle(tr("Cppcheck"));

const QString msg(tr("You must close the project file before selecting new files or directories!"));

msgBox.setText(msg);

msgBox.setIcon(QMessageBox::Critical);

msgBox.exec();

return QStringList();

}

QStringList selected;

// NOTE: we use QFileDialog::getOpenFileNames() and

// QFileDialog::getExistingDirectory() because they show native Windows

// selection dialog which is a lot more usable than Qt:s own dialog.

if (mode == QFileDialog::ExistingFiles) {

QMap<QString,QString> filters;

filters[tr("C/C++ Source")] = FileList::getDefaultFilters().join(" ");

filters[tr("Compile database")] = compile_commands_json;

filters[tr("Visual Studio")] = "*.sln *.vcxproj";

filters[tr("Borland C++ Builder 6")] = "*.bpr";

QString lastFilter = mSettings->value(SETTINGS_LAST_ANALYZE_FILES_FILTER).toString();

selected = QFileDialog::getOpenFileNames(this,

tr("Select files to analyze"),

getPath(SETTINGS_LAST_CHECK_PATH),

toFilterString(filters),

&lastFilter);

mSettings->setValue(SETTINGS_LAST_ANALYZE_FILES_FILTER, lastFilter);

if (selected.isEmpty())

mCurrentDirectory.clear();

else {

QFileInfo inf(selected[0]);

mCurrentDirectory = inf.absolutePath();

}

formatAndSetTitle();

} else if (mode == QFileDialog::DirectoryOnly) {

QString dir = QFileDialog::getExistingDirectory(this,

tr("Select directory to analyze"),

getPath(SETTINGS_LAST_CHECK_PATH));

if (!dir.isEmpty()) {

qDebug() << "Setting current directory to: " << dir;

mCurrentDirectory = dir;

selected.append(dir);

dir = QDir::toNativeSeparators(dir);

formatAndSetTitle(dir);

}

}

setPath(SETTINGS_LAST_CHECK_PATH, mCurrentDirectory);

return selected;

{

Settings::terminate(false);

QStringList selected = selectFilesToAnalyze(QFileDialog::ExistingFiles);

const QString file0 = (selected.size() ? selected[0].toLower() : QString());

if (file0.endsWith(".sln")

|| file0.endsWith(".vcxproj")

|| file0.endsWith(compile_commands_json)

|| file0.endsWith(".bpr")) {

ImportProject p;

p.import(selected[0].toStdString());

if (file0.endsWith(".sln")) {

QStringList configs;

for (std::list<ImportProject::FileSettings>::const_iterator it = p.fileSettings.begin(); it != p.fileSettings.end(); ++it) {

const QString cfg(QString::fromStdString(it->cfg));

if (!configs.contains(cfg))

configs.push_back(cfg);

}

configs.sort();

bool ok = false;

const QString cfg = QInputDialog::getItem(this, tr("Select configuration"), tr("Select the configuration that will be analyzed"), configs, 0, false, &ok);

if (!ok)

return;

p.ignoreOtherConfigs(cfg.toStdString());

}

doAnalyzeProject(p);

return;

}

doAnalyzeFiles(selected);

{

QStringList dir = selectFilesToAnalyze(QFileDialog::DirectoryOnly);

if (dir.isEmpty())

return;

QDir checkDir(dir[0]);

QStringList filters;

filters << "*.cppcheck";

checkDir.setFilter(QDir::Files | QDir::Readable);

checkDir.setNameFilters(filters);

QStringList projFiles = checkDir.entryList();

if (!projFiles.empty()) {

if (projFiles.size() == 1) {

// If one project file found, suggest loading it

QMessageBox msgBox(this);

msgBox.setWindowTitle(tr("Cppcheck"));

const QString msg(tr("Found project file: %1\n\nDo you want to "

"load this project file instead?").arg(projFiles[0]));

msgBox.setText(msg);

msgBox.setIcon(QMessageBox::Warning);

msgBox.addButton(QMessageBox::Yes);

msgBox.addButton(QMessageBox::No);

msgBox.setDefaultButton(QMessageBox::Yes);

int dlgResult = msgBox.exec();

if (dlgResult == QMessageBox::Yes) {

QString path = checkDir.canonicalPath();

if (!path.endsWith("/"))

path += "/";

path += projFiles[0];

loadProjectFile(path);

} else {

doAnalyzeFiles(dir);

}

} else {

// If multiple project files found inform that there are project

// files also available.

QMessageBox msgBox(this);

msgBox.setWindowTitle(tr("Cppcheck"));

const QString msg(tr("Found project files from the directory.\n\n"

"Do you want to proceed analysis without "

"using any of these project files?"));

msgBox.setText(msg);

msgBox.setIcon(QMessageBox::Warning);

msgBox.addButton(QMessageBox::Yes);

msgBox.addButton(QMessageBox::No);

msgBox.setDefaultButton(QMessageBox::Yes);

int dlgResult = msgBox.exec();

if (dlgResult == QMessageBox::Yes) {

doAnalyzeFiles(dir);

}

}

} else {

doAnalyzeFiles(dir);

}

{

QString dir;

foreach (dir, includeDirs) {

QString incdir;

if (!QDir::isAbsolutePath(dir))

incdir = mCurrentDirectory + "/";

incdir += dir;

incdir = QDir::cleanPath(incdir);

// include paths must end with '/'

if (!incdir.endsWith("/"))

incdir += "/";

result.includePaths.push_back(incdir.toStdString());

}

{

Library::Error ret;

// Try to load the library from the project folder..

if (mProjectFile) {

QString path = QFileInfo(mProjectFile->getFilename()).canonicalPath();

ret = library->load(nullptr, (path+"/"+filename).toLatin1());

if (ret.errorcode != Library::ErrorCode::FILE_NOT_FOUND)

return ret;

}

// Try to load the library from the application folder..

const QString appPath = QFileInfo(QCoreApplication::applicationFilePath()).canonicalPath();

ret = library->load(nullptr, (appPath+"/"+filename).toLatin1());

if (ret.errorcode != Library::ErrorCode::FILE_NOT_FOUND)

return ret;

ret = library->load(nullptr, (appPath+"/cfg/"+filename).toLatin1());

if (ret.errorcode != Library::ErrorCode::FILE_NOT_FOUND)

return ret;

#ifdef FILESDIR

// Try to load the library from FILESDIR/cfg..

const QString filesdir = FILESDIR;

if (!filesdir.isEmpty()) {

ret = library->load(nullptr, (filesdir+"/cfg/"+filename).toLatin1());

if (ret.errorcode != Library::ErrorCode::FILE_NOT_FOUND)

return ret;

ret = library->load(nullptr, (filesdir+filename).toLatin1());

if (ret.errorcode != Library::ErrorCode::FILE_NOT_FOUND)

return ret;

}

#endif

// Try to load the library from the cfg subfolder..

const QString datadir = mSettings->value("DATADIR", QString()).toString();

if (!datadir.isEmpty()) {

ret = library->load(nullptr, (datadir+"/"+filename).toLatin1());

if (ret.errorcode != Library::ErrorCode::FILE_NOT_FOUND)

return ret;

ret = library->load(nullptr, (datadir+"/cfg/"+filename).toLatin1());

if (ret.errorcode != Library::ErrorCode::FILE_NOT_FOUND)

return ret;

}

return ret;

{

const Library::Error error = loadLibrary(library, filename);

if (error.errorcode != Library::ErrorCode::OK) {

if (error.errorcode == Library::UNKNOWN_ELEMENT) {

QMessageBox::information(this, tr("Information"), tr("The library '%1' contains unknown elements:\n%2").arg(filename).arg(error.reason.c_str()));

return true;

}

QString errmsg;

switch (error.errorcode) {

case Library::ErrorCode::OK:

break;

case Library::ErrorCode::FILE_NOT_FOUND:

errmsg = tr("File not found");

break;

case Library::ErrorCode::BAD_XML:

errmsg = tr("Bad XML");

break;

case Library::ErrorCode::MISSING_ATTRIBUTE:

errmsg = tr("Missing attribute");

break;

case Library::ErrorCode::BAD_ATTRIBUTE_VALUE:

errmsg = tr("Bad attribute value");

break;

case Library::ErrorCode::UNSUPPORTED_FORMAT:

errmsg = tr("Unsupported format");

break;

case Library::ErrorCode::DUPLICATE_PLATFORM_TYPE:

errmsg = tr("Duplicate platform type");

break;

case Library::ErrorCode::PLATFORM_TYPE_REDEFINED:

errmsg = tr("Platform type redefined");

break;

case Library::ErrorCode::UNKNOWN_ELEMENT:

errmsg = tr("Unknown element");

break;

default:

errmsg = tr("Unknown issue");

break;

}

if (!error.reason.empty())

errmsg += " '" + QString::fromStdString(error.reason) + "'";

QMessageBox::information(this, tr("Information"), tr("Failed to load the selected library '%1'.\n%2").arg(filename).arg(errmsg));

return false;

}

return true;

{

saveSettings(); // Save settings

Settings result;

const bool std = tryLoadLibrary(&result.library, "std.cfg");

bool posix = true;

if (result.posix())

posix = tryLoadLibrary(&result.library, "posix.cfg");

bool windows = true;

if (result.isWindowsPlatform())

windows = tryLoadLibrary(&result.library, "windows.cfg");

if (!std || !posix || !windows)

QMessageBox::critical(this, tr("Error"), tr("Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=<directory> at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.").arg(!std ? "std.cfg" : !posix ? "posix.cfg" : "windows.cfg"));

// If project file loaded, read settings from it

if (mProjectFile) {

QStringList dirs = mProjectFile->getIncludeDirs();

addIncludeDirs(dirs, result);

const QStringList defines = mProjectFile->getDefines();

foreach (QString define, defines) {

if (!result.userDefines.empty())

result.userDefines += ";";

result.userDefines += define.toStdString();

}

result.clang = mProjectFile->clangParser;

const QStringList undefines = mProjectFile->getUndefines();

foreach (QString undefine, undefines)

result.userUndefs.insert(undefine.toStdString());

const QStringList libraries = mProjectFile->getLibraries();

foreach (QString library, libraries) {

const QString filename = library + ".cfg";

tryLoadLibrary(&result.library, filename);

}

foreach (const Suppressions::Suppression &suppression, mProjectFile->getSuppressions()) {

result.nomsg.addSuppression(suppression);

}

// Only check the given -D configuration

if (!defines.isEmpty())

result.maxConfigs = 1;

// If importing a project, only check the given configuration

if (!mProjectFile->getImportProject().isEmpty())

result.checkAllConfigurations = false;

const QString &buildDir = mProjectFile->getBuildDir();

if (!buildDir.isEmpty()) {

if (QDir(buildDir).isAbsolute()) {

result.buildDir = buildDir.toStdString();

} else {

QString prjpath = QFileInfo(mProjectFile->getFilename()).absolutePath();

result.buildDir = (prjpath + '/' + buildDir).toStdString();

}

}

const QString platform = mProjectFile->getPlatform();

if (platform.endsWith(".xml")) {

const QString applicationFilePath = QCoreApplication::applicationFilePath();

result.loadPlatformFile(applicationFilePath.toStdString().c_str(), platform.toStdString());

} else {

for (int i = cppcheck::Platform::Native; i <= cppcheck::Platform::Unix64; i++) {

const cppcheck::Platform::PlatformType p = (cppcheck::Platform::PlatformType)i;

if (platform == cppcheck::Platform::platformString(p)) {

result.platform(p);

break;

}

}

}

result.maxCtuDepth = mProjectFile->getMaxCtuDepth();

result.checkHeaders = mProjectFile->getCheckHeaders();

result.checkUnusedTemplates = mProjectFile->getCheckUnusedTemplates();

result.safeChecks.classes = mProjectFile->getSafeChecks().classes;

result.safeChecks.externalFunctions = mProjectFile->getSafeChecks().externalFunctions;

result.safeChecks.internalFunctions = mProjectFile->getSafeChecks().internalFunctions;

result.safeChecks.externalVariables = mProjectFile->getSafeChecks().externalVariables;

foreach (QString s, mProjectFile->getCheckUnknownFunctionReturn())

result.checkUnknownFunctionReturn.insert(s.toStdString());

}

// Include directories (and files) are searched in listed order.

// Global include directories must be added AFTER the per project include

// directories so per project include directories can override global ones.

const QString globalIncludes = mSettings->value(SETTINGS_GLOBAL_INCLUDE_PATHS).toString();

if (!globalIncludes.isEmpty()) {

QStringList includes = globalIncludes.split(";");

addIncludeDirs(includes, result);

}

result.addEnabled("warning");

result.addEnabled("style");

result.addEnabled("performance");

result.addEnabled("portability");

result.addEnabled("information");

result.addEnabled("missingInclude");

if (!result.buildDir.empty())

result.addEnabled("unusedFunction");

result.debugwarnings = mSettings->value(SETTINGS_SHOW_DEBUG_WARNINGS, false).toBool();

result.quiet = false;

result.verbose = true;

result.force = mSettings->value(SETTINGS_CHECK_FORCE, 1).toBool();

result.xml = false;

result.jobs = mSettings->value(SETTINGS_CHECK_THREADS, 1).toInt();

result.inlineSuppressions = mSettings->value(SETTINGS_INLINE_SUPPRESSIONS, false).toBool();

result.inconclusive = mSettings->value(SETTINGS_INCONCLUSIVE_ERRORS, false).toBool();

if (!mProjectFile || result.platformType == cppcheck::Platform::Unspecified)

result.platform((cppcheck::Platform::PlatformType) mSettings->value(SETTINGS_CHECKED_PLATFORM, 0).toInt());

result.standards.setCPP(mSettings->value(SETTINGS_STD_CPP, QString()).toString().toStdString());

result.standards.setC(mSettings->value(SETTINGS_STD_C, QString()).toString().toStdString());

result.enforcedLang = (Settings::Language)mSettings->value(SETTINGS_ENFORCED_LANGUAGE, 0).toInt();

if (result.jobs <= 1) {

result.jobs = 1;

}

result.terminate(false);

return result;

{

if (mExiting) {

close();

return;

}

mUI.mResults->checkingFinished();

enableCheckButtons(true);

mUI.mActionSettings->setEnabled(true);

mUI.mActionOpenXML->setEnabled(true);

if (mProjectFile) {

enableProjectActions(true);

} else if (mIsLogfileLoaded) {

mUI.mActionReanalyzeModified->setEnabled(false);

mUI.mActionReanalyzeAll->setEnabled(false);

}

enableProjectOpenActions(true);

mPlatformActions->setEnabled(true);

mCStandardActions->setEnabled(true);

mCppStandardActions->setEnabled(true);

mSelectLanguageActions->setEnabled(true);

mUI.mActionPosix->setEnabled(true);

if (mScratchPad)

mScratchPad->setEnabled(true);

mUI.mActionViewStats->setEnabled(true);

if (mProjectFile && !mProjectFile->getBuildDir().isEmpty()) {

const QString prjpath = QFileInfo(mProjectFile->getFilename()).absolutePath();

const QString buildDir = prjpath + '/' + mProjectFile->getBuildDir();

if (QDir(buildDir).exists()) {

mUI.mResults->saveStatistics(buildDir + "/statistics.txt");

mUI.mResults->updateFromOldReport(buildDir + "/lastResults.xml");

mUI.mResults->save(buildDir + "/lastResults.xml", Report::XMLV2);

}

}

enableResultsButtons();

for (int i = 0; i < MaxRecentProjects + 1; i++) {

if (mRecentProjectActs[i] != nullptr)

mRecentProjectActs[i]->setEnabled(true);

}

// Notify user - if the window is not active - that check is ready

QApplication::alert(this, 3000);

if (mSettings->value(SETTINGS_SHOW_STATISTICS, false).toBool())

showStatistics();

{

enableCheckButtons(false);

mUI.mActionSettings->setEnabled(false);

mUI.mActionOpenXML->setEnabled(false);

enableProjectActions(false);

enableProjectOpenActions(false);

mPlatformActions->setEnabled(false);

mCStandardActions->setEnabled(false);

mCppStandardActions->setEnabled(false);