blob: 12272d14819565fc890cfa1b135f6fbc53dc1fbf [file] [log] [blame]
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmXCodeScheme.h"
#include <iomanip>
#include <sstream>
#include <utility>
#include <cmext/algorithm>
#include <cmext/string_view>
#include "cmsys/String.h"
#include "cmGeneratedFileStream.h"
#include "cmGeneratorExpression.h"
#include "cmGeneratorTarget.h"
#include "cmList.h"
#include "cmStateTypes.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include "cmValue.h"
#include "cmXCodeObject.h"
#include "cmXMLWriter.h"
class cmLocalGenerator;
cmXCodeScheme::cmXCodeScheme(cmLocalGenerator* lg, cmXCodeObject* xcObj,
TestObjects tests,
const std::vector<std::string>& configList,
unsigned int xcVersion)
: LocalGenerator(lg)
, Target(xcObj)
, Tests(std::move(tests))
, TargetName(xcObj->GetTarget()->GetName())
, ConfigList(configList)
, XcodeVersion(xcVersion)
{
}
void cmXCodeScheme::WriteXCodeSharedScheme(const std::string& xcProjDir,
const std::string& container)
{
// Create shared scheme sub-directory tree
//
std::string xcodeSchemeDir = cmStrCat(xcProjDir, "/xcshareddata/xcschemes");
cmSystemTools::MakeDirectory(xcodeSchemeDir);
std::string xcodeSchemeFile =
cmStrCat(xcodeSchemeDir, '/', this->TargetName, ".xcscheme");
cmGeneratedFileStream fout(xcodeSchemeFile);
fout.SetCopyIfDifferent(true);
if (!fout) {
return;
}
WriteXCodeXCScheme(fout, container);
}
void cmXCodeScheme::WriteXCodeXCScheme(std::ostream& fout,
const std::string& container)
{
cmXMLWriter xout(fout);
xout.SetIndentationElement(std::string(3, ' '));
xout.StartDocument();
xout.StartElement("Scheme");
xout.BreakAttributes();
xout.Attribute("LastUpgradeVersion", WriteVersionString());
xout.Attribute("version", "1.3");
cmValue propDftCfg =
Target->GetTarget()->GetProperty("XCODE_SCHEME_LAUNCH_CONFIGURATION");
std::string launchConfiguration =
!propDftCfg.IsEmpty() ? *propDftCfg : "Debug";
WriteBuildAction(xout, container);
WriteTestAction(xout, FindConfiguration("Debug"), container);
WriteLaunchAction(xout, FindConfiguration(launchConfiguration), container);
WriteProfileAction(xout, FindConfiguration("Release"), container);
WriteAnalyzeAction(xout, FindConfiguration("Debug"));
WriteArchiveAction(xout, FindConfiguration("Release"));
xout.EndElement();
}
void cmXCodeScheme::WriteBuildAction(cmXMLWriter& xout,
const std::string& container)
{
xout.StartElement("BuildAction");
xout.BreakAttributes();
xout.Attribute("parallelizeBuildables", "YES");
xout.Attribute("buildImplicitDependencies", "YES");
xout.StartElement("BuildActionEntries");
xout.StartElement("BuildActionEntry");
xout.BreakAttributes();
xout.Attribute("buildForTesting", "YES");
xout.Attribute("buildForRunning", "YES");
xout.Attribute("buildForProfiling", "YES");
xout.Attribute("buildForArchiving", "YES");
xout.Attribute("buildForAnalyzing", "YES");
WriteBuildableReference(xout, this->Target, container);
xout.EndElement(); // BuildActionEntry
xout.EndElement(); // BuildActionEntries
xout.EndElement(); // BuildAction
}
void cmXCodeScheme::WriteTestAction(cmXMLWriter& xout,
const std::string& configuration,
const std::string& container)
{
xout.StartElement("TestAction");
xout.BreakAttributes();
xout.Attribute("buildConfiguration", configuration);
xout.Attribute("selectedDebuggerIdentifier",
"Xcode.DebuggerFoundation.Debugger.LLDB");
xout.Attribute("selectedLauncherIdentifier",
"Xcode.DebuggerFoundation.Launcher.LLDB");
xout.Attribute("shouldUseLaunchSchemeArgsEnv", "YES");
xout.StartElement("Testables");
for (auto const* test : this->Tests) {
xout.StartElement("TestableReference");
xout.BreakAttributes();
xout.Attribute("skipped", "NO");
WriteBuildableReference(xout, test, container);
xout.EndElement(); // TestableReference
}
xout.EndElement();
if (IsTestable()) {
xout.StartElement("MacroExpansion");
WriteBuildableReference(xout, this->Target, container);
xout.EndElement(); // MacroExpansion
}
xout.StartElement("AdditionalOptions");
xout.EndElement();
xout.EndElement(); // TestAction
}
void cmXCodeScheme::WriteLaunchAction(cmXMLWriter& xout,
const std::string& configuration,
const std::string& container)
{
xout.StartElement("LaunchAction");
xout.BreakAttributes();
xout.Attribute("buildConfiguration", configuration);
xout.Attribute("selectedDebuggerIdentifier",
"Xcode.DebuggerFoundation.Debugger.LLDB");
xout.Attribute("selectedLauncherIdentifier",
"Xcode.DebuggerFoundation.Launcher.LLDB");
{
cmValue launchMode =
this->Target->GetTarget()->GetProperty("XCODE_SCHEME_LAUNCH_MODE");
std::string value = "0"; // == 'AUTO'
if (launchMode && *launchMode == "WAIT"_s) {
value = "1";
}
xout.Attribute("launchStyle", value);
}
WriteCustomWorkingDirectory(xout, configuration);
xout.Attribute("ignoresPersistentStateOnLaunch", "NO");
WriteLaunchActionBooleanAttribute(xout, "debugDocumentVersioning",
"XCODE_SCHEME_DEBUG_DOCUMENT_VERSIONING",
true);
xout.Attribute("debugServiceExtension", "internal");
xout.Attribute("allowLocationSimulation", "YES");
if (cmValue gpuFrameCaptureMode = this->Target->GetTarget()->GetProperty(
"XCODE_SCHEME_ENABLE_GPU_FRAME_CAPTURE_MODE")) {
std::string value = *gpuFrameCaptureMode;
if (cmsysString_strcasecmp(value.c_str(), "Metal") == 0) {
value = "1";
} else if (cmsysString_strcasecmp(value.c_str(), "Disabled") == 0) {
value = "3";
}
xout.Attribute("enableGPUFrameCaptureMode", value);
}
// Diagnostics tab begin
bool useAddressSanitizer = WriteLaunchActionAttribute(
xout, "enableAddressSanitizer",
"XCODE_SCHEME_ADDRESS_SANITIZER"); // not allowed with
// enableThreadSanitizer=YES
WriteLaunchActionAttribute(
xout, "enableASanStackUseAfterReturn",
"XCODE_SCHEME_ADDRESS_SANITIZER_USE_AFTER_RETURN");
bool useThreadSanitizer = false;
if (!useAddressSanitizer) {
useThreadSanitizer = WriteLaunchActionAttribute(
xout, "enableThreadSanitizer",
"XCODE_SCHEME_THREAD_SANITIZER"); // not allowed with
// enableAddressSanitizer=YES
}
WriteLaunchActionAttribute(xout, "stopOnEveryThreadSanitizerIssue",
"XCODE_SCHEME_THREAD_SANITIZER_STOP");
WriteLaunchActionAttribute(xout, "enableUBSanitizer",
"XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER");
if (cmValue value = this->Target->GetTarget()->GetProperty(
"XCODE_SCHEME_ENABLE_GPU_API_VALIDATION")) {
if (value.IsOff()) {
xout.Attribute("enableGPUValidationMode",
"1"); // unset means YES, "1" means NO
}
}
if (cmValue value = this->Target->GetTarget()->GetProperty(
"XCODE_SCHEME_ENABLE_GPU_SHADER_VALIDATION")) {
if (value.IsOn()) {
xout.Attribute("enableGPUShaderValidationMode",
"2"); // unset means NO, "2" means YES
}
}
WriteLaunchActionAttribute(
xout, "stopOnEveryUBSanitizerIssue",
"XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER_STOP");
WriteLaunchActionAttribute(
xout, "disableMainThreadChecker",
"XCODE_SCHEME_DISABLE_MAIN_THREAD_CHECKER"); // negative enabled!
WriteLaunchActionAttribute(xout, "stopOnEveryMainThreadCheckerIssue",
"XCODE_SCHEME_MAIN_THREAD_CHECKER_STOP");
if (this->Target->GetTarget()->GetPropertyAsBool(
"XCODE_SCHEME_DEBUG_AS_ROOT")) {
xout.Attribute("debugAsWhichUser", "root");
}
// Diagnostics tab end
if (IsExecutable(this->Target)) {
WriteBuildableProductRunnable(xout, this->Target, container);
} else {
xout.StartElement("MacroExpansion");
WriteBuildableReference(xout, this->Target, container);
xout.EndElement();
}
// Info tab begin
if (cmValue exe =
this->Target->GetTarget()->GetProperty("XCODE_SCHEME_EXECUTABLE")) {
xout.StartElement("PathRunnable");
xout.BreakAttributes();
xout.Attribute("runnableDebuggingMode", "0");
xout.Attribute("FilePath", *exe);
xout.EndElement(); // PathRunnable
}
// Info tab end
// Arguments tab begin
if (cmValue argList =
this->Target->GetTarget()->GetProperty("XCODE_SCHEME_ARGUMENTS")) {
cmList arguments{ *argList };
if (!arguments.empty()) {
xout.StartElement("CommandLineArguments");
for (auto const& argument : arguments) {
xout.StartElement("CommandLineArgument");
xout.BreakAttributes();
xout.Attribute("argument", argument);
xout.Attribute("isEnabled", "YES");
xout.EndElement(); // CommandLineArgument
}
xout.EndElement(); // CommandLineArguments
}
}
if (cmValue envList =
this->Target->GetTarget()->GetProperty("XCODE_SCHEME_ENVIRONMENT")) {
cmList envs{ *envList };
if (!envs.empty()) {
xout.StartElement("EnvironmentVariables");
for (auto env : envs) {
xout.StartElement("EnvironmentVariable");
xout.BreakAttributes();
std::string envValue;
const auto p = env.find_first_of('=');
if (p != std::string::npos) {
envValue = env.substr(p + 1);
env.resize(p);
}
xout.Attribute("key", env);
xout.Attribute("value", envValue);
xout.Attribute("isEnabled", "YES");
xout.EndElement(); // EnvironmentVariable
}
xout.EndElement(); // EnvironmentVariables
}
}
// Arguments tab end
xout.StartElement("AdditionalOptions");
if (!useThreadSanitizer) {
WriteLaunchActionAdditionalOption(xout, "MallocScribble", "",
"XCODE_SCHEME_MALLOC_SCRIBBLE");
}
if (!useThreadSanitizer && !useAddressSanitizer) {
WriteLaunchActionAdditionalOption(xout, "MallocGuardEdges", "",
"XCODE_SCHEME_MALLOC_GUARD_EDGES");
}
if (!useThreadSanitizer && !useAddressSanitizer) {
WriteLaunchActionAdditionalOption(xout, "DYLD_INSERT_LIBRARIES",
"/usr/lib/libgmalloc.dylib",
"XCODE_SCHEME_GUARD_MALLOC");
}
WriteLaunchActionAdditionalOption(xout, "NSZombieEnabled", "YES",
"XCODE_SCHEME_ZOMBIE_OBJECTS");
if (!useThreadSanitizer && !useAddressSanitizer) {
WriteLaunchActionAdditionalOption(xout, "MallocStackLogging", "",
"XCODE_SCHEME_MALLOC_STACK");
}
WriteLaunchActionAdditionalOption(xout, "DYLD_PRINT_APIS", "",
"XCODE_SCHEME_DYNAMIC_LINKER_API_USAGE");
WriteLaunchActionAdditionalOption(xout, "DYLD_PRINT_LIBRARIES", "",
"XCODE_SCHEME_DYNAMIC_LIBRARY_LOADS");
xout.EndElement();
xout.EndElement(); // LaunchAction
}
bool cmXCodeScheme::WriteLaunchActionAttribute(cmXMLWriter& xout,
const std::string& attrName,
const std::string& varName)
{
if (Target->GetTarget()->GetPropertyAsBool(varName)) {
xout.Attribute(attrName.c_str(), "YES");
return true;
}
return false;
}
bool cmXCodeScheme::WriteLaunchActionBooleanAttribute(
cmXMLWriter& xout, const std::string& attrName, const std::string& varName,
bool defaultValue)
{
cmValue property = Target->GetTarget()->GetProperty(varName);
bool isOn = (!property && defaultValue) || property.IsOn();
if (isOn) {
xout.Attribute(attrName.c_str(), "YES");
} else {
xout.Attribute(attrName.c_str(), "NO");
}
return isOn;
}
bool cmXCodeScheme::WriteLaunchActionAdditionalOption(
cmXMLWriter& xout, const std::string& key, const std::string& value,
const std::string& varName)
{
if (Target->GetTarget()->GetPropertyAsBool(varName)) {
xout.StartElement("AdditionalOption");
xout.BreakAttributes();
xout.Attribute("key", key);
xout.Attribute("value", value);
xout.Attribute("isEnabled", "YES");
xout.EndElement(); // AdditionalOption
return true;
}
return false;
}
void cmXCodeScheme::WriteProfileAction(cmXMLWriter& xout,
const std::string& configuration,
const std::string& container)
{
xout.StartElement("ProfileAction");
xout.BreakAttributes();
xout.Attribute("buildConfiguration", configuration);
xout.Attribute("shouldUseLaunchSchemeArgsEnv", "YES");
xout.Attribute("savedToolIdentifier", "");
WriteCustomWorkingDirectory(xout, configuration);
WriteLaunchActionBooleanAttribute(xout, "debugDocumentVersioning",
"XCODE_SCHEME_DEBUG_DOCUMENT_VERSIONING",
true);
if (IsExecutable(this->Target)) {
WriteBuildableProductRunnable(xout, this->Target, container);
}
xout.EndElement();
}
void cmXCodeScheme::WriteAnalyzeAction(cmXMLWriter& xout,
const std::string& configuration)
{
xout.StartElement("AnalyzeAction");
xout.BreakAttributes();
xout.Attribute("buildConfiguration", configuration);
xout.EndElement();
}
void cmXCodeScheme::WriteArchiveAction(cmXMLWriter& xout,
const std::string& configuration)
{
xout.StartElement("ArchiveAction");
xout.BreakAttributes();
xout.Attribute("buildConfiguration", configuration);
xout.Attribute("revealArchiveInOrganizer", "YES");
xout.EndElement();
}
void cmXCodeScheme::WriteBuildableProductRunnable(cmXMLWriter& xout,
const cmXCodeObject* xcObj,
const std::string& container)
{
xout.StartElement("BuildableProductRunnable");
xout.BreakAttributes();
xout.Attribute("runnableDebuggingMode", "0");
WriteBuildableReference(xout, xcObj, container);
xout.EndElement();
}
void cmXCodeScheme::WriteBuildableReference(cmXMLWriter& xout,
const cmXCodeObject* xcObj,
const std::string& container)
{
xout.StartElement("BuildableReference");
xout.BreakAttributes();
xout.Attribute("BuildableIdentifier", "primary");
xout.Attribute("BlueprintIdentifier", xcObj->GetId());
std::string const noConfig; // FIXME: What config to use here?
xout.Attribute("BuildableName", xcObj->GetTarget()->GetFullName(noConfig));
xout.Attribute("BlueprintName", xcObj->GetTarget()->GetName());
xout.Attribute("ReferencedContainer", cmStrCat("container:", container));
xout.EndElement();
}
void cmXCodeScheme::WriteCustomWorkingDirectory(
cmXMLWriter& xout, const std::string& configuration)
{
std::string const& propertyValue =
this->Target->GetTarget()->GetSafeProperty(
"XCODE_SCHEME_WORKING_DIRECTORY");
if (propertyValue.empty()) {
xout.Attribute("useCustomWorkingDirectory", "NO");
} else {
xout.Attribute("useCustomWorkingDirectory", "YES");
auto customWorkingDirectory = cmGeneratorExpression::Evaluate(
propertyValue, this->LocalGenerator, configuration);
xout.Attribute("customWorkingDirectory", customWorkingDirectory);
}
}
std::string cmXCodeScheme::WriteVersionString()
{
std::ostringstream v;
v << std::setfill('0') << std::setw(4) << this->XcodeVersion * 10;
return v.str();
}
std::string cmXCodeScheme::FindConfiguration(const std::string& name)
{
// Try to find the desired configuration by name,
// and if it's not found return first from the list
//
if (!cm::contains(this->ConfigList, name) && !this->ConfigList.empty()) {
return this->ConfigList[0];
}
return name;
}
bool cmXCodeScheme::IsTestable() const
{
return !this->Tests.empty() || IsExecutable(this->Target);
}
bool cmXCodeScheme::IsExecutable(const cmXCodeObject* target)
{
cmGeneratorTarget* gt = target->GetTarget();
if (!gt) {
cmSystemTools::Error("Error no target on xobject\n");
return false;
}
return gt->GetType() == cmStateEnums::EXECUTABLE;
}