YAMLTraits.cpp revision 249423
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) { 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()); 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)) { 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)) { 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)) { 297 MapHNode *mapHNode = new MapHNode(N); 298 for (MappingNode::iterator i = Map->begin(), End = Map->end(); i != End; 299 ++i) { 300 ScalarNode *KeyScalar = dyn_cast<ScalarNode>(i->getKey()); 301 StringStorage.clear(); 302 StringRef KeyStr = KeyScalar->getValue(StringStorage); 303 if (!StringStorage.empty()) { 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()); 311 if (EC) 312 break; 313 mapHNode->Mapping[KeyStr] = ValueHNode; 314 } 315 return mapHNode; 316 } else if (isa<NullNode>(N)) { 317 return new EmptyHNode(N); 318 } else { 319 setError(N, "unknown node kind"); 320 return 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"); 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); 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_MAX) || (N < INT16_MIN)) 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_MAX) || (N < INT32_MIN)) 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} 828