ext::optional<pbxbuild::DirectedGraph<pbxproj::PBX::Target::shared_ptr>> Parameters::
resolveDependencies(pbxbuild::Build::Environment const &buildEnvironment, pbxbuild::Build::Context const &buildContext) const
{
pbxbuild::Build::DependencyResolver resolver = pbxbuild::Build::DependencyResolver(buildEnvironment);
if (buildContext.scheme() != nullptr) {
return resolver.resolveSchemeDependencies(buildContext);
} else if (buildContext.workspaceContext().project() != nullptr) {
return resolver.resolveLegacyDependencies(buildContext, _allTargets, _target);
} else {
fprintf(stderr, "error: scheme is required for workspace\n");
return ext::nullopt;
}
}
ext::optional<Target::Environment> Target::Environment::
Create(Build::Environment const &buildEnvironment, Build::Context const &buildContext, pbxproj::PBX::Target::shared_ptr const &target)
{
/* Use the source root, which could have been modified by project options, rather than the raw project path. */
std::string workingDirectory = target->project()->sourceRoot();
xcsdk::SDK::Target::shared_ptr sdk;
std::vector<std::string> specDomains;
pbxproj::XC::BuildConfiguration::shared_ptr projectConfiguration;
pbxproj::XC::BuildConfiguration::shared_ptr targetConfiguration;
ext::optional<pbxsetting::XC::Config> projectConfigurationFile;
ext::optional<pbxsetting::XC::Config> targetConfigurationFile;
{
/*
* Create a synthetic build setting environment to determine the SDK to use. The real build
* setting environment will interleave in SDK build settings, but those aren't available until
* the target SDK is itself determined.
*/
pbxsetting::Environment determinationEnvironment = pbxsetting::Environment(buildEnvironment.baseEnvironment());
/*
* Add build base settings.
*/
determinationEnvironment.insertFront(buildContext.baseSettings(), false);
/*
* Add project build settings.
*/
determinationEnvironment.insertFront(target->project()->settings(), false);
projectConfiguration = ConfigurationNamed(target->project()->buildConfigurationList(), buildContext.configuration());
if (projectConfiguration == nullptr) {
fprintf(stderr, "error: unable to find project configuration %s\n", buildContext.configuration().c_str());
return ext::nullopt;
}
projectConfigurationFile = ConfigurationFile(buildContext.workspaceContext(), projectConfiguration);
if (projectConfigurationFile) {
determinationEnvironment.insertFront(projectConfigurationFile->level(), false);
}
determinationEnvironment.insertFront(projectConfiguration->buildSettings(), false);
/*
* Add target build settings.
*/
determinationEnvironment.insertFront(target->settings(), false);
targetConfiguration = ConfigurationNamed(target->buildConfigurationList(), buildContext.configuration());
if (targetConfiguration == nullptr) {
fprintf(stderr, "error: unable to find target configuration %s\n", buildContext.configuration().c_str());
return ext::nullopt;
}
targetConfigurationFile = ConfigurationFile(buildContext.workspaceContext(), targetConfiguration);
if (targetConfigurationFile) {
determinationEnvironment.insertFront(targetConfigurationFile->level(), false);
}
determinationEnvironment.insertFront(targetConfiguration->buildSettings(), false);
/*
* Add build override settings.
*/
determinationEnvironment.insertFront(buildContext.actionSettings(), false);
for (pbxsetting::Level const &level : buildContext.overrideLevels()) {
determinationEnvironment.insertFront(level, false);
}
/*
* All settings added; determine target SDK.
*/
std::string sdkroot = determinationEnvironment.resolve("SDKROOT");
sdk = buildEnvironment.sdkManager()->findTarget(nullptr, sdkroot);
if (sdk == nullptr) {
fprintf(stderr, "error: unable to find sdkroot %s\n", sdkroot.c_str());
return ext::nullopt;
}
specDomains = SDKSpecificationDomains(sdk);
}
pbxspec::PBX::BuildSystem::shared_ptr buildSystem = TargetBuildSystem(buildEnvironment.specManager(), specDomains, target);
if (buildSystem == nullptr) {
fprintf(stderr, "error: unable to create build system\n");
return ext::nullopt;
}
pbxspec::PBX::ProductType::shared_ptr productType = nullptr;
pbxspec::PBX::PackageType::shared_ptr packageType = nullptr;
if (target->type() == pbxproj::PBX::Target::Type::Native) {
pbxproj::PBX::NativeTarget::shared_ptr nativeTarget = std::static_pointer_cast<pbxproj::PBX::NativeTarget>(target);
productType = buildEnvironment.specManager()->productType(nativeTarget->productType(), specDomains);
if (productType == nullptr) {
fprintf(stderr, "error: unable to find product type %s\n", nativeTarget->productType().c_str());
return ext::nullopt;
}
// FIXME(grp): Should this always use the first package type?
if (productType->packageTypes() && !productType->packageTypes()->empty()) {
packageType = buildEnvironment.specManager()->packageType(productType->packageTypes()->at(0), specDomains);
if (packageType == nullptr) {
fprintf(stderr, "error: unable to find package type %s\n", productType->packageTypes()->at(0).c_str());
return ext::nullopt;
}
}
}
/*
* Now we have $(SDKROOT), and can make the real levels.
*/
pbxsetting::Environment environment = pbxsetting::Environment(buildEnvironment.baseEnvironment());
environment.insertFront(buildSystem->defaultSettings(), true);
environment.insertFront(buildContext.baseSettings(), false);
environment.insertFront(pbxsetting::Level({
pbxsetting::Setting::Parse("GCC_VERSION", "$(DEFAULT_COMPILER)"),
}), false);
if (sdk->platform()->defaultProperties()) {
environment.insertFront(*sdk->platform()->defaultProperties(), false);
}
environment.insertFront(PlatformArchitecturesLevel(buildEnvironment.specManager(), specDomains), false);
if (sdk->defaultProperties()) {
environment.insertFront(*sdk->defaultProperties(), false);
}
environment.insertFront(sdk->platform()->settings(), false);
environment.insertFront(sdk->settings(), false);
if (sdk->customProperties()) {
environment.insertFront(*sdk->customProperties(), false);
}
if (sdk->platform()->overrideProperties()) {
environment.insertFront(*sdk->platform()->overrideProperties(), false);
}
if (packageType != nullptr) {
environment.insertFront(PackageTypeLevel(packageType), false);
}
if (productType != nullptr) {
environment.insertFront(ProductTypeLevel(productType), false);
}
/*
* Add project build settings.
*/
environment.insertFront(target->project()->settings(), false);
if (projectConfigurationFile) {
environment.insertFront(projectConfigurationFile->level(), false);
}
environment.insertFront(projectConfiguration->buildSettings(), false);
/*
* Add target build settings.
*/
environment.insertFront(target->settings(), false);
if (targetConfigurationFile) {
environment.insertFront(targetConfigurationFile->level(), false);
}
environment.insertFront(targetConfiguration->buildSettings(), false);
environment.insertFront(buildContext.actionSettings(), false);
for (pbxsetting::Level const &level : buildContext.overrideLevels()) {
environment.insertFront(level, false);
}
std::vector<std::string> architectures = ResolveArchitectures(environment);
std::vector<std::string> variants = ResolveVariants(environment);
environment.insertFront(ArchitecturesVariantsLevel(architectures, variants), false);
/* Determine toolchains. Must be after the SDK levels are added, so they can be a fallback. */
std::vector<xcsdk::SDK::Toolchain::shared_ptr> toolchains;
std::vector<std::string> effectiveToolchainPaths;
for (std::string const &toolchainName : pbxsetting::Type::ParseList(environment.resolve("TOOLCHAINS"))) {
if (xcsdk::SDK::Toolchain::shared_ptr toolchain = buildEnvironment.sdkManager()->findToolchain(nullptr, toolchainName)) {
// TODO: Apply toolchain override build settings.
toolchains.push_back(toolchain);
effectiveToolchainPaths.push_back(toolchain->path());
}
}
environment.insertFront(pbxsetting::Level({
/* At the target level and below, the SDKROOT changes to always be a SDK path. */
pbxsetting::Setting::Create("SDKROOT", sdk->path()),
pbxsetting::Setting::Create("EFFECTIVE_TOOLCHAINS_DIRS", pbxsetting::Type::FormatList(effectiveToolchainPaths)),
}), false);
/* Tool search directories. Use the toolchains just discovered. */
std::shared_ptr<xcsdk::SDK::Manager> const &sdkManager = buildEnvironment.sdkManager();
std::vector<std::string> executablePaths = sdkManager->executablePaths(sdk->platform(), sdk, toolchains);
executablePaths.insert(executablePaths.end(), buildEnvironment.baseExecutablePaths().begin(), buildEnvironment.baseExecutablePaths().end());
environment.insertFront(ExecutablePathsLevel(executablePaths), false);
auto buildRules = Target::BuildRules::Create(buildEnvironment.specManager(), specDomains, target);
auto buildFileDisambiguation = BuildFileDisambiguation(target);
return Environment(
sdk,
toolchains,
executablePaths,
buildRules,
specDomains,
buildSystem,
productType,
packageType,
environment,
variants,
architectures,
workingDirectory,
buildFileDisambiguation);
}
ext::optional<Target::Environment> Target::Environment::
Create(Build::Environment const &buildEnvironment, Build::Context const &buildContext, pbxproj::PBX::Target::shared_ptr const &target)
{
xcsdk::SDK::Target::shared_ptr sdk;
std::vector<std::string> specDomains;
pbxproj::XC::BuildConfiguration::shared_ptr projectConfiguration;
pbxproj::XC::BuildConfiguration::shared_ptr targetConfiguration;
pbxsetting::XC::Config::shared_ptr projectConfigurationFile;
pbxsetting::XC::Config::shared_ptr targetConfigurationFile;
{
// FIXME(grp): $(SRCROOT) must be set in order to find the xcconfig, but we need the xcconfig to know $(SDKROOT). So this can't
// use the default level order, because $(SRCROOT) comes below $(SDKROOT). Hack around this for now with a synthetic environment.
// It's also in the wrong order because project settings should be below the SDK, but are needed to *load* the xcconfig.
pbxsetting::Environment determinationEnvironment = buildEnvironment.baseEnvironment();
determinationEnvironment.insertFront(buildContext.baseSettings(), false);
projectConfiguration = ConfigurationNamed(target->project()->buildConfigurationList(), buildContext.configuration());
if (projectConfiguration == nullptr) {
fprintf(stderr, "error: unable to find project configuration %s\n", buildContext.configuration().c_str());
return ext::nullopt;
}
determinationEnvironment.insertFront(target->project()->settings(), false);
determinationEnvironment.insertFront(projectConfiguration->buildSettings(), false);
pbxsetting::Environment projectActionEnvironment = determinationEnvironment;
projectActionEnvironment.insertFront(buildContext.actionSettings(), false);
for (pbxsetting::Level const &level : buildContext.overrideLevels()) {
projectActionEnvironment.insertFront(level, false);
}
projectConfigurationFile = LoadConfigurationFile(projectConfiguration, projectActionEnvironment);
if (projectConfigurationFile != nullptr) {
determinationEnvironment.insertFront(projectConfigurationFile->level(), false);
}
targetConfiguration = ConfigurationNamed(target->buildConfigurationList(), buildContext.configuration());
if (targetConfiguration == nullptr) {
fprintf(stderr, "error: unable to find target configuration %s\n", buildContext.configuration().c_str());
return ext::nullopt;
}
determinationEnvironment.insertFront(target->settings(), false);
determinationEnvironment.insertFront(targetConfiguration->buildSettings(), false);
// FIXME(grp): Similar issue for the target xcconfig. These levels aren't complete (no platform) but are needed to *get* which SDK to use.
pbxsetting::Environment targetActionEnvironment = determinationEnvironment;
targetActionEnvironment.insertFront(buildContext.actionSettings(), false);
for (pbxsetting::Level const &level : buildContext.overrideLevels()) {
targetActionEnvironment.insertFront(level, false);
}
targetConfigurationFile = LoadConfigurationFile(targetConfiguration, targetActionEnvironment);
if (targetConfigurationFile != nullptr) {
determinationEnvironment.insertFront(targetConfigurationFile->level(), false);
}
determinationEnvironment.insertFront(buildContext.actionSettings(), false);
for (pbxsetting::Level const &level : buildContext.overrideLevels()) {
determinationEnvironment.insertFront(level, false);
}
std::string sdkroot = determinationEnvironment.resolve("SDKROOT");
sdk = buildEnvironment.sdkManager()->findTarget(sdkroot);
if (sdk == nullptr) {
fprintf(stderr, "error: unable to find sdkroot %s\n", sdkroot.c_str());
return ext::nullopt;
}
specDomains = SDKSpecificationDomains(sdk);
}
pbxspec::PBX::BuildSystem::shared_ptr buildSystem = TargetBuildSystem(buildEnvironment.specManager(), specDomains, target);
if (buildSystem == nullptr) {
fprintf(stderr, "error: unable to create build system\n");
return ext::nullopt;
}
pbxspec::PBX::ProductType::shared_ptr productType = nullptr;
pbxspec::PBX::PackageType::shared_ptr packageType = nullptr;
if (target->type() == pbxproj::PBX::Target::Type::Native) {
pbxproj::PBX::NativeTarget::shared_ptr nativeTarget = std::static_pointer_cast<pbxproj::PBX::NativeTarget>(target);
productType = buildEnvironment.specManager()->productType(nativeTarget->productType(), specDomains);
if (productType == nullptr) {
fprintf(stderr, "error: unable to find product type %s\n", nativeTarget->productType().c_str());
return ext::nullopt;
}
// FIXME(grp): Should this always use the first package type?
if (productType->packageTypes() && !productType->packageTypes()->empty()) {
packageType = buildEnvironment.specManager()->packageType(productType->packageTypes()->at(0), specDomains);
if (packageType == nullptr) {
fprintf(stderr, "error: unable to find package type %s\n", productType->packageTypes()->at(0).c_str());
return ext::nullopt;
}
}
}
// Now we have $(SDKROOT), and can make the real levels.
pbxsetting::Environment environment = buildEnvironment.baseEnvironment();
environment.insertFront(buildSystem->defaultSettings(), true);
environment.insertFront(buildContext.baseSettings(), false);
environment.insertFront(pbxsetting::Level({
pbxsetting::Setting::Parse("GCC_VERSION", "$(DEFAULT_COMPILER)"),
}), false);
environment.insertFront(sdk->platform()->defaultProperties(), false);
environment.insertFront(PlatformArchitecturesLevel(buildEnvironment.specManager(), specDomains), false);
environment.insertFront(sdk->defaultProperties(), false);
environment.insertFront(sdk->platform()->settings(), false);
environment.insertFront(sdk->settings(), false);
environment.insertFront(sdk->customProperties(), false);
environment.insertFront(sdk->platform()->overrideProperties(), false);
if (packageType != nullptr) {
environment.insertFront(PackageTypeLevel(packageType), false);
}
if (productType != nullptr) {
environment.insertFront(ProductTypeLevel(productType), false);
}
environment.insertFront(target->project()->settings(), false);
if (projectConfigurationFile != nullptr) {
environment.insertFront(projectConfigurationFile->level(), false);
}
environment.insertFront(projectConfiguration->buildSettings(), false);
environment.insertFront(target->settings(), false);
if (targetConfigurationFile != nullptr) {
environment.insertFront(targetConfigurationFile->level(), false);
}
environment.insertFront(targetConfiguration->buildSettings(), false);
environment.insertFront(buildContext.actionSettings(), false);
for (pbxsetting::Level const &level : buildContext.overrideLevels()) {
environment.insertFront(level, false);
}
std::vector<std::string> architectures = ResolveArchitectures(environment);
std::vector<std::string> variants = ResolveVariants(environment);
environment.insertFront(ArchitecturesVariantsLevel(architectures, variants), false);
/* At the target level and below, the SDKROOT changes to always be a SDK path. */
environment.insertFront(pbxsetting::Level({
pbxsetting::Setting::Create("SDKROOT", sdk->path()),
}), false);
/* Determine toolchains. Must be after the SDK levels are added, so they can be a fallback. */
xcsdk::SDK::Toolchain::vector toolchains;
for (std::string const &toolchainName : pbxsetting::Type::ParseList(environment.resolve("TOOLCHAINS"))) {
if (xcsdk::SDK::Toolchain::shared_ptr toolchain = buildEnvironment.sdkManager()->findToolchain(toolchainName)) {
toolchains.push_back(toolchain);
}
}
/* Tool search directories. Use the toolchains just discovered. */
std::vector<std::string> executablePaths = sdk->executablePaths(toolchains);
auto buildRules = std::make_shared<Target::BuildRules>(Target::BuildRules::Create(buildEnvironment.specManager(), specDomains, target));
auto buildFileDisambiguation = BuildFileDisambiguation(target);
/* Use the source root, which could have been modified by project options, rather than the raw project path. */
std::string workingDirectory = target->project()->sourceRoot();
Target::Environment te = Target::Environment();
te._sdk = sdk;
te._toolchains = toolchains;
te._executablePaths = executablePaths;
te._buildRules = buildRules;
te._environment = std::unique_ptr<pbxsetting::Environment>(new pbxsetting::Environment(environment));
te._variants = variants;
te._architectures = architectures;
te._buildSystem = buildSystem;
te._packageType = packageType;
te._productType = productType;
te._specDomains = specDomains;
te._projectConfigurationFile = projectConfigurationFile;
te._targetConfigurationFile = targetConfigurationFile;
te._workingDirectory = workingDirectory;
te._buildFileDisambiguation = buildFileDisambiguation;
return te;
}