1 //===- TextStubCommon.cpp -------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Implements common Text Stub YAML mappings. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "TextStubCommon.h" 14 #include "TextAPIContext.h" 15 #include "llvm/ADT/StringSwitch.h" 16 17 using namespace llvm::MachO; 18 19 namespace llvm { 20 namespace yaml { 21 22 void ScalarTraits<FlowStringRef>::output(const FlowStringRef &Value, void *Ctx, 23 raw_ostream &OS) { 24 ScalarTraits<StringRef>::output(Value, Ctx, OS); 25 } 26 StringRef ScalarTraits<FlowStringRef>::input(StringRef Value, void *Ctx, 27 FlowStringRef &Out) { 28 return ScalarTraits<StringRef>::input(Value, Ctx, Out.value); 29 } 30 QuotingType ScalarTraits<FlowStringRef>::mustQuote(StringRef Name) { 31 return ScalarTraits<StringRef>::mustQuote(Name); 32 } 33 34 void ScalarEnumerationTraits<ObjCConstraintType>::enumeration( 35 IO &IO, ObjCConstraintType &Constraint) { 36 IO.enumCase(Constraint, "none", ObjCConstraintType::None); 37 IO.enumCase(Constraint, "retain_release", ObjCConstraintType::Retain_Release); 38 IO.enumCase(Constraint, "retain_release_for_simulator", 39 ObjCConstraintType::Retain_Release_For_Simulator); 40 IO.enumCase(Constraint, "retain_release_or_gc", 41 ObjCConstraintType::Retain_Release_Or_GC); 42 IO.enumCase(Constraint, "gc", ObjCConstraintType::GC); 43 } 44 45 void ScalarTraits<PlatformSet>::output(const PlatformSet &Values, void *IO, 46 raw_ostream &OS) { 47 48 const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO); 49 assert((!Ctx || Ctx->FileKind != FileType::Invalid) && 50 "File type is not set in context"); 51 52 if (Ctx && Ctx->FileKind == TBD_V3 && Values.count(PLATFORM_MACOS) && 53 Values.count(PLATFORM_MACCATALYST)) { 54 OS << "zippered"; 55 return; 56 } 57 58 assert(Values.size() == 1U); 59 switch (*Values.begin()) { 60 default: 61 llvm_unreachable("unexpected platform"); 62 break; 63 case PLATFORM_MACOS: 64 OS << "macosx"; 65 break; 66 case PLATFORM_IOSSIMULATOR: 67 [[fallthrough]]; 68 case PLATFORM_IOS: 69 OS << "ios"; 70 break; 71 case PLATFORM_WATCHOSSIMULATOR: 72 [[fallthrough]]; 73 case PLATFORM_WATCHOS: 74 OS << "watchos"; 75 break; 76 case PLATFORM_TVOSSIMULATOR: 77 [[fallthrough]]; 78 case PLATFORM_TVOS: 79 OS << "tvos"; 80 break; 81 case PLATFORM_BRIDGEOS: 82 OS << "bridgeos"; 83 break; 84 case PLATFORM_MACCATALYST: 85 OS << "maccatalyst"; 86 break; 87 case PLATFORM_DRIVERKIT: 88 OS << "driverkit"; 89 break; 90 } 91 } 92 93 StringRef ScalarTraits<PlatformSet>::input(StringRef Scalar, void *IO, 94 PlatformSet &Values) { 95 const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO); 96 assert((!Ctx || Ctx->FileKind != FileType::Invalid) && 97 "File type is not set in context"); 98 99 if (Scalar == "zippered") { 100 if (Ctx && Ctx->FileKind == FileType::TBD_V3) { 101 Values.insert(PLATFORM_MACOS); 102 Values.insert(PLATFORM_MACCATALYST); 103 return {}; 104 } 105 return "invalid platform"; 106 } 107 108 auto Platform = StringSwitch<PlatformType>(Scalar) 109 .Case("macosx", PLATFORM_MACOS) 110 .Case("ios", PLATFORM_IOS) 111 .Case("watchos", PLATFORM_WATCHOS) 112 .Case("tvos", PLATFORM_TVOS) 113 .Case("bridgeos", PLATFORM_BRIDGEOS) 114 .Case("iosmac", PLATFORM_MACCATALYST) 115 .Case("maccatalyst", PLATFORM_MACCATALYST) 116 .Case("driverkit", PLATFORM_DRIVERKIT) 117 .Default(PLATFORM_UNKNOWN); 118 119 if (Platform == PLATFORM_MACCATALYST) 120 if (Ctx && Ctx->FileKind != FileType::TBD_V3) 121 return "invalid platform"; 122 123 if (Platform == PLATFORM_UNKNOWN) 124 return "unknown platform"; 125 126 Values.insert(Platform); 127 return {}; 128 } 129 130 QuotingType ScalarTraits<PlatformSet>::mustQuote(StringRef) { 131 return QuotingType::None; 132 } 133 134 void ScalarBitSetTraits<ArchitectureSet>::bitset(IO &IO, 135 ArchitectureSet &Archs) { 136 #define ARCHINFO(arch, type, subtype, numbits) \ 137 IO.bitSetCase(Archs, #arch, 1U << static_cast<int>(AK_##arch)); 138 #include "llvm/TextAPI/Architecture.def" 139 #undef ARCHINFO 140 } 141 142 void ScalarTraits<Architecture>::output(const Architecture &Value, void *, 143 raw_ostream &OS) { 144 OS << Value; 145 } 146 StringRef ScalarTraits<Architecture>::input(StringRef Scalar, void *, 147 Architecture &Value) { 148 Value = getArchitectureFromName(Scalar); 149 return {}; 150 } 151 QuotingType ScalarTraits<Architecture>::mustQuote(StringRef) { 152 return QuotingType::None; 153 } 154 155 void ScalarTraits<PackedVersion>::output(const PackedVersion &Value, void *, 156 raw_ostream &OS) { 157 OS << Value; 158 } 159 StringRef ScalarTraits<PackedVersion>::input(StringRef Scalar, void *, 160 PackedVersion &Value) { 161 if (!Value.parse32(Scalar)) 162 return "invalid packed version string."; 163 return {}; 164 } 165 QuotingType ScalarTraits<PackedVersion>::mustQuote(StringRef) { 166 return QuotingType::None; 167 } 168 169 void ScalarTraits<SwiftVersion>::output(const SwiftVersion &Value, void *, 170 raw_ostream &OS) { 171 switch (Value) { 172 case 1: 173 OS << "1.0"; 174 break; 175 case 2: 176 OS << "1.1"; 177 break; 178 case 3: 179 OS << "2.0"; 180 break; 181 case 4: 182 OS << "3.0"; 183 break; 184 default: 185 OS << (unsigned)Value; 186 break; 187 } 188 } 189 StringRef ScalarTraits<SwiftVersion>::input(StringRef Scalar, void *IO, 190 SwiftVersion &Value) { 191 const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO); 192 assert((!Ctx || Ctx->FileKind != FileType::Invalid) && 193 "File type is not set in context"); 194 195 if (Ctx->FileKind == FileType::TBD_V4) { 196 if (Scalar.getAsInteger(10, Value)) 197 return "invalid Swift ABI version."; 198 return {}; 199 } else { 200 Value = StringSwitch<SwiftVersion>(Scalar) 201 .Case("1.0", 1) 202 .Case("1.1", 2) 203 .Case("2.0", 3) 204 .Case("3.0", 4) 205 .Default(0); 206 } 207 208 if (Value != SwiftVersion(0)) 209 return {}; 210 211 if (Scalar.getAsInteger(10, Value)) 212 return "invalid Swift ABI version."; 213 214 return StringRef(); 215 } 216 QuotingType ScalarTraits<SwiftVersion>::mustQuote(StringRef) { 217 return QuotingType::None; 218 } 219 220 void ScalarTraits<UUID>::output(const UUID &Value, void *, raw_ostream &OS) {} 221 222 StringRef ScalarTraits<UUID>::input(StringRef Scalar, void *, UUID &Value) { 223 Value = {}; 224 return {}; 225 } 226 227 QuotingType ScalarTraits<UUID>::mustQuote(StringRef) { 228 return QuotingType::Single; 229 } 230 231 } // end namespace yaml. 232 } // end namespace llvm. 233