LLVM  10.0.0svn
YAMLTraits.cpp
Go to the documentation of this file.
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 
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"
18 #include "llvm/Support/Format.h"
21 #include "llvm/Support/Unicode.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");
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)
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);
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 }
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:232
LLVMContext & Context
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool getAsUnsignedInteger(StringRef Str, unsigned Radix, unsigned long long &Result)
Helper functions for StringRef::getAsInteger.
Definition: StringRef.cpp:488
SourceMgr SrcMgr
Definition: Error.cpp:23
static std::unique_ptr< MemoryBuffer > getMemBuffer(StringRef InputData, StringRef BufferName="", bool RequiresNullTerminator=true)
Open the specified memory range as a MemoryBuffer.
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
Represents a YAML sequence created from either a block sequence for a flow sequence.
Definition: YAMLParser.h:452
A forward iterator which reads text lines from a buffer.
Definition: LineIterator.h:31
#define error(X)
std::string escape(StringRef Input, bool EscapePrintable=true)
Escape Input for a double quoted scalar; if EscapePrintable is true, all UTF8 sequences will be escap...
Definition: YAMLParser.cpp:690
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
LLVM_NODISCARD StringRef copy(Allocator &A) const
Definition: StringRef.h:162
A Use represents the edge between a Value definition and its users.
Definition: Use.h:55
std::error_code make_error_code(BitcodeError E)
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:140
static void DiagHandler(const SMDiagnostic &Diag, void *Context)
Definition: TextStub.cpp:611
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:266
Key
PAL metadata keys.
A key and value pair.
Definition: YAMLParser.h:279
bool to_float(const Twine &T, float &Num)
Definition: StringExtras.h:211
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:144
#define P(N)
void setDiagHandler(DiagHandlerTy DH, void *Ctx=nullptr)
Specify a diagnostic handler to be invoked every time PrintMessage is called.
Definition: SourceMgr.h:119
A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs...
Definition: StringRef.h:852
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
void(*)(const SMDiagnostic &, void *Context) DiagHandlerTy
Clients that want to handle their own diagnostics in a custom way can register a function pointer+con...
Definition: SourceMgr.h:53
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
A scalar node is an opaque datum that can be presented as a series of zero or more Unicode scalar val...
Definition: YAMLParser.h:206
This class represents a YAML stream potentially containing multiple documents.
Definition: YAMLParser.h:83
LLVM_NODISCARD bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:174
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:55
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
Sequence
A sequence of states that a pointer may go through in which an objc_retain and objc_release are actua...
Definition: PtrState.h:40
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:332
A block scalar node is an opaque datum that can be presented as a series of zero or more Unicode scal...
Definition: YAMLParser.h:249
Represents a YAML map created from either a block map for a flow map.
Definition: YAMLParser.h:404
LLVM_NODISCARD const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:136
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:73
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
std::string getVerbatimTag() const
Get the verbatium tag for a given Node.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
StringRef getValue(SmallVectorImpl< char > &Storage) const
Gets the value of this node as a StringRef.
bool getAsSignedInteger(StringRef Str, unsigned Radix, long long &Result)
Definition: StringRef.cpp:498
Abstract base class for all Nodes.
Definition: YAMLParser.h:113
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:1224