static pbxspec::PBX::BuildSystem::shared_ptr
TargetBuildSystem(pbxspec::Manager::shared_ptr const &specManager, std::vector<std::string> const &specDomains, pbxproj::PBX::Target::shared_ptr const &target)
{
if (target->type() == pbxproj::PBX::Target::Type::Native) {
return specManager->buildSystem("com.apple.build-system.native", specDomains);
} else if (target->type() == pbxproj::PBX::Target::Type::Legacy) {
return specManager->buildSystem("com.apple.build-system.external", specDomains);
} else if (target->type() == pbxproj::PBX::Target::Type::Aggregate) {
return specManager->buildSystem("com.apple.build-system.external", specDomains);
} else {
fprintf(stderr, "error: unknown target type\n");
return nullptr;
}
}
Target::BuildRules Target::BuildRules::
Create(pbxspec::Manager::shared_ptr const &specManager, std::vector<std::string> const &domains, pbxproj::PBX::Target::shared_ptr const &target)
{
Target::BuildRules::BuildRule::vector buildRules;
if (target->type() == pbxproj::PBX::Target::kTypeNative) {
pbxproj::PBX::NativeTarget::shared_ptr nativeTarget = std::static_pointer_cast <pbxproj::PBX::NativeTarget> (target);
for (pbxproj::PBX::BuildRule::shared_ptr const &projBuildRule : nativeTarget->buildRules()) {
if (Target::BuildRules::BuildRule::shared_ptr buildRule = ProjectBuildRule(specManager, domains, projBuildRule)) {
buildRules.push_back(buildRule);
}
}
}
for (pbxspec::PBX::BuildRule::shared_ptr const &specBuildRule : specManager->buildRules()) {
if (Target::BuildRules::BuildRule::shared_ptr buildRule = SpecificationBuildRule(specManager, domains, specBuildRule)) {
buildRules.push_back(buildRule);
}
}
for (pbxspec::PBX::BuildRule::shared_ptr const &specBuildRule : specManager->synthesizedBuildRules(domains)) {
if (BuildRule::shared_ptr buildRule = SpecificationBuildRule(specManager, domains, specBuildRule)) {
buildRules.push_back(buildRule);
}
}
return Target::BuildRules(buildRules);
}
static std::unordered_map<pbxproj::PBX::BuildFile::shared_ptr, std::string>
BuildFileDisambiguation(pbxproj::PBX::Target::shared_ptr const &target)
{
std::unordered_multimap<std::string, pbxproj::PBX::BuildFile::shared_ptr> buildFileUnambiguous;
std::unordered_map<pbxproj::PBX::BuildFile::shared_ptr, std::string> buildFileDisambiguation;
for (pbxproj::PBX::BuildPhase::shared_ptr const &buildPhase : target->buildPhases()) {
if (buildPhase->type() != pbxproj::PBX::BuildPhase::Type::Sources) {
continue;
}
for (pbxproj::PBX::BuildFile::shared_ptr const &buildFile : buildPhase->files()) {
if (buildFile->fileRef() == nullptr) {
continue;
}
std::string name = FSUtil::GetBaseNameWithoutExtension(buildFile->fileRef()->name());
/* Use a case-insensitive key to detect conflicts. */
std::string lower;
std::transform(name.begin(), name.end(), std::back_inserter(lower), ::tolower);
auto range = buildFileUnambiguous.equal_range(lower);
if (range.first != buildFileUnambiguous.end()) {
/* Conflicts with at least one other file, add a disambiguation. */
buildFileDisambiguation.insert({ buildFile, name + "-" + buildFile->blueprintIdentifier() });
/* Add disambiguations for all the conflicting files. */
for (auto it = range.first; it != range.second; ++it) {
pbxproj::PBX::BuildFile::shared_ptr const &otherBuildFile = it->second;
std::string otherName = FSUtil::GetBaseNameWithoutExtension(otherBuildFile->fileRef()->name());
buildFileDisambiguation.insert({ otherBuildFile, otherName + "-" + otherBuildFile->blueprintIdentifier() });
}
}
buildFileUnambiguous.insert({ lower, buildFile });
}
}
return buildFileDisambiguation;
}
static std::vector<std::string>
HeadermapSearchPaths(pbxspec::Manager::shared_ptr const &specManager, pbxsetting::Environment const &environment, pbxproj::PBX::Target::shared_ptr const &target, Tool::SearchPaths const &searchPaths, std::string const &workingDirectory)
{
std::unordered_set<std::string> allHeaderSearchPaths;
std::vector<std::string> orderedHeaderSearchPaths;
for (pbxproj::PBX::BuildPhase::shared_ptr const &buildPhase : target->buildPhases()) {
if (buildPhase->type() != pbxproj::PBX::BuildPhase::Type::Sources) {
continue;
}
for (pbxproj::PBX::BuildFile::shared_ptr const &buildFile : buildPhase->files()) {
if (buildFile->fileRef() == nullptr) {
continue;
}
std::string filePath = environment.expand(buildFile->fileRef()->resolve());
std::string fullPath = FSUtil::GetDirectoryName(filePath);
if (allHeaderSearchPaths.insert(fullPath).second) {
orderedHeaderSearchPaths.push_back(fullPath);
}
}
}
for (std::string const &path : searchPaths.userHeaderSearchPaths()) {
std::string fullPath = FSUtil::ResolveRelativePath(path, workingDirectory);
if (allHeaderSearchPaths.insert(fullPath).second) {
orderedHeaderSearchPaths.push_back(fullPath);
}
}
for (std::string const &path : searchPaths.headerSearchPaths()) {
std::string fullPath = FSUtil::ResolveRelativePath(path, workingDirectory);
if (allHeaderSearchPaths.insert(fullPath).second) {
orderedHeaderSearchPaths.push_back(fullPath);
}
}
return orderedHeaderSearchPaths;
}
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;
}
void Tool::HeadermapResolver::
resolve(
Tool::Context *toolContext,
pbxsetting::Environment const &environment,
pbxproj::PBX::Target::shared_ptr const &target
) const
{
/* Add the compiler default environment, which contains the headermap setting defaults. */
pbxsetting::Environment compilerEnvironment = pbxsetting::Environment(environment);
compilerEnvironment.insertFront(_compiler->defaultSettings(), true);
if (!pbxsetting::Type::ParseBoolean(compilerEnvironment.resolve("USE_HEADERMAP"))) {
return;
}
if (pbxsetting::Type::ParseBoolean(compilerEnvironment.resolve("HEADERMAP_USES_VFS"))) {
// TODO(grp): Support VFS-based header maps.
}
HeaderMap targetName;
HeaderMap ownTargetHeaders;
HeaderMap projectHeaders;
HeaderMap allTargetHeaders;
HeaderMap allNonFrameworkTargetHeaders;
bool includeFlatEntriesForTargetBeingBuilt = pbxsetting::Type::ParseBoolean(compilerEnvironment.resolve("HEADERMAP_INCLUDES_FLAT_ENTRIES_FOR_TARGET_BEING_BUILT"));
bool includeFrameworkEntriesForAllProductTypes = pbxsetting::Type::ParseBoolean(compilerEnvironment.resolve("HEADERMAP_INCLUDES_FRAMEWORK_ENTRIES_FOR_ALL_PRODUCT_TYPES"));
bool includeProjectHeaders = pbxsetting::Type::ParseBoolean(compilerEnvironment.resolve("HEADERMAP_INCLUDES_PROJECT_HEADERS"));
// TODO(grp): Populate generated headers.
HeaderMap generatedFiles;
pbxproj::PBX::Project::shared_ptr project = target->project();
std::vector<std::string> headermapSearchPaths = HeadermapSearchPaths(_specManager, compilerEnvironment, target, toolContext->searchPaths(), toolContext->workingDirectory());
for (std::string const &path : headermapSearchPaths) {
Filesystem::GetDefaultUNSAFE()->readDirectory(path, false, [&](std::string const &fileName) -> bool {
// TODO(grp): Use FileTypeResolver when reliable.
std::string extension = FSUtil::GetFileExtension(fileName);
if (extension != "h" && extension != "hpp") {
return true;
}
targetName.add(fileName, path + "/", fileName);
return true;
});
}
for (pbxproj::PBX::FileReference::shared_ptr const &fileReference : project->fileReferences()) {
std::string filePath = compilerEnvironment.expand(fileReference->resolve());
pbxspec::PBX::FileType::shared_ptr fileType = FileTypeResolver::Resolve(Filesystem::GetDefaultUNSAFE(), _specManager, { pbxspec::Manager::AnyDomain() }, fileReference, filePath);
if (fileType == nullptr || (fileType->identifier() != "sourcecode.c.h" && fileType->identifier() != "sourcecode.cpp.h")) {
continue;
}
std::string fileName = FSUtil::GetBaseName(filePath);
std::string fileDirectory = FSUtil::GetDirectoryName(filePath) + "/";
projectHeaders.add(fileName, fileDirectory, fileName);
if (includeProjectHeaders) {
targetName.add(fileName, fileDirectory, fileName);
}
}
for (pbxproj::PBX::Target::shared_ptr const &projectTarget : project->targets()) {
for (pbxproj::PBX::BuildPhase::shared_ptr const &buildPhase : projectTarget->buildPhases()) {
if (buildPhase->type() != pbxproj::PBX::BuildPhase::Type::Headers) {
continue;
}
for (pbxproj::PBX::BuildFile::shared_ptr const &buildFile : buildPhase->files()) {
if (buildFile->fileRef() == nullptr || buildFile->fileRef()->type() != pbxproj::PBX::GroupItem::Type::FileReference) {
continue;
}
pbxproj::PBX::FileReference::shared_ptr const &fileReference = std::static_pointer_cast <pbxproj::PBX::FileReference> (buildFile->fileRef());
std::string filePath = compilerEnvironment.expand(fileReference->resolve());
pbxspec::PBX::FileType::shared_ptr fileType = FileTypeResolver::Resolve(Filesystem::GetDefaultUNSAFE(), _specManager, { pbxspec::Manager::AnyDomain() }, fileReference, filePath);
if (fileType == nullptr || (fileType->identifier() != "sourcecode.c.h" && fileType->identifier() != "sourcecode.cpp.h")) {
continue;
}
std::string fileName = FSUtil::GetBaseName(filePath);
std::string fileDirectory = FSUtil::GetDirectoryName(filePath) + "/";
std::string frameworkName = projectTarget->productName() + "/" + fileName;
std::vector<std::string> const &attributes = buildFile->attributes();
bool isPublic = std::find(attributes.begin(), attributes.end(), "Public") != attributes.end();
bool isPrivate = std::find(attributes.begin(), attributes.end(), "Private") != attributes.end();
if (projectTarget == target) {
ownTargetHeaders.add(fileName, fileDirectory, fileName);
if (!isPublic && !isPrivate) {
ownTargetHeaders.add(frameworkName, fileDirectory, fileName);
if (includeFlatEntriesForTargetBeingBuilt) {
targetName.add(frameworkName, fileDirectory, fileName);
}
}
}
if (isPublic || isPrivate) {
allTargetHeaders.add(frameworkName, fileDirectory, fileName);
if (includeFrameworkEntriesForAllProductTypes) {
targetName.add(frameworkName, fileDirectory, fileName);
}
// TODO(grp): This is a little messy. Maybe check the product type specification, or the product reference's file type?
if (projectTarget->type() == pbxproj::PBX::Target::Type::Native && std::static_pointer_cast<pbxproj::PBX::NativeTarget>(projectTarget)->productType().find("framework") == std::string::npos) {
allNonFrameworkTargetHeaders.add(frameworkName, fileDirectory, fileName);
if (!includeFrameworkEntriesForAllProductTypes) {
targetName.add(frameworkName, fileDirectory, fileName);
}
}
}
}
}
}
std::string headermapFile = compilerEnvironment.resolve("CPP_HEADERMAP_FILE");
std::string headermapFileForOwnTargetHeaders = compilerEnvironment.resolve("CPP_HEADERMAP_FILE_FOR_OWN_TARGET_HEADERS");
std::string headermapFileForAllTargetHeaders = compilerEnvironment.resolve("CPP_HEADERMAP_FILE_FOR_ALL_TARGET_HEADERS");
std::string headermapFileForAllNonFrameworkTargetHeaders = compilerEnvironment.resolve("CPP_HEADERMAP_FILE_FOR_ALL_NON_FRAMEWORK_TARGET_HEADERS");
std::string headermapFileForGeneratedFiles = compilerEnvironment.resolve("CPP_HEADERMAP_FILE_FOR_GENERATED_FILES");
std::string headermapFileForProjectFiles = compilerEnvironment.resolve("CPP_HEADERMAP_FILE_FOR_PROJECT_FILES");
std::vector<Tool::AuxiliaryFile> auxiliaryFiles = {
Tool::AuxiliaryFile::Data(headermapFile, targetName.write()),
Tool::AuxiliaryFile::Data(headermapFileForOwnTargetHeaders, ownTargetHeaders.write()),
Tool::AuxiliaryFile::Data(headermapFileForAllTargetHeaders, allTargetHeaders.write()),
Tool::AuxiliaryFile::Data(headermapFileForAllNonFrameworkTargetHeaders, allNonFrameworkTargetHeaders.write()),
Tool::AuxiliaryFile::Data(headermapFileForGeneratedFiles, generatedFiles.write()),
Tool::AuxiliaryFile::Data(headermapFileForProjectFiles, projectHeaders.write()),
};
toolContext->auxiliaryFiles().insert(toolContext->auxiliaryFiles().end(), auxiliaryFiles.begin(), auxiliaryFiles.end());
std::vector<std::string> systemHeadermapFiles;
std::vector<std::string> userHeadermapFiles;
if (pbxsetting::Type::ParseBoolean(compilerEnvironment.resolve("ALWAYS_SEARCH_USER_PATHS")) && !pbxsetting::Type::ParseBoolean(compilerEnvironment.resolve("ALWAYS_USE_SEPARATE_HEADERMAPS"))) {
systemHeadermapFiles.push_back(headermapFile);
} else {
if (includeFlatEntriesForTargetBeingBuilt) {
systemHeadermapFiles.push_back(headermapFileForOwnTargetHeaders);
}
if (includeFrameworkEntriesForAllProductTypes) {
systemHeadermapFiles.push_back(headermapFileForAllTargetHeaders);
} else {
systemHeadermapFiles.push_back(headermapFileForAllNonFrameworkTargetHeaders);
}
userHeadermapFiles.push_back(headermapFileForGeneratedFiles);
if (includeProjectHeaders) {
userHeadermapFiles.push_back(headermapFileForProjectFiles);
}
}
Tool::HeadermapInfo *headermapInfo = &toolContext->headermapInfo();
headermapInfo->systemHeadermapFiles().insert(headermapInfo->systemHeadermapFiles().end(), systemHeadermapFiles.begin(), systemHeadermapFiles.end());
headermapInfo->userHeadermapFiles().insert(headermapInfo->userHeadermapFiles().end(), userHeadermapFiles.begin(), userHeadermapFiles.end());
}