{

const int count = list->count();

QStringList paths;

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

QListWidgetItem *item = list->item(i);

paths << QDir::fromNativeSeparators(item->text());

}

return paths;

{

QStringList ret;

ImportProject importer;

Settings projSettings;

importer.import(fileName.toStdString(), &projSettings);

for (const std::string &cfg : importer.getVSConfigs())

ret << QString::fromStdString(cfg);

return ret;

: QDialog(parent)

, mProjectFile(projectFile)

{

mUI.setupUi(this);

mUI.mToolClangAnalyzer->hide();

const QFileInfo inf(projectFile->getFilename());

QString filename = inf.fileName();

QString title = tr("Project file: %1").arg(filename);

setWindowTitle(title);

loadSettings();

// Checkboxes for the libraries..

const QString applicationFilePath = QCoreApplication::applicationFilePath();

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

QSettings settings;

const QString datadir = settings.value("DATADIR",QString()).toString();

QStringList searchPaths;

searchPaths << appPath << appPath + "/cfg" << inf.canonicalPath();

#ifdef FILESDIR

if (FILESDIR[0])

searchPaths << FILESDIR << FILESDIR "/cfg";

#endif

if (!datadir.isEmpty())

searchPaths << datadir << datadir + "/cfg";

QStringList libs;

// Search the std.cfg first since other libraries could depend on it

QString stdLibraryFilename;

foreach (const QString sp, searchPaths) {

QDir dir(sp);

dir.setSorting(QDir::Name);

dir.setNameFilters(QStringList("*.cfg"));

dir.setFilter(QDir::Files | QDir::NoDotAndDotDot);

foreach (QFileInfo item, dir.entryInfoList()) {

QString library = item.fileName();

if (library.compare("std.cfg", Qt::CaseInsensitive) != 0)

continue;

Library lib;

const QString fullfilename = sp + "/" + library;

const Library::Error err = lib.load(nullptr, fullfilename.toLatin1());

if (err.errorcode != Library::OK)

continue;

// Working std.cfg found

stdLibraryFilename = fullfilename;

break;

}

if (!stdLibraryFilename.isEmpty())

break;

}

// Search other libraries

foreach (const QString sp, searchPaths) {

QDir dir(sp);

dir.setSorting(QDir::Name);

dir.setNameFilters(QStringList("*.cfg"));

dir.setFilter(QDir::Files | QDir::NoDotAndDotDot);

foreach (QFileInfo item, dir.entryInfoList()) {

QString library = item.fileName();

{

Library lib;

const QString fullfilename = sp + "/" + library;

Library::Error err = lib.load(nullptr, fullfilename.toLatin1());

if (err.errorcode != Library::OK) {

// Some libraries depend on std.cfg so load it first and test again

lib.load(nullptr, stdLibraryFilename.toLatin1());

err = lib.load(nullptr, fullfilename.toLatin1());

}

if (err.errorcode != Library::OK)

continue;

}

library.chop(4);

if (library.compare("std", Qt::CaseInsensitive) == 0)

continue;

if (libs.indexOf(library) == -1)

libs << library;

}

}

libs.sort();

mUI.mLibraries->clear();

for (const QString &lib : libs) {

QListWidgetItem* item = new QListWidgetItem(lib, mUI.mLibraries);

item->setFlags(item->flags() | Qt::ItemIsUserCheckable); // set checkable flag

item->setCheckState(Qt::Unchecked); // AND initialize check state

}

// Platforms..

Platforms platforms;

for (int i = 0; i < numberOfBuiltinPlatforms; i++)

mUI.mComboBoxPlatform->addItem(platforms.get(builtinPlatforms[i]).mTitle);

QStringList platformFiles;

foreach (QString sp, searchPaths) {

if (sp.endsWith("/cfg"))

sp = sp.mid(0,sp.length()-3) + "platforms";

QDir dir(sp);

dir.setSorting(QDir::Name);

dir.setNameFilters(QStringList("*.xml"));

dir.setFilter(QDir::Files | QDir::NoDotAndDotDot);

foreach (QFileInfo item, dir.entryInfoList()) {

const QString platformFile = item.fileName();

cppcheck::Platform plat2;

if (!plat2.loadPlatformFile(applicationFilePath.toStdString().c_str(), platformFile.toStdString()))

continue;

if (platformFiles.indexOf(platformFile) == -1)

platformFiles << platformFile;

}

}

platformFiles.sort();

mUI.mComboBoxPlatform->addItems(platformFiles);

mUI.mEditTags->setValidator(new QRegExpValidator(QRegExp("[a-zA-Z0-9 ;]*"),this));

const QRegExp undefRegExp("\\s*([a-zA-Z_][a-zA-Z0-9_]*[; ]*)*");

mUI.mEditUndefines->setValidator(new QRegExpValidator(undefRegExp, this));

connect(mUI.mButtons, &QDialogButtonBox::accepted, this, &ProjectFileDialog::ok);

connect(mUI.mBtnBrowseBuildDir, &QPushButton::clicked, this, &ProjectFileDialog::browseBuildDir);

connect(mUI.mBtnClearImportProject, &QPushButton::clicked, this, &ProjectFileDialog::clearImportProject);

connect(mUI.mBtnBrowseImportProject, &QPushButton::clicked, this, &ProjectFileDialog::browseImportProject);

connect(mUI.mBtnAddCheckPath, SIGNAL(clicked()), this, SLOT(addCheckPath()));

connect(mUI.mBtnEditCheckPath, &QPushButton::clicked, this, &ProjectFileDialog::editCheckPath);

connect(mUI.mBtnRemoveCheckPath, &QPushButton::clicked, this, &ProjectFileDialog::removeCheckPath);

connect(mUI.mBtnAddInclude, SIGNAL(clicked()), this, SLOT(addIncludeDir()));

connect(mUI.mBtnEditInclude, &QPushButton::clicked, this, &ProjectFileDialog::editIncludeDir);

connect(mUI.mBtnRemoveInclude, &QPushButton::clicked, this, &ProjectFileDialog::removeIncludeDir);

connect(mUI.mBtnAddIgnorePath, SIGNAL(clicked()), this, SLOT(addExcludePath()));

connect(mUI.mBtnEditIgnorePath, &QPushButton::clicked, this, &ProjectFileDialog::editExcludePath);

connect(mUI.mBtnRemoveIgnorePath, &QPushButton::clicked, this, &ProjectFileDialog::removeExcludePath);

connect(mUI.mBtnIncludeUp, &QPushButton::clicked, this, &ProjectFileDialog::moveIncludePathUp);

connect(mUI.mBtnIncludeDown, &QPushButton::clicked, this, &ProjectFileDialog::moveIncludePathDown);

connect(mUI.mBtnAddSuppression, &QPushButton::clicked, this, &ProjectFileDialog::addSuppression);

connect(mUI.mBtnRemoveSuppression, &QPushButton::clicked, this, &ProjectFileDialog::removeSuppression);

connect(mUI.mListSuppressions, &QListWidget::doubleClicked, this, &ProjectFileDialog::editSuppression);

connect(mUI.mBtnBrowseMisraFile, &QPushButton::clicked, this, &ProjectFileDialog::browseMisraFile);

connect(mUI.mChkAllVsConfigs, &QCheckBox::clicked, this, &ProjectFileDialog::checkAllVSConfigs);

loadFromProjectFile(projectFile);

{

QSettings settings;

resize(settings.value(SETTINGS_PROJECT_DIALOG_WIDTH, 470).toInt(),

settings.value(SETTINGS_PROJECT_DIALOG_HEIGHT, 330).toInt());

{

QSettings settings;

settings.setValue(SETTINGS_PROJECT_DIALOG_WIDTH, size().width());

settings.setValue(SETTINGS_PROJECT_DIALOG_HEIGHT, size().height());

{

if (projectFile)

cb->setChecked(projectFile->getAddons().contains(addon));

if (CheckThread::getAddonFilePath(dataDir, addon + ".py").isEmpty()) {

cb->setEnabled(false);

cb->setText(cb->text() + QObject::tr(" (Not found)"));

}

{

if (mUI.mChkAllVsConfigs->isChecked())

mUI.mListVsConfigs->selectAll();

mUI.mListVsConfigs->setEnabled(!mUI.mChkAllVsConfigs->isChecked());

{

setRootPath(projectFile->getRootPath());

setBuildDir(projectFile->getBuildDir());

setIncludepaths(projectFile->getIncludeDirs());

setDefines(projectFile->getDefines());

setUndefines(projectFile->getUndefines());

setCheckPaths(projectFile->getCheckPaths());

setImportProject(projectFile->getImportProject());

mUI.mChkAllVsConfigs->setChecked(projectFile->getAnalyzeAllVsConfigs());

mUI.mCheckHeaders->setChecked(projectFile->getCheckHeaders());

mUI.mCheckUnusedTemplates->setChecked(projectFile->getCheckUnusedTemplates());

mUI.mMaxCtuDepth->setValue(projectFile->getMaxCtuDepth());

if (projectFile->clangParser)

mUI.mBtnClangParser->setChecked(true);

else

mUI.mBtnCppcheckParser->setChecked(true);

mUI.mBtnSafeClasses->setChecked(projectFile->safeChecks.classes);

mUI.mBugHunting->setChecked(projectFile->bugHunting);

setExcludedPaths(projectFile->getExcludedPaths());

setLibraries(projectFile->getLibraries());

const QString platform = projectFile->getPlatform();

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

int i;

for (i = numberOfBuiltinPlatforms; i < mUI.mComboBoxPlatform->count(); ++i) {

if (mUI.mComboBoxPlatform->itemText(i) == platform)

break;

}

if (i < mUI.mComboBoxPlatform->count())

mUI.mComboBoxPlatform->setCurrentIndex(i);

else {

mUI.mComboBoxPlatform->addItem(platform);

mUI.mComboBoxPlatform->setCurrentIndex(i);

}

} else {

int i;

for (i = 0; i < numberOfBuiltinPlatforms; ++i) {

const cppcheck::Platform::PlatformType p = builtinPlatforms[i];

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

break;

}

if (i < numberOfBuiltinPlatforms)

mUI.mComboBoxPlatform->setCurrentIndex(i);

else

mUI.mComboBoxPlatform->setCurrentIndex(-1);

}

mUI.mComboBoxPlatform->setCurrentText(projectFile->getPlatform());

setSuppressions(projectFile->getSuppressions());

// Human knowledge..

/*

// Addons..

QSettings settings;

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

updateAddonCheckBox(mUI.mAddonThreadSafety, projectFile, dataDir, "threadsafety");

updateAddonCheckBox(mUI.mAddonY2038, projectFile, dataDir, "y2038");

updateAddonCheckBox(mUI.mAddonCert, projectFile, dataDir, "cert");

updateAddonCheckBox(mUI.mAddonMisra, projectFile, dataDir, "misra");

const QString &misraFile = settings.value(SETTINGS_MISRA_FILE, QString()).toString();

mUI.mEditMisraFile->setText(misraFile);

if (!mUI.mAddonMisra->isEnabled()) {

mUI.mEditMisraFile->setEnabled(false);

mUI.mBtnBrowseMisraFile->setEnabled(false);

} else if (misraFile.isEmpty()) {

mUI.mAddonMisra->setEnabled(false);

mUI.mAddonMisra->setText(mUI.mAddonMisra->text() + ' ' + tr("(no rule texts file)"));

}

mUI.mToolClangAnalyzer->setChecked(projectFile->getClangAnalyzer());

mUI.mToolClangTidy->setChecked(projectFile->getClangTidy());

if (CheckThread::clangTidyCmd().isEmpty()) {

mUI.mToolClangTidy->setText(tr("Clang-tidy (not found)"));

mUI.mToolClangTidy->setEnabled(false);

}

mUI.mEditTags->setText(projectFile->getTags().join(';'));

updatePathsAndDefines();

if (mUI.mEditImportProject->text().endsWith(".sln") || mUI.mEditImportProject->text().endsWith(".vcxproj")) {

setVsConfigurations(getProjectConfigs(mUI.mEditImportProject->text()));

foreach (const QString &cfg, projectFile->getVsConfigurations()) {

QList<QListWidgetItem*> items = mUI.mListVsConfigs->findItems(cfg, Qt::MatchFlag::MatchExactly);

items[0]->setSelected(true);

}

} else {

mUI.mListVsConfigs->clear();

mUI.mListVsConfigs->setEnabled(false);

}

{

projectFile->setRootPath(getRootPath());

projectFile->setBuildDir(getBuildDir());

projectFile->setImportProject(getImportProject());

projectFile->setAnalyzeAllVsConfigs(mUI.mChkAllVsConfigs->isChecked());

projectFile->setCheckHeaders(mUI.mCheckHeaders->isChecked());

projectFile->setCheckUnusedTemplates(mUI.mCheckUnusedTemplates->isChecked());

projectFile->setMaxCtuDepth(mUI.mMaxCtuDepth->value());

projectFile->setIncludes(getIncludePaths());

projectFile->setDefines(getDefines());

projectFile->setUndefines(getUndefines());

projectFile->setCheckPaths(getCheckPaths());

projectFile->setExcludedPaths(getExcludedPaths());

projectFile->setLibraries(getLibraries());

projectFile->clangParser = mUI.mBtnClangParser->isChecked();

projectFile->safeChecks.classes = mUI.mBtnSafeClasses->isChecked();

projectFile->bugHunting = mUI.mBugHunting->isChecked();

if (mUI.mComboBoxPlatform->currentText().endsWith(".xml"))

projectFile->setPlatform(mUI.mComboBoxPlatform->currentText());

else {

int i = mUI.mComboBoxPlatform->currentIndex();

if (i < numberOfBuiltinPlatforms)

projectFile->setPlatform(cppcheck::Platform::platformString(builtinPlatforms[i]));

else

projectFile->setPlatform(QString());

}

projectFile->setSuppressions(getSuppressions());

// Human knowledge

/*

// Addons

QStringList list;

if (mUI.mAddonThreadSafety->isChecked())

list << "threadsafety";

if (mUI.mAddonY2038->isChecked())

list << "y2038";

if (mUI.mAddonCert->isChecked())

list << "cert";

if (mUI.mAddonMisra->isChecked())

list << "misra";

projectFile->setAddons(list);

projectFile->setClangAnalyzer(mUI.mToolClangAnalyzer->isChecked());

projectFile->setClangTidy(mUI.mToolClangTidy->isChecked());

projectFile->setTags(mUI.mEditTags->text().split(";", QString::SkipEmptyParts));

projectFile->setVSConfigurations(getVsConfigurations());

{

saveToProjectFile(mProjectFile);

mProjectFile->write();

accept();

{

const QFileInfo inf(mProjectFile->getFilename());

const QString rootpath = inf.absolutePath();

QString selectedDir = QFileDialog::getExistingDirectory(this,

caption,

rootpath);

if (selectedDir.isEmpty())

return QString();

// Check if the path is relative to project file's path and if so

// make it a relative path instead of absolute path.

const QDir dir(rootpath);

const QString relpath(dir.relativeFilePath(selectedDir));

if (!relpath.startsWith("../.."))

selectedDir = relpath;

// Trailing slash..

if (trailingSlash && !selectedDir.endsWith('/'))

selectedDir += '/';

return selectedDir;

{

const QString dir(getExistingDirectory(tr("Select Cppcheck build dir"), false));

if (!dir.isEmpty())

mUI.mEditBuildDir->setText(dir);

{

const QString &fileName = mUI.mEditImportProject->text();

bool importProject = !fileName.isEmpty();

mUI.mBtnClearImportProject->setEnabled(importProject);

mUI.mListCheckPaths->setEnabled(!importProject);

mUI.mListIncludeDirs->setEnabled(!importProject);

mUI.mBtnAddCheckPath->setEnabled(!importProject);

mUI.mBtnEditCheckPath->setEnabled(!importProject);

mUI.mBtnRemoveCheckPath->setEnabled(!importProject);

mUI.mEditDefines->setEnabled(!importProject);

mUI.mEditUndefines->setEnabled(!importProject);

mUI.mBtnAddInclude->setEnabled(!importProject);

mUI.mBtnEditInclude->setEnabled(!importProject);

mUI.mBtnRemoveInclude->setEnabled(!importProject);

mUI.mBtnIncludeUp->setEnabled(!importProject);

mUI.mBtnIncludeDown->setEnabled(!importProject);

mUI.mChkAllVsConfigs->setEnabled(fileName.endsWith(".sln") || fileName.endsWith(".vcxproj"));

mUI.mListVsConfigs->setEnabled(fileName.endsWith(".sln") || fileName.endsWith(".vcxproj"));

if (!mUI.mListVsConfigs->isEnabled())

mUI.mListVsConfigs->clear();

{

mUI.mEditImportProject->clear();

updatePathsAndDefines();

{

const QFileInfo inf(mProjectFile->getFilename());

const QDir &dir = inf.absoluteDir();

QMap<QString,QString> filters;

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

filters[tr("Compile database")] = "compile_commands.json";

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

QString fileName = QFileDialog::getOpenFileName(this, tr("Import Project"),

dir.canonicalPath(),

toFilterString(filters));

if (!fileName.isEmpty()) {

mUI.mEditImportProject->setText(dir.relativeFilePath(fileName));

updatePathsAndDefines();

setVsConfigurations(getProjectConfigs(fileName));

mUI.mListVsConfigs->selectAll();

}

{

QStringList configs;

foreach (QListWidgetItem *item, mUI.mListVsConfigs->selectedItems())

configs << item->text();

return configs;

{

mUI.mListVsConfigs->clear();

mUI.mListVsConfigs->addItems(configs);

{

if (dir.isNull() || dir.isEmpty())

return;

const QString newdir = QDir::toNativeSeparators(dir);

QListWidgetItem *item = new QListWidgetItem(newdir);

item->setFlags(item->flags() | Qt::ItemIsEditable);

mUI.mListIncludeDirs->addItem(item);

{

if (path.isNull() || path.isEmpty())

return;

const QString newpath = QDir::toNativeSeparators(path);

QListWidgetItem *item = new QListWidgetItem(newpath);

item->setFlags(item->flags() | Qt::ItemIsEditable);

mUI.mListCheckPaths->addItem(item);

{

if (path.isNull() || path.isEmpty())

return;

const QString newpath = QDir::toNativeSeparators(path);

QListWidgetItem *item = new QListWidgetItem(newpath);

item->setFlags(item->flags() | Qt::ItemIsEditable);

mUI.mListExcludedPaths->addItem(item);

{

QString root = mUI.mEditProjectRoot->text();

root = root.trimmed();

root = QDir::fromNativeSeparators(root);

return root;

{

const QString undefine = mUI.mEditUndefines->text().trimmed();

QStringList undefines = undefine.split(QRegExp("\\s*;\\s*"), QString::SkipEmptyParts);

undefines.removeDuplicates();

return undefines;

{

QStringList libraries;

for (int row = 0; row < mUI.mLibraries->count(); ++row) {

QListWidgetItem *item = mUI.mLibraries->item(row);

if (item->checkState() == Qt::Checked)

libraries << item->text();

}

return libraries;

{

foreach (QString dir, includes) {

addIncludeDir(dir);

}

{

foreach (QString path, paths) {

addCheckPath(path);

}

{

foreach (QString path, paths) {

addExcludePath(path);

}

{

for (int row = 0; row < mUI.mLibraries->count(); ++row) {

QListWidgetItem *item = mUI.mLibraries->item(row);

item->setCheckState(libraries.contains(item->text()) ? Qt::Checked : Qt::Unchecked);

}

{

mSuppressions = suppressions;

QStringList s;

foreach (const Suppressions::Suppression &suppression, mSuppressions) {

s << QString::fromStdString(suppression.getText());

}

mUI.mListSuppressions->clear();

mUI.mListSuppressions->addItems(s);

mUI.mListSuppressions->sortItems();

{

QString dir = getExistingDirectory(tr("Select a directory to check"), false);

if (!dir.isEmpty())

addCheckPath(dir);

{

QListWidgetItem *item = mUI.mListCheckPaths->currentItem();

mUI.mListCheckPaths->editItem(item);

{

const int row = mUI.mListCheckPaths->currentRow();

QListWidgetItem *item = mUI.mListCheckPaths->takeItem(row);

delete item;

{

const QString dir = getExistingDirectory(tr("Select include directory"), true);

if (!dir.isEmpty())

addIncludeDir(dir);

{

const int row = mUI.mListIncludeDirs->currentRow();

QListWidgetItem *item = mUI.mListIncludeDirs->takeItem(row);

delete item;

{

QListWidgetItem *item = mUI.mListIncludeDirs->currentItem();

mUI.mListIncludeDirs->editItem(item);

{

QString dir = getExistingDirectory(tr("Select directory to ignore"), true);

if (!dir.isEmpty())

addExcludePath(dir);

{

QListWidgetItem *item = mUI.mListExcludedPaths->currentItem();

mUI.mListExcludedPaths->editItem(item);

{

const int row = mUI.mListExcludedPaths->currentRow();

QListWidgetItem *item = mUI.mListExcludedPaths->takeItem(row);

delete item;

{

int row = mUI.mListIncludeDirs->currentRow();

QListWidgetItem *item = mUI.mListIncludeDirs->takeItem(row);

row = row > 0 ? row - 1 : 0;

mUI.mListIncludeDirs->insertItem(row, item);

mUI.mListIncludeDirs->setCurrentItem(item);

{

int row = mUI.mListIncludeDirs->currentRow();

QListWidgetItem *item = mUI.mListIncludeDirs->takeItem(row);

const int count = mUI.mListIncludeDirs->count();

row = row < count ? row + 1 : count;

mUI.mListIncludeDirs->insertItem(row, item);

mUI.mListIncludeDirs->setCurrentItem(item);

{

NewSuppressionDialog dlg;

if (dlg.exec() == QDialog::Accepted) {

setSuppressions(mSuppressions << dlg.getSuppression());

}

{

const int row = mUI.mListSuppressions->currentRow();

QListWidgetItem *item = mUI.mListSuppressions->takeItem(row);

if (!item)

return;

int suppressionIndex = getSuppressionIndex(item->text());

if (suppressionIndex >= 0)

mSuppressions.removeAt(suppressionIndex);

delete item;

{

const int row = mUI.mListSuppressions->currentRow();

QListWidgetItem *item = mUI.mListSuppressions->item(row);

int suppressionIndex = getSuppressionIndex(item->text());

if (suppressionIndex >= 0) { // TODO what if suppression is not found?

NewSuppressionDialog dlg;

dlg.setSuppression(mSuppressions[suppressionIndex]);

if (dlg.exec() == QDialog::Accepted) {

mSuppressions[suppressionIndex] = dlg.getSuppression();

setSuppressions(mSuppressions);

}

}

{

const std::string s = shortText.toStdString();

for (int i = 0; i < mSuppressions.size(); ++i) {

if (mSuppressions[i].getText() == s)

return i;

}

return -1;

{

const QString fileName = QFileDialog::getOpenFileName(this, tr("Select MISRA rule texts file"), QDir::homePath(), tr("Misra rule texts file (%1)").arg("*.txt"));

if (!fileName.isEmpty()) {

QSettings settings;

mUI.mEditMisraFile->setText(fileName);

settings.setValue(SETTINGS_MISRA_FILE, fileName);

mUI.mAddonMisra->setText("MISRA C 2012");

mUI.mAddonMisra->setEnabled(true);

updateAddonCheckBox(mUI.mAddonMisra, nullptr, settings.value("DATADIR", QString()).toString(), "misra");

}