Level Config::
level() const
{
std::vector<Setting> settings;
for (Entry const &entry : _contents) {
switch (entry.type()) {
case Entry::Type::Setting: {
Setting const &setting = *entry.setting();
settings.push_back(setting);
break;
}
case Entry::Type::Include: {
Level level = entry.config()->level();
settings.insert(settings.end(), level.settings().begin(), level.settings().end());
break;
}
}
}
return Level(settings);
}
bool PackageType::
parse(Context *context, plist::Dictionary const *dict, std::unordered_set<std::string> *seen, bool check)
{
if (!Specification::parse(context, dict, seen, false))
return false;
auto unpack = plist::Keys::Unpack("PackageType", dict, seen);
auto PR = unpack.cast <plist::Dictionary> ("ProductReference");
auto DBS = unpack.cast <plist::Dictionary> ("DefaultBuildSettings");
if (!unpack.complete(check)) {
fprintf(stderr, "%s", unpack.errorText().c_str());
}
if (PR != nullptr) {
ProductReference productReference;
if (productReference.parse(PR)) {
_productReference = productReference;
}
}
if (DBS != nullptr) {
std::vector<Setting> settings;
for (size_t n = 0; n < DBS->count(); n++) {
auto DBSK = DBS->key(n);
auto DBSV = DBS->value <plist::String> (DBSK);
if (DBSV != nullptr) {
Setting setting = Setting::Parse(DBSK, DBSV->value());
settings.push_back(setting);
}
}
_defaultBuildSettings = Level(settings);
}
return true;
}
bool ProductType::
parse(Context *context, plist::Dictionary const *dict, std::unordered_set<std::string> *seen, bool check)
{
if (!Specification::parse(context, dict, seen, false))
return false;
auto unpack = plist::Keys::Unpack("ProductType", dict, seen);
auto DTN = unpack.cast <plist::String> ("DefaultTargetName");
auto DBP = unpack.cast <plist::Dictionary> ("DefaultBuildProperties");
auto V = unpack.cast <plist::Dictionary> ("Validation");
auto INP = unpack.cast <plist::String> ("IconNamePrefix");
auto PTs = unpack.cast <plist::Array> ("PackageTypes");
auto HIP = unpack.coerce <plist::Boolean> ("HasInfoPlist");
auto HIPS = unpack.coerce <plist::Boolean> ("HasInfoPlistStrings");
auto IW = unpack.coerce <plist::Boolean> ("IsWrapper");
auto IJ = unpack.coerce <plist::Boolean> ("IsJava");
auto SZL = unpack.coerce <plist::Boolean> ("SupportsZeroLink");
auto APSS = unpack.coerce <plist::Boolean> ("AlwaysPerformSeparateStrip");
auto WSTE = unpack.coerce <plist::Boolean> ("WantsSimpleTargetEditing");
auto AWCR = unpack.coerce <plist::Boolean> ("AddWatchCompanionRequirement");
auto ROP = unpack.coerce <plist::Boolean> ("RunsOnProxy");
auto DSA = unpack.coerce <plist::Boolean> ("DisableSchemeAutocreation");
auto VEB = unpack.coerce <plist::Boolean> ("ValidateEmbeddedBinaries");
auto SODR = unpack.coerce <plist::Boolean> ("SupportsOnDemandResources");
auto CEAL = unpack.coerce <plist::Boolean> ("CanEmbedAddressSanitizerLibraries");
auto RSEF = unpack.coerce <plist::String> ("RunpathSearchPathForEmbeddedFrameworks");
auto IE = unpack.coerce <plist::Boolean> ("IsEmbeddable");
auto BPIWE = unpack.coerce <plist::Array> ("BuildPhaseInjectionsWhenEmbedding");
auto RBPD = unpack.coerce <plist::String> ("RequiredBuiltProductsDir");
if (!unpack.complete(check)) {
fprintf(stderr, "%s", unpack.errorText().c_str());
}
if (DTN != nullptr) {
_defaultTargetName = DTN->value();
}
if (DBP != nullptr) {
std::vector<Setting> settings;
for (size_t n = 0; n < DBP->count(); n++) {
auto DBPK = DBP->key(n);
auto DBPV = DBP->value <plist::String> (DBPK);
if (DBPV != nullptr) {
Setting setting = Setting::Parse(DBPK, DBPV->value());
settings.push_back(setting);
}
}
_defaultBuildProperties = Level(settings);
}
if (V != nullptr) {
_validation = Validation();
_validation->parse(V);
}
if (INP != nullptr) {
_iconNamePrefix = INP->value();
}
if (PTs != nullptr) {
_packageTypes = std::vector<std::string>();
for (size_t n = 0; n < PTs->count(); n++) {
if (auto PT = PTs->value <plist::String> (n)) {
_packageTypes->push_back(PT->value());
}
}
}
if (HIP != nullptr) {
_hasInfoPlist = HIP->value();
}
if (HIPS != nullptr) {
_hasInfoPlistStrings = HIPS->value();
}
if (IW != nullptr) {
_isWrapper = IW->value();
}
if (IJ != nullptr) {
_isJava = IJ->value();
}
if (SZL != nullptr) {
_supportsZeroLink = SZL->value();
}
if (APSS != nullptr) {
_alwaysPerformSeparateStrip = APSS->value();
}
if (WSTE != nullptr) {
_wantsSimpleTargetEditing = WSTE->value();
}
if (AWCR != nullptr) {
_addWatchCompanionRequirement = AWCR->value();
}
if (ROP != nullptr) {
_runsOnProxy = ROP->value();
}
if (DSA != nullptr) {
_disableSchemeAutocreation = DSA->value();
}
if (VEB != nullptr) {
_validateEmbeddedBinaries = VEB->value();
}
if (SODR != nullptr) {
_supportsOnDemandResources = SODR->value();
}
if (CEAL != nullptr) {
_canEmbedAddressSanitizerLibraries = CEAL->value();
}
if (RSEF != nullptr) {
_runpathSearchPathForEmbeddedFrameworks = RSEF->value();
}
if (IE != nullptr) {
_isEmbeddable = IE->value();
}
if (BPIWE != nullptr) {
_buildPhaseInjectionsWhenEmbedding = std::vector<BuildPhaseInjection>();
for (size_t n = 0; n < BPIWE->count(); n++) {
auto BPI = BPIWE->value <plist::Dictionary> (n);
if (BPI != nullptr) {
BuildPhaseInjection injection;
if (injection.parse(BPI)) {
_buildPhaseInjectionsWhenEmbedding->push_back(injection);
}
}
}
}
if (RBPD != nullptr) {
_requiredBuiltProductsDir = RBPD->value();
}
return true;
}
