Bumped version to 0.2.7

It seems that it's not necessary to export those members (as long as you can't access them), and most of them are STL instances, which apparently cause lots of problems for DLLs. (For example, you simply can't export instances of std::map; see http://support.microsoft.com/kb/168958.)

.hgeol

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

CMakeLists.txt

@@ -1,62 +1,267 @@
+###
+### CMake settings
+###
+## Due to Mac OSX we need to keep compatibility with CMake 2.6
+# see http://www.cmake.org/Wiki/CMake_Policies
 cmake_minimum_required(VERSION 2.6)
+# see http://www.cmake.org/cmake/help/cmake-2-8-docs.html#policy:CMP0012
+if(POLICY CMP0012)
+	cmake_policy(SET CMP0012 OLD)
+endif()
+# see http://www.cmake.org/cmake/help/cmake-2-8-docs.html#policy:CMP0015
+if(POLICY CMP0015)
+	cmake_policy(SET CMP0015 OLD)
+endif()
 
-project (YAML_CPP)
+include(CheckCXXCompilerFlag)
 
-set(LIB_TYPE SHARED)
 
-if(IPHONE)
-  set(CMAKE_OSX_SYSROOT iphoneos2.2.1)
-  set(LIB_TYPE)
-endif(IPHONE)
-
-if(CMAKE_COMPILER_IS_GNUCC)
-  set(CMAKE_CXX_FLAGS "-O2 -Wall -pedantic -Wextra ${CMAKE_CXX_FLAGS}")
-endif(CMAKE_COMPILER_IS_GNUCC)
+###
+### Project settings
+###
+project(YAML_CPP)
 
 set(YAML_CPP_VERSION_MAJOR "0")
 set(YAML_CPP_VERSION_MINOR "2")
-set(YAML_CPP_VERSION_PATCH "3")
+set(YAML_CPP_VERSION_PATCH "7")
 set(YAML_CPP_VERSION "${YAML_CPP_VERSION_MAJOR}.${YAML_CPP_VERSION_MINOR}.${YAML_CPP_VERSION_PATCH}")
 
 enable_testing()
 
-option(YAML_CPP_BUILD_TOOLS "Enables or disables yaml-reader and parse tools" true)
+
+###
+### Project options
+###
+## Project stuff
+option(YAML_CPP_BUILD_TOOLS "Enable testing and parse tools" ON)
+option(YAML_CPP_BUILD_CONTRIB "Enable contrib stuff in library" ON)
+
+## Build options
+# --> General
+# see http://www.cmake.org/cmake/help/cmake2.6docs.html#variable:BUILD_SHARED_LIBS
+#     http://www.cmake.org/cmake/help/cmake2.6docs.html#command:add_library
+option(BUILD_SHARED_LIBS "Build Shared Libraries" OFF)
+
+# --> Apple
+option(APPLE_UNIVERSAL_BIN "Apple: Build universal binary" OFF)
+
+# --> Microsoft Visual C++
+# see http://msdn.microsoft.com/en-us/library/aa278396(v=VS.60).aspx
+#     http://msdn.microsoft.com/en-us/library/2kzt1wy3(v=VS.71).aspx
+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
+###
+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")
+	file(GLOB contrib_private_headers "src/contrib/[a-zA-Z]*.h")
+else()
+	add_definitions(-DYAML_CPP_NO_CONTRIB)
+endif()
+
+if(VERBOSE)
+	message(STATUS "sources: ${sources}")
+	message(STATUS "public_headers: ${public_headers}")
+	message(STATUS "private_headers: ${private_headers}")
+	message(STATUS "contrib_sources: ${contrib_sources}")
+	message(STATUS "contrib_public_headers: ${contrib_public_headers}")
+	message(STATUS "contrib_private_headers: ${contrib_private_headers}")
+endif()
+
+include_directories(${YAML_CPP_SOURCE_DIR}/include)
+
+
+###
+### General compilation settings
+###
+if(BUILD_SHARED_LIBS)
+	set(LABEL_SUFFIX "shared")
+else()
+	set(LABEL_SUFFIX "static")
+endif()
+
+if(APPLE)
+	if(APPLE_UNIVERSAL_BIN)
+		set(CMAKE_OSX_ARCHITECTURES ppc;i386)
+	endif()
+endif()
+
+if(IPHONE)
+	set(CMAKE_OSX_SYSROOT "iphoneos4.2")
+	set(CMAKE_OSX_ARCHITECTURES "armv6;armv7")
+endif()
 
 if(WIN32)
-  set(_library_dir bin) # .dll are in PATH, like executables
-else(WIN32)
-  set(_library_dir lib)
-endif(WIN32)
+	if(BUILD_SHARED_LIBS)
+		add_definitions(-D${PROJECT_NAME}_DLL)	# use or build Windows DLL
+	endif()
+	if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+		set(CMAKE_INSTALL_PREFIX "C:/")
+	endif()
+endif()
 
-set(INCLUDE_INSTALL_DIR include/yaml-cpp)
-set(LIB_INSTALL_DIR ${_library_dir}${LIB_SUFFIX})
+# GCC specialities
+if(CMAKE_COMPILER_IS_GNUCXX)
+	### General stuff
+	if(WIN32)
+		set(CMAKE_SHARED_LIBRARY_PREFIX "")	# DLLs do not have a "lib" prefix
+		set(CMAKE_IMPORT_LIBRARY_PREFIX "")	# same for DLL import libs
+		set(CMAKE_LINK_DEF_FILE_FLAG "")	# CMake workaround (2.8.3)
+	endif()
+
+	### Project stuff
+	if(NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
+		set(CMAKE_BUILD_TYPE Release)
+	endif()
+	#
+	set(CMAKE_CXX_FLAGS_RELEASE "-O2")
+	set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")
+	set(CMAKE_CXX_FLAGS_DEBUG "-g")
+	set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os")
+	#
+	set(GCC_EXTRA_OPTIONS "")
+	#
+	set(FLAG_TESTED "-Wextra")
+	check_cxx_compiler_flag(${FLAG_TESTED} FLAG_WEXTRA)
+	if(FLAG_WEXTRA)
+		set(GCC_EXTRA_OPTIONS "${GCC_EXTRA_OPTIONS} ${FLAG_TESTED}")
+	endif()
+	#
+	set(CMAKE_CXX_FLAGS "-Wall ${GCC_EXTRA_OPTIONS} -pedantic -Wno-long-long ${CMAKE_CXX_FLAGS}")
+	#
+	add_custom_target(debuggable $(MAKE) clean
+		COMMAND ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE=Debug ${CMAKE_SOURCE_DIR}
+		COMMENT "Adjusting settings for debug compilation"
+		VERBATIM)
+	add_custom_target(releasable $(MAKE) clean
+		COMMAND ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE=Release ${CMAKE_SOURCE_DIR}
+		COMMENT "Adjusting settings for release compilation"
+		VERBATIM)
+endif()
+
+# Microsoft VisualC++ specialities
+if(MSVC)
+	### General stuff
+	# a) Change MSVC runtime library settings (/MD[d], /MT[d], /ML[d] (single-threaded until VS 2003))
+	#    plus set lib suffix for later use and project label accordingly
+	# see http://msdn.microsoft.com/en-us/library/aa278396(v=VS.60).aspx
+	#     http://msdn.microsoft.com/en-us/library/2kzt1wy3(v=VS.71).aspx
+	set(LIB_RT_SUFFIX "md")	# CMake defaults to /MD for MSVC
+	set(LIB_RT_OPTION "/MD")
+	#
+	if(NOT MSVC_SHARED_RT)	# User wants to have static runtime libraries (/MT, /ML)
+		if(MSVC_STHREADED_RT)	# User wants to have old single-threaded static runtime libraries
+			set(LIB_RT_SUFFIX "ml")
+			set(LIB_RT_OPTION "/ML")
+			if(NOT ${MSVC_VERSION} LESS 1400)
+				message(FATAL_ERROR "Single-threaded static runtime libraries (/ML) only available until VS .NET 2003 (7.1).")
+			endif()
+		else()
+			set(LIB_RT_SUFFIX "mt")
+			set(LIB_RT_OPTION "/MT")
+		endif()
+
+		# correct linker options
+		foreach(flag_var  CMAKE_C_FLAGS  CMAKE_CXX_FLAGS)
+			foreach(config_name  ""  DEBUG  RELEASE  MINSIZEREL  RELWITHDEBINFO)
+				set(var_name "${flag_var}")
+				if(NOT "${config_name}" STREQUAL "")
+					set(var_name "${var_name}_${config_name}")
+				endif()
+				string(REPLACE "/MD" "${LIB_RT_OPTION}" ${var_name} "${${var_name}}")
+			endforeach()
+		endforeach()
+	endif()
+	#
+	set(LABEL_SUFFIX "${LABEL_SUFFIX} ${LIB_RT_SUFFIX}")
+
+	# b) Change prefix for static libraries
+	set(CMAKE_STATIC_LIBRARY_PREFIX "lib")	# to distinguish static libraries from DLL import libs
+
+	# c) Correct suffixes for static libraries
+	if(NOT BUILD_SHARED_LIBS)
+		### General stuff
+		set(LIB_TARGET_SUFFIX "${LIB_SUFFIX}${LIB_RT_SUFFIX}")
+	endif()
+
+	### Project stuff
+	# /W3 = set warning level; see http://msdn.microsoft.com/en-us/library/thxezb7y.aspx
+	# /wd4127 = disable warning C4127 "conditional expression is constant"; see http://msdn.microsoft.com/en-us/library/6t66728h.aspx
+	# /wd4355 = disable warning C4355 "'this' : used in base member initializer list"; http://msdn.microsoft.com/en-us/library/3c594ae3.aspx
+	set(CMAKE_CXX_FLAGS "/W3 /wd4127 /wd4355 /D_SCL_SECURE_NO_WARNINGS ${CMAKE_CXX_FLAGS}")
+endif()
+
+
+###
+### General install settings
+###
+if(WIN32)
+	set(_library_dir bin)	# .dll are in PATH, like executables
+else()
+	set(_library_dir lib)
+endif()
+
+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
 	RUNTIME DESTINATION bin
 	LIBRARY DESTINATION ${LIB_INSTALL_DIR}
-	ARCHIVE DESTINATION lib${LIB_SUFFIX}
+	ARCHIVE DESTINATION "lib${LIB_SUFFIX}"
 )
-#
-file(GLOB public_headers include/[a-z]*.h)
-file(GLOB private_headers src/[a-z]*.h)
-file(GLOB sources src/[a-z]*.cpp)
 
-include_directories(${YAML_CPP_SOURCE_DIR}/include)
+
+###
+### Library
+###
 add_library(yaml-cpp
-	${LIB_TYPE}
+	${sources}
 	${public_headers}
 	${private_headers}
-	${sources}
+	${contrib_sources}
+	${contrib_public_headers}
+	${contrib_private_headers}
 )
+
 set_target_properties(yaml-cpp PROPERTIES
 	VERSION "${YAML_CPP_VERSION}"
 	SOVERSION "${YAML_CPP_VERSION_MAJOR}.${YAML_CPP_VERSION_MINOR}"
+	PROJECT_LABEL "yaml-cpp ${LABEL_SUFFIX}"
 )
 
+if(IPHONE)
+	set_target_properties(yaml-cpp PROPERTIES
+		XCODE_ATTRIBUTE_IPHONEOS_DEPLOYMENT_TARGET "3.0"
+	)
+endif()
+
+if(MSVC)
+	if(NOT BUILD_SHARED_LIBS)
+		# correct library names
+		set_target_properties(yaml-cpp PROPERTIES
+			DEBUG_POSTFIX "${LIB_TARGET_SUFFIX}d"
+			RELEASE_POSTFIX "${LIB_TARGET_SUFFIX}"
+			MINSIZEREL_POSTFIX "${LIB_TARGET_SUFFIX}"
+			RELWITHDEBINFO_POSTFIX "${LIB_TARGET_SUFFIX}"
+		)
+	endif()
+endif()
+
 install(TARGETS yaml-cpp ${_INSTALL_DESTINATIONS})
 install(
-	FILES ${public_headers}
+	FILES
+		${public_headers}
+		${contrib_public_headers}
 	DESTINATION ${INCLUDE_INSTALL_DIR}
 )
 
@@ -64,9 +269,13 @@ if(UNIX)
 	set(PC_FILE ${CMAKE_BINARY_DIR}/yaml-cpp.pc)
 	configure_file("yaml-cpp.pc.cmake" ${PC_FILE} @ONLY)
 	install(FILES ${PC_FILE} DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
-endif(UNIX)
+endif()
 
+
+###
+### Extras
+###
 if(YAML_CPP_BUILD_TOOLS)
-	add_subdirectory (yaml-reader)
-	add_subdirectory (util)
-endif(YAML_CPP_BUILD_TOOLS)
+	add_subdirectory(test)
+	add_subdirectory(util)
+endif()

include/conversion.h

@@ -1,43 +0,0 @@
-#pragma once
-
-#ifndef CONVERSION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define CONVERSION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-#include "null.h"
-#include <string>
-#include <sstream>
-
-namespace YAML
-{
-	inline bool Convert(const std::string& input, std::string& output) {
-		output = input;
-		return true;
-	}
-	
-	bool Convert(const std::string& input, bool& output);
-	bool Convert(const std::string& input, _Null& output);
-	
-#define YAML_MAKE_STREAM_CONVERT(type) \
-	inline bool Convert(const std::string& input, type& output) { \
-		std::stringstream stream(input); \
-		stream >> output; \
-		return !stream.fail(); \
-	}
-	
-	YAML_MAKE_STREAM_CONVERT(char)
-	YAML_MAKE_STREAM_CONVERT(unsigned char)
-	YAML_MAKE_STREAM_CONVERT(int)
-	YAML_MAKE_STREAM_CONVERT(unsigned int)
-	YAML_MAKE_STREAM_CONVERT(short)
-	YAML_MAKE_STREAM_CONVERT(unsigned short)
-	YAML_MAKE_STREAM_CONVERT(long)
-	YAML_MAKE_STREAM_CONVERT(unsigned long)
-	YAML_MAKE_STREAM_CONVERT(float)
-	YAML_MAKE_STREAM_CONVERT(double)
-	YAML_MAKE_STREAM_CONVERT(long double)
-	
-#undef YAML_MAKE_STREAM_CONVERT
-}
-
-#endif // CONVERSION_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/crt.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#ifndef CRT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define CRT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-// for detecting memory leaks
-#ifdef _DEBUG
-
-#define _CRTDBG_MAP_ALLOC
-#include <stdlib.h>
-#include <crtdbg.h>
-
-#endif // _DEBUG
-
-
-#endif // CRT_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/emitter.h

@@ -1,95 +0,0 @@
-#pragma once
-
-#ifndef EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-#include "emittermanip.h"
-#include "ostream.h"
-#include "null.h"
-#include <memory>
-#include <string>
-
-namespace YAML
-{
-	class EmitterState;
-	
-	class Emitter
-	{
-	public:
-		Emitter();
-		~Emitter();
-		
-		// output
-		const char *c_str() const;
-		unsigned size() const;
-		
-		// state checking
-		bool good() const;
-		const std::string GetLastError() const;
-		
-		// global setters
-		bool SetOutputCharset(EMITTER_MANIP value);
-		bool SetStringFormat(EMITTER_MANIP value);
-		bool SetBoolFormat(EMITTER_MANIP value);
-		bool SetIntBase(EMITTER_MANIP value);
-		bool SetSeqFormat(EMITTER_MANIP value);
-		bool SetMapFormat(EMITTER_MANIP value);
-		bool SetIndent(unsigned n);
-		bool SetPreCommentIndent(unsigned n);
-		bool SetPostCommentIndent(unsigned n);
-		
-		// local setters
-		Emitter& SetLocalValue(EMITTER_MANIP value);
-		Emitter& SetLocalIndent(const _Indent& indent);
-		
-		// overloads of write
-		Emitter& Write(const std::string& str);
-		Emitter& Write(const char *str);
-		Emitter& Write(int i);
-		Emitter& Write(bool b);
-		Emitter& Write(float f);
-		Emitter& Write(double d);
-		Emitter& Write(const _Alias& alias);
-		Emitter& Write(const _Anchor& anchor);
-		Emitter& Write(const _Comment& comment);
-		Emitter& Write(const _Null& null);
-		
-	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 EmitBeginSeq();
-		void EmitEndSeq();
-		void EmitBeginMap();
-		void EmitEndMap();
-		void EmitKey();
-		void EmitValue();
-		
-	private:
-		ostream m_stream;
-		std::auto_ptr <EmitterState> m_pState;
-	};
-	
-	// overloads of insertion
-	template <typename T>
-	inline Emitter& operator << (Emitter& emitter, T v) {
-		return emitter.Write(v);
-	}
-
-	template <>
-	inline Emitter& operator << (Emitter& emitter, EMITTER_MANIP value) {
-		return emitter.SetLocalValue(value);
-	}
-	
-	template <>
-	inline Emitter& operator << (Emitter& emitter, _Indent indent) {
-		return emitter.SetLocalIndent(indent);
-	}
-}
-
-#endif // EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/exceptions.h

@@ -1,137 +0,0 @@
-#pragma once
-
-#ifndef EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-#include "mark.h"
-#include <exception>
-#include <string>
-#include <sstream>
-
-namespace YAML
-{
-	// error messages
-	namespace ErrorMsg
-	{
-		const std::string YAML_DIRECTIVE_ARGS    = "YAML directives must have exactly one argument";
-		const std::string YAML_VERSION           = "bad YAML version: ";
-		const std::string YAML_MAJOR_VERSION     = "YAML major version too large";
-		const std::string TAG_DIRECTIVE_ARGS     = "TAG directives must have exactly two arguments";
-		const std::string END_OF_MAP             = "end of map not found";
-		const std::string END_OF_MAP_FLOW        = "end of map flow not found";
-		const std::string END_OF_SEQ             = "end of sequence not found";
-		const std::string END_OF_SEQ_FLOW        = "end of sequence flow not found";
-		const std::string MULTIPLE_TAGS          = "cannot assign multiple tags to the same node";
-		const std::string MULTIPLE_ANCHORS       = "cannot assign multiple anchors to the same node";
-		const std::string MULTIPLE_ALIASES       = "cannot assign multiple aliases to the same node";
-		const std::string ALIAS_CONTENT          = "aliases can't have any content, *including* tags";
-		const std::string INVALID_HEX            = "bad character found while scanning hex number";
-		const std::string INVALID_UNICODE        = "invalid unicode: ";
-		const std::string INVALID_ESCAPE         = "unknown escape character: ";
-		const std::string UNKNOWN_TOKEN          = "unknown token";
-		const std::string DOC_IN_SCALAR          = "illegal document indicator in scalar";
-		const std::string EOF_IN_SCALAR          = "illegal EOF in scalar";
-		const std::string CHAR_IN_SCALAR         = "illegal character in scalar";
-		const std::string TAB_IN_INDENTATION     = "illegal tab when looking for indentation";
-		const std::string FLOW_END               = "illegal flow end";
-		const std::string BLOCK_ENTRY            = "illegal block entry";
-		const std::string MAP_KEY                = "illegal map key";
-		const std::string MAP_VALUE              = "illegal map value";
-		const std::string ALIAS_NOT_FOUND        = "alias not found after *";
-		const std::string ANCHOR_NOT_FOUND       = "anchor not found after &";
-		const std::string CHAR_IN_ALIAS          = "illegal character found while scanning alias";
-		const std::string CHAR_IN_ANCHOR         = "illegal character found while scanning anchor";
-		const std::string ZERO_INDENT_IN_BLOCK   = "cannot set zero indentation for a block scalar";
-		const std::string CHAR_IN_BLOCK          = "unexpected character in block scalar";
-		const std::string AMBIGUOUS_ANCHOR     = "cannot assign the same alias to multiple nodes";
-		const std::string UNKNOWN_ANCHOR       = "the referenced anchor is not defined";
-
-		const std::string INVALID_SCALAR         = "invalid scalar";
-		const std::string KEY_NOT_FOUND          = "key not found";
-		const std::string BAD_DEREFERENCE        = "bad dereference";
-		
-		const std::string UNMATCHED_GROUP_TAG    = "unmatched group tag";
-		const std::string UNEXPECTED_END_SEQ     = "unexpected end sequence token";
-		const std::string UNEXPECTED_END_MAP     = "unexpected end map token";
-		const std::string SINGLE_QUOTED_CHAR     = "invalid character in single-quoted string";
-		const std::string INVALID_ANCHOR         = "invalid anchor";
-		const std::string INVALID_ALIAS          = "invalid alias";
-		const std::string EXPECTED_KEY_TOKEN     = "expected key token";
-		const std::string EXPECTED_VALUE_TOKEN   = "expected value token";
-		const std::string UNEXPECTED_KEY_TOKEN   = "unexpected key token";
-		const std::string UNEXPECTED_VALUE_TOKEN = "unexpected value token";
-	}
-
-	class Exception: public std::exception {
-	public:
-		Exception(const Mark& mark_, const std::string& msg_)
-			: mark(mark_), msg(msg_) {
-				std::stringstream output;
-				output << "yaml-cpp: error at line " << mark.line+1 << ", column " << mark.column+1 << ": " << msg;
-				what_ = output.str();
-			}
-		virtual ~Exception() throw() {}
-		virtual const char *what() const throw() { return what_.c_str(); }
-
-		Mark mark;
-		std::string msg;
-		
-	private:
-		std::string what_;
-	};
-
-	class ParserException: public Exception {
-	public:
-		ParserException(const Mark& mark_, const std::string& msg_)
-			: Exception(mark_, msg_) {}
-	};
-
-	class RepresentationException: public Exception {
-	public:
-		RepresentationException(const Mark& mark_, const std::string& msg_)
-			: Exception(mark_, msg_) {}
-	};
-
-	// representation exceptions
-	class InvalidScalar: public RepresentationException {
-	public:
-		InvalidScalar(const Mark& mark_)
-			: RepresentationException(mark_, ErrorMsg::INVALID_SCALAR) {}
-	};
-
-	class KeyNotFound: public RepresentationException {
-	public:
-		KeyNotFound(const Mark& mark_)
-			: RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND) {}
-	};
-
-	template <typename T>
-	class TypedKeyNotFound: public KeyNotFound {
-	public:
-		TypedKeyNotFound(const Mark& mark_, const T& key_)
-			: KeyNotFound(mark_), key(key_) {}
-		~TypedKeyNotFound() throw() {}
-
-		T key;
-	};
-
-	template <typename T>
-	TypedKeyNotFound <T> MakeTypedKeyNotFound(const Mark& mark, const T& key) {
-		return TypedKeyNotFound <T> (mark, key);
-	}
-
-	class BadDereference: public RepresentationException {
-	public:
-		BadDereference()
-		: RepresentationException(Mark::null(), ErrorMsg::BAD_DEREFERENCE) {}
-	};
-	
-	class EmitterException: public Exception {
-	public:
-		EmitterException(const std::string& msg_)
-		: Exception(Mark::null(), msg_) {}
-	};
-}
-
-#endif // EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/node.h

@@ -1,138 +0,0 @@
-#pragma once
-
-#ifndef NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-#include "conversion.h"
-#include "exceptions.h"
-#include "iterator.h"
-#include "mark.h"
-#include "noncopyable.h"
-#include "parserstate.h"
-#include <iostream>
-#include <string>
-#include <vector>
-#include <map>
-#include <memory>
-
-namespace YAML
-{
-	class Content;
-	class Scanner;
-	class Emitter;
-
-	enum CONTENT_TYPE { CT_NONE, CT_SCALAR, CT_SEQUENCE, CT_MAP };
-
-	class Node: private noncopyable
-	{
-	public:
-		Node();
-		~Node();
-
-		void Clear();
-		std::auto_ptr<Node> Clone() const;
-		void Parse(Scanner *pScanner, const ParserState& state);
-
-		CONTENT_TYPE GetType() 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 Read() const;
-		
-		template <typename T>
-		operator T() const;
-
-		template <typename T>
-		friend 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 anchors/aliases
-		const Node *Identity() const { return m_pIdentity; }
-		bool IsAlias() const { return m_alias; }
-		bool IsReferenced() const { return m_referenced; }
-
-		// emitting
-		friend Emitter& operator << (Emitter& out, const Node& node);
-
-		// ordering
-		int Compare(const Node& rhs) const;
-		friend bool operator < (const Node& n1, const Node& n2);
-
-	private:
-		// 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;
-		
-		// helper for cloning
-		Node(const Mark& mark, const std::string& anchor, const std::string& tag, const Content *pContent);
-
-		// helpers for parsing
-		void ParseHeader(Scanner *pScanner, const ParserState& state);
-		void ParseTag(Scanner *pScanner, const ParserState& state);
-		void ParseAnchor(Scanner *pScanner, const ParserState& state);
-		void ParseAlias(Scanner *pScanner, const ParserState& state);
-
-	private:
-		Mark m_mark;
-		std::string m_anchor, m_tag;
-		Content *m_pContent;
-		bool m_alias;
-		const Node *m_pIdentity;
-		mutable bool m_referenced;
-	};
-	
-	// comparisons with auto-conversion
-	template <typename T>
-	bool operator == (const T& value, const Node& node);
-	
-	template <typename T>
-	bool operator == (const Node& node, const T& value);
-	
-	template <typename T>
-	bool operator != (const T& value, const Node& node);
-	
-	template <typename T>
-	bool operator != (const Node& node, const T& value);
-	
-	bool operator == (const char *value, const Node& node);
-	bool operator == (const Node& node, const char *value);
-	bool operator != (const char *value, const Node& node);
-	bool operator != (const Node& node, const char *value);
-}
-
-#include "nodeimpl.h"
-#include "nodereadimpl.h"
-
-#endif // NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/nodeimpl.h

@@ -1,118 +0,0 @@
-#pragma once
-
-#ifndef NODEIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NODEIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-#include "nodeutil.h"
-
-namespace YAML
-{
-	// implementation of templated things
-	template <typename T>
-	inline const T Node::Read() const {
-		T value;
-		*this >> value;
-		return value;
-	}
-	
-	template <typename T>
-	Node::operator T() const {
-		return Read<T>();
-	}
-
-	template <typename T>
-	inline void operator >> (const Node& node, T& value) {
-		if(!ConvertScalar(node, value))
-			throw InvalidScalar(node.m_mark);
-	}
-	
-	template <typename T>
-	inline const Node *Node::FindValue(const T& key) const {
-		switch(GetType()) {
-			case CT_MAP:
-				return FindValueForKey(key);
-			case CT_SEQUENCE:
-				return FindFromNodeAtIndex(*this, key);
-			default:
-				return 0;
-		}
-	}
-	
-	template <typename T>
-	inline const Node *Node::FindValueForKey(const T& key) const {
-		for(Iterator it=begin();it!=end();++it) {
-			T t;
-			if(it.first().Read(t)) {
-				if(key == t)
-					return &it.second();
-			}
-		}
-		
-		return 0;
-	}
-	
-	template <typename T>
-	inline const Node& Node::GetValue(const T& key) const {
-		if(!m_pContent)
-			throw BadDereference();
-		
-		const Node *pValue = FindValue(key);
-		if(!pValue)
-			throw MakeTypedKeyNotFound(m_mark, key);
-
-		return *pValue;
-	}
-	
-	template <typename T>
-	inline const Node& Node::operator [] (const T& key) const {
-		return GetValue(key);
-	}
-	
-	inline const Node *Node::FindValue(const char *key) const {
-		return FindValue(std::string(key));
-	}
-	
-	inline const Node& Node::operator [] (const char *key) const {
-		return GetValue(std::string(key));
-	}
-
-	template <typename T>
-	inline bool operator == (const T& value, const Node& node) {
-		return value == node.operator T();
-	}
-	
-	template <typename T>
-	inline bool operator == (const Node& node, const T& value) {
-		return value == node.operator T();
-	}
-	
-	template <typename T>
-	inline bool operator != (const T& value, const Node& node) {
-		return value != node.operator T();
-	}
-	
-	template <typename T>
-	inline bool operator != (const Node& node, const T& value) {
-		return value != node.operator T();
-	}
-
-	inline bool operator == (const char *value, const Node& node) {
-		return std::string(value) == node;
-	}
-	
-	inline bool operator == (const Node& node, const char *value) {
-		return std::string(value) == node;
-	}
-	
-	inline bool operator != (const char *value, const Node& node) {
-		return std::string(value) != node;
-	}
-	
-	inline bool operator != (const Node& node, const char *value) {
-		return std::string(value) != node;
-	}
-	
-}
-
-#endif // NODEIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/noncopyable.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#ifndef NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-namespace YAML
-{
-	// this is basically boost::noncopyable
-	class noncopyable
-		{
-		protected:
-			noncopyable() {}
-			~noncopyable() {}
-			
-		private:
-			noncopyable(const noncopyable&);
-			const noncopyable& operator = (const noncopyable&);
-		};
-}
-
-#endif // NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/parser.h

@@ -1,46 +0,0 @@
-#pragma once
-
-#ifndef PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-#include "node.h"
-#include "parserstate.h"
-#include "noncopyable.h"
-#include <ios>
-#include <string>
-#include <vector>
-#include <map>
-#include <memory>
-
-namespace YAML
-{
-	class Scanner;
-	struct Token;
-
-	class Parser: private noncopyable
-	{
-	public:
-		Parser();
-		Parser(std::istream& in);
-		~Parser();
-
-		operator bool() const;
-
-		void Load(std::istream& in);
-		bool GetNextDocument(Node& document);
-		void PrintTokens(std::ostream& out);
-
-	private:
-		void ParseDirectives();
-		void HandleDirective(Token *pToken);
-		void HandleYamlDirective(Token *pToken);
-		void HandleTagDirective(Token *pToken);
-
-	private:
-		std::auto_ptr<Scanner> m_pScanner;
-		ParserState m_state;
-	};
-}
-
-#endif // PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/parserstate.h

@@ -1,26 +0,0 @@
-#pragma once
-
-#ifndef PARSERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define PARSERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-#include <string>
-#include <map>
-
-namespace YAML
-{
-	struct Version {
-		int major, minor;
-	};
-
-	struct ParserState
-	{
-		Version version;
-		std::map <std::string, std::string> tags;
-
-		void Reset();
-		std::string TranslateTag(const std::string& handle) const;
-	};
-}
-
-#endif // PARSERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/stlemitter.h

@@ -1,44 +0,0 @@
-#pragma once
-
-#ifndef STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-#include <vector>
-#include <list>
-#include <map>
-
-namespace YAML
-{
-	template <typename T>
-	inline Emitter& operator << (Emitter& emitter, const std::vector <T>& v) {
-		typedef typename std::vector <T> vec;
-		emitter << BeginSeq;
-		for(typename vec::const_iterator it=v.begin();it!=v.end();++it)
-			emitter << *it;
-		emitter << EndSeq;
-		return emitter;
-	}	
-
-	template <typename T>
-	inline Emitter& operator << (Emitter& emitter, const std::list <T>& v) {
-		typedef typename std::list <T> list;
-		emitter << BeginSeq;
-		for(typename list::const_iterator it=v.begin();it!=v.end();++it)
-			emitter << *it;
-		emitter << EndSeq;
-		return emitter;
-	}
-	
-	template <typename K, typename V>
-	inline Emitter& operator << (Emitter& emitter, const std::map <K, V>& m) {
-		typedef typename std::map <K, V> map;
-		emitter << BeginMap;
-		for(typename map::const_iterator it=m.begin();it!=m.end();++it)
-			emitter << Key << it->first << Value << it->second;
-		emitter << EndMap;
-		return emitter;
-	}
-}
-
-#endif // STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/aliasmanager.h

@@ -0,0 +1,34 @@
+#ifndef ALIASMANAGER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define ALIASMANAGER_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 "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

@@ -0,0 +1,16 @@
+#ifndef ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define ANCHOR_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 <cstddef>
+
+namespace YAML
+{
+	typedef std::size_t anchor_t;
+	const anchor_t NullAnchor = 0;
+}
+
+#endif // ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/contrib/anchordict.h

@@ -0,0 +1,42 @@
+#ifndef ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define ANCHORDICT_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 <vector>
+
+#include "../anchor.h"
+
+namespace YAML
+{
+  /// AnchorDict
+  /// . An object that stores and retrieves values correlating to anchor_t
+  ///   values.
+  /// . Efficient implementation that can make assumptions about how anchor_t
+  ///   values are assigned by the Parser class.
+  template <class T>
+  class AnchorDict
+  {
+  public:
+    void Register(anchor_t anchor, T value)
+    {
+      if (anchor > m_data.size())
+      {
+        m_data.resize(anchor);
+      }
+      m_data[anchor - 1] = value;
+    }
+    
+    T Get(anchor_t anchor) const
+    {
+      return m_data[anchor - 1];
+    }
+  
+  private:
+    std::vector<T> m_data;
+  };
+}
+
+#endif // ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/contrib/graphbuilder.h

@@ -0,0 +1,133 @@
+#ifndef GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define GRAPHBUILDER_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 "yaml-cpp/mark.h"
+#include <string>
+
+namespace YAML
+{
+  class Parser;
+  
+  // GraphBuilderInterface
+  // . Abstraction of node creation
+  // . pParentNode is always NULL or the return value of one of the NewXXX()
+  //   functions.
+  class GraphBuilderInterface
+  {
+  public:
+    // Create and return a new node with a null value.
+    virtual void *NewNull(const Mark& mark, void *pParentNode) = 0;
+    
+    // Create and return a new node with the given tag and value.
+    virtual void *NewScalar(const Mark& mark, const std::string& tag, void *pParentNode, const std::string& value) = 0;
+    
+    // Create and return a new sequence node
+    virtual void *NewSequence(const Mark& mark, const std::string& tag, void *pParentNode) = 0;
+    // Add pNode to pSequence.  pNode was created with one of the NewXxx()
+    // functions and pSequence with NewSequence().
+    virtual void AppendToSequence(void *pSequence, void *pNode) = 0;
+    // Note that no moew entries will be added to pSequence
+    virtual void SequenceComplete(void *pSequence) {(void)pSequence;}
+    
+    // Create and return a new map node
+    virtual void *NewMap(const Mark& mark, const std::string& tag, void *pParentNode) = 0;
+    // Add the pKeyNode => pValueNode mapping to pMap.  pKeyNode and pValueNode
+    // were created with one of the NewXxx() methods and pMap with NewMap().
+    virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) = 0;
+    // Note that no more assignments will be made in pMap
+    virtual void MapComplete(void *pMap) {(void)pMap;}
+    
+    // Return the node that should be used in place of an alias referencing
+    // pNode (pNode by default)
+    virtual void *AnchorReference(const Mark& mark, void *pNode) {(void)mark; return pNode;}
+  };
+  
+  // Typesafe wrapper for GraphBuilderInterface.  Assumes that Impl defines
+  // Node, Sequence, and Map types.  Sequence and Map must derive from Node
+  // (unless Node is defined as void).  Impl must also implement function with
+  // all of the same names as the virtual functions in GraphBuilderInterface
+  // -- including the ones with default implementations -- but with the
+  // prototypes changed to accept an explicit Node*, Sequence*, or Map* where
+  // appropriate.
+  template <class Impl>
+  class GraphBuilder : public GraphBuilderInterface
+  {
+  public:
+    typedef typename Impl::Node Node;
+    typedef typename Impl::Sequence Sequence;
+    typedef typename Impl::Map Map;
+    
+    GraphBuilder(Impl& impl) : m_impl(impl)
+    {
+      Map* pMap = NULL;
+      Sequence* pSeq = NULL;
+      Node* pNode = NULL;
+      
+      // Type consistency checks
+      pNode = pMap;
+      pNode = pSeq;
+    }
+    
+    GraphBuilderInterface& AsBuilderInterface() {return *this;}
+    
+    virtual void *NewNull(const Mark& mark, void* pParentNode) {
+      return CheckType<Node>(m_impl.NewNull(mark, AsNode(pParentNode)));
+    }
+    
+    virtual void *NewScalar(const Mark& mark, const std::string& tag, void *pParentNode, const std::string& value) {
+      return CheckType<Node>(m_impl.NewScalar(mark, tag, AsNode(pParentNode), value));
+    }
+    
+    virtual void *NewSequence(const Mark& mark, const std::string& tag, void *pParentNode) {
+      return CheckType<Sequence>(m_impl.NewSequence(mark, tag, AsNode(pParentNode)));
+    }
+    virtual void AppendToSequence(void *pSequence, void *pNode) {
+      m_impl.AppendToSequence(AsSequence(pSequence), AsNode(pNode));
+    }
+    virtual void SequenceComplete(void *pSequence) {
+      m_impl.SequenceComplete(AsSequence(pSequence));
+    }
+    
+    virtual void *NewMap(const Mark& mark, const std::string& tag, void *pParentNode) {
+      return CheckType<Map>(m_impl.NewMap(mark, tag, AsNode(pParentNode)));
+    }
+    virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) {
+      m_impl.AssignInMap(AsMap(pMap), AsNode(pKeyNode), AsNode(pValueNode));
+    }
+    virtual void MapComplete(void *pMap) {
+      m_impl.MapComplete(AsMap(pMap));
+    }
+    
+    virtual void *AnchorReference(const Mark& mark, void *pNode) {
+      return CheckType<Node>(m_impl.AnchorReference(mark, AsNode(pNode)));
+    }
+  
+  private:
+    Impl& m_impl;
+    
+    // Static check for pointer to T
+    template <class T, class U>
+    static T* CheckType(U* p) {return p;}
+    
+    static Node *AsNode(void *pNode) {return static_cast<Node*>(pNode);}
+    static Sequence *AsSequence(void *pSeq) {return static_cast<Sequence*>(pSeq);}
+    static Map *AsMap(void *pMap) {return static_cast<Map*>(pMap);}
+  };
+  
+  void *BuildGraphOfNextDocument(Parser& parser, GraphBuilderInterface& graphBuilder);
+  
+  template <class Impl>
+  typename Impl::Node *BuildGraphOfNextDocument(Parser& parser, Impl& impl)
+  {
+    GraphBuilder<Impl> graphBuilder(impl);
+    return static_cast<typename Impl::Node *>(BuildGraphOfNextDocument(
+      parser, graphBuilder
+    ));
+  }
+}
+
+#endif // GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/conversion.h

@@ -0,0 +1,65 @@
+#ifndef CONVERSION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define CONVERSION_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 "yaml-cpp/null.h"
+#include "yaml-cpp/traits.h"
+#include <limits>
+#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);
+	
+	inline bool IsInfinity(const std::string& input) {
+		return input == ".inf" || input == ".Inf" || input == ".INF" || input == "+.inf" || input == "+.Inf" || input == "+.INF";
+	}
+	
+	inline bool IsNegativeInfinity(const std::string& input) {
+		return input == "-.inf" || input == "-.Inf" || input == "-.INF";
+	}
+	
+	inline bool IsNaN(const std::string& input) {
+		return input == ".nan" || input == ".NaN" || input == ".NAN";
+	}
+
+
+	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;
+		if(!!stream)
+			return true;
+		
+		if(std::numeric_limits<T>::has_infinity) {
+			if(IsInfinity(input)) {
+				output = std::numeric_limits<T>::infinity();
+				return true;
+			} else if(IsNegativeInfinity(input)) {
+				output = -std::numeric_limits<T>::infinity();
+				return true;
+			}
+		}
+		
+		if(std::numeric_limits<T>::has_quiet_NaN && IsNaN(input)) {
+			output = std::numeric_limits<T>::quiet_NaN();
+			return true;
+		}
+		
+		return false;
+	}
+}
+
+#endif // CONVERSION_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/dll.h

@@ -0,0 +1,28 @@
+#ifndef DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define DLL_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
+
+// The following ifdef block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the yaml_cpp_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// YAML_CPP_API functions as being imported from a DLL, whereas this DLL sees symbols
+// defined with this macro as being exported.
+#undef YAML_CPP_API
+
+#ifdef YAML_CPP_DLL // Using or Building YAML-CPP DLL (definition defined manually)
+	#ifdef yaml_cpp_EXPORTS // Building YAML-CPP DLL (definition created by CMake or defined manually)
+	//	#pragma message( "Defining YAML_CPP_API for DLL export" )
+		#define YAML_CPP_API __declspec(dllexport)
+	#else // yaml_cpp_EXPORTS
+	//	#pragma message( "Defining YAML_CPP_API for DLL import" )
+		#define YAML_CPP_API __declspec(dllimport)
+	#endif // yaml_cpp_EXPORTS
+#else //YAML_CPP_DLL
+#define YAML_CPP_API
+#endif // YAML_CPP_DLL
+
+#endif // DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/emitfromevents.h

@@ -0,0 +1,45 @@
+#ifndef EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITFROMEVENTS_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 "yaml-cpp/eventhandler.h"
+#include <stack>
+
+namespace YAML
+{
+	class Emitter;
+	
+	class EmitFromEvents: public EventHandler
+	{
+	public:
+		EmitFromEvents(Emitter& emitter);
+		
+		virtual void OnDocumentStart(const Mark& mark);
+		virtual void OnDocumentEnd();
+		
+		virtual void OnNull(const Mark& mark, anchor_t anchor);
+		virtual void OnAlias(const Mark& mark, anchor_t anchor);
+		virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value);
+		
+		virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor);
+		virtual void OnSequenceEnd();
+		
+		virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor);
+		virtual void OnMapEnd();
+		
+	private:
+		void BeginNode();
+		void EmitProps(const std::string& tag, anchor_t anchor);
+		
+	private:
+		Emitter& m_emitter;
+		
+		struct State { enum value { WaitingForSequenceEntry, WaitingForKey, WaitingForValue }; };
+		std::stack<State::value> m_stateStack;
+	};
+}
+
+#endif // EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/emitter.h

@@ -0,0 +1,158 @@
+#ifndef EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTER_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 "yaml-cpp/dll.h"
+#include "yaml-cpp/emittermanip.h"
+#include "yaml-cpp/ostream.h"
+#include "yaml-cpp/noncopyable.h"
+#include "yaml-cpp/null.h"
+#include <memory>
+#include <string>
+#include <sstream>
+
+namespace YAML
+{
+	class EmitterState;
+	
+	class YAML_CPP_API Emitter: private noncopyable
+	{
+	public:
+		Emitter();
+		~Emitter();
+		
+		// output
+		const char *c_str() const;
+		unsigned size() const;
+		
+		// state checking
+		bool good() const;
+		const std::string GetLastError() const;
+		
+		// global setters
+		bool SetOutputCharset(EMITTER_MANIP value);
+		bool SetStringFormat(EMITTER_MANIP value);
+		bool SetBoolFormat(EMITTER_MANIP value);
+		bool SetIntBase(EMITTER_MANIP value);
+		bool SetSeqFormat(EMITTER_MANIP value);
+		bool SetMapFormat(EMITTER_MANIP value);
+		bool SetIndent(unsigned n);
+		bool SetPreCommentIndent(unsigned n);
+		bool SetPostCommentIndent(unsigned n);
+		
+		// local setters
+		Emitter& SetLocalValue(EMITTER_MANIP value);
+		Emitter& SetLocalIndent(const _Indent& indent);
+		
+		// overloads of write
+		Emitter& Write(const std::string& str);
+		Emitter& Write(bool b);
+		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);
+		
+		template <typename T>
+		Emitter& WriteIntegralType(T value);
+		
+		template <typename T>
+		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);
+	
+	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);
+		
+		const char *ComputeFullBoolName(bool b) const;
+		bool CanEmitNewline() const;
+		
+	private:
+		ostream m_stream;
+		std::auto_ptr <EmitterState> m_pState;
+	};
+	
+	template <typename T>
+	inline Emitter& Emitter::WriteIntegralType(T value)
+	{
+		if(!good())
+			return *this;
+		
+		std::stringstream str;
+		PreWriteIntegralType(str);
+		str << value;
+		PostWriteIntegralType(str);
+		return *this;
+	}
+
+	template <typename T>
+	inline Emitter& Emitter::WriteStreamable(T value)
+	{
+		if(!good())
+			return *this;
+		
+		std::stringstream str;
+		PreWriteStreamable(str);
+		str << value;
+		PostWriteStreamable(str);
+		return *this;
+	}
+	
+	// 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, 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 char *v) { return emitter.Write(std::string(v)); }
+
+	inline Emitter& operator << (Emitter& emitter, int v) { return emitter.WriteIntegralType(v); }
+	inline Emitter& operator << (Emitter& emitter, unsigned int v) { return emitter.WriteIntegralType(v); }
+	inline Emitter& operator << (Emitter& emitter, short v) { return emitter.WriteIntegralType(v); }
+	inline Emitter& operator << (Emitter& emitter, unsigned short v) { return emitter.WriteIntegralType(v); }
+	inline Emitter& operator << (Emitter& emitter, long v) { return emitter.WriteIntegralType(v); }
+	inline Emitter& operator << (Emitter& emitter, unsigned long v) { return emitter.WriteIntegralType(v); }
+	inline Emitter& operator << (Emitter& emitter, long long v) { return emitter.WriteIntegralType(v); }
+	inline Emitter& operator << (Emitter& emitter, unsigned long long v) { return emitter.WriteIntegralType(v); }
+
+	inline Emitter& operator << (Emitter& emitter, float v) { return emitter.WriteStreamable(v); }
+	inline Emitter& operator << (Emitter& emitter, double v) { return emitter.WriteStreamable(v); }
+
+	inline Emitter& operator << (Emitter& emitter, EMITTER_MANIP value) {
+		return emitter.SetLocalValue(value);
+	}
+	
+	inline Emitter& operator << (Emitter& emitter, _Indent indent) {
+		return emitter.SetLocalIndent(indent);
+	}
+}
+
+#endif // EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66