YAMLTraits.cpp revision 249259
10SN/A//===- lib/Support/YAMLTraits.cpp -----------------------------------------===// 29595SN/A// 30SN/A// The LLVM Linker 40SN/A// 50SN/A// This file is distributed under the University of Illinois Open Source 60SN/A// License. See LICENSE.TXT for details. 72362SN/A// 80SN/A//===----------------------------------------------------------------------===// 92362SN/A 100SN/A#include "llvm/Support/YAMLTraits.h" 110SN/A#include "llvm/ADT/Twine.h" 120SN/A#include "llvm/Support/Casting.h" 130SN/A#include "llvm/Support/ErrorHandling.h" 140SN/A#include "llvm/Support/Format.h" 150SN/A#include "llvm/Support/YAMLParser.h" 160SN/A#include "llvm/Support/raw_ostream.h" 170SN/A#include <cstring> 180SN/Ausing namespace llvm; 190SN/Ausing namespace yaml; 200SN/A 212362SN/A//===----------------------------------------------------------------------===// 222362SN/A// IO 232362SN/A//===----------------------------------------------------------------------===// 240SN/A 250SN/AIO::IO(void *Context) : Ctxt(Context) { 260SN/A} 270SN/A 280SN/AIO::~IO() { 290SN/A} 300SN/A 310SN/Avoid *IO::getContext() { 320SN/A return Ctxt; 330SN/A} 340SN/A 350SN/Avoid IO::setContext(void *Context) { 360SN/A Ctxt = Context; 370SN/A} 380SN/A 390SN/A//===----------------------------------------------------------------------===// 400SN/A// Input 410SN/A//===----------------------------------------------------------------------===// 421085SN/A 431085SN/AInput::Input(StringRef InputContent, void *Ctxt) 440SN/A : IO(Ctxt), 450SN/A Strm(new Stream(InputContent, SrcMgr)), 460SN/A CurrentNode(NULL) { 470SN/A DocIterator = Strm->begin(); 480SN/A} 490SN/A 500SN/AInput::~Input() { 5112195Savstepan 520SN/A} 530SN/A 540SN/Aerror_code Input::error() { 550SN/A return EC; 560SN/A} 570SN/A 580SN/Avoid Input::setDiagHandler(SourceMgr::DiagHandlerTy Handler, void *Ctxt) { 590SN/A SrcMgr.setDiagHandler(Handler, Ctxt); 600SN/A} 610SN/A 620SN/Abool Input::outputting() { 634402SN/A return false; 640SN/A} 650SN/A 660SN/Abool Input::setCurrentDocument() { 670SN/A if (DocIterator != Strm->end()) { 680SN/A Node *N = DocIterator->getRoot(); 690SN/A if (isa<NullNode>(N)) { 700SN/A // Empty files are allowed and ignored 710SN/A ++DocIterator; 720SN/A return setCurrentDocument(); 730SN/A } 740SN/A TopNode.reset(this->createHNodes(N)); 750SN/A CurrentNode = TopNode.get(); 760SN/A return true; 770SN/A } 780SN/A return false; 794402SN/A} 800SN/A 810SN/Avoid Input::nextDocument() { 820SN/A ++DocIterator; 830SN/A} 840SN/A 850SN/Avoid Input::beginMapping() { 860SN/A if (EC) 870SN/A return; 880SN/A MapHNode *MN = dyn_cast<MapHNode>(CurrentNode); 890SN/A if (MN) { 900SN/A MN->ValidKeys.clear(); 910SN/A } 920SN/A} 930SN/A 940SN/Abool Input::preflightKey(const char *Key, bool Required, bool, bool &UseDefault, 950SN/A void *&SaveInfo) { 960SN/A UseDefault = false; 970SN/A if (EC) 980SN/A return false; 990SN/A MapHNode *MN = dyn_cast<MapHNode>(CurrentNode); 1000SN/A if (!MN) { 1010SN/A setError(CurrentNode, "not a mapping"); 1020SN/A return false; 1030SN/A } 1040SN/A MN->ValidKeys.push_back(Key); 1050SN/A HNode *Value = MN->Mapping[Key]; 1060SN/A if (!Value) { 1070SN/A if (Required) 1080SN/A setError(CurrentNode, Twine("missing required key '") + Key + "'"); 1090SN/A else 1100SN/A UseDefault = true; 1110SN/A return false; 1120SN/A } 1130SN/A SaveInfo = CurrentNode; 1140SN/A CurrentNode = Value; 1150SN/A return true; 1160SN/A} 1170SN/A 1180SN/Avoid Input::postflightKey(void *saveInfo) { 1190SN/A CurrentNode = reinterpret_cast<HNode *>(saveInfo); 1200SN/A} 1210SN/A 1220SN/Avoid Input::endMapping() { 1230SN/A if (EC) 1240SN/A return; 1250SN/A MapHNode *MN = dyn_cast<MapHNode>(CurrentNode); 1260SN/A if (!MN) 1270SN/A return; 1280SN/A for (MapHNode::NameToNode::iterator i = MN->Mapping.begin(), 1290SN/A End = MN->Mapping.end(); i != End; ++i) { 1300SN/A if (!MN->isValidKey(i->first)) { 1310SN/A setError(i->second, Twine("unknown key '") + i->first + "'"); 1320SN/A break; 1330SN/A } 1340SN/A } 1350SN/A} 1360SN/A 1370SN/Aunsigned Input::beginSequence() { 1380SN/A if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) { 1390SN/A return SQ->Entries.size(); 1400SN/A } 1410SN/A return 0; 1420SN/A} 1430SN/A 1440SN/Avoid Input::endSequence() { 1450SN/A} 1460SN/A 1470SN/Abool Input::preflightElement(unsigned Index, void *&SaveInfo) { 1480SN/A if (EC) 1490SN/A return false; 1500SN/A if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) { 1510SN/A SaveInfo = CurrentNode; 1520SN/A CurrentNode = SQ->Entries[Index]; 1530SN/A return true; 1540SN/A } 1550SN/A return false; 1560SN/A} 1570SN/A 1580SN/Avoid Input::postflightElement(void *SaveInfo) { 1590SN/A CurrentNode = reinterpret_cast<HNode *>(SaveInfo); 1600SN/A} 1610SN/A 1620SN/Aunsigned Input::beginFlowSequence() { 1630SN/A if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) { 1640SN/A return SQ->Entries.size(); 1650SN/A } 1660SN/A return 0; 1670SN/A} 1680SN/A 1690SN/Abool Input::preflightFlowElement(unsigned index, void *&SaveInfo) { 1700SN/A if (EC) 1710SN/A return false; 1720SN/A if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) { 1730SN/A SaveInfo = CurrentNode; 1740SN/A CurrentNode = SQ->Entries[index]; 1750SN/A return true; 1760SN/A } 1770SN/A return false; 1780SN/A} 1790SN/A 1800SN/Avoid Input::postflightFlowElement(void *SaveInfo) { 1810SN/A CurrentNode = reinterpret_cast<HNode *>(SaveInfo); 1820SN/A} 1830SN/A 1840SN/Avoid Input::endFlowSequence() { 1850SN/A} 1860SN/A 1870SN/Avoid Input::beginEnumScalar() { 1880SN/A ScalarMatchFound = false; 1890SN/A} 1900SN/A 1910SN/Abool Input::matchEnumScalar(const char *Str, bool) { 1920SN/A if (ScalarMatchFound) 19310337SN/A return false; 1940SN/A if (ScalarHNode *SN = dyn_cast<ScalarHNode>(CurrentNode)) { 1950SN/A if (SN->value().equals(Str)) { 1960SN/A ScalarMatchFound = true; 1970SN/A return true; 1980SN/A } 1990SN/A } 2000SN/A return false; 2010SN/A} 2020SN/A 2030SN/Avoid Input::endEnumScalar() { 2040SN/A if (!ScalarMatchFound) { 2050SN/A setError(CurrentNode, "unknown enumerated scalar"); 2060SN/A } 2070SN/A} 2080SN/A 2090SN/Abool Input::beginBitSetScalar(bool &DoClear) { 2100SN/A BitValuesUsed.clear(); 2110SN/A if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) { 2120SN/A BitValuesUsed.insert(BitValuesUsed.begin(), SQ->Entries.size(), false); 2130SN/A } else { 2140SN/A setError(CurrentNode, "expected sequence of bit values"); 2150SN/A } 2160SN/A DoClear = true; 2170SN/A return true; 2180SN/A} 2190SN/A 2200SN/Abool Input::bitSetMatch(const char *Str, bool) { 2211639SN/A if (EC) 2220SN/A return false; 2230SN/A if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) { 2240SN/A unsigned Index = 0; 2250SN/A for (std::vector<HNode *>::iterator i = SQ->Entries.begin(), 2260SN/A End = SQ->Entries.end(); i != End; ++i) { 2279595SN/A if (ScalarHNode *SN = dyn_cast<ScalarHNode>(*i)) { 2289595SN/A if (SN->value().equals(Str)) { 2290SN/A BitValuesUsed[Index] = true; 2300SN/A return true; 2310SN/A } 2320SN/A } else { 2330SN/A setError(CurrentNode, "unexpected scalar in sequence of bit values"); 2340SN/A } 2350SN/A ++Index; 2360SN/A } 2370SN/A } else { 2380SN/A setError(CurrentNode, "expected sequence of bit values"); 2390SN/A } 2400SN/A return false; 2419595SN/A} 2420SN/A 2430SN/Avoid Input::endBitSetScalar() { 2440SN/A if (EC) 2450SN/A return; 2460SN/A if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) { 2470SN/A assert(BitValuesUsed.size() == SQ->Entries.size()); 2480SN/A for (unsigned i = 0; i < SQ->Entries.size(); ++i) { 2499595SN/A if (!BitValuesUsed[i]) { 2509595SN/A setError(SQ->Entries[i], "unknown bit value"); 2510SN/A return; 2520SN/A } 2530SN/A } 2540SN/A } 2550SN/A} 2560SN/A 2570SN/Avoid Input::scalarString(StringRef &S) { 2580SN/A if (ScalarHNode *SN = dyn_cast<ScalarHNode>(CurrentNode)) { 2590SN/A S = SN->value(); 2600SN/A } else { 2610SN/A setError(CurrentNode, "unexpected scalar"); 2620SN/A } 2630SN/A} 2649595SN/A 2650SN/Avoid Input::setError(HNode *hnode, const Twine &message) { 2660SN/A this->setError(hnode->_node, message); 2670SN/A} 2680SN/A 2690SN/Avoid Input::setError(Node *node, const Twine &message) { 2700SN/A Strm->printError(node, message); 2710SN/A EC = make_error_code(errc::invalid_argument); 2720SN/A} 2730SN/A 2740SN/AInput::HNode *Input::createHNodes(Node *N) { 2750SN/A SmallString<128> StringStorage; 2760SN/A if (ScalarNode *SN = dyn_cast<ScalarNode>(N)) { 2770SN/A StringRef KeyStr = SN->getValue(StringStorage); 2780SN/A if (!StringStorage.empty()) { 2791639SN/A // Copy string to permanent storage 2801639SN/A unsigned Len = StringStorage.size(); 2810SN/A char *Buf = StringAllocator.Allocate<char>(Len); 2820SN/A memcpy(Buf, &StringStorage[0], Len); 2830SN/A KeyStr = StringRef(Buf, Len); 2840SN/A } 2851639SN/A return new ScalarHNode(N, KeyStr); 2861639SN/A } else if (SequenceNode *SQ = dyn_cast<SequenceNode>(N)) { 2871639SN/A SequenceHNode *SQHNode = new SequenceHNode(N); 2880SN/A for (SequenceNode::iterator i = SQ->begin(), End = SQ->end(); i != End; 2891639SN/A ++i) { 2901639SN/A HNode *Entry = this->createHNodes(i); 2911639SN/A if (EC) 2921639SN/A break; 2931639SN/A SQHNode->Entries.push_back(Entry); 2941639SN/A } 2951639SN/A return SQHNode; 2961639SN/A } else if (MappingNode *Map = dyn_cast<MappingNode>(N)) { 2971639SN/A MapHNode *mapHNode = new MapHNode(N); 2981639SN/A for (MappingNode::iterator i = Map->begin(), End = Map->end(); i != End; 2991639SN/A ++i) { 3001639SN/A ScalarNode *KeyScalar = dyn_cast<ScalarNode>(i->getKey()); 3011639SN/A StringStorage.clear(); 3021639SN/A StringRef KeyStr = KeyScalar->getValue(StringStorage); 3031639SN/A if (!StringStorage.empty()) { 3041639SN/A // Copy string to permanent storage 3051639SN/A unsigned Len = StringStorage.size(); 3061639SN/A char *Buf = StringAllocator.Allocate<char>(Len); 3070SN/A memcpy(Buf, &StringStorage[0], Len); 3081639SN/A KeyStr = StringRef(Buf, Len); 3091639SN/A } 3101639SN/A HNode *ValueHNode = this->createHNodes(i->getValue()); 3111639SN/A if (EC) 3121639SN/A break; 3131639SN/A mapHNode->Mapping[KeyStr] = ValueHNode; 3141639SN/A } 3151639SN/A return mapHNode; 3161639SN/A } else if (isa<NullNode>(N)) { 3171639SN/A return new EmptyHNode(N); 3181639SN/A } else { 3191639SN/A setError(N, "unknown node kind"); 3201639SN/A return NULL; 3211639SN/A } 3221639SN/A} 3231639SN/A 3241639SN/Abool Input::MapHNode::isValidKey(StringRef Key) { 3251639SN/A for (SmallVector<const char *, 6>::iterator i = ValidKeys.begin(), 3260SN/A End = ValidKeys.end(); i != End; ++i) { 3271639SN/A if (Key.equals(*i)) 3281639SN/A return true; 3291639SN/A } 3301639SN/A return false; 3311639SN/A} 3321639SN/A 3331639SN/Avoid Input::setError(const Twine &Message) { 3341639SN/A this->setError(CurrentNode, Message); 3351639SN/A} 3361639SN/A 3371639SN/AInput::MapHNode::~MapHNode() { 3381639SN/A for (MapHNode::NameToNode::iterator i = Mapping.begin(), End = Mapping.end(); 3391639SN/A i != End; ++i) { 3401639SN/A delete i->second; 3411639SN/A } 3421639SN/A} 3431639SN/A 3440SN/AInput::SequenceHNode::~SequenceHNode() { 3451639SN/A for (std::vector<HNode*>::iterator i = Entries.begin(), End = Entries.end(); 3461639SN/A i != End; ++i) { 3471639SN/A delete *i; 3481639SN/A } 3491639SN/A} 3501639SN/A 3511639SN/A 3521639SN/A 3531639SN/A//===----------------------------------------------------------------------===// 3541639SN/A// Output 3551639SN/A//===----------------------------------------------------------------------===// 3561639SN/A 3571639SN/AOutput::Output(raw_ostream &yout, void *context) 3580SN/A : IO(context), 3591639SN/A Out(yout), 3600SN/A Column(0), 3611639SN/A ColumnAtFlowStart(0), 3621639SN/A NeedBitValueComma(false), 3631639SN/A NeedFlowSequenceComma(false), 3641639SN/A EnumerationMatchFound(false), 3651639SN/A NeedsNewLine(false) { 3661639SN/A} 3671639SN/A 3680SN/AOutput::~Output() { 3691639SN/A} 3701639SN/A 3711639SN/Abool Output::outputting() { 3720SN/A return true; 3730SN/A} 3741639SN/A 3751639SN/Avoid Output::beginMapping() { 3760SN/A StateStack.push_back(inMapFirstKey); 3770SN/A NeedsNewLine = true; 3780SN/A} 3790SN/A 3800SN/Avoid Output::endMapping() { 3810SN/A StateStack.pop_back(); 3820SN/A} 3830SN/A 3840SN/Abool Output::preflightKey(const char *Key, bool Required, bool SameAsDefault, 3850SN/A bool &UseDefault, void *&) { 3860SN/A UseDefault = false; 3870SN/A if (Required || !SameAsDefault) { 3880SN/A this->newLineCheck(); 3890SN/A this->paddedKey(Key); 3900SN/A return true; 3910SN/A } 3920SN/A return false; 3930SN/A} 3940SN/A 3950SN/Avoid Output::postflightKey(void *) { 3960SN/A if (StateStack.back() == inMapFirstKey) { 3970SN/A StateStack.pop_back(); 3980SN/A StateStack.push_back(inMapOtherKey); 3990SN/A } 4000SN/A} 4010SN/A 4020SN/Avoid Output::beginDocuments() { 4030SN/A this->outputUpToEndOfLine("---"); 4040SN/A} 4050SN/A 4060SN/Abool Output::preflightDocument(unsigned index) { 4070SN/A if (index > 0) 4080SN/A this->outputUpToEndOfLine("\n---"); 4090SN/A return true; 4100SN/A} 4110SN/A 4120SN/Avoid Output::postflightDocument() { 4130SN/A} 4140SN/A 4150SN/Avoid Output::endDocuments() { 4160SN/A output("\n...\n"); 4170SN/A} 4180SN/A 4190SN/Aunsigned Output::beginSequence() { 4200SN/A StateStack.push_back(inSeq); 4210SN/A NeedsNewLine = true; 4229595SN/A return 0; 4239595SN/A} 4240SN/A 4250SN/Avoid Output::endSequence() { 4260SN/A StateStack.pop_back(); 4270SN/A} 4289595SN/A 4290SN/Abool Output::preflightElement(unsigned, void *&) { 4300SN/A return true; 4310SN/A} 4320SN/A 4330SN/Avoid Output::postflightElement(void *) { 4340SN/A} 4350SN/A 4360SN/Aunsigned Output::beginFlowSequence() { 4370SN/A StateStack.push_back(inFlowSeq); 4380SN/A this->newLineCheck(); 4390SN/A ColumnAtFlowStart = Column; 4400SN/A output("[ "); 4410SN/A NeedFlowSequenceComma = false; 4420SN/A return 0; 4430SN/A} 4440SN/A 4450SN/Avoid Output::endFlowSequence() { 4460SN/A StateStack.pop_back(); 4470SN/A this->outputUpToEndOfLine(" ]"); 4480SN/A} 4490SN/A 4500SN/Abool Output::preflightFlowElement(unsigned, void *&) { 4510SN/A if (NeedFlowSequenceComma) 4524402SN/A output(", "); 4530SN/A if (Column > 70) { 4540SN/A output("\n"); 4550SN/A for (int i = 0; i < ColumnAtFlowStart; ++i) 4560SN/A output(" "); 4570SN/A Column = ColumnAtFlowStart; 4580SN/A output(" "); 4590SN/A } 4600SN/A return true; 4610SN/A} 4620SN/A 4639595SN/Avoid Output::postflightFlowElement(void *) { 4649595SN/A NeedFlowSequenceComma = true; 4650SN/A} 4660SN/A 4670SN/Avoid Output::beginEnumScalar() { 4680SN/A EnumerationMatchFound = false; 4690SN/A} 4709595SN/A 4710SN/Abool Output::matchEnumScalar(const char *Str, bool Match) { 4720SN/A if (Match && !EnumerationMatchFound) { 4730SN/A this->newLineCheck(); 4740SN/A this->outputUpToEndOfLine(Str); 4750SN/A EnumerationMatchFound = true; 4760SN/A } 4770SN/A return false; 4780SN/A} 4790SN/A 4800SN/Avoid Output::endEnumScalar() { 4810SN/A if (!EnumerationMatchFound) 4829595SN/A llvm_unreachable("bad runtime enum value"); 4839595SN/A} 4840SN/A 4850SN/Abool Output::beginBitSetScalar(bool &DoClear) { 4860SN/A this->newLineCheck(); 4870SN/A output("[ "); 4880SN/A NeedBitValueComma = false; 4899595SN/A DoClear = false; 4900SN/A return true; 4910SN/A} 4920SN/A 4930SN/Abool Output::bitSetMatch(const char *Str, bool Matches) { 4940SN/A if (Matches) { 4950SN/A if (NeedBitValueComma) 4960SN/A output(", "); 4970SN/A this->output(Str); 4980SN/A NeedBitValueComma = true; 4990SN/A } 5000SN/A return false; 5010SN/A} 5020SN/A 5030SN/Avoid Output::endBitSetScalar() { 5041639SN/A this->outputUpToEndOfLine(" ]"); 5051639SN/A} 5061639SN/A 5071639SN/Avoid Output::scalarString(StringRef &S) { 5081639SN/A this->newLineCheck(); 5091639SN/A if (S.find('\n') == StringRef::npos) { 5101639SN/A // No embedded new-line chars, just print string. 5111639SN/A this->outputUpToEndOfLine(S); 5121639SN/A return; 5131639SN/A } 5141639SN/A unsigned i = 0; 5151639SN/A unsigned j = 0; 5160SN/A unsigned End = S.size(); 5170SN/A output("'"); // Starting single quote. 5180SN/A const char *Base = S.data(); 5190SN/A while (j < End) { 5200SN/A // Escape a single quote by doubling it. 5210SN/A if (S[j] == '\'') { 5220SN/A output(StringRef(&Base[i], j - i + 1)); 5230SN/A output("'"); 5240SN/A i = j + 1; 5250SN/A } 5260SN/A ++j; 5270SN/A } 5280SN/A output(StringRef(&Base[i], j - i)); 5290SN/A this->outputUpToEndOfLine("'"); // Ending single quote. 5300SN/A} 5310SN/A 5320SN/Avoid Output::setError(const Twine &message) { 5330SN/A} 5340SN/A 5350SN/Avoid Output::output(StringRef s) { 5360SN/A Column += s.size(); 5370SN/A Out << s; 5380SN/A} 5394536SN/A 5400SN/Avoid Output::outputUpToEndOfLine(StringRef s) { 5410SN/A this->output(s); 5420SN/A if (StateStack.empty() || StateStack.back() != inFlowSeq) 5434536SN/A NeedsNewLine = true; 5440SN/A} 5454536SN/A 5460SN/Avoid Output::outputNewLine() { 5470SN/A Out << "\n"; 5484536SN/A Column = 0; 5490SN/A} 5500SN/A 5510SN/A// if seq at top, indent as if map, then add "- " 5520SN/A// if seq in middle, use "- " if firstKey, else use " " 5530SN/A// 5540SN/A 5550SN/Avoid Output::newLineCheck() { 5560SN/A if (!NeedsNewLine) 5570SN/A return; 5580SN/A NeedsNewLine = false; 5590SN/A 5600SN/A this->outputNewLine(); 5614536SN/A 5624536SN/A assert(StateStack.size() > 0); 5634536SN/A unsigned Indent = StateStack.size() - 1; 5644536SN/A bool OutputDash = false; 5650SN/A 5660SN/A if (StateStack.back() == inSeq) { 5670SN/A OutputDash = true; 5680SN/A } else if ((StateStack.size() > 1) && (StateStack.back() == inMapFirstKey) && 5690SN/A (StateStack[StateStack.size() - 2] == inSeq)) { 5700SN/A --Indent; 5710SN/A OutputDash = true; 5720SN/A } 5730SN/A 5740SN/A for (unsigned i = 0; i < Indent; ++i) { 5750SN/A output(" "); 5760SN/A } 5770SN/A if (OutputDash) { 5780SN/A output("- "); 5790SN/A } 5800SN/A 5810SN/A} 5820SN/A 5830SN/Avoid Output::paddedKey(StringRef key) { 5840SN/A output(key); 5850SN/A output(":"); 5860SN/A const char *spaces = " "; 5870SN/A if (key.size() < strlen(spaces)) 5880SN/A output(&spaces[key.size()]); 5890SN/A else 5900SN/A output(" "); 5910SN/A} 5920SN/A 5930SN/A//===----------------------------------------------------------------------===// 5940SN/A// traits for built-in types 5950SN/A//===----------------------------------------------------------------------===// 5960SN/A 5970SN/Avoid ScalarTraits<bool>::output(const bool &Val, void *, raw_ostream &Out) { 5980SN/A Out << (Val ? "true" : "false"); 5990SN/A} 6009595SN/A 6010SN/AStringRef ScalarTraits<bool>::input(StringRef Scalar, void *, bool &Val) { 6020SN/A if (Scalar.equals("true")) { 6030SN/A Val = true; 6040SN/A return StringRef(); 6050SN/A } else if (Scalar.equals("false")) { 6060SN/A Val = false; 6070SN/A return StringRef(); 6080SN/A } 6099595SN/A return "invalid boolean"; 6100SN/A} 6110SN/A 6120SN/Avoid ScalarTraits<StringRef>::output(const StringRef &Val, void *, 6130SN/A raw_ostream &Out) { 6140SN/A Out << Val; 6150SN/A} 6160SN/A 6170SN/AStringRef ScalarTraits<StringRef>::input(StringRef Scalar, void *, 6180SN/A StringRef &Val) { 6190SN/A Val = Scalar; 6200SN/A return StringRef(); 6210SN/A} 6220SN/A 6230SN/Avoid ScalarTraits<uint8_t>::output(const uint8_t &Val, void *, 6240SN/A raw_ostream &Out) { 6250SN/A // use temp uin32_t because ostream thinks uint8_t is a character 6260SN/A uint32_t Num = Val; 6270SN/A Out << Num; 6280SN/A} 6290SN/A 6300SN/AStringRef ScalarTraits<uint8_t>::input(StringRef Scalar, void *, uint8_t &Val) { 6310SN/A unsigned long long n; 6320SN/A if (getAsUnsignedInteger(Scalar, 0, n)) 6330SN/A return "invalid number"; 6340SN/A if (n > 0xFF) 6350SN/A return "out of range number"; 6360SN/A Val = n; 6370SN/A return StringRef(); 6380SN/A} 6390SN/A 6400SN/Avoid ScalarTraits<uint16_t>::output(const uint16_t &Val, void *, 6410SN/A raw_ostream &Out) { 6420SN/A Out << Val; 6430SN/A} 64411429Sserb 6450SN/AStringRef ScalarTraits<uint16_t>::input(StringRef Scalar, void *, 6460SN/A uint16_t &Val) { 6470SN/A unsigned long long n; 6480SN/A if (getAsUnsignedInteger(Scalar, 0, n)) 6490SN/A return "invalid number"; 6500SN/A if (n > 0xFFFF) 6510SN/A return "out of range number"; 6520SN/A Val = n; 6530SN/A return StringRef(); 6540SN/A} 6550SN/A 6560SN/Avoid ScalarTraits<uint32_t>::output(const uint32_t &Val, void *, 6570SN/A raw_ostream &Out) { 6580SN/A Out << Val; 6590SN/A} 6600SN/A 6610SN/AStringRef ScalarTraits<uint32_t>::input(StringRef Scalar, void *, 6620SN/A uint32_t &Val) { 66311429Sserb unsigned long long n; 6640SN/A if (getAsUnsignedInteger(Scalar, 0, n)) 66511429Sserb return "invalid number"; 6660SN/A if (n > 0xFFFFFFFFUL) 6670SN/A return "out of range number"; 6680SN/A Val = n; 6690SN/A return StringRef(); 6700SN/A} 6710SN/A 6720SN/Avoid ScalarTraits<uint64_t>::output(const uint64_t &Val, void *, 6730SN/A raw_ostream &Out) { 6740SN/A Out << Val; 67511429Sserb} 6760SN/A 6770SN/AStringRef ScalarTraits<uint64_t>::input(StringRef Scalar, void *, 6780SN/A uint64_t &Val) { 6790SN/A unsigned long long N; 6800SN/A if (getAsUnsignedInteger(Scalar, 0, N)) 6810SN/A return "invalid number"; 6820SN/A Val = N; 6830SN/A return StringRef(); 6840SN/A} 6850SN/A 6860SN/Avoid ScalarTraits<int8_t>::output(const int8_t &Val, void *, raw_ostream &Out) { 6870SN/A // use temp in32_t because ostream thinks int8_t is a character 6880SN/A int32_t Num = Val; 6890SN/A Out << Num; 6900SN/A} 6910SN/A 6920SN/AStringRef ScalarTraits<int8_t>::input(StringRef Scalar, void *, int8_t &Val) { 6930SN/A long long N; 6940SN/A if (getAsSignedInteger(Scalar, 0, N)) 69510089SN/A return "invalid number"; 6960SN/A if ((N > 127) || (N < -128)) 6970SN/A return "out of range number"; 6980SN/A Val = N; 6990SN/A return StringRef(); 7000SN/A} 7010SN/A 7020SN/Avoid ScalarTraits<int16_t>::output(const int16_t &Val, void *, 7030SN/A raw_ostream &Out) { 7040SN/A Out << Val; 7050SN/A} 7060SN/A 7070SN/AStringRef ScalarTraits<int16_t>::input(StringRef Scalar, void *, int16_t &Val) { 7080SN/A long long N; 7090SN/A if (getAsSignedInteger(Scalar, 0, N)) 7100SN/A return "invalid number"; 7110SN/A if ((N > INT16_MAX) || (N < INT16_MIN)) 7120SN/A return "out of range number"; 7130SN/A Val = N; 7140SN/A return StringRef(); 7150SN/A} 7160SN/A 7170SN/Avoid ScalarTraits<int32_t>::output(const int32_t &Val, void *, 7180SN/A raw_ostream &Out) { 7190SN/A Out << Val; 7200SN/A} 7210SN/A 7220SN/AStringRef ScalarTraits<int32_t>::input(StringRef Scalar, void *, int32_t &Val) { 7230SN/A long long N; 7240SN/A if (getAsSignedInteger(Scalar, 0, N)) 7250SN/A return "invalid number"; 7260SN/A if ((N > INT32_MAX) || (N < INT32_MIN)) 7270SN/A return "out of range number"; 7280SN/A Val = N; 7290SN/A return StringRef(); 7300SN/A} 7310SN/A 7320SN/Avoid ScalarTraits<int64_t>::output(const int64_t &Val, void *, 7330SN/A raw_ostream &Out) { 7340SN/A Out << Val; 7350SN/A} 7360SN/A 7370SN/AStringRef ScalarTraits<int64_t>::input(StringRef Scalar, void *, int64_t &Val) { 7380SN/A long long N; 7390SN/A if (getAsSignedInteger(Scalar, 0, N)) 7400SN/A return "invalid number"; 7410SN/A Val = N; 7420SN/A return StringRef(); 7430SN/A} 7440SN/A 7450SN/Avoid ScalarTraits<double>::output(const double &Val, void *, raw_ostream &Out) { 7460SN/A Out << format("%g", Val); 7470SN/A} 7480SN/A 7490SN/AStringRef ScalarTraits<double>::input(StringRef Scalar, void *, double &Val) { 7500SN/A SmallString<32> buff(Scalar.begin(), Scalar.end()); 7510SN/A char *end; 7520SN/A Val = strtod(buff.c_str(), &end); 7530SN/A if (*end != '\0') 7540SN/A return "invalid floating point number"; 7550SN/A return StringRef(); 7560SN/A} 7570SN/A 7580SN/Avoid ScalarTraits<float>::output(const float &Val, void *, raw_ostream &Out) { 7590SN/A Out << format("%g", Val); 7600SN/A} 7610SN/A 7620SN/AStringRef ScalarTraits<float>::input(StringRef Scalar, void *, float &Val) { 7630SN/A SmallString<32> buff(Scalar.begin(), Scalar.end()); 7640SN/A char *end; 7650SN/A Val = strtod(buff.c_str(), &end); 7660SN/A if (*end != '\0') 7670SN/A return "invalid floating point number"; 7680SN/A return StringRef(); 7690SN/A} 7700SN/A 7710SN/Avoid ScalarTraits<Hex8>::output(const Hex8 &Val, void *, raw_ostream &Out) { 7720SN/A uint8_t Num = Val; 7730SN/A Out << format("0x%02X", Num); 7740SN/A} 7750SN/A 7760SN/AStringRef ScalarTraits<Hex8>::input(StringRef Scalar, void *, Hex8 &Val) { 7770SN/A unsigned long long n; 7780SN/A if (getAsUnsignedInteger(Scalar, 0, n)) 7790SN/A return "invalid hex8 number"; 7800SN/A if (n > 0xFF) 7810SN/A return "out of range hex8 number"; 7820SN/A Val = n; 7830SN/A return StringRef(); 7840SN/A} 7850SN/A 7860SN/Avoid ScalarTraits<Hex16>::output(const Hex16 &Val, void *, raw_ostream &Out) { 7870SN/A uint16_t Num = Val; 7880SN/A Out << format("0x%04X", Num); 7890SN/A} 7900SN/A 7910SN/AStringRef ScalarTraits<Hex16>::input(StringRef Scalar, void *, Hex16 &Val) { 7920SN/A unsigned long long n; 7930SN/A if (getAsUnsignedInteger(Scalar, 0, n)) 7940SN/A return "invalid hex16 number"; 7950SN/A if (n > 0xFFFF) 7960SN/A return "out of range hex16 number"; 7970SN/A Val = n; 7980SN/A return StringRef(); 7990SN/A} 8000SN/A 8010SN/Avoid ScalarTraits<Hex32>::output(const Hex32 &Val, void *, raw_ostream &Out) { 8020SN/A uint32_t Num = Val; 8030SN/A Out << format("0x%08X", Num); 8040SN/A} 8050SN/A 8060SN/AStringRef ScalarTraits<Hex32>::input(StringRef Scalar, void *, Hex32 &Val) { 8070SN/A unsigned long long n; 8080SN/A if (getAsUnsignedInteger(Scalar, 0, n)) 8090SN/A return "invalid hex32 number"; 8100SN/A if (n > 0xFFFFFFFFUL) 8110SN/A return "out of range hex32 number"; 8120SN/A Val = n; 8130SN/A return StringRef(); 8140SN/A} 8150SN/A 8160SN/Avoid ScalarTraits<Hex64>::output(const Hex64 &Val, void *, raw_ostream &Out) { 8170SN/A uint64_t Num = Val; 8180SN/A Out << format("0x%016llX", Num); 8190SN/A} 8200SN/A 8210SN/AStringRef ScalarTraits<Hex64>::input(StringRef Scalar, void *, Hex64 &Val) { 8220SN/A unsigned long long Num; 8230SN/A if (getAsUnsignedInteger(Scalar, 0, Num)) 8240SN/A return "invalid hex64 number"; 8250SN/A Val = Num; 8260SN/A return StringRef(); 8270SN/A} 8280SN/A