foreach (const FileName &command, suspects) {
CMakeTool *item = new CMakeTool(CMakeTool::AutoDetection);
item->setCMakeExecutable(command);
item->setDisplayName(CMakeToolManager::tr("System CMake at %1").arg(command.toUserOutput()));
found.append(item);
}
void CMakeToolItemModel::apply()
{
foreach (const Core::Id &id, m_removedItems)
CMakeToolManager::deregisterCMakeTool(id);
foreach (auto item, itemsAtLevel<CMakeToolTreeItem *>(2)) {
item->m_changed = false;
bool isNew = false;
CMakeTool *cmake = CMakeToolManager::findById(item->m_id);
if (!cmake) {
isNew = true;
CMakeTool::Detection detection = item->m_autodetected ? CMakeTool::AutoDetection
: CMakeTool::ManualDetection;
cmake = new CMakeTool(detection, item->m_id);
}
cmake->setDisplayName(item->m_name);
cmake->setCMakeExecutable(item->m_executable);
if (isNew) {
if (!CMakeToolManager::registerCMakeTool(cmake)) {
delete cmake;
item->m_changed = true;
}
}
}
CMakeToolManager::setDefaultCMakeTool(defaultItemId());
}
static void readAndDeleteLegacyCMakeSettings ()
{
// restore the legacy cmake
QSettings *settings = ICore::settings();
settings->beginGroup(QLatin1String("CMakeSettings"));
FileName exec = FileName::fromUserInput(settings->value(QLatin1String("cmakeExecutable")).toString());
if (exec.toFileInfo().isExecutable()) {
CMakeTool *item = CMakeToolManager::findByCommand(exec);
if (!item) {
item = new CMakeTool(CMakeTool::ManualDetection);
item->setCMakeExecutable(exec);
item->setDisplayName(CMakeToolManager::tr("CMake at %1").arg(item->cmakeExecutable().toUserOutput()));
if (!CMakeToolManager::registerCMakeTool(item)) {
delete item;
item = 0;
}
}
//this setting used to be the default cmake, make sure it is again
if (item)
d->m_defaultCMake = item->id();
}
//read the legacy ninja setting, if its not available use the current value
d->m_preferNinja = settings->value(QLatin1String("preferNinja"), d->m_preferNinja).toBool();
settings->remove(QString());
settings->endGroup();
}
QList<Task> CMakeGeneratorKitInformation::validate(const Kit *k) const
{
CMakeTool *tool = CMakeKitInformation::cmakeTool(k);
QString generator = CMakeGeneratorKitInformation::generator(k);
QList<Task> result;
if (!tool) {
if (!generator.isEmpty()) {
result << Task(Task::Warning, tr("No CMake Tool configured, CMake generator will be ignored."),
Utils::FileName(), -1, Core::Id(Constants::TASK_CATEGORY_BUILDSYSTEM));
}
} else {
if (!tool->isValid()) {
result << Task(Task::Warning, tr("CMake Tool is unconfigured, CMake generator will be ignored."),
Utils::FileName(), -1, Core::Id(Constants::TASK_CATEGORY_BUILDSYSTEM));
} else {
QStringList known = tool->supportedGenerators();
if (!known.contains(generator)) {
result << Task(Task::Error, tr("CMake Tool does not support the configured generator."),
Utils::FileName(), -1, Core::Id(Constants::TASK_CATEGORY_BUILDSYSTEM));
}
if (!generator.startsWith(QLatin1String("CodeBlocks -"))) {
result << Task(Task::Warning, tr("CMake generator does not generate CodeBlocks file. "
"Qt Creator will not be able to parse the CMake project."),
Utils::FileName(), -1, Core::Id(Constants::TASK_CATEGORY_BUILDSYSTEM));
}
}
}
return result;
}
void CMakeKitInformation::addToMacroExpander(Kit *k, Utils::MacroExpander *expander) const
{
expander->registerFileVariables("CMake:Executable", tr("Path to the cmake executable"),
[this, k]() -> QString {
CMakeTool *tool = CMakeKitInformation::cmakeTool(k);
return tool ? tool->cmakeExecutable().toString() : QString();
});
}
void CMakeToolItemModel::reevaluateChangedFlag(CMakeToolTreeItem *item) const
{
CMakeTool *orig = CMakeToolManager::findById(item->m_id);
item->m_changed = !orig || orig->displayName() != item->m_name
|| orig->cmakeExecutable() != item->m_executable;
//make sure the item is marked as changed when the default cmake was changed
CMakeTool *origDefTool = CMakeToolManager::defaultCMakeTool();
Core::Id origDefault = origDefTool ? origDefTool->id() : Core::Id();
if (origDefault != m_defaultItemId) {
if (item->m_id == origDefault || item->m_id == m_defaultItemId)
item->m_changed = true;
}
item->update(); // Notify views.
}
void CMakeCbpParser::parseUnit()
{
//qDebug()<<stream.attributes().value("filename");
FileName fileName =
FileName::fromUserInput(attributes().value(QLatin1String("filename")).toString());
CMakeTool *tool = CMakeKitInformation::cmakeTool(m_kit);
if (tool) {
QString mappedFile = tool->mapAllPaths(m_kit, fileName.toString());
fileName = FileName::fromUserInput(mappedFile);
}
m_parsingCmakeUnit = false;
m_unitTarget.clear();
while (!atEnd()) {
readNext();
if (isEndElement()) {
if (!fileName.endsWith(QLatin1String(".rule")) && !m_processedUnits.contains(fileName)) {
// Now check whether we found a virtual element beneath
if (m_parsingCmakeUnit) {
m_cmakeFileList.append( new ProjectExplorer::FileNode(fileName, ProjectExplorer::ProjectFileType, false));
} else {
bool generated = false;
QString onlyFileName = fileName.fileName();
if ( (onlyFileName.startsWith(QLatin1String("moc_")) && onlyFileName.endsWith(QLatin1String(".cxx")))
|| (onlyFileName.startsWith(QLatin1String("ui_")) && onlyFileName.endsWith(QLatin1String(".h")))
|| (onlyFileName.startsWith(QLatin1String("qrc_")) && onlyFileName.endsWith(QLatin1String(".cxx"))))
generated = true;
if (fileName.endsWith(QLatin1String(".qrc")))
m_fileList.append( new ProjectExplorer::FileNode(fileName, ProjectExplorer::ResourceType, generated));
else
m_fileList.append( new ProjectExplorer::FileNode(fileName, ProjectExplorer::SourceType, generated));
}
if (!m_unitTarget.isEmpty())
m_unitTargetMap.insert(fileName, m_unitTarget);
m_processedUnits.insert(fileName);
}
return;
} else if (name() == QLatin1String("Option")) {
parseUnitOption();
} else if (isStartElement()) {
parseUnknownElement();
}
}
}
void CMakeCbpParser::parseBuildTargetClean()
{
if (attributes().hasAttribute(QLatin1String("command"))) {
m_buildTarget.makeCleanCommand = attributes().value(QLatin1String("command")).toString();
CMakeTool *tool = CMakeKitInformation::cmakeTool(m_kit);
if (tool)
m_buildTarget.makeCleanCommand = tool->mapAllPaths(m_kit, m_buildTarget.makeCleanCommand);
}
while (!atEnd()) {
readNext();
if (isEndElement())
return;
else if (isStartElement())
parseUnknownElement();
}
}
void CMakeCbpParser::parseBuildTargetOption()
{
if (attributes().hasAttribute(QLatin1String("output"))) {
m_buildTarget.executable = attributes().value(QLatin1String("output")).toString();
CMakeTool *tool = CMakeKitInformation::cmakeTool(m_kit);
if (tool)
m_buildTarget.executable = tool->mapAllPaths(m_kit, m_buildTarget.executable);
} else if (attributes().hasAttribute(QLatin1String("type"))) {
const QStringRef value = attributes().value(QLatin1String("type"));
if (value == QLatin1String("2") || value == QLatin1String("3"))
m_buildTarget.targetType = TargetType(value.toInt());
} else if (attributes().hasAttribute(QLatin1String("working_dir"))) {
m_buildTarget.workingDirectory = attributes().value(QLatin1String("working_dir")).toString();
QFile cmakeSourceInfoFile(m_buildTarget.workingDirectory
+ QStringLiteral("/CMakeFiles/CMakeDirectoryInformation.cmake"));
if (cmakeSourceInfoFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
QTextStream stream(&cmakeSourceInfoFile);
const QLatin1String searchSource("SET(CMAKE_RELATIVE_PATH_TOP_SOURCE \"");
while (!stream.atEnd()) {
const QString lineTopSource = stream.readLine().trimmed();
if (lineTopSource.startsWith(searchSource)) {
m_buildTarget.sourceDirectory = lineTopSource.mid(searchSource.size());
m_buildTarget.sourceDirectory.chop(2); // cut off ")
break;
}
}
}
if (m_buildTarget.sourceDirectory.isEmpty()) {
QDir dir(m_buildDirectory);
const QString relative = dir.relativeFilePath(m_buildTarget.workingDirectory);
m_buildTarget.sourceDirectory
= FileName::fromString(m_sourceDirectory).appendPath(relative).toString();
}
}
while (!atEnd()) {
readNext();
if (isEndElement())
return;
else if (isStartElement())
parseUnknownElement();
}
}
QVariant CMakeGeneratorKitInformation::defaultValue(const Kit *k) const
{
CMakeTool *tool = CMakeKitInformation::cmakeTool(k);
if (!tool)
return QString();
QStringList known = tool->supportedGenerators();
auto it = std::find_if(known.constBegin(), known.constEnd(),
[](const QString &s) { return s == QLatin1String("CodeBlocks - Ninja"); });
if (it == known.constEnd())
it = std::find_if(known.constBegin(), known.constEnd(),
[](const QString &s) { return s == QLatin1String("CodeBlocks - Unix Makefiles"); });
if (it == known.constEnd())
it = std::find_if(known.constBegin(), known.constEnd(),
[](const QString &s) { return s == QLatin1String("CodeBlocks - NMake Makefiles"); });
if (it == known.constEnd())
it = known.constBegin(); // Fallback to the first generator...
if (it != known.constEnd())
return *it;
return QString();
}
static QList<CMakeTool *> readCMakeTools(const FileName &fileName, Core::Id *defaultId, bool fromSDK)
{
PersistentSettingsReader reader;
if (!reader.load(fileName))
return QList<CMakeTool *>();
QVariantMap data = reader.restoreValues();
// Check version
int version = data.value(QLatin1String(CMAKETOOL_FILE_VERSION_KEY), 0).toInt();
if (version < 1)
return QList<CMakeTool *>();
QList<CMakeTool *> loaded;
int count = data.value(QLatin1String(CMAKETOOL_COUNT_KEY), 0).toInt();
for (int i = 0; i < count; ++i) {
const QString key = QString::fromLatin1(CMAKETOOL_DATA_KEY) + QString::number(i);
if (!data.contains(key))
continue;
const QVariantMap dbMap = data.value(key).toMap();
CMakeTool *item = new CMakeTool(dbMap,fromSDK);
if (item->isAutoDetected()) {
if (!item->cmakeExecutable().toFileInfo().isExecutable()) {
qWarning() << QString::fromLatin1("CMakeTool \"%1\" (%2) read from \"%3\" dropped since the command is not executable.")
.arg(item->cmakeExecutable().toUserOutput(), item->id().toString(), fileName.toUserOutput());
delete item;
continue;
}
}
loaded.append(item);
}
*defaultId = Id::fromSetting(data.value(QLatin1String(CMAKETOOL_DEFAULT_KEY), defaultId->toSetting()));
d->m_preferNinja= data.value(QLatin1String(CMAKETOOL_PREFER_NINJA_KEY), d->m_preferNinja).toBool();
return loaded;
}
QVariant CMakeGeneratorKitInformation::defaultValue(const Kit *k) const
{
CMakeTool *tool = CMakeKitInformation::cmakeTool(k);
if (!tool)
return QString();
QStringList known = tool->supportedGenerators();
auto it = std::find_if(known.constBegin(), known.constEnd(),
[](const QString &s) { return s == QLatin1String("CodeBlocks - Ninja"); });
if (it != known.constEnd()) {
Utils::Environment env = Utils::Environment::systemEnvironment();
k->addToEnvironment(env);
const Utils::FileName ninjaExec = env.searchInPath(QLatin1String("ninja"));
if (ninjaExec.isEmpty())
it = known.constEnd(); // Ignore ninja generator without ninja exectuable
}
if (Utils::HostOsInfo::isWindowsHost()) {
// *sigh* Windows with its zoo of incompatible stuff again...
ToolChain *tc = ToolChainKitInformation::toolChain(k, ToolChain::Language::Cxx);
if (tc && tc->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID) {
if (it == known.constEnd())
it = std::find_if(known.constBegin(), known.constEnd(),
[](const QString &s) { return s == QLatin1String("CodeBlocks - MinGW Makefiles"); });
} else {
if (it == known.constEnd())
it = std::find_if(known.constBegin(), known.constEnd(),
[](const QString &s) { return s == QLatin1String("CodeBlocks - NMake Makefiles"); });
}
} else {
// Unix-oid OSes:
if (it == known.constEnd())
it = std::find_if(known.constBegin(), known.constEnd(),
[](const QString &s) { return s == QLatin1String("CodeBlocks - Unix Makefiles"); });
}
if (it == known.constEnd())
it = known.constBegin(); // Fallback to the first generator...
if (it != known.constEnd())
return *it;
return QString();
}
bool CMakeOpenProjectWizard::compatibleKitExist() const
{
bool preferNinja = CMakeManager::preferNinja();
const QList<Kit *> kitList = KitManager::kits();
foreach (Kit *k, kitList) {
CMakeTool *cmake = CMakeKitInformation::cmakeTool(k);
if (!cmake)
continue;
bool hasCodeBlocksGenerator = cmake->hasCodeBlocksMsvcGenerator();
bool hasNinjaGenerator = cmake->hasCodeBlocksNinjaGenerator();
// OfferNinja and ForceNinja differ in what they return
// but not whether the list is empty or not, which is what we
// are interested in here
QList<GeneratorInfo> infos = GeneratorInfo::generatorInfosFor(k, hasNinjaGenerator,
preferNinja,
hasCodeBlocksGenerator);
if (!infos.isEmpty())
return true;
}
void CMakeCbpParser::parseAdd()
{
// CMake only supports <Add option=\> and <Add directory=\>
const QXmlStreamAttributes addAttributes = attributes();
QString includeDirectory = addAttributes.value(QLatin1String("directory")).toString();
CMakeTool *tool = CMakeKitInformation::cmakeTool(m_kit);
if (tool)
includeDirectory = tool->mapAllPaths(m_kit, includeDirectory);
// allow adding multiple times because order happens
if (!includeDirectory.isEmpty())
m_buildTarget.includeFiles.append(includeDirectory);
QString compilerOption = addAttributes.value(QLatin1String("option")).toString();
// defining multiple times a macro to the same value makes no sense
if (!compilerOption.isEmpty() && !m_buildTarget.compilerOptions.contains(compilerOption)) {
m_buildTarget.compilerOptions.append(compilerOption);
int macroNameIndex = compilerOption.indexOf(QLatin1String("-D")) + 2;
if (macroNameIndex != 1) {
int assignIndex = compilerOption.indexOf(QLatin1Char('='), macroNameIndex);
if (assignIndex != -1)
compilerOption[assignIndex] = ' ';
m_buildTarget.defines.append("#define ");
m_buildTarget.defines.append(compilerOption.mid(macroNameIndex).toUtf8());
m_buildTarget.defines.append('\n');
}
}
while (!atEnd()) {
readNext();
if (isEndElement())
return;
else if (isStartElement())
parseUnknownElement();
}
}
BuildDirReader::Parameters::Parameters(const CMakeBuildConfiguration *bc)
{
const ProjectExplorer::Kit *k = bc->target()->kit();
projectName = bc->target()->project()->displayName();
sourceDirectory = bc->target()->project()->projectDirectory();
buildDirectory = bc->buildDirectory();
environment = bc->environment();
CMakeTool *cmake = CMakeKitInformation::cmakeTool(k);
cmakeVersion = cmake->version();
cmakeHasServerMode = cmake->hasServerMode();
cmakeExecutable = cmake->cmakeExecutable();
pathMapper = cmake->pathMapper();
isAutorun = cmake->isAutoRun();
auto tc = ProjectExplorer::ToolChainKitInformation::toolChain(k, ProjectExplorer::ToolChain::Language::Cxx);
if (tc)
cxxToolChainId = tc->id();
tc = ProjectExplorer::ToolChainKitInformation::toolChain(k, ProjectExplorer::ToolChain::Language::C);
if (tc)
cToolChainId = tc->id();
sysRoot = ProjectExplorer::SysRootKitInformation::sysRoot(k);
expander = k->macroExpander();
configuration = bc->cmakeConfiguration();
generator = CMakeGeneratorKitInformation::generator(k);
extraGenerator = CMakeGeneratorKitInformation::extraGenerator(k);
platform = CMakeGeneratorKitInformation::platform(k);
toolset = CMakeGeneratorKitInformation::toolset(k);
generatorArguments = CMakeGeneratorKitInformation::generatorArguments(k);
}