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