Updated the CMake file for 0.2.0 release, and added install.txt

More to the point, the yaml-reader program doesn't do any file IO, so it doesn't require a specific working directory.

.hgeol

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

.hgignore

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

CMakeLists.txt

@@ -1,285 +1,68 @@
-###
-### 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()
 
-include(CheckCXXCompilerFlag)
+project (YAML_CPP)
 
+set(LIB_TYPE SHARED)
 
-###
-### Project settings
-###
-project(YAML_CPP)
+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")
+endif(CMAKE_COMPILER_IS_GNUCC)
 
 set(YAML_CPP_VERSION_MAJOR "0")
-set(YAML_CPP_VERSION_MINOR "5")
+set(YAML_CPP_VERSION_MINOR "2")
 set(YAML_CPP_VERSION_PATCH "0")
 set(YAML_CPP_VERSION "${YAML_CPP_VERSION_MAJOR}.${YAML_CPP_VERSION_MINOR}.${YAML_CPP_VERSION_PATCH}")
 
 enable_testing()
 
-
-###
-### 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
-###
-set(header_directory "include/yaml-cpp/")
-
-file(GLOB sources "src/[a-zA-Z]*.cpp")
-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")
-	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}/src)
-include_directories(${YAML_CPP_SOURCE_DIR}/include)
-
-find_package(Boost REQUIRED)
-include_directories(${Boost_INCLUDE_DIRS})
-
-
-###
-### 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)
-	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(_library_dir bin) # .dll are in PATH, like executables
+else(WIN32)
+  set(_library_dir lib)
+endif(WIN32)
 
-# 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(INCLUDE_INSTALL_DIR include/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/*.h)
+file(GLOB private_headers src/*.h)
+file(GLOB sources src/*.cpp)
 
-
-###
-### Library
-###
+include_directories(${YAML_CPP_SOURCE_DIR}/include)
 add_library(yaml-cpp
-	${sources}
+	${LIB_TYPE}
 	${public_headers}
 	${private_headers}
-	${contrib_sources}
-	${contrib_public_headers}
-	${contrib_private_headers}
+	${sources}
 )
-
 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(
-	DIRECTORY ${header_directory}
+	FILES ${public_headers}
 	DESTINATION ${INCLUDE_INSTALL_DIR}
-	FILES_MATCHING PATTERN "*.h"
 )
 
 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()
+endif(UNIX)
 
-
-###
-### Extras
-###
-if(YAML_CPP_BUILD_TOOLS)
-	add_subdirectory(test)
-	add_subdirectory(util)
-endif()
+add_subdirectory (yaml-reader)
+add_subdirectory (util)

include/conversion.h

@@ -0,0 +1,45 @@
+#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
+{
+	template <typename T>
+	struct Converter {
+		static bool Convert(const std::string& input, T& output);
+	};
+
+	template <typename T>
+	bool Convert(const std::string& input, T& output) {
+		return Converter<T>::Convert(input, output);
+	}
+	
+	// this is the one to specialize
+	template <typename T>
+	inline bool Converter<T>::Convert(const std::string& input, T& output) {
+		std::stringstream stream(input);
+		stream >> output;
+		return !stream.fail();
+	}
+
+	// specializations
+	template <>
+	inline bool Converter<std::string>::Convert(const std::string& input, std::string& output) {
+		output = input;
+		return true;
+	}
+
+	template <>
+	bool Converter<bool>::Convert(const std::string& input, bool& output);
+	
+	template <>
+	bool Converter<_Null>::Convert(const std::string& input, _Null& output);
+}
+
+#endif // CONVERSION_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/crt.h

@@ -0,0 +1,17 @@
+#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

@@ -0,0 +1,94 @@
+#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 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/emittermanip.h

@@ -1,10 +1,8 @@
+#pragma once
+
 #ifndef EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITTERMANIP_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>
 
@@ -13,12 +11,6 @@ namespace YAML
 	enum EMITTER_MANIP {
 		// general manipulators
 		Auto,
-		TagByKind,
-		Newline,
-
-		// output character set
-		EmitNonAscii,
-		EscapeNonAscii,
 		
 		// string manipulators
 		// Auto, // duplicate
@@ -41,10 +33,6 @@ namespace YAML
 		Hex,
 		Oct,
 		
-		// document manipulators
-		BeginDoc,
-		EndDoc,
-		
 		// sequence manipulators
 		BeginSeq,
 		EndSeq,
@@ -88,34 +76,6 @@ namespace YAML
 	inline _Anchor Anchor(const std::string content) {
 		return _Anchor(content);
 	}
-	
-	struct _Tag {
-		struct Type { enum value { Verbatim, PrimaryHandle, NamedHandle }; };
-		
-		explicit _Tag(const std::string& prefix_, const std::string& content_, Type::value type_)
-		: prefix(prefix_), content(content_), type(type_)
-		{
-		}
-		std::string prefix;
-		std::string content;
-		Type::value type;
-	};
-	
-	inline _Tag VerbatimTag(const std::string content) {
-		return _Tag("", content, _Tag::Type::Verbatim);
-	}
-
-	inline _Tag LocalTag(const std::string content) {
-		return _Tag("", content, _Tag::Type::PrimaryHandle);
-	}
-
-	inline _Tag LocalTag(const std::string& prefix, const std::string content) {
-		return _Tag(prefix, content, _Tag::Type::NamedHandle);
-	}
-
-	inline _Tag SecondaryTag(const std::string content) {
-		return _Tag("", content, _Tag::Type::NamedHandle);
-	}
 
 	struct _Comment {
 		_Comment(const std::string& content_): content(content_) {}
@@ -125,25 +85,6 @@ namespace YAML
 	inline _Comment Comment(const std::string content) {
 		return _Comment(content);
 	}
-    
-    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/exceptions.h

@@ -0,0 +1,137 @@
+#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/iterator.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#ifndef ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+
+namespace YAML
+{
+	class Node;
+	struct IterPriv;
+
+	class Iterator
+	{
+	public:
+		Iterator();
+		Iterator(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 bool operator == (const Iterator& it, const Iterator& jt);
+		friend bool operator != (const Iterator& it, const Iterator& jt);
+
+	private:
+		IterPriv *m_pData;
+	};
+}
+
+#endif // ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/mark.h

@@ -1,16 +1,12 @@
+#pragma once
+
 #ifndef MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define MARK_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"
 
 namespace YAML
 {
-	struct YAML_CPP_API Mark {
+	struct Mark {
 		Mark(): pos(0), line(0), column(0) {}
 		
 		static const Mark null() { return Mark(-1, -1, -1); }

include/node.h

@@ -0,0 +1,116 @@
+#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>
+		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;
+	};
+}
+
+#include "nodeimpl.h"
+
+#endif // NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/nodeimpl.h

@@ -0,0 +1,85 @@
+#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 bool Node::Read(T& value) const {
+		std::string scalar;
+		if(!GetScalar(scalar))
+			return false;
+		
+		return Convert(scalar, value);
+	}
+	
+	template <typename T>
+	inline const T Node::Read() const {
+		T value;
+		*this >> value;
+		return value;
+	}
+	
+	template <typename T>
+	inline void operator >> (const Node& node, T& value) {
+		if(!node.Read(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));
+	}
+}
+
+#endif // NODEIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/nodeutil.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#ifndef NODEUTIL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODEUTIL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+
+namespace YAML
+{
+	template <typename T, typename U>
+	struct is_same_type {
+		enum { value = false };
+	};
+	
+	template <typename T>
+	struct is_same_type<T, T> {
+		enum { value = true };
+	};
+	
+	template <typename T, bool check>
+	struct is_index_type_with_check {
+		enum { value = false };
+	};
+	
+	template <> struct is_index_type_with_check<std::size_t, false> { enum { value = true }; };
+
+#define MAKE_INDEX_TYPE(Type) \
+	template <> struct is_index_type_with_check<Type, is_same_type<Type, std::size_t>::value> { enum { value = true }; }
+	
+	MAKE_INDEX_TYPE(int);
+	MAKE_INDEX_TYPE(unsigned);
+	MAKE_INDEX_TYPE(short);
+	MAKE_INDEX_TYPE(unsigned short);
+	MAKE_INDEX_TYPE(long);
+	MAKE_INDEX_TYPE(unsigned long);
+
+#undef MAKE_INDEX_TYPE
+	
+	template <typename T>
+	struct is_index_type: public is_index_type_with_check<T, false> {};
+	
+	// messing around with template stuff to get the right overload for operator [] for a sequence
+	template <typename T, bool b>
+	struct _FindFromNodeAtIndex {
+		const Node *pRet;
+		_FindFromNodeAtIndex(const Node&, const T&): pRet(0) {}
+	};
+
+	template <typename T>
+	struct _FindFromNodeAtIndex<T, true> {
+		const Node *pRet;
+		_FindFromNodeAtIndex(const Node& node, const T& key): pRet(node.FindAtIndex(static_cast<std::size_t>(key))) {}
+	};
+
+	template <typename T>
+	inline const Node *FindFromNodeAtIndex(const Node& node, const T& key) {
+		return _FindFromNodeAtIndex<T, is_index_type<T>::value>(node, key).pRet;
+	}
+}
+
+#endif // NODEUTIL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/noncopyable.h

@@ -0,0 +1,22 @@
+#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/null.h

@@ -1,24 +1,20 @@
+#pragma once
+
 #ifndef NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define NULL_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"
 
 namespace YAML
 {
 	class Node;
 	
-	struct YAML_CPP_API _Null {};
+	struct _Null {};
 	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); // old API only
+	bool IsNull(const Node& node);
 	
-	extern YAML_CPP_API _Null Null;
+	extern _Null Null;
 }
 
 #endif // NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/ostream.h

@@ -1,10 +1,8 @@
+#pragma once
+
 #ifndef OSTREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define OSTREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
-#pragma once
-#endif
-
 
 #include <string>
 

include/parser.h

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

include/parserstate.h

@@ -0,0 +1,26 @@
+#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

@@ -0,0 +1,44 @@
+#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/anchor.h

@@ -1,16 +0,0 @@
-#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/binary.h

@@ -1,62 +0,0 @@
-#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,42 +0,0 @@
-#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

@@ -1,133 +0,0 @@
-#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/dll.h

@@ -1,28 +0,0 @@
-#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

@@ -1,45 +0,0 @@
-#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

@@ -1,186 +0,0 @@
-#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/binary.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);
-        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);
-		
-		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);
-        
-        template<typename T> void SetStreamablePrecision(std::stringstream&) {}
-        unsigned GetFloatPrecision() const;
-        unsigned GetDoublePrecision() const;
-	
-	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);
-        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 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);
-	}
-    
-    inline Emitter& operator << (Emitter& emitter, _Precision precision) {
-        return emitter.SetLocalPrecision(precision);
-    }
-}
-
-#endif // EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/eventhandler.h

@@ -1,36 +0,0 @@
-#ifndef EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define EVENTHANDLER_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 <string>
-
-namespace YAML
-{
-	struct Mark;
-	
-	class EventHandler
-	{
-	public:
-		virtual ~EventHandler() {}
-
-		virtual void OnDocumentStart(const Mark& mark) = 0;
-		virtual void OnDocumentEnd() = 0;
-		
-		virtual void OnNull(const Mark& mark, anchor_t anchor) = 0;
-		virtual void OnAlias(const Mark& mark, anchor_t anchor) = 0;
-		virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value) = 0;
-
-		virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor) = 0;
-		virtual void OnSequenceEnd() = 0;
-
-		virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor) = 0;
-		virtual void OnMapEnd() = 0;
-	};
-}
-
-#endif // EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

include/yaml-cpp/exceptions.h

@@ -1,192 +0,0 @@
-#ifndef EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define EXCEPTIONS_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 "yaml-cpp/traits.h"
-#include <stdexcept>
-#include <string>
-#include <sstream>
-
-namespace YAML
-{
-	// error messages
-	namespace ErrorMsg
-	{
-		const char * const YAML_DIRECTIVE_ARGS    = "YAML directives must have exactly one argument";
-		const char * const YAML_VERSION           = "bad YAML version: ";
-		const char * const YAML_MAJOR_VERSION     = "YAML major version too large";
-		const char * const REPEATED_YAML_DIRECTIVE= "repeated YAML directive";
-		const char * const TAG_DIRECTIVE_ARGS     = "TAG directives must have exactly two arguments";
-		const char * const REPEATED_TAG_DIRECTIVE = "repeated TAG directive";
-		const char * const CHAR_IN_TAG_HANDLE     = "illegal character found while scanning tag handle";
-		const char * const TAG_WITH_NO_SUFFIX     = "tag handle with no suffix";
-		const char * const END_OF_VERBATIM_TAG    = "end of verbatim tag not found";
-		const char * const END_OF_MAP             = "end of map not found";
-		const char * const END_OF_MAP_FLOW        = "end of map flow not found";
-		const char * const END_OF_SEQ             = "end of sequence not found";
-		const char * const END_OF_SEQ_FLOW        = "end of sequence flow not found";
-		const char * const MULTIPLE_TAGS          = "cannot assign multiple tags to the same node";
-		const char * const MULTIPLE_ANCHORS       = "cannot assign multiple anchors to the same node";
-		const char * const MULTIPLE_ALIASES       = "cannot assign multiple aliases to the same node";
-		const char * const ALIAS_CONTENT          = "aliases can't have any content, *including* tags";
-		const char * const INVALID_HEX            = "bad character found while scanning hex number";
-		const char * const INVALID_UNICODE        = "invalid unicode: ";
-		const char * const INVALID_ESCAPE         = "unknown escape character: ";
-		const char * const UNKNOWN_TOKEN          = "unknown token";
-		const char * const DOC_IN_SCALAR          = "illegal document indicator in scalar";
-		const char * const EOF_IN_SCALAR          = "illegal EOF in scalar";
-		const char * const CHAR_IN_SCALAR         = "illegal character in scalar";
-		const char * const TAB_IN_INDENTATION     = "illegal tab when looking for indentation";
-		const char * const FLOW_END               = "illegal flow end";
-		const char * const BLOCK_ENTRY            = "illegal block entry";
-		const char * const MAP_KEY                = "illegal map key";
-		const char * const MAP_VALUE              = "illegal map value";
-		const char * const ALIAS_NOT_FOUND        = "alias not found after *";
-		const char * const ANCHOR_NOT_FOUND       = "anchor not found after &";
-		const char * const CHAR_IN_ALIAS          = "illegal character found while scanning alias";
-		const char * const CHAR_IN_ANCHOR         = "illegal character found while scanning anchor";
-		const char * const ZERO_INDENT_IN_BLOCK   = "cannot set zero indentation for a block scalar";
-		const char * const CHAR_IN_BLOCK          = "unexpected character in block scalar";
-		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_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 UNMATCHED_GROUP_TAG    = "unmatched group tag";
-		const char * const UNEXPECTED_END_SEQ     = "unexpected end sequence token";
-		const char * const UNEXPECTED_END_MAP     = "unexpected end map token";
-		const char * const SINGLE_QUOTED_CHAR     = "invalid character in single-quoted string";
-		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";
-
-		template <typename T>
-		inline const std::string KEY_NOT_FOUND_WITH_KEY(const T&, typename disable_if<is_numeric<T> >::type * = 0) {
-			return KEY_NOT_FOUND;
-		}
-
-		inline const std::string KEY_NOT_FOUND_WITH_KEY(const std::string& key) {
-			std::stringstream stream;
-			stream << KEY_NOT_FOUND << ": " << key;
-			return stream.str();
-		}
-		
-		template <typename T>
-		inline const std::string KEY_NOT_FOUND_WITH_KEY(const T& key, typename enable_if<is_numeric<T> >::type * = 0) {
-			std::stringstream stream;
-			stream << KEY_NOT_FOUND << ": " << key;
-			return stream.str();
-		}
-	}
-
-	class Exception: public std::runtime_error {
-	public:
-		Exception(const Mark& mark_, const std::string& msg_)
-		: std::runtime_error(build_what(mark_, msg_)), mark(mark_), msg(msg_) {}
-		virtual ~Exception() throw() {}
-
-		Mark mark;
-		std::string msg;
-
-	private:
-		static const std::string build_what(const Mark& mark, const std::string& msg) {
-			std::stringstream output;
-			output << "yaml-cpp: error at line " << mark.line+1 << ", column " << mark.column+1 << ": " << msg;
-			return output.str();
-		}
-	};
-
-	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:
-		template <typename T>
-		KeyNotFound(const Mark& mark_, const T& key_)
-			: RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) {}
-	};
-	
-	template <typename T>
-	class TypedKeyNotFound: public KeyNotFound {
-	public:
-		TypedKeyNotFound(const Mark& mark_, const T& key_)
-			: KeyNotFound(mark_, key_), key(key_) {}
-		virtual ~TypedKeyNotFound() throw() {}
-
-		T key;
-	};
-
-	template <typename T>
-	inline TypedKeyNotFound <T> MakeTypedKeyNotFound(const Mark& mark, const T& key) {
-		return TypedKeyNotFound <T> (mark, key);
-	}
-
-	class BadConversion: public RepresentationException {
-	public:
-		BadConversion()
-        : RepresentationException(Mark::null(), 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) {}
-	};
-
-	class BadSubscript: public RepresentationException {
-	public:
-		BadSubscript()
-		: RepresentationException(Mark::null(), ErrorMsg::BAD_SUBSCRIPT) {}
-	};
-
-	class BadPushback: public RepresentationException {
-	public:
-		BadPushback()
-		: RepresentationException(Mark::null(), ErrorMsg::BAD_PUSHBACK) {}
-	};
-	
-	class EmitterException: public Exception {
-	public:
-		EmitterException(const std::string& msg_)
-		: Exception(Mark::null(), msg_) {}
-	};
-}
-
-#endif // EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/node/convert.h

@@ -1,209 +0,0 @@
-#ifndef NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NODE_CONVERT_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/binary.h"
-#include "yaml-cpp/node/node.h"
-#include "yaml-cpp/node/iterator.h"
-#include "yaml-cpp/null.h"
-#include <limits>
-#include <list>
-#include <map>
-#include <sstream>
-#include <vector>
-
-namespace YAML
-{
-    namespace conversion {
-        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";
-        }
-    }
-    
-	// std::string
-	template<>
-	struct convert<std::string> {
-		static Node encode(const std::string& rhs) {
-			return Node(rhs);
-		}
-		
-		static bool decode(const Node& node, std::string& rhs) {
-			if(!node.IsScalar())
-				return false;
-			rhs = node.Scalar();
-			return true;
-		}
-	};
-	
-	template<>
-	struct convert<_Null> {
-		static Node encode(const _Null& /* rhs */) {
-			return Node();
-		}
-		
-		static bool decode(const Node& node, _Null& /* rhs */) {
-			return node.IsNull();
-		}
-	};
-	
-#define YAML_DEFINE_CONVERT_STREAMABLE(type)\
-	template<>\
-	struct convert<type> {\
-		static Node encode(const type& rhs) {\
-			std::stringstream stream;\
-			stream << rhs;\
-			return Node(stream.str());\
-		}\
-		\
-		static bool decode(const Node& node, type& rhs) {\
-			if(node.Type() != NodeType::Scalar)\
-				return false;\
-            const std::string& input = node.Scalar();\
-			std::stringstream stream(input);\
-            stream.unsetf(std::ios::dec);\
-			if((stream >> rhs) && (stream >> std::ws).eof())\
-                return true;\
-            if(std::numeric_limits<type>::has_infinity) {\
-                if(conversion::IsInfinity(input)) {\
-                    rhs = std::numeric_limits<type>::infinity();\
-                    return true;\
-                } else if(conversion::IsNegativeInfinity(input)) {\
-                    rhs = -std::numeric_limits<type>::infinity();\
-                    return true;\
-                }\
-            }\
-            \
-            if(std::numeric_limits<type>::has_quiet_NaN && conversion::IsNaN(input)) {\
-                rhs = std::numeric_limits<type>::quiet_NaN();\
-                return true;\
-            }\
-            \
-            return false;\
-		}\
-	}
-	
-	YAML_DEFINE_CONVERT_STREAMABLE(int);
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned);
-	YAML_DEFINE_CONVERT_STREAMABLE(short);
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned short);
-	YAML_DEFINE_CONVERT_STREAMABLE(long);
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned long);
-	YAML_DEFINE_CONVERT_STREAMABLE(long long);
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned long long);
-	
-	YAML_DEFINE_CONVERT_STREAMABLE(char);
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned char);
-	
-	YAML_DEFINE_CONVERT_STREAMABLE(float);
-	YAML_DEFINE_CONVERT_STREAMABLE(double);
-	YAML_DEFINE_CONVERT_STREAMABLE(long double);
-	
-#undef YAML_DEFINE_CONVERT_STREAMABLE
-	
-	// bool
-	template<>
-	struct convert<bool> {
-		static Node encode(bool rhs) {
-			return rhs ? Node("true") : Node("false");
-		}
-		
-		static bool decode(const Node& node, bool& rhs);
-	};
-
-	// std::map
-	template<typename K, typename V>
-	struct convert<std::map<K, V> > {
-		static Node encode(const std::map<K, V>& rhs) {
-			Node node(NodeType::Map);
-			for(typename std::map<K, V>::const_iterator it=rhs.begin();it!=rhs.end();++it)
-				node[it->first] = it->second;
-			return node;
-		}
-		
-		static bool decode(const Node& node, std::map<K, V>& rhs) {
-			if(!node.IsMap())
-				return false;
-
-			rhs.clear();
-			for(const_iterator it=node.begin();it!=node.end();++it)
-				rhs[it->first.as<K>()] = it->second.as<V>();
-			return true;
-		}
-	};
-	
-	// std::vector
-	template<typename T>
-	struct convert<std::vector<T> > {
-		static Node encode(const std::vector<T>& rhs) {
-			Node node(NodeType::Sequence);
-			for(typename std::vector<T>::const_iterator it=rhs.begin();it!=rhs.end();++it)
-				node.push_back(*it);
-			return node;
-		}
-		
-		static bool decode(const Node& node, std::vector<T>& rhs) {
-			if(!node.IsSequence())
-				return false;
-			
-			rhs.clear();
-			for(const_iterator it=node.begin();it!=node.end();++it)
-				rhs.push_back(it->as<T>());
-			return true;
-		}
-	};
-	
-	// std::list
-	template<typename T>
-	struct convert<std::list<T> > {
-		static Node encode(const std::list<T>& rhs) {
-			Node node(NodeType::Sequence);
-			for(typename std::list<T>::const_iterator it=rhs.begin();it!=rhs.end();++it)
-				node.push_back(*it);
-			return node;
-		}
-		
-		static bool decode(const Node& node, std::list<T>& rhs) {
-			if(!node.IsSequence())
-				return false;
-			
-			rhs.clear();
-			for(const_iterator it=node.begin();it!=node.end();++it)
-				rhs.push_back(it->as<T>());
-			return true;
-		}
-	};
-    
-    // binary
-    template<>
-	struct convert<Binary> {
-		static Node encode(const Binary& rhs) {
-            return Node(EncodeBase64(rhs.data(), rhs.size()));
-		}
-		
-		static bool decode(const Node& node, Binary& rhs) {
-			if(!node.IsScalar())
-				return false;
-            
-            std::vector<unsigned char> data = DecodeBase64(node.Scalar());
-            if(data.empty() && !node.Scalar().empty())
-                return false;
-            
-            rhs.swap(data);
-            return true;
-		}
-	};
-}
-
-#endif // NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66

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

@@ -1,26 +0,0 @@
-#ifndef NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NODE_DETAIL_BOOL_TYPE_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
-{
-	namespace detail
-	{
-		struct unspecified_bool {
-			struct NOT_ALLOWED;
-			static void true_value(NOT_ALLOWED*) {}
-		};
-		typedef void (*unspecified_bool_type)(unspecified_bool::NOT_ALLOWED*);
-	}
-}
-
-#define YAML_CPP_OPERATOR_BOOL()\
-operator YAML::detail::unspecified_bool_type() const\
-{\
-	return this->operator!() ? 0 : &YAML::detail::unspecified_bool::true_value;\
-}
-
-#endif // NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

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

@@ -1,142 +0,0 @@
-#ifndef NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NODE_DETAIL_IMPL_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/node/detail/node.h"
-#include "yaml-cpp/node/detail/node_data.h"
-#include <boost/type_traits.hpp>
-
-namespace YAML
-{
-	namespace detail
-	{
-		template<typename Key, typename Enable = void>
-		struct get_idx {
-			static node *get(const std::vector<node *>& /* sequence */, const Key& /* key */, shared_memory_holder /* pMemory */) {
-				return 0;
-			}
-		};
-
-		template<typename Key>
-		struct get_idx<Key, typename boost::enable_if<boost::is_unsigned<Key> >::type> {
-			static node *get(const std::vector<node *>& sequence, const Key& key, shared_memory_holder /* pMemory */) {
-				return key < sequence.size() ? sequence[key] : 0;
-			}
-
-			static node *get(std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) {
-				if(key > sequence.size())
-					return 0;
-				if(key == sequence.size())
-					sequence.push_back(&pMemory->create_node());
-				return sequence[key];
-			}
-		};
-		
-		template<typename Key>
-		struct get_idx<Key, typename boost::enable_if<boost::is_signed<Key> >::type> {
-			static node *get(const std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) {
-				return key >= 0 ? get_idx<std::size_t>::get(sequence, static_cast<std::size_t>(key), pMemory) : 0;
-			}
-			static node *get(std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) {
-				return key >= 0 ? get_idx<std::size_t>::get(sequence, static_cast<std::size_t>(key), pMemory) : 0;
-			}
-		};
-
-		// indexing
-		template<typename Key>
-		inline node& node_data::get(const Key& key, shared_memory_holder pMemory) const
-		{
-			switch(m_type) {
-				case NodeType::Map:
-					break;
-				case NodeType::Undefined:
-				case NodeType::Null:
-					return pMemory->create_node();
-				case NodeType::Sequence:
-					if(node *pNode = get_idx<Key>::get(m_sequence, key, pMemory))
-						return *pNode;
-					return pMemory->create_node();
-				case NodeType::Scalar:
-                    throw BadSubscript();
-			}
-
-			for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) {
-				if(equals(*it->first, key, pMemory))
-					return *it->second;
-			}
-			
-			return pMemory->create_node();
-		}
-		
-		template<typename Key>
-		inline node& node_data::get(const Key& key, shared_memory_holder pMemory)
-		{
-			switch(m_type) {
-				case NodeType::Map:
-					break;
-				case NodeType::Undefined:
-				case NodeType::Null:
-				case NodeType::Sequence:
-					if(node *pNode = get_idx<Key>::get(m_sequence, key, pMemory)) {
-						m_type = NodeType::Sequence;
-						return *pNode;
-					}
-					
-					convert_to_map(pMemory);
-					break;
-				case NodeType::Scalar:
-                    throw BadSubscript();
-			}
-			
-			for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) {
-				if(equals(*it->first, key, pMemory))
-					return *it->second;
-			}
-			
-			node& k = convert_to_node(key, pMemory);
-			node& v = pMemory->create_node();
-			insert_map_pair(k, v);
-			return v;
-		}
-		
-		template<typename Key>
-		inline bool node_data::remove(const Key& key, shared_memory_holder pMemory)
-		{
-			if(m_type != NodeType::Map)
-				return false;
-			
-			for(node_map::iterator it=m_map.begin();it!=m_map.end();++it) {
-				if(equals(*it->first, key, pMemory)) {
-					m_map.erase(it);
-					return true;
-				}
-			}
-			
-			return false;
-		}
-
-		template<typename T>
-		inline bool node_data::equals(node& node, const T& rhs, shared_memory_holder pMemory)
-		{
-			T lhs;
-			if(convert<T>::decode(Node(node, pMemory), lhs))
-				return lhs == rhs;
-			return false;
-		}
-		
-		template<typename T>
-		inline node& node_data::convert_to_node(const T& rhs, shared_memory_holder pMemory)
-		{
-			Node value = convert<T>::encode(rhs);
-			value.EnsureNodeExists();
-			pMemory->merge(*value.m_pMemory);
-			return *value.m_pNode;
-		}
-	}
-}
-
-#endif // NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

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

@@ -1,64 +0,0 @@
-#ifndef VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define VALUE_DETAIL_ITERATOR_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/node/ptr.h"
-#include "yaml-cpp/node/detail/node_iterator.h"
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/utility.hpp>
-
-namespace YAML
-{
-	namespace detail
-	{
-		struct iterator_value;
-
-		template<typename V>
-		class iterator_base: public boost::iterator_adaptor<
-		iterator_base<V>,
-		node_iterator,
-		V,
-		std::forward_iterator_tag,
-		V>
-		{
-		private:
-			template<typename> friend class iterator_base;
-			struct enabler {};
-			typedef typename iterator_base::base_type base_type;
-            
-        public:
-			typedef typename iterator_base::value_type value_type;
-			
-		public:
-			iterator_base() {}
-			explicit iterator_base(base_type rhs, shared_memory_holder pMemory): iterator_base::iterator_adaptor_(rhs), m_pMemory(pMemory) {}
-			
-			template<class W>
-			iterator_base(const iterator_base<W>& rhs, typename boost::enable_if<boost::is_convertible<W*, V*>, enabler>::type = enabler()): iterator_base::iterator_adaptor_(rhs.base()), m_pMemory(rhs.m_pMemory) {}
-		
-		private:
-			friend class boost::iterator_core_access;
-
-			void increment() { this->base_reference() = boost::next(this->base()); }
-			
-			value_type dereference() const {
-				const typename base_type::value_type& v = *this->base();
-				if(v.pNode)
-					return value_type(Node(*v, m_pMemory));
-				if(v.first && v.second)
-					return value_type(Node(*v.first, m_pMemory), Node(*v.second, m_pMemory));
-				return value_type();
-			}
-		
-		private:
-			shared_memory_holder m_pMemory;
-		};
-	}
-}
-
-#endif // VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

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

@@ -1,27 +0,0 @@
-#ifndef VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define VALUE_DETAIL_ITERATOR_FWD_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 <list>
-#include <utility>
-#include <vector>
-
-namespace YAML
-{
-	class node;
-	
-	namespace detail {
-		struct iterator_value;
-		template<typename V> class iterator_base;
-	}
-
-	typedef detail::iterator_base<detail::iterator_value> iterator;
-	typedef detail::iterator_base<const detail::iterator_value> const_iterator;
-}
-
-#endif // VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66

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

@@ -1,39 +0,0 @@
-#ifndef VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define VALUE_DETAIL_MEMORY_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/node/ptr.h"
-#include <set>
-#include <boost/shared_ptr.hpp>
-
-namespace YAML
-{
-	namespace detail
-	{
-		class memory {
-		public:
-			node& create_node();
-			void merge(const memory& rhs);
-			
-		private:
-			typedef std::set<shared_node> Nodes;
-			Nodes m_nodes;
-		};
-
-		class memory_holder {
-		public:
-			memory_holder(): m_pMemory(new memory) {}
-			
-			node& create_node() { return m_pMemory->create_node(); }
-			void merge(memory_holder& rhs);
-			
-		private:
-			boost::shared_ptr<memory> m_pMemory;
-		};
-	}
-}
-
-#endif // VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66

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

@@ -1,126 +0,0 @@
-#ifndef NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NODE_DETAIL_NODE_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/node/type.h"
-#include "yaml-cpp/node/ptr.h"
-#include "yaml-cpp/node/detail/node_ref.h"
-#include <set>
-#include <boost/utility.hpp>
-
-namespace YAML
-{
-	namespace detail
-	{
-		class node: private boost::noncopyable
-		{
-		public:
-			node(): m_pRef(new node_ref) {}
-
-			bool is(const node& rhs) const { return m_pRef == rhs.m_pRef; }
-			const node_ref *ref() const { return m_pRef.get(); }
-			
-			bool is_defined() const { return m_pRef->is_defined(); }
-			NodeType::value type() const { return m_pRef->type(); }
-			
-			const std::string& scalar() const { return m_pRef->scalar(); }
-			const std::string& tag() const { return m_pRef->tag(); }
-			
-			void mark_defined() {
-				if(is_defined())
-					return;
-				
-				m_pRef->mark_defined();
-				for(nodes::iterator it=m_dependencies.begin();it!=m_dependencies.end();++it)
-					(*it)->mark_defined();
-				m_dependencies.clear();
-			}
-			
-			void add_dependency(node& rhs) {
-				if(is_defined())
-					rhs.mark_defined();
-				else
-					m_dependencies.insert(&rhs);
-			}
-			
-			void set_ref(const node& rhs) {
-				if(rhs.is_defined())
-					mark_defined();
-				m_pRef = rhs.m_pRef;
-			}
-			void set_data(const node& rhs) {
-				if(rhs.is_defined())
-					mark_defined();
-				m_pRef->set_data(*rhs.m_pRef);
-			}
-				
-			void set_type(NodeType::value type) {
-				if(type != NodeType::Undefined)
-					mark_defined();
-				m_pRef->set_type(type);
-			}
-			void set_null() {
-				mark_defined();
-				m_pRef->set_null();
-			}
-			void set_scalar(const std::string& scalar) {
-				mark_defined();
-				m_pRef->set_scalar(scalar);
-			}
-			void set_tag(const std::string& tag) {
-				mark_defined();
-				m_pRef->set_tag(tag);
-			}
-
-			// size/iterator
-			std::size_t size() const { return m_pRef->size(); }
-			
-			const_node_iterator begin() const { return static_cast<const node_ref&>(*m_pRef).begin(); }
-			node_iterator begin() { return m_pRef->begin(); }
-			
-			const_node_iterator end() const { return static_cast<const node_ref&>(*m_pRef).end(); }
-			node_iterator end() { return m_pRef->end(); }
-
-			// sequence
-			void push_back(node& node, shared_memory_holder pMemory) {
-				m_pRef->push_back(node, pMemory);
-				node.add_dependency(*this);
-			}
-			void insert(node& key, node& value, shared_memory_holder pMemory) {
-				m_pRef->insert(key, value, pMemory);
-				key.add_dependency(*this);
-				value.add_dependency(*this);
-			}
-
-			// indexing
-			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) const { return static_cast<const node_ref&>(*m_pRef).get(key, pMemory); }
-			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) {
-				node& value = m_pRef->get(key, pMemory);
-				value.add_dependency(*this);
-				return value;
-			}
-			template<typename Key> bool remove(const Key& key, shared_memory_holder pMemory) { return m_pRef->remove(key, pMemory); }
-			
-			node& get(node& key, shared_memory_holder pMemory) const { return static_cast<const node_ref&>(*m_pRef).get(key, pMemory); }
-			node& get(node& key, shared_memory_holder pMemory) {
-				node& value = m_pRef->get(key, pMemory);
-				key.add_dependency(*this);
-				value.add_dependency(*this);
-				return value;
-			}
-			bool remove(node& key, shared_memory_holder pMemory) { return m_pRef->remove(key, pMemory); }
-
-		private:
-			shared_node_ref m_pRef;
-			typedef std::set<node *> nodes;
-			nodes m_dependencies;
-		};
-	}
-}
-
-#endif // NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

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

@@ -1,105 +0,0 @@
-#ifndef VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define VALUE_DETAIL_NODE_DATA_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/node/iterator.h"
-#include "yaml-cpp/node/ptr.h"
-#include "yaml-cpp/node/type.h"
-#include <boost/utility.hpp>
-#include <list>
-#include <utility>
-#include <vector>
-
-namespace YAML
-{
-	namespace detail
-	{
-		class node_data: private boost::noncopyable
-		{
-		public:
-			node_data();
-			
-			void mark_defined();
-			void set_type(NodeType::value type);
-			void set_tag(const std::string& tag);
-			void set_null();
-			void set_scalar(const std::string& scalar);
-			
-			bool is_defined() const { return m_isDefined; }
-			NodeType::value type() const { return m_isDefined ? m_type : NodeType::Undefined; }
-			const std::string& scalar() const { return m_scalar; }
-			const std::string& tag() const { return m_tag; }
-			
-			// size/iterator
-			std::size_t size() const;
-			
-			const_node_iterator begin() const;
-			node_iterator begin();
-			
-			const_node_iterator end() const;
-			node_iterator end();
-
-			// sequence
-			void push_back(node& node, shared_memory_holder pMemory);
-			void insert(node& key, node& value, shared_memory_holder pMemory);
-
-			// indexing
-			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) const;
-			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory);
-			template<typename Key> bool remove(const Key& key, shared_memory_holder pMemory);
-			
-			node& get(node& key, shared_memory_holder pMemory) const;
-			node& get(node& key, shared_memory_holder pMemory);
-			bool remove(node& key, shared_memory_holder pMemory);
-			
-		public:
-			static std::string empty_scalar;
-			
-		private:
-			void compute_seq_size() const;
-			void compute_map_size() const;
-
-			void reset_sequence();
-			void reset_map();
-			
-			void insert_map_pair(node& key, node& value);
-			void convert_to_map(shared_memory_holder pMemory);
-			void convert_sequence_to_map(shared_memory_holder pMemory);
-			
-			template<typename T>
-			static bool equals(node& node, const T& rhs, shared_memory_holder pMemory);
-			
-			template<typename T>
-			static node& convert_to_node(const T& rhs, shared_memory_holder pMemory);
-
-		private:
-			bool m_isDefined;
-			NodeType::value m_type;
-			std::string m_tag;
-			
-			// scalar
-			std::string m_scalar;
-			
-			// sequence
-			typedef std::vector<node *> node_seq;
-			node_seq m_sequence;
-			
-			mutable std::size_t m_seqSize;
-			
-			// map
-			typedef std::map<node *, node *> node_map;
-			node_map m_map;
-			
-			typedef std::pair<node *, node *> kv_pair;
-			typedef std::list<kv_pair> kv_pairs;
-			mutable kv_pairs m_undefinedPairs;
-		};
-	}
-}
-
-#endif // VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66

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

@@ -1,139 +0,0 @@
-#ifndef VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define VALUE_DETAIL_NODE_ITERATOR_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/node/ptr.h"
-#include <boost/iterator/iterator_facade.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <map>
-#include <utility>
-#include <vector>
-
-namespace YAML
-{
-	namespace detail
-	{
-		struct iterator_type { enum value { None, Sequence, Map }; };
-		
-		template<typename V>
-		struct node_iterator_value: public std::pair<V*, V*> {
-			typedef std::pair<V*, V*> kv;
-			
-			node_iterator_value(): kv(), pNode(0) {}
-			explicit node_iterator_value(V& rhs): kv(), pNode(&rhs) {}
-			explicit node_iterator_value(V& key, V& value): kv(&key, &value), pNode(0) {}
-			
-			V& operator *() const { return *pNode; }
-			V& operator ->() const { return *pNode; }
-			
-			V *pNode;
-		};
-		
-		typedef std::vector<node *> node_seq;
-		typedef std::map<node *, node *> node_map;
-		
-		template<typename V>
-		struct node_iterator_type {
-			typedef node_seq::iterator seq;
-			typedef node_map::iterator map;
-		};
-		
-		template<typename V>
-		struct node_iterator_type<const V> {
-			typedef node_seq::const_iterator seq;
-			typedef node_map::const_iterator map;
-		};
-		
-
-		template<typename V>
-		class node_iterator_base: public boost::iterator_facade<
-		node_iterator_base<V>,
-		node_iterator_value<V>,
-		std::forward_iterator_tag,
-		node_iterator_value<V> >
-		{
-		private:
-			struct enabler {};
-			
-		public:
-			typedef typename node_iterator_type<V>::seq SeqIter;
-			typedef typename node_iterator_type<V>::map MapIter;
-			typedef node_iterator_value<V> value_type;
-			
-			node_iterator_base(): m_type(iterator_type::None) {}
-			explicit node_iterator_base(SeqIter seqIt): m_type(iterator_type::Sequence), m_seqIt(seqIt) {}
-			explicit node_iterator_base(MapIter mapIt, MapIter mapEnd): m_type(iterator_type::Map), m_mapIt(mapIt), m_mapEnd(mapEnd) {
-				m_mapIt = increment_until_defined(m_mapIt);
-			}
-			
-			template<typename W>
-			node_iterator_base(const node_iterator_base<W>& rhs, typename boost::enable_if<boost::is_convertible<W*, V*>, enabler>::type = enabler())
-			: m_type(rhs.m_type), m_seqIt(rhs.m_seqIt), m_mapIt(rhs.m_mapIt), m_mapEnd(rhs.m_mapEnd) {}
-			
-		private:
-			friend class boost::iterator_core_access;
-			template<typename> friend class node_iterator_base;
-			
-			template<typename W>
-			bool equal(const node_iterator_base<W>& rhs) const {
-				if(m_type != rhs.m_type)
-					return false;
-				
-				switch(m_type) {
-					case iterator_type::None: return true;
-					case iterator_type::Sequence: return m_seqIt == rhs.m_seqIt;
-					case iterator_type::Map: return m_mapIt == rhs.m_mapIt;
-				}
-				return true;
-			}
-			
-			void increment() {
-				switch(m_type) {
-					case iterator_type::None: break;
-					case iterator_type::Sequence:
-						++m_seqIt;
-						break;
-					case iterator_type::Map:
-						++m_mapIt;
-						m_mapIt = increment_until_defined(m_mapIt);
-						break;
-				}
-			}
-
-			value_type dereference() const {
-				switch(m_type) {
-					case iterator_type::None: return value_type();
-					case iterator_type::Sequence: return value_type(**m_seqIt);
-					case iterator_type::Map: return value_type(*m_mapIt->first, *m_mapIt->second);
-				}
-				return value_type();
-			}
-			
-			MapIter increment_until_defined(MapIter it) {
-				while(it != m_mapEnd && !is_defined(it))
-					++it;
-				return it;
-			}
-			
-			bool is_defined(MapIter it) const {
-				return it->first->is_defined() && it->second->is_defined();
-			}
-
-		private:
-			typename iterator_type::value m_type;
-
-			SeqIter m_seqIt;
-			MapIter m_mapIt, m_mapEnd;
-		};
-
-		typedef node_iterator_base<node> node_iterator;
-		typedef node_iterator_base<const node> const_node_iterator;
-	}
-}
-
-#endif // VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

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

@@ -1,65 +0,0 @@
-#ifndef VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define VALUE_DETAIL_NODE_REF_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/node/type.h"
-#include "yaml-cpp/node/ptr.h"
-#include "yaml-cpp/node/detail/node_data.h"
-#include <boost/utility.hpp>
-
-namespace YAML
-{
-	namespace detail
-	{
-		class node_ref: private boost::noncopyable
-		{
-		public:
-			node_ref(): m_pData(new node_data) {}
-			
-			bool is_defined() const { return m_pData->is_defined(); }
-			NodeType::value type() const { return m_pData->type(); }
-			const std::string& scalar() const { return m_pData->scalar(); }
-			const std::string& tag() const { return m_pData->tag(); }
-			
-			void mark_defined() { m_pData->mark_defined(); }
-			void set_data(const node_ref& rhs) { m_pData = rhs.m_pData; }
-			
-			void set_type(NodeType::value type) { m_pData->set_type(type); }
-			void set_tag(const std::string& tag) { m_pData->set_tag(tag); }
-			void set_null() { m_pData->set_null(); }
-			void set_scalar(const std::string& scalar) { m_pData->set_scalar(scalar); }
-			
-			// size/iterator
-			std::size_t size() const { return m_pData->size(); }
-			
-			const_node_iterator begin() const { return static_cast<const node_data&>(*m_pData).begin(); }
-			node_iterator begin() {return m_pData->begin(); }
-			
-			const_node_iterator end() const { return static_cast<const node_data&>(*m_pData).end(); }
-			node_iterator end() {return m_pData->end(); }
-
-			// sequence
-			void push_back(node& node, shared_memory_holder pMemory) { m_pData->push_back(node, pMemory); }
-			void insert(node& key, node& value, shared_memory_holder pMemory) { m_pData->insert(key, value, pMemory); }
-			
-			// indexing
-			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) const { return static_cast<const node_data&>(*m_pData).get(key, pMemory); }
-			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) { return m_pData->get(key, pMemory); }
-			template<typename Key> bool remove(const Key& key, shared_memory_holder pMemory) { return m_pData->remove(key, pMemory); }
-			
-			node& get(node& key, shared_memory_holder pMemory) const { return static_cast<const node_data&>(*m_pData).get(key, pMemory); }
-			node& get(node& key, shared_memory_holder pMemory) { return m_pData->get(key, pMemory); }
-			bool remove(node& key, shared_memory_holder pMemory) { return m_pData->remove(key, pMemory); }
-
-		private:
-			shared_node_data m_pData;
-		};
-	}
-}
-
-#endif // VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/node/emit.h

@@ -1,23 +0,0 @@
-#ifndef NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NODE_EMIT_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 <iosfwd>
-
-namespace YAML
-{
-	class Emitter;
-	class Node;
-	
-	Emitter& operator << (Emitter& out, const Node& node);
-	std::ostream& operator << (std::ostream& out, const Node& node);
-	
-	std::string Dump(const Node& node);
-}
-
-#endif // NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

include/yaml-cpp/node/impl.h

@@ -1,355 +0,0 @@
-#ifndef NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NODE_IMPL_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/node/node.h"
-#include "yaml-cpp/node/iterator.h"
-#include "yaml-cpp/node/detail/memory.h"
-#include "yaml-cpp/node/detail/node.h"
-#include "yaml-cpp/exceptions.h"
-#include <string>
-
-namespace YAML
-{
-	inline Node::Node(): m_pNode(0)
-	{
-	}
-	
-	inline Node::Node(NodeType::value type): m_pMemory(new detail::memory_holder), m_pNode(&m_pMemory->create_node())
-	{
-		m_pNode->set_type(type);
-	}
-	
-	template<typename T>
-	inline Node::Node(const T& rhs): m_pMemory(new detail::memory_holder), m_pNode(&m_pMemory->create_node())
-	{
-		Assign(rhs);
-	}
-	
-    inline Node::Node(const detail::iterator_value& rhs): m_pMemory(rhs.m_pMemory), m_pNode(rhs.m_pNode)
-    {
-    }
-
-	inline Node::Node(const Node& rhs): m_pMemory(rhs.m_pMemory), m_pNode(rhs.m_pNode)
-	{
-	}
-	
-	inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory): m_pMemory(pMemory), m_pNode(&node)
-	{
-	}
-
-	inline Node::~Node()
-	{
-	}
-
-	inline void Node::EnsureNodeExists() const
-	{
-		if(!m_pNode) {
-			m_pMemory.reset(new detail::memory_holder);
-			m_pNode = &m_pMemory->create_node();
-			m_pNode->set_null();
-		}
-	}
-	
-	inline bool Node::IsDefined() const
-	{
-		return m_pNode ? m_pNode->is_defined() : true;
-	}
-
-	inline NodeType::value Node::Type() const
-	{
-		return m_pNode ? m_pNode->type() : NodeType::Null;
-	}
-	
-	// access
-    
-    // template helpers
-    template<typename T, typename S>
-    struct as_if {
-        explicit as_if(const Node& node_): node(node_) {}
-        const Node& node;
-        
-        const T operator()(const S& fallback) const {
-            if(!node.m_pNode)
-                return fallback;
-            
-            T t;
-            if(convert<T>::decode(node, t))
-                return t;
-            return fallback;
-        }
-    };
-    
-    template<typename S>
-    struct as_if<std::string, S> {
-        explicit as_if(const Node& node_): node(node_) {}
-        const Node& node;
-        
-        const std::string operator()(const S& fallback) const {
-            if(node.Type() != NodeType::Scalar)
-                return fallback;
-            return node.Scalar();
-        }
-    };
-    
-    template<typename T>
-    struct as_if<T, void> {
-        explicit as_if(const Node& node_): node(node_) {}
-        const Node& node;
-        
-        const T operator()() const {
-            if(!node.m_pNode)
-                throw TypedBadConversion<T>();
-			
-            T t;
-            if(convert<T>::decode(node, t))
-                return t;
-            throw TypedBadConversion<T>();
-        }
-    };
-    
-    template<>
-    struct as_if<std::string, void> {
-        explicit as_if(const Node& node_): node(node_) {}
-        const Node& node;
-        
-        const std::string operator()() const {
-            if(node.Type() != NodeType::Scalar)
-                throw TypedBadConversion<std::string>();
-            return node.Scalar();
-        }
-    };
-    
-    // access functions
-	template<typename T>
-	inline const T Node::as() const
-	{
-        return as_if<T, void>(*this)();
-	}
-
-    template<typename T, typename S>
-    inline const T Node::as(const S& fallback) const
-    {
-        return as_if<T, S>(*this)(fallback);
-    }
-    
-	inline const std::string& Node::Scalar() const
-	{
-		return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar;
-	}
-
-	inline const std::string& Node::Tag() const
-	{
-		return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar;
-	}
-
-	inline void Node::SetTag(const std::string& tag)
-	{
-		EnsureNodeExists();
-		m_pNode->set_tag(tag);
-	}
-
-	// assignment
-	inline bool Node::is(const Node& rhs) const
-	{
-        if(!m_pNode || !rhs.m_pNode)
-            return false;
-		return m_pNode->is(*rhs.m_pNode);
-	}
-
-	template<typename T>
-	inline Node& Node::operator=(const T& rhs)
-	{
-		Assign(rhs);
-		return *this;
-	}
-	
-	template<typename T>
-	inline void Node::Assign(const T& rhs)
-	{
-		AssignData(convert<T>::encode(rhs));
-	}
-
-	template<>
-	inline void Node::Assign(const std::string& rhs)
-	{
-		EnsureNodeExists();
-		m_pNode->set_scalar(rhs);
-	}
-
-	inline void Node::Assign(const char *rhs)
-	{
-		EnsureNodeExists();
-		m_pNode->set_scalar(rhs);
-	}
-
-	inline void Node::Assign(char *rhs)
-	{
-		EnsureNodeExists();
-		m_pNode->set_scalar(rhs);
-	}
-	
-	inline Node& Node::operator=(const Node& rhs)
-	{
-		if(is(rhs))
-			return *this;
-		AssignNode(rhs);
-		return *this;
-	}
-
-	inline void Node::AssignData(const Node& rhs)
-	{
-		EnsureNodeExists();
-		rhs.EnsureNodeExists();
-		
-		m_pNode->set_data(*rhs.m_pNode);
-		m_pMemory->merge(*rhs.m_pMemory);
-	}
-
-	inline void Node::AssignNode(const Node& rhs)
-	{
-		rhs.EnsureNodeExists();
-
-		if(!m_pNode) {
-			m_pNode = rhs.m_pNode;
-			m_pMemory = rhs.m_pMemory;
-			return;
-		}
-
-		m_pNode->set_ref(*rhs.m_pNode);
-		m_pMemory->merge(*rhs.m_pMemory);
-		m_pNode = rhs.m_pNode;
-	}
-
-	// size/iterator
-	inline std::size_t Node::size() const
-	{
-		return m_pNode ? m_pNode->size() : 0;
-	}
-
-	inline const_iterator Node::begin() const
-	{
-		return m_pNode ? const_iterator(m_pNode->begin(), m_pMemory) : const_iterator();
-	}
-	
-	inline iterator Node::begin()
-	{
-		return m_pNode ? iterator(m_pNode->begin(), m_pMemory) : iterator();
-	}
-
-	inline const_iterator Node::end() const
-	{
-		return m_pNode ? const_iterator(m_pNode->end(), m_pMemory) : const_iterator();
-	}
-
-	inline iterator Node::end()
-	{
-		return m_pNode ? iterator(m_pNode->end(), m_pMemory) : iterator();
-	}
-	
-	// sequence
-	template<typename T>
-	inline void Node::push_back(const T& rhs)
-	{
-		push_back(Node(rhs));
-	}
-	
-	inline void Node::push_back(const Node& rhs)
-	{
-		EnsureNodeExists();
-		rhs.EnsureNodeExists();
-		
-		m_pNode->push_back(*rhs.m_pNode, m_pMemory);
-		m_pMemory->merge(*rhs.m_pMemory);
-	}
-
-	// indexing
-	template<typename Key>
-	inline const Node Node::operator[](const Key& key) const
-	{
-		EnsureNodeExists();
-		detail::node& value = static_cast<const detail::node&>(*m_pNode).get(key, m_pMemory);
-		return Node(value, m_pMemory);
-	}
-	
-	template<typename Key>
-	inline Node Node::operator[](const Key& key)
-	{
-		EnsureNodeExists();
-		detail::node& value = m_pNode->get(key, m_pMemory);
-		return Node(value, m_pMemory);
-	}
-	
-	template<typename Key>
-	inline bool Node::remove(const Key& key)
-	{
-		EnsureNodeExists();
-		return m_pNode->remove(key, m_pMemory);
-	}
-	
-	inline const Node Node::operator[](const Node& key) const
-	{
-		EnsureNodeExists();
-		key.EnsureNodeExists();
-		detail::node& value = static_cast<const detail::node&>(*m_pNode).get(*key.m_pNode, m_pMemory);
-		return Node(value, m_pMemory);
-	}
-	
-	inline Node Node::operator[](const Node& key)
-	{
-		EnsureNodeExists();
-		key.EnsureNodeExists();
-		detail::node& value = m_pNode->get(*key.m_pNode, m_pMemory);
-		return Node(value, m_pMemory);
-	}
-	
-	inline bool Node::remove(const Node& key)
-	{
-		EnsureNodeExists();
-		key.EnsureNodeExists();
-		return m_pNode->remove(*key.m_pNode, m_pMemory);
-	}
-	
-	inline const Node Node::operator[](const char *key) const
-	{
-		return operator[](std::string(key));
-	}
-	
-	inline Node Node::operator[](const char *key)
-	{
-		return operator[](std::string(key));
-	}
-	
-	inline bool Node::remove(const char *key)
-	{
-		return remove(std::string(key));
-	}
-	
-	inline const Node Node::operator[](char *key) const
-	{
-		return operator[](static_cast<const char *>(key));
-	}
-	
-	inline Node Node::operator[](char *key)
-	{
-		return operator[](static_cast<const char *>(key));
-	}
-	
-	inline bool Node::remove(char *key)
-	{
-		return remove(static_cast<const char *>(key));
-	}
-
-	// free functions
-
-	inline bool operator==(const Node& lhs, const Node& rhs)
-	{
-		return lhs.is(rhs);
-	}
-}
-
-#endif // NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/node/iterator.h

@@ -1,28 +0,0 @@
-#ifndef VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define VALUE_ITERATOR_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/node/node.h"
-#include "yaml-cpp/node/detail/iterator_fwd.h"
-#include "yaml-cpp/node/detail/iterator.h"
-#include <list>
-#include <utility>
-#include <vector>
-
-namespace YAML
-{
-	namespace detail {
-		struct iterator_value: public Node, std::pair<Node, Node> {
-			iterator_value() {}
-			explicit iterator_value(const Node& rhs): Node(rhs) {}
-			explicit iterator_value(const Node& key, const Node& value): std::pair<Node, Node>(key, value) {}
-		};
-	}
-}
-
-#endif // VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/node/node.h

@@ -1,113 +0,0 @@
-#ifndef NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NODE_NODE_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/node/ptr.h"
-#include "yaml-cpp/node/type.h"
-#include "yaml-cpp/node/detail/iterator_fwd.h"
-#include "yaml-cpp/node/detail/bool_type.h"
-#include <stdexcept>
-
-namespace YAML
-{
-	class Node
-	{
-	public:
-		friend class NodeBuilder;
-		friend class NodeEvents;
-		friend class detail::node_data;
-		template<typename> friend class detail::iterator_base;
-        template<typename T, typename S> friend struct as_if;
-        
-        typedef YAML::iterator iterator;
-        typedef YAML::const_iterator const_iterator;
-		
-		Node();
-		explicit Node(NodeType::value type);
-		template<typename T> explicit Node(const T& rhs);
-        explicit Node(const detail::iterator_value& rhs);
-		Node(const Node& rhs);
-		~Node();
-		
-		NodeType::value Type() const;
-		bool IsDefined() const;
-		bool IsNull() const { return Type() == NodeType::Null; }
-		bool IsScalar() const { return Type() == NodeType::Scalar; }
-		bool IsSequence() const { return Type() == NodeType::Sequence; }
-		bool IsMap() const { return Type() == NodeType::Map; }
-		
-		// bool conversions
-		YAML_CPP_OPERATOR_BOOL();
-		bool operator!() const { return !IsDefined(); }
-		
-		// access
-		template<typename T> const T as() const;
-		template<typename T, typename S> const T as(const S& fallback) const;
-		const std::string& Scalar() const;
-		const std::string& Tag() const;
-		void SetTag(const std::string& tag);
-
-		// assignment
-		bool is(const Node& rhs) const;
-		template<typename T> Node& operator=(const T& rhs);
-		Node& operator=(const Node& rhs);
-
-		// size/iterator
-		std::size_t size() const;
-
-		const_iterator begin() const;
-		iterator begin();
-		
-		const_iterator end() const;
-		iterator end();
-		
-		// sequence
-		template<typename T> void push_back(const T& rhs);
-		void push_back(const Node& rhs);
-		
-		// indexing
-		template<typename Key> const Node operator[](const Key& key) const;
-		template<typename Key> Node operator[](const Key& key);
-		template<typename Key> bool remove(const Key& key);
-
-		const Node operator[](const Node& key) const;
-		Node operator[](const Node& key);
-		bool remove(const Node& key);
-		
-		const Node operator[](const char *key) const;
-		Node operator[](const char *key);
-		bool remove(const char *key);
-
-		const Node operator[](char *key) const;
-		Node operator[](char *key);
-		bool remove(char *key);
-		
-	private:
-		explicit Node(detail::node& node, detail::shared_memory_holder pMemory);
-		
-		void EnsureNodeExists() const;
-		
-		template<typename T> void Assign(const T& rhs);
-		void Assign(const char *rhs);
-		void Assign(char *rhs);
-
-		void AssignData(const Node& rhs);
-		void AssignNode(const Node& rhs);
-		
-	private:
-		mutable detail::shared_memory_holder m_pMemory;
-		mutable detail::node *m_pNode;
-	};
-
-	bool operator==(const Node& lhs, const Node& rhs);
-	
-	template<typename T>
-	struct convert;
-}
-
-#endif // NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/node/parse.h

@@ -1,28 +0,0 @@
-#ifndef VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define VALUE_PARSE_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 <iosfwd>
-#include <string>
-#include <vector>
-
-namespace YAML
-{
-	class Node;
-	
-	Node Load(const std::string& input);
-	Node Load(const char *input);
-	Node Load(std::istream& input);
-    Node LoadFile(const std::string& filename);
-
-	std::vector<Node> LoadAll(const std::string& input);
-	std::vector<Node> LoadAll(const char *input);
-	std::vector<Node> LoadAll(std::istream& input);
-    std::vector<Node> LoadAllFromFile(const std::string& filename);
-}
-
-#endif // VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

include/yaml-cpp/node/ptr.h

@@ -1,29 +0,0 @@
-#ifndef VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define VALUE_PTR_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 <boost/shared_ptr.hpp>
-
-namespace YAML
-{
-	namespace detail {
-		class node;
-		class node_ref;
-		class node_data;
-		class memory;
-		class memory_holder;
-
-		typedef boost::shared_ptr<node> shared_node;
-		typedef boost::shared_ptr<node_ref> shared_node_ref;
-		typedef boost::shared_ptr<node_data> shared_node_data;
-		typedef boost::shared_ptr<memory_holder> shared_memory_holder;
-		typedef boost::shared_ptr<memory> shared_memory;
-	}
-}
-
-#endif // VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/node/type.h

@@ -1,14 +0,0 @@
-#ifndef VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define VALUE_TYPE_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 NodeType { enum value { Undefined, Null, Scalar, Sequence, Map }; };	
-}
-
-#endif // VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/noncopyable.h

@@ -1,25 +0,0 @@
-#ifndef NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NONCOPYABLE_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"
-
-namespace YAML
-{
-	// this is basically boost::noncopyable
-	class YAML_CPP_API noncopyable
-	{
-	protected:
-		noncopyable() {}
-		~noncopyable() {}
-			
-	private:
-		noncopyable(const noncopyable&);
-		const noncopyable& operator = (const noncopyable&);
-	};
-}
-
-#endif // NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/parser.h

@@ -1,51 +0,0 @@
-#ifndef PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define PARSER_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/noncopyable.h"
-#include <ios>
-#include <memory>
-
-namespace YAML
-{
-	struct Directives;
-	struct Mark;
-	struct Token;
-	class EventHandler;
-	class Node;
-	class Scanner;
-
-	class YAML_CPP_API Parser: private noncopyable
-	{
-	public:
-		Parser();
-		Parser(std::istream& in);
-		~Parser();
-
-		operator bool() const;
-
-		void Load(std::istream& in);
-		bool HandleNextDocument(EventHandler& eventHandler);
-		
-		bool GetNextDocument(Node& document); // old API only
-		
-		void PrintTokens(std::ostream& out);
-
-	private:
-		void ParseDirectives();
-		void HandleDirective(const Token& token);
-		void HandleYamlDirective(const Token& token);
-		void HandleTagDirective(const Token& token);
-		
-	private:
-		std::auto_ptr<Scanner> m_pScanner;
-		std::auto_ptr<Directives> m_pDirectives;
-	};
-}
-
-#endif // PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/stlemitter.h

@@ -1,51 +0,0 @@
-#ifndef STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define STLEMITTER_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 <list>
-#include <set>
-#include <map>
-
-namespace YAML
-{
-	template<typename Seq>
-	inline Emitter& EmitSeq(Emitter& emitter, const Seq& seq) {
-		emitter << BeginSeq;
-		for(typename Seq::const_iterator it=seq.begin();it!=seq.end();++it)
-			emitter << *it;
-		emitter << EndSeq;
-		return emitter;
-	}
-	
-	template<typename T>
-	inline Emitter& operator << (Emitter& emitter, const std::vector<T>& v) {
-		return EmitSeq(emitter, v);
-	}	
-
-	template<typename T>
-	inline Emitter& operator << (Emitter& emitter, const std::list<T>& v) {
-		return EmitSeq(emitter, v);
-	}
-
-	template<typename T>
-	inline Emitter& operator << (Emitter& emitter, const std::set<T>& v) {
-		return EmitSeq(emitter, v);
-	}
-	
-	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/traits.h

@@ -1,57 +0,0 @@
-#ifndef TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define TRAITS_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
-{
-	template <typename>
-	struct is_numeric { enum { value = false }; };
-
-	template <> struct is_numeric <char> { enum { value = true }; };
-	template <> struct is_numeric <unsigned char> { enum { value = true }; };
-	template <> struct is_numeric <int> { enum { value = true }; };
-	template <> struct is_numeric <unsigned int> { enum { value = true }; };
-	template <> struct is_numeric <long int> { enum { value = true }; };
-	template <> struct is_numeric <unsigned long int> { enum { value = true }; };
-	template <> struct is_numeric <short int> { enum { value = true }; };
-	template <> struct is_numeric <unsigned short int> { enum { value = true }; };
-#if defined(_MSC_VER) && (_MSC_VER < 1310)
-	template <> struct is_numeric <__int64> { enum { value = true }; };
-	template <> struct is_numeric <unsigned __int64> { enum { value = true }; };
-#else
-	template <> struct is_numeric <long long> { enum { value = true }; };
-	template <> struct is_numeric <unsigned long long> { enum { value = true }; };
-#endif
-	template <> struct is_numeric <float> { enum { value = true }; };
-	template <> struct is_numeric <double> { enum { value = true }; };
-	template <> struct is_numeric <long double> { enum { value = true }; };
-
-	template <bool, class T = void>
-	struct enable_if_c {
-	  typedef T type;
-	};
-
-	template <class T>
-	struct enable_if_c<false, T> {};
-
-	template <class Cond, class T = void>
-	struct enable_if : public enable_if_c<Cond::value, T> {};
-
-	template <bool, class T = void>
-	struct disable_if_c {
-	  typedef T type;
-	};
-
-	template <class T>
-	struct disable_if_c<true, T> {};
-
-	template <class Cond, class T = void>
-	struct disable_if : public disable_if_c<Cond::value, T> {};
-}
-
-#endif // TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

include/yaml-cpp/yaml.h

@@ -1,21 +0,0 @@
-#ifndef YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define YAML_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/parser.h"
-#include "yaml-cpp/emitter.h"
-#include "yaml-cpp/stlemitter.h"
-#include "yaml-cpp/exceptions.h"
-
-#include "yaml-cpp/node/node.h"
-#include "yaml-cpp/node/impl.h"
-#include "yaml-cpp/node/convert.h"
-#include "yaml-cpp/node/iterator.h"
-#include "yaml-cpp/node/detail/impl.h"
-#include "yaml-cpp/node/parse.h"
-#include "yaml-cpp/node/emit.h"
-
-#endif // YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#ifndef YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+
+#include "crt.h"
+#include "parser.h"
+#include "node.h"
+#include "iterator.h"
+#include "emitter.h"
+#include "stlemitter.h"
+#include "exceptions.h"
+
+#endif // YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66

install.txt

@@ -21,4 +21,4 @@ make install
 
 If you don't want to use CMake, just add all .cpp files to a makefile. yaml-cpp does not need any special build settings, so no 'configure' file is necessary.
 
-(Note: this is pretty tedious. It's sooo much easier to use CMake.)
+(Note: this is pretty tedious. It's sooo much easier to use CMake.)

license.txt

@@ -1,19 +1,19 @@
-Copyright (c) 2008 Jesse Beder.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+Copyright (c) 2008 Jesse Beder.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

src/aliascontent.cpp

@@ -0,0 +1,94 @@
+#include "crt.h"
+#include "aliascontent.h"
+
+namespace YAML
+{
+	AliasContent::AliasContent(Content* pNodeContent)
+		: m_pRef(pNodeContent)
+	{
+	}
+
+	Content *AliasContent::Clone() const
+	{
+		return 0; // TODO: how to clone an alias?
+	}
+
+	void AliasContent::Parse(Scanner * /*pScanner*/, const ParserState& /*state*/)
+	{
+	}
+
+	void AliasContent::Write(Emitter&) const
+	{
+		// no content (just an alias)
+	}
+
+	bool AliasContent::GetBegin(std::vector <Node *>::const_iterator& i) const
+	{
+		return m_pRef->GetBegin(i);
+	}
+
+	bool AliasContent::GetBegin(std::map <Node *, Node *, ltnode>::const_iterator& i) const
+	{
+		return m_pRef->GetBegin(i);
+	}
+
+	bool AliasContent::GetEnd(std::vector <Node *>::const_iterator& i) const
+	{
+		return m_pRef->GetEnd(i);
+	}
+
+	bool AliasContent::GetEnd(std::map <Node *, Node *, ltnode>::const_iterator& i) const
+	{
+		return m_pRef->GetEnd(i);
+	}
+
+	Node* AliasContent::GetNode(std::size_t n) const
+	{
+		return m_pRef->GetNode(n);
+	}
+
+	std::size_t AliasContent::GetSize() const
+	{
+		return m_pRef->GetSize();
+	}
+
+	bool AliasContent::IsScalar() const
+	{
+		return m_pRef->IsScalar();
+	}
+
+	bool AliasContent::IsMap() const
+	{
+		return m_pRef->IsMap();
+	}
+
+	bool AliasContent::IsSequence() const
+	{
+		return m_pRef->IsSequence();
+	}
+
+	bool AliasContent::GetScalar(std::string& scalar) const
+	{
+		return m_pRef->GetScalar(scalar);
+	}
+
+	int AliasContent::Compare(Content *pContent)
+	{
+		return m_pRef->Compare(pContent);
+	}
+
+	int AliasContent::Compare(Scalar *pScalar)
+	{
+		return m_pRef->Compare(pScalar);
+	}
+
+	int AliasContent::Compare(Sequence *pSequence)
+	{
+		return m_pRef->Compare(pSequence);
+	}
+
+	int AliasContent::Compare(Map *pMap)
+	{
+		return m_pRef->Compare(pMap);
+	}
+}

src/aliascontent.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#ifndef ALIASCONTENT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define ALIASCONTENT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+
+#include "content.h"
+
+namespace YAML
+{
+	class AliasContent : public Content
+	{
+	public:
+		AliasContent(Content *pNodeContent);
+		
+		virtual Content *Clone() const;
+
+		virtual void Parse(Scanner* pScanner, const ParserState& state);
+		virtual void Write(Emitter&) const;
+
+		virtual bool GetBegin(std::vector <Node *>::const_iterator&) const;
+		virtual bool GetBegin(std::map <Node *, Node *, ltnode>::const_iterator&) const;
+		virtual bool GetEnd(std::vector <Node *>::const_iterator&) const;
+		virtual bool GetEnd(std::map <Node *, Node *, ltnode>::const_iterator&) const;
+		virtual Node* GetNode(std::size_t) const;
+		virtual std::size_t GetSize() const;
+		virtual bool IsScalar() const;
+		virtual bool IsMap() const;
+		virtual bool IsSequence() const;
+
+		virtual bool GetScalar(std::string& s) const;
+
+		virtual int Compare(Content *);
+		virtual int Compare(Scalar *);
+		virtual int Compare(Sequence *);
+		virtual int Compare(Map *);
+
+	private:
+		Content* m_pRef;
+	};
+}
+
+#endif // ALIASCONTENT_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/binary.cpp

@@ -1,93 +0,0 @@
-#include "yaml-cpp/binary.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;
-    }
-}

src/collectionstack.h

@@ -1,35 +0,0 @@
-#ifndef COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define COLLECTIONSTACK_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 <stack>
-#include <cassert>
-
-namespace YAML
-{
-	struct CollectionType {
-		enum value { None, BlockMap, BlockSeq, FlowMap, FlowSeq, CompactMap };
-	};
-
-	class CollectionStack
-	{
-	public:
-		CollectionType::value GetCurCollectionType() const {
-			if(collectionStack.empty())
-				return CollectionType::None;
-			return collectionStack.top();
-		}
-		
-		void PushCollectionType(CollectionType::value type) { collectionStack.push(type); }
-		void PopCollectionType(CollectionType::value type) { assert(type == GetCurCollectionType()); collectionStack.pop(); }
-		
-	private:
-		std::stack<CollectionType::value> collectionStack;
-	};
-}
-
-#endif // COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/content.cpp

@@ -0,0 +1,13 @@
+#include "crt.h"
+#include "content.h"
+
+namespace YAML
+{
+	Content::Content()
+	{
+	}
+
+	Content::~Content()
+	{
+	}
+}

src/content.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#ifndef CONTENT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define CONTENT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+
+#include <vector>
+#include <map>
+#include "parserstate.h"
+#include "exceptions.h"
+#include "ltnode.h"
+
+namespace YAML
+{
+	class Scanner;
+	class Parser;
+	class Node;
+	class Scalar;
+	class Sequence;
+	class Map;
+	class Emitter;
+
+	class Content
+	{
+	public:
+		Content();
+		virtual ~Content();
+		
+		virtual Content *Clone() const = 0;
+
+		virtual void Parse(Scanner *pScanner, const ParserState& state) = 0;
+		virtual void Write(Emitter& out) const = 0;
+
+		virtual bool GetBegin(std::vector <Node *>::const_iterator&) const { return false; }
+		virtual bool GetBegin(std::map <Node *, Node *, ltnode>::const_iterator&) const { return false; }
+		virtual bool GetEnd(std::vector <Node *>::const_iterator&) const { return false; }
+		virtual bool GetEnd(std::map <Node *, Node *, ltnode>::const_iterator&) const { return false; }
+		virtual Node *GetNode(std::size_t) const { return 0; }
+		virtual std::size_t GetSize() const { return 0; }
+		virtual bool IsScalar() const { return false; }
+		virtual bool IsMap() const { return false; }
+		virtual bool IsSequence() const { return false; }
+
+		// extraction
+		virtual bool GetScalar(std::string&) const { return false; }
+
+		// ordering
+		virtual int Compare(Content *) { return 0; }
+		virtual int Compare(Scalar *) { return 0; }
+		virtual int Compare(Sequence *) { return 0; }
+		virtual int Compare(Map *) { return 0; }
+
+	protected:
+	};
+}
+
+#endif // CONTENT_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/contrib/graphbuilder.cpp

@@ -1,16 +0,0 @@
-#include "yaml-cpp/parser.h"
-#include "yaml-cpp/contrib/graphbuilder.h"
-#include "graphbuilderadapter.h"
-
-namespace YAML
-{
-  void *BuildGraphOfNextDocument(Parser& parser, GraphBuilderInterface& graphBuilder)
-  {
-    GraphBuilderAdapter eventHandler(graphBuilder);
-    if (parser.HandleNextDocument(eventHandler)) {
-      return eventHandler.RootNode();
-    } else {
-      return NULL;
-    }
-  }
-}

src/contrib/graphbuilderadapter.cpp

@@ -1,96 +0,0 @@
-#include "graphbuilderadapter.h"
-
-namespace YAML
-{
-  int GraphBuilderAdapter::ContainerFrame::sequenceMarker;
-  
-  void GraphBuilderAdapter::OnNull(const Mark& mark, anchor_t anchor)
-  {
-    void *pParent = GetCurrentParent();
-    void *pNode = m_builder.NewNull(mark, pParent);
-    RegisterAnchor(anchor, pNode);
-    
-    DispositionNode(pNode);
-  }
-  
-  void GraphBuilderAdapter::OnAlias(const Mark& mark, anchor_t anchor)
-  {
-    void *pReffedNode = m_anchors.Get(anchor);
-    DispositionNode(m_builder.AnchorReference(mark, pReffedNode));
-  }
-  
-  void GraphBuilderAdapter::OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value)
-  {
-    void *pParent = GetCurrentParent();
-    void *pNode = m_builder.NewScalar(mark, tag, pParent, value);
-    RegisterAnchor(anchor, pNode);
-    
-    DispositionNode(pNode);
-  }
-  
-  void GraphBuilderAdapter::OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor)
-  {
-    void *pNode = m_builder.NewSequence(mark, tag, GetCurrentParent());
-    m_containers.push(ContainerFrame(pNode));
-    RegisterAnchor(anchor, pNode);
-  }
-  
-  void GraphBuilderAdapter::OnSequenceEnd()
-  {
-    void *pSequence = m_containers.top().pContainer;
-    m_containers.pop();
-    
-    DispositionNode(pSequence);
-  }
-  
-  void GraphBuilderAdapter::OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor)
-  {
-    void *pNode = m_builder.NewMap(mark, tag, GetCurrentParent());
-    m_containers.push(ContainerFrame(pNode, m_pKeyNode));
-    m_pKeyNode = NULL;
-    RegisterAnchor(anchor, pNode);
-  }
-  
-  void GraphBuilderAdapter::OnMapEnd()
-  {
-    void *pMap = m_containers.top().pContainer;
-    m_pKeyNode = m_containers.top().pPrevKeyNode;
-    m_containers.pop();
-    DispositionNode(pMap);
-  }
-  
-  void *GraphBuilderAdapter::GetCurrentParent() const
-  {
-    if (m_containers.empty()) {
-      return NULL;
-    }
-    return m_containers.top().pContainer;
-  }
-  
-  void GraphBuilderAdapter::RegisterAnchor(anchor_t anchor, void *pNode)
-  {
-    if (anchor) {
-      m_anchors.Register(anchor, pNode);
-    }
-  }
-  
-  void GraphBuilderAdapter::DispositionNode(void *pNode)
-  {
-    if (m_containers.empty()) {
-      m_pRootNode = pNode;
-      return;
-    }
-    
-    void *pContainer = m_containers.top().pContainer;
-    if (m_containers.top().isMap()) {
-      if (m_pKeyNode) {
-        m_builder.AssignInMap(pContainer, m_pKeyNode, pNode);
-        m_pKeyNode = NULL;
-      } else {
-        m_pKeyNode = pNode;
-      }
-    } else {
-      m_builder.AppendToSequence(pContainer, pNode);
-    }
-  }
-}

src/contrib/graphbuilderadapter.h

@@ -1,73 +0,0 @@
-#ifndef GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define GRAPHBUILDERADAPTER_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 <cstdlib>
-#include <map>
-#include <stack>
-#include "yaml-cpp/eventhandler.h"
-#include "yaml-cpp/contrib/anchordict.h"
-#include "yaml-cpp/contrib/graphbuilder.h"
-
-namespace YAML
-{
-  class GraphBuilderAdapter : public EventHandler
-  {
-  public:
-    GraphBuilderAdapter(GraphBuilderInterface& builder)
-    : m_builder(builder), m_pRootNode(NULL), m_pKeyNode(NULL)
-    {
-    }
-    
-    virtual void OnDocumentStart(const Mark& mark) {(void)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();
-    
-    void *RootNode() const {return m_pRootNode;}
-  
-  private:
-    struct ContainerFrame
-    {
-      ContainerFrame(void *pSequence)
-      : pContainer(pSequence), pPrevKeyNode(&sequenceMarker)
-      {}
-      ContainerFrame(void *pMap, void* pPrevKeyNode)
-      : pContainer(pMap), pPrevKeyNode(pPrevKeyNode)
-      {}
-      
-      void *pContainer;
-      void *pPrevKeyNode;
-      
-      bool isMap() const {return pPrevKeyNode != &sequenceMarker;}
-    
-    private:
-      static int sequenceMarker;
-    };
-    typedef std::stack<ContainerFrame> ContainerStack;
-    typedef AnchorDict<void*> AnchorMap;
-    
-    GraphBuilderInterface& m_builder;
-    ContainerStack m_containers;
-    AnchorMap m_anchors;
-    void *m_pRootNode;
-    void *m_pKeyNode;
-    
-    void *GetCurrentParent() const;
-    void RegisterAnchor(anchor_t anchor, void *pNode);
-    void DispositionNode(void *pNode);
-  };
-}
-
-#endif // GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/conversion.cpp

@@ -1,31 +1,33 @@
-#include "yaml-cpp/node/convert.h"
-#include "yaml-cpp/node/impl.h"
+#include "conversion.h"
 #include <algorithm>
 
+////////////////////////////////////////////////////////////////
+// Specializations for converting a string to specific types
+
 namespace
 {
 	// we're not gonna mess with the mess that is all the isupper/etc. functions
 	bool IsLower(char ch) { return 'a' <= ch && ch <= 'z'; }
 	bool IsUpper(char ch) { return 'A' <= ch && ch <= 'Z'; }
 	char ToLower(char ch) { return IsUpper(ch) ? ch + 'a' - 'A' : ch; }
-	
+
 	std::string tolower(const std::string& str)
 	{
 		std::string s(str);
 		std::transform(s.begin(), s.end(), s.begin(), ToLower);
 		return s;
 	}
-	
+
 	template <typename T>
 	bool IsEntirely(const std::string& str, T func)
 	{
 		for(std::size_t i=0;i<str.size();i++)
 			if(!func(str[i]))
 				return false;
-		
+
 		return true;
 	}
-	
+
 	// IsFlexibleCase
 	// . Returns true if 'str' is:
 	//   . UPPERCASE
@@ -35,10 +37,10 @@ namespace
 	{
 		if(str.empty())
 			return true;
-		
+
 		if(IsEntirely(str, IsLower))
 			return true;
-		
+
 		bool firstcaps = IsUpper(str[0]);
 		std::string rest = str.substr(1);
 		return firstcaps && (IsEntirely(rest, IsLower) || IsEntirely(rest, IsUpper));
@@ -47,10 +49,9 @@ namespace
 
 namespace YAML
 {
-	bool convert<bool>::decode(const Node& node, bool& rhs) {
-		if(!node.IsScalar())
-			return false;
-		
+	template <>
+	bool Converter<bool>::Convert(const std::string& input, bool& b)
+	{
 		// we can't use iostream bool extraction operators as they don't
 		// recognize all possible values in the table below (taken from
 		// http://yaml.org/type/bool.html)
@@ -62,22 +63,29 @@ namespace YAML
 			{ "true", "false" },
 			{ "on", "off" },
 		};
-		
-		if(!IsFlexibleCase(node.Scalar()))
+
+		if(!IsFlexibleCase(input))
 			return false;
-		
+
 		for(unsigned i=0;i<sizeof(names)/sizeof(names[0]);i++) {
-			if(names[i].truename == tolower(node.Scalar())) {
-				rhs = true;
+			if(names[i].truename == tolower(input)) {
+				b = true;
 				return true;
 			}
-			
-			if(names[i].falsename == tolower(node.Scalar())) {
-				rhs = false;
+
+			if(names[i].falsename == tolower(input)) {
+				b = false;
 				return true;
 			}
 		}
-		
+
 		return false;
 	}
+	
+	template <>
+	bool Converter<_Null>::Convert(const std::string& input, _Null& /*output*/)
+	{
+		return input.empty() || input == "~" || input == "null" || input == "Null" || input == "NULL";
+	}
 }
+

src/directives.cpp

@@ -1,24 +0,0 @@
-#include "directives.h"
-
-namespace YAML
-{
-	Directives::Directives()
-	{
-		// version
-		version.isDefault = true;
-		version.major = 1;
-		version.minor = 2;
-	}
-	
-	const std::string Directives::TranslateTagHandle(const std::string& handle) const
-	{
-		std::map <std::string, std::string>::const_iterator it = tags.find(handle);
-		if(it == tags.end()) {
-			if(handle == "!!")
-				return "tag:yaml.org,2002:";
-			return handle;
-		}
-		
-		return it->second;
-	}
-}

src/directives.h

@@ -1,29 +0,0 @@
-#ifndef DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define DIRECTIVES_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 <map>
-
-namespace YAML
-{
-	struct Version {
-		bool isDefault;
-		int major, minor;
-	};
-	
-	struct Directives {
-		Directives();
-		
-		const std::string TranslateTagHandle(const std::string& handle) const;
-
-		Version version;
-		std::map<std::string, std::string> tags;
-	};
-}
-
-#endif // DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/emit.cpp

@@ -1,30 +0,0 @@
-#include "yaml-cpp/node/emit.h"
-#include "yaml-cpp/emitfromevents.h"
-#include "yaml-cpp/emitter.h"
-#include "nodeevents.h"
-
-namespace YAML
-{
-	Emitter& operator << (Emitter& out, const Node& node)
-	{
-		EmitFromEvents emitFromEvents(out);
-		NodeEvents events(node);
-		events.Emit(emitFromEvents);
-		return out;
-	}
-	
-	std::ostream& operator << (std::ostream& out, const Node& node)
-	{
-		Emitter emitter;
-		emitter << node;
-		out << emitter.c_str();
-		return out;
-	}
-
-	std::string Dump(const Node& node)
-	{
-		Emitter emitter;
-		emitter << node;
-		return emitter.c_str();
-	}
-}

src/emitfromevents.cpp

@@ -1,105 +0,0 @@
-#include "yaml-cpp/emitfromevents.h"
-#include "yaml-cpp/emitter.h"
-#include "yaml-cpp/null.h"
-#include <cassert>
-#include <sstream>
-
-namespace {
-	std::string ToString(YAML::anchor_t anchor) {
-		std::stringstream stream;
-		stream << anchor;
-		return stream.str();
-	}
-}
-
-namespace YAML
-{
-	EmitFromEvents::EmitFromEvents(Emitter& emitter): m_emitter(emitter)
-	{
-	}
-	
-	void EmitFromEvents::OnDocumentStart(const Mark&)
-	{
-	}
-	
-	void EmitFromEvents::OnDocumentEnd()
-	{
-	}
-	
-	void EmitFromEvents::OnNull(const Mark&, anchor_t anchor)
-	{
-		BeginNode();
-		EmitProps("", anchor);
-		m_emitter << Null;
-	}
-	
-	void EmitFromEvents::OnAlias(const Mark&, anchor_t anchor)
-	{
-		BeginNode();
-		m_emitter << Alias(ToString(anchor));
-	}
-	
-	void EmitFromEvents::OnScalar(const Mark&, const std::string& tag, anchor_t anchor, const std::string& value)
-	{
-		BeginNode();
-		EmitProps(tag, anchor);
-		m_emitter << value;
-	}
-	
-	void EmitFromEvents::OnSequenceStart(const Mark&, const std::string& tag, anchor_t anchor)
-	{
-		BeginNode();
-		EmitProps(tag, anchor);
-		m_emitter << BeginSeq;
-		m_stateStack.push(State::WaitingForSequenceEntry);
-	}
-	
-	void EmitFromEvents::OnSequenceEnd()
-	{
-		m_emitter << EndSeq;
-		assert(m_stateStack.top() == State::WaitingForSequenceEntry);
-		m_stateStack.pop();
-	}
-	
-	void EmitFromEvents::OnMapStart(const Mark&, const std::string& tag, anchor_t anchor)
-	{
-		BeginNode();
-		EmitProps(tag, anchor);
-		m_emitter << BeginMap;
-		m_stateStack.push(State::WaitingForKey);
-	}
-
-	void EmitFromEvents::OnMapEnd()
-	{
-		m_emitter << EndMap;
-		assert(m_stateStack.top() == State::WaitingForKey);
-		m_stateStack.pop();
-	}
-
-	void EmitFromEvents::BeginNode()
-	{
-		if(m_stateStack.empty())
-			return;
-		
-		switch(m_stateStack.top()) {
-			case State::WaitingForKey:
-				m_emitter << Key;
-				m_stateStack.top() = State::WaitingForValue;
-				break;
-			case State::WaitingForValue:
-				m_emitter << Value;
-				m_stateStack.top() = State::WaitingForKey;
-				break;
-			default:
-				break;
-		}
-	}
-	
-	void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor)
-	{
-		if(!tag.empty() && tag != "?")
-			m_emitter << VerbatimTag(tag);
-		if(anchor)
-			m_emitter << Anchor(ToString(anchor));
-	}
-}

src/emitter.cpp

@@ -1,8 +1,8 @@
-#include "yaml-cpp/emitter.h"
+#include "emitter.h"
 #include "emitterstate.h"
 #include "emitterutils.h"
 #include "indentation.h"
-#include "yaml-cpp/exceptions.h"
+#include "exceptions.h"
 #include <sstream>
 
 namespace YAML
@@ -37,11 +37,6 @@ namespace YAML
 	}
 
 	// global setters
-	bool Emitter::SetOutputCharset(EMITTER_MANIP value)
-	{
-		return m_pState->SetOutputCharset(value, GLOBAL);
-	}
-
 	bool Emitter::SetStringFormat(EMITTER_MANIP value)
 	{
 		return m_pState->SetStringFormat(value, GLOBAL);
@@ -93,16 +88,6 @@ 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
@@ -112,12 +97,6 @@ namespace YAML
 			return *this;
 		
 		switch(value) {
-			case BeginDoc:
-				EmitBeginDoc();
-				break;
-			case EndDoc:
-				EmitEndDoc();
-				break;
 			case BeginSeq:
 				EmitBeginSeq();
 				break;
@@ -136,12 +115,6 @@ namespace YAML
 			case Value:
 				EmitValue();
 				break;
-			case TagByKind:
-				EmitKindTag();
-				break;
-			case Newline:
-				EmitNewline();
-				break;
 			default:
 				m_pState->SetLocalValue(value);
 				break;
@@ -155,15 +128,6 @@ 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()
@@ -181,14 +145,11 @@ namespace YAML
 				return true;
 			case ES_WRITING_DOC:
 				return true;
-			case ES_DONE_WITH_DOC:
-				EmitBeginDoc();
-				return false;
 				
 				// block sequence
 			case ES_WAITING_FOR_BLOCK_SEQ_ENTRY:
 				m_stream << IndentTo(curIndent) << "-";
-				m_pState->RequireSoftSeparation();
+				m_pState->RequireSeparation();
 				m_pState->SwitchState(ES_WRITING_BLOCK_SEQ_ENTRY);
 				return true;
 			case ES_WRITING_BLOCK_SEQ_ENTRY:
@@ -205,9 +166,8 @@ namespace YAML
 			case ES_WRITING_FLOW_SEQ_ENTRY:
 				return true;
 			case ES_DONE_WITH_FLOW_SEQ_ENTRY:
-				EmitSeparationIfNecessary();
 				m_stream << ',';
-				m_pState->RequireSoftSeparation();
+				m_pState->RequireSeparation();
 				m_pState->SwitchState(ES_WAITING_FOR_FLOW_SEQ_ENTRY);
 				return false;
 				
@@ -218,7 +178,7 @@ namespace YAML
 			case ES_WAITING_FOR_BLOCK_MAP_KEY:
 				if(m_pState->CurrentlyInLongKey()) {
 					m_stream << IndentTo(curIndent) << '?';
-					m_pState->RequireSoftSeparation();
+					m_pState->RequireSeparation();
 				}
 				m_pState->SwitchState(ES_WRITING_BLOCK_MAP_KEY);
 				return true;
@@ -228,6 +188,10 @@ namespace YAML
 				m_pState->SetError(ErrorMsg::EXPECTED_VALUE_TOKEN);
 				return true;
 			case ES_WAITING_FOR_BLOCK_MAP_VALUE:
+				if(m_pState->CurrentlyInLongKey())
+					m_stream << IndentTo(curIndent);
+				m_stream << ':';
+				m_pState->RequireSeparation();
 				m_pState->SwitchState(ES_WRITING_BLOCK_MAP_VALUE);
 				return true;
 			case ES_WRITING_BLOCK_MAP_VALUE:
@@ -241,11 +205,11 @@ namespace YAML
 				m_pState->SetError(ErrorMsg::EXPECTED_KEY_TOKEN);
 				return true;
 			case ES_WAITING_FOR_FLOW_MAP_KEY:
-				EmitSeparationIfNecessary();
 				m_pState->SwitchState(ES_WRITING_FLOW_MAP_KEY);
 				if(m_pState->CurrentlyInLongKey()) {
+					EmitSeparationIfNecessary();
 					m_stream << '?';
-					m_pState->RequireSoftSeparation();
+					m_pState->RequireSeparation();
 				}
 				return true;
 			case ES_WRITING_FLOW_MAP_KEY:
@@ -254,9 +218,8 @@ namespace YAML
 				m_pState->SetError(ErrorMsg::EXPECTED_VALUE_TOKEN);
 				return true;
 			case ES_WAITING_FOR_FLOW_MAP_VALUE:
-				EmitSeparationIfNecessary();
 				m_stream << ':';
-				m_pState->RequireSoftSeparation();
+				m_pState->RequireSeparation();
 				m_pState->SwitchState(ES_WRITING_FLOW_MAP_VALUE);
 				return true;
 			case ES_WRITING_FLOW_MAP_VALUE:
@@ -310,10 +273,6 @@ namespace YAML
 				
 				// block map
 			case ES_WRITING_BLOCK_MAP_KEY:
-				if(!m_pState->CurrentlyInLongKey()) {
-					m_stream << ':';
-					m_pState->RequireSoftSeparation();
-				}
 				m_pState->SwitchState(ES_DONE_WITH_BLOCK_MAP_KEY);
 				break;
 			case ES_WRITING_BLOCK_MAP_VALUE:
@@ -340,54 +299,11 @@ namespace YAML
 		if(!good())
 			return;
 		
-		if(m_pState->RequiresSoftSeparation())
+		if(m_pState->RequiresSeparation())
 			m_stream << ' ';
-		else if(m_pState->RequiresHardSeparation())
-			m_stream << '\n';
 		m_pState->UnsetSeparation();
 	}
 	
-	// EmitBeginDoc
-	void Emitter::EmitBeginDoc()
-	{
-		if(!good())
-			return;
-		
-		EMITTER_STATE curState = m_pState->GetCurState();
-		if(curState != ES_WAITING_FOR_DOC && curState != ES_WRITING_DOC && curState != ES_DONE_WITH_DOC) {
-			m_pState->SetError("Unexpected begin document");
-			return;
-		}
-		
-		if(curState == ES_WRITING_DOC || curState == ES_DONE_WITH_DOC)
-			m_stream << '\n';		
-		m_stream << "---\n";
-
-		m_pState->UnsetSeparation();
-		m_pState->SwitchState(ES_WAITING_FOR_DOC);
-	}
-	
-	// EmitEndDoc
-	void Emitter::EmitEndDoc()
-	{
-		if(!good())
-			return;
-
-		
-		EMITTER_STATE curState = m_pState->GetCurState();
-		if(curState != ES_WAITING_FOR_DOC && curState != ES_WRITING_DOC && curState != ES_DONE_WITH_DOC) {
-			m_pState->SetError("Unexpected end document");
-			return;
-		}
-		
-		if(curState == ES_WRITING_DOC || curState == ES_DONE_WITH_DOC)
-			m_stream << '\n';		
-		m_stream << "...\n";
-		
-		m_pState->UnsetSeparation();
-		m_pState->SwitchState(ES_WAITING_FOR_DOC);
-	}
-
 	// EmitBeginSeq
 	void Emitter::EmitBeginSeq()
 	{
@@ -402,14 +318,9 @@ namespace YAML
 		EMITTER_STATE curState = m_pState->GetCurState();
 		EMITTER_MANIP flowType = m_pState->GetFlowType(GT_SEQ);
 		if(flowType == Block) {
-			if(curState == ES_WRITING_BLOCK_SEQ_ENTRY ||
-			   curState == ES_WRITING_BLOCK_MAP_KEY || curState == ES_WRITING_BLOCK_MAP_VALUE ||
-			   curState == ES_WRITING_DOC
-			) {
-				if(m_pState->RequiresHardSeparation() || curState != ES_WRITING_DOC) {
-					m_stream << "\n";
-					m_pState->UnsetSeparation();
-				}
+			if(curState == ES_WRITING_BLOCK_SEQ_ENTRY || curState == ES_WRITING_BLOCK_MAP_KEY || curState == ES_WRITING_BLOCK_MAP_VALUE) {
+				m_stream << "\n";
+				m_pState->UnsetSeparation();
 			}
 			m_pState->PushState(ES_WAITING_FOR_BLOCK_SEQ_ENTRY);
 		} else if(flowType == Flow) {
@@ -433,22 +344,12 @@ namespace YAML
 		
 		EMITTER_STATE curState = m_pState->GetCurState();
 		FLOW_TYPE flowType = m_pState->GetCurGroupFlowType();
-		if(flowType == FT_BLOCK) {
-			// Note: block sequences are *not* allowed to be empty, but we convert it
-			//       to a flow sequence if it is
-			assert(curState == ES_DONE_WITH_BLOCK_SEQ_ENTRY || curState == ES_WAITING_FOR_BLOCK_SEQ_ENTRY);
-			if(curState == ES_WAITING_FOR_BLOCK_SEQ_ENTRY) {
-				// Note: only one of these will actually output anything for a given situation
-				EmitSeparationIfNecessary();
-				unsigned curIndent = m_pState->GetCurIndent();
-				m_stream << IndentTo(curIndent);
-
-				m_stream << "[]";
-			}
-		} else if(flowType == FT_FLOW) {
+		if(flowType == FT_BLOCK)
+			assert(curState == ES_DONE_WITH_BLOCK_SEQ_ENTRY);
+		else if(flowType == FT_FLOW) {
+			m_stream << "]";
 			// Note: flow sequences are allowed to be empty
 			assert(curState == ES_DONE_WITH_FLOW_SEQ_ENTRY || curState == ES_WAITING_FOR_FLOW_SEQ_ENTRY);
-			m_stream << "]";
 		} else
 			assert(false);
 		
@@ -472,14 +373,9 @@ namespace YAML
 		EMITTER_STATE curState = m_pState->GetCurState();
 		EMITTER_MANIP flowType = m_pState->GetFlowType(GT_MAP);
 		if(flowType == Block) {
-			if(curState == ES_WRITING_BLOCK_SEQ_ENTRY ||
-			   curState == ES_WRITING_BLOCK_MAP_KEY || curState == ES_WRITING_BLOCK_MAP_VALUE ||
-			   curState == ES_WRITING_DOC
-			) {
-				if(m_pState->RequiresHardSeparation() || (curState != ES_WRITING_DOC && curState != ES_WRITING_BLOCK_SEQ_ENTRY)) {
-					m_stream << "\n";
-					m_pState->UnsetSeparation();
-				}
+			if(curState == ES_WRITING_BLOCK_SEQ_ENTRY || curState == ES_WRITING_BLOCK_MAP_KEY || curState == ES_WRITING_BLOCK_MAP_VALUE) {
+				m_stream << "\n";
+				m_pState->UnsetSeparation();
 			}
 			m_pState->PushState(ES_WAITING_FOR_BLOCK_MAP_ENTRY);
 		} else if(flowType == Flow) {
@@ -503,22 +399,12 @@ namespace YAML
 
 		EMITTER_STATE curState = m_pState->GetCurState();
 		FLOW_TYPE flowType = m_pState->GetCurGroupFlowType();
-		if(flowType == FT_BLOCK) {
-			// Note: block sequences are *not* allowed to be empty, but we convert it
-			//       to a flow sequence if it is
-			assert(curState == ES_DONE_WITH_BLOCK_MAP_VALUE || curState == ES_WAITING_FOR_BLOCK_MAP_ENTRY);
-			if(curState == ES_WAITING_FOR_BLOCK_MAP_ENTRY) {
-				// Note: only one of these will actually output anything for a given situation
-				EmitSeparationIfNecessary();
-				unsigned curIndent = m_pState->GetCurIndent();
-				m_stream << IndentTo(curIndent);
-				m_stream << "{}";
-			}
-		} else if(flowType == FT_FLOW) {
+		if(flowType == FT_BLOCK)
+			assert(curState == ES_DONE_WITH_BLOCK_MAP_VALUE);
+		else if(flowType == FT_FLOW) {
+			m_stream << "}";
 			// Note: flow maps are allowed to be empty
 			assert(curState == ES_DONE_WITH_FLOW_MAP_VALUE || curState == ES_WAITING_FOR_FLOW_MAP_ENTRY);
-			EmitSeparationIfNecessary();
-			m_stream << "}";
 		} else
 			assert(false);
 		
@@ -545,13 +431,11 @@ namespace YAML
 				m_stream << '\n';
 			unsigned curIndent = m_pState->GetCurIndent();
 			m_stream << IndentTo(curIndent);
-			m_pState->UnsetSeparation();
 			m_pState->SwitchState(ES_WAITING_FOR_BLOCK_MAP_KEY);
 		} else if(flowType == FT_FLOW) {
-			EmitSeparationIfNecessary();
 			if(curState == ES_DONE_WITH_FLOW_MAP_VALUE) {
 				m_stream << ',';
-				m_pState->RequireSoftSeparation();
+				m_pState->RequireSeparation();
 			}
 			m_pState->SwitchState(ES_WAITING_FOR_FLOW_MAP_KEY);
 		} else
@@ -577,12 +461,8 @@ namespace YAML
 			return m_pState->SetError(ErrorMsg::UNEXPECTED_VALUE_TOKEN);
 
 		if(flowType == FT_BLOCK) {
-			if(m_pState->CurrentlyInLongKey()) {
+			if(m_pState->CurrentlyInLongKey())
 				m_stream << '\n';
-				m_stream << IndentTo(m_pState->GetCurIndent());
-				m_stream << ':';
-				m_pState->RequireSoftSeparation();
-			}
 			m_pState->SwitchState(ES_WAITING_FOR_BLOCK_MAP_VALUE);
 		} else if(flowType == FT_FLOW) {
 			m_pState->SwitchState(ES_WAITING_FOR_FLOW_MAP_VALUE);
@@ -590,28 +470,6 @@ namespace YAML
 			assert(false);
 	}
 
-	// EmitNewline
-	void Emitter::EmitNewline()
-	{
-		if(!good())
-			return;
-
-		if(CanEmitNewline()) {
-			m_stream << '\n';
-			m_pState->UnsetSeparation();
-		}
-	}
-
-	bool Emitter::CanEmitNewline() const
-	{
-		FLOW_TYPE flowType = m_pState->GetCurGroupFlowType();
-		if(flowType == FT_BLOCK && m_pState->CurrentlyInLongKey())
-			return true;
-
-		EMITTER_STATE curState = m_pState->GetCurState();
-		return curState != ES_DONE_WITH_BLOCK_MAP_KEY && curState != ES_WAITING_FOR_BLOCK_MAP_VALUE && curState != ES_WRITING_BLOCK_MAP_VALUE;
-	}
-
 	// *******************************************************************************************
 	// overloads of Write
 	
@@ -627,14 +485,13 @@ namespace YAML
 		PreAtomicWrite();
 		EmitSeparationIfNecessary();
 		
-		bool escapeNonAscii = m_pState->GetOutputCharset() == EscapeNonAscii;
 		EMITTER_MANIP strFmt = m_pState->GetStringFormat();
 		FLOW_TYPE flowType = m_pState->GetCurGroupFlowType();
 		unsigned curIndent = m_pState->GetCurIndent();
 
 		switch(strFmt) {
 			case Auto:
-				Utils::WriteString(m_stream, str, flowType == FT_FLOW, escapeNonAscii);
+				Utils::WriteString(m_stream, str, flowType == FT_FLOW);
 				break;
 			case SingleQuoted:
 				if(!Utils::WriteSingleQuotedString(m_stream, str)) {
@@ -643,11 +500,11 @@ namespace YAML
 				}
 				break;
 			case DoubleQuoted:
-				Utils::WriteDoubleQuotedString(m_stream, str, escapeNonAscii);
+				Utils::WriteDoubleQuotedString(m_stream, str);
 				break;
 			case Literal:
 				if(flowType == FT_FLOW)
-					Utils::WriteString(m_stream, str, flowType == FT_FLOW, escapeNonAscii);
+					Utils::WriteString(m_stream, str, flowType == FT_FLOW);
 				else
 					Utils::WriteLiteralString(m_stream, str, curIndent + m_pState->GetIndent());
 				break;
@@ -658,93 +515,46 @@ namespace YAML
 		PostAtomicWrite();
 		return *this;
 	}
-
-	void Emitter::PreWriteIntegralType(std::stringstream& str)
+	
+	Emitter& Emitter::Write(const char *str)
 	{
+		if(!good())
+			return *this;
+		
+		return Write(std::string(str));
+	}
+	
+	Emitter& Emitter::Write(int i)
+	{
+		if(!good())
+			return *this;
+		
 		PreAtomicWrite();
 		EmitSeparationIfNecessary();
 		
 		EMITTER_MANIP intFmt = m_pState->GetIntFormat();
+		std::stringstream str;
 		switch(intFmt) {
 			case Dec:
 				str << std::dec;
 				break;
 			case Hex:
-                str << "0x";
 				str << std::hex;
 				break;
 			case Oct:
-                str << "0";
 				str << std::oct;
 				break;
 			default:
 				assert(false);
 		}
-	}
-
-	void Emitter::PreWriteStreamable(std::stringstream&)
-	{
-		PreAtomicWrite();
-		EmitSeparationIfNecessary();
-	}
-
-    unsigned Emitter::GetFloatPrecision() const
-    {
-        return m_pState->GetFloatPrecision();
-    }
-    
-    unsigned Emitter::GetDoublePrecision() const
-    {
-        return m_pState->GetDoublePrecision();
-    }
-
-	void Emitter::PostWriteIntegralType(const std::stringstream& str)
-	{
+		
+		str << i;
 		m_stream << str.str();
+		
 		PostAtomicWrite();
+		return *this;
 	}
-
-	void Emitter::PostWriteStreamable(const std::stringstream& str)
-	{
-		m_stream << str.str();
-		PostAtomicWrite();
-	}
-
-	const char *Emitter::ComputeFullBoolName(bool b) const
-	{
-		const EMITTER_MANIP mainFmt = (m_pState->GetBoolLengthFormat() == ShortBool ? YesNoBool : m_pState->GetBoolFormat());
-		const EMITTER_MANIP caseFmt = m_pState->GetBoolCaseFormat();
-		switch(mainFmt) {
-			case YesNoBool:
-				switch(caseFmt) {
-					case UpperCase: return b ? "YES" : "NO";
-					case CamelCase: return b ? "Yes" : "No";
-					case LowerCase: return b ? "yes" : "no";
-					default: break;
-				}
-				break;
-			case OnOffBool:
-				switch(caseFmt) {
-					case UpperCase: return b ? "ON" : "OFF";
-					case CamelCase: return b ? "On" : "Off";
-					case LowerCase: return b ? "on" : "off";
-					default: break;
-				}
-				break;
-			case TrueFalseBool:
-				switch(caseFmt) {
-					case UpperCase: return b ? "TRUE" : "FALSE";
-					case CamelCase: return b ? "True" : "False";
-					case LowerCase: return b ? "true" : "false";
-					default: break;
-				}
-				break;
-			default:
-				break;
-		}
-		return b ? "y" : "n"; // should never get here, but it can't hurt to give these answers
-	}
-
+	
 	Emitter& Emitter::Write(bool b)
 	{
 		if(!good())
@@ -752,18 +562,39 @@ namespace YAML
 		
 		PreAtomicWrite();
 		EmitSeparationIfNecessary();
-	
-		const char *name = ComputeFullBoolName(b);
-		if(m_pState->GetBoolLengthFormat() == ShortBool)
+		
+		// set up all possible bools to write
+		struct BoolName { std::string trueName, falseName; };
+		struct BoolFormatNames { BoolName upper, lower, camel; };
+		struct BoolTypes { BoolFormatNames yesNo, trueFalse, onOff; };
+		
+		static const BoolTypes boolTypes = {
+			{ { "YES", "NO" }, { "yes", "no" }, { "Yes", "No" } },
+			{ { "TRUE", "FALSE" }, { "true", "false" }, { "True", "False" } },
+			{ { "ON", "OFF" }, { "on", "off" }, { "On", "Off" } }
+		};
+
+		// select the right one
+		EMITTER_MANIP boolFmt = m_pState->GetBoolFormat();
+		EMITTER_MANIP boolLengthFmt = m_pState->GetBoolLengthFormat();
+		EMITTER_MANIP boolCaseFmt = m_pState->GetBoolCaseFormat();
+		
+		const BoolFormatNames& fmtNames = (boolFmt == YesNoBool ? boolTypes.yesNo : boolFmt == TrueFalseBool ? boolTypes.trueFalse : boolTypes.onOff);
+		const BoolName& boolName = (boolCaseFmt == UpperCase ? fmtNames.upper : boolCaseFmt == LowerCase ? fmtNames.lower : fmtNames.camel);
+		const std::string& name = (b ? boolName.trueName : boolName.falseName);
+		
+		// and say it!
+		// TODO: should we disallow writing OnOffBool with ShortBool? (it'll just print "o" for both, which is silly)
+		if(boolLengthFmt == ShortBool)
 			m_stream << name[0];
 		else
 			m_stream << name;
-
+		
 		PostAtomicWrite();
 		return *this;
 	}
 
-	Emitter& Emitter::Write(char ch)
+	Emitter& Emitter::Write(float f)
 	{
 		if(!good())
 			return *this;
@@ -771,10 +602,28 @@ namespace YAML
 		PreAtomicWrite();
 		EmitSeparationIfNecessary();
 		
-		Utils::WriteChar(m_stream, ch);
+		std::stringstream str;
+		str << f;
+		m_stream << str.str();
 		
 		PostAtomicWrite();
-		return *this;
+		return *this;		
+	}
+	
+	Emitter& Emitter::Write(double d)
+	{
+		if(!good())
+			return *this;
+		
+		PreAtomicWrite();
+		EmitSeparationIfNecessary();
+		
+		std::stringstream str;
+		str << d;
+		m_stream << str.str();
+		
+		PostAtomicWrite();
+		return *this;		
 	}
 
 	Emitter& Emitter::Write(const _Alias& alias)
@@ -803,53 +652,18 @@ namespace YAML
 			m_pState->SetError(ErrorMsg::INVALID_ANCHOR);
 			return *this;
 		}
-		m_pState->RequireHardSeparation();
+		m_pState->RequireSeparation();
 		// Note: no PostAtomicWrite() because we need another value for this node
 		return *this;
 	}
 	
-	Emitter& Emitter::Write(const _Tag& tag)
-	{
-		if(!good())
-			return *this;
-
-		PreAtomicWrite();
-		EmitSeparationIfNecessary();
-		
-		bool success = false;
-		if(tag.type == _Tag::Type::Verbatim)
-			success = Utils::WriteTag(m_stream, tag.content, true);
-		else if(tag.type == _Tag::Type::PrimaryHandle)
-			success = Utils::WriteTag(m_stream, tag.content, false);
-		else
-			success = Utils::WriteTagWithPrefix(m_stream, tag.prefix, tag.content);
-		
-		if(!success) {
-			m_pState->SetError(ErrorMsg::INVALID_TAG);
-			return *this;
-		}
-		
-		m_pState->RequireHardSeparation();
-		// Note: no PostAtomicWrite() because we need another value for this node
-		return *this;
-	}
-
-	void Emitter::EmitKindTag()
-	{
-		Write(LocalTag(""));
-	}
-
 	Emitter& Emitter::Write(const _Comment& comment)
 	{
 		if(!good())
 			return *this;
 		
-		if(m_stream.col() > 0)
-			m_stream << Indentation(m_pState->GetPreCommentIndent());
+		m_stream << Indentation(m_pState->GetPreCommentIndent());
 		Utils::WriteComment(m_stream, comment.content, m_pState->GetPostCommentIndent());
-		m_pState->RequireHardSeparation();
-		m_pState->ForceHardSeparation();
-		
 		return *this;
 	}
 
@@ -864,19 +678,4 @@ namespace YAML
 		PostAtomicWrite();
 		return *this;
 	}
-
-	Emitter& Emitter::Write(const Binary& binary)
-	{
-		Write(SecondaryTag("binary"));
-
-		if(!good())
-			return *this;
-		
-		PreAtomicWrite();
-		EmitSeparationIfNecessary();
-		Utils::WriteBinary(m_stream, binary);
-		PostAtomicWrite();
-		return *this;
-	}
 }
-

src/emitterstate.cpp

@@ -1,16 +1,14 @@
 #include "emitterstate.h"
-#include "yaml-cpp/exceptions.h"
-#include <limits>
+#include "exceptions.h"
 
 namespace YAML
 {
-	EmitterState::EmitterState(): m_isGood(true), m_curIndent(0), m_requiresSoftSeparation(false), m_requiresHardSeparation(false)
+	EmitterState::EmitterState(): m_isGood(true), m_curIndent(0), m_requiresSeparation(false)
 	{
 		// start up
 		m_stateStack.push(ES_WAITING_FOR_DOC);
 		
 		// set default global manipulators
-		m_charset.set(EmitNonAscii);
 		m_strFmt.set(Auto);
 		m_boolFmt.set(TrueFalseBool);
 		m_boolLengthFmt.set(LongBool);
@@ -22,12 +20,22 @@ namespace YAML
 		m_seqFmt.set(Block);
 		m_mapFmt.set(Block);
 		m_mapKeyFmt.set(Auto);
-        m_floatPrecision.set(6);
-        m_doublePrecision.set(15);
 	}
 	
 	EmitterState::~EmitterState()
 	{
+		while(!m_groups.empty())
+			_PopGroup();
+	}
+	
+	std::auto_ptr <EmitterState::Group> EmitterState::_PopGroup()
+	{
+		if(m_groups.empty())
+			return std::auto_ptr <Group> (0);
+		
+		std::auto_ptr <Group> pGroup(m_groups.top());
+		m_groups.pop();
+		return pGroup;
 	}
 
 	// SetLocalValue
@@ -35,7 +43,6 @@ namespace YAML
 	// . Only the ones that make sense will be accepted
 	void EmitterState::SetLocalValue(EMITTER_MANIP value)
 	{
-		SetOutputCharset(value, LOCAL);
 		SetStringFormat(value, LOCAL);
 		SetBoolFormat(value, LOCAL);
 		SetBoolCaseFormat(value, LOCAL);
@@ -48,10 +55,10 @@ namespace YAML
 	
 	void EmitterState::BeginGroup(GROUP_TYPE type)
 	{
-		unsigned lastIndent = (m_groups.empty() ? 0 : m_groups.top().indent);
+		unsigned lastIndent = (m_groups.empty() ? 0 : m_groups.top()->indent);
 		m_curIndent += lastIndent;
 		
-		std::auto_ptr<Group> pGroup(new Group(type));
+		std::auto_ptr <Group> pGroup(new Group(type));
 		
 		// transfer settings (which last until this group is done)
 		pGroup->modifiedSettings = m_modifiedSettings;
@@ -61,7 +68,7 @@ namespace YAML
 		pGroup->indent = GetIndent();
 		pGroup->usingLongKey = (GetMapKeyFormat() == LongKey ? true : false);
 
-		m_groups.push(pGroup);
+		m_groups.push(pGroup.release());
 	}
 	
 	void EmitterState::EndGroup(GROUP_TYPE type)
@@ -71,13 +78,13 @@ namespace YAML
 		
 		// get rid of the current group
 		{
-			std::auto_ptr<Group> pFinishedGroup = m_groups.pop();
+			std::auto_ptr <Group> pFinishedGroup = _PopGroup();
 			if(pFinishedGroup->type != type)
 				return SetError(ErrorMsg::UNMATCHED_GROUP_TAG);
 		}
 
 		// reset old settings
-		unsigned lastIndent = (m_groups.empty() ? 0 : m_groups.top().indent);
+		unsigned lastIndent = (m_groups.empty() ? 0 : m_groups.top()->indent);
 		assert(m_curIndent >= lastIndent);
 		m_curIndent -= lastIndent;
 		
@@ -91,7 +98,7 @@ namespace YAML
 		if(m_groups.empty())
 			return GT_NONE;
 		
-		return m_groups.top().type;
+		return m_groups.top()->type;
 	}
 	
 	FLOW_TYPE EmitterState::GetCurGroupFlowType() const
@@ -99,44 +106,32 @@ namespace YAML
 		if(m_groups.empty())
 			return FT_NONE;
 		
-		return (m_groups.top().flow == Flow ? FT_FLOW : FT_BLOCK);
+		return (m_groups.top()->flow == Flow ? FT_FLOW : FT_BLOCK);
 	}
 	
 	bool EmitterState::CurrentlyInLongKey()
 	{
 		if(m_groups.empty())
 			return false;
-		return m_groups.top().usingLongKey;
+		return m_groups.top()->usingLongKey;
 	}
 	
 	void EmitterState::StartLongKey()
 	{
 		if(!m_groups.empty())
-			m_groups.top().usingLongKey = true;
+			m_groups.top()->usingLongKey = true;
 	}
 	
 	void EmitterState::StartSimpleKey()
 	{
 		if(!m_groups.empty())
-			m_groups.top().usingLongKey = false;
+			m_groups.top()->usingLongKey = false;
 	}
 
 	void EmitterState::ClearModifiedSettings()
 	{
 		m_modifiedSettings.clear();
 	}
-
-	bool EmitterState::SetOutputCharset(EMITTER_MANIP value, FMT_SCOPE scope)
-	{
-		switch(value) {
-			case EmitNonAscii:
-			case EscapeNonAscii:
-				_Set(m_charset, value, scope);
-				return true;
-			default:
-				return false;
-		}
-	}
 	
 	bool EmitterState::SetStringFormat(EMITTER_MANIP value, FMT_SCOPE scope)
 	{
@@ -264,21 +259,5 @@ 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

@@ -1,14 +1,11 @@
+#pragma once
+
 #ifndef EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITTERSTATE_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 "ptr_stack.h"
 #include "setting.h"
-#include "yaml-cpp/emittermanip.h"
+#include "emittermanip.h"
 #include <cassert>
 #include <vector>
 #include <stack>
@@ -104,19 +101,13 @@ namespace YAML
 		void StartLongKey();
 		void StartSimpleKey();
 
-		bool RequiresSoftSeparation() const { return m_requiresSoftSeparation; }
-		bool RequiresHardSeparation() const { return m_requiresHardSeparation; }
-		void RequireSoftSeparation() { m_requiresSoftSeparation = true; }
-		void RequireHardSeparation() { m_requiresSoftSeparation = true; m_requiresHardSeparation = true; }
-		void ForceHardSeparation() { m_requiresSoftSeparation = false; }
-		void UnsetSeparation() { m_requiresSoftSeparation = false; m_requiresHardSeparation = false; }
+		bool RequiresSeparation() const { return m_requiresSeparation; }
+		void RequireSeparation() { m_requiresSeparation = true; }
+		void UnsetSeparation() { m_requiresSeparation = false; }
 
 		void ClearModifiedSettings();
 
 		// formatters
-		bool SetOutputCharset(EMITTER_MANIP value, FMT_SCOPE scope);
-		EMITTER_MANIP GetOutputCharset() const { return m_charset.get(); }
-
 		bool SetStringFormat(EMITTER_MANIP value, FMT_SCOPE scope);
 		EMITTER_MANIP GetStringFormat() const { return m_strFmt.get(); }
 		
@@ -145,11 +136,6 @@ 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>
@@ -161,21 +147,18 @@ namespace YAML
 		std::string m_lastError;
 		
 		// other state
-		std::stack<EMITTER_STATE> m_stateStack;
+		std::stack <EMITTER_STATE> m_stateStack;
 		
-		Setting<EMITTER_MANIP> m_charset;
-		Setting<EMITTER_MANIP> m_strFmt;
-		Setting<EMITTER_MANIP> m_boolFmt;
-		Setting<EMITTER_MANIP> m_boolLengthFmt;
-		Setting<EMITTER_MANIP> m_boolCaseFmt;
-		Setting<EMITTER_MANIP> m_intFmt;
-		Setting<unsigned> m_indent;
-		Setting<unsigned> m_preCommentIndent, m_postCommentIndent;
-		Setting<EMITTER_MANIP> m_seqFmt;
-		Setting<EMITTER_MANIP> m_mapFmt;
-		Setting<EMITTER_MANIP> m_mapKeyFmt;
-        Setting<int> m_floatPrecision;
-        Setting<int> m_doublePrecision;
+		Setting <EMITTER_MANIP> m_strFmt;
+		Setting <EMITTER_MANIP> m_boolFmt;
+		Setting <EMITTER_MANIP> m_boolLengthFmt;
+		Setting <EMITTER_MANIP> m_boolCaseFmt;
+		Setting <EMITTER_MANIP> m_intFmt;
+		Setting <unsigned> m_indent;
+		Setting <unsigned> m_preCommentIndent, m_postCommentIndent;
+		Setting <EMITTER_MANIP> m_seqFmt;
+		Setting <EMITTER_MANIP> m_mapFmt;
+		Setting <EMITTER_MANIP> m_mapKeyFmt;
 		
 		SettingChanges m_modifiedSettings;
 		SettingChanges m_globalModifiedSettings;
@@ -190,11 +173,12 @@ namespace YAML
 			
 			SettingChanges modifiedSettings;
 		};
-
-		ptr_stack<Group> m_groups;
+		
+		std::auto_ptr <Group> _PopGroup();
+		
+		std::stack <Group *> m_groups;
 		unsigned m_curIndent;
-		bool m_requiresSoftSeparation;
-		bool m_requiresHardSeparation;
+		bool m_requiresSeparation;
 	};
 
 	template <typename T>

src/emitterutils.cpp

@@ -1,8 +1,7 @@
 #include "emitterutils.h"
 #include "exp.h"
 #include "indentation.h"
-#include "yaml-cpp/binary.h"
-#include "yaml-cpp/exceptions.h"
+#include "exceptions.h"
 #include "stringsource.h"
 #include <sstream>
 #include <iomanip>
@@ -12,128 +11,13 @@ namespace YAML
 	namespace Utils
 	{
 		namespace {
-			enum {REPLACEMENT_CHARACTER = 0xFFFD};
-
-			bool IsAnchorChar(int ch) { // test for ns-anchor-char
-				switch (ch) {
-					case ',': case '[': case ']': case '{': case '}': // c-flow-indicator
-					case ' ': case '\t': // s-white
-					case 0xFEFF: // c-byte-order-mark
-					case 0xA: case 0xD: // b-char
-						return false;
-					case 0x85:
-						return true;
-				}
-
-				if (ch < 0x20)
-					return false;
-
-				if (ch < 0x7E)
-					return true;
-
-				if (ch < 0xA0)
-					return false;
-				if (ch >= 0xD800 && ch <= 0xDFFF)
-					return false;
-				if ((ch & 0xFFFE) == 0xFFFE)
-					return false;
-				if ((ch >= 0xFDD0) && (ch <= 0xFDEF))
-					return false;
-				if (ch > 0x10FFFF)
-					return false;
-
-				return true;
+			bool IsPrintable(char ch) {
+				return (0x20 <= ch && ch <= 0x7E);
 			}
 			
-			int Utf8BytesIndicated(char ch) {
-				int byteVal = static_cast<unsigned char>(ch);
-				switch (byteVal >> 4) {
-					case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
-						return 1;
-					case 12: case 13:
-						return 2;
-					case 14:
-						return 3;
-					case 15:
-						return 4;
-					default:
-					  return -1;
-				}
-			}
-
-			bool IsTrailingByte(char ch) {
-				return (ch & 0xC0) == 0x80;
-			}
-			
-			bool GetNextCodePointAndAdvance(int& codePoint, std::string::const_iterator& first, std::string::const_iterator last) {
-				if (first == last)
-					return false;
-				
-				int nBytes = Utf8BytesIndicated(*first);
-				if (nBytes < 1) {
-					// Bad lead byte
-					++first;
-					codePoint = REPLACEMENT_CHARACTER;
-					return true;
-				}
-				
-				if (nBytes == 1) {
-					codePoint = *first++;
-					return true;
-				}
-				
-				// Gather bits from trailing bytes
-				codePoint = static_cast<unsigned char>(*first) & ~(0xFF << (7 - nBytes));
-				++first;
-				--nBytes;
-				for (; nBytes > 0; ++first, --nBytes) {
-					if ((first == last) || !IsTrailingByte(*first)) {
-						codePoint = REPLACEMENT_CHARACTER;
-						break;
-					}
-					codePoint <<= 6;
-					codePoint |= *first & 0x3F;
-				}
-
-				// Check for illegal code points
-				if (codePoint > 0x10FFFF)
-					codePoint = REPLACEMENT_CHARACTER;
-				else if (codePoint >= 0xD800 && codePoint <= 0xDFFF)
-					codePoint = REPLACEMENT_CHARACTER;
-				else if ((codePoint & 0xFFFE) == 0xFFFE)
-					codePoint = REPLACEMENT_CHARACTER;
-				else if (codePoint >= 0xFDD0 && codePoint <= 0xFDEF)
-					codePoint = REPLACEMENT_CHARACTER;
-				return true;
-			}
-			
-			void WriteCodePoint(ostream& out, int codePoint) {
-				if (codePoint < 0 || codePoint > 0x10FFFF) {
-					codePoint = REPLACEMENT_CHARACTER;
-				}
-				if (codePoint < 0x7F) {
-					out << static_cast<char>(codePoint);
-				} else if (codePoint < 0x7FF) {
-					out << static_cast<char>(0xC0 | (codePoint >> 6))
-					    << static_cast<char>(0x80 | (codePoint & 0x3F));
-				} else if (codePoint < 0xFFFF) {
-					out << static_cast<char>(0xE0 | (codePoint >> 12))
-					    << static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F))
-					    << static_cast<char>(0x80 | (codePoint & 0x3F));
-				} else {
-					out << static_cast<char>(0xF0 | (codePoint >> 18))
-					    << static_cast<char>(0x80 | ((codePoint >> 12) & 0x3F))
-					    << static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F))
-					    << static_cast<char>(0x80 | (codePoint & 0x3F));
-				}
-			}
-			
-			bool IsValidPlainScalar(const std::string& str, bool inFlow, bool allowOnlyAscii) {
-				if(str.empty())
-					return false;
-				
+			bool IsValidPlainScalar(const std::string& str, bool inFlow) {
 				// first check the start
-				const RegEx& start = (inFlow ? Exp::PlainScalarInFlow() : Exp::PlainScalar());
+				const RegEx& start = (inFlow ? Exp::PlainScalarInFlow : Exp::PlainScalar);
 				if(!start.Matches(str))
 					return false;
 				
@@ -142,111 +26,66 @@ namespace YAML
 					return false;
 
 				// then check until something is disallowed
-				const RegEx& disallowed = (inFlow ? Exp::EndScalarInFlow() : Exp::EndScalar())
-				                          || (Exp::BlankOrBreak() + Exp::Comment())
-				                          || Exp::NotPrintable()
-				                          || Exp::Utf8_ByteOrderMark()
-				                          || Exp::Break()
-				                          || Exp::Tab();
+				const RegEx& disallowed = (inFlow ? Exp::EndScalarInFlow : Exp::EndScalar)
+				                          || (Exp::BlankOrBreak + Exp::Comment)
+				                          || (!Exp::Printable)
+				                          || Exp::Break
+				                          || Exp::Tab;
 				StringCharSource buffer(str.c_str(), str.size());
 				while(buffer) {
 					if(disallowed.Matches(buffer))
 						return false;
-					if(allowOnlyAscii && (0x7F < static_cast<unsigned char>(buffer[0]))) 
-						return false;
 					++buffer;
 				}
 				
 				return true;
 			}
-
-			void WriteDoubleQuoteEscapeSequence(ostream& out, int codePoint) {
-				static const char hexDigits[] = "0123456789abcdef";
-
-				char escSeq[] = "\\U00000000";
-				int digits = 8;
-				if (codePoint < 0xFF) {
-					escSeq[1] = 'x';
-					digits = 2;
-				} else if (codePoint < 0xFFFF) {
-					escSeq[1] = 'u';
-					digits = 4;
-				}
-
-				// Write digits into the escape sequence
-				int i = 2;
-				for (; digits > 0; --digits, ++i) {
-					escSeq[i] = hexDigits[(codePoint >> (4 * (digits - 1))) & 0xF];
-				}
-
-				escSeq[i] = 0; // terminate with NUL character
-				out << escSeq;
-			}
-
-			bool WriteAliasName(ostream& out, const std::string& str) {
-				int codePoint;
-				for(std::string::const_iterator i = str.begin();
-					GetNextCodePointAndAdvance(codePoint, i, str.end());
-					)
-				{
-					if (!IsAnchorChar(codePoint))
-						return false;
-
-					WriteCodePoint(out, codePoint);
-				}
-				return true;
-			}
 		}
 		
-		bool WriteString(ostream& out, const std::string& str, bool inFlow, bool escapeNonAscii)
+		bool WriteString(ostream& out, const std::string& str, bool inFlow)
 		{
-			if(IsValidPlainScalar(str, inFlow, escapeNonAscii)) {
+			if(IsValidPlainScalar(str, inFlow)) {
 				out << str;
 				return true;
 			} else
-				return WriteDoubleQuotedString(out, str, escapeNonAscii);
+				return WriteDoubleQuotedString(out, str);
 		}
 		
 		bool WriteSingleQuotedString(ostream& out, const std::string& str)
 		{
 			out << "'";
-			int codePoint;
-			for(std::string::const_iterator i = str.begin();
-				GetNextCodePointAndAdvance(codePoint, i, str.end());
-				) 
-			{
-				if (codePoint == '\n')
-					return false;  // We can't handle a new line and the attendant indentation yet
-
-				if (codePoint == '\'')
+			for(std::size_t i=0;i<str.size();i++) {
+				char ch = str[i];
+				if(!IsPrintable(ch))
+					return false;
+				
+				if(ch == '\'')
 					out << "''";
 				else
-					WriteCodePoint(out, codePoint);
+					out << ch;
 			}
 			out << "'";
 			return true;
 		}
 		
-		bool WriteDoubleQuotedString(ostream& out, const std::string& str, bool escapeNonAscii)
+		bool WriteDoubleQuotedString(ostream& out, const std::string& str)
 		{
 			out << "\"";
-			int codePoint;
-			for(std::string::const_iterator i = str.begin();
-				GetNextCodePointAndAdvance(codePoint, i, str.end());
-				) 
-			{
-				if (codePoint == '\"')
-					out << "\\\"";
-				else if (codePoint == '\\')
-					out << "\\\\";
-				else if (codePoint < 0x20 || (codePoint >= 0x80 && codePoint <= 0xA0)) // Control characters and non-breaking space
-					WriteDoubleQuoteEscapeSequence(out, codePoint);
-				else if (codePoint == 0xFEFF) // Byte order marks (ZWNS) should be escaped (YAML 1.2, sec. 5.2)	
-					WriteDoubleQuoteEscapeSequence(out, codePoint);
-				else if (escapeNonAscii && codePoint > 0x7E)
-					WriteDoubleQuoteEscapeSequence(out, codePoint);
-				else
-					WriteCodePoint(out, codePoint);
+			for(std::size_t i=0;i<str.size();i++) {
+				char ch = str[i];
+				if(IsPrintable(ch)) {
+					if(ch == '\"')
+						out << "\\\"";
+					else if(ch == '\\')
+						out << "\\\\";
+					else
+						out << ch;
+				} else {
+					// TODO: for the common escaped characters, give their usual symbol
+					std::stringstream str;
+					str << "\\x" << std::hex << std::setfill('0') << std::setw(2) << static_cast <int>(ch);
+					out << str.str();
+				}
 			}
 			out << "\"";
 			return true;
@@ -256,52 +95,24 @@ namespace YAML
 		{
 			out << "|\n";
 			out << IndentTo(indent);
-			int codePoint;
-			for(std::string::const_iterator i = str.begin();
-				GetNextCodePointAndAdvance(codePoint, i, str.end());
-				)
-			{
-				if (codePoint == '\n')
-				  out << "\n" << IndentTo(indent);
+			for(std::size_t i=0;i<str.size();i++) {
+				if(str[i] == '\n')
+					out << "\n" << IndentTo(indent);
 				else
-				  WriteCodePoint(out, codePoint);
+					out << str[i];
 			}
 			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();
+			unsigned curIndent = out.col();
 			out << "#" << Indentation(postCommentIndent);
-			int codePoint;
-			for(std::string::const_iterator i = str.begin();
-				GetNextCodePointAndAdvance(codePoint, i, str.end());
-				)
-			{
-				if(codePoint == '\n')
+			for(std::size_t i=0;i<str.size();i++) {
+				if(str[i] == '\n')
 					out << "\n" << IndentTo(curIndent) << "#" << Indentation(postCommentIndent);
 				else
-					WriteCodePoint(out, codePoint);
+					out << str[i];
 			}
 			return true;
 		}
@@ -309,70 +120,26 @@ namespace YAML
 		bool WriteAlias(ostream& out, const std::string& str)
 		{
 			out << "*";
-			return WriteAliasName(out, str);
+			for(std::size_t i=0;i<str.size();i++) {
+				if(!IsPrintable(str[i]) || str[i] == ' ' || str[i] == '\t' || str[i] == '\n' || str[i] == '\r')
+					return false;
+				
+				out << str[i];
+			}
+			return true;
 		}
 		
 		bool WriteAnchor(ostream& out, const std::string& str)
 		{
 			out << "&";
-			return WriteAliasName(out, str);
-		}
-
-		bool WriteTag(ostream& out, const std::string& str, bool verbatim)
-		{
-			out << (verbatim ? "!<" : "!");
-			StringCharSource buffer(str.c_str(), str.size());
-			const RegEx& reValid = verbatim ? Exp::URI() : Exp::Tag();
-			while(buffer) {
-				int n = reValid.Match(buffer);
-				if(n <= 0)
-					return false;
-
-				while(--n >= 0) {
-					out << buffer[0];
-					++buffer;
-				}
-			}
-			if (verbatim)
-				out << ">";
-			return true;
-		}
-
-		bool WriteTagWithPrefix(ostream& out, const std::string& prefix, const std::string& tag)
-		{
-			out << "!";
-			StringCharSource prefixBuffer(prefix.c_str(), prefix.size());
-			while(prefixBuffer) {
-				int n = Exp::URI().Match(prefixBuffer);
-				if(n <= 0)
+			for(std::size_t i=0;i<str.size();i++) {
+				if(!IsPrintable(str[i]) || str[i] == ' ' || str[i] == '\t' || str[i] == '\n' || str[i] == '\r')
 					return false;
 				
-				while(--n >= 0) {
-					out << prefixBuffer[0];
-					++prefixBuffer;
-				}
-			}
-
-			out << "!";
-			StringCharSource tagBuffer(tag.c_str(), tag.size());
-			while(tagBuffer) {
-				int n = Exp::Tag().Match(tagBuffer);
-				if(n <= 0)
-					return false;
-				
-				while(--n >= 0) {
-					out << tagBuffer[0];
-					++tagBuffer;
-				}
+				out << str[i];
 			}
 			return true;
 		}
-
-		bool WriteBinary(ostream& out, const Binary& binary)
-		{
-            WriteDoubleQuotedString(out, EncodeBase64(binary.data(), binary.size()), false);
-            return true;
-		}
 	}
 }
 

src/emitterutils.h

@@ -1,31 +1,23 @@
+#pragma once
+
 #ifndef EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITTERUTILS_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/ostream.h"
+#include "ostream.h"
 #include <string>
 
 namespace YAML
 {
-    class Binary;
-    
 	namespace Utils
 	{
-		bool WriteString(ostream& out, const std::string& str, bool inFlow, bool escapeNonAscii);
+		bool WriteString(ostream& out, const std::string& str, bool inFlow);
 		bool WriteSingleQuotedString(ostream& out, const std::string& str);
-		bool WriteDoubleQuotedString(ostream& out, const std::string& str, bool escapeNonAscii);
+		bool WriteDoubleQuotedString(ostream& out, const std::string& str);
 		bool WriteLiteralString(ostream& out, const std::string& str, int indent);
-		bool WriteChar(ostream& out, char ch);
 		bool WriteComment(ostream& out, const std::string& str, int postCommentIndent);
 		bool WriteAlias(ostream& out, const std::string& str);
 		bool WriteAnchor(ostream& out, const std::string& str);
-		bool WriteTag(ostream& out, const std::string& str, bool verbatim);
-		bool WriteTagWithPrefix(ostream& out, const std::string& prefix, const std::string& tag);
-		bool WriteBinary(ostream& out, const Binary& binary);
 	}
 }
 

src/exp.cpp

@@ -1,5 +1,6 @@
+#include "crt.h"
 #include "exp.h"
-#include "yaml-cpp/exceptions.h"
+#include "exceptions.h"
 #include <sstream>
 
 namespace YAML
@@ -27,9 +28,9 @@ namespace YAML
 			return value;
 		}
 
-		std::string Str(unsigned ch)
+		std::string Str(char ch)
 		{
-			return std::string(1, static_cast<char>(ch));
+			return std::string("") + ch;
 		}
 
 		// Escape
@@ -82,7 +83,7 @@ namespace YAML
 
 			// now do the slash (we're not gonna check if it's a slash - you better pass one!)
 			switch(ch) {
-				case '0': return std::string(1, '\x00');
+				case '0': return "\0";
 				case 'a': return "\x07";
 				case 'b': return "\x08";
 				case 't':
@@ -96,9 +97,8 @@ namespace YAML
 				case '\"': return "\"";
 				case '\'': return "\'";
 				case '\\': return "\\";
-				case '/': return "/";
-				case 'N': return "\x85";
-				case '_': return "\xA0";
+				case 'N': return "\xC2\x85";  // NEL (#x85)
+				case '_': return "\xC2\xA0";  // #xA0
 				case 'L': return "\xE2\x80\xA8";  // LS (#x2028)
 				case 'P': return "\xE2\x80\xA9";  // PS (#x2029)
 				case 'x': return Escape(in, 2);
@@ -107,7 +107,7 @@ namespace YAML
 			}
 
 			std::stringstream msg;
-			throw ParserException(in.mark(), std::string(ErrorMsg::INVALID_ESCAPE) + ch);
+			throw ParserException(in.mark(), ErrorMsg::INVALID_ESCAPE + ch);
 		}
 	}
 }

src/exp.h

@@ -1,10 +1,8 @@
+#pragma once
+
 #ifndef EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EXP_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 "regex.h"
 #include <string>
@@ -19,157 +17,45 @@ namespace YAML
 	namespace Exp
 	{
 		// misc
-		inline const RegEx& Space() {
-			static const RegEx e = RegEx(' ');
-			return e;
-		}
-		inline const RegEx& Tab() {
-			static const RegEx e = RegEx('\t');
-			return e;
-		}
-		inline const RegEx& Blank() {
-			static const RegEx e = Space() || Tab();
-			return e;
-		}
-		inline const RegEx& Break() {
-			static const RegEx e = RegEx('\n') || RegEx("\r\n");
-			return e;
-		}
-		inline const RegEx& BlankOrBreak() {
-			static const RegEx e = Blank() || Break();
-			return e;
-		}
-		inline const RegEx& Digit() {
-			static const RegEx e = RegEx('0', '9');
-			return e;
-		}
-		inline const RegEx& Alpha() {
-			static const RegEx e = RegEx('a', 'z') || RegEx('A', 'Z');
-			return e;
-		}
-		inline const RegEx& AlphaNumeric() {
-			static const RegEx e = Alpha() || Digit();
-			return e;
-		}
-		inline const RegEx& Word() {
-			static const RegEx e = AlphaNumeric() || RegEx('-');
-			return e;
-		}
-		inline const RegEx& Hex() {
-			static const RegEx e = Digit() || RegEx('A', 'F') || RegEx('a', 'f');
-			return e;
-		}
-		// Valid Unicode code points that are not part of c-printable (YAML 1.2, sec. 5.1)
-		inline const RegEx& NotPrintable() {
-			static const RegEx e = RegEx(0) || 
-				RegEx("\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x7F", REGEX_OR) || 
-				RegEx(0x0E, 0x1F) ||
-				(RegEx('\xC2') + (RegEx('\x80', '\x84') || RegEx('\x86', '\x9F')));
-			return e;
-		}
-		inline const RegEx& Utf8_ByteOrderMark() {
-			static const RegEx e = RegEx("\xEF\xBB\xBF");
-			return e;
-		}
+		const RegEx Space = RegEx(' ');
+		const RegEx Tab = RegEx('\t');
+		const RegEx Blank = Space || Tab;
+		const RegEx Break = RegEx('\n') || RegEx("\r\n");
+		const RegEx BlankOrBreak = Blank || Break;
+		const RegEx Digit = RegEx('0', '9');
+		const RegEx Alpha = RegEx('a', 'z') || RegEx('A', 'Z');
+		const RegEx AlphaNumeric = Alpha || Digit;
+		const RegEx Hex = Digit || RegEx('A', 'F') || RegEx('a', 'f');
+		const RegEx Printable = RegEx(0x20, 0x7E);
 
 		// actual tags
 
-		inline const RegEx& DocStart() {
-			static const RegEx e = RegEx("---") + (BlankOrBreak() || RegEx());
-			return e;
-		}
-		inline const RegEx& DocEnd() {
-			static const RegEx e = RegEx("...") + (BlankOrBreak() || RegEx());
-			return e;
-		}
-		inline const RegEx& DocIndicator() {
-			static const RegEx e = DocStart() || DocEnd();
-			return e;
-		}
-		inline const RegEx& BlockEntry() {
-			static const RegEx e = RegEx('-') + (BlankOrBreak() || RegEx());
-			return e;
-		}
-		inline const RegEx& Key() {
-			static const RegEx e = RegEx('?');
-			return e;
-		}
-		inline const RegEx& KeyInFlow() {
-			static const RegEx e = RegEx('?') + BlankOrBreak();
-			return e;
-		}
-		inline const RegEx& Value() {
-			static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx());
-			return e;
-		}
-		inline const RegEx& ValueInFlow() {
-			static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx(",}", REGEX_OR));
-			return e;
-		}
-		inline const RegEx& ValueInJSONFlow() {
-			static const RegEx e = RegEx(':');
-			return e;
-		}
-		inline const RegEx Comment() {
-			static const RegEx e = RegEx('#');
-			return e;
-		}
-		inline const RegEx& Anchor() {
-			static const RegEx e = !(RegEx("[]{},", REGEX_OR) || BlankOrBreak());
-			return e;
-		}
-		inline const RegEx& AnchorEnd() {
-			static const RegEx e = RegEx("?:,]}%@`", REGEX_OR) || BlankOrBreak();
-			return e;
-		}
-		inline const RegEx& URI() {
-			static const RegEx e = Word() || RegEx("#;/?:@&=+$,_.!~*'()[]", REGEX_OR) || (RegEx('%') + Hex() + Hex());
-			return e;
-		}
-		inline const RegEx& Tag() {
-			static const RegEx e = Word() || RegEx("#;/?:@&=+$_.~*'", REGEX_OR) || (RegEx('%') + Hex() + Hex());
-			return e;
-		}
+		const RegEx DocStart = RegEx("---") + (BlankOrBreak || RegEx());
+		const RegEx DocEnd = RegEx("...") + (BlankOrBreak || RegEx());
+		const RegEx DocIndicator = DocStart || DocEnd;
+		const RegEx BlockEntry = RegEx('-') + (BlankOrBreak || RegEx());
+		const RegEx Key = RegEx('?'),
+		            KeyInFlow = RegEx('?') + BlankOrBreak;
+		const RegEx Value = RegEx(':') + (BlankOrBreak || RegEx()),
+		            ValueInFlow = RegEx(':') + (BlankOrBreak || RegEx(",}", REGEX_OR));
+		const RegEx Comment = RegEx('#');
+		const RegEx AnchorEnd = RegEx("?:,]}%@`", REGEX_OR) || BlankOrBreak;
 
 		// Plain scalar rules:
 		// . Cannot start with a blank.
 		// . Can never start with any of , [ ] { } # & * ! | > \' \" % @ `
 		// . 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) + (BlankOrBreak() || RegEx())));
-			return e;
-		}
-		inline const RegEx& PlainScalarInFlow() {
-			static const RegEx e = !(BlankOrBreak() || RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) || (RegEx("-:", REGEX_OR) + Blank()));
-			return e;
-		}
-		inline const RegEx& EndScalar() {
-			static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx());
-			return e;
-		}
-		inline const RegEx& EndScalarInFlow() {
-			static const RegEx e = (RegEx(':') + (BlankOrBreak() || RegEx() || RegEx(",]}", REGEX_OR))) || RegEx(",?[]{}", REGEX_OR);
-			return e;
-		}
+		const RegEx PlainScalar = !(BlankOrBreak || RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) || (RegEx("-?:", REGEX_OR) + Blank)),
+		            PlainScalarInFlow = !(BlankOrBreak || RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) || (RegEx("-:", REGEX_OR) + Blank));
+		const RegEx EndScalar = RegEx(':') + (BlankOrBreak || RegEx()),
+		            EndScalarInFlow = (RegEx(':') + (BlankOrBreak || RegEx(",]}", REGEX_OR))) || RegEx(",?[]{}", REGEX_OR);
 
-		inline const RegEx& EscSingleQuote() {
-			static const RegEx e = RegEx("\'\'");
-			return e;
-		}
-		inline const RegEx& EscBreak() {
-			static const RegEx e = RegEx('\\') + Break();
-			return e;
-		}
+		const RegEx EscSingleQuote = RegEx("\'\'");
+		const RegEx EscBreak = RegEx('\\') + Break;
 
-		inline const RegEx& ChompIndicator() {
-			static const RegEx e = RegEx("+-", REGEX_OR);
-			return e;
-		}
-		inline const RegEx& Chomp() {
-			static const RegEx e = (ChompIndicator() + Digit()) || (Digit() + ChompIndicator()) || ChompIndicator() || Digit();
-			return e;
-		}
+		const RegEx ChompIndicator = RegEx("+-", REGEX_OR);
+		const RegEx Chomp = (ChompIndicator + Digit) || (Digit + ChompIndicator) || ChompIndicator || Digit;
 
 		// and some functions
 		std::string Escape(Stream& in);
@@ -188,8 +74,6 @@ namespace YAML
 		const char Tag = '!';
 		const char LiteralScalar = '|';
 		const char FoldedScalar = '>';
-		const char VerbatimTagStart = '<';
-		const char VerbatimTagEnd = '>';
 	}
 }
 

src/indentation.h

@@ -1,12 +1,10 @@
+#pragma once
+
 #ifndef INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define INDENTATION_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/ostream.h"
+#include "ostream.h"
 #include <iostream>
 
 namespace YAML

src/iterator.cpp

@@ -0,0 +1,108 @@
+#include "crt.h"
+#include "node.h"
+#include "exceptions.h"
+#include "iterpriv.h"
+
+namespace YAML
+{
+	Iterator::Iterator(): m_pData(0)
+	{
+		m_pData = new IterPriv;
+	}
+
+	Iterator::Iterator(IterPriv *pData): m_pData(pData)
+	{
+	}
+
+	Iterator::Iterator(const Iterator& rhs): m_pData(0)
+	{
+		m_pData = new IterPriv(*rhs.m_pData);
+	}
+
+	Iterator& Iterator::operator = (const Iterator& rhs)
+	{
+		if(this == &rhs)
+			return *this;
+
+		delete m_pData;
+		m_pData = new IterPriv(*rhs.m_pData);
+		return *this;
+	}
+
+	Iterator::~Iterator()
+	{
+		delete m_pData;
+	}
+
+	Iterator& Iterator::operator ++ ()
+	{
+		if(m_pData->type == IterPriv::IT_SEQ)
+			++m_pData->seqIter;
+		else if(m_pData->type == IterPriv::IT_MAP)
+			++m_pData->mapIter;
+
+		return *this;
+	}
+
+	Iterator Iterator::operator ++ (int)
+	{
+		Iterator temp = *this;
+
+		if(m_pData->type == IterPriv::IT_SEQ)
+			++m_pData->seqIter;
+		else if(m_pData->type == IterPriv::IT_MAP)
+			++m_pData->mapIter;
+
+		return temp;
+	}
+
+	const Node& Iterator::operator * () const
+	{
+		if(m_pData->type == IterPriv::IT_SEQ)
+			return **m_pData->seqIter;
+
+		throw BadDereference();
+	}
+
+	const Node *Iterator::operator -> () const
+	{
+		if(m_pData->type == IterPriv::IT_SEQ)
+			return *m_pData->seqIter;
+
+		throw BadDereference();
+	}
+
+	const Node& Iterator::first() const
+	{
+		if(m_pData->type == IterPriv::IT_MAP)
+			return *m_pData->mapIter->first;
+
+		throw BadDereference();
+	}
+
+	const Node& Iterator::second() const
+	{
+		if(m_pData->type == IterPriv::IT_MAP)
+			return *m_pData->mapIter->second;
+
+		throw BadDereference();
+	}
+
+	bool operator == (const Iterator& it, const Iterator& jt)
+	{
+		if(it.m_pData->type != jt.m_pData->type)
+			return false;
+
+		if(it.m_pData->type == IterPriv::IT_SEQ)
+			return it.m_pData->seqIter == jt.m_pData->seqIter;
+		else if(it.m_pData->type == IterPriv::IT_MAP)
+			return it.m_pData->mapIter == jt.m_pData->mapIter;
+
+		return true;
+	}
+
+	bool operator != (const Iterator& it, const Iterator& jt)
+	{
+		return !(it == jt);
+	}
+}

src/iterpriv.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#ifndef ITERPRIV_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define ITERPRIV_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+
+#include "ltnode.h"
+#include <vector>
+#include <map>
+
+namespace YAML
+{
+	class Node;
+
+	// IterPriv
+	// . The implementation for iterators - essentially a union of sequence and map iterators.
+	struct IterPriv
+	{
+		IterPriv(): type(IT_NONE) {}
+		IterPriv(std::vector <Node *>::const_iterator it): type(IT_SEQ), seqIter(it) {}
+		IterPriv(std::map <Node *, Node *, ltnode>::const_iterator it): type(IT_MAP), mapIter(it) {}
+
+		enum ITER_TYPE { IT_NONE, IT_SEQ, IT_MAP };
+		ITER_TYPE type;
+
+		std::vector <Node *>::const_iterator seqIter;
+		std::map <Node *, Node *, ltnode>::const_iterator mapIter;
+	};
+}
+
+#endif // ITERPRIV_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/ltnode.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#ifndef LTNODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define LTNODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+
+namespace YAML
+{
+	class Node;
+
+	struct ltnode {
+		bool operator()(const Node *pNode1, const Node *pNode2) const;
+	};
+}
+
+#endif // LTNODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/map.cpp

@@ -0,0 +1,187 @@
+#include "crt.h"
+#include "map.h"
+#include "node.h"
+#include "scanner.h"
+#include "token.h"
+#include "exceptions.h"
+#include "emitter.h"
+#include <memory>
+
+namespace YAML
+{
+	Map::Map()
+	{
+	}
+	
+	Map::Map(const node_map& data)
+	{
+		for(node_map::const_iterator it=data.begin();it!=data.end();++it) {
+			std::auto_ptr<Node> pKey = it->first->Clone();
+			std::auto_ptr<Node> pValue = it->second->Clone();
+			m_data[pKey.release()] = pValue.release();
+		}
+	}
+
+	Map::~Map()
+	{
+		Clear();
+	}
+
+	void Map::Clear()
+	{
+		for(node_map::const_iterator it=m_data.begin();it!=m_data.end();++it) {
+			delete it->first;
+			delete it->second;
+		}
+		m_data.clear();
+	}
+
+	Content *Map::Clone() const
+	{
+		return new Map(m_data);
+	}
+	
+	bool Map::GetBegin(std::map <Node *, Node *, ltnode>::const_iterator& it) const
+	{
+		it = m_data.begin();
+		return true;
+	}
+
+	bool Map::GetEnd(std::map <Node *, Node *, ltnode>::const_iterator& it) const
+	{
+		it = m_data.end();
+		return true;
+	}
+
+	void Map::Parse(Scanner *pScanner, const ParserState& state)
+	{
+		Clear();
+
+		// split based on start token
+		switch(pScanner->peek().type) {
+			case Token::BLOCK_MAP_START: ParseBlock(pScanner, state); break;
+			case Token::FLOW_MAP_START: ParseFlow(pScanner, state); break;
+			default: break;
+		}
+	}
+
+	void Map::ParseBlock(Scanner *pScanner, const ParserState& state)
+	{
+		// eat start token
+		pScanner->pop();
+
+		while(1) {
+			if(pScanner->empty())
+				throw ParserException(Mark::null(), ErrorMsg::END_OF_MAP);
+
+			Token token = pScanner->peek();
+			if(token.type != Token::KEY && token.type != Token::VALUE && token.type != Token::BLOCK_MAP_END)
+				throw ParserException(token.mark, ErrorMsg::END_OF_MAP);
+
+			if(token.type == Token::BLOCK_MAP_END) {
+				pScanner->pop();
+				break;
+			}
+
+			std::auto_ptr <Node> pKey(new Node), pValue(new Node);
+			
+			// grab key (if non-null)
+			if(token.type == Token::KEY) {
+				pScanner->pop();
+				pKey->Parse(pScanner, state);
+			}
+
+			// now grab value (optional)
+			if(!pScanner->empty() && pScanner->peek().type == Token::VALUE) {
+				pScanner->pop();
+				pValue->Parse(pScanner, state);
+			}
+
+			// assign the map with the actual pointers
+			m_data[pKey.release()] = pValue.release();
+		}
+	}
+
+	void Map::ParseFlow(Scanner *pScanner, const ParserState& state)
+	{
+		// eat start token
+		pScanner->pop();
+
+		while(1) {
+			if(pScanner->empty())
+				throw ParserException(Mark::null(), ErrorMsg::END_OF_MAP_FLOW);
+
+			Token& token = pScanner->peek();
+			// first check for end
+			if(token.type == Token::FLOW_MAP_END) {
+				pScanner->pop();
+				break;
+			}
+
+			// now it better be a key
+			if(token.type != Token::KEY)
+				throw ParserException(token.mark, ErrorMsg::END_OF_MAP_FLOW);
+
+			pScanner->pop();
+
+			std::auto_ptr <Node> pKey(new Node), pValue(new Node);
+
+			// grab key
+			pKey->Parse(pScanner, state);
+
+			// now grab value (optional)
+			if(!pScanner->empty() && pScanner->peek().type == Token::VALUE) {
+				pScanner->pop();
+				pValue->Parse(pScanner, state);
+			}
+
+			// now eat the separator (or could be a map end, which we ignore - but if it's neither, then it's a bad node)
+			Token& nextToken = pScanner->peek();
+			if(nextToken.type == Token::FLOW_ENTRY)
+				pScanner->pop();
+			else if(nextToken.type != Token::FLOW_MAP_END)
+				throw ParserException(nextToken.mark, ErrorMsg::END_OF_MAP_FLOW);
+
+			// assign the map with the actual pointers
+			m_data[pKey.release()] = pValue.release();
+		}
+	}
+
+	void Map::Write(Emitter& out) const
+	{
+		out << BeginMap;
+		for(node_map::const_iterator it=m_data.begin();it!=m_data.end();++it)
+			out << Key << *it->first << Value << *it->second;
+		out << EndMap;
+	}
+
+	int Map::Compare(Content *pContent)
+	{
+		return -pContent->Compare(this);
+	}
+
+	int Map::Compare(Map *pMap)
+	{
+		node_map::const_iterator it = m_data.begin(), jt = pMap->m_data.begin();
+		while(1) {
+			if(it == m_data.end()) {
+				if(jt == pMap->m_data.end())
+					return 0;
+				else
+					return -1;
+			}
+			if(jt == pMap->m_data.end())
+				return 1;
+
+			int cmp = it->first->Compare(*jt->first);
+			if(cmp != 0)
+				return cmp;
+
+			cmp = it->second->Compare(*jt->second);
+			if(cmp != 0)
+				return cmp;
+		}
+
+		return 0;
+	}
+}

src/map.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#ifndef MAP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define MAP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+
+#include "content.h"
+#include <map>
+
+namespace YAML
+{
+	class Node;
+
+	class Map: public Content
+	{
+	private:
+		typedef std::map <Node *, Node *, ltnode> node_map;
+
+	public:
+		Map();
+		Map(const node_map& data);
+		virtual ~Map();
+
+		void Clear();
+		virtual Content *Clone() const;
+
+		virtual bool GetBegin(std::map <Node *, Node *, ltnode>::const_iterator& it) const;
+		virtual bool GetEnd(std::map <Node *, Node *, ltnode>::const_iterator& it) const;
+		virtual void Parse(Scanner *pScanner, const ParserState& state);
+		virtual void Write(Emitter& out) const;
+
+		virtual bool IsMap() const { return true; }
+
+		// ordering
+		virtual int Compare(Content *pContent);
+		virtual int Compare(Scalar *) { return 1; }
+		virtual int Compare(Sequence *) { return 1; }
+		virtual int Compare(Map *pMap);
+
+	private:
+		void ParseBlock(Scanner *pScanner, const ParserState& state);
+		void ParseFlow(Scanner *pScanner, const ParserState& state);
+
+	private:
+		node_map m_data;
+	};
+}
+
+#endif // MAP_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/memory.cpp

@@ -1,29 +0,0 @@
-#include "yaml-cpp/node/detail/memory.h"
-#include "yaml-cpp/node/detail/node.h"
-
-namespace YAML
-{
-	namespace detail
-	{
-		void memory_holder::merge(memory_holder& rhs)
-		{
-			if(m_pMemory == rhs.m_pMemory)
-				return;
-			
-			m_pMemory->merge(*rhs.m_pMemory);
-			rhs.m_pMemory = m_pMemory;
-		}
-		
-		node& memory::create_node()
-		{
-			shared_node pNode(new node);
-			m_nodes.insert(pNode);
-			return *pNode;
-		}
-		
-		void memory::merge(const memory& rhs)
-		{
-			m_nodes.insert(rhs.m_nodes.begin(), rhs.m_nodes.end());
-		}
-	}
-}

src/node.cpp

@@ -0,0 +1,292 @@
+#include "crt.h"
+#include "node.h"
+#include "token.h"
+#include "scanner.h"
+#include "content.h"
+#include "parser.h"
+#include "scalar.h"
+#include "sequence.h"
+#include "map.h"
+#include "aliascontent.h"
+#include "iterpriv.h"
+#include "emitter.h"
+#include <stdexcept>
+
+namespace YAML
+{
+	// the ordering!
+	bool ltnode::operator ()(const Node *pNode1, const Node *pNode2) const
+	{
+		return *pNode1 < *pNode2;
+	}
+
+	Node::Node(): m_pContent(0), m_alias(false), m_pIdentity(this), m_referenced(true)
+	{
+	}
+
+	Node::Node(const Mark& mark, const std::string& anchor, const std::string& tag, const Content *pContent)
+	: m_mark(mark), m_anchor(anchor), m_tag(tag), m_pContent(0), m_alias(false), m_pIdentity(this), m_referenced(false)
+	{
+		if(m_pContent)
+			m_pContent = pContent->Clone();
+	}
+
+	Node::~Node()
+	{
+		Clear();
+	}
+
+	void Node::Clear()
+	{
+		delete m_pContent;
+		m_pContent = 0;
+		m_alias = false;
+		m_referenced = false;
+		m_anchor.clear();
+		m_tag.clear();
+	}
+	
+	std::auto_ptr<Node> Node::Clone() const
+	{
+		if(m_alias)
+			throw std::runtime_error("yaml-cpp: Can't clone alias");  // TODO: what to do about aliases?
+		
+		return std::auto_ptr<Node> (new Node(m_mark, m_anchor, m_tag, m_pContent));
+	}
+
+	void Node::Parse(Scanner *pScanner, const ParserState& state)
+	{
+		Clear();
+
+		// an empty node *is* a possibility
+		if(pScanner->empty())
+			return;
+
+		// save location
+		m_mark = pScanner->peek().mark;
+
+		ParseHeader(pScanner, state);
+
+		// is this an alias? if so, its contents are an alias to
+		// a previously defined anchor
+		if(m_alias) {
+			// the scanner throws an exception if it doesn't know this anchor name
+			const Node *pReferencedNode = pScanner->Retrieve(m_anchor);
+			m_pIdentity = pReferencedNode;
+
+			// mark the referenced node for the sake of the client code
+			pReferencedNode->m_referenced = true;
+
+			// use of an Alias object keeps the referenced content from
+			// being deleted twice
+			Content *pAliasedContent = pReferencedNode->m_pContent;
+			if(pAliasedContent)
+				m_pContent = new AliasContent(pAliasedContent);
+			
+			return;
+		}
+
+		// now split based on what kind of node we should be
+		switch(pScanner->peek().type) {
+			case Token::SCALAR:
+				m_pContent = new Scalar;
+				break;
+			case Token::FLOW_SEQ_START:
+			case Token::BLOCK_SEQ_START:
+				m_pContent = new Sequence;
+				break;
+			case Token::FLOW_MAP_START:
+			case Token::BLOCK_MAP_START:
+				m_pContent = new Map;
+				break;
+			default:
+//				std::stringstream str;
+//				str << TokenNames[pScanner->peek().type];
+//				throw std::runtime_error(str.str());
+				break;
+		}
+
+		// Have to save anchor before parsing to allow for aliases as
+		// contained node (recursive structure)
+		if(!m_anchor.empty())
+			pScanner->Save(m_anchor, this);
+
+		if(m_pContent)
+			m_pContent->Parse(pScanner, state);
+	}
+
+	// ParseHeader
+	// . Grabs any tag, alias, or anchor tokens and deals with them.
+	void Node::ParseHeader(Scanner *pScanner, const ParserState& state)
+	{
+		while(1) {
+			if(pScanner->empty())
+				return;
+
+			switch(pScanner->peek().type) {
+				case Token::TAG: ParseTag(pScanner, state); break;
+				case Token::ANCHOR: ParseAnchor(pScanner, state); break;
+				case Token::ALIAS: ParseAlias(pScanner, state); break;
+				default: return;
+			}
+		}
+	}
+
+	void Node::ParseTag(Scanner *pScanner, const ParserState& state)
+	{
+		Token& token = pScanner->peek();
+		if(m_tag != "")
+			throw ParserException(token.mark, ErrorMsg::MULTIPLE_TAGS);
+
+		m_tag = state.TranslateTag(token.value);
+
+		for(std::size_t i=0;i<token.params.size();i++)
+			m_tag += token.params[i];
+		pScanner->pop();
+	}
+	
+	void Node::ParseAnchor(Scanner *pScanner, const ParserState& /*state*/)
+	{
+		Token& token = pScanner->peek();
+		if(m_anchor != "")
+			throw ParserException(token.mark, ErrorMsg::MULTIPLE_ANCHORS);
+
+		m_anchor = token.value;
+		m_alias = false;
+		pScanner->pop();
+	}
+
+	void Node::ParseAlias(Scanner *pScanner, const ParserState& /*state*/)
+	{
+		Token& token = pScanner->peek();
+		if(m_anchor != "")
+			throw ParserException(token.mark, ErrorMsg::MULTIPLE_ALIASES);
+		if(m_tag != "")
+			throw ParserException(token.mark, ErrorMsg::ALIAS_CONTENT);
+
+		m_anchor = token.value;
+		m_alias = true;
+		pScanner->pop();
+	}
+
+	CONTENT_TYPE Node::GetType() const
+	{
+		if(!m_pContent)
+			return CT_NONE;
+
+		if(m_pContent->IsScalar())
+			return CT_SCALAR;
+		else if(m_pContent->IsSequence())
+			return CT_SEQUENCE;
+		else if(m_pContent->IsMap())
+			return CT_MAP;
+			
+		return CT_NONE;
+	}
+
+	// begin
+	// Returns an iterator to the beginning of this (sequence or map).
+	Iterator Node::begin() const
+	{
+		if(!m_pContent)
+			return Iterator();
+
+		std::vector <Node *>::const_iterator seqIter;
+		if(m_pContent->GetBegin(seqIter))
+			return Iterator(new IterPriv(seqIter));
+
+		std::map <Node *, Node *, ltnode>::const_iterator mapIter;
+		if(m_pContent->GetBegin(mapIter))
+			return Iterator(new IterPriv(mapIter));
+
+		return Iterator();
+	}
+
+	// end
+	// . Returns an iterator to the end of this (sequence or map).
+	Iterator Node::end() const
+	{
+		if(!m_pContent)
+			return Iterator();
+
+		std::vector <Node *>::const_iterator seqIter;
+		if(m_pContent->GetEnd(seqIter))
+			return Iterator(new IterPriv(seqIter));
+
+		std::map <Node *, Node *, ltnode>::const_iterator mapIter;
+		if(m_pContent->GetEnd(mapIter))
+			return Iterator(new IterPriv(mapIter));
+
+		return Iterator();
+	}
+
+	// size
+	// . Returns the size of this node, if it's a sequence node.
+	// . Otherwise, returns zero.
+	std::size_t Node::size() const
+	{
+		if(!m_pContent)
+			return 0;
+
+		return m_pContent->GetSize();
+	}
+
+	const Node *Node::FindAtIndex(std::size_t i) const
+	{
+		if(!m_pContent)
+			return 0;
+		
+		return m_pContent->GetNode(i);
+	}
+
+	bool Node::GetScalar(std::string& s) const
+	{
+		if(!m_pContent) {
+			s = "~";
+			return true;
+		}
+		
+		return m_pContent->GetScalar(s);
+	}
+
+	Emitter& operator << (Emitter& out, const Node& node)
+	{
+		// write anchor/alias
+		if(node.m_anchor != "") {
+			if(node.m_alias)
+				out << Alias(node.m_anchor);
+			else
+				out << Anchor(node.m_anchor);
+		}
+
+		// TODO: write tag
+
+		// write content
+		if(node.m_pContent)
+			node.m_pContent->Write(out);
+		else if(!node.m_alias)
+			out << Null;
+
+		return out;
+	}
+
+	int Node::Compare(const Node& rhs) const
+	{
+		// Step 1: no content is the smallest
+		if(!m_pContent) {
+			if(rhs.m_pContent)
+				return -1;
+			else
+				return 0;
+		}
+		if(!rhs.m_pContent)
+			return 1;
+
+		return m_pContent->Compare(rhs.m_pContent);
+	}
+
+	bool operator < (const Node& n1, const Node& n2)
+	{
+		return n1.Compare(n2) < 0;
+	}
+}

src/node_data.cpp

@@ -1,295 +0,0 @@
-#include "yaml-cpp/node/detail/node_data.h"
-#include "yaml-cpp/node/detail/memory.h"
-#include "yaml-cpp/node/detail/node.h"
-#include "yaml-cpp/exceptions.h"
-#include <sstream>
-
-namespace YAML
-{
-	namespace detail
-	{
-		std::string node_data::empty_scalar;
-
-		node_data::node_data(): m_isDefined(false), m_type(NodeType::Null), m_seqSize(0)
-		{
-		}
-
-		void node_data::mark_defined()
-		{
-			if(m_type == NodeType::Undefined)
-				m_type = NodeType::Null;
-			m_isDefined = true;
-		}
-
-		void node_data::set_type(NodeType::value type)
-		{
-			if(type == NodeType::Undefined) {
-				m_type = type;
-				m_isDefined = false;
-				return;
-			}
-			
-
-			m_isDefined = true;
-			if(type == m_type)
-				return;
-			
-			m_type = type;
-			
-			switch(m_type) {
-				case NodeType::Null:
-					break;
-				case NodeType::Scalar:
-					m_scalar.clear();
-					break;
-				case NodeType::Sequence:
-					reset_sequence();
-					break;
-				case NodeType::Map:
-					reset_map();
-					break;
-				case NodeType::Undefined:
-					assert(false);
-					break;
-			}
-		}
-
-		void node_data::set_tag(const std::string& tag)
-		{
-			m_tag = tag;
-		}
-		
-		void node_data::set_null()
-		{
-			m_isDefined = true;
-			m_type = NodeType::Null;
-		}
-		
-		void node_data::set_scalar(const std::string& scalar)
-		{
-			m_isDefined = true;
-			m_type = NodeType::Scalar;
-			m_scalar = scalar;
-		}
-
-		// size/iterator
-		std::size_t node_data::size() const
-		{
-			if(!m_isDefined)
-				return 0;
-
-			switch(m_type) {
-				case NodeType::Sequence: compute_seq_size(); return m_seqSize;
-				case NodeType::Map: compute_map_size(); return m_map.size() - m_undefinedPairs.size();
-				default:
-					return 0;
-			}
-			return 0;
-		}
-		
-		void node_data::compute_seq_size() const
-		{
-			while(m_seqSize < m_sequence.size() && m_sequence[m_seqSize]->is_defined())
-				m_seqSize++;
-		}
-
-		void node_data::compute_map_size() const
-		{
-			kv_pairs::iterator it = m_undefinedPairs.begin();
-			while(it != m_undefinedPairs.end()) {
-				kv_pairs::iterator jt = boost::next(it);
-				if(it->first->is_defined() && it->second->is_defined())
-					m_undefinedPairs.erase(it);
-				it = jt;
-			}
-		}
-		
-		const_node_iterator node_data::begin() const
-		{
-			if(!m_isDefined)
-				return const_node_iterator();
-			
-			switch(m_type) {
-				case NodeType::Sequence: return const_node_iterator(m_sequence.begin());
-				case NodeType::Map: return const_node_iterator(m_map.begin(), m_map.end());
-				default: return const_node_iterator();
-			}
-		}
-		
-		node_iterator node_data::begin()
-		{
-			if(!m_isDefined)
-				return node_iterator();
-
-			switch(m_type) {
-				case NodeType::Sequence: return node_iterator(m_sequence.begin());
-				case NodeType::Map: return node_iterator(m_map.begin(), m_map.end());
-				default: return node_iterator();
-			}
-		}
-		
-		const_node_iterator node_data::end() const
-		{
-			if(!m_isDefined)
-				return const_node_iterator();
-
-			switch(m_type) {
-				case NodeType::Sequence: return const_node_iterator(m_sequence.end());
-				case NodeType::Map: return const_node_iterator(m_map.end(), m_map.end());
-				default: return const_node_iterator();
-			}
-		}
-		
-		node_iterator node_data::end()
-		{
-			if(!m_isDefined)
-				return node_iterator();
-
-			switch(m_type) {
-				case NodeType::Sequence: return node_iterator(m_sequence.end());
-				case NodeType::Map: return node_iterator(m_map.end(), m_map.end());
-				default: return node_iterator();
-			}
-		}
-
-		// sequence
-		void node_data::push_back(node& node, shared_memory_holder /* pMemory */)
-		{
-			if(m_type == NodeType::Undefined || m_type == NodeType::Null) {
-				m_type = NodeType::Sequence;
-				reset_sequence();
-			}
-			
-			if(m_type != NodeType::Sequence)
-                throw BadPushback();
-			
-			m_sequence.push_back(&node);
-		}
-
-		void node_data::insert(node& key, node& value, shared_memory_holder pMemory)
-		{
-			switch(m_type) {
-				case NodeType::Map:
-					break;
-				case NodeType::Undefined:
-				case NodeType::Null:
-				case NodeType::Sequence:
-					convert_to_map(pMemory);
-					break;
-				case NodeType::Scalar:
-                    throw BadSubscript();
-			}
-
-			insert_map_pair(key, value);
-		}
-
-		// indexing
-		node& node_data::get(node& key, shared_memory_holder pMemory) const
-		{
-			if(m_type != NodeType::Map)
-				return pMemory->create_node();
-			
-			for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) {
-				if(it->first->is(key))
-					return *it->second;
-			}
-			
-			return pMemory->create_node();
-		}
-		
-		node& node_data::get(node& key, shared_memory_holder pMemory)
-		{
-			switch(m_type) {
-				case NodeType::Map:
-					break;
-				case NodeType::Undefined:
-				case NodeType::Null:
-				case NodeType::Sequence:
-					convert_to_map(pMemory);
-					break;
-				case NodeType::Scalar:
-                    throw BadSubscript();
-			}
-
-			for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) {
-				if(it->first->is(key))
-					return *it->second;
-			}
-			
-			node& value = pMemory->create_node();
-			insert_map_pair(key, value);
-			return value;
-		}
-		
-		bool node_data::remove(node& key, shared_memory_holder /* pMemory */)
-		{
-			if(m_type != NodeType::Map)
-				return false;
-
-			for(node_map::iterator it=m_map.begin();it!=m_map.end();++it) {
-				if(it->first->is(key)) {
-					m_map.erase(it);
-					return true;
-				}
-			}
-			
-			return false;
-		}
-
-		void node_data::reset_sequence()
-		{
-			m_sequence.clear();
-			m_seqSize = 0;
-		}
-
-		void node_data::reset_map()
-		{
-			m_map.clear();
-			m_undefinedPairs.clear();
-		}
-
-		void node_data::insert_map_pair(node& key, node& value)
-		{
-			m_map[&key] = &value;
-			if(!key.is_defined() || !value.is_defined())
-				m_undefinedPairs.push_back(kv_pair(&key, &value));
-		}
-
-		void node_data::convert_to_map(shared_memory_holder pMemory)
-		{
-			switch(m_type) {
-				case NodeType::Undefined:
-				case NodeType::Null:
-					reset_map();
-					m_type = NodeType::Map;
-					break;
-				case NodeType::Sequence:
-					convert_sequence_to_map(pMemory);
-					break;
-				case NodeType::Map:
-					break;
-				case NodeType::Scalar:
-					assert(false);
-					break;
-			}
-		}
-
-		void node_data::convert_sequence_to_map(shared_memory_holder pMemory)
-		{
-			assert(m_type == NodeType::Sequence);
-
-			reset_map();
-			for(std::size_t i=0;i<m_sequence.size();i++) {
-				std::stringstream stream;
-				stream << i;
-
-				node& key = pMemory->create_node();
-				key.set_scalar(stream.str());
-				insert_map_pair(key, *m_sequence[i]);
-			}
-			
-			reset_sequence();
-			m_type = NodeType::Map;
-		}
-	}
-}

src/nodebuilder.cpp

@@ -1,138 +0,0 @@
-#include "nodebuilder.h"
-#include "yaml-cpp/mark.h"
-#include "yaml-cpp/node/node.h"
-#include "yaml-cpp/node/impl.h"
-#include <cassert>
-
-namespace YAML
-{
-	NodeBuilder::NodeBuilder(): m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0)
-	{
-		m_anchors.push_back(0); // since the anchors start at 1
-	}
-	
-	NodeBuilder::~NodeBuilder()
-	{
-	}
-	
-	Node NodeBuilder::Root()
-	{
-		if(!m_pRoot)
-			return Node();
-		
-		return Node(*m_pRoot, m_pMemory);
-	}
-
-	void NodeBuilder::OnDocumentStart(const Mark&)
-	{
-	}
-	
-	void NodeBuilder::OnDocumentEnd()
-	{
-	}
-	
-	void NodeBuilder::OnNull(const Mark& /* mark */, anchor_t anchor)
-	{
-		detail::node& node = Push(anchor);
-		node.set_null();
-		Pop();
-	}
-	
-	void NodeBuilder::OnAlias(const Mark& /* mark */, anchor_t anchor)
-	{
-		detail::node& node = *m_anchors[anchor];
-		Push(node);
-		Pop();
-	}
-	
-	void NodeBuilder::OnScalar(const Mark& /* mark */, const std::string& tag, anchor_t anchor, const std::string& value)
-	{
-		detail::node& node = Push(anchor);
-		node.set_scalar(value);
-		node.set_tag(tag);
-		Pop();
-	}
-	
-	void NodeBuilder::OnSequenceStart(const Mark& /* mark */, const std::string& tag, anchor_t anchor)
-	{
-		detail::node& node = Push(anchor);
-		node.set_tag(tag);
-		node.set_type(NodeType::Sequence);
-	}
-	
-	void NodeBuilder::OnSequenceEnd()
-	{
-		Pop();
-	}
-	
-	void NodeBuilder::OnMapStart(const Mark& /* mark */, const std::string& tag, anchor_t anchor)
-	{
-		detail::node& node = Push(anchor);
-		node.set_type(NodeType::Map);
-		node.set_tag(tag);
-		m_mapDepth++;
-	}
-	
-	void NodeBuilder::OnMapEnd()
-	{
-		assert(m_mapDepth > 0);
-		m_mapDepth--;
-		Pop();
-	}
-
-	detail::node& NodeBuilder::Push(anchor_t anchor)
-	{
-		detail::node& node = m_pMemory->create_node();
-		RegisterAnchor(anchor, node);
-		Push(node);
-		return node;
-	}
-	
-	void NodeBuilder::Push(detail::node& node)
-	{
-		const bool needsKey = (!m_stack.empty() && m_stack.back()->type() == NodeType::Map && m_keys.size() < m_mapDepth);
-		
-		m_stack.push_back(&node);
-		if(needsKey)
-			m_keys.push_back(PushedKey(&node, false));
-	}
-	
-	void NodeBuilder::Pop()
-	{
-		assert(!m_stack.empty());
-		if(m_stack.size() == 1) {
-			m_pRoot = m_stack[0];
-			m_stack.pop_back();
-			return;
-		}
-		
-		detail::node& node = *m_stack.back();
-		m_stack.pop_back();
-
-		detail::node& collection = *m_stack.back();
-		
-		if(collection.type() == NodeType::Sequence) {
-			collection.push_back(node, m_pMemory);
-		} else if(collection.type() == NodeType::Map) {
-			assert(!m_keys.empty());
-			PushedKey& key = m_keys.back();
-			if(key.second) {
-				collection.insert(*key.first, node, m_pMemory);
-				m_keys.pop_back();
-			} else {
-				key.second = true;
-			}
-		} else {
-			assert(false);
-			m_stack.clear();
-		}
-	}
-
-	void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node)
-	{
-		if(anchor) {
-			assert(anchor == m_anchors.size());
-			m_anchors.push_back(&node);
-		}
-	}
-}

src/nodebuilder.h

@@ -1,58 +0,0 @@
-#ifndef NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NODE_NODEBUILDER_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 "yaml-cpp/node/ptr.h"
-#include <vector>
-
-namespace YAML
-{
-	class Node;
-
-	class NodeBuilder: public EventHandler
-	{
-	public:
-		NodeBuilder();
-		virtual ~NodeBuilder();
-		
-		Node Root();
-		
-		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:
-		detail::node& Push(anchor_t anchor);
-		void Push(detail::node& node);
-		void Pop();
-		void RegisterAnchor(anchor_t anchor, detail::node& node);
-		
-	private:
-		detail::shared_memory_holder m_pMemory;
-		detail::node *m_pRoot;
-		
-		typedef std::vector<detail::node *> Nodes;
-		Nodes m_stack;
-		Nodes m_anchors;
-
-		typedef std::pair<detail::node *, bool> PushedKey;
-		std::vector<PushedKey> m_keys;
-		std::size_t m_mapDepth;
-	};
-}
-
-#endif // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

src/nodeevents.cpp

@@ -1,99 +0,0 @@
-#include "nodeevents.h"
-#include "yaml-cpp/node/node.h"
-#include "yaml-cpp/node/impl.h"
-#include "yaml-cpp/eventhandler.h"
-#include "yaml-cpp/mark.h"
-
-namespace YAML
-{
-	void NodeEvents::AliasManager::RegisterReference(const detail::node& node)
-	{
-		m_anchorByIdentity.insert(std::make_pair(node.ref(), _CreateNewAnchor()));
-	}
-	
-	anchor_t NodeEvents::AliasManager::LookupAnchor(const detail::node& node) const
-	{
-		AnchorByIdentity::const_iterator it = m_anchorByIdentity.find(node.ref());
-		if(it == m_anchorByIdentity.end())
-			return 0;
-		return it->second;
-	}
-
-	NodeEvents::NodeEvents(const Node& node): m_pMemory(node.m_pMemory), m_root(*node.m_pNode)
-	{
-		Setup(m_root);
-	}
-
-	void NodeEvents::Setup(const detail::node& node)
-	{
-		int& refCount = m_refCount[node.ref()];
-		refCount++;
-		if(refCount > 1)
-			return;
-		
-		if(node.type() == NodeType::Sequence) {
-			for(detail::const_node_iterator it=node.begin();it!=node.end();++it)
-				Setup(**it);
-		} else if(node.type() == NodeType::Map) {
-			for(detail::const_node_iterator it=node.begin();it!=node.end();++it) {
-				Setup(*it->first);
-				Setup(*it->second);
-			}
-		}
-	}
-
-	void NodeEvents::Emit(EventHandler& handler)
-	{
-		AliasManager am;
-		
-		handler.OnDocumentStart(Mark());
-		Emit(m_root, handler, am);
-		handler.OnDocumentEnd();
-	}
-
-	void NodeEvents::Emit(const detail::node& node, EventHandler& handler, AliasManager& am) const
-	{
-		anchor_t anchor = NullAnchor;
-		if(IsAliased(node)) {
-			anchor = am.LookupAnchor(node);
-			if(anchor) {
-				handler.OnAlias(Mark(), anchor);
-				return;
-			}
-			
-			am.RegisterReference(node);
-			anchor = am.LookupAnchor(node);
-		}
-		
-		switch(node.type()) {
-			case NodeType::Undefined:
-				break;
-			case NodeType::Null:
-				handler.OnNull(Mark(), anchor);
-				break;
-			case NodeType::Scalar:
-				handler.OnScalar(Mark(), node.tag(), anchor, node.scalar());
-				break;
-			case NodeType::Sequence:
-				handler.OnSequenceStart(Mark(), node.tag(), anchor);
-				for(detail::const_node_iterator it=node.begin();it!=node.end();++it)
-					Emit(**it, handler, am);
-				handler.OnSequenceEnd();
-				break;
-			case NodeType::Map:
-				handler.OnMapStart(Mark(), node.tag(), anchor);
-				for(detail::const_node_iterator it=node.begin();it!=node.end();++it) {
-					Emit(*it->first, handler, am);
-					Emit(*it->second, handler, am);
-				}
-				handler.OnMapEnd();
-				break;
-		}
-	}
-
-	bool NodeEvents::IsAliased(const detail::node& node) const
-	{
-		RefCount::const_iterator it = m_refCount.find(node.ref());
-		return it != m_refCount.end() && it->second > 1;
-	}
-}

src/nodeevents.h

@@ -1,57 +0,0 @@
-#ifndef NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NODE_NODEEVENTS_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 "yaml-cpp/node/ptr.h"
-#include <map>
-#include <vector>
-
-namespace YAML
-{
-	class EventHandler;
-	class Node;
-	
-	class NodeEvents
-	{
-	public:
-		explicit NodeEvents(const Node& node);
-		
-		void Emit(EventHandler& handler);
-		
-	private:
-		class AliasManager {
-		public:
-			AliasManager(): m_curAnchor(0) {}
-			
-			void RegisterReference(const detail::node& node);
-			anchor_t LookupAnchor(const detail::node& node) const;
-			
-		private:
-			anchor_t _CreateNewAnchor() { return ++m_curAnchor; }
-			
-		private:
-			typedef std::map<const detail::node_ref*, anchor_t> AnchorByIdentity;
-			AnchorByIdentity m_anchorByIdentity;
-			
-			anchor_t m_curAnchor;
-		};
-		
-		void Setup(const detail::node& node);
-		void Emit(const detail::node& node, EventHandler& handler, AliasManager& am) const;
-		bool IsAliased(const detail::node& node) const;
-		
-	private:
-		detail::shared_memory_holder m_pMemory;
-		detail::node& m_root;
-		
-		typedef std::map<const detail::node_ref *, int> RefCount;
-		RefCount m_refCount;
-	};
-}
-
-#endif // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

src/null.cpp

@@ -1,6 +1,12 @@
-#include "yaml-cpp/null.h"
+#include "null.h"
+#include "node.h"
 
 namespace YAML
 {
 	_Null Null;
+
+	bool IsNull(const Node& node)
+	{
+		return node.Read(Null);
+	}
 }

src/ostream.cpp

@@ -1,4 +1,4 @@
-#include "yaml-cpp/ostream.h"
+#include "ostream.h"
 #include <cstring>
 
 namespace YAML

src/parse.cpp

@@ -1,64 +0,0 @@
-#include "yaml-cpp/node/parse.h"
-#include "yaml-cpp/node/node.h"
-#include "yaml-cpp/node/impl.h"
-#include "yaml-cpp/parser.h"
-#include "nodebuilder.h"
-
-#include <fstream>
-#include <sstream>
-
-namespace YAML
-{
-	Node Load(const std::string& input) {
-		std::stringstream stream(input);
-		return Load(stream);
-	}
-	
-	Node Load(const char *input) {
-		std::stringstream stream(input);
-		return Load(stream);
-	}
-	
-	Node Load(std::istream& input) {
-		Parser parser(input);
-		NodeBuilder builder;
-		if(!parser.HandleNextDocument(builder))
-			return Node();
-		
-		return builder.Root();
-	}
-
-    Node LoadFile(const std::string& filename) {
-        std::ifstream fin(filename.c_str());
-        return Load(fin);
-    }
-
-	std::vector<Node> LoadAll(const std::string& input) {
-		std::stringstream stream(input);
-		return LoadAll(stream);
-	}
-	
-	std::vector<Node> LoadAll(const char *input) {
-		std::stringstream stream(input);
-		return LoadAll(stream);
-	}
-	
-	std::vector<Node> LoadAll(std::istream& input) {
-		std::vector<Node> docs;
-		
-		Parser parser(input);
-		while(1) {
-			NodeBuilder builder;
-			if(!parser.HandleNextDocument(builder))
-				break;
-			docs.push_back(builder.Root());
-		}
-		
-		return docs;
-	}
-
-    std::vector<Node> LoadAllFromFile(const std::string& filename) {
-        std::ifstream fin(filename.c_str());
-        return LoadAll(fin);
-    }
-}

src/parser.cpp

@@ -1,56 +1,63 @@
-#include "yaml-cpp/parser.h"
-#include "yaml-cpp/eventhandler.h"
-#include "yaml-cpp/exceptions.h"
-#include "directives.h"
+#include "crt.h"
+#include "parser.h"
 #include "scanner.h"
-#include "singledocparser.h"
-#include "tag.h"
 #include "token.h"
+#include "exceptions.h"
 #include <sstream>
 #include <cstdio>
 
 namespace YAML
 {
-	Parser::Parser()
-	{
-	}
-	
-	Parser::Parser(std::istream& in)
+	Parser::Parser(std::istream& in): m_pScanner(0)
 	{
 		Load(in);
 	}
 
 	Parser::~Parser()
 	{
+		delete m_pScanner;
 	}
 
 	Parser::operator bool() const
 	{
-		return m_pScanner.get() && !m_pScanner->empty();
+		return !m_pScanner->empty();
 	}
 
 	void Parser::Load(std::istream& in)
 	{
-		m_pScanner.reset(new Scanner(in));
-		m_pDirectives.reset(new Directives);
+		delete m_pScanner;
+		m_pScanner = new Scanner(in);
+		m_state.Reset();
 	}
 
-	// HandleNextDocument
-	// . Handles the next document
+	// GetNextDocument
+	// . Reads the next document in the queue (of tokens).
 	// . Throws a ParserException on error.
-	// . Returns false if there are no more documents
-	bool Parser::HandleNextDocument(EventHandler& eventHandler)
+	void Parser::GetNextDocument(Node& document)
 	{
-		if(!m_pScanner.get())
-			return false;
+		// clear node
+		document.Clear();
 
+		// first read directives
 		ParseDirectives();
+
+		// we better have some tokens in the queue
 		if(m_pScanner->empty())
-			return false;
-		
-		SingleDocParser sdp(*m_pScanner, *m_pDirectives);
-		sdp.HandleDocument(eventHandler);
-		return true;
+			return;
+
+		// first eat doc start (optional)
+		if(m_pScanner->peek().type == Token::DOC_START)
+			m_pScanner->pop();
+
+		// now parse our root node
+		document.Parse(m_pScanner, m_state);
+
+		// and finally eat any doc ends we see
+		while(!m_pScanner->empty() && m_pScanner->peek().type == Token::DOC_END)
+			m_pScanner->pop();
+
+		// clear anchors from the scanner, which are no longer relevant
+		m_pScanner->ClearAnchors();
 	}
 
 	// ParseDirectives
@@ -70,66 +77,55 @@ namespace YAML
 			// we keep the directives from the last document if none are specified;
 			// but if any directives are specific, then we reset them
 			if(!readDirective)
-				m_pDirectives.reset(new Directives);
+				m_state.Reset();
 
 			readDirective = true;
-			HandleDirective(token);
+			HandleDirective(&token);
 			m_pScanner->pop();
 		}
 	}
 
-	void Parser::HandleDirective(const Token& token)
+	void Parser::HandleDirective(Token *pToken)
 	{
-		if(token.value == "YAML")
-			HandleYamlDirective(token);
-		else if(token.value == "TAG")
-			HandleTagDirective(token);
+		if(pToken->value == "YAML")
+			HandleYamlDirective(pToken);
+		else if(pToken->value == "TAG")
+			HandleTagDirective(pToken);
 	}
 
 	// HandleYamlDirective
 	// . Should be of the form 'major.minor' (like a version number)
-	void Parser::HandleYamlDirective(const Token& token)
+	void Parser::HandleYamlDirective(Token *pToken)
 	{
-		if(token.params.size() != 1)
-			throw ParserException(token.mark, ErrorMsg::YAML_DIRECTIVE_ARGS);
-		
-		if(!m_pDirectives->version.isDefault)
-			throw ParserException(token.mark, ErrorMsg::REPEATED_YAML_DIRECTIVE);
+		if(pToken->params.size() != 1)
+			throw ParserException(pToken->mark, ErrorMsg::YAML_DIRECTIVE_ARGS);
 
-		std::stringstream str(token.params[0]);
-		str >> m_pDirectives->version.major;
+		std::stringstream str(pToken->params[0]);
+		str >> m_state.version.major;
 		str.get();
-		str >> m_pDirectives->version.minor;
+		str >> m_state.version.minor;
 		if(!str || str.peek() != EOF)
-			throw ParserException(token.mark, std::string(ErrorMsg::YAML_VERSION) + token.params[0]);
+			throw ParserException(pToken->mark, ErrorMsg::YAML_VERSION + pToken->params[0]);
 
-		if(m_pDirectives->version.major > 1)
-			throw ParserException(token.mark, ErrorMsg::YAML_MAJOR_VERSION);
+		if(m_state.version.major > 1)
+			throw ParserException(pToken->mark, ErrorMsg::YAML_MAJOR_VERSION);
 
-		m_pDirectives->version.isDefault = false;
 		// TODO: warning on major == 1, minor > 2?
 	}
 
 	// HandleTagDirective
 	// . Should be of the form 'handle prefix', where 'handle' is converted to 'prefix' in the file.
-	void Parser::HandleTagDirective(const Token& token)
+	void Parser::HandleTagDirective(Token *pToken)
 	{
-		if(token.params.size() != 2)
-			throw ParserException(token.mark, ErrorMsg::TAG_DIRECTIVE_ARGS);
+		if(pToken->params.size() != 2)
+			throw ParserException(pToken->mark, ErrorMsg::TAG_DIRECTIVE_ARGS);
 
-		const std::string& handle = token.params[0];
-		const std::string& prefix = token.params[1];
-		if(m_pDirectives->tags.find(handle) != m_pDirectives->tags.end())
-			throw ParserException(token.mark, ErrorMsg::REPEATED_TAG_DIRECTIVE);
-		
-		m_pDirectives->tags[handle] = prefix;
+		std::string handle = pToken->params[0], prefix = pToken->params[1];
+		m_state.tags[handle] = prefix;
 	}
 
 	void Parser::PrintTokens(std::ostream& out)
 	{
-		if(!m_pScanner.get())
-			return;
-		
 		while(1) {
 			if(m_pScanner->empty())
 				break;

src/parserstate.cpp

@@ -0,0 +1,26 @@
+#include "crt.h"
+#include "parserstate.h"
+
+namespace YAML
+{
+	void ParserState::Reset()
+	{
+		// version
+		version.major = 1;
+		version.minor = 2;
+
+		// and tags
+		tags.clear();
+		tags["!"] = "!";
+		tags["!!"] = "tag:yaml.org,2002:";
+	}
+
+	std::string ParserState::TranslateTag(const std::string& handle) const
+	{
+		std::map <std::string, std::string>::const_iterator it = tags.find(handle);
+		if(it == tags.end())
+			return handle;
+
+		return it->second;
+	}
+}

src/ptr_stack.h

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

src/ptr_vector.h

@@ -1,47 +0,0 @@
-#ifndef PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define PTR_VECTOR_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/noncopyable.h"
-#include <cstddef>
-#include <cstdlib>
-#include <memory>
-#include <vector>
-
-namespace YAML {
-	
-	template <typename T>
-	class ptr_vector: private YAML::noncopyable
-	{
-	public:
-		ptr_vector() {}
-		~ptr_vector() { clear(); }
-		
-		void clear() {
-			for(unsigned i=0;i<m_data.size();i++)
-				delete m_data[i];
-			m_data.clear();
-		}
-		
-		std::size_t size() const { return m_data.size(); }
-		bool empty() const { return m_data.empty(); }
-		
-		void push_back(std::auto_ptr<T> t) {
-			m_data.push_back(NULL);
-			m_data.back() = t.release();
-		}
-		T& operator[](std::size_t i) { return *m_data[i]; }
-		const T& operator[](std::size_t i) const { return *m_data[i]; }
-		
-		T& back() { return *m_data.back(); }
-		const T& back() const { return *m_data.back(); }
-
-	private:
-		std::vector<T*> m_data;
-	};
-}
-
-#endif // PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/regex.cpp

@@ -1,3 +1,4 @@
+#include "crt.h"
 #include "regex.h"
 
 namespace YAML

src/regex.h

@@ -1,10 +1,8 @@
+#pragma once
+
 #ifndef REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define REGEX_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 <string>
@@ -39,12 +37,12 @@ namespace YAML
 
 		int Match(const std::string& str) const;
 		int Match(const Stream& in) const;
-		template <typename Source> int Match(const Source& source) const;
 
 	private:
 		RegEx(REGEX_OP op);
 		
 		template <typename Source> bool IsValidSource(const Source& source) const;
+		template <typename Source> int Match(const Source& source) const;
 		template <typename Source> int MatchUnchecked(const Source& source) const;
 
 		template <typename Source> int MatchOpEmpty(const Source& source) const;

src/regeximpl.h

@@ -1,10 +1,8 @@
+#pragma once
+
 #ifndef REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define REGEXIMPL_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 "stream.h"
 #include "stringsource.h"
@@ -60,13 +58,7 @@ namespace YAML
 	template<>
 	inline bool RegEx::IsValidSource<StringCharSource>(const StringCharSource&source) const
 	{
-		switch(m_op) {
-			case REGEX_MATCH:
-			case REGEX_RANGE:
-				return source;
-			default:
-				return true;
-		}
+		return source || m_op == REGEX_EMPTY;
 	}
 
 	template <typename Source>

src/scalar.cpp

@@ -0,0 +1,55 @@
+#include "crt.h"
+#include "scalar.h"
+#include "scanner.h"
+#include "token.h"
+#include "exceptions.h"
+#include "node.h"
+#include "emitter.h"
+
+namespace YAML
+{
+	Scalar::Scalar()
+	{
+	}
+
+	Scalar::Scalar(const std::string& data): m_data(data)
+	{
+	}
+
+	Scalar::~Scalar()
+	{
+	}
+
+	Content *Scalar::Clone() const
+	{
+		return new Scalar(m_data);
+	}
+
+	void Scalar::Parse(Scanner *pScanner, const ParserState& /*state*/)
+	{
+		Token& token = pScanner->peek();
+		m_data = token.value;
+		pScanner->pop();
+	}
+
+	void Scalar::Write(Emitter& out) const
+	{
+		out << m_data;
+	}
+
+	int Scalar::Compare(Content *pContent)
+	{
+		return -pContent->Compare(this);
+	}
+
+	int Scalar::Compare(Scalar *pScalar)
+	{
+		if(m_data < pScalar->m_data)
+			return -1;
+		else if(m_data > pScalar->m_data)
+			return 1;
+		else
+			return 0;
+	}
+}
+

src/scalar.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#ifndef SCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define SCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+
+#include "content.h"
+#include <string>
+
+namespace YAML
+{
+	class Scalar: public Content
+	{
+	public:
+		Scalar();
+		Scalar(const std::string& data);
+		virtual ~Scalar();
+
+		virtual Content *Clone() const;
+
+		virtual void Parse(Scanner *pScanner, const ParserState& state);
+		virtual void Write(Emitter& out) const;
+
+		virtual bool IsScalar() const { return true; }
+
+		// extraction
+		virtual bool GetScalar(std::string& scalar) const {
+			scalar = m_data;
+			return true;
+		}
+
+		// ordering
+		virtual int Compare(Content *pContent);
+		virtual int Compare(Scalar *pScalar);
+		virtual int Compare(Sequence *) { return -1; }
+		virtual int Compare(Map *) { return -1; }
+
+	protected:
+		std::string m_data;
+	};
+}
+
+#endif // SCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+

src/scanner.cpp

@@ -1,14 +1,14 @@
+#include "crt.h"
 #include "scanner.h"
 #include "token.h"
-#include "yaml-cpp/exceptions.h"
+#include "exceptions.h"
 #include "exp.h"
 #include <cassert>
-#include <memory>
 
 namespace YAML
 {
 	Scanner::Scanner(std::istream& in)
-		: INPUT(in), m_startedStream(false), m_endedStream(false), m_simpleKeyAllowed(false), m_canBeJSONFlow(false)
+		: INPUT(in), m_startedStream(false), m_endedStream(false), m_simpleKeyAllowed(false)
 	{
 	}
 
@@ -29,8 +29,13 @@ namespace YAML
 	void Scanner::pop()
 	{
 		EnsureTokensInQueue();
-		if(!m_tokens.empty())
+		if(!m_tokens.empty()) {
+			// Saved anchors shouldn't survive popping the document end marker
+			if (m_tokens.front().type == Token::DOC_END) {
+				ClearAnchors();
+			}
 			m_tokens.pop();
+		}
 	}
 
 	// peek
@@ -111,10 +116,10 @@ namespace YAML
 			return ScanDirective();
 
 		// document token
-		if(INPUT.column() == 0 && Exp::DocStart().Matches(INPUT))
+		if(INPUT.column() == 0 && Exp::DocStart.Matches(INPUT))
 			return ScanDocStart();
 
-		if(INPUT.column() == 0 && Exp::DocEnd().Matches(INPUT))
+		if(INPUT.column() == 0 && Exp::DocEnd.Matches(INPUT))
 			return ScanDocEnd();
 
 		// flow start/end/entry
@@ -128,13 +133,13 @@ namespace YAML
 			return ScanFlowEntry();
 
 		// block/map stuff
-		if(Exp::BlockEntry().Matches(INPUT))
+		if(Exp::BlockEntry.Matches(INPUT))
 			return ScanBlockEntry();
 
-		if((InBlockContext() ? Exp::Key() : Exp::KeyInFlow()).Matches(INPUT))
+		if((InBlockContext() ? Exp::Key : Exp::KeyInFlow).Matches(INPUT))
 			return ScanKey();
 
-		if(GetValueRegex().Matches(INPUT))
+		if((InBlockContext() ? Exp::Value : Exp::ValueInFlow).Matches(INPUT))
 			return ScanValue();
 
 		// alias/anchor
@@ -153,7 +158,7 @@ namespace YAML
 			return ScanQuotedScalar();
 
 		// plain scalars
-		if((InBlockContext() ? Exp::PlainScalar() : Exp::PlainScalarInFlow()).Matches(INPUT))
+		if((InBlockContext() ? Exp::PlainScalar : Exp::PlainScalarInFlow).Matches(INPUT))
 			return ScanPlainScalar();
 
 		// don't know what it is!
@@ -166,25 +171,22 @@ namespace YAML
 	{
 		while(1) {
 			// first eat whitespace
-			while(INPUT && IsWhitespaceToBeEaten(INPUT.peek())) {
-				if(InBlockContext() && Exp::Tab().Matches(INPUT))
-					m_simpleKeyAllowed = false;
+			while(INPUT && IsWhitespaceToBeEaten(INPUT.peek()))
 				INPUT.eat(1);
-			}
 
 			// then eat a comment
-			if(Exp::Comment().Matches(INPUT)) {
+			if(Exp::Comment.Matches(INPUT)) {
 				// eat until line break
-				while(INPUT && !Exp::Break().Matches(INPUT))
+				while(INPUT && !Exp::Break.Matches(INPUT))
 					INPUT.eat(1);
 			}
 
 			// if it's NOT a line break, then we're done!
-			if(!Exp::Break().Matches(INPUT))
+			if(!Exp::Break.Matches(INPUT))
 				break;
 
 			// otherwise, let's eat the line break and keep going
-			int n = Exp::Break().Match(INPUT);
+			int n = Exp::Break.Match(INPUT);
 			INPUT.eat(n);
 
 			// oh yeah, and let's get rid of that simple key
@@ -200,43 +202,31 @@ namespace YAML
 	// Misc. helpers
 
 	// IsWhitespaceToBeEaten
-	// . We can eat whitespace if it's a space or tab
-	// . Note: originally tabs in block context couldn't be eaten
-	//         "where a simple key could be allowed
-	//         (i.e., not at the beginning of a line, or following '-', '?', or ':')"
-	//   I think this is wrong, since tabs can be non-content whitespace; it's just
-	//   that they can't contribute to indentation, so once you've seen a tab in a
-	//   line, you can't start a simple key
+	// . We can eat whitespace if:
+	//   1. It's a space
+	//   2. It's a tab, and we're either:
+	//      a. In the flow context
+	//      b. In the block context but not where a simple key could be allowed
+	//         (i.e., not at the beginning of a line, or following '-', '?', or ':')
 	bool Scanner::IsWhitespaceToBeEaten(char ch)
 	{
 		if(ch == ' ')
 			return true;
 
-		if(ch == '\t')
+		if(ch == '\t' && (InFlowContext() || !m_simpleKeyAllowed))
 			return true;
 
 		return false;
 	}
 
-	// GetValueRegex
-	// . Get the appropriate regex to check if it's a value token
-	const RegEx& Scanner::GetValueRegex() const
-	{
-		if(InBlockContext())
-			return Exp::Value();
-		
-		return m_canBeJSONFlow ? Exp::ValueInJSONFlow() : Exp::ValueInFlow();
-	}
-
 	// StartStream
 	// . Set the initial conditions for starting a stream.
 	void Scanner::StartStream()
 	{
 		m_startedStream = true;
 		m_simpleKeyAllowed = true;
-		std::auto_ptr<IndentMarker> pIndent(new IndentMarker(-1, IndentMarker::NONE));
-		m_indentRefs.push_back(pIndent);
-		m_indents.push(&m_indentRefs.back());
+		m_indents.push(IndentMarker(-1, IndentMarker::NONE));
+		m_anchors.clear();
 	}
 
 	// EndStream
@@ -254,23 +244,6 @@ namespace YAML
 		m_endedStream = true;
 	}
 
-	Token *Scanner::PushToken(Token::TYPE type)
-	{
-		m_tokens.push(Token(type, INPUT.mark()));
-		return &m_tokens.back();
-	}
-
-	Token::TYPE Scanner::GetStartTokenFor(IndentMarker::INDENT_TYPE type) const
-	{
-		switch(type) {
-			case IndentMarker::SEQ: return Token::BLOCK_SEQ_START;
-			case IndentMarker::MAP: return Token::BLOCK_MAP_START;
-			case IndentMarker::NONE: assert(false); break;
-		}
-		assert(false);
-		throw std::runtime_error("yaml-cpp: internal error, invalid indent type");
-	}
-
 	// PushIndentTo
 	// . Pushes an indentation onto the stack, and enqueues the
 	//   proper token (sequence start or mapping start).
@@ -281,9 +254,8 @@ namespace YAML
 		if(InFlowContext())
 			return 0;
 		
-		std::auto_ptr<IndentMarker> pIndent(new IndentMarker(column, type));
-		IndentMarker& indent = *pIndent;
-		const IndentMarker& lastIndent = *m_indents.top();
+		IndentMarker indent(column, type);
+		const IndentMarker& lastIndent = m_indents.top();
 
 		// is this actually an indentation?
 		if(indent.column < lastIndent.column)
@@ -292,18 +264,22 @@ namespace YAML
 			return 0;
 
 		// push a start token
-		indent.pStartToken = PushToken(GetStartTokenFor(type));
+		if(type == IndentMarker::SEQ)
+			m_tokens.push(Token(Token::BLOCK_SEQ_START, INPUT.mark()));
+		else if(type == IndentMarker::MAP)
+			m_tokens.push(Token(Token::BLOCK_MAP_START, INPUT.mark()));
+		else
+			assert(false);
+		indent.pStartToken = &m_tokens.back();
 
 		// and then the indent
-		m_indents.push(&indent);
-		m_indentRefs.push_back(pIndent);
-		return &m_indentRefs.back();
+		m_indents.push(indent);
+		return &m_indents.top();
 	}
 
 	// PopIndentToHere
 	// . Pops indentations off the stack until we reach the current indentation level,
 	//   and enqueues the proper token each time.
-	// . Then pops all invalid indentations off.
 	void Scanner::PopIndentToHere()
 	{
 		// are we in flow?
@@ -312,17 +288,14 @@ namespace YAML
 
 		// now pop away
 		while(!m_indents.empty()) {
-			const IndentMarker& indent = *m_indents.top();
+			const IndentMarker& indent = m_indents.top();
 			if(indent.column < INPUT.column())
 				break;
-			if(indent.column == INPUT.column() && !(indent.type == IndentMarker::SEQ && !Exp::BlockEntry().Matches(INPUT)))
+			if(indent.column == INPUT.column() && !(indent.type == IndentMarker::SEQ && !Exp::BlockEntry.Matches(INPUT)))
 				break;
 				
 			PopIndent();
 		}
-		
-		while(!m_indents.empty() && m_indents.top()->status == IndentMarker::INVALID)
-			PopIndent();
 	}
 	
 	// PopAllIndents
@@ -336,7 +309,7 @@ namespace YAML
 
 		// now pop away
 		while(!m_indents.empty()) {
-			const IndentMarker& indent = *m_indents.top();
+			const IndentMarker& indent = m_indents.top();
 			if(indent.type == IndentMarker::NONE)
 				break;
 			
@@ -348,17 +321,17 @@ namespace YAML
 	// . Pops a single indent, pushing the proper token
 	void Scanner::PopIndent()
 	{
-		const IndentMarker& indent = *m_indents.top();
+		IndentMarker indent = m_indents.top();
+		IndentMarker::INDENT_TYPE type = indent.type;
 		m_indents.pop();
-
-		if(indent.status != IndentMarker::VALID) {
+		if(!indent.isValid) {
 			InvalidateSimpleKey();
 			return;
 		}
 		
-		if(indent.type == IndentMarker::SEQ)
+		if(type == IndentMarker::SEQ)
 			m_tokens.push(Token(Token::BLOCK_SEQ_END, INPUT.mark()));
-		else if(indent.type == IndentMarker::MAP)
+		else if(type == IndentMarker::MAP)
 			m_tokens.push(Token(Token::BLOCK_MAP_END, INPUT.mark()));
 	}
 
@@ -367,7 +340,30 @@ namespace YAML
 	{
 		if(m_indents.empty())
 			return 0;
-		return m_indents.top()->column;
+		return m_indents.top().column;
+	}
+
+	// Save
+	// . Saves a pointer to the Node object referenced by a particular anchor
+	//   name.
+	void Scanner::Save(const std::string& anchor, Node* value)
+	{
+		m_anchors[anchor] = value;
+	}
+
+	// Retrieve
+	// . Retrieves a pointer previously saved for an anchor name.
+	// . Throws an exception if the anchor has not been defined.
+	const Node *Scanner::Retrieve(const std::string& anchor) const
+	{
+		typedef std::map<std::string, const Node *> map;
+
+		map::const_iterator itNode = m_anchors.find(anchor);
+
+		if(m_anchors.end() == itNode)
+			ThrowParserException(ErrorMsg::UNKNOWN_ANCHOR);
+
+		return itNode->second;
 	}
 
 	// ThrowParserException
@@ -383,5 +379,9 @@ namespace YAML
 		}
 		throw ParserException(mark, msg);
 	}
-}
 
+	void Scanner::ClearAnchors()
+	{
+		m_anchors.clear();
+	}
+}