Bug Summary

File:f:/llvm_COMMON/lib/Support/YAMLTraits.cpp
Location:line 315, column 12
Description:Memory is never released; potential leak of memory pointed to by 'ValueHNode'

Annotated Source Code

1//===- lib/Support/YAMLTraits.cpp -----------------------------------------===//
2//
3// The LLVM Linker
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "llvm/Support/YAMLTraits.h"
11#include "llvm/ADT/Twine.h"
12#include "llvm/Support/Casting.h"
13#include "llvm/Support/ErrorHandling.h"
14#include "llvm/Support/Format.h"
15#include "llvm/Support/YAMLParser.h"
16#include "llvm/Support/raw_ostream.h"
17#include <cstring>
18using namespace llvm;
19using namespace yaml;
20
21//===----------------------------------------------------------------------===//
22// IO
23//===----------------------------------------------------------------------===//
24
25IO::IO(void *Context) : Ctxt(Context) {
26}
27
28IO::~IO() {
29}
30
31void *IO::getContext() {
32 return Ctxt;
33}
34
35void IO::setContext(void *Context) {
36 Ctxt = Context;
37}
38
39//===----------------------------------------------------------------------===//
40// Input
41//===----------------------------------------------------------------------===//
42
43Input::Input(StringRef InputContent, void *Ctxt)
44 : IO(Ctxt),
45 Strm(new Stream(InputContent, SrcMgr)),
46 CurrentNode(NULL__null) {
47 DocIterator = Strm->begin();
48}
49
50Input::~Input() {
51
52}
53
54error_code Input::error() {
55 return EC;
56}
57
58void Input::setDiagHandler(SourceMgr::DiagHandlerTy Handler, void *Ctxt) {
59 SrcMgr.setDiagHandler(Handler, Ctxt);
60}
61
62bool Input::outputting() {
63 return false;
64}
65
66bool Input::setCurrentDocument() {
67 if (DocIterator != Strm->end()) {
68 Node *N = DocIterator->getRoot();
69 if (isa<NullNode>(N)) {
70 // Empty files are allowed and ignored
71 ++DocIterator;
72 return setCurrentDocument();
73 }
74 TopNode.reset(this->createHNodes(N));
75 CurrentNode = TopNode.get();
76 return true;
77 }
78 return false;
79}
80
81void Input::nextDocument() {
82 ++DocIterator;
83}
84
85void Input::beginMapping() {
86 if (EC)
87 return;
88 MapHNode *MN = dyn_cast<MapHNode>(CurrentNode);
89 if (MN) {
90 MN->ValidKeys.clear();
91 }
92}
93
94bool Input::preflightKey(const char *Key, bool Required, bool, bool &UseDefault,
95 void *&SaveInfo) {
96 UseDefault = false;
97 if (EC)
98 return false;
99 MapHNode *MN = dyn_cast<MapHNode>(CurrentNode);
100 if (!MN) {
101 setError(CurrentNode, "not a mapping");
102 return false;
103 }
104 MN->ValidKeys.push_back(Key);
105 HNode *Value = MN->Mapping[Key];
106 if (!Value) {
107 if (Required)
108 setError(CurrentNode, Twine("missing required key '") + Key + "'");
109 else
110 UseDefault = true;
111 return false;
112 }
113 SaveInfo = CurrentNode;
114 CurrentNode = Value;
115 return true;
116}
117
118void Input::postflightKey(void *saveInfo) {
119 CurrentNode = reinterpret_cast<HNode *>(saveInfo);
120}
121
122void Input::endMapping() {
123 if (EC)
124 return;
125 MapHNode *MN = dyn_cast<MapHNode>(CurrentNode);
126 if (!MN)
127 return;
128 for (MapHNode::NameToNode::iterator i = MN->Mapping.begin(),
129 End = MN->Mapping.end(); i != End; ++i) {
130 if (!MN->isValidKey(i->first)) {
131 setError(i->second, Twine("unknown key '") + i->first + "'");
132 break;
133 }
134 }
135}
136
137unsigned Input::beginSequence() {
138 if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) {
139 return SQ->Entries.size();
140 }
141 return 0;
142}
143
144void Input::endSequence() {
145}
146
147bool Input::preflightElement(unsigned Index, void *&SaveInfo) {
148 if (EC)
149 return false;
150 if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) {
151 SaveInfo = CurrentNode;
152 CurrentNode = SQ->Entries[Index];
153 return true;
154 }
155 return false;
156}
157
158void Input::postflightElement(void *SaveInfo) {
159 CurrentNode = reinterpret_cast<HNode *>(SaveInfo);
160}
161
162unsigned Input::beginFlowSequence() {
163 if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) {
164 return SQ->Entries.size();
165 }
166 return 0;
167}
168
169bool Input::preflightFlowElement(unsigned index, void *&SaveInfo) {
170 if (EC)
171 return false;
172 if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) {
173 SaveInfo = CurrentNode;
174 CurrentNode = SQ->Entries[index];
175 return true;
176 }
177 return false;
178}
179
180void Input::postflightFlowElement(void *SaveInfo) {
181 CurrentNode = reinterpret_cast<HNode *>(SaveInfo);
182}
183
184void Input::endFlowSequence() {
185}
186
187void Input::beginEnumScalar() {
188 ScalarMatchFound = false;
189}
190
191bool Input::matchEnumScalar(const char *Str, bool) {
192 if (ScalarMatchFound)
193 return false;
194 if (ScalarHNode *SN = dyn_cast<ScalarHNode>(CurrentNode)) {
195 if (SN->value().equals(Str)) {
196 ScalarMatchFound = true;
197 return true;
198 }
199 }
200 return false;
201}
202
203void Input::endEnumScalar() {
204 if (!ScalarMatchFound) {
205 setError(CurrentNode, "unknown enumerated scalar");
206 }
207}
208
209bool Input::beginBitSetScalar(bool &DoClear) {
210 BitValuesUsed.clear();
211 if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) {
212 BitValuesUsed.insert(BitValuesUsed.begin(), SQ->Entries.size(), false);
213 } else {
214 setError(CurrentNode, "expected sequence of bit values");
215 }
216 DoClear = true;
217 return true;
218}
219
220bool Input::bitSetMatch(const char *Str, bool) {
221 if (EC)
222 return false;
223 if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) {
224 unsigned Index = 0;
225 for (std::vector<HNode *>::iterator i = SQ->Entries.begin(),
226 End = SQ->Entries.end(); i != End; ++i) {
227 if (ScalarHNode *SN = dyn_cast<ScalarHNode>(*i)) {
228 if (SN->value().equals(Str)) {
229 BitValuesUsed[Index] = true;
230 return true;
231 }
232 } else {
233 setError(CurrentNode, "unexpected scalar in sequence of bit values");
234 }
235 ++Index;
236 }
237 } else {
238 setError(CurrentNode, "expected sequence of bit values");
239 }
240 return false;
241}
242
243void Input::endBitSetScalar() {
244 if (EC)
245 return;
246 if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) {
247 assert(BitValuesUsed.size() == SQ->Entries.size())((void)0);
248 for (unsigned i = 0; i < SQ->Entries.size(); ++i) {
249 if (!BitValuesUsed[i]) {
250 setError(SQ->Entries[i], "unknown bit value");
251 return;
252 }
253 }
254 }
255}
256
257void Input::scalarString(StringRef &S) {
258 if (ScalarHNode *SN = dyn_cast<ScalarHNode>(CurrentNode)) {
259 S = SN->value();
260 } else {
261 setError(CurrentNode, "unexpected scalar");
262 }
263}
264
265void Input::setError(HNode *hnode, const Twine &message) {
266 this->setError(hnode->_node, message);
267}
268
269void Input::setError(Node *node, const Twine &message) {
270 Strm->printError(node, message);
271 EC = make_error_code(errc::invalid_argument);
272}
273
274Input::HNode *Input::createHNodes(Node *N) {
275 SmallString<128> StringStorage;
276 if (ScalarNode *SN = dyn_cast<ScalarNode>(N)) {
1
Taking false branch
8
Taking false branch
277 StringRef KeyStr = SN->getValue(StringStorage);
278 if (!StringStorage.empty()) {
279 // Copy string to permanent storage
280 unsigned Len = StringStorage.size();
281 char *Buf = StringAllocator.Allocate<char>(Len);
282 memcpy(Buf, &StringStorage[0], Len);
283 KeyStr = StringRef(Buf, Len);
284 }
285 return new ScalarHNode(N, KeyStr);
286 } else if (SequenceNode *SQ = dyn_cast<SequenceNode>(N)) {
2
Taking false branch
9
Taking false branch
287 SequenceHNode *SQHNode = new SequenceHNode(N);
288 for (SequenceNode::iterator i = SQ->begin(), End = SQ->end(); i != End;
289 ++i) {
290 HNode *Entry = this->createHNodes(i);
291 if (EC)
292 break;
293 SQHNode->Entries.push_back(Entry);
294 }
295 return SQHNode;
296 } else if (MappingNode *Map = dyn_cast<MappingNode>(N)) {
3
Assuming 'Map' is non-null
4
Taking true branch
10
Taking false branch
297 MapHNode *mapHNode = new MapHNode(N);
298 for (MappingNode::iterator i = Map->begin(), End = Map->end(); i != End;
5
Loop condition is true. Entering loop body
299 ++i) {
300 ScalarNode *KeyScalar = dyn_cast<ScalarNode>(i->getKey());
301 StringStorage.clear();
302 StringRef KeyStr = KeyScalar->getValue(StringStorage);
303 if (!StringStorage.empty()) {
6
Taking false branch
304 // Copy string to permanent storage
305 unsigned Len = StringStorage.size();
306 char *Buf = StringAllocator.Allocate<char>(Len);
307 memcpy(Buf, &StringStorage[0], Len);
308 KeyStr = StringRef(Buf, Len);
309 }
310 HNode *ValueHNode = this->createHNodes(i->getValue());
7
Calling 'Input::createHNodes'
13
Returned allocated memory
311 if (EC)
14
Taking true branch
312 break;
15
Execution continues on line 315
313 mapHNode->Mapping[KeyStr] = ValueHNode;
314 }
315 return mapHNode;
16
Memory is never released; potential leak of memory pointed to by 'ValueHNode'
316 } else if (isa<NullNode>(N)) {
11
Taking true branch
317 return new EmptyHNode(N);
12
Memory is allocated
318 } else {
319 setError(N, "unknown node kind");
320 return NULL__null;
321 }
322}
323
324bool Input::MapHNode::isValidKey(StringRef Key) {
325 for (SmallVector<const char *, 6>::iterator i = ValidKeys.begin(),
326 End = ValidKeys.end(); i != End; ++i) {
327 if (Key.equals(*i))
328 return true;
329 }
330 return false;
331}
332
333void Input::setError(const Twine &Message) {
334 this->setError(CurrentNode, Message);
335}
336
337Input::MapHNode::~MapHNode() {
338 for (MapHNode::NameToNode::iterator i = Mapping.begin(), End = Mapping.end();
339 i != End; ++i) {
340 delete i->second;
341 }
342}
343
344Input::SequenceHNode::~SequenceHNode() {
345 for (std::vector<HNode*>::iterator i = Entries.begin(), End = Entries.end();
346 i != End; ++i) {
347 delete *i;
348 }
349}
350
351
352
353//===----------------------------------------------------------------------===//
354// Output
355//===----------------------------------------------------------------------===//
356
357Output::Output(raw_ostream &yout, void *context)
358 : IO(context),
359 Out(yout),
360 Column(0),
361 ColumnAtFlowStart(0),
362 NeedBitValueComma(false),
363 NeedFlowSequenceComma(false),
364 EnumerationMatchFound(false),
365 NeedsNewLine(false) {
366}
367
368Output::~Output() {
369}
370
371bool Output::outputting() {
372 return true;
373}
374
375void Output::beginMapping() {
376 StateStack.push_back(inMapFirstKey);
377 NeedsNewLine = true;
378}
379
380void Output::endMapping() {
381 StateStack.pop_back();
382}
383
384bool Output::preflightKey(const char *Key, bool Required, bool SameAsDefault,
385 bool &UseDefault, void *&) {
386 UseDefault = false;
387 if (Required || !SameAsDefault) {
388 this->newLineCheck();
389 this->paddedKey(Key);
390 return true;
391 }
392 return false;
393}
394
395void Output::postflightKey(void *) {
396 if (StateStack.back() == inMapFirstKey) {
397 StateStack.pop_back();
398 StateStack.push_back(inMapOtherKey);
399 }
400}
401
402void Output::beginDocuments() {
403 this->outputUpToEndOfLine("---");
404}
405
406bool Output::preflightDocument(unsigned index) {
407 if (index > 0)
408 this->outputUpToEndOfLine("\n---");
409 return true;
410}
411
412void Output::postflightDocument() {
413}
414
415void Output::endDocuments() {
416 output("\n...\n");
417}
418
419unsigned Output::beginSequence() {
420 StateStack.push_back(inSeq);
421 NeedsNewLine = true;
422 return 0;
423}
424
425void Output::endSequence() {
426 StateStack.pop_back();
427}
428
429bool Output::preflightElement(unsigned, void *&) {
430 return true;
431}
432
433void Output::postflightElement(void *) {
434}
435
436unsigned Output::beginFlowSequence() {
437 StateStack.push_back(inFlowSeq);
438 this->newLineCheck();
439 ColumnAtFlowStart = Column;
440 output("[ ");
441 NeedFlowSequenceComma = false;
442 return 0;
443}
444
445void Output::endFlowSequence() {
446 StateStack.pop_back();
447 this->outputUpToEndOfLine(" ]");
448}
449
450bool Output::preflightFlowElement(unsigned, void *&) {
451 if (NeedFlowSequenceComma)
452 output(", ");
453 if (Column > 70) {
454 output("\n");
455 for (int i = 0; i < ColumnAtFlowStart; ++i)
456 output(" ");
457 Column = ColumnAtFlowStart;
458 output(" ");
459 }
460 return true;
461}
462
463void Output::postflightFlowElement(void *) {
464 NeedFlowSequenceComma = true;
465}
466
467void Output::beginEnumScalar() {
468 EnumerationMatchFound = false;
469}
470
471bool Output::matchEnumScalar(const char *Str, bool Match) {
472 if (Match && !EnumerationMatchFound) {
473 this->newLineCheck();
474 this->outputUpToEndOfLine(Str);
475 EnumerationMatchFound = true;
476 }
477 return false;
478}
479
480void Output::endEnumScalar() {
481 if (!EnumerationMatchFound)
482 llvm_unreachable("bad runtime enum value")__builtin_unreachable();
483}
484
485bool Output::beginBitSetScalar(bool &DoClear) {
486 this->newLineCheck();
487 output("[ ");
488 NeedBitValueComma = false;
489 DoClear = false;
490 return true;
491}
492
493bool Output::bitSetMatch(const char *Str, bool Matches) {
494 if (Matches) {
495 if (NeedBitValueComma)
496 output(", ");
497 this->output(Str);
498 NeedBitValueComma = true;
499 }
500 return false;
501}
502
503void Output::endBitSetScalar() {
504 this->outputUpToEndOfLine(" ]");
505}
506
507void Output::scalarString(StringRef &S) {
508 this->newLineCheck();
509 if (S.find('\n') == StringRef::npos) {
510 // No embedded new-line chars, just print string.
511 this->outputUpToEndOfLine(S);
512 return;
513 }
514 unsigned i = 0;
515 unsigned j = 0;
516 unsigned End = S.size();
517 output("'"); // Starting single quote.
518 const char *Base = S.data();
519 while (j < End) {
520 // Escape a single quote by doubling it.
521 if (S[j] == '\'') {
522 output(StringRef(&Base[i], j - i + 1));
523 output("'");
524 i = j + 1;
525 }
526 ++j;
527 }
528 output(StringRef(&Base[i], j - i));
529 this->outputUpToEndOfLine("'"); // Ending single quote.
530}
531
532void Output::setError(const Twine &message) {
533}
534
535void Output::output(StringRef s) {
536 Column += s.size();
537 Out << s;
538}
539
540void Output::outputUpToEndOfLine(StringRef s) {
541 this->output(s);
542 if (StateStack.empty() || StateStack.back() != inFlowSeq)
543 NeedsNewLine = true;
544}
545
546void Output::outputNewLine() {
547 Out << "\n";
548 Column = 0;
549}
550
551// if seq at top, indent as if map, then add "- "
552// if seq in middle, use "- " if firstKey, else use " "
553//
554
555void Output::newLineCheck() {
556 if (!NeedsNewLine)
557 return;
558 NeedsNewLine = false;
559
560 this->outputNewLine();
561
562 assert(StateStack.size() > 0)((void)0);
563 unsigned Indent = StateStack.size() - 1;
564 bool OutputDash = false;
565
566 if (StateStack.back() == inSeq) {
567 OutputDash = true;
568 } else if ((StateStack.size() > 1) && (StateStack.back() == inMapFirstKey) &&
569 (StateStack[StateStack.size() - 2] == inSeq)) {
570 --Indent;
571 OutputDash = true;
572 }
573
574 for (unsigned i = 0; i < Indent; ++i) {
575 output(" ");
576 }
577 if (OutputDash) {
578 output("- ");
579 }
580
581}
582
583void Output::paddedKey(StringRef key) {
584 output(key);
585 output(":");
586 const char *spaces = " ";
587 if (key.size() < strlen(spaces))
588 output(&spaces[key.size()]);
589 else
590 output(" ");
591}
592
593//===----------------------------------------------------------------------===//
594// traits for built-in types
595//===----------------------------------------------------------------------===//
596
597void ScalarTraits<bool>::output(const bool &Val, void *, raw_ostream &Out) {
598 Out << (Val ? "true" : "false");
599}
600
601StringRef ScalarTraits<bool>::input(StringRef Scalar, void *, bool &Val) {
602 if (Scalar.equals("true")) {
603 Val = true;
604 return StringRef();
605 } else if (Scalar.equals("false")) {
606 Val = false;
607 return StringRef();
608 }
609 return "invalid boolean";
610}
611
612void ScalarTraits<StringRef>::output(const StringRef &Val, void *,
613 raw_ostream &Out) {
614 Out << Val;
615}
616
617StringRef ScalarTraits<StringRef>::input(StringRef Scalar, void *,
618 StringRef &Val) {
619 Val = Scalar;
620 return StringRef();
621}
622
623void ScalarTraits<uint8_t>::output(const uint8_t &Val, void *,
624 raw_ostream &Out) {
625 // use temp uin32_t because ostream thinks uint8_t is a character
626 uint32_t Num = Val;
627 Out << Num;
628}
629
630StringRef ScalarTraits<uint8_t>::input(StringRef Scalar, void *, uint8_t &Val) {
631 unsigned long long n;
632 if (getAsUnsignedInteger(Scalar, 0, n))
633 return "invalid number";
634 if (n > 0xFF)
635 return "out of range number";
636 Val = n;
637 return StringRef();
638}
639
640void ScalarTraits<uint16_t>::output(const uint16_t &Val, void *,
641 raw_ostream &Out) {
642 Out << Val;
643}
644
645StringRef ScalarTraits<uint16_t>::input(StringRef Scalar, void *,
646 uint16_t &Val) {
647 unsigned long long n;
648 if (getAsUnsignedInteger(Scalar, 0, n))
649 return "invalid number";
650 if (n > 0xFFFF)
651 return "out of range number";
652 Val = n;
653 return StringRef();
654}
655
656void ScalarTraits<uint32_t>::output(const uint32_t &Val, void *,
657 raw_ostream &Out) {
658 Out << Val;
659}
660
661StringRef ScalarTraits<uint32_t>::input(StringRef Scalar, void *,
662 uint32_t &Val) {
663 unsigned long long n;
664 if (getAsUnsignedInteger(Scalar, 0, n))
665 return "invalid number";
666 if (n > 0xFFFFFFFFUL)
667 return "out of range number";
668 Val = n;
669 return StringRef();
670}
671
672void ScalarTraits<uint64_t>::output(const uint64_t &Val, void *,
673 raw_ostream &Out) {
674 Out << Val;
675}
676
677StringRef ScalarTraits<uint64_t>::input(StringRef Scalar, void *,
678 uint64_t &Val) {
679 unsigned long long N;
680 if (getAsUnsignedInteger(Scalar, 0, N))
681 return "invalid number";
682 Val = N;
683 return StringRef();
684}
685
686void ScalarTraits<int8_t>::output(const int8_t &Val, void *, raw_ostream &Out) {
687 // use temp in32_t because ostream thinks int8_t is a character
688 int32_t Num = Val;
689 Out << Num;
690}
691
692StringRef ScalarTraits<int8_t>::input(StringRef Scalar, void *, int8_t &Val) {
693 long long N;
694 if (getAsSignedInteger(Scalar, 0, N))
695 return "invalid number";
696 if ((N > 127) || (N < -128))
697 return "out of range number";
698 Val = N;
699 return StringRef();
700}
701
702void ScalarTraits<int16_t>::output(const int16_t &Val, void *,
703 raw_ostream &Out) {
704 Out << Val;
705}
706
707StringRef ScalarTraits<int16_t>::input(StringRef Scalar, void *, int16_t &Val) {
708 long long N;
709 if (getAsSignedInteger(Scalar, 0, N))
710 return "invalid number";
711 if ((N > INT16_MAX32767) || (N < INT16_MIN(-32768)))
712 return "out of range number";
713 Val = N;
714 return StringRef();
715}
716
717void ScalarTraits<int32_t>::output(const int32_t &Val, void *,
718 raw_ostream &Out) {
719 Out << Val;
720}
721
722StringRef ScalarTraits<int32_t>::input(StringRef Scalar, void *, int32_t &Val) {
723 long long N;
724 if (getAsSignedInteger(Scalar, 0, N))
725 return "invalid number";
726 if ((N > INT32_MAX2147483647) || (N < INT32_MIN(-2147483647 - 1)))
727 return "out of range number";
728 Val = N;
729 return StringRef();
730}
731
732void ScalarTraits<int64_t>::output(const int64_t &Val, void *,
733 raw_ostream &Out) {
734 Out << Val;
735}
736
737StringRef ScalarTraits<int64_t>::input(StringRef Scalar, void *, int64_t &Val) {
738 long long N;
739 if (getAsSignedInteger(Scalar, 0, N))
740 return "invalid number";
741 Val = N;
742 return StringRef();
743}
744
745void ScalarTraits<double>::output(const double &Val, void *, raw_ostream &Out) {
746 Out << format("%g", Val);
747}
748
749StringRef ScalarTraits<double>::input(StringRef Scalar, void *, double &Val) {
750 SmallString<32> buff(Scalar.begin(), Scalar.end());
751 char *end;
752 Val = strtod(buff.c_str(), &end);
753 if (*end != '\0')
754 return "invalid floating point number";
755 return StringRef();
756}
757
758void ScalarTraits<float>::output(const float &Val, void *, raw_ostream &Out) {
759 Out << format("%g", Val);
760}
761
762StringRef ScalarTraits<float>::input(StringRef Scalar, void *, float &Val) {
763 SmallString<32> buff(Scalar.begin(), Scalar.end());
764 char *end;
765 Val = strtod(buff.c_str(), &end);
766 if (*end != '\0')
767 return "invalid floating point number";
768 return StringRef();
769}
770
771void ScalarTraits<Hex8>::output(const Hex8 &Val, void *, raw_ostream &Out) {
772 uint8_t Num = Val;
773 Out << format("0x%02X", Num);
774}
775
776StringRef ScalarTraits<Hex8>::input(StringRef Scalar, void *, Hex8 &Val) {
777 unsigned long long n;
778 if (getAsUnsignedInteger(Scalar, 0, n))
779 return "invalid hex8 number";
780 if (n > 0xFF)
781 return "out of range hex8 number";
782 Val = n;
783 return StringRef();
784}
785
786void ScalarTraits<Hex16>::output(const Hex16 &Val, void *, raw_ostream &Out) {
787 uint16_t Num = Val;
788 Out << format("0x%04X", Num);
789}
790
791StringRef ScalarTraits<Hex16>::input(StringRef Scalar, void *, Hex16 &Val) {
792 unsigned long long n;
793 if (getAsUnsignedInteger(Scalar, 0, n))
794 return "invalid hex16 number";
795 if (n > 0xFFFF)
796 return "out of range hex16 number";
797 Val = n;
798 return StringRef();
799}
800
801void ScalarTraits<Hex32>::output(const Hex32 &Val, void *, raw_ostream &Out) {
802 uint32_t Num = Val;
803 Out << format("0x%08X", Num);
804}
805
806StringRef ScalarTraits<Hex32>::input(StringRef Scalar, void *, Hex32 &Val) {
807 unsigned long long n;
808 if (getAsUnsignedInteger(Scalar, 0, n))
809 return "invalid hex32 number";
810 if (n > 0xFFFFFFFFUL)
811 return "out of range hex32 number";
812 Val = n;
813 return StringRef();
814}
815
816void ScalarTraits<Hex64>::output(const Hex64 &Val, void *, raw_ostream &Out) {
817 uint64_t Num = Val;
818 Out << format("0x%016llX", Num);
819}
820
821StringRef ScalarTraits<Hex64>::input(StringRef Scalar, void *, Hex64 &Val) {
822 unsigned long long Num;
823 if (getAsUnsignedInteger(Scalar, 0, Num))
824 return "invalid hex64 number";
825 Val = Num;
826 return StringRef();
827}