llvm/lib/Support/YAMLTraits.cpp

   1 //===- lib/Support/YAMLTraits.cpp -----------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/Support/YAMLTraits.h"
  10 #include "llvm/ADT/STLExtras.h"
  11 #include "llvm/ADT/SmallString.h"
  12 #include "llvm/ADT/StringExtras.h"
  13 #include "llvm/ADT/StringRef.h"
  14 #include "llvm/ADT/Twine.h"
  15 #include "llvm/Support/Casting.h"
  16 #include "llvm/Support/Errc.h"
  17 #include "llvm/Support/ErrorHandling.h"
  18 #include "llvm/Support/Format.h"
  19 #include "llvm/Support/LineIterator.h"
  20 #include "llvm/Support/MemoryBuffer.h"
  21 #include "llvm/Support/VersionTuple.h"
  22 #include "llvm/Support/YAMLParser.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 #include <cassert>
  25 #include <cstdint>
  26 #include <cstring>
  27 #include <string>
  28 #include <vector>
  29
  30 using namespace llvm;
  31 using namespace yaml;
  32
  33 //===----------------------------------------------------------------------===//
  34 //  IO
  35 //===----------------------------------------------------------------------===//
  36
  37 IO::IO(void *Context) : Ctxt(Context) {}
  38
  39 IO::~IO() = default;
  40
  41 void *IO::getContext() const {
  42   return Ctxt;
  43 }
  44
  45 void IO::setContext(void *Context) {
  46   Ctxt = Context;
  47 }
  48
  49 void IO::setAllowUnknownKeys(bool Allow) {
  50   llvm_unreachable("Only supported for Input");
  51 }
  52
  53 //===----------------------------------------------------------------------===//
  54 //  Input
  55 //===----------------------------------------------------------------------===//
  56
  57 Input::Input(StringRef InputContent, void *Ctxt,
  58              SourceMgr::DiagHandlerTy DiagHandler, void *DiagHandlerCtxt)
  59     : IO(Ctxt), Strm(new Stream(InputContent, SrcMgr, false, &EC)) {
  60   if (DiagHandler)
  61     SrcMgr.setDiagHandler(DiagHandler, DiagHandlerCtxt);
  62   DocIterator = Strm->begin();
  63 }
  64
  65 Input::Input(MemoryBufferRef Input, void *Ctxt,
  66              SourceMgr::DiagHandlerTy DiagHandler, void *DiagHandlerCtxt)
  67     : IO(Ctxt), Strm(new Stream(Input, SrcMgr, false, &EC)) {
  68   if (DiagHandler)
  69     SrcMgr.setDiagHandler(DiagHandler, DiagHandlerCtxt);
  70   DocIterator = Strm->begin();
  71 }
  72
  73 Input::~Input() = default;
  74
  75 std::error_code Input::error() { return EC; }
  76
  77 bool Input::outputting() const {
  78   return false;
  79 }
  80
  81 bool Input::setCurrentDocument() {
  82   if (DocIterator != Strm->end()) {
  83     Node *N = DocIterator->getRoot();
  84     if (!N) {
  85       EC = make_error_code(errc::invalid_argument);
  86       return false;
  87     }
  88
  89     if (isa<NullNode>(N)) {
  90       // Empty files are allowed and ignored
  91       ++DocIterator;
  92       return setCurrentDocument();
  93     }
  94     releaseHNodeBuffers();
  95     TopNode = createHNodes(N);
  96     CurrentNode = TopNode;
  97     return true;
  98   }
  99   return false;
 100 }
 101
 102 bool Input::nextDocument() {
 103   return ++DocIterator != Strm->end();
 104 }
 105
 106 const Node *Input::getCurrentNode() const {
 107   return CurrentNode ? CurrentNode->_node : nullptr;
 108 }
 109
 110 bool Input::mapTag(StringRef Tag, bool Default) {
 111   // CurrentNode can be null if setCurrentDocument() was unable to
 112   // parse the document because it was invalid or empty.
 113   if (!CurrentNode)
 114     return false;
 115
 116   std::string foundTag = CurrentNode->_node->getVerbatimTag();
 117   if (foundTag.empty()) {
 118     // If no tag found and 'Tag' is the default, say it was found.
 119     return Default;
 120   }
 121   // Return true iff found tag matches supplied tag.
 122   return Tag == foundTag;
 123 }
 124
 125 void Input::beginMapping() {
 126   if (EC)
 127     return;
 128   // CurrentNode can be null if the document is empty.
 129   MapHNode *MN = dyn_cast_or_null<MapHNode>(CurrentNode);
 130   if (MN) {
 131     MN->ValidKeys.clear();
 132   }
 133 }
 134
 135 std::vector<StringRef> Input::keys() {
 136   MapHNode *MN = dyn_cast<MapHNode>(CurrentNode);
 137   std::vector<StringRef> Ret;
 138   if (!MN) {
 139     setError(CurrentNode, "not a mapping");
 140     return Ret;
 141   }
 142   for (auto &P : MN->Mapping)
 143     Ret.push_back(P.first());
 144   return Ret;
 145 }
 146
 147 bool Input::preflightKey(const char *Key, bool Required, bool, bool &UseDefault,
 148                          void *&SaveInfo) {
 149   UseDefault = false;
 150   if (EC)
 151     return false;
 152
 153   // CurrentNode is null for empty documents, which is an error in case required
 154   // nodes are present.
 155   if (!CurrentNode) {
 156     if (Required)
 157       EC = make_error_code(errc::invalid_argument);
 158     else
 159       UseDefault = true;
 160     return false;
 161   }
 162
 163   MapHNode *MN = dyn_cast<MapHNode>(CurrentNode);
 164   if (!MN) {
 165     if (Required || !isa<EmptyHNode>(CurrentNode))
 166       setError(CurrentNode, "not a mapping");
 167     else
 168       UseDefault = true;
 169     return false;
 170   }
 171   MN->ValidKeys.push_back(Key);
 172   HNode *Value = MN->Mapping[Key].first;
 173   if (!Value) {
 174     if (Required)
 175       setError(CurrentNode, Twine("missing required key '") + Key + "'");
 176     else
 177       UseDefault = true;
 178     return false;
 179   }
 180   SaveInfo = CurrentNode;
 181   CurrentNode = Value;
 182   return true;
 183 }
 184
 185 void Input::postflightKey(void *saveInfo) {
 186   CurrentNode = reinterpret_cast<HNode *>(saveInfo);
 187 }
 188
 189 void Input::endMapping() {
 190   if (EC)
 191     return;
 192   // CurrentNode can be null if the document is empty.
 193   MapHNode *MN = dyn_cast_or_null<MapHNode>(CurrentNode);
 194   if (!MN)
 195     return;
 196   for (const auto &NN : MN->Mapping) {
 197     if (!is_contained(MN->ValidKeys, NN.first())) {
 198       const SMRange &ReportLoc = NN.second.second;
 199       if (!AllowUnknownKeys) {
 200         setError(ReportLoc, Twine("unknown key '") + NN.first() + "'");
 201         break;
 202       } else
 203         reportWarning(ReportLoc, Twine("unknown key '") + NN.first() + "'");
 204     }
 205   }
 206 }
 207
 208 void Input::beginFlowMapping() { beginMapping(); }
 209
 210 void Input::endFlowMapping() { endMapping(); }
 211
 212 unsigned Input::beginSequence() {
 213   if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode))
 214     return SQ->Entries.size();
 215   if (isa<EmptyHNode>(CurrentNode))
 216     return 0;
 217   // Treat case where there's a scalar "null" value as an empty sequence.
 218   if (ScalarHNode *SN = dyn_cast<ScalarHNode>(CurrentNode)) {
 219     if (isNull(SN->value()))
 220       return 0;
 221   }
 222   // Any other type of HNode is an error.
 223   setError(CurrentNode, "not a sequence");
 224   return 0;
 225 }
 226
 227 void Input::endSequence() {
 228 }
 229
 230 bool Input::preflightElement(unsigned Index, void *&SaveInfo) {
 231   if (EC)
 232     return false;
 233   if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) {
 234     SaveInfo = CurrentNode;
 235     CurrentNode = SQ->Entries[Index];
 236     return true;
 237   }
 238   return false;
 239 }
 240
 241 void Input::postflightElement(void *SaveInfo) {
 242   CurrentNode = reinterpret_cast<HNode *>(SaveInfo);
 243 }
 244
 245 unsigned Input::beginFlowSequence() { return beginSequence(); }
 246
 247 bool Input::preflightFlowElement(unsigned index, void *&SaveInfo) {
 248   if (EC)
 249     return false;
 250   if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) {
 251     SaveInfo = CurrentNode;
 252     CurrentNode = SQ->Entries[index];
 253     return true;
 254   }
 255   return false;
 256 }
 257
 258 void Input::postflightFlowElement(void *SaveInfo) {
 259   CurrentNode = reinterpret_cast<HNode *>(SaveInfo);
 260 }
 261
 262 void Input::endFlowSequence() {
 263 }
 264
 265 void Input::beginEnumScalar() {
 266   ScalarMatchFound = false;
 267 }
 268
 269 bool Input::matchEnumScalar(const char *Str, bool) {
 270   if (ScalarMatchFound)
 271     return false;
 272   if (ScalarHNode *SN = dyn_cast<ScalarHNode>(CurrentNode)) {
 273     if (SN->value() == Str) {
 274       ScalarMatchFound = true;
 275       return true;
 276     }
 277   }
 278   return false;
 279 }
 280
 281 bool Input::matchEnumFallback() {
 282   if (ScalarMatchFound)
 283     return false;
 284   ScalarMatchFound = true;
 285   return true;
 286 }
 287
 288 void Input::endEnumScalar() {
 289   if (!ScalarMatchFound) {
 290     setError(CurrentNode, "unknown enumerated scalar");
 291   }
 292 }
 293
 294 bool Input::beginBitSetScalar(bool &DoClear) {
 295   BitValuesUsed.clear();
 296   if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) {
 297     BitValuesUsed.resize(SQ->Entries.size());
 298   } else {
 299     setError(CurrentNode, "expected sequence of bit values");
 300   }
 301   DoClear = true;
 302   return true;
 303 }
 304
 305 bool Input::bitSetMatch(const char *Str, bool) {
 306   if (EC)
 307     return false;
 308   if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) {
 309     unsigned Index = 0;
 310     for (auto &N : SQ->Entries) {
 311       if (ScalarHNode *SN = dyn_cast<ScalarHNode>(N)) {
 312         if (SN->value() == Str) {
 313           BitValuesUsed[Index] = true;
 314           return true;
 315         }
 316       } else {
 317         setError(CurrentNode, "unexpected scalar in sequence of bit values");
 318       }
 319       ++Index;
 320     }
 321   } else {
 322     setError(CurrentNode, "expected sequence of bit values");
 323   }
 324   return false;
 325 }
 326
 327 void Input::endBitSetScalar() {
 328   if (EC)
 329     return;
 330   if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) {
 331     assert(BitValuesUsed.size() == SQ->Entries.size());
 332     for (unsigned i = 0; i < SQ->Entries.size(); ++i) {
 333       if (!BitValuesUsed[i]) {
 334         setError(SQ->Entries[i], "unknown bit value");
 335         return;
 336       }
 337     }
 338   }
 339 }
 340
 341 void Input::scalarString(StringRef &S, QuotingType) {
 342   if (ScalarHNode *SN = dyn_cast<ScalarHNode>(CurrentNode)) {
 343     S = SN->value();
 344   } else {
 345     setError(CurrentNode, "unexpected scalar");
 346   }
 347 }
 348
 349 void Input::blockScalarString(StringRef &S) { scalarString(S, QuotingType::None); }
 350
 351 void Input::scalarTag(std::string &Tag) {
 352   Tag = CurrentNode->_node->getVerbatimTag();
 353 }
 354
 355 void Input::setError(HNode *hnode, const Twine &message) {
 356   assert(hnode && "HNode must not be NULL");
 357   setError(hnode->_node, message);
 358 }
 359
 360 NodeKind Input::getNodeKind() {
 361   if (isa<ScalarHNode>(CurrentNode))
 362     return NodeKind::Scalar;
 363   else if (isa<MapHNode>(CurrentNode))
 364     return NodeKind::Map;
 365   else if (isa<SequenceHNode>(CurrentNode))
 366     return NodeKind::Sequence;
 367   llvm_unreachable("Unsupported node kind");
 368 }
 369
 370 void Input::setError(Node *node, const Twine &message) {
 371   Strm->printError(node, message);
 372   EC = make_error_code(errc::invalid_argument);
 373 }
 374
 375 void Input::setError(const SMRange &range, const Twine &message) {
 376   Strm->printError(range, message);
 377   EC = make_error_code(errc::invalid_argument);
 378 }
 379
 380 void Input::reportWarning(HNode *hnode, const Twine &message) {
 381   assert(hnode && "HNode must not be NULL");
 382   Strm->printError(hnode->_node, message, SourceMgr::DK_Warning);
 383 }
 384
 385 void Input::reportWarning(Node *node, const Twine &message) {
 386   Strm->printError(node, message, SourceMgr::DK_Warning);
 387 }
 388
 389 void Input::reportWarning(const SMRange &range, const Twine &message) {
 390   Strm->printError(range, message, SourceMgr::DK_Warning);
 391 }
 392
 393 void Input::releaseHNodeBuffers() {
 394   EmptyHNodeAllocator.DestroyAll();
 395   ScalarHNodeAllocator.DestroyAll();
 396   SequenceHNodeAllocator.DestroyAll();
 397   MapHNodeAllocator.DestroyAll();
 398 }
 399
 400 Input::HNode *Input::createHNodes(Node *N) {
 401   SmallString<128> StringStorage;
 402   switch (N->getType()) {
 403   case Node::NK_Scalar: {
 404     ScalarNode *SN = dyn_cast<ScalarNode>(N);
 405     StringRef KeyStr = SN->getValue(StringStorage);
 406     if (!StringStorage.empty()) {
 407       // Copy string to permanent storage
 408       KeyStr = StringStorage.str().copy(StringAllocator);
 409     }
 410     return new (ScalarHNodeAllocator.Allocate()) ScalarHNode(N, KeyStr);
 411   }
 412   case Node::NK_BlockScalar: {
 413     BlockScalarNode *BSN = dyn_cast<BlockScalarNode>(N);
 414     StringRef ValueCopy = BSN->getValue().copy(StringAllocator);
 415     return new (ScalarHNodeAllocator.Allocate()) ScalarHNode(N, ValueCopy);
 416   }
 417   case Node::NK_Sequence: {
 418     SequenceNode *SQ = dyn_cast<SequenceNode>(N);
 419     auto SQHNode = new (SequenceHNodeAllocator.Allocate()) SequenceHNode(N);
 420     for (Node &SN : *SQ) {
 421       auto Entry = createHNodes(&SN);
 422       if (EC)
 423         break;
 424       SQHNode->Entries.push_back(Entry);
 425     }
 426     return SQHNode;
 427   }
 428   case Node::NK_Mapping: {
 429     MappingNode *Map = dyn_cast<MappingNode>(N);
 430     auto mapHNode = new (MapHNodeAllocator.Allocate()) MapHNode(N);
 431     for (KeyValueNode &KVN : *Map) {
 432       Node *KeyNode = KVN.getKey();
 433       ScalarNode *Key = dyn_cast_or_null<ScalarNode>(KeyNode);
 434       Node *Value = KVN.getValue();
 435       if (!Key || !Value) {
 436         if (!Key)
 437           setError(KeyNode, "Map key must be a scalar");
 438         if (!Value)
 439           setError(KeyNode, "Map value must not be empty");
 440         break;
 441       }
 442       StringStorage.clear();
 443       StringRef KeyStr = Key->getValue(StringStorage);
 444       if (!StringStorage.empty()) {
 445         // Copy string to permanent storage
 446         KeyStr = StringStorage.str().copy(StringAllocator);
 447       }
 448       if (mapHNode->Mapping.count(KeyStr))
 449         // From YAML spec: "The content of a mapping node is an unordered set of
 450         // key/value node pairs, with the restriction that each of the keys is
 451         // unique."
 452         setError(KeyNode, Twine("duplicated mapping key '") + KeyStr + "'");
 453       auto ValueHNode = createHNodes(Value);
 454       if (EC)
 455         break;
 456       mapHNode->Mapping[KeyStr] =
 457           std::make_pair(std::move(ValueHNode), KeyNode->getSourceRange());
 458     }
 459     return std::move(mapHNode);
 460   }
 461   case Node::NK_Null:
 462     return new (EmptyHNodeAllocator.Allocate()) EmptyHNode(N);
 463   default:
 464     setError(N, "unknown node kind");
 465     return nullptr;
 466   }
 467 }
 468
 469 void Input::setError(const Twine &Message) {
 470   setError(CurrentNode, Message);
 471 }
 472
 473 void Input::setAllowUnknownKeys(bool Allow) { AllowUnknownKeys = Allow; }
 474
 475 bool Input::canElideEmptySequence() {
 476   return false;
 477 }
 478
 479 //===----------------------------------------------------------------------===//
 480 //  Output
 481 //===----------------------------------------------------------------------===//
 482
 483 Output::Output(raw_ostream &yout, void *context, int WrapColumn)
 484     : IO(context), Out(yout), WrapColumn(WrapColumn) {}
 485
 486 Output::~Output() = default;
 487
 488 bool Output::outputting() const {
 489   return true;
 490 }
 491
 492 void Output::beginMapping() {
 493   StateStack.push_back(inMapFirstKey);
 494   PaddingBeforeContainer = Padding;
 495   Padding = "\n";
 496 }
 497
 498 bool Output::mapTag(StringRef Tag, bool Use) {
 499   if (Use) {
 500     // If this tag is being written inside a sequence we should write the start
 501     // of the sequence before writing the tag, otherwise the tag won't be
 502     // attached to the element in the sequence, but rather the sequence itself.
 503     bool SequenceElement = false;
 504     if (StateStack.size() > 1) {
 505       auto &E = StateStack[StateStack.size() - 2];
 506       SequenceElement = inSeqAnyElement(E) || inFlowSeqAnyElement(E);
 507     }
 508     if (SequenceElement && StateStack.back() == inMapFirstKey) {
 509       newLineCheck();
 510     } else {
 511       output(" ");
 512     }
 513     output(Tag);
 514     if (SequenceElement) {
 515       // If we're writing the tag during the first element of a map, the tag
 516       // takes the place of the first element in the sequence.
 517       if (StateStack.back() == inMapFirstKey) {
 518         StateStack.pop_back();
 519         StateStack.push_back(inMapOtherKey);
 520       }
 521       // Tags inside maps in sequences should act as keys in the map from a
 522       // formatting perspective, so we always want a newline in a sequence.
 523       Padding = "\n";
 524     }
 525   }
 526   return Use;
 527 }
 528
 529 void Output::endMapping() {
 530   // If we did not map anything, we should explicitly emit an empty map
 531   if (StateStack.back() == inMapFirstKey) {
 532     Padding = PaddingBeforeContainer;
 533     newLineCheck();
 534     output("{}");
 535     Padding = "\n";
 536   }
 537   StateStack.pop_back();
 538 }
 539
 540 std::vector<StringRef> Output::keys() {
 541   report_fatal_error("invalid call");
 542 }
 543
 544 bool Output::preflightKey(const char *Key, bool Required, bool SameAsDefault,
 545                           bool &UseDefault, void *&SaveInfo) {
 546   UseDefault = false;
 547   SaveInfo = nullptr;
 548   if (Required || !SameAsDefault || WriteDefaultValues) {
 549     auto State = StateStack.back();
 550     if (State == inFlowMapFirstKey || State == inFlowMapOtherKey) {
 551       flowKey(Key);
 552     } else {
 553       newLineCheck();
 554       paddedKey(Key);
 555     }
 556     return true;
 557   }
 558   return false;
 559 }
 560
 561 void Output::postflightKey(void *) {
 562   if (StateStack.back() == inMapFirstKey) {
 563     StateStack.pop_back();
 564     StateStack.push_back(inMapOtherKey);
 565   } else if (StateStack.back() == inFlowMapFirstKey) {
 566     StateStack.pop_back();
 567     StateStack.push_back(inFlowMapOtherKey);
 568   }
 569 }
 570
 571 void Output::beginFlowMapping() {
 572   StateStack.push_back(inFlowMapFirstKey);
 573   newLineCheck();
 574   ColumnAtMapFlowStart = Column;
 575   output("{ ");
 576 }
 577
 578 void Output::endFlowMapping() {
 579   StateStack.pop_back();
 580   outputUpToEndOfLine(" }");
 581 }
 582
 583 void Output::beginDocuments() {
 584   outputUpToEndOfLine("---");
 585 }
 586
 587 bool Output::preflightDocument(unsigned index) {
 588   if (index > 0)
 589     outputUpToEndOfLine("\n---");
 590   return true;
 591 }
 592
 593 void Output::postflightDocument() {
 594 }
 595
 596 void Output::endDocuments() {
 597   output("\n...\n");
 598 }
 599
 600 unsigned Output::beginSequence() {
 601   StateStack.push_back(inSeqFirstElement);
 602   PaddingBeforeContainer = Padding;
 603   Padding = "\n";
 604   return 0;
 605 }
 606
 607 void Output::endSequence() {
 608   // If we did not emit anything, we should explicitly emit an empty sequence
 609   if (StateStack.back() == inSeqFirstElement) {
 610     Padding = PaddingBeforeContainer;
 611     newLineCheck(/*EmptySequence=*/true);
 612     output("[]");
 613     Padding = "\n";
 614   }
 615   StateStack.pop_back();
 616 }
 617
 618 bool Output::preflightElement(unsigned, void *&SaveInfo) {
 619   SaveInfo = nullptr;
 620   return true;
 621 }
 622
 623 void Output::postflightElement(void *) {
 624   if (StateStack.back() == inSeqFirstElement) {
 625     StateStack.pop_back();
 626     StateStack.push_back(inSeqOtherElement);
 627   } else if (StateStack.back() == inFlowSeqFirstElement) {
 628     StateStack.pop_back();
 629     StateStack.push_back(inFlowSeqOtherElement);
 630   }
 631 }
 632
 633 unsigned Output::beginFlowSequence() {
 634   StateStack.push_back(inFlowSeqFirstElement);
 635   newLineCheck();
 636   ColumnAtFlowStart = Column;
 637   output("[ ");
 638   NeedFlowSequenceComma = false;
 639   return 0;
 640 }
 641
 642 void Output::endFlowSequence() {
 643   StateStack.pop_back();
 644   outputUpToEndOfLine(" ]");
 645 }
 646
 647 bool Output::preflightFlowElement(unsigned, void *&SaveInfo) {
 648   if (NeedFlowSequenceComma)
 649     output(", ");
 650   if (WrapColumn && Column > WrapColumn) {
 651     output("\n");
 652     for (int i = 0; i < ColumnAtFlowStart; ++i)
 653       output(" ");
 654     Column = ColumnAtFlowStart;
 655     output("  ");
 656   }
 657   SaveInfo = nullptr;
 658   return true;
 659 }
 660
 661 void Output::postflightFlowElement(void *) {
 662   NeedFlowSequenceComma = true;
 663 }
 664
 665 void Output::beginEnumScalar() {
 666   EnumerationMatchFound = false;
 667 }
 668
 669 bool Output::matchEnumScalar(const char *Str, bool Match) {
 670   if (Match && !EnumerationMatchFound) {
 671     newLineCheck();
 672     outputUpToEndOfLine(Str);
 673     EnumerationMatchFound = true;
 674   }
 675   return false;
 676 }
 677
 678 bool Output::matchEnumFallback() {
 679   if (EnumerationMatchFound)
 680     return false;
 681   EnumerationMatchFound = true;
 682   return true;
 683 }
 684
 685 void Output::endEnumScalar() {
 686   if (!EnumerationMatchFound)
 687     llvm_unreachable("bad runtime enum value");
 688 }
 689
 690 bool Output::beginBitSetScalar(bool &DoClear) {
 691   newLineCheck();
 692   output("[ ");
 693   NeedBitValueComma = false;
 694   DoClear = false;
 695   return true;
 696 }
 697
 698 bool Output::bitSetMatch(const char *Str, bool Matches) {
 699   if (Matches) {
 700     if (NeedBitValueComma)
 701       output(", ");
 702     output(Str);
 703     NeedBitValueComma = true;
 704   }
 705   return false;
 706 }
 707
 708 void Output::endBitSetScalar() {
 709   outputUpToEndOfLine(" ]");
 710 }
 711
 712 void Output::scalarString(StringRef &S, QuotingType MustQuote) {
 713   newLineCheck();
 714   if (S.empty()) {
 715     // Print '' for the empty string because leaving the field empty is not
 716     // allowed.
 717     outputUpToEndOfLine("''");
 718     return;
 719   }
 720   output(S, MustQuote);
 721   outputUpToEndOfLine("");
 722 }
 723
 724 void Output::blockScalarString(StringRef &S) {
 725   if (!StateStack.empty())
 726     newLineCheck();
 727   output(" |");
 728   outputNewLine();
 729
 730   unsigned Indent = StateStack.empty() ? 1 : StateStack.size();
 731
 732   auto Buffer = MemoryBuffer::getMemBuffer(S, "", false);
 733   for (line_iterator Lines(*Buffer, false); !Lines.is_at_end(); ++Lines) {
 734     for (unsigned I = 0; I < Indent; ++I) {
 735       output("  ");
 736     }
 737     output(*Lines);
 738     outputNewLine();
 739   }
 740 }
 741
 742 void Output::scalarTag(std::string &Tag) {
 743   if (Tag.empty())
 744     return;
 745   newLineCheck();
 746   output(Tag);
 747   output(" ");
 748 }
 749
 750 void Output::setError(const Twine &message) {
 751 }
 752
 753 bool Output::canElideEmptySequence() {
 754   // Normally, with an optional key/value where the value is an empty sequence,
 755   // the whole key/value can be not written.  But, that produces wrong yaml
 756   // if the key/value is the only thing in the map and the map is used in
 757   // a sequence.  This detects if the this sequence is the first key/value
 758   // in map that itself is embedded in a sequence.
 759   if (StateStack.size() < 2)
 760     return true;
 761   if (StateStack.back() != inMapFirstKey)
 762     return true;
 763   return !inSeqAnyElement(StateStack[StateStack.size() - 2]);
 764 }
 765
 766 void Output::output(StringRef s) {
 767   Column += s.size();
 768   Out << s;
 769 }
 770
 771 void Output::output(StringRef S, QuotingType MustQuote) {
 772   if (MustQuote == QuotingType::None) {
 773     // Only quote if we must.
 774     output(S);
 775     return;
 776   }
 777
 778   StringLiteral Quote = MustQuote == QuotingType::Single ? StringLiteral("'")
 779                                                          : StringLiteral("\"");
 780   output(Quote); // Starting quote.
 781
 782   // When using double-quoted strings (and only in that case), non-printable
 783   // characters may be present, and will be escaped using a variety of
 784   // unicode-scalar and special short-form escapes. This is handled in
 785   // yaml::escape.
 786   if (MustQuote == QuotingType::Double) {
 787     output(yaml::escape(S, /* EscapePrintable= */ false));
 788     output(Quote);
 789     return;
 790   }
 791
 792   unsigned i = 0;
 793   unsigned j = 0;
 794   unsigned End = S.size();
 795   const char *Base = S.data();
 796
 797   // When using single-quoted strings, any single quote ' must be doubled to be
 798   // escaped.
 799   while (j < End) {
 800     if (S[j] == '\'') {                   // Escape quotes.
 801       output(StringRef(&Base[i], j - i)); // "flush".
 802       output(StringLiteral("''"));        // Print it as ''
 803       i = j + 1;
 804     }
 805     ++j;
 806   }
 807   output(StringRef(&Base[i], j - i));
 808   output(Quote); // Ending quote.
 809 }
 810
 811 void Output::outputUpToEndOfLine(StringRef s) {
 812   output(s);
 813   if (StateStack.empty() || (!inFlowSeqAnyElement(StateStack.back()) &&
 814                              !inFlowMapAnyKey(StateStack.back())))
 815     Padding = "\n";
 816 }
 817
 818 void Output::outputNewLine() {
 819   Out << "\n";
 820   Column = 0;
 821 }
 822
 823 // if seq at top, indent as if map, then add "- "
 824 // if seq in middle, use "- " if firstKey, else use "  "
 825 //
 826
 827 void Output::newLineCheck(bool EmptySequence) {
 828   if (Padding != "\n") {
 829     output(Padding);
 830     Padding = {};
 831     return;
 832   }
 833   outputNewLine();
 834   Padding = {};
 835
 836   if (StateStack.size() == 0 || EmptySequence)
 837     return;
 838
 839   unsigned Indent = StateStack.size() - 1;
 840   bool PossiblyNestedSeq = false;
 841   auto I = StateStack.rbegin(), E = StateStack.rend();
 842
 843   if (inSeqAnyElement(*I)) {
 844     PossiblyNestedSeq = true; // Not possibly but always.
 845     ++Indent;
 846   } else if (*I == inMapFirstKey || *I == inFlowMapFirstKey ||
 847              inFlowSeqAnyElement(*I)) {
 848     PossiblyNestedSeq = true;
 849     ++I; // Skip back().
 850   }
 851
 852   unsigned OutputDashCount = 0;
 853   if (PossiblyNestedSeq) {
 854     // Count up consecutive inSeqFirstElement from the end, unless
 855     // inSeqFirstElement is the top of nested sequence.
 856     while (I != E) {
 857       // Don't count the top of nested sequence.
 858       if (!inSeqAnyElement(*I))
 859         break;
 860
 861       ++OutputDashCount;
 862
 863       // Stop counting if consecutive inSeqFirstElement ends.
 864       if (*I++ != inSeqFirstElement)
 865         break;
 866     }
 867   }
 868
 869   for (unsigned I = OutputDashCount; I < Indent; ++I)
 870     output("  ");
 871
 872   for (unsigned I = 0; I < OutputDashCount; ++I)
 873     output("- ");
 874 }
 875
 876 void Output::paddedKey(StringRef key) {
 877   output(key, needsQuotes(key, false));
 878   output(":");
 879   const char *spaces = "                ";
 880   if (key.size() < strlen(spaces))
 881     Padding = &spaces[key.size()];
 882   else
 883     Padding = " ";
 884 }
 885
 886 void Output::flowKey(StringRef Key) {
 887   if (StateStack.back() == inFlowMapOtherKey)
 888     output(", ");
 889   if (WrapColumn && Column > WrapColumn) {
 890     output("\n");
 891     for (int I = 0; I < ColumnAtMapFlowStart; ++I)
 892       output(" ");
 893     Column = ColumnAtMapFlowStart;
 894     output("  ");
 895   }
 896   output(Key, needsQuotes(Key, false));
 897   output(": ");
 898 }
 899
 900 NodeKind Output::getNodeKind() { report_fatal_error("invalid call"); }
 901
 902 bool Output::inSeqAnyElement(InState State) {
 903   return State == inSeqFirstElement || State == inSeqOtherElement;
 904 }
 905
 906 bool Output::inFlowSeqAnyElement(InState State) {
 907   return State == inFlowSeqFirstElement || State == inFlowSeqOtherElement;
 908 }
 909
 910 bool Output::inMapAnyKey(InState State) {
 911   return State == inMapFirstKey || State == inMapOtherKey;
 912 }
 913
 914 bool Output::inFlowMapAnyKey(InState State) {
 915   return State == inFlowMapFirstKey || State == inFlowMapOtherKey;
 916 }
 917
 918 //===----------------------------------------------------------------------===//
 919 //  traits for built-in types
 920 //===----------------------------------------------------------------------===//
 921
 922 void ScalarTraits<bool>::output(const bool &Val, void *, raw_ostream &Out) {
 923   Out << (Val ? "true" : "false");
 924 }
 925
 926 StringRef ScalarTraits<bool>::input(StringRef Scalar, void *, bool &Val) {
 927   if (std::optional<bool> Parsed = parseBool(Scalar)) {
 928     Val = *Parsed;
 929     return StringRef();
 930   }
 931   return "invalid boolean";
 932 }
 933
 934 void ScalarTraits<StringRef>::output(const StringRef &Val, void *,
 935                                      raw_ostream &Out) {
 936   Out << Val;
 937 }
 938
 939 StringRef ScalarTraits<StringRef>::input(StringRef Scalar, void *,
 940                                          StringRef &Val) {
 941   Val = Scalar;
 942   return StringRef();
 943 }
 944
 945 void ScalarTraits<std::string>::output(const std::string &Val, void *,
 946                                        raw_ostream &Out) {
 947   Out << Val;
 948 }
 949
 950 StringRef ScalarTraits<std::string>::input(StringRef Scalar, void *,
 951                                            std::string &Val) {
 952   Val = Scalar.str();
 953   return StringRef();
 954 }
 955
 956 void ScalarTraits<uint8_t>::output(const uint8_t &Val, void *,
 957                                    raw_ostream &Out) {
 958   // use temp uin32_t because ostream thinks uint8_t is a character
 959   uint32_t Num = Val;
 960   Out << Num;
 961 }
 962
 963 StringRef ScalarTraits<uint8_t>::input(StringRef Scalar, void *, uint8_t &Val) {
 964   unsigned long long n;
 965   if (getAsUnsignedInteger(Scalar, 0, n))
 966     return "invalid number";
 967   if (n > 0xFF)
 968     return "out of range number";
 969   Val = n;
 970   return StringRef();
 971 }
 972
 973 void ScalarTraits<uint16_t>::output(const uint16_t &Val, void *,
 974                                     raw_ostream &Out) {
 975   Out << Val;
 976 }
 977
 978 StringRef ScalarTraits<uint16_t>::input(StringRef Scalar, void *,
 979                                         uint16_t &Val) {
 980   unsigned long long n;
 981   if (getAsUnsignedInteger(Scalar, 0, n))
 982     return "invalid number";
 983   if (n > 0xFFFF)
 984     return "out of range number";
 985   Val = n;
 986   return StringRef();
 987 }
 988
 989 void ScalarTraits<uint32_t>::output(const uint32_t &Val, void *,
 990                                     raw_ostream &Out) {
 991   Out << Val;
 992 }
 993
 994 StringRef ScalarTraits<uint32_t>::input(StringRef Scalar, void *,
 995                                         uint32_t &Val) {
 996   unsigned long long n;
 997   if (getAsUnsignedInteger(Scalar, 0, n))
 998     return "invalid number";
 999   if (n > 0xFFFFFFFFUL)
1000     return "out of range number";
1001   Val = n;
1002   return StringRef();
1003 }
1004
1005 void ScalarTraits<uint64_t>::output(const uint64_t &Val, void *,
1006                                     raw_ostream &Out) {
1007   Out << Val;
1008 }
1009
1010 StringRef ScalarTraits<uint64_t>::input(StringRef Scalar, void *,
1011                                         uint64_t &Val) {
1012   unsigned long long N;
1013   if (getAsUnsignedInteger(Scalar, 0, N))
1014     return "invalid number";
1015   Val = N;
1016   return StringRef();
1017 }
1018
1019 void ScalarTraits<int8_t>::output(const int8_t &Val, void *, raw_ostream &Out) {
1020   // use temp in32_t because ostream thinks int8_t is a character
1021   int32_t Num = Val;
1022   Out << Num;
1023 }
1024
1025 StringRef ScalarTraits<int8_t>::input(StringRef Scalar, void *, int8_t &Val) {
1026   long long N;
1027   if (getAsSignedInteger(Scalar, 0, N))
1028     return "invalid number";
1029   if ((N > 127) || (N < -128))
1030     return "out of range number";
1031   Val = N;
1032   return StringRef();
1033 }
1034
1035 void ScalarTraits<int16_t>::output(const int16_t &Val, void *,
1036                                    raw_ostream &Out) {
1037   Out << Val;
1038 }
1039
1040 StringRef ScalarTraits<int16_t>::input(StringRef Scalar, void *, int16_t &Val) {
1041   long long N;
1042   if (getAsSignedInteger(Scalar, 0, N))
1043     return "invalid number";
1044   if ((N > INT16_MAX) || (N < INT16_MIN))
1045     return "out of range number";
1046   Val = N;
1047   return StringRef();
1048 }
1049
1050 void ScalarTraits<int32_t>::output(const int32_t &Val, void *,
1051                                    raw_ostream &Out) {
1052   Out << Val;
1053 }
1054
1055 StringRef ScalarTraits<int32_t>::input(StringRef Scalar, void *, int32_t &Val) {
1056   long long N;
1057   if (getAsSignedInteger(Scalar, 0, N))
1058     return "invalid number";
1059   if ((N > INT32_MAX) || (N < INT32_MIN))
1060     return "out of range number";
1061   Val = N;
1062   return StringRef();
1063 }
1064
1065 void ScalarTraits<int64_t>::output(const int64_t &Val, void *,
1066                                    raw_ostream &Out) {
1067   Out << Val;
1068 }
1069
1070 StringRef ScalarTraits<int64_t>::input(StringRef Scalar, void *, int64_t &Val) {
1071   long long N;
1072   if (getAsSignedInteger(Scalar, 0, N))
1073     return "invalid number";
1074   Val = N;
1075   return StringRef();
1076 }
1077
1078 void ScalarTraits<double>::output(const double &Val, void *, raw_ostream &Out) {
1079   Out << format("%g", Val);
1080 }
1081
1082 StringRef ScalarTraits<double>::input(StringRef Scalar, void *, double &Val) {
1083   if (to_float(Scalar, Val))
1084     return StringRef();
1085   return "invalid floating point number";
1086 }
1087
1088 void ScalarTraits<float>::output(const float &Val, void *, raw_ostream &Out) {
1089   Out << format("%g", Val);
1090 }
1091
1092 StringRef ScalarTraits<float>::input(StringRef Scalar, void *, float &Val) {
1093   if (to_float(Scalar, Val))
1094     return StringRef();
1095   return "invalid floating point number";
1096 }
1097
1098 void ScalarTraits<Hex8>::output(const Hex8 &Val, void *, raw_ostream &Out) {
1099   Out << format("0x%" PRIX8, (uint8_t)Val);
1100 }
1101
1102 StringRef ScalarTraits<Hex8>::input(StringRef Scalar, void *, Hex8 &Val) {
1103   unsigned long long n;
1104   if (getAsUnsignedInteger(Scalar, 0, n))
1105     return "invalid hex8 number";
1106   if (n > 0xFF)
1107     return "out of range hex8 number";
1108   Val = n;
1109   return StringRef();
1110 }
1111
1112 void ScalarTraits<Hex16>::output(const Hex16 &Val, void *, raw_ostream &Out) {
1113   Out << format("0x%" PRIX16, (uint16_t)Val);
1114 }
1115
1116 StringRef ScalarTraits<Hex16>::input(StringRef Scalar, void *, Hex16 &Val) {
1117   unsigned long long n;
1118   if (getAsUnsignedInteger(Scalar, 0, n))
1119     return "invalid hex16 number";
1120   if (n > 0xFFFF)
1121     return "out of range hex16 number";
1122   Val = n;
1123   return StringRef();
1124 }
1125
1126 void ScalarTraits<Hex32>::output(const Hex32 &Val, void *, raw_ostream &Out) {
1127   Out << format("0x%" PRIX32, (uint32_t)Val);
1128 }
1129
1130 StringRef ScalarTraits<Hex32>::input(StringRef Scalar, void *, Hex32 &Val) {
1131   unsigned long long n;
1132   if (getAsUnsignedInteger(Scalar, 0, n))
1133     return "invalid hex32 number";
1134   if (n > 0xFFFFFFFFUL)
1135     return "out of range hex32 number";
1136   Val = n;
1137   return StringRef();
1138 }
1139
1140 void ScalarTraits<Hex64>::output(const Hex64 &Val, void *, raw_ostream &Out) {
1141   Out << format("0x%" PRIX64, (uint64_t)Val);
1142 }
1143
1144 StringRef ScalarTraits<Hex64>::input(StringRef Scalar, void *, Hex64 &Val) {
1145   unsigned long long Num;
1146   if (getAsUnsignedInteger(Scalar, 0, Num))
1147     return "invalid hex64 number";
1148   Val = Num;
1149   return StringRef();
1150 }
1151
1152 void ScalarTraits<VersionTuple>::output(const VersionTuple &Val, void *,
1153                                         llvm::raw_ostream &Out) {
1154   Out << Val.getAsString();
1155 }
1156
1157 StringRef ScalarTraits<VersionTuple>::input(StringRef Scalar, void *,
1158                                             VersionTuple &Val) {
1159   if (Val.tryParse(Scalar))
1160     return "invalid version format";
1161   return StringRef();
1162 }