CbC/CbC_llvm: lib/Support/YAMLParser.cpp comparison

comparison lib/Support/YAMLParser.cpp @ 77:54457678186b LLVM3.6

LLVM 3.6

author	Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date	Mon, 08 Sep 2014 22:06:00 +0900
parents	95c75e76d11b
children	60c9769439b8

comparison

equal deleted inserted replaced

-:e874dbf0ad9d
+:54457678186b
 namespace llvm {
 namespace yaml {
 /// @brief Scans YAML tokens from a MemoryBuffer.
 class Scanner {
 public:
-Scanner(const StringRef Input, SourceMgr &SM);
+Scanner(StringRef Input, SourceMgr &SM);
-Scanner(MemoryBuffer *Buffer, SourceMgr &SM_);
+Scanner(MemoryBufferRef Buffer, SourceMgr &SM_);
 /// @brief Parse the next token and return it without popping it.
 Token &peekNext();
 /// @brief Parse the next token and pop it from the queue.
 bool failed() {
 return Failed;
 }
 private:
+void init(MemoryBufferRef Buffer);
 StringRef currentInput() {
 return StringRef(Current, End - Current);
 }
 /// @brief Decode a UTF-8 minimal well-formed code unit subsequence starting
 ///
 /// @returns A StringRef starting at Cur which covers the longest contiguous
 ///          sequence of ns-uri-char.
 StringRef scan_ns_uri_char();
-/// @brief Scan ns-plain-one-line[133] starting at \a Cur.
-StringRef scan_ns_plain_one_line();
 /// @brief Consume a minimal well-formed code unit subsequence starting at
 ///        \a Cur. Return false if it is not the same Unicode scalar value as
 ///        \a Expected. This updates \a Column.
 bool consume(uint32_t Expected);
 /// @brief The SourceMgr used for diagnostics and buffer management.
 SourceMgr &SM;
 /// @brief The original input.
-MemoryBuffer *InputBuffer;
+MemoryBufferRef InputBuffer;
 /// @brief The current position of the scanner.
 StringRef::iterator Current;
 /// @brief The end of the input (one past the last character).
 EscapedInput.push_back(*i);
 }
 return EscapedInput;
 }
-Scanner::Scanner(StringRef Input, SourceMgr &sm)
+Scanner::Scanner(StringRef Input, SourceMgr &sm) : SM(sm) {
-: SM(sm)
+init(MemoryBufferRef(Input, "YAML"));
-, Indent(-1)
+}
-, Column(0)
-, Line(0)
+Scanner::Scanner(MemoryBufferRef Buffer, SourceMgr &SM_) : SM(SM_) {
-, FlowLevel(0)
+init(Buffer);
-, IsStartOfStream(true)
+}
-, IsSimpleKeyAllowed(true)
-, Failed(false) {
+void Scanner::init(MemoryBufferRef Buffer) {
-InputBuffer = MemoryBuffer::getMemBuffer(Input, "YAML");
+InputBuffer = Buffer;
-SM.AddNewSourceBuffer(InputBuffer, SMLoc());
+Current = InputBuffer.getBufferStart();
-Current = InputBuffer->getBufferStart();
+End = InputBuffer.getBufferEnd();
-End = InputBuffer->getBufferEnd();
+Indent = -1;
-}
+Column = 0;
+Line = 0;
-Scanner::Scanner(MemoryBuffer *Buffer, SourceMgr &SM_)
+FlowLevel = 0;
-: SM(SM_)
+IsStartOfStream = true;
-, InputBuffer(Buffer)
+IsSimpleKeyAllowed = true;
-, Current(InputBuffer->getBufferStart())
+Failed = false;
-, End(InputBuffer->getBufferEnd())
+std::unique_ptr<MemoryBuffer> InputBufferOwner =
-, Indent(-1)
+MemoryBuffer::getMemBuffer(Buffer);
-, Column(0)
+SM.AddNewSourceBuffer(std::move(InputBufferOwner), SMLoc());
-, Line(0)
-, FlowLevel(0)
-, IsStartOfStream(true)
-, IsSimpleKeyAllowed(true)
-, Failed(false) {
-SM.AddNewSourceBuffer(InputBuffer, SMLoc());
 }
 Token &Scanner::peekNext() {
 // If the current token is a possible simple key, keep parsing until we
 // can confirm.
 ++Column;
 } else
 break;
 }
 return StringRef(Start, Current - Start);
-}
-StringRef Scanner::scan_ns_plain_one_line() {
-StringRef::iterator start = Current;
-// The first character must already be verified.
-++Current;
-while (true) {
-if (Current == End) {
-break;
-} else if (*Current == ':') {
-// Check if the next character is a ns-char.
-if (Current + 1 == End)
-break;
-StringRef::iterator i = skip_ns_char(Current + 1);
-if (Current + 1 != i) {
-Current = i;
-Column += 2; // Consume both the ':' and ns-char.
-} else
-break;
-} else if (*Current == '#') {
-// Check if the previous character was a ns-char.
-// The & 0x80 check is to check for the trailing byte of a utf-8
-if (*(Current - 1) & 0x80 || skip_ns_char(Current - 1) == Current) {
-++Current;
-++Column;
-} else
-break;
-} else {
-StringRef::iterator i = skip_nb_char(Current);
-if (i == Current)
-break;
-Current = i;
-++Column;
-}
-}
-return StringRef(start, Current - start);
 }
 bool Scanner::consume(uint32_t Expected) {
 if (Expected >= 0x80)
 report_fatal_error("Not dealing with this yet");
 setError("Unrecognized character while tokenizing.");
 return false;
 }
 Stream::Stream(StringRef Input, SourceMgr &SM)
-: scanner(new Scanner(Input, SM))
+: scanner(new Scanner(Input, SM)), CurrentDoc() {}
-, CurrentDoc(0) {}
+Stream::Stream(MemoryBufferRef InputBuffer, SourceMgr &SM)
-Stream::Stream(MemoryBuffer *InputBuffer, SourceMgr &SM)
+: scanner(new Scanner(InputBuffer, SM)), CurrentDoc() {}
-: scanner(new Scanner(InputBuffer, SM))
-, CurrentDoc(0) {}
 Stream::~Stream() {}
 bool Stream::failed() { return scanner->failed(); }
 void Stream::skip() {
 for (document_iterator i = begin(), e = end(); i != e; ++i)
 i->skip();
 }
-Node::Node(unsigned int Type, OwningPtr<Document> &D, StringRef A, StringRef T)
+Node::Node(unsigned int Type, std::unique_ptr<Document> &D, StringRef A,
-: Doc(D)
+StringRef T)
-, TypeID(Type)
+: Doc(D), TypeID(Type), Anchor(A), Tag(T) {
-, Anchor(A)
-, Tag(T) {
 SMLoc Start = SMLoc::getFromPointer(peekNext().Range.begin());
 SourceRange = SMRange(Start, Start);
 }
 std::string Node::getVerbatimTag() const {
 if (!Raw.empty() && Raw != "!") {
 std::string Ret;
 if (Raw.find_last_of('!') == 0) {
 Ret = Doc->getTagMap().find("!")->second;
 Ret += Raw.substr(1);
-return llvm_move(Ret);
+return std::move(Ret);
 } else if (Raw.startswith("!!")) {
 Ret = Doc->getTagMap().find("!!")->second;
 Ret += Raw.substr(2);
-return llvm_move(Ret);
+return std::move(Ret);
 } else {
 StringRef TagHandle = Raw.substr(0, Raw.find_last_of('!') + 1);
 std::map<StringRef, StringRef>::const_iterator It =
 Doc->getTagMap().find(TagHandle);
 if (It != Doc->getTagMap().end())
 T.Kind = Token::TK_Tag;
 T.Range = TagHandle;
 setError(Twine("Unknown tag handle ") + TagHandle, T);
 }
 Ret += Raw.substr(Raw.find_last_of('!') + 1);
-return llvm_move(Ret);
+return std::move(Ret);
 }
 }
 switch (getType()) {
 case NK_Null:
 }
 void MappingNode::increment() {
 if (failed()) {
 IsAtEnd = true;
-CurrentEntry = 0;
+CurrentEntry = nullptr;
 return;
 }
 if (CurrentEntry) {
 CurrentEntry->skip();
 if (Type == MT_Inline) {
 IsAtEnd = true;
-CurrentEntry = 0;
+CurrentEntry = nullptr;
 return;
 }
 }
 Token T = peekNext();
 if (T.Kind == Token::TK_Key || T.Kind == Token::TK_Scalar) {
 } else if (Type == MT_Block) {
 switch (T.Kind) {
 case Token::TK_BlockEnd:
 getNext();
 IsAtEnd = true;
-CurrentEntry = 0;
+CurrentEntry = nullptr;
 break;
 default:
 setError("Unexpected token. Expected Key or Block End", T);
 case Token::TK_Error:
 IsAtEnd = true;
-CurrentEntry = 0;
+CurrentEntry = nullptr;
 }
 } else {
 switch (T.Kind) {
 case Token::TK_FlowEntry:
 // Eat the flow entry and recurse.
 case Token::TK_FlowMappingEnd:
 getNext();
 case Token::TK_Error:
 // Set this to end iterator.
 IsAtEnd = true;
-CurrentEntry = 0;
+CurrentEntry = nullptr;
 break;
 default:
 setError( "Unexpected token. Expected Key, Flow Entry, or Flow "
 "Mapping End."
 , T);
 IsAtEnd = true;
-CurrentEntry = 0;
+CurrentEntry = nullptr;
 }
 }
 }
 void SequenceNode::increment() {
 if (failed()) {
 IsAtEnd = true;
-CurrentEntry = 0;
+CurrentEntry = nullptr;
 return;
 }
 if (CurrentEntry)
 CurrentEntry->skip();
 Token T = peekNext();
 if (SeqType == ST_Block) {
 switch (T.Kind) {
 case Token::TK_BlockEntry:
 getNext();
 CurrentEntry = parseBlockNode();
-if (CurrentEntry == 0) { // An error occurred.
+if (!CurrentEntry) { // An error occurred.
 IsAtEnd = true;
-CurrentEntry = 0;
+CurrentEntry = nullptr;
 }
 break;
 case Token::TK_BlockEnd:
 getNext();
 IsAtEnd = true;
-CurrentEntry = 0;
+CurrentEntry = nullptr;
 break;
 default:
 setError( "Unexpected token. Expected Block Entry or Block End."
 , T);
 case Token::TK_Error:
 IsAtEnd = true;
-CurrentEntry = 0;
+CurrentEntry = nullptr;
 }
 } else if (SeqType == ST_Indentless) {
 switch (T.Kind) {
 case Token::TK_BlockEntry:
 getNext();
 CurrentEntry = parseBlockNode();
-if (CurrentEntry == 0) { // An error occurred.
+if (!CurrentEntry) { // An error occurred.
 IsAtEnd = true;
-CurrentEntry = 0;
+CurrentEntry = nullptr;
 }
 break;
 default:
 case Token::TK_Error:
 IsAtEnd = true;
-CurrentEntry = 0;
+CurrentEntry = nullptr;
 }
 } else if (SeqType == ST_Flow) {
 switch (T.Kind) {
 case Token::TK_FlowEntry:
 // Eat the flow entry and recurse.
 case Token::TK_FlowSequenceEnd:
 getNext();
 case Token::TK_Error:
 // Set this to end iterator.
 IsAtEnd = true;
-CurrentEntry = 0;
+CurrentEntry = nullptr;
 break;
 case Token::TK_StreamEnd:
 case Token::TK_DocumentEnd:
 case Token::TK_DocumentStart:
 setError("Could not find closing ]!", T);
 // Set this to end iterator.
 IsAtEnd = true;
-CurrentEntry = 0;
+CurrentEntry = nullptr;
 break;
 default:
 if (!WasPreviousTokenFlowEntry) {
 setError("Expected , between entries!", T);
 IsAtEnd = true;
-CurrentEntry = 0;
+CurrentEntry = nullptr;
 break;
 }
 // Otherwise it must be a flow entry.
 CurrentEntry = parseBlockNode();
 if (!CurrentEntry) {
 break;
 }
 }
 }
-Document::Document(Stream &S) : stream(S), Root(0) {
+Document::Document(Stream &S) : stream(S), Root(nullptr) {
 // Tag maps starts with two default mappings.
 TagMap["!"] = "!";
 TagMap["!!"] = "tag:yaml.org,2002:";
 if (parseDirectives())
 getNext();
 return new (NodeAllocator) AliasNode(stream.CurrentDoc, T.Range.substr(1));
 case Token::TK_Anchor:
 if (AnchorInfo.Kind == Token::TK_Anchor) {
 setError("Already encountered an anchor for this node!", T);
-return 0;
+return nullptr;
 }
 AnchorInfo = getNext(); // Consume TK_Anchor.
 T = peekNext();
 goto parse_property;
 case Token::TK_Tag:
 if (TagInfo.Kind == Token::TK_Tag) {
 setError("Already encountered a tag for this node!", T);
-return 0;
+return nullptr;
 }
 TagInfo = getNext(); // Consume TK_Tag.
 T = peekNext();
 goto parse_property;
 default:
 default:
 // TODO: Properly handle tags. "[!!str ]" should resolve to !!str "", not
 //       !!null null.
 return new (NodeAllocator) NullNode(stream.CurrentDoc);
 case Token::TK_Error:
-return 0;
+return nullptr;
 }
 llvm_unreachable("Control flow shouldn't reach here.");
-return 0;
+return nullptr;
 }
 bool Document::parseDirectives() {
 bool isDirective = false;
 while (true) {

Mercurial > hg > CbC > CbC_llvm

comparison lib/Support/YAMLParser.cpp @ 77:54457678186b LLVM3.6