Bumped version to 0.3.0

.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 "7")
+set(YAML_CPP_VERSION_MINOR "3")
+set(YAML_CPP_VERSION_PATCH "0")
 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 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")
@@ -77,6 +78,7 @@ if(VERBOSE)
 endif()
 
 include_directories(${YAML_CPP_SOURCE_DIR}/include)
+include_directories(${YAML_CPP_SOURCE_DIR}/src)
 
 
 ###
@@ -259,10 +261,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/binary.h

@@ -0,0 +1,66 @@
+#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
+{
+    class Node;
+    
+    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;
+    };
+    
+    void operator >> (const Node& node, Binary& binary);
+}
+
+#endif // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/conversion.h

@@ -14,6 +14,17 @@
 
 namespace YAML
 {
+	// traits for conversion
+	
+	template<typename T>
+	struct is_scalar_convertible { enum { value = is_numeric<T>::value }; };
+	
+	template<> struct is_scalar_convertible<std::string> { enum { value = true }; };
+	template<> struct is_scalar_convertible<bool> { enum { value = true }; };
+	template<> struct is_scalar_convertible<_Null> { enum { value = true }; };
+
+	// actual conversion
+	
 	inline bool Convert(const std::string& input, std::string& output) {
 		output = input;
 		return true;
@@ -39,9 +50,8 @@ namespace YAML
 	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;
-		if(!!stream)
-			return true;
+        if((stream >> output) && (stream >> std::ws).eof())
+            return true;
 		
 		if(std::numeric_limits<T>::has_infinity) {
 			if(IsInfinity(input)) {

include/yaml-cpp/emitter.h

@@ -7,6 +7,7 @@
 
 
 #include "yaml-cpp/dll.h"
+#include "yaml-cpp/binary.h"
 #include "yaml-cpp/emittermanip.h"
 #include "yaml-cpp/ostream.h"
 #include "yaml-cpp/noncopyable.h"
@@ -43,20 +44,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 Binary& binary);
 		
 		template <typename T>
 		Emitter& WriteIntegralType(T value);
@@ -69,6 +74,10 @@ namespace YAML
 		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;
 	
 	private:
 		void PreAtomicWrite();
@@ -117,20 +126,35 @@ namespace YAML
 		
 		std::stringstream str;
 		PreWriteStreamable(str);
+        SetStreamablePrecision<T>(str);
 		str << value;
 		PostWriteStreamable(str);
 		return *this;
 	}
 	
+    template<>
+    inline void Emitter::SetStreamablePrecision<float>(std::stringstream& str)
+    {
+		str.precision(GetFloatPrecision());
+    }
+
+    template<>
+    inline void Emitter::SetStreamablePrecision<double>(std::stringstream& str)
+    {
+		str.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)); }
 
@@ -153,6 +177,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/emittermanip.h

@@ -125,16 +125,25 @@ namespace YAML
 	inline _Comment Comment(const std::string content) {
 		return _Comment(content);
 	}
-	
-	struct _Binary {
-		_Binary(const unsigned char *data_, std::size_t size_): data(data_), size(size_) {}
-		const unsigned char *data;
-		std::size_t size;
-	};
-	
-	inline _Binary Binary(const unsigned 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/node.h

@@ -6,13 +6,13 @@
 #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 "yaml-cpp/conversion.h"
+#include "yaml-cpp/iterator.h"
+#include "yaml-cpp/ltnode.h"
 #include <iostream>
 #include <map>
 #include <memory>
@@ -66,7 +66,7 @@ namespace YAML
 		const T to() const;
 
 		template <typename T>
-		friend YAML_CPP_API void operator >> (const Node& node, T& value);
+		friend YAML_CPP_API typename enable_if<is_scalar_convertible<T> >::type operator >> (const Node& node, T& value);
 
 		// retrieval for maps and sequences
 		template <typename T>

include/yaml-cpp/nodeimpl.h

@@ -20,7 +20,7 @@ namespace YAML
 	}
 
 	template <typename T>
-	inline void operator >> (const Node& node, T& value) {
+	inline typename enable_if<is_scalar_convertible<T> >::type operator >> (const Node& node, T& value) {
 		if(!ConvertScalar(node, value))
 			throw InvalidScalar(node.m_mark);
 	}

include/yaml-cpp/null.h

@@ -16,7 +16,7 @@ namespace YAML
 	inline bool operator == (const _Null&, const _Null&) { return true; }
 	inline bool operator != (const _Null&, const _Null&) { return false; }
 	
-	YAML_CPP_API bool IsNull(const Node& node);
+	YAML_CPP_API bool IsNull(const Node& node); // old API only
 	
 	extern YAML_CPP_API _Null Null;
 }

include/yaml-cpp/parser.h

@@ -32,7 +32,8 @@ namespace YAML
 		void Load(std::istream& in);
 		bool HandleNextDocument(EventHandler& eventHandler);
 		
-		bool GetNextDocument(Node& document);
+		bool GetNextDocument(Node& document); // old API only
+		
 		void PrintTokens(std::ostream& out);
 
 	private:

include/yaml-cpp/yaml.h

@@ -5,13 +5,13 @@
 #pragma once
 #endif
 
-
 #include "yaml-cpp/parser.h"
-#include "yaml-cpp/node.h"
-#include "yaml-cpp/stlnode.h"
-#include "yaml-cpp/iterator.h"
 #include "yaml-cpp/emitter.h"
 #include "yaml-cpp/stlemitter.h"
 #include "yaml-cpp/exceptions.h"
 
+#include "yaml-cpp/node.h"
+#include "yaml-cpp/stlnode.h"
+#include "yaml-cpp/iterator.h"
+
 #endif // YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/binary.cpp

@@ -0,0 +1,102 @@
+#include "yaml-cpp/binary.h"
+#include "yaml-cpp/node.h"
+
+namespace YAML
+{
+    static const char encoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+    std::string EncodeBase64(const unsigned char *data, std::size_t size)
+    {
+        const char PAD = '=';
+        
+        std::string ret;
+        ret.resize(4 * size / 3 + 3);
+        char *out = &ret[0];
+        
+        std::size_t chunks = size / 3;
+        std::size_t remainder = size % 3;
+        
+        for(std::size_t i=0;i<chunks;i++, data += 3) {
+            *out++ = encoding[data[0] >> 2];
+            *out++ = encoding[((data[0] & 0x3) << 4) | (data[1] >> 4)];
+            *out++ = encoding[((data[1] & 0xf) << 2) | (data[2] >> 6)];
+            *out++ = encoding[data[2] & 0x3f];
+        }
+        
+        switch(remainder) {
+            case 0:
+                break;
+            case 1:
+                *out++ = encoding[data[0] >> 2];
+                *out++ = encoding[((data[0] & 0x3) << 4)];
+                *out++ = PAD;
+                *out++ = PAD;
+                break;
+            case 2:
+                *out++ = encoding[data[0] >> 2];
+                *out++ = encoding[((data[0] & 0x3) << 4) | (data[1] >> 4)];
+                *out++ = encoding[((data[1] & 0xf) << 2)];
+                *out++ = PAD;
+                break;
+        }
+        
+        ret.resize(out - &ret[0]);
+        return ret;
+    }
+    
+    static const unsigned char decoding[] = {
+        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+        255,255,255,255,255,255,255,255,255,255,255, 62,255,255,255, 63,
+         52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255,  0,255,255,
+        255,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+         15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255,
+        255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+         41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,255,255,255,255,255,
+        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    };
+
+    std::vector<unsigned char> DecodeBase64(const std::string& input)
+    {
+        typedef std::vector<unsigned char> ret_type;
+        if(input.empty())
+            return ret_type();
+        
+        ret_type ret(3 * input.size() / 4 + 1);
+        unsigned char *out = &ret[0];
+        
+        unsigned value = 0;
+        for(std::size_t i=0;i<input.size();i++) {
+            unsigned char d = decoding[static_cast<unsigned>(input[i])];
+            if(d == 255)
+                return ret_type();
+
+            value = (value << 6) | d;
+            if(i % 4 == 3) {
+                *out++ = value >> 16;
+                if(i > 0 && input[i - 1] != '=')
+                    *out++ = value >> 8;
+                if(input[i] != '=')
+                    *out++ = value;
+            }
+        }
+        
+        ret.resize(out - &ret[0]);
+        return ret;
+    }
+
+    void operator >> (const Node& node, Binary& binary)
+    {
+        std::string scalar;
+        node.GetScalar(scalar);
+        std::vector<unsigned char> data = DecodeBase64(scalar);
+        binary.swap(data);
+    }
+}

src/emitter.cpp

@@ -93,6 +93,16 @@ namespace YAML
 	{
 		return m_pState->SetPostCommentIndent(n, GLOBAL);
 	}
+    
+    bool Emitter::SetFloatPrecision(unsigned n)
+    {
+        return m_pState->SetFloatPrecision(n, GLOBAL);
+    }
+
+    bool Emitter::SetDoublePrecision(unsigned n)
+    {
+        return m_pState->SetDoublePrecision(n, GLOBAL);
+    }
 
 	// SetLocalValue
 	// . Either start/end a group, or set a modifier locally
@@ -145,6 +155,15 @@ namespace YAML
 		return *this;
 	}
 
+    Emitter& Emitter::SetLocalPrecision(const _Precision& precision)
+    {
+        if(precision.floatPrecision >= 0)
+            m_pState->SetFloatPrecision(precision.floatPrecision, LOCAL);
+        if(precision.doublePrecision >= 0)
+            m_pState->SetDoublePrecision(precision.doublePrecision, LOCAL);
+        return *this;
+    }
+
 	// GotoNextPreAtomicState
 	// . Runs the state machine, emitting if necessary, and returns 'true' if done (i.e., ready to emit an atom)
 	bool Emitter::GotoNextPreAtomicState()
@@ -651,9 +670,11 @@ namespace YAML
 				str << std::dec;
 				break;
 			case Hex:
+                str << "0x";
 				str << std::hex;
 				break;
-				case Oct:
+			case Oct:
+                str << "0";
 				str << std::oct;
 				break;
 			default:
@@ -661,13 +682,22 @@ namespace YAML
 		}
 	}
 
-	void Emitter::PreWriteStreamable(std::stringstream& str)
+	void Emitter::PreWriteStreamable(std::stringstream&)
 	{
 		PreAtomicWrite();
 		EmitSeparationIfNecessary();
-		str.precision(15);
 	}
 
+    unsigned Emitter::GetFloatPrecision() const
+    {
+        return m_pState->GetFloatPrecision();
+    }
+    
+    unsigned Emitter::GetDoublePrecision() const
+    {
+        return m_pState->GetDoublePrecision();
+    }
+
 	void Emitter::PostWriteIntegralType(const std::stringstream& str)
 	{
 		m_stream << str.str();
@@ -733,6 +763,20 @@ namespace YAML
 		return *this;
 	}
 
+	Emitter& Emitter::Write(char ch)
+	{
+		if(!good())
+			return *this;
+		
+		PreAtomicWrite();
+		EmitSeparationIfNecessary();
+		
+		Utils::WriteChar(m_stream, ch);
+		
+		PostAtomicWrite();
+		return *this;
+	}
+
 	Emitter& Emitter::Write(const _Alias& alias)
 	{
 		if(!good())
@@ -821,7 +865,7 @@ namespace YAML
 		return *this;
 	}
 
-	Emitter& Emitter::Write(const _Binary& binary)
+	Emitter& Emitter::Write(const Binary& binary)
 	{
 		Write(SecondaryTag("binary"));
 
@@ -830,7 +874,7 @@ namespace YAML
 		
 		PreAtomicWrite();
 		EmitSeparationIfNecessary();
-		Utils::WriteBinary(m_stream, binary.data, binary.size);
+		Utils::WriteBinary(m_stream, binary);
 		PostAtomicWrite();
 		return *this;
 	}

src/emitterstate.cpp

@@ -1,5 +1,6 @@
 #include "emitterstate.h"
 #include "yaml-cpp/exceptions.h"
+#include <limits>
 
 namespace YAML
 {
@@ -21,6 +22,8 @@ namespace YAML
 		m_seqFmt.set(Block);
 		m_mapFmt.set(Block);
 		m_mapKeyFmt.set(Auto);
+        m_floatPrecision.set(6);
+        m_doublePrecision.set(15);
 	}
 	
 	EmitterState::~EmitterState()
@@ -261,5 +264,21 @@ namespace YAML
 				return false;
 		}
 	}
+
+    bool EmitterState::SetFloatPrecision(int value, FMT_SCOPE scope)
+    {
+        if(value < 0 || value > std::numeric_limits<float>::digits10)
+            return false;
+        _Set(m_floatPrecision, value, scope);
+        return true;
+    }
+    
+    bool EmitterState::SetDoublePrecision(int value, FMT_SCOPE scope)
+    {
+        if(value < 0 || value > std::numeric_limits<double>::digits10)
+            return false;
+        _Set(m_doublePrecision, value, scope);
+        return true;
+    }
 }
 

src/emitterstate.h

@@ -145,6 +145,11 @@ namespace YAML
 		
 		bool SetMapKeyFormat(EMITTER_MANIP value, FMT_SCOPE scope);
 		EMITTER_MANIP GetMapKeyFormat() const { return m_mapKeyFmt.get(); }
+        
+        bool SetFloatPrecision(int value, FMT_SCOPE scope);
+        unsigned GetFloatPrecision() const { return m_floatPrecision.get(); }
+        bool SetDoublePrecision(int value, FMT_SCOPE scope);
+        unsigned GetDoublePrecision() const { return m_doublePrecision.get(); }
 		
 	private:
 		template <typename T>
@@ -169,6 +174,8 @@ namespace YAML
 		Setting<EMITTER_MANIP> m_seqFmt;
 		Setting<EMITTER_MANIP> m_mapFmt;
 		Setting<EMITTER_MANIP> m_mapKeyFmt;
+        Setting<int> m_floatPrecision;
+        Setting<int> m_doublePrecision;
 		
 		SettingChanges m_modifiedSettings;
 		SettingChanges m_globalModifiedSettings;

src/emitterutils.cpp

@@ -1,6 +1,7 @@
 #include "emitterutils.h"
 #include "exp.h"
 #include "indentation.h"
+#include "yaml-cpp/binary.h"
 #include "yaml-cpp/exceptions.h"
 #include "stringsource.h"
 #include <sstream>
@@ -268,6 +269,26 @@ namespace YAML
 			return true;
 		}
 		
+		bool WriteChar(ostream& out, char ch)
+		{
+			if(('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z'))
+				out << ch;
+			else if((0x20 <= ch && ch <= 0x7e) || ch == ' ')
+				out << "\"" << ch << "\"";
+			else if(ch == '\t')
+				out << "\"\\t\"";
+			else if(ch == '\n')
+				out << "\"\\n\"";
+			else if(ch == '\b')
+				out << "\"\\b\"";
+			else {
+				out << "\"";
+				WriteDoubleQuoteEscapeSequence(out, ch);
+				out << "\"";
+			}
+			return true;
+		}
+
 		bool WriteComment(ostream& out, const std::string& str, int postCommentIndent)
 		{
 			const unsigned curIndent = out.col();
@@ -347,41 +368,10 @@ namespace YAML
 			return true;
 		}
 
-		bool WriteBinary(ostream& out, const unsigned char *data, std::size_t size)
+		bool WriteBinary(ostream& out, const Binary& binary)
 		{
-			static const char encoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-			const char PAD = '=';
-			
-			out << "\"";
-			std::size_t chunks = size / 3;
-			std::size_t remainder = size % 3;
-
-			for(std::size_t i=0;i<chunks;i++, data += 3) {
-				out << encoding[data[0] >> 2];
-				out << encoding[((data[0] & 0x3) << 4) | (data[1] >> 4)];
-				out << encoding[((data[1] & 0xf) << 2) | (data[2] >> 6)];
-				out << encoding[data[2] & 0x3f];
-			}
-			
-			switch(remainder) {
-				case 0:
-					break;
-				case 1:
-					out << encoding[data[0] >> 2];
-					out << encoding[((data[0] & 0x3) << 4)];
-					out << PAD;
-					out << PAD;
-					break;
-				case 2:
-					out << encoding[data[0] >> 2];
-					out << encoding[((data[0] & 0x3) << 4) | (data[1] >> 4)];
-					out << encoding[((data[1] & 0xf) << 2)];
-					out << PAD;
-					break;
-			}
-			
-			out << "\"";
-			return true;
+            WriteDoubleQuotedString(out, EncodeBase64(binary.data(), binary.size()), false);
+            return true;
 		}
 	}
 }

src/emitterutils.h

@@ -11,18 +11,21 @@
 
 namespace YAML
 {
+    class Binary;
+    
 	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 unsigned char *data, std::size_t size);
+		bool WriteBinary(ostream& out, const Binary& binary);
 	}
 }
 

src/exp.h

@@ -137,7 +137,7 @@ namespace YAML
 		// . In the block context - ? : must be not be followed with a space.
 		// . In the flow context ? is illegal and : and - must not be followed with a space.
 		inline const RegEx& PlainScalar() {
-			static const RegEx e = !(BlankOrBreak() || RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) || (RegEx("-?:", REGEX_OR) + Blank()));
+			static const RegEx e = !(BlankOrBreak() || RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) || (RegEx("-?:", REGEX_OR) + (BlankOrBreak() || RegEx())));
 			return e;
 		}
 		inline const RegEx& PlainScalarInFlow() {
@@ -149,7 +149,7 @@ namespace YAML
 			return e;
 		}
 		inline const RegEx& EndScalarInFlow() {
-			static const RegEx e = (RegEx(':') + (BlankOrBreak() || RegEx(",]}", REGEX_OR))) || RegEx(",?[]{}", REGEX_OR);
+			static const RegEx e = (RegEx(':') + (BlankOrBreak() || RegEx() || RegEx(",]}", REGEX_OR))) || RegEx(",?[]{}", REGEX_OR);
 			return e;
 		}
 

src/node.cpp

@@ -1,14 +1,14 @@
 #include "yaml-cpp/node.h"
+#include "yaml-cpp/aliasmanager.h"
+#include "yaml-cpp/emitfromevents.h"
+#include "yaml-cpp/emitter.h"
+#include "yaml-cpp/eventhandler.h"
 #include "iterpriv.h"
 #include "nodebuilder.h"
 #include "nodeownership.h"
 #include "scanner.h"
 #include "tag.h"
 #include "token.h"
-#include "yaml-cpp/aliasmanager.h"
-#include "yaml-cpp/emitfromevents.h"
-#include "yaml-cpp/emitter.h"
-#include "yaml-cpp/eventhandler.h"
 #include <cassert>
 #include <stdexcept>
 

src/parser.cpp

@@ -1,8 +1,8 @@
 #include "yaml-cpp/parser.h"
-#include "directives.h"
 #include "yaml-cpp/eventhandler.h"
 #include "yaml-cpp/exceptions.h"
 #include "yaml-cpp/node.h"
+#include "directives.h"
 #include "nodebuilder.h"
 #include "scanner.h"
 #include "singledocparser.h"