xref: /freebsd/contrib/llvm-project/llvm/lib/Support/YAMLTraits.cpp (revision 2f513db72b034fd5ef7f080b11be5c711c15186a)
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() {
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() {
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 llvm::make_unique<ScalarHNode>(N, KeyStr);
381   } else if (BlockScalarNode *BSN = dyn_cast<BlockScalarNode>(N)) {
382     StringRef ValueCopy = BSN->getValue().copy(StringAllocator);
383     return llvm::make_unique<ScalarHNode>(N, ValueCopy);
384   } else if (SequenceNode *SQ = dyn_cast<SequenceNode>(N)) {
385     auto SQHNode = llvm::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 = llvm::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 llvm::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() {
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 }
1089