cppcheck/gui/mainwindow.cpp

1918 lines
69 KiB
C++
Raw Normal View History

/*
* Cppcheck - A tool for static C/C++ code analysis
2020-05-10 11:16:32 +02:00
* Copyright (C) 2007-2020 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 <QApplication>
#include <QDebug>
#include <QMessageBox>
#include <QFileInfo>
#include <QDir>
#include <QDesktopServices>
#include <QUrl>
#include <QAction>
#include <QActionGroup>
#include <QFile>
#include <QInputDialog>
#include "mainwindow.h"
#include "cppcheck.h"
#include "applicationlist.h"
#include "aboutdialog.h"
#include "common.h"
2020-07-20 11:59:28 +02:00
#include "filelist.h"
#include "fileviewdialog.h"
#include "functioncontractdialog.h"
#include "helpdialog.h"
2020-07-20 11:59:28 +02:00
#include "librarydialog.h"
#include "projectfile.h"
2017-07-31 12:02:51 +02:00
#include "projectfiledialog.h"
#include "report.h"
#include "scratchpad.h"
2020-07-20 11:59:28 +02:00
#include "showtypes.h"
#include "statsdialog.h"
#include "settingsdialog.h"
2020-07-20 11:59:28 +02:00
#include "threadhandler.h"
#include "threadresult.h"
#include "translationhandler.h"
2020-08-22 11:37:44 +02:00
#include "variablecontractsdialog.h"
static const QString OnlineHelpURL("http://cppcheck.net/manual.html");
static const QString compile_commands_json("compile_commands.json");
MainWindow::MainWindow(TranslationHandler* th, QSettings* settings) :
mSettings(settings),
2010-04-15 20:08:51 +02:00
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());
2017-07-28 12:10:10 +02:00
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);
2017-07-31 07:36:42 +02:00
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()));
2017-07-31 07:36:42 +02:00
connect(mLineEditFilter, &QLineEdit::returnPressed, this, &MainWindow::filterResults);
2017-07-28 12:22:15 +02:00
connect(mUI.mActionPrint, SIGNAL(triggered()), mUI.mResults, SLOT(print()));
connect(mUI.mActionPrintPreview, SIGNAL(triggered()), mUI.mResults, SLOT(printPreview()));
2017-07-31 07:36:42 +02:00
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);
2017-07-31 07:36:42 +02:00
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);
2017-07-31 07:36:42 +02:00
connect(mUI.mActionStop, &QAction::triggered, this, &MainWindow::stopAnalysis);
connect(mUI.mActionSave, &QAction::triggered, this, &MainWindow::save);
// About menu
2017-07-31 07:36:42 +02:00
connect(mUI.mActionAbout, &QAction::triggered, this, &MainWindow::about);
connect(mUI.mActionLicense, &QAction::triggered, this, &MainWindow::showLicense);
// View > Toolbar menu
2017-07-28 12:22:15 +02:00
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()));
2017-07-31 07:36:42 +02:00
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);
2020-02-10 20:24:36 +01:00
connect(mThread, &ThreadHandler::bughuntingReportLine, mUI.mResults, &ResultsView::bughuntingReportLine);
2017-07-31 07:36:42 +02:00
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);
2017-08-11 07:45:29 +02:00
connect(mUI.mResults, &ResultsView::suppressIds, this, &MainWindow::suppressIds);
connect(mUI.mResults, &ResultsView::editFunctionContract, this, &MainWindow::editFunctionContract);
2020-08-22 11:37:44 +02:00
connect(mUI.mResults, &ResultsView::editVariableContract, this, &MainWindow::editVariableContract);
connect(mUI.mResults, &ResultsView::deleteFunctionContract, this, &MainWindow::deleteFunctionContract);
connect(mUI.mResults, &ResultsView::deleteVariableContract, this, &MainWindow::deleteVariableContract);
2017-07-31 07:36:42 +02:00
connect(mUI.mMenuView, &QMenu::aboutToShow, this, &MainWindow::aboutToShowViewMenu);
// File menu
2017-07-31 07:36:42 +02:00
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);
2017-07-31 07:36:42 +02:00
connect(mUI.mActionHelpContents, &QAction::triggered, this, &MainWindow::openHelpContents);
2017-07-28 05:44:15 +02:00
loadSettings();
2017-07-28 12:39:28 +02:00
mThread->initialize(mUI.mResults);
2017-07-31 12:02:51 +02:00
if (mProjectFile)
formatAndSetTitle(tr("Project:") + ' ' + mProjectFile->getFilename());
else
formatAndSetTitle();
2017-07-28 05:44:15 +02:00
enableCheckButtons(true);
mUI.mActionPrint->setShortcut(QKeySequence::Print);
enableResultsButtons();
2017-07-28 05:44:15 +02:00
enableProjectOpenActions(true);
enableProjectActions(false);
// Must setup MRU menu before CLI param handling as it can load a
// project file and update MRU menu.
2011-10-13 20:53:06 +02:00
for (int i = 0; i < MaxRecentProjects; ++i) {
mRecentProjectActs[i] = new QAction(this);
mRecentProjectActs[i]->setVisible(false);
connect(mRecentProjectActs[i], SIGNAL(triggered()),
2017-07-28 12:22:15 +02:00
this, SLOT(openRecentProject()));
}
mRecentProjectActs[MaxRecentProjects] = nullptr; // The separator
mUI.mActionProjectMRU->setVisible(false);
2017-07-28 05:44:15 +02:00
updateMRUMenuItems();
QStringList args = QCoreApplication::arguments();
//Remove the application itself
args.removeFirst();
if (!args.isEmpty()) {
2017-07-28 05:44:15 +02:00
handleCLIParams(args);
}
2017-07-31 12:02:51 +02:00
mUI.mActionCloseProjectFile->setEnabled(mProjectFile != nullptr);
mUI.mActionEditProjectFile->setEnabled(mProjectFile != nullptr);
2011-10-13 20:53:06 +02:00
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);
2017-09-22 22:00:00 +02:00
mUI.mActionCpp14->setActionGroup(mCppStandardActions);
mUI.mActionCpp17->setActionGroup(mCppStandardActions);
2019-05-05 10:44:09 +02:00
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);
}
MainWindow::~MainWindow()
{
2017-07-31 12:02:51 +02:00
delete mProjectFile;
delete mScratchPad;
}
2017-07-28 05:44:15 +02:00
void MainWindow::handleCLIParams(const QStringList &params)
{
int index;
2011-10-13 20:53:06 +02:00
if (params.contains("-p")) {
index = params.indexOf("-p");
if ((index + 1) < params.length())
2017-07-28 05:44:15 +02:00
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];
2017-07-28 05:44:15 +02:00
loadResults(logFile, checkedDir);
2013-02-10 23:53:01 +01:00
} else {
2017-07-28 05:44:15 +02:00
loadResults(logFile);
}
} else if ((index = params.indexOf(QRegExp(".*\\.cppcheck$", Qt::CaseInsensitive), 0)) >= 0 && index < params.length() && QFile(params[index]).exists()) {
2017-07-28 05:44:15 +02:00
loadProjectFile(params[index]);
} else if ((index = params.indexOf(QRegExp(".*\\.xml$", Qt::CaseInsensitive), 0)) >= 0 && index < params.length() && QFile(params[index]).exists()) {
2017-07-28 05:44:15 +02:00
loadResults(params[index],QDir::currentPath());
2011-10-13 20:53:06 +02:00
} else
doAnalyzeFiles(params);
}
2017-07-28 05:44:15 +02:00
void MainWindow::loadSettings()
{
// Window/dialog sizes
2011-10-13 20:53:06 +02:00
if (mSettings->value(SETTINGS_WINDOW_MAXIMIZED, false).toBool()) {
showMaximized();
2011-10-13 20:53:06 +02:00
} else {
resize(mSettings->value(SETTINGS_WINDOW_WIDTH, 800).toInt(),
mSettings->value(SETTINGS_WINDOW_HEIGHT, 600).toInt());
}
2009-03-22 18:39:44 +01:00
2017-07-28 12:10:10 +02:00
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);
2019-05-05 10:44:09 +02:00
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);
2017-07-28 05:18:43 +02:00
bool succeeded = mApplications->loadSettings();
2011-10-13 20:53:06 +02:00
if (!succeeded) {
2011-08-22 21:37:38 +02:00
const QString msg = tr("There was a problem with loading the editor application settings.\n\n"
2011-08-23 02:32:35 +02:00
"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()) {
2017-07-30 23:02:30 +02:00
setPath(SETTINGS_LAST_PROJECT_PATH, projectFile);
2017-07-31 12:02:51 +02:00
mProjectFile = new ProjectFile(this);
2020-07-15 13:03:07 +02:00
mProjectFile->setActiveProject();
2017-07-31 12:02:51 +02:00
mProjectFile->read(projectFile);
loadLastResults();
QDir::setCurrent(inf.absolutePath());
}
}
2020-08-22 11:37:44 +02:00
updateFunctionContractsTab();
updateVariableContractsTab();
}
2017-07-28 05:44:15 +02:00
void MainWindow::saveSettings() const
{
// Window/dialog sizes
mSettings->setValue(SETTINGS_WINDOW_WIDTH, size().width());
mSettings->setValue(SETTINGS_WINDOW_HEIGHT, size().height());
mSettings->setValue(SETTINGS_WINDOW_MAXIMIZED, isMaximized());
2009-03-22 18:39:44 +01:00
// 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");
2019-05-05 10:44:09 +02:00
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);
2017-07-28 05:18:43 +02:00
mApplications->saveSettings();
2017-07-28 13:43:49 +02:00
mSettings->setValue(SETTINGS_LANGUAGE, mTranslation->getCurrentLanguage());
2017-07-31 12:02:51 +02:00
mSettings->setValue(SETTINGS_OPEN_PROJECT, mProjectFile ? mProjectFile->getFilename() : QString());
2017-07-28 12:10:10 +02:00
mUI.mResults->saveSettings(mSettings);
}
void MainWindow::doAnalyzeProject(ImportProject p, const bool checkLibrary, const bool checkConfiguration)
2016-08-18 21:58:50 +02:00
{
2017-07-28 10:41:03 +02:00
clearResults();
2016-08-18 21:58:50 +02:00
mIsLogfileLoaded = false;
2017-07-31 12:02:51 +02:00
if (mProjectFile) {
2016-08-18 21:58:50 +02:00
std::vector<std::string> v;
2017-07-31 12:02:51 +02:00
foreach (const QString &i, mProjectFile->getExcludedPaths()) {
v.push_back(i.toStdString());
2016-08-18 21:58:50 +02:00
}
p.ignorePaths(v);
if (!mProjectFile->getAnalyzeAllVsConfigs()) {
Settings::PlatformType platform = (Settings::PlatformType) mSettings->value(SETTINGS_CHECKED_PLATFORM, 0).toInt();
p.selectOneVsConfig(platform);
}
2016-08-18 21:58:50 +02:00
} else {
2017-07-28 05:44:15 +02:00
enableProjectActions(false);
2016-08-18 21:58:50 +02:00
}
2017-07-28 12:10:10 +02:00
mUI.mResults->clear(true);
2017-07-28 12:39:28 +02:00
mThread->clearFiles();
2016-08-18 21:58:50 +02:00
2017-07-28 12:10:10 +02:00
mUI.mResults->checkingStarted(p.fileSettings.size());
2016-08-18 21:58:50 +02:00
QDir inf(mCurrentDirectory);
const QString checkPath = inf.canonicalPath();
2017-07-28 11:20:35 +02:00
setPath(SETTINGS_LAST_CHECK_PATH, checkPath);
2016-08-18 21:58:50 +02:00
2017-07-28 10:41:03 +02:00
checkLockDownUI(); // lock UI while checking
2016-08-18 21:58:50 +02:00
2017-07-28 12:10:10 +02:00
mUI.mResults->setCheckDirectory(checkPath);
2017-07-28 05:44:15 +02:00
Settings checkSettings = getCppcheckSettings();
checkSettings.force = false;
checkSettings.checkLibrary = checkLibrary;
checkSettings.checkConfiguration = checkConfiguration;
2016-08-18 21:58:50 +02:00
2017-07-31 12:02:51 +02:00
if (mProjectFile)
qDebug() << "Checking project file" << mProjectFile->getFilename();
2016-08-18 21:58:50 +02:00
2016-12-09 20:48:32 +01:00
if (!checkSettings.buildDir.empty()) {
2020-12-19 20:45:51 +01:00
checkSettings.loadSummaries();
2016-12-09 20:48:32 +01:00
std::list<std::string> sourcefiles;
2020-12-19 20:45:51 +01:00
AnalyzerInformation::writeFilesTxt(checkSettings.buildDir, sourcefiles, checkSettings.userDefines, p.fileSettings);
2016-12-09 20:48:32 +01:00
}
//mThread->SetanalyzeProject(true);
if (mProjectFile) {
mThread->setAddonsAndTools(mProjectFile->getAddonsAndTools());
2017-08-13 17:13:24 +02:00
QString clangHeaders = mSettings->value(SETTINGS_VS_INCLUDE_PATHS).toString();
mThread->setClangIncludePaths(clangHeaders.split(";"));
mThread->setSuppressions(mProjectFile->getSuppressions());
}
2017-07-28 12:39:28 +02:00
mThread->setProject(p);
mThread->check(checkSettings);
2016-08-18 21:58:50 +02:00
}
void MainWindow::doAnalyzeFiles(const QStringList &files, const bool checkLibrary, const bool checkConfiguration)
{
2011-10-13 20:53:06 +02:00
if (files.isEmpty()) {
return;
}
2017-07-28 10:41:03 +02:00
clearResults();
mIsLogfileLoaded = false;
FileList pathList;
pathList.addPathList(files);
2017-07-31 12:02:51 +02:00
if (mProjectFile) {
pathList.addExcludeList(mProjectFile->getExcludedPaths());
} else {
2017-07-28 05:44:15 +02:00
enableProjectActions(false);
}
QStringList fileNames = pathList.getFileList();
2017-07-28 12:10:10 +02:00
mUI.mResults->clear(true);
2017-07-28 12:39:28 +02:00
mThread->clearFiles();
2011-10-13 20:53:06 +02:00
if (fileNames.isEmpty()) {
QMessageBox msg(QMessageBox::Warning,
tr("Cppcheck"),
tr("No suitable files found to analyze!"),
QMessageBox::Ok,
this);
msg.exec();
return;
}
2017-07-28 12:10:10 +02:00
mUI.mResults->checkingStarted(fileNames.count());
2017-07-28 12:39:28 +02:00
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();
2017-07-28 11:20:35 +02:00
setPath(SETTINGS_LAST_CHECK_PATH, checkPath);
2017-07-28 10:41:03 +02:00
checkLockDownUI(); // lock UI while checking
2017-07-28 12:10:10 +02:00
mUI.mResults->setCheckDirectory(checkPath);
2017-07-28 05:44:15 +02:00
Settings checkSettings = getCppcheckSettings();
checkSettings.checkLibrary = checkLibrary;
checkSettings.checkConfiguration = checkConfiguration;
2017-07-31 12:02:51 +02:00
if (mProjectFile)
qDebug() << "Checking project file" << mProjectFile->getFilename();
2016-11-19 20:38:50 +01:00
if (!checkSettings.buildDir.empty()) {
2020-12-19 20:45:51 +01:00
checkSettings.loadSummaries();
2016-12-09 20:48:32 +01:00
std::list<std::string> sourcefiles;
foreach (QString s, fileNames)
sourcefiles.push_back(s.toStdString());
2020-12-19 20:45:51 +01:00
AnalyzerInformation::writeFilesTxt(checkSettings.buildDir, sourcefiles, checkSettings.userDefines, checkSettings.project.fileSettings);
2016-11-19 20:38:50 +01:00
}
2017-07-28 12:39:28 +02:00
mThread->setCheckFiles(true);
mThread->check(checkSettings);
}
void MainWindow::analyzeCode(const QString& code, const QString& filename)
{
// Initialize dummy ThreadResult as ErrorLogger
ThreadResult result;
2017-07-28 12:39:28 +02:00
result.setFiles(QStringList(filename));
2017-07-28 13:43:49 +02:00
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 &)));
2017-07-28 13:43:49 +02:00
connect(&result, SIGNAL(debugError(const ErrorItem &)),
mUI.mResults, SLOT(debugError(const ErrorItem &)));
// Create CppCheck instance
CppCheck cppcheck(result, true, nullptr);
2017-07-28 05:44:15 +02:00
cppcheck.settings() = getCppcheckSettings();
// Check
2017-07-28 10:41:03 +02:00
checkLockDownUI();
clearResults();
2017-07-28 12:10:10 +02:00
mUI.mResults->checkingStarted(1);
cppcheck.check(filename.toStdString(), code.toStdString());
analysisDone();
// Expand results
if (mUI.mResults->hasVisibleResults())
mUI.mResults->expandAllResults();
}
QStringList MainWindow::selectFilesToAnalyze(QFileDialog::FileMode mode)
{
2017-07-31 12:02:51 +02:00
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
2012-09-09 13:51:34 +02:00
// selection dialog which is a lot more usable than Qt:s own dialog.
2011-10-13 20:53:06 +02:00
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"),
2017-07-28 11:20:35 +02:00
getPath(SETTINGS_LAST_CHECK_PATH),
toFilterString(filters),
&lastFilter);
mSettings->setValue(SETTINGS_LAST_ANALYZE_FILES_FILTER, lastFilter);
if (selected.isEmpty())
mCurrentDirectory.clear();
2011-10-13 20:53:06 +02:00
else {
QFileInfo inf(selected[0]);
mCurrentDirectory = inf.absolutePath();
}
2017-07-28 05:44:15 +02:00
formatAndSetTitle();
2011-10-13 20:53:06 +02:00
} else if (mode == QFileDialog::DirectoryOnly) {
QString dir = QFileDialog::getExistingDirectory(this,
tr("Select directory to analyze"),
2017-07-28 11:20:35 +02:00
getPath(SETTINGS_LAST_CHECK_PATH));
if (!dir.isEmpty()) {
qDebug() << "Setting current directory to: " << dir;
mCurrentDirectory = dir;
selected.append(dir);
dir = QDir::toNativeSeparators(dir);
2017-07-28 05:44:15 +02:00
formatAndSetTitle(dir);
}
}
2013-02-19 21:39:50 +01:00
2017-07-28 11:20:35 +02:00
setPath(SETTINGS_LAST_CHECK_PATH, mCurrentDirectory);
2013-02-19 21:39:50 +01:00
return selected;
}
2020-08-22 11:37:44 +02:00
void MainWindow::updateFunctionContractsTab()
{
QStringList addedContracts;
if (mProjectFile) {
for (const auto& it: mProjectFile->getFunctionContracts()) {
addedContracts << QString::fromStdString(it.first);
}
}
2020-08-22 11:37:44 +02:00
mUI.mResults->setAddedFunctionContracts(addedContracts);
}
void MainWindow::updateVariableContractsTab()
{
QStringList added;
if (mProjectFile) {
for (auto vc: mProjectFile->getVariableContracts()) {
QString line = vc.first;
if (!vc.second.minValue.empty())
line += " min:" + QString::fromStdString(vc.second.minValue);
if (!vc.second.maxValue.empty())
line += " max:" + QString::fromStdString(vc.second.maxValue);
added << line;
}
}
mUI.mResults->setAddedVariableContracts(added);
}
void MainWindow::analyzeFiles()
{
Settings::terminate(false);
QStringList selected = selectFilesToAnalyze(QFileDialog::ExistingFiles);
2017-08-03 12:39:31 +02:00
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);
}
void MainWindow::analyzeDirectory()
{
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();
2011-10-13 20:53:06 +02:00
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();
2011-10-13 20:53:06 +02:00
if (dlgResult == QMessageBox::Yes) {
QString path = checkDir.canonicalPath();
if (!path.endsWith("/"))
path += "/";
path += projFiles[0];
2017-07-28 05:44:15 +02:00
loadProjectFile(path);
2011-10-13 20:53:06 +02:00
} else {
doAnalyzeFiles(dir);
}
2011-10-13 20:53:06 +02:00
} 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();
2011-10-13 20:53:06 +02:00
if (dlgResult == QMessageBox::Yes) {
doAnalyzeFiles(dir);
}
}
2011-10-13 20:53:06 +02:00
} else {
doAnalyzeFiles(dir);
}
}
2017-07-28 05:44:15 +02:00
void MainWindow::addIncludeDirs(const QStringList &includeDirs, Settings &result)
2010-11-26 21:51:38 +01:00
{
QString dir;
foreach (dir, includeDirs) {
2010-11-26 21:51:38 +01:00
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());
2010-11-26 21:51:38 +01:00
}
}
Library::Error MainWindow::loadLibrary(Library *library, const QString &filename)
{
Library::Error ret;
// Try to load the library from the project folder..
2017-07-31 12:02:51 +02:00
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;
}
bool MainWindow::tryLoadLibrary(Library *library, const QString& filename)
{
2017-07-28 05:44:15 +02:00
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;
2015-12-07 11:24:54 +01:00
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;
}
2017-07-28 05:44:15 +02:00
Settings MainWindow::getCppcheckSettings()
{
2017-07-28 05:44:15 +02:00
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
2017-07-31 12:02:51 +02:00
if (mProjectFile) {
QStringList dirs = mProjectFile->getIncludeDirs();
2017-07-28 05:44:15 +02:00
addIncludeDirs(dirs, result);
2010-11-26 21:51:38 +01:00
2017-07-31 12:02:51 +02:00
const QStringList defines = mProjectFile->getDefines();
2017-07-28 05:08:59 +02:00
foreach (QString define, defines) {
if (!result.userDefines.empty())
result.userDefines += ";";
result.userDefines += define.toStdString();
}
2020-02-02 10:45:42 +01:00
result.clang = mProjectFile->clangParser;
result.bugHunting = mProjectFile->bugHunting;
2020-02-10 20:24:36 +01:00
result.bugHuntingReport = " ";
2020-02-02 10:45:42 +01:00
result.functionContracts = mProjectFile->getFunctionContracts();
for (const auto& vc: mProjectFile->getVariableContracts())
2020-08-22 11:37:44 +02:00
result.variableContracts[vc.first.toStdString()] = vc.second;
const QStringList undefines = mProjectFile->getUndefines();
foreach (QString undefine, undefines)
result.userUndefs.insert(undefine.toStdString());
2017-07-31 12:02:51 +02:00
const QStringList libraries = mProjectFile->getLibraries();
foreach (QString library, libraries) {
const QString filename = library + ".cfg";
2017-07-28 05:44:15 +02:00
tryLoadLibrary(&result.library, filename);
2013-12-29 18:06:31 +01:00
}
foreach (const Suppressions::Suppression &suppression, mProjectFile->getSuppressions()) {
result.nomsg.addSuppression(suppression);
2013-12-30 22:32:50 +01:00
}
// Only check the given -D configuration
if (!defines.isEmpty())
result.maxConfigs = 1;
2016-11-19 20:38:50 +01:00
// If importing a project, only check the given configuration
if (!mProjectFile->getImportProject().isEmpty())
result.checkAllConfigurations = false;
2017-07-31 12:02:51 +02:00
const QString &buildDir = mProjectFile->getBuildDir();
2016-11-19 20:38:50 +01:00
if (!buildDir.isEmpty()) {
if (QDir(buildDir).isAbsolute()) {
result.buildDir = buildDir.toStdString();
} else {
QString prjpath = QFileInfo(mProjectFile->getFilename()).absolutePath();
result.buildDir = (prjpath + '/' + buildDir).toStdString();
}
2016-11-19 20:38:50 +01:00
}
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.maxTemplateRecursion = mProjectFile->getMaxTemplateRecursion();
result.checkHeaders = mProjectFile->getCheckHeaders();
result.checkUnusedTemplates = mProjectFile->getCheckUnusedTemplates();
result.safeChecks.classes = mProjectFile->safeChecks.classes;
result.safeChecks.externalFunctions = mProjectFile->safeChecks.externalFunctions;
result.safeChecks.internalFunctions = mProjectFile->safeChecks.internalFunctions;
result.safeChecks.externalVariables = mProjectFile->safeChecks.externalVariables;
foreach (QString s, mProjectFile->getCheckUnknownFunctionReturn())
result.checkUnknownFunctionReturn.insert(s.toStdString());
QString filesDir(getDataDir());
const QString pythonCmd = mSettings->value(SETTINGS_PYTHON_PATH).toString();
foreach (QString addon, mProjectFile->getAddons()) {
QString addonFilePath = ProjectFile::getAddonFilePath(filesDir, addon);
if (addonFilePath.isEmpty())
continue;
addonFilePath.replace(QChar('\\'), QChar('/'));
QString json;
json += "{ \"script\":\"" + addonFilePath + "\"";
if (!pythonCmd.isEmpty())
json += ", \"python\":\"" + pythonCmd + "\"";
QString misraFile = mSettings->value(SETTINGS_MISRA_FILE).toString();
if (addon == "misra" && !misraFile.isEmpty()) {
QString arg;
if (misraFile.endsWith(".pdf", Qt::CaseInsensitive))
arg = "--misra-pdf=" + misraFile;
else
arg = "--rule-texts=" + misraFile;
json += ", \"args\":[\"" + arg + "\"]";
}
json += " }";
result.addons.push_back(json.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();
2011-10-13 20:53:06 +02:00
if (!globalIncludes.isEmpty()) {
QStringList includes = globalIncludes.split(";");
2017-07-28 05:44:15 +02:00
addIncludeDirs(includes, result);
}
result.addEnabled("warning");
result.addEnabled("style");
result.addEnabled("performance");
result.addEnabled("portability");
result.addEnabled("information");
result.addEnabled("missingInclude");
2016-11-19 20:38:50 +01:00
if (!result.buildDir.empty())
result.addEnabled("unusedFunction");
result.debugwarnings = mSettings->value(SETTINGS_SHOW_DEBUG_WARNINGS, false).toBool();
2015-07-25 19:17:24 +02:00
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;
}
Settings::terminate(false);
return result;
}
void MainWindow::analysisDone()
{
2011-10-13 20:53:06 +02:00
if (mExiting) {
close();
return;
}
2017-07-28 12:10:10 +02:00
mUI.mResults->checkingFinished();
2017-07-28 05:44:15 +02:00
enableCheckButtons(true);
mUI.mActionSettings->setEnabled(true);
mUI.mActionOpenXML->setEnabled(true);
2017-07-31 12:02:51 +02:00
if (mProjectFile) {
2017-07-28 05:44:15 +02:00
enableProjectActions(true);
} else if (mIsLogfileLoaded) {
2017-07-30 09:46:01 +02:00
mUI.mActionReanalyzeModified->setEnabled(false);
mUI.mActionReanalyzeAll->setEnabled(false);
}
2017-07-28 05:44:15 +02:00
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);
2017-07-31 12:02:51 +02:00
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 (QAction* recentProjectAct : mRecentProjectActs) {
if (recentProjectAct != nullptr)
2020-09-21 19:48:04 +02:00
recentProjectAct->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())
2017-07-28 10:41:03 +02:00
showStatistics();
}
2017-07-28 10:41:03 +02:00
void MainWindow::checkLockDownUI()
{
2017-07-28 05:44:15 +02:00
enableCheckButtons(false);
mUI.mActionSettings->setEnabled(false);
mUI.mActionOpenXML->setEnabled(false);
2017-07-28 05:44:15 +02:00
enableProjectActions(false);
enableProjectOpenActions(false);
mPlatformActions->setEnabled(false);
mCStandardActions->setEnabled(false);
mCppStandardActions->setEnabled(false);
mSelectLanguageActions->setEnabled(false);
mUI.mActionPosix->setEnabled(false);
if (mScratchPad)
mScratchPad->setEnabled(false);
for (QAction* recentProjectAct : mRecentProjectActs) {
if (recentProjectAct != nullptr)
2020-09-21 19:48:04 +02:00
recentProjectAct->setEnabled(false);
}
}
2017-07-28 10:41:03 +02:00
void MainWindow::programSettings()
{
SettingsDialog dialog(mApplications, mTranslation, this);
2011-10-13 20:53:06 +02:00
if (dialog.exec() == QDialog::Accepted) {
2017-07-28 13:43:49 +02:00
dialog.saveSettingValues();
mSettings->sync();
2017-07-28 13:43:49 +02:00
mUI.mResults->updateSettings(dialog.showFullPath(),
dialog.saveFullPath(),
dialog.saveAllErrors(),
dialog.showNoErrorsMessage(),
dialog.showErrorId(),
dialog.showInconclusive());
mUI.mResults->updateStyleSetting(mSettings);
const QString newLang = mSettings->value(SETTINGS_LANGUAGE, "en").toString();
2017-07-28 05:44:15 +02:00
setLanguage(newLang);
}
}
void MainWindow::reAnalyzeModified()
{
reAnalyze(false);
}
void MainWindow::reAnalyzeAll()
{
2017-07-31 12:02:51 +02:00
if (mProjectFile)
analyzeProject(mProjectFile);
2017-07-30 23:02:30 +02:00
else
reAnalyze(true);
}
void MainWindow::checkLibrary()
{
if (mProjectFile)
analyzeProject(mProjectFile, true);
}
void MainWindow::checkConfiguration()
{
if (mProjectFile)
analyzeProject(mProjectFile, false, true);
}
void MainWindow::reAnalyzeSelected(QStringList files)
{
if (files.empty())
return;
2017-07-28 12:39:28 +02:00
if (mThread->isChecking())
return;
// Clear details, statistics and progress
2017-07-28 12:10:10 +02:00
mUI.mResults->clear(false);
for (int i = 0; i < files.size(); ++i)
2017-07-28 12:10:10 +02:00
mUI.mResults->clearRecheckFile(files[i]);
2017-07-28 12:10:10 +02:00
mCurrentDirectory = mUI.mResults->getCheckDirectory();
FileList pathList;
pathList.addPathList(files);
2017-07-31 12:02:51 +02:00
if (mProjectFile)
pathList.addExcludeList(mProjectFile->getExcludedPaths());
QStringList fileNames = pathList.getFileList();
2017-07-28 10:41:03 +02:00
checkLockDownUI(); // lock UI while checking
2017-07-28 12:10:10 +02:00
mUI.mResults->checkingStarted(fileNames.size());
2017-07-28 12:39:28 +02:00
mThread->setCheckFiles(fileNames);
// Saving last check start time, otherwise unchecked modified files will not be
// considered in "Modified Files Check" performed after "Selected Files Check"
// TODO: Should we store per file CheckStartTime?
2017-07-28 12:39:28 +02:00
QDateTime saveCheckStartTime = mThread->getCheckStartTime();
mThread->check(getCppcheckSettings());
2017-07-28 12:39:28 +02:00
mThread->setCheckStartTime(saveCheckStartTime);
}
void MainWindow::reAnalyze(bool all)
{
2017-07-28 12:39:28 +02:00
const QStringList files = mThread->getReCheckFiles(all);
if (files.empty())
return;
// Clear details, statistics and progress
2017-07-28 12:10:10 +02:00
mUI.mResults->clear(all);
// Clear results for changed files
for (int i = 0; i < files.size(); ++i)
2017-07-28 12:10:10 +02:00
mUI.mResults->clear(files[i]);
2017-07-28 10:41:03 +02:00
checkLockDownUI(); // lock UI while checking
2017-07-28 12:10:10 +02:00
mUI.mResults->checkingStarted(files.size());
2017-07-31 12:02:51 +02:00
if (mProjectFile)
qDebug() << "Rechecking project file" << mProjectFile->getFilename();
2017-07-28 12:39:28 +02:00
mThread->setCheckFiles(all);
mThread->check(getCppcheckSettings());
}
2017-07-28 10:41:03 +02:00
void MainWindow::clearResults()
{
if (mProjectFile && !mProjectFile->getBuildDir().isEmpty()) {
QDir dir(QFileInfo(mProjectFile->getFilename()).absolutePath() + '/' + mProjectFile->getBuildDir());
for (const QString& f: dir.entryList(QDir::Files)) {
2020-12-19 20:45:51 +01:00
if (!f.endsWith("files.txt") && !QRegExp(".*.s[0-9]+$").exactMatch(f))
dir.remove(f);
}
}
2017-07-28 12:10:10 +02:00
mUI.mResults->clear(true);
Q_ASSERT(false == mUI.mResults->hasResults());
enableResultsButtons();
}
2017-07-28 10:41:03 +02:00
void MainWindow::openResults()
{
2017-07-28 12:10:10 +02:00
if (mUI.mResults->hasResults()) {
QMessageBox msgBox(this);
msgBox.setWindowTitle(tr("Cppcheck"));
const QString msg(tr("Current results will be cleared.\n\n"
2019-07-12 17:55:44 +02:00
"Opening a new XML file will clear current results.\n"
"Do you want to proceed?"));
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::No) {
return;
}
}
QString selectedFilter;
2011-08-22 21:37:38 +02:00
const QString filter(tr("XML files (*.xml)"));
QString selectedFile = QFileDialog::getOpenFileName(this,
tr("Open the report file"),
2017-07-28 11:20:35 +02:00
getPath(SETTINGS_LAST_RESULT_PATH),
filter,
&selectedFilter);
if (!selectedFile.isEmpty()) {
2017-07-28 05:44:15 +02:00
loadResults(selectedFile);
}
}
void MainWindow::loadResults(const QString &selectedFile)
{
2018-02-20 13:10:36 +01:00
if (selectedFile.isEmpty())
return;
if (mProjectFile)
closeProjectFile();
mIsLogfileLoaded = true;
mUI.mResults->clear(true);
mUI.mActionReanalyzeModified->setEnabled(false);
mUI.mActionReanalyzeAll->setEnabled(false);
mUI.mResults->readErrorsXml(selectedFile);
setPath(SETTINGS_LAST_RESULT_PATH, selectedFile);
formatAndSetTitle(selectedFile);
}
void MainWindow::loadResults(const QString &selectedFile, const QString &sourceDirectory)
{
2017-07-28 05:44:15 +02:00
loadResults(selectedFile);
2017-07-28 12:10:10 +02:00
mUI.mResults->setCheckDirectory(sourceDirectory);
}
2017-07-28 05:44:15 +02:00
void MainWindow::enableCheckButtons(bool enable)
{
mUI.mActionStop->setEnabled(!enable);
2017-07-30 09:46:01 +02:00
mUI.mActionAnalyzeFiles->setEnabled(enable);
2017-07-31 12:02:51 +02:00
if (mProjectFile) {
2017-07-30 23:02:30 +02:00
mUI.mActionReanalyzeModified->setEnabled(false);
mUI.mActionReanalyzeAll->setEnabled(enable);
} else if (!enable || mThread->hasPreviousFiles()) {
mUI.mActionReanalyzeModified->setEnabled(enable);
2017-07-30 09:46:01 +02:00
mUI.mActionReanalyzeAll->setEnabled(enable);
}
2017-07-30 09:46:01 +02:00
mUI.mActionAnalyzeDirectory->setEnabled(enable);
}
void MainWindow::enableResultsButtons()
{
bool enabled = mUI.mResults->hasResults();
mUI.mActionClearResults->setEnabled(enabled);
mUI.mActionSave->setEnabled(enabled);
mUI.mActionPrint->setEnabled(enabled);
mUI.mActionPrintPreview->setEnabled(enabled);
}
2017-07-28 10:41:03 +02:00
void MainWindow::showStyle(bool checked)
2009-03-22 18:39:44 +01:00
{
2017-07-28 12:10:10 +02:00
mUI.mResults->showResults(ShowTypes::ShowStyle, checked);
2009-03-22 18:39:44 +01:00
}
2017-07-28 10:41:03 +02:00
void MainWindow::showErrors(bool checked)
2009-03-22 18:39:44 +01:00
{
2017-07-28 12:10:10 +02:00
mUI.mResults->showResults(ShowTypes::ShowErrors, checked);
2009-03-22 18:39:44 +01:00
}
2017-07-28 10:41:03 +02:00
void MainWindow::showWarnings(bool checked)
{
2017-07-28 12:10:10 +02:00
mUI.mResults->showResults(ShowTypes::ShowWarnings, checked);
}
2017-07-28 10:41:03 +02:00
void MainWindow::showPortability(bool checked)
{
2017-07-28 12:10:10 +02:00
mUI.mResults->showResults(ShowTypes::ShowPortability, checked);
}
2017-07-28 10:41:03 +02:00
void MainWindow::showPerformance(bool checked)
{
2017-07-28 12:10:10 +02:00
mUI.mResults->showResults(ShowTypes::ShowPerformance, checked);
}
2017-07-28 10:41:03 +02:00
void MainWindow::showInformation(bool checked)
{
2017-07-28 12:10:10 +02:00
mUI.mResults->showResults(ShowTypes::ShowInformation, checked);
}
2017-07-28 10:41:03 +02:00
void MainWindow::checkAll()
{
2017-07-28 05:44:15 +02:00
toggleAllChecked(true);
}
2017-07-28 10:41:03 +02:00
void MainWindow::uncheckAll()
{
2017-07-28 05:44:15 +02:00
toggleAllChecked(false);
}
void MainWindow::closeEvent(QCloseEvent *event)
{
// Check that we aren't checking files
2017-07-28 12:39:28 +02:00
if (!mThread->isChecking()) {
2017-07-28 05:44:15 +02:00
saveSettings();
event->accept();
2011-10-13 20:53:06 +02:00
} else {
const QString text(tr("Analyzer is running.\n\n" \
"Do you want to stop the analysis and exit Cppcheck?"));
QMessageBox msg(QMessageBox::Warning,
tr("Cppcheck"),
text,
QMessageBox::Yes | QMessageBox::No,
this);
msg.setDefaultButton(QMessageBox::No);
int rv = msg.exec();
2011-10-13 20:53:06 +02:00
if (rv == QMessageBox::Yes) {
// This isn't really very clean way to close threads but since the app is
// exiting it doesn't matter.
2017-07-28 12:39:28 +02:00
mThread->stop();
2017-07-28 05:44:15 +02:00
saveSettings();
mExiting = true;
}
event->ignore();
}
}
2017-07-28 05:44:15 +02:00
void MainWindow::toggleAllChecked(bool checked)
{
mUI.mActionShowStyle->setChecked(checked);
2017-07-28 10:41:03 +02:00
showStyle(checked);
mUI.mActionShowErrors->setChecked(checked);
2017-07-28 10:41:03 +02:00
showErrors(checked);
mUI.mActionShowWarnings->setChecked(checked);
2017-07-28 10:41:03 +02:00
showWarnings(checked);
mUI.mActionShowPortability->setChecked(checked);
2017-07-28 10:41:03 +02:00
showPortability(checked);
mUI.mActionShowPerformance->setChecked(checked);
2017-07-28 10:41:03 +02:00
showPerformance(checked);
mUI.mActionShowInformation->setChecked(checked);
2017-07-28 10:41:03 +02:00
showInformation(checked);
}
2017-07-28 10:41:03 +02:00
void MainWindow::about()
{
AboutDialog *dlg = new AboutDialog(CppCheck::version(), CppCheck::extraVersion(), this);
dlg->exec();
}
2017-07-28 10:41:03 +02:00
void MainWindow::showLicense()
{
FileViewDialog *dlg = new FileViewDialog(":COPYING", tr("License"), this);
dlg->resize(570, 400);
dlg->exec();
}
2017-07-28 10:41:03 +02:00
void MainWindow::showAuthors()
{
FileViewDialog *dlg = new FileViewDialog(":AUTHORS", tr("Authors"), this);
2009-06-14 22:22:19 +02:00
dlg->resize(350, 400);
dlg->exec();
}
void MainWindow::performSelectedFilesCheck(const QStringList &selectedFilesList)
{
reAnalyzeSelected(selectedFilesList);
}
2017-07-28 10:41:03 +02:00
void MainWindow::save()
{
QString selectedFilter;
2017-07-29 19:36:01 +02:00
const QString filter(tr("XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)"));
QString selectedFile = QFileDialog::getSaveFileName(this,
tr("Save the report file"),
2017-07-28 11:20:35 +02:00
getPath(SETTINGS_LAST_RESULT_PATH),
filter,
&selectedFilter);
2011-10-13 20:53:06 +02:00
if (!selectedFile.isEmpty()) {
Report::Type type = Report::TXT;
2017-07-29 19:36:01 +02:00
if (selectedFilter == tr("XML files (*.xml)")) {
type = Report::XMLV2;
if (!selectedFile.endsWith(".xml", Qt::CaseInsensitive))
selectedFile += ".xml";
2011-10-13 20:53:06 +02:00
} else if (selectedFilter == tr("Text files (*.txt)")) {
type = Report::TXT;
if (!selectedFile.endsWith(".txt", Qt::CaseInsensitive))
selectedFile += ".txt";
2011-10-13 20:53:06 +02:00
} else if (selectedFilter == tr("CSV files (*.csv)")) {
type = Report::CSV;
if (!selectedFile.endsWith(".csv", Qt::CaseInsensitive))
selectedFile += ".csv";
2011-10-13 20:53:06 +02:00
} else {
if (selectedFile.endsWith(".xml", Qt::CaseInsensitive))
2017-07-29 19:36:01 +02:00
type = Report::XMLV2;
else if (selectedFile.endsWith(".txt", Qt::CaseInsensitive))
type = Report::TXT;
else if (selectedFile.endsWith(".csv", Qt::CaseInsensitive))
type = Report::CSV;
}
2017-07-28 12:10:10 +02:00
mUI.mResults->save(selectedFile, type);
2017-07-28 11:20:35 +02:00
setPath(SETTINGS_LAST_RESULT_PATH, selectedFile);
}
}
2017-07-28 10:41:03 +02:00
void MainWindow::resultsAdded()
{
}
2017-07-28 10:41:03 +02:00
void MainWindow::toggleMainToolBar()
{
mUI.mToolBarMain->setVisible(mUI.mActionToolBarMain->isChecked());
}
2017-07-28 10:41:03 +02:00
void MainWindow::toggleViewToolBar()
{
mUI.mToolBarView->setVisible(mUI.mActionToolBarView->isChecked());
}
2017-07-28 10:41:03 +02:00
void MainWindow::toggleFilterToolBar()
{
mUI.mToolBarFilter->setVisible(mUI.mActionToolBarFilter->isChecked());
mLineEditFilter->clear(); // Clearing the filter also disables filtering
}
2017-07-28 05:44:15 +02:00
void MainWindow::formatAndSetTitle(const QString &text)
{
QString nameWithVersion = QString("Cppcheck %1").arg(CppCheck::version());
QString extraVersion = CppCheck::extraVersion();
if (!extraVersion.isEmpty()) {
nameWithVersion += " (" + extraVersion + ")";
}
QString title;
if (text.isEmpty())
title = nameWithVersion;
else
title = QString("%1 - %2").arg(nameWithVersion, text);
setWindowTitle(title);
}
2017-07-28 05:44:15 +02:00
void MainWindow::setLanguage(const QString &code)
{
2017-07-28 13:43:49 +02:00
const QString currentLang = mTranslation->getCurrentLanguage();
if (currentLang == code)
return;
2017-07-28 13:43:49 +02:00
if (mTranslation->setLanguage(code)) {
2009-07-02 12:48:32 +02:00
//Translate everything that is visible here
mUI.retranslateUi(this);
2017-07-28 12:10:10 +02:00
mUI.mResults->translate();
}
}
2017-07-28 10:41:03 +02:00
void MainWindow::aboutToShowViewMenu()
{
mUI.mActionToolBarMain->setChecked(mUI.mToolBarMain->isVisible());
mUI.mActionToolBarView->setChecked(mUI.mToolBarView->isVisible());
mUI.mActionToolBarFilter->setChecked(mUI.mToolBarFilter->isVisible());
}
void MainWindow::stopAnalysis()
{
2017-07-28 12:39:28 +02:00
mThread->stop();
2017-07-28 12:10:10 +02:00
mUI.mResults->disableProgressbar();
const QString &lastResults = getLastResults();
if (!lastResults.isEmpty()) {
mUI.mResults->updateFromOldReport(lastResults);
}
}
2017-07-28 10:41:03 +02:00
void MainWindow::openHelpContents()
{
2017-07-28 05:44:15 +02:00
openOnlineHelp();
}
2017-07-28 05:44:15 +02:00
void MainWindow::openOnlineHelp()
{
HelpDialog *helpDialog = new HelpDialog;
helpDialog->showMaximized();
}
2017-07-28 10:41:03 +02:00
void MainWindow::openProjectFile()
{
const QString filter = tr("Project files (*.cppcheck);;All files(*.*)");
const QString filepath = QFileDialog::getOpenFileName(this,
tr("Select Project File"),
2017-07-28 11:20:35 +02:00
getPath(SETTINGS_LAST_PROJECT_PATH),
filter);
2011-10-13 20:53:06 +02:00
if (!filepath.isEmpty()) {
const QFileInfo fi(filepath);
if (fi.exists() && fi.isFile() && fi.isReadable()) {
2017-07-28 11:20:35 +02:00
setPath(SETTINGS_LAST_PROJECT_PATH, filepath);
2017-07-28 05:44:15 +02:00
loadProjectFile(filepath);
}
}
}
2017-07-28 10:41:03 +02:00
void MainWindow::showScratchpad()
{
if (!mScratchPad)
mScratchPad = new ScratchPad(*this);
mScratchPad->show();
if (!mScratchPad->isActiveWindow())
mScratchPad->activateWindow();
}
2017-07-28 05:44:15 +02:00
void MainWindow::loadProjectFile(const QString &filePath)
{
QFileInfo inf(filePath);
const QString filename = inf.fileName();
formatAndSetTitle(tr("Project:") + ' ' + filename);
2017-07-28 05:44:15 +02:00
addProjectMRU(filePath);
mIsLogfileLoaded = false;
mUI.mActionCloseProjectFile->setEnabled(true);
mUI.mActionEditProjectFile->setEnabled(true);
2017-07-31 12:02:51 +02:00
delete mProjectFile;
mProjectFile = new ProjectFile(filePath, this);
2020-07-15 13:03:07 +02:00
mProjectFile->setActiveProject();
2020-08-22 11:37:44 +02:00
mUI.mResults->showContracts(mProjectFile->bugHunting);
updateFunctionContractsTab();
updateVariableContractsTab();
if (!loadLastResults())
2017-07-31 12:02:51 +02:00
analyzeProject(mProjectFile);
}
QString MainWindow::getLastResults() const
{
if (!mProjectFile || mProjectFile->getBuildDir().isEmpty())
return QString();
return QFileInfo(mProjectFile->getFilename()).absolutePath() + '/' + mProjectFile->getBuildDir() + "/lastResults.xml";
}
bool MainWindow::loadLastResults()
{
const QString &lastResults = getLastResults();
if (lastResults.isEmpty())
return false;
if (!QFileInfo(lastResults).exists())
return false;
mUI.mResults->readErrorsXml(lastResults);
2017-09-23 15:11:42 +02:00
mUI.mResults->setCheckDirectory(mSettings->value(SETTINGS_LAST_CHECK_PATH,QString()).toString());
mUI.mActionViewStats->setEnabled(true);
enableResultsButtons();
return true;
}
void MainWindow::analyzeProject(const ProjectFile *projectFile, const bool checkLibrary, const bool checkConfiguration)
{
Settings::terminate(false);
2017-07-31 12:02:51 +02:00
QFileInfo inf(projectFile->getFilename());
const QString rootpath = projectFile->getRootPath();
2018-07-01 08:00:05 +02:00
QDir::setCurrent(inf.absolutePath());
mThread->setAddonsAndTools(projectFile->getAddonsAndTools());
// If the root path is not given or is not "current dir", use project
// file's location directory as root path
if (rootpath.isEmpty() || rootpath == ".")
mCurrentDirectory = inf.canonicalPath();
else if (rootpath.startsWith("./"))
mCurrentDirectory = inf.canonicalPath() + rootpath.mid(1);
else
mCurrentDirectory = rootpath;
2017-07-31 12:02:51 +02:00
if (!projectFile->getBuildDir().isEmpty()) {
QString buildDir = projectFile->getBuildDir();
if (!QDir::isAbsolutePath(buildDir))
buildDir = inf.canonicalPath() + '/' + buildDir;
if (!QDir(buildDir).exists()) {
QMessageBox msg(QMessageBox::Critical,
tr("Cppcheck"),
tr("Build dir '%1' does not exist, create it?").arg(buildDir),
QMessageBox::Yes | QMessageBox::No,
this);
if (msg.exec() == QMessageBox::Yes) {
QDir().mkpath(buildDir);
}
}
}
2017-07-31 12:02:51 +02:00
if (!projectFile->getImportProject().isEmpty()) {
2016-08-18 21:58:50 +02:00
ImportProject p;
QString prjfile;
2018-03-06 22:51:06 +01:00
if (QFileInfo(projectFile->getImportProject()).isAbsolute()) {
prjfile = projectFile->getImportProject();
2018-03-06 22:51:06 +01:00
} else {
prjfile = inf.canonicalPath() + '/' + projectFile->getImportProject();
}
2017-09-02 11:11:35 +02:00
try {
p.import(prjfile.toStdString());
} catch (InternalError &e) {
QMessageBox msg(QMessageBox::Critical,
tr("Cppcheck"),
tr("Failed to import '%1', analysis is stopped").arg(prjfile),
QMessageBox::Ok,
this);
msg.exec();
return;
}
doAnalyzeProject(p, checkLibrary, checkConfiguration);
2016-08-18 21:58:50 +02:00
return;
}
2017-07-31 12:02:51 +02:00
QStringList paths = projectFile->getCheckPaths();
// If paths not given then check the root path (which may be the project
// file's location, see above). This is to keep the compatibility with
// old "silent" project file loading when we checked the director where the
// project file was located.
2011-10-13 20:53:06 +02:00
if (paths.isEmpty()) {
paths << mCurrentDirectory;
}
doAnalyzeFiles(paths, checkLibrary, checkConfiguration);
}
2017-07-28 10:41:03 +02:00
void MainWindow::newProjectFile()
{
const QString filter = tr("Project files (*.cppcheck)");
QString filepath = QFileDialog::getSaveFileName(this,
tr("Select Project Filename"),
2017-07-28 11:20:35 +02:00
getPath(SETTINGS_LAST_PROJECT_PATH),
filter);
if (filepath.isEmpty())
return;
if (!filepath.endsWith(".cppcheck", Qt::CaseInsensitive))
filepath += ".cppcheck";
2013-02-09 19:36:48 +01:00
2017-07-28 11:20:35 +02:00
setPath(SETTINGS_LAST_PROJECT_PATH, filepath);
2013-02-19 21:39:50 +01:00
QFileInfo inf(filepath);
const QString filename = inf.fileName();
2017-07-28 05:44:15 +02:00
formatAndSetTitle(tr("Project:") + QString(" ") + filename);
2017-07-31 12:02:51 +02:00
delete mProjectFile;
mProjectFile = new ProjectFile(this);
2020-07-15 13:03:07 +02:00
mProjectFile->setActiveProject();
mProjectFile->setFilename(filepath);
mProjectFile->setBuildDir(filename.left(filename.indexOf(".")) + "-cppcheck-build-dir");
2017-07-31 12:02:51 +02:00
ProjectFileDialog dlg(mProjectFile, this);
2017-07-31 12:02:51 +02:00
if (dlg.exec() == QDialog::Accepted) {
2017-07-28 05:44:15 +02:00
addProjectMRU(filepath);
2020-08-22 11:37:44 +02:00
mUI.mResults->showContracts(mProjectFile->bugHunting);
2017-07-31 12:02:51 +02:00
analyzeProject(mProjectFile);
} else {
closeProjectFile();
}
2020-08-22 11:37:44 +02:00
updateFunctionContractsTab();
updateVariableContractsTab();
}
2017-07-28 10:41:03 +02:00
void MainWindow::closeProjectFile()
{
2017-07-31 12:02:51 +02:00
delete mProjectFile;
mProjectFile = nullptr;
mUI.mResults->clear(true);
2020-08-22 11:37:44 +02:00
mUI.mResults->clearContracts();
mUI.mResults->showContracts(false);
2017-07-28 05:44:15 +02:00
enableProjectActions(false);
enableProjectOpenActions(true);
formatAndSetTitle();
}
2017-07-28 10:41:03 +02:00
void MainWindow::editProjectFile()
{
2017-07-31 12:02:51 +02:00
if (!mProjectFile) {
QMessageBox msg(QMessageBox::Critical,
tr("Cppcheck"),
QString(tr("No project file loaded")),
QMessageBox::Ok,
this);
msg.exec();
return;
}
2017-07-31 12:02:51 +02:00
ProjectFileDialog dlg(mProjectFile, this);
2017-07-31 12:02:51 +02:00
if (dlg.exec() == QDialog::Accepted) {
mProjectFile->write();
2020-08-22 11:37:44 +02:00
mUI.mResults->showContracts(mProjectFile->bugHunting);
2017-07-31 12:02:51 +02:00
analyzeProject(mProjectFile);
}
}
2017-07-28 10:41:03 +02:00
void MainWindow::showStatistics()
{
StatsDialog statsDialog(this);
// Show a dialog with the previous scan statistics and project information
2017-07-31 12:02:51 +02:00
statsDialog.setProject(mProjectFile);
statsDialog.setPathSelected(mCurrentDirectory);
2017-07-28 12:39:28 +02:00
statsDialog.setNumberOfFilesScanned(mThread->getPreviousFilesCount());
statsDialog.setScanDuration(mThread->getPreviousScanDuration() / 1000.0);
2017-07-28 12:10:10 +02:00
statsDialog.setStatistics(mUI.mResults->getStatistics());
statsDialog.exec();
}
2017-07-28 10:41:03 +02:00
void MainWindow::showLibraryEditor()
2015-08-16 17:36:10 +02:00
{
2015-09-04 20:46:26 +02:00
LibraryDialog libraryDialog(this);
libraryDialog.exec();
2015-08-16 17:36:10 +02:00
}
2017-07-28 10:41:03 +02:00
void MainWindow::filterResults()
{
2017-07-28 12:10:10 +02:00
mUI.mResults->filterResults(mLineEditFilter->text());
}
2017-07-28 05:44:15 +02:00
void MainWindow::enableProjectActions(bool enable)
{
mUI.mActionCloseProjectFile->setEnabled(enable);
mUI.mActionEditProjectFile->setEnabled(enable);
mUI.mActionCheckLibrary->setEnabled(enable);
mUI.mActionCheckConfiguration->setEnabled(enable);
}
2017-07-28 05:44:15 +02:00
void MainWindow::enableProjectOpenActions(bool enable)
{
mUI.mActionNewProjectFile->setEnabled(enable);
mUI.mActionOpenProjectFile->setEnabled(enable);
}
2017-07-28 10:41:03 +02:00
void MainWindow::openRecentProject()
{
QAction *action = qobject_cast<QAction *>(sender());
2018-08-08 09:00:04 +02:00
if (!action)
return;
const QString project = action->data().toString();
QFileInfo inf(project);
if (inf.exists()) {
if (inf.suffix() == "xml")
loadResults(project);
else {
loadProjectFile(project);
loadLastResults();
}
2018-08-08 09:00:04 +02:00
} else {
const QString text(tr("The project file\n\n%1\n\n could not be found!\n\n"
"Do you want to remove the file from the recently "
"used projects -list?").arg(project));
2018-08-08 09:00:04 +02:00
QMessageBox msg(QMessageBox::Warning,
tr("Cppcheck"),
text,
QMessageBox::Yes | QMessageBox::No,
this);
2018-08-08 09:00:04 +02:00
msg.setDefaultButton(QMessageBox::No);
int rv = msg.exec();
if (rv == QMessageBox::Yes) {
removeProjectMRU(project);
}
}
}
2017-07-28 05:44:15 +02:00
void MainWindow::updateMRUMenuItems()
{
for (QAction* recentProjectAct : mRecentProjectActs) {
if (recentProjectAct != nullptr)
mUI.mMenuFile->removeAction(recentProjectAct);
}
QStringList projects = mSettings->value(SETTINGS_MRU_PROJECTS).toStringList();
// Do a sanity check - remove duplicates and non-existing projects
int removed = projects.removeDuplicates();
for (int i = projects.size() - 1; i >= 0; i--) {
if (!QFileInfo(projects[i]).exists()) {
projects.removeAt(i);
removed++;
}
}
if (removed)
mSettings->setValue(SETTINGS_MRU_PROJECTS, projects);
const int numRecentProjects = qMin(projects.size(), (int)MaxRecentProjects);
2011-10-13 20:53:06 +02:00
for (int i = 0; i < numRecentProjects; i++) {
const QString filename = QFileInfo(projects[i]).fileName();
const QString text = QString("&%1 %2").arg(i + 1).arg(filename);
mRecentProjectActs[i]->setText(text);
mRecentProjectActs[i]->setData(projects[i]);
mRecentProjectActs[i]->setVisible(true);
mUI.mMenuFile->insertAction(mUI.mActionProjectMRU, mRecentProjectActs[i]);
}
if (numRecentProjects > 1)
mRecentProjectActs[numRecentProjects] = mUI.mMenuFile->insertSeparator(mUI.mActionProjectMRU);
}
2017-07-28 05:44:15 +02:00
void MainWindow::addProjectMRU(const QString &project)
{
QStringList files = mSettings->value(SETTINGS_MRU_PROJECTS).toStringList();
files.removeAll(project);
files.prepend(project);
while (files.size() > MaxRecentProjects)
files.removeLast();
mSettings->setValue(SETTINGS_MRU_PROJECTS, files);
2017-07-28 05:44:15 +02:00
updateMRUMenuItems();
}
2017-07-28 05:44:15 +02:00
void MainWindow::removeProjectMRU(const QString &project)
{
QStringList files = mSettings->value(SETTINGS_MRU_PROJECTS).toStringList();
files.removeAll(project);
mSettings->setValue(SETTINGS_MRU_PROJECTS, files);
2017-07-28 05:44:15 +02:00
updateMRUMenuItems();
}
2017-07-28 10:41:03 +02:00
void MainWindow::selectPlatform()
{
QAction *action = qobject_cast<QAction *>(sender());
2011-10-13 20:53:06 +02:00
if (action) {
const Settings::PlatformType platform = (Settings::PlatformType) action->data().toInt();
mSettings->setValue(SETTINGS_CHECKED_PLATFORM, platform);
}
}
2017-08-11 07:45:29 +02:00
void MainWindow::suppressIds(QStringList ids)
{
if (!mProjectFile)
return;
ids.removeDuplicates();
QList<Suppressions::Suppression> suppressions = mProjectFile->getSuppressions();
foreach (QString id, ids) {
// Remove all matching suppressions
std::string id2 = id.toStdString();
for (int i = 0; i < suppressions.size();) {
if (suppressions[i].errorId == id2)
suppressions.removeAt(i);
else
++i;
2017-08-11 07:45:29 +02:00
}
Suppressions::Suppression newSuppression;
newSuppression.errorId = id2;
suppressions << newSuppression;
2017-08-11 07:45:29 +02:00
}
mProjectFile->setSuppressions(suppressions);
mProjectFile->write();
2017-08-11 07:45:29 +02:00
}
void MainWindow::editFunctionContract(QString function)
{
if (!mProjectFile)
return;
QString expects;
const auto it = mProjectFile->getFunctionContracts().find(function.toStdString());
if (it != mProjectFile->getFunctionContracts().end())
expects = QString::fromStdString(it->second);
FunctionContractDialog dlg(nullptr,
function,
expects);
if (dlg.exec() == QDialog::Accepted) {
mProjectFile->setFunctionContract(function, dlg.getExpects());
mProjectFile->write();
}
2020-08-22 11:37:44 +02:00
updateFunctionContractsTab();
}
void MainWindow::editVariableContract(QString var)
{
if (!mProjectFile)
return;
VariableContractsDialog dlg(nullptr, var);
if (dlg.exec() == QDialog::Accepted) {
mProjectFile->setVariableContracts(dlg.getVarname(), dlg.getMin(), dlg.getMax());
mProjectFile->write();
}
updateVariableContractsTab();
}
void MainWindow::deleteFunctionContract(QString function)
{
if (mProjectFile) {
mProjectFile->deleteFunctionContract(function);
mProjectFile->write();
}
}
void MainWindow::deleteVariableContract(QString var)
{
if (mProjectFile) {
mProjectFile->deleteVariableContract(var);
mProjectFile->write();
}
}