File: | llvm/include/llvm/Support/YAMLTraits.h |
Warning: | line 799, column 51 The left operand of '==' is a garbage value |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===- CodeViewYAMLSymbols.cpp - CodeView YAMLIO Symbol 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 | // This file defines classes for handling the YAML representation of CodeView | |||
10 | // Debug Info. | |||
11 | // | |||
12 | //===----------------------------------------------------------------------===// | |||
13 | ||||
14 | #include "llvm/ObjectYAML/CodeViewYAMLSymbols.h" | |||
15 | #include "llvm/ADT/ArrayRef.h" | |||
16 | #include "llvm/ADT/StringRef.h" | |||
17 | #include "llvm/DebugInfo/CodeView/CodeView.h" | |||
18 | #include "llvm/DebugInfo/CodeView/CodeViewError.h" | |||
19 | #include "llvm/DebugInfo/CodeView/EnumTables.h" | |||
20 | #include "llvm/DebugInfo/CodeView/RecordSerialization.h" | |||
21 | #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h" | |||
22 | #include "llvm/DebugInfo/CodeView/SymbolRecord.h" | |||
23 | #include "llvm/DebugInfo/CodeView/SymbolSerializer.h" | |||
24 | #include "llvm/DebugInfo/CodeView/TypeIndex.h" | |||
25 | #include "llvm/ObjectYAML/YAML.h" | |||
26 | #include "llvm/Support/Allocator.h" | |||
27 | #include "llvm/Support/Error.h" | |||
28 | #include "llvm/Support/YAMLTraits.h" | |||
29 | #include <algorithm> | |||
30 | #include <cstdint> | |||
31 | #include <cstring> | |||
32 | #include <string> | |||
33 | #include <vector> | |||
34 | ||||
35 | using namespace llvm; | |||
36 | using namespace llvm::codeview; | |||
37 | using namespace llvm::CodeViewYAML; | |||
38 | using namespace llvm::CodeViewYAML::detail; | |||
39 | using namespace llvm::yaml; | |||
40 | ||||
41 | LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)namespace llvm { namespace yaml { static_assert( !std::is_fundamental <TypeIndex>::value && !std::is_same<TypeIndex , std::string>::value && !std::is_same<TypeIndex , llvm::StringRef>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control" ); template <> struct SequenceElementTraits<TypeIndex > { static const bool flow = true; }; } } | |||
42 | LLVM_YAML_IS_SEQUENCE_VECTOR(LocalVariableAddrGap)namespace llvm { namespace yaml { static_assert( !std::is_fundamental <LocalVariableAddrGap>::value && !std::is_same< LocalVariableAddrGap, std::string>::value && !std:: is_same<LocalVariableAddrGap, llvm::StringRef>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control" ); template <> struct SequenceElementTraits<LocalVariableAddrGap > { static const bool flow = false; }; } } | |||
43 | ||||
44 | // We only need to declare these, the definitions are in CodeViewYAMLTypes.cpp | |||
45 | LLVM_YAML_DECLARE_SCALAR_TRAITS(APSInt, QuotingType::None)namespace llvm { namespace yaml { template <> struct ScalarTraits <APSInt> { static void output(const APSInt &Value, void *ctx, raw_ostream &Out); static StringRef input(StringRef Scalar, void *ctxt, APSInt &Value); static QuotingType mustQuote (StringRef) { return QuotingType::None; } }; } } | |||
46 | LLVM_YAML_DECLARE_SCALAR_TRAITS(TypeIndex, QuotingType::None)namespace llvm { namespace yaml { template <> struct ScalarTraits <TypeIndex> { static void output(const TypeIndex &Value , void *ctx, raw_ostream &Out); static StringRef input(StringRef Scalar, void *ctxt, TypeIndex &Value); static QuotingType mustQuote(StringRef) { return QuotingType::None; } }; } } | |||
47 | ||||
48 | LLVM_YAML_DECLARE_ENUM_TRAITS(SymbolKind)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits <SymbolKind> { static void enumeration(IO &io, SymbolKind &Value); }; } } | |||
49 | LLVM_YAML_DECLARE_ENUM_TRAITS(FrameCookieKind)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits <FrameCookieKind> { static void enumeration(IO &io, FrameCookieKind &Value); }; } } | |||
50 | ||||
51 | LLVM_YAML_DECLARE_BITSET_TRAITS(CompileSym2Flags)namespace llvm { namespace yaml { template <> struct ScalarBitSetTraits <CompileSym2Flags> { static void bitset(IO &IO, CompileSym2Flags &Options); }; } } | |||
52 | LLVM_YAML_DECLARE_BITSET_TRAITS(CompileSym3Flags)namespace llvm { namespace yaml { template <> struct ScalarBitSetTraits <CompileSym3Flags> { static void bitset(IO &IO, CompileSym3Flags &Options); }; } } | |||
53 | LLVM_YAML_DECLARE_BITSET_TRAITS(ExportFlags)namespace llvm { namespace yaml { template <> struct ScalarBitSetTraits <ExportFlags> { static void bitset(IO &IO, ExportFlags &Options); }; } } | |||
54 | LLVM_YAML_DECLARE_BITSET_TRAITS(PublicSymFlags)namespace llvm { namespace yaml { template <> struct ScalarBitSetTraits <PublicSymFlags> { static void bitset(IO &IO, PublicSymFlags &Options); }; } } | |||
55 | LLVM_YAML_DECLARE_BITSET_TRAITS(LocalSymFlags)namespace llvm { namespace yaml { template <> struct ScalarBitSetTraits <LocalSymFlags> { static void bitset(IO &IO, LocalSymFlags &Options); }; } } | |||
56 | LLVM_YAML_DECLARE_BITSET_TRAITS(ProcSymFlags)namespace llvm { namespace yaml { template <> struct ScalarBitSetTraits <ProcSymFlags> { static void bitset(IO &IO, ProcSymFlags &Options); }; } } | |||
57 | LLVM_YAML_DECLARE_BITSET_TRAITS(FrameProcedureOptions)namespace llvm { namespace yaml { template <> struct ScalarBitSetTraits <FrameProcedureOptions> { static void bitset(IO &IO , FrameProcedureOptions &Options); }; } } | |||
58 | LLVM_YAML_DECLARE_ENUM_TRAITS(CPUType)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits <CPUType> { static void enumeration(IO &io, CPUType &Value); }; } } | |||
59 | LLVM_YAML_DECLARE_ENUM_TRAITS(RegisterId)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits <RegisterId> { static void enumeration(IO &io, RegisterId &Value); }; } } | |||
60 | LLVM_YAML_DECLARE_ENUM_TRAITS(TrampolineType)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits <TrampolineType> { static void enumeration(IO &io, TrampolineType &Value); }; } } | |||
61 | LLVM_YAML_DECLARE_ENUM_TRAITS(ThunkOrdinal)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits <ThunkOrdinal> { static void enumeration(IO &io, ThunkOrdinal &Value); }; } } | |||
62 | ||||
63 | LLVM_YAML_STRONG_TYPEDEF(StringRef, TypeName)struct TypeName { TypeName() = default; TypeName(const StringRef v) : value(v) {} TypeName(const TypeName &v) = default; TypeName &operator=(const TypeName &rhs) = default; TypeName & operator=(const StringRef &rhs) { value = rhs; return *this ; } operator const StringRef & () const { return value; } bool operator==(const TypeName &rhs) const { return value == rhs.value; } bool operator==(const StringRef &rhs) const { return value == rhs; } bool operator<(const TypeName & rhs) const { return value < rhs.value; } StringRef value; using BaseType = StringRef; }; | |||
64 | ||||
65 | LLVM_YAML_DECLARE_SCALAR_TRAITS(TypeName, QuotingType::Single)namespace llvm { namespace yaml { template <> struct ScalarTraits <TypeName> { static void output(const TypeName &Value , void *ctx, raw_ostream &Out); static StringRef input(StringRef Scalar, void *ctxt, TypeName &Value); static QuotingType mustQuote(StringRef) { return QuotingType::Single; } }; } } | |||
66 | ||||
67 | StringRef ScalarTraits<TypeName>::input(StringRef S, void *V, TypeName &T) { | |||
68 | return ScalarTraits<StringRef>::input(S, V, T.value); | |||
69 | } | |||
70 | ||||
71 | void ScalarTraits<TypeName>::output(const TypeName &T, void *V, | |||
72 | raw_ostream &R) { | |||
73 | ScalarTraits<StringRef>::output(T.value, V, R); | |||
74 | } | |||
75 | ||||
76 | void ScalarEnumerationTraits<SymbolKind>::enumeration(IO &io, | |||
77 | SymbolKind &Value) { | |||
78 | auto SymbolNames = getSymbolTypeNames(); | |||
79 | for (const auto &E : SymbolNames) | |||
80 | io.enumCase(Value, E.Name.str().c_str(), E.Value); | |||
81 | } | |||
82 | ||||
83 | void ScalarBitSetTraits<CompileSym2Flags>::bitset(IO &io, | |||
84 | CompileSym2Flags &Flags) { | |||
85 | auto FlagNames = getCompileSym2FlagNames(); | |||
86 | for (const auto &E : FlagNames) { | |||
87 | io.bitSetCase(Flags, E.Name.str().c_str(), | |||
88 | static_cast<CompileSym2Flags>(E.Value)); | |||
89 | } | |||
90 | } | |||
91 | ||||
92 | void ScalarBitSetTraits<CompileSym3Flags>::bitset(IO &io, | |||
93 | CompileSym3Flags &Flags) { | |||
94 | auto FlagNames = getCompileSym3FlagNames(); | |||
95 | for (const auto &E : FlagNames) { | |||
96 | io.bitSetCase(Flags, E.Name.str().c_str(), | |||
97 | static_cast<CompileSym3Flags>(E.Value)); | |||
98 | } | |||
99 | } | |||
100 | ||||
101 | void ScalarBitSetTraits<ExportFlags>::bitset(IO &io, ExportFlags &Flags) { | |||
102 | auto FlagNames = getExportSymFlagNames(); | |||
103 | for (const auto &E : FlagNames) { | |||
104 | io.bitSetCase(Flags, E.Name.str().c_str(), | |||
105 | static_cast<ExportFlags>(E.Value)); | |||
106 | } | |||
107 | } | |||
108 | ||||
109 | void ScalarBitSetTraits<PublicSymFlags>::bitset(IO &io, PublicSymFlags &Flags) { | |||
110 | auto FlagNames = getPublicSymFlagNames(); | |||
111 | for (const auto &E : FlagNames) { | |||
112 | io.bitSetCase(Flags, E.Name.str().c_str(), | |||
113 | static_cast<PublicSymFlags>(E.Value)); | |||
114 | } | |||
115 | } | |||
116 | ||||
117 | void ScalarBitSetTraits<LocalSymFlags>::bitset(IO &io, LocalSymFlags &Flags) { | |||
118 | auto FlagNames = getLocalFlagNames(); | |||
119 | for (const auto &E : FlagNames) { | |||
120 | io.bitSetCase(Flags, E.Name.str().c_str(), | |||
121 | static_cast<LocalSymFlags>(E.Value)); | |||
122 | } | |||
123 | } | |||
124 | ||||
125 | void ScalarBitSetTraits<ProcSymFlags>::bitset(IO &io, ProcSymFlags &Flags) { | |||
126 | auto FlagNames = getProcSymFlagNames(); | |||
127 | for (const auto &E : FlagNames) { | |||
128 | io.bitSetCase(Flags, E.Name.str().c_str(), | |||
129 | static_cast<ProcSymFlags>(E.Value)); | |||
130 | } | |||
131 | } | |||
132 | ||||
133 | void ScalarBitSetTraits<FrameProcedureOptions>::bitset( | |||
134 | IO &io, FrameProcedureOptions &Flags) { | |||
135 | auto FlagNames = getFrameProcSymFlagNames(); | |||
136 | for (const auto &E : FlagNames) { | |||
137 | io.bitSetCase(Flags, E.Name.str().c_str(), | |||
138 | static_cast<FrameProcedureOptions>(E.Value)); | |||
139 | } | |||
140 | } | |||
141 | ||||
142 | void ScalarEnumerationTraits<CPUType>::enumeration(IO &io, CPUType &Cpu) { | |||
143 | auto CpuNames = getCPUTypeNames(); | |||
144 | for (const auto &E : CpuNames) { | |||
145 | io.enumCase(Cpu, E.Name.str().c_str(), static_cast<CPUType>(E.Value)); | |||
146 | } | |||
147 | } | |||
148 | ||||
149 | void ScalarEnumerationTraits<RegisterId>::enumeration(IO &io, RegisterId &Reg) { | |||
150 | const auto *Header = static_cast<COFF::header *>(io.getContext()); | |||
151 | assert(Header && "The IO context is not initialized")(static_cast <bool> (Header && "The IO context is not initialized" ) ? void (0) : __assert_fail ("Header && \"The IO context is not initialized\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/ObjectYAML/CodeViewYAMLSymbols.cpp" , 151, __extension__ __PRETTY_FUNCTION__)); | |||
152 | ||||
153 | Optional<CPUType> CpuType; | |||
154 | ArrayRef<EnumEntry<uint16_t>> RegNames; | |||
155 | ||||
156 | switch (Header->Machine) { | |||
157 | case COFF::IMAGE_FILE_MACHINE_I386: | |||
158 | CpuType = CPUType::Pentium3; | |||
159 | break; | |||
160 | case COFF::IMAGE_FILE_MACHINE_AMD64: | |||
161 | CpuType = CPUType::X64; | |||
162 | break; | |||
163 | case COFF::IMAGE_FILE_MACHINE_ARMNT: | |||
164 | CpuType = CPUType::ARMNT; | |||
165 | break; | |||
166 | case COFF::IMAGE_FILE_MACHINE_ARM64: | |||
167 | CpuType = CPUType::ARM64; | |||
168 | break; | |||
169 | } | |||
170 | ||||
171 | if (CpuType) | |||
172 | RegNames = getRegisterNames(*CpuType); | |||
173 | ||||
174 | for (const auto &E : RegNames) { | |||
175 | io.enumCase(Reg, E.Name.str().c_str(), static_cast<RegisterId>(E.Value)); | |||
176 | } | |||
177 | io.enumFallback<Hex16>(Reg); | |||
178 | } | |||
179 | ||||
180 | void ScalarEnumerationTraits<TrampolineType>::enumeration( | |||
181 | IO &io, TrampolineType &Tramp) { | |||
182 | auto TrampNames = getTrampolineNames(); | |||
183 | for (const auto &E : TrampNames) { | |||
184 | io.enumCase(Tramp, E.Name.str().c_str(), | |||
185 | static_cast<TrampolineType>(E.Value)); | |||
186 | } | |||
187 | } | |||
188 | ||||
189 | void ScalarEnumerationTraits<ThunkOrdinal>::enumeration(IO &io, | |||
190 | ThunkOrdinal &Ord) { | |||
191 | auto ThunkNames = getThunkOrdinalNames(); | |||
192 | for (const auto &E : ThunkNames) { | |||
193 | io.enumCase(Ord, E.Name.str().c_str(), static_cast<ThunkOrdinal>(E.Value)); | |||
194 | } | |||
195 | } | |||
196 | ||||
197 | void ScalarEnumerationTraits<FrameCookieKind>::enumeration( | |||
198 | IO &io, FrameCookieKind &FC) { | |||
199 | auto ThunkNames = getFrameCookieKindNames(); | |||
200 | for (const auto &E : ThunkNames) { | |||
201 | io.enumCase(FC, E.Name.str().c_str(), | |||
202 | static_cast<FrameCookieKind>(E.Value)); | |||
203 | } | |||
204 | } | |||
205 | ||||
206 | namespace llvm { | |||
207 | namespace yaml { | |||
208 | template <> struct MappingTraits<LocalVariableAddrRange> { | |||
209 | static void mapping(IO &io, LocalVariableAddrRange &Range) { | |||
210 | io.mapRequired("OffsetStart", Range.OffsetStart); | |||
211 | io.mapRequired("ISectStart", Range.ISectStart); | |||
212 | io.mapRequired("Range", Range.Range); | |||
213 | } | |||
214 | }; | |||
215 | template <> struct MappingTraits<LocalVariableAddrGap> { | |||
216 | static void mapping(IO &io, LocalVariableAddrGap &Gap) { | |||
217 | io.mapRequired("GapStartOffset", Gap.GapStartOffset); | |||
218 | io.mapRequired("Range", Gap.Range); | |||
219 | } | |||
220 | }; | |||
221 | } // namespace yaml | |||
222 | } // namespace llvm | |||
223 | ||||
224 | namespace llvm { | |||
225 | namespace CodeViewYAML { | |||
226 | namespace detail { | |||
227 | ||||
228 | struct SymbolRecordBase { | |||
229 | codeview::SymbolKind Kind; | |||
230 | ||||
231 | explicit SymbolRecordBase(codeview::SymbolKind K) : Kind(K) {} | |||
232 | virtual ~SymbolRecordBase() = default; | |||
233 | ||||
234 | virtual void map(yaml::IO &io) = 0; | |||
235 | virtual codeview::CVSymbol | |||
236 | toCodeViewSymbol(BumpPtrAllocator &Allocator, | |||
237 | CodeViewContainer Container) const = 0; | |||
238 | virtual Error fromCodeViewSymbol(codeview::CVSymbol Type) = 0; | |||
239 | }; | |||
240 | ||||
241 | template <typename T> struct SymbolRecordImpl : public SymbolRecordBase { | |||
242 | explicit SymbolRecordImpl(codeview::SymbolKind K) | |||
243 | : SymbolRecordBase(K), Symbol(static_cast<SymbolRecordKind>(K)) {} | |||
244 | ||||
245 | void map(yaml::IO &io) override; | |||
246 | ||||
247 | codeview::CVSymbol | |||
248 | toCodeViewSymbol(BumpPtrAllocator &Allocator, | |||
249 | CodeViewContainer Container) const override { | |||
250 | return SymbolSerializer::writeOneSymbol(Symbol, Allocator, Container); | |||
251 | } | |||
252 | ||||
253 | Error fromCodeViewSymbol(codeview::CVSymbol CVS) override { | |||
254 | return SymbolDeserializer::deserializeAs<T>(CVS, Symbol); | |||
255 | } | |||
256 | ||||
257 | mutable T Symbol; | |||
258 | }; | |||
259 | ||||
260 | struct UnknownSymbolRecord : public SymbolRecordBase { | |||
261 | explicit UnknownSymbolRecord(codeview::SymbolKind K) : SymbolRecordBase(K) {} | |||
262 | ||||
263 | void map(yaml::IO &io) override; | |||
264 | ||||
265 | CVSymbol toCodeViewSymbol(BumpPtrAllocator &Allocator, | |||
266 | CodeViewContainer Container) const override { | |||
267 | RecordPrefix Prefix; | |||
268 | uint32_t TotalLen = sizeof(RecordPrefix) + Data.size(); | |||
269 | Prefix.RecordKind = Kind; | |||
270 | Prefix.RecordLen = TotalLen - 2; | |||
271 | uint8_t *Buffer = Allocator.Allocate<uint8_t>(TotalLen); | |||
272 | ::memcpy(Buffer, &Prefix, sizeof(RecordPrefix)); | |||
273 | ::memcpy(Buffer + sizeof(RecordPrefix), Data.data(), Data.size()); | |||
274 | return CVSymbol(ArrayRef<uint8_t>(Buffer, TotalLen)); | |||
275 | } | |||
276 | ||||
277 | Error fromCodeViewSymbol(CVSymbol CVS) override { | |||
278 | this->Kind = CVS.kind(); | |||
279 | Data = CVS.RecordData.drop_front(sizeof(RecordPrefix)); | |||
280 | return Error::success(); | |||
281 | } | |||
282 | ||||
283 | std::vector<uint8_t> Data; | |||
284 | }; | |||
285 | ||||
286 | template <> void SymbolRecordImpl<ScopeEndSym>::map(IO &IO) {} | |||
287 | ||||
288 | void UnknownSymbolRecord::map(yaml::IO &io) { | |||
289 | yaml::BinaryRef Binary; | |||
290 | if (io.outputting()) | |||
291 | Binary = yaml::BinaryRef(Data); | |||
292 | io.mapRequired("Data", Binary); | |||
293 | if (!io.outputting()) { | |||
294 | std::string Str; | |||
295 | raw_string_ostream OS(Str); | |||
296 | Binary.writeAsBinary(OS); | |||
297 | OS.flush(); | |||
298 | Data.assign(Str.begin(), Str.end()); | |||
299 | } | |||
300 | } | |||
301 | ||||
302 | template <> void SymbolRecordImpl<Thunk32Sym>::map(IO &IO) { | |||
303 | IO.mapRequired("Parent", Symbol.Parent); | |||
304 | IO.mapRequired("End", Symbol.End); | |||
305 | IO.mapRequired("Next", Symbol.Next); | |||
306 | IO.mapRequired("Off", Symbol.Offset); | |||
307 | IO.mapRequired("Seg", Symbol.Segment); | |||
308 | IO.mapRequired("Len", Symbol.Length); | |||
309 | IO.mapRequired("Ordinal", Symbol.Thunk); | |||
310 | } | |||
311 | ||||
312 | template <> void SymbolRecordImpl<TrampolineSym>::map(IO &IO) { | |||
313 | IO.mapRequired("Type", Symbol.Type); | |||
314 | IO.mapRequired("Size", Symbol.Size); | |||
315 | IO.mapRequired("ThunkOff", Symbol.ThunkOffset); | |||
316 | IO.mapRequired("TargetOff", Symbol.TargetOffset); | |||
317 | IO.mapRequired("ThunkSection", Symbol.ThunkSection); | |||
318 | IO.mapRequired("TargetSection", Symbol.TargetSection); | |||
319 | } | |||
320 | ||||
321 | template <> void SymbolRecordImpl<SectionSym>::map(IO &IO) { | |||
322 | IO.mapRequired("SectionNumber", Symbol.SectionNumber); | |||
323 | IO.mapRequired("Alignment", Symbol.Alignment); | |||
324 | IO.mapRequired("Rva", Symbol.Rva); | |||
325 | IO.mapRequired("Length", Symbol.Length); | |||
326 | IO.mapRequired("Characteristics", Symbol.Characteristics); | |||
327 | IO.mapRequired("Name", Symbol.Name); | |||
328 | } | |||
329 | ||||
330 | template <> void SymbolRecordImpl<CoffGroupSym>::map(IO &IO) { | |||
331 | IO.mapRequired("Size", Symbol.Size); | |||
332 | IO.mapRequired("Characteristics", Symbol.Characteristics); | |||
333 | IO.mapRequired("Offset", Symbol.Offset); | |||
334 | IO.mapRequired("Segment", Symbol.Segment); | |||
335 | IO.mapRequired("Name", Symbol.Name); | |||
336 | } | |||
337 | ||||
338 | template <> void SymbolRecordImpl<ExportSym>::map(IO &IO) { | |||
339 | IO.mapRequired("Ordinal", Symbol.Ordinal); | |||
340 | IO.mapRequired("Flags", Symbol.Flags); | |||
341 | IO.mapRequired("Name", Symbol.Name); | |||
342 | } | |||
343 | ||||
344 | template <> void SymbolRecordImpl<ProcSym>::map(IO &IO) { | |||
345 | IO.mapOptional("PtrParent", Symbol.Parent, 0U); | |||
346 | IO.mapOptional("PtrEnd", Symbol.End, 0U); | |||
347 | IO.mapOptional("PtrNext", Symbol.Next, 0U); | |||
348 | IO.mapRequired("CodeSize", Symbol.CodeSize); | |||
349 | IO.mapRequired("DbgStart", Symbol.DbgStart); | |||
350 | IO.mapRequired("DbgEnd", Symbol.DbgEnd); | |||
351 | IO.mapRequired("FunctionType", Symbol.FunctionType); | |||
352 | IO.mapOptional("Offset", Symbol.CodeOffset, 0U); | |||
353 | IO.mapOptional("Segment", Symbol.Segment, uint16_t(0)); | |||
354 | IO.mapRequired("Flags", Symbol.Flags); | |||
355 | IO.mapRequired("DisplayName", Symbol.Name); | |||
356 | } | |||
357 | ||||
358 | template <> void SymbolRecordImpl<RegisterSym>::map(IO &IO) { | |||
359 | IO.mapRequired("Type", Symbol.Index); | |||
360 | IO.mapRequired("Seg", Symbol.Register); | |||
361 | IO.mapRequired("Name", Symbol.Name); | |||
362 | } | |||
363 | ||||
364 | template <> void SymbolRecordImpl<PublicSym32>::map(IO &IO) { | |||
365 | IO.mapRequired("Flags", Symbol.Flags); | |||
366 | IO.mapOptional("Offset", Symbol.Offset, 0U); | |||
367 | IO.mapOptional("Segment", Symbol.Segment, uint16_t(0)); | |||
368 | IO.mapRequired("Name", Symbol.Name); | |||
369 | } | |||
370 | ||||
371 | template <> void SymbolRecordImpl<ProcRefSym>::map(IO &IO) { | |||
372 | IO.mapRequired("SumName", Symbol.SumName); | |||
373 | IO.mapRequired("SymOffset", Symbol.SymOffset); | |||
374 | IO.mapRequired("Mod", Symbol.Module); | |||
375 | IO.mapRequired("Name", Symbol.Name); | |||
376 | } | |||
377 | ||||
378 | template <> void SymbolRecordImpl<EnvBlockSym>::map(IO &IO) { | |||
379 | IO.mapRequired("Entries", Symbol.Fields); | |||
380 | } | |||
381 | ||||
382 | template <> void SymbolRecordImpl<InlineSiteSym>::map(IO &IO) { | |||
383 | IO.mapOptional("PtrParent", Symbol.Parent, 0U); | |||
384 | IO.mapOptional("PtrEnd", Symbol.End, 0U); | |||
385 | IO.mapRequired("Inlinee", Symbol.Inlinee); | |||
386 | // TODO: The binary annotations | |||
387 | } | |||
388 | ||||
389 | template <> void SymbolRecordImpl<LocalSym>::map(IO &IO) { | |||
390 | IO.mapRequired("Type", Symbol.Type); | |||
391 | IO.mapRequired("Flags", Symbol.Flags); | |||
392 | ||||
393 | IO.mapRequired("VarName", Symbol.Name); | |||
394 | } | |||
395 | ||||
396 | template <> void SymbolRecordImpl<DefRangeSym>::map(IO &IO) { | |||
397 | IO.mapRequired("Program", Symbol.Program); | |||
398 | IO.mapRequired("Range", Symbol.Range); | |||
399 | IO.mapRequired("Gaps", Symbol.Gaps); | |||
400 | } | |||
401 | ||||
402 | template <> void SymbolRecordImpl<DefRangeSubfieldSym>::map(IO &IO) { | |||
403 | IO.mapRequired("Program", Symbol.Program); | |||
404 | IO.mapRequired("OffsetInParent", Symbol.OffsetInParent); | |||
405 | IO.mapRequired("Range", Symbol.Range); | |||
406 | IO.mapRequired("Gaps", Symbol.Gaps); | |||
407 | } | |||
408 | ||||
409 | template <> void SymbolRecordImpl<DefRangeRegisterSym>::map(IO &IO) { | |||
410 | IO.mapRequired("Register", Symbol.Hdr.Register); | |||
411 | IO.mapRequired("MayHaveNoName", Symbol.Hdr.MayHaveNoName); | |||
412 | IO.mapRequired("Range", Symbol.Range); | |||
413 | IO.mapRequired("Gaps", Symbol.Gaps); | |||
414 | } | |||
415 | ||||
416 | template <> void SymbolRecordImpl<DefRangeFramePointerRelSym>::map(IO &IO) { | |||
417 | IO.mapRequired("Offset", Symbol.Hdr.Offset); | |||
418 | IO.mapRequired("Range", Symbol.Range); | |||
419 | IO.mapRequired("Gaps", Symbol.Gaps); | |||
420 | } | |||
421 | ||||
422 | template <> void SymbolRecordImpl<DefRangeSubfieldRegisterSym>::map(IO &IO) { | |||
423 | IO.mapRequired("Register", Symbol.Hdr.Register); | |||
424 | IO.mapRequired("MayHaveNoName", Symbol.Hdr.MayHaveNoName); | |||
425 | IO.mapRequired("OffsetInParent", Symbol.Hdr.OffsetInParent); | |||
426 | IO.mapRequired("Range", Symbol.Range); | |||
427 | IO.mapRequired("Gaps", Symbol.Gaps); | |||
428 | } | |||
429 | ||||
430 | template <> | |||
431 | void SymbolRecordImpl<DefRangeFramePointerRelFullScopeSym>::map(IO &IO) { | |||
432 | IO.mapRequired("Register", Symbol.Offset); | |||
433 | } | |||
434 | ||||
435 | template <> void SymbolRecordImpl<DefRangeRegisterRelSym>::map(IO &IO) { | |||
436 | IO.mapRequired("Register", Symbol.Hdr.Register); | |||
437 | IO.mapRequired("Flags", Symbol.Hdr.Flags); | |||
438 | IO.mapRequired("BasePointerOffset", Symbol.Hdr.BasePointerOffset); | |||
439 | IO.mapRequired("Range", Symbol.Range); | |||
440 | IO.mapRequired("Gaps", Symbol.Gaps); | |||
441 | } | |||
442 | ||||
443 | template <> void SymbolRecordImpl<BlockSym>::map(IO &IO) { | |||
444 | IO.mapOptional("PtrParent", Symbol.Parent, 0U); | |||
445 | IO.mapOptional("PtrEnd", Symbol.End, 0U); | |||
446 | IO.mapRequired("CodeSize", Symbol.CodeSize); | |||
447 | IO.mapOptional("Offset", Symbol.CodeOffset, 0U); | |||
448 | IO.mapOptional("Segment", Symbol.Segment, uint16_t(0)); | |||
449 | IO.mapRequired("BlockName", Symbol.Name); | |||
450 | } | |||
451 | ||||
452 | template <> void SymbolRecordImpl<LabelSym>::map(IO &IO) { | |||
453 | IO.mapOptional("Offset", Symbol.CodeOffset, 0U); | |||
454 | IO.mapOptional("Segment", Symbol.Segment, uint16_t(0)); | |||
455 | IO.mapRequired("Flags", Symbol.Flags); | |||
456 | IO.mapRequired("Flags", Symbol.Flags); | |||
457 | IO.mapRequired("DisplayName", Symbol.Name); | |||
458 | } | |||
459 | ||||
460 | template <> void SymbolRecordImpl<ObjNameSym>::map(IO &IO) { | |||
461 | IO.mapRequired("Signature", Symbol.Signature); | |||
462 | IO.mapRequired("ObjectName", Symbol.Name); | |||
463 | } | |||
464 | ||||
465 | template <> void SymbolRecordImpl<Compile2Sym>::map(IO &IO) { | |||
466 | IO.mapRequired("Flags", Symbol.Flags); | |||
467 | IO.mapRequired("Machine", Symbol.Machine); | |||
468 | IO.mapRequired("FrontendMajor", Symbol.VersionFrontendMajor); | |||
469 | IO.mapRequired("FrontendMinor", Symbol.VersionFrontendMinor); | |||
470 | IO.mapRequired("FrontendBuild", Symbol.VersionFrontendBuild); | |||
471 | IO.mapRequired("BackendMajor", Symbol.VersionBackendMajor); | |||
472 | IO.mapRequired("BackendMinor", Symbol.VersionBackendMinor); | |||
473 | IO.mapRequired("BackendBuild", Symbol.VersionBackendBuild); | |||
474 | IO.mapRequired("Version", Symbol.Version); | |||
475 | } | |||
476 | ||||
477 | template <> void SymbolRecordImpl<Compile3Sym>::map(IO &IO) { | |||
478 | IO.mapRequired("Flags", Symbol.Flags); | |||
479 | IO.mapRequired("Machine", Symbol.Machine); | |||
480 | IO.mapRequired("FrontendMajor", Symbol.VersionFrontendMajor); | |||
481 | IO.mapRequired("FrontendMinor", Symbol.VersionFrontendMinor); | |||
482 | IO.mapRequired("FrontendBuild", Symbol.VersionFrontendBuild); | |||
483 | IO.mapRequired("FrontendQFE", Symbol.VersionFrontendQFE); | |||
484 | IO.mapRequired("BackendMajor", Symbol.VersionBackendMajor); | |||
485 | IO.mapRequired("BackendMinor", Symbol.VersionBackendMinor); | |||
486 | IO.mapRequired("BackendBuild", Symbol.VersionBackendBuild); | |||
487 | IO.mapRequired("BackendQFE", Symbol.VersionBackendQFE); | |||
488 | IO.mapRequired("Version", Symbol.Version); | |||
489 | } | |||
490 | ||||
491 | template <> void SymbolRecordImpl<FrameProcSym>::map(IO &IO) { | |||
492 | IO.mapRequired("TotalFrameBytes", Symbol.TotalFrameBytes); | |||
493 | IO.mapRequired("PaddingFrameBytes", Symbol.PaddingFrameBytes); | |||
494 | IO.mapRequired("OffsetToPadding", Symbol.OffsetToPadding); | |||
495 | IO.mapRequired("BytesOfCalleeSavedRegisters", | |||
496 | Symbol.BytesOfCalleeSavedRegisters); | |||
497 | IO.mapRequired("OffsetOfExceptionHandler", Symbol.OffsetOfExceptionHandler); | |||
498 | IO.mapRequired("SectionIdOfExceptionHandler", | |||
499 | Symbol.SectionIdOfExceptionHandler); | |||
500 | IO.mapRequired("Flags", Symbol.Flags); | |||
501 | } | |||
502 | ||||
503 | template <> void SymbolRecordImpl<CallSiteInfoSym>::map(IO &IO) { | |||
504 | IO.mapOptional("Offset", Symbol.CodeOffset, 0U); | |||
505 | IO.mapOptional("Segment", Symbol.Segment, uint16_t(0)); | |||
506 | IO.mapRequired("Type", Symbol.Type); | |||
507 | } | |||
508 | ||||
509 | template <> void SymbolRecordImpl<FileStaticSym>::map(IO &IO) { | |||
510 | IO.mapRequired("Index", Symbol.Index); | |||
511 | IO.mapRequired("ModFilenameOffset", Symbol.ModFilenameOffset); | |||
512 | IO.mapRequired("Flags", Symbol.Flags); | |||
513 | IO.mapRequired("Name", Symbol.Name); | |||
514 | } | |||
515 | ||||
516 | template <> void SymbolRecordImpl<HeapAllocationSiteSym>::map(IO &IO) { | |||
517 | IO.mapOptional("Offset", Symbol.CodeOffset, 0U); | |||
518 | IO.mapOptional("Segment", Symbol.Segment, uint16_t(0)); | |||
519 | IO.mapRequired("CallInstructionSize", Symbol.CallInstructionSize); | |||
520 | IO.mapRequired("Type", Symbol.Type); | |||
521 | } | |||
522 | ||||
523 | template <> void SymbolRecordImpl<FrameCookieSym>::map(IO &IO) { | |||
524 | IO.mapRequired("Register", Symbol.Register); | |||
525 | IO.mapRequired("CookieKind", Symbol.CookieKind); | |||
526 | IO.mapRequired("Flags", Symbol.Flags); | |||
527 | } | |||
528 | ||||
529 | template <> void SymbolRecordImpl<CallerSym>::map(IO &IO) { | |||
530 | IO.mapRequired("FuncID", Symbol.Indices); | |||
531 | } | |||
532 | ||||
533 | template <> void SymbolRecordImpl<UDTSym>::map(IO &IO) { | |||
534 | IO.mapRequired("Type", Symbol.Type); | |||
535 | IO.mapRequired("UDTName", Symbol.Name); | |||
536 | } | |||
537 | ||||
538 | template <> void SymbolRecordImpl<BuildInfoSym>::map(IO &IO) { | |||
539 | IO.mapRequired("BuildId", Symbol.BuildId); | |||
540 | } | |||
541 | ||||
542 | template <> void SymbolRecordImpl<BPRelativeSym>::map(IO &IO) { | |||
543 | IO.mapRequired("Offset", Symbol.Offset); | |||
544 | IO.mapRequired("Type", Symbol.Type); | |||
545 | IO.mapRequired("VarName", Symbol.Name); | |||
546 | } | |||
547 | ||||
548 | template <> void SymbolRecordImpl<RegRelativeSym>::map(IO &IO) { | |||
549 | IO.mapRequired("Offset", Symbol.Offset); | |||
550 | IO.mapRequired("Type", Symbol.Type); | |||
551 | IO.mapRequired("Register", Symbol.Register); | |||
552 | IO.mapRequired("VarName", Symbol.Name); | |||
553 | } | |||
554 | ||||
555 | template <> void SymbolRecordImpl<ConstantSym>::map(IO &IO) { | |||
556 | IO.mapRequired("Type", Symbol.Type); | |||
557 | IO.mapRequired("Value", Symbol.Value); | |||
558 | IO.mapRequired("Name", Symbol.Name); | |||
559 | } | |||
560 | ||||
561 | template <> void SymbolRecordImpl<DataSym>::map(IO &IO) { | |||
562 | IO.mapRequired("Type", Symbol.Type); | |||
563 | IO.mapOptional("Offset", Symbol.DataOffset, 0U); | |||
564 | IO.mapOptional("Segment", Symbol.Segment, uint16_t(0)); | |||
565 | IO.mapRequired("DisplayName", Symbol.Name); | |||
566 | } | |||
567 | ||||
568 | template <> void SymbolRecordImpl<ThreadLocalDataSym>::map(IO &IO) { | |||
569 | IO.mapRequired("Type", Symbol.Type); | |||
570 | IO.mapOptional("Offset", Symbol.DataOffset, 0U); | |||
571 | IO.mapOptional("Segment", Symbol.Segment, uint16_t(0)); | |||
572 | IO.mapRequired("DisplayName", Symbol.Name); | |||
573 | } | |||
574 | ||||
575 | template <> void SymbolRecordImpl<UsingNamespaceSym>::map(IO &IO) { | |||
576 | IO.mapRequired("Namespace", Symbol.Name); | |||
577 | } | |||
578 | ||||
579 | template <> void SymbolRecordImpl<AnnotationSym>::map(IO &IO) { | |||
580 | IO.mapOptional("Offset", Symbol.CodeOffset, 0U); | |||
581 | IO.mapOptional("Segment", Symbol.Segment, uint16_t(0)); | |||
582 | IO.mapRequired("Strings", Symbol.Strings); | |||
583 | } | |||
584 | ||||
585 | } // end namespace detail | |||
586 | } // end namespace CodeViewYAML | |||
587 | } // end namespace llvm | |||
588 | ||||
589 | CVSymbol CodeViewYAML::SymbolRecord::toCodeViewSymbol( | |||
590 | BumpPtrAllocator &Allocator, CodeViewContainer Container) const { | |||
591 | return Symbol->toCodeViewSymbol(Allocator, Container); | |||
592 | } | |||
593 | ||||
594 | namespace llvm { | |||
595 | namespace yaml { | |||
596 | ||||
597 | template <> struct MappingTraits<SymbolRecordBase> { | |||
598 | static void mapping(IO &io, SymbolRecordBase &Record) { Record.map(io); } | |||
599 | }; | |||
600 | ||||
601 | } // end namespace yaml | |||
602 | } // end namespace llvm | |||
603 | ||||
604 | template <typename SymbolType> | |||
605 | static inline Expected<CodeViewYAML::SymbolRecord> | |||
606 | fromCodeViewSymbolImpl(CVSymbol Symbol) { | |||
607 | CodeViewYAML::SymbolRecord Result; | |||
608 | ||||
609 | auto Impl = std::make_shared<SymbolType>(Symbol.kind()); | |||
610 | if (auto EC = Impl->fromCodeViewSymbol(Symbol)) | |||
611 | return std::move(EC); | |||
612 | Result.Symbol = Impl; | |||
613 | return Result; | |||
614 | } | |||
615 | ||||
616 | Expected<CodeViewYAML::SymbolRecord> | |||
617 | CodeViewYAML::SymbolRecord::fromCodeViewSymbol(CVSymbol Symbol) { | |||
618 | #define SYMBOL_RECORD(EnumName, EnumVal, ClassName) \ | |||
619 | case EnumName: \ | |||
620 | return fromCodeViewSymbolImpl<SymbolRecordImpl<ClassName>>(Symbol); | |||
621 | #define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \ | |||
622 | SYMBOL_RECORD(EnumName, EnumVal, ClassName) | |||
623 | switch (Symbol.kind()) { | |||
624 | #include "llvm/DebugInfo/CodeView/CodeViewSymbols.def" | |||
625 | default: | |||
626 | return fromCodeViewSymbolImpl<UnknownSymbolRecord>(Symbol); | |||
627 | } | |||
628 | return make_error<CodeViewError>(cv_error_code::corrupt_record); | |||
629 | } | |||
630 | ||||
631 | template <typename ConcreteType> | |||
632 | static void mapSymbolRecordImpl(IO &IO, const char *Class, SymbolKind Kind, | |||
633 | CodeViewYAML::SymbolRecord &Obj) { | |||
634 | if (!IO.outputting()) | |||
635 | Obj.Symbol = std::make_shared<ConcreteType>(Kind); | |||
636 | ||||
637 | IO.mapRequired(Class, *Obj.Symbol); | |||
638 | } | |||
639 | ||||
640 | void MappingTraits<CodeViewYAML::SymbolRecord>::mapping( | |||
641 | IO &IO, CodeViewYAML::SymbolRecord &Obj) { | |||
642 | SymbolKind Kind; | |||
| ||||
643 | if (IO.outputting()) | |||
644 | Kind = Obj.Symbol->Kind; | |||
645 | IO.mapRequired("Kind", Kind); | |||
646 | ||||
647 | #define SYMBOL_RECORD(EnumName, EnumVal, ClassName) \ | |||
648 | case EnumName: \ | |||
649 | mapSymbolRecordImpl<SymbolRecordImpl<ClassName>>(IO, #ClassName, Kind, \ | |||
650 | Obj); \ | |||
651 | break; | |||
652 | #define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \ | |||
653 | SYMBOL_RECORD(EnumName, EnumVal, ClassName) | |||
654 | switch (Kind) { | |||
655 | #include "llvm/DebugInfo/CodeView/CodeViewSymbols.def" | |||
656 | default: | |||
657 | mapSymbolRecordImpl<UnknownSymbolRecord>(IO, "UnknownSym", Kind, Obj); | |||
658 | } | |||
659 | } |
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 |