Merged r366:387 from the jbeder-event-api branch

src/nodebuilder.h

+#pragma once
+
+#ifndef NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#include "eventhandler.h"
+#include "ptr_stack.h"
+#include <map>
+#include <memory>
+#include <stack>
+
+namespace YAML
+{
+	class Node;
+	
+	class NodeBuilder: public EventHandler
+	{
+	public:
+		explicit NodeBuilder(Node& root);
+		virtual ~NodeBuilder();
+
+		virtual void OnDocumentStart(const Mark& mark);
+		virtual void OnDocumentEnd();
+		
+		virtual void OnNull(const std::string& tag, anchor_t anchor);
+		virtual void OnAlias(const Mark& mark, anchor_t anchor);
+		virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value);
+		
+		virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor);
+		virtual void OnSequenceEnd();
+		
+		virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor);
+		virtual void OnMapEnd();
+		
+	private:
+		Node& Push(anchor_t anchor);
+		Node& Push();
+		Node& Top();
+		void Pop();
+
+		void Insert(std::auto_ptr<Node> pNode);
+		void RegisterAnchor(anchor_t anchor, const Node& node);
+		
+	private:
+		Node& m_root;
+		bool m_initializedRoot;
+		bool m_finished;
+		
+		ptr_stack<Node> m_stack;
+		ptr_stack<Node> m_pendingKeys;
+		std::stack<bool> m_didPushKey;
+
+		typedef std::vector<const Node *> Anchors;
+		Anchors m_anchors;
+	};
+}
+
+#endif // NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+

src/parser.cpp

 #include "parser.h"
+#include "directives.h"
+#include "eventhandler.h"
+#include "exceptions.h"
+#include "node.h"
+#include "nodebuilder.h"
 #include "scanner.h"
+#include "singledocparser.h"
+#include "tag.h"
 #include "token.h"
-#include "exceptions.h"
-#include "parserstate.h"
 #include <sstream>
 #include <cstdio>
 
@@ -29,44 +34,36 @@ namespace YAML
 	void Parser::Load(std::istream& in)
 	{
 		m_pScanner.reset(new Scanner(in));
-		m_pState.reset(new ParserState);
+		m_pDirectives.reset(new Directives);
 	}
 
-	// GetNextDocument
-	// . Reads the next document in the queue (of tokens).
+	// HandleNextDocument
+	// . Handles the next document
 	// . Throws a ParserException on error.
-	bool Parser::GetNextDocument(Node& document)
+	// . Returns false if there are no more documents
+	bool Parser::HandleNextDocument(EventHandler& eventHandler)
 	{
 		if(!m_pScanner.get())
 			return false;
-		
-		// clear node
-		document.Clear();
 
-		// first read directives
 		ParseDirectives();
-
-		// we better have some tokens in the queue
 		if(m_pScanner->empty())
 			return false;
-
-		// first eat doc start (optional)
-		if(m_pScanner->peek().type == Token::DOC_START)
-			m_pScanner->pop();
-
-		// now parse our root node
-		document.Parse(m_pScanner.get(), *m_pState);
-
-		// and finally eat any doc ends we see
-		while(!m_pScanner->empty() && m_pScanner->peek().type == Token::DOC_END)
-			m_pScanner->pop();
-
-		// clear anchors from the scanner, which are no longer relevant
-		m_pScanner->ClearAnchors();
 		
+		SingleDocParser sdp(*m_pScanner, *m_pDirectives);
+		sdp.HandleDocument(eventHandler);
 		return true;
 	}
 
+	// GetNextDocument
+	// . Reads the next document in the queue (of tokens).
+	// . Throws a ParserException on error.
+	bool Parser::GetNextDocument(Node& document)
+	{
+		NodeBuilder builder(document);
+		return HandleNextDocument(builder);
+	}
+
 	// ParseDirectives
 	// . Reads any directives that are next in the queue.
 	void Parser::ParseDirectives()
@@ -84,7 +81,7 @@ namespace YAML
 			// we keep the directives from the last document if none are specified;
 			// but if any directives are specific, then we reset them
 			if(!readDirective)
-				m_pState.reset(new ParserState);
+				m_pDirectives.reset(new Directives);
 
 			readDirective = true;
 			HandleDirective(token);
@@ -107,20 +104,20 @@ namespace YAML
 		if(token.params.size() != 1)
 			throw ParserException(token.mark, ErrorMsg::YAML_DIRECTIVE_ARGS);
 		
-		if(!m_pState->version.isDefault)
+		if(!m_pDirectives->version.isDefault)
 			throw ParserException(token.mark, ErrorMsg::REPEATED_YAML_DIRECTIVE);
 
 		std::stringstream str(token.params[0]);
-		str >> m_pState->version.major;
+		str >> m_pDirectives->version.major;
 		str.get();
-		str >> m_pState->version.minor;
+		str >> m_pDirectives->version.minor;
 		if(!str || str.peek() != EOF)
 			throw ParserException(token.mark, ErrorMsg::YAML_VERSION + token.params[0]);
 
-		if(m_pState->version.major > 1)
+		if(m_pDirectives->version.major > 1)
 			throw ParserException(token.mark, ErrorMsg::YAML_MAJOR_VERSION);
 
-		m_pState->version.isDefault = false;
+		m_pDirectives->version.isDefault = false;
 		// TODO: warning on major == 1, minor > 2?
 	}
 
@@ -133,10 +130,10 @@ namespace YAML
 
 		const std::string& handle = token.params[0];
 		const std::string& prefix = token.params[1];
-		if(m_pState->tags.find(handle) != m_pState->tags.end())
+		if(m_pDirectives->tags.find(handle) != m_pDirectives->tags.end())
 			throw ParserException(token.mark, ErrorMsg::REPEATED_TAG_DIRECTIVE);
 		
-		m_pState->tags[handle] = prefix;
+		m_pDirectives->tags[handle] = prefix;
 	}
 
 	void Parser::PrintTokens(std::ostream& out)

src/parserstate.h

-#pragma once
-
-#ifndef PARSERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define PARSERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-#include <string>
-#include <map>
-#include <stack>
-#include <cassert>
-
-namespace YAML
-{
-	struct Version {
-		bool isDefault;
-		int major, minor;
-	};
-	
-	struct ParserState
-	{
-		enum COLLECTION_TYPE { NONE, BLOCK_MAP, BLOCK_SEQ, FLOW_MAP, FLOW_SEQ, COMPACT_MAP };
-		
-		ParserState();
-
-		const std::string TranslateTagHandle(const std::string& handle) const;
-		COLLECTION_TYPE GetCurCollectionType() const { if(collectionStack.empty()) return NONE; return collectionStack.top(); }
-		
-		void PushCollectionType(COLLECTION_TYPE type) { collectionStack.push(type); }
-		void PopCollectionType(COLLECTION_TYPE type) { assert(type == GetCurCollectionType()); collectionStack.pop(); }
-	
-		Version version;
-		std::map <std::string, std::string> tags;
-		std::stack <COLLECTION_TYPE> collectionStack;
-	};
-}
-
-#endif // PARSERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/ptr_stack.h

+#pragma once
+
+#ifndef PTR_STACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define PTR_STACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#include "noncopyable.h"
+#include <memory>
+#include <vector>
+
+template <typename T>
+class ptr_stack: private YAML::noncopyable
+{
+public:
+	ptr_stack() {}
+	~ptr_stack() { clear(); }
+	
+	void clear() {
+		for(unsigned i=0;i<m_data.size();i++)
+			delete m_data[i];
+		m_data.clear();
+	}
+	
+	std::size_t size() const { return m_data.size(); }
+	bool empty() const { return m_data.empty(); }
+	
+	void push(std::auto_ptr<T> t) {
+		m_data.push_back(NULL);
+		m_data.back() = t.release();
+	}
+	std::auto_ptr<T> pop() {
+		std::auto_ptr<T> t(m_data.back());
+		m_data.pop_back();
+		return t;
+	}
+	T& top() { return *m_data.back(); }
+	
+private:
+	std::vector<T*> m_data;
+};
+
+#endif // PTR_STACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/scalar.cpp

 #include "scalar.h"
-#include "scanner.h"
-#include "token.h"
-#include "exceptions.h"
-#include "node.h"
-#include "emitter.h"
+#include "eventhandler.h"
 
 namespace YAML
 {
@@ -11,29 +7,13 @@ namespace YAML
 	{
 	}
 
-	Scalar::Scalar(const std::string& data): m_data(data)
-	{
-	}
-
 	Scalar::~Scalar()
 	{
 	}
 
-	Content *Scalar::Clone() const
-	{
-		return new Scalar(m_data);
-	}
-
-	void Scalar::Parse(Scanner *pScanner, ParserState& /*state*/)
-	{
-		Token& token = pScanner->peek();
-		m_data = token.value;
-		pScanner->pop();
-	}
-
-	void Scalar::Write(Emitter& out) const
+	void Scalar::EmitEvents(AliasManager&, EventHandler& eventHandler, const Mark& mark, const std::string& tag, anchor_t anchor) const
 	{
-		out << m_data;
+		eventHandler.OnScalar(mark, tag, anchor, m_data);
 	}
 
 	int Scalar::Compare(Content *pContent)

src/scalar.h

@@ -13,15 +13,12 @@ namespace YAML
 	{
 	public:
 		Scalar();
-		Scalar(const std::string& data);
 		virtual ~Scalar();
 
-		virtual Content *Clone() const;
-
-		virtual void Parse(Scanner *pScanner, ParserState& state);
-		virtual void Write(Emitter& out) const;
+		virtual void SetData(const std::string& data) { m_data = data; }
 
 		virtual bool IsScalar() const { return true; }
+		virtual void EmitEvents(AliasManager& am, EventHandler& eventHandler, const Mark& mark, const std::string& tag, anchor_t anchor) const;
 
 		// extraction
 		virtual bool GetScalar(std::string& scalar) const {

src/scanner.cpp

@@ -32,13 +32,8 @@ namespace YAML
 	void Scanner::pop()
 	{
 		EnsureTokensInQueue();
-		if(!m_tokens.empty()) {
-			// Saved anchors shouldn't survive popping the document end marker
-			if (m_tokens.front().type == Token::DOC_END) {
-				ClearAnchors();
-			}
+		if(!m_tokens.empty())
 			m_tokens.pop();
-		}
 	}
 
 	// peek
@@ -245,7 +240,6 @@ namespace YAML
 		IndentMarker *pIndent = new IndentMarker(-1, IndentMarker::NONE);
 		m_indentRefs.push_back(pIndent);
 		m_indents.push(pIndent);
-		m_anchors.clear();
 	}
 
 	// EndStream
@@ -378,29 +372,6 @@ namespace YAML
 		return m_indents.top()->column;
 	}
 
-	// Save
-	// . Saves a pointer to the Node object referenced by a particular anchor
-	//   name.
-	void Scanner::Save(const std::string& anchor, Node* value)
-	{
-		m_anchors[anchor] = value;
-	}
-
-	// Retrieve
-	// . Retrieves a pointer previously saved for an anchor name.
-	// . Throws an exception if the anchor has not been defined.
-	const Node *Scanner::Retrieve(const std::string& anchor) const
-	{
-		typedef std::map<std::string, const Node *> map;
-
-		map::const_iterator itNode = m_anchors.find(anchor);
-
-		if(m_anchors.end() == itNode)
-			ThrowParserException(ErrorMsg::UNKNOWN_ANCHOR);
-
-		return itNode->second;
-	}
-
 	// ThrowParserException
 	// . Throws a ParserException with the current token location
 	//   (if available).
@@ -414,10 +385,5 @@ namespace YAML
 		}
 		throw ParserException(mark, msg);
 	}
-
-	void Scanner::ClearAnchors()
-	{
-		m_anchors.clear();
-	}
 }
 

src/scanner.h

@@ -29,11 +29,6 @@ namespace YAML
 		void pop();
 		Token& peek();
 
-		// anchor management
-		void Save(const std::string& anchor, Node* value);
-		const Node *Retrieve(const std::string& anchor) const;
-		void ClearAnchors();
-
 	private:
 		struct IndentMarker {
 			enum INDENT_TYPE { MAP, SEQ, NONE };
@@ -127,7 +122,6 @@ namespace YAML
 		std::stack <IndentMarker *> m_indents;
 		std::vector <IndentMarker *> m_indentRefs; // for "garbage collection"
 		std::stack <FLOW_MARKER> m_flows;
-		std::map <std::string, const Node *> m_anchors;
 	};
 }
 

src/sequence.cpp

 #include "sequence.h"
+#include "eventhandler.h"
 #include "node.h"
-#include "scanner.h"
-#include "token.h"
-#include "emitter.h"
 #include <stdexcept>
 
 namespace YAML
@@ -12,12 +10,6 @@ namespace YAML
 
 	}
 
-	Sequence::Sequence(const std::vector<Node *>& data)
-	{
-		for(std::size_t i=0;i<data.size();i++)
-			m_data.push_back(data[i]->Clone().release());
-	}
-
 	Sequence::~Sequence()
 	{
 		Clear();
@@ -30,11 +22,6 @@ namespace YAML
 		m_data.clear();
 	}
 
-	Content *Sequence::Clone() const
-	{
-		return new Sequence(m_data);
-	}
-
 	bool Sequence::GetBegin(std::vector <Node *>::const_iterator& it) const
 	{
 		it = m_data.begin();
@@ -59,90 +46,17 @@ namespace YAML
 		return m_data.size();
 	}
 
-	void Sequence::Parse(Scanner *pScanner, ParserState& state)
-	{
-		Clear();
-
-		// split based on start token
-		switch(pScanner->peek().type) {
-			case Token::BLOCK_SEQ_START: ParseBlock(pScanner, state); break;
-			case Token::FLOW_SEQ_START: ParseFlow(pScanner, state); break;
-			default: break;
-		}
-	}
-
-	void Sequence::ParseBlock(Scanner *pScanner, ParserState& state)
-	{
-		// eat start token
-		pScanner->pop();
-		state.PushCollectionType(ParserState::BLOCK_SEQ);
-
-		while(1) {
-			if(pScanner->empty())
-				throw ParserException(Mark::null(), ErrorMsg::END_OF_SEQ);
-
-			Token token = pScanner->peek();
-			if(token.type != Token::BLOCK_ENTRY && token.type != Token::BLOCK_SEQ_END)
-				throw ParserException(token.mark, ErrorMsg::END_OF_SEQ);
-
-			pScanner->pop();
-			if(token.type == Token::BLOCK_SEQ_END)
-				break;
-
-			Node *pNode = new Node;
-			m_data.push_back(pNode);
-			
-			// check for null
-			if(!pScanner->empty()) {
-				const Token& token = pScanner->peek();
-				if(token.type == Token::BLOCK_ENTRY || token.type == Token::BLOCK_SEQ_END)
-					continue;
-			}
-			
-			pNode->Parse(pScanner, state);
-		}
-
-		state.PopCollectionType(ParserState::BLOCK_SEQ);
-	}
-
-	void Sequence::ParseFlow(Scanner *pScanner, ParserState& state)
+	void Sequence::Append(std::auto_ptr<Node> pNode)
 	{
-		// eat start token
-		pScanner->pop();
-		state.PushCollectionType(ParserState::FLOW_SEQ);
-
-		while(1) {
-			if(pScanner->empty())
-				throw ParserException(Mark::null(), ErrorMsg::END_OF_SEQ_FLOW);
-
-			// first check for end
-			if(pScanner->peek().type == Token::FLOW_SEQ_END) {
-				pScanner->pop();
-				break;
-			}
-
-			// then read the node
-			Node *pNode = new Node;
-			m_data.push_back(pNode);
-			pNode->Parse(pScanner, state);
-
-			// now eat the separator (or could be a sequence end, which we ignore - but if it's neither, then it's a bad node)
-			Token& token = pScanner->peek();
-			if(token.type == Token::FLOW_ENTRY)
-				pScanner->pop();
-			else if(token.type != Token::FLOW_SEQ_END)
-				throw ParserException(token.mark, ErrorMsg::END_OF_SEQ_FLOW);
-		}
-
-		state.PopCollectionType(ParserState::FLOW_SEQ);
+		m_data.push_back(pNode.release());
 	}
-
-	void Sequence::Write(Emitter& out) const
+	
+	void Sequence::EmitEvents(AliasManager& am, EventHandler& eventHandler, const Mark& mark, const std::string& tag, anchor_t anchor) const
 	{
-		out << BeginSeq;
+		eventHandler.OnSequenceStart(mark, tag, anchor);
 		for(std::size_t i=0;i<m_data.size();i++)
-			out << *m_data[i];
-		out << EndSeq;
+			m_data[i]->EmitEvents(am, eventHandler);
+		eventHandler.OnSequenceEnd();
 	}
 
 	int Sequence::Compare(Content *pContent)

src/sequence.h

@@ -15,19 +15,17 @@ namespace YAML
 	{
 	public:
 		Sequence();
-		Sequence(const std::vector<Node *>& data);
 		virtual ~Sequence();
 
 		void Clear();
-		virtual Content *Clone() const;
 
 		virtual bool GetBegin(std::vector <Node *>::const_iterator& it) const;
 		virtual bool GetEnd(std::vector <Node *>::const_iterator& it) const;
 		virtual Node *GetNode(std::size_t i) const;
 		virtual std::size_t GetSize() const;
 
-		virtual void Parse(Scanner *pScanner, ParserState& state);
-		virtual void Write(Emitter& out) const;
+		virtual void Append(std::auto_ptr<Node> pNode);
+		virtual void EmitEvents(AliasManager& am, EventHandler& eventHandler, const Mark& mark, const std::string& tag, anchor_t anchor) const;
 
 		virtual bool IsSequence() const { return true; }
 
@@ -37,10 +35,6 @@ namespace YAML
 		virtual int Compare(Sequence *pSeq);
 		virtual int Compare(Map *) { return -1; }
 
-	private:
-		void ParseBlock(Scanner *pScanner, ParserState& state);
-		void ParseFlow(Scanner *pScanner, ParserState& state);
-
 	protected:
 		std::vector <Node *> m_data;
 	};

src/singledocparser.cpp

+#include "singledocparser.h"
+#include "collectionstack.h"
+#include "directives.h"
+#include "eventhandler.h"
+#include "exceptions.h"
+#include "scanner.h"
+#include "tag.h"
+#include "token.h"
+#include <sstream>
+#include <cstdio>
+
+namespace YAML
+{
+	SingleDocParser::SingleDocParser(Scanner& scanner, const Directives& directives): m_scanner(scanner), m_directives(directives), m_pCollectionStack(new CollectionStack), m_curAnchor(0)
+	{
+	}
+
+	SingleDocParser::~SingleDocParser()
+	{
+	}
+
+	// HandleDocument
+	// . Handles the next document
+	// . Throws a ParserException on error.
+	void SingleDocParser::HandleDocument(EventHandler& eventHandler)
+	{
+		assert(!m_scanner.empty()); // guaranteed that there are tokens
+		assert(!m_curAnchor);
+
+		eventHandler.OnDocumentStart(m_scanner.peek().mark);
+		
+		// eat doc start
+		if(m_scanner.peek().type == Token::DOC_START)
+			m_scanner.pop();
+		
+		// recurse!
+		HandleNode(eventHandler);
+		
+		eventHandler.OnDocumentEnd();
+		
+		// and finally eat any doc ends we see
+		while(!m_scanner.empty() && m_scanner.peek().type == Token::DOC_END)
+			m_scanner.pop();
+	}
+	
+	void SingleDocParser::HandleNode(EventHandler& eventHandler)
+	{
+		// an empty node *is* a possibility
+		if(m_scanner.empty()) {
+			eventHandler.OnNull("", NullAnchor);
+			return;
+		}
+		
+		// save location
+		Mark mark = m_scanner.peek().mark;
+		
+		// special case: a value node by itself must be a map, with no header
+		if(m_scanner.peek().type == Token::VALUE) {
+			eventHandler.OnMapStart(mark, "", NullAnchor);
+			HandleMap(eventHandler);
+			eventHandler.OnMapEnd();
+			return;
+		}
+		
+		// special case: an alias node
+		if(m_scanner.peek().type == Token::ALIAS) {
+			eventHandler.OnAlias(mark, LookupAnchor(mark, m_scanner.peek().value));
+			m_scanner.pop();
+			return;
+		}
+		
+		std::string tag;
+		anchor_t anchor;
+		ParseProperties(tag, anchor);
+		
+		// now split based on what kind of node we should be
+		switch(m_scanner.peek().type) {
+			case Token::SCALAR:
+				eventHandler.OnScalar(mark, tag, anchor, m_scanner.peek().value);
+				m_scanner.pop();
+				return;
+			case Token::FLOW_SEQ_START:
+			case Token::BLOCK_SEQ_START:
+				eventHandler.OnSequenceStart(mark, tag, anchor);
+				HandleSequence(eventHandler);
+				eventHandler.OnSequenceEnd();
+				return;
+			case Token::FLOW_MAP_START:
+			case Token::BLOCK_MAP_START:
+				eventHandler.OnMapStart(mark, tag, anchor);
+				HandleMap(eventHandler);
+				eventHandler.OnMapEnd();
+				return;
+			case Token::KEY:
+				// compact maps can only go in a flow sequence
+				if(m_pCollectionStack->GetCurCollectionType() == CollectionType::FlowSeq) {
+					eventHandler.OnMapStart(mark, tag, anchor);
+					HandleMap(eventHandler);
+					eventHandler.OnMapEnd();
+					return;
+				}
+				break;
+			default:
+				break;
+		}
+		
+		eventHandler.OnNull(tag, anchor);
+	}
+	
+	void SingleDocParser::HandleSequence(EventHandler& eventHandler)
+	{
+		// split based on start token
+		switch(m_scanner.peek().type) {
+			case Token::BLOCK_SEQ_START: HandleBlockSequence(eventHandler); break;
+			case Token::FLOW_SEQ_START: HandleFlowSequence(eventHandler); break;
+			default: break;
+		}
+	}
+	
+	void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler)
+	{
+		// eat start token
+		m_scanner.pop();
+		m_pCollectionStack->PushCollectionType(CollectionType::BlockSeq);
+		
+		while(1) {
+			if(m_scanner.empty())
+				throw ParserException(Mark::null(), ErrorMsg::END_OF_SEQ);
+			
+			Token token = m_scanner.peek();
+			if(token.type != Token::BLOCK_ENTRY && token.type != Token::BLOCK_SEQ_END)
+				throw ParserException(token.mark, ErrorMsg::END_OF_SEQ);
+			
+			m_scanner.pop();
+			if(token.type == Token::BLOCK_SEQ_END)
+				break;
+			
+			// check for null
+			if(!m_scanner.empty()) {
+				const Token& token = m_scanner.peek();
+				if(token.type == Token::BLOCK_ENTRY || token.type == Token::BLOCK_SEQ_END) {
+					eventHandler.OnNull("", NullAnchor);
+					continue;
+				}
+			}
+			
+			HandleNode(eventHandler);
+		}
+		
+		m_pCollectionStack->PopCollectionType(CollectionType::BlockSeq);
+	}
+	
+	void SingleDocParser::HandleFlowSequence(EventHandler& eventHandler)
+	{
+		// eat start token
+		m_scanner.pop();
+		m_pCollectionStack->PushCollectionType(CollectionType::FlowSeq);
+		
+		while(1) {
+			if(m_scanner.empty())
+				throw ParserException(Mark::null(), ErrorMsg::END_OF_SEQ_FLOW);
+			
+			// first check for end
+			if(m_scanner.peek().type == Token::FLOW_SEQ_END) {
+				m_scanner.pop();
+				break;
+			}
+			
+			// then read the node
+			HandleNode(eventHandler);
+			
+			// now eat the separator (or could be a sequence end, which we ignore - but if it's neither, then it's a bad node)
+			Token& token = m_scanner.peek();
+			if(token.type == Token::FLOW_ENTRY)
+				m_scanner.pop();
+			else if(token.type != Token::FLOW_SEQ_END)
+				throw ParserException(token.mark, ErrorMsg::END_OF_SEQ_FLOW);
+		}
+		
+		m_pCollectionStack->PopCollectionType(CollectionType::FlowSeq);
+	}
+	
+	void SingleDocParser::HandleMap(EventHandler& eventHandler)
+	{
+		// split based on start token
+		switch(m_scanner.peek().type) {
+			case Token::BLOCK_MAP_START: HandleBlockMap(eventHandler); break;
+			case Token::FLOW_MAP_START: HandleFlowMap(eventHandler); break;
+			case Token::KEY: HandleCompactMap(eventHandler); break;
+			case Token::VALUE: HandleCompactMapWithNoKey(eventHandler); break;
+			default: break;
+		}
+	}
+	
+	void SingleDocParser::HandleBlockMap(EventHandler& eventHandler)
+	{
+		// eat start token
+		m_scanner.pop();
+		m_pCollectionStack->PushCollectionType(CollectionType::BlockMap);
+		
+		while(1) {
+			if(m_scanner.empty())
+				throw ParserException(Mark::null(), ErrorMsg::END_OF_MAP);
+			
+			Token token = m_scanner.peek();
+			if(token.type != Token::KEY && token.type != Token::VALUE && token.type != Token::BLOCK_MAP_END)
+				throw ParserException(token.mark, ErrorMsg::END_OF_MAP);
+			
+			if(token.type == Token::BLOCK_MAP_END) {
+				m_scanner.pop();
+				break;
+			}
+			
+			// grab key (if non-null)
+			if(token.type == Token::KEY) {
+				m_scanner.pop();
+				HandleNode(eventHandler);
+			} else {
+				eventHandler.OnNull("", NullAnchor);
+			}
+			
+			// now grab value (optional)
+			if(!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) {
+				m_scanner.pop();
+				HandleNode(eventHandler);
+			} else {
+				eventHandler.OnNull("", NullAnchor);
+			}
+		}
+		
+		m_pCollectionStack->PopCollectionType(CollectionType::BlockMap);
+	}
+	
+	void SingleDocParser::HandleFlowMap(EventHandler& eventHandler)
+	{
+		// eat start token
+		m_scanner.pop();
+		m_pCollectionStack->PushCollectionType(CollectionType::FlowMap);
+		
+		while(1) {
+			if(m_scanner.empty())
+				throw ParserException(Mark::null(), ErrorMsg::END_OF_MAP_FLOW);
+			
+			Token& token = m_scanner.peek();
+			// first check for end
+			if(token.type == Token::FLOW_MAP_END) {
+				m_scanner.pop();
+				break;
+			}
+			
+			// grab key (if non-null)
+			if(token.type == Token::KEY) {
+				m_scanner.pop();
+				HandleNode(eventHandler);
+			} else {
+				eventHandler.OnNull("", NullAnchor);
+			}
+			
+			// now grab value (optional)
+			if(!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) {
+				m_scanner.pop();
+				HandleNode(eventHandler);
+			} else {
+				eventHandler.OnNull("", NullAnchor);
+			}
+			
+			// now eat the separator (or could be a map end, which we ignore - but if it's neither, then it's a bad node)
+			Token& nextToken = m_scanner.peek();
+			if(nextToken.type == Token::FLOW_ENTRY)
+				m_scanner.pop();
+			else if(nextToken.type != Token::FLOW_MAP_END)
+				throw ParserException(nextToken.mark, ErrorMsg::END_OF_MAP_FLOW);
+		}
+		
+		m_pCollectionStack->PopCollectionType(CollectionType::FlowMap);
+	}
+	
+	// . Single "key: value" pair in a flow sequence
+	void SingleDocParser::HandleCompactMap(EventHandler& eventHandler)
+	{
+		m_pCollectionStack->PushCollectionType(CollectionType::CompactMap);
+		
+		// grab key
+		m_scanner.pop();
+		HandleNode(eventHandler);
+		
+		// now grab value (optional)
+		if(!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) {
+			m_scanner.pop();
+			HandleNode(eventHandler);
+		} else {
+			eventHandler.OnNull("", NullAnchor);
+		}
+		
+		m_pCollectionStack->PopCollectionType(CollectionType::CompactMap);
+	}
+	
+	// . Single ": value" pair in a flow sequence
+	void SingleDocParser::HandleCompactMapWithNoKey(EventHandler& eventHandler)
+	{
+		m_pCollectionStack->PushCollectionType(CollectionType::CompactMap);
+		
+		// null key
+		eventHandler.OnNull("", NullAnchor);
+		
+		// grab value
+		m_scanner.pop();
+		HandleNode(eventHandler);
+		
+		m_pCollectionStack->PopCollectionType(CollectionType::CompactMap);
+	}
+	
+	// ParseProperties
+	// . Grabs any tag or anchor tokens and deals with them.
+	void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor)
+	{
+		tag.clear();
+		anchor = NullAnchor;
+		
+		while(1) {
+			if(m_scanner.empty())
+				return;
+			
+			switch(m_scanner.peek().type) {
+				case Token::TAG: ParseTag(tag); break;
+				case Token::ANCHOR: ParseAnchor(anchor); break;
+				default: return;
+			}
+		}
+	}
+	
+	void SingleDocParser::ParseTag(std::string& tag)
+	{
+		Token& token = m_scanner.peek();
+		if(!tag.empty())
+			throw ParserException(token.mark, ErrorMsg::MULTIPLE_TAGS);
+		
+		Tag tagInfo(token);
+		tag = tagInfo.Translate(m_directives);
+		m_scanner.pop();
+	}
+	
+	void SingleDocParser::ParseAnchor(anchor_t& anchor)
+	{
+		Token& token = m_scanner.peek();
+		if(anchor)
+			throw ParserException(token.mark, ErrorMsg::MULTIPLE_ANCHORS);
+		
+		anchor = RegisterAnchor(token.value);
+		m_scanner.pop();
+	}
+	
+	anchor_t SingleDocParser::RegisterAnchor(const std::string& name)
+	{
+		if(name.empty())
+			return NullAnchor;
+		
+		return m_anchors[name] = ++m_curAnchor;
+	}
+	
+	anchor_t SingleDocParser::LookupAnchor(const Mark& mark, const std::string& name) const
+	{
+		Anchors::const_iterator it = m_anchors.find(name);
+		if(it == m_anchors.end())
+			throw ParserException(mark, ErrorMsg::UNKNOWN_ANCHOR);
+		
+		return it->second;
+	}
+}

src/singledocparser.h

+#pragma once
+
+#ifndef SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+
+#include "anchor.h"
+#include "noncopyable.h"
+#include <string>
+#include <map>
+#include <memory>
+
+namespace YAML
+{
+	struct Directives;
+	struct Mark;
+	struct Token;
+	class CollectionStack;
+	class EventHandler;
+	class Node;
+	class Scanner;
+	
+	class SingleDocParser: private noncopyable
+	{
+	public:
+		SingleDocParser(Scanner& scanner, const Directives& directives);
+		~SingleDocParser();
+
+		void HandleDocument(EventHandler& eventHandler);
+
+	private:
+		void HandleNode(EventHandler& eventHandler);
+		
+		void HandleSequence(EventHandler& eventHandler);
+		void HandleBlockSequence(EventHandler& eventHandler);
+		void HandleFlowSequence(EventHandler& eventHandler);
+		
+		void HandleMap(EventHandler& eventHandler);
+		void HandleBlockMap(EventHandler& eventHandler);
+		void HandleFlowMap(EventHandler& eventHandler);
+		void HandleCompactMap(EventHandler& eventHandler);
+		void HandleCompactMapWithNoKey(EventHandler& eventHandler);
+		
+		void ParseProperties(std::string& tag, anchor_t& anchor);
+		void ParseTag(std::string& tag);
+		void ParseAnchor(anchor_t& anchor);
+		
+		anchor_t RegisterAnchor(const std::string& name);
+		anchor_t LookupAnchor(const Mark& mark, const std::string& name) const;
+		
+	private:
+		Scanner& m_scanner;
+		const Directives& m_directives;
+		std::auto_ptr<CollectionStack> m_pCollectionStack;
+		
+		typedef std::map<std::string, anchor_t> Anchors;
+		Anchors m_anchors;
+		
+		anchor_t m_curAnchor;
+	};
+}
+
+#endif // SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/tag.cpp

 #include "tag.h"
+#include "directives.h"
 #include "token.h"
-#include "parserstate.h"
 #include <cassert>
 
 namespace YAML
@@ -28,17 +28,17 @@ namespace YAML
 		}
 	}
 
-	const std::string Tag::Translate(const ParserState& state)
+	const std::string Tag::Translate(const Directives& directives)
 	{
 		switch(type) {
 			case VERBATIM:
 				return value;
 			case PRIMARY_HANDLE:
-				return state.TranslateTagHandle("!") + value;
+				return directives.TranslateTagHandle("!") + value;
 			case SECONDARY_HANDLE:
-				return state.TranslateTagHandle("!!") + value;
+				return directives.TranslateTagHandle("!!") + value;
 			case NAMED_HANDLE:
-				return state.TranslateTagHandle("!" + handle + "!") + value;
+				return directives.TranslateTagHandle("!" + handle + "!") + value;
 			case NON_SPECIFIC:
 				// TODO:
 				return "!";

src/tag.h

@@ -8,7 +8,7 @@
 namespace YAML
 {
 	struct Token;
-	struct ParserState;
+	struct Directives;
 
 	struct Tag {
 		enum TYPE {
@@ -16,7 +16,7 @@ namespace YAML
 		};
 		
 		Tag(const Token& token);
-		const std::string Translate(const ParserState& state);
+		const std::string Translate(const Directives& directives);
 		
 		TYPE type;
 		std::string handle, value;

util/parse.cpp

 #include "yaml.h"
 #include <fstream>
 #include <iostream>
+#include <vector>
+
+struct Params {
+	bool hasFile;
+	std::string fileName;
+};
+
+Params ParseArgs(int argc, char **argv) {
+	Params p;
+
+	std::vector<std::string> args(argv + 1, argv + argc);
+	
+	return p;
+}
 
 int main(int argc, char **argv)
 {
+	Params p = ParseArgs(argc, argv);
+
 	std::ifstream fin;
 	if(argc > 1)
 		fin.open(argv[1]);
@@ -13,9 +29,9 @@ int main(int argc, char **argv)
 		YAML::Parser parser(input);
 		YAML::Node doc;
 		while(parser.GetNextDocument(doc)) {
-			YAML::Emitter emitter;
-			emitter << doc;
-			std::cout << emitter.c_str() << "\n";
+//			YAML::Emitter emitter;
+//			emitter << doc;
+//			std::cout << emitter.c_str() << "\n";
 		}
 	} catch(const YAML::Exception& e) {
 		std::cerr << e.what() << "\n";