Set the eol style to native for all files.

src/regex.h

-#pragma once
-
-#include <vector>
-#include <string>
-#include <ios>
-
-namespace YAML
-{
-	struct Stream;
-
-	enum REGEX_OP { REGEX_EMPTY, REGEX_MATCH, REGEX_RANGE, REGEX_OR, REGEX_AND, REGEX_NOT, REGEX_SEQ };
-
-	// simplified regular expressions
-	// . Only straightforward matches (no repeated characters)
-	// . Only matches from start of string
-	class RegEx
-	{
-	private:
-		struct Operator {
-			virtual ~Operator() {}
-			virtual int Match(const std::string& str, const RegEx& regex) const = 0;
-			virtual int Match(std::istream& in, const RegEx& regex) const = 0;
-		};
-
-		struct MatchOperator: public Operator {
-			virtual int Match(const std::string& str, const RegEx& regex) const;
-			virtual int Match(std::istream& in, const RegEx& regex) const;
-		};
-
-		struct RangeOperator: public Operator {
-			virtual int Match(const std::string& str, const RegEx& regex) const;
-			virtual int Match(std::istream& in, const RegEx& regex) const;
-		};
-
-		struct OrOperator: public Operator {
-			virtual int Match(const std::string& str, const RegEx& regex) const;
-			virtual int Match(std::istream& in, const RegEx& regex) const;
-		};
-
-		struct AndOperator: public Operator {
-			virtual int Match(const std::string& str, const RegEx& regex) const;
-			virtual int Match(std::istream& in, const RegEx& regex) const;
-		};
-
-		struct NotOperator: public Operator {
-			virtual int Match(const std::string& str, const RegEx& regex) const;
-			virtual int Match(std::istream& in, const RegEx& regex) const;
-		};
-
-		struct SeqOperator: public Operator {
-			virtual int Match(const std::string& str, const RegEx& regex) const;
-			virtual int Match(std::istream& in, const RegEx& regex) const;
-		};
-
-	public:
-		friend struct Operator;
-
-		RegEx();
-		RegEx(char ch);
-		RegEx(char a, char z);
-		RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ);
-		RegEx(const RegEx& rhs);
-		~RegEx();
-
-		RegEx& operator = (const RegEx& rhs);
-
-		bool Matches(char ch) const;
-		bool Matches(const std::string& str) const;
-		bool Matches(std::istream& in) const;
-		bool Matches(Stream& in) const;
-		int Match(const std::string& str) const;
-		int Match(std::istream& in) const;
-		int Match(Stream& in) const;
-
-		friend RegEx operator ! (const RegEx& ex);
-		friend RegEx operator || (const RegEx& ex1, const RegEx& ex2);
-		friend RegEx operator && (const RegEx& ex1, const RegEx& ex2);
-		friend RegEx operator + (const RegEx& ex1, const RegEx& ex2);
-
-	private:
-		RegEx(REGEX_OP op);
-		void SetOp();
-
-	private:
-		REGEX_OP m_op;
-		Operator *m_pOp;
-		char m_a, m_z;
-		std::vector <RegEx> m_params;
-	};
-}
+#pragma once
+
+#include <vector>
+#include <string>
+#include <ios>
+
+namespace YAML
+{
+	struct Stream;
+
+	enum REGEX_OP { REGEX_EMPTY, REGEX_MATCH, REGEX_RANGE, REGEX_OR, REGEX_AND, REGEX_NOT, REGEX_SEQ };
+
+	// simplified regular expressions
+	// . Only straightforward matches (no repeated characters)
+	// . Only matches from start of string
+	class RegEx
+	{
+	private:
+		struct Operator {
+			virtual ~Operator() {}
+			virtual int Match(const std::string& str, const RegEx& regex) const = 0;
+			virtual int Match(std::istream& in, const RegEx& regex) const = 0;
+		};
+
+		struct MatchOperator: public Operator {
+			virtual int Match(const std::string& str, const RegEx& regex) const;
+			virtual int Match(std::istream& in, const RegEx& regex) const;
+		};
+
+		struct RangeOperator: public Operator {
+			virtual int Match(const std::string& str, const RegEx& regex) const;
+			virtual int Match(std::istream& in, const RegEx& regex) const;
+		};
+
+		struct OrOperator: public Operator {
+			virtual int Match(const std::string& str, const RegEx& regex) const;
+			virtual int Match(std::istream& in, const RegEx& regex) const;
+		};
+
+		struct AndOperator: public Operator {
+			virtual int Match(const std::string& str, const RegEx& regex) const;
+			virtual int Match(std::istream& in, const RegEx& regex) const;
+		};
+
+		struct NotOperator: public Operator {
+			virtual int Match(const std::string& str, const RegEx& regex) const;
+			virtual int Match(std::istream& in, const RegEx& regex) const;
+		};
+
+		struct SeqOperator: public Operator {
+			virtual int Match(const std::string& str, const RegEx& regex) const;
+			virtual int Match(std::istream& in, const RegEx& regex) const;
+		};
+
+	public:
+		friend struct Operator;
+
+		RegEx();
+		RegEx(char ch);
+		RegEx(char a, char z);
+		RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ);
+		RegEx(const RegEx& rhs);
+		~RegEx();
+
+		RegEx& operator = (const RegEx& rhs);
+
+		bool Matches(char ch) const;
+		bool Matches(const std::string& str) const;
+		bool Matches(std::istream& in) const;
+		bool Matches(Stream& in) const;
+		int Match(const std::string& str) const;
+		int Match(std::istream& in) const;
+		int Match(Stream& in) const;
+
+		friend RegEx operator ! (const RegEx& ex);
+		friend RegEx operator || (const RegEx& ex1, const RegEx& ex2);
+		friend RegEx operator && (const RegEx& ex1, const RegEx& ex2);
+		friend RegEx operator + (const RegEx& ex1, const RegEx& ex2);
+
+	private:
+		RegEx(REGEX_OP op);
+		void SetOp();
+
+	private:
+		REGEX_OP m_op;
+		Operator *m_pOp;
+		char m_a, m_z;
+		std::vector <RegEx> m_params;
+	};
+}

src/scalar.cpp

-#include "crt.h"
-#include "scalar.h"
-#include "scanner.h"
-#include "token.h"
-#include "exceptions.h"
-#include "node.h"
-#include <sstream>
-
-namespace YAML
-{
-	Scalar::Scalar()
-	{
-	}
-
-	Scalar::~Scalar()
-	{
-	}
-
-	void Scalar::Parse(Scanner *pScanner, const ParserState& state)
-	{
-		Token& token = pScanner->peek();
-		m_data = token.value;
-		pScanner->pop();
-	}
-
-	void Scalar::Write(std::ostream& out, int indent, bool startedLine, bool onlyOneCharOnLine)
-	{
-		out << "\"";
-		for(unsigned i=0;i<m_data.size();i++) {
-			switch(m_data[i]) {
-				case '\\': out << "\\\\"; break;
-				case '\t': out << "\\t"; break;
-				case '\n': out << "\\n"; break;
-				case '\r': out << "\\r"; break;
-				default: out << m_data[i]; break;
-			}
-		}
-		out << "\"\n";
-	}
-
-	void Scalar::Read(std::string& s)
-	{
-		s = m_data;
-	}
-
-	void Scalar::Read(int& i)
-	{
-		std::stringstream data(m_data);
-		data >> i;
-		if(!data)
-			throw InvalidScalar();
-	}
-
-	void Scalar::Read(unsigned& u)
-	{
-		std::stringstream data(m_data);
-		data >> u;
-		if(!data)
-			throw InvalidScalar();
-	}
-
-	void Scalar::Read(long& l)
-	{
-		std::stringstream data(m_data);
-		data >> l;
-		if(!data)
-			throw InvalidScalar();
-	}
-	
-	void Scalar::Read(float& f)
-	{
-		std::stringstream data(m_data);
-		data >> f;
-		if(!data)
-			throw InvalidScalar();
-	}
-	
-	void Scalar::Read(double& d)
-	{
-		std::stringstream data(m_data);
-		data >> d;
-		if(!data)
-			throw InvalidScalar();
-	}
-
-	void Scalar::Read(char& c)
-	{
-		std::stringstream data(m_data);
-		data >> c;
-		if(!data)
-			throw InvalidScalar();
-	}
-
-	int Scalar::Compare(Content *pContent)
-	{
-		return -pContent->Compare(this);
-	}
-
-	int Scalar::Compare(Scalar *pScalar)
-	{
-		if(m_data < pScalar->m_data)
-			return -1;
-		else if(m_data > pScalar->m_data)
-			return 1;
-		else
-			return 0;
-	}
-}
+#include "crt.h"
+#include "scalar.h"
+#include "scanner.h"
+#include "token.h"
+#include "exceptions.h"
+#include "node.h"
+#include <sstream>
+
+namespace YAML
+{
+	Scalar::Scalar()
+	{
+	}
+
+	Scalar::~Scalar()
+	{
+	}
+
+	void Scalar::Parse(Scanner *pScanner, const ParserState& state)
+	{
+		Token& token = pScanner->peek();
+		m_data = token.value;
+		pScanner->pop();
+	}
+
+	void Scalar::Write(std::ostream& out, int indent, bool startedLine, bool onlyOneCharOnLine)
+	{
+		out << "\"";
+		for(unsigned i=0;i<m_data.size();i++) {
+			switch(m_data[i]) {
+				case '\\': out << "\\\\"; break;
+				case '\t': out << "\\t"; break;
+				case '\n': out << "\\n"; break;
+				case '\r': out << "\\r"; break;
+				default: out << m_data[i]; break;
+			}
+		}
+		out << "\"\n";
+	}
+
+	void Scalar::Read(std::string& s)
+	{
+		s = m_data;
+	}
+
+	void Scalar::Read(int& i)
+	{
+		std::stringstream data(m_data);
+		data >> i;
+		if(!data)
+			throw InvalidScalar();
+	}
+
+	void Scalar::Read(unsigned& u)
+	{
+		std::stringstream data(m_data);
+		data >> u;
+		if(!data)
+			throw InvalidScalar();
+	}
+
+	void Scalar::Read(long& l)
+	{
+		std::stringstream data(m_data);
+		data >> l;
+		if(!data)
+			throw InvalidScalar();
+	}
+	
+	void Scalar::Read(float& f)
+	{
+		std::stringstream data(m_data);
+		data >> f;
+		if(!data)
+			throw InvalidScalar();
+	}
+	
+	void Scalar::Read(double& d)
+	{
+		std::stringstream data(m_data);
+		data >> d;
+		if(!data)
+			throw InvalidScalar();
+	}
+
+	void Scalar::Read(char& c)
+	{
+		std::stringstream data(m_data);
+		data >> c;
+		if(!data)
+			throw InvalidScalar();
+	}
+
+	int Scalar::Compare(Content *pContent)
+	{
+		return -pContent->Compare(this);
+	}
+
+	int Scalar::Compare(Scalar *pScalar)
+	{
+		if(m_data < pScalar->m_data)
+			return -1;
+		else if(m_data > pScalar->m_data)
+			return 1;
+		else
+			return 0;
+	}
+}

src/scalar.h

-#pragma once
-
-#include "content.h"
-#include <string>
-
-namespace YAML
-{
-	class Scalar: public Content
-	{
-	public:
-		Scalar();
-		virtual ~Scalar();
-
-		virtual void Parse(Scanner *pScanner, const ParserState& state);
-		virtual void Write(std::ostream& out, int indent, bool startedLine, bool onlyOneCharOnLine);
-
-		virtual bool IsScalar() const { return true; }
-
-		// extraction
-		virtual void Read(std::string& s);
-		virtual void Read(int& i);
-		virtual void Read(unsigned& u);
-		virtual void Read(long& l);
-		virtual void Read(float& f);
-		virtual void Read(double& d);
-		virtual void Read(char& c);
-
-		// ordering
-		virtual int Compare(Content *pContent);
-		virtual int Compare(Scalar *pScalar);
-		virtual int Compare(Sequence *pSeq) { return -1; }
-		virtual int Compare(Map *pMap) { return -1; }
-
-	protected:
-		std::string m_data;
-	};
-}
+#pragma once
+
+#include "content.h"
+#include <string>
+
+namespace YAML
+{
+	class Scalar: public Content
+	{
+	public:
+		Scalar();
+		virtual ~Scalar();
+
+		virtual void Parse(Scanner *pScanner, const ParserState& state);
+		virtual void Write(std::ostream& out, int indent, bool startedLine, bool onlyOneCharOnLine);
+
+		virtual bool IsScalar() const { return true; }
+
+		// extraction
+		virtual void Read(std::string& s);
+		virtual void Read(int& i);
+		virtual void Read(unsigned& u);
+		virtual void Read(long& l);
+		virtual void Read(float& f);
+		virtual void Read(double& d);
+		virtual void Read(char& c);
+
+		// ordering
+		virtual int Compare(Content *pContent);
+		virtual int Compare(Scalar *pScalar);
+		virtual int Compare(Sequence *pSeq) { return -1; }
+		virtual int Compare(Map *pMap) { return -1; }
+
+	protected:
+		std::string m_data;
+	};
+}

src/scanner.cpp

-#include "crt.h"
-#include "scanner.h"
-#include "token.h"
-#include "exceptions.h"
-#include "exp.h"
-#include <cassert>
-
-namespace YAML
-{
-	Scanner::Scanner(std::istream& in)
-		: INPUT(in), m_startedStream(false), m_endedStream(false), m_simpleKeyAllowed(false), m_flowLevel(0)
-	{
-	}
-
-	Scanner::~Scanner()
-	{
-	}
-
-	// empty
-	// . Returns true if there are no more tokens to be read
-	bool Scanner::empty()
-	{
-		EnsureTokensInQueue();
-		return m_tokens.empty();
-	}
-
-	// pop
-	// . Simply removes the next token on the queue.
-	void Scanner::pop()
-	{
-		EnsureTokensInQueue();
-		if(!m_tokens.empty())
-			m_tokens.pop();
-	}
-
-	// peek
-	// . Returns (but does not remove) the next token on the queue.
-	Token& Scanner::peek()
-	{
-		EnsureTokensInQueue();
-		assert(!m_tokens.empty());  // should we be asserting here? I mean, we really just be checking
-		                            // if it's empty before peeking.
-
-		return m_tokens.front();
-	}
-
-	// EnsureTokensInQueue
-	// . Scan until there's a valid token at the front of the queue,
-	//   or we're sure the queue is empty.
-	void Scanner::EnsureTokensInQueue()
-	{
-		while(1) {
-			if(!m_tokens.empty()) {
-				Token& token = m_tokens.front();
-
-				// if this guy's valid, then we're done
-				if(token.status == TS_VALID)
-					return;
-
-				// here's where we clean up the impossible tokens
-				if(token.status == TS_INVALID) {
-					m_tokens.pop();
-					continue;
-				}
-
-				// note: what's left are the unverified tokens
-			}
-
-			// no token? maybe we've actually finished
-			if(m_endedStream)
-				return;
-
-			// no? then scan...
-			ScanNextToken();
-		}
-	}
-
-	// ScanNextToken
-	// . The main scanning function; here we branch out and
-	//   scan whatever the next token should be.
-	void Scanner::ScanNextToken()
-	{
-		if(m_endedStream)
-			return;
-
-		if(!m_startedStream)
-			return StartStream();
-
-		// get rid of whitespace, etc. (in between tokens it should be irrelevent)
-		ScanToNextToken();
-
-		// check the latest simple key
-		VerifySimpleKey();
-
-		// maybe need to end some blocks
-		PopIndentTo(INPUT.column);
-
-		// *****
-		// And now branch based on the next few characters!
-		// *****
-
-		// end of stream
-		if(INPUT.peek() == EOF)
-			return EndStream();
-
-		if(INPUT.column == 0 && INPUT.peek() == Keys::Directive)
-			return ScanDirective();
-
-		// document token
-		if(INPUT.column == 0 && Exp::DocStart.Matches(INPUT))
-			return ScanDocStart();
-
-		if(INPUT.column == 0 && Exp::DocEnd.Matches(INPUT))
-			return ScanDocEnd();
-
-		// flow start/end/entry
-		if(INPUT.peek() == Keys::FlowSeqStart || INPUT.peek() == Keys::FlowMapStart)
-			return ScanFlowStart();
-
-		if(INPUT.peek() == Keys::FlowSeqEnd || INPUT.peek() == Keys::FlowMapEnd)
-			return ScanFlowEnd();
-	
-		if(INPUT.peek() == Keys::FlowEntry)
-			return ScanFlowEntry();
-
-		// block/map stuff
-		if(Exp::BlockEntry.Matches(INPUT))
-			return ScanBlockEntry();
-
-		if((m_flowLevel == 0 ? Exp::Key : Exp::KeyInFlow).Matches(INPUT))
-			return ScanKey();
-
-		if((m_flowLevel == 0 ? Exp::Value : Exp::ValueInFlow).Matches(INPUT))
-			return ScanValue();
-
-		// alias/anchor
-		if(INPUT.peek() == Keys::Alias || INPUT.peek() == Keys::Anchor)
-			return ScanAnchorOrAlias();
-
-		// tag
-		if(INPUT.peek() == Keys::Tag)
-			return ScanTag();
-
-		// special scalars
-		if(m_flowLevel == 0 && (INPUT.peek() == Keys::LiteralScalar || INPUT.peek() == Keys::FoldedScalar))
-			return ScanBlockScalar();
-
-		if(INPUT.peek() == '\'' || INPUT.peek() == '\"')
-			return ScanQuotedScalar();
-
-		// plain scalars
-		if((m_flowLevel == 0 ? Exp::PlainScalar : Exp::PlainScalarInFlow).Matches(INPUT))
-			return ScanPlainScalar();
-
-		// don't know what it is!
-		throw ParserException(INPUT.line, INPUT.column, ErrorMsg::UNKNOWN_TOKEN);
-	}
-
-	// ScanToNextToken
-	// . Eats input until we reach the next token-like thing.
-	void Scanner::ScanToNextToken()
-	{
-		while(1) {
-			// first eat whitespace
-			while(IsWhitespaceToBeEaten(INPUT.peek()))
-				INPUT.eat(1);
-
-			// then eat a comment
-			if(Exp::Comment.Matches(INPUT)) {
-				// eat until line break
-				while(INPUT && !Exp::Break.Matches(INPUT))
-					INPUT.eat(1);
-			}
-
-			// if it's NOT a line break, then we're done!
-			if(!Exp::Break.Matches(INPUT))
-				break;
-
-			// otherwise, let's eat the line break and keep going
-			int n = Exp::Break.Match(INPUT);
-			INPUT.eat(n);
-
-			// oh yeah, and let's get rid of that simple key
-			VerifySimpleKey();
-
-			// new line - we may be able to accept a simple key now
-			if(m_flowLevel == 0)
-				m_simpleKeyAllowed = true;
-        }
-	}
-
-	///////////////////////////////////////////////////////////////////////
-	// Misc. helpers
-
-	// IsWhitespaceToBeEaten
-	// . We can eat whitespace if:
-	//   1. It's a space
-	//   2. It's a tab, and we're either:
-	//      a. In the flow context
-	//      b. In the block context but not where a simple key could be allowed
-	//         (i.e., not at the beginning of a line, or following '-', '?', or ':')
-	bool Scanner::IsWhitespaceToBeEaten(char ch)
-	{
-		if(ch == ' ')
-			return true;
-
-		if(ch == '\t' && (m_flowLevel >= 0 || !m_simpleKeyAllowed))
-			return true;
-
-		return false;
-	}
-
-	// StartStream
-	// . Set the initial conditions for starting a stream.
-	void Scanner::StartStream()
-	{
-		m_startedStream = true;
-		m_simpleKeyAllowed = true;
-		m_indents.push(-1);
-	}
-
-	// EndStream
-	// . Close out the stream, finish up, etc.
-	void Scanner::EndStream()
-	{
-		// force newline
-		if(INPUT.column > 0)
-			INPUT.column = 0;
-
-		PopIndentTo(-1);
-		VerifyAllSimpleKeys();
-
-		m_simpleKeyAllowed = false;
-		m_endedStream = true;
-	}
-
-	// PushIndentTo
-	// . Pushes an indentation onto the stack, and enqueues the
-	//   proper token (sequence start or mapping start).
-	// . Returns the token it generates (if any).
-	Token *Scanner::PushIndentTo(int column, bool sequence)
-	{
-		// are we in flow?
-		if(m_flowLevel > 0)
-			return 0;
-
-		// is this actually an indentation?
-		if(column <= m_indents.top())
-			return 0;
-
-		// now push
-		m_indents.push(column);
-		if(sequence)
-			m_tokens.push(Token(TT_BLOCK_SEQ_START, INPUT.line, INPUT.column));
-		else
-			m_tokens.push(Token(TT_BLOCK_MAP_START, INPUT.line, INPUT.column));
-
-		return &m_tokens.back();
-	}
-
-	// PopIndentTo
-	// . Pops indentations off the stack until we reach 'column' indentation,
-	//   and enqueues the proper token each time.
-	void Scanner::PopIndentTo(int column)
-	{
-		// are we in flow?
-		if(m_flowLevel > 0)
-			return;
-
-		// now pop away
-		while(!m_indents.empty() && m_indents.top() > column) {
-			m_indents.pop();
-			m_tokens.push(Token(TT_BLOCK_END, INPUT.line, INPUT.column));
-		}
-	}
-}
+#include "crt.h"
+#include "scanner.h"
+#include "token.h"
+#include "exceptions.h"
+#include "exp.h"
+#include <cassert>
+
+namespace YAML
+{
+	Scanner::Scanner(std::istream& in)
+		: INPUT(in), m_startedStream(false), m_endedStream(false), m_simpleKeyAllowed(false), m_flowLevel(0)
+	{
+	}
+
+	Scanner::~Scanner()
+	{
+	}
+
+	// empty
+	// . Returns true if there are no more tokens to be read
+	bool Scanner::empty()
+	{
+		EnsureTokensInQueue();
+		return m_tokens.empty();
+	}
+
+	// pop
+	// . Simply removes the next token on the queue.
+	void Scanner::pop()
+	{
+		EnsureTokensInQueue();
+		if(!m_tokens.empty())
+			m_tokens.pop();
+	}
+
+	// peek
+	// . Returns (but does not remove) the next token on the queue.
+	Token& Scanner::peek()
+	{
+		EnsureTokensInQueue();
+		assert(!m_tokens.empty());  // should we be asserting here? I mean, we really just be checking
+		                            // if it's empty before peeking.
+
+		return m_tokens.front();
+	}
+
+	// EnsureTokensInQueue
+	// . Scan until there's a valid token at the front of the queue,
+	//   or we're sure the queue is empty.
+	void Scanner::EnsureTokensInQueue()
+	{
+		while(1) {
+			if(!m_tokens.empty()) {
+				Token& token = m_tokens.front();
+
+				// if this guy's valid, then we're done
+				if(token.status == TS_VALID)
+					return;
+
+				// here's where we clean up the impossible tokens
+				if(token.status == TS_INVALID) {
+					m_tokens.pop();
+					continue;
+				}
+
+				// note: what's left are the unverified tokens
+			}
+
+			// no token? maybe we've actually finished
+			if(m_endedStream)
+				return;
+
+			// no? then scan...
+			ScanNextToken();
+		}
+	}
+
+	// ScanNextToken
+	// . The main scanning function; here we branch out and
+	//   scan whatever the next token should be.
+	void Scanner::ScanNextToken()
+	{
+		if(m_endedStream)
+			return;
+
+		if(!m_startedStream)
+			return StartStream();
+
+		// get rid of whitespace, etc. (in between tokens it should be irrelevent)
+		ScanToNextToken();
+
+		// check the latest simple key
+		VerifySimpleKey();
+
+		// maybe need to end some blocks
+		PopIndentTo(INPUT.column);
+
+		// *****
+		// And now branch based on the next few characters!
+		// *****
+
+		// end of stream
+		if(INPUT.peek() == EOF)
+			return EndStream();
+
+		if(INPUT.column == 0 && INPUT.peek() == Keys::Directive)
+			return ScanDirective();
+
+		// document token
+		if(INPUT.column == 0 && Exp::DocStart.Matches(INPUT))
+			return ScanDocStart();
+
+		if(INPUT.column == 0 && Exp::DocEnd.Matches(INPUT))
+			return ScanDocEnd();
+
+		// flow start/end/entry
+		if(INPUT.peek() == Keys::FlowSeqStart || INPUT.peek() == Keys::FlowMapStart)
+			return ScanFlowStart();
+
+		if(INPUT.peek() == Keys::FlowSeqEnd || INPUT.peek() == Keys::FlowMapEnd)
+			return ScanFlowEnd();
+	
+		if(INPUT.peek() == Keys::FlowEntry)
+			return ScanFlowEntry();
+
+		// block/map stuff
+		if(Exp::BlockEntry.Matches(INPUT))
+			return ScanBlockEntry();
+
+		if((m_flowLevel == 0 ? Exp::Key : Exp::KeyInFlow).Matches(INPUT))
+			return ScanKey();
+
+		if((m_flowLevel == 0 ? Exp::Value : Exp::ValueInFlow).Matches(INPUT))
+			return ScanValue();
+
+		// alias/anchor
+		if(INPUT.peek() == Keys::Alias || INPUT.peek() == Keys::Anchor)
+			return ScanAnchorOrAlias();
+
+		// tag
+		if(INPUT.peek() == Keys::Tag)
+			return ScanTag();
+
+		// special scalars
+		if(m_flowLevel == 0 && (INPUT.peek() == Keys::LiteralScalar || INPUT.peek() == Keys::FoldedScalar))
+			return ScanBlockScalar();
+
+		if(INPUT.peek() == '\'' || INPUT.peek() == '\"')
+			return ScanQuotedScalar();
+
+		// plain scalars
+		if((m_flowLevel == 0 ? Exp::PlainScalar : Exp::PlainScalarInFlow).Matches(INPUT))
+			return ScanPlainScalar();
+
+		// don't know what it is!
+		throw ParserException(INPUT.line, INPUT.column, ErrorMsg::UNKNOWN_TOKEN);
+	}
+
+	// ScanToNextToken
+	// . Eats input until we reach the next token-like thing.
+	void Scanner::ScanToNextToken()
+	{
+		while(1) {
+			// first eat whitespace
+			while(IsWhitespaceToBeEaten(INPUT.peek()))
+				INPUT.eat(1);
+
+			// then eat a comment
+			if(Exp::Comment.Matches(INPUT)) {
+				// eat until line break
+				while(INPUT && !Exp::Break.Matches(INPUT))
+					INPUT.eat(1);
+			}
+
+			// if it's NOT a line break, then we're done!
+			if(!Exp::Break.Matches(INPUT))
+				break;
+
+			// otherwise, let's eat the line break and keep going
+			int n = Exp::Break.Match(INPUT);
+			INPUT.eat(n);
+
+			// oh yeah, and let's get rid of that simple key
+			VerifySimpleKey();
+
+			// new line - we may be able to accept a simple key now
+			if(m_flowLevel == 0)
+				m_simpleKeyAllowed = true;
+        }
+	}
+
+	///////////////////////////////////////////////////////////////////////
+	// Misc. helpers
+
+	// IsWhitespaceToBeEaten
+	// . We can eat whitespace if:
+	//   1. It's a space
+	//   2. It's a tab, and we're either:
+	//      a. In the flow context
+	//      b. In the block context but not where a simple key could be allowed
+	//         (i.e., not at the beginning of a line, or following '-', '?', or ':')
+	bool Scanner::IsWhitespaceToBeEaten(char ch)
+	{
+		if(ch == ' ')
+			return true;
+
+		if(ch == '\t' && (m_flowLevel >= 0 || !m_simpleKeyAllowed))
+			return true;
+
+		return false;
+	}
+
+	// StartStream
+	// . Set the initial conditions for starting a stream.
+	void Scanner::StartStream()
+	{
+		m_startedStream = true;
+		m_simpleKeyAllowed = true;
+		m_indents.push(-1);
+	}
+
+	// EndStream
+	// . Close out the stream, finish up, etc.
+	void Scanner::EndStream()
+	{
+		// force newline
+		if(INPUT.column > 0)
+			INPUT.column = 0;
+
+		PopIndentTo(-1);
+		VerifyAllSimpleKeys();
+
+		m_simpleKeyAllowed = false;
+		m_endedStream = true;
+	}
+
+	// PushIndentTo
+	// . Pushes an indentation onto the stack, and enqueues the
+	//   proper token (sequence start or mapping start).
+	// . Returns the token it generates (if any).
+	Token *Scanner::PushIndentTo(int column, bool sequence)
+	{
+		// are we in flow?
+		if(m_flowLevel > 0)
+			return 0;
+
+		// is this actually an indentation?
+		if(column <= m_indents.top())
+			return 0;
+
+		// now push
+		m_indents.push(column);
+		if(sequence)
+			m_tokens.push(Token(TT_BLOCK_SEQ_START, INPUT.line, INPUT.column));
+		else
+			m_tokens.push(Token(TT_BLOCK_MAP_START, INPUT.line, INPUT.column));
+
+		return &m_tokens.back();
+	}
+
+	// PopIndentTo
+	// . Pops indentations off the stack until we reach 'column' indentation,
+	//   and enqueues the proper token each time.
+	void Scanner::PopIndentTo(int column)
+	{
+		// are we in flow?
+		if(m_flowLevel > 0)
+			return;
+
+		// now pop away
+		while(!m_indents.empty() && m_indents.top() > column) {
+			m_indents.pop();
+			m_tokens.push(Token(TT_BLOCK_END, INPUT.line, INPUT.column));
+		}
+	}
+}

src/scanner.h

-#pragma once
-
-#include <ios>
-#include <string>
-#include <queue>
-#include <stack>
-#include <set>
-#include "stream.h"
-#include "token.h"
-
-namespace YAML
-{
-	class Scanner
-	{
-	public:
-		Scanner(std::istream& in);
-		~Scanner();
-
-		// token queue management (hopefully this looks kinda stl-ish)
-		bool empty();
-		void pop();
-		Token& peek();
-
-	private:
-		// scanning
-		void EnsureTokensInQueue();
-		void ScanNextToken();
-		void ScanToNextToken();
-		void StartStream();
-		void EndStream();
-		Token *PushIndentTo(int column, bool sequence);
-		void PopIndentTo(int column);
-
-		// checking input
-		void InsertSimpleKey();
-		bool VerifySimpleKey();
-		void VerifyAllSimpleKeys();
-
-		bool IsWhitespaceToBeEaten(char ch);
-
-		struct SimpleKey {
-			SimpleKey(int pos_, int line_, int column_, int flowLevel_);
-
-			void Validate();
-			void Invalidate();
-
-			int pos, line, column, flowLevel;
-			Token *pMapStart, *pKey;
-		};
-
-		// and the tokens
-		void ScanDirective();
-		void ScanDocStart();
-		void ScanDocEnd();
-		void ScanBlockSeqStart();
-		void ScanBlockMapSTart();
-		void ScanBlockEnd();
-		void ScanBlockEntry();
-		void ScanFlowStart();
-		void ScanFlowEnd();
-		void ScanFlowEntry();
-		void ScanKey();
-		void ScanValue();
-		void ScanAnchorOrAlias();
-		void ScanTag();
-		void ScanPlainScalar();
-		void ScanQuotedScalar();
-		void ScanBlockScalar();
-
-	private:
-		// the stream
-		Stream INPUT;
-
-		// the output (tokens)
-		std::queue <Token> m_tokens;
-
-		// state info
-		bool m_startedStream, m_endedStream;
-		bool m_simpleKeyAllowed;
-		int m_flowLevel;                // number of unclosed '[' and '{' indicators
-		bool m_isLastKeyValid;
-		std::stack <SimpleKey> m_simpleKeys;
-		std::stack <int> m_indents;
-	};
-}
+#pragma once
+
+#include <ios>
+#include <string>
+#include <queue>
+#include <stack>
+#include <set>
+#include "stream.h"
+#include "token.h"
+
+namespace YAML
+{
+	class Scanner
+	{
+	public:
+		Scanner(std::istream& in);
+		~Scanner();
+
+		// token queue management (hopefully this looks kinda stl-ish)
+		bool empty();
+		void pop();
+		Token& peek();
+
+	private:
+		// scanning
+		void EnsureTokensInQueue();
+		void ScanNextToken();
+		void ScanToNextToken();
+		void StartStream();
+		void EndStream();
+		Token *PushIndentTo(int column, bool sequence);
+		void PopIndentTo(int column);
+
+		// checking input
+		void InsertSimpleKey();
+		bool VerifySimpleKey();
+		void VerifyAllSimpleKeys();
+
+		bool IsWhitespaceToBeEaten(char ch);
+
+		struct SimpleKey {
+			SimpleKey(int pos_, int line_, int column_, int flowLevel_);
+
+			void Validate();
+			void Invalidate();
+
+			int pos, line, column, flowLevel;
+			Token *pMapStart, *pKey;
+		};
+
+		// and the tokens
+		void ScanDirective();
+		void ScanDocStart();
+		void ScanDocEnd();
+		void ScanBlockSeqStart();
+		void ScanBlockMapSTart();
+		void ScanBlockEnd();
+		void ScanBlockEntry();
+		void ScanFlowStart();
+		void ScanFlowEnd();
+		void ScanFlowEntry();
+		void ScanKey();
+		void ScanValue();
+		void ScanAnchorOrAlias();
+		void ScanTag();
+		void ScanPlainScalar();
+		void ScanQuotedScalar();
+		void ScanBlockScalar();
+
+	private:
+		// the stream
+		Stream INPUT;
+
+		// the output (tokens)
+		std::queue <Token> m_tokens;
+
+		// state info
+		bool m_startedStream, m_endedStream;
+		bool m_simpleKeyAllowed;
+		int m_flowLevel;                // number of unclosed '[' and '{' indicators
+		bool m_isLastKeyValid;
+		std::stack <SimpleKey> m_simpleKeys;
+		std::stack <int> m_indents;
+	};
+}

src/scanscalar.cpp

-#include "crt.h"
-#include "scanscalar.h"
-#include "scanner.h"
-#include "exp.h"
-#include "exceptions.h"
-#include "token.h"
-
-namespace YAML
-{
-	// ScanScalar
-	// . This is where the scalar magic happens.
-	//
-	// . We do the scanning in three phases:
-	//   1. Scan until newline
-	//   2. Eat newline
-	//   3. Scan leading blanks.
-	//
-	// . Depending on the parameters given, we store or stop
-	//   and different places in the above flow.
-	std::string ScanScalar(Stream& INPUT, ScanScalarParams& params)
-	{
-		bool foundNonEmptyLine = false, pastOpeningBreak = false;
-		bool emptyLine = false, moreIndented = false;
-		std::string scalar;
-		params.leadingSpaces = false;
-
-		while(INPUT) {
-			// ********************************
-			// Phase #1: scan until line ending
-			while(!params.end.Matches(INPUT) && !Exp::Break.Matches(INPUT)) {
-				if(INPUT.peek() == EOF)
-					break;
-
-				// document indicator?
-				if(INPUT.column == 0 && Exp::DocIndicator.Matches(INPUT)) {
-					if(params.onDocIndicator == BREAK)
-						break;
-					else if(params.onDocIndicator == THROW)
-						throw ParserException(INPUT.line, INPUT.column, ErrorMsg::DOC_IN_SCALAR);
-				}
-
-				foundNonEmptyLine = true;
-				pastOpeningBreak = true;
-
-				// escaped newline? (only if we're escaping on slash)
-				if(params.escape == '\\' && Exp::EscBreak.Matches(INPUT)) {
-					int n = Exp::EscBreak.Match(INPUT);
-					INPUT.eat(n);
-					continue;
-				}
-
-				// escape this?
-				if(INPUT.peek() == params.escape) {
-					scalar += Exp::Escape(INPUT);
-					continue;
-				}
-
-				// otherwise, just add the damn character
-				scalar += INPUT.get();
-			}
-
-			// eof? if we're looking to eat something, then we throw
-			if(INPUT.peek() == EOF) {
-				if(params.eatEnd)
-					throw ParserException(INPUT.line, INPUT.column, ErrorMsg::EOF_IN_SCALAR);
-				break;
-			}
-
-			// doc indicator?
-			if(params.onDocIndicator == BREAK && INPUT.column == 0 && Exp::DocIndicator.Matches(INPUT))
-				break;
-
-			// are we done via character match?
-			int n = params.end.Match(INPUT);
-			if(n >= 0) {
-				if(params.eatEnd)
-					INPUT.eat(n);
-				break;
-			}
-
-			// ********************************
-			// Phase #2: eat line ending
-			n = Exp::Break.Match(INPUT);
-			INPUT.eat(n);
-
-			// ********************************
-			// Phase #3: scan initial spaces
-
-			// first the required indentation
-			while(INPUT.peek() == ' ' && (INPUT.column < params.indent || (params.detectIndent && !foundNonEmptyLine)))
-				INPUT.eat(1);
-
-			// update indent if we're auto-detecting
-			if(params.detectIndent && !foundNonEmptyLine)
-				params.indent = std::max(params.indent, INPUT.column);
-
-			// and then the rest of the whitespace
-			while(Exp::Blank.Matches(INPUT)) {
-				// we check for tabs that masquerade as indentation
-				if(INPUT.peek() == '\t'&& INPUT.column < params.indent && params.onTabInIndentation == THROW)
-					throw ParserException(INPUT.line, INPUT.column, ErrorMsg::TAB_IN_INDENTATION);
-
-				if(!params.eatLeadingWhitespace)
-					break;
-
-				INPUT.eat(1);
-			}
-
-			// was this an empty line?
-			bool nextEmptyLine = Exp::Break.Matches(INPUT);
-			bool nextMoreIndented = (INPUT.peek() == ' ');
-
-			// for block scalars, we always start with a newline, so we should ignore it (not fold or keep)
-			bool useNewLine = pastOpeningBreak;
-			// and for folded scalars, we don't fold the very last newline to a space
-			if(params.fold && !emptyLine && INPUT.column < params.indent)
-				useNewLine = false;
-
-			if(useNewLine) {
-				if(params.fold && !emptyLine && !nextEmptyLine && !moreIndented && !nextMoreIndented)
-					scalar += " ";
-				else
-					scalar += "\n";
-			}
-
-			emptyLine = nextEmptyLine;
-			moreIndented = nextMoreIndented;
-			pastOpeningBreak = true;
-
-			// are we done via indentation?
-			if(!emptyLine && INPUT.column < params.indent) {
-				params.leadingSpaces = true;
-				break;
-			}
-		}
-
-		// post-processing
-		if(params.trimTrailingSpaces) {
-			unsigned pos = scalar.find_last_not_of(' ');
-			if(pos < scalar.size())
-				scalar.erase(pos + 1);
-		}
-
-		if(params.chomp <= 0) {
-			unsigned pos = scalar.find_last_not_of('\n');
-			if(params.chomp == 0 && pos + 1 < scalar.size())
-				scalar.erase(pos + 2);
-			else if(params.chomp == -1 && pos < scalar.size())
-				scalar.erase(pos + 1);
-		}
-
-		return scalar;
-	}
-}
+#include "crt.h"
+#include "scanscalar.h"
+#include "scanner.h"
+#include "exp.h"
+#include "exceptions.h"
+#include "token.h"
+
+namespace YAML
+{
+	// ScanScalar
+	// . This is where the scalar magic happens.
+	//
+	// . We do the scanning in three phases:
+	//   1. Scan until newline
+	//   2. Eat newline
+	//   3. Scan leading blanks.
+	//
+	// . Depending on the parameters given, we store or stop
+	//   and different places in the above flow.
+	std::string ScanScalar(Stream& INPUT, ScanScalarParams& params)
+	{
+		bool foundNonEmptyLine = false, pastOpeningBreak = false;
+		bool emptyLine = false, moreIndented = false;
+		std::string scalar;
+		params.leadingSpaces = false;
+
+		while(INPUT) {
+			// ********************************
+			// Phase #1: scan until line ending
+			while(!params.end.Matches(INPUT) && !Exp::Break.Matches(INPUT)) {
+				if(INPUT.peek() == EOF)
+					break;
+
+				// document indicator?
+				if(INPUT.column == 0 && Exp::DocIndicator.Matches(INPUT)) {
+					if(params.onDocIndicator == BREAK)
+						break;
+					else if(params.onDocIndicator == THROW)
+						throw ParserException(INPUT.line, INPUT.column, ErrorMsg::DOC_IN_SCALAR);
+				}
+
+				foundNonEmptyLine = true;
+				pastOpeningBreak = true;
+
+				// escaped newline? (only if we're escaping on slash)
+				if(params.escape == '\\' && Exp::EscBreak.Matches(INPUT)) {
+					int n = Exp::EscBreak.Match(INPUT);
+					INPUT.eat(n);
+					continue;
+				}
+
+				// escape this?
+				if(INPUT.peek() == params.escape) {
+					scalar += Exp::Escape(INPUT);
+					continue;
+				}
+
+				// otherwise, just add the damn character
+				scalar += INPUT.get();
+			}
+
+			// eof? if we're looking to eat something, then we throw
+			if(INPUT.peek() == EOF) {
+				if(params.eatEnd)
+					throw ParserException(INPUT.line, INPUT.column, ErrorMsg::EOF_IN_SCALAR);
+				break;
+			}
+
+			// doc indicator?
+			if(params.onDocIndicator == BREAK && INPUT.column == 0 && Exp::DocIndicator.Matches(INPUT))
+				break;
+
+			// are we done via character match?
+			int n = params.end.Match(INPUT);
+			if(n >= 0) {
+				if(params.eatEnd)
+					INPUT.eat(n);
+				break;
+			}
+
+			// ********************************
+			// Phase #2: eat line ending
+			n = Exp::Break.Match(INPUT);
+			INPUT.eat(n);
+
+			// ********************************
+			// Phase #3: scan initial spaces
+
+			// first the required indentation
+			while(INPUT.peek() == ' ' && (INPUT.column < params.indent || (params.detectIndent && !foundNonEmptyLine)))
+				INPUT.eat(1);
+
+			// update indent if we're auto-detecting
+			if(params.detectIndent && !foundNonEmptyLine)
+				params.indent = std::max(params.indent, INPUT.column);
+
+			// and then the rest of the whitespace
+			while(Exp::Blank.Matches(INPUT)) {
+				// we check for tabs that masquerade as indentation
+				if(INPUT.peek() == '\t'&& INPUT.column < params.indent && params.onTabInIndentation == THROW)
+					throw ParserException(INPUT.line, INPUT.column, ErrorMsg::TAB_IN_INDENTATION);
+
+				if(!params.eatLeadingWhitespace)
+					break;
+
+				INPUT.eat(1);
+			}
+
+			// was this an empty line?
+			bool nextEmptyLine = Exp::Break.Matches(INPUT);
+			bool nextMoreIndented = (INPUT.peek() == ' ');
+
+			// for block scalars, we always start with a newline, so we should ignore it (not fold or keep)
+			bool useNewLine = pastOpeningBreak;
+			// and for folded scalars, we don't fold the very last newline to a space
+			if(params.fold && !emptyLine && INPUT.column < params.indent)
+				useNewLine = false;
+
+			if(useNewLine) {
+				if(params.fold && !emptyLine && !nextEmptyLine && !moreIndented && !nextMoreIndented)
+					scalar += " ";
+				else
+					scalar += "\n";
+			}
+
+			emptyLine = nextEmptyLine;
+			moreIndented = nextMoreIndented;
+			pastOpeningBreak = true;
+
+			// are we done via indentation?
+			if(!emptyLine && INPUT.column < params.indent) {
+				params.leadingSpaces = true;
+				break;
+			}
+		}
+
+		// post-processing
+		if(params.trimTrailingSpaces) {
+			unsigned pos = scalar.find_last_not_of(' ');
+			if(pos < scalar.size())
+				scalar.erase(pos + 1);
+		}
+
+		if(params.chomp <= 0) {
+			unsigned pos = scalar.find_last_not_of('\n');
+			if(params.chomp == 0 && pos + 1 < scalar.size())
+				scalar.erase(pos + 2);
+			else if(params.chomp == -1 && pos < scalar.size())
+				scalar.erase(pos + 1);
+		}
+
+		return scalar;
+	}
+}

src/scanscalar.h

-#pragma once
-
-#include <string>
-#include "regex.h"
-#include "stream.h"
-
-namespace YAML
-{
-	enum CHOMP { STRIP = -1, CLIP, KEEP };
-	enum ACTION { NONE, BREAK, THROW };
-
-	struct ScanScalarParams {
-		ScanScalarParams(): eatEnd(false), indent(0), detectIndent(false), eatLeadingWhitespace(0), escape(0), fold(false),
-			trimTrailingSpaces(0), chomp(CLIP), onDocIndicator(NONE), onTabInIndentation(NONE), leadingSpaces(false) {}
-
-		// input:
-		RegEx end;                      // what condition ends this scalar?
-		bool eatEnd;                    // should we eat that condition when we see it?
-		int indent;                     // what level of indentation should be eaten and ignored?
-		bool detectIndent;              // should we try to autodetect the indent?
-		bool eatLeadingWhitespace;      // should we continue eating this delicious indentation after 'indent' spaces?
-		char escape;                    // what character do we escape on (i.e., slash or single quote) (0 for none)
-		bool fold;                      // do we fold line ends?
-		bool trimTrailingSpaces;        // do we remove all trailing spaces (at the very end)
-		CHOMP chomp;                    // do we strip, clip, or keep trailing newlines (at the very end)
-		                                //   Note: strip means kill all, clip means keep at most one, keep means keep all
-		ACTION onDocIndicator;          // what do we do if we see a document indicator?
-		ACTION onTabInIndentation;      // what do we do if we see a tab where we should be seeing indentation spaces
-
-		// output:
-		bool leadingSpaces;
-	};
-
-	std::string ScanScalar(Stream& INPUT, ScanScalarParams& info);
-}
+#pragma once
+
+#include <string>
+#include "regex.h"
+#include "stream.h"
+
+namespace YAML
+{
+	enum CHOMP { STRIP = -1, CLIP, KEEP };
+	enum ACTION { NONE, BREAK, THROW };
+
+	struct ScanScalarParams {
+		ScanScalarParams(): eatEnd(false), indent(0), detectIndent(false), eatLeadingWhitespace(0), escape(0), fold(false),
+			trimTrailingSpaces(0), chomp(CLIP), onDocIndicator(NONE), onTabInIndentation(NONE), leadingSpaces(false) {}
+
+		// input:
+		RegEx end;                      // what condition ends this scalar?
+		bool eatEnd;                    // should we eat that condition when we see it?
+		int indent;                     // what level of indentation should be eaten and ignored?
+		bool detectIndent;              // should we try to autodetect the indent?
+		bool eatLeadingWhitespace;      // should we continue eating this delicious indentation after 'indent' spaces?
+		char escape;                    // what character do we escape on (i.e., slash or single quote) (0 for none)
+		bool fold;                      // do we fold line ends?
+		bool trimTrailingSpaces;        // do we remove all trailing spaces (at the very end)
+		CHOMP chomp;                    // do we strip, clip, or keep trailing newlines (at the very end)
+		                                //   Note: strip means kill all, clip means keep at most one, keep means keep all
+		ACTION onDocIndicator;          // what do we do if we see a document indicator?
+		ACTION onTabInIndentation;      // what do we do if we see a tab where we should be seeing indentation spaces
+
+		// output:
+		bool leadingSpaces;
+	};
+
+	std::string ScanScalar(Stream& INPUT, ScanScalarParams& info);
+}

src/sequence.h

-#pragma once
-
-#include "content.h"
-#include <vector>
-
-namespace YAML
-{
-	class Node;
-
-	class Sequence: public Content
-	{
-	public:
-		Sequence();
-		virtual ~Sequence();
-
-		void Clear();
-		virtual bool GetBegin(std::vector <Node *>::const_iterator& it) const;
-		virtual bool GetEnd(std::vector <Node *>::const_iterator& it) const;
-		virtual Node *GetNode(unsigned i) const;
-		virtual unsigned GetSize() const;
-
-		virtual void Parse(Scanner *pScanner, const ParserState& state);
-		virtual void Write(std::ostream& out, int indent, bool startedLine, bool onlyOneCharOnLine);
-
-		virtual bool IsSequence() const { return true; }
-
-		// ordering
-		virtual int Compare(Content *pContent);
-		virtual int Compare(Scalar *pScalar) { return 1; }
-		virtual int Compare(Sequence *pSeq);
-		virtual int Compare(Map *pMap) { return -1; }
-
-	private:
-		void ParseBlock(Scanner *pScanner, const ParserState& state);
-		void ParseImplicit(Scanner *pScanner, const ParserState& state);
-		void ParseFlow(Scanner *pScanner, const ParserState& state);
-
-	protected:
-		std::vector <Node *> m_data;
-	};
-}
+#pragma once
+
+#include "content.h"
+#include <vector>
+
+namespace YAML
+{
+	class Node;
+
+	class Sequence: public Content
+	{
+	public:
+		Sequence();
+		virtual ~Sequence();
+
+		void Clear();
+		virtual bool GetBegin(std::vector <Node *>::const_iterator& it) const;
+		virtual bool GetEnd(std::vector <Node *>::const_iterator& it) const;
+		virtual Node *GetNode(unsigned i) const;
+		virtual unsigned GetSize() const;
+
+		virtual void Parse(Scanner *pScanner, const ParserState& state);
+		virtual void Write(std::ostream& out, int indent, bool startedLine, bool onlyOneCharOnLine);
+
+		virtual bool IsSequence() const { return true; }
+
+		// ordering
+		virtual int Compare(Content *pContent);
+		virtual int Compare(Scalar *pScalar) { return 1; }
+		virtual int Compare(Sequence *pSeq);
+		virtual int Compare(Map *pMap) { return -1; }
+
+	private:
+		void ParseBlock(Scanner *pScanner, const ParserState& state);
+		void ParseImplicit(Scanner *pScanner, const ParserState& state);
+		void ParseFlow(Scanner *pScanner, const ParserState& state);
+
+	protected:
+		std::vector <Node *> m_data;
+	};
+}