Bumped version to 0.5.1

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

.hgeol

@@ -0,0 +1,4 @@
+**.h = native
+**.c = native
+**.cpp = native
+**.txt = native

.hgignore

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

CMakeLists.txt

@@ -22,8 +22,8 @@ include(CheckCXXCompilerFlag)
 project(YAML_CPP)
 
 set(YAML_CPP_VERSION_MAJOR "0")
-set(YAML_CPP_VERSION_MINOR "2")
-set(YAML_CPP_VERSION_PATCH "5")
+set(YAML_CPP_VERSION_MINOR "5")
+set(YAML_CPP_VERSION_PATCH "1")
 set(YAML_CPP_VERSION "${YAML_CPP_VERSION_MAJOR}.${YAML_CPP_VERSION_MINOR}.${YAML_CPP_VERSION_PATCH}")
 
 enable_testing()
@@ -51,14 +51,15 @@ option(APPLE_UNIVERSAL_BIN "Apple: Build universal binary" OFF)
 option(MSVC_SHARED_RT "MSVC: Build with shared runtime libs (/MD)" ON)
 option(MSVC_STHREADED_RT "MSVC: Build with single-threaded static runtime libs (/ML until VS .NET 2003)" OFF)
 
-
 ###
 ### Sources, headers, directories and libs
 ###
+set(header_directory "include/yaml-cpp/")
+
 file(GLOB sources "src/[a-zA-Z]*.cpp")
-file(GLOB public_headers "include/yaml-cpp/[a-zA-Z]*.h")
+file(GLOB_RECURSE public_headers "include/yaml-cpp/[a-zA-Z]*.h")
 file(GLOB private_headers "src/[a-zA-Z]*.h")
- 
+
 if(YAML_CPP_BUILD_CONTRIB)
 	file(GLOB contrib_sources "src/contrib/[a-zA-Z]*.cpp")
 	file(GLOB contrib_public_headers "include/yaml-cpp/contrib/[a-zA-Z]*.h")
@@ -76,8 +77,12 @@ if(VERBOSE)
 	message(STATUS "contrib_private_headers: ${contrib_private_headers}")
 endif()
 
+include_directories(${YAML_CPP_SOURCE_DIR}/src)
 include_directories(${YAML_CPP_SOURCE_DIR}/include)
 
+find_package(Boost REQUIRED)
+include_directories(${Boost_INCLUDE_DIRS})
+
 
 ###
 ### General compilation settings
@@ -209,7 +214,9 @@ else()
 	set(_library_dir lib)
 endif()
 
-set(INCLUDE_INSTALL_DIR include/yaml-cpp)
+set(INCLUDE_INSTALL_ROOT_DIR include)
+
+set(INCLUDE_INSTALL_DIR ${INCLUDE_INSTALL_ROOT_DIR}/yaml-cpp)
 set(LIB_INSTALL_DIR "${_library_dir}${LIB_SUFFIX}")
 
 set(_INSTALL_DESTINATIONS
@@ -257,10 +264,9 @@ endif()
 
 install(TARGETS yaml-cpp ${_INSTALL_DESTINATIONS})
 install(
-	FILES
-		${public_headers}
-		${contrib_public_headers}
+	DIRECTORY ${header_directory}
 	DESTINATION ${INCLUDE_INSTALL_DIR}
+	FILES_MATCHING PATTERN "*.h"
 )
 
 if(UNIX)

include/yaml-cpp/aliasmanager.h

@@ -1,34 +0,0 @@
-#ifndef ALIASMANAGER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define ALIASMANAGER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
-#pragma once
-#endif
-
-#include "yaml-cpp/anchor.h"
-#include <map>
-
-namespace YAML
-{
-	class Node;
-	
-	class AliasManager
-	{
-	public:
-		AliasManager();
-		
-		void RegisterReference(const Node& node);
-		anchor_t LookupAnchor(const Node& node) const;
-		
-	private:
-		anchor_t _CreateNewAnchor();
-		
-	private:
-		typedef std::map<const Node*, anchor_t> AnchorByIdentity;
-		AnchorByIdentity m_anchorByIdentity;
-		
-		anchor_t m_curAnchor;
-	};
-}
-
-#endif // ALIASMANAGER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/anchor.h

@@ -1,7 +1,7 @@
 #ifndef ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#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/yaml-cpp/binary.h

@@ -0,0 +1,62 @@
+#ifndef BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define BASE64_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
+{
+    std::string EncodeBase64(const unsigned char *data, std::size_t size);
+    std::vector<unsigned char> DecodeBase64(const std::string& input);
+    
+    class Binary {
+    public:
+        Binary(): m_unownedData(0), m_unownedSize(0) {}
+        Binary(const unsigned char *data_, std::size_t size_): m_unownedData(data_), m_unownedSize(size_) {}
+        
+        bool owned() const { return !m_unownedData; }
+        std::size_t size() const { return owned() ? m_data.size() : m_unownedSize; }
+        const unsigned char *data() const { return owned() ? &m_data[0] : m_unownedData; }
+        
+        void swap(std::vector<unsigned char>& rhs) {
+            if(m_unownedData) {
+                m_data.swap(rhs);
+                rhs.clear();
+                rhs.resize(m_unownedSize);
+                std::copy(m_unownedData, m_unownedData + m_unownedSize, &rhs[0]);
+                m_unownedData = 0;
+                m_unownedSize = 0;
+            } else {
+                m_data.swap(rhs);
+            }
+        }
+        
+        bool operator == (const Binary& rhs) const {
+            const std::size_t s = size();
+            if(s != rhs.size())
+                return false;
+            const unsigned char *d1 = data();
+            const unsigned char *d2 = rhs.data();
+            for(std::size_t i=0;i<s;i++) {
+                if(*d1++ != *d2++)
+                    return false;
+            }
+            return true;
+        }
+        
+        bool operator != (const Binary& rhs) const {
+            return !(*this == rhs);
+        }
+        
+    private:
+        std::vector<unsigned char> m_data;
+        const unsigned char *m_unownedData;
+        std::size_t m_unownedSize;
+    };
+}
+
+#endif // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/contrib/anchordict.h

@@ -1,7 +1,7 @@
 #ifndef ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#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/yaml-cpp/contrib/graphbuilder.h

@@ -1,7 +1,7 @@
 #ifndef GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#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/yaml-cpp/conversion.h

@@ -1,33 +0,0 @@
-#ifndef CONVERSION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define CONVERSION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
-#pragma once
-#endif
-
-
-#include "yaml-cpp/null.h"
-#include "yaml-cpp/traits.h"
-#include <string>
-#include <sstream>
-
-namespace YAML
-{
-	inline bool Convert(const std::string& input, std::string& output) {
-		output = input;
-		return true;
-	}
-	
-	YAML_CPP_API bool Convert(const std::string& input, bool& output);
-	YAML_CPP_API bool Convert(const std::string& input, _Null& output);
-	
-	template <typename T> 
-	inline bool Convert(const std::string& input, T& output, typename enable_if<is_numeric<T> >::type * = 0) {
-		std::stringstream stream(input);
-		stream.unsetf(std::ios::dec);
-		stream >> output;
-		return !!stream;
-	}
-}
-
-#endif // CONVERSION_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/dll.h

@@ -1,7 +1,7 @@
 #ifndef DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#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/yaml-cpp/emitfromevents.h

@@ -1,7 +1,7 @@
 #ifndef EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#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/yaml-cpp/emitter.h

@@ -1,16 +1,18 @@
 #ifndef EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#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 "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>
@@ -23,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;
@@ -43,20 +46,24 @@ namespace YAML
 		bool SetIndent(unsigned n);
 		bool SetPreCommentIndent(unsigned n);
 		bool SetPostCommentIndent(unsigned n);
+        bool SetFloatPrecision(unsigned n);
+        bool SetDoublePrecision(unsigned n);
 		
 		// local setters
 		Emitter& SetLocalValue(EMITTER_MANIP value);
 		Emitter& SetLocalIndent(const _Indent& indent);
+        Emitter& SetLocalPrecision(const _Precision& precision);
 		
 		// overloads of write
 		Emitter& Write(const std::string& str);
 		Emitter& Write(bool b);
+		Emitter& Write(char ch);
 		Emitter& Write(const _Alias& alias);
 		Emitter& Write(const _Anchor& anchor);
 		Emitter& Write(const _Tag& tag);
 		Emitter& Write(const _Comment& comment);
-		Emitter& Write(const _Null& null);
-		Emitter& Write(const _Binary& binary);
+		Emitter& Write(const _Null& n);
+		Emitter& Write(const Binary& binary);
 		
 		template <typename T>
 		Emitter& WriteIntegralType(T value);
@@ -65,37 +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:
-		enum ATOMIC_TYPE { AT_SCALAR, AT_SEQ, AT_BLOCK_SEQ, AT_FLOW_SEQ, AT_MAP, AT_BLOCK_MAP, AT_FLOW_MAP };
-		
-		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>
@@ -104,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;
 	}
 
@@ -117,22 +143,41 @@ namespace YAML
 		if(!good())
 			return *this;
 		
-		std::stringstream str;
-		PreWriteStreamable(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& stream)
+    {
+		stream.precision(GetFloatPrecision());
+    }
+
+    template<>
+    inline void Emitter::SetStreamablePrecision<double>(std::stringstream& stream)
+    {
+		stream.precision(GetDoublePrecision());
+    }
+
 	// overloads of insertion
 	inline Emitter& operator << (Emitter& emitter, const std::string& v) { return emitter.Write(v); }
 	inline Emitter& operator << (Emitter& emitter, bool v) { return emitter.Write(v); }
+	inline Emitter& operator << (Emitter& emitter, char v) { return emitter.Write(v); }
+	inline Emitter& operator << (Emitter& emitter, unsigned char v) { return emitter.Write(static_cast<char>(v)); }
 	inline Emitter& operator << (Emitter& emitter, const _Alias& v) { return emitter.Write(v); }
 	inline Emitter& operator << (Emitter& emitter, const _Anchor& v) { return emitter.Write(v); }
 	inline Emitter& operator << (Emitter& emitter, const _Tag& v) { return emitter.Write(v); }
 	inline Emitter& operator << (Emitter& emitter, const _Comment& v) { return emitter.Write(v); }
 	inline Emitter& operator << (Emitter& emitter, const _Null& v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, const _Binary& b) { return emitter.Write(b); }
+	inline Emitter& operator << (Emitter& emitter, const Binary& b) { return emitter.Write(b); }
 
 	inline Emitter& operator << (Emitter& emitter, const char *v) { return emitter.Write(std::string(v)); }
 
@@ -155,6 +200,10 @@ namespace YAML
 	inline Emitter& operator << (Emitter& emitter, _Indent indent) {
 		return emitter.SetLocalIndent(indent);
 	}
+    
+    inline Emitter& operator << (Emitter& emitter, _Precision precision) {
+        return emitter.SetLocalPrecision(precision);
+    }
 }
 
 #endif // EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

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/emittermanip.h

@@ -1,7 +1,7 @@
 #ifndef EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif
 
@@ -125,16 +125,25 @@ namespace YAML
 	inline _Comment Comment(const std::string content) {
 		return _Comment(content);
 	}
-	
-	struct _Binary {
-		_Binary(const char *data_, std::size_t size_): data(data_), size(size_) {}
-		const char *data;
-		std::size_t size;
-	};
-	
-	inline _Binary Binary(const char *data, std::size_t size) {
-		return _Binary(data, size);
-	}
+    
+    struct _Precision {
+        _Precision(int floatPrecision_, int doublePrecision_): floatPrecision(floatPrecision_), doublePrecision(doublePrecision_) {}
+        
+        int floatPrecision;
+        int doublePrecision;
+    };
+    
+    inline _Precision FloatPrecision(int n) {
+        return _Precision(n, -1);
+    }
+
+    inline _Precision DoublePrecision(int n) {
+        return _Precision(-1, n);
+    }
+
+    inline _Precision Precision(int n) {
+        return _Precision(n, n);
+    }
 }
 
 #endif // EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/eventhandler.h

@@ -1,7 +1,7 @@
 #ifndef EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#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/yaml-cpp/exceptions.h

@@ -1,7 +1,7 @@
 #ifndef EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif
 
@@ -55,9 +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";
@@ -66,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) {
@@ -148,17 +150,59 @@ namespace YAML
 		return TypedKeyNotFound <T> (mark, key);
 	}
 
+	class InvalidNode: public RepresentationException {
+	public:
+		InvalidNode()
+        : RepresentationException(Mark::null_mark(), ErrorMsg::INVALID_NODE) {}
+	};
+
+    class BadConversion: public RepresentationException {
+	public:
+		BadConversion()
+        : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_CONVERSION) {}
+	};
+
+    template<typename T>
+	class TypedBadConversion: public BadConversion {
+	public:
+		TypedBadConversion()
+        : BadConversion() {}
+	};
+
 	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_mark(), ErrorMsg::BAD_SUBSCRIPT) {}
+	};
+
+	class BadPushback: public RepresentationException {
+	public:
+		BadPushback()
+		: 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/iterator.h

@@ -1,40 +0,0 @@
-#ifndef ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
-#pragma once
-#endif
-
-#include "yaml-cpp/dll.h"
-#include <memory>
-
-namespace YAML
-{
-	class Node;
-	struct IterPriv;
-
-	class YAML_CPP_API Iterator
-	{
-	public:
-		Iterator();
-		Iterator(std::auto_ptr<IterPriv> pData);
-		Iterator(const Iterator& rhs);
-		~Iterator();
-
-		Iterator& operator = (const Iterator& rhs);
-		Iterator& operator ++ ();
-		Iterator operator ++ (int);
-		const Node& operator * () const;
-		const Node *operator -> () const;
-		const Node& first() const;
-		const Node& second() const;
-
-		friend YAML_CPP_API bool operator == (const Iterator& it, const Iterator& jt);
-		friend YAML_CPP_API bool operator != (const Iterator& it, const Iterator& jt);
-
-	private:
-		std::auto_ptr<IterPriv> m_pData;
-	};
-}
-
-#endif // ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/ltnode.h

@@ -1,18 +0,0 @@
-#ifndef LTNODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define LTNODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
-#pragma once
-#endif
-
-
-namespace YAML
-{
-	class Node;
-
-	struct ltnode {
-		bool operator()(const Node *pNode1, const Node *pNode2) const;
-	};
-}
-
-#endif // LTNODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/mark.h

@@ -1,7 +1,7 @@
 #ifndef MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
+#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
 #pragma once
 #endif
 
@@ -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.h

@@ -1,133 +0,0 @@
-#ifndef NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
-#pragma once
-#endif
-
-
-#include "yaml-cpp/conversion.h"
-#include "yaml-cpp/dll.h"
-#include "yaml-cpp/exceptions.h"
-#include "yaml-cpp/iterator.h"
-#include "yaml-cpp/ltnode.h"
-#include "yaml-cpp/mark.h"
-#include "yaml-cpp/noncopyable.h"
-#include <iostream>
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace YAML
-{
-	class AliasManager;
-	class Content;
-	class NodeOwnership;
-	class Scanner;
-	class Emitter;
-	class EventHandler;
-
-	struct NodeType { enum value { Null, Scalar, Sequence, Map }; };
-
-	class YAML_CPP_API Node: private noncopyable
-	{
-	public:
-		friend class NodeOwnership;
-		friend class NodeBuilder;
-		
-		Node();
-		~Node();
-
-		void Clear();
-		std::auto_ptr<Node> Clone() const;
-		void EmitEvents(EventHandler& eventHandler) const;
-		void EmitEvents(AliasManager& am, EventHandler& eventHandler) const;
-		
-		NodeType::value Type() const { return m_type; }
-		bool IsAliased() const;
-
-		// file location of start of this node
-		const Mark GetMark() const { return m_mark; }
-
-		// accessors
-		Iterator begin() const;
-		Iterator end() const;
-		std::size_t size() const;
-
-		// extraction of scalars
-		bool GetScalar(std::string& s) const;
-
-		// we can specialize this for other values
-		template <typename T>
-		bool Read(T& value) const;
-
-		template <typename T>
-		const T to() const;
-
-		template <typename T>
-		friend YAML_CPP_API void operator >> (const Node& node, T& value);
-
-		// retrieval for maps and sequences
-		template <typename T>
-		const Node *FindValue(const T& key) const;
-
-		template <typename T>
-		const Node& operator [] (const T& key) const;
-		
-		// specific to maps
-		const Node *FindValue(const char *key) const;
-		const Node& operator [] (const char *key) const;
-
-		// for tags
-		const std::string& Tag() const { return m_tag; }
-
-		// emitting
-		friend YAML_CPP_API Emitter& operator << (Emitter& out, const Node& node);
-
-		// ordering
-		int Compare(const Node& rhs) const;
-		friend bool operator < (const Node& n1, const Node& n2);
-
-	private:
-		explicit Node(NodeOwnership& owner);
-		Node& CreateNode();
-		
-		void Init(NodeType::value type, const Mark& mark, const std::string& tag);
-		
-		void MarkAsAliased();
-		void SetScalarData(const std::string& data);
-		void Append(Node& node);
-		void Insert(Node& key, Node& value);
-
-		// helper for sequences
-		template <typename, bool> friend struct _FindFromNodeAtIndex;
-		const Node *FindAtIndex(std::size_t i) const;
-		
-		// helper for maps
-		template <typename T>
-		const Node& GetValue(const T& key) const;
-
-		template <typename T>
-		const Node *FindValueForKey(const T& key) const;
-
-	private:
-		std::auto_ptr<NodeOwnership> m_pOwnership;
-
-		Mark m_mark;
-		std::string m_tag;
-
-		typedef std::vector<Node *> node_seq;
-		typedef std::map<Node *, Node *, ltnode> node_map;
-
-		NodeType::value m_type;
-		std::string m_scalarData;
-		node_seq m_seqData;
-		node_map m_mapData;
-	};
-}
-
-#include "yaml-cpp/nodeimpl.h"
-#include "yaml-cpp/nodereadimpl.h"
-
-#endif // NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66