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