Bumped version to 0.5.1

See, e.g., http://stackoverflow.com/questions/4738768/printing-double-without-losing-precision.

.hgignore

@@ -1,2 +1 @@
 syntax: glob
-

CMakeLists.txt

@@ -23,7 +23,7 @@ project(YAML_CPP)
 
 set(YAML_CPP_VERSION_MAJOR "0")
 set(YAML_CPP_VERSION_MINOR "5")
-set(YAML_CPP_VERSION_PATCH "0")
+set(YAML_CPP_VERSION_PATCH "1")
 set(YAML_CPP_VERSION "${YAML_CPP_VERSION_MAJOR}.${YAML_CPP_VERSION_MINOR}.${YAML_CPP_VERSION_PATCH}")
 
 enable_testing()

include/yaml-cpp/emitter.h

@@ -8,10 +8,11 @@
 
 #include "yaml-cpp/dll.h"
 #include "yaml-cpp/binary.h"
+#include "yaml-cpp/emitterdef.h"
 #include "yaml-cpp/emittermanip.h"
-#include "yaml-cpp/ostream.h"
 #include "yaml-cpp/noncopyable.h"
 #include "yaml-cpp/null.h"
+#include "yaml-cpp/ostream_wrapper.h"
 #include <memory>
 #include <string>
 #include <sstream>
@@ -24,11 +25,12 @@ namespace YAML
 	{
 	public:
 		Emitter();
+        explicit Emitter(std::ostream& stream);
 		~Emitter();
 		
 		// output
 		const char *c_str() const;
-		unsigned size() const;
+        std::size_t size() const;
 		
 		// state checking
 		bool good() const;
@@ -60,7 +62,7 @@ namespace YAML
 		Emitter& Write(const _Anchor& anchor);
 		Emitter& Write(const _Tag& tag);
 		Emitter& Write(const _Comment& comment);
-		Emitter& Write(const _Null& null);
+		Emitter& Write(const _Null& n);
 		Emitter& Write(const Binary& binary);
 		
 		template <typename T>
@@ -70,39 +72,51 @@ namespace YAML
 		Emitter& WriteStreamable(T value);
 
 	private:
-		void PreWriteIntegralType(std::stringstream& str);
-		void PreWriteStreamable(std::stringstream& str);
-		void PostWriteIntegralType(const std::stringstream& str);
-		void PostWriteStreamable(const std::stringstream& str);
-        
         template<typename T> void SetStreamablePrecision(std::stringstream&) {}
         unsigned GetFloatPrecision() const;
         unsigned GetDoublePrecision() const;
+        
+        void PrepareIntegralStream(std::stringstream& stream) const;
+        void StartedScalar();
 	
 	private:
-		void PreAtomicWrite();
-		bool GotoNextPreAtomicState();
-		void PostAtomicWrite();
-		void EmitSeparationIfNecessary();
-		
 		void EmitBeginDoc();
 		void EmitEndDoc();
 		void EmitBeginSeq();
 		void EmitEndSeq();
 		void EmitBeginMap();
 		void EmitEndMap();
-		void EmitKey();
-		void EmitValue();
 		void EmitNewline();
 		void EmitKindTag();
 		void EmitTag(bool verbatim, const _Tag& tag);
 		
+        void PrepareNode(EmitterNodeType::value child);
+        void PrepareTopNode(EmitterNodeType::value child);
+        void FlowSeqPrepareNode(EmitterNodeType::value child);
+        void BlockSeqPrepareNode(EmitterNodeType::value child);
+
+        void FlowMapPrepareNode(EmitterNodeType::value child);
+
+        void FlowMapPrepareLongKey(EmitterNodeType::value child);
+        void FlowMapPrepareLongKeyValue(EmitterNodeType::value child);
+        void FlowMapPrepareSimpleKey(EmitterNodeType::value child);
+        void FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child);
+
+        void BlockMapPrepareNode(EmitterNodeType::value child);
+
+        void BlockMapPrepareLongKey(EmitterNodeType::value child);
+        void BlockMapPrepareLongKeyValue(EmitterNodeType::value child);
+        void BlockMapPrepareSimpleKey(EmitterNodeType::value child);
+        void BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child);
+        
+        void SpaceOrIndentTo(bool requireSpace, unsigned indent);
+        
 		const char *ComputeFullBoolName(bool b) const;
 		bool CanEmitNewline() const;
 		
 	private:
-		ostream m_stream;
-		std::auto_ptr <EmitterState> m_pState;
+		std::auto_ptr<EmitterState> m_pState;
+		ostream_wrapper m_stream;
 	};
 	
 	template <typename T>
@@ -111,10 +125,15 @@ namespace YAML
 		if(!good())
 			return *this;
 		
-		std::stringstream str;
-		PreWriteIntegralType(str);
-		str << value;
-		PostWriteIntegralType(str);
+        PrepareNode(EmitterNodeType::Scalar);
+
+        std::stringstream stream;
+        PrepareIntegralStream(stream);
+        stream << value;
+        m_stream << stream.str();
+        
+        StartedScalar();
+
 		return *this;
 	}
 
@@ -124,24 +143,28 @@ namespace YAML
 		if(!good())
 			return *this;
 		
-		std::stringstream str;
-		PreWriteStreamable(str);
-        SetStreamablePrecision<T>(str);
-		str << value;
-		PostWriteStreamable(str);
+        PrepareNode(EmitterNodeType::Scalar);
+
+		std::stringstream stream;
+        SetStreamablePrecision<T>(stream);
+		stream << value;
+        m_stream << stream.str();
+        
+        StartedScalar();
+
 		return *this;
 	}
 	
     template<>
-    inline void Emitter::SetStreamablePrecision<float>(std::stringstream& str)
+    inline void Emitter::SetStreamablePrecision<float>(std::stringstream& stream)
     {
-		str.precision(GetFloatPrecision());
+		stream.precision(GetFloatPrecision());
     }
 
     template<>
-    inline void Emitter::SetStreamablePrecision<double>(std::stringstream& str)
+    inline void Emitter::SetStreamablePrecision<double>(std::stringstream& stream)
     {
-		str.precision(GetDoublePrecision());
+		stream.precision(GetDoublePrecision());
     }
 
 	// overloads of insertion

include/yaml-cpp/emitterdef.h

@@ -0,0 +1,13 @@
+#ifndef EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace YAML
+{
+    struct EmitterNodeType { enum value { None, Property, Scalar, FlowSeq, BlockSeq, FlowMap, BlockMap }; };
+}
+
+#endif // EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/exceptions.h

@@ -55,12 +55,14 @@ namespace YAML
 		const char * const AMBIGUOUS_ANCHOR       = "cannot assign the same alias to multiple nodes";
 		const char * const UNKNOWN_ANCHOR         = "the referenced anchor is not defined";
 
+        const char * const INVALID_NODE           = "invalid node; this may result from using a map iterator as a sequence iterator, or vice-versa";
 		const char * const INVALID_SCALAR         = "invalid scalar";
 		const char * const KEY_NOT_FOUND          = "key not found";
         const char * const BAD_CONVERSION         = "bad conversion";
 		const char * const BAD_DEREFERENCE        = "bad dereference";
         const char * const BAD_SUBSCRIPT          = "operator[] call on a scalar";
         const char * const BAD_PUSHBACK           = "appending to a non-sequence";
+        const char * const BAD_INSERT             = "inserting in a non-convertible-to-map";
 		
 		const char * const UNMATCHED_GROUP_TAG    = "unmatched group tag";
 		const char * const UNEXPECTED_END_SEQ     = "unexpected end sequence token";
@@ -69,10 +71,7 @@ namespace YAML
 		const char * const INVALID_ANCHOR         = "invalid anchor";
 		const char * const INVALID_ALIAS          = "invalid alias";
 		const char * const INVALID_TAG            = "invalid tag";
-		const char * const EXPECTED_KEY_TOKEN     = "expected key token";
-		const char * const EXPECTED_VALUE_TOKEN   = "expected value token";
-		const char * const UNEXPECTED_KEY_TOKEN   = "unexpected key token";
-		const char * const UNEXPECTED_VALUE_TOKEN = "unexpected value token";
+        const char * const BAD_FILE               = "bad file";
 
 		template <typename T>
 		inline const std::string KEY_NOT_FOUND_WITH_KEY(const T&, typename disable_if<is_numeric<T> >::type * = 0) {
@@ -151,10 +150,16 @@ namespace YAML
 		return TypedKeyNotFound <T> (mark, key);
 	}
 
-	class BadConversion: public RepresentationException {
+	class InvalidNode: public RepresentationException {
+	public:
+		InvalidNode()
+        : RepresentationException(Mark::null_mark(), ErrorMsg::INVALID_NODE) {}
+	};
+
+    class BadConversion: public RepresentationException {
 	public:
 		BadConversion()
-        : RepresentationException(Mark::null(), ErrorMsg::BAD_CONVERSION) {}
+        : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_CONVERSION) {}
 	};
 
     template<typename T>
@@ -167,26 +172,37 @@ namespace YAML
 	class BadDereference: public RepresentationException {
 	public:
 		BadDereference()
-		: RepresentationException(Mark::null(), ErrorMsg::BAD_DEREFERENCE) {}
+		: RepresentationException(Mark::null_mark(), ErrorMsg::BAD_DEREFERENCE) {}
 	};
 
 	class BadSubscript: public RepresentationException {
 	public:
 		BadSubscript()
-		: RepresentationException(Mark::null(), ErrorMsg::BAD_SUBSCRIPT) {}
+		: RepresentationException(Mark::null_mark(), ErrorMsg::BAD_SUBSCRIPT) {}
 	};
 
 	class BadPushback: public RepresentationException {
 	public:
 		BadPushback()
-		: RepresentationException(Mark::null(), ErrorMsg::BAD_PUSHBACK) {}
+		: RepresentationException(Mark::null_mark(), ErrorMsg::BAD_PUSHBACK) {}
 	};
 	
+	class BadInsert: public RepresentationException {
+	public:
+		BadInsert()
+		: RepresentationException(Mark::null_mark(), ErrorMsg::BAD_INSERT) {}
+	};
+
 	class EmitterException: public Exception {
 	public:
 		EmitterException(const std::string& msg_)
-		: Exception(Mark::null(), msg_) {}
+		: Exception(Mark::null_mark(), msg_) {}
 	};
+    
+    class BadFile: public Exception {
+    public:
+        BadFile(): Exception(Mark::null_mark(), ErrorMsg::BAD_FILE) {}
+    };
 }
 
 #endif // EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/mark.h

@@ -13,7 +13,7 @@ namespace YAML
 	struct YAML_CPP_API Mark {
 		Mark(): pos(0), line(0), column(0) {}
 		
-		static const Mark null() { return Mark(-1, -1, -1); }
+		static const Mark null_mark() { return Mark(-1, -1, -1); }
 		
 		int pos;
 		int line, column;

include/yaml-cpp/node/convert.h

@@ -47,7 +47,22 @@ namespace YAML
 		}
 	};
 	
+	// C-strings can only be encoded
 	template<>
+	struct convert<const char *> {
+		static Node encode(const char *&rhs) {
+			return Node(rhs);
+		}
+	};
+
+	template<std::size_t N>
+	struct convert<const char[N]> {
+		static Node encode(const char (&rhs)[N]) {
+			return Node(rhs);
+		}
+	};
+
+    template<>
 	struct convert<_Null> {
 		static Node encode(const _Null& /* rhs */) {
 			return Node();
@@ -58,11 +73,12 @@ namespace YAML
 		}
 	};
 	
-#define YAML_DEFINE_CONVERT_STREAMABLE(type)\
+#define YAML_DEFINE_CONVERT_STREAMABLE(type, negative_op)\
 	template<>\
 	struct convert<type> {\
 		static Node encode(const type& rhs) {\
 			std::stringstream stream;\
+            stream.precision(std::numeric_limits<type>::digits10 + 1);\
 			stream << rhs;\
 			return Node(stream.str());\
 		}\
@@ -80,7 +96,7 @@ namespace YAML
                     rhs = std::numeric_limits<type>::infinity();\
                     return true;\
                 } else if(conversion::IsNegativeInfinity(input)) {\
-                    rhs = -std::numeric_limits<type>::infinity();\
+                    rhs = negative_op std::numeric_limits<type>::infinity();\
                     return true;\
                 }\
             }\
@@ -94,22 +110,30 @@ namespace YAML
 		}\
 	}
 	
-	YAML_DEFINE_CONVERT_STREAMABLE(int);
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned);
-	YAML_DEFINE_CONVERT_STREAMABLE(short);
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned short);
-	YAML_DEFINE_CONVERT_STREAMABLE(long);
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned long);
-	YAML_DEFINE_CONVERT_STREAMABLE(long long);
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned long long);
+#define YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(type)\
+    YAML_DEFINE_CONVERT_STREAMABLE(type, -)
+
+#define YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(type)\
+    YAML_DEFINE_CONVERT_STREAMABLE(type, +)
+
+    YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(int);
+	YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(short);
+	YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long);
+	YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long long);
+	YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned);
+	YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned short);
+	YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long);
+	YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long long);
 	
-	YAML_DEFINE_CONVERT_STREAMABLE(char);
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned char);
+	YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(char);
+	YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned char);
 	
-	YAML_DEFINE_CONVERT_STREAMABLE(float);
-	YAML_DEFINE_CONVERT_STREAMABLE(double);
-	YAML_DEFINE_CONVERT_STREAMABLE(long double);
+	YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(float);
+	YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(double);
+	YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long double);
 	
+#undef YAML_DEFINE_CONVERT_STREAMABLE_SIGNED
+#undef YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED
 #undef YAML_DEFINE_CONVERT_STREAMABLE
 	
 	// bool
@@ -128,7 +152,7 @@ namespace YAML
 		static Node encode(const std::map<K, V>& rhs) {
 			Node node(NodeType::Map);
 			for(typename std::map<K, V>::const_iterator it=rhs.begin();it!=rhs.end();++it)
-				node[it->first] = it->second;
+                node.force_insert(it->first, it->second);
 			return node;
 		}
 		
@@ -138,7 +162,12 @@ namespace YAML
 
 			rhs.clear();
 			for(const_iterator it=node.begin();it!=node.end();++it)
+#if defined(__GNUC__) && __GNUC__ < 4
+//workaround for GCC 3:
+				rhs[it->first.template as<K>()] = it->second.template as<V>();
+#else
 				rhs[it->first.as<K>()] = it->second.as<V>();
+#endif
 			return true;
 		}
 	};
@@ -159,7 +188,12 @@ namespace YAML
 			
 			rhs.clear();
 			for(const_iterator it=node.begin();it!=node.end();++it)
+#if defined(__GNUC__) && __GNUC__ < 4
+//workaround for GCC 3:
+				rhs.push_back(it->template as<T>());
+#else
 				rhs.push_back(it->as<T>());
+#endif
 			return true;
 		}
 	};
@@ -180,11 +214,48 @@ namespace YAML
 			
 			rhs.clear();
 			for(const_iterator it=node.begin();it!=node.end();++it)
+#if defined(__GNUC__) && __GNUC__ < 4
+//workaround for GCC 3:
+				rhs.push_back(it->template as<T>());
+#else
 				rhs.push_back(it->as<T>());
+#endif
 			return true;
 		}
 	};
     
+	// std::pair
+	template<typename T, typename U>
+	struct convert<std::pair<T, U> > {
+		static Node encode(const std::pair<T, U>& rhs) {
+			Node node(NodeType::Sequence);
+            node.push_back(rhs.first);
+            node.push_back(rhs.second);
+			return node;
+		}
+		
+		static bool decode(const Node& node, std::pair<T, U>& rhs) {
+			if(!node.IsSequence())
+				return false;
+            if (node.size() != 2)
+                return false;
+
+#if defined(__GNUC__) && __GNUC__ < 4
+//workaround for GCC 3:
+				rhs.first = node[0].template as<T>();
+#else
+				rhs.first = node[0].as<T>();
+#endif
+#if defined(__GNUC__) && __GNUC__ < 4
+//workaround for GCC 3:
+				rhs.second = node[1].template as<U>();
+#else
+				rhs.second = node[1].as<U>();
+#endif
+			return true;
+		}
+	};
+
     // binary
     template<>
 	struct convert<Binary> {

include/yaml-cpp/node/detail/impl.h

@@ -22,7 +22,7 @@ namespace YAML
 		};
 
 		template<typename Key>
-		struct get_idx<Key, typename boost::enable_if<boost::is_unsigned<Key> >::type> {
+		struct get_idx<Key, typename boost::enable_if_c<boost::is_unsigned<Key>::value && !boost::is_same<Key, bool>::value>::type> {
 			static node *get(const std::vector<node *>& sequence, const Key& key, shared_memory_holder /* pMemory */) {
 				return key < sequence.size() ? sequence[key] : 0;
 			}
@@ -118,6 +118,27 @@ namespace YAML
 			
 			return false;
 		}
+        
+        // map
+        template<typename Key, typename Value>
+        inline void node_data::force_insert(const Key& key, const Value& value, shared_memory_holder pMemory)
+        {
+			switch(m_type) {
+				case NodeType::Map:
+					break;
+				case NodeType::Undefined:
+				case NodeType::Null:
+				case NodeType::Sequence:
+					convert_to_map(pMemory);
+					break;
+				case NodeType::Scalar:
+                    throw BadInsert();
+			}
+			
+			node& k = convert_to_node(key, pMemory);
+			node& v = convert_to_node(value, pMemory);
+			insert_map_pair(k, v);
+        }
 
 		template<typename T>
 		inline bool node_data::equals(node& node, const T& rhs, shared_memory_holder pMemory)
@@ -128,7 +149,12 @@ namespace YAML
 			return false;
 		}
 		
-		template<typename T>
+		inline bool node_data::equals(node& node, const char *rhs, shared_memory_holder pMemory)
+		{
+            return equals<std::string>(node, rhs, pMemory);
+		}
+
+        template<typename T>
 		inline node& node_data::convert_to_node(const T& rhs, shared_memory_holder pMemory)
 		{
 			Node value = convert<T>::encode(rhs);

include/yaml-cpp/node/detail/node.h

@@ -115,6 +115,10 @@ namespace YAML
 			}
 			bool remove(node& key, shared_memory_holder pMemory) { return m_pRef->remove(key, pMemory); }
 
+            // map
+            template<typename Key, typename Value>
+            void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory){ m_pRef->force_insert(key, value, pMemory); }
+
 		private:
 			shared_node_ref m_pRef;
 			typedef std::set<node *> nodes;

include/yaml-cpp/node/detail/node_data.h

@@ -56,6 +56,10 @@ namespace YAML
 			node& get(node& key, shared_memory_holder pMemory) const;
 			node& get(node& key, shared_memory_holder pMemory);
 			bool remove(node& key, shared_memory_holder pMemory);
+            
+            // map
+            template<typename Key, typename Value>
+            void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory);
 			
 		public:
 			static std::string empty_scalar;
@@ -73,6 +77,7 @@ namespace YAML
 			
 			template<typename T>
 			static bool equals(node& node, const T& rhs, shared_memory_holder pMemory);
+			static bool equals(node& node, const char *rhs, shared_memory_holder pMemory);
 			
 			template<typename T>
 			static node& convert_to_node(const T& rhs, shared_memory_holder pMemory);

include/yaml-cpp/node/detail/node_ref.h

@@ -55,6 +55,10 @@ namespace YAML
 			node& get(node& key, shared_memory_holder pMemory) const { return static_cast<const node_data&>(*m_pData).get(key, pMemory); }
 			node& get(node& key, shared_memory_holder pMemory) { return m_pData->get(key, pMemory); }
 			bool remove(node& key, shared_memory_holder pMemory) { return m_pData->remove(key, pMemory); }
+            
+            // map
+            template<typename Key, typename Value>
+            void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory) { m_pData->force_insert(key, value, pMemory); }
 
 		private:
 			shared_node_data m_pData;

include/yaml-cpp/node/impl.h

@@ -15,30 +15,34 @@
 
 namespace YAML
 {
-	inline Node::Node(): m_pNode(0)
+	inline Node::Node(): m_isValid(true), m_pNode(NULL)
 	{
 	}
 	
-	inline Node::Node(NodeType::value type): m_pMemory(new detail::memory_holder), m_pNode(&m_pMemory->create_node())
+	inline Node::Node(NodeType::value type): m_isValid(true), m_pMemory(new detail::memory_holder), m_pNode(&m_pMemory->create_node())
 	{
 		m_pNode->set_type(type);
 	}
 	
 	template<typename T>
-	inline Node::Node(const T& rhs): m_pMemory(new detail::memory_holder), m_pNode(&m_pMemory->create_node())
+	inline Node::Node(const T& rhs): m_isValid(true), m_pMemory(new detail::memory_holder), m_pNode(&m_pMemory->create_node())
 	{
 		Assign(rhs);
 	}
 	
-    inline Node::Node(const detail::iterator_value& rhs): m_pMemory(rhs.m_pMemory), m_pNode(rhs.m_pNode)
+    inline Node::Node(const detail::iterator_value& rhs): m_isValid(rhs.m_isValid), m_pMemory(rhs.m_pMemory), m_pNode(rhs.m_pNode)
     {
     }
 
-	inline Node::Node(const Node& rhs): m_pMemory(rhs.m_pMemory), m_pNode(rhs.m_pNode)
+	inline Node::Node(const Node& rhs): m_isValid(rhs.m_isValid), m_pMemory(rhs.m_pMemory), m_pNode(rhs.m_pNode)
 	{
 	}
 	
-	inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory): m_pMemory(pMemory), m_pNode(&node)
+    inline Node::Node(Zombie): m_isValid(false), m_pNode(NULL)
+    {
+    }
+
+    inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory): m_isValid(true), m_pMemory(pMemory), m_pNode(&node)
 	{
 	}
 
@@ -48,6 +52,8 @@ namespace YAML
 
 	inline void Node::EnsureNodeExists() const
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		if(!m_pNode) {
 			m_pMemory.reset(new detail::memory_holder);
 			m_pNode = &m_pMemory->create_node();
@@ -57,11 +63,15 @@ namespace YAML
 	
 	inline bool Node::IsDefined() const
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		return m_pNode ? m_pNode->is_defined() : true;
 	}
 
 	inline NodeType::value Node::Type() const
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		return m_pNode ? m_pNode->type() : NodeType::Null;
 	}
 	
@@ -123,32 +133,42 @@ namespace YAML
             return node.Scalar();
         }
     };
-    
+
     // access functions
 	template<typename T>
 	inline const T Node::as() const
 	{
+        if(!m_isValid)
+            throw InvalidNode();
         return as_if<T, void>(*this)();
 	}
 
     template<typename T, typename S>
     inline const T Node::as(const S& fallback) const
     {
+        if(!m_isValid)
+            throw InvalidNode();
         return as_if<T, S>(*this)(fallback);
     }
     
 	inline const std::string& Node::Scalar() const
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar;
 	}
 
 	inline const std::string& Node::Tag() const
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar;
 	}
 
 	inline void Node::SetTag(const std::string& tag)
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		EnsureNodeExists();
 		m_pNode->set_tag(tag);
 	}
@@ -156,6 +176,8 @@ namespace YAML
 	// assignment
 	inline bool Node::is(const Node& rhs) const
 	{
+        if(!m_isValid || !rhs.m_isValid)
+            throw InvalidNode();
         if(!m_pNode || !rhs.m_pNode)
             return false;
 		return m_pNode->is(*rhs.m_pNode);
@@ -164,37 +186,57 @@ namespace YAML
 	template<typename T>
 	inline Node& Node::operator=(const T& rhs)
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		Assign(rhs);
 		return *this;
 	}
 	
+    inline void Node::reset(const YAML::Node& rhs)
+    {
+        if(!m_isValid || !rhs.m_isValid)
+            throw InvalidNode();
+        m_pMemory = rhs.m_pMemory;
+        m_pNode = rhs.m_pNode;
+    }
+
 	template<typename T>
 	inline void Node::Assign(const T& rhs)
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		AssignData(convert<T>::encode(rhs));
 	}
 
 	template<>
 	inline void Node::Assign(const std::string& rhs)
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		EnsureNodeExists();
 		m_pNode->set_scalar(rhs);
 	}
 
 	inline void Node::Assign(const char *rhs)
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		EnsureNodeExists();
 		m_pNode->set_scalar(rhs);
 	}
 
 	inline void Node::Assign(char *rhs)
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		EnsureNodeExists();
 		m_pNode->set_scalar(rhs);
 	}
 	
 	inline Node& Node::operator=(const Node& rhs)
 	{
+        if(!m_isValid || !rhs.m_isValid)
+            throw InvalidNode();
 		if(is(rhs))
 			return *this;
 		AssignNode(rhs);
@@ -203,6 +245,8 @@ namespace YAML
 
 	inline void Node::AssignData(const Node& rhs)
 	{
+        if(!m_isValid || !rhs.m_isValid)
+            throw InvalidNode();
 		EnsureNodeExists();
 		rhs.EnsureNodeExists();
 		
@@ -212,6 +256,8 @@ namespace YAML
 
 	inline void Node::AssignNode(const Node& rhs)
 	{
+        if(!m_isValid || !rhs.m_isValid)
+            throw InvalidNode();
 		rhs.EnsureNodeExists();
 
 		if(!m_pNode) {
@@ -224,30 +270,40 @@ namespace YAML
 		m_pMemory->merge(*rhs.m_pMemory);
 		m_pNode = rhs.m_pNode;
 	}
-
+    
 	// size/iterator
 	inline std::size_t Node::size() const
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		return m_pNode ? m_pNode->size() : 0;
 	}
 
 	inline const_iterator Node::begin() const
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		return m_pNode ? const_iterator(m_pNode->begin(), m_pMemory) : const_iterator();
 	}
 	
 	inline iterator Node::begin()
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		return m_pNode ? iterator(m_pNode->begin(), m_pMemory) : iterator();
 	}
 
 	inline const_iterator Node::end() const
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		return m_pNode ? const_iterator(m_pNode->end(), m_pMemory) : const_iterator();
 	}
 
 	inline iterator Node::end()
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		return m_pNode ? iterator(m_pNode->end(), m_pMemory) : iterator();
 	}
 	
@@ -255,11 +311,15 @@ namespace YAML
 	template<typename T>
 	inline void Node::push_back(const T& rhs)
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		push_back(Node(rhs));
 	}
 	
 	inline void Node::push_back(const Node& rhs)
 	{
+        if(!m_isValid || !rhs.m_isValid)
+            throw InvalidNode();
 		EnsureNodeExists();
 		rhs.EnsureNodeExists();
 		
@@ -267,32 +327,85 @@ namespace YAML
 		m_pMemory->merge(*rhs.m_pMemory);
 	}
 
+    // helpers for indexing
+    namespace detail {
+        template<typename T>
+        struct to_value_t {
+            explicit to_value_t(const T& t_): t(t_) {}
+            const T& t;
+            typedef const T& return_type;
+            
+            const T& operator()() const { return t; }
+        };
+        
+        template<>
+        struct to_value_t<const char*> {
+            explicit to_value_t(const char *t_): t(t_) {}
+            const char *t;
+            typedef std::string return_type;
+            
+            const std::string operator()() const { return t; }
+        };
+        
+        template<>
+        struct to_value_t<char*> {
+            explicit to_value_t(char *t_): t(t_) {}
+            const char *t;
+            typedef std::string return_type;
+            
+            const std::string operator()() const { return t; }
+        };
+        
+        template<std::size_t N>
+        struct to_value_t<char [N]> {
+            explicit to_value_t(const char *t_): t(t_) {}
+            const char *t;
+            typedef std::string return_type;
+            
+            const std::string operator()() const { return t; }
+        };
+
+        // converts C-strings to std::strings so they can be copied
+        template<typename T>
+        inline typename to_value_t<T>::return_type to_value(const T& t) {
+            return to_value_t<T>(t)();
+        }
+    }
+
 	// indexing
 	template<typename Key>
 	inline const Node Node::operator[](const Key& key) const
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		EnsureNodeExists();
-		detail::node& value = static_cast<const detail::node&>(*m_pNode).get(key, m_pMemory);
+		detail::node& value = static_cast<const detail::node&>(*m_pNode).get(detail::to_value(key), m_pMemory);
 		return Node(value, m_pMemory);
 	}
 	
 	template<typename Key>
 	inline Node Node::operator[](const Key& key)
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		EnsureNodeExists();
-		detail::node& value = m_pNode->get(key, m_pMemory);
+		detail::node& value = m_pNode->get(detail::to_value(key), m_pMemory);
 		return Node(value, m_pMemory);
 	}
 	
 	template<typename Key>
 	inline bool Node::remove(const Key& key)
 	{
+        if(!m_isValid)
+            throw InvalidNode();
 		EnsureNodeExists();
-		return m_pNode->remove(key, m_pMemory);
+		return m_pNode->remove(detail::to_value(key), m_pMemory);
 	}
 	
 	inline const Node Node::operator[](const Node& key) const
 	{
+        if(!m_isValid || !key.m_isValid)
+            throw InvalidNode();
 		EnsureNodeExists();
 		key.EnsureNodeExists();
 		detail::node& value = static_cast<const detail::node&>(*m_pNode).get(*key.m_pNode, m_pMemory);
@@ -301,6 +414,8 @@ namespace YAML
 	
 	inline Node Node::operator[](const Node& key)
 	{
+        if(!m_isValid || !key.m_isValid)
+            throw InvalidNode();
 		EnsureNodeExists();
 		key.EnsureNodeExists();
 		detail::node& value = m_pNode->get(*key.m_pNode, m_pMemory);
@@ -309,43 +424,24 @@ namespace YAML
 	
 	inline bool Node::remove(const Node& key)
 	{
+        if(!m_isValid || !key.m_isValid)
+            throw InvalidNode();
 		EnsureNodeExists();
 		key.EnsureNodeExists();
 		return m_pNode->remove(*key.m_pNode, m_pMemory);
 	}
-	
-	inline const Node Node::operator[](const char *key) const
-	{
-		return operator[](std::string(key));
-	}
-	
-	inline Node Node::operator[](const char *key)
-	{
-		return operator[](std::string(key));
-	}
-	
-	inline bool Node::remove(const char *key)
-	{
-		return remove(std::string(key));
-	}
-	
-	inline const Node Node::operator[](char *key) const
-	{
-		return operator[](static_cast<const char *>(key));
-	}
-	
-	inline Node Node::operator[](char *key)
-	{
-		return operator[](static_cast<const char *>(key));
-	}
-	
-	inline bool Node::remove(char *key)
-	{
-		return remove(static_cast<const char *>(key));
-	}
+    
+    // map
+    template<typename Key, typename Value>
+    inline void Node::force_insert(const Key& key, const Value& value)
+    {
+        if(!m_isValid)
+            throw InvalidNode();
+        EnsureNodeExists();
+		m_pNode->force_insert(detail::to_value(key), detail::to_value(value), m_pMemory);
+    }
 
 	// free functions
-
 	inline bool operator==(const Node& lhs, const Node& rhs)
 	{
 		return lhs.is(rhs);

include/yaml-cpp/node/iterator.h

@@ -19,8 +19,8 @@ namespace YAML
 	namespace detail {
 		struct iterator_value: public Node, std::pair<Node, Node> {
 			iterator_value() {}
-			explicit iterator_value(const Node& rhs): Node(rhs) {}
-			explicit iterator_value(const Node& key, const Node& value): std::pair<Node, Node>(key, value) {}
+			explicit iterator_value(const Node& rhs): Node(rhs), std::pair<Node, Node>(Node(Node::ZombieNode), Node(Node::ZombieNode)) {}
+			explicit iterator_value(const Node& key, const Node& value): Node(Node::ZombieNode), std::pair<Node, Node>(key, value) {}
 		};
 	}
 }

include/yaml-cpp/node/node.h

@@ -20,6 +20,7 @@ namespace YAML
 	public:
 		friend class NodeBuilder;
 		friend class NodeEvents;
+        friend struct detail::iterator_value;
 		friend class detail::node_data;
 		template<typename> friend class detail::iterator_base;
         template<typename T, typename S> friend struct as_if;
@@ -56,7 +57,8 @@ namespace YAML
 		bool is(const Node& rhs) const;
 		template<typename T> Node& operator=(const T& rhs);
 		Node& operator=(const Node& rhs);
-
+        void reset(const Node& rhs = Node());
+        
 		// size/iterator
 		std::size_t size() const;
 
@@ -78,16 +80,14 @@ namespace YAML
 		const Node operator[](const Node& key) const;
 		Node operator[](const Node& key);
 		bool remove(const Node& key);
-		
-		const Node operator[](const char *key) const;
-		Node operator[](const char *key);
-		bool remove(const char *key);
+        
+        // map
+        template<typename Key, typename Value>
+        void force_insert(const Key& key, const Value& value);
 
-		const Node operator[](char *key) const;
-		Node operator[](char *key);
-		bool remove(char *key);
-		
 	private:
+        enum Zombie { ZombieNode };
+        explicit Node(Zombie);
 		explicit Node(detail::node& node, detail::shared_memory_holder pMemory);
 		
 		void EnsureNodeExists() const;
@@ -100,11 +100,14 @@ namespace YAML
 		void AssignNode(const Node& rhs);
 		
 	private:
+        bool m_isValid;
 		mutable detail::shared_memory_holder m_pMemory;
 		mutable detail::node *m_pNode;
 	};
 
 	bool operator==(const Node& lhs, const Node& rhs);
+    
+    Node Clone(const Node& node);
 	
 	template<typename T>
 	struct convert;

include/yaml-cpp/ostream.h

@@ -1,40 +0,0 @@
-#ifndef OSTREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define OSTREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
-#pragma once
-#endif
-
-
-#include <string>
-
-namespace YAML
-{
-	class ostream
-	{
-	public:
-		ostream();
-		~ostream();
-		
-		void reserve(unsigned size);
-		void put(char ch);
-		const char *str() const { return m_buffer; }
-		
-		unsigned row() const { return m_row; }
-		unsigned col() const { return m_col; }
-		unsigned pos() const { return m_pos; }
-		
-	private:
-		char *m_buffer;
-		unsigned m_pos;
-		unsigned m_size;
-		
-		unsigned m_row, m_col;
-	};
-	
-	ostream& operator << (ostream& out, const char *str);
-	ostream& operator << (ostream& out, const std::string& str);
-	ostream& operator << (ostream& out, char ch);
-}
-
-#endif // OSTREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/ostream_wrapper.h

@@ -0,0 +1,69 @@
+#ifndef OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+
+#include <string>
+#include <vector>
+
+namespace YAML
+{
+	class ostream_wrapper
+	{
+	public:
+		ostream_wrapper();
+        explicit ostream_wrapper(std::ostream& stream);
+		~ostream_wrapper();
+		
+        void write(const std::string& str);
+        void write(const char *str, std::size_t size);
+        
+        void set_comment() { m_comment = true; }
+
+		const char *str() const {
+            if(m_pStream) {
+                return 0;
+            } else {
+                m_buffer[m_pos] = '\0';
+                return &m_buffer[0];
+            }
+        }
+		
+		std::size_t row() const { return m_row; }
+		std::size_t col() const { return m_col; }
+		std::size_t pos() const { return m_pos; }
+        bool comment() const { return m_comment; }
+        
+    private:
+        void update_pos(char ch);
+		
+	private:
+        mutable std::vector<char> m_buffer;
+        std::ostream *m_pStream;
+
+		std::size_t m_pos;
+		std::size_t m_row, m_col;
+        bool m_comment;
+	};
+	
+    template<std::size_t N>
+	inline ostream_wrapper& operator << (ostream_wrapper& stream, const char (&str)[N]) {
+        stream.write(str, N-1);
+        return stream;
+    }
+    
+	inline ostream_wrapper& operator << (ostream_wrapper& stream, const std::string& str) {
+        stream.write(str);
+        return stream;
+    }
+    
+	inline ostream_wrapper& operator << (ostream_wrapper& stream, char ch) {
+        stream.write(&ch, 1);
+        return stream;
+    }
+}
+
+#endif // OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/parser.h

@@ -14,10 +14,8 @@
 namespace YAML
 {
 	struct Directives;
-	struct Mark;
 	struct Token;
 	class EventHandler;
-	class Node;
 	class Scanner;
 
 	class YAML_CPP_API Parser: private noncopyable
@@ -31,9 +29,7 @@ namespace YAML
 
 		void Load(std::istream& in);
 		bool HandleNextDocument(EventHandler& eventHandler);
-		
-		bool GetNextDocument(Node& document); // old API only
-		
+
 		void PrintTokens(std::ostream& out);
 
 	private:

src/emit.cpp

@@ -15,9 +15,8 @@ namespace YAML
 	
 	std::ostream& operator << (std::ostream& out, const Node& node)
 	{
-		Emitter emitter;
+		Emitter emitter(out);
 		emitter << node;
-		out << emitter.c_str();
 		return out;
 	}
 

src/emitterstate.cpp

@@ -4,11 +4,8 @@
 
 namespace YAML
 {
-	EmitterState::EmitterState(): m_isGood(true), m_curIndent(0), m_requiresSoftSeparation(false), m_requiresHardSeparation(false)
+	EmitterState::EmitterState(): m_isGood(true), m_curIndent(0), m_hasAnchor(false), m_hasTag(false), m_hasNonContent(false), m_docCount(0)
 	{
-		// start up
-		m_stateStack.push(ES_WAITING_FOR_DOC);
-		
 		// set default global manipulators
 		m_charset.set(EmitNonAscii);
 		m_strFmt.set(Auto);
@@ -22,8 +19,8 @@ namespace YAML
 		m_seqFmt.set(Block);
 		m_mapFmt.set(Block);
 		m_mapKeyFmt.set(Auto);
-        m_floatPrecision.set(6);
-        m_doublePrecision.set(15);
+        m_floatPrecision.set(std::numeric_limits<float>::digits10 + 1);
+        m_doublePrecision.set(std::numeric_limits<double>::digits10 + 1);
 	}
 	
 	EmitterState::~EmitterState()
@@ -35,21 +32,111 @@ namespace YAML
 	// . Only the ones that make sense will be accepted
 	void EmitterState::SetLocalValue(EMITTER_MANIP value)
 	{
-		SetOutputCharset(value, LOCAL);
-		SetStringFormat(value, LOCAL);
-		SetBoolFormat(value, LOCAL);
-		SetBoolCaseFormat(value, LOCAL);
-		SetBoolLengthFormat(value, LOCAL);
-		SetIntFormat(value, LOCAL);
-		SetFlowType(GT_SEQ, value, LOCAL);
-		SetFlowType(GT_MAP, value, LOCAL);
-		SetMapKeyFormat(value, LOCAL);
+		SetOutputCharset(value, FmtScope::Local);
+		SetStringFormat(value, FmtScope::Local);
+		SetBoolFormat(value, FmtScope::Local);
+		SetBoolCaseFormat(value, FmtScope::Local);
+		SetBoolLengthFormat(value, FmtScope::Local);
+		SetIntFormat(value, FmtScope::Local);
+		SetFlowType(GroupType::Seq, value, FmtScope::Local);
+		SetFlowType(GroupType::Map, value, FmtScope::Local);
+		SetMapKeyFormat(value, FmtScope::Local);
 	}
 	
-	void EmitterState::BeginGroup(GROUP_TYPE type)
+    void EmitterState::SetAnchor()
+    {
+        m_hasAnchor = true;
+    }
+        
+    void EmitterState::SetTag()
+    {
+        m_hasTag = true;
+    }
+
+    void EmitterState::SetNonContent()
+    {
+        m_hasNonContent = true;
+    }
+
+    void EmitterState::SetLongKey()
+    {
+        assert(!m_groups.empty());        
+        if(m_groups.empty())
+            return;
+        
+        assert(m_groups.top().type == GroupType::Map);
+        m_groups.top().longKey = true;
+    }
+    
+    void EmitterState::ForceFlow()
+    {
+        assert(!m_groups.empty());
+        if(m_groups.empty())
+            return;
+        
+        m_groups.top().flowType = FlowType::Flow;
+    }
+
+    void EmitterState::StartedNode()
+    {
+        if(m_groups.empty()) {
+            m_docCount++;
+        } else {
+            m_groups.top().childCount++;
+            if(m_groups.top().childCount % 2 == 0)
+                m_groups.top().longKey = false;
+        }
+        
+        m_hasAnchor = false;
+        m_hasTag = false;
+        m_hasNonContent = false;
+    }
+
+    EmitterNodeType::value EmitterState::NextGroupType(GroupType::value type) const
+    {
+        if(type == GroupType::Seq) {
+            if(GetFlowType(type) == Block)
+                return EmitterNodeType::BlockSeq;
+            else
+                return EmitterNodeType::FlowSeq;
+        } else {
+            if(GetFlowType(type) == Block)
+                return EmitterNodeType::BlockMap;
+            else
+                return EmitterNodeType::FlowMap;
+        }
+        
+        // can't happen
+        assert(false);
+        return EmitterNodeType::None;
+    }
+    
+    void EmitterState::StartedDoc()
+    {
+        m_hasAnchor = false;
+        m_hasTag = false;
+        m_hasNonContent = false;
+    }
+    
+    void EmitterState::EndedDoc()
+    {
+        m_hasAnchor = false;
+        m_hasTag = false;
+        m_hasNonContent = false;
+    }
+
+    void EmitterState::StartedScalar()
+    {
+        StartedNode();
+        ClearModifiedSettings();
+    }
+
+	void EmitterState::StartedGroup(GroupType::value type)
 	{
-		unsigned lastIndent = (m_groups.empty() ? 0 : m_groups.top().indent);
-		m_curIndent += lastIndent;
+        StartedNode();
+
+		const int lastGroupIndent = (m_groups.empty() ? 0 : m_groups.top().indent);
+		m_curIndent += lastGroupIndent;
 		
 		std::auto_ptr<Group> pGroup(new Group(type));
 		
@@ -57,17 +144,23 @@ namespace YAML
 		pGroup->modifiedSettings = m_modifiedSettings;
 
 		// set up group
-		pGroup->flow = GetFlowType(type);
+        if(GetFlowType(type) == Block)
+            pGroup->flowType = FlowType::Block;
+        else
+            pGroup->flowType = FlowType::Flow;
 		pGroup->indent = GetIndent();
-		pGroup->usingLongKey = (GetMapKeyFormat() == LongKey ? true : false);
 
 		m_groups.push(pGroup);
 	}
 	
-	void EmitterState::EndGroup(GROUP_TYPE type)
+	void EmitterState::EndedGroup(GroupType::value type)
 	{
-		if(m_groups.empty())
-			return SetError(ErrorMsg::UNMATCHED_GROUP_TAG);
+		if(m_groups.empty()) {
+            if(type == GroupType::Seq)
+                return SetError(ErrorMsg::UNEXPECTED_END_SEQ);
+            else
+                return SetError(ErrorMsg::UNEXPECTED_END_MAP);
+        }
 		
 		// get rid of the current group
 		{
@@ -84,49 +177,57 @@ namespace YAML
 		// some global settings that we changed may have been overridden
 		// by a local setting we just popped, so we need to restore them
 		m_globalModifiedSettings.restore();
+
+        ClearModifiedSettings();
 	}
-		
-	GROUP_TYPE EmitterState::GetCurGroupType() const
+
+    EmitterNodeType::value EmitterState::CurGroupNodeType() const
+    {
+        if(m_groups.empty())
+            return EmitterNodeType::None;
+        
+        return m_groups.top().NodeType();
+    }
+
+    GroupType::value EmitterState::CurGroupType() const
 	{
-		if(m_groups.empty())
-			return GT_NONE;
-		
-		return m_groups.top().type;
+        return m_groups.empty() ? GroupType::None : m_groups.top().type;
 	}
 	
-	FLOW_TYPE EmitterState::GetCurGroupFlowType() const
+    FlowType::value EmitterState::CurGroupFlowType() const
 	{
-		if(m_groups.empty())
-			return FT_NONE;
-		
-		return (m_groups.top().flow == Flow ? FT_FLOW : FT_BLOCK);
-	}
-	
-	bool EmitterState::CurrentlyInLongKey()
-	{
-		if(m_groups.empty())
-			return false;
-		return m_groups.top().usingLongKey;
-	}
-	
-	void EmitterState::StartLongKey()
-	{
-		if(!m_groups.empty())
-			m_groups.top().usingLongKey = true;
-	}
-	
-	void EmitterState::StartSimpleKey()
-	{
-		if(!m_groups.empty())
-			m_groups.top().usingLongKey = false;
+        return m_groups.empty() ? FlowType::None : m_groups.top().flowType;
 	}
 
+    int EmitterState::CurGroupIndent() const
+    {
+        return m_groups.empty() ? 0 : m_groups.top().indent;
+    }
+
+    std::size_t EmitterState::CurGroupChildCount() const
+    {
+        return m_groups.empty() ? m_docCount : m_groups.top().childCount;
+    }
+
+    bool EmitterState::CurGroupLongKey() const
+    {
+        return m_groups.empty() ? false : m_groups.top().longKey;
+    }
+
+    int EmitterState::LastIndent() const
+    {
+        if(m_groups.size() <= 1)
+            return 0;
+        
+        return m_curIndent - m_groups.top(-1).indent;
+    }
+
 	void EmitterState::ClearModifiedSettings()
 	{
 		m_modifiedSettings.clear();
 	}
 
-	bool EmitterState::SetOutputCharset(EMITTER_MANIP value, FMT_SCOPE scope)
+	bool EmitterState::SetOutputCharset(EMITTER_MANIP value, FmtScope::value scope)
 	{
 		switch(value) {
 			case EmitNonAscii:
@@ -138,7 +239,7 @@ namespace YAML
 		}
 	}
 	
-	bool EmitterState::SetStringFormat(EMITTER_MANIP value, FMT_SCOPE scope)
+	bool EmitterState::SetStringFormat(EMITTER_MANIP value, FmtScope::value scope)
 	{
 		switch(value) {
 			case Auto:
@@ -152,7 +253,7 @@ namespace YAML
 		}
 	}
 	
-	bool EmitterState::SetBoolFormat(EMITTER_MANIP value, FMT_SCOPE scope)
+	bool EmitterState::SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope)
 	{
 		switch(value) {
 			case OnOffBool:
@@ -165,7 +266,7 @@ namespace YAML
 		}
 	}
 
-	bool EmitterState::SetBoolLengthFormat(EMITTER_MANIP value, FMT_SCOPE scope)
+	bool EmitterState::SetBoolLengthFormat(EMITTER_MANIP value, FmtScope::value scope)
 	{
 		switch(value) {
 			case LongBool:
@@ -177,7 +278,7 @@ namespace YAML
 		}
 	}
 
-	bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value, FMT_SCOPE scope)
+	bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value, FmtScope::value scope)
 	{
 		switch(value) {
 			case UpperCase:
@@ -190,7 +291,7 @@ namespace YAML
 		}
 	}
 
-	bool EmitterState::SetIntFormat(EMITTER_MANIP value, FMT_SCOPE scope)
+	bool EmitterState::SetIntFormat(EMITTER_MANIP value, FmtScope::value scope)
 	{
 		switch(value) {
 			case Dec:
@@ -203,16 +304,16 @@ namespace YAML
 		}
 	}
 
-	bool EmitterState::SetIndent(unsigned value, FMT_SCOPE scope)
+	bool EmitterState::SetIndent(unsigned value, FmtScope::value scope)
 	{
-		if(value == 0)
+		if(value <= 1)
 			return false;
 		
 		_Set(m_indent, value, scope);
 		return true;
 	}
 
-	bool EmitterState::SetPreCommentIndent(unsigned value, FMT_SCOPE scope)
+	bool EmitterState::SetPreCommentIndent(unsigned value, FmtScope::value scope)
 	{
 		if(value == 0)
 			return false;
@@ -221,7 +322,7 @@ namespace YAML
 		return true;
 	}
 	
-	bool EmitterState::SetPostCommentIndent(unsigned value, FMT_SCOPE scope)
+	bool EmitterState::SetPostCommentIndent(unsigned value, FmtScope::value scope)
 	{
 		if(value == 0)
 			return false;
@@ -230,30 +331,29 @@ namespace YAML
 		return true;
 	}
 
-	bool EmitterState::SetFlowType(GROUP_TYPE groupType, EMITTER_MANIP value, FMT_SCOPE scope)
+	bool EmitterState::SetFlowType(GroupType::value groupType, EMITTER_MANIP value, FmtScope::value scope)
 	{
 		switch(value) {
 			case Block:
 			case Flow:
-				_Set(groupType == GT_SEQ ? m_seqFmt : m_mapFmt, value, scope);
+				_Set(groupType == GroupType::Seq ? m_seqFmt : m_mapFmt, value, scope);
 				return true;
 			default:
 				return false;
 		}
 	}
 
-	EMITTER_MANIP EmitterState::GetFlowType(GROUP_TYPE groupType) const
+	EMITTER_MANIP EmitterState::GetFlowType(GroupType::value groupType) const
 	{
 		// force flow style if we're currently in a flow
-		FLOW_TYPE flowType = GetCurGroupFlowType();
-		if(flowType == FT_FLOW)
+		if(CurGroupFlowType() == FlowType::Flow)
 			return Flow;
 		
-		// otherwise, go with what's asked of use
-		return (groupType == GT_SEQ ? m_seqFmt.get() : m_mapFmt.get());
+		// otherwise, go with what's asked of us
+		return (groupType == GroupType::Seq ? m_seqFmt.get() : m_mapFmt.get());
 	}
 	
-	bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FMT_SCOPE scope)
+	bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope)
 	{
 		switch(value) {
 			case Auto:
@@ -265,17 +365,17 @@ namespace YAML
 		}
 	}
 
-    bool EmitterState::SetFloatPrecision(int value, FMT_SCOPE scope)
+    bool EmitterState::SetFloatPrecision(int value, FmtScope::value scope)
     {
-        if(value < 0 || value > std::numeric_limits<float>::digits10)
+        if(value < 0 || value > std::numeric_limits<float>::digits10 + 1)
             return false;
         _Set(m_floatPrecision, value, scope);
         return true;
     }
     
-    bool EmitterState::SetDoublePrecision(int value, FMT_SCOPE scope)
+    bool EmitterState::SetDoublePrecision(int value, FmtScope::value scope)
     {
-        if(value < 0 || value > std::numeric_limits<double>::digits10)
+        if(value < 0 || value > std::numeric_limits<double>::digits10 + 1)
             return false;
         _Set(m_doublePrecision, value, scope);
         return true;

src/emitterstate.h

@@ -8,71 +8,20 @@
 
 #include "ptr_stack.h"
 #include "setting.h"
+#include "yaml-cpp/emitterdef.h"
 #include "yaml-cpp/emittermanip.h"
 #include <cassert>
 #include <vector>
 #include <stack>
 #include <memory>
+#include <stdexcept>
 
 namespace YAML
 {
-	enum FMT_SCOPE {
-		LOCAL,
-		GLOBAL
-	};
-	
-	enum GROUP_TYPE {
-		GT_NONE,
-		GT_SEQ,
-		GT_MAP
-	};
-	
-	enum FLOW_TYPE {
-		FT_NONE,
-		FT_FLOW,
-		FT_BLOCK
-	};
-	
-	enum NODE_STATE {
-		NS_START,
-		NS_READY_FOR_ATOM,
-		NS_END
-	};
-	
-	enum EMITTER_STATE {
-		ES_WAITING_FOR_DOC,
-		ES_WRITING_DOC,
-		ES_DONE_WITH_DOC,
-		
-		// block seq
-		ES_WAITING_FOR_BLOCK_SEQ_ENTRY,
-		ES_WRITING_BLOCK_SEQ_ENTRY,
-		ES_DONE_WITH_BLOCK_SEQ_ENTRY,
-		
-		// flow seq
-		ES_WAITING_FOR_FLOW_SEQ_ENTRY,
-		ES_WRITING_FLOW_SEQ_ENTRY,
-		ES_DONE_WITH_FLOW_SEQ_ENTRY,
-		
-		// block map
-		ES_WAITING_FOR_BLOCK_MAP_ENTRY,
-		ES_WAITING_FOR_BLOCK_MAP_KEY,
-		ES_WRITING_BLOCK_MAP_KEY,
-		ES_DONE_WITH_BLOCK_MAP_KEY,
-		ES_WAITING_FOR_BLOCK_MAP_VALUE,
-		ES_WRITING_BLOCK_MAP_VALUE,
-		ES_DONE_WITH_BLOCK_MAP_VALUE,
-		
-		// flow map
-		ES_WAITING_FOR_FLOW_MAP_ENTRY,
-		ES_WAITING_FOR_FLOW_MAP_KEY,
-		ES_WRITING_FLOW_MAP_KEY,
-		ES_DONE_WITH_FLOW_MAP_KEY,
-		ES_WAITING_FOR_FLOW_MAP_VALUE,
-		ES_WRITING_FLOW_MAP_VALUE,
-		ES_DONE_WITH_FLOW_MAP_VALUE
-	};
-	
+	struct FmtScope { enum value { Local, Global }; };
+	struct GroupType { enum value { None, Seq, Map }; };
+	struct FlowType { enum value { None, Flow, Block }; };
+
 	class EmitterState
 	{
 	public:
@@ -84,76 +33,81 @@ namespace YAML
 		const std::string GetLastError() const { return m_lastError; }
 		void SetError(const std::string& error) { m_isGood = false; m_lastError = error; }
 		
-		// main state of the machine
-		EMITTER_STATE GetCurState() const { return m_stateStack.top(); }
-		void SwitchState(EMITTER_STATE state) { PopState(); PushState(state); }
-		void PushState(EMITTER_STATE state) { m_stateStack.push(state); }
-		void PopState() { m_stateStack.pop(); }
-		
-		void SetLocalValue(EMITTER_MANIP value);
-		
-		// group handling
-		void BeginGroup(GROUP_TYPE type);
-		void EndGroup(GROUP_TYPE type);
-		
-		GROUP_TYPE GetCurGroupType() const;
-		FLOW_TYPE GetCurGroupFlowType() const;
-		int GetCurIndent() const { return m_curIndent; }
-		
-		bool CurrentlyInLongKey();
-		void StartLongKey();
-		void StartSimpleKey();
+		// node handling
+        void SetAnchor();
+        void SetTag();
+        void SetNonContent();
+        void SetLongKey();
+        void ForceFlow();
+        void StartedDoc();
+        void EndedDoc();
+        void StartedScalar();
+		void StartedGroup(GroupType::value type);
+		void EndedGroup(GroupType::value type);
 
-		bool RequiresSoftSeparation() const { return m_requiresSoftSeparation; }
-		bool RequiresHardSeparation() const { return m_requiresHardSeparation; }
-		void RequireSoftSeparation() { m_requiresSoftSeparation = true; }
-		void RequireHardSeparation() { m_requiresSoftSeparation = true; m_requiresHardSeparation = true; }
-		void ForceHardSeparation() { m_requiresSoftSeparation = false; }
-		void UnsetSeparation() { m_requiresSoftSeparation = false; m_requiresHardSeparation = false; }
+        EmitterNodeType::value NextGroupType(GroupType::value type) const;
+        EmitterNodeType::value CurGroupNodeType() const;
+
+		GroupType::value CurGroupType() const;
+        FlowType::value CurGroupFlowType() const;
+        int CurGroupIndent() const;
+        std::size_t CurGroupChildCount() const;
+        bool CurGroupLongKey() const;
+
+        int LastIndent() const;
+		int CurIndent() const { return m_curIndent; }
+        bool HasAnchor() const { return m_hasAnchor; }
+        bool HasTag() const { return m_hasTag; }
+        bool HasBegunNode() const { return m_hasAnchor || m_hasTag || m_hasNonContent; }
+        bool HasBegunContent() const { return m_hasAnchor || m_hasTag; }
 
 		void ClearModifiedSettings();
 
 		// formatters
-		bool SetOutputCharset(EMITTER_MANIP value, FMT_SCOPE scope);
+		void SetLocalValue(EMITTER_MANIP value);
+
+		bool SetOutputCharset(EMITTER_MANIP value, FmtScope::value scope);
 		EMITTER_MANIP GetOutputCharset() const { return m_charset.get(); }
 
-		bool SetStringFormat(EMITTER_MANIP value, FMT_SCOPE scope);
+		bool SetStringFormat(EMITTER_MANIP value, FmtScope::value scope);
 		EMITTER_MANIP GetStringFormat() const { return m_strFmt.get(); }
 		
-		bool SetBoolFormat(EMITTER_MANIP value, FMT_SCOPE scope);
+		bool SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope);
 		EMITTER_MANIP GetBoolFormat() const { return m_boolFmt.get(); }
 
-		bool SetBoolLengthFormat(EMITTER_MANIP value, FMT_SCOPE scope);
+		bool SetBoolLengthFormat(EMITTER_MANIP value, FmtScope::value scope);
 		EMITTER_MANIP GetBoolLengthFormat() const { return m_boolLengthFmt.get(); }
 
-		bool SetBoolCaseFormat(EMITTER_MANIP value, FMT_SCOPE scope);
+		bool SetBoolCaseFormat(EMITTER_MANIP value, FmtScope::value scope);
 		EMITTER_MANIP GetBoolCaseFormat() const { return m_boolCaseFmt.get(); }
 
-		bool SetIntFormat(EMITTER_MANIP value, FMT_SCOPE scope);
+		bool SetIntFormat(EMITTER_MANIP value, FmtScope::value scope);
 		EMITTER_MANIP GetIntFormat() const { return m_intFmt.get(); }
 
-		bool SetIndent(unsigned value, FMT_SCOPE scope);
+		bool SetIndent(unsigned value, FmtScope::value scope);
 		int GetIndent() const { return m_indent.get(); }
 		
-		bool SetPreCommentIndent(unsigned value, FMT_SCOPE scope);
+		bool SetPreCommentIndent(unsigned value, FmtScope::value scope);
 		int GetPreCommentIndent() const { return m_preCommentIndent.get(); }
-		bool SetPostCommentIndent(unsigned value, FMT_SCOPE scope);
+		bool SetPostCommentIndent(unsigned value, FmtScope::value scope);
 		int GetPostCommentIndent() const { return m_postCommentIndent.get(); }
 		
-		bool SetFlowType(GROUP_TYPE groupType, EMITTER_MANIP value, FMT_SCOPE scope);
-		EMITTER_MANIP GetFlowType(GROUP_TYPE groupType) const;
+		bool SetFlowType(GroupType::value groupType, EMITTER_MANIP value, FmtScope::value scope);
+		EMITTER_MANIP GetFlowType(GroupType::value groupType) const;
 		
-		bool SetMapKeyFormat(EMITTER_MANIP value, FMT_SCOPE scope);
+		bool SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope);
 		EMITTER_MANIP GetMapKeyFormat() const { return m_mapKeyFmt.get(); }
         
-        bool SetFloatPrecision(int value, FMT_SCOPE scope);
+        bool SetFloatPrecision(int value, FmtScope::value scope);
         unsigned GetFloatPrecision() const { return m_floatPrecision.get(); }
-        bool SetDoublePrecision(int value, FMT_SCOPE scope);
+        bool SetDoublePrecision(int value, FmtScope::value scope);
         unsigned GetDoublePrecision() const { return m_doublePrecision.get(); }
 		
 	private:
 		template <typename T>
-		void _Set(Setting<T>& fmt, T value, FMT_SCOPE scope);
+		void _Set(Setting<T>& fmt, T value, FmtScope::value scope);
+        
+        void StartedNode();
 		
 	private:
 		// basic state ok?
@@ -161,8 +115,6 @@ namespace YAML
 		std::string m_lastError;
 		
 		// other state
-		std::stack<EMITTER_STATE> m_stateStack;
-		
 		Setting<EMITTER_MANIP> m_charset;
 		Setting<EMITTER_MANIP> m_strFmt;
 		Setting<EMITTER_MANIP> m_boolFmt;
@@ -181,29 +133,50 @@ namespace YAML
 		SettingChanges m_globalModifiedSettings;
 		
 		struct Group {
-			Group(GROUP_TYPE type_): type(type_), usingLongKey(false), indent(0) {}
+			explicit Group(GroupType::value type_): type(type_), indent(0), childCount(0), longKey(false) {}
 			
-			GROUP_TYPE type;
-			EMITTER_MANIP flow;
-			bool usingLongKey;
+            GroupType::value type;
+            FlowType::value flowType;
 			int indent;
+            std::size_t childCount;
+            bool longKey;
 			
 			SettingChanges modifiedSettings;
+            
+            EmitterNodeType::value NodeType() const {
+                if(type == GroupType::Seq) {
+                    if(flowType == FlowType::Flow)
+                        return EmitterNodeType::FlowSeq;
+                    else
+                        return EmitterNodeType::BlockSeq;
+                } else {
+                    if(flowType == FlowType::Flow)
+                        return EmitterNodeType::FlowMap;
+                    else
+                        return EmitterNodeType::BlockMap;
+                }
+
+                // can't get here
+                assert(false);
+                return EmitterNodeType::None;
+            }
 		};
 
 		ptr_stack<Group> m_groups;
 		unsigned m_curIndent;
-		bool m_requiresSoftSeparation;
-		bool m_requiresHardSeparation;
+        bool m_hasAnchor;
+        bool m_hasTag;
+        bool m_hasNonContent;
+        std::size_t m_docCount;
 	};
 
 	template <typename T>
-	void EmitterState::_Set(Setting<T>& fmt, T value, FMT_SCOPE scope) {
+	void EmitterState::_Set(Setting<T>& fmt, T value, FmtScope::value scope) {
 		switch(scope) {
-			case LOCAL:
+			case FmtScope::Local:
 				m_modifiedSettings.push(fmt.set(value));
 				break;
-			case GLOBAL:
+			case FmtScope::Global:
 				fmt.set(value);
 				m_globalModifiedSettings.push(fmt.set(value));  // this pushes an identity set, so when we restore,
 				                                                // it restores to the value here, and not the previous one

src/emitterutils.cpp

@@ -107,7 +107,7 @@ namespace YAML
 				return true;
 			}
 			
-			void WriteCodePoint(ostream& out, int codePoint) {
+			void WriteCodePoint(ostream_wrapper& out, int codePoint) {
 				if (codePoint < 0 || codePoint > 0x10FFFF) {
 					codePoint = REPLACEMENT_CHARACTER;
 				}
@@ -128,12 +128,12 @@ namespace YAML
 				}
 			}
 			
-			bool IsValidPlainScalar(const std::string& str, bool inFlow, bool allowOnlyAscii) {
+			bool IsValidPlainScalar(const std::string& str, FlowType::value flowType, bool allowOnlyAscii) {
 				if(str.empty())
 					return false;
 				
 				// first check the start
-				const RegEx& start = (inFlow ? Exp::PlainScalarInFlow() : Exp::PlainScalar());
+				const RegEx& start = (flowType == FlowType::Flow ? Exp::PlainScalarInFlow() : Exp::PlainScalar());
 				if(!start.Matches(str))
 					return false;
 				
@@ -142,7 +142,7 @@ namespace YAML
 					return false;
 
 				// then check until something is disallowed
-				const RegEx& disallowed = (inFlow ? Exp::EndScalarInFlow() : Exp::EndScalar())
+				const RegEx& disallowed = (flowType == FlowType::Flow ? Exp::EndScalarInFlow() : Exp::EndScalar())
 				                          || (Exp::BlankOrBreak() + Exp::Comment())
 				                          || Exp::NotPrintable()
 				                          || Exp::Utf8_ByteOrderMark()
@@ -152,7 +152,7 @@ namespace YAML
 				while(buffer) {
 					if(disallowed.Matches(buffer))
 						return false;
-					if(allowOnlyAscii && (0x7F < static_cast<unsigned char>(buffer[0]))) 
+					if(allowOnlyAscii && (0x80 <= static_cast<unsigned char>(buffer[0]))) 
 						return false;
 					++buffer;
 				}
@@ -160,30 +160,53 @@ namespace YAML
 				return true;
 			}
 
-			void WriteDoubleQuoteEscapeSequence(ostream& out, int codePoint) {
+			bool IsValidSingleQuotedScalar(const std::string& str, bool escapeNonAscii)
+            {
+                // TODO: check for non-printable characters?
+                for(std::size_t i=0;i<str.size();i++) {
+                    if(escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i])))
+                       return false;
+                    if(str[i] == '\n')
+                        return false;
+                }
+                return true;
+			}
+            
+            bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType, bool escapeNonAscii)
+            {
+                if(flowType == FlowType::Flow)
+                    return false;
+
+                // TODO: check for non-printable characters?
+                for(std::size_t i=0;i<str.size();i++) {
+                    if(escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i])))
+                        return false;
+                }
+                return true;
+            }
+			
+            void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint) {
 				static const char hexDigits[] = "0123456789abcdef";
 
-				char escSeq[] = "\\U00000000";
+                out << "\\";
 				int digits = 8;
-				if (codePoint < 0xFF) {
-					escSeq[1] = 'x';
+				if(codePoint < 0xFF) {
+                    out << "x";
 					digits = 2;
-				} else if (codePoint < 0xFFFF) {
-					escSeq[1] = 'u';
+				} else if(codePoint < 0xFFFF) {
+                    out << "u";
 					digits = 4;
-				}
+				} else {
+                    out << "U";
+                    digits = 8;
+                }
 
 				// Write digits into the escape sequence
-				int i = 2;
-				for (; digits > 0; --digits, ++i) {
-					escSeq[i] = hexDigits[(codePoint >> (4 * (digits - 1))) & 0xF];
-				}
-
-				escSeq[i] = 0; // terminate with NUL character
-				out << escSeq;
+				for (; digits > 0; --digits)
+					out << hexDigits[(codePoint >> (4 * (digits - 1))) & 0xF];
 			}
 
-			bool WriteAliasName(ostream& out, const std::string& str) {
+			bool WriteAliasName(ostream_wrapper& out, const std::string& str) {
 				int codePoint;
 				for(std::string::const_iterator i = str.begin();
 					GetNextCodePointAndAdvance(codePoint, i, str.end());
@@ -198,16 +221,31 @@ namespace YAML
 			}
 		}
 		
-		bool WriteString(ostream& out, const std::string& str, bool inFlow, bool escapeNonAscii)
-		{
-			if(IsValidPlainScalar(str, inFlow, escapeNonAscii)) {
-				out << str;
-				return true;
-			} else
-				return WriteDoubleQuotedString(out, str, escapeNonAscii);
-		}
-		
-		bool WriteSingleQuotedString(ostream& out, const std::string& str)
+        StringFormat::value ComputeStringFormat(const std::string& str, EMITTER_MANIP strFormat, FlowType::value flowType, bool escapeNonAscii)
+        {
+            switch(strFormat) {
+                case Auto:
+                    if(IsValidPlainScalar(str, flowType, escapeNonAscii))
+                        return StringFormat::Plain;
+                    return StringFormat::DoubleQuoted;
+                case SingleQuoted:
+                    if(IsValidSingleQuotedScalar(str, escapeNonAscii))
+                        return StringFormat::SingleQuoted;
+                    return StringFormat::DoubleQuoted;
+                case DoubleQuoted:
+                    return StringFormat::DoubleQuoted;
+                case Literal:
+                    if(IsValidLiteralScalar(str, flowType, escapeNonAscii))
+                        return StringFormat::Literal;
+                    return StringFormat::DoubleQuoted;
+                default:
+                    break;
+            }
+
+            return StringFormat::DoubleQuoted;
+        }
+
+		bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str)
 		{
 			out << "'";
 			int codePoint;
@@ -227,7 +265,7 @@ namespace YAML
 			return true;
 		}
 		
-		bool WriteDoubleQuotedString(ostream& out, const std::string& str, bool escapeNonAscii)
+		bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str, bool escapeNonAscii)
 		{
 			out << "\"";
 			int codePoint;
@@ -235,24 +273,29 @@ namespace YAML
 				GetNextCodePointAndAdvance(codePoint, i, str.end());
 				) 
 			{
-				if (codePoint == '\"')
-					out << "\\\"";
-				else if (codePoint == '\\')
-					out << "\\\\";
-				else if (codePoint < 0x20 || (codePoint >= 0x80 && codePoint <= 0xA0)) // Control characters and non-breaking space
-					WriteDoubleQuoteEscapeSequence(out, codePoint);
-				else if (codePoint == 0xFEFF) // Byte order marks (ZWNS) should be escaped (YAML 1.2, sec. 5.2)	
-					WriteDoubleQuoteEscapeSequence(out, codePoint);
-				else if (escapeNonAscii && codePoint > 0x7E)
-					WriteDoubleQuoteEscapeSequence(out, codePoint);
-				else
-					WriteCodePoint(out, codePoint);
+                switch(codePoint) {
+                    case '\"': out << "\\\""; break;
+                    case '\\': out << "\\\\"; break;
+                    case '\n': out << "\\n"; break;
+                    case '\t': out << "\\t"; break;
+                    case '\r': out << "\\r"; break;
+                    case '\b': out << "\\b"; break;
+                    default:
+                        if(codePoint < 0x20 || (codePoint >= 0x80 && codePoint <= 0xA0)) // Control characters and non-breaking space
+                            WriteDoubleQuoteEscapeSequence(out, codePoint);
+                        else if (codePoint == 0xFEFF) // Byte order marks (ZWNS) should be escaped (YAML 1.2, sec. 5.2)	
+                            WriteDoubleQuoteEscapeSequence(out, codePoint);
+                        else if (escapeNonAscii && codePoint > 0x7E)
+                            WriteDoubleQuoteEscapeSequence(out, codePoint);
+                        else
+                            WriteCodePoint(out, codePoint);
+                }
 			}
 			out << "\"";
 			return true;
 		}
 
-		bool WriteLiteralString(ostream& out, const std::string& str, int indent)
+		bool WriteLiteralString(ostream_wrapper& out, const std::string& str, int indent)
 		{
 			out << "|\n";
 			out << IndentTo(indent);
@@ -269,7 +312,7 @@ namespace YAML
 			return true;
 		}
 		
-		bool WriteChar(ostream& out, char ch)
+		bool WriteChar(ostream_wrapper& out, char ch)
 		{
 			if(('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z'))
 				out << ch;
@@ -289,36 +332,39 @@ namespace YAML
 			return true;
 		}
 
-		bool WriteComment(ostream& out, const std::string& str, int postCommentIndent)
+		bool WriteComment(ostream_wrapper& out, const std::string& str, int postCommentIndent)
 		{
 			const unsigned curIndent = out.col();
 			out << "#" << Indentation(postCommentIndent);
+            out.set_comment();
 			int codePoint;
 			for(std::string::const_iterator i = str.begin();
 				GetNextCodePointAndAdvance(codePoint, i, str.end());
 				)
 			{
-				if(codePoint == '\n')
+				if(codePoint == '\n') {
 					out << "\n" << IndentTo(curIndent) << "#" << Indentation(postCommentIndent);
-				else
+                    out.set_comment();
+				} else {
 					WriteCodePoint(out, codePoint);
+                }
 			}
 			return true;
 		}
 
-		bool WriteAlias(ostream& out, const std::string& str)
+		bool WriteAlias(ostream_wrapper& out, const std::string& str)
 		{
 			out << "*";
 			return WriteAliasName(out, str);
 		}
 		
-		bool WriteAnchor(ostream& out, const std::string& str)
+		bool WriteAnchor(ostream_wrapper& out, const std::string& str)
 		{
 			out << "&";
 			return WriteAliasName(out, str);
 		}
 
-		bool WriteTag(ostream& out, const std::string& str, bool verbatim)
+		bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim)
 		{
 			out << (verbatim ? "!<" : "!");
 			StringCharSource buffer(str.c_str(), str.size());
@@ -338,7 +384,7 @@ namespace YAML
 			return true;
 		}
 
-		bool WriteTagWithPrefix(ostream& out, const std::string& prefix, const std::string& tag)
+		bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix, const std::string& tag)
 		{
 			out << "!";
 			StringCharSource prefixBuffer(prefix.c_str(), prefix.size());
@@ -368,7 +414,7 @@ namespace YAML
 			return true;
 		}
 
-		bool WriteBinary(ostream& out, const Binary& binary)
+		bool WriteBinary(ostream_wrapper& out, const Binary& binary)
 		{
             WriteDoubleQuotedString(out, EncodeBase64(binary.data(), binary.size()), false);
             return true;

src/emitterutils.h

@@ -6,26 +6,30 @@
 #endif
 
 
-#include "yaml-cpp/ostream.h"
+#include "emitterstate.h"
+#include "yaml-cpp/ostream_wrapper.h"
 #include <string>
 
 namespace YAML
 {
     class Binary;
     
+    struct StringFormat { enum value { Plain, SingleQuoted, DoubleQuoted, Literal }; };
+
 	namespace Utils
 	{
-		bool WriteString(ostream& out, const std::string& str, bool inFlow, bool escapeNonAscii);
-		bool WriteSingleQuotedString(ostream& out, const std::string& str);
-		bool WriteDoubleQuotedString(ostream& out, const std::string& str, bool escapeNonAscii);
-		bool WriteLiteralString(ostream& out, const std::string& str, int indent);
-		bool WriteChar(ostream& out, char ch);
-		bool WriteComment(ostream& out, const std::string& str, int postCommentIndent);
-		bool WriteAlias(ostream& out, const std::string& str);
-		bool WriteAnchor(ostream& out, const std::string& str);
-		bool WriteTag(ostream& out, const std::string& str, bool verbatim);
-		bool WriteTagWithPrefix(ostream& out, const std::string& prefix, const std::string& tag);
-		bool WriteBinary(ostream& out, const Binary& binary);
+        StringFormat::value ComputeStringFormat(const std::string& str, EMITTER_MANIP strFormat, FlowType::value flowType, bool escapeNonAscii);
+        
+		bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str);
+		bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str, bool escapeNonAscii);
+		bool WriteLiteralString(ostream_wrapper& out, const std::string& str, int indent);
+		bool WriteChar(ostream_wrapper& out, char ch);
+		bool WriteComment(ostream_wrapper& out, const std::string& str, int postCommentIndent);
+		bool WriteAlias(ostream_wrapper& out, const std::string& str);
+		bool WriteAnchor(ostream_wrapper& out, const std::string& str);
+		bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim);
+		bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix, const std::string& tag);
+		bool WriteBinary(ostream_wrapper& out, const Binary& binary);
 	}
 }
 

src/exp.h

@@ -91,7 +91,7 @@ namespace YAML
 			return e;
 		}
 		inline const RegEx& Key() {
-			static const RegEx e = RegEx('?');
+			static const RegEx e = RegEx('?') + BlankOrBreak();
 			return e;
 		}
 		inline const RegEx& KeyInFlow() {

src/indentation.h

@@ -6,7 +6,7 @@
 #endif
 
 
-#include "yaml-cpp/ostream.h"
+#include "yaml-cpp/ostream_wrapper.h"
 #include <iostream>
 
 namespace YAML
@@ -16,7 +16,7 @@ namespace YAML
 		unsigned n;
 	};
 	
-	inline ostream& operator << (ostream& out, const Indentation& indent) {
+	inline ostream_wrapper& operator << (ostream_wrapper& out, const Indentation& indent) {
 		for(unsigned i=0;i<indent.n;i++)
 			out << ' ';
 		return out;
@@ -27,7 +27,7 @@ namespace YAML
 		unsigned n;
 	};
 	
-	inline ostream& operator << (ostream& out, const IndentTo& indent) {
+	inline ostream_wrapper& operator << (ostream_wrapper& out, const IndentTo& indent) {
 		while(out.col() < indent.n)
 			out << ' ';
 		return out;

src/node.cpp

@@ -0,0 +1,14 @@
+#include "yaml-cpp/node/node.h"
+#include "nodebuilder.h"
+#include "nodeevents.h"
+
+namespace YAML
+{
+    Node Clone(const Node& node)
+    {
+		NodeEvents events(node);
+        NodeBuilder builder;
+        events.Emit(builder);
+        return builder.Root();
+    }
+}

src/ostream.cpp

@@ -1,63 +0,0 @@
-#include "yaml-cpp/ostream.h"
-#include <cstring>
-
-namespace YAML
-{
-	ostream::ostream(): m_buffer(0), m_pos(0), m_size(0), m_row(0), m_col(0)
-	{
-		reserve(1024);
-	}
-	
-	ostream::~ostream()
-	{
-		delete [] m_buffer;
-	}
-	
-	void ostream::reserve(unsigned size)
-	{
-		if(size <= m_size)
-			return;
-		
-		char *newBuffer = new char[size];
-		std::memset(newBuffer, 0, size * sizeof(char));
-		std::memcpy(newBuffer, m_buffer, m_size * sizeof(char));
-		delete [] m_buffer;
-		m_buffer = newBuffer;
-		m_size = size;
-	}
-	
-	void ostream::put(char ch)
-	{
-		if(m_pos >= m_size - 1)   // an extra space for the NULL terminator
-			reserve(m_size * 2);
-		
-		m_buffer[m_pos] = ch;
-		m_pos++;
-		
-		if(ch == '\n') {
-			m_row++;
-			m_col = 0;
-		} else
-			m_col++;
-	}
-
-	ostream& operator << (ostream& out, const char *str)
-	{
-		std::size_t length = std::strlen(str);
-		for(std::size_t i=0;i<length;i++)
-			out.put(str[i]);
-		return out;
-	}
-	
-	ostream& operator << (ostream& out, const std::string& str)
-	{
-		out << str.c_str();
-		return out;
-	}
-	
-	ostream& operator << (ostream& out, char ch)
-	{
-		out.put(ch);
-		return out;
-	}
-}

src/ostream_wrapper.cpp

@@ -0,0 +1,56 @@
+#include "yaml-cpp/ostream_wrapper.h"
+#include <cstring>
+#include <iostream>
+
+namespace YAML
+{
+	ostream_wrapper::ostream_wrapper(): m_pStream(0), m_pos(0), m_row(0), m_col(0), m_comment(false)
+	{
+	}
+	
+	ostream_wrapper::ostream_wrapper(std::ostream& stream): m_pStream(&stream), m_pos(0), m_row(0), m_col(0), m_comment(false)
+	{
+	}
+
+	ostream_wrapper::~ostream_wrapper()
+	{
+	}
+	
+    void ostream_wrapper::write(const std::string& str)
+    {
+        if(m_pStream) {
+            m_pStream->write(str.c_str(), str.size());
+        } else {
+            m_buffer.resize(std::max(m_buffer.size(), m_pos + str.size() + 1));
+            std::copy(str.begin(), str.end(), &m_buffer[m_pos]);
+        }
+        
+        for(std::size_t i=0;i<str.size();i++)
+            update_pos(str[i]);
+    }
+
+    void ostream_wrapper::write(const char *str, std::size_t size)
+    {
+        if(m_pStream) {
+            m_pStream->write(str, size);
+        } else {
+            m_buffer.resize(std::max(m_buffer.size(), m_pos + size + 1));
+            std::copy(str, str + size, &m_buffer[m_pos]);
+        }
+        
+        for(std::size_t i=0;i<size;i++)
+            update_pos(str[i]);
+    }
+	
+    void ostream_wrapper::update_pos(char ch)
+    {
+		m_pos++;
+        m_col++;
+		
+		if(ch == '\n') {
+			m_row++;
+			m_col = 0;
+            m_comment = false;
+		}
+    }
+}

src/parse.cpp

@@ -30,6 +30,8 @@ namespace YAML
 
     Node LoadFile(const std::string& filename) {
         std::ifstream fin(filename.c_str());
+        if(!fin)
+            throw BadFile();
         return Load(fin);
     }
 
@@ -59,6 +61,8 @@ namespace YAML
 
     std::vector<Node> LoadAllFromFile(const std::string& filename) {
         std::ifstream fin(filename.c_str());
+        if(!fin)
+            throw BadFile();
         return LoadAll(fin);
     }
 }

src/ptr_stack.h

@@ -38,7 +38,10 @@ public:
 	}
 	T& top() { return *m_data.back(); }
 	const T& top() const { return *m_data.back(); }
-	
+
+	T& top(std::ptrdiff_t diff) { return **(m_data.end() - 1 + diff); }
+	const T& top(std::ptrdiff_t diff) const { return **(m_data.end() - 1 + diff); }
+
 private:
 	std::vector<T*> m_data;
 };

src/scanner.cpp

@@ -51,6 +51,13 @@ namespace YAML
 		return m_tokens.front();
 	}
 
+    // mark
+    // . Returns the current mark in the stream
+    Mark Scanner::mark() const
+    {
+        return INPUT.mark();
+    }
+
 	// EnsureTokensInQueue
 	// . Scan until there's a valid token at the front of the queue,
 	//   or we're sure the queue is empty.
@@ -376,7 +383,7 @@ namespace YAML
 	// . Does not parse any more tokens.
 	void Scanner::ThrowParserException(const std::string& msg) const
 	{
-		Mark mark = Mark::null();
+		Mark mark = Mark::null_mark();
 		if(!m_tokens.empty()) {
 			const Token& token = m_tokens.front();
 			mark = token.mark;

src/scanner.h

@@ -31,6 +31,7 @@ namespace YAML
 		bool empty();
 		void pop();
 		Token& peek();
+        Mark mark() const;
 
 	private:
 		struct IndentMarker {

src/singledocparser.cpp

@@ -48,7 +48,7 @@ namespace YAML
 	{
 		// an empty node *is* a possibility
 		if(m_scanner.empty()) {
-			eventHandler.OnNull(Mark::null(), NullAnchor);
+			eventHandler.OnNull(m_scanner.mark(), NullAnchor);
 			return;
 		}
 		
@@ -57,7 +57,7 @@ namespace YAML
 		
 		// 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);
+			eventHandler.OnMapStart(mark, "?", NullAnchor);
 			HandleMap(eventHandler);
 			eventHandler.OnMapEnd();
 			return;
@@ -75,6 +75,12 @@ namespace YAML
 		ParseProperties(tag, anchor);
 		
 		const Token& token = m_scanner.peek();
+
+        if(token.type == Token::PLAIN_SCALAR && token.value == "null") {
+            eventHandler.OnNull(mark, anchor);
+            m_scanner.pop();
+            return;
+        }
 		
 		// add non-specific tags
 		if(tag.empty())
@@ -136,7 +142,7 @@ namespace YAML
 		
 		while(1) {
 			if(m_scanner.empty())
-				throw ParserException(Mark::null(), ErrorMsg::END_OF_SEQ);
+				throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ);
 			
 			Token token = m_scanner.peek();
 			if(token.type != Token::BLOCK_ENTRY && token.type != Token::BLOCK_SEQ_END)
@@ -169,7 +175,7 @@ namespace YAML
 		
 		while(1) {
 			if(m_scanner.empty())
-				throw ParserException(Mark::null(), ErrorMsg::END_OF_SEQ_FLOW);
+				throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW);
 			
 			// first check for end
 			if(m_scanner.peek().type == Token::FLOW_SEQ_END) {
@@ -179,6 +185,9 @@ namespace YAML
 			
 			// then read the node
 			HandleNode(eventHandler);
+            
+            if(m_scanner.empty())
+				throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW);
 			
 			// 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();
@@ -211,7 +220,7 @@ namespace YAML
 		
 		while(1) {
 			if(m_scanner.empty())
-				throw ParserException(Mark::null(), ErrorMsg::END_OF_MAP);
+				throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP);
 			
 			Token token = m_scanner.peek();
 			if(token.type != Token::KEY && token.type != Token::VALUE && token.type != Token::BLOCK_MAP_END)
@@ -250,9 +259,10 @@ namespace YAML
 		
 		while(1) {
 			if(m_scanner.empty())
-				throw ParserException(Mark::null(), ErrorMsg::END_OF_MAP_FLOW);
+				throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW);
 			
 			Token& token = m_scanner.peek();
+            const Mark mark = token.mark;
 			// first check for end
 			if(token.type == Token::FLOW_MAP_END) {
 				m_scanner.pop();
@@ -264,7 +274,7 @@ namespace YAML
 				m_scanner.pop();
 				HandleNode(eventHandler);
 			} else {
-				eventHandler.OnNull(token.mark, NullAnchor);
+				eventHandler.OnNull(mark, NullAnchor);
 			}
 			
 			// now grab value (optional)
@@ -272,8 +282,11 @@ namespace YAML
 				m_scanner.pop();
 				HandleNode(eventHandler);
 			} else {
-				eventHandler.OnNull(token.mark, NullAnchor);
+				eventHandler.OnNull(mark, NullAnchor);
 			}
+            
+            if(m_scanner.empty())
+				throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW);
 			
 			// 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();

test/core/parsertests.cpp

@@ -0,0 +1,77 @@
+#include "parsertests.h"
+#include "handlermacros.h"
+#include "yaml-cpp/yaml.h"
+#include <iostream>
+
+namespace Test
+{
+    namespace Parser {
+		TEST NoEndOfMapFlow()
+        {
+            try {
+                HANDLE("---{header: {id: 1");
+            } catch(const YAML::ParserException& e) {
+                YAML_ASSERT(e.msg == std::string(YAML::ErrorMsg::END_OF_MAP_FLOW));
+                return true;
+            }
+            return "  no exception caught";
+        }
+        
+        TEST PlainScalarStartingWithQuestionMark()
+        {
+            HANDLE("foo: ?bar");
+            EXPECT_DOC_START();
+            EXPECT_MAP_START("?", 0);
+            EXPECT_SCALAR("?", 0, "foo");
+            EXPECT_SCALAR("?", 0, "?bar");
+            EXPECT_MAP_END();
+            EXPECT_DOC_END();
+            DONE();
+        }
+
+        TEST NullStringScalar()
+        {
+            HANDLE("foo: null");
+            EXPECT_DOC_START();
+            EXPECT_MAP_START("?", 0);
+            EXPECT_SCALAR("?", 0, "foo");
+            EXPECT_NULL(0);
+            EXPECT_MAP_END();
+            EXPECT_DOC_END();
+            DONE();
+        }
+    }
+    
+	namespace {
+		void RunParserTest(TEST (*test)(), const std::string& name, int& passed, int& total) {
+			TEST ret;
+			try {
+				ret = test();
+			} catch(const YAML::Exception& e) {
+				ret.ok = false;
+				ret.error = std::string("  Exception caught: ") + e.what();
+			}
+			
+			if(!ret.ok) {
+				std::cout << "Parser test failed: " << name << "\n";
+				std::cout << ret.error << "\n";
+			}
+			
+			if(ret.ok)
+				passed++;
+			total++;
+		}
+	}
+	
+	bool RunParserTests()
+	{
+		int passed = 0;
+		int total = 0;
+		RunParserTest(&Parser::NoEndOfMapFlow, "No end of map flow", passed, total);
+		RunParserTest(&Parser::PlainScalarStartingWithQuestionMark, "Plain scalar starting with question mark", passed, total);
+		RunParserTest(&Parser::NullStringScalar, "Null string scalar", passed, total);
+		
+		std::cout << "Parser tests: " << passed << "/" << total << " passed\n";
+		return passed == total;
+	}
+}

test/create-emitter-tests.py

@@ -0,0 +1,184 @@
+import sys
+import yaml
+import hashlib
+
+NS = 'Emitter'
+DEFINE = 'YAML_GEN_TESTS'
+EVENT_COUNT = 5
+
+def encode_stream(line):
+    for c in line:
+        if c == '\n':
+            yield '\\n'
+        elif c == '"':
+            yield '\\"'
+        elif c == '\t':
+            yield '\\t'
+        elif ord(c) < 0x20:
+            yield '\\x' + hex(ord(c))
+        else:
+            yield c
+
+def encode(line):
+    return ''.join(encode_stream(line))
+
+def doc_start(implicit=False):
+    if implicit:
+        return {'emit': '', 'handle': 'DOC_START()'}
+    else:
+        return {'emit': 'YAML::BeginDoc', 'handle': 'DOC_START()'}
+
+def doc_end(implicit=False):
+    if implicit:
+        return {'emit': '', 'handle': 'DOC_END()'}
+    else:
+        return {'emit': 'YAML::EndDoc', 'handle': 'DOC_END()'}
+
+def scalar(value, tag='', anchor='', anchor_id=0):
+    emit = []
+    if tag:
+        emit += ['YAML::VerbatimTag("%s")' % encode(tag)]
+    if anchor:
+        emit += ['YAML::Anchor("%s")' % encode(anchor)]
+    if tag:
+        out_tag = encode(tag)
+    else:
+        if value == encode(value):
+            out_tag = '?'
+        else:
+            out_tag = '!'
+    emit += ['"%s"' % encode(value)]
+    return {'emit': emit, 'handle': 'SCALAR("%s", %s, "%s")' % (out_tag, anchor_id, encode(value))}
+
+def comment(value):
+    return {'emit': 'YAML::Comment("%s")' % value, 'handle': ''}
+
+def seq_start(tag='', anchor='', anchor_id=0):
+    emit = []
+    if tag:
+        emit += ['YAML::VerbatimTag("%s")' % encode(tag)]
+    if anchor:
+        emit += ['YAML::Anchor("%s")' % encode(anchor)]
+    if tag:
+        out_tag = encode(tag)
+    else:
+        out_tag = '?'
+    emit += ['YAML::BeginSeq']
+    return {'emit': emit, 'handle': 'SEQ_START("%s", %s)' % (out_tag, anchor_id)}
+
+def seq_end():
+    return {'emit': 'YAML::EndSeq', 'handle': 'SEQ_END()'}
+
+def map_start(tag='', anchor='', anchor_id=0):
+    emit = []
+    if tag:
+        emit += ['YAML::VerbatimTag("%s")' % encode(tag)]
+    if anchor:
+        emit += ['YAML::Anchor("%s")' % encode(anchor)]
+    if tag:
+        out_tag = encode(tag)
+    else:
+        out_tag = '?'
+    emit += ['YAML::BeginMap']
+    return {'emit': emit, 'handle': 'MAP_START("%s", %s)' % (out_tag, anchor_id)}
+
+def map_end():
+    return {'emit': 'YAML::EndMap', 'handle': 'MAP_END()'}
+
+def gen_templates():
+    yield [[doc_start(), doc_start(True)],
+           [scalar('foo'), scalar('foo\n'), scalar('foo', 'tag'), scalar('foo', '', 'anchor', 1)],
+           [doc_end(), doc_end(True)]]
+    yield [[doc_start(), doc_start(True)],
+           [seq_start()],
+           [[], [scalar('foo')], [scalar('foo', 'tag')], [scalar('foo', '', 'anchor', 1)], [scalar('foo', 'tag', 'anchor', 1)], [scalar('foo'), scalar('bar')], [scalar('foo', 'tag', 'anchor', 1), scalar('bar', 'tag', 'other', 2)]],
+           [seq_end()],
+           [doc_end(), doc_end(True)]]
+    yield [[doc_start(), doc_start(True)],
+           [map_start()],
+           [[], [scalar('foo'), scalar('bar')], [scalar('foo', 'tag', 'anchor', 1), scalar('bar', 'tag', 'other', 2)]],
+           [map_end()],
+           [doc_end(), doc_end(True)]]
+    yield [[doc_start(True)],
+           [map_start()],
+           [[scalar('foo')], [seq_start(), scalar('foo'), seq_end()], [map_start(), scalar('foo'), scalar('bar'), map_end()]],
+           [[scalar('foo')], [seq_start(), scalar('foo'), seq_end()], [map_start(), scalar('foo'), scalar('bar'), map_end()]],
+           [map_end()],
+           [doc_end(True)]]
+    yield [[doc_start(True)],
+           [seq_start()],
+           [[scalar('foo')], [seq_start(), scalar('foo'), seq_end()], [map_start(), scalar('foo'), scalar('bar'), map_end()]],
+           [[scalar('foo')], [seq_start(), scalar('foo'), seq_end()], [map_start(), scalar('foo'), scalar('bar'), map_end()]],
+           [seq_end()],
+           [doc_end(True)]]
+
+def expand(template):
+    if len(template) == 0:
+        pass
+    elif len(template) == 1:
+        for item in template[0]:
+            if isinstance(item, list):
+                yield item
+            else:
+                yield [item]
+    else:
+        for car in expand(template[:1]):
+            for cdr in expand(template[1:]):
+                yield car + cdr
+            
+
+def gen_events():
+    for template in gen_templates():
+        for events in expand(template):
+            base = list(events)
+            for i in range(0, len(base)+1):
+                cpy = list(base)
+                cpy.insert(i, comment('comment'))
+                yield cpy
+
+def gen_tests():
+    for events in gen_events():
+        name = 'test' + hashlib.sha1(''.join(yaml.dump(event) for event in events)).hexdigest()[:20]
+        yield {'name': name, 'events': events}
+        
+
+def create_emitter_tests(out):
+    out.write('#ifdef %s\n' % DEFINE)
+    out.write('namespace %s {\n' % NS)
+
+    tests = list(gen_tests())
+
+    for test in tests:
+        out.write('TEST %s(YAML::Emitter& out)\n' % test['name'])
+        out.write('{\n')
+        for event in test['events']:
+            emit = event['emit']
+            if isinstance(emit, list):
+                for e in emit:
+                    out.write('    out << %s;\n' % e)
+            elif emit:
+                out.write('    out << %s;\n' % emit)
+        out.write('\n')
+        out.write('    HANDLE(out.c_str());\n')
+        for event in test['events']:
+            handle = event['handle']
+            if handle:
+                out.write('    EXPECT_%s;\n' % handle)
+        out.write('    DONE();\n')
+        out.write('}\n')
+
+    out.write('}\n')
+    out.write('#endif // %s\n\n' % DEFINE)
+
+    out.write('void RunGenEmitterTests(int& passed, int& total)\n')
+    out.write('{\n')
+    out.write('#ifdef %s\n' % DEFINE)
+    for test in tests:
+        out.write('    RunGenEmitterTest(&Emitter::%s, "%s", passed, total);\n' % (test['name'], encode(test['name'])))
+    out.write('#else // %s\n' % DEFINE)
+    out.write('   (void)passed; (void)total;\n')
+    out.write('#endif // %s\n' % DEFINE)
+    out.write('}\n')
+
+if __name__ == '__main__':
+    create_emitter_tests(sys.stdout)

test/emittertests.cpp

@@ -1,4 +1,5 @@
 #include "tests.h"
+#include "handlermacros.h"
 #include "yaml-cpp/yaml.h"
 #include <iostream>
 
@@ -190,7 +191,7 @@ namespace Test
 			out << YAML::Value << "demon";
 			out << YAML::EndMap;
 			
-			desiredOutput = "?\n  - 1\n  - 3\n: monster\n? [2, 0]\n: demon";
+			desiredOutput = "? - 1\n  - 3\n: monster\n? [2, 0]\n: demon";
 		}
 
 		void AutoLongKey(YAML::Emitter& out, std::string& desiredOutput)
@@ -204,7 +205,7 @@ namespace Test
 			out << YAML::Value << "angel";
 			out << YAML::EndMap;
 			
-			desiredOutput = "?\n  - 1\n  - 3\n: monster\n? [2, 0]\n: demon\nthe origin: angel";
+			desiredOutput = "? - 1\n  - 3\n: monster\n[2, 0]: demon\nthe origin: angel";
 		}
 		
 		void ScalarFormat(YAML::Emitter& out, std::string& desiredOutput)
@@ -218,7 +219,7 @@ namespace Test
 			out << YAML::Literal << "literal scalar\nthat may span\nmany, many\nlines and have \"whatever\" crazy\tsymbols that we like";
 			out << YAML::EndSeq;
 			
-			desiredOutput = "- simple scalar\n- 'explicit single-quoted scalar'\n- \"explicit double-quoted scalar\"\n- \"auto-detected\\x0adouble-quoted scalar\"\n- a non-\"auto-detected\" double-quoted scalar\n- |\n  literal scalar\n  that may span\n  many, many\n  lines and have \"whatever\" crazy\tsymbols that we like";
+			desiredOutput = "- simple scalar\n- 'explicit single-quoted scalar'\n- \"explicit double-quoted scalar\"\n- \"auto-detected\\ndouble-quoted scalar\"\n- a non-\"auto-detected\" double-quoted scalar\n- |\n  literal scalar\n  that may span\n  many, many\n  lines and have \"whatever\" crazy\tsymbols that we like";
 		}
 
 		void AutoLongKeyScalar(YAML::Emitter& out, std::string& desiredOutput)
@@ -256,7 +257,7 @@ namespace Test
 			out << "total value";
 			out << YAML::EndMap;
 			
-			desiredOutput = "?\n  key: value\n  next key: next value\n: total value";
+			desiredOutput = "? key: value\n  next key: next value\n: total value";
 		}
 		
 		void AliasAndAnchor(YAML::Emitter& out, std::string& desiredOutput)
@@ -539,7 +540,7 @@ namespace Test
 		{
 			out << YAML::Flow << YAML::BeginSeq << "foo" << YAML::Comment("foo!") << "bar" << YAML::EndSeq;
 			
-			desiredOutput = "[foo  # foo!\n, bar]";
+			desiredOutput = "[foo,  # foo!\nbar]";
 		}
 
 		void CommentInFlowMap(YAML::Emitter& out, std::string& desiredOutput)
@@ -550,7 +551,7 @@ namespace Test
 			out << YAML::Key << "baz" << YAML::Value << "baz value" << YAML::Comment("baz!");
 			out << YAML::EndMap;
 			
-			desiredOutput = "{foo: foo value, bar: bar value  # bar!\n, baz: baz value  # baz!\n}";
+			desiredOutput = "{foo: foo value, bar: bar value,  # bar!\nbaz: baz value,  # baz!\n}";
 		}
 
 		void Indentation(YAML::Emitter& out, std::string& desiredOutput)
@@ -563,7 +564,7 @@ namespace Test
 			out << YAML::EndMap;
 			out << YAML::EndSeq;
 			
-			desiredOutput = "-   key 1: value 1\n    key 2:\n        - a\n        - b\n        - c";
+			desiredOutput = "-   key 1: value 1\n    key 2:\n        -   a\n        -   b\n        -   c";
 		}
 
 		void SimpleGlobalSettings(YAML::Emitter& out, std::string& desiredOutput)
@@ -597,7 +598,7 @@ namespace Test
 			out << YAML::EndMap;
 			out << YAML::EndSeq;
 			
-			desiredOutput = "- key 1: value 1\n  key 2: [a, b, c]\n- ? [1, 2]\n  :\n    a: b";
+			desiredOutput = "- key 1: value 1\n  key 2: [a, b, c]\n- [1, 2]:\n    a: b";
 		}
 
 		void Null(YAML::Emitter& out, std::string& desiredOutput)
@@ -720,7 +721,7 @@ namespace Test
 			out << YAML::Flow << YAML::BeginSeq;
 			out << "a" << YAML::Newline << "b" << "c" << YAML::Newline << "d";
 			out << YAML::EndSeq;
-			desiredOutput = "[a\n, b, c\n, d]";
+			desiredOutput = "[a,\nb, c,\nd]";
 		}
 
 		void NewlineInBlockMap(YAML::Emitter& out, std::string& desiredOutput)
@@ -730,7 +731,7 @@ namespace Test
 			out << YAML::Key << "b" << YAML::Newline << YAML::Value << "bar";
 			out << YAML::LongKey << YAML::Key << "c" << YAML::Newline << YAML::Value << "car";
 			out << YAML::EndMap;
-			desiredOutput = "a: foo\n\nb: bar\n? c\n\n: car";
+			desiredOutput = "a: foo\nb:\n  bar\n? c\n\n: car";
 		}
 		
 		void NewlineInFlowMap(YAML::Emitter& out, std::string& desiredOutput)
@@ -739,7 +740,7 @@ namespace Test
 			out << YAML::Key << "a" << YAML::Value << "foo" << YAML::Newline;
 			out << YAML::Key << "b" << YAML::Value << "bar";
 			out << YAML::EndMap;
-			desiredOutput = "{a: foo\n, b: bar}";
+			desiredOutput = "{a: foo,\nb: bar}";
 		}
 		
 		void LotsOfNewlines(YAML::Emitter& out, std::string& desiredOutput)
@@ -755,7 +756,7 @@ namespace Test
 			out << YAML::LongKey << YAML::Key << "f" << YAML::Newline << YAML::Value << "foo";
 			out << YAML::EndMap;
 			out << YAML::EndSeq;
-			desiredOutput = "- a\n\n-\n  - b\n  - c\n\n\n-\n  d: e\n  ? f\n\n  : foo";
+			desiredOutput = "- a\n\n-\n  - b\n  - c\n\n\n-\n  d:\n    e\n  ? f\n\n  : foo";
 		}
 		
 		void Binary(YAML::Emitter& out, std::string& desiredOutput)
@@ -911,7 +912,40 @@ namespace Test
             desiredOutput = "[31, 0x1f, 037]";
         }
         
-        ////////////////////////////////////////////////////////////////////////////////////////////////////////
+        void CompactMapWithNewline(YAML::Emitter& out, std::string& desiredOutput)
+        {
+            out << YAML::Comment("Characteristics");
+            out << YAML::BeginSeq;
+            out << YAML::BeginMap;
+            out << YAML::Key << "color" << YAML::Value << "blue";
+            out << YAML::Key << "height" << YAML::Value << 120;
+            out << YAML::EndMap;
+            out << YAML::Newline << YAML::Newline;
+            out << YAML::Comment("Skills");
+            out << YAML::BeginMap;
+            out << YAML::Key << "attack" << YAML::Value << 23;
+            out << YAML::Key << "intelligence" << YAML::Value << 56;
+            out << YAML::EndMap;
+            out << YAML::EndSeq;
+            
+            desiredOutput =
+            "# Characteristics\n"
+            "- color: blue\n"
+            "  height: 120\n"
+            "\n"
+            "# Skills\n"
+            "- attack: 23\n"
+            "  intelligence: 56";
+        }
+        
+		void ForceSingleQuotedToDouble(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::SingleQuoted << "Hello\nWorld";
+
+            desiredOutput = "\"Hello\\nWorld\"";
+		}
+        
+        ////////////////////////////////////////////////////////////////////////////////
 		// incorrect emitting
 		
 		void ExtraEndSeq(YAML::Emitter& out, std::string& desiredError)
@@ -935,13 +969,6 @@ namespace Test
 			out << YAML::EndMap;
 		}
 
-		void BadSingleQuoted(YAML::Emitter& out, std::string& desiredError)
-		{
-			desiredError = YAML::ErrorMsg::SINGLE_QUOTED_CHAR;
-			
-			out << YAML::SingleQuoted << "Hello\nWorld";
-		}
-
 		void InvalidAnchor(YAML::Emitter& out, std::string& desiredError)
 		{
 			desiredError = YAML::ErrorMsg::INVALID_ANCHOR;
@@ -959,43 +986,6 @@ namespace Test
 			out << YAML::Alias("new\nline");
 			out << YAML::EndSeq;
 		}
-
-		void MissingKey(YAML::Emitter& out, std::string& desiredError)
-		{
-			desiredError = YAML::ErrorMsg::EXPECTED_KEY_TOKEN;
-			
-			out << YAML::BeginMap;
-			out << YAML::Key << "key" << YAML::Value << "value";
-			out << "missing key" << YAML::Value << "value";
-			out << YAML::EndMap;
-		}
-		
-		void MissingValue(YAML::Emitter& out, std::string& desiredError)
-		{
-			desiredError = YAML::ErrorMsg::EXPECTED_VALUE_TOKEN;
-			
-			out << YAML::BeginMap;
-			out << YAML::Key << "key" << "value";
-			out << YAML::EndMap;
-		}
-
-		void UnexpectedKey(YAML::Emitter& out, std::string& desiredError)
-		{
-			desiredError = YAML::ErrorMsg::UNEXPECTED_KEY_TOKEN;
-			
-			out << YAML::BeginSeq;
-			out << YAML::Key << "hi";
-			out << YAML::EndSeq;
-		}
-		
-		void UnexpectedValue(YAML::Emitter& out, std::string& desiredError)
-		{
-			desiredError = YAML::ErrorMsg::UNEXPECTED_VALUE_TOKEN;
-			
-			out << YAML::BeginSeq;
-			out << YAML::Value << "hi";
-			out << YAML::EndSeq;
-		}
 	}
 	
 	namespace {
@@ -1043,7 +1033,37 @@ namespace Test
 			}
 			total++;
 		}
+        
+        void RunGenEmitterTest(TEST (*test)(YAML::Emitter&), const std::string& name, int& passed, int& total) {
+            YAML::Emitter out;
+            TEST ret;
+
+			try {
+				ret = test(out);
+			} catch(const YAML::Exception& e) {
+				ret.ok = false;
+				ret.error = std::string("  Exception caught: ") + e.what();
+			}
+            
+            if(!out.good()) {
+                ret.ok = false;
+                ret.error = out.GetLastError();
+            }
+			
+			if(!ret.ok) {
+				std::cout << "Generated emitter test failed: " << name << "\n";
+                std::cout << "Output:\n";
+                std::cout << out.c_str() << "<<<\n";
+				std::cout << ret.error << "\n";
+			}
+			
+			if(ret.ok)
+				passed++;
+			total++;
+        }
 	}
+    
+#include "genemittertests.h"
 	
 	bool RunEmitterTests()
 	{
@@ -1126,17 +1146,16 @@ namespace Test
 		RunEmitterTest(&Emitter::SetPrecision, "set precision", passed, total);
 		RunEmitterTest(&Emitter::DashInBlockContext, "dash in block context", passed, total);
 		RunEmitterTest(&Emitter::HexAndOct, "hex and oct", passed, total);
+		RunEmitterTest(&Emitter::CompactMapWithNewline, "compact map with newline", passed, total);
+        RunEmitterTest(&Emitter::ForceSingleQuotedToDouble, "force single quoted to double", passed, total);
 		
 		RunEmitterErrorTest(&Emitter::ExtraEndSeq, "extra EndSeq", passed, total);
 		RunEmitterErrorTest(&Emitter::ExtraEndMap, "extra EndMap", passed, total);
-		RunEmitterErrorTest(&Emitter::BadSingleQuoted, "bad single quoted string", passed, total);
 		RunEmitterErrorTest(&Emitter::InvalidAnchor, "invalid anchor", passed, total);
 		RunEmitterErrorTest(&Emitter::InvalidAlias, "invalid alias", passed, total);
-		RunEmitterErrorTest(&Emitter::MissingKey, "missing key", passed, total);
-		RunEmitterErrorTest(&Emitter::MissingValue, "missing value", passed, total);
-		RunEmitterErrorTest(&Emitter::UnexpectedKey, "unexpected key", passed, total);
-		RunEmitterErrorTest(&Emitter::UnexpectedValue, "unexpected value", passed, total);
 		RunEmitterErrorTest(&Emitter::BadLocalTag, "bad local tag", passed, total);
+        
+        RunGenEmitterTests(passed, total);
 
 		std::cout << "Emitter tests: " << passed << "/" << total << " passed\n";
 		return passed == total;

test/handlermacros.h

@@ -0,0 +1,190 @@
+#include "teststruct.h"
+#pragma once
+
+#include "yaml-cpp/yaml.h"
+#include "yaml-cpp/eventhandler.h"
+#include <string>
+#include <cassert>
+
+namespace Test {
+    inline std::string Quote(const std::string& text) {
+        YAML::Emitter out;
+        out << YAML::DoubleQuoted << text;
+        return out.c_str();
+    }
+    
+    struct Event {
+        enum Type { DocStart, DocEnd, Null, Alias, Scalar, SeqStart, SeqEnd, MapStart, MapEnd };
+        
+        typedef YAML::Mark Mark;
+        typedef YAML::anchor_t anchor_t;
+        
+        Event(Type type_, const std::string& tag_, anchor_t anchor_, const std::string& scalar_): type(type_), tag(tag_), anchor(anchor_), scalar(scalar_) {}
+        
+        Type type;
+        std::string tag;
+        anchor_t anchor;
+        std::string scalar;
+        
+        std::ostream& write(std::ostream& out) const {
+            switch(type) {
+                case DocStart:
+                    return out << "DocStart";
+                case DocEnd:
+                    return out << "DocEnd";
+                case Null:
+                    return out << "Null(" << anchor << ")";
+                case Alias:
+                    return out << "Alias(" << anchor << ")";
+                case Scalar:
+                    return out << "Scalar(" << Quote(tag) << ", " << anchor << ", " << Quote(scalar) << ")";
+                case SeqStart:
+                    return out << "SeqStart(" << Quote(tag) << ", " << anchor << ")";
+                case SeqEnd:
+                    return out << "SeqEnd";
+                case MapStart:
+                    return out << "MapStart(" << Quote(tag) << ", " << anchor << ")";
+                case MapEnd:
+                    return out << "MapEnd";
+            }
+            assert(false);
+            return out;
+        }
+    };
+    
+    inline std::ostream& operator << (std::ostream& out, const Event& event) {
+        return event.write(out);
+    }
+    
+    inline bool operator == (const Event& a, const Event& b) {
+        return a.type == b.type && a.tag == b.tag && a.anchor == b.anchor && a.scalar == b.scalar;
+    }
+    
+    inline bool operator != (const Event& a, const Event& b) {
+        return !(a == b);
+    }
+    
+	class MockEventHandler: public YAML::EventHandler
+	{
+	public:
+        typedef YAML::Mark Mark;
+        typedef YAML::anchor_t anchor_t;
+        
+        MockEventHandler() {}
+        
+		virtual void OnDocumentStart(const Mark&) {
+            m_actualEvents.push_back(Event(Event::DocStart, "", 0, ""));
+        }
+        
+		virtual void OnDocumentEnd() {
+            m_actualEvents.push_back(Event(Event::DocEnd, "", 0, ""));
+        }
+		
+		virtual void OnNull(const Mark&, anchor_t anchor) {
+            m_actualEvents.push_back(Event(Event::Null, "", anchor, ""));
+        }
+        
+		virtual void OnAlias(const Mark&, anchor_t anchor) {
+            m_actualEvents.push_back(Event(Event::Alias, "", anchor, ""));
+        }
+        
+		virtual void OnScalar(const Mark&, const std::string& tag, anchor_t anchor, const std::string& value) {
+            m_actualEvents.push_back(Event(Event::Scalar, tag, anchor, value));
+        }
+        
+		virtual void OnSequenceStart(const Mark&, const std::string& tag, anchor_t anchor) {
+            m_actualEvents.push_back(Event(Event::SeqStart, tag, anchor, ""));
+        }
+        
+		virtual void OnSequenceEnd() {
+            m_actualEvents.push_back(Event(Event::SeqEnd, "", 0, ""));
+        }
+        
+		virtual void OnMapStart(const Mark&, const std::string& tag, anchor_t anchor) {
+            m_actualEvents.push_back(Event(Event::MapStart, tag, anchor, ""));
+        }
+        
+		virtual void OnMapEnd() {
+            m_actualEvents.push_back(Event(Event::MapEnd, "", 0, ""));
+        }
+        
+        void Expect(const Event& event) { m_expectedEvents.push_back(event); }
+        
+        Test::TEST Check() const {
+            std::size_t N = std::max(m_expectedEvents.size(), m_actualEvents.size());
+            for(std::size_t i=0;i<N;i++) {
+                if(i >= m_expectedEvents.size()) {
+                    std::stringstream out;
+                    for(std::size_t j=0;j<i;j++) {
+                        out << "  " << m_expectedEvents[j] << "\n";
+                    }
+                    out << "  EXPECTED: (no event expected)\n";
+                    out << "  ACTUAL  : " << m_actualEvents[i] << "\n";
+                    return out.str().c_str();
+                }
+                
+                if(i >= m_actualEvents.size()) {
+                    std::stringstream out;
+                    for(std::size_t j=0;j<i;j++) {
+                        out << "  " << m_expectedEvents[j] << "\n";
+                    }
+                    out << "  EXPECTED: " << m_expectedEvents[i] << "\n";
+                    out << "  ACTUAL  : (no event recorded)\n";
+                    return out.str().c_str();
+                }
+                
+                if(m_expectedEvents[i] != m_actualEvents[i]) {
+                    std::stringstream out;
+                    for(std::size_t j=0;j<i;j++) {
+                        out << "  " <<  m_expectedEvents[j] << "\n";
+                    }
+                    out << "  EXPECTED: " << m_expectedEvents[i] << "\n";
+                    out << "  ACTUAL  : " << m_actualEvents[i] << "\n";
+                    return out.str().c_str();
+                }
+            }
+            
+            return true;
+        }
+        
+        std::vector<Event> m_expectedEvents;
+        std::vector<Event> m_actualEvents;
+	};
+    
+#define HANDLE(ex)\
+MockEventHandler handler;\
+std::stringstream stream(ex);\
+YAML::Parser parser(stream);\
+while(parser.HandleNextDocument(handler)) {}
+
+#define EXPECT_DOC_START()\
+handler.Expect(Event(Event::DocStart, "", 0, ""))
+    
+#define EXPECT_DOC_END()\
+handler.Expect(Event(Event::DocEnd, "", 0, ""))
+    
+#define EXPECT_NULL(anchor)\
+handler.Expect(Event(Event::Null, "", anchor, ""))
+    
+#define EXPECT_ALIAS(anchor)\
+handler.Expect(Event(Event::Alias, "", anchor, ""))
+    
+#define EXPECT_SCALAR(tag, anchor, value)\
+handler.Expect(Event(Event::Scalar, tag, anchor, value))
+    
+#define EXPECT_SEQ_START(tag, anchor)\
+handler.Expect(Event(Event::SeqStart, tag, anchor, ""))
+    
+#define EXPECT_SEQ_END()\
+handler.Expect(Event(Event::SeqEnd, "", 0, ""))
+    
+#define EXPECT_MAP_START(tag, anchor)\
+handler.Expect(Event(Event::MapStart, tag, anchor, ""))
+    
+#define EXPECT_MAP_END()\
+handler.Expect(Event(Event::MapEnd, "", 0, ""))
+    
+#define DONE()\
+return handler.Check()
+    
+}

test/new-api/nodetests.cpp

@@ -8,15 +8,33 @@ namespace {
 		TEST(): ok(false) {}
 		TEST(bool ok_): ok(ok_) {}
 		TEST(const char *error_): ok(false), error(error_) {}
+        TEST(const std::string& error_): ok(false), error(error_) {}
 		
 		bool ok;
 		std::string error;
 	};
 }
 
-#define YAML_ASSERT(cond) do { if(!(cond)) return "  Assert failed: " #cond; } while(false)
+#define YAML_ASSERT(cond)\
+    do {\
+        if(!(cond))\
+            return "  Assert failed: " #cond;\
+    } while(false)
 
-#define YAML_ASSERT_THROWS(cond, exc) do { try { (cond); return "  Expression did not throw: " #cond; } catch(const exc&) {} catch(...) { return "  Expression threw something other than " #exc ": " #cond; } } while(false)
+#define YAML_ASSERT_THROWS(cond, exc)\
+    do {\
+        try {\
+            (cond);\
+            return "  Expression did not throw: " #cond;\
+        } catch(const exc&) {\
+        } catch(const std::runtime_error& e) {\
+            std::stringstream stream;\
+            stream << "  Expression threw runtime error ther than " #exc ":\n    " #cond "\n    " << e.what();\
+            return stream.str();\
+        } catch(...) {\
+            return "  Expression threw unknown exception, other than " #exc ":\n    " #cond;\
+        }\
+    } while(false)
 
 namespace Test
 {
@@ -168,7 +186,19 @@ namespace Test
 			return true;
 		}
 		
-		TEST SimpleAlias()
+		TEST StdPair()
+		{
+			std::pair<int, std::string> p;
+            p.first = 5;
+            p.second = "five";
+			
+			YAML::Node node;
+			node["pair"] = p;
+			YAML_ASSERT((node["pair"].as<std::pair<int, std::string> >() == p));
+			return true;
+		}
+
+        TEST SimpleAlias()
 		{
 			YAML::Node node;
 			node["foo"] = "value";
@@ -307,7 +337,7 @@ namespace Test
             YAML::Node node = YAML::Load("[1.5, 1, .nan, .inf, -.inf, 0x15, 015]");
             YAML_ASSERT(node[0].as<float>() == 1.5f);
             YAML_ASSERT(node[0].as<double>() == 1.5);
-            YAML_ASSERT_THROWS(node[0].as<int>(), std::runtime_error);
+            YAML_ASSERT_THROWS(node[0].as<int>(), YAML::TypedBadConversion<int>);
             YAML_ASSERT(node[1].as<int>() == 1);
             YAML_ASSERT(node[1].as<float>() == 1.0f);
             YAML_ASSERT(node[2].as<float>() != node[2].as<float>());
@@ -373,14 +403,118 @@ namespace Test
             }
             return true;
         }
-	}
+        
+        TEST CloneScalar()
+        {
+            YAML::Node node = YAML::Load("!foo monkey");
+            YAML::Node clone = Clone(node);
+            YAML_ASSERT(!(node == clone));
+            YAML_ASSERT(node.as<std::string>() == clone.as<std::string>());
+            YAML_ASSERT(node.Tag() == clone.Tag());
+            return true;
+        }
+
+        TEST CloneSeq()
+        {
+            YAML::Node node = YAML::Load("[1, 3, 5, 7]");
+            YAML::Node clone = Clone(node);
+            YAML_ASSERT(!(node == clone));
+            YAML_ASSERT(clone.Type() == YAML::NodeType::Sequence);
+            YAML_ASSERT(node.size() == clone.size());
+            for(std::size_t i=0;i<node.size();i++)
+                YAML_ASSERT(node[i].as<int>() == clone[i].as<int>());
+            return true;
+        }
+
+        TEST CloneMap()
+        {
+            YAML::Node node = YAML::Load("{foo: bar}");
+            YAML::Node clone = Clone(node);
+            YAML_ASSERT(!(node == clone));
+            YAML_ASSERT(clone.Type() == YAML::NodeType::Map);
+            YAML_ASSERT(node.size() == clone.size());
+            YAML_ASSERT(node["foo"].as<std::string>() == clone["foo"].as<std::string>());
+            return true;
+        }
+
+        TEST CloneAlias()
+        {
+            YAML::Node node = YAML::Load("&foo [*foo]");
+            YAML::Node clone = Clone(node);
+            YAML_ASSERT(!(node == clone));
+            YAML_ASSERT(clone.Type() == YAML::NodeType::Sequence);
+            YAML_ASSERT(node.size() == clone.size());
+            YAML_ASSERT(clone == clone[0]);
+            return true;
+        }
+        
+        TEST ForceInsertIntoMap()
+        {
+            YAML::Node node;
+            node["a"] = "b";
+            node.force_insert("x", "y");
+            node.force_insert("a", 5);
+            YAML_ASSERT(node.size() == 3);
+            YAML_ASSERT(node.Type() == YAML::NodeType::Map);
+            bool ab = false;
+            bool a5 = false;
+            bool xy = false;
+            for(YAML::const_iterator it=node.begin();it!=node.end();++it) {
+                if(it->first.as<std::string>() == "a") {
+                    if(it->second.as<std::string>() == "b")
+                        ab = true;
+                    else if(it->second.as<std::string>() == "5")
+                        a5 = true;
+                } else if(it->first.as<std::string>() == "x" && it->second.as<std::string>() == "y")
+                    xy = true;
+            }
+            YAML_ASSERT(ab);
+            YAML_ASSERT(a5);
+            YAML_ASSERT(xy);
+            return true;
+        }
+        
+        TEST ResetNode()
+        {
+            YAML::Node node = YAML::Load("[1, 2, 3]");
+            YAML_ASSERT(!node.IsNull());
+            YAML::Node other = node;
+            node.reset();
+            YAML_ASSERT(node.IsNull());
+            YAML_ASSERT(!other.IsNull());
+            node.reset(other);
+            YAML_ASSERT(!node.IsNull());
+            YAML_ASSERT(other == node);
+            return true;
+        }
+
+        TEST DereferenceIteratorError()
+        {
+            YAML::Node node = YAML::Load("[{a: b}, 1, 2]");
+            YAML_ASSERT_THROWS(node.begin()->first.as<int>(), YAML::InvalidNode);
+            YAML_ASSERT((*node.begin()).IsMap() == true);
+            YAML_ASSERT(node.begin()->IsMap() == true);
+            YAML_ASSERT_THROWS((*node.begin()->begin()).IsDefined(), YAML::InvalidNode);
+            YAML_ASSERT_THROWS(node.begin()->begin()->IsDefined(), YAML::InvalidNode);
+            return true;
+        }
+
+        TEST FloatingPrecision()
+        {
+            const double x = 0.123456789;
+            YAML::Node node = YAML::Node(x);
+            YAML_ASSERT(node.as<double>() == x);
+            return true;
+        }
+    }
 	
 	void RunNodeTest(TEST (*test)(), const std::string& name, int& passed, int& total) {
 		TEST ret;
 		try {
 			ret = test();
-		} catch(...) {
+		} catch(const std::exception& e) {
 			ret.ok = false;
+            ret.error = e.what();
 		}
 		if(ret.ok) {
 			passed++;
@@ -408,6 +542,7 @@ namespace Test
 		RunNodeTest(&Node::StdVector, "std::vector", passed, total);
 		RunNodeTest(&Node::StdList, "std::list", passed, total);
 		RunNodeTest(&Node::StdMap, "std::map", passed, total);
+		RunNodeTest(&Node::StdPair, "std::pair", passed, total);
 		RunNodeTest(&Node::SimpleAlias, "simple alias", passed, total);
 		RunNodeTest(&Node::AliasAsKey, "alias as key", passed, total);
 		RunNodeTest(&Node::SelfReferenceSequence, "self reference sequence", passed, total);
@@ -426,6 +561,14 @@ namespace Test
 		RunNodeTest(&Node::IterateMap, "iterate map", passed, total);
 		RunNodeTest(&Node::ForEach, "for each", passed, total);
 		RunNodeTest(&Node::ForEachMap, "for each map", passed, total);
+		RunNodeTest(&Node::CloneScalar, "clone scalar", passed, total);
+		RunNodeTest(&Node::CloneSeq, "clone seq", passed, total);
+		RunNodeTest(&Node::CloneMap, "clone map", passed, total);
+		RunNodeTest(&Node::CloneAlias, "clone alias", passed, total);
+        RunNodeTest(&Node::ForceInsertIntoMap, "force insert into map", passed, total);
+        RunNodeTest(&Node::ResetNode, "reset node", passed, total);
+        RunNodeTest(&Node::DereferenceIteratorError, "dereference iterator error", passed, total);
+        RunNodeTest(&Node::FloatingPrecision, "floating precision", passed, total);
 
 		std::cout << "Node tests: " << passed << "/" << total << " passed\n";
 		return passed == total;

test/spectests.h

@@ -5,18 +5,9 @@
 #pragma once
 #endif
 
-#include <string>
+#include "teststruct.h"
 
 namespace Test {
-	struct TEST {
-		TEST(): ok(false) {}
-		TEST(bool ok_): ok(ok_) {}
-		TEST(const char *error_): ok(false), error(error_) {}
-		
-		bool ok;
-		std::string error;
-	};
-	
 	namespace Spec {
 		// 2.1
 		TEST SeqScalars();

test/teststruct.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <string>
+
+#define YAML_ASSERT(cond) do { if(!(cond)) return "  Assert failed: " #cond; } while(false)
+
+namespace Test
+{
+	struct TEST {
+		TEST(): ok(false) {}
+		TEST(bool ok_): ok(ok_) {}
+		TEST(const char *error_): ok(false), error(error_) {}
+		
+		bool ok;
+		std::string error;
+	};
+    
+}

util/CMakeLists.txt

@@ -1,2 +1,8 @@
 add_executable(parse parse.cpp)
 target_link_libraries(parse yaml-cpp)
+
+add_executable(sandbox sandbox.cpp)
+target_link_libraries(sandbox yaml-cpp)
+
+add_executable(read read.cpp)
+target_link_libraries(read yaml-cpp)

util/read.cpp

@@ -0,0 +1,30 @@
+#include "yaml-cpp/yaml.h"
+#include "yaml-cpp/eventhandler.h"
+#include <iostream>
+
+class NullEventHandler: public YAML::EventHandler
+{
+public:
+    typedef YAML::Mark Mark;
+    typedef YAML::anchor_t anchor_t;
+    
+    NullEventHandler() {}
+    
+    virtual void OnDocumentStart(const Mark&) {}
+    virtual void OnDocumentEnd() {}
+    virtual void OnNull(const Mark&, anchor_t) {}
+    virtual void OnAlias(const Mark&, anchor_t) {}
+    virtual void OnScalar(const Mark&, const std::string&, anchor_t, const std::string&) {}
+    virtual void OnSequenceStart(const Mark&, const std::string&, anchor_t) {}
+    virtual void OnSequenceEnd() {}
+    virtual void OnMapStart(const Mark&, const std::string&, anchor_t) {}
+    virtual void OnMapEnd() {}
+};
+
+int main()
+{
+    YAML::Parser parser(std::cin);
+    NullEventHandler handler;
+    parser.HandleNextDocument(handler);
+    return 0;
+}

util/sandbox.cpp

@@ -0,0 +1,32 @@
+#include "yaml-cpp/yaml.h"
+#include "yaml-cpp/eventhandler.h"
+#include <iostream>
+
+class NullEventHandler: public YAML::EventHandler
+{
+public:
+    typedef YAML::Mark Mark;
+    typedef YAML::anchor_t anchor_t;
+    
+    NullEventHandler() {}
+    
+    virtual void OnDocumentStart(const Mark&) {}
+    virtual void OnDocumentEnd() {}
+    virtual void OnNull(const Mark&, anchor_t) {}
+    virtual void OnAlias(const Mark&, anchor_t) {}
+    virtual void OnScalar(const Mark&, const std::string&, anchor_t, const std::string&) {}
+    virtual void OnSequenceStart(const Mark&, const std::string&, anchor_t) {}
+    virtual void OnSequenceEnd() {}
+    virtual void OnMapStart(const Mark&, const std::string&, anchor_t) {}
+    virtual void OnMapEnd() {}
+};
+
+int main()
+{
+    std::stringstream stream("---{header: {id: 1");
+    YAML::Parser parser(stream);
+//    parser.PrintTokens(std::cout);
+    NullEventHandler handler;
+    parser.HandleNextDocument(handler);
+    return 0;
+}