File: | llvm/lib/ObjectYAML/MinidumpYAML.cpp |
Warning: | line 408, column 9 1st function call argument is an uninitialized value |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===- MinidumpYAML.cpp - Minidump YAMLIO implementation ------------------===// | |||
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 | #include "llvm/ObjectYAML/MinidumpYAML.h" | |||
10 | #include "llvm/Support/Allocator.h" | |||
11 | ||||
12 | using namespace llvm; | |||
13 | using namespace llvm::MinidumpYAML; | |||
14 | using namespace llvm::minidump; | |||
15 | ||||
16 | /// Perform an optional yaml-mapping of an endian-aware type EndianType. The | |||
17 | /// only purpose of this function is to avoid casting the Default value to the | |||
18 | /// endian type; | |||
19 | template <typename EndianType> | |||
20 | static inline void mapOptional(yaml::IO &IO, const char *Key, EndianType &Val, | |||
21 | typename EndianType::value_type Default) { | |||
22 | IO.mapOptional(Key, Val, EndianType(Default)); | |||
23 | } | |||
24 | ||||
25 | /// Yaml-map an endian-aware type EndianType as some other type MapType. | |||
26 | template <typename MapType, typename EndianType> | |||
27 | static inline void mapRequiredAs(yaml::IO &IO, const char *Key, | |||
28 | EndianType &Val) { | |||
29 | MapType Mapped = static_cast<typename EndianType::value_type>(Val); | |||
30 | IO.mapRequired(Key, Mapped); | |||
31 | Val = static_cast<typename EndianType::value_type>(Mapped); | |||
32 | } | |||
33 | ||||
34 | /// Perform an optional yaml-mapping of an endian-aware type EndianType as some | |||
35 | /// other type MapType. | |||
36 | template <typename MapType, typename EndianType> | |||
37 | static inline void mapOptionalAs(yaml::IO &IO, const char *Key, EndianType &Val, | |||
38 | MapType Default) { | |||
39 | MapType Mapped = static_cast<typename EndianType::value_type>(Val); | |||
40 | IO.mapOptional(Key, Mapped, Default); | |||
41 | Val = static_cast<typename EndianType::value_type>(Mapped); | |||
42 | } | |||
43 | ||||
44 | namespace { | |||
45 | /// Return the appropriate yaml Hex type for a given endian-aware type. | |||
46 | template <typename EndianType> struct HexType; | |||
47 | template <> struct HexType<support::ulittle16_t> { using type = yaml::Hex16; }; | |||
48 | template <> struct HexType<support::ulittle32_t> { using type = yaml::Hex32; }; | |||
49 | template <> struct HexType<support::ulittle64_t> { using type = yaml::Hex64; }; | |||
50 | } // namespace | |||
51 | ||||
52 | /// Yaml-map an endian-aware type as an appropriately-sized hex value. | |||
53 | template <typename EndianType> | |||
54 | static inline void mapRequiredHex(yaml::IO &IO, const char *Key, | |||
55 | EndianType &Val) { | |||
56 | mapRequiredAs<typename HexType<EndianType>::type>(IO, Key, Val); | |||
57 | } | |||
58 | ||||
59 | /// Perform an optional yaml-mapping of an endian-aware type as an | |||
60 | /// appropriately-sized hex value. | |||
61 | template <typename EndianType> | |||
62 | static inline void mapOptionalHex(yaml::IO &IO, const char *Key, | |||
63 | EndianType &Val, | |||
64 | typename EndianType::value_type Default) { | |||
65 | mapOptionalAs<typename HexType<EndianType>::type>(IO, Key, Val, Default); | |||
66 | } | |||
67 | ||||
68 | Stream::~Stream() = default; | |||
69 | ||||
70 | Stream::StreamKind Stream::getKind(StreamType Type) { | |||
71 | switch (Type) { | |||
72 | case StreamType::Exception: | |||
73 | return StreamKind::Exception; | |||
74 | case StreamType::MemoryInfoList: | |||
75 | return StreamKind::MemoryInfoList; | |||
76 | case StreamType::MemoryList: | |||
77 | return StreamKind::MemoryList; | |||
78 | case StreamType::ModuleList: | |||
79 | return StreamKind::ModuleList; | |||
80 | case StreamType::SystemInfo: | |||
81 | return StreamKind::SystemInfo; | |||
82 | case StreamType::LinuxCPUInfo: | |||
83 | case StreamType::LinuxProcStatus: | |||
84 | case StreamType::LinuxLSBRelease: | |||
85 | case StreamType::LinuxCMDLine: | |||
86 | case StreamType::LinuxMaps: | |||
87 | case StreamType::LinuxProcStat: | |||
88 | case StreamType::LinuxProcUptime: | |||
89 | return StreamKind::TextContent; | |||
90 | case StreamType::ThreadList: | |||
91 | return StreamKind::ThreadList; | |||
92 | default: | |||
93 | return StreamKind::RawContent; | |||
94 | } | |||
95 | } | |||
96 | ||||
97 | std::unique_ptr<Stream> Stream::create(StreamType Type) { | |||
98 | StreamKind Kind = getKind(Type); | |||
99 | switch (Kind) { | |||
100 | case StreamKind::Exception: | |||
101 | return std::make_unique<ExceptionStream>(); | |||
102 | case StreamKind::MemoryInfoList: | |||
103 | return std::make_unique<MemoryInfoListStream>(); | |||
104 | case StreamKind::MemoryList: | |||
105 | return std::make_unique<MemoryListStream>(); | |||
106 | case StreamKind::ModuleList: | |||
107 | return std::make_unique<ModuleListStream>(); | |||
108 | case StreamKind::RawContent: | |||
109 | return std::make_unique<RawContentStream>(Type); | |||
110 | case StreamKind::SystemInfo: | |||
111 | return std::make_unique<SystemInfoStream>(); | |||
112 | case StreamKind::TextContent: | |||
113 | return std::make_unique<TextContentStream>(Type); | |||
114 | case StreamKind::ThreadList: | |||
115 | return std::make_unique<ThreadListStream>(); | |||
116 | } | |||
117 | llvm_unreachable("Unhandled stream kind!")::llvm::llvm_unreachable_internal("Unhandled stream kind!", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/ObjectYAML/MinidumpYAML.cpp" , 117); | |||
118 | } | |||
119 | ||||
120 | void yaml::ScalarBitSetTraits<MemoryProtection>::bitset( | |||
121 | IO &IO, MemoryProtection &Protect) { | |||
122 | #define HANDLE_MDMP_PROTECT(CODE, NAME, NATIVENAME) \ | |||
123 | IO.bitSetCase(Protect, #NATIVENAME, MemoryProtection::NAME); | |||
124 | #include "llvm/BinaryFormat/MinidumpConstants.def" | |||
125 | } | |||
126 | ||||
127 | void yaml::ScalarBitSetTraits<MemoryState>::bitset(IO &IO, MemoryState &State) { | |||
128 | #define HANDLE_MDMP_MEMSTATE(CODE, NAME, NATIVENAME) \ | |||
129 | IO.bitSetCase(State, #NATIVENAME, MemoryState::NAME); | |||
130 | #include "llvm/BinaryFormat/MinidumpConstants.def" | |||
131 | } | |||
132 | ||||
133 | void yaml::ScalarBitSetTraits<MemoryType>::bitset(IO &IO, MemoryType &Type) { | |||
134 | #define HANDLE_MDMP_MEMTYPE(CODE, NAME, NATIVENAME) \ | |||
135 | IO.bitSetCase(Type, #NATIVENAME, MemoryType::NAME); | |||
136 | #include "llvm/BinaryFormat/MinidumpConstants.def" | |||
137 | } | |||
138 | ||||
139 | void yaml::ScalarEnumerationTraits<ProcessorArchitecture>::enumeration( | |||
140 | IO &IO, ProcessorArchitecture &Arch) { | |||
141 | #define HANDLE_MDMP_ARCH(CODE, NAME) \ | |||
142 | IO.enumCase(Arch, #NAME, ProcessorArchitecture::NAME); | |||
143 | #include "llvm/BinaryFormat/MinidumpConstants.def" | |||
144 | IO.enumFallback<Hex16>(Arch); | |||
145 | } | |||
146 | ||||
147 | void yaml::ScalarEnumerationTraits<OSPlatform>::enumeration(IO &IO, | |||
148 | OSPlatform &Plat) { | |||
149 | #define HANDLE_MDMP_PLATFORM(CODE, NAME) \ | |||
150 | IO.enumCase(Plat, #NAME, OSPlatform::NAME); | |||
151 | #include "llvm/BinaryFormat/MinidumpConstants.def" | |||
152 | IO.enumFallback<Hex32>(Plat); | |||
153 | } | |||
154 | ||||
155 | void yaml::ScalarEnumerationTraits<StreamType>::enumeration(IO &IO, | |||
156 | StreamType &Type) { | |||
157 | #define HANDLE_MDMP_STREAM_TYPE(CODE, NAME) \ | |||
158 | IO.enumCase(Type, #NAME, StreamType::NAME); | |||
159 | #include "llvm/BinaryFormat/MinidumpConstants.def" | |||
160 | IO.enumFallback<Hex32>(Type); | |||
161 | } | |||
162 | ||||
163 | void yaml::MappingTraits<CPUInfo::ArmInfo>::mapping(IO &IO, | |||
164 | CPUInfo::ArmInfo &Info) { | |||
165 | mapRequiredHex(IO, "CPUID", Info.CPUID); | |||
166 | mapOptionalHex(IO, "ELF hwcaps", Info.ElfHWCaps, 0); | |||
167 | } | |||
168 | ||||
169 | namespace { | |||
170 | template <std::size_t N> struct FixedSizeHex { | |||
171 | FixedSizeHex(uint8_t (&Storage)[N]) : Storage(Storage) {} | |||
172 | ||||
173 | uint8_t (&Storage)[N]; | |||
174 | }; | |||
175 | } // namespace | |||
176 | ||||
177 | namespace llvm { | |||
178 | namespace yaml { | |||
179 | template <std::size_t N> struct ScalarTraits<FixedSizeHex<N>> { | |||
180 | static void output(const FixedSizeHex<N> &Fixed, void *, raw_ostream &OS) { | |||
181 | OS << toHex(makeArrayRef(Fixed.Storage)); | |||
182 | } | |||
183 | ||||
184 | static StringRef input(StringRef Scalar, void *, FixedSizeHex<N> &Fixed) { | |||
185 | if (!all_of(Scalar, isHexDigit)) | |||
186 | return "Invalid hex digit in input"; | |||
187 | if (Scalar.size() < 2 * N) | |||
188 | return "String too short"; | |||
189 | if (Scalar.size() > 2 * N) | |||
190 | return "String too long"; | |||
191 | copy(fromHex(Scalar), Fixed.Storage); | |||
192 | return ""; | |||
193 | } | |||
194 | ||||
195 | static QuotingType mustQuote(StringRef S) { return QuotingType::None; } | |||
196 | }; | |||
197 | } // namespace yaml | |||
198 | } // namespace llvm | |||
199 | void yaml::MappingTraits<CPUInfo::OtherInfo>::mapping( | |||
200 | IO &IO, CPUInfo::OtherInfo &Info) { | |||
201 | FixedSizeHex<sizeof(Info.ProcessorFeatures)> Features(Info.ProcessorFeatures); | |||
202 | IO.mapRequired("Features", Features); | |||
203 | } | |||
204 | ||||
205 | namespace { | |||
206 | /// A type which only accepts strings of a fixed size for yaml conversion. | |||
207 | template <std::size_t N> struct FixedSizeString { | |||
208 | FixedSizeString(char (&Storage)[N]) : Storage(Storage) {} | |||
209 | ||||
210 | char (&Storage)[N]; | |||
211 | }; | |||
212 | } // namespace | |||
213 | ||||
214 | namespace llvm { | |||
215 | namespace yaml { | |||
216 | template <std::size_t N> struct ScalarTraits<FixedSizeString<N>> { | |||
217 | static void output(const FixedSizeString<N> &Fixed, void *, raw_ostream &OS) { | |||
218 | OS << StringRef(Fixed.Storage, N); | |||
219 | } | |||
220 | ||||
221 | static StringRef input(StringRef Scalar, void *, FixedSizeString<N> &Fixed) { | |||
222 | if (Scalar.size() < N) | |||
223 | return "String too short"; | |||
224 | if (Scalar.size() > N) | |||
225 | return "String too long"; | |||
226 | copy(Scalar, Fixed.Storage); | |||
227 | return ""; | |||
228 | } | |||
229 | ||||
230 | static QuotingType mustQuote(StringRef S) { return needsQuotes(S); } | |||
231 | }; | |||
232 | } // namespace yaml | |||
233 | } // namespace llvm | |||
234 | ||||
235 | void yaml::MappingTraits<CPUInfo::X86Info>::mapping(IO &IO, | |||
236 | CPUInfo::X86Info &Info) { | |||
237 | FixedSizeString<sizeof(Info.VendorID)> VendorID(Info.VendorID); | |||
238 | IO.mapRequired("Vendor ID", VendorID); | |||
239 | ||||
240 | mapRequiredHex(IO, "Version Info", Info.VersionInfo); | |||
241 | mapRequiredHex(IO, "Feature Info", Info.FeatureInfo); | |||
242 | mapOptionalHex(IO, "AMD Extended Features", Info.AMDExtendedFeatures, 0); | |||
243 | } | |||
244 | ||||
245 | void yaml::MappingTraits<MemoryInfo>::mapping(IO &IO, MemoryInfo &Info) { | |||
246 | mapRequiredHex(IO, "Base Address", Info.BaseAddress); | |||
247 | mapOptionalHex(IO, "Allocation Base", Info.AllocationBase, Info.BaseAddress); | |||
248 | mapRequiredAs<MemoryProtection>(IO, "Allocation Protect", | |||
249 | Info.AllocationProtect); | |||
250 | mapOptionalHex(IO, "Reserved0", Info.Reserved0, 0); | |||
251 | mapRequiredHex(IO, "Region Size", Info.RegionSize); | |||
252 | mapRequiredAs<MemoryState>(IO, "State", Info.State); | |||
253 | mapOptionalAs<MemoryProtection>(IO, "Protect", Info.Protect, | |||
254 | Info.AllocationProtect); | |||
255 | mapRequiredAs<MemoryType>(IO, "Type", Info.Type); | |||
256 | mapOptionalHex(IO, "Reserved1", Info.Reserved1, 0); | |||
257 | } | |||
258 | ||||
259 | void yaml::MappingTraits<VSFixedFileInfo>::mapping(IO &IO, | |||
260 | VSFixedFileInfo &Info) { | |||
261 | mapOptionalHex(IO, "Signature", Info.Signature, 0); | |||
262 | mapOptionalHex(IO, "Struct Version", Info.StructVersion, 0); | |||
263 | mapOptionalHex(IO, "File Version High", Info.FileVersionHigh, 0); | |||
264 | mapOptionalHex(IO, "File Version Low", Info.FileVersionLow, 0); | |||
265 | mapOptionalHex(IO, "Product Version High", Info.ProductVersionHigh, 0); | |||
266 | mapOptionalHex(IO, "Product Version Low", Info.ProductVersionLow, 0); | |||
267 | mapOptionalHex(IO, "File Flags Mask", Info.FileFlagsMask, 0); | |||
268 | mapOptionalHex(IO, "File Flags", Info.FileFlags, 0); | |||
269 | mapOptionalHex(IO, "File OS", Info.FileOS, 0); | |||
270 | mapOptionalHex(IO, "File Type", Info.FileType, 0); | |||
271 | mapOptionalHex(IO, "File Subtype", Info.FileSubtype, 0); | |||
272 | mapOptionalHex(IO, "File Date High", Info.FileDateHigh, 0); | |||
273 | mapOptionalHex(IO, "File Date Low", Info.FileDateLow, 0); | |||
274 | } | |||
275 | ||||
276 | void yaml::MappingTraits<ModuleListStream::entry_type>::mapping( | |||
277 | IO &IO, ModuleListStream::entry_type &M) { | |||
278 | mapRequiredHex(IO, "Base of Image", M.Entry.BaseOfImage); | |||
279 | mapRequiredHex(IO, "Size of Image", M.Entry.SizeOfImage); | |||
280 | mapOptionalHex(IO, "Checksum", M.Entry.Checksum, 0); | |||
281 | mapOptional(IO, "Time Date Stamp", M.Entry.TimeDateStamp, 0); | |||
282 | IO.mapRequired("Module Name", M.Name); | |||
283 | IO.mapOptional("Version Info", M.Entry.VersionInfo, VSFixedFileInfo()); | |||
284 | IO.mapRequired("CodeView Record", M.CvRecord); | |||
285 | IO.mapOptional("Misc Record", M.MiscRecord, yaml::BinaryRef()); | |||
286 | mapOptionalHex(IO, "Reserved0", M.Entry.Reserved0, 0); | |||
287 | mapOptionalHex(IO, "Reserved1", M.Entry.Reserved1, 0); | |||
288 | } | |||
289 | ||||
290 | static void streamMapping(yaml::IO &IO, RawContentStream &Stream) { | |||
291 | IO.mapOptional("Content", Stream.Content); | |||
292 | IO.mapOptional("Size", Stream.Size, Stream.Content.binary_size()); | |||
293 | } | |||
294 | ||||
295 | static std::string streamValidate(RawContentStream &Stream) { | |||
296 | if (Stream.Size.value < Stream.Content.binary_size()) | |||
297 | return "Stream size must be greater or equal to the content size"; | |||
298 | return ""; | |||
299 | } | |||
300 | ||||
301 | void yaml::MappingTraits<MemoryListStream::entry_type>::mapping( | |||
302 | IO &IO, MemoryListStream::entry_type &Range) { | |||
303 | MappingContextTraits<MemoryDescriptor, yaml::BinaryRef>::mapping( | |||
304 | IO, Range.Entry, Range.Content); | |||
305 | } | |||
306 | ||||
307 | static void streamMapping(yaml::IO &IO, MemoryInfoListStream &Stream) { | |||
308 | IO.mapRequired("Memory Ranges", Stream.Infos); | |||
309 | } | |||
310 | ||||
311 | static void streamMapping(yaml::IO &IO, MemoryListStream &Stream) { | |||
312 | IO.mapRequired("Memory Ranges", Stream.Entries); | |||
313 | } | |||
314 | ||||
315 | static void streamMapping(yaml::IO &IO, ModuleListStream &Stream) { | |||
316 | IO.mapRequired("Modules", Stream.Entries); | |||
317 | } | |||
318 | ||||
319 | static void streamMapping(yaml::IO &IO, SystemInfoStream &Stream) { | |||
320 | SystemInfo &Info = Stream.Info; | |||
321 | IO.mapRequired("Processor Arch", Info.ProcessorArch); | |||
322 | mapOptional(IO, "Processor Level", Info.ProcessorLevel, 0); | |||
323 | mapOptional(IO, "Processor Revision", Info.ProcessorRevision, 0); | |||
324 | IO.mapOptional("Number of Processors", Info.NumberOfProcessors, 0); | |||
325 | IO.mapOptional("Product type", Info.ProductType, 0); | |||
326 | mapOptional(IO, "Major Version", Info.MajorVersion, 0); | |||
327 | mapOptional(IO, "Minor Version", Info.MinorVersion, 0); | |||
328 | mapOptional(IO, "Build Number", Info.BuildNumber, 0); | |||
329 | IO.mapRequired("Platform ID", Info.PlatformId); | |||
330 | IO.mapOptional("CSD Version", Stream.CSDVersion, ""); | |||
331 | mapOptionalHex(IO, "Suite Mask", Info.SuiteMask, 0); | |||
332 | mapOptionalHex(IO, "Reserved", Info.Reserved, 0); | |||
333 | switch (static_cast<ProcessorArchitecture>(Info.ProcessorArch)) { | |||
334 | case ProcessorArchitecture::X86: | |||
335 | case ProcessorArchitecture::AMD64: | |||
336 | IO.mapOptional("CPU", Info.CPU.X86); | |||
337 | break; | |||
338 | case ProcessorArchitecture::ARM: | |||
339 | case ProcessorArchitecture::ARM64: | |||
340 | case ProcessorArchitecture::BP_ARM64: | |||
341 | IO.mapOptional("CPU", Info.CPU.Arm); | |||
342 | break; | |||
343 | default: | |||
344 | IO.mapOptional("CPU", Info.CPU.Other); | |||
345 | break; | |||
346 | } | |||
347 | } | |||
348 | ||||
349 | static void streamMapping(yaml::IO &IO, TextContentStream &Stream) { | |||
350 | IO.mapOptional("Text", Stream.Text); | |||
351 | } | |||
352 | ||||
353 | void yaml::MappingContextTraits<MemoryDescriptor, yaml::BinaryRef>::mapping( | |||
354 | IO &IO, MemoryDescriptor &Memory, BinaryRef &Content) { | |||
355 | mapRequiredHex(IO, "Start of Memory Range", Memory.StartOfMemoryRange); | |||
356 | IO.mapRequired("Content", Content); | |||
357 | } | |||
358 | ||||
359 | void yaml::MappingTraits<ThreadListStream::entry_type>::mapping( | |||
360 | IO &IO, ThreadListStream::entry_type &T) { | |||
361 | mapRequiredHex(IO, "Thread Id", T.Entry.ThreadId); | |||
362 | mapOptionalHex(IO, "Suspend Count", T.Entry.SuspendCount, 0); | |||
363 | mapOptionalHex(IO, "Priority Class", T.Entry.PriorityClass, 0); | |||
364 | mapOptionalHex(IO, "Priority", T.Entry.Priority, 0); | |||
365 | mapOptionalHex(IO, "Environment Block", T.Entry.EnvironmentBlock, 0); | |||
366 | IO.mapRequired("Context", T.Context); | |||
367 | IO.mapRequired("Stack", T.Entry.Stack, T.Stack); | |||
368 | } | |||
369 | ||||
370 | static void streamMapping(yaml::IO &IO, ThreadListStream &Stream) { | |||
371 | IO.mapRequired("Threads", Stream.Entries); | |||
372 | } | |||
373 | ||||
374 | static void streamMapping(yaml::IO &IO, MinidumpYAML::ExceptionStream &Stream) { | |||
375 | mapRequiredHex(IO, "Thread ID", Stream.MDExceptionStream.ThreadId); | |||
376 | IO.mapRequired("Exception Record", Stream.MDExceptionStream.ExceptionRecord); | |||
377 | IO.mapRequired("Thread Context", Stream.ThreadContext); | |||
378 | } | |||
379 | ||||
380 | void yaml::MappingTraits<minidump::Exception>::mapping( | |||
381 | yaml::IO &IO, minidump::Exception &Exception) { | |||
382 | mapRequiredHex(IO, "Exception Code", Exception.ExceptionCode); | |||
383 | mapOptionalHex(IO, "Exception Flags", Exception.ExceptionFlags, 0); | |||
384 | mapOptionalHex(IO, "Exception Record", Exception.ExceptionRecord, 0); | |||
385 | mapOptionalHex(IO, "Exception Address", Exception.ExceptionAddress, 0); | |||
386 | mapOptional(IO, "Number of Parameters", Exception.NumberParameters, 0); | |||
387 | ||||
388 | for (size_t Index = 0; Index < Exception.MaxParameters; ++Index) { | |||
389 | SmallString<16> Name("Parameter "); | |||
390 | Twine(Index).toVector(Name); | |||
391 | support::ulittle64_t &Field = Exception.ExceptionInformation[Index]; | |||
392 | ||||
393 | if (Index < Exception.NumberParameters) | |||
394 | mapRequiredHex(IO, Name.c_str(), Field); | |||
395 | else | |||
396 | mapOptionalHex(IO, Name.c_str(), Field, 0); | |||
397 | } | |||
398 | } | |||
399 | ||||
400 | void yaml::MappingTraits<std::unique_ptr<Stream>>::mapping( | |||
401 | yaml::IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S) { | |||
402 | StreamType Type; | |||
403 | if (IO.outputting()) | |||
404 | Type = S->Type; | |||
405 | IO.mapRequired("Type", Type); | |||
406 | ||||
407 | if (!IO.outputting()) | |||
408 | S = MinidumpYAML::Stream::create(Type); | |||
| ||||
409 | switch (S->Kind) { | |||
410 | case MinidumpYAML::Stream::StreamKind::Exception: | |||
411 | streamMapping(IO, llvm::cast<MinidumpYAML::ExceptionStream>(*S)); | |||
412 | break; | |||
413 | case MinidumpYAML::Stream::StreamKind::MemoryInfoList: | |||
414 | streamMapping(IO, llvm::cast<MemoryInfoListStream>(*S)); | |||
415 | break; | |||
416 | case MinidumpYAML::Stream::StreamKind::MemoryList: | |||
417 | streamMapping(IO, llvm::cast<MemoryListStream>(*S)); | |||
418 | break; | |||
419 | case MinidumpYAML::Stream::StreamKind::ModuleList: | |||
420 | streamMapping(IO, llvm::cast<ModuleListStream>(*S)); | |||
421 | break; | |||
422 | case MinidumpYAML::Stream::StreamKind::RawContent: | |||
423 | streamMapping(IO, llvm::cast<RawContentStream>(*S)); | |||
424 | break; | |||
425 | case MinidumpYAML::Stream::StreamKind::SystemInfo: | |||
426 | streamMapping(IO, llvm::cast<SystemInfoStream>(*S)); | |||
427 | break; | |||
428 | case MinidumpYAML::Stream::StreamKind::TextContent: | |||
429 | streamMapping(IO, llvm::cast<TextContentStream>(*S)); | |||
430 | break; | |||
431 | case MinidumpYAML::Stream::StreamKind::ThreadList: | |||
432 | streamMapping(IO, llvm::cast<ThreadListStream>(*S)); | |||
433 | break; | |||
434 | } | |||
435 | } | |||
436 | ||||
437 | std::string yaml::MappingTraits<std::unique_ptr<Stream>>::validate( | |||
438 | yaml::IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S) { | |||
439 | switch (S->Kind) { | |||
440 | case MinidumpYAML::Stream::StreamKind::RawContent: | |||
441 | return streamValidate(cast<RawContentStream>(*S)); | |||
442 | case MinidumpYAML::Stream::StreamKind::Exception: | |||
443 | case MinidumpYAML::Stream::StreamKind::MemoryInfoList: | |||
444 | case MinidumpYAML::Stream::StreamKind::MemoryList: | |||
445 | case MinidumpYAML::Stream::StreamKind::ModuleList: | |||
446 | case MinidumpYAML::Stream::StreamKind::SystemInfo: | |||
447 | case MinidumpYAML::Stream::StreamKind::TextContent: | |||
448 | case MinidumpYAML::Stream::StreamKind::ThreadList: | |||
449 | return ""; | |||
450 | } | |||
451 | llvm_unreachable("Fully covered switch above!")::llvm::llvm_unreachable_internal("Fully covered switch above!" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/ObjectYAML/MinidumpYAML.cpp" , 451); | |||
452 | } | |||
453 | ||||
454 | void yaml::MappingTraits<Object>::mapping(IO &IO, Object &O) { | |||
455 | IO.mapTag("!minidump", true); | |||
456 | mapOptionalHex(IO, "Signature", O.Header.Signature, Header::MagicSignature); | |||
457 | mapOptionalHex(IO, "Version", O.Header.Version, Header::MagicVersion); | |||
458 | mapOptionalHex(IO, "Flags", O.Header.Flags, 0); | |||
459 | IO.mapRequired("Streams", O.Streams); | |||
| ||||
460 | } | |||
461 | ||||
462 | Expected<std::unique_ptr<Stream>> | |||
463 | Stream::create(const Directory &StreamDesc, const object::MinidumpFile &File) { | |||
464 | StreamKind Kind = getKind(StreamDesc.Type); | |||
465 | switch (Kind) { | |||
466 | case StreamKind::Exception: { | |||
467 | Expected<const minidump::ExceptionStream &> ExpectedExceptionStream = | |||
468 | File.getExceptionStream(); | |||
469 | if (!ExpectedExceptionStream) | |||
470 | return ExpectedExceptionStream.takeError(); | |||
471 | Expected<ArrayRef<uint8_t>> ExpectedThreadContext = | |||
472 | File.getRawData(ExpectedExceptionStream->ThreadContext); | |||
473 | if (!ExpectedThreadContext) | |||
474 | return ExpectedThreadContext.takeError(); | |||
475 | return std::make_unique<ExceptionStream>(*ExpectedExceptionStream, | |||
476 | *ExpectedThreadContext); | |||
477 | } | |||
478 | case StreamKind::MemoryInfoList: { | |||
479 | if (auto ExpectedList = File.getMemoryInfoList()) | |||
480 | return std::make_unique<MemoryInfoListStream>(*ExpectedList); | |||
481 | else | |||
482 | return ExpectedList.takeError(); | |||
483 | } | |||
484 | case StreamKind::MemoryList: { | |||
485 | auto ExpectedList = File.getMemoryList(); | |||
486 | if (!ExpectedList) | |||
487 | return ExpectedList.takeError(); | |||
488 | std::vector<MemoryListStream::entry_type> Ranges; | |||
489 | for (const MemoryDescriptor &MD : *ExpectedList) { | |||
490 | auto ExpectedContent = File.getRawData(MD.Memory); | |||
491 | if (!ExpectedContent) | |||
492 | return ExpectedContent.takeError(); | |||
493 | Ranges.push_back({MD, *ExpectedContent}); | |||
494 | } | |||
495 | return std::make_unique<MemoryListStream>(std::move(Ranges)); | |||
496 | } | |||
497 | case StreamKind::ModuleList: { | |||
498 | auto ExpectedList = File.getModuleList(); | |||
499 | if (!ExpectedList) | |||
500 | return ExpectedList.takeError(); | |||
501 | std::vector<ModuleListStream::entry_type> Modules; | |||
502 | for (const Module &M : *ExpectedList) { | |||
503 | auto ExpectedName = File.getString(M.ModuleNameRVA); | |||
504 | if (!ExpectedName) | |||
505 | return ExpectedName.takeError(); | |||
506 | auto ExpectedCv = File.getRawData(M.CvRecord); | |||
507 | if (!ExpectedCv) | |||
508 | return ExpectedCv.takeError(); | |||
509 | auto ExpectedMisc = File.getRawData(M.MiscRecord); | |||
510 | if (!ExpectedMisc) | |||
511 | return ExpectedMisc.takeError(); | |||
512 | Modules.push_back( | |||
513 | {M, std::move(*ExpectedName), *ExpectedCv, *ExpectedMisc}); | |||
514 | } | |||
515 | return std::make_unique<ModuleListStream>(std::move(Modules)); | |||
516 | } | |||
517 | case StreamKind::RawContent: | |||
518 | return std::make_unique<RawContentStream>(StreamDesc.Type, | |||
519 | File.getRawStream(StreamDesc)); | |||
520 | case StreamKind::SystemInfo: { | |||
521 | auto ExpectedInfo = File.getSystemInfo(); | |||
522 | if (!ExpectedInfo) | |||
523 | return ExpectedInfo.takeError(); | |||
524 | auto ExpectedCSDVersion = File.getString(ExpectedInfo->CSDVersionRVA); | |||
525 | if (!ExpectedCSDVersion) | |||
526 | return ExpectedInfo.takeError(); | |||
527 | return std::make_unique<SystemInfoStream>(*ExpectedInfo, | |||
528 | std::move(*ExpectedCSDVersion)); | |||
529 | } | |||
530 | case StreamKind::TextContent: | |||
531 | return std::make_unique<TextContentStream>( | |||
532 | StreamDesc.Type, toStringRef(File.getRawStream(StreamDesc))); | |||
533 | case StreamKind::ThreadList: { | |||
534 | auto ExpectedList = File.getThreadList(); | |||
535 | if (!ExpectedList) | |||
536 | return ExpectedList.takeError(); | |||
537 | std::vector<ThreadListStream::entry_type> Threads; | |||
538 | for (const Thread &T : *ExpectedList) { | |||
539 | auto ExpectedStack = File.getRawData(T.Stack.Memory); | |||
540 | if (!ExpectedStack) | |||
541 | return ExpectedStack.takeError(); | |||
542 | auto ExpectedContext = File.getRawData(T.Context); | |||
543 | if (!ExpectedContext) | |||
544 | return ExpectedContext.takeError(); | |||
545 | Threads.push_back({T, *ExpectedStack, *ExpectedContext}); | |||
546 | } | |||
547 | return std::make_unique<ThreadListStream>(std::move(Threads)); | |||
548 | } | |||
549 | } | |||
550 | llvm_unreachable("Unhandled stream kind!")::llvm::llvm_unreachable_internal("Unhandled stream kind!", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/ObjectYAML/MinidumpYAML.cpp" , 550); | |||
551 | } | |||
552 | ||||
553 | Expected<Object> Object::create(const object::MinidumpFile &File) { | |||
554 | std::vector<std::unique_ptr<Stream>> Streams; | |||
555 | Streams.reserve(File.streams().size()); | |||
556 | for (const Directory &StreamDesc : File.streams()) { | |||
557 | auto ExpectedStream = Stream::create(StreamDesc, File); | |||
558 | if (!ExpectedStream) | |||
559 | return ExpectedStream.takeError(); | |||
560 | Streams.push_back(std::move(*ExpectedStream)); | |||
561 | } | |||
562 | return Object(File.header(), std::move(Streams)); | |||
563 | } |
1 | //===- llvm/Support/YAMLTraits.h --------------------------------*- C++ -*-===// | ||||
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 | #ifndef LLVM_SUPPORT_YAMLTRAITS_H | ||||
10 | #define LLVM_SUPPORT_YAMLTRAITS_H | ||||
11 | |||||
12 | #include "llvm/ADT/Optional.h" | ||||
13 | #include "llvm/ADT/SmallVector.h" | ||||
14 | #include "llvm/ADT/StringExtras.h" | ||||
15 | #include "llvm/ADT/StringMap.h" | ||||
16 | #include "llvm/ADT/StringRef.h" | ||||
17 | #include "llvm/ADT/Twine.h" | ||||
18 | #include "llvm/Support/AlignOf.h" | ||||
19 | #include "llvm/Support/Allocator.h" | ||||
20 | #include "llvm/Support/Endian.h" | ||||
21 | #include "llvm/Support/Regex.h" | ||||
22 | #include "llvm/Support/SMLoc.h" | ||||
23 | #include "llvm/Support/SourceMgr.h" | ||||
24 | #include "llvm/Support/VersionTuple.h" | ||||
25 | #include "llvm/Support/YAMLParser.h" | ||||
26 | #include "llvm/Support/raw_ostream.h" | ||||
27 | #include <cassert> | ||||
28 | #include <cctype> | ||||
29 | #include <cstddef> | ||||
30 | #include <cstdint> | ||||
31 | #include <iterator> | ||||
32 | #include <map> | ||||
33 | #include <memory> | ||||
34 | #include <new> | ||||
35 | #include <string> | ||||
36 | #include <system_error> | ||||
37 | #include <type_traits> | ||||
38 | #include <vector> | ||||
39 | |||||
40 | namespace llvm { | ||||
41 | namespace yaml { | ||||
42 | |||||
43 | enum class NodeKind : uint8_t { | ||||
44 | Scalar, | ||||
45 | Map, | ||||
46 | Sequence, | ||||
47 | }; | ||||
48 | |||||
49 | struct EmptyContext {}; | ||||
50 | |||||
51 | /// This class should be specialized by any type that needs to be converted | ||||
52 | /// to/from a YAML mapping. For example: | ||||
53 | /// | ||||
54 | /// struct MappingTraits<MyStruct> { | ||||
55 | /// static void mapping(IO &io, MyStruct &s) { | ||||
56 | /// io.mapRequired("name", s.name); | ||||
57 | /// io.mapRequired("size", s.size); | ||||
58 | /// io.mapOptional("age", s.age); | ||||
59 | /// } | ||||
60 | /// }; | ||||
61 | template<class T> | ||||
62 | struct MappingTraits { | ||||
63 | // Must provide: | ||||
64 | // static void mapping(IO &io, T &fields); | ||||
65 | // Optionally may provide: | ||||
66 | // static std::string validate(IO &io, T &fields); | ||||
67 | // | ||||
68 | // The optional flow flag will cause generated YAML to use a flow mapping | ||||
69 | // (e.g. { a: 0, b: 1 }): | ||||
70 | // static const bool flow = true; | ||||
71 | }; | ||||
72 | |||||
73 | /// This class is similar to MappingTraits<T> but allows you to pass in | ||||
74 | /// additional context for each map operation. For example: | ||||
75 | /// | ||||
76 | /// struct MappingContextTraits<MyStruct, MyContext> { | ||||
77 | /// static void mapping(IO &io, MyStruct &s, MyContext &c) { | ||||
78 | /// io.mapRequired("name", s.name); | ||||
79 | /// io.mapRequired("size", s.size); | ||||
80 | /// io.mapOptional("age", s.age); | ||||
81 | /// ++c.TimesMapped; | ||||
82 | /// } | ||||
83 | /// }; | ||||
84 | template <class T, class Context> struct MappingContextTraits { | ||||
85 | // Must provide: | ||||
86 | // static void mapping(IO &io, T &fields, Context &Ctx); | ||||
87 | // Optionally may provide: | ||||
88 | // static std::string validate(IO &io, T &fields, Context &Ctx); | ||||
89 | // | ||||
90 | // The optional flow flag will cause generated YAML to use a flow mapping | ||||
91 | // (e.g. { a: 0, b: 1 }): | ||||
92 | // static const bool flow = true; | ||||
93 | }; | ||||
94 | |||||
95 | /// This class should be specialized by any integral type that converts | ||||
96 | /// to/from a YAML scalar where there is a one-to-one mapping between | ||||
97 | /// in-memory values and a string in YAML. For example: | ||||
98 | /// | ||||
99 | /// struct ScalarEnumerationTraits<Colors> { | ||||
100 | /// static void enumeration(IO &io, Colors &value) { | ||||
101 | /// io.enumCase(value, "red", cRed); | ||||
102 | /// io.enumCase(value, "blue", cBlue); | ||||
103 | /// io.enumCase(value, "green", cGreen); | ||||
104 | /// } | ||||
105 | /// }; | ||||
106 | template <typename T, typename Enable = void> struct ScalarEnumerationTraits { | ||||
107 | // Must provide: | ||||
108 | // static void enumeration(IO &io, T &value); | ||||
109 | }; | ||||
110 | |||||
111 | /// This class should be specialized by any integer type that is a union | ||||
112 | /// of bit values and the YAML representation is a flow sequence of | ||||
113 | /// strings. For example: | ||||
114 | /// | ||||
115 | /// struct ScalarBitSetTraits<MyFlags> { | ||||
116 | /// static void bitset(IO &io, MyFlags &value) { | ||||
117 | /// io.bitSetCase(value, "big", flagBig); | ||||
118 | /// io.bitSetCase(value, "flat", flagFlat); | ||||
119 | /// io.bitSetCase(value, "round", flagRound); | ||||
120 | /// } | ||||
121 | /// }; | ||||
122 | template <typename T, typename Enable = void> struct ScalarBitSetTraits { | ||||
123 | // Must provide: | ||||
124 | // static void bitset(IO &io, T &value); | ||||
125 | }; | ||||
126 | |||||
127 | /// Describe which type of quotes should be used when quoting is necessary. | ||||
128 | /// Some non-printable characters need to be double-quoted, while some others | ||||
129 | /// are fine with simple-quoting, and some don't need any quoting. | ||||
130 | enum class QuotingType { None, Single, Double }; | ||||
131 | |||||
132 | /// This class should be specialized by type that requires custom conversion | ||||
133 | /// to/from a yaml scalar. For example: | ||||
134 | /// | ||||
135 | /// template<> | ||||
136 | /// struct ScalarTraits<MyType> { | ||||
137 | /// static void output(const MyType &val, void*, llvm::raw_ostream &out) { | ||||
138 | /// // stream out custom formatting | ||||
139 | /// out << llvm::format("%x", val); | ||||
140 | /// } | ||||
141 | /// static StringRef input(StringRef scalar, void*, MyType &value) { | ||||
142 | /// // parse scalar and set `value` | ||||
143 | /// // return empty string on success, or error string | ||||
144 | /// return StringRef(); | ||||
145 | /// } | ||||
146 | /// static QuotingType mustQuote(StringRef) { return QuotingType::Single; } | ||||
147 | /// }; | ||||
148 | template <typename T, typename Enable = void> struct ScalarTraits { | ||||
149 | // Must provide: | ||||
150 | // | ||||
151 | // Function to write the value as a string: | ||||
152 | // static void output(const T &value, void *ctxt, llvm::raw_ostream &out); | ||||
153 | // | ||||
154 | // Function to convert a string to a value. Returns the empty | ||||
155 | // StringRef on success or an error string if string is malformed: | ||||
156 | // static StringRef input(StringRef scalar, void *ctxt, T &value); | ||||
157 | // | ||||
158 | // Function to determine if the value should be quoted. | ||||
159 | // static QuotingType mustQuote(StringRef); | ||||
160 | }; | ||||
161 | |||||
162 | /// This class should be specialized by type that requires custom conversion | ||||
163 | /// to/from a YAML literal block scalar. For example: | ||||
164 | /// | ||||
165 | /// template <> | ||||
166 | /// struct BlockScalarTraits<MyType> { | ||||
167 | /// static void output(const MyType &Value, void*, llvm::raw_ostream &Out) | ||||
168 | /// { | ||||
169 | /// // stream out custom formatting | ||||
170 | /// Out << Value; | ||||
171 | /// } | ||||
172 | /// static StringRef input(StringRef Scalar, void*, MyType &Value) { | ||||
173 | /// // parse scalar and set `value` | ||||
174 | /// // return empty string on success, or error string | ||||
175 | /// return StringRef(); | ||||
176 | /// } | ||||
177 | /// }; | ||||
178 | template <typename T> | ||||
179 | struct BlockScalarTraits { | ||||
180 | // Must provide: | ||||
181 | // | ||||
182 | // Function to write the value as a string: | ||||
183 | // static void output(const T &Value, void *ctx, llvm::raw_ostream &Out); | ||||
184 | // | ||||
185 | // Function to convert a string to a value. Returns the empty | ||||
186 | // StringRef on success or an error string if string is malformed: | ||||
187 | // static StringRef input(StringRef Scalar, void *ctxt, T &Value); | ||||
188 | // | ||||
189 | // Optional: | ||||
190 | // static StringRef inputTag(T &Val, std::string Tag) | ||||
191 | // static void outputTag(const T &Val, raw_ostream &Out) | ||||
192 | }; | ||||
193 | |||||
194 | /// This class should be specialized by type that requires custom conversion | ||||
195 | /// to/from a YAML scalar with optional tags. For example: | ||||
196 | /// | ||||
197 | /// template <> | ||||
198 | /// struct TaggedScalarTraits<MyType> { | ||||
199 | /// static void output(const MyType &Value, void*, llvm::raw_ostream | ||||
200 | /// &ScalarOut, llvm::raw_ostream &TagOut) | ||||
201 | /// { | ||||
202 | /// // stream out custom formatting including optional Tag | ||||
203 | /// Out << Value; | ||||
204 | /// } | ||||
205 | /// static StringRef input(StringRef Scalar, StringRef Tag, void*, MyType | ||||
206 | /// &Value) { | ||||
207 | /// // parse scalar and set `value` | ||||
208 | /// // return empty string on success, or error string | ||||
209 | /// return StringRef(); | ||||
210 | /// } | ||||
211 | /// static QuotingType mustQuote(const MyType &Value, StringRef) { | ||||
212 | /// return QuotingType::Single; | ||||
213 | /// } | ||||
214 | /// }; | ||||
215 | template <typename T> struct TaggedScalarTraits { | ||||
216 | // Must provide: | ||||
217 | // | ||||
218 | // Function to write the value and tag as strings: | ||||
219 | // static void output(const T &Value, void *ctx, llvm::raw_ostream &ScalarOut, | ||||
220 | // llvm::raw_ostream &TagOut); | ||||
221 | // | ||||
222 | // Function to convert a string to a value. Returns the empty | ||||
223 | // StringRef on success or an error string if string is malformed: | ||||
224 | // static StringRef input(StringRef Scalar, StringRef Tag, void *ctxt, T | ||||
225 | // &Value); | ||||
226 | // | ||||
227 | // Function to determine if the value should be quoted. | ||||
228 | // static QuotingType mustQuote(const T &Value, StringRef Scalar); | ||||
229 | }; | ||||
230 | |||||
231 | /// This class should be specialized by any type that needs to be converted | ||||
232 | /// to/from a YAML sequence. For example: | ||||
233 | /// | ||||
234 | /// template<> | ||||
235 | /// struct SequenceTraits<MyContainer> { | ||||
236 | /// static size_t size(IO &io, MyContainer &seq) { | ||||
237 | /// return seq.size(); | ||||
238 | /// } | ||||
239 | /// static MyType& element(IO &, MyContainer &seq, size_t index) { | ||||
240 | /// if ( index >= seq.size() ) | ||||
241 | /// seq.resize(index+1); | ||||
242 | /// return seq[index]; | ||||
243 | /// } | ||||
244 | /// }; | ||||
245 | template<typename T, typename EnableIf = void> | ||||
246 | struct SequenceTraits { | ||||
247 | // Must provide: | ||||
248 | // static size_t size(IO &io, T &seq); | ||||
249 | // static T::value_type& element(IO &io, T &seq, size_t index); | ||||
250 | // | ||||
251 | // The following is option and will cause generated YAML to use | ||||
252 | // a flow sequence (e.g. [a,b,c]). | ||||
253 | // static const bool flow = true; | ||||
254 | }; | ||||
255 | |||||
256 | /// This class should be specialized by any type for which vectors of that | ||||
257 | /// type need to be converted to/from a YAML sequence. | ||||
258 | template<typename T, typename EnableIf = void> | ||||
259 | struct SequenceElementTraits { | ||||
260 | // Must provide: | ||||
261 | // static const bool flow; | ||||
262 | }; | ||||
263 | |||||
264 | /// This class should be specialized by any type that needs to be converted | ||||
265 | /// to/from a list of YAML documents. | ||||
266 | template<typename T> | ||||
267 | struct DocumentListTraits { | ||||
268 | // Must provide: | ||||
269 | // static size_t size(IO &io, T &seq); | ||||
270 | // static T::value_type& element(IO &io, T &seq, size_t index); | ||||
271 | }; | ||||
272 | |||||
273 | /// This class should be specialized by any type that needs to be converted | ||||
274 | /// to/from a YAML mapping in the case where the names of the keys are not known | ||||
275 | /// in advance, e.g. a string map. | ||||
276 | template <typename T> | ||||
277 | struct CustomMappingTraits { | ||||
278 | // static void inputOne(IO &io, StringRef key, T &elem); | ||||
279 | // static void output(IO &io, T &elem); | ||||
280 | }; | ||||
281 | |||||
282 | /// This class should be specialized by any type that can be represented as | ||||
283 | /// a scalar, map, or sequence, decided dynamically. For example: | ||||
284 | /// | ||||
285 | /// typedef std::unique_ptr<MyBase> MyPoly; | ||||
286 | /// | ||||
287 | /// template<> | ||||
288 | /// struct PolymorphicTraits<MyPoly> { | ||||
289 | /// static NodeKind getKind(const MyPoly &poly) { | ||||
290 | /// return poly->getKind(); | ||||
291 | /// } | ||||
292 | /// static MyScalar& getAsScalar(MyPoly &poly) { | ||||
293 | /// if (!poly || !isa<MyScalar>(poly)) | ||||
294 | /// poly.reset(new MyScalar()); | ||||
295 | /// return *cast<MyScalar>(poly.get()); | ||||
296 | /// } | ||||
297 | /// // ... | ||||
298 | /// }; | ||||
299 | template <typename T> struct PolymorphicTraits { | ||||
300 | // Must provide: | ||||
301 | // static NodeKind getKind(const T &poly); | ||||
302 | // static scalar_type &getAsScalar(T &poly); | ||||
303 | // static map_type &getAsMap(T &poly); | ||||
304 | // static sequence_type &getAsSequence(T &poly); | ||||
305 | }; | ||||
306 | |||||
307 | // Only used for better diagnostics of missing traits | ||||
308 | template <typename T> | ||||
309 | struct MissingTrait; | ||||
310 | |||||
311 | // Test if ScalarEnumerationTraits<T> is defined on type T. | ||||
312 | template <class T> | ||||
313 | struct has_ScalarEnumerationTraits | ||||
314 | { | ||||
315 | using Signature_enumeration = void (*)(class IO&, T&); | ||||
316 | |||||
317 | template <typename U> | ||||
318 | static char test(SameType<Signature_enumeration, &U::enumeration>*); | ||||
319 | |||||
320 | template <typename U> | ||||
321 | static double test(...); | ||||
322 | |||||
323 | static bool const value = | ||||
324 | (sizeof(test<ScalarEnumerationTraits<T>>(nullptr)) == 1); | ||||
325 | }; | ||||
326 | |||||
327 | // Test if ScalarBitSetTraits<T> is defined on type T. | ||||
328 | template <class T> | ||||
329 | struct has_ScalarBitSetTraits | ||||
330 | { | ||||
331 | using Signature_bitset = void (*)(class IO&, T&); | ||||
332 | |||||
333 | template <typename U> | ||||
334 | static char test(SameType<Signature_bitset, &U::bitset>*); | ||||
335 | |||||
336 | template <typename U> | ||||
337 | static double test(...); | ||||
338 | |||||
339 | static bool const value = (sizeof(test<ScalarBitSetTraits<T>>(nullptr)) == 1); | ||||
340 | }; | ||||
341 | |||||
342 | // Test if ScalarTraits<T> is defined on type T. | ||||
343 | template <class T> | ||||
344 | struct has_ScalarTraits | ||||
345 | { | ||||
346 | using Signature_input = StringRef (*)(StringRef, void*, T&); | ||||
347 | using Signature_output = void (*)(const T&, void*, raw_ostream&); | ||||
348 | using Signature_mustQuote = QuotingType (*)(StringRef); | ||||
349 | |||||
350 | template <typename U> | ||||
351 | static char test(SameType<Signature_input, &U::input> *, | ||||
352 | SameType<Signature_output, &U::output> *, | ||||
353 | SameType<Signature_mustQuote, &U::mustQuote> *); | ||||
354 | |||||
355 | template <typename U> | ||||
356 | static double test(...); | ||||
357 | |||||
358 | static bool const value = | ||||
359 | (sizeof(test<ScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1); | ||||
360 | }; | ||||
361 | |||||
362 | // Test if BlockScalarTraits<T> is defined on type T. | ||||
363 | template <class T> | ||||
364 | struct has_BlockScalarTraits | ||||
365 | { | ||||
366 | using Signature_input = StringRef (*)(StringRef, void *, T &); | ||||
367 | using Signature_output = void (*)(const T &, void *, raw_ostream &); | ||||
368 | |||||
369 | template <typename U> | ||||
370 | static char test(SameType<Signature_input, &U::input> *, | ||||
371 | SameType<Signature_output, &U::output> *); | ||||
372 | |||||
373 | template <typename U> | ||||
374 | static double test(...); | ||||
375 | |||||
376 | static bool const value = | ||||
377 | (sizeof(test<BlockScalarTraits<T>>(nullptr, nullptr)) == 1); | ||||
378 | }; | ||||
379 | |||||
380 | // Test if TaggedScalarTraits<T> is defined on type T. | ||||
381 | template <class T> struct has_TaggedScalarTraits { | ||||
382 | using Signature_input = StringRef (*)(StringRef, StringRef, void *, T &); | ||||
383 | using Signature_output = void (*)(const T &, void *, raw_ostream &, | ||||
384 | raw_ostream &); | ||||
385 | using Signature_mustQuote = QuotingType (*)(const T &, StringRef); | ||||
386 | |||||
387 | template <typename U> | ||||
388 | static char test(SameType<Signature_input, &U::input> *, | ||||
389 | SameType<Signature_output, &U::output> *, | ||||
390 | SameType<Signature_mustQuote, &U::mustQuote> *); | ||||
391 | |||||
392 | template <typename U> static double test(...); | ||||
393 | |||||
394 | static bool const value = | ||||
395 | (sizeof(test<TaggedScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1); | ||||
396 | }; | ||||
397 | |||||
398 | // Test if MappingContextTraits<T> is defined on type T. | ||||
399 | template <class T, class Context> struct has_MappingTraits { | ||||
400 | using Signature_mapping = void (*)(class IO &, T &, Context &); | ||||
401 | |||||
402 | template <typename U> | ||||
403 | static char test(SameType<Signature_mapping, &U::mapping>*); | ||||
404 | |||||
405 | template <typename U> | ||||
406 | static double test(...); | ||||
407 | |||||
408 | static bool const value = | ||||
409 | (sizeof(test<MappingContextTraits<T, Context>>(nullptr)) == 1); | ||||
410 | }; | ||||
411 | |||||
412 | // Test if MappingTraits<T> is defined on type T. | ||||
413 | template <class T> struct has_MappingTraits<T, EmptyContext> { | ||||
414 | using Signature_mapping = void (*)(class IO &, T &); | ||||
415 | |||||
416 | template <typename U> | ||||
417 | static char test(SameType<Signature_mapping, &U::mapping> *); | ||||
418 | |||||
419 | template <typename U> static double test(...); | ||||
420 | |||||
421 | static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1); | ||||
422 | }; | ||||
423 | |||||
424 | // Test if MappingContextTraits<T>::validate() is defined on type T. | ||||
425 | template <class T, class Context> struct has_MappingValidateTraits { | ||||
426 | using Signature_validate = std::string (*)(class IO &, T &, Context &); | ||||
427 | |||||
428 | template <typename U> | ||||
429 | static char test(SameType<Signature_validate, &U::validate>*); | ||||
430 | |||||
431 | template <typename U> | ||||
432 | static double test(...); | ||||
433 | |||||
434 | static bool const value = | ||||
435 | (sizeof(test<MappingContextTraits<T, Context>>(nullptr)) == 1); | ||||
436 | }; | ||||
437 | |||||
438 | // Test if MappingTraits<T>::validate() is defined on type T. | ||||
439 | template <class T> struct has_MappingValidateTraits<T, EmptyContext> { | ||||
440 | using Signature_validate = std::string (*)(class IO &, T &); | ||||
441 | |||||
442 | template <typename U> | ||||
443 | static char test(SameType<Signature_validate, &U::validate> *); | ||||
444 | |||||
445 | template <typename U> static double test(...); | ||||
446 | |||||
447 | static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1); | ||||
448 | }; | ||||
449 | |||||
450 | // Test if SequenceTraits<T> is defined on type T. | ||||
451 | template <class T> | ||||
452 | struct has_SequenceMethodTraits | ||||
453 | { | ||||
454 | using Signature_size = size_t (*)(class IO&, T&); | ||||
455 | |||||
456 | template <typename U> | ||||
457 | static char test(SameType<Signature_size, &U::size>*); | ||||
458 | |||||
459 | template <typename U> | ||||
460 | static double test(...); | ||||
461 | |||||
462 | static bool const value = (sizeof(test<SequenceTraits<T>>(nullptr)) == 1); | ||||
463 | }; | ||||
464 | |||||
465 | // Test if CustomMappingTraits<T> is defined on type T. | ||||
466 | template <class T> | ||||
467 | struct has_CustomMappingTraits | ||||
468 | { | ||||
469 | using Signature_input = void (*)(IO &io, StringRef key, T &v); | ||||
470 | |||||
471 | template <typename U> | ||||
472 | static char test(SameType<Signature_input, &U::inputOne>*); | ||||
473 | |||||
474 | template <typename U> | ||||
475 | static double test(...); | ||||
476 | |||||
477 | static bool const value = | ||||
478 | (sizeof(test<CustomMappingTraits<T>>(nullptr)) == 1); | ||||
479 | }; | ||||
480 | |||||
481 | // has_FlowTraits<int> will cause an error with some compilers because | ||||
482 | // it subclasses int. Using this wrapper only instantiates the | ||||
483 | // real has_FlowTraits only if the template type is a class. | ||||
484 | template <typename T, bool Enabled = std::is_class<T>::value> | ||||
485 | class has_FlowTraits | ||||
486 | { | ||||
487 | public: | ||||
488 | static const bool value = false; | ||||
489 | }; | ||||
490 | |||||
491 | // Some older gcc compilers don't support straight forward tests | ||||
492 | // for members, so test for ambiguity cause by the base and derived | ||||
493 | // classes both defining the member. | ||||
494 | template <class T> | ||||
495 | struct has_FlowTraits<T, true> | ||||
496 | { | ||||
497 | struct Fallback { bool flow; }; | ||||
498 | struct Derived : T, Fallback { }; | ||||
499 | |||||
500 | template<typename C> | ||||
501 | static char (&f(SameType<bool Fallback::*, &C::flow>*))[1]; | ||||
502 | |||||
503 | template<typename C> | ||||
504 | static char (&f(...))[2]; | ||||
505 | |||||
506 | static bool const value = sizeof(f<Derived>(nullptr)) == 2; | ||||
507 | }; | ||||
508 | |||||
509 | // Test if SequenceTraits<T> is defined on type T | ||||
510 | template<typename T> | ||||
511 | struct has_SequenceTraits : public std::integral_constant<bool, | ||||
512 | has_SequenceMethodTraits<T>::value > { }; | ||||
513 | |||||
514 | // Test if DocumentListTraits<T> is defined on type T | ||||
515 | template <class T> | ||||
516 | struct has_DocumentListTraits | ||||
517 | { | ||||
518 | using Signature_size = size_t (*)(class IO &, T &); | ||||
519 | |||||
520 | template <typename U> | ||||
521 | static char test(SameType<Signature_size, &U::size>*); | ||||
522 | |||||
523 | template <typename U> | ||||
524 | static double test(...); | ||||
525 | |||||
526 | static bool const value = (sizeof(test<DocumentListTraits<T>>(nullptr))==1); | ||||
527 | }; | ||||
528 | |||||
529 | template <class T> struct has_PolymorphicTraits { | ||||
530 | using Signature_getKind = NodeKind (*)(const T &); | ||||
531 | |||||
532 | template <typename U> | ||||
533 | static char test(SameType<Signature_getKind, &U::getKind> *); | ||||
534 | |||||
535 | template <typename U> static double test(...); | ||||
536 | |||||
537 | static bool const value = (sizeof(test<PolymorphicTraits<T>>(nullptr)) == 1); | ||||
538 | }; | ||||
539 | |||||
540 | inline bool isNumeric(StringRef S) { | ||||
541 | const static auto skipDigits = [](StringRef Input) { | ||||
542 | return Input.drop_front( | ||||
543 | std::min(Input.find_first_not_of("0123456789"), Input.size())); | ||||
544 | }; | ||||
545 | |||||
546 | // Make S.front() and S.drop_front().front() (if S.front() is [+-]) calls | ||||
547 | // safe. | ||||
548 | if (S.empty() || S.equals("+") || S.equals("-")) | ||||
549 | return false; | ||||
550 | |||||
551 | if (S.equals(".nan") || S.equals(".NaN") || S.equals(".NAN")) | ||||
552 | return true; | ||||
553 | |||||
554 | // Infinity and decimal numbers can be prefixed with sign. | ||||
555 | StringRef Tail = (S.front() == '-' || S.front() == '+') ? S.drop_front() : S; | ||||
556 | |||||
557 | // Check for infinity first, because checking for hex and oct numbers is more | ||||
558 | // expensive. | ||||
559 | if (Tail.equals(".inf") || Tail.equals(".Inf") || Tail.equals(".INF")) | ||||
560 | return true; | ||||
561 | |||||
562 | // Section 10.3.2 Tag Resolution | ||||
563 | // YAML 1.2 Specification prohibits Base 8 and Base 16 numbers prefixed with | ||||
564 | // [-+], so S should be used instead of Tail. | ||||
565 | if (S.startswith("0o")) | ||||
566 | return S.size() > 2 && | ||||
567 | S.drop_front(2).find_first_not_of("01234567") == StringRef::npos; | ||||
568 | |||||
569 | if (S.startswith("0x")) | ||||
570 | return S.size() > 2 && S.drop_front(2).find_first_not_of( | ||||
571 | "0123456789abcdefABCDEF") == StringRef::npos; | ||||
572 | |||||
573 | // Parse float: [-+]? (\. [0-9]+ | [0-9]+ (\. [0-9]* )?) ([eE] [-+]? [0-9]+)? | ||||
574 | S = Tail; | ||||
575 | |||||
576 | // Handle cases when the number starts with '.' and hence needs at least one | ||||
577 | // digit after dot (as opposed by number which has digits before the dot), but | ||||
578 | // doesn't have one. | ||||
579 | if (S.startswith(".") && | ||||
580 | (S.equals(".") || | ||||
581 | (S.size() > 1 && std::strchr("0123456789", S[1]) == nullptr))) | ||||
582 | return false; | ||||
583 | |||||
584 | if (S.startswith("E") || S.startswith("e")) | ||||
585 | return false; | ||||
586 | |||||
587 | enum ParseState { | ||||
588 | Default, | ||||
589 | FoundDot, | ||||
590 | FoundExponent, | ||||
591 | }; | ||||
592 | ParseState State = Default; | ||||
593 | |||||
594 | S = skipDigits(S); | ||||
595 | |||||
596 | // Accept decimal integer. | ||||
597 | if (S.empty()) | ||||
598 | return true; | ||||
599 | |||||
600 | if (S.front() == '.') { | ||||
601 | State = FoundDot; | ||||
602 | S = S.drop_front(); | ||||
603 | } else if (S.front() == 'e' || S.front() == 'E') { | ||||
604 | State = FoundExponent; | ||||
605 | S = S.drop_front(); | ||||
606 | } else { | ||||
607 | return false; | ||||
608 | } | ||||
609 | |||||
610 | if (State == FoundDot) { | ||||
611 | S = skipDigits(S); | ||||
612 | if (S.empty()) | ||||
613 | return true; | ||||
614 | |||||
615 | if (S.front() == 'e' || S.front() == 'E') { | ||||
616 | State = FoundExponent; | ||||
617 | S = S.drop_front(); | ||||
618 | } else { | ||||
619 | return false; | ||||
620 | } | ||||
621 | } | ||||
622 | |||||
623 | assert(State == FoundExponent && "Should have found exponent at this point.")(static_cast <bool> (State == FoundExponent && "Should have found exponent at this point." ) ? void (0) : __assert_fail ("State == FoundExponent && \"Should have found exponent at this point.\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/YAMLTraits.h" , 623, __extension__ __PRETTY_FUNCTION__)); | ||||
624 | if (S.empty()) | ||||
625 | return false; | ||||
626 | |||||
627 | if (S.front() == '+' || S.front() == '-') { | ||||
628 | S = S.drop_front(); | ||||
629 | if (S.empty()) | ||||
630 | return false; | ||||
631 | } | ||||
632 | |||||
633 | return skipDigits(S).empty(); | ||||
634 | } | ||||
635 | |||||
636 | inline bool isNull(StringRef S) { | ||||
637 | return S.equals("null") || S.equals("Null") || S.equals("NULL") || | ||||
638 | S.equals("~"); | ||||
639 | } | ||||
640 | |||||
641 | inline bool isBool(StringRef S) { | ||||
642 | // FIXME: using parseBool is causing multiple tests to fail. | ||||
643 | return S.equals("true") || S.equals("True") || S.equals("TRUE") || | ||||
644 | S.equals("false") || S.equals("False") || S.equals("FALSE"); | ||||
645 | } | ||||
646 | |||||
647 | // 5.1. Character Set | ||||
648 | // The allowed character range explicitly excludes the C0 control block #x0-#x1F | ||||
649 | // (except for TAB #x9, LF #xA, and CR #xD which are allowed), DEL #x7F, the C1 | ||||
650 | // control block #x80-#x9F (except for NEL #x85 which is allowed), the surrogate | ||||
651 | // block #xD800-#xDFFF, #xFFFE, and #xFFFF. | ||||
652 | inline QuotingType needsQuotes(StringRef S) { | ||||
653 | if (S.empty()) | ||||
654 | return QuotingType::Single; | ||||
655 | |||||
656 | QuotingType MaxQuotingNeeded = QuotingType::None; | ||||
657 | if (isSpace(static_cast<unsigned char>(S.front())) || | ||||
658 | isSpace(static_cast<unsigned char>(S.back()))) | ||||
659 | MaxQuotingNeeded = QuotingType::Single; | ||||
660 | if (isNull(S)) | ||||
661 | MaxQuotingNeeded = QuotingType::Single; | ||||
662 | if (isBool(S)) | ||||
663 | MaxQuotingNeeded = QuotingType::Single; | ||||
664 | if (isNumeric(S)) | ||||
665 | MaxQuotingNeeded = QuotingType::Single; | ||||
666 | |||||
667 | // 7.3.3 Plain Style | ||||
668 | // Plain scalars must not begin with most indicators, as this would cause | ||||
669 | // ambiguity with other YAML constructs. | ||||
670 | static constexpr char Indicators[] = R"(-?:\,[]{}#&*!|>'"%@`)"; | ||||
671 | if (S.find_first_of(Indicators) == 0) | ||||
672 | MaxQuotingNeeded = QuotingType::Single; | ||||
673 | |||||
674 | for (unsigned char C : S) { | ||||
675 | // Alphanum is safe. | ||||
676 | if (isAlnum(C)) | ||||
677 | continue; | ||||
678 | |||||
679 | switch (C) { | ||||
680 | // Safe scalar characters. | ||||
681 | case '_': | ||||
682 | case '-': | ||||
683 | case '^': | ||||
684 | case '.': | ||||
685 | case ',': | ||||
686 | case ' ': | ||||
687 | // TAB (0x9) is allowed in unquoted strings. | ||||
688 | case 0x9: | ||||
689 | continue; | ||||
690 | // LF(0xA) and CR(0xD) may delimit values and so require at least single | ||||
691 | // quotes. LLVM YAML parser cannot handle single quoted multiline so use | ||||
692 | // double quoting to produce valid YAML. | ||||
693 | case 0xA: | ||||
694 | case 0xD: | ||||
695 | return QuotingType::Double; | ||||
696 | // DEL (0x7F) are excluded from the allowed character range. | ||||
697 | case 0x7F: | ||||
698 | return QuotingType::Double; | ||||
699 | // Forward slash is allowed to be unquoted, but we quote it anyway. We have | ||||
700 | // many tests that use FileCheck against YAML output, and this output often | ||||
701 | // contains paths. If we quote backslashes but not forward slashes then | ||||
702 | // paths will come out either quoted or unquoted depending on which platform | ||||
703 | // the test is run on, making FileCheck comparisons difficult. | ||||
704 | case '/': | ||||
705 | default: { | ||||
706 | // C0 control block (0x0 - 0x1F) is excluded from the allowed character | ||||
707 | // range. | ||||
708 | if (C <= 0x1F) | ||||
709 | return QuotingType::Double; | ||||
710 | |||||
711 | // Always double quote UTF-8. | ||||
712 | if ((C & 0x80) != 0) | ||||
713 | return QuotingType::Double; | ||||
714 | |||||
715 | // The character is not safe, at least simple quoting needed. | ||||
716 | MaxQuotingNeeded = QuotingType::Single; | ||||
717 | } | ||||
718 | } | ||||
719 | } | ||||
720 | |||||
721 | return MaxQuotingNeeded; | ||||
722 | } | ||||
723 | |||||
724 | template <typename T, typename Context> | ||||
725 | struct missingTraits | ||||
726 | : public std::integral_constant<bool, | ||||
727 | !has_ScalarEnumerationTraits<T>::value && | ||||
728 | !has_ScalarBitSetTraits<T>::value && | ||||
729 | !has_ScalarTraits<T>::value && | ||||
730 | !has_BlockScalarTraits<T>::value && | ||||
731 | !has_TaggedScalarTraits<T>::value && | ||||
732 | !has_MappingTraits<T, Context>::value && | ||||
733 | !has_SequenceTraits<T>::value && | ||||
734 | !has_CustomMappingTraits<T>::value && | ||||
735 | !has_DocumentListTraits<T>::value && | ||||
736 | !has_PolymorphicTraits<T>::value> {}; | ||||
737 | |||||
738 | template <typename T, typename Context> | ||||
739 | struct validatedMappingTraits | ||||
740 | : public std::integral_constant< | ||||
741 | bool, has_MappingTraits<T, Context>::value && | ||||
742 | has_MappingValidateTraits<T, Context>::value> {}; | ||||
743 | |||||
744 | template <typename T, typename Context> | ||||
745 | struct unvalidatedMappingTraits | ||||
746 | : public std::integral_constant< | ||||
747 | bool, has_MappingTraits<T, Context>::value && | ||||
748 | !has_MappingValidateTraits<T, Context>::value> {}; | ||||
749 | |||||
750 | // Base class for Input and Output. | ||||
751 | class IO { | ||||
752 | public: | ||||
753 | IO(void *Ctxt = nullptr); | ||||
754 | virtual ~IO(); | ||||
755 | |||||
756 | virtual bool outputting() const = 0; | ||||
757 | |||||
758 | virtual unsigned beginSequence() = 0; | ||||
759 | virtual bool preflightElement(unsigned, void *&) = 0; | ||||
760 | virtual void postflightElement(void*) = 0; | ||||
761 | virtual void endSequence() = 0; | ||||
762 | virtual bool canElideEmptySequence() = 0; | ||||
763 | |||||
764 | virtual unsigned beginFlowSequence() = 0; | ||||
765 | virtual bool preflightFlowElement(unsigned, void *&) = 0; | ||||
766 | virtual void postflightFlowElement(void*) = 0; | ||||
767 | virtual void endFlowSequence() = 0; | ||||
768 | |||||
769 | virtual bool mapTag(StringRef Tag, bool Default=false) = 0; | ||||
770 | virtual void beginMapping() = 0; | ||||
771 | virtual void endMapping() = 0; | ||||
772 | virtual bool preflightKey(const char*, bool, bool, bool &, void *&) = 0; | ||||
773 | virtual void postflightKey(void*) = 0; | ||||
774 | virtual std::vector<StringRef> keys() = 0; | ||||
775 | |||||
776 | virtual void beginFlowMapping() = 0; | ||||
777 | virtual void endFlowMapping() = 0; | ||||
778 | |||||
779 | virtual void beginEnumScalar() = 0; | ||||
780 | virtual bool matchEnumScalar(const char*, bool) = 0; | ||||
781 | virtual bool matchEnumFallback() = 0; | ||||
782 | virtual void endEnumScalar() = 0; | ||||
783 | |||||
784 | virtual bool beginBitSetScalar(bool &) = 0; | ||||
785 | virtual bool bitSetMatch(const char*, bool) = 0; | ||||
786 | virtual void endBitSetScalar() = 0; | ||||
787 | |||||
788 | virtual void scalarString(StringRef &, QuotingType) = 0; | ||||
789 | virtual void blockScalarString(StringRef &) = 0; | ||||
790 | virtual void scalarTag(std::string &) = 0; | ||||
791 | |||||
792 | virtual NodeKind getNodeKind() = 0; | ||||
793 | |||||
794 | virtual void setError(const Twine &) = 0; | ||||
795 | virtual void setAllowUnknownKeys(bool Allow); | ||||
796 | |||||
797 | template <typename T> | ||||
798 | void enumCase(T &Val, const char* Str, const T ConstVal) { | ||||
799 | if ( matchEnumScalar(Str, outputting() && Val == ConstVal) ) { | ||||
800 | Val = ConstVal; | ||||
801 | } | ||||
802 | } | ||||
803 | |||||
804 | // allow anonymous enum values to be used with LLVM_YAML_STRONG_TYPEDEF | ||||
805 | template <typename T> | ||||
806 | void enumCase(T &Val, const char* Str, const uint32_t ConstVal) { | ||||
807 | if ( matchEnumScalar(Str, outputting() && Val == static_cast<T>(ConstVal)) ) { | ||||
808 | Val = ConstVal; | ||||
809 | } | ||||
810 | } | ||||
811 | |||||
812 | template <typename FBT, typename T> | ||||
813 | void enumFallback(T &Val) { | ||||
814 | if (matchEnumFallback()) { | ||||
815 | EmptyContext Context; | ||||
816 | // FIXME: Force integral conversion to allow strong typedefs to convert. | ||||
817 | FBT Res = static_cast<typename FBT::BaseType>(Val); | ||||
818 | yamlize(*this, Res, true, Context); | ||||
819 | Val = static_cast<T>(static_cast<typename FBT::BaseType>(Res)); | ||||
820 | } | ||||
821 | } | ||||
822 | |||||
823 | template <typename T> | ||||
824 | void bitSetCase(T &Val, const char* Str, const T ConstVal) { | ||||
825 | if ( bitSetMatch(Str, outputting() && (Val & ConstVal) == ConstVal) ) { | ||||
826 | Val = static_cast<T>(Val | ConstVal); | ||||
827 | } | ||||
828 | } | ||||
829 | |||||
830 | // allow anonymous enum values to be used with LLVM_YAML_STRONG_TYPEDEF | ||||
831 | template <typename T> | ||||
832 | void bitSetCase(T &Val, const char* Str, const uint32_t ConstVal) { | ||||
833 | if ( bitSetMatch(Str, outputting() && (Val & ConstVal) == ConstVal) ) { | ||||
834 | Val = static_cast<T>(Val | ConstVal); | ||||
835 | } | ||||
836 | } | ||||
837 | |||||
838 | template <typename T> | ||||
839 | void maskedBitSetCase(T &Val, const char *Str, T ConstVal, T Mask) { | ||||
840 | if (bitSetMatch(Str, outputting() && (Val & Mask) == ConstVal)) | ||||
841 | Val = Val | ConstVal; | ||||
842 | } | ||||
843 | |||||
844 | template <typename T> | ||||
845 | void maskedBitSetCase(T &Val, const char *Str, uint32_t ConstVal, | ||||
846 | uint32_t Mask) { | ||||
847 | if (bitSetMatch(Str, outputting() && (Val & Mask) == ConstVal)) | ||||
848 | Val = Val | ConstVal; | ||||
849 | } | ||||
850 | |||||
851 | void *getContext() const; | ||||
852 | void setContext(void *); | ||||
853 | |||||
854 | template <typename T> void mapRequired(const char *Key, T &Val) { | ||||
855 | EmptyContext Ctx; | ||||
856 | this->processKey(Key, Val, true, Ctx); | ||||
857 | } | ||||
858 | |||||
859 | template <typename T, typename Context> | ||||
860 | void mapRequired(const char *Key, T &Val, Context &Ctx) { | ||||
861 | this->processKey(Key, Val, true, Ctx); | ||||
862 | } | ||||
863 | |||||
864 | template <typename T> void mapOptional(const char *Key, T &Val) { | ||||
865 | EmptyContext Ctx; | ||||
866 | mapOptionalWithContext(Key, Val, Ctx); | ||||
867 | } | ||||
868 | |||||
869 | template <typename T, typename DefaultT> | ||||
870 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | ||||
871 | EmptyContext Ctx; | ||||
872 | mapOptionalWithContext(Key, Val, Default, Ctx); | ||||
873 | } | ||||
874 | |||||
875 | template <typename T, typename Context> | ||||
876 | std::enable_if_t<has_SequenceTraits<T>::value, void> | ||||
877 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | ||||
878 | // omit key/value instead of outputting empty sequence | ||||
879 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())) | ||||
880 | return; | ||||
881 | this->processKey(Key, Val, false, Ctx); | ||||
882 | } | ||||
883 | |||||
884 | template <typename T, typename Context> | ||||
885 | void mapOptionalWithContext(const char *Key, Optional<T> &Val, Context &Ctx) { | ||||
886 | this->processKeyWithDefault(Key, Val, Optional<T>(), /*Required=*/false, | ||||
887 | Ctx); | ||||
888 | } | ||||
889 | |||||
890 | template <typename T, typename Context> | ||||
891 | std::enable_if_t<!has_SequenceTraits<T>::value, void> | ||||
892 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | ||||
893 | this->processKey(Key, Val, false, Ctx); | ||||
894 | } | ||||
895 | |||||
896 | template <typename T, typename Context, typename DefaultT> | ||||
897 | void mapOptionalWithContext(const char *Key, T &Val, const DefaultT &Default, | ||||
898 | Context &Ctx) { | ||||
899 | static_assert(std::is_convertible<DefaultT, T>::value, | ||||
900 | "Default type must be implicitly convertible to value type!"); | ||||
901 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | ||||
902 | false, Ctx); | ||||
903 | } | ||||
904 | |||||
905 | private: | ||||
906 | template <typename T, typename Context> | ||||
907 | void processKeyWithDefault(const char *Key, Optional<T> &Val, | ||||
908 | const Optional<T> &DefaultValue, bool Required, | ||||
909 | Context &Ctx); | ||||
910 | |||||
911 | template <typename T, typename Context> | ||||
912 | void processKeyWithDefault(const char *Key, T &Val, const T &DefaultValue, | ||||
913 | bool Required, Context &Ctx) { | ||||
914 | void *SaveInfo; | ||||
915 | bool UseDefault; | ||||
916 | const bool sameAsDefault = outputting() && Val == DefaultValue; | ||||
917 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | ||||
918 | SaveInfo) ) { | ||||
919 | yamlize(*this, Val, Required, Ctx); | ||||
920 | this->postflightKey(SaveInfo); | ||||
921 | } | ||||
922 | else { | ||||
923 | if ( UseDefault ) | ||||
924 | Val = DefaultValue; | ||||
925 | } | ||||
926 | } | ||||
927 | |||||
928 | template <typename T, typename Context> | ||||
929 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | ||||
930 | void *SaveInfo; | ||||
931 | bool UseDefault; | ||||
932 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | ||||
933 | yamlize(*this, Val, Required, Ctx); | ||||
934 | this->postflightKey(SaveInfo); | ||||
935 | } | ||||
936 | } | ||||
937 | |||||
938 | private: | ||||
939 | void *Ctxt; | ||||
940 | }; | ||||
941 | |||||
942 | namespace detail { | ||||
943 | |||||
944 | template <typename T, typename Context> | ||||
945 | void doMapping(IO &io, T &Val, Context &Ctx) { | ||||
946 | MappingContextTraits<T, Context>::mapping(io, Val, Ctx); | ||||
947 | } | ||||
948 | |||||
949 | template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) { | ||||
950 | MappingTraits<T>::mapping(io, Val); | ||||
951 | } | ||||
952 | |||||
953 | } // end namespace detail | ||||
954 | |||||
955 | template <typename T> | ||||
956 | std::enable_if_t<has_ScalarEnumerationTraits<T>::value, void> | ||||
957 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | ||||
958 | io.beginEnumScalar(); | ||||
959 | ScalarEnumerationTraits<T>::enumeration(io, Val); | ||||
960 | io.endEnumScalar(); | ||||
961 | } | ||||
962 | |||||
963 | template <typename T> | ||||
964 | std::enable_if_t<has_ScalarBitSetTraits<T>::value, void> | ||||
965 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | ||||
966 | bool DoClear; | ||||
967 | if ( io.beginBitSetScalar(DoClear) ) { | ||||
968 | if ( DoClear ) | ||||
969 | Val = T(); | ||||
970 | ScalarBitSetTraits<T>::bitset(io, Val); | ||||
971 | io.endBitSetScalar(); | ||||
972 | } | ||||
973 | } | ||||
974 | |||||
975 | template <typename T> | ||||
976 | std::enable_if_t<has_ScalarTraits<T>::value, void> yamlize(IO &io, T &Val, bool, | ||||
977 | EmptyContext &Ctx) { | ||||
978 | if ( io.outputting() ) { | ||||
979 | std::string Storage; | ||||
980 | raw_string_ostream Buffer(Storage); | ||||
981 | ScalarTraits<T>::output(Val, io.getContext(), Buffer); | ||||
982 | StringRef Str = Buffer.str(); | ||||
983 | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | ||||
984 | } | ||||
985 | else { | ||||
986 | StringRef Str; | ||||
987 | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | ||||
988 | StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val); | ||||
989 | if ( !Result.empty() ) { | ||||
990 | io.setError(Twine(Result)); | ||||
991 | } | ||||
992 | } | ||||
993 | } | ||||
994 | |||||
995 | template <typename T> | ||||
996 | std::enable_if_t<has_BlockScalarTraits<T>::value, void> | ||||
997 | yamlize(IO &YamlIO, T &Val, bool, EmptyContext &Ctx) { | ||||
998 | if (YamlIO.outputting()) { | ||||
999 | std::string Storage; | ||||
1000 | raw_string_ostream Buffer(Storage); | ||||
1001 | BlockScalarTraits<T>::output(Val, YamlIO.getContext(), Buffer); | ||||
1002 | StringRef Str = Buffer.str(); | ||||
1003 | YamlIO.blockScalarString(Str); | ||||
1004 | } else { | ||||
1005 | StringRef Str; | ||||
1006 | YamlIO.blockScalarString(Str); | ||||
1007 | StringRef Result = | ||||
1008 | BlockScalarTraits<T>::input(Str, YamlIO.getContext(), Val); | ||||
1009 | if (!Result.empty()) | ||||
1010 | YamlIO.setError(Twine(Result)); | ||||
1011 | } | ||||
1012 | } | ||||
1013 | |||||
1014 | template <typename T> | ||||
1015 | std::enable_if_t<has_TaggedScalarTraits<T>::value, void> | ||||
1016 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | ||||
1017 | if (io.outputting()) { | ||||
1018 | std::string ScalarStorage, TagStorage; | ||||
1019 | raw_string_ostream ScalarBuffer(ScalarStorage), TagBuffer(TagStorage); | ||||
1020 | TaggedScalarTraits<T>::output(Val, io.getContext(), ScalarBuffer, | ||||
1021 | TagBuffer); | ||||
1022 | io.scalarTag(TagBuffer.str()); | ||||
1023 | StringRef ScalarStr = ScalarBuffer.str(); | ||||
1024 | io.scalarString(ScalarStr, | ||||
1025 | TaggedScalarTraits<T>::mustQuote(Val, ScalarStr)); | ||||
1026 | } else { | ||||
1027 | std::string Tag; | ||||
1028 | io.scalarTag(Tag); | ||||
1029 | StringRef Str; | ||||
1030 | io.scalarString(Str, QuotingType::None); | ||||
1031 | StringRef Result = | ||||
1032 | TaggedScalarTraits<T>::input(Str, Tag, io.getContext(), Val); | ||||
1033 | if (!Result.empty()) { | ||||
1034 | io.setError(Twine(Result)); | ||||
1035 | } | ||||
1036 | } | ||||
1037 | } | ||||
1038 | |||||
1039 | template <typename T, typename Context> | ||||
1040 | std::enable_if_t<validatedMappingTraits<T, Context>::value, void> | ||||
1041 | yamlize(IO &io, T &Val, bool, Context &Ctx) { | ||||
1042 | if (has_FlowTraits<MappingTraits<T>>::value
| ||||
1043 | io.beginFlowMapping(); | ||||
1044 | else | ||||
1045 | io.beginMapping(); | ||||
1046 | if (io.outputting()) { | ||||
1047 | std::string Err = MappingTraits<T>::validate(io, Val); | ||||
1048 | if (!Err.empty()) { | ||||
1049 | errs() << Err << "\n"; | ||||
1050 | assert(Err.empty() && "invalid struct trying to be written as yaml")(static_cast <bool> (Err.empty() && "invalid struct trying to be written as yaml" ) ? void (0) : __assert_fail ("Err.empty() && \"invalid struct trying to be written as yaml\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/YAMLTraits.h" , 1050, __extension__ __PRETTY_FUNCTION__)); | ||||
1051 | } | ||||
1052 | } | ||||
1053 | detail::doMapping(io, Val, Ctx); | ||||
1054 | if (!io.outputting()) { | ||||
1055 | std::string Err = MappingTraits<T>::validate(io, Val); | ||||
1056 | if (!Err.empty()) | ||||
1057 | io.setError(Err); | ||||
1058 | } | ||||
1059 | if (has_FlowTraits<MappingTraits<T>>::value) | ||||
1060 | io.endFlowMapping(); | ||||
1061 | else | ||||
1062 | io.endMapping(); | ||||
1063 | } | ||||
1064 | |||||
1065 | template <typename T, typename Context> | ||||
1066 | std::enable_if_t<unvalidatedMappingTraits<T, Context>::value, void> | ||||
1067 | yamlize(IO &io, T &Val, bool, Context &Ctx) { | ||||
1068 | if (has_FlowTraits<MappingTraits<T>>::value) { | ||||
1069 | io.beginFlowMapping(); | ||||
1070 | detail::doMapping(io, Val, Ctx); | ||||
1071 | io.endFlowMapping(); | ||||
1072 | } else { | ||||
1073 | io.beginMapping(); | ||||
1074 | detail::doMapping(io, Val, Ctx); | ||||
1075 | io.endMapping(); | ||||
1076 | } | ||||
1077 | } | ||||
1078 | |||||
1079 | template <typename T> | ||||
1080 | std::enable_if_t<has_CustomMappingTraits<T>::value, void> | ||||
1081 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | ||||
1082 | if ( io.outputting() ) { | ||||
1083 | io.beginMapping(); | ||||
1084 | CustomMappingTraits<T>::output(io, Val); | ||||
1085 | io.endMapping(); | ||||
1086 | } else { | ||||
1087 | io.beginMapping(); | ||||
1088 | for (StringRef key : io.keys()) | ||||
1089 | CustomMappingTraits<T>::inputOne(io, key, Val); | ||||
1090 | io.endMapping(); | ||||
1091 | } | ||||
1092 | } | ||||
1093 | |||||
1094 | template <typename T> | ||||
1095 | std::enable_if_t<has_PolymorphicTraits<T>::value, void> | ||||
1096 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | ||||
1097 | switch (io.outputting() ? PolymorphicTraits<T>::getKind(Val) | ||||
1098 | : io.getNodeKind()) { | ||||
1099 | case NodeKind::Scalar: | ||||
1100 | return yamlize(io, PolymorphicTraits<T>::getAsScalar(Val), true, Ctx); | ||||
1101 | case NodeKind::Map: | ||||
1102 | return yamlize(io, PolymorphicTraits<T>::getAsMap(Val), true, Ctx); | ||||
1103 | case NodeKind::Sequence: | ||||
1104 | return yamlize(io, PolymorphicTraits<T>::getAsSequence(Val), true, Ctx); | ||||
1105 | } | ||||
1106 | } | ||||
1107 | |||||
1108 | template <typename T> | ||||
1109 | std::enable_if_t<missingTraits<T, EmptyContext>::value, void> | ||||
1110 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | ||||
1111 | char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)]; | ||||
1112 | } | ||||
1113 | |||||
1114 | template <typename T, typename Context> | ||||
1115 | std::enable_if_t<has_SequenceTraits<T>::value, void> | ||||
1116 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | ||||
1117 | if ( has_FlowTraits< SequenceTraits<T>>::value
| ||||
1118 | unsigned incnt = io.beginFlowSequence(); | ||||
1119 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt; | ||||
1120 | for(unsigned i=0; i < count; ++i) { | ||||
1121 | void *SaveInfo; | ||||
1122 | if ( io.preflightFlowElement(i, SaveInfo) ) { | ||||
1123 | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | ||||
1124 | io.postflightFlowElement(SaveInfo); | ||||
1125 | } | ||||
1126 | } | ||||
1127 | io.endFlowSequence(); | ||||
1128 | } | ||||
1129 | else { | ||||
1130 | unsigned incnt = io.beginSequence(); | ||||
1131 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt; | ||||
1132 | for(unsigned i=0; i < count; ++i) { | ||||
1133 | void *SaveInfo; | ||||
1134 | if ( io.preflightElement(i, SaveInfo) ) { | ||||
1135 | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | ||||
1136 | io.postflightElement(SaveInfo); | ||||
1137 | } | ||||
1138 | } | ||||
1139 | io.endSequence(); | ||||
1140 | } | ||||
1141 | } | ||||
1142 | |||||
1143 | template<> | ||||
1144 | struct ScalarTraits<bool> { | ||||
1145 | static void output(const bool &, void* , raw_ostream &); | ||||
1146 | static StringRef input(StringRef, void *, bool &); | ||||
1147 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1148 | }; | ||||
1149 | |||||
1150 | template<> | ||||
1151 | struct ScalarTraits<StringRef> { | ||||
1152 | static void output(const StringRef &, void *, raw_ostream &); | ||||
1153 | static StringRef input(StringRef, void *, StringRef &); | ||||
1154 | static QuotingType mustQuote(StringRef S) { return needsQuotes(S); } | ||||
1155 | }; | ||||
1156 | |||||
1157 | template<> | ||||
1158 | struct ScalarTraits<std::string> { | ||||
1159 | static void output(const std::string &, void *, raw_ostream &); | ||||
1160 | static StringRef input(StringRef, void *, std::string &); | ||||
1161 | static QuotingType mustQuote(StringRef S) { return needsQuotes(S); } | ||||
1162 | }; | ||||
1163 | |||||
1164 | template<> | ||||
1165 | struct ScalarTraits<uint8_t> { | ||||
1166 | static void output(const uint8_t &, void *, raw_ostream &); | ||||
1167 | static StringRef input(StringRef, void *, uint8_t &); | ||||
1168 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1169 | }; | ||||
1170 | |||||
1171 | template<> | ||||
1172 | struct ScalarTraits<uint16_t> { | ||||
1173 | static void output(const uint16_t &, void *, raw_ostream &); | ||||
1174 | static StringRef input(StringRef, void *, uint16_t &); | ||||
1175 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1176 | }; | ||||
1177 | |||||
1178 | template<> | ||||
1179 | struct ScalarTraits<uint32_t> { | ||||
1180 | static void output(const uint32_t &, void *, raw_ostream &); | ||||
1181 | static StringRef input(StringRef, void *, uint32_t &); | ||||
1182 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1183 | }; | ||||
1184 | |||||
1185 | template<> | ||||
1186 | struct ScalarTraits<uint64_t> { | ||||
1187 | static void output(const uint64_t &, void *, raw_ostream &); | ||||
1188 | static StringRef input(StringRef, void *, uint64_t &); | ||||
1189 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1190 | }; | ||||
1191 | |||||
1192 | template<> | ||||
1193 | struct ScalarTraits<int8_t> { | ||||
1194 | static void output(const int8_t &, void *, raw_ostream &); | ||||
1195 | static StringRef input(StringRef, void *, int8_t &); | ||||
1196 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1197 | }; | ||||
1198 | |||||
1199 | template<> | ||||
1200 | struct ScalarTraits<int16_t> { | ||||
1201 | static void output(const int16_t &, void *, raw_ostream &); | ||||
1202 | static StringRef input(StringRef, void *, int16_t &); | ||||
1203 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1204 | }; | ||||
1205 | |||||
1206 | template<> | ||||
1207 | struct ScalarTraits<int32_t> { | ||||
1208 | static void output(const int32_t &, void *, raw_ostream &); | ||||
1209 | static StringRef input(StringRef, void *, int32_t &); | ||||
1210 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1211 | }; | ||||
1212 | |||||
1213 | template<> | ||||
1214 | struct ScalarTraits<int64_t> { | ||||
1215 | static void output(const int64_t &, void *, raw_ostream &); | ||||
1216 | static StringRef input(StringRef, void *, int64_t &); | ||||
1217 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1218 | }; | ||||
1219 | |||||
1220 | template<> | ||||
1221 | struct ScalarTraits<float> { | ||||
1222 | static void output(const float &, void *, raw_ostream &); | ||||
1223 | static StringRef input(StringRef, void *, float &); | ||||
1224 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1225 | }; | ||||
1226 | |||||
1227 | template<> | ||||
1228 | struct ScalarTraits<double> { | ||||
1229 | static void output(const double &, void *, raw_ostream &); | ||||
1230 | static StringRef input(StringRef, void *, double &); | ||||
1231 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1232 | }; | ||||
1233 | |||||
1234 | // For endian types, we use existing scalar Traits class for the underlying | ||||
1235 | // type. This way endian aware types are supported whenever the traits are | ||||
1236 | // defined for the underlying type. | ||||
1237 | template <typename value_type, support::endianness endian, size_t alignment> | ||||
1238 | struct ScalarTraits<support::detail::packed_endian_specific_integral< | ||||
1239 | value_type, endian, alignment>, | ||||
1240 | std::enable_if_t<has_ScalarTraits<value_type>::value>> { | ||||
1241 | using endian_type = | ||||
1242 | support::detail::packed_endian_specific_integral<value_type, endian, | ||||
1243 | alignment>; | ||||
1244 | |||||
1245 | static void output(const endian_type &E, void *Ctx, raw_ostream &Stream) { | ||||
1246 | ScalarTraits<value_type>::output(static_cast<value_type>(E), Ctx, Stream); | ||||
1247 | } | ||||
1248 | |||||
1249 | static StringRef input(StringRef Str, void *Ctx, endian_type &E) { | ||||
1250 | value_type V; | ||||
1251 | auto R = ScalarTraits<value_type>::input(Str, Ctx, V); | ||||
1252 | E = static_cast<endian_type>(V); | ||||
1253 | return R; | ||||
1254 | } | ||||
1255 | |||||
1256 | static QuotingType mustQuote(StringRef Str) { | ||||
1257 | return ScalarTraits<value_type>::mustQuote(Str); | ||||
1258 | } | ||||
1259 | }; | ||||
1260 | |||||
1261 | template <typename value_type, support::endianness endian, size_t alignment> | ||||
1262 | struct ScalarEnumerationTraits< | ||||
1263 | support::detail::packed_endian_specific_integral<value_type, endian, | ||||
1264 | alignment>, | ||||
1265 | std::enable_if_t<has_ScalarEnumerationTraits<value_type>::value>> { | ||||
1266 | using endian_type = | ||||
1267 | support::detail::packed_endian_specific_integral<value_type, endian, | ||||
1268 | alignment>; | ||||
1269 | |||||
1270 | static void enumeration(IO &io, endian_type &E) { | ||||
1271 | value_type V = E; | ||||
1272 | ScalarEnumerationTraits<value_type>::enumeration(io, V); | ||||
1273 | E = V; | ||||
1274 | } | ||||
1275 | }; | ||||
1276 | |||||
1277 | template <typename value_type, support::endianness endian, size_t alignment> | ||||
1278 | struct ScalarBitSetTraits< | ||||
1279 | support::detail::packed_endian_specific_integral<value_type, endian, | ||||
1280 | alignment>, | ||||
1281 | std::enable_if_t<has_ScalarBitSetTraits<value_type>::value>> { | ||||
1282 | using endian_type = | ||||
1283 | support::detail::packed_endian_specific_integral<value_type, endian, | ||||
1284 | alignment>; | ||||
1285 | static void bitset(IO &io, endian_type &E) { | ||||
1286 | value_type V = E; | ||||
1287 | ScalarBitSetTraits<value_type>::bitset(io, V); | ||||
1288 | E = V; | ||||
1289 | } | ||||
1290 | }; | ||||
1291 | |||||
1292 | // Utility for use within MappingTraits<>::mapping() method | ||||
1293 | // to [de]normalize an object for use with YAML conversion. | ||||
1294 | template <typename TNorm, typename TFinal> | ||||
1295 | struct MappingNormalization { | ||||
1296 | MappingNormalization(IO &i_o, TFinal &Obj) | ||||
1297 | : io(i_o), BufPtr(nullptr), Result(Obj) { | ||||
1298 | if ( io.outputting() ) { | ||||
1299 | BufPtr = new (&Buffer) TNorm(io, Obj); | ||||
1300 | } | ||||
1301 | else { | ||||
1302 | BufPtr = new (&Buffer) TNorm(io); | ||||
1303 | } | ||||
1304 | } | ||||
1305 | |||||
1306 | ~MappingNormalization() { | ||||
1307 | if ( ! io.outputting() ) { | ||||
1308 | Result = BufPtr->denormalize(io); | ||||
1309 | } | ||||
1310 | BufPtr->~TNorm(); | ||||
1311 | } | ||||
1312 | |||||
1313 | TNorm* operator->() { return BufPtr; } | ||||
1314 | |||||
1315 | private: | ||||
1316 | using Storage = AlignedCharArrayUnion<TNorm>; | ||||
1317 | |||||
1318 | Storage Buffer; | ||||
1319 | IO &io; | ||||
1320 | TNorm *BufPtr; | ||||
1321 | TFinal &Result; | ||||
1322 | }; | ||||
1323 | |||||
1324 | // Utility for use within MappingTraits<>::mapping() method | ||||
1325 | // to [de]normalize an object for use with YAML conversion. | ||||
1326 | template <typename TNorm, typename TFinal> | ||||
1327 | struct MappingNormalizationHeap { | ||||
1328 | MappingNormalizationHeap(IO &i_o, TFinal &Obj, BumpPtrAllocator *allocator) | ||||
1329 | : io(i_o), Result(Obj) { | ||||
1330 | if ( io.outputting() ) { | ||||
1331 | BufPtr = new (&Buffer) TNorm(io, Obj); | ||||
1332 | } | ||||
1333 | else if (allocator) { | ||||
1334 | BufPtr = allocator->Allocate<TNorm>(); | ||||
1335 | new (BufPtr) TNorm(io); | ||||
1336 | } else { | ||||
1337 | BufPtr = new TNorm(io); | ||||
1338 | } | ||||
1339 | } | ||||
1340 | |||||
1341 | ~MappingNormalizationHeap() { | ||||
1342 | if ( io.outputting() ) { | ||||
1343 | BufPtr->~TNorm(); | ||||
1344 | } | ||||
1345 | else { | ||||
1346 | Result = BufPtr->denormalize(io); | ||||
1347 | } | ||||
1348 | } | ||||
1349 | |||||
1350 | TNorm* operator->() { return BufPtr; } | ||||
1351 | |||||
1352 | private: | ||||
1353 | using Storage = AlignedCharArrayUnion<TNorm>; | ||||
1354 | |||||
1355 | Storage Buffer; | ||||
1356 | IO &io; | ||||
1357 | TNorm *BufPtr = nullptr; | ||||
1358 | TFinal &Result; | ||||
1359 | }; | ||||
1360 | |||||
1361 | /// | ||||
1362 | /// The Input class is used to parse a yaml document into in-memory structs | ||||
1363 | /// and vectors. | ||||
1364 | /// | ||||
1365 | /// It works by using YAMLParser to do a syntax parse of the entire yaml | ||||
1366 | /// document, then the Input class builds a graph of HNodes which wraps | ||||
1367 | /// each yaml Node. The extra layer is buffering. The low level yaml | ||||
1368 | /// parser only lets you look at each node once. The buffering layer lets | ||||
1369 | /// you search and interate multiple times. This is necessary because | ||||
1370 | /// the mapRequired() method calls may not be in the same order | ||||
1371 | /// as the keys in the document. | ||||
1372 | /// | ||||
1373 | class Input : public IO { | ||||
1374 | public: | ||||
1375 | // Construct a yaml Input object from a StringRef and optional | ||||
1376 | // user-data. The DiagHandler can be specified to provide | ||||
1377 | // alternative error reporting. | ||||
1378 | Input(StringRef InputContent, | ||||
1379 | void *Ctxt = nullptr, | ||||
1380 | SourceMgr::DiagHandlerTy DiagHandler = nullptr, | ||||
1381 | void *DiagHandlerCtxt = nullptr); | ||||
1382 | Input(MemoryBufferRef Input, | ||||
1383 | void *Ctxt = nullptr, | ||||
1384 | SourceMgr::DiagHandlerTy DiagHandler = nullptr, | ||||
1385 | void *DiagHandlerCtxt = nullptr); | ||||
1386 | ~Input() override; | ||||
1387 | |||||
1388 | // Check if there was an syntax or semantic error during parsing. | ||||
1389 | std::error_code error(); | ||||
1390 | |||||
1391 | private: | ||||
1392 | bool outputting() const override; | ||||
1393 | bool mapTag(StringRef, bool) override; | ||||
1394 | void beginMapping() override; | ||||
1395 | void endMapping() override; | ||||
1396 | bool preflightKey(const char *, bool, bool, bool &, void *&) override; | ||||
1397 | void postflightKey(void *) override; | ||||
1398 | std::vector<StringRef> keys() override; | ||||
1399 | void beginFlowMapping() override; | ||||
1400 | void endFlowMapping() override; | ||||
1401 | unsigned beginSequence() override; | ||||
1402 | void endSequence() override; | ||||
1403 | bool preflightElement(unsigned index, void *&) override; | ||||
1404 | void postflightElement(void *) override; | ||||
1405 | unsigned beginFlowSequence() override; | ||||
1406 | bool preflightFlowElement(unsigned , void *&) override; | ||||
1407 | void postflightFlowElement(void *) override; | ||||
1408 | void endFlowSequence() override; | ||||
1409 | void beginEnumScalar() override; | ||||
1410 | bool matchEnumScalar(const char*, bool) override; | ||||
1411 | bool matchEnumFallback() override; | ||||
1412 | void endEnumScalar() override; | ||||
1413 | bool beginBitSetScalar(bool &) override; | ||||
1414 | bool bitSetMatch(const char *, bool ) override; | ||||
1415 | void endBitSetScalar() override; | ||||
1416 | void scalarString(StringRef &, QuotingType) override; | ||||
1417 | void blockScalarString(StringRef &) override; | ||||
1418 | void scalarTag(std::string &) override; | ||||
1419 | NodeKind getNodeKind() override; | ||||
1420 | void setError(const Twine &message) override; | ||||
1421 | bool canElideEmptySequence() override; | ||||
1422 | |||||
1423 | class HNode { | ||||
1424 | virtual void anchor(); | ||||
1425 | |||||
1426 | public: | ||||
1427 | HNode(Node *n) : _node(n) { } | ||||
1428 | virtual ~HNode() = default; | ||||
1429 | |||||
1430 | static bool classof(const HNode *) { return true; } | ||||
1431 | |||||
1432 | Node *_node; | ||||
1433 | }; | ||||
1434 | |||||
1435 | class EmptyHNode : public HNode { | ||||
1436 | void anchor() override; | ||||
1437 | |||||
1438 | public: | ||||
1439 | EmptyHNode(Node *n) : HNode(n) { } | ||||
1440 | |||||
1441 | static bool classof(const HNode *n) { return NullNode::classof(n->_node); } | ||||
1442 | |||||
1443 | static bool classof(const EmptyHNode *) { return true; } | ||||
1444 | }; | ||||
1445 | |||||
1446 | class ScalarHNode : public HNode { | ||||
1447 | void anchor() override; | ||||
1448 | |||||
1449 | public: | ||||
1450 | ScalarHNode(Node *n, StringRef s) : HNode(n), _value(s) { } | ||||
1451 | |||||
1452 | StringRef value() const { return _value; } | ||||
1453 | |||||
1454 | static bool classof(const HNode *n) { | ||||
1455 | return ScalarNode::classof(n->_node) || | ||||
1456 | BlockScalarNode::classof(n->_node); | ||||
1457 | } | ||||
1458 | |||||
1459 | static bool classof(const ScalarHNode *) { return true; } | ||||
1460 | |||||
1461 | protected: | ||||
1462 | StringRef _value; | ||||
1463 | }; | ||||
1464 | |||||
1465 | class MapHNode : public HNode { | ||||
1466 | void anchor() override; | ||||
1467 | |||||
1468 | public: | ||||
1469 | MapHNode(Node *n) : HNode(n) { } | ||||
1470 | |||||
1471 | static bool classof(const HNode *n) { | ||||
1472 | return MappingNode::classof(n->_node); | ||||
1473 | } | ||||
1474 | |||||
1475 | static bool classof(const MapHNode *) { return true; } | ||||
1476 | |||||
1477 | using NameToNodeAndLoc = | ||||
1478 | StringMap<std::pair<std::unique_ptr<HNode>, SMRange>>; | ||||
1479 | |||||
1480 | NameToNodeAndLoc Mapping; | ||||
1481 | SmallVector<std::string, 6> ValidKeys; | ||||
1482 | }; | ||||
1483 | |||||
1484 | class SequenceHNode : public HNode { | ||||
1485 | void anchor() override; | ||||
1486 | |||||
1487 | public: | ||||
1488 | SequenceHNode(Node *n) : HNode(n) { } | ||||
1489 | |||||
1490 | static bool classof(const HNode *n) { | ||||
1491 | return SequenceNode::classof(n->_node); | ||||
1492 | } | ||||
1493 | |||||
1494 | static bool classof(const SequenceHNode *) { return true; } | ||||
1495 | |||||
1496 | std::vector<std::unique_ptr<HNode>> Entries; | ||||
1497 | }; | ||||
1498 | |||||
1499 | std::unique_ptr<Input::HNode> createHNodes(Node *node); | ||||
1500 | void setError(HNode *hnode, const Twine &message); | ||||
1501 | void setError(Node *node, const Twine &message); | ||||
1502 | void setError(const SMRange &Range, const Twine &message); | ||||
1503 | |||||
1504 | void reportWarning(HNode *hnode, const Twine &message); | ||||
1505 | void reportWarning(Node *hnode, const Twine &message); | ||||
1506 | void reportWarning(const SMRange &Range, const Twine &message); | ||||
1507 | |||||
1508 | public: | ||||
1509 | // These are only used by operator>>. They could be private | ||||
1510 | // if those templated things could be made friends. | ||||
1511 | bool setCurrentDocument(); | ||||
1512 | bool nextDocument(); | ||||
1513 | |||||
1514 | /// Returns the current node that's being parsed by the YAML Parser. | ||||
1515 | const Node *getCurrentNode() const; | ||||
1516 | |||||
1517 | void setAllowUnknownKeys(bool Allow) override; | ||||
1518 | |||||
1519 | private: | ||||
1520 | SourceMgr SrcMgr; // must be before Strm | ||||
1521 | std::unique_ptr<llvm::yaml::Stream> Strm; | ||||
1522 | std::unique_ptr<HNode> TopNode; | ||||
1523 | std::error_code EC; | ||||
1524 | BumpPtrAllocator StringAllocator; | ||||
1525 | document_iterator DocIterator; | ||||
1526 | std::vector<bool> BitValuesUsed; | ||||
1527 | HNode *CurrentNode = nullptr; | ||||
1528 | bool ScalarMatchFound = false; | ||||
1529 | bool AllowUnknownKeys = false; | ||||
1530 | }; | ||||
1531 | |||||
1532 | /// | ||||
1533 | /// The Output class is used to generate a yaml document from in-memory structs | ||||
1534 | /// and vectors. | ||||
1535 | /// | ||||
1536 | class Output : public IO { | ||||
1537 | public: | ||||
1538 | Output(raw_ostream &, void *Ctxt = nullptr, int WrapColumn = 70); | ||||
1539 | ~Output() override; | ||||
1540 | |||||
1541 | /// Set whether or not to output optional values which are equal | ||||
1542 | /// to the default value. By default, when outputting if you attempt | ||||
1543 | /// to write a value that is equal to the default, the value gets ignored. | ||||
1544 | /// Sometimes, it is useful to be able to see these in the resulting YAML | ||||
1545 | /// anyway. | ||||
1546 | void setWriteDefaultValues(bool Write) { WriteDefaultValues = Write; } | ||||
1547 | |||||
1548 | bool outputting() const override; | ||||
1549 | bool mapTag(StringRef, bool) override; | ||||
1550 | void beginMapping() override; | ||||
1551 | void endMapping() override; | ||||
1552 | bool preflightKey(const char *key, bool, bool, bool &, void *&) override; | ||||
1553 | void postflightKey(void *) override; | ||||
1554 | std::vector<StringRef> keys() override; | ||||
1555 | void beginFlowMapping() override; | ||||
1556 | void endFlowMapping() override; | ||||
1557 | unsigned beginSequence() override; | ||||
1558 | void endSequence() override; | ||||
1559 | bool preflightElement(unsigned, void *&) override; | ||||
1560 | void postflightElement(void *) override; | ||||
1561 | unsigned beginFlowSequence() override; | ||||
1562 | bool preflightFlowElement(unsigned, void *&) override; | ||||
1563 | void postflightFlowElement(void *) override; | ||||
1564 | void endFlowSequence() override; | ||||
1565 | void beginEnumScalar() override; | ||||
1566 | bool matchEnumScalar(const char*, bool) override; | ||||
1567 | bool matchEnumFallback() override; | ||||
1568 | void endEnumScalar() override; | ||||
1569 | bool beginBitSetScalar(bool &) override; | ||||
1570 | bool bitSetMatch(const char *, bool ) override; | ||||
1571 | void endBitSetScalar() override; | ||||
1572 | void scalarString(StringRef &, QuotingType) override; | ||||
1573 | void blockScalarString(StringRef &) override; | ||||
1574 | void scalarTag(std::string &) override; | ||||
1575 | NodeKind getNodeKind() override; | ||||
1576 | void setError(const Twine &message) override; | ||||
1577 | bool canElideEmptySequence() override; | ||||
1578 | |||||
1579 | // These are only used by operator<<. They could be private | ||||
1580 | // if that templated operator could be made a friend. | ||||
1581 | void beginDocuments(); | ||||
1582 | bool preflightDocument(unsigned); | ||||
1583 | void postflightDocument(); | ||||
1584 | void endDocuments(); | ||||
1585 | |||||
1586 | private: | ||||
1587 | void output(StringRef s); | ||||
1588 | void outputUpToEndOfLine(StringRef s); | ||||
1589 | void newLineCheck(bool EmptySequence = false); | ||||
1590 | void outputNewLine(); | ||||
1591 | void paddedKey(StringRef key); | ||||
1592 | void flowKey(StringRef Key); | ||||
1593 | |||||
1594 | enum InState { | ||||
1595 | inSeqFirstElement, | ||||
1596 | inSeqOtherElement, | ||||
1597 | inFlowSeqFirstElement, | ||||
1598 | inFlowSeqOtherElement, | ||||
1599 | inMapFirstKey, | ||||
1600 | inMapOtherKey, | ||||
1601 | inFlowMapFirstKey, | ||||
1602 | inFlowMapOtherKey | ||||
1603 | }; | ||||
1604 | |||||
1605 | static bool inSeqAnyElement(InState State); | ||||
1606 | static bool inFlowSeqAnyElement(InState State); | ||||
1607 | static bool inMapAnyKey(InState State); | ||||
1608 | static bool inFlowMapAnyKey(InState State); | ||||
1609 | |||||
1610 | raw_ostream &Out; | ||||
1611 | int WrapColumn; | ||||
1612 | SmallVector<InState, 8> StateStack; | ||||
1613 | int Column = 0; | ||||
1614 | int ColumnAtFlowStart = 0; | ||||
1615 | int ColumnAtMapFlowStart = 0; | ||||
1616 | bool NeedBitValueComma = false; | ||||
1617 | bool NeedFlowSequenceComma = false; | ||||
1618 | bool EnumerationMatchFound = false; | ||||
1619 | bool WriteDefaultValues = false; | ||||
1620 | StringRef Padding; | ||||
1621 | StringRef PaddingBeforeContainer; | ||||
1622 | }; | ||||
1623 | |||||
1624 | template <typename T, typename Context> | ||||
1625 | void IO::processKeyWithDefault(const char *Key, Optional<T> &Val, | ||||
1626 | const Optional<T> &DefaultValue, bool Required, | ||||
1627 | Context &Ctx) { | ||||
1628 | assert(DefaultValue.hasValue() == false &&(static_cast <bool> (DefaultValue.hasValue() == false && "Optional<T> shouldn't have a value!") ? void (0) : __assert_fail ("DefaultValue.hasValue() == false && \"Optional<T> shouldn't have a value!\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/YAMLTraits.h" , 1629, __extension__ __PRETTY_FUNCTION__)) | ||||
1629 | "Optional<T> shouldn't have a value!")(static_cast <bool> (DefaultValue.hasValue() == false && "Optional<T> shouldn't have a value!") ? void (0) : __assert_fail ("DefaultValue.hasValue() == false && \"Optional<T> shouldn't have a value!\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/YAMLTraits.h" , 1629, __extension__ __PRETTY_FUNCTION__)); | ||||
1630 | void *SaveInfo; | ||||
1631 | bool UseDefault = true; | ||||
1632 | const bool sameAsDefault = outputting() && !Val.hasValue(); | ||||
1633 | if (!outputting() && !Val.hasValue()) | ||||
1634 | Val = T(); | ||||
1635 | if (Val.hasValue() && | ||||
1636 | this->preflightKey(Key, Required, sameAsDefault, UseDefault, SaveInfo)) { | ||||
1637 | |||||
1638 | // When reading an Optional<X> key from a YAML description, we allow the | ||||
1639 | // special "<none>" value, which can be used to specify that no value was | ||||
1640 | // requested, i.e. the DefaultValue will be assigned. The DefaultValue is | ||||
1641 | // usually None. | ||||
1642 | bool IsNone = false; | ||||
1643 | if (!outputting()) | ||||
1644 | if (auto *Node = dyn_cast<ScalarNode>(((Input *)this)->getCurrentNode())) | ||||
1645 | // We use rtrim to ignore possible white spaces that might exist when a | ||||
1646 | // comment is present on the same line. | ||||
1647 | IsNone = Node->getRawValue().rtrim(' ') == "<none>"; | ||||
1648 | |||||
1649 | if (IsNone) | ||||
1650 | Val = DefaultValue; | ||||
1651 | else | ||||
1652 | yamlize(*this, Val.getValue(), Required, Ctx); | ||||
1653 | this->postflightKey(SaveInfo); | ||||
1654 | } else { | ||||
1655 | if (UseDefault) | ||||
1656 | Val = DefaultValue; | ||||
1657 | } | ||||
1658 | } | ||||
1659 | |||||
1660 | /// YAML I/O does conversion based on types. But often native data types | ||||
1661 | /// are just a typedef of built in intergral types (e.g. int). But the C++ | ||||
1662 | /// type matching system sees through the typedef and all the typedefed types | ||||
1663 | /// look like a built in type. This will cause the generic YAML I/O conversion | ||||
1664 | /// to be used. To provide better control over the YAML conversion, you can | ||||
1665 | /// use this macro instead of typedef. It will create a class with one field | ||||
1666 | /// and automatic conversion operators to and from the base type. | ||||
1667 | /// Based on BOOST_STRONG_TYPEDEF | ||||
1668 | #define LLVM_YAML_STRONG_TYPEDEF(_base, _type)struct _type { _type() = default; _type(const _base v) : value (v) {} _type(const _type &v) = default; _type &operator =(const _type &rhs) = default; _type &operator=(const _base &rhs) { value = rhs; return *this; } operator const _base & () const { return value; } bool operator==(const _type &rhs) const { return value == rhs.value; } bool operator ==(const _base &rhs) const { return value == rhs; } bool operator <(const _type &rhs) const { return value < rhs.value ; } _base value; using BaseType = _base; }; \ | ||||
1669 | struct _type { \ | ||||
1670 | _type() = default; \ | ||||
1671 | _type(const _base v) : value(v) {} \ | ||||
1672 | _type(const _type &v) = default; \ | ||||
1673 | _type &operator=(const _type &rhs) = default; \ | ||||
1674 | _type &operator=(const _base &rhs) { value = rhs; return *this; } \ | ||||
1675 | operator const _base & () const { return value; } \ | ||||
1676 | bool operator==(const _type &rhs) const { return value == rhs.value; } \ | ||||
1677 | bool operator==(const _base &rhs) const { return value == rhs; } \ | ||||
1678 | bool operator<(const _type &rhs) const { return value < rhs.value; } \ | ||||
1679 | _base value; \ | ||||
1680 | using BaseType = _base; \ | ||||
1681 | }; | ||||
1682 | |||||
1683 | /// | ||||
1684 | /// Use these types instead of uintXX_t in any mapping to have | ||||
1685 | /// its yaml output formatted as hexadecimal. | ||||
1686 | /// | ||||
1687 | LLVM_YAML_STRONG_TYPEDEF(uint8_t, Hex8)struct Hex8 { Hex8() = default; Hex8(const uint8_t v) : value (v) {} Hex8(const Hex8 &v) = default; Hex8 &operator= (const Hex8 &rhs) = default; Hex8 &operator=(const uint8_t &rhs) { value = rhs; return *this; } operator const uint8_t & () const { return value; } bool operator==(const Hex8 & rhs) const { return value == rhs.value; } bool operator==(const uint8_t &rhs) const { return value == rhs; } bool operator <(const Hex8 &rhs) const { return value < rhs.value ; } uint8_t value; using BaseType = uint8_t; }; | ||||
1688 | LLVM_YAML_STRONG_TYPEDEF(uint16_t, Hex16)struct Hex16 { Hex16() = default; Hex16(const uint16_t v) : value (v) {} Hex16(const Hex16 &v) = default; Hex16 &operator =(const Hex16 &rhs) = default; Hex16 &operator=(const uint16_t &rhs) { value = rhs; return *this; } operator const uint16_t & () const { return value; } bool operator==(const Hex16 &rhs) const { return value == rhs.value; } bool operator ==(const uint16_t &rhs) const { return value == rhs; } bool operator<(const Hex16 &rhs) const { return value < rhs.value; } uint16_t value; using BaseType = uint16_t; }; | ||||
1689 | LLVM_YAML_STRONG_TYPEDEF(uint32_t, Hex32)struct Hex32 { Hex32() = default; Hex32(const uint32_t v) : value (v) {} Hex32(const Hex32 &v) = default; Hex32 &operator =(const Hex32 &rhs) = default; Hex32 &operator=(const uint32_t &rhs) { value = rhs; return *this; } operator const uint32_t & () const { return value; } bool operator==(const Hex32 &rhs) const { return value == rhs.value; } bool operator ==(const uint32_t &rhs) const { return value == rhs; } bool operator<(const Hex32 &rhs) const { return value < rhs.value; } uint32_t value; using BaseType = uint32_t; }; | ||||
1690 | LLVM_YAML_STRONG_TYPEDEF(uint64_t, Hex64)struct Hex64 { Hex64() = default; Hex64(const uint64_t v) : value (v) {} Hex64(const Hex64 &v) = default; Hex64 &operator =(const Hex64 &rhs) = default; Hex64 &operator=(const uint64_t &rhs) { value = rhs; return *this; } operator const uint64_t & () const { return value; } bool operator==(const Hex64 &rhs) const { return value == rhs.value; } bool operator ==(const uint64_t &rhs) const { return value == rhs; } bool operator<(const Hex64 &rhs) const { return value < rhs.value; } uint64_t value; using BaseType = uint64_t; }; | ||||
1691 | |||||
1692 | template<> | ||||
1693 | struct ScalarTraits<Hex8> { | ||||
1694 | static void output(const Hex8 &, void *, raw_ostream &); | ||||
1695 | static StringRef input(StringRef, void *, Hex8 &); | ||||
1696 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1697 | }; | ||||
1698 | |||||
1699 | template<> | ||||
1700 | struct ScalarTraits<Hex16> { | ||||
1701 | static void output(const Hex16 &, void *, raw_ostream &); | ||||
1702 | static StringRef input(StringRef, void *, Hex16 &); | ||||
1703 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1704 | }; | ||||
1705 | |||||
1706 | template<> | ||||
1707 | struct ScalarTraits<Hex32> { | ||||
1708 | static void output(const Hex32 &, void *, raw_ostream &); | ||||
1709 | static StringRef input(StringRef, void *, Hex32 &); | ||||
1710 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1711 | }; | ||||
1712 | |||||
1713 | template<> | ||||
1714 | struct ScalarTraits<Hex64> { | ||||
1715 | static void output(const Hex64 &, void *, raw_ostream &); | ||||
1716 | static StringRef input(StringRef, void *, Hex64 &); | ||||
1717 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1718 | }; | ||||
1719 | |||||
1720 | template <> struct ScalarTraits<VersionTuple> { | ||||
1721 | static void output(const VersionTuple &Value, void *, llvm::raw_ostream &Out); | ||||
1722 | static StringRef input(StringRef, void *, VersionTuple &); | ||||
1723 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } | ||||
1724 | }; | ||||
1725 | |||||
1726 | // Define non-member operator>> so that Input can stream in a document list. | ||||
1727 | template <typename T> | ||||
1728 | inline std::enable_if_t<has_DocumentListTraits<T>::value, Input &> | ||||
1729 | operator>>(Input &yin, T &docList) { | ||||
1730 | int i = 0; | ||||
1731 | EmptyContext Ctx; | ||||
1732 | while ( yin.setCurrentDocument() ) { | ||||
1733 | yamlize(yin, DocumentListTraits<T>::element(yin, docList, i), true, Ctx); | ||||
1734 | if ( yin.error() ) | ||||
1735 | return yin; | ||||
1736 | yin.nextDocument(); | ||||
1737 | ++i; | ||||
1738 | } | ||||
1739 | return yin; | ||||
1740 | } | ||||
1741 | |||||
1742 | // Define non-member operator>> so that Input can stream in a map as a document. | ||||
1743 | template <typename T> | ||||
1744 | inline std::enable_if_t<has_MappingTraits<T, EmptyContext>::value, Input &> | ||||
1745 | operator>>(Input &yin, T &docMap) { | ||||
1746 | EmptyContext Ctx; | ||||
1747 | yin.setCurrentDocument(); | ||||
1748 | yamlize(yin, docMap, true, Ctx); | ||||
1749 | return yin; | ||||
1750 | } | ||||
1751 | |||||
1752 | // Define non-member operator>> so that Input can stream in a sequence as | ||||
1753 | // a document. | ||||
1754 | template <typename T> | ||||
1755 | inline std::enable_if_t<has_SequenceTraits<T>::value, Input &> | ||||
1756 | operator>>(Input &yin, T &docSeq) { | ||||
1757 | EmptyContext Ctx; | ||||
1758 | if (yin.setCurrentDocument()) | ||||
1759 | yamlize(yin, docSeq, true, Ctx); | ||||
1760 | return yin; | ||||
1761 | } | ||||
1762 | |||||
1763 | // Define non-member operator>> so that Input can stream in a block scalar. | ||||
1764 | template <typename T> | ||||
1765 | inline std::enable_if_t<has_BlockScalarTraits<T>::value, Input &> | ||||
1766 | operator>>(Input &In, T &Val) { | ||||
1767 | EmptyContext Ctx; | ||||
1768 | if (In.setCurrentDocument()) | ||||
1769 | yamlize(In, Val, true, Ctx); | ||||
1770 | return In; | ||||
1771 | } | ||||
1772 | |||||
1773 | // Define non-member operator>> so that Input can stream in a string map. | ||||
1774 | template <typename T> | ||||
1775 | inline std::enable_if_t<has_CustomMappingTraits<T>::value, Input &> | ||||
1776 | operator>>(Input &In, T &Val) { | ||||
1777 | EmptyContext Ctx; | ||||
1778 | if (In.setCurrentDocument()) | ||||
1779 | yamlize(In, Val, true, Ctx); | ||||
1780 | return In; | ||||
1781 | } | ||||
1782 | |||||
1783 | // Define non-member operator>> so that Input can stream in a polymorphic type. | ||||
1784 | template <typename T> | ||||
1785 | inline std::enable_if_t<has_PolymorphicTraits<T>::value, Input &> | ||||
1786 | operator>>(Input &In, T &Val) { | ||||
1787 | EmptyContext Ctx; | ||||
1788 | if (In.setCurrentDocument()) | ||||
1789 | yamlize(In, Val, true, Ctx); | ||||
1790 | return In; | ||||
1791 | } | ||||
1792 | |||||
1793 | // Provide better error message about types missing a trait specialization | ||||
1794 | template <typename T> | ||||
1795 | inline std::enable_if_t<missingTraits<T, EmptyContext>::value, Input &> | ||||
1796 | operator>>(Input &yin, T &docSeq) { | ||||
1797 | char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)]; | ||||
1798 | return yin; | ||||
1799 | } | ||||
1800 | |||||
1801 | // Define non-member operator<< so that Output can stream out document list. | ||||
1802 | template <typename T> | ||||
1803 | inline std::enable_if_t<has_DocumentListTraits<T>::value, Output &> | ||||
1804 | operator<<(Output &yout, T &docList) { | ||||
1805 | EmptyContext Ctx; | ||||
1806 | yout.beginDocuments(); | ||||
1807 | const size_t count = DocumentListTraits<T>::size(yout, docList); | ||||
1808 | for(size_t i=0; i < count; ++i) { | ||||
1809 | if ( yout.preflightDocument(i) ) { | ||||
1810 | yamlize(yout, DocumentListTraits<T>::element(yout, docList, i), true, | ||||
1811 | Ctx); | ||||
1812 | yout.postflightDocument(); | ||||
1813 | } | ||||
1814 | } | ||||
1815 | yout.endDocuments(); | ||||
1816 | return yout; | ||||
1817 | } | ||||
1818 | |||||
1819 | // Define non-member operator<< so that Output can stream out a map. | ||||
1820 | template <typename T> | ||||
1821 | inline std::enable_if_t<has_MappingTraits<T, EmptyContext>::value, Output &> | ||||
1822 | operator<<(Output &yout, T &map) { | ||||
1823 | EmptyContext Ctx; | ||||
1824 | yout.beginDocuments(); | ||||
1825 | if ( yout.preflightDocument(0) ) { | ||||
1826 | yamlize(yout, map, true, Ctx); | ||||
1827 | yout.postflightDocument(); | ||||
1828 | } | ||||
1829 | yout.endDocuments(); | ||||
1830 | return yout; | ||||
1831 | } | ||||
1832 | |||||
1833 | // Define non-member operator<< so that Output can stream out a sequence. | ||||
1834 | template <typename T> | ||||
1835 | inline std::enable_if_t<has_SequenceTraits<T>::value, Output &> | ||||
1836 | operator<<(Output &yout, T &seq) { | ||||
1837 | EmptyContext Ctx; | ||||
1838 | yout.beginDocuments(); | ||||
1839 | if ( yout.preflightDocument(0) ) { | ||||
1840 | yamlize(yout, seq, true, Ctx); | ||||
1841 | yout.postflightDocument(); | ||||
1842 | } | ||||
1843 | yout.endDocuments(); | ||||
1844 | return yout; | ||||
1845 | } | ||||
1846 | |||||
1847 | // Define non-member operator<< so that Output can stream out a block scalar. | ||||
1848 | template <typename T> | ||||
1849 | inline std::enable_if_t<has_BlockScalarTraits<T>::value, Output &> | ||||
1850 | operator<<(Output &Out, T &Val) { | ||||
1851 | EmptyContext Ctx; | ||||
1852 | Out.beginDocuments(); | ||||
1853 | if (Out.preflightDocument(0)) { | ||||
1854 | yamlize(Out, Val, true, Ctx); | ||||
1855 | Out.postflightDocument(); | ||||
1856 | } | ||||
1857 | Out.endDocuments(); | ||||
1858 | return Out; | ||||
1859 | } | ||||
1860 | |||||
1861 | // Define non-member operator<< so that Output can stream out a string map. | ||||
1862 | template <typename T> | ||||
1863 | inline std::enable_if_t<has_CustomMappingTraits<T>::value, Output &> | ||||
1864 | operator<<(Output &Out, T &Val) { | ||||
1865 | EmptyContext Ctx; | ||||
1866 | Out.beginDocuments(); | ||||
1867 | if (Out.preflightDocument(0)) { | ||||
1868 | yamlize(Out, Val, true, Ctx); | ||||
1869 | Out.postflightDocument(); | ||||
1870 | } | ||||
1871 | Out.endDocuments(); | ||||
1872 | return Out; | ||||
1873 | } | ||||
1874 | |||||
1875 | // Define non-member operator<< so that Output can stream out a polymorphic | ||||
1876 | // type. | ||||
1877 | template <typename T> | ||||
1878 | inline std::enable_if_t<has_PolymorphicTraits<T>::value, Output &> | ||||
1879 | operator<<(Output &Out, T &Val) { | ||||
1880 | EmptyContext Ctx; | ||||
1881 | Out.beginDocuments(); | ||||
1882 | if (Out.preflightDocument(0)) { | ||||
1883 | // FIXME: The parser does not support explicit documents terminated with a | ||||
1884 | // plain scalar; the end-marker is included as part of the scalar token. | ||||
1885 | assert(PolymorphicTraits<T>::getKind(Val) != NodeKind::Scalar && "plain scalar documents are not supported")(static_cast <bool> (PolymorphicTraits<T>::getKind (Val) != NodeKind::Scalar && "plain scalar documents are not supported" ) ? void (0) : __assert_fail ("PolymorphicTraits<T>::getKind(Val) != NodeKind::Scalar && \"plain scalar documents are not supported\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include/llvm/Support/YAMLTraits.h" , 1885, __extension__ __PRETTY_FUNCTION__)); | ||||
1886 | yamlize(Out, Val, true, Ctx); | ||||
1887 | Out.postflightDocument(); | ||||
1888 | } | ||||
1889 | Out.endDocuments(); | ||||
1890 | return Out; | ||||
1891 | } | ||||
1892 | |||||
1893 | // Provide better error message about types missing a trait specialization | ||||
1894 | template <typename T> | ||||
1895 | inline std::enable_if_t<missingTraits<T, EmptyContext>::value, Output &> | ||||
1896 | operator<<(Output &yout, T &seq) { | ||||
1897 | char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)]; | ||||
1898 | return yout; | ||||
1899 | } | ||||
1900 | |||||
1901 | template <bool B> struct IsFlowSequenceBase {}; | ||||
1902 | template <> struct IsFlowSequenceBase<true> { static const bool flow = true; }; | ||||
1903 | |||||
1904 | template <typename T, bool Flow> | ||||
1905 | struct SequenceTraitsImpl : IsFlowSequenceBase<Flow> { | ||||
1906 | private: | ||||
1907 | using type = typename T::value_type; | ||||
1908 | |||||
1909 | public: | ||||
1910 | static size_t size(IO &io, T &seq) { return seq.size(); } | ||||
1911 | |||||
1912 | static type &element(IO &io, T &seq, size_t index) { | ||||
1913 | if (index >= seq.size()) | ||||
1914 | seq.resize(index + 1); | ||||
1915 | return seq[index]; | ||||
1916 | } | ||||
1917 | }; | ||||
1918 | |||||
1919 | // Simple helper to check an expression can be used as a bool-valued template | ||||
1920 | // argument. | ||||
1921 | template <bool> struct CheckIsBool { static const bool value = true; }; | ||||
1922 | |||||
1923 | // If T has SequenceElementTraits, then vector<T> and SmallVector<T, N> have | ||||
1924 | // SequenceTraits that do the obvious thing. | ||||
1925 | template <typename T> | ||||
1926 | struct SequenceTraits< | ||||
1927 | std::vector<T>, | ||||
1928 | std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>> | ||||
1929 | : SequenceTraitsImpl<std::vector<T>, SequenceElementTraits<T>::flow> {}; | ||||
1930 | template <typename T, unsigned N> | ||||
1931 | struct SequenceTraits< | ||||
1932 | SmallVector<T, N>, | ||||
1933 | std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>> | ||||
1934 | : SequenceTraitsImpl<SmallVector<T, N>, SequenceElementTraits<T>::flow> {}; | ||||
1935 | template <typename T> | ||||
1936 | struct SequenceTraits< | ||||
1937 | SmallVectorImpl<T>, | ||||
1938 | std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>> | ||||
1939 | : SequenceTraitsImpl<SmallVectorImpl<T>, SequenceElementTraits<T>::flow> {}; | ||||
1940 | |||||
1941 | // Sequences of fundamental types use flow formatting. | ||||
1942 | template <typename T> | ||||
1943 | struct SequenceElementTraits<T, | ||||
1944 | std::enable_if_t<std::is_fundamental<T>::value>> { | ||||
1945 | static const bool flow = true; | ||||
1946 | }; | ||||
1947 | |||||
1948 | // Sequences of strings use block formatting. | ||||
1949 | template<> struct SequenceElementTraits<std::string> { | ||||
1950 | static const bool flow = false; | ||||
1951 | }; | ||||
1952 | template<> struct SequenceElementTraits<StringRef> { | ||||
1953 | static const bool flow = false; | ||||
1954 | }; | ||||
1955 | template<> struct SequenceElementTraits<std::pair<std::string, std::string>> { | ||||
1956 | static const bool flow = false; | ||||
1957 | }; | ||||
1958 | |||||
1959 | /// Implementation of CustomMappingTraits for std::map<std::string, T>. | ||||
1960 | template <typename T> struct StdMapStringCustomMappingTraitsImpl { | ||||
1961 | using map_type = std::map<std::string, T>; | ||||
1962 | |||||
1963 | static void inputOne(IO &io, StringRef key, map_type &v) { | ||||
1964 | io.mapRequired(key.str().c_str(), v[std::string(key)]); | ||||
1965 | } | ||||
1966 | |||||
1967 | static void output(IO &io, map_type &v) { | ||||
1968 | for (auto &p : v) | ||||
1969 | io.mapRequired(p.first.c_str(), p.second); | ||||
1970 | } | ||||
1971 | }; | ||||
1972 | |||||
1973 | } // end namespace yaml | ||||
1974 | } // end namespace llvm | ||||
1975 | |||||
1976 | #define LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(TYPE, FLOW)namespace llvm { namespace yaml { static_assert( !std::is_fundamental <TYPE>::value && !std::is_same<TYPE, std::string >::value && !std::is_same<TYPE, llvm::StringRef >::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control" ); template <> struct SequenceElementTraits<TYPE> { static const bool flow = FLOW; }; } } \ | ||||
1977 | namespace llvm { \ | ||||
1978 | namespace yaml { \ | ||||
1979 | static_assert( \ | ||||
1980 | !std::is_fundamental<TYPE>::value && \ | ||||
1981 | !std::is_same<TYPE, std::string>::value && \ | ||||
1982 | !std::is_same<TYPE, llvm::StringRef>::value, \ | ||||
1983 | "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"); \ | ||||
1984 | template <> struct SequenceElementTraits<TYPE> { \ | ||||
1985 | static const bool flow = FLOW; \ | ||||
1986 | }; \ | ||||
1987 | } \ | ||||
1988 | } | ||||
1989 | |||||
1990 | /// Utility for declaring that a std::vector of a particular type | ||||
1991 | /// should be considered a YAML sequence. | ||||
1992 | #define LLVM_YAML_IS_SEQUENCE_VECTOR(type)namespace llvm { namespace yaml { static_assert( !std::is_fundamental <type>::value && !std::is_same<type, std::string >::value && !std::is_same<type, llvm::StringRef >::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control" ); template <> struct SequenceElementTraits<type> { static const bool flow = false; }; } } \ | ||||
1993 | LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, false)namespace llvm { namespace yaml { static_assert( !std::is_fundamental <type>::value && !std::is_same<type, std::string >::value && !std::is_same<type, llvm::StringRef >::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control" ); template <> struct SequenceElementTraits<type> { static const bool flow = false; }; } } | ||||
1994 | |||||
1995 | /// Utility for declaring that a std::vector of a particular type | ||||
1996 | /// should be considered a YAML flow sequence. | ||||
1997 | #define LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(type)namespace llvm { namespace yaml { static_assert( !std::is_fundamental <type>::value && !std::is_same<type, std::string >::value && !std::is_same<type, llvm::StringRef >::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control" ); template <> struct SequenceElementTraits<type> { static const bool flow = true; }; } } \ | ||||
1998 | LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, true)namespace llvm { namespace yaml { static_assert( !std::is_fundamental <type>::value && !std::is_same<type, std::string >::value && !std::is_same<type, llvm::StringRef >::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control" ); template <> struct SequenceElementTraits<type> { static const bool flow = true; }; } } | ||||
1999 | |||||
2000 | #define LLVM_YAML_DECLARE_MAPPING_TRAITS(Type)namespace llvm { namespace yaml { template <> struct MappingTraits <Type> { static void mapping(IO &IO, Type &Obj) ; }; } } \ | ||||
2001 | namespace llvm { \ | ||||
2002 | namespace yaml { \ | ||||
2003 | template <> struct MappingTraits<Type> { \ | ||||
2004 | static void mapping(IO &IO, Type &Obj); \ | ||||
2005 | }; \ | ||||
2006 | } \ | ||||
2007 | } | ||||
2008 | |||||
2009 | #define LLVM_YAML_DECLARE_ENUM_TRAITS(Type)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits <Type> { static void enumeration(IO &io, Type & Value); }; } } \ | ||||
2010 | namespace llvm { \ | ||||
2011 | namespace yaml { \ | ||||
2012 | template <> struct ScalarEnumerationTraits<Type> { \ | ||||
2013 | static void enumeration(IO &io, Type &Value); \ | ||||
2014 | }; \ | ||||
2015 | } \ | ||||
2016 | } | ||||
2017 | |||||
2018 | #define LLVM_YAML_DECLARE_BITSET_TRAITS(Type)namespace llvm { namespace yaml { template <> struct ScalarBitSetTraits <Type> { static void bitset(IO &IO, Type &Options ); }; } } \ | ||||
2019 | namespace llvm { \ | ||||
2020 | namespace yaml { \ | ||||
2021 | template <> struct ScalarBitSetTraits<Type> { \ | ||||
2022 | static void bitset(IO &IO, Type &Options); \ | ||||
2023 | }; \ | ||||
2024 | } \ | ||||
2025 | } | ||||
2026 | |||||
2027 | #define LLVM_YAML_DECLARE_SCALAR_TRAITS(Type, MustQuote)namespace llvm { namespace yaml { template <> struct ScalarTraits <Type> { static void output(const Type &Value, void *ctx, raw_ostream &Out); static StringRef input(StringRef Scalar, void *ctxt, Type &Value); static QuotingType mustQuote (StringRef) { return MustQuote; } }; } } \ | ||||
2028 | namespace llvm { \ | ||||
2029 | namespace yaml { \ | ||||
2030 | template <> struct ScalarTraits<Type> { \ | ||||
2031 | static void output(const Type &Value, void *ctx, raw_ostream &Out); \ | ||||
2032 | static StringRef input(StringRef Scalar, void *ctxt, Type &Value); \ | ||||
2033 | static QuotingType mustQuote(StringRef) { return MustQuote; } \ | ||||
2034 | }; \ | ||||
2035 | } \ | ||||
2036 | } | ||||
2037 | |||||
2038 | /// Utility for declaring that a std::vector of a particular type | ||||
2039 | /// should be considered a YAML document list. | ||||
2040 | #define LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(_type)namespace llvm { namespace yaml { template <unsigned N> struct DocumentListTraits<SmallVector<_type, N>> : public SequenceTraitsImpl<SmallVector<_type, N>, false > {}; template <> struct DocumentListTraits<std:: vector<_type>> : public SequenceTraitsImpl<std::vector <_type>, false> {}; } } \ | ||||
2041 | namespace llvm { \ | ||||
2042 | namespace yaml { \ | ||||
2043 | template <unsigned N> \ | ||||
2044 | struct DocumentListTraits<SmallVector<_type, N>> \ | ||||
2045 | : public SequenceTraitsImpl<SmallVector<_type, N>, false> {}; \ | ||||
2046 | template <> \ | ||||
2047 | struct DocumentListTraits<std::vector<_type>> \ | ||||
2048 | : public SequenceTraitsImpl<std::vector<_type>, false> {}; \ | ||||
2049 | } \ | ||||
2050 | } | ||||
2051 | |||||
2052 | /// Utility for declaring that std::map<std::string, _type> should be considered | ||||
2053 | /// a YAML map. | ||||
2054 | #define LLVM_YAML_IS_STRING_MAP(_type)namespace llvm { namespace yaml { template <> struct CustomMappingTraits <std::map<std::string, _type>> : public StdMapStringCustomMappingTraitsImpl <_type> {}; } } \ | ||||
2055 | namespace llvm { \ | ||||
2056 | namespace yaml { \ | ||||
2057 | template <> \ | ||||
2058 | struct CustomMappingTraits<std::map<std::string, _type>> \ | ||||
2059 | : public StdMapStringCustomMappingTraitsImpl<_type> {}; \ | ||||
2060 | } \ | ||||
2061 | } | ||||
2062 | |||||
2063 | LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::Hex64)namespace llvm { namespace yaml { static_assert( !std::is_fundamental <llvm::yaml::Hex64>::value && !std::is_same< llvm::yaml::Hex64, std::string>::value && !std::is_same <llvm::yaml::Hex64, llvm::StringRef>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control" ); template <> struct SequenceElementTraits<llvm::yaml ::Hex64> { static const bool flow = true; }; } } | ||||
2064 | LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::Hex32)namespace llvm { namespace yaml { static_assert( !std::is_fundamental <llvm::yaml::Hex32>::value && !std::is_same< llvm::yaml::Hex32, std::string>::value && !std::is_same <llvm::yaml::Hex32, llvm::StringRef>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control" ); template <> struct SequenceElementTraits<llvm::yaml ::Hex32> { static const bool flow = true; }; } } | ||||
2065 | LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::Hex16)namespace llvm { namespace yaml { static_assert( !std::is_fundamental <llvm::yaml::Hex16>::value && !std::is_same< llvm::yaml::Hex16, std::string>::value && !std::is_same <llvm::yaml::Hex16, llvm::StringRef>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control" ); template <> struct SequenceElementTraits<llvm::yaml ::Hex16> { static const bool flow = true; }; } } | ||||
2066 | LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::Hex8)namespace llvm { namespace yaml { static_assert( !std::is_fundamental <llvm::yaml::Hex8>::value && !std::is_same<llvm ::yaml::Hex8, std::string>::value && !std::is_same <llvm::yaml::Hex8, llvm::StringRef>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control" ); template <> struct SequenceElementTraits<llvm::yaml ::Hex8> { static const bool flow = true; }; } } | ||||
2067 | |||||
2068 | #endif // LLVM_SUPPORT_YAMLTRAITS_H |