| File: | src/gnu/usr.bin/clang/liblldbAPI/../../../llvm/llvm/include/llvm/Support/YAMLTraits.h |
| Warning: | line 616, column 7 Value stored to 'State' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 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; |
Value stored to 'State' is never read | |
| 617 | S = S.drop_front(); |
| 618 | } else { |
| 619 | return false; |
| 620 | } |
| 621 | } |
| 622 | |
| 623 | assert(State == FoundExponent && "Should have found exponent at this point.")((void)0); |
| 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")((void)0); |
| 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 &&((void)0) |
| 1629 | "Optional<T> shouldn't have a value!")((void)0); |
| 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")((void)0); |
| 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 |