#ifdef Q_OS_WIN

QString ret(p);

ret.replace('\\', '/');

return ret;

#else

return p;

#endif

mSettings(settings),

mApplications(new ApplicationList(this)),

mTranslation(th),

mUI(new Ui::MainWindow),

mPlatformActions(new QActionGroup(this)),

mCStandardActions(new QActionGroup(this)),

mCppStandardActions(new QActionGroup(this)),

mSelectLanguageActions(new QActionGroup(this))

{

{

Settings tempSettings;

tempSettings.exename = QCoreApplication::applicationFilePath().toStdString();

tempSettings.loadCppcheckCfg(); // TODO: how to handle error?

mCppcheckCfgProductName = QString::fromStdString(tempSettings.cppcheckCfgProductName);

mCppcheckCfgAbout = QString::fromStdString(tempSettings.cppcheckCfgAbout);

}

mUI->setupUi(this);

mThread = new ThreadHandler(this);

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

connect(mUI->mActionComplianceReport, &QAction::triggered, this, &MainWindow::complianceReport);

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

mUI->mActionComplianceReport->setVisible(isCppcheckPremium());

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++) {

PlatformData platform = mPlatforms.mPlatforms[i];

auto *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->mActionCpp23->setActionGroup(mCppStandardActions);

mUI->mActionEnforceC->setActionGroup(mSelectLanguageActions);

mUI->mActionEnforceCpp->setActionGroup(mSelectLanguageActions);

mUI->mActionAutoDetectLanguage->setActionGroup(mSelectLanguageActions);

// TODO: we no longer default to a Windows platform in CLI - so we should probably also get rid of this in the GUI

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

constexpr Platform::Type defaultPlatform = Platform::Type::Win32W;

#else

constexpr Platform::Type defaultPlatform = Platform::Type::Unspecified;

#endif

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

platform.mActMainWindow->setChecked(true);

mNetworkAccessManager = new QNetworkAccessManager(this);

connect(mNetworkAccessManager, &QNetworkAccessManager::finished,

this, &MainWindow::replyFinished);

mUI->mLabelInformation->setVisible(false);

mUI->mButtonHideInformation->setVisible(false);

connect(mUI->mButtonHideInformation, &QPushButton::clicked,

this, &MainWindow::hideInformation);

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

// Is there a new version?

if (isCppcheckPremium()) {

const QUrl url("https://files.cppchecksolutions.com/version.txt");

mNetworkAccessManager->get(QNetworkRequest(url));

} else {

const QUrl url("https://cppcheck.sourceforge.io/version.txt");

mNetworkAccessManager->get(QNetworkRequest(url));

}

} else {

delete mUI->mLayoutInformation;

}

{

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(QRegularExpression(".*\\.cppcheck$", QRegularExpression::CaseInsensitiveOption))) >= 0 && index < params.length() && QFile(params[index]).exists()) {

loadProjectFile(params[index]);

} else if ((index = params.indexOf(QRegularExpression(".*\\.xml$", QRegularExpression::CaseInsensitiveOption))) >= 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());

}

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

//mUI->mActionCpp23->setChecked(standards.cpp == Standards::CPP23);

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

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

if (enforcedLanguage == Standards::Language::CPP)

mUI->mActionEnforceCpp->setChecked(true);

else if (enforcedLanguage == Standards::Language::C)

mUI->mActionEnforceC->setChecked(true);

else

mUI->mActionAutoDetectLanguage->setChecked(true);

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

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

//if (mUI.mActionCpp23->isChecked())

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

// 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, Standards::Language::CPP);

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

mSettings->setValue(SETTINGS_ENFORCED_LANGUAGE, Standards::Language::C);

else

mSettings->setValue(SETTINGS_ENFORCED_LANGUAGE, Standards::Language::None);

mApplications->saveSettings();

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

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

mUI->mResults->saveSettings(mSettings);

{

QPair<bool,Settings> checkSettingsPair = getCppcheckSettings();

if (!checkSettingsPair.first)

return;

Settings& checkSettings = checkSettingsPair.second;

clearResults();

mIsLogfileLoaded = false;

if (mProjectFile) {

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

const QStringList excluded = mProjectFile->getExcludedPaths();

std::transform(excluded.cbegin(), excluded.cend(), std::back_inserter(v), [](const QString& e) {

return e.toStdString();

});

p.ignorePaths(v);

if (!mProjectFile->getAnalyzeAllVsConfigs()) {

const Platform::Type platform = (Platform::Type) mSettings->value(SETTINGS_CHECKED_PLATFORM, 0).toInt();

std::vector<std::string> configurations;

const QStringList configs = mProjectFile->getVsConfigurations();

std::transform(configs.cbegin(), configs.cend(), std::back_inserter(configurations), [](const QString& e) {

return e.toStdString();

});

p.selectVsConfigurations(platform, configurations);

}

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

checkSettings.force = false;

checkSettings.checkLibrary = checkLibrary;

checkSettings.checkConfiguration = checkConfiguration;

if (mProjectFile)

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

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

checkSettings.loadSummaries();

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

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

}

//mThread->SetanalyzeProject(true);

if (mProjectFile) {

mThread->setAddonsAndTools(mProjectFile->getAddonsAndTools());

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

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

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

}

mThread->setProject(p);

mThread->check(checkSettings);

mUI->mResults->setCheckSettings(checkSettings);

{

if (files.isEmpty())

return;

QPair<bool, Settings> checkSettingsPair = getCppcheckSettings();

if (!checkSettingsPair.first)

return;

Settings& checkSettings = checkSettingsPair.second;

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

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

checkSettings.checkLibrary = checkLibrary;

checkSettings.checkConfiguration = checkConfiguration;

if (mProjectFile)

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

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

checkSettings.loadSummaries();

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

std::transform(fileNames.cbegin(), fileNames.cend(), std::back_inserter(sourcefiles), [](const QString& s) {

return s.toStdString();

});

AnalyzerInformation::writeFilesTxt(checkSettings.buildDir, sourcefiles, checkSettings.userDefines, {});

}

mThread->setCheckFiles(true);

mThread->check(checkSettings);

mUI->mResults->setCheckSettings(checkSettings);

{

const QPair<bool, Settings>& checkSettingsPair = getCppcheckSettings();

if (!checkSettingsPair.first)

return;

const Settings& checkSettings = checkSettingsPair.second;

// Initialize dummy ThreadResult as ErrorLogger

ThreadResult result;

result.setFiles(QStringList(filename));

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

mUI->mResults, SLOT(progress(int,QString)));

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

mUI->mResults, SLOT(error(ErrorItem)));

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

mUI->mResults, SLOT(log(QString)));

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

mUI->mResults, SLOT(debugError(ErrorItem)));

// Create CppCheck instance

CppCheck cppcheck(result, true, nullptr);

cppcheck.settings() = checkSettings;

// 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::Directory) {

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

}

}

if (!mCurrentDirectory.isEmpty())

setPath(SETTINGS_LAST_CHECK_PATH, mCurrentDirectory);

return selected;

{

Settings::terminate(false);

QStringList selected = selectFilesToAnalyze(QFileDialog::ExistingFiles);

const QString file0 = (!selected.empty() ? 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<FileSettings>::const_iterator it = p.fileSettings.cbegin(); it != p.fileSettings.cend(); ++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::Directory);

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

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

const int dlgResult = msgBox.exec();

if (dlgResult == QMessageBox::Yes) {

doAnalyzeFiles(dir);

}

}

} else {

doAnalyzeFiles(dir);

}

{

for (const QString& 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 = getDataDir();

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::ErrorCode::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::DUPLICATE_DEFINE:

errmsg = tr("Duplicate define");

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;

{

const QString addonFilePath = fromNativePath(ProjectFile::getAddonFilePath(filesDir, addon));

if (addonFilePath.isEmpty())

return tr("File not found: '%1'").arg(addon);

picojson::object obj;

obj["script"] = picojson::value(addonFilePath.toStdString());

if (!pythonCmd.isEmpty())

obj["python"] = picojson::value(pythonCmd.toStdString());

if (!isCppcheckPremium() && addon == "misra") {

const QString misraFile = fromNativePath(mSettings->value(SETTINGS_MISRA_FILE).toString());

if (!misraFile.isEmpty()) {

QString arg;

if (misraFile.endsWith(".pdf", Qt::CaseInsensitive))

arg = "--misra-pdf=" + misraFile;

else

arg = "--rule-texts=" + misraFile;

obj["args"] = picojson::value(arg.toStdString());

}

}

const std::string& json_str = picojson::value(obj).serialize();

AddonInfo addonInfo;

const std::string errmsg = addonInfo.getAddonInfo(json_str, settings.exename);

if (!errmsg.empty())

return tr("Failed to load/setup addon %1: %2").arg(addon, QString::fromStdString(errmsg));

settings.addonInfos.emplace_back(std::move(addonInfo));

settings.addons.emplace(json_str);

return "";

{

saveSettings(); // Save settings

Settings::terminate(true);

Settings result;

result.exename = QCoreApplication::applicationFilePath().toStdString();

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

if (!std) {

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.\n\nAnalysis is aborted.").arg("std.cfg"));

return {false, {}};

}

const QString filesDir(getDataDir());

const QString pythonCmd = fromNativePath(mSettings->value(SETTINGS_PYTHON_PATH).toString());

{

const QString cfgErr = QString::fromStdString(result.loadCppcheckCfg());

if (!cfgErr.isEmpty()) {

QMessageBox::critical(this, tr("Error"), tr("Failed to load %1 - %2\n\nAnalysis is aborted.").arg("cppcheck.cfg").arg(cfgErr));

return {false, {}};

}

const auto cfgAddons = result.addons;

result.addons.clear();

for (const std::string& addon : cfgAddons) {

// TODO: support addons which are a script and not a file

const QString addonError = loadAddon(result, filesDir, pythonCmd, QString::fromStdString(addon));

if (!addonError.isEmpty()) {

QMessageBox::critical(this, tr("Error"), tr("%1\n\nAnalysis is aborted.").arg(addonError));

return {false, {}};

}

}

}

// If project file loaded, read settings from it

if (mProjectFile) {